public static void Mask(Light2D light, LightCollider2D id, LayerSetting layerSetting) { if (id.InLight(light) == false) { return; } int shapeCount = id.shapes.Count; for (int i = 0; i < shapeCount; i++) { LightColliderShape shape = id.shapes[i]; List <MeshObject> meshObjects = shape.GetMeshes(); if (meshObjects == null) { return; } Vector2 position = shape.transform2D.position - light.transform2D.position; Vector2 pivotPosition = shape.GetPivotPoint() - light.transform2D.position; GL.Color(LayerSettingColor.Get(pivotPosition, layerSetting, id.maskEffect, id.maskTranslucency)); GLExtended.DrawMeshPass(meshObjects, position, shape.transform.lossyScale, shape.transform2D.rotation); } }
private static void DrawSprite(Pass pass) { int colliderCount = pass.layerMaskList.Count; if (colliderCount < 1) { return; } for (int id = 0; id < colliderCount; id++) { LightCollider2D collider = pass.layerMaskList[id]; switch (collider.mainShape.maskType) { case LightCollider2D.MaskType.Sprite: SpriteRenderer2D.Mask(pass.light, collider, pass.materialWhite, pass.layer); break; case LightCollider2D.MaskType.BumpedSprite: Material material = collider.bumpMapMode.SelectMaterial(pass.materialNormalMap_PixelToLight, pass.materialNormalMap_ObjectToLight); SpriteRenderer2D.MaskNormalMap(pass.light, collider, material, pass.layer); break; } } }
private void OnEnable() { lightCollider2D = target as LightCollider2D; InitProperties(); Undo.undoRedoPerformed += RefreshAll; }
private void OnEnable() { lightCollider = GetComponent <LightCollider2D>(); if (lightCollider != null) { lightCollider.AddEvent(CollisionEvent); } }
public LightCollision2D(bool _active) { light = null; collider = null; points = null; state = LightEventState.None; }
static void CreateLightCollider() { GameObject newGameObject = new GameObject("Light Collider 2D"); newGameObject.AddComponent <PolygonCollider2D>(); LightCollider2D collider = newGameObject.AddComponent <LightCollider2D>(); collider.maskType = LightCollider2D.MaskType.Collider2D; collider.shadowType = LightCollider2D.ShadowType.Collider2D; collider.Initialize(); newGameObject.transform.position = GetCameraPoint(); }
public static void Mask(Light2D light, LightCollider2D id, Material material, LayerSetting layerSetting) { if (id.InLight(light) == false) { return; } Texture2D currentTexture = null; Color currentColor = Color.black; GL.Begin(GL.QUADS); foreach (LightColliderShape shape in id.shapes) { UnityEngine.SpriteRenderer spriteRenderer = shape.spriteShape.GetSpriteRenderer(); Sprite sprite = shape.spriteShape.GetOriginalSprite(); if (sprite == null || spriteRenderer == null) { continue; } if (sprite.texture == null) { continue; } Vector2 position = shape.transform2D.position - light.transform2D.position; Color color = LayerSettingColor.Get(shape, position, layerSetting, id.maskEffect, id.maskTranslucency); if (currentTexture != sprite.texture || currentColor != color) { currentTexture = sprite.texture; currentColor = color; material.mainTexture = currentTexture; material.color = currentColor; material.SetPass(0); } Rendering.Universal.Sprite.FullRect.DrawPass(id.spriteMeshObject, spriteRenderer, position, shape.transform2D.scale, shape.transform2D.rotation); } GL.End(); material.mainTexture = null; material.color = Color.white; }
public void Add(LightCollider2D collider2D, float dist) { if (count < list.Length) { list[count].value = dist; list[count].type = SortObject.Type.Collider; list[count].lightObject = (object)collider2D; count++; } else { Debug.LogError("Collider Depth Overhead!"); } }
public static void Draw(Light2D light, LightCollider2D id) { if (id.InLight(light) == false) { return; } light.AddCollider(id); foreach (LightColliderShape shape in id.shapes) { List <Polygon2> polygons = shape.GetPolygonsWorld(); ShadowEngine.Draw(polygons, shape.shadowDistance, id.shadowTranslucency); } }
public static void Mask(Light2D light, LightCollider2D id, Material material, LayerSetting layerSetting) { if (id.InLight(light) == false) { return; } foreach (LightColliderShape shape in id.shapes) { SkinnedMeshRenderer skinnedMeshRenderer = shape.skinnedMeshShape.GetSkinnedMeshRenderer(); if (skinnedMeshRenderer == null) { return; } List <MeshObject> meshObject = shape.GetMeshes(); if (meshObject == null) { return; } if (skinnedMeshRenderer.sharedMaterial != null) { material.mainTexture = skinnedMeshRenderer.sharedMaterial.mainTexture; } else { material.mainTexture = null; } Vector2 position = shape.transform2D.position - light.transform2D.position; Vector2 pivotPosition = shape.GetPivotPoint() - light.transform2D.position; material.color = LayerSettingColor.Get(pivotPosition, layerSetting, id.maskEffect, id.maskTranslucency); material.SetPass(0); GLExtended.DrawMesh(meshObject, position, id.mainShape.transform2D.scale, shape.transform2D.rotation); material.mainTexture = null; } }
public static void GenerateEffectLayers() { int layerID = (int)ShadowEngine.effectLayer; foreach (LightCollider2D c in LightCollider2D.GetShadowList((layerID))) { List <Polygon2> polygons = c.mainShape.GetPolygonsWorld(); if (polygons == null) { continue; } if (c.InLight(light)) { effectPolygons.Add(polygons); } } }
private static void DrawCollider(Pass pass) { int colliderCount = pass.layerMaskList.Count; if (colliderCount < 1) { return; } for (int id = 0; id < colliderCount; id++) { LightCollider2D collider = pass.layerMaskList[id]; switch (collider.mainShape.maskType) { case LightCollider2D.MaskType.SpritePhysicsShape: case LightCollider2D.MaskType.CompositeCollider2D: case LightCollider2D.MaskType.Collider2D: case LightCollider2D.MaskType.Collider3D: Shape.Mask(pass.light, collider, pass.layer); break; } } }
private static void DrawCollider(Pass pass) { int colliderCount = pass.layerShadowList.Count; if (colliderCount < 1) { return; } for (int id = 0; id < colliderCount; id++) { LightCollider2D collider = pass.layerShadowList[id]; if (collider.ShadowDisabled()) { continue; } // Shadow Projection Sprite ShadowEngine.spriteProjection = collider.mainShape.spriteShape.GetOriginalSprite(); Shadow.Shape.Draw(pass.light, collider); } }
override public void OnInspectorGUI() { if (lightCollider2D == null) { return; } // Warning // Debug.Log(lightCollider2D.mainShape.spriteShape.GetOriginalSprite().packingMode); // Shadow Properties EditorGUILayout.PropertyField(shadowType, new GUIContent("Shadow Type")); EditorGUI.BeginDisabledGroup(shadowType.intValue == (int)LightCollider2D.ShadowType.None); shadowLayer.intValue = EditorGUILayout.Popup("Shadow Layer (Light)", shadowLayer.intValue, Lighting2D.Profile.layers.lightLayers.GetNames()); string shadowDistanceName = "Shadow Distance"; if (shadowDistance.floatValue == 0) { shadowDistanceName = "Shadow Distance (infinite)"; } EditorGUILayout.PropertyField(shadowDistance, new GUIContent(shadowDistanceName)); EditorGUILayout.PropertyField(shadowTranslucency, new GUIContent("Shadow Translucency")); EditorGUI.EndDisabledGroup(); EditorGUILayout.Space(); // Mask Properties EditorGUILayout.PropertyField(maskType, new GUIContent("Mask Type")); EditorGUI.BeginDisabledGroup(maskType.intValue == (int)LightCollider2D.MaskType.None); maskLayer.intValue = EditorGUILayout.Popup("Mask Layer (Light)", maskLayer.intValue, Lighting2D.Profile.layers.lightLayers.GetNames()); EditorGUILayout.PropertyField(maskEffect, new GUIContent("Mask Effect")); EditorGUILayout.PropertyField(maskPivot, new GUIContent("Mask Pivot")); EditorGUILayout.PropertyField(maskTranslucency, new GUIContent("Mask Translucency")); EditorGUI.EndDisabledGroup(); if (lightCollider2D.maskType == LightCollider2D.MaskType.BumpedSprite || lightCollider2D.maskType == LightCollider2D.MaskType.BumpedMeshRenderer) { GUIBumpMapMode.Draw(serializedObject, lightCollider2D); } EditorGUILayout.Space(); // Apply to Children EditorGUILayout.PropertyField(applyToChildren, new GUIContent("Apply to Children")); serializedObject.ApplyModifiedProperties(); EditorGUILayout.Space(); // Update if (GUILayout.Button("Update")) { SpriteExtension.PhysicsShapeManager.Clear(); foreach (Object target in targets) { LightCollider2D lightCollider2D = target as LightCollider2D; lightCollider2D.Initialize(); } LightingManager2D.ForceUpdate(); } if (GUI.changed) { foreach (Object target in targets) { LightCollider2D lightCollider2D = target as LightCollider2D; lightCollider2D.Initialize(); lightCollider2D.UpdateNearbyLights(); if (EditorApplication.isPlaying == false) { EditorUtility.SetDirty(target); } } if (EditorApplication.isPlaying == false) { EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene()); } LightingManager2D.ForceUpdate(); } }
public static void MaskNormalMap(Light2D light, LightCollider2D id, Material material, LayerSetting layerSetting) { if (id.InLight(light) == false) { return; } Texture normalTexture = id.bumpMapMode.GetBumpTexture(); if (normalTexture == null) { return; } float rotation; material.SetTexture("_Bump", normalTexture); foreach (LightColliderShape shape in id.shapes) { MeshRenderer meshRenderer = id.mainShape.meshShape.GetMeshRenderer(); if (meshRenderer == null) { return; } List <MeshObject> meshObjects = id.mainShape.GetMeshes(); if (meshObjects == null) { return; } if (meshRenderer.sharedMaterial != null) { material.mainTexture = meshRenderer.sharedMaterial.mainTexture; } else { material.mainTexture = null; } Vector2 position = shape.transform2D.position - light.transform2D.position; Vector2 pivotPosition = shape.GetPivotPoint() - light.transform2D.position; material.color = LayerSettingColor.Get(pivotPosition, layerSetting, id.maskEffect, id.maskTranslucency); float color = material.color.r; switch (id.bumpMapMode.type) { case NormalMapType.ObjectToLight: rotation = Mathf.Atan2(light.transform2D.position.y - shape.transform2D.position.y, light.transform2D.position.x - shape.transform2D.position.x); rotation -= Mathf.Deg2Rad * (shape.transform2D.rotation); material.SetFloat("_LightRX", Mathf.Cos(rotation) * 2); material.SetFloat("_LightRY", Mathf.Sin(rotation) * 2); material.SetFloat("_LightColor", color); break; case NormalMapType.PixelToLight: material.SetFloat("_LightColor", color); rotation = shape.transform2D.rotation * Mathf.Deg2Rad; Vector2 sc = shape.transform2D.scale; sc = sc.normalized; material.SetFloat("_LightX", Mathf.Cos(rotation) * sc.x); material.SetFloat("_LightY", Mathf.Cos(rotation) * sc.y); material.SetFloat("_Depth", id.bumpMapMode.depth); if (id.bumpMapMode.invertX) { material.SetFloat("_InvertX", -1); } else { material.SetFloat("_InvertX", 1); } if (id.bumpMapMode.invertY) { material.SetFloat("_InvertY", -1); } else { material.SetFloat("_InvertY", 1); } break; } material.SetPass(0); GLExtended.DrawMesh(meshObjects, position, id.mainShape.transform2D.scale, shape.transform2D.rotation); material.mainTexture = null; } }
public void Update(Light2D light, EventPreset eventPreset) { if (light == null) { return; } listenersInLight.Clear(); // Get Event Receivers LightCollider.GetCollisions(listenersInLight, light); // Remove Event Receiver Vertices with Shadows LightCollider.RemoveHiddenCollisions(listenersInLight, light, eventPreset); LightTilemap.RemoveHiddenCollisions(listenersInLight, light, eventPreset); if (listenersInLight.Count < 1) { for (int i = 0; i < listenersCache.Count; i++) { LightCollider2D collider = listenersCache[i]; LightCollision2D collision = new LightCollision2D(); collision.light = light; collision.collider = collider; collision.points = null; collision.state = LightEventState.OnCollisionExit; collider.CollisionEvent(collision); } listenersCache.Clear(); return; } listenersInLightColliders.Clear(); foreach (LightCollision2D collision in listenersInLight) { listenersInLightColliders.Add(collision.collider); } for (int i = 0; i < listenersCache.Count; i++) { LightCollider2D collider = listenersCache[i]; if (listenersInLightColliders.Contains(collider) == false) { LightCollision2D collision = new LightCollision2D(); collision.light = light; collision.collider = collider; collision.points = null; collision.state = LightEventState.OnCollisionExit; collider.CollisionEvent(collision); listenersCache.Remove(collider); } } for (int i = 0; i < listenersInLight.Count; i++) { LightCollision2D collision = listenersInLight[i]; if (listenersCache.Contains(collision.collider)) { collision.state = LightEventState.OnCollision; } else { collision.state = LightEventState.OnCollisionEnter; listenersCache.Add(collision.collider); } collision.collider.CollisionEvent(collision); } }
private static void DrawCollider(Pass pass) { LightCollider2D collider = (LightCollider2D)pass.sortPass.sortObject.lightObject; if (collider.shadowLayer == pass.layerID && pass.drawShadows) { if (collider.ShadowDisabled() == false) { ShadowEngine.GetMaterial().SetPass(0); GL.Begin(GL.TRIANGLES); Shadow.Shape.Draw(pass.light, collider); GL.End(); } } // Masking if (collider.maskLayer == pass.layerID && pass.drawMask) { pass.materialWhite.color = Color.white; switch (collider.mainShape.maskType) { case LightCollider2D.MaskType.SpritePhysicsShape: case LightCollider2D.MaskType.Collider2D: case LightCollider2D.MaskType.Collider3D: case LightCollider2D.MaskType.CompositeCollider2D: pass.materialWhite.SetPass(0); GL.Begin(GL.TRIANGLES); Shape.Mask(pass.light, collider, pass.layer); GL.End(); break; case LightCollider2D.MaskType.Sprite: SpriteRenderer2D.Mask(pass.light, collider, pass.materialWhite, pass.layer); break; case LightCollider2D.MaskType.BumpedSprite: Material material = collider.bumpMapMode.SelectMaterial(pass.materialNormalMap_PixelToLight, pass.materialNormalMap_ObjectToLight); SpriteRenderer2D.MaskNormalMap(pass.light, collider, material, pass.layer); break; case LightCollider2D.MaskType.MeshRenderer: pass.materialWhite.SetPass(0); GL.Begin(GL.TRIANGLES); Mesh.Mask(pass.light, collider, pass.materialWhite, pass.layer); GL.End(); break; case LightCollider2D.MaskType.BumpedMeshRenderer: Material material2 = collider.bumpMapMode.SelectMaterial(pass.materialNormalMap_PixelToLight, pass.materialNormalMap_ObjectToLight); material2.SetPass(0); GL.Begin(GL.TRIANGLES); Mesh.MaskNormalMap(pass.light, collider, material2, pass.layer); GL.End(); break; case LightCollider2D.MaskType.SkinnedMeshRenderer: pass.materialWhite.SetPass(0); GL.Begin(GL.TRIANGLES); SkinnedMesh.Mask(pass.light, collider, pass.materialWhite, pass.layer); GL.End(); break; } } }
void RefreshAll() { LightCollider2D.ForceUpdateAll(); }
void AddColliders() { for (int id = 0; id < pass.colliderList.Count; id++) { LightCollider2D collider = pass.colliderList[id]; if (collider.shadowLayer != pass.layerID && collider.maskLayer != pass.layerID) { continue; } if (collider.InLight(pass.light) == false) { continue; } switch (pass.layer.sorting) { case LightLayerSorting.Isometric: Vector2 lightPos = pass.light.transform.position; Vector2 colliderPos = collider.mainShape.GetPivotPoint(); Vector2 position = colliderPos - lightPos; float x = position.y + position.x / 2; float y = -(position.x / 2 - position.y); if (x > 0) { sortList.Add(collider, x); } else { sortList.Add(collider, -x + 10000); } break; case LightLayerSorting.SortingLayerAndOrder: sortList.Add(collider, collider.mainShape.GetSortingOrder() + collider.mainShape.GetSortingLayer() * 1000); break; case LightLayerSorting.ZAxisLower: if (pass.layer.sortingIgnore == LightLayerSortingIgnore.IgnoreAbove) { if (collider.transform.position.z >= pass.light.transform.position.z) { sortList.Add(collider, -collider.transform.position.z); } } else { sortList.Add(collider, -collider.transform.position.z); } break; case LightLayerSorting.ZAxisHigher: if (pass.layer.sortingIgnore == LightLayerSortingIgnore.IgnoreAbove) { if (collider.transform.position.z <= pass.light.transform.position.z) { sortList.Add(collider, collider.transform.position.z); } } else { sortList.Add(collider, collider.transform.position.z); } break; case LightLayerSorting.YAxisLower: sortList.Add(collider, -collider.transform.position.y); break; case LightLayerSorting.YAxisHigher: sortList.Add(collider, collider.transform.position.y); break; case LightLayerSorting.DistanceToLight: sortList.Add(collider, -Vector2.Distance(collider.transform.position, pass.light.transform.position)); break; case LightLayerSorting.YDistanceToLight: sortList.Add(collider, -Mathf.Abs(collider.transform.position.y - pass.light.transform.position.y)); break; } } }
public static void MaskNormalMap(Light2D light, LightCollider2D id, Material material, LayerSetting layerSetting) { if (id.InLight(light) == false) { return; } Texture normalTexture = id.bumpMapMode.GetBumpTexture(); if (normalTexture == null) { return; } float rotation; material.SetTexture("_Bump", normalTexture); foreach (LightColliderShape shape in id.shapes) { UnityEngine.SpriteRenderer spriteRenderer = shape.spriteShape.GetSpriteRenderer(); if (spriteRenderer == null) { continue; } Sprite sprite = shape.spriteShape.GetOriginalSprite(); if (sprite == null) { continue; } if (sprite.texture == null) { continue; } Vector2 position = shape.transform2D.position - light.transform2D.position; material.mainTexture = sprite.texture; material.color = LayerSettingColor.Get(position, layerSetting, id.maskEffect, id.maskTranslucency); float color = material.color.r; switch (id.bumpMapMode.type) { case NormalMapType.ObjectToLight: rotation = Mathf.Atan2(light.transform2D.position.y - shape.transform2D.position.y, light.transform2D.position.x - shape.transform2D.position.x); rotation -= Mathf.Deg2Rad * (shape.transform2D.rotation); material.SetFloat("_LightRX", Mathf.Cos(rotation) * 2); material.SetFloat("_LightRY", Mathf.Sin(rotation) * 2); material.SetFloat("_LightColor", color); break; case NormalMapType.PixelToLight: material.SetFloat("_LightColor", color); rotation = shape.transform2D.rotation * Mathf.Deg2Rad; Vector2 sc = shape.transform2D.scale; sc = sc.normalized; material.SetFloat("_LightX", Mathf.Cos(rotation) * sc.x); material.SetFloat("_LightY", Mathf.Cos(rotation) * sc.y); material.SetFloat("_Depth", id.bumpMapMode.depth); if (id.bumpMapMode.invertX) { material.SetFloat("_InvertX", -1); } else { material.SetFloat("_InvertX", 1); } if (id.bumpMapMode.invertY) { material.SetFloat("_InvertY", -1); } else { material.SetFloat("_InvertY", 1); } break; } Rendering.Universal.Sprite.FullRect.Draw(id.spriteMeshObject, material, spriteRenderer, position, shape.transform2D.scale, shape.transform2D.rotation); } }
public bool Setup(Light2D light, LayerSetting setLayer) { // Layer ID layerID = setLayer.GetLayerID(); if (layerID < 0) { return(false); } layer = setLayer; // Calculation Setup this.light = light; lightSizeSquared = Mathf.Sqrt(light.size * light.size + light.size * light.size); colliderList = LightCollider2D.List; layerShadowList = LightCollider2D.GetShadowList(layerID); layerMaskList = LightCollider2D.GetMaskList(layerID); #if UNITY_2017_4_OR_NEWER tilemapList = LightTilemapCollider2D.GetList(); #endif // Draw Mask & Shadows? drawMask = (layer.type != LightLayerType.ShadowOnly); drawShadows = (layer.type != LightLayerType.MaskOnly); // Materials materialWhite = Lighting2D.materials.GetMask(); if (materialWhite != null) { materialWhite.SetFloat("translucency", (light.maskTranslucency * 100) / light.size); materialWhite.SetFloat("intensity", light.maskTranslucencyIntensity); if (light.maskTranslucency > 0) { if (light.Buffer.collisionTexture != null) { materialWhite.SetTexture("_SecTex", light.Buffer.collisionTexture.renderTexture); materialWhite.SetFloat("textureSize", light.GetTextureSize().x); } } } materialNormalMap_PixelToLight = Lighting2D.materials.GetNormalMapSpritePixelToLight(); if (materialNormalMap_PixelToLight != null) { materialNormalMap_PixelToLight.SetFloat("translucency", (light.maskTranslucency * 100) / light.size); materialNormalMap_PixelToLight.SetFloat("intensity", light.maskTranslucencyIntensity); if (light.maskTranslucency > 0) { if (light.Buffer.collisionTexture != null) { materialNormalMap_PixelToLight.SetTexture("_SecTex", light.Buffer.collisionTexture.renderTexture); materialNormalMap_PixelToLight.SetFloat("textureSize", light.GetTextureSize().x); } } } materialNormalMap_ObjectToLight = Lighting2D.materials.GetNormalMapSpriteObjectToLight(); if (materialNormalMap_ObjectToLight != null) { materialNormalMap_ObjectToLight.SetFloat("translucency", (light.maskTranslucency * 100) / light.size); if (light.maskTranslucency > 0) { if (light.Buffer.collisionTexture != null) { materialNormalMap_ObjectToLight.SetTexture("_SecTex", light.Buffer.collisionTexture.renderTexture); materialNormalMap_ObjectToLight.SetFloat("textureSize", light.GetTextureSize().x); } } } materialNormalMap_PixelToLight.SetFloat("_LightSize", light.size); materialNormalMap_PixelToLight.SetFloat("_LightIntensity", light.bumpMap.intensity); materialNormalMap_PixelToLight.SetFloat("_LightZ", light.bumpMap.depth); materialNormalMap_ObjectToLight.SetFloat("_LightSize", light.size); materialNormalMap_ObjectToLight.SetFloat("_LightIntensity", light.bumpMap.intensity); materialNormalMap_ObjectToLight.SetFloat("_LightZ", light.bumpMap.depth); sortPass.pass = this; // Sort sortPass.Clear(); return(true); }
public static List <LightCollision2D> RemoveHiddenCollisions(List <LightCollision2D> collisions, Light2D light, EventPreset eventPreset) { float lightSize = Mathf.Sqrt(light.size * light.size + light.size * light.size); double rotLeft, rotRight; Polygon2D testPolygon = GetPolygon(); Vector2 lightPosition = -light.transform.position; int next; for (int iid = 0; iid < eventPreset.layerSetting.list.Length; iid++) { int layerId = eventPreset.layerSetting.list[iid].layerID; List <LightCollider2D> colliderList = LightCollider2D.GetShadowList(layerId); foreach (LightCollider2D id in colliderList) { if (id.InLight(light) == false) { continue; } if (id.mainShape.shadowType == LightCollider2D.ShadowType.None) { continue; } List <Polygon2> polygons = id.mainShape.GetPolygonsWorld(); if (polygons.Count < 1) { continue; } removePointsColliding.Clear(); removeCollisions.Clear(); for (int i = 0; i < polygons.Count; i++) { Vector2[] pointsList = polygons[i].points; int pointsCount = pointsList.Length; for (int x = 0; x < pointsCount; x++) { next = (x + 1) % pointsCount; Vector2 left = pointsList[x]; Vector2 right = pointsList[next]; edgeLeft.x = left.x + lightPosition.x; edgeLeft.y = left.y + lightPosition.y; edgeRight.x = right.x + lightPosition.x; edgeRight.y = right.y + lightPosition.y; rotLeft = System.Math.Atan2(edgeLeft.y, edgeLeft.x); rotRight = System.Math.Atan2(edgeRight.y, edgeRight.x); projectionLeft.x = edgeLeft.x + System.Math.Cos(rotLeft) * lightSize; projectionLeft.y = edgeLeft.y + System.Math.Sin(rotLeft) * lightSize; projectionRight.x = edgeRight.x + System.Math.Cos(rotRight) * lightSize; projectionRight.y = edgeRight.y + System.Math.Sin(rotRight) * lightSize; testPolygon.pointsList[0].x = projectionLeft.x; testPolygon.pointsList[0].y = projectionLeft.y; testPolygon.pointsList[1].x = projectionRight.x; testPolygon.pointsList[1].y = projectionRight.y; testPolygon.pointsList[2].x = edgeRight.x; testPolygon.pointsList[2].y = edgeRight.y; testPolygon.pointsList[3].x = edgeLeft.x; testPolygon.pointsList[3].y = edgeLeft.y; foreach (LightCollision2D col in collisions) { if (col.collider == id) { continue; } foreach (Vector2 point in col.points) { if (testPolygon.PointInPoly(point)) { removePointsColliding.Add(point); } } foreach (Vector2 point in removePointsColliding) { col.points.Remove(point); } removePointsColliding.Clear(); if (col.points.Count < 1) { removeCollisions.Add(col); } } foreach (LightCollision2D col in removeCollisions) { collisions.Remove(col); } removeCollisions.Clear(); } } } } return(collisions); }