CLight.h

/*
!@
MIT License
 
Copyright (c) 2019 Skylicht Technology CO., LTD
 
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files
(the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify,
merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
This file is part of the "Skylicht Engine".
https://github.com/skylicht-lab/skylicht-engine
!#
*/
 
#pragma once
 
#include "Components/CComponentSystem.h"
#include "CLightCullingData.h"
 
namespace Skylicht
{
    class SKYLICHT_API CLight : public CComponentSystem
    {
    public:
        enum ERenderLightType
        {
            Realtime = 0,
            Baked,
            Mixed
        };
 
        enum ELightType
        {
            DirectionalLight = 0,
            PointLight,
            SpotLight,
            AreaLight
        };
 
    protected:
        SColorf m_color;


        float m_attenuation;

        float m_radius;

        float m_spotCutoff;
        float m_spotInnerCutoff;
        float m_spotExponent;


        core::vector3df m_direction;

        bool m_castShadow;

        bool m_dynamicShadow;

        float m_intensity;

        u32 m_bakeBounce;

        ERenderLightType m_renderType;

        u32 m_lightLayers;

        u32 m_lightPriority;
 
        bool m_needValidate;
 
        CLightCullingData* m_cullingData;
 
        ITexture* m_shadowTex;
 
        float* m_shadowMatrices;
    public:
        CLight();
 
        virtual ~CLight();
 
        virtual CObjectSerializable* createSerializable();
 
        virtual void loadSerializable(CObjectSerializable* object);
 
        inline const SColorf& getColor()
        {
            return m_color;
        }
 
        inline void setColor(const SColorf& c)
        {
            m_color = c;
        }
 
        inline float getAttenuation()
        {
            return m_attenuation;
        }
 
        inline float getRadius()
        {
            return m_radius;
        }
 
        core::aabbox3df getBBBox();
 
        inline ERenderLightType getRenderLightType()
        {
            return m_renderType;
        }
 
        virtual void setRenderLightType(ERenderLightType type)
        {
            m_renderType = type;
        }
 
        inline int getLightTypeId()
        {
            return m_cullingData->LightType;
        }
 
        inline void setBounce(u32 b)
        {
            m_bakeBounce = b;
        }
 
        inline u32 getBounce()
        {
            return m_bakeBounce;
        }
 
        void setRadius(float r)
        {
            r = core::max_(r, 0.01f);
            m_radius = r;
            m_attenuation = 1.0f / m_radius;
        }
 
        inline void setSpotAngle(float angle)
        {
            m_spotCutoff = angle;
        }
 
        inline float getSplotCutoff()
        {
            return m_spotCutoff;
        }
 
        inline void setSpotInnerAngle(float angle)
        {
            m_spotInnerCutoff = angle;
        }
 
        inline float getSpotInnerCutof()
        {
            return m_spotInnerCutoff;
        }
 
        inline void setSpotExponent(float e)
        {
            m_spotExponent = e;
        }
 
        inline float getSpotExponent()
        {
            return m_spotExponent;
        }
 
        inline core::vector3df& getDirection()
        {
            return m_direction;
        }
 
        inline bool isCastShadow()
        {
            return m_castShadow;
        }
 
        inline void setShadow(bool shadow)
        {
            m_castShadow = shadow;
            m_shadowTex = NULL;
        }
 
        inline bool isDynamicShadow()
        {
            return m_dynamicShadow;
        }
 
        inline void setDynamicShadow(bool shadow)
        {
            m_dynamicShadow = shadow;
            m_shadowTex = NULL;
        }
 
        inline void setIntensity(float f)
        {
            m_intensity = f;
        }
 
        inline float getIntensity()
        {
            return m_intensity;
        }
 
        inline u32 getLightLayers()
        {
            return m_lightLayers;
        }
 
        inline void setLightLayers(u32 layers)
        {
            m_lightLayers = layers;
        }
 
        inline bool isAffectingDefaultObjects()
        {
            return m_lightLayers & 1;
        }
 
        inline void setLightPriority(u32 priority)
        {
            m_lightPriority = priority;
        }
 
        inline u32 getLightPriority()
        {
            return m_lightPriority;
        }
 
        inline void validate()
        {
            m_needValidate = true;
        }
 
        inline ITexture* getShadowTexture()
        {
            return m_shadowTex;
        }
 
        inline void setShadowTexture(ITexture* tex)
        {
            m_shadowTex = tex;
        }
 
        void setShadowMatrices(float* m);
 
        inline float* getShadowMatrices()
        {
            return m_shadowMatrices;
        }
    };
}