ForwardLight.hpp

#pragma once
 
#include "scene/Scene.hpp"
 
#include "renderers/LightRenderer.hpp"
#include "renderers/shadowmaps/ShadowMap.hpp"
#include "scene/lights/Light.hpp"
#include "scene/lights/PointLight.hpp"
#include "scene/lights/DirectionalLight.hpp"
#include "scene/lights/SpotLight.hpp"
#include "resources/Buffer.hpp"
 
#include "Common.hpp"
 
 
class ForwardLight final : public LightRenderer {
 
public:
 
    struct GPULight {
        glm::mat4 viewToLight; 
        glm::vec4 colorAndBias; 
        glm::vec4 positionAndRadius; 
        glm::vec4 directionAndPlane; 
        glm::vec4 typeModeLayer; 
        glm::vec4 angles; 
    };
 
    explicit ForwardLight(size_t count);
    
    void updateCameraInfos(const glm::mat4 & viewMatrix, const glm::mat4 & projMatrix);
 
 
    void draw(const SpotLight * light) override;
    
    void draw(const PointLight * light) override;
    
    void draw(const DirectionalLight * light) override;
 
    size_t count() const {
        return _currentCount;
    }
 
    const std::vector<const Texture *> & shadowMaps() const {
        return _shadowMaps;
    }
 
    UniformBuffer<GPULight> & data(){
        return _lightsData;
    }
 
private:
 
    size_t _currentId = 0; 
    size_t _currentCount = 0; 
    const static size_t _maxLightCount; 
    UniformBuffer<GPULight> _lightsData; 
 
    glm::mat4 _view = glm::mat4(1.0f); 
    glm::mat4 _proj = glm::mat4(1.0f); 
    glm::mat4 _invView = glm::mat4(1.0f); 
 
    std::vector<const Texture *> _shadowMaps; 
};
 
 
class ForwardProbe  {
 
public:
 
    struct GPUProbe {
        glm::vec4 positionAndMip{0.0f}; 
        glm::vec4 sizeAndFade{0.0f};    
        glm::vec4 centerAndCos{0.0f}; 
        glm::vec4 extentAndSin{0.0f}; 
    };
 
    explicit ForwardProbe(size_t count);
 
    void draw(const LightProbe & probe);
 
    size_t count() const {
        return _currentCount;
    }
 
    const std::vector<const Texture *> & envmaps() const {
        return _probesMaps;
    }
 
    const std::vector<const Buffer *> & shCoeffs() const {
        return _probesCoeffs;
    }
 
    UniformBuffer<GPUProbe> & data(){
        return _probesData;
    }
 
private:
 
    size_t _currentId = 0; 
    size_t _currentCount = 0; 
    const static size_t _maxProbeCount; 
    UniformBuffer<GPUProbe> _probesData; 
 
    std::vector<const Texture *> _probesMaps; 
    std::vector<const Buffer *> _probesCoeffs; 
};