ssdfasd
58dde75d3d
Invoke managed pipeline disposal and asset runtime cleanup from the native bridge lifecycle. Add Universal renderer and feature cleanup hooks plus regression probes to verify runtime cache teardown semantics.
2115 lines
77 KiB
C#
2115 lines
77 KiB
C#
using System;
|
|
using XCEngine;
|
|
using XCEngine.Rendering;
|
|
using XCEngine.Rendering.Universal;
|
|
|
|
namespace Gameplay
|
|
{
|
|
internal static class BuiltinShaderPaths
|
|
{
|
|
public const string ColorScalePostProcess =
|
|
"builtin://shaders/color-scale-post-process";
|
|
}
|
|
|
|
internal static class ProbeFinalColorSettingsFactory
|
|
{
|
|
public static FinalColorSettings Create()
|
|
{
|
|
FinalColorSettings settings =
|
|
FinalColorSettings.CreateDefault();
|
|
settings.outputTransferMode =
|
|
FinalColorOutputTransferMode.LinearToSRGB;
|
|
settings.exposureMode =
|
|
FinalColorExposureMode.Fixed;
|
|
settings.exposureValue = 1.75f;
|
|
settings.toneMappingMode =
|
|
FinalColorToneMappingMode.ACES;
|
|
settings.finalColorScale =
|
|
new Vector4(0.90f, 1.10f, 1.20f, 1.0f);
|
|
return settings;
|
|
}
|
|
}
|
|
|
|
internal enum SceneInjectionKind
|
|
{
|
|
BeforeOpaque,
|
|
AfterOpaque,
|
|
BeforeSkybox,
|
|
AfterSkybox,
|
|
BeforeTransparent,
|
|
AfterTransparent
|
|
}
|
|
|
|
internal enum ScenePhaseKind
|
|
{
|
|
Opaque,
|
|
Skybox,
|
|
Transparent
|
|
}
|
|
|
|
internal enum FullscreenPassKind
|
|
{
|
|
ColorScale,
|
|
ShaderVector
|
|
}
|
|
|
|
internal sealed class SceneInjectionPass : ScriptableRenderPass
|
|
{
|
|
private readonly SceneInjectionKind m_injectionKind;
|
|
|
|
public SceneInjectionPass(
|
|
RenderPassEvent passEvent,
|
|
SceneInjectionKind injectionKind)
|
|
{
|
|
renderPassEvent = passEvent;
|
|
m_injectionKind = injectionKind;
|
|
}
|
|
|
|
protected override bool RecordRenderGraph(
|
|
ScriptableRenderContext context,
|
|
RenderingData renderingData)
|
|
{
|
|
return context != null &&
|
|
renderingData != null &&
|
|
renderingData.isMainSceneStage &&
|
|
RecordInjection(context);
|
|
}
|
|
|
|
private bool RecordInjection(
|
|
ScriptableRenderContext context)
|
|
{
|
|
switch (m_injectionKind)
|
|
{
|
|
case SceneInjectionKind.BeforeOpaque:
|
|
return RecordBeforeOpaqueInjection(context);
|
|
case SceneInjectionKind.AfterOpaque:
|
|
return RecordAfterOpaqueInjection(context);
|
|
case SceneInjectionKind.BeforeSkybox:
|
|
return RecordBeforeSkyboxInjection(context);
|
|
case SceneInjectionKind.AfterSkybox:
|
|
return RecordAfterSkyboxInjection(context);
|
|
case SceneInjectionKind.BeforeTransparent:
|
|
return RecordBeforeTransparentInjection(context);
|
|
case SceneInjectionKind.AfterTransparent:
|
|
return RecordAfterTransparentInjection(context);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal sealed class ScenePhasePass : ScriptableRenderPass
|
|
{
|
|
private readonly ScenePhaseKind m_phaseKind;
|
|
private readonly Action m_onRecorded;
|
|
|
|
public ScenePhasePass(
|
|
RenderPassEvent passEvent,
|
|
ScenePhaseKind phaseKind,
|
|
Action onRecorded = null)
|
|
{
|
|
renderPassEvent = passEvent;
|
|
m_phaseKind = phaseKind;
|
|
m_onRecorded = onRecorded;
|
|
}
|
|
|
|
protected override bool RecordRenderGraph(
|
|
ScriptableRenderContext context,
|
|
RenderingData renderingData)
|
|
{
|
|
bool recorded = context != null &&
|
|
renderingData != null &&
|
|
renderingData.isMainSceneStage &&
|
|
RecordPhase(context);
|
|
if (recorded && m_onRecorded != null)
|
|
{
|
|
m_onRecorded();
|
|
}
|
|
|
|
return recorded;
|
|
}
|
|
|
|
private bool RecordPhase(
|
|
ScriptableRenderContext context)
|
|
{
|
|
switch (m_phaseKind)
|
|
{
|
|
case ScenePhaseKind.Opaque:
|
|
return RecordOpaqueScenePhase(context);
|
|
case ScenePhaseKind.Skybox:
|
|
return RecordSkyboxScenePhase(context);
|
|
case ScenePhaseKind.Transparent:
|
|
return RecordTransparentScenePhase(context);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal sealed class FullscreenPass : ScriptableRenderPass
|
|
{
|
|
private readonly FullscreenPassKind m_passKind;
|
|
private readonly Vector4 m_vectorPayload;
|
|
private readonly string m_shaderPath;
|
|
private readonly string m_passName;
|
|
|
|
public FullscreenPass(
|
|
RenderPassEvent passEvent,
|
|
Vector4 colorScale)
|
|
{
|
|
renderPassEvent = passEvent;
|
|
m_passKind = FullscreenPassKind.ColorScale;
|
|
m_vectorPayload = colorScale;
|
|
m_shaderPath = string.Empty;
|
|
m_passName = string.Empty;
|
|
}
|
|
|
|
public FullscreenPass(
|
|
RenderPassEvent passEvent,
|
|
string shaderPath,
|
|
Vector4 vectorPayload,
|
|
string passName = null)
|
|
{
|
|
renderPassEvent = passEvent;
|
|
m_passKind = FullscreenPassKind.ShaderVector;
|
|
m_vectorPayload = vectorPayload;
|
|
m_shaderPath = shaderPath ?? string.Empty;
|
|
m_passName = passName ?? string.Empty;
|
|
}
|
|
|
|
protected override bool RecordRenderGraph(
|
|
ScriptableRenderContext context,
|
|
RenderingData renderingData)
|
|
{
|
|
return context != null &&
|
|
renderingData != null &&
|
|
RecordFullscreen(context);
|
|
}
|
|
|
|
private bool RecordFullscreen(
|
|
ScriptableRenderContext context)
|
|
{
|
|
switch (m_passKind)
|
|
{
|
|
case FullscreenPassKind.ColorScale:
|
|
return RecordColorScaleFullscreenPass(
|
|
context,
|
|
m_vectorPayload);
|
|
case FullscreenPassKind.ShaderVector:
|
|
return RecordShaderVectorFullscreenPass(
|
|
context,
|
|
m_shaderPath,
|
|
m_vectorPayload,
|
|
m_passName);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal sealed class DefaultSceneFeature : ScriptableRendererFeature
|
|
{
|
|
private readonly SceneInjectionPass m_beforeOpaquePass;
|
|
private readonly ScenePhasePass m_opaquePass;
|
|
private readonly SceneInjectionPass m_afterOpaquePass;
|
|
private readonly SceneInjectionPass m_beforeSkyboxPass;
|
|
private readonly ScenePhasePass m_skyboxPass;
|
|
private readonly SceneInjectionPass m_afterSkyboxPass;
|
|
private readonly SceneInjectionPass m_beforeTransparentPass;
|
|
private readonly ScenePhasePass m_transparentPass;
|
|
private readonly SceneInjectionPass m_afterTransparentPass;
|
|
|
|
public DefaultSceneFeature(
|
|
Action onOpaqueRecorded = null)
|
|
{
|
|
m_beforeOpaquePass =
|
|
new SceneInjectionPass(
|
|
RenderPassEvent.BeforeRenderingOpaques,
|
|
SceneInjectionKind.BeforeOpaque);
|
|
m_opaquePass =
|
|
new ScenePhasePass(
|
|
RenderPassEvent.RenderOpaques,
|
|
ScenePhaseKind.Opaque,
|
|
onOpaqueRecorded);
|
|
m_afterOpaquePass =
|
|
new SceneInjectionPass(
|
|
RenderPassEvent.AfterRenderingOpaques,
|
|
SceneInjectionKind.AfterOpaque);
|
|
m_beforeSkyboxPass =
|
|
new SceneInjectionPass(
|
|
RenderPassEvent.BeforeRenderingSkybox,
|
|
SceneInjectionKind.BeforeSkybox);
|
|
m_skyboxPass =
|
|
new ScenePhasePass(
|
|
RenderPassEvent.RenderSkybox,
|
|
ScenePhaseKind.Skybox);
|
|
m_afterSkyboxPass =
|
|
new SceneInjectionPass(
|
|
RenderPassEvent.AfterRenderingSkybox,
|
|
SceneInjectionKind.AfterSkybox);
|
|
m_beforeTransparentPass =
|
|
new SceneInjectionPass(
|
|
RenderPassEvent.BeforeRenderingTransparents,
|
|
SceneInjectionKind.BeforeTransparent);
|
|
m_transparentPass =
|
|
new ScenePhasePass(
|
|
RenderPassEvent.RenderTransparents,
|
|
ScenePhaseKind.Transparent);
|
|
m_afterTransparentPass =
|
|
new SceneInjectionPass(
|
|
RenderPassEvent.AfterRenderingTransparents,
|
|
SceneInjectionKind.AfterTransparent);
|
|
}
|
|
|
|
public override void AddRenderPasses(
|
|
ScriptableRenderer renderer,
|
|
RenderingData renderingData)
|
|
{
|
|
if (renderer == null ||
|
|
renderingData == null ||
|
|
!renderingData.isMainSceneStage)
|
|
{
|
|
return;
|
|
}
|
|
|
|
renderer.EnqueuePass(m_beforeOpaquePass);
|
|
renderer.EnqueuePass(m_opaquePass);
|
|
renderer.EnqueuePass(m_afterOpaquePass);
|
|
renderer.EnqueuePass(m_beforeSkyboxPass);
|
|
renderer.EnqueuePass(m_skyboxPass);
|
|
renderer.EnqueuePass(m_afterSkyboxPass);
|
|
renderer.EnqueuePass(m_beforeTransparentPass);
|
|
renderer.EnqueuePass(m_transparentPass);
|
|
renderer.EnqueuePass(m_afterTransparentPass);
|
|
}
|
|
}
|
|
|
|
internal sealed class FullscreenFeature : ScriptableRendererFeature
|
|
{
|
|
private readonly ScriptableRenderPass[] m_passes;
|
|
|
|
public FullscreenFeature(
|
|
params ScriptableRenderPass[] passes)
|
|
{
|
|
m_passes = passes ?? Array.Empty<ScriptableRenderPass>();
|
|
}
|
|
|
|
public override void AddRenderPasses(
|
|
ScriptableRenderer renderer,
|
|
RenderingData renderingData)
|
|
{
|
|
if (renderer == null ||
|
|
renderingData == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < m_passes.Length; ++i)
|
|
{
|
|
ScriptableRenderPass renderPass = m_passes[i];
|
|
if (renderPass == null ||
|
|
!renderPass.SupportsStage(renderingData.stage))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
renderer.EnqueuePass(renderPass);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class ProbeSceneRenderer : ScriptableRenderer
|
|
{
|
|
public ProbeSceneRenderer(
|
|
Action onOpaqueRecorded = null)
|
|
{
|
|
AddFeature(new DefaultSceneFeature(onOpaqueRecorded));
|
|
}
|
|
}
|
|
|
|
internal class ProbePostProcessRenderer : ScriptableRenderer
|
|
{
|
|
public ProbePostProcessRenderer(
|
|
Vector4 firstVectorPayload,
|
|
Vector4 secondVectorPayload)
|
|
{
|
|
AddFeature(
|
|
new FullscreenFeature(
|
|
new FullscreenPass(
|
|
RenderPassEvent.BeforeRenderingPostProcessing,
|
|
BuiltinShaderPaths.ColorScalePostProcess,
|
|
firstVectorPayload,
|
|
"ColorScale"),
|
|
new FullscreenPass(
|
|
RenderPassEvent.AfterRenderingPostProcessing,
|
|
BuiltinShaderPaths.ColorScalePostProcess,
|
|
secondVectorPayload,
|
|
"ColorScale")));
|
|
}
|
|
}
|
|
|
|
internal class ProbeUniversalRenderer : ScriptableRenderer
|
|
{
|
|
public ProbeUniversalRenderer(
|
|
Vector4 postProcessScale,
|
|
Action onOpaqueRecorded)
|
|
{
|
|
AddFeature(new DefaultSceneFeature(onOpaqueRecorded));
|
|
AddFeature(
|
|
new FullscreenFeature(
|
|
new FullscreenPass(
|
|
RenderPassEvent.BeforeRenderingPostProcessing,
|
|
postProcessScale)));
|
|
}
|
|
}
|
|
|
|
internal class ProbePlannedFullscreenRenderer : ScriptableRenderer
|
|
{
|
|
public ProbePlannedFullscreenRenderer()
|
|
{
|
|
AddFeature(
|
|
new FullscreenFeature(
|
|
new FullscreenPass(
|
|
RenderPassEvent.BeforeRenderingPostProcessing,
|
|
new Vector4(1.05f, 1.0f, 0.95f, 1.0f)),
|
|
new FullscreenPass(
|
|
RenderPassEvent.BeforeRenderingFinalOutput,
|
|
new Vector4(1.05f, 1.0f, 0.95f, 1.0f))));
|
|
}
|
|
}
|
|
|
|
internal sealed class CameraDataObservationPass
|
|
: ScriptableRenderPass
|
|
{
|
|
public static Vector4 ObservedViewRow0;
|
|
public static Vector4 ObservedViewRow1;
|
|
public static Vector4 ObservedViewRow2;
|
|
public static Vector4 ObservedViewRow3;
|
|
public static Vector4 ObservedProjectionRow0;
|
|
public static Vector4 ObservedProjectionRow1;
|
|
public static Vector4 ObservedProjectionRow2;
|
|
public static Vector4 ObservedProjectionRow3;
|
|
public static Vector4 ObservedViewProjectionRow0;
|
|
public static Vector4 ObservedViewProjectionRow1;
|
|
public static Vector4 ObservedViewProjectionRow2;
|
|
public static Vector4 ObservedViewProjectionRow3;
|
|
public static Vector3 ObservedWorldPosition;
|
|
public static Vector4 ObservedClearColor;
|
|
public static int ObservedClearFlags;
|
|
public static bool ObservedPerspectiveProjection;
|
|
public static float ObservedVerticalFovRadians;
|
|
public static float ObservedOrthographicSize;
|
|
public static float ObservedAspectRatio;
|
|
public static float ObservedNearClipPlane;
|
|
public static float ObservedFarClipPlane;
|
|
public static int ObservedViewportWidth;
|
|
public static int ObservedViewportHeight;
|
|
public static bool ObservedMainDirectionalLightEnabled;
|
|
public static bool ObservedMainDirectionalLightCastsShadows;
|
|
public static Vector3 ObservedMainDirectionalLightDirection;
|
|
public static Vector4 ObservedMainDirectionalLightColor;
|
|
public static float ObservedMainDirectionalLightIntensity;
|
|
public static bool ObservedHasMainDirectionalShadow;
|
|
public static int ObservedAdditionalLightCount;
|
|
public static bool ObservedShadowEnabled;
|
|
public static Vector4 ObservedShadowViewProjectionRow0;
|
|
public static Vector4 ObservedShadowViewProjectionRow1;
|
|
public static Vector4 ObservedShadowViewProjectionRow2;
|
|
public static Vector4 ObservedShadowViewProjectionRow3;
|
|
public static float ObservedShadowOrthographicHalfExtent;
|
|
public static float ObservedShadowNearClipPlane;
|
|
public static float ObservedShadowFarClipPlane;
|
|
public static int ObservedShadowMapWidth;
|
|
public static int ObservedShadowMapHeight;
|
|
public static float ObservedShadowWorldTexelSize;
|
|
public static float ObservedShadowReceiverDepthBias;
|
|
public static float ObservedShadowNormalBiasScale;
|
|
public static float ObservedShadowStrength;
|
|
public static float ObservedShadowDepthBiasFactor;
|
|
public static int ObservedShadowDepthBiasUnits;
|
|
public static int ObservedEnvironmentMode;
|
|
public static Vector4 ObservedSkyboxTopColor;
|
|
public static Vector4 ObservedSkyboxHorizonColor;
|
|
public static Vector4 ObservedSkyboxBottomColor;
|
|
public static int ObservedFinalColorOutputTransferMode;
|
|
public static int ObservedFinalColorExposureMode;
|
|
public static float ObservedFinalColorExposureValue;
|
|
public static int ObservedFinalColorToneMappingMode;
|
|
public static Vector4 ObservedFinalColorScale;
|
|
public static bool ObservedFinalColorHasPipelineDefaults;
|
|
public static bool ObservedFinalColorHasCameraOverrides;
|
|
public static bool ObservedFinalColorRequiresProcessing;
|
|
public static int RecordCallCount;
|
|
|
|
public CameraDataObservationPass()
|
|
{
|
|
renderPassEvent = RenderPassEvent.RenderOpaques;
|
|
}
|
|
|
|
public static void Reset()
|
|
{
|
|
ObservedViewRow0 = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
ObservedViewRow1 = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
ObservedViewRow2 = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
ObservedViewRow3 = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
ObservedProjectionRow0 = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
ObservedProjectionRow1 = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
ObservedProjectionRow2 = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
ObservedProjectionRow3 = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
ObservedViewProjectionRow0 = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
ObservedViewProjectionRow1 = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
ObservedViewProjectionRow2 = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
ObservedViewProjectionRow3 = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
ObservedWorldPosition = new Vector3(0.0f, 0.0f, 0.0f);
|
|
ObservedClearColor = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
ObservedClearFlags = 0;
|
|
ObservedPerspectiveProjection = true;
|
|
ObservedVerticalFovRadians = 0.0f;
|
|
ObservedOrthographicSize = 0.0f;
|
|
ObservedAspectRatio = 0.0f;
|
|
ObservedNearClipPlane = 0.0f;
|
|
ObservedFarClipPlane = 0.0f;
|
|
ObservedViewportWidth = 0;
|
|
ObservedViewportHeight = 0;
|
|
ObservedMainDirectionalLightEnabled = false;
|
|
ObservedMainDirectionalLightCastsShadows = false;
|
|
ObservedMainDirectionalLightDirection =
|
|
new Vector3(0.0f, 0.0f, 0.0f);
|
|
ObservedMainDirectionalLightColor =
|
|
new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
ObservedMainDirectionalLightIntensity = 0.0f;
|
|
ObservedHasMainDirectionalShadow = false;
|
|
ObservedAdditionalLightCount = 0;
|
|
ObservedShadowEnabled = false;
|
|
ObservedShadowViewProjectionRow0 =
|
|
new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
ObservedShadowViewProjectionRow1 =
|
|
new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
ObservedShadowViewProjectionRow2 =
|
|
new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
ObservedShadowViewProjectionRow3 =
|
|
new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
ObservedShadowOrthographicHalfExtent = 0.0f;
|
|
ObservedShadowNearClipPlane = 0.0f;
|
|
ObservedShadowFarClipPlane = 0.0f;
|
|
ObservedShadowMapWidth = 0;
|
|
ObservedShadowMapHeight = 0;
|
|
ObservedShadowWorldTexelSize = 0.0f;
|
|
ObservedShadowReceiverDepthBias = 0.0f;
|
|
ObservedShadowNormalBiasScale = 0.0f;
|
|
ObservedShadowStrength = 0.0f;
|
|
ObservedShadowDepthBiasFactor = 0.0f;
|
|
ObservedShadowDepthBiasUnits = 0;
|
|
ObservedEnvironmentMode = 0;
|
|
ObservedSkyboxTopColor =
|
|
new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
ObservedSkyboxHorizonColor =
|
|
new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
ObservedSkyboxBottomColor =
|
|
new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
ObservedFinalColorOutputTransferMode = 0;
|
|
ObservedFinalColorExposureMode = 0;
|
|
ObservedFinalColorExposureValue = 0.0f;
|
|
ObservedFinalColorToneMappingMode = 0;
|
|
ObservedFinalColorScale =
|
|
new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
ObservedFinalColorHasPipelineDefaults = false;
|
|
ObservedFinalColorHasCameraOverrides = false;
|
|
ObservedFinalColorRequiresProcessing = false;
|
|
RecordCallCount = 0;
|
|
}
|
|
|
|
protected override bool RecordRenderGraph(
|
|
ScriptableRenderContext context,
|
|
RenderingData renderingData)
|
|
{
|
|
if (context == null ||
|
|
renderingData == null ||
|
|
!renderingData.isMainSceneStage)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
CameraData cameraData = renderingData.cameraData;
|
|
LightingData lightingData = renderingData.lightingData;
|
|
ShadowData shadowData = renderingData.shadowData;
|
|
EnvironmentData environmentData =
|
|
renderingData.environmentData;
|
|
FinalColorData finalColorData =
|
|
renderingData.finalColorData;
|
|
if (cameraData == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
ObservedViewRow0 = cameraData.view.GetRow(0);
|
|
ObservedViewRow1 = cameraData.view.GetRow(1);
|
|
ObservedViewRow2 = cameraData.view.GetRow(2);
|
|
ObservedViewRow3 = cameraData.view.GetRow(3);
|
|
ObservedProjectionRow0 =
|
|
cameraData.projection.GetRow(0);
|
|
ObservedProjectionRow1 =
|
|
cameraData.projection.GetRow(1);
|
|
ObservedProjectionRow2 =
|
|
cameraData.projection.GetRow(2);
|
|
ObservedProjectionRow3 =
|
|
cameraData.projection.GetRow(3);
|
|
ObservedViewProjectionRow0 =
|
|
cameraData.viewProjection.GetRow(0);
|
|
ObservedViewProjectionRow1 =
|
|
cameraData.viewProjection.GetRow(1);
|
|
ObservedViewProjectionRow2 =
|
|
cameraData.viewProjection.GetRow(2);
|
|
ObservedViewProjectionRow3 =
|
|
cameraData.viewProjection.GetRow(3);
|
|
ObservedWorldPosition = cameraData.worldPosition;
|
|
ObservedClearColor = new Vector4(
|
|
cameraData.clearColor.r,
|
|
cameraData.clearColor.g,
|
|
cameraData.clearColor.b,
|
|
cameraData.clearColor.a);
|
|
ObservedClearFlags = (int)cameraData.clearFlags;
|
|
ObservedPerspectiveProjection =
|
|
cameraData.perspectiveProjection;
|
|
ObservedVerticalFovRadians =
|
|
cameraData.verticalFovRadians;
|
|
ObservedOrthographicSize =
|
|
cameraData.orthographicSize;
|
|
ObservedAspectRatio =
|
|
cameraData.aspectRatio;
|
|
ObservedNearClipPlane =
|
|
cameraData.nearClipPlane;
|
|
ObservedFarClipPlane =
|
|
cameraData.farClipPlane;
|
|
ObservedViewportWidth =
|
|
cameraData.viewportWidth;
|
|
ObservedViewportHeight =
|
|
cameraData.viewportHeight;
|
|
if (lightingData != null &&
|
|
lightingData.mainDirectionalLight != null)
|
|
{
|
|
ObservedMainDirectionalLightEnabled =
|
|
lightingData.mainDirectionalLight.enabled;
|
|
ObservedMainDirectionalLightCastsShadows =
|
|
lightingData.mainDirectionalLight.castsShadows;
|
|
ObservedMainDirectionalLightDirection =
|
|
lightingData.mainDirectionalLight.direction;
|
|
ObservedMainDirectionalLightColor = new Vector4(
|
|
lightingData.mainDirectionalLight.color.r,
|
|
lightingData.mainDirectionalLight.color.g,
|
|
lightingData.mainDirectionalLight.color.b,
|
|
lightingData.mainDirectionalLight.color.a);
|
|
ObservedMainDirectionalLightIntensity =
|
|
lightingData.mainDirectionalLight.intensity;
|
|
ObservedHasMainDirectionalShadow =
|
|
lightingData.hasMainDirectionalShadow;
|
|
ObservedAdditionalLightCount =
|
|
lightingData.additionalLightCount;
|
|
}
|
|
if (shadowData != null &&
|
|
shadowData.mainDirectionalShadow != null)
|
|
{
|
|
DirectionalShadowData mainDirectionalShadow =
|
|
shadowData.mainDirectionalShadow;
|
|
ObservedShadowEnabled =
|
|
mainDirectionalShadow.enabled;
|
|
ObservedShadowViewProjectionRow0 =
|
|
mainDirectionalShadow.viewProjection.GetRow(0);
|
|
ObservedShadowViewProjectionRow1 =
|
|
mainDirectionalShadow.viewProjection.GetRow(1);
|
|
ObservedShadowViewProjectionRow2 =
|
|
mainDirectionalShadow.viewProjection.GetRow(2);
|
|
ObservedShadowViewProjectionRow3 =
|
|
mainDirectionalShadow.viewProjection.GetRow(3);
|
|
ObservedShadowOrthographicHalfExtent =
|
|
mainDirectionalShadow.orthographicHalfExtent;
|
|
ObservedShadowNearClipPlane =
|
|
mainDirectionalShadow.nearClipPlane;
|
|
ObservedShadowFarClipPlane =
|
|
mainDirectionalShadow.farClipPlane;
|
|
ObservedShadowMapWidth =
|
|
mainDirectionalShadow.mapWidth;
|
|
ObservedShadowMapHeight =
|
|
mainDirectionalShadow.mapHeight;
|
|
ObservedShadowWorldTexelSize =
|
|
mainDirectionalShadow.worldTexelSize;
|
|
ObservedShadowReceiverDepthBias =
|
|
mainDirectionalShadow.receiverDepthBias;
|
|
ObservedShadowNormalBiasScale =
|
|
mainDirectionalShadow.normalBiasScale;
|
|
ObservedShadowStrength =
|
|
mainDirectionalShadow.shadowStrength;
|
|
ObservedShadowDepthBiasFactor =
|
|
mainDirectionalShadow.depthBiasFactor;
|
|
ObservedShadowDepthBiasUnits =
|
|
mainDirectionalShadow.depthBiasUnits;
|
|
}
|
|
if (environmentData != null)
|
|
{
|
|
ObservedEnvironmentMode =
|
|
(int)environmentData.mode;
|
|
ObservedSkyboxTopColor = new Vector4(
|
|
environmentData.skyboxTopColor.r,
|
|
environmentData.skyboxTopColor.g,
|
|
environmentData.skyboxTopColor.b,
|
|
environmentData.skyboxTopColor.a);
|
|
ObservedSkyboxHorizonColor = new Vector4(
|
|
environmentData.skyboxHorizonColor.r,
|
|
environmentData.skyboxHorizonColor.g,
|
|
environmentData.skyboxHorizonColor.b,
|
|
environmentData.skyboxHorizonColor.a);
|
|
ObservedSkyboxBottomColor = new Vector4(
|
|
environmentData.skyboxBottomColor.r,
|
|
environmentData.skyboxBottomColor.g,
|
|
environmentData.skyboxBottomColor.b,
|
|
environmentData.skyboxBottomColor.a);
|
|
}
|
|
if (finalColorData != null)
|
|
{
|
|
ObservedFinalColorOutputTransferMode =
|
|
(int)finalColorData.settings.outputTransferMode;
|
|
ObservedFinalColorExposureMode =
|
|
(int)finalColorData.settings.exposureMode;
|
|
ObservedFinalColorExposureValue =
|
|
finalColorData.settings.exposureValue;
|
|
ObservedFinalColorToneMappingMode =
|
|
(int)finalColorData.settings.toneMappingMode;
|
|
ObservedFinalColorScale =
|
|
finalColorData.settings.finalColorScale;
|
|
ObservedFinalColorHasPipelineDefaults =
|
|
finalColorData.hasPipelineDefaults;
|
|
ObservedFinalColorHasCameraOverrides =
|
|
finalColorData.hasCameraOverrides;
|
|
ObservedFinalColorRequiresProcessing =
|
|
finalColorData.requiresProcessing;
|
|
}
|
|
RecordCallCount++;
|
|
return RecordScene(context);
|
|
}
|
|
}
|
|
|
|
internal sealed class CameraDataObservationFeature
|
|
: ScriptableRendererFeature
|
|
{
|
|
private readonly CameraDataObservationPass m_pass =
|
|
new CameraDataObservationPass();
|
|
|
|
public override void AddRenderPasses(
|
|
ScriptableRenderer renderer,
|
|
RenderingData renderingData)
|
|
{
|
|
if (renderer == null ||
|
|
renderingData == null ||
|
|
!renderingData.isMainSceneStage)
|
|
{
|
|
return;
|
|
}
|
|
|
|
renderer.EnqueuePass(m_pass);
|
|
}
|
|
}
|
|
|
|
internal class CameraDataObservationRenderer
|
|
: ScriptableRenderer
|
|
{
|
|
public CameraDataObservationRenderer()
|
|
{
|
|
AddFeature(new CameraDataObservationFeature());
|
|
}
|
|
}
|
|
|
|
internal sealed class StageColorObservationPass
|
|
: ScriptableRenderPass
|
|
{
|
|
public static int ObservedMainSceneSource;
|
|
public static bool ObservedMainSceneUsesGraphManagedOutputColor;
|
|
public static int ObservedPostProcessSource;
|
|
public static bool ObservedPostProcessUsesGraphManagedOutputColor;
|
|
public static int ObservedFinalOutputSource;
|
|
public static bool ObservedFinalOutputUsesGraphManagedOutputColor;
|
|
public static int MainSceneRecordCallCount;
|
|
public static int PostProcessRecordCallCount;
|
|
public static int FinalOutputRecordCallCount;
|
|
|
|
public StageColorObservationPass(
|
|
RenderPassEvent passEvent)
|
|
{
|
|
renderPassEvent = passEvent;
|
|
}
|
|
|
|
public static void Reset()
|
|
{
|
|
ObservedMainSceneSource = 0;
|
|
ObservedMainSceneUsesGraphManagedOutputColor = false;
|
|
ObservedPostProcessSource = 0;
|
|
ObservedPostProcessUsesGraphManagedOutputColor = false;
|
|
ObservedFinalOutputSource = 0;
|
|
ObservedFinalOutputUsesGraphManagedOutputColor = false;
|
|
MainSceneRecordCallCount = 0;
|
|
PostProcessRecordCallCount = 0;
|
|
FinalOutputRecordCallCount = 0;
|
|
}
|
|
|
|
protected override bool RecordRenderGraph(
|
|
ScriptableRenderContext context,
|
|
RenderingData renderingData)
|
|
{
|
|
if (context == null ||
|
|
renderingData == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
StageColorData stageColorData =
|
|
renderingData.stageColorData;
|
|
if (stageColorData == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (renderingData.isMainSceneStage)
|
|
{
|
|
ObservedMainSceneSource =
|
|
(int)stageColorData.source;
|
|
ObservedMainSceneUsesGraphManagedOutputColor =
|
|
stageColorData.usesGraphManagedOutputColor;
|
|
MainSceneRecordCallCount++;
|
|
return true;
|
|
}
|
|
|
|
if (renderingData.isPostProcessStage)
|
|
{
|
|
ObservedPostProcessSource =
|
|
(int)stageColorData.source;
|
|
ObservedPostProcessUsesGraphManagedOutputColor =
|
|
stageColorData.usesGraphManagedOutputColor;
|
|
PostProcessRecordCallCount++;
|
|
return true;
|
|
}
|
|
|
|
if (renderingData.isFinalOutputStage)
|
|
{
|
|
ObservedFinalOutputSource =
|
|
(int)stageColorData.source;
|
|
ObservedFinalOutputUsesGraphManagedOutputColor =
|
|
stageColorData.usesGraphManagedOutputColor;
|
|
FinalOutputRecordCallCount++;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
internal class StageColorObservationRenderer
|
|
: ScriptableRenderer
|
|
{
|
|
public StageColorObservationRenderer()
|
|
{
|
|
AddFeature(
|
|
new FullscreenFeature(
|
|
new StageColorObservationPass(
|
|
RenderPassEvent.RenderOpaques),
|
|
new StageColorObservationPass(
|
|
RenderPassEvent.BeforeRenderingPostProcessing),
|
|
new StageColorObservationPass(
|
|
RenderPassEvent.BeforeRenderingFinalOutput)));
|
|
}
|
|
}
|
|
|
|
internal abstract class ProbeRendererData
|
|
: UniversalRendererData
|
|
{
|
|
protected sealed override ScriptableRenderer CreateRenderer()
|
|
{
|
|
return CreateProbeRenderer();
|
|
}
|
|
|
|
protected abstract ScriptableRenderer CreateProbeRenderer();
|
|
}
|
|
|
|
internal sealed class ManagedRenderPipelineProbeRendererData
|
|
: ProbeRendererData
|
|
{
|
|
protected override ScriptableRenderer CreateProbeRenderer()
|
|
{
|
|
return new ManagedRenderPipelineProbe();
|
|
}
|
|
}
|
|
|
|
internal sealed class ManagedPostProcessRenderPipelineProbeRendererData
|
|
: ProbeRendererData
|
|
{
|
|
protected override ScriptableRenderer CreateProbeRenderer()
|
|
{
|
|
return new ManagedPostProcessRenderPipelineProbe();
|
|
}
|
|
}
|
|
|
|
internal sealed class ManagedUniversalRenderPipelineProbeRendererData
|
|
: ProbeRendererData
|
|
{
|
|
private readonly Vector4 m_postProcessScale;
|
|
|
|
public ManagedUniversalRenderPipelineProbeRendererData(
|
|
Vector4 postProcessScale)
|
|
{
|
|
m_postProcessScale = postProcessScale;
|
|
}
|
|
|
|
protected override ScriptableRenderer CreateProbeRenderer()
|
|
{
|
|
return new ManagedUniversalRenderPipelineProbe(
|
|
m_postProcessScale);
|
|
}
|
|
}
|
|
|
|
internal sealed class ManagedUnknownBackendProbeRendererData
|
|
: ProbeRendererData
|
|
{
|
|
protected override ScriptableRenderer CreateProbeRenderer()
|
|
{
|
|
return new ManagedRenderPipelineProbe();
|
|
}
|
|
|
|
protected override string GetPipelineRendererAssetKey()
|
|
{
|
|
return "MissingBackend";
|
|
}
|
|
}
|
|
|
|
internal sealed class ManagedRendererReuseProbeRendererData
|
|
: ProbeRendererData
|
|
{
|
|
public static int CreateRendererCallCount;
|
|
|
|
protected override ScriptableRenderer CreateProbeRenderer()
|
|
{
|
|
CreateRendererCallCount++;
|
|
return new ManagedRenderPipelineProbe();
|
|
}
|
|
}
|
|
|
|
internal sealed class ManagedPlannedFullscreenRenderPipelineProbeRendererData
|
|
: ProbeRendererData
|
|
{
|
|
protected override ScriptableRenderer CreateProbeRenderer()
|
|
{
|
|
return new ManagedPlannedFullscreenRenderPipelineProbe();
|
|
}
|
|
}
|
|
|
|
internal sealed class ManagedRenderContextCameraDataProbeRendererData
|
|
: ProbeRendererData
|
|
{
|
|
protected override ScriptableRenderer CreateProbeRenderer()
|
|
{
|
|
return new ManagedRenderContextCameraDataProbe();
|
|
}
|
|
}
|
|
|
|
internal sealed class ManagedRenderContextStageColorDataProbeRendererData
|
|
: ProbeRendererData
|
|
{
|
|
protected override ScriptableRenderer CreateProbeRenderer()
|
|
{
|
|
return new ManagedRenderContextStageColorDataProbe();
|
|
}
|
|
}
|
|
|
|
internal static class ManagedLifecycleProbeState
|
|
{
|
|
public static int CreatePipelineCallCount;
|
|
public static int CreateRendererCallCount;
|
|
public static int CreateFeatureCallCount;
|
|
public static int ReleaseRendererDataRuntimeResourcesCallCount;
|
|
public static int DisposePipelineCallCount;
|
|
public static int ReleaseAssetRuntimeResourcesCallCount;
|
|
public static int DisposeRendererCallCount;
|
|
public static int DisposeFeatureCallCount;
|
|
|
|
public static void Reset()
|
|
{
|
|
CreatePipelineCallCount = 0;
|
|
CreateRendererCallCount = 0;
|
|
CreateFeatureCallCount = 0;
|
|
ReleaseRendererDataRuntimeResourcesCallCount = 0;
|
|
DisposePipelineCallCount = 0;
|
|
ReleaseAssetRuntimeResourcesCallCount = 0;
|
|
DisposeRendererCallCount = 0;
|
|
DisposeFeatureCallCount = 0;
|
|
}
|
|
}
|
|
|
|
internal sealed class ManagedLifecycleProbeRendererFeature
|
|
: ScriptableRendererFeature
|
|
{
|
|
protected override void ReleaseRuntimeResources()
|
|
{
|
|
ManagedLifecycleProbeState.DisposeFeatureCallCount++;
|
|
}
|
|
}
|
|
|
|
internal sealed class ManagedLifecycleProbeRenderer
|
|
: ScriptableRenderer
|
|
{
|
|
public ManagedLifecycleProbeRenderer(
|
|
ScriptableRendererFeature[] rendererFeatures)
|
|
{
|
|
ScriptableRendererFeature[] resolvedRendererFeatures =
|
|
rendererFeatures ?? Array.Empty<ScriptableRendererFeature>();
|
|
for (int i = 0; i < resolvedRendererFeatures.Length; ++i)
|
|
{
|
|
AddFeature(resolvedRendererFeatures[i]);
|
|
}
|
|
}
|
|
|
|
protected override bool SupportsStageRenderGraph(
|
|
CameraFrameStage stage)
|
|
{
|
|
return stage == CameraFrameStage.MainScene;
|
|
}
|
|
|
|
protected override bool RecordStageRenderGraph(
|
|
ScriptableRenderContext context)
|
|
{
|
|
return context != null;
|
|
}
|
|
|
|
protected override void ReleaseRuntimeResources()
|
|
{
|
|
ManagedLifecycleProbeState.DisposeRendererCallCount++;
|
|
}
|
|
}
|
|
|
|
internal sealed class ManagedLifecycleProbeRendererData
|
|
: ScriptableRendererData
|
|
{
|
|
protected override ScriptableRenderer CreateRenderer()
|
|
{
|
|
ManagedLifecycleProbeState.CreateRendererCallCount++;
|
|
return new ManagedLifecycleProbeRenderer(
|
|
CreateRendererFeatures());
|
|
}
|
|
|
|
protected override ScriptableRendererFeature[] CreateRendererFeatures()
|
|
{
|
|
ManagedLifecycleProbeState.CreateFeatureCallCount++;
|
|
return new ScriptableRendererFeature[]
|
|
{
|
|
new ManagedLifecycleProbeRendererFeature()
|
|
};
|
|
}
|
|
|
|
protected override string GetPipelineRendererAssetKey()
|
|
{
|
|
return "BuiltinForward";
|
|
}
|
|
|
|
protected override void ReleaseRuntimeResources()
|
|
{
|
|
ManagedLifecycleProbeState.ReleaseRendererDataRuntimeResourcesCallCount++;
|
|
}
|
|
}
|
|
|
|
internal sealed class ManagedPipelineDisposeProbe
|
|
: ScriptableRenderPipeline
|
|
{
|
|
protected override bool SupportsStageRenderGraph(
|
|
CameraFrameStage stage)
|
|
{
|
|
return stage == CameraFrameStage.MainScene;
|
|
}
|
|
|
|
protected override bool RecordStageRenderGraph(
|
|
ScriptableRenderContext context)
|
|
{
|
|
return context != null;
|
|
}
|
|
|
|
protected override void Dispose(
|
|
bool disposing)
|
|
{
|
|
if (disposing)
|
|
{
|
|
ManagedLifecycleProbeState.DisposePipelineCallCount++;
|
|
}
|
|
}
|
|
}
|
|
|
|
public sealed class LegacyRenderPipelineApiProbeAsset : RenderPipelineAsset
|
|
{
|
|
}
|
|
|
|
public sealed class RenderPipelineApiProbeAsset : ScriptableRenderPipelineAsset
|
|
{
|
|
}
|
|
|
|
public sealed class ManagedPipelineDisposeProbeAsset
|
|
: ScriptableRenderPipelineAsset
|
|
{
|
|
protected override ScriptableRenderPipeline CreatePipeline()
|
|
{
|
|
ManagedLifecycleProbeState.CreatePipelineCallCount++;
|
|
return new ManagedPipelineDisposeProbe();
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedUniversalLifecycleProbeAsset
|
|
: UniversalRenderPipelineAsset
|
|
{
|
|
public ManagedUniversalLifecycleProbeAsset()
|
|
{
|
|
rendererDataList = new ScriptableRendererData[]
|
|
{
|
|
new ManagedLifecycleProbeRendererData()
|
|
};
|
|
}
|
|
|
|
protected override ScriptableRenderPipeline CreatePipeline()
|
|
{
|
|
ManagedLifecycleProbeState.CreatePipelineCallCount++;
|
|
return base.CreatePipeline();
|
|
}
|
|
|
|
protected override void ReleaseRuntimeResources()
|
|
{
|
|
ManagedLifecycleProbeState.ReleaseAssetRuntimeResourcesCallCount++;
|
|
ReleaseRendererDataRuntimeResources();
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedRenderPipelineProbeAsset
|
|
: UniversalRenderPipelineAsset
|
|
{
|
|
public static int CreatePipelineCallCount;
|
|
|
|
public ManagedRenderPipelineProbeAsset()
|
|
{
|
|
rendererDataList = new ScriptableRendererData[]
|
|
{
|
|
new ManagedRenderPipelineProbeRendererData()
|
|
};
|
|
}
|
|
|
|
protected override ScriptableRenderPipeline CreatePipeline()
|
|
{
|
|
CreatePipelineCallCount++;
|
|
return base.CreatePipeline();
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedPostProcessRenderPipelineProbeAsset
|
|
: UniversalRenderPipelineAsset
|
|
{
|
|
public ManagedPostProcessRenderPipelineProbeAsset()
|
|
{
|
|
rendererDataList =
|
|
new ScriptableRendererData[]
|
|
{
|
|
new ManagedPostProcessRenderPipelineProbeRendererData()
|
|
};
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedUnknownBackendRenderPipelineProbeAsset
|
|
: UniversalRenderPipelineAsset
|
|
{
|
|
public ManagedUnknownBackendRenderPipelineProbeAsset()
|
|
{
|
|
rendererDataList = new ScriptableRendererData[]
|
|
{
|
|
new ManagedUnknownBackendProbeRendererData()
|
|
};
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedUniversalRenderPipelineProbeAsset
|
|
: UniversalRenderPipelineAsset
|
|
{
|
|
public static int CreatePipelineCallCount;
|
|
public Vector4 postProcessScale = new Vector4(1.03f, 0.98f, 0.94f, 1.0f);
|
|
|
|
public ManagedUniversalRenderPipelineProbeAsset()
|
|
{
|
|
rendererDataList = CreateRendererDataList();
|
|
}
|
|
|
|
protected override ScriptableRenderPipeline CreatePipeline()
|
|
{
|
|
CreatePipelineCallCount++;
|
|
rendererDataList = CreateRendererDataList();
|
|
return base.CreatePipeline();
|
|
}
|
|
|
|
private ScriptableRendererData[] CreateRendererDataList()
|
|
{
|
|
return new ScriptableRendererData[]
|
|
{
|
|
new ManagedUniversalRenderPipelineProbeRendererData(
|
|
postProcessScale)
|
|
};
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedDefaultRendererSelectionProbeAsset
|
|
: UniversalRenderPipelineAsset
|
|
{
|
|
public ManagedDefaultRendererSelectionProbeAsset()
|
|
{
|
|
rendererDataList = new ScriptableRendererData[]
|
|
{
|
|
new ManagedUnknownBackendProbeRendererData(),
|
|
new ManagedRenderPipelineProbeRendererData()
|
|
};
|
|
defaultRendererIndex = 1;
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedInvalidDefaultRendererSelectionProbeAsset
|
|
: UniversalRenderPipelineAsset
|
|
{
|
|
public ManagedInvalidDefaultRendererSelectionProbeAsset()
|
|
{
|
|
rendererDataList = new ScriptableRendererData[]
|
|
{
|
|
new ManagedRenderPipelineProbeRendererData(),
|
|
new ManagedUnknownBackendProbeRendererData()
|
|
};
|
|
defaultRendererIndex = 5;
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedRendererReuseProbeAsset
|
|
: UniversalRenderPipelineAsset
|
|
{
|
|
public ManagedRendererReuseProbeAsset()
|
|
{
|
|
ManagedRendererReuseProbeRendererData.CreateRendererCallCount = 0;
|
|
rendererDataList = new ScriptableRendererData[]
|
|
{
|
|
new ManagedRendererReuseProbeRendererData()
|
|
};
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedPlannedFullscreenRenderPipelineProbeAsset
|
|
: UniversalRenderPipelineAsset
|
|
{
|
|
public ManagedPlannedFullscreenRenderPipelineProbeAsset()
|
|
{
|
|
rendererDataList =
|
|
new ScriptableRendererData[]
|
|
{
|
|
new ManagedPlannedFullscreenRenderPipelineProbeRendererData()
|
|
};
|
|
}
|
|
}
|
|
|
|
internal sealed class ManagedCameraRequestConfiguredRendererData
|
|
: UniversalRendererData
|
|
{
|
|
protected override ScriptableRenderer CreateRenderer()
|
|
{
|
|
return new ProbeSceneRenderer();
|
|
}
|
|
|
|
protected override void ConfigureCameraRenderRequest(
|
|
CameraRenderRequestContext context)
|
|
{
|
|
if (HasDirectionalShadow(context))
|
|
{
|
|
ClearDirectionalShadow(context);
|
|
}
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedCameraRequestConfiguredRenderPipelineProbeAsset
|
|
: UniversalRenderPipelineAsset
|
|
{
|
|
public ManagedCameraRequestConfiguredRenderPipelineProbeAsset()
|
|
{
|
|
rendererDataList = new ScriptableRendererData[]
|
|
{
|
|
new ManagedCameraRequestConfiguredRendererData()
|
|
};
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedRenderContextCameraDataProbeAsset
|
|
: UniversalRenderPipelineAsset
|
|
{
|
|
public ManagedRenderContextCameraDataProbeAsset()
|
|
{
|
|
rendererDataList =
|
|
new ScriptableRendererData[]
|
|
{
|
|
new ManagedRenderContextCameraDataProbeRendererData()
|
|
};
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedFinalColorRenderPipelineProbeAsset
|
|
: UniversalRenderPipelineAsset
|
|
{
|
|
public ManagedFinalColorRenderPipelineProbeAsset()
|
|
{
|
|
rendererDataList = new ScriptableRendererData[]
|
|
{
|
|
new ManagedRenderPipelineProbeRendererData()
|
|
};
|
|
}
|
|
|
|
protected override FinalColorSettings GetDefaultFinalColorSettings()
|
|
{
|
|
return ProbeFinalColorSettingsFactory.Create();
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedRenderContextFinalColorDataProbeAsset
|
|
: UniversalRenderPipelineAsset
|
|
{
|
|
public ManagedRenderContextFinalColorDataProbeAsset()
|
|
{
|
|
rendererDataList =
|
|
new ScriptableRendererData[]
|
|
{
|
|
new ManagedRenderContextCameraDataProbeRendererData()
|
|
};
|
|
}
|
|
|
|
protected override FinalColorSettings GetDefaultFinalColorSettings()
|
|
{
|
|
return ProbeFinalColorSettingsFactory.Create();
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedRenderContextStageColorDataProbeAsset
|
|
: UniversalRenderPipelineAsset
|
|
{
|
|
public ManagedRenderContextStageColorDataProbeAsset()
|
|
{
|
|
rendererDataList =
|
|
new ScriptableRendererData[]
|
|
{
|
|
new ManagedRenderContextStageColorDataProbeRendererData()
|
|
};
|
|
}
|
|
}
|
|
|
|
internal sealed class ManagedRenderPipelineProbe
|
|
: ProbeSceneRenderer
|
|
{
|
|
public static int SupportsStageCallCount;
|
|
public static int RecordStageCallCount;
|
|
|
|
protected override bool SupportsStageRenderGraph(
|
|
CameraFrameStage stage)
|
|
{
|
|
SupportsStageCallCount++;
|
|
return base.SupportsStageRenderGraph(stage);
|
|
}
|
|
|
|
protected override bool RecordStageRenderGraph(
|
|
ScriptableRenderContext context)
|
|
{
|
|
RecordStageCallCount++;
|
|
return base.RecordStageRenderGraph(context);
|
|
}
|
|
}
|
|
|
|
internal sealed class ManagedPostProcessRenderPipelineProbe
|
|
: ProbePostProcessRenderer
|
|
{
|
|
public ManagedPostProcessRenderPipelineProbe()
|
|
: base(
|
|
new Vector4(1.10f, 0.95f, 0.90f, 1.0f),
|
|
new Vector4(0.95f, 1.05f, 1.10f, 1.0f))
|
|
{
|
|
}
|
|
}
|
|
|
|
internal sealed class ManagedUniversalRenderPipelineProbe
|
|
: ProbeUniversalRenderer
|
|
{
|
|
public static int SupportsMainSceneCallCount;
|
|
public static int SupportsPostProcessCallCount;
|
|
public static int RecordMainSceneCallCount;
|
|
public static int RecordSceneCallCount;
|
|
public static int RecordPostProcessCallCount;
|
|
public static Vector4 LastPostProcessScale;
|
|
|
|
private readonly Vector4 m_postProcessScale;
|
|
|
|
public ManagedUniversalRenderPipelineProbe(
|
|
Vector4 postProcessScale)
|
|
: base(
|
|
postProcessScale,
|
|
OnOpaqueRecorded)
|
|
{
|
|
m_postProcessScale = postProcessScale;
|
|
}
|
|
|
|
protected override bool SupportsStageRenderGraph(
|
|
CameraFrameStage stage)
|
|
{
|
|
if (stage == CameraFrameStage.MainScene)
|
|
{
|
|
SupportsMainSceneCallCount++;
|
|
}
|
|
else if (stage == CameraFrameStage.PostProcess)
|
|
{
|
|
SupportsPostProcessCallCount++;
|
|
}
|
|
|
|
return base.SupportsStageRenderGraph(stage);
|
|
}
|
|
|
|
protected override bool RecordStageRenderGraph(
|
|
ScriptableRenderContext context)
|
|
{
|
|
if (context == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (context.stage == CameraFrameStage.MainScene)
|
|
{
|
|
RecordMainSceneCallCount++;
|
|
}
|
|
else if (context.stage == CameraFrameStage.PostProcess)
|
|
{
|
|
RecordPostProcessCallCount++;
|
|
LastPostProcessScale = m_postProcessScale;
|
|
}
|
|
|
|
return base.RecordStageRenderGraph(context);
|
|
}
|
|
|
|
private static void OnOpaqueRecorded()
|
|
{
|
|
RecordSceneCallCount++;
|
|
}
|
|
}
|
|
|
|
internal sealed class ManagedPlannedFullscreenRenderPipelineProbe
|
|
: ProbePlannedFullscreenRenderer
|
|
{
|
|
}
|
|
|
|
internal sealed class ManagedRenderContextCameraDataProbe
|
|
: CameraDataObservationRenderer
|
|
{
|
|
}
|
|
|
|
internal sealed class ManagedRenderContextStageColorDataProbe
|
|
: StageColorObservationRenderer
|
|
{
|
|
}
|
|
|
|
public sealed class ManagedRendererReuseObservationProbe
|
|
: MonoBehaviour
|
|
{
|
|
public int ObservedCreateRendererCallCount;
|
|
|
|
public void Start()
|
|
{
|
|
ObservedCreateRendererCallCount =
|
|
ManagedRendererReuseProbeRendererData
|
|
.CreateRendererCallCount;
|
|
}
|
|
}
|
|
|
|
public sealed class RenderPipelineApiProbe : MonoBehaviour
|
|
{
|
|
public bool InitialAssetWasNull;
|
|
public bool SelectionRoundTripSucceeded;
|
|
public bool SelectionReferencePreserved;
|
|
public string SelectedPipelineAssetTypeName = string.Empty;
|
|
|
|
public void Start()
|
|
{
|
|
InitialAssetWasNull = GraphicsSettings.renderPipelineAsset == null;
|
|
|
|
RenderPipelineApiProbeAsset selectedAssetInstance =
|
|
new RenderPipelineApiProbeAsset();
|
|
GraphicsSettings.renderPipelineAsset = selectedAssetInstance;
|
|
ScriptableRenderPipelineAsset selectedAsset =
|
|
GraphicsSettings.renderPipelineAsset;
|
|
SelectionRoundTripSucceeded =
|
|
selectedAsset is RenderPipelineApiProbeAsset;
|
|
SelectionReferencePreserved =
|
|
object.ReferenceEquals(
|
|
selectedAsset,
|
|
selectedAssetInstance);
|
|
SelectedPipelineAssetTypeName = selectedAsset != null
|
|
? selectedAsset.GetType().FullName ?? string.Empty
|
|
: string.Empty;
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedRenderPipelineRuntimeSelectionProbe : MonoBehaviour
|
|
{
|
|
public void Start()
|
|
{
|
|
ManagedRenderPipelineProbeAsset.CreatePipelineCallCount = 0;
|
|
ManagedRenderPipelineProbe.SupportsStageCallCount = 0;
|
|
ManagedRenderPipelineProbe.RecordStageCallCount = 0;
|
|
GraphicsSettings.renderPipelineAsset =
|
|
new ManagedRenderPipelineProbeAsset();
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedRenderPipelineCreateCountObservationProbe
|
|
: MonoBehaviour
|
|
{
|
|
public int ObservedCreatePipelineCallCount;
|
|
|
|
public void Start()
|
|
{
|
|
ManagedRenderPipelineProbeAsset.CreatePipelineCallCount = 0;
|
|
}
|
|
|
|
public void Update()
|
|
{
|
|
ObservedCreatePipelineCallCount =
|
|
ManagedRenderPipelineProbeAsset.CreatePipelineCallCount;
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedLifecycleObservationProbe
|
|
: MonoBehaviour
|
|
{
|
|
public int ObservedCreatePipelineCallCount;
|
|
public int ObservedCreateRendererCallCount;
|
|
public int ObservedCreateFeatureCallCount;
|
|
public int ObservedReleaseRendererDataRuntimeResourcesCallCount;
|
|
public int ObservedDisposePipelineCallCount;
|
|
public int ObservedReleaseAssetRuntimeResourcesCallCount;
|
|
public int ObservedDisposeRendererCallCount;
|
|
public int ObservedDisposeFeatureCallCount;
|
|
|
|
public void Start()
|
|
{
|
|
ManagedLifecycleProbeState.Reset();
|
|
}
|
|
|
|
public void Update()
|
|
{
|
|
ObservedCreatePipelineCallCount =
|
|
ManagedLifecycleProbeState.CreatePipelineCallCount;
|
|
ObservedCreateRendererCallCount =
|
|
ManagedLifecycleProbeState.CreateRendererCallCount;
|
|
ObservedCreateFeatureCallCount =
|
|
ManagedLifecycleProbeState.CreateFeatureCallCount;
|
|
ObservedReleaseRendererDataRuntimeResourcesCallCount =
|
|
ManagedLifecycleProbeState
|
|
.ReleaseRendererDataRuntimeResourcesCallCount;
|
|
ObservedDisposePipelineCallCount =
|
|
ManagedLifecycleProbeState.DisposePipelineCallCount;
|
|
ObservedReleaseAssetRuntimeResourcesCallCount =
|
|
ManagedLifecycleProbeState.ReleaseAssetRuntimeResourcesCallCount;
|
|
ObservedDisposeRendererCallCount =
|
|
ManagedLifecycleProbeState.DisposeRendererCallCount;
|
|
ObservedDisposeFeatureCallCount =
|
|
ManagedLifecycleProbeState.DisposeFeatureCallCount;
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedUniversalLifecycleRuntimeSelectionProbe
|
|
: MonoBehaviour
|
|
{
|
|
public int ObservedCreatePipelineCallCount;
|
|
public int ObservedCreateRendererCallCount;
|
|
public int ObservedCreateFeatureCallCount;
|
|
public int ObservedReleaseRendererDataRuntimeResourcesCallCount;
|
|
public int ObservedDisposePipelineCallCount;
|
|
public int ObservedReleaseAssetRuntimeResourcesCallCount;
|
|
public int ObservedDisposeRendererCallCount;
|
|
public int ObservedDisposeFeatureCallCount;
|
|
|
|
public void Start()
|
|
{
|
|
ManagedLifecycleProbeState.Reset();
|
|
GraphicsSettings.renderPipelineAsset =
|
|
new ManagedUniversalLifecycleProbeAsset();
|
|
}
|
|
|
|
public void Update()
|
|
{
|
|
ObservedCreatePipelineCallCount =
|
|
ManagedLifecycleProbeState.CreatePipelineCallCount;
|
|
ObservedCreateRendererCallCount =
|
|
ManagedLifecycleProbeState.CreateRendererCallCount;
|
|
ObservedCreateFeatureCallCount =
|
|
ManagedLifecycleProbeState.CreateFeatureCallCount;
|
|
ObservedReleaseRendererDataRuntimeResourcesCallCount =
|
|
ManagedLifecycleProbeState
|
|
.ReleaseRendererDataRuntimeResourcesCallCount;
|
|
ObservedDisposePipelineCallCount =
|
|
ManagedLifecycleProbeState.DisposePipelineCallCount;
|
|
ObservedReleaseAssetRuntimeResourcesCallCount =
|
|
ManagedLifecycleProbeState.ReleaseAssetRuntimeResourcesCallCount;
|
|
ObservedDisposeRendererCallCount =
|
|
ManagedLifecycleProbeState.DisposeRendererCallCount;
|
|
ObservedDisposeFeatureCallCount =
|
|
ManagedLifecycleProbeState.DisposeFeatureCallCount;
|
|
}
|
|
}
|
|
|
|
public sealed class ScriptCoreUniversalRenderPipelineSelectionProbe
|
|
: MonoBehaviour
|
|
{
|
|
public bool SelectionRoundTripSucceeded;
|
|
public string SelectedPipelineAssetTypeName = string.Empty;
|
|
public string SelectedRendererDataTypeName = string.Empty;
|
|
|
|
public void Start()
|
|
{
|
|
UniversalRenderPipelineAsset asset =
|
|
new UniversalRenderPipelineAsset
|
|
{
|
|
rendererDataList =
|
|
new ScriptableRendererData[]
|
|
{
|
|
new UniversalRendererData()
|
|
}
|
|
};
|
|
GraphicsSettings.renderPipelineAsset = asset;
|
|
|
|
UniversalRenderPipelineAsset selectedAsset =
|
|
GraphicsSettings.renderPipelineAsset as UniversalRenderPipelineAsset;
|
|
ScriptableRendererData selectedRendererData = null;
|
|
if (selectedAsset != null &&
|
|
selectedAsset.rendererDataList != null &&
|
|
selectedAsset.rendererDataList.Length > 0)
|
|
{
|
|
int rendererIndex =
|
|
selectedAsset.defaultRendererIndex;
|
|
if (rendererIndex < 0 ||
|
|
rendererIndex >= selectedAsset.rendererDataList.Length)
|
|
{
|
|
rendererIndex = 0;
|
|
}
|
|
|
|
selectedRendererData =
|
|
selectedAsset.rendererDataList[rendererIndex];
|
|
}
|
|
|
|
SelectionRoundTripSucceeded =
|
|
selectedAsset != null;
|
|
SelectedPipelineAssetTypeName =
|
|
selectedAsset != null
|
|
? selectedAsset.GetType().FullName ?? string.Empty
|
|
: string.Empty;
|
|
SelectedRendererDataTypeName = selectedRendererData != null
|
|
? selectedRendererData.GetType().FullName ?? string.Empty
|
|
: string.Empty;
|
|
}
|
|
}
|
|
|
|
public sealed class ScriptCoreUniversalRenderPipelineRuntimeSelectionProbe
|
|
: MonoBehaviour
|
|
{
|
|
public void Start()
|
|
{
|
|
GraphicsSettings.renderPipelineAsset =
|
|
new UniversalRenderPipelineAsset
|
|
{
|
|
rendererDataList =
|
|
new ScriptableRendererData[]
|
|
{
|
|
new UniversalRendererData()
|
|
}
|
|
};
|
|
}
|
|
}
|
|
|
|
public sealed class ScriptCoreConfiguredUniversalRenderPipelineRuntimeSelectionProbe
|
|
: MonoBehaviour
|
|
{
|
|
public void Start()
|
|
{
|
|
GraphicsSettings.renderPipelineAsset =
|
|
new UniversalRenderPipelineAsset
|
|
{
|
|
rendererDataList =
|
|
new ScriptableRendererData[]
|
|
{
|
|
new UniversalRendererData
|
|
{
|
|
renderOpaque = true,
|
|
renderSkybox = false,
|
|
renderTransparent = false
|
|
}
|
|
}
|
|
};
|
|
}
|
|
}
|
|
|
|
public sealed class ScriptCoreUniversalPostProcessRendererFeatureRuntimeSelectionProbe
|
|
: MonoBehaviour
|
|
{
|
|
public void Start()
|
|
{
|
|
GraphicsSettings.renderPipelineAsset =
|
|
new UniversalRenderPipelineAsset
|
|
{
|
|
rendererDataList =
|
|
new ScriptableRendererData[]
|
|
{
|
|
new UniversalRendererData
|
|
{
|
|
rendererFeatures =
|
|
new ScriptableRendererFeature[]
|
|
{
|
|
new ColorScalePostProcessRendererFeature
|
|
{
|
|
colorScale = new Vector4(
|
|
1.08f,
|
|
0.96f,
|
|
0.92f,
|
|
1.0f)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
}
|
|
|
|
public sealed class ScriptCoreUniversalShadowlessRendererFeatureRuntimeSelectionProbe
|
|
: MonoBehaviour
|
|
{
|
|
public void Start()
|
|
{
|
|
GraphicsSettings.renderPipelineAsset =
|
|
new UniversalRenderPipelineAsset
|
|
{
|
|
rendererDataList =
|
|
new ScriptableRendererData[]
|
|
{
|
|
new UniversalRendererData
|
|
{
|
|
rendererFeatures =
|
|
new ScriptableRendererFeature[]
|
|
{
|
|
new DisableDirectionalShadowRendererFeature()
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
}
|
|
|
|
public sealed class ProjectConfiguredRenderPipelineGetterProbe
|
|
: MonoBehaviour
|
|
{
|
|
public bool ObservedAssetWasNull = true;
|
|
public string ObservedPipelineAssetTypeName = string.Empty;
|
|
|
|
public void Start()
|
|
{
|
|
ScriptableRenderPipelineAsset asset =
|
|
GraphicsSettings.renderPipelineAsset;
|
|
ObservedAssetWasNull = asset == null;
|
|
ObservedPipelineAssetTypeName = asset != null
|
|
? asset.GetType().FullName ?? string.Empty
|
|
: string.Empty;
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedUniversalRenderPipelineRuntimeSelectionProbe
|
|
: MonoBehaviour
|
|
{
|
|
public int ObservedCreatePipelineCallCount;
|
|
public int ObservedSupportsMainSceneCallCount;
|
|
public int ObservedSupportsPostProcessCallCount;
|
|
public int ObservedRecordMainSceneCallCount;
|
|
public int ObservedRecordSceneCallCount;
|
|
public int ObservedRecordPostProcessCallCount;
|
|
public Vector4 ObservedPostProcessScale;
|
|
|
|
public void Start()
|
|
{
|
|
ManagedUniversalRenderPipelineProbeAsset.CreatePipelineCallCount = 0;
|
|
ManagedUniversalRenderPipelineProbe.SupportsMainSceneCallCount = 0;
|
|
ManagedUniversalRenderPipelineProbe.SupportsPostProcessCallCount = 0;
|
|
ManagedUniversalRenderPipelineProbe.RecordMainSceneCallCount = 0;
|
|
ManagedUniversalRenderPipelineProbe.RecordSceneCallCount = 0;
|
|
ManagedUniversalRenderPipelineProbe.RecordPostProcessCallCount = 0;
|
|
ManagedUniversalRenderPipelineProbe.LastPostProcessScale =
|
|
new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
GraphicsSettings.renderPipelineAsset =
|
|
new ManagedUniversalRenderPipelineProbeAsset
|
|
{
|
|
postProcessScale = new Vector4(1.11f, 0.97f, 0.93f, 1.0f)
|
|
};
|
|
}
|
|
|
|
public void Update()
|
|
{
|
|
ObservedCreatePipelineCallCount =
|
|
ManagedUniversalRenderPipelineProbeAsset.CreatePipelineCallCount;
|
|
ObservedSupportsMainSceneCallCount =
|
|
ManagedUniversalRenderPipelineProbe.SupportsMainSceneCallCount;
|
|
ObservedSupportsPostProcessCallCount =
|
|
ManagedUniversalRenderPipelineProbe.SupportsPostProcessCallCount;
|
|
ObservedRecordMainSceneCallCount =
|
|
ManagedUniversalRenderPipelineProbe.RecordMainSceneCallCount;
|
|
ObservedRecordSceneCallCount =
|
|
ManagedUniversalRenderPipelineProbe.RecordSceneCallCount;
|
|
ObservedRecordPostProcessCallCount =
|
|
ManagedUniversalRenderPipelineProbe.RecordPostProcessCallCount;
|
|
ObservedPostProcessScale =
|
|
ManagedUniversalRenderPipelineProbe.LastPostProcessScale;
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedRenderContextCameraDataRuntimeSelectionProbe
|
|
: MonoBehaviour
|
|
{
|
|
public Vector4 ObservedViewRow0;
|
|
public Vector4 ObservedViewRow1;
|
|
public Vector4 ObservedViewRow2;
|
|
public Vector4 ObservedViewRow3;
|
|
public Vector4 ObservedProjectionRow0;
|
|
public Vector4 ObservedProjectionRow1;
|
|
public Vector4 ObservedProjectionRow2;
|
|
public Vector4 ObservedProjectionRow3;
|
|
public Vector4 ObservedViewProjectionRow0;
|
|
public Vector4 ObservedViewProjectionRow1;
|
|
public Vector4 ObservedViewProjectionRow2;
|
|
public Vector4 ObservedViewProjectionRow3;
|
|
public Vector3 ObservedWorldPosition;
|
|
public Vector4 ObservedClearColor;
|
|
public int ObservedClearFlags;
|
|
public bool ObservedPerspectiveProjection;
|
|
public float ObservedVerticalFovRadians;
|
|
public float ObservedOrthographicSize;
|
|
public float ObservedAspectRatio;
|
|
public float ObservedNearClipPlane;
|
|
public float ObservedFarClipPlane;
|
|
public int ObservedViewportWidth;
|
|
public int ObservedViewportHeight;
|
|
public int ObservedRecordCallCount;
|
|
|
|
public void Start()
|
|
{
|
|
CameraDataObservationPass.Reset();
|
|
GraphicsSettings.renderPipelineAsset =
|
|
new ManagedRenderContextCameraDataProbeAsset();
|
|
}
|
|
|
|
public void Update()
|
|
{
|
|
ObservedViewRow0 =
|
|
CameraDataObservationPass.ObservedViewRow0;
|
|
ObservedViewRow1 =
|
|
CameraDataObservationPass.ObservedViewRow1;
|
|
ObservedViewRow2 =
|
|
CameraDataObservationPass.ObservedViewRow2;
|
|
ObservedViewRow3 =
|
|
CameraDataObservationPass.ObservedViewRow3;
|
|
ObservedProjectionRow0 =
|
|
CameraDataObservationPass.ObservedProjectionRow0;
|
|
ObservedProjectionRow1 =
|
|
CameraDataObservationPass.ObservedProjectionRow1;
|
|
ObservedProjectionRow2 =
|
|
CameraDataObservationPass.ObservedProjectionRow2;
|
|
ObservedProjectionRow3 =
|
|
CameraDataObservationPass.ObservedProjectionRow3;
|
|
ObservedViewProjectionRow0 =
|
|
CameraDataObservationPass.ObservedViewProjectionRow0;
|
|
ObservedViewProjectionRow1 =
|
|
CameraDataObservationPass.ObservedViewProjectionRow1;
|
|
ObservedViewProjectionRow2 =
|
|
CameraDataObservationPass.ObservedViewProjectionRow2;
|
|
ObservedViewProjectionRow3 =
|
|
CameraDataObservationPass.ObservedViewProjectionRow3;
|
|
ObservedWorldPosition =
|
|
CameraDataObservationPass.ObservedWorldPosition;
|
|
ObservedClearColor =
|
|
CameraDataObservationPass.ObservedClearColor;
|
|
ObservedClearFlags =
|
|
CameraDataObservationPass.ObservedClearFlags;
|
|
ObservedPerspectiveProjection =
|
|
CameraDataObservationPass.ObservedPerspectiveProjection;
|
|
ObservedVerticalFovRadians =
|
|
CameraDataObservationPass.ObservedVerticalFovRadians;
|
|
ObservedOrthographicSize =
|
|
CameraDataObservationPass.ObservedOrthographicSize;
|
|
ObservedAspectRatio =
|
|
CameraDataObservationPass.ObservedAspectRatio;
|
|
ObservedNearClipPlane =
|
|
CameraDataObservationPass.ObservedNearClipPlane;
|
|
ObservedFarClipPlane =
|
|
CameraDataObservationPass.ObservedFarClipPlane;
|
|
ObservedViewportWidth =
|
|
CameraDataObservationPass.ObservedViewportWidth;
|
|
ObservedViewportHeight =
|
|
CameraDataObservationPass.ObservedViewportHeight;
|
|
ObservedRecordCallCount =
|
|
CameraDataObservationPass.RecordCallCount;
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedRenderContextLightingDataRuntimeSelectionProbe
|
|
: MonoBehaviour
|
|
{
|
|
public bool ObservedMainDirectionalLightEnabled;
|
|
public bool ObservedMainDirectionalLightCastsShadows;
|
|
public Vector3 ObservedMainDirectionalLightDirection;
|
|
public Vector4 ObservedMainDirectionalLightColor;
|
|
public float ObservedMainDirectionalLightIntensity;
|
|
public bool ObservedHasMainDirectionalShadow;
|
|
public int ObservedAdditionalLightCount;
|
|
public int ObservedRecordCallCount;
|
|
|
|
public void Start()
|
|
{
|
|
CameraDataObservationPass.Reset();
|
|
GraphicsSettings.renderPipelineAsset =
|
|
new ManagedRenderContextCameraDataProbeAsset();
|
|
}
|
|
|
|
public void Update()
|
|
{
|
|
ObservedMainDirectionalLightEnabled =
|
|
CameraDataObservationPass
|
|
.ObservedMainDirectionalLightEnabled;
|
|
ObservedMainDirectionalLightCastsShadows =
|
|
CameraDataObservationPass
|
|
.ObservedMainDirectionalLightCastsShadows;
|
|
ObservedMainDirectionalLightDirection =
|
|
CameraDataObservationPass
|
|
.ObservedMainDirectionalLightDirection;
|
|
ObservedMainDirectionalLightColor =
|
|
CameraDataObservationPass
|
|
.ObservedMainDirectionalLightColor;
|
|
ObservedMainDirectionalLightIntensity =
|
|
CameraDataObservationPass
|
|
.ObservedMainDirectionalLightIntensity;
|
|
ObservedHasMainDirectionalShadow =
|
|
CameraDataObservationPass
|
|
.ObservedHasMainDirectionalShadow;
|
|
ObservedAdditionalLightCount =
|
|
CameraDataObservationPass
|
|
.ObservedAdditionalLightCount;
|
|
ObservedRecordCallCount =
|
|
CameraDataObservationPass.RecordCallCount;
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedRenderContextEnvironmentDataRuntimeSelectionProbe
|
|
: MonoBehaviour
|
|
{
|
|
public int ObservedEnvironmentMode;
|
|
public Vector4 ObservedSkyboxTopColor;
|
|
public Vector4 ObservedSkyboxHorizonColor;
|
|
public Vector4 ObservedSkyboxBottomColor;
|
|
public int ObservedRecordCallCount;
|
|
|
|
public void Start()
|
|
{
|
|
CameraDataObservationPass.Reset();
|
|
GraphicsSettings.renderPipelineAsset =
|
|
new ManagedRenderContextCameraDataProbeAsset();
|
|
}
|
|
|
|
public void Update()
|
|
{
|
|
ObservedEnvironmentMode =
|
|
CameraDataObservationPass.ObservedEnvironmentMode;
|
|
ObservedSkyboxTopColor =
|
|
CameraDataObservationPass.ObservedSkyboxTopColor;
|
|
ObservedSkyboxHorizonColor =
|
|
CameraDataObservationPass.ObservedSkyboxHorizonColor;
|
|
ObservedSkyboxBottomColor =
|
|
CameraDataObservationPass.ObservedSkyboxBottomColor;
|
|
ObservedRecordCallCount =
|
|
CameraDataObservationPass.RecordCallCount;
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedRenderContextShadowDataRuntimeSelectionProbe
|
|
: MonoBehaviour
|
|
{
|
|
public bool ObservedShadowEnabled;
|
|
public Vector4 ObservedShadowViewProjectionRow0;
|
|
public Vector4 ObservedShadowViewProjectionRow1;
|
|
public Vector4 ObservedShadowViewProjectionRow2;
|
|
public Vector4 ObservedShadowViewProjectionRow3;
|
|
public float ObservedShadowOrthographicHalfExtent;
|
|
public float ObservedShadowNearClipPlane;
|
|
public float ObservedShadowFarClipPlane;
|
|
public int ObservedShadowMapWidth;
|
|
public int ObservedShadowMapHeight;
|
|
public float ObservedShadowWorldTexelSize;
|
|
public float ObservedShadowReceiverDepthBias;
|
|
public float ObservedShadowNormalBiasScale;
|
|
public float ObservedShadowStrength;
|
|
public float ObservedShadowDepthBiasFactor;
|
|
public int ObservedShadowDepthBiasUnits;
|
|
public int ObservedRecordCallCount;
|
|
|
|
public void Start()
|
|
{
|
|
CameraDataObservationPass.Reset();
|
|
GraphicsSettings.renderPipelineAsset =
|
|
new ManagedRenderContextCameraDataProbeAsset();
|
|
}
|
|
|
|
public void Update()
|
|
{
|
|
ObservedShadowEnabled =
|
|
CameraDataObservationPass.ObservedShadowEnabled;
|
|
ObservedShadowViewProjectionRow0 =
|
|
CameraDataObservationPass
|
|
.ObservedShadowViewProjectionRow0;
|
|
ObservedShadowViewProjectionRow1 =
|
|
CameraDataObservationPass
|
|
.ObservedShadowViewProjectionRow1;
|
|
ObservedShadowViewProjectionRow2 =
|
|
CameraDataObservationPass
|
|
.ObservedShadowViewProjectionRow2;
|
|
ObservedShadowViewProjectionRow3 =
|
|
CameraDataObservationPass
|
|
.ObservedShadowViewProjectionRow3;
|
|
ObservedShadowOrthographicHalfExtent =
|
|
CameraDataObservationPass
|
|
.ObservedShadowOrthographicHalfExtent;
|
|
ObservedShadowNearClipPlane =
|
|
CameraDataObservationPass
|
|
.ObservedShadowNearClipPlane;
|
|
ObservedShadowFarClipPlane =
|
|
CameraDataObservationPass
|
|
.ObservedShadowFarClipPlane;
|
|
ObservedShadowMapWidth =
|
|
CameraDataObservationPass
|
|
.ObservedShadowMapWidth;
|
|
ObservedShadowMapHeight =
|
|
CameraDataObservationPass
|
|
.ObservedShadowMapHeight;
|
|
ObservedShadowWorldTexelSize =
|
|
CameraDataObservationPass
|
|
.ObservedShadowWorldTexelSize;
|
|
ObservedShadowReceiverDepthBias =
|
|
CameraDataObservationPass
|
|
.ObservedShadowReceiverDepthBias;
|
|
ObservedShadowNormalBiasScale =
|
|
CameraDataObservationPass
|
|
.ObservedShadowNormalBiasScale;
|
|
ObservedShadowStrength =
|
|
CameraDataObservationPass
|
|
.ObservedShadowStrength;
|
|
ObservedShadowDepthBiasFactor =
|
|
CameraDataObservationPass
|
|
.ObservedShadowDepthBiasFactor;
|
|
ObservedShadowDepthBiasUnits =
|
|
CameraDataObservationPass
|
|
.ObservedShadowDepthBiasUnits;
|
|
ObservedRecordCallCount =
|
|
CameraDataObservationPass.RecordCallCount;
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedRenderContextFinalColorDataRuntimeSelectionProbe
|
|
: MonoBehaviour
|
|
{
|
|
public int ObservedFinalColorOutputTransferMode;
|
|
public int ObservedFinalColorExposureMode;
|
|
public float ObservedFinalColorExposureValue;
|
|
public int ObservedFinalColorToneMappingMode;
|
|
public Vector4 ObservedFinalColorScale;
|
|
public bool ObservedFinalColorHasPipelineDefaults;
|
|
public bool ObservedFinalColorHasCameraOverrides;
|
|
public bool ObservedFinalColorRequiresProcessing;
|
|
public int ObservedRecordCallCount;
|
|
|
|
public void Start()
|
|
{
|
|
CameraDataObservationPass.Reset();
|
|
GraphicsSettings.renderPipelineAsset =
|
|
new ManagedRenderContextFinalColorDataProbeAsset();
|
|
}
|
|
|
|
public void Update()
|
|
{
|
|
ObservedFinalColorOutputTransferMode =
|
|
CameraDataObservationPass
|
|
.ObservedFinalColorOutputTransferMode;
|
|
ObservedFinalColorExposureMode =
|
|
CameraDataObservationPass
|
|
.ObservedFinalColorExposureMode;
|
|
ObservedFinalColorExposureValue =
|
|
CameraDataObservationPass
|
|
.ObservedFinalColorExposureValue;
|
|
ObservedFinalColorToneMappingMode =
|
|
CameraDataObservationPass
|
|
.ObservedFinalColorToneMappingMode;
|
|
ObservedFinalColorScale =
|
|
CameraDataObservationPass
|
|
.ObservedFinalColorScale;
|
|
ObservedFinalColorHasPipelineDefaults =
|
|
CameraDataObservationPass
|
|
.ObservedFinalColorHasPipelineDefaults;
|
|
ObservedFinalColorHasCameraOverrides =
|
|
CameraDataObservationPass
|
|
.ObservedFinalColorHasCameraOverrides;
|
|
ObservedFinalColorRequiresProcessing =
|
|
CameraDataObservationPass
|
|
.ObservedFinalColorRequiresProcessing;
|
|
ObservedRecordCallCount =
|
|
CameraDataObservationPass.RecordCallCount;
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedRenderContextStageColorDataRuntimeSelectionProbe
|
|
: MonoBehaviour
|
|
{
|
|
public int ObservedMainSceneSource;
|
|
public bool ObservedMainSceneUsesGraphManagedOutputColor;
|
|
public int ObservedPostProcessSource;
|
|
public bool ObservedPostProcessUsesGraphManagedOutputColor;
|
|
public int ObservedFinalOutputSource;
|
|
public bool ObservedFinalOutputUsesGraphManagedOutputColor;
|
|
public int ObservedMainSceneRecordCallCount;
|
|
public int ObservedPostProcessRecordCallCount;
|
|
public int ObservedFinalOutputRecordCallCount;
|
|
|
|
public void Start()
|
|
{
|
|
StageColorObservationPass.Reset();
|
|
GraphicsSettings.renderPipelineAsset =
|
|
new ManagedRenderContextStageColorDataProbeAsset();
|
|
}
|
|
|
|
public void Update()
|
|
{
|
|
ObservedMainSceneSource =
|
|
StageColorObservationPass.ObservedMainSceneSource;
|
|
ObservedMainSceneUsesGraphManagedOutputColor =
|
|
StageColorObservationPass
|
|
.ObservedMainSceneUsesGraphManagedOutputColor;
|
|
ObservedPostProcessSource =
|
|
StageColorObservationPass.ObservedPostProcessSource;
|
|
ObservedPostProcessUsesGraphManagedOutputColor =
|
|
StageColorObservationPass
|
|
.ObservedPostProcessUsesGraphManagedOutputColor;
|
|
ObservedFinalOutputSource =
|
|
StageColorObservationPass.ObservedFinalOutputSource;
|
|
ObservedFinalOutputUsesGraphManagedOutputColor =
|
|
StageColorObservationPass
|
|
.ObservedFinalOutputUsesGraphManagedOutputColor;
|
|
ObservedMainSceneRecordCallCount =
|
|
StageColorObservationPass.MainSceneRecordCallCount;
|
|
ObservedPostProcessRecordCallCount =
|
|
StageColorObservationPass.PostProcessRecordCallCount;
|
|
ObservedFinalOutputRecordCallCount =
|
|
StageColorObservationPass.FinalOutputRecordCallCount;
|
|
}
|
|
}
|
|
}
|
|
|