Initial late commit

open_engine/include/open_engine/opengl/imgui_glfw.h

@@ -0,0 +1,73 @@
+// dear imgui: Platform Backend for GLFW
+// This needs to be used along with a Renderer (e.g. OpenGL3, Vulkan, WebGPU..)
+// (Info: GLFW is a cross-platform general purpose library for handling windows, inputs, OpenGL/Vulkan graphics context creation, etc.)
+// (Requires: GLFW 3.0+. Prefer GLFW 3.3+/3.4+ for full feature support.)
+
+// Implemented features:
+//  [X] Platform: Clipboard support.
+//  [X] Platform: Mouse support. Can discriminate Mouse/TouchScreen/Pen (Windows only).
+//  [X] Platform: Keyboard support. Since 1.87 we are using the io.AddKeyEvent() function. Pass ImGuiKey values to all key functions e.g. ImGui::IsKeyPressed(ImGuiKey_Space). [Legacy GLFW_KEY_* values are obsolete since 1.87 and not supported since 1.91.5]
+//  [X] Platform: Gamepad support. Enable with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
+//  [X] Platform: Mouse cursor shape and visibility (ImGuiBackendFlags_HasMouseCursors) with GLFW 3.1+. Resizing cursors requires GLFW 3.4+! Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'.
+//  [X] Platform: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
+//  [X] Multiple Dear ImGui contexts support.
+// Missing features or Issues:
+//  [ ] Platform: Touch events are only correctly identified as Touch on Windows. This create issues with some interactions. GLFW doesn't provide a way to identify touch inputs from mouse inputs, we cannot call io.AddMouseSourceEvent() to identify the source. We provide a Windows-specific workaround.
+//  [ ] Platform: Missing ImGuiMouseCursor_Wait and ImGuiMouseCursor_Progress cursors.
+//  [ ] Platform: Multi-viewport: Missing ImGuiBackendFlags_HasParentViewport support. The viewport->ParentViewportID field is ignored, and therefore io.ConfigViewportsNoDefaultParent has no effect either.
+
+// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
+// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
+// Learn about Dear ImGui:
+// - FAQ                  https://dearimgui.com/faq
+// - Getting Started      https://dearimgui.com/getting-started
+// - Documentation        https://dearimgui.com/docs (same as your local docs/ folder).
+// - Introduction, links and more at the top of imgui.cpp
+
+#pragma once
+#include "imgui.h"      // IMGUI_IMPL_API
+#ifndef IMGUI_DISABLE
+
+struct GLFWwindow;
+struct GLFWmonitor;
+
+// Follow "Getting Started" link and check examples/ folder to learn about using backends!
+IMGUI_IMPL_API bool     ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window, bool install_callbacks);
+IMGUI_IMPL_API bool     ImGui_ImplGlfw_InitForVulkan(GLFWwindow* window, bool install_callbacks);
+IMGUI_IMPL_API bool     ImGui_ImplGlfw_InitForOther(GLFWwindow* window, bool install_callbacks);
+IMGUI_IMPL_API void     ImGui_ImplGlfw_Shutdown();
+IMGUI_IMPL_API void     ImGui_ImplGlfw_NewFrame();
+
+// Emscripten related initialization phase methods (call after ImGui_ImplGlfw_InitForOpenGL)
+#ifdef __EMSCRIPTEN__
+IMGUI_IMPL_API void     ImGui_ImplGlfw_InstallEmscriptenCallbacks(GLFWwindow* window, const char* canvas_selector);
+//static inline void    ImGui_ImplGlfw_InstallEmscriptenCanvasResizeCallback(const char* canvas_selector) { ImGui_ImplGlfw_InstallEmscriptenCallbacks(nullptr, canvas_selector); } } // Renamed in 1.91.0
+#endif
+
+// GLFW callbacks install
+// - When calling Init with 'install_callbacks=true': ImGui_ImplGlfw_InstallCallbacks() is called. GLFW callbacks will be installed for you. They will chain-call user's previously installed callbacks, if any.
+// - When calling Init with 'install_callbacks=false': GLFW callbacks won't be installed. You will need to call individual function yourself from your own GLFW callbacks.
+IMGUI_IMPL_API void     ImGui_ImplGlfw_InstallCallbacks(GLFWwindow* window);
+IMGUI_IMPL_API void     ImGui_ImplGlfw_RestoreCallbacks(GLFWwindow* window);
+
+// GFLW callbacks options:
+// - Set 'chain_for_all_windows=true' to enable chaining callbacks for all windows (including secondary viewports created by backends or by user)
+IMGUI_IMPL_API void     ImGui_ImplGlfw_SetCallbacksChainForAllWindows(bool chain_for_all_windows);
+
+// GLFW callbacks (individual callbacks to call yourself if you didn't install callbacks)
+IMGUI_IMPL_API void     ImGui_ImplGlfw_WindowFocusCallback(GLFWwindow* window, int focused);        // Since 1.84
+IMGUI_IMPL_API void     ImGui_ImplGlfw_CursorEnterCallback(GLFWwindow* window, int entered);        // Since 1.84
+IMGUI_IMPL_API void     ImGui_ImplGlfw_CursorPosCallback(GLFWwindow* window, double x, double y);   // Since 1.87
+IMGUI_IMPL_API void     ImGui_ImplGlfw_MouseButtonCallback(GLFWwindow* window, int button, int action, int mods);
+IMGUI_IMPL_API void     ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window, double xoffset, double yoffset);
+IMGUI_IMPL_API void     ImGui_ImplGlfw_KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods);
+IMGUI_IMPL_API void     ImGui_ImplGlfw_CharCallback(GLFWwindow* window, unsigned int c);
+IMGUI_IMPL_API void     ImGui_ImplGlfw_MonitorCallback(GLFWmonitor* monitor, int event);
+
+// GLFW helpers
+IMGUI_IMPL_API void     ImGui_ImplGlfw_Sleep(int milliseconds);
+IMGUI_IMPL_API float    ImGui_ImplGlfw_GetContentScaleForWindow(GLFWwindow* window);
+IMGUI_IMPL_API float    ImGui_ImplGlfw_GetContentScaleForMonitor(GLFWmonitor* monitor);
+
+
+#endif // #ifndef IMGUI_DISABLE

