GLWireframe.cpp

gehe zur Dokumentation dieser Datei

#include <qcursor.h>
#include <qfont.h>

#include <math.h>
#include <iostream>
using namespace std; 

#include "GLWireframe.h"

//------------------------------------------------------------------------------------------------------------------
GLWireframe::GLWireframe( QWidget* parent, const char* name, QGLWidget *share, WFlags f, Spur** spurenliste, long int anzahlSpuren, Liste *kreuzungsliste ) : QGLWidget( parent, name, share, f )
{
    clear();
    
    spurenliste_ = spurenliste;
    anzahlSpuren_ = anzahlSpuren;
        kreuzungsliste_ = kreuzungsliste;
    
    erzeugeParameter();
        ladeWerkseinstellungen();
        initializeGL();
}
//------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------------------------------------------------------------------
void GLWireframe::erzeugeParameter()
{
 // Extrahiere die maximale Ausdehnung in alle Richtungen
 int i(0);
 
 for( i = 0; i < anzahlSpuren_; i++ )
 {
  if( maximaleKoordinaten_[0] < spurenliste_[i]->gibKoordinaten().x )
   maximaleKoordinaten_[0] = spurenliste_[i]->gibKoordinaten().x;
  if( maximaleKoordinaten_[1] < spurenliste_[i]->gibKoordinaten().y )
   maximaleKoordinaten_[1] = spurenliste_[i]->gibKoordinaten().y;
  if( maximaleKoordinaten_[2] < spurenliste_[i]->gibKoordinaten().z )
   maximaleKoordinaten_[2] = spurenliste_[i]->gibKoordinaten().z;
  
  if( minimaleKoordinaten_[0] > spurenliste_[i]->gibKoordinaten().x )
   minimaleKoordinaten_[0] = spurenliste_[i]->gibKoordinaten().x;
  if( minimaleKoordinaten_[1] > spurenliste_[i]->gibKoordinaten().y )
   minimaleKoordinaten_[1] = spurenliste_[i]->gibKoordinaten().y;
  if( minimaleKoordinaten_[2] > spurenliste_[i]->gibKoordinaten().z )
   minimaleKoordinaten_[2] = spurenliste_[i]->gibKoordinaten().z;
 }
 
 if( anzahlSpuren_!= 0 ){
        // Errechne eine Verschiebung, damit das Zentrum des Universums immer in (0|0|0) liegt
        verschiebungsKoordinaten_[0] = (maximaleKoordinaten_[0] + minimaleKoordinaten_[0]) / 2;
        verschiebungsKoordinaten_[1] = (maximaleKoordinaten_[1] + minimaleKoordinaten_[1]) / 2;
        verschiebungsKoordinaten_[2] = (maximaleKoordinaten_[2] + minimaleKoordinaten_[2]) / 2;
 }
}
//------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------------------------------------------------------------------
GLWireframe::GLWireframe( QWidget* parent, const char* name, QGLWidget *share, WFlags f , double xRotD, double yRotD, double zRotD, 
        double xKameraD, double yKameraD, double zKameraD, Spur** spurenliste, long int anzahlSpuren, Liste *kreuzungsliste  ) : QGLWidget( parent, name, share, f )
{
 clear();

 spurenliste_ = spurenliste;
 anzahlSpuren_ = anzahlSpuren;
 kreuzungsliste_ = kreuzungsliste;
    
 standardxRot_ = xRotD;
 standardyRot_ = yRotD;
 standardzRot_ = zRotD;
    
 standardpunktKamera_[0] = xKameraD;
 standardpunktKamera_[1] = yKameraD;
 standardpunktKamera_[2] = zKameraD;
    
 standardpunktReferenz_[0] = xKameraD;
 standardpunktReferenz_[1] = yKameraD;
 standardpunktReferenz_[2] = zKameraD;
    
 standardvectorKameraOben_[0] = 0;
 standardvectorKameraOben_[1] = 0;
 standardvectorKameraOben_[2] = 1;
 
 erzeugeParameter();
 ladeStandardwerte();
 initializeGL();
}
//------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------------------------------------------------------------------
GLWireframe::~GLWireframe(){
        // makeCurrent();
}
//------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------------------------------------------------------------------
void GLWireframe::paintGL()
{
 Fahrzeug *fahrzeug;
 int i = 0;

 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 transform();
 
 glTranslatef( -1*verschiebungsKoordinaten_[0], -1*verschiebungsKoordinaten_[1],-1*verschiebungsKoordinaten_[2] );

 // Liste Zeichnen
 glCallList( list_ );
 
 // Dastellen aller Haltelinien
 for( i = 0; i < anzahlSpuren_; i++ )
  zeichneHaltelinie( spurenliste_[i] );

 // Darstellen alle Fahrzeuge
 if( fahrzeugliste_ != 0 )
 {
  fahrzeugliste_->geheZuErsten();
  while( !fahrzeugliste_->istEnde() )
  {
   fahrzeugliste_->geheZuNaechsten();
   fahrzeug = (Fahrzeug *) fahrzeugliste_->gibDaten();
   if( !fahrzeug->sollEntferntWerden() )
    zeichneFahrzeug( fahrzeug );
  }
 }
 
 glTranslatef( verschiebungsKoordinaten_[0], verschiebungsKoordinaten_[1],verschiebungsKoordinaten_[2] );
}
//------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------------------------------------------------------------------
void GLWireframe::initializeGL()
{
 // Setzte die Hintergrundfarbe auf den Standard
 glClearColor( 1.0, 1.0, 1.0, 1.0 );
 glEnable( GL_NORMALIZE );
 
 if( anzahlSpuren_ != 0 ){
        // Liste aller nicht veraenderlichen Objekte anlegen
        erzeugeZeichenliste();
 }
 
 /*Loeschfarbe fuer Bildschirm
 glClearColor( 1.0, 1.0, 1.0, 1.0 );
 //z-Puffer-Test aktivieren:
 glEnable( GL_DEPTH_TEST );
 //Gouraud-Shading fuer Polygone
 glShadeModel( GL_SMOOTH );
 //Polygone vollflaechig zeichnen
 glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
 //Polygonrueckseiten werden nicht dargestellt (Backface-Culling)
 glCullFace( GL_BACK );
 glEnable( GL_CULL_FACE );
 //Beleuchtungsrechnung und eine weisse Lichtquelle aktivieren
 glEnable(GL_LIGHTING);
 GLfloat light_amb[]  = { 0.3, 0.3, 0.3, 1.0 };
 GLfloat light_diff[] = { 0.2, 0.2, 0.2, 1.0 };
 GLfloat light_spec[] = { 0.1, 0.1, 0.1, 1.0 };
 glLightfv( GL_LIGHT0, GL_AMBIENT, light_amb );
 glLightfv( GL_LIGHT0, GL_DIFFUSE, light_diff );
 glLightfv( GL_LIGHT0, GL_SPECULAR, light_spec );
 glEnable( GL_LIGHT0 );
 glLightModeli( GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE );
 //glLightModeli( GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE );
 glEnable( GL_NORMALIZE );*/
 
}
//------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------------------------------------------------------------------
void GLWireframe::resizeGL( int breite, int hoehe )
{
    if( breite > hoehe )
      hoehe = breite;
    else
      breite = hoehe;

    glViewport( 0, 0, breite, hoehe );
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
 gluPerspective( 90.0, 1, 0, 20.0 );
 
 // ohne Frustum unter Mac OS kein Bild
 // mit Frustum unter Windows kein Bild
#ifndef _WIN32 && #ifndef WIN32 && #ifndef __WIN32__
 glFrustum( -1.0, 1.0, -1.0, 1.0, 1.0, 10000.0 );
#endif

 glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslatef( 0.0, 0.0, -40.0 );
}
//------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------------------------------------------------------------------
void GLWireframe::transform()
{
  glLoadIdentity();

  // Zoomen durchfuehren (durch Kameraverschiebung)
  gluLookAt(punktKamera_[0],punktKamera_[1], punktKamera_[2]+(gibMaximaleAusdehnung()),
   punktReferenz_[0], punktReferenz_[1], punktReferenz_[2], 
   vectorKameraOben_[0], vectorKameraOben_[1], vectorKameraOben_[2] );

  // Rotationen durchfuehren (direkt mit dem Objekt)
  glRotatef( xRot_, 1.0, 0.0, 0.0 );
  glRotatef( yRot_, 0.0, 1.0, 0.0 );
  glRotatef( zRot_, 0.0, 0.0, 1.0 );
}
//------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------------------------------------------------------------------
void GLWireframe::setzeXRotation( double grad )
{
    xRot_ = (GLfloat)fmod(grad, 360.0);
 
    updateGL();
}
//------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------------------------------------------------------------------
void GLWireframe::setzeYRotation( double grad )
{
    yRot_ = (GLfloat)fmod(grad, 360.0);
 
    updateGL();
}
//------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------------------------------------------------------------------
void GLWireframe::setzeZRotation( double grad )
{
    zRot_ = (GLfloat)fmod(grad, 360.0);
 
    updateGL();
}
//------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------------------------------------------------------------------
void GLWireframe::setzeRotationImpulse( double x, double y, double z )
{
    setzeXRotation( xRot_ + 180*x );
    setzeYRotation( yRot_ + 180*y );
    setzeZRotation( zRot_ - 180*z );
}
//------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------------------------------------------------------------------
void GLWireframe::setzeZoom( double aenderung )
{
  aenderung = aenderung / 100 * gibMaximaleAusdehnung();
  
  punktKamera_[2] = punktKamera_[2] - aenderung;
  punktReferenz_[2] = punktReferenz_[2] - aenderung;
  
  updateGL();
}
//------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------------------------------------------------------------------
void GLWireframe::setzeTranslationImpulse( double x, double y )
{
  x = x / 700 * gibMaximaleAusdehnung();
  y = y / 700 * gibMaximaleAusdehnung();

  punktKamera_[0] = punktKamera_[0] - x;
  punktKamera_[1] = punktKamera_[1] + y;

  punktReferenz_[0] = punktReferenz_[0] - x;
  punktReferenz_[1] = punktReferenz_[1] + y;

  updateGL();
}
//------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------------------------------------------------------------------
void GLWireframe::mousePressEvent( QMouseEvent *event )
{
    event->accept();
    oldPos_ = event->pos();
}
//------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------------------------------------------------------------------
void GLWireframe::mouseReleaseEvent( QMouseEvent *event )
{
    event->accept();
    oldPos_ = event->pos();
}
//------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------------------------------------------------------------------
void GLWireframe::mouseMoveEvent( QMouseEvent *event )
{
    event->accept();
 
    double dx = event->x() - oldPos_.x();
    double dy = event->y() - oldPos_.y();

    oldPos_ = event->pos();

    double rx = dx / width();
    double ry = dy / height();
 
    if( maussteuerung_ == 1 )
    {
 if ( event->state() == (LeftButton | RightButton) )
                      setzeRotationImpulse( -ry, rx, 0 );
                else if ( event->state() == LeftButton )
                {
                      setzeZoom( dy );
                      setzeRotationImpulse( 0, 0, -rx );
                }
                else if ( event->state() == RightButton )
                      setzeTranslationImpulse( dx, dy ); 
     }
     else
     {
                if ( event->state() == MidButton )
                      setzeRotationImpulse( 0, 0, -rx );
                else if ( event->state() == LeftButton ) 
                      setzeTranslationImpulse( dx, dy );
                else if ( event->state() == RightButton )
                      setzeRotationImpulse( -ry, rx, 0 );
     }
}
//------------------------------------------------------------------------------------------------------------------


