Les extensions JavaTM

Activation
Les différentes sources lumineuses
Combinaison des sources lumineuses
Les classes d'éclairage

Après avoir appris comment créer des objets 3D et modifier leurs attributs d'apparence, ce chapitre présente comment appliquer un éclairage à une scène 3D, pour lui donner une touche plus réaliste.

Activation

Il suffit d'ajouter n'importe où dans l'arbre d'une scène 3D une instance de la classe Light pour activer l'éclairage de cette scène. La couleur des objets sous éclairage dépend de leurs attributs d'apparence. Les attributs de classe Material permettent d'obtenir un ne sont pas obligatoires pour que Java 3D puissent déterminer la couleur des différentes formes d'une scène 3D mais il est conseillé de les utiliser pour un rendu plus réaliste de vos objets.
Le tableau suivant vous indique quelle sera la couleur d'une forme 3D en fonction de l'attribut d'apparence dominant (voir aussi le tableau de choix des couleurs qui permet de déterminer l'attribut dominant) :

Attribut d'apparence de la forme 3D	Couleur de la forme 3D sous éclairage
Material	Combinaison des couleurs de Material et des couleurs des différentes sources lumineuses
ColoringAttributes	Couleur de l'instance de ColoringAttributes. Même effet avec ou sans éclairage.
Couleurs des sommets	Couleurs des sommets. Même effet avec ou sans éclairage.

Les différentes sources lumineuses

Effets des sources lumineuses

Java 3D définit les quatre classes de sources lumineuses suivantes :

Classe	Effet
AmbientLight			Source lumineuse ambiante Cette lumière est utilisée pour éclairer un minimum les zones d'une scène 3D ne recevant aucune lumière des autres types de sources lumineuses. La couleur d'ambiance (couleur ambiantColor de la classe Material) des formes 3D réfléchit cette lumière de manière uniforme.
DirectionalLight			Source lumineuse unidirectionnelle Cette lumière rayonne dans une direction unique dir. Ceci correspond à une approximation d'une source lumineuse ponctuelle située à une distance très éloignée, comme le soleil éclairant une scène. Les couleurs de diffusion et de spécularité (couleurs diffuseColor et specularColor de la classe Material) des formes 3D réfléchissent cette lumière en fonction de l'orientation de chacune des facettes par rapport à la direction de la lumière. Toutes les facettes qui ne sont pas orientée vers la source lumineuse ne sont pas éclairées.
PointLight			Source lumineuse ponctuelle Comme pour une ampoule, cette lumière rayonne à partir d'un point pos de l'espace dans toutes les directions. De plus, son intensité diminue à fur et à mesure que l'on séloigne de ce type de source lumineuse. Les couleurs de diffusion et de spécularité (couleurs diffuseColor et specularColor de la classe Material) des formes 3D réfléchissent cette lumière en fonction de l'orientation de chacune des facettes.
SpotLight			Spot Comme une source lumineuse ponctuelle, cette lumière rayonne à partir d'un point pos de l'espace mais les directions des rayons sont conscrits dans un cône d'angle alpha et d'axe dir. Les couleurs de diffusion et de spécularité (couleurs diffuseColor et specularColor de la classe Material) des formes 3D réfléchissent cette lumière en fonction de l'orientation de chacune des facettes.

Voici l'applet LightEffect dérivant de la classe Applet3D : cet exemple permet de tester sur une sphère les différents types d'éclairage décrits ci-dessus, grâce au paramètre LightClass. Ce paramètre doit prendre pour valeur le nom d'une des classes de source lumineuse. Pour une utilisation avec la commande java, la valeur du paramètre est passée de la manière suivante :
java LightEffect LightClass=SpotLight

import javax.media.j3d.*;
import javax.vecmath.*;
import com.sun.j3d.utils.applet.MainFrame;
import com.sun.j3d.utils.geometry.*;
 
