Appliquer lumière sur les deux faces d'un polygone

**choko83** · 13/01/2011, 10h33

Bonjour,
Je programme avec JOGL. J'ai un petit soucis avec la lumière. J'aimerai appliquer la lumière sur les deux faces de chaque polygone de mon modèle en utilisant l'instruction:

Code :

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

1
2
 
 gl.glLightModeli(GL.GL_LIGHT_MODEL_TWO_SIDE,1);

Cependant, j'obtiens parfois des polygones avec une seule face éclairée.
Pourriez-vous m'aider à résoudre le problème?
Merci d'avance.

**ShevchenKik** · 13/01/2011, 10h36

Bonjour,

peux-tu mettre une capture d'écran du probleme? Normalement

gl.glLightModeli(GL.GL_LIGHT_MODEL_TWO_SIDE,1);

te permet ca mais le probleme peut venir d'ailleurs...définition de tes normales, culling de la face arriere, etc...

Bah tant qu'à faire met du code aussi

**choko83** · 13/01/2011, 11h51

Envoyé par ShevchenKik

Bonjour,

Bah tant qu'à faire met du code aussi

Voilà comment j'initialise ma scène:

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
103
 
public void init(GLAutoDrawable drawable) 
	    	{
	    		setSize(new Dimension(1723, 1004));
	    		PredicatePanel.setSize(new Dimension(891, 97));
 
 
	    		drawable.setGL(new DebugGL(drawable.getGL()));
	    		gl = drawable.getGL();
 
	    		textRenderer = new TextRenderer(new Font("Arial", Font.PLAIN, 12), true,true);
 
 
	    		//gl.glLoadIdentity();
 
	    		camera = new Camera(0,20,20,//Position
	                    			0,0,0,  // Target
	                    			0,0,1);//up vector
 
 
	    		/*glu.gluLookAt(20,20,20,//Position
	                           0,0,0,  // Target
	                           0,0,1);//Up vector*/		
 
 
 
	    		gl.glClearColor(0.17f, 0.65f, 0.92f, 0.0f);// Blue Sky Clor for the backGround (Sky)
	    		gl.glClearDepth(1.0f);
	    		//gl.glLoadIdentity();
	    		/*allModels3D.add(new Model3D());
	    		allModels3D.get(layerNumber).setGL(gl);
	    		allModels3D.get(layerNumber).setGLU(glu);
	    		allModels3D.get(layerNumber).setCamera(camera);*/
 
 
	    		//gl.glMatrixMode( GL.GL_MODELVIEW );
 
	    		mat_specular[0] = 1.0f;
	    		mat_specular[1] =1.0f;
	    		mat_specular[2] =1.0f;
	    		mat_specular[3] =1.0f;
 
	    	    light_position[0] =10.0f;
	    	    light_position[1] =10.0f;
	    	    light_position[2] =50.0f;
	    	    light_position[3] = 0.0f;
 
	    	    diffuseMaterial[0] =0.5f;
	    	    diffuseMaterial[1]=0.5f ;
	    	    diffuseMaterial[2] =1.0f;
	    	    diffuseMaterial[3]=1.0f;
 
	    	    white[0]=1.0f;
	    	    white[1]=1.0f;
	    	    white[2]=1.0f;
	    	    white[3]=1.0f;
 
 
	    	    gl.glMaterialfv(GL.GL_FRONT, GL.GL_DIFFUSE, diffuseMaterial, 0);
	    	    gl.glMaterialfv(GL.GL_FRONT, GL.GL_SPECULAR, mat_specular, 0);
	    	    gl.glMaterialf(GL.GL_FRONT, GL.GL_SHININESS, 25.0f);
	    	    gl.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, light_position, 0);
	    	    gl.glLightfv(GL.GL_LIGHT0, GL.GL_AMBIENT, FloatBuffer.wrap(white));
 
	    	    gl.glEnable(GL.GL_LIGHTING);
	    	    gl.glEnable(GL.GL_LIGHT0);
	    	    gl.glDepthFunc(GL.GL_LESS);
	    	    gl.glEnable(GL.GL_DEPTH_TEST);
	    	    gl.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT,GL.GL_NICEST);
 
	    	    gl.glColorMaterial(GL.GL_FRONT, GL.GL_DIFFUSE);
	    	    gl.glEnable(GL.GL_COLOR_MATERIAL);
 
 
	    	    //gl.glLightModeli(GL.GL_LIGHT_MODEL_TWO_SIDE,1);
 
 
 
 
 
	    		drawable.addMouseListener(this); 
	    		drawable.addMouseMotionListener(this); 
	    		drawable.addMouseWheelListener(this); 
	    		drawable.addKeyListener(this); 
	    		this.addMouseListener(this);
	    		this.addMouseMotionListener(this);
	    		this.addMouseWheelListener(this);
	    		this.requestFocus();
 
	    		gl.glMatrixMode(GL.GL_PROJECTION);
	            gl.glLoadIdentity();
	            glu.gluOrtho2D(0, drawable.getWidth(), 0, drawable.getHeight());
	            gl.glMatrixMode(GL.GL_MODELVIEW);
	            gl.glLoadIdentity();
                //The scene animator 
	    		anim = new FPSAnimator(drawable,fps);
	    		anim.start();
	    		//User Authentification frame
	    		getUserLoginFrame();
		    	userLoginFrame.setVisible(true);
		    	//this.setEnabled(false);
 
	        }

