using System;
using UnityEngine;
using UnityEngine.Rendering;

namespace UnityStandardAssets.CinematicEffects
{
	// Token: 0x02000015 RID: 21
	[ExecuteInEditMode]
	[RequireComponent(typeof(Camera))]
	[AddComponentMenu("Image Effects/Cinematic/Ambient Occlusion")]
	[ImageEffectAllowedInSceneView]
	public class AmbientOcclusion : MonoBehaviour
	{
		// Token: 0x17000013 RID: 19
		// (get) Token: 0x06000036 RID: 54 RVA: 0x00002F05 File Offset: 0x00001305
		public bool isAmbientOnlySupported
		{
			get
			{
				return this.targetCamera.allowHDR && this.occlusionSource == AmbientOcclusion.OcclusionSource.GBuffer;
			}
		}

		// Token: 0x17000014 RID: 20
		// (get) Token: 0x06000037 RID: 55 RVA: 0x00002F23 File Offset: 0x00001323
		public bool isGBufferAvailable
		{
			get
			{
				return this.targetCamera.actualRenderingPath == RenderingPath.DeferredShading;
			}
		}

		// Token: 0x17000015 RID: 21
		// (get) Token: 0x06000038 RID: 56 RVA: 0x00002F33 File Offset: 0x00001333
		private float intensity
		{
			get
			{
				return this.settings.intensity;
			}
		}

		// Token: 0x17000016 RID: 22
		// (get) Token: 0x06000039 RID: 57 RVA: 0x00002F40 File Offset: 0x00001340
		private float radius
		{
			get
			{
				return Mathf.Max(this.settings.radius, 0.0001f);
			}
		}

		// Token: 0x17000017 RID: 23
		// (get) Token: 0x0600003A RID: 58 RVA: 0x00002F57 File Offset: 0x00001357
		private AmbientOcclusion.SampleCount sampleCount
		{
			get
			{
				return this.settings.sampleCount;
			}
		}

		// Token: 0x17000018 RID: 24
		// (get) Token: 0x0600003B RID: 59 RVA: 0x00002F64 File Offset: 0x00001364
		private int sampleCountValue
		{
			get
			{
				switch (this.settings.sampleCount)
				{
				case AmbientOcclusion.SampleCount.Lowest:
					return 3;
				case AmbientOcclusion.SampleCount.Low:
					return 6;
				case AmbientOcclusion.SampleCount.Medium:
					return 12;
				case AmbientOcclusion.SampleCount.High:
					return 20;
				default:
					return Mathf.Clamp(this.settings.sampleCountValue, 1, 256);
				}
			}
		}

		// Token: 0x17000019 RID: 25
		// (get) Token: 0x0600003C RID: 60 RVA: 0x00002FB8 File Offset: 0x000013B8
		private AmbientOcclusion.OcclusionSource occlusionSource
		{
			get
			{
				if (this.settings.occlusionSource == AmbientOcclusion.OcclusionSource.GBuffer && !this.isGBufferAvailable)
				{
					return AmbientOcclusion.OcclusionSource.DepthNormalsTexture;
				}
				return this.settings.occlusionSource;
			}
		}

		// Token: 0x1700001A RID: 26
		// (get) Token: 0x0600003D RID: 61 RVA: 0x00002FE3 File Offset: 0x000013E3
		private bool downsampling
		{
			get
			{
				return this.settings.downsampling;
			}
		}

		// Token: 0x1700001B RID: 27
		// (get) Token: 0x0600003E RID: 62 RVA: 0x00002FF0 File Offset: 0x000013F0
		private bool ambientOnly
		{
			get
			{
				return this.settings.ambientOnly && this.isAmbientOnlySupported;
			}
		}

		// Token: 0x1700001C RID: 28
		// (get) Token: 0x0600003F RID: 63 RVA: 0x0000300B File Offset: 0x0000140B
		private Shader aoShader
		{
			get
			{
				if (this._aoShader == null)
				{
					this._aoShader = Shader.Find("Hidden/Image Effects/Cinematic/AmbientOcclusion");
				}
				return this._aoShader;
			}
		}