open_engine/include/open_engine/opengl/imgui_opengl.h

@@ -0,0 +1,69 @@
+// dear imgui: Renderer Backend for modern OpenGL with shaders / programmatic pipeline
+// - Desktop GL: 2.x 3.x 4.x
+// - Embedded GL: ES 2.0 (WebGL 1.0), ES 3.0 (WebGL 2.0)
+// This needs to be used along with a Platform Backend (e.g. GLFW, SDL, Win32, custom..)
+
+// Implemented features:
+//  [X] Renderer: User texture binding. Use 'GLuint' OpenGL texture as texture identifier. Read the FAQ about ImTextureID/ImTextureRef!
+//  [x] Renderer: Large meshes support (64k+ vertices) even with 16-bit indices (ImGuiBackendFlags_RendererHasVtxOffset) [Desktop OpenGL only!]
+//  [X] Renderer: Texture updates support for dynamic font atlas (ImGuiBackendFlags_RendererHasTextures).
+//  [X] Renderer: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
+
+// About WebGL/ES:
+// - You need to '#define IMGUI_IMPL_OPENGL_ES2' or '#define IMGUI_IMPL_OPENGL_ES3' to use WebGL or OpenGL ES.
+// - This is done automatically on iOS, Android and Emscripten targets.
+// - For other targets, the define needs to be visible from the imgui_impl_opengl3.cpp compilation unit. If unsure, define globally or in imconfig.h.
+
+// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
+// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
+// Learn about Dear ImGui:
+// - FAQ                  https://dearimgui.com/faq
+// - Getting Started      https://dearimgui.com/getting-started
+// - Documentation        https://dearimgui.com/docs (same as your local docs/ folder).
+// - Introduction, links and more at the top of imgui.cpp
+
+// About GLSL version:
+//  The 'glsl_version' initialization parameter should be nullptr (default) or a "#version XXX" string.
+//  On computer platform the GLSL version default to "#version 130". On OpenGL ES 3 platform it defaults to "#version 300 es"
+//  Only override if your GL version doesn't handle this GLSL version. See GLSL version table at the top of imgui_impl_opengl3.cpp.
+
+#pragma once
+#include "imgui.h"      // IMGUI_IMPL_API
+#ifndef IMGUI_DISABLE
+
+// Follow "Getting Started" link and check examples/ folder to learn about using backends!
+IMGUI_IMPL_API bool     ImGui_ImplOpenGL3_Init(const char* glsl_version = nullptr);
+IMGUI_IMPL_API void     ImGui_ImplOpenGL3_Shutdown();
+IMGUI_IMPL_API void     ImGui_ImplOpenGL3_NewFrame();
+IMGUI_IMPL_API void     ImGui_ImplOpenGL3_RenderDrawData(ImDrawData* draw_data);
+
+// (Optional) Called by Init/NewFrame/Shutdown
+IMGUI_IMPL_API bool     ImGui_ImplOpenGL3_CreateDeviceObjects();
+IMGUI_IMPL_API void     ImGui_ImplOpenGL3_DestroyDeviceObjects();
+
+// (Advanced) Use e.g. if you need to precisely control the timing of texture updates (e.g. for staged rendering), by setting ImDrawData::Textures = NULL to handle this manually.
+IMGUI_IMPL_API void     ImGui_ImplOpenGL3_UpdateTexture(ImTextureData* tex);
+
+// Configuration flags to add in your imconfig file:
+//#define IMGUI_IMPL_OPENGL_ES2     // Enable ES 2 (Auto-detected on Emscripten)
+//#define IMGUI_IMPL_OPENGL_ES3     // Enable ES 3 (Auto-detected on iOS/Android)
+
+// You can explicitly select GLES2 or GLES3 API by using one of the '#define IMGUI_IMPL_OPENGL_LOADER_XXX' in imconfig.h or compiler command-line.
+#if !defined(IMGUI_IMPL_OPENGL_ES2) \
+ && !defined(IMGUI_IMPL_OPENGL_ES3)
+
+// Try to detect GLES on matching platforms
+#if defined(__APPLE__)
+#include <TargetConditionals.h>
+#endif
+#if (defined(__APPLE__) && (TARGET_OS_IOS || TARGET_OS_TV)) || (defined(__ANDROID__))
+#define IMGUI_IMPL_OPENGL_ES3               // iOS, Android  -> GL ES 3, "#version 300 es"
+#elif defined(__EMSCRIPTEN__) || defined(__amigaos4__)
+#define IMGUI_IMPL_OPENGL_ES2               // Emscripten    -> GL ES 2, "#version 100"
+#else
+// Otherwise imgui_impl_opengl3_loader.h will be used.
+#endif
+
+#endif
+
+#endif // #ifndef IMGUI_DISABLE

