GALAXIE

Collection Interactive de Planètes

Projet Galaxie


Combiner art et numérique

Comprendre le projet

Ce projet est une approche pour tenter d’unir l’informatique et l’art numérique.
Ces domaines d’innovations où les règles sont mouvantes et les limites chaque jour repoussées, offre un champ d’action des plus stimulant. Sous le thème de la collection, cette ébauche laisse l’imagination du spectateur naviguer dans une galaxie, c’est-à-dire un choix de planètes imaginaires, avec lesquelles le public pourra interagir. L’interaction induit le ludique qui permet une appropriation plus immédiate d’un large public.

Partir en exploration dans une Galaxie

Choisissez votre étoile et approchez-vous d’elle pour comprendre ses mécanismes et ses mystères. Avec de la chance, vous trouverez surement l’unique étoile qui illumine tout l’Univers…

À l’aide d’un socle de polystyrène taillé, d’une surface de projection, et du matériel informatique disposé à cette expérience, nous avons ainsi conçu un portail numérique et interactif d’animations représentant les différentes planètes de cette galaxie lointaine.

Collaboration

Le développement avec le service internet GitHub, et l’aide de gestion de version sur dépôts Git, permettent un travail compréhensible, collaboratif et librement partageable. Ces avantages sont considérables dans la mesure où d’une part le code source du projet peut être amélioré, et d’autre part les bogues sont plus simplement corrigeables.
La mutualisation de la source permet à tous les acteurs du projet de suivre en temps réel la progression du code, ainsi qu’un partage de contenu, valeur première d’Internet.

Ouverture

Les possibilités sont infinies ! Néanmoins une excellente et intéressante optimisation pourrait être l’aspect génératif, dans le sens où chaque planète acquerrait des caractéristiques générée en temps réel. Certains artistes utilisent beaucoup la génération comme support de leur travail, tel que Miguel Chevalier.


Production

Problématiques

Au cours du développement du projet, quelques difficultés ont été rencontrées. Notamment :

Structures

Eléments

galaxieApp

Classe principale, elle définit et recense les fonctions essentielles et structurante. On y retrouve les fonctions de réception de message, et les variables de configurations.
Pour d’avantages de variables paramètres, référez-vous à gConstants.h.

class galaxieApp {

	// Fonctions & Meéthodes
	void setup();
	void setupI();
	void update();
	void draw();
	void keyPressed(int key);
	void keyReleased(int key);
	void mouseMoved(int x, int y);
	void mouseDragged(int x, int y, int button);
	void mousePressed(int x, int y, int button);
	void mouseReleased(int x, int y, int button);
	void windowResized(int w, int h);
	void dragEvent(ofDragInfo dragInfo);
	void gotMessage(ofMessage msg);
	void onNewMessage(string & byteReceived);

	// Variables
	float CENTER_X, CENTER_Y;
	int planetState;
	bool gInitialized;
	string byteReceived;
	int sendedByte;
}
gInitZone

Classe d’initialisation de l’application, elle permet de positionner le centre de la planète / zone.

class gInitZone {

	// Fonctions & Méthodes
	gInitZone();
	void update(int xM, int yM);
	void draw();
	void mouseMoved(int x, int y);
	void mousePressed(int x, int y, int button);

	// Variables
	float x, y;
	bool isFixed;
};
gPlanet

Classe importante, cette dernière gère toutes les interactions, les animations et l’appel de configuration lors de l’affichage des planètes.

class gPlanet {

	// Fonction Friend
	friend void selectPlanet();

	// Fonctions & Méthodes
	gPlanet();
	friend void selectPlanet();
	void update(int newStep);
	void draw();
	void sceneWillAppear(ofxScene * fromScreen);
	void interaction(int variationD);
	void mouseMoved(int x, int y);
	void onNewMessage(string & byteReceived);
	void sceneDidDisappear(ofxScene * fromScreen);
	float timeTrigo(string function, float multi = 1, int piTimes = 0);

