diff --git a/engine/src/Scripting/Mono/MonoScriptRuntime.cpp b/engine/src/Scripting/Mono/MonoScriptRuntime.cpp
index 5a4ab4e9..ad6bbd3d 100644
--- a/engine/src/Scripting/Mono/MonoScriptRuntime.cpp
+++ b/engine/src/Scripting/Mono/MonoScriptRuntime.cpp
@@ -46,6 +46,8 @@ namespace Scripting {
 
 namespace {
 
+constexpr const char* kManagedRenderingNamespace = "XCEngine.Rendering";
+
 struct MonoRootState {
     MonoDomain* rootDomain = nullptr;
     bool initialized = false;
@@ -4472,7 +4474,7 @@ bool MonoScriptRuntime::DiscoverScriptClasses() {
 
     m_scriptableRenderPipelineAssetClass = mono_class_from_name(
         m_coreImage,
-        m_settings.baseNamespace.c_str(),
+        kManagedRenderingNamespace,
         "ScriptableRenderPipelineAsset");
     if (!m_scriptableRenderPipelineAssetClass) {
         SetError("Failed to locate the managed ScriptableRenderPipelineAsset base type.");
@@ -4481,7 +4483,7 @@ bool MonoScriptRuntime::DiscoverScriptClasses() {
 
     m_scriptableRenderPipelineClass = mono_class_from_name(
         m_coreImage,
-        m_settings.baseNamespace.c_str(),
+        kManagedRenderingNamespace,
         "ScriptableRenderPipeline");
     if (!m_scriptableRenderPipelineClass) {
         SetError("Failed to locate the managed ScriptableRenderPipeline base type.");
@@ -4490,7 +4492,7 @@ bool MonoScriptRuntime::DiscoverScriptClasses() {
 
     m_scriptableRenderContextClass = mono_class_from_name(
         m_coreImage,
-        m_settings.baseNamespace.c_str(),
+        kManagedRenderingNamespace,
         "ScriptableRenderContext");
     if (!m_scriptableRenderContextClass) {
         SetError("Failed to locate the managed ScriptableRenderContext type.");
@@ -4509,7 +4511,7 @@ bool MonoScriptRuntime::DiscoverScriptClasses() {
 
     m_scriptableRenderPipelineCameraRequestContextClass = mono_class_from_name(
         m_coreImage,
-        m_settings.baseNamespace.c_str(),
+        kManagedRenderingNamespace,
         "ScriptableRenderPipelineCameraRequestContext");
     if (!m_scriptableRenderPipelineCameraRequestContextClass) {
         SetError(
@@ -4530,7 +4532,7 @@ bool MonoScriptRuntime::DiscoverScriptClasses() {
 
     m_scriptableRenderPipelinePlanningContextClass = mono_class_from_name(
         m_coreImage,
-        m_settings.baseNamespace.c_str(),
+        kManagedRenderingNamespace,
         "ScriptableRenderPipelinePlanningContext");
     if (!m_scriptableRenderPipelinePlanningContextClass) {
         SetError(
diff --git a/managed/CMakeLists.txt b/managed/CMakeLists.txt
index 81578a32..ab9f6429 100644
--- a/managed/CMakeLists.txt
+++ b/managed/CMakeLists.txt
@@ -101,34 +101,15 @@ endforeach()
 set(XCENGINE_SCRIPT_CORE_SOURCES
     ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Behaviour.cs
     ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Camera.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/CameraData.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/CameraFrameColorSource.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/CameraFrameStage.cs
     ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Color.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/ColorScalePostProcessRendererFeature.cs
     ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Component.cs
     ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Debug.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/DisableDirectionalShadowRendererFeature.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/DirectionalLightData.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/DirectionalShadowData.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/FinalColorExposureMode.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/FinalColorData.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/FinalColorOutputTransferMode.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/FinalColorSettings.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/FinalColorToneMappingMode.cs
     ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/ForceMode.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/ForwardRenderer.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/ForwardRendererData.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/ForwardRenderPipelineAsset.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/FullscreenPassDescriptor.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/EnvironmentData.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/GraphicsSettings.cs
     ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/GameObject.cs
     ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Input.cs
     ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/InternalCalls.cs
     ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/KeyCode.cs
     ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Light.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/LightingData.cs
     ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/MeshFilter.cs
     ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/MeshRenderer.cs
     ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Matrix4x4.cs
@@ -138,33 +119,56 @@ set(XCENGINE_SCRIPT_CORE_SOURCES
     ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/PhysicsBodyType.cs
     ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Quaternion.cs
     ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/RaycastHit.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/RenderPassEvent.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/RenderPipelineAsset.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/RenderClearFlags.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/RenderEnvironmentMode.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/RendererDrivenRenderPipeline.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/RenderingData.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/ScenePhase.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/SceneRenderInjectionPoint.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/ShadowData.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/ScriptableRenderPass.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/ScriptableRenderPipeline.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/ScriptableRenderPipelineAsset.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/ScriptableRenderPipelineCameraRequestContext.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/ScriptableRenderPipelinePlanningContext.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/ScriptableRenderContext.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/ScriptableRenderer.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/ScriptableRendererData.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/ScriptableRendererFeature.cs
     ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rigidbody.cs
     ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/SerializeField.cs
     ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Space.cs
-    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/StageColorData.cs
     ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Time.cs
     ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Transform.cs
     ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Vector2.cs
     ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Vector3.cs
     ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Vector4.cs
+    # Rendering core
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/CameraFrameColorSource.cs
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/CameraFrameStage.cs
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/FinalColorExposureMode.cs
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/FinalColorOutputTransferMode.cs
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/FinalColorSettings.cs
+    ${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/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/ScriptableRenderPipelineCameraRequestContext.cs
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipelinePlanningContext.cs
+    # Rendering renderer model
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Renderer/RendererBackedRenderPipeline.cs
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Renderer/RendererBackedRenderPipelineAsset.cs
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Renderer/RendererRecordingContext.cs
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Renderer/RendererDrivenRenderPipeline.cs
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Renderer/RenderPassEvent.cs
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Renderer/ScriptableRenderPass.cs
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Renderer/ScriptableRenderer.cs
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Renderer/ScriptableRendererData.cs
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Renderer/ScriptableRendererFeature.cs
+    # Rendering shared data
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Data/CameraData.cs
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Data/DirectionalLightData.cs
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Data/DirectionalShadowData.cs
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Data/EnvironmentData.cs
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Data/FinalColorData.cs
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Data/LightingData.cs
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Data/RenderClearFlags.cs
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Data/RenderEnvironmentMode.cs
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Data/RenderingData.cs
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Data/ShadowData.cs
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/Data/StageColorData.cs
+    # First-party rendering
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/FirstParty/ColorScalePostProcessRendererFeature.cs
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/FirstParty/DisableDirectionalShadowRendererFeature.cs
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/FirstParty/ForwardRenderer.cs
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/FirstParty/ForwardRendererData.cs
+    ${CMAKE_CURRENT_SOURCE_DIR}/XCEngine.ScriptCore/Rendering/FirstParty/ForwardRenderPipelineAsset.cs
 )
 
 set(XCENGINE_GAME_SCRIPT_SOURCES
diff --git a/managed/GameScripts/RenderPipelineApiProbe.cs b/managed/GameScripts/RenderPipelineApiProbe.cs
index ffc835fe..51525781 100644
--- a/managed/GameScripts/RenderPipelineApiProbe.cs
+++ b/managed/GameScripts/RenderPipelineApiProbe.cs
@@ -1,5 +1,8 @@
 using System;
 using XCEngine;
+using XCEngine.Rendering;
+using XCEngine.Rendering.Renderer;
+using XCEngine.Rendering.FirstParty;
 
 namespace Gameplay
 {
@@ -30,50 +33,52 @@ namespace Gameplay
 
     internal sealed class SceneInjectionPass : ScriptableRenderPass
     {
-        private readonly SceneRenderInjectionPoint m_injectionPoint;
+        private readonly Func<RendererRecordingContext, bool> m_recordAction;
 
         public SceneInjectionPass(
             RenderPassEvent passEvent,
-            SceneRenderInjectionPoint injectionPoint)
+            Func<RendererRecordingContext, bool> recordAction)
         {
             renderPassEvent = passEvent;
-            m_injectionPoint = injectionPoint;
+            m_recordAction = recordAction;
         }
 
         protected override bool RecordRenderGraph(
-            ScriptableRenderContext context,
+            RendererRecordingContext context,
             RenderingData renderingData)
         {
             return context != null &&
                    renderingData != null &&
                    renderingData.isMainSceneStage &&
-                   context.RecordSceneInjectionPoint(m_injectionPoint);
+                   m_recordAction != null &&
+                   m_recordAction(context);
         }
     }
 
     internal sealed class ScenePhasePass : ScriptableRenderPass
     {
-        private readonly ScenePhase m_scenePhase;
+        private readonly Func<RendererRecordingContext, bool> m_recordAction;
         private readonly Action m_onRecorded;
 
         public ScenePhasePass(
             RenderPassEvent passEvent,
-            ScenePhase scenePhase,
+            Func<RendererRecordingContext, bool> recordAction,
             Action onRecorded = null)
         {
             renderPassEvent = passEvent;
-            m_scenePhase = scenePhase;
+            m_recordAction = recordAction;
             m_onRecorded = onRecorded;
         }
 
         protected override bool RecordRenderGraph(
-            ScriptableRenderContext context,
+            RendererRecordingContext context,
             RenderingData renderingData)
         {
             bool recorded = context != null &&
                             renderingData != null &&
                             renderingData.isMainSceneStage &&
-                            context.RecordScenePhase(m_scenePhase);
+                            m_recordAction != null &&
+                            m_recordAction(context);
             if (recorded && m_onRecorded != null)
             {
                 m_onRecorded();
@@ -85,23 +90,24 @@ namespace Gameplay
 
     internal sealed class FullscreenPass : ScriptableRenderPass
     {
-        private readonly FullscreenPassDescriptor m_descriptor;
+        private readonly Func<RendererRecordingContext, bool> m_recordAction;
 
         public FullscreenPass(
             RenderPassEvent passEvent,
-            FullscreenPassDescriptor descriptor)
+            Func<RendererRecordingContext, bool> recordAction)
         {
             renderPassEvent = passEvent;
-            m_descriptor = descriptor;
+            m_recordAction = recordAction;
         }
 
         protected override bool RecordRenderGraph(
-            ScriptableRenderContext context,
+            RendererRecordingContext context,
             RenderingData renderingData)
         {
             return context != null &&
                    renderingData != null &&
-                   context.RecordFullscreenPass(m_descriptor);
+                   m_recordAction != null &&
+                   m_recordAction(context);
         }
     }
 
@@ -123,40 +129,40 @@ namespace Gameplay
             m_beforeOpaquePass =
                 new SceneInjectionPass(
                     RenderPassEvent.BeforeRenderingOpaques,
-                    SceneRenderInjectionPoint.BeforeOpaque);
+                    context => context.RecordBeforeOpaqueInjection());
             m_opaquePass =
                 new ScenePhasePass(
                     RenderPassEvent.RenderOpaques,
-                    ScenePhase.Opaque,
+                    context => context.RecordOpaqueScenePhase(),
                     onOpaqueRecorded);
             m_afterOpaquePass =
                 new SceneInjectionPass(
                     RenderPassEvent.AfterRenderingOpaques,
-                    SceneRenderInjectionPoint.AfterOpaque);
+                    context => context.RecordAfterOpaqueInjection());
             m_beforeSkyboxPass =
                 new SceneInjectionPass(
                     RenderPassEvent.BeforeRenderingSkybox,
-                    SceneRenderInjectionPoint.BeforeSkybox);
+                    context => context.RecordBeforeSkyboxInjection());
             m_skyboxPass =
                 new ScenePhasePass(
                     RenderPassEvent.RenderSkybox,
-                    ScenePhase.Skybox);
+                    context => context.RecordSkyboxScenePhase());
             m_afterSkyboxPass =
                 new SceneInjectionPass(
                     RenderPassEvent.AfterRenderingSkybox,
-                    SceneRenderInjectionPoint.AfterSkybox);
+                    context => context.RecordAfterSkyboxInjection());
             m_beforeTransparentPass =
                 new SceneInjectionPass(
                     RenderPassEvent.BeforeRenderingTransparents,
-                    SceneRenderInjectionPoint.BeforeTransparent);
+                    context => context.RecordBeforeTransparentInjection());
             m_transparentPass =
                 new ScenePhasePass(
                     RenderPassEvent.RenderTransparents,
-                    ScenePhase.Transparent);
+                    context => context.RecordTransparentScenePhase());
             m_afterTransparentPass =
                 new SceneInjectionPass(
                     RenderPassEvent.AfterRenderingTransparents,
-                    SceneRenderInjectionPoint.AfterTransparent);
+                    context => context.RecordAfterTransparentInjection());
         }
 
         public override void AddRenderPasses(
@@ -228,17 +234,23 @@ namespace Gameplay
     internal sealed class ProbePostProcessRenderer : ScriptableRenderer
     {
         public ProbePostProcessRenderer(
-            FullscreenPassDescriptor firstPass,
-            FullscreenPassDescriptor secondPass)
+            Vector4 firstVectorPayload,
+            Vector4 secondVectorPayload)
         {
             AddFeature(
                 new FullscreenFeature(
                     new FullscreenPass(
                         RenderPassEvent.BeforeRenderingPostProcessing,
-                        firstPass),
+                        context => context.RecordShaderVectorFullscreenPass(
+                            BuiltinShaderPaths.ColorScalePostProcess,
+                            firstVectorPayload,
+                            "ColorScale")),
                     new FullscreenPass(
                         RenderPassEvent.AfterRenderingPostProcessing,
-                        secondPass)));
+                        context => context.RecordShaderVectorFullscreenPass(
+                            BuiltinShaderPaths.ColorScalePostProcess,
+                            secondVectorPayload,
+                            "ColorScale"))));
         }
     }
 
@@ -253,7 +265,7 @@ namespace Gameplay
                 new FullscreenFeature(
                     new FullscreenPass(
                         RenderPassEvent.BeforeRenderingPostProcessing,
-                        FullscreenPassDescriptor.CreateColorScale(
+                        context => context.RecordColorScaleFullscreenPass(
                             postProcessScale))));
         }
     }
@@ -262,17 +274,16 @@ namespace Gameplay
     {
         public ProbePlannedFullscreenRenderer()
         {
-            FullscreenPassDescriptor descriptor =
-                FullscreenPassDescriptor.CreateColorScale(
-                    new Vector4(1.05f, 1.0f, 0.95f, 1.0f));
             AddFeature(
                 new FullscreenFeature(
                     new FullscreenPass(
                         RenderPassEvent.BeforeRenderingPostProcessing,
-                        descriptor),
+                        context => context.RecordColorScaleFullscreenPass(
+                            new Vector4(1.05f, 1.0f, 0.95f, 1.0f))),
                     new FullscreenPass(
                         RenderPassEvent.BeforeRenderingFinalOutput,
-                        descriptor)));
+                        context => context.RecordColorScaleFullscreenPass(
+                            new Vector4(1.05f, 1.0f, 0.95f, 1.0f)))));
         }
     }
 
@@ -418,7 +429,7 @@ namespace Gameplay
         }
 
         protected override bool RecordRenderGraph(
-            ScriptableRenderContext context,
+            RendererRecordingContext context,
             RenderingData renderingData)
         {
             if (context == null ||
@@ -649,7 +660,7 @@ namespace Gameplay
         }
 
         protected override bool RecordRenderGraph(
-            ScriptableRenderContext context,
+            RendererRecordingContext context,
             RenderingData renderingData)
         {
             if (context == null ||
@@ -867,7 +878,8 @@ namespace Gameplay
         }
     }
 
-    public sealed class ManagedRenderPipelineProbe : ScriptableRenderPipeline
+    public sealed class ManagedRenderPipelineProbe
+        : RendererBackedRenderPipeline
     {
         public static int SupportsStageCallCount;
         public static int RecordStageCallCount;
@@ -892,24 +904,19 @@ namespace Gameplay
         }
     }
 
