Discussion :

[Ben's49]

salut a tous,je debute dans opengl en langage C sous GLUT.svp j'ai besoin d'aide,voila j'ai mon code d'essai sur les materiaux,lumieres,et les normales,c'est juste un cube applati pour un essai;après avoir parcouru presque tous les tutoriels du moins ce que j'ai pu avoir sur le net,je souhaite avoir vos lumieres sur mon bout de code ci dessous,voila mes preoccupations:
est ce que ma definition d'une fonction a part pour un materiau est bien (je veux dire sa joue pas sur la memoire et l'execution)?
mes normales sont-elles justes?(malgré j'ai verifié et tout)
le paramètrage de la lumière sont-elles bonnes?
concernant l'attenuation de la lumiere,il y'en a 3:constant,linear,et quadratic_attenuation,on peut les utiliser tous les 3 a la fois? ou une seule a la fois?c'est quoi la difference entre les trois?
pour le chargement d'une texture,est ce possible de charger une texture avec GLUT?sinon puis-je faire le chargement avec SDL_image en C dans ce meme code(opengl/glut)?svp

svp merci d'avance de bien vouloir m'aider.

voici mon code:

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
#include <GL/gl.h>
#include <GL/glut.h>
 
void silver()
{
    GLfloat mat_amb[]={0.19,0.19,0.19,1.00};
    GLfloat mat_diff[]={0.51,0.51,0.51,1.00};
    GLfloat mat_spec[]={0.51,0.51,0.51,1.00};
    GLfloat mat_emiss[]={0.00,0.00,0.00,1.00};
    GLfloat mat_shinn[]={25};
    glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT,mat_amb);
    glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,mat_diff);
    glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,mat_spec);
    glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,mat_emiss);
    glMaterialfv(GL_FRONT_AND_BACK,GL_SHININESS,mat_shinn);
}
 
 
 
