public void ConfineToAxisSpace(MentalMath.AxisSpace space)
{
switch (space)
{
case MentalMath.AxisSpace.XY:
for (int i = 0; i < this.nodes.Count; i++)
{
this.nodes[i].Position = new Vector3(this.nodes[i].Position.x, this.nodes[i].Position.y, 0f);
this.nodes[i].BackwardTangent = new Vector3(this.nodes[i].BackwardTangent.x, this.nodes[i].BackwardTangent.y, 0f);
this.nodes[i].ForwardTangent = new Vector3(this.nodes[i].ForwardTangent.x, this.nodes[i].ForwardTangent.y, 0f);
}
break;
case MentalMath.AxisSpace.XZ:
for (int j = 0; j < this.nodes.Count; j++)
{
this.nodes[j].Position = new Vector3(this.nodes[j].Position.x, 0f, this.nodes[j].Position.z);
this.nodes[j].BackwardTangent = new Vector3(this.nodes[j].BackwardTangent.x, 0f, this.nodes[j].Position.z);
this.nodes[j].ForwardTangent = new Vector3(this.nodes[j].ForwardTangent.x, 0f, this.nodes[j].Position.z);
}
break;
case MentalMath.AxisSpace.YZ:
for (int k = 0; k < this.nodes.Count; k++)
{
this.nodes[k].Position = new Vector3(0f, this.nodes[k].Position.y, this.nodes[k].Position.z);
this.nodes[k].BackwardTangent = new Vector3(0f, this.nodes[k].BackwardTangent.y, this.nodes[k].Position.z);
this.nodes[k].ForwardTangent = new Vector3(0f, this.nodes[k].ForwardTangent.y, this.nodes[k].Position.z);
}
break;
}
}
public static Vector3 GetCounterClockwiseNormal(Vector3 tangent, MentalMath.AxisSpace space)
{
Vector3 vector = Vector3.zero;
Vector3 rhs = Vector3.zero;
switch (space)
{
case MentalMath.AxisSpace.XY:
{
rhs = Vector3.back;
Vector3 vector2 = new Vector3(-tangent.y, tangent.x, 0f);
vector = vector2.normalized;
break;
}
case MentalMath.AxisSpace.XZ:
rhs = Vector3.up;
vector = Vector3.Cross(tangent, rhs);
break;
case MentalMath.AxisSpace.YZ:
rhs = Vector3.right;
vector = Vector3.Cross(tangent, rhs);
break;
}
return(vector.normalized);
}
public static Vector3 GetClockwiseNormal(Vector3 tangent, MentalMath.AxisSpace space)
{
Vector3 vector = Vector3.zero;
Vector3 rhs = Vector3.zero;
switch (space)
{
case MentalMath.AxisSpace.XY:
rhs = Vector3.forward;
vector = Vector3.Cross(tangent, rhs);
break;
case MentalMath.AxisSpace.XZ:
rhs = Vector3.down;
vector = Vector3.Cross(tangent, rhs);
break;
case MentalMath.AxisSpace.YZ:
rhs = Vector3.left;
vector = Vector3.Cross(tangent, rhs);
break;
}
return(vector.normalized);
}
public static bool PointInTriangle(Vector3 p, Vector3 p0, Vector3 p1, Vector3 p2, MentalMath.AxisSpace space)
{
double num = 0.0;
double num2 = 0.0;
double num3 = 0.0;
switch (space)
{
case MentalMath.AxisSpace.XY:
num = (double)(p0.y * p2.x - p0.x * p2.y + (p2.y - p0.y) * p.x + (p0.x - p2.x) * p.y);
num2 = (double)(p0.x * p1.y - p0.y * p1.x + (p0.y - p1.y) * p.x + (p1.x - p0.x) * p.y);
if (num < 0.0 != num2 < 0.0)
{
return(false);
}
num3 = (double)(-(double)p1.y * p2.x + p0.y * (p2.x - p1.x) + p0.x * (p1.y - p2.y) + p1.x * p2.y);
if (num3 < 0.0)
{
num = -num;
num2 = -num2;
num3 = -num3;
}
break;
case MentalMath.AxisSpace.XZ:
num = (double)(p0.z * p2.x - p0.x * p2.z + (p2.z - p0.z) * p.x + (p0.x - p2.x) * p.z);
num2 = (double)(p0.x * p1.z - p0.z * p1.x + (p0.z - p1.z) * p.x + (p1.x - p0.x) * p.z);
if (num < 0.0 != num2 < 0.0)
{
return(false);
}
num3 = (double)(-(double)p1.z * p2.x + p0.z * (p2.x - p1.x) + p0.x * (p1.z - p2.z) + p1.x * p2.z);
if (num3 < 0.0)
{
num = -num;
num2 = -num2;
num3 = -num3;
}
break;
case MentalMath.AxisSpace.YZ:
num = (double)(p0.z * p2.y - p0.y * p2.z + (p2.z - p0.z) * p.y + (p0.y - p2.y) * p.z);
num2 = (double)(p0.y * p1.z - p0.z * p1.y + (p0.z - p1.z) * p.y + (p1.y - p0.y) * p.z);
if (num < 0.0 != num2 < 0.0)
{
return(false);
}
num3 = (double)(-(double)p1.z * p2.y + p0.z * (p2.y - p1.y) + p0.y * (p1.z - p2.z) + p1.y * p2.z);
if (num3 < 0.0)
{
num = -num;
num2 = -num2;
num3 = -num3;
}
break;
}
return(num > 0.0 && num2 > 0.0 && num + num2 < num3);
}
public static GameObject CreateMeshFromPolygon(List <Vector3> vertices, Transform transform, MentalMath.AxisSpace space, bool debugMode = false)
{
MeshTool.MeshObject meshObject = MeshTool.InitTransformForMesh(transform);
if (debugMode)
{
for (int i = 0; i < vertices.Count; i++)
{
}
}
List <Vector2> list = new List <Vector2>();
for (int j = 0; j < vertices.Count; j++)
{
list.Add(new Vector2(vertices[j].x, vertices[j].y));
}
List <int> list2 = new List <int>();
bool[] array = new bool[vertices.Count];
for (int k = 0; k < array.Length; k++)
{
array[k] = true;
}
int num = 0;
int num2 = 1;
int num3 = 2;
int l = vertices.Count;
int num4 = l * 10;
while (l > 0)
{
num4--;
if (num4 < 0)
{
break;
}
bool flag = true;
for (int m = 0; m < vertices.Count; m++)
{
if (num != m && num2 != m && num3 != m)
{
if (MentalMath.PointInTriangle(vertices[m], vertices[num], vertices[num2], vertices[num3], MentalMath.AxisSpace.XY))
{
flag = false;
break;
}
}
}
if (flag)
{
Vector3 a = vertices[num2] - vertices[num];
Vector3 tangent = a + (vertices[num3] - vertices[num2]);
Vector3 counterClockwiseNormal = MentalMath.GetCounterClockwiseNormal(tangent, space);
float num5 = Vector3.Angle(-a, counterClockwiseNormal);
flag = (num5 > 90f);
}
if (!flag)
{
num = num2;
num2 = num3;
}
else
{
if (debugMode)
{
Vector3 vector = transform.position + Vector3.up * 3f;
}
list2.Add(num);
list2.Add(num2);
list2.Add(num3);
l--;
if (l <= 2)
{
if (debugMode)
{
}
break;
}
array[num2] = false;
num2 = num3;
}
int num6 = num2;
int num7 = vertices.Count;
while (num2 == num3)
{
num7--;
if (num7 < 0)
{
break;
}
num6++;
if (num6 >= vertices.Count)
{
num6 = 0;
}
if (array[num6] && num != num6 && num2 != num6)
{
if (debugMode)
{
}
num3 = num6;
break;
}
}
}
if (!debugMode)
{
Mesh mesh = new Mesh();
mesh.name = transform.name;
mesh.vertices = vertices.ToArray();
mesh.uv = list.ToArray();
mesh.triangles = list2.ToArray();
mesh.RecalculateNormals();
meshObject.mf.sharedMesh = mesh;
}
return(meshObject.parent);
}
public static GameObject CreateMeshFromBezier(BezierCurve bezierCurve, Transform transform, MentalMath.AxisSpace space, bool debugMode = false)
{
if (bezierCurve == null || bezierCurve.Curve == null || bezierCurve.Curve.Count == 0)
{
return(null);
}
List <Vector3> list = new List <Vector3>();
int bezierPointCount = bezierCurve.bezierPointCount;
for (int i = 1; i <= bezierPointCount; i++)
{
list.Add(bezierCurve.Curve.GetPoint((float)i / (float)bezierPointCount, true, Vector3.zero));
}
if (list.Count <= 0)
{
return(null);
}
return(MeshTool.CreateMeshFromPolygon(list, transform, space, debugMode));
}
public static GameObject CreateMeshStripFromBezier(BezierCurve bezierCurve, Transform transform, MentalMath.AxisSpace space, float stripWidth, bool debugMode = false)
{
List <Vector3> list = new List <Vector3>();
int bezierPointCount = bezierCurve.bezierPointCount;
Vector3 vector = bezierCurve.Curve.GetPoint(0f, false);
Vector3 vector2 = bezierCurve.Curve.GetPoint(1f / (float)bezierPointCount, bezierCurve.loop);
Vector3 vector3 = vector2;
Vector3 a = vector2 - vector;
Vector3 tangent = a + (vector3 - vector2);
Vector3 counterClockwiseNormal = MentalMath.GetCounterClockwiseNormal(tangent, space);
list.Add(vector + counterClockwiseNormal * stripWidth);
list.Add(vector - counterClockwiseNormal * stripWidth);
for (int i = 1; i <= bezierPointCount; i++)
{
if (i == bezierPointCount && bezierCurve.loop)
{
list.Add(list[0]);
list.Add(list[1]);
}
else
{
float ct = (float)(i + 1) / (float)bezierPointCount;
vector3 = bezierCurve.Curve.GetPoint(ct, bezierCurve.loop);
a = vector2 - vector;
tangent = a + (vector3 - vector2);
counterClockwiseNormal = MentalMath.GetCounterClockwiseNormal(tangent, space);
list.Add(vector2 + counterClockwiseNormal * stripWidth);
list.Add(vector2 - counterClockwiseNormal * stripWidth);
vector = vector2;
vector2 = vector3;
}
}
return(MeshTool.CreateMeshStrip(list, transform, debugMode));
}
