spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

//===========================================================================
// Dreidimensionale Körper
//===========================================================================

//===========================================================================
// includes
//===========================================================================

// Deklaration einbinden
#include "cube.h"

// GL Bibliothek einbinden (je nach Betriebssystem)

#ifdef WIN32
    #include <windows.h>
    #include <GL/gl.h>
#else
    #include <OpenGL/gl.h>
#endif

#include <stdlib.h> // rand(), RAND_MAX


//===========================================================================
// implementierung
//===========================================================================

CCube::CCube()
{
    // Attribute mit Standardwerten initialisieren
    m_divisions = 1;    // Anzahl Cubes
    m_rotation  = 0.0f;
    m_rotationTime = 30.0f;
}


CCube::~CCube()
{
    // nichts aufzuräumen
}


void CCube::update(float time)
{
    // Rotation des Objekls weiterbewegen (in Grad)
    m_rotation += 360.0f * time / m_rotationTime;
}


void CCube::render()
{
    // Körper rotieren
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glRotatef(m_rotation, 0.0f, 1.0f, 0.0f);

    // Linienzeichnen einleiten
    glBegin(GL_LINES);

    // Verschachtelte For-Schleifen, um das Rechteck
    // mit einer bestimmten Anzahl an Unterteiolungen
    // zu druchlaufen
    for (unsigned int j = 0; j <= m_divisions; j++)
    {
        // Unterteilungspunkt b zwischen -1 und 1 berechnen
        float b = float(j)/float(m_divisions)*2.0f - 1.0f;

        for (unsigned int i = 0; i <= m_divisions; i++)
        {
            // Unterteilungspunkt a zwischen -1 und 1 berechnen
            float a = float(i)/float(m_divisions)*2.0f - 1.0f;

            // Linie in x-Richtung zeichnen
            glVertex3f(-1, a, b);
            glVertex3f( 1, a, b);

            // Linie in y-Richtung zeichnen
            glVertex3f(a, -1, b);
            glVertex3f(a,  1, b);

            // Linie in z-Richtung zeichnen
            glVertex3f(a, b, -1);
            glVertex3f(a, b,  1);
        }
    }

    // Ende der Linien
    glEnd();

    // Alte Transformation wiederherstellen (Rotation löschen)
    glPopMatrix();

} // render()

C-/C++-Quelltext

//===========================================================================
// Dreidimensionale Körper
//===========================================================================

//===========================================================================
// includes
//===========================================================================

// GL und GLUT Bibliotheken einbinden (je nach Betriebssystem)

#ifdef WIN32
    #include <windows.h>
    #include <GL/gl.h>
    #include "GL/glut.h"
#else
    #include <GLUT/glut.h>
#endif

#include "cube.h"

#include <stdlib.h> // exit()


//===========================================================================
// Globale variablen
//===========================================================================

int   glutWindow = 0;
CCube cube;


//===========================================================================
// OpenGL Zeichenfunktion
//===========================================================================

void transform(unsigned int width, unsigned int height)
{
    // OpenGL Transformationen initialisieren...
    // Ausgabefenstergröße setzen
    glViewport(0, 0, (GLint)width, (GLint)height);

    // Transformationen für 3D-Koordinaten bearbeiten
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    // Kameraposition setzen
    gluLookAt(0.0, 0.0, 4.0,  // von wo
            0.0, 0.0, 0.0,  // nach wo
            0.0, 1.0, 0.0); // wo ist oben?

    // Perspektivische Projektion bearbeiten
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    // Verhältnis Breite zu Höhe (aspect) berechnen
    GLdouble aspect = (GLdouble)width / (GLdouble)height;
    
    // Kameraperspektive setzen
    gluPerspective(53,          // Öffnungswinkel vertikal (field of view)
                aspect,     // aspect ratio setzen
                0.001, 10.0); // nahe und ferne Begrenzungsebene setzen
}


//===========================================================================
// GLUT callback funktionen
//===========================================================================

void display(void)
{
    // Ausgabefenster in schwarz löschen
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // Transformationen vor dem Zeichnen setzen
    transform(glutGet(GLUT_WINDOW_WIDTH), glutGet(GLUT_WINDOW_HEIGHT));

    // Würfelrotation aktualisieren (angenommen: 60Hz)
    cube.update(1.0f / 60.0f);

    // Zeichnen
    glColor3f(0.6f, 0.8f, 0.4f);
    cube.render();

    // Hintergrundpuffer anzeigen
    glutSwapBuffers();
}


void idle(void)
{
    // nochmaliges Zeichnen einleiten
    if (glutWindow != 0) glutPostRedisplay();
}


void keyboard(unsigned char key, int x, int y)
{
    // Fenster schließen
    glutDestroyWindow(glutWindow);
    glutWindow = 0;

    // Programm beenden (etwas unsauber)
    exit(0);
}


//===========================================================================
// Hauptroutine
//===========================================================================

int main(int argc, char* argv[])
{
    // GLUT initialisieren
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);

    // Fenster öffnen
    glutWindow = glutCreateWindow("Wuerfel");

    // GLUT Funktionen für Zeichnen, Leerlauf, Tastatur und Maus setzen
    glutDisplayFunc(display);
    glutIdleFunc(idle);
    glutKeyboardFunc(keyboard);

    // Vollbildmodus ohne Mauszeiger
    glutFullScreen();
    glutSetCursor(GLUT_CURSOR_NONE);

    // Tiefenpuffer-Test einschalten
    glEnable(GL_DEPTH_TEST);

    // Hauptschleife des Programms aufrufen
    glutMainLoop();

    // Bis hierhin kommt das Programm nicht
    return 0;
}

C-/C++-Quelltext

//===========================================================================
// Dreidimensionale Körper
//===========================================================================

// mehrfaches Einbinden durch Präprozessor verhindern
#ifndef _CUBE_H_
#define _CUBE_H_


//===========================================================================
// Klassendeklaration
//===========================================================================

// Würfelklasse
class CCube
{
  // Nachfolgende Elemente sind öffentlich
  public:

    /// Konstruktor
    CCube();

    /// Destruktor virtuell, d.h. alles bereit zum Ableiten
    virtual ~CCube();

    /// aktualisieren
    void update(float time);

    /// Zeichnen
    void render();

  // Nachfolgende Elemente sind geschützt
  protected:

    unsigned int m_divisions;   ///< Unterteilungen der Achsen
    float       m_rotation;     ///< Rotation des Würfels in Grad
    float       m_rotationTime; ///< Rotationszeit des Würfels in Sekunden

}; // Klassendeklaration auch mit Semikolon abschließen

#endif // _CUBE_H_

C-/C++-Quelltext

// Linie in x-Richtung zeichnen
            glVertex3f(-1, 0.2, 0.2);
            glVertex3f(1, a, b);

            // Linie in y-Richtung zeichnen
            glVertex3f(a, -1, b);
            glVertex3f(a, 1, b);

            // Linie in z-Richtung zeichnen
            glVertex3f(a, b, -1);
            glVertex3f(a, b, 1);