Working with format md3

Game.cpp

@@ -26,6 +26,7 @@ namespace ZL
 		std::shared_ptr<Texture> pipeTexturePtr;
 		std::shared_ptr<Texture> gameOverTexturePtr;
 		std::shared_ptr<Texture> testObjTexturePtr;
+		std::shared_ptr<Texture> md3TexturePtr;
 
 		VertexRenderStruct birdMesh;
 
@@ -40,6 +41,10 @@ namespace ZL
 
 		VertexDataStruct testObjMesh;
 		VertexRenderStruct testObjMeshMutable;
+
+		std::vector<VertexDataStruct> testmd3;
+		std::vector<VertexRenderStruct> testmd3mutable;
+
 	}
 
 

Game.h

@@ -98,6 +98,7 @@ namespace ZL
 		extern std::shared_ptr<Texture> pipeTexturePtr;
 		extern std::shared_ptr<Texture> gameOverTexturePtr;
 		extern std::shared_ptr<Texture> testObjTexturePtr;
+		extern std::shared_ptr<Texture> md3TexturePtr;
 
 		extern VertexRenderStruct birdMesh;
 
@@ -111,5 +112,8 @@ namespace ZL
 		extern VertexRenderStruct colorCubeMeshMutable;
 		extern VertexDataStruct testObjMesh;
 		extern VertexRenderStruct testObjMeshMutable;
+
+		extern std::vector<VertexDataStruct> testmd3;
+		extern std::vector<VertexRenderStruct> testmd3mutable;
 	}
 }

Readme.md

