We be kinda rendering

2026-01-05 06:20:49 +01:00
parent 1168f9e5d1
commit c83c423b42
48 changed files with 2789 additions and 382 deletions
@@ -0,0 +1,149 @@
+#include <destrum/Graphics/Renderer.h>
+
+#include <destrum/Graphics/Util.h>
+
+GameRenderer::GameRenderer(MeshCache& meshCache): meshCache{meshCache} {
+}
+
+void GameRenderer::init(GfxDevice& gfxDevice, const glm::ivec2& drawImageSize) {
+    sceneDataBuffer.init(
+        gfxDevice,
+        VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
+        sizeof(GPUSceneData),
+        "scene data");
+
+    createDrawImage(gfxDevice, drawImageSize, true);
+
+    meshPipeline = std::make_unique<MeshPipeline>();
+    meshPipeline->init(gfxDevice, drawImageFormat, depthImageFormat);
+
+}
+
+void GameRenderer::beginDrawing(GfxDevice& gfxDevice) {
+    meshDrawCommands.clear();
+}
+
+void GameRenderer::endDrawing() {
+    //Sort the drawlist
+}
+
+void GameRenderer::draw(VkCommandBuffer cmd, GfxDevice& gfxDevice, const Camera& camera, const SceneData& sceneData) {
+    const auto gpuSceneData = GPUSceneData{
+        .view = sceneData.camera.GetViewMatrix(),
+        .proj = sceneData.camera.GetProjectionMatrix(),
+        .viewProj = sceneData.camera.GetViewProjectionMatrix(),
+        .cameraPos = glm::vec4{sceneData.camera.m_position, 1.f},
+        .ambientColor = {sceneData.ambientColor},
+        .ambientIntensity = sceneData.ambientIntensity,
+        .fogColor = {sceneData.fogColor},
+        .fogDensity = sceneData.fogDensity,
+        .materialsBuffer = materialCache.getMaterialDataBufferAddress(),
+    };
+    sceneDataBuffer.uploadNewData(
+           cmd, gfxDevice.getCurrentFrameIndex(), (void*)&gpuSceneData, sizeof(GPUSceneData));
+
+    const auto& drawImage = gfxDevice.getImage(drawImageId);
+    const auto& depthImage = gfxDevice.getImage(depthImageId);
+
+    // vkutil::cmdBeginLabel(cmd, "Geometry");
+    vkutil::transitionImage(
+            cmd,
+            drawImage.image,
+            VK_IMAGE_LAYOUT_UNDEFINED,
+            VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
+
+    vkutil::transitionImage(
+        cmd,
+        depthImage.image,
+        VK_IMAGE_LAYOUT_UNDEFINED,
+        VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL);
+
+    const auto renderInfo = vkutil::createRenderingInfo({
+           .renderExtent = drawImage.getExtent2D(),
+           .colorImageView = drawImage.imageView,
+           .colorImageClearValue = glm::vec4{0.f, 0.f, 0.f, 1.f},
+           .depthImageView = depthImage.imageView,
+           .depthImageClearValue = 0.f,
+       });
+
+    vkCmdBeginRendering(cmd, &renderInfo.renderingInfo);
+    meshPipeline->draw(
+            cmd,
+            drawImage.getExtent2D(),
+            gfxDevice,
+            meshCache,
+            materialCache,
+            camera,
+            sceneDataBuffer.getBuffer(),
+            meshDrawCommands,
+            sortedMeshDrawCommands);
+
+    vkCmdEndRendering(cmd);
+    // vkutil::cmdEndLabel(cmd);
+
+
+}
+
+void GameRenderer::cleanup() {
+}
+
+void GameRenderer::drawMesh(MeshID id, const glm::mat4& transform, MaterialId materialId) {
+    const auto& mesh = meshCache.getMesh(id);
+    // const auto worldBoundingSphere = edge::calculateBoundingSphereWorld(transform, mesh.boundingSphere, false);
+    assert(materialId != NULL_MATERIAL_ID);
+
+    meshDrawCommands.push_back(MeshDrawCommand{
+        .meshId = id,
+        .transformMatrix = transform,
+        .materialId = materialId,
+    });
+}
+
+void GameRenderer::createDrawImage(GfxDevice& gfxDevice,
+                                   const glm::ivec2& drawImageSize,
+                                   bool firstCreate)
+{
+    const VkExtent3D drawImageExtent{
+        .width  = (std::uint32_t)drawImageSize.x,
+        .height = (std::uint32_t)drawImageSize.y,
+        .depth  = 1,
+    };
+
+    constexpr VkSampleCountFlagBits noMsaa = VK_SAMPLE_COUNT_1_BIT;
+
+    { // setup draw image (single-sampled)
+        VkImageUsageFlags usages{};
+        usages |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
+        usages |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+        usages |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+        usages |= VK_IMAGE_USAGE_SAMPLED_BIT;
+
+        auto createImageInfo = vkutil::CreateImageInfo{
+            .format  = drawImageFormat,
+            .usage   = usages,
+            .extent  = drawImageExtent,
+            .samples = noMsaa,
+        };
+
+        // reuse the same id if creating again
+        drawImageId = gfxDevice.createImage(createImageInfo, "draw image", nullptr, drawImageId);
+
+        if (firstCreate) {
+            // Optional: a separate post-fx target (ping-pong)
+            // postFXDrawImageId = gfxDevice.createImage(createImageInfo, "post FX draw image");
+        }
+    }
+
+
+    { // setup depth image (single-sampled)
+        auto createInfo = vkutil::CreateImageInfo{
+            .format  = depthImageFormat,
+            .usage   = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
+            .extent  = drawImageExtent,
+            .samples = noMsaa,
+        };
+
+        depthImageId = gfxDevice.createImage(createInfo, "depth image", nullptr, depthImageId);
+
+    }
+}