public static bool lineIntersect3D(Vector3 linea1, Vector3 linea2, Vector3 lineb1, Vector3 lineb2, ref Vector3 ip, float tol)
{
Vector3 da = linea2 - linea1;
Vector3 db = lineb2 - lineb1;
Vector3 dc = lineb1 - linea1;
Vector3 dadbcross = Vector3.Cross(da, db);
float dotTol = Vector3.Dot(dc, dadbcross);
//Debug.Log(dotTol);
float toln = tol * 100;
if (!NearestPointTest.valueWithinRange(-toln, toln, dotTol))
{
return(false);
}
float s = Vector3.Dot(Vector3.Cross(dc, db), dadbcross) / dadbcross.sqrMagnitude;
if (s >= 0.0f && s <= 1.0f)
{
Vector3 mp = da * s;
ip = linea1 + mp;
return(true);
}
return(false);
}
public static Vector3 NearestPointOnMesh(Vector3 pt, Vector3[] verts, int[] tri, VertTriList vt)
{
int num = -1;
float num2 = 1E+08f;
for (int i = 0; i < verts.Length; i++)
{
float sqrMagnitude = (verts[i] - pt).sqrMagnitude;
bool flag = sqrMagnitude >= num2;
if (!flag)
{
num = i;
num2 = sqrMagnitude;
}
}
bool flag2 = num == -1;
Vector3 result;
if (flag2)
{
result = Vector3.zero;
}
else
{
int[] array = vt[num];
Vector3 vector = Vector3.zero;
num2 = 1E+08f;
for (int j = 0; j < array.Length; j++)
{
int num3 = array[j] * 3;
Vector3 vector2 = verts[tri[num3]];
Vector3 vector3 = verts[tri[num3 + 1]];
Vector3 vector4 = verts[tri[num3 + 2]];
Vector3 vector5 = NearestPointTest.NearestPointOnTri(pt, vector2, vector3, vector4);
float sqrMagnitude2 = (pt - vector5).sqrMagnitude;
bool flag3 = sqrMagnitude2 >= num2;
if (!flag3)
{
vector = vector5;
num2 = sqrMagnitude2;
}
}
result = vector;
}
return(result);
}
// To do falloff we need connected verts to each vert then just need to do recursive check until none effected
void DeformMesh()
{
for (int i = 0; i < verts.Length; i++)
{
Vector3 p = verts[i]; // + offsets[i];
Vector3 origin = transform.TransformPoint(p);
if (col.bounds.Contains(origin))
{
// Point in collider space
Vector3 lp = col.transform.worldToLocalMatrix.MultiplyPoint(origin);
Vector3 np = NearestPointTest.NearestPointOnMesh(lp, colmesh.verts, colmesh.tris, colmesh.trilist);
float dist = Vector3.Distance(lp, np);
Debug.Log("[" + i + "] = " + dist.ToString("0.00000")); //np " + np);
}
sverts[i] = verts[i];
}
}
public static void ConvexHull2DTriangulated(List <Vector3> pt, List <Vector3> tri, ref Vector3 norm)
{
NearestPointTest.triangulate(pt, tri, norm);
/*opt.Clear();
*
* ConvexHull2D(pt, opt, ref norm);
*
* if (opt.Count < 3) {
* return;
* }
*
* Vector3 line1 = pt[0];
*
* int count = pt.Count - 1;
*
* for (int i = 1; i < count; i++) {
* tri.Add(line1);
* tri.Add(pt[i]);
* tri.Add(pt[i + 1]);
* }*/
}
public void updateMesh()
{
vertexPoints.Clear();
indexPoints.Clear();
uvPoints.Clear();
oobb.update(gameObject);
Vector3 dirUp = gameObject.transform.TransformDirection(Vector3.up);
Vector3 dirUpPos = gameObject.transform.position - (dirUp * gameObject.transform.localScale.y);
Vector3 dirDown = gameObject.transform.TransformDirection(Vector3.down);
Vector3 dirDownPos = gameObject.transform.position - (dirDown * gameObject.transform.localScale.y);
Vector3 dirForward = gameObject.transform.TransformDirection(Vector3.forward);
Vector3 dirForwardPos = gameObject.transform.position - (dirForward * gameObject.transform.localScale.z);
Vector3 dirBack = gameObject.transform.TransformDirection(Vector3.back);
Vector3 dirBackPos = gameObject.transform.position - (dirBack * gameObject.transform.localScale.z);
Vector3 dirLeft = gameObject.transform.TransformDirection(Vector3.left);
Vector3 dirLeftPos = gameObject.transform.position - (dirLeft * gameObject.transform.localScale.x);
Vector3 dirRight = gameObject.transform.TransformDirection(Vector3.right);
Vector3 dirRightPos = gameObject.transform.position - (dirRight * gameObject.transform.localScale.x);
yPosPlane.SetValues(dirUp, dirUpPos);
yNegPlane.SetValues(dirDown, dirDownPos);
zPosPlane.SetValues(dirForward, dirForwardPos);
zNegPlane.SetValues(dirBack, dirBackPos);
xPosPlane.SetValues(dirLeft, dirLeftPos);
xNegPlane.SetValues(dirRight, dirRightPos);
if (data != null)
{
List <TriangleData> tris = data.getTrianglesInOOBB(oobb);
//Debug.Log(tris.Count);
Vector3 lineInt = new Vector3();
for (int i = 0; i < tris.Count; i++)
{
Vector3[] pts = tris[i].getTransformedPoints();
Vector3 point1 = pts[0];
Vector3 point2 = pts[1];
Vector3 point3 = pts[2];
Vector3 n = Vector3.Cross(point2 - point1, point3 - point1);
n.Normalize();
points.Clear();
newTris.Clear();
lpoints.Clear();
if (TriangleTests.IntersectLineTriangle(ref oobb.oobbCoordsTrans[0], ref oobb.oobbCoordsTrans[1], ref point1, ref point2, ref point3, ref lineInt))
{
lpoints.Add(lineInt);
}
if (TriangleTests.IntersectLineTriangle(ref oobb.oobbCoordsTrans[0], ref oobb.oobbCoordsTrans[2], ref point1, ref point2, ref point3, ref lineInt))
{
lpoints.Add(lineInt);
}
if (TriangleTests.IntersectLineTriangle(ref oobb.oobbCoordsTrans[0], ref oobb.oobbCoordsTrans[4], ref point1, ref point2, ref point3, ref lineInt))
{
lpoints.Add(lineInt);
}
if (TriangleTests.IntersectLineTriangle(ref oobb.oobbCoordsTrans[1], ref oobb.oobbCoordsTrans[3], ref point1, ref point2, ref point3, ref lineInt))
{
lpoints.Add(lineInt);
}
if (TriangleTests.IntersectLineTriangle(ref oobb.oobbCoordsTrans[1], ref oobb.oobbCoordsTrans[5], ref point1, ref point2, ref point3, ref lineInt))
{
lpoints.Add(lineInt);
}
if (TriangleTests.IntersectLineTriangle(ref oobb.oobbCoordsTrans[2], ref oobb.oobbCoordsTrans[6], ref point1, ref point2, ref point3, ref lineInt))
{
lpoints.Add(lineInt);
}
if (TriangleTests.IntersectLineTriangle(ref oobb.oobbCoordsTrans[2], ref oobb.oobbCoordsTrans[3], ref point1, ref point2, ref point3, ref lineInt))
{
lpoints.Add(lineInt);
}
if (TriangleTests.IntersectLineTriangle(ref oobb.oobbCoordsTrans[3], ref oobb.oobbCoordsTrans[7], ref point1, ref point2, ref point3, ref lineInt))
{
lpoints.Add(lineInt);
}
if (TriangleTests.IntersectLineTriangle(ref oobb.oobbCoordsTrans[4], ref oobb.oobbCoordsTrans[5], ref point1, ref point2, ref point3, ref lineInt))
{
lpoints.Add(lineInt);
}
if (TriangleTests.IntersectLineTriangle(ref oobb.oobbCoordsTrans[4], ref oobb.oobbCoordsTrans[6], ref point1, ref point2, ref point3, ref lineInt))
{
lpoints.Add(lineInt);
}
if (TriangleTests.IntersectLineTriangle(ref oobb.oobbCoordsTrans[5], ref oobb.oobbCoordsTrans[7], ref point1, ref point2, ref point3, ref lineInt))
{
lpoints.Add(lineInt);
}
if (TriangleTests.IntersectLineTriangle(ref oobb.oobbCoordsTrans[6], ref oobb.oobbCoordsTrans[7], ref point1, ref point2, ref point3, ref lineInt))
{
lpoints.Add(lineInt);
}
NDPlane.IntersectSixPlanesTriangle(xPosPlane, xNegPlane, yPosPlane, yNegPlane, zPosPlane, zNegPlane, ref point1, ref point2, ref point3, lpoints);
NDPlane.SideOfSixPlanesFilter(xPosPlane, xNegPlane, yPosPlane, yNegPlane, zPosPlane, zNegPlane, lpoints, points);
HullTests.ConvexHull2DTriangulated(points, newTris, ref n);
for (int j = 0; j < newTris.Count; j += 3)
{
Vector3 v1 = newTris[j + 0];
Vector3 v2 = newTris[j + 1];
Vector3 v3 = newTris[j + 2];
float tolerance = layer * offset;
Vector3 dist = n * tolerance;
v1 = v1 + dist;
v2 = v2 + dist;
v3 = v3 + dist;
int vec1 = 0;
int vec2 = 0;
int vec3 = 0;
// point is new, compute new UV coordinates for it
if (!NearestPointTest.approxContains(vertexPoints, v1, tolerance, ref vec1))
{
Vector3 transVec = gameObject.transform.InverseTransformPoint(vertexPoints[vec1]);
if (!cubeMap)
{
uvPoints.Add(new Vector2((transVec.y + 1) / 2, (transVec.z + 1) / 2));
}
else
{
uvPoints.Add(HullTests.CubeMap3DV(ref transVec, ref n));
}
}
if (!NearestPointTest.approxContains(vertexPoints, v2, tolerance, ref vec2))
{
Vector3 transVec = gameObject.transform.InverseTransformPoint(vertexPoints[vec2]);
if (!cubeMap)
{
uvPoints.Add(new Vector2((transVec.y + 1) / 2, (transVec.z + 1) / 2));
}
else
{
uvPoints.Add(HullTests.CubeMap3DV(ref transVec, ref n));
}
}
if (!NearestPointTest.approxContains(vertexPoints, v3, tolerance, ref vec3))
{
Vector3 transVec = gameObject.transform.InverseTransformPoint(vertexPoints[vec3]);
if (!cubeMap)
{
uvPoints.Add(new Vector2((transVec.y + 1) / 2, (transVec.z + 1) / 2));
}
else
{
uvPoints.Add(HullTests.CubeMap3DV(ref transVec, ref n));
}
}
//Debug.Log(vertexPoints.Count + " " + vec1 + " " + vec2 + " " + vec3);
if (HullTests.IsTriClockwise(vertexPoints[vec1], vertexPoints[vec2], vertexPoints[vec3], n))
{
indexPoints.Add(vec1);
indexPoints.Add(vec2);
indexPoints.Add(vec3);
}
else
{
indexPoints.Add(vec1);
indexPoints.Add(vec3);
indexPoints.Add(vec2);
}
}
}
}
}