		// Token: 0x1700001D RID: 29
		// (get) Token: 0x06000040 RID: 64 RVA: 0x00003034 File Offset: 0x00001434
		private Material aoMaterial
		{
			get
			{
				if (this._aoMaterial == null)
				{
					this._aoMaterial = ImageEffectHelper.CheckShaderAndCreateMaterial(this.aoShader);
				}
				return this._aoMaterial;
			}
		}

		// Token: 0x1700001E RID: 30
		// (get) Token: 0x06000041 RID: 65 RVA: 0x0000305E File Offset: 0x0000145E
		private CommandBuffer aoCommands
		{
			get
			{
				if (this._aoCommands == null)
				{
					this._aoCommands = new CommandBuffer();
					this._aoCommands.name = "AmbientOcclusion";
				}
				return this._aoCommands;
			}
		}

		// Token: 0x1700001F RID: 31
		// (get) Token: 0x06000042 RID: 66 RVA: 0x0000308C File Offset: 0x0000148C
		private Camera targetCamera
		{
			get
			{
				return base.GetComponent<Camera>();
			}
		}

		// Token: 0x17000020 RID: 32
		// (get) Token: 0x06000043 RID: 67 RVA: 0x00003094 File Offset: 0x00001494
		// (set) Token: 0x06000044 RID: 68 RVA: 0x0000309C File Offset: 0x0000149C
		private AmbientOcclusion.PropertyObserver propertyObserver { get; set; }

		// Token: 0x17000021 RID: 33
		// (get) Token: 0x06000045 RID: 69 RVA: 0x000030A5 File Offset: 0x000014A5
		private Mesh quadMesh
		{
			get
			{
				return this._quadMesh;
			}
		}

		// Token: 0x06000046 RID: 70 RVA: 0x000030B0 File Offset: 0x000014B0
		private void BuildAOCommands()
		{
			CommandBuffer aoCommands = this.aoCommands;
			int pixelWidth = this.targetCamera.pixelWidth;
			int pixelHeight = this.targetCamera.pixelHeight;
			int num = ((!this.downsampling) ? 1 : 2);
			RenderTextureFormat renderTextureFormat = RenderTextureFormat.R8;
			RenderTextureReadWrite renderTextureReadWrite = RenderTextureReadWrite.Linear;
			FilterMode filterMode = FilterMode.Bilinear;
			Material aoMaterial = this.aoMaterial;
			int num2 = Shader.PropertyToID("_OcclusionTexture");
			aoCommands.GetTemporaryRT(num2, pixelWidth / num, pixelHeight / num, 0, filterMode, renderTextureFormat, renderTextureReadWrite);
			aoCommands.Blit(null, num2, aoMaterial, 0);
			int num3 = Shader.PropertyToID("_OcclusionBlurTexture");
			aoCommands.GetTemporaryRT(num3, pixelWidth, pixelHeight, 0, filterMode, renderTextureFormat, renderTextureReadWrite);
			aoCommands.SetGlobalVector("_BlurVector", Vector2.right * 2f);
			aoCommands.Blit(num2, num3, aoMaterial, 1);
			aoCommands.ReleaseTemporaryRT(num2);
			aoCommands.GetTemporaryRT(num2, pixelWidth, pixelHeight, 0, filterMode, renderTextureFormat, renderTextureReadWrite);
			aoCommands.SetGlobalVector("_BlurVector", Vector2.up * 2f * (float)num);
			aoCommands.Blit(num3, num2, aoMaterial, 1);
			aoCommands.ReleaseTemporaryRT(num3);
			aoCommands.GetTemporaryRT(num3, pixelWidth, pixelHeight, 0, filterMode, renderTextureFormat, renderTextureReadWrite);
			aoCommands.SetGlobalVector("_BlurVector", Vector2.right * (float)num);
			aoCommands.Blit(num2, num3, aoMaterial, 2);
			aoCommands.ReleaseTemporaryRT(num2);
			aoCommands.GetTemporaryRT(num2, pixelWidth, pixelHeight, 0, filterMode, renderTextureFormat, renderTextureReadWrite);
			aoCommands.SetGlobalVector("_BlurVector", Vector2.up * (float)num);
			aoCommands.Blit(num3, num2, aoMaterial, 2);
			aoCommands.ReleaseTemporaryRT(num3);
			RenderTargetIdentifier[] array = new RenderTargetIdentifier[]
			{
				BuiltinRenderTextureType.GBuffer0,
				BuiltinRenderTextureType.CameraTarget
			};
			aoCommands.SetRenderTarget(array, BuiltinRenderTextureType.CameraTarget);
			aoCommands.SetGlobalTexture("_OcclusionTexture", num2);
			aoCommands.DrawMesh(this.quadMesh, Matrix4x4.identity, aoMaterial, 0, 4);
			aoCommands.ReleaseTemporaryRT(num2);
		}

