source: GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/src/BBCSubEntity.cpp @ 721

#include "BBCSubEntity.h"

namespace BBC {

SubEntity::SubEntity(): references(0) // initialize references to 0
{
        mHasTangents = false;
        mHasVertexColours = false;
        mHasNormals = true;
        mHasTextureCoords = true;
}

SubEntity::~SubEntity() 
{
        mUniqueVertexList.clear();
        mIndices.clear();
        mTextureCoordSetsDimensions.clear();

}

void SubEntity::setPosition(unsigned int index, Ogre::Vector3 value)
{
        mUniqueVertexList[index].position = value;
}

Ogre::Vector3 SubEntity::getPosition(unsigned int index)
{
        return mUniqueVertexList[index].position;
}

void SubEntity::setNormal(unsigned int index, Ogre::Vector3 value)
{
        mUniqueVertexList[index].normal = value;
}

Ogre::Vector3 SubEntity::getNormal(unsigned int index)
{
        return mUniqueVertexList[index].normal;
}

void SubEntity::setTexCoord(unsigned int index, unsigned int set, Ogre::Vector3 value)
{
        mUniqueVertexList[index].uv[set] = value;
}

Ogre::Vector3 SubEntity::getTexCoord(unsigned int index, unsigned int set, unsigned int value)
{
        return mUniqueVertexList[index].uv[set];
}

void SubEntity::addFaceVerticesIDs(Ogre::Vector3 value)
{
        mIndices.push_back(value);
}

void SubEntity::removeFaceVerticesIDs(unsigned int value)
{
        mIndices.erase(mIndices.begin()+value);
}

Ogre::Vector3 SubEntity::getFaceVerticesIDs(unsigned int value)
{
        return mIndices[value];
}

void SubEntity::enableTangents(bool value)
{
        mHasTangents = value;
}

bool SubEntity::hasTangents()
{
        return mHasTangents;
}

void SubEntity::enableNormals(bool value)
{
        mHasNormals = value;
}

bool SubEntity::hasNormals()
{
        return mHasNormals;
}

void SubEntity::enableTextureCoords(bool value)
{
        mHasTextureCoords = value;
}

void SubEntity::addTextureCoordSet(unsigned int numTexCoords)
{
        mTextureCoordSetsDimensions.push_back(numTexCoords);
        enableTextureCoords(true);
}


unsigned int SubEntity::getNumTexCoordSets()
{
        return static_cast<unsigned int>(mTextureCoordSetsDimensions.size());
}

unsigned int SubEntity::getNumTexCoords()
{
        return static_cast<unsigned int>(mUniqueVertexList.size());
}

unsigned int SubEntity::getTexCoordDimensions(unsigned int set)
{
        return mTextureCoordSetsDimensions[set];
}

void SubEntity::enableVertexColours(bool value)
{
        mHasVertexColours = value;
}

bool SubEntity::hasVertexColours()
{
        return mHasVertexColours;
}

void SubEntity::setVertexColour(unsigned int index, Ogre::RGBA value)
{
        mUniqueVertexList[index].colour = value;
}

Ogre::RGBA SubEntity::getVertexColour(unsigned int index)
{
        return mUniqueVertexList[index].colour;
}

unsigned int SubEntity::getNumFaces()
{
        return static_cast<unsigned int>(mIndices.size());
}

unsigned int SubEntity::getNumVertices()
{
        return static_cast<unsigned int>(mUniqueVertexList.size());
}

Ogre::String SubEntity::getName()
{
        return mName;
}

void SubEntity::setName(Ogre::String value)
{
        mName = value;
}

Ogre::String SubEntity::getMaterialName()
{
        return mMaterialName;
}

void SubEntity::setMaterialName(Ogre::String value)
{
        mMaterialName = value;
}


UniqueVertexList* SubEntity::getUniqueVertices()
{
        return &mUniqueVertexList;
}

/*
void SubEntity::createUniqueVertices()
{
        for (unsigned int i = 0; i < getNumVertices(); i++)
        {
                UniqueVertex uniqueVertex;
                uniqueVertex.position = getVertex(i);
                uniqueVertex.normal = getNormal(i);
                for (unsigned int j = 0; j < getNumTexCoordSets(); j++)
                {
                        uniqueVertex.uv[j] = getTexCoord(j,i);
                }
                
        }
}
*/

void SubEntity::addUniqueVertex(UniqueVertex uniqueVertex)
{
        mUniqueVertexList.push_back(uniqueVertex);
}

void SubEntity::removeUniqueVertex(unsigned int index)
{
        mUniqueVertexList.erase(mUniqueVertexList.begin() + index);
}

UniqueVertex SubEntity::getUniqueVertex(unsigned int index)
{
        return mUniqueVertexList[index];
}

const Ogre::AxisAlignedBox &SubEntity::getAABBox()
{
        return mAABBox;
}

void SubEntity::setAABBox(Ogre::AxisAlignedBox box)
{
        mAABBox = box;
}

void SubEntity::generateAABBox()
{
        // Bounds calculation
        Ogre::Real squaredRadius = 0.0f;
    Ogre::Vector3 min, max;
    bool first = true;

        for (size_t jVertex = 0; jVertex < this->getNumVertices(); jVertex++)
        {
                if (first)
                {
                        squaredRadius = this->getUniqueVertex(jVertex).position.squaredLength();
                        min = max = this->getUniqueVertex(jVertex).position;
                        first = false;
                }
                else
                {
                        size_t numVertices = (unsigned int)this->getNumVertices();
                        //Ogre::LogManager::getSingleton().logMessage("NumVertices:" + Ogre::StringConverter::toString(numVertices));
                        //Ogre::LogManager::getSingleton().logMessage("IDVertex:" + Ogre::StringConverter::toString(jVertex) + "--" + Ogre::StringConverter::toString(iSubEntity) + "--" + Ogre::StringConverter::toString(mEntity->getSubEntity(iSubEntity)->getUniqueVertex(jVertex).position));
                        squaredRadius = 
                                std::max(squaredRadius,this->getUniqueVertex(jVertex).position.squaredLength());
                        min.makeFloor(this->getUniqueVertex(jVertex).position);
                        max.makeCeil(this->getUniqueVertex(jVertex).position);
                }
        }

        // Merge bounds
        mAABBox.setExtents(min, max);
}

}