Warning: session_start(): open(/var/lib/php/sessions/sess_a147ca9cd5ae7488f04faff4f715ef0c, O_RDWR) failed: No such file or directory (2) in /var/www/web1319/html/cwx/phpwebed/config.inc.php on line 1

Warning: session_start(): Cannot send session cache limiter - headers already sent (output started at /var/www/web1319/html/cwx/phpwebed/config.inc.php:1) in /var/www/web1319/html/cwx/phpwebed/config.inc.php on line 1
codeworx.org - OpenGL Tutorial 31: Milkshape 3D Modelle laden

www.codeworx.org/opengl-tutorials/Tutorial 31: Milkshape 3D Modelle laden

Lektion 31: Milkshape 3D Modelle laden

Autor: Brett Porter (brettporter@yahoo.com)

Der Quellcode dieser Lektion stammt aus PortaLib3D, das dem Benutzer z.B. ermöglicht Objekte schnell und einfach zu laden und darzustellen. Aber warum sollte man eine Grafikbibliothek benutzen, wenn man den Code dahinter nicht auch selber verstehen und schreiben kann? Dieses Tutorial wird dabei helfen.

Die aus PortaLib3D entnommenen Teile stehen unter meinem Copyright, dürfen aber natürlich von jedem genutzt werden, solange die Copyright-Hinweise bestehen bleiben und ich in den Credits genannt werde. Sollte das Tutorial verstanden worden sein und jemand den Code neu implementiert (per cut-and-paste lernt man sowieso nichts!), dann kann man sich den Copyright Hinweis natürlich freiwillig setzen.

Der OpenGL Basiscode

befindet sich in Lesson31.cpp. Das meiste davon stammt noch aus Lektion 6, mit einigen kleineren Änderungen beim Texturladen und an der Ausgabefunktion. Die Änderungen werden später besprochen.

Milkshape 3D

Das genutzte 3D-Modell wurde mit Milkshape 3D erstellt, da das Dateifomat sehr einfach zu parsen und verstehen ist. Als nächstes plane ich ein ähnliches Programm zum Einlesen von Anim8or und 3DS-Dateien.

Natürlich ist das Dateiformat eher nebensächlich und wird hier nur kurz beschrieben. Die Daten müssen vorallem in die passenden Strukturen ( z.B. struct Vertex ) geladen werden, also wird auch mit diesen begonnen:

Datenstrukturen des 3D-Modells

Als erstes werden normale Punkte im 3-dimensionalen Raum benötigt, zu finden in der Klasse Model in Model.h:

// Vertex Structure
struct Vertex
{
   char m_boneID;// For Skeletal Animation
   float m_location[3];
};

// Vertices Used
int m_numVertices;
Vertex *m_pVertices;

m_boneID kann in diesem Tutorial noch ignoriert werden, es könnte aber eine weitere Lektion zum Thema geben. m_location repräsentiert die 3 Koordinaten (X, Y und Z). Die beiden Variablen speichern die Anzahl der Punkte und die Punkte selber in einem dynamischen Array, dessen Speicherplatz später alloziiert wird.

Die Punkte werden in Dreiecken angeordnet:

// Triangle Structure
struct Triangle
{
   float m_vertexNormals[3][3];
   float m_s[3], m_t[3];
   int m_vertexIndices[3];
};

// Triangles Used
int m_numTriangles;
Triangle *m_pTriangles;

3 Punkte die ein Dreieck bilden sind in m_vertexIndices gespeichert. Es handelt sich hierbei um Adressen in dem Punktarray m_pVertices. So muss jeder Punkt nur einmal gespeichert werden, was Speicher und Berechnungen bei späteren Bewegungen spart. (Bei "geschlossenen" Oberflächen ist es ja sehr wahrscheinlich das sich zwei nebeneinander liegende Dreiecke einen Punkt teilen, der dann nur einmal gespeichert wird, daher diese zwar umständliche aber sparende Methode.) m_s und m_t sind die Texturkoordinaten (S und T) für jeden der 3 Punkte. Die dafür genutzte Textur gehört zu einem bestimmten mesh (dazu gleich). m_vertexNormals speichert die drei Koordinaten des Normalenvektors für jeden der drei Punkte.

Ein mesh ist eine bestimmte Anzahl von Dreiecken, die sich das gleiche Material, also eine bestimmte Textur (mit Beleuchtung) teilen. Mehrere meshs bilden das fertige Modell.

