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

#include "LBBCLeaf.h"

namespace LBBC {

Leaf::Leaf() 
{
}

Leaf::~Leaf() 
{

}

void Leaf::setPlaneD(float value) {
        mPlaneD = value;
}

float Leaf::getPlaneD() {
        return mPlaneD;
}

void Leaf::setPlaneNormal(Ogre::Vector3 value) {
}

Ogre::Vector3 Leaf::getPlaneNormal() {
        return mPlaneNormal;
}

void Leaf::setPosition(Ogre::Vector3 value) {
        mPosition = value;
}

Ogre::Vector3 Leaf::getPosition() {
        return mPosition;
}

Ogre::Quaternion Leaf::getOrientation() {
        return mOrientation; 
}

void Leaf::setOrientation(const Ogre::Quaternion & orientation) {
        mOrientation = orientation;
}

void Leaf::addFaceNormal(Ogre::Vector3 value)
{
        mFacesNormals.push_back(value);
}

void Leaf::removeFaceNormal(unsigned int value)
{
        mFacesNormals.erase(mFacesNormals.begin()+value);
}

Ogre::Vector3 Leaf::getFaceNormal(unsigned int value)
{
        return mFacesNormals[value];
}

bool Leaf::hasFace(unsigned int value)
{
        bool hasFace = false;

        if (mFacesEntitySet.size() > 0)
        {
                hasFace = mFacesEntitySet.find(value) != mFacesEntitySet.end();
        }
        return hasFace;
}

void Leaf::addFace(unsigned int value)
{
        mFacesEntitySet.insert(value);
}

void Leaf::removeFace(unsigned int value)
{
        mFacesEntitySet.erase(value);
}

unsigned int Leaf::getFace(unsigned int value)
{
        ID_FACESet::iterator itFacesEntitySet;
        itFacesEntitySet = mFacesEntitySet.begin();

        unsigned int iElem = 0;
        while ((iElem < value) && (value < mFacesEntitySet.size()))
        {
                itFacesEntitySet++;
                iElem++;
        }       
        return static_cast<unsigned int>(* itFacesEntitySet);
}

unsigned int Leaf::getNumFaces()
{
        return static_cast<unsigned int>(mFacesEntitySet.size());       
}

unsigned int Leaf::getNumLeafNormals()
{
        return static_cast<unsigned int>(mFacesNormals.size());
}

void Leaf::setLeafNormal(Ogre::Vector3 normal)
{
        mLeafNormal = normal;
}

Ogre::Vector3 Leaf::getLeafNormal()
{
        return mLeafNormal;
}

void Leaf::setLeafD(float leafD)
{
        mLeafD = leafD;
}

float Leaf::getLeafD()
{
        return mLeafD;
}

void Leaf::addFaceInfo(BBC::UniqueVertex v0, BBC::UniqueVertex v1, BBC::UniqueVertex v2)
{
        // Add vertex 0 from the first face     
        getSubEntity(0)->addUniqueVertex(v0);                                   
        
        // Add vertex 1 from the first face
        getSubEntity(0)->addUniqueVertex(v1);

        // Add vertex 2 from the first face
        getSubEntity(0)->addUniqueVertex(v2);

        unsigned int numIndices = getSubEntity(0)->getNumFaces() * 3;
        Ogre::Vector3 indices = Ogre::Vector3(numIndices, numIndices + 1, numIndices + 2);
        getSubEntity(0)->addFaceVerticesIDs(indices);

        Ogre::Vector3 p1 = v0.position;
        Ogre::Vector3 p2 = v1.position;
        Ogre::Vector3 p3 = v2.position;
        Ogre::Vector3 v21 = p2 - p1;
        Ogre::Vector3 v31 = p3 - p1;
        Ogre::Vector3 normal = v21.crossProduct(v31);

        //if (dotProd < 0)
        if (normal[2] < 0)
        {
                normal = v31.crossProduct(v21);
                normal.normalise();
        }

        addFaceNormal(normal);
}

void Leaf::readLeaf(TiXmlNode *leafNode)
{
        unsigned int id = Ogre::StringConverter::parseInt(leafNode->ToElement()->Attribute("id"));
        setEntityHandle(id);

        Ogre::Vector3 normal;
        TiXmlNode *coord4dNode = leafNode->FirstChild("coord4d");
        normal.x = Ogre::StringConverter::parseReal(coord4dNode->ToElement()->Attribute("nx"));
        normal.y = Ogre::StringConverter::parseReal(coord4dNode->ToElement()->Attribute("ny"));
        normal.z = Ogre::StringConverter::parseReal(coord4dNode->ToElement()->Attribute("nz"));
        float d = Ogre::StringConverter::parseReal(coord4dNode->ToElement()->Attribute("d"));   

        Ogre::Vector3 position;
        TiXmlNode *positionNode = leafNode->FirstChild("position");
        position.x = Ogre::StringConverter::parseReal(positionNode->ToElement()->Attribute("x"));
        position.y = Ogre::StringConverter::parseReal(positionNode->ToElement()->Attribute("y"));
        position.z = Ogre::StringConverter::parseReal(positionNode->ToElement()->Attribute("z"));       

        setLeafNormal(normal);
        setPosition(position);
        setLeafD(d);

        TiXmlNode *facesNode = leafNode->FirstChild("faces");
        unsigned int count = Ogre::StringConverter::parseInt(facesNode->ToElement()->Attribute("count"));

        for (TiXmlNode *faceNode = facesNode->FirstChild("face"); faceNode; faceNode = faceNode->NextSibling() )
        {
                unsigned int id = Ogre::StringConverter::parseInt(faceNode->ToElement()->Attribute("id"));
                addFace(id);
        }
}

void Leaf::writeLeaf(TiXmlNode *leafNode)
{       
        leafNode->ToElement()->SetAttribute(Ogre::String("id"),Ogre::StringConverter::toString(getEntityHandle())); 
        
        TiXmlNode *coord4dNode = leafNode->ToElement()->InsertEndChild(TiXmlElement(Ogre::String("coord4d").c_str()))->ToElement();

        Ogre::String sNx = Ogre::StringConverter::toString(getLeafNormal().x);
        Ogre::String sNy = Ogre::StringConverter::toString(getLeafNormal().y);
        Ogre::String sNz = Ogre::StringConverter::toString(getLeafNormal().z);
        Ogre::String sD = Ogre::StringConverter::toString(getLeafD());

        coord4dNode->ToElement()->SetAttribute("nx", sNx.c_str());
        coord4dNode->ToElement()->SetAttribute("ny", sNy.c_str());
        coord4dNode->ToElement()->SetAttribute("nz", sNz.c_str());
        coord4dNode->ToElement()->SetAttribute("d", sD.c_str());

        TiXmlNode *positionNode = leafNode->ToElement()->InsertEndChild(TiXmlElement(Ogre::String("position").c_str()))->ToElement();           

        Ogre::String sCoordX = Ogre::StringConverter::toString(getPosition().x);
        Ogre::String sCoordY = Ogre::StringConverter::toString(getPosition().y);
        Ogre::String sCoordZ = Ogre::StringConverter::toString(getPosition().z);

        positionNode->ToElement()->SetAttribute(Ogre::String("x").c_str(), sCoordX.c_str());
        positionNode->ToElement()->SetAttribute(Ogre::String("y").c_str(), sCoordY.c_str());
        positionNode->ToElement()->SetAttribute(Ogre::String("z").c_str(), sCoordZ.c_str());
        TiXmlNode *facesNode;
        for (unsigned int i = 0; i < getNumFaces(); i++)
        {
                if (i == 0)
                {
                        facesNode = leafNode->ToElement()->InsertEndChild(TiXmlElement(Ogre::String("faces").c_str()))->ToElement();

                        Ogre::String sFace = Ogre::StringConverter::toString(getNumFaces());
                        facesNode->ToElement()->SetAttribute(Ogre::String("count").c_str(), sFace.c_str());
                }
                
                TiXmlNode *faceNode = facesNode->ToElement()->InsertEndChild(TiXmlElement(Ogre::String("face").c_str()))->ToElement();
                Ogre::String sId = Ogre::StringConverter::toString(getFace(i));
                faceNode->ToElement()->SetAttribute("id", sId.c_str());         
        }
}

}