extracting ui render function from the ECS components. Adding dynamic component display

editor/src/editor_component.cpp

@@ -0,0 +1,86 @@
+#include <editor_component.hpp>
+#include <open_engine.hpp>
+
+namespace OpenEngine {
+
+    void TagOnImGuiRender(entt::registry& registry, entt::entity entity)
+    {
+        char buffer[256];
+
+        auto& tag = registry.get<TagComponent>(entity).tag;
+        std::memset(buffer, 0, sizeof(buffer));
+        std::strncpy(buffer, tag.c_str(), sizeof(buffer));
+
+        if (ImGui::InputText("##tagEditor", buffer, sizeof(buffer), ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_AutoSelectAll)
+                || (!ImGui::IsItemActive() && ImGui::IsMouseClicked(0)))
+            tag = buffer;
+    };
+
+    void TransformOnImGuiRender(entt::registry& registry, entt::entity entity) 
+    {
+        auto& transform = registry.get<TransformComponent>(entity);
+        DrawVec3Control("Position", transform.translation);
+        glm::vec3 rotation_comp = glm::degrees(transform.rotation);
+        DrawVec3Control("Rotation", rotation_comp);
+        transform.rotation = glm::radians(rotation_comp);
+        DrawVec3Control("Scale", transform.scale);
+    };
+    
+    void SpriteOnImGuiRender(entt::registry& registry, entt::entity entity) 
+    {
+        auto& sprite = registry.get<SpriteRendererComponent>(entity);
+        ImGui::ColorEdit4("color", glm::value_ptr(sprite.color));
+    };
+
+    void CameraOnImGuiRender(entt::registry& registry, entt::entity entity) 
+    {
+        auto& camera_comp = registry.get<CameraComponent>(entity);
+        auto& camera = camera_comp.camera;
+        ImGui::Checkbox("Is primary", &camera_comp.primary);
+        const char* projection_type_strings[] = {"Perspective", "Orthographic"};
+        const char* current_projection_type = projection_type_strings[(int)camera.GetProjectionType()];
+
+        if (ImGui::BeginCombo("Projection", current_projection_type)) {
+            for (int i = 0; i < 2; i++) {
+                bool is_selected = current_projection_type == projection_type_strings[i];
+                if (ImGui::Selectable(projection_type_strings[i], is_selected)) {
+                    current_projection_type = projection_type_strings[i];
+                    camera.SetProjectionType((SceneCamera::ProjectionType)i);
+                }
+
+                if (is_selected)
+                    ImGui::SetItemDefaultFocus();
+            }
+            ImGui::EndCombo();
+        }
+
+        if (camera.GetProjectionType() == SceneCamera::ProjectionType::Perspective) {
+            float fov = camera.GetVerticalFov();
+            if (ImGui::DragFloat("Fov", &fov, 0.1f))
+                camera.SetVerticalFov(fov);
+
+            float near_clip = camera.GetPerspectiveNearClip();
+            if (ImGui::DragFloat("Near clip", &near_clip, 0.1f))
+                camera.SetPerspectiveNearClip(near_clip);
+
+            float far_clip = camera.GetPerspectiveFarClip();
+            if (ImGui::DragFloat("Far clip", &far_clip, 0.1f))
+                camera.SetPerspectiveFarClip(far_clip);
+        }
+        else if (camera.GetProjectionType() == SceneCamera::ProjectionType::Orthographic) {
+            ImGui::Checkbox("Has fixed aspect ratio", &camera_comp.fixed_aspect_ratio);
+            float ortho_size = camera.GetOrthographicSize();
+            if (ImGui::DragFloat("Orthographic size", &ortho_size, 0.1f))
+                camera.SetOrthographicSize(ortho_size);
+
+            float near_clip = camera.GetOrthographicNearClip();
+            if (ImGui::DragFloat("Near clip", &near_clip, 0.1f))
+                camera.SetOrthographicNearClip(near_clip);
+
+            float far_clip = camera.GetOrthographicFarClip();
+            if (ImGui::DragFloat("Far clip", &far_clip, 0.1f))
+                camera.SetOrthographicFarClip(far_clip);
+        }
+
+    };
+}

editor/src/panels/scene_hierarchy.cpp

@@ -1,5 +1,7 @@
 #include "open_engine/scene/components.hpp"
 #include "open_engine/scene/entity.hpp"
+#include "editor_component.hpp"
+
 #include <panels/scene_hierarchy.hpp>
 
 #include <cstring>
@@ -7,13 +9,20 @@
 #include <imgui.h>
 
 namespace OpenEngine {
+
+    using ComponentDrawer = std::function<void(entt::registry&, entt::entity)>;
+
     SceneHierarchy::SceneHierarchy(const Ref<Scene>& scene)
         : scene(scene)
     {
     }
 
-    void SceneHierarchy::SetContext(const Ref<Scene>& context)
+    void SceneHierarchy::Init(const Ref<Scene>& context)
     {
+        RegisterDrawer<TransformComponent>("Transform", &TransformOnImGuiRender);
+        RegisterDrawer<SpriteRendererComponent>("Sprite Renderer", &SpriteOnImGuiRender);
+        RegisterDrawer<CameraComponent>("Camera", &CameraOnImGuiRender);
+
         scene = context;
         selected_context = {};
     }
@@ -184,11 +193,54 @@ namespace OpenEngine {
 
     void SceneHierarchy::DrawComponents(Entity& entity)
     {
-        if (entity.HasComponent<TagComponent>())
-            entity.GetComponents<TagComponent>().OnImGuiRender(entity);
+        auto& reg = scene->GetRegistry();
+        entt::entity handle = selected_context;
 
-        DrawComponentDrawer<TransformComponent>(entity, "Transform");
-        DrawComponentDrawer<SpriteRendererComponent>(entity, "Sprite");
-        DrawComponentDrawer<CameraComponent>(entity, "Camera");
+        if (!selected_context)
+            return;
+
+        entity.GetComponents<TagComponent>();
+        TagOnImGuiRender(reg, entity);
+
+        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)) {
+                if (drawers.contains(id)) {
+                    bool component_marked_deletion = false;
+                    ImVec2 region_available = ImGui::GetContentRegionAvail();
+                    ImGuiTreeNodeFlags tree_node_flags = ImGuiTreeNodeFlags_DefaultOpen
+                        | ImGuiTreeNodeFlags_Framed
+                        | ImGuiTreeNodeFlags_AllowOverlap;
+                    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2{ 4, 4 });
+                    float line_height = ImGui::GetFontSize() + ImGui::GetStyle().FramePadding.y * 2.0f;
+
+                    bool opened = ImGui::TreeNodeEx((void*)(intptr_t)id, tree_node_flags, "%s", drawers[id].name.c_str());
+                    ImGui::SameLine(region_available.x - line_height * 0.5f);
+
+                    ImGui::PushStyleColor(ImGuiCol_Button, { 0.290f, 0.301f, 0.388f, 1.0f });
+                    if (ImGui::Button("...", ImVec2{ line_height, line_height }))
+                        ImGui::OpenPopup("component_settings");
+                    ImGui::PopStyleColor();
+
+                    ImGui::PopStyleVar();
+
+                    if (ImGui::BeginPopup("component_settings")) {
+                        if (ImGui::MenuItem("Remove component"))
+                            component_to_delete.emplace_back(id);
+
+                        ImGui::EndPopup();
+                    }
+
+                    if (opened) {
+                        drawers[id].draw_func(reg, handle);
+                        ImGui::TreePop();
+                    }
+                }
+            }
+        }
+
+        for (auto& id : component_to_delete)
+            drawers[id].remove_func(reg, entity);
     }
 }