Warning: session_start(): open(/var/lib/php/sessions/sess_1cf356a509e8fd318c64acc4a6746696, 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 25 - Auslesen von Objekten aus Dateien und Morphing

www.codeworx.org/opengl-tutorials/Tutorial 25: Auslesen von Objekten aus Dateien und Morphing

Lektion 25: Auslesen von Objekten aus Dateien und Morphing

Willkommen zu dieser hoffentlich spannenden Lektion. Es wird ein immer wieder gern genutzter Effekt, das Morphing vorgestellt. Dabei verwandelt sich ein Objekt nahezu stufenlos in ein anderes. Es gibt eine kleine Einschränkung, alle Objekte müssen die gleiche Anzahl von Punkten haben.

Wie in der Überschrift "versprochen", werden diese Objekte aus Textdateien gelesen, das Format stammt noch aus Lektion 10.

Es geht los mit dem inkludieren der Header-Dateien. Glaux.h wird nicht benötigt, da es Punkte statt Texturen zu bestaunen gibt. Später kann natürlich immernoch mit anderen Grundprimitiven rumprobiert werden (LINES, QUADS usw).

#include<windows.h>   // Header File For Windows
#include<math.h>      // Math Library Header File
#include<stdio.h>     // Header File For Standard Input/Output
#include<gl\gl.h>     // Header File For The OpenGL32 Library
#include<gl\glu.h>    // Header File For The GLu32 Library

HDChDC=NULL;          // Device Context Handle
HGLRChRC=NULL;        // Rendering Context Handle
HWNDhWnd=NULL;        // Window Handle
HINSTANCE hInstance;   // Instance Handle

bool keys[256];        // Key Array
bool active=TRUE;      // Program's Active
bool fullscreen=TRUE; // Default Fullscreen To True

Es werden weitere Variablen benötigt: xrot, yrot und zrot speichern die Achsenrotation des aktuellen Objektes. xspeed, yspeed und zspeed die jeweiligen Rotationsgeschwindigkeiten, cx, cy und cz die Prosition.

key soll sicherstellen das der Benutzer nicht sinnloserweise ein Objekt in sich selber morphen läßt (wird am Code klar), steps legt fest wieviele Schritte eine Animation haben soll. je größer der Wert destso langsamer aber auch "weicher" der Effekt.

morph wird TRUE wenn die Animation läuft (Damit jedes Morphing bis zum Ende durchläuft!).

GLfloat xrot,yrot,zrot,   // X, Y & Z Rotation
xspeed,yspeed,zspeed,     // X, Y & Z Spin Speed
cx,cy,cz=-15;             // X, Y & Z Position
int key=1;                // Used To Make Sure Same Morph Key Is Not Pressed
int step=0,steps=200;     // Step Counter And Maximum Number Of Steps
bool morph=FALSE;         // Default morph To False (Not Morphing)

Es wird eine Structure Vertex erstellt die einen einfachen geometrischen Punkt (3D) beschreibt.

typedef struct      // Structure For 3D Points
{
   float x, y, z;   // X, Y & Z Points
} VERTEX;           // Called VERTEX


Jetzt muss noch eine Structure für die Objekte her. verts speichert die Anzahl der Punkte des Objektes. Die eigentliche Anzahl wird später im Code festgelegt. "points" ist eine Referenz auf einen beliebigen Punkt der Form VERTEX. Das erleichtert den Zugriff.

typedefstruct     // Structure For An Object
{
   int verts;     // Number Of Vertices For The Object
   VERTEX*points; // One Vertice (Vertex x,y & z)
} OBJECT;         // Called OBJECT

Der Integer maxver speichert die maximale (und gleiche) Anzahl der Punkte in den Objekten. Für die 4 verschiedenen Objekte werden Instanzen von OBJECT erstellt. helper ist ebenfalls ein Objekt, *sour und *dest sind Zeiger auf ein solches Objekt. helper wird für das Morphing an sich genutzt, *sour zeigt auf das Ausgangsobjekt, *dest auf das Ziel.

int max ver;                        // Will Eventually Hold The Maximum Number Of Vertices
OBJECT morph1,morph2,morph3,morph4, // Our 4 Morphable Objects (morph1,2,3 &    4)
helper,*sour,*dest;                 // Helper Object, Source Object, Destination Object

WndProc() wie immer:

LRESULTCALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);// Declaration

