FluidPlane.cpp

// FluidPlane.cpp: implementation of the FluidPlane class.
//

#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 "FluidPlane.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
                {

FluidPlane::FluidPlane()
{
}

FluidPlane::~FluidPlane()
{

}


CStdFPoint FluidPlane::Velocity() {return m_vVelocity;}

void FluidPlane::Velocity(CStdFPoint &oPoint, bool bUseScaling) 
{
        if(bUseScaling)
                m_vVelocity = oPoint * m_lpMovableSim->InverseDistanceUnits();
        else
                m_vVelocity = oPoint;
}

void FluidPlane::Velocity(float fltX, float fltY, float fltZ, bool bUseScaling) 
{
        CStdFPoint vPos(fltX, fltY, fltZ);
        Velocity(vPos, bUseScaling);
}

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

void FluidPlane::SetGravity()
{}

bool FluidPlane::AllowRotateDragX() {return false;}

bool FluidPlane::AllowRotateDragY() {return false;}

bool FluidPlane::AllowRotateDragZ() {return false;}

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

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

        if(strType == "VELOCITY")
        {
                Velocity(strValue);
                return true;
        }

        if(strType == "GRAVITY")
        {
                SetGravity();
                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 FluidPlane::QueryProperties(CStdPtrArray<TypeProperty> &aryProperties)
{
        Plane::QueryProperties(aryProperties);

        aryProperties.Add(new TypeProperty("Velocity", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("Gravity", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
}

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

        oXml.IntoElem();  //Into RigidBody Element

        CStdFPoint vPoint;
        Std_LoadPoint(oXml, "Velocity", vPoint, false);
        Velocity(vPoint);

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

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