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);
}
