Discussion :

[jojomillenium]

Bonjour,

Ca fait plus d une semaine que je cherche l origine de l erreur et je ne trouve pas! Peut etre saurez vous d ou cela provient!

J'essaie betement de compiler une source fourni ans un bouquin (qui est la meme que sur le site de opengl tess.c) les erreurs sont a la suite du 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
170
171
172
173
174
175
176
177
178
179
180
181
182
 
 
#include <windows.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <stdlib.h>
#include <stdio.h>
 
#ifndef CALLBACK 
#define CALLBACK
#endif
 
GLuint startList;
 
void display (void) {
   glClear(GL_COLOR_BUFFER_BIT);
   glColor3f(1.0, 1.0, 1.0);
   glCallList(startList);
   glCallList(startList + 1);
   glFlush();
}
 
void CALLBACK beginCallback(GLenum which)
{
   glBegin(which);
}
 
void CALLBACK errorCallback(GLenum errorCode)
{
   const GLubyte *estring;
 
   estring = gluErrorString(errorCode);
   fprintf(stderr, "Tessellation Error: %s\n", estring);
   exit(0);
}
 
void CALLBACK endCallback(void)
{
   glEnd();
}
 
void CALLBACK vertexCallback(GLvoid *vertex)
{
   const GLdouble *pointer;
 
   pointer = (GLdouble *) vertex;
   glColor3dv(pointer+3);
   glVertex3dv(vertex);
}
 
/*  combineCallback is used to create a new vertex when edges
 *  intersect.  coordinate location is trivial to calculate,
 *  but weight[4] may be used to average color, normal, or texture
 *  coordinate data.  In this program, color is weighted.
 */
void CALLBACK combineCallback(GLdouble coords[3], 
                     GLdouble *vertex_data[4],
                     GLfloat weight[4], GLdouble **dataOut )
{
   GLdouble *vertex;
   int i;
 
   vertex = (GLdouble *) malloc(6 * sizeof(GLdouble));
 
   vertex[0] = coords[0];
   vertex[1] = coords[1];
   vertex[2] = coords[2];
   for (i = 3; i < 7; i++)
      vertex[i] = weight[0] * vertex_data[0][i] 
                  + weight[1] * vertex_data[1][i]
                  + weight[2] * vertex_data[2][i] 
                  + weight[3] * vertex_data[3][i];
   *dataOut = vertex;
}
 
void init (void) 
{
   GLUtesselator *tobj;
   GLdouble rect[4][3] = {50.0, 50.0, 0.0,
                          200.0, 50.0, 0.0,
                          200.0, 200.0, 0.0,
                          50.0, 200.0, 0.0};
   GLdouble tri[3][3] = {75.0, 75.0, 0.0,
                         125.0, 175.0, 0.0,
                         175.0, 75.0, 0.0};
   GLdouble star[5][6] = {250.0, 50.0, 0.0, 1.0, 0.0, 1.0,
                          325.0, 200.0, 0.0, 1.0, 1.0, 0.0,
                          400.0, 50.0, 0.0, 0.0, 1.0, 1.0,
                          250.0, 150.0, 0.0, 1.0, 0.0, 0.0,
                          400.0, 150.0, 0.0, 0.0, 1.0, 0.0};
 
   glClearColor(0.0, 0.0, 0.0, 0.0);
 
   startList = glGenLists(2);
 
   tobj = gluNewTess();
   gluTessCallback(tobj, GLU_TESS_VERTEX, 
                   glVertex3dv);
   gluTessCallback(tobj, GLU_TESS_BEGIN, 
                   beginCallback);
   gluTessCallback(tobj, GLU_TESS_END, 
                   endCallback);
   gluTessCallback(tobj, GLU_TESS_ERROR, 
                   errorCallback);
 
   /*  rectangle with triangular hole inside  */
   glNewList(startList, GL_COMPILE);
   glShadeModel(GL_FLAT);    
   gluTessBeginPolygon(tobj, NULL);
      gluTessBeginContour(tobj);
         gluTessVertex(tobj, rect[0], rect[0]);
         gluTessVertex(tobj, rect[1], rect[1]);
         gluTessVertex(tobj, rect[2], rect[2]);
         gluTessVertex(tobj, rect[3], rect[3]);
      gluTessEndContour(tobj);
      gluTessBeginContour(tobj);
         gluTessVertex(tobj, tri[0], tri[0]);
         gluTessVertex(tobj, tri[1], tri[1]);
         gluTessVertex(tobj, tri[2], tri[2]);
      gluTessEndContour(tobj);
   gluTessEndPolygon(tobj);
   glEndList();
 
   gluTessCallback(tobj, GLU_TESS_VERTEX, 
                   vertexCallback);
   gluTessCallback(tobj, GLU_TESS_BEGIN, 
                   beginCallback);
   gluTessCallback(tobj, GLU_TESS_END, 
                   endCallback);
   gluTessCallback(tobj, GLU_TESS_ERROR, 
                   errorCallback);
   gluTessCallback(tobj, GLU_TESS_COMBINE, 
                   combineCallback);
 
   /*  smooth shaded, self-intersecting star  */
   glNewList(startList + 1, GL_COMPILE);
   glShadeModel(GL_SMOOTH);    
   gluTessProperty(tobj, GLU_TESS_WINDING_RULE,
                   GLU_TESS_WINDING_POSITIVE);
   gluTessBeginPolygon(tobj, NULL);
      gluTessBeginContour(tobj);
         gluTessVertex(tobj, star[0], star[0]);
         gluTessVertex(tobj, star[1], star[1]);
         gluTessVertex(tobj, star[2], star[2]);
         gluTessVertex(tobj, star[3], star[3]);
         gluTessVertex(tobj, star[4], star[4]);
      gluTessEndContour(tobj);
   gluTessEndPolygon(tobj);
   glEndList();
   gluDeleteTess(tobj);
}
 
