using System;
using System.Collections.Generic;
using UnityEngine;

namespace Artngame.GIPROXY
{
	public class LightCollisionsPDM : MonoBehaviour
	{
		public bool check_secondary_collisions;

		public bool meet_half_way;

		public bool Disable_on_tag;

		public List<string> Disable_Tags = new List<string>();

		public bool Disable_on_layer;

		public List<string> Disable_Layers = new List<string>();

		public bool Set_light_mask;

		public LayerMask Bounce_light_mask;

		public bool Cut_below_height;

		public float Cut_height;

		public bool Preview;

		public bool SecondBounce;

		private int Cycle_ID;

		private int Cycle_ID1;

		public bool Not_important_2ond;

		public bool use_light_sampling;

		public float sampling_dist = 15f;

		public bool use_grid;

		public int max_positions = 10;

		private List<Vector3> ray_dest_positions = new List<Vector3>();

		private List<Vector3> sphere_dest_positions = new List<Vector3>();

		private bool got_random_offsets;

		public float extend_X = 1f;

		public float extend_Y = 1f;

		private bool randomize;

		private Vector2[] rand_offsets;

		public bool go_random;

		public int hor_directions = 5;

		public int ver_directions = 5;

		public float PointLight_Radius = 10f;

		public float PointLight_Radius_2ond = 10f;

		public float Update_Color_Dist = 1f;

		public bool Follow_Hero;

		public Transform HERO;

		public bool Tag_based_player;

		public string Player_tag = "Player";

		private Vector3 Hero_Dist;

		public Vector3 Hero_offset = new Vector3(0f, 0f, 0f);

		private bool Hero_has_been_set;

		private Transform LightTransform;

		private float current_time;

		[HideInInspector]
		public List<int> Lights_level;

		[HideInInspector]
		public List<Transform> Lights_source;

		[HideInInspector]
		public List<Transform> Lights;

		[HideInInspector]
		public List<Color> Lights_destination_color;

		public float Divide_init_intensity = 5f;

		public float Bounce_Intensity = 5f;

		public float Bounce_Range = 230f;

		public float Degrade_speed = 0.6f;

		public float Appear_speed = 2f;

		public float min_dist_to_last_light = 10f;

		public float min_dist_to_source = 10f;

		public float min_density_dist = 1f;

		public bool Enable_follow;

		public float Follow_dist = 10f;

		public float Follow_speed = 10f;

		public Color Bounce_color;

		private Vector3 Start_light_pos;

		public bool Jitter_directional;

		public float bound_up_down = 50f;

		public float HDR_drop_speed = 1f;

		public bool get_hit_color;

		public bool get_texture_color;

		public bool mix_colors;

		public bool dynamic_update_color;

		public float Color_change_speed = 0.5f;

		public bool Soften_color_change;

		public bool Use_light_color;

		public bool Debug_on;

		public bool Debug_2ond;

		public bool add_only_when_seen;

		private Transform CameraTransform;

		public bool close_to_camera;

		public float min_dist_to_camera = 10f;

		public float max_hit_light_dist = 10f;

		public bool Give_Offset;

		public float placement_offset = 5f;

		public bool Origin_at_Projector;

		public Transform Projector_OBJ;

		public GameObject LightPool;

		public float Update_every = 0.1f;

		public bool Use_Height_cut_off;

		public float Cut_off_height = 15f;

		public float floor_if_no_hero;

		public bool Jove_Lights;

		public bool Grab_Skylight;

		public bool Rotate_grid;

		public float Sky_influence = 0.05f;

		public GameObject Sky;

		public bool offset_on_normal;

		private void Start()
		{
			if (Tag_based_player)
			{
				if (HERO == null)
				{
					HERO = GameObject.FindGameObjectWithTag(Player_tag).transform;
				}
			}
			else if (HERO == null)
			{
				HERO = Camera.main.transform;
			}
			LightTransform = GetComponent<Light>().transform;
			Bounce_color = GetComponent<Light>().color;
			Start_light_pos = LightTransform.position;
			CameraTransform = Camera.main.transform;
			current_time = Time.fixedTime;
		}

