GraphicsController.hpp

Go to the documentation of this file.

 
#ifndef GRAPHICSCONTROLLER_HPP
#define GRAPHICSCONTROLLER_HPP
#include <engine/graphics/Camera.hpp>
#include <engine/core/Controller.hpp>
#include <engine/platform/PlatformEventObserver.hpp>
 
struct ImGuiContext;
 
namespace engine::resources {
    class Skybox;
    class Shader;
}
 
namespace engine::graphics {
    struct PerspectiveMatrixParams {
        float FOV;
        float Width;
        float Height;
        float Near;
        float Far;
    };
 
    struct OrthographicMatrixParams {
        float Left;
        float Right;
        float Bottom;
        float Top;
        float Near;
        float Far;
    };
 
    enum ProjectionType {
        Perspective,
        Orthographic
    };
 
    class GraphicsController final : public core::Controller {
    public:
        std::string_view name() const override;
 
        void begin_gui();
 
        void end_gui();
 
        void draw_skybox(const resources::Shader *shader, const resources::Skybox *skybox);
 
        Camera *camera() {
            return &m_camera;
        }
 
        template<ProjectionType type = Perspective>
        glm::mat4 projection_matrix() const {
            if constexpr (type == Perspective) {
                return glm::perspective(m_perspective_params.FOV,
                                        m_perspective_params.Width / m_perspective_params.Height,
                                        m_perspective_params.Near, m_perspective_params.Far);
            } else {
                return glm::ortho(m_ortho_params.Left, m_ortho_params.Right, m_ortho_params.Bottom, m_ortho_params.Top,
                                  m_ortho_params.Near, m_ortho_params.Far);
            }
        }
 
        glm::mat4 projection_matrix(ProjectionType type = Perspective) const {
            switch (type) {
            case Perspective: return projection_matrix<Perspective>();
            case Orthographic: return projection_matrix<Orthographic>();
            default: RG_SHOULD_NOT_REACH_HERE("Unsupported type");
            }
        }
 
        PerspectiveMatrixParams &perspective_params() {
            return m_perspective_params;
        }
 
        const PerspectiveMatrixParams &perspective_params() const {
            return m_perspective_params;
        }
 
        OrthographicMatrixParams &orthographic_params() {
            return m_ortho_params;
        }
 
        const OrthographicMatrixParams &orthographic_params() const {
            return m_ortho_params;
        }
 
    private:
        void initialize() override;
 
        void terminate();
 
        PerspectiveMatrixParams m_perspective_params{};
        OrthographicMatrixParams m_ortho_params{};
 
        glm::mat4 m_projection_matrix{};
        Camera m_camera{};
        ImGuiContext *m_imgui_context{};
    };
 
    class GraphicsPlatformEventObserver final : public platform::PlatformEventObserver {
    public:
        explicit GraphicsPlatformEventObserver(GraphicsController *graphics) : m_graphics(graphics) {
        }
 
        void on_window_resize(int width, int height) override;
 
    private:
        GraphicsController *m_graphics;
    };
}
#endif //GRAPHICSCONTROLLER_HPP