fixing compilation

still fixing compilation errors
updating cmakelists
2026-03-10 10:12:48 +01:00 · 2026-03-10 09:57:38 +01:00 · 2026-03-10 09:41:46 +01:00 · 2026-03-10 09:29:19 +01:00 · 2026-03-10 09:29:13 +01:00 · 2026-03-10 09:19:03 +01:00
47 changed files with 1697 additions and 453 deletions
--- a/.envrc
+++ b/.envrc
@@ -0,0 +1,4 @@
+export CC=clang
+export CXX=clang++
+export COMPILE_COMMANDS=ON
+export BUILD_TYPE=Debug
--- a/.gitmodules
+++ b/.gitmodules
@@ -0,0 +1,6 @@
+[submodule "vendor/ImGuizmo"]
+	path = vendor/ImGuizmo
+	url = https://github.com/CedricGuillemet/ImGuizmo
+[submodule "open_engine/vendor/nativefiledialog-extended"]
+	path = open_engine/vendor/nativefiledialog-extended
+	url = https://github.com/btzy/nativefiledialog-extended
--- a/.onedev-buildspec.yml
+++ b/.onedev-buildspec.yml
@@ -0,0 +1,73 @@
+version: 46
+jobs:
+- name: Push to Gitea
+  steps:
+  - type: PushRepository
+    name: Push to Gitea
+    remoteUrl: https://gitea.anfer.fr/anfer/OpenEngine
+    passwordSecret: Gitea
+    force: false
+    condition: SUCCESSFUL
+    optional: false
+  triggers:
+  - type: BranchUpdateTrigger
+    branches: main
+    userMatch: anyone
+    projects: OpenEngine
+  - type: TagCreateTrigger
+    branches: main
+    projects: OpenEngine
+  retryCondition: never
+  maxRetries: 3
+  retryDelay: 30
+  timeout: 14400
+- name: Compile for Linux
+  steps:
+  - type: CheckoutStep
+    name: Checkout
+    cloneCredential:
+      type: DefaultCredential
+    withLfs: false
+    withSubmodules: false
+    condition: SUCCESSFUL
+    optional: false
+  - type: CommandStep
+    name: Compile for Linux
+    runInContainer: true
+    image: erriss/erris-build_tools:V0.7
+    interpreter:
+      type: DefaultInterpreter
+      commands: |
+        conan profile detect --force
+        git submodule update --init --recursive
+        conan install . -c tools.system.package_manager:mode=install --output-folder=build --build=missing -s build_type=${BUILD_TYPE}
+        cmake -S . -G Ninja -B build -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DCMAKE_TOOLCHAIN_FILE=conan_toolchain.cmake
+
+        echo ====== Building =============================
+        cmake --build build --config ${BUILD_TYPE}
+
+        echo ====== ls ===================================
+        ls -la
+
+        echo ====== ls build =============================
+        ls build -la
+    envVars:
+    - name: BUILD_TYPE
+      value: Debug
+    - name: CC
+      value: clang
+    - name: CXX
+      value: clang++
+    useTTY: true
+    condition: SUCCESSFUL
+    optional: false
+  - type: PublishArtifactStep
+    name: Get build artifacts
+    sourcePath: build
+    artifacts: editor/* open_engine/*
+    condition: SUCCESSFUL
+    optional: false
+  retryCondition: never
+  maxRetries: 3
+  retryDelay: 30
+  timeout: 14400
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.28)
+cmake_minimum_required(VERSION 3.25.1)

 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

--- a/README.md
+++ b/README.md
@@ -0,0 +1 @@
+Readme
--- a/assets/shaders/color3d.glsl
+++ b/assets/shaders/color3d.glsl
@@ -2,10 +2,8 @@
 #version 450 core

 layout(location = 0) in vec3 a_Position;
-layout(location = 1) in vec4 a_Color;
-layout(location = 2) in vec3 a_Normal;
-layout(location = 3) in vec2 a_TexCoord;
-layout(location = 4) in int a_EntityID;
+layout(location = 1) in vec3 a_Normal;
+layout(location = 2) in vec2 a_TexCoord;

 layout(std140, binding = 0) uniform Camera
 {
@@ -20,25 +18,20 @@ layout(std140, binding = 1) uniform Transform

 struct VertexOutput
 {
-	vec4 Color;
 	vec2 TexCoord;
    vec3 Normal;
    vec3 ViewPos;
 };

 layout (location = 0) out VertexOutput Output;
-layout (location = 4) out flat int v_EntityID;
 layout (location = 5) out vec4 v_Pos;

 void main()
 {
-	Output.Color = a_Color;
 	Output.TexCoord = a_TexCoord;
    Output.Normal = mat3(transpose(inverse(u_Transform))) * a_Normal;
    Output.ViewPos = u_ViewPosition;

-	v_EntityID = a_EntityID;
-
    v_Pos = u_Transform * vec4(a_Position, 1.0);
    gl_Position = u_ViewProjection * v_Pos;
 }
@@ -49,9 +42,22 @@ void main()
 layout (location = 0) out vec4 color;
 layout (location = 1) out int color2;

+layout (std140, binding = 2) uniform Material
+{
+    vec4 u_Albedo;
+    float u_Roughness;
+    float u_Metallic;
+    float u_AmbientStrength;
+    float u_SpecularStrength;
+};
+
+layout(std140, binding = 3) uniform EditorID
+{
+    int u_EntityID;
+};
+
 struct VertexOutput
 {
-	vec4 Color;
 	vec2 TexCoord;
    vec3 Normal;
    vec3 ViewPos;
@@ -67,8 +73,7 @@ void main()
    vec3 lightColor = vec3(1.0f, 1.0f, 1.0f);

    // Ambiant lighting
-    float ambientStrength = 0.8;
-    vec3 ambient = ambientStrength * lightColor;
+    vec3 ambient = lightColor * u_AmbientStrength;

    // Diffuse lighting
    vec3 norm = normalize(Input.Normal);
@@ -78,16 +83,19 @@ void main()
    vec3 diffuse = diff * lightColor;

    // Specular highlight
-    float specularStrength = 0.5;
    vec3 viewDir = normalize(Input.ViewPos - v_Pos.xyz); // .xyz here too
    vec3 reflectDir = reflect(-lightDir, norm);

-    float spec = pow(max(dot(viewDir, reflectDir), 0.0), 32);
-    vec3 specular = specularStrength * spec * lightColor;
+    float shininess = mix(2.0, 256.0, 1.0 - u_Roughness);
+    float spec = pow(max(dot(viewDir, reflectDir), 0.0), shininess);
+    vec3 specularColor = mix(vec3(1.0), u_Albedo.rgb, u_Metallic);
+    vec3 specular = u_SpecularStrength * spec * lightColor * specularColor;

-    vec3 result = (ambient + diffuse + specular) * Input.Color.rgb; // objectColor → Input.Color.rgb
+    // Total
+    //vec3 result = (ambient + diffuse + specular) * Input.Color.rgb; // objectColor → Input.Color.rgb
+    vec3 result = (ambient + diffuse + specular) * u_Albedo.rgb; // objectColor → Input.Color.rgb

    // Output
-    color = vec4(result, 1.0); // vec3 → vec4
-	color2 = v_EntityID;
+    color = vec4(result, u_Albedo.w); // vec3 → vec4
+	color2 = u_EntityID;
 }
--- a/conanfile.txt
+++ b/conanfile.txt
@@ -4,6 +4,9 @@ spdlog/1.16.0
 entt/3.16.0
 yaml-cpp/0.8.0
 joltphysics/5.2.0
+fastgltf/0.9.0
+glm/1.0.1
+glfw/3.4

 [generators]
 CMakeDeps
--- a/editor/CMakeLists.txt
+++ b/editor/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.28)
+cmake_minimum_required(VERSION 3.25.1)

 set(CMAKE_CXX_STANDARD 20)

--- a/editor/include/editor.hpp
+++ b/editor/include/editor.hpp
@@ -1,15 +1,21 @@
 #ifndef EDITOR_HPP
 #define EDITOR_HPP

-#include <X11/X.h>
 #include <open_engine.hpp>

+#include "open_engine/fastgltf.hpp"
+#include "open_engine/logging.hpp"
+#include "open_engine/ref_scope.hpp"
+#include "open_engine/renderer/model3d.hpp"
 #include "open_engine/renderer/renderer3d.hpp"
 #include "open_engine/scene/components.hpp"
-#include "open_engine/scene/scene_serializer.hpp"
 #include "panels/content_browser.hpp"
 #include "panels/scene_hierarchy.hpp"

+#include <Jolt/Physics/Collision/Shape/Shape.h>
+#include <Jolt/Math/Real.h>
+#include <Jolt/Math/Vec3.h>
+#include <Jolt/Physics/Body/BodyCreationSettings.h>
 #include <glm/ext/matrix_transform.hpp>
 #include <glm/gtc/type_ptr.hpp>
 #include <glm/matrix.hpp>
@@ -92,33 +98,56 @@ namespace OpenEngine {

                editor_camera = EditorCamera(30.0f, 1920.0f/1080.0f, 0.1f, 1000.0f);

+                // TODO: Add license
                icons["play"] = Texture2D::Create("resources/textures/icons/play.png");
                icons["stop"] = Texture2D::Create("resources/textures/icons/stop.png");

+                // =============================================
                Entity cube = scene->CreateEntity("cube");

-
-                cube.AddComponent<TransformComponent>();
+                auto& tc = cube.AddComponent<TransformComponent>();

                Ref<Mesh> mesh = CreateCube(cube);

-                cube.AddComponent<MeshComponent>(mesh);
+                auto& mc = cube.AddComponent<MeshComponent>(mesh);
+                mc.primitive_type = PrimitiveType::Cube;

+                // =============================================
                Entity quad = scene->CreateEntity("quad");
                quad.AddComponent<TransformComponent>();
                quad.GetComponents<TransformComponent>().translation = {0, 0, 0};

                Ref<Mesh> quad_mesh = CreateQuad(quad, true);

-                quad.AddComponent<MeshComponent>(quad_mesh);
+                auto& mc3 = quad.AddComponent<MeshComponent>(quad_mesh);
+                mc3.primitive_type = PrimitiveType::Quad;

+                // =============================================
                Entity cube2 = scene->CreateEntity("cube2");
                cube2.AddComponent<TransformComponent>();
                cube2.GetComponents<TransformComponent>().translation = {2, 0, 0};

                Ref<Mesh> mesh2 = CreateCube(cube2);

-                cube2.AddComponent<MeshComponent>(mesh2);
+                auto& mc2 = cube2.AddComponent<MeshComponent>(mesh2);
+                mc2.primitive_type = PrimitiveType::Cube;
+
+                // ============================================================
+
+                Entity cube3 = scene->CreateEntity("glb");
+                Entity cube4 = scene->CreateEntity("glb2");
+                Entity cube5 = scene->CreateEntity("glb2");
+                cube3.AddComponent<TransformComponent>();
+                cube4.AddComponent<TransformComponent>();
+                cube5.AddComponent<TransformComponent>();
+
+                Ref<Model3D> model = Model3D::Create("./assets/models/cubes.glb");
+                Ref<Model3D> model2 = Model3D::Create("./assets/models/cube_legs.glb");
+                Ref<Model3D> monkey = Model3D::Create("./assets/models/monkey.glb");
+
+                cube3.AddComponent<ModelComponent>(model);
+                cube4.AddComponent<ModelComponent>(model2);
+                cube5.AddComponent<ModelComponent>(monkey);

                /*
                auto view = scene->GetRegistry().view<TagComponent>();
@@ -129,7 +158,6 @@ namespace OpenEngine {
                }
                */

