feat(rendering): add managed SRP renderer runtime

managed/XCEngine.ScriptCore/CameraData.cs

@@ -0,0 +1,109 @@
+namespace XCEngine
+{
+    public sealed class CameraData
+    {
+        internal static readonly CameraData Default =
+            new CameraData(
+                Matrix4x4.Identity,
+                Matrix4x4.Identity,
+                Matrix4x4.Identity,
+                new Vector3(0.0f, 0.0f, 0.0f),
+                new Vector3(1.0f, 0.0f, 0.0f),
+                new Vector3(0.0f, 1.0f, 0.0f),
+                new Vector3(0.0f, 0.0f, 1.0f),
+                new Color(0.0f, 0.0f, 0.0f, 1.0f),
+                RenderClearFlags.All,
+                true,
+                60.0f * 0.017453292519943295f,
+                5.0f,
+                1.0f,
+                0.1f,
+                1000.0f,
+                0,
+                0);
+
+        internal CameraData(
+            Matrix4x4 view,
+            Matrix4x4 projection,
+            Matrix4x4 viewProjection,
+            Vector3 worldPosition,
+            Vector3 worldRight,
+            Vector3 worldUp,
+            Vector3 worldForward,
+            Color clearColor,
+            RenderClearFlags clearFlags,
+            bool perspectiveProjection,
+            float verticalFovRadians,
+            float orthographicSize,
+            float aspectRatio,
+            float nearClipPlane,
+            float farClipPlane,
+            int viewportWidth,
+            int viewportHeight)
+        {
+            this.view = view;
+            this.projection = projection;
+            this.viewProjection = viewProjection;
+            this.worldPosition = worldPosition;
+            this.worldRight = worldRight;
+            this.worldUp = worldUp;
+            this.worldForward = worldForward;
+            this.clearColor = clearColor;
+            this.clearFlags = clearFlags;
+            this.perspectiveProjection = perspectiveProjection;
+            this.verticalFovRadians = verticalFovRadians;
+            this.orthographicSize = orthographicSize;
+            this.aspectRatio = aspectRatio;
+            this.nearClipPlane = nearClipPlane;
+            this.farClipPlane = farClipPlane;
+            this.viewportWidth = viewportWidth;
+            this.viewportHeight = viewportHeight;
+        }
+
+        public Matrix4x4 view { get; }
+
+        public Matrix4x4 projection { get; }
+
+        public Matrix4x4 viewProjection { get; }
+
+        public Vector3 worldPosition { get; }
+
+        public Vector3 worldRight { get; }
+
+        public Vector3 worldUp { get; }
+
+        public Vector3 worldForward { get; }
+
+        public Color clearColor { get; }
+
+        public RenderClearFlags clearFlags { get; }
+
+        public bool perspectiveProjection { get; }
+
+        public bool isPerspectiveProjection =>
+            perspectiveProjection;
+
+        public bool isOrthographicProjection =>
+            !perspectiveProjection;
+
+        public bool clearsColor =>
+            (clearFlags & RenderClearFlags.Color) != 0;
+
+        public bool clearsDepth =>
+            (clearFlags & RenderClearFlags.Depth) != 0;
+
+        public float verticalFovRadians { get; }
+
+        public float orthographicSize { get; }
+
+        public float aspectRatio { get; }
+
+        public float nearClipPlane { get; }
+
+        public float farClipPlane { get; }
+
+        public int viewportWidth { get; }
+
+        public int viewportHeight { get; }
+    }
+}

managed/XCEngine.ScriptCore/Color.cs

@@ -0,0 +1,49 @@
+using System.Runtime.InteropServices;
+
+namespace XCEngine
+{
+    [StructLayout(LayoutKind.Sequential)]
+    public struct Color
+    {
+        public float R;
+        public float G;
+        public float B;
+        public float A;
+
+        public float r
+        {
+            get => R;
+            set => R = value;
+        }
+
+        public float g
+        {
+            get => G;
+            set => G = value;
+        }
+
+        public float b
+        {
+            get => B;
+            set => B = value;
+        }
+
+        public float a
+        {
+            get => A;
+            set => A = value;
+        }
+
+        public Color(
+            float r,
+            float g,
+            float b,
+            float a = 1.0f)
+        {
+            R = r;
+            G = g;
+            B = b;
+            A = a;
+        }
+    }
+}

managed/XCEngine.ScriptCore/ColorScalePostProcessRendererFeature.cs

@@ -0,0 +1,79 @@
+namespace XCEngine
+{
+    internal sealed class ColorScalePostProcessPass
+        : ScriptableRenderPass
+    {
+        private readonly ColorScalePostProcessRendererFeature m_feature;
+
+        public ColorScalePostProcessPass(
+            ColorScalePostProcessRendererFeature feature)
+        {
+            m_feature = feature;
+            renderPassEvent =
+                RenderPassEvent.BeforeRenderingPostProcessing;
+        }
+
+        protected override bool RecordRenderGraph(
+            ScriptableRenderContext context,
+            RenderingData renderingData)
+        {
+            return context != null &&
+                   renderingData != null &&
+                   renderingData.isPostProcessStage &&
+                   m_feature != null &&
+                   context.RecordFullscreenPass(
+                       FullscreenPassDescriptor.CreateColorScale(
+                           m_feature.colorScale));
+        }
+    }
+
+    public sealed class ColorScalePostProcessRendererFeature
+        : ScriptableRendererFeature
+    {
+        private ColorScalePostProcessPass m_pass;
+
+        public Vector4 colorScale = new Vector4(
+            1.0f,
+            1.0f,
+            1.0f,
+            1.0f);
+
+        public override void Create()
+        {
+            m_pass =
+                new ColorScalePostProcessPass(this);
+        }
+
+        public override void ConfigureCameraFramePlan(
+            ScriptableRenderPipelinePlanningContext context)
+        {
+            if (context == null)
+            {
+                return;
+            }
+
+            context.RequestFullscreenStage(
+                CameraFrameStage.PostProcess,
+                CameraFrameColorSource.MainSceneColor);
+        }
+
+        public override void AddRenderPasses(
+            ScriptableRenderer renderer,
+            RenderingData renderingData)
+        {
+            if (renderer == null ||
+                renderingData == null ||
+                !renderingData.isPostProcessStage)
+            {
+                return;
+            }
+
+            if (m_pass == null)
+            {
+                Create();
+            }
+
+            renderer.EnqueuePass(m_pass);
+        }
+    }
+}

managed/XCEngine.ScriptCore/DirectionalLightData.cs

@@ -0,0 +1,40 @@
+namespace XCEngine
+{
+    public sealed class DirectionalLightData
+    {
+        internal static readonly DirectionalLightData Default =
+            new DirectionalLightData(
+                false,
+                false,
+                new Vector3(0.0f, 0.0f, -1.0f),
+                new Color(1.0f, 1.0f, 1.0f, 1.0f),
+                1.0f);
+
+        internal DirectionalLightData(
+            bool enabled,
+            bool castsShadows,
+            Vector3 direction,
+            Color color,
+            float intensity)
+        {
+            this.enabled = enabled;
+            this.castsShadows = castsShadows;
+            this.direction = direction;
+            this.color = color;
+            this.intensity = intensity;
+        }
+
+        public bool enabled { get; }
+
+        public bool castsShadows { get; }
+
+        public Vector3 direction { get; }
+
+        public Color color { get; }
+
+        public float intensity { get; }
+
+        public bool isValid =>
+            enabled;
+    }
+}

