c++ like

// CarTransformer.cpp : Definiert den Einstiegspunkt für die Konsolenanwendung.

#include <iostream>
#include <GL/freeglut.h>         //lädt alles für OpenGL
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>

using namespace std;

//Kameraperspektive zu Beginn: weit weg, Blick von oben rechts auf Objekt (Koordinatenursprung)
float camX = 3;
float camY = 2;
float camZ = 10;

//Rotationen
float wheelRotation = 1.0;
float legRotationX = 1.0;
float legRotationZ = 1.0;

//Verschiebungen
float moveTiresZ = 0;
float moveRoofY = 0;
float moveLegsX = 0;
float moveLegsY = 0;
float moveLegsZ = 0;
float moveLaneLineX = 0;        //Fahrbahnstreifen

//Skalierungen
float stretchLegsX = 0;
float stretchLegsZ = 0;
float stretchRoofX = 0;
float stretchRoofY = 0;

bool transform = false;

//Tastaturoptionen
bool showFront = false;
bool showBack = false;
bool showAxes = true;           //Achsenkreuze anzeigen
bool showLaneGround = true;     //Fahrbahn und Untergrund anzeigen

GLfloat xMousePos = 300;
GLfloat yMousePos = 300;

GLfloat xMousePosTMP = xMousePos;
GLfloat yMousePosTMP = yMousePos;


void moveCam(){
    //x - Achse
    if((xMousePos > xMousePosTMP) && (xMousePos != xMousePosTMP)){
        xMousePosTMP = xMousePos;
        camX = camX - (xMousePos / 1000);
    }
    else if((xMousePos < xMousePosTMP) && (xMousePos != xMousePosTMP)){
        xMousePosTMP = xMousePos;
        camX = camX + (xMousePos / 1000);
    }

    //y-Achse
    if((yMousePos > yMousePosTMP) && (yMousePos != yMousePosTMP)){
        yMousePosTMP = yMousePos;
        camY = camY - (yMousePos / 1000);
    }
    else if((yMousePos < yMousePosTMP) && (yMousePos != yMousePosTMP)){
        yMousePosTMP = yMousePos;
        camY = camY + (yMousePos / 1000);
    }
}

//Tastaturbelegung
void SpecialFunc ( int key, int x, int y ){
    switch(key){
        case GLUT_KEY_F1:
            showFront = true;
            showBack = false;
            break;
        case GLUT_KEY_F2:
            showBack = true;
            showFront = false;
            break;
        case GLUT_KEY_F3:
            camX = 3;
            camY = 2;
            camZ = 10;
            break;
        case GLUT_KEY_F4:
            if(!showAxes)
                showAxes = true;
            else
                showAxes = false;
            break;
        case GLUT_KEY_F5:
            if(!showLaneGround)
                showLaneGround = true;
            else
                showLaneGround = false;
            break;
    }
    // RenderScene aufrufen.
    glutPostRedisplay();
}

void Init()
{
   // Hier finden jene Aktionen statt, die zum Programmstart einmalig
   // durchgeführt werden müssen
    glClearColor(0, 0.3, 0.7, 0.0);    // Hintergrundfarbe setzen
    glEnable(GL_DEPTH_TEST);
    glClearDepth(1.0);

    // Create light components
    GLfloat ambientLight[] = { 1.0f, 1.0f, 1.0f, 0.3f };
    GLfloat diffuseLight[] = { 1.0f, 1.0f, 1.0f, 1.0f };
    GLfloat specularLight[] = {1.0f, 1.0f, 1.0f, 1.0f};
    GLfloat position1[] = {5.0f, 5.0f, 5.0f, 1.0f};     //Lichtquelle gerichtet und leuchtet entlang der X,Y und Z-Achse

    // Assign created components to GL_LIGHT0
    //glLightfv(GL_LIGHT1, GL_AMBIENT, ambientLight);
    glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuseLight);
    //glLightfv(GL_LIGHT1, GL_SPECULAR, specularLight);
    glLightfv(GL_LIGHT1, GL_POSITION, position1);

    glEnable(GL_COLOR_MATERIAL);
    glEnable(GL_LIGHT1);
    glEnable(GL_LIGHTING);

    //Ausgaben
    cout << "##########################################################################" << endl;
    cout << "#                           Car Transformer                              #" << endl;
    cout << "#          Markus Mayer (719045) und Daniel Braeutigam (719406)          #" << endl;
    cout << "##########################################################################" << endl;
    cout << endl;
    cout << " Blickwinkelaenderung:" << endl;
    cout << " mit gedrueckter linker Maustaste bewegen" << endl;
    cout << endl;
    cout << endl;
    cout << " Tastaturbefehle:" << endl;
    cout << endl;
    cout << " F1     -    Objekt von der Vorderseite betrachten" << endl;
    cout << " F2     -    Objekt von der Rueckseite betrachten" << endl;
    cout << " F3     -    Kamera auf Ausgangsposition zuruecksetzen" << endl;
    cout << " F4     -    Achsenkreuze ein-/ausblenden" << endl;
    cout << " F5     -    Fahrbahn und Untergrund ein-/ausblenden" << endl;

}

