Jeux Libres

Envie de créer un jeu vidéo ?   Le site qui vous accompagne de A à Z.


» Les Tutoriels » Création d'un jeu vidéo » Création du projet

Création du projet


Les choses sérieuses vont commencer dès maintenant. Nous allons créer le projet et installer les bibliothèques SDL et OpenGL.


Sommaire du chapitre :


Chapitre précédent     Sommaire     Chapitre suivant

Installation des bibliothèques


Créer un nouveau projet sous Code::Blocks



Sous Code::Blocks, commencez par créer un nouveau projet de type "Console" en C++.

Pourquoi "console" ?


Par habitude, je créé toujours un projet de type "console" pour commencer. Ensuite on créera la fenêtre et on enlèvera la console.

Ici, le terme "console" ne doit pas être confondu avec "console de jeu". Ça n'a rien à voir ! La console désigne ici le programme d'affichage de la sortie standard : la fenêtre dans laquelle s'affiche généralement les "printf".


Lorsque votre nouveau projet sera créé, essayez de le compiler et de l'exécuter. Le code minimal proposé devrait s'exécuter correctement.

Installation de la bibliothèque SDL



Pour installer la bibliothèque SDL, téléchargez là sur le site de l'auteur : http://www.libsdl.org/. Dans la section "Download", "Development Libraries", "Win32".

Dans le .tar.gz, vous trouverez les .a à copier dans "CodeBlocks\MinGW\lib\". Copiez également les .h dans le dossier "CodeBlocks\MinGW\include\SDL\" que vous aurez créé auparavant.

Pour finir, ajoutez "-lmingw32", "-lSDLmain" et "-lSDL" dans l'éditeur de liens.


Si vous rencontrez des difficultés, vous pouvez vous aider de la vidéo située un peu plus bas.


Essayez de compiler et exécuter ce code :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
 
int main(int argc, char *argv[])
{
    SDL_Init(SDL_INIT_VIDEO); // Initialisation de la SDL
 
    SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE); // Ouverture de la fenêtre
 
    int continuer = 1;
    SDL_Event event;
 
    while (continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                continuer = 0;
        }
    }
 
    SDL_Quit(); // Arrêt de la SDL
 
    return EXIT_SUCCESS; // Fermeture du programme
}

Un message d'erreur apparait. Vous devez ajouter le fichier SDL.dll près de votre exécutable.


Vous devriez voir apparaître une fenêtre noire. Si ce n'est pas le cas, recommencez l'installation attentivement.

Installation de l'API OpenGL



Pour installer OpenGL, c'est très simple. OpenGL est déjà installé avec le système d'exploitation. Vous n'aurez qu'à ajouter "-lopengl32" et "-lglu32" à l'éditeur de lien et ça devrait être bon.

Pour tester, je vous conseil ce code, de type "Hello world!", qui utilise OpenGL avec SDL :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <SDL/SDL.h>
#include <GL/gl.h>
#include <GL/glu.h>
 
int main(int argc, char *argv[])
{
    SDL_Init(SDL_INIT_VIDEO);
    SDL_WM_SetCaption("Hello world!",NULL);
    SDL_SetVideoMode(640, 480, 32, SDL_OPENGL);
 
    bool continuer = true;
    SDL_Event event;
 
    while (continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                continuer = false;
        }
 
        glClear(GL_COLOR_BUFFER_BIT);
 
        glBegin(GL_TRIANGLES);
            glColor3ub(255,0,0);    glVertex2d(-0.75,-0.75);
            glColor3ub(0,255,0);    glVertex2d(0,0.75);
            glColor3ub(0,0,255);    glVertex2d(0.75,-0.75);
        glEnd();
 
        glFlush();
        SDL_GL_SwapBuffers();
    }
 
    SDL_Quit();
 
    return 0;
}

Un triangle de 3 couleurs doit apparaitre. Sinon, revoyez la procédure attentivement.


Suppression de la console



Nous n'avons plus besoin de la console, nous pouvons maintenant la supprimer à l'aide du menu "Project", "Properties", "Build target". Choisissez un projet de type GUI.


Une recompilation complète est nécessaire afin que cette modification soit prise en compte.


Aide supplémentaire



Je reconnais qu'il n'est pas évident de faire toutes ces manipulations sans se tromper. Vous pouvez vous aider de cette vidéo qui retrace chacune de ces étapes.


