Sujet Précédent Sujet Suivant

Problème de caméra OpenGL

MeraK1337 Messages postés 1 Date d'inscription vendredi 2 mars 2007 Statut Membre Dernière intervention 9 mars 2007 - 9 mars 2007 à 15:30
niyana Messages postés 2 Date d'inscription lundi 30 janvier 2006 Statut Membre Dernière intervention 18 mars 2007 - 18 mars 2007 à 14:19
Bonjour, je suis débutant en java et j'ai un problème pour le contrôle de ma caméra sur une scène 3D.
J'ai besoin d'adapter une classe que j'ai récupéré sur le net avec un exercice que j'ai pratiqué en cours.

Cette exercice contenait déjà un contrôleur mais je l'ai égaré...

Voilà, j'ai la classe Camera.java, je suis les instructions que m'as laissé l'auteur de cette classe mais cela ne suffit pas...

J'ai aussi la classe CamQuaternion.

Exo et ExoView compose l'exercice.

Je souhaite donc pouvoir contrôler la scène produite par Exo.java grâce à la classe Camera.java

Si vous pouvez m'aider, cela serais très sympathique...
Malheureusement pour moi, je dois trouver une solution avant lundi...
J'espere que vous allez pouvoir résoudre mon problème.

CLASSE Camera.java: 

//Pour les fentres
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Insets;
import java.awt.Robot;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import javax.media.opengl.*;

/**
 * Camra  base de quaternions
 * La camera bouge par la modification de son heading, pitch et bank
 * Ces termes anglais sont lis  l'aronautique
 * heading =  le cap
 * pitch   = le tangage
 * bank    = le roulis
 * C'est le modle utils par la plupart des soft 3D (Lighwave, 3DSMax)
 *
 * Pour l'utilisateur :
 * UP : Avancer (ou mettre les gazs)
 * DOWN : Reculer (ou inverser les gazs)
 * LEFT : Tourner  gauche
 * RIGHT : Tourner  droite
 * Souris : Contrle de la vue
 *
 * Pour le codeur :
 * dans init : -on cre un objet de type Camera
 *             -on l'ajoute en tant que KeyListener et MouseMotionListener de
 *              l'objet GLDrawable
 * dans display : -on appelle setPerspective(GL gl) juste aprs le glLoadIdentity
 *                et juste avant un glTranslatef(0.f,0.f,-5.f)
 *
 */
