# [OpenGL]Problème d'illumination

## Recommended Posts

Salut,

j'ai un problème au niveau de l'illumination de la scene.

J'ai calculé les normales mais ça ne m'affiche pas ce que je souhaite

Voici le code complet

```#include <GL/glut.h>
#include <stdlib.h>
#include <math.h>
#define PI 3.14159263

int angle;

void calcNormal(GLfloat p1[3], GLfloat p2[3], GLfloat p3[3],GLfloat normal[3]);

GLfloat jarre_2d[]={0,0,
3,0,
4,2,
4,5,
3,7,
1,9,
1,11,
3,13};

void lathe(int nbr_vertices, GLfloat profile[], float angle, int nbr_sections) {
int s, v;
float theta1, theta2, x1, y1, z1, x2, y2, z2, x3, y3, z3, x4, y4, z4;
GLfloat p1[3],p2[3],p3[3],normal[3];

for(s=0; s<nbr_sections; s++) {

theta1 = (s*1.0)*angle/nbr_sections*PI/180;
theta2 = (s+1.0)*angle/nbr_sections*PI/180;

for(v=0; v<nbr_vertices-1; v++) {
x1 = profile[v*2]*cos(theta1);
y1 = profile[v*2+1];
z1 = profile[v*2]*sin(theta1);

x2 = profile[v*2+2]*cos(theta1);
y2 = profile[v*2+3];
z2 = profile[v*2+2]*sin(theta1);

x3 = profile[v*2+2]*cos(theta2);
y3 = profile[v*2+3];
z3 = profile[v*2+2]*sin(theta2);

x4 = profile[v*2]*cos(theta2);
y4 = profile[v*2+1];
z4 = profile[v*2]*sin(theta2);

calcNormal(p1,p2,p3,normal);
glBegin(GL_POLYGON);
glNormal3fv(normal);
glVertex3f(x1,y1,z1);
glVertex3f(x2,y2,z2);
glVertex3f(x3,y3,z3);
glVertex3f(x4,y4,z4);
glEnd();

}
}
}

void normalize(GLfloat *vector){

GLfloat length = sqrt(vector[0]*vector[0] + vector[1]*vector[1] + vector[2]* vector[2]);

if( length == 0.0 )
length = 1.0;

vector[0] /= length;
vector[1] /= length;
vector[2] /= length;
}

void calcNormal(GLfloat *p1, GLfloat *p2, GLfloat *p3, GLfloat *n){

GLfloat v1[3];
GLfloat v2[3];

v1[0] = p2[0]-p1[0];
v1[1] = p2[1]-p1[1];
v1[2] = p2[2]-p1[2];
v2[0] = p3[0]-p2[0];
v2[1] = p3[1]-p2[1];
v2[2] = p3[2]-p2[2];

n[0] = v1[1] * v2[2] - v1[2] * v2[1];
n[1] = v1[2] * v2[0] - v1[0] * v2[2];
n[2] = v1[0] * v2[1] - v1[1] * v2[0];

normalize(n);
}

void display(void)
{
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); // Clear the colour and depth buffer

// We set the camera in position 50,50,100 and we look at origo
gluLookAt(50,50,100,0,0,0,0,1,0);
//jarre
glPushMatrix();
glColor3f(0.6,0.2,1.0);
glTranslatef(18,0,4);
glScalef(3,3,3);
lathe(8, jarre_2d, 360.0, 16);

glColor3f(0.6,0.2,1.0);
glTranslatef(0,5,17);
glScalef(5,5,5);
glutSolidCube(1);

/*glColor3f(1.0,0.5,0.5);
glPushMatrix();
glTranslated( 0, 15, 0 );
glScaled(20,20,20);
glutSolidTeapot(1.0);
glPopMatrix();*/

glFlush(); // Makes sure that we output the model to the graphics card
glutSwapBuffers();
}

// Called when a key is pressed
void key(unsigned char k, int x, int y)
{
switch(k){
case 'f':
glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
glutPostRedisplay();
break;
case 'p':
glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
glutPostRedisplay();
break;
case 'q':
exit(0);
}
}

void reshape(int width,int height)
{
glViewport(0,0,width,height); // Reset The Current Viewport

glMatrixMode(GL_PROJECTION); // Select The Projection Matrix
glLoadIdentity(); // Reset The Projection Matrix

// Calculate The Aspect Ratio Of The Window
gluPerspective(45.0f,(float)640/(float)480,0.1f,1000.0f);
// Always keeps the same aspect as a 640 wide and 480 high window

glMatrixMode(GL_MODELVIEW); // Select The Modelview Matrix
glLoadIdentity(); // Reset The Modelview Matrix
}

void init()
{
glClearColor(0,0,0,0);
glClearDepth(1.0); // Enables Clearing Of The Depth Buffer
glDepthFunc(GL_LESS); // The Type Of Depth Test To Do
glEnable(GL_DEPTH_TEST); // Enables Depth Testing
}

void setupRC(){
glDepthFunc(GL_LESS);
glEnable(GL_DEPTH_TEST);
glFrontFace(GL_CCW);

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glEnable(GL_LIGHTING);

GLfloat diffuseLight[] = {0.7,0.7,0.7,1.0};
glLightfv(GL_LIGHT0,GL_DIFFUSE,diffuseLight);
glEnable(GL_LIGHT0);

glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);

GLfloat ambientLight[] = {0.05,0.05,0.05,1.0};
glLightfv(GL_LIGHT0,GL_AMBIENT,ambientLight);

GLfloat specularLight [] = {0.7,0.7,0.7,1.0};
GLfloat spectre [] = {1.0,1.0,1.0,1.0};
glLightfv(GL_LIGHT0,GL_SPECULAR,specularLight);
glMaterialfv(GL_FRONT, GL_SPECULAR, spectre);
glMaterialf(GL_FRONT,GL_SHININESS,128);

GLfloat lightPosition [] = {600,10,200,1};
glLightfv(GL_LIGHT0,GL_POSITION,lightPosition);
}

int main(int argc, char *argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB|GLUT_DOUBLE); // We want rgb display functionality
glutInitWindowSize(640,480); // Set the window dimensions
glutInitWindowPosition(0,0); // Set the window starting point
glutCreateWindow("Exercise 1"); // Set the caption and launch the window

angle = 0;

init();
setupRC();

// Last things before rendering starts
glutDisplayFunc(display); // This will be called every frame
glutReshapeFunc(reshape); // Reshape the window when something changes
glutKeyboardFunc(key); // Callback for input

glutMainLoop(); // Starts the main program

// We will not reach this point unless exit(0) is called (see function keyCB)

return 0;
}

```

Ce que j'obtiens :

http://img222.imageshack us/my.php?image=capturezm3.png