Inspector refactor (#66)

* Move SceneResources to dedicated header

- Make mut and const versions.

* WIP: Inspector refactor

* WIP: contd

* Remove old inspector

* Enable adding new materials and meshes

* Cleanup

* Use typeid::name() for payload type

- Add docs.

* Split Inspector, add docs

- `ResourceInspector`: unframed nodes.
- `SceneInspector`: framed nodes.

* Enable orientation reset

- Fixup default sizes and positions of editor windows.

Author: karnkaul

lib/engine/CMakeLists.txt

@@ -42,8 +42,10 @@ target_sources(${PROJECT_NAME} PRIVATE
 
   include/${target_prefix}/engine/editor/browse_file.hpp
   include/${target_prefix}/engine/editor/common.hpp
+  include/${target_prefix}/engine/editor/drag_drop_id.hpp
   include/${target_prefix}/engine/editor/inspector.hpp
   include/${target_prefix}/engine/editor/log.hpp
+  include/${target_prefix}/engine/editor/reflector.hpp
   include/${target_prefix}/engine/editor/scene_tree.hpp
 
   src/scene_renderer.cpp
@@ -53,5 +55,6 @@ target_sources(${PROJECT_NAME} PRIVATE
   src/editor/common.cpp
   src/editor/inspector.cpp
   src/editor/log.cpp
+  src/editor/reflector.cpp
   src/editor/scene_tree.cpp
 )

lib/engine/include/facade/engine/editor/common.hpp

@@ -11,6 +11,20 @@ class Engine;
 }
 
 namespace facade::editor {
+///
+/// \brief Obtain the maximum width and height of a number of ImGui Texts.
+/// \param strings Array of C strings to compute sizes of
+/// \returns Maximum width and height (independent) of all strings
+///
+glm::vec2 max_size(std::span<char const* const> strings);
+
+///
+/// \brief Create a small red button.
+/// \param label Label on the button
+/// \returns true if clicked
+///
+bool small_button_red(char const* label);
+
 ///
 /// \brief Base class for RAII Dear ImGui wrappers whose widgets return a boolean on Begin()
 ///

lib/engine/include/facade/engine/editor/drag_drop_id.hpp

@@ -0,0 +1,111 @@
+#pragma once
+#include <imgui.h>
+#include <facade/engine/editor/common.hpp>
+#include <facade/scene/node.hpp>
+#include <facade/util/fixed_string.hpp>
+#include <optional>
+#include <typeinfo>
+
+namespace facade::editor {
+///
+/// \brief Initiate dragging an Id<T> drag-drop payload.
+/// \param out Id to store as the drag-drop payload
+/// \param label Label to display on drag
+/// \returns true if dragging is engaged
+///
+template <typename T>
+bool drag_payload(Id<T> id, char const* label) {
+	if (ImGui::BeginDragDropSource()) {
+		ImGui::SetDragDropPayload(typeid(id).name(), &id, sizeof(id));
+		if (label && *label) { ImGui::Text("%s", label); }
+		ImGui::EndDragDropSource();
+		return true;
+	}
+	return false;
+}
+
+///
+/// \brief Accept dropping an Id<T> drag-drop payload.
+/// \param out Id to write payload to
+/// \returns true if payload accepted
+///
+template <typename T>
+bool accept_drop(Id<T>& out) {
+	if (ImGui::BeginDragDropTarget()) {
+		if (ImGuiPayload const* payload = ImGui::AcceptDragDropPayload(typeid(out).name())) {
+			assert(payload->DataSize == sizeof(out));
+			out = *reinterpret_cast<Id<T>*>(payload->Data);
+			return true;
+		}
+		ImGui::EndDragDropTarget();
+	}
+	return false;
+}
+
+///
+/// \brief Create a potentially nullable drag-drop Id slot.
+/// \param out_id Id to use for drag-drop payload
+/// \param label Label to use for the slot
+/// \param payload_name Label to use when dragging payload
+/// \param removable Whether to allow nulling out out_id
+///
+template <typename T>
+void make_id_slot(std::optional<Id<T>>& out_id, char const* label, char const* payload_name, Bool removable) {
+	ImGui::Text("%s", label);
+	if (out_id) {
+		if (removable) {
+			ImGui::SameLine();
+			if (small_button_red(FixedString{"x###remove_{}", label}.c_str())) {
+				out_id = {};
+				return;
+			}
+		}
+		ImGui::SameLine();
+		auto const name = FixedString{"{} ({})", payload_name, *out_id};
+		ImGui::Selectable(name.c_str());
+		drag_payload(*out_id, name.c_str());
+		accept_drop(*out_id);
+	} else {
+		ImGui::SameLine();
+		ImGui::Selectable("[None]");
+		auto id = Id<T>{};
+		if (accept_drop(id)) { out_id = id; }
+	}
+}
+
+///
+/// \brief Create a drag-drop Id slot.
+/// \param out_id Id to use for drag-drop payload
+/// \param label Label to use for the slot
+/// \param payload_name Label to use when dragging payload
+///
+template <typename T>
+void make_id_slot(Id<T>& out_id, char const* label, char const* payload_name) {
+	auto id = std::optional<Id<T>>{out_id};
+	make_id_slot(id, label, payload_name, {false});
+	out_id = *id;
+}
+
+///
+/// \brief Create a drag-drop Id slot.
+/// \param out_node Node to attach / detach Id<T> drag-drop payloads to / from
+/// \param label Label to use for the slot
+/// \param payload_name Label to use when dragging payload
+///
+template <typename T>
+void make_id_slot(Node& out_node, char const* label, char const* payload_name) {
+	auto oid = std::optional<Id<T>>{};
+	auto* id = out_node.find<Id<T>>();
+	if (id) { oid = *id; }
+	make_id_slot(oid, label, payload_name, {true});
+	if (id) {
+		if (!oid) {
+			out_node.detach<Id<T>>();
+		} else {
+			*id = *oid;
+		}
+	} else {
+		if (oid) { out_node.attach(*oid); }
+	}
+}
+} // namespace facade::editor

lib/engine/include/facade/engine/editor/inspector.hpp

@@ -1,84 +1,112 @@
 #pragma once
 #include <facade/engine/editor/common.hpp>
-#include <facade/scene/material.hpp>
-#include <facade/scene/node.hpp>
-#include <facade/util/nvec3.hpp>
-#include <facade/util/rgb.hpp>
-#include <limits>
+#include <facade/scene/scene.hpp>
 
-namespace facade {
-struct Camera;
-struct Mesh;
-struct Lights;
-struct SceneResources;
-class Scene;
-
-namespace editor {
+namespace facade::editor {
+///
+/// \brief Base class for Inspectors.
 ///
-/// \brief Stateless ImGui helper to inspect / reflect various properties
+/// Inspectors are stateless ImGui helpers to view / edit various components, with drag-and-drop support.
 ///
 class Inspector {
-  public:
-	static constexpr auto min_v{-std::numeric_limits<float>::max()};
-	static constexpr auto max_v{std::numeric_limits<float>::max()};
-
+  protected:
 	///
-	/// \brief Construct an Inspector instance
+	/// \brief Construct an Inspector instance.
 	///
 	/// Inspectors don't do anything on construction, constructors exist to enforce invariants instance-wide.
-	/// For all Inspectors, an existing Window target is required, Inspector instances will not create any
+	/// For all Inspectors, an existing Window target is required, Inspector instances will not create any.
 	///
-	Inspector(NotClosed<Window>) {}
-
-	bool inspect(char const* label, glm::vec2& out_vec2, float speed = 1.0f, float lo = min_v, float hi = max_v) const;
-	bool inspect(char const* label, glm::vec3& out_vec3, float speed = 1.0f, float lo = min_v, float hi = max_v) const;
-	bool inspect(char const* label, glm::vec4& out_vec4, float speed = 1.0f, float lo = min_v, float hi = max_v) const;
-	bool inspect(char const* label, nvec3& out_vec3, float speed = 0.01f) const;
-	bool inspect(char const* label, glm::quat& out_quat) const;
-	bool inspect_rgb(char const* label, glm::vec3& out_rgb) const;
-	bool inspect(char const* label, Rgb& out_rgb) const;
-	bool inspect(Transform& out_transform, Bool& out_unified_scaling) const;
-	bool inspect(std::span<Transform> out_instances, Bool unfied_scaling) const;
-	bool inspect(Lights& out_lights) const;
+	Inspector(NotClosed<Window> target, Scene& out_scene) : m_target(target), m_scene(out_scene), m_resources(out_scene.resources()) {}
 
-  private:
-	bool do_inspect(Transform& out_transform, Bool& out_unified_scaling, Bool scaling_toggle) const;
+	NotClosed<Window> m_target;
+	Scene& m_scene;
+	SceneResourcesMut m_resources;
 };
 
-class SceneInspector : public Inspector {
+///
+/// \brief Inspector for resources in a Scene.
+///
+/// Provides drag source (and target) for each resource viewed (and edited).
+///
+class ResourceInspector : public Inspector {
   public:
-	using Inspector::inspect;
-
-	SceneInspector(NotClosed<Window> target, Scene& scene);
+	ResourceInspector(NotClosed<Window> target, Scene& out_scene) : Inspector(target, out_scene) {}
 
-	bool inspect(NotClosed<TreeNode>, UnlitMaterial& out_material) const;
-	bool inspect(NotClosed<TreeNode> node, LitMaterial& out_material) const;
-	bool inspect(Id<Material> material_id) const;
-	bool inspect(Id<Mesh> mesh_id) const;
-	bool inspect(Id<Camera> camera_id) const;
-
-	bool inspect(Id<Node> node_id, Bool& out_unified_scaling) const;
+	///
+	/// \brief Inspect a Texture (read-only).
+	/// \param texture Texture to inspect
+	/// \param id Id of the Texture being inspected (used to create unique labels and drag payloads)
+	///
+	void view(Texture const& texture, Id<Texture> id) const;
+	///
+	/// \brief Inspect a StaticMesh (read-only).
+	/// \param mesh the StaticMesh to inspect
+	/// \param id Id of the StaticMesh being inspected (used to create unique labels and drag payloads)
+	///
+	void view(StaticMesh const& mesh, Id<StaticMesh> id) const;
 
-  private:
-	Scene& m_scene;
-	NotClosed<Window> m_target;
+	///
+	/// \brief Inspect a Material.
+	/// \param out_material Material to inspect
+	/// \param id Id of the Material being inspected (used to create unique labels and drag payloads)
+	///
+	void edit(Material& out_material, Id<Material> id) const;
+	///
+	/// \brief Inspect a Mesh.
+	/// \param out_mesh Mesh to inspect
+	/// \param id Id of the Mesh being inspected (used to create unique labels and drag payloads)
+	///
+	void edit(Mesh& out_mesh, Id<Mesh> id) const;
 };
 
-class ResourceInspector {
+///
+/// \brief Inspector for Scene and its Nodes.
+///
+/// Provides drag-and-drop support where applicable.
+/// Uses a framed TreeNode for each top level component.
+///
+class SceneInspector : public Inspector {
   public:
-	ResourceInspector(NotClosed<Window>, SceneResources const& resources);
-
-	void display() const;
-	void display(Camera const& camera, std::size_t index, std::string_view prefix = {}) const;
-	void display(Texture const& texture, std::size_t index, std::string_view prefix = {}) const;
-	void display(Material const& material, std::size_t const index, std::string_view prefix = {}) const;
-	void display(Mesh const& mesh, std::size_t const index, std::string_view prefix = {}) const;
-
-  private:
-	void display(LitMaterial const& lit) const;
-	void display(UnlitMaterial const& unlit) const;
+	SceneInspector(NotClosed<Window> target, Scene& out_scene) : Inspector(target, out_scene) {}
 
-	SceneResources const& m_resources;
+	///
+	/// \brief View/edit all resources.
+	/// \param out_name_buf Persistent buffer for popups
+	///
+	/// Uses ResourceInspector.
+	///
+	void resources(std::string& out_name_buf) const;
+	///
+	/// \brief Inspect the Scene's camera.
+	///
+	void camera() const;
+	///
+	/// \brief Inspect the Scene's lights.
+	///
+	void lights() const;
+	///
+	/// \brief Inspect a Node's Transform.
+	/// \param out_node Node whose Transform to inspect
+	/// \param out_unified_scaling Whether to use a single locked control for scale
+	///
+	void transform(Node& out_node, Bool& out_unified_scaling) const;
+	///
+	/// \brief Inspect a Node's instances.
+	/// \param out_node Node whose instances to inspect
+	/// \param unified_scaling Whether to use a single locked control for scale
+	///
+	void instances(Node& out_node, Bool unified_scaling) const;
+	///
+	/// \brief Inspect a Node's Id<Mesh>.
+	/// \param out_node Node whose attachment to inspect
+	///
+	void mesh(Node& out_node) const;
+	///
+	/// \brief Inspect a Node and its attachments.
+	/// \param node_id Id of Node to inspect
+	///
+	/// Inspects Transform, instances, and Id<Mesh>.
+	///
+	void node(Id<Node> node_id, Bool& out_unified_scaling) const;
 };
-} // namespace editor
-} // namespace facade
+} // namespace facade::editor

lib/engine/include/facade/engine/editor/reflector.hpp

@@ -0,0 +1,40 @@
+#pragma once
+#include <facade/engine/editor/common.hpp>
+#include <facade/scene/camera.hpp>
+#include <facade/util/nvec3.hpp>
+#include <facade/util/rgb.hpp>
+#include <facade/util/transform.hpp>
+#include <glm/gtc/quaternion.hpp>
+
+namespace facade::editor {
+///
+/// \brief Stateless ImGui helper to reflect various properties.
+///
+class Reflector {
+  public:
+	struct AsRgb {
+		glm::vec3& out;
+	};
+
+	static constexpr auto min_v{-std::numeric_limits<float>::max()};
+	static constexpr auto max_v{std::numeric_limits<float>::max()};
+
+	///
+	/// \brief Construct an Reflector instance.
+	///
+	/// Reflectors don't do anything on construction, constructors exist to enforce invariants instance-wide.
+	/// For all Reflectors, an existing Window target is required, Reflector instances will not create any
+	///
+	Reflector(NotClosed<Window>) {}
+
+	bool operator()(char const* label, glm::vec2& out_vec2, float speed = 1.0f, float lo = min_v, float hi = max_v) const;
+	bool operator()(char const* label, glm::vec3& out_vec3, float speed = 1.0f, float lo = min_v, float hi = max_v) const;
+	bool operator()(char const* label, glm::vec4& out_vec4, float speed = 1.0f, float lo = min_v, float hi = max_v) const;
+	bool operator()(char const* label, nvec3& out_vec3, float speed = 0.01f) const;
+	bool operator()(char const* label, glm::quat& out_quat) const;
+	bool operator()(char const* label, AsRgb out_rgb) const;
+	bool operator()(Rgb& out_rgb) const;
+	bool operator()(Transform& out_transform, Bool& out_unified_scaling, Bool scaling_toggle) const;
+	bool operator()(Camera& out_camera) const;
+};
+} // namespace facade::editor

lib/engine/src/editor/common.cpp

@@ -3,6 +3,26 @@
 #include <cassert>
 
 namespace facade::editor {
+glm::vec2 max_size(std::span<char const* const> strings) {
+	auto ret = glm::vec2{};
+	for (auto const* str : strings) {
+		auto const size = ImGui::CalcTextSize(str);
+		ret.x = std::max(ret.x, size.x);
+		ret.y = std::max(ret.y, size.y);
+	}
+	return ret;
+}
+
+bool small_button_red(char const* label) {
+	bool ret = false;
+	ImGui::PushStyleColor(ImGuiCol_Button, {0.8f, 0.0f, 0.1f, 1.0f});
+	ImGui::PushStyleColor(ImGuiCol_ButtonHovered, {1.0f, 0.0f, 0.1f, 1.0f});
+	ImGui::PushStyleColor(ImGuiCol_ButtonActive, {0.6f, 0.0f, 0.1f, 1.0f});
+	if (ImGui::SmallButton(label)) { ret = true; }
+	ImGui::PopStyleColor(3);
+	return ret;
+}
+
 Openable::Openable(bool is_open) : m_open(is_open) {}
 
 Window::Window(char const* label, bool* open_if, int flags) : Canvas(ImGui::Begin(label, open_if, flags)) {}