Added changes in /S9GB/MODIF1/window.c on expreg.org for the board and the character

window.c

@@ -1,12 +1,6 @@
 /*!\file window.c
- * \brief Utilisation du raster DIY comme pipeline de rendu 3D. Cet
- * exemple montre les géométries disponibles et quelques
- * transformations dessus.
  * \author Farès BELHADJ, amsi@up8.edu
  * \date November 16, 2021.
- * \todo exercice intéressant à faire : changer la variation de
- * l'angle de rotation pour qu'il soit dépendant du temps et non du
- * framerate
  */
 #include <assert.h>
 /* inclusion des entêtes de fonctions de gestion de primitives simples
@@ -23,22 +17,49 @@
 
 /* protos de fonctions locales (static) */
 static void init(void);
+static void idle(void);
 static void draw(void);
-static void key(int keycode);
+static void keyu(int keycode);
+static void keyd(int keycode);
 static void sortie(void);
 
-/*!\brief une surface représentant un quadrilatère */
-static surface_t * _quad = NULL;
 /*!\brief une surface représentant un cube */
 static surface_t * _cube = NULL;
-/*!\brief une surface représentant une sphere */
+static float _cubeSize = 4.0f;
-static surface_t * _sphere = NULL;
 
 /* des variable d'états pour activer/désactiver des options de rendu */
 static int _use_tex = 1, _use_color = 1, _use_lighting = 1;
 
