RT Shading works

res/shaders/lib/MaterialParameter.slang

@@ -55,6 +55,7 @@ struct FragmentParameter
         FragmentParameter result;
         result.position_CS = f0.position_CS * barycentricCoords.x + f1.position_CS * barycentricCoords.y + f2.position_CS * barycentricCoords.z;
 #ifndef POS_ONLY
+	    result.cameraPos_WS = f0.cameraPos_WS * barycentricCoords.x + f1.cameraPos_WS * barycentricCoords.y + f2.cameraPos_WS * barycentricCoords.z;
         result.normal_WS = f0.normal_WS * barycentricCoords.x + f1.normal_WS * barycentricCoords.y + f2.normal_WS * barycentricCoords.z;
 	    result.tangent_WS = f0.tangent_WS * barycentricCoords.x + f1.tangent_WS * barycentricCoords.y + f2.tangent_WS * barycentricCoords.z;
 	    result.biTangent_WS = f0.biTangent_WS * barycentricCoords.x + f1.biTangent_WS * barycentricCoords.y + f2.biTangent_WS * barycentricCoords.z;

res/shaders/raytracing/ClosestHit.slang

@@ -53,5 +53,5 @@ void closestHit(inout RayPayload hitValue, in BuiltInTriangleIntersectionAttribu
     // gamma correction
     result = result / (result + float3(1.0));
     result = pow(result, float3(1.0/2.2));
-    hitValue.color = getMaterialTextureParameter(0).Sample(getMaterialSamplerParameter(0), params.texCoords[0]).xyz;
+    hitValue.color = result;
 }

res/shaders/raytracing/RayGen.slang

@@ -21,5 +21,5 @@ void raygen()
     RayPayload payload;
     TraceRay(pRayTracingParams.scene, RAY_FLAG_FORCE_OPAQUE, 0xff, 0, 0, 0, rayDesc, payload);
 
-    pRayTracingParams.image[int2(LaunchID.xy)] = float4(payload.color, 0.0);
+    pRayTracingParams.image[int2(LaunchID.xy)] = float4(payload.color, 1.0);
 }

src/Engine/Graphics/RenderPass/RayTracingPass.cpp