public class LightEffect extends Applet3D
{
  public BranchGroup createSceneTree ()
  {
    // Racine de l'arbre des objets représentés dans la scène 3D
    BranchGroup root = new BranchGroup ();

    // Création d'une source lumineuse en fonction du paramètre LightClass 
    // Par exemple : <PARAM NAME="LightClass" VALUE="AmbientLight"> pour une applet
    //               ou LightClass=AmbientLight en paramètre de la commande java
    Light light = null;
    Color3f lightColor = new Color3f (1, 1, 0.5f); // jaune clair 
    if ("AmbientLight".equals (getParameter ("LightClass")))
      // Création d'une source lumineuse d'ambiance
      light = new AmbientLight (lightColor);    
    else if (   "DirectionalLight".equals (getParameter ("LightClass")) 
        || getParameter ("LightClass") == null)
      // Création d'une source lumineuse unidirectionnelle (utilisée par défaut)
      light = new DirectionalLight (lightColor,
                                    new Vector3f (1, -1, -1)); // direction    
    else if ("PointLight".equals (getParameter ("LightClass")))
      // Création d'une source lumineuse ponctuelle
      light = new PointLight (lightColor,
                              new Point3f (-1, 1, 1),   // position
                              new Point3f (1f, 0, 0));  // atténuation
    else if ("SpotLight".equals (getParameter ("LightClass")))
      // Création d'une lumière spot
      light = new SpotLight (lightColor,
                             new Point3f (-1, 1, 1),      // position
                             new Point3f (1f, 0, 0),      // atténuation
                             new Vector3f (1f, -1, -1),   // direction
                             (float)Math.PI / 4,          // angle
                             92);                         // concentration
 
    // Changement de ces limites d'influence    
    light.setInfluencingBounds (new BoundingSphere (new Point3d (), 10.0));
    // Ajout de la lumière à l'arbre de la scène
    root.addChild (light);
      
    // Création d'un fond gris foncé  
    Background background = new Background (0.2f, 0.2f, 0.2f);
    background.setApplicationBounds (new BoundingBox ());
    root.addChild (background);
      
    // Ajout d'un objet
    root.addChild (createScene ());
    return root;
  }
    
  public Node createScene ()
  {  
    return new Sphere (0.7f);
  }
   
  // Méthode main () pour permettre d'utiliser cette classe 
  // comme applet ou comme application
  public static void main (String [] args) 
  {
    new MainFrame (new LightEffect (), args, 80, 85);
  }  
}

Figure 18. Arbre de la scène LightEffect

Le symbole est utilisé pour les feuilles représentant des sources lumineuses dans l'arbre d'une scène 3D.
Comme le fait la classe LitPlane, vous pouvez tester les effets des différentes sources lumineuses sur des objets d'une autre forme, en outrepassant la méthode createScene () dans une classe dérivée de LightEffect.

Les sources lumineuses permettent d'éclairer une scène mais n'ont pas de représentation physique à l'écran. En cas de besoin, c'est à vous d'ajouter à votre scène une forme 3D supplémentaire représentant la source lumineuse (par exemple une sphère est utilisée pour le soleil dans l'applet SunEarthMoonMotion).

Couleur des facettes éclairées

La couleur finale de chaque facette d'une forme 3D est le résultat de la combinaison des effets des lumières décrits ci-dessus et des couleurs de l'attribut d'apparence de classe Material de cette forme :

	couleur emissiveColor
+	couleurs de toutes les sources lumineuses ambiantes réfléchies par la couleur ambiantColor
+	couleurs de toutes les autre sources lumineuses réfléchies par les couleurs diffuseColor et specularColor
=	couleur de la facette

Chacune des composantes Rouge, Vert, Bleue s'additionne pour donner la couleur finale de la facette.

L'intensité lumineuse de la couleur est déterminée à chaque sommet d'une facette grâce à sa normale et la direction des sources lumineuses à ce sommet. Une fois calculée la couleur à chaque sommet, la facette est colorée par interpolation de ces différentes couleurs (sauf si le modèle de remplissage de l'attribut de classe ColoringAttributes est SHADE_FLAT). L'effet des sources lumineuses ponctuelles et des spots sur une forme 3D, plane ou non, sera beaucoup mieux rendu si cette forme est découpée en un grand nombre de facettes : ceci va augmenter le nombre de sommets et de normales et par conséquent le nombre et la précision des calculs de couleurs.

Le modèle d'éclairage utilisé par Java 3D ne calcule pas les ombres des objets les uns sur les autres ni leur reflet (pas de ray tracing ou d'algorithmes du même genre) : Si vous tenez à rendre une touche très réaliste à vos scènes sous Java 3D, c'est à vous de calculer les ombres et d'ajouter à la scène 3D les objets représentant ces ombres.

Eclairage et texture

