Merge branch '3d'

editor/include/editor.hpp

@@ -1,17 +1,15 @@
 #ifndef EDITOR_HPP
 #define EDITOR_HPP
 
+#include <X11/X.h>
 #include <open_engine.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>
@@ -94,39 +92,33 @@ 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");
 
-                auto& tc = cube.AddComponent<TransformComponent>();
+
+                cube.AddComponent<TransformComponent>();
 
                 Ref<Mesh> mesh = CreateCube(cube);
 
-                auto& mc = cube.AddComponent<MeshComponent>(mesh);
-                mc.primitive_type = PrimitiveType::Cube;
+                cube.AddComponent<MeshComponent>(mesh);
 
-                // =============================================
                 Entity quad = scene->CreateEntity("quad");
                 quad.AddComponent<TransformComponent>();
                 quad.GetComponents<TransformComponent>().translation = {0, 0, 0};
 
                 Ref<Mesh> quad_mesh = CreateQuad(quad, true);
 
-                auto& mc3 = quad.AddComponent<MeshComponent>(quad_mesh);
-                mc3.primitive_type = PrimitiveType::Quad;
+                quad.AddComponent<MeshComponent>(quad_mesh);
 
-                // =============================================
                 Entity cube2 = scene->CreateEntity("cube2");
                 cube2.AddComponent<TransformComponent>();
                 cube2.GetComponents<TransformComponent>().translation = {2, 0, 0};
 
                 Ref<Mesh> mesh2 = CreateCube(cube2);
 
