ember_core.h

Go to the documentation of this file.

#pragma once
 
#include "core/component/components.h"
#include "core/text_parser.h"
 
#pragma region OPENGL/ES
#include "core/renderer/mesh.h"
#include "core/renderer/opengl/shader_gl.h"
#pragma endregion
 
#pragma region METAL
#pragma endregion
 
#include "core/audio/ember_audio.h"
#include "core/ember_utils.h"
#include "core/system_info.h"
#include "core/http/http_client.h"
 
enum class DrawCommandMode { LINES, TRIANGLES };
 
enum class DrawCommandType {
    NONE, 
    TEXTURE, 
    TEXT, 
    LINE, 
    RECT, 
    TRIANGLE, 
    CIRCLE, 
    POLYGON 
};
 
struct DrawCommand {
    DrawCommandType type = DrawCommandType::NONE; 
    std::vector<Vertex> vertices; 
    std::vector<uint32_t> indices; 
    Uint32 texture_id   = 0; 
    float line_width    = 1.0f; 
    int circle_segments = 32; 
    int z_index         = 0; 
 
    explicit DrawCommand(DrawCommandType t, int z = 0) : type(t), z_index(z) {
    }
};
 
struct BatchKey {
    Uint32 texture_id; 
    int z_index; 
    DrawCommandType type; 
    UberShader uber_shader = UberShader::none(); 
 
    bool operator==(const BatchKey& other) const {
        return texture_id == other.texture_id && z_index == other.z_index && type == other.type;
    }
};
 
template <>
struct std::hash<BatchKey> {
    std::size_t operator()(const BatchKey& k) const {
        std::size_t h1       = std::hash<Uint32>()(k.texture_id);
        std::size_t h2       = std::hash<int>()(k.z_index);
        std::size_t h3       = std::hash<int>()(static_cast<int>(k.type));
        std::size_t combined = h1 ^ (h2 << 1);
        return (combined >> 1) ^ h3;
    }
};
 
struct Batch {
    std::vector<Vertex> vertices; 
    std::vector<uint32_t> indices; 
    Uint32 texture_id      = 0; 
    DrawCommandType type   = DrawCommandType::NONE; 
    int z_index            = 0; 
    UberShader uber_shader = UberShader::none(); 
    DrawCommandMode mode   = DrawCommandMode::TRIANGLES;
    float thickness = 1.0f; 
};
 
 
class Renderer {
public:
    virtual ~Renderer() = default;
 
    int Viewport[2]    = {800, 600}; 
    SDL_Window* Window = nullptr; 
    Backend Type  = Backend::GL_COMPATIBILITY; 
 
    virtual void initialize() = 0;
 
    virtual bool load_font(const std::string& font_path, const std::string& font_alias, int font_size = 48) = 0;
 
 
    virtual std::shared_ptr<Texture> load_texture(const std::string& path) = 0;
 
    virtual std::shared_ptr<Texture> get_texture(const std::string& path) = 0;
 
    virtual void draw_texture(const Texture* texture, const Rect2& dest_rect, float rotation, const glm::vec4& color,
                                      const Rect2& src_rect, int z_index,
                                      bool flip_h = false, bool flip_v = false, const UberShader& uber_shader = {}) = 0;
 
    virtual void draw_rect(Rect2 rect, float rotation, const glm::vec4& color, bool filled = true, int z_index = 0) = 0;
 
    virtual void draw_text(const std::string& text, float x, float y, float rotation, float scale, const glm::vec4& color,
                           const std::string& font_alias = "", int z_index = 0,
                           const UberShader& uber_shader = UberShader::none(),int ft_size = 0) = 0;
 
    virtual void draw_line(float x1, float y1, float x2, float y2, float thickness, float rotation, const glm::vec4& color,
                           int z_index = 0) = 0;
 
    virtual void draw_triangle(float x1, float y1, float x2, float y2, float x3, float y3, float rotation, const glm::vec4& color,
                               bool filled = true, int z_index = 0) = 0;
 
    virtual void draw_circle(float center_x, float center_y, float rotation, float radius, const glm::vec4& color, bool filled = true,
                             int segments = 32, int z_index = 0) = 0;
 
    virtual void draw_polygon(const std::vector<glm::vec2>& points, float rotation, const glm::vec4& color, bool filled = true,
                              int z_index = 0) = 0;
 
 
    virtual void flush() = 0;
 
    virtual void present() = 0;
 
    virtual void clear(glm::vec4 color = glm::vec4(0.0f, 0.0f, 0.0f, 0.0f)) = 0;
 
    virtual void resize_viewport(int view_width, int view_height) = 0;
 
    virtual void set_context(const void* ctx) = 0;
 
    virtual void* get_context() = 0;
 
    virtual void destroy() = 0;
 
    virtual void unload_font(const Font& font) = 0;
 
    virtual void unload_texture(Uint32 id) = 0;
 
    void set_view_matrix(const glm::mat4& view_matrix  = glm::mat4(1.f));
 
    [[nodiscard]] glm::mat4 get_view_matrix() const;
 
   virtual   Uint32 get_framebuffer_texture() const  {
       return 0;
   }
 
    virtual HashMap<std::string, std::shared_ptr<Texture>>& get_loaded_textures() {
        return _textures;
    }
 
    virtual std::vector<std::string>& get_loaded_fonts_name() {
        static std::vector<std::string> font_names;
        font_names.clear();
 
        for (const auto& [name, font] : fonts) {
            font_names.push_back(name);
        }
 
        return font_names;
    }
 
 
protected:
    HashMap<BatchKey, Batch> _batches; 
 
    FT_Library _ft = {}; 
 
    HashMap<std::string, Font> fonts; 
    std::string current_font_name; 
 
    glm::mat4 _projection = glm::mat4(1.f); 
    glm::mat4 _view       = glm::mat4(1.f); 
 
    HashMap<std::string, std::shared_ptr<Texture>> _textures; 
 
    HashMap<Uint32, glm::vec2> _texture_sizes; 
 
    virtual void set_default_font(const std::string& font_name) = 0;
 
    glm::vec2 rotate_point(const glm::vec2& point, const glm::vec2& center, float radians);
 
    Recti calc_display();
 
    virtual void render_fbo() = 0;
 
    void submit(const BatchKey& key, float x, float y, float w, float h, float u0, float v0, float u1, float v1,
                            const glm::vec4& color, float rotation = 0.0f, bool is_filled = true);
 
    virtual void set_effect_uniforms(const UberShader& uber_shader, const glm::vec2& texture_size = glm::vec2(1, 1)) = 0;
 
    [[nodiscard]] virtual glm::vec2 get_texture_size(Uint32 texture_id) const = 0;
};