-    public sealed class ManagedPostProcessRenderPipelineProbe : ScriptableRenderPipeline
+    public sealed class ManagedPostProcessRenderPipelineProbe
+        : RendererBackedRenderPipeline
     {
         protected override ScriptableRenderer CreateRenderer()
         {
             return new ProbePostProcessRenderer(
-                FullscreenPassDescriptor.CreateShaderVector(
-                    BuiltinShaderPaths.ColorScalePostProcess,
-                    new Vector4(1.10f, 0.95f, 0.90f, 1.0f),
-                    "ColorScale"),
-                FullscreenPassDescriptor.CreateShaderVector(
-                    BuiltinShaderPaths.ColorScalePostProcess,
-                    new Vector4(0.95f, 1.05f, 1.10f, 1.0f),
-                    "ColorScale"));
+                new Vector4(1.10f, 0.95f, 0.90f, 1.0f),
+                new Vector4(0.95f, 1.05f, 1.10f, 1.0f));
         }
     }
 
     public sealed class ManagedForwardRenderPipelineProbe
-        : ScriptableRenderPipeline
+        : RendererBackedRenderPipeline
     {
         public static int SupportsMainSceneCallCount;
         public static int SupportsPostProcessCallCount;
@@ -976,7 +983,7 @@ namespace Gameplay
     }
 
     public sealed class ManagedPlannedFullscreenRenderPipelineProbe