@@ -77,10 +77,7 @@ void RayTracingPass::render() {
         }
     }
     pipeline = graphics->createRayTracingPipeline(Gfx::RayTracingPipelineCreateInfo{
-        .pipelineLayout = pipelineLayout,
+        .pipelineLayout = pipelineLayout, .rayGenGroup = {.shader = rayGen}, .hitGroups = callableGroups, .missGroups = {{.shader = miss}},
-        .rayGenGroup = {.shader = rayGen},
-        .hitGroups = callableGroups,
-        .missGroups = {{.shader = miss}},
         //.callableGroups = callableGroups,
     });
     tlas = graphics->createTopLevelAccelerationStructure(Gfx::TopLevelASCreateInfo{
@@ -122,7 +119,8 @@ void RayTracingPass::publishOutputs() {
         .usage = Gfx::SE_IMAGE_USAGE_STORAGE_BIT,
     });
     texture->changeLayout(Gfx::SE_IMAGE_LAYOUT_GENERAL, Gfx::SE_ACCESS_NONE, Gfx::SE_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
-                          Gfx::SE_ACCESS_SHADER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
+                          Gfx::SE_ACCESS_SHADER_WRITE_BIT,
+                          Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT | Gfx::SE_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR);
     ShaderCompilationInfo compileInfo = {
         .name = "RT",
         .modules = {"RayGen", "Miss"},

src/Engine/Graphics/RenderPass/RenderPass.cpp

@@ -39,9 +39,10 @@ void RenderPass::beginFrame(const Component::Camera& cam) {
     viewParamsBuffer->rotateBuffer(sizeof(ViewParameter));
     viewParamsBuffer->updateContents(uniformUpdate);
     viewParamsBuffer->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT,
-                                      Gfx::SE_ACCESS_UNIFORM_READ_BIT,
+                                      Gfx::SE_ACCESS_UNIFORM_READ_BIT | Gfx::SE_ACCESS_TRANSFER_WRITE_BIT,
                                       Gfx::SE_PIPELINE_STAGE_TASK_SHADER_BIT_EXT | Gfx::SE_PIPELINE_STAGE_MESH_SHADER_BIT_EXT |
-                                          Gfx::SE_PIPELINE_STAGE_VERTEX_SHADER_BIT | Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
+                                          Gfx::SE_PIPELINE_STAGE_VERTEX_SHADER_BIT | Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT |
+                                          Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT);
     viewParamsLayout->reset();
     viewParamsSet = viewParamsLayout->allocateDescriptorSet();
     viewParamsSet->updateBuffer(0, viewParamsBuffer);

src/Engine/Graphics/Vulkan/Buffer.cpp

@@ -117,6 +117,8 @@ void BufferAllocation::updateContents(uint64 regionOffset, uint64 regionSize, vo
         .size = regionSize,
     };
     vkCmdCopyBuffer(cmd->getHandle(), staging->buffer, buffer, 1, &copy);
+    pipelineBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_ACCESS_TRANSFER_WRITE_BIT,
+                    VK_PIPELINE_STAGE_TRANSFER_BIT);
     cmd->bindResource(PBufferAllocation(this));
     cmd->bindResource(PBufferAllocation(staging));
 

src/Engine/Graphics/Vulkan/Command.cpp

@@ -235,6 +235,9 @@ void RenderCommand::bindPipeline(Gfx::PRayTracingPipeline gfxPipeline) {
     assert(threadId == std::this_thread::get_id());
     rtPipeline = gfxPipeline.cast<RayTracingPipeline>();
     rtPipeline->bind(handle);
+    boundResources.add(PBufferAllocation(rtPipeline->rayGen));
+    boundResources.add(PBufferAllocation(rtPipeline->hit));
+    boundResources.add(PBufferAllocation(rtPipeline->miss));
 }
 
 void RenderCommand::bindDescriptor(Gfx::PDescriptorSet descriptorSet, Array<uint32> dynamicOffsets) {

src/Engine/Graphics/Vulkan/Graphics.cpp

@@ -654,6 +654,8 @@ void Graphics::initInstance(GraphicsInitializer initInfo) {
 #ifdef __APPLE__
     extensions.add("VK_KHR_portability_enumeration");
 #endif
+    Array<const char*> layers = initInfo.layers;
+    layers.add("VK_LAYER_KHRONOS_validation");
     VkInstanceCreateInfo info = {
         .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
         .pNext = nullptr,
@@ -661,8 +663,8 @@ void Graphics::initInstance(GraphicsInitializer initInfo) {
         .flags = VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR,
 #endif
         .pApplicationInfo = &appInfo,
-        .enabledLayerCount = (uint32)initInfo.layers.size(),
+        .enabledLayerCount = (uint32)layers.size(),
-        .ppEnabledLayerNames = initInfo.layers.data(),
+        .ppEnabledLayerNames = layers.data(),
         .enabledExtensionCount = (uint32)extensions.size(),
         .ppEnabledExtensionNames = extensions.data(),
     };

src/Engine/Graphics/Vulkan/PipelineCache.cpp

@@ -478,6 +478,7 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
             .stage = VK_SHADER_STAGE_RAYGEN_BIT_KHR,
             .module = rayGen->getModuleHandle(),
             .pName = rayGen->getEntryPointName(),
+            .pSpecializationInfo = nullptr,
         });
         shaderGroups.add(VkRayTracingShaderGroupCreateInfoKHR{
             .sType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR,
@@ -487,6 +488,7 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
             .closestHitShader = VK_SHADER_UNUSED_KHR,
             .anyHitShader = VK_SHADER_UNUSED_KHR,
             .intersectionShader = VK_SHADER_UNUSED_KHR,
+            .pShaderGroupCaptureReplayHandle = nullptr,
         });
     }
     {
@@ -499,6 +501,7 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
                 .stage = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR,
                 .module = hit->getModuleHandle(),
                 .pName = hit->getEntryPointName(),
+                .pSpecializationInfo = nullptr,
             });
             uint32 hitIndex = static_cast<uint32>(shaderStages.size() - 1);
             uint32 anyHitIndex = VK_SHADER_UNUSED_KHR;
@@ -512,6 +515,7 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
                     .stage = VK_SHADER_STAGE_ANY_HIT_BIT_KHR,
                     .module = anyHit->getModuleHandle(),
                     .pName = anyHit->getEntryPointName(),
+                    .pSpecializationInfo = nullptr,
                 });
             }
             if (hitgroup.intersectionShader != nullptr) {
@@ -523,6 +527,7 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
                     .stage = VK_SHADER_STAGE_INTERSECTION_BIT_KHR,
                     .module = intersect->getModuleHandle(),
                     .pName = intersect->getEntryPointName(),
+                    .pSpecializationInfo = nullptr,
                 });
             }
             shaderGroups.add(VkRayTracingShaderGroupCreateInfoKHR{
@@ -533,6 +538,7 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
                 .closestHitShader = hitIndex,
                 .anyHitShader = anyHitIndex,
                 .intersectionShader = intersectionIndex,
+                .pShaderGroupCaptureReplayHandle = nullptr,
             });
         }
     }
