transformations.c

/*!\file transformations.c
 * \brief transformations spatiales pour un moteur de rendu basé raster "maison".
 *
 * CE CODE A ÉTÉ EN PARTIE RÉALISÉ LORS DE LA SÉANCE DE COURS. IL RESTE DES CHOSES À IMPLÉMENTER OU À OPTIMISER.
 *
 * \author Farès BELHADJ, amsi@up8.edu
 * \date November 24, 2020.
 *
 * \todo COMPLÉTER LE CLIPPING POUR GÉRER ICI LES TRIANGLES
 * PARTIELLEMENT HORS-CHAMP ET ÉVITER DES TESTS GOURMANDS DANS \ref
 * primitives.c
 */
#include "moteur.h"
#include <assert.h>

/* fonctions locale (static) */
static inline void clip2UnitCube(triangle_t * t);

/*!\brief projette le sommet \a v à l'écran (le \a viewport) selon la
   matrice de model-view \a mvMat et de projection \a projMat. \a
   timvMat est la transposée de l'inverse de la matrice \a mvMat.*/
vertex_t vtransform(surface_t * s, vertex_t v, float * mvMat, float * timvMat, float * projMat, float * viewport) {
  float dist = 1.0f;
  vec4 r1, r2;
  v.state = PS_NONE;
  MMAT4XVEC4((float *)&r1, mvMat, (float *)&(v.position));
  MMAT4XVEC4((float *)&r2, projMat, (float *)&r1);
  r2.x /= r2.w;
  r2.y /= r2.w;
  r2.z /= r2.w;
  r2.w = 1.0f;
  /* dist doit être à 1 ci-après */
  if(r2.x < -dist) v.state |= PS_OUT_LEFT;
  if(r2.x >  dist) v.state |= PS_OUT_RIGHT;
  if(r2.y < -dist) v.state |= PS_OUT_BOTTOM;
  if(r2.y >  dist) v.state |= PS_OUT_TOP;
  if(r2.z < -dist) v.state |= PS_OUT_NEAR;
  if(r2.z >  dist) v.state |= PS_OUT_FAR;
  /* "hack" pas terrible permettant d'éviter les gros triangles
     partiellement hors-champ. Modifier dist pour jouer sur la taille
     (une fois projetés) des triangles qu'on laisse passer (plus c'est
     gros plus c'est lent avec les gros triangles). La "vraie"
     solution est obtenue en calculant l'intersection exacte entre le
     triangle et le cube unitaire ; attention, ceci produit
     potentiellement une nouvelle liste de triangles à chaque frame,
     et les attributs des sommets doivent être recalculés. */
  dist = 10.0f;
  if(r2.x < -dist || r2.x > dist || r2.y < -dist || r2.y > dist || r2.z < -dist || r2.z > dist) {
    v.state |= PS_TOO_FAR;
    return v;
  }
  /* Gouraud */
  if(s->options & SO_USE_LIGHTING) {
    /* la lumière est positionnelle et fixe dans la scène. \todo dans
       scene.c la rendre modifiable, voire aussi pouvoir la placer par
       rapport aux objets (elle subirait la matrice modèle). */
    const vec4 lp[1] = { {0.0f, 0.0f, 1.0f} };
    vec4 ld = {lp[0].x - r1.x, lp[0].y - r1.y, lp[0].z - r1.z, lp[0].w - r1.w};
    float n[4] = {v.normal.x, v.normal.y, v.normal.z, 0.0f}, res[4];
    MMAT4XVEC4(res, timvMat, n);
    MVEC3NORMALIZE(res);
    MVEC3NORMALIZE((float *)&ld);
    v.li = MVEC3DOT(res, (float *)&ld);
    v.li = MIN(MAX(0.0f, v.li), 1.0f);
  } else
    v.li = 1.0f;
  v.icolor = v.color0;
  /* Mapping du cube unitaire vers l'écran */
  v.x = viewport[0] + ((r2.x + 1.0f) * 0.5f) * (viewport[2] - EPSILON);
  v.y = viewport[1] + ((r2.y + 1.0f) * 0.5f) * (viewport[3] - EPSILON);
  v.z = pow((-r2.z + 1.0f) * 0.5f, 0.5);
  /* sinon pour near = 0.1f et far = 10.0f on peut rendre non linéaire la depth avec */
  /* v.z = 1.0f - (1.0f / r2.z - 1.0f / 0.1f) / (1.0f / 10.0f - 1.0f / 0.1f); */
  v.zmod = r1.z;
  return v;
}

