Samedi 30 décembre 2006
Moteur à particules
 
I.Définition d'un moteur à particules.

    Dans une conception graphique, certains effets sont impossibles a réaliser avec un traçage classique tel qu'avec le dragon. Les effets de pluie, de feu, de fumée nécessitent que l'on fasse appel à un moteur à particules. Les moteurs à particules permettent de générer un grand nombre de points qui appartiennent tous à des objets différents mais qui sont tous identiques. Par exemple, dans un effet de pluie, on peut définir la forme d'une goutte, et ensuite générer un moteur qui fait tomber un grand nombre de particules ayant chacune la forme de cette goutte. On crée les particules de façon uniformément repartie sur une surface d'origine, en leur affectant une trajectoire vers le sol. Ce procédé est une méthode très puissante et qui permet de réaliser des animations très réalistes, mais, qui est aussi très lourde en calculs.

 
II.Paramétrage d'une particule.

    Les animations plus complexes utilisent plus de coefficients de paramétrage pour les mouvements. Les principaux paramètres permettant de régler les comportements des particules sont:

-Le nombre total des particules qui interviendront dans l'animation. Ce paramètre est très important car un nombre trop grand de particules intervenantes dans un temps trop court sera impossible à gérer même pour les processeurs les plus puissants.

-La durée de vie des particules. Pour la même raison qu'au dessus, si la durée de vie est trop longue, le nombre de particules ne cessera d'augmenter jusqu'au plantage du système.

-La force s'exerçant sur chaque particule. Ainsi, on crée une accélération et on donne un mouvement au point (x = 0.5*a(t-t0)²+v(t-t0)+x0).

-La direction initiale de la particule. Avec la force précédente, les particules partent toutes exactement dans la même direction, les faire partir dans des directions différentes et aléatoires permet de donner des effets plus naturels.

-L'association à un objet. On peut simuler un grand nombre d'animations en associant des objets à des particules, telles que la chute des feuilles d'un arbre, du feu, du mouvement de cheveux,....

 
 
III.Exemple avec le moteur à particules de Blender.



    Le but est de paramétrer le moteur à particules pour donner un effet de feu. On commence par créer un ensemble de points qui sera l'origine des particules. On défini le nombre de particules à 50 et on règle la durée de génération sur 5 secondes.



On défini une force qui s?exercent vers le haut pour créer un mouvement d'accélération constante.





On fait partir les particules en les projetant dans un intervalle restreint de façon aléatoire.




Enfin on défini le graphisme de chaque particule, pour cela on crée une texture de type marbrée, en associant la partie sombre de la texture à une couleur ayant un coefficient alpha de 0 (donc transparente), et la partie visible à une couleur jaune de type halo de lumière.



Léo
Par Leo - Publié dans : leo666
Ecrire un commentaire - Voir les 0 commentaires - Recommander
Samedi 16 décembre 2006
Analyse : assemblage de graphismes

 



 
            Ce programme a pour but de voir comment différents objets graphiques peuvent cohabiter entre eux, et comment les organiser de façon harmonieuse pour qu'ils puissent former un début de monde.
 





I. Description des fichiers du programme
Le programme comprend les fichiers suivants :

>>      Main.cpp : fichier principal du programme, il introduit l'ensemble des fichiers et gère le brouillard ainsi que les interfaces utilisateur (souris, clavier, et l'affichage des objets)

>>       Main.h : fichier de déclaration des variables globales du programme (objets, booléens clavier, coordonnées souris).

>>      Window.h : classe contenant les attributs d'une fenêtre utile dans le cas d'un affichage en fenêtres multiples.

>>      RessourceArbre.h, RessourceDragon.h, RessourceTerrain.h : matrices des points et des faces appartenant aux objets graphiques.