managed/XCEngine.ScriptCore/DirectionalShadowData.cs

@@ -0,0 +1,83 @@
+namespace XCEngine
+{
+    public sealed class DirectionalShadowData
+    {
+        internal static readonly DirectionalShadowData Default =
+            new DirectionalShadowData(
+                false,
+                Matrix4x4.Identity,
+                0.0f,
+                0.1f,
+                0.0f,
+                0,
+                0,
+                0.0f,
+                0.0f,
+                0.0f,
+                0.0f,
+                0.0f,
+                0);
+
+        internal DirectionalShadowData(
+            bool enabled,
+            Matrix4x4 viewProjection,
+            float orthographicHalfExtent,
+            float nearClipPlane,
+            float farClipPlane,
+            int mapWidth,
+            int mapHeight,
+            float worldTexelSize,
+            float receiverDepthBias,
+            float normalBiasScale,
+            float shadowStrength,
+            float depthBiasFactor,
+            int depthBiasUnits)
+        {
+            this.enabled = enabled;
+            this.viewProjection = viewProjection;
+            this.orthographicHalfExtent =
+                orthographicHalfExtent;
+            this.nearClipPlane = nearClipPlane;
+            this.farClipPlane = farClipPlane;
+            this.mapWidth = mapWidth;
+            this.mapHeight = mapHeight;
+            this.worldTexelSize = worldTexelSize;
+            this.receiverDepthBias = receiverDepthBias;
+            this.normalBiasScale = normalBiasScale;
+            this.shadowStrength = shadowStrength;
+            this.depthBiasFactor = depthBiasFactor;
+            this.depthBiasUnits = depthBiasUnits;
+        }
+
+        public bool enabled { get; }
+
+        public Matrix4x4 viewProjection { get; }
+
+        public float orthographicHalfExtent { get; }
+
+        public float nearClipPlane { get; }
+
+        public float farClipPlane { get; }
+
+        public int mapWidth { get; }
+
+        public int mapHeight { get; }
+
+        public float worldTexelSize { get; }
+
+        public float receiverDepthBias { get; }
+
+        public float normalBiasScale { get; }
+
+        public float shadowStrength { get; }
+
+        public float depthBiasFactor { get; }
+
+        public int depthBiasUnits { get; }
+
+        public bool hasShadowMap =>
+            enabled &&
+            mapWidth > 0 &&
+            mapHeight > 0;
+    }
+}

managed/XCEngine.ScriptCore/DisableDirectionalShadowRendererFeature.cs

@@ -0,0 +1,16 @@
+namespace XCEngine
+{
+    public sealed class DisableDirectionalShadowRendererFeature
+        : ScriptableRendererFeature
+    {
+        public override void ConfigureCameraRenderRequest(
+            ScriptableRenderPipelineCameraRequestContext context)
+        {
+            if (context != null &&
+                context.hasDirectionalShadow)
+            {
+                context.ClearDirectionalShadow();
+            }
+        }
+    }
+}

managed/XCEngine.ScriptCore/EnvironmentData.cs

@@ -0,0 +1,41 @@
+namespace XCEngine
+{
+    public sealed class EnvironmentData
+    {
+        internal static readonly EnvironmentData Default =
+            new EnvironmentData(
+                RenderEnvironmentMode.None,
+                new Color(0.18f, 0.36f, 0.74f, 1.0f),
+                new Color(0.78f, 0.84f, 0.92f, 1.0f),
+                new Color(0.92f, 0.93f, 0.95f, 1.0f));
+
+        internal EnvironmentData(
+            RenderEnvironmentMode mode,
+            Color skyboxTopColor,
+            Color skyboxHorizonColor,
+            Color skyboxBottomColor)
+        {
+            this.mode = mode;
+            this.skyboxTopColor = skyboxTopColor;
+            this.skyboxHorizonColor = skyboxHorizonColor;
+            this.skyboxBottomColor = skyboxBottomColor;
+        }
+
+        public RenderEnvironmentMode mode { get; }
+
+        public Color skyboxTopColor { get; }
+
+        public Color skyboxHorizonColor { get; }
+
+        public Color skyboxBottomColor { get; }
+
+        public bool hasProceduralSkybox =>
+            mode == RenderEnvironmentMode.ProceduralSkybox;
+
+        public bool hasMaterialSkybox =>
+            mode == RenderEnvironmentMode.MaterialSkybox;
+
+        public bool hasSkybox =>
+            hasProceduralSkybox || hasMaterialSkybox;
+    }
+}

managed/XCEngine.ScriptCore/FinalColorData.cs

@@ -0,0 +1,39 @@
+namespace XCEngine
+{
+    public sealed class FinalColorData
+    {
+        internal static readonly FinalColorData Default =
+            new FinalColorData(
+                FinalColorSettings.CreateDefault(),
+                false,
+                false);
+
+        internal FinalColorData(
+            FinalColorSettings settings,
+            bool hasPipelineDefaults,
+            bool hasCameraOverrides)
+        {
+            this.settings = settings;
+            this.hasPipelineDefaults = hasPipelineDefaults;
+            this.hasCameraOverrides = hasCameraOverrides;
+        }
+
+        public FinalColorSettings settings { get; }
+
+        public bool hasPipelineDefaults { get; }
+
+        public bool hasCameraOverrides { get; }
+
+        public bool requiresProcessing =>
+            settings.outputTransferMode !=
+                FinalColorOutputTransferMode.Disabled ||
+            settings.exposureMode !=
+                FinalColorExposureMode.Disabled ||
+            settings.toneMappingMode !=
+                FinalColorToneMappingMode.Disabled ||
+            settings.finalColorScale.x != 1.0f ||
+            settings.finalColorScale.y != 1.0f ||
+            settings.finalColorScale.z != 1.0f ||
+            settings.finalColorScale.w != 1.0f;
+    }
+}

managed/XCEngine.ScriptCore/ForwardRenderPipelineAsset.cs

@@ -0,0 +1,18 @@
+namespace XCEngine
+{
+    public class ForwardRenderPipelineAsset : ScriptableRenderPipelineAsset
+    {
+        public ForwardRendererData rendererData =
+            new ForwardRendererData();
+
+        protected override ScriptableRendererData GetDefaultRendererData()
+        {
+            if (rendererData == null)
+            {
+                rendererData = new ForwardRendererData();
+            }
+
+            return rendererData;
+        }
+    }
+}

managed/XCEngine.ScriptCore/ForwardRenderer.cs

