public List <List <Pair2D> > GetPolygons_Pair_Shape_World(Transform transform, VirtualSpriteRenderer spriteRenderer)
{
if (polygons_shape_world_pair == null)
{
if (polygons_shape_world_pair_cache != null)
{
GetPolygons_Shape_World(transform, spriteRenderer);
}
if (polygons_shape_world_pair_cache != null)
{
polygons_shape_world_pair = polygons_shape_world_pair_cache;
}
else
{
polygons_shape_world_pair = new List <List <Pair2D> >();
foreach (Polygon2D poly in GetPolygons_Shape_World(transform, spriteRenderer))
{
polygons_shape_world_pair.Add(Pair2D.GetList(poly.pointsList));
}
polygons_shape_world_pair_cache = polygons_shape_world_pair;
}
}
return(polygons_shape_world_pair);
}
// Sprite To Mesh
public static void SpriteToMesh(GameObject gameObject, VirtualSpriteRenderer spriteRenderer, PolygonTriangulator2D.Triangulation triangulation = PolygonTriangulator2D.Triangulation.Advanced)
{
Texture2D texture = null;
Sprite sprite = null;
if (spriteRenderer.sprite != null)
{
sprite = spriteRenderer.sprite;
texture = sprite.texture;
}
Rect spriteRect = sprite.textureRect;
float spriteSheetU = (float)(texture.width) / spriteRect.width;
float spriteSheetV = (float)(texture.height) / spriteRect.height;
Rect uvRect = new Rect((float)spriteRect.x / texture.width, (float)spriteRect.y / texture.height, (float)spriteRect.width / texture.width, (float)spriteRect.height / texture.height);
Vector2 scale = new Vector2(spriteSheetU * spriteRect.width / sprite.pixelsPerUnit, spriteSheetV * spriteRect.height / spriteRenderer.sprite.pixelsPerUnit);
if (spriteRenderer.flipX)
{
scale.x = -scale.x;
}
if (spriteRenderer.flipY)
{
scale.y = -scale.y;
}
float pivotX = sprite.pivot.x / spriteRect.width - 0.5f;
float pivotY = sprite.pivot.y / spriteRect.height - 0.5f;
float ix = -0.5f + pivotX / spriteSheetU;
float iy = -0.5f + pivotY / spriteSheetV;
Vector2 uvOffset = new Vector2(uvRect.center.x + ix, uvRect.center.y + iy);
Polygon2D polygon2D = Polygon2DListCollider2D.CreateFromGameObject(gameObject)[0];
polygon2D.CreateMesh(gameObject, scale, uvOffset, triangulation);
MeshRenderer meshRenderer = gameObject.GetComponent <MeshRenderer> ();
if (meshRenderer == null)
{
meshRenderer = gameObject.AddComponent <MeshRenderer> ();
}
meshRenderer.sharedMaterial = spriteRenderer.material;
meshRenderer.sharedMaterial.mainTexture = texture;
meshRenderer.sharedMaterial.color = spriteRenderer.color;
//meshRenderer.sortingLayerName = spriteRenderer.sortingLayerName;
//meshRenderer.sortingLayerID = spriteRenderer.sortingLayerID;
//meshRenderer.sortingOrder = spriteRenderer.sortingOrder;
}
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++;
}
//////////////////////////////////////////// Polygon Objects
public List <Polygon2D> GetPolygons_World_ColliderType(Transform transform, VirtualSpriteRenderer virtualSpriteRenderer)
{
switch (colliderType)
{
case LightingCollider2D.ColliderType.Collider:
return(GetPolygons_Collider_World(transform));
case LightingCollider2D.ColliderType.SpriteCustomPhysicsShape:
return(GetPolygons_Shape_World(transform, virtualSpriteRenderer));
}
return(null);
}
// Check Before Each Function - Then This Could Be Private
public void Initialize()
{
if (spriteMaterial == null)
{
spriteMaterial = new Material(Shader.Find("Sprites/Default"));
}
List <Polygon2D> result = Polygon2D.GetListFromCollider(gameObject);
// Split collider if there are more polygons than 1
if (result.Count > 1)
{
PerformResult(result, new Slice2D());
}
body2D = GetComponent <Rigidbody2D> ();
MeshRenderer meshRenderer;
switch (textureType)
{
case TextureType.Mesh2D:
// Needs Mesh UV Options
GetPolygon().CreateMesh(gameObject, new Vector2(1, 1), Vector2.zero, triangulation);
meshRenderer = GetComponent <MeshRenderer> ();
meshRenderer.material = material;
break;
case TextureType.Mesh3D:
GetPolygon().CreateMesh3D(gameObject, 1, new Vector2(1, 1), Vector2.zero, triangulation);
meshRenderer = GetComponent <MeshRenderer> ();
meshRenderer.material = material;
break;
case TextureType.Sprite:
case TextureType.SpriteAnimation:
if (spriteRenderer == null)
{
spriteRenderer = new VirtualSpriteRenderer(GetComponent <SpriteRenderer>());
}
break;
default:
break;
}
}
static public void Draw_scriptable(Scriptable.LightSprite2D id, Camera camera)
{
if (id.Sprite == null)
{
return;
}
if (id.InCamera(camera) == false)
{
return;
}
Vector2 offset = -camera.transform.position;
Vector2 position = id.Position;
Vector2 scale = id.Scale;
float rot = id.Rotation;
Color color = id.Color;
Material material = Lighting2D.materials.GetAdditive();
material.SetColor("_TintColor", color);
material.mainTexture = id.Sprite.texture;
VirtualSpriteRenderer virtualSprite = new VirtualSpriteRenderer();
virtualSprite.sprite = id.Sprite;
GLExtended.color = Color.white;
Universal.Sprite.FullRect.Simple.Draw(id.spriteMeshObject, material, virtualSprite, offset + position, scale, rot);
material.mainTexture = null;
}
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++;
}
// Check Before Each Function - Then This Could Be Private
public void Initialize()
{
shape.ForceUpdate();
List <Polygon2D> result = Polygon2DList.CreateFromGameObject(gameObject);
// Split collider if there are more polygons than 1
if (result.Count > 1)
{
PerformResult(result, new Slice2D());
}
switch (textureType)
{
case TextureType.Mesh2D:
if (Settings.GetBatching(materialSettings.batchMaterial) && spriteRenderer != null)
{
materialSettings.material = spriteRenderer.material;
}
// Needs Mesh UV Options
materialSettings.CreateMesh(gameObject, shape.GetLocal());
meshRenderer = GetComponent <MeshRenderer> ();
meshFilter = GetComponent <MeshFilter>();
break;
case TextureType.Mesh3D:
shape.GetLocal().CreateMesh3D(gameObject, materialSettings.depth, materialSettings.scale, materialSettings.offset, 0, materialSettings.GetTriangulation());
meshRenderer = GetComponent <MeshRenderer> ();
meshFilter = GetComponent <MeshFilter>();
Material[] sharedMaterials = new Material[2];
sharedMaterials[1] = materialSettings.material;
sharedMaterials[0] = materialSettings.sideMaterial;
meshRenderer.sharedMaterials = sharedMaterials;
break;
case TextureType.Sprite:
if (spriteRenderer == null)
{
spriteRendererComponent = GetComponent <SpriteRenderer>();
spriteRenderer = new VirtualSpriteRenderer(spriteRendererComponent);
}
else
{
if (Settings.GetBatching(materialSettings.batchMaterial) == false)
{
spriteRenderer.material = new Material(spriteRenderer.material);
}
}
break;
case TextureType.Sprite3D:
if (spriteRenderer == null)
{
spriteRendererComponent = GetComponent <SpriteRenderer>();
spriteRenderer = new VirtualSpriteRenderer(spriteRendererComponent);
reinitialize = true;
if (Application.IsPlaying(this.gameObject))
{
Destroy(spriteRendererComponent);
}
spriteRendererComponent = null;
}
else
{
if (Settings.GetBatching(materialSettings.batchMaterial) == false)
{
spriteRenderer.material = new Material(spriteRenderer.material);
}
}
break;
case TextureType.SpriteAnimation:
if (spriteRenderer == null)
{
spriteRenderer = new VirtualSpriteRenderer(GetComponent <SpriteRenderer>());
}
break;
default:
break;
}
}
////////////// Sprite Atlas Sprite
static public void DrawSpriteBatched_Tris(VirtualSpriteRenderer spriteRenderer, LayerSetting layerSetting, LightingMaskMode maskMode, Vector2 pos, Vector2 size, float rot, float z = 0f)
{
Sprite sprite = spriteRenderer.sprite;
if (spriteRenderer == null || sprite == null || sprite.texture == null)
{
return;
}
// UV Coordinates Calculation
float spriteSheetUV_X = (float)(sprite.texture.width) / sprite.rect.width;
float spriteSheetUV_Y = (float)(sprite.texture.height) / sprite.rect.height;
Rect rect = sprite.rect;
uvRect.x = rect.x / sprite.texture.width;
uvRect.y = rect.y / sprite.texture.height;
uvRect.width = rect.width / sprite.texture.width;
uvRect.height = rect.height / sprite.texture.height;
uvRect.width += uvRect.x;
uvRect.height += uvRect.y;
//uvRect.x += 1f / sprite.texture.width;
//uvRect.y += 1f / sprite.texture.height;
//uvRect.width -= 2f / sprite.texture.width;
//uvRect.height -= 2f / sprite.texture.height;
// Vertex Position Calculation
scale.x = spriteSheetUV_X * rect.width / sprite.pixelsPerUnit;
scale.y = spriteSheetUV_Y * rect.height / sprite.pixelsPerUnit;
scale.x = (float)sprite.texture.width / sprite.rect.width;
scale.y = (float)sprite.texture.height / sprite.rect.height;
size.x /= scale.x;
size.y /= scale.y;
size.x *= (float)sprite.texture.width / (sprite.pixelsPerUnit * 2);
size.y *= (float)sprite.texture.height / (sprite.pixelsPerUnit * 2);
if (spriteRenderer.flipX)
{
size.x = -size.x;
}
if (spriteRenderer.flipY)
{
size.y = -size.y;
}
float rectAngle = Mathf.Atan2(size.y, size.x);
float dist = Mathf.Sqrt(size.x * size.x + size.y * size.y);
rot = rot * Mathf.Deg2Rad + Mathf.PI;
// Pivot Point Calculation
Vector2 pivot = sprite.pivot;
pivot.x /= sprite.rect.width;
pivot.y /= sprite.rect.height;
pivot.x -= 0.5f;
pivot.y -= 0.5f;
pivot.x *= size.x * 2;
pivot.y *= size.y * 2;
float pivotDist = Mathf.Sqrt(pivot.x * pivot.x + pivot.y * pivot.y);
float pivotAngle = Mathf.Atan2(pivot.y, pivot.x);
pos.x += Mathf.Cos(pivotAngle + rot) * pivotDist;
pos.y += Mathf.Sin(pivotAngle + rot) * pivotDist;
// Vertext Coordinates
pos1.x = pos.x + Mathf.Cos(rectAngle + rot) * dist;
pos1.y = pos.y + Mathf.Sin(rectAngle + rot) * dist;
pos2.x = pos.x + Mathf.Cos(-rectAngle + rot) * dist;
pos2.y = pos.y + Mathf.Sin(-rectAngle + rot) * dist;
pos3.x = pos.x + Mathf.Cos(rectAngle + Mathf.PI + rot) * dist;
pos3.y = pos.y + Mathf.Sin(rectAngle + Mathf.PI + rot) * dist;
pos4.x = pos.x + Mathf.Cos(-rectAngle + Mathf.PI + rot) * dist;
pos4.y = pos.y + Mathf.Sin(-rectAngle + Mathf.PI + rot) * dist;
if (maskMode == LightingMaskMode.Invisible)
{
GL.Color(Color.black);
}
else if (layerSetting.effect == LightingLayerEffect.InvisibleBellow)
{
//float lowestY = v1.y;
//lowestY = Mathf.Min(lowestY, v2.y);
//lowestY = Mathf.Min(lowestY, v3.y);
//lowestY = Mathf.Min(lowestY, v3.y);
float c = pos.y / layerSetting.maskEffectDistance + layerSetting.maskEffectDistance * 2; // + 1f // pos.y
if (c < 0)
{
c = 0;
}
color.r = c;
color.g = c;
color.b = c;
color.a = 1;
GL.Color(color);
}
else
{
GL.Color(Color.white);
}
GL.TexCoord2(uvRect.x, uvRect.y);
GL.Vertex3(pos1.x, pos1.y, z);
GL.TexCoord2(uvRect.x, uvRect.height);
GL.Vertex3(pos2.x, pos2.y, z);
GL.TexCoord2(uvRect.width, uvRect.height);
GL.Vertex3(pos3.x, pos3.y, z);
GL.TexCoord2(uvRect.width, uvRect.height);
GL.Vertex3(pos3.x, pos3.y, z);
GL.TexCoord2(uvRect.width, uvRect.y);
GL.Vertex3(pos4.x, pos4.y, z);
GL.TexCoord2(uvRect.x, uvRect.y);
GL.Vertex3(pos1.x, pos1.y, z);
}
public void Set(VirtualSpriteRenderer spriteRenderer, Transform transform, LightSpriteTransform lightSpriteTransform)
{
this.spriteRenderer = spriteRenderer;
this.lightSpriteTransform = lightSpriteTransform;
this.transform = transform;
}
public static void Draw(List <Polygon2> polygons, float shadowDistance, float translucency)
{
if (polygons == null)
{
return;
}
Vector2[] uv = new Vector2[4];
Vector2[] vertices = new Vector2[4];
Material mat = Lighting2D.materials.GetSpriteProjectionMaterial();
if (ShadowEngine.spriteProjection == null)
{
return;
}
mat.mainTexture = ShadowEngine.spriteProjection.texture;
mat.SetPass(0);
GL.Begin(GL.QUADS);
GL.Color(new Color(translucency, 0, 0, 0));
UVRect fill = ShadowEngine.FillBlack.uvRect;
Light2D light = ShadowEngine.light;
Vector2 offset = ShadowEngine.lightOffset + ShadowEngine.objectOffset;
float lightSize = ShadowEngine.lightSize;
float pivotY = (float)ShadowEngine.spriteProjection.pivot.y / ShadowEngine.spriteProjection.texture.height;
VirtualSpriteRenderer virtualSpriteRenderer = new VirtualSpriteRenderer();
virtualSpriteRenderer.sprite = ShadowEngine.spriteProjection;
// virtualSpriteRenderer.flipX = spriteRenderer.flipX;
// virtualSpriteRenderer.flipY = spriteRenderer.flipY;
SpriteTransform spriteTransform = new SpriteTransform(virtualSpriteRenderer, Vector2.zero, Vector2.one, 0);
Rect uvRect = spriteTransform.uv;
pivotY = uvRect.y + pivotY;
if (shadowDistance == 0)
{
shadowDistance = lightSize;
}
float outerAngle = light.outerAngle;
Vector2 vA, vB, vC, vD;
float angleA, angleB, rotA, rotB;
int PolygonCount = polygons.Count;
for (int i = 0; i < PolygonCount; i++)
{
Vector2[] pointsList = polygons[i].points;
int pointsCount = pointsList.Length;
SoftShadowSorter.Set(polygons[i], light);
pair.A.x = SoftShadowSorter.minPoint.x;
pair.A.y = SoftShadowSorter.minPoint.y;
pair.B.x = SoftShadowSorter.maxPoint.x;
pair.B.y = SoftShadowSorter.maxPoint.y;
float edgeALocalX = pair.A.x;
float edgeALocalY = pair.A.y;
float edgeBLocalX = pair.B.x;
float edgeBLocalY = pair.B.y;
float edgeAWorldX = edgeALocalX + offset.x;
float edgeAWorldY = edgeALocalY + offset.y;
float edgeBWorldX = edgeBLocalX + offset.x;
float edgeBWorldY = edgeBLocalY + offset.y;
float lightDirection = Mathf.Atan2((edgeAWorldY + edgeBWorldY) / 2, (edgeAWorldX + edgeBWorldX) / 2) * Mathf.Rad2Deg;
float EdgeDirection = (Mathf.Atan2(edgeALocalY - edgeBLocalY, edgeALocalX - edgeBLocalX) * Mathf.Rad2Deg - 180 + 720) % 360;
lightDirection -= EdgeDirection;
lightDirection = (lightDirection + 720) % 360;
if (lightDirection > 180)
{
// continue;
}
for (float s = 0; s <= 1; s += 0.1f)
{
float step0 = s;
float step1 = s + 0.1f;
float dir = SoftShadowSorter.minPoint.Atan2(SoftShadowSorter.maxPoint) - Mathf.PI;
float distance = Vector2.Distance(SoftShadowSorter.minPoint, SoftShadowSorter.maxPoint);
pair.A.x = SoftShadowSorter.minPoint.x + Mathf.Cos(dir) * distance * step0;
pair.A.y = SoftShadowSorter.minPoint.y + Mathf.Sin(dir) * distance * step0;
pair.B.x = SoftShadowSorter.minPoint.x + Mathf.Cos(dir) * distance * step1;
pair.B.y = SoftShadowSorter.minPoint.y + Mathf.Sin(dir) * distance * step1;
edgeALocalX = pair.A.x;
edgeALocalY = pair.A.y;
edgeBLocalX = pair.B.x;
edgeBLocalY = pair.B.y;
edgeAWorldX = edgeALocalX + offset.x;
edgeAWorldY = edgeALocalY + offset.y;
edgeBWorldX = edgeBLocalX + offset.x;
edgeBWorldY = edgeBLocalY + offset.y;
angleA = (float)System.Math.Atan2(edgeAWorldY, edgeAWorldX);
angleB = (float)System.Math.Atan2(edgeBWorldY, edgeBWorldX);
rotA = angleA - Mathf.Deg2Rad * light.outerAngle;
rotB = angleB + Mathf.Deg2Rad * light.outerAngle;
// Right Collision
vC.x = edgeAWorldX;
vC.y = edgeAWorldY;
// Left Collision
vD.x = edgeBWorldX;
vD.y = edgeBWorldY;
// Right Inner
vA.x = edgeAWorldX;
vA.y = edgeAWorldY;
vA.x += Mathf.Cos(angleA) * shadowDistance;
vA.y += Mathf.Sin(angleA) * shadowDistance;
// Left Inner
vB.x = edgeBWorldX;
vB.y = edgeBWorldY;
vB.x += Mathf.Cos(angleB) * shadowDistance;
vB.y += Mathf.Sin(angleB) * shadowDistance;
vertices[0] = new Vector2(vD.x, vD.y);
vertices[1] = new Vector2(vC.x, vC.y);
vertices[2] = new Vector2(vA.x, vA.y);
vertices[3] = new Vector2(vB.x, vB.y);
float x0;
float x1;
if (edgeAWorldY < 0)
{
x0 = Mathf.Lerp(uvRect.width, uvRect.x, step0);
x1 = Mathf.Lerp(uvRect.width, uvRect.x, step1);
}
else
{
x0 = Mathf.Lerp(uvRect.x, uvRect.width, step0);
x1 = Mathf.Lerp(uvRect.x, uvRect.width, step1);
}
float y0 = Mathf.Lerp(uvRect.y, uvRect.height, pivotY);
float y1 = Mathf.Lerp(uvRect.y, uvRect.height, 1);
uv[0] = new Vector2(x1, y0);
uv[1] = new Vector2(x0, y0);
uv[2] = new Vector2(x0, y1);
uv[3] = new Vector2(x1, y1);
// Right Fin
GL.MultiTexCoord3(0, uv[2].x, uv[2].y, 0);
GL.Vertex3(vertices[2].x, vertices[2].y, 0);
GL.MultiTexCoord3(0, uv[3].x, uv[3].y, 0);
GL.Vertex3(vertices[3].x, vertices[3].y, 0);
GL.MultiTexCoord3(0, uv[0].x, uv[0].y, 0);
GL.Vertex3(vertices[0].x, vertices[0].y, 0);
GL.MultiTexCoord3(0, uv[1].x, uv[1].y, 0);
GL.Vertex3(vertices[1].x, vertices[1].y, 0);
}
}
GL.End();
}
static public void Draw(SpriteMeshObject spriteMeshObject, Material material, VirtualSpriteRenderer spriteRenderer, Vector2 position, Vector2 scale, float rotation)
{
SpriteTransform spriteTransform = new SpriteTransform(spriteRenderer, position, scale, rotation);
Texture.Draw(material, spriteTransform.position, spriteTransform.scale, spriteTransform.uv, rotation, 0);
}
// Check Before Each Function - Then This Could Be Private
public void Initialize()
{
shape.ForceUpdate();
List <Polygon2D> result = Polygon2DList.CreateFromGameObject(gameObject);
// Split collider if there are more polygons than 1
if (result.Count > 1)
{
PerformResult(result, new Slice2D());
}
switch (textureType)
{
case TextureType.Mesh2D:
if (Slicer2DSettings.GetBatching(materialSettings.batchMaterial) && spriteRenderer != null)
{
materialSettings.material = spriteRenderer.material;
}
// Needs Mesh UV Options
materialSettings.CreateMesh(gameObject, shape.GetLocal());
meshRenderer = GetComponent <MeshRenderer> ();
meshFilter = GetComponent <MeshFilter>();
break;
case TextureType.Mesh3D:
shape.GetLocal().CreateMesh3D(gameObject, 1, new Vector2(1, 1), Vector2.zero, materialSettings.GetTriangulation());
meshRenderer = GetComponent <MeshRenderer> ();
meshRenderer.sharedMaterial = materialSettings.material;
meshFilter = GetComponent <MeshFilter>();
break;
case TextureType.Sprite:
if (spriteRenderer == null)
{
spriteRendererComponent = GetComponent <SpriteRenderer>();
spriteRenderer = new VirtualSpriteRenderer(spriteRendererComponent);
}
else
{
if (Slicer2DSettings.GetBatching(materialSettings.batchMaterial) == false)
{
spriteRenderer.material = new Material(spriteRenderer.material);
}
}
break;
case TextureType.SpriteAnimation:
if (spriteRenderer == null)
{
spriteRenderer = new VirtualSpriteRenderer(GetComponent <SpriteRenderer>());
}
break;
default:
break;
}
}
static public void DrawSpriteBatched_Tris_Day(VirtualSpriteRenderer spriteRenderer, Vector2 pos, Vector2 size, float rot, float z = 0f)
{
Sprite sprite = spriteRenderer.sprite;
if (sprite == null || sprite.texture == null)
{
return;
}
// UV Coordinates Calculation
float spriteSheetUV_X = (float)(sprite.texture.width) / sprite.rect.width;
float spriteSheetUV_Y = (float)(sprite.texture.height) / sprite.rect.height;
Rect rect = sprite.rect;
uvRect.x = rect.x / sprite.texture.width;
uvRect.y = rect.y / sprite.texture.height;
uvRect.width = rect.width / sprite.texture.width;
uvRect.height = rect.height / sprite.texture.height;
uvRect.width += uvRect.x;
uvRect.height += uvRect.y;
// Vertex Position Calculation
scale.x = spriteSheetUV_X * rect.width / sprite.pixelsPerUnit;
scale.y = spriteSheetUV_Y * rect.height / sprite.pixelsPerUnit;
scale.x = (float)sprite.texture.width / sprite.rect.width;
scale.y = (float)sprite.texture.height / sprite.rect.height;
size.x /= scale.x;
size.y /= scale.y;
size.x *= (float)sprite.texture.width / (sprite.pixelsPerUnit * 2);
size.y *= (float)sprite.texture.height / (sprite.pixelsPerUnit * 2);
if (spriteRenderer.flipX)
{
size.x = -size.x;
}
if (spriteRenderer.flipY)
{
size.y = -size.y;
}
float rectAngle = Mathf.Atan2(size.y, size.x);
float dist = Mathf.Sqrt(size.x * size.x + size.y * size.y);
rot = rot * Mathf.Deg2Rad + Mathf.PI;
// Pivot Point Calculation
Vector2 pivot = sprite.pivot;
pivot.x /= sprite.rect.width;
pivot.y /= sprite.rect.height;
pivot.x -= 0.5f;
pivot.y -= 0.5f;
pivot.x *= size.x * 2;
pivot.y *= size.y * 2;
float pivotDist = Mathf.Sqrt(pivot.x * pivot.x + pivot.y * pivot.y);
float pivotAngle = Mathf.Atan2(pivot.y, pivot.x);
pos.x += Mathf.Cos(pivotAngle + rot) * pivotDist;
pos.y += Mathf.Sin(pivotAngle + rot) * pivotDist;
// Vertext Coordinates
pos1.x = pos.x + Mathf.Cos(rectAngle + rot) * dist;
pos1.y = pos.y + Mathf.Sin(rectAngle + rot) * dist;
pos2.x = pos.x + Mathf.Cos(-rectAngle + rot) * dist;
pos2.y = pos.y + Mathf.Sin(-rectAngle + rot) * dist;
pos3.x = pos.x + Mathf.Cos(rectAngle + Mathf.PI + rot) * dist;
pos3.y = pos.y + Mathf.Sin(rectAngle + Mathf.PI + rot) * dist;
pos4.x = pos.x + Mathf.Cos(-rectAngle + Mathf.PI + rot) * dist;
pos4.y = pos.y + Mathf.Sin(-rectAngle + Mathf.PI + rot) * dist;
uvRect.x += 4f / sprite.texture.width;
uvRect.y += 4f / sprite.texture.height;
uvRect.width -= 8f / sprite.texture.width;
uvRect.height -= 8f / sprite.texture.height;
GL.TexCoord2(uvRect.x, uvRect.y);
GL.Vertex3(pos1.x, pos1.y, z);
GL.TexCoord2(uvRect.x, uvRect.height);
GL.Vertex3(pos2.x, pos2.y, z);
GL.TexCoord2(uvRect.width, uvRect.height);
GL.Vertex3(pos3.x, pos3.y, z);
GL.TexCoord2(uvRect.width, uvRect.height);
GL.Vertex3(pos3.x, pos3.y, z);
GL.TexCoord2(uvRect.width, uvRect.y);
GL.Vertex3(pos4.x, pos4.y, z);
GL.TexCoord2(uvRect.x, uvRect.y);
GL.Vertex3(pos1.x, pos1.y, z);
}
public List <Polygon2D> GetPolygons_Shape_World(Transform transform, VirtualSpriteRenderer virtualSpriteRenderer)
{
if (polygons_shape_world == null)
{
Vector2 scale = new Vector2();
List <Polygon2D> list = GetPolygons_Shape_Local();
if (polygons_shape_world_cache != null)
{
if (list.Count != polygons_shape_world_cache.Count)
{
polygons_shape_world_cache = null;
polygons_shape_world_pair_cache = null;
}
else
{
for (int i = 0; i < list.Count; i++)
{
if (list[i].pointsList.Count != polygons_shape_world_cache[i].pointsList.Count)
{
polygons_shape_world_cache = null;
polygons_shape_world_pair_cache = null;
break;
}
}
}
}
if (polygons_shape_world_cache != null)
{
LightingDebug.ShadowColliderTotalGenerationsWorld_shape_re++;
polygons_shape_world = polygons_shape_world_cache;
Polygon2D poly;
Vector2D point;
for (int i = 0; i < list.Count; i++)
{
poly = list[i];
for (int p = 0; p < poly.pointsList.Count; p++)
{
point = poly.pointsList[p];
polygons_shape_world[i].pointsList[p].x = point.x;
polygons_shape_world[i].pointsList[p].y = point.y;
}
if (virtualSpriteRenderer != null)
{
scale.x = 1;
scale.y = 1;
if (virtualSpriteRenderer.flipX == true)
{
scale.x = -1;
}
if (virtualSpriteRenderer.flipY == true)
{
scale.y = -1;
}
if (virtualSpriteRenderer.flipX != false || virtualSpriteRenderer.flipY != false)
{
polygons_shape_world[i].ToScaleItself(scale);
}
}
polygons_shape_world[i].ToWorldSpaceItself(transform);
}
}
else
{
LightingDebug.ShadowColliderTotalGenerationsWorld_shape++;
Polygon2D polygon;
polygons_shape_world = new List <Polygon2D>();
foreach (Polygon2D poly in list)
{
polygon = poly.Copy();
if (virtualSpriteRenderer != null)
{
scale.x = 1;
scale.y = 1;
if (virtualSpriteRenderer.flipX == true)
{
scale.x = -1;
}
if (virtualSpriteRenderer.flipY == true)
{
scale.y = -1;
}
if (virtualSpriteRenderer.flipX != false || virtualSpriteRenderer.flipY != false)
{
polygon.ToScaleItself(scale);
}
}
polygon.ToWorldSpaceItself(transform);
polygons_shape_world.Add(polygon);
polygons_shape_world_cache = polygons_shape_world;
}
}
}
return(polygons_shape_world);
}
public SpriteTransform(VirtualSpriteRenderer spriteRenderer, Vector2 position, Vector2 scale, float rotation)
{
UnityEngine.Sprite sprite = spriteRenderer.sprite;
if (spriteRenderer == null || sprite == null)
{
this.rotation = 0;
this.scale = Vector2.zero;
this.uv = new Rect();
this.position = Vector2.zero;
return;
}
Texture2D spriteTexture = sprite.texture;
float textureWidth = spriteTexture.width;
float textureHeight = spriteTexture.height;
Rect spriteRect = sprite.textureRect;
Rect uvRect = new Rect();
uvRect.x = spriteRect.x / textureWidth;
uvRect.y = spriteRect.y / textureHeight;
uvRect.width = spriteRect.width / textureWidth + uvRect.x;
uvRect.height = spriteRect.height / textureHeight + uvRect.y;
// Scale
Vector2 textureScale = new Vector2();
textureScale.x = textureWidth / spriteRect.width;
textureScale.y = textureHeight / spriteRect.height;
scale.x /= textureScale.x;
scale.y /= textureScale.y;
scale.x *= textureWidth / (sprite.pixelsPerUnit * 2);
scale.y *= textureHeight / (sprite.pixelsPerUnit * 2);
if (spriteRenderer.flipX)
{
scale.x = -scale.x;
}
if (spriteRenderer.flipY)
{
scale.y = -scale.y;
}
// Pivot
Vector2 pivot = sprite.pivot;
pivot.x /= spriteRect.width;
pivot.y /= spriteRect.height;
pivot.x -= 0.5f;
pivot.y -= 0.5f;
pivot.x *= scale.x * 2;
pivot.y *= scale.y * 2;
float pivotDist = Mathf.Sqrt(pivot.x * pivot.x + pivot.y * pivot.y);
float pivotAngle = Mathf.Atan2(pivot.y, pivot.x);
float rot = rotation * Mathf.Deg2Rad + Mathf.PI;
this.position.x = position.x + Mathf.Cos(pivotAngle + rot) * pivotDist;
this.position.y = position.y + Mathf.Sin(pivotAngle + rot) * pivotDist;
this.uv = uvRect;
this.scale = scale;
this.rotation = rotation;
}
static public void DrawSpriteBatched(VirtualSpriteRenderer spriteRenderer, Vector2 pos, Vector2 size, float rot, float z = 0f)
{
Sprite sprite = spriteRenderer.sprite;
if (spriteRenderer == null || sprite == null || sprite.texture == null)
{
return;
}
// UV Coordinates Calculation
float spriteSheetUV_X = (float)(sprite.texture.width) / sprite.rect.width;
float spriteSheetUV_Y = (float)(sprite.texture.height) / sprite.rect.height;
Rect rect = sprite.rect;
Rect uvRect = new Rect((float)rect.x / sprite.texture.width, (float)rect.y / sprite.texture.height, (float)rect.width / sprite.texture.width, (float)rect.height / sprite.texture.height);
uvRect.width += uvRect.x;
uvRect.height += uvRect.y;
// Vertex Position Calculation
Vector2 scale = new Vector2(spriteSheetUV_X * rect.width / sprite.pixelsPerUnit, spriteSheetUV_Y * rect.height / sprite.pixelsPerUnit);
scale.x = (float)sprite.texture.width / sprite.rect.width;
scale.y = (float)sprite.texture.height / sprite.rect.height;
size.x /= scale.x;
size.y /= scale.y;
size.x *= (float)sprite.texture.width / (sprite.pixelsPerUnit * 2);
size.y *= (float)sprite.texture.height / (sprite.pixelsPerUnit * 2);
if (spriteRenderer.flipX)
{
size.x = -size.x;
}
if (spriteRenderer.flipY)
{
size.y = -size.y;
}
float rectAngle = Mathf.Atan2(size.y, size.x);
float dist = Mathf.Sqrt(size.x * size.x + size.y * size.y);
rot = rot * Mathf.Deg2Rad + Mathf.PI;
// Pivot Point Calculation
Vector2 pivot = sprite.pivot;
pivot.x /= sprite.rect.width;
pivot.y /= sprite.rect.height;
pivot.x -= 0.5f;
pivot.y -= 0.5f;
pivot.x *= size.x * 2;
pivot.y *= size.y * 2;
float pivotDist = Mathf.Sqrt(pivot.x * pivot.x + pivot.y * pivot.y);
float pivotAngle = Mathf.Atan2(pivot.y, pivot.x);
pos.x += Mathf.Cos(pivotAngle + rot) * pivotDist;
pos.y += Mathf.Sin(pivotAngle + rot) * pivotDist;
// Vertext Coordinates
Vector2 v1 = new Vector2(pos.x + Mathf.Cos(rectAngle + rot) * dist, pos.y + Mathf.Sin(rectAngle + rot) * dist);
Vector2 v2 = new Vector2(pos.x + Mathf.Cos(-rectAngle + rot) * dist, pos.y + Mathf.Sin(-rectAngle + rot) * dist);
Vector2 v3 = new Vector2(pos.x + Mathf.Cos(rectAngle + Mathf.PI + rot) * dist, pos.y + Mathf.Sin(rectAngle + Mathf.PI + rot) * dist);
Vector2 v4 = new Vector2(pos.x + Mathf.Cos(-rectAngle + Mathf.PI + rot) * dist, pos.y + Mathf.Sin(-rectAngle + Mathf.PI + rot) * dist);
// GL.TexCoord2 (sprite.uv[2].x, sprite.uv[2].y);
GL.TexCoord2(uvRect.x, uvRect.y);
GL.Vertex3(v1.x, v1.y, z);
// GL.TexCoord2 (sprite.uv[0].x, sprite.uv[0].y);
GL.TexCoord2(uvRect.x, uvRect.height);
GL.Vertex3(v2.x, v2.y, z);
// GL.TexCoord2 (sprite.uv[1].x, sprite.uv[1].y);
GL.TexCoord2(uvRect.width, uvRect.height);
GL.Vertex3(v3.x, v3.y, z);
//GL.TexCoord2 (sprite.uv[3].x, sprite.uv[3].y);
GL.TexCoord2(uvRect.width, uvRect.y);
GL.Vertex3(v4.x, v4.y, z);
}
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
}
static public void SortTilemap(LightingBuffer2D buffer, LightingTilemapCollider2D id)
{
//if (id.maskType != LightingTilemapCollider2D.MaskType.Sprite) {
// return;
//}
if (id.map == null)
{
return;
}
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;
int sizeInt = LightingBufferTilemapRectangle.LightTilemapSize(id, buffer);
LightingBufferTilemapRectangle.LightTilemapOffset(id, new Vector2(scaleX, scaleY), buffer);
Vector2Int newPositionInt = LightingBufferTilemapRectangle.newPositionInt;
Vector2D tilemapOffset = LightingBufferTilemapRectangle.tilemapOffset;
Vector2D polyOffset = LightingBufferTilemapRectangle.polyOffset;
Vector2D inverseOffset = LightingBufferTilemapRectangle.inverseOffset;
tilemapOffset.x = id.area.position.x + id.cellAnchor.x + id.transform.position.x;
tilemapOffset.y = id.area.position.y + id.cellAnchor.y + id.transform.position.y;
offset.x = -buffer.lightSource.transform.position.x;
offset.y = -buffer.lightSource.transform.position.y;
VirtualSpriteRenderer spriteRenderer = new VirtualSpriteRenderer();
Vector2 tileSize = new Vector2(scaleX / id.cellSize.x, scaleY / id.cellSize.y);
LightingTile tile;
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 *= scaleX;
polyOffset.y *= scaleY;
if (LightingManager2D.culling && Vector2.Distance(polyOffset.ToVector2(), 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;
//if (poly.PointInPoly (inverseOffset)) {
// continue;
//}
if (layerSettings.renderingOrder == LightRenderingOrder.YAxis)
{
list.Add(id, tile, -(float)polyOffset.y - (float)offset.y, polyOffset);
}
else
{
list.Add(id, tile, -Vector2.Distance(polyOffset.ToVector2() - offset.ToVector2(), buffer.lightSource.transform.position), polyOffset);
}
}
}
}