public strictfp class Camera implements KeyListener, MouseMotionListener {

    /**
     * Classe interne CamPoint
     * Reprsente un point par ses coordonnes cartsiennes
     */
    strictfp class CamPoint {
        public float x;
        public float y;
        public float z;

        CamPoint() {
            x = 0.0f;
            y = 0.0f;
            z = 0.0f;
        }
    }//FIN DE LA CLASSE CamPoint

    /**
     * Classe interne CamVector
     * Reprsente un vecteur
     */
    strictfp class CamVector {

        public float i;
        public float j;
        public float k;

        /** Constructeur*/
        CamVector() {
            i = 0.0f;
            j = 0.0f;
            k = 0.0f;
        }

        /**Pour multiplier un vecteur par un scalaire*/
        CamVector multiplierScalaire(float scalaire) {
            CamVector c = new CamVector();
            c.i = i * scalaire;
            c.j = j * scalaire;
            c.k = k * scalaire;
            return c;
        }
    }//FIN DE LA CLASSE CamVector

    /**
     * Classe interne CamQuaternion
     * Reprsente les Quaternions de manire assez simple
     * Les oprations comme le conjugu ou la norme ne sont pas implmentes
     */
    strictfp class CamQuaternion {

        private float w;
        private float x;
        private float y;
        private float z;

        /**Constructeur*/
        CamQuaternion() {
            w = 1.0f;
            x = 0.0f;
            y = 0.0f;
            z = 0.0f;
        }

        /**
         * Transforme un quaternion en un quaternion reprsentant une
         * rotation quelconque dans l'espace
         */
        void createFromAxisAngle(float x, float y, float z, float degrees) {

            // On convertit les degrs en radians
            float angle = (degrees / 180.0f) * (float)Math.PI;

            // On calcule sinus(theta/2) une seule fois pour optimiser
            float result = (float)Math.sin(angle / 2.0f);

            // On calcule la valeur de w = cosinus(theta / 2)
            this.w = (float)Math.cos(angle / 2.0f);

            // On calcule les coordonnes x y z du quaternion
            this.x = x * result;
            this.y = y * result;
            this.z = z * result;
            normaliser();
        }

        /**
         * Normalise le quaternion courant
         */
        void normaliser() {
            float norme = norme();
            w = w/norme;
            x = x/norme;
            y = y/norme;
            z = z/norme;
        }

        /**
         * Renvoie la norme du quaternion courant
         */
        float norme() {
            return w*w + x*x + y*y + z*z;
        }

        /**
         * Pour crer  partir d'un quaternion une matrice qui peut tre utilise
         * par OpenGL
         */
        float[] createMatrix() {
            float[] matrix = new float[16];

            // Premire COLONNE
            matrix[0] = 1.0f - 2.0f * ( y*y + z*z);
            matrix[1] = 2.0f * ( x*y + z*w);
            matrix[2] = 2.0f * ( x*z - y*w);
            matrix[3] = 0.0f;

            // Seconde COLONNE
            matrix[4] = 2.0f * ( x*y - z*w);
            matrix[5] = 1.0f - 2.0f * ( x*x + z*z);
            matrix[6] = 2.0f * ( z*y + x*w);
            matrix[7] = 0.0f;

            // Troisime COLONNE
            matrix[8] = 2.0f * ( x*z + y*w);
            matrix[9] = 2.0f * ( y*z - x*w);
            matrix[10] = 1.0f - 2.0f * ( x*x + y*y);
            matrix[11] = 0.0f;

            // Quatrime COLONNE
            matrix[12] = 0.0f;
            matrix[13] = 0.0f;
            matrix[14] = 0.0f;
            matrix[15] = 1.0f;

            // matrix est une matrice 4x4 homogne qui peut tre utilise pour les
            // calculs avec les matrices OpenGL
            return matrix;
        }

        /**Pour multiplier 2 quaternions*/
        CamQuaternion multiplier(CamQuaternion q) {
            CamQuaternion resultat = new CamQuaternion();
            resultat.w = w * q.w - x * q.x - y * q.y - z * q.z;
            resultat.x = w * q.x + x * q.w + y * q.z - z * q.y;
            resultat.y = w * q.y + y * q.w + z * q.x - x * q.z;
            resultat.z = w * q.z + z * q.w + x * q.y - y * q.x;
            return resultat;
        }
    }//FIN DE LA CLASSE CamQuaternion

    //Coefficient maximum pour la variation du pitch
    public float maxPitchRate;

    //Coefficient maximum pour la variation du heading
    public float maxHeadingRate;

    //Coefficient maximum pour la variation de vitesse
    public float maxForwardVelocity;

    //Angle de rotation du heading
    public float headingDegrees;

    //Angle de rotation du pitch
    public float pitchDegrees;

    //Valeur de la vitesse
    public float forwardVelocity;

    //Quaternions pour effectuer les rotations
    CamQuaternion qHeading;
    CamQuaternion qPitch;

    //La position de la camra
    CamPoint position;

    //Le vecteur de la direction de la camera.
    CamVector directionVector;

    //Un Robot est un objet java utilis pour les dmonstrations d'applications
    //Il permet d'imposer la position du curseur de la souris, de le dplacer,
    //de simuler une frappe au clavier...
    Robot robot;

    /**Constructeur de la classe Camera*/
    public Camera() {

        try {
            robot = new Robot();
        }
        catch (Exception e) {
            System.out.println("Echec  l'initialisation du robot");
        }

        qHeading = new CamQuaternion();
        qPitch = new CamQuaternion();

        position = new CamPoint();
        position.x = 0.0f;
        position.y = 0.0f;
        position.z = -5.0f;

        directionVector = new CamVector();

        maxPitchRate =          1.0f;
        maxHeadingRate =        1.0f;
        maxForwardVelocity =    1.0f;
        headingDegrees =        0.0f;
        pitchDegrees =          0.0f;
        forwardVelocity =       0.0f;
    }

    /**
     * Pour dfinir la perspective, c'est  dire la faon dont on voit le monde
     * C'est ainsi que l'on "dplace" la camra
     */
    public void setPerspective(GL gl) {

        float[] matrice = new float[16];
        CamQuaternion q = new CamQuaternion();

        // On fabrique les quaternions reprsentant nos rotations
        qPitch.createFromAxisAngle(1.0f, 0.0f, 0.0f, pitchDegrees);
        qHeading.createFromAxisAngle(0.0f, 1.0f, 0.0f, headingDegrees);

        // On multiplie les rotations pitch et heading
        q = qPitch.multiplier(qHeading);
        matrice = q.createMatrix();

        // OpenGL dfinit notre nouvelle perspective du monde
        // XXX : Cette opration est beaucoup plus couteuse que des appels 
        // glRotatef et glTranslatef
        gl.glMultMatrixf(matrice,0);

        // On cre une matrice  partir du quaternion reprsentant le pitch
        matrice = qPitch.createMatrix();
        // Et on en extrait le vecteur j reprsentant la direction dans laquelle
        // on regarde
        directionVector.j = matrice[9];

        // On multiplie les rotations heading et pitch
        q = qHeading.multiplier(qPitch);

        // On fabrique la matrice pour pouvoir en extraire les vecteurs i et k
        matrice = q.createMatrix();

        directionVector.i = matrice[8];
        directionVector.k = matrice[10];

        // On adapte le vecteur direction en fonction de la vitesse
        directionVector = directionVector.multiplierScalaire(forwardVelocity);

        //XXX
        // Remise  zro de la vitesse :
        // - Cette classe reprsente  l'origine une camra  la Wing Commander,
        // c'est  dire que l'on dirige la vue  la souris, et une impulsion
        // au clavier active les gazs, on avance alors tout seul (comme un
        // avion)
        // - Pour une camra a la quake, ne pas appuyer sur le clavier
        // correspond  ne pas avancer
        //
        // Remettre cette variable  zro en permanence est un pure bricolage
        // pour obtenir un comportement quake-like d'une camra Wing Commander
        // De toute faon, elle reste "non straffante"
        forwardVelocity = 0.0f;
        //XXX

        // On incrmente la position  l'aide du vecteur
        position.x += directionVector.i;
        position.y += directionVector.j;
        position.z += directionVector.k;

        // On fait une translation jusque notre nouvelle position
        gl.glTranslatef( -position.x , -position.y , position.z);
    }

    /**Pour changer la direction*/
    void changePitch(float degrees) {

        // Notre pitch vaut moins que le maximum rate
        // donc on peut l'incrmenter
        if (Math.abs(degrees) < Math.abs(maxPitchRate)) {
            pitchDegrees += degrees;
        }

        // Sinon notre pitch vaut plus que le maximum rate
        // donc on peut seulement incrmenter le pitch
        // de ce maximum rate
        else {
            if (degrees < 0.0f) {
                pitchDegrees -= maxPitchRate;
            }
            else {
                pitchDegrees += maxPitchRate;
            }
        }

        // On ne veut pas que notre pitch "explose"
        if (pitchDegrees > 360.0f) {
            pitchDegrees -= 360.0f;
        }
        else {
            if (pitchDegrees < -360.0f) {
                pitchDegrees += 360.0f;
            }
        }
    }

    /**Pour changer le cap*/
    void changeHeading(float degrees) {

        // Notre heading vaut moins que le maximum rate
        // donc on peut l'incrmenter
        // MAIS on doit vrifier si nous sommes renverss
        if (Math.abs(degrees) < Math.abs(maxHeadingRate)) {
            if ( (pitchDegrees > 90.0f &amp;&amp; pitchDegrees < 270.0f)
                    ||
                 (pitchDegrees < -90.0f &amp;&amp; pitchDegrees > -270.0f)) {
                headingDegrees -= degrees;
            }
            else {
                headingDegrees += degrees;
            }
        }

        // Notre heading est plus grand que le maximum rate
        // donc on peut seulement incrmenter le heading
        // de ce maximum rate
        else {
            if (degrees < 0.0f) {
                if ( (pitchDegrees > 90.0f &amp;&amp; pitchDegrees < 270.0f)
                        ||
                     (pitchDegrees < -90.0f &amp;&amp; pitchDegrees > -270.0f)) {

                    // Normalement ici on dcremente, mais vu que nous sommes
                    // renverss, on incrmente
                    headingDegrees += maxHeadingRate;
                }
                else {
                    headingDegrees -= maxHeadingRate;
                }
            }
            else {
                if ( (pitchDegrees > 90.0f &amp;&amp; pitchDegrees < 270.0f)
                        ||
                     (pitchDegrees < -90.0f &amp;&amp; pitchDegrees > -270.0f)) {
                    headingDegrees -= maxHeadingRate;
                }
                else {
                    headingDegrees += maxHeadingRate;
                }
            }
        }

        // On ne veut pas que notre heading "explose"
        if (headingDegrees > 360.0f) {
            headingDegrees -= 360.0f;
        }
        else {
            if (headingDegrees < -360.0f) {
                headingDegrees += 360.0f;
            }
        }
    }

    /**Pour changer la vitesse*/
    void changeVelocity(float vel) {

        // Notre vitesse vaut moins que le maximum rate
        // donc on peut l'incrmenter
        if (Math.abs(vel) < Math.abs(maxForwardVelocity)) {
            forwardVelocity += vel;
        }

        // Notre vitesse est plus grande que le maximum rate
        // donc on peut seulement l'incrmenter de ce maximum rate
        else {
            if (vel < 0.0f) {
                forwardVelocity -= -maxForwardVelocity;
            }
            else {
                forwardVelocity += maxForwardVelocity;
            }
        }

    }

    // ON IMPLEMENTE LE KEYLISTENER
    public void keyPressed(KeyEvent e) {
        //Quitter
        if(e.getKeyCode() == KeyEvent.VK_ESCAPE) {
            System.exit(0);
        }

        //On accelre
        if(e.getKeyCode() == KeyEvent.VK_UP) {
            changeVelocity(0.05f);
        }

        //On ralentit
        if(e.getKeyCode() == KeyEvent.VK_DOWN) {
            changeVelocity(-0.05f);
        }

        //On tourne  gauche (on ne straffe pas)
        if(e.getKeyCode() == KeyEvent.VK_LEFT) {
            changeHeading(-5.0f);
        }

        //On tourne  droite (on ne straffe pas)
        if(e.getKeyCode() == KeyEvent.VK_RIGHT) {
            changeHeading(5.0f);
        }
    }

    public void keyReleased(KeyEvent e) {
    }

    public void keyTyped(KeyEvent e) {}

    // ON IMPLEMENTE LE MOUSEMOTIONLISTENER
    public void mouseDragged(MouseEvent e) {

    }

    public void mouseMoved(MouseEvent e) {

        //deltaMouse mesure de combien le curseur de souris s'loigne du centre
        //de l'cran
        float deltaMouse = 0.0f;

        //On rcupre le component qui communique avec le listener car on a
        //besoin de connatre les dimensions de la fentre
        Component component = e.getComponent();

        //On rcupre le container du component (ie la Frame) car on a besoin de
        //rcuprer les dimensions de la bordure (les Insets)
        //En effet les mthodes rcuprant les coordonnes du curseur de souris
        //calculent  partir de l'origine de la fentre AVEC bordures
        Container container = component.getParent();

        //On rcupre les informations sur les dimensions des bordures
        Insets insets = container.getInsets();

        //On rcupre la taille de la fentre et on calcule le milieu
        Dimension size = component.getSize();

        //On cherche le centre de la zone opengl :
        //Coordonne extrieure gauche de la frame + paisseur de la bordure = on est
        //au bord gauche de la zone opengl
        // + la largeur de la zone opengl / 2  = le milieu de la zone opengl
        int centerX = container.getX() + insets.left + (component.getWidth() / 2);
        int centerY = container.getY() + insets.top + (component.getHeight() / 2);

        //e.getPoint().getX() = coordonne x de la souris par rapport  la Frame
        // Donc on rajoute la coordonne extrieur gauche de la frame + la
        // bordure

        // XXX
        // Explication du +1.0f : un nombre empirique
        // Selon le gestionnaire de fentre :
        //
        // Pour Windows XP / KDE3 / Fvwm2 :
        // - si l'origine de la fentre est en (1,1) il y a une diffrence de 1
        // pixel entre le calcul du centre et celui des coordonnes de la souris
        // Donc on ajoute 1
        // - si la fentre est n'importe o ailleurs on ne touche  rien
        //
        // Pour Fluxbox :
        // On constate sur Fluxbox (un window manager de Linux) un comportement
        // particulier.
        // - si l'origine de la fentre est en (1,1) il ne faut rien rajouter
        // - si la fentre est n'importe o ailleurs : il y a une diffrence de 1 pixel
        // entre le calcul du centre et celui des coordonnes de la souris
        // Donc on ajoute 1

        //CODE WINDOWS_XP KDE3 FVWM2
        /*
        float x = (float)(container.getX() +e.getPoint().getX() + insets.left);
        float y = (float)(container.getY() +e.getPoint().getY() + insets.top);
        if (container.getX() 1 &amp;&amp; container.getY() 1) {
            x += 1.0f;
            y += 1.0f;
        }
        */
        //FIN CODE WINDOWS_XP KDE3 FVWM2

        //CODE FLUXBOX
        float x = (float)(container.getX() +e.getPoint().getX() + insets.left);
        float y = (float)(container.getY() +e.getPoint().getY() + insets.top);

        if (container.getX() != 1 || container.getY() != 1) {
            x += 1.0f;
            y += 1.0f;
        }
        //FIN CODE FLUXBOX

        if (x < centerX) {
            deltaMouse = (float)(centerX - x);
            changeHeading(-0.2f * deltaMouse);
        }
        else if (x > centerX) {
            deltaMouse = (float)(x - centerX);
            changeHeading(0.2f * deltaMouse);
        }

        if (y < centerY) {
            deltaMouse = (float)(centerY - y);
            changePitch(-0.2f * deltaMouse);
        }
        else if (y > centerY) {
            deltaMouse =  (float)(y - centerY);
            changePitch(0.2f * deltaMouse);
        }

        //Le curseur de souris doit rester au centre de l'cran
        robot.mouseMove(centerX, centerY);
    }
}


