using System;
using UnityEngine;

namespace UnityStandardAssets.CinematicEffects
{
	// Token: 0x0200001F RID: 31
	[ExecuteInEditMode]
	[AddComponentMenu("Image Effects/Cinematic/Depth Of Field")]
	[RequireComponent(typeof(Camera))]
	public class DepthOfField : MonoBehaviour
	{
		// Token: 0x17000029 RID: 41
		// (get) Token: 0x06000065 RID: 101 RVA: 0x00003EC8 File Offset: 0x000022C8
		public Shader filmicDepthOfFieldShader
		{
			get
			{
				if (this.m_FilmicDepthOfFieldShader == null)
				{
					this.m_FilmicDepthOfFieldShader = Shader.Find("Hidden/DepthOfField/DepthOfField");
				}
				return this.m_FilmicDepthOfFieldShader;
			}
		}

		// Token: 0x1700002A RID: 42
		// (get) Token: 0x06000066 RID: 102 RVA: 0x00003EF1 File Offset: 0x000022F1
		public Shader medianFilterShader
		{
			get
			{
				if (this.m_MedianFilterShader == null)
				{
					this.m_MedianFilterShader = Shader.Find("Hidden/DepthOfField/MedianFilter");
				}
				return this.m_MedianFilterShader;
			}
		}

		// Token: 0x1700002B RID: 43
		// (get) Token: 0x06000067 RID: 103 RVA: 0x00003F1A File Offset: 0x0000231A
		public Shader textureBokehShader
		{
			get
			{
				if (this.m_TextureBokehShader == null)
				{
					this.m_TextureBokehShader = Shader.Find("Hidden/DepthOfField/BokehSplatting");
				}
				return this.m_TextureBokehShader;
			}
		}

		// Token: 0x1700002C RID: 44
		// (get) Token: 0x06000068 RID: 104 RVA: 0x00003F43 File Offset: 0x00002343
		public Material filmicDepthOfFieldMaterial
		{
			get
			{
				if (this.m_FilmicDepthOfFieldMaterial == null)
				{
					this.m_FilmicDepthOfFieldMaterial = ImageEffectHelper.CheckShaderAndCreateMaterial(this.filmicDepthOfFieldShader);
				}
				return this.m_FilmicDepthOfFieldMaterial;
			}
		}

		// Token: 0x1700002D RID: 45
		// (get) Token: 0x06000069 RID: 105 RVA: 0x00003F6D File Offset: 0x0000236D
		public Material medianFilterMaterial
		{
			get
			{
				if (this.m_MedianFilterMaterial == null)
				{
					this.m_MedianFilterMaterial = ImageEffectHelper.CheckShaderAndCreateMaterial(this.medianFilterShader);
				}
				return this.m_MedianFilterMaterial;
			}
		}

		// Token: 0x1700002E RID: 46
		// (get) Token: 0x0600006A RID: 106 RVA: 0x00003F97 File Offset: 0x00002397
		public Material textureBokehMaterial
		{
			get
			{
				if (this.m_TextureBokehMaterial == null)
				{
					this.m_TextureBokehMaterial = ImageEffectHelper.CheckShaderAndCreateMaterial(this.textureBokehShader);
				}
				return this.m_TextureBokehMaterial;
			}
		}

		// Token: 0x1700002F RID: 47
		// (get) Token: 0x0600006B RID: 107 RVA: 0x00003FC4 File Offset: 0x000023C4
		public ComputeBuffer computeBufferDrawArgs
		{
			get
			{
				if (this.m_ComputeBufferDrawArgs == null)
				{
					this.m_ComputeBufferDrawArgs = new ComputeBuffer(1, 16, ComputeBufferType.DrawIndirect);
					this.m_ComputeBufferDrawArgs.SetData(new int[] { 0, 1, 0, 0 });
				}
				return this.m_ComputeBufferDrawArgs;
			}
		}

		// Token: 0x17000030 RID: 48
		// (get) Token: 0x0600006C RID: 108 RVA: 0x00004011 File Offset: 0x00002411
		public ComputeBuffer computeBufferPoints
		{
			get
			{
				if (this.m_ComputeBufferPoints == null)
				{
					this.m_ComputeBufferPoints = new ComputeBuffer(90000, 28, ComputeBufferType.Append);
				}
				return this.m_ComputeBufferPoints;
			}
		}

		// Token: 0x0600006D RID: 109 RVA: 0x00004038 File Offset: 0x00002438
		private void OnEnable()
		{
			if (!ImageEffectHelper.IsSupported(this.filmicDepthOfFieldShader, true, true, this) || !ImageEffectHelper.IsSupported(this.medianFilterShader, true, true, this))
			{
				base.enabled = false;
				return;
			}
			if (ImageEffectHelper.supportsDX11 && !ImageEffectHelper.IsSupported(this.textureBokehShader, true, true, this))
			{
				base.enabled = false;
				return;
			}
			this.ComputeBlurDirections(true);
			base.GetComponent<Camera>().depthTextureMode |= DepthTextureMode.Depth;
		}

		// Token: 0x0600006E RID: 110 RVA: 0x000040B4 File Offset: 0x000024B4
		private void OnDisable()
		{
			this.ReleaseComputeResources();
			if (this.m_FilmicDepthOfFieldMaterial != null)
			{
				global::UnityEngine.Object.DestroyImmediate(this.m_FilmicDepthOfFieldMaterial);
			}
			if (this.m_TextureBokehMaterial != null)
			{
				global::UnityEngine.Object.DestroyImmediate(this.m_TextureBokehMaterial);
			}
			if (this.m_MedianFilterMaterial != null)
			{
				global::UnityEngine.Object.DestroyImmediate(this.m_MedianFilterMaterial);
			}
			this.m_FilmicDepthOfFieldMaterial = null;
			this.m_TextureBokehMaterial = null;
			this.m_MedianFilterMaterial = null;
			this.m_RTU.ReleaseAllTemporaryRenderTextures();
		}

