using System;
using System.Collections.Generic;
using System.Reflection;
using UnityEngine;
using UnityEngine.Rendering;

namespace LOS
{
	// Token: 0x02000110 RID: 272
	[RequireComponent(typeof(Camera))]
	public class PointLightShadows : MonoBehaviour
	{
		// Token: 0x17000057 RID: 87
		// (get) Token: 0x06001655 RID: 5717 RVA: 0x0019DCAF File Offset: 0x0019BEAF
		public static Plane[] CameraFrustumPlanes
		{
			get
			{
				return PointLightShadows.m_CameraFrustumPlanes;
			}
		}

		// Token: 0x06001656 RID: 5718 RVA: 0x0019DCB6 File Offset: 0x0019BEB6
		private void Awake()
		{
			this.m_Camera = base.GetComponent<Camera>();
			this.pointLightObject.SetActive(false);
		}

		// Token: 0x06001657 RID: 5719 RVA: 0x0019DCD0 File Offset: 0x0019BED0
		private void OnEnable()
		{
			LOSHelper.ExtractFrustumPlanes(PointLightShadows.m_CameraFrustumPlanes, this.m_Camera);
		}

		// Token: 0x06001658 RID: 5720 RVA: 0x0019DCE2 File Offset: 0x0019BEE2
		private void OnDisable()
		{
			Materials.DestroyResources();
			Shaders.DestroyResources();
			if (this.buffer != null)
			{
				this.m_Camera.RemoveCommandBuffer(CameraEvent.AfterDepthTexture, this.buffer);
			}
		}

		// Token: 0x06001659 RID: 5721 RVA: 0x0019DD08 File Offset: 0x0019BF08
		private void CreateCombineTexture()
		{
			this.width = Screen.width;
			this.height = Screen.height;
			if (this.combinedLights)
			{
				this.combinedLights.Release();
			}
			this.combinedLights = new RenderTexture(this.width, this.height, 16, RenderTextureFormat.R8);
			if (this.combinedLights2)
			{
				this.combinedLights2.Release();
			}
			this.combinedLights2 = new RenderTexture(this.width, this.height, 16, RenderTextureFormat.R8);
		}

		// Token: 0x0600165A RID: 5722 RVA: 0x0019DD91 File Offset: 0x0019BF91
		private float GetCamDistance(int id)
		{
			if (id < this.cameraDistance.Count)
			{
				return this.cameraDistance[id];
			}
			return 0f;
		}

		// Token: 0x0600165B RID: 5723 RVA: 0x0019DDB3 File Offset: 0x0019BFB3
		private Vector3 GetCamPosition(int id)
		{
			if (id < this.cameraPosition.Count)
			{
				return this.cameraPosition[id];
			}
			return Vector3.zero;
		}

		// Token: 0x0600165C RID: 5724 RVA: 0x0019DDD8 File Offset: 0x0019BFD8
		public void Buffer()
		{
			if (this.buffer == null)
			{
				this.buffer = new CommandBuffer();
				this.buffer.name = "Quad Shadows";
				this.m_Camera.AddCommandBuffer(CameraEvent.AfterDepthTexture, this.buffer);
			}
			this.buffer.Clear();
			if (Links.x && Links.x.cameraEffects)
			{
				if (this.quadW != Screen.width || this.quadH != Screen.height || !this.quadShadowTexture)
				{
					if (this.quadShadowTexture)
					{
						this.quadShadowTexture.Release();
					}
					if (this.quadShadowTextureFinal)
					{
						this.quadShadowTextureFinal.Release();
					}
					this.quadW = Screen.width;
					this.quadH = Screen.height;
					this.quadShadowTexture = new RenderTexture(this.quadW, this.quadH, 16, RenderTextureFormat.R8);
				}
				RenderTargetIdentifier renderTargetIdentifier = new RenderTargetIdentifier(this.quadShadowTexture);
				this.buffer.SetRenderTarget(renderTargetIdentifier);
				this.buffer.ClearRenderTarget(true, true, Color.clear);
				if (!this.switchingScenes)
				{
					for (int i = 0; i < this.quadsToRender.Count; i++)
					{
						if (this.quadsToRender[i])
						{
							if (!Links.x.cameraEffects.indoors)
							{
								this.buffer.DrawRenderer(this.quadsToRender[i], this.quadMats[i], 0, 0);
							}
							else
							{
								this.buffer.DrawRenderer(this.quadsToRender[i], this.quadMats[i], 0, 0);
							}
						}
					}
				}
				this.buffer.SetGlobalTexture("_QuadShadows", this.quadShadowTexture);
			}
		}

