Implemented ray tracing

.gitmodules

@@ -1,6 +1,6 @@
-[submodule "vendor/PyroRHI"]
-	path = vendor/PyroRHI
-	url = https://github.com/PyroshockStudios/PyroRHI.git
 [submodule "vendor/PyroPlatform"]
 	path = vendor/PyroPlatform
 	url = https://github.com/PyroshockStudios/PyroPlatform.git
+[submodule "vendor/PyroRHI"]
+	path = vendor/PyroRHI
+	url = https://github.com/PyroshockStudios/PyroRHI.git

ShockGraph/Resources.cpp

@@ -20,8 +20,6 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-#pragma once
-
 #include "Resources.hpp"
 #include "TaskResourceManager.hpp"
 #include <PyroCommon/Core.hpp>
@@ -120,7 +118,7 @@ namespace PyroshockStudios {
             mShader.program->RemoveReference(this);
             Device()->Destroy(mPipeline);
         }
-         void TaskComputePipeline_::Recreate() {
+        void TaskComputePipeline_::Recreate() {
             ShaderInfo copyShader;
             copyShader.program = mShader.program->Program().bytecode;
             copyShader.specializationConstants = mShader.specializationConstants;
@@ -132,9 +130,15 @@ namespace PyroshockStudios {
         }
         SHOCKGRAPH_API TaskBuffer_::~TaskBuffer_() {
             Owner()->ReleaseBufferResource(this);
-            Device()->Destroy(mBuffer);
-            for (auto& buffer : mInFlightBuffers) {
-                Device()->Destroy(buffer);
+            if (this->mInfo.mode == TaskBufferMode::HostDynamic || this->mInfo.mode == TaskBufferMode::Readback) {
+                // Do not destroy mBuffer as it is the same stuff as in mInFlightBuffers!
+            } else {
+                Device()->Destroy(mBuffer);
+            }
+            if (this->mInfo.mode != TaskBufferMode::Host) {  // Do not destroy these as they are copies of mBuffer!
+                for (auto& buffer : mInFlightBuffers) {
+                    Device()->Destroy(buffer);
+                }
             }
         }
         SHOCKGRAPH_API u8* TaskBuffer_::MappedMemory() {
@@ -166,5 +170,20 @@ namespace PyroshockStudios {
         SHOCKGRAPH_API TaskSwapChain_::~TaskSwapChain_() {
             Device()->Destroy(mSwapChain);
         }
+        SHOCKGRAPH_API TaskBlas_::TaskBlas_(TaskResourceManager* owner, const TaskBlasInfo& info, BlasId&& blas)
+            : TaskResource_(owner), mBlas(blas), mInfo(info) {
+        }
+        SHOCKGRAPH_API TaskBlas_::~TaskBlas_() {
+            Device()->Destroy(mBlas);
+        }
+        PYRO_NODISCARD BlasAddress TaskBlas_::InstanceAddress() {
+            return Device()->BlasInstanceAddress(mBlas);
+        }
+        SHOCKGRAPH_API TaskTlas_::TaskTlas_(TaskResourceManager* owner, const TaskTlasInfo& info, TlasId&& tlas)
+            : TaskResource_(owner), mTlas(tlas), mInfo(info) {
+        }
+        SHOCKGRAPH_API TaskTlas_::~TaskTlas_() {
+            Device()->Destroy(mTlas);
+        }
     } // namespace Renderer
 } // namespace PyroshockStudios

ShockGraph/Resources.hpp

@@ -27,6 +27,7 @@
 #ifdef SHOCKGRAPH_USE_PYRO_PLATFORM
 #include <PyroPlatform/Forward.hpp>
 #endif
+#include <PyroRHI/Api/AccelerationStructure.hpp>
 #include <PyroRHI/Api/Forward.hpp>
 #include <PyroRHI/Api/GPUResource.hpp>
 #include <PyroRHI/Api/Pipeline.hpp>
@@ -183,15 +184,18 @@ namespace PyroshockStudios {
 
         using TaskComputePipelineRef = TaskComputePipeline&;
 
+        enum struct TaskBufferMode : u32 {
+            Default = 0,     ///< Stored on Device, not accessible from CPU.
+            Host = 1,        ///< Stored on Host, with CPU read/write access, but GPU read-only. Not to be confused with HostDynamic, as this does not allow for safe per-frame write access.
+            Dynamic = 2,     ///< Stored on Device, with CPU write access, but GPU read-only. Optimised for fast GPU access, but writes may be slower.
+            HostDynamic = 3, ///< Stored on Host memory, with CPU read/write access, but GPU read-only. Optimised for fast CPU access, but reads may be slower.
+            Readback = 4,    ///< Stored on Host memory, with CPU read access, but GPU write-only.
+        };
+
         struct TaskBufferInfo {
             usize size = 0;
             BufferUsageFlags usage = {};
-            // Buffer is stored on CPU visible memory
-            bool bCpuVisible = false;
-            // Buffer can be read from CPU
-            bool bReadback = false;
-            // Buffer is reliably accessible between CPU and GPU
-            bool bDynamic = false;
+            TaskBufferMode mode = TaskBufferMode::Default;
             eastl::string name = {};
         };
         struct TaskBuffer_ final : public TaskResource_ {
@@ -335,5 +339,50 @@ namespace PyroshockStudios {
         };
         using TaskSwapChain = SharedRef<TaskSwapChain_>;
         using TaskSwapChainRef = TaskSwapChain&;
+
+        struct TaskBlasInfo {
+            usize size = 0;
+            eastl::string name = {};
+        };
+        struct TaskBlas_ final : public TaskResource_ {
+            SHOCKGRAPH_API TaskBlas_(TaskResourceManager* owner, const TaskBlasInfo& info, BlasId&& blas);
+            SHOCKGRAPH_API ~TaskBlas_() override;
+            PYRO_NODISCARD PYRO_FORCEINLINE BlasId Internal() {
+                return mBlas;
+            }
+            PYRO_NODISCARD PYRO_FORCEINLINE const TaskBlasInfo& Info() const { return mInfo; }
+            PYRO_NODISCARD BlasAddress InstanceAddress();
+
+        private:
+            BlasId mBlas = PYRO_NULL_BLAS;
+            TaskBlasInfo mInfo;
+
+            friend class TaskResourceManager;
+            friend class TaskGraph;
+        };
+        using TaskBlas = SharedRef<TaskBlas_>;
+        using TaskBlasRef = TaskBlas&;
+
+        struct TaskTlasInfo {
+            usize size = 0;
+            eastl::string name = {};
+        };
+        struct TaskTlas_ final : public TaskResource_ {
+            SHOCKGRAPH_API TaskTlas_(TaskResourceManager* owner, const TaskTlasInfo& info, TlasId&& tlas);
+            SHOCKGRAPH_API ~TaskTlas_() override;
+            PYRO_NODISCARD PYRO_FORCEINLINE TlasId Internal() {
+                return mTlas;
+            }
+            PYRO_NODISCARD PYRO_FORCEINLINE const TaskTlasInfo& Info() const { return mInfo; }
+
+        private:
+            TlasId mTlas = PYRO_NULL_TLAS;
+            TaskTlasInfo mInfo;
+
+            friend class TaskResourceManager;
+            friend class TaskGraph;
+        };
+        using TaskTlas = SharedRef<TaskTlas_>;
+        using TaskTlasRef = TaskTlas&;
     } // namespace Renderer
 } // namespace PyroshockStudios

ShockGraph/Task.cpp

@@ -63,6 +63,9 @@ namespace PyroshockStudios {
         SHOCKGRAPH_API void GenericTask::UseImage(const TaskImageDependencyInfo& info) {
             mSetupData.imageDepends.emplace_back(info);
         }
+        SHOCKGRAPH_API void GenericTask::UseAccelerationStructure(const TaskAccelerationStructureDependencyInfo& info) {
+            mSetupData.accelerationStructureDepends.emplace_back(info);
+        }
         SHOCKGRAPH_API void CustomTask::ExecuteTask(TaskCommandList& commandList) {
             ExecuteTask(commandList.Internal());
         }

ShockGraph/Task.hpp

@@ -56,6 +56,13 @@ namespace PyroshockStudios {
             PYRO_NODISCARD PYRO_FORCEINLINE bool operator==(const TaskImageDependencyInfo&) const = default;
             PYRO_NODISCARD PYRO_FORCEINLINE bool operator!=(const TaskImageDependencyInfo&) const = default;
         };
+        struct TaskAccelerationStructureDependencyInfo {
+            eastl::variant<TaskBlas, TaskTlas> accelerationStructure;
+            TaskAccessType access;
+
+            PYRO_NODISCARD PYRO_FORCEINLINE bool operator==(const TaskAccelerationStructureDependencyInfo&) const = default;
+            PYRO_NODISCARD PYRO_FORCEINLINE bool operator!=(const TaskAccelerationStructureDependencyInfo&) const = default;
+        };
 
         struct TaskInfo {
             eastl::string name = {};
@@ -80,6 +87,7 @@ namespace PyroshockStudios {
 
             SHOCKGRAPH_API void UseBuffer(const TaskBufferDependencyInfo& info);
             SHOCKGRAPH_API void UseImage(const TaskImageDependencyInfo& info);
+            SHOCKGRAPH_API void UseAccelerationStructure(const TaskAccelerationStructureDependencyInfo& info);
 
             PYRO_NODISCARD PYRO_FORCEINLINE const TaskInfo& Info() const {
                 return mTaskInfo;
@@ -89,6 +97,7 @@ namespace PyroshockStudios {
             struct GenericSetup {
                 eastl::vector<TaskBufferDependencyInfo> bufferDepends;
                 eastl::vector<TaskImageDependencyInfo> imageDepends;
+                eastl::vector<TaskAccelerationStructureDependencyInfo> accelerationStructureDepends;
             };
 
             GenericSetup mSetupData = {};

ShockGraph/TaskCommandList.hpp

@@ -24,6 +24,7 @@
 
 #include "Resources.hpp"
 #include <PyroRHI/Api/ICommandBuffer.hpp>
+#include <PyroRHI/Api/IDevice.hpp>
 
 namespace PyroshockStudios {
     inline namespace Renderer {
@@ -101,6 +102,29 @@ namespace PyroshockStudios {
             usize indirectBufferOffset = {};
         };
 
+        struct TaskBlasBuildInfo {
+            AccelerationStructureCreateFlags flags = AccelerationStructureCreateFlagBits::NONE;
+            bool bUpdate = false;
+            TaskBlas srcBlas = {};
+            TaskBlas dstBlas = {};
+            eastl::variant<eastl::span<const BlasTriangleGeometryInfo>, eastl::span<const BlasAabbGeometryInfo>> geometries = {};
+            Buffer scratchBuffer = PYRO_NULL_BUFFER;
+        };
+
+        struct TaskTlasBuildInfo {
+            AccelerationStructureCreateFlags flags = AccelerationStructureCreateFlagBits::NONE;
+            bool update = false;
+            TaskTlas srcTlas = {};
+            TaskTlas dstTlas = {};
+            TlasInstanceInfo instances = {};
+            Buffer scratchBuffer = PYRO_NULL_BUFFER;
+        };
+
+        struct TaskBuildAccelerationStructuresInfo {
+            eastl::span<const TaskTlasBuildInfo> tlasBuildInfos = {};
+            eastl::span<const TaskBlasBuildInfo> blasBuildInfos = {};
+        };
+
         class TaskCommandList : DeleteCopy, DeleteMove {
         public:
             PYRO_FORCEINLINE void CopyBuffer(const TaskCopyBufferInfo& info) {
@@ -217,6 +241,40 @@ namespace PyroshockStudios {
                 });
             }
 
+            PYRO_FORCEINLINE void BuildAccelerationStructures(const TaskBuildAccelerationStructuresInfo& info) {
+                eastl::vector<TlasBuildInfo> tlasBuildInfos = {};
+                eastl::vector<BlasBuildInfo> blasBuildInfos = {};
+
+                tlasBuildInfos.reserve(info.tlasBuildInfos.size());
+                for (const auto& t : info.tlasBuildInfos) {
+                    TlasBuildInfo out = {};
+                    out.flags = t.flags;
+                    out.update = t.update;
+                    out.srcTlas = t.srcTlas ? t.srcTlas->Internal() : PYRO_NULL_TLAS;
+                    out.dstTlas = t.dstTlas ? t.dstTlas->Internal() : PYRO_NULL_TLAS;
+                    out.instances = t.instances;
+                    out.scratchBuffer = t.scratchBuffer;
+                    tlasBuildInfos.push_back(out);
+                }
+
+                blasBuildInfos.reserve(info.blasBuildInfos.size());
+                for (const auto& b : info.blasBuildInfos) {
+                    BlasBuildInfo out = {};
+                    out.flags = b.flags;
+                    out.bUpdate = b.bUpdate;
+                    out.srcBlas = b.srcBlas ? b.srcBlas->Internal() : PYRO_NULL_BLAS;
+                    out.dstBlas = b.dstBlas ? b.dstBlas->Internal() : PYRO_NULL_BLAS;
+                    out.geometries = b.geometries;
+                    out.scratchBuffer = b.scratchBuffer;
+                    blasBuildInfos.push_back(out);
+                }
+
+                mCommandBuffer->BuildAccelerationStructures({
+                    .tlasBuildInfos = tlasBuildInfos,
+                    .blasBuildInfos = blasBuildInfos,
+                });
+            }
+
             PYRO_FORCEINLINE ICommandBuffer* Internal() {
                 return mCommandBuffer;
             }
@@ -227,7 +285,7 @@ namespace PyroshockStudios {
                 if (!pipeline->mbDirty)
                     return;
                 pipeline->mbDirty = false;
-                mCommandBuffer->DestroyDeferred(pipeline->mPipeline);
+                mOwningDevice->Destroy(pipeline->mPipeline, true);
                 pipeline->Recreate();
             }