Et voilà la fonction permettant de déssiner un polygone

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
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
 
public void drawPolygon(Point3D barycenter, Color color, float transparency)
{
	Form= this.getPolygonForm();
	gl.glPushMatrix();
 
	gl.glEnable (GL.GL_BLEND);
	gl.glBlendFunc (GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
 
 
   //gl.glEnable(GL.GL_TEXTURE_2D);
   //gl.glShadeModel(GL.GL_SMOOTH);
 
   double normalVector[]=new double[3];
   normalVector[0]=0;
   normalVector[0]=1;
   normalVector[0]=0;
 
 
   if(color == null)
   {
	 float colors[] = {1,1,1,transparency};
     gl.glColor4fv(colors,0);
   }
   else
   {
	 float colors[] = {(float)color.getRed()/256,(float)color.getGreen()/256,(float)color.getBlue()/256,transparency};
	 gl.glColor4fv(colors,0);
   }   
 
   if (ThePolygonPoints.size()>2)
   {
	   normalVector=SurfaceNormal(getPoint(0).getX(),getPoint(0).getY(),getPoint(0).getZ(),getPoint(1).getX(),getPoint(1).getY(),getPoint(1).getZ(),getPoint(2).getX(),getPoint(2).getY(),getPoint(2).getZ());
   }
	// 1) We test if there is no texture for the Polygon
	if (TextureID == -1)
    {
		  gl.glDisable(GL.GL_TEXTURE_2D);
          //1.1) We draw a polyline
		   if(Form.toUpperCase().equals("LINE"))
		   {
			   // We begin drawing the Triangle
 
				gl.glNormal3f((float)normalVector[0],(float)normalVector[1],(float)normalVector[2]);
				gl.glBegin(GL.GL_LINES);
 
 
		        for (int i=ThePolygonPoints.size()-1;i>=0 ;i--)
		        { 	
		    	  gl.glVertex3d(getPoint(i).getX()-barycenter.getX(),getPoint(i).getY()-barycenter.getY(),getPoint(i).getZ()-barycenter.getZ());	
		        }
		        gl.glEnd();
 
		   } 
 
	   // 1.2) We draw a Triangle
	   if(Form.toUpperCase().equals("TRIANGLE"))
	   {
		   // We begin drawing the Triangle
 
			gl.glNormal3f((float)normalVector[0],(float)normalVector[1],(float)normalVector[2]);
			gl.glBegin(GL.GL_TRIANGLES);
 
 
	        for (int i=ThePolygonPoints.size()-1;i>=0 ;i--)
	        { 	
	    	  gl.glVertex3d(getPoint(i).getX()-barycenter.getX(),getPoint(i).getY()-barycenter.getY(),getPoint(i).getZ()-barycenter.getZ());	
	        }
	        gl.glEnd();
	   }
 
	   // 1.3) We draw a Quad
	   if(Form.toUpperCase().equals("QUAD"))
	   {
		  gl.glNormal3f((float)normalVector[0],(float)normalVector[1],(float)normalVector[2]);
		  gl.glBegin(GL.GL_QUADS);
 
 
		  for (int i=ThePolygonPoints.size()-1;i>=0 ;i--)
	      {   
	    	gl.glVertex3d(getPoint(i).getX()-barycenter.getX(),getPoint(i).getY()-barycenter.getY(),getPoint(i).getZ()-barycenter.getZ());
	      }
	        gl.glEnd();
	    }
 
	   // 1.4) We draw a Polygon
	   if(Form.toUpperCase().equals("POLYGON"))
	   {  
 
		gl.glNormal3f((float)normalVector[0],(float)normalVector[1],(float)normalVector[2]);
		gl.glBegin(GL.GL_POLYGON);
 
 
 
		for (int i=0;i<ThePolygonPoints.size() ;i++)
	    {   
	    	gl.glVertex3d(getPoint(i).getX()-barycenter.getX(),getPoint(i).getY()-barycenter.getY(),getPoint(i).getZ()-barycenter.getZ());
	    }
	    gl.glEnd();
	    }
    }
 
	// 2) If the polygon has a texture 
 
	else
	{
		gl.glPushMatrix();
		gl.glEnable(GL.GL_TEXTURE_2D);
        //gl.glBindTexture(GL.GL_TEXTURE_2D, TextureID);
        gl.glPopMatrix();
        if(color != null)
        {
     	 gl.glColor3f((float)color.getRed()/256,(float)color.getGreen()/256,(float)color.getBlue()/256);
        } 
 
           //2.1) We draw a polyline
		   if(Form.toUpperCase().equals("LINE"))
		   {
			   // We begin drawing the Triangle
 
				gl.glNormal3f((float)normalVector[0],(float)normalVector[1],(float)normalVector[2]);
				gl.glBegin(GL.GL_LINES);
 
 
		        for (int i=ThePolygonPoints.size()-1;i>=0 ;i--)
		        { 	
		    	  gl.glVertex3d(getPoint(i).getX()-barycenter.getX(),getPoint(i).getY()-barycenter.getY(),getPoint(i).getZ()-barycenter.getZ());	
		        }
		        gl.glEnd();
 
		   } 
        // 2.2) We draw a Triangle 
        if(Form.toUpperCase().equals("TRIANGLE"))
 	   {
        	tackleAutomaticTexture(gl, this.getPolygonTextureID()); 
        	gl.glBegin(GL.GL_TRIANGLES);
    		gl.glNormal3f(0,0,1.0f);
    		for (int i=0;i< 3;i++)
    		{ 
 
    			gl.glVertex3d(getPoint(i).getX()-barycenter.getX(),getPoint(i).getY()-barycenter.getY(),getPoint(i).getZ()-barycenter.getZ());	
    		}
    		gl.glEnd();
    		disableAutomaticTexture(gl);
 	    }
        //gl.glEnable(GL.GL_CULL_FACE) ;
     // 2.3) We draw a Quad
 	   if(Form.toUpperCase().equals("QUAD"))
 	   {
 		//disableAutomaticTexture(gl);
 		int texcoord[][]=new int[4][2];
 		texcoord[0][0]=0;texcoord[0][1]=0;
 		texcoord[1][0]=1;texcoord[1][1]=0;
 		texcoord[2][0]=1;texcoord[2][1]=1;
 		texcoord[3][0]=0;texcoord[3][1]=1;
 		//gl.glCullFace(GL.GL_FRONT);
 		gl.glBegin(GL.GL_QUADS);
 		gl.glNormal3f(0,0,1.0f);
 	    for (int i=0;i<4;i++)
 	    {  
 	    	gl.glTexCoord2d(texcoord[i][0],texcoord[i][1]);
 	    	gl.glVertex3d(getPoint(i).getX()-barycenter.getX(),getPoint(i).getY()-barycenter.getY(),getPoint(i).getZ()-barycenter.getZ()); 
 	    }
 	    gl.glEnd();
 	    }
 	   // 2.4) We draw a Polygon
 	  if(Form.toUpperCase().equals("POLYGON"))
	   {
 		tackleAutomaticTexture(gl,this.getPolygonTextureID()); 
 		gl.glCullFace(GL.GL_FRONT);
  		gl.glBegin(GL.GL_POLYGON);
  		gl.glNormal3f(0,0,1.0f);
  	    for (int i=0;i<ThePolygonPoints.size();i++)
  	    {   
  	    	gl.glVertex3d(getPoint(i).getX()-barycenter.getX(),getPoint(i).getY()-barycenter.getY(),getPoint(i).getZ()-barycenter.getZ());
  	    }
  	    gl.glEnd();
  	    disableAutomaticTexture(gl);
	    }
 	 disableAutomaticTexture(gl);
 	 PolygonTexture = -1;
	 }
	gl.glDisable (GL.GL_BLEND);
	gl.glPopMatrix();//On dépile la matrice
 
} // End drawPolygon method

**ShevchenKik** · 13/01/2011, 12h02

Re,

sans regarder plus loin, je vois que tu ne définis tes matériaux que pour la face avant:

Code :

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

1
2
3
4
gl.glMaterialfv(GL.GL_FRONT, GL.GL_DIFFUSE, diffuseMaterial, 0);
	    	    gl.glMaterialfv(GL.GL_FRONT, GL.GL_SPECULAR, mat_specular, 0);
...
 gl.glColorMaterial(GL.GL_FRONT, GL.GL_DIFFUSE);

Essaie avec GL_FRONT_AND_BACK, c peut être ca tout simplement

**choko83** · 13/01/2011, 14h12

Envoyé par ShevchenKik

Re,
Essaie avec GL_FRONT_AND_BACK, c peut être ca tout simplement

J'ai l'avais changé, mais ça ne résoud pas le problème.

**dragonjoker59** · 13/01/2011, 17h36

Si tu veux obtenir l'effet que tu veux (id est : face éclairée des 2 côtés), il te faut créer 2 faces, afin d'avoir la normale qui pointe du bon côté de chaque face.
En effet OpenGL ne te permet pas d'assigner 2 normales à un vertex en même temps. Il te faut donc dessiner une face dans un sens avec la normale qui va bien, puis "retourner" cette face (la dessiner dans l'autre sens) avec la seconde normale. Ainsi tu auras l'effet voulu.

**choko83** · 13/01/2011, 18h48

Envoyé par dragonjoker59

Si tu veux obtenir l'effet que tu veux (id est : face éclairée des 2 côtés), il te faut créer 2 faces, afin d'avoir la normale qui pointe du bon côté de chaque face.
En effet OpenGL ne te permet pas d'assigner 2 normales à un vertex en même temps. Il te faut donc dessiner une face dans un sens avec la normale qui va bien, puis "retourner" cette face (la dessiner dans l'autre sens) avec la seconde normale. Ainsi tu auras l'effet voulu.

Je suis pas tout à fait d'accord avec toi. Car pour un modèle de 10.000.000 de polygones, doubler le nombre de polygones sera vachement pénalisant et peut dégrader d'une manière importante le calcul.

Appliquer lumière sur les deux faces d'un polygone

OpenGL

Vue hybride

Discussions similaires

Partager

Partager