Formalize GaussianSplat scene extraction

engine/include/XCEngine/Components/GaussianSplatRendererComponent.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/GaussianSplat/GaussianSplat.h>
+#include <XCEngine/Resources/Material/Material.h>
+
+#include <memory>
+#include <string>
+
+namespace XCEngine {
+namespace Components {
+
+class GaussianSplatRendererComponent : public Component {
+public:
+    std::string GetName() const override { return "GaussianSplatRenderer"; }
+
+    Resources::GaussianSplat* GetGaussianSplat() const;
+    const Resources::ResourceHandle<Resources::GaussianSplat>& GetGaussianSplatHandle() const;
+    const std::string& GetGaussianSplatPath() const { return m_gaussianSplatPath; }
+    const Resources::AssetRef& GetGaussianSplatAssetRef() const { return m_gaussianSplatRef; }
+
+    void SetGaussianSplatPath(const std::string& gaussianSplatPath);
+    void SetGaussianSplat(const Resources::ResourceHandle<Resources::GaussianSplat>& gaussianSplat);
+    void SetGaussianSplat(Resources::GaussianSplat* gaussianSplat);
+    void ClearGaussianSplat();
+
+    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 PendingGaussianSplatLoadState;
+    struct PendingMaterialLoadState;
+
+    void BeginAsyncGaussianSplatLoad(const std::string& gaussianSplatPath);
+    void EnsureDeferredAsyncGaussianSplatLoadStarted();
+    void ResolvePendingGaussianSplat();
+
+    void BeginAsyncMaterialLoad(const std::string& materialPath);
+    void EnsureDeferredAsyncMaterialLoadStarted();
+    void ResolvePendingMaterial();
+
+    Resources::ResourceHandle<Resources::GaussianSplat> m_gaussianSplat;
+    std::string m_gaussianSplatPath;
+    Resources::AssetRef m_gaussianSplatRef;
+    std::shared_ptr<PendingGaussianSplatLoadState> m_pendingGaussianSplatLoad;
+    bool m_asyncGaussianSplatLoadRequested = 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

@@ -42,6 +42,7 @@ private:
         const Math::Vector3& cameraPosition,
         uint32_t cullingMask,
         std::vector<VisibleRenderItem>& outVisibleItems,
+        std::vector<VisibleGaussianSplatItem>& outVisibleGaussianSplats,
         std::vector<VisibleVolumeItem>& outVisibleVolumes) const;
 };
 

engine/include/XCEngine/Rendering/Extraction/RenderSceneUtility.h

@@ -2,6 +2,7 @@
 
 #include <XCEngine/Core/Math/Vector3.h>
 #include <XCEngine/Rendering/FrameData/RenderCameraData.h>
+#include <XCEngine/Rendering/FrameData/VisibleGaussianSplatItem.h>
 #include <XCEngine/Rendering/FrameData/VisibleRenderItem.h>
 #include <XCEngine/Rendering/FrameData/VisibleVolumeItem.h>
 
@@ -33,10 +34,19 @@ void AppendVisibleVolumesForGameObject(
     const Math::Vector3& cameraPosition,
     std::vector<VisibleVolumeItem>& outVisibleVolumes);
 
+void AppendVisibleGaussianSplatsForGameObject(
+    Components::GameObject& gameObject,
+    const Math::Vector3& cameraPosition,
+    std::vector<VisibleGaussianSplatItem>& outVisibleGaussianSplats);
+
 bool CompareVisibleRenderItemsStable(
     const VisibleRenderItem& lhs,
     const VisibleRenderItem& rhs);
 
+bool CompareVisibleGaussianSplatsStable(
+    const VisibleGaussianSplatItem& lhs,
+    const VisibleGaussianSplatItem& rhs);
+
 bool CompareVisibleVolumesStable(
     const VisibleVolumeItem& lhs,
     const VisibleVolumeItem& rhs);

engine/include/XCEngine/Rendering/FrameData/RenderSceneData.h

@@ -4,6 +4,7 @@
 #include <XCEngine/Core/Math/Vector4.h>
 #include <XCEngine/Rendering/FrameData/RenderCameraData.h>
 #include <XCEngine/Rendering/FrameData/RenderEnvironmentData.h>
+#include <XCEngine/Rendering/FrameData/VisibleGaussianSplatItem.h>
 #include <XCEngine/Rendering/FrameData/VisibleRenderItem.h>
 #include <XCEngine/Rendering/FrameData/VisibleVolumeItem.h>
 #include <XCEngine/Resources/Shader/ShaderKeywordTypes.h>
@@ -88,6 +89,7 @@ struct RenderSceneData {
     RenderLightingData lighting;
     Resources::ShaderKeywordSet globalShaderKeywords;
     std::vector<VisibleRenderItem> visibleItems;
+    std::vector<VisibleGaussianSplatItem> visibleGaussianSplats;
     std::vector<VisibleVolumeItem> visibleVolumes;
 
     bool HasCamera() const {

engine/include/XCEngine/Rendering/FrameData/VisibleGaussianSplatItem.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 GaussianSplatRendererComponent;
+} // namespace Components
+
+namespace Resources {
+class GaussianSplat;
+class Material;
+} // namespace Resources
+
+namespace Rendering {
+
+struct VisibleGaussianSplatItem {
+    Components::GameObject* gameObject = nullptr;
+    Components::GaussianSplatRendererComponent* gaussianSplatRenderer = nullptr;
+    Resources::GaussianSplat* gaussianSplat = nullptr;
+    const Resources::Material* material = nullptr;
+    Core::int32 renderQueue = 0;
+    float cameraDistanceSq = 0.0f;
+    Math::Matrix4x4 localToWorld = Math::Matrix4x4::Identity();
+};
+
+} // namespace Rendering
+} // namespace XCEngine