runtime pipeline

examples/README.md

@@ -43,10 +43,8 @@ This series explains the vulkan integration.
 -   Make sure your environment is correctly set up with all dependencies required by `Crafter.Graphics`.
 -   A comaptible WSL envoirement can be set up by running these commands:
 ```cmd
-wsl --update --pre-release
+wsl --update
 wsl --install archlinux --name crafter --no-launch
-wsl -d crafter pacman -Syu vulkan-devel mesa vulkan-dzn clang git base-devel code libpqxx onetbb boost lld glslang code --noconfirm
-wsl -d crafter bash -c "echo  export GALLIUM_DRIVER=d3d12 > /etc/profile.d/wslg.sh"
-wsl -d crafter ln -s /usr/lib/libedit.so /usr/lib/libedit.so.2
+wsl -d crafter pacman -Syu vulkan-devel vulkan-swrast clang git base-devel libpqxx onetbb boost lld glslang --noconfirm
 wsl --terminate crafter
 ```

examples/VulkanTriangleRuntime/README.md

@@ -0,0 +1,25 @@
+# HelloWindow Example
+
+## Description
+
+This example demonstrates how to load shaders and render a triangle.
+
+## Expected Result
+
+A blue tinted vulkan window with a white triangle in the center.
+
+##  Highlighted Code Snippet
+
+```cpp
+EventListener<VkCommandBuffer> listener(&window.onDraw, [&descriptors, &meshShader](VkCommandBuffer cmd){
+    vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, Pipeline::pipelineLayout, 0, 2, &descriptors.set[0], 0, NULL);
+    vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, Pipeline::pipeline);
+    VulkanDevice::vkCmdDrawMeshTasksEXTProc(cmd, meshShader.threadCount, 1, 1);
+});
+```
+
+## How to Run
+
+```bash
+crafter-build build executable -r
+```

examples/VulkanTriangleRuntime/closesthit.glsl

@@ -0,0 +1,12 @@
+#version 460
+#extension GL_EXT_ray_tracing : enable
+#extension GL_EXT_nonuniform_qualifier : enable
+
+layout(location = 0) rayPayloadInEXT vec3 hitValue;
+hitAttributeEXT vec2 attribs;
+
+void main()
+{
+  const vec3 barycentricCoords = vec3(1.0f - attribs.x - attribs.y, attribs.x, attribs.y);
+  hitValue = barycentricCoords;
+}

examples/VulkanTriangleRuntime/main.cpp

@@ -0,0 +1,138 @@
+#include <vulkan/vulkan.h>
+
+import Crafter.Graphics;
+using namespace Crafter;
+import std;
+import Crafter.Event;
+import Crafter.Math;
+
+
+int main() {
+    VulkanDevice::CreateDevice();
+    WindowVulkan window(1280, 720, "HelloVulkan");
+    VkCommandBuffer cmd = window.StartInit();
+
+    std::vector<VkDescriptorSetLayoutBinding> bindings {
+        {
+            .binding = 0,
+            .descriptorType = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR,
+            .descriptorCount = 1,
+            .stageFlags = VK_SHADER_STAGE_RAYGEN_BIT_KHR,
+        },
+        {
+            .binding = 1,
+            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
+            .descriptorCount = 1,
+            .stageFlags = VK_SHADER_STAGE_RAYGEN_BIT_KHR,
+        }
+    };
+    DescriptorSetLayoutVulkan layout(std::move(bindings));
+
+    std::array<VkDescriptorSetLayout, 1> layouts {{layout.layout}};
+
+    DescriptorPool pool;
+    pool.sets.resize(1);
+    pool.BuildPool(DescriptorPool::GetPoolSizes({layout}), layouts);
+
+    std::array<VulkanShader, 3> shaders{{
+        {"raygen.spv", "main", VK_SHADER_STAGE_RAYGEN_BIT_KHR},
+        {"miss.spv", "main", VK_SHADER_STAGE_MISS_BIT_KHR},
+        {"closesthit.spv", "main", VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR}
+    }};
+
+    ShaderBindingTableVulkan shaderTable;
+    shaderTable.Init(shaders);
+
+    std::array<VkRayTracingShaderGroupCreateInfoKHR, 1> raygenGroups {{
+        {
+            .sType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR,
+            .type = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR,
+            .generalShader = 0,
+            .closestHitShader = VK_SHADER_UNUSED_KHR,
+            .anyHitShader = VK_SHADER_UNUSED_KHR,
+            .intersectionShader = VK_SHADER_UNUSED_KHR,
+        },
+    }};
+    std::array<VkRayTracingShaderGroupCreateInfoKHR, 1> missGroups {{
+        {
+            .sType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR,
+            .type = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR,
+            .generalShader = 1,
+            .closestHitShader = VK_SHADER_UNUSED_KHR,
+            .anyHitShader = VK_SHADER_UNUSED_KHR,
+            .intersectionShader = VK_SHADER_UNUSED_KHR,
+        },
+    }};
+    std::array<VkRayTracingShaderGroupCreateInfoKHR, 1> hitGroups {{
+        {
+            .sType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR,
+            .type = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR,
+            .generalShader = VK_SHADER_UNUSED_KHR,
+            .closestHitShader = 2,
+            .anyHitShader = VK_SHADER_UNUSED_KHR,
+            .intersectionShader = VK_SHADER_UNUSED_KHR,
+        },
+    }};
+
+    PipelineRTVulkan pipeline;
+    pipeline.Init(cmd, layouts, raygenGroups, missGroups, hitGroups, shaderTable);
+
+    Mesh triangleMesh;
+    std::array<Vector<float, 3, 3>, 3> verts {{{-150, -150, 100}, {0, 150, 100}, {150, -150, 100}}};
+    std::array<std::uint32_t, 3> index {{2,1,0}};
+    triangleMesh.Build(verts, index, cmd);
+    RenderingElement3DVulkan renderer = {
+        .instance = {
+            .instanceCustomIndex                    = 0,
+            .mask                                   = 0xFF,
+            .instanceShaderBindingTableRecordOffset = 0,
+            .flags                                  = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR,
+            .accelerationStructureReference         = triangleMesh.blasAddr
+        }
+    };
+    MatrixRowMajor<float, 4, 3, 1> transform = MatrixRowMajor<float, 4, 3, 1>::Identity();
+    std::memcpy(renderer.instance.transform.matrix, transform.m, sizeof(transform.m));
+    RenderingElement3DVulkan::tlases.resize(1);
+    RenderingElement3DVulkan::elements.push_back(&renderer);
+    RenderingElement3DVulkan::BuildTLAS(cmd, 0);
+
+    VkDescriptorImageInfo imageInfo = {
+        .imageView = window.imageViews[0],
+        .imageLayout = VK_IMAGE_LAYOUT_GENERAL
+    };
+
+    VkWriteDescriptorSetAccelerationStructureKHR writeDescriptorSetAccelerationStructure {
+        .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR,
+        .accelerationStructureCount = 1,
+        .pAccelerationStructures = &RenderingElement3DVulkan::tlases[0].accelerationStructure
+    };
+
+    VkWriteDescriptorSet write[2] = {
+        {
+            .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
+            .pNext = &writeDescriptorSetAccelerationStructure,
+            .dstSet = pool.sets[0],
+            .dstBinding = 0,
+            .dstArrayElement = 0,
+            .descriptorCount = 1,
+            .descriptorType = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR,
+        },
+        {
+            .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
+            .dstSet = pool.sets[0],
+            .dstBinding = 1,
+            .dstArrayElement = 0,
+            .descriptorCount = 1,
+            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
+            .pImageInfo = &imageInfo
+        }
+    };
+    vkUpdateDescriptorSets(VulkanDevice::device, 2, write, 0, nullptr);
+
+    window.SetPipelineRT(pipeline);
+    window.descriptorsRt = pool.sets;
+
+    window.FinishInit();
+    window.Render();
+    window.StartSync();
+}

examples/VulkanTriangleRuntime/miss.glsl

@@ -0,0 +1,9 @@
+#version 460
+#extension GL_EXT_ray_tracing : enable
+
+layout(location = 0) rayPayloadInEXT vec3 hitValue;
+
+void main()
+{
+    hitValue = vec3(1, 1, 1);
+}

examples/VulkanTriangleRuntime/project.json

@@ -0,0 +1,32 @@
+{
+    "name": "crafter-graphics",
+    "configurations": [
+        {
+            "name": "executable",
+            "implementations": ["main"],
+            "dependencies": [
+                {
+                    "path":"../../project.json",
+                    "configuration":"lib-vulkan-debug"
+                }
+            ],
+            "shaders": [
+                {
+                    "path":"raygen.glsl",
+                    "type": 6,
+                    "entrypoint":"main"
+                },
+                {
+                    "path":"closesthit.glsl",
+                    "type": 9,
+                    "entrypoint":"main"
+                },
+                {
+                    "path":"miss.glsl",
+                    "type": 10,
+                    "entrypoint":"main"
+                }
+            ]
+        }
+    ]
+}

examples/VulkanTriangleRuntime/raygen.glsl

@@ -0,0 +1,47 @@
+#version 460
+#extension GL_EXT_ray_tracing : enable
+#extension GL_EXT_shader_image_load_formatted : enable
+
+layout(binding = 0, set = 0) uniform accelerationStructureEXT topLevelAS;
+layout(binding = 1, set = 0, rgba8) uniform writeonly image2D image;
+
+layout(location = 0) rayPayloadEXT vec3 hitValue;
+
+void main()
+{
+    // Pixel coordinates
+    uvec2 pixel = gl_LaunchIDEXT.xy;
+    uvec2 resolution = gl_LaunchSizeEXT.xy;
+
+    // Normalized coordinates in range [-1, 1]
+    vec2 uv = (vec2(pixel) + 0.5) / vec2(resolution);
+    vec2 ndc = uv * 2.0 - 1.0;
+
+    // Camera parameters
+    vec3 origin = vec3(0.0, 0.0, -300.0);
+
+    float aspect = float(resolution.x) / float(resolution.y);
+    float fov = radians(60.0);
+    float tanHalfFov = tan(fov * 0.5);
+
+    // Simple pinhole camera facing +Z
+    vec3 direction = normalize(vec3(
+        ndc.x * aspect * tanHalfFov,
+        -ndc.y * tanHalfFov,
+        1.0
+    ));
+
+    traceRayEXT(
+        topLevelAS,
+        gl_RayFlagsNoneEXT,
+        0xff,
+        0, 0, 0,
+        origin,
+        0.001,
+        direction,
+        10000.0,
+        0
+    );
+
+    imageStore(image, ivec2(pixel), vec4(hitValue, 1.0));
+}