Misc improvements (#53)

* Improve orientation and scale inspection

- Fix janky Euler rotation: all axes rotate smoothly and continuously.
- Add option to unify all scaling axes into one inspect parameter.

* Add Version; CMake option to build exe

* Upgrade loading metrics

- Defer decompressing images to `Scene` (instead of `gltf::Scene`).
- Refactor `LoadStatus`: Provide granular done / total metrics.

* Cleanup

* 🐛 Only iterate over directories

Author: karnkaul

CMakeLists.txt

@@ -8,10 +8,17 @@ set(target_prefix facade)
 
 project(facade)
 
-option(FACADE_BUILD_SHADERS "Build facade shaders" ON)
+set(is_root_project OFF)
+
+if(PROJECT_NAME STREQUAL CMAKE_PROJECT_NAME)
+  set(is_root_project ON)
+endif()
+
+option(FACADE_BUILD_SHADERS "Build facade shaders" ${is_root_project})
 option(FACADE_PCH "Use PCH" ON)
+option(FACADE_BUILD_EXE "Build facade application (else only library)" ${is_root_project})
 
-if(FACADE_BUILD_SHADERS)
+if(FACADE_BUILD_EXE AND FACADE_BUILD_SHADERS)
   find_program(glslc glslc)
 
   if(glslc STREQUAL glslc-NOTFOUND)
@@ -23,7 +30,7 @@ endif()
 add_subdirectory(tools/embed_shader)
 add_subdirectory(lib)
 
-if(FACADE_BUILD_SHADERS)
+if(FACADE_BUILD_EXE AND FACADE_BUILD_SHADERS)
   message(STATUS "Adding build step to embed shaders")
   add_custom_command(
     DEPENDS
@@ -42,27 +49,29 @@ if(FACADE_BUILD_SHADERS)
   )
 endif()
 
-add_executable(${PROJECT_NAME})
+if(FACADE_BUILD_EXE)
+  add_executable(${PROJECT_NAME})
+
+  target_sources(${PROJECT_NAME} PRIVATE
+    src/main.cpp
 
-target_sources(${PROJECT_NAME} PRIVATE
-  src/main.cpp
+    src/bin/shaders.cpp
+    src/bin/shaders.hpp
 
-  src/bin/shaders.cpp
-  src/bin/shaders.hpp
+    src/bin/default_vert.spv.hpp
+    src/bin/unlit_frag.spv.hpp
+  )
 
-  src/bin/default_vert.spv.hpp
-  src/bin/unlit_frag.spv.hpp
-)
+  target_link_libraries(${PROJECT_NAME} PRIVATE
+    facade::engine
+    facade::compile-options
+  )
 
-target_link_libraries(${PROJECT_NAME} PRIVATE
-  facade::engine
-  facade::compile-options
-)
+  string(TOUPPER ${target_prefix} target_prefix_upper)
 
-string(TOUPPER ${target_prefix} target_prefix_upper)
+  if(${${target_prefix_upper}_PCH})
+    target_precompile_headers(${PROJECT_NAME} REUSE_FROM ${target_prefix}-vk)
+  endif()
 
-if(${${target_prefix_upper}_PCH})
-  target_precompile_headers(${PROJECT_NAME} REUSE_FROM ${target_prefix}-vk)
+  target_include_directories(${PROJECT_NAME} PRIVATE src)
 endif()
-
-target_include_directories(${PROJECT_NAME} PRIVATE src)

lib/CMakeLists.txt

@@ -8,7 +8,9 @@ set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_DEBUG_POSTFIX "-d")
 
-project(${target_prefix}-lib)
+set(${target_prefix}_version 0.1.0)
+
+project(${target_prefix}-lib VERSION ${${target_prefix}_version})
 
 add_subdirectory(ext)
 add_subdirectory(interface)

lib/engine/CMakeLists.txt

@@ -2,7 +2,9 @@ if("${target_prefix}" STREQUAL "")
   message(FATAL_ERROR "target_prefix unset")
 endif()
 