void RenderScene() //Zeichenfunktion
{
   // Hier befindet sich der Code der in jedem Frame ausgefuehrt werden muss
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);         // Farbpuffer und Tiefenpuffer leeren/überschreiben
   glLoadIdentity ();   // Aktuelle Model-/View-Transformations-Matrix zuruecksetzen
   moveCam();
   gluLookAt ( camX, camY, camZ, 0., 0., 0., 0., 1., 0.);
   glLineWidth (2);

   glTranslatef(0., -2.,0); //Koordinatenursprung nach unten verschieben

   //Rueckseite betrachten, wenn F2 gedrueckt
   if(showBack){
        glRotatef(-180., 0, 1, 0);
   }

   if(showAxes){
       //x-Achse Senkrechte
       glBegin(GL_LINES);
            glColor3f(1.0,0.0,0.0);
            glVertex2f(0.,0.);
            glVertex2f(10.,0.);
       glEnd();
       //y-Achse Senkrechte
       glBegin(GL_LINES);
            glColor3f(0.0,1.0,0.0);
            glVertex2f(0.,0.);
            glVertex2f(0.,10.);
       glEnd();
       //z-Achse Senkrechte
       glBegin(GL_LINES);
            glColor3f(0.0,0.0,1.0);
            glVertex3f(0.,0., 0.);
            glVertex3f(0.,0., 10.);
       glEnd();
    }

    glPushMatrix();

        if(showLaneGround){
            //Untergrund "Rasen"
            glPushMatrix();
                glColor3f(0.3, 0.9, 0.3);
                glTranslatef(0., -0.8, 0.0);
                glScalef(100, 0.2, 100);
                glutSolidCube(1.0);
            glPopMatrix();

            //Fahrbahn
            glPushMatrix();
                glColor3f(0.3, 0.3, 0.3);
                glTranslatef(0., -0.6, 0.0);
                glScalef(100, 0.2, 7);
                glutSolidCube(1.0);
            glPopMatrix();

            //Fahrbahnstreifen Rand rechts
            glPushMatrix();
                glColor3f(1, 1, 1);
                glTranslatef(0, -0.49, +3.3);
                glScalef(100, 0.01, 0.5);
                glutSolidCube(1.0);
            glPopMatrix();

            //Fahrbahnstreifen Rand links
            glPushMatrix();
                glColor3f(1, 1, 1);
                glTranslatef(0, -0.49, -3.2);
                glScalef(100, 0.01, 0.5);
                glutSolidCube(1.0);
            glPopMatrix();

            //Fahrbahnstreifen Mitte hinten
            glPushMatrix();
                glColor3f(1, 1, 1);
                glTranslatef(-25-moveLaneLineX, -0.49, 0.0);
                glScalef(8, 0.01, 0.5);
                glutSolidCube(1.0);
            glPopMatrix();

            //Fahrbahnstreifen Mitte mitte
            glPushMatrix();
                glColor3f(1, 1, 1);
                glTranslatef(+5.-moveLaneLineX, -0.49, 0.0);
                glScalef(8, 0.01, 0.5);
                glutSolidCube(1.0);
            glPopMatrix();

            //Fahrbahnstreifen Mitte vorne
            glPushMatrix();
                glColor3f(1, 1, 1);
                glTranslatef(+35-moveLaneLineX, -0.49, 0.0);
                glScalef(8, 0.01, 0.5);
                glutSolidCube(1.0);
            glPopMatrix();
        }

        // Dach
        glPushMatrix();
            glColor3f(0.0, 1.0, 0.5);
            glTranslatef(0., 1.5+moveRoofY, 0.0);
            glScalef(4.-stretchRoofX, 1.0+stretchRoofY, 3);
            glutSolidCube(1.0);
        glPopMatrix();

        // rechtes "Bein"
        glPushMatrix();
            glColor3f(0.5, 0.0, 1.5);
            glTranslatef(0.-moveLegsX, 0.5+moveLegsY, 0.75-moveLegsZ);
            if(transform){
                glRotatef(legRotationZ, 0, 0, 1);
                glRotatef(legRotationX, 1, 0, 0);
            }
            glScalef(7.-stretchLegsX, 1.0, 1.5-stretchLegsZ);
            glutSolidCube(1.0);
        glPopMatrix();

        // linkes "Bein"
        glPushMatrix();
            glColor3f(1.0, 0.0, 0.5);
            glTranslatef(0.+moveLegsX, 0.5+moveLegsY, -0.75+moveLegsZ);
            if(transform){
                glRotatef(legRotationZ, 0, 0, 1);
                glRotatef(legRotationX, 1, 0, 0);
            }
            glScalef(7.-stretchLegsX, 1.0, 1.5-stretchLegsZ);
            glutSolidCube(1.0);
        glPopMatrix();

        //linkes hinteres Rad
        glPushMatrix();
            glTranslatef(-2.0, 0., -1.55-moveTiresZ);
            glColor3f(0.2,0.2, 0.2);
            glutSolidCylinder(0.5, 0.40, 100, 100);
            if(!transform)
                glRotatef(wheelRotation, 0, 0, 1); //Rad drehen, so lange keine Transformation statt findet

            glPushMatrix();
                glColor3f(0.8, 0.8, 0.8);
                glTranslatef(0., 0., -0.05);
                glutSolidCylinder(0.4, 0.40, 100, 100);

                // Radmuttern
                glPushMatrix();
                    glColor3f(0., 0., 0.);
                    glTranslatef(0.1, 0.1, -0.01);
                    glutSolidCylinder(0.05, 0.01, 100, 100);
                glPopMatrix();
                glPushMatrix();
                    glColor3f(0., 0., 0.);
                    glTranslatef(-0.1, 0.1, -0.01);
                    glutSolidCylinder(0.05, 0.01, 100, 100);
                glPopMatrix();
                glPushMatrix();
                    glColor3f(0., 0., 0.);
                    glTranslatef(0.1, -0.1, -0.01);
                    glutSolidCylinder(0.05, 0.01, 100, 100);
                glPopMatrix();
                glPushMatrix();
                    glColor3f(0., 0., 0.);
                    glTranslatef(-0.1, -0.1, -0.01);
                    glutSolidCylinder(0.05, 0.01, 100, 100);
                glPopMatrix();
                glPushMatrix();
                    glColor3f(0., 0., 0.);
                    glTranslatef(0., 0., -0.01);
                    glutSolidCylinder(0.05, 0.01, 100, 100);
                glPopMatrix();

            glPopMatrix();
        glPopMatrix();

        //linkes vorderes Rad
        glPushMatrix();
            glTranslatef(2.0, 0., -1.55-moveTiresZ);
            glColor3f(0.2,0.2, 0.2);
            glutSolidCylinder(0.5, 0.40, 100, 100);
            glPushMatrix();
                glColor3f(0.8, 0.8, 0.8);
                glTranslatef(0., 0., -0.05);
                glutSolidCylinder(0.4, 0.40, 100, 100);
                if(!transform)
                    glRotatef(wheelRotation, 0, 0, 1); //Rad drehen, so lange keine Transformation statt findet

                // Radmuttern
                glPushMatrix();
                    glColor3f(0., 0., 0.);
                    glTranslatef(0.1, 0.1, -0.01);
                    glutSolidCylinder(0.05, 0.01, 100, 100);
                glPopMatrix();
                glPushMatrix();
                    glColor3f(0., 0., 0.);
                    glTranslatef(-0.1, 0.1, -0.01);
                    glutSolidCylinder(0.05, 0.01, 100, 100);
                glPopMatrix();
                glPushMatrix();
                    glColor3f(0., 0., 0.);
                    glTranslatef(0.1, -0.1, -0.01);
                    glutSolidCylinder(0.05, 0.01, 100, 100);
                glPopMatrix();
                glPushMatrix();
                    glColor3f(0., 0., 0.);
                    glTranslatef(-0.1, -0.1, -0.01);
                    glutSolidCylinder(0.05, 0.01, 100, 100);
                glPopMatrix();
                glPushMatrix();
                    glColor3f(0., 0., 0.);
                    glTranslatef(0., 0., -0.01);
                    glutSolidCylinder(0.05, 0.01, 100, 100);
                glPopMatrix();

            glPopMatrix();
        glPopMatrix();

        //rechtes hinteres Rad
        glPushMatrix();
            glTranslatef(-2.0, 0., 1.15+moveTiresZ);
            glColor3f(0.2,0.2, 0.2);
            glutSolidCylinder(0.5, 0.40, 100, 100);
            glPushMatrix();
                glColor3f(0.8, 0.8, 0.8);
                glTranslatef(0., 0., 0.05);
                glutSolidCylinder(0.4, 0.40, 100, 100);
                if(!transform)
                    glRotatef(wheelRotation, 0, 0, 1); //Rad drehen, so lange keine Transformation statt findet

                // Radmuttern
                glPushMatrix();
                    glColor3f(0., 0., 0.);
                    glTranslatef(0.1, 0.1, 0.4);
                    glutSolidCylinder(0.05, 0.01, 100, 100);
                glPopMatrix();
                glPushMatrix();
                    glColor3f(0., 0., 0.);
                    glTranslatef(-0.1, 0.1, 0.4);
                    glutSolidCylinder(0.05, 0.01, 100, 100);
                glPopMatrix();
                glPushMatrix();
                    glColor3f(0., 0., 0.);
                    glTranslatef(0.1, -0.1, 0.4);
                    glutSolidCylinder(0.05, 0.01, 100, 100);
                glPopMatrix();
                glPushMatrix();
                    glColor3f(0., 0., 0.);
                    glTranslatef(-0.1, -0.1, 0.4);
                    glutSolidCylinder(0.05, 0.01, 100, 100);
                glPopMatrix();
                glPushMatrix();
                    glColor3f(0., 0., 0.);
                    glTranslatef(0., 0., 0.4);
                    glutSolidCylinder(0.05, 0.01, 100, 100);
                glPopMatrix();

            glPopMatrix();
        glPopMatrix();

        //rechtes vorderes Rad
        glPushMatrix();
            glTranslatef(2.0, 0., 1.15+moveTiresZ);
            glColor3f(0.2,0.2, 0.2);
            glutSolidCylinder(0.5, 0.40, 100, 100);
            glPushMatrix();
                glColor3f(0.8, 0.8, 0.8);
                glTranslatef(0., 0., 0.05);
                glutSolidCylinder(0.4, 0.40, 100, 100);
                if(!transform)
                    glRotatef(wheelRotation, 0, 0, 1); //Rad drehen, so lange keine Transformation statt findet

                // Radmuttern
                glPushMatrix();
                    glColor3f(0., 0., 0.);
                    glTranslatef(0.1, 0.1, 0.4);
                    glutSolidCylinder(0.05, 0.01, 100, 100);
                glPopMatrix();
                glPushMatrix();
                    glColor3f(0., 0., 0.);
                    glTranslatef(-0.1, 0.1, 0.4);
                    glutSolidCylinder(0.05, 0.01, 100, 100);
                glPopMatrix();
                glPushMatrix();
                    glColor3f(0., 0., 0.);
                    glTranslatef(0.1, -0.1, 0.4);
                    glutSolidCylinder(0.05, 0.01, 100, 100);
                glPopMatrix();
                glPushMatrix();
                    glColor3f(0., 0., 0.);
                    glTranslatef(-0.1, -0.1, 0.4);
                    glutSolidCylinder(0.05, 0.01, 100, 100);
                glPopMatrix();
                glPushMatrix();
                    glColor3f(0., 0., 0.);
                    glTranslatef(0., 0., 0.4);
                    glutSolidCylinder(0.05, 0.01, 100, 100);
                glPopMatrix();

            glPopMatrix();
        glPopMatrix();
    glPopMatrix();

   glutSwapBuffers();
   glFlush();
}

