Created StaticMesh class

ChangeLog.md

@@ -2,6 +2,9 @@
 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20140621 ]
+    * Created StaticMesh class replacing model_mesh_t stuff
+
     [ 20140617 ]
     * Finally fixed SkeletalModel bugs introduced a month ago
       (animations and rotations are *mostly* correct now)

include/Game.h

@@ -53,10 +53,6 @@ private:
     void processModels();
     void processRooms();
 
-#ifdef EXPERIMENTAL
-    void setupTextureColor(texture_tri_t *r_tri, float *colorf);
-#endif
-
     char *mName;
     bool mLoaded;
 

include/Render.h

@@ -15,8 +15,6 @@
 #include "Texture.h"
 #include "ViewVolume.h"
 
-#include "WorldData.h"
-
 /*!
  * \brief OpenRaider Renderer class
  */
@@ -140,16 +138,7 @@ public:
 
     bool isVisible(BoundingBox &box);
 
-    /*!
-     * \brief Renders a mesh.
-     *
-     * Texture must be initialized.
-     * \param r_mesh Mesh to render.
-     */
-    void drawModelMesh(model_mesh_t *r_mesh);
-
     //! \fixme should be private
-
     ViewVolume mViewVolume; //!< View Volume for frustum culling
     Texture mTexture; //!< Texture subsystem
 
@@ -183,9 +172,6 @@ private:
      */
     void updateViewVolume();
 
-    //! \fixme Let them eat cake...? O.o
-    void tmpRenderModelMesh(model_mesh_t *r_mesh, texture_tri_t *ttri);
-
     std::vector<Room *> mRoomRenderList;
 
     unsigned int mFlags;                  //!< Rendering flags

include/StaticMesh.h

@@ -0,0 +1,57 @@
+/*!
+ * \file include/StaticMesh.h
+ * \brief Static Model Meshes
+ *
+ * \author xythobuz
+ */
+
+#ifndef _STATIC_MODEL_H_
+#define _STATIC_MODEL_H_
+
+#include <vector>
+#include "math/math.h"
+#include "TombRaider.h"
+
+class TexturedTriangle {
+public:
+    TexturedTriangle(int i[3], vec_t s[6], int tex, unsigned short trans);
+    bool operator< (TexturedTriangle &t);
+
+    void display(vec_t *vertices, vec_t *colors, vec_t *normals);
+
+private:
+    int index[3];
+    vec_t st[6];
+    int texture;
+    unsigned short transparency;
+};
+
+class StaticMesh {
+public:
+    StaticMesh(TombRaider &tr, unsigned int index);
+    ~StaticMesh();
+
+    void display();
+    vec_t getRadius();
+
+private:
+    bool dontshow;
+    vec3_t center;
+    vec_t radius;
+
+    unsigned int vertexCount;
+    unsigned int colorCount;
+    unsigned int normalCount;
+
+    vec_t *vertices;
+    vec_t *colors;
+    vec_t *normals;
+
+    std::vector<TexturedTriangle *> texturedTriangles;
+    std::vector<TexturedTriangle *> coloredTriangles;
+    std::vector<TexturedTriangle *> texturedRectangles;
+    std::vector<TexturedTriangle *> coloredRectangles;
+};
+
+#endif
+

include/World.h

@@ -16,8 +16,7 @@
 #include "Room.h"
 #include "SkeletalModel.h"
 #include "Sprite.h"
-
-#include "WorldData.h"
+#include "StaticMesh.h"
 
 /*!
  * \brief The game world (model)
@@ -51,13 +50,9 @@ public:
     unsigned int sizeSkeletalModel();
     SkeletalModel &getSkeletalModel(unsigned int index);
 
-    /*!
-     * \brief Adds mesh to world
-     * \param model mesh to add
-     */
-    void addMesh(model_mesh_t *model);
-
-    model_mesh_t *getMesh(int index);
+    void addStaticMesh(StaticMesh &model);
+    unsigned int sizeStaticMesh();
+    StaticMesh &getStaticMesh(unsigned int index);
 
     /*!
      * \brief Find room a location is in.
@@ -83,15 +78,11 @@ public:
     int getRoomByLocation(float x, float y, float z);
 
 private:
-
-    // Old World
-    std::vector<model_mesh_t *> mMeshes;     //!< Unanimated meshes
-
-    // New World
     std::vector<Room *> mRooms;
     std::vector<SpriteSequence *> mSprites;
     std::vector<Entity *> mEntities;
     std::vector<SkeletalModel *> mModels;
+    std::vector<StaticMesh *> mMeshes;
 };
 
 World &getWorld();

include/WorldData.h

@@ -1,45 +0,0 @@
-/*!
- * \file include/WorldData.h
- * \brief Structs and enums for the game world (model)
- *
- * \author Mongoose
- * \author xythobuz
- */
-
-#ifndef _WORLDDATA_H_
-#define _WORLDDATA_H_
-
-#include "math/math.h"
-
-/*! \fixme For now shaders are textures on tex objects
- * and materials on color objects. If -1
- * then it doesn't have that information yet.
- */
-typedef struct {
-    int index[3];
-    vec_t st[6];
-    int texture;
-    unsigned short transparency;
-} texture_tri_t;
-
-typedef struct {
-    std::vector<texture_tri_t *> texturedTriangles;
-    std::vector<texture_tri_t *> coloredTriangles;
-    std::vector<texture_tri_t *> texturedRectangles;
-    std::vector<texture_tri_t *> coloredRectangles;
-
-    vec3_t center;
-    float radius;
-
-    unsigned int vertexCount;
-    vec_t *vertices;
-
-    unsigned int colorCount;
-    vec_t *colors;
-
-    unsigned int normalCount;
-    vec_t *normals;
-} model_mesh_t;
-
-#endif
-