		// Token: 0x0600006F RID: 111 RVA: 0x0000413C File Offset: 0x0000253C
		private void OnRenderImage(RenderTexture source, RenderTexture destination)
		{
			if (this.medianFilterMaterial == null || this.filmicDepthOfFieldMaterial == null)
			{
				Graphics.Blit(source, destination);
				return;
			}
			if (this.settings.visualizeBluriness)
			{
				Vector4 vector;
				Vector4 vector2;
				this.ComputeCocParameters(out vector, out vector2);
				this.filmicDepthOfFieldMaterial.SetVector("_BlurParams", vector);
				this.filmicDepthOfFieldMaterial.SetVector("_BlurCoe", vector2);
				Graphics.Blit(null, destination, this.filmicDepthOfFieldMaterial, (this.settings.tweakMode != DepthOfField.TweakMode.Explicit) ? 6 : 7);
			}
			else
			{
				this.DoDepthOfField(source, destination);
			}
			this.m_RTU.ReleaseAllTemporaryRenderTextures();
		}

		// Token: 0x06000070 RID: 112 RVA: 0x000041EC File Offset: 0x000025EC
		private void DoDepthOfField(RenderTexture source, RenderTexture destination)
		{
			this.m_CurrentQualitySettings = this.quality;
			if (this.settings.quality != DepthOfField.QualityPreset.Custom)
			{
				this.m_CurrentQualitySettings = DepthOfField.QualitySettings.presetQualitySettings[(int)this.settings.quality];
			}
			float num = (float)source.height / 720f;
			float num2 = num;
			float num3 = Mathf.Max(this.blur.nearRadius, this.blur.farRadius) * num2 * 0.75f;
			float num4 = this.blur.nearRadius * num;
			float num5 = this.blur.farRadius * num;
			float num6 = Mathf.Max(num4, num5);
			DepthOfField.ApertureShape apertureShape = this.settings.apertureShape;
			if (apertureShape != DepthOfField.ApertureShape.Hexagonal)
			{
				if (apertureShape == DepthOfField.ApertureShape.Octogonal)
				{
					num6 *= 1.15f;
				}
			}
			else
			{
				num6 *= 1.2f;
			}
			if (num6 < 0.5f)
			{
				Graphics.Blit(source, destination);
				return;
			}
			int num7 = source.width / 2;
			int num8 = source.height / 2;
			Vector4 vector = new Vector4(num4 * 0.5f, num5 * 0.5f, 0f, 0f);
			RenderTexture temporaryRenderTexture = this.m_RTU.GetTemporaryRenderTexture(num7, num8, 0, RenderTextureFormat.ARGBHalf, FilterMode.Bilinear);
			RenderTexture temporaryRenderTexture2 = this.m_RTU.GetTemporaryRenderTexture(num7, num8, 0, RenderTextureFormat.ARGBHalf, FilterMode.Bilinear);
			if (this.m_CurrentQualitySettings.preventHaloing)
			{
				this.filmicDepthOfFieldMaterial.EnableKeyword("USE_SPECIAL_FETCH_FOR_COC");
			}
			else
			{
				this.filmicDepthOfFieldMaterial.DisableKeyword("USE_SPECIAL_FETCH_FOR_COC");
			}
			Vector4 vector2;
			Vector4 vector3;
			this.ComputeCocParameters(out vector2, out vector3);
			this.filmicDepthOfFieldMaterial.SetVector("_BlurParams", vector2);
			this.filmicDepthOfFieldMaterial.SetVector("_BlurCoe", vector3);
			this.filmicDepthOfFieldMaterial.SetVector("_BoostParams", new Vector4(num4 * this.blur.nearBoostAmount * -0.5f, num5 * this.blur.farBoostAmount * 0.5f, this.blur.boostPoint, 0f));
			Graphics.Blit(source, temporaryRenderTexture2, this.filmicDepthOfFieldMaterial, (this.settings.tweakMode != DepthOfField.TweakMode.Explicit) ? 4 : 5);
			RenderTexture renderTexture = temporaryRenderTexture2;
			RenderTexture renderTexture2 = temporaryRenderTexture;
			if (this.shouldPerformBokeh)
			{
				RenderTexture temporaryRenderTexture3 = this.m_RTU.GetTemporaryRenderTexture(num7, num8, 0, RenderTextureFormat.ARGBHalf, FilterMode.Bilinear);
				Graphics.Blit(renderTexture, temporaryRenderTexture3, this.filmicDepthOfFieldMaterial, 1);
				this.filmicDepthOfFieldMaterial.SetVector("_Offsets", new Vector4(0f, 1.5f, 0f, 1.5f));
				Graphics.Blit(temporaryRenderTexture3, renderTexture2, this.filmicDepthOfFieldMaterial, 0);
				this.filmicDepthOfFieldMaterial.SetVector("_Offsets", new Vector4(1.5f, 0f, 0f, 1.5f));
				Graphics.Blit(renderTexture2, temporaryRenderTexture3, this.filmicDepthOfFieldMaterial, 0);
				this.textureBokehMaterial.SetTexture("_BlurredColor", temporaryRenderTexture3);
				this.textureBokehMaterial.SetFloat("_SpawnHeuristic", this.bokehTexture.spawnHeuristic);
				this.textureBokehMaterial.SetVector("_BokehParams", new Vector4(this.bokehTexture.scale * num2, this.bokehTexture.intensity, this.bokehTexture.threshold, num3));
				Graphics.SetRandomWriteTarget(1, this.computeBufferPoints);
				Graphics.Blit(renderTexture, renderTexture2, this.textureBokehMaterial, 1);
				Graphics.ClearRandomWriteTargets();
				DepthOfField.SwapRenderTexture(ref renderTexture, ref renderTexture2);
				this.m_RTU.ReleaseTemporaryRenderTexture(temporaryRenderTexture3);
			}
			this.filmicDepthOfFieldMaterial.SetVector("_BlurParams", vector2);
			this.filmicDepthOfFieldMaterial.SetVector("_BlurCoe", vector);
			this.filmicDepthOfFieldMaterial.SetVector("_BoostParams", new Vector4(num4 * this.blur.nearBoostAmount * -0.5f, num5 * this.blur.farBoostAmount * 0.5f, this.blur.boostPoint, 0f));
			RenderTexture renderTexture3 = null;
			if (this.m_CurrentQualitySettings.dilateNearBlur)
			{
				RenderTexture temporaryRenderTexture4 = this.m_RTU.GetTemporaryRenderTexture(num7, num8, 0, RenderTextureFormat.RGHalf, FilterMode.Bilinear);
				renderTexture3 = this.m_RTU.GetTemporaryRenderTexture(num7, num8, 0, RenderTextureFormat.RGHalf, FilterMode.Bilinear);
				this.filmicDepthOfFieldMaterial.SetVector("_Offsets", new Vector4(0f, num4 * 0.75f, 0f, 0f));
				Graphics.Blit(renderTexture, temporaryRenderTexture4, this.filmicDepthOfFieldMaterial, 2);
				this.filmicDepthOfFieldMaterial.SetVector("_Offsets", new Vector4(num4 * 0.75f, 0f, 0f, 0f));
				Graphics.Blit(temporaryRenderTexture4, renderTexture3, this.filmicDepthOfFieldMaterial, 3);
				this.m_RTU.ReleaseTemporaryRenderTexture(temporaryRenderTexture4);
				renderTexture3.filterMode = FilterMode.Point;
			}
			if (this.m_CurrentQualitySettings.prefilterBlur)
			{
				Graphics.Blit(renderTexture, renderTexture2, this.filmicDepthOfFieldMaterial, 8);
				DepthOfField.SwapRenderTexture(ref renderTexture, ref renderTexture2);
			}
			DepthOfField.ApertureShape apertureShape2 = this.settings.apertureShape;
			if (apertureShape2 != DepthOfField.ApertureShape.Circular)
			{
				if (apertureShape2 != DepthOfField.ApertureShape.Hexagonal)
				{
					if (apertureShape2 == DepthOfField.ApertureShape.Octogonal)
					{
						this.DoOctogonalBlur(renderTexture3, ref renderTexture, ref renderTexture2, num6);
					}
				}
				else
				{
					this.DoHexagonalBlur(renderTexture3, ref renderTexture, ref renderTexture2, num6);
				}
			}
			else
			{
				this.DoCircularBlur(renderTexture3, ref renderTexture, ref renderTexture2, num6);
			}
			DepthOfField.FilterQuality medianFilter = this.m_CurrentQualitySettings.medianFilter;
			if (medianFilter != DepthOfField.FilterQuality.Normal)
			{
				if (medianFilter == DepthOfField.FilterQuality.High)
				{
					Graphics.Blit(renderTexture, renderTexture2, this.medianFilterMaterial, 1);
					DepthOfField.SwapRenderTexture(ref renderTexture, ref renderTexture2);
				}
			}
			else
			{
				this.medianFilterMaterial.SetVector("_Offsets", new Vector4(1f, 0f, 0f, 0f));
				Graphics.Blit(renderTexture, renderTexture2, this.medianFilterMaterial, 0);
				DepthOfField.SwapRenderTexture(ref renderTexture, ref renderTexture2);
				this.medianFilterMaterial.SetVector("_Offsets", new Vector4(0f, 1f, 0f, 0f));
				Graphics.Blit(renderTexture, renderTexture2, this.medianFilterMaterial, 0);
				DepthOfField.SwapRenderTexture(ref renderTexture, ref renderTexture2);
			}
			this.filmicDepthOfFieldMaterial.SetVector("_BlurCoe", vector);
			this.filmicDepthOfFieldMaterial.SetVector("_Convolved_TexelSize", new Vector4((float)renderTexture.width, (float)renderTexture.height, 1f / (float)renderTexture.width, 1f / (float)renderTexture.height));
			this.filmicDepthOfFieldMaterial.SetTexture("_SecondTex", renderTexture);
			int num9 = ((this.settings.tweakMode != DepthOfField.TweakMode.Explicit) ? 13 : 14);
			if (this.m_CurrentQualitySettings.highQualityUpsampling)
			{
				num9 = ((this.settings.tweakMode != DepthOfField.TweakMode.Explicit) ? 15 : 16);
			}
			if (this.shouldPerformBokeh)
			{
				RenderTexture temporaryRenderTexture5 = this.m_RTU.GetTemporaryRenderTexture(source.height, source.width, 0, source.format, FilterMode.Bilinear);
				Graphics.Blit(source, temporaryRenderTexture5, this.filmicDepthOfFieldMaterial, num9);
				Graphics.SetRenderTarget(temporaryRenderTexture5);
				ComputeBuffer.CopyCount(this.computeBufferPoints, this.computeBufferDrawArgs, 0);
				this.textureBokehMaterial.SetBuffer("pointBuffer", this.computeBufferPoints);
				this.textureBokehMaterial.SetTexture("_MainTex", this.bokehTexture.texture);
				this.textureBokehMaterial.SetVector("_Screen", new Vector3(1f / (1f * (float)source.width), 1f / (1f * (float)source.height), num3));
				this.textureBokehMaterial.SetPass(0);
				Graphics.DrawProceduralIndirect(MeshTopology.Points, this.computeBufferDrawArgs, 0);
				Graphics.Blit(temporaryRenderTexture5, destination);
			}
			else
			{
				Graphics.Blit(source, destination, this.filmicDepthOfFieldMaterial, num9);
			}
		}

