IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

OpenGL Discussion :

Opengl - Problème avec les arrêtes


Sujet :

OpenGL

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre averti
    Homme Profil pro
    Directeur technique
    Inscrit en
    Juillet 2007
    Messages
    31
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Directeur technique

    Informations forums :
    Inscription : Juillet 2007
    Messages : 31
    Par défaut Opengl - Problème avec les arrêtes
    Bonjour,

    Alors voila c'est très simple,
    Je programme une petite appli avec OPENGL, juste pour le fun. Et je suis passé à l'utilisation des lumières. J'arrive à m'en servir, vecteur normal et tout. Mais lorsque j'éclaire une surface plane, pour laquelle j'ai maximiser le nombre de sommet, afin que la lumière puisse être effective au maximum, j'obtiens des strilles qui fausse l'image un peu comme l'aliasing.

    Mieux vaut une bonne image qu'un long discours :p : (voir image en bas du post. AuraHxC)

    C'est bizar.
    Voici un petit bout de code qui montre ma configuration OPENGL :

    Code : 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
     
    //Type de projection, perspective
    		gl.glMatrixMode(GL.GL_PROJECTION);
    		gl.glLoadIdentity();
     
    		glu.gluPerspective(40, FLUX.mainWindowWidth/FLUX.mainWindowHeight, 1.0, 1000.0);
    		gl.glScalef(0.2f, 0.4f, 1);
     
     
     
    		//Taille d'une ligen par default
    		gl.glLineWidth(1.5f);
     
    		//Buffer qOptions
    		gl.glEnable(GL.GL_DEPTH_TEST);
    		gl.glEnable(GL.GL_TEXTURE_2D);
    		gl.glEnable (GL.GL_NORMALIZE);
    		gl.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);
     
     
    		gl.glEnable( GL.GL_POLYGON_SMOOTH );
    		gl.glBlendFunc( GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA );
    		gl.glEnable( GL.GL_BLEND );
     
                            //TEXTURE SOL
    			sol.setTexParameteri(GL.GL_TEXTURE_WRAP_S, GL.GL_REPEAT);
    			sol.setTexParameteri(GL.GL_TEXTURE_WRAP_T, GL.GL_REPEAT);
    			sol.setTexParameteri(GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR);
    			sol.setTexParameteri(GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR);
     
            float[] mambient = {0.11f, 0.06f, 0.11f, 1.0f};
    	float[] mdiffuse = {0.43f, 0.47f, 0.54f, 1.0f};
    	float[] mspecular = {0.33f, 0.33f, 0.52f, 1.0f};
    	float[] memission = {0f, 0f, 0f, 0.0f};
    	float mshininess = 10.0f;
     
    	float[] position = {0.0f, 0.0f, 1f, 1.0f};
    	float[] ambient = {0.0f, 0.0f, 0.0f, 1.0f};
    	float[] diffuse = {1.0f, 1.0f, 1.0f, 1.0f};
    	float[] specular = {1.0f, 1.0f, 1.0f, 1.0f};
     
     
     
    		gl.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, position, 0);
    		gl.glLightfv(GL.GL_LIGHT0, GL.GL_AMBIENT, ambient, 0);
    		gl.glLightfv(GL.GL_LIGHT0, GL.GL_DIFFUSE, diffuse, 0);
    		gl.glLightfv(GL.GL_LIGHT0, GL.GL_SPECULAR, specular, 0);
     
    		gl.glLightf(GL.GL_LIGHT0, GL.GL_SPOT_CUTOFF, 30);
     
    		gl.glMaterialfv(GL.GL_FRONT, GL.GL_AMBIENT, mambient, 0);
    		gl.glMaterialfv(GL.GL_FRONT, GL.GL_DIFFUSE, mdiffuse, 0);
    		gl.glMaterialfv(GL.GL_FRONT, GL.GL_SPECULAR, mspecular, 0);
    		gl.glMaterialfv(GL.GL_FRONT, GL.GL_EMISSION, memission, 0);
    		gl.glMaterialf(GL.GL_FRONT, GL.GL_SHININESS, mshininess);
     
     
    		gl.glEnable(GL.GL_LIGHT0);
     
    		gl.glEnable(GL.GL_COLOR_MATERIAL); 
    		gl.glEnable(GL.GL_LIGHTING);
    ma boucle :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
     
    //On met à jour le tampon
    		gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
     
    		//Affichage et positionnement de la caméra
    		gl.glMatrixMode(GL.GL_MODELVIEW);
    		gl.glLoadIdentity();
    				//gluLookAt( camX, camY, camZ, cibleX, cibleY, cibleZ, vertX, vertY, vertZ );
    				glu.gluLookAt(CameraX, CameraY, CameraZ, CameraCibleX, CameraCibleY, CameraCibleZ, 0, 1, 0);
     
                   //PUIS JE DESSINE...
    Est-ce que quelqu'un saurait d'où cela pourrait-il venir ? :euh:
    Merci à vous,
    Images attachées Images attachées  

  2. #2
    Membre très actif
    Profil pro
    Dev
    Inscrit en
    Mai 2009
    Messages
    257
    Détails du profil
    Informations personnelles :
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Dev

    Informations forums :
    Inscription : Mai 2009
    Messages : 257
    Par défaut
    on dirait que la texture est plaquée sur toute l'image

    un problème de coordonnées de textures peut-être ?

  3. #3
    Membre averti
    Homme Profil pro
    Directeur technique
    Inscrit en
    Juillet 2007
    Messages
    31
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Directeur technique

    Informations forums :
    Inscription : Juillet 2007
    Messages : 31
    Par défaut
    Bonjour,

    Merci d'avoir répondu mais non, la texture est bien affichée. En faite, la texture est très bien affichée quand il s'agit de la lumière "normale" par default.

    Voici la fonction que j'utilise pour afficher mon rectangle. En Faite j'utilise GL_QUAD_STRIP qui m'évite de devoir faire plusieurs GL_QUAD et donc d'appel à GL_BEGIN. De plus, cela me permet de gérer le nombre de subdivision de ma surface avec le parametre "int nb_div" de ma fonction. Car j'ai crû comprendre qu'OpenGL calculait la lumière selon les sommets, et donc, plus il y a de sommet plus la lumière est précise.

    Cette fonction est toute fraiche, il n'y a pas eu d'optimisation. Tant que tout ce que je veux faire ne s'affiche pas, je laisse ça en "brouillon".

    Code : 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
    //MultiTexRectangle(GL gl, float x, float y, float z, float width, float height, int nb_div, int TexEchelle)
    	//nb_div, est le nombre de division en carré de la surface, avec de garantir un nombre important de sommet, s'il faut éclairer la surface
    	private void MultiTexRectangle(GL gl, float x, float y, float z, float width, float height, int nb_div, int TexEchelle){
    		vector normale;
    		//On déssine le rectangle
    		gl.glColor3f( 1.0f, 1.0f, 1.0f );
     
    		gl.glBegin(GL.GL_QUAD_STRIP);
     
    		float nb_div_width = nb_div;
    		float nb_div_height = nb_div;
     
    		float sizew = (width / nb_div_width); //Rect_Division_Size
    		float sizeh = (height / nb_div_height); //Rect_Division_Size
     
     
    		float TexX = 1/nb_div_width;
    		float TexY = 1/nb_div_height;
     
    		TexX *= TexEchelle;
    		TexY *= TexEchelle;
     
     
    		//System.out.println("x:"+normale[0]+" y:"+normale[1]+" z:"+normale[2]);
     
    		//gl.glNormal3f(normale[0], normale[1], normale[2]);
    		//gl.glNormal3f(normale[0], normale[1], normale[2]);
     
     
     
     
     
     
    		gl.glColor3f( 1.0f, 1.0f, 1.0f );
    		for(int i=0;i<nb_div_width;i++){
     
     
    			//VERTEX 1
    			normale = CalculateSurfaceNormal(new float[] {
    					x,  y + i * sizeh + sizeh, z,
    					x, y + i * sizeh, z,
    					x + sizew, y + i * sizeh, z 
    					}, true);
     
    			gl.glNormal3f(normale.x, normale.y, normale.z);
    		gl.glTexCoord2f(0.0f, 1-(i*TexY));  gl.glVertex3f(x, y + i * sizeh, z);    //1 ... Y
     
    			//VERTEX 2
    		normale = CalculateSurfaceNormal(new float[] {
    				x + sizew,  y + i * sizeh + sizeh, z,
    				x,  y + i * sizeh + sizeh, z,
    				x, y + i * sizeh, z 
    				}, true);
    			gl.glNormal3f(normale.x, normale.y, normale.z);
    		gl.glTexCoord2f(0.0f, 1-((i+1)*TexY));  gl.glVertex3f(x,  y + i * sizeh + sizeh, z);   //2 ... Y
     
    			//VERTEX 3
    		normale = CalculateSurfaceNormal(new float[] {
    				x, y + i * sizeh, z,
    				x + sizew, y + i * sizeh, z,
    				x + sizew,  y + i * sizeh + sizeh, z 
    				}, true);
    			gl.glNormal3f(normale.x, normale.y, normale.z);
    		gl.glTexCoord2f(TexX, 1-(i*TexY));  gl.glVertex3f(x + sizew, y + i * sizeh, z);   //3 .. Y
     
    			//VERTEX 4
    		normale = CalculateSurfaceNormal(new float[] {
    				x + sizew, y + i * sizeh, z,
    				x + sizew,  y + i * sizeh + sizeh, z,
    				x,  y + i * sizeh + sizeh, z 
    				}, true);
    			gl.glNormal3f(normale.x, normale.y, normale.z);
    		gl.glTexCoord2f(TexX, 1-((i+1)*TexY));  gl.glVertex3f(x + sizew,  y + i * sizeh + sizeh, z);//4 ... Y
     
     
    		for(int j=1;j<nb_div_height;j++){
    			//VERTEX 5
    			normale = CalculateSurfaceNormal(new float[] {
    					x + sizew*j, y + i * sizeh, z,
    					x + sizew + j * sizew, y + i * sizeh, z,
    					x + sizew + j * sizew, y + i * sizeh + sizeh, z 
    					}, true);
    				gl.glNormal3f(normale.x, normale.y, normale.z);
    			gl.glTexCoord2f((j+1)*TexX,  1-(i*TexY)); gl.glVertex3f(x + sizew + j * sizew, y + i * sizeh, z);//5 ... X
     
    			//VERTEX 6
    			normale = CalculateSurfaceNormal(new float[] {
    					x + sizew + j * sizew, y + i * sizeh, z,
    					x + sizew + j * sizew, y + i * sizeh + sizeh, z,
    					x + sizew*j,  y + i * sizeh + sizeh, z 
    					}, true);
    				gl.glNormal3f(normale.x, normale.y, normale.z);
    			gl.glTexCoord2f((j+1)*TexX,  1-((i+1)*TexY)); gl.glVertex3f(x + sizew + j * sizew, y + i * sizeh + sizeh, z);//6 ... X
    		}
     
    		}
     
     
     
    		gl.glEnd();
     
    	}
    Elle est un peu compliquée à visualiser. Personnellement j'ai beaucoup galéré à la faire, étant donné que je suis un gros débutant d'opengl.

    Voici l'appel à cette fonction dans DISPLAY :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    	gl.glMatrixMode(GL.GL_MODELVIEW);
    		gl.glLoadIdentity();
    				glu.gluLookAt(CameraX, CameraY, CameraZ, CameraCibleX, CameraCibleY, CameraCibleZ, 0, 1, 0);
     
     
    				gl.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, new float[]{SpotX, SpotY, 500f, 1.0f}, 0);
    				gl.glLightfv(GL.GL_LIGHT0, GL.GL_SPOT_DIRECTION, new float[]{SpotCibleX, SpotCibleY, -1f}, 0);
     
    				//Texture a afficher
    				sol.bind();
    				MultiTexRectangle(gl, 0, 0, 0, 800, 600, 100, 5);
    J'espère que quelqu'un y verra une erreur qui résoudra tout.

    Merci à vous,
    Cordialement,

  4. #4
    Membre éclairé
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Avril 2010
    Messages
    517
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Gironde (Aquitaine)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Santé

    Informations forums :
    Inscription : Avril 2010
    Messages : 517
    Par défaut
    Bonjour,
    Je ne vois pas la fonction de test de profondeur.
    Essaye de rajouter au niveau de l'initialisation: glDephtFunc(GL_LEQUAL);

  5. #5
    Membre averti
    Homme Profil pro
    Directeur technique
    Inscrit en
    Juillet 2007
    Messages
    31
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Nord (Nord Pas de Calais)

    Informations professionnelles :
    Activité : Directeur technique

    Informations forums :
    Inscription : Juillet 2007
    Messages : 31
    Par défaut
    Merci d'avoir répondu,
    Non cela ne change rien,

    Bon après minte recherche, j'ai finit pas remarquer que le fait d'avoir des sommets qui se confondent peut poser problème. Donc j'ai décidé d'utiliser les Vertex Arrays qui me semblent plus performant que les DisplayLists dans beaucoup de contextes et qui me "simplifieront la vie".

    Il semble intérressant de s'en servir, car ces tableaux intègrent un système d'indices qui me permet de choisir un sommet plusieurs fois, ainsi éviter la "superposition" de sommets.

    De plus, cela me permet d'utiliser GL_QUAD plusieurs fois plutôt que GL_TRIANGLE_STRIP ou autre qui sont bien compliqués.
    En effet, si j'utilisais QUAD_STRIP c'était pour éviter les gl_begin() gl_end() à répétition.
    Car ils s'ouvrent un accès au pilote à chaque fois. Ce qui detruit les performances :p
    Donc avec les Vertex Arrays je pourrais utiliser GL_QUADS car il n'ouvre un accès pilote qu'au debut du tableau de sommets, puis à la fin de la lecture du tableau.
    Pratique non !
    Et enfin le dernier avantage des Vertex Array c'est qu'ils sont utilisable dans un VertexBuffer. Buffer veut dire tampon. Donc memoire tampon. Donc memoire Vidéo ici. Donc cela permet d'utilsier des "VBO" pour écrire directement mes tableaux dans la memoire de la Carte Graphique.
    Pratique !!

    Je vais mettre ce topic en résolu. Si ce que je dis s'avère fonctionner je viendrais donner des nouvelles. Pas tout de suite vu que c'est secondaire pour moi en ce moment.

    Merci à vous en tout cas.
    Cordialement,

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. [Lazarus] [Linux] Problème avec les points d'arrêts
    Par ovni76 dans le forum Lazarus
    Réponses: 6
    Dernier message: 15/02/2010, 22h45
  2. Problème avec les NURBS avec OPENGL
    Par milena dans le forum Développement 2D, 3D et Jeux
    Réponses: 0
    Dernier message: 10/01/2010, 17h48
  3. Skybox: problème avec les arrêtes
    Par milena dans le forum Développement 2D, 3D et Jeux
    Réponses: 9
    Dernier message: 16/08/2008, 19h16
  4. Projet WinCE 5 : Problème avec les points d'arrêts
    Par arnoo91410 dans le forum Visual Studio
    Réponses: 0
    Dernier message: 31/08/2007, 16h11
  5. [TP] Problème avec les points d'arrêt
    Par 8811fred dans le forum Turbo Pascal
    Réponses: 4
    Dernier message: 30/05/2007, 21h17

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo