RigidBody.h

Go to the documentation of this file.

#pragma once

namespace AnimatSim
{
        namespace Environment
        {
                class Odor;

                class ANIMAT_PORT RigidBody : public BodyPart    
                {
                protected:
                        CStdFPoint m_vCenterOfMass;

                        bool m_bFreeze;

                        float m_fltDensity;

            float m_fltReportDensity;

                        float m_fltMass;

                        float m_fltReportMass;

            float m_fltVolume;

                        float m_fltReportVolume;

                        CStdPtrArray<RigidBody> m_aryChildParts;

                        Joint *m_lpJointToParent;

                        bool m_bUsesJoint;

                        bool m_bIsContactSensor;

                        bool m_bIsCollisionObject;

                        float m_fltSurfaceContactCount;

                        bool m_bIsStickyPart;

                        float m_fltStickyOn;

                        RigidBody *m_lpStickyChild;

                        ContactSensor *m_lpContactSensor;

                        float m_fltLinearVelocityDamping;

                        float m_fltAngularVelocityDamping;

                        CStdPtrMap<std::string, Odor> m_aryOdorSources;
                        
                        bool m_bFoodSource;  
                        
                        float m_fltFoodQuantity;

                        float m_fltFoodQuantityInit;

                        float m_fltFoodEaten;

                        float m_fltMaxFoodQuantity;

                        float m_fltFoodReplenishRate;

                        float m_fltFoodEnergyContent;

                        long m_lEatTime;

                        std::string m_strMaterialID;

                        //Hyrdrodynamic properties
                        CStdFPoint m_vBuoyancyCenter;

                        float m_fltBuoyancyScale;

                        CStdFPoint m_vLinearDrag;

                        CStdFPoint m_vAngularDrag;

            float m_fltMaxHydroForce;

            float m_fltMaxHydroTorque;

                        float m_fltMagnus;
                        
                        bool m_bEnableFluids;

            bool m_bDisplayDebugCollisionGraphic;

            std::unordered_set<RigidBody *> m_aryExcludeCollisionSet;

                        virtual RigidBody *LoadRigidBody(CStdXml &oXml);
                        virtual Joint *LoadJoint(CStdXml &oXml);

                        virtual void LoadPosition(CStdXml &oXml);

                        virtual RigidBody *AddRigidBody(std::string strXml);
                        virtual void RemoveRigidBody(std::string strID, bool bThrowError = true);
                        virtual int FindChildListPos(std::string strID, bool bThrowError = true);

                        virtual void AddContactSensor(std::string strXml);
                        virtual void RemoveContactSensor(std::string strID, bool bThrowError = true);
                        virtual void LoadContactSensor(CStdXml &oXml);

                        virtual Odor *LoadOdor(CStdXml &oXml);
                        virtual void AddOdor(Odor *lpOdor);
                        virtual void AddOdor(std::string strXml, bool bDoNotInit);
                        virtual void RemoveOdor(std::string strID, bool bThrowError = true);

                        virtual void Mass(float fltVal, bool bUseScaling, bool bPhysicsCallback);
                        virtual void CenterOfMass(CStdFPoint &vPoint, bool bUseScaling, bool bPhysicsCallback);
                        virtual void Freeze(bool bVal, bool bPhysicsCallback);

            virtual void RemoveCollisionExclusions();

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

#pragma region AccessorMutators

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

                        virtual CStdFPoint CenterOfMass();
                        virtual CStdFPoint CenterOfMassWithStaticChildren();
                        virtual void CenterOfMass(CStdFPoint &vPoint, bool bUseScaling = true);
                        virtual void CenterOfMass(float fltX, float fltY, float fltZ, bool bUseScaling = true);
                        virtual void CenterOfMass(std::string strXml, bool bUseScaling = true);

                        virtual CStdPtrArray<RigidBody>* ChildParts();

                        virtual Joint *JointToParent();
                        virtual void JointToParent(Joint *lpValue);

                        virtual ContactSensor *GetContactSensor();

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

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

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

                        virtual bool Freeze();
                        virtual void Freeze(bool bVal);

                        virtual bool IsContactSensor();
                        virtual void IsContactSensor(bool bVal);

                        virtual bool IsCollisionObject();
                        virtual void IsCollisionObject(bool bVal);
                        
                        virtual bool IsStickyPart();
                        virtual void IsStickyPart(bool bVal);

                        virtual float StickyOn();
                        virtual void StickyOn(float fltVal);

