OpenGL Matrix Skinning

OpenGL Matrix Skinning - C++ - Programmation

Marsh Posté le 06-04-2005 à 16:06:59    

Bijour tout le monde !
Je tente la compilation de ce code :

Code :
  1. // Simple vertex weighting demo
  2. // d'après: Matt Craighead, 3D Software Engineer, NVIDIA Corporation
  3. // Email: mcraighead at nvidia dot com
  5. #include <stdio.h>
  6. #include <math.h>
  7. #include <gl/glut.h>
  8. #include <windows.h>
  10. #define M_PI 3.1415926
  12. /* EXT_vertex_weighting */
  13. #ifndef GL_EXT_vertex_weighting
  14. #define GL_VERTEX_WEIGHTING_EXT           0x8509
  15. #define GL_MODELVIEW0_EXT                 GL_MODELVIEW
  16. #define GL_MODELVIEW1_EXT                 0x850A
  17. typedef void (APIENTRY * PFNGLVERTEXWEIGHTFEXTPROC) (GLfloat weight);
  18. typedef void (APIENTRY * PFNGLVERTEXWEIGHTFVEXTPROC) (const GLfloat *weight);
  19. #endif
  21. PFNGLVERTEXWEIGHTFEXTPROC glVertexWeightfEXT;
  23. // Display lists for the arm
  24. int armLists[2];
  26. int wireframe = 0;
  27. int stepWeight = 0;
  29. // Constants for the "arm" geometry
  30. const int tesselate[2] = {24, 12};
  31. const float length = 4.0;
  32. const float radius = 0.4;
  34. // For animation
  35. float time = 0.0;
  36. DWORD dwStartTime;
  38. // This is a nice cubic weighting function that seems to work well empirically
  39. // for the geomtry in question.
  40. float WeightFunction(float x)
  41. {
  42.   if (x < 0.4) return 1.0;
  43.   if (x > 0.6) return 0.0;
  44.   return (x-0.6)*(x-0.6)*(250*x-75);
  45. }
  47. // This weight function gives no transition at all.  It can be used to emulate
  48. // other simpler animation methods without actually having to write extra code
  49. // where I need to disable vertex weighting, etc.
  50. float StepWeightFunction(float x)
  51. {
  52.   if (x < 0.5) return 1.0;
  53.   else return 0.0;
  54. }
  56. // This function draws the geometry for a tapered cone with vertex weights
  57. void DrawArm(int step)
  58. {
  59.   float weight;
  60.   for (int i = 0; i < tesselate[0]; i++)
  61.   {
  62.     glBegin(GL_TRIANGLE_STRIP);
  63.     for (int j = 0; j <= tesselate[1]; j++)
  64. {
  65.       float x, y, current_radius;
  67.       y = 2*M_PI * (float)j / (float)tesselate[1];
  69.       x = (float)i / (float)tesselate[0];
  70.       current_radius = radius*(1.2-x*0.4);
  71.       weight = (step == 0 ? WeightFunction(x) : StepWeightFunction(x));
  72.      
  73.   glColor3f(0,0,1);
  74.       glVertexWeightfEXT(weight);
  75.       glNormal3f(0.4, sin(y), cos(y));
  76.       glVertex3f(length*(x-0.5), current_radius*sin(y), current_radius*cos(y));
  78.       x = (float)(i+1) / (float)tesselate[0];
  79.       current_radius = radius*(1.2-x*0.4);
  80.       weight = (step == 0 ? WeightFunction(x) : StepWeightFunction(x));
  82.   glColor3f(1,0,0);
  83.       glVertexWeightfEXT(weight);
  84.       glNormal3f(0.4, sin(y), cos(y));
  85.       glVertex3f(length*(x-0.5), current_radius*sin(y), current_radius*cos(y));
  86.     }
  87.     glEnd();
  88.   }
  89. }
  91. // Set up state, build display lists
  92. void init(void)
  93. {
  94.     glEnable(GL_DEPTH_TEST);
  95.   glEnable(GL_VERTEX_WEIGHTING_EXT);
  97.   // Vertex weighting always needs normalized normals, since they become
  98.   // unnormalized during the blending step even if they were before.
  99.   glEnable(GL_NORMALIZE);
  101.      // Build two arm display list
  102.     armLists[0] = glGenLists(2);
  103.     armLists[1] = armLists[0]+1;
  104.     glNewList(armLists[0], GL_COMPILE);
  105.     DrawArm(0);
  106.     glEndList();
  107.     glNewList(armLists[1], GL_COMPILE);
  108.     DrawArm(1);
  109.     glEndList();
  110. }
  113. // Window reshape handler
  114. void reshape(int w, int h)
  115. {
  116.   glViewport(0, 0, (GLsizei)w, (GLsizei)h);
  117.   glMatrixMode(GL_PROJECTION);
  118.   glLoadIdentity();
  119.   gluPerspective(60.0, (GLdouble)w/(GLdouble)h, 1.0, 100.0);
  120. }
  122. // Keyboard handler
  123. void keyboard(unsigned char key, int x, int y)
  124. {
  125.     switch (key)
  126. {
  127.        case 's' :
  128.     stepWeight = 1 - stepWeight;
  129.     break;
  130.        case 'w' :
  131.     wireframe = 1 - wireframe;
  132.     break;
  133.        case 27 :
  134.     exit(0);
  135.     break;
  136.        default:
  137.          break;
  138.   }
  139.   glutPostRedisplay();
  140. }
  142. // Draw one arm
  143. void DrawOne(int step)
  144. {
  145.   float matrix[16];
  146.   static int armList[2];
  148.   glPushMatrix();
  150.   // Set up the second matrix with the right rotation
  151.   glGetFloatv(GL_MODELVIEW_MATRIX, matrix);
  152.   glMatrixMode(GL_MODELVIEW1_EXT);
  153.   glLoadMatrixf(matrix);
  155.   //Animation
  156.   glRotatef(90.0*sin(2.0*time), 0, 0, 1);
  157.  
  158.   glMatrixMode(GL_MODELVIEW0_EXT);
  160.   // Call the display list for the arm  
  161.   glCallList(armLists[step]);
  163.   glPopMatrix();
  164. }
  166. // Display handler
  167. void display(void)
  168. {
  169.   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  171.   time = (float)(GetTickCount() - dwStartTime) / 1000.0;
  173.   glMatrixMode(GL_MODELVIEW0_EXT);
  174.   glLoadIdentity();
  175.   glTranslatef(0, 0, -8);
  177.   // Set state based on program mode
  178.   glPolygonMode(GL_FRONT_AND_BACK, wireframe ? GL_LINE : GL_FILL);
  180.     glPushMatrix();
  181.     glScalef(1.5, 1.5, 1.5);
  182.     DrawOne(stepWeight);
  183.     glPopMatrix();
  185.    glutSwapBuffers();
  186. }
  188. void idle(void)
  189. {
  190.   glutPostRedisplay();
  191. }
  193. int main(int argc, char **argv)
  194. {
  195.   glutInit(&argc, argv);
  196.   glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  197.   glutInitWindowSize(640, 480);
  198.   glutCreateWindow("matriw skinning" );
  200.   glVertexWeightfEXT = (PFNGLVERTEXWEIGHTFEXTPROC)wglGetProcAddress("glVertexWeightfEXT" );
  202.   dwStartTime = GetTickCount();
  203.  
  204.   //== Couleur du fond ==
  205. glClearColor(1.0, 1.0, 1.0, 0.0);
  207.   init();
  208.   glutReshapeFunc(reshape);
  209.   glutKeyboardFunc(keyboard);
  210.   glutDisplayFunc(display);
  211.   glutIdleFunc(idle);
  212.  
  213.   glutMainLoop();
  215.   return 0;
  216. }


