macros et fonctions liées aux calculs mathématiques propres à l'utilisation de GL4Dummies. Plus de détails...

#include "gl4dummies.h"
#include <math.h>
#include <assert.h>
#include "gl4dm.inl"

Graphe des dépendances par inclusion de gl4dm.h:

Ce graphe montre quels fichiers incluent directement ou indirectement ce fichier :

Structures de données
struct	GL4DMVector
	Méthodes alternative utilisant des fonctions inline (compatible seulement a partir de la norme c99) Plus de détails...

struct	GL4DMMatrix

Macros
#define	GL4DM_E 2.7182818284590452354

#define	GL4DM_LOG2E 1.4426950408889634074

#define	GL4DM_LOG10E 0.43429448190325182765

#define	GL4DM_LN2 0.69314718055994530942

#define	GL4DM_LN10 2.30258509299404568402

#define	GL4DM_PI 3.14159265358979323846

#define	GL4DM_PI_2 1.57079632679489661923

#define	GL4DM_PI_4 0.78539816339744830962

#define	GL4DM_PI_180 0.01745329251994329576

#define	GL4DM_1_PI 0.31830988618379067154

#define	GL4DM_2_PI 0.63661977236758134308

#define	GL4DM_2_SQRTPI 1.12837916709551257390

#define	GL4DM_SQRT2 1.41421356237309504880

#define	GL4DM_SQRT1_2 0.70710678118654752440

#define	GL4DM_EPSILON 1.19209290e-07F

#define	MIN(a, b) (((a) < (b)) ? (a) : (b))

#define	MAX(a, b) (((a) > (b)) ? (a) : (b))

#define	SIGN(i) ((i) < 0 ? -1 : 1)

#define	SQUARE(X) ((X)*(X))

#define	COTANGENT(X) (cos(X)/sin(X))

#define	RADIAN(X) (GL4DM_PI * (X) / 180)

#define	MMAT4XMAT4(r, a, b)
	Multiplication de deux matrices 4x4. Les matrices a et b sont multipliées et le résultat est stocké dans r. Plus de détails...

#define	MMAT4XVEC4(r, m, v)
	Multiplication d'une matrices 4x4 par un vecteur. La matrice m et le vecteur v sont multipliés et le résultat est stocké dans le vecteur r. Plus de détails...

#define	MVEC4WEIGHT(v)
	divise les composantes x, y et z du vecteur v par sa composante w et remet w à 1. Plus de détails...

#define	MMAT4TRANSPOSE(m)
	Transposée de la matrice 4x4 m. Plus de détails...

#define	MMAT4INVERSE(m)
	Inverse de la matrice 4x4 m. Plus de détails...

#define	MVEC3CROSS(r, u, v)
	Produit vectoriel 3D entre u et v écrit dans r. Plus de détails...

#define	MVEC4CROSS(r, u, v)
	Produit vectoriel 3D entre u et v écrit dans r avec un 1.0 pour la 4ème dimension de r. Plus de détails...

#define	MVEC2DOT(u, v) ((u)[0] * (v)[0] + (u)[1] * (v)[1])
	Renvoie le produit scalaire entre deux vecteurs 2D entre u et v. Plus de détails...

#define	MVEC3DOT(u, v) ((u)[0] * (v)[0] + (u)[1] * (v)[1] + (u)[2] * (v)[2])
	Renvoie le produit scalaire entre deux vecteurs 3D entre u et v. Plus de détails...

#define	MVEC4DOT(u, v) ((u)[0] * (v)[0] + (u)[1] * (v)[1] + (u)[2] * (v)[2] + (u)[3] * (v)[3])
	Renvoie le produit scalaire entre deux vecteurs 4D entre u et v. Plus de détails...

#define	MVEC4NORMALIZE(v)
	Normalise le vecteur 4D v. Plus de détails...

#define	MVEC3NORMALIZE(v)
	Normalise le vecteur 3D v. Plus de détails...

#define	MVEC2NORMALIZE(v)
	Normalise le vecteur 2D v. Plus de détails...

#define	MFRUSTUM(mat, l, r, b, t, n, f)
	Création d'une matrice de projection en perspective selon l'ancienne fonction glFrustum. Plus de détails...

#define	MORTHO(mat, l, r, b, t, n, f)
	Création d'une matrice de projection orthogonale selon l'ancienne fonction glOrtho. Plus de détails...

