spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#include "globals.h"

float Normals[162][3]=
{
#include "anorms.h"
};


Vector3 MD2Model::GiveVertex(int Frame, int Index)
{
    frame_md2* selectedframe= (frame_md2*) ((char*)(pFrames)+Header.frameSize*Frame);
    return Vector3((float)selectedframe->verts[Index].vertex[0]*(float)selectedframe->scale[0]+(float)selectedframe->translate[0],
                   (float)selectedframe->verts[Index].vertex[1]*(float)selectedframe->scale[1]+(float)selectedframe->translate[1],
                   (float)selectedframe->verts[Index].vertex[2]*(float)selectedframe->scale[2]+(float)selectedframe->translate[2]);
}

textureCoordinate_md2 MD2Model::GiveTexCoordinate(int Index)
{
    textureCoordinate_md2 tex;
    //tex.x=(float)Header.skinHeight/(float)pTexCoords[Index].u;

    //tex.y=(float)Header.skinWidth/(float)pTexCoords[Index].v;

    tex.u=pTexCoords[Index].u;
    tex.v=pTexCoords[Index].v;
    return tex;
}

Vector3 MD2Model::GiveNormal(int Frame, int Index)
{
    frame_md2* selectedframe= (frame_md2*) ((char*)(pFrames)+Header.frameSize*Frame);
    return Vector3(Normals[selectedframe->verts[Index].lightNormalIndex][0],
                   Normals[selectedframe->verts[Index].lightNormalIndex][1],
                   Normals[selectedframe->verts[Index].lightNormalIndex][2]);
}

bool MD2Model::LoadModel(char *Filename)
{
    FILE* FileHandle;
    FileHandle=fopen(Filename, "rb");
    if (FileHandle==NULL)
        return false;
    fread(&Header, 1, sizeof(header_md2), FileHandle);
    if(Header.magic!=844121161)
        return false;
    
      pSkins     = new TextureFilename_md2[ Header.numSkins ];

      pTexCoords = new textureCoordinate_md2[ Header.numTexCoords ];

      pTriangles = new triangle_md2[ Header.numTriangles ];

      pFrames    = (frame_md2*)malloc(Header.numFrames*Header.frameSize);
 
      fseek(FileHandle, Header.offsetSkins, SEEK_SET);
      fread(pSkins, Header.numSkins, sizeof(TextureFilename_md2), FileHandle);

      fseek(FileHandle, Header.offsetTexCoords, SEEK_SET);
      fread(pTexCoords, Header.numTexCoords, sizeof(textureCoordinate_md2), FileHandle);

      fseek(FileHandle, Header.offsetTriangles, SEEK_SET);
      fread(pTriangles, Header.numTriangles, sizeof(triangle_md2), FileHandle);

      fseek(FileHandle, Header.offsetFrames, SEEK_SET);
      fread(pFrames, Header.numFrames*Header.frameSize, 1, FileHandle);
      
      fseek(FileHandle, Header.offsetGlCommands, SEEK_SET);
      fread(pglCommands, Header.numGlCommands, sizeof(int), FileHandle);

      fclose(FileHandle); 
      //Textur laden

        
      LOG("INFO: Die Textur für das Modell %s namens %s wird geladen.\n", Filename, pSkins[0].Filename);
      TextureHandleMD2=Game.TextureManager->LoadTexture("droideka.tga", LINEAR_FILTERING);

      //Jetzt die Listen vorbereiten, für jeden Frame eine

      for(int counter=0; counter<Header.numFrames; counter++)
      {
          Listnumbers[counter]=glGenLists(1);
          glNewList(Listnumbers[counter], GL_COMPILE);
          Game.TextureManager->ActivateTexture(TextureHandleMD2);
          glBegin (GL_TRIANGLES);
          for(int counter2=0; counter2<Header.numTriangles; counter2++)
          {
          Vector3 first=GiveVertex(counter, pTriangles[counter2].vertexIndices[0]);
          Vector3 second=GiveVertex(counter, pTriangles[counter2].vertexIndices[1]);
          Vector3 third=GiveVertex(counter, pTriangles[counter2].vertexIndices[2]);

          textureCoordinate_md2 temptex;
          Vector3 Normal=GiveNormal(counter, pTriangles[counter2].vertexIndices[0]);
          temptex=GiveTexCoordinate(pTriangles[counter2].textureIndices[0]);
          glTexCoord2f((float)temptex.u/(float)Header.skinWidth,1-(float)temptex.v/(float)Header.skinHeight);
          glNormal3fv(Normal);
          glVertex3fv(first);
          //LOG("erster vertex für frame %d lautet %f-%f-%f\n", counter, first.x, first.y, first.z);


          Normal=GiveNormal(counter, pTriangles[counter2].vertexIndices[1]);
          temptex=GiveTexCoordinate(pTriangles[counter2].textureIndices[1]);
          glTexCoord2f((float)temptex.u/(float)Header.skinWidth,1-(float)temptex.v/(float)Header.skinHeight);
          glNormal3fv(Normal);
          glVertex3fv(second);

          Normal=GiveNormal(counter, pTriangles[counter2].vertexIndices[2]);
          temptex=GiveTexCoordinate(pTriangles[counter2].textureIndices[2]);
          glTexCoord2f((float)temptex.u/(float)Header.skinWidth,1-(float)temptex.v/(float)Header.skinHeight);
          glNormal3fv(Normal);
          glVertex3fv(third);
          }
            
          glEnd ();

          glEndList();

      }
    return true;
}

void MD2Model::RenderFrame(unsigned int Number)
{
    glPushMatrix();
    glPushAttrib(GL_ALL_ATTRIB_BITS);
    
    glRotatef(270.f, 1,0,0);
    glFrontFace( GL_CW );
    glEnable( GL_CULL_FACE );
    glCullFace( GL_BACK );
    glEnable(GL_TEXTURE_2D);
    glCallList(Listnumbers[Number]);
    glDisable( GL_CULL_FACE );

    glPopAttrib();
    glPopMatrix();
}