BodyPart.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 "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
        {
BodyPart::BodyPart(void)
{
        m_lpPhysicsBody = NULL;
        m_bSynchWithRobot = false;
        m_fltSynchUpdateInterval = 0;
        m_iSynchUpdateInterval = 0;
        m_iSynchCount = 0;
}

BodyPart::~BodyPart(void)
{

try
{
        m_aryRobotParts.RemoveAll();
}
catch(...)
{Std_TraceMsg(0, "Caught Error in desctructor of BodyPart\r\n", "", -1, false, true);}
}

#pragma region AccessorMutators

void BodyPart::UpdateData()
{
        if(m_lpPhysicsMovableItem)
                m_lpPhysicsMovableItem->Physics_CollectData();
}

void BodyPart::UpdateExtraData()
{
        if(m_lpPhysicsMovableItem)
                m_lpPhysicsMovableItem->Physics_CollectExtraData();
}


IPhysicsBody *BodyPart::PhysicsBody() {return m_lpPhysicsBody;}

void BodyPart::PhysicsBody(IPhysicsBody *lpBody) 
{
        m_lpPhysicsBody = lpBody;
}

void BodyPart::Resize() 
{
        if(m_lpPhysicsMovableItem)
                m_lpPhysicsMovableItem->Physics_Resize();

        if(m_lpCallback)
                m_lpCallback->SizeChanged();
}

bool BodyPart::SynchWithRobot() {return m_bSynchWithRobot;}

void BodyPart::SynchWithRobot(bool bVal) {m_bSynchWithRobot = bVal;}

float BodyPart::SynchUpdateInterval() {return m_fltSynchUpdateInterval;}

void BodyPart::SynchUpdateInterval(float fltVal)
{
        Std_IsAboveMin((float) 0, fltVal, true, "SynchUpdateInterval", true);
        m_fltSynchUpdateInterval = fltVal;

        if(m_lpSim)
        {
                float fltTimeStep = m_lpSim->PhysicsTimeStep();

                if(fltTimeStep > 0)
                        m_iSynchUpdateInterval = (int) ((m_fltSynchUpdateInterval/fltTimeStep) + 0.5);
                else
                        m_iSynchUpdateInterval = 0;
        }
}

#pragma endregion

void BodyPart::Selected(bool bValue, bool bSelectMultiple)
{
        Node::Selected(bValue, bSelectMultiple);
        MovableItem::Selected(bValue, bSelectMultiple);
}

void BodyPart::VisualSelectionModeChanged(int iNewMode)
{
        Node::VisualSelectionModeChanged(iNewMode);
        MovableItem::VisualSelectionModeChanged(iNewMode);
}

void BodyPart::AddBodyClicked(float fltPosX, float fltPosY, float fltPosZ, float fltNormX, float fltNormY, float fltNormZ)
{
        if(m_lpCallback)
                m_lpCallback->AddBodyClicked(fltPosX, fltPosY, fltPosZ, fltNormX, fltNormY, fltNormZ);
}

void BodyPart::WakeDynamics()
{
    if(m_lpPhysicsBody)
        m_lpPhysicsBody->Physics_WakeDynamics();
}

#pragma region DataAccesMethods

void BodyPart::SetSystemPointers(Simulator *lpSim, Structure *lpStructure, NeuralModule *lpModule, Node *lpNode, bool bVerify)
{
        Node::SetSystemPointers(lpSim, lpStructure, lpModule, lpNode, bVerify);
        m_lpMovableSim = lpSim;
}

float *BodyPart::GetDataPointer(const std::string &strDataType)
{
        return MovableItem::GetDataPointer(strDataType);
}

bool BodyPart::SetData(const std::string &strDataType, const std::string &strValue, bool bThrowError)
{
        if(Node::SetData(strDataType, strValue, false))
                return true;

        if(MovableItem::SetData(strDataType, strValue, false))
                return true;
        
        std::string strType = Std_CheckString(strDataType);

        if(strType == "SYNCHWITHROBOT")
        {
                SynchWithRobot(Std_ToBool(strValue));
                return true;
        }

        if(strType == "SYNCHUPDATEINTERVAL")
        {
                SynchUpdateInterval(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 BodyPart::QueryProperties(CStdPtrArray<TypeProperty> &aryProperties)
{
        Node::QueryProperties(aryProperties);
        MovableItem::QueryProperties(aryProperties);
        aryProperties.Add(new TypeProperty("SynchWithRobot", AnimatPropertyType::Boolean, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("SynchUpdateInterval", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
}

CStdArray<RobotPartInterface *> *BodyPart::GetRobotPartInterfaces() {return &m_aryRobotParts;};

void BodyPart::AddRobotPartInterface(RobotPartInterface *lpPart) 
{
        if(FindRobotPartListIndex(lpPart->ID(), false) == -1)
                m_aryRobotParts.Add(lpPart);
};

void BodyPart::RemoveRobotPartInterface(RobotPartInterface *lpPart) 
{
        int iIdx = FindRobotPartListIndex(lpPart->ID(), false);
        if(iIdx >= 0)
                m_aryRobotParts.RemoveAt(iIdx);
};

int BodyPart::FindRobotPartListIndex(std::string strID, bool bThrowError)
{
        int iCount = m_aryRobotParts.GetSize();
        for(int iIdx=0; iIdx<iCount; iIdx++)
                if(m_aryRobotParts[iIdx]->ID() == strID)
                        return iIdx;

        if(bThrowError)
                THROW_PARAM_ERROR(Al_Err_lPartInterfaceIDNotFound, Al_Err_strPartInterfaceIDNotFound, "ID", strID);

        return -1;
}

#pragma endregion

void BodyPart::TimeStepModified()
{
        Node::TimeStepModified();
        SynchUpdateInterval(m_fltSynchUpdateInterval);
}

bool BodyPart::NeedsRobotSynch()
{
        if(!m_lpSim->InSimulation() || !m_lpSim->RobotAdpaterSynch() || !m_bSynchWithRobot || m_iSynchUpdateInterval <= 0)
                return true;
        
        bool bRet = false;

        if(m_iSynchCount == m_iSynchUpdateInterval)
        {
                m_iSynchCount = 0;
                bRet = true;
        }
        else
                m_iSynchCount++;

        return bRet;
}

void BodyPart::ResetSimulation()
{
        Node::ResetSimulation();

        m_iSynchCount = 0;
}

void BodyPart::Initialize()
{
        Node::Initialize();
        SynchUpdateInterval(m_fltSynchUpdateInterval);
}

void BodyPart::UpdatePhysicsPosFromGraphics()
{
}

void BodyPart::Load(CStdXml &oXml)
{
        Node::Load(oXml);
        MovableItem::Load(oXml);

        oXml.IntoElem();  //Into BodyPart Element

        SynchWithRobot(oXml.GetChildBool("SynchWithRobot", m_bSynchWithRobot));
        SynchUpdateInterval(oXml.GetChildFloat("SynchUpdateInterval", m_fltSynchUpdateInterval));

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

        }                       //Environment
}                               //AnimatSim