Before adding new layer popping mechanisms

application/include/control_layer.hpp

@@ -0,0 +1,25 @@
+#ifndef LAYER_SWITCHER_HPP
+#define LAYER_SWITCHER_HPP
+
+#include <open_engine.hpp>
+
+class ControlLayer : public OpenEngine::Layer
+{
+    public:
+        ControlLayer(OpenEngine::Ref<OpenEngine::Layer> layer);
+        ~ControlLayer() = default;
+
+        void OnUpdate() override;
+        void OnEvent(OpenEngine::Event& event) override;
+        void OnImGuiRender() override;
+        void OnAttach() override;
+        void OnDetach() override;
+
+    private:
+        bool SwitchLayer(OpenEngine::KeyPressedEvent& event);
+        bool StopRunning(OpenEngine::KeyPressedEvent& event);
+
+        OpenEngine::Ref<OpenEngine::Layer> active_layer;
+};
+
+#endif // LAYER_SWITCHER_HPP

application/include/modding.hpp

@@ -0,0 +1,119 @@
+#ifndef MODDING_HPP
+#define MODDING_HPP
+
+#include <dlfcn.h>
+#include <open_engine.hpp>
+
+#include "/usr/share/dotnet/packs/Microsoft.NETCore.App.Host.arch-x64/10.0.0/runtimes/arch-x64/native/nethost.h"
+#include "/usr/share/dotnet/packs/Microsoft.NETCore.App.Host.arch-x64/10.0.0/runtimes/arch-x64/native/hostfxr.h"
+#include "/usr/share/dotnet/packs/Microsoft.NETCore.App.Host.arch-x64/10.0.0/runtimes/arch-x64/native/coreclr_delegates.h"
+
+class Modding : public OpenEngine::Layer
+{
+    public:
+        Modding()
+            : OpenEngine::Layer("modding")
+        {
+        };
+        ~Modding()
+        {
+        };
+
+        void* get_export(void* sample_lib, const char* name) {
+            // dlsym is the Linux version of GetProcAddress
+            void* f = dlsym(sample_lib, name);
+            if (!f) {
+                OE_ERROR("Failed to find symbol: {} Error: {}", name, dlerror());
+            }
+            return f;
+        }
+        // Using the nethost library, discover the location of hostfxr and get exports
+        bool load_hostfxr()
+        {
+            // Pre-allocate a large buffer for the path to hostfxr
+            char_t buffer[250];
+            size_t buffer_size = sizeof(buffer) / sizeof(char_t);
+            int rc = get_hostfxr_path(buffer, &buffer_size, nullptr);
+            if (rc != 0)
+                return false;
+
+            // Load hostfxr and get desired exports
+            auto* lib = dlopen(buffer, RTLD_NOW);
+            init_fptr = (hostfxr_initialize_for_runtime_config_fn)get_export(lib, "hostfxr_initialize_for_runtime_config");
+            get_delegate_fptr = (hostfxr_get_runtime_delegate_fn)get_export(lib, "hostfxr_get_runtime_delegate");
+            close_fptr = (hostfxr_close_fn)get_export(lib, "hostfxr_close");
+
+            return (init_fptr && get_delegate_fptr && close_fptr);
+        }
+
+        load_assembly_and_get_function_pointer_fn get_dotnet_load_assembly(const char_t *config_path)
+        {
+            // Load .NET Core
+            void *load_assembly_and_get_function_pointer = nullptr;
+            hostfxr_handle cxt = nullptr;
+            int rc = init_fptr(config_path, nullptr, &cxt);
+            if (rc != 0 || cxt == nullptr)
+            {
+                OE_ERROR("Init failed");
+                close_fptr(cxt);
+                return nullptr;
+            }
+
+            // Get the load assembly function pointer
+            rc = get_delegate_fptr(
+                    cxt,
+                    hdt_load_assembly_and_get_function_pointer,
+                    &load_assembly_and_get_function_pointer);
+            if (rc != 0 || load_assembly_and_get_function_pointer == nullptr)
+                OE_ERROR("Get delegate failed");
+
+            close_fptr(cxt);
+            return (load_assembly_and_get_function_pointer_fn)load_assembly_and_get_function_pointer;
+        }
+
+        void OnAttach() override
+        {
+            load_hostfxr();
+            auto load_assembly_and_get_function_pointer = get_dotnet_load_assembly("assets/scripts/mod_loader.runtimeconfig.json");
+            component_entry_point_fn init = nullptr;
+            int rc = load_assembly_and_get_function_pointer(
+                    dotnet_lib_path,
+                    dotnet_type,
+                    dotnet_type_method,
+                    UNMANAGEDCALLERSONLY_METHOD /*delegate_type_name*/,
+                    nullptr,
+                    (void**)&init);
+
+            init(nullptr, 1);
+        }
+
+        void OnDetach() override
+        {
+        }
+
+        void OnUpdate() override
+        {
+        }
+
+        void OnEvent(OpenEngine::Event& event) override
+        {
+            //OpenEngine::EventDispatcher dispatcher(event);
+
+            //dispatcher.Dispatch<OpenEngine::KeyPressedEvent>(BIND_EVENT_FN(Sandbox2DLayer::StopRunning));
+        }
+
+        void OnImGuiRender() override
+        {
+        }
+
+    private:
+        hostfxr_initialize_for_runtime_config_fn init_fptr;
+        hostfxr_get_runtime_delegate_fn get_delegate_fptr;
+        hostfxr_close_fn close_fptr;
+
+        const char_t* dotnet_lib_path = "assets/scripts/mod_loader.dll";
+        const char_t* dotnet_type = "OpenEngine.ModLoader, mod_loader";
+        const char_t* dotnet_type_method = "Init";
+};
+
+#endif // MODDING_HPP