	// Variables
	int thisPlanet;
	// Variables privées
	int proximity; // Captor sensor interpretation
	int step;
};
gTransition

Classe de transition, elle complète et lie chaque chargement de planète. Elle permet la sélection de la planète à appeler.

class gTransition {

	// Fonctions & Méthodes
	gTransition();
	void update();
	void draw();
	void mousePressed(int x, int y, int button);
	void sceneWillAppear(ofxScene * fromScreen);
	void sceneDidDisappear(ofxScene * fromScreen);
	void selectPlanet(gPlanet * toSelect);

	// Variables
	int configStep;
	int result;
	// Variables privées
	int selection[3];
};

Détails d’une fonction

1 void galaxieApp::onNewMessage(std::string & byteReceived) {
2 	stateGalaxie->onNewMessage(byteReceived);
3 	sendedByte = ofToInt(byteReceived);
4 	cout << sendedByte << "\n";
5 }

Dans cette fonction, l’application réceptionne le message serial transmis par Arduino. Il correspond à la distance calculée. Lors d'un nouveau message, la fonction galaxieApp::onNewMessage(...) est donc appelée.

stateGalaxie->onNewMessage(byteReceived);

Ici, nous globalisons cette fonction, pour permettre à l'application d'interagir aux nouveaux messages quelque que soit son état.

sendedByte = ofToInt(byteReceived);

Le message transmis est de type std::string. Par la fonction ofToInt(...) la chaine de caractères est transposée en nombre entier int.

cout << sendedByte << "\n";

Enfin, le chiffre intercepté est affiché dans la fenêtre d’invite aux commandes. Cela permet de déboguer, mais aussi de voir et comprendre les variations de distances.


Développement

Environnement

Pour débuter le développement du projet, commençons par décrire la méthode à suivre. Préparez en premier l’environnement numérique de travail.

openFrameworks

Logiciels requis

Installation

Il existe déjà un tutorial illustré sur l’installation d’openFrameworks le site officiel. Il est en anglais, mais relativement facile à suivre grâce à ses nombreuses captures d’écran.

  1. Allez sur le site de Visual Studio 2012.
  2. Téléchargez Visual Studio 2012 Express for Windows Desktop.
  3. Installez ce logiciel.

Vous avez terminé de configurer Visual Studio 2012. Il faut maintenant installer les bibliothèques et exemples d’openFrameworks.

  1. Allez dans l’espace « download » d’openFrameworks, et téléchargez le fichier « windows visual studio ».
  2. Décompressez ce dossier et placez-le quelque part dans « Mes Documents » ou n’importe quel autre endroit où vous stockez vos fichiers.

Passons ensuite au Modules openFrameworks.

  1. Ouvrez le fichier addons.make.
  2. Dirigez-vous sur ofxaddons.com, et téléchargez chaque « addon » référencé dans addons.make.
  3. Décompressez chaque téléchargement dans le dossier addons du répertoire d’openFrameworks.

Terminez l’installation en téléchargeant Galaxie, et en décompressant l’archive dans le dossier apps/myApps du répertoire d’openFrameworks.

Arduino

Matériel requis

Croquis

  1. Télécharger l’IDE d’Arduino
  2. Connecter la carte et installer les drivers
  3. Lancer l’application Arduino
  4. Ouvrir le croquis lié au projet

Construction

La conjstruction du projet Galaxie se déroulle en quelques étapes simples :

Dans le cas d’une utilisation d’Arduino, une configuration spatiale spécifique est requise. Editez le projet pour que l'application soit cohérente avec son environnement.


À propos

Sites officiels

Ressources

Licences

Ce projet est dans son ensemble distribué sous licence MIT.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Néanmoins, certains composants contiennent leurs propres licences, en particulier openFrameworks et extensions.

Notes de Version

Principe

Par transparence, les versions suivent un cycle défini comme le conseille Semantic Versioning.
Cela permet une plus grande clarté dans les nouvelles versions, qui sont donc numérotées par <majeure>.<mineure>.<patch>, et plus strictement à partir de la version 1.0.0.

1.0.0

0.5.0