public static void Mask(Light2D light, LightCollider2D id, LayerSetting layerSetting)
{
if (id.InLight(light) == false)
{
return;
}
int shapeCount = id.shapes.Count;
for (int i = 0; i < shapeCount; i++)
{
LightColliderShape shape = id.shapes[i];
List <MeshObject> meshObjects = shape.GetMeshes();
if (meshObjects == null)
{
return;
}
Vector2 position = shape.transform2D.position - light.transform2D.position;
Vector2 pivotPosition = shape.GetPivotPoint() - light.transform2D.position;
GL.Color(LayerSettingColor.Get(pivotPosition, layerSetting, id.maskEffect, id.maskTranslucency));
GLExtended.DrawMeshPass(meshObjects, position, shape.transform.lossyScale, shape.transform2D.rotation);
}
}
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 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);
}
}
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 public void Draw(DayLightCollider2D id, Vector2 position)
{
if (id.mainShape.shadowType == DayLightCollider2D.ShadowType.None)
{
return;
}
if (id.mainShape.shadowType == DayLightCollider2D.ShadowType.SpriteOffset)
{
return;
}
if (id.mainShape.shadowType == DayLightCollider2D.ShadowType.SpriteProjection)
{
return;
}
if (id.mainShape.height < 0)
{
return;
}
if (id.InAnyCamera() == false)
{
return;
}
Color color = new Color(id.shadowTranslucency, id.shadowTranslucency, id.shadowTranslucency, 1);
GL.Color(color);
foreach (DayLightColliderShape shape in id.shapes)
{
DayLighting.ShadowMesh shadow = shape.shadowMesh;
if (shadow == null)
{
continue;
}
Vector3 pos = new Vector3(shape.transform2D.position.x + position.x, shape.transform2D.position.y + position.y, 0);
Matrix4x4 matrix = Matrix4x4.TRS(pos, Quaternion.Euler(0, 0, 0), Vector3.one);
foreach (MeshObject mesh in shadow.softMeshes)
{
GLExtended.DrawMeshPass(mesh, pos, Vector3.one, 0);
}
foreach (MeshObject mesh in shadow.meshes)
{
GLExtended.DrawMeshPass(mesh, pos, Vector3.one, 0);
}
}
}
public static void Mask(Light2D light, LightCollider2D id, Material material, LayerSetting layerSetting)
{
if (id.InLight(light) == false)
{
return;
}
foreach (LightColliderShape shape in id.shapes)
{
SkinnedMeshRenderer skinnedMeshRenderer = shape.skinnedMeshShape.GetSkinnedMeshRenderer();
if (skinnedMeshRenderer == null)
{
return;
}
List <MeshObject> meshObject = shape.GetMeshes();
if (meshObject == null)
{
return;
}
if (skinnedMeshRenderer.sharedMaterial != null)
{
material.mainTexture = skinnedMeshRenderer.sharedMaterial.mainTexture;
}
else
{
material.mainTexture = null;
}
Vector2 position = shape.transform2D.position - light.transform2D.position;
Vector2 pivotPosition = shape.GetPivotPoint() - light.transform2D.position;
material.color = LayerSettingColor.Get(pivotPosition, layerSetting, id.maskEffect, id.maskTranslucency);
material.SetPass(0);
GLExtended.DrawMesh(meshObject, position, id.mainShape.transform2D.scale, shape.transform2D.rotation);
material.mainTexture = null;
}
}
static public void DrawTilemap(DayLightTilemapCollider2D id, Vector2 position)
{
//if (id.mainShape.shadowType == DayLightCollider2D.shadowType.None) {
// return;
//}
// if (id.mainShape.shadowType == DayLightCollider2D.shadowType.Sprite) {
// return;
//}
//if (id.mainShape.height < 0) {
// return;
//}//
//if (id.InAnyCamera() == false) {
// continue;
//}
// shadowTranslucency
GL.Color(Color.black);
foreach (DayLightingTile dayTile in id.dayTiles)
{
DayLighting.TilemapShadowMesh shadow = dayTile.shadowMesh;
if (shadow == null)
{
continue;
}
Vector3 pos = new Vector3(position.x, position.y, 0);
Matrix4x4 matrix = Matrix4x4.TRS(pos, Quaternion.Euler(0, 0, 0), Vector3.one);
foreach (MeshObject mesh in shadow.softMeshes)
{
GLExtended.DrawMeshPass(mesh, pos, Vector3.one, 0);
}
foreach (MeshObject mesh in shadow.meshes)
{
GLExtended.DrawMeshPass(mesh, pos, Vector3.one, 0);
}
}
}
public static void Draw(Light2D light, Vector2 position, Material material, float z)
{
float rotation = light.transform.rotation.eulerAngles.z + (Mathf.PI / 4) * Mathf.Rad2Deg;
float size = light.size;
size = Mathf.Sqrt(((size * size) + (size * size)));
Vector3 matrixPosition = new Vector3(position.x, position.y, z);
Quaternion matrixRotation = Quaternion.Euler(0, 0, rotation);
Vector3 matrixScale = new Vector3(size, size, 1);
if (light.IsPixelPerfect())
{
GLExtended.DrawMesh(GetMeshPixelPerfect(light), matrixPosition, matrixScale, rotation);
}
else
{
GLExtended.DrawMesh(GetMesh(), matrixPosition, matrixScale, rotation);
}
}
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 static void Draw(LightRoom2D id, Camera camera)
{
Material material = Lighting2D.materials.GetMask();
Vector2 position;
Vector2 offset = -camera.transform.position;
switch (id.shape.type)
{
case LightRoom2D.RoomType.Collider:
List <MeshObject> meshObjects = id.shape.GetMeshes();
if (meshObjects == null)
{
return;
}
//Vector3 matrixPosition = new Vector3(id.transform.position.x, id.transform.position.y, z);
//Quaternion matrixRotation = Quaternion.Euler(0, 0, id.transform.rotation.eulerAngles.z);
//Vector3 matrixScale = new Vector3(id.transform.lossyScale.x, id.transform.lossyScale.y, 1);
//Graphics.DrawMeshNow(meshObject.mesh, Matrix4x4.TRS(matrixPosition, matrixRotation, matrixScale));
material.color = id.color;
material.mainTexture = null;
material.SetPass(0);
position = id.transform.position;
position += offset;
GLExtended.DrawMesh(meshObjects, position, id.transform.lossyScale, id.transform.rotation.eulerAngles.z);
break;
case LightRoom2D.RoomType.Sprite:
UnityEngine.SpriteRenderer spriteRenderer = id.shape.spriteShape.GetSpriteRenderer();
if (spriteRenderer == null)
{
return;
}
Sprite sprite = spriteRenderer.sprite;;
if (sprite == null)
{
return;
}
material.mainTexture = sprite.texture;
material.color = id.color;
position = id.transform.position;
position += offset;
Rendering.Universal.Sprite.FullRect.Draw(id.spriteMeshObject, material, spriteRenderer, position, id.transform.lossyScale, id.transform.eulerAngles.z);
break;
}
material.color = Color.white;
material.mainTexture = null;
}
static public void DrawPass(SpriteMeshObject spriteMeshObject, SpriteRenderer spriteRenderer, Vector2 pos, Vector2 size, float rotation)
{
GLExtended.DrawMesh(spriteMeshObject.GetTiledMesh().GetMesh(spriteRenderer), pos, size, rotation);
}
static public void Draw(SpriteMeshObject spriteMeshObject, Material material, SpriteRenderer spriteRenderer, Vector2 pos, Vector2 size, float rotation)
{
material.SetPass(0);
GLExtended.DrawMesh(spriteMeshObject.GetTiledMesh().GetMesh(spriteRenderer), pos, size, rotation);
}
public static void MaskNormalMap(Light2D light, LightCollider2D id, Material material, LayerSetting layerSetting)
{
if (id.InLight(light) == false)
{
return;
}
Texture normalTexture = id.bumpMapMode.GetBumpTexture();
if (normalTexture == null)
{
return;
}
float rotation;
material.SetTexture("_Bump", normalTexture);
foreach (LightColliderShape shape in id.shapes)
{
MeshRenderer meshRenderer = id.mainShape.meshShape.GetMeshRenderer();
if (meshRenderer == null)
{
return;
}
List <MeshObject> meshObjects = id.mainShape.GetMeshes();
if (meshObjects == null)
{
return;
}
if (meshRenderer.sharedMaterial != null)
{
material.mainTexture = meshRenderer.sharedMaterial.mainTexture;
}
else
{
material.mainTexture = null;
}
Vector2 position = shape.transform2D.position - light.transform2D.position;
Vector2 pivotPosition = shape.GetPivotPoint() - light.transform2D.position;
material.color = LayerSettingColor.Get(pivotPosition, layerSetting, id.maskEffect, id.maskTranslucency);
float color = material.color.r;
switch (id.bumpMapMode.type)
{
case NormalMapType.ObjectToLight:
rotation = Mathf.Atan2(light.transform2D.position.y - shape.transform2D.position.y, light.transform2D.position.x - shape.transform2D.position.x);
rotation -= Mathf.Deg2Rad * (shape.transform2D.rotation);
material.SetFloat("_LightRX", Mathf.Cos(rotation) * 2);
material.SetFloat("_LightRY", Mathf.Sin(rotation) * 2);
material.SetFloat("_LightColor", color);
break;
case NormalMapType.PixelToLight:
material.SetFloat("_LightColor", color);
rotation = shape.transform2D.rotation * Mathf.Deg2Rad;
Vector2 sc = shape.transform2D.scale;
sc = sc.normalized;
material.SetFloat("_LightX", Mathf.Cos(rotation) * sc.x);
material.SetFloat("_LightY", Mathf.Cos(rotation) * sc.y);
material.SetFloat("_Depth", id.bumpMapMode.depth);
if (id.bumpMapMode.invertX)
{
material.SetFloat("_InvertX", -1);
}
else
{
material.SetFloat("_InvertX", 1);
}
if (id.bumpMapMode.invertY)
{
material.SetFloat("_InvertY", -1);
}
else
{
material.SetFloat("_InvertY", 1);
}
break;
}
material.SetPass(0);
GLExtended.DrawMesh(meshObjects, position, id.mainShape.transform2D.scale, shape.transform2D.rotation);
material.mainTexture = null;
}
}
