mouvement d'objets rendus dans opengl

Question

J'ai du mal à déplacer ces objets de façon ordonnée avec openGL. Ce que je veux faire, c'est que chaque objet dans chaque rangée tourne lentement et bouge à droite de l'écran, et comme il disparaît de la vue, il devrait réapparaître de l'autre côté comme s'il était dans une boucle.

La fonction inactive fonctionnait correctement pour un seul objet, mais elle ne fonctionnait pas avec le groupe d'objets.

#include <stdlib.h> 
#include <GL/glut.h> 

GLuint objectList; 

GLfloat xRotated, yRotated, zRotated; 
GLdouble size = 0.5; 

float xpos = 0.0; 
float ypos = 0.0; 
float zpos = 0.0; 

int x = 1; 
float r, g, b; 

/* 
* Initialize depth buffer, projection matrix, light source, and lighting 
* model. Do not specify a material property here. 
*/ 
void init(void) 
{ 
    GLfloat ambient[] = { 0.0, 0.0, 0.0, 1.0 }; 
    GLfloat diffuse[] = { 1.0, 1.0, 1.0, 1.0 }; 
    GLfloat specular[] = { 1.0, 1.0, 1.0, 1.0 }; 
    GLfloat position[] = { 0.0, 3.0, 3.0, 0.0 }; 

    GLfloat lmodel_ambient[] = { 0.2, 0.2, 0.2, 1.0 }; 
    GLfloat local_view[] = { 0.0 }; 

    glLightfv(GL_LIGHT0, GL_AMBIENT, ambient); 
    glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse); 
    glLightfv(GL_LIGHT0, GL_POSITION, position); 
    glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient); 
    glLightModelfv(GL_LIGHT_MODEL_LOCAL_VIEWER, local_view); 

    glFrontFace(GL_CW); 
    glEnable(GL_LIGHTING); 
    glEnable(GL_LIGHT0); 
    glEnable(GL_AUTO_NORMAL); 
    glEnable(GL_NORMALIZE); 
    glEnable(GL_DEPTH_TEST); 


    objectList = glGenLists(1); 
    glNewList(objectList, GL_COMPILE); 
    glutSolidTeapot(0.5); 
    glEndList(); 
} 

/* 
* Move object into position. Use 3rd through 12th 
* parameters to specify the material property. Draw a teapot. 
*/ 
void renderObject(GLfloat x, GLfloat y, 
    GLfloat ambr, GLfloat ambg, GLfloat ambb, 
    GLfloat difr, GLfloat difg, GLfloat difb, 
    GLfloat specr, GLfloat specg, GLfloat specb, GLfloat shine) 
{ 
    GLfloat mat[4]; 

    glPushMatrix(); 
    glTranslatef(x, y, 0.0); 
    mat[0] = ambr; mat[1] = ambg; mat[2] = ambb; mat[3] = 1.0; 
    glMaterialfv(GL_FRONT, GL_AMBIENT, mat); 
    mat[0] = difr; mat[1] = difg; mat[2] = difb; 
    glMaterialfv(GL_FRONT, GL_DIFFUSE, mat); 
    mat[0] = specr; mat[1] = specg; mat[2] = specb; 
    glMaterialfv(GL_FRONT, GL_SPECULAR, mat); 
    glMaterialf(GL_FRONT, GL_SHININESS, shine * 128.0); 
    glCallList(objectList); 
    glPopMatrix(); 
} 

void idle(void) { 

    //xRotated += 0.01; 
    yRotated += 0.01; 
    //zRotated += 0.01; 

    if (xpos > -1 && x == 1) { 

     xpos = -15; 
     ypos = 0; 

    } 
    else { 
     x = 0; 

     if (xpos <= 15) { 
      xpos += 0.001; 
      //ypos += 0.001; 
     } 
     else { 
      xpos = 1; 
      ypos = 1; 
      x = 1; 
     } 
    } 

    glutPostRedisplay(); 
} 


