Mesh.cpp

Go to the documentation of this file.

#include "StdAfx.h"
#include "IMovableItemCallback.h"
#include "ISimGUICallback.h"
#include "AnimatBase.h"

#include "Node.h"
#include "IPhysicsMovableItem.h"
#include "IPhysicsBody.h"
#include "BoundingBox.h"
#include "MovableItem.h"
#include "BodyPart.h"
#include "Joint.h"
#include "ReceptiveField.h"
#include "ContactSensor.h"
#include "RigidBody.h"
#include "Mesh.h"
#include "Structure.h"
#include "Organism.h"
#include "ActivatedItem.h"
#include "ActivatedItemMgr.h"
#include "DataChartMgr.h"
#include "ExternalStimuliMgr.h"
#include "KeyFrame.h"
#include "SimulationRecorder.h"
#include "OdorType.h"
#include "Odor.h"
#include "Light.h"
#include "LightManager.h"
#include "Simulator.h"

namespace AnimatSim
{
        namespace Environment
        {
                namespace Bodies
                {

Mesh::Mesh()
{
        m_vScale.Set(1, 1, 1);
}

Mesh::~Mesh()
{
}

std::string Mesh::MeshFile() {return m_strMeshFile;}

void Mesh::MeshFile(std::string strFile) 
{
        m_strMeshFile = strFile;
        Resize();
}

std::string Mesh::CollisionMeshType() {return m_strCollisionMeshType;}

void Mesh::CollisionMeshType(std::string strType)
{
        std::string strUpType = Std_CheckString(strType);
        if(strUpType != "TRIANGULAR" && strUpType != "CONVEX" && strUpType != "TERRAIN")
                THROW_TEXT_ERROR(Al_Err_lInvalidCollisionMeshType, Al_Err_strInvalidCollisionMeshType, "Body: " + m_strName + "  MeshType: " + m_strCollisionMeshType);

        m_strCollisionMeshType = strUpType;
        Resize();
}


std::string Mesh::ConvexMeshFile() {return m_strConvexMeshFile;}

void Mesh::ConvexMeshFile(std::string strFile) 
{
        m_strConvexMeshFile = strFile;
        Resize();
}


CStdFPoint Mesh::Scale() {return m_vScale;}

void Mesh::Scale(CStdFPoint &oPoint, bool bUpdateMatrix) 
{
        m_vScale = oPoint;
        m_vReportScale = m_vScale;

        if(m_lpPhysicsMovableItem && bUpdateMatrix)
                m_lpPhysicsMovableItem->Physics_Resize();
}

void Mesh::Scale(float fltX, float fltY, float fltZ, bool bUpdateMatrix) 
{
        CStdFPoint vPos(fltX, fltY, fltZ);
        Scale(vPos);
}

void Mesh::Scale(std::string strXml, bool bUpdateMatrix)
{
        CStdXml oXml;
        oXml.Deserialize(strXml);
        oXml.FindElement("Root");
        oXml.FindChildElement("Scale");
        
        CStdFPoint vPos;
        Std_LoadPoint(oXml, "Scale", vPos);
        Scale(vPos);
}

void Mesh::SetBoundingBox(int iIdx, float fltVal)
{
        if(iIdx >= 0 && iIdx <= 2 && fltVal > 0)
        {
                BoundingBox bb = GetBoundingBox();

                //Calculate the scale change required.
                float fltOldDim = bb.GetDimensionSize(iIdx);

                if(fltOldDim > 0)
                {
                        float fltNewDim = fltVal*m_lpSim->InverseDistanceUnits();
                        float fltConvert = fltNewDim / fltOldDim;

                        float fltNewX = m_vScale.x*fltConvert;
                        float fltNewY = m_vScale.y*fltConvert;
                        float fltNewZ = m_vScale.z*fltConvert;

                        Scale(fltNewX, fltNewY, fltNewZ);
                }       
        }
        else
                THROW_PARAM_ERROR(Al_Err_lInvalidMeshScaleParam, Al_Err_strInvalidMeshScaleParam, "Data", fltVal);

}

void Mesh::SetMeshFile(std::string strXml)
{
        CStdXml oXml;
        oXml.Deserialize(strXml);
        oXml.FindElement("Root");
        oXml.FindChildElement("MeshFile");

        m_strMeshFile = oXml.GetChildString("MeshFile");
        m_strConvexMeshFile = oXml.GetChildString("ConvexMeshFile", "");
        CollisionMeshType(oXml.GetChildString("MeshType"));
}

float *Mesh::GetDataPointer(const std::string &strDataType)
{
        float *lpData=NULL;
        std::string strType = Std_CheckString(strDataType);

        float *lpVal = NULL; 

        if(strType == "SCALE.X")
                lpData = &m_vReportScale.x;
        else if(strType == "SCALE.Y")
                lpData = &m_vReportScale.y;
        else if(strType == "SCALE.Z")
                lpData = &m_vReportScale.z;
        else
                lpData = RigidBody::GetDataPointer(strDataType);

        return lpData;
}

bool Mesh::SetData(const std::string &strDataType, const std::string &strValue, bool bThrowError)
{
        std::string strType = Std_CheckString(strDataType);

        if(RigidBody::SetData(strType, strValue, false))
                return true;

        if(strType == "MESHFILE")
        {
                MeshFile(strValue);
                return true;
        }

        if(strType == "MESHTYPE")
        {
                CollisionMeshType(strValue);
                return true;
        }

        if(strType == "CONVEXMESHFILE")
        {
                ConvexMeshFile(strValue);
                return true;
        }

        if(strType == "SETMESHFILE")
        {
                SetMeshFile(strValue);
                return true;
        }

        if(strType == "SCALE")
        {
                Scale(strValue);
                return true;
        }

        if(strType == "SCALE.X")
        {
                Scale(atof(strValue.c_str()), m_vScale.y, m_vScale.z);
                return true;
        }

        if(strType == "SCALE.Y")
        {
                Scale(m_vScale.x, atof(strValue.c_str()), m_vScale.z);
                return true;
        }

        if(strType == "SCALE.Z")
        {
                Scale(m_vScale.x, m_vScale.y, atof(strValue.c_str()));
                return true;
        }

        //If it was not one of those above then we have a problem.
        if(bThrowError)
                THROW_PARAM_ERROR(Al_Err_lInvalidDataType, Al_Err_strInvalidDataType, "Data Type", strDataType);

        return false;
}

void Mesh::QueryProperties(CStdPtrArray<TypeProperty> &aryProperties)
{
        RigidBody::QueryProperties(aryProperties);

        aryProperties.Add(new TypeProperty("MeshFile", AnimatPropertyType::String, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("MeshType", AnimatPropertyType::String, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("ConvexMeshFile", AnimatPropertyType::String, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("SetMeshFile", AnimatPropertyType::Xml, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Scale", AnimatPropertyType::Xml, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Scale.X", AnimatPropertyType::Float, AnimatPropertyDirection::Both));
        aryProperties.Add(new TypeProperty("Scale.Y", AnimatPropertyType::Float, AnimatPropertyDirection::Both));
        aryProperties.Add(new TypeProperty("Scale.Z", AnimatPropertyType::Float, AnimatPropertyDirection::Both));
}

void Mesh::Load(CStdXml &oXml)
{
        RigidBody::Load(oXml);

        oXml.IntoElem();  //Into RigidBody Element

        MeshFile(oXml.GetChildString("MeshFile"));
        CollisionMeshType(oXml.GetChildString("MeshType"));
        ConvexMeshFile(oXml.GetChildString("ConvexMeshFile", ""));

        Std_LoadPoint(oXml, "Scale", m_vScale, false);
        m_vReportScale = m_vScale;

        oXml.OutOfElem(); //OutOf RigidBody Element

}

                }               //Bodies
        }                       //Environment
}                               //AnimatSim