ConstraintLimit.cpp

Go to the documentation of this file.

#include "StdAfx.h"
#include "AnimatBase.h"

#include "Node.h"
#include "IPhysicsMovableItem.h"
#include "IPhysicsBody.h"
#include "ISimGUICallback.h"
#include "BoundingBox.h"
#include "MovableItem.h"
#include "BodyPart.h"
#include "Joint.h"
#include "ReceptiveField.h"
#include "ContactSensor.h"
#include "RigidBody.h"
#include "ConstraintLimit.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
        {
ConstraintLimit::ConstraintLimit()
{
        m_lpSim = NULL;
        m_lpStructure = NULL;
        m_lpJoint = NULL;

        m_fltLimitPos = 0;
        m_fltDamping = 0;
        m_fltRestitution = 0;
        m_fltStiffness = 0;
        m_bIsLowerLimit = true;
        m_bIsShowPosition = false;
}

ConstraintLimit::~ConstraintLimit()
{
}

float ConstraintLimit::LimitPos() {return m_fltLimitPos;}

void ConstraintLimit::LimitPos(float fltVal, bool bUseScaling, bool bOverrideSameCheck) 
{
        //If the values are the same then skip setting this step to preven having to
        //recalculate the matrix positions repeatedly. Only do this when the new position is
        // different than the old one.
        if(fabs(fltVal - m_fltLimitPos) < 1e-5 && !bOverrideSameCheck)
                return;

        if(bUseScaling && m_lpSim && m_lpJoint && !m_lpJoint->UsesRadians())
                m_fltLimitPos = fltVal * m_lpSim->InverseDistanceUnits();
        else
                m_fltLimitPos = fltVal;

        SetLimitPos();
}

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

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

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

    m_fltDamping = fltVal;
        SetLimitValues();
}

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

void ConstraintLimit::Restitution(float fltVal)
{
        Std_IsAboveMin((float) 0, fltVal, true, "Constraint::Restitution", true);
        m_fltRestitution = fltVal;
        SetLimitValues();
}

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

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

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

        m_fltStiffness = fltVal;
        SetLimitValues();
}

void ConstraintLimit::Color(float fltR, float fltG, float fltB, float fltA)
{m_vColor.Set(fltR, fltG, fltB, fltA);}

CStdColor *ConstraintLimit::Color() {return &m_vColor;}

void ConstraintLimit::Color(std::string strXml)
{
        m_vColor.Load(strXml, "Color");
}

float ConstraintLimit::Alpha() {return m_vColor.a();}

void ConstraintLimit::IsLowerLimit(bool bVal) {m_bIsLowerLimit = bVal;}

bool ConstraintLimit::IsLowerLimit() {return m_bIsLowerLimit;}

void ConstraintLimit::IsShowPosition(bool bVal) {m_bIsShowPosition = bVal;}

bool ConstraintLimit::IsShowPosition() {return m_bIsShowPosition;}

void ConstraintLimit::SetSystemPointers(Simulator *lpSim, Structure *lpStructure, NeuralModule *lpModule, Node *lpNode, bool bVerify)
{
        AnimatBase::SetSystemPointers(lpSim, lpStructure, lpModule, lpNode, false);
        m_lpJoint = dynamic_cast<Joint *>(lpNode);

        if(bVerify) VerifySystemPointers();
}

void ConstraintLimit::SetSystemPointers(Simulator *lpSim, Structure *lpStructure, NeuralModule *lpModule, Node *lpNode, float fltPosition, bool bVerify)
{
        SetSystemPointers(lpSim, lpStructure, lpModule, lpNode, bVerify);
        LimitPos(fltPosition);
}
                
void ConstraintLimit::VerifySystemPointers()
{
        AnimatBase::VerifySystemPointers();

        if(!m_lpStructure)
                THROW_PARAM_ERROR(Al_Err_lStructureNotDefined, Al_Err_strStructureNotDefined, "ConstraintLimit: ", m_strName);

        if(!m_lpJoint)
                THROW_PARAM_ERROR(Al_Err_lJointNotDefined, Al_Err_strJointNotDefined, "ConstraintLimit: ", m_strName);
}

#pragma region DataAccesMethods

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

        if(strType == "LIMITPOS")
                return &m_fltLimitPos;
        else
                THROW_TEXT_ERROR(Al_Err_lInvalidDataType, Al_Err_strInvalidDataType, "JointID: " + STR(m_strName) + "  DataType: " + strDataType);

        return NULL;
}

bool ConstraintLimit::SetData(const std::string &strDataType, const std::string &strValue, bool bThrowError)
{
        std::string strType = Std_CheckString(strDataType);
        
        if(AnimatBase::SetData(strDataType, strValue, false))
                return true;

        if(strType == "LIMITPOS")
        {
                LimitPos((float) atof(strValue.c_str()));
                return true;
        }
        else if(strType == "DAMPING")
        {
                Damping((float) atof(strValue.c_str()));
                return true;
        }
        else if(strType == "RESTITUTION")
        {
                Restitution((float) atof(strValue.c_str()));
                return true;
        }
        else if(strType == "STIFFNESS")
        {
                Stiffness((float) atof(strValue.c_str()));
                return true;
        }
        else if(strType == "COLOR")
        {
                Color(strValue);
                return true;
        }
        else if(strType == "ALPHA")
        {
                Alpha((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 ConstraintLimit::QueryProperties(CStdPtrArray<TypeProperty> &aryProperties)
{
        AnimatBase::QueryProperties(aryProperties);

        aryProperties.Add(new TypeProperty("LimitPos", AnimatPropertyType::Float, AnimatPropertyDirection::Both));
        aryProperties.Add(new TypeProperty("Damping", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Restitution", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Stiffness", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Color", AnimatPropertyType::Xml, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Alpha", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
}

#pragma endregion

void ConstraintLimit::Load(CStdXml &oXml, std::string strName)
{
        oXml.FindChildElement(strName);

        AnimatBase::Load(oXml);

        oXml.IntoElem();  //Into ConstraintLimit Element

        LimitPos(oXml.GetChildFloat("LimitPos", m_fltLimitPos));
        Damping(oXml.GetChildFloat("Damping", m_fltDamping));
        Restitution(oXml.GetChildFloat("Restitution", m_fltRestitution));
        Stiffness(oXml.GetChildFloat("Stiffness", m_fltStiffness));

        oXml.OutOfElem(); //OutOf ConstraintLimit Element
}


        }                       //Environment
}                               //AnimatSim