RbMaterialType.cpp

// RbMaterialType.cpp: implementation of the RbMaterialType class.
//

#include "StdAfx.h"
#include "RbMovableItem.h"
#include "RbBody.h"
#include "RbJoint.h"
#include "RbRigidBody.h"
#include "RbSimulator.h"

namespace RoboticsAnimatSim
{
        namespace Environment
        {

// Construction/Destruction

RbMaterialType::RbMaterialType()
{
        m_fltFrictionLinearPrimary = 1;
        m_fltFrictionAngularPrimary = 0;
        m_fltRestitution = 0;
}

RbMaterialType::~RbMaterialType()
{
}

float RbMaterialType::FrictionLinearPrimary() {return m_fltFrictionLinearPrimary;}

void RbMaterialType::FrictionLinearPrimary(float fltVal) 
{
        Std_IsAboveMin((float) 0, fltVal, true, "FrictionLinearPrimary", true);
        
        m_fltFrictionLinearPrimary = fltVal;
        SetMaterialProperties();
}

float RbMaterialType::FrictionAngularPrimary() {return m_fltFrictionAngularPrimary;}


void RbMaterialType::FrictionAngularPrimary(float fltVal) 
{
        Std_IsAboveMin((float) 0, fltVal, true, "FrictionAngularPrimary", true);
        
        m_fltFrictionAngularPrimary = fltVal;
        SetMaterialProperties();
}

float RbMaterialType::FrictionAngularPrimaryConverted() 
{
    return m_fltFrictionAngularPrimary*6.3;
}

float RbMaterialType::Restitution() {return m_fltRestitution;}

void RbMaterialType::Restitution(float fltVal) 
{
        Std_InValidRange((float) 0, (float) 1, fltVal, true, "Restitution");
        m_fltRestitution = fltVal;
        SetMaterialProperties();
}

void RbMaterialType::CreateDefaultUnits()
{
        m_fltFrictionLinearPrimary = 1;
        m_fltFrictionAngularPrimary = 0;
        m_fltRestitution = 0;
}

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

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

        if(strType == "FRICTIONLINEARPRIMARY")
        {
                FrictionLinearPrimary((float) atof(strValue.c_str()));
                return true;
        }

        if(strType == "FRICTIONANGULARPRIMARY")
        {
                FrictionAngularPrimary((float) atof(strValue.c_str()));
                return true;
        }

        if(strType == "RESTITUTION")
        {
                Restitution((float) 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 RbMaterialType::QueryProperties(CStdPtrArray<TypeProperty> &aryProperties)
{
        MaterialType::QueryProperties(aryProperties);

        aryProperties.Add(new TypeProperty("FrictionLinearPrimary", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("FrictionAngularPrimary", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Restitution", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
}

void RbMaterialType::Load(CStdXml &oXml)
{
        MaterialType::Load(oXml);

        oXml.IntoElem();  //Into MaterialType Element

        FrictionLinearPrimary(oXml.GetChildFloat("FrictionLinearPrimary", m_fltFrictionLinearPrimary));
        FrictionAngularPrimary(oXml.GetChildFloat("FrictionAngularPrimary", m_fltFrictionAngularPrimary));
        Restitution(oXml.GetChildFloat("Restitution", m_fltRestitution));

    oXml.OutOfElem(); //OutOf MaterialType Element

}

void RbMaterialType::AddRigidBodyAssociation(RigidBody *lpBody)
{
        if(lpBody)
        {
                //If we do not already have this body in the list then add it.
                if(!FindBodyByID(lpBody->ID(), false))
                        m_aryBodies.Add(lpBody->ID(), lpBody);
        }
}

void RbMaterialType::RemoveRigidBodyAssociation(RigidBody *lpBody)
{
        if(lpBody)
        {
                if(FindBodyByID(lpBody->ID(), false))
                        m_aryBodies.Remove(lpBody->ID());
        }
}

RigidBody *RbMaterialType::FindBodyByID(std::string strID, bool bThrowError)
{
        RigidBody *lpFind = NULL;
        CStdMap<std::string, RigidBody *>::iterator oPos;
        oPos = m_aryBodies.find(Std_CheckString(strID));

        if(oPos != m_aryBodies.end())
                lpFind =  oPos->second;
        else if(bThrowError)
                THROW_PARAM_ERROR(Al_Err_lIDNotFound, Al_Err_strIDNotFound, "ID", strID);

        return lpFind;
}

int RbMaterialType::GetMaterialID(std::string strName)
{
    return -1;
}

void RbMaterialType::RegisterMaterialType()
{
}

void RbMaterialType::Initialize()
{
        //MaterialType::Initialize();

 //   RegisterMaterialType();
        //SetMaterialProperties();
}

void RbMaterialType::SetMaterialProperties()
{
        //CStdMap<std::string, RigidBody *>::iterator oPos;
        //RigidBody *lpBody = NULL;
        //RbRigidBody *lpRbBody = NULL;
        //for(oPos=m_aryBodies.begin(); oPos!=m_aryBodies.end(); ++oPos)
        //{
        //      lpBody = oPos->second;
        //      lpRbBody = dynamic_cast<RbRigidBody *>(lpBody);

        //      if(lpRbBody)
        //              lpRbBody->MaterialTypeModified();
        //}
}

        }                       // Visualization
}                               //RoboticsAnimatSim