		// Token: 0x06000071 RID: 113 RVA: 0x00004994 File Offset: 0x00002D94
		private void DoHexagonalBlur(RenderTexture blurredFgCoc, ref RenderTexture src, ref RenderTexture dst, float maxRadius)
		{
			this.ComputeBlurDirections(false);
			int num;
			int num2;
			DepthOfField.GetDirectionalBlurPassesFromRadius(blurredFgCoc, maxRadius, out num, out num2);
			this.filmicDepthOfFieldMaterial.SetTexture("_SecondTex", blurredFgCoc);
			RenderTexture temporaryRenderTexture = this.m_RTU.GetTemporaryRenderTexture(src.width, src.height, 0, src.format, FilterMode.Bilinear);
			this.filmicDepthOfFieldMaterial.SetVector("_Offsets", this.m_HexagonalBokehDirection1);
			Graphics.Blit(src, temporaryRenderTexture, this.filmicDepthOfFieldMaterial, num);
			this.filmicDepthOfFieldMaterial.SetVector("_Offsets", this.m_HexagonalBokehDirection2);
			Graphics.Blit(temporaryRenderTexture, src, this.filmicDepthOfFieldMaterial, num);
			this.filmicDepthOfFieldMaterial.SetVector("_Offsets", this.m_HexagonalBokehDirection3);
			this.filmicDepthOfFieldMaterial.SetTexture("_ThirdTex", src);
			Graphics.Blit(temporaryRenderTexture, dst, this.filmicDepthOfFieldMaterial, num2);
			this.m_RTU.ReleaseTemporaryRenderTexture(temporaryRenderTexture);
			DepthOfField.SwapRenderTexture(ref src, ref dst);
		}

