BlMaterialType.cpp

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

#include "StdAfx.h"
#include "BlJoint.h"
#include "BlRigidBody.h"
#include "BlSimulator.h"

namespace BulletAnimatSim
{
        namespace Environment
        {

// Construction/Destruction

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

BlMaterialType::~BlMaterialType()
{
}

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

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

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


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

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

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

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

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

bool BlMaterialType::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 BlMaterialType::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 BlMaterialType::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 BlMaterialType::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 BlMaterialType::RemoveRigidBodyAssociation(RigidBody *lpBody)
{
        if(lpBody)
        {
                if(FindBodyByID(lpBody->ID(), false))
                        m_aryBodies.Remove(lpBody->ID());
        }
}

RigidBody *BlMaterialType::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 BlMaterialType::GetMaterialID(std::string strName)
{
    return -1;
}

void BlMaterialType::RegisterMaterialType()
{
}

void BlMaterialType::Initialize()
{
        MaterialType::Initialize();

    RegisterMaterialType();
        SetMaterialProperties();
}

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

                if(lpBlBody)
                        lpBlBody->MaterialTypeModified();
        }
}

        }                       // Visualization
}                               //BulletAnimatSim