ConstraintRelaxation.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 "Sensor.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
        {
ConstraintRelaxation::ConstraintRelaxation()
{
    m_iCoordinateID = 0;
        m_fltStiffness = 1000e3;
        m_fltDamping = 500;
    m_bEnabled = false;
}

ConstraintRelaxation::~ConstraintRelaxation()
{
}

bool ConstraintRelaxation::Enabled()
{return m_bEnabled;}

void ConstraintRelaxation::Enabled(bool bVal)
{
        m_bEnabled = bVal;
        SetRelaxationProperties();
}

int ConstraintRelaxation::CoordinateID()
{return m_iCoordinateID;}

void ConstraintRelaxation::CoordinateID(int iVal)
{
        Std_IsAboveMin((int) 0, iVal, true, "CoordinateID", true);

        m_iCoordinateID = iVal;
        SetRelaxationProperties();
}

float ConstraintRelaxation::Stiffness() {return m_fltStiffness;}

void ConstraintRelaxation::Stiffness(float fltVal, bool bUseScaling) 
{
        Std_IsAboveMin((float) 0, fltVal, true, "Stiffness", true);

        if(bUseScaling)
                fltVal *= m_lpSim->InverseMassUnits();
        
        m_fltStiffness = fltVal;
        SetRelaxationProperties();
}

float ConstraintRelaxation::Damping() {return m_fltDamping;}

void ConstraintRelaxation::Damping(float fltVal, bool bUseScaling) 
{
        Std_IsAboveMin((float) 0, fltVal, true, "Damping", true);

        if(bUseScaling)
                fltVal = fltVal/m_lpSim->DisplayMassUnits();

        m_fltDamping = fltVal;
        SetRelaxationProperties();
}

void ConstraintRelaxation::CreateDefaultUnits()
{
        m_fltStiffness = 1e-7f;
        m_fltDamping = 5e4f;

        //scale the varios units to be consistent
        //Friction coefficients are unitless
        m_fltStiffness *= m_lpSim->InverseMassUnits(); 
        m_fltDamping *= m_lpSim->InverseMassUnits();
}

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

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

        if(strType == "COORDINATEID")
        {
                CoordinateID(atoi(strValue.c_str()));
                return true;
        }

        if(strType == "STIFFNESS")
        {
                Stiffness((float) atof(strValue.c_str()));
                return true;
        }
        
        if(strType == "DAMPING")
        {
                Damping((float) atof(strValue.c_str()));
                return true;
        }
        
        if(strType == "ENABLED")
        {
                Enabled(Std_ToBool(strValue));
                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 ConstraintRelaxation::QueryProperties(CStdPtrArray<TypeProperty> &aryProperties)
{
        AnimatBase::QueryProperties(aryProperties);

        aryProperties.Add(new TypeProperty("CoordinateID", AnimatPropertyType::Integer, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Enabled", AnimatPropertyType::Boolean, AnimatPropertyDirection::Both));
        aryProperties.Add(new TypeProperty("Damping", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Stiffness", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
}

void ConstraintRelaxation::Load(CStdXml &oXml)
{
        AnimatBase::Load(oXml);

        oXml.IntoElem();  //Into ConstraintRelaxation Element

    CoordinateID(oXml.GetChildInt("CoordinateID", m_iCoordinateID));
    Enabled(oXml.GetChildBool("Enabled", m_bEnabled));
        Stiffness(oXml.GetChildFloat("Stiffness", m_fltStiffness));
        Damping(oXml.GetChildFloat("Damping", m_fltDamping));

    oXml.OutOfElem(); //OutOf ConstraintRelaxation Element

}

        }                       // Visualization
}                               //VortexAnimatSim