//------------------------------------------------------------------------------------------------------------------
void GLWireframe::wheelEvent( QWheelEvent *event )
{
    if( maussteuerung_ == 2 )
    {
 event->accept();
                setzeZoom( event->delta() / 100 );
    } 
}

//------------------------------------------------------------------------------------------------------------------
double GLWireframe::gibXRot()
{
    return xRot_;
}
//------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------------------------------------------------------------------
double GLWireframe::gibYRot()
{
    return yRot_;
}
//------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------------------------------------------------------------------
double GLWireframe::gibZRot( )
{
    return zRot_;
} 
//------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------------------------------------------------------------------
double GLWireframe::gibXKamera( )
{
    return punktKamera_[0];
}
//------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------------------------------------------------------------------
double GLWireframe::gibYKamera( )
{
    return punktKamera_[1];
}
//------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------------------------------------------------------------------
double GLWireframe::gibZKamera( )
{
    return punktKamera_[2];
}
//------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------------------------------------------------------------------
void GLWireframe::zeichne( )
{
    updateGL();
}
//------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------------------------------------------------------------------
void GLWireframe::clear()
{
 maximaleKoordinaten_[0] = 0;
 maximaleKoordinaten_[1] = 0;
 maximaleKoordinaten_[2] = 0;
 minimaleKoordinaten_[0] = 5000;
 minimaleKoordinaten_[1] = 5000;
 minimaleKoordinaten_[2] = 5000;
 anzahlSpuren_ = 0;
 fahrzeugliste_ = 0;
 spurenliste_ = 0;
 kreuzungsliste_ = 0;
 maussteuerung_ = 2;
 list_ = 0;
}
//------------------------------------------------------------------------------------------------------------------

//------------------------------------------------------------------------------------------------------------------
void GLWireframe::setzeMaussteuerung( int maussteuerung )
{
 if( maussteuerung == 1 || maussteuerung == 2 )
 {   
  maussteuerung_ = maussteuerung; 
 }
}
//------------------------------------------------------------------------------------------------------------------


//------------------------------------------------------------------------------------------------------------------
double GLWireframe::gibMaximaleAusdehnung( )
{
  double ausdehnung(0);
  
  ausdehnung = maximaleKoordinaten_[0] - minimaleKoordinaten_[0];
  if( ausdehnung < maximaleKoordinaten_[1] - minimaleKoordinaten_[1]  )
    ausdehnung = maximaleKoordinaten_[1] - minimaleKoordinaten_[1];
  if( ausdehnung < maximaleKoordinaten_[2] - minimaleKoordinaten_[2]  )
    ausdehnung = maximaleKoordinaten_[2] - minimaleKoordinaten_[2];

  return ausdehnung;
}
//------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------------------------------------------------------------------
void GLWireframe::ladeStandardwerte()
{
 xRot_ = standardxRot_;
 yRot_ = standardyRot_;
 zRot_ = standardzRot_;
 
 punktKamera_[0] = standardpunktKamera_[0];
 punktKamera_[1] = standardpunktKamera_[1];
 punktKamera_[2] = standardpunktKamera_[2];
 
 punktReferenz_[0] = standardpunktReferenz_[0];
 punktReferenz_[1] = standardpunktReferenz_[1];
 punktReferenz_[2] = standardpunktReferenz_[2];
 
 vectorKameraOben_[0] = standardvectorKameraOben_[0];
 vectorKameraOben_[1] = standardvectorKameraOben_[1];
 vectorKameraOben_[2] = standardvectorKameraOben_[2];
 
 updateGL();
}
//------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------------------------------------------------------------------
void GLWireframe::ladeWerkseinstellungen()
{
    standardxRot_ = 0;
    standardyRot_ = 0;
    standardzRot_ = 0;
  
 erzeugeParameter();
 
    standardpunktKamera_[0] = 0;
    standardpunktKamera_[1] = 1000;
    standardpunktKamera_[2] = 200;
 
    standardpunktReferenz_[0] = 0;
    standardpunktReferenz_[1] = 1000;
    standardpunktReferenz_[2] = 0;
 
    standardvectorKameraOben_[0] = 0;
    standardvectorKameraOben_[1] = 1;
    standardvectorKameraOben_[2] = 0;
 
    ladeStandardwerte();
}
//------------------------------------------------------------------------------------------------------------------



//------------------------------------------------------------------------------------------------------------------
void GLWireframe::erzeugeZeichenliste()
{
 Kreuzung *kreuzung;
 int i = 0;

 // Erzeuge eine neue Displayliste
 list_ = glGenLists( 1 );
 glNewList( list_, GL_COMPILE );
 
 // Fuege die Spuren in die Liste ein
 for( i = 0; i < anzahlSpuren_; i++ )
  zeichneSpur( spurenliste_[i] );
 
 // Fuege die Verbindungselemente an die Spuren an
 for( i = 0; i < anzahlSpuren_; i++ )
 {
  if( spurenliste_[i]->gibWahrscheinlichkeit( LINKS ) != 0 )
   zeichneSpurverbindung( spurenliste_[i], spurenliste_[i]->gibNaechsteSpur( LINKS ) );
  
  if( spurenliste_[i]->gibWahrscheinlichkeit( MITTE ) != 0 )
   zeichneSpurverbindung( spurenliste_[i], spurenliste_[i]->gibNaechsteSpur( MITTE ) );
  
  if( spurenliste_[i]->gibWahrscheinlichkeit( RECHTS ) != 0 )
   zeichneSpurverbindung( spurenliste_[i], spurenliste_[i]->gibNaechsteSpur( RECHTS ) );
 }
 
 // Zeichne alle Kreuzungen ein
 if( kreuzungsliste_ != 0 )
 {
  kreuzungsliste_->geheZuErsten();
  while( !kreuzungsliste_->istEnde() )
  {
   kreuzungsliste_->geheZuNaechsten();
   kreuzung = (Kreuzung *) kreuzungsliste_->gibDaten();
   zeichneKreuzung( kreuzung );
  }
 }
 
 // Die Liste beenden
 glEndList();
}
//------------------------------------------------------------------------------------------------------------------