Der untere Code reserviert Speicher für die zu ladenden Objekte n. *k zeigt auf das aktuell zu ladende Objekt. "sizeof" gibt die größe des freizumachenden Objektes an. Jedes OBJECT besteht dabei aus einer bestimmten Anzahl von Punkten (VERTEX) die jeweils aus 3 floats bestehen.

void objallocate(OBJECT *k,int n)               // Allocate Memory For Each Object
{                                               // And Defines points
   k->points=(VERTEX*)malloc(sizeof(VERTEX)*n); 
   // Sets points Equal To VERTEX* Number Of Vertices
}                                               // (3 Points For Each Vertice)

Hier wird der Speicher nach erfolgreichem Laden aufgeräumt:

void objfree(OBJECT *k)  // Frees The Object (Releasing The Memory)
{
   free(k->points);      // Frees Points
}


Der folgende Code liest eine Zeichenkette *string aus einer Date *f (Zeiger auf die Datei) mithilfe von fgets(); Wenn die Zeile leer ist oder ein Zeilenumbruch stattfindet, wird abgebrochen.

void readstr(FILE *f,char *string)// Reads A String From File (f)
{
   do// Do This
   {
      fgets(string, 255, f);                                
      // Gets A String Of 255 Chars Max From f (File)
   } while ((string[0] == '/') || (string[0] == '\n'));     
      // Until End Of Line Is    Reached

   return;                                                  // Return
}


objload lädt ein Objekt (*k zeigt drauf) aus einer Datei mit dem Pfad *name.

ver speichert die Anzahl der Punkte des Objekts.

rx, ry & rz speichern die Werte der Einzelpunkte.

filein zeigt auf die Datei mit den Objektdaten, oneline speichert 255 Zeichen.

Die Datei wird geöffnet, dabei soll diese als Textdatei behandelt werden, Strg+z bezeichnet dabei das Ende einer Zeile. readstr(filein,oneline) liest eine zeile der Datei und speichert diese in onneline.

Jetzt wird die gespeicherte Zeichenkette nach dem Ausdruck "Vertices: {Anzahl} {\n}" durchsucht. Ist die Zeile gefunden, wird die angegebene Zahl in ver gespeichert. (Das läßt sich am besten anhand einer Objektdatei demonstrieren, einfach mal mit nem Texteditor angucken.)

Jetzt können auch Objekte mit unterschiedlicher Punkanzahl geladen werden, wovon ich aber trotzdem, abrate. Als letztes wird die Speicherreservierungsfunktion von vorhin genutzt.

