ObjLevel.cpp

Go to the documentation of this file.

#include "ObjLevel.h"

ObjLevel::ObjLevel(LevelInfo &lvl, Renderer *renderer) {
        m_wallVertices = NULL;
        m_floorVertices = NULL;
        m_shadowVertices = NULL;
        m_waterVertices = NULL;
        m_waterSurface = NULL;
        mp_lvl = &lvl;
        mp_renderer = renderer;
        m_nSpawnpools = 0;
}

bool ObjLevel::load() {
        Set <Vertex> wallVertices;
        Set <Vertex> floorVertices;
        Set <Vert> shadowVertices;
        Set <Vert> shadowVerticesFinal;
        Set <Vertex> waterVertices;
        Set <Vertex> waterSurfaceVertices;
        int wallIndex = 0;
        int floorIndex = 0;
        int shadowIndex = 0;
        int shadowIndexFinal = 0;
        int waterIndex = 0;
        waterSurfaceIndex = 0;
        m_numObjects = 0;
        m_nExtras = 0;
        m_nSpawnpools = 0;

        int size = mp_lvl->width*mp_lvl->height*3;
        int x = 0, y = 0;
        unsigned char *d = mp_lvl->data;
        unsigned int i;

        for (i=0; i<mp_lvl->numModels; i++) {
                m_models[i].loadFromAsciiFile(mp_lvl->modelsPath, mp_lvl->models[i]);
        }


        for (i=0; i<size; i+=3) {

                // ========== WALL ==========
                if (isWall(&d[i])) {

                        // add ALL walls and remove, or check first time?

                        if (x > 0) {
                                if (!isWall(&d[i-3])) {
                                        wallVertices.add(newVertex(0.0f, 0.0f,  -1.0f, 0.0f, 0.0f,      -0.5f+x, 0.0f,-0.5f+y));
                                        wallVertices.add(newVertex(0.0f, 1.0f,  -1.0f, 0.0f, 0.0f,      -0.5f+x, 1.0f,-0.5f+y));
                                        wallVertices.add(newVertex(1.0f, 1.0f,  -1.0f, 0.0f, 0.0f,      -0.5f+x, 1.0f, 0.5f+y));
                                        wallVertices.add(newVertex(1.0f, 0.0f,  -1.0f, 0.0f, 0.0f,      -0.5f+x, 0.0f, 0.5f+y));
                                        wallIndex += 4;

                                        // add wall to LEFT side
                                        //LOG_MISC(("Do wall LEFT, %d %d",x,y));
                                }
                        }

                        if (x < mp_lvl->width-1) {
                                if (!isWall(&d[i+3])) {
                                        wallVertices.add(newVertex(0.0f, 0.0f,   1.0f, 0.0f, 0.0f,       0.5f+x, 0.0f, 0.5f+y));
                                        wallVertices.add(newVertex(0.0f, 1.0f,   1.0f, 0.0f, 0.0f,       0.5f+x, 1.0f, 0.5f+y));
                                        wallVertices.add(newVertex(1.0f, 1.0f,   1.0f, 0.0f, 0.0f,       0.5f+x, 1.0f,-0.5f+y));
                                        wallVertices.add(newVertex(1.0f, 0.0f,   1.0f, 0.0f, 0.0f,       0.5f+x, 0.0f,-0.5f+y));
                                        wallIndex += 4;

                                        // add wall to RIGHT side
                                        //LOG_MISC(("Do wall RIGHT, %d %d",x,y));
                                }
                        }

                        if (y > 0) {
                                if (!isWall(&d[i-mp_lvl->width*3])) {
                                        wallVertices.add(newVertex(0.0f, 0.0f,   0.0f, 0.0f, 1.0f,       0.5f+x, 0.0f,-0.5f+y));
                                        wallVertices.add(newVertex(0.0f, 1.0f,   0.0f, 0.0f, 1.0f,       0.5f+x, 1.0f,-0.5f+y));
                                        wallVertices.add(newVertex(1.0f, 1.0f,   0.0f, 0.0f, 1.0f,      -0.5f+x, 1.0f,-0.5f+y));
                                        wallVertices.add(newVertex(1.0f, 0.0f,   0.0f, 0.0f, 1.0f,      -0.5f+x, 0.0f,-0.5f+y));
                                        wallIndex += 4;

                                        // add wall to TOP side
                                        //LOG_MISC(("Do wall TOP, %d %d",x,y));
                                }
                        }

                        if (y < mp_lvl->height-1) {
                                if (!isWall(&d[i+mp_lvl->width*3])) {
                                        wallVertices.add(newVertex(0.0f, 0.0f,   0.0f, 0.0f, -1.0f,     -0.5f+x, 0.0f, 0.5f+y));
                                        wallVertices.add(newVertex(0.0f, 1.0f,   0.0f, 0.0f, -1.0f,     -0.5f+x, 1.0f, 0.5f+y));
                                        wallVertices.add(newVertex(1.0f, 1.0f,   0.0f, 0.0f, -1.0f,      0.5f+x, 1.0f, 0.5f+y));
                                        wallVertices.add(newVertex(1.0f, 0.0f,   0.0f, 0.0f, -1.0f,      0.5f+x, 0.0f, 0.5f+y));
                                        wallIndex += 4;

                                        // add wall to BOTTOM side
                                        //LOG_MISC(("Do wall BOTTOM, %d %d",x,y));
                                }
                        }

                }

                // ========== FLOOR ==========
                else if (isColor(&d[i], 15) || isColor(&d[i], 14)) {
                        floorVertices.add(newVertex(0.0f, 0.0f, 0.0f, 1.0f, 0.0f,       -0.5f+x, 0.0f, 0.5f+y));
                        floorVertices.add(newVertex(0.0f, 1.0f, 0.0f, 1.0f, 0.0f,       -0.5f+x, 0.0f,-0.5f+y));
                        floorVertices.add(newVertex(1.0f, 1.0f, 0.0f, 1.0f, 0.0f,        0.5f+x, 0.0f,-0.5f+y));
                        floorVertices.add(newVertex(1.0f, 0.0f, 0.0f, 1.0f, 0.0f,        0.5f+x, 0.0f, 0.5f+y));
                        floorIndex += 4;

                        // ========== SPAWN POOL ==========
                        if (isSpawnPool(&d[i])) {
                                if (m_nSpawnpools < MAX_SPAWNPOOLS) {
                                        m_spawnpools[m_nSpawnpools].x = (float)x;
                                        m_spawnpools[m_nSpawnpools].y = 0.0f;
                                        m_spawnpools[m_nSpawnpools].z = (float)y;
                                        m_nSpawnpools++;
                                }
                        }
                        // ========== EXTRAS ==========
                        else if (d[i+2] == 140) {
                                if (m_nExtras < MAX_EXTRAS) {
                                        m_extras[m_nExtras].x = (float)x;
                                        m_extras[m_nExtras].y = 0.0f;
                                        m_extras[m_nExtras].z = (float)y;
                                        m_nExtras++;
                                }
                        }

                        // ========== OBJECT 0 ==========
                        else if (d[i+1] == 240) {
                                if (m_numObjects < MAX_LEVEL_OBJECTS) {
                                        //LOG_MISC(("LEVEL OBJ #%d type 0 added", m_numObjects));
                                        m_objects[m_numObjects].alive = true;
                                        m_objects[m_numObjects].x = (float)x;
                                        m_objects[m_numObjects].y = 0.0f;
                                        m_objects[m_numObjects].z = (float)y;
                                        m_objects[m_numObjects].model = 0;
                                        m_numObjects++;
                                }
                        }
                        // ========== OBJECT 1 ==========
                        else if (d[i+1] == 140) {
                                if (m_numObjects < MAX_LEVEL_OBJECTS) {
                                        //LOG_MISC(("LEVEL OBJ #%d type 1 added", m_numObjects));
                                        m_objects[m_numObjects].alive = true;
                                        m_objects[m_numObjects].x = x;
                                        m_objects[m_numObjects].y = 0.0f;
                                        m_objects[m_numObjects].z = y;
                                        m_objects[m_numObjects].model = 1;
                                        m_numObjects++;
                                }
                        }

                }

                // ========== WATER ==========
                else if (isColor(&d[i], 0, 0,  240)) {
                        bool left = false, right = false, top = false, bottom = false;
                        Vec3 tuu, tuv, tvv, tvu;
                        tuu = Vec3(0.0f, 1.0f, 0.0f);
                        tuv = Vec3(0.0f, 1.0f, 0.0f);
                        tvv = Vec3(0.0f, 1.0f, 0.0f);
                        tvu = Vec3(0.0f, 1.0f, 0.0f);

                        // left
                        if (x > 0) {
                                if (!isColor(&d[i-3], 0, 0, 240)) {
                                        left = true;
                                        if (x < mp_lvl->width-1) {
                                                // top
                                                if (y > 0) {
                                                        if (!isColor(&d[i-mp_lvl->width*3], 0, 0,  240)) {
                                                                tuv = Vec3(0.333333f, 0.333333f, 0.333333f);
                                                        }
                                                }

                                                // bottom
                                                if (y < mp_lvl->height-1) {
                                                        if (!isColor(&d[i+mp_lvl->width*3], 0, 0,  240))
                                                                tuu = Vec3(0.333333f, 0.333333f,-0.333333f);
                                                }
                                        }
                                }
                        }

                        // right
                        if (x < mp_lvl->width-1) {
                                if (!isColor(&d[i+3], 0, 0,  240)) {
                                        right = true;

                                        if (x > 0) {
                                                // top
                                                if (y > 0) {
                                                        if (!isColor(&d[i-mp_lvl->width*3], 0, 0,  240))
                                                                tvv = Vec3(-0.333333f, 0.333333f, 0.333333f);
                                                }

                                                // bottom
                                                if (y < mp_lvl->height-1) {
                                                        if (!isColor(&d[i+mp_lvl->width*3], 0, 0,  240))
                                                                tvu = Vec3(-0.333333f, 0.333333f,-0.333333f);
                                                }
                                        }
                                }
                        }

                        // top
                        if (y > 0) {
                                if (!isColor(&d[i-mp_lvl->width*3], 0, 0,  240)) {
                                        top = true;

                                        if (y < mp_lvl->width) {
                                                // left
                                                if (x > 0) {
                                                        if (!isColor(&d[i-3], 0, 0,  240))
                                                                tuv = Vec3(0.333333f, 0.333333f, 0.333333f);
                                                }

                                                // right
                                                if (x < mp_lvl->width-1) {
                                                        if (!isColor(&d[i+3], 0, 0,  240))
                                                                tvv = Vec3(-0.333333f, 0.333333f,0.333333f);
                                                }
                                        }
                                }
                        }

                        // bottom
                        if (y < mp_lvl->height-1) {
                                if (!isColor(&d[i+mp_lvl->width*3], 0, 0,  240)) {
                                        bottom = true;

                                        if (y < mp_lvl->width) {
                                                // left
                                                if (x > 0) {
                                                        if (!isColor(&d[i-3], 0, 0,  240))
                                                                tuu = Vec3(0.333333f, 0.333333f,-0.333333f);
                                                }

                                                // right
                                                if (x < mp_lvl->width-1) {
                                                        if (!isColor(&d[i+3], 0, 0,  240))
                                                                tvu = Vec3(-0.333333f, 0.333333f,-0.333333f);
                                                }
                                        }
                                }
                        }


                        if (left) {
                                waterVertices.add(newVertex(0.25f, 0.25f,       tuu.x, tuu.y, tuu.z,    -0.5f+x,-0.5f, 0.5f+y));
                                waterVertices.add(newVertex(0.0f, 0.25f,        0.5f, 0.5f, 0.0f,               -0.5f+x, 0.0f, 0.5f+y));
                                waterVertices.add(newVertex(0.0f, 0.75f,        0.5f, 0.5f, 0.0f,               -0.5f+x, 0.0f,-0.5f+y));
                                waterVertices.add(newVertex(0.25f, 0.75f,       tuv.x, tuv.y, tuv.z,    -0.5f+x,-0.5f,-0.5f+y));
                                waterIndex += 4;
                        }

                        if (right) {
                                waterVertices.add(newVertex(0.75f, 0.75f,       tvv.x, tvv.y, tvv.z,     0.5f+x,-0.5f,-0.5f+y));
                                waterVertices.add(newVertex(1.0f, 0.75f,        -0.5f, 0.5f, 0.0f,       0.5f+x, 0.0f,-0.5f+y));
                                waterVertices.add(newVertex(1.0f, 0.25f,        -0.5f, 0.5f, 0.0f,       0.5f+x, 0.0f, 0.5f+y));
                                waterVertices.add(newVertex(0.75f, 0.25f,       tvu.x, tvu.y, tvu.z,     0.5f+x,-0.5f, 0.5f+y));
                                waterIndex += 4;
                        }

                        if (top) {
                                waterVertices.add(newVertex(0.25f, 0.75f,       tuv.x, tuv.y, tuv.z,    -0.5f+x,-0.5f,-0.5f+y));
                                waterVertices.add(newVertex(0.25f, 1.0f,        0.0f, 0.5f, 0.5f,               -0.5f+x, 0.0f,-0.5f+y));
                                waterVertices.add(newVertex(0.75f, 1.0f,        0.0f, 0.5f, 0.5f,                0.5f+x, 0.0f,-0.5f+y));
                                waterVertices.add(newVertex(0.75f, 0.75f,       tvv.x, tvv.y, tvv.z,     0.5f+x,-0.5f,-0.5f+y));
                                waterIndex += 4;
                        }

                        if (bottom) {
                                waterVertices.add(newVertex(0.75f, 0.25f,       tvu.x, tvu.y, tvu.z,     0.5f+x,-0.5f, 0.5f+y));
                                waterVertices.add(newVertex(0.75f, 0.0f,        0.0f, 0.5f, -0.5f,       0.5f+x, 0.0f, 0.5f+y));
                                waterVertices.add(newVertex(0.25f, 0.0f,        0.0f, 0.5f, -0.5f,      -0.5f+x, 0.0f, 0.5f+y));
                                waterVertices.add(newVertex(0.25f, 0.25f,       tuu.x, tuu.y, tuu.z,    -0.5f+x,-0.5f, 0.5f+y));
                                waterIndex += 4;
                        }

                        waterVertices.add(newVertex(0.25f, 0.25f,       tuu.x, tuu.y, tuu.z,            -0.5f+x,-0.5f, 0.5f+y));
                        waterVertices.add(newVertex(0.25f, 0.75f,       tuv.x, tuv.y, tuv.z,            -0.5f+x,-0.5f,-0.5f+y));
                        waterVertices.add(newVertex(0.75f, 0.75f,       tvv.x, tvv.y, tvv.z,             0.5f+x,-0.5f,-0.5f+y));
                        waterVertices.add(newVertex(0.75f, 0.25f,       tvu.x, tvu.y, tvu.z,             0.5f+x,-0.5f, 0.5f+y));

                        waterIndex += 4;

                        waterSurfaceVertices.add(newVertex(0.0f, 0.0f,  tuu.x, tuu.y, tuu.z,    -0.5f+x,-0.3f, 0.5f+y));
                        waterSurfaceVertices.add(newVertex(0.0f, 1.0f,  tuv.x, tuv.y, tuv.z,    -0.5f+x,-0.3f,-0.5f+y));
                        waterSurfaceVertices.add(newVertex(1.0f, 1.0f,  tvv.x, tvv.y, tvv.z,     0.5f+x,-0.3f,-0.5f+y));
                        waterSurfaceVertices.add(newVertex(1.0f, 0.0f,  tvu.x, tvu.y, tvu.z,     0.5f+x,-0.3f, 0.5f+y));
                        waterSurfaceIndex += 4;
                }



                x++;
                if (x == mp_lvl->width) {
                        x = 0;
                        y++;
                }

        }


        //LOG_MISC(("Spawnpools: %d", m_nSpawnpools));

        // ========== WALL ==========
        if (wallIndex > 0) {
                //LOG_MISC(("wallIndex: %d (%d polygons)", wallIndex, wallIndex/4));
                m_wallVertices = new Vertex[wallIndex];
                memcpy(m_wallVertices, wallVertices.getArray(), sizeof(Vertex)*wallIndex);

                m_walls = new OpenGLObject();
                m_walls->addFormat(ATT_VERTEX, ATT_FLOAT, 3, sizeof(float)*5);
                m_walls->addFormat(ATT_NORMAL, ATT_FLOAT, 3, sizeof(float)*2);
                m_walls->addFormat(ATT_TEX, ATT_FLOAT, 2, 0);
                m_walls->setPrimitive(PRIM_QUADS);
                m_walls->setVertices(m_wallVertices, wallIndex, sizeof(Vertex));

                //LOG_SUCCESS(("Object level walls loaded"));


                // ===== calculate SHADOW VOLUMES =====
                //lvl.lights[0].pos = Vec3(10.0f, 10.0f, 60.0f);        // remove this later
                Vec3 lPos = mp_lvl->lights[0].pos;

                for (int i=0; i<wallIndex; i+=4) {
                        float dist = dot(Vec3(m_wallVertices[i].nx, m_wallVertices[i].ny, m_wallVertices[i].nz), lPos);
                        // do not face light
                        if (dist >= 0.0f) {
                                Vec3 v0 = (Vec3(m_wallVertices[i+0].vx, m_wallVertices[i+0].vy, m_wallVertices[i+0].vz)-lPos)*100.0f;
                                Vec3 v1 = (Vec3(m_wallVertices[i+1].vx, m_wallVertices[i+1].vy, m_wallVertices[i+1].vz)-lPos)*100.0f;
                                Vec3 v2 = (Vec3(m_wallVertices[i+2].vx, m_wallVertices[i+2].vy, m_wallVertices[i+2].vz)-lPos)*100.0f;
                                Vec3 v3 = (Vec3(m_wallVertices[i+3].vx, m_wallVertices[i+3].vy, m_wallVertices[i+3].vz)-lPos)*100.0f;

                                Vert v[4];

                                // top
                                v[0].x = m_wallVertices[i+1].vx; v[0].y = m_wallVertices[i+1].vy; v[0].z = m_wallVertices[i+1].vz;
                                v[1].x = v1.x; v[1].y = v1.y; v[1].z = v1.z;
                                v[2].x = v2.x; v[2].y = v2.y; v[2].z = v2.z;
                                v[3].x = m_wallVertices[i+2].vx; v[3].y = m_wallVertices[i+2].vy; v[3].z = m_wallVertices[i+2].vz;

                                shadowVertices.add(v[0]);
                                shadowVertices.add(v[1]);
                                shadowVertices.add(v[2]);
                                shadowVertices.add(v[3]);

                                shadowIndex += 4;

                                // right
                                v[0].x = m_wallVertices[i+2].vx; v[0].y = m_wallVertices[i+2].vy; v[0].z = m_wallVertices[i+2].vz;
                                v[1].x = v2.x; v[1].y = v2.y; v[1].z = v2.z;
                                v[2].x = v3.x; v[2].y = v3.y; v[2].z = v3.z;
                                v[3].x = m_wallVertices[i+3].vx; v[3].y = m_wallVertices[i+3].vy; v[3].z = m_wallVertices[i+3].vz;

                                shadowVertices.add(v[0]);
                                shadowVertices.add(v[1]);
                                shadowVertices.add(v[2]);
                                shadowVertices.add(v[3]);

                                shadowIndex += 4;

                                // bottom (skip)
                                // left
                                v[0].x = m_wallVertices[i+0].vx; v[0].y = m_wallVertices[i+0].vy; v[0].z = m_wallVertices[i+0].vz;
                                v[1].x = v0.x; v[1].y = v0.y; v[1].z = v0.z;
                                v[2].x = v1.x; v[2].y = v1.y; v[2].z = v1.z;
                                v[3].x = m_wallVertices[i+1].vx; v[3].y = m_wallVertices[i+1].vy; v[3].z = m_wallVertices[i+1].vz;

                                shadowVertices.add(v[0]);
                                shadowVertices.add(v[1]);
                                shadowVertices.add(v[2]);
                                shadowVertices.add(v[3]);

                                shadowIndex += 4;
                        }
                }

                // ========== OPTIMIZE SHADOW VOLUMES ==========
                for (int p=0; p<shadowVertices.getCount(); p+=4) {
                        bool found = false;
                        int equal = 0;
                        for (int n=0; n<shadowVertices.getCount() && !found; n+=4) {
                                if (p==n)
                                        continue;

                                equal = 0;
                                for (int a=0; a<4 && !found; a++) {
                                        for (int b=0; b<4 && !found; b++) {
                                                if (vertEqual(shadowVertices[p+a], shadowVertices[n+b])) {
                                                        equal++;
                                                }
                                        }
                                }

                                if (equal == 4)
                                        found = true;
                        }

                        //found = false;
                        if (!found) {
                                shadowVerticesFinal.add(shadowVertices[p]);
                                shadowVerticesFinal.add(shadowVertices[p+1]);
                                shadowVerticesFinal.add(shadowVertices[p+2]);
                                shadowVerticesFinal.add(shadowVertices[p+3]);
                                shadowIndexFinal +=4;
                        }
                }


                //if (shadowIndexFinal > 0) {
                        //LOG_MISC(("shadowIndexFinal: %d (%d polygons)", shadowIndexFinal, shadowIndexFinal/4));
                        m_shadowVertices = new Vert[shadowIndexFinal];
                        memcpy(m_shadowVertices, shadowVerticesFinal.getArray(), sizeof(Vert)*shadowIndexFinal);

                        m_shadow = new OpenGLObject();
                        m_shadow->addFormat(ATT_VERTEX, ATT_FLOAT, 3, sizeof(float)*0);
                        m_shadow->setPrimitive(PRIM_QUADS);
                        m_shadow->setVertices(m_shadowVertices, shadowIndexFinal, sizeof(Vert));

                        //LOG_SUCCESS(("Object level shadows loaded"));
                //}
        }

        // ========== FLOOR ==========
        if (floorIndex > 0) {
                //LOG_MISC(("floorIndex: %d (%d polygons)", wallIndex, wallIndex/4));
                m_floorVertices = new Vertex[floorIndex];
                memcpy(m_floorVertices, floorVertices.getArray(), sizeof(Vertex)*floorIndex);

                m_floor = new OpenGLObject();
                m_floor->addFormat(ATT_VERTEX, ATT_FLOAT, 3, sizeof(float)*5);
                m_floor->addFormat(ATT_NORMAL, ATT_FLOAT, 3, sizeof(float)*2);
                m_floor->addFormat(ATT_TEX, ATT_FLOAT, 2, 0);
                m_floor->setPrimitive(PRIM_QUADS);
                m_floor->setVertices(m_floorVertices, floorIndex, sizeof(Vertex));

                //LOG_SUCCESS(("Object level floor loaded"));
        }
        

        // ========== WATER ==========
        //LOG_MISC(("waterIndex: %d (%d polygons)", waterIndex, waterIndex/4));
        m_waterVertices = new Vertex[waterIndex];
        memcpy(m_waterVertices, waterVertices.getArray(), sizeof(Vertex)*waterIndex);

        m_water = new OpenGLObject();
        m_water->addFormat(ATT_VERTEX, ATT_FLOAT, 3, sizeof(float)*5);
        m_water->addFormat(ATT_NORMAL, ATT_FLOAT, 3, sizeof(float)*2);
        m_water->addFormat(ATT_TEX, ATT_FLOAT, 2, 0);
        m_water->setPrimitive(PRIM_QUADS);
        m_water->setVertices(m_waterVertices, waterIndex, sizeof(Vertex));

        //LOG_SUCCESS(("Object level water loaded"));


        // ========== WATER SURFACE ==========
        //LOG_MISC(("waterSurfaceIndex: %d (%d polygons)", waterSurfaceIndex, waterSurfaceIndex/4));
        m_waterSurfaceVertices = new Vertex[waterSurfaceIndex];
        memcpy(m_waterSurfaceVertices, waterSurfaceVertices.getArray(), sizeof(Vertex)*waterSurfaceIndex);

        m_waterSurface = new OpenGLObject();
        m_waterSurface->addFormat(ATT_VERTEX, ATT_FLOAT, 3, sizeof(float)*5);
        m_waterSurface->addFormat(ATT_NORMAL, ATT_FLOAT, 3, sizeof(float)*2);
        m_waterSurface->addFormat(ATT_TEX, ATT_FLOAT, 2, 0);
        m_waterSurface->setPrimitive(PRIM_QUADS);
        m_waterSurface->setVertices(m_waterSurfaceVertices, waterSurfaceIndex, sizeof(Vertex));

        //LOG_SUCCESS(("Object level water surface loaded"));

        String str;

        str = "data\\textures\\walls\\";        str += mp_lvl->texWall;
        if ((m_texWall = mp_renderer->addTexture(str)) == TEXTURE_NONE) return false;

        str = "data\\textures\\floor\\";        str += mp_lvl->texFloor;
        if ((m_texFloor = mp_renderer->addTexture(str)) == TEXTURE_NONE) return false;

        str = "data\\textures\\water\\";        str += mp_lvl->texWater;
        if ((m_texWater = mp_renderer->addTexture(str)) == TEXTURE_NONE) return false;

        str = "data\\textures\\water\\";        str += mp_lvl->texWaterSurface;
        if ((m_texWaterSurface = mp_renderer->addTexture(str)) == TEXTURE_NONE) return false;

        LOG_SUCCESS(("Level object loaded"));

        return true;
}

