demande d'aide-opengl C debutant

**Ben's49** · 02/09/2018, 18h28

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** · 03/09/2018, 06h44

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** · 03/09/2018, 11h53

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** · 03/09/2018, 15h14

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

**Ben's49** · 03/09/2018, 17h45

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** · 03/09/2018, 18h05

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.

**Ben's49** · 03/09/2018, 18h30

Ok bien entendu. Merci.je vais essayer de m'y mettre dans SDL et surtout opengl 3.0.comme c'est le plus mieux. Tu as des liens interessantes ou autres a ce sujet pour moi?en attendant je vois sur google.encore une fois merci Kannagi.

**Kannagi** · 03/09/2018, 18h56

On t'a deja donner un lien :

Envoyé par LittleWhite

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** · 04/09/2018, 03h08

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

**Kannagi** · 17/09/2018, 14h20

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

**LittleWhite** · 17/09/2018, 14h30

Envoyé par Kannagi

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

Qui plus est, lorsqu'ils sont traduits ici (partiellement, mais y a les bases) et en cours de traduction ici.

Et celui qui va me dire que comme c'est partiel, c'est nul... je le tape, car :

ce que propose les autres ne vont pas plus loin que ce qui a déjà été traduit ;
il y a bel et bien un tuto complet de dispo (et bientôt deux, si le responsable de rubrique était un peu plus aidé ) ;
une fois que vous avez lu en français ce qui est déjà dispo, vous pouvez passer sur les ressources originales, toutes aussi gratuites

(Et puis je trouve que regarder des vidéos fait perdre énormément de temps, à tel point que je mets 1.5x sur Youtube.)

**Ben's49** · 17/09/2018, 17h31

Moi personnellement,j'admire du fond du coeur tout ce qui sont derriere ce forum,qui se consacre a vraiment aider. A chaque probleme,j'ai du rechercher et trouver mon bonheur ici surtout.j'admire vraiment,de meme,il y'a plein de cours et meilleurs pdf gratuit de quelques kilo-octets et tres top.il suffit de rechercher ici,et boum l'on se retrouve. Vraiment merci a tous ce qui derriere sa,les moderateurs,et ceux qui mettent a notre disposition des cours pdf,epub et autre,et surtout merci a ceux qui contribue par leurs reponses chaques jours par des idées incroyables.vraiment ce forum est le top pour moi

demande d'aide-opengl C debutant

OpenGL

Discussions similaires

Partager

Partager