// Mesh
struct Mesh
{
   int m_materialIndex;
   int m_numTriangles;
   int *m_pTriangleIndices;
};

// Meshes Used
int m_numMeshes;
Mesh *m_pMeshes;

Die zu einem mesh zugehörigen Dreiecke werden in m_pTriangleIndices gespeicht, genauso wie weiter oben die Punkte der einzelnen Dreiecke. Da die Anzahl der Dreiecke im mesh (m_numTriangles) erst beim eigentlichen Laden bekannt ist, wird auch hier wieder Speicher dynamisch alloziiert. m_materialIndex spezifiziert das verwendete Material:

// Material Properties
struct Material
{
   float m_ambient[4], m_diffuse[4], m_specular[4], m_emissive[4];
   float m_shininess;
   GLuint m_texture;
   char *m_pTextureFilename;
};

// Materials Used
int m_numMaterials;
Material *m_pMaterials;

Die für OpenGL typischen Beleuchtungswerte (ambient, diffuse, specular, emissive und shininess) gehören zu einem Material, genauso wie die Textur (m_texture) und deren Dateiname (auch dynamisch), damit diese bei Bedarf geladen werden kann.

Das 3D-Modell wird geladen

Der virtuellen Funktion loadModelData wird der Dateiname des zu ladenen Modells übergeben. Die von "Model" abgeleitete Klasse "MilkshapeModel" (MilkshapeModel.h) enthält diese Funktion.