-                // TODO: Add file texture. Get free icons and add license
                //icons["folder"] = Texture2D::Create("resources/textures/icons/folder.png");
                /*
                for (float i = 0; i < 200; i++) {
@@ -179,7 +207,6 @@ namespace OpenEngine {
                RenderCommand::Clear();
                framebuffer->ClearBufferI(1, -1);

-
                switch (state) {
                    case PlayState::Play: {
                        scene->OnUpdateRuntime();
@@ -206,6 +233,7 @@ namespace OpenEngine {
                static bool clicked = false;
                // Mouse Picking
                if (Input::IsMouseButtonPressed(MouseCode::ButtonLeft)
+                        && !Application::Get().GetImGuiLayer()->GetBlockEvents()
                        && mouse_x >= 0 && mouse_y >= 0
                        && mouse_x < (int)viewport_size.x
                        && mouse_y < (int)viewport_size.y
@@ -278,6 +306,10 @@ namespace OpenEngine {
                        guizmo_operation = ImGuizmo::OPERATION::SCALE;
                        break;
                    }
+                    case KeyCode::T: {
+                        guizmo_operation = ImGuizmo::OPERATION::UNIVERSAL;
+                        break;
+                    }
                    case KeyCode::Delete: {
                        scene->MarkEntityForDeletion(selected_entity);
                        scene_hierarchy.ClearSelection();
@@ -352,7 +384,7 @@ namespace OpenEngine {
                bool was_focused = viewport_focused;
                viewport_focused = ImGui::IsWindowFocused(ImGuiFocusedFlags_RootWindow);
                viewport_hovered = ImGui::IsWindowHovered(ImGuiHoveredFlags_RootWindow);
-                Application::Get().GetImGuiLayer()->SetBlockEvents((!viewport_focused && !viewport_hovered) || ImGui::IsAnyItemActive());
+                Application::Get().GetImGuiLayer()->SetBlockEvents(ImGui::IsAnyItemActive());

                if (viewport_focused && !was_focused)
                    editor_camera.ResetMousePosition();
@@ -563,10 +595,12 @@ namespace OpenEngine {
            void OnScenePlay()
            {
                state = PlayState::Play;
+                scene->OnRuntimeStart();
            }
            void OnSceneStop()
            {
                state = PlayState::Edit;
+                scene->OnRuntimeStop();
            }

        private:
--- a/editor/include/editor_component.hpp
+++ b/editor/include/editor_component.hpp
@@ -17,6 +17,12 @@ namespace OpenEngine {
    void SpriteOnImGuiRender(entt::registry& registry, entt::entity entity);
    void CameraOnImGuiRender(entt::registry& registry, entt::entity entity);
    void MeshOnImGuiRender(entt::registry&registry, entt::entity entity);
+    void MaterialOnImGuiRender(entt::registry& registry, entt::entity entity);
+    void BodyOnImGuiRender(entt::registry& registry, entt::entity entity);
+    void SphereShapeOnImGuiRender(entt::registry& registry, entt::entity entity);
+    void BoxShapeOnImGuiRender(entt::registry& registry, entt::entity entity);
+    void PlaneShapeOnImGuiRender(entt::registry& registry, entt::entity entity);
+    void ModelOnImGuiRender(entt::registry& registry, entt::entity entity);
 }

 #endif // EDITOR_COMPONENT_HPP
--- a/editor/include/panels/content_browser.hpp
+++ b/editor/include/panels/content_browser.hpp
@@ -18,6 +18,7 @@ namespace OpenEngine {
        private:
            std::filesystem::path current_directory;
            Ref<Texture2D> folder_icon;
+            Ref<Texture2D> file_icon;
    };

 }
--- a/editor/src/editor_component.cpp
+++ b/editor/src/editor_component.cpp
@@ -1,5 +1,11 @@
 #include "imgui.h"
+#include "open_engine/renderer/renderer3d.hpp"
+#include "open_engine/scene/components.hpp"
+#include <Jolt/Physics/Body/MotionType.h>
+#include <cstdint>
 #include <editor_component.hpp>
+#include <entt/entity/fwd.hpp>
+#include <glm/gtc/type_ptr.hpp>
 #include <open_engine.hpp>

 namespace OpenEngine {
@@ -91,6 +97,7 @@ namespace OpenEngine {
        if (ImGui::InputText("##tagEditor", buffer, sizeof(buffer), ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_AutoSelectAll)
                || (!ImGui::IsItemActive() && ImGui::IsMouseClicked(0)))
            tag = buffer;
+        ImGui::Spacing();
    };

    void TransformOnImGuiRender(entt::registry& registry, entt::entity entity) 
@@ -101,6 +108,7 @@ namespace OpenEngine {
        DrawVec3Control("Rotation", rotation_comp);
        transform.rotation = glm::radians(rotation_comp);
        DrawVec3Control("Scale", transform.scale);
+        ImGui::Spacing();
    };
    
    void SpriteOnImGuiRender(entt::registry& registry, entt::entity entity) 
@@ -171,8 +179,148 @@ namespace OpenEngine {

    };

-    void MeshOnImGuiRender(entt::registry&registry, entt::entity entity)
+    void MeshOnImGuiRender(entt::registry& registry, entt::entity entity)
    {
+        auto& mesh_component = registry.get<MeshComponent>(entity); 

+        const char* items[] = { "None", "Quad", "Cube" };
+
+        int item_selected_idx = (int)mesh_component.primitive_type;
+        if (ImGui::BeginCombo("Mesh", items[item_selected_idx])) {
+            for (int n = 0; n < 3; n++) {
+                const bool is_selected = (item_selected_idx == n);
+                if (ImGui::Selectable(items[n], is_selected))
+                    item_selected_idx = n;
+
+                // Set the initial focus when opening the combo (scrolling + keyboard navigation focus)
+                if (is_selected)
+                    ImGui::SetItemDefaultFocus();
+            }
+            ImGui::EndCombo();
+        }
+
+        if ((int)mesh_component.primitive_type == (item_selected_idx))
+            return;
+
+        mesh_component.primitive_type = (PrimitiveType)(item_selected_idx);
+        switch (mesh_component.primitive_type) {
+            case OpenEngine::PrimitiveType::Quad:
+                {
+                    mesh_component.mesh = CreateQuad((uint32_t)entity);
+                    break;
+                }
+            case OpenEngine::PrimitiveType::Cube:
+                {
+                    mesh_component.mesh = CreateCube((uint32_t)entity);
+                    break;
+                }
+            default:
+                mesh_component.mesh = nullptr;
+                break;
+        }
+    }
+
+    void MaterialOnImGuiRender(entt::registry& registry, entt::entity entity)
+    {
+        auto& material = registry.get<MaterialComponent>(entity).material;
+
+        ImGui::SliderFloat4("Albedo", glm::value_ptr(material.albedo), 0, 1);
+        ImGui::SliderFloat("Roughness", &material.roughness, 0, 1);
+        ImGui::SliderFloat("Metallic", &material.metallic, 0, 1);
+        ImGui::SliderFloat("Ambient strength", &material.ambient_strength, 0, 1);
+        ImGui::SliderFloat("Specular strength", &material.specular_strength, 0, 10);
+    }
+
+    void BodyOnImGuiRender(entt::registry &registry, entt::entity entity)
+    {
+        auto& body_comp = registry.get<PhysicsBodyComponent>(entity);
+
+        const char* items[] = { "Static", "Kinematic", "Dynamic" };
+        int item_selected_idx = body_comp.type;
+
+        if (ImGui::BeginCombo("Body type", items[item_selected_idx])) {
+            for (int n = 0; n < 3; n++)
+            {
+                const bool is_selected = (item_selected_idx == n);
+                if (ImGui::Selectable(items[n], is_selected))
+                    item_selected_idx = n;
+
+                // Set the initial focus when opening the combo (scrolling + keyboard navigation focus)
+                if (is_selected)
+                    ImGui::SetItemDefaultFocus();
+            }
+            ImGui::EndCombo();
+        }
+
+        body_comp.type = item_selected_idx;
+
+        ImGui::SliderFloat("Linear damping", &body_comp.linear_damping, 0, 1);
+        ImGui::SliderFloat("Angular damping", &body_comp.angular_damping, 0, 1);
+        ImGui::SliderFloat("Gravity factor", &body_comp.gravity_factor, 0, 1);
+        ImGui::SliderFloat("Bounciness", &body_comp.restitution, 0, 1);
+        ImGui::SliderFloat("Friction", &body_comp.friction, 0, 1);
+    }
+
+    void SphereShapeOnImGuiRender(entt::registry &registry, entt::entity entity)
+    {
+        auto& sphere_comp = registry.get<SphereShapeComponent>(entity);
+        
+        ImGui::DragFloat("Radius",
+                &sphere_comp.radius,
+                0.1f,
+                0.11f, FLT_MAX,
+                "%.2f",
+                ImGuiSliderFlags_AlwaysClamp);
+    }
+
+    void BoxShapeOnImGuiRender(entt::registry &registry, entt::entity entity)
+    {
+        auto& box_comp = registry.get<BoxShapeComponent>(entity);
+        
+        ImGui::DragFloat3("Size",
+                glm::value_ptr(box_comp.size),
+                0.1f,
+                0.11f, FLT_MAX,
+                "%.2f",
+                ImGuiSliderFlags_AlwaysClamp);
+    }
+
+    void PlaneShapeOnImGuiRender(entt::registry& registry, entt::entity entity)
+    {
+        auto& planed_comp = registry.get<PlaneShapeComponent>(entity);
+
+        ImGui::DragFloat("Size",
+                &planed_comp.extent,
+                0.1f,
+                0.01f, FLT_MAX,
+                "%.2f",
+                ImGuiSliderFlags_AlwaysClamp);
+    }
+
+    void ModelOnImGuiRender(entt::registry& registry, entt::entity entity)
+    {
+        auto& model_comp = registry.get<ModelComponent>(entity);
+
+        bool opened = ImGui::TreeNodeEx(
+                (void*)(intptr_t)entity,
+                ImGuiTreeNodeFlags_None,
+                "Meshes");
+
+        if (opened) {
+            unsigned int i = 0;
+            for (auto& mesh : model_comp.model->GetMeshes())
+                ImGui::Text("Mesh: %i", i++);
+
+
+            ImGui::PushStyleColor(ImGuiCol_ChildBg, {1, 1, 1, 1});
+            if (ImGui::BeginChild("Material list")) {
+                for (auto& mesh : model_comp.model->GetMeshes())
+                    ImGui::Text("Material: %s", mesh.material.name.c_str());
+                ImGui::EndChild();
+            }
+            ImGui::PopStyleColor();
+
+            ImGui::TreePop();
+        }
    }
 }
--- a/editor/src/panels/content_browser.cpp
+++ b/editor/src/panels/content_browser.cpp
@@ -15,8 +15,9 @@ namespace OpenEngine {
    ContentBrowserPanel::ContentBrowserPanel()
        : current_directory(assets_directory)
    {
-        // TODO: Add file texture. Get free icons and add license
-        folder_icon = Texture2D::Create("resources/textures/icons/folder.png");
+        // TODO: Add license
+        folder_icon = Texture2D::Create("resources/textures/icons/folder2.png");
+        file_icon = Texture2D::Create("resources/textures/icons/file.png");
    }

    void ContentBrowserPanel::OnImGuiRender()
@@ -30,6 +31,16 @@ namespace OpenEngine {
                current_directory = current_directory.parent_path();

        auto directory_it = std::filesystem::directory_iterator(current_directory);
+        std::vector<std::filesystem::directory_entry> entries;
+
+        for (auto entry : directory_it)
+            entries.emplace_back(entry);
+
+        std::sort(entries.begin(), entries.end(),
+                [](const std::filesystem::directory_entry& a,
+                    const std::filesystem::directory_entry& b) {
+                return (a.is_directory() && !b.is_directory());
+                });

        ImVec2 button_size = { 100, 100 };
        auto panel_width = ImGui::GetContentRegionAvail().x;
@@ -42,9 +53,12 @@ namespace OpenEngine {

        ImGui::PushStyleVar(ImGuiStyleVar_CellPadding, padding);

+        float margin = 20.0f;
+        ImGui::Indent(margin);
+
        if (ImGui::BeginTable("table1", table_columns, ImGuiTableFlags_SizingFixedSame))
        {
-            for (auto& entry : directory_it) {
+            for (auto& entry : entries) {
                auto file_name = entry.path().filename().string();

                ImGui::PushID(file_name.c_str());
@@ -56,17 +70,14 @@ namespace OpenEngine {
                ImGui::PushStyleColor(ImGuiCol_ButtonActive, { 0.270f, 0.278f, 0.352f, 1.0f });

                ImGui::BeginGroup();
-                ImGui::ImageButton("##X", (ImTextureID)folder_icon->GetID(), button_size, { 0, 1 }, { 1, 0 });
+                Ref<Texture2D> icon = entry.is_directory() ? folder_icon : file_icon;
+                ImGui::ImageButton("##X", (ImTextureID)icon->GetID(), button_size, { 0, 1 }, { 1, 0 });
                if (entry.is_regular_file() && ImGui::BeginDragDropSource()) {
                    const char* source = entry.path().c_str();
                    ImGui::SetDragDropPayload("CONTENT_BROWSER_PAYLOAD", source, (strlen(source) + 1) * sizeof(char), ImGuiCond_Once);

                    ImGui::EndDragDropSource();
                }
-
-                float columnWidth = ImGui::GetColumnWidth();
-                float textWidth = ImGui::CalcTextSize(file_name.c_str()).x;
-                ImGui::SetCursorPosX(ImGui::GetCursorPosX() + (columnWidth - textWidth) * 0.5f);
                ImGui::TextWrapped("%s", file_name.c_str());

                ImGui::EndGroup();
@@ -81,6 +92,7 @@ namespace OpenEngine {
            }
            ImGui::EndTable();
        }
+        ImGui::Unindent();
        ImGui::PopStyleVar();

        ImGui::End();
--- a/editor/src/panels/scene_hierarchy.cpp
+++ b/editor/src/panels/scene_hierarchy.cpp
@@ -23,6 +23,12 @@ namespace OpenEngine {
        RegisterDrawer<SpriteRendererComponent>("Sprite Renderer", &SpriteOnImGuiRender);
        RegisterDrawer<CameraComponent>("Camera", &CameraOnImGuiRender);
        RegisterDrawer<MeshComponent>("Mesh", &MeshOnImGuiRender);
+        RegisterDrawer<MaterialComponent>("Material", &MaterialOnImGuiRender);
+        RegisterDrawer<PhysicsBodyComponent>("Physics Body", &BodyOnImGuiRender);
+        RegisterDrawer<SphereShapeComponent>("Sphere Shape", &SphereShapeOnImGuiRender);
+        RegisterDrawer<BoxShapeComponent>("Box Shape", &BoxShapeOnImGuiRender);
+        RegisterDrawer<PlaneShapeComponent>("Plane Shape", &PlaneShapeOnImGuiRender);
+        RegisterDrawer<ModelComponent>("Model", &ModelOnImGuiRender);

        scene = context;
        selected_context = {};
@@ -51,6 +57,36 @@ namespace OpenEngine {
                selected_context.AddComponent<MeshComponent>();
                ImGui::CloseCurrentPopup();
            }
+        if (!selected_context.HasComponent<MaterialComponent>())
+            if (ImGui::MenuItem("Material")) {
+                selected_context.AddComponent<MaterialComponent>();
+                ImGui::CloseCurrentPopup();
+            }
+        if (!selected_context.HasComponent<PhysicsBodyComponent>())
+            if (ImGui::MenuItem("Physics body")) {
+                selected_context.AddComponent<PhysicsBodyComponent>();
+                ImGui::CloseCurrentPopup();
+            }
+        if (!selected_context.HasComponent<SphereShapeComponent>())
+            if (ImGui::MenuItem("Sphere shape")) {
+                selected_context.AddComponent<SphereShapeComponent>();
+                ImGui::CloseCurrentPopup();
+            }
+        if (!selected_context.HasComponent<BoxShapeComponent>())
+            if (ImGui::MenuItem("Box shape")) {
+                selected_context.AddComponent<BoxShapeComponent>();
+                ImGui::CloseCurrentPopup();
+            }
+        if (!selected_context.HasComponent<PlaneShapeComponent>())
+            if (ImGui::MenuItem("Plane shape")) {
+                selected_context.AddComponent<PlaneShapeComponent>();
+                ImGui::CloseCurrentPopup();
+            }
+        if (!selected_context.HasComponent<ModelComponent>())
+            if (ImGui::MenuItem("Model")) {
+                selected_context.AddComponent<ModelComponent>();
+                ImGui::CloseCurrentPopup();
+            }
    }

    void EntityPopup(Ref<Scene>& scene)
@@ -195,16 +231,17 @@ namespace OpenEngine {
    void SceneHierarchy::DrawComponents(Entity& entity)
    {
        auto& reg = scene->GetRegistry();
-        entt::entity handle = selected_context;
+        entt::entity handle = entity;

-        if (!selected_context || !entity)
+        if (!entity)
            return;

        entity.GetComponents<TagComponent>();
        TagOnImGuiRender(reg, entity);

+        // TODO: Defer deletion like the entities?
+        std::vector<entt::id_type> pending_deletion; // 0 is null/invalid in entt usually

-        std::vector<entt::id_type> component_to_delete; // 0 is null/invalid in entt usually
        // Iterate through every component type entt knows about
        for (auto [id, storage] : reg.storage()) {
            if (storage.contains(handle)) {
@@ -228,20 +265,24 @@ namespace OpenEngine {

                    if (ImGui::BeginPopup("component_settings")) {
                        if (ImGui::MenuItem("Remove component"))
-                            component_to_delete.emplace_back(id);
+                            pending_deletion.emplace_back(id);

                        ImGui::EndPopup();
                    }

                    if (opened) {
+                        ImGui::Spacing();
                        drawers[id].draw_func(reg, handle);
+                        ImGui::Spacing();
                        ImGui::TreePop();
                    }
                }
            }
        }

-        for (auto& id : component_to_delete)
+        for (auto& id : pending_deletion) {
            drawers[id].remove_func(reg, entity);
+            pending_deletion.clear();
+        }
    }
 }
--- a/imgui.ini
+++ b/imgui.ini
@@ -10,7 +10,7 @@ Collapsed=0

 [Window][Statistics]
 Pos=0,24
-Size=224,437
+Size=409,437
 Collapsed=0
 DockId=0x00000003,0

@@ -21,8 +21,8 @@ Collapsed=0
 DockId=0x00000007,0

 [Window][Viewport]
-Pos=226,61
-Size=594,956
+Pos=411,61
+Size=409,956
 Collapsed=0
 DockId=0x00000012,0

@@ -34,7 +34,7 @@ DockId=0x00000008,0

 [Window][Scene]
 Pos=0,463
-Size=224,924
+Size=409,924
 Collapsed=0
 DockId=0x00000004,0

@@ -143,8 +143,8 @@ Collapsed=0
 DockId=0x00000012,1

 [Window][Assets]
-Pos=226,1019
-Size=594,368
+Pos=411,1019
+Size=409,368
 Collapsed=0
 DockId=0x0000000C,0

@@ -155,29 +155,29 @@ Collapsed=0
 DockId=0x0000000F,0

 [Window][##play_state_bar]
-Pos=226,24
-Size=594,35
+Pos=411,24
+Size=409,35
 Collapsed=0
 DockId=0x00000011,0

 [Docking][Data]
 DockSpace               ID=0x08BD597D Window=0x1BBC0F80 Pos=0,24 Size=1272,1363 Split=X
  DockNode              ID=0x00000005 Parent=0x08BD597D SizeRef=820,1386 Split=X
-    DockNode            ID=0x00000001 Parent=0x00000005 SizeRef=224,1386 Split=Y Selected=0xE601B12F
+    DockNode            ID=0x00000001 Parent=0x00000005 SizeRef=409,1386 Split=Y Selected=0xE601B12F
      DockNode          ID=0x00000003 Parent=0x00000001 SizeRef=255,417 Selected=0x553E127E
      DockNode          ID=0x00000004 Parent=0x00000001 SizeRef=255,883 Selected=0xE601B12F
-    DockNode            ID=0x00000002 Parent=0x00000005 SizeRef=594,1386 Split=Y Selected=0xC450F867
+    DockNode            ID=0x00000002 Parent=0x00000005 SizeRef=409,1386 Split=Y Selected=0xC450F867
      DockNode          ID=0x00000009 Parent=0x00000002 SizeRef=483,784 Split=Y Selected=0xC450F867
        DockNode        ID=0x0000000B Parent=0x00000009 SizeRef=409,932 Split=X Selected=0xC450F867
          DockNode      ID=0x0000000D Parent=0x0000000B SizeRef=1080,993 Split=Y Selected=0xC450F867
            DockNode    ID=0x0000000F Parent=0x0000000D SizeRef=594,60 Selected=0x8325EBDA
            DockNode    ID=0x00000010 Parent=0x0000000D SizeRef=594,931 Split=Y Selected=0xC450F867
              DockNode  ID=0x00000011 Parent=0x00000010 SizeRef=594,35 HiddenTabBar=1 Selected=0xAB37695D
-              DockNode  ID=0x00000012 Parent=0x00000010 SizeRef=594,956 CentralNode=1 Selected=0xC450F867
+              DockNode  ID=0x00000012 Parent=0x00000010 SizeRef=594,964 CentralNode=1 Selected=0xC450F867
          DockNode      ID=0x0000000E Parent=0x0000000B SizeRef=800,993 Selected=0x3EEA4247
        DockNode        ID=0x0000000C Parent=0x00000009 SizeRef=409,368 Selected=0x42C24103
      DockNode          ID=0x0000000A Parent=0x00000002 SizeRef=483,600 Selected=0x1BCA3180
  DockNode              ID=0x00000006 Parent=0x08BD597D SizeRef=450,1386 Split=Y Selected=0x8C72BEA8
-    DockNode            ID=0x00000007 Parent=0x00000006 SizeRef=444,769 Selected=0x8C72BEA8
-    DockNode            ID=0x00000008 Parent=0x00000006 SizeRef=444,531 Selected=0x5E5F7166
+    DockNode            ID=0x00000007 Parent=0x00000006 SizeRef=444,805 Selected=0x8C72BEA8
+    DockNode            ID=0x00000008 Parent=0x00000006 SizeRef=444,556 Selected=0x5E5F7166

--- a/open_engine/CMakeLists.txt
+++ b/open_engine/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.28)
+cmake_minimum_required(VERSION 3.25.1)

 set(CMAKE_CXX_STANDARD 23)

@@ -14,6 +14,10 @@ find_package(imgui REQUIRED)
 find_package(EnTT REQUIRED)
 find_package(yaml-cpp REQUIRED)
 find_package(Jolt REQUIRED)
+find_package(fastgltf REQUIRED)
+find_package(spdlog REQUIRED)
+find_package(glm REQUIRED)
+find_package(glfw3 REQUIRED)

 file(GLOB_RECURSE SRC_FILES "src/*.cpp")
 file(GLOB IMGUIZMO_SRC_FILES "${CMAKE_SOURCE_DIR}/vendor/ImGuizmo/*.cpp")
@@ -34,20 +38,28 @@ target_include_directories(${PROJECT_EXECUTABLE_NAME} PRIVATE

 target_include_directories(${PROJECT_EXECUTABLE_NAME} PUBLIC
    "${CMAKE_CURRENT_SOURCE_DIR}/include"
-    "/home/erris/.conan2/p/b/imguic69fe98538919/p/include"
+    #"/home/erris/.conan2/p/b/imguic69fe98538919/p/include"
    "vendor/nativefiledialog-extended/src/include"
    "${CMAKE_SOURCE_DIR}/vendor/ImGuizmo"
 )

+file(GLOB DOTNET_NETHOST_PATH "/usr/share/dotnet/packs/Microsoft.NETCore.App.Host.*/*/runtimes/arch-x64/native")
+
+if(DOTNET_NETHOST_PATH)
+    target_include_directories(${PROJECT_EXECUTABLE_NAME} PUBLIC ${DOTNET_NETHOST_PATH})
+else()
+    message(WARNING "nethost.h path not found automatically!")
+endif()
+
 #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address -fno-omit-frame-pointer")
 #set(CMAKE_LINKER_FLAGS "${CMAKE_LINKER_FLAGS} -fsanitize=address")

 target_link_libraries(${PROJECT_EXECUTABLE_NAME} PUBLIC
    imgui::imgui
-    spdlog
+    spdlog::spdlog
    glad
    glfw
-    glm
+    glm::glm
    dl
    EnTT::EnTT
    X11
@@ -63,6 +75,7 @@ target_link_libraries(${PROJECT_EXECUTABLE_NAME} PUBLIC
    spirv-cross-glsl
    spirv-cross-reflect
    Jolt::Jolt
+    fastgltf::fastgltf
 )

 #target_link_directories(${PROJECT_EXECUTABLE_NAME} PRIVATE
@@ -74,3 +87,5 @@ add_subdirectory(vendor/glad
 )

 add_subdirectory("vendor/nativefiledialog-extended")
+
+target_compile_options(open_engine PRIVATE -msse4.1 -msse4.2 -mavx -mavx2)
--- a/open_engine/include/open_engine/core/uuid.hpp
+++ b/open_engine/include/open_engine/core/uuid.hpp
@@ -0,0 +1,36 @@
+#ifndef UUID_HPP
+#define UUID_HPP
+
+#include <cstdint>
+
+namespace OpenEngine {
+
+    class UUID
+    {
+        public:
+            UUID();
+            UUID(uint64_t uuid);
+            UUID(const UUID&) = default;
+
+            operator uint64_t() const { return uuid; };
+
+        private:
+            uint64_t uuid;
+    };
+
+}
+
+namespace std {
+
+    template<>
+        struct hash<OpenEngine::UUID>
+        {
+            std::size_t operator()(const OpenEngine::UUID& uuid) const
+            {
+                return hash<uint64_t>()((uint64_t)uuid);
+            }
+        };
+
+}
+
+#endif // UUID_HPP
--- a/open_engine/include/open_engine/fastgltf.hpp
+++ b/open_engine/include/open_engine/fastgltf.hpp
@@ -0,0 +1,13 @@
+#ifndef FASTGLTF_HPP
+#define FASTGLTF_HPP
+
+#include "renderer/renderer3d.hpp"
+#include "open_engine/ref_scope.hpp"
+
+namespace OpenEngine {
+
+    Ref<Mesh> TestGLTF();
+
+}
+
+#endif // FASTGLTF_HPP
--- a/open_engine/include/open_engine/gltf/gltf_model3d.hpp
+++ b/open_engine/include/open_engine/gltf/gltf_model3d.hpp
@@ -0,0 +1,38 @@
+#ifndef GLTF_MODEL3D_HPP
+#define GLTF_MODEL3D_HPP
+
+#include "open_engine/renderer/model3d.hpp"
+
+#include <fastgltf/types.hpp>
+#include <vector>
+#include <cstddef>
+
+namespace OpenEngine {
+
+    class GLTFModel3D : public Model3D
+    {
+        public:
+            GLTFModel3D(const char* path);
+
+            void loadPrimitive(fastgltf::Asset& asset,
+                    fastgltf::Primitive& primitive,
+                    Mesh& out);
+            virtual const Mesh& GetMesh(int index) const override;
+            virtual const std::vector<Mesh>& GetMeshes() const override;
+
+            virtual size_t GetMeshCount() const override { return meshes.size(); };
+
+            virtual std::vector<Mesh>::iterator begin() override { return meshes.begin(); };
+            virtual std::vector<Mesh>::iterator end() override { return meshes.end(); };
+
+            virtual std::vector<Mesh>::const_iterator begin() const override { return meshes.cbegin(); };
+            virtual std::vector<Mesh>::const_iterator end() const override { return meshes.end(); };
+
+        private:
+            std::string name;
+            std::vector<Mesh> meshes;
+    };
+
+}
+
+#endif // GLTF_MODEL3D_HPP
--- a/open_engine/include/open_engine/imgui/imgui_layer.hpp
+++ b/open_engine/include/open_engine/imgui/imgui_layer.hpp
@@ -19,6 +19,7 @@ namespace OpenEngine {
            bool CloseWindow(OpenEngine::KeyPressedEvent& event);

            void SetBlockEvents(bool block) { block_events = block; };
+            bool GetBlockEvents() { return block_events; };

            void Begin();
            void End();
--- a/open_engine/include/open_engine/input/input_system.hpp
+++ b/open_engine/include/open_engine/input/input_system.hpp
@@ -2,7 +2,6 @@
 #define INPUT_HPP

 #include "open_engine/input/mouse_codes.hpp"
-#include "open_engine/ref_scope.hpp"
 #include "open_engine/input/keycodes.hpp"

 #include <string>
--- a/open_engine/include/open_engine/instrumentor.hpp
+++ b/open_engine/include/open_engine/instrumentor.hpp
@@ -3,6 +3,7 @@

 #include "open_engine/logging.hpp"

+#include <iomanip>
 #include <mutex>
 #include <sstream>
 #include <string>
--- a/open_engine/include/open_engine/physics.hpp
+++ b/open_engine/include/open_engine/physics.hpp
@@ -0,0 +1,191 @@
+#ifndef PHYSICS_HPP
+#define PHYSICS_HPP
+
+#include "logging.hpp"
+
+#include <Jolt/Jolt.h>
+#include <Jolt/Physics/Body/BodyInterface.h>
+#include <Jolt/RegisterTypes.h>
+#include <Jolt/Core/Factory.h>
+#include <Jolt/Core/TempAllocator.h>
+#include <Jolt/Core/JobSystemThreadPool.h>
+#include <Jolt/Physics/PhysicsSettings.h>
+#include <Jolt/Physics/PhysicsSystem.h>
+#include <Jolt/Physics/Collision/Shape/BoxShape.h>
+#include <Jolt/Physics/Collision/Shape/SphereShape.h>
+#include <Jolt/Physics/Body/BodyCreationSettings.h>
+#include <Jolt/Physics/Body/BodyActivationListener.h>
+
+#include <cstdarg>
+#include <glm/glm.hpp>
+
+using namespace JPH;
+using namespace JPH::literals;
+
+// Callback for traces, connect this to your own trace function if you have one
+static void TraceImpl(const char *in_fmt, ...)
+{
+    // Format the message
+    va_list list;
+    va_start(list, in_fmt);
+    char buffer[1024];
+    vsnprintf(buffer, sizeof(buffer), in_fmt, list);
+    va_end(list);
+
+    OE_CORE_TRACE("Jolt: {}", buffer);
+}
+
+#ifdef JPH_ENABLE_ASSERTS
+// Callback for asserts, connect this to your own assert handler if you have one
+static bool AssertFailedImpl(const char *in_expression, const char *in_message, const char *in_file, uint in_line)
+{
+    OE_CORE_ERROR("Jolt: Assert in file: {}:{} :({}) {}", in_file, in_line, in_expression, (in_message != nullptr? in_message : ""));
+
+    // Breakpoint
+    return true;
+};
+#endif // JPH_ENABLE_ASSERTS
+
+// Layer that objects can be in, determines which other objects it can collide with
+// Typically you at least want to have 1 layer for moving bodies and 1 layer for static bodies, but you can have more
+// layers if you want. E.g. you could have a layer for high detail collision (which is not used by the physics simulation
+// but only if you do collision testing).
+namespace Layers {
+	static constexpr ObjectLayer NON_MOVING = 0;
+	static constexpr ObjectLayer MOVING = 1;
+	static constexpr ObjectLayer NUM_LAYERS = 2;
+};
+
+class ObjectLayerPairFilterImpl : public ObjectLayerPairFilter
+{
+    public:
+        virtual bool ShouldCollide(ObjectLayer object1, ObjectLayer object2) const override;
+};
+
+// Each broadphase layer results in a separate bounding volume tree in the broad phase. You at least want to have
+// a layer for non-moving and moving objects to avoid having to update a tree full of static objects every frame.
+// You can have a 1-on-1 mapping between object layers and broadphase layers (like in this case) but if you have
+// many object layers you'll be creating many broad phase trees, which is not efficient. If you want to fine tune
+// your broadphase layers define JPH_TRACK_BROADPHASE_STATS and look at the stats reported on the TTY.
+namespace BroadPhaseLayers
+{
+	static constexpr BroadPhaseLayer NON_MOVING(0);
+	static constexpr BroadPhaseLayer MOVING(1);
+	static constexpr uint NUM_LAYERS(2);
+};
+
+inline JPH::Vec3 ToJolt(const glm::vec3& v) { return JPH::Vec3(v.x, v.y, v.z); };
+
+class BPLayerInterfaceImpl final : public BroadPhaseLayerInterface
+{
+    public:
+        BPLayerInterfaceImpl()
+        {
+            object_to_broad_phase[Layers::NON_MOVING] = BroadPhaseLayers::NON_MOVING;
+            object_to_broad_phase[Layers::MOVING] = BroadPhaseLayers::MOVING;
+        }
+
+        virtual uint GetNumBroadPhaseLayers() const override { return BroadPhaseLayers::NUM_LAYERS; };
+
+        virtual BroadPhaseLayer GetBroadPhaseLayer(ObjectLayer layer) const override
+        {
+            JPH_ASSERT(layer < Layers::NUM_LAYERS);
+            return object_to_broad_phase[layer];
+        }
+
+    private:
+        BroadPhaseLayer	object_to_broad_phase[Layers::NUM_LAYERS];
+};
+
+class ObjectVsBroadPhaseLayerFilterImpl : public ObjectVsBroadPhaseLayerFilter
+{
+    public:
+        virtual bool ShouldCollide(ObjectLayer layer1, BroadPhaseLayer layer2) const override
+        {
+            switch (layer1)
+            {
+                case Layers::NON_MOVING:
+                    return layer2 == BroadPhaseLayers::MOVING;
+                case Layers::MOVING:
+                    return true;
+                default:
+                    JPH_ASSERT(false);
+                    return false;
+            }
+        }
+};
+
+// An example contact listener
+class MyContactListener : public ContactListener
+{
+public:
+	// See: ContactListener
+	virtual ValidateResult	OnContactValidate(const Body &inBody1, const Body &inBody2, RVec3Arg inBaseOffset, const CollideShapeResult &inCollisionResult) override
+	{
+		OE_CORE_TRACE("Jolt: Contact validate callback");
+
+		// Allows you to ignore a contact before it is created (using layers to not make objects collide is cheaper!)
+		return ValidateResult::AcceptAllContactsForThisBodyPair;
+	}
+
+	virtual void			OnContactAdded(const Body &inBody1, const Body &inBody2, const ContactManifold &inManifold, ContactSettings &ioSettings) override
+	{
+		OE_CORE_TRACE("Jolt: A contact was added");
+	}
+
+	virtual void			OnContactPersisted(const Body &inBody1, const Body &inBody2, const ContactManifold &inManifold, ContactSettings &ioSettings) override
+	{
+		OE_CORE_TRACE("Jolt: A contact was persisted");
+	}
+
+	virtual void			OnContactRemoved(const SubShapeIDPair &inSubShapePair) override
+	{
+		OE_CORE_TRACE("Jolt: A contact was removed");
+	}
+};
+
+// An example activation listener
+class MyBodyActivationListener : public BodyActivationListener
+{
+public:
+	virtual void		OnBodyActivated(const BodyID &inBodyID, uint64 inBodyUserData) override
+	{
+		OE_CORE_TRACE("Jolt: A body got activated");
+	}
+
+	virtual void		OnBodyDeactivated(const BodyID &inBodyID, uint64 inBodyUserData) override
+	{
+		OE_CORE_TRACE("Jolt: A body went to sleep");
+	}
+};
+
+namespace OpenEngine {
+
+    // Consider making this static like the renderer
+    class PhysicsEngine
+    {
+        public:
+            PhysicsEngine();
+            ~PhysicsEngine();
+
+            // TODO: Temp, make abstract function to create a body
+            BodyInterface& GetBodyInterface() { return physics_system.GetBodyInterface(); };
+            void Update( float delta_time, int collision_steps);
+
+        private:
+            PhysicsSystem physics_system;
+
+            Ref<TempAllocatorImpl> tmp_allocator;
+            Ref<JobSystemThreadPool> job_system;
+
+            MyBodyActivationListener body_activation_listener;
+            MyContactListener contact_listener;
+
+            BPLayerInterfaceImpl broad_phase_layer_interface;
+            ObjectVsBroadPhaseLayerFilterImpl object_vs_broadphase_layer_filter;
+            ObjectLayerPairFilterImpl object_vs_object_layer_filter;
+
+    };
+}
+
+#endif // PHYSICS_HPP
--- a/open_engine/include/open_engine/renderer/.nvim_session
+++ b/open_engine/include/open_engine/renderer/.nvim_session
@@ -1,220 +0,0 @@
-let SessionLoad = 1
-let s:so_save = &g:so | let s:siso_save = &g:siso | setg so=0 siso=0 | setl so=-1 siso=-1
-let v:this_session=expand("<sfile>:p")
-silent only
-silent tabonly
-cd ~/projects/open_engine/open_engine
-if expand('%') == '' && !&modified && line('$') <= 1 && getline(1) == ''
-  let s:wipebuf = bufnr('%')
-endif
-let s:shortmess_save = &shortmess
-if &shortmess =~ 'A'
-  set shortmess=aoOA
-else
-  set shortmess=aoO
-endif
-badd +1 ~/projects/open_engine/open_engine
-badd +170 ~/projects/open_engine/open_engine/src/open_engine/imgui/imgui_layer.cpp
-badd +4 ~/projects/open_engine/open_engine/include/open_engine/opengl/imgui_glfw.h
-badd +35 ~/projects/open_engine/open_engine/include/open_engine/opengl/imgui_opengl.h
-badd +23 ~/projects/open_engine/open_engine/src/open_engine/application.cpp
-badd +47 ~/projects/open_engine/open_engine/CMakeLists.txt
-badd +12 ~/projects/open_engine/open_engine/include/open_engine/imgui/imgui_layer.hpp
-badd +123 ~/projects/open_engine/open_engine/src/open_engine/opengl/imgui_opengl.cpp
-badd +89 ~/.conan2/p/b/imgui15e51a8fb5246/p/include/imgui.h
-badd +7 ~/projects/open_engine/open_engine/.envrc
-badd +5 ~/projects/open_engine/open_engine/include/open_engine/core.hpp
-badd +11 ~/.conan2/p/b/imgui15e51a8fb5246/p/include/imgui_export_headers.h
-badd +1 ~/projects/open_engine/open_engine/src/open_engine/opengl/build_opengl.cpp
-badd +4 ~/projects/open_engine/open_engine/src/open_engine/opengl/imgui_build.cpp
-badd +1 ~/projects/open_engine/open_engine/conanfile.txt
-badd +1 ~/projects/open_engine/open_engine/build/imguiTargets.cmake
-badd +8 ~/projects/open_engine/open_engine/include/open_engine/logging.hpp
-badd +4 ~/projects/open_engine/open_engine/src/open_engine/logging.cpp
-badd +110 ~/projects/open_engine/open_engine/src/open_engine/opengl/imgui_glfw.cpp
-badd +1 ~/projects/open_engine/open_engine/include/open_engine/application.hpp
-badd +21 ~/projects/open_engine/open_engine/src/open_engine/window/linux_window.cpp
-badd +24 ~/projects/open_engine/open_engine/include/open_engine/window/window.hpp
-badd +27 ~/projects/open_engine/open_engine/include/open_engine/window/linux_window.hpp
-badd +7 ~/projects/open_engine/open_engine/include/open_engine/renderer/GraphicsContext.hpp
-badd +12 ~/projects/open_engine/open_engine/include/open_engine/opengl/opengl_context.hpp
-badd +10 ~/projects/open_engine/open_engine/src/open_engine/input/linux_input.cpp
-badd +17 ~/projects/open_engine/open_engine/src/open_engine/opengl/opengl_context.cpp
-badd +3295 ~/projects/open_engine/open_engine/vendor/glad/include/glad/glad.h
-badd +148 ~/projects/open_engine/open_engine/vendor/glad/src/glad/glad.c
-badd +13 ~/projects/open_engine/open_engine/include/open_engine/renderer/graphics_context.hpp
-badd +80 ~/projects/open_engine/open_engine/src/open_engine/opengl/opengl_shader.cpp
-badd +8 ~/projects/open_engine/open_engine/include/open_engine/opengl/opengl_shader.hpp
-badd +8 ~/projects/open_engine/open_engine/include/open_engine/renderer/shader.hpp
-badd +1 ~/projects/open_engine/open_engine/src/open_engine/renderer/shader.cpp
-badd +1 ~/projects/open_engine/open_engine/include/open_engine/pch.hpp
-badd +3 ~/projects/open_engine/open_engine/assets/shaders/fragment.frag.old
-badd +1 ~/projects/open_engine/open_engine/assets/shaders/fragment.frag
-badd +5 ~/projects/open_engine/open_engine/assets/shaders/vertex.vert
-badd +1 ~/projects/open_engine/open_engine/\'
-badd +66 ~/projects/open_engine/open_engine/include/open_engine/renderer/buffer.hpp
-badd +56 ~/projects/open_engine/open_engine/src/open_engine/renderer/buffer.cpp
-badd +18 ~/projects/open_engine/open_engine/include/open_engine/opengl/opengl_buffer.hpp
-badd +34 ~/projects/open_engine/open_engine/src/open_engine/opengl/opengl_buffer.cpp
-badd +2 ~/projects/open_engine/open_engine/src/open_engine/renderer/renderer.cpp
-badd +5 ~/projects/open_engine/open_engine/include/open_engine/renderer/renderer.hpp
-badd +1 ~/projects/open_engine/open_engine/src/open_engine/layer.cpp
-badd +12 ~/projects/open_engine/open_engine/include/open_engine/layer.hpp
-badd +21 ~/projects/open_engine/open_engine/include/open_engine/events/event.hpp
-badd +11 ~/projects/open_engine/open_engine/src/open_engine/renderer/vertex_array.cpp
-badd +8 ~/projects/open_engine/open_engine/include/open_engine/renderer/vertex_array.hpp
-badd +27 ~/projects/open_engine/open_engine/src/open_engine/layer_stack.cpp
-badd +1 ~/projects/open_engine/open_engine/include/open_engine/layer_stack.hpp
-argglobal
-%argdel
-$argadd ~/projects/open_engine/open_engine
-set stal=2
-tabnew +setlocal\ bufhidden=wipe
-tabrewind
-edit ~/projects/open_engine/open_engine/include/open_engine/renderer/vertex_array.hpp
-let s:save_splitbelow = &splitbelow
-let s:save_splitright = &splitright
-set splitbelow splitright
-wincmd _ | wincmd |
-vsplit
-1wincmd h
-wincmd w
-let &splitbelow = s:save_splitbelow
-let &splitright = s:save_splitright
-wincmd t
-let s:save_winminheight = &winminheight
-let s:save_winminwidth = &winminwidth
-set winminheight=0
-set winheight=1
-set winminwidth=0
-set winwidth=1
-exe 'vert 1resize ' . ((&columns * 127 + 127) / 255)
-exe 'vert 2resize ' . ((&columns * 127 + 127) / 255)
-argglobal
-setlocal foldmethod=manual
-setlocal foldexpr=0
-setlocal foldmarker={{{,}}}
-setlocal foldignore=#
-setlocal foldlevel=0
-setlocal foldminlines=1
-setlocal foldnestmax=20
-setlocal foldenable
-silent! normal! zE
-let &fdl = &fdl
-let s:l = 8 - ((7 * winheight(0) + 13) / 27)
-if s:l < 1 | let s:l = 1 | endif
-keepjumps exe s:l
-normal! zt
-keepjumps 8
-normal! 0
-lcd ~/projects/open_engine/open_engine
-wincmd w
-argglobal
-if bufexists(fnamemodify("~/projects/open_engine/open_engine/include/open_engine/renderer/vertex_array.hpp", ":p")) | buffer ~/projects/open_engine/open_engine/include/open_engine/renderer/vertex_array.hpp | else | edit ~/projects/open_engine/open_engine/include/open_engine/renderer/vertex_array.hpp | endif
-if &buftype ==# 'terminal'
-  silent file ~/projects/open_engine/open_engine/include/open_engine/renderer/vertex_array.hpp
-endif
-setlocal foldmethod=manual
-setlocal foldexpr=0
-setlocal foldmarker={{{,}}}
-setlocal foldignore=#
-setlocal foldlevel=0
-setlocal foldminlines=1
-setlocal foldnestmax=20
-setlocal foldenable
-silent! normal! zE
-let &fdl = &fdl
-let s:l = 1 - ((0 * winheight(0) + 13) / 27)
-if s:l < 1 | let s:l = 1 | endif
-keepjumps exe s:l
-normal! zt
-keepjumps 1
-normal! 0
-lcd ~/projects/open_engine/open_engine
-wincmd w
-exe 'vert 1resize ' . ((&columns * 127 + 127) / 255)
-exe 'vert 2resize ' . ((&columns * 127 + 127) / 255)
-tabnext
-edit ~/projects/open_engine/open_engine/assets/shaders/fragment.frag
-let s:save_splitbelow = &splitbelow
-let s:save_splitright = &splitright
-set splitbelow splitright
-wincmd _ | wincmd |
-vsplit
-1wincmd h
-wincmd w
-let &splitbelow = s:save_splitbelow
-let &splitright = s:save_splitright
-wincmd t
-let s:save_winminheight = &winminheight
-let s:save_winminwidth = &winminwidth
-set winminheight=0
-set winheight=1
-set winminwidth=0
-set winwidth=1
-exe 'vert 1resize ' . ((&columns * 254 + 127) / 255)
-exe 'vert 2resize ' . ((&columns * 0 + 127) / 255)
-argglobal
-setlocal foldmethod=manual
-setlocal foldexpr=0
-setlocal foldmarker={{{,}}}
-setlocal foldignore=#
-setlocal foldlevel=0
-setlocal foldminlines=1
-setlocal foldnestmax=20
-setlocal foldenable
-silent! normal! zE
-let &fdl = &fdl
-let s:l = 11 - ((8 * winheight(0) + 13) / 27)
-if s:l < 1 | let s:l = 1 | endif
-keepjumps exe s:l
-normal! zt
-keepjumps 11
-normal! 020|
-lcd ~/projects/open_engine/open_engine
-wincmd w
-argglobal
-if bufexists(fnamemodify("~/projects/open_engine/open_engine/assets/shaders/vertex.vert", ":p")) | buffer ~/projects/open_engine/open_engine/assets/shaders/vertex.vert | else | edit ~/projects/open_engine/open_engine/assets/shaders/vertex.vert | endif
-if &buftype ==# 'terminal'
-  silent file ~/projects/open_engine/open_engine/assets/shaders/vertex.vert
-endif
-balt ~/projects/open_engine/open_engine/assets/shaders/fragment.frag
-setlocal foldmethod=manual
-setlocal foldexpr=0
-setlocal foldmarker={{{,}}}
-setlocal foldignore=#
-setlocal foldlevel=0
-setlocal foldminlines=1
-setlocal foldnestmax=20
-setlocal foldenable
-silent! normal! zE
-let &fdl = &fdl
-let s:l = 12 - ((11 * winheight(0) + 13) / 27)
-if s:l < 1 | let s:l = 1 | endif
-keepjumps exe s:l
-normal! zt
-keepjumps 12
-normal! 022|
-lcd ~/projects/open_engine/open_engine
-wincmd w
-exe 'vert 1resize ' . ((&columns * 254 + 127) / 255)
-exe 'vert 2resize ' . ((&columns * 0 + 127) / 255)
-tabnext 1
-set stal=1
-if exists('s:wipebuf') && len(win_findbuf(s:wipebuf)) == 0 && getbufvar(s:wipebuf, '&buftype') isnot# 'terminal'
-  silent exe 'bwipe ' . s:wipebuf
-endif
-unlet! s:wipebuf
-set winheight=1 winwidth=20
-let &shortmess = s:shortmess_save
-let &winminheight = s:save_winminheight
-let &winminwidth = s:save_winminwidth
-let s:sx = expand("<sfile>:p:r")."x.vim"
-if filereadable(s:sx)
-  exe "source " . fnameescape(s:sx)
-endif
-let &g:so = s:so_save | let &g:siso = s:siso_save
-set hlsearch
-doautoall SessionLoadPost
-unlet SessionLoad
-" vim: set ft=vim :
--- a/open_engine/include/open_engine/renderer/model3d.hpp
+++ b/open_engine/include/open_engine/renderer/model3d.hpp
@@ -0,0 +1,69 @@
+#ifndef MODEL3D_HPP
+#define MODEL3D_HPP
+
+#include "open_engine/core/uuid.hpp"
+#include "open_engine/renderer/vertex_array.hpp"
+#include <cstddef>
+#include <cstdint>
+#include <glm/glm.hpp>
+#include <vector>
+
+namespace OpenEngine {
+
+    struct Material
+    {
+        glm::vec4 albedo = { 1.0f, 0.0f, 0.8f, 1.0f };
+        float roughness = 1.0f;
+        float metallic = 1.0f;
+        float ambient_strength = 1.0f;
+        float specular_strength = 1.0f;
+        std::string name = "un-named material";
+    };
+
+    struct MeshVertex
+    {
+        glm::vec3 position;
+        glm::vec3 normal;
+        glm::vec2 text_coords;
+    };
+
+    struct Mesh
+    {
+        UUID uuid;
+
+        Material material;
+
+        Ref<VertexArray> vertex_array;
+        Ref<VertexBuffer> vertex_buffer;
+        Ref<IndexBuffer> index_buffer;
+
+        // TODO: Make them a ptr or something
+        std::vector<MeshVertex> vertices;
+        std::vector<uint32_t> indices;
+    };
+
+    // TODO: Model3D.Instanciate();
+    // Or Model3D.GetVertices() {return iterateaccessorwithindex bla bla bla}
+    // What data should Model3D hold in the end if it is not a renderable object?
+    class Model3D
+    {
+        public:
+            virtual ~Model3D() = default;
+
+            static Ref<Model3D> Create(const char* path);
+
+            virtual const Mesh& GetMesh(int index) const = 0;
+            virtual const std::vector<Mesh>& GetMeshes() const = 0;
+
+            virtual size_t GetMeshCount() const = 0;
+
+            virtual std::vector<Mesh>::iterator begin() = 0;
+            virtual std::vector<Mesh>::iterator end() = 0;
+
+            virtual std::vector<Mesh>::const_iterator begin() const = 0;
+            virtual std::vector<Mesh>::const_iterator end() const = 0;
+    };
+
+}
+
+#endif // MODEL3D_HPP
--- a/open_engine/include/open_engine/renderer/renderer3d.hpp
+++ b/open_engine/include/open_engine/renderer/renderer3d.hpp
@@ -2,38 +2,27 @@
 #define RENDERER3D_HPP

 #include "open_engine/renderer/editor_camera.hpp"
-#include "open_engine/renderer/vertex_array.hpp"
-#include "open_engine/renderer/buffer.hpp"
 #include "open_engine/scene/scene_camera.hpp"
+#include "open_engine/renderer/model3d.hpp"
 #include <cstdint>

 namespace OpenEngine {

    // SHOULD BE MOVED ==================================
-    struct MeshVertex
-    {
-        glm::vec3 position;
-        glm::vec4 color;
-        glm::vec3 normal;
-        glm::vec2 text_coords;
-        uint32_t id = -1;
-    };

-    struct Mesh
+    enum class PrimitiveType
    {
-        Ref<VertexArray> vertex_array;
-        Ref<VertexBuffer> vertex_buffer;
-        Ref<IndexBuffer> index_buffer;
-
-        // TODO: Make them a ptr or something
-        std::vector<MeshVertex> vertices;
-        std::vector<uint32_t> indices;
+        None = 0,
+        Quad,
+        Cube
    };

    Ref<Mesh> CreateMesh(const std::vector<MeshVertex>& vertices,
            const std::vector<uint32_t>& indices);
+    void PopulateMesh(Mesh& mesh);
    Ref<Mesh> CreateCube(uint32_t id = -1);
    Ref<Mesh> CreateQuad(uint32_t id = -1, bool back_face = false);
+
    // ==================================================

    class Renderer3D
@@ -46,7 +35,14 @@ namespace OpenEngine {
            static void BeginScene(const EditorCamera& camera);
            static void EndScene();

-            static void DrawMesh(const Ref<Mesh>& mesh, const glm::mat4& transform);
+            static void DrawMesh(const Ref<Mesh>& mesh, Material& material,
+                    const glm::mat4& transform);
+            static void DrawMesh(const Ref<Mesh>& mesh, Material& material,
+                    const glm::mat4& transform,
+                    uint32_t entity_id);
+            static void DrawModel(const Ref<Model3D>& model,
+                    const glm::mat4& transform,
+                    uint32_t entity_id);
    };
 }

--- a/open_engine/include/open_engine/renderer/uniform_buffer.hpp
+++ b/open_engine/include/open_engine/renderer/uniform_buffer.hpp
@@ -8,7 +8,7 @@ namespace OpenEngine {
    class UniformBuffer
    {
        public:
-            virtual ~UniformBuffer() {}
+            virtual ~UniformBuffer() = default;
            virtual void SetData(const void* data, uint32_t size,
                    uint32_t offset = 0) = 0;

--- a/open_engine/include/open_engine/scene/components.hpp
+++ b/open_engine/include/open_engine/scene/components.hpp
@@ -1,12 +1,21 @@
 #ifndef COMPONENTS_HPP
 #define COMPONENTS_HPP

-#include "open_engine/scene/native_scriptable_entity.hpp"
 #include "open_engine/renderer/renderer3d.hpp"
 #include "open_engine/scene/scene_camera.hpp"
 #include "open_engine/renderer/texture.hpp"
 #include "open_engine/renderer/renderer3d.hpp"
+#include "open_engine/physics.hpp"
+#include "open_engine/core/uuid.hpp"
+#include "open_engine/ref_scope.hpp"
+#include "open_engine/renderer/model3d.hpp"

+#include <Jolt/Physics/Body/BodyCreationSettings.h>
+#include <Jolt/Physics/Body/BodyInterface.h>
+#include <Jolt/Physics/Body/MotionType.h>
+#include <Jolt/Physics/Collision/ObjectLayer.h>
+#include <Jolt/Physics/Collision/Shape/Shape.h>
+#include <Jolt/Physics/EActivation.h>
 #include <glm/ext/matrix_transform.hpp>
 #include <glm/gtc/type_ptr.hpp>
 #include <glm/fwd.hpp>
@@ -21,6 +30,15 @@

 namespace OpenEngine {

+    struct IDComponent
+    {
+        UUID id;
+
+        IDComponent() = default;
+        IDComponent(const IDComponent&) = default;
+        IDComponent(const UUID& uuid) : id(uuid) {};
+    };
+
    struct TagComponent
    {
        std::string tag;
@@ -67,6 +85,8 @@ namespace OpenEngine {
        CameraComponent(const CameraComponent&) = default;
    };

+    class NativeScriptableEntity;
+
    struct NativeScriptComponent 
    {
        NativeScriptableEntity* instance = nullptr;
@@ -74,9 +94,6 @@ namespace OpenEngine {
        NativeScriptableEntity* (*InstanciateScript)();
        void (*DestroyInstanceScript)(NativeScriptComponent*);

-        void OnImGuiRender(Entity& entity) 
-        {};
-
        template <typename T>
            void Bind()
            {
@@ -86,19 +103,83 @@ namespace OpenEngine {
                    (delete nsc->instance);
                    nsc->instance = nullptr;
                };
-            }
+            };
    };

    struct MeshComponent
    {
        Ref<Mesh> mesh;
+        PrimitiveType primitive_type = PrimitiveType::None;
        
        MeshComponent() = default;
        MeshComponent(const MeshComponent&) = default;
        MeshComponent(const Ref<Mesh>& mesh)
-            : mesh(mesh) {}
+            : mesh(mesh) {};
    };

+    struct MaterialComponent
+    {
+        Material material;
+
+        MaterialComponent() = default;
+        MaterialComponent(const MaterialComponent&) = default;
+        MaterialComponent(const Material& material)
+            : material(material) {};
+    };
+
+    struct PhysicsBodyComponent
+    {
+        BodyID body;
+
+        float linear_damping = 0.05f;
+        float angular_damping = 0.05f;
+        float gravity_factor = 1.0f;
+        float restitution = 0.8f;
+        float friction = 0.5f;
+
+        int type = (int)EMotionType::Static;
+        int initial_activation_state = (int)EActivation::Activate;
+        int layer = (int)Layers::MOVING;
+
+        PhysicsBodyComponent() = default;
+        PhysicsBodyComponent(const PhysicsBodyComponent&) = default;
+    };
+
+    // TODO: Let's add more shapes
+    struct BoxShapeComponent
+    {
+        glm::vec3 size = { 1.0f, 1.0f, 1.0f };
+
+        BoxShapeComponent() = default;
+        BoxShapeComponent(const BoxShapeComponent&) = default;
+    };
+
+    struct SphereShapeComponent
+    {
+        float radius = 1.0f;
+
+        SphereShapeComponent() = default;
+        SphereShapeComponent(const SphereShapeComponent&) = default;
+    };
+
+    struct PlaneShapeComponent
+    {
+        float extent = 1.0f;
+
+        PlaneShapeComponent() = default;
+        PlaneShapeComponent(const PlaneShapeComponent&) = default;
+    };
+
+    struct ModelComponent
+    {
+        Ref<Model3D> model;
+
+        ModelComponent() = default;
+        ModelComponent(const ModelComponent&) = default;
+        ModelComponent(Ref<Model3D>& model)
+            : model(model)
+        {}
+    };
 }

 #endif // COMPONENTS_HPP
--- a/open_engine/include/open_engine/scene/entity.hpp
+++ b/open_engine/include/open_engine/scene/entity.hpp
@@ -3,6 +3,8 @@

 #include "open_engine/core.hpp"

+#include "open_engine/core/uuid.hpp"
+#include "open_engine/scene/components.hpp"
 #include "open_engine/scene/scene.hpp"

 #include <cstdint>
@@ -48,6 +50,8 @@ namespace OpenEngine {
                    return scene->registry.all_of<T>(handle);
                };

+            UUID GetUUID() { return GetComponents<IDComponent>().id; };
+
            operator bool() const { return handle != entt::null; };
            operator entt::entity() const { return handle; };
            operator uint32_t() const { return (uint32_t)handle; };
--- a/open_engine/include/open_engine/scene/native_scriptable_entity.hpp
+++ b/open_engine/include/open_engine/scene/native_scriptable_entity.hpp
@@ -1,6 +1,7 @@
 #ifndef NATIVE_SCRIPTABLE_ENTITY_HPP
 #define NATIVE_SCRIPTABLE_ENTITY_HPP

+#include "open_engine/scene/native_scriptable_entity.hpp"
 #include "open_engine/scene/entity.hpp"

 namespace OpenEngine {
--- a/open_engine/include/open_engine/scene/scene.hpp
+++ b/open_engine/include/open_engine/scene/scene.hpp
@@ -1,8 +1,11 @@
 #ifndef SCENE_HPP
 #define SCENE_HPP

+#include "open_engine/core/uuid.hpp"
 #include "open_engine/renderer/editor_camera.hpp"
+#include "open_engine/physics.hpp"

+#include <Jolt/Physics/Body/BodyInterface.h>
 #include <entt/entity/fwd.hpp>
 #include <entt/entt.hpp>
 #include <cstdint>
@@ -16,8 +19,13 @@ namespace OpenEngine {
        public:
            Scene() = default;
            ~Scene() = default;
+            Scene(Scene& other) {};
+
+            void OnRuntimeStart();
+            void OnRuntimeStop();

            Entity CreateEntity(const std::string& name = std::string());
+            Entity CreateEntityWithUUID(UUID uuid, const std::string& name = std::string());
            void DeleteEntity(entt::entity entity);
            void MarkEntityForDeletion(Entity entity);

@@ -28,19 +36,24 @@ namespace OpenEngine {
            void OnViewportResize(uint32_t width, uint32_t height);

            entt::registry& GetRegistry() { return registry; };
-
+            PhysicsEngine& GetPhysicsEngine() { return physics_engine; };
            Entity GetPrimaryCamera();

        private:
+            void OnUpdatePhysics();
+
            template<typename T>
                void OnComponentAdded(Entity entity, T& component);

        private:
            entt::registry registry;
+            PhysicsEngine physics_engine;
+
+            BodyInterface* body_interface;

            uint32_t viewport_width = 0, viewport_height = 0;

-            std::vector<entt::entity> entities_to_be_deleted;
+            std::vector<entt::entity> pending_deletion;

            friend class SceneSerializer;
            friend class Entity;
--- a/open_engine/src/open_engine/core/uuid.cpp
+++ b/open_engine/src/open_engine/core/uuid.cpp
@@ -0,0 +1,24 @@
+#include <cstdint>
+#include <pch.hpp>
+
+#include <core/uuid.hpp>
+
+#include <random>
+
+namespace OpenEngine {
+
+    static std::random_device s_random_device;
+    static std::mt19937_64 s_engine(s_random_device());
+    static std::uniform_int_distribution<uint64_t> s_uniform_distribution;
+
+    UUID::UUID()
+        : uuid(s_uniform_distribution(s_engine))
+    {
+    }
+
+    UUID::UUID(uint64_t uuid)
+        : uuid(uuid)
+    {
+    }
+
+}
--- a/open_engine/src/open_engine/fastgltf.cpp
+++ b/open_engine/src/open_engine/fastgltf.cpp
@@ -0,0 +1,86 @@
+#include <pch.hpp>
+
+#include "logging.hpp"
+#include <fastgltf.hpp>
+#include "ref_scope.hpp"
+
+#include <cstddef>
+#include <cstdint>
+#include <glm/fwd.hpp>
+#include <fastgltf/core.hpp>
+#include <fastgltf/types.hpp>
+#include <fastgltf/tools.hpp>
+#include <fastgltf/glm_element_traits.hpp>
+
+#include <vector>
+
+namespace OpenEngine {
+
+    void loadPrimitive(fastgltf::Asset& asset,
+            fastgltf::Primitive& primitive,
+            Mesh& out)
+    {
+        if (primitive.indicesAccessor.has_value()) {
+            auto& accessor = asset.accessors[primitive.indicesAccessor.value()];
+            out.indices.resize(accessor.count);
+
+            fastgltf::iterateAccessorWithIndex<uint32_t>(asset, accessor,
+                    [&](uint32_t index, size_t i) {
+                        out.indices[i] = index;
+                    });
+        }
+
+        {
+            auto* position_iterator = primitive.findAttribute("POSITION");
+            auto& accessor = asset.accessors[position_iterator->accessorIndex];
+            out.vertices.resize(accessor.count);
+            
+            fastgltf::iterateAccessorWithIndex<glm::vec3>(asset, accessor,
+                    [&](glm::vec3 pos, size_t i) {
+                        out.vertices[i].position = pos;
+                    });
+        }
+
+        if (auto* normal_iterator = primitive.findAttribute("NORMAL");
+                normal_iterator != primitive.attributes.end()) {
+            auto& accessor = asset.accessors[normal_iterator->accessorIndex];
+
+            fastgltf::iterateAccessorWithIndex<glm::vec3>(asset, accessor,
+                    [&](glm::vec3 norm, size_t i) {
+                        out.vertices[i].normal = norm;
+                    });
+        }
+
+        {
+            if (primitive.materialIndex.has_value()) {
+                auto& material = asset.materials[primitive.materialIndex.value()];
+                auto& pbr = material.pbrData;
+
+                auto& c = pbr.baseColorFactor;
+            }
+        }
+    }
+
+    Ref<Mesh> TestGLTF()
+    {
+        fastgltf::Parser parser;
+        Ref<Mesh> new_mesh = CreateRef<Mesh>();
+
+        auto data = fastgltf::GltfDataBuffer::FromPath("assets/models/cube.glb");
+        if (data.error() != fastgltf::Error::None)
+            OE_CORE_ERROR("Could not parse model");
+
+        auto asset = parser.loadGltfBinary(data.get(), ".",
+                fastgltf::Options::LoadExternalBuffers
+                );
+        if (asset.error() != fastgltf::Error::None)
+            OE_CORE_ERROR("Could not optain asset");
+
+        for (auto& mesh : asset->meshes)
+            for (auto& primitive : mesh.primitives)
+                loadPrimitive(asset.get(), primitive, *new_mesh);
+
+        return new_mesh;
+    }
+
+}
--- a/open_engine/src/open_engine/gltf/gltf_model3d.cpp
+++ b/open_engine/src/open_engine/gltf/gltf_model3d.cpp
@@ -0,0 +1,137 @@
+#include "logging.hpp"
+#include <pch.hpp>
+
+#include <gltf/gltf_model3d.hpp>
+
+#include <fastgltf/core.hpp>
+#include <fastgltf/types.hpp>
+#include <fastgltf/tools.hpp>
+#include <fastgltf/glm_element_traits.hpp>
+
+namespace OpenEngine {
+
+    void PopulateMesh(Mesh& mesh)
+    {
+        mesh.vertex_array = VertexArray::Create();
+
+        mesh.vertex_buffer = VertexBuffer::Create(mesh.vertices.size() * sizeof(MeshVertex));
+        mesh.vertex_buffer->SetData(mesh.vertices.data(), mesh.vertices.size() * sizeof(MeshVertex));
+
+        BufferLayout layout = {
+            { ShaderDataType::Float3, "a_Position" },
+            { ShaderDataType::Float3, "a_Normal" },
+            { ShaderDataType::Float2, "a_TexCoord" }
+        };
+
+        mesh.vertex_buffer->SetLayout(layout);
+        mesh.vertex_array->AddVertexBuffer(mesh.vertex_buffer);
+
+        mesh.index_buffer = IndexBuffer::Create(mesh.indices.data(), mesh.indices.size());
+        mesh.vertex_array->SetIndexBuffer(mesh.index_buffer);
+    }
+
+    Ref<Mesh> CreateMesh(const std::vector<MeshVertex>& vertices,
+            const std::vector<uint32_t>& indices)
+    {
+        Ref<Mesh> mesh = CreateRef<Mesh>();
+
+        mesh->vertices = vertices;
+        mesh->indices = indices;
+
+        PopulateMesh(*mesh);
+
+        return mesh;
+    }
+
+    void GLTFModel3D::loadPrimitive(fastgltf::Asset& asset,
+            fastgltf::Primitive& primitive,
+            Mesh& out)
+    {
+        if (primitive.indicesAccessor.has_value()) {
+            auto& accessor = asset.accessors[primitive.indicesAccessor.value()];
+            out.indices.resize(accessor.count);
+
+            fastgltf::iterateAccessorWithIndex<uint32_t>(asset, accessor,
+                    [&](uint32_t index, size_t i) {
+                    out.indices[i] = index;
+                    });
+        }
+
+        {
+            auto* position_iterator = primitive.findAttribute("POSITION");
+            auto& accessor = asset.accessors[position_iterator->accessorIndex];
+            out.vertices.resize(accessor.count);
+
+            fastgltf::iterateAccessorWithIndex<glm::vec3>(asset, accessor,
+                    [&](glm::vec3 pos, size_t i) {
+                    out.vertices[i].position = pos;
+                    });
+        }
+
+        if (auto* normal_iterator = primitive.findAttribute("NORMAL");
+                normal_iterator != primitive.attributes.end()) {
+            auto& accessor = asset.accessors[normal_iterator->accessorIndex];
+
+            fastgltf::iterateAccessorWithIndex<glm::vec3>(asset, accessor,
+                    [&](glm::vec3 norm, size_t i) {
+                    out.vertices[i].normal = norm;
+                    });
+        }
+
+        {
+            if (primitive.materialIndex.has_value()) {
+                auto& material = asset.materials[primitive.materialIndex.value()];
+                auto& pbr = material.pbrData;
+
+                auto& color = pbr.baseColorFactor;
+                auto& roughness = pbr.roughnessFactor;
+                auto& metallic = pbr.metallicFactor;
+
+                out.material.name = material.name;
+                out.material.albedo = glm::vec4(color[0], color[1], color[2], color[3]);
+                out.material.roughness = roughness;
+                out.material.metallic = metallic;
+            }
+        }
+    }
+
+    GLTFModel3D::GLTFModel3D(const char* path)
+    {
+        fastgltf::Parser parser;
+
+        auto data = fastgltf::GltfDataBuffer::FromPath(path);
+        if (data.error() != fastgltf::Error::None)
+            OE_CORE_ERROR("Could not parse model");
+
+        auto asset = parser.loadGltfBinary(data.get(), ".",
+                fastgltf::Options::LoadExternalBuffers
+                );
+        if (asset.error() != fastgltf::Error::None)
+            OE_CORE_ERROR("Could not optain asset");
+
+
+        for (auto& mesh : asset->meshes) {
+            name = mesh.name;
+
+            for (auto& primitive : mesh.primitives) {
+                Mesh prim_mesh;
+
+                loadPrimitive(asset.get(), primitive, prim_mesh);
+                PopulateMesh(prim_mesh);
+
+                meshes.emplace_back(prim_mesh);
+            }
+        }
+    };
+
+    const Mesh& GLTFModel3D::GetMesh(int index) const
+    {
+        return meshes[index];
+    }
+
+    const std::vector<Mesh>& GLTFModel3D::GetMeshes() const
+    {
+        return meshes;
+    }
+
+}
--- a/open_engine/src/open_engine/physics.cpp
+++ b/open_engine/src/open_engine/physics.cpp
@@ -0,0 +1,73 @@
+#include <pch.hpp>
+
+#include <ref_scope.hpp>
+#include <physics.hpp>
+
+#include <Jolt/Physics/Body/BodyInterface.h>
+#include <Jolt/Core/JobSystemThreadPool.h>
+#include <Jolt/Core/Memory.h>
+#include <Jolt/Physics/PhysicsSystem.h>
+#include <Jolt/Physics/PhysicsUpdateContext.h>
+
+bool ObjectLayerPairFilterImpl::ShouldCollide(ObjectLayer object1, ObjectLayer object2) const
+{
+    switch (object1)
+    {
+        case Layers::NON_MOVING:
+            return object2 == Layers::MOVING; // Non moving only collides with moving
+        case Layers::MOVING:
+            return true; // Moving collides with everything
+        default:
+            JPH_ASSERT(false);
+            return false;
+    }
+}
+
+namespace OpenEngine {
+
+    PhysicsEngine::PhysicsEngine()
+    {
+        RegisterDefaultAllocator();
+
+        Trace = TraceImpl;
+        JPH_IF_ENABLE_ASSERTS(AssertFailed = AssertFailedImpl);
+
+        Factory::sInstance = new Factory();
+
+        RegisterTypes();
+
+        tmp_allocator = CreateRef<TempAllocatorImpl>(10 * 1024 * 1024);
+
+        job_system = CreateRef<JobSystemThreadPool>(cMaxPhysicsJobs,
+                cMaxPhysicsBarriers,
+                thread::hardware_concurrency() - 1);
+
+        physics_system.Init(
+                1024,
+                0,
+                1024,
+                1024,
+                broad_phase_layer_interface,
+                object_vs_broadphase_layer_filter,
+                object_vs_object_layer_filter);
+
+        //physics_system.SetBodyActivationListener(&body_activation_listener);
+        //physics_system.SetContactListener(&contact_listener);
+
+        // TODO: Check the comment on Jolt's example
+        physics_system.OptimizeBroadPhase();
+    }
+
+    PhysicsEngine::~PhysicsEngine() {
+        UnregisterTypes();
+
+        // Destroy the factory
+        delete Factory::sInstance;
+        Factory::sInstance = nullptr;
+    };
+
+    void PhysicsEngine::Update(float delta_time, int collision_steps)
+    {
+        physics_system.Update(delta_time, collision_steps, &*tmp_allocator, &*job_system);
+    }
+}
--- a/open_engine/src/open_engine/renderer/model3d.cpp
+++ b/open_engine/src/open_engine/renderer/model3d.cpp
@@ -0,0 +1,19 @@
+#include <pch.hpp>
+
+#include <renderer/model3d.hpp>
+
+#include <gltf/gltf_model3d.hpp>
+#include <instrumentor.hpp>
+#include <ref_scope.hpp>
+
+
+namespace OpenEngine {
+
+    Ref<Model3D> Model3D::Create(const char* path)
+    {
+        OE_PROFILE_FUNCTION();
+
+        return CreateRef<GLTFModel3D>(path);
+    }
+
+}
--- a/open_engine/src/open_engine/renderer/renderer3d.cpp
+++ b/open_engine/src/open_engine/renderer/renderer3d.cpp
@@ -23,33 +23,6 @@
 namespace OpenEngine {

    // SHOULD BE MOVED ==================================
-    Ref<Mesh> CreateMesh(const std::vector<MeshVertex>& vertices,
-            const std::vector<uint32_t>& indices)
-    {
-        Ref<Mesh> mesh = CreateRef<Mesh>();
-        mesh->vertices = vertices;
-        mesh->indices = indices;
-
-        mesh->vertex_array = VertexArray::Create();
-
-        mesh->vertex_buffer = VertexBuffer::Create(vertices.size() * sizeof(MeshVertex));
-        mesh->vertex_buffer->SetData(vertices.data(), vertices.size() * sizeof(MeshVertex));
-
-        BufferLayout layout = {
-            { ShaderDataType::Float3, "a_Position" },
-            { ShaderDataType::Float4, "a_Color" },
-            { ShaderDataType::Float3, "a_Normal" },
-            { ShaderDataType::Float2, "a_TexCoord" },
-            { ShaderDataType::Int, "a_EntityID"}
-        };
-        mesh->vertex_buffer->SetLayout(layout);
-        mesh->vertex_array->AddVertexBuffer(mesh->vertex_buffer);
-
-        mesh->index_buffer = IndexBuffer::Create(indices.data(), indices.size());
-        mesh->vertex_array->SetIndexBuffer(mesh->index_buffer);
-
-        return mesh;
-    }

    Ref<Mesh> CreateQuad(uint32_t id, bool back_face)
    {
@@ -61,16 +34,16 @@ namespace OpenEngine {
        if (back_face) {
            vertices = {
                // Front face (normal 0, 0, 1)
-                {{-0.5f, -0.5f,  0.0f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,1}, {0,0}, id},
-                {{-0.5f,  0.5f,  0.0f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,1}, {0,1}, id},
-                {{ 0.5f,  0.5f,  0.0f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,1}, {1,1}, id},
-                {{ 0.5f, -0.5f,  0.0f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,1}, {1,0}, id},
+                {{-0.5f, -0.5f,  0.0f}, {0,0,1}, {0,0}},
+                {{-0.5f,  0.5f,  0.0f}, {0,0,1}, {0,1}},
+                {{ 0.5f,  0.5f,  0.0f}, {0,0,1}, {1,1}},
+                {{ 0.5f, -0.5f,  0.0f}, {0,0,1}, {1,0}},

                // Back face (normal 0, 0, -1)
-                {{-0.5f, -0.5f, -0.0f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,-1}, {0,0}, id},
-                {{-0.5f,  0.5f, -0.0f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,-1}, {0,1}, id},
-                {{ 0.5f,  0.5f, -0.0f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,-1}, {1,1}, id},
-                {{ 0.5f, -0.5f, -0.0f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,-1}, {1,0}, id}
+                {{-0.5f, -0.5f, -0.0f}, {0,0,-1}, {0,0}},
+                {{-0.5f,  0.5f, -0.0f}, {0,0,-1}, {0,1}},
+                {{ 0.5f,  0.5f, -0.0f}, {0,0,-1}, {1,1}},
+                {{ 0.5f, -0.5f, -0.0f}, {0,0,-1}, {1,0}}
            };

            indices = {
@@ -82,10 +55,10 @@ namespace OpenEngine {
        } else {
            vertices = {
                // Front face (normal 0, 0, 1)
-                {{-0.5f, -0.5f,  0.0f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,1}, {0,0}, id},
-                {{-0.5f,  0.5f,  0.0f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,1}, {0,1}, id},
-                {{ 0.5f,  0.5f,  0.0f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,1}, {1,1}, id},
-                {{ 0.5f, -0.5f,  0.0f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,1}, {1,0}, id}
+                {{-0.5f, -0.5f,  0.0f}, {0,0,1}, {0,0}},
+                {{-0.5f,  0.5f,  0.0f}, {0,0,1}, {0,1}},
+                {{ 0.5f,  0.5f,  0.0f}, {0,0,1}, {1,1}},
+                {{ 0.5f, -0.5f,  0.0f}, {0,0,1}, {1,0}}
            };

            indices = {
@@ -103,40 +76,40 @@ namespace OpenEngine {
        OE_CORE_DEBUG("Creating cube with id {}.", id);
        std::vector<MeshVertex> vertices = {
            // Front face (normal 0, 0, 1)
-            {{-0.5f, -0.5f,  0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,1}, {0,0}, id},
-            {{-0.5f,  0.5f,  0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,1}, {0,1}, id},
-            {{ 0.5f,  0.5f,  0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,1}, {1,1}, id},
-            {{ 0.5f, -0.5f,  0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,1}, {1,0}, id},
+            {{-0.5f, -0.5f,  0.5f}, {0,0,1}, {0,0}},
+            {{-0.5f,  0.5f,  0.5f}, {0,0,1}, {0,1}},
+            {{ 0.5f,  0.5f,  0.5f}, {0,0,1}, {1,1}},
+            {{ 0.5f, -0.5f,  0.5f}, {0,0,1}, {1,0}},

            // Back face (normal 0, 0, -1)
-            {{-0.5f, -0.5f, -0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,-1}, {0,0}, id},
-            {{-0.5f,  0.5f, -0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,-1}, {0,1}, id},
-            {{ 0.5f,  0.5f, -0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,-1}, {1,1}, id},
-            {{ 0.5f, -0.5f, -0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,0,-1}, {1,0}, id},
+            {{-0.5f, -0.5f, -0.5f}, {0,0,-1}, {0,0}},
+            {{-0.5f,  0.5f, -0.5f}, {0,0,-1}, {0,1}},
+            {{ 0.5f,  0.5f, -0.5f}, {0,0,-1}, {1,1}},
+            {{ 0.5f, -0.5f, -0.5f}, {0,0,-1}, {1,0}},

            // Left face (normal -1, 0, 0)
-            {{-0.5f, -0.5f, -0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {-1,0,0}, {0,0}, id},
-            {{-0.5f,  0.5f, -0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {-1,0,0}, {0,1}, id},
-            {{-0.5f,  0.5f,  0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {-1,0,0}, {1,1}, id},
-            {{-0.5f, -0.5f,  0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {-1,0,0}, {1,0}, id},
+            {{-0.5f, -0.5f, -0.5f}, {-1,0,0}, {0,0}},
+            {{-0.5f,  0.5f, -0.5f}, {-1,0,0}, {0,1}},
+            {{-0.5f,  0.5f,  0.5f}, {-1,0,0}, {1,1}},
+            {{-0.5f, -0.5f,  0.5f}, {-1,0,0}, {1,0}},

            // Right face (normal 1, 0, 0)
-            {{ 0.5f, -0.5f, -0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {1,0,0}, {0,0}, id},
-            {{ 0.5f,  0.5f, -0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {1,0,0}, {0,1}, id},
-            {{ 0.5f,  0.5f,  0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {1,0,0}, {1,1}, id},
-            {{ 0.5f, -0.5f,  0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {1,0,0}, {1,0}, id},
+            {{ 0.5f, -0.5f, -0.5f}, {1,0,0}, {0,0}},
+            {{ 0.5f,  0.5f, -0.5f}, {1,0,0}, {0,1}},
+            {{ 0.5f,  0.5f,  0.5f}, {1,0,0}, {1,1}},
+            {{ 0.5f, -0.5f,  0.5f}, {1,0,0}, {1,0}},

            // Top face (normal 0, 1, 0)
-            {{-0.5f,  0.5f, -0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,1,0}, {0,0}, id},
-            {{-0.5f,  0.5f,  0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,1,0}, {0,1}, id},
-            {{ 0.5f,  0.5f,  0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,1,0}, {1,1}, id},
-            {{ 0.5f,  0.5f, -0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,1,0}, {1,0}, id},
+            {{-0.5f,  0.5f, -0.5f}, {0,1,0}, {0,0}},
+            {{-0.5f,  0.5f,  0.5f}, {0,1,0}, {0,1}},
+            {{ 0.5f,  0.5f,  0.5f}, {0,1,0}, {1,1}},
+            {{ 0.5f,  0.5f, -0.5f}, {0,1,0}, {1,0}},

            // Bottom face (normal 0, -1, 0)
-            {{-0.5f, -0.5f, -0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,-1,0}, {0,0}, id},
-            {{-0.5f, -0.5f,  0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,-1,0}, {0,1}, id},
-            {{ 0.5f, -0.5f,  0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,-1,0}, {1,1}, id},
-            {{ 0.5f, -0.5f, -0.5f}, { 0.5f, 0.5f, 0.5f, 1 }, {0,-1,0}, {1,0}, id},
+            {{-0.5f, -0.5f, -0.5f}, {0,-1,0}, {0,0}},
+            {{-0.5f, -0.5f,  0.5f}, {0,-1,0}, {0,1}},
+            {{ 0.5f, -0.5f,  0.5f}, {0,-1,0}, {1,1}},
+            {{ 0.5f, -0.5f, -0.5f}, {0,-1,0}, {1,0}},
        };

        std::vector<uint32_t> indices = {
@@ -176,6 +149,11 @@ namespace OpenEngine {
        };
        TransformData transform_buffer;
        Ref<UniformBuffer> transform_uniform_buffer;
+
+        Material material_buffer;
+        Ref<UniformBuffer> material_uniform_buffer;
+
+        Ref<UniformBuffer> id_uniform_buffer;
    };

    static Renderer3DData renderer_data;
@@ -190,6 +168,8 @@ namespace OpenEngine {
        renderer_data.color_shader_3d = Shader::Create("assets/shaders/color3d.glsl");
        renderer_data.camera_uniform_buffer = UniformBuffer::Create(sizeof(Renderer3DData::CameraData), 0);
        renderer_data.transform_uniform_buffer = UniformBuffer::Create(sizeof(Renderer3DData::TransformData), 1);
+        renderer_data.material_uniform_buffer = UniformBuffer::Create(sizeof(Material), 2);
+        renderer_data.id_uniform_buffer = UniformBuffer::Create(sizeof(uint32_t), 3);

        glEnable(GL_DEBUG_OUTPUT);
        glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
@@ -201,8 +181,11 @@ namespace OpenEngine {
    
    void Renderer3D::Shutdown()
    {
-        renderer_data.camera_uniform_buffer.reset();
        renderer_data.color_shader_3d.reset();
+        renderer_data.camera_uniform_buffer.reset();
+        renderer_data.transform_uniform_buffer.reset();
+        renderer_data.material_uniform_buffer.reset();
+        renderer_data.id_uniform_buffer.reset();
    }
    
    void Renderer3D::BeginScene(const SceneCamera& camera, const glm::mat4& transform)
@@ -230,7 +213,8 @@ namespace OpenEngine {

    }

-    void Renderer3D::DrawMesh(const Ref<Mesh>& mesh, const glm::mat4& transform)
+    void Renderer3D::DrawMesh(const Ref<Mesh>& mesh, Material& material,
+            const glm::mat4& transform)
    {
        OE_PROFILE_FUNCTION();

@@ -239,8 +223,55 @@ namespace OpenEngine {
        renderer_data.transform_buffer.transform = transform;
        renderer_data.transform_uniform_buffer->SetData(&renderer_data.transform_buffer, sizeof(Renderer3DData::TransformData));

+        renderer_data.material_buffer = material;
+        renderer_data.material_uniform_buffer->SetData(&renderer_data.material_buffer, sizeof(Material));
+
        mesh->vertex_array->Bind();

        RenderCommand::DrawIndexed(mesh->vertex_array, mesh->indices.size());
    }
+
+    void Renderer3D::DrawMesh(const Ref<Mesh>& mesh, Material& material,
+            const glm::mat4& transform,
+            uint32_t entity_id)
+    {
+        OE_PROFILE_FUNCTION();
+
+        renderer_data.color_shader_3d->Bind();
+
+        renderer_data.transform_buffer.transform = transform;
+        renderer_data.transform_uniform_buffer->SetData(&renderer_data.transform_buffer, sizeof(Renderer3DData::TransformData));
+
+        renderer_data.material_buffer = material;
+        renderer_data.material_uniform_buffer->SetData(&renderer_data.material_buffer, sizeof(Material));
+
+        renderer_data.id_uniform_buffer->SetData(&entity_id, sizeof(uint32_t));
+
+        mesh->vertex_array->Bind();
+
+        RenderCommand::DrawIndexed(mesh->vertex_array, mesh->indices.size());
+    }
+
+    void Renderer3D::DrawModel(const Ref<Model3D>& model,
+            const glm::mat4& transform,
+            uint32_t entity_id)
+    {
+        OE_PROFILE_FUNCTION();
+
+        renderer_data.color_shader_3d->Bind();
+
+        renderer_data.transform_buffer.transform = transform;
+        renderer_data.transform_uniform_buffer->SetData(&renderer_data.transform_buffer, sizeof(Renderer3DData::TransformData));
+
+        for (auto& mesh : *model) {
+            renderer_data.material_buffer = mesh.material;
+            renderer_data.material_uniform_buffer->SetData(&renderer_data.material_buffer, sizeof(Material));
+
+            renderer_data.id_uniform_buffer->SetData(&entity_id, sizeof(uint32_t));
+
+            mesh.vertex_array->Bind();
+
+            RenderCommand::DrawIndexed(mesh.vertex_array, mesh.indices.size());
+        }
+    }
 }
--- a/open_engine/src/open_engine/scene/scene.cpp
+++ b/open_engine/src/open_engine/scene/scene.cpp
@@ -1,18 +1,120 @@
-#include <cstdint>
-#include <entt/entity/fwd.hpp>
+#include "logging.hpp"
+#include "physics.hpp"
+#include "ref_scope.hpp"
+#include "renderer/model3d.hpp"
+#include <Jolt/Physics/Body/MotionType.h>
+#include <Jolt/Physics/Collision/ObjectLayer.h>
+#include <Jolt/Physics/Collision/Shape/ConvexShape.h>
 #include <pch.hpp>

 #include <renderer/renderer3d.hpp>
 #include <scene/components.hpp>
+#include <open_engine/scene/native_scriptable_entity.hpp>
 #include <scene/entity.hpp>
 #include <scene/scene.hpp>
+#include <core/time.hpp>
+
+#include <Jolt/Physics/Collision/Shape/Shape.h>
+#include <Jolt/Physics/Collision/Shape/PlaneShape.h>
+#include <Jolt/Physics/Collision/Shape/BoxShape.h>
+#include <Jolt/Physics/Collision/Shape/SphereShape.h>
+#include <Jolt/Physics/EActivation.h>
+#include <Jolt/Math/Real.h>
+#include <Jolt/Math/Quat.h>
+#include <cstdint>
+#include <entt/entity/fwd.hpp>

 namespace OpenEngine {

+    static Ref<ShapeSettings> CreateShape(entt::registry& reg, entt::entity e)
+    {
+        if (reg.any_of<BoxShapeComponent>(e)) {
+            auto& c = reg.get<BoxShapeComponent>(e);
+            return CreateRef<BoxShapeSettings>(ToJolt(c.size * 0.5f));
+        }
+        if (reg.any_of<SphereShapeComponent>(e)) {
+            auto& c = reg.get<SphereShapeComponent>(e);
+            return CreateRef<SphereShapeSettings>(c.radius);
+        }
+        if (reg.any_of<PlaneShapeComponent>(e)) {
+            auto& c = reg.get<PlaneShapeComponent>(e);
+            const Plane plane({ 0.0f, 1.0f, 0.0f }, 0);
+            return CreateRef<PlaneShapeSettings>(plane, nullptr, c.extent);
+        }
+
+        OE_CORE_ERROR("Entity {} has no shape component!", reg.get<TagComponent>(e).tag);
+        return nullptr;
+    };
+
+    void Scene::OnRuntimeStart()
+    {
+        body_interface = &physics_engine.GetBodyInterface();
+        // TODO: Cleanup components aquisition
+        auto view = registry.view<TransformComponent, PhysicsBodyComponent>();
+        for (auto e : view) {
+            Entity entity = { e, this };
+            
+            auto shape_settings = CreateShape(registry, e);
+            if (!shape_settings)
+                shape_settings = CreateRef<BoxShapeSettings>(Vec3(0.5f, 0.5f, 0.5f));
+
+            auto shape_result = shape_settings->Create();
+            if (shape_result.HasError()) {
+                OE_CORE_ERROR("Shape creation failed: {}", shape_result.GetError().c_str());
+                continue;
+            }
+            ShapeRefC shape = shape_result.Get();
+
+            auto& pbc = entity.GetComponents<PhysicsBodyComponent>();
+            auto& tc = entity.GetComponents<TransformComponent>();
+            
+            glm::vec3& pos = tc.translation;
+            glm::vec3& scale = tc.scale;
+            glm::vec3& rot = tc.rotation;
+
+            Quat quat = Quat::sEulerAngles(Vec3(rot.x, rot.y, rot.z));
+            BodyCreationSettings settings(
+                    shape,
+                    //new BoxShape(Vec3(scale.x * 0.5, scale.y * 0.5f, scale.z * 0.5f)),
+                    Vec3(pos.x, pos.y, pos.z),
+                    quat,
+                    (EMotionType)pbc.type,
+                    pbc.layer);
+
+            settings.mLinearDamping = pbc.linear_damping;
+            settings.mAngularDamping = pbc.angular_damping;
+            settings.mGravityFactor = pbc.gravity_factor;
+            settings.mRestitution = pbc.restitution;
+            settings.mFriction = pbc.friction;
+            settings.mObjectLayer = (ObjectLayer)pbc.layer;
+
+            pbc.body = body_interface->CreateAndAddBody(settings, (EActivation)pbc.initial_activation_state);
+        }
+    }
+
+    void Scene::OnRuntimeStop()
+    {
+        auto view = registry.view<PhysicsBodyComponent>();
+        for (auto e : view) {
+            Entity entity = { e, this };
+
+            auto& pbc = entity.GetComponents<PhysicsBodyComponent>();
+
+            body_interface->RemoveBody(pbc.body);
+            body_interface->DestroyBody(pbc.body);
+        }
+    }
+
    Entity Scene::CreateEntity(const std::string& name)
+    {
+        return CreateEntityWithUUID(UUID(), name);
+    }
+
+    Entity Scene::CreateEntityWithUUID(UUID uuid, const std::string& name)
    {
        Entity entity = { registry.create(), this };

+        entity.AddComponent<IDComponent>(uuid);
        auto& tag = entity.AddComponent<TagComponent>();
        tag.tag = name.empty() ? "Entity" : name;

@@ -26,15 +128,31 @@ namespace OpenEngine {

    void Scene::MarkEntityForDeletion(Entity entity)
    {
-        entities_to_be_deleted.emplace_back(entity);
+        pending_deletion.emplace_back(entity);
    }
    
    void Scene::UpdateEntities()
    {
-        for (auto& entity : entities_to_be_deleted)
+        for (auto& entity : pending_deletion)
            DeleteEntity(entity);

-        entities_to_be_deleted.clear();
+        pending_deletion.clear();
+    }
+
+    void Scene::OnUpdatePhysics()
+    {
+        static int step = 0;
+        static float accumulator = 0.0f;
+        static const float fixedDT = 1.0f / 60.0f;
+
+        float real_delta_time = Time::DeltaTime(); // e.g. from a timer
+        accumulator += real_delta_time;
+
+        if (accumulator >= fixedDT) {
+            step++;
+            physics_engine.Update(fixedDT, 1);
+            accumulator -= fixedDT;
+        }
    }

    void Scene::OnUpdateRuntime()
@@ -54,6 +172,40 @@ namespace OpenEngine {
                    });
        }

+        auto view = registry.view<TransformComponent, PhysicsBodyComponent>();
+        for (auto e : view) {
+            Entity entity = { e, this };
+
+            auto& pos = entity.GetComponents<TransformComponent>().translation;
+            auto& body = entity.GetComponents<PhysicsBodyComponent>();
+
+            body_interface->SetPosition(body.body, { pos.x, pos.y, pos.z }, EActivation::Activate);
+
+            body_interface->SetRestitution(body.body, body.restitution);
+            body_interface->SetFriction(body.body, body.friction);
+        }
+
+        OnUpdatePhysics();
+
+        for (auto e : view) {
+            Entity entity = { e, this };
+
+            auto& transform = entity.GetComponents<TransformComponent>();
+            auto& body = entity.GetComponents<PhysicsBodyComponent>();
+
+            auto position = body_interface->GetPosition(body.body);
+            auto rotation = body_interface->GetRotation(body.body).GetEulerAngles();
+            transform.translation.x = position.GetX();
+            transform.translation.y = position.GetY();
+            transform.translation.z = position.GetZ();
+
+            transform.rotation.x = rotation.GetX();
+            transform.rotation.y = rotation.GetY();
+            transform.rotation.z = rotation.GetZ();
+
+            body_interface->SetGravityFactor(body.body, body.gravity_factor);
+        }
+
        SceneCamera* main_camera = nullptr;
        glm::mat4 main_transform{ 1.0f };
        {
@@ -73,10 +225,15 @@ namespace OpenEngine {

                auto view = registry.view<TransformComponent, MeshComponent>();

-                for (const auto& entity : view) {
-                    auto [transform, mesh] = view.get<TransformComponent, MeshComponent>(entity);
+                for (const auto& e : view) {
+                    auto [transform, mesh] = view.get<TransformComponent, MeshComponent>(e);
+                    Entity entity(e, this);

-                    Renderer3D::DrawMesh(mesh.mesh, GetTransformFromComp(transform));
+                    Material material;
+                    if (entity.HasComponent<MaterialComponent>())
+                        material = entity.GetComponents<MaterialComponent>().material;
+
+                    Renderer3D::DrawMesh(mesh.mesh, material, GetTransformFromComp(transform));
                    /*
                    if (sprite.texture)
                        Renderer2D::DrawQuad(GetTransformFromComp(transform),
@@ -101,7 +258,24 @@ namespace OpenEngine {
        for (const auto& entity : view) {
            auto [transform, mesh] = view.get<TransformComponent, MeshComponent>(entity);

-            Renderer3D::DrawMesh(mesh.mesh, GetTransformFromComp(transform));
+            Material material;
+
+            Entity _entity(entity, this);
+            if (_entity.HasComponent<MaterialComponent>())
+                material = _entity.GetComponents<MaterialComponent>().material;
+
+            if (mesh.mesh)
+                Renderer3D::DrawMesh(mesh.mesh, material, GetTransformFromComp(transform), (uint32_t)_entity);
+        }
+
+        auto model_view = registry.view<TransformComponent, ModelComponent>();
+
+        for (const auto& entity : model_view) {
+            auto [transform, model_comp] = model_view.get<TransformComponent, ModelComponent>(entity);
+
+            Entity _entity(entity, this);
+
+            Renderer3D::DrawModel(model_comp.model, GetTransformFromComp(transform), (uint32_t)_entity);
        }

 		Renderer3D::EndScene();
@@ -170,4 +344,39 @@ namespace OpenEngine {
 	void Scene::OnComponentAdded<MeshComponent>(Entity entity, MeshComponent& component)
 	{
 	}
+
+	template<>
+	void Scene::OnComponentAdded<MaterialComponent>(Entity entity, MaterialComponent& component)
+	{
+	}
+
+	template<>
+	void Scene::OnComponentAdded<PhysicsBodyComponent>(Entity entity, PhysicsBodyComponent& component)
+	{
+	}
+
+	template<>
+	void Scene::OnComponentAdded<SphereShapeComponent>(Entity entity, SphereShapeComponent& component)
+	{
+	}
+
+	template<>
+	void Scene::OnComponentAdded<BoxShapeComponent>(Entity entity, BoxShapeComponent& component)
+	{
+	}
+
+    template<>
+	void Scene::OnComponentAdded<IDComponent>(Entity entity, IDComponent& component)
+	{
+	}
+
+    template<>
+	void Scene::OnComponentAdded<PlaneShapeComponent>(Entity entity, PlaneShapeComponent& component)
+	{
+	}
+
+    template<>
+	void Scene::OnComponentAdded<ModelComponent>(Entity entity, ModelComponent& component)
+	{
+	}
 }
--- a/open_engine/src/open_engine/scene/scene_serializer.cpp
+++ b/open_engine/src/open_engine/scene/scene_serializer.cpp
@@ -1,7 +1,9 @@
+#include <cstdint>
 #include <pch.hpp>

 #include "core.hpp"
 #include <scene/scene_serializer.hpp>
+#include "renderer/renderer3d.hpp"
 #include "scene/components.hpp"
 #include "scene/entity.hpp"

@@ -86,11 +88,12 @@ namespace OpenEngine {

    static void SerializeEntity(YAML::Emitter& out, Entity entity)
    {
-        out << YAML::BeginMap;
-        out << YAML::Key << "Entity" << YAML::Value << "412741205"; // Needs random
+        OE_CORE_ASSERT(entity.HasComponent<IDComponent>(), "Entity is missing UUID.");

-        if (entity.HasComponent<TagComponent>())
-        {
+        out << YAML::BeginMap;
+        out << YAML::Key << "Entity" << YAML::Value << entity.GetUUID(); // Needs random
+
+        if (entity.HasComponent<TagComponent>()) {
            out << YAML::Key << "TagComponent";
            out << YAML::BeginMap; // TagComponent

@@ -100,8 +103,7 @@ namespace OpenEngine {
            out << YAML::EndMap; // TagComponent
        }

-        if (entity.HasComponent<TransformComponent>())
-        {
+        if (entity.HasComponent<TransformComponent>()) {
            out << YAML::Key << "TransformComponent";
            out << YAML::BeginMap; // TransformComponent

@@ -113,8 +115,7 @@ namespace OpenEngine {
            out << YAML::EndMap; // TransformComponent
        }

-        if (entity.HasComponent<CameraComponent>())
-        {
+        if (entity.HasComponent<CameraComponent>()) {
            out << YAML::Key << "CameraComponent";
            out << YAML::BeginMap; // CameraComponent

@@ -138,8 +139,7 @@ namespace OpenEngine {
            out << YAML::EndMap; // CameraComponent
        }

-        if (entity.HasComponent<SpriteRendererComponent>())
-        {
+        if (entity.HasComponent<SpriteRendererComponent>()) {
            out << YAML::Key << "SpriteRendererComponent";
            out << YAML::BeginMap; // SpriteRendererComponent

@@ -149,6 +149,78 @@ namespace OpenEngine {
            out << YAML::EndMap; // SpriteRendererComponent
        }

+        if (entity.HasComponent<MeshComponent>()) {
+            out << YAML::Key << "MeshComponent";
+            out << YAML::BeginMap; // MeshComponent
+
+            auto& mesh_component = entity.GetComponents<MeshComponent>();
+            out << YAML::Key << "MeshType" << YAML::Value << (int)mesh_component.primitive_type;
+
+            out << YAML::EndMap; // MeshComponent
+        }
+
+        if (entity.HasComponent<MaterialComponent>()) {
+            out << YAML::Key << "MaterialComponent";
+            out << YAML::BeginMap; // MaterialComponent
+
+            auto& material = entity.GetComponents<MaterialComponent>().material;
+            out << YAML::Key << "Albedo" << YAML::Value << material.albedo;
+            out << YAML::Key << "Roughness" << YAML::Value << material.roughness;
+            out << YAML::Key << "Metalic" << YAML::Value << material.metallic;
+            out << YAML::Key << "AmbiantStrength" << YAML::Value << material.ambient_strength;
+            out << YAML::Key << "SpecularStrength" << YAML::Value << material.specular_strength;
+
+            out << YAML::EndMap; // MaterialComponent
+        }
+
+        if (entity.HasComponent<PhysicsBodyComponent>()) {
+            out << YAML::Key << "PhysicsBodyComponent";
+            out << YAML::BeginMap; // PhysicsBodyComponent
+
+            auto& pbc = entity.GetComponents<PhysicsBodyComponent>();
+            out << YAML::Key << "LinearDamping" << YAML::Value << pbc.linear_damping;
+            out << YAML::Key << "AngularDamping" << YAML::Value << pbc.angular_damping;
+            out << YAML::Key << "GravityFactor" << YAML::Value << pbc.gravity_factor;
+            out << YAML::Key << "Restitution" << YAML::Value << pbc.restitution;
+            out << YAML::Key << "Friction" << YAML::Value << pbc.friction;
+
+            out << YAML::Key << "Type" << YAML::Value << pbc.type;
+            out << YAML::Key << "ActivationState" << YAML::Value << pbc.initial_activation_state;
+            out << YAML::Key << "Layer" << YAML::Value << pbc.layer;
+
+            out << YAML::EndMap; // PhysicsBodyComponent
+        }
+
+        if (entity.HasComponent<BoxShapeComponent>()) {
+            out << YAML::Key << "BoxShapeComponent";
+            out << YAML::BeginMap; //BoxShapeComponent 
+
+            auto& bsc = entity.GetComponents<BoxShapeComponent>();
+            out << YAML::Key << "Size" << YAML::Value << bsc.size;
+
+            out << YAML::EndMap; //BoxShapeComponent 
+        }
+
+        if (entity.HasComponent<SphereShapeComponent>()) {
+            out << YAML::Key << "SphereShapeComponent";
+            out << YAML::BeginMap; //SphereShapeComponent 
+
+            auto& ssc = entity.GetComponents<SphereShapeComponent>();
+            out << YAML::Key << "Radius" << YAML::Value << ssc.radius;
+
+            out << YAML::EndMap; //SphereShapeComponent 
+        }
+
+        if (entity.HasComponent<PlaneShapeComponent>()) {
+            out << YAML::Key << "PlaneShapeComponent";
+            out << YAML::BeginMap; //PlaneShapeComponent 
+
+            auto& psc = entity.GetComponents<PlaneShapeComponent>();
+            out << YAML::Key << "Extent" << YAML::Value << psc.extent;
+
+            out << YAML::EndMap; //PlaneShapeComponent 
+        }
+
        out << YAML::EndMap;
    }

@@ -191,11 +263,10 @@ namespace OpenEngine {
 		OE_CORE_TRACE("Deserializing scene '{0}'", sceneName);

 		auto entities = data["Entities"];
-		if (entities)
-		{
+		if (entities) {
 			for (auto entity : entities)
 			{
-				uint64_t uuid = entity["Entity"].as<uint64_t>(); // TODO
+				uint64_t uuid = entity["Entity"].as<uint64_t>();

 				std::string name;
 				auto tagComponent = entity["TagComponent"];
@@ -204,11 +275,10 @@ namespace OpenEngine {

 				OE_CORE_TRACE("Deserialized entity with ID = {0}, name = {1}", uuid, name);

-				Entity deserializedEntity = context->CreateEntity(name);
+				Entity deserializedEntity = context->CreateEntityWithUUID(uuid, name);

 				auto transformComponent = entity["TransformComponent"];
-				if (transformComponent)
-				{
+				if (transformComponent) {
 					auto& tc = deserializedEntity.AddComponent<TransformComponent>();
 					tc.translation = transformComponent["Translation"].as<glm::vec3>();
 					tc.rotation = transformComponent["Rotation"].as<glm::vec3>();
@@ -216,8 +286,7 @@ namespace OpenEngine {
 				}

 				auto cameraComponent = entity["CameraComponent"];
-				if (cameraComponent)
-				{
+				if (cameraComponent) {
 					auto& cc = deserializedEntity.AddComponent<CameraComponent>();

 					auto camera_props = cameraComponent["Camera"];
@@ -236,16 +305,82 @@ namespace OpenEngine {
 				}

 				auto spriteRendererComponent = entity["SpriteRendererComponent"];
-				if (spriteRendererComponent)
-				{
+				if (spriteRendererComponent) {
 					auto& src = deserializedEntity.AddComponent<SpriteRendererComponent>();
 					src.color = spriteRendererComponent["Color"].as<glm::vec4>();
 				}
+
+                auto mesh_component = entity["MeshComponent"];
+                if (mesh_component) {
+                    auto& mesh = deserializedEntity.AddComponent<MeshComponent>();
+                    mesh.primitive_type = (PrimitiveType)mesh_component["MeshType"].as<int>();
+                    switch (mesh.primitive_type) {
+                        case OpenEngine::PrimitiveType::Quad: {
+                                mesh.mesh = CreateQuad((uint32_t)deserializedEntity);
+                                break;
+                            }
+                        case OpenEngine::PrimitiveType::Cube: {
+                                mesh.mesh = CreateCube((uint32_t)deserializedEntity);
+                                break;
+                            }
+                        default: {
+                                OE_CORE_ASSERT(false, "No mesh");
+                                break;
+                            }
+                    }
+                }
+
+				auto material_component = entity["MaterialComponent"];
+				if (material_component) {
+					auto& material = deserializedEntity.AddComponent<MaterialComponent>();
+					material.material.albedo = material_component["Albedo"].as<glm::vec4>();
+					material.material.roughness = material_component["Roughness"].as<float>();
+					material.material.metallic = material_component["Metalic"].as<float>();
+					material.material.ambient_strength = material_component["AmbiantStrength"].as<float>();
+					material.material.specular_strength = material_component["SpecularStrength"].as<float>();
+				}
+
+                auto physics_body_component = entity["PhysicsBodyComponent"];
+                if (physics_body_component) {
+                    auto& pbc = deserializedEntity.AddComponent<PhysicsBodyComponent>();
+
+                    pbc.linear_damping = physics_body_component["LinearDamping"].as<float>();
+                    pbc.angular_damping = physics_body_component["AngularDamping"].as<float>();
+                    pbc.gravity_factor = physics_body_component["GravityFactor"].as<float>();
+                    pbc.restitution = physics_body_component["Restitution"].as<float>();
+                    pbc.friction = physics_body_component["Friction"].as<float>();
+
+                    pbc.type = physics_body_component["Type"].as<int>();
+                    pbc.initial_activation_state = physics_body_component["ActivationState"].as<int>();
+                    pbc.layer = physics_body_component["Layer"].as<int>();
+                }
+
+                auto box_shape_component = entity["BoxShapeComponent"];
+                if (box_shape_component) {
+                    auto& bsc = deserializedEntity.AddComponent<BoxShapeComponent>();
+
+                    bsc.size = box_shape_component["Size"].as<glm::vec3>();
+                }
+
+                auto sphere_shape_component = entity["SphereShapeComponent"];
+                if (sphere_shape_component) {
+                    auto& ssc = deserializedEntity.AddComponent<SphereShapeComponent>();
+
+                    ssc.radius = sphere_shape_component["Radius"].as<float>();
+                }
+
+                auto plane_shape_component = entity["PlaneShapeComponent"];
+                if (sphere_shape_component) {
+                    auto& psc = deserializedEntity.AddComponent<PlaneShapeComponent>();
+
+                    psc.extent = plane_shape_component["Extent"].as<float>();
+                }
 			}
 		}

 		return true;
    }
+
    bool SceneSerializer::DeserializeRuntime(const std::string& file_path)
    {
        OE_CORE_ASSERT(false, "Not implemented yet");
--- a/open_engine/vendor/glad/CMakeLists.txt
+++ b/open_engine/vendor/glad/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.28)
+cmake_minimum_required(VERSION 3.25.1)

 set(CMAKE_CXX_STANDARD 20)

--- a/open_engine/vendor/nativefiledialog-extended
+++ b/open_engine/vendor/nativefiledialog-extended
--- a/resources/textures/icons/file.png
+++ b/resources/textures/icons/file.png
--- a/resources/textures/icons/folder2.png
+++ b/resources/textures/icons/folder2.png
--- a/resources/textures/icons/play.png
+++ b/resources/textures/icons/play.png
--- a/resources/textures/icons/stop.png
+++ b/resources/textures/icons/stop.png
--- a/untitled_persp.oes
+++ b/untitled_persp.oes
@@ -1,47 +0,0 @@
-Scene: N/A
-Entities:
-  - Entity: 412741205
-    TagComponent:
-      Tag: square 3
-    TransformComponent:
-      Translation: [-1.49011612e-08, 0.299999774, -0.499999911]
-      Rotation: [-1.57079685, 0, 0]
-      Scale: [0.605000019, 0.60496217, 0.60496217]
-    SpriteRendererComponent:
-      Color: [1, 1, 1, 1]
-  - Entity: 412741205
-    TagComponent:
-      Tag: "square 2 "
-    TransformComponent:
-      Translation: [0, 0, -0.200000003]
-      Rotation: [0, 0, 0]
-      Scale: [0.600000024, 0.600000083, 0.600000024]
-    SpriteRendererComponent:
-      Color: [0.882352948, 0.745098054, 0.376470596, 1]
-  - Entity: 412741205
-    TagComponent:
-      Tag: square
-    TransformComponent:
-      Translation: [0.299827427, -9.68575478e-08, -0.499896437]
-      Rotation: [0, 1.57079637, 0]
-      Scale: [0.6049999, 0.604999959, 0.6049999]
-    SpriteRendererComponent:
-      Color: [0.517647088, 0.0901960805, 1, 1]
-  - Entity: 412741205
-    TagComponent:
-      Tag: camera
-    TransformComponent:
-      Translation: [0, 0, 20.8999996]
-      Rotation: [0, 0, 0]
-      Scale: [1, 1, 1]
-    CameraComponent:
-      Camera:
-        ProjectionType: 0
-        PerspectiveFOV: 45
-        PerspectiveNear: 0.00999999978
-        PerspectiveFar: 1000
-        OrthographicSize: 10
-        OrthographicNear: -1
-        OrthographicFar: 1
-      Primary: true
-      FixedAspectRatio: false
--- a/vendor/ImGuizmo
+++ b/vendor/ImGuizmo
Author	SHA1	Message	Date
Erris	073bb47586	fixing compilation	2026-03-10 10:12:48 +01:00
Erris	0abc3dbfab	still fixing compilation errors	2026-03-10 09:57:38 +01:00
Erris	820442c4d6	updating cmakelists	2026-03-10 09:41:46 +01:00
Erris	9145e739ba	Merge branch 'main' of https://git.anfer.fr/OpenEngine	2026-03-10 09:29:19 +01:00
Erris	988f7f8805	fixing cmakefiles	2026-03-10 09:29:13 +01:00
erris	e4dcfeccb9	Edit .onedev-buildspec.yml	2026-03-10 09:19:03 +01:00
Erris	c808fe2903	Merge branch 'main' of https://git.anfer.fr/OpenEngine	2026-03-10 09:17:07 +01:00
Erris	f603d3b58f	updating cmakelists.txt	2026-03-10 09:16:48 +01:00
erris	1a312832ea	Edit .onedev-buildspec.yml	2026-03-10 08:49:13 +01:00
erris	85c45f0929	Edit .onedev-buildspec.yml	2026-03-10 08:47:07 +01:00
erris	6abfe9f27b	Edit .onedev-buildspec.yml	2026-03-10 08:46:09 +01:00
erris	a84b35c105	Edit .onedev-buildspec.yml	2026-03-10 08:40:17 +01:00
erris	8db8ca679e	Edit .onedev-buildspec.yml	2026-03-10 08:37:26 +01:00
erris	83bb2c6932	Edit .onedev-buildspec.yml	2026-03-10 08:32:37 +01:00
erris	4d5c9fc614	Edit .onedev-buildspec.yml	2026-03-10 08:28:38 +01:00
erris	c9c0a328dc	Edit .onedev-buildspec.yml	2026-03-10 08:26:43 +01:00
erris	7ab3e7434a	Edit .onedev-buildspec.yml	2026-03-10 08:25:18 +01:00
erris	fe4b54699b	Edit .onedev-buildspec.yml	2026-03-10 08:23:05 +01:00
erris	b69f9c5305	Edit .onedev-buildspec.yml	2026-03-10 08:17:16 +01:00
Erris	adc6676dc9	fixing cmakelists	2026-03-10 08:02:29 +01:00
Erris	43c66d887b	fixing compilation	2026-03-10 07:42:42 +01:00
Erris	6970df2ead	forgor glm	2026-03-10 07:25:50 +01:00
Erris	b24578ad70	updating cmakelists.txt	2026-03-10 07:16:49 +01:00
Erris	2463a5f001	Merge branch 'main' of https://git.anfer.fr/OpenEngine	2026-03-10 07:02:44 +01:00
Erris	697ae61109	fixing missing spdlog	2026-03-10 07:02:37 +01:00
erris	e20853fdb1	Edit .onedev-buildspec.yml	2026-03-10 06:32:57 +01:00
erris	55437f397e	Edit .onedev-buildspec.yml	2026-03-10 06:22:04 +01:00
erris	729abc17f0	Edit .onedev-buildspec.yml	2026-03-10 06:12:45 +01:00
erris	42090a5d47	Edit .onedev-buildspec.yml	2026-03-10 05:50:45 +01:00
erris	88ea35ab67	Edit .onedev-buildspec.yml	2026-03-10 05:37:41 +01:00
erris	a6a3340334	Edit .onedev-buildspec.yml	2026-03-10 05:15:18 +01:00
erris	73a82a00b4	Edit .onedev-buildspec.yml	2026-03-10 05:04:29 +01:00
erris	7d7b09df55	Edit .onedev-buildspec.yml	2026-03-10 05:03:37 +01:00
erris	9fc3422913	Edit .onedev-buildspec.yml	2026-03-10 04:46:15 +01:00
erris	f053f23ed6	Edit .onedev-buildspec.yml	2026-03-10 04:30:51 +01:00
erris	8b093603f5	Edit .onedev-buildspec.yml	2026-03-10 04:14:30 +01:00
Erris	27365835fa	04:04am commit	2026-03-10 04:04:49 +01:00
Erris	04ce3f4b8f	4am commit	2026-03-10 03:57:40 +01:00
Erris	15a137644f	moving nfde	2026-03-10 03:36:27 +01:00
Erris	9add74afa8	submodules	2026-03-10 03:26:42 +01:00
erris	7b6afc5240	Edit .onedev-buildspec.yml	2026-03-10 03:22:09 +01:00
erris	2b0b81b2c8	Edit .onedev-buildspec.yml	2026-03-10 03:07:51 +01:00
Erris	0d9dcfd541	Merge branch 'main' of https://git.anfer.fr/OpenEngine	2026-03-10 03:07:33 +01:00
Erris	772b219caa	updating cmakelists	2026-03-10 03:07:27 +01:00
erris	be57a1fc16	Edit .onedev-buildspec.yml	2026-03-10 02:58:52 +01:00
erris	67a42e5685	Edit .onedev-buildspec.yml	2026-03-10 02:47:19 +01:00
Erris	6ace0bac91	updating cmakelists	2026-03-10 02:41:24 +01:00
erris	9b2d5bf35a	Edit .onedev-buildspec.yml	2026-03-10 02:31:38 +01:00
erris	378d4c58a9	Edit .onedev-buildspec.yml	2026-03-10 02:19:15 +01:00
erris	c5d650cf6b	Edit .onedev-buildspec.yml	2026-03-10 02:16:45 +01:00
erris	709fb3141b	Edit .onedev-buildspec.yml	2026-03-10 02:13:21 +01:00
erris	3e96b676da	Edit .onedev-buildspec.yml	2026-03-10 02:10:50 +01:00
erris	f761718957	Edit .onedev-buildspec.yml	2026-03-10 02:06:35 +01:00
erris	b72206b531	Edit .onedev-buildspec.yml	2026-03-10 02:01:13 +01:00
erris	ca74942001	Edit .onedev-buildspec.yml	2026-03-10 01:59:32 +01:00
erris	57a15752c7	Edit .onedev-buildspec.yml	2026-03-10 01:56:50 +01:00
Erris	5c5f55ec16	Merge branch 'main' of https://git.anfer.fr/OpenEngine	2026-03-10 01:56:00 +01:00
Erris	25d82d6689	adding .envrc necessary for compilation	2026-03-10 01:55:47 +01:00
erris	2e3f7c9e20	Edit .onedev-buildspec.yml	2026-03-10 01:53:39 +01:00
erris	0001e7e023	Edit .onedev-buildspec.yml	2026-03-10 01:51:20 +01:00
erris	d3a0e88eb0	Edit .onedev-buildspec.yml	2026-03-10 01:45:26 +01:00
erris	752d556204	Edit .onedev-buildspec.yml	2026-03-10 01:41:33 +01:00
erris	94529460e2	Edit .onedev-buildspec.yml	2026-03-10 01:40:54 +01:00
erris	37864d6d37	Edit .onedev-buildspec.yml	2026-03-10 01:39:59 +01:00
erris	54c083ccda	Edit .onedev-buildspec.yml	2026-03-10 01:09:15 +01:00
Erris	44910bd3f8	test autopush	2026-03-09 17:41:40 +01:00
Erris	b4f4aa010e	Merge branch 'main' of https://git.anfer.fr/OpenEngine	2026-03-09 17:40:10 +01:00
Erris	521ee17daf	Merge branch 'fastgltf'	2026-03-09 17:35:29 +01:00
Erris	2175b60990	test commit to sync to gitea	2026-03-09 17:19:20 +01:00
erris	ebb179ec68	Adding repo sync to gitea	2026-03-09 17:18:07 +01:00
erris	ee8841b6d4	Add README.md	2026-03-09 16:39:04 +01:00
Erris	a0c900166f	improved model loading and added model component	2026-03-09 16:37:30 +01:00
Erris	ac18bb6f00	Initial fastgltf integration	2026-03-08 11:38:46 +01:00
Erris	464ab70c46	Merge branch 'jolt'	2026-03-07 11:53:40 +01:00
Erris	48d2905695	Merge branch 'fastgltf' into jolt	2026-03-07 11:53:23 +01:00
Erris	af7b7d2bfa	adding plane shape and universal guizmo (this is the wrong branch)	2026-03-07 11:48:46 +01:00
Erris	1eda916f3e	Merge branch '3d'	2026-03-06 18:09:39 +01:00
Erris	44f766863d	Merge branch 'jolt' into 3d	2026-03-06 18:09:26 +01:00
Erris	2d3fe57d5a	added UUID	2026-03-06 18:07:51 +01:00
Erris	5be3c61859	fixing segv when closing the program	2026-03-05 22:30:48 +01:00
Erris	a187bd2894	needed for jolt	2026-03-05 01:23:26 +01:00
Erris	ecf27eae73	various bug fix, serialization, adding shapes	2026-03-05 01:22:41 +01:00
Erris	f45091349e	added rotation	2026-03-04 11:18:16 +01:00
Erris	eaef554b10	Adding basic impl of Jolt Update positions on 60tps, position of objects can be modified while physic simulation is running. Position is owned by transform comps but the truth is held by the physics engine for affected entities	2026-03-04 10:19:46 +01:00
Erris	282eeeabda	fixed unselecting entity when cursor goes from ImGui to viewport while click is held	2026-03-03 09:38:52 +01:00
Erris	4a624cfe70	adding materials, adding serialization for meshes and materials, random fixes	2026-03-03 08:51:02 +01:00