application/include/sandbox2d.hpp

@@ -0,0 +1,91 @@
+#ifndef SANDBOX2D_HPP
+#define SANDBOX2D_HPP
+
+#include <dlfcn.h>
+#include <open_engine.hpp>
+
+#include "imgui.h"
+
+#include <glm/ext/matrix_transform.hpp>
+#include <glm/glm.hpp>
+
+class Sandbox2DLayer : public OpenEngine::Layer
+{
+    public:
+        Sandbox2DLayer()
+            : OpenEngine::Layer("sandbox_2d"),
+            camera((float)OpenEngine::Application::Get().GetWindow().GetWidth() /
+                    OpenEngine::Application::Get().GetWindow().GetHeight(), 1.0f)
+        {
+        }
+        ~Sandbox2DLayer() {};
+
+        void OnAttach() override
+        {
+            bindings = {
+                {"fwd/bckwd", 1},
+                {"right/left", 0},
+                {"yaw", 2}
+            };
+
+            face = OpenEngine::Texture2D::Create("assets/textures/awesomeface.png");
+        }
+
+        void OnDetach() override
+        {
+        }
+
+        void OnUpdate() override
+        {
+            OpenEngine::RenderCommand::SetClearColor({0.11f, 0.11f, 0.15f, 1.0f});
+            OpenEngine::RenderCommand::Clear();
+
+            OpenEngine::Renderer2D::BeginScene(camera.GetCamera());
+
+            OpenEngine::Renderer2D::DrawQuad(glm::vec2(0.5f, 0.5f), glm::vec2(0.3f), glm::vec4(color[0], color[1], color[2], color[3]));
+            OpenEngine::Renderer2D::DrawQuad(glm::vec2(-0.2f, -0.2f), glm::vec2(0.5f, 0.2f), {0.5f, 0.3f, 0.8f, 1.0f});
+            OpenEngine::Renderer2D::DrawQuad(glm::vec3(0.0f, 0.0f, -0.1f), glm::vec2(1.0f, 1.0f), face);
+
+            OpenEngine::Renderer2D::EndScene();
+        }
+
+        bool StopRunning(OpenEngine::KeyPressedEvent& event)
+        {
+            if (event.GetKeyCode() == OE_KEY_ESCAPE) {
+                OpenEngine::Application::Get().StopRunning();
+
+                return true;
+            }
+
+            return false;
+        }
+
+        void OnEvent(OpenEngine::Event& event) override
+        {
+            OpenEngine::EventDispatcher dispatcher(event);
+
+            //dispatcher.Dispatch<OpenEngine::KeyPressedEvent>(BIND_EVENT_FN(Sandbox2DLayer::StopRunning));
+            camera.OnEvent(event);
+        }
+
+        void OnImGuiRender() override
+        {
+            ImGui::Begin("Square settings");
+            ImGui::ColorEdit4("Square color", color);
+            ImGui::End();
+        }
+
+    private:
+        //OpenEngine::ShaderLibrary shader_library;
+
+        glm::vec3 square_pos = glm::vec3(0.0f);
+        glm::vec4 square_color = glm::vec4(1.0f);
+
+        float color[4] = {0.5f, 0.3f, 0.4f, 1.0f};
+        OpenEngine::Ref<OpenEngine::Texture2D> face;
+
+        std::unordered_map<std::string, unsigned int> bindings;
+        OpenEngine::OrthographicCameraController camera = {1280.0f / 1440.0f, 1.0f};
+};
+
+#endif // SANDBOX2D_HPP

