Fix D3D12 NanoVDB volume load stalls

engine/include/XCEngine/Core/Containers/Array.h

@@ -4,6 +4,7 @@
 #include <initializer_list>
 #include <algorithm>
 #include <stdexcept>
+#include <type_traits>
 #include <XCEngine/Memory/Allocator.h>
 
 namespace XCEngine {
@@ -41,6 +42,7 @@ public:
     void Reserve(size_t capacity);
     void Resize(size_t newSize);
     void Resize(size_t newSize, const T& value);
+    void ResizeUninitialized(size_t newSize);
 
     void PushBack(const T& value);
     void PushBack(T&& value);
@@ -199,6 +201,22 @@ void Array<T>::Resize(size_t newSize) {
     m_size = newSize;
 }
 
+template<typename T>
+void Array<T>::ResizeUninitialized(size_t newSize) {
+    static_assert(
+        std::is_trivially_default_constructible_v<T>,
+        "ResizeUninitialized requires trivially default-constructible elements");
+    static_assert(
+        std::is_trivially_destructible_v<T>,
+        "ResizeUninitialized requires trivially destructible elements");
+
+    if (newSize > m_capacity) {
+        Reallocate(newSize);
+    }
+
+    m_size = newSize;
+}
+
 template<typename T>
 void Array<T>::Resize(size_t newSize, const T& value) {
     if (newSize > m_capacity) {

engine/include/XCEngine/RHI/D3D12/D3D12Device.h

@@ -64,6 +64,7 @@ public:
     bool IsDeviceRemoved() const { return m_isDeviceRemoved; }
 
     RHIBuffer* CreateBuffer(const BufferDesc& desc) override;
+    RHIBuffer* CreateBuffer(const BufferDesc& desc, const void* initialData, size_t initialDataSize, ResourceStates finalState = ResourceStates::GenericRead) override;
     RHITexture* CreateTexture(const TextureDesc& desc) override;
     RHITexture* CreateTexture(const TextureDesc& desc, const void* initialData, size_t initialDataSize, uint32_t rowPitch = 0) override;
     RHISwapChain* CreateSwapChain(const SwapChainDesc& desc, RHICommandQueue* presentQueue) override;

engine/include/XCEngine/RHI/RHIDevice.h

@@ -2,6 +2,7 @@
 
 #include "RHITypes.h"
 #include "RHICapabilities.h"
+#include "RHIBuffer.h"
 #include "RHIDescriptorPool.h"
 #include "RHIDescriptorSet.h"
 #include "RHIRenderPass.h"
@@ -35,6 +36,40 @@ public:
     virtual void Shutdown() = 0;
 
     virtual RHIBuffer* CreateBuffer(const BufferDesc& desc) = 0;
+    virtual RHIBuffer* CreateBuffer(
+        const BufferDesc& desc,
+        const void* initialData,
+        size_t initialDataSize,
+        ResourceStates finalState = ResourceStates::GenericRead) {
+        if (initialData == nullptr || initialDataSize == 0u) {
+            return CreateBuffer(desc);
+        }
+        if (initialDataSize > desc.size) {
+            return nullptr;
+        }
+
+        RHIBuffer* buffer = CreateBuffer(desc);
+        if (buffer == nullptr) {
+            return nullptr;
+        }
+
+        buffer->SetData(initialData, initialDataSize);
+        if (desc.size > static_cast<uint64_t>(initialDataSize)) {
+            const std::array<unsigned char, 256> zeroBytes = {};
+            uint64_t remainingBytes = desc.size - static_cast<uint64_t>(initialDataSize);
+            size_t writeOffset = initialDataSize;
+            while (remainingBytes > 0u) {
+                const size_t chunkSize = static_cast<size_t>(
+                    remainingBytes > zeroBytes.size() ? zeroBytes.size() : remainingBytes);
+                buffer->SetData(zeroBytes.data(), chunkSize, writeOffset);
+                remainingBytes -= static_cast<uint64_t>(chunkSize);
+                writeOffset += chunkSize;
+            }
+        }
+
+        buffer->SetState(finalState);
+        return buffer;
+    }
     virtual RHITexture* CreateTexture(const TextureDesc& desc) = 0;
     virtual RHITexture* CreateTexture(const TextureDesc& desc, const void* initialData, size_t initialDataSize, uint32_t rowPitch = 0) = 0;
     virtual RHISwapChain* CreateSwapChain(const SwapChainDesc& desc, RHICommandQueue* presentQueue) = 0;

engine/include/XCEngine/Resources/Volume/VolumeField.h

@@ -57,6 +57,13 @@ public:
                 const VolumeIndexBounds& indexBounds = VolumeIndexBounds(),
                 Core::uint32 gridType = 0u,
                 Core::uint32 gridClass = 0u);
+    bool CreateOwned(VolumeStorageKind storageKind,
+                     Containers::Array<Core::uint8>&& payload,
+                     const Math::Bounds& bounds = Math::Bounds(),
+                     const Math::Vector3& voxelSize = Math::Vector3::Zero(),
+                     const VolumeIndexBounds& indexBounds = VolumeIndexBounds(),
+                     Core::uint32 gridType = 0u,
+                     Core::uint32 gridClass = 0u);
 
     VolumeStorageKind GetStorageKind() const { return m_storageKind; }
     const Math::Bounds& GetBounds() const { return m_bounds; }
@@ -69,6 +76,12 @@ public:
     size_t GetPayloadSize() const { return m_payload.Size(); }
 
 private:
+    bool ApplyMetadata(VolumeStorageKind storageKind,
+                       const Math::Bounds& bounds,
+                       const Math::Vector3& voxelSize,
+                       const VolumeIndexBounds& indexBounds,
+                       Core::uint32 gridType,
+                       Core::uint32 gridClass);
     void UpdateMemorySize();
 
     VolumeStorageKind m_storageKind = VolumeStorageKind::Unknown;