		// Token: 0x06000072 RID: 114 RVA: 0x00004A7C File Offset: 0x00002E7C
		private void DoOctogonalBlur(RenderTexture blurredFgCoc, ref RenderTexture src, ref RenderTexture dst, float maxRadius)
		{
			this.ComputeBlurDirections(false);
			int num;
			int num2;
			DepthOfField.GetDirectionalBlurPassesFromRadius(blurredFgCoc, maxRadius, out num, out num2);
			this.filmicDepthOfFieldMaterial.SetTexture("_SecondTex", blurredFgCoc);
			RenderTexture temporaryRenderTexture = this.m_RTU.GetTemporaryRenderTexture(src.width, src.height, 0, src.format, FilterMode.Bilinear);
			this.filmicDepthOfFieldMaterial.SetVector("_Offsets", this.m_OctogonalBokehDirection1);
			Graphics.Blit(src, temporaryRenderTexture, this.filmicDepthOfFieldMaterial, num);
			this.filmicDepthOfFieldMaterial.SetVector("_Offsets", this.m_OctogonalBokehDirection2);
			Graphics.Blit(temporaryRenderTexture, dst, this.filmicDepthOfFieldMaterial, num);
			this.filmicDepthOfFieldMaterial.SetVector("_Offsets", this.m_OctogonalBokehDirection3);
			Graphics.Blit(src, temporaryRenderTexture, this.filmicDepthOfFieldMaterial, num);
			this.filmicDepthOfFieldMaterial.SetVector("_Offsets", this.m_OctogonalBokehDirection4);
			this.filmicDepthOfFieldMaterial.SetTexture("_ThirdTex", dst);
			Graphics.Blit(temporaryRenderTexture, src, this.filmicDepthOfFieldMaterial, num2);
			this.m_RTU.ReleaseTemporaryRenderTexture(temporaryRenderTexture);
		}

		// Token: 0x06000073 RID: 115 RVA: 0x00004B84 File Offset: 0x00002F84
		private void DoCircularBlur(RenderTexture blurredFgCoc, ref RenderTexture src, ref RenderTexture dst, float maxRadius)
		{
			int num;
			if (blurredFgCoc != null)
			{
				this.filmicDepthOfFieldMaterial.SetTexture("_SecondTex", blurredFgCoc);
				num = ((maxRadius <= 10f) ? 12 : 10);
			}
			else
			{
				num = ((maxRadius <= 10f) ? 11 : 9);
			}
			Graphics.Blit(src, dst, this.filmicDepthOfFieldMaterial, num);
			DepthOfField.SwapRenderTexture(ref src, ref dst);
		}

		// Token: 0x06000074 RID: 116 RVA: 0x00004BF8 File Offset: 0x00002FF8
		private void ComputeCocParameters(out Vector4 blurParams, out Vector4 blurCoe)
		{
			Camera component = base.GetComponent<Camera>();
			float num = ((!this.focus.transform) ? (this.focus.plane * this.focus.plane * this.focus.plane * this.focus.plane) : (component.WorldToViewportPoint(this.focus.transform.position).z / component.farClipPlane));
			if (this.settings.tweakMode == DepthOfField.TweakMode.Basic || this.settings.tweakMode == DepthOfField.TweakMode.Advanced)
			{
				float num2 = this.focus.rangeAdjustment * this.focus.rangeAdjustment * this.focus.rangeAdjustment * this.focus.rangeAdjustment;
				float num3 = 4f / Mathf.Tan(0.5f * component.fieldOfView * 0.017453292f);
				float num4 = num3 / this.focus.fStops;
				blurCoe = new Vector4(0f, 0f, 1f, 1f);
				blurParams = new Vector4(num4, num3, num, num2);
			}
			else
			{
				float num5 = this.focus.nearPlane * this.focus.nearPlane * this.focus.nearPlane * this.focus.nearPlane;
				float num6 = this.focus.farPlane * this.focus.farPlane * this.focus.farPlane * this.focus.farPlane;
				float num7 = this.focus.rangeAdjustment * this.focus.rangeAdjustment * this.focus.rangeAdjustment * this.focus.rangeAdjustment;
				float num8 = num7;
				if (num <= num5)
				{
					num = num5 + 1E-07f;
				}
				if (num >= num6)
				{
					num = num6 - 1E-07f;
				}
				if (num - num7 <= num5)
				{
					num7 = num - num5 - 1E-07f;
				}
				if (num + num8 >= num6)
				{
					num8 = num6 - num - 1E-07f;
				}
				float num9 = 1f / (num5 - num + num7);
				float num10 = 1f / (num6 - num - num8);
				float num11 = 1f - num9 * num5;
				float num12 = 1f - num10 * num6;
				blurParams = new Vector4(-1f * num9, -1f * num11, 1f * num10, 1f * num12);
				blurCoe = new Vector4(0f, 0f, (num12 - num11) / (num9 - num10), 0f);
			}
		}

