lightcomponent.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Local includes
#include "renderfrustumcomponent.h"
 
// External includes
#include <component.h>
#include <componentptr.h>
#include <cameracomponent.h>
#include <transformcomponent.h>
#include <rendergnomoncomponent.h>
#include <entity.h>
 
namespace nap
{
    // Forward declares
    class LightComponentInstance;
    class RenderAdvancedService;
 
    enum class ELightType : uint8
    {
        Custom          = 0,
        Directional     = 1,
        Point           = 2,
        Spot            = 3
    };
 
    enum class EShadowMapType : uint8
    {
        Quad = 0,
        Cube = 1
    };
 
    namespace uniform
    {
        inline constexpr const char* lightStruct = "light";                     // Default light UBO struct name
        inline constexpr const char* shadowStruct = "shadow";                   // Default shadow UBO struct name
 
        namespace light
        {
            inline constexpr const char* color = "color";
            inline constexpr const char* intensity = "intensity";
            inline constexpr const char* origin = "origin";
            inline constexpr const char* direction = "direction";
            inline constexpr const char* attenuation = "attenuation";
            inline constexpr const char* angle = "angle";
            inline constexpr const char* falloff = "falloff";
            inline constexpr const char* flags = "flags";
            inline constexpr const char* lights = "lights";
            inline constexpr const char* count = "count";
            inline constexpr const uint defaultMemberCount = 8;
        }
 
        namespace shadow
        {
            inline constexpr const char* lightViewProjectionMatrix = "lightViewProjectionMatrix";
            inline constexpr const char* nearFar = "nearFar";
            inline constexpr const char* strength = "strength";
            inline constexpr const char* spread = "spread";
            inline constexpr const char* flags = "flags";
            inline constexpr const char* count = "count";
        }
    }
 
    namespace sampler
    {
        namespace light
        {
            inline constexpr const char* shadowMaps = "shadowMaps";
            inline constexpr const char* cubeShadowMaps = "cubeShadowMaps";
        }
    }
 
 
    class NAPAPI LightComponent : public Component
    {
        RTTI_ENABLE(Component)
        DECLARE_COMPONENT(LightComponent, LightComponentInstance)
    public:
        struct Locator
        {
            float mLineWidth  = 1.0f;   
            float mGnomonSize = 1.0f;   
        };
 
        virtual void getDependentComponents(std::vector<rtti::TypeInfo>& components) const override;
 
        bool mEnabled = true;                                   
        bool mCastShadows = false;                              
        RGBColorFloat mColor = {1.0f, 1.0f, 1.0f};              
        float mIntensity = 1.0f;                                
        float mShadowStrength = 1.0f;                           
        float mShadowSpread = 2.0f;                             
        Locator mLocator;                                       
    };
 
 
    class NAPAPI LightComponentInstance : public ComponentInstance
    {
        friend class RenderAdvancedService;
        RTTI_ENABLE(ComponentInstance)
    public:
        // Constructor
        LightComponentInstance(EntityInstance& entity, Component& resource) :
            ComponentInstance(entity, resource) { }
 
        virtual ~LightComponentInstance() { };
 
        virtual bool init(utility::ErrorState& errorState) override;
 
        virtual void onDestroy() override;
 
        virtual void enable(bool enable)                                    { mIsEnabled = enable; }
 
         bool isEnabled() const                                             { return mIsEnabled; };
 
        bool canCastShadows() const                                         { return mSpawnedCamera != nullptr; }
 
        bool castsShadows() const                                           { return canCastShadows() && mIsShadowEnabled; }
 
        virtual ELightType getLightType() const = 0;
 
        virtual EShadowMapType getShadowMapType() const = 0;
 
        virtual uint getShadowMapSize() const                               { return mShadowMapSize; }
 
        virtual float getIntensity() const                                  { return mIntensity; }
 
        void setIntensity(float intensity)                                  { mIntensity = intensity; }
 
        virtual float getShadowStrength() const                             { return mShadowStrength; }
 
        virtual void setShadowStrength(float strength)                      { mShadowStrength = strength; }
 
        virtual float getShadowSpread() const                               { return mShadowSpread; }
 
        virtual void setShadowSpread(float spread)                          { mShadowSpread = spread; }
 
        virtual const RGBColorFloat& getColor() const                       { return mColor; }
 
        void setColor(const RGBColorFloat& color)                           { mColor = color; }
 
        const glm::vec3 getLightPosition() const                            { return math::extractPosition(getTransform().getGlobalTransform()); }
 
        const glm::vec3 getLightDirection() const                           { return -glm::normalize(getTransform().getGlobalTransform()[2]); }
 
        const TransformComponentInstance& getTransform() const              { assert(mTransform != nullptr); return *mTransform; }
 
        TransformComponentInstance& getTransform()                          { assert(mTransform != nullptr); return *mTransform; }
 
        bool hasCamera() const                                              { return mSpawnedCamera != nullptr; }
 
        CameraComponentInstance& getCamera() const                          { assert(mSpawnedCamera != nullptr); return mSpawnedCamera->getComponent<CameraComponentInstance>(); }
 
        CameraComponentInstance& getCamera()                                { assert(mSpawnedCamera != nullptr); return mSpawnedCamera->getComponent<CameraComponentInstance>(); }
 
        const RenderGnomonComponentInstance& getGnomon() const              { assert(mSpawnedCamera != nullptr); return mSpawnedCamera->getComponent<RenderGnomonComponentInstance>(); }
 
        RenderGnomonComponentInstance& getGnomon()                          { assert(mSpawnedCamera != nullptr); return mSpawnedCamera->getComponent<RenderGnomonComponentInstance>(); }
 
        const RenderFrustumComponentInstance* getFrustrum() const           { assert(mSpawnedCamera != nullptr); return mSpawnedCamera->findComponent<RenderFrustumComponentInstance>(); }
 
        RenderFrustumComponentInstance* getFrustrum()                       { assert(mSpawnedCamera != nullptr); return mSpawnedCamera->findComponent<RenderFrustumComponentInstance>(); }
 
        float mIntensity = 1.0f;
        RGBColorFloat mColor = { 1.0f, 1.0f, 1.0f };
 
    protected:
        void registerUniformLightProperty(const std::string& memberName);
 
        SpawnedEntityInstance spawnShadowCamera(const nap::Entity& entity, nap::utility::ErrorState& error);
 
        LightComponent* mResource                       = nullptr;
        TransformComponentInstance* mTransform          = nullptr;
        RenderAdvancedService* mService                 = nullptr;
        SpawnedEntityInstance mSpawnedCamera;
 
        bool mIsEnabled                                 = true;
        bool mIsShadowEnabled                           = false;
        float mShadowStrength                           = 1.0f;
        float mShadowSpread                             = 2.0f;
        uint mShadowMapSize                             = 512;
 
    private:
        std::vector<nap::rtti::Property> mUniformList;
    };
}