RenderSystem.hpp

#pragma once
#ifdef StevEngine_RENDERER_GL
#include "Object.hpp"
#include "utilities/Color.hpp"
#include "visuals/shaders/Shader.hpp"
#include "visuals/shaders/ShaderProgram.hpp"
 
#include <SDL.h>
 
#include <vector>
#include <array>
#include <cstdint>
 
#define OPENGL_MAJOR 4
#define OPENGL_MINOR 4
 
namespace StevEngine {
    namespace Visuals {
        class Light;
    }
    namespace Renderer {
        //Object
        struct RenderObject {
            const CustomObject& object;         
            const Utilities::Matrix4 transform;  

            RenderObject(const CustomObject& object, const Utilities::Matrix4& transform) : object(object), transform(transform) {}

            void Draw() {
                object.Draw(transform);
            }
        };

        enum RenderQueue {
            STANDARD,    
            TRANSPARENT,  
            OVERLAY,   
            MUST_BE_LAST  
        };

        class RenderSystem {
            public:
                void Init(SDL_Window* window);

                void DrawObject(const CustomObject& object, Utilities::Matrix4 transform, RenderQueue queue = STANDARD);

                void SetBackground(const Utilities::Color& color);

                void SetAmbientLight(float strength, const Utilities::Color& color = Utilities::Color(255,255,255,255));

                void AddGlobalShader(ShaderProgram shader);

                void ResetGlobalShader(ShaderType type);
 
                // Engine interface functions
                static const Uint32 WindowType(); 
                void DrawFrame();                  
                void SetViewSize(int WIDTH, int HEIGHT);  
                void SetVSync(bool vsync);         
                void SetFaceCulling(bool enable, GLenum face = GL_FRONT, bool clockwise = false);  
                void SetMSAA(bool enable, uint16_t amount = 4);  
 
                //Enable/disable
                void SetEnabled(bool enabled);
                private: bool enabled;
            public:
 
                // Getters
                const ShaderProgram& GetDefaultVertexShaderProgram() const { return vertexShaderProgram; }
                const ShaderProgram& GetDefaultFragmentShaderProgram() const { return fragmentShaderProgram; }
                uint32_t GetShaderPipeline() const { return shaderPipeline; }
                Utilities::Color GetAmbientLightColor() const { return ambientLightColor; }
                float GetAmbientLightStrength() const { return ambientLightStrength; }
 
                // Light management
                uint32_t GetLightID(std::string type);

                std::vector<Visuals::Light*> GetLights() const { return lights; }

                void AddLight(Visuals::Light* light);

                void RemoveLight(Visuals::Light* light);

                void ResetGPUBuffers();
 
            private:
                SDL_GLContext context;  

                std::array<std::vector<RenderObject>, RenderQueue::MUST_BE_LAST> queues;
 
                // Shader programs
                ShaderProgram vertexShaderProgram; 
                ShaderProgram fragmentShaderProgram;  
                uint32_t shaderPipeline;             
 
                // GPU Buffers
                uint32_t VBO;  
                uint32_t EBO;  
                uint32_t VAO;  
 
                // Scene properties
                Utilities::Color backgroundColor = {0, 0, 0, 255};  
                std::vector<Visuals::Light*> lights;  
                Utilities::Color ambientLightColor;   
                float ambientLightStrength;       
        };
 
        extern RenderSystem render;  
    }
}
#endif