		// Token: 0x0600165D RID: 5725 RVA: 0x0019DFAC File Offset: 0x0019C1AC
		public void SwitchingScenes()
		{
			Shader.SetGlobalTexture("_RealtimeShadowTex", Links.x.emptyTexture);
			this.switchingScenes = true;
			for (int i = 0; i < this.quadMats.Count; i++)
			{
				Object.Destroy(this.quadMats[i]);
			}
			this.quadMats.Clear();
			this.quadsToRender.Clear();
		}

		// Token: 0x0600165E RID: 5726 RVA: 0x0019E011 File Offset: 0x0019C211
		public void DoneSwitchingScenes()
		{
			this.switchingScenes = false;
		}

		// Token: 0x0600165F RID: 5727 RVA: 0x0019E01A File Offset: 0x0019C21A
		private void OnPreRender()
		{
			if (this.width != Screen.width || this.height != Screen.height)
			{
				this.CreateCombineTexture();
			}
			this.Buffer();
		}

		// Token: 0x06001660 RID: 5728 RVA: 0x0019E044 File Offset: 0x0019C244
		private void Update()
		{
			if (Links.x && Links.x.diorama)
			{
				if (this.quads == null)
				{
					this.quads = Links.x.quads;
				}
				if (this.quads != null && !this.switchingScenes)
				{
					this.quadsToRender.Clear();
					int num = 0;
					int count = this.quads.Count;
					this.planes = GeometryUtility.CalculateFrustumPlanes(Links.x.worldCamera);
					for (int i = 0; i < count; i++)
					{
						if (this.quads[i].isOn)
						{
							MeshRenderer art = this.quads[i].art;
							if (art && art.enabled && this.TestPlanesAABBInternalFastBounds(this.quads[i].art.bounds.min, this.quads[i].art.bounds.max))
							{
								this.quadsToRender.Add(art);
								if (this.quadMats.Count < this.quadsToRender.Count)
								{
									Material material = new Material(this.quadShader);
									this.quadMats.Add(material);
								}
								else
								{
									Material material2 = this.quadMats[num];
								}
								num++;
							}
						}
					}
				}
			}
		}

		// Token: 0x06001661 RID: 5729 RVA: 0x0019E1B9 File Offset: 0x0019C3B9
		public void SetupNewInterior(InteriorLights l)
		{
		}

		// Token: 0x06001662 RID: 5730 RVA: 0x0019E1BC File Offset: 0x0019C3BC
		private void RenderSourceToMask(LOSSource losSource, int num, Vector3 center)
		{
			Camera camera = losSource.SourceCamera;
			if (!camera)
			{
				camera = losSource.gameObject.GetComponent<Camera>();
				losSource.SetCamera(camera);
			}
			int num2 = this.currentLightIndex * 6;
			if (num + num2 < this.savedTextures.Count)
			{
				Materials.SkyBox.SetVector(ShaderID.FarPlane, new Vector4(camera.farClipPlane, camera.farClipPlane, camera.farClipPlane, camera.farClipPlane));
				camera.targetTexture = this.savedTextures[num + num2];
				FieldInfo field = typeof(Canvas).GetField("willRenderCanvases", BindingFlags.Static | BindingFlags.NonPublic);
				object value = field.GetValue(null);
				field.SetValue(null, null);
				camera.RenderWithShader(Shaders.Depth, null);
				field.SetValue(null, value);
				this.sourcePositions[num + num2] = losSource.gameObject.transform.position + losSource.gameObject.transform.forward;
				this.projectionMatrix[num + num2] = camera.projectionMatrix * camera.worldToCameraMatrix;
			}
		}