CLASSE Exo.java : 

import java.awt.Color;
import java.awt.Frame;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import javax.media.opengl.GLCanvas;
import javax.media.opengl.GLCapabilities;

/**
 * Exercice main window
 */
public class Exo
{
  /**
    * Creates AWT Frame with OpenGL context
    */
  public static void main (String[] args)
  {
    // Creation d'une fenetre AWT
    Frame frame   = new Frame ("TP Primitives colorees");

    // Creation de la surface d'affichage GL
    GLCapabilities capabilities =  new GLCapabilities ();
    capabilities.setDoubleBuffered (false); 
    GLCanvas canvas = new GLCanvas (capabilities);

    // Ajout d'un contexte OpenGL (vue)
    ExoView myView = new ExoView ();
    
    // Ancien contrôleur
    // Ajout d'un gestionnaire d'entrees utilisateur (controleur)
    //ExoController myController = new ExoController (canvas, myView);
    //canvas.addKeyListener (myController);
    
    
     Camera    c =  new Camera();
     canvas.addGLEventListener (myView);
      canvas.addMouseMotionListener(c);
      canvas.addKeyListener(c);
      
      

    // Programmation du bouton de fermeture de la fenetre
    frame.addWindowListener (
      new WindowAdapter ()
      {
        public void windowClosing (WindowEvent e)
        {
          System.exit (0);
        }
      });

    // Fin de la specification de la fenetre
    frame.add (canvas);
    frame.setSize (600, 600);
    frame.setLocation (0, 0);
    frame.setBackground (Color.white);
    frame.setVisible (true);
    frame.show ();

    // Capture des evenements AWT 
    canvas.requestFocus ();
  }
}


