void AddTilemaps()
{
#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 && tilemap.maskLayer != pass.layerID)
{
continue;
}
//if (tilemap.IsNotInRange(pass.light)) {
// continue;
//}
bool shadowsDisabled = tilemap.ShadowsDisabled();
bool masksDisabled = tilemap.MasksDisabled();
if (shadowsDisabled && masksDisabled)
{
continue;
}
//AddTiles(tilemap);
AddTileMap(tilemap);
}
#endif
}
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);
}
}
private static void DrawTile(Pass pass)
{
#if UNITY_2017_4_OR_NEWER
LightTile tile = (LightTile)pass.sortPass.sortObject.lightObject;
LightTilemapCollider2D tilemap = pass.sortPass.sortObject.tilemap;
bool masksDisabled = tilemap.MasksDisabled();
bool shadowsDisabled = tilemap.ShadowsDisabled();
if (pass.sortPass.sortObject.tilemap.shadowLayer == pass.layerID && pass.drawShadows && shadowsDisabled == false)
{
ShadowEngine.GetMaterial().SetPass(0);
GL.Begin(GL.TRIANGLES);
Shadow.Tile.Draw(pass.light, tile, tilemap);
GL.End();
}
// sprite mask - but what about shape mask?
if (tilemap.maskLayer == pass.layerID && pass.drawMask && masksDisabled == false)
{
Tile.MaskSprite(tile, pass.layer, pass.materialWhite, tilemap, pass.lightSizeSquared);
}
#endif
}
static public void Sprite(Light2D light, LightTilemapCollider2D id, Material material, LayerSetting layerSetting)
{
Vector2 lightPosition = -light.transform.position;
LightTilemapCollider.Base tilemap = id.GetCurrentTilemap();
Vector2 scale = tilemap.TileWorldScale();
float rotation = id.transform.eulerAngles.z;
int count = tilemap.chunkManager.GetTiles(light.GetWorldRect());
Texture2D currentTexture = null;
Color currentColor = Color.black;
GL.Begin(GL.QUADS);
for (int i = 0; i < count; i++)
{
LightTile tile = tilemap.chunkManager.display[i];
if (tile.GetOriginalSprite() == null)
{
return;
}
Vector2 tilePosition = tile.GetWorldPosition(tilemap);
tilePosition += lightPosition;
if (tile.NotInRange(tilePosition, light.size))
{
continue;
}
virtualSpriteRenderer.sprite = tile.GetOriginalSprite();
if (virtualSpriteRenderer.sprite.texture == null)
{
continue;
}
Color color = LayerSettingColor.Get(tilePosition, layerSetting, MaskEffect.Lit, 1); // 1?
if (currentTexture != virtualSpriteRenderer.sprite.texture || currentColor != color)
{
currentTexture = virtualSpriteRenderer.sprite.texture;
currentColor = color;
material.mainTexture = currentTexture;
material.color = currentColor;
material.SetPass(0);
}
Universal.Sprite.FullRect.Simple.Draw(tile.spriteMeshObject, material, virtualSpriteRenderer, tilePosition, scale * tile.scale, rotation + tile.rotation);
}
GL.End();
material.mainTexture = null;
}
static public void Draw(Light2D light, LightTile tile, LightTilemapCollider2D tilemap)
{
LightTilemapCollider.Base tilemapCollider = tilemap.GetCurrentTilemap();
List <Polygon2> polygons = tile.GetWorldPolygons(tilemapCollider);
ShadowEngine.Draw(polygons, 0, 0);
}
public SortObject(int a)
{
type = Type.Collider;
value = 0;
lightObject = null;
tilemap = null;
}
static public void MaskShape(Light2D light, LightTilemapCollider2D id, LayerSetting layerSetting)
{
Vector2 lightPosition = -light.transform.position;
LightTilemapCollider.Base tilemap = id.GetCurrentTilemap();
bool isGrid = !tilemap.IsPhysicsShape();
Vector2 scale = tilemap.TileWorldScale();
float rotation = id.transform.eulerAngles.z;
MeshObject tileMesh = null;
if (isGrid)
{
tileMesh = LightTile.GetStaticMesh(tilemap);
}
int count = tilemap.chunkManager.GetTiles(light.GetWorldRect());
for (int i = 0; i < count; i++)
{
LightTile tile = tilemap.chunkManager.display[i];
Vector2 tilePosition = tilemap.TileWorldPosition(tile);
tilePosition += lightPosition;
if (tile.NotInRange(tilePosition, light.size))
{
continue;
}
if (isGrid == false)
{
tileMesh = null;
tileMesh = tile.GetDynamicMesh();
}
if (tileMesh == null)
{
continue;
}
Color color = LayerSettingColor.Get(tilePosition, layerSetting, MaskEffect.Lit, 1); // 1?
GL.Color(color);
GLExtended.DrawMeshPass(tileMesh, tilePosition, scale, rotation + tile.rotation);
}
GL.Color(Color.white);
}
static void Update(LightTilemapCollider2D script)
{
if (GUILayout.Button("Update"))
{
SpriteExtension.PhysicsShapeManager.Clear();
script.Initialize();
Light2D.ForceUpdateAll();
LightingManager2D.ForceUpdate();
}
}
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 static void Events(Tilemap tilemap, Tilemap.SyncTile[] s)
{
if (Application.isPlaying)
{
return;
}
foreach (LightTilemapCollider2D tilemap2D in LightTilemapCollider2D.GetList())
{
tilemap2D.Initialize();
}
Light2D.ForceUpdateAll();
}
static public void Draw(Light2D light, LightTilemapCollider2D id)
{
Vector2 position = -light.transform.position;
switch (id.rectangle.shadowType)
{
case LightTilemapCollider.ShadowType.CompositeCollider:
ShadowEngine.objectOffset = id.transform.position;
ShadowEngine.Draw(id.rectangle.compositeColliders, 0, 0);
ShadowEngine.objectOffset = Vector2.zero;
break;
}
}
public void AddTilemap(LightTilemapCollider2D tilemap, float value)
{
if (count < list.Length)
{
list[count].value = value;
list[count].type = SortObject.Type.TilemapMap;
list[count].tilemap = tilemap;
count++;
}
else
{
Debug.LogError("Tile Depth Overhead!");
}
}
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;
}
public void AddTileMap(LightTilemapCollider2D id)
{
switch (id.mapType)
{
case MapType.UnityRectangle:
switch (pass.layer.sorting)
{
case LightLayerSorting.SortingLayerAndOrder:
sortList.AddTilemap(id, id.lightingTransform.sortingOrder + id.lightingTransform.sortingLayerID * 1000);
break;
case LightLayerSorting.ZAxisLower:
sortList.AddTilemap(id, -id.transform.position.z);
break;
case LightLayerSorting.ZAxisHigher:
sortList.AddTilemap(id, id.transform.position.z);
break;
case LightLayerSorting.YAxisLower:
sortList.AddTilemap(id, -id.transform.position.y);
break;
case LightLayerSorting.YAxisHigher:
sortList.AddTilemap(id, id.transform.position.y);
break;
case LightLayerSorting.DistanceToLight:
sortList.AddTilemap(id, -Vector2.Distance(id.transform.position, pass.light.transform.position));
break;
case LightLayerSorting.YDistanceToLight:
// sortList.Add(id, tile, -Mathf.Abs(tilePosition.y - pass.light.transform.position.y));
break;
}
break;
}
}
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);
}
}
static public void BumpedSprite(Light2D light, LightTilemapCollider2D id, Material material)
{
}
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
}
private static void DrawTileMap(Pass pass)
{
#if UNITY_2017_4_OR_NEWER
LightTilemapCollider2D tilemap = pass.sortPass.sortObject.tilemap;
bool masksDisabled = tilemap.MasksDisabled();
bool shadowsDisabled = tilemap.ShadowsDisabled();
if (tilemap.shadowLayer == pass.layerID && pass.drawShadows && shadowsDisabled == false)
{
ShadowEngine.GetMaterial().SetPass(0);
GL.Begin(GL.TRIANGLES);
switch (tilemap.mapType)
{
case MapType.UnityRectangle:
switch (tilemap.rectangle.shadowType)
{
case ShadowType.Grid:
case ShadowType.SpritePhysicsShape:
Shadow.UnityTilemap.Draw(pass.light, tilemap, pass.lightSizeSquared);
break;
case ShadowType.CompositeCollider:
Shadow.TilemapCollider.Rectangle.Draw(pass.light, tilemap);
break;
}
break;
case MapType.UnityIsometric:
switch (tilemap.isometric.shadowType)
{
case ShadowType.Grid:
case ShadowType.SpritePhysicsShape:
Shadow.UnityTilemap.Draw(pass.light, tilemap, pass.lightSizeSquared);
break;
}
break;
case MapType.UnityHexagon:
switch (tilemap.hexagon.shadowType)
{
case ShadowType.Grid:
case ShadowType.SpritePhysicsShape:
Shadow.UnityTilemap.Draw(pass.light, tilemap, pass.lightSizeSquared);
break;
}
break;
case MapType.SuperTilemapEditor:
switch (tilemap.superTilemapEditor.shadowTypeSTE)
{
case SuperTilemapEditorSupport.TilemapCollider2D.ShadowType.TileCollider:
case SuperTilemapEditorSupport.TilemapCollider2D.ShadowType.Grid:
SuperTilemapEditorSupport.RenderingColliderShadow.Grid(pass.light, tilemap);
break;
case SuperTilemapEditorSupport.TilemapCollider2D.ShadowType.Collider:
SuperTilemapEditorSupport.RenderingColliderShadow.Collider(pass.light, tilemap);
break;
}
break;
}
GL.End();
}
if (pass.sortPass.sortObject.tilemap.maskLayer == pass.layerID && pass.drawMask && masksDisabled == false)
{
switch (tilemap.mapType)
{
case MapType.UnityRectangle:
switch (tilemap.rectangle.maskType)
{
case LightTilemapCollider.MaskType.Sprite:
UnityTilemap.Sprite(pass.light, tilemap, pass.materialWhite, pass.layer);
break;
case LightTilemapCollider.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.UnityIsometric:
switch (tilemap.isometric.maskType)
{
case MaskType.Sprite:
UnityTilemap.Sprite(pass.light, tilemap, pass.materialWhite, pass.layer);
break;
}
break;
case MapType.UnityHexagon:
switch (tilemap.hexagon.maskType)
{
case MaskType.Sprite:
// TilemapHexagon.MaskSprite(pass.buffer, tilemap, pass.materialWhite, pass.z);
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
}
override public void OnInspectorGUI()
{
LightTilemapCollider2D script = target as LightTilemapCollider2D;
script.mapType = (MapType)EditorGUILayout.EnumPopup("Tilemap Type", script.mapType);
EditorGUILayout.Space();
switch (script.mapType)
{
case MapType.UnityRectangle:
script.rectangle.shadowType = (ShadowType)EditorGUILayout.EnumPopup("Shadow Type", script.rectangle.shadowType);
EditorGUI.BeginDisabledGroup(script.rectangle.shadowType == ShadowType.None);
script.shadowLayer = EditorGUILayout.Popup("Shadow Layer (Light)", script.shadowLayer, Lighting2D.Profile.layers.lightLayers.GetNames());
switch (script.rectangle.shadowType)
{
case ShadowType.Grid:
case ShadowType.SpritePhysicsShape:
script.shadowTileType = (ShadowTileType)EditorGUILayout.EnumPopup("Shadow Tile Type", script.shadowTileType);
break;
}
script.rectangle.shadowOptimization = EditorGUILayout.Toggle("Shadow Optimization", script.rectangle.shadowOptimization);
EditorGUI.EndDisabledGroup();
EditorGUILayout.Space();
script.rectangle.maskType = (MaskType)EditorGUILayout.EnumPopup("Mask Type", script.rectangle.maskType);
EditorGUI.BeginDisabledGroup(script.rectangle.maskType == MaskType.None);
script.maskLayer = EditorGUILayout.Popup("Mask Layer (Light)", script.maskLayer, Lighting2D.Profile.layers.lightLayers.GetNames());
if (script.rectangle.maskType == MaskType.BumpedSprite)
{
GUIBumpMapMode.Draw(serializedObject, script);
}
EditorGUI.EndDisabledGroup();
break;
case MapType.UnityIsometric:
script.isometric.shadowType = (ShadowType)EditorGUILayout.EnumPopup("Shadow Type", script.isometric.shadowType);
EditorGUI.BeginDisabledGroup(script.isometric.shadowType == ShadowType.None);
script.shadowLayer = EditorGUILayout.Popup("Shadow Layer (Light)", script.shadowLayer, Lighting2D.Profile.layers.lightLayers.GetNames());
script.shadowTileType = (ShadowTileType)EditorGUILayout.EnumPopup("Shadow Tile Type", script.shadowTileType);
EditorGUI.EndDisabledGroup();
EditorGUILayout.Space();
script.isometric.maskType = (MaskType)EditorGUILayout.EnumPopup("Mask Type", script.isometric.maskType);
EditorGUI.BeginDisabledGroup(script.isometric.maskType == MaskType.None);
script.maskLayer = EditorGUILayout.Popup("Mask Layer (Light)", script.maskLayer, Lighting2D.Profile.layers.lightLayers.GetNames());
EditorGUILayout.Space();
script.isometric.ZasY = EditorGUILayout.Toggle("Z as Y", script.isometric.ZasY);
EditorGUI.EndDisabledGroup();
break;
case MapType.UnityHexagon:
script.hexagon.shadowType = (ShadowType)EditorGUILayout.EnumPopup("Shadow Type", script.hexagon.shadowType);
EditorGUI.BeginDisabledGroup(script.hexagon.shadowType == ShadowType.None);
script.shadowLayer = EditorGUILayout.Popup("Shadow Layer (Light)", script.shadowLayer, Lighting2D.Profile.layers.lightLayers.GetNames());
script.shadowTileType = (ShadowTileType)EditorGUILayout.EnumPopup("Shadow Tile Type", script.shadowTileType);
EditorGUI.EndDisabledGroup();
EditorGUILayout.Space();
script.hexagon.maskType = (MaskType)EditorGUILayout.EnumPopup("Mask Type", script.hexagon.maskType);
EditorGUI.BeginDisabledGroup(script.hexagon.maskType == MaskType.None);
script.maskLayer = EditorGUILayout.Popup("Mask Layer (Light)", script.maskLayer, Lighting2D.Profile.layers.lightLayers.GetNames());
EditorGUI.EndDisabledGroup();
break;
case MapType.SuperTilemapEditor:
script.superTilemapEditor.shadowTypeSTE = (SuperTilemapEditorSupport.TilemapCollider2D.ShadowType)EditorGUILayout.EnumPopup("Shadow Type", script.superTilemapEditor.shadowTypeSTE);
script.shadowLayer = EditorGUILayout.Popup("Shadow Layer (Light)", script.shadowLayer, Lighting2D.Profile.layers.lightLayers.GetNames());
EditorGUILayout.Space();
script.superTilemapEditor.maskTypeSTE = (SuperTilemapEditorSupport.TilemapCollider2D.MaskType)EditorGUILayout.EnumPopup("Mask Type", script.superTilemapEditor.maskTypeSTE);
EditorGUI.BeginDisabledGroup(script.superTilemapEditor.maskTypeSTE == SuperTilemapEditorSupport.TilemapCollider2D.MaskType.None);
script.maskLayer = EditorGUILayout.Popup("Mask Layer (Light)", script.maskLayer, Lighting2D.Profile.layers.lightLayers.GetNames());
if (script.superTilemapEditor.maskTypeSTE == SuperTilemapEditorSupport.TilemapCollider2D.MaskType.BumpedSprite)
{
GUIBumpMapMode.Draw(serializedObject, script);
}
EditorGUI.EndDisabledGroup();
break;
}
EditorGUILayout.Space();
Update(script);
serializedObject.ApplyModifiedProperties();
if (GUI.changed)
{
script.Initialize();
Light2D.ForceUpdateAll();
LightingManager2D.ForceUpdate();
if (EditorApplication.isPlaying == false)
{
EditorUtility.SetDirty(target);
EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
}
}
}
static public void MaskSprite(LightTile tile, LayerSetting layerSetting, Material material, LightTilemapCollider2D tilemap, float lightSizeSquared)
{
virtualSpriteRenderer.sprite = tile.GetOriginalSprite();
if (virtualSpriteRenderer.sprite == null)
{
return;
}
LightTilemapCollider.Base tilemapBase = tilemap.GetCurrentTilemap();
Vector2 tilePosition = tile.GetWorldPosition(tilemapBase) - ShadowEngine.light.transform2D.position;
material.color = LayerSettingColor.Get(tilePosition, layerSetting, MaskEffect.Lit, 1); // 1?
material.mainTexture = virtualSpriteRenderer.sprite.texture;
Vector2 scale = tile.worldScale * tile.scale;
GLExtended.SetColor(Color.white);
tilePosition += ShadowEngine.drawOffset;
Universal.Sprite.FullRect.Simple.Draw(tile.spriteMeshObject, material, virtualSpriteRenderer, tilePosition, scale, tile.worldRotation);
material.mainTexture = null;
}
static public void Collider(Light2D light, LightTilemapCollider2D id)
{
Rendering.Light.ShadowEngine.Draw(id.superTilemapEditor.GetWorldColliders(), 0, 0);
}
static public void Collider(Light2D light, LightTilemapCollider2D id)
{
}
static public void BumpedSprite(Light2D light, LightTilemapCollider2D id, Material material, LayerSetting layerSetting)
{
Texture bumpTexture = id.bumpMapMode.GetBumpTexture();
if (bumpTexture == null)
{
return;
}
material.SetTexture("_Bump", bumpTexture);
Vector2 lightPosition = -light.transform.position;
LightTilemapCollider.Base tilemap = id.GetCurrentTilemap();
Vector2 scale = tilemap.TileWorldScale();
Texture2D currentTexture = null;
GL.Begin(GL.QUADS);
foreach (LightTile tile in tilemap.mapTiles)
{
if (tile.GetOriginalSprite() == null)
{
return;
}
Vector2 tilePosition = tilemap.TileWorldPosition(tile);
tilePosition += lightPosition;
if (tile.NotInRange(tilePosition, light.size))
{
continue;
}
virtualSpriteRenderer.sprite = tile.GetOriginalSprite();
if (virtualSpriteRenderer.sprite.texture == null)
{
continue;
}
if (currentTexture != virtualSpriteRenderer.sprite.texture)
{
currentTexture = virtualSpriteRenderer.sprite.texture;
material.mainTexture = currentTexture;
material.SetPass(0);
}
Color color = LayerSettingColor.Get(tilePosition, layerSetting, MaskEffect.Lit, 1); // 1
GLExtended.SetColor(color);
Universal.Sprite.FullRect.Simple.DrawPass(tile.spriteMeshObject, virtualSpriteRenderer, tilePosition, scale, tile.worldRotation);
}
GL.End();
material.mainTexture = null;
}
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 lightSizeSquared = 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 <LightTilemapCollider2D> tilemapColliderList = LightTilemapCollider2D.GetCollisionList(layerId);
foreach (LightTilemapCollider2D id in tilemapColliderList)
{
LightTilemapCollider.Base tilemapCollider = id.GetCurrentTilemap();
int count = tilemapCollider.chunkManager.GetTiles(light.GetWorldRect());
for (int t = 0; t < count; t++)
{
LightTile tile = tilemapCollider.chunkManager.display[t];
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);
if (polygons.Count < 1)
{
continue;
}
Vector2 tilePosition = tile.GetWorldPosition(tilemapCollider) + lightPosition;
if (tile.NotInRange(tilePosition, light.size))
{
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) * lightSizeSquared;
projectionLeft.y = edgeLeft.y + System.Math.Sin(rotLeft) * lightSizeSquared;
projectionRight.x = edgeRight.x + System.Math.Cos(rotRight) * lightSizeSquared;
projectionRight.y = edgeRight.y + System.Math.Sin(rotRight) * lightSizeSquared;
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);
}