#define	MPERSPECTIVE(mat, fovy, aspect, zNear, zFar)
	Création d'une matrice de projection en perspective selon l'ancienne fonction gluPerspective. Plus de détails...

#define	MIDENTITY(m)
	Chargement d'une matrice identitéé dans m. Plus de détails...

Fonctions
GL4DAPI double GL4DAPIENTRY	gl4dmURand (void)
	Retourne un nombre pseudo-aleatoire dans l'intervalle [0, 1[. Ici la distribution est uniforme. Plus de détails...

GL4DAPI double GL4DAPIENTRY	gl4dmSURand (void)
	Retourne un nombre pseudo-aleatoire dans l'intervalle [-1, 1[. Ici la distribution est uniforme. Plus de détails...

GL4DAPI double GL4DAPIENTRY	gl4dmGRand (void)
	Retourne un nombre pseudo-aleatoire dans l'intervalle ]-7, +7[. Ici la distribution est Gaussienne. Plus de détails...

GL4DAPI double GL4DAPIENTRY	gl4dmGURand (void)
	Retourne un nombre pseudo-aleatoire dans l'intervalle [-1, +1[. Ici la distribution est Gaussienne centrée en zéro. Plus de détails...

GL4DAPI GLfloat *GL4DAPIENTRY	gl4dmTriangleEdge (GLuint width, GLuint height, GLfloat H)
	génère une heightmap en utilisant l'algorithme du triangle-edge. Les valeurs retournées dans la map sont comprises entre 0 et 1. Plus de détails...

Description détaillée

macros et fonctions liées aux calculs mathématiques propres à l'utilisation de GL4Dummies.

Auteur: Farès BELHADJ amsi@.nosp@m.ai.u.nosp@m.niv-p.nosp@m.aris.nosp@m.8.fr

Date: November 12, 2014

A faire:: voir ce qui est fait avec les w des vec4 et corriger toutes les macros si nécessaire.

Définition dans le fichier gl4dm.h.

Documentation des macros

◆ COTANGENT

#define COTANGENT ( X ) (cos(X)/sin(X))

◆ GL4DM_1_PI

#define GL4DM_1_PI 0.31830988618379067154

◆ GL4DM_2_PI

#define GL4DM_2_PI 0.63661977236758134308

◆ GL4DM_2_SQRTPI

#define GL4DM_2_SQRTPI 1.12837916709551257390

◆ GL4DM_E

#define GL4DM_E 2.7182818284590452354

◆ GL4DM_EPSILON

#define GL4DM_EPSILON 1.19209290e-07F

◆ GL4DM_LN10

#define GL4DM_LN10 2.30258509299404568402

◆ GL4DM_LN2

#define GL4DM_LN2 0.69314718055994530942

◆ GL4DM_LOG10E

#define GL4DM_LOG10E 0.43429448190325182765

◆ GL4DM_LOG2E

#define GL4DM_LOG2E 1.4426950408889634074

◆ GL4DM_PI

#define GL4DM_PI 3.14159265358979323846

◆ GL4DM_PI_180

#define GL4DM_PI_180 0.01745329251994329576

◆ GL4DM_PI_2

#define GL4DM_PI_2 1.57079632679489661923

◆ GL4DM_PI_4

#define GL4DM_PI_4 0.78539816339744830962

◆ GL4DM_SQRT1_2

#define GL4DM_SQRT1_2 0.70710678118654752440

◆ GL4DM_SQRT2

#define GL4DM_SQRT2 1.41421356237309504880

◆ MAX

#define MAX	(	a,
		b
	)	(((a) > (b)) ? (a) : (b))

◆ MFRUSTUM

#define MFRUSTUM	(	mat,
		l,
		r,
		b,
		t,
		n,
		f
	)

Valeur :

    do {        \
    (mat)[0]  = 2.0 * (n) / ((r) - (l));        \
    (mat)[1]  = 0.0;                    \
    (mat)[2]  = ((r) + (l)) / ((r) - (l));      \
    (mat)[3]  = 0.0;                    \
    (mat)[4]  = 0.0;                    \
    (mat)[5]  = 2.0 * (n) / ((t) - (b));        \
    (mat)[6]  = ((t) + (b)) / ((t) - (b));      \
    (mat)[7]  = 0.0;                    \
    (mat)[8]  = 0.0;                    \
    (mat)[9]  = 0.0;                    \
    (mat)[10] = -((f) + (n)) / ((f) - (n));     \
    (mat)[11] = -2.0 * (f) * (n) / ((f) - (n));     \
    (mat)[12] = 0.0;                    \
    (mat)[13] = 0.0;                    \
    (mat)[14] = -1.0;                   \
    (mat)[15] = 0.0;                    \
  } while(0)

