Get the Mytodolist Free Android app from SlideME.

lundi 22 avril 2013

2/ Créer vos scènes 3D avec les noeuds et géométries .


                    Dans ce tutoriel, nous allons jeter un coup d'oeil à la création d'une scène 3D, cela suppose que vous savez ce que sait que le graphe de scène.




Lors de la création d'un jeu en 3D:
  • Vous créez des objets de la scène comme les joueurs, les bâtiments, etc
  • Vous pouvez ajouter des objets à la scène.
  • Vous déplacer, redimensionner, faire pivoter, la couleur, et de les animer.

               Vous comprendrez dans ce tutoriel que le graphe de scène représente le monde de la 3D, et pourquoi un rootNode (c'est a dire le noeud racine) est important. Vous allez apprendre

  •  à créer des objets simples
  • comment les faire transporter des données personnalisées (telles que des points de santé communément appelée vie ),
  •  et comment les «transformer» en les déplaçant (translation), en faisant la mise à l'échelle et la rotation. 
           Vous saurez aussi la différence entre les deux types d'espaces dans le graphe de scène: Nœuds et Géométries.


Exemple de code

package jme3test.helloworld;
 
import com.jme3.app.SimpleApplication;
import com.jme3.material.Material;
import com.jme3.math.Vector3f;
import com.jme3.scene.Geometry;
import com.jme3.scene.shape.Box;
import com.jme3.math.ColorRGBA;
import com.jme3.scene.Node;
 
/ ** Exemple 2 - Comment utiliser les nœuds de poignées pour manipuler des objets dans la scène.
  * Vous pouvez faire pivoter, translater et modifier l'échelle des objets en manipulant leurs nœuds parents.
  * Le nœud racine est spéciale: Seul ce qui est attaché au nœud racine apparaît dans la scène. * /
 
public class HelloNode extends SimpleApplication {
 
    public static void main(String[] args){
        HelloNode app = new HelloNode();
        app.start();
    }
 
    @Override
    public void simpleInitApp() {
 
        /** créé une boite bleu de cordonnées (1,-1,1) */
        Box box1 = new Box( Vector3f.ZERO, 1,1,1);
        Geometry blue = new Geometry("Box", box1);
        Material mat1 = new Material(assetManager, 
                "Common/MatDefs/Misc/Unshaded.j3md");
        mat1.setColor("Color", ColorRGBA.Blue);
        blue.setMaterial(mat1);
        blue.move(1,-1,1);
 
        /** créer une boîte rouge juste au-dessus du bleu au (1,3,1) */
        Box box2 = new Box( Vector3f.ZERO, 1,1,1);
        Geometry red = new Geometry("Box", box2);
        Material mat2 = new Material(assetManager, 
                "Common/MatDefs/Misc/Unshaded.j3md");
        mat2.setColor("Color", ColorRGBA.Red);
        red.setMaterial(mat2);
        red.move(1,3,1);
 
        /** Crée un noeud pivot à (0,0,0) et lattacher au noeud racine */
        Node pivot = new Node("pivot");
        rootNode.attachChild(pivot); // mettre ce noeud dans la scène
 
        /** Joindre les deux cases vers le noeud * pivot **/
        pivot.attachChild(blue);
        pivot.attachChild(red);
    /** Tourner le noeud pivot: Notez que les deux boîtes ont tourné! */
        pivot.rotate(.4f,.4f,0f);
    }
}

Exécutez l'exemple de code. Vous devriez voir deux cases colorées inclinés sous le même angle.




Image JMonkeyEngine, Bonjour noeud


Comprendre la terminologie


Dans ce tutoriel, vous apprendrez quelques nouveaux termes:



Que voulez vous faireComment le dire à JMonkeyEngine
Étalez la scène 3DRemplissez le graphe de scène
Créé les objets de scèneCréé des espaces (exemple: créé les géométries)
Faire apparaître un objet dans la scèneJoindre l'espace au noeud racine
Faire disparaître un objet dans la scèneDétacher l'espace du noeud racine
Positionner / déplacer, tourner ou redimensionner un objetTranslater, ou faire pivoter ou redimensionner un objet = transformer un objet.




Chaque application JME3 a un nœud racine: Votre jeu hérite automatiquement de la classe RootNode (nœud racine), objet de SimpleApplication.Tout ce qui est fixé à la rootNode fait partie du graphe de scène. Les éléments du graphe de scène sont des espaces.


  • Un espace contient la position, la rotation et l'échelle d'un objet.
  • Un espace peut être chargé, transformé, et sauvegarder.
  • Il existe deux types d'espaces: les nœuds et géométries.

GeometrieNoeud
Visibilité:Une géométrie est un objet visible dans une scèneUn nœud est une "manche" invisible pour les objets de la scène.
But:Une géométrie sauvegarde l'apparence de l'objetLes groupes de nœuds de géométries et d'autres noeuds entre eux.
Exemples:Une boîte, une sphère, un joueur, un bâtiment, un morceau de terrain, un véhicule, des missiles, des PNJ, etc ...Le nœud racine, un nœud de-chaussée regroupant plusieurs terrains, un véhicule-avec-passagers comme noeud personnalisé, un noeud de joueur avec l'arme, un nœud audio, etc ...




Comprendre le code


Qu'est-ce qui se passe dans l'extrait du code? Vous utilisez la méthode de simpleInitApp () qui a été introduit dans le premier tutoriel pour initialiser la scène.



1/ Vous créez votre premier cube.

  • Créer une forme ou boite (la forme est cubique) de longueur (1,1,1) pour chaque côté soit de 2x2x2 unités de valeur réelle.
  • Déplacez la forme sur (1, -1,1) en utilisant la méthode move (). (Ne pas modifier Vector3f.ZERO sauf si vous voulez changer le centre de rotation)
  • Enveloppez la forme du cube par une géométrie.
  • Créer un matériel bleu.
  • Appliquer le matériel bleu à la forme Géométrique.
( j'espère que j'ai parlé un bon français ( ^_^;)


Box box1 = new Box( Vector3f.ZERO, 1,1,1);
Geometry blue = new Geometry("Box", box1);
Material mat1 = new Material(assetManager,
"Common/MatDefs/Misc/Unshaded.j3md");
mat1.setColor("Color", ColorRGBA.Blue);
blue.setMaterial(mat1);
blue.move(1,-1,1);

2/ Vous créez un second cube.

  • Créer une deuxième boîte de la même taille que le premier.
  • Placez la boîte à la position (1,3,1). C'est juste au-dessus de la première boîte, avec un écart de 2 unités comme valeur réelle entre les deux.
  • Enveloppez la boîte par une géométrie.
  • Créer un matériel rouge.
  • Appliquer le matériel rouge sur la boite Géométrique.
 Box box2 = new Box( Vector3f.ZERO, 1,1,1);
    Geometry red = new Geometry("Box", box2);
    Material mat2 = new Material(assetManager,
      "Common/MatDefs/Misc/Unshaded.j3md");
    mat2.setColor("Color", ColorRGBA.Red);
    red.setMaterial(mat2);
    red.move(1,3,1);


3/ Vous créez un nœud de pivot.

  • Nommez le Noeud "pivot".
  • Par défaut, le nœud est positionné à (0,0,0).
  • Fixez le nœud au noeud racine ou rootNode.
  • Le Noeud n'a aucune apparence visible dans la scène.
Node pivot = new Node("pivot");
    rootNode.attachChild(pivot);

Si vous exécutez l'application avec seulement le code jusque-là, la scène semble vide. C'est parce qu'un nœud est invisible, et vous n'avez pas encore fixé les géométries visibles au noeud racine.



4/ Fixez les deux boîtes au nœud pivot.

  pivot.attachChild(blue);
        pivot.attachChild(red);

Si vous exécutez l'application avec seulement le code jusqu'à ici, vous voyez deux cubes: un cube rouge juste au-dessus d'un cube bleu comme ceux la.






5/ Tourner le nœud de pivot.
        pivot.rotate( 0.4f , 0.4f , 0.0f );

Si vous exécutez l'application maintenant, vous voyez deux boîtes les unes sur les autres - à la fois inclinés au même angle.

Qu'est-ce qu'un nœud de Pivot?


Vous pouvez transformer (par exemple, tourner) les géométries autour de leur propre centre, ou autour d'un point central défini par l'utilisateur. Un utilisateur définie un point central d'une ou plusieurs géométries qui est appelé un pivot.

         Dans cet exemple, vous avez regroupé deux géométries en les rattachant à un nœud de pivot. Vous utilisez le nœud de pivot comme une poignée pour faire tourner les deux géométries ensemble autour d'un centre commun. En tournant, le nœud pivot fait tourner tous les géométries jointes en une seule étape. Le noeud de pivotement est au centre de la rotation. Avant de fixer les autres géométries, assurez-vous que le nœud pivot soit à (0,0,0).


          Il est courant de faire une transformation sur un noeud parent pour transformer tous les espaces enfants attachées. Vous allez utiliser cette méthode dans beaucoup de vos jeux lorsque vous déplacez les espaces autour.

Exemples

  • Un véhicule et son conducteur se déplacent ensemble, 
  • une planète avec sa lune tourne autour du soleil. 
               Contrastez ce cas avec l'autre option: Si vous ne créez pas un nœud pivot supplémentaire pour transformer une géométrie, chaque transformation se fera alors par rapport à l'origine de la géométrie (généralement le centre).

 Exemples: Si vous faites pivoter chaque cube directement (en utilisant red.rotate (0.1f, 0.2F, 0.3f) et blue.rotate (0.5f, 0.0f, 0,25 F);), chaque cube tournera individuellement autour de son centre . Ceci est similaire à une planète tournant autour de lui même.


Comment puis-je remplir la Graphe scénique?



Tâche…?Solution!
Créé un espaceCréer une forme de maille, l'envelopper dans une géométrie, et de lui donner un matériel. Par exemple:
Box mesh = new Box(Vector3f.ZERO, 1, 1, 1); // a cuboid default mesh
Geometry thing = new Geometry("thing", mesh); 
Material mat = new Material(assetManager,
   "Common/MatDefs/Misc/ShowNormals.j3md");
thing.setMaterial(mat);
Faire apparaître un objet dans une scèneFixez le espace au nœud racine, ou à n'importe quel nœud qui est attaché au nœud racine.
rootNode.attachChild(thing);
Supprimer l'objet de la scèneDétachez le territoire à partir du nœud racine, et à partir de n'importe quel nœud qui est attaché au nœud racine.
rootNode.detachChild(thing);
rootNode.detachAllChildren();
Trouvez un espace dans la scène par le nom de l'objet, ou ID, ou par sa position dans la hiérarchie parent-enfant.Regardez les enfants ou parent du nœud:
Spatial thing = rootNode.getChild("thing");
Spatial twentyThird = rootNode.getChild(22);
Spatial parent = myNode.getParent();
Indiquez ce qui doit être chargé au débutTout ce que  vous initialisez et joignez à la méthode rootNode dans le simpleInitApp () fait partie de la scène au début de la partie.

Comment transformer un espace ?

Il existe trois types de transformation 3D: la translation, mise à l'échelle et la rotation.


La translation déplace les espacesaxe Xaxe Yaxe Z
Indique le nouvel emplacement dans un repère à trois dimensions:
A quelle distance est-il de l'origine? aller en haut à droite ou vers l'avant?
Pour déplacer un espace à des coordonnées spécifiques, tels que (0,40.2 f, -2), utilisez 

chose.setLocalTranslation( new Vector3f( 0.0f, 40.2f, -2.0f ) );
Pour déplacer un espace d'une certaine distance, par exemple plus haut (y = 40.2f) et plus loin (z =-2.0f):
chose.move( 0.0f, 40.2f, -2.0f );
+droit -gauche+haut -bas+loin -près
Une translation redimensionne l'espaceaxe Xaxe Yaxe Z
Indique le facteur de translation dans chaque dimension: longueur, hauteur, largeur.
 Une valeur comprise entre 0.0f et 1.0f rétrécit l'espace; plus grand que 1.0f l'étire; 1.0f maintient le même.
 En utilisant la même valeur pour chacune des dimensions proportionnellement 
 translatées, les valeurs différentes l'étirent. Pour allonger un espace 10 fois plus, on ajoute un dixième de la hauteur et on garde la même largeur:

thing.scale( 10.0f, 0.1f, 1.0f );
longueurhauteurlargeur
La rotation fait tournée l'espaceaxe Xaxe YZ-axis
Rotation 3-D est un peu délicate. En bref: Vous pouvez faire pivoter autour de trois axes:
 hauteur , écart et rouleau. Vous pouvez spécifier les angles en degrés en multipliant
 la valeur des dégrés avec FastMath.DEG_TO_RAD. Pour restaurer un objet à 180 ° autour de l'axe z:

thing.rotate( 0f , 0f , 180*FastMath.DEG_TO_RAD );
Astuce: Si votre idée de jeu nécessite une grande quantité de rotations, il est intéressant d'utiliser quaternions, une structure de données qui peuvent 

se combiner et stocker des rotations efficacement.
thing.setLocalRotation( 
  new Quaternion().fromAngleAxis(180*FastMath.DEG_TO_RAD, 

new Vector3f(1,0,0)));
hauteur= hochant la têteécart=secoue
la tête
rouleau=armement
tête


Comment résoudre les problèmes d'espace?

              Si vous obtenez des résultats inattendus, vérifiez si vous avez fait des erreurs suivantes :



Problème?Solution!
La géométrie créé n'apparait pasL'Avez-vous joint (un noeud qui est attaché )  au nœud racine?
 At-il un matériel?
Quelle est sa translation (position)?
Est-il derrière la caméra ou couvert par une autre géométrie?
 Est elle petite ou trop gigantesque pour être vur?
 Est-il trop loin de la camera?
L'espace fait une rotation inattendue.Avez-vous utilisé les valeurs en dégré au lieu de radian?
(Si vous avez utilisé les degrés, multipliez-les avec FastMath.DEG_TO_RAD
pour les convertir en radians) Avez-vous créé l'espace à l'origine (Vector.ZERO)
 avant de le déplacer?
 Avez-vous fait une rotation autour du nœud pivot par défaut
ou autour de quelque chose d'autre?
 Avez-vous fait une rotation autour de l'axe de droite?
La géométrie a une couleur ou matériel inattendueAvez-vous réutiliser un matériel d'une autre géométrie et avez par mégarde
changé ses propriétés? (Si oui, envisagez de le cloner: mat2 = mat.clone ();)






Comment ajouter des données personnalisées aux espaces?


          Beaucoup d'espaces représentent les personnages de jeu ou d'autres entités avec lequel le joueur pourrait interagir. Le code ci-dessus qui fait tourner les deux caissons autour d'un centre commun (pivot) pourrait être utilisée pour un engin spatial attelés à une station orbitale, par exemple.

            En fonction de votre jeu, les entités de jeu ne changent pas seulement leur position, la rotation ou l'échelle ( bref les transformations que vous venez d'apprendre). Les entités de jeu ont également des propriétés personnalisées, telles que la santé, l'inventaire effectué, équipement porté pour un personnage, ou résistance de la coque et le carburant restant pour un engin spatial. 

           En Java, vous pouvez représentez les données d'entité en tant que variable de classe, par exemple, flotteurs, chaînes ou des tableaux.

                 Vous pouvez ajouter des données personnalisées directement sur n'importe quel nœud ou la géométrie. Vous n'avez pas besoin d'étendre la classe Node et d'inclure des variables! Par exemple, pour ajouter un numéro d'identification personnalisée à un nœud, vous devez utiliser:


pivot.setUserData( "pivot id", 42 );

          Pour lire le numéro d'identification de ce noeud ailleurs, vous pouvez utiliser:


int id = pivot.getUserData( "pivot id" ); 



               En utilisant différentes clés de chaînes de caractères (ici la clé est pivot id), vous pouvez obtenir et définir plusieurs valeurs pour toutes les données que les espaces ont besoins d'utiliser. Lorsque vous commencez à écrire votre jeu, vous pouvez ajouter une valeur de carburant à un noeud de voiture, la valeur de la vitesse à un noeud d'avion, ou le nombre de pièces d'or à un noeud de joueur, et bien plus encore. Cependant, il faut noter que seuls les objets personnalisés qui implémentent Savable peuvent être transmises.


Conclusion:

           Vous avez appris que votre scène 3D est un graphe de scènes composée d'espaces : Géométriques qui sont visibles et nœuds qui sont invisibles . Vous pouvez transformer les espaces, ou les attacher aux noeuds et transformer les nœuds. Vous connaissez la meilleur façon d'ajouter des propriétés d'entités personnalisées (telles que la santé du joueur ou de la vitesse du véhicule) aux espaces.

Puisque les formes standard comme des sphères et des boîtes vieillissent vite, continuons avec le chapitre suivant où vous apprendrez à charger des actifs tels que les modèles 3-D.




---

<<Précédent                          Sommaire                                     Suivant>>




1 commentaire: