// Update is called once per frame
void Update()
{
if (Input.GetKeyUp(KeyCode.Space))
{
m_bLightning = !m_bLightning;
ScreenSpaceAmbientOcclusion aoFilter = CameraPivot.GetComponentInChildren <ScreenSpaceAmbientOcclusion>();
if (aoFilter)
{
aoFilter.enabled = this.m_bLightning;
}
}
if (Input.GetKeyUp(KeyCode.Z))
{
m_bZoomed = !m_bZoomed;
if (m_bZoomed)
{
Camera.transform.position = Camera.transform.position + Camera.transform.forward * 2f;
}
else
{
Camera.transform.position = Camera.transform.position - Camera.transform.forward * 2f;
}
}
if (Input.GetKeyUp(KeyCode.A))
{
int iAnim = (m_iDefaultAnim++) % 3;
foreach (Animator anim in CharacterAnim)
{
anim.SetInteger("Animation", iAnim);
}
}
Vector3 positionToReach = m_bLightning ? LightningPivot.position : ToonPivot.position;
if (Vector3.Distance(CameraPivot.transform.position, positionToReach) < .01f) // Camera reach position
{
CameraPivot.transform.position = positionToReach;
}
else
{
CameraPivot.transform.position = Vector3.Lerp(CameraPivot.transform.position, positionToReach, Time.deltaTime * 2f);
}
if (Input.GetKeyUp(KeyCode.S))
{
for (int i = 0; i < Princesses.Length; i++)
{
Princesses[i].Activate(i == m_iPrincess);
}
m_iPrincess = (m_iPrincess + 1) % Princesses.Length;
}
if (Input.GetKeyUp(KeyCode.Escape))
{
Application.Quit();
}
}
private bool RendererIsDeferred()
{
ScreenSpaceAmbientOcclusion ssaoFeature = (ScreenSpaceAmbientOcclusion)this.target;
UniversalRenderPipelineAsset pipelineAsset = (UniversalRenderPipelineAsset)GraphicsSettings.renderPipelineAsset;
if (ssaoFeature == null || pipelineAsset == null)
{
return(false);
}
// We have to find the renderer related to the SSAO feature, then test if it is in deferred mode.
var rendererDataList = pipelineAsset.m_RendererDataList;
for (int rendererIndex = 0; rendererIndex < rendererDataList.Length; ++rendererIndex)
{
ScriptableRendererData rendererData = (ScriptableRendererData)rendererDataList[rendererIndex];
if (rendererData == null)
{
continue;
}
var rendererFeatures = rendererData.rendererFeatures;
foreach (var feature in rendererFeatures)
{
if (feature is ScreenSpaceAmbientOcclusion && (ScreenSpaceAmbientOcclusion)feature == ssaoFeature)
{
return(rendererData is UniversalRendererData && ((UniversalRendererData)rendererData).renderingMode == RenderingMode.Deferred);
}
}
}
return(false);
}
// Use this for initialization
void Start () {
noiseAndGrain = GetComponent<NoiseAndGrain>();
occlusion = GetComponent<ScreenSpaceAmbientOcclusion>();
bloom = GetComponent<BloomOptimized>();
qualityChanges();
}
// Use this for initialization
void Start()
{
noiseAndGrain = GetComponent <NoiseAndGrain>();
occlusion = GetComponent <ScreenSpaceAmbientOcclusion>();
bloom = GetComponent <BloomOptimized>();
qualityChanges();
}
void Awake()
{
m_Bloom = Camera.main.GetComponent <BloomOptimized>();
m_Depth = Camera.main.GetComponent <DepthOfField>();
m_SSAO = Camera.main.GetComponent <ScreenSpaceAmbientOcclusion>();
m_SunShafts = Camera.main.GetComponent <SunShafts>();
m_CCC = Camera.main.GetComponent <ColorCorrectionCurves>();
}
public void DisableSSAO()
{
ScreenSpaceAmbientOcclusion ssao = HeadCamera.GetComponent <ScreenSpaceAmbientOcclusion>();
if (ssao != null)
{
ssao.enabled = false;
}
}
// Use this for initialization
void Start()
{
_SSAO = GetComponent <ScreenSpaceAmbientOcclusion> ();
PlayerPrefs.SetInt("SSAO", 0);
_CE = GetComponent <ContrastEnhance> ();
PlayerPrefs.SetInt("CE", 0);
_Bloom = GetComponent <BloomOptimized> ();
PlayerPrefs.SetInt("Bloom", 0);
_Vignette = GetComponent <VignetteAndChromaticAberration> ();
PlayerPrefs.SetInt("Vignette", 0);
}
private void Start()
{
musicManager = GameObject.FindObjectOfType <MusicManager>();
soundFXManager = GameObject.FindObjectOfType <SoundFXManager>();
motionBlur = camera.GetComponent <MotionBlur>();
depthOfField = camera.GetComponent <DepthOfField>();
SSAO = camera.GetComponent <ScreenSpaceAmbientOcclusion>();
noiseAndGrain = camera.GetComponent <NoiseAndGrain>();
bloom = camera.GetComponent <Bloom>();
antiAliasing = camera.GetComponent <Antialiasing>();
fpsCap = GameObject.FindObjectOfType <FPS_Cap>();
musicScrollbar.value = PlayerPrefsManager.GetMusicVolume();
soundFXScrollbar.value = PlayerPrefsManager.GetSoundFXVolume();
motionBlurScrollbar.value = PlayerPrefsManager.GetMotionBlur();
depthOfFieldScrollbar.value = PlayerPrefsManager.GetDepthOfField();
SSAOScrollbar.value = PlayerPrefsManager.GetSSAO();
noiseAndGrainToggle.isOn = PlayerPrefsManager.GetNoiseAndGrain();
bloomToggle.isOn = PlayerPrefsManager.GetBloom();
antiAliasingDropdown.value = PlayerPrefsManager.GetAntiAliasing();
targetFrameRateDropdown.value = PlayerPrefsManager.GetTargetFramerate();
}
private static ShaderFeatures GetSupportedShaderFeatures(UniversalRenderPipelineAsset pipelineAsset)
{
ShaderFeatures shaderFeatures;
shaderFeatures = ShaderFeatures.MainLight;
if (pipelineAsset.supportsMainLightShadows)
{
shaderFeatures |= ShaderFeatures.MainLightShadows;
}
if (pipelineAsset.additionalLightsRenderingMode == LightRenderingMode.PerVertex)
{
shaderFeatures |= ShaderFeatures.VertexLighting;
}
else if (pipelineAsset.additionalLightsRenderingMode == LightRenderingMode.PerPixel)
{
shaderFeatures |= ShaderFeatures.AdditionalLights;
if (pipelineAsset.supportsAdditionalLightShadows)
{
shaderFeatures |= ShaderFeatures.AdditionalLightShadows;
}
}
bool anyShadows = pipelineAsset.supportsMainLightShadows ||
(shaderFeatures & ShaderFeatures.AdditionalLightShadows) != 0;
if (pipelineAsset.supportsSoftShadows && anyShadows)
{
shaderFeatures |= ShaderFeatures.SoftShadows;
}
if (pipelineAsset.supportsMixedLighting)
{
shaderFeatures |= ShaderFeatures.MixedLighting;
}
if (pipelineAsset.supportsTerrainHoles)
{
shaderFeatures |= ShaderFeatures.TerrainHoles;
}
if (pipelineAsset.useFastSRGBLinearConversion)
{
shaderFeatures |= ShaderFeatures.UseFastSRGBLinearConversion;
}
if (pipelineAsset.supportsLightLayers)
{
shaderFeatures |= ShaderFeatures.LightLayers;
}
bool hasScreenSpaceShadows = false;
bool hasScreenSpaceOcclusion = false;
bool hasDeferredRenderer = false;
bool withAccurateGbufferNormals = false;
bool withoutAccurateGbufferNormals = false;
int rendererCount = pipelineAsset.m_RendererDataList.Length;
for (int rendererIndex = 0; rendererIndex < rendererCount; ++rendererIndex)
{
ScriptableRenderer renderer = pipelineAsset.GetRenderer(rendererIndex);
if (renderer is UniversalRenderer)
{
UniversalRenderer universalRenderer = (UniversalRenderer)renderer;
if (universalRenderer.renderingMode == RenderingMode.Deferred)
{
hasDeferredRenderer |= true;
withAccurateGbufferNormals |= universalRenderer.accurateGbufferNormals;
withoutAccurateGbufferNormals |= !universalRenderer.accurateGbufferNormals;
}
}
// Check for Screen Space Ambient Occlusion Renderer Feature
ScriptableRendererData rendererData = pipelineAsset.m_RendererDataList[rendererIndex];
if (rendererData != null)
{
for (int rendererFeatureIndex = 0; rendererFeatureIndex < rendererData.rendererFeatures.Count; rendererFeatureIndex++)
{
ScriptableRendererFeature rendererFeature = rendererData.rendererFeatures[rendererFeatureIndex];
ScreenSpaceShadows ssshadows = rendererFeature as ScreenSpaceShadows;
hasScreenSpaceShadows |= ssshadows != null;
ScreenSpaceAmbientOcclusion ssao = rendererFeature as ScreenSpaceAmbientOcclusion;
hasScreenSpaceOcclusion |= ssao != null;
}
}
}
if (hasDeferredRenderer)
{
shaderFeatures |= ShaderFeatures.DeferredShading;
}
// We can only strip accurateGbufferNormals related variants if all DeferredRenderers use the same option.
if (withAccurateGbufferNormals)
{
shaderFeatures |= ShaderFeatures.DeferredWithAccurateGbufferNormals;
}
if (withoutAccurateGbufferNormals)
{
shaderFeatures |= ShaderFeatures.DeferredWithoutAccurateGbufferNormals;
}
if (hasScreenSpaceShadows)
{
shaderFeatures |= ShaderFeatures.ScreenSpaceShadows;
}
if (hasScreenSpaceOcclusion)
{
shaderFeatures |= ShaderFeatures.ScreenSpaceOcclusion;
}
return(shaderFeatures);
}
private static ShaderFeatures GetSupportedShaderFeatures(UniversalRenderPipelineAsset pipelineAsset)
{
ShaderFeatures shaderFeatures;
shaderFeatures = ShaderFeatures.MainLight;
if (pipelineAsset.supportsMainLightShadows)
{
shaderFeatures |= ShaderFeatures.MainLightShadows;
}
if (pipelineAsset.additionalLightsRenderingMode == LightRenderingMode.PerVertex)
{
shaderFeatures |= ShaderFeatures.VertexLighting;
}
else if (pipelineAsset.additionalLightsRenderingMode == LightRenderingMode.PerPixel)
{
shaderFeatures |= ShaderFeatures.AdditionalLights;
}
bool anyShadows = pipelineAsset.supportsMainLightShadows ||
(shaderFeatures & ShaderFeatures.AdditionalLightShadows) != 0;
if (pipelineAsset.supportsSoftShadows && anyShadows)
{
shaderFeatures |= ShaderFeatures.SoftShadows;
}
if (pipelineAsset.supportsMixedLighting)
{
shaderFeatures |= ShaderFeatures.MixedLighting;
}
if (pipelineAsset.supportsTerrainHoles)
{
shaderFeatures |= ShaderFeatures.TerrainHoles;
}
if (pipelineAsset.useFastSRGBLinearConversion)
{
shaderFeatures |= ShaderFeatures.UseFastSRGBLinearConversion;
}
if (pipelineAsset.supportsLightLayers)
{
shaderFeatures |= ShaderFeatures.LightLayers;
}
bool hasScreenSpaceShadows = false;
bool hasScreenSpaceOcclusion = false;
bool hasDeferredRenderer = false;
bool withAccurateGbufferNormals = false;
bool withoutAccurateGbufferNormals = false;
bool clusteredRendering = false;
bool onlyClusteredRendering = false;
bool usesRenderPass = false;
int rendererCount = pipelineAsset.m_RendererDataList.Length;
for (int rendererIndex = 0; rendererIndex < rendererCount; ++rendererIndex)
{
ScriptableRenderer renderer = pipelineAsset.GetRenderer(rendererIndex);
if (renderer is UniversalRenderer)
{
UniversalRenderer universalRenderer = (UniversalRenderer)renderer;
if (universalRenderer.renderingMode == RenderingMode.Deferred)
{
hasDeferredRenderer |= true;
withAccurateGbufferNormals |= universalRenderer.accurateGbufferNormals;
withoutAccurateGbufferNormals |= !universalRenderer.accurateGbufferNormals;
usesRenderPass |= universalRenderer.useRenderPassEnabled;
}
}
var rendererClustered = false;
ScriptableRendererData rendererData = pipelineAsset.m_RendererDataList[rendererIndex];
if (rendererData != null)
{
for (int rendererFeatureIndex = 0; rendererFeatureIndex < rendererData.rendererFeatures.Count; rendererFeatureIndex++)
{
ScriptableRendererFeature rendererFeature = rendererData.rendererFeatures[rendererFeatureIndex];
ScreenSpaceShadows ssshadows = rendererFeature as ScreenSpaceShadows;
hasScreenSpaceShadows |= ssshadows != null;
// Check for Screen Space Ambient Occlusion Renderer Feature
ScreenSpaceAmbientOcclusion ssao = rendererFeature as ScreenSpaceAmbientOcclusion;
hasScreenSpaceOcclusion |= ssao != null;
// Check for Decal Renderer Feature
DecalRendererFeature decal = rendererFeature as DecalRendererFeature;
if (decal != null)
{
var technique = decal.GetTechnique(renderer);
switch (technique)
{
case DecalTechnique.DBuffer:
shaderFeatures |= GetFromDecalSurfaceData(decal.GetDBufferSettings().surfaceData);
break;
case DecalTechnique.ScreenSpace:
shaderFeatures |= GetFromNormalBlend(decal.GetScreenSpaceSettings().normalBlend);
shaderFeatures |= ShaderFeatures.DecalScreenSpace;
break;
case DecalTechnique.GBuffer:
shaderFeatures |= GetFromNormalBlend(decal.GetScreenSpaceSettings().normalBlend);
shaderFeatures |= ShaderFeatures.DecalGBuffer;
break;
}
}
}
if (rendererData is UniversalRendererData universalRendererData)
{
rendererClustered = universalRendererData.renderingMode == RenderingMode.Forward &&
universalRendererData.clusteredRendering;
}
}
clusteredRendering |= rendererClustered;
onlyClusteredRendering &= rendererClustered;
}
if (hasDeferredRenderer)
{
shaderFeatures |= ShaderFeatures.DeferredShading;
}
// We can only strip accurateGbufferNormals related variants if all DeferredRenderers use the same option.
if (withAccurateGbufferNormals)
{
shaderFeatures |= ShaderFeatures.DeferredWithAccurateGbufferNormals;
}
if (withoutAccurateGbufferNormals)
{
shaderFeatures |= ShaderFeatures.DeferredWithoutAccurateGbufferNormals;
}
if (hasScreenSpaceShadows)
{
shaderFeatures |= ShaderFeatures.ScreenSpaceShadows;
}
if (hasScreenSpaceOcclusion)
{
shaderFeatures |= ShaderFeatures.ScreenSpaceOcclusion;
}
if (usesRenderPass)
{
shaderFeatures |= ShaderFeatures.RenderPassEnabled;
}
if (pipelineAsset.reflectionProbeBlending)
{
shaderFeatures |= ShaderFeatures.ReflectionProbeBlending;
}
if (pipelineAsset.reflectionProbeBoxProjection)
{
shaderFeatures |= ShaderFeatures.ReflectionProbeBoxProjection;
}
if (clusteredRendering)
{
shaderFeatures |= ShaderFeatures.ClusteredRendering;
}
if (onlyClusteredRendering)
{
shaderFeatures &= ~(ShaderFeatures.AdditionalLights | ShaderFeatures.VertexLighting);
}
if (pipelineAsset.additionalLightsRenderingMode == LightRenderingMode.PerPixel || clusteredRendering)
{
if (pipelineAsset.supportsAdditionalLightShadows)
{
shaderFeatures |= ShaderFeatures.AdditionalLightShadows;
}
}
return(shaderFeatures);
}
// Use this for initialization
void Start()
{
ssao = GetComponent <ScreenSpaceAmbientOcclusion>();
}
// Use this for initialization
void Start()
{
effect = GetComponentInChildren <ScreenSpaceAmbientOcclusion>();
maxEffect = effect.m_OcclusionIntensity;
}
public override void Start()
{
bloom = gameObject.GetComponent <BloomOptimized>();
dof = gameObject.GetComponent <DepthOfField>();
ssao = gameObject.GetComponent <ScreenSpaceAmbientOcclusion>();
}