Création d'une matrice de projection en perspective selon l'ancienne fonction glFrustum.

◆ MIDENTITY

#define MIDENTITY ( m )

Valeur :

    do {                        \
    (m)[1] = (m)[2] = (m)[3] = (m)[4] = (m)[6] = (m)[7] = (m)[8] = (m)[9] = (m)[11] = (m)[12] = (m)[13] = (m)[14] = 0.0; \
    (m)[0] = (m)[5] = (m)[10] = (m)[15] = 1.0;              \
  } while(0)

Chargement d'une matrice identitéé dans m.

◆ MIN

#define MIN	(	a,
		b
	)	(((a) < (b)) ? (a) : (b))

◆ MMAT4INVERSE

#define MMAT4INVERSE ( m )

Inverse de la matrice 4x4 m.

◆ MMAT4TRANSPOSE

#define MMAT4TRANSPOSE ( m )

Valeur :

    do {                \
    double t;                       \
    t = (m)[1];  (m)[1]  = (m)[4];  (m)[4]  = t;    \
    t = (m)[2];  (m)[2]  = (m)[8];  (m)[8]  = t;    \
    t = (m)[3];  (m)[3]  = (m)[12]; (m)[12] = t;    \
    t = (m)[6];  (m)[6]  = (m)[9];  (m)[9]  = t;    \
    t = (m)[7];  (m)[7]  = (m)[13]; (m)[13] = t;    \
    t = (m)[11]; (m)[11] = (m)[14]; (m)[14] = t;    \
  } while(0)

Transposée de la matrice 4x4 m.

◆ MMAT4XMAT4

#define MMAT4XMAT4	(	r,
		a,
		b
	)

Valeur :

    do {                    \
    (r)[0]  = (a)[0]  * (b)[0] + (a)[1]  * (b)[4] + (a)[2]  * (b)[8]  + (a)[3]  * (b)[12]; \
    (r)[1]  = (a)[0]  * (b)[1] + (a)[1]  * (b)[5] + (a)[2]  * (b)[9]  + (a)[3]  * (b)[13]; \
    (r)[2]  = (a)[0]  * (b)[2] + (a)[1]  * (b)[6] + (a)[2]  * (b)[10] + (a)[3]  * (b)[14]; \
    (r)[3]  = (a)[0]  * (b)[3] + (a)[1]  * (b)[7] + (a)[2]  * (b)[11] + (a)[3]  * (b)[15]; \
    (r)[4]  = (a)[4]  * (b)[0] + (a)[5]  * (b)[4] + (a)[6]  * (b)[8]  + (a)[7]  * (b)[12]; \
    (r)[5]  = (a)[4]  * (b)[1] + (a)[5]  * (b)[5] + (a)[6]  * (b)[9]  + (a)[7]  * (b)[13]; \
    (r)[6]  = (a)[4]  * (b)[2] + (a)[5]  * (b)[6] + (a)[6]  * (b)[10] + (a)[7]  * (b)[14]; \
    (r)[7]  = (a)[4]  * (b)[3] + (a)[5]  * (b)[7] + (a)[6]  * (b)[11] + (a)[7]  * (b)[15]; \
    (r)[8]  = (a)[8]  * (b)[0] + (a)[9]  * (b)[4] + (a)[10] * (b)[8]  + (a)[11] * (b)[12]; \
    (r)[9]  = (a)[8]  * (b)[1] + (a)[9]  * (b)[5] + (a)[10] * (b)[9]  + (a)[11] * (b)[13]; \
    (r)[10] = (a)[8]  * (b)[2] + (a)[9]  * (b)[6] + (a)[10] * (b)[10] + (a)[11] * (b)[14]; \
    (r)[11] = (a)[8]  * (b)[3] + (a)[9]  * (b)[7] + (a)[10] * (b)[11] + (a)[11] * (b)[15]; \
    (r)[12] = (a)[12] * (b)[0] + (a)[13] * (b)[4] + (a)[14] * (b)[8]  + (a)[15] * (b)[12]; \
    (r)[13] = (a)[12] * (b)[1] + (a)[13] * (b)[5] + (a)[14] * (b)[9]  + (a)[15] * (b)[13]; \
    (r)[14] = (a)[12] * (b)[2] + (a)[13] * (b)[6] + (a)[14] * (b)[10] + (a)[15] * (b)[14]; \
    (r)[15] = (a)[12] * (b)[3] + (a)[13] * (b)[7] + (a)[14] * (b)[11] + (a)[15] * (b)[15]; \
  } while(0)