application/src/control_layer.cpp

@@ -0,0 +1,73 @@
+#include "open_engine/core.hpp"
+#include <sandbox2d.hpp>
+#include <sandbox.hpp>
+#include <control_layer.hpp>
+
+ControlLayer::ControlLayer(OpenEngine::Ref<OpenEngine::Layer> layer)
+    : active_layer(layer), OpenEngine::Layer("control_layer")
+{
+}
+
+void ControlLayer::OnUpdate()
+{
+}
+
+bool ControlLayer::SwitchLayer(OpenEngine::KeyPressedEvent& event)
+{
+    auto& app = OpenEngine::Application::Get();
+    OpenEngine::Ref<Layer> layer;
+
+    if (event.GetKeyCode() == OE_KEY_1) {
+        OE_DEBUG("Sandbox2D Layer");
+        layer = OpenEngine::CreateRef<Sandbox2DLayer>();
+
+        app.PushLayer(layer);
+        app.PopLayer(active_layer);
+        active_layer = layer;
+
+        return true;
+    } else if (event.GetKeyCode() == OE_KEY_2) {
+        OE_DEBUG("Sandbox Layer");
+        layer = OpenEngine::CreateRef<SandboxLayer>();
+
+        app.PushLayer(layer);
+        app.PopLayer(active_layer);
+        active_layer = layer;
+
+        return true;
+    }
+
+    return false;
+}
+
+bool ControlLayer::StopRunning(OpenEngine::KeyPressedEvent& event)
+{
+    if (event.GetKeyCode() == OE_KEY_ESCAPE) {
+        OpenEngine::Application::Get().StopRunning();
+
+        return true;
+    }
+
+    return false;
+}
+
+
+void ControlLayer::OnEvent(OpenEngine::Event& event)
+{
+    OpenEngine::EventDispatcher dispatcher(event);
+
+    dispatcher.Dispatch<OpenEngine::KeyPressedEvent>(BIND_EVENT_FN(ControlLayer::SwitchLayer));
+    dispatcher.Dispatch<OpenEngine::KeyPressedEvent>(BIND_EVENT_FN(ControlLayer::StopRunning));
+}
+
+void ControlLayer::OnImGuiRender()
+{
+}
+
+void ControlLayer::OnAttach()
+{
+}
+
+void ControlLayer::OnDetach()
+{
+}

open_engine/include/open_engine/renderer/renderer2d.hpp

@@ -0,0 +1,27 @@
+#ifndef RENDERER2D_HPP
+#define RENDERER2D_HPP
+
+#include "open_engine/core.hpp"
+#include "open_engine/orthographic_camera.hpp"
+#include "open_engine/renderer/texture.hpp"
+
+#include <glm/fwd.hpp>
+
+namespace OpenEngine {
+    class Renderer2D
+    {
+        public:
+            static void Init();
+            static void Shutdown();
+
+            static void BeginScene(const OrthographicCamera& camera);
+            static void EndScene();
+
+            static void DrawQuad(const glm::vec2& position, const glm::vec2& size, const glm::vec4& color);
+            static void DrawQuad(const glm::vec3& position, const glm::vec2& size, const glm::vec4& color);
+            static void DrawQuad(const glm::vec2& position, const glm::vec2& size, const Ref<Texture2D>& texture);
+            static void DrawQuad(const glm::vec3& position, const glm::vec2& size, const Ref<Texture2D>& texture);
+    };
+}
+
+#endif // RENDERER2D_HPP

open_engine/src/open_engine/renderer/renderer2d.cpp

