using System;
using UnityEngine;

namespace UnityStandardAssets.ImageEffects
{
	// Token: 0x02000076 RID: 118
	[ExecuteInEditMode]
	[RequireComponent(typeof(Camera))]
	[AddComponentMenu("Image Effects/Noise/Noise And Grain (Filmic)")]
	public class NoiseAndGrain : PostEffectsBase
	{
		// Token: 0x0600014D RID: 333 RVA: 0x0000EA74 File Offset: 0x0000CE74
		private void Awake()
		{
			this.mesh = new Mesh();
		}

		// Token: 0x0600014E RID: 334 RVA: 0x0000EA84 File Offset: 0x0000CE84
		public override bool CheckResources()
		{
			base.CheckSupport(false);
			this.noiseMaterial = base.CheckShaderAndCreateMaterial(this.noiseShader, this.noiseMaterial);
			if (this.dx11Grain && this.supportDX11)
			{
				this.dx11NoiseMaterial = base.CheckShaderAndCreateMaterial(this.dx11NoiseShader, this.dx11NoiseMaterial);
			}
			if (!this.isSupported)
			{
				base.ReportAutoDisable();
			}
			return this.isSupported;
		}

		// Token: 0x0600014F RID: 335 RVA: 0x0000EAF8 File Offset: 0x0000CEF8
		private void OnRenderImage(RenderTexture source, RenderTexture destination)
		{
			if (!this.CheckResources() || null == this.noiseTexture)
			{
				Graphics.Blit(source, destination);
				if (null == this.noiseTexture)
				{
					Debug.LogWarning("Noise & Grain effect failing as noise texture is not assigned. please assign.", base.transform);
				}
				return;
			}
			this.softness = Mathf.Clamp(this.softness, 0f, 0.99f);
			if (this.dx11Grain && this.supportDX11)
			{
				this.dx11NoiseMaterial.SetFloat("_DX11NoiseTime", (float)Time.frameCount);
				this.dx11NoiseMaterial.SetTexture("_NoiseTex", this.noiseTexture);
				this.dx11NoiseMaterial.SetVector("_NoisePerChannel", (!this.monochrome) ? this.intensities : Vector3.one);
				this.dx11NoiseMaterial.SetVector("_MidGrey", new Vector3(this.midGrey, 1f / (1f - this.midGrey), -1f / this.midGrey));
				this.dx11NoiseMaterial.SetVector("_NoiseAmount", new Vector3(this.generalIntensity, this.blackIntensity, this.whiteIntensity) * this.intensityMultiplier);
				if (this.softness > Mathf.Epsilon)
				{
					RenderTexture temporary = RenderTexture.GetTemporary((int)((float)source.width * (1f - this.softness)), (int)((float)source.height * (1f - this.softness)));
					NoiseAndGrain.DrawNoiseQuadGrid(source, temporary, this.dx11NoiseMaterial, this.noiseTexture, this.mesh, (!this.monochrome) ? 2 : 3);
					this.dx11NoiseMaterial.SetTexture("_NoiseTex", temporary);
					Graphics.Blit(source, destination, this.dx11NoiseMaterial, 4);
					RenderTexture.ReleaseTemporary(temporary);
				}
				else
				{
					NoiseAndGrain.DrawNoiseQuadGrid(source, destination, this.dx11NoiseMaterial, this.noiseTexture, this.mesh, (!this.monochrome) ? 0 : 1);
				}
			}
			else
			{
				if (this.noiseTexture)
				{
					this.noiseTexture.wrapMode = TextureWrapMode.Repeat;
					this.noiseTexture.filterMode = this.filterMode;
				}
				this.noiseMaterial.SetTexture("_NoiseTex", this.noiseTexture);
				this.noiseMaterial.SetVector("_NoisePerChannel", (!this.monochrome) ? this.intensities : Vector3.one);
				this.noiseMaterial.SetVector("_NoiseTilingPerChannel", (!this.monochrome) ? this.tiling : (Vector3.one * this.monochromeTiling));
				this.noiseMaterial.SetVector("_MidGrey", new Vector3(this.midGrey, 1f / (1f - this.midGrey), -1f / this.midGrey));
				this.noiseMaterial.SetVector("_NoiseAmount", new Vector3(this.generalIntensity, this.blackIntensity, this.whiteIntensity) * this.intensityMultiplier);
				if (this.softness > Mathf.Epsilon)
				{
					RenderTexture temporary2 = RenderTexture.GetTemporary((int)((float)source.width * (1f - this.softness)), (int)((float)source.height * (1f - this.softness)));
					NoiseAndGrain.DrawNoiseQuadGrid(source, temporary2, this.noiseMaterial, this.noiseTexture, this.mesh, 2);
					this.noiseMaterial.SetTexture("_NoiseTex", temporary2);
					Graphics.Blit(source, destination, this.noiseMaterial, 1);
					RenderTexture.ReleaseTemporary(temporary2);
				}
				else
				{
					NoiseAndGrain.DrawNoiseQuadGrid(source, destination, this.noiseMaterial, this.noiseTexture, this.mesh, 0);
				}
			}
		}

