public void Initialize()
{
if (GetComponents <Mesh2D>().Length > 1)
{
//Slicer2D.Debug.LogError("Multiple 'Mesh2D' components cannot be attached to the same game object");
return;
}
// Generate Mesh from collider
Polygon2D polygon = Polygon2DList.CreateFromGameObject(gameObject)[0];
if (polygon != null)
{
polygon.CreateMesh(gameObject, materialScale, materialOffset, triangulation);
meshFilter = GetComponent <MeshFilter>();
// Setting Mesh material
if (material != null)
{
meshRenderer = GetComponent <MeshRenderer> ();
meshRenderer.sharedMaterial = material;
meshRenderer.sortingLayerName = sortingLayerName;
meshRenderer.sortingOrder = sortingOrder;
}
}
}
void Start()
{
if (GetComponents <Mesh2D>().Length > 1)
{
Slicer2D.Debug.LogError("Multiple 'Mesh2D' components cannot be attached to the same game object");
return;
}
if (GetComponent <Slicer2D>() != null)
{
Slicer2D.Debug.LogError("'Mesh2D' and Slicer2D components cannot be attached to the same game object");
return;
}
// Generate Mesh from collider
Polygon2D polygon = Polygon2D.CreateFromCollider(gameObject);
if (polygon != null)
{
polygon.CreateMesh(gameObject, Vector2.zero, Vector2.zero, triangulation);
// Setting Mesh material
if (material != null)
{
MeshRenderer meshRenderer = GetComponent <MeshRenderer> ();
meshRenderer.material = material;
meshRenderer.sortingLayerName = sortingLayerName;
meshRenderer.sortingLayerID = sortingLayerID;
meshRenderer.sortingOrder = sortingOrder;
}
}
}
void Start()
{
Polygon2D polygon = Polygon2DList.CreateFromGameObject(gameObject)[0];
polygon = polygon.ToOffset(new Vector2D(0.125f, -0.125f));
mesh = polygon.CreateMesh(Vector2.zero, Vector2.zero);
Update();
}
// 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;
}
public static Mesh GetStaticTileMesh()
{
if (staticTileMesh == null)
{
Polygon2D tilePoly = Polygon2D.CreateFromRect(new Vector2(0.5f + 0.01f, 0.5f + 0.01f));
staticTileMesh = tilePoly.CreateMesh(Vector2.zero, Vector2.zero);
}
return(staticTileMesh);
}
public static Mesh GetRenderMesh()
{
if (preRenderMesh == null)
{
Polygon2D tilePoly = Polygon2D.CreateFromRect(new Vector2(1f, 1f));
Mesh staticTileMesh = tilePoly.CreateMesh(new Vector2(2f, 2f), Vector2.zero);
preRenderMesh = staticTileMesh;
}
return(preRenderMesh);
}
void Initialize()
{
Transform transform = renderCamera.transform;
//DrawSelf
foreach (DestructionModifier modifier in destructible.modifiers)
{
Vector3 pos = (Vector3)modifier.position;
float ratioX = (destructible.transform.localScale.x / destructible.transform.localScale.y);
Vector2 size = modifier.size;
pos.x *= transform.localScale.x;
pos.y *= transform.localScale.y * ratioX;
size.y *= ratioX;
Vector2 scale = new Vector2(destructible.transform.localScale.x, destructible.transform.localScale.y);
Max2D.DrawImage(transform, modifier.material, pos, size, modifier.rotation, 0.3f, new Vector2D(scale));
}
foreach (Polygon2D p in destructible.erasePolygons)
{
Vector2 scale = new Vector2(1, 1);
Polygon2D polygon = p.ToScale(scale);
Mesh mesh = polygon.CreateMesh(Vector2.zero, Vector2.zero);
EraseMesh eraseMesh = new EraseMesh();
eraseMesh.mesh = mesh;
destructible.EraseBrushes.Add(eraseMesh);
}
// Not Necessary? Why?
foreach (EraseMesh e in destructible.EraseBrushes)
{
float ratioX = destructible.transform.localScale.x / destructible.transform.localScale.y;
Vector2 scale = destructible.transform.localScale;
scale.y *= ratioX;
Max2D.DrawMesh(GetEraseMaterial(), e.mesh, transform, Vector2D.Zero(), transform.position.z + 0.2f, new Vector2D(scale));
}
SaveRenderTextureToSprite();
destructible.initialized = true;
}
public Mesh GetTileDynamicMesh()
{
if (tileMesh == null)
{
if (polygons.Count > 0)
{
Polygon2D tilePoly = polygons[0];
tileMesh = tilePoly.CreateMesh(Vector2.zero, Vector2.zero);
//Polygon2D.CreateFromRect(new Vector2(0.5f + 0.01f, 0.5f + 0.01f));
}
}
return(tileMesh);
}
private void CreatePolygon(Polygon2D newPolygon)
{
GameObject newGameObject = new GameObject();
newGameObject.transform.parent = transform;
newGameObject.AddComponent <Rigidbody2D> ();
newGameObject.AddComponent <ColliderLineRenderer2D> ().color = Color.black;
Slicer2D smartSlicer = newGameObject.AddComponent <Slicer2D> ();
smartSlicer.textureType = Slicer2D.TextureType.Mesh2D;
smartSlicer.material = material;
newPolygon.CreateCollider(newGameObject);
newPolygon.CreateMesh(newGameObject, new Vector2(1, 1), Vector2.zero, PolygonTriangulator2D.Triangulation.Advanced);
}
public void CreateMesh(GameObject gameObject, Polygon2D polygon)
{
polygon.CreateMesh(gameObject, scale, offset, GetTriangulation());
if (material)
{
MeshRenderer meshRenderer = gameObject.GetComponent <MeshRenderer> ();
if (Settings.GetBatching(batchMaterial))
{
Slicer2D.Profiler.IncBatchingApplied();
meshRenderer.sharedMaterial = material;
}
else
{
meshRenderer.sharedMaterial = new Material(material);
}
}
}
//ポリゴン生成
private void CreatePolygon(Polygon2D newPolygon, Transform transform)
{
GameObject newGameObject = new GameObject();
newGameObject.transform.parent = transform;
newGameObject.transform.position = new Vector3(0, 0, visuals.zPosition + 0.01f);
//ここで力を加えてやる
newGameObject.AddComponent <Rigidbody2D> ();
newGameObject.AddComponent <ColliderLineRenderer2D> ().color = Color.black;
Slicer2D smartSlicer = newGameObject.AddComponent <Slicer2D> ();
smartSlicer.textureType = Slicer2D.TextureType.Mesh2D;
smartSlicer.materialSettings.material = material;
newPolygon.CreatePolygonCollider(newGameObject);
newPolygon.CreateMesh(newGameObject, new Vector2(1, 1), Vector2.zero, PolygonTriangulator2D.Triangulation.Advanced);
}
public void Draw()
{
if (lineBorder && meshBorder.Count > 0)
{
if (meshBorder.Count > 0)
{
foreach (Mesh m in meshBorder)
{
Max2DMesh.Draw(m, GetBorderMaterial());
}
}
}
if (mesh.Count > 0)
{
foreach (Mesh m in mesh)
{
Max2DMesh.Draw(m, GetFillMaterial());
}
}
if (customEndingsPosition.Count > 0)
{
Matrix4x4 matrix;
foreach (Pair2D pair in customEndingsPosition)
{
Polygon2D polyA = Polygon2D.CreateFromRect(new Vector2(1, 1));
//polyA.ToOffset(pair.A);
Mesh mA = polyA.CreateMesh(new Vector2(2, 2), Vector2.zero);
matrix = Matrix4x4.TRS(pair.A.ToVector3(zPosition), Quaternion.Euler(0, 0, 0), new Vector3(1, 1, 1));
Graphics.DrawMesh(mA, matrix, customEndingImageMaterial, 0);
matrix = Matrix4x4.TRS(pair.B.ToVector3(zPosition), Quaternion.Euler(0, 0, 0), new Vector3(1, 1, 1));
Graphics.DrawMesh(mA, matrix, customEndingImageMaterial, 0);
}
}
}
static public void DrawPolygonMesh(Polygon2D polygon)
{
Mesh mesh = polygon.CreateMesh(Vector2.zero, Vector2.zero);
Max2D.DrawMesh(Max2D.defaultMaterial, mesh, new Vector2D(0, 0), 0);
}
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;
}
if (id.colliderType == LightingCollider2D.ColliderType.Mesh)
{
continue;
}
List <Polygon2D> polygons = null;
switch (id.colliderType)
{
case LightingCollider2D.ColliderType.Collider:
polygons = id.GetColliderPolygons();
break;
case LightingCollider2D.ColliderType.SpriteCustomPhysicsShape:
polygons = id.GetShapePolygons();
break;
}
Polygon2D poly;
Vector3 vecA;
Vector3 vecB;
Vector3 vecC;
foreach (Polygon2D polygon in polygons)
{
poly = polygon.ToWorldSpace(id.gameObject.transform);
Polygon2D convexHull = Polygon2D.GenerateShadow(new Polygon2D(poly.pointsList), sunDirection, id.height);
Mesh mesh = convexHull.CreateMesh(Vector2.zero, Vector2.zero);
for (int i = 0; i < mesh.triangles.GetLength(0); i = i + 3)
{
vecA = mesh.vertices [mesh.triangles [i]];
vecB = mesh.vertices [mesh.triangles [i + 1]];
vecC = mesh.vertices [mesh.triangles [i + 2]];
Max2DMatrix.DrawTriangle(vecA.x, vecA.y, vecB.x, vecB.y, vecC.x, vecC.y, offset, z);
}
}
}
GL.End();
GL.PopMatrix();
GL.PushMatrix();
// Null Check?
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;
}
if (id.colliderType == LightingCollider2D.ColliderType.Mesh)
{
continue;
}
List <Polygon2D> polygons = null;
switch (id.colliderType)
{
case LightingCollider2D.ColliderType.Collider:
polygons = id.GetColliderPolygons();
break;
case LightingCollider2D.ColliderType.SpriteCustomPhysicsShape:
polygons = id.GetShapePolygons();
break;
}
foreach (Polygon2D polygon in polygons)
{
Polygon2D poly = polygon.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();
#if UNITY_2018_1_OR_NEWER
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] == null)
{
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] == null)
{
DrawSoftShadowTileBlur(offset + new Vector2D(x, y), z, id.height);
}
}
}
}
GL.End();
GL.PopMatrix();
#endif
/*
*
* 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);
* } */
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.DrawImage(LightingManager2D.Get().additiveMaterial, new Vector2D(pos), new Vector2D(size), pos.z);
// Day Lighting Masking
foreach (LightingCollider2D id in LightingCollider2D.GetList())
{
if (id.generateDayMask == false)
{
continue;
}
switch (id.maskType)
{
case LightingCollider2D.MaskType.SpriteCustomPhysicsShape:
Max2D.SetColor(Color.white);
Max2D.DrawMesh(Max2D.defaultMaterial, id.GetShapeMesh(), id.transform, offset, z);
break;
case LightingCollider2D.MaskType.Collider:
Max2D.SetColor(Color.white);
Max2D.DrawMesh(Max2D.defaultMaterial, id.GetColliderMesh(), id.transform, offset, z);
break;
case LightingCollider2D.MaskType.Sprite:
if (id.spriteRenderer == null || id.spriteRenderer.sprite == null)
{
break;
}
Material material = LightingManager2D.Get().whiteSpriteMaterial;
material.mainTexture = id.spriteRenderer.sprite.texture;
Max2D.DrawSprite(material, id.spriteRenderer, new Vector2(id.transform.position.x, id.transform.position.y) + offset.ToVector2(), new Vector2(1, 1), id.transform.rotation.eulerAngles.z, z);
break;
}
}
}
// Visuals
//GameObject visualsGameObject;
//MeshFilter visualMeshFilter;
//MeshRenderer visualMeshRenderer;
public void Draw()
{
if (lineBorder && meshBorder.Count > 0)
{
if (meshBorder.Count > 0)
{
foreach (Mesh m in meshBorder)
{
RendererObject renderObject = GetFreeRenderObject();
renderObject.drawn = true;
renderObject.meshRenderer.sharedMaterial = GetBorderMaterial();
renderObject.meshFilter.sharedMesh = m;
renderObject.transform.position = Vector3.zero;
Vector3 lScale = renderObject.transform.parent.lossyScale;
lScale.x = 1f / lScale.x;
lScale.y = 1f / lScale.y;
lScale.z = 1f / lScale.z;
renderObject.transform.localScale = lScale;
}
}
}
if (mesh.Count > 0)
{
foreach (Mesh m in mesh)
{
RendererObject renderObject = GetFreeRenderObject();
renderObject.drawn = true;
renderObject.meshRenderer.sharedMaterial = GetFillMaterial();
renderObject.meshFilter.sharedMesh = m;
renderObject.transform.position = Vector3.zero;
Vector3 lScale = renderObject.transform.parent.lossyScale;
lScale.x = 1f / lScale.x;
lScale.y = 1f / lScale.y;
lScale.z = 1f / lScale.z;
renderObject.transform.localScale = lScale;
}
}
// Does not use Mesh Renderer Object
if (customEndingsPosition.Count > 0)
{
Matrix4x4 matrix;
foreach (Pair2 pair in customEndingsPosition)
{
Polygon2D polyA = Polygon2D.CreateFromRect(new Vector2(1, 1));
//polyA.ToOffset(pair.A);
Mesh mA = polyA.CreateMesh(new Vector2(2, 2), Vector2.zero);
matrix = Matrix4x4.TRS(pair.a.ToVector3(zPosition), Quaternion.Euler(0, 0, 0), new Vector3(1, 1, 1));
Graphics.DrawMesh(mA, matrix, customEndingImageMaterial, 0);
matrix = Matrix4x4.TRS(pair.b.ToVector3(zPosition), Quaternion.Euler(0, 0, 0), new Vector3(1, 1, 1));
Graphics.DrawMesh(mA, matrix, customEndingImageMaterial, 0);
}
}
}
