[openGL] probleem met roteren en transleren van object

[Verwijderd]

Beste mensen ik heb een object gemaakt in een 3d omgeving.

Nu wil ik dit object sturen op de de x en z as.
De besturing is dus eigenlijk 2d.

Nu heb ik het volgende gedaan:

code:

glTranslatef(0.0, 0.0, verplaatsing);   
glRotatef(alpha, 0.0, 1.0, 0.0);    
tank(0.3, headtank1);
glRotatef(-alpha, 0.0, 1.0, 0.0);
glTranslatef(0.0, 0.0, -verplaatsing);

alpha en verplaatsing worden dmv de toetsen verhoogd en verlaagd.
Het object draait nu om zijn eigen as (is ook de bedoeling) maar transleert alleen op de x as en neemt dus niet de draaing mee.

Het volgende wat ik gedaan heb is het berekenen van mijn x en z punt
dmv het volgende:

code:

    tank1X = sin(c*alpha) * verplaatsing;
    tank1Z = cos(c*alpha) *verplaatsing;




    glTranslatef(tank1X, 0.0, tank1Z);  
    glRotatef(alpha, 0.0, 1.0, 0.0);    
    tank(0.3, headtank1);
    glRotatef(-alpha, 0.0, 1.0, 0.0);
    glTranslatef(tank1X, 0.0, -tank1Z);

Nu krijg ik helemaal vage dingen.
Op google vind ik ook niets nuttigs dus wellicht dat iemand dit probleem herkent

alvast bedankt

[EfBe]

Bij OpenGL zit de Z as in het scherm, de Y as is vertikaal, de x as horizontaal.

Wat je fout doet is een mixup van roteren en translaten die dan omgekeerd op de matrixstack komen (je vermenigvuldigt matrices) en dan krijg je ongewenste zaken.

Kijk in dit online boek:
http://fly.cc.fer.hr/~unreal/theredbook/

En lees de hoofdstukken over viewing e.d.

[Verwijderd]

Ik begrijp enigszins het probleem. Maar is roteren en transleren door elkaar wil gebruiken en herhalen dan krijg ik zowiezo een mixup.

Hoe kan ik dit voorkomen is eingenlijk de vraag.
In de scene die ik maak is de camera gescheiden van het object (3rd person) het is dus de bedoeling dat mij figuur (een tank) kan rijden.

Kan iemand mij vertellen hoe ik dit het best kan aanpakken

[EfBe]

Deze routine tekent verschillende objects met verschillende posities in een scene. Zoals je ziet gebruik ik pushmatrix en popmatrix om de camera matrix te bewaren. Lees dat Viewing hoofdstuk in dat boek waar ik een link naar gaf, je zult zien dat je het dan begrijpt.

(let niet op de comments, die schrijf ik veelal eerst uit en dan de code, dus die vertellen wat er onderstaat en zijn een beetje redundant)

C++:

glMatrixMode(GL_PROJECTION);
glPushMatrix();
    glLoadIdentity();
    // Create dynamic cubemaps
    glPushMatrix();
        CreateDynamicCubemaps();
    glPopMatrix();
    // reset the frustum settings to 
    glFrustum(-1.0, 1.0, -0.75, 0.75, 1.0, 100.0);
    // set matrixmode in Modelview.
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
        // load the identity matrix into the modelview matrix.
        glLoadIdentity();
        
        // position camera at the startposition of the camera
        m_vStartPosition[0]=CAMERA_STARTPOS_X;
        m_vStartPosition[1]=CAMERA_STARTPOS_Y;
        m_vStartPosition[2]=CAMERA_STARTPOS_Z;
        m_vStartPosition[3]=0.0f;

        // Calculate new position of the camera using the pan angles
        PanCamera();

        // produce modelview TR matrix on OPenGL's modelview stack to 
        // get the right view
        gluLookAt(
            m_scCamera.m_vPosition[0],
            m_scCamera.m_vPosition[1],
            m_scCamera.m_vPosition[2],
            m_scCamera.m_vTarget[0],
            m_scCamera.m_vTarget[1],
            m_scCamera.m_vTarget[2],
            m_scCamera.m_vUp[0],
            m_scCamera.m_vUp[1],
            m_scCamera.m_vUp[2]);
        // Draw Skybox
        DrawSkyBox();

        // Set states we need for this scene to render
        glEnable(GL_CULL_FACE);
        glEnable(GL_DEPTH_TEST);
        glFrontFace(GL_CCW);
        glDepthFunc(GL_LEQUAL);
        glCullFace(GL_BACK);

        // render the flying object
        glPushMatrix();
            glTranslatef(m_vFlyingObjectPos[0], m_vFlyingObjectPos[1],m_vFlyingObjectPos[2]);
            glRotatef(m_fFlyingObjectPanAngle/2.0f, 1.0f,0.0f,0.0f);
            glRotatef(m_fFlyingObjectPanAngle*1.2f, 0.0f,0.0f,1.0f);
            // render flying object
            DrawFlyingObject();
        glPopMatrix();

        // render the model. We have to correct the texturematrix first, otherwise we'll
        // see the same reflection no matter how we pan the camera.
        glMatrixMode(GL_TEXTURE);
        glPushMatrix();
            // Correct the texture matrix so the viewport difference is reflected in the
            // correct textxure coord generation. (so what's behind the camera is indeed reflected in
            // the object
            glRotatef(-m_fCameraPanZAngle, 0.0f, 0.0f, 1.0f);
            glRotatef(-m_fCameraPanYAngle, 0.0f, 1.0f, 0.0f);
            glRotatef(-m_fCameraPanXAngle, 1.0f, 0.0f, 0.0f);
            DrawMesh();
        glPopMatrix();

        // done
        glMatrixMode(GL_MODELVIEW);
    glPopMatrix();
    glMatrixMode(GL_PROJECTION);
glPopMatrix();

Deze routine tekent dit:

Dus er zijn verschillende camera standpunten gebruikt om alles te tekenen, wat je terugziet in de routine.

[ Voor 8% gewijzigd door EfBe op 03-03-2005 17:05 ]