feat(srp): add render layer filtering to scene draw

- carry MeshRenderer renderLayer through scene extraction into VisibleRenderItem
- extend native and managed FilteringSettings with renderLayerMask support
- let RenderObjectsRendererFeature author layer-filtered object draws

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

@@ -26,12 +26,14 @@ enum class RendererSortMode : Core::uint32 {
 struct FilteringSettings {
     Core::int32 renderQueueMin = std::numeric_limits<Core::int32>::lowest();
     Core::int32 renderQueueMax = std::numeric_limits<Core::int32>::max();
+    Core::uint32 renderLayerMask = std::numeric_limits<Core::uint32>::max();
     bool requireShadowCasting = false;
     bool requireRenderObjectId = false;
 
     bool operator==(const FilteringSettings& other) const {
         return renderQueueMin == other.renderQueueMin &&
                renderQueueMax == other.renderQueueMax &&
+               renderLayerMask == other.renderLayerMask &&
                requireShadowCasting == other.requireShadowCasting &&
                requireRenderObjectId == other.requireRenderObjectId;
     }

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

@@ -72,6 +72,12 @@ inline bool MatchesFilteringSettings(
         return false;
     }
 
+    if (visibleItem.renderLayer >= 32u ||
+        ((filtering.renderLayerMask &
+          (1u << visibleItem.renderLayer)) == 0u)) {
+        return false;
+    }
+
     if (filtering.requireShadowCasting &&
         visibleItem.meshRenderer != nullptr &&
         !visibleItem.meshRenderer->GetCastShadows()) {

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

@@ -24,6 +24,7 @@ struct VisibleRenderItem {
     Core::uint32 materialIndex = 0;
     Core::uint32 sectionIndex = 0;
     bool hasSection = false;
+    Core::uint32 renderLayer = 0;
     Core::int32 renderQueue = 0;
     float cameraDistanceSq = 0.0f;
     Math::Matrix4x4 localToWorld = Math::Matrix4x4::Identity();

engine/src/Rendering/Extraction/RenderSceneUtility.cpp

@@ -116,6 +116,7 @@ void AppendRenderItemsForGameObject(
             visibleItem.renderObjectId = renderObjectId;
             visibleItem.sectionIndex = static_cast<Core::uint32>(sectionIndex);
             visibleItem.hasSection = true;
+            visibleItem.renderLayer = meshRenderer->GetRenderLayer();
             visibleItem.material = ResolveMaterial(meshRenderer, mesh, section.materialID);
             visibleItem.renderQueue = ResolveMaterialRenderQueue(visibleItem.material);
             visibleItem.cameraDistanceSq = cameraDistanceSq;
@@ -134,6 +135,7 @@ void AppendRenderItemsForGameObject(
     visibleItem.materialIndex = 0;
     visibleItem.sectionIndex = 0;
     visibleItem.hasSection = false;
+    visibleItem.renderLayer = meshRenderer->GetRenderLayer();
     visibleItem.material = ResolveMaterial(meshRenderer, mesh, 0);
     visibleItem.renderQueue = ResolveMaterialRenderQueue(visibleItem.material);
     visibleItem.cameraDistanceSq = cameraDistanceSq;

engine/src/Scripting/Mono/MonoScriptRuntime.cpp

@@ -932,9 +932,9 @@ static_assert(
 struct ManagedFilteringSettingsData {
     int32_t renderQueueMin = std::numeric_limits<int32_t>::lowest();
     int32_t renderQueueMax = std::numeric_limits<int32_t>::max();
+    uint32_t renderLayerMask = std::numeric_limits<uint32_t>::max();
     uint8_t requireShadowCasting = 0u;
     uint8_t requireRenderObjectId = 0u;
-    uint8_t padding[2] = {};
 };
 
 static_assert(

managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/RenderObjectsRendererFeature.cs

@@ -17,6 +17,8 @@ namespace XCEngine.Rendering.Universal
         public bool overrideRenderQueueRange;
         public RenderQueueRange renderQueueRange =
             RenderQueueRange.Opaque;
+        public bool overrideRenderLayerMask;
+        public uint renderLayerMask = uint.MaxValue;
         public bool overrideFilteringSettings;
         public FilteringSettings filteringSettings;
         public bool overrideSortingSettings;
@@ -82,6 +84,12 @@ namespace XCEngine.Rendering.Universal
                     renderQueueRange;
             }
 
+            if (overrideRenderLayerMask)
+            {
+                rendererListDesc.filtering.renderLayerMask =
+                    renderLayerMask;
+            }
+
             if (overrideSortingSettings)
             {
                 rendererListDesc.sorting =

managed/XCEngine.ScriptCore/Rendering/Core/FilteringSettings.cs

@@ -7,6 +7,7 @@ namespace XCEngine.Rendering
     {
         public int renderQueueMin;
         public int renderQueueMax;
+        public uint renderLayerMask;
 
         [MarshalAs(UnmanagedType.I1)]
         public bool requireShadowCasting;
@@ -34,7 +35,8 @@ namespace XCEngine.Rendering
         {
             return new FilteringSettings
             {
-                renderQueueRange = renderQueueRange
+                renderQueueRange = renderQueueRange,
+                renderLayerMask = uint.MaxValue
             };
         }
 

project/Assets/Scripts/ProjectRenderPipelineProbe.cs

@@ -142,6 +142,8 @@ namespace ProjectScripts
                             overrideRenderQueueRange = true,
                             renderQueueRange =
                                 RenderQueueRange.Opaque,
+                            overrideRenderLayerMask = true,
+                            renderLayerMask = 1u << 0,
                             rendererListType =
                                 RendererListType.Opaque
                         }