SpotlightNode.h

#pragma once
 
// Custom.
#include "game/nodes/SpatialNode.h"
#include "math/GLMath.hpp"
#include "shader/VulkanAlignmentConstants.hpp"
#include "shader/general/resources/LightingShaderResourceManager.h"
#include "misc/shapes/Cone.h"
#include "render/general/resources/shadow/ShadowMapHandle.h"
 
#include "SpotlightNode.generated.h"
 
namespace ne RNAMESPACE() {
    class RCLASS(Guid("e7b203dc-0f47-43f2-b26d-3b09a5ec1661")) SpotlightNode : public SpatialNode {
        // Renderer reads shadow map handle and index into viewProjection matrix array.
        friend class Renderer;
 
    public:
        SpotlightNode();
 
        SpotlightNode(const std::string& sNodeName);
 
        virtual ~SpotlightNode() override = default;
 
        static constexpr float getMaxLightConeAngle() { return maxConeAngle; }
 
        void setLightColor(const glm::vec3& color);
 
        void setLightIntensity(float intensity);
 
        void setLightDistance(float distance);
 
        void setLightInnerConeAngle(float innerConeAngle);
 
        void setLightOuterConeAngle(float outerConeAngle);
 
        glm::vec3 getLightColor() const;
 
        float getLightIntensity() const;
 
        float getLightDistance() const;
 
        float getLightInnerConeAngle() const;
 
        float getLightOuterConeAngle() const;
 
        std::pair<std::mutex, Cone>* getShape();
 
    protected:
        virtual void onAfterDeserialized() override;
 
        virtual void onSpawning() override;
 
        virtual void onDespawning() override;
 
        virtual void onWorldLocationRotationScaleChanged() override;
 
    private:
        struct SpotlightShaderData {
            SpotlightShaderData() = default;
 
            alignas(iVkMat4Alignment) glm::mat4 viewProjectionMatrix = glm::identity<glm::mat4>();
 
            alignas(iVkVec4Alignment) glm::vec4 position = glm::vec4(0.0F, 0.0F, 0.0F, 1.0F);
 
            alignas(iVkVec4Alignment) glm::vec4 direction = glm::vec4(0.0F, 0.0F, 0.0F, 0.0F);
 
            alignas(iVkVec4Alignment) glm::vec4 color = glm::vec4(1.0F, 1.0F, 1.0F, 1.0F);
 
            alignas(iVkScalarAlignment) float intensity = 1.0F;
 
            alignas(iVkScalarAlignment) float distance = 1.0F;
 
            alignas(iVkScalarAlignment) float cosInnerConeAngle = 0.0F;
 
            alignas(iVkScalarAlignment) float cosOuterConeAngle = 0.0F;
 
            alignas(iVkScalarAlignment) float coneBottomRadius = 0.0F;
 
            alignas(iVkScalarAlignment) unsigned int iShadowMapIndex = 0;
        };
 
        struct ShaderData {
            ShaderData() = default;
 
            struct ShadowPassDataGroup {
                ShadowPassDataGroup() = default;
 
                std::unique_ptr<ShaderLightArraySlot> pSlot;
 
                ShadowPassLightShaderInfo shaderData;
            };
 
            std::unique_ptr<ShaderLightArraySlot> pSpotlightArraySlot;
 
            ShadowPassDataGroup shadowPassData;
 
            SpotlightShaderData shaderData;
        };
 
        ShadowMapHandle* getShadowMapHandle() const;
 
        unsigned int getIndexIntoShadowPassInfoShaderArray();
 
        void onShadowMapArrayIndexChanged(unsigned int iNewIndexIntoArray);
 
        void* onStartedUpdatingShaderData();
 
        void onFinishedUpdatingShaderData();
 
        void* onStartedUpdatingShadowPassData();
 
        void onFinishedUpdatingShadowPassData();
 
        void recalculateShadowMappingShaderData();
 
        void recalculateAndMarkShaderDataToBeCopiedToGpu();
 
        void markShaderDataToBeCopiedToGpu();
 
        void recalculateShape();
 
        std::pair<std::recursive_mutex, ShaderData> mtxShaderData;
 
        std::pair<std::mutex, Cone> mtxShape;
 
        std::unique_ptr<ShadowMapHandle> pShadowMapHandle;
 
        RPROPERTY(Serialize)
        glm::vec3 color = glm::vec3(1.0F, 1.0F, 1.0F);
 
        RPROPERTY(Serialize)
        float intensity = 1.0F;
 
        RPROPERTY(Serialize)
        float distance = 15.0F; // NOLINT: seems like a pretty good default value
 
        RPROPERTY(Serialize)
        float innerConeAngle = 25.0F;
 
        RPROPERTY(Serialize)
        float outerConeAngle = 45.0F;
 
        static constexpr float maxConeAngle = 80.0F; // NOLINT: max angle that won't cause any visual issues
 
        ne_SpotlightNode_GENERATED
    };
}
 
File_SpotlightNode_GENERATED