/*!\brief projette le triangle \a t à l'écran (\a W x \a H) selon la
 * matrice de model-view \a mvMat et de projection \a projMat.
 *
 * Cette fonction utilise \a vtransform sur chaque sommet de la
 * surface. Elle utilise aussi \a clip2UnitCube pour connaître l'état
 * du triangle par rapport au cube unitaire.
 *
 * \see vtransform 
 * \see clip2UnitCube
 */
void stransform(surface_t * s, float * mvMat, float * projMat, float * viewport) {
  int i, j;
  float timvMat[16];
  triangle_t vcull;
  /* calcul de la transposée de l'inverse de la matrice model-view
     pour la transformation des normales et le calcul du lambertien
     utilisé par le shading Gouraud dans vtransform. */
  memcpy(timvMat, mvMat, sizeof timvMat);
  MMAT4INVERSE(timvMat);
  MMAT4TRANSPOSE(timvMat);
  for(i = 0; i < s->n; ++i) {
    s->t[i].state = PS_NONE;
    for(j = 0; j < 3; ++j) {
      s->t[i].v[j] = vtransform(s, s->t[i].v[j], mvMat, timvMat, projMat, viewport);
      if(s->options & SO_CULL_BACKFACES) {
	vcull.v[j].position.x = s->t[i].v[j].x;
	vcull.v[j].position.y = s->t[i].v[j].y;
	vcull.v[j].position.z = 0.0f;
      }
    }
    if(s->options & SO_CULL_BACKFACES) {
      tnormal(&vcull);
      if(vcull.normal.z <= 0.0f) {
	s->t[i].state |= PS_CULL;
	continue;
      }
    }
    clip2UnitCube(&(s->t[i]));
  }
}

/*!\brief multiplie deux matrices : \a res = \a res x \a m */
void multMatrix(float * res, float * m) {
  /* res = res x m */
  float cpy[16];
  memcpy(cpy, res, sizeof cpy);
  MMAT4XMAT4(res, cpy, m);
}

/*!\brief ajoute (multiplication droite) une translation à la matrice
 * \a m */
void translate(float * m, float tx, float ty, float tz) {
  float mat[] = { 1.0f, 0.0f, 0.0f, tx,
		  0.0f, 1.0f, 0.0f, ty,
		  0.0f, 0.0f, 1.0f, tz,
		  0.0f, 0.0f, 0.0f, 1.0f };
  multMatrix(m, mat);
}

/*!\brief ajoute (multiplication droite) une rotation à la matrice \a
 * m */
void rotate(float * m, float angle, float x, float y, float z) {
  float n = sqrtf(x * x + y * y + z * z);
  if ( n > 0.0f ) {
    float a, s, c, cc, x2, y2, z2, xy, yz, zx, xs, ys, zs;
    float mat[] = { 0.0f, 0.0f, 0.0f, 0.0f,
		    0.0f, 0.0f, 0.0f, 0.0f,
		    0.0f, 0.0f, 0.0f, 0.0f,
		    0.0f, 0.0f, 0.0f, 1.0f };
    s  = sinf ( a = (angle * (float)M_PI / 180.0f) );
    cc = 1.0f - (c = cosf ( a ));
    x /= n;     y /= n;     z /= n;
    x2 = x * x; y2 = y * y; z2 = z * z;
    xy = x * y; yz = y * z; zx = z * x;
    xs = x * s; ys = y * s; zs = z * s;
    mat[0]  = (cc * x2) + c;
    mat[1]  = (cc * xy) - zs;
    mat[2]  = (cc * zx) + ys;
    /* mat[3]  = 0.0f; */
    mat[4]  = (cc * xy) + zs;
    mat[5]  = (cc * y2) + c;
    mat[6]  = (cc * yz) - xs;
    /* mat[7]  = 0.0f; */
    mat[8]  = (cc * zx) - ys;
    mat[9]  = (cc * yz) + xs;
    mat[10] = (cc * z2) + c;
    /* mat[11] = 0.0f; */
    /* mat[12] = 0.0f; mat[= 0.0f; mat[14] = 0.0f; mat[15] = 1.0f; */
    multMatrix(m, mat);
  }
}

