Discussion :

[nikhun]

Voila ca peu sembler extrement simple pour certain mais je galere, jai chercher un maximum de documentation et ne comprend toujours pas comment appliquer un shader a un objet creer en opengl.

jai vu qu'il faut appliquer ces fonctions mais je comprend pas comment les metres en pratique concretement ...

1. Créer un ou plusieurs objets (vides) de shader en appelant le glCreateShader.
2. Fournir le code source pour ces shaders en appelant le glShaderSource.
3. Compiler chacun des shaders en appelant le glCompileShader.
4. Créer un objet de programme en appelant le glCreateProgram.
5. Attacher tous objets de shader à l'objet de programme en appelant le glAttachShader.
6. Lier l'objet de programme en appelant le glLinkProgram.
7. Installer le programme exécutable en tant qu'élément de l'état actuel d'OpenGL en appelant le glUseProgram.

Je comprend que certain peuvent dire que ce post est inutil mais jai eplucher tout les sujet du forum sans rien trouver, je n'utilise pas dev++ c'est peut mon tord, car je compile tout sous linux en travaillant uniquement en c ...
Ainsi ma grande question est quel son les modifications a aporter a mon programme opengl de cube qui se trouve ci dessous pour pouvoir le compiler en lui applikan le shader "toon" ?

Pour moi la reponse apporter aura la valeur d'un tutorial, car la liaison prog opengl et shader est vraiment obscure pour moi ....

merci de vos reponses, car je block depuis quelques jours ...
----------------

(vertex)

Code :

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

1
2
3
4
5
6
7
8
varying vec3 vNormal;
varying vec3 vVertex;
void main(void)
{
 vVertex = gl_Vertex.xyz;
 vNormal = gl_Normal; 
 gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
}

(fragment)

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
varying vec3 vNormal;
varying vec3 vVertex;
uniform vec3 eyePos;
uniform vec3 lightPos;
#define shininess 20.0
void main (void)
{         
 
vec3 Normal = normalize(gl_NormalMatrix * vNormal);
vec3 EyeVert = normalize(eyePos - vVertex);
vec3 LightVert = normalize(lightPos - vVertex);
vec3 EyeLight = normalize(LightVert+EyeVert);
float sil = max(dot(Normal,EyeVert), 0.0);
if (sil < 0.3) gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
gl_FragColor = vec4(0.8, 0.0, 0.0, 1.0);
/*float spec = pow(max(dot(Normal,EyeLight),0.0), shininess);   
if (spec < 0.2) 
  gl_FragColor *= 0.8;
else 
  gl_FragColor = vec4(0.8, 0.0, 0.0, 1.0);
float diffuse = max(dot(Normal,LightVert),0.0);
if (diffuse < 0.5) 
  gl_FragColor *=0.8; */  
}

a ce cube tirer dun exemple d'introduction a 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
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
/********************************************************/
/*                     cube.c                           */
/********************************************************/
/* Affiche a l'ecran un cube en 3D                      */
/********************************************************/
 
/* inclusion des fichiers d'en-tete Glut */
 
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
 
/* Notre structure point */
 
typedef struct
{
  float x;
  float y;
  float z;
  float r;
  float g;
  float b;
} point;
 
point p[8]={
    {-0.5,-0.5, 0.5,1.0,0.0,0.0},
    {-0.5, 0.5, 0.5,0.0,1.0,0.0},
    { 0.5, 0.5, 0.5,0.0,0.0,1.0},
    { 0.5,-0.5, 0.5,1.0,1.0,1.0},
    {-0.5,-0.5,-0.5,1.0,0.0,0.0},
    {-0.5, 0.5,-0.5,0.0,1.0,0.0},
    { 0.5, 0.5,-0.5,0.0,0.0,1.0},
    { 0.5,-0.5,-0.5,1.0,1.0,1.0}};
 
int f[6][4]={
  {0,1,2,3},
  {3,2,6,7},
  {4,5,6,7},
  {0,1,5,4},
  {1,5,6,2},
  {0,4,7,3}};
 
char presse;
int anglex,angley,x,y,xold,yold;
 
/* Prototype des fonctions */
void affichage();
void clavier(unsigned char touche,int x,int y);
void reshape(int x,int y);
void idle();
void mouse(int bouton,int etat,int x,int y);
void mousemotion(int x,int y);
 
