Java 3D
INTRODUCTION
Principales fonctionnalités
Paradigme de programmation
Performances
Hiérarchie de classes
Structure d'un programme Java 3D
GRAPHE DE SCÈNE
SceneGraphObjet
Node
Group
Leaf
NodeComponent
PÉRIPHÉRIQUES DE SAISIE
ET
SÉLECTION
CLASSES MATHÉMATIQUES
Vecteurs
Matrices
EXEMPLES
Text3DMotion
HelloUniverse
SphereMotion
PureImmediate
BrasRobot
LES CLASSES
IMPORTANTES
Alpha
Appearance
Behavior
Bounds
BranchGroup
Group
Interpolator
Leaf
Light
Locale
Material
Node
NodeComponent
Primitive
SceneGraphObject
Shape3D
SimpleUniverse
Transform3D
TransformGroup
ViewPlatform
VirtualUniverse
RETOURAPI Java de Sun destinée à l'affichage 3D sous Java.
Java 3D destiné à l'écriture d'applications et d'Applets.
Conçu dans le but de faciliter la programmation.
Justifié par la portabilité de Java qui permet la portabilité des applications Java 3D sur toute plate-forme où Java3D existe (actuellement Solaris et Windows).
Modélisation et affichage 3D de scènes (moteur de rendu: Z-Buffer + ombrage de Gouraud étendu).
Évolutivité par dérivation de classes.
Notion de "Behaviors": Possibilité d'implanter des comportements spécifiques programmés.
Notion d'"Interpolator": Possibilité de "brancher" l'heure du système sur les variables définissant une scène -> animations.
Détection des collisions entre objets.
Sélection d'objets et gestion de périphériques de saisie.
Fonctionnalités de l'informatique graphique classique:
- brouillard
- antialiasing
- ...
Gestion des sons dans un environnement 3D.
Graphe de scène (Scene graph)
Modèle de programmation de Java 3D permettant la représentation et le rendu de scènes.
-> Description complète de la scène (ou univers virtuel).
-> Données géométriques, divers attributs, informations de visualisation.
-> Graphe de scène organisé sous forme arborescente par assemblage d'éléments
(objets) liés par des relations de type père <-> fils (voir
schéma plus loin).
Programmation orientée objet.
-> Graphe de scène construit par assemblage d'éléments graphiques constitués
d'objets Java individuels instanciés à partir de classes Java.
Modèles de rendu
Existence de trois modèles de rendu permettant d'espérer des optimisations conduisant à
l'amélioration de la vitesse d'affichage au prix d'une programmation moins flexible.
Immediate mode
Permet d'utiliser ou non la structure graphe de scène inhérente à l'API Java 3D.
Maximum de flexibilité au prix d'une moins bonne vitesse de rendu.Retained mode
Tous les objets définis dans le graphe de scène accessibles et manipulables (création, destruction, ...) par programme, par sélection, ...
Optimisation de la vitesse de rendu par réalisation automatique d'optimisations par Java3D (opération possible car Java 3D connaît ce que le programmeur a réalisé).Compiled-Retained mode
Meilleures performances de rendu par optimisation poussée, mais perte de la flexibilité de programmation liée aux possibilités d'accès et de modification des objets.
Conservation d'un accès aux objets via les capability flags.
Extensibilité
Possibilité de créer ses propres classes par dérivation de classes existantes.
Programmation simplifiée d'applications gérant concurremment des tâches du type:
- parcours du graphe de scène,
- gestion des changements des variables d'état,
- ...
Support natif de OpenGL, Direct 3D et QuickDraw 3D.
Optimisations.
La hiérarchie de classes Java3D
Le package Java 3D est constitué d'une partie du package javax.media sous le nom javax.media.j3d.
Ses classes sont (non exhaustivement):
- VirtualUniverse
- Locale
- View
- PhysicalBody
- PhysicalEnvironment
- Screen3D
- Canvas3D (hérite de java.awt.Canvas)
- SceneGraphObject
- Node
- Group
- Leaf
- NodeComponent
- Node
- Transform3D
Exemple de structure d'un programme Java 3D
Deux composants superstructures: un objet VirtualUniverse et un objet Locale. Un ensemble de graphes branches dont les racines individuelles sont des objets BranchGroup.
VirtualUniverse: Racine d'un graphe de scène. Une application peut contenir plusieurs "Univers Virtuels".
Locale: Définit l'origine (repère) de tous les graphes branches.
BranchGroup: Nœud racine d'un graphe branche. Les graphes branche prennent en charge les diverses fonctionnalités liées à l'affichage 3D: construction de la scène, définition des paramètres de visualisation, ...
Source correspondant au schéma ci-dessus
/* Copyright (c) 1996-1998
* Sun Microsystems, Inc.
* All Rights Reserved.
*
* Sun grants ("Licensee") a non-exclusive,
* royalty free, license to use, modify
* and redistribute this software in source
* and binary code form, provided that
* i) this copyright notice and license appear
* on all copies of the software; and
* ii) Licensee does not utilize the software
* in a manner which is disparaging to Sun.
*
* This software is provided "AS IS," without
* a warranty of any kind. ALL EXPRESS OR
* IMPLIED CONDITIONS, REPRESENTATIONS
* AND WARRANTIES, INCLUDING ANY IMPLIED
* WARRANTY OF MERCHANTABILITY, FITNESS
* FOR A PARTICULAR PURPOSE OR
* NON-INFRINGEMENT, ARE HEREBY
* EXCLUDED. SUN AND ITS LICENSORS SHALL NOT
* BE LIABLE FOR ANY DAMAGES SUFFERED
* BY LICENSEE AS A RESULT OF USING,
* MODIFYING OR DISTRIBUTING THE SOFTWARE
* OR ITS DERIVATIVES. IN NO EVENT
* WILL SUN OR ITS LICENSORS BE LIABLE
* FOR ANY LOST REVENUE, PROFIT OR DATA,
* OR FOR DIRECT, INDIRECT, SPECIAL,
* CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
* DAMAGES, HOWEVER CAUSED AND REGARDLESS
* OF THE THEORY OF LIABILITY, ARISING
* OUT OF THE USE OF OR INABILITY TO USE
* SOFTWARE, EVEN IF SUN HAS BEEN ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGES.
*
* This software is not designed or intended
* for use in on-line control of aircraft,
* air traffic, aircraft navigation
* or aircraft communications; or in the
* design, construction,
* operation or maintenance of any nuclear
* facility. Licensee represents and warrants
* that it will not use or redistribute
* the Software for such purposes.
*/
import java.applet.Applet;
import java.awt.BorderLayout;
import java.awt.event.*;
import java.awt.GraphicsConfiguration;
import com.sun.j3d.utils.applet.MainFrame;
import com.sun.j3d.utils.geometry.ColorCube;
import com.sun.j3d.utils.universe.*;
import javax.media.j3d.*;
import javax.vecmath.*;
public class Hello extends Applet {
public BranchGroup createSceneGraph() {
// Cree la racine du graphe branche.
BranchGroup objRoot = new BranchGroup();
// Cree le noeud transform group
// et l'initialise a l'identité.
// Autorise le flag TRANSFORM_WRITE
// pour que notre programme behavior
// puisse le modifier.
// l'ajoute a la racine du sous-graphe.
TransformGroup objTrans =
new TransformGroup();
objTrans.setCapability(
TransformGroup.ALLOW_TRANSFORM_WRITE);
objRoot.addChild(objTrans);
// Cree un noeud feuille forme simple,
// et l'ajoute au graphe de scene.
objTrans.addChild(new ColorCube(0.4));
// Cree un nouvel objet Behavior
// qui realisera les operations desirees
// sur l'objet transform specifie
// et l'ajoute dans le graphe de scene.
Transform3D yAxis = new Transform3D();
Alpha rotationAlpha = new Alpha(-1,
Alpha.INCREASING_ENABLE,
0,0,
4000,0,0,
0,0,0);
RotationInterpolator rotator =
new RotationInterpolator(
rotationAlpha,
objTrans,yAxis,
0.0f,
(float) Math.PI*2.0f);
BoundingSphere bounds =
new BoundingSphere(new Point3d(0.0,
0.0,
0.0),
100.0);
rotator.setSchedulingBounds(bounds);
objTrans.addChild(rotator);
// Compilation pour de meilleures
// performances.
objRoot.compile();
return objRoot;
}
public Hello() {
setLayout(new BorderLayout());
GraphicsConfiguration config ;
config = SimpleUniverse
.getPreferredConfiguration();
Canvas3D c = new Canvas3D(config);
add("Center",c);
// Cree une scene simple et l'attache
// a l'univers virtuel.
BranchGroup scene = createSceneGraph();
SimpleUniverse u = new SimpleUniverse(c);
// ceci deplace le ViewPlatform
// un peu en arriere pour que les
// objets de la scene soient visibles.
u.getViewingPlatform()
.setNominalViewingTransform();
u.addBranchGraph(scene);
}
//
// HelloUniverse peut etre utilise comme
// une application ou comme une applet
//
public static void main(String[] args) {
System.out.println("Go") ;
new MainFrame(new Hello(),256,256);
}
}
Résultat à l'exécution (Plugin Java nécessaire)
Container de plus haut niveau pour les graphes de scène.
Contient un ensemble d'objets Locale, chacun d'eux ayant une position "haute-résolution" dans cet univers virtuel définissant ainsi un repère.
Définition des méthodes pour énumérer ses objets Locale et les gérer.
- Constructeurs
- VirtualUniverse()
- Méthodes
- Enumeration getAllLocales()
- static int getJ3DThreadPriority()
- int numLocales()
- void removeAllLocales()
- void removeLocale(Locale locale)
- static void setJ3DThreadPriority(int priority)
Définition d'un environnement utilisateur minimum pour créer facilement un programme Java3D.
Création des objets nécessaires à la gestion de la partie "view" du graphe de scène.
Partie "géométrie" initialisée à vide.
- Champs
- protected Locale locale
- protected Viewer viewer
- protected ViewingPlatform viewingPlatform
- Constructeurs
- SimpleUniverse()
- SimpleUniverse(Canvas3D canvas)
- SimpleUniverse(HiResCoord origin, int numTransforms, Canvas3D canvas, URL userConfig)
- SimpleUniverse(ViewingPlatform viewingPlatform, Viewer viewer)
- Méthodes
- void addBranchGraph(BranchGroup bg)
- Canvas3D getCanvas()
- Canvas3D getCanvas(int canvasNum)
- Locale getLocale()
- GraphicsConfiguration getPreferredConfiguration()
- Viewer getViewer()
- ViewingPlatform getViewingPlatform()
Définit d'une position en haute-résolution dans un VirtualUniverse. Container pour un ensemble de sous-graphes enracinés en cette position.
Objets dans un objet Locale définis en utilisant des coordonnées double-précision relativement à l'origine de cet objet (définition du système de coordonnées du monde virtuel pour cet objet Locale).
Méthodes set et get nécessaires à la configuration des coordonnées haute-résolution.
Méthodes pour ajouter, retirer et énumérer les graphes branches contenus.
- Constructeurs
- Locale(VirtualUniverse universe)
- Locale(VirtualUniverse universe, HiResCoord hiRes)
- Locale(VirtualUniverse universe, int[] x, int[] y, int[] z)
- Méthodes
- void addBranchGraph(BranchGroup branchGroup)
- protected void finalize()
- Enumeration getAllBranchGraphs()
- void getHiRes(HiResCoord hiRes)
- VirtualUniverse getVirtualUniverse()
- int numBranchGraphs()
- SceneGraphPath[] pickAll(PickShape pickShape)
- SceneGraphPath[] pickAllSorted(PickShape pickShape)
- SceneGraphPath pickAny(PickShape pickShape)
- SceneGraphPath pickClosest(PickShape pickShape)
- void removeBranchGraph(BranchGroup branchGroup)
- void replaceBranchGraph(BranchGroup oldGroup, BranchGroup newGroup)
- void setHiRes(HiResCoord hiRes)
- void setHiRes(int[] x, int[] y, int[] z)
Constitués de nœuds organisés en arbre au moyen de relations père <-> fils.
Constituants: Super-classe SceneGraphObject dérivée vers Node, elle-même dérivée en deux sous-classes:
- Group: 1 ou plusieurs nœuds fils (ou même 0), un seul nœud parent.
- Leaf: 0 nœuds fils, un seul nœud parent. Définition de:
- formes géométriques,
- lumières,
- brouillard,
- sons,
- ...
Important: Graphe de scène parcouru sans notion d'ordre
de parcours horizontal.
-> Nœuds fils d'un nœud parcourus par la fonction de rendu de Java 3D dans un
ordre arbitraire voire même en parallèle..
Héritage: Un nœud fils hérite de l'ensemble des
paramètres d'état de son père. S'il possède un frère, un nœud n'hérite pas de
ses paramètres d'état (une seule exception, les nœuds lumière et brouillard).
-> Héritage vertical (de la racine vers le nœud) et non horizontal.
Les nœuds
Construits par instanciation de la classe souhaitée.
Accédés via les méthodes get et set existantes et autorisées (pour permettre des optimisations à l'exécution).
La super-classe SceneGraphObject
- Méthodes
- void clearCapability(int bit)
- boolean getCapability(int bit)
- Object getUserData()
- boolean isCompiled()
- boolean isLive()
- void setCapability(int bit)
- void setUserData(Object userData)
Deux classes dérivées de SceneGraphObject:
Node: Classe abstraite pour les nœuds de structuration d'un graphe de scène et les nœuds feuilles d'un tel graphe.
NodeComponent: Classe abstraite pour les nœuds définissant certaines composantes des graphes de scène.
- Champs
- static int ALLOW_AUTO_COMPUTE_BOUNDS_READ
- static int ALLOW_AUTO_COMPUTE_BOUNDS_WRITE
- static int ALLOW_BOUNDS_READ
- static int ALLOW_BOUNDS_WRITE
- static int ALLOW_COLLIDABLE_READ
- static int ALLOW_COLLIDABLE_WRITE
- static int ALLOW_LOCAL_TO_VWORLD_READ
- static int ALLOW_PICKABLE_READ
- static int ALLOW_PICKABLE_WRITE
- static int ENABLE_COLLISION_REPORTING
- static int ENABLE_PICK_REPORTING
- Méthodes
- Node cloneNode(boolean forceDuplicate)
- Node cloneTree()
- Node cloneTree(boolean forceDuplicate)
- Node cloneTree(boolean forceDuplicate, boolean allowDanglingReference)
- Node cloneTree(NodeReferenceTable referenceTable)
- Node cloneTree(NodeReferenceTable referenceTable, boolean forceDuplicate)
- Node cloneTree(NodeReferenceTable referenceTable, boolean forceDuplicate, boolean allowDanglingReferences)
- void duplicateNode(Node originalNode, boolean forceDuplicate)
- Bounds getBounds()
- boolean getBoundsAutoCompute()
- boolean getCollidable()
- void getLocalToVworld(SceneGraphPath path, Transform3D t)
- void getLocalToVworld(Transform3D t)
- Node getParent()
- boolean getPickable()
- void setBounds(Bounds bounds)
- void setBoundsAutoCompute(boolean autoCompute)
- void setCollidable(boolean collidable)
- void setPickable(boolean pickable)
Classe Node dérivée en deux classes:
Classe pour l'instanciation de nœuds permettant de grouper d'autres nœuds. Support des relations père<->fils.
Un seul nœud parent et un nombre arbitraire de nœuds fils Group ou non rendus dans un ordre non spécifié ("en parallèle").
Fils Null autorisés.
Méthodes pour l'ajout, la suppression et l'énumération des fils.
- Champs
- static int ALLOW_CHILDREN_EXTEND
- static int ALLOW_CHILDREN_READ
- static int ALLOW_CHILDREN_WRITE
- static int ALLOW_COLLISION_BOUNDS_READ
- static int ALLOW_COLLISION_BOUNDS_WRITE
- Méthodes
- void addChild(Node child)
- Node cloneNode(boolean forceDuplicate)
- Enumeration getAllChildren()
- boolean getAlternateCollisionTarget()
- Node getChild(int index)
- Bounds getCollisionBounds()
- void insertChild(Node child, int index)
- void moveTo(BranchGroup branchGroup)
- int numChildren()
- void removeChild(int index)
- void setChild(Node child, int index)
- void setCollisionBounds(Bounds bounds)
Toutes les autres classes nœud de groupe héritent de Group:
- BranchGroup: Pointeur sur la racine d'une branche d'un graphe de scène. Insertion possible seulement dans l'ensemble des racines associé à un objet Locale.
- OrderedGroup: Les fils sont parcourus dans l'ordre de définition.
- SharedGroup: Nœud destiné à être partagé par plusieurs nœuds feuille Link -> Un même graphe peut être référencé plusieurs fois au sein d'un même graphe de scène.
- Switch: Permet de contrôler celui des nœuds fils qui devra être traité lors de la phase de rendu. Contrôle effectué à partir d'une valeur pouvant indiquer un seul nœud ou bien plusieurs si elle est utilisée comme bitfield.
- TransformGroup: Un nœud Group qui contient une transformation de classe Transform3D appliquée à chacun de ses fils avant son traitement.
Jamais de fils.
Représentation des lumières, nœuds géométriques et sons.
Réalisation de liaisons et instanciation pour le partage de graphes de scène.
Apport d'une plate-forme de visualisation pour placer et orienter une vue.
Toutes les classes feuille héritent de Leaf:
- AlternateAppearance: Non décrit ici.
- Background: La classe feuille Background définit soit une couleur de fond unie, soit une image de fond utilisée pour remplir la fenêtre de dessin au début de chaque image.
- Behavior: Behavior est une classe abstraite qui contient les bases pour tous les composants de type Behavior en Java 3D.
- BoundingLeaf: La classe BoundingLeaf définit un objet région englobante pouvant être référencé par d'autres nœuds (région d'influence, région d'activation, scheduling region).
- Clip: La classe feuille Clip définit les distances de clipping avant et arrière dans l'univers virtuel.
- Fog: La classe feuille abstraite Fog définit un ensemble de
paramètres commun à tous les types de brouillard. Ces paramètres incluent la couleur du
brouillard et une région d'influence dans laquelle le nœud brouillard est actif.
Sous-classes: ExponentialFog, LinearFog. - Light: La classe feuille
abstraite Light définit un ensemble de paramètres commun à tous les types de lumières.
Ces paramètres incluent la couleur de la lumière, un drapeau d'activation, et une
région d'influence dans laquelle la lumière est active.
Sous-classes:- AmbientLight,
- DirectionalLight,
- PointLight,
- SpotLight.
- Link: La classe feuille Link autorise une application à référencer un graphe partagé (dont la racine est un nœud SharedGroup). Un nombre arbitraire de nœuds Link peuvent référencer le même nœud SharedGroup.
- ModelClip: La classe feuille ModelClip définit un ensemble de 6 plans de clipping arbitraires dans l'univers virtuel.
- Morph: Non décrit ici.
- Shape3D: La classe feuille Shape3D définit tous les objets géométriques.
- Sound: La classe feuille abstraite Sound définit les propriétés
communes à toutes les sources sonores.
Sous-classes:- BackgroundSound,
- PointSound,
- ConeSound.
- Soundscape: La classe feuille Soundscape définit les attributs qui caractérisent l'environnement de l'"écouteur".
- ViewPlatform: La classe feuille ViewPlatform contrôle la position, l'orientation et le zoom de l'observateur.
La classe NodeComponent est la super-classe commune à certains objets composant de graphe de scène:
- Alpha: Calcul automatique d'une valeur à partir de l'heure du système.
- Appearance: Caractéristique visuelle pour les objets Shape3D.
- AuralAttributes: Non renseigné.
- ColoringAttributes: Non renseigné.
- DepthComponent: Non renseigné.
- Geometry: Caractéristique géométrique pour les objet Shape3D.
- ImageComponent: Non renseigné.
- LineAttributes: Caractéristique visuelle pour les objets Shape3D.
- Material: Caractéristique visuelle (matériau) pour les objets Shape3D.
- MediaContainer: Non renseigné.
- PointAttributes: Caractéristique visuelle pour les objets points.
- PolygonAttributes: Caractéristique visuelle pour les objets polygones.
- RenderingAttributes: Caractéristique visuelle pour tout type d'objet.
- TexCoordGeneration: Non renseigné.
- Texture: Configuration de texture pour les objets.
- TextureAttributes: Non renseigné.
- TextureUnitState: Non renseigné.
- TransparencyAttributes: Caractéristique visuelle (transparence) pour tout type d'objet..
Les nœuds behaviors et interpolator
Rôle:
- Animation d'objets.
- Gestion des événements clavier et souris.
- Réaction à des mouvements.
- Autorisation et gestion des événements de sélection.
- ...
Contenu:
- Code Java.
- Variables d'état.
Rôle du code Java:
- Interagir avec des objets Java.
- Changer les valeurs de nœuds dans un graphe de scène
- Changer les valeurs internes du behavior.
- Réaliser tout calcul nécessaire.
Le nœud feuille Behavior
Une scheduling region définissant le volume servant à l'activation de la
gestion du Behavior.
Un nœud Behavior est actif tant que le volume d'activation d'une ViewPlatform coupe
sa scheduling region.
- Constructeurs
- Behavior()
- Méthodes
- boolean getEnable()
- BoundingLeaf getSchedulingBoundingLeaf()
- Bounds getSchedulingBounds()
- protected View getView()
- abstract void initialize()
- void postId(int postId)
- abstract void processStimulus(Enumeration criteria)
- void setEnable(boolean state)
- void setSchedulingBoundingLeaf(BoundingLeaf region)
- void setSchedulingBounds(Bounds region)
- void updateNodeReferences( NodeReferenceTable referenceTable)
- protected void wakeupOn(WakeupCondition criteria)
- Alpha getAlpha()
Deux méthodes abstraites initialize et processStimulus.
initialize: Initialisation de l'état interne du Behavior et spécification de ses conditions initiales de réveil.
processStimulus: Réception et traitement d'un message d'activation. Méthode exécutée si le nœud est actif et si tous les critères de réveil sont vérifiés.
Les classes filles de Behavior
- Billboard: Le nœud behavior Billboard agit sur un nœud TransformGroup pour orienter l'axe local +z du TransformGroup vers la position de l'œil de l'observateur.
- Interpolator: Voir plus loin
- KeyNavigatorBehavior: Non décrit ici.
- LOD (Level Of Detail): Classe abstraite utilisant une liste de
nœud groupe Switch pour sélectionner un des fils des ces nœuds.
Classe fille: DistanceLOD (Choix d'un fils en fonction de la distance) - MouseBehavior: Classe abstraite pour tous les manipulateurs à la
souris.
Classes filles: MouseRotate, MouseTranslate, MouseZoom. - PickMouseBehavior: Classe abstraite qui autorise les programmeurs à
ajouter des fonctionnalités de sélection à un graphe de scène.
Classes filles: PickRotateBehavior, PickTranslateBehavior, PickZoomBehavior.
Interpolator classe fille abstraite de Behavior.
Interpolation lisse entre deux valeurs extrêmes.
Interpolation basée sur le temps de la machine hôte au moyen d'une instance de la classe Alpha.
- Constructeurs
- Interpolator()
- Interpolator(Alpha alpha)
- Méthodes
- Alpha getAlpha()
- void initialize()
- void setAlpha(Alpha alpha)
- Champs
- protected WakeupCriterion
Conversion automatique d'une valeur temporelle en une valeur comprise
entre 0 et 1.
5 périodes de temps définissable pour l'Alpha de manière cyclique ou non sur les quatre
dernières:
- Délai initial (Alpha = 0)
- Alpha croissant
- Alpha à 1
- Alpha décroissant
- Alpha à 0
- loopCount: Nombre d'exécution de cet objet Alpha. -1 indique qu'il boucle indéfiniment.
- triggerTime: Temps en milli-secondes compté à partir du lancement du système à partir duquel cet objet sera activé pour la première fois.
- phaseDelayDuration: Nombre de milli-secondes attendues après le moment de déclenchement avant de démarrer cet Alpha.
- mode: Peut être défini à INCREASING_ENABLE, DECREASING_ENABLE, ou à la valeur ou des deux. INCREASING_ENABLE active les paramètres Alpha croissants listés ci-dessous; DECREASING_ENABLE active les paramètres Alpha décroissants listés ci-dessous.
Paramètres croissants Alpha:
- increasingAlphaDuration: Période de temps durant laquelle Alpha varie de 0 à 1.
- increasingAlphaRampDuration: Non décrit ici.
- alphaAtOneDuration: Période de temps durant laquelle l'Alpha reste à 0.
Paramètres décroissants Alpha:
- decreasingAlphaDuration: Période de temps durant laquelle Alpha varie de 1 à 0.
- decreasingAlphaRampDuration: Non décrit ici.
- alphaAtZeroDuration: Période de temps durant laquelle l'Alpha reste à 0.
Sous-classes de Interpolator
- ColorInterpolator: Interpolation entre deux couleurs pour un objet Material.
- KBSplinePathInterpolator: Non décrit ici.
- PathInterpolator: Non décrit ici.
- PositionInterpolator: Interpolation entre deux positions pour la composante de rotation d'un objet TransformGroup.
- RotationInterpolator: Interpolation entre deux valeurs d'angle pour la composante de rotation d'un objet TransformGroup.
- ScaleInterpolator: Interpolation entre deux valeurs de mise à l'échelle pour la composante de mise à l'échelle uniforme d'un objet TransformGroup.
- SwitchValueInterpolator: Interpolation entre deux valeurs d'index pour un objet Switch.
- TCBSplinePathInterpolator: Non décrit ici.
- TransparencyInterpolator: Interpolation entre deux valeurs de transparence pour un objet TransparencyAttributes.
Les périphériques de saisie et la sélection
Utilisation de l'API Java standard pour gérer le clavier et la souris.
Implantation possible de la gestion de périphériques de type tracker à 6 degrés de liberté (position et orientation) et joysticks.
Utilisation de l'interface InputDevice et de la classe Sensor.
Gestion des sons dans un environnement 3D.
Modèle de visualisation puissant mais complexe non décrit ici totalement.
Environnement minimum nécessaire à Java 3D
Utilisation d'un objet Canvas3D comme zone de dessin pour l'application ou l'applet.
Création d'un objet View pour définir tous les paramètres nécessaires au rendu d'une scène depuis un point de vue arbitraire.
Création des éléments du graphe de scène suivants:
- Un objet VirtualUniverse.
- Un objet haute-résolution Locale.
- Un objet BranchGroup.
- Un objet nœud TransformGroup avec sa transformation associée.
- Un objet nœud feuille ViewPlateform qui définit la position et l'orientation pour la génération des images de l'univers virtuel.
Classes mathématiques pour l'Infographie
Définies dans le package java.vecmath.
Stockage des valeurs caractéristiques des objets.
Implantation des fonctions membres pour les opérations mathématiques classiques sur ces objets de l'Infographie.
Utilisées directement ou de préférence par leurs classes dérivées.
- Tuple2f: Coordonnées flottantes simple précision dans un
espace 2D.
Sous-classes: Point2f, TexCoord2f, Vector2f. - Tuple3b: Coordonnées entières sur un octet signé dans un
espace 3D.
Sous-classe: Color3b. - Tuple3d: Coordonnées flottantes double précision dans un
espace 3D.
Sous-classes: Point3d, Vector3d. - Tuple3f: Coordonnées flottantes simple précision dans un
espace 3D.
Sous-classes: Color3f, Point3f, TexCoord3f, Vector3f. - Tuple4b: Coordonnées entières sur un octet signé dans un
espace 4D.
Sous-classe: Color4b. - Tuple4d: Coordonnées flottantes double précision dans un
espace 4D.
Sous-classes: Point4d, Quat4d, Vector4d. - Tuple4f: Coordonnées flottantes simple précision dans un
espace 4D.
Sous-classes: Color4f, Point4f, Quat4f, Vector4f. - AxisAngle4d: Coordonnées flottantes double précision représentant les valeurs d'une rotation d'un angle a en radian autour d'un axe (x, y, z) dans un espace 3D.
- AxisAngle4f: Coordonnées flottantes simple précision représentant les valeurs d'une rotation d'un angle a en radian autour d'un axe (x, y, z) dans un espace 3D.
- GVector: Vecteur de dimension arbitraire pour stocker des valeurs double précision.
Convention de notation W = M.V.
- Matrix3f: Matrice 3x3 de réels simple précision.
- Matrix3d: Matrice 3x3 de réels double précision.
- Matrix4f: Matrice 4x4 de réels simple précision.
- Matrix4d: Matrice 4x4 de réels double précision.
- GMatrix: Matrice arbitraire MxN (M lignes, N colonnes) de réels double précision.
- Alpha
- Appearance
- Behavior
- Bounds
- BranchGroup
- Group
- Interpolator
- Leaf
- Light
- Locale
- Material
- Node
- NodeComponent
- Primitive
- SceneGraphObject
- Shape3D
- SimpleUniverse
- Transform3D
- TransformGroup
- ViewPlatform
- VirtualUniverse
- Exemple 0: Text3DMotion
- Exemple 1: HelloUniverse
- Exemple 2: SphereMotion
- Exemple 3: PureImmediate
- Exemple 4: Hello2
- Exemple 5: FourByFour
- Exemple 6: BrasRobot
- Exemple 7: Simple
- Exemple 8: SimplePrimitive
- Exemple 9: SimpleMaterial
- Exemple 10: SimpleLight
- Exemple 11: SimpleTexture
- Exemple 12: SimpleBackground
- Exemple 12Bis: SimpleBackground2
- Exemple 13: SimpleAnimation
- Exemple 14: SimpleDoubleBuffer
- Exemple 15: SimpleTransparency
- Exemple 16: SimpleText2D
- Exemple 16Bis: SimpleText3D
- Exemple 17: SimpleClip
- Exemple 18: SimpleAWTJava3D
- Exemple 19: SimpleOrthoPersp
- Exemple 20: SimpleCollision
- Exemple 21: SimpleMouse
- Exemple 22: SimplePicking
- Exemple 23: SimpleSound
- Exemple 24: SimpleFog
- Exemple 25: SimpleSwitch
- Exemple 26: SimpleLOD
- Exemple 27: SimpleRaster
- Exemple 28: SimplePolyLines