@@ -1,5 +1,36 @@
 # Script to run:
 
 ```
+C:\Work\Projects\emsdk\emsdk.bat activate latest
+C:\Work\Projects\emsdk\emsdk_env.bat
 emcc main.cpp Game.cpp Math.cpp Physics.cpp Renderer.cpp ShaderManager.cpp TextureManager.cpp Utils.cpp OpenGlExtensions.cpp -O2 -std=c++14 -sTOTAL_MEMORY=33554432 -sUSE_SDL_IMAGE=2 -sSDL2_IMAGE_FORMATS="[""png""]" -sUSE_SDL=2 --preload-file background.bmp --preload-file bird.bmp32 --preload-file default.fragment --preload-file default.vertex --preload-file game_over.bmp32 --preload-file pipe.bmp32 -o jumpingbird.html
-```
+```
+
+```
+
+
+zlib-1.3.1:
+
+mkdir build
+cd build
+cmake -DCMAKE_INSTALL_PREFIX=install ..
+
+then run ALL_BUILD and INSTALL in Visual Studio
+
+lpng1645:
+
+mkdir build
+cd build
+cmake -DCMAKE_INSTALL_PREFIX=install -DZLIB_ROOT=C:\Work\Projects\zlib-1.3.1\build\install ..
+
+then run ALL_BUILD and INSTALL in Visual Studio
+
+
+```
+
+
+https://github.com/Bly7/OBJ-Loader/blob/master/Source/OBJ_Loader.h
+
+
+https://github.com/gametutorials/tutorials/blob/master/OpenGL/MD3%20Animation/Main.cpp
+

ZeptoLabTest1.vcxproj

@@ -114,15 +114,15 @@
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
       <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
-      <AdditionalIncludeDirectories>C:\Work\SDL2-2.28.3\include</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>C:\Work\SDL2-2.28.3\include;C:\Work\Projects\lpng1645\build\install\include</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalDependencies>SDL2.lib;SDL2main.lib;opengl32.lib;glu32.lib;shell32.lib;opengl32.lib;glu32.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;$(CoreLibraryDependencies);%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>libpng16_staticd.lib;SDL2.lib;SDL2main.lib;opengl32.lib;glu32.lib;shell32.lib;opengl32.lib;glu32.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;$(CoreLibraryDependencies);%(AdditionalDependencies)</AdditionalDependencies>
-      <AdditionalLibraryDirectories>C:\Work\SDL2-2.28.3\lib\x64</AdditionalLibraryDirectories>
+      <AdditionalLibraryDirectories>C:\Work\SDL2-2.28.3\lib\x64;C:\Work\Projects\lpng1645\build\install\lib</AdditionalLibraryDirectories>
       <EntryPointSymbol>
       </EntryPointSymbol>
     </Link>
@@ -148,6 +148,8 @@
     <ClCompile Include="Game.cpp" />
     <ClCompile Include="main.cpp" />
     <ClCompile Include="Math.cpp" />
+    <ClCompile Include="md3test.cpp" />
+    <ClCompile Include="ObjLoader.cpp" />
     <ClCompile Include="OpenGlExtensions.cpp" />
     <ClCompile Include="Physics.cpp" />
     <ClCompile Include="Renderer.cpp" />
@@ -158,6 +160,8 @@
   <ItemGroup>
     <ClInclude Include="Game.h" />
     <ClInclude Include="Math.h" />
+    <ClInclude Include="md3test.h" />
+    <ClInclude Include="ObjLoader.h" />
     <ClInclude Include="OpenGlExtensions.h" />
     <ClInclude Include="Physics.h" />
     <ClInclude Include="Renderer.h" />

ZeptoLabTest1.vcxproj.filters

@@ -42,6 +42,12 @@
     <ClCompile Include="Game.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="ObjLoader.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="md3test.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="TextureManager.h">
@@ -68,5 +74,11 @@
     <ClInclude Include="Game.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="ObjLoader.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="md3test.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

default.fragment

@@ -5,7 +5,8 @@ varying vec2 texCoord;
 void main() 
 {
 	vec4 color = texture2D(Texture,texCoord).rgba;
-
+    //gl_FragColor = vec4(color.rgb*0.1 + vec3(0.9, 0.9, 0.9), 1.0);
+	
 	gl_FragColor = color;
 	
 }

main.cpp

@@ -14,6 +14,8 @@
 
 #include "Game.h"
 
+std::vector<ZL::VertexDataStruct> testLoadModel();
+
 namespace ZL
 {
 
@@ -143,23 +145,32 @@ namespace ZL
 
 		renderer.LoadIdentity();
 
-		renderer.TranslateMatrix({ 0,0, -100 });
+		renderer.TranslateMatrix({ 0,0, -300 });
 
 
 		renderer.RotateMatrix(QuatFromRotateAroundX(-M_PI / 3.0));
 
+		/*
 		GameObjects::testObjMeshMutable.AssignFrom(GameObjects::testObjMesh);
 		GameObjects::testObjMeshMutable.data.RotateByMatrix(QuatToMatrix(QuatFromRotateAroundZ(gs.rotateTimer * M_PI / 3.0)));
-		GameObjects::testObjMeshMutable.RefreshVBO();
+		GameObjects::testObjMeshMutable.RefreshVBO();*/
 
-		glBindTexture(GL_TEXTURE_2D, GameObjects::testObjTexturePtr->getTexID());
+
-		renderer.DrawVertexRenderStruct(GameObjects::testObjMeshMutable);
+		//GameObjects::testmd3mutable[0].RefreshVBO();
+		//GameObjects::testmd3mutable[1].RefreshVBO();
+
+		//glBindTexture(GL_TEXTURE_2D, GameObjects::testObjTexturePtr->getTexID());	
+		//renderer.DrawVertexRenderStruct(GameObjects::testObjMeshMutable);
+
+		glBindTexture(GL_TEXTURE_2D, GameObjects::md3TexturePtr->getTexID());
+		renderer.DrawVertexRenderStruct(GameObjects::testmd3mutable[0]);
+		renderer.DrawVertexRenderStruct(GameObjects::testmd3mutable[1]);
 
 		renderer.PopMatrix();
 
 		renderer.PopProjectionMatrix();
 
-		renderer.DisableVertexAttribArray(vColorName);
+		renderer.DisableVertexAttribArray(vPositionName);
 		renderer.DisableVertexAttribArray(vTexCoordName);
 
 		renderer.shaderManager.PopShader();
@@ -247,6 +258,17 @@ namespace ZL
 
 		CheckGlError();
 
+		GameObjects::testmd3 = testLoadModel();
+
+		GameObjects::testmd3mutable.resize(GameObjects::testmd3.size());
+
+		for (int i = 0; i < GameObjects::testmd3.size(); i++)
+		{
+			GameObjects::testmd3[i].Scale(0.01);
+
+			GameObjects::testmd3mutable[i].data = GameObjects::testmd3[i];
+			GameObjects::testmd3mutable[i].RefreshVBO();
+		}
 
 		//Load shaders:
 		renderer.shaderManager.AddShaderFromFiles("default", "./default.vertex", "./default.fragment");
@@ -259,6 +281,8 @@ namespace ZL
 		GameObjects::gameOverTexturePtr = std::make_shared<Texture>(CreateTextureDataFromBmp32("./game_over.bmp32"));
 		GameObjects::testObjTexturePtr = std::make_shared<Texture>(CreateTextureDataFromPng("./chair_01_Base_Color.png"));
 
+		GameObjects::md3TexturePtr = std::make_shared<Texture>(CreateTextureDataFromPng("./model/sarge/band.png"));
+
 
 		CheckGlError();
 		//Create bird mesh

md3test.cpp

@@ -0,0 +1,380 @@
+#include "md3test.h"
+#include "Renderer.h"
+
+//Saving debug information to a log file
+void abc(const char* str)
+{
+    /*
+    FILE* fp = fopen("output.txt", "a+");
+    fprintf(fp, "%s\n", str);
+    fclose(fp);*/
+}
+
+
+long filesize(FILE* stream)
+{
+    long curpos, length;
+
+    curpos = ftell(stream);
+    fseek(stream, 0L, SEEK_END);
+    length = ftell(stream);
+    fseek(stream, curpos, SEEK_SET);
+    return length;
+}
+
+//---------------------------------------------------------------------------
+
+
+class CMD3
+{
+public:
+    char        m_md3FileName[MAX_FILENAME_LENGTH];
+    stMD3Header m_md3Header;
+
+
+    stBoneFrame* m_pBoneFrame;
+    stTag* m_pTags;
+    stMesh* m_pMeshes;
+
+    std::vector<ZL::VertexDataStruct> modelData;
+
+    //-----------------------------------------------------------------------
+    //
+    //  Loads model from a .md3 file
+    //
+    //-----------------------------------------------------------------------
+    bool LoadModel(const char* filename)
+    {
+        char buf[256];
+
+        FILE* fp = fopen(filename, "rb");
+
+        if (fp == NULL)
+        {
+            abc("unable to open file");
+            return false;
+        }
+
+        // Lets get the size of this md3 file
+        int md3filesize = filesize(fp);
+        fseek(fp, 0L, SEEK_SET);
+
+        if (strlen(filename) > 255)
+        {
+            sprintf(buf, "filename is longer than %d", MAX_FILENAME_LENGTH);
+            abc(buf);
+            return false;
+        }
+        // copy name
+        strcpy(m_md3FileName, filename);
+        sprintf(buf, "MD3 FileName: %s", m_md3FileName);
+        abc(buf);
+
+        sprintf(buf, "FileSize: %d", md3filesize);
+        abc(buf);
+
+        abc("\n~~MD3 Header~~\n");
+
+        // read header
+        fread(&m_md3Header, 1, sizeof(stMD3Header), fp);
+
+        // log debug information to file
+        sprintf(buf, "ID %c%c%c%c", m_md3Header.ID[0], m_md3Header.ID[1], m_md3Header.ID[2], m_md3Header.ID[3]);
+        abc(buf);
+
+        sprintf(buf, "Version: %d", m_md3Header.Version);
+        abc(buf);
+
+        sprintf(buf, "FileName: %s", m_md3Header.Filename);
+        abc(buf);
+
+        sprintf(buf, "numBoneFrames: %d", m_md3Header.numBoneFrames);
+        abc(buf);
+
+        sprintf(buf, "numTags: %d", m_md3Header.numTags);
+        abc(buf);
+
+        sprintf(buf, "numMeshes: %d", m_md3Header.numMeshes);
+        abc(buf);
+
+        sprintf(buf, "numMaxSkins: %d", m_md3Header.numMaxSkins);
+        abc(buf);
+
+        sprintf(buf, "ofsFrames: %d", m_md3Header.ofsFrames);
+        abc(buf);
+
+        sprintf(buf, "ofsTagStart: %d", m_md3Header.ofsTagStart);
+        abc(buf);
+
+        sprintf(buf, "ofMeshSurfaces: %d", m_md3Header.ofMeshSurfaces);
+        abc(buf);
+
+        sprintf(buf, "ofEndOfFile (Filesize): %d", m_md3Header.ofEndOfFile);
+        abc(buf);
+
+
+        if (strcmp("IDP3", m_md3Header.ID) == NULL)
+        {
+            sprintf(buf, "Incorrect File Format 'Incorrect ID' ie. ('IDP3')");
+            abc(buf);
+        }
+
+        // Allocate memory for all or bones/tags/etc
+        m_pBoneFrame = new stBoneFrame[m_md3Header.numBoneFrames];
+        m_pTags = new stTag[m_md3Header.numBoneFrames * m_md3Header.numTags];
+        m_pMeshes = new stMesh[m_md3Header.numMeshes];
+
+
+        // Lets seek to the start of the bone frames & read boneframe
+        fseek(fp, m_md3Header.ofsFrames, SEEK_SET);
+        fread(m_pBoneFrame, 1, m_md3Header.numBoneFrames * sizeof(stBoneFrame), fp);
+
+        sprintf(buf, "\n~~~~BoneFrames: %d~~~~~~", m_md3Header.numBoneFrames);
+        abc(buf);
+        for (int i = 0; i < m_md3Header.numBoneFrames; i++)
+        {
+            abc("#");
+            sprintf(buf, "mins[%.1f,%.1f,%.1f]", m_pBoneFrame[i].mins[0], m_pBoneFrame[i].mins[1], m_pBoneFrame[i].mins[2]);
+            abc(buf);
+            sprintf(buf, "maxs[%.1f,%.1f,%.1f]", m_pBoneFrame[i].maxs[0], m_pBoneFrame[i].maxs[1], m_pBoneFrame[i].maxs[2]);
+            abc(buf);
+            sprintf(buf, "Position[%.1f,%.1f,%.1f]", m_pBoneFrame[i].Position[0], m_pBoneFrame[i].Position[1], m_pBoneFrame[i].Position[2]);
+            abc(buf);
+            sprintf(buf, "Scale[%.1f]", m_pBoneFrame[i].Scale);
+            abc(buf);
+            sprintf(buf, "Creator[%s]", m_pBoneFrame[i].Creator);
+            abc(buf);
+        }
+
+
+        // Seek to start of tags and read them all in
+        fseek(fp, m_md3Header.ofsTagStart, SEEK_SET);
+        fread(m_pTags, 1, m_md3Header.numBoneFrames * m_md3Header.numTags * sizeof(stTag), fp);
+
+        sprintf(buf, "\n~~~~Tags: %d~~~~~~", m_md3Header.numTags);
+        abc(buf);
+        for (int i = 0; i < m_md3Header.numTags; i++)
+        {
+            abc("#");
+            sprintf(buf, "Name[%s]", m_pTags[i].Name);
+            abc(buf);
+            sprintf(buf, "Position[%.1f,%.1f,%.1f]", m_pTags[i].Position[0], m_pTags[i].Position[1], m_pTags[i].Position[2]);
+            abc(buf);
+            sprintf(buf, "Rotation[%.1f,%.1f,%.1f][...][...]", m_pTags[i].Rotation[0][0], m_pTags[i].Rotation[0][1], m_pTags[i].Rotation[0][2]);
+            abc(buf);
+        }
+
+
+        int meshOFS = m_md3Header.ofMeshSurfaces;
+
+        
+
+        for (int j = 0; j < m_md3Header.numMeshes; j++)
+        {
+            stMesh* pMesh = &m_pMeshes[j];
+            stMeshHeader* pMeshHeader = &(pMesh->MeshHeader);
+
+            fseek(fp, meshOFS, SEEK_SET);
+
+            // Seek to the start of the mesh data and read it all in
+            fread(pMeshHeader, 1, sizeof(stMeshHeader), fp);
+
+            // Read in all the sub parts of the mesh data
+            {
+                fseek(fp, meshOFS + pMeshHeader->ofsTriangles, SEEK_SET);
+                pMesh->pTriangle = new stTriangle[pMeshHeader->numTriangles];
+                fread(pMesh->pTriangle, 1, pMeshHeader->numTriangles * sizeof(stTriangle), fp);
+
+                fseek(fp, meshOFS + pMeshHeader->ofsSkins, SEEK_SET);
+                pMesh->pSkins = new stSkin[pMeshHeader->numSkins];
+                fread(pMesh->pSkins, 1, pMeshHeader->numSkins * sizeof(stSkin), fp);
+
+                fseek(fp, meshOFS + pMeshHeader->ofsTexVector, SEEK_SET);
+                pMesh->pTexCoord = new stTexCoord[pMeshHeader->numVertexes];
+                fread(pMesh->pTexCoord, 1, pMeshHeader->numVertexes * sizeof(stTexCoord), fp);
+
+                fseek(fp, meshOFS + pMeshHeader->ofsVertex, SEEK_SET);
+                pMesh->pVertex = new stVertex[pMeshHeader->numVertexes];
+                fread(pMesh->pVertex, 1, pMeshHeader->numVertexes * sizeof(stVertex), fp);
+            }
+
+            meshOFS += pMeshHeader->ofsEndMeshSize;
+
+        }//End for meshes
+
+
+
+        modelData.resize(m_md3Header.numMeshes); // !!! Load the mesh actually
+
+
+        sprintf(buf, "\n~~~~Mesh Surfaces: %d~~~~~~", m_md3Header.numMeshes);
+        abc(buf);
+        for (int j = 0; j < m_md3Header.numMeshes; j++)
+        {
+            abc("#");
+            stMesh* pMesh = &m_pMeshes[j];
+            stMeshHeader* pMeshHeader = &(pMesh->MeshHeader);
+
+            sprintf(buf, "ID [%c%c%c%c]", pMeshHeader->ID[0], pMeshHeader->ID[1], pMeshHeader->ID[2], pMeshHeader->ID[3]);
+            abc(buf);
+            sprintf(buf, "Name [%s]", pMeshHeader->Name);
+            abc(buf);
+            sprintf(buf, "flags [0x%.2X]", pMeshHeader->flags);
+            abc(buf);
+            sprintf(buf, "numMeshFrames [%d]", pMeshHeader->numMeshFrames);
+            abc(buf);
+            sprintf(buf, "numSkins [%d]", pMeshHeader->numSkins);
+            abc(buf);
+            sprintf(buf, "numVertexes [%d]", pMeshHeader->numVertexes);
+            abc(buf);
+            sprintf(buf, "numVertexes [%d]", pMeshHeader->numVertexes);
+            abc(buf);
+            sprintf(buf, "ofsTriangles [%d]", pMeshHeader->ofsTriangles);
+            abc(buf);
+            sprintf(buf, "ofsSkins [%d]", pMeshHeader->ofsSkins);
+            abc(buf);
+            sprintf(buf, "ofsTexVector [%d]", pMeshHeader->ofsTexVector);
+            abc(buf);
+            sprintf(buf, "ofsVertex [%d]", pMeshHeader->ofsVertex);
+            abc(buf);
+            sprintf(buf, "ofsEndMeshSize [%d]", pMeshHeader->ofsEndMeshSize);
+            abc(buf);
+
+
+            // Mesh Triangles
+            for (int i = 0; i < pMeshHeader->numTriangles; i++)
+            {
+                stTriangle* pTri = &(pMesh->pTriangle[i]);
+                sprintf(buf, "Triangle [%d,%d,%d]", pTri->Vertex[0], pTri->Vertex[1], pTri->Vertex[2]);
+                abc(buf);
+            }
+
+            // Mesh Skins
+            for (int i = 0; i < pMeshHeader->numSkins; i++)
+            {
+                stSkin* pSkin = &(pMesh->pSkins[i]);
+                sprintf(buf, "Skin:Name [%s]", pSkin->Name);
+                abc(buf);
+                sprintf(buf, "Skin:Index [%d]", pSkin->index);
+                abc(buf);
+            }
+
+            for (int i = 0; i < pMeshHeader->numVertexes; i++)
+            {
+                stTexCoord* pTex = &(pMesh->pTexCoord[i]);
+                sprintf(buf, "TexCoord:Index [%.1f,%.1f]", pTex->Coord[0], pTex->Coord[1]);
+                abc(buf);
+            }
+
+
+            for (int i = 0; i < pMeshHeader->numVertexes; i++)
+            {
+                stVertex* pVert = &(pMesh->pVertex[i]);
+                sprintf(buf, "Vertice:Vertex [%d,%d,%d]", pVert->Vertex[0], pVert->Vertex[1], pVert->Vertex[2]);
+                abc(buf);
+
+            }
+
+            //!!! Load the mesh actually:
+            for (int i = 0; i < pMeshHeader->numTriangles; i++)
+            {
+                stTriangle* pTri = &(pMesh->pTriangle[i]);
+
+                stVertex* pVert0 = &(pMesh->pVertex[pTri->Vertex[0]]);
+                stVertex* pVert1 = &(pMesh->pVertex[pTri->Vertex[1]]);
+                stVertex* pVert2 = &(pMesh->pVertex[pTri->Vertex[2]]);
+                ZL::Vector3f v0;
+
+                v0.v[0] = pVert0->Vertex[0];
+                v0.v[1] = pVert0->Vertex[1];
+                v0.v[2] = pVert0->Vertex[2];
+
+                modelData[j].PositionData.push_back(v0);
+
+                ZL::Vector3f v1;
+
+                v1.v[0] = pVert1->Vertex[0];
+                v1.v[1] = pVert1->Vertex[1];
+                v1.v[2] = pVert1->Vertex[2];
+
+                modelData[j].PositionData.push_back(v1);
+
+                ZL::Vector3f v2;
+
+                v2.v[0] = pVert2->Vertex[0];
+                v2.v[1] = pVert2->Vertex[1];
+                v2.v[2] = pVert2->Vertex[2];
+
+                modelData[j].PositionData.push_back(v2);
+
+                stTexCoord* pTex0 = &(pMesh->pTexCoord[pTri->Vertex[0]]);
+                stTexCoord* pTex1 = &(pMesh->pTexCoord[pTri->Vertex[1]]);
+                stTexCoord* pTex2 = &(pMesh->pTexCoord[pTri->Vertex[2]]);
+
+
+
+                ZL::Vector2f t0;
+
+                t0.v[0] = pTex0->Coord[0];
+                t0.v[1] = pTex0->Coord[1];
+
+                modelData[j].TexCoordData.push_back(t0);
+
+                ZL::Vector2f t1;
+
+                t1.v[0] = pTex1->Coord[0];
+                t1.v[1] = pTex1->Coord[1];
+
+                modelData[j].TexCoordData.push_back(t1);
+
+                ZL::Vector2f t2;
+
+                t2.v[0] = pTex2->Coord[0];
+                t2.v[1] = pTex2->Coord[1];
+
+                modelData[j].TexCoordData.push_back(t2);
+            }
+
+
+        }
+
+
+        fclose(fp);
+
+        for (int j = 0; j < m_md3Header.numMeshes; j++)
+        {
+            stMesh* pMesh = &m_pMeshes[j];
+
+            delete[] pMesh->pSkins;
+            delete[] pMesh->pTexCoord;
+            delete[] pMesh->pTriangle;
+            delete[] pMesh->pVertex;
+
+            pMesh->pSkins = NULL;
+            pMesh->pTexCoord = NULL;
+            pMesh->pTriangle = NULL;
+            pMesh->pVertex = NULL;
+        }
+
+        delete[] m_pBoneFrame;
+        delete[] m_pTags;
+        delete[] m_pMeshes;
+
+        m_pBoneFrame = NULL;
+        m_pTags = NULL;
+        m_pMeshes = NULL;
+
+        return true;
+    }// End LoadModel(..)
+
+};
+
+
+std::vector<ZL::VertexDataStruct> testLoadModel()
+{
+    static CMD3 md3;
+
+    md3.LoadModel(SZ_MD3_FILE);
+
+    return md3.modelData;
+}

md3test.h

@@ -0,0 +1,113 @@
+#pragma once
+
+
+#define SZ_MD3_FILE "model/sarge/upper.md3"
+
+#define MAX_FILENAME_LENGTH 256
+
+
+//---------------------------------------------------------------------------
+
+#include <windows.h>
+#include <stdio.h>                      //sprintf(...)
+
+
+//---------------------------------------------------------------------------
+
+
+typedef unsigned int        uint32;
+typedef int                 int32;
+typedef unsigned short int  uint16;
+typedef short int           int16;
+typedef float               float32;
+
+
+
+struct stMD3Header
+{
+    char        ID[4];          //  ID of the file is always "IDP3"
+    int32       Version;        //  Version number, usually 15
+    char        Filename[68];   //  Filename, sometimes left blank
+    int32       numBoneFrames;  //  Number of BoneFrames
+    int32       numTags;        //  Number of 'tags' per BoneFrame
+    int32       numMeshes;      //  Number of Meshes/Skins in MaxSkin
+    int32       numMaxSkins;    //  Maximum number of unique skins
+    int32       ofsFrames;      //  Always equal to the length this header
+    int32       ofsTagStart;    //  Starting position of tag structures
+    int32       ofMeshSurfaces; //  Ending position of tag structure
+    int32       ofEndOfFile;    //  Size of file
+};
+
+
+
+struct stBoneFrame
+{
+    float32 mins[3];
+    float32 maxs[3];
+    float32 Position[3];
+    float32 Scale;
+    char    Creator[16];
+};
+
+struct stAnim
+{
+    int32 FirstFrame;
+    int32 numFrames;
+    int32 LoopingFrames;
+    int32 FPS;
+};
+
+struct stSkin
+{
+    char Name[64];
+    int32 index;
+};
+
+struct stTag
+{
+    char            Name[64];
+    float32         Position[3];
+    float32         Rotation[3][3];
+};
+
+struct stTriangle
+{
+    int32 Vertex[3];
+};
+
+struct stTexCoord
+{
+    float32 Coord[2];
+};
+
+struct stVertex // = Record
+{
+    int16           Vertex[3];
+    unsigned char   Normal[2];
+};
+
+struct stMeshHeader
+{
+    char    ID[4];
+    char    Name[64];
+    int32   flags;
+    int32   numMeshFrames;
+    int32   numSkins;
+    int32   numVertexes;
+    int32   numTriangles;
+    int32   ofsTriangles;
+    int32   ofsSkins;
+    int32   ofsTexVector;
+    int32   ofsVertex;
+    int32   ofsEndMeshSize;
+};
+
+struct stMesh
+{
+    stMeshHeader    MeshHeader;
+    stSkin* pSkins;
+    stTriangle* pTriangle;
+    stTexCoord* pTexCoord;
+    stVertex* pVertex;
+};
+

model/sarge/animation.cfg

@@ -0,0 +1,40 @@
+// animation config file
+
+sex	m
+
+// first frame, num frames, looping frames, frames per second
+
+0	30	0	20		// BOTH_DEATH1
+29	1	0	20		// BOTH_DEAD1
+30	30	0	20		// BOTH_DEATH2
+59	1	0	20		// BOTH_DEAD2
+60	30	0	20		// BOTH_DEATH3
+89	1	0	20		// BOTH_DEAD3
+
+90	40	0	18		// TORSO_GESTURE
+
+130	6	0	15		// TORSO_ATTACK		(MUST NOT CHANGE -- hand animation is synced to this)
+136	6	0	15		// TORSO_ATTACK2	(MUST NOT CHANGE -- hand animation is synced to this)
+
+142	5	0	20		// TORSO_DROP		(MUST NOT CHANGE -- hand animation is synced to this)
+147	4	0	20		// TORSO_RAISE		(MUST NOT CHANGE -- hand animation is synced to this)
+
+151	1	0	15		// TORSO_STAND
+152	1	0	15		// TORSO_STAND2
+
+153	8	8	20		// LEGS_WALKCR
+161	12	12	20		// LEGS_WALK
+173	11	11	21		// LEGS_RUN
+184	10	10	20		// LEGS_BACK
+194	10	10	15		// LEGS_SWIM
+
+204	10	0	18		// LEGS_JUMP
+214	6	0	20		// LEGS_LAND
+
+220	8	0	15		// LEGS_JUMPB
+228	1	0	15		// LEGS_LANDB
+
+229	10	10	15		// LEGS_IDLE
+239	8	8	15		// LEGS_IDLECR
+
+247	7	7	15		// LEGS_TURN

model/sarge/head_default.skin

@@ -0,0 +1,3 @@
+tag_head,
+h_cigar,models/players/sarge/cigar.png
+h_head,models/players/sarge/band.png

model/sarge/lower_default.skin

@@ -0,0 +1,2 @@
+l_legs,models/players/sarge/band.png
+tag_torso,

model/sarge/upper_default.skin

@@ -0,0 +1,5 @@
+tag_head,
+tag_weapon,
+u_rshoulder,models/players/sarge/band.png
+u_torso,models/players/sarge/band.png
+tag_torso,