void Profiler()
{
EditorGUILayout.HelpBox("Advanced Triangulation: " + Slicer2DProfiler.GetAdvancedTriangulation(), MessageType.None);
EditorGUILayout.HelpBox("Legacy Triangulation: " + Slicer2DProfiler.GetLegacyTriangulation(), MessageType.None);
EditorGUILayout.HelpBox("Batched Objects: " + Slicer2DProfiler.GetBatchingApplied(), MessageType.None);
EditorGUILayout.HelpBox("Objects Created: " + Slicer2DProfiler.GetObjectsCreated(), MessageType.None);
EditorGUILayout.HelpBox("Objects Slices Created With Performance: " + Slicer2DProfiler.GetSlicesCreatedWithPeroformance(), MessageType.None);
EditorGUILayout.HelpBox("Objects Slices Created With Quality: " + Slicer2DProfiler.GetSlicesCreatedWithQuality(), MessageType.None);
}
public static Mesh Triangulate(Polygon2D polygon, Vector2 UVScale, Vector2 UVOffset, Triangulation triangulation)
{
polygon.Normalize();
Mesh result = null;
switch (triangulation)
{
case Triangulation.Advanced:
Slicer2DProfiler.IncAdvancedTriangulation();
float GC = Slicer2DSettings.GetGarbageCollector();
if (GC > 0 & polygon.GetArea() < GC)
{
Debug.LogWarning("SmartUtilities2D: Garbage Collector Removed Object Because it was too small");
return(null);
}
Polygon2D newPolygon = new Polygon2D(PreparePolygon.Get(polygon));
if (newPolygon.pointsList.Count < 3)
{
Debug.LogWarning("SmartUtilities2D: Mesh is too small for advanced triangulation, using simplified triangulations instead (size: " + polygon.GetArea() + ")");
result = PerformTriangulation(polygon, UVScale, UVOffset);
return(result);
}
foreach (Polygon2D hole in polygon.holesList)
{
newPolygon.AddHole(new Polygon2D(PreparePolygon.Get(hole, -1)));
}
result = PerformTriangulation(newPolygon, UVScale, UVOffset);
break;
case Triangulation.Legacy:
Slicer2DProfiler.IncLegacyTriangulation();
List <Vector2> list = new List <Vector2>();
foreach (Vector2D p in polygon.pointsList)
{
list.Add(p.ToVector2());
}
result = Triangulator.Create(list.ToArray(), UVScale, UVOffset);
return(result);
}
return(result);
}
public void CreateMesh(GameObject gameObject, Polygon2D polygon)
{
polygon.CreateMesh(gameObject, scale, offset, GetTriangulation());
if (material)
{
MeshRenderer meshRenderer = gameObject.GetComponent <MeshRenderer> ();
if (Slicer2DSettings.GetBatching(batchMaterial))
{
Slicer2DProfiler.IncBatchingApplied();
meshRenderer.sharedMaterial = material;
}
else
{
meshRenderer.sharedMaterial = new Material(material);
}
}
}
public List <GameObject> PerformResult(List <Polygon2D> result, Slice2D slice)
{
List <GameObject> resultGameObjects = new List <GameObject> ();
if (result.Count < 1)
{
return(resultGameObjects);
}
slice.SetPolygons(result);
slice.originGameObject = gameObject;
if (eventHandler.SliceEvent(slice) == false)
{
return(resultGameObjects);
}
if (Slicer2DEventHandling.GlobalSliceEvent(slice) == false)
{
return(resultGameObjects);
}
double originArea = 1f;
if (recalculateMass)
{
originArea = shape.GetLocal().GetArea();
}
Rigidbody2D originalRigidBody = gameObject.GetComponent <Rigidbody2D>();
Collider2D collider2D = gameObject.GetComponent <Collider2D>();
PhysicsMaterial2D material = collider2D.sharedMaterial;
bool isTrigger = collider2D.isTrigger;
switch (Slicer2DSettings.GetComponentsCopy(instantiateMethod))
{
case InstantiationMethod.Performance:
switch (textureType)
{
case TextureType.Sprite:
case TextureType.Sprite3D:
if (spriteRendererComponent)
{
DestroyImmediate(spriteRendererComponent);
spriteRendererComponent = null;
}
break;
}
BoxCollider2D c1 = gameObject.GetComponent <BoxCollider2D>();
if (c1 != null)
{
DestroyImmediate(c1);
}
CircleCollider2D c2 = gameObject.GetComponent <CircleCollider2D>();
if (c2 != null)
{
DestroyImmediate(c2);
}
CapsuleCollider2D c3 = gameObject.GetComponent <CapsuleCollider2D>();
if (c3 != null)
{
DestroyImmediate(c3);
}
break;
}
int name_id = 1;
foreach (Polygon2D id in result)
{
GameObject gObject = null;
switch (Slicer2DSettings.GetComponentsCopy(instantiateMethod))
{
case InstantiationMethod.Performance:
Slicer2DProfiler.IncSlicesCreatedWithPerformance();
gObject = Instantiate(gameObject, transform.position, transform.rotation, transform.parent);
break;
case InstantiationMethod.Quality:
Slicer2DProfiler.IncSlicesCreatedWithQuality();
gObject = new GameObject();
gObject.transform.parent = transform.parent;
gObject.transform.position = transform.position;
gObject.transform.rotation = transform.rotation;
break;
}
gObject.name = name + " (" + name_id + ")";
gObject.transform.localScale = transform.localScale;
gObject.layer = gameObject.layer;
gObject.tag = gameObject.tag;
resultGameObjects.Add(gObject);
switch (Slicer2DSettings.GetComponentsCopy(instantiateMethod))
{
case InstantiationMethod.Quality:
Slicer2DComponents.Copy(this, gObject);
break;
}
Slicer2D slicer = gObject.GetComponent <Slicer2D> ();
//ここがPlay時に情報を書き込んでいるところ
slicer.limit = new Slicer2DLimit();
slicer.limit.counter = limit.counter + 1;
slicer.limit.maxSlices = limit.maxSlices;
slicer.limit.enabled = limit.enabled;
slicer.eventHandler = new Slicer2DEventHandling();
slicer.shape = new Slicer2DShape();
slicer.shape.SetSlicer2D(slicer);
slicer.shape.ForceUpdate();
slicer.materialSettings = materialSettings.Copy();
slicer.anchor = anchor.Copy();
Slicer2DComponents.CopyRigidbody2D(originalRigidBody, slicer, id, originArea);
if (Slicer2DSettings.GetCenterOfSliceTransform(centerOfSlice) == CenterOfSliceTransform.ColliderCenter)
{
Polygon2D localPoly = id.ToLocalSpace(gObject.transform);
Rect bounds = localPoly.GetBounds();
Vector2 center = bounds.center;
Vector2 centerWorld = new Vector2(center.x * transform.lossyScale.x, center.y * transform.lossyScale.y);
gObject.transform.Translate(centerWorld);
slicer.materialSettings.offset += center;
}
Collider2D collider = null;
switch (colliderType)
{
case ColliderType.PolygonCollider2D:
collider = (Collider2D)id.ToLocalSpace(gObject.transform).CreatePolygonCollider(gObject);
break;
case ColliderType.EdgeCollider2D:
collider = (Collider2D)id.ToLocalSpace(gObject.transform).CreateEdgeCollider(gObject);
break;
}
collider.sharedMaterial = material;
collider.isTrigger = isTrigger;
Vector2D uvOffset;
switch (textureType)
{
case TextureType.Sprite:
slicer.spriteRenderer = spriteRenderer;
uvOffset = new Vector2D(slicer.materialSettings.offset);
Polygon2D.SpriteToMesh(gObject, spriteRenderer, materialSettings.GetTriangulation(), uvOffset);
break;
case TextureType.Sprite3D:
slicer.spriteRenderer = spriteRenderer;
uvOffset = new Vector2D(slicer.materialSettings.offset);
Polygon2D.SpriteToMesh3D(gObject, spriteRenderer, materialSettings.depth, materialSettings.GetTriangulation(), uvOffset);
MeshRenderer meshRenderer = slicer.GetComponent <MeshRenderer>();
Material[] sharedMaterials = new Material[2];
sharedMaterials[1] = spriteRenderer.material;
sharedMaterials[0] = materialSettings.sideMaterial;
meshRenderer.sharedMaterials = sharedMaterials;
break;
case TextureType.SpriteAnimation:
slicer.textureType = TextureType.Sprite;
Polygon2D.SpriteToMesh(gObject, spriteRenderer, materialSettings.GetTriangulation());
break;
default:
break;
}
name_id += 1;
}
if (afterSliceRemoveOrigin)
{
Destroy(gameObject);
}
if (resultGameObjects.Count > 0)
{
slice.originGameObject = gameObject;
slice.SetGameObjects(resultGameObjects);
if (supportJoints == true)
{
SliceJointEvent(slice);
}
eventHandler.Result(slice);
}
return(resultGameObjects);
}
// ANCHOR!!!!!!! ////////////////////
////////////////////////
void Awake()
{
Slicer2DProfiler.IncObjectsCreated();
shape.SetSlicer2D(this);
}
public static Mesh Triangulate3D(Polygon2D polygon, float z, Vector2 UVScale, Vector2 UVOffset, Triangulation triangulation)
{
Mesh result = null;
switch (triangulation)
{
case Triangulation.Advanced:
Slicer2DProfiler.IncAdvancedTriangulation();
Polygon2D newPolygon = polygon;
List <Vector3> sideVertices = new List <Vector3>();
List <int> sideTriangles = new List <int>();
int vCount = 0;
foreach (Pair2D pair in Pair2D.GetList(polygon.pointsList))
{
Vector3 pointA = new Vector3((float)pair.A.x, (float)pair.A.y, 0);
Vector3 pointB = new Vector3((float)pair.B.x, (float)pair.B.y, 0);
Vector3 pointC = new Vector3((float)pair.B.x, (float)pair.B.y, 1);
Vector3 pointD = new Vector3((float)pair.A.x, (float)pair.A.y, 1);
sideVertices.Add(pointA);
sideVertices.Add(pointB);
sideVertices.Add(pointC);
sideVertices.Add(pointD);
sideTriangles.Add(vCount + 2);
sideTriangles.Add(vCount + 1);
sideTriangles.Add(vCount + 0);
sideTriangles.Add(vCount + 0);
sideTriangles.Add(vCount + 3);
sideTriangles.Add(vCount + 2);
vCount += 4;
}
Mesh meshA = PerformTriangulation(newPolygon, UVScale, UVOffset);
Mesh meshB = new Mesh();
List <Vector3> verticesB = new List <Vector3>();
foreach (Vector3 v in meshA.vertices)
{
verticesB.Add(new Vector3(v.x, v.y, v.z + z));
}
meshB.vertices = verticesB.ToArray();
meshB.triangles = meshA.triangles.Reverse().ToArray();
Mesh mesh = new Mesh();
mesh.SetVertices(sideVertices);
mesh.SetTriangles(sideTriangles, 0);
List <Vector3> vertices = new List <Vector3>();
foreach (Vector3 v in meshA.vertices)
{
vertices.Add(v);
}
foreach (Vector3 v in meshB.vertices)
{
vertices.Add(v);
}
foreach (Vector3 v in sideVertices)
{
vertices.Add(v);
}
mesh.vertices = vertices.ToArray();
List <int> triangles = new List <int>();
foreach (int p in meshA.triangles)
{
triangles.Add(p);
}
int count = meshA.vertices.Count();
foreach (int p in meshB.triangles)
{
triangles.Add(p + count);
}
count = meshA.vertices.Count() + meshB.vertices.Count();
foreach (int p in sideTriangles)
{
triangles.Add(p + count);
}
mesh.triangles = triangles.ToArray();
mesh.RecalculateNormals();
mesh.RecalculateBounds();
result = mesh;
break;
}
return(result);
}