Mais la focntion 'glVertexWeightfEXT' dans la fonction 'DrawArm(int step)' leve une erreur. L'initialisation 'glVertexWeightfEXT = (PFNGLVERTEXWEIGHTFEXTPROC)wglGetProcAddress("glVertexWeightfEXT" );' n'a pas l'air de fonctionner.
si vous avez la moindre idée Merci d'avance.

Reply

Marsh Posté le 06-04-2005 à 16:06:59   

Reply

Marsh Posté le 06-04-2005 à 17:52:42    

J'imagine que le probleme ne vient pas à la compilation mais à l'execution.
Le code suppose que l'extension EXT_vertex_weighting est supportée. Si ce n'est pas le cas, le pointeur retourné par wglGetProcAddress n'est pas valide. Normalement il faut d'abord verifier si une extension est dispo en cherchant dans l'extension string (glGetString(GL_EXTENSIONS)).
 
De toutes façons cette extension est obsolete. Seul NVIDIA la supportait il y a quelques années, mais ce n'est plus le cas (depuis fin 2002). Elle n'apparait plus dans les drivers depuis cette date. Tout se fait maintenant en vertex shader (ARB_vertex_program ou GLSL).


Message édité par retrox le 06-04-2005 à 17:53:10
Reply

Marsh Posté le 06-04-2005 à 20:06:21    

Merci pour cette reponce je cour voir (ARB_vertex_program ou GLSL).

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed