Plane.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 "Plane.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
        {
                namespace Bodies
                {
Plane::Plane()
{
        m_fltDensity = 0;
        m_bFreeze = true;

        m_ptSize.Set(200, 200, 0);
}

Plane::~Plane()
{

}

float Plane::CornerX() {return m_oAbsPosition.x-(m_ptSize.x/2.0f);}

float Plane::CornerY() {return m_oAbsPosition.y-(m_ptSize.y/2.0f);}

float Plane::GridX() {return (float) m_iWidthSegments;}

float Plane::GridY() {return (float) m_iLengthSegments;}

CStdFPoint Plane::Size() {return m_ptSize;}

void Plane::Size(CStdFPoint ptPoint, bool bUseScaling)
{
        if(ptPoint.x <= 0)
                THROW_PARAM_ERROR(Al_Err_lInavlidPlaneSize, Al_Err_strInavlidPlaneSize, "X Size", ptPoint.x);
        if(ptPoint.y <= 0)
                THROW_PARAM_ERROR(Al_Err_lInavlidPlaneSize, Al_Err_strInavlidPlaneSize, "Y Size", ptPoint.y);

        if(bUseScaling)
                m_ptSize = ptPoint * m_lpSim->InverseDistanceUnits();
        else
                m_ptSize = ptPoint;

        Resize();
}

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

int Plane::WidthSegments() {return m_iWidthSegments;}

void Plane::WidthSegments(int iVal)
{
        Std_IsAboveMin((int) 0, iVal, true, "Plane.WidthSegments");
        m_iWidthSegments = iVal;

        Resize();
}

int Plane::LengthSegments() {return m_iLengthSegments;}

void Plane::LengthSegments(int iVal)
{
        Std_IsAboveMin((int) 0, iVal, true, "Plane.LengthSegments");
        m_iLengthSegments = iVal;

        Resize();
}

bool Plane::SetData(const std::string &strDataType, const std::string &strValue, bool bThrowError)
{
        std::string strType = Std_CheckString(strDataType);

        if(RigidBody::SetData(strType, strValue, false))
                return true;

        if(strType == "SIZE")
        {
                Size(strValue);
                return true;
        }

        if(strType == "LENGTHSEGMENTS")
        {
                LengthSegments(atoi(strValue.c_str()));
                return true;
        }

        if(strType == "WIDTHSEGMENTS")
        {
                WidthSegments(atoi(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 Plane::QueryProperties(CStdPtrArray<TypeProperty> &aryProperties)
{
        RigidBody::QueryProperties(aryProperties);

        aryProperties.Add(new TypeProperty("Size", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("LengthSegments", AnimatPropertyType::Integer, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("WidthSegments", AnimatPropertyType::Integer, AnimatPropertyDirection::Set));
}

void Plane::Load(CStdXml &oXml)
{
        RigidBody::Load(oXml);

        //Plane  is always frozen
        m_bFreeze = true;

        oXml.IntoElem();  //Into RigidBody Element

        CStdFPoint vPos;
        Std_LoadPoint(oXml, "Size", vPos);
        Size(vPos);
        
        WidthSegments(oXml.GetChildInt("WidthSegments", m_iWidthSegments));
        LengthSegments(oXml.GetChildInt("LengthSegments", m_iLengthSegments));

        oXml.OutOfElem(); //OutOf RigidBody Element
}

                }               //Bodies
        }                       //Environment
}                               //AnimatSim