anfer/OpenEngine
1
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Erris
2026-02-24 15:29:29 +01:00
parent 0bbfe41117
commit 38b92611be
7 changed files with 205 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
editor/include/editor.hpp
View File

@@ -3,12 +3,6 @@
#include <open_engine.hpp>
#include "open_engine/events/mouse_event.hpp"
#include "open_engine/input/input_system.hpp"
#include "open_engine/input/mouse_codes.hpp"
#include "open_engine/renderer/render_command.hpp"
#include "open_engine/renderer/renderer2d.hpp"
#include "open_engine/scene/components.hpp"
#include "panels/scene_hierarchy.hpp"
#include <glm/ext/matrix_transform.hpp>
@@ -94,7 +88,7 @@ namespace OpenEngine {
}
*/
scene_hierarchy.SetContext(scene);
scene_hierarchy.Init(scene);
}
void OnDetach() override
@@ -364,7 +358,7 @@ namespace OpenEngine {
if (!file.empty()) {
scene = CreateRef<Scene>();
scene->OnViewportResize((uint32_t)viewport_size.x, (uint32_t)viewport_size.y);
scene_hierarchy.SetContext(scene);
scene_hierarchy.Init(scene);
SceneSerializer serializer(scene);
serializer.Deserialize(file);
@@ -373,7 +367,7 @@ namespace OpenEngine {
if (ImGui::MenuItem("New Scene", "Ctrl+N")) {
scene = CreateRef<Scene>();
scene->OnViewportResize((uint32_t)viewport_size.x, (uint32_t)viewport_size.y);
scene_hierarchy.SetContext(scene);
scene_hierarchy.Init(scene);
}
ImGui::Separator();
if (ImGui::MenuItem("Exit"))

27
editor/include/editor_component.hpp Normal file
View File

@@ -0,0 +1,27 @@
#ifndef EDITOR_COMPONENT_HPP
#define EDITOR_COMPONENT_HPP
#include "open_engine/scene/components.hpp"
#include <entt/entity/fwd.hpp>
#include <imgui.h>
namespace OpenEngine {
/*
void DrawVec3Control(const char* label, glm::vec3& values,
float reset_value = 0.0f, float column_width = 100.0f,
const std::array<const char*, 3> labels = {"x", "y", "z"});
*/
void TagOnImGuiRender(entt::registry& registry, entt::entity entity);
void TransformOnImGuiRender(entt::registry& registry, entt::entity entity);
void SpriteOnImGuiRender(entt::registry& registry, entt::entity entity);
void CameraOnImGuiRender(entt::registry& registry, entt::entity entity);
}
#endif // EDITOR_COMPONENT_HPP

26
editor/include/panels/scene_hierarchy.hpp
View File

@@ -1,17 +1,27 @@
#ifndef SCENE_HIERARCHY_HPP
#define SCENE_HIERARCHY_HPP
#include "imgui.h"
#include <entt/core/fwd.hpp>
#include <entt/entity/fwd.hpp>
#include <open_engine.hpp>
namespace OpenEngine {
using ComponentDrawer = std::function<void(entt::registry&, entt::entity)>;
struct ComponentUI {
std::string name;
std::function<void(entt::registry&, entt::entity)> draw_func;
std::function<void(entt::registry&, entt::entity)> remove_func;
};
class SceneHierarchy
{
public:
SceneHierarchy() = default;
SceneHierarchy(const Ref<Scene>& scene);
void SetContext(const Ref<Scene>& scene);
void Init(const Ref<Scene>& scene);
void OnImGuiRender();
@@ -22,6 +32,7 @@ namespace OpenEngine {
void DrawEntityNode(Entity& entity);
void DrawComponents(Entity& entity);
/*
template <typename T>
void DrawComponentDrawer(Entity& entity, const char* header)
{
@@ -62,8 +73,19 @@ namespace OpenEngine {
if (component_marked_deletion)
entity.RemoveComponents<T>();
}
*/
private:
template<typename T>
static void RegisterDrawer(const std::string& name, std::function<void(entt::registry&, entt::entity)> func) {
drawers[entt::type_id<T>().hash()] = {
name,
func,
[](entt::registry& reg, entt::entity ent) { reg.remove<T>(ent); }
};
}
inline static std::map<entt::id_type, ComponentUI> drawers;
Ref<Scene> scene;
Entity selected_context, renamed_entity;
double last_selected_time = 10.0;

86
editor/src/editor_component.cpp Normal file
View File

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

64
editor/src/panels/scene_hierarchy.cpp
View File

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

1
open_engine/include/open_engine.hpp
View File

@@ -12,7 +12,6 @@
#include "open_engine/scene/native_scriptable_entity.hpp"
#include "open_engine/scene/scene_serializer.hpp"
#include "open_engine/scene/components.hpp"
#include "open_engine/scene/components.hpp"
#include "open_engine/core/file_dialogs.hpp"
#include "open_engine/core/time.hpp"

78
open_engine/include/open_engine/scene/components.hpp
View File

@@ -31,17 +31,6 @@ namespace OpenEngine {
TagComponent(const TagComponent&) = default;
TagComponent(const std::string& tag)
: tag(tag) {}
void OnImGuiRender(Entity& entity)
{
char buffer[256];
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;
};
};
struct TransformComponent
@@ -64,15 +53,6 @@ namespace OpenEngine {
return transform;
};
void OnImGuiRender(Entity& entity)
{
DrawVec3Control("Position", translation);
glm::vec3 rotation_comp = glm::degrees(rotation);
DrawVec3Control("Rotation", rotation_comp);
rotation = glm::radians(rotation_comp);
DrawVec3Control("Scale", scale);
};
};
struct SpriteRendererComponent
@@ -83,11 +63,6 @@ namespace OpenEngine {
SpriteRendererComponent(const SpriteRendererComponent&) = default;
SpriteRendererComponent(const glm::vec4& color)
: color(color) {}
void OnImGuiRender(Entity& entity)
{
ImGui::ColorEdit4("color", glm::value_ptr(color));
};
};
struct CameraComponent
@@ -98,56 +73,6 @@ namespace OpenEngine {
CameraComponent() = default;
CameraComponent(const CameraComponent&) = default;
void OnImGuiRender(Entity& entity)
{
ImGui::Checkbox("Is primary", &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", &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);
}
};
};
struct NativeScriptComponent
@@ -157,6 +82,9 @@ namespace OpenEngine {
NativeScriptableEntity* (*InstanciateScript)();
void (*DestroyInstanceScript)(NativeScriptComponent*);
void OnImGuiRender(Entity& entity)
{};
template <typename T>
void Bind()
{