Discussion :

[gnouz]

Voilà je compte réaliser un fps en 3D (codé en C & en utilisant les librairies OpenGL et SDL), c'est mon premier semestre d'opengl, je sais deplacer ma caméra dans un environnement texturé et éclairé.

Je dois créer les niveaux avec un editeur, et sur ce point là je bloque je ne vois pas trop comment faire, je serais faire un editeur de maps simple en 2D mais je ne serais pas trop comment transposer les infos de la map dans un environnement 3D.

Ensuite pour la gestion des collisions, on en a pas trop parlé, alors perso je compte faire, plusieurs structures, par exemple des structures couloir, piece1, piece2, piece3, caisses qui representeront tous les couloirs, les pieces et les objets comme les caisses dans mon environnement, je stockerai dans cette structure leurs coordonnées respectives.
Et pour gérer les collisions, à chaque fois que le joueur fait deplacer le personnage, (je choisis de deplacer la caméra dans le monde, et non pas le monde autour de moi), je verifie si ma position est egale à une des positions de toutes les structures.

Voilà, j'aimerais avoir quelques conseils avant de me lancer.

Merci d'avance

[Ange_blond]

Bonjour

Pour faire une map en3D, tu peux l'éditer en 2D... une fois le dessins 2D terminé (en vue de dessus) tu "extrude" tes contours pour en faire des murs et voilà.

De plus, de créer ton propre éditeur te permet d'écrire directement les données dans le formalisme qui t'arrange (cf collisions)

Par contre, le test de collision systématique avec tous les objets de la scene, ça peut etre pratique au début, mais tres couteux une fois que ta scene se charge en décors...
Privilegie des méthodes de réel test de collision. Je n'en ai pas à te suggerer là comme ça, mais il y en a surement pas bien loin...

bon courage

[Mat.M]

Gnouz bon courage également ; tu peux prendre les sources de Irrlicht 3d ils ont implémentés un BSP ( je pense comme Quake ).
Perso je m'inspirerais fortement des sources de Irrlicht le code source est bien fait.
http://fr.wikipedia.org/wiki/Binary_space_partitioning
Je préfère la page en anglais plus complète
http://en.wikipedia.org/wiki/Binary_space_partitioning

[drcd]

Pour les tests de collisions, regarde les tutoriaux sur le moteur physique Newton Engine disponible sur le site:
http://jeux.developpez.com/tutoriels/?page=phys#newton

Tu ne pourras pas avoir de meilleurs résultats en codant toi même et newton est assez simple à utiliser. Si tu tiens absolument à faire l'algo de test de collision toi même, je te le donnerai. Mais le fait d'utiliser newton te donnera beaucoup d'avantages:
- Pas de bugs de collisions
- déplacement de l'objet en fonction du temps
- Presque rien à faire au niveau code. La plupart des appels que tu fais aux fonctions newton sont de la config. Donc tout se fait à l'initialisation de ton objet.

[Mat.M]

Utiliser une couche logicielle gérant la physique pour un FPS je suis assez perplexe.
Pour faire une simulation de course de voiture là je dis d'accord avec plusieurs entités qui ont un mouvement ,ok,mais pour un FPS je pense que cela va entrainer des calculs supplémentaires inutiles

[shenron666]

à part une couche logicielle, tu peux utiliser quoi ?

au moins, ça te donne de la marge, quelque chose de stable et performant pour les collisions, sachant que c'est une partie qui peut demander beaucoup de temps de dev

tu pourras gérer les rag-dolls, la destruction de murs, des véhicules ect
c'est peut-être présomptueux pour un projet amateur mais en l'implémentant l'api de physique maintenant il n'y aura pas à casser le moteur pour intégrer cette api plus tard

[drcd]

c'est peut-être présomptueux pour un projet amateur mais en l'implémentant l'api de physique maintenant il n'y aura pas à casser le moteur pour intégrer cette api plus tard

C'est exactement ce qui m'est arrivé. Je n'avais pas implémenté de moteur physique par paresse et manque de connaissance. J'avais codé un algo de détection de collision qui marchait plus ou moins bien suivant les cas. J'avais donc du mettre des rustine de partout pour cacher la misère. J'ai tout cassé, implémenté correctement Newton et ça marche beaucoup mieux qu'avant.

En plus c'est marrant de faire joujou avec les valeur pour voir le comportement du moteur .

[Mat.M]

à part une couche logicielle, tu peux utiliser quoi ?

au moins, ça te donne de la marge, quelque chose de stable et performant pour les collisions, sachant que c'est une partie qui peut demander beaucoup de temps de dev

Par couche logicielle je veux parler de bibliothèque de code comme Newton.