-project(${target_prefix}-engine)
+project(${target_prefix}-engine VERSION ${${target_prefix}_version})
+
+configure_file(src/build_version.hpp.in "${CMAKE_CURRENT_BINARY_DIR}/include/${target_prefix}/build_version.hpp" @ONLY)
 
 add_library(${PROJECT_NAME})
 add_library(${target_prefix}::engine ALIAS ${PROJECT_NAME})
@@ -12,6 +14,7 @@ target_compile_features(${PROJECT_NAME} PUBLIC cxx_std_20)
 target_include_directories(${PROJECT_NAME}
   PUBLIC
   include
+  "${CMAKE_CURRENT_BINARY_DIR}/include"
 
   PRIVATE
   src

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

@@ -30,7 +30,7 @@ class Inspector {
 	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, glm::quat& out_quat) const;
-	bool inspect(Transform& out_transform) const;
+	bool inspect(Transform& out_transform, Bool& out_unified_scaling) const;
 };
 
 class SceneInspector : public Inspector {
@@ -42,7 +42,7 @@ class SceneInspector : public Inspector {
 	bool inspect(TreeNode const& node, UnlitMaterial& out_material) const;
 	bool inspect(TreeNode const& node, LitMaterial& out_material) const;
 	bool inspect(Id<Material> material_id) const;
-	bool inspect(Id<Node> node_id) const;
+	bool inspect(Id<Node> node_id, Bool& out_unified_scaling) const;
 
 	bool inspect(Id<Mesh> mesh) const;
 

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

@@ -1,4 +1,5 @@
 #pragma once
+#include <facade/build_version.hpp>
 #include <facade/glfw/glfw.hpp>
 #include <facade/scene/scene.hpp>
 #include <facade/util/time.hpp>

lib/engine/src/build_version.hpp.in

@@ -0,0 +1,12 @@
+#include <facade/util/version.hpp>
+
+namespace facade {
+///
+/// \brief facade build version
+///
+constexpr auto version_v = Version{
+	.major = @PROJECT_VERSION_MAJOR@,
+	.minor = @PROJECT_VERSION_MINOR@,
+	.patch = @PROJECT_VERSION_PATCH@,
+};
+}

lib/engine/src/editor/inspector.cpp

@@ -7,7 +7,6 @@
 namespace facade::editor {
 namespace {
 bool eq(float const a, float const b, float const epsilon = 0.001f) { return std::abs(a - b) < epsilon; }
-constexpr glm::vec3 to_radian(glm::vec3 const& angles) { return {glm::radians(angles.x), glm::radians(angles.y), glm::radians(angles.z)}; }
 constexpr glm::vec3 to_degree(glm::vec3 const& angles) { return {glm::degrees(angles.x), glm::degrees(angles.y), glm::degrees(angles.z)}; }
 
 struct Modified {
@@ -54,25 +53,31 @@ bool Inspector::inspect(char const* label, glm::vec4& out_vec4, float speed, flo
 
 bool Inspector::inspect(char const* label, glm::quat& out_quat) const {
 	auto euler = to_degree(glm::eulerAngles(out_quat));
+	auto const org = euler;
 	if (inspect(label, euler, 0.5f, -180.0f, 180.0f)) {
-		static constexpr auto y_limit_v{90.0f};
-		if (euler.y < -y_limit_v) { euler.y = y_limit_v; }
-		if (euler.y > y_limit_v) { euler.y = -y_limit_v; }
-		out_quat = glm::quat(to_radian(euler));
+		if (auto const diff = org.x - euler.x; std::abs(diff) > 0.0f) { out_quat = glm::rotate(out_quat, glm::radians(diff), right_v); }
+		if (auto const diff = org.y - euler.y; std::abs(diff) > 0.0f) { out_quat = glm::rotate(out_quat, glm::radians(diff), up_v); }
+		if (auto const diff = org.z - euler.z; std::abs(diff) > 0.0f) { out_quat = glm::rotate(out_quat, glm::radians(diff), front_v); }
 		return true;
 	}
 	return false;
 }
 
-bool Inspector::inspect(Transform& out_transform) const {
+bool Inspector::inspect(Transform& out_transform, Bool& out_unified_scaling) const {
 	auto ret = Modified{};
 	if (ImGui::CollapsingHeader("Transform", ImGuiTreeNodeFlags_DefaultOpen)) {
 		auto vec3 = out_transform.position();
 		if (ret(inspect("Position", vec3))) { out_transform.set_position(vec3); }
 		auto quat = out_transform.orientation();
 		if (ret(inspect("Orientation", quat))) { out_transform.set_orientation(quat); }
 		vec3 = out_transform.scale();
-		if (ret(inspect("Scale", vec3))) { out_transform.set_scale(vec3); }
+		if (out_unified_scaling) {
+			if (ret(ImGui::DragFloat("Scale", &vec3.x, 0.1f))) { out_transform.set_scale({vec3.x, vec3.x, vec3.x}); }
+		} else {
+			if (ret(inspect("Scale", vec3, 0.1f))) { out_transform.set_scale(vec3); }
+		}
+		ImGui::SameLine();
+		ImGui::Checkbox("Unified", &out_unified_scaling.value);
 	}
 	return ret.value;
 }
@@ -107,11 +112,11 @@ bool SceneInspector::inspect(Id<Material> material_id) const {
 	return false;
 }
 
-bool SceneInspector::inspect(Id<Node> node_id) const {
+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));
+	ret(inspect(node->transform, out_unified_scaling));
 	if (auto const* mesh_id = node->find<Id<Mesh>>()) { ret(inspect(*mesh_id)); }
 	return ret.value;
 }

lib/engine/src/engine.cpp

@@ -158,7 +158,7 @@ struct RenderWindow {
 		  renderer(gfx, this->window, gui.get(), Renderer::CreateInfo{command_buffers_v, msaa}), gui(std::move(gui)) {}
 };
 
-bool load_gltf(Scene& out_scene, char const* path, std::atomic<LoadStatus>* out_status) {
+bool load_gltf(Scene& out_scene, char const* path, AtomicLoadStatus* out_status) {
 	auto const provider = FileDataProvider::mount_parent_dir(path);
 	auto json = dj::Json::from_file(path);
 	return out_scene.load_gltf(json, provider, out_status);
@@ -182,7 +182,7 @@ bool busy(std::future<T> const& future) {
 struct LoadRequest {
 	std::string path{};
 	std::future<Scene> future{};
-	std::atomic<LoadStatus> status{};
+	AtomicLoadStatus status{};
 	float start_time{};
 };
 } // namespace
@@ -204,6 +204,7 @@ struct Engine::Impl {
 	Impl(UniqueWin window, std::uint8_t msaa, bool validation)
 		: window(std::move(window), std::make_unique<DearImGui>(), msaa, validation), renderer(this->window.gfx), scene(this->window.gfx), msaa(msaa) {
 		s_instance = this;
+		load.request.status.reset();
 	}
 
 	~Impl() {
@@ -279,7 +280,7 @@ bool Engine::load_async(std::string gltf_json_path, UniqueTask<void()> on_loaded
 	// populate load request
 	m_impl->load.callback = std::move(on_loaded);
 	m_impl->load.request.path = std::move(gltf_json_path);
-	m_impl->load.request.status.store(LoadStatus::eStartingThread);
+	m_impl->load.request.status.reset();
 	m_impl->load.request.start_time = time::since_start();
 	auto func = [path = m_impl->load.request.path, gfx = m_impl->window.gfx, status = &m_impl->load.request.status] {
 		auto scene = Scene{gfx};
@@ -294,7 +295,8 @@ bool Engine::load_async(std::string gltf_json_path, UniqueTask<void()> on_loaded
 
 LoadStatus Engine::load_status() const {
 	auto lock = std::scoped_lock{m_impl->mutex};
-	return m_impl->load.request.status.load();
+	auto const& status = m_impl->load.request.status;
+	return {.stage = status.stage.load(), .total = status.total, .done = status.done};
 }
 
 Scene& Engine::scene() const { return m_impl->scene; }
@@ -311,7 +313,7 @@ void Engine::update_load_request() {
 	// transfer scene (under mutex lock)
 	m_impl->scene = m_impl->load.request.future.get();
 	// reset load status
-	m_impl->load.request.status.store(LoadStatus::eNone);
+	m_impl->load.request.status.reset();
 	// move out the path
 	auto path = std::move(m_impl->load.request.path);
 	// move out the callback

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

@@ -3,44 +3,29 @@
 #include <string_view>
 
 namespace facade {
-enum class LoadStatus : std::uint8_t {
+enum class LoadStage : std::uint8_t {
 	eNone,
-	eStartingThread,
-	eParsingBuffers,
-	eParsingBufferViews,
-	eParsingAccessors,
-	eParsingCameras,
-	eParsingSamplers,
+	eParsingJson,
 	eLoadingImages,
-	eParsingTextures,
-	eParsingMeshes,
-	eParsingMaterials,
-	eBuildingGeometry,
-	eBuildingNodes,
+	eUploadingTextures,
+	eUploadingMeshes,
 	eBuildingScenes,
-	eUploadingResources,
 	eCOUNT_,
 };
 
-constexpr auto load_status_str = EnumArray<LoadStatus, std::string_view>{
-	"None",
-	"Starting Thread",
-	"Parsing Buffers",
-	"Parsing BufferViews",
-	"Parsing Accessors",
-	"Parsing Cameras",
-	"Parsing Samplers",
-	"Loading Images",
-	"Parsing Textures",
-	"Parsing Meshes",
-	"Parsing Materials",
-	"Building Geometry",
-	"Building Nodes",
-	"Building Scenes",
-	"Uploading Resources",
+constexpr auto load_stage_str = EnumArray<LoadStage, std::string_view>{
+	"None", "Parsing JSON", "Loading Images", "Uploading Textures", "Uploading Meshes", "Building Scenes",
 };
+static_assert(std::size(load_stage_str.t) == static_cast<std::size_t>(LoadStage::eCOUNT_));
 
-static_assert(std::size(load_status_str.t) == static_cast<std::size_t>(LoadStatus::eCOUNT_));
+struct LoadStatus {
+	LoadStage stage{};
+	std::size_t total{};
+	std::size_t done{};
 
-constexpr float load_progress(LoadStatus const stage) { return static_cast<float>(stage) / static_cast<float>(LoadStatus::eCOUNT_); }
+	constexpr float ratio() const {
+		if (total == 0) { return 0.0f; }
+		return static_cast<float>(done) / static_cast<float>(total);
+	}
+};
 } // namespace facade

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

@@ -24,6 +24,18 @@ class Json;
 }
 
 namespace facade {
+struct AtomicLoadStatus {
+	std::atomic<LoadStage> stage{};
+	std::atomic<std::size_t> total{};
+	std::atomic<std::size_t> done{};
+
+	void reset() {
+		stage = LoadStage::eNone;
+		total = {};
+		done = {};
+	}
+};
+
 struct Mesh {
 	struct Primitive {
 		Id<StaticMesh> static_mesh{};
@@ -51,7 +63,7 @@ class Scene {
 
 	explicit Scene(Gfx const& gfx);
 
-	bool load_gltf(dj::Json const& root, DataProvider const& provider, std::atomic<LoadStatus>* out_status = {}) noexcept(false);
+	bool load_gltf(dj::Json const& root, DataProvider const& provider, AtomicLoadStatus* out_status = {}) noexcept(false);
 
 	Id<Camera> add(Camera camera);
 	Id<Sampler> add(Sampler sampler);