//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void GLWireframe::zeichneSpur(Spur *spur)
{
 double laenge,breite = 20.0;
 int    ausrichtung, richtung, pfeil;
 Koordinaten *grau = new Koordinaten();
     grau->x = grau->y = grau->z = 76.0;
 Koordinaten *weiss = new Koordinaten();
     weiss->x = weiss->y = weiss->z = 204.0;
 
 laenge      = spur->gibLaenge()*10;
 ausrichtung = spur->gibAusrichtung();
 richtung    = spur->gibRichtung();
 pfeil       = spur->gibAbbiegerichtung();

 
 Koordinaten *ursprung = new Koordinaten();
 *ursprung = spur->gibKoordinaten();
 
 // Spur an den richtigen Platz verschieben
 glTranslated( ursprung->x, ursprung->y, ursprung->z);
  
 if( ausrichtung == HOR )
 {
  // Seitenstreifen
  glBegin(GL_QUADS);
   setMaterialColor3d( *weiss );

   glVertex3d(    0.0,    0.0, 0.0 ); 
   glVertex3d( laenge*richtung,          0.0, 0.0 );
   glVertex3d( laenge*richtung, 2.0*richtung, 0.0 );
   glVertex3d(             0.0, 2.0*richtung, 0.0 );
  glEnd();
  
  // Fahrbahn
  glBegin(GL_QUADS);
   setMaterialColor3d( *grau );
  
   glVertex3d(    0.0,          2.0*richtung, 0.0 );
   glVertex3d( laenge*richtung,          2.0*richtung, 0.0 );
   glVertex3d( laenge*richtung, (breite-2.0)*richtung, 0.0 );
   glVertex3d(             0.0, (breite-2.0)*richtung, 0.0 );
  glEnd();
  
  // Seitenstreifen
  glBegin(GL_QUADS);
   setMaterialColor3d( *weiss );
  
   glVertex3d(             0.0, (breite-2.0)*richtung, 0.0 ); 
   glVertex3d( laenge*richtung, (breite-2.0)*richtung, 0.0 );
   glVertex3d( laenge*richtung,       breite*richtung, 0.0 );
   glVertex3d(             0.0,       breite*richtung, 0.0 );
  glEnd();
  
  // Abbiegepfeil
  switch( pfeil )
  {
   case MITTE:
   {
    glBegin(GL_QUADS);
     setMaterialColor3d( *weiss );
  
     glVertex3d( (laenge-19)*richtung,            (6.0)*richtung, 0.5 ); 
     glVertex3d(  (laenge-8)*richtung, ((breite/2)-0.5)*richtung, 0.5 ); 
     glVertex3d(  (laenge-8)*richtung, ((breite/2)+0.5)*richtung, 0.5 ); 
     glVertex3d( (laenge-19)*richtung,     (breite-6.0)*richtung, 0.5 ); 
    glEnd();
   } break;
   case LINKS:
   {
    glBegin(GL_QUADS);
    setMaterialColor3d( *weiss );
    
     glVertex3d( (laenge-15)*richtung,          4.0*richtung, 0.5 ); 
     glVertex3d(  (laenge-8)*richtung, (breite-6.0)*richtung, 0.5 ); 
     glVertex3d(  (laenge-8)*richtung, (breite-5.0)*richtung, 0.5 ); 
     glVertex3d( (laenge-21)*richtung, (breite-9.0)*richtung, 0.5 ); 
    glEnd();
   } break;
   case RECHTS:
   {
    glBegin(GL_QUADS);
    setMaterialColor3d( *weiss );
    
     glVertex3d( (laenge-21)*richtung, (breite-11.0)*richtung, 0.5 ); 
     glVertex3d(  (laenge-8)*richtung,           5.0*richtung, 0.5 ); 
     glVertex3d(  (laenge-8)*richtung,           6.0*richtung, 0.5 ); 
     glVertex3d( (laenge-15)*richtung, (breite- 4.0)*richtung, 0.5 ); 
    glEnd();
   } break;
   default: break;
  }
 }
 else
 { // Seitenstreifen
  glBegin(GL_QUADS);
   setMaterialColor3d( *weiss );
  
   glVertex3d(    0.0,        0.0, 0.0 ); 
   glVertex3d( 2.0*richtung,             0.0, 0.0 );
   glVertex3d( 2.0*richtung, laenge*richtung, 0.0 );
   glVertex3d(          0.0, laenge*richtung, 0.0 );
  glEnd();
  
  // Fahrbahn
  glBegin(GL_QUADS);
   setMaterialColor3d( *grau );
  
   glVertex3d(    2.0*richtung,             0.0, 0.0 );
   glVertex3d( (breite-2.0)*richtung,             0.0, 0.0 );
   glVertex3d( (breite-2.0)*richtung, laenge*richtung, 0.0 );
   glVertex3d(          2.0*richtung, laenge*richtung, 0.0 );
  glEnd();
  
  // Seitenstreifen
  glBegin(GL_QUADS);
   setMaterialColor3d( *weiss );
  
   glVertex3d( (breite-2.0)*richtung,             0.0, 0.0 );
   glVertex3d(       breite*richtung,             0.0, 0.0 );
   glVertex3d(       breite*richtung, laenge*richtung, 0.0 );
   glVertex3d( (breite-2.0)*richtung, laenge*richtung, 0.0 );
  glEnd();
  
  // Abbiegepfeil
  switch( pfeil )
  {
   case MITTE:
   {
    glBegin(GL_QUADS);
     setMaterialColor3d( *weiss );
    
     glVertex3d(            (6.0)*richtung, (laenge-19)*richtung, 0.5 ); 
     glVertex3d(     (breite-6.0)*richtung, (laenge-19)*richtung, 0.5 ); 
     glVertex3d( ((breite/2)+0.5)*richtung,  (laenge-8)*richtung, 0.5 ); 
     glVertex3d( ((breite/2)-0.5)*richtung,  (laenge-8)*richtung, 0.5 ); 
    glEnd();
   } break;
   case RECHTS:
   {
    glBegin(GL_QUADS);
     setMaterialColor3d( *weiss );
    
     glVertex3d(          4.0*richtung, (laenge-15.0)*richtung, 0.5 );  
     glVertex3d( (breite-9.0)*richtung, (laenge-21.0)*richtung, 0.5 ); 
     glVertex3d( (breite-4.0)*richtung, (laenge-10.0)*richtung, 0.5 ); 
     glVertex3d( (breite-4.0)*richtung, (laenge- 9.0)*richtung, 0.5 ); 
    glEnd();
   } break;
   case LINKS:
   {
    glBegin(GL_QUADS);
     setMaterialColor3d( *weiss );
    
     glVertex3d(           4.0*richtung, (laenge- 9.0)*richtung, 0.5 ); 
     glVertex3d(           4.0*richtung, (laenge-10.0)*richtung, 0.5 ); 
     glVertex3d( (breite-11.0)*richtung, (laenge-21.0)*richtung, 0.5 ); 
     glVertex3d( (breite- 4.0)*richtung, (laenge-15.0)*richtung, 0.5 ); 
    glEnd();
   } break;
  }
 }
  
  // Koordinatensystem zurueckschieben
  glTranslated( -1*ursprung->x, -1*ursprung->y, -1*ursprung->z);
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++



//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void GLWireframe::zeichneHaltelinie(Spur *spur)
{
 double laenge,breite = 20.0;
 int    richtung, zustand, ausrichtung;
 Koordinaten *zustandsFarbe = new Koordinaten();
 
 
 laenge      = spur->gibLaenge()*10;
 richtung    = spur->gibRichtung();
 ausrichtung = spur->gibAusrichtung();
 zustand     = spur->gibEndzustand();
 
 
 // Farbe nach Zustand festlegen
 switch( zustand )
 {
  case ROT:  { zustandsFarbe->x = 222; zustandsFarbe->y = 33; zustandsFarbe->z = 56; } break;
  case GELB: { zustandsFarbe->x = 247; zustandsFarbe->y = 217; zustandsFarbe->z = 54; } break;
  default:   { zustandsFarbe->x = 0;  zustandsFarbe->y = 252; zustandsFarbe->z = 69; } break;
 }
 
 Koordinaten *ursprung = new Koordinaten();
 *ursprung = spur->gibKoordinaten();
 
 // Spur an den richtigen Platz verschieben
 glTranslated( ursprung->x, ursprung->y, ursprung->z);
 
 if( ausrichtung == HOR )
 {  
  if( zustand )
  {   // Endzustandstreifen
   glBegin(GL_QUADS);
   setMaterialColor3d( *zustandsFarbe );
   
   glVertex3d( (laenge-4)*richtung,       2.0*richtung, 0.5 );  
   glVertex3d(     laenge*richtung,    2.0*richtung, 0.5 ); 
   glVertex3d(     laenge*richtung, (breite-2.0)*richtung, 0.5 ); 
   glVertex3d( (laenge-4)*richtung, (breite-2.0)*richtung, 0.5 ); 
   glEnd();
  }
 }
 else
 { 
  if( zustand )
  {   // Endzustandstreifen
   glBegin(GL_QUADS);
   setMaterialColor3d( *zustandsFarbe );
   
   glVertex3d(    2.0*richtung, (laenge-4)*richtung, 0.5 );  
   glVertex3d( (breite-2.0)*richtung, (laenge-4)*richtung, 0.5 ); 
   glVertex3d( (breite-2.0)*richtung,     laenge*richtung, 0.5 ); 
   glVertex3d(    2.0*richtung,     laenge*richtung, 0.5 ); 
   glEnd();
  }
 }
 
 // Koordinatensystem zurueckschieben
 glTranslated( -1*ursprung->x, -1*ursprung->y, -1*ursprung->z);
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++



//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void GLWireframe::zeichneKreuzung(Kreuzung *kreuzung)
{
 Koordinaten *nordR = new Koordinaten();
     nordR->x = nordR->y = nordR->z = -1;
 Koordinaten *nordL = new Koordinaten();
     nordL->x = nordL->y = nordL->z = -1;
 Koordinaten *westO = new Koordinaten();
     westO->x = westO->y = westO->z = -1;
 Koordinaten *westU = new Koordinaten();
     westU->x = westU->y = westU->z = -1;
 Koordinaten *suedL = new Koordinaten();
     suedL->x = suedL->y = suedL->z = -1;
 Koordinaten *suedR = new Koordinaten();
     suedR->x = suedR->y = suedR->z = -1;
 Koordinaten *ostU = new Koordinaten();
     ostU->x = ostU->y = ostU->z = -1;
 Koordinaten *ostO = new Koordinaten();
     ostO->x = ostO->y = ostO->z = -1;
 
 Koordinaten *farbe  = new Koordinaten();
     farbe->x = farbe->y = farbe->z = 76;
 bool nordFlag = FALSE,westFlag = FALSE,suedFlag = FALSE,ostFlag = FALSE;
 int i;
 
 
 // Westen
 for( i = LINKS; i <= RECHTS; i++ )
 {
  if( kreuzung->gibSpur( WEST, i ) )
  {   // wenn Spur im Westen existiert, dann mitzeichnen
   westFlag = TRUE;
  
   if( westO->y == -1 )
   {
    *westO = kreuzung->gibSpur( WEST, i )->gibKoordinaten();
    westO->x += kreuzung->gibSpur( WEST, i )->gibLaenge()*10;
    westO->y += 20;
   }
  
   *westU = kreuzung->gibSpur( WEST, i )->gibKoordinaten();
   westU->x += kreuzung->gibSpur( WEST, i )->gibLaenge()*10;
  }
 }
 
 // Sueden
 for( i = LINKS; i <= RECHTS; i++ )
 {
  if( kreuzung->gibSpur( SUED, i ) )
  {   // wenn Spur im Sueden existiert, dann mitzeichnen
   suedFlag = TRUE;
   
   if( suedL->y == -1 )
   {
    *suedL = kreuzung->gibSpur( SUED, i )->gibKoordinaten();
    suedL->y += kreuzung->gibSpur( SUED, i )->gibLaenge()*10;
   }
   
   *suedR = kreuzung->gibSpur( SUED, i )->gibKoordinaten();
   suedR->y += kreuzung->gibSpur( SUED, i )->gibLaenge()*10;
   suedR->x += 20;
  }
 }
 
 // Osten
 for( i = LINKS; i <= RECHTS; i++ )
 {
  if( kreuzung->gibSpur( OST, i ) )
  {   // wenn Spur im Osten existiert, dann mitzeichnen
   ostFlag = TRUE;
   
   if( ostU->y == -1 )
   {
    *ostU = kreuzung->gibSpur( OST, i )->gibKoordinaten();
    ostU->x -= kreuzung->gibSpur( OST, i )->gibLaenge()*10;
    ostU->y -= 20;
   }
   
   *ostO = kreuzung->gibSpur( OST, i )->gibKoordinaten();
   ostO->x -= kreuzung->gibSpur( OST, i )->gibLaenge()*10;
  }
 }
 
 // Norden
 for( i = LINKS; i <= RECHTS; i++ )
 {
  if( kreuzung->gibSpur( NORD, i ) )
  {   // wenn Spur im Norden existiert, dann mitzeichnen
   nordFlag = TRUE;
   
   if( nordR->y == -1 )
   {
    *nordR = kreuzung->gibSpur( NORD, i )->gibKoordinaten();
    nordR->y -= kreuzung->gibSpur( NORD, i )->gibLaenge()*10;
   }
   
   *nordL = kreuzung->gibSpur( NORD, i )->gibKoordinaten();
   nordL->y -= kreuzung->gibSpur( NORD, i )->gibLaenge()*10;
   nordL->x -= 20;
  }
 }
 
 // Zwischenraum zeichen
 glBegin(GL_POLYGON);
  setMaterialColor3d( *farbe );
   
  if( westFlag )
  {
   glVertex3d( westO->x, westO->y, westO->z );
   glVertex3d( westU->x, westU->y, westU->z );
  }
  if( suedFlag )
  {
   glVertex3d( suedL->x, suedL->y, suedL->z );
   glVertex3d( suedR->x, suedR->y, suedR->z );
  }
  if( ostFlag )
  {
   glVertex3d( ostU->x, ostU->y, ostU->z );
   glVertex3d( ostO->x, ostO->y, ostO->z );
  }
  if( nordFlag )
  {
   glVertex3d( nordR->x, nordR->y, nordR->z );
   glVertex3d( nordL->x, nordL->y, nordL->z );
  }
 glEnd();
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++



//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void GLWireframe::zeichneSpurverbindung(Spur *vorgaenger, Spur *nachfolger)
{
 double breite = 20.0;
 double vLaenge = vorgaenger->gibLaenge()*10;
 int vAusrichtung = vorgaenger->gibAusrichtung();
 int nAusrichtung = nachfolger->gibAusrichtung();
 int vRichtung = vorgaenger->gibRichtung();
 int nRichtung = nachfolger->gibRichtung();
 Koordinaten *vCoord = new Koordinaten();
    *vCoord = vorgaenger->gibKoordinaten();
 Koordinaten *nCoord = new Koordinaten();
    *nCoord = nachfolger->gibKoordinaten();
 Koordinaten *farbe  = new Koordinaten();
     farbe->x = farbe->y = farbe->z = 76;
 
   
 if( vAusrichtung == HOR )
 {
  if( nAusrichtung == HOR  )
  {
   glBegin(GL_QUADS);
    setMaterialColor3d( *farbe );
   
    glVertex3d( (vCoord->x+(vLaenge*vRichtung)), (vCoord->y),      (vCoord->z) );
    glVertex3d( (nCoord->x),      (nCoord->y),      (nCoord->z) );
    glVertex3d( (nCoord->x),         (nCoord->y+(breite*nRichtung)), (nCoord->z) );
    glVertex3d( (vCoord->x+(vLaenge*vRichtung)), (vCoord->y+(breite*vRichtung)), (vCoord->z) );
   glEnd();
  }
  else
  {
   glBegin(GL_QUADS);
    setMaterialColor3d( *farbe );
   
    glVertex3d( (vCoord->x+(vLaenge*vRichtung)),  (vCoord->y),                    (vCoord->z) );
    glVertex3d( (nCoord->x+(breite*nRichtung)),   (nCoord->y),                    (nCoord->z) );
    glVertex3d( (nCoord->x),                      (nCoord->y),                    (nCoord->z) );
    glVertex3d( (vCoord->x+(vLaenge*vRichtung)),  (vCoord->y+(breite*vRichtung)), (vCoord->z) );
   glEnd();
  }
 }
 else
 {
  if( nAusrichtung == HOR  )
  {
   glBegin(GL_QUADS);
    setMaterialColor3d( *farbe );
   
    glVertex3d( (vCoord->x),                    (vCoord->y+(vLaenge*vRichtung)), (vCoord->z) );
    glVertex3d( (vCoord->x+(breite*vRichtung)), (vCoord->y+(vLaenge*vRichtung)), (vCoord->z) );
    glVertex3d( (nCoord->x),                    (nCoord->y),                     (nCoord->z) );
    glVertex3d( (nCoord->x),                    (nCoord->y+(breite*nRichtung)),  (nCoord->z) );
   glEnd();
  }
  else
  {
   glBegin(GL_QUADS);
    setMaterialColor3d( *farbe );
   
    glVertex3d( (vCoord->x),                    (vCoord->y+(vLaenge*vRichtung)), (vCoord->z) );
    glVertex3d( (nCoord->x),                    (nCoord->y),                     (nCoord->z) );
    glVertex3d( (nCoord->x+(breite*nRichtung)), (nCoord->y),         (nCoord->z) );
    glVertex3d( (vCoord->x+(breite*vRichtung)), (vCoord->y+(vLaenge*vRichtung)), (vCoord->z) );
   glEnd();
  }
 }
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++



//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void GLWireframe::zeichneFahrzeug(Fahrzeug *fahrzeug)
{
 double laenge,breite,hoehe;
 int    ausrichtung, richtung, bremsen, typ, weg;
 Koordinaten *rot = new Koordinaten();
     rot->x = 255.0;
     rot->y = rot->z = 10.0;
 Koordinaten *schwarz = new Koordinaten();
     schwarz->x = schwarz->y = schwarz->z = 10.0;
 
 laenge      = fahrzeug->gibLaenge()*10;
 bremsen     = fahrzeug->istBremsend();
 typ   = fahrzeug->gibTyp();
 ausrichtung = fahrzeug->gibSpur()->gibAusrichtung();
 richtung    = fahrzeug->gibSpur()->gibRichtung();
 weg   = fahrzeug->gibPosition()*10;
  
 Koordinaten *ursprung = &fahrzeug->gibSpur()->gibKoordinaten();
 Koordinaten *fahrzeugPosition = new Koordinaten();
  
 // Fahrzeug an den richtigen Platz schieben verschieben
 if( ausrichtung == HOR )
 {
  fahrzeugPosition->x = ursprung->x + ( richtung * weg );
  if( typ == BIKE )
   fahrzeugPosition->y = ursprung->y + ( richtung * 7.0 );
  else if( typ == PKW )
   fahrzeugPosition->y = ursprung->y + ( richtung * 4.0 );
  else
   fahrzeugPosition->y = ursprung->y + ( richtung * 2.0 );
  fahrzeugPosition->z = ursprung->z;
 }
 else
 {
  if( typ == BIKE )
   fahrzeugPosition->x = ursprung->x + ( richtung * 7.0 );
  else if( typ == PKW )
   fahrzeugPosition->x = ursprung->x + ( richtung * 4.0 );
  else
   fahrzeugPosition->x = ursprung->x + ( richtung * 2.0 );
  fahrzeugPosition->y = ursprung->y + ( richtung * weg );
  fahrzeugPosition->z = ursprung->z;
 }
 
 glTranslated( fahrzeugPosition->x, fahrzeugPosition->y, fahrzeugPosition->z);

 switch( typ )
 {   //----------------------------------------------------------------
  case PKW:
  {   hoehe = 10.0;
   breite = 13.0;
   
   if( ausrichtung == HOR )
   {
    // Bodenplatte
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d(             0.0, breite*richtung, 0.0 );
     glVertex3d( laenge*richtung, breite*richtung, 0.0 );
     glVertex3d( laenge*richtung,             0.0, 0.0 );
     glVertex3d(       0.0,             0.0, 0.0 );
    glEnd();
    
    // Kuehlergrill
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d(     laenge*richtung,             0.0, 0.0 );
     glVertex3d(     laenge*richtung, breite*richtung, 0.0 );
     glVertex3d( (laenge-1)*richtung, breite*richtung, 5.0 );
     glVertex3d( (laenge-1)*richtung,             0.0, 5.0 );
    glEnd();
    
    // Motorhaube
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d( (laenge-1)*richtung,             0.0, 5.0 );
     glVertex3d( (laenge-1)*richtung, breite*richtung, 5.0 );
     glVertex3d( (laenge-8)*richtung, breite*richtung, 6.0 );
     glVertex3d( (laenge-8)*richtung,             0.0, 6.0 );
    glEnd();
    
    // Frontscheibe
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d( (laenge-8 )*richtung,             0.0, 6.0 );
     glVertex3d( (laenge-8 )*richtung, breite*richtung, 6.0 );
     glVertex3d( (laenge-11)*richtung, breite*richtung, hoehe );
     glVertex3d( (laenge-11)*richtung,             0.0, hoehe );
    glEnd();
    
    
    // Dach
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d( (laenge-11)*richtung,             0.0, hoehe );
     glVertex3d( (laenge-11)*richtung, breite*richtung, hoehe );
     glVertex3d(         9.0*richtung, breite*richtung, hoehe );
     glVertex3d(   9.0*richtung,             0.0, hoehe );
    glEnd();
    
    // Heckscheibe
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d( 9.0*richtung,             0.0, hoehe );
     glVertex3d( 9.0*richtung, breite*richtung, hoehe );
     glVertex3d( 7.0*richtung, breite*richtung, hoehe-4 );
     glVertex3d( 7.0*richtung,             0.0, hoehe-4 );
    glEnd();
    
    // Kofferraum
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d( 7.0*richtung,             0.0, hoehe-4 );
     glVertex3d( 7.0*richtung, breite*richtung, hoehe-4 );
     glVertex3d( 2.0*richtung, breite*richtung, 5.0 );
     glVertex3d( 2.0*richtung,             0.0, 5.0 );
    glEnd();
    
    // Heck oben
    glBegin(GL_QUADS);
     if( bremsen )
      setMaterialColor3d( *rot );
     else
      setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d( 2.0*richtung,             0.0, 5.0 );
     glVertex3d( 2.0*richtung, breite*richtung, 5.0 );
     glVertex3d( 0.0,          breite*richtung, 0.0 );
     glVertex3d( 0.0,                      0.0, 0.0 );
    glEnd();
    
    // Seitenwand eins
    glBegin(GL_POLYGON);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d(                  0.0, 0.0, 0.0 );
     glVertex3d(      laenge*richtung, 0.0, 0.0 );
     glVertex3d( (laenge-1 )*richtung, 0.0, 5.0 );
     glVertex3d( (laenge-8 )*richtung, 0.0, 6.0 );
     glVertex3d( (laenge-11)*richtung, 0.0, hoehe );
     glVertex3d(         9.0*richtung, 0.0, hoehe );
     glVertex3d(   7.0*richtung, 0.0, hoehe-4 );
     glVertex3d(   2.0*richtung, 0.0, 5.0 );
    glEnd();
    
    // Seitenwand zwei
    glBegin(GL_POLYGON);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d(                  0.0, breite*richtung, 0.0 );
     glVertex3d(   2.0*richtung, breite*richtung, 5.0 );
     glVertex3d(   7.0*richtung, breite*richtung, hoehe-4 );
     glVertex3d(   9.0*richtung, breite*richtung, hoehe );
     glVertex3d( (laenge-11)*richtung, breite*richtung, hoehe );
     glVertex3d( (laenge-8 )*richtung, breite*richtung, 6.0 );
     glVertex3d( (laenge-1 )*richtung, breite*richtung, 5.0 );
     glVertex3d(      laenge*richtung, breite*richtung, 0.0 );
    glEnd();
   }
   else

   {
    // Bodenplatte
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d( breite*richtung,             0.0, 0.0 );
     glVertex3d(             0.0,             0.0, 0.0 );
     glVertex3d(             0.0, laenge*richtung, 0.0 );
     glVertex3d( breite*richtung, laenge*richtung, 0.0 );
    glEnd();
    
    // Kuehlergrill
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d(             0.0,     laenge*richtung, 0.0 );
     glVertex3d(             0.0, (laenge-1)*richtung, 5.0 );
     glVertex3d( breite*richtung, (laenge-1)*richtung, 5.0 );
     glVertex3d( breite*richtung,     laenge*richtung, 0.0 );
    glEnd();
    
    // Motorhaube
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d(             0.0, (laenge-1)*richtung, 5.0 );
     glVertex3d(             0.0, (laenge-8)*richtung, 6.0 );
     glVertex3d( breite*richtung, (laenge-8)*richtung, 6.0 );
     glVertex3d( breite*richtung, (laenge-1)*richtung, 5.0 );
    glEnd();
    
    // Frontscheibe
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d(             0.0, (laenge-8 )*richtung, 6.0 );
     glVertex3d(             0.0, (laenge-11)*richtung, hoehe );
     glVertex3d( breite*richtung, (laenge-11)*richtung, hoehe );
     glVertex3d( breite*richtung, (laenge-8 )*richtung, 6.0 );
    glEnd();
    
    
    // Dach
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d(             0.0, (laenge-11)*richtung, hoehe );
     glVertex3d(             0.0,         9.0*richtung, hoehe );
     glVertex3d( breite*richtung,   9.0*richtung, hoehe );
     glVertex3d( breite*richtung, (laenge-11)*richtung, hoehe );
    glEnd();
    
    // Heckscheibe
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d(             0.0, 9.0*richtung, hoehe );
     glVertex3d(             0.0, 7.0*richtung, hoehe-4 );
     glVertex3d( breite*richtung, 7.0*richtung, hoehe-4 );
     glVertex3d( breite*richtung, 9.0*richtung, hoehe );
    glEnd();
    
    // Kofferraum
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d(             0.0, 7.0*richtung, hoehe-4 );
     glVertex3d(             0.0, 2.0*richtung, 5.0 );
     glVertex3d( breite*richtung, 2.0*richtung, 5.0 );
     glVertex3d( breite*richtung, 7.0*richtung, hoehe-4 );
    glEnd();
    
    // Heck oben
    glBegin(GL_QUADS);
     if( bremsen )
      setMaterialColor3d( *rot );
     else
      setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d(             0.0, 2.0*richtung, 5.0 );
     glVertex3d(             0.0,          0.0, 0.0 );
     glVertex3d( breite*richtung,          0.0, 0.0 );
     glVertex3d( breite*richtung, 2.0*richtung, 5.0 );
    glEnd();
    
    // Seitenwand eins
    glBegin(GL_POLYGON);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d( 0.0,                  0.0, 0.0 );
     glVertex3d( 0.0,   2.0*richtung, 5.0 );
     glVertex3d( 0.0,   7.0*richtung, hoehe-4 );
     glVertex3d( 0.0,   9.0*richtung, hoehe );
     glVertex3d( 0.0, (laenge-11)*richtung, hoehe );
     glVertex3d( 0.0, (laenge-8 )*richtung, 6.0 );
     glVertex3d( 0.0, (laenge-1 )*richtung, 5.0 );
     glVertex3d( 0.0,      laenge*richtung, 0.0 );
    glEnd();
    
    // Seitenwand zwei
    glBegin(GL_POLYGON);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d( breite*richtung,                  0.0, 0.0 );
     glVertex3d( breite*richtung,      laenge*richtung, 0.0 );
     glVertex3d( breite*richtung, (laenge-1 )*richtung, 5.0 );
     glVertex3d( breite*richtung, (laenge-8 )*richtung, 6.0 );
     glVertex3d( breite*richtung, (laenge-11)*richtung, hoehe );
     glVertex3d( breite*richtung,   9.0*richtung, hoehe );
     glVertex3d( breite*richtung,   7.0*richtung, hoehe-4 );
     glVertex3d( breite*richtung,   2.0*richtung, 5.0 );
    glEnd();
   }
   
  } break;
  
  //----------------------------------------------------------------
  case LKW:
  {   hoehe = 20.0;
   breite = 15.0;
   
   if( ausrichtung == VER )
   {
    // Bodenplatte

    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
   
     glVertex3d(  breite*richtung,             0.0, 0.0 );
     glVertex3d(              0.0,             0.0, 0.0 );
     glVertex3d(              0.0, laenge*richtung, 0.0 );
     glVertex3d(  breite*richtung, laenge*richtung, 0.0 );
    glEnd();
   
    // Front unten
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
   
     glVertex3d(             0.0, laenge*richtung, 0.0 );
     glVertex3d(             0.0, laenge*richtung, hoehe-10 );
     glVertex3d( breite*richtung, laenge*richtung, hoehe-10 );
     glVertex3d( breite*richtung, laenge*richtung, 0.0 );
    glEnd();
   
    // Front oben
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
   
     glVertex3d(             0.0, (laenge-2)*richtung, hoehe-5 );
     glVertex3d( breite*richtung, (laenge-2)*richtung, hoehe-5 );
     glVertex3d( breite*richtung,     laenge*richtung, hoehe-10 );
     glVertex3d(             0.0,     laenge*richtung, hoehe-10 );
    glEnd();
   
    // Front Dach
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
   
     glVertex3d(             0.0, (laenge-2)*richtung, hoehe-5 );
     glVertex3d(             0.0, (laenge-7)*richtung, hoehe-5 );
     glVertex3d( breite*richtung, (laenge-7)*richtung, hoehe-5 );
     glVertex3d( breite*richtung, (laenge-2)*richtung, hoehe-5 );
    glEnd();
   
    // Dach Front
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
   
     glVertex3d(             0.0, (laenge-7)*richtung, hoehe-5 );
     glVertex3d(             0.0, (laenge-7)*richtung, hoehe );
     glVertex3d( breite*richtung, (laenge-7)*richtung, hoehe );
     glVertex3d( breite*richtung, (laenge-7)*richtung, hoehe-5 );
    glEnd();
   
    // Dach
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
   
     glVertex3d(             0.0, (laenge-7)*richtung, hoehe );
     glVertex3d(             0.0, 2.0*richtung,        hoehe );
     glVertex3d( breite*richtung, 2.0*richtung,        hoehe );
     glVertex3d( breite*richtung, (laenge-7)*richtung, hoehe );
    glEnd();
   
    // Heck oben (als Bremslicht)
    glBegin(GL_QUADS);
     if( bremsen )
      setMaterialColor3d( *rot);
     else
      setMaterialColor3d( fahrzeug->gibFarbe() );
   
     glVertex3d(             0.0, 2.0*richtung, hoehe );
     glVertex3d(             0.0,          0.0, hoehe-5 );
     glVertex3d( breite*richtung,          0.0, hoehe-5 );
     glVertex3d( breite*richtung, 2.0*richtung, hoehe );
    glEnd();
   
    // Heck unten
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
   
     glVertex3d(             0.0, 0.0, hoehe-5 );
     glVertex3d(             0.0, 0.0, 0.0 );
     glVertex3d( breite*richtung, 0.0, 0.0 );
     glVertex3d( breite*richtung, 0.0, hoehe-5 );
    glEnd();
   
    // Seitenwand eins
    glBegin(GL_POLYGON);
     setMaterialColor3d( fahrzeug->gibFarbe() );
   
     glVertex3d( breite*richtung,                 0.0, 0.0 );
     glVertex3d( breite*richtung,     laenge*richtung, 0.0 );
     glVertex3d( breite*richtung,     laenge*richtung, hoehe-10 );
     glVertex3d( breite*richtung, (laenge-2)*richtung, hoehe-5 );
     glVertex3d( breite*richtung, (laenge-7)*richtung, hoehe-5 );
     glVertex3d( breite*richtung, (laenge-7)*richtung, hoehe );
     glVertex3d( breite*richtung,  2.0*richtung, hoehe );
     glVertex3d( breite*richtung,                 0.0, hoehe-5 );
    glEnd();
   
    // Seitenwand zwei
    glBegin(GL_POLYGON);
     setMaterialColor3d( fahrzeug->gibFarbe() );
   
     glVertex3d( 0.0,                 0.0, 0.0 );
     glVertex3d( 0.0,                 0.0, hoehe-5 );
     glVertex3d( 0.0,  2.0*richtung, hoehe );
     glVertex3d( 0.0, (laenge-7)*richtung, hoehe );
     glVertex3d( 0.0, (laenge-7)*richtung, hoehe-5 );
     glVertex3d( 0.0, (laenge-2)*richtung, hoehe-5 );
     glVertex3d( 0.0,     laenge*richtung, hoehe-10 );
     glVertex3d( 0.0,     laenge*richtung, 0.0 );
    glEnd();
   }
   else
   {
    // Bodenplatte
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d(             0.0, breite*richtung, 0.0 );
     glVertex3d( laenge*richtung, breite*richtung, 0.0 );
     glVertex3d( laenge*richtung, 0.0,             0.0 );
     glVertex3d(             0.0, 0.0,             0.0 );
    glEnd();
    
    // Front unten
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d( laenge*richtung,             0.0, 0.0 );
     glVertex3d( laenge*richtung, breite*richtung, 0.0 );
     glVertex3d( laenge*richtung, breite*richtung, hoehe-10 );
     glVertex3d( laenge*richtung,             0.0, hoehe-10 );
    glEnd();
    
    // Front oben
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d( (laenge-2)*richtung,             0.0, hoehe-5 );
     glVertex3d(     laenge*richtung,             0.0, hoehe-10 );
     glVertex3d(     laenge*richtung, breite*richtung, hoehe-10 );
     glVertex3d( (laenge-2)*richtung, breite*richtung, hoehe-5 );
    glEnd();
    
    // Front Dach
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d( (laenge-2)*richtung,             0.0, hoehe-5 );
     glVertex3d( (laenge-2)*richtung, breite*richtung, hoehe-5 );
     glVertex3d( (laenge-7)*richtung, breite*richtung, hoehe-5 );
     glVertex3d( (laenge-7)*richtung,             0.0, hoehe-5 );
    glEnd();
    
    // Dach Front
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d( (laenge-7)*richtung,             0.0, hoehe-5 );
     glVertex3d( (laenge-7)*richtung, breite*richtung, hoehe-5 );
     glVertex3d( (laenge-7)*richtung, breite*richtung, hoehe );
     glVertex3d( (laenge-7)*richtung,             0.0, hoehe );
    glEnd();
    
    // Dach
    glBegin(GL_QUADS);
                                        setMaterialColor3d( fahrzeug->gibFarbe() );
                                
                                        glVertex3d( (laenge-7)*richtung,             0.0, hoehe );
                                        glVertex3d( (laenge-7)*richtung, breite*richtung, hoehe );
                                        glVertex3d( 2.0*richtung,        breite*richtung, hoehe );
                                        glVertex3d( 2.0*richtung,                    0.0, hoehe );
                                glEnd();
                                
                                // Heck oben (als Bremslicht)
                                glBegin(GL_QUADS);
                                        if( bremsen )
                                                setMaterialColor3d( *rot );
     else
      setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d( 2.0*richtung,             0.0, hoehe );
     glVertex3d( 2.0*richtung, breite*richtung, hoehe );
     glVertex3d( 0.0,          breite*richtung, hoehe-5 );
     glVertex3d( 0.0,                      0.0, hoehe-5 );
    glEnd();
    
    // Heck unten
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d( 0.0,             0.0, hoehe-5 );
     glVertex3d( 0.0, breite*richtung, hoehe-5 );
     glVertex3d( 0.0, breite*richtung, 0.0 );
     glVertex3d( 0.0,             0.0, 0.0 );
    glEnd();
    
    // Seitenwand eins
    glBegin(GL_POLYGON);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d(                 0.0, breite*richtung, 0.0 );
     glVertex3d(                 0.0, breite*richtung, hoehe-5 );
     glVertex3d(     2.0*richtung, breite*richtung, hoehe );
     glVertex3d( (laenge-7)*richtung, breite*richtung, hoehe );
     glVertex3d( (laenge-7)*richtung, breite*richtung, hoehe-5 );
     glVertex3d( (laenge-2)*richtung, breite*richtung, hoehe-5 );
     glVertex3d(     laenge*richtung, breite*richtung, hoehe-10 );
     glVertex3d(     laenge*richtung, breite*richtung, 0.0 );
    glEnd();
    
    // Seitenwand zwei
    glBegin(GL_POLYGON);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d(                 0.0, 0.0, 0.0 );
     glVertex3d(     laenge*richtung, 0.0, 0.0 );
     glVertex3d(     laenge*richtung, 0.0, hoehe-10 );
     glVertex3d( (laenge-2)*richtung, 0.0, hoehe-5 );
     glVertex3d( (laenge-7)*richtung, 0.0, hoehe-5 );
     glVertex3d( (laenge-7)*richtung, 0.0, hoehe );
     glVertex3d(     2.0*richtung, 0.0, hoehe );
     glVertex3d(                 0.0, 0.0, hoehe-5 );
    glEnd();
   }
  } break;
  
  //----------------------------------------------------------------
  case BUS:
  {   hoehe = 20.0;
   breite = 15.0;
   
   if( ausrichtung == HOR )
   {
    // Bodenplatte
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d(                 0.0, breite*richtung, 0.0 );
     glVertex3d( (laenge-2)*richtung, breite*richtung, 0.0 );
     glVertex3d( (laenge-2)*richtung,             0.0, 0.0 );
     glVertex3d(        0.0,             0.0, 0.0 );
    glEnd();
    
    // Front unten
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d( (laenge-2)*richtung,             0.0, 0.0 );
     glVertex3d( (laenge-2)*richtung, breite*richtung, 0.0 );
     glVertex3d(     laenge*richtung, breite*richtung, 5.0 );
     glVertex3d(     laenge*richtung,             0.0, 5.0 );
    glEnd();
    
    // Front oben
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d( (laenge-2)*richtung,             0.0, hoehe );
     glVertex3d(     laenge*richtung,             0.0, 5.0 );
     glVertex3d(     laenge*richtung, breite*richtung, 5.0 );
     glVertex3d( (laenge-2)*richtung, breite*richtung, hoehe );
    glEnd();
    
    // Dach
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d( (laenge-2)*richtung,             0.0, hoehe );
     glVertex3d( (laenge-2)*richtung, breite*richtung, hoehe );
     glVertex3d(     2.0*richtung, breite*richtung, hoehe );
     glVertex3d(        2.0*richtung,             0.0, hoehe );
    glEnd();
    
    // Heck oben (als Bremslicht)
    glBegin(GL_QUADS);
     if( bremsen )
      setMaterialColor3d( *rot );
     else
                                                setMaterialColor3d( fahrzeug->gibFarbe() );
                                
                                        glVertex3d( 2.0*richtung,             0.0, hoehe );
     glVertex3d( 2.0*richtung, breite*richtung, hoehe );
     glVertex3d( 0.0,          breite*richtung, hoehe-5 );
     glVertex3d( 0.0,                      0.0, hoehe-5 );
    glEnd();
    
    // Heck unten
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d( 0.0,             0.0, hoehe-5 );
     glVertex3d( 0.0, breite*richtung, hoehe-5 );
     glVertex3d( 0.0, breite*richtung, 0.0 );
     glVertex3d( 0.0,             0.0, 0.0 );
    glEnd();
    
    // Seitenwand eins
    glBegin(GL_POLYGON);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d(                 0.0, 0.0, 0.0 );
     glVertex3d( (laenge-2)*richtung, 0.0, 0.0 );
     glVertex3d(     laenge*richtung, 0.0, 5.0 );
     glVertex3d( (laenge-2)*richtung, 0.0, hoehe );
     glVertex3d(     2.0*richtung, 0.0, hoehe );
     glVertex3d(                 0.0, 0.0, hoehe-5 );
    glEnd();
    
    // Seitenwand zwei
    glBegin(GL_POLYGON);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d(                 0.0, breite*richtung, 0.0 );
     glVertex3d(                 0.0, breite*richtung, hoehe-5 );
     glVertex3d(     2.0*richtung, breite*richtung, hoehe );
     glVertex3d( (laenge-2)*richtung, breite*richtung, hoehe );
     glVertex3d(  laenge*richtung, breite*richtung, 5.0 );
     glVertex3d( (laenge-2)*richtung, breite*richtung, 0.0 );
    glEnd();
   }
   else
   {
    // Bodenplatte
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d(  breite*richtung,                 0.0, 0.0 );
     glVertex3d(              0.0,                 0.0, 0.0 );
     glVertex3d(              0.0, (laenge-2)*richtung, 0.0 );
     glVertex3d(  breite*richtung, (laenge-2)*richtung, 0.0 );
    glEnd();
    
    // Front unten
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d(             0.0, (laenge-2)*richtung, 0.0 );
     glVertex3d(             0.0,     laenge*richtung, 5.0 );
     glVertex3d( breite*richtung,     laenge*richtung, 5.0 );
     glVertex3d( breite*richtung, (laenge-2)*richtung, 0.0 );
    glEnd();
    
    // Front oben
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d(             0.0, (laenge-2)*richtung, hoehe );
     glVertex3d( breite*richtung, (laenge-2)*richtung, hoehe );
     glVertex3d( breite*richtung,     laenge*richtung, 5.0 );
     glVertex3d(             0.0,     laenge*richtung, 5.0 );
    glEnd();
    
    // Dach
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d(             0.0, (laenge-2)*richtung, hoehe );
     glVertex3d(             0.0, 2.0*richtung,        hoehe );
     glVertex3d( breite*richtung, 2.0*richtung,        hoehe );
     glVertex3d( breite*richtung, (laenge-2)*richtung, hoehe );
    glEnd();
    
    // Heck oben
    glBegin(GL_QUADS);
     if( bremsen )
      setMaterialColor3d( *rot );
     else
      setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d(             0.0, 2.0*richtung, hoehe );
     glVertex3d(             0.0, 0.0         , hoehe-5 );
     glVertex3d( breite*richtung, 0.0         , hoehe-5 );
     glVertex3d( breite*richtung, 2.0*richtung, hoehe );
    glEnd();
    
    // Heck unten (als Bremslicht)
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d(             0.0, 0.0, hoehe-5 );
     glVertex3d(             0.0, 0.0, 0.0 );
     glVertex3d( breite*richtung, 0.0, 0.0 );
     glVertex3d( breite*richtung, 0.0, hoehe-5 );
    glEnd();
    
    // Seitenwand eins
    glBegin(GL_POLYGON);
    setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d( 0.0,                 0.0, 0.0 );
     glVertex3d( 0.0,                 0.0, hoehe-5 );
     glVertex3d( 0.0,     2.0*richtung, hoehe );
     glVertex3d( 0.0, (laenge-2)*richtung, hoehe );
     glVertex3d( 0.0,     laenge*richtung, 5.0 );
     glVertex3d( 0.0, (laenge-2)*richtung, 0.0 );
    glEnd();
    
    // Seitenwand zwei
    glBegin(GL_POLYGON);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d( breite*richtung, (laenge-2)*richtung, 0.0 );
     glVertex3d( breite*richtung,     laenge*richtung, 5.0 );
     glVertex3d( breite*richtung, (laenge-2)*richtung, hoehe );
                                        glVertex3d( breite*richtung,            2.0*richtung, hoehe );
                                        glVertex3d( breite*richtung,                 0.0, hoehe-5 );
                                        glVertex3d( breite*richtung,                 0.0, 0.0 );
                                glEnd();
                        }
                } break;
                
                //----------------------------------------------------------------
                case BIKE:
                {   hoehe = 6;
                        breite = 4;

                        if( ausrichtung == HOR )
                        {
                                // Hinterrad hinten
                                glBegin(GL_QUADS);
                                        setMaterialColor3d( *schwarz );
                                
                                        glVertex3d(     0.0,             0.0, 0.0 );
                                        glVertex3d( 0.0,             0.0, 4.0 );
                                        glVertex3d( 0.0, breite*richtung, 4.0 );
                                        glVertex3d( 0.0, breite*richtung, 0.0 );
                                glEnd();
                                
                                // Hinterradboden
                                glBegin(GL_QUADS);
                                        setMaterialColor3d( *schwarz );
                                
                                        glVertex3d(          0.0, breite*richtung, 0.0 );
                                        glVertex3d( 5.0*richtung, breite*richtung, 0.0 );
                                        glVertex3d( 5.0*richtung,             0.0, 0.0 );
                                        glVertex3d(          0.0,             0.0, 0.0 );
                                glEnd();
                                
                                // Hinterrad vorne
                                glBegin(GL_QUADS);
                                        setMaterialColor3d( *schwarz );
                                
                                        glVertex3d(     5.0*richtung,             0.0, 0.0 );
                                        glVertex3d( 5.0*richtung, breite*richtung, 0.0 );
                                        glVertex3d( 5.0*richtung, breite*richtung, 2.0 );
                                        glVertex3d( 5.0*richtung,             0.0, 2.0 );
                                glEnd();
                                
                                // Mittelboden
                                glBegin(GL_QUADS);
                                        setMaterialColor3d( fahrzeug->gibFarbe() );
                                
                                        glVertex3d(        5.0*richtung, breite*richtung, 2.0 );
                                        glVertex3d( (laenge-5)*richtung, breite*richtung, 2.0 );
                                        glVertex3d( (laenge-5)*richtung,             0.0, 2.0 );
                                        glVertex3d(        5.0*richtung,             0.0, 2.0 );
                                glEnd();
                                
                                // Vorderrad hinten
                                glBegin(GL_QUADS);
                                        setMaterialColor3d( *schwarz );
                                
                                        glVertex3d(     (laenge-5)*richtung,             0.0, 0.0 );
                                        glVertex3d( (laenge-5)*richtung,             0.0, 2.0 );
                                        glVertex3d( (laenge-5)*richtung, breite*richtung, 2.0 );
                                        glVertex3d( (laenge-5)*richtung, breite*richtung, 0.0 );
                                glEnd();
                                
                                // Vorderradboden
                                glBegin(GL_QUADS);
                                        setMaterialColor3d( *schwarz );
                                
                                        glVertex3d( (laenge-5)*richtung, breite*richtung, 0.0 );
                                        glVertex3d(     laenge*richtung, breite*richtung, 0.0 );
                                        glVertex3d(     laenge*richtung,             0.0, 0.0 );
                                        glVertex3d( (laenge-5)*richtung,             0.0, 0.0 );
                                glEnd();
                                
                                // Vorderrad vorne
                                glBegin(GL_QUADS);
                                        setMaterialColor3d( *schwarz );
                                
                                        glVertex3d(     laenge*richtung,             0.0, 0.0 );
                                        glVertex3d( laenge*richtung, breite*richtung, 0.0 );
                                        glVertex3d( laenge*richtung, breite*richtung, 4.0 );
                                        glVertex3d( laenge*richtung,             0.0, 4.0 );
                                glEnd();
                                
                                // Front oben
                                glBegin(GL_QUADS);
                                        setMaterialColor3d( fahrzeug->gibFarbe() );
                                
                                        glVertex3d(         laenge*richtung,             0.0, 4.0 );
                                        glVertex3d(     laenge*richtung, breite*richtung, 4.0 );
                                        glVertex3d( (laenge-3)*richtung, breite*richtung, hoehe );
                                        glVertex3d( (laenge-3)*richtung,             0.0, hoehe );
                                glEnd();
                                
                                // Dach
                                glBegin(GL_QUADS);
                                        setMaterialColor3d( fahrzeug->gibFarbe() );
                                
                                        glVertex3d(     (laenge-3)*richtung,             0.0, hoehe );
                                        glVertex3d( (laenge-3)*richtung, breite*richtung, hoehe );
                                        glVertex3d(                5.0*richtung, breite*richtung, hoehe );
                                        glVertex3d(        5.0*richtung,             0.0, hoehe );
                                glEnd();
                                
                                // Heck oben (als Bremslicht)
                                glBegin(GL_QUADS);
                                        if( bremsen )
                                                setMaterialColor3d( *rot );
                                        else
                                                setMaterialColor3d( fahrzeug->gibFarbe() );
                                
                                        glVertex3d( 5.0*richtung,             0.0, hoehe );
                                        glVertex3d( 5.0*richtung, breite*richtung, hoehe );
                                        glVertex3d( 3.0*richtung, breite*richtung, 4.0 );
                                        glVertex3d( 3.0*richtung,             0.0, 4.0 );
                                glEnd();
                                
                                // Hinterrad oben
                                glBegin(GL_QUADS);
                                        setMaterialColor3d( *schwarz );
                                
                                        glVertex3d(              0.0,             0.0, 4.0 );
                                        glVertex3d( 3.0*richtung,             0.0, 4.0 );
                                        glVertex3d(     3.0*richtung, breite*richtung, 4.0 );
                                        glVertex3d(          0.0, breite*richtung, 4.0 );
                                glEnd();
                                
                                // Hinterradseitenwand eins
                                glBegin(GL_POLYGON);
                                        setMaterialColor3d( *schwarz );
                                
                                        glVertex3d(          0.0, 0.0, 0.0 );
                                        glVertex3d( 5.0*richtung, 0.0, 0.0 );
                                        glVertex3d( 5.0*richtung, 0.0, 2.0 );
                                        glVertex3d( 3.0*richtung, 0.0, 4.0 );
                                        glVertex3d(          0.0, 0.0, 4.0 );
                                glEnd();
                                
                                // Hinterradseitenwand zwei
                                glBegin(GL_POLYGON);
                                        setMaterialColor3d( *schwarz );
                                
                                        glVertex3d(          0.0, breite*richtung, 0.0 );
                                        glVertex3d(          0.0, breite*richtung, 4.0 );
                                        glVertex3d( 3.0*richtung, breite*richtung, 4.0 );
                                        glVertex3d( 5.0*richtung, breite*richtung, 2.0 );
                                        glVertex3d( 5.0*richtung, breite*richtung, 0.0 );
                                glEnd();
                                
                                // Vorderradseitenwand eins
                                glBegin(GL_QUADS);
                                        setMaterialColor3d( *schwarz );
                                
                                        glVertex3d( (laenge-5)*richtung, 0.0, 0.0 );
                                        glVertex3d(     laenge*richtung, 0.0, 0.0 );
                                        glVertex3d(     laenge*richtung, 0.0, 4.0 );
                                        glVertex3d( (laenge-5)*richtung, 0.0, 2.0 );
                                glEnd();
                                
                                // Vorderradseitenwand zwei
                                glBegin(GL_QUADS);
                                        setMaterialColor3d( *schwarz );
                                
                                        glVertex3d( (laenge-5)*richtung, breite*richtung, 0.0 );
                                        glVertex3d( (laenge-5)*richtung, breite*richtung, 2.0 );
                                        glVertex3d(     laenge*richtung, breite*richtung, 4.0 );
                                        glVertex3d(     laenge*richtung, breite*richtung, 0.0 );
                                glEnd();
                                
                                // Chassieseitenwand eins
                                glBegin(GL_POLYGON);
                                        setMaterialColor3d( fahrzeug->gibFarbe() );
                                
                                        glVertex3d(        3.0*richtung, 0.0, 4.0 );
                                        glVertex3d(        5.0*richtung, 0.0, 2.0 );
                                        glVertex3d( (laenge-5)*richtung, 0.0, 2.0 );
                                        glVertex3d(     laenge*richtung, 0.0, 4.0 );
                                        glVertex3d( (laenge-3)*richtung, 0.0, hoehe );
                                        glVertex3d(        5.0*richtung, 0.0, hoehe );
                                glEnd();
                                
                                // Chassieseitenwand zwei
                                glBegin(GL_POLYGON);
                                        setMaterialColor3d( fahrzeug->gibFarbe() );
                                
                                        glVertex3d(        3.0*richtung, breite*richtung, 4.0 );
                                        glVertex3d(        5.0*richtung, breite*richtung, hoehe );
                                        glVertex3d( (laenge-3)*richtung, breite*richtung, hoehe );
                                        glVertex3d(     laenge*richtung, breite*richtung, 4.0 );
                                        glVertex3d( (laenge-5)*richtung, breite*richtung, 2.0 );
                                        glVertex3d(        5.0*richtung, breite*richtung, 2.0 );
                                glEnd();
                        }
                        else

                        {
                                // Hinterrad hinten
                                glBegin(GL_QUADS);
                                        setMaterialColor3d( *schwarz );
                                
                                        glVertex3d(                 0.0, 0.0, 0.0 );
                                        glVertex3d( breite*richtung, 0.0, 0.0 );
                                        glVertex3d( breite*richtung, 0.0, 4.0 );
                                        glVertex3d(             0.0, 0.0, 4.0 );
                                glEnd();
                                
                                // Hinterradboden
                                glBegin(GL_QUADS);
                                        setMaterialColor3d( *schwarz );
                                
                                        glVertex3d( breite*richtung,          0.0, 0.0 );
                                        glVertex3d(             0.0,          0.0, 0.0 );
                                        glVertex3d(             0.0, 5.0*richtung, 0.0 );
                                        glVertex3d( breite*richtung, 5.0*richtung, 0.0 );
                                glEnd();
                                
                                // Hinterrad vorne
                                glBegin(GL_QUADS);
                                        setMaterialColor3d( *schwarz );
                                
                                        glVertex3d(                 0.0, 5.0*richtung, 0.0 );
                                        glVertex3d(             0.0, 5.0*richtung, 2.0 );
                                        glVertex3d( breite*richtung, 5.0*richtung, 2.0 );
                                        glVertex3d( breite*richtung, 5.0*richtung, 0.0 );
                                glEnd();
                                
                                // Mittelboden
                                glBegin(GL_QUADS);
                                        setMaterialColor3d( fahrzeug->gibFarbe() );
                                
                                        glVertex3d( breite*richtung,        5.0*richtung, 2.0 );
                                        glVertex3d(             0.0,        5.0*richtung, 2.0 );
                                        glVertex3d(             0.0, (laenge-5)*richtung, 2.0 );
                                        glVertex3d( breite*richtung, (laenge-5)*richtung, 2.0 );
                                glEnd();
    
    // Vorderrad hinten
    glBegin(GL_QUADS);
     setMaterialColor3d( *schwarz );
    
     glVertex3d(             0.0, (laenge-5)*richtung, 0.0 );
     glVertex3d( breite*richtung, (laenge-5)*richtung, 0.0 );
     glVertex3d( breite*richtung, (laenge-5)*richtung, 2.0 );
     glVertex3d(             0.0, (laenge-5)*richtung, 2.0 );
    glEnd();
    
    // Vorderradboden
    glBegin(GL_QUADS);
     setMaterialColor3d( *schwarz );
    
     glVertex3d( breite*richtung, (laenge-5)*richtung, 0.0 );
     glVertex3d(             0.0, (laenge-5)*richtung, 0.0 );
     glVertex3d(             0.0,     laenge*richtung, 0.0 );
     glVertex3d( breite*richtung,     laenge*richtung, 0.0 );
    glEnd();
    
    // Vorderrad vorne
    glBegin(GL_QUADS);
     setMaterialColor3d( *schwarz );
    
     glVertex3d(             0.0, laenge*richtung, 0.0 );
     glVertex3d(             0.0, laenge*richtung, 4.0 );
     glVertex3d( breite*richtung, laenge*richtung, 4.0 );
     glVertex3d( breite*richtung, laenge*richtung, 0.0 );
    glEnd();
    
    // Front oben
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d(             0.0,     laenge*richtung, 4.0 );
     glVertex3d(             0.0, (laenge-3)*richtung, hoehe );
     glVertex3d( breite*richtung, (laenge-3)*richtung, hoehe );
     glVertex3d( breite*richtung,     laenge*richtung, 4.0 );
    glEnd();
    
    // Dach
    glBegin(GL_QUADS);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d(             0.0, (laenge-3)*richtung, hoehe );
     glVertex3d(             0.0,        5.0*richtung, hoehe );
     glVertex3d( breite*richtung,        5.0*richtung, hoehe );
     glVertex3d( breite*richtung, (laenge-3)*richtung, hoehe );
    glEnd();
    
    // Heck oben (als Bremslicht)
    glBegin(GL_QUADS);
     if( bremsen )
      setMaterialColor3d( *rot );
     else
      setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d(             0.0, 5.0*richtung, hoehe );
     glVertex3d(             0.0, 3.0*richtung, 4.0 );
     glVertex3d( breite*richtung, 3.0*richtung, 4.0 );
     glVertex3d( breite*richtung, 5.0*richtung, hoehe );
    glEnd();
    
    // Hinterrad oben
    glBegin(GL_QUADS);
     setMaterialColor3d( *schwarz );
                                
                                        glVertex3d(                 0.0,          0.0, 4.0 );
                                        glVertex3d( breite*richtung,          0.0, 4.0 );
     glVertex3d( breite*richtung, 3.0*richtung, 4.0 );
     glVertex3d(             0.0, 3.0*richtung, 4.0 );
    glEnd();
    
    // Hinterradseitenwand eins
    glBegin(GL_POLYGON);
     setMaterialColor3d( *schwarz );
    
     glVertex3d( 0.0,          0.0, 0.0 );
     glVertex3d( 0.0,          0.0, 4.0 );
     glVertex3d( 0.0, 3.0*richtung, 4.0 );
     glVertex3d( 0.0, 5.0*richtung, 2.0 );
     glVertex3d( 0.0, 5.0*richtung, 0.0 );
    glEnd();
    
    // Hinterradseitenwand zwei
    glBegin(GL_POLYGON);
     setMaterialColor3d( *schwarz );
    
     glVertex3d( breite*richtung,          0.0, 0.0 );
     glVertex3d( breite*richtung, 5.0*richtung, 0.0 );
     glVertex3d( breite*richtung, 5.0*richtung, 2.0 );
     glVertex3d( breite*richtung, 3.0*richtung, 4.0 );
     glVertex3d( breite*richtung,          0.0, 4.0 );
    glEnd();
    
    // Vorderradseitenwand eins
    glBegin(GL_QUADS);
     setMaterialColor3d( *schwarz );
    
     glVertex3d( 0.0, (laenge-5)*richtung, 0.0 );
     glVertex3d( 0.0, (laenge-5)*richtung, 2.0 );
     glVertex3d( 0.0,     laenge*richtung, 4.0 );
     glVertex3d( 0.0,     laenge*richtung, 0.0 );
    glEnd();
    
    // Vorderradseitenwand zwei
    glBegin(GL_QUADS);
     setMaterialColor3d( *schwarz );
    
     glVertex3d( breite*richtung, (laenge-5)*richtung, 0.0 );
     glVertex3d( breite*richtung,     laenge*richtung, 0.0 );
     glVertex3d( breite*richtung,     laenge*richtung, 4.0 );
     glVertex3d( breite*richtung, (laenge-5)*richtung, 2.0 );
    glEnd();
    
    // Chassieseitenwand eins
    glBegin(GL_POLYGON);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d( 0.0,        3.0*richtung, 4.0 );
     glVertex3d( 0.0,        5.0*richtung, hoehe );
     glVertex3d( 0.0, (laenge-3)*richtung, hoehe );
     glVertex3d( 0.0,     laenge*richtung, 4.0 );
     glVertex3d( 0.0, (laenge-5)*richtung, 2.0 );
     glVertex3d( 0.0,        5.0*richtung, 2.0 );
    glEnd();
    
    // Chassieseitenwand zwei
    glBegin(GL_POLYGON);
     setMaterialColor3d( fahrzeug->gibFarbe() );
    
     glVertex3d( breite*richtung,        3.0*richtung, 4.0 );
     glVertex3d( breite*richtung,        5.0*richtung, 2.0 );
     glVertex3d( breite*richtung, (laenge-5)*richtung, 2.0 );
     glVertex3d( breite*richtung,     laenge*richtung, 4.0 );
     glVertex3d( breite*richtung, (laenge-3)*richtung, hoehe );
     glVertex3d( breite*richtung,        5.0*richtung, hoehe );
    glEnd();
   }
  } break;
 }   

 // Koordinatensystem zurueckschieben
 glTranslated( -1*fahrzeugPosition->x, -1*fahrzeugPosition->y, -1*fahrzeugPosition->z);
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++



//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void GLWireframe::setMaterialColor3d(Koordinaten farbe)
{
 glColor3d( farbe.x/255, farbe.y/255, farbe.z/255 );

 /*GLfloat matColor[]  = {1,1,1,0};
 GLfloat specColor[] = {1,1,1,0};
 GLfloat noColor[]   = {0,0,0,0};
 GLfloat shine[]     = {5.0};
 
 matColor[0] = farbe.x/255;
 matColor[1] = farbe.y/255;
 matColor[2] = farbe.z/255;
 
 glMaterialfv( GL_FRONT, GL_AMBIENT, matColor );
 glMaterialfv( GL_FRONT, GL_DIFFUSE, matColor );
 glMaterialfv( GL_FRONT, GL_SPECULAR, specColor );
 glMaterialfv( GL_FRONT, GL_SHININESS, shine );
 glMaterialfv( GL_FRONT, GL_EMISSION, noColor );*/
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++



//------------------------------------------------------------------------------------------------------------------
void GLWireframe::setzeFahrzeugliste( Liste *fahrzeugliste )
{
 fahrzeugliste_ = fahrzeugliste;
}
//------------------------------------------------------------------------------------------------------------------


//------------------------------------------------------------------------------------------------------------------
void GLWireframe::setzeKreuzungsliste( Liste *kreuzungsliste )
{
 kreuzungsliste_ = kreuzungsliste;
}
//------------------------------------------------------------------------------------------------------------------


//------------------------------------------------------------------------------------------------------------------
void GLWireframe::setzeSpurenliste( Spur **spurenliste, long int anzahlSpuren )
{
 spurenliste_ = spurenliste;
 anzahlSpuren_ = anzahlSpuren;
}
//------------------------------------------------------------------------------------------------------------------

---