Pour éclairer une forme 3D sur laquelle est appliquée une texture, il faut ajouter à ses attributs d'apparence une instance de la classe TextureAttributes dont le mode d'application est MODULATE. Comme ce mode provoque la combinaison de la texture avec la couleur des facettes, il vaut mieux que les couleurs des attributs de classe Material de la forme 3D soient blanches ou grises, sauf pour faire des effets spéciaux (le constructeur par défaut de la classe Material suffit généralement).

L'applet LitPlane suivante dérive de la classe LightEffect et permet de tester l'effet des différents types d'éclairage sur un plan dont le nombre de sommets par côté peut varier en fonction du paramètre precision. Une texture peut être appliquée sur ce plan en mode MODULATE en utilisant l'image passée par le paramètre imageFile (par exemple grain.jpg), ce qui permet de combiner la texture avec le résultat du calcul de l'éclairage.

Les captures d'écran suivantes vous montre l'effet d'une source lumineuse de classe SpotLight sur un plan en fonction du nombre de ses sommets (et de ses normales) : avec une précision de 2x2 et 5x5 facettes, l'effet du spot est bien visible mais les facettes se devinent (en fait, il y a deux fois plus de facettes car elles sont triangulaires). Si une texture est appliquée sur le plan, les facettes sous-jacentes se devinent beaucoup moins même avec une précision faible.
Pour information, si vous utilisez une précision égale à 1, vous obtiendrez un plan décrit par deux facettes triangulaires dont les sommets sont les coins du plan. La lumière spot n'éclairant ici aucun coin du plan, le plan sera noir résultat de l'interpolation par Java 3D de la couleur noire calculée avec les normales à chaque sommet.

java LitPlane LightClass=SpotLight Precision=2	java LitPlane LightClass=SpotLight Precision=5	java LitPlane LightClass=SpotLight Precision=10
java LitPlane LightClass=SpotLight Precision=2 ImageFile=grain.jpg	java LitPlane LightClass=SpotLight Precision=5 ImageFile=grain.jpg	java LitPlane LightClass=SpotLight Precision=10 ImageFile=grain.jpg

import javax.media.j3d.*;
import javax.vecmath.*;
import com.sun.j3d.utils.applet.MainFrame;
import com.sun.j3d.utils.image.TextureLoader;
import com.sun.j3d.utils.geometry.*;
 
public class LitPlane extends LightEffect
{
  // Méthode de la classe LightEffect outrepassée
  public Node createScene ()
  {  
    // Création d'une rotation de -PI / 6 autour de l'axe z et de l'axe x
    Transform3D transform = new Transform3D ();
    transform.rotX (-Math.PI / 6);
    Transform3D rot = new Transform3D ();
    rot.rotZ (-Math.PI / 6);
    // Multiplication des deux transformations pour les cumuler
    transform.mul (rot);
    TransformGroup transformGroup = new TransformGroup (transform);
        
    // Ajout d'un plan avec un nombre de facettes variables
    String precisionParam = getParameter ("Precision");
    int precision = precisionParam == null 
                      ? 10 
                      : Integer.parseInt (precisionParam);
    Shape3D plane = createPlane (1, precision);  
 
    Appearance appearance = new Appearance ();
    appearance.setMaterial (new Material ()); // Blanc
    // Création d'une instance de texture avec l'image du paramètre ImageFile
    String imageFileName = getParameter ("ImageFile");
    if (imageFileName != null)
    {
      Texture texture = new TextureLoader (imageFileName, this).getTexture ();
      appearance.setTexture (texture);
      // Combinaison entre la texture et la couleur de la facette
      TextureAttributes textureAttributes = new TextureAttributes ();
      textureAttributes.setTextureMode (TextureAttributes.MODULATE);
      appearance.setTextureAttributes (textureAttributes);    
    }
    plane.setAppearance (appearance);
    
    transformGroup.addChild (plane);
    return transformGroup;
  }
   
