renderer.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "lmgl/renderer/framebuffer.hpp"
#include "lmgl/renderer/shadow_map.hpp"
#include "lmgl/scene/camera.hpp"
#include "lmgl/scene/mesh.hpp"
#include "lmgl/scene/node.hpp"
#include "lmgl/scene/scene.hpp"
 
#include <memory>
#include <vector>
 
namespace lmgl {

namespace renderer {

enum class RenderMode { Solid = 0, Wireframe, Points };

enum class RenderLayer { Skybox = 0, Opaque = 100, Transparent = 200, UI = 300 };

class Renderer {
  public:
    Renderer();

    ~Renderer() = default;

    void render(std::shared_ptr<scene::Scene> scene, std::shared_ptr<scene::Camera> camera);

    void set_render_mode(RenderMode mode);

    void set_culling(bool enabled);

    void set_depth_test(bool enabled);

    void set_blending(bool enabled);

    inline RenderMode get_render_mode() const { return m_render_mode; }

    inline unsigned int get_draw_calls() const { return m_draw_calls; }

    inline unsigned int get_triangles_count() const { return m_triangles_count; }

    void resize(int width, int height);

    inline void set_tone_map_mode(int mode) { m_tone_map_mode = mode; }

    inline void set_exposure(float exposure) { m_exposure = exposure; }

    inline void set_gamma(float gamma) { m_gamma = gamma; }

    void enable_post_processing(bool enabled);

    inline void set_bloom_enabled(bool enabled) { m_bloom_enabled = enabled; }

    inline void set_bloom_threshold(float threshold) { m_bloom_threshold = threshold; }

    inline void set_bloom_intensity(float intensity) { m_bloom_intensity = intensity; }

    void setup_shadows(std::shared_ptr<scene::Scene> scene, std::shared_ptr<Shader> shader, 
                      bool enable_point = true, bool enable_directional = true);
 
  private:
    RenderMode m_render_mode;

    unsigned int m_draw_calls;

    unsigned int m_triangles_count;

    bool m_depth_test_enabled;

    bool m_culling_enabled;

    bool m_blending_enabled;

    std::vector<std::shared_ptr<scene::Light>> m_directional_lights;

    std::vector<std::shared_ptr<scene::Light>> m_point_lights;

    std::vector<std::shared_ptr<scene::Light>> m_spot_lights;

    std::shared_ptr<scene::Material> m_default_material;

    std::shared_ptr<scene::Material> m_last_bound_material;

    std::unique_ptr<Framebuffer> m_framebuffer;

    std::unique_ptr<Framebuffer> m_bright_framebuffer;

    std::unique_ptr<Framebuffer> m_blur_framebuffer[2];

    std::shared_ptr<Shader> m_postprocess_shader;

    std::shared_ptr<Shader> m_bright_pass_shader;

    std::shared_ptr<Shader> m_blur_shader;

    std::shared_ptr<scene::Mesh> m_screen_quad;

    int m_tone_map_mode = 2;

    float m_exposure = 1.0f;

    float m_gamma = 2.2f;

    int m_window_width = 1920;
    int m_window_height = 1080;

    bool m_bloom_enabled = true;

    float m_bloom_threshold = 1.0f;

    float m_bloom_intensity = 0.5f;

    std::shared_ptr<ShadowMap> m_shadow_map;

    std::shared_ptr<CubemapShadowMap> m_cubemap_shadow_map;

    std::unique_ptr<ShadowRenderer> m_shadow_renderer;

    bool m_shadow_enabled = false;
    glm::vec3 m_shadow_light_pos = glm::vec3(0.0f);
    float m_shadow_far_plane = 1.0f;
    glm::mat4 m_light_space_matrix = glm::mat4(1.0f);

    struct RenderItem {

        std::shared_ptr<scene::Mesh> mesh;

        glm::mat4 transform;

        float distance_to_camera;

        RenderLayer layer;

        bool is_transparent;
    };

    std::vector<RenderItem> m_render_queue;

    void build_render_queue(std::shared_ptr<scene::Node> node, std::shared_ptr<scene::Camera> camera,
                            const glm::mat4 &par_transform, std::vector<RenderItem> &out_items);

    void build_render_queue_culled(std::shared_ptr<scene::Node> node, std::shared_ptr<scene::Camera> camera,
                                   const glm::mat4 &par_transform, std::vector<RenderItem> &out_items,
                                   const scene::Frustum &frustum);

    void sort_render_queue(std::vector<RenderItem> &items);

    void render_mesh(std::shared_ptr<scene::Mesh> mesh, const glm::mat4 &transform,
                     std::shared_ptr<scene::Camera> camera, std::shared_ptr<scene::Scene> scene);

    void apply_render_mode();

    void collect_lights(std::shared_ptr<scene::Scene> scene);

    void collect_node_lights(std::shared_ptr<scene::Node> node);

    void bind_lights(std::shared_ptr<renderer::Shader> shader);

    void bind_material(std::shared_ptr<scene::Material> material, std::shared_ptr<renderer::Shader> shader);

    void clear_material_cache();
};
 
} // namespace renderer
 
} // namespace lmgl