public static Vector3 UnitCross(ref Vector3 vector, ref Vector3 value)
{
Vector3 result = new Vector3(vector.y * value.z - vector.z * value.y, vector.z * value.x - vector.x * value.z, vector.x * value.y - vector.y * value.x);
Vector3ex.Normalize(ref result, 1E-05f);
return(result);
}
public Circle3(Vector3 center, Vector3 normal, float radius)
{
this.Center = center;
this.Normal = normal;
Vector3ex.CreateOrthonormalBasis(out this.Axis0, out this.Axis1, ref this.Normal);
this.Radius = radius;
}
public static bool CreateInscribed(Vector3 v0, Vector3 v1, Vector3 v2, Vector3 v3, out Sphere3 sphere)
{
Vector3 vector = v1 - v0;
Vector3 vector2 = v2 - v0;
Vector3 vector3 = v3 - v0;
Vector3 value = v2 - v1;
Vector3 vector4 = v3 - v1;
Vector3 vector5 = vector4.Cross(value);
Vector3 vector6 = vector2.Cross(vector3);
Vector3 vector7 = vector3.Cross(vector);
Vector3 vector8 = vector.Cross(vector2);
if (Mathf.Abs(Vector3ex.Normalize(ref vector5, 1E-05f)) < 1E-05f)
{
sphere = default(Sphere3);
return(false);
}
if (Mathf.Abs(Vector3ex.Normalize(ref vector6, 1E-05f)) < 1E-05f)
{
sphere = default(Sphere3);
return(false);
}
if (Mathf.Abs(Vector3ex.Normalize(ref vector7, 1E-05f)) < 1E-05f)
{
sphere = default(Sphere3);
return(false);
}
if (Mathf.Abs(Vector3ex.Normalize(ref vector8, 1E-05f)) < 1E-05f)
{
sphere = default(Sphere3);
return(false);
}
float[,] array = new float[3, 3];
array[0, 0] = vector6.x - vector5.x;
array[0, 1] = vector6.y - vector5.y;
array[0, 2] = vector6.z - vector5.z;
array[1, 0] = vector7.x - vector5.x;
array[1, 1] = vector7.y - vector5.y;
array[1, 2] = vector7.z - vector5.z;
array[2, 0] = vector8.x - vector5.x;
array[2, 1] = vector8.y - vector5.y;
array[2, 2] = vector8.z - vector5.z;
float[,] a = array;
float[] b = new float[]
{
0f,
0f,
-vector8.Dot(vector3)
};
Vector3 vector9;
if (LinearSystem.Solve3(a, b, out vector9, 1E-05f))
{
sphere.Center = v3 + vector9;
sphere.Radius = Mathf.Abs(vector5.Dot(vector9));
return(true);
}
sphere = default(Sphere3);
return(false);
}
public void UpdateEdge(int edgeIndex)
{
Vector3 vector = (this._edges[edgeIndex].Point1 = this._vertices[(edgeIndex + 1) % this._vertices.Length]) - (this._edges[edgeIndex].Point0 = this._vertices[edgeIndex]);
this._edges[edgeIndex].Length = Vector3ex.Normalize(ref vector, 1E-05f);
this._edges[edgeIndex].Direction = vector;
this._edges[edgeIndex].Normal = this._plane.Normal.Cross(vector);
}
public void UpdateEdges()
{
int num = this._vertices.Length;
int num2 = num - 1;
for (int i = 0; i < num; i++)
{
Vector3 vector = (this._edges[num2].Point1 = this._vertices[i]) - (this._edges[num2].Point0 = this._vertices[num2]);
this._edges[num2].Length = Vector3ex.Normalize(ref vector, 1E-05f);
this._edges[num2].Direction = vector;
this._edges[num2].Normal = this._plane.Normal.Cross(vector);
num2 = i;
}
}
public static Rectangle3 CreateFromCWPoints(Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3)
{
Vector3 vector = p2 - p1;
Vector3 vector2 = p1 - p0;
Rectangle3 result;
result.Center = (p0 + p2) * 0.5f;
result.Extents.x = Vector3ex.Normalize(ref vector, 1E-05f) * 0.5f;
result.Extents.y = Vector3ex.Normalize(ref vector2, 1E-05f) * 0.5f;
result.Axis0 = vector;
result.Axis1 = vector2;
result.Normal = vector.Cross(vector2);
return(result);
}
public float AngleBetweenPlaneAndLine(Vector3 direction)
{
Vector3ex.Normalize(ref direction, 1E-05f);
float num = this.Normal.Dot(direction);
if (num > 1f)
{
num = 1f;
}
else if (num < -1f)
{
num = -1f;
}
return(1.57079637f - Mathf.Acos(num));
}
public static float AngleRad(this Vector3 vector, Vector3 target)
{
Vector3ex.Normalize(ref vector, 1E-05f);
Vector3ex.Normalize(ref target, 1E-05f);
float num = vector.x * target.x + vector.y * target.y + vector.z * target.z;
if (num > 1f)
{
num = 1f;
}
else if (num < -1f)
{
num = -1f;
}
return(Mathf.Acos(num));
}
public static void CalcBarycentricCoords(ref Vector3 point, ref Vector3 v0, ref Vector3 v1, ref Vector3 v2, out Vector3 baryCoords)
{
Vector3 vector = v1 - v0;
Vector3 vector2 = v2 - v0;
Vector3 vector3 = point - v0;
float num = Vector3ex.Dot(ref vector, ref vector);
float num2 = Vector3ex.Dot(ref vector, ref vector2);
float num3 = Vector3ex.Dot(ref vector2, ref vector2);
float num4 = Vector3ex.Dot(ref vector3, ref vector);
float num5 = Vector3ex.Dot(ref vector3, ref vector2);
float num6 = 1f / (num * num3 - num2 * num2);
baryCoords.y = (num3 * num4 - num2 * num5) * num6;
baryCoords.z = (num * num5 - num2 * num4) * num6;
baryCoords.x = 1f - baryCoords.y - baryCoords.z;
}
public static float SignedAngleRad(this Vector3 vector, Vector3 target, Vector3 normal)
{
Vector3ex.Normalize(ref vector, 1E-05f);
Vector3ex.Normalize(ref target, 1E-05f);
float num = vector.x * target.x + vector.y * target.y + vector.z * target.z;
if (num > 1f)
{
num = 1f;
}
else if (num < -1f)
{
num = -1f;
}
float num2 = Mathf.Acos(num);
Vector3 value = vector.Cross(target);
if (normal.Dot(value) < 0f)
{
num2 = -num2;
}
return(num2);
}
public static bool Create(IList <Vector3> vertices, float epsilon, out int dimension, out int[] indices)
{
Vector3ex.Information information = Vector3ex.GetInformation(vertices, epsilon);
if (information == null)
{
dimension = -1;
indices = null;
return(false);
}
int count = vertices.Count;
if (information.Dimension == 0)
{
dimension = 0;
int[] array = new int[1];
indices = array;
return(true);
}
if (information.Dimension == 1)
{
float[] array2 = new float[count];
Vector3 origin = information.Origin;
Vector3 vector = information.Direction[0];
for (int i = 0; i < count; i++)
{
Vector3 value = vertices[i] - origin;
array2[i] = vector.Dot(value);
}
ConvexHull1.Create(array2, epsilon, out dimension, out indices);
return(true);
}
if (information.Dimension == 2)
{
Vector2[] array3 = new Vector2[count];
Vector3 origin2 = information.Origin;
Vector3 vector2 = information.Direction[0];
Vector3 vector3 = information.Direction[1];
for (int j = 0; j < count; j++)
{
Vector3 value2 = vertices[j] - origin2;
array3[j] = new Vector2(vector2.Dot(value2), vector3.Dot(value2));
}
return(ConvexHull2.Create(array3, epsilon, out dimension, out indices));
}
dimension = 3;
Vector3[] array4 = new Vector3[count];
Vector3 min = information.Min;
float d = 1f / information.MaxRange;
for (int k = 0; k < count; k++)
{
array4[k] = (vertices[k] - min) * d;
}
Query3 query = new Query3(array4);
int v = information.Extreme[0];
int num = information.Extreme[1];
int num2 = information.Extreme[2];
int num3 = information.Extreme[3];
ConvexHull3.Triangle triangle;
ConvexHull3.Triangle triangle2;
ConvexHull3.Triangle triangle3;
ConvexHull3.Triangle triangle4;
if (information.ExtremeCCW)
{
triangle = new ConvexHull3.Triangle(v, num, num3);
triangle2 = new ConvexHull3.Triangle(v, num2, num);
triangle3 = new ConvexHull3.Triangle(v, num3, num2);
triangle4 = new ConvexHull3.Triangle(num, num2, num3);
triangle.AttachTo(triangle2, triangle4, triangle3);
triangle2.AttachTo(triangle3, triangle4, triangle);
triangle3.AttachTo(triangle, triangle4, triangle2);
triangle4.AttachTo(triangle2, triangle3, triangle);
}
else
{
triangle = new ConvexHull3.Triangle(v, num3, num);
triangle2 = new ConvexHull3.Triangle(v, num, num2);
triangle3 = new ConvexHull3.Triangle(v, num2, num3);
triangle4 = new ConvexHull3.Triangle(num, num3, num2);
triangle.AttachTo(triangle3, triangle4, triangle2);
triangle2.AttachTo(triangle, triangle4, triangle3);
triangle3.AttachTo(triangle2, triangle4, triangle);
triangle4.AttachTo(triangle, triangle3, triangle2);
}
HashSet <ConvexHull3.Triangle> hashSet = new HashSet <ConvexHull3.Triangle>();
hashSet.Add(triangle);
hashSet.Add(triangle2);
hashSet.Add(triangle3);
hashSet.Add(triangle4);
for (int l = 0; l < count; l++)
{
if (!ConvexHull3.Update(hashSet, l, query))
{
dimension = -1;
indices = null;
return(false);
}
}
ConvexHull3.ExtractIndices(hashSet, out indices);
return(true);
}
