private void DrawGizmos()
{
if (isActiveAndEnabled == false)
{
return;
}
Gizmos.color = new Color(1f, 0.5f, 0.25f);
LightTilemapCollider.Base tilemap = GetCurrentTilemap();
foreach (DayLightingTile dayTile in dayTiles)
{
GizmosHelper.DrawPolygons(dayTile.polygons, transform.position);
}
Gizmos.color = new Color(0, 1f, 1f);
switch (Lighting2D.ProjectSettings.editorView.drawGizmosBounds)
{
case EditorGizmosBounds.Rectangle:
GizmosHelper.DrawRect(transform.position, tilemap.GetRect());
break;
}
}
private void DrawGizmos()
{
if (isActiveAndEnabled == false)
{
return;
}
Gizmos.color = new Color(1f, 0.5f, 0.25f);
LightTilemapCollider.Base tilemap = GetCurrentTilemap();
foreach (LightTile tile in GetTileList())
{
GizmosHelper.DrawPolygons(tile.GetWorldPolygons(tilemap), transform.position);
}
// GizmosHelper.DrawPolygons(superTilemapEditor.GetWorldColliders(), transform.position);
Gizmos.color = new Color(0, 1f, 1f);
switch (Lighting2D.ProjectSettings.editorView.drawGizmosBounds)
{
case EditorGizmosBounds.Rectangle:
GizmosHelper.DrawRect(transform.position, GetCurrentTilemap().GetRect());
break;
}
}
static public void Grid(Light2D light, LightTilemapCollider2D id)
{
if (id.superTilemapEditor.maskTypeSTE != SuperTilemapEditorSupport.TilemapCollider2D.MaskType.Grid)
{
return;
}
Vector2 lightPosition = -light.transform.position;
MeshObject tileMesh = LightingTile.Rectangle.GetStaticMesh();
GL.Color(Color.white);
LightTilemapCollider.Base tilemapBase = id.GetCurrentTilemap();
foreach (LightingTile tile in id.superTilemapEditor.mapTiles)
{
Vector2 tilePosition = tile.GetWorldPosition(tilemapBase);
tilePosition += lightPosition;
if (tile.NotInRange(tilePosition, light.size))
{
continue;
}
GLExtended.DrawMeshPass(tileMesh, tilePosition, tile.worldScale, tile.worldRotation);
}
}
public List <Polygon2> GetWorldPolygons(LightTilemapCollider.Base tilemap)
{
if (worldPolygons == null)
{
List <Polygon2> localPolygons = GetLocalPolygons(tilemap);
if (worldPolygonsCache == null)
{
worldPolygons = new List <Polygon2>();
worldPolygonsCache = worldPolygons;
UpdateTransform(tilemap);
foreach (Polygon2 polygon in localPolygons)
{
Polygon2 worldPolygon = polygon.Copy();
if (scale != Vector2.one)
{
worldPolygon.ToScaleSelf(scale);
}
worldPolygon.ToScaleSelf(worldScale);
worldPolygon.ToRotationSelf((tilemap.transform.eulerAngles.z + rotation) * Mathf.Deg2Rad);
worldPolygon.ToOffsetSelf(worldPosition.Value);
worldPolygons.Add(worldPolygon);
}
}
else
{
worldPolygons = worldPolygonsCache;
UpdateTransform(tilemap);
for (int i = 0; i < localPolygons.Count; i++)
{
Polygon2 polygon = localPolygons[i];
Polygon2 worldPolygon = worldPolygons[i];
for (int j = 0; j < polygon.points.Length; j++)
{
worldPolygon.points[j].x = polygon.points[j].x;
worldPolygon.points[j].y = polygon.points[j].y;
}
if (scale != Vector2.one)
{
worldPolygon.ToScaleSelf(scale);
}
worldPolygon.ToScaleSelf(worldScale);
worldPolygon.ToRotationSelf(tilemap.transform.eulerAngles.z * Mathf.Deg2Rad);
worldPolygon.ToOffsetSelf(worldPosition.Value);
}
}
}
return(worldPolygons);
}
public static void Draw(Camera camera, LightTilemapRoom2D id, Material material)
{
Vector2 cameraPosition = -camera.transform.position;
float cameraRadius = CameraTransform.GetRadius(camera);
LightTilemapCollider.Base tilemapCollider = id.GetCurrentTilemap();
material.mainTexture = null;
Texture2D currentTexture = null;
GL.Begin(GL.QUADS);
int count = tilemapCollider.chunkManager.GetTiles(CameraTransform.GetWorldRect(camera));
for (int i = 0; i < count; i++)
{
LightTile tile = tilemapCollider.chunkManager.display[i];
if (tile.GetOriginalSprite() == null)
{
continue;
}
Vector2 tilePosition = tile.GetWorldPosition(tilemapCollider);
tilePosition += cameraPosition;
if (tile.NotInRange(tilePosition, cameraRadius))
{
continue;
}
spriteRenderer.sprite = tile.GetOriginalSprite();
if (spriteRenderer.sprite.texture == null)
{
continue;
}
if (currentTexture != spriteRenderer.sprite.texture)
{
currentTexture = spriteRenderer.sprite.texture;
material.mainTexture = currentTexture;
material.SetPass(0);
}
Universal.Sprite.FullRect.Simple.DrawPass(tile.spriteMeshObject, spriteRenderer, tilePosition, tile.worldScale, tile.worldRotation);
}
GL.End();
material.mainTexture = null;
}
public void UpdateTransform(LightTilemapCollider.Base tilemap)
{
if (worldPosition != null)
{
return;
}
worldPosition = tilemap.TileWorldPosition(this);
worldRotation = tilemap.TileWorldRotation(this);
worldScale = tilemap.TileWorldScale();
}
// Remove
public Vector2 GetWorldPosition(LightTilemapCollider.Base tilemap)
{
if (worldPosition == null)
{
worldPosition = tilemap.TileWorldPosition(this);
worldRotation = tilemap.TileWorldRotation(this);
worldScale = tilemap.TileWorldScale();
}
return(worldPosition.Value);
}
public void AddTiles(LightTilemapCollider2D id)
{
Vector2 lightPosition = -pass.light.transform2D.position;
LightTilemapCollider.Base tilemapBase = id.GetCurrentTilemap();
foreach (LightTile tile in id.GetTileList())
{
if (tile.GetOriginalSprite() == null)
{
return;
}
Vector2 tilePosition = tile.GetWorldPosition(tilemapBase);
if (tile.NotInRange(tilePosition + lightPosition, pass.light.size))
{
continue;
}
switch (pass.layer.sorting)
{
case LightLayerSorting.SortingLayerAndOrder:
sortList.Add(id, tile, id.lightingTransform.sortingOrder + id.lightingTransform.sortingLayerID * 1000);
break;
case LightLayerSorting.ZAxisLower:
sortList.Add(id, tile, -id.transform.position.z);
break;
case LightLayerSorting.ZAxisHigher:
sortList.Add(id, tile, id.transform.position.z);
break;
case LightLayerSorting.YAxisLower:
sortList.Add(id, tile, -tilePosition.y);
break;
case LightLayerSorting.YAxisHigher:
sortList.Add(id, tile, tilePosition.y);
break;
case LightLayerSorting.DistanceToLight:
sortList.Add(id, tile, -Vector2.Distance(tilePosition, pass.light.transform.position));
break;
case LightLayerSorting.YDistanceToLight:
sortList.Add(id, tile, -Mathf.Abs(tilePosition.y - pass.light.transform.position.y));
break;
}
}
}
public List <Polygon2> GetLocalPolygons(LightTilemapCollider.Base tilemap)
{
if (occluded == true)
{
localPolygons = new List <Polygon2>();
return(localPolygons);
}
if (localPolygons == null)
{
if (tilemap.IsPhysicsShape())
{
List <Polygon2> customShapePolygons = GetPhysicsShapePolygons();
if (customShapePolygons.Count > 0)
{
localPolygons = customShapePolygons;
}
else
{
localPolygons = new List <Polygon2>();
}
}
else
{
localPolygons = new List <Polygon2>();
switch (tilemap.TilemapType())
{
case MapType.UnityRectangle:
case MapType.SuperTilemapEditor:
localPolygons.Add(Polygon2.CreateRect(Vector2.one));
break;
case MapType.UnityIsometric:
localPolygons.Add(Polygon2.CreateIsometric(new Vector2(1, 0.5f)));
break;
case MapType.UnityHexagon:
localPolygons.Add(Polygon2.CreateHexagon(new Vector2(1, 0.5f)));
break;
}
}
}
return(localPolygons);
}
public static MeshObject GetStaticMesh(LightTilemapCollider.Base tilemap)
{
switch (tilemap.TilemapType())
{
case MapType.UnityRectangle:
return(Rectangle.GetStaticMesh());
case MapType.UnityIsometric:
return(Isometric.GetStaticMesh());
case MapType.UnityHexagon:
return(Hexagon.GetStaticMesh());
}
return(null);
}
static public void BumpedSprite(Light2D light, LightTilemapCollider2D id, Material material)
{
Texture bumpTexture = id.bumpMapMode.GetBumpTexture();
if (bumpTexture == null)
{
return;
}
material.SetTexture("_Bump", bumpTexture);
Vector2 lightPosition = -light.transform.position;
LightTilemapCollider.Base tilemapCollider = id.GetCurrentTilemap();
if (id.superTilemapEditor.tilemap != null)
{
if (id.superTilemapEditor.tilemap.Tileset != null)
{
material.mainTexture = id.superTilemapEditor.tilemap.Tileset.AtlasTexture;
}
}
material.SetPass(0);
GL.Begin(GL.QUADS);
foreach (LightingTile tile in id.superTilemapEditor.mapTiles)
{
tile.UpdateTransform(tilemapCollider);
Vector2 tilePosition = tile.GetWorldPosition(tilemapCollider);
tilePosition += lightPosition;
if (tile.NotInRange(tilePosition, light.size))
{
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;
}
private static void DrawTilemapCollider(Pass pass)
{
#if UNITY_2017_4_OR_NEWER
for (int id = 0; id < pass.tilemapList.Count; id++)
{
LightTilemapCollider2D tilemap = pass.tilemapList[id];
if (tilemap.maskLayer != pass.layerID)
{
continue;
}
if (tilemap.MasksDisabled())
{
continue;
}
// Tilemap In Range
switch (tilemap.mapType)
{
case MapType.UnityRectangle:
case MapType.UnityIsometric:
case MapType.UnityHexagon:
LightTilemapCollider.Base baseTilemap = tilemap.GetCurrentTilemap();
switch (baseTilemap.maskType)
{
case MaskType.Grid:
case MaskType.SpritePhysicsShape:
UnityTilemap.MaskShape(pass.light, tilemap, pass.layer);
break;
}
break;
case MapType.SuperTilemapEditor:
SuperTilemapEditorSupport.RenderingColliderMask.Grid(pass.light, tilemap);
break;
}
}
#endif
}
static public void Sprite(Light2D light, LightTilemapCollider2D id, Material material)
{
Vector2 lightPosition = -light.transform.position;
LightTilemapCollider.Base tilemapCollider = id.GetCurrentTilemap();
if (id.superTilemapEditor.tilemap != null)
{
if (id.superTilemapEditor.tilemap.Tileset != null)
{
material.mainTexture = id.superTilemapEditor.tilemap.Tileset.AtlasTexture;
}
}
material.SetPass(0);
GL.Begin(GL.QUADS);
int count = tilemapCollider.chunkManager.GetTiles(light.GetWorldRect());
for (int i = 0; i < count; i++)
{
LightTile tile = tilemapCollider.chunkManager.display[i];
tile.UpdateTransform(tilemapCollider);
Vector2 tilePosition = tile.GetWorldPosition(tilemapCollider);
tilePosition += lightPosition;
if (tile.NotInRange(tilePosition, light.size))
{
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;
}
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 Draw(Light2D light, LightTilemapCollider2D id, float lightSizeSquared)
{
Vector2 lightPosition = -light.transform.position;
LightTilemapCollider.Base tilemapCollider = id.GetCurrentTilemap();
int count = tilemapCollider.chunkManager.GetTiles(light.GetWorldRect());
for (int i = 0; i < count; i++)
{
LightTile tile = tilemapCollider.chunkManager.display[i];
switch (id.shadowTileType)
{
case ShadowTileType.AllTiles:
break;
case ShadowTileType.ColliderOnly:
if (tile.colliderType == UnityEngine.Tilemaps.Tile.ColliderType.None)
{
continue;
}
break;
}
List <Polygon2> polygons = tile.GetWorldPolygons(tilemapCollider);
Vector2 tilePosition = tile.GetWorldPosition(tilemapCollider);
if (tile.NotInRange(lightPosition + tilePosition, light.size))
{
continue;
}
ShadowEngine.Draw(polygons, 0, 0);
}
}
private static void DrawTilemapCollider(Pass pass)
{
#if UNITY_2017_4_OR_NEWER
for (int id = 0; id < pass.tilemapList.Count; id++)
{
LightTilemapCollider2D tilemap = pass.tilemapList[id];
if (tilemap.shadowLayer != pass.layerID)
{
continue;
}
bool shadowsDisabled = tilemap.ShadowsDisabled();
if (shadowsDisabled)
{
continue;
}
//if (tilemap.IsNotInRange(pass.light)) {
// continue;
//}
switch (tilemap.mapType)
{
case MapType.UnityRectangle:
case MapType.UnityIsometric:
case MapType.UnityHexagon:
LightTilemapCollider.Base baseTilemap = tilemap.GetCurrentTilemap();
switch (baseTilemap.shadowType)
{
case ShadowType.SpritePhysicsShape:
case ShadowType.Grid:
Shadow.UnityTilemap.Draw(pass.light, tilemap, pass.lightSizeSquared);
break;
case ShadowType.CompositeCollider:
// Only Rectangle?
Shadow.TilemapCollider.Rectangle.Draw(pass.light, tilemap);
break;
}
break;
case MapType.SuperTilemapEditor:
switch (tilemap.superTilemapEditor.shadowTypeSTE)
{
case SuperTilemapEditorSupport.TilemapCollider2D.ShadowType.Grid:
case SuperTilemapEditorSupport.TilemapCollider2D.ShadowType.TileCollider:
SuperTilemapEditorSupport.RenderingColliderShadow.Grid(pass.light, tilemap);
break;
case SuperTilemapEditorSupport.TilemapCollider2D.ShadowType.Collider:
SuperTilemapEditorSupport.RenderingColliderShadow.Collider(pass.light, tilemap);
break;
}
break;
}
}
#endif
}
private static void DrawTilemapSprite(Pass pass)
{
#if UNITY_2017_4_OR_NEWER
for (int id = 0; id < pass.tilemapList.Count; id++)
{
LightTilemapCollider2D tilemap = pass.tilemapList[id];
if (tilemap.maskLayer != pass.layerID)
{
continue;
}
if (tilemap.MasksDisabled())
{
continue;
}
// Tilemap In Range
switch (tilemap.mapType)
{
case MapType.UnityRectangle:
case MapType.UnityIsometric:
case MapType.UnityHexagon:
LightTilemapCollider.Base baseTilemap = tilemap.GetCurrentTilemap();
switch (baseTilemap.maskType)
{
case LightTilemapCollider.MaskType.Sprite:
UnityTilemap.Sprite(pass.light, tilemap, pass.materialWhite, pass.layer);
break;
case MaskType.BumpedSprite:
Material material = tilemap.bumpMapMode.SelectMaterial(pass.materialNormalMap_PixelToLight, pass.materialNormalMap_ObjectToLight);
UnityTilemap.BumpedSprite(pass.light, tilemap, material, pass.layer);
break;
}
break;
case MapType.SuperTilemapEditor:
switch (tilemap.superTilemapEditor.maskTypeSTE)
{
case SuperTilemapEditorSupport.TilemapCollider.MaskType.Sprite:
SuperTilemapEditorSupport.RenderingColliderMask.WithoutAtlas.Sprite(pass.light, tilemap, pass.materialWhite);
break;
case SuperTilemapEditorSupport.TilemapCollider.MaskType.BumpedSprite:
Material material = tilemap.bumpMapMode.SelectMaterial(pass.materialNormalMap_PixelToLight, pass.materialNormalMap_ObjectToLight);
SuperTilemapEditorSupport.RenderingColliderMask.WithoutAtlas.BumpedSprite(pass.light, tilemap, material);
break;
}
break;
}
}
#endif
}