		// Token: 0x06000075 RID: 117 RVA: 0x00004E8B File Offset: 0x0000328B
		private void ReleaseComputeResources()
		{
			if (this.m_ComputeBufferDrawArgs != null)
			{
				this.m_ComputeBufferDrawArgs.Release();
			}
			if (this.m_ComputeBufferPoints != null)
			{
				this.m_ComputeBufferPoints.Release();
			}
			this.m_ComputeBufferDrawArgs = null;
			this.m_ComputeBufferPoints = null;
		}

		// Token: 0x06000076 RID: 118 RVA: 0x00004EC8 File Offset: 0x000032C8
		private void ComputeBlurDirections(bool force)
		{
			if (!force && Math.Abs(this.m_LastApertureOrientation - this.settings.apertureOrientation) < 1E-45f)
			{
				return;
			}
			this.m_LastApertureOrientation = this.settings.apertureOrientation;
			float num = this.settings.apertureOrientation * 0.017453292f;
			float num2 = Mathf.Cos(num);
			float num3 = Mathf.Sin(num);
			this.m_OctogonalBokehDirection1 = new Vector4(0.5f, 0f, 0f, 0f);
			this.m_OctogonalBokehDirection2 = new Vector4(0f, 0.5f, 1f, 0f);
			this.m_OctogonalBokehDirection3 = new Vector4(-0.353553f, 0.353553f, 1f, 0f);
			this.m_OctogonalBokehDirection4 = new Vector4(0.353553f, 0.353553f, 1f, 0f);
			this.m_HexagonalBokehDirection1 = new Vector4(0.5f, 0f, 0f, 0f);
			this.m_HexagonalBokehDirection2 = new Vector4(0.25f, 0.433013f, 1f, 0f);
			this.m_HexagonalBokehDirection3 = new Vector4(0.25f, -0.433013f, 1f, 0f);
			if (num > 1E-45f)
			{
				DepthOfField.Rotate2D(ref this.m_OctogonalBokehDirection1, num2, num3);
				DepthOfField.Rotate2D(ref this.m_OctogonalBokehDirection2, num2, num3);
				DepthOfField.Rotate2D(ref this.m_OctogonalBokehDirection3, num2, num3);
				DepthOfField.Rotate2D(ref this.m_OctogonalBokehDirection4, num2, num3);
				DepthOfField.Rotate2D(ref this.m_HexagonalBokehDirection1, num2, num3);
				DepthOfField.Rotate2D(ref this.m_HexagonalBokehDirection2, num2, num3);
				DepthOfField.Rotate2D(ref this.m_HexagonalBokehDirection3, num2, num3);
			}
		}

		// Token: 0x17000031 RID: 49
		// (get) Token: 0x06000077 RID: 119 RVA: 0x00005070 File Offset: 0x00003470
		private bool shouldPerformBokeh
		{
			get
			{
				return ImageEffectHelper.supportsDX11 && this.bokehTexture.texture != null && this.textureBokehMaterial && this.settings.tweakMode != DepthOfField.TweakMode.Basic;
			}
		}

		// Token: 0x06000078 RID: 120 RVA: 0x000050C4 File Offset: 0x000034C4
		private static void Rotate2D(ref Vector4 direction, float cosinus, float sinus)
		{
			Vector4 vector = direction;
			direction.x = vector.x * cosinus - vector.y * sinus;
			direction.y = vector.x * sinus + vector.y * cosinus;
		}

		// Token: 0x06000079 RID: 121 RVA: 0x0000510C File Offset: 0x0000350C
		private static void SwapRenderTexture(ref RenderTexture src, ref RenderTexture dst)
		{
			RenderTexture renderTexture = dst;
			dst = src;
			src = renderTexture;
		}

		// Token: 0x0600007A RID: 122 RVA: 0x00005124 File Offset: 0x00003524
		private static void GetDirectionalBlurPassesFromRadius(RenderTexture blurredFgCoc, float maxRadius, out int blurPass, out int blurAndMergePass)
		{
			if (blurredFgCoc == null)
			{
				if (maxRadius > 10f)
				{
					blurPass = 25;
					blurAndMergePass = 27;
				}
				else if (maxRadius > 5f)
				{
					blurPass = 21;
					blurAndMergePass = 23;
				}
				else
				{
					blurPass = 17;
					blurAndMergePass = 19;
				}
			}
			else if (maxRadius > 10f)
			{
				blurPass = 26;
				blurAndMergePass = 28;
			}
			else if (maxRadius > 5f)
			{
				blurPass = 22;
				blurAndMergePass = 24;
			}
			else
			{
				blurPass = 18;
				blurAndMergePass = 20;
			}
		}

		// Token: 0x04000072 RID: 114
		private const float kMaxBlur = 35f;

		// Token: 0x04000073 RID: 115
		[DepthOfField.TopLevelSettings]
		public DepthOfField.GlobalSettings settings = DepthOfField.GlobalSettings.defaultSettings;

		// Token: 0x04000074 RID: 116
		[DepthOfField.SettingsGroup]
		[DepthOfField.AllTweakModes]
		public DepthOfField.QualitySettings quality = DepthOfField.QualitySettings.presetQualitySettings[3];

		// Token: 0x04000075 RID: 117
		[DepthOfField.SettingsGroup]
		public DepthOfField.FocusSettings focus = DepthOfField.FocusSettings.defaultSettings;

