Premiers pas avec OpenFrameworks (français)

OPENFRAMEWORKS est un bundle de fonctions C++ , pour le “Creative Coding & Prototyping”… C’est à dire une compilation de différentes fonctions utiles à la création visuelle par programmation dans le langage C++. Il est encore en phase de dévellopement, et la dernière version à ce jour est la v0.06.
Un wiki pour plus d’informations.

Il est une continuité de processing dans le sens ou il utilise le même type de fonction et vocabulaire mais est toutefois déconseillé comme première approche au langage de programmation.

made with openFrameworks from openFrameworks on Vimeo.

Il n’y a pas de IDE proprement dit pour OPENFRAMEWORKS car ce n’est pas un langage en soi. XCode est une solution pour utilisateurs mac.

// INSTALLEZ OPENFRAMEWORKS

Ceci n’étant pas vraiment un tutoriel parce que contenant des erreurs et incomplet dans les fondement du C++, il est plutôt un carnet de bord pour l’approche de ce langage de programmation et témoigne de mes premiers pas dans ce framework.

Téléchargez OPENFRAMEWORKS,
Version FAT (avec les addons et les exemples)

Vous recevez un .zip que vous décompresserez dans un endroit voulu.
ex: “Users/Documents/…”
L’image ci dessous (et le contenu de votre dossier) est votre dossier de travail et votre librairie pour OPENFRAMEWORKS.

A l’intérieur se trouvent ces dossiers:

> Addons:
Dossier de fonctions supplémentaires…

> Apps:
Le dossier de vos applications,
c’est ici que seront sauvés vos sketches sous forme de projets XCode. Il contient aussi les exemples qui vous permettrons de commencer.

> Lib:

Les librairies. Elles permettent d’alléger l’application dans le sens ou on ne fait appel à elles seulement quand on en a besoin. Vous noterez parmis d’autres, à l’intérieur de ce dossier “libs“, un dossier nommé “openFrameworks” et un fichier “ofMain.h“. Ce sont les documents de base pour utiliser OPENFRAMEWORKS.

>Other:
Librairie Tierce, pour controller une Arduino board.

Ne changez pas la hiérarchie de ces dossiers.

// LE DOSSIER D’UN PROJET

Comment s’organisent les fichiers d’un projet?

Chaque Dossier de projets est organisé comme suit:
nom_du_projet/
.        Bin/ data/
.        openFrameworks-info.plist
.        openFrameworks.xcodeproj
.        src/
.        .       main.cpp
.        .       testApp.cpp
.        .       testApp.h

Ces noms de fichiers ne sont pas changeable au premier abords, mis à part le dossier parent “nom_du_projet“. Changer ces noms de fichiers sans en connaitre les tenant et aboutissants vous expose à de nombreuses erreurs lors de la compilation du programme, il est donc conseillé de les laisser tel quel dans un premier temps.

Le dossier “src/” contient votre partie du programme, votre création. Au minimum, il devra contenir ces trois fichiers.

// COPIEZ ET OUVREZ LE PROJET XCODE

Comment s’organise mon projet?

Apparement, Xcode ne permet pas d’”enregistrer sous” afin de changer le nom de projet (plus justement le nom du dossier parent). Donc, pour un nouveau projet OPENFRAMEWORKS, dupliquez le dossier “nom_du_projet/” et changez son nom.

Lors ce qu’un projet openframeworks.xcodeproj est ouvert dans Xcode, les librairies liées au projet sont sur la gauche et les documents lié à la librairie sur la droite.

A l’intérieur du projet openframeworks, nous retouvons quelques dossiers familiers; Ce sont les documents liés au projets:

openFramework.app/
openFrameworks-info.plist
src/
openFrameworks/
libs/

“openFrameworks.app/” est le résultat de notre compilation, mais notre projet n’a pas encore été complilé, il est donc normal qu’il soit affiché en rouge.

“openFrameworks-info.plist” notre fichier de préférences.

“libs/ et openFrameworks/” sont des liens vers la bibliotheque OPENFRAMEWORKS… et vous permettent d’en utiliser les fonctionnalités.

“src/” est le dossier de notre programme.

// LES 3 FICHIERS
main.cpp, test_App.h, testApp.cpp

le dossier “src/” et les fichiers de mon programme.

Dans un premier temps, tout se passe avec l’ensemble des trois fichiers main.cpp, testApp.h testApp.cpp.

