void LogShaderVariants(Shader shader, ShaderSnippetData snippetData, ShaderVariantLogLevel logLevel, int prevVariantsCount, int currVariantsCount)
{
Func <bool> showlog = () =>
{
if (logLevel == ShaderVariantLogLevel.AllShaders)
{
return(true);
}
if (logLevel == ShaderVariantLogLevel.OnlyLightweightRPShaders && shader.name.Contains("Lightweight Render Pipeline"))
{
return(true);
}
LightweightRenderPipelineAsset lwrpAsset = GraphicsSettings.renderPipelineAsset as LightweightRenderPipelineAsset;
if (logLevel == ShaderVariantLogLevel.ShowIfAbove && currVariantsCount > lwrpAsset.shaderVariantShowNum)
{
return(true);
}
return(false);
};
if (showlog())
{
float percentageCurrent = (float)currVariantsCount / (float)prevVariantsCount * 100f;
float percentageTotal = (float)m_TotalVariantsOutputCount / (float)m_TotalVariantsInputCount * 100f;
string result = string.Format("{9}'s STRIPPING: {0} ({1} pass) ({2}) -" +
" Remaining shader variants = {3}/{4} = {5}% ||| Total = {6}/{7} = {8}%",
shader.name, snippetData.passName, snippetData.shaderType.ToString(), currVariantsCount,
prevVariantsCount, percentageCurrent, m_TotalVariantsOutputCount, m_TotalVariantsInputCount,
percentageTotal, Application.productName);
Debug.Log(YText(result));
}
}
public void OnProcessShader(Shader shader, ShaderSnippetData snippetData, IList <ShaderCompilerData> compilerDataList)
{
LightweightRenderPipelineAsset lwrpAsset = GraphicsSettings.renderPipelineAsset as LightweightRenderPipelineAsset;
if (lwrpAsset == null || compilerDataList == null || compilerDataList.Count == 0)
{
return;
}
ShaderFeatures features = GetSupportedShaderFeatures(lwrpAsset);
int prevVariantCount = compilerDataList.Count;
for (int i = 0; i < compilerDataList.Count; ++i)
{
if (StripUnused(features, shader, snippetData, compilerDataList[i]))
{
compilerDataList.RemoveAt(i);
--i;
}
}
if (lwrpAsset.shaderVariantLogLevel != ShaderVariantLogLevel.Disabled)
{
m_TotalVariantsInputCount += prevVariantCount;
m_TotalVariantsOutputCount += compilerDataList.Count;
LogShaderVariants(shader, snippetData, lwrpAsset.shaderVariantLogLevel, prevVariantCount, compilerDataList.Count);
}
}
private void CreateTextureIfNone(Camera currentCamera)
{
LightweightRenderPipelineAsset lwAsset = (LightweightRenderPipelineAsset)GraphicsSettings.renderPipelineAsset;
//m_TextureSize.y = (int)Mathf.Pow(2, Mathf.RoundToInt(Mathf.Log(currentCamera.pixelHeight * resMulti, 2)));
// Reflection render texture
//if (Int2Compare(m_TextureSize, m_OldReflectionTextureSize) || !m_ReflectionTexture)
if (!m_CamptureTexture)
{
if (m_CamptureTexture)
{
DestroyImmediate(m_CamptureTexture);
}
m_CamptureTexture = new RenderTexture(currentCamera.pixelWidth, currentCamera.pixelHeight, 16, RenderTextureFormat.Default);
m_CamptureTexture.useMipMap = m_CamptureTexture.autoGenerateMips = false;
m_CamptureTexture.autoGenerateMips = false; // no need for mips(unless wanting cheap roughness)
m_CamptureTexture.name = "_PlanarReflection" + GetInstanceID();
m_CamptureTexture.hideFlags = HideFlags.DontSave;
m_CamptureTexture.filterMode = FilterMode.Point;
}
m_CamptureTexture.DiscardContents();
}
public void SetupReferences()
{
lwrpAsset = GraphicsSettings.renderPipelineAsset as LightweightRenderPipelineAsset;
GeneralSettingsController generalSettingsController = GameObject.FindObjectOfType <GeneralSettingsController>();
QualitySettingsController qualitySettingsController = GameObject.FindObjectOfType <QualitySettingsController>();
Assert.IsNotNull(generalSettingsController, "GeneralSettingsController not found in scene");
Assert.IsNotNull(qualitySettingsController, "QualitySettingsController not found in scene");
freeLookCamera = generalSettingsController.thirdPersonCamera;
Assert.IsNotNull(freeLookCamera, "GeneralSettingsController: thirdPersonCamera reference missing");
CinemachineVirtualCamera virtualCamera = generalSettingsController.firstPersonCamera;
Assert.IsNotNull(virtualCamera, "GeneralSettingsController: firstPersonCamera reference missing");
povCamera = virtualCamera.GetCinemachineComponent <CinemachinePOV>();
Assert.IsNotNull(povCamera, "GeneralSettingsController: firstPersonCamera doesn't have CinemachinePOV component");
environmentLight = qualitySettingsController.environmentLight;
Assert.IsNotNull(environmentLight, "QualitySettingsController: environmentLight reference missing");
postProcessVolume = qualitySettingsController.postProcessVolume;
Assert.IsNotNull(postProcessVolume, "QualitySettingsController: postProcessVolume reference missing");
firstPersonCamera = qualitySettingsController.firstPersonCamera;
Assert.IsNotNull(firstPersonCamera, "QualitySettingsController: firstPersonCamera reference missing");
Assert.IsNotNull(qualitySettingsController.thirdPersonCamera, "QualitySettingsController: thirdPersonCamera reference missing");
}
public void Setup()
{
go = new GameObject();
camera = go.AddComponent <Camera>();
prevAsset = GraphicsSettings.renderPipelineAsset;
asset = ScriptableObject.CreateInstance <LightweightRenderPipelineAsset>();
}
public void ValidateAssetSettings()
{
// Create a new asset and validate invalid settings
LightweightRenderPipelineAsset asset = LightweightRenderPipelineAsset.Create();
if (asset != null)
{
asset.shadowDistance = -1.0f;
Assert.GreaterOrEqual(asset.shadowDistance, 0.0f);
asset.renderScale = -1.0f;
Assert.GreaterOrEqual(asset.renderScale, LightweightRenderPipeline.minRenderScale);
asset.renderScale = 32.0f;
Assert.LessOrEqual(asset.renderScale, LightweightRenderPipeline.maxRenderScale);
asset.shadowNormalBias = -1.0f;
Assert.GreaterOrEqual(asset.shadowNormalBias, 0.0f);
asset.shadowNormalBias = 32.0f;
Assert.LessOrEqual(asset.shadowNormalBias, LightweightRenderPipeline.maxShadowBias);
asset.shadowDepthBias = -1.0f;
Assert.GreaterOrEqual(asset.shadowDepthBias, 0.0f);
asset.shadowDepthBias = 32.0f;
Assert.LessOrEqual(asset.shadowDepthBias, LightweightRenderPipeline.maxShadowBias);
asset.maxAdditionalLightsCount = -1;
Assert.GreaterOrEqual(asset.maxAdditionalLightsCount, 0);
asset.maxAdditionalLightsCount = 32;
Assert.LessOrEqual(asset.maxAdditionalLightsCount, LightweightRenderPipeline.maxPerObjectLightCount);
}
}
public new void OnEnable()
{
m_LightweightRenderPipeline = GraphicsSettings.renderPipelineAsset as LightweightRenderPipelineAsset;
settings.OnEnable();
UpdateAnimationValues(true);
}
// Use this for initialization
void Start()
{
float res;
switch (maxRenderSize)
{
case RenderRes._720p:
res = 720f;
break;
case RenderRes._1080p:
res = 1080f;
break;
case RenderRes._2440p:
res = 2440f;
break;
default:
res = Camera.main.pixelHeight;
break;
}
var newRenderScale = Mathf.Clamp(res / Camera.main.pixelHeight, 0.1f, 1.0f);
LightweightRenderPipelineAsset lightweightAsset = GraphicsSettings.renderPipelineAsset as LightweightRenderPipelineAsset;
lightweightAsset.renderScale = newRenderScale;
}
public void OnDisable()
{
m_ShowBGColorAnim.valueChanged.RemoveListener(Repaint);
m_ShowOrthoAnim.valueChanged.RemoveListener(Repaint);
m_ShowTargetEyeAnim.valueChanged.RemoveListener(Repaint);
m_LightweightRenderPipeline = null;
}
public void Awake()
{
LightweightRenderPipelineAsset asset = GraphicsSettings.renderPipelineAsset as LightweightRenderPipelineAsset;
if (asset != null)
{
asset.shadowCascadeOption = (m_EnableCascades) ? ShadowCascadesOption.FourCascades : ShadowCascadesOption.NoCascades;
}
QualitySettings.shadowCascades = (m_EnableCascades) ? 4 : 1;
}
public new void OnEnable()
{
m_LightweightRenderPipeline = GraphicsSettings.renderPipelineAsset as LightweightRenderPipelineAsset;
CoreEditorUtils.GetAdditionalData <LWRPAdditionalCameraData>(targets);
m_AdditionalCameraData = camera.gameObject.GetComponent <LWRPAdditionalCameraData>();
settings.OnEnable();
init(m_AdditionalCameraData);
UpdateAnimationValues(true);
}
public IEnumerator PipelineHasCorrectRenderingSettings()
{
yield return(null);
LightweightRenderPipelineAsset asset = GraphicsSettings.renderPipelineAsset as LightweightRenderPipelineAsset;
Assert.AreNotEqual(asset, null, "LWRP asset is not assigned in the GraphicsSettings.");
Assert.AreEqual(Shader.globalRenderPipeline, "LightweightPipeline", "Wrong render pipeline shader tag.");
Assert.AreEqual(GraphicsSettings.lightsUseLinearIntensity, true, "LWRP must use linear light intensities.");
}
private void SetupRendererPipeline()
{
LightweightRenderPipelineAsset lwrpa = ScriptableObject.Instantiate(GraphicsSettings.renderPipelineAsset) as LightweightRenderPipelineAsset;
if (lwrpa != null)
{
lwrpa.shadowDepthBias = 3;
lwrpa.shadowDistance = 80f;
GraphicsSettings.renderPipelineAsset = lwrpa;
}
}
void init(LWRPAdditionalLightData additionalLightData)
{
if(additionalLightData == null)
return;
m_AdditionalLightDataSO = new SerializedObject(additionalLightData);
m_UseAdditionalDataProp = m_AdditionalLightDataSO.FindProperty("m_UsePipelineSettings");
LightweightRenderPipelineAsset asset = GraphicsSettings.renderPipelineAsset as LightweightRenderPipelineAsset;
settings.shadowsBias.floatValue = asset.shadowDepthBias;
settings.shadowsNormalBias.floatValue = asset.shadowNormalBias;
settings.ApplyModifiedProperties();
}
void Awake()
{
if (lightweightRenderPipelineAsset == null)
{
lightweightRenderPipelineAsset = GraphicsSettings.renderPipelineAsset as LightweightRenderPipelineAsset;
// 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);
}
void UpdateLWRPAssetUI(int newAssetID)
{
lwrpAssetSettings[currentLWRPAssetID].qualitySelectedDisplay.SetActive(false);
currentLWRPAssetID = newAssetID;
lwrpAssetSettings[currentLWRPAssetID].qualitySelectedDisplay.SetActive(true);
LightweightRenderPipelineAsset asset = GraphicsSettings.renderPipelineAsset as LightweightRenderPipelineAsset;
string assetInfoString =
"HDR: " + asset.supportsHDR;
currentLWRPAssetInfo.text = assetInfoString;
}
public IEnumerator PipelineRestoreCorrectSettingsWhenSwitchingToBuiltinPipeline()
{
yield return(null);
LightweightRenderPipelineAsset asset = GraphicsSettings.renderPipelineAsset as LightweightRenderPipelineAsset;
Assert.AreNotEqual(asset, null, "LWRP asset is not assigned in the GraphicsSettings.");
GraphicsSettings.renderPipelineAsset = null;
yield return(null);
Assert.AreEqual(Shader.globalRenderPipeline, "", "Render Pipeline shader tag is not restored.");
GraphicsSettings.renderPipelineAsset = asset;
}
public IEnumerator PipelineRestoreCorrectSettingsWhenSwitchingToBuiltinPipeline()
{
RenderPipelineAsset prevAsset = GraphicsSettings.renderPipelineAsset;
LightweightRenderPipelineAsset asset = ScriptableObject.CreateInstance <LightweightRenderPipelineAsset>();
GraphicsSettings.renderPipelineAsset = asset;
yield return(null);
GraphicsSettings.renderPipelineAsset = null;
yield return(null);
//Assert.AreEqual(Shader.globalRenderPipeline, "", "Render Pipeline shader tag is not restored.");
GraphicsSettings.renderPipelineAsset = prevAsset;
ScriptableObject.DestroyImmediate(asset);
}
public void ValidateNewAssetResources()
{
LightweightRenderPipelineAsset asset = LightweightRenderPipelineAsset.Create();
Assert.AreNotEqual(asset.defaultMaterial, null);
Assert.AreNotEqual(asset.defaultParticleMaterial, null);
Assert.AreNotEqual(asset.defaultLineMaterial, null);
Assert.AreNotEqual(asset.defaultTerrainMaterial, null);
Assert.AreNotEqual(asset.defaultShader, null);
// LWRP doesn't override the following materials
Assert.AreEqual(asset.defaultUIMaterial, null);
Assert.AreEqual(asset.defaultUIOverdrawMaterial, null);
Assert.AreEqual(asset.defaultUIETC1SupportedMaterial, null);
Assert.AreEqual(asset.default2DMaterial, null);
}
static bool CreateLightValidation()
{
LightweightRenderPipeline pipeline = UnityEngine.Rendering.RenderPipelineManager.currentPipeline as LightweightRenderPipeline;
if (pipeline != null)
{
LightweightRenderPipelineAsset asset = LightweightRenderPipeline.asset;
Renderer2DData assetData = asset.scriptableRendererData as Renderer2DData;
if (assetData != null)
{
return(true);
}
}
return(false);
}
public IEnumerator PipelineHasCorrectRenderingSettings()
{
RenderPipelineAsset prevAsset = GraphicsSettings.renderPipelineAsset;
LightweightRenderPipelineAsset asset = ScriptableObject.CreateInstance <LightweightRenderPipelineAsset>();
GraphicsSettings.renderPipelineAsset = asset;
yield return(null);
//Assert.AreEqual(Shader.globalRenderPipeline, "LightweightPipeline", "Wrong render pipeline shader tag.");
//Assert.AreEqual(GraphicsSettings.lightsUseLinearIntensity, true, "LWRP must use linear light intensities.");
GraphicsSettings.renderPipelineAsset = prevAsset;
yield return(null);
ScriptableObject.DestroyImmediate(asset);
}
private void CreateGlossyTexture(Camera currentCamera, float reflectionBufferScale)
{
LightweightRenderPipelineAsset lwAsset = (LightweightRenderPipelineAsset)GraphicsSettings.renderPipelineAsset;
var resMulti = reflectionBufferScale * GetGlossyScaleValue();
int glossyTextureSize = (int)Mathf.Pow(2, Mathf.RoundToInt(Mathf.Log(currentCamera.pixelWidth * resMulti, 2)));
if (!m_ReflectionBlurTexture)
{
DestroyImmediate(m_ReflectionBlurTexture);
}
if (!m_ReflectionDepthTexture)
{
DestroyImmediate(m_ReflectionDepthTexture);
}
bool useHDR10 = Application.isMobilePlatform &&
SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.ARGB2101010);
RenderTextureFormat hdrFormat = (useHDR10) ? RenderTextureFormat.ARGB2101010 : RenderTextureFormat.DefaultHDR;
if (m_ReflectionBlurTexture)
{
DestroyImmediate(m_ReflectionBlurTexture);
}
m_ReflectionBlurTexture = new RenderTexture(m_TextureSize, m_TextureSize, 16,
currentCamera.allowHDR ? hdrFormat : RenderTextureFormat.Default);
m_ReflectionBlurTexture.useMipMap = m_ReflectionBlurTexture.autoGenerateMips = true;
m_ReflectionBlurTexture.autoGenerateMips = true; // no need for mips(unless wanting cheap roughness)
m_ReflectionBlurTexture.name = "_PlanarReflection blur" + GetInstanceID();
m_ReflectionBlurTexture.isPowerOfTwo = true;
m_ReflectionBlurTexture.hideFlags = HideFlags.DontSave;
m_ReflectionBlurTexture.filterMode = FilterMode.Trilinear;
if (m_ReflectionDepthTexture)
{
DestroyImmediate(m_ReflectionDepthTexture);
}
m_ReflectionDepthTexture = new RenderTexture(m_TextureSize, m_TextureSize, 0, RenderTextureFormat.RHalf);
// m_ReflectionDepthTexture = new RenderTexture(m_TextureSize, m_TextureSize, 0, RenderTextureFormat.R8);
m_ReflectionDepthTexture.name = "__MirrorReflectionDepth" + GetInstanceID();
m_ReflectionDepthTexture.isPowerOfTwo = true;
m_ReflectionDepthTexture.hideFlags = HideFlags.DontSave;
m_ReflectionDepthTexture.filterMode = FilterMode.Bilinear;
Shader.SetGlobalTexture("_PlanarReflectionBlurTexture", m_ReflectionBlurTexture);
Shader.SetGlobalTexture("_PlanarReflectionDepth", m_ReflectionDepthTexture);
}
public ScriptableRenderer(LightweightRenderPipelineAsset pipelineAsset)
{
if (pipelineAsset == null)
{
throw new ArgumentNullException("pipelineAsset");
}
m_Materials = new[]
{
CoreUtils.CreateEngineMaterial("Hidden/InternalErrorShader"),
CoreUtils.CreateEngineMaterial(pipelineAsset.copyDepthShader),
CoreUtils.CreateEngineMaterial(pipelineAsset.samplingShader),
CoreUtils.CreateEngineMaterial(pipelineAsset.blitShader),
CoreUtils.CreateEngineMaterial(pipelineAsset.screenSpaceShadowShader),
};
postProcessingContext = new PostProcessRenderContext();
}
public void CreatePipelineAssetWithoutErrors()
{
// Test without any render pipeline assigned to GraphicsSettings.
var renderPipelineAsset = GraphicsSettings.renderPipelineAsset;
GraphicsSettings.renderPipelineAsset = null;
try
{
LightweightRenderPipelineAsset asset = LightweightRenderPipelineAsset.Create();
LogAssert.NoUnexpectedReceived();
ScriptableObject.DestroyImmediate(asset);
}
// Makes sure the render pipeline is restored in case of a NullReference exception.
finally
{
GraphicsSettings.renderPipelineAsset = renderPipelineAsset;
}
}
public IEnumerator PipelineHasCorrectColorSpace()
{
GameObject go = new GameObject();
Camera camera = go.AddComponent <Camera>();
RenderPipelineAsset prevAsset = GraphicsSettings.renderPipelineAsset;
LightweightRenderPipelineAsset asset = ScriptableObject.CreateInstance <LightweightRenderPipelineAsset>();
GraphicsSettings.renderPipelineAsset = asset;
camera.Render();
yield return(null);
Assert.AreEqual(QualitySettings.activeColorSpace == ColorSpace.Linear, GraphicsSettings.lightsUseLinearIntensity,
"GraphicsSettings.lightsUseLinearIntensity must match active color space.");
GraphicsSettings.renderPipelineAsset = prevAsset;
ScriptableObject.DestroyImmediate(asset);
GameObject.DestroyImmediate(go);
}
private void CreateTextureIfNone(Camera currentCamera)
{
LightweightRenderPipelineAsset lwAsset = (LightweightRenderPipelineAsset)GraphicsSettings.renderPipelineAsset;
var resMulti = lwAsset.renderScale * GetScaleValue();
m_TextureSize = (int)Mathf.Pow(2, Mathf.RoundToInt(Mathf.Log(currentCamera.pixelWidth * resMulti, 2)));
//m_TextureSize.y = (int)Mathf.Pow(2, Mathf.RoundToInt(Mathf.Log(currentCamera.pixelHeight * resMulti, 2)));
// Reflection render texture
//if (Int2Compare(m_TextureSize, m_OldReflectionTextureSize) || !m_ReflectionTexture)
if (!m_ReflectionTexture || m_OldReflectionTextureSize != m_TextureSize)
{
if (m_ReflectionTexture)
{
DestroyImmediate(m_ReflectionTexture);
}
bool useHDR10 = Application.isMobilePlatform &&
SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.ARGB2101010);
RenderTextureFormat hdrFormat = (useHDR10) ? RenderTextureFormat.ARGB2101010 : RenderTextureFormat.DefaultHDR;
m_ReflectionTexture = new RenderTexture(m_TextureSize, m_TextureSize, 16,
currentCamera.allowHDR ? hdrFormat : RenderTextureFormat.Default);
m_ReflectionTexture.useMipMap = m_ReflectionTexture.autoGenerateMips = true;
m_ReflectionTexture.autoGenerateMips = true; // no need for mips(unless wanting cheap roughness)
m_ReflectionTexture.name = "_PlanarReflection" + GetInstanceID();
m_ReflectionTexture.isPowerOfTwo = true;
m_ReflectionTexture.hideFlags = HideFlags.DontSave;
m_ReflectionTexture.filterMode = FilterMode.Trilinear;
m_OldReflectionTextureSize = m_TextureSize;
if (m_settings.m_glossy_enalbe)
{
CreateGlossyTexture(currentCamera, resMulti);
}
else
{
DestroyGlossyBuffers();
}
}
m_ReflectionTexture.DiscardContents();
Shader.SetGlobalTexture("_PlanarReflectionTexture", m_ReflectionTexture);
}
public static void AddProjector(ProjectorForLWRP projector, Camera camera)
{
#if UNITY_EDITOR
// check if the current Forward Renderer has the ProjectorRendererFeature instance.
LightweightRenderPipelineAsset renderPipelineAsset = UnityEngine.Rendering.LWRP.LightweightRenderPipeline.asset;
if (renderPipelineAsset == null)
{
return;
}
UnityEditor.SerializedObject serializedObject = new UnityEditor.SerializedObject(renderPipelineAsset);
UnityEditor.SerializedProperty rendererDataProperty = serializedObject.FindProperty("m_RendererData");
UnityEngine.Rendering.LWRP.ScriptableRendererData rendererData = rendererDataProperty.objectReferenceValue as UnityEngine.Rendering.LWRP.ScriptableRendererData;
if (rendererData == null)
{
Debug.LogError("The current Lightweight Render Pipeline Asset does not have Forward Renderer Data! Please set a Forward Renderer Data which contains ProjectorRendererFeature to the current render pipeline asset.", renderPipelineAsset);
}
else
{
bool found = false;
foreach (var rendererFeature in rendererData.rendererFeatures)
{
if (rendererFeature is ProjectorRendererFeature)
{
found = true;
break;
}
}
if (!found)
{
Debug.LogError("ProjectorRendererFeature is not added to the current Forward Renderer Data.", rendererData);
}
}
#endif
if (s_projectorPasses == null)
{
#if UNITY_EDITOR
Debug.LogError("No ProjectorRendererFeature instances are created!");
#endif
return;
}
AddProjectorInternal(projector, camera);
}
public void ValidateNewAssetResources()
{
LightweightRenderPipelineAsset asset = LightweightRenderPipelineAsset.Create();
Assert.AreNotEqual(asset.defaultMaterial, null);
Assert.AreNotEqual(asset.defaultParticleMaterial, null);
Assert.AreNotEqual(asset.defaultLineMaterial, null);
Assert.AreNotEqual(asset.defaultTerrainMaterial, null);
Assert.AreNotEqual(asset.defaultShader, null);
// LWRP doesn't override the following materials
Assert.AreEqual(asset.defaultUIMaterial, null);
Assert.AreEqual(asset.defaultUIOverdrawMaterial, null);
Assert.AreEqual(asset.defaultUIETC1SupportedMaterial, null);
Assert.AreEqual(asset.default2DMaterial, null);
Assert.AreNotEqual(asset.m_EditorResourcesAsset, null, "Editor Resources should be initialized when creating a new pipeline.");
Assert.AreNotEqual(asset.m_RendererData, null, "A default renderer data should be created when creating a new pipeline.");
ScriptableObject.DestroyImmediate(asset);
}
private static bool IsLightweightRenderPipelineSetupCorrectly()
{
if (s_pipelineSetupOk)
{
return(true);
}
// check if the current Forward Renderer has the ProjectorRendererFeature instance.
LightweightRenderPipelineAsset renderPipelineAsset = LightweightRenderPipeline.asset;
if (renderPipelineAsset == null)
{
return(false);
}
UnityEditor.SerializedObject serializedObject = new UnityEditor.SerializedObject(renderPipelineAsset);
UnityEditor.SerializedProperty rendererDataProperty = serializedObject.FindProperty("m_RendererData");
ScriptableRendererData rendererData = rendererDataProperty.objectReferenceValue as ScriptableRendererData;
if (rendererData == null)
{
Debug.LogError("The current Lightweight Render Pipeline Asset does not have Forward Renderer Data! Please set a Forward Renderer Data which contains ProjectorRendererFeature to the current render pipeline asset.", renderPipelineAsset);
}
else
{
bool found = false;
foreach (var rendererFeature in rendererData.rendererFeatures)
{
if (rendererFeature is ProjectorRendererFeature)
{
found = true;
break;
}
}
if (!found)
{
Debug.LogError("ProjectorRendererFeature is not added to the current Forward Renderer Data.", rendererData);
return(false);
}
}
s_pipelineSetupOk = true;
return(true);
}
ShaderFeatures GetSupportedShaderFeatures(LightweightRenderPipelineAsset pipelineAsset)
{
ShaderFeatures shaderFeatures;
shaderFeatures = ShaderFeatures.MainLight;
if (pipelineAsset.supportsMainLightShadows)
{
shaderFeatures |= ShaderFeatures.MainLightShadows;
}
if (pipelineAsset.additionalLightsRenderingMode == LightRenderingMode.PerVertex)
{
shaderFeatures |= ShaderFeatures.AdditionalLights;
shaderFeatures |= ShaderFeatures.VertexLighting;
}
else if (pipelineAsset.additionalLightsRenderingMode == LightRenderingMode.PerPixel)
{
shaderFeatures |= ShaderFeatures.AdditionalLights;
if (pipelineAsset.supportsAdditionalLightShadows)
{
shaderFeatures |= ShaderFeatures.AdditionalLightShadows;
}
}
bool anyShadows = pipelineAsset.supportsMainLightShadows ||
CoreUtils.HasFlag(shaderFeatures, ShaderFeatures.AdditionalLightShadows);
if (pipelineAsset.supportsSoftShadows && anyShadows)
{
shaderFeatures |= ShaderFeatures.SoftShadows;
}
if (pipelineAsset.supportsMixedLighting)
{
shaderFeatures |= ShaderFeatures.MixedLighting;
}
return(shaderFeatures);
}