void display(void) 
{ 
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 

    // glRotatef(xRotated, 1.0, 0.0, 0.0); 
    // rotation about Y axis 
    glRotatef(xRotated, 1.0, 0.0, 0.0); 
    // rotation about the Z axis 
    glRotatef(yRotated, 0.0, 1.0, 0.0); 
    // scale transformation 
    glScalef(1.0, 1.0, 1.0); 
    // glut spheres 

    renderObject(2.0, 11.0, 0.05375, 0.05, 0.06625, 
     0.18275, 0.17, 0.22525, 0.332741, 0.328634, 0.346435, 0.3); 
    renderObject(2.0, 8.0, 0.25, 0.20725, 0.20725, 
     1, 0.829, 0.829, 0.296648, 0.296648, 0.296648, 0.088); 
    renderObject(2.0, 5.0, 0.1745, 0.01175, 0.01175, 
     0.61424, 0.04136, 0.04136, 0.727811, 0.626959, 0.626959, 0.6); 

    renderObject(6.0, 11.0, 0.25, 0.25, 0.25, 
     0.4, 0.4, 0.4, 0.774597, 0.774597, 0.774597, 0.6); 
    renderObject(6.0, 8.0, 0.19125, 0.0735, 0.0225, 
     0.7038, 0.27048, 0.0828, 0.256777, 0.137622, 0.086014, 0.1); 
    renderObject(6.0, 5.0, 0.24725, 0.1995, 0.0745, 
     0.75164, 0.60648, 0.22648, 0.628281, 0.555802, 0.366065, 0.4); 


    renderObject(10.0, 11.0, 0.0, 0.0, 0.0, 
     0.1, 0.35, 0.1, 0.45, 0.55, 0.45, .25); 
    renderObject(10.0, 8.0, 0.0, 0.0, 0.0, 0.5, 0.0, 0.0, 
     0.7, 0.6, 0.6, .25); 
    renderObject(10.0, 5.0, 0.0, 0.0, 0.0, 0.55, 0.55, 0.55, 
     0.70, 0.70, 0.70, .25); 

    renderObject(14.0, 11.0, 0.0, 0.05, 0.0, 0.4, 0.5, 0.4, 
     0.04, 0.7, 0.04, .078125); 
    renderObject(14.0, 8.0, 0.05, 0.0, 0.0, 0.5, 0.4, 0.4, 
     0.7, 0.04, 0.04, .078125); 
    renderObject(14.0, 5.0, 0.05, 0.05, 0.05, 0.5, 0.5, 0.5, 
     0.7, 0.7, 0.7, .078125); 

    renderObject(18.0, 11.0, 0.0, 0.05, 0.0, 0.4, 0.5, 0.4, 
     0.04, 0.7, 0.04, .078125); 
    renderObject(18.0, 8.0, 0.05, 0.0, 0.0, 0.5, 0.4, 0.4, 
     0.7, 0.04, 0.04, .078125); 
    renderObject(18.0, 5.0, 0.05, 0.05, 0.05, 0.5, 0.5, 0.5, 
     0.7, 0.7, 0.7, .078125); 


    glutSwapBuffers(); 
} 


void reshape(int w, int h) 
{ 
    glViewport(0, 0, (GLsizei)w, (GLsizei)h); 
    glMatrixMode(GL_PROJECTION); 
    glLoadIdentity(); 

    glOrtho(0.0, 16.0, 0.0, 16.0*(GLfloat)h/(GLfloat)w, 
      -10.0, 10.0); 

    glMatrixMode(GL_MODELVIEW); 
} 



/* 
* Main Loop 
*/ 
int main(int argc, char **argv) 
{ 
    glutInit(&argc, argv); 
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); 
    glutInitWindowSize(750, 750); 
    glutInitWindowPosition(50, 50); 
    glutCreateWindow(argv[0]); 
    init(); 
    glutReshapeFunc(reshape); 
    glutDisplayFunc(display); 
    glutIdleFunc(idle); 

    glutMainLoop(); 
    return 0; 
} 

Answer 1

Vous devez changer l'ordre des instructions. Une rotation autour de l'axe de l'objet est réalisée, en multipliant la matrice de traduction par la matrice de rotation.

object-matrix = translation-matrix * rotation-matrix 

Voir la documentation de glRotate qui dit clairement:

glRotate produit une rotation de degrés d'angle autour du vecteur xyz. La matrice actuelle (voir glMatrixMode) est multipliée par une matrice de rotation avec le produit remplaçant la matrice courante.

Adapt votre code comme ceci:

void renderObject(GLfloat x, GLfloat y, 
    GLfloat ambr, GLfloat ambg, GLfloat ambb, 
    GLfloat difr, GLfloat difg, GLfloat difb, 
    GLfloat specr, GLfloat specg, GLfloat specb, GLfloat shine) 
{ 
    glPushMatrix(); 

    glTranslatef(x, y, 0.0);   // translation-matrix 
    glRotatef(yRotated, 0.0, 1.0, 0.0); // multiply by rotation-matrix 
    glRotatef(xRotated, 1.0, 0.0, 0.0); 

    ..... 
} 

Remarque, votre rotation est très légèrement. Remplacez yRotated += 0.01; par yRotated += 1.0;, pour des raisons de débogage (l'angle est spécifié en degrés).