public void Awake()
{
UnityEngine.Rendering.Universal.UniversalRenderPipelineAsset asset = GraphicsSettings.renderPipelineAsset as UnityEngine.Rendering.Universal.UniversalRenderPipelineAsset;
if (asset != null)
{
asset.shadowCascadeOption = (m_EnableCascades) ? UnityEngine.Rendering.Universal.ShadowCascadesOption.FourCascades : UnityEngine.Rendering.Universal.ShadowCascadesOption.NoCascades;
}
QualitySettings.shadowCascades = (m_EnableCascades) ? 4 : 1;
}
void Start()
{
if (lightweightRenderPipelineAsset == null)
{
lightweightRenderPipelineAsset = GraphicsSettings.renderPipelineAsset as UnityEngine.Rendering.Universal.UniversalRenderPipelineAsset;
// NOTE: LightweightRenderPipelineAsset doesn't expose properties to set any of the following fields
lwrpaShadowField = lightweightRenderPipelineAsset.GetType().GetField("m_MainLightShadowsSupported", BindingFlags.NonPublic | BindingFlags.Instance);
lwrpaSoftShadowField = lightweightRenderPipelineAsset.GetType().GetField("m_SoftShadowsSupported", BindingFlags.NonPublic | BindingFlags.Instance);
lwrpaShadowResolutionField = lightweightRenderPipelineAsset.GetType().GetField("m_MainLightShadowmapResolution", BindingFlags.NonPublic | BindingFlags.Instance);
}
ApplyQualitySettings(Settings.i.qualitySettings);
}
static void OnLoad()
{
if (null != GraphicsSettings.renderPipelineAsset)
{
return;
}
var allAssetPaths = AssetDatabase.GetAllAssetPaths();
foreach (var curAssetPath in allAssetPaths)
{
if (curAssetPath.EndsWith("UniversalRenderPipelineAsset.asset"))
{
UnityEngine.Rendering.Universal.UniversalRenderPipelineAsset pipelineAsset =
AssetDatabase.LoadAssetAtPath <UnityEngine.Rendering.Universal.UniversalRenderPipelineAsset>(
curAssetPath);
GraphicsSettings.renderPipelineAsset = pipelineAsset;
PlayerSettings.colorSpace = ColorSpace.Linear;
}
}
}
static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets,
string[] movedAssets, string[] movedFromAssetPaths)
{
if (null != GraphicsSettings.renderPipelineAsset)
{
return;
}
int numImportedAssets = importedAssets.Length;
for (int i = 0; i < numImportedAssets; ++i)
{
string curAssetPath = importedAssets[i];
if (curAssetPath == "Assets/RenderPipeline/URP/UniversalRenderPipelineAsset.asset")
{
UnityEngine.Rendering.Universal.UniversalRenderPipelineAsset pipelineAsset =
AssetDatabase.LoadAssetAtPath <UnityEngine.Rendering.Universal.UniversalRenderPipelineAsset>(curAssetPath);
GraphicsSettings.renderPipelineAsset = pipelineAsset;
PlayerSettings.colorSpace = ColorSpace.Linear;
}
}
}
static void InitializeLightData(UniversalRenderPipelineAsset settings, NativeArray <VisibleLight> visibleLights, int mainLightIndex, out LightData lightData)
{
int maxPerObjectAdditionalLights = UniversalRenderPipeline.maxPerObjectLights;
int maxVisibleAdditionalLights = UniversalRenderPipeline.maxVisibleAdditionalLights;
lightData.mainLightIndex = mainLightIndex;
if (settings.additionalLightsRenderingMode != LightRenderingMode.Disabled)
{
lightData.additionalLightsCount =
Math.Min((mainLightIndex != -1) ? visibleLights.Length - 1 : visibleLights.Length,
maxVisibleAdditionalLights);
lightData.maxPerObjectAdditionalLightsCount = Math.Min(settings.maxAdditionalLightsCount, maxPerObjectAdditionalLights);
}
else
{
lightData.additionalLightsCount = 0;
lightData.maxPerObjectAdditionalLightsCount = 0;
}
lightData.shadeAdditionalLightsPerVertex = settings.additionalLightsRenderingMode == LightRenderingMode.PerVertex;
lightData.visibleLights = visibleLights;
lightData.supportsMixedLighting = settings.supportsMixedLighting;
}
public override void Action(int instanceId, string pathName, string resourceFile)
{
var instance = UniversalRenderPipelineAsset.CreateRendererAsset(pathName, RendererType.UniversalRenderer, false) as UniversalRendererData;
Selection.activeObject = instance;
}
public ForwardRenderer(ForwardRendererData data) : base(data)
{
#if ENABLE_VR && ENABLE_XR_MODULE
UniversalRenderPipeline.m_XRSystem.InitializeXRSystemData(data.xrSystemData);
#endif
m_BlitMaterial = CoreUtils.CreateEngineMaterial(data.shaders.blitPS);
m_CopyDepthMaterial = CoreUtils.CreateEngineMaterial(data.shaders.copyDepthPS);
m_SamplingMaterial = CoreUtils.CreateEngineMaterial(data.shaders.samplingPS);
m_ScreenspaceShadowsMaterial = CoreUtils.CreateEngineMaterial(data.shaders.screenSpaceShadowPS);
//m_TileDepthInfoMaterial = CoreUtils.CreateEngineMaterial(data.shaders.tileDepthInfoPS);
//m_TileDeferredMaterial = CoreUtils.CreateEngineMaterial(data.shaders.tileDeferredPS);
m_StencilDeferredMaterial = CoreUtils.CreateEngineMaterial(data.shaders.stencilDeferredPS);
StencilStateData stencilData = data.defaultStencilState;
m_DefaultStencilState = StencilState.defaultValue;
m_DefaultStencilState.enabled = stencilData.overrideStencilState;
m_DefaultStencilState.SetCompareFunction(stencilData.stencilCompareFunction);
m_DefaultStencilState.SetPassOperation(stencilData.passOperation);
m_DefaultStencilState.SetFailOperation(stencilData.failOperation);
m_DefaultStencilState.SetZFailOperation(stencilData.zFailOperation);
m_ForwardLights = new ForwardLights();
//m_DeferredLights.LightCulling = data.lightCulling;
this.m_RenderingMode = RenderingMode.Forward;
// Note: Since all custom render passes inject first and we have stable sort,
// we inject the builtin passes in the before events.
m_MainLightShadowCasterPass = new MainLightShadowCasterPass(RenderPassEvent.BeforeRenderingShadows);
m_AdditionalLightsShadowCasterPass = new AdditionalLightsShadowCasterPass(RenderPassEvent.BeforeRenderingShadows);
#if ENABLE_VR && ENABLE_XR_MODULE
m_XROcclusionMeshPass = new XROcclusionMeshPass(RenderPassEvent.BeforeRenderingOpaques);
// Schedule XR copydepth right after m_FinalBlitPass(AfterRendering + 1)
m_XRCopyDepthPass = new CopyDepthPass(RenderPassEvent.AfterRendering + 2, m_CopyDepthMaterial);
#endif
m_DepthPrepass = new DepthOnlyPass(RenderPassEvent.BeforeRenderingPrepasses, RenderQueueRange.opaque, data.opaqueLayerMask);
m_DepthNormalPrepass = new DepthNormalOnlyPass(RenderPassEvent.BeforeRenderingPrepasses, RenderQueueRange.opaque, data.opaqueLayerMask);
m_ColorGradingLutPass = new ColorGradingLutPass(RenderPassEvent.BeforeRenderingPrepasses, data.postProcessData);
if (this.renderingMode == RenderingMode.Deferred)
{
m_DeferredLights = new DeferredLights(m_TileDepthInfoMaterial, m_TileDeferredMaterial, m_StencilDeferredMaterial);
m_DeferredLights.AccurateGbufferNormals = data.accurateGbufferNormals;
//m_DeferredLights.TiledDeferredShading = data.tiledDeferredShading;
m_DeferredLights.TiledDeferredShading = false;
UniversalRenderPipelineAsset urpAsset = GraphicsSettings.renderPipelineAsset as UniversalRenderPipelineAsset;
m_GBufferPass = new GBufferPass(RenderPassEvent.BeforeRenderingOpaques, RenderQueueRange.opaque, data.opaqueLayerMask, m_DefaultStencilState, stencilData.stencilReference, m_DeferredLights);
// Forward-only pass only runs if deferred renderer is enabled.
// It allows specific materials to be rendered in a forward-like pass.
// We render both gbuffer pass and forward-only pass before the deferred lighting pass so we can minimize copies of depth buffer and
// benefits from some depth rejection.
// - If a material can be rendered either forward or deferred, then it should declare a UniversalForward and a UniversalGBuffer pass.
// - If a material cannot be lit in deferred (unlit, bakedLit, special material such as hair, skin shader), then it should declare UniversalForwardOnly pass
// - Legacy materials have unamed pass, which is implicitely renamed as SRPDefaultUnlit. In that case, they are considered forward-only too.
// TO declare a material with unnamed pass and UniversalForward/UniversalForwardOnly pass is an ERROR, as the material will be rendered twice.
StencilState forwardOnlyStencilState = DeferredLights.OverwriteStencil(m_DefaultStencilState, (int)StencilUsage.MaterialMask);
ShaderTagId[] forwardOnlyShaderTagIds = new ShaderTagId[] {
new ShaderTagId("UniversalForwardOnly"),
new ShaderTagId("SRPDefaultUnlit"), // Legacy shaders (do not have a gbuffer pass) are considered forward-only for backward compatibility
new ShaderTagId("LightweightForward") // Legacy shaders (do not have a gbuffer pass) are considered forward-only for backward compatibility
};
int forwardOnlyStencilRef = stencilData.stencilReference | (int)StencilUsage.MaterialUnlit;
m_RenderOpaqueForwardOnlyPass = new DrawObjectsPass("Render Opaques Forward Only", forwardOnlyShaderTagIds, true, RenderPassEvent.BeforeRenderingOpaques + 1, RenderQueueRange.opaque, data.opaqueLayerMask, forwardOnlyStencilState, forwardOnlyStencilRef);
m_GBufferCopyDepthPass = new CopyDepthPass(RenderPassEvent.BeforeRenderingOpaques + 2, m_CopyDepthMaterial);
m_TileDepthRangePass = new TileDepthRangePass(RenderPassEvent.BeforeRenderingOpaques + 3, m_DeferredLights, 0);
m_TileDepthRangeExtraPass = new TileDepthRangePass(RenderPassEvent.BeforeRenderingOpaques + 4, m_DeferredLights, 1);
m_DeferredPass = new DeferredPass(RenderPassEvent.BeforeRenderingOpaques + 5, m_DeferredLights);
}
// Always create this pass even in deferred because we use it for wireframe rendering in the Editor or offscreen depth texture rendering.
m_RenderOpaqueForwardPass = new DrawObjectsPass(URPProfileId.DrawOpaqueObjects, true, RenderPassEvent.BeforeRenderingOpaques, RenderQueueRange.opaque, data.opaqueLayerMask, m_DefaultStencilState, stencilData.stencilReference);
m_CopyDepthPass = new CopyDepthPass(RenderPassEvent.AfterRenderingSkybox, m_CopyDepthMaterial);
m_DrawSkyboxPass = new DrawSkyboxPass(RenderPassEvent.BeforeRenderingSkybox);
m_CopyColorPass = new CopyColorPass(RenderPassEvent.AfterRenderingSkybox, m_SamplingMaterial, m_BlitMaterial);
#if ADAPTIVE_PERFORMANCE_2_1_0_OR_NEWER
if (!UniversalRenderPipeline.asset.useAdaptivePerformance || AdaptivePerformance.AdaptivePerformanceRenderSettings.SkipTransparentObjects == false)
#endif
{
m_TransparentSettingsPass = new TransparentSettingsPass(RenderPassEvent.BeforeRenderingTransparents, data.shadowTransparentReceive);
m_RenderTransparentForwardPass = new DrawObjectsPass(URPProfileId.DrawTransparentObjects, false, RenderPassEvent.BeforeRenderingTransparents, RenderQueueRange.transparent, data.transparentLayerMask, m_DefaultStencilState, stencilData.stencilReference);
}
m_OnRenderObjectCallbackPass = new InvokeOnRenderObjectCallbackPass(RenderPassEvent.BeforeRenderingPostProcessing);
m_PostProcessPass = new PostProcessPass(RenderPassEvent.BeforeRenderingPostProcessing, data.postProcessData, m_BlitMaterial);
m_FinalPostProcessPass = new PostProcessPass(RenderPassEvent.AfterRendering + 1, data.postProcessData, m_BlitMaterial);
m_CapturePass = new CapturePass(RenderPassEvent.AfterRendering);
m_FinalBlitPass = new FinalBlitPass(RenderPassEvent.AfterRendering + 1, m_BlitMaterial);
#if UNITY_EDITOR
m_SceneViewDepthCopyPass = new SceneViewDepthCopyPass(RenderPassEvent.AfterRendering + 9, m_CopyDepthMaterial);
#endif
// RenderTexture format depends on camera and pipeline (HDR, non HDR, etc)
// Samples (MSAA) depend on camera and pipeline
m_CameraColorAttachment.Init("_CameraColorTexture");
m_CameraDepthAttachment.Init("_CameraDepthAttachment");
m_DepthTexture.Init("_CameraDepthTexture");
m_NormalsTexture.Init("_CameraNormalsTexture");
if (this.renderingMode == RenderingMode.Deferred)
{
m_GBufferHandles = new RenderTargetHandle[(int)DeferredLights.GBufferHandles.Count];
m_GBufferHandles[(int)DeferredLights.GBufferHandles.DepthAsColor].Init("_GBufferDepthAsColor");
m_GBufferHandles[(int)DeferredLights.GBufferHandles.Albedo].Init("_GBuffer0");
m_GBufferHandles[(int)DeferredLights.GBufferHandles.SpecularMetallic].Init("_GBuffer1");
m_GBufferHandles[(int)DeferredLights.GBufferHandles.NormalSmoothness].Init("_GBuffer2");
m_GBufferHandles[(int)DeferredLights.GBufferHandles.Lighting] = new RenderTargetHandle();
m_GBufferHandles[(int)DeferredLights.GBufferHandles.ShadowMask].Init("_GBuffer4");
}
m_OpaqueColor.Init("_CameraOpaqueTexture");
m_AfterPostProcessColor.Init("_AfterPostProcessTexture");
m_ColorGradingLut.Init("_InternalGradingLut");
m_DepthInfoTexture.Init("_DepthInfoTexture");
m_TileDepthInfoTexture.Init("_TileDepthInfoTexture");
supportedRenderingFeatures = new RenderingFeatures()
{
cameraStacking = true,
};
if (this.renderingMode == RenderingMode.Deferred)
{
unsupportedGraphicsDeviceTypes = new GraphicsDeviceType[] {
GraphicsDeviceType.OpenGLCore,
GraphicsDeviceType.OpenGLES2,
GraphicsDeviceType.OpenGLES3
};
}
}
public override void OnInspectorGUI()
{
ManageBuildOptimizationStatus();
serializedObject.Update();
SetStyles();
Beautify.TonemapOperator prevTonemap = beautify.tonemap.value;
bool prevDirectWrite = beautify.directWrite.value;
EditorGUILayout.BeginVertical();
{
GUI.skin.label.alignment = TextAnchor.MiddleCenter;
GUILayout.BeginHorizontal(blackBack);
GUILayout.Label(headerTex, GUILayout.ExpandWidth(true));
GUI.skin.label.alignment = TextAnchor.MiddleLeft;
GUILayout.EndHorizontal();
Camera cam = Camera.main;
if (cam != null)
{
UniversalAdditionalCameraData data = cam.GetComponent <UniversalAdditionalCameraData>();
if (data != null && !data.renderPostProcessing)
{
EditorGUILayout.HelpBox("Post Processing option is disabled in the camera.", MessageType.Warning);
if (GUILayout.Button("Go to Camera"))
{
Selection.activeObject = cam;
}
EditorGUILayout.Separator();
}
}
UnityEngine.Rendering.Universal.UniversalRenderPipelineAsset pipe = UnityEngine.Rendering.GraphicsSettings.currentRenderPipeline as UnityEngine.Rendering.Universal.UniversalRenderPipelineAsset;
if (pipe == null)
{
EditorGUILayout.HelpBox("Universal Rendering Pipeline asset is not set in 'Project Settings / Graphics' !", MessageType.Error);
EditorGUILayout.Separator();
GUI.enabled = false;
}
else if (!BeautifyRendererFeature.installed)
{
EditorGUILayout.HelpBox("Beautify Render Feature must be added to the rendering pipeline renderer.", MessageType.Error);
if (GUILayout.Button("Go to Universal Rendering Pipeline Asset"))
{
Selection.activeObject = pipe;
}
EditorGUILayout.Separator();
GUI.enabled = false;
}
else if (beautify.RequiresDepthTexture())
{
if (!pipe.supportsCameraDepthTexture)
{
EditorGUILayout.HelpBox("Depth Texture option is required in Universal Rendering Pipeline asset!", MessageType.Warning);
if (GUILayout.Button("Go to Universal Rendering Pipeline Asset"))
{
Selection.activeObject = pipe;
}
EditorGUILayout.Separator();
GUI.enabled = false;
}
}
bool usesHDREffect = beautify.tonemap.value != Beautify.TonemapOperator.Linear;
if (usesHDREffect && (QualitySettings.activeColorSpace != ColorSpace.Linear || (Camera.main != null && !Camera.main.allowHDR)))
{
EditorGUILayout.HelpBox("Some effects, like bloom or tonemapping, works better with Linear Color Space and HDR enabled. Enable Linear color space in Player Settings and check your camera and pipeline HDR setting.", MessageType.Warning);
}
// sections
foreach (var section in sections)
{
bool printSectionHeader = true;
// individual properties
foreach (var field in section.Value.singleFields)
{
var parameter = Unpack(propertyFetcher.Find(field.Name));
var displayName = parameter.displayName;
if (field.GetCustomAttribute(typeof(Beautify.DisplayName)) is Beautify.DisplayName displayNameAttrib)
{
displayName = displayNameAttrib.name;
}
bool indent;
if (!IsVisible(parameter, field, out indent))
{
continue;
}
if (printSectionHeader)
{
GUILayout.Space(6.0f);
Rect rect = GUILayoutUtility.GetRect(16f, 22f, sectionGroupStyle);
GUI.Box(rect, ObjectNames.NicifyVariableName(section.Key.GetType().Name), sectionGroupStyle);
printSectionHeader = false;
}
DrawPropertyField(parameter, field, indent);
if (beautify.disabled.value)
{
GUI.enabled = false;
}
}
GUILayout.Space(6.0f);
// grouped properties
foreach (var group in section.Value.groups)
{
Beautify.SettingsGroup settingsGroup = group.Key;
string groupName = ObjectNames.NicifyVariableName(settingsGroup.GetType().Name);
bool printGroupFoldout = true;
bool firstField = true;
bool groupHasContent = false;
foreach (var field in group.Value)
{
var parameter = Unpack(propertyFetcher.Find(field.Name));
bool indent;
if (!IsVisible(parameter, field, out indent))
{
if (firstField)
{
break;
}
continue;
}
firstField = false;
if (printSectionHeader)
{
GUILayout.Space(6.0f);
Rect rect = GUILayoutUtility.GetRect(16f, 22f, sectionGroupStyle);
GUI.Box(rect, ObjectNames.NicifyVariableName(section.Key.GetType().Name), sectionGroupStyle);
printSectionHeader = false;
}
if (printGroupFoldout)
{
printGroupFoldout = false;
settingsGroup.IsExpanded = EditorGUILayout.Foldout(settingsGroup.IsExpanded, groupName, true, foldoutStyle);
if (!settingsGroup.IsExpanded)
{
break;
}
}
DrawPropertyField(parameter, field, indent);
groupHasContent = true;
if (parameter.value.propertyType == SerializedPropertyType.Boolean)
{
if (!parameter.value.boolValue)
{
var hasToggleSectionBegin = field.GetCustomAttributes(typeof(Beautify.ToggleAllFields)).Any();
if (hasToggleSectionBegin)
{
break;
}
}
}
else if (field.Name.Equals("depthOfFieldFocusMode"))
{
SerializedProperty prop = serializedObject.FindProperty(field.Name);
if (prop != null)
{
var value = prop.FindPropertyRelative("m_Value");
if (value != null && value.enumValueIndex == (int)Beautify.DoFFocusMode.FollowTarget)
{
EditorGUILayout.HelpBox("Assign target in the Beautify Settings component.", MessageType.Info);
}
}
}
}
if (groupHasContent)
{
GUILayout.Space(6.0f);
}
}
}
}
EditorGUILayout.EndVertical();
serializedObject.ApplyModifiedProperties();
if (prevTonemap != beautify.tonemap.value && beautify.tonemap.value == Beautify.TonemapOperator.ACES)
{
beautify.saturate.value = 0;
beautify.saturate.overrideState = true;
beautify.contrast.value = 1f;
beautify.contrast.overrideState = true;
}
if (beautify.directWrite.value != prevDirectWrite)
{
EditorApplication.delayCall += () =>
UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
}
}
static void InitializeShadowData(UniversalRenderPipelineAsset settings, NativeArray <VisibleLight> visibleLights, bool mainLightCastShadows, bool additionalLightsCastShadows, out ShadowData shadowData)
{
m_ShadowBiasData.Clear();
for (int i = 0; i < visibleLights.Length; ++i)
{
Light light = visibleLights[i].light;
UniversalAdditionalLightData data = null;
if (light != null)
{
#if UNITY_2019_3_OR_NEWER
light.gameObject.TryGetComponent(out data);
#else
data = light.gameObject.GetComponent <LWRPAdditionalLightData>();
#endif
}
if (data && !data.usePipelineSettings)
{
m_ShadowBiasData.Add(new Vector4(light.shadowBias, light.shadowNormalBias, 0.0f, 0.0f));
}
else
{
m_ShadowBiasData.Add(new Vector4(settings.shadowDepthBias, settings.shadowNormalBias, 0.0f, 0.0f));
}
}
shadowData.bias = m_ShadowBiasData;
// Until we can have keyword stripping forcing single cascade hard shadows on gles2
bool supportsScreenSpaceShadows = SystemInfo.graphicsDeviceType != GraphicsDeviceType.OpenGLES2;
shadowData.supportsMainLightShadows = SystemInfo.supportsShadows && settings.supportsMainLightShadows && mainLightCastShadows;
// we resolve shadows in screenspace when cascades are enabled to save ALU as computing cascade index + shadowCoord on fragment is expensive
shadowData.requiresScreenSpaceShadowResolve = shadowData.supportsMainLightShadows && supportsScreenSpaceShadows && settings.shadowCascadeOption != ShadowCascadesOption.NoCascades;
int shadowCascadesCount;
switch (settings.shadowCascadeOption)
{
case ShadowCascadesOption.FourCascades:
shadowCascadesCount = 4;
break;
case ShadowCascadesOption.TwoCascades:
shadowCascadesCount = 2;
break;
default:
shadowCascadesCount = 1;
break;
}
shadowData.mainLightShadowCascadesCount = (shadowData.requiresScreenSpaceShadowResolve) ? shadowCascadesCount : 1;
shadowData.mainLightShadowmapWidth = settings.mainLightShadowmapResolution;
shadowData.mainLightShadowmapHeight = settings.mainLightShadowmapResolution;
switch (shadowData.mainLightShadowCascadesCount)
{
case 1:
shadowData.mainLightShadowCascadesSplit = new Vector3(1.0f, 0.0f, 0.0f);
break;
case 2:
shadowData.mainLightShadowCascadesSplit = new Vector3(settings.cascade2Split, 1.0f, 0.0f);
break;
default:
shadowData.mainLightShadowCascadesSplit = settings.cascade4Split;
break;
}
shadowData.supportsAdditionalLightShadows = SystemInfo.supportsShadows && settings.supportsAdditionalLightShadows && additionalLightsCastShadows;
shadowData.additionalLightsShadowmapWidth = shadowData.additionalLightsShadowmapHeight = settings.additionalLightsShadowmapResolution;
shadowData.supportsSoftShadows = settings.supportsSoftShadows && (shadowData.supportsMainLightShadows || shadowData.supportsAdditionalLightShadows);
shadowData.shadowmapDepthBufferBits = 16;
}
static void InitializeCameraData(UniversalRenderPipelineAsset settings, Camera camera, UniversalAdditionalCameraData additionalCameraData, out CameraData cameraData)
{
const float kRenderScaleThreshold = 0.05f;
cameraData = new CameraData();
cameraData.camera = camera;
cameraData.isStereoEnabled = IsStereoEnabled(camera);
int msaaSamples = 1;
if (camera.allowMSAA && settings.msaaSampleCount > 1)
{
msaaSamples = (camera.targetTexture != null) ? camera.targetTexture.antiAliasing : settings.msaaSampleCount;
}
cameraData.isSceneViewCamera = camera.cameraType == CameraType.SceneView;
cameraData.isHdrEnabled = camera.allowHDR && settings.supportsHDR;
cameraData.postProcessEnabled = CoreUtils.ArePostProcessesEnabled(camera) &&
camera.cameraType != CameraType.Reflection &&
camera.cameraType != CameraType.Preview &&
SystemInfo.graphicsDeviceType != GraphicsDeviceType.OpenGLES2;
// Disables postprocessing in mobile VR. It's not stable on mobile yet.
// TODO: enable postfx for stereo rendering
if (cameraData.isStereoEnabled && Application.isMobilePlatform)
{
cameraData.postProcessEnabled = false;
}
Rect cameraRect = camera.rect;
cameraData.isDefaultViewport = (!(Math.Abs(cameraRect.x) > 0.0f || Math.Abs(cameraRect.y) > 0.0f ||
Math.Abs(cameraRect.width) < 1.0f || Math.Abs(cameraRect.height) < 1.0f));
// If XR is enabled, use XR renderScale.
// Discard variations lesser than kRenderScaleThreshold.
// Scale is only enabled for gameview.
float usedRenderScale = XRGraphics.enabled ? XRGraphics.eyeTextureResolutionScale : settings.renderScale;
cameraData.renderScale = (Mathf.Abs(1.0f - usedRenderScale) < kRenderScaleThreshold) ? 1.0f : usedRenderScale;
cameraData.renderScale = (camera.cameraType == CameraType.Game) ? cameraData.renderScale : 1.0f;
bool anyShadowsEnabled = settings.supportsMainLightShadows || settings.supportsAdditionalLightShadows;
cameraData.maxShadowDistance = (anyShadowsEnabled) ? settings.shadowDistance : 0.0f;
if (additionalCameraData != null)
{
cameraData.maxShadowDistance = (additionalCameraData.renderShadows) ? cameraData.maxShadowDistance : 0.0f;
cameraData.requiresDepthTexture = additionalCameraData.requiresDepthTexture;
cameraData.requiresOpaqueTexture = additionalCameraData.requiresColorTexture;
cameraData.volumeLayerMask = additionalCameraData.volumeLayerMask;
cameraData.volumeTrigger = additionalCameraData.volumeTrigger == null ? camera.transform : additionalCameraData.volumeTrigger;
cameraData.postProcessEnabled &= additionalCameraData.renderPostProcessing;
cameraData.isStopNaNEnabled = cameraData.postProcessEnabled && additionalCameraData.stopNaN && SystemInfo.graphicsShaderLevel >= 35;
cameraData.isDitheringEnabled = cameraData.postProcessEnabled && additionalCameraData.dithering;
cameraData.antialiasing = cameraData.postProcessEnabled ? additionalCameraData.antialiasing : AntialiasingMode.None;
cameraData.antialiasingQuality = additionalCameraData.antialiasingQuality;
}
else
{
cameraData.requiresDepthTexture = settings.supportsCameraDepthTexture;
cameraData.requiresOpaqueTexture = settings.supportsCameraOpaqueTexture;
cameraData.volumeLayerMask = 1; // "Default"
cameraData.volumeTrigger = null;
cameraData.postProcessEnabled = false;
cameraData.isStopNaNEnabled = false;
cameraData.isDitheringEnabled = false;
cameraData.antialiasing = AntialiasingMode.None;
cameraData.antialiasingQuality = AntialiasingQuality.High;
}
cameraData.requiresDepthTexture |= cameraData.isSceneViewCamera || cameraData.postProcessEnabled;
var commonOpaqueFlags = SortingCriteria.CommonOpaque;
var noFrontToBackOpaqueFlags = SortingCriteria.SortingLayer | SortingCriteria.RenderQueue | SortingCriteria.OptimizeStateChanges | SortingCriteria.CanvasOrder;
bool hasHSRGPU = SystemInfo.hasHiddenSurfaceRemovalOnGPU;
bool canSkipFrontToBackSorting = (camera.opaqueSortMode == OpaqueSortMode.Default && hasHSRGPU) || camera.opaqueSortMode == OpaqueSortMode.NoDistanceSort;
cameraData.defaultOpaqueSortFlags = canSkipFrontToBackSorting ? noFrontToBackOpaqueFlags : commonOpaqueFlags;
cameraData.captureActions = CameraCaptureBridge.GetCaptureActions(camera);
cameraData.cameraTargetDescriptor = CreateRenderTextureDescriptor(camera, cameraData.renderScale,
cameraData.isStereoEnabled, cameraData.isHdrEnabled, msaaSamples);
}
static void UpgradeAsset(int assetInstanceID)
{
UniversalRenderPipelineAsset asset = EditorUtility.InstanceIDToObject(assetInstanceID) as UniversalRenderPipelineAsset;
EditorUtility.SetDirty(asset);
}