Logging / editor upgrades

lib/editor/include/facade/editor/log.hpp

@@ -1,20 +1,20 @@
 #pragma once
+#include <facade/editor/common.hpp>
 #include <facade/util/enum_array.hpp>
 #include <facade/util/logger.hpp>
 #include <vector>
 
 namespace facade::editor {
 class Log : public logger::Accessor {
   public:
-	void render();
-
-	bool show{};
+	void render(NotClosed<Window> window);
 
   private:
 	void operator()(std::span<logger::Entry const> entries) final;
 
 	std::vector<logger::Entry const*> m_list{};
 	EnumArray<logger::Level, bool> m_level_filter{true, true, true, debug_v};
 	int m_display_count{50};
+	bool m_auto_scroll{true};
 };
 } // namespace facade::editor

lib/editor/src/log.cpp

@@ -1,49 +1,57 @@
 #include <imgui.h>
+#include <imgui_internal.h>
 #include <facade/editor/common.hpp>
 #include <facade/editor/log.hpp>
 #include <facade/util/fixed_string.hpp>
 
 namespace facade::editor {
-void Log::render() {
-	ImGui::SetNextWindowSize({500.0f, 200.0f}, ImGuiCond_Once);
-	if (auto window = editor::Window{"Log", &show}) {
-		ImGui::Text("%s", FixedString{"Count: {}", m_display_count}.c_str());
-		ImGui::SameLine();
-		float spacing = ImGui::GetStyle().ItemInnerSpacing.x;
-		ImGui::PushButtonRepeat(true);
-		if (ImGui::ArrowButton("##left", ImGuiDir_Left)) { m_display_count = std::clamp(m_display_count - 10, 0, 1000); }
-		ImGui::SameLine(0.0f, spacing);
-		if (ImGui::ArrowButton("##right", ImGuiDir_Right)) { m_display_count = std::clamp(m_display_count + 10, 0, 1000); }
-		ImGui::PopButtonRepeat();
+void Log::render(NotClosed<Window> window) {
+	ImGui::Text("%s", FixedString{"Count: {}", m_display_count}.c_str());
+	ImGui::SameLine();
+	float spacing = ImGui::GetStyle().ItemInnerSpacing.x;
+	ImGui::PushButtonRepeat(true);
+	auto const max_logs = static_cast<int>(logger::buffer_size().total());
+	if (ImGui::ArrowButton("##left", ImGuiDir_Left)) { m_display_count = std::clamp(m_display_count - 10, 0, max_logs); }
+	ImGui::SameLine(0.0f, spacing);
+	if (ImGui::ArrowButton("##right", ImGuiDir_Right)) { m_display_count = std::clamp(m_display_count + 10, 0, max_logs); }
+	ImGui::PopButtonRepeat();
 
-		static constexpr std::string_view levels_v[] = {"Error", "Warn", "Info", "Debug"};
-		static constexpr auto max_log_level_v = debug_v ? logger::Level::eDebug : logger::Level::eInfo;
-		for (logger::Level l = logger::Level::eError; l <= max_log_level_v; l = static_cast<logger::Level>(static_cast<int>(l) + 1)) {
-			ImGui::SameLine();
-			ImGui::Checkbox(levels_v[static_cast<std::size_t>(l)].data(), &m_level_filter[l]);
-		}
+	static constexpr std::string_view levels_v[] = {"Error", "Warn", "Info", "Debug"};
+	static constexpr auto max_log_level_v = debug_v ? logger::Level::eDebug : logger::Level::eInfo;
+	for (logger::Level l = logger::Level::eError; l <= max_log_level_v; l = static_cast<logger::Level>(static_cast<int>(l) + 1)) {
+		ImGui::SameLine();
+		ImGui::Checkbox(levels_v[static_cast<std::size_t>(l)].data(), &m_level_filter[l]);
+	}
+	ImGui::SameLine();
+	ImGui::SeparatorEx(ImGuiSeparatorFlags_Vertical);
+	ImGui::SameLine();
+	ImGui::Checkbox("Auto-scroll", &m_auto_scroll);
 
-		logger::access_buffer(*this);
-		auto child = editor::Window{window, "scroll", {}, {}, ImGuiWindowFlags_HorizontalScrollbar};
-		static constexpr auto im_colour = [](logger::Level const l) {
-			switch (l) {
-			case logger::Level::eError: return ImVec4{1.0f, 0.0f, 0.0f, 1.0f};
-			case logger::Level::eWarn: return ImVec4{1.0f, 1.0f, 0.0f, 1.0f};
-			default:
-			case logger::Level::eInfo: return ImVec4{1.0f, 1.0f, 1.0f, 1.0f};
-			case logger::Level::eDebug: return ImVec4{0.5f, 0.5f, 0.5f, 1.0f};
-			}
-		};
-		if (auto style = editor::StyleVar{ImGuiStyleVar_ItemSpacing, glm::vec2{}}) {
-			for (auto const* entry : m_list) ImGui::TextColored(im_colour(entry->level), "%s", entry->message.c_str());
+	ImGui::Separator();
+	logger::access_buffer(*this);
+	auto child = editor::Window{window, "scroll", {}, {}, ImGuiWindowFlags_HorizontalScrollbar};
+	static constexpr auto im_colour = [](logger::Level const l) {
+		switch (l) {
+		case logger::Level::eError: return ImVec4{1.0f, 0.0f, 0.0f, 1.0f};
+		case logger::Level::eWarn: return ImVec4{1.0f, 1.0f, 0.0f, 1.0f};
+		default:
+		case logger::Level::eInfo: return ImVec4{1.0f, 1.0f, 1.0f, 1.0f};
+		case logger::Level::eDebug: return ImVec4{0.5f, 0.5f, 0.5f, 1.0f};
 		}
+	};
+	auto span = std::span{m_list};
+	auto const max_size = static_cast<std::size_t>(m_display_count);
+	if (span.size() > max_size) { span = span.subspan(span.size() - max_size); }
+	if (auto style = editor::StyleVar{ImGuiStyleVar_ItemSpacing, glm::vec2{}}) {
+		for (auto const* entry : span) ImGui::TextColored(im_colour(entry->level), "%s", entry->message.c_str());
 	}
+
+	if (m_auto_scroll && ImGui::GetScrollY() >= ImGui::GetScrollMaxY()) { ImGui::SetScrollHereY(1.0f); }
 }
 
 void Log::operator()(std::span<logger::Entry const> entries) {
 	m_list.clear();
 	for (auto const& entry : entries) {
-		if (m_list.size() >= static_cast<std::size_t>(m_display_count)) { break; }
 		if (!m_level_filter[entry.level]) { continue; }
 		m_list.push_back(&entry);
 	}

lib/engine/src/engine.cpp

@@ -12,31 +12,17 @@ UniqueWin make_window(glm::ivec2 extent, char const* title) {
 	glfwSetWindowSize(ret.get(), extent.x, extent.y);
 	return ret;
 }
-
-constexpr auto get_samples(vk::SampleCountFlags supported, std::uint8_t desired) {
-	if (desired >= 32 && (supported & vk::SampleCountFlagBits::e32)) { return vk::SampleCountFlagBits::e32; }
-	if (desired >= 16 && (supported & vk::SampleCountFlagBits::e16)) { return vk::SampleCountFlagBits::e16; }
-	if (desired >= 8 && (supported & vk::SampleCountFlagBits::e8)) { return vk::SampleCountFlagBits::e8; }
-	if (desired >= 4 && (supported & vk::SampleCountFlagBits::e4)) { return vk::SampleCountFlagBits::e4; }
-	if (desired >= 2 && (supported & vk::SampleCountFlagBits::e2)) { return vk::SampleCountFlagBits::e2; }
-	return vk::SampleCountFlagBits::e1;
-}
-
-Renderer::CreateInfo make_renderer_info(Gpu const& gpu, std::uint8_t sample_count) {
-	return Renderer::CreateInfo{command_buffers_v, get_samples(gpu.properties.limits.framebufferColorSampleCounts, sample_count)};
-}
 } // namespace
 
 struct Engine::Impl {
 	UniqueWin window;
 	Vulkan vulkan;
 	Gfx gfx;
-
 	Renderer renderer;
 
 	Impl(CreateInfo const& info)
 		: window(make_window(info.extent, info.title)), vulkan(GlfwWsi{window}), gfx{vulkan.gfx()},
-		  renderer(gfx, window, make_renderer_info(vulkan.gpu(), info.msaa_samples)) {}
+		  renderer(gfx, window, Renderer::CreateInfo{command_buffers_v, info.msaa_samples}) {}
 };
 
 Engine::Engine(Engine&&) noexcept = default;

lib/render/include/facade/render/renderer.hpp

@@ -8,6 +8,7 @@
 
 namespace facade {
 struct FrameStats {
+	std::string_view gpu_name{};
 	///
 	/// \brief Total frames so far
 	///
@@ -28,20 +29,23 @@ struct FrameStats {
 	/// \brief Current present mode
 	///
 	vk::PresentModeKHR mode{};
+	///
+	/// \brief Multi-sampled anti-aliasing level
+	///
+	vk::SampleCountFlagBits msaa{};
 };
 
 struct RendererCreateInfo {
 	std::size_t command_buffers{1};
-	vk::SampleCountFlagBits samples{vk::SampleCountFlagBits::e1};
+	std::uint8_t desired_msaa{1};
 };
 
 class Renderer {
   public:
 	using CreateInfo = RendererCreateInfo;
 
 	struct Info {
-		vk::PresentModeKHR mode{};
-		vk::SampleCountFlagBits samples{};
+		vk::SampleCountFlags supported_msaa{};
 		ColourSpace colour_space{};
 		std::size_t cbs_per_frame{};
 	};

lib/render/src/renderer.cpp

@@ -17,6 +17,15 @@ vk::Format depth_format(vk::PhysicalDevice const gpu) {
 	return vk::Format::eD16Unorm;
 }
 
+constexpr auto get_samples(vk::SampleCountFlags supported, std::uint8_t desired) {
+	if (desired >= 32 && (supported & vk::SampleCountFlagBits::e32)) { return vk::SampleCountFlagBits::e32; }
+	if (desired >= 16 && (supported & vk::SampleCountFlagBits::e16)) { return vk::SampleCountFlagBits::e16; }
+	if (desired >= 8 && (supported & vk::SampleCountFlagBits::e8)) { return vk::SampleCountFlagBits::e8; }
+	if (desired >= 4 && (supported & vk::SampleCountFlagBits::e4)) { return vk::SampleCountFlagBits::e4; }
+	if (desired >= 2 && (supported & vk::SampleCountFlagBits::e2)) { return vk::SampleCountFlagBits::e2; }
+	return vk::SampleCountFlagBits::e1;
+}
+
 ///
 /// \brief Tracks frames per second
 ///
@@ -38,6 +47,8 @@ struct Fps {
 
 struct Renderer::Impl {
 	Gfx gfx;
+	vk::SampleCountFlags supported_msaa{};
+	vk::SampleCountFlagBits msaa{};
 	Glfw::Window window;
 	Swapchain swapchain;
 
@@ -66,18 +77,20 @@ struct Renderer::Impl {
 
 	struct {
 		FrameStats stats{};
+		std::string gpu_name{};
 		std::uint64_t triangles{};	// reset every frame
 		std::uint32_t draw_calls{}; // reset every frame
 	} stats{};
 
 	Impl(Gfx gfx, Glfw::Window window, Renderer::CreateInfo const& info)
-		: gfx{gfx}, window{window}, swapchain{gfx, GlfwWsi{window}.make_surface(gfx.instance)}, pipes(gfx, info.samples),
-		  render_pass(gfx, info.samples, this->swapchain.info.imageFormat, depth_format(gfx.gpu)), render_frames(make_render_frames(gfx, info.command_buffers)),
+		: gfx{gfx}, supported_msaa(gfx.gpu.getProperties().limits.framebufferColorSampleCounts),
+		  msaa(get_samples(supported_msaa, info.desired_msaa)), window{window}, swapchain{gfx, GlfwWsi{window}.make_surface(gfx.instance)}, pipes(gfx, msaa),
+		  render_pass(gfx, msaa, this->swapchain.info.imageFormat, depth_format(gfx.gpu)), render_frames(make_render_frames(gfx, info.command_buffers)),
 		  dear_imgui(DearImGui::CreateInfo{
 			  gfx,
 			  window,
 			  render_pass.render_pass(),
-			  info.samples,
+			  msaa,
 			  Swapchain::colour_space(swapchain.info.imageFormat),
 		  }) {}
 
@@ -92,6 +105,10 @@ struct Renderer::Impl {
 
 Renderer::Renderer(Gfx gfx, Glfw::Window window, CreateInfo const& info) : m_impl{std::make_unique<Impl>(std::move(gfx), window, info)} {
 	m_impl->swapchain.refresh(Swapchain::Spec{window.framebuffer_extent()});
+	m_impl->stats.gpu_name = m_impl->gfx.gpu.getProperties().deviceName.data();
+	m_impl->stats.stats.gpu_name = m_impl->stats.gpu_name;
+	m_impl->stats.stats.msaa = m_impl->msaa;
+	logger::info("[Renderer] buffering (frames): [{}] | MSAA: [{}x] | max threads: [{}] |", buffering_v, to_int(m_impl->msaa), info.command_buffers);
 }
 
 Renderer::Renderer(Renderer&&) noexcept = default;
@@ -100,8 +117,7 @@ Renderer::~Renderer() noexcept = default;
 
 auto Renderer::info() const -> Info {
 	return {
-		.mode = m_impl->swapchain.info.presentMode,
-		.samples = m_impl->render_pass.samples(),
+		.supported_msaa = m_impl->supported_msaa,
 		.colour_space = m_impl->swapchain.colour_space(),
 		.cbs_per_frame = m_impl->render_frames.get().secondary.size(),
 	};

lib/util/include/facade/util/logger.hpp

@@ -16,18 +16,26 @@ struct Entry {
 	Level level{};
 };
 
+struct BufferSize {
+	std::size_t limit{500};
+	std::size_t delta{100};
+
+	constexpr std::size_t total() const { return limit + delta; }
+};
+
 struct Accessor {
 	virtual void operator()(std::span<Entry const> entries) = 0;
 };
 
 int thread_id();
 std::string format(Level level, std::string_view const message);
 void log_to(Pipe pipe, Entry entry);
+BufferSize const& buffer_size();
 void access_buffer(Accessor& accessor);
 
 class Instance : public Pinned {
   public:
-	Instance(std::size_t buffer_limit = 500, std::size_t buffer_extra = 100);
+	Instance(BufferSize const& buffer_size = {});
 	~Instance();
 };
 

lib/util/src/logger.cpp

@@ -84,8 +84,7 @@ class FileLogger : Pinned {
 
 struct Storage {
 	struct Buffer {
-		std::size_t limit{};
-		std::size_t extra{};
+		logger::BufferSize size{};
 
 		std::vector<logger::Entry> entries{};
 	};
@@ -118,14 +117,16 @@ void logger::log_to(Pipe pipe, Entry entry) {
 	g_storage.buffer.entries.push_back(std::move(entry));
 }
 
+logger::BufferSize const& logger::buffer_size() { return g_storage.buffer.size; }
+
 void logger::access_buffer(Accessor& accessor) {
 	auto lock = std::scoped_lock{g_storage.mutex};
 	accessor(g_storage.buffer.entries);
 }
 
-logger::Instance::Instance(std::size_t buffer_limit, std::size_t buffer_extra) {
+logger::Instance::Instance(logger::BufferSize const& buffer_size) {
 	auto lock = std::scoped_lock{g_storage.mutex};
-	g_storage.buffer = Storage::Buffer{buffer_limit, buffer_extra};
+	g_storage.buffer = Storage::Buffer{buffer_size};
 	g_storage.file_logger.emplace("facade.log");
 }
 

lib/vk/include/facade/vk/render_pass.hpp

@@ -12,7 +12,6 @@ class RenderPass {
 	void bind(vk::CommandBuffer cb, vk::Pipeline pipeline);
 	void execute(Framebuffer const& framebuffer, vk::ClearColorValue const& clear);
 
-	vk::SampleCountFlagBits samples() const { return m_samples; }
 	vk::RenderPass render_pass() const { return *m_render_pass; }
 
   private:

lib/vk/include/facade/vk/vma.hpp

@@ -8,7 +8,7 @@ template <typename T, typename U = T>
 using Pair = std::pair<T, U>;
 
 template <typename Type>
-concept BufferWrite = !std::is_pointer_v<Type> && std::is_trivially_destructible_v<Type>;
+concept BufferWrite = (!std::is_pointer_v<Type>) && std::is_trivially_destructible_v<Type>;
 
 constexpr vk::Format srgb_formats_v[] = {vk::Format::eR8G8B8A8Srgb, vk::Format::eB8G8R8A8Srgb, vk::Format::eA8B8G8R8SrgbPack32};
 constexpr vk::Format linear_formats_v[] = {vk::Format::eR8G8B8A8Unorm, vk::Format::eB8G8R8A8Unorm};
@@ -30,6 +30,19 @@ constexpr std::string_view present_mode_str(vk::PresentModeKHR const mode) {
 	}
 }
 
+constexpr int to_int(vk::SampleCountFlagBits const samples) {
+	switch (samples) {
+	case vk::SampleCountFlagBits::e64: return 64;
+	case vk::SampleCountFlagBits::e32: return 32;
+	case vk::SampleCountFlagBits::e16: return 16;
+	case vk::SampleCountFlagBits::e8: return 8;
+	case vk::SampleCountFlagBits::e4: return 4;
+	case vk::SampleCountFlagBits::e2: return 2;
+	default:
+	case vk::SampleCountFlagBits::e1: return 1;
+	}
+}
+
 struct BufferView {
 	vk::Buffer buffer{};
 	vk::DeviceSize size{};

lib/vk/src/render_pass.cpp

@@ -67,11 +67,10 @@ vk::UniqueRenderPass create_render_pass(vk::Device device, vk::SampleCountFlagBi
 } // namespace
 
 RenderPass::RenderPass(Gfx const& gfx, vk::SampleCountFlagBits samples, vk::Format colour, vk::Format depth)
-	: m_gfx{gfx}, m_render_pass{create_render_pass(gfx.vma.device, samples, colour, depth)} {
+	: m_gfx{gfx}, m_render_pass{create_render_pass(gfx.vma.device, samples, colour, depth)}, m_samples(samples) {
 	m_colour.image = m_gfx.shared->defer_queue;
 	m_depth.image = m_gfx.shared->defer_queue;
 	m_depth.format = depth;
-	m_samples = samples;
 	if (m_samples > vk::SampleCountFlagBits::e1) { m_colour.format = colour; }
 }
 

lib/vk/src/swapchain.cpp

@@ -1,3 +1,4 @@
+#include <facade/util/logger.hpp>
 #include <facade/vk/swapchain.hpp>
 #include <cassert>
 #include <limits>
@@ -85,6 +86,7 @@ vk::Result Swapchain::refresh(Spec const& spec) {
 		m_storage.views.insert(m_gfx.vma.make_image_view(image, info.imageFormat));
 		m_storage.images.insert({image, *m_storage.views.span().back(), info.imageExtent});
 	}
+	logger::info("[Swapchain] images: [{}] | colour space: [{}] |", m_storage.images.size(), is_srgb(info.imageFormat) ? "sRGB" : "linear");
 	return ret;
 }
 

lib/vk/src/vk.cpp

@@ -171,12 +171,13 @@ UniqueVma Vulkan::make_vma(vk::Instance instance, vk::PhysicalDevice gpu, vk::De
 	return ret;
 }
 
-Vulkan ::Vulkan(Wsi const& wsi) noexcept(false) {
+Vulkan::Vulkan(Wsi const& wsi) noexcept(false) {
 	instance = Vulkan::Instance::make(wsi.extensions(), Vulkan::eValidation);
 	auto surface = wsi.make_surface(*instance.instance);
 	device = Vulkan::Device::make(instance, *surface);
 	vma = Vulkan::make_vma(*instance.instance, device.gpu.device, *device.device);
 	shared = std::make_unique<Gfx::Shared>(*device.device, device.gpu.properties);
+	logger::info("[Device] GPU: [{}] |", device.gpu.properties.deviceName.data());
 }
 
 Gfx Vulkan::gfx() const {