Add volume renderer extraction stage 5

2026-04-08 20:12:14 +08:00
parent c6815fa809
commit b839fd98af
14 changed files with 906 additions and 7 deletions
--- a/engine/CMakeLists.txt
+++ b/engine/CMakeLists.txt
@@ -436,6 +436,7 @@ add_library(XCEngine STATIC
    ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Components/LightComponent.h
    ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Components/MeshFilterComponent.h
    ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Components/MeshRendererComponent.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Components/VolumeRendererComponent.h
    ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Components/AudioSourceComponent.h
    ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Components/AudioListenerComponent.h
    ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Components/ComponentFactoryRegistry.h
@@ -446,6 +447,7 @@ add_library(XCEngine STATIC
    ${CMAKE_CURRENT_SOURCE_DIR}/src/Components/LightComponent.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/src/Components/MeshFilterComponent.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/src/Components/MeshRendererComponent.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/Components/VolumeRendererComponent.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/src/Components/AudioSourceComponent.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/src/Components/AudioListenerComponent.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/src/Components/ComponentFactoryRegistry.cpp
@@ -461,6 +463,7 @@ add_library(XCEngine STATIC
    ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/FrameData/RenderCameraData.h
    ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/FrameData/RenderSceneData.h
    ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/FrameData/VisibleRenderItem.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/FrameData/VisibleVolumeItem.h
    ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/Planning/CameraRenderRequest.h
    ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/Planning/FinalColorPassFactory.h
    ${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/Planning/FinalColorSettings.h
--- a/engine/include/XCEngine/Components/VolumeRendererComponent.h
+++ b/engine/include/XCEngine/Components/VolumeRendererComponent.h
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <XCEngine/Components/Component.h>
+#include <XCEngine/Core/Asset/AssetRef.h>
+#include <XCEngine/Core/Asset/ResourceHandle.h>
+#include <XCEngine/Resources/Material/Material.h>
+#include <XCEngine/Resources/Volume/VolumeField.h>
+
+#include <memory>
+#include <string>
+
+namespace XCEngine {
+namespace Components {
+
+class VolumeRendererComponent : public Component {
+public:
+    std::string GetName() const override { return "VolumeRenderer"; }
+
+    Resources::VolumeField* GetVolumeField() const;
+    const Resources::ResourceHandle<Resources::VolumeField>& GetVolumeFieldHandle() const;
+    const std::string& GetVolumeFieldPath() const { return m_volumeFieldPath; }
+    const Resources::AssetRef& GetVolumeFieldAssetRef() const { return m_volumeFieldRef; }
+
+    void SetVolumeFieldPath(const std::string& volumeFieldPath);
+    void SetVolumeField(const Resources::ResourceHandle<Resources::VolumeField>& volumeField);
+    void SetVolumeField(Resources::VolumeField* volumeField);
+    void ClearVolumeField();
+
+    Resources::Material* GetMaterial() const;
+    const Resources::ResourceHandle<Resources::Material>& GetMaterialHandle() const;
+    const std::string& GetMaterialPath() const { return m_materialPath; }
+    const Resources::AssetRef& GetMaterialAssetRef() const { return m_materialRef; }
+
+    void SetMaterialPath(const std::string& materialPath);
+    void SetMaterial(const Resources::ResourceHandle<Resources::Material>& material);
+    void SetMaterial(Resources::Material* material);
+    void ClearMaterial();
+
+    bool GetCastShadows() const { return m_castShadows; }
+    void SetCastShadows(bool value) { m_castShadows = value; }
+
+    bool GetReceiveShadows() const { return m_receiveShadows; }
+    void SetReceiveShadows(bool value) { m_receiveShadows = value; }
+
+    void Serialize(std::ostream& os) const override;
+    void Deserialize(std::istream& is) override;
+
+private:
+    struct PendingVolumeLoadState;
+    struct PendingMaterialLoadState;
+
+    void BeginAsyncVolumeLoad(const std::string& volumeFieldPath);
+    void EnsureDeferredAsyncVolumeLoadStarted();
+    void ResolvePendingVolumeField();
+
+    void BeginAsyncMaterialLoad(const std::string& materialPath);
+    void EnsureDeferredAsyncMaterialLoadStarted();
+    void ResolvePendingMaterial();
+
+    Resources::ResourceHandle<Resources::VolumeField> m_volumeField;
+    std::string m_volumeFieldPath;
+    Resources::AssetRef m_volumeFieldRef;
+    std::shared_ptr<PendingVolumeLoadState> m_pendingVolumeLoad;
+    bool m_asyncVolumeLoadRequested = false;
+
+    Resources::ResourceHandle<Resources::Material> m_material;
+    std::string m_materialPath;
+    Resources::AssetRef m_materialRef;
+    std::shared_ptr<PendingMaterialLoadState> m_pendingMaterialLoad;
+    bool m_asyncMaterialLoadRequested = false;
+
+    bool m_castShadows = true;
+    bool m_receiveShadows = true;
+};
+
+} // namespace Components
+} // namespace XCEngine
--- a/engine/include/XCEngine/Rendering/Extraction/RenderSceneExtractor.h
+++ b/engine/include/XCEngine/Rendering/Extraction/RenderSceneExtractor.h
@@ -37,11 +37,12 @@ private:
        const Math::Vector3& cameraPosition,
        uint32_t cullingMask,
        RenderLightingData& lightingData) const;
-    void ExtractVisibleItems(
+    void ExtractVisibleContent(
        Components::GameObject* gameObject,
        const Math::Vector3& cameraPosition,
        uint32_t cullingMask,
-        std::vector<VisibleRenderItem>& outVisibleItems) const;
+        std::vector<VisibleRenderItem>& outVisibleItems,
+        std::vector<VisibleVolumeItem>& outVisibleVolumes) const;
 };

 } // namespace Rendering
--- a/engine/include/XCEngine/Rendering/Extraction/RenderSceneUtility.h
+++ b/engine/include/XCEngine/Rendering/Extraction/RenderSceneUtility.h
@@ -3,6 +3,7 @@
 #include <XCEngine/Core/Math/Vector3.h>
 #include <XCEngine/Rendering/FrameData/RenderCameraData.h>
 #include <XCEngine/Rendering/FrameData/VisibleRenderItem.h>
+#include <XCEngine/Rendering/FrameData/VisibleVolumeItem.h>

 #include <cstdint>
 #include <vector>
@@ -27,10 +28,19 @@ void AppendRenderItemsForGameObject(
    const Math::Vector3& cameraPosition,
    std::vector<VisibleRenderItem>& outVisibleItems);

+void AppendVisibleVolumesForGameObject(
+    Components::GameObject& gameObject,
+    const Math::Vector3& cameraPosition,
+    std::vector<VisibleVolumeItem>& outVisibleVolumes);
+
 bool CompareVisibleRenderItemsStable(
    const VisibleRenderItem& lhs,
    const VisibleRenderItem& rhs);

+bool CompareVisibleVolumesStable(
+    const VisibleVolumeItem& lhs,
+    const VisibleVolumeItem& rhs);
+
 std::vector<VisibleRenderItem> CollectRenderItemsForEntityIds(
    const Components::Scene& scene,
    const std::vector<uint64_t>& entityIds,
--- a/engine/include/XCEngine/Rendering/FrameData/RenderSceneData.h
+++ b/engine/include/XCEngine/Rendering/FrameData/RenderSceneData.h
@@ -5,6 +5,7 @@
 #include <XCEngine/Rendering/FrameData/RenderCameraData.h>
 #include <XCEngine/Rendering/FrameData/RenderEnvironmentData.h>
 #include <XCEngine/Rendering/FrameData/VisibleRenderItem.h>
+#include <XCEngine/Rendering/FrameData/VisibleVolumeItem.h>
 #include <XCEngine/Resources/Shader/ShaderKeywordTypes.h>

 #include <array>
@@ -87,6 +88,7 @@ struct RenderSceneData {
    RenderLightingData lighting;
    Resources::ShaderKeywordSet globalShaderKeywords;
    std::vector<VisibleRenderItem> visibleItems;
+    std::vector<VisibleVolumeItem> visibleVolumes;

    bool HasCamera() const {
        return camera != nullptr;
--- a/engine/include/XCEngine/Rendering/FrameData/VisibleVolumeItem.h
+++ b/engine/include/XCEngine/Rendering/FrameData/VisibleVolumeItem.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <XCEngine/Core/Math/Matrix4.h>
+#include <XCEngine/Core/Types.h>
+
+namespace XCEngine {
+namespace Components {
+class GameObject;
+class VolumeRendererComponent;
+} // namespace Components
+
+namespace Resources {
+class Material;
+class VolumeField;
+} // namespace Resources
+
+namespace Rendering {
+
+struct VisibleVolumeItem {
+    Components::GameObject* gameObject = nullptr;
+    Components::VolumeRendererComponent* volumeRenderer = nullptr;
+    Resources::VolumeField* volumeField = nullptr;
+    const Resources::Material* material = nullptr;
+    Core::int32 renderQueue = 0;
+    float cameraDistanceSq = 0.0f;
+    Math::Matrix4x4 localToWorld = Math::Matrix4x4::Identity();
+};
+
+} // namespace Rendering
+} // namespace XCEngine
--- a/engine/src/Components/ComponentFactoryRegistry.cpp
+++ b/engine/src/Components/ComponentFactoryRegistry.cpp
@@ -7,6 +7,7 @@
 #include "Components/LightComponent.h"
 #include "Components/MeshFilterComponent.h"
 #include "Components/MeshRendererComponent.h"
+#include "Components/VolumeRendererComponent.h"
 #include "Scripting/ScriptComponent.h"

 namespace XCEngine {
@@ -33,6 +34,7 @@ ComponentFactoryRegistry::ComponentFactoryRegistry() {
    RegisterFactory("AudioListener", &CreateBuiltInComponent<AudioListenerComponent>);
    RegisterFactory("MeshFilter", &CreateBuiltInComponent<MeshFilterComponent>);
    RegisterFactory("MeshRenderer", &CreateBuiltInComponent<MeshRendererComponent>);
+    RegisterFactory("VolumeRenderer", &CreateBuiltInComponent<VolumeRendererComponent>);
    RegisterFactory("ScriptComponent", &CreateBuiltInComponent<XCEngine::Scripting::ScriptComponent>);
 }

--- a/engine/src/Components/VolumeRendererComponent.cpp
+++ b/engine/src/Components/VolumeRendererComponent.cpp
@@ -0,0 +1,420 @@
+#include "Components/VolumeRendererComponent.h"
+
+#include "Core/Asset/ResourceManager.h"
+
+namespace XCEngine {
+namespace Components {
+
+namespace {
+
+std::string ToStdString(const Containers::String& value) {
+    return std::string(value.CStr());
+}
+
+bool HasVirtualPathScheme(const std::string& path) {
+    return path.find("://") != std::string::npos;
+}
+
+std::string EncodeAssetRef(const Resources::AssetRef& assetRef) {
+    if (!assetRef.IsValid()) {
+        return std::string();
+    }
+
+    return ToStdString(assetRef.assetGuid.ToString()) + "," +
+           std::to_string(assetRef.localID) + "," +
+           std::to_string(static_cast<int>(assetRef.resourceType));
+}
+
+bool TryDecodeAssetRef(const std::string& value, Resources::AssetRef& outRef) {
+    const size_t firstComma = value.find(',');
+    const size_t secondComma = firstComma == std::string::npos ? std::string::npos : value.find(',', firstComma + 1);
+    if (firstComma == std::string::npos || secondComma == std::string::npos) {
+        return false;
+    }
+
+    const Containers::String guidText(value.substr(0, firstComma).c_str());
+    outRef.assetGuid = Resources::AssetGUID::ParseOrDefault(guidText);
+    outRef.localID = static_cast<Resources::LocalID>(std::stoull(value.substr(firstComma + 1, secondComma - firstComma - 1)));
+    outRef.resourceType = static_cast<Resources::ResourceType>(std::stoi(value.substr(secondComma + 1)));
+    return outRef.IsValid();
+}
+
+std::string VolumeFieldPathFromHandle(const Resources::ResourceHandle<Resources::VolumeField>& volumeField) {
+    return volumeField.Get() != nullptr ? ToStdString(volumeField->GetPath()) : std::string();
+}
+
+std::string MaterialPathFromHandle(const Resources::ResourceHandle<Resources::Material>& material) {
+    return material.Get() != nullptr ? ToStdString(material->GetPath()) : std::string();
+}
+
+} // namespace
+
+struct VolumeRendererComponent::PendingVolumeLoadState {
+    Resources::LoadResult result;
+    bool completed = false;
+};
+
+struct VolumeRendererComponent::PendingMaterialLoadState {
+    Resources::LoadResult result;
+    bool completed = false;
+};
+
+Resources::VolumeField* VolumeRendererComponent::GetVolumeField() const {
+    const_cast<VolumeRendererComponent*>(this)->EnsureDeferredAsyncVolumeLoadStarted();
+    const_cast<VolumeRendererComponent*>(this)->ResolvePendingVolumeField();
+    return m_volumeField.Get();
+}
+
+const Resources::ResourceHandle<Resources::VolumeField>& VolumeRendererComponent::GetVolumeFieldHandle() const {
+    const_cast<VolumeRendererComponent*>(this)->EnsureDeferredAsyncVolumeLoadStarted();
+    const_cast<VolumeRendererComponent*>(this)->ResolvePendingVolumeField();
+    return m_volumeField;
+}
+
+void VolumeRendererComponent::SetVolumeFieldPath(const std::string& volumeFieldPath) {
+    m_pendingVolumeLoad.reset();
+    m_asyncVolumeLoadRequested = false;
+    m_volumeFieldPath = volumeFieldPath;
+    if (m_volumeFieldPath.empty()) {
+        m_volumeField.Reset();
+        m_volumeFieldRef.Reset();
+        return;
+    }
+
+    m_volumeField = Resources::ResourceManager::Get().Load<Resources::VolumeField>(m_volumeFieldPath.c_str());
+    if (!Resources::ResourceManager::Get().TryGetAssetRef(
+            m_volumeFieldPath.c_str(),
+            Resources::ResourceType::VolumeField,
+            m_volumeFieldRef)) {
+        m_volumeFieldRef.Reset();
+    }
+}
+
+void VolumeRendererComponent::SetVolumeField(
+    const Resources::ResourceHandle<Resources::VolumeField>& volumeField) {
+    m_pendingVolumeLoad.reset();
+    m_asyncVolumeLoadRequested = false;
+    m_volumeField = volumeField;
+    m_volumeFieldPath = VolumeFieldPathFromHandle(volumeField);
+    if (m_volumeFieldPath.empty() ||
+        !Resources::ResourceManager::Get().TryGetAssetRef(
+            m_volumeFieldPath.c_str(),
+            Resources::ResourceType::VolumeField,
+            m_volumeFieldRef)) {
+        m_volumeFieldRef.Reset();
+    }
+}
+
+void VolumeRendererComponent::SetVolumeField(Resources::VolumeField* volumeField) {
+    SetVolumeField(Resources::ResourceHandle<Resources::VolumeField>(volumeField));
+}
+
+void VolumeRendererComponent::ClearVolumeField() {
+    m_pendingVolumeLoad.reset();
+    m_asyncVolumeLoadRequested = false;
+    m_volumeField.Reset();
+    m_volumeFieldPath.clear();
+    m_volumeFieldRef.Reset();
+}
+
+Resources::Material* VolumeRendererComponent::GetMaterial() const {
+    const_cast<VolumeRendererComponent*>(this)->EnsureDeferredAsyncMaterialLoadStarted();
+    const_cast<VolumeRendererComponent*>(this)->ResolvePendingMaterial();
+    return m_material.Get();
+}
+
+const Resources::ResourceHandle<Resources::Material>& VolumeRendererComponent::GetMaterialHandle() const {
+    const_cast<VolumeRendererComponent*>(this)->EnsureDeferredAsyncMaterialLoadStarted();
+    const_cast<VolumeRendererComponent*>(this)->ResolvePendingMaterial();
+    return m_material;
+}
+
+void VolumeRendererComponent::SetMaterialPath(const std::string& materialPath) {
+    m_pendingMaterialLoad.reset();
+    m_asyncMaterialLoadRequested = false;
+    m_materialPath = materialPath;
+    if (m_materialPath.empty()) {
+        m_material.Reset();
+        m_materialRef.Reset();
+        return;
+    }
+
+    m_material = Resources::ResourceManager::Get().Load<Resources::Material>(m_materialPath.c_str());
+    if (!Resources::ResourceManager::Get().TryGetAssetRef(
+            m_materialPath.c_str(),
+            Resources::ResourceType::Material,
+            m_materialRef)) {
+        m_materialRef.Reset();
+    }
+}
+
+void VolumeRendererComponent::SetMaterial(
+    const Resources::ResourceHandle<Resources::Material>& material) {
+    m_pendingMaterialLoad.reset();
+    m_asyncMaterialLoadRequested = false;
+    m_material = material;
+    m_materialPath = MaterialPathFromHandle(material);
+    if (m_materialPath.empty() ||
+        !Resources::ResourceManager::Get().TryGetAssetRef(
+            m_materialPath.c_str(),
+            Resources::ResourceType::Material,
+            m_materialRef)) {
+        m_materialRef.Reset();
+    }
+}
+
+void VolumeRendererComponent::SetMaterial(Resources::Material* material) {
+    SetMaterial(Resources::ResourceHandle<Resources::Material>(material));
+}
+
+void VolumeRendererComponent::ClearMaterial() {
+    m_pendingMaterialLoad.reset();
+    m_asyncMaterialLoadRequested = false;
+    m_material.Reset();
+    m_materialPath.clear();
+    m_materialRef.Reset();
+}
+
+void VolumeRendererComponent::Serialize(std::ostream& os) const {
+    Resources::AssetRef volumeFieldRef = m_volumeFieldRef;
+    if (!volumeFieldRef.IsValid() &&
+        !m_volumeFieldPath.empty() &&
+        !HasVirtualPathScheme(m_volumeFieldPath) &&
+        Resources::ResourceManager::Get().TryGetAssetRef(
+            m_volumeFieldPath.c_str(),
+            Resources::ResourceType::VolumeField,
+            volumeFieldRef)) {
+    }
+
+    Resources::AssetRef materialRef = m_materialRef;
+    if (!materialRef.IsValid() &&
+        !m_materialPath.empty() &&
+        !HasVirtualPathScheme(m_materialPath) &&
+        Resources::ResourceManager::Get().TryGetAssetRef(
+            m_materialPath.c_str(),
+            Resources::ResourceType::Material,
+            materialRef)) {
+    }
+
+    os << "volumeRef=" << EncodeAssetRef(volumeFieldRef) << ";";
+    if (!volumeFieldRef.IsValid() && !m_volumeFieldPath.empty() && HasVirtualPathScheme(m_volumeFieldPath)) {
+        os << "volumePath=" << m_volumeFieldPath << ";";
+    }
+
+    os << "materialRef=" << EncodeAssetRef(materialRef) << ";";
+    if (!materialRef.IsValid() && !m_materialPath.empty() && HasVirtualPathScheme(m_materialPath)) {
+        os << "materialPath=" << m_materialPath << ";";
+    }
+
+    os << "castShadows=" << (m_castShadows ? 1 : 0) << ";";
+    os << "receiveShadows=" << (m_receiveShadows ? 1 : 0) << ";";
+}
+
+void VolumeRendererComponent::Deserialize(std::istream& is) {
+    ClearVolumeField();
+    ClearMaterial();
+    m_castShadows = true;
+    m_receiveShadows = true;
+
+    std::string token;
+    std::string pendingVolumePath;
+    Resources::AssetRef pendingVolumeRef;
+    std::string pendingMaterialPath;
+    Resources::AssetRef pendingMaterialRef;
+    while (std::getline(is, token, ';')) {
+        if (token.empty()) {
+            continue;
+        }
+
+        const size_t eqPos = token.find('=');
+        if (eqPos == std::string::npos) {
+            continue;
+        }
+
+        const std::string key = token.substr(0, eqPos);
+        const std::string value = token.substr(eqPos + 1);
+
+        if (key == "volumePath") {
+            pendingVolumePath = value;
+        } else if (key == "volumeRef") {
+            TryDecodeAssetRef(value, pendingVolumeRef);
+        } else if (key == "materialPath") {
+            pendingMaterialPath = value;
+        } else if (key == "materialRef") {
+            TryDecodeAssetRef(value, pendingMaterialRef);
+        } else if (key == "castShadows") {
+            m_castShadows = (std::stoi(value) != 0);
+        } else if (key == "receiveShadows") {
+            m_receiveShadows = (std::stoi(value) != 0);
+        }
+    }
+
+    if (pendingVolumeRef.IsValid()) {
+        bool restoredOrQueued = false;
+        m_volumeFieldRef = pendingVolumeRef;
+        if (Resources::ResourceManager::Get().IsDeferredSceneLoadEnabled()) {
+            Containers::String resolvedPath;
+            if (Resources::ResourceManager::Get().TryResolveAssetPath(pendingVolumeRef, resolvedPath)) {
+                m_volumeFieldPath = ToStdString(resolvedPath);
+                restoredOrQueued = true;
+            }
+        }
+
+        if (!restoredOrQueued) {
+            m_volumeField = Resources::ResourceManager::Get().Load<Resources::VolumeField>(pendingVolumeRef);
+            m_volumeFieldPath = m_volumeField.Get() != nullptr
+                ? VolumeFieldPathFromHandle(m_volumeField)
+                : pendingVolumePath;
+        }
+    } else if (!pendingVolumePath.empty() && HasVirtualPathScheme(pendingVolumePath)) {
+        if (Resources::ResourceManager::Get().IsDeferredSceneLoadEnabled()) {
+            m_volumeFieldPath = pendingVolumePath;
+        } else {
+            SetVolumeFieldPath(pendingVolumePath);
+        }
+    }
+
+    if (pendingMaterialRef.IsValid()) {
+        bool restoredOrQueued = false;
+        m_materialRef = pendingMaterialRef;
+        if (Resources::ResourceManager::Get().IsDeferredSceneLoadEnabled()) {
+            Containers::String resolvedPath;
+            if (Resources::ResourceManager::Get().TryResolveAssetPath(pendingMaterialRef, resolvedPath)) {
+                m_materialPath = ToStdString(resolvedPath);
+                restoredOrQueued = true;
+            }
+        }
+
+        if (!restoredOrQueued) {
+            m_material = Resources::ResourceManager::Get().Load<Resources::Material>(pendingMaterialRef);
+            m_materialPath = m_material.Get() != nullptr
+                ? MaterialPathFromHandle(m_material)
+                : pendingMaterialPath;
+        }
+    } else if (!pendingMaterialPath.empty() && HasVirtualPathScheme(pendingMaterialPath)) {
+        if (Resources::ResourceManager::Get().IsDeferredSceneLoadEnabled()) {
+            m_materialPath = pendingMaterialPath;
+        } else {
+            SetMaterialPath(pendingMaterialPath);
+        }
+    }
+}
+
+void VolumeRendererComponent::BeginAsyncVolumeLoad(const std::string& volumeFieldPath) {
+    if (volumeFieldPath.empty()) {
+        m_pendingVolumeLoad.reset();
+        m_asyncVolumeLoadRequested = false;
+        m_volumeField.Reset();
+        return;
+    }
+
+    m_asyncVolumeLoadRequested = true;
+    m_volumeField.Reset();
+    m_pendingVolumeLoad = std::make_shared<PendingVolumeLoadState>();
+    std::weak_ptr<PendingVolumeLoadState> weakState = m_pendingVolumeLoad;
+    Resources::ResourceManager::Get().LoadAsync(
+        volumeFieldPath.c_str(),
+        Resources::ResourceType::VolumeField,
+        [weakState](Resources::LoadResult result) {
+            if (std::shared_ptr<PendingVolumeLoadState> state = weakState.lock()) {
+                state->result = std::move(result);
+                state->completed = true;
+            }
+        });
+}
+
+void VolumeRendererComponent::EnsureDeferredAsyncVolumeLoadStarted() {
+    if (m_asyncVolumeLoadRequested || m_volumeField.Get() != nullptr || m_volumeFieldPath.empty()) {
+        return;
+    }
+
+    BeginAsyncVolumeLoad(m_volumeFieldPath);
+}
+
+void VolumeRendererComponent::ResolvePendingVolumeField() {
+    if (!m_pendingVolumeLoad || !m_pendingVolumeLoad->completed) {
+        return;
+    }
+
+    std::shared_ptr<PendingVolumeLoadState> completedLoad = std::move(m_pendingVolumeLoad);
+    m_pendingVolumeLoad.reset();
+
+    if (!completedLoad->result || completedLoad->result.resource == nullptr) {
+        return;
+    }
+
+    m_volumeField = Resources::ResourceHandle<Resources::VolumeField>(
+        static_cast<Resources::VolumeField*>(completedLoad->result.resource));
+    if (m_volumeField.Get() == nullptr) {
+        return;
+    }
+
+    m_volumeFieldPath = VolumeFieldPathFromHandle(m_volumeField);
+    if (!Resources::ResourceManager::Get().TryGetAssetRef(
+            m_volumeFieldPath.c_str(),
+            Resources::ResourceType::VolumeField,
+            m_volumeFieldRef)) {
+        m_volumeFieldRef.Reset();
+    }
+}
+
+void VolumeRendererComponent::BeginAsyncMaterialLoad(const std::string& materialPath) {
+    if (materialPath.empty()) {
+        m_pendingMaterialLoad.reset();
+        m_asyncMaterialLoadRequested = false;
+        m_material.Reset();
+        return;
+    }
+
+    m_asyncMaterialLoadRequested = true;
+    m_material.Reset();
+    m_pendingMaterialLoad = std::make_shared<PendingMaterialLoadState>();
+    std::weak_ptr<PendingMaterialLoadState> weakState = m_pendingMaterialLoad;
+    Resources::ResourceManager::Get().LoadAsync(
+        materialPath.c_str(),
+        Resources::ResourceType::Material,
+        [weakState](Resources::LoadResult result) {
+            if (std::shared_ptr<PendingMaterialLoadState> state = weakState.lock()) {
+                state->result = std::move(result);
+                state->completed = true;
+            }
+        });
+}
+
+void VolumeRendererComponent::EnsureDeferredAsyncMaterialLoadStarted() {
+    if (m_asyncMaterialLoadRequested || m_material.Get() != nullptr || m_materialPath.empty()) {
+        return;
+    }
+
+    BeginAsyncMaterialLoad(m_materialPath);
+}
+
+void VolumeRendererComponent::ResolvePendingMaterial() {
+    if (!m_pendingMaterialLoad || !m_pendingMaterialLoad->completed) {
+        return;
+    }
+
+    std::shared_ptr<PendingMaterialLoadState> completedLoad = std::move(m_pendingMaterialLoad);
+    m_pendingMaterialLoad.reset();
+
+    if (!completedLoad->result || completedLoad->result.resource == nullptr) {
+        return;
+    }
+
+    m_material = Resources::ResourceHandle<Resources::Material>(
+        static_cast<Resources::Material*>(completedLoad->result.resource));
+    if (m_material.Get() == nullptr) {
+        return;
+    }
+
+    m_materialPath = MaterialPathFromHandle(m_material);
+    if (!Resources::ResourceManager::Get().TryGetAssetRef(
+            m_materialPath.c_str(),
+            Resources::ResourceType::Material,
+            m_materialRef)) {
+        m_materialRef.Reset();
+    }
+}
+
+} // namespace Components
+} // namespace XCEngine
--- a/engine/src/Rendering/Extraction/RenderSceneExtractor.cpp
+++ b/engine/src/Rendering/Extraction/RenderSceneExtractor.cpp
@@ -115,6 +115,10 @@ bool CompareVisibleItems(const VisibleRenderItem& lhs, const VisibleRenderItem&
    return CompareVisibleRenderItemsStable(lhs, rhs);
 }

+bool CompareVisibleVolumes(const VisibleVolumeItem& lhs, const VisibleVolumeItem& rhs) {
+    return CompareVisibleVolumesStable(lhs, rhs);
+}
+
 } // namespace

 RenderSceneData RenderSceneExtractor::Extract(
@@ -134,13 +138,22 @@ RenderSceneData RenderSceneExtractor::Extract(

    const std::vector<Components::GameObject*> rootGameObjects = scene.GetRootGameObjects();
    for (Components::GameObject* rootGameObject : rootGameObjects) {
-        ExtractVisibleItems(rootGameObject, cameraPosition, cullingMask, sceneData.visibleItems);
+        ExtractVisibleContent(
+            rootGameObject,
+            cameraPosition,
+            cullingMask,
+            sceneData.visibleItems,
+            sceneData.visibleVolumes);
    }

    std::stable_sort(
        sceneData.visibleItems.begin(),
        sceneData.visibleItems.end(),
        CompareVisibleItems);
+    std::stable_sort(
+        sceneData.visibleVolumes.begin(),
+        sceneData.visibleVolumes.end(),
+        CompareVisibleVolumes);
    ExtractLighting(scene, cameraPosition, cullingMask, sceneData.lighting);

    return sceneData;
@@ -163,13 +176,22 @@ RenderSceneData RenderSceneExtractor::ExtractForCamera(

    const std::vector<Components::GameObject*> rootGameObjects = scene.GetRootGameObjects();
    for (Components::GameObject* rootGameObject : rootGameObjects) {
-        ExtractVisibleItems(rootGameObject, cameraPosition, cullingMask, sceneData.visibleItems);
+        ExtractVisibleContent(
+            rootGameObject,
+            cameraPosition,
+            cullingMask,
+            sceneData.visibleItems,
+            sceneData.visibleVolumes);
    }

    std::stable_sort(
        sceneData.visibleItems.begin(),
        sceneData.visibleItems.end(),
        CompareVisibleItems);
+    std::stable_sort(
+        sceneData.visibleVolumes.begin(),
+        sceneData.visibleVolumes.end(),
+        CompareVisibleVolumes);
    ExtractLighting(scene, cameraPosition, cullingMask, sceneData.lighting);

    return sceneData;
@@ -281,11 +303,12 @@ void RenderSceneExtractor::ExtractLighting(
    }
 }

-void RenderSceneExtractor::ExtractVisibleItems(
+void RenderSceneExtractor::ExtractVisibleContent(
    Components::GameObject* gameObject,
    const Math::Vector3& cameraPosition,
    uint32_t cullingMask,
-    std::vector<VisibleRenderItem>& visibleItems) const {
+    std::vector<VisibleRenderItem>& visibleItems,
+    std::vector<VisibleVolumeItem>& visibleVolumes) const {
    if (gameObject == nullptr || !gameObject->IsActiveInHierarchy()) {
        return;
    }
@@ -295,10 +318,11 @@ void RenderSceneExtractor::ExtractVisibleItems(

    if (isVisibleInCameraMask) {
        AppendRenderItemsForGameObject(*gameObject, cameraPosition, visibleItems);
+        AppendVisibleVolumesForGameObject(*gameObject, cameraPosition, visibleVolumes);
    }

    for (Components::GameObject* child : gameObject->GetChildren()) {
-        ExtractVisibleItems(child, cameraPosition, cullingMask, visibleItems);
+        ExtractVisibleContent(child, cameraPosition, cullingMask, visibleItems, visibleVolumes);
    }
 }

--- a/engine/src/Rendering/Extraction/RenderSceneUtility.cpp
+++ b/engine/src/Rendering/Extraction/RenderSceneUtility.cpp
@@ -6,6 +6,7 @@
 #include "Components/MeshFilterComponent.h"
 #include "Components/MeshRendererComponent.h"
 #include "Components/TransformComponent.h"
+#include "Components/VolumeRendererComponent.h"
 #include "Rendering/Materials/RenderMaterialResolve.h"
 #include "Scene/Scene.h"

@@ -126,6 +127,41 @@ void AppendRenderItemsForGameObject(
    outVisibleItems.push_back(visibleItem);
 }

+void AppendVisibleVolumesForGameObject(
+    Components::GameObject& gameObject,
+    const Math::Vector3& cameraPosition,
+    std::vector<VisibleVolumeItem>& outVisibleVolumes) {
+    if (!gameObject.IsActiveInHierarchy()) {
+        return;
+    }
+
+    auto* volumeRenderer = gameObject.GetComponent<Components::VolumeRendererComponent>();
+    if (volumeRenderer == nullptr || !volumeRenderer->IsEnabled()) {
+        return;
+    }
+
+    Resources::VolumeField* volumeField = volumeRenderer->GetVolumeField();
+    Resources::Material* material = volumeRenderer->GetMaterial();
+    if (volumeField == nullptr ||
+        !volumeField->IsValid() ||
+        material == nullptr) {
+        return;
+    }
+
+    const Math::Matrix4x4 localToWorld = gameObject.GetTransform()->GetLocalToWorldMatrix();
+    const Math::Vector3 worldPosition = localToWorld.GetTranslation();
+
+    VisibleVolumeItem visibleVolume = {};
+    visibleVolume.gameObject = &gameObject;
+    visibleVolume.volumeRenderer = volumeRenderer;
+    visibleVolume.volumeField = volumeField;
+    visibleVolume.material = material;
+    visibleVolume.renderQueue = ResolveMaterialRenderQueue(material);
+    visibleVolume.cameraDistanceSq = (worldPosition - cameraPosition).SqrMagnitude();
+    visibleVolume.localToWorld = localToWorld;
+    outVisibleVolumes.push_back(visibleVolume);
+}
+
 bool CompareVisibleRenderItemsStable(
    const VisibleRenderItem& lhs,
    const VisibleRenderItem& rhs) {
@@ -161,6 +197,29 @@ bool CompareVisibleRenderItemsStable(
    return false;
 }

+bool CompareVisibleVolumesStable(
+    const VisibleVolumeItem& lhs,
+    const VisibleVolumeItem& rhs) {
+    if (lhs.renderQueue != rhs.renderQueue) {
+        return lhs.renderQueue < rhs.renderQueue;
+    }
+
+    const bool isTransparentQueue = IsTransparentRenderQueue(lhs.renderQueue);
+    if (lhs.cameraDistanceSq != rhs.cameraDistanceSq) {
+        return isTransparentQueue
+            ? lhs.cameraDistanceSq > rhs.cameraDistanceSq
+            : lhs.cameraDistanceSq < rhs.cameraDistanceSq;
+    }
+
+    const Core::uint64 lhsObjectId = lhs.gameObject != nullptr ? lhs.gameObject->GetID() : 0u;
+    const Core::uint64 rhsObjectId = rhs.gameObject != nullptr ? rhs.gameObject->GetID() : 0u;
+    if (lhsObjectId != rhsObjectId) {
+        return lhsObjectId < rhsObjectId;
+    }
+
+    return false;
+}
+
 std::vector<VisibleRenderItem> CollectRenderItemsForEntityIds(
    const Components::Scene& scene,
    const std::vector<uint64_t>& entityIds,
--- a/tests/Components/CMakeLists.txt
+++ b/tests/Components/CMakeLists.txt
@@ -9,6 +9,7 @@ set(COMPONENTS_TEST_SOURCES
    test_game_object.cpp
    test_camera_light_component.cpp
    test_mesh_render_components.cpp
+    test_volume_renderer_component.cpp
 )

 add_executable(components_tests ${COMPONENTS_TEST_SOURCES})
--- a/tests/Components/test_component_factory_registry.cpp
+++ b/tests/Components/test_component_factory_registry.cpp
@@ -8,6 +8,7 @@
 #include <XCEngine/Components/LightComponent.h>
 #include <XCEngine/Components/MeshFilterComponent.h>
 #include <XCEngine/Components/MeshRendererComponent.h>
+#include <XCEngine/Components/VolumeRendererComponent.h>

 using namespace XCEngine::Components;

@@ -22,6 +23,7 @@ TEST(ComponentFactoryRegistry_Test, BuiltInTypesAreRegistered) {
    EXPECT_TRUE(registry.IsRegistered("AudioListener"));
    EXPECT_TRUE(registry.IsRegistered("MeshFilter"));
    EXPECT_TRUE(registry.IsRegistered("MeshRenderer"));
+    EXPECT_TRUE(registry.IsRegistered("VolumeRenderer"));
    EXPECT_FALSE(registry.IsRegistered("Transform"));
    EXPECT_FALSE(registry.IsRegistered("MissingComponent"));
 }
@@ -36,6 +38,7 @@ TEST(ComponentFactoryRegistry_Test, CreateBuiltInComponentsByTypeName) {
    EXPECT_NE(dynamic_cast<AudioListenerComponent*>(registry.CreateComponent(&gameObject, "AudioListener")), nullptr);
    EXPECT_NE(dynamic_cast<MeshFilterComponent*>(registry.CreateComponent(&gameObject, "MeshFilter")), nullptr);
    EXPECT_NE(dynamic_cast<MeshRendererComponent*>(registry.CreateComponent(&gameObject, "MeshRenderer")), nullptr);
+    EXPECT_NE(dynamic_cast<VolumeRendererComponent*>(registry.CreateComponent(&gameObject, "VolumeRenderer")), nullptr);
    EXPECT_EQ(registry.CreateComponent(&gameObject, "MissingComponent"), nullptr);
 }

--- a/tests/Components/test_volume_renderer_component.cpp
+++ b/tests/Components/test_volume_renderer_component.cpp
@@ -0,0 +1,171 @@
+#include <gtest/gtest.h>
+
+#include <XCEngine/Components/GameObject.h>
+#include <XCEngine/Components/VolumeRendererComponent.h>
+#include <XCEngine/Core/Asset/IResource.h>
+#include <XCEngine/Core/Asset/ResourceManager.h>
+#include <XCEngine/Core/IO/IResourceLoader.h>
+#include <XCEngine/Core/Math/Bounds.h>
+#include <XCEngine/Resources/Material/Material.h>
+#include <XCEngine/Resources/Volume/VolumeField.h>
+
+#include <chrono>
+#include <sstream>
+#include <thread>
+
+using namespace XCEngine::Components;
+using namespace XCEngine::Math;
+using namespace XCEngine::Resources;
+
+namespace {
+
+VolumeField* CreateTestVolumeField(const char* name, const char* path) {
+    auto* volumeField = new VolumeField();
+    IResource::ConstructParams params = {};
+    params.name = name;
+    params.path = path;
+    params.guid = ResourceGUID::Generate(path);
+    volumeField->Initialize(params);
+
+    const unsigned char payload[8] = { 1, 3, 5, 7, 9, 11, 13, 15 };
+    EXPECT_TRUE(volumeField->Create(
+        VolumeStorageKind::NanoVDB,
+        payload,
+        sizeof(payload),
+        Bounds(Vector3::Zero(), Vector3::One()),
+        Vector3(0.5f, 0.5f, 0.5f)));
+    return volumeField;
+}
+
+Material* CreateTestMaterial(const char* name, const char* path) {
+    auto* material = new Material();
+    IResource::ConstructParams params = {};
+    params.name = name;
+    params.path = path;
+    params.guid = ResourceGUID::Generate(path);
+    material->Initialize(params);
+    return material;
+}
+
+class FakeAsyncVolumeFieldLoader : public IResourceLoader {
+public:
+    ResourceType GetResourceType() const override { return ResourceType::VolumeField; }
+
+    XCEngine::Containers::Array<XCEngine::Containers::String> GetSupportedExtensions() const override {
+        XCEngine::Containers::Array<XCEngine::Containers::String> extensions;
+        extensions.PushBack("nvdb");
+        return extensions;
+    }
+
+    bool CanLoad(const XCEngine::Containers::String& path) const override {
+        (void)path;
+        return true;
+    }
+
+    LoadResult Load(
+        const XCEngine::Containers::String& path,
+        const ImportSettings* settings = nullptr) override {
+        (void)settings;
+        return LoadResult(CreateTestVolumeField("AsyncVolume", path.CStr()));
+    }
+
+    ImportSettings* GetDefaultSettings() const override {
+        return nullptr;
+    }
+};
+
+bool PumpAsyncLoadsUntilIdle(
+    ResourceManager& manager,
+    std::chrono::milliseconds timeout = std::chrono::milliseconds(2000)) {
+    const auto deadline = std::chrono::steady_clock::now() + timeout;
+    while (manager.IsAsyncLoading() && std::chrono::steady_clock::now() < deadline) {
+        manager.UpdateAsyncLoads();
+        std::this_thread::sleep_for(std::chrono::milliseconds(5));
+    }
+
+    manager.UpdateAsyncLoads();
+    return !manager.IsAsyncLoading();
+}
+
+TEST(VolumeRendererComponent_Test, SetResourcesCachesHandlesPathsAndFlags) {
+    GameObject gameObject("VolumeHolder");
+    auto* component = gameObject.AddComponent<VolumeRendererComponent>();
+    VolumeField* volumeField = CreateTestVolumeField("Cloud", "Volumes/cloud.nvdb");
+    Material* material = CreateTestMaterial("VolumeMaterial", "Materials/volume.mat");
+
+    component->SetVolumeField(volumeField);
+    component->SetMaterial(material);
+    component->SetCastShadows(false);
+    component->SetReceiveShadows(false);
+
+    EXPECT_EQ(component->GetVolumeField(), volumeField);
+    EXPECT_EQ(component->GetVolumeFieldPath(), "Volumes/cloud.nvdb");
+    EXPECT_EQ(component->GetMaterial(), material);
+    EXPECT_EQ(component->GetMaterialPath(), "Materials/volume.mat");
+    EXPECT_FALSE(component->GetCastShadows());
+    EXPECT_FALSE(component->GetReceiveShadows());
+
+    component->ClearVolumeField();
+    component->ClearMaterial();
+    delete volumeField;
+    delete material;
+}
+
+TEST(VolumeRendererComponent_Test, SerializeAndDeserializePreservesVirtualPathsAndFlags) {
+    VolumeRendererComponent source;
+    source.SetVolumeFieldPath("test://volumes/cloud.nvdb");
+    source.SetMaterialPath("test://materials/volume.material");
+    source.SetCastShadows(false);
+    source.SetReceiveShadows(true);
+
+    std::stringstream stream;
+    source.Serialize(stream);
+    const std::string serialized = stream.str();
+    EXPECT_NE(serialized.find("volumePath=test://volumes/cloud.nvdb;"), std::string::npos);
+    EXPECT_NE(serialized.find("materialPath=test://materials/volume.material;"), std::string::npos);
+    EXPECT_NE(serialized.find("castShadows=0;"), std::string::npos);
+    EXPECT_NE(serialized.find("receiveShadows=1;"), std::string::npos);
+
+    VolumeRendererComponent target;
+    std::stringstream deserializeStream(serialized);
+    target.Deserialize(deserializeStream);
+
+    EXPECT_EQ(target.GetVolumeFieldPath(), "test://volumes/cloud.nvdb");
+    EXPECT_EQ(target.GetMaterialPath(), "test://materials/volume.material");
+    EXPECT_FALSE(target.GetCastShadows());
+    EXPECT_TRUE(target.GetReceiveShadows());
+    EXPECT_FALSE(target.GetVolumeFieldAssetRef().IsValid());
+    EXPECT_FALSE(target.GetMaterialAssetRef().IsValid());
+}
+
+TEST(VolumeRendererComponent_Test, DeferredSceneDeserializeLoadsVolumeFieldAsyncByPath) {
+    ResourceManager& manager = ResourceManager::Get();
+    manager.Initialize();
+
+    IResourceLoader* originalLoader = manager.GetLoader(ResourceType::VolumeField);
+    FakeAsyncVolumeFieldLoader fakeLoader;
+    manager.RegisterLoader(&fakeLoader);
+
+    VolumeRendererComponent target;
+    const auto pendingBeforeDeserialize = manager.GetAsyncPendingCount();
+    {
+        ResourceManager::ScopedDeferredSceneLoad deferredLoadScope;
+        EXPECT_TRUE(manager.IsDeferredSceneLoadEnabled());
+        std::stringstream stream(
+            "volumePath=test://volumes/async.nvdb;volumeRef=;materialRef=;castShadows=1;receiveShadows=1;");
+        target.Deserialize(stream);
+    }
+
+    EXPECT_EQ(target.GetVolumeFieldPath(), "test://volumes/async.nvdb");
+    EXPECT_EQ(target.GetVolumeField(), nullptr);
+    EXPECT_GT(manager.GetAsyncPendingCount(), pendingBeforeDeserialize);
+    ASSERT_TRUE(PumpAsyncLoadsUntilIdle(manager));
+    ASSERT_NE(target.GetVolumeField(), nullptr);
+    EXPECT_EQ(target.GetVolumeFieldPath(), "test://volumes/async.nvdb");
+    EXPECT_EQ(target.GetVolumeField()->GetStorageKind(), VolumeStorageKind::NanoVDB);
+
+    manager.RegisterLoader(originalLoader);
+    manager.Shutdown();
+}
+
+} // namespace
--- a/tests/Rendering/unit/test_render_scene_extractor.cpp
+++ b/tests/Rendering/unit/test_render_scene_extractor.cpp
@@ -5,8 +5,10 @@
 #include <XCEngine/Components/LightComponent.h>
 #include <XCEngine/Components/MeshFilterComponent.h>
 #include <XCEngine/Components/MeshRendererComponent.h>
+#include <XCEngine/Components/VolumeRendererComponent.h>
 #include <XCEngine/Core/Asset/IResource.h>
 #include <XCEngine/Core/Math/Color.h>
+#include <XCEngine/Core/Math/Bounds.h>
 #include <XCEngine/Core/Math/Quaternion.h>
 #include <XCEngine/Core/Math/Vector3.h>
 #include <XCEngine/Rendering/Builtin/BuiltinPassContract.h>
@@ -18,6 +20,7 @@
 #include <XCEngine/Resources/Mesh/Mesh.h>
 #include <XCEngine/Resources/Shader/Shader.h>
 #include <XCEngine/Resources/Texture/Texture.h>
+#include <XCEngine/Resources/Volume/VolumeField.h>
 #include <XCEngine/Scene/Scene.h>

 #include <string>
@@ -96,6 +99,24 @@ Material* CreateTestMaterial(const char* path, int32_t renderQueue) {
    return material;
 }

+VolumeField* CreateTestVolumeField(const char* path) {
+    auto* volumeField = new VolumeField();
+    IResource::ConstructParams params = {};
+    params.name = "TestVolume";
+    params.path = path;
+    params.guid = ResourceGUID::Generate(path);
+    volumeField->Initialize(params);
+
+    const unsigned char payload[8] = { 1, 2, 3, 4, 5, 6, 7, 8 };
+    EXPECT_TRUE(volumeField->Create(
+        VolumeStorageKind::NanoVDB,
+        payload,
+        sizeof(payload),
+        Bounds(Vector3::Zero(), Vector3(2.0f, 2.0f, 2.0f)),
+        Vector3(0.25f, 0.25f, 0.25f)));
+    return volumeField;
+}
+
 Texture* CreateTestTexture(const char* path, TextureType type) {
    auto* texture = new Texture();
    IResource::ConstructParams params = {};
@@ -372,6 +393,81 @@ TEST(RenderSceneExtractor_Test, FiltersVisibleItemsByCameraCullingMask) {
    delete hiddenMesh;
 }

+TEST(RenderSceneExtractor_Test, ExtractsVisibleVolumesAndSortsByRenderQueue) {
+    Scene scene("VolumeScene");
+
+    GameObject* cameraObject = scene.CreateGameObject("Camera");
+    auto* camera = cameraObject->AddComponent<CameraComponent>();
+    camera->SetPrimary(true);
+    camera->SetCullingMask(1u << 0);
+
+    GameObject* opaqueVolumeObject = scene.CreateGameObject("OpaqueVolume");
+    opaqueVolumeObject->SetLayer(0);
+    opaqueVolumeObject->GetTransform()->SetLocalPosition(Vector3(0.0f, 0.0f, 2.0f));
+    auto* opaqueVolumeRenderer = opaqueVolumeObject->AddComponent<VolumeRendererComponent>();
+    VolumeField* opaqueVolume = CreateTestVolumeField("Volumes/opaque.nvdb");
+    Material* opaqueMaterial = CreateTestMaterial(
+        "Materials/opaque_volume.mat",
+        static_cast<int32_t>(MaterialRenderQueue::Geometry));
+    opaqueVolumeRenderer->SetVolumeField(opaqueVolume);
+    opaqueVolumeRenderer->SetMaterial(opaqueMaterial);
+
+    GameObject* transparentVolumeObject = scene.CreateGameObject("TransparentVolume");
+    transparentVolumeObject->SetLayer(0);
+    transparentVolumeObject->GetTransform()->SetLocalPosition(Vector3(0.0f, 0.0f, 8.0f));
+    auto* transparentVolumeRenderer = transparentVolumeObject->AddComponent<VolumeRendererComponent>();
+    VolumeField* transparentVolume = CreateTestVolumeField("Volumes/transparent.nvdb");
+    Material* transparentMaterial = CreateTestMaterial(
+        "Materials/transparent_volume.mat",
+        static_cast<int32_t>(MaterialRenderQueue::Transparent));
+    transparentVolumeRenderer->SetVolumeField(transparentVolume);
+    transparentVolumeRenderer->SetMaterial(transparentMaterial);
+
+    GameObject* hiddenVolumeObject = scene.CreateGameObject("HiddenVolume");
+    hiddenVolumeObject->SetLayer(2);
+    auto* hiddenVolumeRenderer = hiddenVolumeObject->AddComponent<VolumeRendererComponent>();
+    VolumeField* hiddenVolume = CreateTestVolumeField("Volumes/hidden.nvdb");
+    Material* hiddenMaterial = CreateTestMaterial(
+        "Materials/hidden_volume.mat",
+        static_cast<int32_t>(MaterialRenderQueue::Geometry));
+    hiddenVolumeRenderer->SetVolumeField(hiddenVolume);
+    hiddenVolumeRenderer->SetMaterial(hiddenMaterial);
+
+    RenderSceneExtractor extractor;
+    const RenderSceneData sceneData = extractor.Extract(scene, nullptr, 800, 600);
+
+    ASSERT_TRUE(sceneData.HasCamera());
+    EXPECT_TRUE(sceneData.visibleItems.empty());
+    ASSERT_EQ(sceneData.visibleVolumes.size(), 2u);
+
+    EXPECT_EQ(sceneData.visibleVolumes[0].gameObject, opaqueVolumeObject);
+    EXPECT_EQ(sceneData.visibleVolumes[0].volumeRenderer, opaqueVolumeRenderer);
+    EXPECT_EQ(sceneData.visibleVolumes[0].volumeField, opaqueVolume);
+    EXPECT_EQ(sceneData.visibleVolumes[0].material, opaqueMaterial);
+    EXPECT_EQ(sceneData.visibleVolumes[0].renderQueue, static_cast<int32_t>(MaterialRenderQueue::Geometry));
+    EXPECT_EQ(sceneData.visibleVolumes[0].localToWorld.GetTranslation(), Vector3(0.0f, 0.0f, 2.0f));
+
+    EXPECT_EQ(sceneData.visibleVolumes[1].gameObject, transparentVolumeObject);
+    EXPECT_EQ(sceneData.visibleVolumes[1].volumeRenderer, transparentVolumeRenderer);
+    EXPECT_EQ(sceneData.visibleVolumes[1].volumeField, transparentVolume);
+    EXPECT_EQ(sceneData.visibleVolumes[1].material, transparentMaterial);
+    EXPECT_EQ(sceneData.visibleVolumes[1].renderQueue, static_cast<int32_t>(MaterialRenderQueue::Transparent));
+    EXPECT_EQ(sceneData.visibleVolumes[1].localToWorld.GetTranslation(), Vector3(0.0f, 0.0f, 8.0f));
+
+    opaqueVolumeRenderer->ClearVolumeField();
+    opaqueVolumeRenderer->ClearMaterial();
+    transparentVolumeRenderer->ClearVolumeField();
+    transparentVolumeRenderer->ClearMaterial();
+    hiddenVolumeRenderer->ClearVolumeField();
+    hiddenVolumeRenderer->ClearMaterial();
+    delete opaqueVolume;
+    delete opaqueMaterial;
+    delete transparentVolume;
+    delete transparentMaterial;
+    delete hiddenVolume;
+    delete hiddenMaterial;
+}
+
 TEST(RenderSceneExtractor_Test, ExtractsSectionLevelVisibleItemsAndSortsByRenderQueue) {
    Scene scene("SectionScene");