		// Token: 0x04000076 RID: 118
		[DepthOfField.SettingsGroup]
		public DepthOfField.BokehTextureSettings bokehTexture = DepthOfField.BokehTextureSettings.defaultSettings;

		// Token: 0x04000077 RID: 119
		[DepthOfField.SettingsGroup]
		public DepthOfField.BlurSettings blur = DepthOfField.BlurSettings.defaultSettings;

		// Token: 0x04000078 RID: 120
		[SerializeField]
		private Shader m_FilmicDepthOfFieldShader;

		// Token: 0x04000079 RID: 121
		[SerializeField]
		private Shader m_MedianFilterShader;

		// Token: 0x0400007A RID: 122
		[SerializeField]
		private Shader m_TextureBokehShader;

		// Token: 0x0400007B RID: 123
		private RenderTextureUtility m_RTU = new RenderTextureUtility();

		// Token: 0x0400007C RID: 124
		private Material m_FilmicDepthOfFieldMaterial;

		// Token: 0x0400007D RID: 125
		private Material m_MedianFilterMaterial;

		// Token: 0x0400007E RID: 126
		private Material m_TextureBokehMaterial;

		// Token: 0x0400007F RID: 127
		private ComputeBuffer m_ComputeBufferDrawArgs;

		// Token: 0x04000080 RID: 128
		private ComputeBuffer m_ComputeBufferPoints;

		// Token: 0x04000081 RID: 129
		private DepthOfField.QualitySettings m_CurrentQualitySettings;

		// Token: 0x04000082 RID: 130
		private float m_LastApertureOrientation;

		// Token: 0x04000083 RID: 131
		private Vector4 m_OctogonalBokehDirection1;

		// Token: 0x04000084 RID: 132
		private Vector4 m_OctogonalBokehDirection2;

		// Token: 0x04000085 RID: 133
		private Vector4 m_OctogonalBokehDirection3;

		// Token: 0x04000086 RID: 134
		private Vector4 m_OctogonalBokehDirection4;

		// Token: 0x04000087 RID: 135
		private Vector4 m_HexagonalBokehDirection1;

		// Token: 0x04000088 RID: 136
		private Vector4 m_HexagonalBokehDirection2;

		// Token: 0x04000089 RID: 137
		private Vector4 m_HexagonalBokehDirection3;

		// Token: 0x02000020 RID: 32
		private enum Passes
		{
			// Token: 0x0400008B RID: 139
			BlurAlphaWeighted,
			// Token: 0x0400008C RID: 140
			BoxBlur,
			// Token: 0x0400008D RID: 141
			DilateFgCocFromColor,
			// Token: 0x0400008E RID: 142
			DilateFgCoc,
			// Token: 0x0400008F RID: 143
			CaptureCoc,
			// Token: 0x04000090 RID: 144
			CaptureCocExplicit,
			// Token: 0x04000091 RID: 145
			VisualizeCoc,
			// Token: 0x04000092 RID: 146
			VisualizeCocExplicit,
			// Token: 0x04000093 RID: 147
			CocPrefilter,
			// Token: 0x04000094 RID: 148
			CircleBlur,
			// Token: 0x04000095 RID: 149
			CircleBlurWithDilatedFg,
			// Token: 0x04000096 RID: 150
			CircleBlurLowQuality,
			// Token: 0x04000097 RID: 151
			CircleBlowLowQualityWithDilatedFg,
			// Token: 0x04000098 RID: 152
			Merge,
			// Token: 0x04000099 RID: 153
			MergeExplicit,
			// Token: 0x0400009A RID: 154
			MergeBicubic,
			// Token: 0x0400009B RID: 155
			MergeExplicitBicubic,
			// Token: 0x0400009C RID: 156
			ShapeLowQuality,
			// Token: 0x0400009D RID: 157
			ShapeLowQualityDilateFg,
			// Token: 0x0400009E RID: 158
			ShapeLowQualityMerge,
			// Token: 0x0400009F RID: 159
			ShapeLowQualityMergeDilateFg,
			// Token: 0x040000A0 RID: 160
			ShapeMediumQuality,
			// Token: 0x040000A1 RID: 161
			ShapeMediumQualityDilateFg,
			// Token: 0x040000A2 RID: 162
			ShapeMediumQualityMerge,
			// Token: 0x040000A3 RID: 163
			ShapeMediumQualityMergeDilateFg,
			// Token: 0x040000A4 RID: 164
			ShapeHighQuality,
			// Token: 0x040000A5 RID: 165
			ShapeHighQualityDilateFg,
			// Token: 0x040000A6 RID: 166
			ShapeHighQualityMerge,
			// Token: 0x040000A7 RID: 167
			ShapeHighQualityMergeDilateFg
		}

		// Token: 0x02000021 RID: 33
		private enum MedianPasses
		{
			// Token: 0x040000A9 RID: 169
			Median3,
			// Token: 0x040000AA RID: 170
			Median3X3
		}

		// Token: 0x02000022 RID: 34
		private enum BokehTexturesPasses
		{
			// Token: 0x040000AC RID: 172
			Apply,
			// Token: 0x040000AD RID: 173
			Collect
		}

		// Token: 0x02000023 RID: 35
		public enum TweakMode
		{
			// Token: 0x040000AF RID: 175
			Basic,
			// Token: 0x040000B0 RID: 176
			Advanced,
			// Token: 0x040000B1 RID: 177
			Explicit
		}

		// Token: 0x02000024 RID: 36
		public enum ApertureShape
		{
			// Token: 0x040000B3 RID: 179
			Circular,
			// Token: 0x040000B4 RID: 180
			Hexagonal,
			// Token: 0x040000B5 RID: 181
			Octogonal
		}

