More Ray tracing changes

src/Engine/Graphics/Buffer.cpp

@@ -1,5 +1,4 @@
 #include "Buffer.h"
-#include "Buffer.h"
 
 using namespace Seele;
 using namespace Seele::Gfx;
@@ -42,6 +41,7 @@ IndexBuffer::IndexBuffer(QueueFamilyMapping mapping, uint64 size, Gfx::SeIndexTy
 IndexBuffer::~IndexBuffer()
 {
 }
+
 UniformBuffer::UniformBuffer(QueueFamilyMapping mapping, const DataSource& sourceData)
 	: Buffer(mapping, sourceData.owner)
 {}

src/Engine/Graphics/Buffer.h

@@ -1,5 +1,6 @@
 #pragma once
 #include "Resources.h"
+#include "Initializer.h"
 
 namespace Seele {
 namespace Gfx {

src/Engine/Graphics/CMakeLists.txt

@@ -14,10 +14,13 @@ target_sources(Engine
         Initializer.h
         Mesh.h
         Mesh.cpp
+        MeshData.h
         Meshlet.h
         Meshlet.cpp
         Pipeline.h
         Pipeline.cpp
+        RayTracing.h
+        RayTracing.cpp
         RenderTarget.h
         RenderTarget.cpp
         Resources.h
@@ -47,7 +50,9 @@ target_sources(Engine
             Initializer.h
             Mesh.h
             Meshlet.h
+            MeshData.h
             Pipeline.h
+            RayTracing.h
             RenderTarget.h
             Resources.h
             Shader.h

src/Engine/Graphics/Descriptor.h

@@ -1,7 +1,7 @@
 #pragma once
 #include "Enums.h"
 #include "Resources.h"
-#include <compare>
+#include "Initializer.h"
 
 namespace Seele {
 namespace Gfx {
@@ -19,17 +19,19 @@ DECLARE_REF(DescriptorPool)
 DECLARE_REF(DescriptorSet)
 class DescriptorLayout {
 public:
-  DescriptorLayout(const std::string& name);
+  DescriptorLayout(const std::string &name);
-  DescriptorLayout(const DescriptorLayout& other);
+  DescriptorLayout(const DescriptorLayout &other);
-  DescriptorLayout& operator=(const DescriptorLayout& other);
+  DescriptorLayout &operator=(const DescriptorLayout &other);
   virtual ~DescriptorLayout();
   void addDescriptorBinding(DescriptorBinding binding);
   void reset();
   PDescriptorSet allocateDescriptorSet();
   virtual void create() = 0;
-  constexpr const Array<DescriptorBinding>& getBindings() const { return descriptorBindings; }
+  constexpr const Array<DescriptorBinding> &getBindings() const {
+    return descriptorBindings;
+  }
   constexpr uint32 getHash() const { return hash; }
-  constexpr const std::string& getName() const { return name; }
+  constexpr const std::string &getName() const { return name; }
 
 protected:
   Array<DescriptorBinding> descriptorBindings;
@@ -61,33 +63,41 @@ public:
   virtual void writeChanges() = 0;
   virtual void updateBuffer(uint32 binding, PUniformBuffer uniformBuffer) = 0;
   virtual void updateBuffer(uint32 binding, PShaderBuffer ShaderBuffer) = 0;
-  virtual void updateBuffer(uint32_t binding, uint32 index, Gfx::PShaderBuffer uniformBuffer) = 0;
+  virtual void updateBuffer(uint32_t binding, uint32 index,
+                            Gfx::PShaderBuffer uniformBuffer) = 0;
   virtual void updateSampler(uint32 binding, PSampler sampler) = 0;
-  virtual void updateTexture(uint32 binding, PTexture texture, PSampler samplerState = nullptr) = 0;
+  virtual void updateTexture(uint32 binding, PTexture texture,
-  virtual void updateTextureArray(uint32_t binding, Array<PTexture> texture) = 0;
+                             PSampler samplerState = nullptr) = 0;
+  virtual void updateTextureArray(uint32_t binding,
+                                  Array<PTexture> texture) = 0;
   bool operator<(PDescriptorSet other);
 
   constexpr PDescriptorLayout getLayout() const { return layout; }
-  constexpr const std::string& getName() const { return layout->getName(); }
+  constexpr const std::string &getName() const { return layout->getName(); }
 
 protected:
   PDescriptorLayout layout;
 };
 DEFINE_REF(DescriptorSet)
 
+DECLARE_REF(PipelineLayout)
 class PipelineLayout {
 public:
-  PipelineLayout(const std::string& name);
+  PipelineLayout(const std::string &name);
-  PipelineLayout(const std::string& name, PPipelineLayout baseLayout);
+  PipelineLayout(const std::string &name, PPipelineLayout baseLayout);
   virtual ~PipelineLayout();
   virtual void create() = 0;
   void addDescriptorLayout(PDescriptorLayout layout);
-  void addPushConstants(const SePushConstantRange& pushConstants);
+  void addPushConstants(const SePushConstantRange &pushConstants);
   constexpr uint32 getHash() const { return layoutHash; }
-  constexpr const Map<std::string, PDescriptorLayout>& getLayouts() const { return descriptorSetLayouts; }
+  constexpr const Map<std::string, PDescriptorLayout> &getLayouts() const {
-  constexpr uint32 findParameter(const std::string& param) const { return parameterMapping[param]; }
+    return descriptorSetLayouts;
+  }
+  constexpr uint32 findParameter(const std::string &param) const {
+    return parameterMapping[param];
+  }
   void addMapping(Map<std::string, uint32> mapping);
-    constexpr std::string getName() const {return name;};
+  constexpr std::string getName() const { return name; };
 
 protected:
   uint32 layoutHash = 0;

src/Engine/Graphics/Graphics.h

@@ -31,6 +31,8 @@ DECLARE_REF(GraphicsPipeline)
 DECLARE_REF(ComputePipeline)
 DECLARE_REF(RenderCommand)
 DECLARE_REF(ComputeCommand)
+DECLARE_REF(BottomLevelAS)
+DECLARE_REF(TopLevelAS)
 class Graphics
 {
 public:
@@ -88,6 +90,10 @@ public:
     virtual void resolveTexture(Gfx::PTexture source, Gfx::PTexture destination) = 0;
 
     bool supportMeshShading() const { return meshShadingEnabled; }
+
+    // Ray Tracing
+    virtual OBottomLevelAS createBottomLevelAccelerationStructure(const BottomLevelASCreateInfo& createInfo) = 0;
+    virtual OTopLevelAS createTopLevelAccelerationStructure(const TopLevelASCreateInfo& createInfo) = 0;
 protected:
     QueueFamilyMapping queueMapping;
     OShaderCompiler shaderCompiler;

src/Engine/Graphics/Initializer.h

@@ -2,6 +2,8 @@
 #include "Enums.h"
 #include "Containers/Map.h"
 #include "Math/Math.h"
+#include "MinimalEngine.h"
+#include "MeshData.h"
 
 namespace Seele
 {
@@ -113,6 +115,7 @@ namespace Seele
         DataSource  sourceData = DataSource();
         uint64      numElements = 1;
         uint8       dynamic = 0;
+        uint8       vertexBuffer = 0;
         std::string name = "Unnamed";
     };
     DECLARE_NAME_REF(Gfx, PipelineLayout)
@@ -144,6 +147,7 @@ namespace Seele
         Array<VertexInputBinding> bindings;
         Array<VertexInputAttribute> attributes;
     };
+    DECLARE_REF(MaterialInstance)
     namespace Gfx
     {
         struct SePushConstantRange
@@ -244,5 +248,19 @@ namespace Seele
             Gfx::PComputeShader     computeShader = nullptr;
             Gfx::PPipelineLayout    pipelineLayout = nullptr;
         };
+        DECLARE_REF(ShaderBuffer)
+        struct BottomLevelASCreateInfo
+        {
+            PShaderBuffer positionBuffer;
+            PShaderBuffer indexBuffer;
+            MeshData meshData;
+            PMaterialInstance material;
+            uint64 verticesOffset;
+            uint64 indicesOffset;
+        };
+        struct TopLevelASCreateInfo
+        {
+
+        };
     } // namespace Gfx
 } // namespace Seele

src/Engine/Graphics/MeshData.h

@@ -0,0 +1,18 @@
+#pragma once
+#include "Math/AABB.h"
+namespace Seele
+{
+struct MeshData
+{
+    AABB bounding;
+    uint32 numMeshlets = 0;
+    uint32 meshletOffset = 0;
+    uint32 firstIndex = 0;
+    uint32 numIndices = 0;
+};
+struct InstanceData
+{
+    Matrix4 transformMatrix;
+    Matrix4 inverseTransformMatrix;
+};
+}

src/Engine/Graphics/RayTracing.cpp

@@ -0,0 +1,15 @@
+#include "RayTracing.h"
+
+using namespace Seele::Gfx;
+
+BottomLevelAS::BottomLevelAS()
+{}
+
+BottomLevelAS::~BottomLevelAS()
+{}
+
+TopLevelAS::TopLevelAS()
+{}
+
+TopLevelAS::~TopLevelAS()
+{}

src/Engine/Graphics/RayTracing.h

@@ -0,0 +1,25 @@
+#pragma once
+#include "Resources.h"
+
+namespace Seele
+{
+namespace Gfx
+{
+class BottomLevelAS
+{
+public:
+    BottomLevelAS();
+    ~BottomLevelAS();
+private:
+};
+DEFINE_REF(BottomLevelAS)
+class TopLevelAS
+{
+public:
+    TopLevelAS();
+    ~TopLevelAS();
+private:
+};
+DEFINE_REF(TopLevelAS)
+}
+}

src/Engine/Graphics/RenderPass/RayTracingPass.h

@@ -5,6 +5,16 @@ namespace Seele
 {
 class RayTracingPass : public RenderPass
 {
+public:
+    RayTracingPass(Gfx::PGraphics graphics, PScene scene);
+    RayTracingPass(RayTracingPass&& other) = default;
+    RayTracingPass& operator=(RayTracingPass&& other) = default;
+    virtual void beginFrame(const Component::Camera& cam) override;
+    virtual void render() override;
+    virtual void endFrame() override;
+    virtual void publishOutputs() override;
+    virtual void createRenderPass() override;
+private:
     
 };
 }

src/Engine/Graphics/Resources.h

@@ -2,12 +2,6 @@
 #include "Math/Math.h"
 #include "Enums.h"
 #include "Containers/Array.h"
-#include "Containers/List.h"
-#include "Initializer.h"
-#include "Descriptor.h"
-#include "CRC.h"
-#include <functional>
-
 
 #ifndef ENABLE_VALIDATION
 #define ENABLE_VALIDATION 1

src/Engine/Graphics/StaticMeshVertexData.cpp

@@ -201,9 +201,11 @@ void StaticMeshVertexData::resizeBuffers()
         },
         .numElements = verticesAllocated * 3,
         .dynamic = false,
+        .vertexBuffer = 1,
         .name = "Positions",
     };
     positions = graphics->createShaderBuffer(createInfo);
+    createInfo.vertexBuffer = false;
     createInfo.name = "Normals";
     normals = graphics->createShaderBuffer(createInfo);
     createInfo.name = "Tangents";

src/Engine/Graphics/VertexData.cpp

@@ -4,10 +4,9 @@
 #include "Material/Material.h"
 #include "Graphics/Graphics.h"
 #include "Graphics/Descriptor.h"
-#include "Component/Mesh.h"
 #include "Graphics/Shader.h"
 #include "Graphics/Mesh.h"
-#include "Containers/Set.h"
+#include "Material/MaterialInstance.h"
 
 using namespace Seele;
 
@@ -114,7 +113,6 @@ void VertexData::createDescriptors()
     instanceData.clear();
     instanceMeshData.clear();
 
-    uint32 numMeshlets = 0;
     Array<uint32> cullingOffsets;
     for (auto &mat : materialData)
     {
@@ -130,7 +128,6 @@ void VertexData::createDescriptors()
                 instanceMeshData.add(instance.instanceMeshData[i]);
                 // instance.numMeshlets += instance.instanceMeshData[i].numMeshlets;
                 // cullingOffsets.add(numMeshlets);
-                numMeshlets += instance.instanceMeshData[i].numMeshlets;
             }
         }
     }

src/Engine/Graphics/VertexData.h

@@ -1,77 +1,56 @@
 #pragma once
-#include "Graphics/Initializer.h"
-#include "Material/MaterialInstance.h"
 #include "Component/Transform.h"
 #include "Containers/List.h"
+#include "Graphics/Buffer.h"
 #include "Graphics/Command.h"
 #include "Graphics/Descriptor.h"
-#include "Graphics/Buffer.h"
+#include "MeshData.h"
 #include "Meshlet.h"
 #include <entt/entt.hpp>
 
+
 constexpr uint64 MAX_TEXCOORDS = 8;
 
-namespace Seele
+namespace Seele {
-{
+DECLARE_REF(MaterialInstance)
-  DECLARE_REF(Mesh)
+DECLARE_REF(Mesh)
-  struct MeshId
+struct MeshId {
-  {
   uint64 id;
-    std::strong_ordering operator<=>(const MeshId &other) const
+  std::strong_ordering operator<=>(const MeshId &other) const {
-    {
     return id <=> other.id;
   }
-    bool operator==(const MeshId &other) const
+  bool operator==(const MeshId &other) const { return id == other.id; }
-    {
+};
-      return id == other.id;
+class VertexData {
-    }
+public:
-  };
+  struct DrawCallOffsets {
-  class VertexData
-  {
-  public:
-    struct InstanceData
-    {
-      Matrix4 transformMatrix;
-      Matrix4 inverseTransformMatrix;
-    };
-    struct MeshData
-    {
-      AABB bounding;
-      uint32 numMeshlets = 0;
-      uint32 meshletOffset = 0;
-      uint32 firstIndex = 0;
-      uint32 numIndices = 0;
-    };
-    struct DrawCallOffsets
-    {
     uint32 instanceOffset = 0;
   };
 
-    struct MeshletCullingInfo
+  struct MeshletCullingInfo {
-    {
     uint64_t cull[256 / 64];
   };
-    struct BatchedDrawCall
+  struct BatchedDrawCall {
-    {
     PMaterialInstance materialInstance;
     DrawCallOffsets offsets;
     Array<InstanceData> instanceData;
     Array<MeshData> instanceMeshData;
     Array<uint32> cullingOffsets;
   };
-    struct MaterialData
+  struct MaterialData {
-    {
     PMaterial material;
     Array<BatchedDrawCall> instances;
   };
   void resetMeshData();
-    void updateMesh(entt::entity id, uint32 meshIndex, PMesh mesh, Component::Transform &transform);
+  void updateMesh(entt::entity id, uint32 meshIndex, PMesh mesh,
+                  Component::Transform &transform);
   void createDescriptors();
   void loadMesh(MeshId id, Array<uint32> indices, Array<Meshlet> meshlets);
   MeshId allocateVertexData(uint64 numVertices);
   uint64 getMeshOffset(MeshId id);
   uint64 getMeshVertexCount(MeshId id);
-    virtual void serializeMesh(MeshId id, uint64 numVertices, ArchiveBuffer &buffer) = 0;
+  virtual void serializeMesh(MeshId id, uint64 numVertices,
+                             ArchiveBuffer &buffer) = 0;
   virtual void deserializeMesh(MeshId id, ArchiveBuffer &buffer) = 0;
   virtual void bindBuffers(Gfx::PRenderCommand command) = 0;
   virtual Gfx::PDescriptorLayout getVertexDataLayout() = 0;
@@ -82,28 +61,29 @@ namespace Seele
   Gfx::PDescriptorSet getInstanceDataSet() { return descriptorSet; }
   const Array<MaterialData> &getMaterialData() const { return materialData; }
   const MeshData &getMeshData(MeshId id) { return meshData[id]; }
-    uint64 getIndicesOffset(uint32 meshletIndex) { return meshlets[meshletIndex].indicesOffset; }
+  uint64 getIndicesOffset(uint32 meshletIndex) {
+    return meshlets[meshletIndex].indicesOffset;
+  }
   uint64 getNumInstances() const { return instanceData.size(); }
   static List<VertexData *> getList();
   static VertexData *findByTypeName(std::string name);
   virtual void init(Gfx::PGraphics graphics);
   virtual void destroy();
 
-    struct CullingMapping
+  struct CullingMapping {
-    {
     uint64 instanceId;
     uint32 cullingOffset;
   };
-    static CullingMapping getCullingMapping(entt::entity id, uint32 meshIndex, uint32 numMeshlets);
+  static CullingMapping getCullingMapping(entt::entity id, uint32 meshIndex,
+                                          uint32 numMeshlets);
   static uint64 getInstanceCount() { return instanceCount; }
   static uint64 getMeshletCount() { return meshletCount; }
 
-  protected:
+protected:
   virtual void resizeBuffers() = 0;
   virtual void updateBuffers() = 0;
   VertexData();
-    struct MeshletDescription
+  struct MeshletDescription {
-    {
     AABB bounding;
     uint32 vertexCount;
     uint32 primitiveCount;
@@ -123,11 +103,10 @@ namespace Seele
   Array<uint32> vertexIndices;
   Array<uint32> indices;
 
-    struct MeshMapping
+  struct MeshMapping {
-    {
     entt::entity id;
     uint32 meshId;
-        auto operator<=>(const MeshMapping& other) const = default;
+    auto operator<=>(const MeshMapping &other) const = default;
   };
   static Map<MeshMapping, CullingMapping> instanceIdMap;
   static uint64 instanceCount;
@@ -152,5 +131,5 @@ namespace Seele
   uint64 head;
   uint64 verticesAllocated;
   bool dirty;
-  };
+};
-}
+} // namespace Seele

src/Engine/Graphics/Vulkan/Buffer.cpp

@@ -1,5 +1,7 @@
 #include "Buffer.h"
 #include "Command.h"
+#include "Enums.h"
+#include <vulkan/vulkan_core.h>
 
 using namespace Seele;
 using namespace Seele::Vulkan;
@@ -7,16 +9,13 @@ using namespace Seele::Vulkan;
 BufferAllocation::BufferAllocation(PGraphics graphics)
     : CommandBoundResource(graphics) {}
 
-BufferAllocation::~BufferAllocation()
+BufferAllocation::~BufferAllocation() {
-{
+  if (buffer != VK_NULL_HANDLE) {
-    if (buffer != VK_NULL_HANDLE)
-    {
     vmaDestroyBuffer(graphics->getAllocator(), buffer, allocation);
   }
 }
 
-struct PendingBuffer
+struct PendingBuffer {
-{
   OBufferAllocation allocation;
   uint64 offset;
   Gfx::QueueType prevQueue;
@@ -28,23 +27,20 @@ static Map<Vulkan::Buffer *, PendingBuffer> pendingBuffers;
 Buffer::Buffer(PGraphics graphics, uint64 size, VkBufferUsageFlags usage,
                Gfx::QueueType &queueType, bool dynamic, std::string name)
     : graphics(graphics), currentBuffer(0), owner(queueType),
-      usage(usage | VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT), dynamic(dynamic),
+      usage(usage | VK_BUFFER_USAGE_TRANSFER_DST_BIT |
-      name(name)
+            VK_BUFFER_USAGE_TRANSFER_SRC_BIT),
-{
+      dynamic(dynamic), name(name) {
   createBuffer(size);
 }
 
-Buffer::~Buffer()
+Buffer::~Buffer() {
-{
+  for (uint32 i = 0; i < buffers.size(); ++i) {
-    for (uint32 i = 0; i < buffers.size(); ++i)
-    {
     graphics->getDestructionManager()->queueResourceForDestruction(
         std::move(buffers[i]));
   }
 }
 
-void Buffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
+void Buffer::executeOwnershipBarrier(Gfx::QueueType newOwner) {
-{
   if (getSize() == 0)
     return;
   Gfx::QueueFamilyMapping mapping = graphics->getFamilyMapping();
@@ -62,35 +58,25 @@ void Buffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
   VkPipelineStageFlags srcStage = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
   VkPipelineStageFlags dstStage = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
   assert(barrier.srcQueueFamilyIndex != barrier.dstQueueFamilyIndex);
-    if (owner == Gfx::QueueType::TRANSFER)
+  if (owner == Gfx::QueueType::TRANSFER) {
-    {
     barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
     srcStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
-    }
+  } else if (owner == Gfx::QueueType::COMPUTE) {
-    else if (owner == Gfx::QueueType::COMPUTE)
-    {
     barrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
     srcStage = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
-    }
+  } else if (owner == Gfx::QueueType::GRAPHICS) {
-    else if (owner == Gfx::QueueType::GRAPHICS)
-    {
     barrier.srcAccessMask = getSourceAccessMask();
     srcStage = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
   }
-    if (newOwner == Gfx::QueueType::TRANSFER)
+  if (newOwner == Gfx::QueueType::TRANSFER) {
-    {
     barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
     dstStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
     dstPool = graphics->getTransferCommands();
-    }
+  } else if (newOwner == Gfx::QueueType::COMPUTE) {
-    else if (newOwner == Gfx::QueueType::COMPUTE)
-    {
     barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
     dstStage = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
     dstPool = graphics->getComputeCommands();
-    }
+  } else if (newOwner == Gfx::QueueType::GRAPHICS) {
-    else if (newOwner == Gfx::QueueType::GRAPHICS)
-    {
     barrier.dstAccessMask = getDestAccessMask();
     dstStage = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
     dstPool = graphics->getGraphicsCommands();
@@ -107,8 +93,7 @@ void Buffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
 void Buffer::executePipelineBarrier(VkAccessFlags srcAccess,
                                     VkPipelineStageFlags srcStage,
                                     VkAccessFlags dstAccess,
-                                    VkPipelineStageFlags dstStage)
+                                    VkPipelineStageFlags dstStage) {
-{
   if (getSize() == 0)
     return;
   PCommand commandBuffer = graphics->getQueueCommands(owner)->getCommands();
@@ -130,8 +115,7 @@ void Buffer::executePipelineBarrier(VkAccessFlags srcAccess,
 void *Buffer::map(bool writeOnly) { return mapRegion(0, getSize(), writeOnly); }
 
 void *Buffer::mapRegion(uint64 regionOffset, uint64 regionSize,
-                        bool writeOnly)
+                        bool writeOnly) {
-{
   if (regionSize == 0)
     return nullptr;
   void *data = nullptr;
@@ -142,16 +126,12 @@ void *Buffer::mapRegion(uint64 regionOffset, uint64 regionSize,
   pending.writeOnly = writeOnly;
   pending.prevQueue = owner;
   pending.offset = regionOffset;
-    if (writeOnly)
+  if (writeOnly) {
-    {
     if (buffers[currentBuffer]->properties &
-            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
+        VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) {
-        {
       VK_CHECK(vmaMapMemory(graphics->getAllocator(),
                             buffers[currentBuffer]->allocation, &data));
-        }
+    } else {
-        else
-        {
       VkBufferCreateInfo stagingInfo = {
           .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
           .pNext = nullptr,
@@ -174,9 +154,7 @@ void *Buffer::mapRegion(uint64 regionOffset, uint64 regionSize,
       vmaSetAllocationName(graphics->getAllocator(),
                            pending.allocation->allocation, "MappingStaging");
     }
-    }
+  } else {
-    else
-    {
     assert(false);
   }
   pendingBuffers[this] = std::move(pending);
@@ -185,22 +163,16 @@ void *Buffer::mapRegion(uint64 regionOffset, uint64 regionSize,
   return data;
 }
 
-void Buffer::unmap()
+void Buffer::unmap() {
-{
   auto found = pendingBuffers.find(this);
-    if (found != pendingBuffers.end())
+  if (found != pendingBuffers.end()) {
-    {
     PendingBuffer &pending = found->value;
-        if (pending.writeOnly)
+    if (pending.writeOnly) {
-        {
       if (buffers[currentBuffer]->properties &
-                VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
+          VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) {
-            {
         vmaUnmapMemory(graphics->getAllocator(),
                        buffers[currentBuffer]->allocation);
-            }
+      } else {
-            else
-            {
         vmaFlushAllocation(graphics->getAllocator(),
                            pending.allocation->allocation, 0, VK_WHOLE_SIZE);
         vmaUnmapMemory(graphics->getAllocator(),
@@ -252,18 +224,14 @@ void Buffer::unmap()
   }
 }
 
-void Buffer::rotateBuffer(uint64 size, bool preserveContents)
+void Buffer::rotateBuffer(uint64 size, bool preserveContents) {
-{
   assert(dynamic);
   size = std::max(getSize(), size);
-    for (size_t i = 0; i < buffers.size(); ++i)
+  for (size_t i = 0; i < buffers.size(); ++i) {
-    {
+    if (buffers[i]->isCurrentlyBound()) {
-        if (buffers[i]->isCurrentlyBound())
-        {
       continue;
     }
-        if (buffers[i]->size < size)
+    if (buffers[i]->size < size) {
-        {
       vmaDestroyBuffer(graphics->getAllocator(), buffers[i]->buffer,
                        buffers[i]->allocation);
       VkBufferCreateInfo info = {
@@ -285,8 +253,7 @@ void Buffer::rotateBuffer(uint64 size, bool preserveContents)
       vmaGetAllocationMemoryProperties(graphics->getAllocator(),
                                        buffers[i]->allocation,
                                        &buffers[i]->properties);
-            if (!name.empty())
+      if (!name.empty()) {
-            {
         VkDebugUtilsObjectNameInfoEXT nameInfo = {
             .sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT,
             .pNext = nullptr,
@@ -297,23 +264,20 @@ void Buffer::rotateBuffer(uint64 size, bool preserveContents)
       }
       buffers[i]->size = size;
     }
-        if (preserveContents)
+    if (preserveContents) {
-        {
       copyBuffer(currentBuffer, i);
     }
     currentBuffer = i;
     return;
   }
   createBuffer(size);
-    if (preserveContents)
+  if (preserveContents) {
-    {
     copyBuffer(currentBuffer, buffers.size() - 1);
   }
   currentBuffer = buffers.size() - 1;
 }
 
-void Buffer::createBuffer(uint64 size)
+void Buffer::createBuffer(uint64 size) {
-{
   VkBufferCreateInfo info = {
       .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
       .pNext = nullptr,
@@ -327,8 +291,7 @@ void Buffer::createBuffer(uint64 size)
       .usage = VMA_MEMORY_USAGE_AUTO,
   };
   buffers.add(new BufferAllocation(graphics));
-    if (size > 0)
+  if (size > 0) {
-    {
     VK_CHECK(vmaCreateBuffer(
         graphics->getAllocator(), &info, &allocInfo, &buffers.back()->buffer,
         &buffers.back()->allocation, &buffers.back()->info));
@@ -336,8 +299,14 @@ void Buffer::createBuffer(uint64 size)
     vmaGetAllocationMemoryProperties(graphics->getAllocator(),
                                      buffers.back()->allocation,
                                      &buffers.back()->properties);
-        if (!name.empty())
+    VkBufferDeviceAddressInfo addrInfo = {
-        {
+        .sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR,
+        .pNext = nullptr,
+        .buffer = buffers.back()->buffer,
+    };
+    buffers.back()->deviceAddress =
+        vkGetBufferDeviceAddress(graphics->getDevice(), &addrInfo);
+    if (!name.empty()) {
       VkDebugUtilsObjectNameInfoEXT nameInfo = {
           .sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT,
           .pNext = nullptr,
@@ -349,10 +318,8 @@ void Buffer::createBuffer(uint64 size)
   }
 }
 
-void Buffer::copyBuffer(uint64 src, uint64 dst)
+void Buffer::copyBuffer(uint64 src, uint64 dst) {
-{
+  if (src == dst) {
-    if (src == dst)
-    {
     return;
   }
   PCommand command = graphics->getQueueCommands(owner)->getCommands();
@@ -367,13 +334,14 @@ void Buffer::copyBuffer(uint64 src, uint64 dst)
       .offset = 0,
       .size = buffers[src]->size,
   };
-    vkCmdPipelineBarrier(command->getHandle(), VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 1, &srcBarrier, 0, nullptr);
+  vkCmdPipelineBarrier(command->getHandle(),
+                       VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
+                       VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 1,
+                       &srcBarrier, 0, nullptr);
   VkBufferCopy region = {
-        .srcOffset = 0,
+      .srcOffset = 0, .dstOffset = 0, .size = buffers[src]->size};
-        .dstOffset = 0,
+  vkCmdCopyBuffer(command->getHandle(), buffers[src]->buffer,
-        .size = buffers[src]->size
+                  buffers[dst]->buffer, 1, &region);
-    };
-    vkCmdCopyBuffer(command->getHandle(), buffers[src]->buffer, buffers[dst]->buffer, 1, &region);
   VkBufferMemoryBarrier dstBarrier = {
       .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
       .pNext = nullptr,
@@ -385,7 +353,9 @@ void Buffer::copyBuffer(uint64 src, uint64 dst)
       .offset = 0,
       .size = buffers[dst]->size,
   };
-    vkCmdPipelineBarrier(command->getHandle(), VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, 0, 0, nullptr, 1, &dstBarrier, 0, nullptr);
+  vkCmdPipelineBarrier(command->getHandle(), VK_PIPELINE_STAGE_TRANSFER_BIT,
+                       VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, 0, 0, nullptr, 1,
+                       &dstBarrier, 0, nullptr);
 }
 
 UniformBuffer::UniformBuffer(PGraphics graphics,
@@ -393,10 +363,8 @@ UniformBuffer::UniformBuffer(PGraphics graphics,
     : Gfx::UniformBuffer(graphics->getFamilyMapping(), createInfo.sourceData),
       Vulkan::Buffer(graphics, createInfo.sourceData.size,
                      VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, currentOwner,
-                     createInfo.dynamic, createInfo.name)
+                     createInfo.dynamic, createInfo.name) {
-{
+  if (getSize() > 0 && createInfo.sourceData.data != nullptr) {
-    if (getSize() > 0 && createInfo.sourceData.data != nullptr)
-    {
     void *data = map();
     std::memcpy(data, createInfo.sourceData.data, createInfo.sourceData.size);
     unmap();
@@ -405,44 +373,37 @@ UniformBuffer::UniformBuffer(PGraphics graphics,
 
 UniformBuffer::~UniformBuffer() {}
 
-void UniformBuffer::updateContents(const DataSource &sourceData)
+void UniformBuffer::updateContents(const DataSource &sourceData) {
-{
   void *data = map();
   std::memcpy(data, sourceData.data, sourceData.size);
   unmap();
 }
 
-void UniformBuffer::rotateBuffer(uint64 size)
+void UniformBuffer::rotateBuffer(uint64 size) {
-{
   Vulkan::Buffer::rotateBuffer(size);
 }
 
-void UniformBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner)
+void UniformBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner) {
-{
   Gfx::QueueOwnedResource::transferOwnership(newOwner);
 }
 
-void UniformBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
+void UniformBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner) {
-{
   Vulkan::Buffer::executeOwnershipBarrier(newOwner);
 }
 
 void UniformBuffer::executePipelineBarrier(VkAccessFlags srcAccess,
                                            VkPipelineStageFlags srcStage,
                                            VkAccessFlags dstAccess,
-                                           VkPipelineStageFlags dstStage)
+                                           VkPipelineStageFlags dstStage) {
-{
   Vulkan::Buffer::executePipelineBarrier(srcAccess, srcStage, dstAccess,
                                          dstStage);
 }
 
-VkAccessFlags UniformBuffer::getSourceAccessMask()
+VkAccessFlags UniformBuffer::getSourceAccessMask() {
-{
   return VK_ACCESS_MEMORY_WRITE_BIT;
 }
 
-VkAccessFlags UniformBuffer::getDestAccessMask()
+VkAccessFlags UniformBuffer::getDestAccessMask() {
-{
   return VK_ACCESS_UNIFORM_READ_BIT;
 }
 
@@ -450,12 +411,15 @@ ShaderBuffer::ShaderBuffer(PGraphics graphics,
                            const ShaderBufferCreateInfo &sourceData)
     : Gfx::ShaderBuffer(graphics->getFamilyMapping(), sourceData.numElements,
                         sourceData.sourceData),
-      Vulkan::Buffer(graphics, sourceData.sourceData.size,
+      Vulkan::Buffer(
-                     VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, currentOwner,
+          graphics, sourceData.sourceData.size,
-                     sourceData.dynamic, sourceData.name)
+          VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
-{
+              (sourceData.vertexBuffer
-    if (getSize() > 0 && sourceData.sourceData.data != nullptr)
+                   ? VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR |
-    {
+                         VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT
+                   : 0),
+          currentOwner, sourceData.dynamic, sourceData.name) {
+  if (getSize() > 0 && sourceData.sourceData.data != nullptr) {
     void *data = map();
     std::memcpy(data, sourceData.sourceData.data, sourceData.sourceData.size);
     unmap();
@@ -464,62 +428,55 @@ ShaderBuffer::ShaderBuffer(PGraphics graphics,
 
 ShaderBuffer::~ShaderBuffer() {}
 
-void ShaderBuffer::updateContents(const ShaderBufferCreateInfo &createInfo)
+void ShaderBuffer::updateContents(const ShaderBufferCreateInfo &createInfo) {
-{
+  if (createInfo.sourceData.data == nullptr) {
-    if (createInfo.sourceData.data == nullptr)
-    {
     return;
   }
   // We always want to update, as the contents could be different on the GPU
   void *data = map();
-    std::memcpy((char *)data + createInfo.sourceData.offset, createInfo.sourceData.data, createInfo.sourceData.size);
+  std::memcpy((char *)data + createInfo.sourceData.offset,
+              createInfo.sourceData.data, createInfo.sourceData.size);
   unmap();
 }
 
-void Seele::Vulkan::ShaderBuffer::rotateBuffer(uint64 size, bool preserveContents)
+void Seele::Vulkan::ShaderBuffer::rotateBuffer(uint64 size,
-{
+                                               bool preserveContents) {
   assert(dynamic);
   Vulkan::Buffer::rotateBuffer(size, preserveContents);
 }
 
-void *ShaderBuffer::mapRegion(uint64 offset, uint64 size, bool writeOnly)
+void *ShaderBuffer::mapRegion(uint64 offset, uint64 size, bool writeOnly) {
-{
   return Vulkan::Buffer::mapRegion(offset, size, writeOnly);
 }
 
 void ShaderBuffer::unmap() { Vulkan::Buffer::unmap(); }
 
-void ShaderBuffer::clear()
+void ShaderBuffer::clear() {
-{
+  vkCmdFillBuffer(graphics->getQueueCommands(owner)->getCommands()->getHandle(),
-    vkCmdFillBuffer(graphics->getQueueCommands(owner)->getCommands()->getHandle(), Vulkan::Buffer::getHandle(), 0, VK_WHOLE_SIZE, 0);
+                  Vulkan::Buffer::getHandle(), 0, VK_WHOLE_SIZE, 0);
 }
 
-void ShaderBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner)
+void ShaderBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner) {
-{
   Gfx::QueueOwnedResource::transferOwnership(newOwner);
 }
 
-void ShaderBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
+void ShaderBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner) {
-{
   Vulkan::Buffer::executeOwnershipBarrier(newOwner);
 }
 
 void ShaderBuffer::executePipelineBarrier(VkAccessFlags srcAccess,
                                           VkPipelineStageFlags srcStage,
                                           VkAccessFlags dstAccess,
-                                          VkPipelineStageFlags dstStage)
+                                          VkPipelineStageFlags dstStage) {
-{
   Vulkan::Buffer::executePipelineBarrier(srcAccess, srcStage, dstAccess,
                                          dstStage);
 }
 
-VkAccessFlags ShaderBuffer::getSourceAccessMask()
+VkAccessFlags ShaderBuffer::getSourceAccessMask() {
-{
   return VK_ACCESS_MEMORY_WRITE_BIT;
 }
 
-VkAccessFlags ShaderBuffer::getDestAccessMask()
+VkAccessFlags ShaderBuffer::getDestAccessMask() {
-{
   return VK_ACCESS_MEMORY_READ_BIT;
 }
 
@@ -529,10 +486,8 @@ VertexBuffer::VertexBuffer(PGraphics graphics,
                         sourceData.vertexSize, sourceData.sourceData.owner),
       Vulkan::Buffer(graphics, sourceData.sourceData.size,
                      VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, currentOwner, false,
-                     sourceData.name)
+                     sourceData.name) {
-{
+  if (sourceData.sourceData.data != nullptr) {
-    if (sourceData.sourceData.data != nullptr)
-    {
     void *data = map();
     std::memcpy(data, sourceData.sourceData.data, sourceData.sourceData.size);
     unmap();
@@ -541,47 +496,40 @@ VertexBuffer::VertexBuffer(PGraphics graphics,
 
 VertexBuffer::~VertexBuffer() {}
 
-void VertexBuffer::updateRegion(DataSource update)
+void VertexBuffer::updateRegion(DataSource update) {
-{
   void *data = mapRegion(update.offset, update.size);
   std::memcpy(data, update.data, update.size);
   unmap();
 }
 
-void VertexBuffer::download(Array<uint8> &buffer)
+void VertexBuffer::download(Array<uint8> &buffer) {
-{
   void *data = map(false);
   buffer.resize(getSize());
   std::memcpy(buffer.data(), data, getSize());
   unmap();
 }
 
-void VertexBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner)
+void VertexBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner) {
-{
   Gfx::QueueOwnedResource::transferOwnership(newOwner);
 }
 
-void VertexBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
+void VertexBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner) {
-{
   Vulkan::Buffer::executeOwnershipBarrier(newOwner);
 }
 
 void VertexBuffer::executePipelineBarrier(VkAccessFlags srcAccess,
                                           VkPipelineStageFlags srcStage,
                                           VkAccessFlags dstAccess,
-                                          VkPipelineStageFlags dstStage)
+                                          VkPipelineStageFlags dstStage) {
-{
   Vulkan::Buffer::executePipelineBarrier(srcAccess, srcStage, dstAccess,
                                          dstStage);
 }
 
-VkAccessFlags VertexBuffer::getSourceAccessMask()
+VkAccessFlags VertexBuffer::getSourceAccessMask() {
-{
   return VK_ACCESS_MEMORY_WRITE_BIT;
 }
 
-VkAccessFlags VertexBuffer::getDestAccessMask()
+VkAccessFlags VertexBuffer::getDestAccessMask() {
-{
   return VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
 }
 
@@ -589,12 +537,13 @@ IndexBuffer::IndexBuffer(PGraphics graphics,
                          const IndexBufferCreateInfo &sourceData)
     : Gfx::IndexBuffer(graphics->getFamilyMapping(), sourceData.sourceData.size,
                        sourceData.indexType, sourceData.sourceData.owner),
-      Vulkan::Buffer(graphics, sourceData.sourceData.size,
+      Vulkan::Buffer(
-                     VK_BUFFER_USAGE_INDEX_BUFFER_BIT, currentOwner, false,
+          graphics, sourceData.sourceData.size,
-                     sourceData.name)
+          VK_BUFFER_USAGE_INDEX_BUFFER_BIT |
-{
+              VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR |
-    if (sourceData.sourceData.data != nullptr)
+              VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
-    {
+          currentOwner, false, sourceData.name) {
+  if (sourceData.sourceData.data != nullptr) {
     void *data = map();
     std::memcpy(data, sourceData.sourceData.data, sourceData.sourceData.size);
     unmap();
@@ -603,39 +552,33 @@ IndexBuffer::IndexBuffer(PGraphics graphics,
 
 IndexBuffer::~IndexBuffer() {}
 
-void IndexBuffer::download(Array<uint8> &buffer)
+void IndexBuffer::download(Array<uint8> &buffer) {
-{
   void *data = map(false);
   buffer.resize(getSize());
   std::memcpy(buffer.data(), data, getSize());
   unmap();
 }
 
-void IndexBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner)
+void IndexBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner) {
-{
   Gfx::QueueOwnedResource::transferOwnership(newOwner);
 }
 
-void IndexBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
+void IndexBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner) {
-{
   Vulkan::Buffer::executeOwnershipBarrier(newOwner);
 }
 
 void IndexBuffer::executePipelineBarrier(VkAccessFlags srcAccess,
                                          VkPipelineStageFlags srcStage,
                                          VkAccessFlags dstAccess,
-                                         VkPipelineStageFlags dstStage)
+                                         VkPipelineStageFlags dstStage) {
-{
   Vulkan::Buffer::executePipelineBarrier(srcAccess, srcStage, dstAccess,
                                          dstStage);
 }
 
-VkAccessFlags IndexBuffer::getSourceAccessMask()
+VkAccessFlags IndexBuffer::getSourceAccessMask() {
-{
   return VK_ACCESS_MEMORY_WRITE_BIT;
 }
 
-VkAccessFlags IndexBuffer::getDestAccessMask()
+VkAccessFlags IndexBuffer::getDestAccessMask() {
-{
   return VK_ACCESS_INDEX_READ_BIT;
 }

src/Engine/Graphics/Vulkan/Buffer.h

@@ -16,6 +16,7 @@ public:
   VmaAllocationInfo info = VmaAllocationInfo();
   VkMemoryPropertyFlags properties = 0;
   uint64 size = 0;
+  VkDeviceAddress deviceAddress;
 };
 DEFINE_REF(BufferAllocation);
 class Buffer {
@@ -24,6 +25,9 @@ public:
          Gfx::QueueType &queueType, bool dynamic, std::string name);
   virtual ~Buffer();
   VkBuffer getHandle() const { return buffers[currentBuffer]->buffer; }
+  VkDeviceAddress getDeviceAddress() const {
+    return buffers[currentBuffer]->deviceAddress;
+  }
   PBufferAllocation getAlloc() const { return buffers[currentBuffer]; }
   uint64 getSize() const { return buffers[currentBuffer]->size; }
   void *map(bool writeOnly = true);
@@ -130,7 +134,8 @@ public:
   virtual ~ShaderBuffer();
   virtual void
   updateContents(const ShaderBufferCreateInfo &createInfo) override;
-  virtual void rotateBuffer(uint64 size, bool preserveContents = false) override;
+  virtual void rotateBuffer(uint64 size,
+                            bool preserveContents = false) override;
   virtual void *mapRegion(uint64 offset, uint64 size, bool writeOnly) override;
   virtual void unmap() override;
 

src/Engine/Graphics/Vulkan/CMakeLists.txt

@@ -22,6 +22,8 @@ target_sources(Engine
 		PipelineCache.cpp
 		Queue.h
 		Queue.cpp
+        RayTracing.h
+        RayTracing.cpp
 		RenderPass.h
 		RenderPass.cpp
 		Resources.h
@@ -47,6 +49,7 @@ target_sources(Engine
 			Pipeline.h
 			PipelineCache.h
 			Queue.h
+            RayTracing.h
 			RenderPass.h
 			Resources.h
 			Shader.h

src/Engine/Graphics/Vulkan/Descriptor.cpp

@@ -3,6 +3,7 @@
 #include "Command.h"
 #include "Graphics.h"
 #include "Texture.h"
+#include "CRC.h"
 
 using namespace Seele;
 using namespace Seele::Vulkan;

src/Engine/Graphics/Vulkan/Framebuffer.cpp

@@ -3,6 +3,7 @@
 #include "RenderPass.h"
 #include "Graphics.h"
 #include "Texture.h"
+#include "CRC.h"
 
 using namespace Seele;
 using namespace Seele::Vulkan;

src/Engine/Graphics/Vulkan/Graphics.cpp

@@ -3,6 +3,8 @@
 #include "Allocator.h"
 #include "Buffer.h"
 #include "Graphics/Enums.h"
+#include "Graphics/Graphics.h"
+#include "Graphics/Initializer.h"
 #include "PipelineCache.h"
 #include "Command.h"
 #include "Descriptor.h"
@@ -10,6 +12,7 @@
 #include "RenderPass.h"
 #include "Framebuffer.h"
 #include "Shader.h"
+#include "RayTracing.h"
 #include <GLFW/glfw3.h>
 #include <cstring>
 #include <vulkan/vulkan_core.h>
@@ -291,14 +294,24 @@ void Graphics::resolveTexture(Gfx::PTexture source, Gfx::PTexture destination)
     vkCmdResolveImage(getGraphicsCommands()->getCommands()->getHandle(), sourceTex->getImage(), cast(sourceTex->getLayout()), destinationTex->getImage(), cast(destinationTex->getLayout()), 1, &resolve);
 }
 
-void Graphics::vkCmdDrawMeshTasksEXT(VkCommandBuffer handle, uint32 groupX, uint32 groupY, uint32 groupZ)
+Gfx::OBottomLevelAS Graphics::createBottomLevelAccelerationStructure(const Gfx::BottomLevelASCreateInfo& createInfo)
 {
-    cmdDrawMeshTasks(handle, groupX, groupY, groupZ);
+    return new BottomLevelAS(this, createInfo);
 }
 
-void Graphics::vkCmdDrawMeshTasksIndirectEXT(VkCommandBuffer handle, VkBuffer buffer, uint64 offset, uint32 drawCount, uint32 stride)
+Gfx::OTopLevelAS Graphics::createTopLevelAccelerationStructure(const Gfx::TopLevelASCreateInfo& createInfo)
 {
-    cmdDrawMeshTasksIndirect(handle, buffer, offset, drawCount, stride);
+    return new TopLevelAS(this, createInfo);
+}
+
+void Graphics::vkCmdDrawMeshTasksEXT(VkCommandBuffer cmd, uint32 groupX, uint32 groupY, uint32 groupZ)
+{
+    cmdDrawMeshTasks(cmd, groupX, groupY, groupZ);
+}
+
+void Graphics::vkCmdDrawMeshTasksIndirectEXT(VkCommandBuffer cmd, VkBuffer buffer, uint64 offset, uint32 drawCount, uint32 stride)
+{
+    cmdDrawMeshTasksIndirect(cmd, buffer, offset, drawCount, stride);
 }
 
 void Graphics::vkSetDebugUtilsObjectNameEXT(VkDebugUtilsObjectNameInfoEXT* info)
@@ -395,6 +408,7 @@ void Graphics::initInstance(GraphicsInitializer initInfo)
     assert(glfwVulkanSupported());
     VkApplicationInfo appInfo = {
         .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
+        .pNext = nullptr,
         .pApplicationName = initInfo.applicationName,
         .applicationVersion = VK_MAKE_VERSION(0, 0, 1),
         .pEngineName = initInfo.engineName,
@@ -415,6 +429,7 @@ void Graphics::initInstance(GraphicsInitializer initInfo)
 #endif
     VkInstanceCreateInfo info = {
         .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
+        .pNext = nullptr,
 #if __APPLE__
         .flags = VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR,
 #endif
@@ -562,6 +577,7 @@ void Graphics::createDevice(GraphicsInitializer initializer)
                 .flags = 0,
                 .queueFamilyIndex = familyIndex,
                 .queueCount = numQueuesForFamily,
+                .pQueuePriorities = nullptr,
             };
             numPriorities += numQueuesForFamily;
             queueInfos.add(info);

src/Engine/Graphics/Vulkan/Graphics.h

@@ -1,5 +1,4 @@
 #pragma once
-#include "Enums.h"
 #include "Graphics/Graphics.h"
 #include <vk_mem_alloc.h>
 
@@ -70,6 +69,10 @@ public:
 
     virtual void resolveTexture(Gfx::PTexture source, Gfx::PTexture destination) override;
 
+    // Ray Tracing
+    virtual Gfx::OBottomLevelAS createBottomLevelAccelerationStructure(const Gfx::BottomLevelASCreateInfo& createInfo) override;
+    virtual Gfx::OTopLevelAS createTopLevelAccelerationStructure(const Gfx::TopLevelASCreateInfo& createInfo) override;
+
     void vkCmdDrawMeshTasksEXT(VkCommandBuffer handle, uint32 groupX, uint32 groupY, uint32 groupZ);
     void vkCmdDrawMeshTasksIndirectEXT(VkCommandBuffer handle, VkBuffer buffer, uint64 offset, uint32 drawCount, uint32 stride);
     void vkSetDebugUtilsObjectNameEXT(VkDebugUtilsObjectNameInfoEXT* info);

src/Engine/Graphics/Vulkan/Queue.cpp

@@ -2,6 +2,7 @@
 #include "Graphics.h"
 #include "Allocator.h"
 #include "Command.h"
+#include "Enums.h"
 
 using namespace Seele;
 using namespace Seele::Vulkan;

src/Engine/Graphics/Vulkan/RayTracing.cpp

@@ -0,0 +1,67 @@
+#include "RayTracing.h"
+#include "Buffer.h"
+#include "Graphics/Initializer.h"
+#include <vulkan/vulkan_core.h>
+
+using namespace Seele::Vulkan;
+
+BottomLevelAS::BottomLevelAS(PGraphics graphics, const Gfx::BottomLevelASCreateInfo& createInfo)
+{
+    VkDeviceOrHostAddressConstKHR vertexDataDeviceAddress = {
+        .deviceAddress = createInfo.positionBuffer.cast<Buffer>()->getDeviceAddress() + createInfo.verticesOffset,
+    };
+    VkDeviceOrHostAddressConstKHR indexDataDeviceAddress = {
+        .deviceAddress = createInfo.indexBuffer.cast<Buffer>()->getDeviceAddress() + createInfo.indicesOffset,
+    };
+    VkAccelerationStructureGeometryKHR accelerationStructureGeometry = {
+        .sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR,
+        .pNext = nullptr,
+        .geometryType = VK_GEOMETRY_TYPE_TRIANGLES_KHR,
+        .geometry = {.triangles = {
+            .sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR,
+            .pNext = nullptr,
+            .vertexFormat = VK_FORMAT_R32G32B32_SFLOAT,
+            .vertexData = vertexDataDeviceAddress,
+            .vertexStride = sizeof(Vector),
+            .maxVertex = createInfo.positionBuffer->getNumElements(),
+            .indexType = VK_INDEX_TYPE_UINT32,
+            .indexData = indexDataDeviceAddress,
+        }},
+        .flags = VK_GEOMETRY_OPAQUE_BIT_KHR,
+    };
+    
+    VkAccelerationStructureBuildRangeInfoKHR buildRangeInfo = {
+        .primitiveCount = createInfo.meshData.numIndices / 3,
+        .primitiveOffset = 0,
+        .firstVertex = 0,
+        .transformOffset = 0
+    };
+
+    VkAccelerationStructureBuildGeometryInfoKHR buildGeometry = {
+        .sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR,
+        .pNext = nullptr,
+        .type = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR,
+        .flags = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR,
+    };
+
+    VkAccelerationStructureCreateInfoKHR info = {
+        .sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR,
+        .pNext = nullptr,
+        .createFlags = 0,
+    };
+}
+
+BottomLevelAS::~BottomLevelAS()
+{
+
+}
+
+TopLevelAS::TopLevelAS(PGraphics graphics, const Gfx::TopLevelASCreateInfo& createInfo)
+{
+
+}
+
+TopLevelAS::~TopLevelAS()
+{
+
+}

src/Engine/Graphics/Vulkan/RayTracing.h

@@ -0,0 +1,32 @@
+#pragma once
+#include "Graphics/Initializer.h"
+#include "Graphics.h"
+#include "Graphics/RayTracing.h"
+#include <vulkan/vulkan_core.h>
+
+namespace Seele
+{
+namespace Vulkan
+{
+class BottomLevelAS : public Gfx::BottomLevelAS
+{
+public:
+    BottomLevelAS(PGraphics graphics, const Gfx::BottomLevelASCreateInfo& createInfo);
+    ~BottomLevelAS();
+private:
+    PGraphics graphics;
+    VkAccelerationStructureKHR handle;
+};
+DEFINE_REF(BottomLevelAS)
+class TopLevelAS : public Gfx::TopLevelAS
+{
+public:
+    TopLevelAS(PGraphics graphics, const Gfx::TopLevelASCreateInfo& createInfo);
+    ~TopLevelAS();
+private:
+    PGraphics graphics;
+    VkAccelerationStructureKHR handle;
+};
+DEFINE_REF(TopLevelAS)
+}
+}

src/Engine/Graphics/Vulkan/RenderPass.cpp

@@ -4,6 +4,7 @@
 #include "Texture.h"
 #include "Resources.h"
 #include "Command.h"
+#include "CRC.h"
 
 using namespace Seele;
 using namespace Seele::Vulkan;

src/Engine/Graphics/Vulkan/Texture.cpp

@@ -1,5 +1,6 @@
 #include "Texture.h"
 #include "Command.h"
+#include "Enums.h"
 #include <math.h>
 
 using namespace Seele;

src/Engine/Graphics/Window.h

@@ -1,6 +1,7 @@
 #pragma once
 #include "Initializer.h"
 #include "Texture.h"
+#include <functional>
 
 namespace Seele
 {