952 lines
22 KiB
C#
952 lines
22 KiB
C#
using System;
|
|
using UnityEngine;
|
|
|
|
[AddComponentMenu("MegaShapes/Hose New")]
|
|
[ExecuteInEditMode]
|
|
[RequireComponent(typeof(MeshFilter))]
|
|
[RequireComponent(typeof(MeshRenderer))]
|
|
public class MegaHoseNew : MonoBehaviour
|
|
{
|
|
public bool freecreate = true;
|
|
|
|
public bool updatemesh = true;
|
|
|
|
private const float HalfIntMax = 16383.5f;
|
|
|
|
private const float PIover2 = (float)Math.PI / 2f;
|
|
|
|
private const float EPSILON = 0.0001f;
|
|
|
|
public MegaSpline hosespline = new MegaSpline();
|
|
|
|
private Mesh mesh;
|
|
|
|
public Vector3[] verts = new Vector3[1];
|
|
|
|
public Vector2[] uvs = new Vector2[1];
|
|
|
|
public int[] faces = new int[1];
|
|
|
|
public Vector3[] normals;
|
|
|
|
public bool optimize;
|
|
|
|
public bool calctangents;
|
|
|
|
public bool recalcCollider;
|
|
|
|
public bool calcnormals;
|
|
|
|
public bool capends = true;
|
|
|
|
public GameObject custnode2;
|
|
|
|
public GameObject custnode;
|
|
|
|
public Vector3 offset = Vector3.zero;
|
|
|
|
public Vector3 offset1 = Vector3.zero;
|
|
|
|
public Vector3 rotate = Vector3.zero;
|
|
|
|
public Vector3 rotate1 = Vector3.zero;
|
|
|
|
public Vector3 scale = Vector3.one;
|
|
|
|
public Vector3 scale1 = Vector3.one;
|
|
|
|
public int endsmethod;
|
|
|
|
public float noreflength = 1f;
|
|
|
|
public int segments = 45;
|
|
|
|
public MegaHoseSmooth smooth;
|
|
|
|
public MegaHoseType wiretype;
|
|
|
|
public float rnddia = 0.2f;
|
|
|
|
public int rndsides = 8;
|
|
|
|
public float rndrot;
|
|
|
|
public float rectwidth = 0.2f;
|
|
|
|
public float rectdepth = 0.2f;
|
|
|
|
public float rectfillet;
|
|
|
|
public int rectfilletsides;
|
|
|
|
public float rectrotangle;
|
|
|
|
public float dsecwidth = 0.2f;
|
|
|
|
public float dsecdepth = 0.2f;
|
|
|
|
public float dsecfillet;
|
|
|
|
public int dsecfilletsides;
|
|
|
|
public int dsecrndsides = 4;
|
|
|
|
public float dsecrotangle;
|
|
|
|
public bool mapmemapme = true;
|
|
|
|
public bool flexon;
|
|
|
|
public float flexstart = 0.1f;
|
|
|
|
public float flexstop = 0.9f;
|
|
|
|
public int flexcycles = 5;
|
|
|
|
public float flexdiameter = -0.2f;
|
|
|
|
public float tension1 = 10f;
|
|
|
|
public float tension2 = 10f;
|
|
|
|
public bool usebulgecurve;
|
|
|
|
public AnimationCurve bulge = new AnimationCurve(new Keyframe(0f, 0f), new Keyframe(1f, 0f));
|
|
|
|
public float bulgeamount = 1f;
|
|
|
|
public float bulgeoffset;
|
|
|
|
public Vector2 uvscale = Vector2.one;
|
|
|
|
public bool animatebulge;
|
|
|
|
public float bulgespeed;
|
|
|
|
public float minbulge = -1f;
|
|
|
|
public float maxbulge = 2f;
|
|
|
|
public bool usesizecurve;
|
|
|
|
public AnimationCurve size = new AnimationCurve(new Keyframe(0f, 1f), new Keyframe(1f, 1f));
|
|
|
|
public bool displayspline = true;
|
|
|
|
private bool visible = true;
|
|
|
|
public bool InvisibleUpdate;
|
|
|
|
public bool dolateupdate;
|
|
|
|
private Vector3 endp1 = Vector3.zero;
|
|
|
|
private Vector3 endp2 = Vector3.zero;
|
|
|
|
private Vector3 endr1 = Vector3.zero;
|
|
|
|
private Vector3 endr2 = Vector3.zero;
|
|
|
|
public Vector3[] SaveVertex;
|
|
|
|
public Vector2[] SaveUV;
|
|
|
|
public Vector3[] SaveNormals;
|
|
|
|
public bool rebuildcross = true;
|
|
|
|
public int NvertsPerRing;
|
|
|
|
public int Nverts;
|
|
|
|
public Vector3 up = Vector3.up;
|
|
|
|
private Vector3 starty = Vector3.zero;
|
|
|
|
public Matrix4x4 Tlocal = Matrix4x4.identity;
|
|
|
|
private Matrix4x4 wtm1;
|
|
|
|
private MeshCollider meshCol;
|
|
|
|
[ContextMenu("Help")]
|
|
public void Help()
|
|
{
|
|
Application.OpenURL("http://www.west-racing.com/mf/?page_id=3436");
|
|
}
|
|
|
|
private void Awake()
|
|
{
|
|
updatemesh = true;
|
|
rebuildcross = true;
|
|
Rebuild();
|
|
}
|
|
|
|
private void Reset()
|
|
{
|
|
Rebuild();
|
|
}
|
|
|
|
private void OnBecameVisible()
|
|
{
|
|
visible = true;
|
|
}
|
|
|
|
private void OnBecameInvisible()
|
|
{
|
|
visible = false;
|
|
}
|
|
|
|
public void SetEndTarget(int end, GameObject target)
|
|
{
|
|
if (end == 0)
|
|
{
|
|
custnode = target;
|
|
}
|
|
else
|
|
{
|
|
custnode2 = target;
|
|
}
|
|
updatemesh = true;
|
|
}
|
|
|
|
public void Rebuild()
|
|
{
|
|
MeshFilter component = GetComponent<MeshFilter>();
|
|
if (component != null)
|
|
{
|
|
Mesh mesh = component.sharedMesh;
|
|
if (mesh == null)
|
|
{
|
|
mesh = (component.sharedMesh = new Mesh());
|
|
}
|
|
if (mesh != null)
|
|
{
|
|
BuildMesh();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void MakeSaveVertex(int NvertsPerRing, int nfillets, int nsides, MegaHoseType wtype)
|
|
{
|
|
switch (wtype)
|
|
{
|
|
case MegaHoseType.Round:
|
|
{
|
|
float num31 = (float)Math.PI * 2f / (float)(NvertsPerRing - 1);
|
|
float num32 = rnddia;
|
|
num32 *= 0.5f;
|
|
for (int m = 0; m < NvertsPerRing; m++)
|
|
{
|
|
float f5 = (float)(m + 1) * num31;
|
|
SaveVertex[m] = new Vector3(num32 * Mathf.Cos(f5), num32 * Mathf.Sin(f5), 0f);
|
|
}
|
|
break;
|
|
}
|
|
case MegaHoseType.Rectangle:
|
|
{
|
|
int num17 = 0;
|
|
int num18 = 1 + nfillets;
|
|
int num19 = 2 * num18;
|
|
int num20 = num18 + num19;
|
|
float num21 = rectwidth * 0.5f;
|
|
float num22 = rectdepth * 0.5f;
|
|
float num23 = rectfillet;
|
|
if (num23 < 0f)
|
|
{
|
|
num23 = 0f;
|
|
}
|
|
if (nfillets > 0)
|
|
{
|
|
float num24 = num21 - num23;
|
|
float num25 = num22 - num23;
|
|
float num26 = 0f - num24;
|
|
float num27 = 0f - num25;
|
|
SaveVertex[0] = new Vector3(num21, num25, 0f);
|
|
SaveVertex[nfillets] = new Vector3(num24, num22, 0f);
|
|
SaveVertex[num18] = new Vector3(num26, num22, 0f);
|
|
SaveVertex[num18 + nfillets] = new Vector3(0f - num21, num25, 0f);
|
|
SaveVertex[num19] = new Vector3(0f - num21, num27, 0f);
|
|
SaveVertex[num19 + nfillets] = new Vector3(num26, 0f - num22, 0f);
|
|
SaveVertex[num20] = new Vector3(num24, 0f - num22, 0f);
|
|
SaveVertex[num20 + nfillets] = new Vector3(num21, num27, 0f);
|
|
if (nfillets > 1)
|
|
{
|
|
float num28 = (float)Math.PI / 2f / (float)nfillets;
|
|
num17 = 1;
|
|
for (int l = 0; l < nfillets - 1; l++)
|
|
{
|
|
float f4 = (float)(l + 1) * num28;
|
|
float num29 = num23 * Mathf.Cos(f4);
|
|
float num30 = num23 * Mathf.Sin(f4);
|
|
SaveVertex[num17] = new Vector3(num24 + num29, num25 + num30, 0f);
|
|
SaveVertex[num17 + num18] = new Vector3(num26 - num30, num25 + num29, 0f);
|
|
SaveVertex[num17 + num19] = new Vector3(num26 - num29, num27 - num30, 0f);
|
|
SaveVertex[num17 + num20] = new Vector3(num24 + num30, num27 - num29, 0f);
|
|
num17++;
|
|
}
|
|
}
|
|
SaveVertex[SaveVertex.Length - 1] = SaveVertex[0];
|
|
}
|
|
else if (smooth == MegaHoseSmooth.SMOOTHNONE)
|
|
{
|
|
SaveVertex[num17++] = new Vector3(num21, num22, 0f);
|
|
SaveVertex[num17++] = new Vector3(0f - num21, num22, 0f);
|
|
SaveVertex[num17++] = new Vector3(0f - num21, num22, 0f);
|
|
SaveVertex[num17++] = new Vector3(0f - num21, 0f - num22, 0f);
|
|
SaveVertex[num17++] = new Vector3(0f - num21, 0f - num22, 0f);
|
|
SaveVertex[num17++] = new Vector3(num21, 0f - num22, 0f);
|
|
SaveVertex[num17++] = new Vector3(num21, 0f - num22, 0f);
|
|
SaveVertex[num17++] = new Vector3(num21, num22, 0f);
|
|
}
|
|
else
|
|
{
|
|
SaveVertex[num17++] = new Vector3(num21, num22, 0f);
|
|
SaveVertex[num17++] = new Vector3(0f - num21, num22, 0f);
|
|
SaveVertex[num17++] = new Vector3(0f - num21, 0f - num22, 0f);
|
|
SaveVertex[num17++] = new Vector3(num21, 0f - num22, 0f);
|
|
SaveVertex[num17++] = new Vector3(num21, num22, 0f);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
int num = 0;
|
|
float num2 = (float)Math.PI / (float)nsides;
|
|
float num3 = dsecwidth * 0.5f;
|
|
float num4 = dsecdepth * 0.5f;
|
|
float num5 = dsecfillet;
|
|
if (num5 < 0f)
|
|
{
|
|
num5 = 0f;
|
|
}
|
|
float num6 = num4 - num3;
|
|
if (nfillets > 0)
|
|
{
|
|
float num7 = num4 - num5;
|
|
float num8 = 0f - num7;
|
|
float num9 = num3 - num5;
|
|
int num10 = 1 + nfillets;
|
|
int num11 = num10 + 1 + nsides;
|
|
SaveVertex[0] = new Vector3(num3, num7, 0f);
|
|
SaveVertex[nfillets] = new Vector3(num9, num4, 0f);
|
|
SaveVertex[num10] = new Vector3(num6, num4, 0f);
|
|
SaveVertex[num10 + nsides] = new Vector3(num6, 0f - num4, 0f);
|
|
SaveVertex[num11] = new Vector3(num9, 0f - num4, 0f);
|
|
SaveVertex[num11 + nfillets] = new Vector3(num3, num8, 0f);
|
|
if (nfillets > 1)
|
|
{
|
|
float num12 = (float)Math.PI / 2f / (float)nfillets;
|
|
num = 1;
|
|
for (int i = 0; i < nfillets - 1; i++)
|
|
{
|
|
float f = (float)(i + 1) * num12;
|
|
float num13 = num5 * Mathf.Cos(f);
|
|
float num14 = num5 * Mathf.Sin(f);
|
|
SaveVertex[num] = new Vector3(num9 + num13, num7 + num14, 0f);
|
|
SaveVertex[num + num11] = new Vector3(num9 + num14, num8 - num13, 0f);
|
|
num++;
|
|
}
|
|
}
|
|
num = 1 + num10;
|
|
for (int j = 0; j < nsides - 1; j++)
|
|
{
|
|
float f2 = (float)(j + 1) * num2;
|
|
float y = num4 * Mathf.Cos(f2);
|
|
float num15 = num4 * Mathf.Sin(f2);
|
|
SaveVertex[num] = new Vector3(num6 - num15, y, 0f);
|
|
num++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SaveVertex[num] = new Vector3(num3, num4, 0f);
|
|
num++;
|
|
SaveVertex[num] = new Vector3(num6, num4, 0f);
|
|
num++;
|
|
for (int k = 0; k < nsides - 1; k++)
|
|
{
|
|
float f3 = (float)(k + 1) * num2;
|
|
float y2 = num4 * Mathf.Cos(f3);
|
|
float num16 = num4 * Mathf.Sin(f3);
|
|
SaveVertex[num] = new Vector3(num6 - num16, y2, 0f);
|
|
num++;
|
|
}
|
|
SaveVertex[num] = new Vector3(num6, 0f - num4, 0f);
|
|
num++;
|
|
SaveVertex[num] = new Vector3(num3, 0f - num4, 0f);
|
|
num++;
|
|
}
|
|
SaveVertex[SaveVertex.Length - 1] = SaveVertex[0];
|
|
break;
|
|
}
|
|
}
|
|
float num33 = 0f;
|
|
Vector3 vector = Vector3.zero;
|
|
for (int n = 0; n < NvertsPerRing; n++)
|
|
{
|
|
if (n > 0)
|
|
{
|
|
num33 += (SaveVertex[n] - vector).magnitude;
|
|
}
|
|
SaveUV[n] = new Vector2(0f, num33 * uvscale.y);
|
|
vector = SaveVertex[n];
|
|
}
|
|
for (int num34 = 0; num34 < NvertsPerRing; num34++)
|
|
{
|
|
SaveUV[num34].y /= num33;
|
|
}
|
|
float num35 = 0f;
|
|
switch (wtype)
|
|
{
|
|
case MegaHoseType.Round:
|
|
num35 = rndrot;
|
|
break;
|
|
case MegaHoseType.Rectangle:
|
|
num35 = rectrotangle;
|
|
break;
|
|
case MegaHoseType.DSection:
|
|
num35 = dsecrotangle;
|
|
break;
|
|
}
|
|
if (num35 != 0f)
|
|
{
|
|
num35 *= (float)Math.PI / 180f;
|
|
float num36 = Mathf.Cos(num35);
|
|
float num37 = Mathf.Sin(num35);
|
|
for (int num38 = 0; num38 < NvertsPerRing; num38++)
|
|
{
|
|
float x = SaveVertex[num38].x * num36 - SaveVertex[num38].y * num37;
|
|
float y3 = SaveVertex[num38].x * num37 + SaveVertex[num38].y * num36;
|
|
SaveVertex[num38].x = x;
|
|
SaveVertex[num38].y = y3;
|
|
}
|
|
}
|
|
if (calcnormals)
|
|
{
|
|
for (int num39 = 0; num39 < NvertsPerRing; num39++)
|
|
{
|
|
int num40 = (num39 + 1) % NvertsPerRing;
|
|
Vector3 normalized = (SaveVertex[num40] - SaveVertex[num39]).normalized;
|
|
SaveNormals[num39] = new Vector3(normalized.y, 0f - normalized.x, 0f);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void FixHoseFillet()
|
|
{
|
|
float f = rectwidth;
|
|
float f2 = rectdepth;
|
|
float num = rectfillet;
|
|
float num2 = 0.5f * Mathf.Abs(f2);
|
|
float num3 = 0.5f * Mathf.Abs(f);
|
|
float num4 = ((!(num2 > num3)) ? num2 : num3);
|
|
if (num > num4)
|
|
{
|
|
rectfillet = num4;
|
|
}
|
|
}
|
|
|
|
private float RND11()
|
|
{
|
|
float num = UnityEngine.Random.Range(0f, 32768f) - 16383.5f;
|
|
return num / 16383.5f;
|
|
}
|
|
|
|
private void Mult1X3(Vector3 A, Matrix4x4 B, ref Vector3 C)
|
|
{
|
|
C[0] = A[0] * B[0, 0] + A[1] * B[0, 1] + A[2] * B[0, 2];
|
|
C[1] = A[0] * B[1, 0] + A[1] * B[1, 1] + A[2] * B[1, 2];
|
|
C[2] = A[0] * B[2, 0] + A[1] * B[2, 1] + A[2] * B[2, 2];
|
|
}
|
|
|
|
private void Mult1X4(Vector4 A, Matrix4x4 B, ref Vector4 C)
|
|
{
|
|
C[0] = A[0] * B[0, 0] + A[1] * B[0, 1] + A[2] * B[0, 2] + A[3] * B[0, 3];
|
|
C[1] = A[0] * B[1, 0] + A[1] * B[1, 1] + A[2] * B[1, 2] + A[3] * B[1, 3];
|
|
C[2] = A[0] * B[2, 0] + A[1] * B[2, 1] + A[2] * B[2, 2] + A[3] * B[2, 3];
|
|
C[3] = A[0] * B[3, 0] + A[1] * B[3, 1] + A[2] * B[3, 2] + A[3] * B[3, 3];
|
|
}
|
|
|
|
private void SetUpRotation(Vector3 Q, Vector3 W, float Theta, ref Matrix4x4 Rq)
|
|
{
|
|
Vector3 C = Vector3.zero;
|
|
Matrix4x4 identity = Matrix4x4.identity;
|
|
float num = W[0] * W[0];
|
|
float num2 = W[1] * W[1];
|
|
float num3 = W[2] * W[2];
|
|
float num4 = W[0] * W[1];
|
|
float num5 = W[0] * W[2];
|
|
float num6 = W[1] * W[2];
|
|
float num7 = Mathf.Cos(Theta);
|
|
float num8 = 1f - num7;
|
|
float num9 = Mathf.Sin(Theta);
|
|
identity[0, 0] = num + (1f - num) * num7;
|
|
identity[1, 0] = num4 * num8 + W[2] * num9;
|
|
identity[2, 0] = num5 * num8 - W[1] * num9;
|
|
identity[0, 1] = num4 * num8 - W[2] * num9;
|
|
identity[1, 1] = num2 + (1f - num2) * num7;
|
|
identity[2, 1] = num6 * num8 + W[0] * num9;
|
|
identity[0, 2] = num5 * num8 + W[1] * num9;
|
|
identity[1, 2] = num6 * num8 - W[0] * num9;
|
|
identity[2, 2] = num3 + (1f - num3) * num7;
|
|
Mult1X3(Q, identity, ref C);
|
|
Rq.SetColumn(0, identity.GetColumn(0));
|
|
Rq.SetColumn(1, identity.GetColumn(1));
|
|
Rq.SetColumn(2, identity.GetColumn(2));
|
|
Rq[0, 3] = Q[0] - C.x;
|
|
Rq[1, 3] = Q[1] - C.y;
|
|
Rq[2, 3] = Q[2] - C.z;
|
|
float num10 = (Rq[3, 2] = 0f);
|
|
num10 = (Rq[3, 1] = num10);
|
|
Rq[3, 0] = num10;
|
|
Rq[3, 3] = 1f;
|
|
}
|
|
|
|
private void RotateOnePoint(ref Vector3 Pin, Vector3 Q, Vector3 W, float Theta)
|
|
{
|
|
Matrix4x4 Rq = Matrix4x4.identity;
|
|
Vector4 C = Vector3.zero;
|
|
SetUpRotation(Q, W, Theta, ref Rq);
|
|
Vector4 a = Pin;
|
|
a[3] = 1f;
|
|
Mult1X4(a, Rq, ref C);
|
|
Pin = C;
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
if (animatebulge)
|
|
{
|
|
bulgeoffset += bulgespeed * Time.deltaTime;
|
|
if (bulgeoffset > maxbulge)
|
|
{
|
|
bulgeoffset -= maxbulge - minbulge;
|
|
}
|
|
if (bulgeoffset < minbulge)
|
|
{
|
|
bulgeoffset += maxbulge - minbulge;
|
|
}
|
|
updatemesh = true;
|
|
}
|
|
if ((bool)custnode)
|
|
{
|
|
if (custnode.transform.position != endp1)
|
|
{
|
|
endp1 = custnode.transform.position;
|
|
updatemesh = true;
|
|
}
|
|
if (custnode.transform.eulerAngles != endr1)
|
|
{
|
|
endr1 = custnode.transform.eulerAngles;
|
|
updatemesh = true;
|
|
}
|
|
}
|
|
if ((bool)custnode2)
|
|
{
|
|
if (custnode2.transform.position != endp2)
|
|
{
|
|
endp1 = custnode2.transform.position;
|
|
updatemesh = true;
|
|
}
|
|
if (custnode2.transform.eulerAngles != endr2)
|
|
{
|
|
endr2 = custnode2.transform.eulerAngles;
|
|
updatemesh = true;
|
|
}
|
|
}
|
|
if (!dolateupdate && (visible || InvisibleUpdate) && updatemesh)
|
|
{
|
|
updatemesh = false;
|
|
BuildMesh();
|
|
}
|
|
}
|
|
|
|
private void LateUpdate()
|
|
{
|
|
if (dolateupdate && (visible || InvisibleUpdate) && updatemesh)
|
|
{
|
|
updatemesh = false;
|
|
BuildMesh();
|
|
}
|
|
}
|
|
|
|
private void CalcSpline()
|
|
{
|
|
starty = custnode.transform.up;
|
|
Quaternion quaternion = custnode.transform.rotation * Quaternion.Euler(rotate);
|
|
Quaternion quaternion2 = custnode2.transform.rotation * Quaternion.Euler(rotate1);
|
|
Vector3 vector = tension1 * (quaternion * Vector3.forward);
|
|
Vector3 vector2 = tension2 * (quaternion2 * Vector3.forward);
|
|
Vector3 vector3 = base.transform.worldToLocalMatrix.MultiplyPoint3x4(custnode.transform.position + custnode.transform.TransformDirection(offset));
|
|
Vector3 vector4 = base.transform.worldToLocalMatrix.MultiplyPoint3x4(custnode2.transform.position + custnode2.transform.TransformDirection(offset1));
|
|
hosespline.knots[0].p = vector3;
|
|
hosespline.knots[0].invec = vector3 - vector;
|
|
hosespline.knots[0].outvec = vector3 + vector;
|
|
hosespline.knots[1].p = vector4;
|
|
hosespline.knots[1].invec = vector4 + vector2;
|
|
hosespline.knots[1].outvec = vector4 - vector2;
|
|
hosespline.CalcLength();
|
|
}
|
|
|
|
public Matrix4x4 GetSplineMat(MegaSpline spline, float alpha, bool interp, ref Vector3 lastup)
|
|
{
|
|
int k = -1;
|
|
Vector3 p = spline.InterpCurve3D(alpha, interp, ref k);
|
|
alpha += 0.01f;
|
|
if (spline.closed)
|
|
{
|
|
alpha %= 1f;
|
|
}
|
|
Vector3 forward = spline.InterpCurve3D(alpha, interp, ref k);
|
|
Vector3 vector = default(Vector3);
|
|
forward.x = (vector.x = forward.x - p.x);
|
|
forward.y = (vector.y = forward.y - p.y);
|
|
forward.z = (vector.z = forward.z - p.z);
|
|
MegaMatrix.SetTR(ref wtm1, p, Quaternion.LookRotation(forward, lastup));
|
|
vector = vector.normalized;
|
|
Vector3 lhs = Vector3.Cross(vector, lastup);
|
|
lastup = Vector3.Cross(lhs, vector);
|
|
return wtm1;
|
|
}
|
|
|
|
private void BuildMesh()
|
|
{
|
|
if (!mesh)
|
|
{
|
|
mesh = GetComponent<MeshFilter>().sharedMesh;
|
|
if (mesh == null)
|
|
{
|
|
updatemesh = true;
|
|
return;
|
|
}
|
|
}
|
|
if (hosespline.knots.Count == 0)
|
|
{
|
|
hosespline.AddKnot(Vector3.zero, Vector3.zero, Vector3.zero);
|
|
hosespline.AddKnot(Vector3.zero, Vector3.zero, Vector3.zero);
|
|
}
|
|
FixHoseFillet();
|
|
bool flag = freecreate;
|
|
if (!flag && (!custnode || !custnode2))
|
|
{
|
|
flag = true;
|
|
}
|
|
if ((bool)custnode && (bool)custnode2)
|
|
{
|
|
flag = false;
|
|
}
|
|
float num = 0f;
|
|
Tlocal = Matrix4x4.identity;
|
|
starty = Vector3.zero;
|
|
if (flag)
|
|
{
|
|
num = noreflength;
|
|
}
|
|
else
|
|
{
|
|
starty = custnode.transform.up;
|
|
CalcSpline();
|
|
num = Vector3.Distance(custnode.transform.position, custnode2.transform.position);
|
|
}
|
|
MegaHoseType megaHoseType = wiretype;
|
|
int num2 = segments;
|
|
if (num2 < 3)
|
|
{
|
|
num2 = 3;
|
|
}
|
|
if (rebuildcross)
|
|
{
|
|
rebuildcross = false;
|
|
int num3 = 0;
|
|
int num4 = 0;
|
|
switch (megaHoseType)
|
|
{
|
|
case MegaHoseType.Round:
|
|
NvertsPerRing = rndsides;
|
|
if (NvertsPerRing < 3)
|
|
{
|
|
NvertsPerRing = 3;
|
|
}
|
|
break;
|
|
case MegaHoseType.Rectangle:
|
|
num3 = rectfilletsides;
|
|
if (num3 < 0)
|
|
{
|
|
num3 = 0;
|
|
}
|
|
if (smooth == MegaHoseSmooth.SMOOTHNONE)
|
|
{
|
|
NvertsPerRing = ((num3 <= 0) ? 8 : (8 + 4 * (num3 - 1)));
|
|
}
|
|
else
|
|
{
|
|
NvertsPerRing = ((num3 <= 0) ? 4 : (8 + 4 * (num3 - 1)));
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
num3 = dsecfilletsides;
|
|
if (num3 < 0)
|
|
{
|
|
num3 = 0;
|
|
}
|
|
num4 = dsecrndsides;
|
|
if (num4 < 2)
|
|
{
|
|
num4 = 2;
|
|
}
|
|
int num5 = num4 - 1;
|
|
NvertsPerRing = ((num3 <= 0) ? (4 + num5) : (6 + num5 + 2 * (num3 - 1)));
|
|
break;
|
|
}
|
|
}
|
|
NvertsPerRing++;
|
|
int num6 = 0;
|
|
Nverts = (num2 + 1) * (NvertsPerRing + 1);
|
|
if (capends)
|
|
{
|
|
Nverts += 2;
|
|
}
|
|
int nvertsPerRing = NvertsPerRing;
|
|
int num7 = 6 * NvertsPerRing;
|
|
num6 = num2 * num7;
|
|
if (capends)
|
|
{
|
|
num6 += 2 * nvertsPerRing;
|
|
}
|
|
if (SaveVertex == null || SaveVertex.Length != NvertsPerRing)
|
|
{
|
|
SaveVertex = new Vector3[NvertsPerRing];
|
|
SaveUV = new Vector2[NvertsPerRing];
|
|
}
|
|
if (calcnormals && (SaveNormals == null || SaveNormals.Length != NvertsPerRing))
|
|
{
|
|
SaveNormals = new Vector3[NvertsPerRing];
|
|
}
|
|
MakeSaveVertex(NvertsPerRing, num3, num4, megaHoseType);
|
|
if (verts == null || verts.Length != Nverts)
|
|
{
|
|
verts = new Vector3[Nverts];
|
|
uvs = new Vector2[Nverts];
|
|
faces = new int[num6 * 3];
|
|
}
|
|
if (calcnormals && (normals == null || normals.Length != Nverts))
|
|
{
|
|
normals = new Vector3[Nverts];
|
|
}
|
|
}
|
|
if (Nverts == 0)
|
|
{
|
|
return;
|
|
}
|
|
bool flag2 = mapmemapme;
|
|
int num8 = 0;
|
|
int num9 = Nverts - 1;
|
|
int num10 = num9 - 1;
|
|
int nvertsPerRing2 = NvertsPerRing;
|
|
int num11 = num2 + 1;
|
|
float num12 = flexstart;
|
|
float num13 = flexstop;
|
|
int num14 = flexcycles;
|
|
float num15 = flexdiameter;
|
|
Vector2 zero = Vector2.zero;
|
|
Matrix4x4 identity = Matrix4x4.identity;
|
|
Matrix4x4 mat = Matrix4x4.identity;
|
|
Vector3 lastup = starty;
|
|
float num16 = 1f;
|
|
for (int i = 0; i < num11; i++)
|
|
{
|
|
float num17 = (float)i / (float)num2;
|
|
Vector3 vector;
|
|
if (flag)
|
|
{
|
|
vector = new Vector3(0f, 0f, num * num17);
|
|
}
|
|
else
|
|
{
|
|
int k = 0;
|
|
vector = hosespline.InterpCurve3D(num17, true, ref k);
|
|
}
|
|
identity = GetSplineMat(hosespline, num17, true, ref lastup);
|
|
if (!flag)
|
|
{
|
|
identity = Tlocal * identity;
|
|
}
|
|
if (calcnormals)
|
|
{
|
|
mat = identity;
|
|
MegaMatrix.NoTrans(ref mat);
|
|
}
|
|
float num20;
|
|
if (num17 > num12 && num17 < num13 && flexon)
|
|
{
|
|
float num18 = num13 - num12;
|
|
if (num18 < 0.01f)
|
|
{
|
|
num18 = 0.01f;
|
|
}
|
|
float num19 = (num17 - num12) / num18;
|
|
float f = (float)num14 * num19 * ((float)Math.PI * 2f) + (float)Math.PI / 2f;
|
|
num20 = 1f + num15 * (1f - Mathf.Sin(f));
|
|
}
|
|
else
|
|
{
|
|
num20 = 0f;
|
|
}
|
|
if (usebulgecurve)
|
|
{
|
|
num20 = ((num20 != 0f) ? (num20 + bulge.Evaluate(num17 + bulgeoffset) * bulgeamount) : (1f + bulge.Evaluate(num17 + bulgeoffset) * bulgeamount));
|
|
}
|
|
if (usesizecurve)
|
|
{
|
|
num16 = size.Evaluate(num17);
|
|
}
|
|
zero.x = 0.999999f * num17 * uvscale.x;
|
|
for (int j = 0; j < NvertsPerRing; j++)
|
|
{
|
|
int num21 = j;
|
|
if (flag2)
|
|
{
|
|
zero.y = SaveUV[num21].y;
|
|
uvs[num8] = zero;
|
|
}
|
|
if (num20 != 0f)
|
|
{
|
|
verts[num8] = identity.MultiplyPoint(num16 * num20 * SaveVertex[num21]);
|
|
}
|
|
else
|
|
{
|
|
verts[num8] = identity.MultiplyPoint(num16 * SaveVertex[num21]);
|
|
}
|
|
if (calcnormals)
|
|
{
|
|
normals[num8] = mat.MultiplyPoint(SaveNormals[num21]).normalized;
|
|
}
|
|
num8++;
|
|
}
|
|
if (flag2)
|
|
{
|
|
}
|
|
if (!capends)
|
|
{
|
|
continue;
|
|
}
|
|
if (i == 0)
|
|
{
|
|
verts[num10] = ((!flag) ? Tlocal.MultiplyPoint(vector) : vector);
|
|
if (flag2)
|
|
{
|
|
uvs[num10] = Vector3.zero;
|
|
}
|
|
}
|
|
else if (i == num2)
|
|
{
|
|
verts[num9] = ((!flag) ? Tlocal.MultiplyPoint(vector) : vector);
|
|
if (flag2)
|
|
{
|
|
uvs[num9] = Vector3.zero;
|
|
}
|
|
}
|
|
}
|
|
int num22 = 0;
|
|
int num23 = num10;
|
|
if (capends)
|
|
{
|
|
for (int l = 0; l < NvertsPerRing - 1; l++)
|
|
{
|
|
int num24 = l;
|
|
int num25 = ((l >= nvertsPerRing2) ? (num24 - nvertsPerRing2) : (num24 + 1));
|
|
faces[num22++] = num25;
|
|
faces[num22++] = num24;
|
|
faces[num22++] = num23;
|
|
}
|
|
}
|
|
int nvertsPerRing3 = NvertsPerRing;
|
|
for (int m = 0; m < num2; m++)
|
|
{
|
|
for (int n = 0; n < NvertsPerRing - 1; n++)
|
|
{
|
|
int num24 = m * nvertsPerRing3 + n;
|
|
int num25 = num24 + 1;
|
|
int num26 = num24 + nvertsPerRing3;
|
|
num23 = num25 + nvertsPerRing3;
|
|
faces[num22++] = num24;
|
|
faces[num22++] = num25;
|
|
faces[num22++] = num23;
|
|
faces[num22++] = num24;
|
|
faces[num22++] = num23;
|
|
faces[num22++] = num26;
|
|
}
|
|
}
|
|
int num27 = num2 * nvertsPerRing3;
|
|
num23 = Nverts - 1;
|
|
if (capends)
|
|
{
|
|
for (int num28 = 0; num28 < NvertsPerRing - 1; num28++)
|
|
{
|
|
int num24 = num28 + num27;
|
|
int num25 = ((num28 >= nvertsPerRing2) ? (num24 - nvertsPerRing2) : (num24 + 1));
|
|
faces[num22++] = num24;
|
|
faces[num22++] = num25;
|
|
faces[num22++] = num23;
|
|
}
|
|
}
|
|
mesh.Clear();
|
|
mesh.subMeshCount = 1;
|
|
mesh.vertices = verts;
|
|
mesh.uv = uvs;
|
|
mesh.triangles = faces;
|
|
if (calcnormals)
|
|
{
|
|
mesh.normals = normals;
|
|
}
|
|
else
|
|
{
|
|
mesh.RecalculateNormals();
|
|
}
|
|
mesh.RecalculateBounds();
|
|
if (optimize)
|
|
{
|
|
}
|
|
if (calctangents)
|
|
{
|
|
MegaUtils.BuildTangents(mesh);
|
|
}
|
|
if (recalcCollider)
|
|
{
|
|
if (meshCol == null)
|
|
{
|
|
meshCol = GetComponent<MeshCollider>();
|
|
}
|
|
if (meshCol != null)
|
|
{
|
|
meshCol.sharedMesh = null;
|
|
meshCol.sharedMesh = mesh;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void CalcMatrix(ref Matrix4x4 mat, float incr)
|
|
{
|
|
mat = Tlocal;
|
|
}
|
|
|
|
private static float findmappos(float curpos)
|
|
{
|
|
float num;
|
|
return num = (((num = curpos) < 0f) ? 0f : ((!(num > 1f)) ? num : 1f));
|
|
}
|
|
|
|
private void DisplayNormals()
|
|
{
|
|
}
|
|
|
|
public Vector3 GetPosition(float alpha)
|
|
{
|
|
Matrix4x4 matrix4x = base.transform.localToWorldMatrix * Tlocal;
|
|
int k = 0;
|
|
return matrix4x.MultiplyPoint(hosespline.InterpCurve3D(alpha, true, ref k));
|
|
}
|
|
}
|