		// Token: 0x02000025 RID: 37
		public enum QualityPreset
		{
			// Token: 0x040000B7 RID: 183
			Simple,
			// Token: 0x040000B8 RID: 184
			Low,
			// Token: 0x040000B9 RID: 185
			Medium,
			// Token: 0x040000BA RID: 186
			High,
			// Token: 0x040000BB RID: 187
			VeryHigh,
			// Token: 0x040000BC RID: 188
			Ultra,
			// Token: 0x040000BD RID: 189
			Custom
		}

		// Token: 0x02000026 RID: 38
		public enum FilterQuality
		{
			// Token: 0x040000BF RID: 191
			None,
			// Token: 0x040000C0 RID: 192
			Normal,
			// Token: 0x040000C1 RID: 193
			High
		}

		// Token: 0x02000027 RID: 39
		[AttributeUsage(AttributeTargets.Field)]
		public class TopLevelSettings : Attribute
		{
		}

		// Token: 0x02000028 RID: 40
		[AttributeUsage(AttributeTargets.Field)]
		public class SettingsGroup : Attribute
		{
		}

		// Token: 0x02000029 RID: 41
		[AttributeUsage(AttributeTargets.Field)]
		public class AllTweakModes : Attribute
		{
		}

		// Token: 0x0200002A RID: 42
		[AttributeUsage(AttributeTargets.Field)]
		public class Basic : Attribute
		{
		}

		// Token: 0x0200002B RID: 43
		[AttributeUsage(AttributeTargets.Field)]
		public class Advanced : Attribute
		{
		}

		// Token: 0x0200002C RID: 44
		[AttributeUsage(AttributeTargets.Field)]
		public class Explicit : Attribute
		{
		}

		// Token: 0x0200002D RID: 45
		[Serializable]
		public struct GlobalSettings
		{
			// Token: 0x17000032 RID: 50
			// (get) Token: 0x06000081 RID: 129 RVA: 0x000051E4 File Offset: 0x000035E4
			public static DepthOfField.GlobalSettings defaultSettings
			{
				get
				{
					return new DepthOfField.GlobalSettings
					{
						visualizeBluriness = false,
						tweakMode = DepthOfField.TweakMode.Basic,
						quality = DepthOfField.QualityPreset.High,
						apertureShape = DepthOfField.ApertureShape.Circular,
						apertureOrientation = 0f
					};
				}
			}

			// Token: 0x040000C2 RID: 194
			[Tooltip("Allows to view where the blur will be applied. Yellow for near blur, blue for far blur.")]
			public bool visualizeBluriness;

			// Token: 0x040000C3 RID: 195
			[Tooltip("Setup mode. Use \"Advanced\" if you need more control on blur settings and/or want to use a bokeh texture. \"Explicit\" is the same as \"Advanced\" but makes use of \"Near Plane\" and \"Far Plane\" values instead of \"F-Stop\".")]
			public DepthOfField.TweakMode tweakMode;

			// Token: 0x040000C4 RID: 196
			[Tooltip("Quality presets. Use \"Custom\" for more advanced settings.")]
			public DepthOfField.QualityPreset quality;

			// Token: 0x040000C5 RID: 197
			[Space]
			[Tooltip("\"Circular\" is the fastest, followed by \"Hexagonal\" and \"Octogonal\".")]
			public DepthOfField.ApertureShape apertureShape;

			// Token: 0x040000C6 RID: 198
			[Range(0f, 179f)]
			[Tooltip("Rotates the aperture when working with \"Hexagonal\" and \"Ortogonal\".")]
			public float apertureOrientation;
		}

		// Token: 0x0200002E RID: 46
		[Serializable]
		public struct QualitySettings
		{
			// Token: 0x040000C7 RID: 199
			[Tooltip("Enable this to get smooth bokeh.")]
			public bool prefilterBlur;

			// Token: 0x040000C8 RID: 200
			[Tooltip("Applies a median filter for even smoother bokeh.")]
			public DepthOfField.FilterQuality medianFilter;

			// Token: 0x040000C9 RID: 201
			[Tooltip("Dilates near blur over in focus area.")]
			public bool dilateNearBlur;

			// Token: 0x040000CA RID: 202
			[Tooltip("Uses high quality upsampling.")]
			public bool highQualityUpsampling;

			// Token: 0x040000CB RID: 203
			[Tooltip("Prevent haloing from bright in focus region over dark out of focus region.")]
			public bool preventHaloing;

			// Token: 0x040000CC RID: 204
			public static DepthOfField.QualitySettings[] presetQualitySettings = new DepthOfField.QualitySettings[]
			{
				new DepthOfField.QualitySettings
				{
					prefilterBlur = false,
					medianFilter = DepthOfField.FilterQuality.None,
					dilateNearBlur = false,
					highQualityUpsampling = false,
					preventHaloing = false
				},
				new DepthOfField.QualitySettings
				{
					prefilterBlur = true,
					medianFilter = DepthOfField.FilterQuality.None,
					dilateNearBlur = false,
					highQualityUpsampling = false,
					preventHaloing = false
				},
				new DepthOfField.QualitySettings
				{
					prefilterBlur = true,
					medianFilter = DepthOfField.FilterQuality.Normal,
					dilateNearBlur = false,
					highQualityUpsampling = false,
					preventHaloing = false
				},
				new DepthOfField.QualitySettings
				{
					prefilterBlur = true,
					medianFilter = DepthOfField.FilterQuality.Normal,
					dilateNearBlur = true,
					highQualityUpsampling = false,
					preventHaloing = false
				},
				new DepthOfField.QualitySettings
				{
					prefilterBlur = true,
					medianFilter = DepthOfField.FilterQuality.High,
					dilateNearBlur = true,
					highQualityUpsampling = false,
					preventHaloing = true
				},
				new DepthOfField.QualitySettings
				{
					prefilterBlur = true,
					medianFilter = DepthOfField.FilterQuality.High,
					dilateNearBlur = true,
					highQualityUpsampling = true,
					preventHaloing = true
				}
			};
		}

