v0.2: Add ui::Element, graphics::NineSlice, graphics::RoundedQuad (#76)

* Refactor ui::View into that + ui::Element. Move build version into generated header. * Add ui::Element::m_active * Add Engine::min_frame_time. Improve engine stats. * Make Primitive movable. Fix dangling access in `Resources::store()`. Add some consts in lit.frag. * Set window and framebuffer extents on startup. * Add graphics::Circle. * Move RenderLayer to dedicated header. * Move PolygonMode out of PipelineState into Renderer. * Add graphics::NineSlice * RoundedQuad, NineSlice. - Fix sector UVs and verts. * Add FDuration<PeriodT>. * Linearize all vertex colours.
karnkaul · Aug 24, 2023 · 309bfcf · 309bfcf
1 parent edd3021
commit 309bfcf
Show file tree

Hide file tree

Showing 47 changed files with 589 additions and 140 deletions.
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -4,7 +4,7 @@ set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
-project(little-engine VERSION 0.1.0)
+project(little-engine VERSION 0.2.0)
 
 set(is_root_project OFF)
 

diff --git a/engine/CMakeLists.txt b/engine/CMakeLists.txt
@@ -6,9 +6,6 @@ target_compile_definitions(${PROJECT_NAME} PUBLIC
   $<$<BOOL:${LE_PCH}>:LE_PCH>
   $<$<BOOL:${LE_USE_FREETYPE}>:LE_USE_FREETYPE>
   $<$<BOOL:${CAPO_USE_OPENAL}>:CAPO_USE_OPENAL>
-  LE_VERSION_MAJOR=${PROJECT_VERSION_MAJOR}
-  LE_VERSION_MINOR=${PROJECT_VERSION_MINOR}
-  LE_VERSION_PATCH=${PROJECT_VERSION_PATCH}
 )
 
 target_link_libraries(${PROJECT_NAME} PUBLIC
@@ -21,6 +18,7 @@ target_link_libraries(${PROJECT_NAME} PRIVATE
 
 target_include_directories(${PROJECT_NAME} PUBLIC
   include
+  "${CMAKE_CURRENT_BINARY_DIR}/include"
 )
 
 target_include_directories(${PROJECT_NAME} PRIVATE
@@ -31,6 +29,8 @@ target_compile_features(${PROJECT_NAME} PUBLIC
   cxx_std_20
 )
 
+configure_file(src/build_version.hpp.in "${CMAKE_CURRENT_BINARY_DIR}/include/le/build_version.hpp")
+
 add_subdirectory(src)
 
 include(header_list.cmake)

diff --git a/engine/include/le/core/time.hpp b/engine/include/le/core/time.hpp
@@ -5,7 +5,11 @@ using namespace std::chrono_literals;
 
 namespace le {
 using Clock = std::chrono::steady_clock;
-using Duration = std::chrono::duration<float>;
+
+template <typename PeriodT = std::ratio<1, 1>>
+using FDuration = std::chrono::duration<float, PeriodT>;
+
+using Duration = FDuration<>;
 
 ///
 /// \brief Stateful delta-time computer.

diff --git a/engine/include/le/core/version.hpp b/engine/include/le/core/version.hpp
@@ -14,7 +14,5 @@ struct Version {
 	auto operator<=>(Version const&) const = default;
 };
 
-constexpr Version const build_version_v{LE_VERSION_MAJOR, LE_VERSION_MINOR, LE_VERSION_PATCH};
-
 auto to_string(Version const& version) -> std::string;
 } // namespace le
diff --git a/engine/include/le/core/wrap.hpp b/engine/include/le/core/wrap.hpp
@@ -17,12 +17,17 @@ struct Wrap {
 	StorageT data{};
 	std::size_t offset{};
 
-	[[nodiscard]] constexpr auto get_current() const -> decltype(auto) { return data[offset]; }
-	[[nodiscard]] constexpr auto get_current() -> decltype(auto) { return data[offset]; }
+	[[nodiscard]] constexpr auto get_current() const -> decltype(auto) { return data.at(offset); }
+	[[nodiscard]] constexpr auto get_current() -> decltype(auto) { return data.at(offset); }
 
-	[[nodiscard]] constexpr auto get_previous() const -> decltype(auto) { return data[decrement_wrapped(offset, data.size())]; }
-	[[nodiscard]] constexpr auto get_previous() -> decltype(auto) { return data[decrement_wrapped(offset, data.size())]; }
+	[[nodiscard]] constexpr auto get_previous() const -> decltype(auto) { return data.at(decrement_wrapped(offset, data.size())); }
+	[[nodiscard]] constexpr auto get_previous() -> decltype(auto) { return data.at(decrement_wrapped(offset, data.size())); }
 
 	constexpr auto advance() -> void { offset = increment_wrapped(offset, data.size()); }
+
+	constexpr auto update_offset() -> decltype(auto) {
+		if (offset >= data.size()) { offset = 0; }
+		return get_current();
+	}
 };
 } // namespace le
diff --git a/engine/include/le/engine.hpp b/engine/include/le/engine.hpp
@@ -52,6 +52,8 @@ class Engine : public MonoInstance<Engine> {
 
 	Engine([[maybe_unused]] ConstructTag tag) noexcept {}
 
+	Duration min_frame_time{};
+
   private:
 	auto update_stats() -> void;
 

diff --git a/engine/include/le/environment.hpp b/engine/include/le/environment.hpp
@@ -1,4 +1,5 @@
 #pragma once
+#include <le/build_version.hpp>
 
 namespace le {
 constexpr bool debug_v =

diff --git a/engine/include/le/graphics/cache/pipeline_cache.hpp b/engine/include/le/graphics/cache/pipeline_cache.hpp
@@ -16,7 +16,7 @@ class PipelineCache : public MonoInstance<PipelineCache> {
 	[[nodiscard]] auto shader_layout() const -> ShaderLayout const& { return m_shader_layout; }
 	auto set_shader_layout(ShaderLayout shader_layout) -> void;
 
-	[[nodiscard]] auto load(PipelineFormat format, Shader shader, PipelineState state = {}) -> vk::Pipeline;
+	[[nodiscard]] auto load(PipelineFormat format, Shader shader, PipelineState state, vk::PolygonMode polygon_mode) -> vk::Pipeline;
 
 	[[nodiscard]] auto pipeline_layout() const -> vk::PipelineLayout { return *m_pipeline_layout; }
 	[[nodiscard]] auto descriptor_set_layouts() const -> std::span<vk::DescriptorSetLayout const> { return m_descriptor_set_layouts_view; }
@@ -30,7 +30,7 @@ class PipelineCache : public MonoInstance<PipelineCache> {
   private:
 	struct Key {
 	  public:
-		Key(PipelineFormat format, Shader shader, PipelineState state);
+		Key(PipelineFormat format, Shader shader, PipelineState state, vk::PolygonMode polygon_mode);
 
 		[[nodiscard]] auto hash() const -> std::size_t { return cached_hash; }
 
@@ -39,6 +39,7 @@ class PipelineCache : public MonoInstance<PipelineCache> {
 		PipelineFormat format{};
 		Shader shader{};
 		PipelineState state{};
+		vk::PolygonMode polygon_mode{};
 		std::size_t cached_hash{};
 	};
 

diff --git a/engine/include/le/graphics/geometry.hpp b/engine/include/le/graphics/geometry.hpp
@@ -9,17 +9,55 @@
 
 namespace le::graphics {
 struct Quad {
-	glm::vec2 size{1.0f, 1.0f};
+	glm::vec2 size{1.0f};
 	UvRect uv{uv_rect_v};
-	Rgba rgb{white_v};
+	Rgba rgba{white_v};
 	glm::vec3 origin{};
 
 	auto operator==(Quad const&) const -> bool = default;
 };
 
+struct Circle {
+	static constexpr int resolution_v{128};
+
+	float diameter{1.0f};
+	int resolution{resolution_v};
+	Rgba rgba{white_v};
+	glm::vec3 origin{};
+
+	auto operator==(Circle const&) const -> bool = default;
+};
+
+struct RoundedQuad : Quad {
+	float corner_radius{0.25f};
+	int corner_resolution{8};
+
+	auto operator==(RoundedQuad const&) const -> bool = default;
+};
+
+struct NineSlice {
+	struct Size {
+		glm::vec2 total{1.0f};
+		glm::vec2 top{0.25f};
+		glm::vec2 bottom{0.25f};
+
+		[[nodiscard]] auto rescaled(glm::vec2 extent) const -> Size;
+
+		auto operator==(Size const&) const -> bool = default;
+	};
+
+	Size size{};
+	UvRect top_uv{.lt = {}, .rb = glm::vec2{0.25f}};
+	UvRect bottom_uv{.lt = glm::vec2{0.75f}, .rb = glm::vec2{1.0f}};
+	Rgba rgba{white_v};
+	glm::vec3 origin{};
+
+	auto operator==(NineSlice const&) const -> bool = default;
+};
+
 struct Cube {
-	glm::vec3 size{1.0f, 1.0f, 1.0f};
-	Rgba rgb{white_v};
+	glm::vec3 size{1.0f};
+	Rgba rgba{white_v};
 	glm::vec3 origin{};
 
 	auto operator==(Cube const&) const -> bool = default;
@@ -30,7 +68,7 @@ struct Sphere {
 
 	float diameter{1.0f};
 	std::uint32_t resolution{resolution_v};
-	Rgba rgb{white_v};
+	Rgba rgba{white_v};
 	glm::vec3 origin{};
 
 	auto operator==(Sphere const&) const -> bool = default;
@@ -56,6 +94,10 @@ struct Geometry {
 	auto append(std::span<Vertex const> vs, std::span<std::uint32_t const> is) -> Geometry&;
 
 	auto append(Quad const& quad) -> Geometry&;
+	auto append(Circle const& circle) -> Geometry&;
+	auto append(RoundedQuad const& rounded_quad) -> Geometry&;
+	auto append(NineSlice const& nine_slice) -> Geometry&;
+
 	auto append(Cube const& cube) -> Geometry&;
 	auto append(Sphere const& sphere) -> Geometry&;
 

diff --git a/engine/include/le/graphics/pipeline_state.hpp b/engine/include/le/graphics/pipeline_state.hpp
@@ -1,5 +1,4 @@
 #pragma once
-#include <le/vfs/uri.hpp>
 #include <vulkan/vulkan.hpp>
 
 namespace le::graphics {
@@ -10,9 +9,8 @@ struct PipelineFormat {
 
 struct PipelineState {
 	vk::PrimitiveTopology topology{vk::PrimitiveTopology::eTriangleList};
-	vk::PolygonMode polygon_mode{vk::PolygonMode::eFill};
 	vk::CompareOp depth_compare{vk::CompareOp::eLess};
-	vk::Bool32 depth_test_write{1};
+	vk::Bool32 depth_test_write{vk::True};
 	float line_width{1.0f};
 };
 } // namespace le::graphics
diff --git a/engine/include/le/graphics/primitive.hpp b/engine/include/le/graphics/primitive.hpp
@@ -8,13 +8,13 @@
 namespace le::graphics {
 class Primitive {
   public:
-	Primitive() = default;
-
 	Primitive(Primitive const&) = delete;
-	Primitive(Primitive&&) = delete;
 	auto operator=(Primitive const&) -> Primitive& = delete;
-	auto operator=(Primitive&&) -> Primitive& = delete;
 
+	Primitive(Primitive&&) = default;
+	auto operator=(Primitive&&) -> Primitive& = default;
+
+	Primitive() = default;
 	virtual ~Primitive() = default;
 
 	struct Layout {

diff --git a/engine/include/le/graphics/renderer.hpp b/engine/include/le/graphics/renderer.hpp
@@ -66,6 +66,7 @@ class Renderer : public MonoInstance<Renderer> {
 	std::optional<glm::vec2> custom_world_frustum{};
 	glm::vec3 shadow_frustum{100.0f};
 	vk::Extent2D shadow_map_extent{2048, 2048};
+	vk::PolygonMode polygon_mode{vk::PolygonMode::eFill};
 
   private:
 	struct Frame {
@@ -100,7 +101,7 @@ class Renderer : public MonoInstance<Renderer> {
 	auto bake_objects(RenderFrame const& render_frame) -> void;
 
 	std::unique_ptr<DearImGui> m_imgui{};
-	PipelineCache m_pipeline_cache;
+	PipelineCache m_pipeline_cache{};
 	SamplerCache m_sampler_cache{};
 	DescriptorCache m_descriptor_cache{};
 	ScratchBufferCache m_scratch_buffer_cache{};

diff --git a/engine/include/le/imcpp/engine_stats.hpp b/engine/include/le/imcpp/engine_stats.hpp
@@ -1,20 +1,34 @@
 #pragma once
+#include <glm/vec3.hpp>
 #include <le/core/time.hpp>
 #include <le/core/wrap.hpp>
 #include <le/imcpp/common.hpp>
+#include <vector>
 
 namespace le::imcpp {
 class EngineStats {
   public:
-	static constexpr std::size_t frame_time_count_v{200};
+	struct FpsRgb {
+		std::uint32_t lower_bound{};
+		glm::vec3 rgb{};
+	};
+
+	static constexpr int frame_time_count_v{200};
 
 	auto draw_to(OpenWindow w) -> void;
 
 	auto set_frame_time_count(std::size_t count) -> void;
 
+	int frame_samples{frame_time_count_v};
+	std::vector<FpsRgb> fps_rgb{
+		FpsRgb{.lower_bound = 30, .rgb = {1.0f, 0.0f, 0.0f}},
+		FpsRgb{.lower_bound = 45, .rgb = {1.0f, 1.0f, 0.0f}},
+		FpsRgb{.lower_bound = 60, .rgb = {0.25f, 1.0f, 0.0f}},
+	};
+
   private:
 	auto push_frame_time(Duration dt) -> void;
 
-	Wrap<std::vector<float>> m_frame_times{std::vector<float>(frame_time_count_v)};
+	Wrap<std::vector<float>> m_frame_times{};
 };
 } // namespace le::imcpp
diff --git a/engine/include/le/resources/resources.hpp b/engine/include/le/resources/resources.hpp
@@ -1,6 +1,7 @@
 #pragma once
 #include <le/core/mono_instance.hpp>
 #include <le/core/ptr.hpp>
+#include <le/core/time.hpp>
 #include <le/error.hpp>
 #include <le/resources/asset.hpp>
 #include <le/vfs/uri.hpp>
@@ -53,7 +54,7 @@ class Resources : public MonoInstance<Resources> {
 	template <std::derived_from<Asset> Type>
 	[[nodiscard]] static auto is_ready(std::future<Ptr<Type>> const& future) -> bool {
 		if (!future.valid()) { return false; }
-		return future.wait_for(std::chrono::seconds{}) == std::future_status::ready;
+		return future.wait_for(0s) == std::future_status::ready;
 	}
 
 	auto clear() -> void;

diff --git a/engine/src/build_version.hpp.in b/engine/src/build_version.hpp.in
@@ -0,0 +1,10 @@
+#pragma once
+#include <le/core/version.hpp>
+
+namespace le {
+constexpr Version build_version_v{
+	.major = @PROJECT_VERSION_MAJOR@,
+	.minor = @PROJECT_VERSION_MINOR@,
+	.patch = @PROJECT_VERSION_PATCH@,
+};
+}
diff --git a/engine/src/engine.cpp b/engine/src/engine.cpp
@@ -9,6 +9,7 @@
 #include <le/error.hpp>
 #include <le/input/receiver.hpp>
 #include <format>
+#include <thread>
 
 namespace le {
 namespace {
@@ -225,6 +226,12 @@ auto Engine::render(graphics::RenderFrame const& frame) -> void {
 	}
 
 	FrameProfiler::self().finish();
+
+	if (min_frame_time > 0s) {
+		auto const frame_time = Clock::now() - m_delta_time.start;
+		auto const remain = min_frame_time - frame_time;
+		if (remain > 0s) { std::this_thread::sleep_for(remain); }
+	}
 }
 
 auto Engine::shutdown() -> void {
@@ -291,6 +298,9 @@ auto Engine::Builder::build() -> std::unique_ptr<Engine> {
 
 	ret->m_audio_device = std::make_unique<audio::Device>();
 
+	g_input_state.window_extent = ret->window_extent();
+	g_input_state.framebuffer_extent = ret->framebuffer_extent();
+
 	return ret;
 }
 } // namespace le
diff --git a/engine/src/graphics/cache/pipeline_cache.cpp b/engine/src/graphics/cache/pipeline_cache.cpp
@@ -49,9 +49,10 @@ struct PipelineShaderLayout {
 auto const g_log{logger::Logger{"Cache"}};
 } // namespace
 
-PipelineCache::Key::Key(PipelineFormat format, Shader shader, PipelineState state) : format(format), shader(std::move(shader)), state(state) {
-	cached_hash = make_combined_hash(shader.vertex.hash(), shader.fragment.hash(), state.topology, state.polygon_mode, state.depth_compare,
-									 state.depth_test_write, format.colour, format.depth);
+PipelineCache::Key::Key(PipelineFormat format, Shader shader, PipelineState state, vk::PolygonMode polygon_mode)
+	: format(format), shader(std::move(shader)), state(state), polygon_mode(polygon_mode) {
+	cached_hash = make_combined_hash(shader.vertex.hash(), shader.fragment.hash(), state.topology, polygon_mode, state.depth_compare, state.depth_test_write,
+									 format.colour, format.depth);
 }
 
 PipelineCache::PipelineCache(ShaderLayout shader_layout) { set_shader_layout(std::move(shader_layout)); }
@@ -71,8 +72,8 @@ auto PipelineCache::set_shader_layout(ShaderLayout shader_layout) -> void {
 	m_pipeline_layout = m_device.createPipelineLayoutUnique(plci);
 }
 
-auto PipelineCache::load(PipelineFormat format, Shader shader, PipelineState state) -> vk::Pipeline {
-	auto const key = Key{format, std::move(shader), state};
+auto PipelineCache::load(PipelineFormat format, Shader shader, PipelineState state, vk::PolygonMode polygon_mode) -> vk::Pipeline {
+	auto const key = Key{format, std::move(shader), state, polygon_mode};
 	auto itr = m_pipelines.find(key);
 	if (itr == m_pipelines.end()) {
 		auto ret = build(key);
@@ -92,7 +93,7 @@ auto PipelineCache::clear_pipelines() -> void {
 }
 
 auto PipelineCache::clear_pipelines_and_shaders() -> void {
-	Device::self().get_device().waitIdle();
+	m_device.waitIdle();
 	clear_pipelines();
 	m_shader_cache.clear_shaders();
 }
@@ -123,7 +124,7 @@ auto PipelineCache::build(Key const& key) -> vk::UniquePipeline {
 	gpci.pStages = shader_stages.data();
 
 	auto prsci = vk::PipelineRasterizationStateCreateInfo{};
-	prsci.polygonMode = key.state.polygon_mode;
+	prsci.polygonMode = key.polygon_mode;
 	prsci.cullMode = vk::CullModeFlagBits::eNone;
 	gpci.pRasterizationState = &prsci;