		// Token: 0x06000150 RID: 336 RVA: 0x0000EED4 File Offset: 0x0000D2D4
		private static void DrawNoiseQuadGrid(RenderTexture source, RenderTexture dest, Material fxMaterial, Texture2D noise, Mesh mesh, int passNr)
		{
			RenderTexture.active = dest;
			fxMaterial.SetTexture("_MainTex", source);
			GL.PushMatrix();
			GL.LoadOrtho();
			fxMaterial.SetPass(passNr);
			NoiseAndGrain.BuildMesh(mesh, source, noise);
			Transform transform = Camera.main.transform;
			Vector3 position = transform.position;
			Quaternion rotation = transform.rotation;
			transform.position = Vector3.zero;
			transform.rotation = Quaternion.identity;
			Graphics.DrawMeshNow(mesh, Matrix4x4.identity);
			transform.position = position;
			transform.rotation = rotation;
			GL.PopMatrix();
		}

		// Token: 0x06000151 RID: 337 RVA: 0x0000EF60 File Offset: 0x0000D360
		private static void BuildMesh(Mesh mesh, RenderTexture source, Texture2D noise)
		{
			float num = (float)noise.width * 1f;
			float num2 = 1f * (float)source.width / NoiseAndGrain.TILE_AMOUNT;
			float num3 = 1f * (float)source.width / (1f * (float)source.height);
			float num4 = 1f / num2;
			float num5 = num4 * num3;
			int num6 = (int)Mathf.Ceil(num2);
			int num7 = (int)Mathf.Ceil(1f / num5);
			if (mesh.vertices.Length != num6 * num7 * 4)
			{
				Vector3[] array = new Vector3[num6 * num7 * 4];
				Vector2[] array2 = new Vector2[num6 * num7 * 4];
				int[] array3 = new int[num6 * num7 * 6];
				int num8 = 0;
				int num9 = 0;
				for (float num10 = 0f; num10 < 1f; num10 += num4)
				{
					for (float num11 = 0f; num11 < 1f; num11 += num5)
					{
						array[num8] = new Vector3(num10, num11, 0.1f);
						array[num8 + 1] = new Vector3(num10 + num4, num11, 0.1f);
						array[num8 + 2] = new Vector3(num10 + num4, num11 + num5, 0.1f);
						array[num8 + 3] = new Vector3(num10, num11 + num5, 0.1f);
						array2[num8] = new Vector2(0f, 0f);
						array2[num8 + 1] = new Vector2(1f, 0f);
						array2[num8 + 2] = new Vector2(1f, 1f);
						array2[num8 + 3] = new Vector2(0f, 1f);
						array3[num9] = num8;
						array3[num9 + 1] = num8 + 1;
						array3[num9 + 2] = num8 + 2;
						array3[num9 + 3] = num8;
						array3[num9 + 4] = num8 + 2;
						array3[num9 + 5] = num8 + 3;
						num8 += 4;
						num9 += 6;
					}
				}
				mesh.vertices = array;
				mesh.uv2 = array2;
				mesh.triangles = array3;
			}
			NoiseAndGrain.BuildMeshUV0(mesh, num6, num7, num, noise.width);
		}

		// Token: 0x06000152 RID: 338 RVA: 0x0000F1C0 File Offset: 0x0000D5C0
		private static void BuildMeshUV0(Mesh mesh, int width, int height, float noiseSize, int noiseWidth)
		{
			float num = noiseSize / ((float)noiseWidth * 1f);
			float num2 = 1f / noiseSize;
			Vector2[] array = new Vector2[width * height * 4];
			int num3 = 0;
			for (int i = 0; i < width * height; i++)
			{
				float num4 = global::UnityEngine.Random.Range(0f, noiseSize);
				float num5 = global::UnityEngine.Random.Range(0f, noiseSize);
				num4 = Mathf.Floor(num4) * num2;
				num5 = Mathf.Floor(num5) * num2;
				array[num3] = new Vector2(num4, num5);
				array[num3 + 1] = new Vector2(num4 + num * num2, num5);
				array[num3 + 2] = new Vector2(num4 + num * num2, num5 + num * num2);
				array[num3 + 3] = new Vector2(num4, num5 + num * num2);
				num3 += 4;
			}
			mesh.uv = array;
		}

		// Token: 0x040002D5 RID: 725
		public float intensityMultiplier = 0.25f;

		// Token: 0x040002D6 RID: 726
		public float generalIntensity = 0.5f;

		// Token: 0x040002D7 RID: 727
		public float blackIntensity = 1f;

		// Token: 0x040002D8 RID: 728
		public float whiteIntensity = 1f;

		// Token: 0x040002D9 RID: 729
		public float midGrey = 0.2f;

		// Token: 0x040002DA RID: 730
		public bool dx11Grain;

		// Token: 0x040002DB RID: 731
		public float softness;

		// Token: 0x040002DC RID: 732
		public bool monochrome;

		// Token: 0x040002DD RID: 733
		public Vector3 intensities = new Vector3(1f, 1f, 1f);

		// Token: 0x040002DE RID: 734
		public Vector3 tiling = new Vector3(64f, 64f, 64f);

		// Token: 0x040002DF RID: 735
		public float monochromeTiling = 64f;

		// Token: 0x040002E0 RID: 736
		public FilterMode filterMode = FilterMode.Bilinear;

		// Token: 0x040002E1 RID: 737
		public Texture2D noiseTexture;

		// Token: 0x040002E2 RID: 738
		public Shader noiseShader;

		// Token: 0x040002E3 RID: 739
		private Material noiseMaterial;

		// Token: 0x040002E4 RID: 740
		public Shader dx11NoiseShader;

		// Token: 0x040002E5 RID: 741
		private Material dx11NoiseMaterial;

		// Token: 0x040002E6 RID: 742
		private static float TILE_AMOUNT = 64f;

		// Token: 0x040002E7 RID: 743
		private Mesh mesh;
	}
}