		// Token: 0x0200002F RID: 47
		[Serializable]
		public struct FocusSettings
		{
			// Token: 0x17000033 RID: 51
			// (get) Token: 0x06000083 RID: 131 RVA: 0x000053B0 File Offset: 0x000037B0
			public static DepthOfField.FocusSettings defaultSettings
			{
				get
				{
					return new DepthOfField.FocusSettings
					{
						transform = null,
						plane = 0.225f,
						nearPlane = 0f,
						farPlane = 1f,
						fStops = 5f,
						rangeAdjustment = 0.9f
					};
				}
			}

			// Token: 0x040000CD RID: 205
			[DepthOfField.Basic]
			[DepthOfField.Advanced]
			[DepthOfField.Explicit]
			[Tooltip("Auto-focus on a selected transform.")]
			public Transform transform;

			// Token: 0x040000CE RID: 206
			[DepthOfField.Basic]
			[DepthOfField.Advanced]
			[DepthOfField.Explicit]
			[Range(0f, 1f)]
			[Tooltip("Focus distance.")]
			public float plane;

			// Token: 0x040000CF RID: 207
			[DepthOfField.Explicit]
			[Range(0f, 1f)]
			[Tooltip("Near focus distance.")]
			public float nearPlane;

			// Token: 0x040000D0 RID: 208
			[DepthOfField.Explicit]
			[Range(0f, 1f)]
			[Tooltip("Far focus distance.")]
			public float farPlane;

			// Token: 0x040000D1 RID: 209
			[DepthOfField.Basic]
			[DepthOfField.Advanced]
			[Range(0f, 32f)]
			[Tooltip("Simulates focal ratio. Lower values will result in a narrow depth of field.")]
			public float fStops;

			// Token: 0x040000D2 RID: 210
			[DepthOfField.Basic]
			[DepthOfField.Advanced]
			[DepthOfField.Explicit]
			[Range(0f, 1f)]
			[Tooltip("Focus range/spread. Use this to fine-tune the F-Stop range.")]
			public float rangeAdjustment;
		}

		// Token: 0x02000030 RID: 48
		[Serializable]
		public struct BokehTextureSettings
		{
			// Token: 0x17000034 RID: 52
			// (get) Token: 0x06000084 RID: 132 RVA: 0x0000540C File Offset: 0x0000380C
			public static DepthOfField.BokehTextureSettings defaultSettings
			{
				get
				{
					return new DepthOfField.BokehTextureSettings
					{
						texture = null,
						scale = 1f,
						intensity = 50f,
						threshold = 2f,
						spawnHeuristic = 0.15f
					};
				}
			}

			// Token: 0x040000D3 RID: 211
			[DepthOfField.Advanced]
			[DepthOfField.Explicit]
			[Tooltip("Adding a texture to this field will enable the use of \"Bokeh Textures\". Use with care. This feature is only available on Shader Model 5 compatible-hardware and performance scale with the amount of bokeh.")]
			public Texture2D texture;

			// Token: 0x040000D4 RID: 212
			[DepthOfField.Advanced]
			[DepthOfField.Explicit]
			[Range(0.01f, 5f)]
			[Tooltip("Maximum size of bokeh textures on screen.")]
			public float scale;

			// Token: 0x040000D5 RID: 213
			[DepthOfField.Advanced]
			[DepthOfField.Explicit]
			[Range(0.01f, 100f)]
			[Tooltip("Bokeh brightness.")]
			public float intensity;

			// Token: 0x040000D6 RID: 214
			[DepthOfField.Advanced]
			[DepthOfField.Explicit]
			[Range(0.01f, 50f)]
			[Tooltip("Controls the amount of bokeh textures. Lower values mean more bokeh splats.")]
			public float threshold;

			// Token: 0x040000D7 RID: 215
			[DepthOfField.Advanced]
			[DepthOfField.Explicit]
			[Range(0.01f, 1f)]
			[Tooltip("Controls the spawn conditions. Lower values mean more visible bokeh.")]
			public float spawnHeuristic;
		}

		// Token: 0x02000031 RID: 49
		[Serializable]
		public struct BlurSettings
		{
			// Token: 0x17000035 RID: 53
			// (get) Token: 0x06000085 RID: 133 RVA: 0x0000545C File Offset: 0x0000385C
			public static DepthOfField.BlurSettings defaultSettings
			{
				get
				{
					return new DepthOfField.BlurSettings
					{
						nearRadius = 20f,
						farRadius = 20f,
						boostPoint = 0.75f,
						nearBoostAmount = 0f,
						farBoostAmount = 0f
					};
				}
			}

			// Token: 0x040000D8 RID: 216
			[DepthOfField.Basic]
			[DepthOfField.Advanced]
			[DepthOfField.Explicit]
			[Range(0f, 35f)]
			[Tooltip("Maximum blur radius for the near plane.")]
			public float nearRadius;

			// Token: 0x040000D9 RID: 217
			[DepthOfField.Basic]
			[DepthOfField.Advanced]
			[DepthOfField.Explicit]
			[Range(0f, 35f)]
			[Tooltip("Maximum blur radius for the far plane.")]
			public float farRadius;

			// Token: 0x040000DA RID: 218
			[DepthOfField.Advanced]
			[DepthOfField.Explicit]
			[Range(0.5f, 4f)]
			[Tooltip("Blur luminosity booster threshold for the near and far boost amounts.")]
			public float boostPoint;

			// Token: 0x040000DB RID: 219
			[DepthOfField.Advanced]
			[DepthOfField.Explicit]
			[Range(0f, 1f)]
			[Tooltip("Boosts luminosity in the near blur.")]
			public float nearBoostAmount;

			// Token: 0x040000DC RID: 220
			[DepthOfField.Advanced]
			[DepthOfField.Explicit]
			[Range(0f, 1f)]
			[Tooltip("Boosts luminosity in the far blur.")]
			public float farBoostAmount;
		}
	}
}