>>      Camera.h : classe gérant la totalité des mouvements de la caméra via son interface et les actions utilisateurs (pression d'une touche, mouvements de la souris, ...).

>>      Texture.h : classe permettant de stoker une texture dans un objet pour ensuite en donner un pointeur à l'affichage des différents objets du programme.

>>      Dragon.h, Terrain.h, Arbre.h : classes contenant les paramètres des objets (position dans l'espace, numéro de l'animation) et leur affichage à l'écran.

Après ce résumé, une explication de la partie sur la caméra, de ce programme très simple, est peut-etre bienvenue.

 
II. Gestion du mouvement de la caméra

Les mouvements de la caméra sont déclenchés lors de la pression des flèches, qui activent les booléen déclarés dans main.h. Imaginons un plan horizontal suivant un repère Oxz, et un sous-repère Ox1z1 orienté de façon quelconque dans Oxz, donc selon un angle ALPHA par rapport aux axes de celui-ci. Il suffit d'appliquer des formules de trigo pour avoir les déplacements élémentaires dans le plan horizontal :
Nouvelle_position =
Ancienne_position+Grandeur_pas *Relation_trigo_ALPHA

 
III.Gestion du regard

Les mouvements du regard de la camera sont déclenchés dans la fonction de passivité du programme, quand la valeur des angles de vue changent. Soit un repère Ox1y1z1, dont l'origine correspond au point d'origine du regard. OpengGL fournit la fonction gluLookAt(ox, oy, oz, vx, vy, vz, hx, hy, hz) où « o » sont les coordonnées du point d'origine du  regard, « v » sont les coordonnées du point regardé, et « h » correspond à la dimension représentant la hauteur. Pour pouvoir orienter la camera dans une direction spécifique, on défini deux angles : ALPHA dont la définition est la même que précédemment, BETA correspond à l'angle de vision verticale définit entre 0 et PI. Ainsi, par l'association des relations trigonométriques entre les deux angles, et d'une distance ov fixé à 1, le domaine des valeurs, prises par le point regardé, forme une sphère de centre « o », position de la camera (origine du repère relatif) et de rayon 1. Pour avoir les coordonnées du point regardé dans le repère absolu, il suffit d'ajouter les coordonnées de la caméra dans ce repère et les coordonnées du point regardé dans le repère relatif défini dans cette partie.

 
IV. Evolutions à prévoir

Ce programme est incomplet, à l'exécution on s'aperçoit qu'il manque une chose, le déplacement de la camera ne suit pas le relief du terrain, libre à vous de proposer une solution (dans les commentaires de cet article). On peut aussi prévoir de créer un comportement pour le dragon (par exemple, le dragon peut détecter le mouvement de la camera et la suivre comme un bon chien).


Par Leo - Publié dans : leo666
Ecrire un commentaire - Voir les 1 commentaires - Recommander
Jeudi 7 décembre 2006
Images de mes réalisations
 

    Le développement informatique est un moyen pour l’esprit, de créer des architectures de taille et de complexité quasi illimité. Par l’association de programmes qui s’appuient les uns sur les autres, le résultat fini par « ressembler à quelque chose de correcte ». Pour illustrer cette idée, voici un aperçu de quelques-uns de mes programmes réalisés jusqu'à présent.

 


    L’un de mes premiers programmes OpenGL consistait à afficher un personnage dessiné grâce au logiciel Blender. Aucun lien direct n’existe entre ce logiciel et OpenGL, la transition a été réalisée par un programme de conversion de fichier de ma fabrication, qui permettait de récupérer l’ensemble des points pour les insérer dans des matrices exploitables. Par la suite, ce programme a évolué pour inclure des liens entre les points pour pouvoir créer des faces pouvant être texturées. Les images suivantes sont un terrain avec les points reliés entre eux.

 




   Par la suite, ce programme a encore évolué pour prendre en compte les animations des dessins. Grâce à cette méthode, vous pouvez voir le dragon battre des ailles (code et exécutable sur cppfrance.com présent dans mes liens).

 








    Enfin, j’ai pu commencer l’association de plusieurs objets entre eux, avec évolution de l’utilisateur sur le terrain précédent, avec une vue à la première personne et un effet de brouillard (code bientôt disponible).
 





    A l'avenir, je pense réaliser des objets regroupant tout les attributs des mouvements, des animations, et des comportements pour créer des objets indépendants qui, en étant associé entre eux, pourront interagir les uns sur les autres comme dans des simulations mécaniques ou organiques, comme par exemple, dans « le jeu de la vie » (voir dans mes liens).

Par Leo - Publié dans : leo666
Ecrire un commentaire - Voir les 0 commentaires - Recommander

Calendrier

Juillet 2009
L M M J V S D
    1 2 3 4 5
6 7 8 9 10 11 12
13 14 15 16 17 18 19
20 21 22 23 24 25 26
27 28 29 30 31    
<< < > >>
Créer un blog sur over-blog.com - Contact - C.G.U. - Rémunération en droits d'auteur - Signaler un abus