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()
+{
+}