		// Token: 0x06001663 RID: 5731 RVA: 0x0019E2D4 File Offset: 0x0019C4D4
		public bool TestPlanesAABBInternalFastBounds(Vector3 boundsMin, Vector3 boundsMax)
		{
			for (int i = 0; i < this.planes.Length; i++)
			{
				Vector3 normal = this.planes[i].normal;
				float distance = this.planes[i].distance;
				Vector3 vector;
				Vector3 vector2;
				if (normal.x < 0f)
				{
					vector.x = boundsMin.x;
					vector2.x = boundsMax.x;
				}
				else
				{
					vector.x = boundsMax.x;
					vector2.x = boundsMin.x;
				}
				if (normal.y < 0f)
				{
					vector.y = boundsMin.y;
					vector2.y = boundsMax.y;
				}
				else
				{
					vector.y = boundsMax.y;
					vector2.y = boundsMin.y;
				}
				if (normal.z < 0f)
				{
					vector.z = boundsMin.z;
					vector2.z = boundsMax.z;
				}
				else
				{
					vector.z = boundsMax.z;
					vector2.z = boundsMin.z;
				}
				if (normal.x * vector.x + normal.y * vector.y + normal.z * vector.z + distance < 0f)
				{
					return false;
				}
			}
			return true;
		}

		// Token: 0x0400264A RID: 9802
		public int texSize = 512;

		// Token: 0x0400264B RID: 9803
		private static Plane[] m_CameraFrustumPlanes = new Plane[6];

		// Token: 0x0400264C RID: 9804
		public List<LOSSource> casters = new List<LOSSource>();

		// Token: 0x0400264D RID: 9805
		private Camera m_Camera;

		// Token: 0x0400264E RID: 9806
		public List<float> cameraDistance = new List<float>();

		// Token: 0x0400264F RID: 9807
		public List<Vector3> cameraPosition = new List<Vector3>();

		// Token: 0x04002650 RID: 9808
		public List<Matrix4x4> projectionMatrix = new List<Matrix4x4>();

		// Token: 0x04002651 RID: 9809
		public List<RenderTexture> savedTextures = new List<RenderTexture>();

		// Token: 0x04002652 RID: 9810
		public List<Vector3> sourcePositions = new List<Vector3>();

		// Token: 0x04002653 RID: 9811
		private CommandBuffer buffer;

		// Token: 0x04002654 RID: 9812
		public GameObject pointLightObject;

		// Token: 0x04002655 RID: 9813
		public Light currentLight;

		// Token: 0x04002656 RID: 9814
		private int width;

		// Token: 0x04002657 RID: 9815
		private int height;

		// Token: 0x04002658 RID: 9816
		private int quadW;

		// Token: 0x04002659 RID: 9817
		private int quadH;

		// Token: 0x0400265A RID: 9818
		public RenderTexture combinedLights;

		// Token: 0x0400265B RID: 9819
		public RenderTexture combinedLights2;

		// Token: 0x0400265C RID: 9820
		public RenderTexture quadShadowTexture;

		// Token: 0x0400265D RID: 9821
		public RenderTexture quadShadowTextureFinal;

		// Token: 0x0400265E RID: 9822
		public Material combineMaterial;

		// Token: 0x0400265F RID: 9823
		public int currentLightIndex;

		// Token: 0x04002660 RID: 9824
		public int savedLight1;

		// Token: 0x04002661 RID: 9825
		public int savedLight2;

		// Token: 0x04002662 RID: 9826
		public int savedLight3;

		// Token: 0x04002663 RID: 9827
		public InteriorLights currentInteriorLight;

		// Token: 0x04002664 RID: 9828
		private List<Light> lights;

		// Token: 0x04002665 RID: 9829
		public bool baking;

		// Token: 0x04002666 RID: 9830
		private List<Culling> quads;

		// Token: 0x04002667 RID: 9831
		public List<MeshRenderer> quadsToRender = new List<MeshRenderer>();

		// Token: 0x04002668 RID: 9832
		private Plane[] planes = new Plane[0];

		// Token: 0x04002669 RID: 9833
		public List<Material> quadMats = new List<Material>();

		// Token: 0x0400266A RID: 9834
		public Shader quadShader;

		// Token: 0x0400266B RID: 9835
		public bool switchingScenes;
	}
}