		// Token: 0x06000047 RID: 71 RVA: 0x000032E8 File Offset: 0x000016E8
		private void ExecuteAOPass(RenderTexture source, RenderTexture destination)
		{
			int width = source.width;
			int height = source.height;
			int num = ((!this.downsampling) ? 1 : 2);
			RenderTextureFormat renderTextureFormat = RenderTextureFormat.R8;
			RenderTextureReadWrite renderTextureReadWrite = RenderTextureReadWrite.Linear;
			Material aoMaterial = this.aoMaterial;
			RenderTexture renderTexture = RenderTexture.GetTemporary(width / num, height / num, 0, renderTextureFormat, renderTextureReadWrite);
			Graphics.Blit(null, renderTexture, aoMaterial, 0);
			RenderTexture renderTexture2 = RenderTexture.GetTemporary(width, height, 0, renderTextureFormat, renderTextureReadWrite);
			aoMaterial.SetVector("_BlurVector", Vector2.right * 2f);
			Graphics.Blit(renderTexture, renderTexture2, aoMaterial, 1);
			RenderTexture.ReleaseTemporary(renderTexture);
			renderTexture = RenderTexture.GetTemporary(width, height, 0, renderTextureFormat, renderTextureReadWrite);
			aoMaterial.SetVector("_BlurVector", Vector2.up * 2f * (float)num);
			Graphics.Blit(renderTexture2, renderTexture, aoMaterial, 1);
			RenderTexture.ReleaseTemporary(renderTexture2);
			renderTexture2 = RenderTexture.GetTemporary(width, height, 0, renderTextureFormat, renderTextureReadWrite);
			aoMaterial.SetVector("_BlurVector", Vector2.right * (float)num);
			Graphics.Blit(renderTexture, renderTexture2, aoMaterial, 2);
			RenderTexture.ReleaseTemporary(renderTexture);
			renderTexture = RenderTexture.GetTemporary(width, height, 0, renderTextureFormat, renderTextureReadWrite);
			aoMaterial.SetVector("_BlurVector", Vector2.up * (float)num);
			Graphics.Blit(renderTexture2, renderTexture, aoMaterial, 2);
			RenderTexture.ReleaseTemporary(renderTexture2);
			aoMaterial.SetTexture("_OcclusionTexture", renderTexture);
			if (!this.settings.debug)
			{
				Graphics.Blit(source, destination, aoMaterial, 3);
			}
			else
			{
				Graphics.Blit(source, destination, aoMaterial, 5);
			}
			RenderTexture.ReleaseTemporary(renderTexture);
		}