Les étapes de la vidéo :
   - de 0:00 à 0:47 : Création d'un nouveau projet
   - de 0:47 à 1:30 : Téléchargement de la SDL
   - de 1:30 à 1:58 : Extraction des fichiers de la SDL
   - de 1:58 à 3:22 : Installation de la SDL dans Code::Blocks
   - de 3:22 à 5:26 : Utilisation de la SDL dans un programme d'exemple
   - de 5:26 à 6:46 : Utilisation d'OpenGL dans un programme d'exemple
   - de 6:46 à 7:29 : Suppression de la console.

Pour extraire la bibliothèque, j'ai utilisé 7Zip, un gestionnaire d'archives. Vous pouvez également télécharger la bibliothèque SDL au format ZIP en cliquant ici. Ainsi, vous pourrez l'extraire avec Windows.

Compilation et exécution


Maintenant que tout est prêt, nous allons enfin commencer à taper du vrai code pour notre jeu vidéo. Je vous donne le code et après je vous explique.

Pour insérer le code vous allez devoir créer 4 nouveaux fichiers.

Attention : Lors de l'ajout des fichiers, (les .cpp en  particulier) n'oubliez pas de cocher les cases indiquant que vous voulez qu'ils soient compilés.


Compilation



Voici le nouveau main.cpp et les 4 nouveaux fichiers :

main.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
#include <SDL/SDL.h>
#include <GL/gl.h>
#include <GL/glu.h>
 
#include <stdio.h>
#include <stdlib.h>
#include "configuration.h"
#include "init.h"
 
 
void pause();
 
int main( int argc, char* argv[] )
{
    // Initialisation de la SDL et d'OpenGL
    initSDL();
    initOpenGL();
 
 
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 
    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity( );
 
    gluLookAt(3,4,2,0,0,0,0,0,1);
 
    glBegin(GL_QUADS);
 
    glColor3ub(255,0,0); //face rouge
    glVertex3d(1,1,1);
    glVertex3d(1,1,-1);
    glVertex3d(-1,1,-1);
    glVertex3d(-1,1,1);
 
    glColor3ub(0,255,0); //face verte
    glVertex3d(1,-1,1);
    glVertex3d(1,-1,-1);
    glVertex3d(1,1,-1);
    glVertex3d(1,1,1);
 
    glColor3ub(0,0,255); //face bleue
    glVertex3d(-1,-1,1);
    glVertex3d(-1,-1,-1);
    glVertex3d(1,-1,-1);
    glVertex3d(1,-1,1);
 
    glColor3ub(255,255,0); //face jaune
    glVertex3d(-1,1,1);
    glVertex3d(-1,1,-1);
    glVertex3d(-1,-1,-1);
    glVertex3d(-1,-1,1);
 
    glColor3ub(0,255,255); //face cyan
    glVertex3d(1,1,-1);
    glVertex3d(1,-1,-1);
    glVertex3d(-1,-1,-1);
    glVertex3d(-1,1,-1);
 
    glColor3ub(255,0,255); //face magenta
    glVertex3d(1,-1,1);
    glVertex3d(1,1,1);
    glVertex3d(-1,1,1);
    glVertex3d(-1,-1,1);
 
    glEnd();
 
    glFlush();
    SDL_GL_SwapBuffers();
 
 
    pause();
 
    // Arrêt de la SDL
    SDL_Quit();
 
    return 0;
}
 
 
void pause()
{
    int continuer = 1;
    SDL_Event event;
 
    while (continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                continuer = 0;
        }
    }
}

types.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#ifndef TYPES_H_INCLUDED
#define TYPES_H_INCLUDED
 
typedef unsigned char uint8;
typedef signed char sint8;
typedef unsigned short uint16;
typedef signed short sint16;
typedef unsigned long uint32;
typedef signed long sint32;
 
typedef unsigned char bool8;
#define TRUE 1
#define FALSE 0
 
typedef float float16;
typedef double double32;
 
#endif // TYPES_H_INCLUDED

configuration.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#ifndef CONFIGURATION_H_INCLUDED
#define CONFIGURATION_H_INCLUDED
 
#define LARGEUR_FENETRE 640
#define HAUTEUR_FENETRE 480
 
#define TITRE_APPLICATION "Application de test OpenGL"
 
#define PRET 0.1
#define LOIN 1000.0
 
#define ANGLE_VISION 70.0
 
 
 
#endif // CONFIGURATION_H_INCLUDED

init.h

1
2
3
4
5
6
7
#ifndef INIT_H_INCLUDED
#define INIT_H_INCLUDED
 
void initSDL(void);
void initOpenGL(void);
 
#endif // INIT_H_INCLUDED

