Light.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 "Light.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
        {
Light::Light(void)
{
        m_fltRadius = 1;
        m_iLatitudeSegments = 50;
        m_iLongtitudeSegments = 50;
        m_iLightNum = 0;
        m_fltConstantAttenRatio = 0;
        m_fltLinearAttenDistance = 0;
        m_fltQuadraticAttenDistance = 0;
        m_bEnabled = true;
}

Light::~Light(void)
{
}

#pragma region AccessorMutators

bool Light::Enabled() {return m_bEnabled;}

void Light::Enabled(bool bValue) 
{
        m_bEnabled = bValue;
}

void Light::UpdateData()
{
        if(m_lpPhysicsMovableItem)
                m_lpPhysicsMovableItem->Physics_CollectData();
}

void Light::Resize() 
{
        if(m_lpPhysicsMovableItem)
                m_lpPhysicsMovableItem->Physics_Resize();
}

float Light::Radius() {return m_fltRadius;}

void Light::Radius(float fltVal, bool bUseScaling)
{
        Std_IsAboveMin((float) 0, fltVal, true, "Light.Radius");
        if(bUseScaling)
                m_fltRadius = fltVal * m_lpSim->InverseDistanceUnits();
        else
                m_fltRadius = fltVal;

        Resize();
}

void Light::LatitudeSegments(int iVal) 
{
        Std_IsAboveMin((int) 10, iVal, true, "Light.LatitudeSegments", true);
        m_iLatitudeSegments = iVal;
        Resize();
}

int Light::LatitudeSegments() {return m_iLatitudeSegments;}

void Light::LongtitudeSegments(int iVal)
{
        Std_IsAboveMin((int) 10, iVal, true, "Light.LongtitudeSegments", true);
        m_iLongtitudeSegments = iVal;
        Resize();
}

int Light::LongtitudeSegments() {return m_iLongtitudeSegments;}

#pragma endregion

void Light::Selected(bool bValue, bool bSelectMultiple)
{
        AnimatBase::Selected(bValue, bSelectMultiple);
        MovableItem::Selected(bValue, bSelectMultiple);
}

void Light::LightNumber(int iVal)
{
        Std_IsAboveMin((int) 0, iVal, true, "Light.LightNumber", true);
        m_iLightNum = iVal;
}

int Light::LightNumber() {return m_iLightNum;}

void Light::ConstantAttenRatio(float fltVal)
{
        Std_InValidRange((float) 0, (float) 1, fltVal, true, "Receptive Field Index");
        m_fltConstantAttenRatio = fltVal;
        Resize();
}

float Light::ConstantAttenRatio() {return m_fltConstantAttenRatio;}

void Light::LinearAttenDistance(float fltVal, bool bUseScaling)
{
        Std_IsAboveMin((float) 0, fltVal, true, "Light.LinearAttenDistance", true);
        if(bUseScaling)
                m_fltLinearAttenDistance = fltVal * m_lpSim->InverseDistanceUnits();
        else
                m_fltLinearAttenDistance = fltVal;

        Resize();
}

float Light::LinearAttenDistance() {return m_fltLinearAttenDistance;}

void Light::QuadraticAttenDistance(float fltVal, bool bUseScaling)
{
        Std_IsAboveMin((float) 0, fltVal, true, "Light.QuadraticAttenDistance", true);
        if(bUseScaling)
                m_fltQuadraticAttenDistance = fltVal * m_lpSim->InverseDistanceUnits();
        else
                m_fltQuadraticAttenDistance = fltVal;

        Resize();
}

float Light::QuadraticAttenDistance() {return m_fltQuadraticAttenDistance;}

void Light::VisualSelectionModeChanged(int iNewMode)
{
        MovableItem::VisualSelectionModeChanged(iNewMode);
}


#pragma region DataAccesMethods

void Light::SetSystemPointers(Simulator *lpSim, Structure *lpStructure, NeuralModule *lpModule, Node *lpNode, bool bVerify)
{
        AnimatBase::SetSystemPointers(lpSim, lpStructure, lpModule, lpNode, bVerify);
        m_lpMovableSim = lpSim;
}

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

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

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

        if(strType == "ENABLED")
        {
                Enabled(Std_ToBool(strValue));
                return true;
        }

        if(strType == "RADIUS")
        {
                Radius((float) atof(strValue.c_str()));
                return true;
        }

        if(strType == "LATITUDESEGMENTS")
        {
                LatitudeSegments(atoi(strValue.c_str()));
                return true;
        }

        if(strType == "LONGTITUDESEGMENTS")
        {
                LongtitudeSegments(atoi(strValue.c_str()));
                return true;
        }

        if(strType == "CONSTANTATTENUATION")
        {
                ConstantAttenRatio((float) atof(strValue.c_str()));
                return true;
        }

        if(strType == "LINEARATTENUATIONDISTANCE")
        {
                LinearAttenDistance((float) atof(strValue.c_str()));
                return true;
        }

        if(strType == "QUADRATICATTENUATIONDISTANCE")
        {
                QuadraticAttenDistance((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 Light::QueryProperties(CStdPtrArray<TypeProperty> &aryProperties)
{
        AnimatBase::QueryProperties(aryProperties);
        MovableItem::QueryProperties(aryProperties);

        aryProperties.Add(new TypeProperty("Enabled", AnimatPropertyType::Boolean, AnimatPropertyDirection::Both));
        aryProperties.Add(new TypeProperty("Radius", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("LatitudeSegments", AnimatPropertyType::Integer, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("LongtitudeSegments", AnimatPropertyType::Integer, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("ConstantAttenuation", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("LinearAttenuationDistance", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("QuadraticAttenuationDistance", AnimatPropertyType::Float, AnimatPropertyDirection::Set));
}

#pragma endregion

void Light::Create()
{
}

void Light::Load(CStdXml &oXml)
{
        AnimatBase::Load(oXml);
        MovableItem::Load(oXml);

        oXml.IntoElem();  //Into RigidBody Element
        Enabled(oXml.GetChildBool("Enabled", m_bEnabled));
        Radius(oXml.GetChildFloat("Radius", m_fltRadius));
        LatitudeSegments(oXml.GetChildInt("LatitudeSegments", m_iLatitudeSegments));
        LongtitudeSegments(oXml.GetChildInt("LongtitudeSegments", m_iLongtitudeSegments));
        ConstantAttenRatio(oXml.GetChildFloat("ConstantAttenuation", m_fltConstantAttenRatio));
        LinearAttenDistance(oXml.GetChildFloat("LinearAttenuationDistance", m_fltLinearAttenDistance));
        QuadraticAttenDistance(oXml.GetChildFloat("QuadraticAttenuationDistance", m_fltQuadraticAttenDistance));
        oXml.OutOfElem(); //OutOf RigidBody Element
}

        }                       //Environment
}                               //AnimatSim