bsp.cpp

Go to the documentation of this file.

/*
 * bsp.cpp
 *
 * Copyright (C) 2010  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * BSP parsing.  See bsp.h
 */

// includes --------------------------------------------------------------------
#include "bsp.h"                        // always include our own header first!

#include <iostream>

#include "geometry/plane.h"
#include "perf/perf.h"


namespace quake {



/// quake BSP file directory entry
struct direntry_t {
        int32_t         offset; ///< offset to start of lump from file begin
        int32_t         length; ///< length of this lump in bytes--multiple of 4
};


typedef std::map<eLumpType, direntry_t> lump_entry_map_t;

#define DECLARE_LUMP_READER(type)                                       \
        lump_object_t * readLump ## type (IO std::istream& in);


typedef lump_object_t * (*lump_reader_t)(IO std::istream& in);


struct lump_entry_t {
        eLumpType               type;
        lump_reader_t           reader;
        int                     obj_size;       // size on disk/file
};

#define LUMP_READER_ENTRY( type , size )                                \
         { eLump_ ## type , readLump ## type , size },


// list of lump readers
DECLARE_LUMP_READER(Entities);
DECLARE_LUMP_READER(Faces);
DECLARE_LUMP_READER(Leaffaces);
DECLARE_LUMP_READER(Leafs);
DECLARE_LUMP_READER(Meshverts);
DECLARE_LUMP_READER(Nodes);
DECLARE_LUMP_READER(Planes);
DECLARE_LUMP_READER(Textures);
DECLARE_LUMP_READER(Vertices);


// map from type to lump reading data
static const lump_entry_t s_lumpMap[] = {
        LUMP_READER_ENTRY(Entities,     -1)  // negative value --> variable size
        LUMP_READER_ENTRY(Faces,        14 * sizeof(int32_t) + 12 * sizeof(float))
        LUMP_READER_ENTRY(Leaffaces,    sizeof(int32_t))
        LUMP_READER_ENTRY(Leafs,        12 * sizeof(int32_t))
        LUMP_READER_ENTRY(Meshverts,    sizeof(int32_t))
        LUMP_READER_ENTRY(Nodes,        9 * sizeof(int32_t))
        LUMP_READER_ENTRY(Planes,       4 * sizeof(float))
        LUMP_READER_ENTRY(Textures,     64 + 2 * sizeof(int32_t))
        LUMP_READER_ENTRY(Vertices,     4 + 10 * sizeof(float))

        // must be last!
        { eLump_Invalid, NULL, 0 }
};



// interface destructors
Bsp::~Bsp(void) throw() { }
lump_object_t::~lump_object_t(void) throw() { }

entity_t::~entity_t(void) throw() { }
face_t::~face_t(void) throw() { }
leaf_t::~leaf_t(void) throw() { }
leafface_t::~leafface_t(void) throw() { }
meshvert_t::~meshvert_t(void) throw() { }
node_t::~node_t(void) throw() { }
plane_t::~plane_t(void) throw() { }
texture_path_t::~texture_path_t(void) throw() { }
vertex_t::~vertex_t(void) throw() { }



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

static const lump_entry_t *
getLumpEntry
(
IN eLumpType type
)
throw()
{
        for (const lump_entry_t * p = s_lumpMap; p->reader; ++p) {
                if (p->type == type)
                        return p;
        }

        DPRINTF("Could not find lump type in static map: %d", type);
        return NULL;
}



////////////////////////////////////////////////////////////////////////////////
//
//      lump readers (TODO: break out into separate files?)
//
////////////////////////////////////////////////////////////////////////////////

lump_object_t *
readLumpEntities
(
IO std::istream& in
)
{
        ASSERT_THROW(in.good(), "bad input BSP stream");

        static entity_t s_entity;

        s_entity.dictionary.clear();
        //DPRINTF("ENTITY -----------------------");

        char a;
        std::string key, value;
        in >> a;
        if (!a) {
                // end of entities!
                return NULL;
        }
        ASSERT_THROW('{' == a, "Expected an opening bracket, but read: " << a);
        while (true) {
                in >> a;
                if ('}' == a) {
                        break;          // end of entity
                }
                ASSERT_THROW('\"' == a, "Malformed key.  " <<
                    "Should start with quotes, but read this: " << a);

                key.clear();
                value.clear();

                while (true) {
                        in >> a;
                        if ('\"' == a) {
                                break;
                        }
                        key += a;
                }

                while (true) {
                        in >> a;
                        if ('\"' == a) {
                                break;
                        }
                }

                while (true) {
                        in >> a;
                        if ('\"' == a) {
                                break;
                        }
                        value += a;
                }

                // DPRINTF("  '%s' = '%s'", key.c_str(), value.c_str());
                s_entity.dictionary[key] = value;
        }

        return &s_entity;
}



lump_object_t *
readLumpFaces
(
IO std::istream& in
)
{
        ASSERT_THROW(in.good(), "bad input BSP stream");

        static face_t s_face;

        s_face.texture = readInt(in);
        s_face.effect = readInt(in);
        s_face.type = readInt(in);
        s_face.vertex = readInt(in);
        s_face.nVertices = readInt(in);
        s_face.meshvert = readInt(in);
        s_face.nMeshverts = readInt(in);
        s_face.lmIndex = readInt(in);
        s_face.lmStart[0] = readInt(in);
        s_face.lmStart[1] = readInt(in);
        s_face.lmSize[0] = readInt(in);
        s_face.lmSize[1] = readInt(in);
        s_face.origin = readPoint3d(in);
        s_face.lmVecs[0] = readPoint3d(in);
        s_face.lmVecs[1] = readPoint3d(in);
        s_face.normal = readPoint3d(in);
        s_face.size[0] = readInt(in);
        s_face.size[1] = readInt(in);

        return &s_face;
}



lump_object_t *
readLumpLeaffaces
(
IO std::istream& in
)
{
        ASSERT_THROW(in.good(), "bad input BSP stream");

        static leafface_t s_lf;
        s_lf.face = readInt(in);
        return &s_lf;
}



lump_object_t *
readLumpLeafs
(
IO std::istream& in
)
{
        ASSERT_THROW(in.good(), "bad BSP input stream");

        static leaf_t s_leaf;

        int32_t * n = (int32_t *) &s_leaf.cluster;
        // a leaf is really just 12 ints
        for (int j = 0; j < 12; ++j) {
                n[j] = readInt(in);
        }
        return &s_leaf;
}



lump_object_t *
readLumpMeshverts
(
IO std::istream& in
)
{
        ASSERT_THROW(in.good(), "bad BSP input stream");

        static meshvert_t s_meshvert;

        s_meshvert.vertex = readInt(in);

        return &s_meshvert;
}



lump_object_t *
readLumpNodes
(
IO std::istream& in
)
{
        ASSERT_THROW(in.good(), "bad BSP input stream");

        static node_t s_node;

        // read node entry (just a set of 9 integers)
        int32_t * n = (int32_t *) &s_node.plane;
        for (int j = 0; j < 9; ++j) {
                n[j] = readInt(in);
        }
        return &s_node;
}



lump_object_t *
readLumpPlanes
(
IO std::istream& in
)
{
        ASSERT_THROW(in.good(), "bad bsp stream in readLumpPlanes");

        static plane_t s_plane;

        s_plane.n = readPoint3d(in);
        s_plane.d = readFloat(in);

        return &s_plane;
}



lump_object_t *
readLumpTextures
(
IO std::istream& in
)
{
        ASSERT_THROW(in.good(), "bad bsp stream");

        static texture_path_t s_texture;

        in.read(s_texture.name, 64);
        s_texture.name[64] = 0; // force null termination
        s_texture.flags = readInt(in);
        s_texture.contents = readInt(in);

        return &s_texture;
}



lump_object_t *
readLumpVertices
(
IO std::istream& in
)
{
        ASSERT_THROW(in.good(), "Bad BSP stream");

        static vertex_t s_vertex;

        s_vertex.position = readPoint3d(in);
        s_vertex.texcoord[0][0] = readFloat(in);
        s_vertex.texcoord[0][1] = readFloat(in);
        s_vertex.texcoord[1][0] = readFloat(in);
        s_vertex.texcoord[1][1] = readFloat(in);
        s_vertex.normal = readPoint3d(in);
        in.read((char *) &s_vertex.color, 4);

        return &s_vertex;
}



////////////////////////////////////////////////////////////////////////////////
//
//      BspImpl - class that implements the quake::Bsp interface
//
////////////////////////////////////////////////////////////////////////////////

class BspImpl : public Bsp {
public:
        // constructor, destructor ---------------------------------------------
        BspImpl(void) throw();
        ~BspImpl(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IN smart_ptr<nstream::Stream>& stream);

        // quake::Bsp class interface methods ----------------------------------
        virtual BspVersion getVersion(void) const throw() { return m_version; }
        virtual const char * getName(void) const throw() { return m_name.c_str(); }
        virtual const vec_lump_type_t& getLumps(void) const throw() { return m_lumps; }
        virtual int getLumpObjectCount(IN eLumpType type);
        virtual void startLumpIteration(IN eLumpType type);
        virtual const lump_object_t * getNextLumpObject(void);

private:
        // private typedefs ----------------------------------------------------
        // private helper methods ----------------------------------------------
        direntry_t * getEntry(IN eLumpType type) throw();

        // private member data -------------------------------------------------
        BspVersion              m_version;
        std::string             m_name;
        vec_lump_type_t         m_lumps;
        lump_entry_map_t        m_lumpMap;
        smart_ptr<nstream::Stream>      m_stream;
        std::istream *          m_pinput;
        const lump_entry_t *    m_entry;
        int                     m_index;
        int                     m_max;          // max offset
};



////////////////////////////////////////////////////////////////////////////////
//
//      BspImpl -- public class methods
//
////////////////////////////////////////////////////////////////////////////////

BspImpl::BspImpl
(
void
)
throw()
{
        m_index = -1;
        m_max = 0;
        m_pinput = NULL;
        m_entry = NULL;
}



void
BspImpl::initialize
(
IN smart_ptr<nstream::Stream>& stream
)
{
        perf::Timer timer("loadBsp");
        ASSERT(stream, "null");
        ASSERT_THROW(stream->good(), "bad input BSP stream");
        ASSERT(!m_stream, "already have a stream");

        // save
        m_stream = stream;

        // debug diagnostics
        smart_ptr<nstream::File> file = stream->getFile();
        ASSERT_THROW(file, "stream not attached to file?");
        m_name = file->getName();
        DPRINTF("Reading bsp file from stream: %s", m_name.c_str());

        // okay, get underlying stream
        std::istream& in = stream->getStream();
        ASSERT_THROW(in.good(), "bad input BSP stream");

        // read version
        m_version.read(in);
        ASSERT_THROW(m_version.isValid(), "Could not parse BSP version");

        // get lumps
        ASSERT_THROW(m_version.getLumpTypes(m_lumps),
            "Could not determine BSP lumps from version");

        // now keep reading directory entries
        for (vec_lump_type_t::const_iterator i = m_lumps.begin();
             i != m_lumps.end(); ++i) {
                eLumpType type = *i;
                // const char * name = getLumpName(type);
                // DPRINTF("Reading directory entry for lump '%s'", name);

                direntry_t entry;
                entry.offset = readInt(in);
                entry.length = readInt(in);

                // DPRINTF("  offset: %d", entry.offset);
                // DPRINTF("  length: %d", entry.length);

                ASSERT_THROW(entry.offset > 0,
                    "bad lump offset: " << entry.offset);
                ASSERT_THROW(entry.length >= 0,
                    "bad lump length: " << entry.length);

                // remember the entry information for this lump
                m_lumpMap[type] = entry;
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      BspImpl -- quake::Bsp class interface methods
//
////////////////////////////////////////////////////////////////////////////////

int
BspImpl::getLumpObjectCount
(
IN eLumpType type
)
{
        // do we have a lump directory entry for this type?
        direntry_t * dirent = this->getEntry(type);
        if (!dirent) {
                return 0;       // nope
        }
        ASSERT(dirent->length >= 0, "Bad length: %d", dirent->length);

        // get the lump entry
        const lump_entry_t * p = getLumpEntry(type);
        if (!p) {
                return 0;       // unrecognized lump type
        }
        if (p->obj_size < 0) {
                // objects are of unknown size!
                return -1;
        }
        ASSERT(p->obj_size > 0, "Bad object size: %d", p->obj_size);

        return (dirent->length / p->obj_size);
}



void
BspImpl::startLumpIteration
(
IN eLumpType type
)
{
        perf::Timer timer("Bsp::startLumpIteration");
        DPRINTF("Caller has requested to start iterating lump '%s'",
            getLumpName(type));

        // clear
        m_index = 0;
        m_entry = NULL;
        m_max = 0;
        m_pinput = NULL;

        // do we have a directory entry for this lump?
        direntry_t * dirent = this->getEntry(type);
        if (!dirent) {
                return;         // nope
        }

        // look up entry
        m_entry = getLumpEntry(type);
        if (!m_entry) {
                DPRINTF("Coult not find lump entry for type %d", type);
                return;
        }
        ASSERT(m_entry->reader, "null reader in lump entry map");

        DPRINTF("  Moving to offset %d", dirent->offset);
        ASSERT(dirent->offset > 0, "Bad lump offset: %d", dirent->offset);

        ASSERT(m_stream, "null");
        m_pinput = &m_stream->getStream();
        ASSERT(m_pinput, "null");
        ASSERT_THROW(m_pinput->good(), "bad input BSP stream");
        m_pinput->seekg(dirent->offset);

        // reset max
        m_max = dirent->offset + dirent->length;
}



const lump_object_t *
BspImpl::getNextLumpObject
(
void
)
{
        if (!m_entry || !m_pinput) {
                return NULL;    // no input stream
        }
        int offset = m_pinput->tellg();
        if (offset >= m_max)
                return NULL;    // end of iteration

        // let reader do its work
        lump_object_t * retval = m_entry->reader(*m_pinput);
        if (!retval) {
                DPRINTF("lump reader returned null object");
                return NULL;
        }
        retval->index = m_index;

        // update
        ++m_index;

        // all done
        return retval;
}



////////////////////////////////////////////////////////////////////////////////
//
//      BspImpl -- private member functions
//
////////////////////////////////////////////////////////////////////////////////

direntry_t *
BspImpl::getEntry
(
IN eLumpType type
)
throw()
{
        lump_entry_map_t::iterator i = m_lumpMap.find(type);
        if (m_lumpMap.end() == i) {
                return NULL;
        }
        return &i->second;
}



////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

smart_ptr<Bsp>
Bsp::load
(
IN smart_ptr<nstream::Stream>& stream
)
{
        ASSERT(stream, "null");

        smart_ptr<BspImpl> local = new BspImpl;
        ASSERT(local, "out of memory");

        local->initialize(stream);

        return local;
}



};      // quake namespace