/**
     * Classe interne CamQuaternion
     * Représente les Quaternions de manière assez simple
     * Les opérations comme le conjugué ou la norme ne sont pas implémentées
     */
    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 représentant une
         * rotation quelconque dans l'espace
         */
        void createFromAxisAngle(float x, float y, float z, float degrees) {
        
            // On convertit les degrés 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 coordonnées 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();
            // On ne normalise pas le vecteur nul
            if (norme != 0.0f) {
                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 créer à partir d'un quaternion une matrice qui peut être utilisée
         * par OpenGL
         */
        float[] createMatrix() {
            float[] matrix = new float[16];
            
            // Première 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;
 
            // Troisième 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;
 
            // Quatrième COLONNE
            matrix[12] = 0.0f;
            matrix[13] = 0.0f;
            matrix[14] = 0.0f;
            matrix[15] = 1.0f;
 
            // matrix est une matrice 4x4 homogène qui peut être utilisée 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