Refactor renderers (#75)

* Store all scene rendering resources in SceneRenderer

- Remove `Drawer`.

* Improve instance buffers

- Add `BufferView::count`, defaulted to 1.
- Add `Buffer::Type::eInstance` for vertex buffers with instance data.
- Make `Buffer::write()` strongly typed and take a span to store the count.
- Add `StaticMesh::draw()`.
- Update gltf2cpp.

* Add MorphWeights, refactor Animation

* Move Fps and Stats to Engine

- Remove `Renderer::draw()`, store its stats in `SceneRenderer` + `Engine`.

* Use SceneRenderer to bind instance buffers

- Remove MeshView.

* Incorporate primitive topology

* Add RenderMode

- Replace `Scene::pipeline_state` with `render_mode`.
- Remove `Pipeline::State::line_width`.
- Reflect `StaticMesh::topology()` in inspector.

Author: karnkaul

lib/engine/CMakeLists.txt

@@ -39,6 +39,7 @@ endif()
 target_sources(${PROJECT_NAME} PRIVATE
   include/${target_prefix}/engine/engine.hpp
   include/${target_prefix}/engine/scene_renderer.hpp
+  include/${target_prefix}/engine/stats.hpp
 
   include/${target_prefix}/engine/editor/browse_file.hpp
   include/${target_prefix}/engine/editor/common.hpp

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

@@ -1,5 +1,6 @@
 #pragma once
 #include <facade/build_version.hpp>
+#include <facade/engine/stats.hpp>
 #include <facade/glfw/glfw.hpp>
 #include <facade/scene/load_status.hpp>
 #include <facade/scene/scene.hpp>
@@ -101,6 +102,9 @@ class Engine {
 	glm::uvec2 window_extent() const;
 	glm::uvec2 framebuffer_extent() const;
 
+	Stats const& stats() const;
+	std::string_view gpu_name() const;
+
 	Scene& scene() const;
 	State const& state() const;
 	Input const& input() const;

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

@@ -8,26 +8,44 @@ class Skybox;
 
 class SceneRenderer {
   public:
+	struct Info {
+		std::uint32_t triangles_drawn{};
+		std::uint32_t draw_calls{};
+	};
+
 	explicit SceneRenderer(Gfx const& gfx);
 
+	Info const& info() const { return m_info; }
 	void render(Scene const& scene, Ptr<Skybox const> skybox, Renderer& renderer, vk::CommandBuffer cb);
 
   private:
 	void write_view(glm::vec2 const extent);
 	void update_view(Pipeline& out_pipeline) const;
-	std::span<glm::mat4x4 const> make_instances(Node const& node, glm::mat4x4 const& parent) const;
+	std::span<glm::mat4x4 const> make_instance_mats(Node const& node, glm::mat4x4 const& parent);
+
+	void render(Renderer& renderer, vk::CommandBuffer cb, Skybox const& skybox);
+	void render(Renderer& renderer, vk::CommandBuffer cb, Node const& node, glm::mat4 parent = matrix_identity_v);
+	void draw(vk::CommandBuffer cb, StaticMesh const& static_mesh, std::span<glm::mat4x4 const> mats);
+
+	BufferView next_instances(std::span<glm::mat4x4 const> mats);
+
+	struct Instances {
+		std::vector<Buffer> buffers{};
+		std::size_t index{};
 
-	void render(Renderer& renderer, vk::CommandBuffer cb, Skybox const& skybox) const;
-	void render(Renderer& renderer, vk::CommandBuffer cb, Node const& node, glm::mat4 parent = matrix_identity_v) const;
+		void rotate();
+	};
 
 	Gfx m_gfx;
+	Instances m_instances{};
 	Sampler m_sampler;
 	Buffer m_view_proj;
 	Buffer m_dir_lights;
 	Texture m_white;
 	Texture m_black;
+	Info m_info{};
 
-	mutable std::vector<glm::mat4x4> m_instance_mats{};
+	std::vector<glm::mat4x4> m_instance_mats{};
 	Scene const* m_scene{};
 };
 } // namespace facade

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

@@ -0,0 +1,44 @@
+#pragma once
+#include <vulkan/vulkan.hpp>
+#include <string_view>
+
+namespace facade {
+///
+/// \brief Stores various statistics.
+///
+struct Stats {
+	///
+	/// \brief Total frames so far.
+	///
+	std::uint64_t frame_counter{};
+
+	///
+	/// \brief Triangles drawn in previous frame.
+	///
+	std::uint64_t triangles{};
+
+	///
+	/// \brief Draw calls in previous frame.
+	///
+	std::uint32_t draw_calls{};
+
+	///
+	/// \brief Framerate (until previous frame).
+	///
+	std::uint32_t fps{};
+
+	///
+	/// \brief Current present mode.
+	///
+	vk::PresentModeKHR mode{};
+
+	///
+	/// \brief Multi-sampled anti-aliasing level.
+	///
+	vk::SampleCountFlagBits current_msaa{};
+	///
+	/// \brief Supported anti-aliasing levels.
+	///
+	vk::SampleCountFlags supported_msaa{};
+};
+} // namespace facade

lib/engine/src/editor/inspector.cpp

@@ -31,6 +31,18 @@ void edit_material(SceneResources const& resources, UnlitMaterial& unlit) {
 	if (unlit.texture) { name = FixedString<128>{"{} ({})", resources.textures[*unlit.texture].name(), *unlit.texture}; }
 	make_id_slot(unlit.texture, "Texture", name.c_str(), {true});
 }
+
+constexpr std::string_view to_str(vk::PrimitiveTopology const topo) {
+	switch (topo) {
+	case vk::PrimitiveTopology::ePointList: return "Point list";
+	case vk::PrimitiveTopology::eLineList: return "Line list";
+	case vk::PrimitiveTopology::eLineStrip: return "Line strip";
+	case vk::PrimitiveTopology::eTriangleList: return "Triangle list";
+	case vk::PrimitiveTopology::eTriangleStrip: return "Triangle strip";
+	case vk::PrimitiveTopology::eTriangleFan: return "Triangle fan";
+	default: return "(Unsupported)";
+	}
+}
 } // namespace
 
 void ResourceInspector::view(Texture const& texture, Id<Texture> id) const {
@@ -51,8 +63,10 @@ void ResourceInspector::view(StaticMesh const& mesh, Id<StaticMesh> id) const {
 	auto tn = TreeNode{name.c_str()};
 	drag_payload(id, name.c_str());
 	if (tn) {
-		ImGui::Text("%s", FixedString{"Vertices: {}", mesh.view().vertex_count}.c_str());
-		ImGui::Text("%s", FixedString{"Indices: {}", mesh.view().index_count}.c_str());
+		auto const info = mesh.info();
+		ImGui::Text("%s", FixedString{"Vertices: {}", info.vertices}.c_str());
+		ImGui::Text("%s", FixedString{"Indices: {}", info.indices}.c_str());
+		ImGui::Text("%s", FixedString{"Topology: {}", to_str(mesh.topology())}.c_str());
 	}
 }
 

lib/engine/src/engine.cpp

@@ -225,6 +225,21 @@ struct LoadRequest {
 	AtomicLoadStatus status{};
 	float start_time{};
 };
+
+struct Fps {
+	std::uint32_t frames{};
+	std::uint32_t fps{};
+	float start{time::since_start()};
+
+	std::uint32_t next_frame() {
+		++frames;
+		if (auto const now = time::since_start(); now - start >= 1.0f) {
+			start = now;
+			fps = std::exchange(frames, 0);
+		}
+		return fps;
+	}
+};
 } // namespace
 
 struct Engine::Impl {
@@ -237,6 +252,8 @@ struct Engine::Impl {
 
 	ThreadPool thread_pool{};
 	std::mutex mutex{};
+	Stats stats{};
+	Fps fps{};
 
 	struct {
 		LoadRequest request{};
@@ -293,6 +310,8 @@ auto Engine::poll() -> State const& {
 	m_impl->window.window.get().glfw->poll_events();
 	auto const& ret = m_impl.get()->window.window.get().state();
 	m_impl->scene.tick(ret.dt);
+	m_impl->stats.fps = m_impl->fps.next_frame();
+	++m_impl->stats.frame_counter;
 	return ret;
 }
 
@@ -302,6 +321,17 @@ void Engine::render() {
 	if (m_impl->window.renderer.next_frame({&cb, 1})) { m_impl->renderer.render(scene(), &m_impl->skybox, renderer(), cb); }
 	m_impl->window.gui->end_frame();
 	m_impl->window.renderer.render();
+	{
+		auto const& info = m_impl->renderer.info();
+		m_impl->stats.draw_calls = info.draw_calls;
+		m_impl->stats.triangles = info.triangles_drawn;
+	}
+	{
+		auto info = m_impl->window.renderer.info();
+		m_impl->stats.mode = info.present_mode;
+		m_impl->stats.current_msaa = info.current_msaa;
+		m_impl->stats.supported_msaa = info.supported_msaa;
+	}
 }
 
 void Engine::request_stop() { glfwSetWindowShouldClose(window(), GLFW_TRUE); }
@@ -310,6 +340,9 @@ glm::ivec2 Engine::window_position() const { return m_impl->window.window.get().
 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(); }
 
+Stats const& Engine::stats() const { return m_impl->stats; }
+std::string_view Engine::gpu_name() const { return m_impl->window.renderer.gpu_name(); }
+
 bool Engine::load_async(std::string json_path, UniqueTask<void()> on_loaded) {
 	if (!fs::is_regular_file(json_path)) {
 		// early return if file will fail to load anyway

lib/engine/src/scene_renderer.cpp

@@ -19,36 +19,43 @@ struct DirLightSSBO {
 };
 } // namespace
 
+void SceneRenderer::Instances::rotate() {
+	for (auto& buffer : buffers) { buffer.rotate(); }
+	index = 0;
+}
+
 SceneRenderer::SceneRenderer(Gfx const& gfx)
 	: m_gfx(gfx), m_sampler(gfx), m_view_proj(gfx, Buffer::Type::eUniform), m_dir_lights(gfx, Buffer::Type::eStorage),
 	  m_white(gfx, m_sampler.sampler(), Bmp1x1{0xff_B, 0xff_B, 0xff_B, 0xff_B}.view(), Texture::CreateInfo{.mip_mapped = false}),
 	  m_black(gfx, m_sampler.sampler(), Bmp1x1{0x0_B, 0x0_B, 0x0_B, 0xff_B}.view(), Texture::CreateInfo{.mip_mapped = false}) {}
 
 void SceneRenderer::render(Scene const& scene, Ptr<Skybox const> skybox, Renderer& renderer, vk::CommandBuffer cb) {
 	m_scene = &scene;
+	m_info = {};
 	write_view(renderer.framebuffer_extent());
 	if (skybox) { render(renderer, cb, *skybox); }
 	for (auto const& node : m_scene->roots()) { render(renderer, cb, m_scene->resources().nodes[node]); }
+	m_instances.rotate();
 }
 
 void SceneRenderer::write_view(glm::vec2 const extent) {
 	auto const& cam_node = m_scene->camera();
 	auto const cam_id = cam_node.find<Camera>();
 	assert(cam_id);
 	auto const& cam = m_scene->resources().cameras[*cam_id];
-	struct {
+	struct ViewSSBO {
 		glm::mat4x4 mat_v;
 		glm::mat4x4 mat_p;
 		glm::vec4 vpos_exposure;
-	} vp{
+	} view{
 		.mat_v = cam.view(cam_node.transform),
 		.mat_p = cam.projection(extent),
 		.vpos_exposure = {cam_node.transform.position(), cam.exposure},
 	};
-	m_view_proj.write(&vp, sizeof(vp));
+	m_view_proj.write<ViewSSBO>({&view, 1});
 	auto dir_lights = FlexArray<DirLightSSBO, 4>{};
 	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());
+	m_dir_lights.write(dir_lights.span());
 }
 
 void SceneRenderer::update_view(Pipeline& out_pipeline) const {
@@ -58,7 +65,7 @@ void SceneRenderer::update_view(Pipeline& out_pipeline) const {
 	out_pipeline.bind(set0);
 }
 
-std::span<glm::mat4x4 const> SceneRenderer::make_instances(Node const& node, glm::mat4x4 const& parent) const {
+std::span<glm::mat4x4 const> SceneRenderer::make_instance_mats(Node const& node, glm::mat4x4 const& parent) {
 	m_instance_mats.clear();
 	if (node.instances.empty()) {
 		m_instance_mats.reserve(1);
@@ -70,40 +77,63 @@ std::span<glm::mat4x4 const> SceneRenderer::make_instances(Node const& node, glm
 	return m_instance_mats;
 }
 
-void SceneRenderer::render(Renderer& renderer, vk::CommandBuffer cb, Skybox const& skybox) const {
-	auto state = m_scene->pipeline_state;
-	state.depth_test = false;
-	auto pipeline = renderer.bind_pipeline(cb, state, "skybox");
+void SceneRenderer::render(Renderer& renderer, vk::CommandBuffer cb, Skybox const& skybox) {
+	auto pipeline = renderer.bind_pipeline(cb, {.depth_test = false}, "skybox");
 	pipeline.set_line_width(1.0f);
 	update_view(pipeline);
 	auto& set1 = pipeline.next_set(1);
 	set1.update(0, skybox.cubemap().descriptor_image());
 	pipeline.bind(set1);
-	auto const instance = glm::translate(matrix_identity_v, m_scene->camera().transform.position());
-	renderer.draw(pipeline, skybox.static_mesh(), {&instance, 1});
+	auto const mat = glm::translate(matrix_identity_v, m_scene->camera().transform.position());
+	draw(cb, skybox.static_mesh(), {&mat, 1u});
 }
 
-void SceneRenderer::render(Renderer& renderer, vk::CommandBuffer cb, Node const& node, glm::mat4 parent) const {
+void SceneRenderer::render(Renderer& renderer, vk::CommandBuffer cb, Node const& node, glm::mat4 parent) {
 	auto const& resources = m_scene->resources();
 	if (auto mesh_id = node.find<Mesh>()) {
 		static auto const s_default_material = Material{std::make_unique<LitMaterial>()};
 		auto const& mesh = resources.meshes[*mesh_id];
 		for (auto const& primitive : mesh.primitives) {
 			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);
+			auto const& static_mesh = resources.static_meshes[primitive.static_mesh];
+
+			auto const mode = m_scene->render_mode.type == RenderMode::Type::eWireframe ? vk::PolygonMode::eLine : vk::PolygonMode::eFill;
+			auto pipeline = renderer.bind_pipeline(cb, {.mode = mode, .topology = static_mesh.topology()}, material.shader_id());
+			pipeline.set_line_width(m_scene->render_mode.line_width);
 
 			update_view(pipeline);
 			auto const store = TextureStore{resources.textures, m_white, m_black};
 			material.write_sets(pipeline, store);
 
-			auto const& static_mesh = resources.static_meshes[primitive.static_mesh];
-			auto const instances = make_instances(node, parent);
-			renderer.draw(pipeline, static_mesh, instances);
+			auto const mats = make_instance_mats(node, parent);
+			draw(cb, static_mesh, mats);
 		}
 	}
 
 	parent = parent * node.transform.matrix();
 	for (auto const& id : node.children) { render(renderer, cb, m_scene->resources().nodes[id], parent); }
 }
+
+void SceneRenderer::draw(vk::CommandBuffer cb, StaticMesh const& static_mesh, std::span<glm::mat4x4 const> mats) {
+	auto const instances = next_instances(mats);
+	cb.bindVertexBuffers(1u, instances.buffer, vk::DeviceSize{0});
+	static_mesh.draw(cb, mats.size());
+	m_info.triangles_drawn += static_mesh.info().vertices / 3;
+	++m_info.draw_calls;
+}
+
+BufferView SceneRenderer::next_instances(std::span<glm::mat4x4 const> mats) {
+	auto& buffer = [&]() -> Buffer& {
+		auto ret = Ptr<Buffer>{};
+		if (m_instances.index < m_instances.buffers.size()) {
+			ret = &m_instances.buffers[m_instances.index++];
+		} else {
+			++m_instances.index;
+			ret = &m_instances.buffers.emplace_back(m_gfx, Buffer::Type::eInstance);
+		}
+		return *ret;
+	}();
+	buffer.write(mats);
+	return buffer.view();
+}
 } // namespace facade