public shatterTriangle(shatterVert v1, shatterVert v2, shatterVert v3, bool isSubstrateTri)
{
verts = new List <shatterVert>();
verts.Add(v1);
verts.Add(v2);
verts.Add(v3);
storedIntersects = new List <shatterVert>();
adjacent = new List <shatterTriangle>();
isSubstrate = isSubstrateTri;
norm = Vector3.Cross(v2.pos - v1.pos, v3.pos - v1.pos);
norm = Vector3.Normalize(norm);
up = Vector3.Cross(norm, Vector3.right);
if (Vector3.Magnitude(up) < largeEpsilon)
{
up = Vector3.Cross(norm, Vector3.up);
}
up = Vector3.Normalize(up);
right = Vector3.Cross(up, norm);
Vector2 ac = collapse(v2.pos - v1.pos);
Vector2 bd = collapse(v3.pos - v1.pos);
p02D = collapse(v1.pos);
a = ac[0];
b = bd[0];
c = ac[1];
d = bd[1];
det = 1 / (a * d - b * c);
area = getArea();
}
public shatterVert intersect(shatterVert l1V, shatterVert l2V)
{
Vector3 l1 = l1V.pos;
Vector3 l2 = l2V.pos;
Vector3 lv = l2 - l1;
Vector3 lo = l1 - verts[0].pos;
float loDist = Vector3.Dot(lo, norm);
float lvAlign = Vector3.Dot(lv, norm);
float travelT = -loDist / lvAlign;
float parallelMetric = Vector3.Dot(Vector3.Normalize(lo), norm);
if (travelT > 1 || travelT < 0 || Mathf.Abs(lvAlign) < largeEpsilon)
{
return(null);
}
Vector3 proj = l1 + lv * travelT;
Vector2 proj2 = collapse(proj) - p02D;
Vector2 bari = new Vector2(d * proj2[0] - b * proj2[1], a * proj2[1] - c * proj2[0]);
bari = det * bari;
float w = 1 - bari[0] - bari[1];
if (bari[0] < -epsilon || bari[1] < -epsilon || w < -epsilon)
{
return(null);
}
Vector2 UV = verts[2].uv * bari[0] + verts[1].uv * bari[1] + verts[0].uv * w;
shatterVert res = new shatterVert(proj, UV);
res.projenitorEdges.Add(l1V);
res.projenitorEdges.Add(l2V);
return(res);
}
public bool raycastExternalCheck(shatterTriangle toMeasure, int stopCheck = -1)
{
Vector3 tPos = (toMeasure.verts[0].pos + toMeasure.verts[1].pos + toMeasure.verts[2].pos) / 3;
int intersects = 0;
List <shatterVert> ignores = new List <shatterVert>();
shatterVert infinity = new shatterVert(new Vector3(99999, 99999, 99999), new Vector2(0, 0));
shatterVert toMeasureVert = new shatterVert(tPos, new Vector2(0, 0));
if (stopCheck < 0)
{
stopCheck = triangles.Count;
}
for (int i = 0; i < stopCheck; i++)
{
shatterTriangle tri = triangles[i];
shatterVert found = tri.intersect(toMeasureVert, infinity);
if (found != null && Vector3.Magnitude(found.pos - tPos) < epsilon)
{
return(false);
}
if (found != null && Vector3.Dot(found.pos - tPos, new Vector3(1, 1, 1)) > 0 && getDuplicate(found.pos, ignores) == -1)
{
intersects += 1;
ignores.Add(found);
//Debug.Log(found.pos);
}
}
return(intersects % 2 == 0);
}
public shatterVert(shatterVert other)
{
pos = other.pos;
uv = other.uv;
faces = new List <shatterTriangle>();
excludeEdges = new List <shatterVert>();
projenitorEdges = new List <shatterVert>();
}
public shatterEdge(shatterVert v1, shatterVert v2)
{
verts = new List <shatterVert>();
verts.Add(v1);
verts.Add(v2);
/*if (v1.generatorEdge != null && v2.generatorEdge != null){
* if (v1.generatorEdge.faces.Contains)
* }*/
}
public void absorb(shatterVert other)
{
/*if (other.excludeEdges.Count != 0){
* Debug.Log(other.excludeEdges.Count);
* Debug.Log(other == this);
* }*/
pos = (pos + other.pos) / 2.0f;
if (other.intersectTunnel != null && intersectTunnel == null)
{
intersectTunnel = other.intersectTunnel;
intersectTunnel.intersectTunnel = this;
}
}
private void repairTri1(shatterTriangle triangle, shatterVert inter)
{
for (int i = 0; i < 3; i++)
{
if (nonLinear(triangle.verts[i].pos, triangle.verts[(i + 1) % 3].pos, inter.pos))
{
shatterTriangle newTri = new shatterTriangle(triangle.verts[i], triangle.verts[(i + 1) % 3], inter, triangle.isSubstrate);
newTri.storedIntersects = triangle.storedIntersects;
triangles.Add(newTri);
}
}
triangle.cull();
}
private void cutTri(shatterTriangle tri, shatterTriangle other)
{
float parallelMetric = Vector3.Dot(tri.norm, other.norm);
if (parallelMetric > 1 - epsilon || parallelMetric < epsilon - 1)
{
return;
}
List <shatterVert> intersects = new List <shatterVert>();
for (int i = 0; i < 3; i++)
{
shatterVert intersect = tri.intersect(other.verts[i], other.verts[(i + 1) % 3]);
if (intersect != null && getDuplicate(intersect.pos, intersects) == -1)
{
int dup = getDuplicate(intersect.pos, tri.storedIntersects);
if (dup != -1)
{
tri.storedIntersects[dup].absorb(intersect);
intersect = tri.storedIntersects[dup];
}
intersects.Add(intersect);
other.storedIntersects.Add(other.portIn(intersect));
}
shatterVert intersectOther = other.intersect(tri.verts[i], tri.verts[(i + 1) % 3]);
if (intersectOther != null && getDuplicate(intersectOther.pos, intersects) == -1)
{
shatterVert intersectThis = null;
int dup = getDuplicate(intersectOther.pos, tri.storedIntersects);
if (dup != -1)
{
tri.storedIntersects[dup].absorb(intersectOther);
intersectThis = tri.storedIntersects[dup];
}
else
{
intersectThis = tri.portIn(intersectOther);
}
intersects.Add(intersectThis);
other.storedIntersects.Add(intersectOther);
}
}
if (intersects.Count != 0)
{
repairTri(tri, intersects);
}
}
public shatterVert portIn(shatterVert v)
{
Vector2 proj2 = collapse(v.pos) - p02D;
Vector2 bari = new Vector2(d * proj2[0] - b * proj2[1], a * proj2[1] - c * proj2[0]);
bari = det * bari;
float w = 1 - bari[0] - bari[1];
Vector2 UV = verts[2].uv * bari[0] + verts[1].uv * bari[1] + verts[0].uv * w;
shatterVert ported = new shatterVert(v.pos, UV);
ported.intersectTunnel = v;
v.intersectTunnel = ported;
ported.intersectTunnel = v;
ported.projenitorEdges = v.projenitorEdges;
return(ported);
}
private void considerConnection(shatterTriangle t, shatterVert v)
{
if (!adjacent.Contains(t))
{
int seenIndex = seenOnce.IndexOf(t);
if (seenIndex != -1)
{
if (!(seenOnceVerts[seenIndex].excludeEdges.Contains(v) || v.excludeEdges.Contains(seenOnceVerts[seenIndex])))
{
adjacent.Add(t);
t.adjacent.Add(this);
}
}
else
{
seenOnce.Add(t);
seenOnceVerts.Add(v);
}
}
}