void reshape (int w, int h)
{
   glViewport(0, 0, (GLsizei) w, (GLsizei) h);
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   gluOrtho2D(0.0, (GLdouble) w, 0.0, (GLdouble) h);
}
 
void keyboard(unsigned char key, int x, int y)
{
   switch (key) {
      case 27:
         exit(0);
         break;
   }
}
 
int main(int argc, char** argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
   glutInitWindowSize(500, 500);
   glutCreateWindow(argv[0]);
   init();
   glutDisplayFunc(display);
   glutReshapeFunc(reshape);
   glutKeyboardFunc(keyboard);
   glutMainLoop();
   return 0;  
}

Voila seulement j'ai des erreurs que voila:

-error C2664: 'glVertex3dv' : cannot convert parameter 1 from 'void *' to 'const double *'
Conversion from 'void*' to pointer to non-'void' requires an explicit cast
-error C2664: 'gluTessCallback' : cannot convert parameter 3 from 'void (const double *)' to 'void (__stdcall *)(void)'
None of the functions with this name in scope match the target type
-error C2664: 'gluTessCallback' : cannot convert parameter 3 from 'void (unsigned int)' to 'void (__stdcall *)(void)'
None of the functions with this name in scope match the target type
-error C2664: 'gluTessCallback' : cannot convert parameter 3 from 'void (unsigned int)' to 'void (__stdcall *)(void)'
None of the functions with this name in scope match the target type
-error C2664: 'gluTessCallback' : cannot convert parameter 3 from 'void (void *)' to 'void (__stdcall *)(void)'
None of the functions with this name in scope match the target type
-error C2664: 'gluTessCallback' : cannot convert parameter 3 from 'void (unsigned int)' to 'void (__stdcall *)(void)'
None of the functions with this name in scope match the target type
-error C2664: 'gluTessCallback' : cannot convert parameter 3 from 'void (unsigned int)' to 'void (__stdcall *)(void)'
None of the functions with this name in scope match the target type
-error C2664: 'gluTessCallback' : cannot convert parameter 3 from 'void (double [],double *[],float [],double ** )' to 'void (__stdcall *)(void)'
None of the functions with this name in scope match the target type

Je programme sous VSC++ 6 et mes version de glu et gl sont 1.2 !

Pourquoi ca me fait ca et comment y remedier?

merci pour votre aide

[olix2007]

bonjour,

il faut que tu castes tes variables :
ex pour la premiere erreur :
remplace glVertex3dv(vertex);
par glVertex3dv((GLdouble *)vertex);
etc....

[jojomillenium]

Je te remercie,
effectivement ca m enleve ma premier erreur,
mais comment me debarasser des autre en castant mes void(const double *), void(unsigned int), void(void *) ou meme void (double [],double *[],float [],double ** ) en void (__stdcall *)(void)?

merci pour ton aide

[fearyourself]

Je te remercie,
effectivement ca m enleve ma premier erreur,
mais comment me debarasser des autre en castant mes void(const double *), void(unsigned int), void(void *) ou meme void (double [],double *[],float [],double ** ) en void (__stdcall *)(void)?

merci pour ton aide

La fonction a comme prototype :

Code :

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

1
2
3
4
 
void gluTessCallback(GLUtriangulatorObj *tobj,
                     GLenum which,
                     void (*fn)() )

Donc le troisième argument est une fonction qui ne retourne rien et qui ne prend rien en argument.

Voici les prototypes que tu passes en argument :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
void CALLBACK beginCallback(GLenum which)
 
void CALLBACK errorCallback(GLenum errorCode)
 
void CALLBACK endCallback(void)
 
void CALLBACK vertexCallback(GLvoid *vertex)
 
void CALLBACK combineCallback(GLdouble coords[3],
GLdouble *vertex_data[4],
GLfloat weight[4], GLdouble **dataOut )
 
void glVertex3dv( const GLdouble *v )

A ton avis, est-ce que c'est vraiment une bonne idée de passer l'adresse d'une fonction qui retourne quelque chose ou qui prend des arguments à un callback qui suppose que y en a pas ?

Jc

[jojomillenium]

je sais, mais je ne vois pas comment regler le probleme! Surtout que j'ai repris la source exacte de tess.c donné sur opengl.org et sur d'autre bouquin expliquant la tesselation glu!

Je dois modifier le fichier glu.h?

Comment faire pour que ma tesselation fonctionne?