// 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++;
}
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++;
}
void InitializeUnityDefault()
{
tilemap2D = GetComponent <Tilemap>();
if (tilemap2D == null)
{
return;
}
Grid grid = tilemap2D.layoutGrid;
if (grid == null)
{
Debug.LogError("Lighting 2D Error: Lighting Tilemap Collider is missing Grid");
}
else
{
cellSize = grid.cellSize;
}
cellAnchor = tilemap2D.tileAnchor;
int minPos = Mathf.Min(tilemap2D.cellBounds.xMin, tilemap2D.cellBounds.yMin);
int maxPos = Mathf.Max(tilemap2D.cellBounds.size.x, tilemap2D.cellBounds.size.y);
area = new BoundsInt(minPos, minPos, 0, maxPos + Mathf.Abs(minPos), maxPos + Mathf.Abs(minPos), 1);
TileBase[] tileArray = tilemap2D.GetTilesBlock(area);
map = new LightingTile[area.size.x + 1, area.size.y + 1];
for (int index = 0; index < tileArray.Length; index++)
{
TileBase tile = tileArray[index];
if (tile == null)
{
continue;
}
TileData tileData = new TileData();
ITilemap tilemap = (ITilemap)FormatterServices.GetUninitializedObject(typeof(ITilemap));
typeof(ITilemap).GetField("m_Tilemap", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(tilemap, tilemap2D);
tile.GetTileData(new Vector3Int(0, 0, 0), tilemap, ref tileData);
LightingTile lightingTile = new LightingTile();
lightingTile.SetOriginalSprite(tileData.sprite);
lightingTile.GetShapePolygons();
map[(index % area.size.x), (index / area.size.x)] = lightingTile;
//map[(index % area.size.x), (index / area.size.y)] = true;
}
}
public static void DrawTiles(Camera camera, LightTilemapRoom2D id, Material material)
{
Vector2 cameraPosition = -camera.transform.position;
float cameraRadius = CameraTransform.GetRadius(camera);
if (id.superTilemapEditor.tilemap == null)
{
return;
}
if (id.superTilemapEditor.tilemap.Tileset != null)
{
material.mainTexture = id.superTilemapEditor.tilemap.Tileset.AtlasTexture;
}
material.color = id.color;
LightTilemapCollider.Base tilemapCollider = id.GetCurrentTilemap();
material.SetPass(0);
GL.Begin(GL.QUADS);
int count = id.superTilemapEditor.chunkManager.GetTiles(CameraTransform.GetWorldRect(camera));
for (int i = 0; i < count; i++)
{
LightingTile tile = id.superTilemapEditor.chunkManager.display[i];
Vector2 tilePosition = tile.GetWorldPosition(tilemapCollider);
tilePosition += cameraPosition;
if (tile.NotInRange(tilePosition, cameraRadius))
{
continue;
}
Vector2 scale = tile.worldScale * 0.5f * tile.scale;
Rendering.Universal.Texture.DrawPassSTE(tilePosition, scale, tile.uv, tile.worldRotation, 0);
}
GL.End();
material.mainTexture = null;
material.color = Color.white;
}
public void Add(LightingTilemapCollider2D tilemap, LightingTile tile2D, float dist, Vector2D polyOffset)
{
if (count + 1 < list.Length)
{
list[count].type = ColliderDepth.Type.Tile;
list[count].tile = tile2D;
list[count].tilemap = tilemap;
list[count].distance = dist;
list[count].polyOffset.x = polyOffset.x;
list[count].polyOffset.y = polyOffset.y;
// Tile Size?
count++;
}
else
{
Debug.LogError("Tile Depth Overhead!");
}
}
static public void Grid(Light2D light, LightTilemapCollider2D id)
{
Vector2 lightPosition = -light.transform.position;
LightTilemapCollider.Base tilemapCollider = id.GetCurrentTilemap();
int count = tilemapCollider.chunkManager.GetTiles(light.GetWorldRect());
for (int i = 0; i < count; i++)
{
LightingTile tile = tilemapCollider.chunkManager.display[i];
List <Polygon2> polygons = tile.GetWorldPolygons(tilemapCollider);
Vector2 tilePosition = tile.GetWorldPosition(tilemapCollider);
if (tile.NotInRange(tilePosition + lightPosition, light.size))
{
continue;
}
Rendering.Light.ShadowEngine.Draw(polygons, 0, 0);
}
}
static public void DrawMask(LightingBuffer2D buffer, LightingTile tile, LightingLayerEffect maskEffect, Material materialA, Material materialB, Vector2D polyOffset, LightingTilemapCollider2D tilemap, float lightSizeSquared, float z)
{
VirtualSpriteRenderer spriteRenderer = new VirtualSpriteRenderer();
spriteRenderer.sprite = tile.GetOriginalSprite();
if (spriteRenderer.sprite == null)
{
return;
}
Vector3 rot = Math2D.GetPitchYawRollRad(tilemap.transform.rotation);
float rotationYScale = Mathf.Sin(rot.x + Mathf.PI / 2);
float rotationXScale = Mathf.Sin(rot.y + Mathf.PI / 2);
float scaleX = tilemap.transform.lossyScale.x * rotationXScale * tilemap.cellSize.x;
float scaleY = tilemap.transform.lossyScale.y * rotationYScale * tilemap.cellSize.y;
Vector2 tileSize = new Vector2(scaleX / tilemap.cellSize.x, scaleY / tilemap.cellSize.y);
Material material = materialA;
if (tilemap.maskMode == LightingMaskMode.Invisible || (maskEffect == LightingLayerEffect.InvisibleBellow && polyOffset.y < 0))
{
material = materialB;
}
material.mainTexture = spriteRenderer.sprite.texture;
Max2D.DrawSprite(material, spriteRenderer, polyOffset.ToVector2(), tileSize, 0, z);
material.mainTexture = null;
LightingDebug.maskGenerations++;
}
static public void DrawTilemaps(Vector2D offset, float z)
{
#if UNITY_2018_1_OR_NEWER
LightingManager2D manager = LightingManager2D.Get();
GL.PushMatrix();
Max2D.defaultMaterial.SetPass(0);
GL.Begin(GL.TRIANGLES);
GL.Color(Color.black);
// Day Soft Shadows
foreach (LightingTilemapCollider2D id in LightingTilemapCollider2D.GetList())
{
if (id.map == null)
{
continue;
}
if (id.dayHeight == false)
{
continue;
}
Vector2D tilesetOffset = new Vector2D(offset);
tilesetOffset += new Vector2D(id.area.position.x, id.area.position.y);
for (int x = 0; x < id.area.size.x; x++)
{
for (int y = 0; y < id.area.size.y; y++)
{
if (id.map[x, y] == null)
{
continue;
}
Vector2D tileOffset = tilesetOffset.Copy();
tileOffset += new Vector2D(x, y);
DrawSoftShadowTile(tileOffset, z, id.height);
}
}
}
GL.End();
GL.PopMatrix();
GL.PushMatrix();
manager.materials.GetShadowBlur().SetPass(0);
GL.Begin(GL.TRIANGLES);
Max2D.SetColor(Color.white);
// Day Soft Shadows Penumbra
foreach (LightingTilemapCollider2D id in LightingTilemapCollider2D.GetList())
{
if (id.map == null)
{
continue;
}
if (id.dayHeight == false)
{
continue;
}
Vector2D tilesetOffset = new Vector2D(offset);
tilesetOffset += new Vector2D(id.area.position.x, id.area.position.y);
for (int x = 0; x < id.area.size.x; x++)
{
for (int y = 0; y < id.area.size.y; y++)
{
if (id.map[x, y] == null)
{
continue;
}
Vector2D tileOffset = tilesetOffset.Copy();
tileOffset += new Vector2D(x, y);
DrawSoftShadowTileBlur(tileOffset, z, id.height);
}
}
}
GL.End();
GL.PopMatrix();
Material materialWhite = manager.materials.GetWhiteSprite();
// Tilemap Daylighting Masks
foreach (LightingTilemapCollider2D id in LightingTilemapCollider2D.GetList())
{
if (id.map == null)
{
continue;
}
if (id.dayHeight == false)
{
continue;
}
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);
float scaleX = id.transform.lossyScale.x * rotationXScale * id.cellSize.x;
float scaleY = id.transform.lossyScale.y * rotationYScale * id.cellSize.y;
Vector2D tilesetOffset = new Vector2D(offset);
tilesetOffset += new Vector2D(id.area.position.x, id.area.position.y);
tilesetOffset += new Vector2D(id.cellAnchor.x, id.cellAnchor.y);
//GL.PushMatrix ();
for (int x = 0; x < id.area.size.x; x++)
{
for (int y = 0; y < id.area.size.y; y++)
{
LightingTile tile = id.map[x, y];
if (tile == null)
{
continue;
}
if (tile.GetOriginalSprite() == null)
{
continue;
}
VirtualSpriteRenderer spriteRenderer = new VirtualSpriteRenderer();
spriteRenderer.sprite = tile.GetOriginalSprite();
materialWhite.mainTexture = tile.GetOriginalSprite().texture;
Vector2D tileOffset = tilesetOffset.Copy();
tileOffset += new Vector2D(x, y);
//Max2D.DrawSprite(materialWhite, spriteRenderer, tileOffset.ToVector2(), new Vector2(scaleX / id.cellSize.x, scaleY / id.cellSize.y), 0, z);
materialWhite.mainTexture = null;
}
}
}
//GL.PopMatrix ();
#endif
}
public void Initialize()
{
switch (mapType)
{
case MapType.UnityEngineTilemap:
tilemap2D = GetComponent <Tilemap>();
if (tilemap2D == null)
{
return;
}
Grid grid = tilemap2D.layoutGrid;
if (grid == null)
{
Debug.LogError("Lighting 2D Error: Lighting Tilemap Collider is missing Grid");
}
else
{
cellSize = grid.cellSize;
}
cellAnchor = tilemap2D.tileAnchor;
int minPos = Mathf.Min(tilemap2D.cellBounds.xMin, tilemap2D.cellBounds.yMin);
int maxPos = Mathf.Max(tilemap2D.cellBounds.size.x, tilemap2D.cellBounds.size.y);
area = new BoundsInt(minPos, minPos, 0, maxPos, maxPos, 1);
TileBase[] tileArray = tilemap2D.GetTilesBlock(area);
map = new LightingTile[area.size.x + 1, area.size.y + 1];
for (int index = 0; index < tileArray.Length; index++)
{
TileBase tile = tileArray[index];
if (tile == null)
{
continue;
}
TileData tileData = new TileData();
ITilemap tilemap = (ITilemap)FormatterServices.GetUninitializedObject(typeof(ITilemap));
typeof(ITilemap).GetField("m_Tilemap", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(tilemap, tilemap2D);
tile.GetTileData(new Vector3Int(0, 0, 0), tilemap, ref tileData);
LightingTile lightingTile = new LightingTile();
lightingTile.sprite = tileData.sprite;
lightingTile.GeneratePhysicsShape();
map[(index % area.size.x), (index / area.size.x)] = lightingTile;
//map[(index % area.size.x), (index / area.size.y)] = true;
}
break;
case MapType.SuperTilemapEditor:
/*
* CreativeSpore.SuperTilemapEditor.STETilemap tilemapSTE = GetComponent<CreativeSpore.SuperTilemapEditor.STETilemap>();
*
* map = new LightingTile[tilemapSTE.GridWidth + 2, tilemapSTE.GridHeight + 2];
*
* area.position = new Vector3Int((int)tilemapSTE.MapBounds.center.x, (int)tilemapSTE.MapBounds.center.y, 0);
*
* area.size = new Vector3Int((int)(tilemapSTE.MapBounds.extents.x + 1) * 2, (int)(tilemapSTE.MapBounds.extents.y + 1) * 2, 0);
*
* for(int x = 0; x <= tilemapSTE.GridWidth; x++) {
* for(int y = 0; y <= tilemapSTE.GridHeight; y++) {
* int tileX = x + area.position.x - area.size.x / 2;
* int tileY = y + area.position.y - area.size.y / 2;
* if(tilemapSTE.GetTile(tileX, tileY) == null) {
* continue;
* }
* LightingTile lightingTile = new LightingTile();
* map[x, y] = lightingTile;
* }
* }
*/
break;
}
}
static public void Shadow(LightingBuffer2D buffer, LightingTilemapCollider2D id, float lightSizeSquared, float z)
{
if (id.colliderType == LightingTilemapCollider2D.ColliderType.None)
{
return;
}
if (id.colliderType == LightingTilemapCollider2D.ColliderType.Collider)
{
// Adjust Color?
Fill_Component(buffer, id, lightSizeSquared, z);
Penumbra_Component(buffer, id, lightSizeSquared, z);
return;
}
if (id.map == null)
{
return;
}
manager = LightingManager2D.Get();
SetupLocation(buffer, id);
CalculatePenumbra();
bool penumbra = manager.drawPenumbra;
bool drawAbove = buffer.lightSource.whenInsideCollider == LightingSource2D.WhenInsideCollider.DrawAbove;
for (int x = newPositionInt.x - sizeInt; x < newPositionInt.x + sizeInt; x++)
{
for (int y = newPositionInt.y - sizeInt; y < newPositionInt.y + sizeInt; y++)
{
if (x < 0 || y < 0)
{
continue;
}
if (x >= id.area.size.x || y >= id.area.size.y)
{
continue;
}
tile = id.map[x, y];
if (tile == null)
{
continue;
}
polygons = tile.GetPolygon(id);
if (polygons == null || polygons.Count < 1)
{
continue;
}
polyOffset.x = x + tilemapOffset.x;
polyOffset.y = y + tilemapOffset.y;
if (id.mapType == LightingTilemapCollider2D.MapType.SuperTilemapEditor)
{
polyOffset.x -= id.area.size.x / 2;
polyOffset.y -= id.area.size.y / 2;
}
polyOffset.x *= scale.x;
polyOffset.y *= scale.y;
polyOffset2.x = (float)polyOffset.x;
polyOffset2.y = (float)polyOffset.y;
if (LightingManager2D.culling && Vector2.Distance(polyOffset2, buffer.lightSource.transform.position) > 2 + buffer.lightSource.lightSize)
{
LightingDebug.culled++;
continue;
}
polyOffset.x += offset.x;
polyOffset.y += offset.y;
inverseOffset.x = -polyOffset.x;
inverseOffset.y = -polyOffset.y;
pairList2 = tile.GetPairs(id);
for (int i = 0; i < polygons.Count; i++)
{
polygon = polygons[i];
if (drawAbove && polygon.PointInPoly(inverseOffset))
{
continue;
}
LightingDebug.shadowGenerations++;
pairList = pairList2[i];
GL.Color(Color.black);
for (int e = 0; e < pairList.Count; e++)
{
p = pairList[e];
vA.x = p.A.x + polyOffset.x;
vA.y = p.A.y + polyOffset.y;
vB.x = p.B.x + polyOffset.x;
vB.y = p.B.y + polyOffset.y;
vC.x = p.A.x + polyOffset.x;
vC.y = p.A.y + polyOffset.y;
vD.x = p.B.x + polyOffset.x;
vD.y = p.B.y + polyOffset.y;
rot = System.Math.Atan2(vA.y - zero.y, vA.x - zero.x);
vA.x += System.Math.Cos(rot) * lightSizeSquared;
vA.y += System.Math.Sin(rot) * lightSizeSquared;
rot = System.Math.Atan2(vB.y - zero.y, vB.x - zero.x);
vB.x += System.Math.Cos(rot) * lightSizeSquared;
vB.y += System.Math.Sin(rot) * lightSizeSquared;
GL.TexCoord3(Max2DMatrix.c_x, Max2DMatrix.c_y, 0);
GL.Vertex3((float)vC.x, (float)vC.y, z);
GL.TexCoord3(Max2DMatrix.c_x, Max2DMatrix.c_y, 0);
GL.Vertex3((float)vD.x, (float)vD.y, z);
GL.TexCoord3(Max2DMatrix.c_x, Max2DMatrix.c_y, 0);
GL.Vertex3((float)vA.x, (float)vA.y, z);
GL.TexCoord3(Max2DMatrix.c_x, Max2DMatrix.c_y, 0);
GL.Vertex3((float)vA.x, (float)vA.y, z);
GL.TexCoord3(Max2DMatrix.c_x, Max2DMatrix.c_y, 0);
GL.Vertex3((float)vB.x, (float)vB.y, z);
GL.TexCoord3(Max2DMatrix.c_x, Max2DMatrix.c_y, 0);
GL.Vertex3((float)vD.x, (float)vD.y, z);
}
if (penumbra)
{
GL.Color(Color.white);
for (int e = 0; e < pairList.Count; e++)
{
p = pairList[e];
vA.x = p.A.x + polyOffset.x;
vA.y = p.A.y + polyOffset.y;
pA.x = p.A.x + polyOffset.x;
pA.y = p.A.y + polyOffset.y;
pB.x = p.B.x + polyOffset.x;
pB.y = p.B.y + polyOffset.y;
vB.x = p.B.x + polyOffset.x;
vB.y = p.B.y + polyOffset.y;
vC.x = p.A.x + polyOffset.x;
vC.y = p.A.y + polyOffset.y;
vD.x = p.B.x + polyOffset.x;
vD.y = p.B.y + polyOffset.y;
angleA = (float)System.Math.Atan2(vA.y - zero.y, vA.x - zero.x);
angleB = (float)System.Math.Atan2(vB.y - zero.y, vB.x - zero.x);
vA.x += System.Math.Cos(angleA) * lightSizeSquared;
vA.y += System.Math.Sin(angleA) * lightSizeSquared;
vB.x += System.Math.Cos(angleB) * lightSizeSquared;
vB.y += System.Math.Sin(angleB) * lightSizeSquared;
rot = angleA - Mathf.Deg2Rad * buffer.lightSource.occlusionSize;
pA.x += System.Math.Cos(rot) * lightSizeSquared;
pA.y += System.Math.Sin(rot) * lightSizeSquared;
rot = angleB + Mathf.Deg2Rad * buffer.lightSource.occlusionSize;
pB.x += System.Math.Cos(rot) * lightSizeSquared;
pB.y += System.Math.Sin(rot) * lightSizeSquared;
GL.TexCoord3(uvRectX, uvRectY, 0);
GL.Vertex3((float)vC.x, (float)vC.y, z);
GL.TexCoord3(uvRectWidth, uvRectHeight, 0);
GL.Vertex3((float)vA.x, (float)vA.y, z);
GL.TexCoord3((float)uvRectX, uvRectHeight, 0);
GL.Vertex3((float)pA.x, (float)pA.y, z);
GL.TexCoord3(uvRectX, uvRectY, 0);
GL.Vertex3((float)vD.x, (float)vD.y, z);
GL.TexCoord3(uvRectWidth, uvRectY, 0);
GL.Vertex3((float)vB.x, (float)vB.y, z);
GL.TexCoord3(uvRectX, uvRectHeight, 0);
GL.Vertex3((float)pB.x, (float)pB.y, z);
}
}
}
}
}
}
static public void MaskShape(LightingBuffer2D buffer, LightingTilemapCollider2D id, Vector2D offset, float z)
{
if (id.maskType == LightingTilemapCollider2D.MaskType.SpriteCustomPhysicsShape || id.maskType == LightingTilemapCollider2D.MaskType.Tile)
{
}
else
{
return;
}
if (id.map == null)
{
return;
}
SetupLocation(buffer, id);
Vector2 vecA, vecB, vecC;
LightingTile tile;
Mesh tileMesh = null;
int triangleCount;
tileSize2.x = 1;
tileSize2.y = 1;
if (id.maskType == LightingTilemapCollider2D.MaskType.Tile)
{
tileMesh = LightingTile.GetStaticTileMesh();
}
for (int x = newPositionInt.x - sizeInt; x < newPositionInt.x + sizeInt; x++)
{
for (int y = newPositionInt.y - sizeInt; y < newPositionInt.y + sizeInt; y++)
{
if (x < 0 || y < 0)
{
continue;
}
if (x >= id.area.size.x || y >= id.area.size.y)
{
continue;
}
tile = id.map[x, y];
if (tile == null)
{
continue;
}
polyOffset.x = x + tilemapOffset.x;
polyOffset.y = y + tilemapOffset.y;
polyOffset.x *= scale.x;
polyOffset.y *= scale.y;
polyOffset2.x = (float)polyOffset.x;
polyOffset2.y = (float)polyOffset.y;
if (LightingManager2D.culling && Vector2.Distance(polyOffset2, buffer.lightSource.transform.position) > (id.cellSize.x * 2f) + buffer.lightSource.lightSize)
{
LightingDebug.culled++;
continue;
}
polyOffset.x += offset.x;
polyOffset.y += offset.y;
if (id.maskType == LightingTilemapCollider2D.MaskType.SpriteCustomPhysicsShape)
{
tileMesh = null;
tileMesh = tile.GetTileDynamicMesh();
}
if (tileMesh == null)
{
continue;
}
polyOffset2.x = (float)polyOffset.x;
polyOffset2.y = (float)polyOffset.y;
// Batch and Optimize???
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, polyOffset2, z, tileSize2);
}
LightingDebug.maskGenerations++;
}
}
}
static public void MaskSpriteWithoutAtlas(LightingBuffer2D buffer, LightingTilemapCollider2D id, Material materialA, Material materialB, Vector2D offset, float z)
{
if (id.maskType != LightingTilemapCollider2D.MaskType.Sprite)
{
return;
}
if (id.map == null)
{
return;
}
Material material;
SetupLocation(buffer, id);
bool maskEffect = (buffer.lightSource.layerSetting[0].effect == LightingLayerEffect.InvisibleBellow);
bool invisible = (id.maskMode == LightingMaskMode.Invisible);
for (int x = newPositionInt.x - sizeInt; x < newPositionInt.x + sizeInt; x++)
{
for (int y = newPositionInt.y - sizeInt; y < newPositionInt.y + sizeInt; y++)
{
if (x < 0 || y < 0)
{
continue;
}
if (x >= id.area.size.x || y >= id.area.size.y)
{
continue;
}
tile = id.map[x, y];
if (tile == null)
{
continue;
}
if (tile.GetOriginalSprite() == null)
{
return;
}
polyOffset.x = x + tilemapOffset.x;
polyOffset.y = y + tilemapOffset.y;
polyOffset.x *= scale.x;
polyOffset.y *= scale.y;
polyOffset2.x = (float)polyOffset.x;
polyOffset2.y = (float)polyOffset.y;
if (LightingManager2D.culling && Vector2.Distance(polyOffset2, buffer.lightSource.transform.position) > 2 + buffer.lightSource.lightSize)
{
LightingDebug.culled++;
continue;
}
polyOffset.x += offset.x;
polyOffset.y += offset.y;
spriteRenderer.sprite = tile.GetOriginalSprite();
polyOffset2.x = (float)polyOffset.x;
polyOffset2.y = (float)polyOffset.y;
if (invisible || (maskEffect && polyOffset2.y < 0))
{
material = materialB;
}
else
{
material = materialA;
}
material.mainTexture = spriteRenderer.sprite.texture;
Max2D.DrawSprite(material, spriteRenderer, polyOffset2, tileSize, 0, z);
material.mainTexture = null;
LightingDebug.maskGenerations++;
}
}
}
static public void MaskSpriteWithAtlas(LightingBuffer2D buffer, LightingTilemapCollider2D id, Vector2D offset, float z)
{
if (id.maskType != LightingTilemapCollider2D.MaskType.Sprite)
{
return;
}
if (id.map == null)
{
return;
}
SetupLocation(buffer, id);
Sprite reqSprite;
PartiallyBatched_Tilemap batched;
for (int x = newPositionInt.x - sizeInt; x < newPositionInt.x + sizeInt; x++)
{
for (int y = newPositionInt.y - sizeInt; y < newPositionInt.y + sizeInt; y++)
{
if (x < 0 || y < 0)
{
continue;
}
if (x >= id.area.size.x || y >= id.area.size.y)
{
continue;
}
tile = id.map[x, y];
if (tile == null)
{
continue;
}
if (tile.GetOriginalSprite() == null)
{
continue;
}
polyOffset.x = x + tilemapOffset.x;
polyOffset.y = y + tilemapOffset.y;
polyOffset.x *= scale.x;
polyOffset.y *= scale.y;
polyOffset2.x = (float)polyOffset.x;
polyOffset2.y = (float)polyOffset.y;
if (LightingManager2D.culling && Vector2.Distance(polyOffset2, buffer.lightSource.transform.position) > 2 + buffer.lightSource.lightSize)
{
LightingDebug.culled++;
continue;
}
polyOffset.x += offset.x;
polyOffset.y += offset.y;
spriteRenderer.sprite = tile.GetAtlasSprite();
if (spriteRenderer.sprite == null)
{
reqSprite = SpriteAtlasManager.RequestSprite(tile.GetOriginalSprite(), SpriteRequest.Type.WhiteMask);
if (reqSprite == null)
{
// Add Partialy Batched
batched = new PartiallyBatched_Tilemap();
batched.virtualSpriteRenderer = new VirtualSpriteRenderer();
batched.virtualSpriteRenderer.sprite = tile.GetOriginalSprite();
batched.polyOffset = polyOffset.ToVector2();
batched.tileSize = tileSize;
buffer.partiallyBatchedList_Tilemap.Add(batched);
continue;
}
else
{
tile.SetAtlasSprite(reqSprite);
spriteRenderer.sprite = reqSprite;
}
}
polyOffset2.x = (float)polyOffset.x;
polyOffset2.y = (float)polyOffset.y;
Max2D.DrawSpriteBatched_Tris(spriteRenderer, buffer.lightSource.layerSetting[0], id.maskMode, polyOffset2, tileSize, 0, z);
LightingDebug.maskGenerations++;
}
}
}
static public void DrawShadow(LightingBuffer2D buffer, LightingTile tile, Vector2D polyOffset, LightingTilemapCollider2D tilemap, float lightSizeSquared, float z)
{
if (tile.GetPairs(tilemap).Count < 1)
{
return;
}
LightingBufferTilemapRectangle.pairList = tile.GetPairs(tilemap)[0];
Pair2D p;
Vector2D zero = Vector2D.Zero();
GL.Color(Color.black);
for (int s = 0; s < LightingBufferTilemapRectangle.pairList.Count; s++)
{
p = LightingBufferTilemapRectangle.pairList[s];
vA.x = p.A.x + polyOffset.x;
vA.y = p.A.y + polyOffset.y;
vB.x = p.B.x + polyOffset.x;
vB.y = p.B.y + polyOffset.y;
vC.x = p.A.x + polyOffset.x;
vC.y = p.A.y + polyOffset.y;
vD.x = p.B.x + polyOffset.x;
vD.y = p.B.y + polyOffset.y;
vA.Push(Vector2D.Atan2(vA, zero), lightSizeSquared);
vB.Push(Vector2D.Atan2(vB, zero), lightSizeSquared);
Max2DMatrix.DrawTriangle(vC, vD, vA, zero, z);
Max2DMatrix.DrawTriangle(vA, vB, vD, zero, z);
}
Sprite penumbraSprite = LightingManager2D.Get().materials.GetAtlasPenumbraSprite();
float angleA, angleB;
Rect uvRect = new Rect((float)penumbraSprite.rect.x / penumbraSprite.texture.width, (float)penumbraSprite.rect.y / penumbraSprite.texture.height, (float)penumbraSprite.rect.width / penumbraSprite.texture.width, (float)penumbraSprite.rect.height / penumbraSprite.texture.height);
uvRect.width += uvRect.x;
uvRect.height += uvRect.y;
uvRect.x += 1f / 2048;
uvRect.y += 1f / 2048;
uvRect.width -= 1f / 2048;
uvRect.height -= 1f / 2048;
GL.Color(Color.white);
for (int s = 0; s < LightingBufferTilemapRectangle.pairList.Count; s++)
{
p = LightingBufferTilemapRectangle.pairList[s];
vA.x = p.A.x + polyOffset.x;
vA.y = p.A.y + polyOffset.y;
pA.x = p.A.x + polyOffset.x;
pA.y = p.A.y + polyOffset.y;
pB.x = p.B.x + polyOffset.x;
pB.y = p.B.y + polyOffset.y;
vB.x = p.B.x + polyOffset.x;
vB.y = p.B.y + polyOffset.y;
vC.x = p.A.x + polyOffset.x;
vC.y = p.A.y + polyOffset.y;
vD.x = p.B.x + polyOffset.x;
vD.y = p.B.y + polyOffset.y;
angleA = (float)Vector2D.Atan2(vA, zero);
angleB = (float)Vector2D.Atan2(vB, zero);
vA.Push(angleA, lightSizeSquared);
pA.Push(angleA - Mathf.Deg2Rad * buffer.lightSource.occlusionSize, lightSizeSquared);
vB.Push(angleB, lightSizeSquared);
pB.Push(angleB + Mathf.Deg2Rad * buffer.lightSource.occlusionSize, lightSizeSquared);
GL.TexCoord2(uvRect.x, uvRect.y);
GL.Vertex3((float)vC.x, (float)vC.y, z);
GL.TexCoord2(uvRect.width, uvRect.y);
GL.Vertex3((float)vA.x, (float)vA.y, z);
GL.TexCoord2((float)uvRect.x, uvRect.height);
GL.Vertex3((float)pA.x, (float)pA.y, z);
GL.TexCoord2(uvRect.x, uvRect.y);
GL.Vertex3((float)vD.x, (float)vD.y, z);
GL.TexCoord2(uvRect.width, uvRect.y);
GL.Vertex3((float)vB.x, (float)vB.y, z);
GL.TexCoord2(uvRect.x, uvRect.height);
GL.Vertex3((float)pB.x, (float)pB.y, z);
}
LightingDebug.shadowGenerations++;
}
