niko
287 lines
9.3 KiB
C#
287 lines
9.3 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using UnityEngine;
|
|
|
|
namespace ProBuilder2.Common
|
|
{
|
|
// Token: 0x0200003B RID: 59
|
|
public static class pb_Projection
|
|
{
|
|
// Token: 0x060001DE RID: 478 RVA: 0x00017AD5 File Offset: 0x00015ED5
|
|
public static Vector2[] PlanarProject(IList<Vector3> verts, Vector3 planeNormal)
|
|
{
|
|
return pb_Projection.PlanarProject(verts.ToArray<Vector3>(), planeNormal, pb_Projection.VectorToProjectionAxis(planeNormal), null);
|
|
}
|
|
|
|
// Token: 0x060001DF RID: 479 RVA: 0x00017AEC File Offset: 0x00015EEC
|
|
public static Vector2[] PlanarProject(pb_Object pb, pb_Face face)
|
|
{
|
|
Vector3 vector = pb_Math.Normal(pb, face);
|
|
return pb_Projection.PlanarProject(pb.vertices, vector, pb_Projection.VectorToProjectionAxis(vector), face.indices);
|
|
}
|
|
|
|
// Token: 0x060001E0 RID: 480 RVA: 0x00017B1C File Offset: 0x00015F1C
|
|
public static Vector2[] PlanarProject(IList<pb_Vertex> vertices, IList<int> indices)
|
|
{
|
|
int count = indices.Count;
|
|
Vector3[] array = new Vector3[count];
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
array[i] = vertices[indices[i]].position;
|
|
}
|
|
Vector3 vector = pb_Math.Normal(vertices, indices);
|
|
ProjectionAxis projectionAxis = pb_Projection.VectorToProjectionAxis(vector);
|
|
return pb_Projection.PlanarProject(array, vector, projectionAxis, null);
|
|
}
|
|
|
|
// Token: 0x060001E1 RID: 481 RVA: 0x00017B84 File Offset: 0x00015F84
|
|
public static Vector2[] PlanarProject(Vector3[] verts, Vector3 planeNormal, ProjectionAxis projectionAxis, int[] indices = null)
|
|
{
|
|
int num = ((indices != null && indices.Length >= 1) ? indices.Length : verts.Length);
|
|
Vector2[] array = new Vector2[num];
|
|
Vector3 vector = Vector3.zero;
|
|
switch (projectionAxis)
|
|
{
|
|
case ProjectionAxis.X:
|
|
case ProjectionAxis.X_Negative:
|
|
vector = Vector3.up;
|
|
break;
|
|
case ProjectionAxis.Y:
|
|
case ProjectionAxis.Y_Negative:
|
|
vector = Vector3.forward;
|
|
break;
|
|
case ProjectionAxis.Z:
|
|
case ProjectionAxis.Z_Negative:
|
|
vector = Vector3.up;
|
|
break;
|
|
}
|
|
Vector3 vector2 = Vector3.Cross(planeNormal, vector);
|
|
vector2.Normalize();
|
|
Vector3 vector3 = Vector3.Cross(vector2, planeNormal);
|
|
vector3.Normalize();
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
int num2 = ((indices == null) ? i : indices[i]);
|
|
float num3 = Vector3.Dot(vector2, verts[num2]);
|
|
float num4 = Vector3.Dot(vector3, verts[num2]);
|
|
array[i] = new Vector2(num3, num4);
|
|
}
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x060001E2 RID: 482 RVA: 0x00017C88 File Offset: 0x00016088
|
|
public static void PlanarProject(Vector3[] verts, Vector2[] uvs, int[] indices, Vector3 planeNormal, ProjectionAxis projectionAxis)
|
|
{
|
|
Vector3 vector;
|
|
switch (projectionAxis)
|
|
{
|
|
case ProjectionAxis.X:
|
|
case ProjectionAxis.X_Negative:
|
|
vector = Vector3.up;
|
|
break;
|
|
case ProjectionAxis.Y:
|
|
case ProjectionAxis.Y_Negative:
|
|
vector = Vector3.forward;
|
|
break;
|
|
case ProjectionAxis.Z:
|
|
case ProjectionAxis.Z_Negative:
|
|
vector = Vector3.up;
|
|
break;
|
|
default:
|
|
vector = Vector3.up;
|
|
break;
|
|
}
|
|
pb_Math.Cross(planeNormal, vector, ref pb_Projection.t_uaxis.x, ref pb_Projection.t_uaxis.y, ref pb_Projection.t_uaxis.z);
|
|
pb_Projection.t_uaxis.Normalize();
|
|
pb_Math.Cross(pb_Projection.t_uaxis, planeNormal, ref pb_Projection.t_vaxis.x, ref pb_Projection.t_vaxis.y, ref pb_Projection.t_vaxis.z);
|
|
pb_Projection.t_vaxis.Normalize();
|
|
int num = indices.Length;
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
int num2 = indices[i];
|
|
uvs[num2].x = Vector3.Dot(pb_Projection.t_uaxis, verts[num2]);
|
|
uvs[num2].y = Vector3.Dot(pb_Projection.t_vaxis, verts[num2]);
|
|
}
|
|
}
|
|
|
|
// Token: 0x060001E3 RID: 483 RVA: 0x00017DA8 File Offset: 0x000161A8
|
|
public static Vector2[] SphericalProject(IList<Vector3> vertices, IList<int> indices = null)
|
|
{
|
|
int num = ((indices != null) ? indices.Count : vertices.Count);
|
|
Vector2[] array = new Vector2[num];
|
|
Vector3 vector = pb_Math.Average(vertices, indices);
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
int num2 = ((indices != null) ? indices[i] : i);
|
|
Vector3 vector2 = vertices[num2] - vector;
|
|
vector2.Normalize();
|
|
array[i].x = 0.5f + Mathf.Atan2(vector2.z, vector2.x) / 6.2831855f;
|
|
array[i].y = 0.5f - Mathf.Asin(vector2.y) / 3.1415927f;
|
|
}
|
|
return array;
|
|
}
|
|
|
|
// Token: 0x060001E4 RID: 484 RVA: 0x00017E6C File Offset: 0x0001626C
|
|
public static IList<Vector2> Sort(IList<Vector2> verts, SortMethod method = SortMethod.CounterClockwise)
|
|
{
|
|
Vector2 vector = pb_Math.Average(verts, null);
|
|
Vector2 up = Vector2.up;
|
|
int count = verts.Count;
|
|
List<pb_Tuple<float, Vector2>> list = new List<pb_Tuple<float, Vector2>>(count);
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
list.Add(new pb_Tuple<float, Vector2>(pb_Math.SignedAngle(up, verts[i] - vector), verts[i]));
|
|
}
|
|
list.Sort((pb_Tuple<float, Vector2> a, pb_Tuple<float, Vector2> b) => (a.Item1 >= b.Item1) ? 1 : (-1));
|
|
IList<Vector2> list2 = list.Select((pb_Tuple<float, Vector2> x) => x.Item2).ToList<Vector2>();
|
|
if (method == SortMethod.Clockwise)
|
|
{
|
|
list2.Reverse<Vector2>();
|
|
}
|
|
return list2;
|
|
}
|
|
|
|
// Token: 0x060001E5 RID: 485 RVA: 0x00017F30 File Offset: 0x00016330
|
|
public static Vector3 ProjectionAxisToVector(ProjectionAxis axis)
|
|
{
|
|
switch (axis)
|
|
{
|
|
case ProjectionAxis.X:
|
|
return Vector3.right;
|
|
case ProjectionAxis.Y:
|
|
return Vector3.up;
|
|
case ProjectionAxis.Z:
|
|
return Vector3.forward;
|
|
case ProjectionAxis.X_Negative:
|
|
return -Vector3.right;
|
|
case ProjectionAxis.Y_Negative:
|
|
return -Vector3.up;
|
|
case ProjectionAxis.Z_Negative:
|
|
return -Vector3.forward;
|
|
default:
|
|
return Vector3.zero;
|
|
}
|
|
}
|
|
|
|
// Token: 0x060001E6 RID: 486 RVA: 0x00017F98 File Offset: 0x00016398
|
|
public static ProjectionAxis VectorToProjectionAxis(Vector3 plane)
|
|
{
|
|
if (Mathf.Abs(plane.x) > Mathf.Abs(plane.y) && Mathf.Abs(plane.x) > Mathf.Abs(plane.z))
|
|
{
|
|
return (plane.x <= 0f) ? ProjectionAxis.X_Negative : ProjectionAxis.X;
|
|
}
|
|
if (Mathf.Abs(plane.y) > Mathf.Abs(plane.z))
|
|
{
|
|
return (plane.y <= 0f) ? ProjectionAxis.Y_Negative : ProjectionAxis.Y;
|
|
}
|
|
return (plane.z <= 0f) ? ProjectionAxis.Z_Negative : ProjectionAxis.Z;
|
|
}
|
|
|
|
// Token: 0x060001E7 RID: 487 RVA: 0x00018048 File Offset: 0x00016448
|
|
public static Plane FindBestPlane<T>(IList<T> points, Func<T, Vector3> selector, IList<int> indices = null)
|
|
{
|
|
float num = 0f;
|
|
float num2 = 0f;
|
|
float num3 = 0f;
|
|
float num4 = 0f;
|
|
float num5 = 0f;
|
|
float num6 = 0f;
|
|
bool flag = indices != null && indices.Count > 0;
|
|
int num7 = ((!flag) ? points.Count : indices.Count);
|
|
Vector3 vector = points.Average(selector, indices);
|
|
for (int i = 0; i < num7; i++)
|
|
{
|
|
Vector3 vector2 = selector(points[(!flag) ? i : indices[i]]) - vector;
|
|
num += vector2.x * vector2.x;
|
|
num2 += vector2.x * vector2.y;
|
|
num3 += vector2.x * vector2.z;
|
|
num4 += vector2.y * vector2.y;
|
|
num5 += vector2.y * vector2.z;
|
|
num6 += vector2.z * vector2.z;
|
|
}
|
|
float num8 = num4 * num6 - num5 * num5;
|
|
float num9 = num * num6 - num3 * num3;
|
|
float num10 = num * num4 - num2 * num2;
|
|
Vector3 vector3;
|
|
if (num8 > num9 && num8 > num10)
|
|
{
|
|
vector3 = new Vector3(1f, (num3 * num5 - num2 * num6) / num8, (num2 * num5 - num3 * num4) / num8);
|
|
}
|
|
else if (num9 > num10)
|
|
{
|
|
vector3 = new Vector3((num5 * num3 - num2 * num6) / num9, 1f, (num2 * num3 - num5 * num) / num9);
|
|
}
|
|
else
|
|
{
|
|
vector3 = new Vector3((num5 * num2 - num3 * num4) / num10, (num3 * num2 - num5 * num) / num10, 1f);
|
|
}
|
|
vector3.Normalize();
|
|
return new Plane(vector3, vector);
|
|
}
|
|
|
|
// Token: 0x060001E8 RID: 488 RVA: 0x00018224 File Offset: 0x00016624
|
|
public static Plane FindBestPlane(Vector3[] points, int[] indices = null)
|
|
{
|
|
float num = 0f;
|
|
float num2 = 0f;
|
|
float num3 = 0f;
|
|
float num4 = 0f;
|
|
float num5 = 0f;
|
|
float num6 = 0f;
|
|
bool flag = indices != null && indices.Length > 0;
|
|
int num7 = ((!flag) ? points.Length : indices.Length);
|
|
Vector3 zero = Vector3.zero;
|
|
Vector3 zero2 = Vector3.zero;
|
|
for (int i = 0; i < num7; i++)
|
|
{
|
|
zero.x += points[(!flag) ? i : indices[i]].x;
|
|
zero.y += points[(!flag) ? i : indices[i]].y;
|
|
zero.z += points[(!flag) ? i : indices[i]].z;
|
|
}
|
|
zero.x /= (float)num7;
|
|
zero.y /= (float)num7;
|
|
zero.z /= (float)num7;
|
|
for (int j = 0; j < num7; j++)
|
|
{
|
|
Vector3 vector = points[(!flag) ? j : indices[j]] - zero;
|
|
num += vector.x * vector.x;
|
|
num2 += vector.x * vector.y;
|
|
num3 += vector.x * vector.z;
|
|
num4 += vector.y * vector.y;
|
|
num5 += vector.y * vector.z;
|
|
num6 += vector.z * vector.z;
|
|
}
|
|
float num8 = num4 * num6 - num5 * num5;
|
|
float num9 = num * num6 - num3 * num3;
|
|
float num10 = num * num4 - num2 * num2;
|
|
if (num8 > num9 && num8 > num10)
|
|
{
|
|
zero2.x = 1f;
|
|
zero2.y = (num3 * num5 - num2 * num6) / num8;
|
|
zero2.z = (num2 * num5 - num3 * num4) / num8;
|
|
}
|
|
else if (num9 > num10)
|
|
{
|
|
zero2.x = (num5 * num3 - num2 * num6) / num9;
|
|
zero2.y = 1f;
|
|
zero2.z = (num2 * num3 - num5 * num) / num9;
|
|
}
|
|
else
|
|
{
|
|
zero2.x = (num5 * num2 - num3 * num4) / num10;
|
|
zero2.y = (num3 * num2 - num5 * num) / num10;
|
|
zero2.z = 1f;
|
|
}
|
|
zero2.Normalize();
|
|
return new Plane(zero2, zero);
|
|
}
|
|
|
|
// Token: 0x0400016B RID: 363
|
|
private static Vector3 t_uaxis = Vector3.zero;
|
|
|
|
// Token: 0x0400016C RID: 364
|
|
private static Vector3 t_vaxis = Vector3.zero;
|
|
}
|
|
}
|