MovableItem.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
        {
MovableItem::MovableItem(void)
{
        m_bIsVisible = true;
        m_fltReportIsVisible = 1;
        m_lpCallback = NULL;
        m_lpParent = NULL;
        m_lpPhysicsMovableItem = NULL;
        m_lpMovableSim = NULL;

        m_fltGraphicsAlpha = 1;
        m_fltCollisionsAlpha = 1;
        m_fltJointsAlpha = 1;
        m_fltReceptiveFieldsAlpha = 1;
        m_fltSimulationAlpha = 1;
        m_fltAlpha = 1;

        m_vAmbient.Set(0.1f, 0.1f, 0.1f, 1);
        m_vDiffuse.Set(1, 0, 0, 1);
        m_vSpecular.Set(0.25f, 0.25f, 0.25f, 1);
        m_fltShininess = 64;
        m_fltUserDefinedDraggerRadius = -1;
    m_bIsSelected = false;
}

MovableItem::~MovableItem(void)
{
}

#pragma region AccessorMutators

RigidBody *MovableItem::Parent() {return m_lpParent;}

void MovableItem::Parent(RigidBody *lpValue) 
{
        m_lpParent = lpValue;
        if(m_lpPhysicsMovableItem)
                m_lpPhysicsMovableItem->Physics_SetParent(lpValue);
}

int MovableItem::VisualSelectionType() {return 0;}

bool MovableItem::AllowMouseManipulation() {return true;}

CStdFPoint MovableItem::Position() {return m_oPosition;}

void MovableItem::Position(CStdFPoint &oPoint, bool bUseScaling, bool bFireChangeEvent, bool bUpdateMatrix) 
{
        if(bUseScaling)
                m_oPosition = oPoint * m_lpMovableSim->InverseDistanceUnits();
        else
                m_oPosition = oPoint;
        m_oReportPosition = m_oPosition * m_lpMovableSim->DistanceUnits();

        if(m_lpPhysicsMovableItem && bUpdateMatrix)
                m_lpPhysicsMovableItem->Physics_PositionChanged();

        if(m_lpCallback && bFireChangeEvent)
                m_lpCallback->PositionChanged();

        if(m_lpPhysicsMovableItem)
                m_lpPhysicsMovableItem->Physics_UpdateAbsolutePosition();
}

void MovableItem::Position(float fltX, float fltY, float fltZ, bool bUseScaling, bool bFireChangeEvent, bool bUpdateMatrix) 
{
        CStdFPoint vPos(fltX, fltY, fltZ);
        Position(vPos, bUseScaling, bFireChangeEvent);
}

void MovableItem::Position(std::string strXml, bool bUseScaling, bool bFireChangeEvent, bool bUpdateMatrix)
{
        CStdXml oXml;
        oXml.Deserialize(strXml);
        oXml.FindElement("Root");
        oXml.FindChildElement("Position");
        
        CStdFPoint vPos;
        Std_LoadPoint(oXml, "Position", vPos);
        Position(vPos, bUseScaling, bFireChangeEvent);
}

CStdFPoint MovableItem::AbsolutePosition() 
{
        if(!m_lpPhysicsMovableItem)
                THROW_ERROR(Al_Err_lAttempedToReadAbsPosBeforeDefined, Al_Err_strAttempedToReadAbsPosBeforeDefined);

        return m_oAbsPosition;
}

void MovableItem::AbsolutePosition(CStdFPoint &oPoint) 
{
        m_oAbsPosition = oPoint;
        m_oReportWorldPosition = m_oAbsPosition * m_lpMovableSim->DistanceUnits();
}

void MovableItem::AbsolutePosition(float fltX, float fltY, float fltZ) 
{
        m_oAbsPosition.Set(fltX, fltY, fltZ);
        m_oReportWorldPosition = m_oAbsPosition * m_lpMovableSim->DistanceUnits();
}

CStdFPoint MovableItem::GetCurrentPosition() {return m_oAbsPosition;}

CStdFPoint  MovableItem::UpdateAbsolutePosition()
{
        if(!m_lpPhysicsMovableItem)
                THROW_ERROR(Al_Err_lAttempedToReadAbsPosBeforeDefined, Al_Err_strAttempedToReadAbsPosBeforeDefined);

        m_lpPhysicsMovableItem->Physics_UpdateAbsolutePosition();

        return AbsolutePosition();
}

CStdFPoint MovableItem::ReportPosition() {return m_oReportPosition;}

void MovableItem::ReportPosition(CStdFPoint &oPoint) {m_oReportPosition = oPoint;}

void MovableItem::ReportPosition(float fltX, float fltY, float fltZ) {m_oReportPosition.Set(fltX, fltY, fltZ);}

CStdFPoint MovableItem::ReportWorldPosition() {return m_oReportWorldPosition;}

void MovableItem::ReportWorldPosition(CStdFPoint &oPoint) {m_oReportWorldPosition = oPoint;}

void MovableItem::ReportWorldPosition(float fltX, float fltY, float fltZ) {m_oReportWorldPosition.Set(fltX, fltY, fltZ);}

CStdFPoint MovableItem::Rotation()      {return m_oRotation;}

void MovableItem::Rotation(CStdFPoint &oPoint, bool bFireChangeEvent, bool bUpdateMatrix) 
{
        m_oRotation = oPoint;
        m_oReportRotation = m_oRotation;

        if(m_lpPhysicsMovableItem && bUpdateMatrix)
                m_lpPhysicsMovableItem->Physics_RotationChanged();

        if(m_lpCallback && bFireChangeEvent)
                m_lpCallback->RotationChanged();
}

void MovableItem::Rotation(float fltX, float fltY, float fltZ, bool bFireChangeEvent, bool bUpdateMatrix) 
{
        CStdFPoint vPos(fltX, fltY, fltZ);
        Rotation(vPos, bFireChangeEvent);
}

void MovableItem::Rotation(std::string strXml, bool bFireChangeEvent, bool bUpdateMatrix)
{
        CStdXml oXml;
        oXml.Deserialize(strXml);
        oXml.FindElement("Root");
        oXml.FindChildElement("Rotation");
        
        CStdFPoint vPos;
        Std_LoadPoint(oXml, "Rotation", vPos);
        Rotation(vPos, bFireChangeEvent);
}

CStdFPoint MovableItem::ReportRotation() {return m_oReportRotation;}

void MovableItem::ReportRotation(CStdFPoint &oPoint) {m_oReportRotation = oPoint;}

void MovableItem::ReportRotation(float fltX, float fltY, float fltZ) {m_oReportRotation.Set(fltX, fltY, fltZ);}

std::string MovableItem::LocalTransformationMatrixString()
{
        if(m_lpPhysicsMovableItem)
                return m_lpPhysicsMovableItem->Physics_GetLocalTransformMatrixString();
    else
        return "";
}

bool MovableItem::IsVisible() {return m_bIsVisible;}

void MovableItem::IsVisible(bool bVal) 
{
        m_bIsVisible = bVal;
        m_fltReportIsVisible = (float) bVal;

        if(m_lpPhysicsMovableItem)
                m_lpPhysicsMovableItem->SetVisible(m_bIsVisible);
}

float MovableItem::GraphicsAlpha() {return m_fltGraphicsAlpha;}

void MovableItem::GraphicsAlpha(float fltVal) 
{
        Std_InValidRange((float) 0, (float) 1, fltVal, true, "GraphicsAlpha");

        m_fltGraphicsAlpha = fltVal;

        if(m_lpPhysicsMovableItem)
                m_lpPhysicsMovableItem->SetAlpha();
}

float MovableItem::CollisionsAlpha() {return m_fltCollisionsAlpha;}

void MovableItem::CollisionsAlpha(float fltVal) 
{
        Std_InValidRange((float) 0, (float) 1, fltVal, true, "CollisionsAlpha");

        m_fltCollisionsAlpha = fltVal;

        if(m_lpPhysicsMovableItem)
                m_lpPhysicsMovableItem->SetAlpha();
}

float MovableItem::JointsAlpha() {return m_fltJointsAlpha;}

void MovableItem::JointsAlpha(float fltVal) 
{
        Std_InValidRange((float) 0, (float) 1, fltVal, true, "JointsAlpha");

        m_fltJointsAlpha = fltVal;

        if(m_lpPhysicsMovableItem)
                m_lpPhysicsMovableItem->SetAlpha();
}

float MovableItem::ReceptiveFieldsAlpha() {return m_fltReceptiveFieldsAlpha;}

void MovableItem::ReceptiveFieldsAlpha(float fltVal) 
{
        Std_InValidRange((float) 0, (float) 1, fltVal, true, "ReceptiveFieldsAlpha");

        m_fltReceptiveFieldsAlpha = fltVal;

        if(m_lpPhysicsMovableItem)
                m_lpPhysicsMovableItem->SetAlpha();
}

float MovableItem::SimulationAlpha() {return m_fltSimulationAlpha;}

void MovableItem::SimulationAlpha(float fltVal) 
{
        Std_InValidRange((float) 0, (float) 1, fltVal, true, "SimulationAlpha");

        m_fltSimulationAlpha = fltVal;

        if(m_lpPhysicsMovableItem)
                m_lpPhysicsMovableItem->SetAlpha();
}

float MovableItem::Alpha() {return m_fltAlpha;}

void MovableItem::Alpha(float fltAlpha) 
{
        Std_InValidRange((float) 0, (float) 1, fltAlpha, true, "Alpha");

        m_fltAlpha = fltAlpha;
}

CStdColor *MovableItem::Ambient() {return &m_vAmbient;}

void MovableItem::Ambient(CStdColor &aryColor)
{
        m_vAmbient = aryColor;
        if(m_lpPhysicsMovableItem) m_lpPhysicsMovableItem->Physics_SetColor();
}

void MovableItem::Ambient(float *aryColor)
{
        CStdColor vColor(aryColor[0], aryColor[1], aryColor[2], aryColor[3], 1);
        Ambient(vColor);
}

void MovableItem::Ambient(std::string strXml)
{
        CStdColor vColor(1);
        vColor.Load(strXml, "Color");
        Ambient(vColor);
}

CStdColor *MovableItem::Diffuse() {return &m_vDiffuse;}

void MovableItem::Diffuse(CStdColor &aryColor)
{
        m_vDiffuse = aryColor;
        if(m_lpPhysicsMovableItem) m_lpPhysicsMovableItem->Physics_SetColor();
}

void MovableItem::Diffuse(float *aryColor)
{
        CStdColor vColor(aryColor[0], aryColor[1], aryColor[2], aryColor[3], 1);
        Diffuse(vColor);
}

void MovableItem::Diffuse(std::string strXml)
{
        CStdColor vColor(1);
        vColor.Load(strXml, "Color");
        Diffuse(vColor);
}

CStdColor *MovableItem::Specular() {return &m_vSpecular;}

void MovableItem::Specular(CStdColor &aryColor)
{
        m_vSpecular = aryColor;
        if(m_lpPhysicsMovableItem) m_lpPhysicsMovableItem->Physics_SetColor();
}

void MovableItem::Specular(float *aryColor)
{
        CStdColor vColor(aryColor[0], aryColor[1], aryColor[2], aryColor[3], 1);
        Specular(vColor);
}

void MovableItem::Specular(std::string strXml)
{
        CStdColor vColor(1);
        vColor.Load(strXml, "Color");
        Specular(vColor);
}

float MovableItem::Shininess() {return m_fltShininess;}

void MovableItem::Shininess(float fltVal)
{
        Std_InValidRange((float) 0, (float) 128, fltVal, true, "Shininess");
        m_fltShininess = fltVal;
        if(m_lpPhysicsMovableItem) m_lpPhysicsMovableItem->Physics_SetColor();
}

std::string MovableItem::Texture() {return m_strTexture;}

void MovableItem::Texture(std::string strValue)
{
        m_strTexture = strValue;
        if(m_lpPhysicsMovableItem) m_lpPhysicsMovableItem->Physics_TextureChanged();
}

CStdFPoint MovableItem::SelectedVertex() {return m_vSelectedVertex;}

void MovableItem::SelectedVertex(CStdFPoint &vPoint, bool bFireChangeEvent, bool bUpdatePhysics) 
{
        m_vSelectedVertex = vPoint;
        
        if(m_lpPhysicsMovableItem)
                m_lpPhysicsMovableItem->Physics_SelectedVertex(vPoint.x, vPoint.y, vPoint.z);

        if(m_lpCallback && bFireChangeEvent)
                m_lpCallback->SelectedVertexChanged(vPoint.x, vPoint.y, vPoint.z);
}

void MovableItem::SelectedVertex(float fltX, float fltY, float fltZ, bool bFireChangeEvent, bool bUpdatePhysics) 
{
        CStdFPoint vPos(fltX, fltY, fltZ);
        SelectedVertex(vPos, bFireChangeEvent, bUpdatePhysics);
}

IMovableItemCallback *MovableItem::Callback() {return m_lpCallback;}

void MovableItem::Callback(IMovableItemCallback *lpCallback) {m_lpCallback = lpCallback;}

IPhysicsMovableItem *MovableItem::PhysicsMovableItem() {return m_lpPhysicsMovableItem;}

void MovableItem::PhysicsMovableItem(IPhysicsMovableItem *lpBody) {m_lpPhysicsMovableItem = lpBody;}

float MovableItem::GetBoundingRadius()
{
        if(m_lpPhysicsMovableItem)
                return m_lpPhysicsMovableItem->Physics_GetBoundingRadius();
        else
                return 1;
}

BoundingBox MovableItem::GetBoundingBox()
{
        BoundingBox bb;

        if(m_lpPhysicsMovableItem)
                return m_lpPhysicsMovableItem->Physics_GetBoundingBox();
        else
                return bb;
}

void MovableItem::SetBoundingBox(int iIdx, float fltVal)
{
}


bool MovableItem::AllowTranslateDragX() {return true;}


bool MovableItem::AllowTranslateDragY() {return true;}

bool MovableItem::AllowTranslateDragZ() {return true;}

bool MovableItem::AllowRotateDragX() {return true;}

bool MovableItem::AllowRotateDragY() {return true;}

bool MovableItem::AllowRotateDragZ() {return true;}

void MovableItem::UserDefinedDraggerRadius(float fltRadius)
{
        if(fltRadius <= 0)
                m_fltUserDefinedDraggerRadius = -1;
        else
                m_fltUserDefinedDraggerRadius = fltRadius;

        if(m_lpPhysicsMovableItem)
                m_lpPhysicsMovableItem->Physics_ResizeDragHandler(m_fltUserDefinedDraggerRadius);
}

float MovableItem::UserDefinedDraggerRadius()
{return m_fltUserDefinedDraggerRadius;}

bool MovableItem::IsSelected()
{return m_bIsSelected;}

#pragma endregion

void MovableItem::Selected(bool bValue, bool bSelectMultiple)
{
    m_bIsSelected = bValue;

        if(m_lpPhysicsMovableItem)
                m_lpPhysicsMovableItem->Physics_Selected(bValue, bSelectMultiple);

        if(m_lpCallback)
                m_lpCallback->SelectionChanged(bValue, bSelectMultiple);
}

void MovableItem::VisualSelectionModeChanged(int iNewMode)
{
        if(m_lpPhysicsMovableItem)
                m_lpPhysicsMovableItem->SetAlpha();
}
void MovableItem::AddBodyClicked(float fltPosX, float fltPosY, float fltPosZ, float fltNormX, float fltNormY, float fltNormZ)
{
        //Do nothing here in the base. This could be a strucutre, and we do not want to do anything for that class.
        //You need to implmenent this in the derived bodypart class.
}

void MovableItem::OrientNewPart(float fltXPos, float fltYPos, float fltZPos, float fltXNorm, float fltYNorm, float fltZNorm)
{
        if(m_lpPhysicsMovableItem)
                m_lpPhysicsMovableItem->Physics_OrientNewPart(fltXPos, fltYPos, fltZPos, fltXNorm, fltYNorm, fltZNorm);
}

bool MovableItem::CalculateLocalPosForWorldPos(float fltWorldX, float fltWorldY, float fltWorldZ, CStdFPoint &vLocalPos)
{
        if(m_lpPhysicsMovableItem)
                return m_lpPhysicsMovableItem->Physics_CalculateLocalPosForWorldPos(fltWorldX, fltWorldY, fltWorldZ, vLocalPos);
        return false;
}

#pragma region DataAccesMethods

float *MovableItem::GetDataPointer(const std::string &strDataType)
{
        std::string strType = Std_CheckString(strDataType);

        if(strType == "WORLDPOSITIONX")
                return &m_oReportWorldPosition.x;

        if(strType == "WORLDPOSITIONY")
                return &m_oReportWorldPosition.y;

        if(strType == "WORLDPOSITIONZ")
                return &m_oReportWorldPosition.z;

        if(strType == "POSITIONX")
                return &m_oReportPosition.x;

        if(strType == "POSITIONY")
                return &m_oReportPosition.y;

        if(strType == "POSITIONZ")
                return &m_oReportPosition.z;

        if(strType == "ROTATIONX")
                return &m_oReportRotation.x;

        if(strType == "ROTATIONY")
                return &m_oReportRotation.y;

        if(strType == "ROTATIONZ")
                return &m_oReportRotation.z;

        if(strType == "VISIBLE")
                return &m_fltReportIsVisible;

        return 0;
}

bool MovableItem::SetData(const std::string &strDataType, const std::string &strValue, bool bThrowError)
{
        if(strDataType == "POSITION")
        {
                Position(strValue);
                return true;
        }

        if(strDataType == "POSITION.X")
        {
                Position(atof(strValue.c_str()), m_oReportPosition.y, m_oReportPosition.z);
                return true;
        }

        if(strDataType == "POSITION.Y")
        {
                Position(m_oReportPosition.x, atof(strValue.c_str()), m_oReportPosition.z);
                return true;
        }

        if(strDataType == "POSITION.Z")
        {
                Position(m_oReportPosition.x, m_oReportPosition.y, atof(strValue.c_str()));
                return true;
        }

        if(strDataType == "ROTATION")
        {
                Rotation(strValue);
                return true;
        }

        if(strDataType == "ROTATION.X")
        {
                Rotation(atof(strValue.c_str()), m_oReportRotation.y, m_oReportRotation.z);
                return true;
        }

        if(strDataType == "ROTATION.Y")
        {
                Rotation(m_oReportRotation.x, atof(strValue.c_str()), m_oReportRotation.z);
                return true;
        }

        if(strDataType == "ROTATION.Z")
        {
                Rotation(m_oReportRotation.x, m_oReportRotation.y, atof(strValue.c_str()));
                return true;
        }

        if(strDataType == "BOUNDINGBOX.X")
        {
                SetBoundingBox(0, atof(strValue.c_str()));
                return true;
        }

        if(strDataType == "BOUNDINGBOX.Y")
        {
                SetBoundingBox(1, atof(strValue.c_str()));
                return true;
        }

        if(strDataType == "BOUNDINGBOX.Z")
        {
                SetBoundingBox(2, atof(strValue.c_str()));
                return true;
        }
        
        if(strDataType == "VISIBLE")
        {
                IsVisible(Std_ToBool(strValue));
                return true;
        }

        if(strDataType == "GRAPHICSALPHA")
        {
                GraphicsAlpha((float) atof(strValue.c_str()));
                return true;
        }

        if(strDataType == "COLLISIONALPHA")
        {
                CollisionsAlpha((float) atof(strValue.c_str()));
                return true;
        }

        if(strDataType == "JOINTSALPHA")
        {
                JointsAlpha((float) atof(strValue.c_str()));
                return true;
        }

        if(strDataType == "RECEPTIVEFIELDSALPHA")
        {
                ReceptiveFieldsAlpha((float) atof(strValue.c_str()));
                return true;
        }

        if(strDataType == "SIMULATIONALPHA")
        {
                SimulationAlpha((float) atof(strValue.c_str()));
                return true;
        }

        if(strDataType == "AMBIENT")
        {
                Ambient(strValue);
                return true;
        }

        if(strDataType == "AMBIENT.RED")
        {
                float aryVal[4] = {(float) atof(strValue.c_str()), m_vAmbient.g(), m_vAmbient.b(), m_vAmbient.a()};
                Ambient(aryVal);
                return true;
        }

        if(strDataType == "AMBIENT.GREEN")
        {
                float aryVal[4] = {m_vAmbient.r(), (float) atof(strValue.c_str()), m_vAmbient.b(), m_vAmbient.a()};
                Ambient(aryVal);
                return true;
        }

        if(strDataType == "AMBIENT.BLUE")
        {
                float aryVal[4] = {m_vAmbient.r(), m_vAmbient.g(), (float) atof(strValue.c_str()), m_vAmbient.a()};
                Ambient(aryVal);
                return true;
        }

        if(strDataType == "AMBIENT.ALPHA")
        {
                float aryVal[4] = {m_vAmbient.r(), m_vAmbient.g(), m_vAmbient.b(), (float) atof(strValue.c_str())};
                Ambient(aryVal);
                return true;
        }
        
        if(strDataType == "DIFFUSE")
        {
                Diffuse(strValue);
                return true;
        }

        if(strDataType == "DIFFUSE.RED")
        {
                float aryVal[4] = {(float) atof(strValue.c_str()), m_vDiffuse.g(), m_vDiffuse.b(), m_vDiffuse.a()};
                Diffuse(aryVal);
                return true;
        }

        if(strDataType == "DIFFUSE.GREEN")
        {
                float aryVal[4] = {m_vDiffuse.r(), (float) atof(strValue.c_str()), m_vDiffuse.b(), m_vDiffuse.a()};
                Diffuse(aryVal);
                return true;
        }

        if(strDataType == "DIFFUSE.BLUE")
        {
                float aryVal[4] = {m_vDiffuse.r(), m_vDiffuse.g(), (float) atof(strValue.c_str()), m_vDiffuse.a()};
                Diffuse(aryVal);
                return true;
        }

        if(strDataType == "DIFFUSE.ALPHA")
        {
                float aryVal[4] = {m_vDiffuse.r(), m_vDiffuse.g(), m_vDiffuse.b(), (float) atof(strValue.c_str())};
                Diffuse(aryVal);
                return true;
        }
        
        if(strDataType == "SPECULAR")
        {
                Specular(strValue);
                return true;
        }

        if(strDataType == "SPECULAR.RED")
        {
                float aryVal[4] = {(float) atof(strValue.c_str()), m_vSpecular.g(), m_vSpecular.b(), m_vSpecular.a()};
                Specular(aryVal);
                return true;
        }

        if(strDataType == "SPECULAR.GREEN")
        {
                float aryVal[4] = {m_vSpecular.r(), (float) atof(strValue.c_str()), m_vSpecular.b(), m_vSpecular.a()};
                Specular(aryVal);
                return true;
        }

        if(strDataType == "SPECULAR.BLUE")
        {
                float aryVal[4] = {m_vSpecular.r(), m_vSpecular.g(), (float) atof(strValue.c_str()), m_vSpecular.a()};
                Specular(aryVal);
                return true;
        }

        if(strDataType == "SPECULAR.ALPHA")
        {
                float aryVal[4] = {m_vSpecular.r(), m_vSpecular.g(), m_vSpecular.b(), (float) atof(strValue.c_str())};
                Specular(aryVal);
                return true;
        }
        
        if(strDataType == "SHININESS")
        {
                Shininess((float) atof(strValue.c_str()));
                return true;
        }
        
        if(strDataType == "TEXTURE")
        {
                Texture(strValue);
                return true;
        }
        
        if(strDataType == "DRAGGERRADIUS")
        {
                UserDefinedDraggerRadius((float) 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 MovableItem::QueryProperties(CStdPtrArray<TypeProperty> &aryProperties)
{
        aryProperties.Add(new TypeProperty("WorldPositionX", AnimatPropertyType::Float, AnimatPropertyDirection::Get));
        aryProperties.Add(new TypeProperty("WorldPositionY", AnimatPropertyType::Float, AnimatPropertyDirection::Get));
        aryProperties.Add(new TypeProperty("WorldPositionZ", AnimatPropertyType::Float, AnimatPropertyDirection::Get));
        aryProperties.Add(new TypeProperty("PositionX", AnimatPropertyType::Float, AnimatPropertyDirection::Get));
        aryProperties.Add(new TypeProperty("PositionY", AnimatPropertyType::Float, AnimatPropertyDirection::Get));
        aryProperties.Add(new TypeProperty("PositionZ", AnimatPropertyType::Float, AnimatPropertyDirection::Get));
        aryProperties.Add(new TypeProperty("RotationX", AnimatPropertyType::Float, AnimatPropertyDirection::Get));
        aryProperties.Add(new TypeProperty("RotationY", AnimatPropertyType::Float, AnimatPropertyDirection::Get));
        aryProperties.Add(new TypeProperty("RotationZ", AnimatPropertyType::Float, AnimatPropertyDirection::Get));

        aryProperties.Add(new TypeProperty("Position", AnimatPropertyType::Xml, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Position.X", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Position.Y", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Position.Z", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Rotation", AnimatPropertyType::Xml, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Rotation.X", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Rotation.Y", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Rotation.Z", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("BoundingBox.X", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("BoundingBox.Y", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("BoundingBox.Z", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Visible", AnimatPropertyType::Boolean, AnimatPropertyDirection::Both));
        aryProperties.Add(new TypeProperty("GraphicsAlpha", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("CollisionAlpha", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("JointsAlpha", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("ReceptiveFieldsAlpha", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("SimulationAlpha", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Ambient", AnimatPropertyType::Xml, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Ambient.Red", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Ambient.Green", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Ambient.Blue", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Ambient.Alpha", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Diffuse", AnimatPropertyType::Xml, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Diffuse.Red", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Diffuse.Green", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Diffuse.Blue", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Diffuse.Alpha", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Specular", AnimatPropertyType::Xml, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Specular.Red", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Specular.Green", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Specular.Blue", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Specular.Alpha", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Shininess", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Texture", AnimatPropertyType::String, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("DraggerRadius", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
}

#pragma endregion

void MovableItem::LoadPosition(CStdXml &oXml)
{
        CStdFPoint vTemp;

        Std_LoadPoint(oXml, "Position", vTemp);
        Position(vTemp, true, false, false);    
}

void MovableItem::LoadRotation(CStdXml &oXml)
{
        CStdFPoint vTemp;
        Std_LoadPoint(oXml, "Rotation", vTemp);
        Rotation(vTemp, false, false);  
}

void MovableItem::Load(CStdXml &oXml)
{
        oXml.IntoElem();  //Into Element
        
        LoadPosition(oXml);
        LoadRotation(oXml);

        IsVisible(oXml.GetChildBool("IsVisible", m_bIsVisible));
        GraphicsAlpha(oXml.GetChildFloat("GraphicsAlpha", m_fltGraphicsAlpha));
        CollisionsAlpha(oXml.GetChildFloat("CollisionsAlpha", m_fltCollisionsAlpha));
        JointsAlpha(oXml.GetChildFloat("JointsAlpha", m_fltJointsAlpha));
        ReceptiveFieldsAlpha(oXml.GetChildFloat("ReceptiveFieldsAlpha", m_fltReceptiveFieldsAlpha));
        SimulationAlpha(oXml.GetChildFloat("SimulationAlpha", m_fltSimulationAlpha));

        m_vDiffuse.Load(oXml, "Diffuse", false);
        m_vAmbient.Load(oXml, "Ambient", false);
        m_vSpecular.Load(oXml, "Specular", false);
        m_fltShininess = oXml.GetChildFloat("Shininess", m_fltShininess);

        m_strTexture = oXml.GetChildString("Texture", "");

        m_fltUserDefinedDraggerRadius = oXml.GetChildFloat("DraggerSize", m_fltUserDefinedDraggerRadius);

        oXml.OutOfElem(); //OutOf Element
}

        }                       //Environment
}                               //AnimatSim