  // Crée une surface plane carrée dont les deux points opposées ont 
  // pour coordonnées (-size / 2, -size / 2, 0) et (size / 2, size / 2, 0)
  // et dont les coordonnées de texture se répartissent entre (0,0) et (size,size)
  // Cette surface est constituée de precision * precision facettes
  public Shape3D createPlane (float size, int precision)
  {      
    float halfSize = size / 2;
    // Calcul des sommets d'un carré construit avec des bandes
    float [] coords    = new float [2 * 3 * (precision + 1) * precision];
    float [] texCoords = new float [2 * 2 * (precision + 1) * precision];
    for (int i = 0, k = 0, l = 0; i < precision; i ++)
      for (int j = 0; j < precision + 1; j ++)
      {
        coords [k++] = size / precision * i - halfSize;
        coords [k++] = size / precision * j - halfSize;
        coords [k++] = 0;
        coords [k++] = size / precision * (i + 1) - halfSize;
        coords [k++] = size / precision * j - halfSize;
        coords [k++] = 0;
 
        texCoords [l++] = size * i / precision;
        texCoords [l++] = size * j / precision;
        texCoords [l++] = size * (i + 1) / precision;
        texCoords [l++] = size * j / precision;
      }
    // Tableau du nombre de sommets par bande
    int [] stripCounts = new int [precision];
    for (int i = 0; i < precision; i ++)
      stripCounts [i] = 2 * (precision + 1);
    GeometryInfo geometryInfo = new GeometryInfo (GeometryInfo.TRIANGLE_STRIP_ARRAY);
    geometryInfo.setCoordinates (coords);
    geometryInfo.setStripCounts (stripCounts);
    geometryInfo.setTextureCoordinates2 (texCoords);
    // Génération des normales
    new NormalGenerator ().generateNormals (geometryInfo);
    // Création d'une forme 3D avec ce plan   
    return new Shape3D (geometryInfo.getIndexedGeometryArray ());
  }
 
  // Méthode main () pour permettre d'utiliser cette classe 
  // comme applet ou comme application
  public static void main (String [] args) 
  {
    new MainFrame (new LitPlane (), args, 150, 150);
  }  
}

Figure 19. Arbre de la scène LitPlane

Combinaison des sources lumineuses

Une scène 3D est souvent éclairée par au moins deux sources lumineuses : une source lumineuse ambiante de classe AmbientLight et une source lumineuse d'une autre classe qui éclaire la scène. La source ambiante permet d'apercevoir la forme de tous les objets et évite que certains restent complètement dans l'ombre.
Il est possible de multiplier les sources lumineuses pour mettre en scène vos objets, avec par exemple des lumières de différentes couleurs.

L'applet LitApplet3D dérivant de la classe Applet3D permet d'éclairer les autres applets de classe Applet3D décrites précédemment pour les tester sous l'effet de trois sources lumineuses : une source lumineuse ambiante et deux sources lumineuses unidirectionnelles de couleurs et de directions différentes. La classe LitApplet3D définie aussi une méthode checkMaterial () qui attribue des attributs de classe Material aux formes 3D visualisées qui n'en ont pas.
La classe de l'applet à éclairer est spécifiée grâce au paramètre Applet3DClass. Pour une utilisation avec la commande java, la valeur du paramètre est passée de la manière suivante :
java LitApplet3D Applet3DClass=AxisShapeDemo
Cette applet fonctionne avec tous les applets de classe Applet3D de ce manuel mais l'éclairage n'a d'effet que sur les scènes 3D utilisant des formes 3D qui ne définissent pas de couleur pour leur sommets, comme : SimpleObjects, AxisShapeDemo, HelloWorld3D, ObjectFileDemo, Clown, SphereConstruction et WaterGlass.

Exemples de scène 3D éclairées par l'applet LitApplet3D
AxisShapeDemo	ObjectFileDemo
Clown	SphereConstruction

import javax.media.j3d.*;
import javax.vecmath.*;
import java.util.Enumeration;
import com.sun.j3d.utils.applet.MainFrame;
 
public class LitApplet3D extends Applet3D
{
  public BranchGroup createSceneTree ()
  {
    // Racine de l'arbre des objets représentés dans la scène 3D
    BranchGroup root = new BranchGroup ();
 
    // Récupération de la classe d'applet passée dans le paramètre Applet3DClass
    // Par exemple : <PARAM NAME="Applet3DClass" VALUE="Clown"> pour une applet
    //               ou Applet3DClass=Clown en paramètre de la commande java
    String applet3DClassName = getParameter ("Applet3DClass");
    if (applet3DClassName != null)
      try
      { 
        // Instantion de la classe d'applet et création de l'arbre de la scène 3D
        Applet3D subApplet = (Applet3D)Class.forName (applet3DClassName).newInstance ();
        Group subTree = subApplet.createSceneTree ();
        checkMaterial (subTree);
        root.addChild (subTree);
      }
      catch (Exception e)
      {
        System.err.println (  "Can't instantiate Applet3DClass " + applet3DClassName 
                            + "\n" + e);
      }
 
    // Ajout des sources lumineuses   
    addLights (root);    
    return root;
  }
  