/*!\brief ajoute (multiplication droite) un scale à la matrice \a m */
void scale(float * m, float sx, float sy, float sz) {
  float mat[] = { sx  , 0.0f, 0.0f, 0.0f,
		  0.0f,   sy, 0.0f, 0.0f,
		  0.0f, 0.0f,   sz, 0.0f,
		  0.0f, 0.0f, 0.0f, 1.0f };
  multMatrix(m, mat);
}

/*!\brief simule une free camera, voir la doc de gluLookAt */
void lookAt(float * m, float eyeX, float eyeY, float eyeZ, float centerX, float centerY, float centerZ, float upX, float upY, float upZ) {
  float forward[3], side[3], up[3];
  float mat[] = {
		 1.0f,       0.0f,       0.0f,       0.0f,
		 0.0f,       1.0f,       0.0f,       0.0f,
		 0.0f,       0.0f,       1.0f,       0.0f,
		 0.0f,       0.0f,       0.0f,       1.0f
  };
  forward[0] = centerX - eyeX;
  forward[1] = centerY - eyeY;
  forward[2] = centerZ - eyeZ;
  up[0] = upX;
  up[1] = upY;
  up[2] = upZ;
  MVEC3NORMALIZE(forward);
  /* side = forward x up */
  MVEC3CROSS(side, forward, up);
  MVEC3NORMALIZE(side);
  /* up = side x forward */
  MVEC3CROSS(up, side, forward);
  mat[0] = side[0];
  mat[1] = side[1];
  mat[2] = side[2];
  mat[4] = up[0];
  mat[5] = up[1];
  mat[6] = up[2];
  mat[8] = -forward[0];
  mat[9] = -forward[1];
  mat[10] = -forward[2];
  multMatrix(m, mat);
  translate(m, -eyeX, -eyeY, -eyeZ);
}

/*!\brief intersection triangle-cube unitaire, à compléter (voir le
 * todo du fichier et le commentaire dans le code) */
void clip2UnitCube(triangle_t * t) {
    int i, oleft = 0, oright = 0, obottom = 0, otop = 0, onear = 0, ofar = 0;
    for (i = 0; i < 3; ++i) {
      if(t->v[i].state & PS_OUT_LEFT) ++oleft;
      if(t->v[i].state & PS_OUT_RIGHT) ++oright;
      if(t->v[i].state & PS_OUT_BOTTOM) ++obottom;
      if(t->v[i].state & PS_OUT_TOP) ++otop;
      if(t->v[i].state & PS_OUT_NEAR) ++onear;
      if(t->v[i].state & PS_OUT_FAR) ++ofar;
    }
    if(!(oleft | oright | obottom | otop | onear | ofar))
      return;
    if(oleft == 3 || oright == 3 || obottom == 3 || otop == 3 || onear == 3 || ofar == 3) {
      t->state |= PS_TOTALLY_OUT;
      return;
    }
    t->state |= PS_PARTIALLY_OUT;
    /* le cas PARTIALLY_OUT n'est pas réellement géré. Il serait
       nécessaire à partir d'ici de construire la liste des triangles
       qui repésentent l'intersection entre le triangle d'origine et
       le cube unitaire. Ceci permettrait de ne plus avoir besoin de
       tester si le pixel produit par le raster est bien dans le
       "screen" avant d'écrire ; et aussi de se passer du "hack"
       PS_TOO_FAR qui est problématique.  Vous pouvez vous inspirer de
       ce qui est fait là :
       https://github.com/erich666/GraphicsGems/blob/master/gems/PolyScan/poly_clip.c
       en le ramenant au cas d'un triangle.
    */
}