Removing the need for multiview

res/shaders/EnvironmentMapping.slang

@@ -70,11 +70,11 @@ struct VertexOutput
     float3 localPos : LOCALPOS;
 };
 [shader("vertex")]
-VertexOutput vertMain(uint vertexIndex : SV_VertexID, uint viewIndex : SV_ViewID)
+VertexOutput vertMain(uint vertexIndex : SV_VertexID)
 {
     VertexOutput output;
     output.localPos = vertices[vertexIndex];
-    output.svPos = mul(pViewParams.projection, mul(pViewParams.view[viewIndex], float4(output.localPos, 1)));
+    output.svPos = mul(pViewParams.projection, mul(pViewParams.view[vertexIndex / 6], float4(output.localPos, 1)));
     return output;
 }
 

src/Editor/Asset/EnvironmentLoader.cpp

@@ -131,93 +131,112 @@ void EnvironmentLoader::import(EnvironmentImportArgs args, PEnvironmentMapAsset
         .height = SOURCE_RESOLUTION,
         .usage = Gfx::SE_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | Gfx::SE_IMAGE_USAGE_SAMPLED_BIT,
     });
-    Gfx::ORenderPass cubeRenderPass = graphics->createRenderPass(
+    Array<Gfx::OTextureView> cubeViews;
-        Gfx::RenderTargetLayout{
+    cubeViews.add(cubeMap->createTextureView(0, 1, 0, 1));
-            .colorAttachments =
+    cubeViews.add(cubeMap->createTextureView(0, 1, 1, 1));
-                {
+    cubeViews.add(cubeMap->createTextureView(0, 1, 2, 1));
-                    Gfx::RenderTargetAttachment(cubeMap->getDefaultView(), Gfx::SE_IMAGE_LAYOUT_UNDEFINED, Gfx::SE_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+    cubeViews.add(cubeMap->createTextureView(0, 1, 3, 1));
-                                                Gfx::SE_ATTACHMENT_LOAD_OP_DONT_CARE, Gfx::SE_ATTACHMENT_STORE_OP_STORE),
+    cubeViews.add(cubeMap->createTextureView(0, 1, 4, 1));
+    cubeViews.add(cubeMap->createTextureView(0, 1, 5, 1));
+    for(uint32 i = 0; i < 6; ++i) {
+        Gfx::ORenderPass cubeRenderPass = graphics->createRenderPass(
+            Gfx::RenderTargetLayout{
+                .colorAttachments =
+                    {
+                        Gfx::RenderTargetAttachment(cubeViews[i], Gfx::SE_IMAGE_LAYOUT_UNDEFINED, Gfx::SE_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+                                                    Gfx::SE_ATTACHMENT_LOAD_OP_DONT_CARE, Gfx::SE_ATTACHMENT_STORE_OP_STORE),
+                    },
+            },
+            {
+                Gfx::SubPassDependency{
+                    .srcSubpass = 0,
+                    .dstSubpass = ~0U,
+                    .srcStage = Gfx::SE_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+                    .dstStage = Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+                    .srcAccess = Gfx::SE_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                    .dstAccess = Gfx::SE_ACCESS_SHADER_READ_BIT,
                 },
-        },
-        {
-            Gfx::SubPassDependency{
-                .srcSubpass = 0,
-                .dstSubpass = ~0U,
-                .srcStage = Gfx::SE_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
-                .dstStage = Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
-                .srcAccess = Gfx::SE_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
-                .dstAccess = Gfx::SE_ACCESS_SHADER_READ_BIT,
             },
-        },
-        {
-            .size = {SOURCE_RESOLUTION, SOURCE_RESOLUTION},
-            .offset = {0, 0},
-        },
-        "EnvironmentRenderPass", {0b111111}, {0b111111});
-    cubeRenderPipeline = graphics->createGraphicsPipeline(Gfx::LegacyPipelineCreateInfo{
-        .vertexShader = cubeRenderVertex,
-        .fragmentShader = cubeRenderFrag,
-        .renderPass = cubeRenderPass,
-        .pipelineLayout = cubePipelineLayout,
-        .colorBlend =
             {
-                .attachmentCount = 1,
+                .size = {SOURCE_RESOLUTION, SOURCE_RESOLUTION},
+                .offset = {0, 0},
             },
-    });
+            "EnvironmentRenderPass");
-    graphics->beginRenderPass(cubeRenderPass);
+        cubeRenderPipeline = graphics->createGraphicsPipeline(Gfx::LegacyPipelineCreateInfo{
-    Gfx::ORenderCommand renderCommand = graphics->createRenderCommand("CubeMapRender");
+            .vertexShader = cubeRenderVertex,
-    renderCommand->bindPipeline(cubeRenderPipeline);
+            .fragmentShader = cubeRenderFrag,
-    renderCommand->bindDescriptor({set});
+            .renderPass = cubeRenderPass,
-    renderCommand->setViewport(cubeRenderViewport);
+            .pipelineLayout = cubePipelineLayout,
-    renderCommand->draw(36, 1, 0, 0);
+            .colorBlend =
-    graphics->executeCommands(std::move(renderCommand));
+                {
-    graphics->endRenderPass();
+                    .attachmentCount = 1,
-
+                },
-    Gfx::OTextureCube convolutedMap = graphics->createTextureCube(TextureCreateInfo{
+        });
-        .format = Gfx::SE_FORMAT_R32G32B32A32_SFLOAT,
+        graphics->beginRenderPass(cubeRenderPass);
-        .width = CONVOLUTED_RESOLUTION,
+        Gfx::ORenderCommand renderCommand = graphics->createRenderCommand("CubeMapRender");
-        .height = CONVOLUTED_RESOLUTION,
+        renderCommand->bindPipeline(cubeRenderPipeline);
-        .usage = Gfx::SE_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
+        renderCommand->bindDescriptor({set});
-    });
+        renderCommand->setViewport(cubeRenderViewport);
-    Gfx::ORenderPass convolutionPass = graphics->createRenderPass(
+        renderCommand->draw(6, 1, i*6, 0);
-        Gfx::RenderTargetLayout{
+        graphics->executeCommands(std::move(renderCommand));
-            .colorAttachments = {Gfx::RenderTargetAttachment(convolutedMap->getDefaultView(), Gfx::SE_IMAGE_LAYOUT_UNDEFINED,
+        graphics->endRenderPass();
-                                                             Gfx::SE_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+    }
-                                                             Gfx::SE_ATTACHMENT_LOAD_OP_DONT_CARE, Gfx::SE_ATTACHMENT_STORE_OP_STORE)},
+    
-        },
-        {},
-        {
-            .size = {CONVOLUTED_RESOLUTION, CONVOLUTED_RESOLUTION},
-            .offset = {0, 0},
-        },
-        "EnvironmentRenderPass", {0b111111}, {0b111111});
-    convolutionPipeline = graphics->createGraphicsPipeline(Gfx::LegacyPipelineCreateInfo{
-        .vertexShader = cubeRenderVertex,
-        .fragmentShader = convolutionFrag,
-        .renderPass = convolutionPass,
-        .pipelineLayout = cubePipelineLayout,
-        .colorBlend =
-            {
-                .attachmentCount = 1,
-            },
-    });
-
     set = cubeRenderLayout->allocateDescriptorSet();
     set->updateConstants("view", 0, captureViews);
     set->updateConstants("projection", 0, &captureProjection);
     set->updateSampler("sampler", 0, cubeSampler);
     set->updateTexture("cubeMap", 0, cubeMap->getDefaultView());
     set->writeChanges();
+    
+    Gfx::OTextureCube convolutedMap = graphics->createTextureCube(TextureCreateInfo{
+        .format = Gfx::SE_FORMAT_R32G32B32A32_SFLOAT,
+        .width = CONVOLUTED_RESOLUTION,
+        .height = CONVOLUTED_RESOLUTION,
+        .usage = Gfx::SE_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
+    });
+    Array<Gfx::OTextureView> convolutedViews;
+    convolutedViews.add(cubeMap->createTextureView(0, 1, 0, 1));
+    convolutedViews.add(cubeMap->createTextureView(0, 1, 1, 1));
+    convolutedViews.add(cubeMap->createTextureView(0, 1, 2, 1));
+    convolutedViews.add(cubeMap->createTextureView(0, 1, 3, 1));
+    convolutedViews.add(cubeMap->createTextureView(0, 1, 4, 1));
+    convolutedViews.add(cubeMap->createTextureView(0, 1, 5, 1));
+    for(uint32 i = 0; i < 6; ++i) {
+        Gfx::ORenderPass convolutionPass = graphics->createRenderPass(
+            Gfx::RenderTargetLayout{
+                .colorAttachments = {Gfx::RenderTargetAttachment(convolutedViews[i], Gfx::SE_IMAGE_LAYOUT_UNDEFINED,
+                                                                Gfx::SE_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+                                                                Gfx::SE_ATTACHMENT_LOAD_OP_DONT_CARE, Gfx::SE_ATTACHMENT_STORE_OP_STORE)},
+            },
+            {},
+            {
+                .size = {CONVOLUTED_RESOLUTION, CONVOLUTED_RESOLUTION},
+                .offset = {0, 0},
+            },
+            "EnvironmentRenderPass");
+        convolutionPipeline = graphics->createGraphicsPipeline(Gfx::LegacyPipelineCreateInfo{
+            .vertexShader = cubeRenderVertex,
+            .fragmentShader = convolutionFrag,
+            .renderPass = convolutionPass,
+            .pipelineLayout = cubePipelineLayout,
+            .colorBlend =
+                {
+                    .attachmentCount = 1,
+                },
+        });
 
-    graphics->beginRenderPass(convolutionPass);
+        graphics->beginRenderPass(convolutionPass);
-    Gfx::ORenderCommand cmd = graphics->createRenderCommand("ConvolutionPass");
+        Gfx::ORenderCommand cmd = graphics->createRenderCommand("ConvolutionPass");
-    cmd->bindPipeline(convolutionPipeline);
+        cmd->bindPipeline(convolutionPipeline);
-    cmd->bindDescriptor({set});
+        cmd->bindDescriptor({set});
-    cmd->setViewport(convolutionViewport);
+        cmd->setViewport(convolutionViewport);
-    cmd->draw(36, 1, 0, 0);
+        cmd->draw(6, 1, i*6, 0);
-    graphics->executeCommands(std::move(cmd));
+        graphics->executeCommands(std::move(cmd));
-    graphics->endRenderPass();
+        graphics->endRenderPass();
 
+    }
+    
     asset->skybox = std::move(cubeMap);
     asset->irradianceMap = std::move(convolutedMap);
     graphics->waitDeviceIdle();

src/Engine/Graphics/Vulkan/Graphics.cpp

@@ -905,7 +905,6 @@ void Graphics::createDevice(GraphicsInitializer initializer) {
         // required for spirv_1_4
         initializer.deviceExtensions.add(VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME);
     }
-    initializer.deviceExtensions.add(VK_KHR_MULTIVIEW_EXTENSION_NAME);
 #ifdef __APPLE__
     initializer.deviceExtensions.add("VK_KHR_portability_subset");
 #endif