[Résolu] Gestion du tampon de profondeur sous OpenGL

Moi j'utilise la fonction gluPerspective() qui initialise le volume dont l'angle de vision et la profondeur.
exemple:

gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);

que je lance à l'initialisation et à chaque fois que la fenetre est redimensionnée.
L'angle de vision se met en fonction de la distance entre l'oeil et l'écran. Si l'oeil est proche de l'écran, l'angle avec les bords est plus grand, donc il faut augmenter.
Le dernier paramètre de gluPerspective est la profondeur de clipping au loin. Dans l'exemple, tout vertex avec z > 100.0f ne sera pas affiché.

Il faut savoir que plus tu vois loin, plus tu risque d'avoir des polygones et faire ramer le rendu. L'astuce est de mettre une valeur pas trop grande et de mettre du brouillard pour ne pas faire une coupure nette.
Bon ça gène les snipers mais ça lag pas :-D

Voici une partie de mon code :


#include <stdio.h>
#include <stdlib.h>
#include <GL/glut.h>
#include <GL/gl.h>
#include <math.h>

//Fonction d'affichage des objets du moteur 3D
void display();
//Fonction de gestion des mouvements au clavier
void keyboard(int key,int x, int y);
//Fonction permettant de modéliser les objets avec une perspective différente
void reshape(int x,int y);
//Fonction qui calcule les sinus et les cosinus pour les déplacements dans le monde
void calcCosSinTable();
//Fonction permettant de gerer les obstacles
void testPosition();
//Fonction permettant de changer la perspective de l'objet
void changePerspective();
//Fonction créant un object de type rectangle
void rectangle(float clong, float
clarg, float chaut);
/*Variables:
px, py, pz : coordonnées de la position de l'observateur
pxold, pyold, pzold : blocage des coordonnées de la position de l'observateur
Déclaration des variables Cos(cosinus), Sin (sinus), theta*/
float pz=5.0,px=2.0,py=0,pzold=0,pxold=0,pyold=0,Sin[360],Cos[360],theta=50;
int r=0;
int angle=45;

/* Paramètres de lumières */
GLfloat L0pos[]={ 19,10,19};//Position de la lumière diffuse
GLfloat L0dif[]={ 0.8,0.5,0.2}; //Couleur de la lumière diffuse

GLfloat L1pos[]={ -19,10,-19};//Position de la lumière spéculaire
GLfloat L1dif[]={ 0.8,0.5,0.2};//Couleur de la lumière spéculaire

GLfloat L2pos[]={ 19,10,-19};//Position de la lumière ambiante
GLfloat L2dif[]={ 0.8,0.5,0.2};//Couleur de la lumière ambiante

GLfloat L3pos[]={ -19,10,19};//Position de la lumière émise
GLfloat L3dif[]={ 0.8,0.5,0.2};//Couleur de la lumière émise


GLfloat Mspec[]={0.8,0.2,0.6};//Couleur de la brillance
GLfloat Mshiny=20;// Coefficient de brillance
////////////////////////////////////////////////////////////////////////////////
//Fonction principale
int main(int argc,char **argv)
{

/* initialisation de glut et creation
de la fenetre */
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_RGB|GLUT_DOUBLE);
glutInitWindowPosition(200,200);
glutInitWindowSize(700,700);
glutCreateWindow("Monde 3D");
gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);

/* Initialisation d'OpenGL */
glClearColor(0.0,0.0,0.0,0.0);
glColor3f(1.0,1.0,1.0);
glEnable(GL_DEPTH_TEST);
changePerspective();
/* Precalcul des sinus et cosinus */
calcCosSinTable();
/* Paramétrage des lumières*/
glShadeModel(GL_SMOOTH);//Spécification du mode de remplissage
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER,GL_TRUE);

glEnable(GL_LIGHTING);//Pour utiliser le calcul d'éclairage

//Activation des sources de lumière
glEnable(GL_LIGHT0);
glEnable(GL_LIGHT1);
glEnable(GL_LIGHT2);
glEnable(GL_LIGHT3);

//Paramétrage des différentes lampes
glLightfv(GL_LIGHT0,GL_DIFFUSE,L0dif);
glLightfv(GL_LIGHT0,GL_SPECULAR,L0dif);

glLightfv(GL_LIGHT1,GL_DIFFUSE,L1dif);
glLightfv(GL_LIGHT1,GL_SPECULAR,L1dif);

glLightfv(GL_LIGHT2,GL_DIFFUSE,L2dif);
glLightfv(GL_LIGHT2,GL_SPECULAR,L2dif);

glLightfv(GL_LIGHT3,GL_DIFFUSE,L3dif);
glLightfv(GL_LIGHT3,GL_SPECULAR,L3dif);


/* Paramétrage du matériau */
glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,Mspec);
glMaterialf(GL_FRONT_AND_BACK,GL_SHININESS,Mshiny);
/* enregistrement des fonctions de rappel */
glutDisplayFunc(display);
glutSpecialFunc(keyboard);
glutReshapeFunc(reshape);
/* Entre dans la boucle principale glut */
glutMainLoop();
return 0;
}

Pourrais-tu me dire où dois-je mettre la fonction gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f); dans le code?
Et que dois-je mettre en paramètre width et height?

Merci

Oups, je l'avais mis dans le code, mais je ne sais pas quoi mettre en paramètres

En fait je viens de voir que j'appelais déjà cette fonction dans une autre fonction, donc mon problème ne vient pas de là.....
En fait quand on s'éloigne du mur, il devient noir, et je ne sais pas comment régler ce problème

/* initialisation de glut et creation

de la fenetre */

glutInit(&argc,argv);

glutInitDisplayMode(GLUT_RGB|GLUT_DOUBLE);

glutInitWindowPosition(200,200);

glutInitWindowSize(700,700);

glutCreateWindow("Monde 3D");

 
gluPerspective(45.0f,1.0f,0.1f,100.0f);

Toi tu crées une fenetre de 700x700 (width x height). Donc le rapport est de 1.
C'est bien ça qui fait le clipping à une certaine distance, à moins que tu n'ais utilisé glDepthRange() quelquepart qui diminue encore cette distance.

Si tu as déjà fais appel à cette fonction montre comment tu l'as utilisé.
Si ton mur dépasse 100 en profondeur, c'est normal que tu ne le vois pas, augmente cette valeur si nécessaire.

EDIT: je suppose que c'est dans ta fonction changePerspective() ?

Merci j'ai réglé mon problème, il suffisait simplement que je mette un nombre plus grand pour le paramètre "far"