void objload(char *name,OBJECT *k)      // Loads Object From File (name)
{
   int ver;                             // Will Hold Vertice Count
   floatrx,ry,rz;                       // Hold Vertex X, Y & Z Position
   FILE*filein;                         // Filename To Open
   charoneline[255];                    // Holds One Line Of Text (255 Chars Max)

   filein = fopen(name, "rt");          // Opens The File For Reading Text In Translated Mode
                                        // CTRL Z Symbolizes End Of File In Translated Mode
   readstr(filein,oneline);             // Jumps To Code That Reads One Line Of Text From The    File
   sscanf(oneline, "Vertices: %d\n", &ver); // Scans Text For "Vertices: ". Number After Is Stored In ver
   k->verts=ver;                            // Sets Objects verts Variable To Equal The Value Of ver
   objallocate(k,ver);                      // Jumps To Code That Allocates Ram To Hold The Object


Die Datei wird Zeile für Zeile nach den Punktkoordinaten für das Objekt durchsucht, die Anzahl der Zeilen stimmt (hoffentlich) mit der Anzahl der Punkte überein. Mit i wird durch die Punkte geloopt.

In jeder Zeile stecken Koordinaten der Form {X Y Z} die hier als Floats von sscanf() ausgelesen und in den jeweiligen Variablen zwischengespeichert werden.

   for (int i=0;i<ver;i++)                         // Loops Through The Vertices
   {
      readstr(filein,oneline);                     // Reads In The Next Line Of Text
      sscanf(oneline, "%f %f %f", &rx, &ry, &rz);  // Searches For 3 Floating Point Numbers, Store In rx,ry & rz

Hier werden die Punktkoordinaten in das aktuelle Objekt übertragen:

k ist der Zeiger auf das aktuelle Objekt, i ist gleichzeitig die Zeilennummer und die Nummer des Punktes im Objekt (daher ist points[i] kein Problem, da der Speicher eben freigegeben wurde. Da es sich um Punkte handelt wird x, y und z übergeben.

      k->points[i].x = rx;       // Sets Objects (k) points.x Value To rx
      k->points[i].y = ry;       // Sets Objects (k) points.y Value To ry
      k->points[i].z = rz;       // Sets Objects (k) points.z Value To rz
   }

   fclose(filein);               // Close The File
   if(ver>maxver) maxver=ver;    // If ver Is Greater Than maxver Set maxver Equal To ver
}                             // Keeps Track Of Highest Number Of Vertices Used


Das nächste Stück Code mag zuerst verwirren, ist aber schnell erklärt:

Es wird für jeden Punkt seine neue Position während des Morphings berechnet. Die Nummer des zu berechnenden Punktes ist i.

a wird als temporärer Punkt erzeugt, hat also eine x-, y- und z-Koordinate.

Die Punkte sollen sich während der Animation vom Start zum Zielpunkt bewegen, wobei sie eine Gerade beschreiben werden. Da es von sour nach dest gehen soll, wird einer der Punkte subtrahiert und durch den aktuellen Frame der Animation geteilt. a wird mit seinen drei Koordinaten zurückgegeben.

VERTEX calculate(int i)      // Calculates Movement Of Points During Morphing
{
   VERTEX a;                 // Temporary Vertex Called a
   a.x=(sour->points[i].x-dest->points[i].x)/steps;     // a.x Value Equals Source x-Destination x Divided By Steps
   a.y=(sour->points[i].y-dest->points[i].y)/steps;     // a.y Value Equals Source y-Destination y Divided By Steps
   a.z=(sour->points[i].z-dest->points[i].z)/steps;     // a.z Value Equals Source z-Destination z Divided By Steps
   return a;                 // Return The Results
}                            // This Makes Points Move At A Speed So They All Get To Their


ReSizeGLScene() bleibt so. Einige Werte werden initiailisiert.

GLvoid ReSizeGLScene(GLsizei width, GLsizei height)  // Resize And Initialize    The GL Window
(...)
int InitGL(GLvoid)                                   // All Setup For OpenGL Goes Here
{
   glBlendFunc(GL_SRC_ALPHA,GL_ONE);                 // Set The Blending Function For Translucency
   glClearColor(0.0f, 0.0f, 0.0f, 0.0f);             // This Will Clear The Background Color To Black
   glClearDepth(1.0);                                // Enables Clearing Of The Depth Buffer
   glDepthFunc(GL_LESS);                             // The Type Of Depth Test To Do
   glEnable(GL_DEPTH_TEST);                          // Enables Depth Testing
   glShadeModel(GL_SMOOTH);                          // Enables Smooth Color Shading
   glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);// Really Nice Perspective    Calculations

maxver wird sicherheitshalber mit 0 initialisiert, da noch nicht klar ist wieviele Punkte die Objekte haben werden.

Drei Objekte werden geladen, eine Kugel, ein Ring und ein Zylinder.

   maxver=0;// Sets Max Vertices To 0 By Default
   objload("data/sphere.txt",&morph1);// Load The First Object Into    morph1 From File sphere.txt
   objload("data/torus.txt",&morph2);// Load The Second Object Into    morph2 From File torus.txt
   objload("data/tube.txt",&morph3);// Load The Third Object Into    morph3 From File tube.txt


Das vierte Objekt wird nicht aus einer Datei geladen, sondern mit zufällig erzeugten Punkten gefüllt.

Der Speicher muss manuell freigegeben werden, dies passiert mit objallocate(&morph4,468). 468 meint zum Beispiel, das 468 Punkte erzeugt werden sollen. Die drei Zeilen (morph4.points...) erzeugen Zufallspunkte zwischen +7 und -7. (rand()%14000)/1000 erzeugt Punkte zwischen 0 und 14, Sieben abgezogen ergibt das Zufallszahlen zwischen +7 und -7.

   objallocate(&morph4,486);
   // Manually Reserver Ram For A 4th 468 Vertice Object (morph4)

   for(int i=0;i<486;i++)// Loop Through All 468 Vertices
   {
      morph4.points[i].x=((float)(rand()%14000)/1000)-7;
      // morph4 x Point Becomes A Random Float Value From -7 to 7
      morph4.points[i].y=((float)(rand()%14000)/1000)-7;
      // morph4 y Point Becomes A Random Float Value From -7 to 7
      morph4.points[i].z=((float)(rand()%14000)/1000)-7;
      // morph4 z Point Becomes A Random Float Value From -7 to 7
   }	

Jetzt wird sphere.txt als helper-Objekt geladen. Die geladenen Objekte in morph{1/2/3/4} sollen nie direkt verändert werden. helper übernimmt das und bekommt die Daten des jeweils aktuellen Objektes. Da das Beispiel zuerst morph1 darstellen soll, wird sphere.txt in helper geladen.
sour und dest werden auch auf morph1 gesetzt um diese mit gültigen Werten zu versehen.

   objload("data/sphere.txt",&helper); // Load sphere.txt Object    Into Helper (Used As Starting Point)
   sour=dest=&morph1;                  // Source & Destination Are Set To Equal First Object    (morph1)
   return TRUE;                        // Initialization Went OK
}


