Auto stash before merge of "master" and "Gitea/master"

src/Engine/Graphics/RenderPass/BasePass.cpp

@@ -27,6 +27,7 @@ void Seele::addDebugVertices(Array<DebugVertex> verts) { gDebugVertices.addAll(v
 
 BasePass::BasePass(Gfx::PGraphics graphics, PScene scene) : RenderPass(graphics, scene) {
     //waterRenderer = new WaterRenderer(graphics, scene, viewParamsLayout);
+    terrainRenderer = new TerrainRenderer(graphics, scene, viewParamsLayout);
     basePassLayout = graphics->createPipelineLayout("BasePassLayout");
 
     basePassLayout->addDescriptorLayout(viewParamsLayout);
@@ -99,6 +100,7 @@ void BasePass::beginFrame(const Component::Camera& cam) {
     transparentCulling = lightCullingLayout->allocateDescriptorSet();
 
     //waterRenderer->beginFrame();
+    terrainRenderer->beginFrame();
 
     // Debug vertices
     {
@@ -247,7 +249,8 @@ void BasePass::render() {
         }
     }
     
-    //commands.add(waterRenderer->render(viewParamsSet));
+    // commands.add(waterRenderer->render(viewParamsSet));
+    commands.add(terrainRenderer->render(viewParamsSet));
     
     // Skybox
     {
@@ -471,6 +474,7 @@ void BasePass::createRenderPass() {
     tLightGrid = resources->requestTexture("LIGHTCULLING_TLIGHTGRID");
 
     //waterRenderer->setViewport(viewport, renderPass);
+    terrainRenderer->setViewport(viewport, renderPass);
 
     // Debug rendering
     {

src/Engine/Graphics/RenderPass/BasePass.h

@@ -2,6 +2,7 @@
 #include "MinimalEngine.h"
 #include "RenderPass.h"
 #include "WaterRenderer.h"
+#include "TerrainRenderer.h"
 
 namespace Seele {
 DECLARE_REF(CameraActor)
@@ -50,6 +51,7 @@ class BasePass : public RenderPass {
     Gfx::PShaderBuffer cullingBuffer;
 
     OWaterRenderer waterRenderer;
+    OTerrainRenderer terrainRenderer;
 
     // Debug rendering
     Gfx::OVertexInput debugVertexInput;

src/Engine/Graphics/RenderPass/CMakeLists.txt

@@ -15,6 +15,8 @@ target_sources(Engine
         RenderGraphResources.cpp
         RenderPass.h
         RenderPass.cpp
+        TerrainRenderer.h
+        TerrainRenderer.cpp
         TextPass.h
         TextPass.cpp
         UIPass.h
@@ -35,6 +37,7 @@ target_sources(Engine
             RenderGraph.h
             RenderGraphResources.h
             RenderPass.h
+            TerrainRenderer.h
             TextPass.h
             UIPass.h
             VisibilityPass.h)

src/Engine/Graphics/RenderPass/TerrainRenderer.cpp

@@ -0,0 +1,134 @@
+#include "TerrainRenderer.h"
+#include "Asset/AssetRegistry.h"
+#include "Component/TerrainTile.h"
+#include "Graphics/Graphics.h"
+#include "Graphics/Shader.h"
+
+using namespace Seele;
+
+TerrainRenderer::TerrainRenderer(Gfx::PGraphics graphics, PScene scene, Gfx::PDescriptorLayout viewParamsLayout)
+    : graphics(graphics), scene(scene) {
+    tilesBuffer = graphics->createShaderBuffer(ShaderBufferCreateInfo{
+        .dynamic = true,
+        .name = "TilesBuffer",
+    });
+    float displacementData = 0;
+    displacementMap = graphics->createTexture2D(TextureCreateInfo{
+        .sourceData =
+            {
+                .size = sizeof(float),
+                .data = (uint8*)&displacementData,
+            },
+        .format = Gfx::SE_FORMAT_R32_SFLOAT,
+        .width = 1,
+        .height = 1,
+        .depth = 1,
+        .name = "TerrainDisplacement",
+    });
+    sampler = graphics->createSampler(SamplerCreateInfo{});
+    layout = graphics->createDescriptorLayout("pTerrainData");
+    layout->addDescriptorBinding(Gfx::DescriptorBinding{
+        .binding = 0,
+        .descriptorType = Gfx::SE_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+    });
+    layout->addDescriptorBinding(Gfx::DescriptorBinding{
+        .binding = 1,
+        .descriptorType = Gfx::SE_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
+    });
+    layout->addDescriptorBinding(Gfx::DescriptorBinding{
+        .binding = 2,
+        .descriptorType = Gfx::SE_DESCRIPTOR_TYPE_SAMPLER,
+    });
+    layout->create();
+    pipelineLayout = graphics->createPipelineLayout("TerrainLayout");
+    pipelineLayout->addDescriptorLayout(viewParamsLayout);
+    pipelineLayout->addDescriptorLayout(layout);
+    ShaderCompilationInfo s{
+        .name = "TerrainShaders",
+        .modules = {"TerrainPass"},
+        .entryPoints =
+            {
+                {"taskMain", "TerrainPass"},
+                {"meshMain", "TerrainPass"},
+                {"fragmentMain", "TerrainPass"},
+            },
+        .rootSignature = pipelineLayout,
+        .dumpIntermediate = false,
+    };
+    graphics->beginShaderCompilation(s);
+    task = graphics->createTaskShader({0});
+    mesh = graphics->createMeshShader({1});
+    frag = graphics->createFragmentShader({2});
+    pipelineLayout->create();
+}
+
+TerrainRenderer::~TerrainRenderer() {}
+
+void TerrainRenderer::beginFrame() {
+    struct TerrainTile {
+        IVector2 offset;
+        float extent;
+        float height;
+    };
+    Array<TerrainTile> payloads;
+    scene->view<Component::TerrainTile>([&](Component::TerrainTile& tile) {
+        payloads.add(TerrainTile{
+            .offset = IVector2(tile.location),
+            .extent = Component::TerrainTile::DIMENSIONS,
+            .height = tile.height,
+        });
+    });
+    if (payloads.size() == 0)
+        return;
+    tilesBuffer->rotateBuffer(sizeof(TerrainTile) * payloads.size());
+    tilesBuffer->updateContents(0, sizeof(TerrainTile) * payloads.size(), payloads.data());
+    tilesBuffer->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT, Gfx::SE_ACCESS_SHADER_READ_BIT,
+                                 Gfx::SE_PIPELINE_STAGE_TASK_SHADER_BIT_EXT);
+
+    set = layout->allocateDescriptorSet();
+    set->updateBuffer(0, tilesBuffer);
+    set->updateTexture(1, 0, Gfx::PTexture2D(displacementMap));
+    set->updateSampler(2, sampler);
+    set->writeChanges();
+}
+
+Gfx::ORenderCommand TerrainRenderer::render(Gfx::PDescriptorSet viewParamsSet) {
+    Gfx::ORenderCommand command = graphics->createRenderCommand("TerrainRender");
+    command->setViewport(viewport);
+    command->bindPipeline(pipeline);
+    command->bindDescriptor({viewParamsSet, set});
+    command->drawMesh(400, 4, 1);
+    return command;
+}
+
+void TerrainRenderer::setViewport(Gfx::PViewport _viewport, Gfx::PRenderPass renderPass) {
+    viewport = _viewport;
+
+    Gfx::MeshPipelineCreateInfo pipelineInfo = {
+        .taskShader = task,
+        .meshShader = mesh,
+        .fragmentShader = frag,
+        .renderPass = renderPass,
+        .pipelineLayout = pipelineLayout,
+        .multisampleState =
+            {
+                .samples = viewport->getSamples(),
+            },
+        .rasterizationState =
+            {
+                //.polygonMode = Gfx::SE_POLYGON_MODE_LINE,
+                .cullMode = Gfx::SE_CULL_MODE_BACK_BIT,
+            },
+        .colorBlend =
+            {
+                .attachmentCount = 1,
+                .blendAttachments =
+                    {
+                        Gfx::ColorBlendState::BlendAttachment{
+                            .blendEnable = false,
+                        },
+                    },
+            },
+    };
+    pipeline = graphics->createGraphicsPipeline(std::move(pipelineInfo));
+}

src/Engine/Graphics/RenderPass/TerrainRenderer.h

@@ -0,0 +1,29 @@
+#pragma once
+#include "RenderPass.h"
+
+namespace Seele {
+class TerrainRenderer {
+  public:
+    TerrainRenderer(Gfx::PGraphics graphics, PScene scene, Gfx::PDescriptorLayout viewParamsLayout);
+    ~TerrainRenderer();
+    void beginFrame();
+    Gfx::ORenderCommand render(Gfx::PDescriptorSet viewParamsSet);
+    void setViewport(Gfx::PViewport viewport, Gfx::PRenderPass renderPass);
+
+  private:
+    Gfx::PGraphics graphics;
+    PScene scene;
+    Gfx::ODescriptorLayout layout;
+    Gfx::PDescriptorSet set;
+    Gfx::OPipelineLayout pipelineLayout;
+    Gfx::OTaskShader task;
+    Gfx::OMeshShader mesh;
+    Gfx::OFragmentShader frag;
+    Gfx::PGraphicsPipeline pipeline;
+    Gfx::PViewport viewport;
+    Gfx::OShaderBuffer tilesBuffer;
+    Gfx::OTexture2D displacementMap;
+    Gfx::OSampler sampler;
+};
+DEFINE_REF(TerrainRenderer);
+}

src/Engine/Graphics/RenderPass/WaterRenderer.cpp

@@ -243,15 +243,15 @@ WaterRenderer::WaterRenderer(Gfx::PGraphics graphics, PScene scene, Gfx::PDescri
 
     ShaderCompilationInfo createInfo = {
         .name = "WaterTiles",
-        .modules = {"WaterTask", "WaterMesh", "WaterPass"},
+        .modules = {"WaterPass"},
         .entryPoints =
             {
-                {"taskMain", "WaterTask"},
-                {"meshMain", "WaterMesh"},
+                {"taskMain", "WaterPass"},
+                {"meshMain", "WaterPass"},
                 {"fragmentMain", "WaterPass"},
             },
         .rootSignature = waterLayout,
-        .dumpIntermediate = true,
+        .dumpIntermediate = false,
     };
     graphics->beginShaderCompilation(createInfo);
     waterTask = graphics->createTaskShader({0});
@@ -353,7 +353,7 @@ void WaterRenderer::beginFrame() {
     Array<WaterTile> payloads;
     scene->view<Component::WaterTile>([&](Component::WaterTile& tile) {
         payloads.add(WaterTile{
-            .offset = Vector2(tile.location),
+            .offset = IVector2(tile.location),
             .extent = Component::WaterTile::DIMENSIONS,
             .height = tile.height,
         });