SceneEmbedding.cpp

// rendering custom 3D shapes on a Vulkan offscreen framebuffer and composite it as content of a view component

#include <ViewDesign/view/widget/DefaultWindow.h>
#include <ViewDesign/view/frame/CenterFrame.h>
#include <ViewDesign/view/frame/BorderFrame.h>
#include <ViewDesign/view/control/Placeholder.h>

#include <ViewDesign/platform/vulkan/texture.h>
#include <ViewDesign/platform/vulkan/pipeline/composite.h>

#include "pipeline/tetra.h"

#include <chrono>
#include <optional>

#include <glm/gtc/matrix_transform.hpp> 


using namespace ViewDesign;


class EmbeddedView : public Placeholder<Auto, Auto> {
private:
	// the existing `Vulkan::Framebuffer` and `Vulkan::Render()` are used for `Layer` or `Surface` to render a `Canvas` with transform/clip context
	// therefore, we define `Scene` as our framebuffer with an additional depth image and a custom render function
	class Scene {
	public:
		static constexpr SizeU size = SizeU(400, 400);
	public:
		Texture color_texture;
		Texture depth_texture;
	public:
		Scene() : color_texture(size) {
			depth_texture.CreateDepthImage(size);
			depth_texture.ClearDepthImage();
		}
	public:
		void Render() {
			// called during `EmbeddedView::OnDraw()`, reusing the command buffer of the current frame-in-flight of the window's surface
			// the frame-in-flight itself is currently not being rendered
			FrameInFlight& frame_in_flight = FrameInFlight::GetCurrent();
			vk::raii::CommandBuffer& command_buffer = frame_in_flight.command_buffer;

			static constexpr vk::ClearValue color_clear_value = vk::ClearValue(vk::ClearColorValue(std::array<float, 4>{ 0.0f, 0.0f, 0.0f, 0.0f }));
			static constexpr vk::ClearValue depth_clear_value = vk::ClearValue(vk::ClearDepthStencilValue(1.0f, 0));

			vk::Extent2D extent = color_texture.extent;

			TransitionImageLayout(command_buffer, *color_texture.image, color_texture.image_layout, vk::ImageLayout::eColorAttachmentOptimal);
			vk::RenderingAttachmentInfo color_attachment(*color_texture.image_view, vk::ImageLayout::eColorAttachmentOptimal, {}, {}, {}, vk::AttachmentLoadOp::eClear, vk::AttachmentStoreOp::eStore, color_clear_value);
			vk::RenderingAttachmentInfo depth_attachment(*depth_texture.image_view, vk::ImageLayout::eDepthAttachmentOptimal, {}, {}, {}, vk::AttachmentLoadOp::eClear, vk::AttachmentStoreOp::eDontCare, depth_clear_value);
			command_buffer.beginRendering(vk::RenderingInfo({}, vk::Rect2D({}, extent), 1, 0, color_attachment, &depth_attachment));

			{
				using Layout = TetraPipeline::Layout;
				using Vertex = TetraPipeline::Input;

				static constexpr float s = 0.8165f; // sqrt(2/3)
				static constexpr float h = 0.5774f; // 1/sqrt(3)

				static constexpr std::array<Vertex, 4> v = {
					Vertex({ s, -h, 0.0f }, { 1, 0, 0 }),
					Vertex({ -s, -h, 0.0f }, { 0, 1, 0 }),
					Vertex({ 0.0f, h, -1.0f }, { 0, 0, 1 }),
					Vertex({ 0.0f, h, 1.0f }, { 1, 1, 0 }),
				};

				static constexpr std::array<Vertex, 12> vertices = {
					v[0], v[1], v[2],
					v[0], v[2], v[3],
					v[0], v[1], v[3],
					v[1], v[2], v[3],
				};

				command_buffer.setViewport(0, vk::Viewport(0.0f, 0.0f, extent.width, extent.height, 0.0f, 1.0f));
				command_buffer.setScissor(0, vk::Rect2D({}, extent));
				command_buffer.bindPipeline(vk::PipelineBindPoint::eGraphics, *GetPipeline<TetraPipeline>());

				float t = std::chrono::duration<float>(std::chrono::steady_clock::now().time_since_epoch()).count();
				glm::mat4 model = glm::rotate(glm::mat4(1.0f), t, glm::vec3(0.4f, 1.0f, 0.3f));
				glm::mat4 view = glm::lookAt(glm::vec3(0.0f, 0.0f, 3.5f), glm::vec3(0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
				glm::mat4 proj = glm::perspective(glm::radians(45.0f), (float)extent.width / extent.height, 0.1f, 100.0f);
				glm::mat4 mvp = proj * view * model;
				command_buffer.pushConstants<glm::mat4>(*GetPipelineLayout<Layout>(), vk::ShaderStageFlagBits::eVertex, offsetof(Layout::Context, vertex.mvp), mvp);

				auto [vertex_buffer, offset] = frame_in_flight.PushVertices(vertices.data(), sizeof(vertices));
				command_buffer.bindVertexBuffers(0, vertex_buffer, { offset });
				command_buffer.draw(vertices.size(), 1, 0, 0);
			}

			command_buffer.endRendering();
			TransitionImageLayout(command_buffer, *color_texture.image, color_texture.image_layout, vk::ImageLayout::eShaderReadOnlyOptimal);
		}
	};

	struct SceneFigure : Figure {
		Scene& scene;

		SceneFigure(Scene& scene) : scene(scene) {}

		virtual void DrawOn(RenderTarget& target, Point point) const override {
			// the frame-in-flight is currently being rendered
			// `Scene::Render()` should not be called here
			target.BindPipeline<CompositePipeline>();
			CompositePipeline::SetOpacity(target, 1.0f);
			CompositePipeline::BindTexture(target, scene.color_texture);
			target.DrawVertices(Zip(GetVertices(AsQuad(Rect(point, scene.size))), GetVertices(AsQuad(Rect(0.0f, 0.0f, 1.0f, 1.0f)))));
		}
	};

public:
	EmbeddedView() : Placeholder(Scene::size) {}

private:
	std::optional<Scene> scene;
public:
	void Redraw() { Placeholder::Redraw(rect_infinite); }
private:
	virtual void OnDraw(Canvas& canvas, Rect draw_region) override {
		// `Scene` should also be created during `EmbeddedView::OnDraw()`, because it uses the command buffer of the current frame-in-flight as well
		if (!scene.has_value()) { scene.emplace(); }
		scene.value().Render();
		canvas.draw(point_zero, new SceneFigure(*scene));
	}
};


void App() {
	ref_ptr<EmbeddedView> embedded_view;
	desktop.AddWindow(
		new DefaultWindow(
			DefaultWindow::Style(),
			u"SceneEmbedding",
			new CenterFrame<Fixed, Fixed>(
				new BorderFrame(
					Border(2.0f, ColorCode::Orange),
					embedded_view = new EmbeddedView()
				)
			)
		)
	);

	for (;;) {
		desktop.PollEvents();

		if (desktop.WindowListEmpty()) {
			break;
		}

		// `embedded_view` becomes a dangling reference after the window is closed
		embedded_view->Redraw();
	}
}