void Update()
{
Polygon2D polygonA = Polygon2DList.CreateFromGameObject(sliceableA)[0].ToWorldSpace(sliceableA.transform);
Polygon2D polygonB = Polygon2DList.CreateFromGameObject(sliceableB)[0].ToWorldSpace(sliceableB.transform);
Polygon2D MergedPolygon = Merge2D.Merge(polygonA, polygonB);
if (resultObject != null)
{
UnityEngine.Object.Destroy(resultObject);
}
if (MergedPolygon != null)
{
//UnityEngine.Object.Destroy(sliceableA.gameObject);
//UnityEngine.Object.Destroy(sliceableB.gameObject);
resultObject = new GameObject("Merged Polygon");
MergedPolygon.CreatePolygonCollider(resultObject);
Mesh2D mesh = resultObject.AddComponent <Mesh2D>();
mesh.material = OutputMaterial;
resultObject.AddComponent <ColliderLineRenderer2D>();
}
}
void Start()
{
bool addEvents = false;
foreach (Collider2D collider in anchorColliders)
{
addEvents = true;
}
if (addEvents == false)
{
return;
}
Destruction2D destruction = GetComponent <Destruction2D>();
foreach (Collider2D collider in anchorColliders)
{
if (collider == null)
{
continue;
}
destruction.anchorPolygons.Add(Polygon2DList.CreateFromGameObject(collider.gameObject)[0]);
destruction.anchorColliders.Add(collider);
}
Destruction2D destructionEvent = GetComponent <Destruction2D>();
destructionEvent.AddAnchorEvent(AnchorEvent);
}
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()
{
Slicer2D slicer = GetComponent <Slicer2D>();
slicer.AddResultEvent(SliceEvent);
//テキストオブジェクトの取得
g_ScoreTexObj = GameObject.Find("ScoreText");
//スプライトのa値を初期化
if (GetComponent <SpriteRenderer>())
{
GetComponent <SpriteRenderer>().color = new Color(1, 1, 1, 1);
}
//米の大きさを取得
if (currentSize == 0)
{
currentSize = Polygon2DList.CreateFromGameObject(gameObject)[0].ToWorldSpace(transform).GetArea();
//ここかえる
currentSizePercent = (float)System.Math.Round((currentSize / GameObject.Find("DataHolder").GetComponent <Data>().GetOriginalFishTailSize()) * 100);
}
Type = GameObject.Find("DataHolder").GetComponent <Data>().GetFishIcon();
}
void StartAnchor()
{
bool addEvents = false;
foreach (Collider2D collider in anchorsList)
{
if (collider != null)
{
addEvents = true;
}
}
if (addEvents == false)
{
return;
}
Slicer2D slicer = GetComponent <Slicer2D> ();
if (slicer != null)
{
slicer.AddResultEvent(OnAnchorSliceResult);
slicer.AddEvent(OnAnchorSlice);
}
foreach (Collider2D collider in anchorsList)
{
anchorPolygons.Add(Polygon2DList.CreateFromGameObject(collider.gameObject)[0]);
anchorColliders.Add(collider);
}
}
void Start()
{
if (originalSize == 0)
{
originalSize = Polygon2DList.CreateFromGameObject(gameObject)[0].ToWorldSpace(transform).GetArea();
}
}
List <double> SlicesSizesInDoubles()
{
List <double> slicesSizesInDoubles = new List <double>();
//foreach (Slicer2D slicer in Slicer2D.GetList())
/*foreach (Destruction2D slicer in Destruction2D.GetList())
* {
* //Polygon2D poly = slicer.GetPolygon().ToWorldSpace(slicer.transform);
* Polygon2D poly = slicer.GetBoundPolygon().ToWorldSpace(slicer.transform);
* double size = poly.GetArea(); //(int)poly.GetArea();
* // Debug.Log("current size : " + currentSizeInt);
* slicesSizesInDoubles.Add(size);
* }*/
List <Polygon2D> polygons = Polygon2DList.CreateFromGameObject(sliceableObjects.transform.GetChild(0).gameObject, Polygon2D.ColliderType.Polygon);
for (int i = 0; i < polygons.Count; i++)
{
//Debug.Log("polygon " + i + "area: " + polygons[i].GetArea());
double size = polygons[i].GetArea();
Debug.Log("size " + size);
if (size > negligibleSliceSize)
{
slicesSizesInDoubles.Add(polygons[i].GetArea());
}
}
return(slicesSizesInDoubles);
}
// Shape API
public Polygon2D GetLocal()
{
if (polygon == null)
{
polygon = Polygon2DList.CreateFromGameObject(slicer.gameObject)[0];
}
return(polygon);
}
public Mesh GetMesh()
{
if (mesh == null)
{
mesh = PolygonTriangulator2D.Triangulate(Polygon2DList.CreateFromGameObject(gameObject)[0], Vector2.zero, Vector2.zero, PolygonTriangulator2D.Triangulation.Advanced);
}
return(mesh);
}
public Polygon2D GetAIZone()
{
if (AIZonePolygon == null)
{
AIZonePolygon = Polygon2DList.CreateFromGameObject(AIZone)[0].ToWorldSpace(AIZone.transform);
}
return(AIZonePolygon);
}
// Shape API
public List <Polygon2D> GetLocal()
{
if (polygons == null)
{
polygons = Polygon2DList.CreateFromGameObject(destructible.gameObject);
}
return(polygons);
}
public Polygon2D GetPolygon()
{
if (polygon == null)
{
polygon = Polygon2DList.CreateFromGameObject(gameObject)[0];
}
return(polygon);
}
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();
}
void Start()
{
Polygon2D edge = Polygon2DList.CreateFromGameObject(gameObject)[0];
pair = Pair2D.GetList(edge.pointsList)[0];
timer = TimerHelper.Create();
}
void Start()
{
foreach (Slicer2D slicer in Slicer2D.GetList())
{
startingArea += Polygon2DList.CreateFromGameObject(slicer.gameObject)[0].ToWorldSpace(slicer.transform).GetArea();
}
instance = this;
}
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;
}
float spriteSheetU = (float)(texture.width) / sprite.rect.width;
float spriteSheetV = (float)(texture.height) / sprite.rect.height;
Rect rect = sprite.rect;
Rect uvRect = new Rect((float)rect.x / texture.width, (float)rect.y / texture.height, (float)rect.width / texture.width, (float)rect.height / texture.height);
Vector2 scale = new Vector2(spriteSheetU * rect.width / sprite.pixelsPerUnit, spriteSheetV * rect.height / spriteRenderer.sprite.pixelsPerUnit);
if (spriteRenderer.flipX)
{
scale.x = -scale.x;
}
if (spriteRenderer.flipY)
{
scale.y = -scale.y;
}
float pivotX = sprite.pivot.x / sprite.rect.width - 0.5f;
float pivotY = sprite.pivot.y / sprite.rect.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 = Polygon2DList.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;
}
void DrawOcclussion(Vector2 offset, float z)
{
// Collider Ambient Occlusion
GL.PushMatrix();
LightingManager2D.Get().occlusionEdgeMaterial.SetPass(0);
GL.Begin(GL.TRIANGLES);
foreach (LightingCollider2D id in LightingCollider2D.GetList())
{
if (id.ambientOcclusion == true)
{
// Do not call Create From Collider
Polygon2D poly = Polygon2DList.CreateFromGameObject(id.gameObject)[0];
poly = poly.ToWorldSpace(id.gameObject.transform);
foreach (DoublePair2D p in DoublePair2D.GetList(poly.pointsList))
{
Vector2D vA = new Vector2D(p.A.ToVector2() + offset);
Vector2D vB = new Vector2D(p.B.ToVector2() + offset);
Vector2D vC = new Vector2D(p.B.ToVector2() + offset);
Vector2D pA = new Vector2D(p.A.ToVector2() + offset);
Vector2D pB = new Vector2D(p.B.ToVector2() + offset);
vA.Push(Vector2D.Atan2(p.A, p.B) + Mathf.PI / 2, 1);
vB.Push(Vector2D.Atan2(p.A, p.B) + Mathf.PI / 2, 1);
vC.Push(Vector2D.Atan2(p.B, p.C) + Mathf.PI / 2, 1);
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();
}
// Recalculate area that is left
static public void UpdateLevelBar()
{
instance.leftArea = 0;
foreach (Slicer2D slicer in Slicer2D.GetList())
{
Polygon2D poly = Polygon2DList.CreateFromGameObject(slicer.gameObject)[0];
instance.leftArea += poly.ToWorldSpace(slicer.gameObject.transform).GetArea();
}
instance.leftArea = ((instance.leftArea) / instance.startingArea) * 100f;
}
void SliceEvent(Slice2D slice)
{
Vector2D midPoint = SliceMidPoint(slice.slices[0]);
foreach (Slicer2D g in Slicer2D.GetList())
{
Vector2D center = new Vector2D(Polygon2DList.CreateFromGameObject(g.gameObject)[0].ToWorldSpace(g.transform).GetBounds().center);
Vector2D position = new Vector2D(g.transform.position);
position.Push(Vector2D.Atan2(center, midPoint), 0.2f); // + Mathf.PI / 2
g.transform.position = position.ToVector2();
}
}
// Shape API
public Polygon2D GetLocal()
{
if (polygon == null)
{
List <Polygon2D> polygons = Polygon2DList.CreateFromGameObject(slicer.gameObject);
if (polygons.Count > 0)
{
polygon = polygons[0];
}
}
return(polygon);
}
static public void ExplodeInPoint(Slice2D slice, float forceAmount, Vector2D point)
{
foreach (GameObject gameObject in slice.GetGameObjects())
{
Rigidbody2D rigidBody2D = gameObject.GetComponent <Rigidbody2D> ();
if (rigidBody2D)
{
float sliceRotation = (float)Vector2D.Atan2(point, new Vector2D(gameObject.transform.position));
Rect rect = Polygon2DList.CreateFromGameObject(gameObject)[0].GetBounds();
Physics2DHelper.AddForceAtPosition(rigidBody2D, new Vector2(Mathf.Cos(sliceRotation) * forceAmount, Mathf.Sin(sliceRotation) * forceAmount), rect.center);
}
}
}
void Update()
{
if (Input.GetKeyDown(KeyCode.Space))
{
float timer = Time.realtimeSinceStartup;
Polygon2D poly = Polygon2DList.CreateFromGameObject(gameObject)[0].ToWorldSpace(transform);
Slicer2D.ComplexSliceAll(poly.pointsList, Slice2DLayer.Create());
Destroy(gameObject);
Debug.Log(name + " in " + (Time.realtimeSinceStartup - timer) * 1000 + "ms");
}
}
public void Slice()
{
float timer = Time.realtimeSinceStartup;
foreach (Transform t in transform)
{
Polygon2D poly = Polygon2DList.CreateFromGameObject(t.gameObject)[0].ToWorldSpace(t);
Slicer2D.ComplexSliceAll(poly.pointsList, Slice2DLayer.Create());
}
Destroy(gameObject);
Debug.Log(name + " in " + (Time.realtimeSinceStartup - timer) * 1000 + "ms");
}
public void Start()
{
polygons = Polygon2DList.CreateFromGameObject(gameObject);
Shader shaderAdditive = Shader.Find("Particles/Additive");
Shader shaderMultiply = Shader.Find("Particles/Multiply");
materialAdditive = new Material(shaderAdditive);
materialAdditive.color = Color.white;
materialAdditive.mainTexture = Resources.Load("Textures/Bevel") as Texture;
materialMultiply = new Material(shaderMultiply);
materialMultiply.color = Color.white;
materialMultiply.mainTexture = Resources.Load("Textures/Bevel") as Texture;
}
public List <Polygon2D> GetPolygons()
{
if (polygons == null)
{
polygons = Polygon2DList.CreateFromGameObject(gameObject);
if (polygons.Count > 0)
{
}
else
{
Debug.LogWarning("SmartLighting2D: LightingCollider2D object is missing Collider Component");
}
}
return(polygons);
}
// 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 = Polygon2DList.CreateFromGameObject(gameObject);
// Split collider if there are more polygons than 1
if (result.Count > 1)
{
PerformResult(result, new Slice2D());
}
MeshRenderer meshRenderer;
switch (textureType)
{
case TextureType.Mesh2D:
// Needs Mesh UV Options
GetPolygon().CreateMesh(gameObject, materialScale, materialOffset, 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;
}
}
public Mesh GetMesh()
{
if (mesh == null)
{
List <Polygon2D> polygons = Polygon2DList.CreateFromGameObject(gameObject);
if (polygons.Count > 0)
{
mesh = PolygonTriangulator2D.Triangulate(polygons[0], Vector2.zero, Vector2.zero, PolygonTriangulator2D.Triangulation.Advanced);
}
else
{
Debug.Log("SmartLighting2D: LightingRoom2D object is missing Collider Component");
}
}
return(mesh);
}
public Polygon2D GetPolygon()
{
if (polygon == null)
{
List <Polygon2D> polygons = Polygon2DList.CreateFromGameObject(gameObject);
if (polygons.Count > 0)
{
polygon = polygons[0];
}
else
{
Debug.LogWarning("SmartUtilities: CollideLineRenderer object is missing Collider Component");
}
}
return(polygon);
}
void Start()
{
Slicer2D slicer = GetComponent <Slicer2D>();
slicer.AddResultEvent(SliceEvent);
g_ScoreTexObj = GameObject.Find("ScoreText");
//モンスターの大きさを取得
if (currentSize == 0)
{
currentSize = Polygon2DList.CreateFromGameObject(gameObject)[0].ToWorldSpace(transform).GetArea();
currentSizePercent = (float)System.Math.Round((currentSize / GameObject.Find("DataHolder").GetComponent <Data>().GetOriginalTatleSize()) * 100);
}
Type = GameObject.Find("DataHolder").GetComponent <Data>().GetVegeIcon();
}
// After Slice - Get smallest polygon which does not have balls in it
GameObject GetCutGameObject(Slice2D sliceResult)
{
double area = 1e+10f;
GameObject CutObject = null;
foreach (GameObject resultObject in sliceResult.gameObjects)
{
Polygon2D poly = Polygon2DList.CreateFromGameObject(resultObject)[0];
if (poly.GetArea() < area && ThinSliceBall.PolygonHasBallsInside(poly.ToWorldSpace(resultObject.transform)) == false)
{
CutObject = resultObject;
area = poly.GetArea();
}
}
return(CutObject);
}