int main(int argc,char **argv)
{
  /* initialisation de glut et creation
     de la fenetre */
  glutInit(&argc,argv);
  glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
  glutInitWindowPosition(200,200);
  glutInitWindowSize(250,250);
  glutCreateWindow("cube");
 
  /* Initialisation d'OpenGL */
  glClearColor(0.0,0.0,0.0,0.0);
  glColor3f(1.0,1.0,1.0);
  glPointSize(2.0);
  glEnable(GL_DEPTH_TEST);
 
  /* enregistrement des fonctions de rappel */
  glutDisplayFunc(affichage);
  glutKeyboardFunc(clavier);
  glutReshapeFunc(reshape);
  glutMouseFunc(mouse);
  glutMotionFunc(mousemotion);
 
  /* Entree dans la boucle principale glut */
  glutMainLoop();
  return 0;
}
 
 
void affichage()
{
  int i,j;
  /* effacement de l'image avec la couleur de fond */
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
  glLoadIdentity();
  glRotatef(-angley,1.0,0.0,0.0);
  glRotatef(-anglex,0.0,1.0,0.0);
  /* Dessin du cube */
  for (i=0;i<6;i++)
    {
      glBegin(GL_POLYGON);
      for (j=0;j<4;j++)
	{
	  glColor3f(p[f[i][j]].r,p[f[i][j]].g,p[f[i][j]].b);
	  glVertex3f(p[f[i][j]].x,p[f[i][j]].y,p[f[i][j]].z);
	}
      glEnd();
    }
  glFlush();
 
  /* On echange les buffers */
  glutSwapBuffers();
}
 
void clavier(unsigned char touche,int x,int y)
{
  switch (touche)
    {
    case 'p': /* affichage du carre plein */
      glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
      glutPostRedisplay();
      break;
    case 'f': /* affichage en mode fil de fer */
      glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
      glutPostRedisplay();
      break;
    case 's' : /* Affichage en mode sommets seuls */
      glPolygonMode(GL_FRONT_AND_BACK,GL_POINT);
      glutPostRedisplay();
      break;
    case 'd':
      glEnable(GL_DEPTH_TEST);
      glutPostRedisplay();
      break;
    case 'D':
      glDisable(GL_DEPTH_TEST);
      glutPostRedisplay();
      break;
    case 'q' : /*la touche 'q' permet de quitter le programme */
      exit(0);
    }
}
 
void reshape(int x,int y)
{
  if (x<y)
    glViewport(0,(y-x)/2,x,x);
  else 
    glViewport((x-y)/2,0,y,y);
}
 
void mouse(int button, int state,int x,int y)
{
  /* si on appuie sur le bouton gauche */
  if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) 
  {
    presse = 1; /* le booleen presse passe a 1 (vrai) */
    xold = x; /* on sauvegarde la position de la souris */
    yold=y;
  }
  /* si on relache le bouton gauche */
  if (button == GLUT_LEFT_BUTTON && state == GLUT_UP) 
    presse=0; /* le booleen presse passe a 0 (faux) */
}
 
void mousemotion(int x,int y)
  {
    if (presse) /* si le bouton gauche est presse */
    {
      /* on modifie les angles de rotation de l'objet
	 en fonction de la position actuelle de la souris et de la derniere
	 position sauvegardee */
      anglex=anglex+(x-xold); 
      angley=angley+(y-yold);
      glutPostRedisplay(); /* on demande un rafraichissement de l'affichage */
    }
 
    xold=x; /* sauvegarde des valeurs courante de le position de la souris */
    yold=y;
  }

[Sixissor]

Je ne peux pas t'aider en ce qui concerne le GLSL... Encore si ça aurait été le Cg...

Mais voilà quelques liens pour mieux comprendre comment utiliser le GLSL:
G-truc
ClockWorkCoders
Labri.fr (une version doc de ce document existe).

Bonne chance

[Pflafon]

Tiens.. Tu peux piger ce que tu veux dans ça. En gros, ça charge les deux programmes (vertex et fragment), les compile, les relie, etc. Enfin, ça rend le shader opérationnel avec glUseProgram.