renaming and small changes to classes

OSMaxwell · OSMaxwell · commit 991432308b8a · 2023-08-02T18:52:57.000+02:00
diff --git a/Intern/RayCore/src/Tracer/Tracer.cpp b/Intern/RayCore/src/Tracer/Tracer.cpp
@@ -56,26 +56,13 @@ Rays Tracer::trace(const Beamline& b) {
         {
             RAYX_PROFILE_SCOPE_STDOUT("Tracing");
             rawBatchRays = traceRaw(cfg);
-            //assert(rawBatchRays.size() == cfg.m_maxSnapshots * batch_size);
-            for (const auto& _events : rawBatchRays) {  // Sanity Check
+            for ([[maybe_unused]] const auto& _events : rawBatchRays) {  // Sanity Check
                 assert(batch_size == _events.size());
             }
         }
 
         {
             RAYX_PROFILE_SCOPE_STDOUT("Snapshotting");
-            // for (uint i = 0; i < batch_size; i++) {
-            //     Snapshots hist;
-            //     hist.reserve(maxSnapshots);
-            //     for (uint j = 0; j < maxSnapshots; j++) {
-            //         uint idx = i * maxSnapshots + j;
-            //         Ray r = rawBatchRays[idx];
-            //         if (r.m_weight != W_UNINIT) {
-            //             hist.push_back(r);
-            //         }
-            //     }
-            //     result.push_back(hist);
-            // }
             auto _maxSnapshot = rawBatchRays.size();
             result.reserve(batch_size);
 
diff --git a/Intern/RayCore/src/Tracer/VulkanTracer.cpp b/Intern/RayCore/src/Tracer/VulkanTracer.cpp
@@ -56,7 +56,7 @@ Rays VulkanTracer::traceRaw(const TraceRawConfig& cfg) {
     uint64_t workerCounterNum = MAX_UINT64 / uint64_t(cfg.m_numRays);
     for (auto i = 0; i < cfg.m_numRays; i++) {
         rayMeta.push_back({.ctr = ((uint64_t)cfg.m_rayIdStart + (uint64_t)i) * workerCounterNum + uint64_t(cfg.m_randomSeed * MAX_UINT64),
-                           .nextElementId = -1,    // Intersection element unknown / does not exist
+                           .nextElementId = -1,   // Intersection element unknown / does not exist
                            .finalized = false});  // Not started
     }
 
@@ -95,8 +95,8 @@ Rays VulkanTracer::traceRaw(const TraceRawConfig& cfg) {
         std::string passName2 = "OldFullTracingPass";
 
         // Should return only compute now. Important when mixing different shader types to chose right stage flag!
-        auto shaderFlag = m_engine.getComputePass(passName2)->getShaderStage(0).getShaderStageFlagBits();
-        RAYX_D_LOG << "Allocating buffers...";
+        auto shaderFlag = m_engine.getComputePass(passName0)->getShaderStage(0).getShaderStageFlagBits();
+
         // Bindings (Vulkan Buffer <- Descriptors (sets))
         // PS: You can also call addDescriptorSetPerPassBindings once!
         bufferHandler
@@ -106,7 +106,8 @@ Rays VulkanTracer::traceRaw(const TraceRawConfig& cfg) {
             .addDescriptorSetPerPassBinding(passName2, 0, shaderFlag);
 
         bufferHandler
-            ->createBuffer({"output-buffer", VKBUFFER_OUT, numberOfRays * sizeof(Ray) * (size_t)cfg.m_maxSnapshots})  // Beamline quadric info
+            ->createBuffer(
+                {"output-buffer", VKBUFFER_OUT, numberOfRays * sizeof(Ray) * (size_t)cfg.m_maxSnapshots})  // OUTOUT DATA only for main.comp
             .addDescriptorSetPerPassBinding(passName2, 1, shaderFlag);
 
         bufferHandler
@@ -117,7 +118,7 @@ Rays VulkanTracer::traceRaw(const TraceRawConfig& cfg) {
 
         bufferHandler
             ->createBuffer<double>({"quadric-buffer", VKBUFFER_IN}, beamlineData)  // Beamline quadric info
-            .addDescriptorSetPerPassBinding(passName0, 2, shaderFlag)              // TODO : Wrong binding number
+            .addDescriptorSetPerPassBinding(passName0, 2, shaderFlag)
             .addDescriptorSetPerPassBinding(passName1, 2, shaderFlag)
             .addDescriptorSetPerPassBinding(passName2, 3, shaderFlag);
 
@@ -146,27 +147,26 @@ Rays VulkanTracer::traceRaw(const TraceRawConfig& cfg) {
             .addDescriptorSetPerPassBinding(passName1, 6, shaderFlag)
             .addDescriptorSetPerPassBinding(passName2, 7, shaderFlag);
 #endif
-
     }
-
-    // FIXME(OS): Weird pushConstant update
+    // FIXME: Push Constants still support only one shader code! (If two shaders require two structs then Tracer needs to also change to carry a
+    // vector of structs or similar)
     m_engine.getComputePass("singleTracePass")->updatePushConstant(0, m_engine.m_pushConstants.pushConstPtr, m_engine.m_pushConstants.size);
     m_engine.getComputePass("finalCollisionPass")->updatePushConstant(0, m_engine.m_pushConstants.pushConstPtr, m_engine.m_pushConstants.size);
     m_engine.getComputePass("OldFullTracingPass")->updatePushConstant(0, m_engine.m_pushConstants.pushConstPtr, m_engine.m_pushConstants.size);
 
     // Create Pipeline layouts and Descriptor Layouts. Everytime buffer formation (not data) changes, we need to prepare again
     m_engine.prepareComputePipelinePasses();
+
     // Run multiple bounces
-    auto out = m_engine.run({.m_numberOfInvocations = numberOfRays, .maxBounces = (int)cfg.m_elements.size()});
+    auto out = m_engine.runTraceComputeTask({.m_numberOfInvocations = numberOfRays, .maxBounces = (int)cfg.m_elements.size()});
 
 #ifdef RAYX_DEBUG_MODE
     m_debugBufList = bufferHandler->readBuffer<debugBuffer_t>("debug-buffer", true);
 #endif
 
     m_engine.cleanup();
 
-    // Vector of vectors
-
+    // 2D Data
     return out;
 }
 
diff --git a/Intern/RayCore/src/VulkanEngine/Buffer/BufferHandler.cpp b/Intern/RayCore/src/VulkanEngine/Buffer/BufferHandler.cpp
@@ -157,7 +157,7 @@ VulkanBuffer* BufferHandler::getBuffer(const std::string& name) {
 /// If queue -> Wait for queue to finish before reading
 void BufferHandler::readBufferRaw(const char* bufname, char* outdata, const VkQueue& queue) {
     // if (m_state != EngineStates_t::POSTRUN) {
-    //     RAYX_ERR << "you've forgotton to .run() the VulkanEngine. Thats "
+    //     RAYX_ERR << "you've forgotton to .runTraceComputeTask() the VulkanEngine. Thats "
     //                 "mandatory before reading it's output buffers.";
     // }
     VulkanBuffer* buffer = getBuffer(bufname);
@@ -234,8 +234,9 @@ void BufferHandler::updateBuffer(const char* bufname, const std::vector<T>& vec)
     }
     if (vec && m_Buffers[std::string(bufname)]->getSize() == vec.size()) {
         writeBufferRaw(bufname, (char*)vec.data());
-    } else
+    } else {
         RAYX_WARN << "Size mismatch";
+    }
 }
 
 void BufferHandler::deleteBuffer(const char* bufname) {
diff --git a/Intern/RayCore/src/VulkanEngine/Buffer/VulkanBuffer.cpp b/Intern/RayCore/src/VulkanEngine/Buffer/VulkanBuffer.cpp
@@ -7,11 +7,14 @@ namespace RAYX {
 
 VulkanBuffer::VulkanBuffer(const VmaAllocator& vmaAllocator, VulkanBufferCreateInfo createInfo)
     : m_VmaAllocator(vmaAllocator), m_createInfo(createInfo) {
-    int bufferUsageFlags = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;  // Usually target storage buffer
+    int bufferUsageFlags;
+    // Type definition
     if (createInfo.bufferType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) {
         bufferUsageFlags = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
+    } else if (createInfo.bufferType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) {
+        bufferUsageFlags = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
     }
-
+    // Access definition
     if (createInfo.accessType == VKBUFFER_IN) {
         bufferUsageFlags |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
     } else if (createInfo.accessType == VKBUFFER_OUT) {
@@ -27,8 +30,6 @@ VulkanBuffer::VulkanBuffer(const VmaAllocator& vmaAllocator, VulkanBufferCreateI
 
 VulkanBuffer::~VulkanBuffer() { vmaDestroyBuffer(m_VmaAllocator, m_Buffer, m_Alloca); }
 
-uint32_t findMemoryType(VkPhysicalDevice& physicalDevice, uint32_t memoryTypeBits, VkMemoryPropertyFlags properties);
-
 // Creates a buffer to each given object with a given size.
 // This also allocates memory to the buffer according the requirements of the
 // Physical Device. Sharing is kept to exclusive.
@@ -82,14 +83,14 @@ VulkanBuffer& VulkanBuffer::addDescriptorSetPerPassBinding(const std::string& pa
     return *this;
 }
 
-VulkanBuffer& VulkanBuffer::addDescriptorSetPerPassBindings(const std::vector<PassBinding>& descriptorPassBindings) {
+VulkanBuffer& VulkanBuffer::addDescriptorSetPerPassBindings(const std::vector<PassBindingInfo>& descriptorPassBindings) {
     for (const auto& b : descriptorPassBindings) {
         addDescriptorSetPerPassBinding(b.passName, b.binding, b.shaderStageFlag);
     }
     return *this;
 }
 
-VkDescriptorBufferInfo VulkanBuffer::getDescriptorInfo(VkDeviceSize offset) { return VkDescriptorBufferInfo{m_Buffer, offset, m_createInfo.size}; }
+VkDescriptorBufferInfo VulkanBuffer::getVkDescriptorBufferInfo(VkDeviceSize offset) { return VkDescriptorBufferInfo{m_Buffer, offset, m_createInfo.size}; }
 
 uint32_t VulkanBuffer::getPassDescriptorBinding(std::string passName) {
     if (hasPassDescriptorBinding(passName)) {
diff --git a/Intern/RayCore/src/VulkanEngine/Buffer/VulkanBuffer.h b/Intern/RayCore/src/VulkanEngine/Buffer/VulkanBuffer.h
@@ -16,26 +16,21 @@ enum BufferAccessFlags {
     VKBUFFER_INOUT,
 };
 
-/**
- * @brief Pass to VulkanBuffer Class for buffer creation
- *
- */
 struct VulkanBufferCreateInfo {
     const char* bufName;                                              // Unique Buffer name
     BufferAccessFlags accessType;                                     // Access type to Buffer
     VkDeviceSize size = 0;                                            // Size
     VkDescriptorType bufferType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;  // What kind of buffer is it (Storage, Image, Uniform etc.)
 };
 
-struct PassBinding {
+struct PassBindingInfo {
     std::string passName;
     uint32_t binding;
     VkShaderStageFlags shaderStageFlag;
 };
 
 class BufferHandler;
 
-// class VulkanEngine;
 /**
  * @brief Vulkan Storage Buffer Class. Used for Buffer allocation, creation and update
  *
@@ -47,7 +42,7 @@ class RAYX_API VulkanBuffer {
     VulkanBuffer(const VmaAllocator&, VulkanBufferCreateInfo createInfo);
     ~VulkanBuffer();
 
-    // Move/Copy of a VulkanBuffer is not alloawed
+    // Move/Copy of a VulkanBuffer are not alloawed
     VulkanBuffer(const VulkanBuffer&) = delete;
     VulkanBuffer& operator=(const VulkanBuffer&) = delete;
 
@@ -60,16 +55,18 @@ class RAYX_API VulkanBuffer {
     void UnmapMemory();
 
     VulkanBuffer& addDescriptorSetPerPassBinding(const std::string& passName, uint32_t binding, VkShaderStageFlags shaderStageFlag);
-    VulkanBuffer& addDescriptorSetPerPassBindings(const std::vector<PassBinding>&);
-    VkDescriptorBufferInfo getDescriptorInfo(VkDeviceSize offset = 0);
+    VulkanBuffer& addDescriptorSetPerPassBindings(const std::vector<PassBindingInfo>&);
+    VkDescriptorBufferInfo getVkDescriptorBufferInfo(VkDeviceSize offset = 0);
     uint32_t getPassDescriptorBinding(std::string passName);
 
   private:
-    // VMA Version of createVkBuffer
+    /**
+     * @brief Create a Vma Buffer object (VMA version of classical Vulkan createBuffer)
+
+     */
     void createVmaBuffer(VkDeviceSize size, VkBufferUsageFlags buffer_usage, VkBuffer& buffer, VmaAllocation& allocation,
                          VmaAllocationInfo* allocation_info, VmaAllocationCreateFlags flags = VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT,
                          VmaMemoryUsage memory_usage = VMA_MEMORY_USAGE_AUTO, const std::vector<uint32_t>& queue_family_indices = {});
-
     VmaAllocator m_VmaAllocator;
     VulkanBufferCreateInfo m_createInfo;
     VmaAllocationCreateFlags m_VmaFlags;
diff --git a/Intern/RayCore/src/VulkanEngine/Run/Pipeline.cpp b/Intern/RayCore/src/VulkanEngine/Run/Pipeline.cpp
@@ -126,10 +126,10 @@ void Pass::updatePushConstant(int stage, void* data, uint32_t size) { m_pass[sta
 
 // -------------------------------------------------------------------------------------------------------
 
-ComputePass::ComputePass(VkDevice& device, const ComputePassCreateInfo_t& createInfo) : m_Device(device), m_name(std::string(createInfo.passName)) {
+ComputePass::ComputePass(VkDevice& device, const ComputePassCreateInfo_t& createInfo) : m_Device(device) {
+    m_name = std::string(createInfo.passName);
     m_stagesCount = createInfo.shaderStagesCreateInfos.size();
     m_pass.reserve(m_stagesCount);
-
     m_descriptorSets.reserve(createInfo.descriptorSetAmount);
 
     // Fill compute Pipelines
@@ -188,7 +188,10 @@ void ComputePass::updateDescriptorSets(BufferHandler* bufferHandler) {
     auto buffers = bufferHandler->getBuffers();
 
     for (auto& [name, b] : *buffers) {
-        auto descInfo = b->getDescriptorInfo();
+        if (!b->hasPassDescriptorBinding(m_name)) {
+            continue;
+        }
+        auto descInfo = b->getVkDescriptorBufferInfo();
         writer.writeBuffer(b->getPassDescriptorBinding(m_name), &descInfo);
     }
 
@@ -223,7 +226,7 @@ void ComputePass::simpleUpdateDescriptorSets(BufferHandler* bufferHandler) {
         vkUpdateDescriptorSets(m_Device, 1, &writeDescriptorSet, 0, nullptr);
     }
     // FIXME: Not working..
-    // perform the update of the descriptor set.
+    // perform the update of the descriptor set all at once
     // vkUpdateDescriptorSets(m_Device, writes.size(), writes.data(), 0, nullptr);
 }
 
diff --git a/Intern/RayCore/src/VulkanEngine/Run/Pipeline.h b/Intern/RayCore/src/VulkanEngine/Run/Pipeline.h
@@ -14,7 +14,7 @@ namespace RAYX {
 // -------------------------------------------------------------------------------------------------------
 /**
  * @brief General Vulkan Pass (A group of Pipelines)
- *
+ * Not to be used directly, look at ComputePass/GraphicsPass
  */
 class RAYX_API Pass {
   public:
@@ -64,6 +64,7 @@ class RAYX_API Pass {
 
   protected:
     uint32_t m_stagesCount;
+    std::string m_name;
     Pipelines m_pass = {};  // The pass itself (Pipelines)
     std::unique_ptr<DescriptorPool> m_globalDescriptorPool{};
 };
@@ -99,7 +100,7 @@ class RAYX_API ComputePass : public Pass {
     void prepare(std::vector<VkDescriptorSetLayoutBinding> bindings);
     void createDescriptorPool(uint32_t maxSets, uint32_t bufferCount);
 
-    const VkPipelineBindPoint& getPipelineBindPoint() const { return m_PipelineBindPoint; }
+    const VkPipelineBindPoint& getPipelineBindPoint() const  { return m_PipelineBindPoint; }
     const std::vector<VkDescriptorSet>& getDescriptorSets() const { return m_descriptorSets; }
     const std::vector<VkDescriptorSetLayout>& getDescriptorSetLayouts() const { return m_descriptorSetLayouts; }
     std::string getName() const { return m_name; }
@@ -116,14 +117,12 @@ class RAYX_API ComputePass : public Pass {
     void createDescriptorSetLayout(std::vector<VkDescriptorSetLayoutBinding>& bindings);
 
     VkDevice& m_Device;
-    std::string m_name;  // TODO(OS): Consider moving this to Pass parent class
-
     VkPipelineBindPoint m_PipelineBindPoint = VK_PIPELINE_BIND_POINT_COMPUTE;  // Always compute
 
     std::vector<VkDescriptorSetLayout> m_descriptorSetLayouts;  // TODO(OS): For now, only one [0]
     std::vector<VkDescriptorSet> m_descriptorSets;              // TODO(OS): For now, only one [0]
 
-    // TODO(OS): Add missing memory barriers
+    // TODO(OS): Add missing memory barriers, if needed
 };
 }  // namespace RAYX
 #endif
diff --git a/Intern/RayCore/src/VulkanEngine/Run/RecordBuffer.cpp b/Intern/RayCore/src/VulkanEngine/Run/RecordBuffer.cpp
@@ -164,8 +164,6 @@ void VulkanEngine::recordSecondCommand() {
     pass1->bind(*cmdBuffer1, 0);
     pass1->bindDescriptorSet(*cmdBuffer1, 0);
 
-    // auto traceCommand = [](VkCOmmandBuffer & command)
-
     auto requiredLocalWorkGroupNo = (uint32_t)ceil((float)m_numberOfInvocations / float(WORKGROUP_SIZE));  // number of local works groups
     VkPhysicalDeviceProperties deviceProperties;
     vkGetPhysicalDeviceProperties(m_PhysicalDevice, &deviceProperties);
diff --git a/Intern/RayCore/src/VulkanEngine/Run/Run.cpp b/Intern/RayCore/src/VulkanEngine/Run/Run.cpp
diff --git a/Intern/RayCore/src/VulkanEngine/VulkanEngine.h b/Intern/RayCore/src/VulkanEngine/VulkanEngine.h