void Reshape(int width,int height)
{
   // Hier finden die Reaktionen auf eine Veränderung der Größe des
   // Graphikfensters statt
    // Matrix für Transformation: Frustum->viewport
    glMatrixMode(GL_PROJECTION);
    // Aktuelle Transformations-Matrix zuruecksetzen
    glLoadIdentity ();
    // Viewport definieren
    glViewport(0,0,width,height);
    // Frustum definieren (siehe unten)
    gluPerspective(60., 1., 0.1, 100.0);
    // Matrix für Modellierung/Viewing
    glMatrixMode(GL_MODELVIEW);
}

/*
void MotionP ( int x, int y )
// Maus-Bewegungen ohne gedrückte Maus-Taste
{
    GLfloat xMousePos = float(x);
    GLfloat yMousePos = float(y);
    std::cout <<xMousePos<<", "<<yMousePos<<std::endl;
    // RenderScene aufrufen.
    glutPostRedisplay();
} */

void Motion ( int x, int y )
// Maus-Bewegungen mit gedrückter Maus-Taste
{
    xMousePos = float(x);
    yMousePos = float(y);
    //std::cout <<"Maustaste gedrueckt "<< xMousePos<<", "<<yMousePos<<std::endl;
    // RenderScene aufrufen.
    glutPostRedisplay();
}