-/*!\brief on peut bouger la caméra vers le haut et vers le bas avec cette variable */
+/* on créé une grille de positions où il y aura des cubes */
-static float _ycam = 3.0f;
+static int _grille[] = {
+  1, 1, 1, 1, 1, 1, 1,
+  1, 0, 1, 0, 0, 0, 1,
+  1, 0, 1, 0, 0, 0, 1,
+  1, 0, 1, 1, 0, 1, 1,
+  1, 0, 0, 0, 0, 1, 1,
+  1, 0, 0, 1, 0, 0, 1,
+  1, 1, 1, 1, 1, 1, 1
+};
+static int _grilleW = 7;
+static int _grilleH = 7;
+
+/* Définition d'un personnage */
+typedef struct perso_t {
+  float x, y, z;
+} perso_t;
+perso_t _hero = { -10.0f, 0.0f, 0.0f };
+
+/* clavier virtuel */
+enum {
+  VK_RIGHT = 0,
+  VK_UP,
+  VK_LEFT,
+  VK_DOWN,
+  /* toujours à la fin */
+  VK_SIZEOF
+};
+
+int _vkeyboard[VK_SIZEOF] = {0, 0, 0, 0};
 
 /*!\brief paramètre l'application et lance la boucle infinie. */
 int main(int argc, char ** argv) {
@@ -53,10 +74,19 @@ int main(int argc, char ** argv) {
         return 1;
     }
     init();
-    /* mettre en place la fonction d'interception clavier */
+
-    gl4duwKeyDownFunc(key);
+    /* mettre en place la fonction d'interception clavier touche pressée */
+    gl4duwKeyDownFunc(keyd);
+
+    /* mettre en place la fonction d'interception clavier touche relachée */
+    gl4duwKeyUpFunc(keyu);
+
+    /* mettre en place la fonction idle (simulation, au sens physique du terme) */
+    gl4duwIdleFunc(idle);
+
     /* mettre en place la fonction de display */
     gl4duwDisplayFunc(draw);
+
     /* boucle infinie pour éviter que le programme ne s'arrête et ferme
      * la fenêtre immédiatement */
     gl4duwMainLoop();
@@ -73,46 +103,76 @@ void init(void) {
      * créer le screen avant d'utiliser les fonctions liées au
      * textures */
     gl4dpInitScreen();
+
     /* Pour forcer la désactivation de la synchronisation verticale */
     SDL_GL_SetSwapInterval(0);
-    /* on créé nos trois type de surfaces */
+
-    _quad   =   mk_quad();         /* ça fait 2 triangles        */
+    /* on créé le cube */
-    _cube   =   mk_cube();         /* ça fait 2x6 triangles      */
+    _cube = mk_cube();         /* ça fait 2x6 triangles      */
-    _sphere =   mk_sphere(12, 12); /* ça fait 12x12x2 trianles ! */
+
-    /* on change les couleurs de surfaces */
+    /* on change la couleur */
-    _quad->dcolor = r; _cube->dcolor = b; _sphere->dcolor = g;
+    _cube->dcolor = b;
-    /* on leur rajoute à toutes la même texture */
+
+    /* on rajoute la texture */
     id = get_texture_from_BMP("images/tex.bmp");
-    set_texture_id(  _quad, id);
+    set_texture_id(_cube, id);
-    set_texture_id(  _cube, id);
+
-    set_texture_id(_sphere, id);
+    /* si _use_tex != 0, on active l'utilisation de la texture */
-    /* si _use_tex != 0, on active l'utilisation de la texture pour les
+    if(_use_tex)
-     * trois */
-    if(_use_tex) {
-        enable_surface_option(  _quad, SO_USE_TEXTURE);
         enable_surface_option(  _cube, SO_USE_TEXTURE);
-        enable_surface_option(_sphere, SO_USE_TEXTURE);
+
-    }
     /* si _use_lighting != 0, on active l'ombrage */
-    if(_use_lighting) {
+    if(_use_lighting)
-        enable_surface_option(  _quad, SO_USE_LIGHTING);
         enable_surface_option(  _cube, SO_USE_LIGHTING);
-        enable_surface_option(_sphere, SO_USE_LIGHTING);
+
-    }
-    /* on désactive le back cull face pour le quadrilatère, ainsi on
-     * peut voir son arrière quand le lighting est inactif */
-    disable_surface_option(_quad, SO_CULL_BACKFACES);
     /* mettre en place la fonction à appeler en cas de sortie */
     atexit(sortie);
 }
 
+/*!\brief la fonction appellée à chaque idle */
+void idle(void) {
+    /* on récupère le delta-temps */
+    static double t0 = 0.0; // le temps à la frame précédente
+    double t, dt;
+    t = gl4dGetElapsedTime();
+    dt = (t - t0) / 1000.0; // diviser par mille pour avoir des secondes
+    // pour le frame d'après, je mets à jour t0
+    t0 = t;
+
+    if(_vkeyboard[VK_RIGHT])
+        _hero.x += 2.0f * dt;
+    if(_vkeyboard[VK_UP])
+        _hero.z -= 2.0f * dt;
+    if(_vkeyboard[VK_LEFT])
+        _hero.x -= 2.0f * dt;
+    if(_vkeyboard[VK_DOWN])
+        _hero.z += 2.0f * dt;
+
+    int li, col;
+    col = (int)((_hero.x + _cubeSize * _grilleW /2) / _cubeSize);
+    li  = (int)((_hero.z + _cubeSize * _grilleH /2) / _cubeSize);
+    printf("col = %d, li = %d\n", col, li);
+}
+
 /*!\brief la fonction appelée à chaque display. */
 void draw(void) {
+    vec4 r = {1, 0, 0, 1}, b = {0, 0, 1, 1};
+
+    /* on va récupérer le delta-temps */
+    static double t0 = 0.0; // le temps à la frame précédente
+    double t, dt;
+    t = gl4dGetElapsedTime();
+    dt = (t - t0) / 1000.0; // diviser par mille pour avoir des secondes
+    // pour le frame d'après, je mets à jour t0
+    t0 = t;
+
     static float a = 0.0f;
     float model_view_matrix[16], projection_matrix[16], nmv[16];
+
     /* effacer l'écran et le buffer de profondeur */
     gl4dpClearScreen();
     clear_depth_map();
+
     /* des macros facilitant le travail avec des matrices et des
      * vecteurs se trouvent dans la bibliothèque GL4Dummies, dans le
      * fichier gl4dm.h */
@@ -121,92 +181,124 @@ void draw(void) {
     /* charger la matrice identité dans model-view */
     MIDENTITY(model_view_matrix);
     /* on place la caméra en arrière-haut, elle regarde le centre de la scène */
-    lookAt(model_view_matrix, 0, _ycam, 10, 0, 0, 0, 0, 1, 0);
+    lookAt(model_view_matrix, 0, 25 + 50 /* fabs(cos(a * M_PI / 180.0f)) */, 5, 0, 0, 0, 0, 0, -1);
-    /* le quadrilatère est mis à gauche et tourne autour de son axe x */
+
-    memcpy(nmv, model_view_matrix, sizeof nmv); /* copie model_view_matrix dans nmv */
+    /* pour centrer la grille par rapport au monde */
-    translate(nmv, -3.0f, 0.0f, 0.0f);
+    float cX = -_cubeSize * _grilleW / 2.0f;
-    rotate(nmv, a, 1.0f, 0.0f, 0.0f);
+    float cZ = -_cubeSize * _grilleH / 2.0f;
-    transform_n_rasterize(_quad, nmv, projection_matrix);
+
-    /* le cube est mis à droite et tourne autour de son axe z */
+    /* on change la couleur */
-    memcpy(nmv, model_view_matrix, sizeof nmv); /* copie model_view_matrix dans nmv */
+    _cube->dcolor = b;
-    translate(nmv, 3.0f, 0.0f, 0.0f);
+
-    rotate(nmv, a, 0.0f, 0.0f, 1.0f);
+    /* pour toutes les cases de la grille, afficher un cube quand il y a
+     * un 1 dans la grille */
+    for(int i = 0; i < _grilleW; ++i)
+        for(int j = 0; j < _grilleH; ++j)
+            if(_grille[i * _grilleW + j] == 1) {
+                /* copie model_view_matrix dans nmv */
+                memcpy(nmv, model_view_matrix, sizeof nmv);
+
+                /* pour convertir les coordonnées i, j de la grille en x, z du monde */
+                translate(nmv, _cubeSize * j + cX, 0.0f, _cubeSize * i + cZ);
+                scale(nmv, _cubeSize / 2.0f, _cubeSize / 2.0f, _cubeSize / 2.0f);
+                transform_n_rasterize(_cube, nmv, projection_matrix);
+            }
+
+    /* on dessine le perso _hero */
+    /* on change la couleur */
+    _cube->dcolor = r;
+    memcpy(nmv, model_view_matrix, sizeof nmv);
+    translate(nmv, _hero.x, _hero.y, _hero.z);
+    scale(nmv, _cubeSize / 2.0f, _cubeSize / 2.0f, _cubeSize / 2.0f);
     transform_n_rasterize(_cube, nmv, projection_matrix);
-    /* la sphère est laissée au centre et tourne autour de son axe y */
+
-    memcpy(nmv, model_view_matrix, sizeof nmv); /* copie model_view_matrix dans nmv */
-    rotate(nmv, a, 0.0f, 1.0f, 0.0f);
-    transform_n_rasterize(_sphere, nmv, projection_matrix);
     /* déclarer qu'on a changé des pixels du screen (en bas niveau) */
     gl4dpScreenHasChanged();
+
     /* fonction permettant de raffraîchir l'ensemble de la fenêtre*/
     gl4dpUpdateScreen(NULL);
-    a += 0.1f;
+    a += 0.1f * 360.0f * dt;
 }
 
-/*!\brief intercepte l'événement clavier pour modifier les options. */
+/*!\brief intercepte l'événement clavier pour modifier les options (à l'appuie d'une touche). */
-void key(int keycode) {
+void keyd(int keycode) {
     switch(keycode) {
-    case GL4DK_UP:
+        case GL4DK_t: /* 't' la texture */
-        _ycam += 0.05f;
+            _use_tex = !_use_tex;
-        break;
+            if(_use_tex)
-    case GL4DK_DOWN:
+                enable_surface_option(  _cube, SO_USE_TEXTURE);
-        _ycam -= 0.05f;
+            else
-        break;
+                disable_surface_option(  _cube, SO_USE_TEXTURE);
-    case GL4DK_t: /* 't' la texture */
+            break;
-        _use_tex = !_use_tex;
+
-        if(_use_tex) {
+        case GL4DK_c: /* 'c' utiliser la couleur */
-            enable_surface_option(  _quad, SO_USE_TEXTURE);
+            _use_color = !_use_color;
-            enable_surface_option(  _cube, SO_USE_TEXTURE);
+            if(_use_color)
-            enable_surface_option(_sphere, SO_USE_TEXTURE);
+                enable_surface_option(  _cube, SO_USE_COLOR);
-        } else {
+            else
-            disable_surface_option(  _quad, SO_USE_TEXTURE);
+                disable_surface_option(  _cube, SO_USE_COLOR);
-            disable_surface_option(  _cube, SO_USE_TEXTURE);
+            break;
-            disable_surface_option(_sphere, SO_USE_TEXTURE);
+
-        }
+        case GL4DK_l: /* 'l' utiliser l'ombrage par la méthode Gouraud */
-        break;
+            _use_lighting = !_use_lighting;
-    case GL4DK_c: /* 'c' utiliser la couleur */
+            if(_use_lighting)
-        _use_color = !_use_color;
+                enable_surface_option(  _cube, SO_USE_LIGHTING);
-        if(_use_color) {
+            else
-            enable_surface_option(  _quad, SO_USE_COLOR);
+                disable_surface_option(  _cube, SO_USE_LIGHTING);
-            enable_surface_option(  _cube, SO_USE_COLOR);
+            break;
-            enable_surface_option(_sphere, SO_USE_COLOR);
+
-        } else {
+        case GL4DK_RIGHT:
-            disable_surface_option(  _quad, SO_USE_COLOR);
+            _vkeyboard[VK_RIGHT] = 1;
-            disable_surface_option(  _cube, SO_USE_COLOR);
+            break;
-            disable_surface_option(_sphere, SO_USE_COLOR);
+
-        }
+        case GL4DK_UP:
-        break;
+            _vkeyboard[VK_UP] = 1;
-    case GL4DK_l: /* 'l' utiliser l'ombrage par la méthode Gouraud */
+            break;
-        _use_lighting = !_use_lighting;
+
-        if(_use_lighting) {
+        case GL4DK_LEFT:
-            enable_surface_option(  _quad, SO_USE_LIGHTING);
+            _vkeyboard[VK_LEFT] = 1;
-            enable_surface_option(  _cube, SO_USE_LIGHTING);
+            break;
-            enable_surface_option(_sphere, SO_USE_LIGHTING);
+
-        } else {
+        case GL4DK_DOWN:
-            disable_surface_option(  _quad, SO_USE_LIGHTING);
+            _vkeyboard[VK_DOWN] = 1;
-            disable_surface_option(  _cube, SO_USE_LIGHTING);
+            break;
-            disable_surface_option(_sphere, SO_USE_LIGHTING);
+
-        }
+        default: break; // par défaut ne fais rien
-        break;
+    }
-    default: break;
+}
+
+/*!\brief intercepte l'évènement clavier pour modifier les options (au relâchement d'une touche). */
+void keyu(int keycode) {
+    switch(keycode) {
+        /* Cas où on arrête de bouger */
+        case GL4DK_RIGHT:
+            _vkeyboard[VK_RIGHT] = 0;
+            break;
+
+        case GL4DK_UP:
+            _vkeyboard[VK_UP] = 0;
+            break;
+
+        case GL4DK_LEFT:
+            _vkeyboard[VK_LEFT] = 0;
+            break;
+
+        case GL4DK_DOWN:
+            _vkeyboard[VK_DOWN] = 0;
+            break;
+
+        default: break; // par défaut on ne fais rien
     }
 }
 
 /*!\brief à appeler à la sortie du programme. */
 void sortie(void) {
-    /* on libère nos trois surfaces */
+    /* on libère le cube */
-    if(_quad) {
-        free_surface(_quad);
-        _quad = NULL;
-    }
     if(_cube) {
         free_surface(_cube);
         _cube = NULL;
     }
-    if(_sphere) {
+
-        free_surface(_sphere);
-        _sphere = NULL;
-    }
     /* libère tous les objets produits par GL4Dummies, ici
      * principalement les screen */
     gl4duClean(GL4DU_ALL);