Welches 3D-Format für OpenGL



  • Hallo zusammen

    Ich möchte mich in Zukunft etwas mit 3D-Programmierung befassen und da ich unter Linux programmiere, möchte ich OpenGl verwenden.

    Im Vorfeld interessiert mich jetzt ob OpenGl selbstständig ein Format einlesen kann. Im Internet konnte ich leider nichts brauchbares auf die schnelle finden.

    Wenn OpenGL kein Format selber einlesen kann, wie geht man dann am besten vor. Soll man ein eigenes Format entwickeln? Oder ein verbreitetes untersuchen und nach programmieren?

    Was schlagt ihr vor? Wie geht man so was an.

    Bis dann, Sebel



  • hallo,

    schau dir mal bei NeHe die tuts an. Da ist auch eins dabei um milkshape modells zu laden.
    Viel spass 🙂



  • Gibt es mittlerweile eigentlich ein Tutorial für animierte Milkshape Modells ?



  • Du könntest auf DX umsatteln und *.x benutzen. Musst du aber selbst wissen.

    Bye, TGGC



  • @TGGC:

    Man, scheiss das du nicht lesen kannst, seitwann läuft DX unter Linux ?

    @OGL Models:

    www.gametutorials.com -> md2 / md3 loader is ganz praktisch 🙂



  • Man kann unter Linux DX-Programme schreiben.
    Es gibt Wrapperlibs die DX-Befehle durch entsprechende OpenGL Aufrufe ersetzen.

    Was das Format angeht:
    Ich würde mir da selber was ausdenken, das schult.
    Vorher einen Loader für ein bekanntes Format zu schreiben
    ist natürlich auch net schlecht.
    Wie schon gesagt www.gametutorials.com ist da ne gute Adresse.



  • Nimm doch das MD2 Format.

    // MD2 File Header structure
    typedef struct 
    { 
       int magic; 
       int version; 
       int skinWidth; 
       int skinHeight; 
       int frameSize; 
       int numSkins; 
       int numVertices; 
       int numTexCoords; 
       int numTriangles; 
       int numGlCommands; 
       int numFrames; 
    
       int offsetSkins; 
       int offsetTexCoords; 
       int offsetTriangles; 
       int offsetFrames; 
       int offsetGlCommands; 
       int offsetEnd; 
    } model_t;
    
    typedef struct
    {
       byte vertex[3];
       byte lightNormalIndex;
    } triangleVertex_t;
    
    typedef struct
    {
       float scale[3];
       float translate[3];
       char name[16];
       triangleVertex_t vertices;
    } frame_t;
    
    typedef struct
    {
       short vertexIndices[3];
       short textureIndices[3];
    } triangle_t;
    
    typedef struct
    {
       short s, t;
    } textureCoordinate_t;
    
    typedef struct
    {
       float s, t;
       int vertexIndex;
    } glCommandVertex_t;
    

    So sieht das Format aus.

    // Als einfaches Beispiel
    // Laden wir den Modelheader
    
    model_t     modelheader;
    
    //Datei öffnen
    FILE *modelfile = NULL;
    if( (modelfile = fopen (filename, "rb")) == NULL )
       return 0;
    
    //Modelheader in modelheader speichern
    fread( &modelheader, 1, sizeof(model_t), modelfile );
    
    //fseek kann man in der Datei zum nächsten struct "springen"
    //Wie weit man springen muss ist in .offserXXX gespeichert.
    fseek(modelfile, modelheader.offsetFrames, SEEK_SET);
    
    //ein weiteres Beispiel
    fseek(modelfile, modelheader.offsetTriangles, SEEK_SET);
    
    //Hier werden die Triangles gespeichert.
    for(i=0; i<modelheader.numTriangles; i++)
    {
       fread(&tri,sizeof(triangle_t),1,modelfile);
    
       myVertex[counter].x = myV[tri.vertexIndices[0]].x;
       myVertex[counter].y = myV[tri.vertexIndices[0]].z;
       myVertex[counter].z = myV[tri.vertexIndices[0]].y;
    
       myVertex[counter+1].x = myV[tri.vertexIndices[1]].x;
       myVertex[counter+1].y = myV[tri.vertexIndices[1]].z;
       myVertex[counter+1].z = myV[tri.vertexIndices[1]].y;
    
       myVertex[counter+2].x = myV[tri.vertexIndices[2]].x;
       myVertex[counter+2].y = myV[tri.vertexIndices[2]].z;
       myVertex[counter+2].z = myV[tri.vertexIndices[2]].y;
    
       counter+=3;
    }
    
    // Beachte das dieser Code für DX geschrieben wurde. z und y sind vertauscht.
    

    So ich hoffe das du mit dieser Gedankenstütze etwas anfagen kannst.

    cu 👍



  • Das einlesen von bestimmten bekannten 3d Formaten wird von Librarys
    unterstützt, das ist generell nicht die Aufgabe von OpenGL.

    Eine dieser Library ist z.b. die plib.

    plib.sf.net

    Die plib unterstüzt eine Vielzahl von bekannten 3d Formaten.



  • Jau, Danke.

    Die Urls haben mir so ziemlich alle Fragen beantwortet.

    Zum Windows-Linux Flame:

    TGGC: Man kann vielleicht an Linux einige Schwachpunkte finden, aber mit Sicherheit nicht das es inkompatibel sei. DX ist von MS und MS vertreibt halt nur Produkte fürs eigene System.

    Dafür kann man Linux nicht die Schuld geben.

    Jedenfalls besten Dank noch einmal.

    Sebel


Anmelden zum Antworten