@@ -0,0 +1,147 @@
+namespace XCEngine
+{
+    internal sealed class ForwardSceneInjectionPass : ScriptableRenderPass
+    {
+        private readonly SceneRenderInjectionPoint m_injectionPoint;
+
+        public ForwardSceneInjectionPass(
+            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 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);
+        }
+    }
+
+    internal sealed class ForwardSceneFeature : ScriptableRendererFeature
+    {
+        private readonly ForwardRendererData m_rendererData;
+        private readonly ForwardSceneInjectionPass m_beforeOpaquePass =
+            new ForwardSceneInjectionPass(
+                RenderPassEvent.BeforeRenderingOpaques,
+                SceneRenderInjectionPoint.BeforeOpaque);
+        private readonly ForwardScenePhasePass m_opaquePass =
+            new ForwardScenePhasePass(
+                RenderPassEvent.RenderOpaques,
+                ScenePhase.Opaque);
+        private readonly ForwardSceneInjectionPass m_afterOpaquePass =
+            new ForwardSceneInjectionPass(
+                RenderPassEvent.AfterRenderingOpaques,
+                SceneRenderInjectionPoint.AfterOpaque);
+        private readonly ForwardSceneInjectionPass m_beforeSkyboxPass =
+            new ForwardSceneInjectionPass(
+                RenderPassEvent.BeforeRenderingSkybox,
+                SceneRenderInjectionPoint.BeforeSkybox);
+        private readonly ForwardScenePhasePass m_skyboxPass =
+            new ForwardScenePhasePass(
+                RenderPassEvent.RenderSkybox,
+                ScenePhase.Skybox);
+        private readonly ForwardSceneInjectionPass m_afterSkyboxPass =
+            new ForwardSceneInjectionPass(
+                RenderPassEvent.AfterRenderingSkybox,
+                SceneRenderInjectionPoint.AfterSkybox);
+        private readonly ForwardSceneInjectionPass m_beforeTransparentPass =
+            new ForwardSceneInjectionPass(
+                RenderPassEvent.BeforeRenderingTransparents,
+                SceneRenderInjectionPoint.BeforeTransparent);
+        private readonly ForwardScenePhasePass m_transparentPass =
+            new ForwardScenePhasePass(
+                RenderPassEvent.RenderTransparents,
+                ScenePhase.Transparent);
+        private readonly ForwardSceneInjectionPass m_afterTransparentPass =
+            new ForwardSceneInjectionPass(
+                RenderPassEvent.AfterRenderingTransparents,
+                SceneRenderInjectionPoint.AfterTransparent);
+
+        public ForwardSceneFeature(
+            ForwardRendererData rendererData)
+        {
+            m_rendererData = rendererData;
+        }
+
+        public override void AddRenderPasses(
+            ScriptableRenderer renderer,
+            RenderingData renderingData)
+        {
+            if (renderer == null ||
+                renderingData == null ||
+                !renderingData.isMainSceneStage ||
+                m_rendererData == null)
+            {
+                return;
+            }
+
+            if (m_rendererData.renderOpaque)
+            {
+                renderer.EnqueuePass(m_beforeOpaquePass);
+                renderer.EnqueuePass(m_opaquePass);
+                renderer.EnqueuePass(m_afterOpaquePass);
+            }
+
+            if (m_rendererData.renderSkybox)
+            {
+                renderer.EnqueuePass(m_beforeSkyboxPass);
+                renderer.EnqueuePass(m_skyboxPass);
+                renderer.EnqueuePass(m_afterSkyboxPass);
+            }
+
+            if (m_rendererData.renderTransparent)
+            {
+                renderer.EnqueuePass(m_beforeTransparentPass);
+                renderer.EnqueuePass(m_transparentPass);
+                renderer.EnqueuePass(m_afterTransparentPass);
+            }
+        }
+    }
+
+    public sealed class ForwardRenderer : ScriptableRenderer
+    {
+        public ForwardRenderer(
+            ForwardRendererData rendererData)
+        {
+            ForwardRendererData resolvedData =
+                rendererData ?? new ForwardRendererData();
+            AddFeature(new ForwardSceneFeature(resolvedData));
+
+            ScriptableRendererFeature[] rendererFeatures =
+                resolvedData.CreateRendererFeaturesInstance();
+            for (int i = 0; i < rendererFeatures.Length; ++i)
+            {
+                AddFeature(rendererFeatures[i]);
+            }
+        }
+    }
+}

managed/XCEngine.ScriptCore/ForwardRendererData.cs

@@ -0,0 +1,24 @@
+using System;
+
+namespace XCEngine
+{
+    public class ForwardRendererData : ScriptableRendererData
+    {
+        public bool renderOpaque = true;
+        public bool renderSkybox = true;
+        public bool renderTransparent = true;
+        public ScriptableRendererFeature[] rendererFeatures =
+            Array.Empty<ScriptableRendererFeature>();
+
+        protected override ScriptableRenderer CreateRenderer()
+        {
+            return new ForwardRenderer(this);
+        }
+
+        protected override ScriptableRendererFeature[] CreateRendererFeatures()
+        {
+            return rendererFeatures ??
+                   Array.Empty<ScriptableRendererFeature>();
+        }
+    }
+}

managed/XCEngine.ScriptCore/InternalCalls.cs