  public void addLights (Group root)
  {
    BoundingSphere influencingBounds = new BoundingSphere (new Point3d (), 100.0);
    
    // Création de trois sources lumineuses
    Light light1 = new DirectionalLight (new Color3f (1, 0.75f, 0.25f), // jaune
                                         new Vector3f (1, -0.5f, -0.5f));
    light1.setInfluencingBounds (influencingBounds);
    root.addChild (light1);
    
    Light light2 = new DirectionalLight (new Color3f (0.8f, 0.8f, 1f), // bleu
                                         new Vector3f (-1, -0.5f, -0.5f));
    light2.setInfluencingBounds (influencingBounds);
    root.addChild (light2);
    
    Light light3 = new AmbientLight (new Color3f (0.4f, 0.4f, 0.4f));
    light3.setInfluencingBounds (influencingBounds);
    root.addChild (light3);
  }    
 
  // Vérifie que toutes les formes 3D ont un attribut d'apparence Material
  public void checkMaterial (Node node)
  {
    if (node instanceof Group)
      // Enumeration de tous les enfants de ce noeud
      for (Enumeration enumeration = ((Group)node).getAllChildren (); 
           enumeration.hasMoreElements (); )
        checkMaterial ((Node)enumeration.nextElement ());
    else 
      if (node instanceof Shape3D)
      {
        Appearance appearance = ((Shape3D)node).getAppearance ();
        if (appearance == null)
          appearance = new Appearance ();
        if (appearance.getMaterial () == null)
          if (appearance.getColoringAttributes () == null)
            appearance.setMaterial (new Material ());
          else
          {
            // Création d'un attribut Material à partir de la couleur donnée
            Color3f color = new Color3f ();
            ((ColoringAttributes)appearance.getColoringAttributes ()).getColor (color);
            Color3f ambientColor = 
                new Color3f (color.x * .2f, color.y * .2f, color.z * .2f);
            appearance.setMaterial (
                new Material (ambientColor, new Color3f (), color, color, 64));
          }
        ((Shape3D)node).setAppearance (appearance);
      }
  }
  
  // Methode main () pour permettre d'utiliser cette classe 
  // comme applet ou comme application
  public static void main (String [] args) 
  {
    new MainFrame (new LitApplet3D (), args, 150, 150);
  }  
}

Figure 20. Arbre de la scène LitApplet3D avec la scène de la classe AxisShapeDemo

Les classes d'éclairage

La classe javax.media.j3d.Light

Cette classe abstract dérive des classes SceneGraphObject, Node, Leaf. C'est la super classe des classes de sources lumineuses AmbientLight, DirectionalLight, PointLight.

Toutes les sources lumineuses ont une limite d'influence (influencing bounds) null par défaut. Cette limite permet d'optimiser les calculs de Java 3D en lui évitant de prendre en compte à tout moment toutes les sources lumineuses sur les scènes 3D de grande taille. Il faut obligatoirement déterminer cette limite pour que la source lumineuse est un effet.

Champs (constantes de capacité)

public static final int ALLOW_STATE_READ
public static final int ALLOW_STATE_WRITE
public static final int ALLOW_COLOR_READ
public static final int ALLOW_COLOR_WRITE
public static final int ALLOW_INFLUENCING_BOUNDS_READ
public static final int ALLOW_INFLUENCING_BOUNDS_WRITE

Ces capacités permettent d'autoriser la lecture ou la modification de l'état allumé ou éteint de cette source lumineuse, de sa couleur et de ses limites d'influence.

public static final int ALLOW_SCOPE_READ
public static final int ALLOW_SCOPE_WRITE

Principales méthodes

public boolean getEnable ()	(Capacité ALLOW_STATE_READ)
public void setEnable (boolean state)	(Capacité ALLOW_STATE_WRITE)

Ces méthodes permettent d'interroger l'état allumé (true) ou éteint (false) de cette source lumineuse ou de modifier son état.