src/CMakeLists.txt

@@ -57,6 +57,7 @@ set (SRCS ${SRCS} "RoomData.cpp")
 set (SRCS ${SRCS} "SkeletalModel.cpp")
 set (SRCS ${SRCS} "Sound.cpp")
 set (SRCS ${SRCS} "Sprite.cpp")
+set (SRCS ${SRCS} "StaticMesh.cpp")
 set (SRCS ${SRCS} "Texture.cpp")
 set (SRCS ${SRCS} "TombRaider.cpp")
 set (SRCS ${SRCS} "ViewVolume.cpp")

src/Game.cpp

@@ -14,14 +14,11 @@
 #include "Game.h"
 #include "OpenRaider.h"
 #include "Sound.h"
+#include "StaticMesh.h"
 #include "utils/strings.h"
 
 #include "games/TombRaider1.h"
 
-#ifdef EXPERIMENTAL
-std::vector<unsigned int> gColorTextureHACK;
-#endif
-
 #ifdef MULTITEXTURE
 std::map<int, int> gMapTex2Bump;
 #endif
@@ -196,6 +193,13 @@ void Game::processRooms() {
     getConsole().print("Found %d rooms.", mTombRaider.NumRooms());
 }
 
+void Game::processModels() {
+    for (int index = 0; index < mTombRaider.getMeshCount(); index++)
+        getWorld().addStaticMesh(*new StaticMesh(mTombRaider, index));
+
+    getConsole().print("Found %d meshes.", mTombRaider.getMeshCount());
+}
+
 void Game::processPakSounds()
 {
     unsigned char *riff;
@@ -396,258 +400,3 @@ void Game::processMoveable(int index, int i, int object_id) {
                 (mTombRaider.Engine() == TR_VERSION_2));
 }
 