Je suis d'accord avec toi mais la pertinence d'une telle bibliothèque pour un FPS me laisse perplexe...si tu veux faire un jeu de voiture je dis d'accord et c'est évident que ce sera nécessaire .
Mais est-ce vraiment nécessaire de calculer à chaque mouvement du joueur la gravité , la masse l'age du capitaine dans un Quake-Like ?
Je trouve que c'est faire des calculs inutilement pour rien..

[Invité]

Par couche logicielle je veux parler de bibliothèque de code comme Newton.

Je suis d'accord avec toi mais la pertinence d'une telle bibliothèque pour un FPS me laisse perplexe...si tu veux faire un jeu de voiture je dis d'accord et c'est évident que ce sera nécessaire .
Mais est-ce vraiment nécessaire de calculer à chaque mouvement du joueur la gravité , la masse l'age du capitaine dans un Quake-Like ?
Je trouve que c'est faire des calculs inutilement pour rien..

Ca dépend du niveau du programmeur et de la complexité des scènes. C'est sûr qu'utiliser une bibliothèque de physique quand tu as peu d'ennemis et que tu te déplaces dans des scènes d'intérieur assez rudimentaires avec un seul étage et pas d' height maps, c'est disproportionné. Par contre, dès que ça se complique, c'est une autre paire de manche et ça dépend du temps que tu veux y consacrer. Personnellement, je n'aime pas réinventer l'eau chaude bien que ça puisse avoir un intérêt pédagogique.

[gnouz]

Bonsoir,

Non je dois coder moi même la gestion des collisions pour ce projet.

Sinon je vais commencer demain, 1ere etape :

à partir d'une map , realiser l'environnement 3D, en gros :

l'utilisateur fait une map simple sur un fichier, exemple :

Nombre de lignes : 8
Nombre de colonnes : 40

****************************************
* * * * *
** **************************** * *
E * *
******* * *
* * *
* S *
**********************************

les * désignants les murs, le E, la position initiale de la caméra, et le S la sortie.

Mon programme devra lire le fichier, mettre les données dans un tableau et creer le monde 3D par rapport à ce tableau
Ma caméra devra se deplacer librement dans cet environnement.

C'est ma premiere etape, pas encore de gestion de collisions ou d'ennemies ou de tirs.

Je mettrais à jouer ce topic avancée après avancée.

Si vous avez des conseils ou quoi que ce soit, n'hesitez pas.

Merci

p.s : la map est très mal sorti sur ce post, mais bon vous voyez en gros ce que je veux faire

[gnouz]

bon j'ai fais la 1ere étape décrite au dessus, ça marche bien, par contre, quand je veux placer la caméra, ça deconne à mort.

Je suis en train de réfléchir comment placer ma caméra fixe à un point sans que ça deconne.

Comme vous pouvez le voir sur le code, ce n'est pas la caméra qui se deplace, mais le monde qui se deplace autour de moi.

Je veux maintenant placer une caméra qui sera fixé au point 'E' indiqué sur la map.
Cette caméra sera fixe et servira de "viseur", en gros je ferais varier uniquement les 4eme,5eme et 6eme arguments de la fonction gluLookAt (les arguments qui définissent où ma caméra va viser).

Donc voilà, prochaines étapes :

-> Implémenter la caméra
-> Mettre des textures

le code :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
 
#include <stdio.h>
#include <stdlib.h>
#include <SDL/SDL.h>
#include <GL/glut.h>
#include <string.h>
#include <math.h>
 
/* A faire demain : 
   
   - Régler le probleme de la caméra : lorsque je mets la caméra, ça deconne, je veux une caméra fixe qui reste fixe sur le 'E' de la map
   - Utiliser la caméra pour que le personnage puisse viser
   
*/
 
struct MAP {
  int nblignes;
  int nbcols;
  char **elements; };
 
typedef struct MAP MAP;
 
int largeur_wm=800;
int hauteur_wm=600;
 
void readstr(FILE *f,char *ligne) {
 
  do
    {
      fgets(ligne,255,f);
    }
  while((ligne[0]=='#') || (ligne[0]=='\n'));
 
 
}
 