open_engine/include/open_engine/opengl/opengl_buffer.hpp

@@ -0,0 +1,41 @@
+#ifndef OPENGL_BUFFER_HPP
+#define OPENGL_BUFFER_HPP
+
+#include "renderer/buffer.hpp"
+#include <cstdint>
+namespace OpenEngine {
+    class OpenGLVertexBuffer : public VertexBuffer
+    {
+        public:
+            OpenGLVertexBuffer(float* vertices, uint32_t size);
+            virtual ~OpenGLVertexBuffer();
+
+            virtual void Bind() const override;
+            virtual void UnBind() const override;
+
+            virtual const BufferLayout& GetLayout() const override { return layout; }
+            virtual void SetLayout(const BufferLayout& layout) override { this->layout = layout; }
+
+        private:
+            BufferLayout layout;
+            unsigned int id;
+    };
+
+    class OpenGLIndexBuffer : public IndexBuffer
+    {
+        public:
+            OpenGLIndexBuffer(uint32_t* indices, uint32_t count);
+            virtual ~OpenGLIndexBuffer();
+
+            virtual void Bind() const override;
+            virtual void UnBind() const override;
+
+            virtual uint32_t GetCount() const override { return count; };
+
+        private:
+            unsigned int id;
+            uint32_t count;
+    };
+}
+
+#endif // OPENGL_BUFFER_HPP

open_engine/include/open_engine/opengl/opengl_context.hpp

@@ -0,0 +1,22 @@
+#ifndef OPENGL_CONTEXT_HPP
+#define OPENGL_CONTEXT_HPP
+
+#include "renderer/graphics_context.hpp"
+
+struct GLFWwindow;
+
+namespace OpenEngine {
+    class OpenGLContext : public GraphicsContext
+    {
+        public:
+            OpenGLContext(GLFWwindow* window_handle);
+
+            virtual void Init() override;
+            virtual void SwapBuffers() override;
+
+        private:
+            GLFWwindow* window_handle;
+    };
+}
+
+#endif // OPENGL_CONTEXT_HPP

open_engine/include/open_engine/opengl/opengl_renderer_api.hpp

