Add volume renderer extraction stage 5

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

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

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,

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;

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