bool ObjLevel::isColor(unsigned char *data, int r, int g, int b) {
        return (data[0] == r && data[1] == g && data[2] == b);
}

bool ObjLevel::isColor(unsigned char *data, int r, int g) {
        return (data[0] == r && data[1] == g);
}

bool ObjLevel::isColor(unsigned char *data, int r) {
        return (data[0] == r);
}

bool ObjLevel::isWall(unsigned char *data) {
        return isColor(data, 255, 255, 255);
}

bool ObjLevel::isSpawnPool(unsigned char *data) {
        return (data[1] == 240 && data[2] == 240);
}

void ObjLevel::setVertex(Vertex &v, float tu, float tv, float nx, float ny, float nz, float vx, float vy, float vz) {
        v.tu = tu;
        v.tv = tv;
        v.nx = nx;
        v.ny = ny;
        v.nz = nz;
        v.vx = vx;
        v.vy = vy;
        v.vz = vz;
}

Vertex ObjLevel::newVertex(float tu, float tv, float nx, float ny, float nz, float vx, float vy, float vz) {
        Vertex v;
        v.tu = tu;
        v.tv = tv;
        v.nx = nx;
        v.ny = ny;
        v.nz = nz;
        v.vx = vx;
        v.vy = vy;
        v.vz = vz;
        return v;
}