Toujours dans XCode, sélectionez le dossier src/ dans la fenêtre de gauche. L’affichage devrait ressembler à l’image ci-dessous

Nous retrouvons nos trois documents main.cpp , testApp,cpp, testApp.h sur la fenêtre de droite.

• main.cpp:
Fichier principal du projet, il n’est pour autant pas le plus rempli: La balise #include indique quel(s) fichiers sont à charger lors de la compilation… le compilateur “charge*” donc 3 fichiers d’en-tête (”header” indiqué par la terimaison .h) dont deux font partie de OPENFRAMEWORKS (facilement recconaissable par le préfixe of)
Il “charge*” aussi l’entête de notre programme: TestApp.h

*charger l’entête: la manoeuvre de compliation c++ est à vrai dire plus compliquée mais ceci est une introduction.

#include "ofMain.h"
#include "testApp.h"
#include "ofAppGlutWindow.h"

int main( )

main() est la fonction principale du programme.
En somme, le programme va s’éxécuter entre ces crochets “{ }”:

{
      //1> Un objet ofAppGlutWindow est appelé sous la référence "window"
      ofAppGlutWindow window;

      // 2> Un contexte OpenGL est crée,
      // les 2 et 3èmes paramêtres sont la largueur et la hauteur
      // OF_WINDOW peut être changé en OF_FULLSCREEN pour du plein écran.
      ofSetupOpenGL(&window, 1024,768, OF_WINDOW);

      //3> La fonction ofRunApp() s'éxécute
      //avec notre classe testApp comme paramêtre.
      //Ne changez pas ce paramêtre
      ofRunApp( new testApp());

• testApp.h:
Initialise les references et variables float, int, bool, char….

#ifndef _TEST_APP // Ces deux instructions, commençant par "#", et la dernière, #endif sont indissociables 
#define _TEST_APP // Ceci permet de n'incure qu'une seule fois ce fichier d'en-tête dans un fichier

#include "ofMain.h"
// TestApp (notre application) est une sous-classe de ofBaseApp
class testApp : public ofBaseApp{
        //Initialisation d'une reference utilisée dans le programme
        float counter;
};
#endif

• testApp.cpp :
Descriptions de fonctions, dans ce fichier vient s’inscrire la déclaration de fonctions utilisées dans notre programme:

#include "testApp.h"
//--------------------------------------------------------------
void testApp::setup(){
        counter =0.0;
        // fond noir
	ofBackground(0, 0, 0);
	//synchronisation vericale de l'ecran
	ofSetVerticalSync(true);
	// FPS ( débit d'images par secondes
	ofSetFrameRate(60);
}
//--------------------------------------------------------------
void testApp::update(){
        //n'affiche rien
        //calcule les fonctions d'affichage pour le mise à jour de l'affichage
        //EX: ajoute 0.29 au compteur.
	counter = counter + 0.029f;
}
//--------------------------------------------------------------
void testApp::draw(){
        // Cette fonction dessine les choses dans la fenêtre de l'application.
        // il est préférable de ne pas mettre de calcul d'images ici mais juste l'affichage,
        // les calculs peuvent être mis dans update().
        // EX: affiche un cercle bleu de 100p de diamêtre
        // 10px de la gauche, 15px du haut
         ofSetColor(0, 0, 255);
	 ofCircle(10, 10, 100);
}

//LA COMPILATION

“Dans le plus simple des mondes et dans un cas ou les erreurs n’existent pas” , quand on compile l’ensemble des fichiers de codes du projet, les fichiers sont traduits en langage machine, et votre application est rendue; il ne reste plus qu’à la tester…

A vrai dire, c’est un peu plus compliqué que ça: Tout d’abord, un interprêteur va mettre tout les fichiers bout à bout, en suivant les instructions des balises #include , #define et #ifndef pour ne former qu’un seul et (plus ou moins) gros fichier. Une fois ce fichier crée, les comandes sont décortiquées en plus petites commandes (plus élémentaires) par un assembleur pour devenir du langage machine… vous obtenez votre application dans le dossier de votre projet (suivant les préférences).

Il se peut que la première compilation de votre programme prenne du temps, mais une fois fait, seul les document changés seront recompilés, et ce processus, tellement chargé de suspense, ne sera plus qu’un clignement d’œil.