lighting.h

#ifndef OE_RENDER_LIGHTING_H
#define OE_RENDER_LIGHTING_H
 
#include <map>
 
#include "../scene/lighting.h"
#include "pbr.h"
 
#include "shader_base.h"
 
namespace oe::render
{
    class Texture;
    class Cubemap;
}
 
namespace oe::render
{
    struct ReflectionProbe
    {
        std::shared_ptr<Cubemap> irradiance = nullptr;
        std::shared_ptr<Cubemap> specular = nullptr;
    };
 
    class Lighting : public scene::Lighting
    {
        public:
            Lighting();
 
            void update(); //const std::chrono::nanoseconds /*delta*/, const int8_t /*flags = 0*/);
 
            void fillShader(ShaderBase* shader) const noexcept
            {
                shader->setVec3Array("uPointLightPositions", _point_light_positions);
                shader->setVec3Array("uPointLightColors", _point_light_colors);
 
                shader->fillTextures({
                    {"uBRDF", {10, _brdf_texture.get()}}
                });
            }
 
            void fillReflectionsShader(ShaderBase* shader) const noexcept
            {
                if (!_default_reflection_probe.specular || !_default_reflection_probe.irradiance)
                {
                    return;
                }
 
                shader->fillCubemaps({
                    {"uDefaultIrradiance", {12, _default_reflection_probe.irradiance.get()}},
                    {"uDefaultSpecular", {13, _default_reflection_probe.specular.get()}}
                });
            }
 
            void fillTransparencyShader(ShaderBase* shader) const noexcept
            {
                shader->fillTextures({
                    {"uScreenTransparency", {15, _refraction_texture.get()}}
                });
            }
 
            void setRefractionTexture(const std::shared_ptr<Texture>& refraction_texture)
            {
                _refraction_texture = refraction_texture;
            }
 
            const std::vector<glm::mat4> getAreaLights() const
            {
                return _area_light_matrices;
            }
 
            void setDefaultReflectionProbe(Cubemap* cubemap, const uint32_t specular_size = 256);
 
        protected:
            std::vector<glm::vec3> _point_light_positions;
            std::vector<glm::vec3> _point_light_colors;
 
            std::vector<glm::mat4> _area_light_matrices;
 
            ReflectionProbe _default_reflection_probe;
 
            Pbr _pbr;
 
            std::shared_ptr<Texture> _brdf_texture;
            std::shared_ptr<Texture> _refraction_texture;
    };
}
 
#endif