@@ -546,6 +552,7 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
                 .stage = VK_SHADER_STAGE_MISS_BIT_KHR,
                 .module = miss->getModuleHandle(),
                 .pName = miss->getEntryPointName(),
+                .pSpecializationInfo = nullptr,
             });
             shaderGroups.add(VkRayTracingShaderGroupCreateInfoKHR{
                 .sType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR,
@@ -555,6 +562,7 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
                 .closestHitShader = VK_SHADER_UNUSED_KHR,
                 .anyHitShader = VK_SHADER_UNUSED_KHR,
                 .intersectionShader = VK_SHADER_UNUSED_KHR,
+                .pShaderGroupCaptureReplayHandle = nullptr,
             });
         }
     }
@@ -568,6 +576,7 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
                 .stage = VK_SHADER_STAGE_CALLABLE_BIT_KHR,
                 .module = call->getModuleHandle(),
                 .pName = call->getEntryPointName(),
+                .pSpecializationInfo = nullptr,
             });
             shaderGroups.add(VkRayTracingShaderGroupCreateInfoKHR{
                 .sType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR,
@@ -577,11 +586,15 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
                 .closestHitShader = VK_SHADER_UNUSED_KHR,
                 .anyHitShader = VK_SHADER_UNUSED_KHR,
                 .intersectionShader = VK_SHADER_UNUSED_KHR,
+                .pShaderGroupCaptureReplayHandle = nullptr,
             });
         }
     }
     uint32 hash = CRC::Calculate(shaderStages.data(), sizeof(VkPipelineShaderStageCreateInfo) * shaderStages.size(), CRC::CRC_32());
     hash = CRC::Calculate(shaderGroups.data(), sizeof(VkRayTracingShaderGroupCreateInfoKHR) * shaderGroups.size(), CRC::CRC_32(), hash);
+    if (rayTracingPipelines.contains(hash)) {
+        return rayTracingPipelines[hash];
+    }
     VkRayTracingPipelineCreateInfoKHR pipelineInfo = {
         .sType = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR,
         .pNext = nullptr,
@@ -593,7 +606,11 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
         .layout = createInfo.pipelineLayout.cast<PipelineLayout>()->getHandle(),
     };
     VkPipeline pipelineHandle;
+    auto beginTime = std::chrono::high_resolution_clock::now();
     VK_CHECK(vkCreateRayTracingPipelinesKHR(graphics->getDevice(), VK_NULL_HANDLE, cache, 1, &pipelineInfo, nullptr, &pipelineHandle));
+    auto endTime = std::chrono::high_resolution_clock::now();
+    int64 delta = std::chrono::duration_cast<std::chrono::microseconds>(endTime - beginTime).count();
+    std::cout << "RT creation time: " << delta << std::endl;
 
     const uint32_t handleSize = graphics->getRayTracingProperties().shaderGroupHandleSize;
     const uint32_t handleSizeAligned =

src/Engine/Graphics/Vulkan/RayTracing.cpp

@@ -220,4 +220,9 @@ RayTracingPipeline::~RayTracingPipeline() {
     graphics->getDestructionManager()->queueResourceForDestruction(std::move(callable));
 }
 
-void RayTracingPipeline::bind(VkCommandBuffer handle) { vkCmdBindPipeline(handle, VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, pipeline); }
+void RayTracingPipeline::bind(VkCommandBuffer handle) {
+    vkCmdBindPipeline(handle, VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, pipeline);
+    rayGen->bind();
+    hit->bind();
+    miss->bind();
+}

src/Engine/Graphics/Vulkan/RayTracing.h

@@ -101,6 +101,7 @@ class RayTracingPipeline : public Gfx::RayTracingPipeline {
     uint64 missStride;
     OBufferAllocation callable;
     uint64 callableStride;
+    friend class RenderCommand;
 };
 DEFINE_REF(RayTracingPipeline)
 } // namespace Vulkan

src/Engine/Scene/LightEnvironment.cpp

@@ -19,38 +19,14 @@ LightEnvironment::LightEnvironment(Gfx::PGraphics graphics) : graphics(graphics)
     });
     layout->create();
     lightEnvBuffer = graphics->createUniformBuffer(UniformBufferCreateInfo{
-        .sourceData =
-            {
-                .size = sizeof(LightEnv),
-                .data = (uint8*)&lightEnv,
-            },
         .dynamic = true,
     });
     directionalLights = graphics->createShaderBuffer(ShaderBufferCreateInfo{
-        .sourceData =
-            {
-                .size = sizeof(Component::DirectionalLight) * INIT_DIRECTIONAL_LIGHTS,
-                .data = nullptr,
-            },
-        .numElements = INIT_DIRECTIONAL_LIGHTS,
         .dynamic = true,
     });
     pointLights = graphics->createShaderBuffer(ShaderBufferCreateInfo{
-        .sourceData =
-            {
-                .size = sizeof(Component::PointLight) * INIT_POINT_LIGHTS,
-                .data = nullptr,
-            },
-        .numElements = INIT_POINT_LIGHTS,
         .dynamic = true,
     });
