static void Draw_Collider_Strict(Vector2D offset, float z)
{
GL.PushMatrix();
LightingManager2D.Get().occlusionBlurMaterial.SetPass(0);
GL.Begin(GL.QUADS);
GL.Color(Color.white);
foreach (LightingCollider2D id in LightingCollider2D.GetList())
{
if (id.ambientOcclusion == false || id.smoothOcclusionEdges == true)
{
continue;
}
// Do not call Create From Collider
List <Polygon2D> polygons = null;
switch (id.colliderType)
{
case LightingCollider2D.ColliderType.Collider:
polygons = id.GetColliderPolygons();
break;
case LightingCollider2D.ColliderType.SpriteCustomPhysicsShape:
polygons = id.GetShapePolygons();
break;
}
if (polygons == null || polygons.Count < 1)
{
continue;
}
foreach (Polygon2D polygon in polygons)
{
Polygon2D poly = polygon.ToWorldSpace(id.gameObject.transform);
poly.Normalize();
Vector2D first = null;
List <Pair2D> iterate1 = Pair2D.GetList(poly.pointsList);
List <Pair2D> iterate2 = Pair2D.GetList(PreparePolygon(poly, id.occlusionSize).pointsList);
int i = 0;
foreach (Pair2D pA in iterate1)
{
if (id.edgeCollider2D == true && first == null)
{
first = pA.A;
continue;
}
if (i >= iterate2.Count)
{
continue;
}
Pair2D pB = iterate2[i];
GL.TexCoord2(uv0, uv0);
Max2D.Vertex3(pA.A + offset, z);
GL.TexCoord2(uv1, uv0);
Max2D.Vertex3(pA.B + offset, z);
GL.TexCoord2(uv1, uv1);
Max2D.Vertex3(pB.B + offset, z);
GL.TexCoord2(uv0, uv1);
Max2D.Vertex3(pB.A + offset, z);
i++;
}
}
}
GL.End();
GL.PopMatrix();
}
public static void Draw(Vector2D offset, float z)
{
float sunDirection = LightingManager2D.GetSunDirection();
// Day Soft Shadows
GL.PushMatrix();
Max2D.defaultMaterial.SetPass(0);
GL.Begin(GL.TRIANGLES);
GL.Color(Color.black);
foreach (LightingCollider2D id in LightingCollider2D.GetList())
{
if (id.dayHeight == false || id.height <= 0)
{
continue;
}
List <Polygon2D> polygons = id.GetPolygons();
foreach (Polygon2D polygon in polygons)
{
Polygon2D poly = polygon;
poly = poly.ToWorldSpace(id.gameObject.transform);
foreach (Pair2D p in Pair2D.GetList(poly.pointsList))
{
Vector2D vA = p.A.Copy();
Vector2D vB = p.B.Copy();
vA.Push(sunDirection, id.height);
vB.Push(sunDirection, id.height);
Max2DMatrix.DrawTriangle(p.A, p.B, vA, offset, z);
Max2DMatrix.DrawTriangle(vA, vB, p.B, offset, z);
}
}
}
GL.End();
GL.PopMatrix();
GL.PushMatrix();
LightingManager2D.Get().shadowBlurMaterial.SetPass(0);
GL.Begin(GL.TRIANGLES);
Max2D.SetColor(Color.white);
foreach (LightingCollider2D id in LightingCollider2D.GetList())
{
if (id.dayHeight == false || id.height <= 0)
{
continue;
}
List <Polygon2D> polygons = id.GetPolygons();
foreach (Polygon2D polygon in polygons)
{
Polygon2D poly = polygon;
poly = poly.ToWorldSpace(id.gameObject.transform);
Polygon2D convexHull = Polygon2D.GenerateShadow(new Polygon2D(poly.pointsList), sunDirection, id.height);
foreach (DoublePair2D p in DoublePair2D.GetList(convexHull.pointsList))
{
Vector2D zA = new Vector2D(p.A + offset);
Vector2D zB = new Vector2D(p.B + offset);
Vector2D zC = zB.Copy();
Vector2D pA = zA.Copy();
Vector2D pB = zB.Copy();
zA.Push(Vector2D.Atan2(p.A, p.B) + pi2, .5f);
zB.Push(Vector2D.Atan2(p.A, p.B) + pi2, .5f);
zC.Push(Vector2D.Atan2(p.B, p.C) + pi2, .5f);
GL.TexCoord2(uv0, uv0);
Max2D.Vertex3(pB, z);
GL.TexCoord2(0.5f - uv0, uv0);
Max2D.Vertex3(pA, z);
GL.TexCoord2(0.5f - uv0, uv1);
Max2D.Vertex3(zA, z);
GL.TexCoord2(uv0, uv1);
Max2D.Vertex3(zA, z);
GL.TexCoord2(0.5f - uv0, uv1);
Max2D.Vertex3(zB, z);
GL.TexCoord2(0.5f - uv0, uv0);
Max2D.Vertex3(pB, z);
GL.TexCoord2(uv0, uv1);
Max2D.Vertex3(zB, z);
GL.TexCoord2(0.5f - uv0, uv0);
Max2D.Vertex3(pB, z);
GL.TexCoord2(0.5f - uv0, uv1);
Max2D.Vertex3(zC, z);
}
}
}
GL.End();
GL.PopMatrix();
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;
}
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] == true)
{
DrawSoftShadowTile(offset + new Vector2D(x, y), z, id.height);
}
}
}
}
GL.End();
GL.PopMatrix();
GL.PushMatrix();
LightingManager2D.Get().shadowBlurMaterial.SetPass(0);
GL.Begin(GL.TRIANGLES);
Max2D.SetColor(Color.white);
// Day Soft Shadows
foreach (LightingTilemapCollider2D id in LightingTilemapCollider2D.GetList())
{
if (id.map == null)
{
continue;
}
if (id.dayHeight == false)
{
continue;
}
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] == true)
{
DrawSoftShadowTileBlur(offset + new Vector2D(x, y), z, id.height);
}
}
}
}
GL.End();
GL.PopMatrix();
Material material = LightingManager2D.Get().whiteSpriteMaterial;
foreach (LightingSprite2D id in LightingSprite2D.GetList())
{
if (id.GetSpriteRenderer() == null)
{
continue;
}
material.mainTexture = id.GetSpriteRenderer().sprite.texture; //Debug.Log(sprite.pivot);
Vector2 p = id.transform.position;
Vector2 scale = id.transform.lossyScale;
if (id.GetSpriteRenderer().flipX)
{
scale.x = -scale.x;
}
if (id.GetSpriteRenderer().flipY)
{
scale.y = -scale.y;
}
Max2D.DrawImage(material, offset.ToVector2() + p, scale, id.transform.rotation.eulerAngles.z, z);
}
material = LightingManager2D.Get().additiveMaterial;
foreach (LightingSpriteRenderer2D id in LightingSpriteRenderer2D.GetList())
{
if (id.sprite == null)
{
continue;
}
material.mainTexture = id.sprite.texture; //Debug.Log(sprite.pivot);
Vector2 position = id.transform.position;
Vector2 scale = id.transform.lossyScale;
float scaleX = (float)id.sprite.texture.width / (id.sprite.pixelsPerUnit * 2);
float scaleY = (float)id.sprite.texture.width / (id.sprite.pixelsPerUnit * 2);
//Debug.Log(scaleX + " " + scaleY);
scale.x *= scaleX;
scale.y *= scaleY;
scale.x *= id.scale.x;
scale.y *= id.scale.y;
if (id.flipX)
{
scale.x = -scale.x;
}
if (id.flipY)
{
scale.y = -scale.y;
}
//material.color = id.color;
Color color = id.color;
color.a = id.alpha;
material.SetColor("_TintColor", color);
Max2D.DrawImage(material, offset.ToVector2() + position + id.offset, scale, id.transform.rotation.eulerAngles.z, z);
}
material.mainTexture = null;
float ratio = (float)Screen.width / Screen.height;
Camera bufferCamera = LightingMainBuffer2D.Get().bufferCamera;
Vector2 size = new Vector2(bufferCamera.orthographicSize * ratio, bufferCamera.orthographicSize);
Vector3 pos = Camera.main.transform.position;
Max2D.iDrawImage(LightingManager2D.Get().additiveMaterial, new Vector2D(pos), new Vector2D(size), pos.z);
}
public static void DrawWithAtlas(LightingBuffer2D buffer, int layer)
{
float lightSizeSquared = Mathf.Sqrt(buffer.lightSource.lightSize * buffer.lightSource.lightSize + buffer.lightSource.lightSize * buffer.lightSource.lightSize);
float z = buffer.transform.position.z;
offset.x = -buffer.lightSource.transform.position.x;
offset.y = -buffer.lightSource.transform.position.y;
manager = LightingManager2D.Get();
colliderList = LightingCollider2D.GetList();
LayerSetting layerSetting = buffer.lightSource.layerSetting[layer];
bool maskEffect = (layerSetting.effect == LightingLayerEffect.InvisibleBellow);
#if UNITY_2018_1_OR_NEWER
tilemapList = LightingTilemapCollider2D.GetList();
#endif
// Shadow Fill
manager.materials.GetAtlasMaterial().SetPass(0);
GL.Begin(GL.TRIANGLES);
if (drawShadows)
{
for (int id = 0; id < colliderList.Count; id++)
{
if ((int)colliderList[id].lightingCollisionLayer != layer)
{
continue;
}
// Collider Shadow
LightingBufferMesh.Shadow(buffer, colliderList[id], lightSizeSquared, z);
LightingBufferShape.Shadow(buffer, colliderList[id], lightSizeSquared, z, offset);
}
#if UNITY_2018_1_OR_NEWER
for (int id = 0; id < tilemapList.Count; id++)
{
if ((int)tilemapList[id].lightingCollisionLayer != layer)
{
continue;
}
// Tilemap Shadow
LightingBufferTilemapRectangle.Shadow(buffer, tilemapList[id], lightSizeSquared, z);
}
#endif
}
if (drawMask)
{
if (colliderList.Count > 0)
{
for (int id = 0; id < colliderList.Count; id++)
{
if ((int)colliderList[id].lightingMaskLayer != layer)
{
continue;
}
// Collider Shape Mask
LightingBufferShape.Mask(buffer, colliderList[id], layerSetting, offset, z);
// Collider Sprite Mask
LightingBufferSprite.MaskWithAtlas(buffer, colliderList[id], offset, z);
}
}
#if UNITY_2018_1_OR_NEWER
for (int id = 0; id < tilemapList.Count; id++)
{
if ((int)tilemapList[id].lightingMaskLayer != layer)
{
continue;
}
// Tilemap Shape Mask
LightingBufferTilemapRectangle.MaskShape(buffer, tilemapList[id], offset, z);
// Tilemap Sprite Mask
LightingBufferTilemapRectangle.MaskSpriteWithAtlas(buffer, tilemapList[id], offset, z);
}
#endif
}
GL.End();
// Partialy Batched (Default Edition)
if (buffer.partiallyBatchedList_Collider.Count > 0)
{
Material materialWhite = manager.materials.GetWhiteSprite();
Material materialBlack = manager.materials.GetBlackSprite();
Material material;
PartiallyBatched_Collider batch;
materialWhite.mainTexture = SpriteAtlasManager.Get().atlasTexture.texture;
materialWhite.SetPass(0);
for (int i = 0; i < buffer.partiallyBatchedList_Collider.Count; i++)
{
batch = buffer.partiallyBatchedList_Collider[i];
material = materialWhite;
if (maskEffect && colliderList[i].transform.position.y < buffer.lightSource.transform.position.y)
{
material = materialBlack;
}
LightingBufferSprite.MaskWithoutAtlas(buffer, batch.collider2D, material, offset, z);
}
materialWhite.mainTexture = null;
buffer.partiallyBatchedList_Collider.Clear();
}
if (buffer.partiallyBatchedList_Tilemap.Count > 0)
{
Material materialWhite = manager.materials.GetWhiteSprite();
Material materialBlack = manager.materials.GetBlackSprite();
PartiallyBatched_Tilemap batch;
Material material;
// Draw Each Partialy Batched
for (int i = 0; i < buffer.partiallyBatchedList_Tilemap.Count; i++)
{
batch = buffer.partiallyBatchedList_Tilemap[i];
material = materialWhite;
if (maskEffect && batch.polyOffset.y < 0)
{
material = materialBlack;
}
material.mainTexture = batch.virtualSpriteRenderer.sprite.texture;
Max2D.DrawSprite(material, batch.virtualSpriteRenderer, batch.polyOffset, batch.tileSize, 0, z);
material.mainTexture = null;
}
buffer.partiallyBatchedList_Tilemap.Clear();
}
}
public static void Draw(Vector2D offset, float z)
{
List <LightingSpriteRenderer2D> list = LightingSpriteRenderer2D.GetList();
LightingSpriteRenderer2D id;
Material material;
Vector2 position, scale;
float rot;
Color color;
for (int i = 0; i < list.Count; i++)
{
id = list[i];
if (id.GetSprite() == null)
{
continue;
}
if (id.InCamera() == false)
{
continue;
}
LightingManager2D.LightingDebug.SpriteRenderersDrawn++;
position = id.transform.position;
scale = id.transform.lossyScale;
scale.x *= id.offsetScale.x;
scale.y *= id.offsetScale.y;
rot = id.offsetRotation;
if (id.applyTransformRotation)
{
rot += id.transform.rotation.eulerAngles.z;
}
switch (id.type)
{
case LightingSpriteRenderer2D.Type.Particle:
color = id.color;
color.a = id.alpha;
material = LightingManager2D.Get().additiveMaterial;
material.mainTexture = id.GetSprite().texture;
material.SetColor("_TintColor", color);
Max2D.DrawSpriteRenderer(material, id.spriteRenderer, offset.ToVector2() + position + id.offsetPosition, scale, rot, z);
material.mainTexture = null;
break;
case LightingSpriteRenderer2D.Type.WhiteMask:
material = LightingManager2D.Get().whiteSpriteMaterial;
material.mainTexture = id.GetSprite().texture;
Max2D.DrawSpriteRenderer(material, id.spriteRenderer, offset.ToVector2() + position + id.offsetPosition, scale, rot, z);
material.mainTexture = null;
break;
case LightingSpriteRenderer2D.Type.BlackMask:
material = LightingManager2D.Get().blackSpriteMaterial;
material.mainTexture = id.sprite.texture;
Max2D.DrawSpriteRenderer(material, id.spriteRenderer, offset.ToVector2() + position + id.offsetPosition, scale, rot, z);
material.mainTexture = null;
break;
}
}
}
public void OnRenderObject()
{
Max2D.SetLineWidth(lineWidth);
Max2D.SetColor(Color.white);
Max2D.SetLineMode(Max2D.LineMode.Smooth);
Max2D.SetBorder(false);
if (polygon == null)
{
return;
}
Polygon2D poly = polygon.ToWorldSpace(transform);
float z = transform.position.z + lineOffset;
List <DoublePair2D> list = DoublePair2D.GetList(poly.pointsList);
DoublePair2D lastPair = list.Last();
GL.PushMatrix();
materialAdditive.SetPass(0);
GL.Begin(GL.QUADS);
foreach (DoublePair2D p in list)
{
Vector2D vA = GetPoint(lastPair);
Vector2D vB = GetPoint(p);
if (vA == null || vB == null)
{
continue;
}
float c = (Mathf.Cos(Vector2D.Atan2(vA, vB) + Mathf.PI / 4) + 1f) / 8.75f;
GL.Color(new Color(c, c, c));
GL.TexCoord2(uv0, uv0);
GL.Vertex3(p.A.vector.x, p.A.vector.y, z);
GL.TexCoord2(uv1, uv0);
GL.Vertex3(p.B.vector.x, p.B.vector.y, z);
GL.TexCoord2(uv1, uv1);
GL.Vertex3(vB.vector.x, vB.vector.y, z);
GL.TexCoord2(uv0, uv1);
GL.Vertex3(vA.vector.x, vA.vector.y, z);
lastPair = p;
}
GL.End();
materialMultiply.SetPass(0);
GL.Begin(GL.QUADS);
foreach (DoublePair2D p in list)
{
Vector2D vA = GetPoint(lastPair);
Vector2D vB = GetPoint(p);
if (vA == null || vB == null)
{
continue;
}
float c = (Mathf.Cos(Vector2D.Atan2(vA, vB) + Mathf.PI / 4) + 1f) / 1.75f + 0.5f;
GL.Color(new Color(c, c, c));
GL.TexCoord2(uv0, uv0);
GL.Vertex3(p.A.vector.x, p.A.vector.y, z);
GL.TexCoord2(uv1, uv0);
GL.Vertex3(p.B.vector.x, p.B.vector.y, z);
GL.TexCoord2(uv1, uv1);
GL.Vertex3(vB.vector.x, vB.vector.y, z);
GL.TexCoord2(uv0, uv1);
GL.Vertex3(vA.vector.x, vA.vector.y, z);
lastPair = p;
}
GL.End();
GL.PopMatrix();
}
public static void Draw(Vector2D offset, float z)
{
// Collider Ambient Occlusion
GL.PushMatrix();
LightingManager2D.Get().occlusionBlurMaterial.SetPass(0);
GL.Begin(GL.QUADS);
GL.Color(Color.white);
foreach (LightingCollider2D id in LightingCollider2D.GetList())
{
if (id.ambientOcclusion == false || id.smoothOcclusionEdges == true)
{
continue;
}
// Do not call Create From Collider
List <Polygon2D> polygons = id.GetPolygons();
foreach (Polygon2D polygon in polygons)
{
Polygon2D poly = polygon;
poly = poly.ToWorldSpace(id.gameObject.transform);
poly.Normalize();
Vector2D first = null;
List <Pair2D> iterate1 = Pair2D.GetList(poly.pointsList);
List <Pair2D> iterate2 = Pair2D.GetList(PreparePolygon(poly, id.occlusionSize).pointsList);
int i = 0;
foreach (Pair2D pA in iterate1)
{
if (id.edgeCollider2D == true && first == null)
{
first = pA.A;
continue;
}
Pair2D pB = iterate2[i];
GL.TexCoord2(uv0, uv0);
Max2D.Vertex3(pA.A + offset, z);
GL.TexCoord2(uv1, uv0);
Max2D.Vertex3(pA.B + offset, z);
GL.TexCoord2(uv1, uv1);
Max2D.Vertex3(pB.B + offset, z);
GL.TexCoord2(uv0, uv1);
Max2D.Vertex3(pB.A + offset, z);
i++;
}
}
}
GL.End();
GL.PopMatrix();
GL.PushMatrix();
LightingManager2D.Get().occlusionEdgeMaterial.SetPass(0);
GL.Begin(GL.TRIANGLES);
foreach (LightingCollider2D id in LightingCollider2D.GetList())
{
if (id.ambientOcclusion == false || id.smoothOcclusionEdges == false)
{
continue;
}
// Do not call Create From Collider
List <Polygon2D> polygons = id.GetPolygons();
foreach (Polygon2D polygon in polygons)
{
Polygon2D poly = polygon;
poly = poly.ToWorldSpace(id.gameObject.transform);
poly.Normalize();
foreach (DoublePair2D p in DoublePair2D.GetList(poly.pointsList))
{
Vector2D vA = p.A + offset;
Vector2D vB = p.B + offset;
Vector2D vC = p.B + offset;
Vector2D pA = p.A + offset;
Vector2D pB = p.B + offset;
vA.Push(Vector2D.Atan2(p.A, p.B) - Mathf.PI / 2, id.occlusionSize);
vB.Push(Vector2D.Atan2(p.A, p.B) - Mathf.PI / 2, id.occlusionSize);
vC.Push(Vector2D.Atan2(p.B, p.C) - Mathf.PI / 2, id.occlusionSize);
GL.TexCoord2(uv0, uv0);
Max2D.Vertex3(pB, z);
GL.TexCoord2(0.5f - uv0, uv0);
Max2D.Vertex3(pA, z);
GL.TexCoord2(0.5f - uv0, uv1);
Max2D.Vertex3(vA, z);
GL.TexCoord2(uv0, uv1);
Max2D.Vertex3(vA, z);
GL.TexCoord2(0.5f - uv0, uv1);
Max2D.Vertex3(vB, z);
GL.TexCoord2(0.5f - uv0, uv0);
Max2D.Vertex3(pB, z);
GL.TexCoord2(uv1, uv0);
Max2D.Vertex3(vB, z);
GL.TexCoord2(0.5f - uv0, uv0);
Max2D.Vertex3(pB, z);
GL.TexCoord2(0.5f - uv0, uv1);
Max2D.Vertex3(vC, z);
}
}
}
GL.End();
GL.PopMatrix();
GL.PushMatrix();
LightingManager2D.Get().occlusionEdgeMaterial.SetPass(0);
GL.Begin(GL.TRIANGLES);
foreach (LightingTilemapCollider2D id in LightingTilemapCollider2D.GetList())
{
if (id.map == null)
{
continue;
}
if (id.ambientOcclusion == false)
{
continue;
}
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] == false)
{
continue;
}
Vector2D offs = offset.Copy();
offs += new Vector2D(0.5f, 0.5f);
offs += new Vector2D(id.area.position.x, id.area.position.y);
offs += new Vector2D(-id.area.size.x / 2, -id.area.size.y / 2);
DrawTileOcclussion(offs + new Vector2D(x, y), z, id);
}
}
}
GL.End();
GL.PopMatrix();
}
public void OnRenderObject()
{
if (Camera.current != Camera.main)
{
return;
}
Max2D.SetLineWidth(0.5f);
Max2D.SetColor(Color.white);
Max2D.SetBorder(false);
Max2D.SetLineMode(Max2D.LineMode.Default);
GL.PushMatrix();
material.SetPass(0);
GL.Begin(GL.QUADS);
float lineOffset = -0.001f;
float z = transform.position.z + lineOffset;
Pair2D prevPair = null;
foreach (HingeJoint2D joint in nodes)
{
if (joint == null)
{
continue;
}
Pair2D pairA = null;
Pair2D pairB = null;
if (joint == nodes.Last())
{
pairA = GetPair(joint.connectedBody.transform.position, joint.transform.position);
if (prevPair != null)
{
pairB = prevPair;
}
else
{
pairB = GetPair(joint.transform.position, joint.connectedBody.transform.position);
}
}
else
{
pairA = GetPair(joint.transform.position, joint.connectedBody.transform.position);
if (prevPair != null)
{
pairB = prevPair;
}
else
{
pairB = GetPair(joint.transform.position, joint.connectedBody.transform.position);
}
}
GL.TexCoord2(0, 0);
GL.Vertex3((float)pairA.A.x, (float)pairA.A.y, z);
GL.TexCoord2(1, 0);
GL.Vertex3((float)pairA.B.x, (float)pairA.B.y, z);
GL.TexCoord2(1, 1);
GL.Vertex3((float)pairB.A.x, (float)pairB.A.y, z);
GL.TexCoord2(0, 1);
GL.Vertex3((float)pairB.B.x, (float)pairB.B.y, z);
prevPair = new Pair2D(pairA.B, pairA.A);
}
GL.End();
GL.PopMatrix();
}
void DrawCollideMask()
{
float z = transform.position.z;
Vector2D offset = new Vector2D(-lightSource.transform.position);
Material material = LightingManager2D.Get().whiteSpriteMaterial;
// For Collider Sprite Mask
foreach (LightingCollider2D id in LightingCollider2D.GetList())
{
Sprite sprite = id.lightSprite;
if (sprite == null || id.spriteRenderer == null)
{
continue;
}
if (id.maskType != LightingCollider2D.MaskType.Sprite)
{
continue;
}
material.mainTexture = sprite.texture;
Vector2 p = id.transform.position;
Vector2 scale = id.transform.lossyScale;
scale.x *= (float)sprite.texture.width / sprite.texture.height;
if (id.spriteRenderer.flipX)
{
scale.x = -scale.x;
}
if (id.spriteRenderer.flipY)
{
scale.y = -scale.y;
}
Max2D.DrawImage(material, offset.ToVector2() + p, scale, id.transform.rotation.eulerAngles.z, z);
}
GL.PushMatrix();
Max2D.defaultMaterial.SetPass(0);
GL.Begin(GL.TRIANGLES);
GL.Color(Color.white);
// For Collider Mask
foreach (LightingCollider2D id in LightingCollider2D.GetList())
{
Mesh mesh = id.GetMesh();
if (mesh == null)
{
continue;
}
if (id.maskType != LightingCollider2D.MaskType.Collider)
{
continue;
}
for (int i = 0; i < mesh.triangles.GetLength(0); i = i + 3)
{
Vector2 a = id.transform.TransformPoint(mesh.vertices [mesh.triangles [i]]);
Vector2 b = id.transform.TransformPoint(mesh.vertices [mesh.triangles [i + 1]]);
Vector2 c = id.transform.TransformPoint(mesh.vertices [mesh.triangles [i + 2]]);
Max2DMatrix.DrawTriangle(a, b, c, offset.ToVector2(), z);
}
}
GL.End();
GL.PopMatrix();
}
void DrawLightTexture()
{
float z = transform.position.z;
Vector2 size = new Vector2(bufferCamera.orthographicSize, bufferCamera.orthographicSize);
if (lightSource.rotationEnabled)
{
Max2D.DrawImage(lightSource.GetMaterial(), Vector2.zero, size, lightSource.transform.rotation.eulerAngles.z, z);
// Light Rotation!!!
GL.PushMatrix();
Max2D.SetColor(Color.black);
GL.Begin(GL.TRIANGLES);
Max2D.defaultMaterial.color = Color.black;
Max2D.defaultMaterial.SetPass(0);
float rotation = lightSource.transform.rotation.eulerAngles.z * Mathf.Deg2Rad + Mathf.PI / 4;
float squaredSize = Mathf.Sqrt((size.x * size.x) + (size.y * size.y));
Vector2 p0 = Vector2D.RotToVec((double)rotation).ToVector2() * squaredSize;
Vector2 p1 = Vector2D.RotToVec((double)rotation + Mathf.PI / 2).ToVector2() * squaredSize;
Vector2 p2 = Vector2D.RotToVec((double)rotation + Mathf.PI).ToVector2() * squaredSize;
Vector2 p3 = Vector2D.RotToVec((double)rotation - Mathf.PI / 2).ToVector2() * squaredSize;
Vector2 up0 = p1 + Vector2D.RotToVec((double)rotation + Mathf.PI / 4 + Mathf.PI / 2).ToVector2() * squaredSize;
Vector2 up1 = p1 + Vector2D.RotToVec((double)rotation + Mathf.PI / 4).ToVector2() * squaredSize;
up1 += Vector2D.RotToVec((double)rotation + Mathf.PI / 4 + Mathf.PI / 2).ToVector2() * squaredSize;
Vector2 up2 = p0 + Vector2D.RotToVec((double)rotation + Mathf.PI / 4).ToVector2() * squaredSize;
up2 += Vector2D.RotToVec((double)rotation + Mathf.PI / 4 - Mathf.PI / 2).ToVector2() * squaredSize;
Vector2 up3 = p0 + Vector2D.RotToVec((double)rotation + Mathf.PI / 4 - Mathf.PI / 2).ToVector2() * squaredSize;
Vector2 down0 = p3 + Vector2D.RotToVec((double)rotation + Mathf.PI / 4 + Mathf.PI / 2 - Mathf.PI).ToVector2() * squaredSize;
Vector2 down1 = p3 + Vector2D.RotToVec((double)rotation + Mathf.PI / 4 - Mathf.PI).ToVector2() * squaredSize;
down1 += Vector2D.RotToVec((double)rotation + Mathf.PI / 4 + Mathf.PI / 2 - Mathf.PI).ToVector2() * squaredSize;
Vector2 down2 = p2 + Vector2D.RotToVec((double)rotation + Mathf.PI / 4 - Mathf.PI).ToVector2() * squaredSize;
down2 += Vector2D.RotToVec((double)rotation + Mathf.PI / 4 - Mathf.PI / 2 - Mathf.PI).ToVector2() * squaredSize;
Vector2 down3 = p2 + Vector2D.RotToVec((double)rotation + Mathf.PI / 4 - Mathf.PI / 2 - Mathf.PI).ToVector2() * squaredSize;
Vector2 left0 = p0 + Vector2D.RotToVec((double)rotation + Mathf.PI / 4 + Mathf.PI / 2 - Mathf.PI / 2).ToVector2() * squaredSize;
Vector2 left1 = p0 + Vector2D.RotToVec((double)rotation + Mathf.PI / 4 - Mathf.PI / 2).ToVector2() * squaredSize;
left1 += Vector2D.RotToVec((double)rotation + Mathf.PI / 4 + Mathf.PI / 2 - Mathf.PI / 2).ToVector2() * squaredSize;
Vector2 left2 = p3 + Vector2D.RotToVec((double)rotation + Mathf.PI / 4 - Mathf.PI / 2).ToVector2() * squaredSize;
left2 += Vector2D.RotToVec((double)rotation + Mathf.PI / 4 - Mathf.PI / 2 - Mathf.PI / 2).ToVector2() * squaredSize;
Vector2 left3 = p3 + Vector2D.RotToVec((double)rotation + Mathf.PI / 4 - Mathf.PI / 2 - Mathf.PI / 2).ToVector2() * squaredSize;
Vector2 right0 = p2 + Vector2D.RotToVec((double)rotation + Mathf.PI / 4 + Mathf.PI / 2 + Mathf.PI / 2).ToVector2() * squaredSize;
Vector2 right1 = p2 + Vector2D.RotToVec((double)rotation + Mathf.PI / 4 + Mathf.PI / 2).ToVector2() * squaredSize;
left1 += Vector2D.RotToVec((double)rotation + Mathf.PI / 4 + Mathf.PI / 2 + Mathf.PI / 2).ToVector2() * squaredSize;
Vector2 right2 = p1 + Vector2D.RotToVec((double)rotation + Mathf.PI / 4 + Mathf.PI / 2).ToVector2() * squaredSize;
left2 += Vector2D.RotToVec((double)rotation + Mathf.PI / 4 - Mathf.PI / 2 + Mathf.PI / 2).ToVector2() * squaredSize;
Vector2 right3 = p1 + Vector2D.RotToVec((double)rotation + Mathf.PI / 4 - Mathf.PI / 2 + Mathf.PI / 2).ToVector2() * squaredSize;
Max2DMatrix.DrawTriangle(right0, right1, right2, Vector2.zero, z);
Max2DMatrix.DrawTriangle(right2, right3, right0, Vector2.zero, z);
Max2DMatrix.DrawTriangle(left0, left1, left2, Vector2.zero, z);
Max2DMatrix.DrawTriangle(left2, left3, left0, Vector2.zero, z);
Max2DMatrix.DrawTriangle(down0, down1, down2, Vector2.zero, z);
Max2DMatrix.DrawTriangle(down2, down3, down0, Vector2.zero, z);
Max2DMatrix.DrawTriangle(up0, up1, up2, Vector2.zero, z);
Max2DMatrix.DrawTriangle(up2, up3, up0, Vector2.zero, z);
GL.End();
GL.PopMatrix();
Max2D.defaultMaterial.color = Color.white;
}
else
{
Max2D.DrawImage(lightSource.GetMaterial(), Vector2.zero, size, 0, z);
}
}
public void OnRenderObject()
{
if (Camera.current != bufferCamera)
{
return;
}
LightingManager2D.LightingDebug.LightBufferUpdates++;
if (lightSource == null)
{
return;
}
if (lightSource.update == false)
{
bufferCamera.enabled = false;
}
LateUpdate();
lightSource.update = false;
material.SetColor("_TintColor", lightSource.color);
Vector2D vZero = new Vector2D(0, 0);
float z = transform.position.z;
Max2D.Check();
GL.PushMatrix();
Max2D.defaultMaterial.SetPass(0);
GL.Begin(GL.TRIANGLES);
GL.Color(Color.black);
foreach (LightingCollider2D id in LightingCollider2D.GetList())
{
Polygon2D poly = id.GetPolygon();
poly = poly.ToWorldSpace(id.gameObject.transform);
poly = poly.ToOffset(new Vector2D(-lightSource.transform.position));
if (poly.PointInPoly(vZero))
{
continue;
}
foreach (Pair2D p in Pair2D.GetList(poly.pointsList))
{
Vector2D vA = p.A.Copy();
Vector2D vB = p.B.Copy();
vA.Push(Vector2D.Atan2(vA, vZero), 15);
vB.Push(Vector2D.Atan2(vB, vZero), 15);
Max2DMatrix.DrawTriangle(p.A, p.B, vA, vZero, z);
Max2DMatrix.DrawTriangle(vA, vB, p.B, vZero, z);
}
}
GL.End();
GL.PopMatrix();
GL.PushMatrix();
LightingManager2D.Get().penumbraMaterial.SetPass(0);
GL.Begin(GL.TRIANGLES);
GL.Color(Color.white);
const float uv0 = 1f / 128f;
const float uv1 = 1f - uv0;
foreach (LightingCollider2D id in LightingCollider2D.GetList())
{
Polygon2D poly = id.GetPolygon();
poly = poly.ToWorldSpace(id.gameObject.transform);
poly = poly.ToOffset(new Vector2D(-lightSource.transform.position));
if (poly.PointInPoly(vZero))
{
continue;
}
foreach (Pair2D p in Pair2D.GetList(poly.pointsList))
{
Vector2D vA = p.A.Copy();
Vector2D pA = p.A.Copy();
Vector2D vB = p.B.Copy();
Vector2D pB = p.B.Copy();
float angleA = (float)Vector2D.Atan2(vA, vZero);
float angleB = (float)Vector2D.Atan2(vB, vZero);
vA.Push(angleA, lightSource.lightSize);
pA.Push(angleA - Mathf.Deg2Rad * 25, lightSource.lightSize);
vB.Push(angleB, lightSource.lightSize);
pB.Push(angleB + Mathf.Deg2Rad * 25, lightSource.lightSize);
GL.TexCoord2(uv0, uv0);
GL.Vertex3((float)p.A.x, (float)p.A.y, z);
GL.TexCoord2(uv1, uv0);
GL.Vertex3((float)vA.x, (float)vA.y, z);
GL.TexCoord2((float)uv0, uv1);
GL.Vertex3((float)pA.x, (float)pA.y, z);
GL.TexCoord2(uv0, uv0);
GL.Vertex3((float)p.B.x, (float)p.B.y, z);
GL.TexCoord2(uv1, uv0);
GL.Vertex3((float)vB.x, (float)vB.y, z);
GL.TexCoord2(uv0, uv1);
GL.Vertex3((float)pB.x, (float)pB.y, z);
}
}
GL.End();
GL.PopMatrix();
Max2D.SetColor(Color.white);
foreach (LightingCollider2D id in LightingCollider2D.GetList())
{
Max2D.iDrawMesh(id.GetMesh(), id.transform, new Vector2D(-lightSource.transform.position), z);
}
Vector2 size = new Vector2(bufferCamera.orthographicSize, bufferCamera.orthographicSize);
if (lightSource.rotationEnabled)
{
Max2D.DrawImage(lightSource.GetMaterial(), Vector2.zero, size, lightSource.transform.rotation.eulerAngles.z, z);
}
else
{
Max2D.DrawImage(lightSource.GetMaterial(), Vector2.zero, size, 0, z);
}
GL.PushMatrix();
Max2D.SetColor(Color.black);
Max2D.defaultMaterial.color = Color.black;
Max2D.defaultMaterial.SetPass(0);
float rotation = lightSource.transform.rotation.eulerAngles.z;
float squaredSize = Mathf.Sqrt((size.x * size.x) + (size.y * size.y));
Vector2 p0 = Vector2D.RotToVec((double)rotation).ToVector2() * squaredSize;
Vector2 p1 = Vector2D.RotToVec((double)rotation + Mathf.PI / 4).ToVector2() * squaredSize;
Max2DMatrix.DrawTriangle(Vector2.zero, p0, p1, Vector2.zero, z);
Max2DMatrix.DrawTriangle(Vector2.zero, p1, p0, Vector2.zero, z);
//Max2DMatrix.DrawTriangle(vA, vB, p.B, vZero, z);
GL.End();
GL.PopMatrix();
Max2D.defaultMaterial.color = Color.white;
//lightSource = null;
//bufferCamera.enabled = false;
}
static public void MaskSpriteWithoutAtlas(Camera camera, LightingTilemapRoom2D id, Material materialA, Material materialB, Vector2D offset, float z)
{
//if (id.maskType != LightingTilemapCollider2D.MaskType.Sprite) {
// return;
//}
if (id.map == null)
{
return;
}
Material material;
SetupLocation(camera, id);
//bool invisible = true; //(id.maskMode == LightingMaskMode.Invisible);
for (int x = newPositionInt.x - sizeInt; x < newPositionInt.x + sizeInt; x++)
{
for (int y = newPositionInt.y - sizeInt; y < newPositionInt.y + sizeInt; y++)
{
if (x < 0 || y < 0)
{
continue;
}
if (x >= id.area.size.x || y >= id.area.size.y)
{
continue;
}
tile = id.map[x, y];
if (tile == null)
{
continue;
}
if (tile.GetOriginalSprite() == null)
{
return;
}
polyOffset.x = x + tilemapOffset.x;
polyOffset.y = y + tilemapOffset.y;
polyOffset.x *= scale.x;
polyOffset.y *= scale.y;
polyOffset2.x = (float)polyOffset.x;
polyOffset2.y = (float)polyOffset.y;
//if (LightingManager2D.culling && Vector2.Distance(polyOffset2, buffer.lightSource.transform.position) > 2 + buffer.lightSource.lightSize) {
// LightingDebug.culled ++;
// continue;
//}
polyOffset.x += offset.x;
polyOffset.y += offset.y;
spriteRenderer.sprite = tile.GetOriginalSprite();
polyOffset2.x = (float)polyOffset.x;
polyOffset2.y = (float)polyOffset.y;
material = materialB;
material.mainTexture = spriteRenderer.sprite.texture;
Max2D.DrawSprite(material, spriteRenderer, polyOffset2, tileSize, 0, z);
material.mainTexture = null;
LightingDebug.maskGenerations++;
}
}
}
public void OnRenderObject()
{
Vector2f pos = GetMousePosition();
if (drawSlicer == false)
{
return;
}
Max2D.SetBorder(true);
Max2D.SetSmooth(true);
Max2D.SetLineWidth(lineWidth * .5f);
if (mouseDown)
{
Max2D.SetColor(slicerColor);
switch (sliceType)
{
case SliceType.Complex:
if (complexPairs.Count > 0)
{
Max2D.DrawStrippedLine(complexPairs, minVertsDistance, zPosition);
Max2D.DrawLineSquare(complexPairs.Last(), 0.5f, zPosition);
Max2D.DrawLineSquare(complexPairs.First(), 0.5f, zPosition);
}
break;
case SliceType.Create:
if (createType == CreateType.Slice)
{
if (complexPairs.Count > 0)
{
Max2D.DrawStrippedLine(complexPairs, minVertsDistance, zPosition, true);
Max2D.DrawLineSquare(complexPairs.Last(), 0.5f, zPosition);
Max2D.DrawLineSquare(complexPairs.First(), 0.5f, zPosition);
}
}
else
{
Max2D.DrawStrippedLine(Polygon.Create(polygonType, polygonSize).pointsList, minVertsDistance, zPosition, true, pos);
}
break;
case SliceType.Linear:
Max2D.DrawLine(linearPair.A, linearPair.B, zPosition);
Max2D.DrawLineSquare(linearPair.A, 0.5f, zPosition);
Max2D.DrawLineSquare(linearPair.B, 0.5f, zPosition);
break;
case SliceType.Point:
break;
case SliceType.Explode:
break;
case SliceType.Polygon:
slicePolygon = Polygon.Create(polygonType, polygonSize);
//Max2D.DrawStrippedLine (slicePolygon.pointsList, minVertsDistance, zPosition, false, pos);
break;
case SliceType.Photo:
break;
default:
break;
}
}
}
