diff --git a/docs/plan/SRP_ManagedSceneDrawAPI计划_2026-04-20.md b/docs/plan/SRP_ManagedSceneDrawAPI计划_2026-04-20.md new file mode 100644 index 00000000..d8c47732 --- /dev/null +++ b/docs/plan/SRP_ManagedSceneDrawAPI计划_2026-04-20.md @@ -0,0 +1,127 @@ +# SRP Managed Scene Draw API 计划 2026-04-20 + +## 1. 阶段目标 + +当前 SRP 主线已经完成： +1. `ScriptableRenderContext` 拥有 scene phase / injection 录制入口 +2. Universal 默认 main-scene builtin passes 回到 `UniversalRenderer` 自己管理 +3. managed fullscreen authoring 已经 builder 化 + +但现在的 main-scene draw 仍然是黑盒： +1. managed 侧只能 `RecordScenePhase(SceneRenderPhase.*)` +2. URP 包里的 `DrawObjectsPass` 还不是真正的 draw-objects authoring +3. 用户无法像 Unity SRP 一样控制 renderer list / filtering / sorting + +这一阶段的目标是： +1. 把 native 已有的 scene draw primitives 正式抬到 managed API +2. 让 URP 包后续可以从“phase 黑盒”走向真正的 `DrawObjectsPass` +3. 为未来 C# 自定义渲染管线打下第一批 scene draw authoring 基元 + +## 2. 现状分析 + +### 2.1 native 侧已经有 draw 原语，但 managed 侧拿不到 + +当前 native 已存在： +1. `RendererListType` +2. `FilteringSettings` +3. `SortingSettings` +4. `RendererListDesc` +5. `DrawSettings` + +而 builtin forward 也已经按这些原语工作： +1. opaque -> `RendererListType::Opaque` +2. transparent -> `RendererListType::Transparent` +3. 最终由 `VisitRendererListVisibleItems(...)` 完成可见物体遍历 + +所以问题不是底层没有能力，而是： +1. 这些能力仍被 builtin forward 内部私有化 +2. managed SRP/URP 还只能调用 phase 黑盒 + +### 2.2 当前 `SceneRenderPhase` 只能做“整段默认绘制” + +这对于现阶段收口很有价值，但它的上限明显不够： +1. 无法表达只绘制 opaque / transparent 的一个子集 +2. 无法表达自定义 filtering / sorting +3. 无法自然演进到 Unity 风格 `DrawObjectsPass` + +## 3. 本阶段范围 + +本阶段优先做： +1. 梳理 native scene draw 原语与 builtin forward 的耦合点 +2. 确定第一批暴露到 managed 的最小 API 集 +3. 先打通最小可用 scene draw 调用链 +4. 用它替换 Universal 默认对象绘制 pass 的黑盒 phase 依赖 +5. `XCEditor` 重编译与旧 editor 冒烟 + +本阶段暂不做： +1. 全量照搬 Unity 所有 drawing/filtering 状态 +2. layer mask / render queue range / shader tag id 的完整体系 +3. renderer list 缓存优化 +4. deferred renderer + +## 4. 建议切口 + +### Step 1：先暴露最小可用 scene draw 描述 + +建议先暴露： +1. `RendererListType` +2. `RendererSortMode` +3. `FilteringSettings` +4. `SortingSettings` +5. `RendererListDesc` + +原因： +1. 这些类型 native 已经存在 +2. 数据结构简单，不需要先把整套 Unity 复杂状态一次性搬完 +3. 足够支撑第一个 managed `DrawObjectsPass` + +### Step 2：在 `ScriptableRenderContext` 增加显式 scene draw 入口 + +不要继续扩展 `RecordScenePhase(...)` 黑盒。 +建议新增类似： +1. `CreateRendererList(...)` +2. `DrawRendererList(...)` + +或者第一阶段更务实一点： +1. `DrawRenderers(RendererListDesc desc, SceneRenderPhase phase)` + +原则： +1. API 命名要朝 Unity 靠拢 +2. 但实现可以先走引擎现有 `RendererListType` 体系 + +### Step 3：让 Universal 默认对象 pass 开始消费新 API + +目标不是一次性推翻全部逻辑，而是先替换： +1. `UniversalDrawObjectsPass(opaque)` +2. `UniversalDrawObjectsPass(transparent)` + +让它们不再直接 `context.RecordScenePhase(...)` +而是基于新的 scene draw API 录制对象绘制。 + +Skybox 可以后续单独处理，因为它不是 renderer list 驱动的对象遍历。 + +## 5. 验收标准 + +这一阶段收口后应满足： +1. managed 侧首次拥有正式的 scene draw primitives +2. Universal 的对象绘制 pass 不再完全依赖 phase 黑盒 +3. 后续继续实现真正 Unity 风格 `DrawObjectsPass` 时，不需要再推翻这一层 +4. `XCEditor` 编译通过 +5. 旧 editor 冒烟通过 + +## 6. 阶段意义 + +这一步完成后，SRP 主线会从： + +`managed 可以组织主场景顺序，但对象绘制仍是 native 黑盒` + +推进到： + +`managed 开始拥有可组合的 scene draw primitives` + +这才是后面继续做： +1. Unity 风格 `DrawObjectsPass` +2. renderer feature 自定义对象绘制 +3. 更细的 filtering / sorting / override 行为 + +的真正起点。 diff --git a/docs/used/SRP_MainScene录制入口收口与ContextCore化计划_完成归档_2026-04-20.md b/docs/used/SRP_MainScene录制入口收口与ContextCore化计划_完成归档_2026-04-20.md new file mode 100644 index 00000000..39784f14 --- /dev/null +++ b/docs/used/SRP_MainScene录制入口收口与ContextCore化计划_完成归档_2026-04-20.md @@ -0,0 +1,183 @@ +# SRP Main Scene 录制入口收口与 Context Core 化计划 2026-04-20 + +## 1. 阶段目标 + +上一阶段已经完成： + +1. managed fullscreen pass 统一走 `RenderGraphRasterPassBuilder` +2. `Rendering_ScriptableRenderContext_RecordFullscreenPass` 旧桥删除 + +但主场景录制仍然没有完全收口： + +1. `ScriptableRenderPass` 还内置 `RecordScenePhase / RecordSceneInjectionPoint / RecordScene` +2. Universal 的主场景 pass 仍然是通过这些 pass 基类 helper 间接转发到 native +3. `RecordScene` 仍然保留着“一键录制默认 forward 场景顺序”的旧 internal call + +这一阶段的目标是： + +1. 把 main scene 录制入口提升到 `ScriptableRenderContext` +2. 让 `ScriptableRenderPass` 从 builtin-forward scene helper 中退出 +3. 删除 native `RecordScene` 旧桥 + +--- + +## 2. 当前问题 + +### 2.1 scene 录制入口放错层 + +当前 fullscreen 已经变成： + +1. `ScriptableRenderContext` +2. `RenderGraphTextureHandle` +3. `RenderGraphRasterPassBuilder` + +这一套 core API 在负责 authoring。 + +但 main scene 仍然是： + +1. `ScriptableRenderPass.RecordOpaqueScenePhase(...)` +2. `ScriptableRenderPass.RecordBeforeOpaqueInjection(...)` +3. `ScriptableRenderPass.RecordScene(...)` + +也就是 scene 录制能力还挂在首方 Universal pass 基类上。 + +这会导致： + +1. core/context 没有完整 scene authoring 语义 +2. Universal package 仍然在偷偷拥有一套 core 级能力 +3. 后续想做更像 Unity 的 SRP/URP API 时，会继续被 pass helper 绑住 + +### 2.2 `RecordScene` 是旧时代残留 + +`RecordScene` 本质上是在 native 侧执行一段默认 builtin forward 场景顺序： + +1. before opaque +2. opaque +3. after opaque +4. before skybox +5. skybox +6. after skybox +7. before transparent +8. transparent +9. after transparent + +这条能力如果继续保留在 native internal call： + +1. 会鼓励 managed 侧继续依赖默认顺序黑盒 +2. 不利于以后把场景组织完全收回 SRP/URP 包层 + +--- + +## 3. 本阶段范围 + +本阶段只做下面几件事： + +1. 归档上一阶段 fullscreen plan +2. 在 core 层补 scene phase / injection API +3. 删除 `RecordScene` native internal call +4. 重构 Universal 与 probe 调用面 +5. 编译旧 editor 并冒烟 + +本阶段明确不做： + +1. culling API +2. renderer list / draw settings / filtering settings +3. deferred renderer +4. HDRP 风格分支 + +--- + +## 4. 实施步骤 + +### Step 1：core 层补 scene 录制枚举与 context API + +目标： + +在 `XCEngine.Rendering` core 中建立： + +1. `SceneRenderPhase` +2. `SceneRenderInjectionPoint` +3. `ScriptableRenderContext.RecordScenePhase(...)` +4. `ScriptableRenderContext.RecordSceneInjectionPoint(...)` + +并按需要补 convenience 方法： + +1. `RecordOpaqueScenePhase()` +2. `RecordBeforeOpaqueInjection()` +3. 以及一个纯 managed 组合版 `RecordScene()` + +完成标准： + +1. scene authoring 能力回到 context/core +2. core API 不再需要 Universal pass 基类代持 scene helper + +### Step 2：删除 native `RecordScene` 旧桥 + +目标： + +删除： + +1. `InternalCalls.Rendering_ScriptableRenderContext_RecordScene` +2. native 对应实现 +3. native 对应注册 + +并由 managed `ScriptableRenderContext.RecordScene()` 用显式 scene step 顺序自行组合。 + +完成标准： + +1. 全仓搜索不再出现 `Rendering_ScriptableRenderContext_RecordScene` +2. 默认主场景顺序不再是 native 黑盒 + +### Step 3：重构 Universal 与 probes + +目标： + +1. `UniversalRenderer` 改用 `ScriptableRenderContext` scene API +2. `ScriptableRenderPass` 删除 builtin-forward scene helper +3. `GameScripts` probes 改用 context scene API + +完成标准： + +1. Universal 主场景组织不再依赖 pass 基类里的 scene helper +2. probe 仍能覆盖主场景阶段行为 + +### Step 4：编译与冒烟 + +固定验证： + +1. 编译旧 `editor` +2. 启动 `editor/bin/Debug/XCEngine.exe` +3. 冒烟至少 10 秒 +4. 检查 `editor.log` 中新的 `SceneReady` + +--- + +## 5. 验收标准 + +这一阶段收口后应满足： + +1. scene 录制入口正式进入 `ScriptableRenderContext` +2. `ScriptableRenderPass` 不再持有 builtin-forward 专属 scene helper +3. native `RecordScene` 旧桥删除 +4. Universal main scene 仍可稳定录制 +5. 旧 editor 编译通过，冒烟通过 + +--- + +## 6. 阶段意义 + +这一阶段完成以后，SRP 主线会从： + +`fullscreen 已 graph 化，但 main scene 仍绑在 pass helper 上` + +推进到： + +`fullscreen + main scene 的基础 authoring 入口都回到 core/context` + +这样下一步继续做更像 Unity 的： + +1. `DrawObjectsPass` +2. `DrawSkyboxPass` +3. 更正式的 renderer feature / pass 体系 + +时，主语就会是 `context` 和 `SRP package`，而不是一层历史 helper。 diff --git a/docs/used/SRP_Universal默认Pass显式化计划_完成归档_2026-04-20.md b/docs/used/SRP_Universal默认Pass显式化计划_完成归档_2026-04-20.md new file mode 100644 index 00000000..3d97a87d --- /dev/null +++ b/docs/used/SRP_Universal默认Pass显式化计划_完成归档_2026-04-20.md @@ -0,0 +1,114 @@ +# SRP Universal 默认 Pass 显式化计划 2026-04-20 + +## 1. 阶段目标 + +上一阶段已经完成： +1. main-scene 录制入口回收到 `ScriptableRenderContext` +2. native `RecordScene` 旧桥删除 +3. fullscreen 与 main-scene 的基础 authoring 都进入 core/context + +但 Universal 默认主场景组织仍然不够像 Unity： +1. 默认场景拓扑还挂在 `UniversalSceneFeature` +2. renderer 自己没有显式拥有 builtin scene passes +3. opaque / skybox / transparent 仍然表现为通用 phase pass，而不是明确的默认渲染 pass + +这一阶段的目标是： +1. 让 `UniversalRenderer` 自己拥有并组织默认主场景 builtin passes +2. 保留 `ScriptableRendererFeature` 只作为扩展点，而不是默认管线本体 +3. 把默认场景 pass 语义显式化，为后续 SRP/URP 化继续铺路 + +## 2. 当前问题 + +### 2.1 默认主场景拓扑被伪装成 feature + +当前 `UniversalRenderer` 通过 `AddFeature(new UniversalSceneFeature(...))` +把默认 scene 序列塞进 feature 系统。 + +这会导致： +1. builtin pipeline 和 user feature 的职责边界不清 +2. renderer 本身不像 Unity URP 那样显式拥有默认 passes +3. 后续继续做 renderer feature / renderer pass 体系时，默认拓扑会继续漂在扩展层 + +### 2.2 pass 语义仍然偏“占位符” + +当前 main-scene 默认 pass 仍是： +1. injection pass +2. scene phase pass + +这比上一阶段更干净，但还不是最清晰的语义。 +下一步至少要把 renderer 默认 pass 明确为 renderer 自带的 builtin passes， +而不是一个通用 feature 的队列拼装结果。 + +## 3. 本阶段范围 + +本阶段只做： +1. 归档上一阶段 plan +2. 重构 `UniversalRenderer`，让 builtin main-scene pass 由 renderer 自己管理 +3. 清理 `UniversalSceneFeature` 这一层默认拓扑桥接 +4. 保持 project probes / Universal 包行为不回退 +5. 重编译 `XCEditor` +6. 旧 editor 冒烟至少 10 秒 + +本阶段暂不做： +1. culling / drawing settings / filtering settings 的 managed 暴露 +2. deferred renderer +3. HDRP 分支 +4. 真正的 Unity 风格 renderer-list/draw-call authoring + +## 4. 实施步骤 + +### Step 1：收回 builtin scene topology ownership + +目标： +1. `UniversalRenderer` 自己持有 builtin scene passes +2. 通过 `AddRenderPasses(RenderingData)` 组织默认主场景 pass +3. feature 系统只负责附加扩展 passes + +完成标准： +1. 默认 main-scene 拓扑不再依赖 `UniversalSceneFeature` +2. builtin scene pass 的所有权回到 renderer + +### Step 2：显式化默认 scene pass 语义 + +目标： +1. 保留必要 injection 边界 +2. 让 opaque / skybox / transparent 的默认行为成为 renderer builtin passes +3. 为后续继续演进到更像 Unity 的 `DrawObjectsPass` / `DrawSkyboxPass` 打底 + +完成标准： +1. `UniversalRenderer.cs` 不再是“feature 包一层默认拓扑” +2. 默认 pass 结构读起来能直接看出主场景顺序 + +### Step 3：编译与冒烟 + +固定验证： +1. `cmake --build build --config Debug --target XCEditor` +2. 启动 `editor/bin/Debug/XCEngine.exe` +3. 冒烟至少 10 秒 +4. 检查 `editor/bin/Debug/editor.log` 新的 `SceneReady` + +## 5. 验收标准 + +本阶段收口后应满足： +1. `UniversalRenderer` 显式拥有默认主场景 builtin passes +2. `ScriptableRendererFeature` 只承担扩展职责 +3. Universal 默认主场景拓扑边界更接近 Unity 的 renderer-owned 组织方式 +4. `XCEditor` 重编译通过 +5. 旧 editor 冒烟通过 + +## 6. 阶段意义 + +这一阶段完成后，SRP 主线会从： + +`context/core 入口已经收口，但 Universal 默认拓扑仍然漂在 feature 包装层` + +推进到： + +`context/core 负责底层录制入口，Universal renderer 自己负责默认主场景拓扑` + +这样下一小阶段再继续做： +1. 更明确的默认 scene pass 命名与拆分 +2. 更像 Unity 的 renderer pass 体系 +3. 用户侧 feature/pass 与 builtin pass 的职责分界 + +就不会再被“默认逻辑伪装成 feature”这一层历史包袱卡住。 diff --git a/engine/include/XCEngine/Rendering/NativeSceneRenderer.h b/engine/include/XCEngine/Rendering/NativeSceneRenderer.h index caed9951..3573ee96 100644 --- a/engine/include/XCEngine/Rendering/NativeSceneRenderer.h +++ b/engine/include/XCEngine/Rendering/NativeSceneRenderer.h @@ -1,5 +1,6 @@ #pragma once +#include #include #include #include @@ -22,6 +23,9 @@ public: virtual bool ExecuteScenePhase( const RenderPassContext& context, ScenePhase scenePhase) = 0; + virtual bool ExecuteSceneDrawSettings( + const RenderPassContext& context, + const DrawSettings& drawSettings) = 0; }; } // namespace Rendering diff --git a/engine/include/XCEngine/Rendering/Pipelines/BuiltinForwardPipeline.h b/engine/include/XCEngine/Rendering/Pipelines/BuiltinForwardPipeline.h index 0370ee2e..dc9f4508 100644 --- a/engine/include/XCEngine/Rendering/Pipelines/BuiltinForwardPipeline.h +++ b/engine/include/XCEngine/Rendering/Pipelines/BuiltinForwardPipeline.h @@ -70,6 +70,9 @@ public: bool ExecuteScenePhase( const RenderPassContext& context, ScenePhase scenePhase) override; + bool ExecuteSceneDrawSettings( + const RenderPassContext& context, + const DrawSettings& drawSettings) override; void Shutdown() override; bool SupportsStageRenderGraph(CameraFrameStage stage) const override; bool RecordStageRenderGraph( diff --git a/engine/include/XCEngine/Rendering/Pipelines/NativeSceneRecorder.h b/engine/include/XCEngine/Rendering/Pipelines/NativeSceneRecorder.h index 94d53e3c..ef50d132 100644 --- a/engine/include/XCEngine/Rendering/Pipelines/NativeSceneRecorder.h +++ b/engine/include/XCEngine/Rendering/Pipelines/NativeSceneRecorder.h @@ -1,5 +1,6 @@ #pragma once +#include #include #include #include @@ -27,6 +28,7 @@ public: bool RecordDefaultScene(); bool RecordScenePhase(ScenePhase scenePhase); + bool RecordSceneDrawSettings(const DrawSettings& drawSettings); bool RecordInjectionPoint(SceneRenderInjectionPoint injectionPoint); private: diff --git a/engine/src/Rendering/Pipelines/Internal/BuiltinForwardPipelineScenePhases.cpp b/engine/src/Rendering/Pipelines/Internal/BuiltinForwardPipelineScenePhases.cpp index 7ae8d20c..cc156ca3 100644 --- a/engine/src/Rendering/Pipelines/Internal/BuiltinForwardPipelineScenePhases.cpp +++ b/engine/src/Rendering/Pipelines/Internal/BuiltinForwardPipelineScenePhases.cpp @@ -68,6 +68,31 @@ bool BuiltinForwardPipeline::ExecuteScenePhase( scenePhase)); } +bool BuiltinForwardPipeline::ExecuteSceneDrawSettings( + const RenderPassContext& context, + const DrawSettings& drawSettings) { + const FrameExecutionContext executionContext( + context.renderContext, + context.surface, + context.sceneData, + context.sourceSurface, + context.sourceColorView, + context.sourceColorState); + switch (drawSettings.scenePhase) { + case ScenePhase::Opaque: + case ScenePhase::Transparent: + return DrawVisibleItems( + executionContext, + drawSettings); + default: + Debug::Logger::Get().Error( + Debug::LogCategory::Rendering, + (Containers::String("BuiltinForwardPipeline::ExecuteSceneDrawSettings does not support scene phase: ") + + ToString(drawSettings.scenePhase)).CStr()); + return false; + } +} + bool BuiltinForwardPipeline::ExecuteForwardScene( const FrameExecutionContext& executionContext) { return ExecuteForwardSceneSteps( diff --git a/engine/src/Rendering/Pipelines/NativeSceneRecorder.cpp b/engine/src/Rendering/Pipelines/NativeSceneRecorder.cpp index e16a36e5..508ec923 100644 --- a/engine/src/Rendering/Pipelines/NativeSceneRecorder.cpp +++ b/engine/src/Rendering/Pipelines/NativeSceneRecorder.cpp @@ -26,6 +26,12 @@ bool ScenePhaseSamplesMainDirectionalShadow(ScenePhase scenePhase) { scenePhase == ScenePhase::Transparent; } +bool DrawSettingsSamplesMainDirectionalShadow( + const DrawSettings& drawSettings) { + return ScenePhaseSamplesMainDirectionalShadow( + drawSettings.scenePhase); +} + } // namespace NativeSceneRecorder::NativeSceneRecorder( @@ -179,6 +185,50 @@ bool NativeSceneRecorder::RecordScenePhase( return true; } +bool NativeSceneRecorder::RecordSceneDrawSettings( + const DrawSettings& drawSettings) { + if (m_context.stage != CameraFrameStage::MainScene) { + return false; + } + + const RenderPipelineStageRenderGraphContext graphContext = + BuildGraphContext(); + const bool clearAttachments = m_clearAttachments; + const SceneRenderFeaturePassBeginCallback beginRecordedPass = + BuildBeginRecordedPassCallback(graphContext.executionSucceeded); + const SceneRenderFeaturePassEndCallback endRecordedPass = + BuildEndRecordedPassCallback(); + const RenderPassGraphBeginCallback beginPhasePass = + [beginRecordedPass, clearAttachments]( + const RenderPassContext& passContext) { + return beginRecordedPass( + passContext, + clearAttachments); + }; + const std::vector additionalReadTextures = + DrawSettingsSamplesMainDirectionalShadow(drawSettings) && + m_mainDirectionalShadowTexture.IsValid() + ? std::vector{ m_mainDirectionalShadowTexture } + : std::vector{}; + if (!::XCEngine::Rendering::RecordRenderPipelineStagePhasePass( + graphContext, + drawSettings.scenePhase, + [&sceneRenderer = m_sceneRenderer, drawSettings]( + const RenderPassContext& passContext) { + return sceneRenderer.ExecuteSceneDrawSettings( + passContext, + drawSettings); + }, + beginPhasePass, + endRecordedPass, + additionalReadTextures)) { + return false; + } + + m_clearAttachments = false; + return true; +} + bool NativeSceneRecorder::RecordInjectionPoint( SceneRenderInjectionPoint injectionPoint) { if (m_context.stage != CameraFrameStage::MainScene) { diff --git a/engine/src/Scripting/Mono/MonoScriptRuntime.cpp b/engine/src/Scripting/Mono/MonoScriptRuntime.cpp index 99ee7d1b..d825a65e 100644 --- a/engine/src/Scripting/Mono/MonoScriptRuntime.cpp +++ b/engine/src/Scripting/Mono/MonoScriptRuntime.cpp @@ -4515,22 +4515,6 @@ InternalCall_Rendering_ScriptableRenderContext_GetFinalColorHasCameraOverrides( : 0; } -mono_bool InternalCall_Rendering_ScriptableRenderContext_RecordScene( - uint64_t nativeHandle) { - ManagedScriptableRenderContextState* const state = - FindManagedScriptableRenderContextState(nativeHandle); - if (state == nullptr || - state->graphContext == nullptr || - state->sceneRecorder == nullptr || - state->stage != Rendering::CameraFrameStage::MainScene) { - return 0; - } - - return state->sceneRecorder->RecordDefaultScene() - ? 1 - : 0; -} - mono_bool InternalCall_Rendering_ScriptableRenderContext_RecordScenePhase( uint64_t nativeHandle, @@ -4569,6 +4553,31 @@ InternalCall_Rendering_ScriptableRenderContext_RecordSceneInjectionPoint( : 0; } +mono_bool +InternalCall_Rendering_ScriptableRenderContext_DrawRenderers( + uint64_t nativeHandle, + int32_t scenePhase, + int32_t rendererListType) { + ManagedScriptableRenderContextState* const state = + FindManagedScriptableRenderContextState(nativeHandle); + if (state == nullptr || + state->graphContext == nullptr || + state->sceneRecorder == nullptr || + state->stage != Rendering::CameraFrameStage::MainScene) { + return 0; + } + + Rendering::DrawSettings drawSettings = {}; + drawSettings.scenePhase = + static_cast(scenePhase); + drawSettings.rendererListType = + static_cast(rendererListType); + return state->sceneRecorder->RecordSceneDrawSettings( + drawSettings) + ? 1 + : 0; +} + int32_t InternalCall_Rendering_CameraRenderRequestContext_GetRenderedBaseCameraCount( uint64_t nativeHandle) { @@ -4913,8 +4922,8 @@ void RegisterInternalCalls() { mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_GetFinalColorScale", reinterpret_cast(&InternalCall_Rendering_ScriptableRenderContext_GetFinalColorScale)); mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_GetFinalColorHasPipelineDefaults", reinterpret_cast(&InternalCall_Rendering_ScriptableRenderContext_GetFinalColorHasPipelineDefaults)); mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_GetFinalColorHasCameraOverrides", reinterpret_cast(&InternalCall_Rendering_ScriptableRenderContext_GetFinalColorHasCameraOverrides)); - mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_RecordScene", reinterpret_cast(&InternalCall_Rendering_ScriptableRenderContext_RecordScene)); mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_RecordScenePhase", reinterpret_cast(&InternalCall_Rendering_ScriptableRenderContext_RecordScenePhase)); + mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_DrawRenderers", reinterpret_cast(&InternalCall_Rendering_ScriptableRenderContext_DrawRenderers)); mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderContext_RecordSceneInjectionPoint", reinterpret_cast(&InternalCall_Rendering_ScriptableRenderContext_RecordSceneInjectionPoint)); mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderPipelinePlanningContext_IsStageRequested", reinterpret_cast(&InternalCall_Rendering_ScriptableRenderPipelinePlanningContext_IsStageRequested)); mono_add_internal_call("XCEngine.InternalCalls::Rendering_ScriptableRenderPipelinePlanningContext_GetStageColorSource", reinterpret_cast(&InternalCall_Rendering_ScriptableRenderPipelinePlanningContext_GetStageColorSource)); diff --git a/managed/CMakeLists.txt b/managed/CMakeLists.txt index 9b0be987..3e5b751c 100644 --- a/managed/CMakeLists.txt +++ b/managed/CMakeLists.txt @@ -179,43 +179,49 @@ set(XCENGINE_SCRIPT_CORE_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/FinalColorToneMappingMode.cs ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/GraphicsSettings.cs ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/RenderPipelineAsset.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/RendererListType.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/SceneRenderInjectionPoint.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/SceneRenderPhase.cs ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderContext.cs ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipeline.cs ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipelineAsset.cs ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipelinePlanningContext.cs ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/CameraRenderRequestContext.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Graph/RenderGraphRasterPassBuilder.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Graph/RenderGraphTextureDesc.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Graph/RenderGraphTextureHandle.cs ) set(XCENGINE_RENDER_PIPELINES_UNIVERSAL_SOURCES # Universal renderer package - ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Universal/CameraData.cs - ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Universal/ColorScalePostProcessRendererFeature.cs - ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Universal/DirectionalLightData.cs - ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Universal/DirectionalShadowData.cs - ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Universal/DisableDirectionalShadowRendererFeature.cs - ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Universal/EnvironmentData.cs - ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Universal/FinalColorData.cs - ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Universal/LightingData.cs - ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Universal/RenderClearFlags.cs - ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Universal/RenderEnvironmentMode.cs - ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Universal/RenderPassEvent.cs - ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Universal/RendererBackedRenderPipeline.cs - ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Universal/RendererBackedRenderPipelineAsset.cs - ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Universal/RendererCameraRequestContext.cs - ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Universal/RendererDrivenRenderPipeline.cs - ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Universal/RendererRecordingContext.cs - ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Universal/RenderingData.cs - ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Universal/RenderingDataResolver.cs - ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Universal/ShadowData.cs - ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Universal/ScriptableRenderPass.cs - ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Universal/ScriptableRenderer.cs - ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Universal/ScriptableRendererData.cs - ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Universal/ScriptableRendererFeature.cs - ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Universal/StageColorData.cs - ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Universal/UniversalRenderPipeline.cs - ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Universal/UniversalRenderer.cs - ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Universal/UniversalRendererData.cs - ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Universal/UniversalRenderPipelineAsset.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/CameraData.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/ColorScalePostProcessRendererFeature.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/DirectionalLightData.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/DirectionalShadowData.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/DisableDirectionalShadowRendererFeature.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/EnvironmentData.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/FinalColorData.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/LightingData.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/RenderClearFlags.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/RenderEnvironmentMode.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/RenderPassEvent.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/RendererBackedRenderPipeline.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/RendererBackedRenderPipelineAsset.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/RendererCameraRequestContext.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/RendererDrivenRenderPipeline.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/RendererRecordingContext.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/RenderingData.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/RenderingDataResolver.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/ShadowData.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRenderPass.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRenderer.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRendererData.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRendererFeature.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/StageColorData.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/UniversalRenderPipeline.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/UniversalRenderer.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/UniversalRendererData.cs + ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.RenderPipelines.Universal/Rendering/Universal/UniversalRenderPipelineAsset.cs ) set(XCENGINE_GAME_SCRIPT_SOURCES diff --git a/managed/GameScripts/RenderPipelineApiProbe.cs b/managed/GameScripts/RenderPipelineApiProbe.cs index 43b4a79e..700bad89 100644 --- a/managed/GameScripts/RenderPipelineApiProbe.cs +++ b/managed/GameScripts/RenderPipelineApiProbe.cs @@ -110,17 +110,17 @@ namespace Gameplay switch (m_injectionKind) { case SceneInjectionKind.BeforeOpaque: - return RecordBeforeOpaqueInjection(context); + return context.RecordBeforeOpaqueInjection(); case SceneInjectionKind.AfterOpaque: - return RecordAfterOpaqueInjection(context); + return context.RecordAfterOpaqueInjection(); case SceneInjectionKind.BeforeSkybox: - return RecordBeforeSkyboxInjection(context); + return context.RecordBeforeSkyboxInjection(); case SceneInjectionKind.AfterSkybox: - return RecordAfterSkyboxInjection(context); + return context.RecordAfterSkyboxInjection(); case SceneInjectionKind.BeforeTransparent: - return RecordBeforeTransparentInjection(context); + return context.RecordBeforeTransparentInjection(); case SceneInjectionKind.AfterTransparent: - return RecordAfterTransparentInjection(context); + return context.RecordAfterTransparentInjection(); default: return false; } @@ -164,11 +164,11 @@ namespace Gameplay switch (m_phaseKind) { case ScenePhaseKind.Opaque: - return RecordOpaqueScenePhase(context); + return context.RecordOpaqueScenePhase(); case ScenePhaseKind.Skybox: - return RecordSkyboxScenePhase(context); + return context.RecordSkyboxScenePhase(); case ScenePhaseKind.Transparent: - return RecordTransparentScenePhase(context); + return context.RecordTransparentScenePhase(); default: return false; } @@ -847,7 +847,7 @@ namespace Gameplay finalColorData.requiresProcessing; } RecordCallCount++; - return RecordScene(context); + return context.RecordScene(); } } diff --git a/managed/GameScripts/ScriptableRenderContextApiSurfaceProbe.cs b/managed/GameScripts/ScriptableRenderContextApiSurfaceProbe.cs index 01ad84ae..37b4a05d 100644 --- a/managed/GameScripts/ScriptableRenderContextApiSurfaceProbe.cs +++ b/managed/GameScripts/ScriptableRenderContextApiSurfaceProbe.cs @@ -9,9 +9,21 @@ namespace Gameplay : MonoBehaviour { public bool HasPublicContextRecordScene; + public bool HasPublicContextRecordScenePhase; + public bool HasPublicContextRecordSceneInjectionPoint; + public bool HasPublicContextDrawRenderers; + public bool HasPublicContextDrawOpaqueRenderers; + public bool HasPublicContextDrawTransparentRenderers; public bool HasPublicContextRecordOpaqueScenePhase; public bool HasPublicContextRecordBeforeOpaqueInjection; public bool HasPublicContextRecordShaderVectorFullscreenPass; + public bool HasPublicContextSourceColorTexture; + public bool HasPublicContextPrimaryColorTarget; + public bool HasPublicContextDepthTarget; + public bool HasPublicContextCreateTransientTexture; + public bool HasPublicContextCreateFullscreenTransientColorTexture; + public bool HasPublicContextCreateFullscreenTransientDepthTexture; + public bool HasPublicContextAddRasterPass; public bool HasPublicContextCameraData; public bool HasPublicContextLightingData; public bool HasPublicContextShadowData; @@ -43,6 +55,16 @@ namespace Gameplay public bool HasRendererRecordRenderer; public bool HasPublicRendererSupportsStageRenderGraph; public bool HasPublicRendererRecordStageRenderGraph; + public bool HasRenderGraphTextureHandleType; + public bool HasRenderGraphRasterPassBuilderType; + public bool HasRenderGraphRasterPassBuilderUseColorSource; + public bool HasRenderGraphRasterPassBuilderUseTexture; + public bool HasRenderGraphRasterPassBuilderSetColorAttachment; + public bool HasRenderGraphRasterPassBuilderSetColorScaleFullscreenExecution; + public bool HasRenderGraphRasterPassBuilderCommit; + public bool HasSceneRenderPhaseType; + public bool HasSceneRenderInjectionPointType; + public bool HasRendererListType; public void Start() { @@ -54,6 +76,8 @@ namespace Gameplay typeof(CameraRenderRequestContext); System.Type pipelineAssetType = typeof(ScriptableRenderPipelineAsset); + System.Type rasterPassBuilderType = + typeof(RenderGraphRasterPassBuilder); System.Type rendererFeatureType = typeof(ScriptableRendererFeature); System.Type rendererDataType = @@ -75,6 +99,26 @@ namespace Gameplay contextType.GetMethod( "RecordScene", PublicInstanceMethodFlags) != null; + HasPublicContextRecordScenePhase = + contextType.GetMethod( + "RecordScenePhase", + PublicInstanceMethodFlags) != null; + HasPublicContextRecordSceneInjectionPoint = + contextType.GetMethod( + "RecordSceneInjectionPoint", + PublicInstanceMethodFlags) != null; + HasPublicContextDrawRenderers = + contextType.GetMethod( + "DrawRenderers", + PublicInstanceMethodFlags) != null; + HasPublicContextDrawOpaqueRenderers = + contextType.GetMethod( + "DrawOpaqueRenderers", + PublicInstanceMethodFlags) != null; + HasPublicContextDrawTransparentRenderers = + contextType.GetMethod( + "DrawTransparentRenderers", + PublicInstanceMethodFlags) != null; HasPublicContextRecordOpaqueScenePhase = contextType.GetMethod( "RecordOpaqueScenePhase", @@ -87,6 +131,34 @@ namespace Gameplay contextType.GetMethod( "RecordShaderVectorFullscreenPass", PublicInstanceMethodFlags) != null; + HasPublicContextSourceColorTexture = + contextType.GetProperty( + "sourceColorTexture", + PublicInstanceMethodFlags) != null; + HasPublicContextPrimaryColorTarget = + contextType.GetProperty( + "primaryColorTarget", + PublicInstanceMethodFlags) != null; + HasPublicContextDepthTarget = + contextType.GetProperty( + "depthTarget", + PublicInstanceMethodFlags) != null; + HasPublicContextCreateTransientTexture = + contextType.GetMethod( + "CreateTransientTexture", + PublicInstanceMethodFlags) != null; + HasPublicContextCreateFullscreenTransientColorTexture = + contextType.GetMethod( + "CreateFullscreenTransientColorTexture", + PublicInstanceMethodFlags) != null; + HasPublicContextCreateFullscreenTransientDepthTexture = + contextType.GetMethod( + "CreateFullscreenTransientDepthTexture", + PublicInstanceMethodFlags) != null; + HasPublicContextAddRasterPass = + contextType.GetMethod( + "AddRasterPass", + PublicInstanceMethodFlags) != null; HasPublicContextCameraData = contextType.GetProperty( "cameraData", @@ -223,6 +295,40 @@ namespace Gameplay rendererType.GetMethod( "RecordStageRenderGraph", PublicInstanceMethodFlags) != null; + HasRenderGraphTextureHandleType = + contextType.Assembly.GetType( + "XCEngine.Rendering.RenderGraphTextureHandle") != null; + HasRenderGraphRasterPassBuilderType = + rasterPassBuilderType != null; + HasRenderGraphRasterPassBuilderUseColorSource = + rasterPassBuilderType.GetMethod( + "UseColorSource", + PublicInstanceMethodFlags) != null; + HasRenderGraphRasterPassBuilderUseTexture = + rasterPassBuilderType.GetMethod( + "UseTexture", + PublicInstanceMethodFlags) != null; + HasRenderGraphRasterPassBuilderSetColorAttachment = + rasterPassBuilderType.GetMethod( + "SetColorAttachment", + PublicInstanceMethodFlags) != null; + HasRenderGraphRasterPassBuilderSetColorScaleFullscreenExecution = + rasterPassBuilderType.GetMethod( + "SetColorScaleFullscreenExecution", + PublicInstanceMethodFlags) != null; + HasRenderGraphRasterPassBuilderCommit = + rasterPassBuilderType.GetMethod( + "Commit", + PublicInstanceMethodFlags) != null; + HasSceneRenderPhaseType = + contextType.Assembly.GetType( + "XCEngine.Rendering.SceneRenderPhase") != null; + HasSceneRenderInjectionPointType = + contextType.Assembly.GetType( + "XCEngine.Rendering.SceneRenderInjectionPoint") != null; + HasRendererListType = + contextType.Assembly.GetType( + "XCEngine.Rendering.RendererListType") != null; } } } diff --git a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRenderPass.cs b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRenderPass.cs index e5db6fa9..9d49e79d 100644 --- a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRenderPass.cs +++ b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/ScriptableRenderPass.cs @@ -11,23 +11,6 @@ namespace XCEngine.Rendering.Universal private const string kShaderVectorFullscreenPassName = "Universal.ShaderVectorFullscreen"; - private enum RecordedScenePhase - { - Opaque = 0, - Skybox = 1, - Transparent = 3 - } - - private enum RecordedSceneInjectionPoint - { - BeforeOpaque = 0, - AfterOpaque = 1, - BeforeSkybox = 2, - AfterSkybox = 3, - BeforeTransparent = 4, - AfterTransparent = 5 - } - protected ScriptableRenderPass() { } @@ -58,87 +41,6 @@ namespace XCEngine.Rendering.Universal ScriptableRenderContext context, RenderingData renderingData); - protected bool RecordScene( - ScriptableRenderContext context) - { - return context != null && - InternalCalls - .Rendering_ScriptableRenderContext_RecordScene( - context.nativeHandle); - } - - protected bool RecordOpaqueScenePhase( - ScriptableRenderContext context) - { - return RecordScenePhaseInternal( - context, - RecordedScenePhase.Opaque); - } - - protected bool RecordSkyboxScenePhase( - ScriptableRenderContext context) - { - return RecordScenePhaseInternal( - context, - RecordedScenePhase.Skybox); - } - - protected bool RecordTransparentScenePhase( - ScriptableRenderContext context) - { - return RecordScenePhaseInternal( - context, - RecordedScenePhase.Transparent); - } - - protected bool RecordBeforeOpaqueInjection( - ScriptableRenderContext context) - { - return RecordSceneInjectionPointInternal( - context, - RecordedSceneInjectionPoint.BeforeOpaque); - } - - protected bool RecordAfterOpaqueInjection( - ScriptableRenderContext context) - { - return RecordSceneInjectionPointInternal( - context, - RecordedSceneInjectionPoint.AfterOpaque); - } - - protected bool RecordBeforeSkyboxInjection( - ScriptableRenderContext context) - { - return RecordSceneInjectionPointInternal( - context, - RecordedSceneInjectionPoint.BeforeSkybox); - } - - protected bool RecordAfterSkyboxInjection( - ScriptableRenderContext context) - { - return RecordSceneInjectionPointInternal( - context, - RecordedSceneInjectionPoint.AfterSkybox); - } - - protected bool RecordBeforeTransparentInjection( - ScriptableRenderContext context) - { - return RecordSceneInjectionPointInternal( - context, - RecordedSceneInjectionPoint.BeforeTransparent); - } - - protected bool RecordAfterTransparentInjection( - ScriptableRenderContext context) - { - return RecordSceneInjectionPointInternal( - context, - RecordedSceneInjectionPoint.AfterTransparent); - } - protected bool RecordColorScaleFullscreenPass( ScriptableRenderContext context, Vector4 colorScale) @@ -285,28 +187,6 @@ namespace XCEngine.Rendering.Universal } } - private bool RecordScenePhaseInternal( - ScriptableRenderContext context, - RecordedScenePhase scenePhase) - { - return context != null && - InternalCalls - .Rendering_ScriptableRenderContext_RecordScenePhase( - context.nativeHandle, - (int)scenePhase); - } - - private bool RecordSceneInjectionPointInternal( - ScriptableRenderContext context, - RecordedSceneInjectionPoint injectionPoint) - { - return context != null && - InternalCalls - .Rendering_ScriptableRenderContext_RecordSceneInjectionPoint( - context.nativeHandle, - (int)injectionPoint); - } - private static bool TryResolveDefaultFullscreenTargets( ScriptableRenderContext context, out RenderGraphTextureHandle sourceColor, diff --git a/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/UniversalRenderer.cs b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/UniversalRenderer.cs new file mode 100644 index 00000000..612b0a57 --- /dev/null +++ b/managed/XCEngine.RenderPipelines.Universal/Rendering/Universal/UniversalRenderer.cs @@ -0,0 +1,155 @@ +using XCEngine; +using XCEngine.Rendering; + +namespace XCEngine.Rendering.Universal +{ + internal sealed class UniversalSceneInjectionPass : ScriptableRenderPass + { + private readonly SceneRenderInjectionPoint m_injectionPoint; + + public UniversalSceneInjectionPass( + RenderPassEvent passEvent, + SceneRenderInjectionPoint injectionPoint) + { + renderPassEvent = passEvent; + m_injectionPoint = injectionPoint; + } + + protected override bool RecordRenderGraph( + ScriptableRenderContext context, + RenderingData renderingData) + { + return context != null && + renderingData != null && + renderingData.isMainSceneStage && + context.RecordSceneInjectionPoint( + m_injectionPoint); + } + } + + internal sealed class UniversalDrawObjectsPass : ScriptableRenderPass + { + private readonly SceneRenderPhase m_scenePhase; + private readonly RendererListType m_rendererListType; + + public UniversalDrawObjectsPass( + RenderPassEvent passEvent, + SceneRenderPhase scenePhase, + RendererListType rendererListType) + { + renderPassEvent = passEvent; + m_scenePhase = scenePhase; + m_rendererListType = rendererListType; + } + + protected override bool RecordRenderGraph( + ScriptableRenderContext context, + RenderingData renderingData) + { + return context != null && + renderingData != null && + renderingData.isMainSceneStage && + context.DrawRenderers( + m_scenePhase, + m_rendererListType); + } + } + + internal sealed class UniversalDrawSkyboxPass : ScriptableRenderPass + { + public UniversalDrawSkyboxPass() + { + renderPassEvent = RenderPassEvent.RenderSkybox; + } + + protected override bool RecordRenderGraph( + ScriptableRenderContext context, + RenderingData renderingData) + { + return context != null && + renderingData != null && + renderingData.isMainSceneStage && + context.RecordScenePhase( + SceneRenderPhase.Skybox); + } + } + + public sealed class UniversalRenderer : ScriptableRenderer + { + private readonly UniversalRendererData m_rendererData; + private readonly UniversalSceneInjectionPass m_beforeOpaquePass = + new UniversalSceneInjectionPass( + RenderPassEvent.BeforeRenderingOpaques, + SceneRenderInjectionPoint.BeforeOpaque); + private readonly UniversalDrawObjectsPass m_drawOpaqueObjectsPass = + new UniversalDrawObjectsPass( + RenderPassEvent.RenderOpaques, + SceneRenderPhase.Opaque, + RendererListType.Opaque); + private readonly UniversalSceneInjectionPass m_afterOpaquePass = + new UniversalSceneInjectionPass( + RenderPassEvent.AfterRenderingOpaques, + SceneRenderInjectionPoint.AfterOpaque); + private readonly UniversalSceneInjectionPass m_beforeSkyboxPass = + new UniversalSceneInjectionPass( + RenderPassEvent.BeforeRenderingSkybox, + SceneRenderInjectionPoint.BeforeSkybox); + private readonly UniversalDrawSkyboxPass m_drawSkyboxPass = + new UniversalDrawSkyboxPass(); + private readonly UniversalSceneInjectionPass m_afterSkyboxPass = + new UniversalSceneInjectionPass( + RenderPassEvent.AfterRenderingSkybox, + SceneRenderInjectionPoint.AfterSkybox); + private readonly UniversalSceneInjectionPass m_beforeTransparentPass = + new UniversalSceneInjectionPass( + RenderPassEvent.BeforeRenderingTransparents, + SceneRenderInjectionPoint.BeforeTransparent); + private readonly UniversalDrawObjectsPass m_drawTransparentObjectsPass = + new UniversalDrawObjectsPass( + RenderPassEvent.RenderTransparents, + SceneRenderPhase.Transparent, + RendererListType.Transparent); + private readonly UniversalSceneInjectionPass m_afterTransparentPass = + new UniversalSceneInjectionPass( + RenderPassEvent.AfterRenderingTransparents, + SceneRenderInjectionPoint.AfterTransparent); + + public UniversalRenderer( + UniversalRendererData rendererData) + { + m_rendererData = + rendererData ?? new UniversalRendererData(); + } + + protected override void AddRenderPasses( + RenderingData renderingData) + { + if (renderingData == null || + !renderingData.isMainSceneStage) + { + return; + } + + if (m_rendererData.renderOpaque) + { + EnqueuePass(m_beforeOpaquePass); + EnqueuePass(m_drawOpaqueObjectsPass); + EnqueuePass(m_afterOpaquePass); + } + + if (m_rendererData.renderSkybox) + { + EnqueuePass(m_beforeSkyboxPass); + EnqueuePass(m_drawSkyboxPass); + EnqueuePass(m_afterSkyboxPass); + } + + if (m_rendererData.renderTransparent) + { + EnqueuePass(m_beforeTransparentPass); + EnqueuePass(m_drawTransparentObjectsPass); + EnqueuePass(m_afterTransparentPass); + } + } + } +} diff --git a/managed/XCEngine.ScriptCore/InternalCalls.cs b/managed/XCEngine.ScriptCore/InternalCalls.cs index 039d52b3..60714d02 100644 --- a/managed/XCEngine.ScriptCore/InternalCalls.cs +++ b/managed/XCEngine.ScriptCore/InternalCalls.cs @@ -581,11 +581,6 @@ namespace XCEngine Rendering_ScriptableRenderContext_GetMainDirectionalShadowDepthBiasUnits( ulong nativeHandle); - [MethodImpl(MethodImplOptions.InternalCall)] - internal static extern bool - Rendering_ScriptableRenderContext_RecordScene( - ulong nativeHandle); - [MethodImpl(MethodImplOptions.InternalCall)] internal static extern void Rendering_ScriptableRenderContext_GetCameraView( @@ -781,6 +776,13 @@ namespace XCEngine ulong nativeHandle, int scenePhase); + [MethodImpl(MethodImplOptions.InternalCall)] + internal static extern bool + Rendering_ScriptableRenderContext_DrawRenderers( + ulong nativeHandle, + int scenePhase, + int rendererListType); + [MethodImpl(MethodImplOptions.InternalCall)] internal static extern bool Rendering_ScriptableRenderContext_RecordSceneInjectionPoint( diff --git a/managed/XCEngine.ScriptCore/Rendering/Core/RendererListType.cs b/managed/XCEngine.ScriptCore/Rendering/Core/RendererListType.cs new file mode 100644 index 00000000..73eb63b2 --- /dev/null +++ b/managed/XCEngine.ScriptCore/Rendering/Core/RendererListType.cs @@ -0,0 +1,11 @@ +namespace XCEngine.Rendering +{ + public enum RendererListType + { + AllVisible = 0, + Opaque = 1, + Transparent = 2, + ShadowCaster = 3, + ObjectId = 4 + } +} diff --git a/managed/XCEngine.ScriptCore/Rendering/Core/SceneRenderInjectionPoint.cs b/managed/XCEngine.ScriptCore/Rendering/Core/SceneRenderInjectionPoint.cs new file mode 100644 index 00000000..ad6ab707 --- /dev/null +++ b/managed/XCEngine.ScriptCore/Rendering/Core/SceneRenderInjectionPoint.cs @@ -0,0 +1,12 @@ +namespace XCEngine.Rendering +{ + public enum SceneRenderInjectionPoint + { + BeforeOpaque = 0, + AfterOpaque = 1, + BeforeSkybox = 2, + AfterSkybox = 3, + BeforeTransparent = 4, + AfterTransparent = 5 + } +} diff --git a/managed/XCEngine.ScriptCore/Rendering/Core/SceneRenderPhase.cs b/managed/XCEngine.ScriptCore/Rendering/Core/SceneRenderPhase.cs new file mode 100644 index 00000000..0dd5c35f --- /dev/null +++ b/managed/XCEngine.ScriptCore/Rendering/Core/SceneRenderPhase.cs @@ -0,0 +1,12 @@ +namespace XCEngine.Rendering +{ + public enum SceneRenderPhase + { + Opaque = 0, + Skybox = 1, + Transparent = 3, + EditorExtension = 4, + PostProcess = 5, + FinalOutput = 6 + } +} diff --git a/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderContext.cs b/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderContext.cs index 7174121d..6a3c7a9a 100644 --- a/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderContext.cs +++ b/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderContext.cs @@ -15,6 +15,176 @@ namespace XCEngine.Rendering (CameraFrameStage)InternalCalls.Rendering_ScriptableRenderContext_GetStage( m_nativeHandle); + public RenderGraphTextureHandle sourceColorTexture => + RenderGraphTextureHandle.FromNativeIndex( + InternalCalls + .Rendering_ScriptableRenderContext_GetSourceColorTextureHandle( + m_nativeHandle)); + + public RenderGraphTextureHandle primaryColorTarget => + RenderGraphTextureHandle.FromNativeIndex( + InternalCalls + .Rendering_ScriptableRenderContext_GetPrimaryColorTargetHandle( + m_nativeHandle)); + + public RenderGraphTextureHandle depthTarget => + RenderGraphTextureHandle.FromNativeIndex( + InternalCalls + .Rendering_ScriptableRenderContext_GetDepthTargetHandle( + m_nativeHandle)); + + public bool RecordScene() + { + return RecordBeforeOpaqueInjection() && + RecordOpaqueScenePhase() && + RecordAfterOpaqueInjection() && + RecordBeforeSkyboxInjection() && + RecordSkyboxScenePhase() && + RecordAfterSkyboxInjection() && + RecordBeforeTransparentInjection() && + RecordTransparentScenePhase() && + RecordAfterTransparentInjection(); + } + + public bool RecordScenePhase( + SceneRenderPhase scenePhase) + { + return InternalCalls + .Rendering_ScriptableRenderContext_RecordScenePhase( + m_nativeHandle, + (int)scenePhase); + } + + public bool RecordSceneInjectionPoint( + SceneRenderInjectionPoint injectionPoint) + { + return InternalCalls + .Rendering_ScriptableRenderContext_RecordSceneInjectionPoint( + m_nativeHandle, + (int)injectionPoint); + } + + public bool DrawRenderers( + SceneRenderPhase scenePhase, + RendererListType rendererListType) + { + return InternalCalls + .Rendering_ScriptableRenderContext_DrawRenderers( + m_nativeHandle, + (int)scenePhase, + (int)rendererListType); + } + + public bool RecordOpaqueScenePhase() + { + return RecordScenePhase( + SceneRenderPhase.Opaque); + } + + public bool RecordSkyboxScenePhase() + { + return RecordScenePhase( + SceneRenderPhase.Skybox); + } + + public bool RecordTransparentScenePhase() + { + return RecordScenePhase( + SceneRenderPhase.Transparent); + } + + public bool RecordBeforeOpaqueInjection() + { + return RecordSceneInjectionPoint( + SceneRenderInjectionPoint.BeforeOpaque); + } + + public bool RecordAfterOpaqueInjection() + { + return RecordSceneInjectionPoint( + SceneRenderInjectionPoint.AfterOpaque); + } + + public bool RecordBeforeSkyboxInjection() + { + return RecordSceneInjectionPoint( + SceneRenderInjectionPoint.BeforeSkybox); + } + + public bool RecordAfterSkyboxInjection() + { + return RecordSceneInjectionPoint( + SceneRenderInjectionPoint.AfterSkybox); + } + + public bool RecordBeforeTransparentInjection() + { + return RecordSceneInjectionPoint( + SceneRenderInjectionPoint.BeforeTransparent); + } + + public bool RecordAfterTransparentInjection() + { + return RecordSceneInjectionPoint( + SceneRenderInjectionPoint.AfterTransparent); + } + + public bool DrawOpaqueRenderers() + { + return DrawRenderers( + SceneRenderPhase.Opaque, + RendererListType.Opaque); + } + + public bool DrawTransparentRenderers() + { + return DrawRenderers( + SceneRenderPhase.Transparent, + RendererListType.Transparent); + } + + public RenderGraphTextureHandle CreateTransientTexture( + string name, + RenderGraphTextureDesc desc) + { + return RenderGraphTextureHandle.FromNativeIndex( + InternalCalls + .Rendering_ScriptableRenderContext_CreateTransientTexture( + m_nativeHandle, + name, + ref desc)); + } + + public RenderGraphTextureHandle + CreateFullscreenTransientColorTexture( + string name) + { + return RenderGraphTextureHandle.FromNativeIndex( + InternalCalls + .Rendering_ScriptableRenderContext_CreateFullscreenTransientColorTexture( + m_nativeHandle, + name)); + } + + public RenderGraphTextureHandle + CreateFullscreenTransientDepthTexture( + string name) + { + return RenderGraphTextureHandle.FromNativeIndex( + InternalCalls + .Rendering_ScriptableRenderContext_CreateFullscreenTransientDepthTexture( + m_nativeHandle, + name)); + } + + public RenderGraphRasterPassBuilder AddRasterPass( + string passName) + { + return new RenderGraphRasterPassBuilder( + this, + passName); + } + internal ulong nativeHandle => m_nativeHandle; } diff --git a/project/Assets/Scripts/ProjectRenderPipelineProbe.cs b/project/Assets/Scripts/ProjectRenderPipelineProbe.cs index 87612c98..56997a7c 100644 --- a/project/Assets/Scripts/ProjectRenderPipelineProbe.cs +++ b/project/Assets/Scripts/ProjectRenderPipelineProbe.cs @@ -135,7 +135,9 @@ namespace ProjectScripts return context != null && renderingData != null && renderingData.isMainSceneStage && - RecordOpaqueScenePhase(context); + context.DrawRenderers( + SceneRenderPhase.Opaque, + RendererListType.Opaque); } }