LightObject.h

#pragma once
#include "ParaXEntity.h"
#include "SphereObject.h"
#include <string>
namespace ParaEngine
{
    class CParaXModel;
    class CLightParam;

    class CLightObject : public CSphereObject
    {
    public:
        virtual CBaseObject::_SceneObjectType GetType(){return CBaseObject::LightObject;};
        CLightObject(void);
        virtual ~CLightObject(void);
    public:
        // implementation of IAttributeFields
        ATTRIBUTE_DEFINE_CLASS(CLightObject);
        ATTRIBUTE_SUPPORT_CREATE_FACTORY(CLightObject);
        
        virtual int InstallFields(CAttributeClass* pClass, bool bOverride);

        ATTRIBUTE_METHOD1(CLightObject, GetLightType_s, int*)   {*p1 = cls->GetLightType(); return S_OK;}
        ATTRIBUTE_METHOD1(CLightObject, SetLightType_s, int)    {cls->SetLightType(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CLightObject, GetRange_s, float*) {*p1 = cls->GetRange(); return S_OK;}
        ATTRIBUTE_METHOD1(CLightObject, SetRange_s, float)  {cls->SetRange(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CLightObject, GetDiffuse_s, Vector3*)     {*p1 = *(Vector3*)(&cls->GetDiffuse()); return S_OK;}
        ATTRIBUTE_METHOD1(CLightObject, SetDiffuse_s, Vector3)      {LinearColor c(p1.x, p1.y,p1.z,1); cls->SetDiffuse(c); return S_OK;}

        ATTRIBUTE_METHOD1(CLightObject, GetAttenuation0_s, float*)  {*p1 = cls->GetAttenuation0(); return S_OK;}
        ATTRIBUTE_METHOD1(CLightObject, SetAttenuation0_s, float)   {cls->SetAttenuation0(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CLightObject, GetAttenuation1_s, float*)  {*p1 = cls->GetAttenuation1(); return S_OK;}
        ATTRIBUTE_METHOD1(CLightObject, SetAttenuation1_s, float)   {cls->SetAttenuation1(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CLightObject, GetAttenuation2_s, float*)  {*p1 = cls->GetAttenuation2(); return S_OK;}
        ATTRIBUTE_METHOD1(CLightObject, SetAttenuation2_s, float)   {cls->SetAttenuation2(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CLightObject, IsDeferredLightOnly_s, bool*)   { *p1 = cls->IsDeferredLightOnly(); return S_OK; }
        ATTRIBUTE_METHOD1(CLightObject, SetDeferredLightOnly_s, bool)   { cls->SetDeferredLightOnly(p1); return S_OK; }

    public:
        virtual std::string ToString(DWORD nMethod);

        virtual void Rotate(float x, float y, float z);

        virtual void SetScaling(float s);

        virtual void Reset();


        HRESULT InitObject(CLightParam* pLight, MeshEntity* ppMesh, const Vector3& vCenter, const Matrix4& mat, bool bCopyParams = true);

        virtual int PrepareRender(CBaseCamera* pCamera, SceneState * sceneState);

        virtual HRESULT Draw(SceneState * sceneState);

        HRESULT RenderMesh(SceneState * sceneState);

        
        virtual void Cleanup();

        void SetLocalTransform(const Matrix4& mXForm);
        void SetLocalTransform(float fScale, float fRotX, float fRotY, float fRotZ);
        void SetLocalTransform(float fScale, const Quaternion& quat);
        void GetLocalTransform(Matrix4* localTransform);

        CLightParam* GetLightParams();

        virtual AssetEntity* GetPrimaryAsset();
        virtual void SetAssetFileName(const std::string& sFilename);
        virtual Matrix4* GetAttachmentMatrix(Matrix4& pOut, int nAttachmentID = 0, int nRenderNumber = 0);

        virtual Matrix4* GetRenderMatrix(Matrix4& out, int nRenderNumber = 0);
        virtual void RenderDeferredLightMesh(SceneState * sceneState);
    public:
        void SetLightType(int nType);
        int GetLightType();

        void SetDiffuse(const LinearColor& color);
        const LinearColor& GetDiffuse();
        
        void SetRange(float range);
        
        float GetRange();

        void SetAttenuation0(float Attenuation0);

        float GetAttenuation0();


        void SetAttenuation1(float Attenuation1);

        float GetAttenuation1();

        void SetAttenuation2(float Attenuation2);

        float GetAttenuation2();

        bool IsDeferredLightOnly() const;
        void SetDeferredLightOnly(bool val);
    protected:
        //Vector3           m_vPos;
        Matrix4            m_mxLocalTransform;

        AnimIndex m_CurrentAnim;

        ref_ptr<ParaXEntity>      m_pAnimatedMesh;
        ref_ptr<MeshEntity>       m_pDeferredShadingMesh;

        CLightParam* m_pLightParams;

        bool m_bDeleteLightParams;

        bool m_bDeferredLightOnly;
    };
}