ObjLevel::~ObjLevel() {
        if (m_walls) delete m_walls;
        m_walls = NULL;
        m_wallVertices = NULL;          // deletion handled by Object.cpp

        if (m_walls) delete m_floor;
        m_floor = NULL;
        m_floorVertices = NULL;         // deletion handled by Object.cpp

        if (m_shadow) delete m_shadow;
        m_shadow = NULL;
        m_shadowVertices = NULL;                // deletion handled by Object.cpp

        if (m_water) delete m_water;
        m_water = NULL;
        m_waterVertices = NULL;         // deletion handled by Object.cpp

        mp_renderer->deleteTexture(m_texWall);
        mp_renderer->deleteTexture(m_texFloor);
        mp_renderer->deleteTexture(m_texWater);
        mp_renderer->deleteTexture(m_texWaterSurface);

        for (unsigned int i=0; i<mp_lvl->numModels; i++) {
                m_models[i].clear();
        }

        LOG_SUCCESS(("Level object unloaded"));
}

void ObjLevel::draw() {
        m_floor->draw();
        m_walls->draw();
}

void ObjLevel::drawFloor() {
        //mp_renderer->setDepthFunc(EQUAL);
        mp_renderer->setTextures(m_texFloor);
        mp_renderer->apply();
        m_floor->draw();
}

