From d35ca4f67470873782a4512560cd333a9ddb4f39 Mon Sep 17 00:00:00 2001 From: Mylloon Date: Fri, 31 Dec 2021 10:11:59 +0100 Subject: [PATCH] Added changes in /S9GB/MODIF1/window.c on expreg.org for the board and the character --- window.c | 306 ++++++++++++++++++++++++++++++++++++------------------- 1 file changed, 199 insertions(+), 107 deletions(-) diff --git a/window.c b/window.c index c86e86c..5b157ed 100644 --- a/window.c +++ b/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 /* 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 surface_t * _sphere = NULL; +static float _cubeSize = 4.0f; /* 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 */ -static float _ycam = 3.0f; +/* on créé une grille de positions où il y aura des cubes */ +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 */ - _cube = mk_cube(); /* ça fait 2x6 triangles */ - _sphere = mk_sphere(12, 12); /* ça fait 12x12x2 trianles ! */ - /* on change les couleurs de surfaces */ - _quad->dcolor = r; _cube->dcolor = b; _sphere->dcolor = g; - /* on leur rajoute à toutes la même texture */ + + /* on créé le cube */ + _cube = mk_cube(); /* ça fait 2x6 triangles */ + + /* on change la couleur */ + _cube->dcolor = b; + + /* 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(_sphere, id); - /* si _use_tex != 0, on active l'utilisation de la texture pour les - * trois */ - if(_use_tex) { - enable_surface_option( _quad, SO_USE_TEXTURE); + set_texture_id(_cube, id); + + /* si _use_tex != 0, on active l'utilisation de la texture */ + if(_use_tex) 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) { - enable_surface_option( _quad, SO_USE_LIGHTING); + if(_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); - /* 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 */ - translate(nmv, -3.0f, 0.0f, 0.0f); - rotate(nmv, a, 1.0f, 0.0f, 0.0f); - transform_n_rasterize(_quad, nmv, projection_matrix); - /* le cube est mis à droite et tourne autour de son axe z */ - memcpy(nmv, model_view_matrix, sizeof nmv); /* copie model_view_matrix dans nmv */ - translate(nmv, 3.0f, 0.0f, 0.0f); - rotate(nmv, a, 0.0f, 0.0f, 1.0f); + lookAt(model_view_matrix, 0, 25 + 50 /* fabs(cos(a * M_PI / 180.0f)) */, 5, 0, 0, 0, 0, 0, -1); + + /* pour centrer la grille par rapport au monde */ + float cX = -_cubeSize * _grilleW / 2.0f; + float cZ = -_cubeSize * _grilleH / 2.0f; + + /* on change la couleur */ + _cube->dcolor = b; + + /* 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. */ -void key(int keycode) { +/*!\brief intercepte l'événement clavier pour modifier les options (à l'appuie d'une touche). */ +void keyd(int keycode) { switch(keycode) { - case GL4DK_UP: - _ycam += 0.05f; - break; - case GL4DK_DOWN: - _ycam -= 0.05f; - break; - case GL4DK_t: /* 't' la texture */ - _use_tex = !_use_tex; - if(_use_tex) { - enable_surface_option( _quad, SO_USE_TEXTURE); - enable_surface_option( _cube, SO_USE_TEXTURE); - enable_surface_option(_sphere, SO_USE_TEXTURE); - } else { - disable_surface_option( _quad, SO_USE_TEXTURE); - disable_surface_option( _cube, SO_USE_TEXTURE); - disable_surface_option(_sphere, SO_USE_TEXTURE); - } - break; - case GL4DK_c: /* 'c' utiliser la couleur */ - _use_color = !_use_color; - if(_use_color) { - enable_surface_option( _quad, SO_USE_COLOR); - enable_surface_option( _cube, SO_USE_COLOR); - enable_surface_option(_sphere, SO_USE_COLOR); - } else { - disable_surface_option( _quad, SO_USE_COLOR); - disable_surface_option( _cube, SO_USE_COLOR); - disable_surface_option(_sphere, SO_USE_COLOR); - } - break; - case GL4DK_l: /* 'l' utiliser l'ombrage par la méthode Gouraud */ - _use_lighting = !_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); - } else { - disable_surface_option( _quad, SO_USE_LIGHTING); - disable_surface_option( _cube, SO_USE_LIGHTING); - disable_surface_option(_sphere, SO_USE_LIGHTING); - } - break; - default: break; + case GL4DK_t: /* 't' la texture */ + _use_tex = !_use_tex; + if(_use_tex) + enable_surface_option( _cube, SO_USE_TEXTURE); + else + disable_surface_option( _cube, SO_USE_TEXTURE); + break; + + case GL4DK_c: /* 'c' utiliser la couleur */ + _use_color = !_use_color; + if(_use_color) + enable_surface_option( _cube, SO_USE_COLOR); + else + disable_surface_option( _cube, SO_USE_COLOR); + break; + + case GL4DK_l: /* 'l' utiliser l'ombrage par la méthode Gouraud */ + _use_lighting = !_use_lighting; + if(_use_lighting) + enable_surface_option( _cube, SO_USE_LIGHTING); + else + disable_surface_option( _cube, SO_USE_LIGHTING); + break; + + case GL4DK_RIGHT: + _vkeyboard[VK_RIGHT] = 1; + break; + + case GL4DK_UP: + _vkeyboard[VK_UP] = 1; + break; + + case GL4DK_LEFT: + _vkeyboard[VK_LEFT] = 1; + break; + + case GL4DK_DOWN: + _vkeyboard[VK_DOWN] = 1; + break; + + default: break; // par défaut ne fais rien + } +} + +/*!\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 */ - if(_quad) { - free_surface(_quad); - _quad = NULL; - } + /* on libère le cube */ 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);