-bool compareFaceTextureId(const void *voidA, const void *voidB)
-{
-    texture_tri_t *a = (texture_tri_t *)voidA, *b = (texture_tri_t *)voidB;
-
-    if (!a || !b)
-        return false; // error really
-
-    return (a->texture < b->texture);
-}
-
-#ifdef EXPERIMENTAL
-void Game::setupTextureColor(texture_tri_t *r_tri, float *colorf)
-{
-    unsigned char color[4];
-    unsigned int colorI;
-
-    color[0] = (unsigned char)(colorf[0]*255.0f);
-    color[1] = (unsigned char)(colorf[1]*255.0f);
-    color[2] = (unsigned char)(colorf[2]*255.0f);
-    color[3] = (unsigned char)(colorf[3]*255.0f);
-
-    ((unsigned char *)(&colorI))[3] = color[0];
-    ((unsigned char *)(&colorI))[2] = color[1];
-    ((unsigned char *)(&colorI))[1] = color[2];
-    ((unsigned char *)(&colorI))[0] = color[3];
-
-    bool found = false;
-    unsigned int foundIndex = 0;
-    for (foundIndex = 0; foundIndex < gColorTextureHACK.size(); foundIndex++) {
-        if (gColorTextureHACK[foundIndex] == colorI) {
-            found = true;
-            break;
-        }
-    }
-    if (!found)
-    {
-        gColorTextureHACK.push_back(colorI);
-        r_tri->texture = mTextureOffset + gColorTextureHACK.size();
-
-        getRender().loadTexture(Texture::generateColorTexture(color, 32, 32),
-                32, 32, r_tri->texture);
-    }
-    else
-    {
-        //getConsole().print("Color already loaded %i -> 0x%08x",
-        //       gColorTextureHACK.getCurrentIndex(),
-        //       gColorTextureHACK.current());
-
-        r_tri->texture = mTextureOffset + foundIndex;
-    }
-
-    //r_tri->texture = white; // White texture
-}
-#endif
-
-void Game::processModels()
-{
-    for (int index = 0; index < mTombRaider.getMeshCount(); index++) {
-        int i, j, count, texture;
-        int vertexIndices[6];
-        float st[12];
-        float color[4];
-        unsigned short transparency;
-        texture_tri_t *r_tri;
-
-        // Assert common sense
-        if (index < 0 || !mTombRaider.isMeshValid(index))
-        {
-            //! \fixme allow sparse lists with matching ids instead?
-            getWorld().addMesh(NULL); // Filler, to make meshes array ids align
-            return;
-        }
-
-#ifndef EXPERIMENTAL
-        // WHITE texture id
-        int white = 0;
-#endif
-
-        model_mesh_t *mesh = new model_mesh_t;
-
-        // Mongoose 2002.08.30, Testing support for 'shootable' models ( traceable )
-        mTombRaider.getMeshCollisionInfo(index, mesh->center, &mesh->radius);
-
-        //! \fixme Arrays don't work either  =)
-        // Mesh geometery, colors, etc
-        mTombRaider.getMeshVertexArrays(index,
-                &mesh->vertexCount, &mesh->vertices,
-                &mesh->normalCount, &mesh->normals,
-                &mesh->colorCount,  &mesh->colors);
-
-        // Textured Triangles
-        count = mTombRaider.getMeshTexturedTriangleCount(index);
-        mesh->texturedTriangles.reserve(count); // little faster
-
-        for (i = 0; i < count; ++i)
-        {
-            r_tri = new texture_tri_t;
-
-            mTombRaider.getMeshTexturedTriangle(index, i,
-                    r_tri->index,
-                    r_tri->st,
-                    &r_tri->texture,
-                    &r_tri->transparency);
-
-            r_tri->texture += mTextureStart;
-
-            // Add to face vector
-            mesh->texturedTriangles.push_back(r_tri);
-        }
-
-        // Coloured Triangles
-        count = mTombRaider.getMeshColoredTriangleCount(index);
-        mesh->coloredTriangles.reserve(count); // little faster
-
-        for (i = 0; i < count; i++)
-        {
-            r_tri = new texture_tri_t;
-
-            mTombRaider.getMeshColoredTriangle(index, i,
-                    r_tri->index,
-                    color);
-            r_tri->st[0] = color[0];
-            r_tri->st[1] = color[1];
-            r_tri->st[2] = color[2];
-            r_tri->st[3] = color[3];
-            r_tri->st[4] = 1.0;
-            r_tri->st[5] = 1.0;
-
-#ifdef EXPERIMENTAL
-            setupTextureColor(r_tri, color);
-#else
-            r_tri->texture = white; // White texture
-#endif
-            r_tri->transparency = 0;
-
-            // Add to face vector
-            mesh->coloredTriangles.push_back(r_tri);
-        }
-
-        // Textured Rectangles
-        count = mTombRaider.getMeshTexturedRectangleCount(index);
-        mesh->texturedRectangles.reserve(count*2); // little faster
-
-        for (i = 0; i < count; ++i)
-        {
-            mTombRaider.getMeshTexturedRectangle(index, i,
-                    vertexIndices,
-                    st,
-                    &texture,
-                    &transparency);
-
-            r_tri = new texture_tri_t;
-
-            for (j = 0; j < 3; ++j)
-                r_tri->index[j] = vertexIndices[j];
-
-            for (j = 0; j < 6; ++j)
-                r_tri->st[j] = st[j];
-
-            r_tri->texture = texture + mTextureStart;
-            r_tri->transparency = transparency;
-
-            // Add to face vector
-            mesh->texturedRectangles.push_back(r_tri);
-
-            r_tri = new texture_tri_t;
-
-            for (j = 3; j < 6; ++j)
-                r_tri->index[j-3] = vertexIndices[j];
-
-            for (j = 6; j < 12; ++j)
-                r_tri->st[j-6] = st[j];
-
-            r_tri->texture = texture + mTextureStart;
-            r_tri->transparency = transparency;
-
-            // Add to face vector
-            mesh->texturedRectangles.push_back(r_tri);
-        }
-
-        // Coloured Rectangles
-        count = mTombRaider.getMeshColoredRectangleCount(index);
-        mesh->coloredRectangles.reserve(count*2); // little faster
-
-        for (i = 0; i < count; ++i)
-        {
-            mTombRaider.getMeshColoredRectangle(index, i,
-                    vertexIndices,
-                    color);
-
-            r_tri = new texture_tri_t;
-
-            for (j = 0; j < 3; ++j)
-                r_tri->index[j] = vertexIndices[j];
-
-            //for (j = 0; j < 6; ++j)
-            //  r_tri->st[j] = st[j];
-
-            r_tri->st[0] = color[0];
-            r_tri->st[1] = color[1];
-            r_tri->st[2] = color[2];
-            r_tri->st[3] = color[3];
-            r_tri->st[4] = 1.0;
-            r_tri->st[5] = 1.0;
-
-#ifdef EXPERIMENTAL
-            //for (j = 6; j < 12; ++j)
-            //  r_tri->st[j-6] = st[j];
-            setupTextureColor(r_tri, color);
-#else
-            r_tri->texture = white; // White texture
-#endif
-            r_tri->transparency = 0;
-
-            // Add to face vector
-            mesh->coloredRectangles.push_back(r_tri);
-
-            r_tri = new texture_tri_t;
-
-            for (j = 3; j < 6; ++j)
-                r_tri->index[j-3] = vertexIndices[j];
-
-            //for (j = 6; j < 12; ++j)
-            //  r_tri->st[j-6] = st[j];
-
-            r_tri->st[0] = color[0];
-            r_tri->st[1] = color[1];
-            r_tri->st[2] = color[2];
-            r_tri->st[3] = color[3];
-            r_tri->st[4] = 1.0;
-            r_tri->st[5] = 1.0;
-
-#ifdef EXPERIMENTAL
-            setupTextureColor(r_tri, color);
-#else
-            r_tri->texture = white; // White texture
-#endif
-            r_tri->transparency = 0;
-
-            // Add to face vector
-            mesh->coloredRectangles.push_back(r_tri);
-        }
-
-        // Sort faces by texture
-        std::sort(mesh->texturedTriangles.begin(), mesh->texturedTriangles.end(), compareFaceTextureId);
-        std::sort(mesh->coloredTriangles.begin(), mesh->coloredTriangles.end(), compareFaceTextureId);
-        std::sort(mesh->texturedRectangles.begin(), mesh->texturedRectangles.end(), compareFaceTextureId);
-        std::sort(mesh->coloredRectangles.begin(), mesh->coloredRectangles.end(), compareFaceTextureId);
-
-        getWorld().addMesh(mesh);
-    }
-
-    getConsole().print("Found %d meshes.", mTombRaider.getMeshCount());
-}
-

