Ray tracing siggraph25 (#4)

Moved 18_Ray_tracing.adoc to courses/18_Ray_tracing folder and broke it up into subsections.  Did a few minor edits to address flow.

The courses folder should make it easier to create courseware content in the future and provide attribution easily via a README file.

Author: gpx1000

antora/modules/ROOT/nav.adoc

@@ -52,4 +52,13 @@
 * xref:15_GLTF_KTX2_Migration.adoc[Migrating to Modern Asset Formats: glTF and KTX2]
 * xref:16_Multiple_Objects.adoc[Rendering Multiple Objects]
 * xref:17_Multithreading.adoc[Multithreading]
+* xref:courses/18_Ray_tracing/00_Overview.adoc[Ray Tracing]
+** xref:courses/18_Ray_tracing/00_Overview.adoc[Overview]
+** xref:courses/18_Ray_tracing/01_Dynamic_rendering.adoc[Dynamic rendering]
+** xref:courses/18_Ray_tracing/02_Acceleration_structures.adoc[Acceleration structures]
+** xref:courses/18_Ray_tracing/03_Ray_query_shadows.adoc[Ray query shadows]
+** xref:courses/18_Ray_tracing/04_TLAS_animation.adoc[TLAS animation]
+** xref:courses/18_Ray_tracing/05_Shadow_transparency.adoc[Shadow transparency]
+** xref:courses/18_Ray_tracing/06_Reflections.adoc[Reflections]
+** xref:courses/18_Ray_tracing/07_Conclusion.adoc[Conclusion]
 * xref:90_FAQ.adoc[FAQ]

en/18_Ray_tracing.adoc

@@ -0,0 +1,67 @@
+== SIGGRAPH 2025: Hands-on Vulkan Ray Tracing with Dynamic Rendering
+
+=== Overview
+
+Welcome! In this series, we enhance a Vulkan renderer with ray tracing features to implement real-time pixel-perfect shadows (with and without transparency) and a bonus reflection effect. You will work with provided scaffolded code (based on the Vulkan Tutorial) and fill in key shader functions following step-by-step instructions.
+
+Slides available link:Vulkan%20Ray%20Tracing%20With%20Dynamic%20Rendering.pdf[here].
+
+By the end, you'll learn how to:
+
+- Use Vulkan *dynamic rendering* (no pre-defined render passes) and verify it with *RenderDoc*.
+- Create bottom-level and top-level *Acceleration Structures* (BLAS and TLAS) for ray tracing.
+- Implement ray query based *shadow rays* (first with all-opaque geometry, then with alpha-test *transparency*).
+- Debug/inspect the acceleration structures in *Nsight Graphics*.
+- (Bonus) Implement ray query based *reflections*.
+
+*Prerequisites*:
+This series targets intermediate Vulkan programmers. We assume you have completed the basic Vulkan Tutorial (graphics pipeline, descriptor sets, etc.). If not, you can still follow along conceptually. A Windows machine with up-to-date Vulkan SDK (1.4.311), a GPU supporting ray tracing (Vulkan Ray Query), plus RenderDoc and Nsight Graphics is provided.
+
+*Mobile Best-Practice Notes*:
+
+- We use `VK_KHR_dynamic_rendering` (core in Vulkan 1.3) instead of traditional render passes. This not only simplifies the API but also, with the `VK_KHR_dynamic_rendering_local_read` extension, enables tile-local storage reads similar to subpasses, a big deal for mobile tile-based GPUs to save bandwidth.
+- We use Ray Queries (from `VK_KHR_ray_query`) within fragment shaders instead of a separate ray tracing pipeline. On mobile, ray queries are far more widely supported and often (depending on the use case) more efficient than the full ray tracing pipeline. Ray queries integrate nicely into fragment shading, benefiting from on-chip compression and avoiding context switches.
+
+*Provided Code*:
+The provided code is a Vulkan renderer that already implements a basic graphics pipeline with dynamic rendering. It is based on the Vulkan Tutorial and it is self-contained in a single C++ source file and a Slang shader file:
+
+- link:../../../attachments/38_ray_tracing.cpp[38_ray_tracing.cpp]
+- link:../../../attachments/38_ray_tracing.slang[38_ray_tracing.slang]
+- If you get stuck on shader tasks, you can refer to the provided reference solution: link:../../../attachments/38_ray_tracing_complete.slang[38_ray_tracing_complete.slang]
+
+The source code is structured to guide you through the steps, with hints and boilerplate provided. It also sets up all the required extensions and features, including `VK_KHR_acceleration_structure` and `VK_KHR_ray_query`.
+You will find sections of code marked with `// TASKxx` which we reference in each chapter.
+
+At the top of the C++ file, note the following variable:
+
+[,c{pp}]
+----
+#define LAB_TASK_LEVEL 1
+----
+
+At certain intervals, you will be instructed to update this variable and re-build to verify the effect of key changes, no need to write new code.
+
+=== Chapters in this series
+
+- link:00_Overview.adoc[Overview]
+- link:01_Dynamic_rendering.adoc[Dynamic rendering]
+- link:02_Acceleration_structures.adoc[Acceleration structures]
+- link:03_Ray_query_shadows.adoc[Ray query shadows]
+- link:04_TLAS_animation.adoc[TLAS animation]
+- link:05_Shadow_transparency.adoc[Shadow transparency]
+- link:06_Reflections.adoc[Reflections]
+- link:07_Conclusion.adoc[Conclusion]
+
+=== Build and run
+
+You can build and run the provided sample either from Visual Studio (set 38_ray_tracing as the start-up project) or via command line:
+
+[,shell]
+----
+cmake --build build --target 38_ray_tracing --parallel; start .\build\38_ray_tracing\Debug\38_ray_tracing.exe -wo .\build\38_ray_tracing\
+----
+
+Note that the above hasn't changed from the base tutorial, and you may continue to build on other platforms as you have for the rest of the tutorial.
+
+=== Navigation
+- Next: link:01_Dynamic_rendering.adoc[Dynamic rendering]

en/courses/18_Ray_tracing/00_Overview.adoc

@@ -0,0 +1,114 @@
+== Dynamic Rendering
+
+*Objective*: Ensure the base project uses *dynamic rendering* and understand how to verify it using RenderDoc.
+
+In dynamic rendering, we no longer create a VkRenderPass or VkFrameBuffer; instead we begin rendering with `vkCmdBeginRenderingKHR`, specifying attachments on-the-fly. This makes our code more flexible (no need to predeclare subpasses) and is now the "modern" way to render in Vulkan.
+
+=== Task 1: Check the setup for dynamic rendering
+
+In the provided code base, locate the initialization of the graphics pipeline:
+
+[,c{pp}]
+----
+/* TASK01: Check the setup for dynamic rendering
+ *
+ * This new struct replaces what previously was the render pass in the pipeline creation.
+ * Note how this structure is now linked in .pNext below, and .renderPass is not used.
+ */
+vk::PipelineRenderingCreateInfo pipelineRenderingCreateInfo{
+    .colorAttachmentCount = 1,
+    .pColorAttachmentFormats = &swapChainImageFormat,
+    .depthAttachmentFormat = depthFormat
+};
+
+vk::GraphicsPipelineCreateInfo pipelineInfo{
+    .pNext = &pipelineRenderingCreateInfo,
+    .stageCount = 2,
+    .pStages = shaderStages,
+    .pVertexInputState = &vertexInputInfo,
+    .pInputAssemblyState = &inputAssembly,
+    .pViewportState = &viewportState,
+    .pRasterizationState = &rasterizer,
+    .pMultisampleState = &multisampling,
+    .pDepthStencilState = &depthStencil,
+    .pColorBlendState = &colorBlending,
+    .pDynamicState = &dynamicState,
+    .layout = pipelineLayout,
+    .renderPass = nullptr
+};
+
+graphicsPipeline = vk::raii::Pipeline(device, nullptr, pipelineInfo);
+----
+
+And later on, the command buffer recording where we begin rendering:
+
+[,c{pp}]
+----
+/* TASK01: Check the setup for dynamic rendering
+ *
+ * With dynamic rendering, we specify the image view and load/store operations directly
+ * in the vk::RenderingAttachmentInfo structure.
+ * This approach eliminates the need for explicit render pass and framebuffer objects,
+ * simplifying the code and providing flexibility to change attachments at runtime.
+ */
+
+vk::RenderingAttachmentInfo colorAttachmentInfo = {
+    .imageView = swapChainImageViews[imageIndex],
+    .imageLayout = vk::ImageLayout::eColorAttachmentOptimal,
+    .loadOp = vk::AttachmentLoadOp::eClear,
+    .storeOp = vk::AttachmentStoreOp::eStore,
+    .clearValue = clearColor
+};
+
+vk::RenderingAttachmentInfo depthAttachmentInfo = {
+    .imageView = depthImageView,
+    .imageLayout = vk::ImageLayout::eDepthStencilAttachmentOptimal,
+    .loadOp = vk::AttachmentLoadOp::eClear,
+    .storeOp = vk::AttachmentStoreOp::eDontCare,
+    .clearValue = clearDepth
+};
+
+// The vk::RenderingInfo structure combines these attachments with other rendering parameters.
+vk::RenderingInfo renderingInfo = {
+    .renderArea = { .offset = { 0, 0 }, .extent = swapChainExtent },
+    .layerCount = 1,
+    .colorAttachmentCount = 1,
+    .pColorAttachments = &colorAttachmentInfo,
+    .pDepthAttachment = &depthAttachmentInfo
+};
+
+// Note: .beginRendering replaces the previous .beginRenderPass call.
+commandBuffers[currentFrame].beginRendering(renderingInfo);
+----
+
+For more context, refer to the previous tutorial link:../../03_Drawing_a_triangle/02_Graphics_pipeline_basics/03_Render_passes.adoc[chapter].
+
+==== Dynamic rendering with RenderDoc
+
+Use RenderDoc to launch the application and capture a frame:
+
+. Specify executable path: `Vulkan-Tutorial\attachments\build\38_ray_tracing\Debug\38_ray_tracing.exe`.
+. Specify working directory: `Vulkan-Tutorial\attachments\build\38_ray_tracing`.
+. Launch the application.
+
+image::../../../images/38_TASK01_renderdoc_launch.png[]
+
+In the Event Browser, you should see the calls that confirm that dynamic rendering is set up correctly:
+
+. `vkCmdBeginRenderingKHR` and `vkCmdEndRenderingKHR`.
+. `VkRenderingInfoKHR` replacing the old render pass/framebuffer concept.
+. Color (and depth) attachments set via `VkRenderingAttachmentInfo`.
+
+image::../../../images/38_TASK01_renderdoc_events.png[]
+
+In RenderDoc's Texture Viewer, you can inspect the color and depth attachments at various points:
+
+image::../../../images/38_TASK01_renderdoc_color.gif[]
+
+NOTE: Dynamic rendering reduces CPU overhead and, with the `VK_KHR_dynamic_rendering_local_read` extension, lets you do subpass-style tile-local reads without full render passes. This is great for techniques like deferred shading on tilers, where reading from a previous pass's attachment can be done on-tile without extra memory bandwidth. While we won't implement a deferred renderer here, be aware of this benefit for mobile.
+
+After this step, you should be comfortable that dynamic rendering is set up correctly. We can now move on to ray tracing features.
+
+=== Navigation
+- Previous: link:00_Overview.adoc[Overview]
+- Next: link:02_Acceleration_structures.adoc[Acceleration structures]