Inspect DirLights in editor

- Put dir lights in `Lights`, inspect whole struct.
- Fix `Buffer` views not using data size (instead whole size of buffer).
- Fix RGB inspection: discard intensity when editing colour.
- Allow adding / removing lights (at least one must remain).

Author: karnkaul

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

@@ -8,6 +8,7 @@
 
 namespace facade {
 struct Mesh;
+struct Lights;
 class Scene;
 
 namespace editor {
@@ -36,6 +37,7 @@ class Inspector {
 	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;
 
   private:
 	bool do_inspect(Transform& out_transform, Bool& out_unified_scaling, Bool scaling_toggle) const;
@@ -47,13 +49,13 @@ class SceneInspector : public Inspector {
 
 	SceneInspector(NotClosed<Window> target, Scene& scene);
 
-	bool inspect(TreeNode const& node, UnlitMaterial& out_material) const;
-	bool inspect(TreeNode const& node, LitMaterial& out_material) const;
+	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<Node> node_id, Bool& out_unified_scaling) const;
-
 	bool inspect(Id<Mesh> mesh) const;
 
+	bool inspect(Id<Node> node_id, Bool& out_unified_scaling) const;
+
   private:
 	Scene& m_scene;
 };

lib/engine/src/editor/inspector.cpp

@@ -83,8 +83,11 @@ bool Inspector::inspect_rgb(char const* label, glm::vec3& out_rgb) const {
 bool Inspector::inspect(char const* label, Rgb& out_rgb) const {
 	auto ret = Modified{};
 	if (auto tn = TreeNode{label}) {
-		auto vec3 = out_rgb.to_vec3();
-		if (inspect_rgb("RGB", vec3)) { ret.value = true; }
+		auto vec3 = Rgb{.channels = out_rgb.channels, .intensity = 1.0f}.to_vec3();
+		if (inspect_rgb("RGB", vec3)) {
+			out_rgb = Rgb::make(vec3, out_rgb.intensity);
+			ret.value = true;
+		}
 		ret(ImGui::DragFloat("Intensity", &out_rgb.intensity, 0.05f, 0.1f, 1000.0f));
 	}
 	return ret.value;
@@ -106,6 +109,42 @@ bool Inspector::inspect(std::span<Transform> out_instances, Bool unified_scaling
 	return ret.value;
 }
 
+bool Inspector::inspect(Lights& out_lights) const {
+	if (out_lights.dir_lights.empty()) { return false; }
+	auto ret = Modified{};
+	auto to_remove = std::optional<std::size_t>{};
+	bool allow_removal = out_lights.dir_lights.size() > 1;
+	auto inspect_dir_light = [&](DirLight& out_light, std::size_t index) {
+		auto tn = TreeNode{FixedString{"[{}]", index}.c_str()};
+		if (allow_removal) {
+			ImGui::SameLine(ImGui::GetWindowContentRegionWidth() - 10.0f);
+			static constexpr auto colour_v = ImVec4{0.8f, 0.0f, 0.1f, 1.0f};
+			ImGui::PushStyleColor(ImGuiCol_Button, colour_v);
+			ImGui::PushStyleColor(ImGuiCol_ButtonHovered, colour_v);
+			ImGui::PushStyleColor(ImGuiCol_ButtonActive, colour_v);
+			if (ImGui::SmallButton("x")) { to_remove = index; }
+			ImGui::PopStyleColor(3);
+		}
+		if (tn) {
+			ret(inspect("Direction", out_light.direction));
+			ret(inspect("Albedo", out_light.rgb));
+		}
+	};
+	if (ImGui::CollapsingHeader("DirLights")) {
+		for (auto [light, index] : enumerate(out_lights.dir_lights.span())) { inspect_dir_light(light, index); }
+	}
+	if (to_remove) {
+		auto replace = decltype(out_lights.dir_lights){};
+		for (auto const [light, index] : enumerate(out_lights.dir_lights.span())) {
+			if (index == *to_remove) { continue; }
+			replace.insert(light);
+		}
+		out_lights.dir_lights = std::move(replace);
+	}
+	if (out_lights.dir_lights.size() < Lights::max_lights_v && ImGui::Button("[+]")) { out_lights.dir_lights.insert(DirLight{}); }
+	return ret.value;
+}
+
 bool Inspector::do_inspect(Transform& out_transform, Bool& out_unified_scaling, Bool scaling_toggle) const {
 	auto ret = Modified{};
 	auto vec3 = out_transform.position();
@@ -127,15 +166,13 @@ bool Inspector::do_inspect(Transform& out_transform, Bool& out_unified_scaling,
 
 SceneInspector::SceneInspector(NotClosed<Window> target, Scene& scene) : Inspector(target), m_scene(scene) {}
 
-bool SceneInspector::inspect([[maybe_unused]] TreeNode const& node, UnlitMaterial& out_material) const {
-	assert(node.is_open());
+bool SceneInspector::inspect(NotClosed<TreeNode>, UnlitMaterial& out_material) const {
 	auto ret = Modified{};
 	ret(inspect("Tint", out_material.tint, 0.01f, 0.0f, 1.0f));
 	return ret.value;
 }
 
-bool SceneInspector::inspect([[maybe_unused]] TreeNode const& node, LitMaterial& out_material) const {
-	assert(node.is_open());
+bool SceneInspector::inspect(NotClosed<TreeNode>, LitMaterial& out_material) const {
 	auto ret = Modified{};
 	ret(ImGui::SliderFloat("Metallic", &out_material.metallic, 0.0f, 1.0f));
 	ret(ImGui::SliderFloat("Roughness", &out_material.roughness, 0.0f, 1.0f));
@@ -168,29 +205,28 @@ bool SceneInspector::inspect(Id<Material> material_id) const {
 	return false;
 }
 
-bool SceneInspector::inspect(Id<Node> node_id, Bool& out_unified_scaling) const {
-	auto ret = Modified{};
-	auto* node = m_scene.find(node_id);
-	if (!node) { return false; }
-	ret(inspect(node->transform, out_unified_scaling));
-	ret(inspect(node->instances, out_unified_scaling));
-	if (auto const* mesh_id = node->find<Id<Mesh>>()) { ret(inspect(*mesh_id)); }
-	return ret.value;
-}
-
 bool SceneInspector::inspect(Id<Mesh> mesh_id) const {
 	auto ret = Modified{};
 	auto* mesh = m_scene.find(mesh_id);
 	if (!mesh) { return ret.value; }
 	if (ImGui::CollapsingHeader(FixedString{"Mesh ({})###Mesh", mesh_id}.c_str())) {
-		for (std::size_t i = 0; i < mesh->primitives.size(); ++i) {
-			if (auto tn = TreeNode{FixedString{"Primitive [{}]", i}.c_str()}) {
-				auto const& primitive = mesh->primitives[i];
+		for (auto [primitive, index] : enumerate(mesh->primitives)) {
+			if (auto tn = TreeNode{FixedString{"Primitive [{}]", index}.c_str()}) {
 				TreeNode::leaf(FixedString{"Static Mesh ({})", primitive.static_mesh}.c_str());
 				if (primitive.material) { ret(inspect(*primitive.material)); }
 			}
 		}
 	}
 	return ret.value;
 }
+
+bool SceneInspector::inspect(Id<Node> node_id, Bool& out_unified_scaling) const {
+	auto ret = Modified{};
+	auto* node = m_scene.find(node_id);
+	if (!node) { return false; }
+	ret(inspect(node->transform, out_unified_scaling));
+	ret(inspect(node->instances, out_unified_scaling));
+	if (auto const* mesh_id = node->find<Id<Mesh>>()) { ret(inspect(*mesh_id)); }
+	return ret.value;
+}
 } // namespace facade::editor

lib/engine/src/scene_renderer.cpp

@@ -65,7 +65,7 @@ void SceneRenderer::write_view(glm::vec2 const extent) {
 	};
 	m_view_proj.write(&vp, sizeof(vp));
 	auto dir_lights = FlexArray<DirLightSSBO, 4>{};
-	for (auto const& light : m_scene->dir_lights.span()) { dir_lights.insert(DirLightSSBO::make(light)); }
+	for (auto const& light : m_scene->lights.dir_lights.span()) { dir_lights.insert(DirLightSSBO::make(light)); }
 	m_dir_lights.write(dir_lights.span().data(), dir_lights.span().size_bytes());
 }
 

lib/scene/include/facade/scene/lights.hpp

@@ -1,4 +1,5 @@
 #pragma once
+#include <facade/util/flex_array.hpp>
 #include <facade/util/nvec3.hpp>
 #include <facade/util/rgb.hpp>
 
@@ -10,10 +11,16 @@ struct DirLight {
 	///
 	/// \brief Direction.
 	///
-	nvec3 direction{front_v};
+	nvec3 direction{-front_v};
 	///
 	/// \brief Colour and intensity.
 	///
 	Rgb rgb{};
 };
+
+struct Lights {
+	static constexpr std::size_t max_lights_v{4};
+
+	FlexArray<DirLight, max_lights_v> dir_lights{};
+};
 } // namespace facade

lib/scene/include/facade/scene/scene.hpp

@@ -244,9 +244,9 @@ class Scene {
 	Resources resources() const { return m_storage.resources(); }
 
 	///
-	/// \brief All the directional lights in the scene.
+	/// \brief All the lights in the scene.
 	///
-	FlexArray<DirLight, 4> dir_lights{};
+	Lights lights{};
 
   private:
 	struct TreeBuilder;

lib/util/include/facade/util/flex_array.hpp

@@ -40,17 +40,25 @@ class FlexArray {
 
 	///
 	/// \brief Obtain a mutable view into the array.
+	/// \returns Mutable view into the array
 	///
 	constexpr std::span<Type> span() { return {m_t.data(), m_size}; }
 	///
 	/// \brief Obtain an immutable view into the array.
+	/// \returns Immutable view into the array
 	///
 	constexpr std::span<Type const> span() const { return {m_t.data(), m_size}; }
 
 	///
 	/// \brief Obtain the number of elements stored.
+	/// \returns Number of elements stored
 	///
 	constexpr std::size_t size() const { return m_size; }
+	///
+	/// \brief Check if the array size is 0.
+	/// \returns true if size is 0
+	///
+	constexpr bool empty() const { return m_size == 0; }
 
   private:
 	std::array<Type, Capacity> m_t{};

lib/vk/include/facade/vk/buffer.hpp

@@ -33,7 +33,6 @@ class Buffer {
 	Gfx m_gfx{};
 	mutable Rotator<Defer<UniqueBuffer>> m_buffers{};
 	std::vector<std::byte> m_data{};
-	std::size_t m_size{};
 	Type m_type{};
 };
 } // namespace facade

lib/vk/src/buffer.cpp

@@ -35,11 +35,11 @@ void Buffer::refresh() const {
 
 BufferView Buffer::view() const {
 	refresh();
-	return {m_buffers.get().get().get().buffer, m_size};
+	return {m_buffers.get().get().get().buffer, m_data.size()};
 }
 
 DescriptorBuffer Buffer::descriptor_buffer() const {
 	refresh();
-	return {m_buffers.get().get().get().buffer, m_buffers.get().get().get().size, to_descriptor_type(m_type)};
+	return {m_buffers.get().get().get().buffer, m_data.size(), to_descriptor_type(m_type)};
 }
 } // namespace facade

src/main.cpp

@@ -116,6 +116,7 @@ struct MainMenu {
 	struct {
 		bool stats{};
 		bool tree{};
+		bool lights{};
 		bool log{};
 		bool imgui_demo{};
 	} windows{};
@@ -174,6 +175,11 @@ struct MainMenu {
 		if (auto window = editor::Window{"Scene", &windows.tree}) { editor::SceneTree{scene}.render(window, data.inspectee); }
 	}
 
+	void lights(Scene& scene) {
+		ImGui::SetNextWindowSize({400.0f, 400.0f}, ImGuiCond_Once);
+		if (auto window = editor::Window{"Lights", &windows.lights}) { editor::Inspector{window}.inspect(scene.lights); }
+	}
+
 	void log() {
 		ImGui::SetNextWindowSize({600.0f, 200.0f}, ImGuiCond_Once);
 		if (auto window = editor::Window{"Log", &windows.log}) { data.log.render(window); }
@@ -187,6 +193,7 @@ struct MainMenu {
 			}
 			if (auto window = editor::Menu{main, "Window"}) {
 				if (ImGui::MenuItem("Tree")) { windows.tree = true; }
+				if (ImGui::MenuItem("Lights")) { windows.lights = true; }
 				if (ImGui::MenuItem("Stats")) { windows.stats = true; }
 				if (ImGui::MenuItem("Log")) { windows.log = true; }
 				if constexpr (debug_v) {
@@ -198,6 +205,7 @@ struct MainMenu {
 		}
 
 		if (windows.tree) { tree(engine.scene()); }
+		if (windows.lights) { lights(engine.scene()); }
 		if (data.inspectee) { inspector(engine.scene()); }
 		if (windows.stats) { stats(engine, dt); }
 		if (windows.log) { log(); }
@@ -234,12 +242,13 @@ void run() {
 	auto material_id = Id<Material>{};
 	auto node_id = Id<Node>{};
 	auto post_scene_load = [&](Scene& scene) {
+		scene.lights.dir_lights.insert(DirLight{.direction = glm::normalize(glm::vec3{-1.0f, -1.0f, -1.0f}), .rgb = {.intensity = 5.0f}});
 		scene.camera().transform.set_position({0.0f, 0.0f, 5.0f});
 
 		auto material = std::make_unique<LitMaterial>();
 		material->albedo = {1.0f, 0.0f, 0.0f};
 		material_id = scene.add(std::move(material));
-		auto static_mesh_id = scene.add(make_cubed_sphere(1.0f, 32));
+		auto static_mesh_id = scene.add(make_manipulator(0.125f, 1.0f, 16));
 		auto mesh_id = scene.add(Mesh{.primitives = {Mesh::Primitive{static_mesh_id, material_id}}});
 
 		auto node = Node{};
@@ -259,7 +268,6 @@ void run() {
 		engine->add_shader(shaders::unlit());
 
 		auto& scene = engine->scene();
-		scene.dir_lights.insert(DirLight{.direction = glm::normalize(glm::vec3{-1.0f, -1.0f, -1.0f}), .rgb = {.intensity = 5.0f}});
 		scene.load_gltf(dj::Json::parse(test_json_v), DummyDataProvider{});
 		post_scene_load(engine->scene());
 		engine->show(true);