void test()
{
        glEnable(GL_BLEND);
        glEnable(GL_LIGHTING);
        glEnable(GL_LIGHT0);
        glShadeModel(GL_FLAT);
        glEnable(GL_SHADE_MODEL);
        //LUMIERE ET PARAMETRE D'ECLAIRAGES//
                GLfloat light_posi1[]={1.0,3.00,3.00,1.00};
                GLfloat light_amb[]={1.0,1.0,1.0,1.00};
                GLfloat light_diff[]={1.00,1.00,1.00,1.00};
                GLfloat light_spec[]={1.00,1.00,1.00,1.00};
 
                glLightfv(GL_LIGHT0,GL_POSITION,light_posi1);
                glLightfv(GL_LIGHT0,GL_AMBIENT,light_amb);
                glLightfv(GL_LIGHT0,GL_DIFFUSE,light_diff);
                glLightfv(GL_LIGHT0,GL_SPECULAR,light_spec);
 
                glLightf(GL_LIGHT0,GL_CONSTANT_ATTENUATION,1);
 
                glEnable(GL_NORMALIZE);
            glEnable(GL_COLOR_MATERIAL);
                //surface//
                glBegin(GL_QUADS);
                glColor3f(1.0,1.0,0.0);
                glNormal3f(0.0,1.0,0.0);
                glVertex3f(-10.0,-5.0,-10.0);
                glVertex3f(-10.0,-5.0,10.0);
                glVertex3f(10.0,-5.0,10.0);
                glVertex3f(10.0,-5.0,-10.0);
                glEnd();
            glDisable(GL_COLOR_MATERIAL);
            //--liste--d'identifiant--5--//
 
            GLint liste1;
            liste1=glGenLists(5);
            glNewList(liste1,GL_COMPILE_AND_EXECUTE);
 
                    //----mon---objet----//
                    GLfloat  a1[3]={0.0,1.0,2.0};
                    GLfloat  a2[3]={2.0,1.0,2.0};
                    GLfloat  a3[3]={2.0,1.5,2.0};
                    GLfloat  a4[3]={0.0,1.5,2.0};
                    GLfloat  a5[3]={0.0,1.0,5.0};
                    GLfloat  a6[3]={2.0,1.0,5.0};
                    GLfloat  a7[3]={2.0,1.5,5.0};
                    GLfloat  a8[3]={0.0,1.5,5.0};
 
                    silver();
                    glBegin(GL_QUADS);
                    glNormal3f(0.0,0.0,1.0);
                    glVertex3fv(a1);
                    glVertex3fv(a2);
                    glVertex3fv(a3);
                    glVertex3fv(a4);
 
                    glNormal3f(1.0,0.0,0.0);
                    glVertex3fv(a2);
                    glVertex3fv(a6);
                    glVertex3fv(a7);
                    glVertex3fv(a3);
 
                    glNormal3f(0.0,-1.0,0.0);
                    glVertex3fv(a1);
                    glVertex3fv(a2);
                    glVertex3fv(a6);
                    glVertex3fv(a5);
 
                    glNormal3f(0.0,0.0,-1.0);
                    glVertex3fv(a5);
                    glVertex3fv(a6);
                    glVertex3fv(a7);
                    glVertex3fv(a8);
 
                    glNormal3f(0.0,1.0,0.0);
                    glVertex3fv(a4);
                    glVertex3fv(a3);
                    glVertex3fv(a7);
                    glVertex3fv(a8);
 
                    glNormal3f(-1.0,0.0,0.0);
                    glVertex3fv(a5);
                    glVertex3fv(a1);
                    glVertex3fv(a4);
                    glVertex3fv(a8);
                    glEnd();
 
            glEndList();
            glRotatef(45.0,1.0,0.0,0.0);
            glCallList(liste1);
 
            glTranslatef(3.0,0.0,0.0);
            glCallList(liste1);
 
}
void Affichage()
{
    glClearColor(0,1,1,1.0);
 
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
 
    glEnable(GL_DEPTH_TEST);
 
    test();
 
    glFlush();
}
void perspective(int w,int h)
{
 
    GLdouble a=(GLdouble)w/h;
    GLdouble n=0.5,f=50.0;
    GLdouble fovy=60.0;
    glViewport(20,20,w,h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
 
    gluPerspective(fovy,a,n,f);
    glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(
              5.0,2.0,15.0,
              3.0,1.0,0.0,
              0.0,1.0,0.0
              );
 
}
 
int main ( int argc, char * argv[] ) {
 
    /* initialize GLUT, using any commandline parameters passed to the
       program */
    glutInit(&argc,argv);
 
    /* setup the size, position, and display mode for new windows */
    glutInitWindowSize(1000,700);
    glutInitWindowPosition(0,0);
    glutInitDisplayMode(GLUT_RGB|GLUT_DEPTH|GLUT_MULTISAMPLE);
    /* create and set up a window */
    glutCreateWindow("test");
 
    glutDisplayFunc(Affichage);
    //glutKeyboardFunc(keyboard);
    glutReshapeFunc(perspective);
    /* tell GLUT to wait for events */
    glutMainLoop();
 
    return 0;
}

[Kannagi]

Alors beaucoup de choses a dire déjà ne jamais utiliser GLUT (lui préférer freeglut) , et sinon non GLUT ne permet pas de charger une texture , tu peux rajouter SDL_image sur GLUT sans souci.
Pour le code , ton code OpenGL est dépassé , principalement parce que tu utilise GLbegin,glVertex3f,glCallList etc , tout cela est obsolète.
A la limite je conseille les VA a la place , ne pas utiliser glu , et ni utiliser gltranslatef/glrotatef etc , ça fait pas mal de chose a ne pas faire , pour la gestion de la lumière tu perd ton temps OpenGL 1 sur ce coté la est vraiment dépassé , autant utiliser des shaders sur des versions OpenGL plus récente.
Bref je te conseille de passer à OpenGL 3 , la gestion des lumière est beaucoup plus simple (vu que tu décidera directement quel valeur affecter a chaque pixel) et tu trouvera beaucoup plus de ressource aussi

[LittleWhite]

Bonjour,

Je suis d'accord avec Kannagi.

après avoir parcouru presque tous les tutoriels du moins ce que j'ai pu avoir sur le net,

Je ne comprends pas que l'on puisse encore tomber sur des tutoriels OpenGL 1. Du coup, n'hésitez pas à regarder de ce côté : https://opengl.developpez.com (y a pas mal de ressources, avec de bonnes explications de ce qui se passe).

[Ben's49]

Merci kannagi et littleWhite de vos conseils.je passe au version recente.

[Ben's49]

Au faite c'est quoi les VA?et pour utiliser SDL_IMAGE sur GLUT,c'est avec un projet SDL ou un projet GLUT? ET si je compte utiliser FREEGLUT,puis l'utiliser aussi avec SDL_IMAGE?

[Kannagi]

VA pour Vertex Array , mais si tu fait de OpenGL 3 , le mieux est d'utiliser des VBO (Vertex Buffer Object).
Je comprend pas le terme de 'projet' , mais entre glut et SDL il faut mieux utiliser la SDL , après rien ne t’empêche d'avoir freeglut pour gérer la fenêtre et le clavier et la SDL_Image pour charger des textures.

[Kannagi]

On t'a deja donner un lien :

Je ne comprends pas que l'on puisse encore tomber sur des tutoriels OpenGL 1. Du coup, n'hésitez pas à regarder de ce côté : https://opengl.developpez.com (y a pas mal de ressources, avec de bonnes explications de ce qui se passe).

Par exemple tu as ceci : https://opengl.developpez.com/tutori...engl-tutorial/

NT: Par contre si tu veux faire de l'OpenGL 4 , je le trouve un peu inutile , il faut mieux utiliser Vulkan a la place

[Ben's49]

ok oui j'ai vu tout et je les ai(des bons tutoriels en tout cas).bien merci

[Kannagi]

Totalement d'accord , je rajouterai http://ogldev.atspace.co.uk/ et https://learnopengl.com/

Mais peu importe le prix , payer pour apprendre OpenGL est une arnaque.
Déjà parce que celui qui achète ce genre de cours est un débutant donc il fera rien (ou pas grand chose ) avec , et celui qui me dit que c'est pour apprendre comment ça marche derrière , je le tape !
Je crois qu'on a vu plein de débutant qui font de OpenGL ici est qui n'ont aucune connaissance sur comment fonctionne la pipeline graphique