		// Token: 0x06000048 RID: 72 RVA: 0x00003480 File Offset: 0x00001880
		private void UpdateMaterialProperties()
		{
			Material aoMaterial = this.aoMaterial;
			aoMaterial.shaderKeywords = null;
			aoMaterial.SetFloat("_Intensity", this.intensity);
			aoMaterial.SetFloat("_Radius", this.radius);
			aoMaterial.SetFloat("_TargetScale", (!this.downsampling) ? 1f : 0.5f);
			if (this.occlusionSource == AmbientOcclusion.OcclusionSource.GBuffer)
			{
				aoMaterial.EnableKeyword("_SOURCE_GBUFFER");
			}
			else if (this.occlusionSource == AmbientOcclusion.OcclusionSource.DepthTexture)
			{
				aoMaterial.EnableKeyword("_SOURCE_DEPTH");
			}
			else
			{
				aoMaterial.EnableKeyword("_SOURCE_DEPTHNORMALS");
			}
			if (this.sampleCount == AmbientOcclusion.SampleCount.Lowest)
			{
				aoMaterial.EnableKeyword("_SAMPLECOUNT_LOWEST");
			}
			else
			{
				aoMaterial.SetInt("_SampleCount", this.sampleCountValue);
			}
		}

		// Token: 0x06000049 RID: 73 RVA: 0x00003550 File Offset: 0x00001950
		private void OnEnable()
		{
			if (!ImageEffectHelper.IsSupported(this.aoShader, true, false, this))
			{
				base.enabled = false;
				return;
			}
			if (this.ambientOnly)
			{
				this.targetCamera.AddCommandBuffer(CameraEvent.BeforeReflections, this.aoCommands);
			}
			if (this.occlusionSource == AmbientOcclusion.OcclusionSource.DepthTexture)
			{
				this.targetCamera.depthTextureMode |= DepthTextureMode.Depth;
			}
			if (this.occlusionSource != AmbientOcclusion.OcclusionSource.GBuffer)
			{
				this.targetCamera.depthTextureMode |= DepthTextureMode.DepthNormals;
			}
		}

		// Token: 0x0600004A RID: 74 RVA: 0x000035D4 File Offset: 0x000019D4
		private void OnDisable()
		{
			if (this._aoMaterial != null)
			{
				global::UnityEngine.Object.DestroyImmediate(this._aoMaterial);
			}
			this._aoMaterial = null;
			if (this._aoCommands != null)
			{
				this.targetCamera.RemoveCommandBuffer(CameraEvent.BeforeReflections, this._aoCommands);
			}
			this._aoCommands = null;
		}

		// Token: 0x0600004B RID: 75 RVA: 0x0000362C File Offset: 0x00001A2C
		private void Update()
		{
			if (this.propertyObserver.CheckNeedsReset(this.settings, this.targetCamera))
			{
				this.OnDisable();
				this.OnEnable();
				if (this.ambientOnly)
				{
					this.aoCommands.Clear();
					this.BuildAOCommands();
				}
				this.propertyObserver.Update(this.settings, this.targetCamera);
			}
			if (this.ambientOnly)
			{
				this.UpdateMaterialProperties();
			}
		}

		// Token: 0x0600004C RID: 76 RVA: 0x000036AB File Offset: 0x00001AAB
		[ImageEffectOpaque]
		private void OnRenderImage(RenderTexture source, RenderTexture destination)
		{
			if (this.ambientOnly)
			{
				Graphics.Blit(source, destination);
			}
			else
			{
				this.UpdateMaterialProperties();
				this.ExecuteAOPass(source, destination);
			}
		}

		// Token: 0x04000048 RID: 72
		[SerializeField]
		public AmbientOcclusion.Settings settings = AmbientOcclusion.Settings.defaultSettings;

		// Token: 0x04000049 RID: 73
		[SerializeField]
		private Shader _aoShader;

		// Token: 0x0400004A RID: 74
		private Material _aoMaterial;

		// Token: 0x0400004B RID: 75
		private CommandBuffer _aoCommands;

		// Token: 0x0400004D RID: 77
		[SerializeField]
		private Mesh _quadMesh;