void Animate (int value)
{
   // Hier werden Berechnungen durchgeführt, die zu einer Animation der Szene
   // erforderlich sind. Dieser Prozess läuft im Hintergrund und wird alle
   // 1000 msec aufgerufen. Der Parameter "value" wird einfach nur um eins
   // inkrementiert und dem Callback wieder uebergeben.
   //std::cout << "value=" << value << std::endl;
   wheelRotation = wheelRotation - 1.0;
   if ( wheelRotation <= 0.0) {
       wheelRotation = wheelRotation + 360.0;
   }

   //starte Animation: bewege Fahrbahnstreifen
   if(value < 500){
       if(moveLaneLineX < 30.0)
           moveLaneLineX += 0.03;
   }


   //starte Transformation: schiebe Reifen nach aussen, bewege Dach nach oben
   // und skaliere die Beine (kürzer und schmäler)
   if(value > 500 && value <= 700){
       transform = true;
       if(moveTiresZ < 1.0)
           moveTiresZ += 0.03;
       if(moveRoofY < 6.0)
           moveRoofY += 0.04;
       if(stretchLegsX < 4.0)
           stretchLegsX += 0.03;
       if(stretchLegsZ < 0.9)
           stretchLegsZ += 0.02;
   }

   //drehe Beine horizontal und verschiebe sie nach oben, so dass sie auf der Fahrbahn stehen
   if(value > 580 && value <= 680){
      if(legRotationZ > -90)
       legRotationZ -= 1.0;
      if(moveLegsY < 0.5)
          moveLegsY += 0.015;
   }

   //drehe Beine vertikal und verschiebe sie nach links und rechts und mittig nach oben
   //die Mitte der Beine sitzt jetzt am Achsenursprung
   if(value > 680 && value <= 820){
      if(legRotationX > -90)
       legRotationX -= 1.0;
      if(moveLegsX < 1.0)
          moveLegsX += 0.03;
      if(moveLegsZ < 0.75)
          moveLegsZ += 0.02;
   }

   //skaliere Dach als Body
   if(value > 780 && value <= 880){
      if(stretchRoofX < 1.2)
          stretchRoofX += 0.03;
      if(stretchRoofY < 3.0)
          stretchRoofY += 0.06;
   }


   //bewege Dach als Body nach unten
   if(value > 850){
      if(moveRoofY > 3.0)
           moveRoofY = moveRoofY - 0.04;
   }



   //reset Transformation
   if(value == 10000){
       value = 0;
       transform = false;
   }
   // RenderScene aufrufen
   glutPostRedisplay();
   // Timer wieder registrieren; Animate wird so nach 100 msec mit value+=1 aufgerufen
   glutTimerFunc(10, Animate, ++value);
}



int main(int argc, char **argv)
{
   glutInit( &argc, argv );                // GLUT initialisieren
   glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );
   glutInitWindowSize( 600, 600 );         // Fenster-Konfiguration
   glutCreateWindow( "CarTransformer made by Markus Mayer and Daniel Braeutigam" );   // Fenster-Erzeugung
   glutDisplayFunc( RenderScene );         // Zeichenfunktion bekannt machen
   glutReshapeFunc( Reshape );
   //glutPassiveMotionFunc( MotionP );
   glutMotionFunc( Motion );
   glutSpecialFunc( SpecialFunc );
   // TimerCallback registrieren; wird nach 10 msec aufgerufen mit Parameter 0
   glutTimerFunc( 10, Animate, 0);
   Init();
   glutMainLoop();
   return 0;
}