Dem Rendering!

Alles wie gehabt, Bildschirm und depth-Puffer werden gelöscht, die Modelview Matrix zurückgesetzt.

Die Rotation wird mithilfe der vorher definierten Variablen gesteuert.

Die Drehwinkel werden in jedem Frame um die jeweiligen Geschwindigkeiten ({x,y,z}speed) erhöht.

3 temporäre Variablen und ein neuer Punkt q werden erstellt.

void DrawGLScene(GLvoid)// Here's Where We Do All The Drawing
{
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   // Clear The Screen And The Depth Buffer
   glLoadIdentity();// Reset The View
   glTranslatef(cx,cy,cz);// Translate The The Current Position To Start Drawing
   glRotatef(xrot,1,0,0);// Rotate On The X Axis By xrot
   glRotatef(yrot,0,1,0);// Rotate On The Y Axis By yrot
   glRotatef(zrot,0,0,1);// Rotate On The Z Axis By zrot
   xrot+=xspeed; yrot+=yspeed; zrot+=zspeed;// Increase xrot,yrot & zrot by xspeed, yspeed & zspeed
   GLfloat tx,ty,tz;// Temp X, Y & Z Variables
   VERTEX q;// Holds Returned Calculated Values For One Vertex

Die Punkte werden nacheinander ausgegeben und, falls Morphing läuft, diese berechnet. Da sowieso alle Objekte die gleiche Größe haben, wird morph1.verts als Maximalwert genutzt.

In der Schleife wird getestet ob morph TRUE ist. Sollte das zutreffen, werden die Punkte bewegt, andernfall wird ihre Bewegung (q.x=0).

Entsprechend der Ergebnisse von calculate() bewegen sich die Punkte.

   glBegin(GL_POINTS);              // Begin Drawing Points
   for(int i=0;i<morph1.verts;i++)  // Loop Through All The Verts Of morph1 (All    Objects Have
   {
      // The Same Amount Of Verts For Simplicity, Could Use maxver Also)
      if(morph) q=calculate(i); else q.x=q.y=q.z=0;// If morph Is True Calculate Movement    Otherwise Movement=0
      helper.points[i].x-=q.x;      // Subtract q.x Units From helper.points[i].x (Move On X Axis)
      helper.points[i].y-=q.y;      // Subtract q.y Units From helper.points[i].y (Move On Y Axis)
      helper.points[i].z-=q.z;      // Subtract q.z Units From helper.points[i].z (Move On Z Axis)
      tx=helper.points[i].x;        // Make Temp X Variable Equal To Helper's X Variable
      ty=helper.points[i].y;        // Make Temp Y Variable Equal To Helper's Y Variable
      tz=helper.points[i].z;        // Make Temp Z Variable Equal To Helper's Z Variable

Diese werden, mit entsprechenden Farben, ausgeben. Die Farbe wird ein wenig abgedunkelt und ein zweiter Punkt wird neben dem ersten platziert, daneben noch ein Dunkelblauer. Das Ergebnis ist ein leichter 3D-Effekt an dem Punkt..

      glColor3f(0,1,1);             // Set Color To A Bright Shade Of Off Blue
      glVertex3f(tx,ty,tz);         // Draw A Point At The Current Temp Values (Vertex)
      glColor3f(0,0.5f,1);          // Darken Color A Bit
      tx-=2*q.x; ty-=2*q.y; ty-=2*q.y;// Calculate Two Positions Ahead
      glVertex3f(tx,ty,tz);         // Draw A Second Point At The Newly Calculate Position
      glColor3f(0,0,1);             // Set Color To A Very Dark Blue
      tx-=2*q.x; ty-=2*q.y; ty-=2*q.y;// Calculate Two More Positions Ahead
      glVertex3f(tx,ty,tz);         // Draw A Third Point At The Second New Position

   }  // This Creates A Ghostly Tail As Points Move

   glEnd();// Done Drawing Points

Wenn Morphing aktiviert ist und step kleiner als steps (hier 200) ist, wird step erhöht, Für Werte >= 200 wird step 0 und die Animation ist nach 200 Frames beendet.

   // If We're Morphing And We Haven't Gone Through All 200 Steps Increase Our Step Counter
   // Otherwise Set Morphing To False, Make Source=Destination And Set The Step Counter Back To Zero.
   if(morph && step<=steps)step++; else { morph=FALSE; sour=dest; step=0;}
}


