From f75164a4fa063e0478a669d79831c85786eecd32 Mon Sep 17 00:00:00 2001 From: ssdfasd <2156608475@qq.com> Date: Tue, 21 Apr 2026 18:05:33 +0800 Subject: [PATCH] refactor(srp): move scene setup ownership into managed renderer --- ...enderSceneSetupPlan_完成归档_2026-04-21.md | 97 +++++ .../ManagedScriptableRenderPipelineAsset.h | 13 +- .../XCEngine/Rendering/RenderPipeline.h | 5 + .../Scripting/Mono/MonoScriptRuntime.h | 5 + .../Internal/RenderPipelineFactory.cpp | 106 +---- .../Internal/RenderPipelineFactory.h | 14 - .../ScriptableRenderPipelineHost.cpp | 35 +- engine/src/Rendering/RenderPipeline.cpp | 14 +- .../src/Scripting/Mono/MonoScriptRuntime.cpp | 381 ++++++++++++++---- managed/CMakeLists.txt | 1 + .../RendererBackedRenderPipelineAsset.cs | 45 +-- .../Rendering/Universal/ScriptableRenderer.cs | 11 + .../Universal/ScriptableRendererData.cs | 48 ++- .../Universal/ScriptableRendererFeature.cs | 5 + .../Rendering/Universal/UniversalRenderer.cs | 11 + .../Universal/UniversalRendererData.cs | 5 - managed/XCEngine.ScriptCore/InternalCalls.cs | 40 ++ .../Rendering/Core/RenderSceneSetupContext.cs | 67 +++ .../Core/ScriptableRenderPipelineAsset.cs | 12 + 19 files changed, 623 insertions(+), 292 deletions(-) create mode 100644 docs/used/SRP_URP_ManagedRenderSceneSetupPlan_完成归档_2026-04-21.md create mode 100644 managed/XCEngine.ScriptCore/Rendering/Core/RenderSceneSetupContext.cs diff --git a/docs/used/SRP_URP_ManagedRenderSceneSetupPlan_完成归档_2026-04-21.md b/docs/used/SRP_URP_ManagedRenderSceneSetupPlan_完成归档_2026-04-21.md new file mode 100644 index 00000000..c11bb5fe --- /dev/null +++ b/docs/used/SRP_URP_ManagedRenderSceneSetupPlan_完成归档_2026-04-21.md @@ -0,0 +1,97 @@ +# SRP/URP Managed RenderSceneSetup Plan + +日期：2026-04-21 + +## 背景 + +当前 `RenderSceneData` 的 scene setup 仍然主要通过 native policy key +`BuiltinDefaultSceneSetup` 组织： + +- `ScriptableRenderPipelineHost::ConfigureRenderSceneData(...)` + 先向 managed 资产查询字符串 key。 +- `UniversalRendererData` 仍然通过 + `GetRenderSceneSetupPolicyAssetKey()` 返回 + `BuiltinDefaultSceneSetup`。 +- 真正的默认行为仍然落在 native + `ApplyDefaultRenderPipelineSceneSetupPolicy(...)`。 + +这条路径的问题不是功能不对，而是所有权不对： + +- `URP` 默认行为没有显式挂在 managed `renderer` 上。 +- host 仍然依赖字符串分发，而不是显式回调。 +- 这和前面已经完成的 shadow/depth-prepass 接缝上提方向不一致。 + +## 目标 + +本阶段把 scene setup 的默认所有权从 native policy key +切换到 managed `SRP/URP` 显式回调，方向和前面的 +`DirectionalShadowExecutionContext` 一致： + +- C++ 保留默认 scene setup 实现，作为 substrate/fallback。 +- managed 新增 `RenderSceneSetupContext`。 +- `ScriptableRenderPipelineHost` 优先调用 managed 显式配置。 +- `RendererBackedRenderPipelineAsset -> ScriptableRendererData -> UniversalRenderer` + 形成明确的默认 scene setup 所有权链路。 +- 清理 managed 侧 `BuiltinDefaultSceneSetup` 字符串接缝。 + +## 实施步骤 + +1. 新增 native/managed `RenderSceneSetupContext` + +- native 维护 context state registry。 +- 暴露最小必要 API： + - `rendererIndex` + - `isConfigured` + - `UseDefaultSceneSetup()` + - `UseDefaultEnvironment()` + - `UseDefaultGlobalShaderKeywords()` + - `ClearEnvironment()` + - `ClearGlobalShaderKeywords()` + - `ClearSceneSetup()` + +2. 改造 `ManagedRenderPipelineAssetRuntime` + +- 新增 `ConfigureRenderSceneSetup(...)` 显式回调。 +- `ScriptableRenderPipelineHost::ConfigureRenderSceneData(...)` + 改为： + - 先尝试 managed explicit setup + - 未配置时再回退 native 默认实现 + +3. 改造 managed SRP/URP 链路 + +- `ScriptableRenderPipelineAsset` + 增加 `ConfigureRenderSceneSetup(...)` hook。 +- `RendererBackedRenderPipelineAsset` + 将请求分派到当前 `ScriptableRendererData`。 +- `ScriptableRendererData` / `ScriptableRenderer` + 增加对应 hook。 +- `UniversalRenderer` + 显式调用 `context.UseDefaultSceneSetup()`， + 让 URP 默认 scene setup 所有权落到 renderer。 + +4. 清理旧接缝 + +- 删除 managed 侧： + - `GetRenderSceneSetupPolicyAssetKey()` + - `GetRenderSceneSetupPolicyAssetKeyContextual()` +- 删除 host 对 `BuiltinDefaultSceneSetup` 的主路径依赖。 +- 若 native registry 无剩余使用点，则同步清理 + `RenderSceneSetupPolicy` registry。 + +## 验收标准 + +- `UniversalRendererData` 不再暴露 + `BuiltinDefaultSceneSetup` 字符串接缝。 +- `ScriptableRenderPipelineHost` 的 scene setup + 主路径为 managed explicit callback。 +- 默认场景渲染行为不回归。 +- `cmake --build . --config Debug --target XCEditor` + 通过。 +- 旧 `editor/bin/Debug/XCEngine.exe` + 冒烟至少 10 秒并在 `editor.log` 中出现新的 `SceneReady`。 + +## 完成后下一步 + +scene setup 接缝上提完成后，`SRP/URP` 这条主线会继续收紧 +managed 对 camera/light/environment 默认组织的所有权， +再进入下一批更贴近 Unity `URP` 的 renderer capability 收口。 diff --git a/engine/include/XCEngine/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h b/engine/include/XCEngine/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h index 86cbf539..0ed6822a 100644 --- a/engine/include/XCEngine/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h +++ b/engine/include/XCEngine/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h @@ -88,6 +88,11 @@ public: } virtual void ConfigureCameraFramePlan(CameraFramePlan&) const { } + virtual bool ConfigureRenderSceneSetup( + const CameraFramePlan&, + RenderSceneData&) const { + return false; + } virtual bool ConfigureDirectionalShadowExecutionState( const CameraFramePlan&, const DirectionalShadowSurfaceAllocation&, @@ -112,14 +117,6 @@ public: (void)rendererIndex; return UsesNativeCameraFramePlanBaseline(); } - virtual std::string GetRenderSceneSetupPolicyAssetKey() const { - return {}; - } - virtual std::string GetRenderSceneSetupPolicyAssetKey( - int32_t rendererIndex) const { - (void)rendererIndex; - return GetRenderSceneSetupPolicyAssetKey(); - } virtual std::string GetCameraFrameStandalonePassAssetKey( CameraFrameStage stage) const { (void)stage; diff --git a/engine/include/XCEngine/Rendering/RenderPipeline.h b/engine/include/XCEngine/Rendering/RenderPipeline.h index 0879133b..93ff3431 100644 --- a/engine/include/XCEngine/Rendering/RenderPipeline.h +++ b/engine/include/XCEngine/Rendering/RenderPipeline.h @@ -25,6 +25,11 @@ struct CameraFramePlan; struct DirectionalShadowExecutionState; struct DirectionalShadowSurfaceAllocation; +Resources::ShaderKeywordSet +BuildDefaultRenderPipelineSceneGlobalShaderKeywords( + const RenderSceneData& sceneData); +RenderEnvironmentData BuildDefaultRenderPipelineEnvironmentData( + const CameraFramePlan& plan); void ApplyDefaultRenderPipelineDirectionalShadowExecutionPolicy( const CameraFramePlan& plan, const DirectionalShadowSurfaceAllocation& shadowAllocation, diff --git a/engine/include/XCEngine/Scripting/Mono/MonoScriptRuntime.h b/engine/include/XCEngine/Scripting/Mono/MonoScriptRuntime.h index 96e054ee..c435dd1c 100644 --- a/engine/include/XCEngine/Scripting/Mono/MonoScriptRuntime.h +++ b/engine/include/XCEngine/Scripting/Mono/MonoScriptRuntime.h @@ -266,6 +266,8 @@ private: MonoObject* CreateManagedScriptableRenderContext(uint64_t nativeHandle); MonoObject* CreateManagedCameraRenderRequestContext( uint64_t nativeHandle); + MonoObject* CreateManagedRenderSceneSetupContext( + uint64_t nativeHandle); MonoObject* CreateManagedDirectionalShadowExecutionContext( uint64_t nativeHandle); MonoObject* CreateManagedScriptableRenderPipelinePlanningContext( @@ -310,6 +312,7 @@ private: MonoClass* m_scriptableRenderPipelineClass = nullptr; MonoClass* m_scriptableRenderContextClass = nullptr; MonoClass* m_cameraRenderRequestContextClass = nullptr; + MonoClass* m_renderSceneSetupContextClass = nullptr; MonoClass* m_directionalShadowExecutionContextClass = nullptr; MonoClass* m_scriptableRenderPipelinePlanningContextClass = nullptr; MonoClass* m_serializeFieldAttributeClass = nullptr; @@ -317,6 +320,8 @@ private: MonoMethod* m_scriptableRenderContextConstructor = nullptr; MonoMethod* m_cameraRenderRequestContextConstructor = nullptr; + MonoMethod* m_renderSceneSetupContextConstructor = + nullptr; MonoMethod* m_directionalShadowExecutionContextConstructor = nullptr; MonoMethod* m_scriptableRenderPipelinePlanningContextConstructor = diff --git a/engine/src/Rendering/Internal/RenderPipelineFactory.cpp b/engine/src/Rendering/Internal/RenderPipelineFactory.cpp index b906ce84..d9f60046 100644 --- a/engine/src/Rendering/Internal/RenderPipelineFactory.cpp +++ b/engine/src/Rendering/Internal/RenderPipelineFactory.cpp @@ -49,8 +49,6 @@ using DirectionalShadowPlanningPolicyRegistry = std::unordered_map; using CameraFramePlanPolicyRegistry = std::unordered_map; -using RenderSceneSetupPolicyRegistry = - std::unordered_map; using DirectionalShadowExecutionPolicyRegistry = std::unordered_map; @@ -70,18 +68,11 @@ GetDirectionalShadowPlanningPolicyRegistry() { return registry; } -CameraFramePlanPolicyRegistry& -GetCameraFramePlanPolicyRegistry() { +CameraFramePlanPolicyRegistry& GetCameraFramePlanPolicyRegistry() { static CameraFramePlanPolicyRegistry registry = {}; return registry; } -RenderSceneSetupPolicyRegistry& -GetRenderSceneSetupPolicyRegistry() { - static RenderSceneSetupPolicyRegistry registry = {}; - return registry; -} - DirectionalShadowExecutionPolicyRegistry& GetDirectionalShadowExecutionPolicyRegistry() { static DirectionalShadowExecutionPolicyRegistry registry = {}; @@ -108,11 +99,6 @@ std::unordered_set& GetBuiltinCameraFramePlanPolicyKeys() { return builtinKeys; } -std::unordered_set& GetBuiltinRenderSceneSetupPolicyKeys() { - static std::unordered_set builtinKeys = {}; - return builtinKeys; -} - std::unordered_set& GetBuiltinDirectionalShadowExecutionPolicyKeys() { static std::unordered_set builtinKeys = {}; @@ -139,11 +125,6 @@ std::mutex& GetCameraFramePlanPolicyRegistryMutex() { return mutex; } -std::mutex& GetRenderSceneSetupPolicyRegistryMutex() { - static std::mutex mutex; - return mutex; -} - std::mutex& GetDirectionalShadowExecutionPolicyRegistryMutex() { static std::mutex mutex; return mutex; @@ -227,25 +208,6 @@ void EnsureBuiltinCameraFramePlanPolicyRegistryInitialized() { (void)initialized; } -void EnsureBuiltinRenderSceneSetupPolicyRegistryInitialized() { - static const bool initialized = []() { - RenderSceneSetupPolicyRegistry& registry = - GetRenderSceneSetupPolicyRegistry(); - registry.emplace( - "BuiltinDefaultSceneSetup", - [](const CameraFramePlan& plan, - RenderSceneData& sceneData) { - ApplyDefaultRenderPipelineSceneSetupPolicy( - plan, - sceneData); - }); - GetBuiltinRenderSceneSetupPolicyKeys().insert( - "BuiltinDefaultSceneSetup"); - return true; - }(); - (void)initialized; -} - void EnsureBuiltinDirectionalShadowExecutionPolicyRegistryInitialized() { static const bool initialized = []() { DirectionalShadowExecutionPolicyRegistry& registry = @@ -557,72 +519,6 @@ bool ApplyCameraFramePlanPolicyByKey( return true; } -bool RegisterRenderSceneSetupPolicy( - const std::string& key, - RenderSceneSetupPolicy policy) { - if (key.empty() || !policy) { - return false; - } - - EnsureBuiltinRenderSceneSetupPolicyRegistryInitialized(); - - std::lock_guard lock( - GetRenderSceneSetupPolicyRegistryMutex()); - RenderSceneSetupPolicyRegistry& registry = - GetRenderSceneSetupPolicyRegistry(); - if (registry.find(key) != registry.end()) { - return false; - } - - registry.emplace(key, std::move(policy)); - return true; -} - -bool UnregisterRenderSceneSetupPolicy( - const std::string& key) { - if (key.empty()) { - return false; - } - - EnsureBuiltinRenderSceneSetupPolicyRegistryInitialized(); - - std::lock_guard lock( - GetRenderSceneSetupPolicyRegistryMutex()); - if (GetBuiltinRenderSceneSetupPolicyKeys().find(key) != - GetBuiltinRenderSceneSetupPolicyKeys().end()) { - return false; - } - - RenderSceneSetupPolicyRegistry& registry = - GetRenderSceneSetupPolicyRegistry(); - return registry.erase(key) != 0u; -} - -bool ApplyRenderSceneSetupPolicyByKey( - const std::string& key, - const CameraFramePlan& plan, - RenderSceneData& sceneData) { - if (key.empty()) { - return false; - } - - EnsureBuiltinRenderSceneSetupPolicyRegistryInitialized(); - - std::lock_guard lock( - GetRenderSceneSetupPolicyRegistryMutex()); - const RenderSceneSetupPolicyRegistry& registry = - GetRenderSceneSetupPolicyRegistry(); - const auto it = registry.find(key); - if (it == registry.end() || !it->second) { - return false; - } - - it->second( - plan, - sceneData); - return true; -} - bool RegisterDirectionalShadowExecutionPolicy( const std::string& key, DirectionalShadowExecutionPolicy policy) { diff --git a/engine/src/Rendering/Internal/RenderPipelineFactory.h b/engine/src/Rendering/Internal/RenderPipelineFactory.h index f453dabb..05f43f0b 100644 --- a/engine/src/Rendering/Internal/RenderPipelineFactory.h +++ b/engine/src/Rendering/Internal/RenderPipelineFactory.h @@ -14,7 +14,6 @@ class RenderPass; struct CameraRenderRequest; struct CameraFramePlan; struct FinalColorSettings; -struct RenderSceneData; struct DirectionalShadowPlanningSettings; struct DirectionalShadowExecutionState; struct DirectionalShadowSurfaceAllocation; @@ -35,10 +34,6 @@ using CameraFramePlanPolicy = std::function; -using RenderSceneSetupPolicy = - std::function; using DirectionalShadowExecutionPolicy = std::functionGetRenderSceneSetupPolicyAssetKey( - plan.request.rendererIndex); - if (assetKey.empty()) { - RenderPipeline::ConfigureRenderSceneData( - plan, - sceneData); - return; - } - - if (!Rendering::Internal::ApplyRenderSceneSetupPolicyByKey( - assetKey, + if (m_managedAssetRuntime != nullptr && + m_managedAssetRuntime->ConfigureRenderSceneSetup( plan, sceneData)) { - Debug::Logger::Get().Error( - Debug::LogCategory::Rendering, - Containers::String( - "ScriptableRenderPipelineHost failed to resolve render scene setup policy asset key: ") + - assetKey.c_str()); - RenderPipeline::ConfigureRenderSceneData( - plan, - sceneData); + return; } + + RenderPipeline::ConfigureRenderSceneData( + plan, + sceneData); } bool ScriptableRenderPipelineHost::ConfigureDirectionalShadowExecutionState( diff --git a/engine/src/Rendering/RenderPipeline.cpp b/engine/src/Rendering/RenderPipeline.cpp index ef384fab..c83835e8 100644 --- a/engine/src/Rendering/RenderPipeline.cpp +++ b/engine/src/Rendering/RenderPipeline.cpp @@ -10,9 +10,8 @@ namespace XCEngine { namespace Rendering { -namespace { - -Resources::ShaderKeywordSet BuildDefaultSceneGlobalShaderKeywords( +Resources::ShaderKeywordSet +BuildDefaultRenderPipelineSceneGlobalShaderKeywords( const RenderSceneData& sceneData) { Resources::ShaderKeywordSet keywords = {}; if (sceneData.lighting.HasMainDirectionalShadow()) { @@ -23,7 +22,8 @@ Resources::ShaderKeywordSet BuildDefaultSceneGlobalShaderKeywords( return keywords; } -RenderEnvironmentData BuildDefaultEnvironmentData(const CameraFramePlan& plan) { +RenderEnvironmentData BuildDefaultRenderPipelineEnvironmentData( + const CameraFramePlan& plan) { RenderEnvironmentData environment = {}; const RenderSurface& mainSceneSurface = plan.GetMainSceneSurface(); if (plan.request.camera == nullptr || @@ -47,8 +47,6 @@ RenderEnvironmentData BuildDefaultEnvironmentData(const CameraFramePlan& plan) { return environment; } -} // namespace - void RenderPipeline::ConfigureRenderSceneData( const CameraFramePlan& plan, RenderSceneData& sceneData) const { @@ -61,9 +59,9 @@ void ApplyDefaultRenderPipelineSceneSetupPolicy( const CameraFramePlan& plan, RenderSceneData& sceneData) { sceneData.globalShaderKeywords = - BuildDefaultSceneGlobalShaderKeywords(sceneData); + BuildDefaultRenderPipelineSceneGlobalShaderKeywords(sceneData); sceneData.environment = - BuildDefaultEnvironmentData(plan); + BuildDefaultRenderPipelineEnvironmentData(plan); } void ApplyDefaultRenderPipelineDirectionalShadowExecutionPolicy( diff --git a/engine/src/Scripting/Mono/MonoScriptRuntime.cpp b/engine/src/Scripting/Mono/MonoScriptRuntime.cpp index 09e6c31d..891823e6 100644 --- a/engine/src/Scripting/Mono/MonoScriptRuntime.cpp +++ b/engine/src/Scripting/Mono/MonoScriptRuntime.cpp @@ -137,6 +137,13 @@ struct ManagedCameraRenderRequestContextState { bool suppressDirectionalShadow = false; }; +struct ManagedRenderSceneSetupContextState { + uint64_t handle = 0; + const Rendering::CameraFramePlan* plan = nullptr; + Rendering::RenderSceneData* sceneData = nullptr; + bool explicitlyConfigured = false; +}; + struct ManagedDirectionalShadowExecutionContextState { uint64_t handle = 0; const Rendering::CameraFramePlan* plan = nullptr; @@ -529,6 +536,52 @@ void UnregisterManagedCameraRenderRequestContextState( GetManagedCameraRenderRequestContextRegistry().erase(handle); } +uint64_t& GetManagedRenderSceneSetupContextNextHandle() { + static uint64_t nextHandle = 1; + return nextHandle; +} + +std::unordered_map& +GetManagedRenderSceneSetupContextRegistry() { + static std::unordered_map + registry; + return registry; +} + +ManagedRenderSceneSetupContextState* +FindManagedRenderSceneSetupContextState( + uint64_t handle) { + const auto it = + GetManagedRenderSceneSetupContextRegistry().find(handle); + return it != GetManagedRenderSceneSetupContextRegistry().end() + ? it->second + : nullptr; +} + +uint64_t RegisterManagedRenderSceneSetupContextState( + ManagedRenderSceneSetupContextState& state) { + uint64_t handle = + GetManagedRenderSceneSetupContextNextHandle()++; + if (handle == 0) { + handle = + GetManagedRenderSceneSetupContextNextHandle()++; + } + + state.handle = handle; + GetManagedRenderSceneSetupContextRegistry()[handle] = + &state; + return handle; +} + +void UnregisterManagedRenderSceneSetupContextState( + uint64_t handle) { + if (handle == 0) { + return; + } + + GetManagedRenderSceneSetupContextRegistry().erase(handle); +} + uint64_t& GetManagedDirectionalShadowExecutionContextNextHandle() { static uint64_t nextHandle = 1; return nextHandle; @@ -1433,6 +1486,9 @@ public: directionalShadowSettings) const override; void ConfigureCameraFramePlan( Rendering::CameraFramePlan& plan) const override; + bool ConfigureRenderSceneSetup( + const Rendering::CameraFramePlan& plan, + Rendering::RenderSceneData& sceneData) const override; bool ConfigureDirectionalShadowExecutionState( const Rendering::CameraFramePlan& plan, const Rendering::DirectionalShadowSurfaceAllocation& @@ -1449,10 +1505,6 @@ public: bool UsesNativeCameraFramePlanBaseline() const override; bool UsesNativeCameraFramePlanBaseline( int32_t rendererIndex) const override; - std::string GetRenderSceneSetupPolicyAssetKey() const - override; - std::string GetRenderSceneSetupPolicyAssetKey( - int32_t rendererIndex) const override; std::string GetDirectionalShadowPlanningPolicyAssetKey() const override; std::string GetCameraFrameStandalonePassAssetKey( @@ -1498,9 +1550,7 @@ private: MonoObject* assetObject) const; MonoMethod* ResolveUsesNativeCameraFramePlanBaselineContextualMethod( MonoObject* assetObject) const; - MonoMethod* ResolveGetRenderSceneSetupPolicyAssetKeyMethod( - MonoObject* assetObject) const; - MonoMethod* ResolveGetRenderSceneSetupPolicyAssetKeyContextualMethod( + MonoMethod* ResolveConfigureRenderSceneSetupMethod( MonoObject* assetObject) const; MonoMethod* ResolveConfigureDirectionalShadowExecutionStateMethod( MonoObject* assetObject) const; @@ -1532,11 +1582,8 @@ private: mutable MonoMethod* m_usesNativeCameraFramePlanBaselineContextualMethod = nullptr; - mutable MonoMethod* m_getRenderSceneSetupPolicyAssetKeyMethod = + mutable MonoMethod* m_configureRenderSceneSetupMethod = nullptr; - mutable MonoMethod* - m_getRenderSceneSetupPolicyAssetKeyContextualMethod = - nullptr; mutable MonoMethod* m_configureDirectionalShadowExecutionStateMethod = nullptr; mutable MonoMethod* @@ -2061,6 +2108,46 @@ void MonoManagedRenderPipelineAssetRuntime::ConfigureCameraFramePlan( planningContextHandle); } +bool MonoManagedRenderPipelineAssetRuntime::ConfigureRenderSceneSetup( + const Rendering::CameraFramePlan& plan, + Rendering::RenderSceneData& sceneData) const { + if (!EnsureManagedAsset()) { + return false; + } + + MonoObject* const assetObject = GetManagedAssetObject(); + MonoMethod* const method = + ResolveConfigureRenderSceneSetupMethod(assetObject); + if (assetObject == nullptr || method == nullptr) { + return false; + } + + ManagedRenderSceneSetupContextState setupContextState = {}; + setupContextState.plan = &plan; + setupContextState.sceneData = &sceneData; + const uint64_t setupContextHandle = + RegisterManagedRenderSceneSetupContextState( + setupContextState); + MonoObject* const setupContextObject = + m_runtime->CreateManagedRenderSceneSetupContext( + setupContextHandle); + if (setupContextObject == nullptr) { + UnregisterManagedRenderSceneSetupContextState( + setupContextHandle); + return false; + } + + void* args[1] = { setupContextObject }; + m_runtime->InvokeManagedMethod( + assetObject, + method, + args, + nullptr); + UnregisterManagedRenderSceneSetupContextState( + setupContextHandle); + return setupContextState.explicitlyConfigured; +} + bool MonoManagedRenderPipelineAssetRuntime:: ConfigureDirectionalShadowExecutionState( const Rendering::CameraFramePlan& plan, @@ -2298,61 +2385,6 @@ bool MonoManagedRenderPipelineAssetRuntime::UsesNativeCameraFramePlanBaseline( usesBaseline; } -std::string MonoManagedRenderPipelineAssetRuntime:: - GetRenderSceneSetupPolicyAssetKey() const { - return GetRenderSceneSetupPolicyAssetKey(-1); -} - -std::string MonoManagedRenderPipelineAssetRuntime:: - GetRenderSceneSetupPolicyAssetKey( - int32_t rendererIndex) const { - if (!SyncManagedAssetRuntimeState()) { - return {}; - } - - MonoObject* const assetObject = GetManagedAssetObject(); - if (assetObject == nullptr) { - return {}; - } - - MonoMethod* const contextualMethod = - ResolveGetRenderSceneSetupPolicyAssetKeyContextualMethod( - assetObject); - if (contextualMethod != nullptr) { - void* args[1] = { &rendererIndex }; - MonoObject* managedKeyObject = nullptr; - if (!m_runtime->InvokeManagedMethod( - assetObject, - contextualMethod, - args, - &managedKeyObject)) { - return {}; - } - - return MonoStringToUtf8( - reinterpret_cast(managedKeyObject)); - } - - MonoMethod* const method = - ResolveGetRenderSceneSetupPolicyAssetKeyMethod( - assetObject); - if (method == nullptr) { - return {}; - } - - MonoObject* managedKeyObject = nullptr; - if (!m_runtime->InvokeManagedMethod( - assetObject, - method, - nullptr, - &managedKeyObject)) { - return {}; - } - - return MonoStringToUtf8( - reinterpret_cast(managedKeyObject)); -} - std::string MonoManagedRenderPipelineAssetRuntime:: GetDirectionalShadowPlanningPolicyAssetKey() const { if (!SyncManagedAssetRuntimeState()) { @@ -2659,8 +2691,7 @@ void MonoManagedRenderPipelineAssetRuntime::ReleaseManagedAsset() const { m_getPipelineRendererAssetKeyContextualMethod = nullptr; m_usesNativeCameraFramePlanBaselineMethod = nullptr; m_usesNativeCameraFramePlanBaselineContextualMethod = nullptr; - m_getRenderSceneSetupPolicyAssetKeyMethod = nullptr; - m_getRenderSceneSetupPolicyAssetKeyContextualMethod = nullptr; + m_configureRenderSceneSetupMethod = nullptr; m_configureDirectionalShadowExecutionStateMethod = nullptr; m_getDirectionalShadowPlanningPolicyAssetKeyMethod = nullptr; m_getCameraFrameStandalonePassAssetKeyMethod = nullptr; @@ -2846,33 +2877,17 @@ MonoManagedRenderPipelineAssetRuntime:: MonoMethod* MonoManagedRenderPipelineAssetRuntime:: - ResolveGetRenderSceneSetupPolicyAssetKeyMethod( + ResolveConfigureRenderSceneSetupMethod( MonoObject* assetObject) const { - if (m_getRenderSceneSetupPolicyAssetKeyMethod == nullptr) { - m_getRenderSceneSetupPolicyAssetKeyMethod = + if (m_configureRenderSceneSetupMethod == nullptr) { + m_configureRenderSceneSetupMethod = m_runtime->ResolveManagedMethod( assetObject, - "GetRenderSceneSetupPolicyAssetKey", - 0); - } - - return m_getRenderSceneSetupPolicyAssetKeyMethod; -} - -MonoMethod* -MonoManagedRenderPipelineAssetRuntime:: - ResolveGetRenderSceneSetupPolicyAssetKeyContextualMethod( - MonoObject* assetObject) const { - if (m_getRenderSceneSetupPolicyAssetKeyContextualMethod == - nullptr) { - m_getRenderSceneSetupPolicyAssetKeyContextualMethod = - m_runtime->ResolveManagedMethod( - assetObject, - "GetRenderSceneSetupPolicyAssetKeyContextual", + "ConfigureRenderSceneSetupInstance", 1); } - return m_getRenderSceneSetupPolicyAssetKeyContextualMethod; + return m_configureRenderSceneSetupMethod; } MonoMethod* @@ -5806,6 +5821,119 @@ void InternalCall_Rendering_CameraRenderRequestContext_ClearDirectionalShadow( state->suppressDirectionalShadow = true; } +int32_t +InternalCall_Rendering_RenderSceneSetupContext_GetRendererIndex( + uint64_t nativeHandle) { + const ManagedRenderSceneSetupContextState* const state = + FindManagedRenderSceneSetupContextState(nativeHandle); + return state != nullptr && + state->plan != nullptr + ? state->plan->request.rendererIndex + : -1; +} + +mono_bool +InternalCall_Rendering_RenderSceneSetupContext_GetIsConfigured( + uint64_t nativeHandle) { + const ManagedRenderSceneSetupContextState* const state = + FindManagedRenderSceneSetupContextState(nativeHandle); + return state != nullptr && + state->explicitlyConfigured + ? 1 + : 0; +} + +mono_bool +InternalCall_Rendering_RenderSceneSetupContext_UseDefaultSceneSetup( + uint64_t nativeHandle) { + ManagedRenderSceneSetupContextState* const state = + FindManagedRenderSceneSetupContextState(nativeHandle); + if (state == nullptr || + state->plan == nullptr || + state->sceneData == nullptr) { + return 0; + } + + Rendering::ApplyDefaultRenderPipelineSceneSetupPolicy( + *state->plan, + *state->sceneData); + state->explicitlyConfigured = true; + return 1; +} + +mono_bool +InternalCall_Rendering_RenderSceneSetupContext_UseDefaultEnvironment( + uint64_t nativeHandle) { + ManagedRenderSceneSetupContextState* const state = + FindManagedRenderSceneSetupContextState(nativeHandle); + if (state == nullptr || + state->plan == nullptr || + state->sceneData == nullptr) { + return 0; + } + + state->sceneData->environment = + Rendering::BuildDefaultRenderPipelineEnvironmentData( + *state->plan); + state->explicitlyConfigured = true; + return 1; +} + +mono_bool +InternalCall_Rendering_RenderSceneSetupContext_UseDefaultGlobalShaderKeywords( + uint64_t nativeHandle) { + ManagedRenderSceneSetupContextState* const state = + FindManagedRenderSceneSetupContextState(nativeHandle); + if (state == nullptr || state->sceneData == nullptr) { + return 0; + } + + state->sceneData->globalShaderKeywords = + Rendering:: + BuildDefaultRenderPipelineSceneGlobalShaderKeywords( + *state->sceneData); + state->explicitlyConfigured = true; + return 1; +} + +void InternalCall_Rendering_RenderSceneSetupContext_ClearEnvironment( + uint64_t nativeHandle) { + ManagedRenderSceneSetupContextState* const state = + FindManagedRenderSceneSetupContextState(nativeHandle); + if (state == nullptr || state->sceneData == nullptr) { + return; + } + + state->sceneData->environment = {}; + state->explicitlyConfigured = true; +} + +void +InternalCall_Rendering_RenderSceneSetupContext_ClearGlobalShaderKeywords( + uint64_t nativeHandle) { + ManagedRenderSceneSetupContextState* const state = + FindManagedRenderSceneSetupContextState(nativeHandle); + if (state == nullptr || state->sceneData == nullptr) { + return; + } + + state->sceneData->globalShaderKeywords = {}; + state->explicitlyConfigured = true; +} + +void InternalCall_Rendering_RenderSceneSetupContext_ClearSceneSetup( + uint64_t nativeHandle) { + ManagedRenderSceneSetupContextState* const state = + FindManagedRenderSceneSetupContextState(nativeHandle); + if (state == nullptr || state->sceneData == nullptr) { + return; + } + + state->sceneData->environment = {}; + state->sceneData->globalShaderKeywords = {}; + state->explicitlyConfigured = true; +} + mono_bool InternalCall_Rendering_DirectionalShadowExecutionContext_GetHasPlannedMainDirectionalShadow( uint64_t nativeHandle) { @@ -6332,6 +6460,14 @@ void RegisterInternalCalls() { mono_add_internal_call("XCEngine.InternalCalls::Rendering_CameraRenderRequestContext_GetDirectionalShadowPlanningSettings", reinterpret_cast(&InternalCall_Rendering_CameraRenderRequestContext_GetDirectionalShadowPlanningSettings)); mono_add_internal_call("XCEngine.InternalCalls::Rendering_CameraRenderRequestContext_SetDirectionalShadowPlanningSettings", reinterpret_cast(&InternalCall_Rendering_CameraRenderRequestContext_SetDirectionalShadowPlanningSettings)); mono_add_internal_call("XCEngine.InternalCalls::Rendering_CameraRenderRequestContext_ClearDirectionalShadow", reinterpret_cast(&InternalCall_Rendering_CameraRenderRequestContext_ClearDirectionalShadow)); + mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_GetRendererIndex", reinterpret_cast(&InternalCall_Rendering_RenderSceneSetupContext_GetRendererIndex)); + mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_GetIsConfigured", reinterpret_cast(&InternalCall_Rendering_RenderSceneSetupContext_GetIsConfigured)); + mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_UseDefaultSceneSetup", reinterpret_cast(&InternalCall_Rendering_RenderSceneSetupContext_UseDefaultSceneSetup)); + mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_UseDefaultEnvironment", reinterpret_cast(&InternalCall_Rendering_RenderSceneSetupContext_UseDefaultEnvironment)); + mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_UseDefaultGlobalShaderKeywords", reinterpret_cast(&InternalCall_Rendering_RenderSceneSetupContext_UseDefaultGlobalShaderKeywords)); + mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_ClearEnvironment", reinterpret_cast(&InternalCall_Rendering_RenderSceneSetupContext_ClearEnvironment)); + mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_ClearGlobalShaderKeywords", reinterpret_cast(&InternalCall_Rendering_RenderSceneSetupContext_ClearGlobalShaderKeywords)); + mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_ClearSceneSetup", reinterpret_cast(&InternalCall_Rendering_RenderSceneSetupContext_ClearSceneSetup)); mono_add_internal_call("XCEngine.InternalCalls::Rendering_DirectionalShadowExecutionContext_GetHasPlannedMainDirectionalShadow", reinterpret_cast(&InternalCall_Rendering_DirectionalShadowExecutionContext_GetHasPlannedMainDirectionalShadow)); mono_add_internal_call("XCEngine.InternalCalls::Rendering_DirectionalShadowExecutionContext_GetRendererIndex", reinterpret_cast(&InternalCall_Rendering_DirectionalShadowExecutionContext_GetRendererIndex)); mono_add_internal_call("XCEngine.InternalCalls::Rendering_DirectionalShadowExecutionContext_GetIsConfigured", reinterpret_cast(&InternalCall_Rendering_DirectionalShadowExecutionContext_GetIsConfigured)); @@ -6396,6 +6532,10 @@ void MonoScriptRuntime::Shutdown() { GetManagedScriptableRenderContextNextHandle() = 1; GetManagedCameraRenderRequestContextRegistry().clear(); GetManagedCameraRenderRequestContextNextHandle() = 1; + GetManagedRenderSceneSetupContextRegistry().clear(); + GetManagedRenderSceneSetupContextNextHandle() = 1; + GetManagedDirectionalShadowExecutionContextRegistry().clear(); + GetManagedDirectionalShadowExecutionContextNextHandle() = 1; GetManagedScriptableRenderPipelinePlanningContextRegistry().clear(); GetManagedScriptableRenderPipelinePlanningContextNextHandle() = 1; ClearManagedInstances(); @@ -6415,12 +6555,14 @@ void MonoScriptRuntime::Shutdown() { m_scriptableRenderPipelineClass = nullptr; m_scriptableRenderContextClass = nullptr; m_cameraRenderRequestContextClass = nullptr; + m_renderSceneSetupContextClass = nullptr; m_directionalShadowExecutionContextClass = nullptr; m_scriptableRenderPipelinePlanningContextClass = nullptr; m_serializeFieldAttributeClass = nullptr; m_gameObjectConstructor = nullptr; m_scriptableRenderContextConstructor = nullptr; m_cameraRenderRequestContextConstructor = nullptr; + m_renderSceneSetupContextConstructor = nullptr; m_directionalShadowExecutionContextConstructor = nullptr; m_scriptableRenderPipelinePlanningContextConstructor = nullptr; m_managedGameObjectUUIDField = nullptr; @@ -7216,6 +7358,27 @@ bool MonoScriptRuntime::DiscoverScriptClasses() { return false; } + m_renderSceneSetupContextClass = mono_class_from_name( + m_coreImage, + kManagedRenderingNamespace, + "RenderSceneSetupContext"); + if (!m_renderSceneSetupContextClass) { + SetError( + "Failed to locate the managed RenderSceneSetupContext type."); + return false; + } + + m_renderSceneSetupContextConstructor = + mono_class_get_method_from_name( + m_renderSceneSetupContextClass, + ".ctor", + 1); + if (!m_renderSceneSetupContextConstructor) { + SetError( + "Failed to locate the managed RenderSceneSetupContext constructor."); + return false; + } + m_directionalShadowExecutionContextClass = mono_class_from_name( m_coreImage, kManagedRenderingNamespace, @@ -7853,6 +8016,46 @@ MonoScriptRuntime::CreateManagedCameraRenderRequestContext( return contextObject; } +MonoObject* +MonoScriptRuntime::CreateManagedRenderSceneSetupContext( + uint64_t nativeHandle) { + if (!m_initialized || + nativeHandle == 0 || + m_renderSceneSetupContextClass == nullptr || + m_renderSceneSetupContextConstructor == nullptr) { + return nullptr; + } + + SetCurrentDomain(); + + MonoObject* const contextObject = + mono_object_new( + m_appDomain, + m_renderSceneSetupContextClass); + if (contextObject == nullptr) { + SetError( + "Mono failed to allocate a managed RenderSceneSetupContext."); + return nullptr; + } + + void* args[1]; + uint64_t nativeHandleArgument = nativeHandle; + args[0] = &nativeHandleArgument; + + MonoObject* exception = nullptr; + mono_runtime_invoke( + m_renderSceneSetupContextConstructor, + contextObject, + args, + &exception); + if (exception != nullptr) { + RecordException(exception); + return nullptr; + } + + return contextObject; +} + MonoObject* MonoScriptRuntime::CreateManagedDirectionalShadowExecutionContext( uint64_t nativeHandle) { diff --git a/managed/CMakeLists.txt b/managed/CMakeLists.txt index 595bd566..341f1b98 100644 --- a/managed/CMakeLists.txt +++ b/managed/CMakeLists.txt @@ -184,6 +184,7 @@ set(XCENGINE_SCRIPT_CORE_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/FinalColorToneMappingMode.cs ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/FilteringSettings.cs ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/GraphicsSettings.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/RenderSceneSetupContext.cs ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/RenderPipelineAsset.cs ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/RenderQueueRange.cs ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/RenderStateBlock.cs diff --git a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/RendererBackedRenderPipelineAsset.cs b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/RendererBackedRenderPipelineAsset.cs index 111d803c..62d63506 100644 --- a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/RendererBackedRenderPipelineAsset.cs +++ b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/RendererBackedRenderPipelineAsset.cs @@ -82,6 +82,17 @@ namespace XCEngine.Rendering.Universal context); } + protected override bool ConfigureRenderSceneSetup( + RenderSceneSetupContext context) + { + ScriptableRendererData resolvedRendererData = + ResolveRendererData(context); + return resolvedRendererData != null && + resolvedRendererData + .ConfigureRenderSceneSetupInstance( + context); + } + private protected string GetPipelineRendererAssetKey() { return GetPipelineRendererAssetKeyContextual( @@ -99,31 +110,6 @@ namespace XCEngine.Rendering.Universal : string.Empty; } - private protected virtual string GetRenderSceneSetupPolicyAssetKey() - { - return string.Empty; - } - - private protected virtual string - GetRenderSceneSetupPolicyAssetKeyContextual( - int rendererIndex) - { - ScriptableRendererData resolvedRendererData = - GetRendererData(rendererIndex); - if (resolvedRendererData != null) - { - string assetKey = - resolvedRendererData - .GetRenderSceneSetupPolicyAssetKeyInstance(); - if (!string.IsNullOrEmpty(assetKey)) - { - return assetKey; - } - } - - return GetRenderSceneSetupPolicyAssetKey(); - } - private protected virtual string GetCameraFrameStandalonePassAssetKey( CameraFrameStage stage) { @@ -388,6 +374,15 @@ namespace XCEngine.Rendering.Universal : -1); } + private ScriptableRendererData ResolveRendererData( + RenderSceneSetupContext context) + { + return GetRendererData( + context != null + ? context.rendererIndex + : -1); + } + private ScriptableRendererData ResolveRendererData( DirectionalShadowExecutionContext context) { diff --git a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRenderer.cs b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRenderer.cs index 736966fb..d4740b3e 100644 --- a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRenderer.cs +++ b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRenderer.cs @@ -101,6 +101,12 @@ namespace XCEngine.Rendering.Universal FinalizeCameraFramePlan(context); } + internal void ConfigureRenderSceneSetupInstance( + RenderSceneSetupContext context) + { + ConfigureRenderSceneSetup(context); + } + internal void ConfigureDirectionalShadowExecutionStateInstance( DirectionalShadowExecutionContext context) { @@ -205,6 +211,11 @@ namespace XCEngine.Rendering.Universal context); } + protected virtual void ConfigureRenderSceneSetup( + RenderSceneSetupContext context) + { + } + protected virtual void ConfigureDirectionalShadowExecutionState( DirectionalShadowExecutionContext context) { diff --git a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRendererData.cs b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRendererData.cs index 8e0e2925..fb9e31b9 100644 --- a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRendererData.cs +++ b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRendererData.cs @@ -64,11 +64,6 @@ namespace XCEngine.Rendering.Universal return GetPipelineRendererAssetKey(); } - internal string GetRenderSceneSetupPolicyAssetKeyInstance() - { - return GetRenderSceneSetupPolicyAssetKey(); - } - internal string GetCameraFrameStandalonePassAssetKeyInstance( CameraFrameStage stage) { @@ -146,6 +141,39 @@ namespace XCEngine.Rendering.Universal } } + internal bool ConfigureRenderSceneSetupInstance( + RenderSceneSetupContext context) + { + ConfigureRenderSceneSetup(context); + + ScriptableRenderer renderer = + GetRendererInstance(); + if (renderer != null) + { + renderer.ConfigureRenderSceneSetupInstance( + context); + } + + ScriptableRendererFeature[] rendererFeatures = + GetRendererFeatures(); + for (int i = 0; i < rendererFeatures.Length; ++i) + { + ScriptableRendererFeature rendererFeature = + rendererFeatures[i]; + if (rendererFeature == null || + !rendererFeature.isActive) + { + continue; + } + + rendererFeature.ConfigureRenderSceneSetup( + context); + } + + return context != null && + context.isConfigured; + } + internal bool ConfigureDirectionalShadowExecutionStateInstance( DirectionalShadowExecutionContext context) { @@ -205,6 +233,11 @@ namespace XCEngine.Rendering.Universal { } + protected virtual void ConfigureRenderSceneSetup( + RenderSceneSetupContext context) + { + } + protected virtual void ConfigureDirectionalShadowExecutionState( DirectionalShadowExecutionContext context) { @@ -215,11 +248,6 @@ namespace XCEngine.Rendering.Universal return string.Empty; } - private protected virtual string GetRenderSceneSetupPolicyAssetKey() - { - return string.Empty; - } - private protected virtual string GetCameraFrameStandalonePassAssetKey( CameraFrameStage stage) { diff --git a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRendererFeature.cs b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRendererFeature.cs index 7a7a08c7..7b60f78a 100644 --- a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRendererFeature.cs +++ b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRendererFeature.cs @@ -52,6 +52,11 @@ namespace XCEngine.Rendering.Universal { } + public virtual void ConfigureRenderSceneSetup( + RenderSceneSetupContext context) + { + } + public virtual void ConfigureDirectionalShadowExecutionState( DirectionalShadowExecutionContext context) { diff --git a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/UniversalRenderer.cs b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/UniversalRenderer.cs index 255d6486..b2434852 100644 --- a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/UniversalRenderer.cs +++ b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/UniversalRenderer.cs @@ -70,6 +70,17 @@ namespace XCEngine.Rendering.Universal ConfigureFinalOutputStage(context); } + protected override void ConfigureRenderSceneSetup( + RenderSceneSetupContext context) + { + if (context == null) + { + return; + } + + context.UseDefaultSceneSetup(); + } + protected override void ConfigureDirectionalShadowExecutionState( DirectionalShadowExecutionContext context) { diff --git a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/UniversalRendererData.cs b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/UniversalRendererData.cs index bdd698da..d554a1be 100644 --- a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/UniversalRendererData.cs +++ b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/UniversalRendererData.cs @@ -38,11 +38,6 @@ namespace XCEngine.Rendering.Universal return "BuiltinForward"; } - private protected override string GetRenderSceneSetupPolicyAssetKey() - { - return "BuiltinDefaultSceneSetup"; - } - internal UniversalMainSceneData GetMainSceneInstance() { if (mainScene == null) diff --git a/managed/XCEngine.ScriptCore/InternalCalls.cs b/managed/XCEngine.ScriptCore/InternalCalls.cs index 7c5f53a2..220aab49 100644 --- a/managed/XCEngine.ScriptCore/InternalCalls.cs +++ b/managed/XCEngine.ScriptCore/InternalCalls.cs @@ -903,6 +903,46 @@ namespace XCEngine Rendering_CameraRenderRequestContext_ClearDirectionalShadow( ulong nativeHandle); + [MethodImpl(MethodImplOptions.InternalCall)] + internal static extern int + Rendering_RenderSceneSetupContext_GetRendererIndex( + ulong nativeHandle); + + [MethodImpl(MethodImplOptions.InternalCall)] + internal static extern bool + Rendering_RenderSceneSetupContext_GetIsConfigured( + ulong nativeHandle); + + [MethodImpl(MethodImplOptions.InternalCall)] + internal static extern bool + Rendering_RenderSceneSetupContext_UseDefaultSceneSetup( + ulong nativeHandle); + + [MethodImpl(MethodImplOptions.InternalCall)] + internal static extern bool + Rendering_RenderSceneSetupContext_UseDefaultEnvironment( + ulong nativeHandle); + + [MethodImpl(MethodImplOptions.InternalCall)] + internal static extern bool + Rendering_RenderSceneSetupContext_UseDefaultGlobalShaderKeywords( + ulong nativeHandle); + + [MethodImpl(MethodImplOptions.InternalCall)] + internal static extern void + Rendering_RenderSceneSetupContext_ClearEnvironment( + ulong nativeHandle); + + [MethodImpl(MethodImplOptions.InternalCall)] + internal static extern void + Rendering_RenderSceneSetupContext_ClearGlobalShaderKeywords( + ulong nativeHandle); + + [MethodImpl(MethodImplOptions.InternalCall)] + internal static extern void + Rendering_RenderSceneSetupContext_ClearSceneSetup( + ulong nativeHandle); + [MethodImpl(MethodImplOptions.InternalCall)] internal static extern bool Rendering_DirectionalShadowExecutionContext_GetHasPlannedMainDirectionalShadow( diff --git a/managed/XCEngine.ScriptCore/Rendering/Core/RenderSceneSetupContext.cs b/managed/XCEngine.ScriptCore/Rendering/Core/RenderSceneSetupContext.cs new file mode 100644 index 00000000..50234c19 --- /dev/null +++ b/managed/XCEngine.ScriptCore/Rendering/Core/RenderSceneSetupContext.cs @@ -0,0 +1,67 @@ +namespace XCEngine.Rendering +{ + public sealed class RenderSceneSetupContext + { + private readonly ulong m_nativeHandle; + + internal RenderSceneSetupContext(ulong nativeHandle) + { + m_nativeHandle = nativeHandle; + } + + public int rendererIndex => + InternalCalls + .Rendering_RenderSceneSetupContext_GetRendererIndex( + m_nativeHandle); + + public bool isConfigured => + InternalCalls + .Rendering_RenderSceneSetupContext_GetIsConfigured( + m_nativeHandle); + + public bool UseDefaultSceneSetup() + { + return InternalCalls + .Rendering_RenderSceneSetupContext_UseDefaultSceneSetup( + m_nativeHandle); + } + + public bool UseDefaultEnvironment() + { + return InternalCalls + .Rendering_RenderSceneSetupContext_UseDefaultEnvironment( + m_nativeHandle); + } + + public bool UseDefaultGlobalShaderKeywords() + { + return InternalCalls + .Rendering_RenderSceneSetupContext_UseDefaultGlobalShaderKeywords( + m_nativeHandle); + } + + public void ClearEnvironment() + { + InternalCalls + .Rendering_RenderSceneSetupContext_ClearEnvironment( + m_nativeHandle); + } + + public void ClearGlobalShaderKeywords() + { + InternalCalls + .Rendering_RenderSceneSetupContext_ClearGlobalShaderKeywords( + m_nativeHandle); + } + + public void ClearSceneSetup() + { + InternalCalls + .Rendering_RenderSceneSetupContext_ClearSceneSetup( + m_nativeHandle); + } + + internal ulong nativeHandle => + m_nativeHandle; + } +} diff --git a/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipelineAsset.cs b/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipelineAsset.cs index 397d14a1..9bd97294 100644 --- a/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipelineAsset.cs +++ b/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipelineAsset.cs @@ -21,6 +21,12 @@ namespace XCEngine.Rendering ConfigureCameraFramePlan(context); } + internal bool ConfigureRenderSceneSetupInstance( + RenderSceneSetupContext context) + { + return ConfigureRenderSceneSetup(context); + } + internal bool ConfigureDirectionalShadowExecutionStateInstance( DirectionalShadowExecutionContext context) { @@ -49,6 +55,12 @@ namespace XCEngine.Rendering { } + protected virtual bool ConfigureRenderSceneSetup( + RenderSceneSetupContext context) + { + return false; + } + protected virtual bool ConfigureDirectionalShadowExecutionState( DirectionalShadowExecutionContext context) {