Add VolumeField NanoVDB asset pipeline

engine/include/XCEngine/Core/Asset/ArtifactFormats.h

@@ -15,6 +15,7 @@ constexpr Core::uint32 kMaterialArtifactSchemaVersion = 6;
 constexpr Core::uint32 kMeshArtifactSchemaVersion = 2;
 constexpr Core::uint32 kShaderArtifactSchemaVersion = 5;
 constexpr Core::uint32 kUIDocumentArtifactSchemaVersion = 2;
+constexpr Core::uint32 kVolumeFieldArtifactSchemaVersion = 1;
 
 struct TextureArtifactHeader {
     char magic[8] = { 'X', 'C', 'T', 'E', 'X', '0', '1', '\0' };
@@ -129,5 +130,17 @@ struct UIDocumentArtifactDiagnosticHeader {
     Core::uint32 column = 1;
 };
 
+struct VolumeFieldArtifactHeader {
+    char magic[8] = { 'X', 'C', 'V', 'O', 'L', '0', '1', '\0' };
+    Core::uint32 schemaVersion = kVolumeFieldArtifactSchemaVersion;
+    Core::uint32 storageKind = 0;
+    Math::Vector3 boundsMin = Math::Vector3::Zero();
+    Math::Vector3 boundsMax = Math::Vector3::Zero();
+    Math::Vector3 voxelSize = Math::Vector3::Zero();
+    Core::uint64 payloadSize = 0;
+    Core::uint32 reserved0 = 0;
+    Core::uint32 reserved1 = 0;
+};
+
 } // namespace Resources
 } // namespace XCEngine

engine/include/XCEngine/Core/Asset/AssetDatabase.h

@@ -139,6 +139,8 @@ private:
                           ArtifactRecord& outRecord);
     bool ImportShaderAsset(const SourceAssetRecord& sourceRecord,
                            ArtifactRecord& outRecord);
+    bool ImportVolumeFieldAsset(const SourceAssetRecord& sourceRecord,
+                                ArtifactRecord& outRecord);
     bool ImportUIDocumentAsset(const SourceAssetRecord& sourceRecord,
                                UIDocumentKind kind,
                                const char* artifactFileName,

engine/include/XCEngine/Core/Asset/ResourceTypes.h

@@ -25,7 +25,8 @@ enum class ResourceType : Core::uint8 {
     Prefab,
     UIView,
     UITheme,
-    UISchema
+    UISchema,
+    VolumeField
 };
 
 constexpr const char* GetResourceTypeName(ResourceType type) {
@@ -45,6 +46,7 @@ constexpr const char* GetResourceTypeName(ResourceType type) {
         case ResourceType::UIView:        return "UIView";
         case ResourceType::UITheme:       return "UITheme";
         case ResourceType::UISchema:      return "UISchema";
+        case ResourceType::VolumeField:   return "VolumeField";
         default:                          return "Unknown";
     }
 }
@@ -98,6 +100,7 @@ template<> inline ResourceType GetResourceType<class BinaryResource>() { return
 template<> inline ResourceType GetResourceType<class UIView>() { return ResourceType::UIView; }
 template<> inline ResourceType GetResourceType<class UITheme>() { return ResourceType::UITheme; }
 template<> inline ResourceType GetResourceType<class UISchema>() { return ResourceType::UISchema; }
+template<> inline ResourceType GetResourceType<class VolumeField>() { return ResourceType::VolumeField; }
 
 } // namespace Resources
 } // namespace XCEngine

engine/include/XCEngine/Resources/Resources.h

@@ -21,6 +21,8 @@
 #include <XCEngine/Resources/Material/MaterialLoader.h>
 #include <XCEngine/Resources/Shader/Shader.h>
 #include <XCEngine/Resources/Shader/ShaderLoader.h>
+#include <XCEngine/Resources/Volume/VolumeField.h>
+#include <XCEngine/Resources/Volume/VolumeFieldLoader.h>
 #include <XCEngine/Resources/AudioClip/AudioClip.h>
 #include <XCEngine/Resources/AudioClip/AudioLoader.h>
 #include <XCEngine/Resources/UI/UIDocumentTypes.h>

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

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <XCEngine/Core/Asset/IResource.h>
+#include <XCEngine/Core/Containers/Array.h>
+#include <XCEngine/Core/Math/Bounds.h>
+#include <XCEngine/Core/Math/Vector3.h>
+#include <XCEngine/Core/Types.h>
+
+namespace XCEngine {
+namespace Resources {
+
+enum class VolumeStorageKind : Core::uint32 {
+    Unknown = 0,
+    NanoVDB = 1
+};
+
+class VolumeField : public IResource {
+public:
+    VolumeField();
+    virtual ~VolumeField() override;
+
+    ResourceType GetType() const override { return ResourceType::VolumeField; }
+    const Containers::String& GetName() const override { return m_name; }
+    const Containers::String& GetPath() const override { return m_path; }
+    ResourceGUID GetGUID() const override { return m_guid; }
+    bool IsValid() const override { return m_isValid; }
+    size_t GetMemorySize() const override { return m_memorySize; }
+    void Release() override;
+
+    bool Create(VolumeStorageKind storageKind,
+                const void* payload,
+                size_t payloadSize,
+                const Math::Bounds& bounds = Math::Bounds(),
+                const Math::Vector3& voxelSize = Math::Vector3::Zero());
+
+    VolumeStorageKind GetStorageKind() const { return m_storageKind; }
+    const Math::Bounds& GetBounds() const { return m_bounds; }
+    const Math::Vector3& GetVoxelSize() const { return m_voxelSize; }
+    const void* GetPayloadData() const { return m_payload.Data(); }
+    size_t GetPayloadSize() const { return m_payload.Size(); }
+
+private:
+    void UpdateMemorySize();
+
+    VolumeStorageKind m_storageKind = VolumeStorageKind::Unknown;
+    Math::Bounds m_bounds;
+    Math::Vector3 m_voxelSize = Math::Vector3::Zero();
+    Containers::Array<Core::uint8> m_payload;
+};
+
+} // namespace Resources
+} // namespace XCEngine

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

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <XCEngine/Core/IO/IResourceLoader.h>
+
+namespace XCEngine {
+namespace Resources {
+
+class VolumeFieldLoader : public IResourceLoader {
+public:
+    VolumeFieldLoader();
+    virtual ~VolumeFieldLoader() override;
+
+    ResourceType GetResourceType() const override { return ResourceType::VolumeField; }
+    Containers::Array<Containers::String> GetSupportedExtensions() const override;
+    bool CanLoad(const Containers::String& path) const override;
+    LoadResult Load(const Containers::String& path, const ImportSettings* settings = nullptr) override;
+    ImportSettings* GetDefaultSettings() const override;
+};
+
+} // namespace Resources
+} // namespace XCEngine