Multiplication de deux matrices 4x4. Les matrices a et b sont multipliées et le résultat est stocké dans r.

◆ MMAT4XVEC4

#define MMAT4XVEC4	(	r,
		m,
		v
	)

Valeur :

    do {                    \
    (r)[0]  = (m)[0]  * (v)[0] + (m)[1]  * (v)[1] + (m)[2]  * (v)[2]  + (m)[3]  * (v)[3]; \
    (r)[1]  = (m)[4]  * (v)[0] + (m)[5]  * (v)[1] + (m)[6]  * (v)[2]  + (m)[7]  * (v)[3]; \
    (r)[2]  = (m)[8]  * (v)[0] + (m)[9]  * (v)[1] + (m)[10] * (v)[2]  + (m)[11] * (v)[3]; \
    (r)[3]  = (m)[12] * (v)[0] + (m)[13] * (v)[1] + (m)[14] * (v)[2]  + (m)[15] * (v)[3]; \
  } while(0)

Multiplication d'une matrices 4x4 par un vecteur. La matrice m et le vecteur v sont multipliés et le résultat est stocké dans le vecteur r.

◆ MORTHO

#define MORTHO	(	mat,
		l,
		r,
		b,
		t,
		n,
		f
	)

Valeur :

    do {        \
    (mat)[0]  = 2.0 / ((r) - (l));              \
    (mat)[1]  = 0.0;                    \
    (mat)[2]  = 0.0;                    \
    (mat)[3]  = -((r) + (l)) / ((r) - (l));     \
    (mat)[4]  = 0.0;                    \
    (mat)[5]  = 2.0 / ((t) - (b));              \
    (mat)[6]  = 0.0;                    \
    (mat)[7]  = -((t) + (b)) / ((t) - (b));     \
    (mat)[8]  = 0.0;                    \
    (mat)[9]  = 0.0;                    \
    (mat)[10] = -2.0 / ((f) - (n));             \
    (mat)[11] = -((f) + (n)) / ((f) - (n));     \
    (mat)[12] = 0.0;                    \
    (mat)[13] = 0.0;                    \
    (mat)[14] = 0.0;                    \
    (mat)[15] = 1.0;                    \
  } while(0)

Création d'une matrice de projection orthogonale selon l'ancienne fonction glOrtho.

◆ MPERSPECTIVE

#define MPERSPECTIVE	(	mat,
		fovy,
		aspect,
		zNear,
		zFar
	)

Valeur :

  do {      \
  memset((perspective), 0, sizeof(perspective));                        \
  (perspective)[0]  = (1.0/tan((fovy) * GL4DM_PI_180 / 2.0))/(aspect);  \
  (perspective)[5]  = 1.0/tan((fovy) * GL4DM_PI_180 / 2.0);     \
  (perspective)[10] = ((zFar)+(zNear)) / ((zNear)-(zFar));      \
  (perspective)[11] = 2*(zFar)*(zNear)/((zNear)-(zFar));        \
  (perspective)[14] = -1;                                               \
  } while(0)

Création d'une matrice de projection en perspective selon l'ancienne fonction gluPerspective.

◆ MVEC2DOT

#define MVEC2DOT	(	u,
		v
	)	((u)[0] * (v)[0] + (u)[1] * (v)[1])

Renvoie le produit scalaire entre deux vecteurs 2D entre u et v.

◆ MVEC2NORMALIZE

#define MVEC2NORMALIZE ( v )

Valeur :

    do {                        \
    double n = sqrt((v)[0] * (v)[0] + (v)[1] * (v)[1]);         \
    if(n > 0) {                             \
      (v)[0] /= n;                          \
      (v)[1] /= n;                          \
    }                                   \
  } while(0)

Normalise le vecteur 2D v.

◆ MVEC3CROSS

#define MVEC3CROSS	(	r,
		u,
		v
	)