@@ -0,0 +1,108 @@
+#include <pch.hpp>
+
+#include <renderer/render_command.hpp>
+#include <renderer/shader.hpp>
+#include <renderer/vertex_array.hpp>
+#include <renderer/renderer2d.hpp>
+
+#include <glm/fwd.hpp>
+#include <glm/ext/matrix_transform.hpp>
+
+namespace OpenEngine {
+    struct Renderer2DData
+    {
+        Ref<VertexArray> vertex_array;
+        Ref<Shader> flat_color_shader;
+        Ref<Shader> texture_shader;
+    };
+
+    static Renderer2DData* renderer_data;
+
+    void Renderer2D::Init()
+    {
+        renderer_data = new Renderer2DData();
+        renderer_data->vertex_array = VertexArray::Create();
+
+        float square_vertices[5 * 4] = {
+            -0.5f, -0.5f, 0.0f, 0.0f, 0.0f,
+            0.5f, -0.5f, 0.0f, 1.0f, 0.0f,
+            0.5f, 0.5f, 0.0f, 1.0f, 1.0f,
+            -0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
+        };
+
+        Ref<VertexBuffer> vertex_buffer;
+        vertex_buffer.reset(VertexBuffer::Create(square_vertices, sizeof(square_vertices)));
+
+        BufferLayout layout = {
+            { ShaderDataType::Float3, "a_Position" },
+            { ShaderDataType::Float2, "a_TextCoord" }
+        };
+
+        vertex_buffer->SetLayout(layout);
+        renderer_data->vertex_array->AddVertexBuffer(vertex_buffer);
+
+        uint32_t indices[6] = { 0, 1, 2, 2, 3, 0 };
+        Ref<IndexBuffer> index_buffer;
+        index_buffer.reset(IndexBuffer::Create(indices, sizeof(indices) / sizeof(uint32_t)));
+
+        renderer_data->vertex_array->SetIndexBuffer(index_buffer);
+        renderer_data->flat_color_shader = Shader::Create("assets/shaders/flat_color.glsl");
+        renderer_data->texture_shader = Shader::Create("assets/shaders/texture.glsl");
+
+        renderer_data->texture_shader->Bind();
+        renderer_data->texture_shader->SetInt("u_Texture", 0);
+    }
+
+    void Renderer2D::Shutdown()
+    {
+        delete renderer_data;
+    }
+
+    void Renderer2D::BeginScene(const OrthographicCamera& camera)
+    {
+        renderer_data->flat_color_shader->Bind();
+        renderer_data->flat_color_shader->SetMat4("u_ViewProjection", camera.GetViewProjectionMatrix());
+
+        renderer_data->texture_shader->Bind();
+        renderer_data->texture_shader->SetMat4("u_ViewProjection", camera.GetViewProjectionMatrix());
+    }
+
+    void Renderer2D::EndScene()
+    {
+    }
+
+    void Renderer2D::DrawQuad(const glm::vec2& position, const glm::vec2& size, const Ref<Texture2D>& texture)
+    {
+        DrawQuad(glm::vec3(position, 0.0f), size, texture);
+    }
+    void Renderer2D::DrawQuad(const glm::vec3& position, const glm::vec2& size, const Ref<Texture2D>& texture)
+    {
+        renderer_data->texture_shader->Bind();
+
+        glm::mat4 transform = glm::translate(glm::mat4(1.0f), position) *
+            glm::scale(glm::mat4(1.0f), {size.x, size.y, 1.0f});
+        renderer_data->flat_color_shader->SetMat4("u_Transform", transform);
+
+        texture->Bind();
+
+        renderer_data->vertex_array->Bind();
+        RenderCommand::DrawIndexed(renderer_data->vertex_array);
+    }
+
+    void Renderer2D::DrawQuad(const glm::vec2& position, const glm::vec2& size, const glm::vec4& color)
+    {
+        DrawQuad(glm::vec3(position, 0.0f), size, color);
+    }
+    void Renderer2D::DrawQuad(const glm::vec3& position, const glm::vec2& size, const glm::vec4& color)
+    {
+        renderer_data->flat_color_shader->Bind();
+        renderer_data->flat_color_shader->SetVec4("u_Color", color);
+
+        glm::mat4 transform = glm::translate(glm::mat4(1.0f), position) *
+            glm::scale(glm::mat4(1.0f), {size.x, size.y, 1.0f});
+        renderer_data->flat_color_shader->SetMat4("u_Transform", transform);
+
+        renderer_data->vertex_array->Bind();
+        RenderCommand::DrawIndexed(renderer_data->vertex_array);
+    }
+}