		private void Update()
		{
			if (!LightPool.activeInHierarchy)
			{
				LightPool.SetActive(value: true);
			}
			if (Cut_below_height && Projector_OBJ.position.y < Cut_height)
			{
				if (LightPool.activeInHierarchy)
				{
					LightPool.SetActive(value: false);
				}
			}
			else
			{
				if (!(Time.fixedTime - current_time > Update_every))
				{
					return;
				}
				current_time = Time.fixedTime;
				float num = Color_change_speed;
				if ((GetComponent<Light>().type == LightType.Point) | Soften_color_change)
				{
					num = Color_change_speed * Time.deltaTime;
				}
				Vector3 vector = new Vector3(0f, 0f, 0f);
				if (Follow_Hero)
				{
					if (Tag_based_player)
					{
						if (HERO == null)
						{
							HERO = GameObject.FindGameObjectWithTag(Player_tag).transform;
						}
					}
					else if (HERO == null)
					{
						HERO = Camera.main.transform;
					}
					if ((HERO != null) & !Hero_has_been_set)
					{
						Vector3 position = LightTransform.position;
						Vector3 forward = LightTransform.forward;
						RaycastHit hitInfo = default(RaycastHit);
						if (Physics.Raycast(position, forward, out hitInfo, float.PositiveInfinity))
						{
							Hero_Dist = hitInfo.point - HERO.position;
							Hero_has_been_set = true;
						}
					}
					if (HERO != null)
					{
						Vector3 position2 = LightTransform.position;
						Vector3 forward2 = LightTransform.forward;
						RaycastHit hitInfo2 = default(RaycastHit);
						if (Physics.Raycast(position2, forward2, out hitInfo2, float.PositiveInfinity))
						{
							Hero_Dist = hitInfo2.point - HERO.position;
						}
						vector = -Hero_Dist + Hero_offset;
					}
				}
				Vector3 vector2 = LightTransform.position + vector;
				Vector3 forward3 = LightTransform.forward;
				if (Origin_at_Projector)
				{
					if (Projector_OBJ != null)
					{
						vector2 = Projector_OBJ.position + vector;
						forward3 = Projector_OBJ.forward;
					}
					else
					{
						Debug.Log("Please insert the projector gameobject to the script");
					}
				}
				if ((GetComponent<Light>().type == LightType.Directional) & Jitter_directional)
				{
					vector2 = ((!(vector2.y > Start_light_pos.y)) ? new Vector3(vector2.x, vector2.y + bound_up_down * Time.deltaTime, vector2.z) : new Vector3(vector2.x, vector2.y - bound_up_down / 10f * Time.deltaTime, vector2.z));
				}
				for (int num2 = Lights.Count - 1; num2 >= 0; num2--)
				{
					if (Lights[num2] == null)
					{
						if (SecondBounce)
						{
							for (int i = 0; i < Lights.Count; i++)
							{
								if ((Lights_source[i] == Lights[num2]) & (Lights_level[i] > 1))
								{
									Lights[i].GetComponent<Light>().intensity = 0f;
									UnityEngine.Object.Destroy(Lights[i].gameObject);
									Lights.RemoveAt(i);
									Lights_destination_color.RemoveAt(i);
									Lights_level.RemoveAt(i);
									Lights_source.RemoveAt(i);
								}
							}
						}
						Lights.RemoveAt(num2);
						Lights_destination_color.RemoveAt(num2);
						Lights_level.RemoveAt(num2);
						Lights_source.RemoveAt(num2);
					}
					else if (Lights[num2].GetComponent<Light>().intensity == 0f)
					{
						if (SecondBounce)
						{
							for (int j = 0; j < Lights.Count; j++)
							{
								if ((Lights_source[j] == Lights[num2]) & (Lights_level[j] > 1))
								{
									Lights[j].GetComponent<Light>().intensity = 0f;
									UnityEngine.Object.Destroy(Lights[j].gameObject);
									Lights.RemoveAt(j);
									Lights_destination_color.RemoveAt(j);
									Lights_level.RemoveAt(j);
									Lights_source.RemoveAt(j);
								}
							}
						}
						UnityEngine.Object.Destroy(Lights[num2].gameObject);
						Lights.RemoveAt(num2);
						Lights_destination_color.RemoveAt(num2);
						Lights_level.RemoveAt(num2);
						Lights_source.RemoveAt(num2);
					}
				}
				if (!use_grid)
				{
					for (int num3 = Lights.Count - 1; num3 >= 0; num3--)
					{
						if (Debug_on)
						{
							Debug.DrawLine(Lights[num3].position, new Vector3(Lights[num3].position.x, Lights[num3].position.y + 15f, Lights[num3].position.z));
						}
						if (use_light_sampling && Lights_destination_color[num3] != Lights[num3].GetComponent<Light>().color)
						{
							Lights[num3].GetComponent<Light>().color = Color.Lerp(Lights[num3].GetComponent<Light>().color, Lights_destination_color[num3], num);
						}
						if (Vector3.Distance(Lights[num3].position, Lights[Lights.Count - 1].position) > min_dist_to_last_light)
						{
							if (Lights[num3].GetComponent<Light>().intensity > 0f)
							{
								if ((GetComponent<Light>().type != LightType.Point) & (Lights_level[num3] < 2))
								{
									Lights[num3].GetComponent<Light>().intensity -= Degrade_speed * Time.deltaTime;
									if (SecondBounce)
									{
										for (int k = 0; k < Lights.Count; k++)
										{
											if ((Lights_source[k] == Lights[num3]) & (Lights_level[k] > 1))
											{
												Lights[k].GetComponent<Light>().intensity -= 100f * Degrade_speed * Time.deltaTime;
											}
										}
									}
								}
							}
							else
							{
								if (SecondBounce)
								{
									for (int l = 0; l < Lights.Count; l++)
									{
										if ((Lights_source[l] == Lights[num3]) & (Lights_level[l] > 1))
										{
											Lights[l].GetComponent<Light>().intensity = 0f;
											UnityEngine.Object.Destroy(Lights[l].gameObject);
											Lights.RemoveAt(l);
											Lights_destination_color.RemoveAt(l);
											Lights_level.RemoveAt(l);
											Lights_source.RemoveAt(l);
										}
									}
								}
								UnityEngine.Object.Destroy(Lights[num3].gameObject);
								Lights.RemoveAt(num3);
								Lights_destination_color.RemoveAt(num3);
								Lights_level.RemoveAt(num3);
								Lights_source.RemoveAt(num3);
							}
						}
						else if (Vector3.Distance(Lights[num3].position, vector2) > min_dist_to_source)
						{
							if (Lights[num3].GetComponent<Light>().intensity > 0f)
							{
								if ((Lights[num3].GetComponent<Light>().type == LightType.Point) & (Lights_level[num3] < 2))
								{
									Lights[num3].GetComponent<Light>().intensity -= Degrade_speed * Time.deltaTime;
									if (SecondBounce)
									{
										for (int m = 0; m < Lights.Count; m++)
										{
											if ((Lights_source[m] == Lights[num3]) & (Lights_level[m] > 1))
											{
												Lights[m].GetComponent<Light>().intensity -= 100f * Degrade_speed * Time.deltaTime;
											}
										}
									}
								}
							}
							else
							{
								if (SecondBounce)
								{
									for (int n = 0; n < Lights.Count; n++)
									{
										if ((Lights_source[n] == Lights[num3]) & (Lights_level[n] > 1))
										{
											Lights[n].GetComponent<Light>().intensity = 0f;
											UnityEngine.Object.Destroy(Lights[n].gameObject);
											Lights.RemoveAt(n);
											Lights_destination_color.RemoveAt(n);
											Lights_level.RemoveAt(n);
											Lights_source.RemoveAt(n);
										}
									}
								}
								UnityEngine.Object.Destroy(Lights[num3].gameObject);
								Lights.RemoveAt(num3);
								Lights_destination_color.RemoveAt(num3);
								Lights_level.RemoveAt(num3);
								Lights_source.RemoveAt(num3);
							}
						}
						else
						{
							if ((Lights[num3].GetComponent<Light>().intensity < Bounce_Intensity) & (Lights_level[num3] < 2))
							{
								Lights[num3].GetComponent<Light>().intensity += Appear_speed * Time.deltaTime;
							}
							else if ((HDR_drop_speed > 0f) & (Lights[num3].GetComponent<Light>().intensity > Bounce_Intensity + 1f) & (Lights_level[num3] < 2))
							{
								Lights[num3].GetComponent<Light>().intensity -= HDR_drop_speed * Time.deltaTime;
							}
							if ((Lights[num3].GetComponent<Light>().intensity < Bounce_Intensity / (float)Lights_level[num3]) & (Lights_level[num3] >= 2))
							{
								Lights[num3].GetComponent<Light>().intensity += Appear_speed * Time.deltaTime;
							}
							else if ((HDR_drop_speed > 0f) & (Lights[num3].GetComponent<Light>().intensity > Bounce_Intensity / 2f + 1f) & (Lights_level[num3] >= 2))
							{
								Lights[num3].GetComponent<Light>().intensity -= HDR_drop_speed * Time.deltaTime;
							}
						}
					}
					if (Cycle_ID1 > Lights.Count - 1)
					{
						Cycle_ID1 = 0;
					}
					for (int num4 = Lights.Count - 1; num4 >= 0; num4--)
					{
						Cycle_ID1++;
						if (Cycle_ID1 > Lights.Count - 1)
						{
							Cycle_ID1 = 0;
						}
						RaycastHit hitInfo3 = default(RaycastHit);
						if (Physics.Raycast(vector2, forward3, out hitInfo3, float.PositiveInfinity))
						{
							Vector3 vector3 = new Vector3(0f, 0f, 0f);
							if (Vector3.Distance(b: (!Give_Offset) ? hitInfo3.point : ((!offset_on_normal) ? (hitInfo3.point + (vector2 - hitInfo3.point).normalized * placement_offset) : (hitInfo3.point + hitInfo3.normal.normalized * placement_offset)), a: Lights[num4].position) > max_hit_light_dist)
							{
								if (Lights[num4].GetComponent<Light>().intensity > 0f)
								{
									if ((GetComponent<Light>().type != LightType.Point) & (Lights_level[num4] < 2))
									{
										Lights[num4].GetComponent<Light>().intensity -= Degrade_speed * 10f * Time.deltaTime;
										if (SecondBounce)
										{
											for (int num5 = 0; num5 < Lights.Count; num5++)
											{
												if ((Lights_source[num5] == Lights[num4]) & (Lights_level[num5] > 1))
												{
													Lights[num5].GetComponent<Light>().intensity -= 100f * Degrade_speed * Time.deltaTime;
												}
											}
										}
									}
								}
								else
								{
									if (SecondBounce)
									{
										for (int num6 = 0; num6 < Lights.Count; num6++)
										{
											if ((Lights_source[num6] == Lights[num4]) & (Lights_level[num6] > 1))
											{
												Lights[num6].GetComponent<Light>().intensity = 0f;
												UnityEngine.Object.Destroy(Lights[num6].gameObject);
												Lights.RemoveAt(num6);
												Lights_destination_color.RemoveAt(num6);
												Lights_level.RemoveAt(num6);
												Lights_source.RemoveAt(num6);
											}
										}
									}
									UnityEngine.Object.Destroy(Lights[num4].gameObject);
									Lights.RemoveAt(num4);
									Lights_destination_color.RemoveAt(num4);
									Lights_level.RemoveAt(num4);
									Lights_source.RemoveAt(num4);
								}
							}
						}
					}
				}
				else
				{
					for (int num7 = Lights.Count - 1; num7 >= 0; num7--)
					{
						if (Debug_on)
						{
							Debug.DrawLine(Lights[num7].position, new Vector3(Lights[num7].position.x, Lights[num7].position.y + 15f, Lights[num7].position.z));
						}
						if (Vector3.Distance(Lights[num7].position, vector2) > min_dist_to_source)
						{
							if (Lights[num7].GetComponent<Light>().intensity > 0f)
							{
								if ((GetComponent<Light>().type == LightType.Point) & (Lights_level[num7] < 2))
								{
									Lights[num7].GetComponent<Light>().intensity -= Degrade_speed * 10f * Time.deltaTime;
									if (SecondBounce)
									{
										for (int num8 = 0; num8 < Lights.Count; num8++)
										{
											if ((Lights_source[num8] == Lights[num7]) & (Lights_level[num8] > 1))
											{
												Lights[num8].GetComponent<Light>().intensity -= 100f * Degrade_speed * Time.deltaTime;
											}
										}
									}
								}
							}
							else if (GetComponent<Light>().type == LightType.Point)
							{
								if (SecondBounce)
								{
									for (int num9 = 0; num9 < Lights.Count; num9++)
									{
										if ((Lights_source[num9] == Lights[num7]) & (Lights_level[num9] > 1))
										{
											Lights[num9].GetComponent<Light>().intensity = 0f;
											UnityEngine.Object.Destroy(Lights[num9].gameObject);
											Lights.RemoveAt(num9);
											Lights_destination_color.RemoveAt(num9);
											Lights_level.RemoveAt(num9);
											Lights_source.RemoveAt(num9);
										}
									}
								}
								UnityEngine.Object.Destroy(Lights[num7].gameObject);
								Lights.RemoveAt(num7);
								Lights_destination_color.RemoveAt(num7);
								Lights_level.RemoveAt(num7);
								Lights_source.RemoveAt(num7);
							}
						}
						else
						{
							if ((Lights[num7].GetComponent<Light>().intensity < Bounce_Intensity) & (Lights_level[num7] < 2))
							{
								Lights[num7].GetComponent<Light>().intensity += Appear_speed * Time.deltaTime;
							}
							else if ((HDR_drop_speed > 0f) & (Lights[num7].GetComponent<Light>().intensity > Bounce_Intensity + 1f) & (Lights_level[num7] < 2))
							{
								Lights[num7].GetComponent<Light>().intensity -= HDR_drop_speed * Time.deltaTime;
							}
							if ((Lights[num7].GetComponent<Light>().intensity < Bounce_Intensity / (float)Lights_level[num7]) & (Lights_level[num7] >= 2))
							{
								Lights[num7].GetComponent<Light>().intensity += Appear_speed * Time.deltaTime;
							}
							else if ((HDR_drop_speed > 0f) & (Lights[num7].GetComponent<Light>().intensity > Bounce_Intensity / 2f + 1f) & (Lights_level[num7] >= 2))
							{
								Lights[num7].GetComponent<Light>().intensity -= HDR_drop_speed * Time.deltaTime;
							}
						}
					}
					if (Cycle_ID1 > Lights.Count - 1)
					{
						Cycle_ID1 = 0;
					}
					for (int num10 = Lights.Count - 1; num10 >= 0; num10--)
					{
						Cycle_ID1++;
						if (Cycle_ID1 > Lights.Count - 1)
						{
							Cycle_ID1 = 0;
						}
						if (GetComponent<Light>().type == LightType.Point)
						{
							Vector3 vector4 = Lights[num10].position - vector2;
							Vector3 origin = vector2;
							RaycastHit hitInfo4 = default(RaycastHit);
							if (Physics.Raycast(origin, vector4, out hitInfo4, float.PositiveInfinity))
							{
								Vector3 vector5 = new Vector3(0f, 0f, 0f);
								if (Vector3.Distance(b: (!Give_Offset) ? hitInfo4.point : ((!offset_on_normal) ? (hitInfo4.point + (vector2 - hitInfo4.point).normalized * placement_offset) : (hitInfo4.point + hitInfo4.normal.normalized * placement_offset)), a: hitInfo4.point) < Update_Color_Dist)
								{
									Lights[num10].gameObject.GetComponent<Light>().color = Get_color(Lights[num10].gameObject, hitInfo4, num);
								}
							}
							if (Grab_Skylight)
							{
								RaycastHit hitInfo5 = default(RaycastHit);
								if (Physics.Raycast(origin, -vector4, out hitInfo5, float.PositiveInfinity))
								{
									bool flag = true;
									if (Sky != null && Sky.name != hitInfo5.collider.gameObject.name)
									{
										flag = false;
									}
									if (flag)
									{
										Lights[num10].gameObject.GetComponent<Light>().color = Get_color(Lights[num10].gameObject, hitInfo5, num * Sky_influence);
									}
									_ = Debug_on;
								}
							}
						}
						bool flag2 = true;
						for (int num11 = 0; num11 < ray_dest_positions.Count; num11++)
						{
							Vector3 direction = forward3;
							Vector3 origin2 = vector2 + ray_dest_positions[num11];
							RaycastHit hitInfo6 = default(RaycastHit);
							if (Physics.Raycast(origin2, direction, out hitInfo6, float.PositiveInfinity))
							{
								Vector3 vector6 = new Vector3(0f, 0f, 0f);
								if (Vector3.Distance(b: (!Give_Offset) ? hitInfo6.point : ((!offset_on_normal) ? (hitInfo6.point + (vector2 - hitInfo6.point).normalized * placement_offset) : (hitInfo6.point + hitInfo6.normal.normalized * placement_offset)), a: Lights[num10].position) < max_hit_light_dist)
								{
									flag2 = false;
								}
							}
						}
						if (flag2)
						{
							if (Lights[num10].GetComponent<Light>().intensity > 0f)
							{
								if ((GetComponent<Light>().type != LightType.Point) & (Lights_level[num10] < 2))
								{
									Lights[num10].GetComponent<Light>().intensity -= Degrade_speed * 10f * Time.deltaTime;
									if (SecondBounce)
									{
										for (int num12 = 0; num12 < Lights.Count; num12++)
										{
											if ((Lights_source[num12] == Lights[num10]) & (Lights_level[num12] > 1))
											{
												Lights[num12].GetComponent<Light>().intensity -= 100f * Degrade_speed * Time.deltaTime;
											}
										}
									}
								}
							}
							else
							{
								if (SecondBounce)
								{
									for (int num13 = 0; num13 < Lights.Count; num13++)
									{
										if ((Lights_source[num13] == Lights[num10]) & (Lights_level[num13] > 1))
										{
											Lights[num13].GetComponent<Light>().intensity = 0f;
											UnityEngine.Object.Destroy(Lights[num13].gameObject);
											Lights.RemoveAt(num13);
											Lights_destination_color.RemoveAt(num13);
											Lights_level.RemoveAt(num13);
											Lights_source.RemoveAt(num13);
										}
									}
								}
								UnityEngine.Object.Destroy(Lights[num10].gameObject);
								Lights.RemoveAt(num10);
								Lights_destination_color.RemoveAt(num10);
								Lights_level.RemoveAt(num10);
								Lights_source.RemoveAt(num10);
							}
						}
					}
				}
				if (use_grid & !got_random_offsets)
				{
					ray_dest_positions.Clear();
					int num14 = (int)Mathf.Sqrt(max_positions);
					if (!got_random_offsets)
					{
						got_random_offsets = true;
						rand_offsets = new Vector2[num14 * num14];
						int num15 = 0;
						for (int num16 = 0; num16 < num14; num16++)
						{
							for (int num17 = 0; num17 < num14; num17++)
							{
								rand_offsets[num15] = new Vector2(UnityEngine.Random.Range(0f, extend_X * (float)(num14 / 2) * (float)num16) + 1.5f * (float)num15, UnityEngine.Random.Range(0f, extend_Y * (float)(num14 / 2) * (float)num17) + 1.1f * (float)num15);
								num15++;
							}
						}
					}
					int num18 = 0;
					for (int num19 = 0; num19 < num14; num19++)
					{
						for (int num20 = 0; num20 < num14; num20++)
						{
							float num21 = extend_X * (float)(num14 / 2) * (float)num19;
							float num22 = extend_Y * (float)(num14 / 2) * (float)num20;
							if (randomize)
							{
								num21 += UnityEngine.Random.Range(0f, extend_X * (float)(num14 / 2) * (float)num19);
								num22 += UnityEngine.Random.Range(0f, extend_Y * (float)(num14 / 2) * (float)num20);
							}
							if (!go_random)
							{
								ray_dest_positions.Add(new Vector3(0f - num21, 0f, 0f - num22));
								ray_dest_positions.Add(new Vector3(num21, 0f, 0f - num22));
							}
							if (go_random)
							{
								ray_dest_positions.Add(new Vector3(0f - rand_offsets[num18].x, 0f, 0f - rand_offsets[num18].y));
								num18++;
							}
						}
					}
				}
				if (GetComponent<Light>() != null)
				{
					if ((GetComponent<Light>().type == LightType.Directional) | (GetComponent<Light>().type == LightType.Spot))
					{
						Vector3 vector7 = vector2;
						Vector3 vector8 = forward3;
						if (!use_grid & (ray_dest_positions.Count < 1))
						{
							ray_dest_positions.Add(new Vector3(0f, 0f, 0f));
						}
						for (int num23 = 0; num23 < ray_dest_positions.Count; num23++)
						{
							if (use_grid)
							{
								vector8 = forward3;
								vector7 = ((!Rotate_grid) ? (vector2 + ray_dest_positions[num23]) : ((!Origin_at_Projector) ? (vector2 + LightTransform.rotation * ray_dest_positions[num23]) : (vector2 + Projector_OBJ.transform.rotation * ray_dest_positions[num23])));
							}
							RaycastHit hitInfo7 = default(RaycastHit);
							if (!Physics.Raycast(vector7, vector8, out hitInfo7, float.PositiveInfinity))
							{
								continue;
							}
							Vector3 vector9 = new Vector3(0f, 0f, 0f);
							vector9 = ((!Give_Offset) ? hitInfo7.point : ((!offset_on_normal) ? (hitInfo7.point + (vector2 - hitInfo7.point).normalized * placement_offset) : (hitInfo7.point + hitInfo7.normal.normalized * placement_offset)));
							if (Debug_on)
							{
								Debug.DrawLine(vector7, vector9, Color.magenta);
							}
							if (check_secondary_collisions)
							{
								RaycastHit hitInfo8 = default(RaycastHit);
								if (Physics.Raycast(hitInfo7.point, vector9 - hitInfo7.point, out hitInfo8, (vector9 - hitInfo7.point).magnitude) && (hitInfo8.point - hitInfo7.point).magnitude < (vector9 - hitInfo7.point).magnitude)
								{
									vector9 = ((!meet_half_way) ? hitInfo7.point : (hitInfo7.point + (hitInfo8.point - hitInfo7.point).normalized * (hitInfo8.point - hitInfo7.point).magnitude / 2f));
								}
							}
							bool flag3 = true;
							bool flag4 = false;
							if (Lights.Count <= 0)
							{
								flag4 = true;
							}
							else
							{
								if (Enable_follow)
								{
									for (int num24 = Lights.Count - 1; num24 >= 0; num24--)
									{
										if (Vector3.Distance(Lights[num24].position, vector9) > Follow_dist)
										{
											Lights[num24].position = Vector3.Lerp(Lights[num24].position, vector9, Follow_speed * Time.deltaTime);
										}
									}
								}
								if (add_only_when_seen)
								{
									RaycastHit hitInfo9 = default(RaycastHit);
									if (Physics.Raycast(CameraTransform.position, vector9, out hitInfo9, float.PositiveInfinity) && hitInfo9.point.magnitude > 0f && Vector3.Distance(hitInfo9.point, CameraTransform.position) < Vector3.Distance(vector9, CameraTransform.position))
									{
										flag3 = false;
									}
								}
								if (close_to_camera && Vector3.Distance(CameraTransform.position, vector9) > min_dist_to_camera)
								{
									flag3 = false;
								}
								for (int num25 = Lights.Count - 1; num25 >= 0; num25--)
								{
									if (Vector3.Distance(Lights[num25].position, vector9) < min_density_dist)
									{
										flag3 = false;
									}
									if (dynamic_update_color & get_hit_color)
									{
										if (Vector3.Distance(Lights[num25].position, vector9) < min_density_dist)
										{
											Lights[num25].gameObject.GetComponent<Light>().color = Get_color(Lights[num25].gameObject, hitInfo7, num);
										}
										if (Grab_Skylight)
										{
											RaycastHit hitInfo10 = default(RaycastHit);
											if (Physics.Raycast(vector7, -vector8, out hitInfo10, float.PositiveInfinity))
											{
												bool flag5 = true;
												if (Sky != null && Sky.name != hitInfo10.collider.gameObject.name)
												{
													flag5 = false;
												}
												if (flag5)
												{
													Lights[num25].gameObject.GetComponent<Light>().color = Get_color(Lights[num25].gameObject, hitInfo10, num * Sky_influence);
												}
												if (Debug_on)
												{
													Debug.DrawLine(vector7, hitInfo10.point, Color.blue);
												}
											}
										}
									}
								}
							}
							if (Use_Height_cut_off)
							{
								if (Follow_Hero)
								{
									if (hitInfo7.point.y - HERO.position.y > Cut_off_height)
									{
										flag3 = false;
									}
								}
								else if (hitInfo7.point.y - floor_if_no_hero > Cut_off_height)
								{
									flag3 = false;
								}
							}
							if (Disable_on_tag)
							{
								for (int num26 = 0; num26 < Disable_Tags.Count; num26++)
								{
									if (hitInfo7.collider.gameObject.tag == Disable_Tags[num26])
									{
										flag3 = false;
									}
								}
							}
							if (Disable_on_layer)
							{
								for (int num27 = 0; num27 < Disable_Layers.Count; num27++)
								{
									if (LayerMask.LayerToName(hitInfo7.collider.gameObject.layer) == Disable_Layers[num27])
									{
										flag3 = false;
									}
								}
							}
							if (!((flag3 && !flag4) || flag4))
							{
								continue;
							}
							GameObject gameObject = new GameObject("Bounce Light");
							gameObject.AddComponent(typeof(Light));
							if (!get_hit_color)
							{
								if (!mix_colors)
								{
									gameObject.GetComponent<Light>().color = Bounce_color;
								}
								else
								{
									gameObject.GetComponent<Light>().color = Color.Lerp(Bounce_color, GetComponent<Light>().color, num);
								}
							}
							else
							{
								gameObject.GetComponent<Light>().color = Get_color(gameObject, hitInfo7, num);
							}
							gameObject.GetComponent<Light>().intensity = Bounce_Intensity / Divide_init_intensity;
							gameObject.GetComponent<Light>().range = Bounce_Range;
							gameObject.transform.position = vector9;
							if (Set_light_mask)
							{
								gameObject.GetComponent<Light>().cullingMask = Bounce_light_mask;
							}
							Lights_destination_color.Add(gameObject.GetComponent<Light>().color);
							Color color = gameObject.GetComponent<Light>().color;
							if (use_light_sampling)
							{
								for (int num28 = 0; num28 < Lights.Count; num28++)
								{
									if (Vector3.Distance(Lights[num28].position, vector9) < sampling_dist)
									{
										color = Color.Lerp(color, Lights[num28].GetComponent<Light>().color, 0.1f);
									}
								}
							}
							if (Grab_Skylight)
							{
								RaycastHit hitInfo11 = default(RaycastHit);
								if (Physics.Raycast(vector7, -vector8, out hitInfo11, float.PositiveInfinity))
								{
									bool flag6 = true;
									if (Sky != null && Sky.name != hitInfo11.collider.gameObject.name)
									{
										flag6 = false;
									}
									if (flag6)
									{
										color = Get_color(gameObject, hitInfo11, num * Sky_influence);
									}
									_ = Debug_on;
								}
							}
							gameObject.GetComponent<Light>().color = color;
							Lights.Add(gameObject.transform);
							if (Jove_Lights)
							{
								gameObject.AddComponent(typeof(Control_Jove_light));
							}
							Lights_level.Add(1);
							Lights_source.Add(LightTransform);
							gameObject.transform.parent = LightPool.transform;
						}
					}
					if (GetComponent<Light>().type == LightType.Point)
					{
						Vector3 vector10 = vector2;
						Vector3 direction2 = forward3;
						if (sphere_dest_positions != null && sphere_dest_positions.Count <= 0)
						{
							Vector3[] sphereDirections = GetSphereDirections(hor_directions * ver_directions);
							foreach (Vector3 item in sphereDirections)
							{
								sphere_dest_positions.Add(item);
							}
						}
						for (int num30 = 0; num30 < sphere_dest_positions.Count; num30++)
						{
							if (use_grid)
							{
								vector10 = vector2;
								direction2 = sphere_dest_positions[num30];
							}
							RaycastHit hitInfo12 = default(RaycastHit);
							if (!Physics.Raycast(vector10, direction2, out hitInfo12, min_dist_to_source - 1E-05f))
							{
								continue;
							}
							Vector3 vector11 = new Vector3(0f, 0f, 0f);
							vector11 = ((!Give_Offset) ? hitInfo12.point : ((!offset_on_normal) ? (hitInfo12.point + (vector2 - hitInfo12.point).normalized * placement_offset) : (hitInfo12.point + hitInfo12.normal.normalized * placement_offset)));
							if (Debug_on)
							{
								Debug.DrawLine(vector10, vector11, Color.magenta);
							}
							if (check_secondary_collisions)
							{
								RaycastHit hitInfo13 = default(RaycastHit);
								if (Physics.Raycast(hitInfo12.point, vector11 - hitInfo12.point, out hitInfo13, (vector11 - hitInfo12.point).magnitude) && (hitInfo13.point - hitInfo12.point).magnitude < (vector11 - hitInfo12.point).magnitude)
								{
									vector11 = ((!meet_half_way) ? hitInfo12.point : (hitInfo12.point + (hitInfo13.point - hitInfo12.point).normalized * (hitInfo13.point - hitInfo12.point).magnitude / 2f));
								}
							}
							bool flag7 = true;
							bool flag8 = false;
							if (Lights.Count <= 0)
							{
								flag8 = true;
							}
							else
							{
								if (Enable_follow)
								{
									for (int num31 = Lights.Count - 1; num31 >= 0; num31--)
									{
										if (Vector3.Distance(Lights[num31].position, vector11) > Follow_dist)
										{
											Lights[num31].position = Vector3.Lerp(Lights[num31].position, vector11, Follow_speed * Time.deltaTime);
										}
									}
								}
								if (add_only_when_seen)
								{
									RaycastHit hitInfo14 = default(RaycastHit);
									if (Physics.Raycast(CameraTransform.position, vector11, out hitInfo14, float.PositiveInfinity) && hitInfo14.point.magnitude > 0f && Vector3.Distance(hitInfo14.point, CameraTransform.position) < Vector3.Distance(vector11, CameraTransform.position))
									{
										flag7 = false;
									}
								}
								if (close_to_camera && Vector3.Distance(CameraTransform.position, vector11) > min_dist_to_camera)
								{
									flag7 = false;
								}
								for (int num32 = Lights.Count - 1; num32 >= 0; num32--)
								{
									if (Vector3.Distance(Lights[num32].position, vector11) < min_density_dist)
									{
										flag7 = false;
									}
									if ((dynamic_update_color & get_hit_color) && Vector3.Distance(Lights[num32].position, vector11) < min_density_dist / 2f)
									{
										Lights[num32].gameObject.GetComponent<Light>().color = Get_color(Lights[num32].gameObject, hitInfo12, num);
									}
								}
							}
							if (PointLight_Radius < 0f)
							{
								PointLight_Radius = 0f;
							}
							if (PointLight_Radius != 0f && !(Vector3.Distance(hitInfo12.point, GetComponent<Light>().transform.position) < PointLight_Radius))
							{
								flag7 = false;
							}
							if (Disable_on_tag)
							{
								for (int num33 = 0; num33 < Disable_Tags.Count; num33++)
								{
									if (hitInfo12.collider.gameObject.tag == Disable_Tags[num33])
									{
										flag7 = false;
									}
								}
							}
							if (Disable_on_layer)
							{
								for (int num34 = 0; num34 < Disable_Layers.Count; num34++)
								{
									if (LayerMask.LayerToName(hitInfo12.collider.gameObject.layer) == Disable_Layers[num34])
									{
										flag7 = false;
									}
								}
							}
							if (!((flag7 && !flag8) || flag8))
							{
								continue;
							}
							GameObject gameObject2 = new GameObject("Bounce Light");
							gameObject2.AddComponent(typeof(Light));
							if (!get_hit_color)
							{
								if (!mix_colors)
								{
									gameObject2.GetComponent<Light>().color = Bounce_color;
								}
								else
								{
									gameObject2.GetComponent<Light>().color = Color.Lerp(Bounce_color, GetComponent<Light>().color, num);
								}
							}
							else
							{
								gameObject2.GetComponent<Light>().color = Get_color(gameObject2, hitInfo12, num);
							}
							gameObject2.GetComponent<Light>().intensity = Bounce_Intensity / Divide_init_intensity;
							gameObject2.GetComponent<Light>().range = Bounce_Range;
							gameObject2.transform.position = vector11;
							if (Set_light_mask)
							{
								gameObject2.GetComponent<Light>().cullingMask = Bounce_light_mask;
							}
							Lights_destination_color.Add(gameObject2.GetComponent<Light>().color);
							Color color2 = gameObject2.GetComponent<Light>().color;
							if (use_light_sampling)
							{
								for (int num35 = 0; num35 < Lights.Count; num35++)
								{
									if (Vector3.Distance(Lights[num35].position, vector11) < sampling_dist)
									{
										color2 = Color.Lerp(color2, Lights[num35].GetComponent<Light>().color, 0.1f);
									}
								}
							}
							gameObject2.GetComponent<Light>().color = color2;
							Lights.Add(gameObject2.transform);
							if (Jove_Lights)
							{
								gameObject2.AddComponent(typeof(Control_Jove_light));
							}
							Lights_level.Add(1);
							Lights_source.Add(LightTransform);
							gameObject2.transform.parent = LightPool.transform;
						}
					}
					if (!SecondBounce)
					{
						return;
					}
					if (Cycle_ID > Lights.Count - 1)
					{
						Cycle_ID = 0;
					}
					for (int num36 = 0; num36 < Lights.Count; num36++)
					{
						if (Cycle_ID != num36)
						{
							continue;
						}
						Cycle_ID++;
						if (Cycle_ID > Lights.Count - 1)
						{
							Cycle_ID = 0;
						}
						if (Lights[num36].GetComponent<Light>().type != LightType.Point)
						{
							break;
						}
						Vector3 position3 = Lights[num36].position;
						Vector3 direction3 = forward3;
						if (sphere_dest_positions != null && sphere_dest_positions.Count <= 0)
						{
							Vector3[] sphereDirections = GetSphereDirections(hor_directions * ver_directions);
							foreach (Vector3 item2 in sphereDirections)
							{
								sphere_dest_positions.Add(item2);
							}
						}
						for (int num37 = 0; num37 < sphere_dest_positions.Count; num37++)
						{
							if (use_grid)
							{
								position3 = Lights[num36].position;
								direction3 = sphere_dest_positions[num37];
							}
							RaycastHit hitInfo15 = default(RaycastHit);
							if (!Physics.Raycast(position3, direction3, out hitInfo15, PointLight_Radius_2ond))
							{
								continue;
							}
							Vector3 vector12 = new Vector3(0f, 0f, 0f);
							vector12 = ((!Give_Offset) ? hitInfo15.point : ((!offset_on_normal) ? (hitInfo15.point + (vector2 - hitInfo15.point).normalized * placement_offset) : (hitInfo15.point + hitInfo15.normal.normalized * placement_offset)));
							if (Debug_2ond)
							{
								Debug.DrawLine(position3, vector12, Color.magenta);
							}
							if (check_secondary_collisions)
							{
								RaycastHit hitInfo16 = default(RaycastHit);
								if (Physics.Raycast(hitInfo15.point, vector12 - hitInfo15.point, out hitInfo16, (vector12 - hitInfo15.point).magnitude) && (hitInfo16.point - hitInfo15.point).magnitude < (vector12 - hitInfo15.point).magnitude)
								{
									vector12 = ((!meet_half_way) ? hitInfo15.point : (hitInfo15.point + (hitInfo16.point - hitInfo15.point).normalized * (hitInfo16.point - hitInfo15.point).magnitude / 2f));
								}
							}
							bool flag9 = true;
							bool flag10 = false;
							if (Lights.Count <= 0)
							{
								flag10 = true;
							}
							else
							{
								if (Enable_follow)
								{
									for (int num38 = Lights.Count - 1; num38 >= 0; num38--)
									{
										if (Vector3.Distance(Lights[num38].position, vector12) > Follow_dist)
										{
											Lights[num38].position = Vector3.Lerp(Lights[num38].position, vector12, Follow_speed * Time.deltaTime);
										}
									}
								}
								if (add_only_when_seen)
								{
									RaycastHit hitInfo17 = default(RaycastHit);
									if (Physics.Raycast(CameraTransform.position, vector12, out hitInfo17, float.PositiveInfinity) && hitInfo17.point.magnitude > 0f && Vector3.Distance(hitInfo17.point, CameraTransform.position) < Vector3.Distance(vector12, CameraTransform.position))
									{
										flag9 = false;
									}
								}
								if (close_to_camera && Vector3.Distance(CameraTransform.position, vector12) > min_dist_to_camera)
								{
									flag9 = false;
								}
								for (int num39 = Lights.Count - 1; num39 >= 0; num39--)
								{
									if (Vector3.Distance(Lights[num39].position, vector12) < min_density_dist)
									{
										flag9 = false;
									}
									if (Lights_level[num39] >= 2 && (dynamic_update_color & get_hit_color) && Vector3.Distance(Lights[num39].position, vector12) < min_density_dist / 2f)
									{
										Lights[num39].gameObject.GetComponent<Light>().color = Get_color(Lights[num39].gameObject, hitInfo15, num);
									}
								}
							}
							if (PointLight_Radius_2ond < 0f)
							{
								PointLight_Radius_2ond = 0f;
							}
							if (PointLight_Radius_2ond != 0f && !(Vector3.Distance(hitInfo15.point, Lights[num36].GetComponent<Light>().transform.position) < PointLight_Radius_2ond))
							{
								flag9 = false;
							}
							if (Disable_on_tag)
							{
								for (int num40 = 0; num40 < Disable_Tags.Count; num40++)
								{
									if (hitInfo15.collider.gameObject.tag == Disable_Tags[num40])
									{
										flag9 = false;
									}
								}
							}
							if (Disable_on_layer)
							{
								for (int num41 = 0; num41 < Disable_Layers.Count; num41++)
								{
									if (LayerMask.LayerToName(hitInfo15.collider.gameObject.layer) == Disable_Layers[num41])
									{
										flag9 = false;
									}
								}
							}
							if (!((flag9 && !flag10) || flag10))
							{
								continue;
							}
							if (Lights_level[num36] >= 2)
							{
								break;
							}
							GameObject gameObject3 = new GameObject("Indirect Bounce Light Level " + (Lights_level[num36] + 1));
							gameObject3.AddComponent(typeof(Light));
							if (!get_hit_color)
							{
								if (!mix_colors)
								{
									gameObject3.GetComponent<Light>().color = Bounce_color;
								}
								else
								{
									gameObject3.GetComponent<Light>().color = Color.Lerp(Bounce_color, Lights[num36].GetComponent<Light>().color, num);
								}
							}
							else
							{
								gameObject3.GetComponent<Light>().color = Color.Lerp(Get_color(gameObject3, hitInfo15, num), Lights[num36].GetComponent<Light>().color, 0.5f);
							}
							gameObject3.GetComponent<Light>().intensity = Bounce_Intensity / Divide_init_intensity;
							gameObject3.GetComponent<Light>().range = Bounce_Range;
							gameObject3.transform.position = vector12;
							if (Set_light_mask)
							{
								gameObject3.GetComponent<Light>().cullingMask = Bounce_light_mask;
							}
							Lights_destination_color.Add(gameObject3.GetComponent<Light>().color);
							Color color3 = gameObject3.GetComponent<Light>().color;
							if (use_light_sampling)
							{
								for (int num42 = 0; num42 < Lights.Count; num42++)
								{
									if (Vector3.Distance(Lights[num42].position, vector12) < sampling_dist)
									{
										color3 = Color.Lerp(color3, Lights[num42].GetComponent<Light>().color, 0.1f);
									}
								}
							}
							gameObject3.GetComponent<Light>().color = color3;
							if (Not_important_2ond)
							{
								gameObject3.GetComponent<Light>().renderMode = LightRenderMode.ForceVertex;
							}
							Lights.Add(gameObject3.transform);
							if (Jove_Lights)
							{
								gameObject3.AddComponent(typeof(Control_Jove_light));
							}
							int item3 = 2;
							if (Lights_level[num36] > 1)
							{
								item3 = Lights_level[num36] + 1;
							}
							Lights_level.Add(item3);
							Lights_source.Add(Lights[num36]);
							gameObject3.transform.parent = LightPool.transform;
							break;
						}
						break;
					}
				}
				else
				{
					Debug.Log("Add the script to a light");
				}
			}
		}

