bsp.cpp

Go to the documentation of this file.

/*
 * bsp.cpp
 *
 * Copyright (C) 2010  Thomas A. Vaughan
 * All rights reserved.
 *
 * Program to test the glut-demo and quake/bsp libraries.
 */

// includes --------------------------------------------------------------------
#include <iostream>
#include <fstream>

#include "glut-demo/glut-demo.h"
#include "nstream/nstream.h"
#include "perf/perf.h"
#include "quake/bsp/bsp.h"
#include "util/file.h"



struct face_t {
        int             type;   // 1 == polygon, 2 == mesh
        int             vertex; // always vertex
        int             start;  // start index (vertex, meshvert)
        int             N;      // number of points (polygon, mesh)
};


struct vertex_t {
        point3d_t       pos;    // position
        glut_color_t    color;  // color
};


////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////

class Drawer : public glut::DemoHost {
public:
        Drawer(IN const char * file) {
                        m_vertices = NULL;
                        ASSERT(file, "null");
                        m_file = file;
                }
        ~Drawer(void) throw() { 
                        if (m_vertices) {
                                delete[] m_vertices;
                        }
                }

        // glut::Host class interface methods ----------------------------------
        float getDelta(void) { return 25; }

        void onInit(void) {
                        perf::Timer timer("bsp load and parse");

                        // get named stream manager
                        const char * filename = m_file.c_str();
                        std::string dir;
                        GetParentDirectory(filename, dir);
                        smart_ptr<nstream::Manager> mgr =
                            nstream::getFilesystemManager(dir.c_str());
                        ASSERT(mgr, "failed to create filesystem manager");

                        // get named stream
                        smart_ptr<nstream::Stream> stream =
                            nstream::openNamedStream(mgr, GetFilename(filename));
                        ASSERT(stream, "failed to open stream");

                        // load bsp!
                        smart_ptr<quake::Bsp> bsp = quake::Bsp::load(stream);
                        ASSERT(bsp, "failed to load bsp");
                        m_nVertices = bsp->getLumpObjectCount(quake::eLump_Vertices);
                        DPRINTF("BSP contains %d vertices", m_nVertices);
                        m_vertices = new vertex_t[m_nVertices];
                        ASSERT(m_vertices, "out of memory");

                        // load vertices
                        bsp->startLumpIteration(quake::eLump_Vertices);
                        for (int i = 0; i < m_nVertices; ++i) {
                                const quake::lump_object_t * obj =
                                    bsp->getNextLumpObject();
                                ASSERT(obj, "null vertex");
                                ASSERT(obj->index == i, "bad index: %d", obj->index);
                                ASSERT(quake::eLump_Vertices == obj->getType(),
                                    "wrong object type");

                                const quake::vertex_t * vtx =
                                    dynamic_cast<const quake::vertex_t *>(obj);
                                ASSERT(vtx, "failed to upcast?");

                                vertex_t * v = m_vertices + i;
                                v->pos = vtx->position;
                                v->color.red = vtx->color.red;
                                v->color.green = vtx->color.green;
                                v->color.blue = vtx->color.blue;
                                v->color.alpha = vtx->color.alpha;
                        }

                        // load meshvertices
                        m_nMeshverts = bsp->getLumpObjectCount(quake::eLump_Meshverts);
                        DPRINTF("BSP contains %d meshverts", m_nMeshverts);
                        m_meshverts = new int[m_nMeshverts];
                        ASSERT(m_meshverts, "out of memory");

                        bsp->startLumpIteration(quake::eLump_Meshverts);
                        for (int i = 0; i < m_nMeshverts; ++i) {
                                const quake::lump_object_t * obj =
                                    bsp->getNextLumpObject();
                                ASSERT(obj, "null vertex");
                                ASSERT(obj->index == i, "bad index: %d", obj->index);
                                ASSERT(quake::eLump_Meshverts == obj->getType(),
                                    "wrong object type");

                                const quake::meshvert_t * vtx =
                                    dynamic_cast<const quake::meshvert_t *>(obj);
                                ASSERT(vtx, "failed to upcast?");

                                m_meshverts[i] = vtx->vertex;
                        }

                        // load faces
                        m_nFaces = bsp->getLumpObjectCount(quake::eLump_Faces);
                        DPRINTF("BSP contains %d faces", m_nFaces);
                        m_faces = new face_t[m_nFaces];
                        ASSERT(m_faces, "out of memory");

                        face_t * pFace = m_faces;
                        bsp->startLumpIteration(quake::eLump_Faces);
                        for (int i = 0; i < m_nFaces; ++i, ++pFace) {
                                const quake::lump_object_t * obj =
                                    bsp->getNextLumpObject();
                                ASSERT(obj, "null vertex");
                                ASSERT(obj->index == i, "bad index: %d", obj->index);
                                ASSERT(quake::eLump_Faces == obj->getType(),
                                    "wrong object type");

                                const quake::face_t * face =
                                    dynamic_cast<const quake::face_t *>(obj);
                                ASSERT(face, "failed to upcast");

//                              if (1 == face->type) {
                                        // standard polygon face
//                                      pFace->type = 1;
//                                      pFace->vertex = face->vertex;
//                                      pFace->start = face->vertex;
//                                      pFace->N = face->nVertices;
//                              } else if (3 == face->type) {
                                if (1 == face->type || 3 == face->type) {
                                        // triangle mesh
                                        pFace->type = 2;
                                        pFace->vertex = face->vertex;
                                        pFace->start = face->meshvert;
                                        pFace->N = face->nMeshverts;
                                        ASSERT_THROW(0 == (pFace->N % 3),
                                            "Mesh should have exact number of triangles");
                                } else {
                                        pFace->type = 0;
                                        pFace->start = 0;
                                        pFace->N = 0;
                                }
                        }
                }

