bg150.jpg (723 octets)

Java 3D

INTRODUCTION
Principales fonctionnalités
Paradigme de programmation
Performances
Hiérarchie de classes
Structure d'un programme Java 3D

VIRTUALUNIVERSE

LOCALE

GRAPHE DE SCÈNE
SceneGraphObjet
Node
Group

Leaf
NodeComponent

BEHAVIORS

INTERPOLATEURS
Alpha

MODÈLE DE VISUALISATION

PÉRIPHÉRIQUES DE SAISIE ET
SÉLECTION

PÉRIPHÉRIQUES AUDIO

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

INSTALLATION
DE JAVA3D

 

WB01624_.gif (281 octets) RETOUR

Introduction

API 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).

Principales fonctionnalités

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.

Paradigme de programmation

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.

Hautes performances

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
  • Transform3D

Exemple de structure d'un programme Java 3D

Schéma d'un graphe de scène

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);
  }
}
                         

Fichier source : Hello.java

Résultat à l'exécution (Plugin Java nécessaire)

VirtualUniverse

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.

La classe VirtualUniverse

  • Constructeurs
    • VirtualUniverse()
  • Méthodes
    • Enumeration getAllLocales()
    • static int getJ3DThreadPriority()
    • int numLocales()
    • void removeAllLocales()
    • void removeLocale(Locale locale)
    • static void setJ3DThreadPriority(int priority)

La classe SimpleUniverse

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()

Locale

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.

La classe Locale

  • 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)

Les graphes de scène

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.

La classe Node

  • 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:

  • Group: Pour les nœuds de structuration d'un graphe de scène.
  • Leaf: Pour les nœuds feuilles.

La classe Group

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.

Classe de base: Group

  • 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.

Les nœuds feuille

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.

Classe de base: Leaf

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

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

Behaviors

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.

La classe Behavior

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.

Interpolators

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

La classe Interpolator

La classe Alpha

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

Paramètres:

  • 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.

Les périphériques audio

Gestion des sons dans un environnement 3D.

Le modèle de visualisation

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.

Les classes vecteur

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.

Les classes matrice

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.

Les classes importantes

Exemples