An KillGLWindow hat sich nicht viel verändert, zusätzlich wird noch der durch die Objekte belegte Speicher gesäubert, was sich immer empfiehlt.

GLvoid KillGLWindow(GLvoid)// Properly Kill The Window
{
   objfree(&morph1);// Jump To Code To Release morph1 Allocated Ram
   objfree(&morph2);// Jump To Code To Release morph2 Allocated Ram
   objfree(&morph3);// Jump To Code To Release morph3 Allocated Ram
   objfree(&morph4);// Jump To Code To Release morph4 Allocated Ram
   objfree(&helper);// Jump To Code To Release helper Allocated Ram

 (...)


CreateGLWindow() und WndProc() bleiben so wie sie sind.

BOOL CreateGLWindow() // Creates The GL Window
LRESULT CALLBACK WndProc()// Handle For This Window

In WinMain müssen ein paar Änderungen vorgenommen werden.

int WINAPI WinMain(HINSTANCEhInstance,     // Instance
                   HINSTANCEhPrevInstance, // Previous Instance
                   LPSTRlpCmdLine,         // Command Line Parameters
                   intnCmdShow)            // Window Show State
   {
      MSGmsg;                              // Windows Message Structure
      BOOL done=FALSE;                     // Bool Variable To Exit Loop

   // Ask The User Which Screen Mode They Prefer
   if (MessageBox(NULL,"Would You Like To Run In Fullscreen Mode?", 
                  "Start FullScreen?",MB_YESNO|MB_ICONQUESTION)==IDNO)
   {
      fullscreen=FALSE;// Windowed Mode
   }

   // Create Our OpenGL Window
   if (!CreateGLWindow("Piotr Cieslak & NeHe's Morphing Points Tutorial",
                        640,480,16,fullscreen))
   {
      return 0;// Quit If Window Was Not Created
   }

   while(!done)// Loop That Runs While done=FALSE
   {
      if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))// Is There A Message Waiting?
      {
         if (msg.message==WM_QUIT)// Have We Received A Quit Message?
         {
            done=TRUE;// If So done=TRUE
         }

         else // If Not, Deal With Window Messages
         {
            TranslateMessage(&msg);// Translate The Message
            DispatchMessage(&msg);// Dispatch The Message
         }
      }

      else// If There Are No Messages
      {
         // Draw The Scene. Watch For ESC Key And Quit Messages From DrawGLScene()
         if (active && keys[VK_ESCAPE])// Active? Was There A Quit Received?
         {
            done=TRUE;// ESC or DrawGLScene Signaled A Quit
         }

      else// Not Time To Quit, Update Screen
      {
         DrawGLScene();// Draw The Scene (Don't Draw When Inactive 1% CPU Use)
         SwapBuffers(hDC);// Swap Buffers (Double Buffering)


Der untere Code fragt ab, ob der Benutzer bestimmte Tasten gedrückt hat:

      if(keys[VK_PRIOR])// Is Page Up Being Pressed?
         zspeed+=0.01f;// Increase zspeed
      if(keys[VK_NEXT])// Is Page Down Being Pressed?
         zspeed-=0.01f;// Decrease zspeed
      if(keys[VK_DOWN])// Is Page Up Being Pressed?
         xspeed+=0.01f;// Increase xspeed
      if(keys[VK_UP])// Is Page Up Being Pressed?
         xspeed-=0.01f;// Decrease xspeed
      if(keys[VK_RIGHT])// Is Page Up Being Pressed?
         yspeed+=0.01f;// Increase yspeed
      if(keys[VK_LEFT])// Is Page Up Being Pressed?
         yspeed-=0.01f;// Decrease yspeed


Die folgenden Taste bewegen das Objekt im Raum, die vorherigen haben die Drehung verändert.

      if (keys['Q'])// Is Q Key Being Pressed?
         cz-=0.01f;// Move Object Away From Viewer
      if (keys['Z'])// Is Z Key Being Pressed?
         cz+=0.01f;// Move Object Towards Viewer
      if (keys['W'])// Is W Key Being Pressed?
         cy+=0.01f;// Move Object Up
      if (keys['S'])// Is S Key Being Pressed?
         cy-=0.01f;// Move Object Down
      if (keys['D'])// Is D Key Being Pressed?
         cx+=0.01f;// Move Object Right
      if (keys['A'])// Is A Key Being Pressed?
         cx-=0.01f;// Move Object Left

Jetzt werden die Tasten 1 bis 4 kontrolliert. Damit das gleiche Objekt nicht zweimal nacheinander ineinander gemorpht wird (man sähe genau gar nichts davon), speichert key die jeweils letzte Taste. Außerdem wird geprüft ob morph überhaupt TRUE ist.

      if (keys['1'] && (key!=1) && !morph)// Is 1 Pressed, key Not Equal To 1 And Morph False?
      {
         key=1;// Sets key To 1 (To Prevent Pressing 1 2x In A Row)
         morph=TRUE;// Set morph To True (Starts Morphing Process)
         dest=&morph1;// Destination Object To Morph To Becomes morph1
      }

      if (keys['2'] && (key!=2) && !morph)// Is 2 Pressed, key Not Equal To 2 And Morph False?
      {
         key=2;// Sets key To 2 (To Prevent Pressing 2 2x In A Row)
         morph=TRUE;// Set morph To True (Starts Morphing Process)
         dest=&morph2;// Destination Object To Morph To Becomes morph2
      }

      if (keys['3'] && (key!=3) && !morph)// Is 3 Pressed, key Not Equal To 3 And Morph False?
      {
         key=3;// Sets key To 3 (To Prevent Pressing 3 2x In A Row)
         morph=TRUE;// Set morph To True (Starts Morphing Process)
         dest=&morph3;// Destination Object To Morph To Becomes morph3
      }

      if (keys['4'] && (key!=4) && !morph)// Is 4 Pressed, key Not Equal To 4 And Morph False?
      {
         key=4;// Sets key To 4 (To Prevent Pressing 4 2x In A Row)
         morph=TRUE;// Set morph To True (Starts Morphing Process)
         dest=&morph4;// Destination Object To Morph To Becomes morph4
      }

Mit F1 kann der Benutzer Vollbild und Fenster umschalten.

      if (keys[VK_F1])// Is F1 Being Pressed?
      {
         keys[VK_F1]=FALSE;// If So Make Key FALSE
         KillGLWindow();// Kill Our Current Window
         fullscreen=!fullscreen;// Toggle Fullscreen / Windowed Mode
         // Recreate Our OpenGL Window
      if (!CreateGLWindow("Piotr Cieslak & NeHe's Morphing Points Tutorial",
           640,480,16,fullscreen))
      {
         return 0;// Quit If Window Was Not Created
      }
   }
   }
   }
   }

   // Shutdown
   KillGLWindow();// Kill The Window
   return (msg.wParam);// Exit The Program

}

Das wars auch schon :). Ich hoffe das Tutorial ist nicht zu komplex geraten und hat Spaß gemacht. Man kann mit QUADS und Texturen noch eine Menge aus dem Morphing-Effekten machen, immer fleißig rumprobieren, bis die Tage!

codeworx.

Piotr Cieslak : http://homepage.ntlworld.com/fj.williams/PgSoftware.html

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

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

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


 
 

Warning: Unknown: open(/var/lib/php/sessions/sess_1cf356a509e8fd318c64acc4a6746696, 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