bool MilkshapeModel::loadModelData( const char *filename )
{
   ifstream inputFile( filename, ios::in | ios::binary | ios::nocreate );
   if ( inputFile.fail())
      return false;                  // "Couldn't Open The Model File."

Zuerst wird die Milkshape-Datei geöffnet, die im Binärfomat (ios::binar) vorliegt. Sollte diese nicht gefunden werden, bricht die Funktion ab und es wird false zurückgegeben.

   inputFile.seekg( 0, ios::end );
   long fileSize = inputFile.tellg();
   inputFile.seekg( 0, ios::beg );

Die Größe der Datei in Byte wird ermittelt.

   byte *pBuffer = new byte[fileSize];
   inputFile.read( pBuffer, fileSize );
   inputFile.close();

Die Datei wird komplett in einen Puffer geladen.

   const byte *pPtr = pBuffer;
   MS3DHeader *pHeader = ( MS3DHeader* )pPtr;
   pPtr += sizeof( MS3DHeader );
   if ( strncmp( pHeader->m_ID, "MS3D000000", 10 ) != 0 )
      return false;// "Not A Valid Milkshape3D Model File."

   if ( pHeader->m_version < 3 || pHeader->m_version > 4 )
      return false;// "Unhandled File Version. Only Milkshape3D Version 1.3 And    1.4 Is Supported."

pPtr ist ein Pointer der auf die aktuelle Position in der Datei zeigt. Ein Pointer auf den Dateiheader wird gespeichert und pPtr hinter den Header gesetzt um die eigentlichen Daten einzulesen. Es werden mehrmals Strukturen mit MS3D am Anfang genutzt, diese werden in MilkshapeModel.cpp deklariert und stammen direkt aus der Spezifikation für Milkshape-Dateien. Die ausgelesenen Header-Daten werden dann darauf überprüft, ob das Format und die Version stimmt.

   int nVertices = *( word* )pPtr;
   m_numVertices = nVertices;
   m_pVertices = new Vertex[nVertices];
   pPtr += sizeof( word );
   int i;
   for ( i = 0; i < nVertices; i++ )
   {
      MS3DVertex *pVertex = ( MS3DVertex* )pPtr;
      m_pVertices[i].m_boneID = pVertex->m_boneID;
      memcpy( m_pVertices[i].m_location, pVertex->m_vertex, sizeof( float )*3 );
      pPtr += sizeof( MS3DVertex );
   }

Der obere Code liest die gespeicherten Punkte ein, für die mit "new" Speicher alloziiert wird. Mithilfe von pPtr werden diese Schritt für Schritt eingelesen und mit memcpy in das Array m_pVertices kopiert. m_boneID kann ignoriert werden und wird nur bei skelettbasierenden Animationen wichtig.

   int nTriangles = *( word* )pPtr;
   m_numTriangles = nTriangles;
   m_pTriangles = new Triangle[nTriangles];
   pPtr += sizeof( word );
   for ( i = 0; i < nTriangles; i++ )
   {
      MS3DTriangle *pTriangle = ( MS3DTriangle* )pPtr;
      int vertexIndices[3] = { pTriangle->m_vertexIndices[0], pTriangle->m_vertexIndices[1],    pTriangle->m_vertexIndices[2] };
      float t[3] = { 1.0f-pTriangle->m_t[0], 1.0f-pTriangle->m_t[1], 1.0f-pTriangle->m_t[2]    };
      memcpy( m_pTriangles[i].m_vertexNormals, pTriangle->m_vertexNormals, sizeof(    float )*3*3 );
      memcpy( m_pTriangles[i].m_s, pTriangle->m_s, sizeof( float )*3 );
      memcpy( m_pTriangles[i].m_t, t, sizeof( float )*3 );
      memcpy( m_pTriangles[i].m_vertexIndices, vertexIndices, sizeof( int )*3 );
      pPtr += sizeof( MS3DTriangle );
   }

Ähnlich wie bei den Punkten liest dieser Teil der Funktion die Dreiecke aus. Die meisten Werte werden 1 zu 1 übernommen, die Punktindizes werden vom Typ word zu int konvertiert, um später ohne Konvertierungen darauf zugreifen zu können. Die m_t-Werte werden in die Form 1.0-Originalwert umgewandelt, da OpenGL ein anderes Koordinatensystem als Milkshape nutzt (Der Koordinatenursprung liegt bei OpenGL links unten und bei Milkshape links oben, die Y-Koordinate muss also umgedreht werden.)

   int nGroups = *( word* )pPtr;
   m_numMeshes = nGroups;
   m_pMeshes = new Mesh[nGroups];
   pPtr += sizeof( word );

   for ( i = 0; i < nGroups; i++ )
   {
      pPtr += sizeof( byte );// Flags
      pPtr += 32;// Name
      word nTriangles = *( word* )pPtr;
      pPtr += sizeof( word );
      int *pTriangleIndices = new int[nTriangles];
      for ( int j = 0; j < nTriangles; j++ )
      {
         pTriangleIndices[j] = *( word* )pPtr;
         pPtr += sizeof( word );
      }

      char materialIndex = *( char* )pPtr;
      pPtr += sizeof( char );
      m_pMeshes[i].m_materialIndex = materialIndex;
      m_pMeshes[i].m_numTriangles = nTriangles;
      m_pMeshes[i].m_pTriangleIndices = pTriangleIndices;
   }

Der obere Code speichert die mesh-Strukturen, die in Mikshape als "groups" bezeichnet werden. Da die Anzahl der Dreiecke variiert, kann hier von keiner festen Größe ausgegangen werden, es muss also Stück für Stück einzeln gelesen werden. Der Speicher für die Indices der Dreiecke wird wieder mit new reserviert.

   int nMaterials = *( word* )pPtr;
   m_numMaterials = nMaterials;
   m_pMaterials = new Material[nMaterials];
   pPtr += sizeof( word );

   for ( i = 0; i < nMaterials; i++ )
   {
      MS3DMaterial *pMaterial = ( MS3DMaterial* )pPtr;
      memcpy( m_pMaterials[i].m_ambient, pMaterial->m_ambient, sizeof( float )*4    );
      memcpy( m_pMaterials[i].m_diffuse, pMaterial->m_diffuse, sizeof( float )*4    );
      memcpy( m_pMaterials[i].m_specular, pMaterial->m_specular, sizeof( float    )*4 );
      memcpy( m_pMaterials[i].m_emissive, pMaterial->m_emissive, sizeof( float    )*4 );
      m_pMaterials[i].m_shininess = pMaterial->m_shininess;
      m_pMaterials[i].m_pTextureFilename = new char[strlen( pMaterial->m_texture    )+1];
      strcpy( m_pMaterials[i].m_pTextureFilename, pMaterial->m_texture );
      pPtr += sizeof( MS3DMaterial );
   }

   reloadTextures();

Zuletzt werden die Materialinformationen aus dem Puffer gelesen. Dies passiert prinzipiell wie oben. Die benötigten Texturen werden geladen und an die üblichen OpenGL Texturobjekte gebunden. Diese Funktion wird aber gleich beschrieben.

   delete[] pBuffer;
   return true;
}