public void getColor (Color3f color)	(Capacité ALLOW_COLOR_READ)
public void setColor (Color3f color)	(Capacité ALLOW_COLOR_WRITE)

Ces méthodes permettent d'interroger ou de modifier la couleur de cette source lumineuse.

public Bounds getInfluencingBounds ()	(Capacité ALLOW_INFLUENCING_BOUNDS_READ)
public BoundingLeaf getInfluencingBoundingLeaf ()	(Capacité ALLOW_INFLUENCING_BOUNDS_READ)
public void setInfluencingBounds (Bounds region)	(Capacité ALLOW_INFLUENCING_BOUNDS_WRITE)
public void setInfluencingBoundingLeaf (BoundingLeaf region)	(Capacité ALLOW_INFLUENCING_BOUNDS_WRITE)

Ces méthodes permettent d'interroger ou de modifier la limite d'influence de cette source lumineuse.

La classe javax.media.j3d.AmbientLight

Cette classe dérive des classes SceneGraphObject, Node, Leaf, Light et représente une source lumineuse ambiante que réfléchit de manière uniforme la couleur d'ambiance (couleur ambiantColor de la classe Material) des formes 3D.

Constructeurs

public AmbientLight ()
public AmbientLight (Color3f color)
public AmbientLight (boolean lightOn, Color3f color)

Ces constructeurs permettent de créer une source lumineuse ambiante initialisée avec la couleur color et dans l'état allumé ou éteint lightOn (par défaut, égaux à la couleur blanche et true).

Exemples

Applets LightEffect, LitApplet3D.

La classe javax.media.j3d.DirectionalLight

Cette classe dérive des classes SceneGraphObject, Node, Leaf, Light et représente une source lumineuse unidirectionnelle que réfléchissent les couleurs de diffusion et de spécularité (couleurs diffuseColor et specularColor de la classe Material) des formes 3D. Le vecteur indiquant la direction de cette lumière est orienté dans le sens des rayons lumineux.

Champs (constantes de capacité)

public static final int ALLOW_DIRECTION_READ
public static final int ALLOW_DIRECTION_WRITE

Ces capacités permettent d'autoriser la lecture ou la modification la direction de cette source lumineuse.

Constructeurs

public DirectionalLight ()
public DirectionalLight (Color3f color, Vector3f dir)
public DirectionalLight (boolean lightOn, Color3f color, Vector3f dir)

Ces constructeurs permettent de créer une source lumineuse unidirectionnelle initialisée avec la couleur color, de direction dir et dans l'état allumé ou éteint lightOn (par défaut, égaux à la couleur blanche, au vecteur (0,0,-1) et true).

Principales méthodes

public void getDirection (Vector3f dir)	(Capacité ALLOW_DIRECTION_READ)
public void setDirection (float x, float y, float z)	(Capacité ALLOW_DIRECTION_WRITE)
public void setDirection (Vector3f dir)	(Capacité ALLOW_DIRECTION_WRITE)

Ces méthodes permettent d'interroger ou de modifier la direction de cette source lumineuse.

Exemples

Applets LightEffect, LitApplet3D.

La classe javax.media.j3d.PointLight

Cette classe dérive des classes SceneGraphObject, Node, Leaf, Light et représente une source lumineuse ponctuelle que réfléchissent les couleurs de diffusion et de spécularité (couleurs diffuseColor et specularColor de la classe Material) des formes 3D.

Champs (constantes de capacité)

public static final int ALLOW_POSITION_READ
public static final int ALLOW_POSITION_WRITE
public static final int ALLOW_ATTENUATION_READ
public static final int ALLOW_ATTENUATION_WRITE

Ces capacités permettent d'autoriser la lecture ou la modification la position de cette source lumineuse et son atténuation.

Constructeurs

public PointLight ()
public PointLight (Color3f color, Point3f pos, Point3f attenuation)
public PointLight (boolean lightOn, Color3f color, Point3f pos, Point3f attenuation)

Ces constructeurs permettent de créer une source lumineuse ponctuelle initialisée avec la couleur color, de position pos, d'atténuation attenuation et dans l'état allumé ou éteint lightOn. Par défaut, color est égale à la couleur blanche, pos au point (0,0,0), attenuation à (1,0,0) et lightOn à true.

Principales méthodes