@@ -388,11 +388,276 @@ namespace XCEngine
         internal static extern int Rendering_ScriptableRenderContext_GetStage(
             ulong nativeHandle);
 
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern int
+            Rendering_ScriptableRenderContext_GetStageColorSource(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern bool
+            Rendering_ScriptableRenderContext_GetStageUsesGraphManagedOutputColor(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern bool
+            Rendering_ScriptableRenderContext_GetMainDirectionalShadowEnabled(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern void
+            Rendering_ScriptableRenderContext_GetMainDirectionalShadowViewProjection(
+                ulong nativeHandle,
+                out Matrix4x4 viewProjection);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern float
+            Rendering_ScriptableRenderContext_GetMainDirectionalShadowOrthographicHalfExtent(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern float
+            Rendering_ScriptableRenderContext_GetMainDirectionalShadowNearClipPlane(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern float
+            Rendering_ScriptableRenderContext_GetMainDirectionalShadowFarClipPlane(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern int
+            Rendering_ScriptableRenderContext_GetMainDirectionalShadowMapWidth(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern int
+            Rendering_ScriptableRenderContext_GetMainDirectionalShadowMapHeight(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern float
+            Rendering_ScriptableRenderContext_GetMainDirectionalShadowWorldTexelSize(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern float
+            Rendering_ScriptableRenderContext_GetMainDirectionalShadowReceiverDepthBias(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern float
+            Rendering_ScriptableRenderContext_GetMainDirectionalShadowNormalBiasScale(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern float
+            Rendering_ScriptableRenderContext_GetMainDirectionalShadowStrength(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern float
+            Rendering_ScriptableRenderContext_GetMainDirectionalShadowDepthBiasFactor(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern int
+            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(
+                ulong nativeHandle,
+                out Matrix4x4 view);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern void
+            Rendering_ScriptableRenderContext_GetCameraProjection(
+                ulong nativeHandle,
+                out Matrix4x4 projection);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern void
+            Rendering_ScriptableRenderContext_GetCameraViewProjection(
+                ulong nativeHandle,
+                out Matrix4x4 viewProjection);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern void
+            Rendering_ScriptableRenderContext_GetCameraWorldPosition(
+                ulong nativeHandle,
+                out Vector3 worldPosition);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern void
+            Rendering_ScriptableRenderContext_GetCameraWorldRight(
+                ulong nativeHandle,
+                out Vector3 worldRight);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern void
+            Rendering_ScriptableRenderContext_GetCameraWorldUp(
+                ulong nativeHandle,
+                out Vector3 worldUp);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern void
+            Rendering_ScriptableRenderContext_GetCameraWorldForward(
+                ulong nativeHandle,
+                out Vector3 worldForward);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern void
+            Rendering_ScriptableRenderContext_GetCameraClearColor(
+                ulong nativeHandle,
+                out Color clearColor);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern int
+            Rendering_ScriptableRenderContext_GetCameraClearFlags(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern bool
+            Rendering_ScriptableRenderContext_GetCameraPerspectiveProjection(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern float
+            Rendering_ScriptableRenderContext_GetCameraVerticalFovRadians(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern float
+            Rendering_ScriptableRenderContext_GetCameraOrthographicSize(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern float
+            Rendering_ScriptableRenderContext_GetCameraAspectRatio(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern float
+            Rendering_ScriptableRenderContext_GetCameraNearClipPlane(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern float
+            Rendering_ScriptableRenderContext_GetCameraFarClipPlane(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern int
+            Rendering_ScriptableRenderContext_GetCameraViewportWidth(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern int
+            Rendering_ScriptableRenderContext_GetCameraViewportHeight(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern bool
+            Rendering_ScriptableRenderContext_GetMainDirectionalLightEnabled(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern bool
+            Rendering_ScriptableRenderContext_GetMainDirectionalLightCastsShadows(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern void
+            Rendering_ScriptableRenderContext_GetMainDirectionalLightDirection(
+                ulong nativeHandle,
+                out Vector3 direction);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern void
+            Rendering_ScriptableRenderContext_GetMainDirectionalLightColor(
+                ulong nativeHandle,
+                out Color color);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern float
+            Rendering_ScriptableRenderContext_GetMainDirectionalLightIntensity(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern bool
+            Rendering_ScriptableRenderContext_GetHasMainDirectionalShadow(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern int
+            Rendering_ScriptableRenderContext_GetAdditionalLightCount(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern int
+            Rendering_ScriptableRenderContext_GetEnvironmentMode(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern void
+            Rendering_ScriptableRenderContext_GetEnvironmentSkyboxTopColor(
+                ulong nativeHandle,
+                out Color color);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern void
+            Rendering_ScriptableRenderContext_GetEnvironmentSkyboxHorizonColor(
+                ulong nativeHandle,
+                out Color color);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern void
+            Rendering_ScriptableRenderContext_GetEnvironmentSkyboxBottomColor(
+                ulong nativeHandle,
+                out Color color);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern int
+            Rendering_ScriptableRenderContext_GetFinalColorOutputTransferMode(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern int
+            Rendering_ScriptableRenderContext_GetFinalColorExposureMode(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern float
+            Rendering_ScriptableRenderContext_GetFinalColorExposureValue(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern int
+            Rendering_ScriptableRenderContext_GetFinalColorToneMappingMode(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern void
+            Rendering_ScriptableRenderContext_GetFinalColorScale(
+                ulong nativeHandle,
+                out Vector4 scale);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern bool
+            Rendering_ScriptableRenderContext_GetFinalColorHasPipelineDefaults(
+                ulong nativeHandle);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern bool
+            Rendering_ScriptableRenderContext_GetFinalColorHasCameraOverrides(
+                ulong nativeHandle);
+
         [MethodImpl(MethodImplOptions.InternalCall)]
         internal static extern bool
             Rendering_ScriptableRenderContext_RecordScenePhase(

managed/XCEngine.ScriptCore/LightingData.cs

@@ -0,0 +1,35 @@
+namespace XCEngine
+{
+    public sealed class LightingData
+    {
+        internal static readonly LightingData Default =
+            new LightingData(
+                DirectionalLightData.Default,
+                false,
+                0);
+
+        internal LightingData(
+            DirectionalLightData mainDirectionalLight,
+            bool hasMainDirectionalShadow,
+            int additionalLightCount)
+        {
+            this.mainDirectionalLight =
+                mainDirectionalLight ?? DirectionalLightData.Default;
+            this.hasMainDirectionalShadow =
+                hasMainDirectionalShadow;
+            this.additionalLightCount = additionalLightCount;
+        }
+
+        public DirectionalLightData mainDirectionalLight { get; }
+
+        public bool hasMainDirectionalShadow { get; }
+
+        public int additionalLightCount { get; }
+
+        public bool hasMainDirectionalLight =>
+            mainDirectionalLight.enabled;
+
+        public bool hasAdditionalLights =>
+            additionalLightCount > 0;
+    }
+}

managed/XCEngine.ScriptCore/Matrix4x4.cs

@@ -0,0 +1,221 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace XCEngine
+{
+    [StructLayout(LayoutKind.Sequential)]
+    public struct Matrix4x4
+    {
+        public float M00;
+        public float M01;
+        public float M02;
+        public float M03;
+        public float M10;
+        public float M11;
+        public float M12;
+        public float M13;
+        public float M20;
+        public float M21;
+        public float M22;
+        public float M23;
+        public float M30;
+        public float M31;
+        public float M32;
+        public float M33;
+
+        public static Matrix4x4 Identity =>
+            new Matrix4x4
+            {
+                M00 = 1.0f,
+                M11 = 1.0f,
+                M22 = 1.0f,
+                M33 = 1.0f
+            };
+
+        public float this[int row, int column]
+        {
+            get
+            {
+                switch (row)
+                {
+                    case 0:
+                        switch (column)
+                        {
+                            case 0:
+                                return M00;
+                            case 1:
+                                return M01;
+                            case 2:
+                                return M02;
+                            case 3:
+                                return M03;
+                            default:
+                                throw new ArgumentOutOfRangeException(
+                                    nameof(column));
+                        }
+                    case 1:
+                        switch (column)
+                        {
+                            case 0:
+                                return M10;
+                            case 1:
+                                return M11;
+                            case 2:
+                                return M12;
+                            case 3:
+                                return M13;
+                            default:
+                                throw new ArgumentOutOfRangeException(
+                                    nameof(column));
+                        }
+                    case 2:
+                        switch (column)
+                        {
+                            case 0:
+                                return M20;
+                            case 1:
+                                return M21;
+                            case 2:
+                                return M22;
+                            case 3:
+                                return M23;
+                            default:
+                                throw new ArgumentOutOfRangeException(
+                                    nameof(column));
+                        }
+                    case 3:
+                        switch (column)
+                        {
+                            case 0:
+                                return M30;
+                            case 1:
+                                return M31;
+                            case 2:
+                                return M32;
+                            case 3:
+                                return M33;
+                            default:
+                                throw new ArgumentOutOfRangeException(
+                                    nameof(column));
+                        }
+                    default:
+                        throw new ArgumentOutOfRangeException(nameof(row));
+                }
+            }
+            set
+            {
+                switch (row)
+                {
+                    case 0:
+                        switch (column)
+                        {
+                            case 0:
+                                M00 = value;
+                                return;
+                            case 1:
+                                M01 = value;
+                                return;
+                            case 2:
+                                M02 = value;
+                                return;
+                            case 3:
+                                M03 = value;
+                                return;
+                        }
+                        break;
+                    case 1:
+                        switch (column)
+                        {
+                            case 0:
+                                M10 = value;
+                                return;
+                            case 1:
+                                M11 = value;
+                                return;
+                            case 2:
+                                M12 = value;
+                                return;
+                            case 3:
+                                M13 = value;
+                                return;
+                        }
+                        break;
+                    case 2:
+                        switch (column)
+                        {
+                            case 0:
+                                M20 = value;
+                                return;
+                            case 1:
+                                M21 = value;
+                                return;
+                            case 2:
+                                M22 = value;
+                                return;
+                            case 3:
+                                M23 = value;
+                                return;
+                        }
+                        break;
+                    case 3:
+                        switch (column)
+                        {
+                            case 0:
+                                M30 = value;
+                                return;
+                            case 1:
+                                M31 = value;
+                                return;
+                            case 2:
+                                M32 = value;
+                                return;
+                            case 3:
+                                M33 = value;
+                                return;
+                        }
+                        break;
+                }
+
+                throw new ArgumentOutOfRangeException(
+                    row < 0 || row > 3
+                        ? nameof(row)
+                        : nameof(column));
+            }
+        }
+
+        public Vector4 GetRow(int row)
+        {
+            switch (row)
+            {
+                case 0:
+                    return new Vector4(M00, M01, M02, M03);
+                case 1:
+                    return new Vector4(M10, M11, M12, M13);
+                case 2:
+                    return new Vector4(M20, M21, M22, M23);
+                case 3:
+                    return new Vector4(M30, M31, M32, M33);
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(row));
+            }
+        }
+
+        public Vector4 GetColumn(int column)
+        {
+            switch (column)
+            {
+                case 0:
+                    return new Vector4(M00, M10, M20, M30);
+                case 1:
+                    return new Vector4(M01, M11, M21, M31);
+                case 2:
+                    return new Vector4(M02, M12, M22, M32);
+                case 3:
+                    return new Vector4(M03, M13, M23, M33);
+                default:
+                    throw new ArgumentOutOfRangeException(
+                        nameof(column));
+            }
+        }
+    }
+}

managed/XCEngine.ScriptCore/RenderClearFlags.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace XCEngine
+{
+    [Flags]
+    public enum RenderClearFlags
+    {
+        None = 0,
+        Color = 1 << 0,
+        Depth = 1 << 1,
+        All = Color | Depth
+    }
+}

managed/XCEngine.ScriptCore/RenderEnvironmentMode.cs

@@ -0,0 +1,9 @@
+namespace XCEngine
+{
+    public enum RenderEnvironmentMode
+    {
+        None = 0,
+        ProceduralSkybox = 1,
+        MaterialSkybox = 2
+    }
+}

managed/XCEngine.ScriptCore/RenderPassEvent.cs

@@ -0,0 +1,19 @@
+namespace XCEngine
+{
+    public enum RenderPassEvent
+    {
+        BeforeRenderingOpaques = 100,
+        RenderOpaques = 110,
+        AfterRenderingOpaques = 120,
+        BeforeRenderingSkybox = 200,
+        RenderSkybox = 210,
+        AfterRenderingSkybox = 220,
+        BeforeRenderingTransparents = 300,
+        RenderTransparents = 310,
+        AfterRenderingTransparents = 320,
+        BeforeRenderingPostProcessing = 400,
+        AfterRenderingPostProcessing = 420,
+        BeforeRenderingFinalOutput = 500,
+        AfterRenderingFinalOutput = 520
+    }
+}

managed/XCEngine.ScriptCore/RendererDrivenRenderPipeline.cs

@@ -0,0 +1,20 @@
+namespace XCEngine
+{
+    public class RendererDrivenRenderPipeline : ScriptableRenderPipeline
+    {
+        private readonly ScriptableRendererData m_rendererData;
+
+        public RendererDrivenRenderPipeline(
+            ScriptableRendererData rendererData)
+        {
+            m_rendererData = rendererData;
+        }
+
+        protected internal override ScriptableRenderer CreateRenderer()
+        {
+            return m_rendererData != null
+                ? m_rendererData.CreateRendererInstance()
+                : null;
+        }
+    }
+}

managed/XCEngine.ScriptCore/RenderingData.cs

@@ -0,0 +1,89 @@
+namespace XCEngine
+{
+    public sealed class RenderingData
+    {
+        internal RenderingData(CameraFrameStage stage)
+            : this(
+                stage,
+                CameraData.Default,
+                LightingData.Default,
+                ShadowData.Default,
+                EnvironmentData.Default,
+                FinalColorData.Default,
+                StageColorData.Default)
+        {
+        }
+
+        internal RenderingData(ScriptableRenderContext context)
+            : this(
+                context != null
+                    ? context.stage
+                    : CameraFrameStage.MainScene,
+                context != null
+                    ? context.cameraData
+                    : CameraData.Default,
+                context != null
+                    ? context.lightingData
+                    : LightingData.Default,
+                context != null
+                    ? context.shadowData
+                    : ShadowData.Default,
+                context != null
+                    ? context.environmentData
+                    : EnvironmentData.Default,
+                context != null
+                    ? context.finalColorData
+                    : FinalColorData.Default,
+                context != null
+                    ? context.stageColorData
+                    : StageColorData.Default)
+        {
+        }
+
+        private RenderingData(
+            CameraFrameStage stage,
+            CameraData cameraData,
+            LightingData lightingData,
+            ShadowData shadowData,
+            EnvironmentData environmentData,
+            FinalColorData finalColorData,
+            StageColorData stageColorData)
+        {
+            this.stage = stage;
+            this.cameraData = cameraData ?? CameraData.Default;
+            this.lightingData =
+                lightingData ?? LightingData.Default;
+            this.shadowData =
+                shadowData ?? ShadowData.Default;
+            this.environmentData =
+                environmentData ?? EnvironmentData.Default;
+            this.finalColorData =
+                finalColorData ?? FinalColorData.Default;
+            this.stageColorData =
+                stageColorData ?? StageColorData.Default;
+        }
+
+        public CameraFrameStage stage { get; }
+
+        public CameraData cameraData { get; }
+
+        public LightingData lightingData { get; }
+
+        public ShadowData shadowData { get; }
+
+        public EnvironmentData environmentData { get; }
+
+        public FinalColorData finalColorData { get; }
+
+        public StageColorData stageColorData { get; }
+
+        public bool isMainSceneStage =>
+            stage == CameraFrameStage.MainScene;
+
+        public bool isPostProcessStage =>
+            stage == CameraFrameStage.PostProcess;
+
+        public bool isFinalOutputStage =>
+            stage == CameraFrameStage.FinalOutput;
+    }
+}

managed/XCEngine.ScriptCore/ScriptableRenderContext.cs

@@ -5,6 +5,12 @@ namespace XCEngine
     public sealed class ScriptableRenderContext
     {
         private readonly ulong m_nativeHandle;
+        private CameraData m_cameraData;
+        private LightingData m_lightingData;
+        private ShadowData m_shadowData;
+        private EnvironmentData m_environmentData;
+        private FinalColorData m_finalColorData;
+        private StageColorData m_stageColorData;
 
         internal ScriptableRenderContext(ulong nativeHandle)
         {
@@ -15,6 +21,27 @@ namespace XCEngine
             (CameraFrameStage)InternalCalls.Rendering_ScriptableRenderContext_GetStage(
                 m_nativeHandle);
 
+        public CameraData cameraData =>
+            m_cameraData ?? (m_cameraData = ResolveCameraData());
+
+        public LightingData lightingData =>
+            m_lightingData ?? (m_lightingData = ResolveLightingData());
+
+        public ShadowData shadowData =>
+            m_shadowData ?? (m_shadowData = ResolveShadowData());
+
+        public EnvironmentData environmentData =>
+            m_environmentData ??
+            (m_environmentData = ResolveEnvironmentData());
+
+        public FinalColorData finalColorData =>
+            m_finalColorData ??
+            (m_finalColorData = ResolveFinalColorData());
+
+        public StageColorData stageColorData =>
+            m_stageColorData ??
+            (m_stageColorData = ResolveStageColorData());
+
         public bool RecordScene()
         {
             return InternalCalls
@@ -65,5 +92,251 @@ namespace XCEngine
                     passName,
                     ref vectorPayload);
         }
+
+        private CameraData ResolveCameraData()
+        {
+            Matrix4x4 view;
+            Matrix4x4 projection;
+            Matrix4x4 viewProjection;
+            Vector3 worldPosition;
+            Vector3 worldRight;
+            Vector3 worldUp;
+            Vector3 worldForward;
+            Color clearColor;
+
+            InternalCalls
+                .Rendering_ScriptableRenderContext_GetCameraView(
+                    m_nativeHandle,
+                    out view);
+            InternalCalls
+                .Rendering_ScriptableRenderContext_GetCameraProjection(
+                    m_nativeHandle,
+                    out projection);
+            InternalCalls
+                .Rendering_ScriptableRenderContext_GetCameraViewProjection(
+                    m_nativeHandle,
+                    out viewProjection);
+            InternalCalls
+                .Rendering_ScriptableRenderContext_GetCameraWorldPosition(
+                    m_nativeHandle,
+                    out worldPosition);
+            InternalCalls
+                .Rendering_ScriptableRenderContext_GetCameraWorldRight(
+                    m_nativeHandle,
+                    out worldRight);
+            InternalCalls
+                .Rendering_ScriptableRenderContext_GetCameraWorldUp(
+                    m_nativeHandle,
+                    out worldUp);
+            InternalCalls
+                .Rendering_ScriptableRenderContext_GetCameraWorldForward(
+                    m_nativeHandle,
+                    out worldForward);
+            InternalCalls
+                .Rendering_ScriptableRenderContext_GetCameraClearColor(
+                    m_nativeHandle,
+                    out clearColor);
+
+            return new CameraData(
+                view,
+                projection,
+                viewProjection,
+                worldPosition,
+                worldRight,
+                worldUp,
+                worldForward,
+                clearColor,
+                (RenderClearFlags)InternalCalls
+                    .Rendering_ScriptableRenderContext_GetCameraClearFlags(
+                        m_nativeHandle),
+                InternalCalls
+                    .Rendering_ScriptableRenderContext_GetCameraPerspectiveProjection(
+                        m_nativeHandle),
+                InternalCalls
+                    .Rendering_ScriptableRenderContext_GetCameraVerticalFovRadians(
+                        m_nativeHandle),
+                InternalCalls
+                    .Rendering_ScriptableRenderContext_GetCameraOrthographicSize(
+                        m_nativeHandle),
+                InternalCalls
+                    .Rendering_ScriptableRenderContext_GetCameraAspectRatio(
+                        m_nativeHandle),
+                InternalCalls
+                    .Rendering_ScriptableRenderContext_GetCameraNearClipPlane(
+                        m_nativeHandle),
+                InternalCalls
+                    .Rendering_ScriptableRenderContext_GetCameraFarClipPlane(
+                        m_nativeHandle),
+                InternalCalls
+                    .Rendering_ScriptableRenderContext_GetCameraViewportWidth(
+                        m_nativeHandle),
+                InternalCalls
+                    .Rendering_ScriptableRenderContext_GetCameraViewportHeight(
+                        m_nativeHandle));
+        }
+
+        private LightingData ResolveLightingData()
+        {
+            Vector3 mainDirectionalLightDirection;
+            Color mainDirectionalLightColor;
+
+            InternalCalls
+                .Rendering_ScriptableRenderContext_GetMainDirectionalLightDirection(
+                    m_nativeHandle,
+                    out mainDirectionalLightDirection);
+            InternalCalls
+                .Rendering_ScriptableRenderContext_GetMainDirectionalLightColor(
+                    m_nativeHandle,
+                    out mainDirectionalLightColor);
+
+            return new LightingData(
+                new DirectionalLightData(
+                    InternalCalls
+                        .Rendering_ScriptableRenderContext_GetMainDirectionalLightEnabled(
+                            m_nativeHandle),
+                    InternalCalls
+                        .Rendering_ScriptableRenderContext_GetMainDirectionalLightCastsShadows(
+                            m_nativeHandle),
+                    mainDirectionalLightDirection,
+                    mainDirectionalLightColor,
+                    InternalCalls
+                        .Rendering_ScriptableRenderContext_GetMainDirectionalLightIntensity(
+                            m_nativeHandle)),
+                InternalCalls
+                    .Rendering_ScriptableRenderContext_GetHasMainDirectionalShadow(
+                        m_nativeHandle),
+                InternalCalls
+                    .Rendering_ScriptableRenderContext_GetAdditionalLightCount(
+                        m_nativeHandle));
+        }
+
+        private EnvironmentData ResolveEnvironmentData()
+        {
+            Color skyboxTopColor;
+            Color skyboxHorizonColor;
+            Color skyboxBottomColor;
+
+            InternalCalls
+                .Rendering_ScriptableRenderContext_GetEnvironmentSkyboxTopColor(
+                    m_nativeHandle,
+                    out skyboxTopColor);
+            InternalCalls
+                .Rendering_ScriptableRenderContext_GetEnvironmentSkyboxHorizonColor(
+                    m_nativeHandle,
+                    out skyboxHorizonColor);
+            InternalCalls
+                .Rendering_ScriptableRenderContext_GetEnvironmentSkyboxBottomColor(
+                    m_nativeHandle,
+                    out skyboxBottomColor);
+
+            return new EnvironmentData(
+                (RenderEnvironmentMode)InternalCalls
+                    .Rendering_ScriptableRenderContext_GetEnvironmentMode(
+                        m_nativeHandle),
+                skyboxTopColor,
+                skyboxHorizonColor,
+                skyboxBottomColor);
+        }
+
+        private ShadowData ResolveShadowData()
+        {
+            Matrix4x4 viewProjection;
+
+            InternalCalls
+                .Rendering_ScriptableRenderContext_GetMainDirectionalShadowViewProjection(
+                    m_nativeHandle,
+                    out viewProjection);
+
+            return new ShadowData(
+                new DirectionalShadowData(
+                    InternalCalls
+                        .Rendering_ScriptableRenderContext_GetMainDirectionalShadowEnabled(
+                            m_nativeHandle),
+                    viewProjection,
+                    InternalCalls
+                        .Rendering_ScriptableRenderContext_GetMainDirectionalShadowOrthographicHalfExtent(
+                            m_nativeHandle),
+                    InternalCalls
+                        .Rendering_ScriptableRenderContext_GetMainDirectionalShadowNearClipPlane(
+                            m_nativeHandle),
+                    InternalCalls
+                        .Rendering_ScriptableRenderContext_GetMainDirectionalShadowFarClipPlane(
+                            m_nativeHandle),
+                    InternalCalls
+                        .Rendering_ScriptableRenderContext_GetMainDirectionalShadowMapWidth(
+                            m_nativeHandle),
+                    InternalCalls
+                        .Rendering_ScriptableRenderContext_GetMainDirectionalShadowMapHeight(
+                            m_nativeHandle),
+                    InternalCalls
+                        .Rendering_ScriptableRenderContext_GetMainDirectionalShadowWorldTexelSize(
+                            m_nativeHandle),
+                    InternalCalls
+                        .Rendering_ScriptableRenderContext_GetMainDirectionalShadowReceiverDepthBias(
+                            m_nativeHandle),
+                    InternalCalls
+                        .Rendering_ScriptableRenderContext_GetMainDirectionalShadowNormalBiasScale(
+                            m_nativeHandle),
+                    InternalCalls
+                        .Rendering_ScriptableRenderContext_GetMainDirectionalShadowStrength(
+                            m_nativeHandle),
+                    InternalCalls
+                        .Rendering_ScriptableRenderContext_GetMainDirectionalShadowDepthBiasFactor(
+                            m_nativeHandle),
+                    InternalCalls
+                        .Rendering_ScriptableRenderContext_GetMainDirectionalShadowDepthBiasUnits(
+                            m_nativeHandle)));
+        }
+
+        private FinalColorData ResolveFinalColorData()
+        {
+            Vector4 finalColorScale;
+
+            InternalCalls
+                .Rendering_ScriptableRenderContext_GetFinalColorScale(
+                    m_nativeHandle,
+                    out finalColorScale);
+
+            FinalColorSettings settings =
+                FinalColorSettings.CreateDefault();
+            settings.outputTransferMode =
+                (FinalColorOutputTransferMode)InternalCalls
+                    .Rendering_ScriptableRenderContext_GetFinalColorOutputTransferMode(
+                        m_nativeHandle);
+            settings.exposureMode =
+                (FinalColorExposureMode)InternalCalls
+                    .Rendering_ScriptableRenderContext_GetFinalColorExposureMode(
+                        m_nativeHandle);
+            settings.exposureValue =
+                InternalCalls
+                    .Rendering_ScriptableRenderContext_GetFinalColorExposureValue(
+                        m_nativeHandle);
+            settings.toneMappingMode =
+                (FinalColorToneMappingMode)InternalCalls
+                    .Rendering_ScriptableRenderContext_GetFinalColorToneMappingMode(
+                        m_nativeHandle);
+            settings.finalColorScale =
+                finalColorScale;
+
+            return new FinalColorData(
+                settings,
+                InternalCalls
+                    .Rendering_ScriptableRenderContext_GetFinalColorHasPipelineDefaults(
+                        m_nativeHandle),
+                InternalCalls
+                    .Rendering_ScriptableRenderContext_GetFinalColorHasCameraOverrides(
+                        m_nativeHandle));
+        }
+
+        private StageColorData ResolveStageColorData()
+        {
+            return new StageColorData(
+                (CameraFrameColorSource)InternalCalls
+                    .Rendering_ScriptableRenderContext_GetStageColorSource(
+                        m_nativeHandle),
+                InternalCalls
+                    .Rendering_ScriptableRenderContext_GetStageUsesGraphManagedOutputColor(
+                        m_nativeHandle));
+        }
     }
 }

managed/XCEngine.ScriptCore/ScriptableRenderPass.cs

@@ -0,0 +1,66 @@
+namespace XCEngine
+{
+    public abstract class ScriptableRenderPass
+    {
+        protected ScriptableRenderPass()
+        {
+        }
+
+        public RenderPassEvent renderPassEvent { get; protected set; } =
+            RenderPassEvent.BeforeRenderingOpaques;
+
+        public virtual bool SupportsStage(
+            CameraFrameStage stage)
+        {
+            CameraFrameStage resolvedStage;
+            return TryResolveStage(
+                renderPassEvent,
+                out resolvedStage) &&
+                resolvedStage == stage;
+        }
+
+        internal bool Record(
+            ScriptableRenderContext context,
+            RenderingData renderingData)
+        {
+            return RecordRenderGraph(
+                context,
+                renderingData);
+        }
+
+        protected abstract bool RecordRenderGraph(
+            ScriptableRenderContext context,
+            RenderingData renderingData);
+
+        internal static bool TryResolveStage(
+            RenderPassEvent passEvent,
+            out CameraFrameStage stage)
+        {
+            switch (passEvent)
+            {
+                case RenderPassEvent.BeforeRenderingOpaques:
+                case RenderPassEvent.RenderOpaques:
+                case RenderPassEvent.AfterRenderingOpaques:
+                case RenderPassEvent.BeforeRenderingSkybox:
+                case RenderPassEvent.RenderSkybox:
+                case RenderPassEvent.AfterRenderingSkybox:
+                case RenderPassEvent.BeforeRenderingTransparents:
+                case RenderPassEvent.RenderTransparents:
+                case RenderPassEvent.AfterRenderingTransparents:
+                    stage = CameraFrameStage.MainScene;
+                    return true;
+                case RenderPassEvent.BeforeRenderingPostProcessing:
+                case RenderPassEvent.AfterRenderingPostProcessing:
+                    stage = CameraFrameStage.PostProcess;
+                    return true;
+                case RenderPassEvent.BeforeRenderingFinalOutput:
+                case RenderPassEvent.AfterRenderingFinalOutput:
+                    stage = CameraFrameStage.FinalOutput;
+                    return true;
+                default:
+                    stage = CameraFrameStage.MainScene;
+                    return false;
+            }
+        }
+    }
+}

managed/XCEngine.ScriptCore/ScriptableRenderPipeline.cs

@@ -2,20 +2,44 @@ namespace XCEngine
 {
     public abstract class ScriptableRenderPipeline : Object
     {
+        private ScriptableRenderer m_renderer;
+
         protected ScriptableRenderPipeline()
         {
         }
 
+        protected internal virtual ScriptableRenderer CreateRenderer()
+        {
+            return null;
+        }
+
         protected internal virtual bool SupportsStageRenderGraph(
             CameraFrameStage stage)
         {
-            return false;
+            ScriptableRenderer renderer = GetOrCreateRenderer();
+            return renderer != null &&
+                   renderer.SupportsStageRenderGraph(stage);
         }
 
         protected internal virtual bool RecordStageRenderGraph(
             ScriptableRenderContext context)
         {
-            return false;
+            ScriptableRenderer renderer = GetOrCreateRenderer();
+            return renderer != null &&
+                   renderer.RecordStageRenderGraph(context);
+        }
+
+        protected ScriptableRenderer renderer =>
+            GetOrCreateRenderer();
+
+        private ScriptableRenderer GetOrCreateRenderer()
+        {
+            if (m_renderer == null)
+            {
+                m_renderer = CreateRenderer();
+            }
+
+            return m_renderer;
         }
     }
 }

managed/XCEngine.ScriptCore/ScriptableRenderPipelineAsset.cs

@@ -8,22 +8,50 @@ namespace XCEngine
 
         protected internal virtual ScriptableRenderPipeline CreatePipeline()
         {
-            return null;
+            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;
+        }
     }
 }

managed/XCEngine.ScriptCore/ScriptableRenderer.cs

@@ -0,0 +1,128 @@
+using System.Collections.Generic;
+
+namespace XCEngine
+{
+    public abstract class ScriptableRenderer
+    {
+        private readonly List<ScriptableRendererFeature> m_features =
+            new List<ScriptableRendererFeature>();
+        private readonly List<ScriptableRenderPass> m_activePassQueue =
+            new List<ScriptableRenderPass>();
+
+        protected ScriptableRenderer()
+        {
+        }
+
+        public void EnqueuePass(
+            ScriptableRenderPass renderPass)
+        {
+            if (renderPass == null)
+            {
+                return;
+            }
+
+            int insertIndex = m_activePassQueue.Count;
+            while (insertIndex > 0 &&
+                   m_activePassQueue[insertIndex - 1].renderPassEvent >
+                       renderPass.renderPassEvent)
+            {
+                insertIndex--;
+            }
+
+            m_activePassQueue.Insert(
+                insertIndex,
+                renderPass);
+        }
+
+        protected void AddFeature(
+            ScriptableRendererFeature feature)
+        {
+            if (feature == null)
+            {
+                return;
+            }
+
+            m_features.Add(feature);
+            feature.Create();
+        }
+
+        protected virtual void AddRenderPasses(
+            RenderingData renderingData)
+        {
+        }
+
+        internal bool SupportsStageRenderGraph(
+            CameraFrameStage stage)
+        {
+            RenderingData renderingData = new RenderingData(stage);
+            BuildPassQueue(renderingData);
+            for (int i = 0; i < m_activePassQueue.Count; ++i)
+            {
+                ScriptableRenderPass renderPass = m_activePassQueue[i];
+                if (renderPass != null &&
+                    renderPass.SupportsStage(stage))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        internal bool RecordStageRenderGraph(
+            ScriptableRenderContext context)
+        {
+            if (context == null)
+            {
+                return false;
+            }
+
+            RenderingData renderingData =
+                new RenderingData(context);
+            BuildPassQueue(renderingData);
+
+            bool recordedAnyPass = false;
+            for (int i = 0; i < m_activePassQueue.Count; ++i)
+            {
+                ScriptableRenderPass renderPass = m_activePassQueue[i];
+                if (renderPass == null ||
+                    !renderPass.SupportsStage(renderingData.stage))
+                {
+                    continue;
+                }
+
+                if (!renderPass.Record(
+                        context,
+                        renderingData))
+                {
+                    return false;
+                }
+
+                recordedAnyPass = true;
+            }
+
+            return recordedAnyPass;
+        }
+
+        private void BuildPassQueue(
+            RenderingData renderingData)
+        {
+            m_activePassQueue.Clear();
+
+            for (int i = 0; i < m_features.Count; ++i)
+            {
+                ScriptableRendererFeature feature = m_features[i];
+                if (feature == null || !feature.isActive)
+                {
+                    continue;
+                }
+
+                feature.AddRenderPasses(
+                    this,
+                    renderingData);
+            }
+
+            AddRenderPasses(renderingData);
+        }
+    }
+}

managed/XCEngine.ScriptCore/ScriptableRendererData.cs

@@ -0,0 +1,99 @@
+using System;
+
+namespace XCEngine
+{
+    public abstract class ScriptableRendererData : Object
+    {
+        private ScriptableRendererFeature[] m_rendererFeatures;
+
+        protected ScriptableRendererData()
+        {
+        }
+
+        internal ScriptableRenderer CreateRendererInstance()
+        {
+            return CreateRenderer();
+        }
+
+        internal ScriptableRendererFeature[] CreateRendererFeaturesInstance()
+        {
+            return GetRendererFeatures();
+        }
+
+        internal void ConfigureCameraRenderRequestInstance(
+            ScriptableRenderPipelineCameraRequestContext context)
+        {
+            ConfigureCameraRenderRequest(context);
+
+            ScriptableRendererFeature[] rendererFeatures =
+                GetRendererFeatures();
+            for (int i = 0; i < rendererFeatures.Length; ++i)
+            {
+                ScriptableRendererFeature rendererFeature =
+                    rendererFeatures[i];
+                if (rendererFeature == null ||
+                    !rendererFeature.isActive)
+                {
+                    continue;
+                }
+
+                rendererFeature.ConfigureCameraRenderRequest(
+                    context);
+            }
+        }
+
+        internal void ConfigureCameraFramePlanInstance(
+            ScriptableRenderPipelinePlanningContext context)
+        {
+            ConfigureCameraFramePlan(context);
+
+            ScriptableRendererFeature[] rendererFeatures =
+                GetRendererFeatures();
+            for (int i = 0; i < rendererFeatures.Length; ++i)
+            {
+                ScriptableRendererFeature rendererFeature =
+                    rendererFeatures[i];
+                if (rendererFeature == null ||
+                    !rendererFeature.isActive)
+                {
+                    continue;
+                }
+
+                rendererFeature.ConfigureCameraFramePlan(
+                    context);
+            }
+        }
+
+        protected virtual ScriptableRenderer CreateRenderer()
+        {
+            return null;
+        }
+
+        protected virtual void ConfigureCameraRenderRequest(
+            ScriptableRenderPipelineCameraRequestContext context)
+        {
+        }
+
+        protected virtual void ConfigureCameraFramePlan(
+            ScriptableRenderPipelinePlanningContext context)
+        {
+        }
+
+        protected virtual ScriptableRendererFeature[] CreateRendererFeatures()
+        {
+            return Array.Empty<ScriptableRendererFeature>();
+        }
+
+        private ScriptableRendererFeature[] GetRendererFeatures()
+        {
+            if (m_rendererFeatures == null)
+            {
+                m_rendererFeatures =
+                    CreateRendererFeatures() ??
+                    Array.Empty<ScriptableRendererFeature>();
+            }
+
+            return m_rendererFeatures;
+        }
+    }
+}

managed/XCEngine.ScriptCore/ScriptableRendererFeature.cs

@@ -0,0 +1,31 @@
+namespace XCEngine
+{
+    public abstract class ScriptableRendererFeature
+    {
+        protected ScriptableRendererFeature()
+        {
+        }
+
+        public bool isActive { get; set; } = true;
+
+        public virtual void Create()
+        {
+        }
+
+        public virtual void ConfigureCameraRenderRequest(
+            ScriptableRenderPipelineCameraRequestContext context)
+        {
+        }
+
+        public virtual void ConfigureCameraFramePlan(
+            ScriptableRenderPipelinePlanningContext context)
+        {
+        }
+
+        public virtual void AddRenderPasses(
+            ScriptableRenderer renderer,
+            RenderingData renderingData)
+        {
+        }
+    }
+}

managed/XCEngine.ScriptCore/ShadowData.cs

@@ -0,0 +1,22 @@
+namespace XCEngine
+{
+    public sealed class ShadowData
+    {
+        internal static readonly ShadowData Default =
+            new ShadowData(
+                DirectionalShadowData.Default);
+
+        internal ShadowData(
+            DirectionalShadowData mainDirectionalShadow)
+        {
+            this.mainDirectionalShadow =
+                mainDirectionalShadow ??
+                DirectionalShadowData.Default;
+        }
+
+        public DirectionalShadowData mainDirectionalShadow { get; }
+
+        public bool hasMainDirectionalShadow =>
+            mainDirectionalShadow.enabled;
+    }
+}

managed/XCEngine.ScriptCore/StageColorData.cs

@@ -0,0 +1,26 @@
+namespace XCEngine
+{
+    public sealed class StageColorData
+    {
+        internal static readonly StageColorData Default =
+            new StageColorData(
+                CameraFrameColorSource.ExplicitSurface,
+                false);
+
+        internal StageColorData(
+            CameraFrameColorSource source,
+            bool usesGraphManagedOutputColor)
+        {
+            this.source = source;
+            this.usesGraphManagedOutputColor =
+                usesGraphManagedOutputColor;
+        }
+
+        public CameraFrameColorSource source { get; }
+
+        public bool usesGraphManagedSourceColor =>
+            source != CameraFrameColorSource.ExplicitSurface;
+
+        public bool usesGraphManagedOutputColor { get; }
+    }
+}