MAP charger_fichier(MAP carte) {
 
  int nblignes=0,nbcols=0,i,j;
  char **elements;
  char ligne[255];
  FILE *map=NULL;
  map=fopen("map.txt","rt");
 
  if(map==NULL)
    {
      printf("Impossible d'ouvrir le fichier\n");
      exit(0);
    }
 
  else 
    {
 
      readstr(map,ligne);
      sscanf(ligne,"nblignes %d\n",&nblignes);
      readstr(map,ligne);
      sscanf(ligne,"nbcols %d\n",&nbcols);
      carte.nblignes=nblignes;
      carte.nbcols=nbcols;
 
      elements=(char **)malloc(nblignes*sizeof(char *));
      if(elements==NULL)
	{
	  printf("Impossible d'allouer de la mémoire pour le tableau éléments\n");
	  exit(0);
	}
      for (i=0;i<nblignes;i++)
	{
	  elements[i]=(char *)malloc(nbcols*sizeof(char));
	  if(elements[i]==NULL)
	    {
	      printf("Impossible d'allouer de la mémoire pour le tableau element[%d]",i);
	      exit(0);
	    }
	}
 
      for(i=0;i<nblignes;i++)
	{
	  readstr(map,ligne);
	  strcpy(elements[i],ligne);
	}
 
      carte.elements=elements;
 
      fclose(map);
    }
  return carte;
}
 
 
void dessiner_scene(MAP carte,int longueur_mur,int largeur_mur) {
 
  int z=-10,x,i,j,retour=0;
 
  glTranslatef(0,-2,0);
 
  for(i=0;i<carte.nblignes;i++)
    {
      if(i>0) 
	glTranslatef(-retour,0,longueur_mur);
      retour=0;
      x=10;
      for(j=0;j<carte.nbcols;j++)
	{
	  if(carte.elements[i][j]=='*')
	    {
	      glColor3f(1,1,1);
	      glTranslatef(largeur_mur,0,0);
 
	      glBegin(GL_QUADS); // face gauche
	      glVertex3f(0,0,0); // bas droite
	      glVertex3f(0,0,longueur_mur); // bas gauche
	      glVertex3f(0,longueur_mur,longueur_mur); // haut gauche
	      glVertex3f(0,longueur_mur,0); // haut droite
	      glEnd();
 
	      glBegin(GL_QUADS); // face droite
	      glVertex3f(largeur_mur,0,0); // bas droite
	      glVertex3f(largeur_mur,0,longueur_mur); // bas gauche
	      glVertex3f(largeur_mur,longueur_mur,longueur_mur); // haut gauche
	      glVertex3f(largeur_mur,longueur_mur,0); // haut droite
	      glEnd();
 
	      glBegin(GL_QUADS); // face avant
	      glVertex3f(0,0,longueur_mur); // bas gauche
	      glVertex3f(largeur_mur,0,longueur_mur); // bas droite
	      glVertex3f(largeur_mur,longueur_mur,longueur_mur); // haut droit
	      glVertex3f(0,longueur_mur,longueur_mur); // haut gauche
	      glEnd();
 
	      glBegin(GL_QUADS); // face arriere
	      glVertex3f(0,0,0); // bas gauche
	      glVertex3f(largeur_mur,0,0); // bas droite
	      glVertex3f(largeur_mur,longueur_mur,0); //haut droite
	      glVertex3f(0,longueur_mur,0); // haut gauche
	      glEnd();
 
	    }
	  else if(carte.elements[i][j]==' ')
	    {
	      glColor3f(1,0,0);
	      glTranslatef(largeur_mur,0,0);
	      glBegin(GL_QUADS);
	      glVertex3f(0,0,0);
	      glVertex3f(largeur_mur,0,0);
	      glVertex3f(largeur_mur,0,longueur_mur);
	      glVertex3f(0,0,longueur_mur);
	      glEnd();
	    }
	  else if(carte.elements[i][j]=='E' || carte.elements[i][j]=='S')
	    {
	      glColor3f(0,1,0);
	      glTranslatef(largeur_mur,0,0);
	      glBegin(GL_QUADS);
	      glVertex3f(0,0,0);
	      glVertex3f(largeur_mur,0,0);
	      glVertex3f(largeur_mur,0,longueur_mur);
	      glVertex3f(0,0,longueur_mur);
	      glEnd();
	    }
	  glColor3f(0.39,0.12,0.12);
	  glBegin(GL_QUADS); // On dessine le plafond pour chaque case
	  glVertex3f(0,longueur_mur,0); // haut gauche
	  glVertex3f(largeur_mur,longueur_mur,0); // haut droite
	  glVertex3f(largeur_mur,longueur_mur,longueur_mur); // bas droite
	  glVertex3f(0,longueur_mur,longueur_mur); // bas gauche
	  glEnd();
	  retour+=largeur_mur;
	}
    }
  glPopMatrix();
}
 
 
int main (void) {
 
  SDL_Event event;
  MAP carte;
  int i,j,continuer=1;
  int pos_camx,pos_camy,pos_camz,visex,visey,visez;
  int longueur_mur=50,largeur_mur=50;
  int x=0,y=0,z=-10;
  GLfloat ax=0,az=0,angle=0;
 
  SDL_Init(SDL_INIT_VIDEO);
  SDL_WM_SetCaption("projet",NULL);
  SDL_SetVideoMode(largeur_wm,hauteur_wm,32,SDL_OPENGL);
 
  // On charge la map crée par l'utilisateur  
  carte=charger_fichier(carte);
 
  //On récupere les coordonnée x & z de la caméra
 
  for(i=0;i<carte.nblignes;i++)
    {
      z+=longueur_mur;
      x=0;
      for(j=0;j<carte.nbcols;j++)
	{
	  if(carte.elements[i][j]=='E')
	    {
	      pos_camx=x;
	      pos_camz=z;
	    }
	  x+=largeur_mur;
	}
    }
 
    // On charge la machine à états opengl
 
  glViewport(0,0,largeur_wm,hauteur_wm);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective(70,800/600,1,10000);
  glEnable(GL_DEPTH_TEST);
 
  SDL_EnableKeyRepeat(10,10);
 
  // boucle des evenements
 
  while(continuer)
    {
 
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
      glMatrixMode(GL_MODELVIEW);
      glLoadIdentity();
      //gluLookAt(pos_camx,2,pos_camz,0,0,1000,0,1,0);
      SDL_WaitEvent(&event);
 
      if(event.type==SDL_QUIT)
	continuer=0;
 
      if(event.type==SDL_KEYDOWN)
	{
	  switch(event.key.keysym.sym)
	    {
 
	    case SDLK_ESCAPE :
	      continuer=0;
	      break;
 
	    case SDLK_UP :
	      ax-=sin(angle*M_PI/180);
	      az+=cos(angle*M_PI/180);
	      break;
 
	    case SDLK_DOWN :
	      ax+=sin(angle*M_PI/180);
	      az-=cos(angle*M_PI/180);
	      break;
 
	    case SDLK_RIGHT :
	      angle++;
	      break;
 
	    case SDLK_LEFT :
	      angle--;
	      break;
 
	    default : 
	      break;
	    }
	}
 
      glRotatef(angle,0,1,0);
      glTranslatef(ax,0,az); 
      dessiner_scene(carte,longueur_mur,largeur_mur);
      glFlush();
      SDL_GL_SwapBuffers();
    }
 
  SDL_Quit();
  return 0;
}

