Structure.h

Go to the documentation of this file.

#pragma once

#include "ScriptProcessor.h"
#include "RobotInterface.h"
#include "RobotIOControl.h"
#include "RobotPartInterface.h"

namespace AnimatSim
{

        namespace Environment
        {

                class ANIMAT_PORT CollisionPair : public AnimatBase
                {
                public:
                        std::string m_strPart1ID;
                        std::string m_strPart2ID;

                        CollisionPair() {};

                        ~CollisionPair() {};
                };


                class ANIMAT_PORT Structure : public AnimatBase, public MovableItem 
                {
                protected:
                        RigidBody *m_lpBody;

                        CStdMap<std::string, RigidBody *> m_aryRigidBodies;

                        CStdMap<std::string, Joint *> m_aryJoints;

                        CStdPtrArray<CollisionPair> m_aryExcludeCollisionList;

                        IMovableItemCallback *m_lpCallback;

                        float m_fltSize;

                        ScriptProcessor *m_lpScript;

                        virtual void LoadLayout(CStdXml &oXml);
                        virtual void LoadCollisionPair(CStdXml &oXml);
                        virtual RigidBody *LoadRoot(CStdXml &oXml);

                        virtual void AddRoot(std::string strXml);
                        virtual void RemoveRoot(std::string strID, bool bThrowError = true);

                        virtual ScriptProcessor *LoadScript(CStdXml &oXml);
                        virtual void AddScript(std::string strXml);
                        virtual void RemoveScript(std::string strID, bool bThrowError = true);

                        virtual void UpdateData();

                public:
                        Structure();
                        virtual ~Structure();
                                                
                        static Structure *CastToDerived(AnimatBase *lpBase) {return static_cast<Structure*>(lpBase);}

                        void Sim(Simulator *lpSim);

                        virtual void Body(RigidBody *lpBody);
                        virtual RigidBody *Body();

                        virtual CStdFPoint Position();
                        virtual void Position(CStdFPoint &oPoint, bool bUseScaling = true, bool bFireChangeEvent = false, bool bUpdateMatrix = true);

                        virtual float Size();
                        virtual void Size(float fltVal, bool bUseScaling = true);

                        virtual RobotInterface *GetRobotInterface() {return NULL;};

                        virtual bool AllowTranslateDragX();
                        virtual bool AllowTranslateDragY();
                        virtual bool AllowTranslateDragZ();

                        virtual bool AllowRotateDragX();
                        virtual bool AllowRotateDragY();
                        virtual bool AllowRotateDragZ();

                        virtual CStdPtrArray<CollisionPair> ExclusionList();
                        virtual void AddCollisionPair(std::string strID1, std::string strID2);

                        virtual void MinTimeStep(float &fltMin);

            virtual void Create();
                        virtual void StepPhysicsEngine();
                        virtual void ResetSimulation();

                        void AddJoint(Joint *lpJoint);
                        void RemoveJoint(std::string strID);
                        void AddRigidBody(RigidBody *lpBody);
                        void RemoveRigidBody(std::string strID);

                        virtual Joint *FindJoint(std::string strJointID, bool bThrowError = true);
                        virtual RigidBody *FindRigidBody(std::string strBodyID, bool bThrowError = true);
                        virtual Node *FindNode(std::string strID, bool bThrowError = true);
                        //virtual AnimatBase *FindCollisionPair(std::string strID, bool bThrowError = true);

                        virtual void EnableMotor(std::string strJointID, bool bVal);
                        virtual void SetMotorInput(std::string strJointID, float fltInput);

                        virtual void EnableCollision(RigidBody *lpCollisionBody);
                        virtual void DisableCollision(RigidBody *lpCollisionBody);

                        virtual void Selected(bool bValue, bool bSelectMultiple); 
                        virtual void UpdatePhysicsPosFromGraphics();

                        virtual void Script(ScriptProcessor *lpScript);
                        virtual ScriptProcessor *Script();

#pragma region DataAccesMethods

                        virtual void SetSystemPointers(Simulator *lpSim, Structure *lpStructure, NeuralModule *lpModule, Node *lpNode, bool bVerify);
                        virtual float *GetDataPointer(const std::string &strDataType);
                        virtual bool SetData(const std::string &strDataType, const std::string &strValue, bool bThrowError = true);
                        virtual void QueryProperties(CStdPtrArray<TypeProperty> &aryProperties);
                        virtual bool AddItem(const std::string &strItemType, const std::string &strXml, bool bThrowError = true, bool bDoNotInit = false);
                        virtual bool RemoveItem(const std::string &strItemType, const std::string &strID, bool bThrowError = true);

#pragma endregion

#pragma region SnapshotMethods
                        virtual long CalculateSnapshotByteSize();
                        virtual void SaveKeyFrameSnapshot(byte *aryBytes, long &lIndex);
                        virtual void LoadKeyFrameSnapshot(byte *aryBytes, long &lIndex);
#pragma endregion

                        virtual void Initialize();
                        virtual void Kill(bool bState = true);
                        virtual void SimStarting();
                        virtual void SimPausing();
                        virtual void SimStopping();

                        virtual void Load(CStdXml &oXml);
                };

        }                       // Environment
}                               //AnimatSim