CLASSE ExoView.java : 


import java.nio.IntBuffer;

import javax.media.opengl.GL;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLEventListener;
//import javax.media.opengl.*;
import com.sun.opengl.util.BufferUtil;

/** GL context to render a movable 3D primitive
  */
public class ExoView implements GLEventListener
{
    
  /** Rendered 3D primitive */
  private ColorCube myBox   = new ColorCube ();

  /** Half value of the field of view */
  private double fieldOfView =  1.0;
  private boolean fieldOfViewChanged = false;
  private static final double FIELD_OF_VIEW_INC = 1.01;
  private static final double FIELD_OF_VIEW_MIN = 0.5;
  private static final double FIELD_OF_VIEW_MAX = 10.0;

  /** azimuth angle (site) */
  private float azimuthAngle = 0.0f;
  private int azimuthMobility = 0;
  private static final float AZIMUTH_INC = 1.0f;

  /** height angle (elevation) */
  private float heightAngle = 0.0f;
  private int heightMobility = 0;
  private static final float HEIGHT_INC = 1.0f;
  
  Camera c = new Camera();

  /** Called by the drawable immediately after the OpenGL context is
    * initialized for the first time.
    * Implementation from GLEventListener. 
    * Used to perform one-time OpenGL initializations.
    * @param gLDrawable GLAutoDrawable object.
    */
  public void init (GLAutoDrawable gLDrawable)
  {
      
      
     

    gLDrawable.addMouseMotionListener(c);
    gLDrawable.addKeyListener(c);
    
    
    
    
    final GL gl = gLDrawable.getGL ();
    gl.glShadeModel (GL.GL_FLAT);                  // No Smooth Shading
    gl.glClearColor (0.0f, 0.0f, 0.0f, 0.5f);      // Black Background
    gl.glClearDepth (1.0f);                        // Depth Buffer Setup
    gl.glEnable (GL.GL_DEPTH_TEST);                // Enables Depth Testing
    gl.glDepthFunc (GL.GL_LEQUAL);                 // Type Of Depth Testing
    gl.glEnable (GL.GL_CULL_FACE);                 // Face culling
    c.setPerspective(gl);
  }

