static public void SetupLocation(LightingBuffer2D buffer, LightingTilemapCollider2D id) { Vector3 rot = Math2D.GetPitchYawRollRad(id.transform.rotation); float rotationYScale = Mathf.Sin(rot.x + Mathf.PI / 2); float rotationXScale = Mathf.Sin(rot.y + Mathf.PI / 2); scale.x = id.transform.lossyScale.x * rotationXScale * id.cellSize.x; scale.y = id.transform.lossyScale.y * rotationYScale * id.cellSize.y; sizeInt = LightTilemapSize(id, buffer); LightTilemapOffset(id, scale, buffer); offset.x = -buffer.lightSource.transform.position.x; offset.y = -buffer.lightSource.transform.position.y; tilemapOffset.x = id.transform.position.x + id.area.position.x + id.cellAnchor.x; tilemapOffset.y = id.transform.position.y + id.area.position.y + id.cellAnchor.y; if (id.mapType == LightingTilemapCollider2D.MapType.SuperTilemapEditor) { tilemapOffset.x -= id.area.size.x / 2; tilemapOffset.y -= id.area.size.y / 2; } tileSize.x = scale.x / id.cellSize.x; tileSize.y = scale.y / id.cellSize.y; }
// Y Axis public static void MaskDepthWithoutAtlas(LightingBuffer2D buffer, LightingCollider2D id, Material material, Vector2D offset, float z) { if (id.shape.maskType == LightingCollider2D.MaskType.None) { return; } if (id.shape.maskType != LightingCollider2D.MaskType.Sprite) { return; } if (id.isVisibleForLight(buffer) == false) { return; } Sprite sprite = id.shape.GetOriginalSprite(); if (sprite == null || id.spriteRenderer == null) { return; } Vector2 p = id.transform.position; Vector2 scale = id.transform.lossyScale; material.mainTexture = sprite.texture; Max2D.DrawSprite(material, id.spriteRenderer, offset.ToVector2() + p, scale, id.transform.rotation.eulerAngles.z, z); material.mainTexture = null; LightingDebug.maskGenerations++; }
// Lighting Buffers void DrawLightingBuffers(float z) { foreach (LightingBuffer2D id in LightingBuffer2D.GetList()) { if (id.lightSource != null) { if (id.lightSource.isActiveAndEnabled == false) { continue; } LightingManager2D.LightingDebug.LightSourceDrawn += 1; Vector3 pos = id.lightSource.transform.position - Camera.main.transform.position; float size = id.bufferCamera.orthographicSize; Color lightColor = id.lightSource.lightColor; lightColor.a = id.lightSource.lightAlpha / 2; id.material.SetColor("_TintColor", lightColor); Max2D.iDrawImage(id.material, new Vector2D(pos), new Vector2D(size, size), z); } } }
static public void InitializeRenderTexture(LightingBuffer2D buffer, Vector2Int textureSize) { if (buffer.renderTexture != null) { //return; } RenderTextureFormat format = RenderTextureFormat.Default; format = RenderTextureFormat.R8; if (SystemInfo.SupportsTextureFormat(TextureFormat.RHalf)) { if (Lighting2D.QualitySettings.HDR) { format = RenderTextureFormat.DefaultHDR; format = RenderTextureFormat.RHalf; } } buffer.renderTexture = new LightTexture(textureSize.x, textureSize.y, 0, format); buffer.renderTexture.renderTexture.filterMode = Lighting2D.Profile.qualitySettings.lightFilterMode; UpdateName(buffer); }
static public void UpdateName(LightingBuffer2D buffer) { string freeString = ""; if (buffer.Free) { freeString = "free"; } else { freeString = "taken"; } if (buffer.renderTexture != null) { buffer.name = "Buffer (Id: " + (LightingBuffer2D.List.IndexOf(buffer) + 1) + ", Size: " + buffer.renderTexture.width + ", " + freeString + ")"; } else { buffer.name = "Buffer (Id: " + (LightingBuffer2D.List.IndexOf(buffer) + 1) + ", No Texture, " + freeString + ")"; } if (Lighting2D.QualitySettings.HDR) { buffer.name = "HDR " + buffer.name; } }
public static void DrawShadowsAndMask(LightingBuffer2D buffer, int layer) { buffer.CalculateCoords(); drawMask = false; if (buffer.lightSource.layerSetting[layer].type != LightingLayerType.ShadowOnly) { drawMask = true; } drawShadows = false; if (buffer.lightSource.layerSetting[layer].type != LightingLayerType.MaskOnly) { drawShadows = true; } GL.PushMatrix(); if (LightingManager2D.Get().lightingSpriteAtlas&& SpriteAtlasManager.Get().atlasTexture != null) { DrawWithAtlas(buffer, layer); } else { DrawWithoutAtlas(buffer, layer); } GL.PopMatrix(); }
// Lighting Buffer TILE static public void MaskShapeDepthWithAtlas(LightingBuffer2D buffer, LightingTile tile, LightRenderingOrder lightSourceOrder, LightingTilemapCollider2D id, Vector2D offset, float z) { Mesh tileMesh = null; if (id.maskType == LightingTilemapCollider2D.MaskType.Tile) { tileMesh = LightingTile.GetStaticTileMesh(); } else if (id.maskType == LightingTilemapCollider2D.MaskType.SpriteCustomPhysicsShape) { tileMesh = tile.GetTileDynamicMesh(); } if (tileMesh == null) { return; } // Set Color Black Or White? GL.Color(Color.white); int triangleCount = tileMesh.triangles.GetLength(0); for (int i = 0; i < triangleCount; i = i + 3) { vecA = tileMesh.vertices [tileMesh.triangles [i]]; vecB = tileMesh.vertices [tileMesh.triangles [i + 1]]; vecC = tileMesh.vertices [tileMesh.triangles [i + 2]]; Max2DMatrix.DrawTriangle(vecA, vecB, vecC, offset.ToVector2(), z, new Vector2D(1, 1)); } LightingDebug.maskGenerations++; }
// Management static public LightingBuffer2D AddBuffer(int textureSize, LightingSource2D light) { LightingManager2D manager = LightingManager2D.Get(); if (manager.fixedLightBufferSize) { textureSize = LightingManager2D.GetTextureSize(manager.fixedLightTextureSize); } FBOManager fboManager = LightingManager2D.Get().fboManager; if (fboManager == null) { Debug.LogError("Lighting Manager Instance is Out-Dated."); Debug.LogError("Try Re-Initializing 'Lighting Manager 2D' Component"); return(null); } GameObject buffer = new GameObject(); buffer.name = "Buffer " + GetCount(); buffer.transform.parent = LightingManager2D.Get().fboManager.transform; buffer.layer = LightingManager2D.lightingLayer; LightingBuffer2D lightingBuffer = buffer.AddComponent <LightingBuffer2D> (); lightingBuffer.Initiate(textureSize); lightingBuffer.lightSource = light; // Unnecessary? lightingBuffer.free = false; lightingBuffer.bufferCamera.orthographicSize = light.lightSize; return(lightingBuffer); }
static public void SortObjects(LightingBuffer2D buffer, int layer) { colliderList = LightingCollider2D.GetList(); tilemapList = LightingTilemapCollider2D.GetList(); list.Reset(); for (int id = 0; id < colliderList.Count; id++) { // Check If It's In Light Area? collider = colliderList[id]; if ((int)colliderList[id].lightingCollisionLayer != layer && (int)colliderList[id].lightingMaskLayer != layer) { continue; } if (layerSettings.renderingOrder == LightRenderingOrder.YAxis) { list.Add(collider, -collider.transform.position.y); } else { list.Add(collider, -Vector2.Distance(collider.transform.position, buffer.lightSource.transform.position)); } } for (int id = 0; id < tilemapList.Count; id++) { SortTilemap(buffer, tilemapList[id]); } list.Sort(); }
public void Update() { Vector2 position = transform.transform.position; if (movedPosition != position) { movedPosition = position; moved = true; } else { moved = false; } if (moved) { foreach (LightingSource2D id in LightingSource2D.GetList()) { if (Vector2.Distance(id.transform.position, position) < meshDistance + id.lightSize) { id.update = true; LightingBuffer2D.GetBuffer(id.GetTextureSize(), id).lightSource = id; } } } }
///// Light Texture public static void Draw(LightingBuffer2D buffer) { float z = buffer.transform.position.z; size.x = buffer.bufferCamera.orthographicSize; size.y = buffer.bufferCamera.orthographicSize; if (buffer.lightSource.rotationEnabled) { // Light Rotation!!! CalculatePoints(buffer); CalculateOffsets(); GL.PushMatrix(); buffer.lightSource.GetMaterial().SetPass(0); GL.Begin(GL.QUADS); Max2D.DrawImage_Batched(Vector2.zero, size, buffer.lightSource.transform.rotation.eulerAngles.z, z); buffer.lightSource.GetMaterial().color = Color.black; Max2DMatrix.DrawQuad(right0, right1, right2, right3, z); Max2DMatrix.DrawQuad(left0, left1, left2, left3, z); Max2DMatrix.DrawQuad(down0, down1, down2, down3, z); Max2DMatrix.DrawQuad(up0, up1, up2, up3, z); GL.End(); GL.PopMatrix(); } else { Max2D.DrawImage(buffer.lightSource.GetMaterial(), Vector2.zero, size, 0, z); } }
public void UpdateMaterials() { if (Lighting2D.materials.Initialize(Lighting2D.QualitySettings.HDR)) { LightingMainBuffer2D.Clear(); LightingBuffer2D.Clear(); Light2D.ForceUpdateAll(); } }
public void OnDisable() { list.Remove(this); ///// Free Buffer! FBOManager.FreeBuffer(buffer); buffer = null; inScreen = false; }
static public void MaskSpriteDepthWithAtlas(LightingBuffer2D buffer, LightingTile tile, LayerSetting layerSetting, LightingTilemapCollider2D id, Vector2D offset, float z) { if (id.maskType != LightingTilemapCollider2D.MaskType.Sprite) { return; } if (id.maskType == LightingTilemapCollider2D.MaskType.None) { return; } if (tile.GetOriginalSprite() == null) { return; } Sprite sprite = tile.GetAtlasSprite(); Vector2 scale = new Vector2(1, 1); if (sprite == null) { Sprite reqSprite = SpriteAtlasManager.RequestSprite(tile.GetOriginalSprite(), SpriteRequest.Type.WhiteMask); if (reqSprite == null) { PartiallyBatched_Tilemap batched = new PartiallyBatched_Tilemap(); batched.virtualSpriteRenderer = new VirtualSpriteRenderer(); batched.virtualSpriteRenderer.sprite = tile.GetOriginalSprite(); batched.polyOffset = offset.ToVector2(); batched.tileSize = scale; batched.tilemap = id; buffer.partiallyBatchedList_Tilemap.Add(batched); return; } else { tile.SetAtlasSprite(reqSprite); sprite = reqSprite; } } VirtualSpriteRenderer spriteRenderer = new VirtualSpriteRenderer(); spriteRenderer.sprite = sprite; Max2D.DrawSpriteBatched_Tris(spriteRenderer, layerSetting, id.maskMode, offset.ToVector2(), scale, id.transform.rotation.eulerAngles.z, z); LightingDebug.maskGenerations++; }
static public int LightTilemapSize(LightingTilemapCollider2D id, LightingBuffer2D buffer) { if (id.mapType == LightingTilemapCollider2D.MapType.SuperTilemapEditor) { return((int)buffer.lightSource.lightSize); } else { return((int)buffer.lightSource.lightSize + 1); } }
static public void FreeBuffer(LightingBuffer2D buffer) { if (buffer == null) { return; } buffer.free = true; buffer.lightSource = null; buffer.bufferCamera.enabled = false; }
// Management static public LightingBuffer2D AddBuffer(Vector2Int textureSize, Light2D light) // i { Get(); LightingBuffer2D lightingBuffer2D = new LightingBuffer2D(); lightingBuffer2D.Initiate(textureSize); lightingBuffer2D.Light = light; // Unnecessary? return(lightingBuffer2D); }
public static void DrawWithoutAtlas(LightingBuffer2D buffer, int layer) { if (drawShadows) { LightingBufferDefault.DrawShadowsWithoutAtlas(buffer, layer); } if (drawMask) { LightingBufferDefault.DrawMaskWithoutAtlas(buffer, layer); } }
public bool isVisibleForLight(LightingBuffer2D buffer) { // 1.5f?? if (LightingManager2D.culling && Vector2.Distance(transform.position, buffer.lightSource.transform.position) > shape.GetFrustumDistance(transform) + buffer.lightSource.lightSize * 1.5f) { LightingDebug.culled++; return(false); } return(true); }
static public LightingBuffer2D AddBuffer(int textureSize) { GameObject buffer = new GameObject(); buffer.name = "Buffer " + GetCount(); buffer.transform.parent = LightingManager2D.Get().mainBuffer.transform; buffer.layer = LightingManager2D.lightingLayer; LightingBuffer2D lightingBuffer = buffer.AddComponent <LightingBuffer2D> (); lightingBuffer.Initiate(textureSize); return(lightingBuffer); }
static public void Fill_Component(LightingBuffer2D buffer, LightingTilemapCollider2D id, float lightSizeSquared, float z) { Vector2D vA, vB; foreach (Polygon2D polygon in id.edgeColliders) { Vector2D polyOffset = new Vector2D(-buffer.lightSource.transform.position); Polygon2D poly = polygon.Copy(); poly.ToOffsetItself(polyOffset); foreach (Pair2D p in Pair2D.GetList(poly.pointsList, false)) { vA = p.A.Copy(); vB = p.B.Copy(); vA.Push(Vector2D.Atan2(vA, zero), lightSizeSquared); vB.Push(Vector2D.Atan2(vB, zero), lightSizeSquared); Max2DMatrix.DrawTriangle(p.A, p.B, vA, zero, z); Max2DMatrix.DrawTriangle(vA, vB, p.B, zero, z); } LightingDebug.shadowGenerations++; } foreach (Polygon2D polygon in id.polygonColliders) { Vector2D polyOffset = new Vector2D(-buffer.lightSource.transform.position); Polygon2D poly = polygon.Copy(); poly.ToOffsetItself(polyOffset); foreach (Pair2D p in Pair2D.GetList(poly.pointsList)) { vA = p.A.Copy(); vB = p.B.Copy(); vA.Push(Vector2D.Atan2(vA, zero), lightSizeSquared); vB.Push(Vector2D.Atan2(vB, zero), lightSizeSquared); Max2DMatrix.DrawTriangle(p.A, p.B, vA, zero, z); Max2DMatrix.DrawTriangle(vA, vB, p.B, zero, z); } LightingDebug.shadowGenerations++; } }
static public void FreeBuffer(LightingBuffer2D buffer) { if (buffer == null) { return; } if (buffer.Light != null) { buffer.Light.Buffer = null; buffer.Light = null; } buffer.updateNeeded = false; }
void DrawLightingBuffers(float z) { // Lighting Buffers foreach (LightingBuffer2D id in LightingBuffer2D.GetList()) { if (id.lightSource != null) { if (id.lightSource.isActiveAndEnabled) { Vector3 pos = id.lightSource.transform.position - Camera.main.transform.position; float size = id.bufferCamera.orthographicSize; Max2D.iDrawImage(id.material, new Vector2D(pos), new Vector2D(size, size), z); } } } }
static public LightingBuffer2D GetBuffer(int textureSize, LightingSource2D lightSource) { foreach (LightingBuffer2D id in LightingBuffer2D.GetList()) { if ((id.lightSource == lightSource || id.lightSource == null) && id.textureSize == textureSize) { id.lightSource = lightSource; lightSource.update = true; id.bufferCamera.enabled = true; //id.gameObject.SetActive (true); return(id); } } return(AddBuffer(textureSize)); }
static public void OnGUI() { if (timer == null) { LightingDebug.timer = TimerHelper.Create(); } if (timer.GetMillisecs() > 1000) { ShowLightBufferUpdates = LightBufferUpdates; LightBufferUpdates = 0; timer = TimerHelper.Create(); } GUI.Label(new Rect(10, 10, 200, 20), "Light Buffer Updates: " + ShowLightBufferUpdates); GUI.Label(new Rect(10, 30, 200, 20), "Light Buffer Count: " + LightingBuffer2D.GetList().Count); }
public static void DrawShadowsWithoutAtlas(LightingBuffer2D buffer, int layer) { float lightSizeSquared = Mathf.Sqrt(buffer.lightSource.lightSize * buffer.lightSource.lightSize + buffer.lightSource.lightSize * buffer.lightSource.lightSize); float z = buffer.transform.position.z; offset.x = -buffer.lightSource.transform.position.x; offset.y = -buffer.lightSource.transform.position.y; manager = LightingManager2D.Get(); colliderList = LightingCollider2D.GetList(); #if UNITY_2018_1_OR_NEWER tilemapList = LightingTilemapCollider2D.GetList(); #endif manager.materials.GetAtlasMaterial().SetPass(0); GL.Begin(GL.TRIANGLES); for (int id = 0; id < colliderList.Count; id++) { if ((int)colliderList[id].lightingCollisionLayer != layer) { continue; } LightingBufferMesh.Shadow(buffer, colliderList[id], lightSizeSquared, z); LightingBufferShape.Shadow(buffer, colliderList[id], lightSizeSquared, z, offset); } #if UNITY_2018_1_OR_NEWER for (int id = 0; id < tilemapList.Count; id++) { if ((int)tilemapList[id].lightingCollisionLayer != layer) { continue; } LightingBufferTilemapRectangle.Shadow(buffer, tilemapList[id], lightSizeSquared, z); } #endif GL.End(); }
public static void CalculatePoints(LightingBuffer2D buffer) { float rotation = buffer.lightSource.transform.rotation.eulerAngles.z * Mathf.Deg2Rad + Mathf.PI / 4; float squaredSize = Mathf.Sqrt((float)((size.x * size.x) + (size.y * size.y))); p0.RotToVecItself(rotation); p0.x *= squaredSize; p0.y *= squaredSize; p1.RotToVecItself(rotation + Mathf.PI / 2); p1.x *= squaredSize; p1.y *= squaredSize; p2.RotToVecItself(rotation + Mathf.PI); p2.x *= squaredSize; p2.y *= squaredSize; p3.RotToVecItself(rotation - Mathf.PI / 2); p3.x *= squaredSize; p3.y *= squaredSize; z0.RotToVecItself(rotation + Mathf.PI / 4 + Mathf.PI / 2); z0.x *= squaredSize; z0.y *= squaredSize; z1.RotToVecItself(rotation + Mathf.PI / 4); z1.x *= squaredSize; z1.y *= squaredSize; z2.RotToVecItself(rotation + Mathf.PI / 4 - Mathf.PI / 2); z2.x *= squaredSize; z2.y *= squaredSize; z3.RotToVecItself(rotation + Mathf.PI / 4 - Mathf.PI); z3.x *= squaredSize; z3.y *= squaredSize; z4.RotToVecItself(rotation + Mathf.PI / 4 - Mathf.PI / 2 - Mathf.PI); z4.x *= squaredSize; z4.y *= squaredSize; z5.RotToVecItself(rotation + Mathf.PI / 4 + Mathf.PI); z5.x *= squaredSize; z5.y *= squaredSize; }
static public void DrawShadowsAndMask(LightingBuffer2D buffer, int layer) { buffer.CalculateCoords(); offset.x = -buffer.lightSource.transform.position.x; offset.y = -buffer.lightSource.transform.position.y; manager = LightingManager2D.Get(); layerSettings = buffer.lightSource.layerSetting[layer]; z = buffer.transform.position.z; lightSizeSquared = Mathf.Sqrt(buffer.lightSource.lightSize * buffer.lightSource.lightSize + buffer.lightSource.lightSize * buffer.lightSource.lightSize); SortObjects(buffer, layer); drawMask = false; if (buffer.lightSource.layerSetting[layer].type != LightingLayerType.ShadowOnly) { drawMask = true; } drawShadows = false; if (buffer.lightSource.layerSetting[layer].type != LightingLayerType.MaskOnly) { drawShadows = true; } GL.PushMatrix(); if (manager.lightingSpriteAtlas && SpriteAtlasManager.Get().atlasTexture != null) { DrawWithAtlas(buffer, layer); } else { DrawWithoutAtlas(buffer, layer); } GL.PopMatrix(); }
void Update() { if (updatePosition != transform.position) { updatePosition = transform.position; update = true; } if (updateRotation != transform.rotation.eulerAngles.z) { updateRotation = transform.rotation.eulerAngles.z; update = true; } if (updateSize != lightSize) { updateSize = lightSize; update = true; } if (updateColor.Equals(lightColor) == false) { updateColor = lightColor; } if (updateAlpha != lightAlpha) { updateAlpha = lightAlpha; } if (update == true) { LightingBuffer2D buffer = LightingBuffer2D.GetBuffer(GetTextureSize(), this); buffer.lightSource = this; //buffer.bufferCamera.enabled=true; } }
static public void OnGUI() { if (timer == null) { LightingDebug.timer = TimerHelper.Create(); } if (timer.GetMillisecs() > 1000) { ShowLightBufferUpdates = LightBufferUpdates; LightBufferUpdates = 0; ShowLightMainBufferUpdates = LightMainBufferUpdates; LightMainBufferUpdates = 0; ShowLightMainCameraUpdates = LightMainCameraUpdates; LightMainCameraUpdates = 0; timer = TimerHelper.Create(); } ShowLightSourceDrawn = LightSourceDrawn; LightSourceDrawn = 0; GUI.Label(new Rect(10, 10, 200, 20), "Light Buffer Updates: " + ShowLightBufferUpdates); GUI.Label(new Rect(10, 30, 200, 20), "Light Main Buffer Updates: " + ShowLightMainBufferUpdates); GUI.Label(new Rect(10, 50, 200, 20), "Light Main Camera Updates: " + ShowLightMainCameraUpdates); GUI.Label(new Rect(10, 70, 200, 20), "Light Buffer Count: " + LightingBuffer2D.GetList().Count); GUI.Label(new Rect(10, 90, 200, 20), "Light Collider Count: " + LightingCollider2D.GetList().Count); Texture texture = LightingMainBuffer2D.Get().bufferCamera.activeTexture; GUI.Label(new Rect(10, 110, 200, 20), "Main Buffer Resolution: " + texture.width + "x" + texture.height); GUI.Label(new Rect(10, 130, 200, 20), "Light Sources Drawn: " + ShowLightSourceDrawn); }