-    lightEnvBuffer->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT, Gfx::SE_ACCESS_UNIFORM_READ_BIT,
-                                    Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
-    directionalLights->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT,
-                                       Gfx::SE_ACCESS_SHADER_READ_BIT,
-                                       Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
-    pointLights->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT, Gfx::SE_ACCESS_SHADER_READ_BIT,
-                                 Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
 }
 
 LightEnvironment::~LightEnvironment() {}
@@ -73,8 +49,10 @@ void LightEnvironment::commit() {
         .size = sizeof(LightEnv),
         .data = (uint8*)&lightEnv,
     });
-    lightEnvBuffer->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT, Gfx::SE_ACCESS_UNIFORM_READ_BIT,
+    lightEnvBuffer->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT,
-                                    Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
+                                    Gfx::SE_ACCESS_UNIFORM_READ_BIT | Gfx::SE_ACCESS_TRANSFER_WRITE_BIT,
+                                    Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT |
+                                        Gfx::SE_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR | Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT);
     directionalLights->rotateBuffer(sizeof(Component::DirectionalLight) * dirs.size());
     directionalLights->updateContents({
         .sourceData =
@@ -85,8 +63,9 @@ void LightEnvironment::commit() {
         .numElements = dirs.size(),
     });
     directionalLights->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT,
-                                       Gfx::SE_ACCESS_SHADER_READ_BIT,
+                                       Gfx::SE_ACCESS_SHADER_READ_BIT | Gfx::SE_ACCESS_TRANSFER_WRITE_BIT,
-                                       Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
+                                       Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT |
+                                           Gfx::SE_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR | Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT);
     pointLights->rotateBuffer(sizeof(Component::PointLight) * points.size());
     pointLights->updateContents({
         .sourceData =
@@ -96,8 +75,10 @@ void LightEnvironment::commit() {
             },
         .numElements = points.size(),
     });
-    pointLights->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT, Gfx::SE_ACCESS_SHADER_READ_BIT,
+    pointLights->pipelineBarrier(Gfx::SE_ACCESS_TRANSFER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT,
-                                 Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
+                                 Gfx::SE_ACCESS_SHADER_READ_BIT | Gfx::SE_ACCESS_TRANSFER_WRITE_BIT,
+                                 Gfx::SE_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT |
+                                     Gfx::SE_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR | Gfx::SE_PIPELINE_STAGE_TRANSFER_BIT);
     set->updateBuffer(0, lightEnvBuffer);
     set->updateBuffer(1, directionalLights);
     set->updateBuffer(2, pointLights);

src/Engine/Scene/LightEnvironment.h

@@ -18,8 +18,6 @@ class LightEnvironment {
     Gfx::PDescriptorSet getDescriptorSet();
 
   private:
-#define INIT_DIRECTIONAL_LIGHTS 4
-#define INIT_POINT_LIGHTS 256
     struct LightEnv {
         uint32 numDirectionalLights;
         uint32 numPointLights;

src/Engine/Window/GameView.cpp

@@ -23,12 +23,12 @@ using namespace Seele;
 GameView::GameView(Gfx::PGraphics graphics, PWindow window, const ViewportCreateInfo& createInfo, std::string dllPath)
     : View(graphics, window, createInfo, "Game"), scene(new Scene(graphics)), gameInterface(dllPath) {
     reloadGame();
-    renderGraph.addPass(new CachedDepthPass(graphics, scene));
+    //renderGraph.addPass(new CachedDepthPass(graphics, scene));
-    renderGraph.addPass(new DepthCullingPass(graphics, scene));
+    //renderGraph.addPass(new DepthCullingPass(graphics, scene));
-    renderGraph.addPass(new VisibilityPass(graphics, scene));
+    //renderGraph.addPass(new VisibilityPass(graphics, scene));
-    renderGraph.addPass(new LightCullingPass(graphics, scene));
+    //renderGraph.addPass(new LightCullingPass(graphics, scene));
-    renderGraph.addPass(new BasePass(graphics, scene));
+    //renderGraph.addPass(new BasePass(graphics, scene));
-    //renderGraph.addPass(new RayTracingPass(graphics, scene));
+    renderGraph.addPass(new RayTracingPass(graphics, scene));
     renderGraph.setViewport(viewport);
     renderGraph.createRenderPass();
 }