        void display3D(IN const glut::render_context_t& rc,
                                IN glut::RenderQueue * rq) {
                        ASSERT(rq, "null");
                        // display all faces
                        const face_t * p = m_faces;
                        for (int i = 0; i < m_nFaces; ++i, ++p) {
                                int N = p->N;
                                if (19 == p->type) {
                                        // polygon face!
                                        const vertex_t * v = m_vertices + p->start;
                                        glBegin(GL_POLYGON);
                                        for (int j = 0; j < N; ++j, ++v) {
                                                glColor4bv((const GLbyte *) &v->color.red);
                                                glVertex3fv((const GLfloat *) &v->pos.x);
                                        }
                                        glEnd();
                                } else if (3 & p->type) {
                                        // triangle mesh face
                                        int idx = p->vertex;
                                        glBegin(GL_TRIANGLES);
                                        for (int j = 0; j < N; ++j) {
                                                int q = idx + m_meshverts[p->start + j];
                                                const vertex_t * v = m_vertices + q;
                                                glColor4bv((const GLbyte *) &v->color.red);
                                                glVertex3fv((const GLfloat *) &v->pos.x);
                                        }
                                        glEnd();
                                }
                        }
                }

private:
        std::string                     m_file;
        int                             m_nVertices;
        int                             m_nFaces;
        int                             m_nMeshverts;
        vertex_t *                      m_vertices;
        face_t *                        m_faces;
        int *                           m_meshverts;
};



////////////////////////////////////////////////////////////////////////////////
//
//      entry point
//
////////////////////////////////////////////////////////////////////////////////

int
main
(
IN int argc,
IN const char * argv[]
)
{
        ASSERT(2 == argc, "Usage: glut-demo-bsp <bsp-path>");
        const char * filename = argv[1];

        try {
                // title
                std::string title = "BSP map viewer: ";
                title += filename;

                // main loop
                smart_ptr<glut::DemoHost> host = new Drawer(filename);
                ASSERT(host, "out of memory");
                glut::startDemo(argc, argv, title.c_str(), host);

        } catch (std::exception& e) {
                DPRINTF("Exception: %s", e.what());
        }

        // only reach here on error
        return -1;
}