void ObjLevel::drawWalls() {
        //mp_renderer->setDepthFunc(EQUAL);
        mp_renderer->setTextures(m_texWall);
        mp_renderer->apply();
        m_walls->draw();
}

void ObjLevel::drawShadow() {

        m_shadow->draw();
        return;
}

void ObjLevel::drawWater() {
        //mp_renderer->setDepthFunc(EQUAL);
        mp_renderer->setTextures(m_texWater);
        mp_renderer->apply();
        m_water->draw();
}

void ObjLevel::drawWaterSurface() {
        Vertex *vertices = (Vertex *)m_waterSurface->getVertices();

        static float angle = 0.0f;

        mp_renderer->setBlending(ONE, ONE);
        mp_renderer->setTextures(m_texWaterSurface);
        mp_renderer->apply();

        //m_waterSurface->draw();
        m_waterSurface->draw();

        int n = 0;
        float sinfa = sinf(angle)*0.035f*mp_lvl->waterSurfaceSpeed;
        float dtv = g_frameTime*0.0003f*mp_lvl->waterSurfaceSpeed;
        for (int i=0; i<waterSurfaceIndex; i+=1) {
                vertices[i].tv += dtv;
                
                if (n < 2)
                        vertices[i].tu = 0.0f + sinfa;
                else
                        vertices[i].tu = 1.0f + sinfa;

                if (++n == 4)
                        n = 0;
        }

        angle += g_frameTime*0.001f;

        m_waterSurface->draw();
}

