MovableItem.h

#pragma once

namespace AnimatSim
{
        namespace Environment
        {
                class ANIMAT_PORT MovableItem
                {
                protected:
                        Simulator *m_lpMovableSim;
                        
                        RigidBody *m_lpParent;

                        CStdFPoint m_oAbsPosition;

                        // If this item is a structure then this is the world coordinates.
                        CStdFPoint m_oPosition;

                        CStdFPoint m_oReportPosition;

                        CStdFPoint m_oReportWorldPosition;

                        CStdFPoint m_oRotation;

                        CStdFPoint m_oReportRotation;

                        bool m_bIsVisible;

                        //Used to report back if visible.
                        float m_fltReportIsVisible;

                        //Transparencies
                        float m_fltGraphicsAlpha;

                        float m_fltCollisionsAlpha;

                        float m_fltJointsAlpha;

                        float m_fltReceptiveFieldsAlpha;

                        float m_fltSimulationAlpha;

                        float m_fltAlpha; //Current alpha

                        CStdColor m_vAmbient;

                        CStdColor m_vDiffuse;

                        CStdColor m_vSpecular;

                        float m_fltShininess;

                        std::string m_strTexture;

                        CStdFPoint m_vSelectedVertex;

                        IMovableItemCallback *m_lpCallback;

                        IPhysicsMovableItem *m_lpPhysicsMovableItem;

                        float m_fltUserDefinedDraggerRadius;

            bool m_bIsSelected;

                        virtual void LoadPosition(CStdXml &oXml);
                        virtual void LoadRotation(CStdXml &oXml);

                public:
                        MovableItem(void);
                        virtual ~MovableItem(void);

#pragma region AccessorMutators

                        RigidBody *Parent();
                        void Parent(RigidBody *lpValue);

                        virtual int VisualSelectionType() ;
                        virtual bool AllowMouseManipulation();

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

                        virtual CStdFPoint AbsolutePosition();
                        virtual void AbsolutePosition(CStdFPoint &oPoint);
                        virtual void AbsolutePosition(float fltX, float fltY, float fltZ);

                        virtual CStdFPoint ReportPosition();
                        virtual void ReportPosition(CStdFPoint &oPoint);
                        virtual void ReportPosition(float fltX, float fltY, float fltZ);

                        virtual CStdFPoint ReportWorldPosition();
                        virtual void ReportWorldPosition(CStdFPoint &oPoint);
                        virtual void ReportWorldPosition(float fltX, float fltY, float fltZ);

                        virtual CStdFPoint UpdateAbsolutePosition();
                        virtual CStdFPoint GetCurrentPosition();

                        virtual CStdFPoint Rotation();
                        virtual void Rotation(CStdFPoint &oPoint, bool bFireChangeEvent = false, bool bUpdateMatrix = true);
                        virtual void Rotation(float fltX, float fltY, float fltZ, bool bFireChangeEvent = false, bool bUpdateMatrix = true);
                        virtual void Rotation(std::string strXml, bool bFireChangeEvent = false, bool bUpdateMatrix = true);

                        virtual CStdFPoint ReportRotation();
                        virtual void ReportRotation(CStdFPoint &oPoint);
                        virtual void ReportRotation(float fltX, float fltY, float fltZ);

            virtual std::string LocalTransformationMatrixString();

                        virtual bool IsVisible();
                        virtual void IsVisible(bool bVal);

                        virtual float GraphicsAlpha();
                        virtual void GraphicsAlpha(float fltVal);

                        virtual float CollisionsAlpha();
                        virtual void CollisionsAlpha(float fltVal);

                        virtual float JointsAlpha();
                        virtual void JointsAlpha(float fltVal);

                        virtual float ReceptiveFieldsAlpha();
                        virtual void ReceptiveFieldsAlpha(float fltVal);

                        virtual float SimulationAlpha();
                        virtual void SimulationAlpha(float fltVal);

                        virtual float Alpha();
                        virtual void Alpha(float fltAlpha);

                        virtual CStdColor *Ambient();
                        virtual void Ambient(CStdColor &aryColor);
                        virtual void Ambient(float *aryColor);
                        virtual void Ambient(std::string strXml);

                        virtual CStdColor *Diffuse();
                        virtual void Diffuse(CStdColor &aryColor);
                        virtual void Diffuse(float *aryColor);
                        virtual void Diffuse(std::string strXml);

                        virtual CStdColor *Specular();
                        virtual void Specular(CStdColor &aryColor);
                        virtual void Specular(float *aryColor);
                        virtual void Specular(std::string strXml);

                        virtual float Shininess();
                        virtual void Shininess(float fltVal);

                        virtual std::string Texture();
                        virtual void Texture(std::string strValue);
        
                        virtual CStdFPoint SelectedVertex();
                        virtual void SelectedVertex(CStdFPoint &vPoint, bool bFireChangeEvent = false, bool bUpdatePhysics = true);
                        virtual void SelectedVertex(float fltX, float fltY, float fltZ, bool bFireChangeEvent = false, bool bUpdatePhysics = true);

                        virtual IMovableItemCallback *Callback();
                        virtual void Callback(IMovableItemCallback *lpCallback);

                        virtual IPhysicsMovableItem *PhysicsMovableItem();
                        virtual void PhysicsMovableItem(IPhysicsMovableItem *lpBase);

                        virtual float GetBoundingRadius();
                        virtual BoundingBox GetBoundingBox();
                        virtual void SetBoundingBox(int iIdx, float fltVal);

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

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

                        virtual void UserDefinedDraggerRadius(float fltRadius);
                        virtual float UserDefinedDraggerRadius();

            virtual bool IsSelected();

#pragma endregion

#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);

#pragma endregion

                        virtual void AddBodyClicked(float fltPosX, float fltPosY, float fltPosZ, float fltNormX, float fltNormY, float fltNormZ);
                        virtual void Selected(bool bValue, bool bSelectMultiple); 
                        virtual void VisualSelectionModeChanged(int iNewMode);
                        virtual void OrientNewPart(float fltXPos, float fltYPos, float fltZPos, float fltXNorm, float fltYNorm, float fltZNorm);
                        virtual bool CalculateLocalPosForWorldPos(float fltWorldX, float fltWorldY, float fltWorldZ, CStdFPoint &vLocalPos);

                        virtual void Load(CStdXml &oXml);
                };

        }                       // Environment
}                               //AnimatSim