exemple de fichier de map :

une map

Voilà si vous avez des idées, des conseils sur le probleme d'implémentation de la caméra, n'hesitez pas !

Merci d'avance

[Djakisback]

Salut,
apparemment tu ne peux pas utiliser le C++ dommage cela aurait été plus simple.
En tout cas, d'après ton code tu devrais ré-analyser et bien découper le problème (même ou surtout en C) car là tu colles tout dans le main() et dans dessiner() en plus dans un seul fichier. Je pense que tu devrais bien découper ton code et également utiliser des struct et des typedef (je vois d'ailleurs que t'en parlais dans ton premier post). Tu devrais dissocier la partie dessin du reste et créer des fonctions de tracé, ex :
void draw(Mur* mur); ou plus générique : void draw(Sprite* spr);
En fait tout dépend du temps que tu as pour faire ce projet mais là comme tu est parti je pense que tu vas vite galéré
Par exemple à quel moment, vas tu libérer les textures (et lesquels), alors que si tu crées une structure par exemple MoteurGraphique, tu stockes dedans tes id de textures, tes sprites, ta caméra etc... Tu te fais des fonctions de libération de ressources, ça te permet de sécuriser un peu tout cela et facilitera le chargement/déchargement.
Si tu veux faire un fps un peu plus évolué, avec autre chose que des murs je pense que tu devrais t'orienter vers un système de sérialisation des données, plus dur à mettre en oeuvre que ton système de carte, des fichiers plus lourds mais ensuite tu as un système beaucoup plus générique, dans lequel tu pourras par exemple changer la texture de tel ou tel mur, ajouter plusieurs types d'objets de décor. Enfin tout dépend de ce que tu veux faire. Je pense que tu t'es plongé dans le code un peu rapidement. ^^

[gnouz]

ok merci pour les conseils je vais refaire ça demain.

Sinon toujours ce problème avec la caméra que je n'arrive pas à comprendre, vraiment bizarre

[anarkia777]

Prendre le moteur Source de Counter peut être intéressant pour toi?
Il donne le code Source, y'a un éditeur, et la doc est en Fr (une partie).
Ca sera un mods, mais tu cherche plutot à tout créer si j'ai compris?