		private Vector3[] GetSphereDirections(int numDirections)
		{
			Vector3[] array = new Vector3[numDirections];
			float num = MathF.PI * (3f - Mathf.Sqrt(5f));
			float num2 = 2f / (float)numDirections;
			for (int i = 0; i < numDirections; i++)
			{
				float num3 = (float)i * num2 - 1f + num2 / 2f;
				float num4 = Mathf.Sqrt(1f - num3 * num3);
				float f = (float)i * num;
				float x = Mathf.Cos(f) * num4;
				float z = Mathf.Sin(f) * num4;
				array[i] = new Vector3(x, num3, z);
			}
			return array;
		}

		private Color Get_color(GameObject lightGameObject, RaycastHit hit1, float Color_speed)
		{
			Color result = lightGameObject.GetComponent<Light>().color;
			if (!(hit1.transform.GetComponent<Renderer>() != null))
			{
				result = (mix_colors ? Color.Lerp(Bounce_color, GetComponent<Light>().color, Color_speed) : Bounce_color);
			}
			else if (hit1.transform.GetComponent<Renderer>().material != null)
			{
				if (!(get_texture_color & hit1.transform.GetComponent<Renderer>().material.HasProperty("_MainTex")))
				{
					result = ((!hit1.transform.GetComponent<Renderer>().material.HasProperty("_Color")) ? GetComponent<Light>().color : ((!mix_colors) ? hit1.transform.GetComponent<Renderer>().material.color : ((!Use_light_color) ? Color.Lerp(lightGameObject.GetComponent<Light>().color, hit1.transform.GetComponent<Renderer>().material.color, Color_speed) : Color.Lerp(GetComponent<Light>().color, hit1.transform.GetComponent<Renderer>().material.color, Color_speed))));
				}
				else if (!(hit1.transform.GetComponent<Renderer>().material.mainTexture != null))
				{
					result = ((!hit1.transform.GetComponent<Renderer>().material.HasProperty("_Color")) ? GetComponent<Light>().color : ((!mix_colors) ? hit1.transform.GetComponent<Renderer>().material.color : ((!Use_light_color) ? Color.Lerp(lightGameObject.GetComponent<Light>().color, Color.Lerp(hit1.transform.GetComponent<Renderer>().material.color, GetComponent<Light>().color, 0.5f), Color_speed) : Color.Lerp(GetComponent<Light>().color, hit1.transform.GetComponent<Renderer>().material.color, Color_speed))));
				}
				else
				{
					Texture2D texture2D = hit1.transform.GetComponent<Renderer>().material.mainTexture as Texture2D;
					bool flag = true;
					try
					{
						if (texture2D != null)
						{
							texture2D.GetPixel(0, 0);
						}
						else
						{
							flag = false;
						}
					}
					catch (UnityException ex)
					{
						if (ex.Message.StartsWith("Texture '" + texture2D.name + "' is not readable"))
						{
							flag = false;
						}
					}
					if (flag)
					{
						Vector2 textureCoord = hit1.textureCoord;
						textureCoord.x *= texture2D.width;
						textureCoord.y *= texture2D.height;
						result = ((!mix_colors) ? texture2D.GetPixel((int)textureCoord.x, (int)textureCoord.y) : ((!Use_light_color) ? Color.Lerp(lightGameObject.GetComponent<Light>().color, texture2D.GetPixel((int)textureCoord.x, (int)textureCoord.y), Color_speed) : Color.Lerp(GetComponent<Light>().color, lightGameObject.GetComponent<Light>().color, Color_speed)));
					}
				}
			}
			return result;
		}
	}
}