Config, Events, PathSources (#60)

* Add Config

* Add Scene::pipeline_state

- Enable toggling between filled and wireframe pipelines in editor (through frame stats).

* Add Events

- Refine load hooks, config updates, etc: wire through events.
- Only update browse path in `Config` if changed.
- Refactor `BrowseFile` to support above.
- Prepare for unifying interface for all load path sources.

* Add PathSource

- Rename main_menu/ to gui/.
- Move `BrowseGltf`, `OpenRecent`, `DropFile` to gltf_sources.
- Consolidate events in gui/events.hpp.

* Remove events/common

* Move gltf_sources constructors to cpp files

-  Make them classes with only constructors publicly accessible.

* Store weak_ptr<Events> in BrowseGltf

Author: karnkaul

.gitignore

@@ -13,3 +13,4 @@ wiki
 imgui.ini
 
 facade.log*
+facade.conf*

CMakeLists.txt

@@ -53,8 +53,15 @@ if(FACADE_BUILD_EXE)
   add_executable(${PROJECT_NAME})
 
   target_sources(${PROJECT_NAME} PRIVATE
-    src/main_menu/main_menu.cpp
-    src/main_menu/main_menu.hpp
+    src/config/config.cpp
+    src/config/config.hpp
+    src/events/events.hpp
+    src/gui/events.hpp
+    src/gui/gltf_sources.hpp
+    src/gui/gltf_sources.cpp
+    src/gui/main_menu.cpp
+    src/gui/main_menu.hpp
+    src/gui/path_source.hpp
 
     src/main.cpp
 

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

@@ -4,10 +4,15 @@
 
 namespace facade::editor {
 struct BrowseFile {
+	struct Result {
+		std::string selected{};
+		bool dir_changed{};
+	};
+
 	env::DirEntries& out_entries;
 	env::MatchList extensions{};
 	float parent_indent{5.0f};
 
-	std::string operator()(NotClosed<Popup> popup, std::string& out_path);
+	Result operator()(NotClosed<Popup> popup, std::string& out_path);
 };
 } // namespace facade::editor

lib/engine/include/facade/engine/engine.hpp

@@ -91,6 +91,7 @@ class Engine {
 	///
 	LoadStatus load_status() const;
 
+	glm::ivec2 window_position() const;
 	glm::uvec2 window_extent() const;
 	glm::uvec2 framebuffer_extent() const;
 

lib/engine/src/editor/browse_file.cpp

@@ -25,15 +25,24 @@ std::string truncate(std::string_view in, std::size_t limit) {
 }
 } // namespace
 
-std::string BrowseFile::operator()(NotClosed<Popup> popup, std::string& out_path) {
-	auto const fs_path = [&] {
-		auto ret = fs::absolute(out_path);
-		if (!fs::is_directory(ret)) {
-			ret = fs::current_path();
-			out_path = ret.generic_string();
+auto BrowseFile::operator()(NotClosed<Popup> popup, std::string& out_path) -> Result {
+	auto ret = Result{};
+	auto fs_path = [&] {
+		auto path = fs::path{};
+		if (!fs::is_directory(out_path)) {
+			path = fs::current_path();
+			out_path = path.generic_string();
+			ret.dir_changed = true;
+		} else {
+			path = fs::absolute(out_path);
 		}
-		return ret;
+		return path;
 	}();
+	auto cd = [&](fs::path path) {
+		fs_path = std::move(path);
+		out_path = fs_path.generic_string();
+		ret.dir_changed = true;
+	};
 	auto label = out_path;
 	auto const text_size = ImGui::CalcTextSize(label.c_str());
 	ImGui::PushItemWidth(-50.0f);
@@ -49,39 +58,37 @@ std::string BrowseFile::operator()(NotClosed<Popup> popup, std::string& out_path
 			auto name = p.filename().generic_string();
 			name += "/";
 			if (ImGui::Selectable(name.c_str(), false)) {
-				out_path = p.generic_string();
+				cd(std::move(p));
 				break;
 			}
 			if (p.parent_path() == p) { break; }
 		}
 		ImGui::EndCombo();
 	}
-	if (fs_path.has_parent_path() && ImGui::Button("Up")) { out_path = fs_path.parent_path().generic_string(); }
+	if (fs_path.has_parent_path() && ImGui::Button("Up")) { cd(fs_path.parent_path()); }
 	if (auto documents = env::documents_path(); !documents.empty()) {
 		ImGui::SameLine();
-		if (ImGui::Button("Documents")) { out_path = std::move(documents); }
+		if (ImGui::Button("Documents")) { cd(std::move(documents)); }
 	}
 	if (auto downloads = env::downloads_path(); !downloads.empty()) {
 		ImGui::SameLine();
-		if (ImGui::Button("Downloads")) { out_path = std::move(downloads); }
+		if (ImGui::Button("Downloads")) { cd(std::move(downloads)); }
 	}
 
 	ImGui::Separator();
 	if (auto window = editor::Window{popup, "File Tree"}) {
 		env::GetDirEntries{.extensions = extensions}(out_entries, out_path.c_str());
-		if (fs_path.has_parent_path() && ImGui::Selectable("..", false, ImGuiSelectableFlags_DontClosePopups)) {
-			out_path = fs_path.parent_path().generic_string();
-		}
+		if (fs_path.has_parent_path() && ImGui::Selectable("..", false, ImGuiSelectableFlags_DontClosePopups)) { cd(fs_path.parent_path()); }
 		for (auto const& dir : out_entries.dirs) {
 			auto filename = env::to_filename(dir);
 			filename += "/";
-			if (ImGui::Selectable(filename.c_str(), false, ImGuiSelectableFlags_DontClosePopups)) { out_path = dir; }
+			if (ImGui::Selectable(filename.c_str(), false, ImGuiSelectableFlags_DontClosePopups)) { cd(dir); }
 		}
 		for (auto const& file : out_entries.files) {
-			if (ImGui::Selectable(env::to_filename(file).c_str(), false, ImGuiSelectableFlags_DontClosePopups)) { return file; }
+			if (ImGui::Selectable(env::to_filename(file).c_str(), false, ImGuiSelectableFlags_DontClosePopups)) { ret.selected = file; }
 		}
 	}
 
-	return {};
+	return ret;
 }
 } // namespace facade::editor

lib/engine/src/engine.cpp

@@ -259,6 +259,7 @@ void Engine::render() {
 
 void Engine::request_stop() { glfwSetWindowShouldClose(window(), GLFW_TRUE); }
 
+glm::ivec2 Engine::window_position() const { return m_impl->window.window.get().position(); }
 glm::uvec2 Engine::window_extent() const { return m_impl->window.window.get().window_extent(); }
 glm::uvec2 Engine::framebuffer_extent() const { return m_impl->window.window.get().framebuffer_extent(); }
 

lib/engine/src/scene_renderer.cpp

@@ -46,14 +46,14 @@ SceneRenderer::SceneRenderer(Gfx const& gfx)
 void SceneRenderer::render(Scene const& scene, Renderer& renderer, vk::CommandBuffer cb) {
 	m_scene = &scene;
 	write_view(renderer.framebuffer_extent());
-	for (auto const& node : m_scene->m_tree.roots) { render(renderer, cb, node); }
+	for (auto const& node : m_scene->roots()) { render(renderer, cb, node); }
 }
 
 void SceneRenderer::write_view(glm::vec2 const extent) {
 	auto const& cam_node = m_scene->camera();
 	auto const* cam_id = cam_node.find<Id<Camera>>();
 	assert(cam_id);
-	auto const& cam = m_scene->m_storage.cameras[*cam_id];
+	auto const& cam = m_scene->resources().cameras[*cam_id];
 	struct {
 		glm::mat4x4 mat_v;
 		glm::mat4x4 mat_p;
@@ -89,19 +89,20 @@ std::span<glm::mat4x4 const> SceneRenderer::make_instances(Node const& node, glm
 }
 
 void SceneRenderer::render(Renderer& renderer, vk::CommandBuffer cb, Node const& node, glm::mat4 const& parent) {
+	auto const resources = m_scene->resources();
 	if (auto const* mesh_id = node.find<Id<Mesh>>()) {
 		static auto const s_default_material = LitMaterial{};
-		auto const& mesh = m_scene->m_storage.meshes.at(*mesh_id);
+		auto const& mesh = resources.meshes[*mesh_id];
 		for (auto const& primitive : mesh.primitives) {
-			auto const& material =
-				primitive.material ? *m_scene->m_storage.materials.at(primitive.material->value()) : static_cast<Material const&>(s_default_material);
-			auto pipeline = renderer.bind_pipeline(cb, {}, material.shader_id());
+			auto const& material = primitive.material ? *resources.materials[primitive.material->value()] : static_cast<Material const&>(s_default_material);
+			auto pipeline = renderer.bind_pipeline(cb, m_scene->pipeline_state, material.shader_id());
+			pipeline.set_line_width(m_scene->pipeline_state.line_width);
 
 			update_view(pipeline);
-			auto const store = TextureStore{m_scene->m_storage.textures, m_white};
+			auto const store = TextureStore{resources.textures, m_white};
 			material.write_sets(pipeline, store);
 
-			auto const& static_mesh = m_scene->m_storage.static_meshes.at(primitive.static_mesh);
+			auto const& static_mesh = resources.static_meshes[primitive.static_mesh];
 			auto const instances = make_instances(node, parent);
 			renderer.draw(pipeline, static_mesh, instances);
 		}

lib/glfw/include/facade/glfw/glfw.hpp

@@ -89,17 +89,25 @@ struct Glfw::Window {
 	///
 	static UniqueWin make();
 
+	///
+	/// \brief Obtain the window position in screen coordinates.
+	/// \returns Window position in screen coordinates
+	///
+	glm::ivec2 position() const;
 	///
 	/// \brief Obtain the extent (size) of the window.
+	/// \returns Extent (size) of the window
 	///
 	glm::uvec2 window_extent() const;
 	///
 	/// \brief Obtain the extent (size) of the framebuffer.
+	/// \returns Extent (size) of the framebuffer
 	///
 	glm::uvec2 framebuffer_extent() const;
 
 	///
 	/// \brief Obtain the state since the last poll.
+	/// \returns State since the last poll
 	///
 	State const& state() const;
 

lib/glfw/src/glfw.cpp

@@ -93,6 +93,12 @@ std::vector<char const*> Glfw::vk_extensions() const {
 	return ret;
 }
 
+glm::ivec2 Glfw::Window::position() const {
+	auto ret = glm::ivec2{};
+	glfwGetWindowPos(win, &ret.x, &ret.y);
+	return ret;
+}
+
 glm::uvec2 Glfw::Window::window_extent() const {
 	auto ret = glm::ivec2{};
 	glfwGetWindowSize(win, &ret.x, &ret.y);

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

@@ -12,6 +12,7 @@
 #include <facade/util/ptr.hpp>
 #include <facade/util/transform.hpp>
 #include <facade/vk/buffer.hpp>
+#include <facade/vk/pipeline.hpp>
 #include <facade/vk/static_mesh.hpp>
 #include <facade/vk/texture.hpp>
 #include <atomic>
@@ -247,6 +248,11 @@ class Scene {
 	///
 	Lights lights{};
 
+	///
+	/// \brief Global pipeline state.
+	///
+	Pipeline::State pipeline_state{};
+
   private:
 	struct TreeBuilder;
 
@@ -294,7 +300,5 @@ class Scene {
 	Storage m_storage{};
 	std::string m_name{};
 	TreeImpl m_tree{};
-
-	friend class SceneRenderer;
 };
 } // namespace facade

lib/util/include/facade/util/unique_task.hpp

@@ -40,13 +40,13 @@ class UniqueTask<Ret(Args...)> {
   private:
 	struct Base {
 		virtual ~Base() = default;
-		virtual void operator()() = 0;
+		virtual void operator()(Args...) = 0;
 	};
 	template <typename F>
 	struct Func : Base {
 		F f;
 		Func(F&& f) : f(std::move(f)) {}
-		void operator()() final { f(); }
+		void operator()(Args... args) final { f(args...); }
 	};
 
 	std::unique_ptr<Base> m_func{};

lib/vk/include/facade/vk/pipeline.hpp

@@ -9,6 +9,7 @@ class Pipeline {
 	struct State {
 		vk::PolygonMode mode{vk::PolygonMode::eFill};
 		vk::PrimitiveTopology topology{vk::PrimitiveTopology::eTriangleList};
+		float line_width{1.0f};
 		bool depth_test{true};
 
 		bool operator==(State const&) const = default;

src/config/config.cpp

@@ -0,0 +1,86 @@
+#include <config/config.hpp>
+#include <djson/json.hpp>
+#include <facade/engine/engine.hpp>
+#include <facade/util/logger.hpp>
+#include <filesystem>
+
+namespace facade {
+namespace {
+template <int Dim, typename T>
+bool to_json(dj::Json& out, glm::vec<Dim, T> const& vec) {
+	out["x"] = vec.x;
+	if constexpr (Dim > 1) { out["y"] = vec.y; }
+	if constexpr (Dim > 2) { out["z"] = vec.z; }
+	if constexpr (Dim > 3) { out["w"] = vec.w; }
+	return true;
+}
+
+bool to_json(dj::Json& out, Config const& config) {
+	auto window = dj::Json{};
+	to_json(window["extent"], config.window.extent);
+	if (config.window.position) { to_json(window["position"], *config.window.position); }
+	window["msaa"] = static_cast<int>(config.window.msaa);
+	auto file_menu = dj::Json{};
+	file_menu["browse_path"] = config.file_menu.browse_path;
+	if (!config.file_menu.recents.empty()) {
+		auto recents = dj::Json{};
+		for (auto const& path : config.file_menu.recents) { recents.push_back(path); }
+		file_menu["recents"] = std::move(recents);
+	}
+	out["window"] = std::move(window);
+	out["file_menu"] = std::move(file_menu);
+	return true;
+}
+
+template <int Dim, typename T>
+bool from_json(dj::Json const& json, glm::vec<Dim, T>& out) {
+	out.x = json["x"].as<T>();
+	if constexpr (Dim > 1) { out.y = json["y"].as<T>(); }
+	if constexpr (Dim > 2) { out.z = json["z"].as<T>(); }
+	if constexpr (Dim > 3) { out.w = json["w"].as<T>(); }
+	return true;
+}
+
+bool from_json(dj::Json const& json, Config& out) {
+	auto const& window = json["window"];
+	auto extent = glm::uvec2{};
+	from_json<2, std::uint32_t>(window, extent);
+	if (extent.x > 0 && extent.y > 0) { out.window.extent = extent; }
+	if (auto const& position = window["position"]) {
+		auto value = glm::ivec2{};
+		from_json<2, std::int32_t>(position, value);
+		out.window.position = value;
+	}
+	if (auto const& msaa = window["msaa"]) { out.window.msaa = static_cast<std::uint8_t>(msaa.as<int>()); }
+	auto const& file_menu = json["file_menu"];
+	out.file_menu.browse_path = file_menu["browse_path"].as_string();
+	for (auto const& path : file_menu["recents"].array_view()) { out.file_menu.recents.emplace_back(path.as_string()); }
+	return true;
+}
+} // namespace
+
+Config Config::load(char const* path) {
+	auto ret = Config{};
+	if (!std::filesystem::is_regular_file(path)) { return ret; }
+	auto json = dj::Json::from_file(path);
+	from_json(json, ret);
+	logger::info("Loaded config from [{}]", path);
+	return ret;
+}
+
+bool Config::save(char const* path) const {
+	auto json = dj::Json{};
+	if (!to_json(json, *this)) { return false; }
+	if (!json.to_file(path)) {
+		logger::warn("Failed to save config to [{}]", path);
+		return false;
+	}
+	logger::info("Saved config to [{}]", path);
+	return true;
+}
+
+void Config::Scoped::update(Engine const& engine) {
+	config.window.extent = engine.window_extent();
+	config.window.position = engine.window_position();
+}
+} // namespace facade

src/config/config.hpp

@@ -0,0 +1,39 @@
+#pragma once
+#include <glm/vec2.hpp>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace facade {
+class Engine;
+
+struct Config {
+	class Scoped;
+
+	struct {
+		glm::uvec2 extent{1280, 720};
+		std::optional<glm::ivec2> position{};
+		std::uint8_t msaa{};
+	} window{};
+
+	struct {
+		std::string browse_path{};
+		std::vector<std::string> recents{};
+	} file_menu{};
+
+	static Config load(char const* path);
+	bool save(char const* path) const;
+};
+
+class Config::Scoped {
+	std::string m_path{};
+
+  public:
+	Scoped(std::string path = "facade.conf") : m_path(std::move(path)), config(load(m_path.c_str())) {}
+	~Scoped() { config.save(m_path.c_str()); }
+
+	void update(Engine const& engine);
+
+	Config config{};
+};
+} // namespace facade