Das letzte Stück löscht den angelegten Puffer und liefert true zurück wenn alles geklappt hat.

Jetzt sind die Datenstrukturen des 3D-Modells gefüllt und fast fertig zum rendern, der untere Code liest die Texturen für jedes verwendete Material ein:

void Model::reloadTextures()
{
   for ( int i = 0; i < m_numMaterials; i++ )
      if ( strlen( m_pMaterials[i].m_pTextureFilename ) > 0 )
         m_pMaterials[i].m_texture = LoadGLTexture( m_pMaterials[i].m_pTextureFilename );

      else
         m_pMaterials[i].m_texture = 0;
 }

Die Texturdateien werden mit dem üblichen und leicht veränderten Nehe-Code eingelesen, sollte der String des Dateinames leer sein, wird der Texturbezeichner auf 0 gesetzt.

Die Ausgabe

Das 3D-Modell wird ausgegeben, was allerdings weniger tragisch sein sollte, da alle Datenstrukturen einfach zu behandeln sind.

void Model::draw()
{
   GLboolean texEnabled = glIsEnabled( GL_TEXTURE_2D );

Hier wird der momentane Status des Texture Mappings gespeichert (true oder false), um diesen zum Schluss wieder herstellen zu können.

Die meshs werden eins nach dem anderen durchgegangen und ausgegeben:

   // Draw By Group
   for ( int i = 0; i < m_numMeshes; i++ )
   {

m_pMeshes[i] ist das aktuell auszugebene mesh, dessen Materialeigenschaften an OpenGL übermittelt werden. Sollte der Materialindex -1 sein, ist kein Material für dieses mesh vorhanden und es wird mit dem gerade aktuellen OpenGL Status ausgegeben

   int materialIndex = m_pMeshes[i].m_materialIndex;

   if ( materialIndex >= 0 )
   {
      glMaterialfv( GL_FRONT, GL_AMBIENT, m_pMaterials[materialIndex].m_ambient );
      glMaterialfv( GL_FRONT, GL_DIFFUSE, m_pMaterials[materialIndex].m_diffuse );
      glMaterialfv( GL_FRONT, GL_SPECULAR, m_pMaterials[materialIndex].m_specular    );
      glMaterialfv( GL_FRONT, GL_EMISSION, m_pMaterials[materialIndex].m_emissive    );
      glMaterialf( GL_FRONT, GL_SHININESS, m_pMaterials[materialIndex].m_shininess    );

      if ( m_pMaterials[materialIndex].m_texture > 0 )
      {
         glBindTexture( GL_TEXTURE_2D, m_pMaterials[materialIndex].m_texture );
         glEnable( GL_TEXTURE_2D );
      }

      else
         glDisable( GL_TEXTURE_2D );
   }

   else
   {
      glDisable( GL_TEXTURE_2D );
   }

Auch die zu dem mesh gehörende Textur wird am Ende des oberern Codes eingebunden, allerdings nur wenn der Texturbezeichner größer als 0 ist. Andernfalls wird keine Textur gebunden und das Texture Mapping abgeschaltet.

   glBegin( GL_TRIANGLES );
   {
      for ( int j = 0; j < m_pMeshes[i].m_numTriangles; j++ )
      {
         int triangleIndex = m_pMeshes[i].m_pTriangleIndices[j];
         const Triangle* pTri = &m_pTriangles[triangleIndex];

         for ( int k = 0; k < 3; k++ )
         {
            int index = pTri->m_vertexIndices[k];
            glNormal3fv( pTri->m_vertexNormals[k] );
            glTexCoord2f( pTri->m_s[k], pTri->m_t[k] );
            glVertex3fv( m_pVertices[index].m_location );
         }
      }
   }

   glEnd();
   }

Der vorherige Code rendert die Dreiecke des Modells. Die drei Punkte des Dreiecks (m_pVertices[index].m_location) werden durch die innere for-schleife mit ihrer Normalen (m_vertexNormals[k]) und den Textur Koordinaten (m_s[k], m_t[k]) übergeben. pTri ist ein Pointer auf das aktuelle Dreieck, um den Zugriff zu erleichtern und den Code zu vereinfachen. Die Punkte des Dreiecks an sich wurden ja nur als Indices ( TriangleIndices ) im aktuellen Mesh gespeichert und stehen im Punkt-Array des models.

   if ( texEnabled )
      glEnable( GL_TEXTURE_2D );

   else
      glDisable( GL_TEXTURE_2D );
}