void ObjLevel::createVertexBuffer() {
        m_walls->createVertexBuffer();
        m_floor->createVertexBuffer();
        m_shadow->createVertexBuffer();
        m_water->createVertexBuffer();
        //m_waterSurface->createVertexBuffer();
}

void ObjLevel::clearVertexBuffer() {
        m_walls->clearVertexBuffer();
        m_floor->clearVertexBuffer();
        m_shadow->clearVertexBuffer();
        m_water->clearVertexBuffer();
        //m_waterSurface->clearVertexBuffer();
}

bool ObjLevel::vertEqual(Vert &a, Vert &b) {
        return (a.x == b.x && a.y == b.y && a.z == b.z);
}

bool ObjLevel::isWater(Vec3 pos) {
        int x = (int)round(pos.x);
        int z = (int)round(pos.z);
        int offset = z*mp_lvl->width*3 + x*3;
        return isColor(&mp_lvl->data[offset], 0, 0, 240);
}

bool ObjLevel::isWall(Vec3 pos) {
        int x = (int)round(pos.x);
        int z = (int)round(pos.z);
        int offset = z*mp_lvl->width*3 + x*3;
        return isWall(&mp_lvl->data[offset]);
}

bool ObjLevel::collission(Vec3 &pos, float radius) {
        int x;
        int z;
        int offset;
        //int len = mp_lvl->width*mp_lvl->height*3;

        for (int i=-1; i<=1; i++) {
                for (int n=-1; n<=1; n++) {
                        if (i == 0 && n == 0)
                                continue;

                        x = (int)round(pos.x + i*radius);
                        z = (int)round(pos.z + n*radius);
                        offset = z*mp_lvl->width*3 + x*3;
                        if (mp_lvl->data[offset] != 15 && !isColor(&mp_lvl->data[offset], 0, 0,  240))
                                return true;
                }
        }

        return false;
}

