PointLightNode.h

#pragma once
 
// Custom.
#include "game/node/SpatialNode.h"
#include "math/GLMath.hpp"
#include "shader/VulkanAlignmentConstants.hpp"
#include "shader/general/resource/LightingShaderResourceManager.h"
#include "misc/shapes/Sphere.h"
#include "render/general/resource/shadow/ShadowMapHandle.h"
 
#include "PointLightNode.generated.h"
 
namespace ne RNAMESPACE() {
    class RCLASS(Guid("7890ed17-6efb-43d1-a7ef-aa5a0589921a")) PointLightNode : public SpatialNode {
        // Renderer reads shadow map handle and index into viewProjection matrix array.
        friend class Renderer;
 
    public:
        PointLightNode();
 
        PointLightNode(const std::string& sNodeName);
 
        virtual ~PointLightNode() override = default;
 
        void setLightColor(const glm::vec3& color);
 
        void setLightIntensity(float intensity);
 
        void setLightDistance(float distance);
 
        glm::vec3 getLightColor() const;
 
        float getLightIntensity() const;
 
        float getLightDistance() const;
 
        std::pair<std::mutex, Sphere>* getShape();
 
    protected:
        virtual void onAfterDeserialized() override;
 
        virtual void onSpawning() override;
 
        virtual void onDespawning() override;
 
        virtual void onWorldLocationRotationScaleChanged() override;
 
    private:
        struct PointLightShaderData {
            PointLightShaderData() = default;
 
            alignas(iVkVec4Alignment) glm::vec4 position = glm::vec4(0.0F, 0.0F, 0.0F, 1.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) unsigned int iShadowMapIndex = 0;
        };
 
        struct ShaderData {
            ShaderData() = default;
 
            struct ShadowPassDataGroup {
                ShadowPassDataGroup() = default;
 
                std::unique_ptr<ShaderLightArraySlot> pSlot;
 
                ShadowPassLightShaderInfo shaderData;
            };
 
            std::unique_ptr<ShaderLightArraySlot> pPointLightArraySlot;
 
            std::array<ShadowPassDataGroup, 6> vShadowPassDataGroup;
 
            PointLightShaderData shaderData;
        };
 
        ShadowMapHandle* getShadowMapHandle() const;
 
        unsigned int getIndexIntoShadowPassInfoShaderArray(size_t iCubemapFaceIndex = 0);
 
        void* onStartedUpdatingShaderData();
 
        void onFinishedUpdatingShaderData();
 
        void* onStartedUpdatingShadowPassData(size_t iCubemapFaceIndex);
 
        void onFinishedUpdatingShadowPassData();
 
        void markShaderDataToBeCopiedToGpu();
 
        void markShadowPassDataToBeCopiedToGpu();
 
        void onShadowMapArrayIndexChanged(unsigned int iNewIndexIntoArray);
 
        void recalculateShadowPassShaderData();
 
        void recalculateShape();
 
        std::pair<std::recursive_mutex, ShaderData> mtxShaderData;
 
        std::pair<std::mutex, Sphere> 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 = 10.0F; // NOLINT: seems like a pretty good default value
 
        ne_PointLightNode_GENERATED
    };
}
 
File_PointLightNode_GENERATED