Jetzt wird nur noch der Status des Texture Mappings auf den Ausgangswert zurückgesetzt.

Interessant könnten noch der constructor und destructor der Klasse sein, diese erklären sich aber im Prinzip von selber. Der constructor setzt alle seine Member Variablen auf 0, oder NULL bei Pointern, der destructor gibt den dynamisch reservierten Speicher wieder frei. loadModelData sollte pro Objekt auch nur genau einmal aufgerufen werden, sonst kommt es zu Fehlern.

Alle nötigen Veränderungen im Basiscode sollen noch kurz erläutert werden um die erstellte Klasse zu nutzen.

Model *pModel = NULL;    // Holds The Model Data

Am Anfang von Lesson31.cpp wird das genutzte model deklariert, aber erst in WinMain initialisiert.

pModel = new MilkshapeModel();

if ( pModel->loadModelData( "data/model.ms3d" ) == false )
{
   MessageBox( NULL, "Couldn't load the model data/model.ms3d", "Error", MB_OK | MB_ICONERROR );
   return 0;// If Model Didn't Load, Quit
}

Das model sollte besser hier und nicht in InitGL initiallisiert werden, da InitGL mehrmals aufgerufen werden könnte. In InitGL müssen bei Veränderungen am Ausgabemodus die Texturen neu geladen werden, was der nächste Codeschnipsel ebewirkt:

pModel->reloadTextures();

Ganz zum Schluß noch die veränderte DrawGLScene Funktion:

int DrawGLScene(GLvoid)// Here's Where We Do All The Drawing
{
   // Clear The Screen And The Depth Buffer
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   glLoadIdentity();               // Reset The View
   gluLookAt( 75, 75, 75, 0, 0, 0, 0, 1, 0 );
   glRotatef(yrot,0.0f,1.0f,0.0f);
   pModel->draw();
   yrot+=1.0f;
   return TRUE;                    // Keep Going
}

Der color und depht buffer wird geleert und mit gluLookAt wird die Blickrichtung eingestellt. Der Betrachter befindet sich jetzt am Punkt (75, 75, 75) blickt auf den Punkt (0, 0, 0), der letzte Vektor (0, 1, 0) legt fest wo "oben" ist.

Um das Ganze etwas interessanter zu machen, rotiert die Szene ständig mittels glRotatef(...) um die Y-Achse.

Von hier aus wird auch die Ausgabefunktion des Modells aufgerufen, soll das Objekt also verschoben oder in weitere Richtungen gedreht werden, müssen die entsprechenden Funktionen vorher aufegerufen werden.

Das wärs, also ran an Milkshape ;-)

Ein zukünftiges Tutorial

für die Nehe-Reihe wird die Modell-Klasse erweitern um auch skeletal animation nutzen zu können. Der Schritt dorthin ist nicht allzu kompliziert, allerdings kommt mehr Mathe ins Spiel. Außerdem könnten einige Ladefunktionen für weitere Dateiformate folgen.

Bis dann.

Einige Informationen zu Brett Porter. Besagter wurde in Australien geboren und hat an der University of Wollongong studiert. Er hat mit 12 auf einem C64 Klon (VZ300) angefangen BASIC zu programmieren, ist aber sehr schnell zu Pacsal, Assembler, C++ und Java gekommen. Zur Zeit beschäftigt er sich vorallem mit OpenGL. Mehr unter http://rsn.gamedev.net .

Ergänzung: Die Fortsetzung des Tuts ist hier zu finden.

Brett Porter

Jeff Molofee (NeHe) http://nehe.gamedev.net

Die Source Codes und Ausführbaren Dateien zu den Kursen liegen auf der Neon Helium Website

codeworx.

Übersetzt und modifiziert von Hans-Jakob Schwer 29.09.2k3, www.codeworx.org


 
 

Warning: Unknown: open(/var/lib/php/sessions/sess_a147ca9cd5ae7488f04faff4f715ef0c, O_RDWR) failed: No such file or directory (2) in Unknown on line 0

Warning: Unknown: Failed to write session data (files). Please verify that the current setting of session.save_path is correct (/var/lib/php/sessions) in Unknown on line 0