                        virtual RigidBody *StickyChild();
                        virtual void StickyChild(RigidBody *lpChild);

                        virtual bool IsRoot();
                        virtual bool HasStaticJoint();
            virtual bool HasStaticChildren();
            virtual float StaticChildrenMass();

                        virtual bool IsFoodSource();
                        virtual void IsFoodSource(bool bVal);

                        virtual float FoodQuantity();
                        virtual void FoodQuantity(float fltVal);

                        virtual float FoodEaten();
                        virtual void FoodEaten(float fltVal);
                        
                        virtual float FoodReplenishRate();
                        virtual void FoodReplenishRate(float fltVal);

                        virtual float FoodEnergyContent();
                        virtual void FoodEnergyContent(float fltVal);

                        virtual float MaxFoodQuantity();
                        virtual void MaxFoodQuantity(float fltVal);

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

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

                        virtual std::string MaterialID();
                        virtual void MaterialID(std::string strID);

                        virtual CStdFPoint BuoyancyCenter();
                        virtual void BuoyancyCenter(CStdFPoint &oPoint, bool bUseScaling = true);
                        virtual void BuoyancyCenter(float fltX, float fltY, float fltZ, bool bUseScaling = true);
                        virtual void BuoyancyCenter(std::string strXml, bool bUseScaling = true);

                        virtual float BuoyancyScale();
                        virtual void BuoyancyScale(float fltVal);

                        virtual CStdFPoint LinearDrag();
                        virtual void LinearDrag(CStdFPoint &oPoint);
                        virtual void LinearDrag(float fltX, float fltY, float fltZ);
                        virtual void LinearDrag(std::string strXml);

                        virtual CStdFPoint AngularDrag();
                        virtual void AngularDrag(CStdFPoint &oPoint);
                        virtual void AngularDrag(float fltX, float fltY, float fltZ);
                        virtual void AngularDrag(std::string strXml);

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

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

                        virtual float Magnus();
                        virtual void Magnus(float fltVal);

                        virtual bool EnableFluids();
                        virtual void EnableFluids(bool bVal);

                        virtual bool HasCollisionGeometry();

            virtual bool DisplayDebugCollisionGraphic() {return m_bDisplayDebugCollisionGraphic;}
            virtual void DisplayDebugCollisionGraphic(bool bVal) {m_bDisplayDebugCollisionGraphic = bVal;}

            virtual std::unordered_set<RigidBody *> *GetExclusionCollisionSet() {return &m_aryExcludeCollisionSet;};
            virtual bool FindCollisionExclusionBody(RigidBody *lpBody, bool bThrowError = true);

#pragma endregion

                        virtual float SurfaceContactCount();

                        virtual void Eat(float fltBiteSize, long lTimeSlice);
                        virtual void AddSurfaceContact(RigidBody *lpContactedSurface);
                        virtual void RemoveSurfaceContact(RigidBody *lpContactedSurface);
            virtual void SetSurfaceContactCount(int iCount);
                        virtual void AddForceAtLocalPos(float fltPx, float fltPy, float fltPz, float fltFx, float fltFy, float fltFz, bool bScaleUnits);
                        virtual void AddForceAtWorldPos(float fltPx, float fltPy, float fltPz, float fltFx, float fltFy, float fltFz, bool bScaleUnits);
                        virtual void AddTorque(float fltTx, float fltTy, float fltTz, bool bScaleUnits);
                        virtual CStdFPoint GetVelocityAtPoint(float x, float y, float z);
                        virtual float GetMassValueWithStaticChildren();
                        virtual float GetDensity();
                        virtual float GetMass();
                        virtual float GetVolume();
                        virtual void UpdatePhysicsPosFromGraphics();
            virtual void UpdateChildPhysicsPosFromGraphics();

                        virtual RigidBody *ParentWithCollisionGeometry();

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

                        virtual void CreateParts();
            virtual void CreateChildParts();
                        virtual void CreateJoints();
            virtual void CreateChildJoints();

#pragma region DataAccesMethods

                        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

                        virtual void SimPausing();
                        virtual int GetTargetDataTypeIndex(const std::string &strDataType);
                        virtual void AddExternalNodeInput(int iTargetDataType, float fltInput);
                        virtual void StepSimulation();
                        virtual void ResetSimulation();
                        virtual void AfterResetSimulation();
                        virtual void Kill(bool bState = true);
                        virtual void Load(CStdXml &oXml);
                };

        }                       // Environment
}                               //AnimatSim