-        : ScriptableRenderPipeline
+        : RendererBackedRenderPipeline
     {
         protected override ScriptableRenderer CreateRenderer()
         {
@@ -985,7 +992,7 @@ namespace Gameplay
     }
 
     public sealed class ManagedRenderContextCameraDataProbe
-        : ScriptableRenderPipeline
+        : RendererBackedRenderPipeline
     {
         protected override ScriptableRenderer CreateRenderer()
         {
@@ -994,7 +1001,7 @@ namespace Gameplay
     }
 
     public sealed class ManagedRenderContextStageColorDataProbe
-        : ScriptableRenderPipeline
+        : RendererBackedRenderPipeline
     {
         protected override ScriptableRenderer CreateRenderer()
         {
@@ -1561,3 +1568,4 @@ namespace Gameplay
         }
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/FullscreenPassDescriptor.cs b/managed/XCEngine.ScriptCore/FullscreenPassDescriptor.cs
deleted file mode 100644
index bbd13d7f..00000000
--- a/managed/XCEngine.ScriptCore/FullscreenPassDescriptor.cs
+++ /dev/null
@@ -1,53 +0,0 @@
-namespace XCEngine
-{
-    public enum FullscreenPassType
-    {
-        ColorScale = 0,
-        ShaderVector = 1
-    }
-
-    public struct FullscreenPassDescriptor
-    {
-        public FullscreenPassType type;
-        public string shaderPath;
-        public string passName;
-        public Vector4 vectorPayload;
-
-        public static FullscreenPassDescriptor CreateColorScale(
-            Vector4 colorScale)
-        {
-            FullscreenPassDescriptor descriptor = new FullscreenPassDescriptor();
-            descriptor.type = FullscreenPassType.ColorScale;
-            descriptor.shaderPath = string.Empty;
-            descriptor.passName = string.Empty;
-            descriptor.vectorPayload = colorScale;
-            return descriptor;
-        }
-
-        public static FullscreenPassDescriptor CreateShaderVector(
-            string shaderPath,
-            Vector4 vectorPayload,
-            string passName = null)
-        {
-            FullscreenPassDescriptor descriptor = new FullscreenPassDescriptor();
-            descriptor.type = FullscreenPassType.ShaderVector;
-            descriptor.shaderPath = shaderPath ?? string.Empty;
-            descriptor.passName = passName ?? string.Empty;
-            descriptor.vectorPayload = vectorPayload;
-            return descriptor;
-        }
-
-        public bool IsValid()
-        {
-            switch (type)
-            {
-                case FullscreenPassType.ColorScale:
-                    return true;
-                case FullscreenPassType.ShaderVector:
-                    return !string.IsNullOrEmpty(shaderPath);
-                default:
-                    return false;
-            }
-        }
-    }
-}
diff --git a/managed/XCEngine.ScriptCore/InternalCalls.cs b/managed/XCEngine.ScriptCore/InternalCalls.cs
index 59a1d5a4..e25e135c 100644
--- a/managed/XCEngine.ScriptCore/InternalCalls.cs
+++ b/managed/XCEngine.ScriptCore/InternalCalls.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Runtime.CompilerServices;
+using XCEngine.Rendering;
 
 namespace XCEngine
 {
@@ -714,3 +715,4 @@ namespace XCEngine
                 bool usesGraphManagedOutputColor);
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/CameraFrameColorSource.cs b/managed/XCEngine.ScriptCore/Rendering/Core/CameraFrameColorSource.cs
similarity index 75%
rename from managed/XCEngine.ScriptCore/CameraFrameColorSource.cs
rename to managed/XCEngine.ScriptCore/Rendering/Core/CameraFrameColorSource.cs
index 6cdd7487..fed1beee 100644
--- a/managed/XCEngine.ScriptCore/CameraFrameColorSource.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Core/CameraFrameColorSource.cs
@@ -1,4 +1,6 @@
-namespace XCEngine
+using XCEngine;
+
+namespace XCEngine.Rendering
 {
     public enum CameraFrameColorSource
     {
@@ -7,3 +9,4 @@ namespace XCEngine
         PostProcessColor = 2
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/CameraFrameStage.cs b/managed/XCEngine.ScriptCore/Rendering/Core/CameraFrameStage.cs
similarity index 85%
rename from managed/XCEngine.ScriptCore/CameraFrameStage.cs
rename to managed/XCEngine.ScriptCore/Rendering/Core/CameraFrameStage.cs
index c3fcff83..fb6c1b56 100644
--- a/managed/XCEngine.ScriptCore/CameraFrameStage.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Core/CameraFrameStage.cs
@@ -1,4 +1,6 @@
-namespace XCEngine
+using XCEngine;
+
+namespace XCEngine.Rendering
 {
     public enum CameraFrameStage : byte
     {
@@ -13,3 +15,4 @@ namespace XCEngine
         OverlayPasses = 8
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/FinalColorExposureMode.cs b/managed/XCEngine.ScriptCore/Rendering/Core/FinalColorExposureMode.cs
similarity index 68%
rename from managed/XCEngine.ScriptCore/FinalColorExposureMode.cs
rename to managed/XCEngine.ScriptCore/Rendering/Core/FinalColorExposureMode.cs
index 55abe52f..038d040b 100644
--- a/managed/XCEngine.ScriptCore/FinalColorExposureMode.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Core/FinalColorExposureMode.cs
@@ -1,4 +1,6 @@
-namespace XCEngine
+using XCEngine;
+
+namespace XCEngine.Rendering
 {
     public enum FinalColorExposureMode : byte
     {
@@ -6,3 +8,4 @@ namespace XCEngine
         Fixed = 1
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/FinalColorOutputTransferMode.cs b/managed/XCEngine.ScriptCore/Rendering/Core/FinalColorOutputTransferMode.cs
similarity index 70%
rename from managed/XCEngine.ScriptCore/FinalColorOutputTransferMode.cs
rename to managed/XCEngine.ScriptCore/Rendering/Core/FinalColorOutputTransferMode.cs
index 9239a70d..fed45417 100644
--- a/managed/XCEngine.ScriptCore/FinalColorOutputTransferMode.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Core/FinalColorOutputTransferMode.cs
@@ -1,4 +1,6 @@
-namespace XCEngine
+using XCEngine;
+
+namespace XCEngine.Rendering
 {
     public enum FinalColorOutputTransferMode : byte
     {
@@ -6,3 +8,4 @@ namespace XCEngine
         LinearToSRGB = 1
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/FinalColorSettings.cs b/managed/XCEngine.ScriptCore/Rendering/Core/FinalColorSettings.cs
similarity index 93%
rename from managed/XCEngine.ScriptCore/FinalColorSettings.cs
rename to managed/XCEngine.ScriptCore/Rendering/Core/FinalColorSettings.cs
index de03c1b3..bfb60cc5 100644
--- a/managed/XCEngine.ScriptCore/FinalColorSettings.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Core/FinalColorSettings.cs
@@ -1,6 +1,7 @@
 using System.Runtime.InteropServices;
+using XCEngine;
 
-namespace XCEngine
+namespace XCEngine.Rendering
 {
     [StructLayout(LayoutKind.Sequential)]
     public struct FinalColorSettings
@@ -20,3 +21,4 @@ namespace XCEngine
         }
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/FinalColorToneMappingMode.cs b/managed/XCEngine.ScriptCore/Rendering/Core/FinalColorToneMappingMode.cs
similarity index 72%
rename from managed/XCEngine.ScriptCore/FinalColorToneMappingMode.cs
rename to managed/XCEngine.ScriptCore/Rendering/Core/FinalColorToneMappingMode.cs
index 6e63e25e..00d42a02 100644
--- a/managed/XCEngine.ScriptCore/FinalColorToneMappingMode.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Core/FinalColorToneMappingMode.cs
@@ -1,4 +1,6 @@
-namespace XCEngine
+using XCEngine;
+
+namespace XCEngine.Rendering
 {
     public enum FinalColorToneMappingMode : byte
     {
@@ -7,3 +9,4 @@ namespace XCEngine
         ACES = 2
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/GraphicsSettings.cs b/managed/XCEngine.ScriptCore/Rendering/Core/GraphicsSettings.cs
similarity index 86%
rename from managed/XCEngine.ScriptCore/GraphicsSettings.cs
rename to managed/XCEngine.ScriptCore/Rendering/Core/GraphicsSettings.cs
index c3a1a4e7..0cbeec75 100644
--- a/managed/XCEngine.ScriptCore/GraphicsSettings.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Core/GraphicsSettings.cs
@@ -1,6 +1,7 @@
 using System;
+using XCEngine;
 
-namespace XCEngine
+namespace XCEngine.Rendering
 {
     public static class GraphicsSettings
     {
@@ -11,3 +12,4 @@ namespace XCEngine
         }
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/RenderPipelineAsset.cs b/managed/XCEngine.ScriptCore/Rendering/Core/RenderPipelineAsset.cs
similarity index 73%
rename from managed/XCEngine.ScriptCore/RenderPipelineAsset.cs
rename to managed/XCEngine.ScriptCore/Rendering/Core/RenderPipelineAsset.cs
index b4fe885c..72539ed9 100644
--- a/managed/XCEngine.ScriptCore/RenderPipelineAsset.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Core/RenderPipelineAsset.cs
@@ -1,4 +1,6 @@
-namespace XCEngine
+using XCEngine;
+
+namespace XCEngine.Rendering
 {
     public abstract class RenderPipelineAsset : Object
     {
@@ -7,3 +9,4 @@ namespace XCEngine
         }
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/ScriptableRenderContext.cs b/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderContext.cs
similarity index 78%
rename from managed/XCEngine.ScriptCore/ScriptableRenderContext.cs
rename to managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderContext.cs
index 9e17cc5a..da380611 100644
--- a/managed/XCEngine.ScriptCore/ScriptableRenderContext.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderContext.cs
@@ -1,9 +1,33 @@
 using System;
+using XCEngine;
 
-namespace XCEngine
+namespace XCEngine.Rendering
 {
     public sealed class ScriptableRenderContext
     {
+        private enum RecordedScenePhase
+        {
+            Opaque = 0,
+            Skybox = 1,
+            Transparent = 3
+        }
+
+        private enum RecordedSceneInjectionPoint
+        {
+            BeforeOpaque = 0,
+            AfterOpaque = 1,
+            BeforeSkybox = 2,
+            AfterSkybox = 3,
+            BeforeTransparent = 4,
+            AfterTransparent = 5
+        }
+
+        private enum RecordedFullscreenPassType
+        {
+            ColorScale = 0,
+            ShaderVector = 1
+        }
+
         private readonly ulong m_nativeHandle;
         private CameraData m_cameraData;
         private LightingData m_lightingData;
@@ -42,19 +66,98 @@ namespace XCEngine
             m_stageColorData ??
             (m_stageColorData = ResolveStageColorData());
 
-        public bool RecordScene()
+        internal bool RecordScene()
         {
             return InternalCalls
                 .Rendering_ScriptableRenderContext_RecordScene(
                     m_nativeHandle);
         }
 
-        public bool RenderScene()
+        internal bool RecordOpaqueScenePhase()
         {
-            return RecordScene();
+            return RecordScenePhaseInternal(
+                RecordedScenePhase.Opaque);
         }
 
-        public bool RecordScenePhase(ScenePhase scenePhase)
+        internal bool RecordSkyboxScenePhase()
+        {
+            return RecordScenePhaseInternal(
+                RecordedScenePhase.Skybox);
+        }
+
+        internal bool RecordTransparentScenePhase()
+        {
+            return RecordScenePhaseInternal(
+                RecordedScenePhase.Transparent);
+        }
+
+        internal bool RecordBeforeOpaqueInjection()
+        {
+            return RecordSceneInjectionPointInternal(
+                RecordedSceneInjectionPoint.BeforeOpaque);
+        }
+
+        internal bool RecordAfterOpaqueInjection()
+        {
+            return RecordSceneInjectionPointInternal(
+                RecordedSceneInjectionPoint.AfterOpaque);
+        }
+
+        internal bool RecordBeforeSkyboxInjection()
+        {
+            return RecordSceneInjectionPointInternal(
+                RecordedSceneInjectionPoint.BeforeSkybox);
+        }
+
+        internal bool RecordAfterSkyboxInjection()
+        {
+            return RecordSceneInjectionPointInternal(
+                RecordedSceneInjectionPoint.AfterSkybox);
+        }
+
+        internal bool RecordBeforeTransparentInjection()
+        {
+            return RecordSceneInjectionPointInternal(
+                RecordedSceneInjectionPoint.BeforeTransparent);
+        }
+
+        internal bool RecordAfterTransparentInjection()
+        {
+            return RecordSceneInjectionPointInternal(
+                RecordedSceneInjectionPoint.AfterTransparent);
+        }
+
+        internal bool RecordColorScaleFullscreenPass(
+            Vector4 colorScale)
+        {
+            return RecordFullscreenPassInternal(
+                RecordedFullscreenPassType.ColorScale,
+                string.Empty,
+                string.Empty,
+                colorScale);
+        }
+
+        internal bool RecordShaderVectorFullscreenPass(
+            string shaderPath,
+            Vector4 vectorPayload,
+            string passName = null)
+        {
+            if (string.IsNullOrEmpty(shaderPath))
+            {
+                throw new ArgumentException(
+                    "Fullscreen shader path cannot be null or empty.",
+                    nameof(shaderPath));
+            }
+
+            return RecordFullscreenPassInternal(
+                RecordedFullscreenPassType.ShaderVector,
+                shaderPath,
+                passName ?? string.Empty,
+                vectorPayload);
+        }
+
+        private bool RecordScenePhaseInternal(
+            RecordedScenePhase scenePhase)
         {
             return InternalCalls
                 .Rendering_ScriptableRenderContext_RecordScenePhase(
@@ -62,8 +165,8 @@ namespace XCEngine
                     (int)scenePhase);
         }
 
-        public bool RecordSceneInjectionPoint(
-            SceneRenderInjectionPoint injectionPoint)
+        private bool RecordSceneInjectionPointInternal(
+            RecordedSceneInjectionPoint injectionPoint)
         {
             return InternalCalls
                 .Rendering_ScriptableRenderContext_RecordSceneInjectionPoint(
@@ -71,23 +174,16 @@ namespace XCEngine
                     (int)injectionPoint);
         }
 
-        public bool RecordFullscreenPass(
-            FullscreenPassDescriptor pass)
+        private bool RecordFullscreenPassInternal(
+            RecordedFullscreenPassType passType,
+            string shaderPath,
+            string passName,
+            Vector4 vectorPayload)
         {
-            if (!pass.IsValid())
-            {
-                throw new ArgumentException(
-                    "Invalid fullscreen pass descriptor.",
-                    nameof(pass));
-            }
-
-            string shaderPath = pass.shaderPath ?? string.Empty;
-            string passName = pass.passName ?? string.Empty;
-            Vector4 vectorPayload = pass.vectorPayload;
             return InternalCalls
                 .Rendering_ScriptableRenderContext_RecordFullscreenPass(
                     m_nativeHandle,
-                    (int)pass.type,
+                    (int)passType,
                     shaderPath,
                     passName,
                     ref vectorPayload);
@@ -340,3 +436,4 @@ namespace XCEngine
         }
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipeline.cs b/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipeline.cs
new file mode 100644
index 00000000..11c91897
--- /dev/null
+++ b/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipeline.cs
@@ -0,0 +1,24 @@
+using XCEngine;
+
+namespace XCEngine.Rendering
+{
+    public abstract class ScriptableRenderPipeline : Object
+    {
+        protected ScriptableRenderPipeline()
+        {
+        }
+
+        protected internal virtual bool SupportsStageRenderGraph(
+            CameraFrameStage stage)
+        {
+            return false;
+        }
+
+        protected internal virtual bool RecordStageRenderGraph(
+            ScriptableRenderContext context)
+        {
+            return false;
+        }
+    }
+}
+
diff --git a/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipelineAsset.cs b/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipelineAsset.cs
new file mode 100644
index 00000000..14838f2d
--- /dev/null
+++ b/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipelineAsset.cs
@@ -0,0 +1,32 @@
+using XCEngine;
+
+namespace XCEngine.Rendering
+{
+    public abstract class ScriptableRenderPipelineAsset : RenderPipelineAsset
+    {
+        protected ScriptableRenderPipelineAsset()
+        {
+        }
+
+        protected internal virtual ScriptableRenderPipeline CreatePipeline()
+        {
+            return null;
+        }
+
+        protected internal virtual void ConfigureCameraRenderRequest(
+            ScriptableRenderPipelineCameraRequestContext context)
+        {
+        }
+
+        protected internal virtual void ConfigureCameraFramePlan(
+            ScriptableRenderPipelinePlanningContext context)
+        {
+        }
+
+        protected internal virtual FinalColorSettings GetDefaultFinalColorSettings()
+        {
+            return FinalColorSettings.CreateDefault();
+        }
+    }
+}
+
diff --git a/managed/XCEngine.ScriptCore/ScriptableRenderPipelineCameraRequestContext.cs b/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipelineCameraRequestContext.cs
similarity index 95%
rename from managed/XCEngine.ScriptCore/ScriptableRenderPipelineCameraRequestContext.cs
rename to managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipelineCameraRequestContext.cs
index 23068402..76690f87 100644
--- a/managed/XCEngine.ScriptCore/ScriptableRenderPipelineCameraRequestContext.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipelineCameraRequestContext.cs
@@ -1,4 +1,6 @@
-namespace XCEngine
+using XCEngine;
+
+namespace XCEngine.Rendering
 {
     public sealed class ScriptableRenderPipelineCameraRequestContext
     {
@@ -32,3 +34,4 @@ namespace XCEngine
         }
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/ScriptableRenderPipelinePlanningContext.cs b/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipelinePlanningContext.cs
similarity index 98%
rename from managed/XCEngine.ScriptCore/ScriptableRenderPipelinePlanningContext.cs
rename to managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipelinePlanningContext.cs
index 831cb2a6..924767be 100644
--- a/managed/XCEngine.ScriptCore/ScriptableRenderPipelinePlanningContext.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Core/ScriptableRenderPipelinePlanningContext.cs
@@ -1,6 +1,7 @@
 using System;
+using XCEngine;
 
-namespace XCEngine
+namespace XCEngine.Rendering
 {
     public sealed class ScriptableRenderPipelinePlanningContext
     {
@@ -65,3 +66,4 @@ namespace XCEngine
         }
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/CameraData.cs b/managed/XCEngine.ScriptCore/Rendering/Data/CameraData.cs
similarity index 98%
rename from managed/XCEngine.ScriptCore/CameraData.cs
rename to managed/XCEngine.ScriptCore/Rendering/Data/CameraData.cs
index aa7f308a..2e996e3b 100644
--- a/managed/XCEngine.ScriptCore/CameraData.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Data/CameraData.cs
@@ -1,4 +1,6 @@
-namespace XCEngine
+using XCEngine;
+
+namespace XCEngine.Rendering
 {
     public sealed class CameraData
     {
@@ -107,3 +109,4 @@ namespace XCEngine
         public int viewportHeight { get; }
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/DirectionalLightData.cs b/managed/XCEngine.ScriptCore/Rendering/Data/DirectionalLightData.cs
similarity index 95%
rename from managed/XCEngine.ScriptCore/DirectionalLightData.cs
rename to managed/XCEngine.ScriptCore/Rendering/Data/DirectionalLightData.cs
index 9dada2a8..3e748483 100644
--- a/managed/XCEngine.ScriptCore/DirectionalLightData.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Data/DirectionalLightData.cs
@@ -1,4 +1,6 @@
-namespace XCEngine
+using XCEngine;
+
+namespace XCEngine.Rendering
 {
     public sealed class DirectionalLightData
     {
@@ -38,3 +40,4 @@ namespace XCEngine
             enabled;
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/DirectionalShadowData.cs b/managed/XCEngine.ScriptCore/Rendering/Data/DirectionalShadowData.cs
similarity index 98%
rename from managed/XCEngine.ScriptCore/DirectionalShadowData.cs
rename to managed/XCEngine.ScriptCore/Rendering/Data/DirectionalShadowData.cs
index 35e96004..0ffdaf53 100644
--- a/managed/XCEngine.ScriptCore/DirectionalShadowData.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Data/DirectionalShadowData.cs
@@ -1,4 +1,6 @@
-namespace XCEngine
+using XCEngine;
+
+namespace XCEngine.Rendering
 {
     public sealed class DirectionalShadowData
     {
@@ -81,3 +83,4 @@ namespace XCEngine
             mapHeight > 0;
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/EnvironmentData.cs b/managed/XCEngine.ScriptCore/Rendering/Data/EnvironmentData.cs
similarity index 96%
rename from managed/XCEngine.ScriptCore/EnvironmentData.cs
rename to managed/XCEngine.ScriptCore/Rendering/Data/EnvironmentData.cs
index 4968c65a..97d8689e 100644
--- a/managed/XCEngine.ScriptCore/EnvironmentData.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Data/EnvironmentData.cs
@@ -1,4 +1,6 @@
-namespace XCEngine
+using XCEngine;
+
+namespace XCEngine.Rendering
 {
     public sealed class EnvironmentData
     {
@@ -39,3 +41,4 @@ namespace XCEngine
             hasProceduralSkybox || hasMaterialSkybox;
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/FinalColorData.cs b/managed/XCEngine.ScriptCore/Rendering/Data/FinalColorData.cs
similarity index 96%
rename from managed/XCEngine.ScriptCore/FinalColorData.cs
rename to managed/XCEngine.ScriptCore/Rendering/Data/FinalColorData.cs
index 1a595412..ceba96f4 100644
--- a/managed/XCEngine.ScriptCore/FinalColorData.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Data/FinalColorData.cs
@@ -1,4 +1,6 @@
-namespace XCEngine
+using XCEngine;
+
+namespace XCEngine.Rendering
 {
     public sealed class FinalColorData
     {
@@ -37,3 +39,4 @@ namespace XCEngine
             settings.finalColorScale.w != 1.0f;
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/LightingData.cs b/managed/XCEngine.ScriptCore/Rendering/Data/LightingData.cs
similarity index 95%
rename from managed/XCEngine.ScriptCore/LightingData.cs
rename to managed/XCEngine.ScriptCore/Rendering/Data/LightingData.cs
index e9aff57b..f9af2d24 100644
--- a/managed/XCEngine.ScriptCore/LightingData.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Data/LightingData.cs
@@ -1,4 +1,6 @@
-namespace XCEngine
+using XCEngine;
+
+namespace XCEngine.Rendering
 {
     public sealed class LightingData
     {
@@ -33,3 +35,4 @@ namespace XCEngine
             additionalLightCount > 0;
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/RenderClearFlags.cs b/managed/XCEngine.ScriptCore/Rendering/Data/RenderClearFlags.cs
similarity index 78%
rename from managed/XCEngine.ScriptCore/RenderClearFlags.cs
rename to managed/XCEngine.ScriptCore/Rendering/Data/RenderClearFlags.cs
index f8cb26ec..d31dcd53 100644
--- a/managed/XCEngine.ScriptCore/RenderClearFlags.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Data/RenderClearFlags.cs
@@ -1,6 +1,7 @@
 using System;
+using XCEngine;
 
-namespace XCEngine
+namespace XCEngine.Rendering
 {
     [Flags]
     public enum RenderClearFlags
@@ -11,3 +12,4 @@ namespace XCEngine
         All = Color | Depth
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/RenderEnvironmentMode.cs b/managed/XCEngine.ScriptCore/Rendering/Data/RenderEnvironmentMode.cs
similarity index 73%
rename from managed/XCEngine.ScriptCore/RenderEnvironmentMode.cs
rename to managed/XCEngine.ScriptCore/Rendering/Data/RenderEnvironmentMode.cs
index 21bc6d41..74df62ff 100644
--- a/managed/XCEngine.ScriptCore/RenderEnvironmentMode.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Data/RenderEnvironmentMode.cs
@@ -1,4 +1,6 @@
-namespace XCEngine
+using XCEngine;
+
+namespace XCEngine.Rendering
 {
     public enum RenderEnvironmentMode
     {
@@ -7,3 +9,4 @@ namespace XCEngine
         MaterialSkybox = 2
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/RenderingData.cs b/managed/XCEngine.ScriptCore/Rendering/Data/RenderingData.cs
similarity index 98%
rename from managed/XCEngine.ScriptCore/RenderingData.cs
rename to managed/XCEngine.ScriptCore/Rendering/Data/RenderingData.cs
index 537025cc..71662eab 100644
--- a/managed/XCEngine.ScriptCore/RenderingData.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Data/RenderingData.cs
@@ -1,4 +1,6 @@
-namespace XCEngine
+using XCEngine;
+
+namespace XCEngine.Rendering
 {
     public sealed class RenderingData
     {
@@ -87,3 +89,4 @@ namespace XCEngine
             stage == CameraFrameStage.FinalOutput;
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/ShadowData.cs b/managed/XCEngine.ScriptCore/Rendering/Data/ShadowData.cs
similarity index 92%
rename from managed/XCEngine.ScriptCore/ShadowData.cs
rename to managed/XCEngine.ScriptCore/Rendering/Data/ShadowData.cs
index a16046c6..9d30a0af 100644
--- a/managed/XCEngine.ScriptCore/ShadowData.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Data/ShadowData.cs
@@ -1,4 +1,6 @@
-namespace XCEngine
+using XCEngine;
+
+namespace XCEngine.Rendering
 {
     public sealed class ShadowData
     {
@@ -20,3 +22,4 @@ namespace XCEngine
             mainDirectionalShadow.enabled;
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/StageColorData.cs b/managed/XCEngine.ScriptCore/Rendering/Data/StageColorData.cs
similarity index 93%
rename from managed/XCEngine.ScriptCore/StageColorData.cs
rename to managed/XCEngine.ScriptCore/Rendering/Data/StageColorData.cs
index 6122b777..bd032882 100644
--- a/managed/XCEngine.ScriptCore/StageColorData.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Data/StageColorData.cs
@@ -1,4 +1,6 @@
-namespace XCEngine
+using XCEngine;
+
+namespace XCEngine.Rendering
 {
     public sealed class StageColorData
     {
@@ -24,3 +26,4 @@ namespace XCEngine
         public bool usesGraphManagedOutputColor { get; }
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/ColorScalePostProcessRendererFeature.cs b/managed/XCEngine.ScriptCore/Rendering/FirstParty/ColorScalePostProcessRendererFeature.cs
similarity index 87%
rename from managed/XCEngine.ScriptCore/ColorScalePostProcessRendererFeature.cs
rename to managed/XCEngine.ScriptCore/Rendering/FirstParty/ColorScalePostProcessRendererFeature.cs
index f417d90e..0f909bd5 100644
--- a/managed/XCEngine.ScriptCore/ColorScalePostProcessRendererFeature.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/FirstParty/ColorScalePostProcessRendererFeature.cs
@@ -1,4 +1,8 @@
-namespace XCEngine
+using XCEngine;
+using XCEngine.Rendering;
+using XCEngine.Rendering.Renderer;
+
+namespace XCEngine.Rendering.FirstParty
 {
     internal sealed class ColorScalePostProcessPass
         : ScriptableRenderPass
@@ -14,16 +18,15 @@ namespace XCEngine
         }
 
         protected override bool RecordRenderGraph(
-            ScriptableRenderContext context,
+            RendererRecordingContext context,
             RenderingData renderingData)
         {
             return context != null &&
                    renderingData != null &&
                    renderingData.isPostProcessStage &&
                    m_feature != null &&
-                   context.RecordFullscreenPass(
-                       FullscreenPassDescriptor.CreateColorScale(
-                           m_feature.colorScale));
+                   context.RecordColorScaleFullscreenPass(
+                       m_feature.colorScale);
         }
     }
 
@@ -77,3 +80,4 @@ namespace XCEngine
         }
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/DisableDirectionalShadowRendererFeature.cs b/managed/XCEngine.ScriptCore/Rendering/FirstParty/DisableDirectionalShadowRendererFeature.cs
similarity index 77%
rename from managed/XCEngine.ScriptCore/DisableDirectionalShadowRendererFeature.cs
rename to managed/XCEngine.ScriptCore/Rendering/FirstParty/DisableDirectionalShadowRendererFeature.cs
index 62806969..08ec100a 100644
--- a/managed/XCEngine.ScriptCore/DisableDirectionalShadowRendererFeature.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/FirstParty/DisableDirectionalShadowRendererFeature.cs
@@ -1,4 +1,8 @@
-namespace XCEngine
+using XCEngine;
+using XCEngine.Rendering;
+using XCEngine.Rendering.Renderer;
+
+namespace XCEngine.Rendering.FirstParty
 {
     public sealed class DisableDirectionalShadowRendererFeature
         : ScriptableRendererFeature
@@ -14,3 +18,4 @@ namespace XCEngine
         }
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/ForwardRenderPipelineAsset.cs b/managed/XCEngine.ScriptCore/Rendering/FirstParty/ForwardRenderPipelineAsset.cs
similarity index 50%
rename from managed/XCEngine.ScriptCore/ForwardRenderPipelineAsset.cs
rename to managed/XCEngine.ScriptCore/Rendering/FirstParty/ForwardRenderPipelineAsset.cs
index 2aa8d65e..b0453645 100644
--- a/managed/XCEngine.ScriptCore/ForwardRenderPipelineAsset.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/FirstParty/ForwardRenderPipelineAsset.cs
@@ -1,11 +1,16 @@
-namespace XCEngine
+using XCEngine;
+using XCEngine.Rendering;
+using XCEngine.Rendering.Renderer;
+
+namespace XCEngine.Rendering.FirstParty
 {
-    public class ForwardRenderPipelineAsset : ScriptableRenderPipelineAsset
+    public class ForwardRenderPipelineAsset
+        : RendererBackedRenderPipelineAsset
     {
         public ForwardRendererData rendererData =
             new ForwardRendererData();
 
-        protected override ScriptableRendererData GetDefaultRendererData()
+        protected override ScriptableRendererData GetRendererData()
         {
             if (rendererData == null)
             {
@@ -16,3 +21,4 @@ namespace XCEngine
         }
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/ForwardRenderer.cs b/managed/XCEngine.ScriptCore/Rendering/FirstParty/ForwardRenderer.cs
similarity index 53%
rename from managed/XCEngine.ScriptCore/ForwardRenderer.cs
rename to managed/XCEngine.ScriptCore/Rendering/FirstParty/ForwardRenderer.cs
index 294d59bb..aa0e5100 100644
--- a/managed/XCEngine.ScriptCore/ForwardRenderer.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/FirstParty/ForwardRenderer.cs
@@ -1,90 +1,73 @@
-namespace XCEngine
+using System;
+using XCEngine;
+using XCEngine.Rendering;
+using XCEngine.Rendering.Renderer;
+
+namespace XCEngine.Rendering.FirstParty
 {
-    internal sealed class ForwardSceneInjectionPass : ScriptableRenderPass
+    internal sealed class ForwardSceneRecordingPass : ScriptableRenderPass
     {
-        private readonly SceneRenderInjectionPoint m_injectionPoint;
+        private readonly Func<RendererRecordingContext, bool> m_recordAction;
 
-        public ForwardSceneInjectionPass(
+        public ForwardSceneRecordingPass(
             RenderPassEvent passEvent,
-            SceneRenderInjectionPoint injectionPoint)
+            Func<RendererRecordingContext, bool> recordAction)
         {
             renderPassEvent = passEvent;
-            m_injectionPoint = injectionPoint;
+            m_recordAction = recordAction;
         }
 
         protected override bool RecordRenderGraph(
-            ScriptableRenderContext context,
+            RendererRecordingContext context,
             RenderingData renderingData)
         {
             return context != null &&
                    renderingData != null &&
                    renderingData.isMainSceneStage &&
-                   context.RecordSceneInjectionPoint(m_injectionPoint);
-        }
-    }
-
-    internal sealed class ForwardScenePhasePass : ScriptableRenderPass
-    {
-        private readonly ScenePhase m_scenePhase;
-
-        public ForwardScenePhasePass(
-            RenderPassEvent passEvent,
-            ScenePhase scenePhase)
-        {
-            renderPassEvent = passEvent;
-            m_scenePhase = scenePhase;
-        }
-
-        protected override bool RecordRenderGraph(
-            ScriptableRenderContext context,
-            RenderingData renderingData)
-        {
-            return context != null &&
-                   renderingData != null &&
-                   renderingData.isMainSceneStage &&
-                   context.RecordScenePhase(m_scenePhase);
+                   m_recordAction != null &&
+                   m_recordAction(context);
         }
     }
 
     internal sealed class ForwardSceneFeature : ScriptableRendererFeature
     {
         private readonly ForwardRendererData m_rendererData;
-        private readonly ForwardSceneInjectionPass m_beforeOpaquePass =
-            new ForwardSceneInjectionPass(
+        private readonly ForwardSceneRecordingPass m_beforeOpaquePass =
+            new ForwardSceneRecordingPass(
                 RenderPassEvent.BeforeRenderingOpaques,
-                SceneRenderInjectionPoint.BeforeOpaque);
-        private readonly ForwardScenePhasePass m_opaquePass =
-            new ForwardScenePhasePass(
+                context => context.RecordBeforeOpaqueInjection());
+        private readonly ForwardSceneRecordingPass m_opaquePass =
+            new ForwardSceneRecordingPass(
                 RenderPassEvent.RenderOpaques,
-                ScenePhase.Opaque);
-        private readonly ForwardSceneInjectionPass m_afterOpaquePass =
-            new ForwardSceneInjectionPass(
+                context => context.RecordOpaqueScenePhase());
+        private readonly ForwardSceneRecordingPass m_afterOpaquePass =
+            new ForwardSceneRecordingPass(
                 RenderPassEvent.AfterRenderingOpaques,
-                SceneRenderInjectionPoint.AfterOpaque);
-        private readonly ForwardSceneInjectionPass m_beforeSkyboxPass =
-            new ForwardSceneInjectionPass(
+                context => context.RecordAfterOpaqueInjection());
+        private readonly ForwardSceneRecordingPass m_beforeSkyboxPass =
+            new ForwardSceneRecordingPass(
                 RenderPassEvent.BeforeRenderingSkybox,
-                SceneRenderInjectionPoint.BeforeSkybox);
-        private readonly ForwardScenePhasePass m_skyboxPass =
-            new ForwardScenePhasePass(
+                context => context.RecordBeforeSkyboxInjection());
+        private readonly ForwardSceneRecordingPass m_skyboxPass =
+            new ForwardSceneRecordingPass(
                 RenderPassEvent.RenderSkybox,
-                ScenePhase.Skybox);
-        private readonly ForwardSceneInjectionPass m_afterSkyboxPass =
-            new ForwardSceneInjectionPass(
+                context => context.RecordSkyboxScenePhase());
+        private readonly ForwardSceneRecordingPass m_afterSkyboxPass =
+            new ForwardSceneRecordingPass(
                 RenderPassEvent.AfterRenderingSkybox,
-                SceneRenderInjectionPoint.AfterSkybox);
-        private readonly ForwardSceneInjectionPass m_beforeTransparentPass =
-            new ForwardSceneInjectionPass(
+                context => context.RecordAfterSkyboxInjection());
+        private readonly ForwardSceneRecordingPass m_beforeTransparentPass =
+            new ForwardSceneRecordingPass(
                 RenderPassEvent.BeforeRenderingTransparents,
-                SceneRenderInjectionPoint.BeforeTransparent);
-        private readonly ForwardScenePhasePass m_transparentPass =
-            new ForwardScenePhasePass(
+                context => context.RecordBeforeTransparentInjection());
+        private readonly ForwardSceneRecordingPass m_transparentPass =
+            new ForwardSceneRecordingPass(
                 RenderPassEvent.RenderTransparents,
-                ScenePhase.Transparent);
-        private readonly ForwardSceneInjectionPass m_afterTransparentPass =
-            new ForwardSceneInjectionPass(
+                context => context.RecordTransparentScenePhase());
+        private readonly ForwardSceneRecordingPass m_afterTransparentPass =
+            new ForwardSceneRecordingPass(
                 RenderPassEvent.AfterRenderingTransparents,
-                SceneRenderInjectionPoint.AfterTransparent);
+                context => context.RecordAfterTransparentInjection());
 
         public ForwardSceneFeature(
             ForwardRendererData rendererData)
@@ -145,3 +128,4 @@ namespace XCEngine
         }
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/ForwardRendererData.cs b/managed/XCEngine.ScriptCore/Rendering/FirstParty/ForwardRendererData.cs
similarity index 84%
rename from managed/XCEngine.ScriptCore/ForwardRendererData.cs
rename to managed/XCEngine.ScriptCore/Rendering/FirstParty/ForwardRendererData.cs
index 7e8b0c88..a5077afd 100644
--- a/managed/XCEngine.ScriptCore/ForwardRendererData.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/FirstParty/ForwardRendererData.cs
@@ -1,6 +1,9 @@
 using System;
+using XCEngine;
+using XCEngine.Rendering;
+using XCEngine.Rendering.Renderer;
 
-namespace XCEngine
+namespace XCEngine.Rendering.FirstParty
 {
     public class ForwardRendererData : ScriptableRendererData
     {
@@ -22,3 +25,4 @@ namespace XCEngine
         }
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/RenderPassEvent.cs b/managed/XCEngine.ScriptCore/Rendering/Renderer/RenderPassEvent.cs
similarity index 86%
rename from managed/XCEngine.ScriptCore/RenderPassEvent.cs
rename to managed/XCEngine.ScriptCore/Rendering/Renderer/RenderPassEvent.cs
index f4287382..85687583 100644
--- a/managed/XCEngine.ScriptCore/RenderPassEvent.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Renderer/RenderPassEvent.cs
@@ -1,4 +1,7 @@
-namespace XCEngine
+using XCEngine;
+using XCEngine.Rendering;
+
+namespace XCEngine.Rendering.Renderer
 {
     public enum RenderPassEvent
     {
@@ -17,3 +20,4 @@ namespace XCEngine
         AfterRenderingFinalOutput = 520
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/ScriptableRenderPipeline.cs b/managed/XCEngine.ScriptCore/Rendering/Renderer/RendererBackedRenderPipeline.cs
similarity index 73%
rename from managed/XCEngine.ScriptCore/ScriptableRenderPipeline.cs
rename to managed/XCEngine.ScriptCore/Rendering/Renderer/RendererBackedRenderPipeline.cs
index 03c47d7c..5ac251b2 100644
--- a/managed/XCEngine.ScriptCore/ScriptableRenderPipeline.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Renderer/RendererBackedRenderPipeline.cs
@@ -1,10 +1,14 @@
-namespace XCEngine
+using XCEngine;
+using XCEngine.Rendering;
+
+namespace XCEngine.Rendering.Renderer
 {
-    public abstract class ScriptableRenderPipeline : Object
+    public abstract class RendererBackedRenderPipeline
+        : ScriptableRenderPipeline
     {
         private ScriptableRenderer m_renderer;
 
-        protected ScriptableRenderPipeline()
+        protected RendererBackedRenderPipeline()
         {
         }
 
@@ -13,7 +17,7 @@ namespace XCEngine
             return null;
         }
 
-        protected internal virtual bool SupportsStageRenderGraph(
+        protected internal override bool SupportsStageRenderGraph(
             CameraFrameStage stage)
         {
             ScriptableRenderer renderer = GetOrCreateRenderer();
@@ -21,7 +25,7 @@ namespace XCEngine
                    renderer.SupportsStageRenderGraph(stage);
         }
 
-        protected internal virtual bool RecordStageRenderGraph(
+        protected internal override bool RecordStageRenderGraph(
             ScriptableRenderContext context)
         {
             ScriptableRenderer renderer = GetOrCreateRenderer();
@@ -43,3 +47,4 @@ namespace XCEngine
         }
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/Rendering/Renderer/RendererBackedRenderPipelineAsset.cs b/managed/XCEngine.ScriptCore/Rendering/Renderer/RendererBackedRenderPipelineAsset.cs
new file mode 100644
index 00000000..0336988b
--- /dev/null
+++ b/managed/XCEngine.ScriptCore/Rendering/Renderer/RendererBackedRenderPipelineAsset.cs
@@ -0,0 +1,54 @@
+using XCEngine;
+using XCEngine.Rendering;
+
+namespace XCEngine.Rendering.Renderer
+{
+    public abstract class RendererBackedRenderPipelineAsset
+        : ScriptableRenderPipelineAsset
+    {
+        protected RendererBackedRenderPipelineAsset()
+        {
+        }
+
+        protected internal override ScriptableRenderPipeline CreatePipeline()
+        {
+            ScriptableRendererData rendererData =
+                ResolveRendererData();
+            return rendererData != null
+                ? new RendererDrivenRenderPipeline(rendererData)
+                : null;
+        }
+
+        protected internal override void ConfigureCameraRenderRequest(
+            ScriptableRenderPipelineCameraRequestContext context)
+        {
+            ScriptableRendererData rendererData =
+                ResolveRendererData();
+            if (rendererData != null)
+            {
+                rendererData.ConfigureCameraRenderRequestInstance(
+                    context);
+            }
+        }
+
+        protected internal override void ConfigureCameraFramePlan(
+            ScriptableRenderPipelinePlanningContext context)
+        {
+            ScriptableRendererData rendererData =
+                ResolveRendererData();
+            if (rendererData != null)
+            {
+                rendererData.ConfigureCameraFramePlanInstance(
+                    context);
+            }
+        }
+
+        protected abstract ScriptableRendererData GetRendererData();
+
+        private ScriptableRendererData ResolveRendererData()
+        {
+            return GetRendererData();
+        }
+    }
+}
+
diff --git a/managed/XCEngine.ScriptCore/RendererDrivenRenderPipeline.cs b/managed/XCEngine.ScriptCore/Rendering/Renderer/RendererDrivenRenderPipeline.cs
similarity index 73%
rename from managed/XCEngine.ScriptCore/RendererDrivenRenderPipeline.cs
rename to managed/XCEngine.ScriptCore/Rendering/Renderer/RendererDrivenRenderPipeline.cs
index 9aae4517..efdf81bc 100644
--- a/managed/XCEngine.ScriptCore/RendererDrivenRenderPipeline.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Renderer/RendererDrivenRenderPipeline.cs
@@ -1,6 +1,10 @@
-namespace XCEngine
+using XCEngine;
+using XCEngine.Rendering;
+
+namespace XCEngine.Rendering.Renderer
 {
-    public class RendererDrivenRenderPipeline : ScriptableRenderPipeline
+    public class RendererDrivenRenderPipeline
+        : RendererBackedRenderPipeline
     {
         private readonly ScriptableRendererData m_rendererData;
 
@@ -18,3 +22,4 @@ namespace XCEngine
         }
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/Rendering/Renderer/RendererRecordingContext.cs b/managed/XCEngine.ScriptCore/Rendering/Renderer/RendererRecordingContext.cs
new file mode 100644
index 00000000..30e8bde3
--- /dev/null
+++ b/managed/XCEngine.ScriptCore/Rendering/Renderer/RendererRecordingContext.cs
@@ -0,0 +1,97 @@
+using XCEngine;
+using XCEngine.Rendering;
+
+namespace XCEngine.Rendering.Renderer
+{
+    public sealed class RendererRecordingContext
+    {
+        private readonly ScriptableRenderContext m_renderContext;
+
+        internal RendererRecordingContext(
+            ScriptableRenderContext renderContext)
+        {
+            m_renderContext = renderContext;
+        }
+
+        public bool RecordScene()
+        {
+            return m_renderContext != null &&
+                   m_renderContext.RecordScene();
+        }
+
+        public bool RecordOpaqueScenePhase()
+        {
+            return m_renderContext != null &&
+                   m_renderContext.RecordOpaqueScenePhase();
+        }
+
+        public bool RecordSkyboxScenePhase()
+        {
+            return m_renderContext != null &&
+                   m_renderContext.RecordSkyboxScenePhase();
+        }
+
+        public bool RecordTransparentScenePhase()
+        {
+            return m_renderContext != null &&
+                   m_renderContext.RecordTransparentScenePhase();
+        }
+
+        public bool RecordBeforeOpaqueInjection()
+        {
+            return m_renderContext != null &&
+                   m_renderContext.RecordBeforeOpaqueInjection();
+        }
+
+        public bool RecordAfterOpaqueInjection()
+        {
+            return m_renderContext != null &&
+                   m_renderContext.RecordAfterOpaqueInjection();
+        }
+
+        public bool RecordBeforeSkyboxInjection()
+        {
+            return m_renderContext != null &&
+                   m_renderContext.RecordBeforeSkyboxInjection();
+        }
+
+        public bool RecordAfterSkyboxInjection()
+        {
+            return m_renderContext != null &&
+                   m_renderContext.RecordAfterSkyboxInjection();
+        }
+
+        public bool RecordBeforeTransparentInjection()
+        {
+            return m_renderContext != null &&
+                   m_renderContext.RecordBeforeTransparentInjection();
+        }
+
+        public bool RecordAfterTransparentInjection()
+        {
+            return m_renderContext != null &&
+                   m_renderContext.RecordAfterTransparentInjection();
+        }
+
+        public bool RecordColorScaleFullscreenPass(
+            Vector4 colorScale)
+        {
+            return m_renderContext != null &&
+                   m_renderContext.RecordColorScaleFullscreenPass(
+                       colorScale);
+        }
+
+        public bool RecordShaderVectorFullscreenPass(
+            string shaderPath,
+            Vector4 vectorPayload,
+            string passName = null)
+        {
+            return m_renderContext != null &&
+                   m_renderContext.RecordShaderVectorFullscreenPass(
+                       shaderPath,
+                       vectorPayload,
+                       passName);
+        }
+    }
+}
+
diff --git a/managed/XCEngine.ScriptCore/ScriptableRenderPass.cs b/managed/XCEngine.ScriptCore/Rendering/Renderer/ScriptableRenderPass.cs
similarity index 92%
rename from managed/XCEngine.ScriptCore/ScriptableRenderPass.cs
rename to managed/XCEngine.ScriptCore/Rendering/Renderer/ScriptableRenderPass.cs
index 684cfde6..06352ff7 100644
--- a/managed/XCEngine.ScriptCore/ScriptableRenderPass.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Renderer/ScriptableRenderPass.cs
@@ -1,4 +1,7 @@
-namespace XCEngine
+using XCEngine;
+using XCEngine.Rendering;
+
+namespace XCEngine.Rendering.Renderer
 {
     public abstract class ScriptableRenderPass
     {
@@ -20,7 +23,7 @@ namespace XCEngine
         }
 
         internal bool Record(
-            ScriptableRenderContext context,
+            RendererRecordingContext context,
             RenderingData renderingData)
         {
             return RecordRenderGraph(
@@ -29,7 +32,7 @@ namespace XCEngine
         }
 
         protected abstract bool RecordRenderGraph(
-            ScriptableRenderContext context,
+            RendererRecordingContext context,
             RenderingData renderingData);
 
         internal static bool TryResolveStage(
@@ -64,3 +67,4 @@ namespace XCEngine
         }
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/ScriptableRenderer.cs b/managed/XCEngine.ScriptCore/Rendering/Renderer/ScriptableRenderer.cs
similarity index 93%
rename from managed/XCEngine.ScriptCore/ScriptableRenderer.cs
rename to managed/XCEngine.ScriptCore/Rendering/Renderer/ScriptableRenderer.cs
index c102db5d..87932bad 100644
--- a/managed/XCEngine.ScriptCore/ScriptableRenderer.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Renderer/ScriptableRenderer.cs
@@ -1,6 +1,8 @@
 using System.Collections.Generic;
+using XCEngine;
+using XCEngine.Rendering;
 
-namespace XCEngine
+namespace XCEngine.Rendering.Renderer
 {
     public abstract class ScriptableRenderer
     {
@@ -79,6 +81,8 @@ namespace XCEngine
 
             RenderingData renderingData =
                 new RenderingData(context);
+            RendererRecordingContext recordingContext =
+                new RendererRecordingContext(context);
             BuildPassQueue(renderingData);
 
             bool recordedAnyPass = false;
@@ -92,7 +96,7 @@ namespace XCEngine
                 }
 
                 if (!renderPass.Record(
-                        context,
+                        recordingContext,
                         renderingData))
                 {
                     return false;
@@ -126,3 +130,4 @@ namespace XCEngine
         }
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/ScriptableRendererData.cs b/managed/XCEngine.ScriptCore/Rendering/Renderer/ScriptableRendererData.cs
similarity index 97%
rename from managed/XCEngine.ScriptCore/ScriptableRendererData.cs
rename to managed/XCEngine.ScriptCore/Rendering/Renderer/ScriptableRendererData.cs
index 867ebca6..db8a2a21 100644
--- a/managed/XCEngine.ScriptCore/ScriptableRendererData.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Renderer/ScriptableRendererData.cs
@@ -1,6 +1,8 @@
 using System;
+using XCEngine;
+using XCEngine.Rendering;
 
-namespace XCEngine
+namespace XCEngine.Rendering.Renderer
 {
     public abstract class ScriptableRendererData : Object
     {
@@ -97,3 +99,4 @@ namespace XCEngine
         }
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/ScriptableRendererFeature.cs b/managed/XCEngine.ScriptCore/Rendering/Renderer/ScriptableRendererFeature.cs
similarity index 89%
rename from managed/XCEngine.ScriptCore/ScriptableRendererFeature.cs
rename to managed/XCEngine.ScriptCore/Rendering/Renderer/ScriptableRendererFeature.cs
index 8db647ce..0e259ef1 100644
--- a/managed/XCEngine.ScriptCore/ScriptableRendererFeature.cs
+++ b/managed/XCEngine.ScriptCore/Rendering/Renderer/ScriptableRendererFeature.cs
@@ -1,4 +1,7 @@
-namespace XCEngine
+using XCEngine;
+using XCEngine.Rendering;
+
+namespace XCEngine.Rendering.Renderer
 {
     public abstract class ScriptableRendererFeature
     {
@@ -29,3 +32,4 @@ namespace XCEngine
         }
     }
 }
+
diff --git a/managed/XCEngine.ScriptCore/ScenePhase.cs b/managed/XCEngine.ScriptCore/ScenePhase.cs
deleted file mode 100644
index a65aecf9..00000000
--- a/managed/XCEngine.ScriptCore/ScenePhase.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-namespace XCEngine
-{
-    public enum ScenePhase
-    {
-        Opaque = 0,
-        Skybox = 1,
-        Transparent = 3,
-        EditorExtension = 4,
-        PostProcess = 5,
-        FinalOutput = 6
-    }
-}
diff --git a/managed/XCEngine.ScriptCore/SceneRenderInjectionPoint.cs b/managed/XCEngine.ScriptCore/SceneRenderInjectionPoint.cs
deleted file mode 100644
index 6faa8cb5..00000000
--- a/managed/XCEngine.ScriptCore/SceneRenderInjectionPoint.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-namespace XCEngine
-{
-    public enum SceneRenderInjectionPoint
-    {
-        BeforeOpaque = 0,
-        AfterOpaque = 1,
-        BeforeSkybox = 2,
-        AfterSkybox = 3,
-        BeforeTransparent = 4,
-        AfterTransparent = 5
-    }
-}
diff --git a/managed/XCEngine.ScriptCore/ScriptableRenderPipelineAsset.cs b/managed/XCEngine.ScriptCore/ScriptableRenderPipelineAsset.cs
deleted file mode 100644
index bd699fba..00000000
--- a/managed/XCEngine.ScriptCore/ScriptableRenderPipelineAsset.cs
+++ /dev/null
@@ -1,57 +0,0 @@
-namespace XCEngine
-{
-    public abstract class ScriptableRenderPipelineAsset : RenderPipelineAsset
-    {
-        protected ScriptableRenderPipelineAsset()
-        {
-        }
-
-        protected internal virtual ScriptableRenderPipeline CreatePipeline()
-        {
-            ScriptableRendererData rendererData =
-                ResolveDefaultRendererData();
-            return rendererData != null
-                ? new RendererDrivenRenderPipeline(rendererData)
-                : null;
-        }
-
-        protected internal virtual void ConfigureCameraRenderRequest(
-            ScriptableRenderPipelineCameraRequestContext context)
-        {
-            ScriptableRendererData rendererData =
-                ResolveDefaultRendererData();
-            if (rendererData != null)
-            {
-                rendererData.ConfigureCameraRenderRequestInstance(
-                    context);
-            }
-        }
-
-        protected internal virtual void ConfigureCameraFramePlan(
-            ScriptableRenderPipelinePlanningContext context)
-        {
-            ScriptableRendererData rendererData =
-                ResolveDefaultRendererData();
-            if (rendererData != null)
-            {
-                rendererData.ConfigureCameraFramePlanInstance(
-                    context);
-            }
-        }
-
-        protected internal virtual FinalColorSettings GetDefaultFinalColorSettings()
-        {
-            return FinalColorSettings.CreateDefault();
-        }
-
-        internal ScriptableRendererData ResolveDefaultRendererData()
-        {
-            return GetDefaultRendererData();
-        }
-
-        protected virtual ScriptableRendererData GetDefaultRendererData()
-        {
-            return null;
-        }
-    }
-}