OpenGL: Le modèle ne semble pas correct lorsqu'il est chargé en python

Question

J'ai un modèle de blender et ci-dessous est une image de la façon dont mon modèle rend quand je le charge en python. On dirait que les normales sont toutes foirées. J'utilise la normale correcte pour chaque sommet. Je les exporte dans le bon ordre. Je l'ai testé dans la console de blender que le fichier d'exportation réel avait les bonnes données.

Je sais que j'ai dû faire pivoter le modèle en python parce que l'axe z est différent, donc je ne suis pas sûr si les normales z pointent dans la mauvaise direction.

J'utilise pyglet. Quelqu'un at-il déjà eu ce problème avant? Des idées de ce que je peux faire pour essayer de le réparer?

Je ne sais pas si c'est un problème OpenGL ou python.

opengl code d'installation:

glMatrixMode(GL_PROJECTION) 
    zNear = 0.01 
    zFar = 1000.0 
    fieldOfView = 45.0 
    size = zNear * math.tan(math.radians(fieldOfView)/2.0) 
    glFrustum(-size, size, -size/(w/h), size/
      (w/h), zNear, zFar); 
    glViewport(0, 0, w, h); 
    # Set-up projection matrix 
    # TODO 


    glMatrixMode(GL_MODELVIEW) 
    glShadeModel(GL_SMOOTH) 
    glEnable(GL_LIGHTING) 
    glEnable(GL_LIGHT0) 


    light0Ambient = (GLfloat * 4)(*[]) 
    light0Ambient[0] = 0.2 
    light0Ambient[1] = 0.2 
    light0Ambient[2] = 0.2 
    light0Ambient[3] = 1.0 
    glLightfv(GL_LIGHT0, GL_AMBIENT, light0Ambient); 


    lightpos = (GLfloat * 3)(*[]) 
    lightpos[0] = 5.0 
    lightpos[1] = 5.0 
    lightpos[2] = 5.0 
    glLightfv(GL_LIGHT0, GL_POSITION, lightpos) 


    tempLV = self.kjgCreateVectorWithStartandEndPoints((5.0,5.0,5.0), (0.0,0.0,-3.0)) 
    lightVector = (GLfloat * 3)(*[]) 
    lightVector[0] = tempLV[0] 
    lightVector[1] = tempLV[1] 
    lightVector[2] = tempLV[2] 
    glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION,lightVector); 

    glLoadIdentity() 
    glTranslatef(0.0, 2.0, -18.0) 
    #glScalef(0.4, 0.4, 0.4) 
    glRotatef(-90, 1.0, 0.0, 0.0) 

Code Tirage:

for face in self.faces: 
     #print group 
     if len(face) == 3: 
       glBegin(GL_TRIANGLES) 
     elif len(face) == 4: 
       glBegin(GL_QUADS) 
     else: 
       glBegin(GL_POLYGON) 
     for i in face: 
      if i in (104,16,18,102): 
        glVertex3f(*self.vertices[i]) 
        color = self.calculateVertexIntensity((.5,.5,.5),self.normals[i],self.vertices[i]) 
        glColor3f(*color) 
        glNormal3f(*self.normals[i]) 
     glEnd() 

Answer 1

en ce moment, vous indiquez le normal après le sommet au lieu de avant, donc en gros vous spécifiez la normale du sommet X pour le sommet X + 1. C'est la faille la plus importante du code actuel.

En outre, qu'est-ce que c'est calculateVertexIntensity? Tout d'abord, l'éclairage est activé dans votre code, donc glColor va être ignoré de toute façon, mais il semblerait que vous ayez essayé de faire quelque chose d'inutile ici - le rendu de la fonction fixe OpenGL calcule déjà l'intensité des vertex sur la base des paramètres et glMaterial* paramètres.

En outre, vous voudrez peut-être normaliser votre lightVector, je ne suis pas sûr si OpenGL va le normaliser pour vous.

(Assurez-vous également de vérifier les dernières fonctionnalités OpenGL;. Vous êtes en utilisant les fonctions dépréciées en ce moment et à cause de cela que vous allez frapper bientôt une barrière de performance La première chose que regarder trop pour est vertex arrays ou VBO, la prochaine est shaders.)

Answer 2

Cela ressemble à un problème avec votre Normales.

Les données dans self.normals est probablement erronée: vous devez recalculer les normales en vous assurant que vous utilisez toujours une séquence de sommets dans le sens inverse des aiguilles d'une montre autour de la face pour calculer chaque normale.

(aussi, vous devriez appellerez glNormal avant de tirer chaque sommet/du visage)

(également aussi, je ne sais pas ce qui se passe lorsque vous calculez la couleur pour chaque sommet: mais vérifiez que ce n » t) causant des problèmes