Renderer.h

Go to the documentation of this file.

#pragma once
 
#include <functional>
 
#include <glad/gl.h>
#include <glm/glm.hpp>
 
class OrbitCamera;
struct ViewportFBO;
 
class Renderer
{
public:
    // ---- Light types -------------------------------------------------------
 
    enum class LightType : int
    {
        Directional = 0,
        Point,
        Spot,
        AmbientOnly
    };
 
    struct LightSettings
    {
        float     direction[4] = { -1.0f, 1.0f, -1.0f, 0.0f };
        float     diffuse[3]   = {  1.0f, 1.0f,  1.0f };
        float     ambient[3]   = {  0.35f, 0.35f, 0.35f };
        float     specular[3]  = {  0.0f, 0.0f,  0.0f };
        float     intensity    = 1.0f;
        bool      enabled      = true;
        LightType type         = LightType::Directional;
        float     position[3]  = { 0.0f, 5.0f, 0.0f };
        float     spotCutoff   = 45.0f;
        float     spotExponent = 10.0f;
    };
 
    struct RenderState
    {
        LightSettings light;
        bool      drawCheckerBg  = true;
        bool      drawGradientBg = false;
        glm::vec3 gradientTop{0.15f, 0.20f, 0.35f};
        glm::vec3 gradientBottom{0.02f, 0.02f, 0.05f};
    };
 
    Renderer() = default;
    ~Renderer();
 
    Renderer(const Renderer&)            = delete;
    Renderer& operator=(const Renderer&) = delete;
 
    // ---- Lifecycle ---------------------------------------------------------
 
    void init();
 
    void shutdown();
 
    // ---- State access ------------------------------------------------------
 
    RenderState&       state() noexcept       { return m_state; }
    const RenderState& state() const noexcept { return m_state; }
 
    // ---- Rendering operations ----------------------------------------------
 
    void applyLighting();
 
    void applyLighting(const LightSettings& light);
 
    void drawCheckerboard(int w, int h);
 
    void drawGradient(int w, int h,
                      const glm::vec3& top, const glm::vec3& bottom);
 
    void drawBackground(int w, int h);
 
    void drawGrid(float size = 40.0f, float step = 1.0f);
 
    void applyProjection(int w, int h, float fov,
                         float nearPlane = 0.1f, float farPlane = 6400.0f);
 
    void applyView(const glm::mat4& viewMatrix);
 
    void beginPass(ViewportFBO& fbo, int w, int h,
                   const glm::vec3& clearColor);
 
    void endPass(ViewportFBO& fbo);
 
    void renderScene(ViewportFBO& fbo, int w, int h,
                     const OrbitCamera& camera, float fov,
                     const glm::vec3& clearColor, bool drawGrid,
                     const std::function<void()>& drawObjects);
 
    // ---- Resource access ---------------------------------------------------
 
    GLuint checkerTexture() const noexcept { return m_checkerTex; }
 
private:
    GLuint      m_checkerTex = 0;
    RenderState m_state;
};