Référence du fichier gl4dq.c

fonctions de manipulation de Quaternions Plus de détails...

#include "gl4dq.h"
#include <math.h>

Graphe des dépendances par inclusion de gl4dq.c:

Aller au code source de ce fichier.

Fonctions
void	gl4dqComputeScalaire (gl4dqQuaternion q)
	fonction de calcul de la partie scalaire d'un gl4dqQuaternion unitaire où seule la partie imaginaire est donnée Plus de détails...
void	gl4dqConjugate (const gl4dqQuaternion q, gl4dqQuaternion conjugate)
	fonction de calcul du conjugué d'un gl4dqQuaternion Plus de détails...
void	gl4dqMultiply (const gl4dqQuaternion qa, const gl4dqQuaternion qb, gl4dqQuaternion r)
	fonction de calcul de la multiplication de deux gl4dqQuaternions Plus de détails...
float	gl4dqMagnitude (gl4dqQuaternion q)
	fonction qui calcule la norme d'un gl4dqQuaternion Plus de détails...
void	gl4dqNormalize (gl4dqQuaternion q)
	fonction qui transforme un gl4dqQuaternion en un gl4dqQuaternion unitaire Plus de détails...
void	gl4dqCreatePurFromPoint (float *in, gl4dqQuaternion r)
	fonction qui créé un gl4dqQuaternion pur à partir d'un vecteur Plus de détails...
void	gl4dqRotatePoint (const gl4dqQuaternion q, float *in, float *out)
	fonction qui applique une rotation sur un vecteur à l'aide d'un gl4dqQuaternion Plus de détails...
void	gl4dqQuaternionToMatrix (const gl4dqQuaternion q, float *mat)
	fonction qui génère la matrice de rotation sur un vecteur à partir d'un gl4dqQuaternion Plus de détails...

Description détaillée

fonctions de manipulation de Quaternions

Auteur

Vincent Boyer boyer.nosp@m.@ai..nosp@m.univ-.nosp@m.pari.nosp@m.s8.fr

Sylvia Chalencon chale.nosp@m.ncon.nosp@m.@ai.u.nosp@m.niv-.nosp@m.paris.nosp@m.8.fr

Date

2013-2015

Définition dans le fichier gl4dq.c.

Documentation des fonctions

gl4dqComputeScalaire()

void gl4dqComputeScalaire

(

gl4dqQuaternion

q

)

fonction de calcul de la partie scalaire d'un gl4dqQuaternion unitaire où seule la partie imaginaire est donnée

Paramètres

q	un quaternion

                                            {
  float t = 1.0f - (q[1] * q[1]) - (q[2] * q[2]) - (q[3] * q[3]);
  q[0] = (t > 0) ? (float)-sqrt(t) : 0;
}

gl4dqConjugate()

void gl4dqConjugate	(	const gl4dqQuaternion	q,
		gl4dqQuaternion	conjugate
	)

fonction de calcul du conjugué d'un gl4dqQuaternion

Paramètres

q	un quaternion
conjugate	son conjugué

                                                                       {
  conjugate[0] = q[0];
  conjugate[1] = -q[1];
  conjugate[2] = -q[2];
  conjugate[3] = -q[3];
}

Référencé par gl4dqRotatePoint().

gl4dqCreatePurFromPoint()

void gl4dqCreatePurFromPoint	(	float *	v,
		gl4dqQuaternion	qr
	)

fonction qui créé un gl4dqQuaternion pur à partir d'un vecteur

Paramètres

v	un vecteur
qr	le quaternion pur

                                                          {
  r[0] = 0.0;
  r[1] = in[0];
  r[2] = in[1];
  r[3] = in[2];
}

Références in().

Référencé par gl4dqRotatePoint().

gl4dqMagnitude()

float gl4dqMagnitude

(

gl4dqQuaternion

q

)

fonction qui calcule la norme d'un gl4dqQuaternion

Paramètres

q	un quaternion

                                       {
  return (float)sqrt((q[0]*q[0])+(q[1]*q[1]) +(q[2]*q[2])+(q[3]*q[3]));
}

Référencé par gl4dqNormalize().

gl4dqMultiply()

void gl4dqMultiply	(	const gl4dqQuaternion	qa,
		const gl4dqQuaternion	qb,
		gl4dqQuaternion	qr
	)

fonction de calcul de la multiplication de deux gl4dqQuaternions

Paramètres

qa	premier quaternion
qb	second quaternion
qr	le quaternion résultant de la multiplication des deux précédents

                                                                                         {
 
  r[0] = qa[0]*qb[0] - qa[1]*qb[1] - qa[2]*qb[2] - qa[3]*qb[3];
  r[1] = qa[1]*qb[0] + qa[0]*qb[1] + qa[2]*qb[3] - qa[3]*qb[2];
  r[2] = qa[2]*qb[0] + qa[0]*qb[2] + qa[3]*qb[1] - qa[1]*qb[3];
  r[3] = qa[3]*qb[0] + qa[0]*qb[3] + qa[1]*qb[2] - qa[2]*qb[1];
}

Référencé par gl4dqRotatePoint().

gl4dqNormalize()

void gl4dqNormalize

(

gl4dqQuaternion

q

)

fonction qui transforme un gl4dqQuaternion en un gl4dqQuaternion unitaire

Paramètres

q	un quaternion

                                      {
  float mag = gl4dqMagnitude(q);
 
  if (mag > 0.0f) {
    q[0] /= mag;
    q[1] /= mag;
    q[2] /= mag;
    q[3] /= mag;
  }
}

Références gl4dqMagnitude().

Référencé par gl4daTrack().

gl4dqQuaternionToMatrix()

void gl4dqQuaternionToMatrix	(	const gl4dqQuaternion	q,
		float *	mat
	)

fonction qui génère la matrice de rotation sur un vecteur à partir d'un gl4dqQuaternion

Paramètres

q	un quaternion
mat	la matrice de rotation

                                                                   {
  float w = q[0], x = q[1], y = q[2], z = q[3];
  mat [0]  = 1 - 2*y*y -2*z*z ; mat [1]  = 2*x*y + 2*w*z    ; mat [2]  = 2*x*z - 2*w*y    ; mat [3]  = 0;
  mat [4]  = 2*x*y - 2*w*z    ; mat [5]  = 1 - 2*x*x -2*z*z ; mat [6]  = 2*y*z + 2*w*x    ; mat [7]  = 0;
  mat [8]  = 2*x*z + 2*w*y    ; mat [9]  = 2*y*z - 2*w*x    ; mat [10] = 1 - 2*x*x -2*y*y ; mat [11] = 0;
  mat [12] = 0                ; mat [13] = 0                ; mat [14] = 0                ; mat [15] = 1;
}

Références screen_node_t::w.

gl4dqRotatePoint()

void gl4dqRotatePoint	(	const gl4dqQuaternion	q,
		float *	vsrc,
		float *	vdst
	)

fonction qui applique une rotation sur un vecteur à l'aide d'un gl4dqQuaternion

Paramètres

q	un quaternion
vsrc	le vecteur source
vdst	le vecteur destination

                                                                      {
  gl4dqQuaternion conjugate, purfromin, r, final;
  
  gl4dqCreatePurFromPoint(in, purfromin);
  //gl4dqNormalize (purfromin);
  gl4dqConjugate(q, conjugate);
  gl4dqMultiply(q, purfromin, r);
  gl4dqMultiply(r, conjugate, final);
 
  out[0] = final[1];
  out[1] = final[2];
  out[2] = final[3];
}

Références gl4dqConjugate(), gl4dqCreatePurFromPoint(), gl4dqMultiply(), et in().