@@ -0,0 +1,21 @@
+#ifndef OPENGL_RENDERER_API_HPP
+#define OPENGL_RENDERER_API_HPP
+
+#include "../renderer/renderer_api.hpp"
+
+namespace OpenEngine {
+    class OpenGLRendererAPI : public RendererAPI
+    {
+        public:
+            virtual void Init() override;
+
+            virtual void SetViewport(uint32_t x, uint32_t y, uint32_t width, uint32_t height) override;
+
+            virtual void SetClearColor(const glm::vec4& color) override;
+            virtual void Clear() override;
+
+            virtual void DrawIndexed(const std::shared_ptr<VertexArray>& vertex_array) override;
+    };
+}
+
+#endif // OPENGL_RENDEREAPI_HPP

open_engine/include/open_engine/opengl/opengl_shader.hpp

@@ -0,0 +1,45 @@
+#ifndef OPENGL_SHADER_HPP
+#define OPENGL_SHADER_HPP
+
+#include "../renderer/shader.hpp"
+#include <sys/types.h>
+#include <string>
+#include <glad/glad.h>
+#include <unordered_map>
+
+namespace OpenEngine {
+    class OpenGLShader : public Shader
+    {
+        public:
+            OpenGLShader(const std::string& shader_path);
+            OpenGLShader(const std::string& name, const std::string& vertex_src, const std::string& frament_src);
+            virtual ~OpenGLShader() = default;
+
+            virtual const std::string& GetName() const override { return name; };
+
+            // activate the shader
+            virtual void Bind() const override;
+            virtual void Unbind() const override;
+
+            // utility uniform functions
+            virtual void SetBool(const std::string &name, bool value) const;
+            virtual void SetInt(const std::string &name, int value) const;
+            virtual void SetFloat(const std::string &name, float value) const;
+            virtual void SetMat4(const std::string &name, const glm::mat4& value) const;
+            virtual void SetVec3(const std::string &name, const glm::vec3& value) const;
+
+
+        private:
+            std::string ReadFile(const std::string& shader_path);
+            std::unordered_map<GLenum, std::string> PreProcess(const std::string& shader_source);
+            void Compile(const std::unordered_map<GLenum, std::string> sources);
+            
+            void CheckCompileErrors(unsigned int shader, const std::string& type);
+
+            std::string name;
+
+            u_int32_t id;
+    };
+}
+
+#endif // OPENGL_SHADER_HPP

open_engine/include/open_engine/opengl/opengl_texture.hpp

@@ -0,0 +1,27 @@
+#ifndef OPENGL_TEXTURE_HPP
+#define OPENGL_TEXTURE_HPP
+
+#include <cstdint>
+#include <renderer/texture.hpp>
+
+namespace OpenEngine {
+    class OpenGLTexture2D : public Texture2D
+    {
+        public:
+            OpenGLTexture2D(const std::string& path);
+            virtual ~OpenGLTexture2D();
+
+            virtual uint32_t GetWidth() const override { return width; };
+            virtual uint32_t GetHeight() const override { return height; };
+
+            virtual void Bind(uint32_t slot = 0) const override;
+
+        private:
+            std::string path;
+
+            uint32_t width, height;
+            uint32_t id;
+    };
+}
+
+#endif // OPENGL_TEXTURE_HPP

open_engine/include/open_engine/opengl/opengl_vertex_array.hpp

@@ -0,0 +1,31 @@
+#ifndef OPENGL_VERTEX_ARRAY_HPP
+#define OPENGL_VERTEX_ARRAY_HPP
+
+#include "renderer/vertex_array.hpp"
+
+namespace OpenEngine {
+    class OpenGLVertexArray : public VertexArray
+    {
+        public:
+            OpenGLVertexArray();
+            ~OpenGLVertexArray();
+
+            virtual void Bind() const override;
+            virtual void UnBind() const override;
+
+            virtual void AddVertexBuffer(const std::shared_ptr<VertexBuffer>& vertex_buffer) override;
+            virtual void SetIndexBuffer(const std::shared_ptr<IndexBuffer>& index_buffer) override;
+
+            virtual const std::vector<std::shared_ptr<VertexBuffer>>& GetVertexBuffers() const override { return vertex_buffers; }
+            virtual const std::shared_ptr<IndexBuffer>& GetIndexBuffer() const override { return index_buffer; }
+
+        private:
+            uint32_t id;
+            uint32_t index = 0;
+            std::vector<std::shared_ptr<VertexBuffer>> vertex_buffers;
+            std::shared_ptr<IndexBuffer> index_buffer;
+    };
+
+}
+
+#endif // OPENGL_VERTEX_ARRAY_HPP