		// Token: 0x02000016 RID: 22
		private struct PropertyObserver
		{
			// Token: 0x0600004D RID: 77 RVA: 0x000036D4 File Offset: 0x00001AD4
			public bool CheckNeedsReset(AmbientOcclusion.Settings setting, Camera camera)
			{
				return this._downsampling != setting.downsampling || this._occlusionSource != setting.occlusionSource || this._ambientOnly != setting.ambientOnly || this._pixelWidth != camera.pixelWidth || this._pixelHeight != camera.pixelHeight;
			}

			// Token: 0x0600004E RID: 78 RVA: 0x00003739 File Offset: 0x00001B39
			public void Update(AmbientOcclusion.Settings setting, Camera camera)
			{
				this._downsampling = setting.downsampling;
				this._occlusionSource = setting.occlusionSource;
				this._ambientOnly = setting.ambientOnly;
				this._pixelWidth = camera.pixelWidth;
				this._pixelHeight = camera.pixelHeight;
			}

			// Token: 0x0400004E RID: 78
			private bool _downsampling;

			// Token: 0x0400004F RID: 79
			private AmbientOcclusion.OcclusionSource _occlusionSource;

			// Token: 0x04000050 RID: 80
			private bool _ambientOnly;

			// Token: 0x04000051 RID: 81
			private int _pixelWidth;

			// Token: 0x04000052 RID: 82
			private int _pixelHeight;
		}

		// Token: 0x02000017 RID: 23
		public enum SampleCount
		{
			// Token: 0x04000054 RID: 84
			Lowest,
			// Token: 0x04000055 RID: 85
			Low,
			// Token: 0x04000056 RID: 86
			Medium,
			// Token: 0x04000057 RID: 87
			High,
			// Token: 0x04000058 RID: 88
			Variable
		}

		// Token: 0x02000018 RID: 24
		public enum OcclusionSource
		{
			// Token: 0x0400005A RID: 90
			DepthTexture,
			// Token: 0x0400005B RID: 91
			DepthNormalsTexture,
			// Token: 0x0400005C RID: 92
			GBuffer
		}

		// Token: 0x02000019 RID: 25
		[Serializable]
		public class Settings
		{
			// Token: 0x17000022 RID: 34
			// (get) Token: 0x06000050 RID: 80 RVA: 0x00003780 File Offset: 0x00001B80
			public static AmbientOcclusion.Settings defaultSettings
			{
				get
				{
					return new AmbientOcclusion.Settings
					{
						intensity = 1f,
						radius = 0.3f,
						sampleCount = AmbientOcclusion.SampleCount.Medium,
						sampleCountValue = 24,
						downsampling = false,
						ambientOnly = false,
						occlusionSource = AmbientOcclusion.OcclusionSource.DepthNormalsTexture
					};
				}
			}

			// Token: 0x0400005D RID: 93
			[SerializeField]
			[Range(0f, 4f)]
			[Tooltip("Degree of darkness produced by the effect.")]
			public float intensity;

			// Token: 0x0400005E RID: 94
			[SerializeField]
			[Tooltip("Radius of sample points, which affects extent of darkened areas.")]
			public float radius;

			// Token: 0x0400005F RID: 95
			[SerializeField]
			[Tooltip("Number of sample points, which affects quality and performance.")]
			public AmbientOcclusion.SampleCount sampleCount;

			// Token: 0x04000060 RID: 96
			[SerializeField]
			[Tooltip("Determines the sample count when SampleCount.Variable is used.")]
			public int sampleCountValue;

			// Token: 0x04000061 RID: 97
			[SerializeField]
			[Tooltip("Halves the resolution of the effect to increase performance.")]
			public bool downsampling;

			// Token: 0x04000062 RID: 98
			[SerializeField]
			[Tooltip("If checked, the effect only affects ambient lighting.")]
			public bool ambientOnly;

			// Token: 0x04000063 RID: 99
			[SerializeField]
			[Tooltip("Source buffer on which the occlusion estimator is based.")]
			public AmbientOcclusion.OcclusionSource occlusionSource;

			// Token: 0x04000064 RID: 100
			[SerializeField]
			public bool debug;
		}
	}
}