Valeur :

    do {        \
    (r)[0] = (u)[1] * (v)[2] - (u)[2] * (v)[1]; \
    (r)[1] = (u)[2] * (v)[0] - (u)[0] * (v)[2]; \
    (r)[2] = (u)[0] * (v)[1] - (u)[1] * (v)[0]; \
  } while(0)

Produit vectoriel 3D entre u et v écrit dans r.

◆ MVEC3DOT

#define MVEC3DOT	(	u,
		v
	)	((u)[0] * (v)[0] + (u)[1] * (v)[1] + (u)[2] * (v)[2])

Renvoie le produit scalaire entre deux vecteurs 3D entre u et v.

◆ MVEC3NORMALIZE

#define MVEC3NORMALIZE ( v )

Valeur :

    do {                        \
    double MVEC4NORMALIZE_n = sqrt((v)[0] * (v)[0] + (v)[1] * (v)[1] + (v)[2] * (v)[2]); \
    if(MVEC4NORMALIZE_n > 0) {                      \
      (v)[0] /= MVEC4NORMALIZE_n;                   \
      (v)[1] /= MVEC4NORMALIZE_n;                   \
      (v)[2] /= MVEC4NORMALIZE_n;                   \
    }                                   \
  } while(0)

Normalise le vecteur 3D v.

◆ MVEC4CROSS

#define MVEC4CROSS	(	r,
		u,
		v
	)

Valeur :

    do {        \
    MVEC3CROSS(r, u, v);            \
    (r)[3] = 1.0;               \
  } while(0)

Produit vectoriel 3D entre u et v écrit dans r avec un 1.0 pour la 4ème dimension de r.

◆ MVEC4DOT

#define MVEC4DOT	(	u,
		v
	)	((u)[0] * (v)[0] + (u)[1] * (v)[1] + (u)[2] * (v)[2] + (u)[3] * (v)[3])

Renvoie le produit scalaire entre deux vecteurs 4D entre u et v.

◆ MVEC4NORMALIZE

#define MVEC4NORMALIZE ( v )

Valeur :

    do {                        \
    double MVEC4NORMALIZE_n = sqrt((v)[0] * (v)[0] + (v)[1] * (v)[1] + (v)[2] * (v)[2] + (v)[3] * (v)[3]); \
    if(MVEC4NORMALIZE_n > 0) {                      \
      (v)[0] /= MVEC4NORMALIZE_n;                   \
      (v)[1] /= MVEC4NORMALIZE_n;                   \
      (v)[2] /= MVEC4NORMALIZE_n;                   \
      (v)[3] /= MVEC4NORMALIZE_n;                   \
    }                                   \
  } while(0)

Normalise le vecteur 4D v.

◆ MVEC4WEIGHT

#define MVEC4WEIGHT ( v )

Valeur :

    do {            \
    (v)[0] /= (v)[3];               \
    (v)[1] /= (v)[3];               \
    (v)[2] /= (v)[3];               \
    (v)[3]  = 1.0;              \
  } while(0)

divise les composantes x, y et z du vecteur v par sa composante w et remet w à 1.

◆ RADIAN

#define RADIAN ( X ) (GL4DM_PI * (X) / 180)

◆ SIGN

#define SIGN ( i ) ((i) < 0 ? -1 : 1)

◆ SQUARE

#define SQUARE ( X ) ((X)*(X))

Documentation des fonctions

◆ gl4dmGRand()

GL4DAPI double GL4DAPIENTRY gl4dmGRand ( void )

Retourne un nombre pseudo-aleatoire dans l'intervalle ]-7, +7[. Ici la distribution est Gaussienne.

Tire du knuth : le rand Gaussien a deux valeurs par passe deux rand : X1 et X2.

Renvoie: un nombre pseudo-aleatoire selon une distribution gaussienne dans l'intervalle ]-7, +7[ (expérimentalement dans [-6.997568, 6.882738])

                         {
   static int haveX2 = 0;
   static double X2 = 0.0;
   if (haveX2) {
     haveX2 = 0;
     return X2;
   } else {
     double V1, V2, S, precomp;
     do {
       V1 = 2.0 * (rand() / (double)RAND_MAX) - 1.0;
       V2 = 2.0 * (rand() / (double)RAND_MAX) - 1.0;
       S = V1 * V1 + V2 * V2;
     } while (S >= 1.0);
     if(S == 0.0) return (X2 = !((haveX2 = 1)));
     precomp = sqrt(-2.0 * log(S) / S);
     X2 = V2 * precomp;
     haveX2 = 1;
     return V1 * precomp; /* X1 */
   }
 }

