AnimatBase.cpp

Go to the documentation of this file.

#include "StdAfx.h"
#include "IMovableItemCallback.h"
#include "ISimGUICallback.h"
#include "AnimatBase.h"

#include <sys/types.h>
#include <sys/stat.h>
#include "Gain.h"
#include "Node.h"
#include "Link.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 "NeuralModule.h"
#include "Adapter.h"
#include "NervousSystem.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
{

AnimatBase::AnimatBase()
{
        m_lpSim = NULL;
        m_lpStructure = NULL;
        m_lpModule = NULL;
        m_lpNode = NULL;
        m_strID = Std_CreateAppID();
        m_bSelected = false;
        m_bEnabled = true;
}

AnimatBase::~AnimatBase()
{

try
{
        //This will remove this object from the object list of the simulation.
        if(m_lpSim)
                m_lpSim->RemoveFromObjectList(this);
}
catch(...)
{Std_TraceMsg(0, "Caught Error in desctructor of AnimatBase\r\n", "", -1, false, true);}
}

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

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

Simulator *AnimatBase::GetSimulator() {return m_lpSim;}

Structure *AnimatBase::GetStructure() {return m_lpStructure;}

NeuralModule *AnimatBase::GetNeuralModule() {return m_lpModule;}

Node *AnimatBase::GetNode() {return m_lpNode;}

std::string AnimatBase::ID() {return m_strID;}

void AnimatBase::ID(std::string strID) 
{
        if(Std_IsBlank(strID))
                THROW_ERROR(Al_Err_lIDBlank, Al_Err_strIDBlank);

        m_strID = Std_CheckString(strID);
}

std::string AnimatBase::Name() {return m_strName;}

void AnimatBase::Name(std::string strValue) {m_strName = strValue;}

std::string AnimatBase::Type() {return m_strType;}

void AnimatBase::Type(std::string strValue) {m_strType = strValue;}

bool AnimatBase::Selected() {return m_bSelected;}

void AnimatBase::Selected(bool bValue, bool bSelectMultiple) {m_bSelected = bValue;}

void AnimatBase::Copy(CStdSerialize *lpSource)
{
        CStdSerialize::Copy(lpSource);

        AnimatBase *lpOrig = dynamic_cast<AnimatBase *>(lpSource);

        m_bEnabled = lpOrig->m_bEnabled;
        m_lpSim = lpOrig->m_lpSim;
        m_lpStructure = lpOrig->m_lpStructure;
        m_lpModule = lpOrig->m_lpModule;
        m_lpNode = lpOrig->m_lpNode;
        m_strID = lpOrig->m_strID;
        m_strType = lpOrig->m_strType;
        m_strName = lpOrig->m_strName;
        m_bSelected = lpOrig->m_bSelected;
}

#pragma region DataAccesMethods


//Don't know why, but the documentation for this has to be in the .h file. When I try and put it here
//it is not processed by doxygen. ????
void AnimatBase::SetSystemPointers(Simulator *lpSim, Structure *lpStructure, NeuralModule *lpModule, Node *lpNode, bool bVerify)
{
        m_lpSim = lpSim;
        m_lpStructure = lpStructure;
        m_lpModule = lpModule;
        m_lpNode = lpNode;

        if(bVerify) VerifySystemPointers();
}

void AnimatBase::VerifySystemPointers()
{
        if(!m_lpSim)
                THROW_ERROR(Al_Err_lSimulationNotDefined, Al_Err_strSimulationNotDefined);
}

float *AnimatBase::GetDataPointer(const std::string &strDataType)
{
        //If we are using the AnimatBase function then there are no data pointer, so throw an error.
        THROW_TEXT_ERROR(Al_Err_lDataPointNotFound, Al_Err_strDataPointNotFound, ("ID: " + m_strID + " Name: " + m_strName));
        return NULL;
}

bool AnimatBase::SetData(const std::string &strDataType, const std::string &strValue, bool bThrowError)
{
        if(strDataType == "NAME")
        {
                Name(strValue);
                return true;
        }

        if(strDataType == "CALL_INIT")
        {
                this->Initialize();
                return true;
        }

        //If we are using the AnimatBase function then there are no data pointer, so throw an error.
        if(bThrowError)
                THROW_TEXT_ERROR(Al_Err_lDataPointNotFound, Al_Err_strDataPointNotFound, ("ID: " + m_strID + " Name: " + m_strName));
        return false;
}

bool AnimatBase::SetData(const std::string &strDataType, const float fltValue, bool bThrowError)
{
        return SetData(strDataType, Std_ToStr(fltValue), bThrowError);
}

bool AnimatBase::SetData(const std::string &strDataType, const long lValue, bool bThrowError)
{
        return SetData(strDataType, Std_ToStr(lValue), bThrowError);
}


void AnimatBase::QueryProperties(CStdPtrArray<TypeProperty> &aryProperties)
{
        aryProperties.Add(new TypeProperty("Name", AnimatPropertyType::String, AnimatPropertyDirection::Set));
}

bool AnimatBase::HasProperty(const std::string &strName)
{
        CStdPtrArray<TypeProperty> aryProperties;
        QueryProperties(aryProperties);

        std::string strCheck = Std_CheckString(strName);
        int iCount = aryProperties.GetSize();
        for(int iIdx=0; iIdx<iCount; iIdx++)
                if(Std_CheckString(aryProperties[iIdx]->m_strName) == strCheck)
                        return true;

        return false;
}


AnimatPropertyType AnimatBase::PropertyType(const std::string &strName)
{
        CStdPtrArray<TypeProperty> aryProperties;
        QueryProperties(aryProperties);

        std::string strCheck = Std_CheckString(strName);
        int iCount = aryProperties.GetSize();
        for(int iIdx=0; iIdx<iCount; iIdx++)
                if(Std_CheckString(aryProperties[iIdx]->m_strName) == strCheck)
                        return aryProperties[iIdx]->m_eType;

        return AnimatPropertyType::Invalid;
}

bool AnimatBase::AddItem(const std::string &strItemType, const std::string &strXml, bool bThrowError, bool bDoNotInit)
{
        //If we are using the AnimatBase function then there are no data pointer, so throw an error.
        if(bThrowError)
                THROW_TEXT_ERROR(Al_Err_lItemTypeInvalid, Al_Err_strItemTypeInvalid, ("ID: " + m_strID + " ItemType: " + strItemType));
        return false;
}

bool AnimatBase::RemoveItem(const std::string &strItemType, const std::string &strID, bool bThrowError)
{
        //If we are using the AnimatBase function then there are no data pointer, so throw an error.
        if(bThrowError)
                THROW_TEXT_ERROR(Al_Err_lItemNotFound, Al_Err_strItemNotFound, ("ID: " + m_strID));
        return false;
}

#pragma endregion


#pragma region SimulationMethods

void AnimatBase::Reset() {};

void AnimatBase::Initialize()
{
        VerifySystemPointers();
}

void AnimatBase::ResetSimulation() {};

void AnimatBase::AfterResetSimulation() {};

void AnimatBase::ReInitialize() {};

void AnimatBase::Kill(bool bState) {};

void AnimatBase::StepSimulation() {};

void AnimatBase::SimStarting() {};

void AnimatBase::SimPausing() {};

void AnimatBase::SimStopping() {};

void AnimatBase::TimeStepModified() {};

#pragma endregion

#pragma region SnapshotMethods

long AnimatBase::CalculateSnapshotByteSize() {return 0;}

void AnimatBase::SaveKeyFrameSnapshot(byte *aryBytes, long &lIndex) {}

void AnimatBase::LoadKeyFrameSnapshot(byte *aryBytes, long &lIndex) {}

#pragma endregion

void AnimatBase::VisualSelectionModeChanged(int iNewMode) {}

void AnimatBase::Load(StdUtils::CStdXml &oXml)
{
        VerifySystemPointers();

        oXml.IntoElem();
        m_strType = oXml.GetChildString("Type", m_strType);
        m_strID = Std_CheckString(oXml.GetChildString("ID", m_strID));
        m_strName = oXml.GetChildString("Name", m_strName);
        Enabled(oXml.GetChildBool("Enabled", m_bEnabled));
        oXml.OutOfElem();

        if(Std_IsBlank(m_strID)) 
                THROW_ERROR(Al_Err_lIDBlank, Al_Err_strIDBlank);

        if(Std_IsBlank(m_strName)) 
                m_strName = m_strID;

        //if(Std_ToLower(m_strID) == "d10da888-6478-4d60-b878-0e761b7e8ef2")
        //      m_strID = m_strID;

        //This will add this object to the object list of the simulation.
        if(m_lpSim)
                m_lpSim->AddToObjectList(this);
}

}                       //AnimatSim