improved model loading and added model component

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;
 }

conanfile.txt

@@ -4,6 +4,7 @@ spdlog/1.16.0
 entt/3.16.0
 yaml-cpp/0.8.0
 joltphysics/5.2.0
+fastgltf/0.9.0
 
 [generators]
 CMakeDeps

editor/include/editor.hpp

@@ -3,6 +3,10 @@
 
 #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 "panels/content_browser.hpp"
@@ -128,6 +132,20 @@ namespace OpenEngine {
                 auto& mc2 = cube2.AddComponent<MeshComponent>(mesh2);
                 mc2.primitive_type = PrimitiveType::Cube;
 
+                // ============================================================
+
+                Entity cube3 = scene->CreateEntity("glb");
+                Entity cube4 = scene->CreateEntity("glb2");
+                cube3.AddComponent<TransformComponent>();
+                cube4.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>(monkey);
+
                 /*
                 auto view = scene->GetRegistry().view<TagComponent>();
 
@@ -285,6 +303,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();

editor/include/editor_component.hpp

@@ -19,7 +19,10 @@ namespace OpenEngine {
     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 ShapeOnImGuiRender(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

editor/src/editor_component.cpp

@@ -1,6 +1,8 @@
 #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>
@@ -181,12 +183,11 @@ namespace OpenEngine {
     {
         auto& mesh_component = registry.get<MeshComponent>(entity); 
 
-        const char* items[] = { "Quad", "Cube" };
-        static int item_selected_idx = 0;
+        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 < 2; n++)
-            {
+            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;
@@ -196,25 +197,26 @@ namespace OpenEngine {
                     ImGui::SetItemDefaultFocus();
             }
             ImGui::EndCombo();
+        }
 
-            if ((int)mesh_component.primitive_type == (item_selected_idx + 1))
-                return;
+        if ((int)mesh_component.primitive_type == (item_selected_idx))
+            return;
 
-            mesh_component.primitive_type = (PrimitiveType)(item_selected_idx + 1);
-            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.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;
         }
     }
 
@@ -233,16 +235,94 @@ namespace OpenEngine {
     {
         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 ShapeOnImGuiRender(entt::registry &registry, entt::entity entity)
+    void SphereShapeOnImGuiRender(entt::registry &registry, entt::entity entity)
     {
-        auto& shape_comp = registry.get<PhysicsShapeComponent>(entity);
+        auto& sphere_comp = registry.get<SphereShapeComponent>(entity);
+        
+        ImGui::DragFloat("Radius",
+                &sphere_comp.radius,
+                0.1f,
+                0.11f, FLT_MAX,
+                "%.2f",
+                ImGuiSliderFlags_AlwaysClamp);
+    }
 
-        ImGui::SliderFloat("Bounciness", &shape_comp.restitution, 0, 1);
-        ImGui::SliderFloat("Friction", &shape_comp.friction, 0, 1);
+    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",
+                nullptr
+                );
+
+        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();
+        }
     }
 }

editor/src/panels/scene_hierarchy.cpp

@@ -25,7 +25,10 @@ namespace OpenEngine {
         RegisterDrawer<MeshComponent>("Mesh", &MeshOnImGuiRender);
         RegisterDrawer<MaterialComponent>("Material", &MaterialOnImGuiRender);
         RegisterDrawer<PhysicsBodyComponent>("Physics Body", &BodyOnImGuiRender);
-        RegisterDrawer<PhysicsShapeComponent>("Physics Shape", &ShapeOnImGuiRender);
+        RegisterDrawer<SphereShapeComponent>("Sphere Shape", &SphereShapeOnImGuiRender);
+        RegisterDrawer<BoxShapeComponent>("Box Shape", &BoxShapeOnImGuiRender);
+        RegisterDrawer<PlaneShapeComponent>("Plane Shape", &PlaneShapeOnImGuiRender);
+        RegisterDrawer<ModelComponent>("Model", &ModelOnImGuiRender);
 
         scene = context;
         selected_context = {};
@@ -64,9 +67,24 @@ namespace OpenEngine {
                 selected_context.AddComponent<PhysicsBodyComponent>();
                 ImGui::CloseCurrentPopup();
             }
-        if (!selected_context.HasComponent<PhysicsShapeComponent>())
-            if (ImGui::MenuItem("Physics shape")) {
-                selected_context.AddComponent<PhysicsShapeComponent>();
+        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();
             }
     }

imgui.ini

@@ -1,6 +1,6 @@
 [Window][WindowOverViewport_11111111]
 Pos=0,24
-Size=2552,1363
+Size=1272,1363
 Collapsed=0
 
 [Window][Debug##Default]
@@ -10,31 +10,31 @@ Collapsed=0
 
 [Window][Statistics]
 Pos=0,24
-Size=224,437
+Size=409,437
 Collapsed=0
 DockId=0x00000003,0
 
 [Window][Properties]
-Pos=2102,24
+Pos=822,24
 Size=450,805
 Collapsed=0
 DockId=0x00000007,0
 
 [Window][Viewport]
-Pos=226,61
-Size=1874,956
+Pos=411,61
+Size=409,956
 Collapsed=0
 DockId=0x00000012,0
 
 [Window][Dear ImGui Demo]
-Pos=2102,831
+Pos=822,831
 Size=450,556
 Collapsed=0
 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=1874,368
+Pos=411,1019
+Size=409,368
 Collapsed=0
 DockId=0x0000000C,0
 
@@ -155,18 +155,18 @@ Collapsed=0
 DockId=0x0000000F,0
 
 [Window][##play_state_bar]
-Pos=226,24
-Size=1874,35
+Pos=411,24
+Size=409,35
 Collapsed=0
 DockId=0x00000011,0
 
 [Docking][Data]
-DockSpace               ID=0x08BD597D Window=0x1BBC0F80 Pos=0,24 Size=2552,1363 Split=X
+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
@@ -178,6 +178,6 @@ DockSpace               ID=0x08BD597D Window=0x1BBC0F80 Pos=0,24 Size=2552,1363
         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,810 Selected=0x8C72BEA8
-    DockNode            ID=0x00000008 Parent=0x00000006 SizeRef=444,559 Selected=0x5E5F7166
+    DockNode            ID=0x00000007 Parent=0x00000006 SizeRef=444,805 Selected=0x8C72BEA8
+    DockNode            ID=0x00000008 Parent=0x00000006 SizeRef=444,556 Selected=0x5E5F7166
 

open_engine/CMakeLists.txt

@@ -74,3 +74,5 @@ add_subdirectory(vendor/glad
 )
 
 add_subdirectory("vendor/nativefiledialog-extended")
+
+target_compile_options(open_engine PRIVATE -msse4.1 -msse4.2 -mavx -mavx2)

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

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

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

open_engine/include/open_engine/physics.hpp

@@ -17,6 +17,7 @@
 #include <Jolt/Physics/Body/BodyActivationListener.h>
 
 #include <cstdarg>
+#include <glm/glm.hpp>
 
 using namespace JPH;
 using namespace JPH::literals;
@@ -73,6 +74,8 @@ namespace BroadPhaseLayers
 	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:

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

open_engine/include/open_engine/renderer/renderer3d.hpp

@@ -2,9 +2,8 @@
 #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 {
@@ -18,39 +17,12 @@ namespace OpenEngine {
         Cube
     };
 
-    struct MeshVertex
-    {
-        glm::vec3 position;
-        glm::vec4 color;
-        glm::vec3 normal;
-        glm::vec2 text_coords;
-        uint32_t id = -1;
-    };
-
-    struct Material
-    {
-        glm::vec4 albedo = { 1.0f, 1.0f, 1.0f, 1.0f };
-        float roughness = 1.0f;
-        float metallic = 1.0f;
-        float ambient_strength = 1.0f;
-        float specular_strength = 1.0f;
-    };
-
-    struct Mesh
-    {
-        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;
-    };
-
     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
@@ -65,6 +37,12 @@ namespace OpenEngine {
 
             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);
     };
 }
 

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;
 

open_engine/include/open_engine/scene/components.hpp

@@ -1,12 +1,14 @@
 #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>
@@ -28,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;
@@ -74,6 +85,8 @@ namespace OpenEngine {
         CameraComponent(const CameraComponent&) = default;
     };
 
+    class NativeScriptableEntity;
+
     struct NativeScriptComponent 
     {
         NativeScriptableEntity* instance = nullptr;
@@ -81,9 +94,6 @@ namespace OpenEngine {
         NativeScriptableEntity* (*InstanciateScript)();
         void (*DestroyInstanceScript)(NativeScriptComponent*);
 
-        void OnImGuiRender(Entity& entity) 
-        {};
-
         template <typename T>
             void Bind()
             {
@@ -119,30 +129,57 @@ namespace OpenEngine {
 
     struct PhysicsBodyComponent
     {
-        enum class BodyType { Static = 0, Kinematic, Dynamic };
-
         BodyID body;
 
-        BodyType type = BodyType::Dynamic;
-
         float linear_damping = 0.05f;
         float angular_damping = 0.05f;
         float gravity_factor = 1.0f;
+        float restitution = 0.8f;
+        float friction = 0.5f;
 
-        EActivation initial_activation_state = EActivation::Activate;
+        int type = (int)EMotionType::Static;
+        int initial_activation_state = (int)EActivation::Activate;
+        int layer = (int)Layers::MOVING;
 
         PhysicsBodyComponent() = default;
         PhysicsBodyComponent(const PhysicsBodyComponent&) = default;
     };
 
-    struct PhysicsShapeComponent
+    // TODO: Let's add more shapes
+    struct BoxShapeComponent
     {
-        ShapeRefC shape;
+        glm::vec3 size = { 1.0f, 1.0f, 1.0f };
 
-        float restitution = 0.8f;
-        float friction = 0.5f;
+        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

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; };

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 {

open_engine/include/open_engine/scene/scene.hpp

@@ -1,6 +1,7 @@
 #ifndef SCENE_HPP
 #define SCENE_HPP
 
+#include "open_engine/core/uuid.hpp"
 #include "open_engine/renderer/editor_camera.hpp"
 #include "open_engine/physics.hpp"
 
@@ -18,11 +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);
 
@@ -52,8 +55,6 @@ namespace OpenEngine {
 
             std::vector<entt::entity> pending_deletion;
 
-            //BodyID sphere_id;
-
             friend class SceneSerializer;
             friend class Entity;
     };

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

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;
+    }
+
+}

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;
+    }
+
+}

open_engine/src/open_engine/physics.cpp

@@ -38,7 +38,9 @@ namespace OpenEngine {
 
         tmp_allocator = CreateRef<TempAllocatorImpl>(10 * 1024 * 1024);
 
-        job_system = CreateRef<JobSystemThreadPool>(cMaxPhysicsJobs, cMaxPhysicsBarriers, thread::hardware_concurrency() - 1);
+        job_system = CreateRef<JobSystemThreadPool>(cMaxPhysicsJobs,
+                cMaxPhysicsBarriers,
+                thread::hardware_concurrency() - 1);
 
         physics_system.Init(
                 1024,
@@ -49,10 +51,10 @@ namespace OpenEngine {
                 object_vs_broadphase_layer_filter,
                 object_vs_object_layer_filter);
 
-        physics_system.SetBodyActivationListener(&body_activation_listener);
-        physics_system.SetContactListener(&contact_listener);
+        //physics_system.SetBodyActivationListener(&body_activation_listener);
+        //physics_system.SetContactListener(&contact_listener);
 
-        // TODO: Move out of here and check the comment on Jolt's example
+        // TODO: Check the comment on Jolt's example
         physics_system.OptimizeBroadPhase();
     }
 

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);
+    }
+
+}

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 = {
@@ -179,6 +152,8 @@ namespace OpenEngine {
 
         Material material_buffer;
         Ref<UniformBuffer> material_uniform_buffer;
+
+        Ref<UniformBuffer> id_uniform_buffer;
     };
 
     static Renderer3DData renderer_data;
@@ -194,6 +169,7 @@ namespace OpenEngine {
         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);
@@ -205,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)
@@ -251,4 +230,48 @@ namespace OpenEngine {
 
         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());
+        }
+    }
 }

open_engine/src/open_engine/scene/scene.cpp

@@ -1,69 +1,94 @@
 #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();
-
-        BoxShapeSettings floor_shape_settings(Vec3(100.0f, 1.0f, 100.0f));
-        floor_shape_settings.SetEmbedded(); // A ref counted object on the stack (base class RefTarget) should be marked as such to prevent it from being freed when its reference count goes to 0.
-
-        // Create the shape
-        ShapeSettings::ShapeResult floor_shape_result = floor_shape_settings.Create();
-        ShapeRefC floor_shape = floor_shape_result.Get(); // We don't expect an error here, but you can check floor_shape_result for HasError() / GetError()
-
-        // Create the settings for the body itself. Note that here you can also set other properties like the restitution / friction.
-        BodyCreationSettings floor_settings(floor_shape, RVec3(0.0_r, -1.0_r, 0.0_r), Quat::sIdentity(), EMotionType::Static, Layers::NON_MOVING);
-
-        // Create the actual rigid body
-        Body *floor = body_interface->CreateBody(floor_settings); // Note that if we run out of bodies this can return nullptr
-
-        // Add it to the world
-        body_interface->AddBody(floor->GetID(), EActivation::DontActivate);
-
-        auto view = registry.view<PhysicsBodyComponent>();
+        // 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();
 
-            TransformComponent* tc;
-            if (entity.HasComponent<TransformComponent>())
-                tc = &entity.GetComponents<TransformComponent>();
             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;
 
-            PhysicsShapeComponent* psc;
-            if (entity.HasComponent<PhysicsShapeComponent>())
-                psc = &entity.GetComponents<PhysicsShapeComponent>();
-
-            glm::vec3& pos = tc->translation;
+            Quat quat = Quat::sEulerAngles(Vec3(rot.x, rot.y, rot.z));
             BodyCreationSettings settings(
-                    new BoxShape(Vec3(0.5f, 0.5f, 0.5f)),
+                    shape,
+                    //new BoxShape(Vec3(scale.x * 0.5, scale.y * 0.5f, scale.z * 0.5f)),
                     Vec3(pos.x, pos.y, pos.z),
-                    Quat::sIdentity(),
-                    EMotionType::Dynamic,
-                    Layers::MOVING);
+                    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;
 
-            settings.mRestitution = psc->restitution;
-            settings.mFriction = psc->friction;
-
-            pbc.body = body_interface->CreateAndAddBody(settings, EActivation::Activate);
+            pbc.body = body_interface->CreateAndAddBody(settings, (EActivation)pbc.initial_activation_state);
         }
     }
 
@@ -75,15 +100,21 @@ namespace OpenEngine {
 
             auto& pbc = entity.GetComponents<PhysicsBodyComponent>();
 
-            physics_engine.GetBodyInterface().RemoveBody(pbc.body);
-            physics_engine.GetBodyInterface().DestroyBody(pbc.body);
+            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;
 
@@ -150,15 +181,8 @@ namespace OpenEngine {
 
             body_interface->SetPosition(body.body, { pos.x, pos.y, pos.z }, EActivation::Activate);
 
-            PhysicsShapeComponent* shape;
-            if (entity.HasComponent<PhysicsShapeComponent>()) {
-                shape = &entity.GetComponents<PhysicsShapeComponent>();
-
-                body_interface->SetRestitution(body.body, shape->restitution);
-                body_interface->SetFriction(body.body, shape->friction);
-                body_interface->SetGravityFactor(body.body, body.gravity_factor);
-            }
-
+            body_interface->SetRestitution(body.body, body.restitution);
+            body_interface->SetFriction(body.body, body.friction);
         }
 
         OnUpdatePhysics();
@@ -169,10 +193,17 @@ namespace OpenEngine {
             auto& transform = entity.GetComponents<TransformComponent>();
             auto& body = entity.GetComponents<PhysicsBodyComponent>();
 
-            auto position = physics_engine.GetBodyInterface().GetPosition(body.body);
+            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;
@@ -194,14 +225,13 @@ 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);
 
                     Material material;
-
-                    Entity _entity(entity, this);
-                    if (_entity.HasComponent<MaterialComponent>())
-                        material = _entity.GetComponents<MaterialComponent>().material;
+                    if (entity.HasComponent<MaterialComponent>())
+                        material = entity.GetComponents<MaterialComponent>().material;
 
                     Renderer3D::DrawMesh(mesh.mesh, material, GetTransformFromComp(transform));
                     /*
@@ -234,7 +264,18 @@ namespace OpenEngine {
             if (_entity.HasComponent<MaterialComponent>())
                 material = _entity.GetComponents<MaterialComponent>().material;
 
-            Renderer3D::DrawMesh(mesh.mesh, material, GetTransformFromComp(transform));
+            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();
@@ -315,7 +356,27 @@ namespace OpenEngine {
 	}
 
 	template<>
-	void Scene::OnComponentAdded<PhysicsShapeComponent>(Entity entity, PhysicsShapeComponent& component)
+	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)
 	{
 	}
 }

open_engine/src/open_engine/scene/scene_serializer.cpp

@@ -88,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
 
@@ -102,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
 
@@ -115,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
 
@@ -140,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
 
@@ -151,8 +149,7 @@ namespace OpenEngine {
             out << YAML::EndMap; // SpriteRendererComponent
         }
 
-        if (entity.HasComponent<MeshComponent>())
-        {
+        if (entity.HasComponent<MeshComponent>()) {
             out << YAML::Key << "MeshComponent";
             out << YAML::BeginMap; // MeshComponent
 
@@ -162,8 +159,7 @@ namespace OpenEngine {
             out << YAML::EndMap; // MeshComponent
         }
 
-        if (entity.HasComponent<MaterialComponent>())
-        {
+        if (entity.HasComponent<MaterialComponent>()) {
             out << YAML::Key << "MaterialComponent";
             out << YAML::BeginMap; // MaterialComponent
 
@@ -177,6 +173,54 @@ namespace OpenEngine {
             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;
     }
 
@@ -219,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"];
@@ -232,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>();
@@ -244,8 +286,7 @@ namespace OpenEngine {
 				}
 
 				auto cameraComponent = entity["CameraComponent"];
-				if (cameraComponent)
-				{
+				if (cameraComponent) {
 					auto& cc = deserializedEntity.AddComponent<CameraComponent>();
 
 					auto camera_props = cameraComponent["Camera"];
@@ -264,15 +305,13 @@ 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)
-                {
+                if (mesh_component) {
                     auto& mesh = deserializedEntity.AddComponent<MeshComponent>();
                     mesh.primitive_type = (PrimitiveType)mesh_component["MeshType"].as<int>();
                     switch (mesh.primitive_type) {
@@ -292,8 +331,7 @@ namespace OpenEngine {
                 }
 
 				auto material_component = entity["MaterialComponent"];
-				if (material_component)
-				{
+				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>();
@@ -301,11 +339,48 @@ namespace OpenEngine {
 					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");