Vec3 ObjLevel::getSpawnpool() {
        static unsigned int last = 0;

        if (m_nSpawnpools == 0)
                return Vec3(5.0f, 0.0f, 5.0f);
        else if (m_nSpawnpools == 1)
                return m_spawnpools[0];


        unsigned int i = 0;
        unsigned int n = 0;

        srand(GetTickCount()+last);

        do {
                i = round(((float)rand() / (float)RAND_MAX)*(m_nSpawnpools-1));
        } while (i == last && n++ < 10);

        last = i;

        return m_spawnpools[last];
}

Vec3 ObjLevel::getExtras() {
        static unsigned int last = 0;

        if (m_nExtras == 0)
                return Vec3(5.0f, 0.0f, 5.0f);
        else if (m_nExtras == 1)
                return m_extras[0];

        unsigned int i = 0;
        unsigned int n = 0;

        srand(GetTickCount()+last);

        do {
                i = round(((float)rand() / (float)RAND_MAX)*(m_nExtras-1));
        } while (i == last && n++ < 10);

        last = i;

        return m_extras[last];
}

void ObjLevel::drawObjects() {
        for (unsigned int i=0; i<m_numObjects; i++) {
                if (m_objects[i].alive) {
                        glPushMatrix();
                                glTranslatef(m_objects[i].x, m_objects[i].y, m_objects[i].z);
                                glScalef(0.05f, 0.05f, 0.05f);
                                m_models[m_objects[i].model].render();
                        glPopMatrix();
                }
        }
}

---