-                auto& mc2 = cube2.AddComponent<MeshComponent>(mesh2);
-                mc2.primitive_type = PrimitiveType::Cube;
+                cube2.AddComponent<MeshComponent>(mesh2);
 
                 /*
                 auto view = scene->GetRegistry().view<TagComponent>();
@@ -137,6 +129,7 @@ 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++) {
@@ -186,6 +179,7 @@ namespace OpenEngine {
                 RenderCommand::Clear();
                 framebuffer->ClearBufferI(1, -1);
 
+
                 switch (state) {
                     case PlayState::Play: {
                         scene->OnUpdateRuntime();
@@ -212,7 +206,6 @@ 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
@@ -359,7 +352,7 @@ namespace OpenEngine {
                 bool was_focused = viewport_focused;
                 viewport_focused = ImGui::IsWindowFocused(ImGuiFocusedFlags_RootWindow);
                 viewport_hovered = ImGui::IsWindowHovered(ImGuiHoveredFlags_RootWindow);
-                Application::Get().GetImGuiLayer()->SetBlockEvents(ImGui::IsAnyItemActive());
+                Application::Get().GetImGuiLayer()->SetBlockEvents((!viewport_focused && !viewport_hovered) || ImGui::IsAnyItemActive());
 
                 if (viewport_focused && !was_focused)
                     editor_camera.ResetMousePosition();
@@ -570,12 +563,10 @@ namespace OpenEngine {
             void OnScenePlay()
             {
                 state = PlayState::Play;
-                scene->OnRuntimeStart();
             }
             void OnSceneStop()
             {
                 state = PlayState::Edit;
-                scene->OnRuntimeStop();
             }
 
         private:

editor/include/editor_component.hpp

@@ -17,10 +17,6 @@ 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);
 }
 
 #endif // EDITOR_COMPONENT_HPP

editor/include/panels/content_browser.hpp

@@ -18,7 +18,6 @@ namespace OpenEngine {
         private:
             std::filesystem::path current_directory;
             Ref<Texture2D> folder_icon;
-            Ref<Texture2D> file_icon;
     };
 
 }

editor/src/editor_component.cpp

@@ -1,10 +1,5 @@
 #include "imgui.h"
-#include "open_engine/renderer/renderer3d.hpp"
-#include "open_engine/scene/components.hpp"
-#include <Jolt/Physics/Body/MotionType.h>
 #include <editor_component.hpp>
-#include <entt/entity/fwd.hpp>
-#include <glm/gtc/type_ptr.hpp>
 #include <open_engine.hpp>
 
 namespace OpenEngine {
@@ -96,7 +91,6 @@ 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) 
@@ -107,7 +101,6 @@ 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) 
@@ -180,107 +173,6 @@ namespace OpenEngine {
 
     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);
     }
 }

editor/src/panels/content_browser.cpp

@@ -15,9 +15,8 @@ namespace OpenEngine {
     ContentBrowserPanel::ContentBrowserPanel()
         : current_directory(assets_directory)
     {
-        // TODO: Add license
-        folder_icon = Texture2D::Create("resources/textures/icons/folder2.png");
-        file_icon = Texture2D::Create("resources/textures/icons/file.png");
+        // TODO: Add file texture. Get free icons and add license
+        folder_icon = Texture2D::Create("resources/textures/icons/folder.png");
     }
 
     void ContentBrowserPanel::OnImGuiRender()
@@ -31,16 +30,6 @@ 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;
@@ -53,12 +42,9 @@ 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 : entries) {
+            for (auto& entry : directory_it) {
                 auto file_name = entry.path().filename().string();
 
                 ImGui::PushID(file_name.c_str());
@@ -70,14 +56,17 @@ namespace OpenEngine {
                 ImGui::PushStyleColor(ImGuiCol_ButtonActive, { 0.270f, 0.278f, 0.352f, 1.0f });
 
                 ImGui::BeginGroup();
-                Ref<Texture2D> icon = entry.is_directory() ? folder_icon : file_icon;
-                ImGui::ImageButton("##X", (ImTextureID)icon->GetID(), button_size, { 0, 1 }, { 1, 0 });
+                ImGui::ImageButton("##X", (ImTextureID)folder_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();
@@ -92,7 +81,6 @@ namespace OpenEngine {
             }
             ImGui::EndTable();
         }
-        ImGui::Unindent();
         ImGui::PopStyleVar();
 
         ImGui::End();

editor/src/panels/scene_hierarchy.cpp

@@ -1,3 +1,4 @@
+#include "open_engine/scene/components.hpp"
 #include "open_engine/scene/entity.hpp"
 #include "editor_component.hpp"
 
@@ -22,10 +23,6 @@ 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);
 
         scene = context;
         selected_context = {};
@@ -54,26 +51,6 @@ 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();
-            }
     }
 
     void EntityPopup(Ref<Scene>& scene)
@@ -218,17 +195,16 @@ namespace OpenEngine {
     void SceneHierarchy::DrawComponents(Entity& entity)
     {
         auto& reg = scene->GetRegistry();
-        entt::entity handle = entity;
+        entt::entity handle = selected_context;
 
-        if (!entity)
+        if (!selected_context || !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)) {
@@ -252,24 +228,20 @@ namespace OpenEngine {
 
                     if (ImGui::BeginPopup("component_settings")) {
                         if (ImGui::MenuItem("Remove component"))
-                            pending_deletion.emplace_back(id);
+                            component_to_delete.emplace_back(id);
 
                         ImGui::EndPopup();
                     }
 
                     if (opened) {
-                        ImGui::Spacing();
                         drawers[id].draw_func(reg, handle);
-                        ImGui::Spacing();
                         ImGui::TreePop();
                     }
                 }
             }
         }
 
-        for (auto& id : pending_deletion) {
+        for (auto& id : component_to_delete)
             drawers[id].remove_func(reg, entity);
-            pending_deletion.clear();
-        }
     }
 }

imgui.ini

@@ -173,11 +173,11 @@ DockSpace               ID=0x08BD597D Window=0x1BBC0F80 Pos=0,24 Size=1272,1363
             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,964 CentralNode=1 Selected=0xC450F867
+              DockNode  ID=0x00000012 Parent=0x00000010 SizeRef=594,956 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,805 Selected=0x8C72BEA8
-    DockNode            ID=0x00000008 Parent=0x00000006 SizeRef=444,556 Selected=0x5E5F7166
+    DockNode            ID=0x00000007 Parent=0x00000006 SizeRef=444,769 Selected=0x8C72BEA8
+    DockNode            ID=0x00000008 Parent=0x00000006 SizeRef=444,531 Selected=0x5E5F7166
 

open_engine/CMakeLists.txt

@@ -74,5 +74,3 @@ 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

@@ -1,36 +0,0 @@
-#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/imgui/imgui_layer.hpp

@@ -19,7 +19,6 @@ namespace OpenEngine {
             bool CloseWindow(OpenEngine::KeyPressedEvent& event);
 
             void SetBlockEvents(bool block) { block_events = block; };
-            bool GetBlockEvents() { return block_events; };
 
             void Begin();
             void End();

open_engine/include/open_engine/input/input_system.hpp

@@ -2,6 +2,7 @@
 #define INPUT_HPP
 
 #include "open_engine/input/mouse_codes.hpp"
+#include "open_engine/ref_scope.hpp"
 #include "open_engine/input/keycodes.hpp"
 
 #include <string>

open_engine/include/open_engine/physics.hpp

@@ -1,191 +0,0 @@
-#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

open_engine/include/open_engine/renderer/renderer3d.hpp

@@ -10,14 +10,6 @@
 namespace OpenEngine {
 
     // SHOULD BE MOVED ==================================
-
-    enum class PrimitiveType
-    {
-        None = 0,
-        Quad,
-        Cube
-    };
-
     struct MeshVertex
     {
         glm::vec3 position;
@@ -27,15 +19,6 @@ namespace OpenEngine {
         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;
@@ -63,8 +46,7 @@ namespace OpenEngine {
             static void BeginScene(const EditorCamera& camera);
             static void EndScene();
 
-            static void DrawMesh(const Ref<Mesh>& mesh, Material& material,
-                    const glm::mat4& transform);
+            static void DrawMesh(const Ref<Mesh>& mesh, const glm::mat4& transform);
     };
 }
 

open_engine/include/open_engine/renderer/uniform_buffer.hpp

@@ -8,7 +8,7 @@ namespace OpenEngine {
     class UniformBuffer
     {
         public:
-            virtual ~UniformBuffer() = default;
+            virtual ~UniformBuffer() {}
             virtual void SetData(const void* data, uint32_t size,
                     uint32_t offset = 0) = 0;
 

open_engine/include/open_engine/scene/components.hpp

@@ -1,19 +1,12 @@
 #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 <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>
@@ -28,15 +21,6 @@
 
 namespace OpenEngine {
 
-    struct IDComponent
-    {
-        UUID id;
-
-        IDComponent() = default;
-        IDComponent(const IDComponent&) = default;
-        IDComponent(const UUID& uuid) : id(uuid) {};
-    };
-
     struct TagComponent
     {
         std::string tag;
@@ -83,8 +67,6 @@ namespace OpenEngine {
         CameraComponent(const CameraComponent&) = default;
     };
 
-    class NativeScriptableEntity;
-
     struct NativeScriptComponent 
     {
         NativeScriptableEntity* instance = nullptr;
@@ -92,6 +74,9 @@ namespace OpenEngine {
         NativeScriptableEntity* (*InstanciateScript)();
         void (*DestroyInstanceScript)(NativeScriptComponent*);
 
+        void OnImGuiRender(Entity& entity) 
+        {};
+
         template <typename T>
             void Bind()
             {
@@ -101,58 +86,19 @@ 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 };
-    };
-
-    struct SphereShapeComponent
-    {
-        float radius = 1.0f;
-    };
 }
 
 #endif // COMPONENTS_HPP

open_engine/include/open_engine/scene/entity.hpp

@@ -3,8 +3,6 @@
 
 #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>
@@ -50,8 +48,6 @@ 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,7 +1,6 @@
 #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,11 +1,8 @@
 #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>
@@ -19,13 +16,8 @@ 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);
 
@@ -36,24 +28,19 @@ 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> pending_deletion;
+            std::vector<entt::entity> entities_to_be_deleted;
 
             friend class SceneSerializer;
             friend class Entity;

open_engine/src/open_engine/core/uuid.cpp

@@ -1,24 +0,0 @@
-#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/physics.cpp

@@ -1,73 +0,0 @@
-#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);
-    }
-}

open_engine/src/open_engine/renderer/renderer3d.cpp

@@ -176,9 +176,6 @@ namespace OpenEngine {
         };
         TransformData transform_buffer;
         Ref<UniformBuffer> transform_uniform_buffer;
-
-        Material material_buffer;
-        Ref<UniformBuffer> material_uniform_buffer;
     };
 
     static Renderer3DData renderer_data;
@@ -193,7 +190,6 @@ 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);
 
         glEnable(GL_DEBUG_OUTPUT);
         glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
@@ -205,10 +201,8 @@ namespace OpenEngine {
     
     void Renderer3D::Shutdown()
     {
-        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.color_shader_3d.reset();
     }
     
     void Renderer3D::BeginScene(const SceneCamera& camera, const glm::mat4& transform)
@@ -236,8 +230,7 @@ namespace OpenEngine {
 
     }
 
-    void Renderer3D::DrawMesh(const Ref<Mesh>& mesh, Material& material,
-            const glm::mat4& transform)
+    void Renderer3D::DrawMesh(const Ref<Mesh>& mesh, const glm::mat4& transform)
     {
         OE_PROFILE_FUNCTION();
 
@@ -246,9 +239,6 @@ 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());

open_engine/src/open_engine/scene/scene.cpp

@@ -1,113 +1,18 @@
-#include "logging.hpp"
-#include "physics.hpp"
-#include "ref_scope.hpp"
-#include <Jolt/Physics/Body/MotionType.h>
-#include <Jolt/Physics/Collision/ObjectLayer.h>
-#include <Jolt/Physics/Collision/Shape/ConvexShape.h>
+#include <cstdint>
+#include <entt/entity/fwd.hpp>
 #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/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);
-        }
-
-        OE_CORE_ERROR("Entity has no shape component!");
-        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;
 
@@ -121,31 +26,15 @@ namespace OpenEngine {
 
     void Scene::MarkEntityForDeletion(Entity entity)
     {
-        pending_deletion.emplace_back(entity);
+        entities_to_be_deleted.emplace_back(entity);
     }
     
     void Scene::UpdateEntities()
     {
-        for (auto& entity : pending_deletion)
+        for (auto& entity : entities_to_be_deleted)
             DeleteEntity(entity);
 
-        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;
-        }
+        entities_to_be_deleted.clear();
     }
 
     void Scene::OnUpdateRuntime()
@@ -165,40 +54,6 @@ 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 };
         {
@@ -218,15 +73,10 @@ namespace OpenEngine {
 
                 auto view = registry.view<TransformComponent, MeshComponent>();
 
-                for (const auto& e : view) {
-                    auto [transform, mesh] = view.get<TransformComponent, MeshComponent>(e);
-                    Entity entity(e, this);
+                for (const auto& entity : view) {
+                    auto [transform, mesh] = view.get<TransformComponent, MeshComponent>(entity);
 
-                    Material material;
-                    if (entity.HasComponent<MaterialComponent>())
-                        material = entity.GetComponents<MaterialComponent>().material;
-
-                    Renderer3D::DrawMesh(mesh.mesh, material, GetTransformFromComp(transform));
+                    Renderer3D::DrawMesh(mesh.mesh, GetTransformFromComp(transform));
                     /*
                     if (sprite.texture)
                         Renderer2D::DrawQuad(GetTransformFromComp(transform),
@@ -251,14 +101,7 @@ namespace OpenEngine {
         for (const auto& entity : view) {
             auto [transform, mesh] = view.get<TransformComponent, MeshComponent>(entity);
 
-            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));
+            Renderer3D::DrawMesh(mesh.mesh, GetTransformFromComp(transform));
         }
 
 		Renderer3D::EndScene();
@@ -327,29 +170,4 @@ 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)
-	{
-	}
 }

open_engine/src/open_engine/scene/scene_serializer.cpp

@@ -1,9 +1,7 @@
-#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"
 
@@ -88,10 +86,8 @@ namespace OpenEngine {
 
     static void SerializeEntity(YAML::Emitter& out, Entity entity)
     {
-        OE_CORE_ASSERT(entity.HasComponent<IDComponent>(), "Entity is missing UUID.");
-
         out << YAML::BeginMap;
-        out << YAML::Key << "Entity" << YAML::Value << entity.GetUUID(); // Needs random
+        out << YAML::Key << "Entity" << YAML::Value << "412741205"; // Needs random
 
         if (entity.HasComponent<TagComponent>())
         {
@@ -117,7 +113,8 @@ namespace OpenEngine {
             out << YAML::EndMap; // TransformComponent
         }
 
-        if (entity.HasComponent<CameraComponent>()) {
+        if (entity.HasComponent<CameraComponent>())
+        {
             out << YAML::Key << "CameraComponent";
             out << YAML::BeginMap; // CameraComponent
 
@@ -152,68 +149,6 @@ 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 
-        }
-
         out << YAML::EndMap;
     }
 
@@ -260,7 +195,7 @@ namespace OpenEngine {
 		{
 			for (auto entity : entities)
 			{
-				uint64_t uuid = entity["Entity"].as<uint64_t>();
+				uint64_t uuid = entity["Entity"].as<uint64_t>(); // TODO
 
 				std::string name;
 				auto tagComponent = entity["TagComponent"];
@@ -269,7 +204,7 @@ namespace OpenEngine {
 
 				OE_CORE_TRACE("Deserialized entity with ID = {0}, name = {1}", uuid, name);
 
-				Entity deserializedEntity = context->CreateEntityWithUUID(uuid, name);
+				Entity deserializedEntity = context->CreateEntity(name);
 
 				auto transformComponent = entity["TransformComponent"];
 				if (transformComponent)
@@ -306,66 +241,6 @@ namespace OpenEngine {
 					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>();
-                }
 			}
 		}
 

untitled_persp.oes

@@ -0,0 +1,47 @@
+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