  /** Called by the drawable to initiate OpenGL rendering by the client.
    * Implementation from GLEventListener. 
    * After all GLEventListeners have been notified of a display event,
    * the drawable will swap its buffers if necessary.
    * @param gLDrawable GLAutoDrawable object.
    */
  public void display (GLAutoDrawable gLDrawable)
  {
    final GL gl = gLDrawable.getGL ();
    
    final Camera c = new Camera();
    gl.glClearColor (0.0f, 0.0f, 0.0f, 0.5f); // Black Background
    if (fieldOfViewChanged)
    {
      IntBuffer vp = BufferUtil.newIntBuffer(4);
      gl.glGetIntegerv (GL.GL_VIEWPORT, vp);
      setProjection (gl, vp.get (2), vp.get (3));
      fieldOfViewChanged = false;
    }

    gl.glClear (GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
    gl.glLoadIdentity ();  // Reset The View
    
    
    c.setPerspective(gl);
    
    //gl.glTranslatef(0.f,0.f,-5.f);
    
    
    if (azimuthMobility != 0)
      azimuthAngle += AZIMUTH_INC * azimuthMobility;
    if (heightMobility != 0)
      heightAngle += HEIGHT_INC * heightMobility;

    
    
    
    
    gl.glRotatef (azimuthAngle, 0.0f, 1.0f, 0.0f);
    gl.glRotatef (heightAngle, 1.0f, 0.0f, 0.0f);
  
    myBox.draw (gl);
  }

  /** Called by the drawable during the first repaint after the component
    * has been resized.
    * Implementation from GLEventListener. 
    * Used to update the viewport and view volume appropriately,
    * for example by a call to GL.glViewport(int, int, int, int).
    * Note that for convenience the component has already called
    * GL.glViewport(int, int, int, int)(x, y, width, height) when this
    * method is called, so the client may not have to do anything.
    * @param gLDrawable GLAutoDrawable object.
    * @param x X Coordinate of the viewport area.
    * @param y Y coordinate of the viewport area.
    * @param width new width of the window.
    * @param height new height of the window.
    */
  public void reshape (GLAutoDrawable gLDrawable,
                       int x, int y, int width, int height)
  {
    final GL gl = gLDrawable.getGL ();

    if (height <= 0) // avoid a divide by zero error!
      height = 1;
    gl.glViewport (0, 0, width, height);
    setProjection (gl, width, height);
    gl.glLoadIdentity ();
  }

  /** Called when the display mode has been changed.
    * Implementation from GLEventListener. 
    *  !! CURRENTLY UNIMPLEMENTED IN JOGL !! 
    * @param gLDrawable GLAutoDrawable object.
    * @param modeChanged Indicates if the video mode has changed.
    * @param deviceChanged Indicates if the video device has changed.
    */
  public void displayChanged (GLAutoDrawable gLDrawable,
                              boolean modeChanged, boolean deviceChanged)
  {
  }

  /** Resets the projection matrix according to new viewport and
    * projection angle values.
    * @param gl OpenGL context.
    * @param width viewport width.
    * @param height viewport height.
    */ 
  private void setProjection (GL gl, int width, int height)
  {
    gl.glMatrixMode (GL.GL_PROJECTION);
    gl.glLoadIdentity ();
    gl.glOrtho (- fieldOfView, fieldOfView,
                - fieldOfView * height / width,
                fieldOfView * height / width, - 10.0, 10.0);
    gl.glMatrixMode (GL.GL_MODELVIEW);
  }

  /** Increases the projection field of view.
    */
  public void increaseFieldOfView ()
  {
    fieldOfView / = FIELD_OF_VIEW_INC;
    if (fieldOfView < FIELD_OF_VIEW_MIN) fieldOfView = FIELD_OF_VIEW_MIN;
    fieldOfViewChanged = true;
  }

  /** Decreases the projection field of view.
    */
  public void decreaseFieldOfView ()
  {
    fieldOfView *= FIELD_OF_VIEW_INC;
    if (fieldOfView > FIELD_OF_VIEW_MAX) fieldOfView = FIELD_OF_VIEW_MAX;
    fieldOfViewChanged = true;
  }

  /** Controls the primitive rotation in azimuth.
    * @param control rotation control :
    *   fixed if set to 0,
    *   counter-clockwise if set to 1,
    *   clockwise if set to -1.
    */ 
  public void rotateInAzimuth (int control)
  {
    azimuthMobility = control;
  }

  /** Controls the primitive rotation in elevation.
    * @param control rotation control :
    *   fixed if set to 0,
    *   counter-clockwise if set to 1,
    *   clockwise if set to -1.
    */ 
  public void rotateInHeight (int control)
  {
    heightMobility = control;
  }
}

2 réponses

Réponse 1 / 2
Utilisateur anonyme
12 mars 2007 à 11:30
Sur cppfrance, j'ai laissé une caméra OpenGL utilisant des quaternions et équippé d'un système anti-gimbal lock. Va donc y jeter un coup d'oeil. Le code est proche du tien d'ailleurs, tu n'auras pas grand chose à modifier. Précise ce que tu entends par contrôleur. Contrôleur au sens du design pattern MVC? Tu es trop vague, j'aurais voulu t'aider.

yeah! vive java
0
Réponse 2 / 2
niyana Messages postés 2 Date d'inscription lundi 30 janvier 2006 Statut Membre Dernière intervention 18 mars 2007
18 mars 2007 à 14:19
je suis un debutant en 3d mais je suis programmeur en java  et c++
s'il vous est ce que  quelqu'un peux m'expliquer comment la bilbiotéque opengl fonction avec java.
0

Discussions similaires

trier un iterator
lafolle24320 -
Twinuts -

9 réponses
la division en java
cs_aliomar -
KIRAIII -

3 réponses
Le Mapping en Java: Map(Key,Value)
cs_developppez -
icecube005 -

2 réponses
la difference entre a++ et ++a
waluigii -
Twinuts -

2 réponses
Problème de division réelle (et oui...)
playmo420 -
nomad56 -

4 réponses
Rejoignez-nous