
#include "VBSPData.h"
#include <string.h>


using namespace bsp;
using namespace osg;


VBSPData::VBSPData()
{
}


VBSPData::~VBSPData()
{
}


void VBSPData::addEntity(std::string & newEntity)
{
    entity_list.push_back(newEntity);
}


const int VBSPData::getNumEntities() const
{
    return entity_list.size();
}


const std::string & VBSPData::getEntity(int index) const
{
    return entity_list[index];
}


void VBSPData::addModel(Model & newModel)
{
    model_list.push_back(newModel);
}


const int VBSPData::getNumModels() const
{
    return model_list.size();
}


const Model & VBSPData::getModel(int index) const
{
    return model_list[index];
}


void VBSPData::addPlane(bsp::Plane & newPlane)
{
    plane_list.push_back(newPlane);
}


const int VBSPData::getNumPlanes() const
{
    return plane_list.size();
}


const bsp::Plane & VBSPData::getPlane(int index) const
{
    return plane_list[index];
}


void VBSPData::addVertex(osg::Vec3f & newVertex)
{
    // Scale the vertex from inches up to meter scale
    vertex_list.push_back(newVertex * 0.0254f);
}


const int VBSPData::getNumVertices() const
{
    return vertex_list.size();
}


const osg::Vec3f & VBSPData::getVertex(int index) const
{
    return vertex_list[index];
}


void VBSPData::addEdge(Edge & newEdge)
{
    edge_list.push_back(newEdge);
}


const int VBSPData::getNumEdges() const
{
    return edge_list.size();
}


const Edge & VBSPData::getEdge(int index) const
{
    return edge_list[index];
}


void VBSPData::addSurfaceEdge(int & newSurfEdge)
{
    surface_edge_list.push_back(newSurfEdge);
}


const int VBSPData::getNumSurfaceEdges() const
{
    return surface_edge_list.size();
}


const int VBSPData::getSurfaceEdge(int index) const
{
    return surface_edge_list[index];
}


void VBSPData::addFace(Face & newFace)
{
    face_list.push_back(newFace);
}


const int VBSPData::getNumFaces() const
{
    return face_list.size();
}


const Face & VBSPData::getFace(int index) const
{
    return face_list[index];
}


void VBSPData::addTexInfo(TexInfo & newTexInfo)
{
    texinfo_list.push_back(newTexInfo);
}


const int VBSPData::getNumTexInfos() const
{
    return texinfo_list.size();
}


const TexInfo & VBSPData::getTexInfo(int index) const
{
    return texinfo_list[index];
}


void VBSPData::addTexData(TexData & newTexData)
{
    texdata_list.push_back(newTexData);
}


const int VBSPData::getNumTexDatas() const
{
    return texdata_list.size();
}


const TexData & VBSPData::getTexData(int index) const
{
    return texdata_list[index];
}


void VBSPData::addTexDataString(std::string & newTexDataString)
{
    texdata_string_list.push_back(newTexDataString);
}


const int VBSPData::getNumTexDataStrings() const
{
    return texdata_string_list.size();
}


const std::string & VBSPData::getTexDataString(int index) const
{
    return texdata_string_list[index];
}


void VBSPData::addDispInfo(DisplaceInfo & newDispInfo)
{
    dispinfo_list.push_back(newDispInfo);
}


const int VBSPData::getNumDispInfos() const
{
    return dispinfo_list.size();
}


const DisplaceInfo & VBSPData::getDispInfo(int index) const
{
    return dispinfo_list[index];
}


void VBSPData::addDispVertex(DisplacedVertex & newDispVertex)
{
    displaced_vertex_list.push_back(newDispVertex);
}


const int VBSPData::getNumDispVertices() const
{
    return displaced_vertex_list.size();
}


const DisplacedVertex & VBSPData::getDispVertex(int index) const
{
    return displaced_vertex_list[index];
}


void VBSPData::addStaticPropModel(std::string & newModel)
{
    static_prop_model_list.push_back(newModel);
}


const int VBSPData::getNumStaticPropModels() const
{
    return static_prop_model_list.size();
}


const std::string & VBSPData::getStaticPropModel(int index) const
{
    return static_prop_model_list[index];
}


void VBSPData::addStaticProp(StaticPropV4 & newProp)
{
    StaticProp newPropV5;

    // Create a version 5 static prop and copy the data from the given
    // version 4 prop into it
    memcpy(&newPropV5, &newProp, sizeof(StaticPropV4));
    newPropV5.forced_fade_scale = 1.0;

    // Add the new prop to the list
    static_prop_list.push_back(newPropV5);
}


void VBSPData::addStaticProp(StaticProp & newProp)
{
    static_prop_list.push_back(newProp);
}


const int VBSPData::getNumStaticProps() const
{
    return static_prop_list.size();
}


const StaticProp & VBSPData::getStaticProp(int index) const
{
    return static_prop_list[index];
}


void VBSPData::addStateSet(StateSet * stateSet)
{
    state_set_list.push_back(stateSet);
}


const int VBSPData::getNumStateSets() const
{
    return state_set_list.size();
}


StateSet * VBSPData::getStateSet(int index) const
{
    return state_set_list[index].get();
}