init.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#include "init.h"
#include "configuration.h"
 
#include <SDL/SDL.h>
#include <GL/gl.h>
#include <GL/glu.h>
 
void initSDL(void)
{
    // Démarrage de la SDL avec le module vidéo
    if(SDL_Init(SDL_INIT_VIDEO) < 0)
    {
        fprintf(stderr, "Erreur d'initialisation de la SDL : %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }
 
    // Création de la fenetre initialisée pour fonctionner avec OpenGL
    SDL_SetVideoMode(LARGEUR_FENETRE, HAUTEUR_FENETRE, 32, SDL_OPENGL);
 
    // Titre de l'application
    SDL_WM_SetCaption(TITRE_APPLICATION, NULL);
}
 
void initOpenGL(void)
{
    glEnable( GL_CULL_FACE ); // Activer le masquage des faces cachées
    glCullFace(GL_BACK); // Face cachées = faces arrières
    glFrontFace(GL_CCW); // Face avant = sens trigo
 
    // Couleur rgba de vidage de l'écran
    glClearColor(0, 0, 0, 0);
 
    // Définition de la fenetre
    glViewport(0, 0, LARGEUR_FENETRE, HAUTEUR_FENETRE);
 
 
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
 
    // Définition de la zone visible
    gluPerspective(ANGLE_VISION, (GLdouble) LARGEUR_FENETRE / (GLdouble)HAUTEUR_FENETRE, PRET, LOIN);
}

Compilez ce code, tout devrait bien se passer.

Exécution



Après l'exécution de ce programme, un cube doit apparaitre dans une fenêtre. Passons maintenant aux explications.


Explication du code


Le main



Dans le main, on initialise la SDL puis OpenGL avant de dessiner un cube dans le champ de la caméra et d'attendre la demande de fermeture du programme avant de libérer la SDL et quitter le programme.

J'utiliserai le terme caméra pour désigner le point de vu de la scène. On initialisera la caméra à l'aide de la fonction gluLookAt().


Rappels


Avant de dessiner une scène, on devra toujours commencer par "effacer" le dessin de la scène. En effet, lors de l'exécution du jeu, on avoisinera les 60 images par seconde, il serait ennuyeux de voir des traces du dessin de l'image précédente sur le dessin de la scène courante.

Effacer la scène consiste à initialiser tout les pixels du dessin à la couleur souhaitée, par exemple en noir. De plus, il est important de vider le tampon de profondeur des pixels. Souvenez vous, lorsqu'on dessine un objet à l'écran, celui-ci n'est dessiné que s'il est plus près de l'objet précédemment dessiné. Avant de dessiner le premier objet, la distance (ou profondeur) des pixels est donc initialisé à l'infinie.

Pour effacer le dessin de la scène (couleur de fond + tampon de profondeur), on ferra appel à la fonction suivante :
1
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

Avant de dessiner une scène, nous devons toujours commencer par placer la caméra. En effet, si la caméra n'est pas bien placée avant le début du dessin de la scène, OpenGL ne saura pas où dessiner l'objet sur le dessin puisqu'il ne saura pas d'où est visualisée la scène.


La fonction gluLookAt() modifie la matrice courante. Du point de vue d'OpenGL, une matrice est un outil mathématique qui contient un ensemble de transformations (rotation, translation et redimentionnement). Modifier la matrice de projection n'aurait aucun sens d'un point de vu visualisation. Avant de placer la caméra, nous devons donc indiquer à OpenGL que nous allons travailler sur la matrice de modélisation-visualisation avec la fonction glMatrixMode(GL_MODELVIEW);. Puis, pour ne pas modifier une matrice non-initialisée, nous chargeons la matrice identité (matrice particulière qui n'effectue aucune transformation) avec glLoadIdentity() puis nous la modifions avec gluLookAt(), ce qui a pour effet de placer la caméra.

Pour les geeks : En réalité, d'un point de vue mathématique, ce n'est pas la caméra qui bouge. Le fonction gluLookAt() modifie la matrice courante (qui DOIT être la matrice identité) de telle manière que les objets prochainements dessinés se verront appliquer l'ensemble des transformations de cette nouvelle matrice. Ainsi, ils seront placés à l'endroit supposé par rapport à la caméra.

1
2
3
    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity( );
    gluLookAt( 3,4,2,   0,0,0,   0,0,1 );

En l'occurrence, nous plaçons l'œil de la caméra en (x=3;y=4;z=2). Nous regardons, au centre de l'écran, le point (x=0;y=0;z=0) et le haut de notre caméra suit l'axe des Z positifs.


La caméra dans la scène.


Vue depuis la caméra.

Soyez attentif au sens et à direction des différents axes. Vous devrez les garder en tête tout au long du développement de votre jeu vidéo. Je vous conseille de les noter sur une feuille avec un petit dessin : Y à droite, Z en haut, et X vers vous.


Dessin du cube



Ensuite, nous dessinons 6 quadrilatères : les 6 faces carrées de notre cube.

On indique qu'on commence à dessiner des quadrilatères :
1
glBegin(GL_QUADS);

Puis ont sélectionne la couleur et on définit les point de chaque quadrilatère :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
    glColor3ub(255,0,0); //face rouge
 
    glVertex3d(1,1,1);
    glVertex3d(1,1,-1);
    glVertex3d(-1,1,-1);
    glVertex3d(-1,1,1);
 
 
    glColor3ub(0,255,0); //face verte
 
    glVertex3d(1,-1,1);
    glVertex3d(1,-1,-1);
    glVertex3d(1,1,-1);
    glVertex3d(1,1,1);
 
    // Etc ...


Dessin du cube devant la caméra.


Vue du cube depuis la caméra.

Je rappelle que les polygones doivent être convexe et que leur sommets doivent être définit dans le sens trigonométrique lorsqu'on les regarde de face (de l'extérieur de l'objet). Cela permettra d'accélérer le rendu de la scène en ne dessinant pas les faces cachées (les faces visibles depuis l'intérieur, donc invisible). Par exemple, si on ne dessine que la face cyan (face du dessous), on se rend compte que la face a bien été dessinée dans le sens trigonométrique, mais du point de vue de la caméra, elle est dessiné dans le sens horaire. Après activation du masquage des faces cachées (dans initOpenGL), OpenGL saurra qu'il s'agit d'une face caché lorsqu'elle est visible depuis l'arrière (dessinée dans le sens horaire) et n'essaiera pas de la dessiner. Cela permet d'accélérer le rendu.



Lorsque le dessin du cube est terminé, on l'affiche à l'aide des fonctions suivante :
1
2
    glFlush();
    SDL_GL_SwapBuffers();

Et pour ce qui est de la fonction pause(), celle-ci attend un évènement SDL (clavier, souris...) et en occurrence, elle attend un évènement de type SDL_QUIT pour se débloquer et rendre la main. Après quoi le programme se termine.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void pause()
{
    int continuer = 1;
    SDL_Event event;
 
    while (continuer)
    {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                continuer = 0;
        }
    }
}

types.h



Afin d'être certain du type de variable qu'on manipule, j'ai choisi de redéfinir les types. A partir de maintenant, nous utiliserons autant que possible ces nouveaux types car nous savons ce qu'ils signifient. De plus, ils nous obligent à nous demander si le type doit être signé ou non. La taille du type en bit est rappelé en suffixe.

configuration.h



Le fichier de configuration contient les informations paramétrable du programme. Pour l'instant j'ai définit ici les informations relatives à la fenêtre et à la caméra. Ces données sont utilisées dans init.cpp.

init.cpp



Initialisation de la SDL


L'initialisation consiste à démarrer la SDL, créer la fenêtre et lui donner un titre.

Initialisation d'OpenGL


L'initialisation d'OpenGL consiste à initialiser quelques variable d'état (interne à OpenGL) aux valeurs souhaitées.

  • Définition et masquage des faces
  • Couleur d'effacement de l'écran
  • Définition de la zone visible de la caméra (angle, distance...)



Votre environnement de développement est enfin prêt, nous connaissons maintenant le repère dans lequel nous allons visualiser la scène, les types que nous allons utiliser... Et les bases on été rappelées.

Le programme est encore très mal structuré, mais dans le cadre d'un projet amateur, je pense qu'on peut se permettre d'y réfléchir au fur et à mesure de l'avancement du projet.


Chapitre précédent     Sommaire     Chapitre suivant



Rédigé par David
Consulté 22327 fois


Hébergeur du site : 1and1.fr



Site de création de Jeux Vidéo
Apprenez à créer vos propres Jeux Video

 1389734 pages ont été consultées sur le site !
Dont 1627 pages pendant les 24 dernières heures.

Page générée en 0.409 secondes


Nos partenaires
- Otium Production : Aide aux débutants à créer leurs jeux
- Les bibliothèques de développement de jeux vidéo


  © 2005-2012 www.jeux-libres.com - Toute reproduction totale ou partielle du contenu de ce site est strictement interdite.