src/Render.cpp

@@ -655,170 +655,6 @@ void Render::drawSkyMesh(float scale)
 }
 
 
-void Render::tmpRenderModelMesh(model_mesh_t *r_mesh, texture_tri_t *ttri)
-{
-    glBegin(GL_TRIANGLES);
-
-    switch (mMode)
-    {
-        case modeSolid:
-        case modeVertexLight:
-            if (r_mesh->colors)
-            {
-                glColor3fv(r_mesh->colors+ttri->index[0]);
-                glTexCoord2fv(ttri->st);
-                glVertex3fv(r_mesh->vertices+ttri->index[0]*3);
-
-                glColor3fv(r_mesh->colors+ttri->index[1]);
-                glTexCoord2fv(ttri->st+2);
-                glVertex3fv(r_mesh->vertices+ttri->index[1]*3);
-
-                glColor3fv(r_mesh->colors+ttri->index[2]);
-                glTexCoord2fv(ttri->st+4);
-                glVertex3fv(r_mesh->vertices+ttri->index[2]*3);
-            }
-            else if (r_mesh->normals)
-            {
-                glNormal3fv(r_mesh->normals+ttri->index[0]*3);
-                glTexCoord2fv(ttri->st);
-                glVertex3fv(r_mesh->vertices+ttri->index[0]*3);
-
-                glNormal3fv(r_mesh->normals+ttri->index[1]*3);
-                glTexCoord2fv(ttri->st+2);
-                glVertex3fv(r_mesh->vertices+ttri->index[1]*3);
-
-                glNormal3fv(r_mesh->normals+ttri->index[2]*3);
-                glTexCoord2fv(ttri->st+4);
-                glVertex3fv(r_mesh->vertices+ttri->index[2]*3);
-            }
-            else
-            {
-                glTexCoord2fv(ttri->st);
-                glVertex3fv(r_mesh->vertices+ttri->index[0]*3);
-                glTexCoord2fv(ttri->st+2);
-                glVertex3fv(r_mesh->vertices+ttri->index[1]*3);
-                glTexCoord2fv(ttri->st+4);
-                glVertex3fv(r_mesh->vertices+ttri->index[2]*3);
-            }
-            break;
-        case modeWireframe:
-            glVertex3fv(r_mesh->vertices+ttri->index[0]*3);
-            glVertex3fv(r_mesh->vertices+ttri->index[1]*3);
-            glVertex3fv(r_mesh->vertices+ttri->index[2]*3);
-            break;
-        default:
-            glTexCoord2fv(ttri->st);
-            glVertex3fv(r_mesh->vertices+ttri->index[0]*3);
-            glTexCoord2fv(ttri->st+2);
-            glVertex3fv(r_mesh->vertices+ttri->index[1]*3);
-            glTexCoord2fv(ttri->st+4);
-            glVertex3fv(r_mesh->vertices+ttri->index[2]*3);
-    }
-
-    glEnd();
-}
-
-
-void Render::drawModelMesh(model_mesh_t *r_mesh)
-{
-    texture_tri_t *ttri;
-    int lastTexture = -1;
-
-    // If they pass NULL structs let it hang up - this is tmp
-
-    //! \fixme Duh, vis tests need to be put back
-    //if (!isVisible(r_mesh->center,    r_mesh->radius, r_mesh->bbox))
-    //{
-    //   return;
-    //}
-
-    //! \fixme 'AMBIENT' -- Mongoose 2002.01.08
-    glColor3fv(WHITE);
-
-    if (mMode == modeWireframe)
-        glColor3fv(WHITE);
-
-    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-    glBindTexture(GL_TEXTURE_2D, 1);  // White texture for colors
-
-    // Colored Triagles
-    for (unsigned int i = 0; i < r_mesh->coloredTriangles.size(); i++)
-    {
-        ttri = r_mesh->coloredTriangles[i];
-
-        if (!ttri)
-            continue;
-
-        if (mMode != modeWireframe && mMode != modeSolid &&
-                ttri->texture != lastTexture)
-        {
-            glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-            glBindTexture(GL_TEXTURE_2D, ttri->texture+1);
-            lastTexture = ttri->texture;
-        }
-
-        tmpRenderModelMesh(r_mesh, ttri);
-    }
-
-    // Colored Rectagles
-    for (unsigned int i = 0; i < r_mesh->coloredRectangles.size(); i++)
-    {
-        ttri = r_mesh->coloredRectangles[i];
-
-        if (!ttri)
-            continue;
-
-        if (mMode != modeWireframe && mMode != modeSolid &&
-                ttri->texture != lastTexture)
-        {
-            glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-            glBindTexture(GL_TEXTURE_2D, ttri->texture+1);
-            lastTexture = ttri->texture;
-        }
-
-        tmpRenderModelMesh(r_mesh, ttri);
-    }
-
-    // Textured Tris
-    for (unsigned int i = 0; i < r_mesh->texturedTriangles.size(); i++)
-    {
-        ttri = r_mesh->texturedTriangles[i];
-
-        if (!ttri)
-            continue;
-
-        if (mMode != modeWireframe && mMode != modeSolid &&
-                ttri->texture != lastTexture)
-        {
-            glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-            glBindTexture(GL_TEXTURE_2D, ttri->texture+1);
-            lastTexture = ttri->texture;
-        }
-
-        tmpRenderModelMesh(r_mesh, ttri);
-    }
-
-    // Textured Quads
-    for (unsigned int i = 0; i < r_mesh->texturedRectangles.size(); i++)
-    {
-        ttri = r_mesh->texturedRectangles[i];
-
-        if (!ttri)
-            continue;
-
-        if (mMode != modeWireframe && mMode != modeSolid &&
-                ttri->texture != lastTexture)
-        {
-            glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-            glBindTexture(GL_TEXTURE_2D, ttri->texture+1);
-            lastTexture = ttri->texture;
-        }
-
-        tmpRenderModelMesh(r_mesh, ttri);
-    }
-}
-
-
 void Render::setSkyMesh(int index, bool rot)
 {
     mSkyMesh = index;

src/RoomData.cpp

@@ -179,19 +179,15 @@ StaticModel::StaticModel(TombRaider &tr, unsigned int room, unsigned int i) {
 }
 
 void StaticModel::display() {
-    model_mesh_t *mesh = getWorld().getMesh(index);
+    StaticMesh &mesh = getWorld().getStaticMesh(index);
 
-    if (!mesh)
-        return;
-
-    if (!getRender().isVisible(pos[0], pos[1], pos[2], mesh->radius))
+    if (!getRender().isVisible(pos[0], pos[1], pos[2], mesh.getRadius()))
         return;
 
     glPushMatrix();
     glTranslated(pos[0], pos[1], pos[2]);
     glRotated(yaw, 0, 1, 0);
-
-    getRender().drawModelMesh(mesh);
+    mesh.display();
     glPopMatrix();
 }
 

src/SkeletalModel.cpp

@@ -49,7 +49,7 @@ BoneTag::BoneTag(TombRaider &tr, unsigned int index, unsigned int i, unsigned in
 }
 
 void BoneTag::display() {
-    getRender().drawModelMesh(getWorld().getMesh(mesh));
+    getWorld().getStaticMesh(mesh).display();
 }
 
 void BoneTag::getOffset(vec3_t o) {
@@ -332,15 +332,15 @@ void SkeletalModel::display(unsigned int aframe, unsigned int bframe) {
                     if (pigtails) {
                         glPushMatrix();
                         glTranslatef(ponyOff2, 0.0, 0.0);
-                        getRender().drawModelMesh(getWorld().getMesh(ponytailMeshId + i));
+                        getWorld().getStaticMesh(ponytailMeshId + i).display();
                         glPopMatrix();
 
                         glPushMatrix();
                         glTranslatef(-ponyOff2, 0.0, 0.0);
-                        getRender().drawModelMesh(getWorld().getMesh(ponytailMeshId + i));
+                        getWorld().getStaticMesh(ponytailMeshId + i).display();
                         glPopMatrix();
                     } else {
-                        getRender().drawModelMesh(getWorld().getMesh(ponytailMeshId + i));
+                        getWorld().getStaticMesh(ponytailMeshId + i).display();
                     }
                 }
 

src/StaticMesh.cpp

@@ -0,0 +1,300 @@
+/*!
+ * \file src/StaticMesh.cpp
+ * \brief Static Model Meshes
+ *
+ * \author xythobuz
+ */
+
+#include "global.h"
+#include "Game.h"
+#include "Render.h"
+#include "StaticMesh.h"
+
+#ifdef EXPERIMENTAL
+std::vector<unsigned int> gColorTextureHACK;
+#endif
+
+TexturedTriangle::TexturedTriangle(int i[3], vec_t s[6], int tex, unsigned short trans) {
+    index[0] = i[0];
+    index[1] = i[1];
+    index[2] = i[2];
+    st[0] = s[0];
+    st[1] = s[1];
+    st[2] = s[2];
+    st[3] = s[3];
+    st[4] = s[4];
+    st[5] = s[5];
+    texture = tex;
+    transparency = trans;
+}
+
+bool TexturedTriangle::operator< (TexturedTriangle &t) {
+    return texture < t.texture;
+}
+
+void TexturedTriangle::display(vec_t *vertices, vec_t *colors, vec_t *normals) {
+    assert(vertices != NULL);
+
+    if ((getRender().getMode() != Render::modeWireframe)
+            && (getRender().getMode() != Render::modeSolid)) {
+        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+        glBindTexture(GL_TEXTURE_2D, texture + 1);
+    }
+
+    glBegin(GL_TRIANGLES);
+
+    switch (getRender().getMode()) {
+        case Render::modeSolid:
+        case Render::modeVertexLight:
+            if (colors != NULL) {
+                glColor3fv(colors + index[0]);
+                glTexCoord2fv(st);
+                glVertex3fv(vertices + (index[0] * 3));
+
+                glColor3fv(colors + index[1]);
+                glTexCoord2fv(st + 2);
+                glVertex3fv(vertices + (index[1] * 3));
+
+                glColor3fv(colors + index[2]);
+                glTexCoord2fv(st + 4);
+                glVertex3fv(vertices + (index[2] * 3));
+            } else if (normals != NULL) {
+                glNormal3fv(normals + (index[0] * 3));
+                glTexCoord2fv(st);
+                glVertex3fv(vertices + (index[0] * 3));
+
+                glNormal3fv(normals + (index[1] * 3));
+                glTexCoord2fv(st + 2);
+                glVertex3fv(vertices + (index[1] * 3));
+
+                glNormal3fv(normals + (index[2] * 3));
+                glTexCoord2fv(st + 4);
+                glVertex3fv(vertices + (index[2] * 3));
+            } else {
+                glTexCoord2fv(st);
+                glVertex3fv(vertices + (index[0] * 3));
+                glTexCoord2fv(st + 2);
+                glVertex3fv(vertices + (index[1] * 3));
+                glTexCoord2fv(st + 4);
+                glVertex3fv(vertices + (index[2] * 3));
+            }
+            break;
+
+        case Render::modeWireframe:
+            glVertex3fv(vertices + (index[0] * 3));
+            glVertex3fv(vertices + (index[1] * 3));
+            glVertex3fv(vertices + (index[2] * 3));
+            break;
+
+        default:
+            glTexCoord2fv(st);
+            glVertex3fv(vertices + (index[0] * 3));
+            glTexCoord2fv(st + 2);
+            glVertex3fv(vertices + (index[1] * 3));
+            glTexCoord2fv(st + 4);
+            glVertex3fv(vertices + (index[2] * 3));
+    }
+
+    glEnd();
+}
+
+#ifdef EXPERIMENTAL
+int setupTextureColor(float *colorf) {
+    unsigned char color[4];
+    unsigned int colorI;
+    int texture;
+
+    color[0] = (unsigned char)(colorf[0]*255.0f);
+    color[1] = (unsigned char)(colorf[1]*255.0f);
+    color[2] = (unsigned char)(colorf[2]*255.0f);
+    color[3] = (unsigned char)(colorf[3]*255.0f);
+
+    ((unsigned char *)(&colorI))[3] = color[0];
+    ((unsigned char *)(&colorI))[2] = color[1];
+    ((unsigned char *)(&colorI))[1] = color[2];
+    ((unsigned char *)(&colorI))[0] = color[3];
+
+    bool found = false;
+    unsigned int foundIndex = 0;
+    for (foundIndex = 0; foundIndex < gColorTextureHACK.size(); foundIndex++) {
+        if (gColorTextureHACK[foundIndex] == colorI) {
+            found = true;
+            break;
+        }
+    }
+
+    if (!found) {
+        gColorTextureHACK.push_back(colorI);
+        texture = getGame().getTextureOffset() + gColorTextureHACK.size();
+
+        getRender().loadTexture(Texture::generateColorTexture(color, 32, 32),
+                32, 32, texture);
+    } else {
+        texture = getGame().getTextureOffset() + foundIndex;
+    }
+
+    return texture;
+}
+#endif
+
+StaticMesh::StaticMesh(TombRaider &tr, unsigned int index) {
+    int count, texture;
+    int vertexIndices[6];
+    float st[12];
+    float color[4];
+    unsigned short transparency;
+
+    if (!tr.isMeshValid(index)) {
+        dontshow = true;
+        return;
+    } else {
+        dontshow = false;
+    }
+
+    // Mongoose 2002.08.30, Testing support for 'shootable' models ( traceable )
+    tr.getMeshCollisionInfo(index, center, &radius);
+
+    //! \fixme Arrays don't work either  =)
+    // Mesh geometery, colors, etc
+    tr.getMeshVertexArrays(index,
+            &vertexCount, &vertices,
+            &normalCount, &normals,
+            &colorCount,  &colors);
+
+    // Textured Triangles
+    count = tr.getMeshTexturedTriangleCount(index);
+    for (int i = 0; i < count; i++) {
+        tr.getMeshTexturedTriangle(index, i,
+                vertexIndices, st,
+                &texture, &transparency);
+        texturedTriangles.push_back(
+                new TexturedTriangle(vertexIndices, st, texture + getGame().getTextureStart(), transparency));
+    }
+
+    // Coloured Triangles
+    count = tr.getMeshColoredTriangleCount(index);
+    for (int i = 0; i < count; i++) {
+        tr.getMeshColoredTriangle(index, i,
+                vertexIndices, color);
+        st[0] = color[0];
+        st[1] = color[1];
+        st[2] = color[2];
+        st[3] = color[3];
+        st[4] = 1.0;
+        st[5] = 1.0;
+
+#ifdef EXPERIMENTAL
+        texture = setupTextureColor(color);
+#else
+        texture = 0; // White texture
+#endif
+        transparency = 0;
+
+        coloredTriangles.push_back(
+                new TexturedTriangle(vertexIndices, st, texture + getGame().getTextureStart(), transparency));
+    }
+
+    // Textured Rectangles
+    count = tr.getMeshTexturedRectangleCount(index);
+    for (int i = 0; i < count; i++) {
+        tr.getMeshTexturedRectangle(index, i,
+                vertexIndices, st,
+                &texture, &transparency);
+        texturedRectangles.push_back(
+                new TexturedTriangle(vertexIndices, st, texture + getGame().getTextureStart(), transparency));
+        texturedRectangles.push_back(
+                new TexturedTriangle(vertexIndices + 3, st + 6, texture + getGame().getTextureStart(), transparency));
+    }
+
+    // Coloured Rectangles
+    count = tr.getMeshColoredRectangleCount(index);
+    for (int i = 0; i < count; i++) {
+        tr.getMeshColoredRectangle(index, i,
+                vertexIndices, color);
+
+        st[0] = color[0];
+        st[1] = color[1];
+        st[2] = color[2];
+        st[3] = color[3];
+        st[4] = 1.0;
+        st[5] = 1.0;
+
+#ifdef EXPERIMENTAL
+        texture = setupTextureColor(color);
+#else
+        texture = 0; // White texture
+#endif
+        transparency = 0;
+
+        coloredRectangles.push_back(
+                new TexturedTriangle(vertexIndices, st, texture + getGame().getTextureStart(), transparency));
+        coloredRectangles.push_back(
+                new TexturedTriangle(vertexIndices + 3, st, texture + getGame().getTextureStart(), transparency));
+    }
+
+    // Sort faces by texture
+    std::sort(texturedTriangles.begin(), texturedTriangles.end());
+    std::sort(coloredTriangles.begin(), coloredTriangles.end());
+    std::sort(texturedRectangles.begin(), texturedRectangles.end());
+    std::sort(coloredRectangles.begin(), coloredRectangles.end());
+}
+
+StaticMesh::~StaticMesh() {
+    while (!texturedTriangles.empty()) {
+        delete texturedTriangles.back();
+        texturedTriangles.pop_back();
+    }
+
+    while (!coloredTriangles.empty()) {
+        delete coloredTriangles.back();
+        coloredTriangles.pop_back();
+    }
+
+    while (!texturedRectangles.empty()) {
+        delete texturedRectangles.back();
+        texturedRectangles.pop_back();
+    }
+
+    while (!coloredRectangles.empty()) {
+        delete coloredRectangles.back();
+        coloredRectangles.pop_back();
+    }
+
+    delete [] vertices;
+    delete [] normals;
+    delete [] colors;
+}
+
+void StaticMesh::display() {
+    if (!dontshow) {
+        //! \fixme Duh, vis tests need to be put back
+        //if (!isVisible(center, radius, bbox))
+        //   return;
+
+        //! \fixme 'AMBIENT' -- Mongoose 2002.01.08
+        glColor3fv(WHITE);
+
+        if (getRender().getMode() == Render::modeWireframe)
+            glColor3fv(WHITE);
+
+        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+        glBindTexture(GL_TEXTURE_2D, 1);  // White texture for colors
+
+        for (unsigned int i = 0; i < coloredTriangles.size(); i++)
+            coloredTriangles.at(i)->display(vertices, colors, normals);
+
+        for (unsigned int i = 0; i < coloredRectangles.size(); i++)
+            coloredRectangles.at(i)->display(vertices, colors, normals);
+
+        for (unsigned int i = 0; i < texturedTriangles.size(); i++)
+            texturedTriangles.at(i)->display(vertices, colors, normals);
+
+        for (unsigned int i = 0; i < texturedRectangles.size(); i++)
+            texturedRectangles.at(i)->display(vertices, colors, normals);
+    }
+}
+
+vec_t StaticMesh::getRadius() {
+    return radius;
+}
+

src/World.cpp

@@ -15,19 +15,6 @@ World::~World() {
     destroy();
 }
 
-// Temp methods for rendering use until more refactoring is done
-model_mesh_t *World::getMesh(int index)
-{
-    return mMeshes[index];
-}
-
-void World::addMesh(model_mesh_t *mesh)
-{
-    if (mesh)
-        mMeshes.push_back(mesh);
-}
-
-
 void World::addRoom(Room &room) {
     mRooms.push_back(&room);
 }
@@ -80,6 +67,19 @@ SkeletalModel &World::getSkeletalModel(unsigned int index) {
     return *mModels.at(index);
 }
 
+void World::addStaticMesh(StaticMesh &model) {
+    mMeshes.push_back(&model);
+}
+
+unsigned int World::sizeStaticMesh() {
+    return mMeshes.size();
+}
+
+StaticMesh &World::getStaticMesh(unsigned int index) {
+    assert(index < mMeshes.size());
+    return *mMeshes.at(index);
+}
+
 
 int World::getRoomByLocation(int index, float x, float y, float z)
 {
@@ -111,59 +111,24 @@ int World::getRoomByLocation(float x, float y, float z) {
 
 
 void World::destroy() {
-    for (unsigned int i = 0; i != mRooms.size(); i++)
+    for (unsigned int i = 0; i < mRooms.size(); i++)
         delete mRooms[i];
     mRooms.clear();
 
-    for (unsigned int i = 0; i != mSprites.size(); i++)
+    for (unsigned int i = 0; i < mSprites.size(); i++)
         delete mSprites[i];
     mSprites.clear();
 
-    for (unsigned int i = 0; i != mEntities.size(); i++)
+    for (unsigned int i = 0; i < mEntities.size(); i++)
         delete mEntities[i];
     mEntities.clear();
 
-    for (unsigned int i = 0; i != mModels.size(); i++)
+    for (unsigned int i = 0; i < mModels.size(); i++)
         delete mModels[i];
     mModels.clear();
 
-    for (std::vector<int>::size_type i = 0; i != mMeshes.size(); i++) {
-        model_mesh_t *mesh = mMeshes[i];
-
-        if (!mesh)
-            continue;
-
-        for (std::vector<int>::size_type j = 0; j != mesh->texturedTriangles.size(); j++) {
-            if (mesh->texturedTriangles[j])
-                delete mesh->texturedTriangles[j];
-        }
-
-        for (std::vector<int>::size_type j = 0; j != mesh->coloredTriangles.size(); j++) {
-            if (mesh->coloredTriangles[j])
-                delete mesh->coloredTriangles[j];
-        }
-
-        for (std::vector<int>::size_type j = 0; j != mesh->texturedRectangles.size(); j++) {
-            if (mesh->texturedRectangles[j])
-                delete mesh->texturedRectangles[j];
-        }
-
-        for (std::vector<int>::size_type j = 0; j != mesh->coloredRectangles.size(); j++) {
-            if (mesh->coloredRectangles[j])
-                delete mesh->coloredRectangles[j];
-        }
-
-        if (mesh->vertices)
-            delete [] mesh->vertices;
-
-        if (mesh->colors)
-            delete [] mesh->colors;
-
-        if (mesh->normals)
-            delete [] mesh->normals;
-
-        delete mesh;
-    }
+    for (unsigned int i = 0; i < mMeshes.size(); i++)
+        delete mMeshes[i];
     mMeshes.clear();
 }