ssdfasd
cd29c8b2bc
Introduce renderer-driven and renderer-backed managed pipeline base types in the Universal package. Move shared renderer-data/default-renderer ownership out of UniversalRenderPipelineAsset, migrate probe assets onto the generic seam, and expose renderer recording/request context types for future SRP expansion. Update scripting API-surface expectations and validate with build, unit tests, scripting tests, and old editor smoke.
2196 lines
79 KiB
C#
2196 lines
79 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 ManagedFeaturePlannedPostProcessRendererFeature
|
|
: ScriptableRendererFeature
|
|
{
|
|
public override void ConfigureCameraFramePlan(
|
|
ScriptableRenderPipelinePlanningContext context)
|
|
{
|
|
if (context == null ||
|
|
context.IsStageRequested(CameraFrameStage.PostProcess))
|
|
{
|
|
return;
|
|
}
|
|
|
|
context.RequestFullscreenStage(
|
|
CameraFrameStage.PostProcess,
|
|
CameraFrameColorSource.MainSceneColor);
|
|
}
|
|
}
|
|
|
|
internal sealed class ManagedFeaturePlannedPostProcessRendererData
|
|
: ProbeRendererData
|
|
{
|
|
protected override ScriptableRenderer CreateProbeRenderer()
|
|
{
|
|
return new ProbeSceneRenderer();
|
|
}
|
|
|
|
protected override ScriptableRendererFeature[] CreateRendererFeatures()
|
|
{
|
|
return new ScriptableRendererFeature[]
|
|
{
|
|
new ManagedFeaturePlannedPostProcessRendererFeature()
|
|
};
|
|
}
|
|
}
|
|
|
|
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
|
|
: RendererBackedRenderPipelineAsset
|
|
{
|
|
public static int CreatePipelineCallCount;
|
|
|
|
public ManagedRenderPipelineProbeAsset()
|
|
{
|
|
rendererDataList = new ScriptableRendererData[]
|
|
{
|
|
new ManagedRenderPipelineProbeRendererData()
|
|
};
|
|
}
|
|
|
|
protected override ScriptableRenderPipeline CreatePipeline()
|
|
{
|
|
CreatePipelineCallCount++;
|
|
return base.CreatePipeline();
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedPostProcessRenderPipelineProbeAsset
|
|
: RendererBackedRenderPipelineAsset
|
|
{
|
|
public ManagedPostProcessRenderPipelineProbeAsset()
|
|
{
|
|
rendererDataList =
|
|
new ScriptableRendererData[]
|
|
{
|
|
new ManagedPostProcessRenderPipelineProbeRendererData()
|
|
};
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedUnknownBackendRenderPipelineProbeAsset
|
|
: RendererBackedRenderPipelineAsset
|
|
{
|
|
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
|
|
: RendererBackedRenderPipelineAsset
|
|
{
|
|
public ManagedDefaultRendererSelectionProbeAsset()
|
|
{
|
|
rendererDataList = new ScriptableRendererData[]
|
|
{
|
|
new ManagedUnknownBackendProbeRendererData(),
|
|
new ManagedRenderPipelineProbeRendererData()
|
|
};
|
|
defaultRendererIndex = 1;
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedInvalidDefaultRendererSelectionProbeAsset
|
|
: RendererBackedRenderPipelineAsset
|
|
{
|
|
public ManagedInvalidDefaultRendererSelectionProbeAsset()
|
|
{
|
|
rendererDataList = new ScriptableRendererData[]
|
|
{
|
|
new ManagedRenderPipelineProbeRendererData(),
|
|
new ManagedUnknownBackendProbeRendererData()
|
|
};
|
|
defaultRendererIndex = 5;
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedRendererReuseProbeAsset
|
|
: RendererBackedRenderPipelineAsset
|
|
{
|
|
public ManagedRendererReuseProbeAsset()
|
|
{
|
|
ManagedRendererReuseProbeRendererData.CreateRendererCallCount = 0;
|
|
rendererDataList = new ScriptableRendererData[]
|
|
{
|
|
new ManagedRendererReuseProbeRendererData()
|
|
};
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedPlannedFullscreenRenderPipelineProbeAsset
|
|
: UniversalRenderPipelineAsset
|
|
{
|
|
public ManagedPlannedFullscreenRenderPipelineProbeAsset()
|
|
{
|
|
rendererDataList =
|
|
new ScriptableRendererData[]
|
|
{
|
|
new ManagedPlannedFullscreenRenderPipelineProbeRendererData()
|
|
};
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedFeaturePlannedPostProcessProbeAsset
|
|
: UniversalRenderPipelineAsset
|
|
{
|
|
public ManagedFeaturePlannedPostProcessProbeAsset()
|
|
{
|
|
rendererDataList =
|
|
new ScriptableRendererData[]
|
|
{
|
|
new ManagedFeaturePlannedPostProcessRendererData()
|
|
};
|
|
}
|
|
}
|
|
|
|
public sealed class ManagedClearedPostProcessRenderPipelineProbeAsset
|
|
: UniversalRenderPipelineAsset
|
|
{
|
|
public ManagedClearedPostProcessRenderPipelineProbeAsset()
|
|
{
|
|
rendererDataList =
|
|
new ScriptableRendererData[]
|
|
{
|
|
new ManagedPlannedFullscreenRenderPipelineProbeRendererData()
|
|
};
|
|
}
|
|
|
|
protected override void ConfigureCameraFramePlan(
|
|
ScriptableRenderPipelinePlanningContext context)
|
|
{
|
|
if (context == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
context.ClearFullscreenStage(
|
|
CameraFrameStage.PostProcess);
|
|
context.RequestFullscreenStage(
|
|
CameraFrameStage.FinalOutput,
|
|
CameraFrameColorSource.MainSceneColor);
|
|
}
|
|
|
|
protected override FinalColorSettings GetDefaultFinalColorSettings()
|
|
{
|
|
return ProbeFinalColorSettingsFactory.Create();
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|