bsp-version.cpp

Go to the documentation of this file.

/*
 * bsp-version.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.
 *
 *
 */

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

#include <iostream>

#include "perf/perf.h"


namespace quake {


struct lump_meta_t {
        eLumpType               type;
        const char *            name;
};


#define LUMP_META( type ) { eLump_ ## type , #type },

static const lump_meta_t s_lumpMap[] = {
        LUMP_META(Entities)
        LUMP_META(Textures)
        LUMP_META(Planes)
        LUMP_META(Nodes)
        LUMP_META(Leafs)
        LUMP_META(Leaffaces)
        LUMP_META(Leafbrushes)
        LUMP_META(Models)
        LUMP_META(Brushes)
        LUMP_META(Brushsides)
        LUMP_META(Vertices)
        LUMP_META(Meshverts)
        LUMP_META(Effects)
        LUMP_META(Faces)
        LUMP_META(Lightmaps)
        LUMP_META(Lightvols)
        LUMP_META(Visdata)

        // keep this last!
        { eLump_Invalid,        "Invalid" }
};


enum eEndian {
        eLittleEndian           = 1,
        eBigEndian              = 2,

        eEndian_Invalid         = 0
};



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

void
littleEndianToHostEndian
(
IO byte_t * raw         ///< points to 4 bytes of little-endian data
)
{
        ASSERT(raw, "null");

        // are we big or little endian?
        // TODO: is there a better way to do this?  Very hacky...
        static eEndian endian = eEndian_Invalid;
        if (eEndian_Invalid == endian) {
                DPRINTF("determining local host byte order...");
                short test = 256;
                byte_t b[2];
                short * p = (short *) b;
                *p = test;
                if (b[0]) {
                        DPRINTF("Big endian!");
                        endian = eBigEndian;
                } else if (b[1]) {
                        DPRINTF("Little endian!");
                        endian = eLittleEndian;
                }
        }
        ASSERT(endian, "should have determined endian-ness");

        // already little-endian?  No need to convert
        if (eLittleEndian == endian) {
                return;
        }

        // flip
        byte_t save0 = raw[0];
        byte_t save1 = raw[1];
        raw[0] = raw[3];
        raw[1] = raw[2];
        raw[2] = save1;
        raw[3] = save0;
}



static eBspVendor
parseVendor
(
IO std::istream& in
)
{
        ASSERT_THROW(in.good(), "bad input BSP stream");

        char buffer[5];
        in.read(buffer, 4);
        buffer[4] = 0;

        if (!strcmp("IBSP", buffer)) {
                return eBspVendor_Id;
        } else if (!strcmp("VBSP", buffer)) {
                return eBspVendor_Valve;
        }

        // got here?  No idea!
        ASSERT_THROW(false, "Unknown BSP vendor: '" << buffer << "'");
        return eBspVendor_Invalid;
}



static eBspVersion
parseVersion
(
IN eBspVendor vendor,
IN int val
)
{
        switch (vendor) {
        case eBspVendor_Id:
                {
                        switch (val) {
                        case 0x2e:
                                return eBspVersion_IdQuake3;
                        default:
                                ASSERT_THROW(false,
                                    "Unrecognized Id version: " << val);
                        }
                }
                break;

        case eBspVendor_Valve:
                {
                        switch (val) {
                        default:
                                ASSERT_THROW(false,
                                    "Unrecognized Valve version: " << val);
                        }
                }
                break;

        default:
                ASSERT_THROW(false,
                    "Unknown or invalid BSP vendor: " << vendor);
        }

        // should never get here
        ASSERT(false, "should never get here");
        return eBspVersion_Invalid;
}



////////////////////////////////////////////////////////////////////////////////
//
//      BspVersion -- public class methods
//
////////////////////////////////////////////////////////////////////////////////

void
BspVersion::clear
(
void
)
throw()
{
        m_vendor = eBspVendor_Invalid;
        m_version = eBspVersion_Invalid;
}



bool
BspVersion::isValid
(
void
)
const
throw()
{
        return (eBspVendor_Invalid != m_vendor &&
                eBspVersion_Invalid != m_version);
}



void
BspVersion::read
(
IO std::istream& in
)
{
        ASSERT_THROW(in.good(), "bad input BSP stream");

        m_vendor = parseVendor(in);
        m_version = parseVersion(m_vendor, readInt(in));
}



#define ADDLUMP( type ) lumps.push_back( eLump_ ## type );

bool
BspVersion::getLumpTypes
(
OUT vec_lump_type_t& lumps
)
const
{
        lumps.clear();

        switch (m_version) {
        case eBspVersion_IdQuake3:
                ADDLUMP(Entities)
                ADDLUMP(Textures)
                ADDLUMP(Planes)
                ADDLUMP(Nodes)
                ADDLUMP(Leafs)
                ADDLUMP(Leaffaces)
                ADDLUMP(Leafbrushes)
                ADDLUMP(Models)
                ADDLUMP(Brushes)
                ADDLUMP(Brushsides)
                ADDLUMP(Vertices)
                ADDLUMP(Meshverts)
                ADDLUMP(Effects)
                ADDLUMP(Faces)
                ADDLUMP(Lightmaps)
                ADDLUMP(Lightvols)
                ADDLUMP(Visdata)
                return true;

        default:
                break;
        }

        // got here?  Can't determine lump types
        DPRINTF("Can't determine lumps from bsp vendor + version");
        return false;
}



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

const char *
getLumpName
(
IN eLumpType type
)
{
        for (const lump_meta_t * p = s_lumpMap; eLump_Invalid != p->type; ++p)
        {
                if (p->type == type) {
                        return p->name;
                }
        }

        DPRINTF("Unknown lump type: %d", type);
        return "(unknown)";
}



int
readInt
(
IO std::istream& in
)
{
        ASSERT_THROW(in.good(), "bad BSP input stream");

        // read the integer in little-endian
        byte_t raw[4];
        in.read((char *) raw, 4);

        // convert
        littleEndianToHostEndian(raw);

        // recast bytes as integer
        int32_t * pi = (int32_t *) raw;
        return *pi;
}



float
readFloat
(
IO std::istream& in
)
{
        ASSERT_THROW(in.good(), "bad BSP input stream");

        // read the float in little-endian
        byte_t raw[4];
        in.read((char *) raw, 4);

        // convert
        littleEndianToHostEndian(raw);

        // recast bytes as float
        float * pf = (float *) raw;
        return *pf;
}



point3d_t
readPoint3d
(
IO std::istream& in
)
{
        point3d_t p;
        p.x = readFloat(in);
        p.z = readFloat(in);
        p.y = readFloat(in);

        return p;
}



};      // quake namespace