Référencé par gl4dmGURand().

◆ gl4dmGURand()

GL4DAPI double GL4DAPIENTRY gl4dmGURand ( void )

Retourne un nombre pseudo-aleatoire dans l'intervalle [-1, +1[. Ici la distribution est Gaussienne centrée en zéro.

Renvoie: un nombre pseudo-aleatoire selon une distribution gaussienne dans l'intervalle ]-1, +1[

                          {
   return gl4dmGRand() / 7.0;
 }

Références gl4dmGRand().

◆ gl4dmSURand()

GL4DAPI double GL4DAPIENTRY gl4dmSURand ( void )

Retourne un nombre pseudo-aleatoire dans l'intervalle [-1, 1[. Ici la distribution est uniforme.

Renvoie: un nombre pseudo-aleatoire dans l'intervalle [-1, 1[.

                          {
   return 2.0 * (rand() / (RAND_MAX + 1.0)) - 1.0;
 }

Référencé par setDimensions(), et triangle_edge().

◆ gl4dmTriangleEdge()

GL4DAPI GLfloat* GL4DAPIENTRY gl4dmTriangleEdge	(	GLuint	width,
		GLuint	height,
		GLfloat	H
	)

génère une heightmap en utilisant l'algorithme du triangle-edge. Les valeurs retournées dans la map sont comprises entre 0 et 1.

Paramètres

width	la largeur de la heightmap
height	la hauteur de la heightmap
H	exposant de Hurst, permet de controler la dimension fractale de la heightmap. La valeur standard est 0.5 (sinon entre 0 et 1)

Renvoie: la heightmap allouée/générée et qu'il faudra libérer avec free.

                                                                     {
   GLfloat * hm = calloc(width * height, sizeof *hm);
   assert(hm);
   hm[0] = GL4DM_EPSILON + gl4dmURand();
   hm[width - 1] = GL4DM_EPSILON + gl4dmURand();
   hm[(height - 1) * width + width - 1] = GL4DM_EPSILON + gl4dmURand();
   hm[(height - 1) * width] = GL4DM_EPSILON + gl4dmURand();
   triangle_edge(hm, 0, 0, width - 1, height - 1, width, 1, H);
   return hm;
 }

Références GL4DM_EPSILON, gl4dmURand(), et triangle_edge().

◆ gl4dmURand()

GL4DAPI double GL4DAPIENTRY gl4dmURand ( void )

Retourne un nombre pseudo-aleatoire dans l'intervalle [0, 1[. Ici la distribution est uniforme.

Renvoie: un nombre pseudo-aleatoire dans l'intervalle [0, 1[.

                         {
   return (rand() / (RAND_MAX + 1.0));
 }

Référencé par gl4dmTriangleEdge().

Structures de données

Macros

Fonctions

Description détaillée

Documentation des macros

◆ COTANGENT

◆ GL4DM_1_PI

◆ GL4DM_2_PI

◆ GL4DM_2_SQRTPI

◆ GL4DM_E

◆ GL4DM_EPSILON

◆ GL4DM_LN10

◆ GL4DM_LN2

◆ GL4DM_LOG10E

◆ GL4DM_LOG2E

◆ GL4DM_PI

◆ GL4DM_PI_180

◆ GL4DM_PI_2

◆ GL4DM_PI_4

◆ GL4DM_SQRT1_2

◆ GL4DM_SQRT2

◆ MAX

◆ MFRUSTUM

◆ MIDENTITY

◆ MIN

◆ MMAT4INVERSE

◆ MMAT4TRANSPOSE

◆ MMAT4XMAT4

◆ MMAT4XVEC4

◆ MORTHO

◆ MPERSPECTIVE

◆ MVEC2DOT

◆ MVEC2NORMALIZE

◆ MVEC3CROSS

◆ MVEC3DOT

◆ MVEC3NORMALIZE

◆ MVEC4CROSS

◆ MVEC4DOT

◆ MVEC4NORMALIZE

◆ MVEC4WEIGHT

◆ RADIAN

◆ SIGN

◆ SQUARE

Documentation des fonctions

◆ gl4dmGRand()

◆ gl4dmGURand()

◆ gl4dmSURand()

◆ gl4dmTriangleEdge()

◆ gl4dmURand()