295 lines
7.0 KiB
C#
295 lines
7.0 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
|
|
public class MegaUtils
|
|
{
|
|
public static void Bez3D(out Vector3 b, ref Vector3[] p, float u)
|
|
{
|
|
Vector3 vector = p[0];
|
|
vector.x += (p[1].x - p[0].x) * u;
|
|
vector.y += (p[1].y - p[0].y) * u;
|
|
vector.z += (p[1].z - p[0].z) * u;
|
|
Vector3 vector2 = p[1];
|
|
vector2.x += (p[2].x - p[1].x) * u;
|
|
vector2.y += (p[2].y - p[1].y) * u;
|
|
vector2.z += (p[2].z - p[1].z) * u;
|
|
Vector3 vector3 = vector + (vector2 - vector) * u;
|
|
vector.x = p[2].x + (p[3].x - p[2].x) * u;
|
|
vector.y = p[2].y + (p[3].y - p[2].y) * u;
|
|
vector.z = p[2].z + (p[3].z - p[2].z) * u;
|
|
vector.x = vector2.x + (vector.x - vector2.x) * u;
|
|
vector.y = vector2.y + (vector.y - vector2.y) * u;
|
|
vector.z = vector2.z + (vector.z - vector2.z) * u;
|
|
b.x = vector3.x + (vector.x - vector3.x) * u;
|
|
b.y = vector3.y + (vector.y - vector3.y) * u;
|
|
b.z = vector3.z + (vector.z - vector3.z) * u;
|
|
}
|
|
|
|
public static float WaveFunc(float radius, float t, float amp, float waveLen, float phase, float decay)
|
|
{
|
|
if (waveLen == 0f)
|
|
{
|
|
waveLen = 1E-07f;
|
|
}
|
|
float f = (float)Math.PI * 2f * (radius / waveLen + phase);
|
|
return amp * Mathf.Sin(f) * Mathf.Exp((0f - decay) * Mathf.Abs(radius));
|
|
}
|
|
|
|
public static int LargestComponent(Vector3 p)
|
|
{
|
|
if (p.x > p.y)
|
|
{
|
|
return (!(p.x > p.z)) ? 2 : 0;
|
|
}
|
|
return (p.y > p.z) ? 1 : 2;
|
|
}
|
|
|
|
public static float LargestValue(Vector3 p)
|
|
{
|
|
if (p.x > p.y)
|
|
{
|
|
return (!(p.x > p.z)) ? p.z : p.x;
|
|
}
|
|
return (!(p.y > p.z)) ? p.z : p.y;
|
|
}
|
|
|
|
public static float LargestValue1(Vector3 p)
|
|
{
|
|
if (Mathf.Abs(p.x) > Mathf.Abs(p.y))
|
|
{
|
|
return (!(Mathf.Abs(p.x) > Mathf.Abs(p.z))) ? p.z : p.x;
|
|
}
|
|
return (!(Mathf.Abs(p.y) > Mathf.Abs(p.z))) ? p.z : p.y;
|
|
}
|
|
|
|
public static int SmallestComponent(Vector3 p)
|
|
{
|
|
if (p.x < p.y)
|
|
{
|
|
return (!(p.x < p.z)) ? 2 : 0;
|
|
}
|
|
return (p.y < p.z) ? 1 : 2;
|
|
}
|
|
|
|
public static float SmallestValue(Vector3 p)
|
|
{
|
|
if (p.x < p.y)
|
|
{
|
|
return (!(p.x < p.z)) ? p.z : p.x;
|
|
}
|
|
return (!(p.y < p.z)) ? p.z : p.y;
|
|
}
|
|
|
|
public static float SmallestLargestValueAbs(Vector3 p)
|
|
{
|
|
if (Mathf.Abs(p.x) < Mathf.Abs(p.y))
|
|
{
|
|
return (!(Mathf.Abs(p.x) < Mathf.Abs(p.z))) ? p.z : p.x;
|
|
}
|
|
return (!(Mathf.Abs(p.y) < Mathf.Abs(p.z))) ? p.z : p.y;
|
|
}
|
|
|
|
public static Vector3 Extents(Vector3[] verts, out Vector3 min, out Vector3 max)
|
|
{
|
|
Vector3 result = Vector3.zero;
|
|
min = Vector3.zero;
|
|
max = Vector3.zero;
|
|
if (verts != null && verts.Length > 0)
|
|
{
|
|
min = verts[0];
|
|
max = verts[0];
|
|
for (int i = 1; i < verts.Length; i++)
|
|
{
|
|
if (verts[i].x < min.x)
|
|
{
|
|
min.x = verts[i].x;
|
|
}
|
|
if (verts[i].y < min.y)
|
|
{
|
|
min.y = verts[i].y;
|
|
}
|
|
if (verts[i].z < min.z)
|
|
{
|
|
min.z = verts[i].z;
|
|
}
|
|
if (verts[i].x > max.x)
|
|
{
|
|
max.x = verts[i].x;
|
|
}
|
|
if (verts[i].y > max.y)
|
|
{
|
|
max.y = verts[i].y;
|
|
}
|
|
if (verts[i].z > max.z)
|
|
{
|
|
max.z = verts[i].z;
|
|
}
|
|
}
|
|
result = max - min;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static Vector3 Extents(List<Vector3> verts, out Vector3 min, out Vector3 max)
|
|
{
|
|
Vector3 result = Vector3.zero;
|
|
min = Vector3.zero;
|
|
max = Vector3.zero;
|
|
if (verts != null && verts.Count > 0)
|
|
{
|
|
min = verts[0];
|
|
max = verts[0];
|
|
for (int i = 1; i < verts.Count; i++)
|
|
{
|
|
if (verts[i].x < min.x)
|
|
{
|
|
min.x = verts[i].x;
|
|
}
|
|
if (verts[i].y < min.y)
|
|
{
|
|
min.y = verts[i].y;
|
|
}
|
|
if (verts[i].z < min.z)
|
|
{
|
|
min.z = verts[i].z;
|
|
}
|
|
if (verts[i].x > max.x)
|
|
{
|
|
max.x = verts[i].x;
|
|
}
|
|
if (verts[i].y > max.y)
|
|
{
|
|
max.y = verts[i].y;
|
|
}
|
|
if (verts[i].z > max.z)
|
|
{
|
|
max.z = verts[i].z;
|
|
}
|
|
}
|
|
result = max - min;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static int FindVert(Vector3 vert, List<Vector3> verts, float tolerance, float scl, bool flipyz, bool negx, int vn)
|
|
{
|
|
int result = 0;
|
|
if (negx)
|
|
{
|
|
vert.x = 0f - vert.x;
|
|
}
|
|
if (flipyz)
|
|
{
|
|
float z = vert.z;
|
|
vert.z = vert.y;
|
|
vert.y = z;
|
|
}
|
|
vert /= scl;
|
|
float num = Vector3.SqrMagnitude(verts[0] - vert);
|
|
for (int i = 0; i < verts.Count; i++)
|
|
{
|
|
float num2 = Vector3.SqrMagnitude(verts[i] - vert);
|
|
if (num2 < num)
|
|
{
|
|
num = num2;
|
|
result = i;
|
|
}
|
|
}
|
|
if (num > tolerance)
|
|
{
|
|
return -1;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static void BuildTangents(Mesh mesh)
|
|
{
|
|
int num = mesh.triangles.Length;
|
|
int num2 = mesh.vertices.Length;
|
|
Vector3[] array = new Vector3[num2];
|
|
Vector3[] array2 = new Vector3[num2];
|
|
Vector4[] array3 = new Vector4[num2];
|
|
Vector3[] vertices = mesh.vertices;
|
|
Vector2[] uv = mesh.uv;
|
|
Vector3[] normals = mesh.normals;
|
|
int[] triangles = mesh.triangles;
|
|
for (int i = 0; i < num; i += 3)
|
|
{
|
|
long num3 = triangles[i];
|
|
long num4 = triangles[i + 1];
|
|
long num5 = triangles[i + 2];
|
|
Vector3 vector = vertices[num3];
|
|
Vector3 vector2 = vertices[num4];
|
|
Vector3 vector3 = vertices[num5];
|
|
Vector2 vector4 = uv[num3];
|
|
Vector2 vector5 = uv[num4];
|
|
Vector2 vector6 = uv[num5];
|
|
float num6 = vector2.x - vector.x;
|
|
float num7 = vector3.x - vector.x;
|
|
float num8 = vector2.y - vector.y;
|
|
float num9 = vector3.y - vector.y;
|
|
float num10 = vector2.z - vector.z;
|
|
float num11 = vector3.z - vector.z;
|
|
float num12 = vector5.x - vector4.x;
|
|
float num13 = vector6.x - vector4.x;
|
|
float num14 = vector5.y - vector4.y;
|
|
float num15 = vector6.y - vector4.y;
|
|
float num16 = 1f / (num12 * num15 - num13 * num14);
|
|
Vector3 vector7 = new Vector3((num15 * num6 - num14 * num7) * num16, (num15 * num8 - num14 * num9) * num16, (num15 * num10 - num14 * num11) * num16);
|
|
Vector3 vector8 = new Vector3((num12 * num7 - num13 * num6) * num16, (num12 * num9 - num13 * num8) * num16, (num12 * num11 - num13 * num10) * num16);
|
|
array[num3] += vector7;
|
|
array[num4] += vector7;
|
|
array[num5] += vector7;
|
|
array2[num3] += vector8;
|
|
array2[num4] += vector8;
|
|
array2[num5] += vector8;
|
|
}
|
|
for (int j = 0; j < num2; j++)
|
|
{
|
|
Vector3 normal = normals[j];
|
|
Vector3 tangent = array[j];
|
|
Vector3.OrthoNormalize(ref normal, ref tangent);
|
|
array3[j].x = tangent.x;
|
|
array3[j].y = tangent.y;
|
|
array3[j].z = tangent.z;
|
|
array3[j].w = ((!(Vector3.Dot(Vector3.Cross(normal, tangent), array2[j]) < 0f)) ? 1f : (-1f));
|
|
}
|
|
mesh.tangents = array3;
|
|
}
|
|
|
|
public static Mesh GetMesh(GameObject go)
|
|
{
|
|
if (!Application.isPlaying)
|
|
{
|
|
return GetSharedMesh(go);
|
|
}
|
|
MeshFilter meshFilter = (MeshFilter)go.GetComponent(typeof(MeshFilter));
|
|
if (meshFilter != null)
|
|
{
|
|
return meshFilter.mesh;
|
|
}
|
|
SkinnedMeshRenderer skinnedMeshRenderer = (SkinnedMeshRenderer)go.GetComponent(typeof(SkinnedMeshRenderer));
|
|
if (skinnedMeshRenderer != null)
|
|
{
|
|
return skinnedMeshRenderer.sharedMesh;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static Mesh GetSharedMesh(GameObject go)
|
|
{
|
|
MeshFilter meshFilter = (MeshFilter)go.GetComponent(typeof(MeshFilter));
|
|
if (meshFilter != null)
|
|
{
|
|
return meshFilter.sharedMesh;
|
|
}
|
|
SkinnedMeshRenderer skinnedMeshRenderer = (SkinnedMeshRenderer)go.GetComponent(typeof(SkinnedMeshRenderer));
|
|
if (skinnedMeshRenderer != null)
|
|
{
|
|
return skinnedMeshRenderer.sharedMesh;
|
|
}
|
|
return null;
|
|
}
|
|
}
|