public void getPosition (Point3f position)	(Capacité ALLOW_POSITION_READ)
public void setPosition (float x, float y, float z)	(Capacité ALLOW_POSITION_WRITE)
public void setPosition (Point3f position)	(Capacité ALLOW_POSITION_WRITE)

Ces méthodes permettent d'interroger ou de modifier la position de cette source lumineuse.

public void getAttenuation (Point3f attenuation)	(Capacité ALLOW_ATTENUATION_READ)
public void setAttenuation (float constant,      float linear, float quadratic)	(Capacité ALLOW_ATTENUATION_WRITE)
public void setAttenuation (Point3f attenuation)	(Capacité ALLOW_ATTENUATION_WRITE)

Ces méthodes permettent d'interroger ou de modifier l'atténuation de cette source lumineuse. Les trois champs x, y et z du paramètre attenuation correspondent aux paramètres constant, linear et quadratic, et sont utilisés pour déterminer l'atténuation de la lumière en fonction de la distance d entre la position de la source lumineuse et un point de l'espace avec la formule suivante :
1 / (constant + linear * d + quadratic * d * d)
Si linear et quadratic sont égaux à 0 la lumière ne s'atténue pas avec l'éloignement de la position de la source lumineuse.

Exemple

Applet LightEffect, SunEarthMoonMotion.

La classe javax.media.j3d.SpotLight

Cette classe dérive des classes SceneGraphObject, Node, Leaf, Light, PointLight et représente une source lumineuse spot que réfléchissent les couleurs de diffusion et de spécularité (couleurs diffuseColor et specularColor de la classe Material) des formes 3D.

Champs (constantes de capacité)

public static final int ALLOW_DIRECTION_WRITE
public static final int ALLOW_DIRECTION_READ
public static final int ALLOW_SPREAD_ANGLE_WRITE
public static final int ALLOW_SPREAD_ANGLE_READ
public static final int ALLOW_CONCENTRATION_WRITE
public static final int ALLOW_CONCENTRATION_READ

Ces capacités permettent d'autoriser la lecture ou la modification la direction de l'axe du cône d'éclairage de ce spot, l'angle de ce cône et la concentration de la lumière du spot.

Constructeurs

public SpotLight ()
public SpotLight (Color3f color, Point3f pos, Point3f attenuation,
                  Vector3f dir, float spreadAngle, float concentration)
public SpotLight (boolean lightOn, Color3f color, Point3f pos, Point3f attenuation,
                  Vector3f dir, float spreadAngle, float concentration)

Ces constructeurs permettent de créer un spot initialisé avec la couleur color, de position pos, d'atténuation attenuation et dans l'état allumé ou éteint lightOn. dir donne la direction de l'axe du cône d'éclairage, spreadAngle l'angle de ce cône et concentration la concentration de la lumière du spot.
Par défaut, color est égale à la couleur blanche, pos au point (0,0,0), attenuation à (1,0,0), dir à (-1,0,0), spreadAngle à PI et concentration à 0 et lightOn à true.

Principales méthodes

public void getDirection (Vector3f dir)	(Capacité ALLOW_DIRECTION_READ)
public void setDirection (float x, float y, float z)	(Capacité ALLOW_DIRECTION_WRITE)
public void setDirection (Vector3f dir)	(Capacité ALLOW_DIRECTION_WRITE)

Ces méthodes permettent d'interroger ou de modifier la direction de l'axe du cône d'éclairage de ce spot.

public float getSpreadAngle ()	(Capacité ALLOW_SPREAD_ANGLE_READ)
public void setSpreadAngle (float spreadAngle)	(Capacité ALLOW_SPREAD_ANGLE_WRITE)

Ces méthodes permettent d'interroger ou de modifier l'angle du cône d'éclairage de ce spot. spreadAngle est l'angle en radians entre l'axe du cône et le bord du cône.

public float getConcentration ()	(Capacité ALLOW_CONCENTRATION_READ)
public void setConcentration (float concentration)	(Capacité ALLOW_CONCENTRATION_WRITE)

Ces méthodes permettent d'interroger ou de modifier la concentration de la lumière de ce spot. concentration est compris entre 0 et 127. Plus cette valeur est grande, moins la lumière du spot est uniforme du centre à la périphérie du cône d'éclairage.

Exemple

Applet LightEffect.

© Copyrights 1997-2023 Emmanuel PUYBARET / eTeks - Tous droits réservés -