override public void OnSceneViewGUI()
{
if (s_VisualizeBounds == false)
{
return;
}
Color oldColor = Handles.color;
Handles.color = Color.green;
Matrix4x4 oldMatrix = Handles.matrix;
Vector3[] points0 = new Vector3[20];
Vector3[] points1 = new Vector3[20];
Vector3[] points2 = new Vector3[20];
Handles.SetDiscSectionPoints(points0, Vector3.zero, Vector3.forward, Vector3.right, 360, 1.0f);
Handles.SetDiscSectionPoints(points1, Vector3.zero, Vector3.up, -Vector3.right, 360, 1.0f);
Handles.SetDiscSectionPoints(points2, Vector3.zero, Vector3.right, Vector3.up, 360, 1.0f);
Vector3[] points = new Vector3[points0.Length + points1.Length + points2.Length];
points0.CopyTo(points, 0);
points1.CopyTo(points, 20);
points2.CopyTo(points, 40);
foreach (ParticleSystem ps in m_ParticleSystemUI.m_ParticleSystems)
{
if (!ps.trigger.enabled)
{
continue;
}
ParticleSystem.Particle[] particles = new ParticleSystem.Particle[ps.particleCount];
int count = ps.GetParticles(particles);
Matrix4x4 transform = Matrix4x4.identity;
if (ps.main.simulationSpace == ParticleSystemSimulationSpace.Local)
{
transform = ps.GetLocalToWorldMatrix();
}
for (int i = 0; i < count; i++)
{
ParticleSystem.Particle particle = particles[i];
Vector3 size = particle.GetCurrentSize3D(ps);
float radius = System.Math.Max(size.x, System.Math.Max(size.y, size.z)) * 0.5f * ps.trigger.radiusScale;
Handles.matrix = transform * Matrix4x4.TRS(particle.position, Quaternion.identity, new Vector3(radius, radius, radius));
Handles.DrawPolyLine(points);
}
}
Handles.color = oldColor;
Handles.matrix = oldMatrix;
}
public void DrawWireframeBox(Vector3 center, Vector3 siz)
{
Vector3 vector3 = siz * 0.5f;
Vector3[] vector3Array = new Vector3[10] {
center + new Vector3(-vector3.x, -vector3.y, -vector3.z), center + new Vector3(-vector3.x, vector3.y, -vector3.z), center + new Vector3(vector3.x, vector3.y, -vector3.z), center + new Vector3(vector3.x, -vector3.y, -vector3.z), center + new Vector3(-vector3.x, -vector3.y, -vector3.z), center + new Vector3(-vector3.x, -vector3.y, vector3.z), center + new Vector3(-vector3.x, vector3.y, vector3.z), center + new Vector3(vector3.x, vector3.y, vector3.z), center + new Vector3(vector3.x, -vector3.y, vector3.z), center + new Vector3(-vector3.x, -vector3.y, vector3.z)
};
Handles.DrawPolyLine(vector3Array);
Handles.DrawLine(vector3Array[1], vector3Array[6]);
Handles.DrawLine(vector3Array[2], vector3Array[7]);
Handles.DrawLine(vector3Array[3], vector3Array[8]);
}
private void RenderCollisionBounds()
{
if (CollisionModuleUI.s_VisualizeBounds)
{
Color color = Handles.color;
Handles.color = Color.green;
Matrix4x4 matrix = Handles.matrix;
Vector3[] array = new Vector3[20];
Vector3[] array2 = new Vector3[20];
Vector3[] array3 = new Vector3[20];
Handles.SetDiscSectionPoints(array, Vector3.zero, Vector3.forward, Vector3.right, 360f, 1f);
Handles.SetDiscSectionPoints(array2, Vector3.zero, Vector3.up, -Vector3.right, 360f, 1f);
Handles.SetDiscSectionPoints(array3, Vector3.zero, Vector3.right, Vector3.up, 360f, 1f);
Vector3[] array4 = new Vector3[array.Length + array2.Length + array3.Length];
array.CopyTo(array4, 0);
array2.CopyTo(array4, 20);
array3.CopyTo(array4, 40);
ParticleSystem[] particleSystems = this.m_ParticleSystemUI.m_ParticleSystems;
for (int i = 0; i < particleSystems.Length; i++)
{
ParticleSystem particleSystem = particleSystems[i];
if (particleSystem.collision.enabled)
{
ParticleSystem.Particle[] array5 = new ParticleSystem.Particle[particleSystem.particleCount];
int particles = particleSystem.GetParticles(array5);
Matrix4x4 lhs = Matrix4x4.identity;
if (particleSystem.main.simulationSpace == ParticleSystemSimulationSpace.Local)
{
lhs = particleSystem.GetLocalToWorldMatrix();
}
for (int j = 0; j < particles; j++)
{
ParticleSystem.Particle particle = array5[j];
Vector3 currentSize3D = particle.GetCurrentSize3D(particleSystem);
float num = Math.Max(currentSize3D.x, Math.Max(currentSize3D.y, currentSize3D.z)) * 0.5f * particleSystem.collision.radiusScale;
Handles.matrix = lhs * Matrix4x4.TRS(particle.position, Quaternion.identity, new Vector3(num, num, num));
Handles.DrawPolyLine(array4);
}
}
}
Handles.color = color;
Handles.matrix = matrix;
}
}
private static float DoSimpleSpringHandle(float radius, bool editable, float rotationCount)
{
if (Event.current.alt)
{
editable = false;
}
Vector3 right = Vector3.right;
Vector3 up = Vector3.up;
if (editable)
{
// Radius handles at ends
EditorGUI.BeginChangeCheck();
Vector3 start = new Vector3(0.0f, 0.0f, -0.5f * rotationCount) * radius;
radius = Handles.SizeSlider(start, up, radius);
Vector3 end = new Vector3(0.0f, 0.0f, 0.5f * rotationCount) * radius;
radius = Handles.SizeSlider(end, up, radius);
if (EditorGUI.EndChangeCheck())
{
radius = Mathf.Max(0.0f, radius);
}
}
// Draw gizmo
if (radius > 0)
{
Vector3[] points = new Vector3[128];
for (int i = 0; i < points.Length; i++)
{
float percent = ((float)i / (points.Length - 1));
float theta = percent * Mathf.PI * 2.0f * rotationCount;
Vector3 sine = new Vector3(Mathf.Sin(theta), Mathf.Cos(theta), Mathf.Lerp(-0.5f, 0.5f, percent) * rotationCount);
points[i] = sine * radius;
}
Handles.DrawPolyLine(points);
}
return(radius);
}
private static float DoSimpleSineWaveHandle(float radius, bool editable, float heightMultiplier, float repeatCount)
{
if (Event.current.alt)
{
editable = false;
}
Vector3 right = Vector3.right;
Vector3 up = Vector3.up;
if (editable)
{
// Radius handles at ends
EditorGUI.BeginChangeCheck();
radius = Handles.SizeSlider(Vector3.zero, right, radius);
radius = Handles.SizeSlider(Vector3.zero, -right, radius);
if (EditorGUI.EndChangeCheck())
{
radius = Mathf.Max(0.0f, radius);
}
}
// Draw gizmo
if (radius > 0)
{
Vector3 start = -right * radius;
Vector3[] points = new Vector3[128];
for (int i = 0; i < points.Length; i++)
{
float percent = ((float)i / (points.Length - 1));
Vector3 sine = start + right * (radius * percent) * 2.0f;
sine += up * Mathf.Sin(percent * Mathf.PI * 2.0f * repeatCount) * radius * heightMultiplier;
points[i] = sine;
}
Handles.DrawPolyLine(points);
}
return(radius);
}
internal static void RectangleHandleCap(int controlID, Vector3 position, Quaternion rotation, Vector2 size, EventType eventType)
{
switch (eventType)
{
case (EventType.Layout):
// TODO: Create DistanceToRectangle
HandleUtility.AddControl(controlID, HandleUtility.DistanceToRectangleInternal(position, rotation, size));
break;
case (EventType.Repaint):
Vector3 sideways = rotation * new Vector3(size.x, 0, 0);
Vector3 up = rotation * new Vector3(0, size.y, 0);
s_RectangleHandlePointsCache[0] = position + sideways + up;
s_RectangleHandlePointsCache[1] = position + sideways - up;
s_RectangleHandlePointsCache[2] = position - sideways - up;
s_RectangleHandlePointsCache[3] = position - sideways + up;
s_RectangleHandlePointsCache[4] = position + sideways + up;
Handles.DrawPolyLine(s_RectangleHandlePointsCache);
break;
}
}
private static float DoSimpleSquareHandle(float size, bool editable)
{
if (Event.current.alt)
{
editable = false;
}
Vector3 right = Vector3.right;
Vector3 up = Vector3.up;
if (editable)
{
// Size handles at edges
EditorGUI.BeginChangeCheck();
size = Handles.SizeSlider(Vector3.zero, up, size);
size = Handles.SizeSlider(Vector3.zero, -up, size);
size = Handles.SizeSlider(Vector3.zero, right, size);
size = Handles.SizeSlider(Vector3.zero, -right, size);
if (EditorGUI.EndChangeCheck())
{
size = Mathf.Max(0.0f, size);
}
}
// Draw gizmo
if (size > 0)
{
Vector3[] points = new Vector3[5];
points[0] = up * size + right * size;
points[1] = -up * size + right * size;
points[2] = -up * size - right * size;
points[3] = up * size - right * size;
points[4] = points[0];
Handles.DrawPolyLine(points);
}
return(size);
}
public static void DrawPolyLineWithShadow(Color shadowColor, Vector2 screenOffset, params Vector3[] points)
{
Camera current = Camera.current;
if ((current != null) && (Event.current.type == EventType.Repaint))
{
if (s_TempVectors.Length != points.Length)
{
s_TempVectors = new Vector3[points.Length];
}
for (int i = 0; i < points.Length; i++)
{
s_TempVectors[i] = current.ScreenToWorldPoint(current.WorldToScreenPoint(points[i]) + screenOffset);
}
Color color = Handles.color;
shadowColor.a *= color.a;
Handles.color = shadowColor;
Handles.DrawPolyLine(s_TempVectors);
Handles.color = color;
Handles.DrawPolyLine(points);
}
}
public static void DrawWireCube(Vector3 center, Vector3 size)
{
Vector3 halfsize = size * 0.5f;
Vector3[] points = new Vector3[10];
points[0] = center + new Vector3(-halfsize.x, -halfsize.y, -halfsize.z);
points[1] = center + new Vector3(-halfsize.x, halfsize.y, -halfsize.z);
points[2] = center + new Vector3(halfsize.x, halfsize.y, -halfsize.z);
points[3] = center + new Vector3(halfsize.x, -halfsize.y, -halfsize.z);
points[4] = center + new Vector3(-halfsize.x, -halfsize.y, -halfsize.z);
points[5] = center + new Vector3(-halfsize.x, -halfsize.y, halfsize.z);
points[6] = center + new Vector3(-halfsize.x, halfsize.y, halfsize.z);
points[7] = center + new Vector3(halfsize.x, halfsize.y, halfsize.z);
points[8] = center + new Vector3(halfsize.x, -halfsize.y, halfsize.z);
points[9] = center + new Vector3(-halfsize.x, -halfsize.y, halfsize.z);
Handles.DrawPolyLine(points);
Handles.DrawLine(points[1], points[6]);
Handles.DrawLine(points[2], points[7]);
Handles.DrawLine(points[3], points[8]);
}
public static void DrawPolyLineWithShadow(Color shadowColor, Vector2 screenOffset, params Vector3[] points)
{
Camera current = Camera.current;
if (!(bool)((Object)current) || Event.current.type != EventType.Repaint)
{
return;
}
if (RectHandles.s_TempVectors.Length != points.Length)
{
RectHandles.s_TempVectors = new Vector3[points.Length];
}
for (int index = 0; index < points.Length; ++index)
{
RectHandles.s_TempVectors[index] = current.ScreenToWorldPoint(current.WorldToScreenPoint(points[index]) + (Vector3)screenOffset);
}
Color color = Handles.color;
shadowColor.a = shadowColor.a * color.a;
Handles.color = shadowColor;
Handles.DrawPolyLine(RectHandles.s_TempVectors);
Handles.color = color;
Handles.DrawPolyLine(points);
}
public static void DrawCurveWrapped(float minTime, float maxTime, float rangeStart, float rangeEnd,
WrapMode preWrap, WrapMode postWrap, Color color, Matrix4x4 transform, Vector3[] points, Color wrapColor)
{
if (points.Length == 0)
{
return;
}
int minRep;
int maxRep;
if (rangeEnd - rangeStart != 0)
{
minRep = Mathf.FloorToInt((minTime - rangeStart) / (rangeEnd - rangeStart));
maxRep = Mathf.CeilToInt((maxTime - rangeEnd) / (rangeEnd - rangeStart));
// Prevent too many loops from being rendered at one time.
if (minRep < -kMaximumLoops)
{
preWrap = WrapMode.Clamp;
}
if (maxRep > kMaximumLoops)
{
postWrap = WrapMode.Clamp;
}
}
else
{
preWrap = WrapMode.Clamp;
postWrap = WrapMode.Clamp;
minRep = (minTime < rangeStart ? -1 : 0);
maxRep = (maxTime > rangeEnd ? 1 : 0);
}
int last = points.Length - 1;
// Draw curve itself
Handles.color = color;
List <Vector3> line = new List <Vector3>();
if (minRep <= 0 && maxRep >= 0)
{
// Use line drawing with minimum segment length. Faster for large data sets
DrawPolyLine(transform, 2, points);
}
else
{
Handles.DrawPolyLine(points);
}
// Draw wrapping
Handles.color = new Color(wrapColor.r, wrapColor.g, wrapColor.b, wrapColor.a * color.a);
// Draw pre wrapping
if (preWrap == WrapMode.Loop)
{
line = new List <Vector3>();
for (int r = minRep; r < 0; r++)
{
for (int i = 0; i < points.Length; i++)
{
Vector3 point = points[i];
point.x += r * (rangeEnd - rangeStart);
point = transform.MultiplyPoint(point);
line.Add(point);
}
}
line.Add(transform.MultiplyPoint(points[0]));
Handles.DrawPolyLine(line.ToArray());
}
else if (preWrap == WrapMode.PingPong)
{
line = new List <Vector3>();
for (int r = minRep; r < 0; r++)
{
for (int i = 0; i < points.Length; i++)
{
if (r / 2 == r / 2f)
{
Vector3 point = points[i];
point.x += r * (rangeEnd - rangeStart);
point = transform.MultiplyPoint(point);
line.Add(point);
}
else
{
Vector3 point = points[last - i];
point.x = -point.x + (r + 1) * (rangeEnd - rangeStart) + rangeStart * 2;
point = transform.MultiplyPoint(point);
line.Add(point);
}
}
}
Handles.DrawPolyLine(line.ToArray());
}
else
{
if (minRep < 0)
{
Handles.DrawPolyLine(new Vector3[]
{
transform.MultiplyPoint(new Vector3(minTime, points[0].y, 0)),
transform.MultiplyPoint(new Vector3(Mathf.Min(maxTime, points[0].x), points[0].y, 0))
});
}
}
// Draw post wrapping
if (postWrap == WrapMode.Loop)
{
line = new List <Vector3>();
line.Add(transform.MultiplyPoint(points[last]));
for (int r = 1; r <= maxRep; r++)
{
for (int i = 0; i < points.Length; i++)
{
Vector3 point = points[i];
point.x += r * (rangeEnd - rangeStart);
point = transform.MultiplyPoint(point);
line.Add(point);
}
}
Handles.DrawPolyLine(line.ToArray());
}
else if (postWrap == WrapMode.PingPong)
{
line = new List <Vector3>();
for (int r = 1; r <= maxRep; r++)
{
for (int i = 0; i < points.Length; i++)
{
if (r / 2 == r / 2f)
{
Vector3 point = points[i];
point.x += r * (rangeEnd - rangeStart);
point = transform.MultiplyPoint(point);
line.Add(point);
}
else
{
Vector3 point = points[last - i];
point.x = -point.x + (r + 1) * (rangeEnd - rangeStart) + rangeStart * 2;
point = transform.MultiplyPoint(point);
line.Add(point);
}
}
}
Handles.DrawPolyLine(line.ToArray());
}
else
{
if (maxRep > 0)
{
Handles.DrawPolyLine(new Vector3[]
{
transform.MultiplyPoint(new Vector3(Mathf.Max(minTime, points[last].x), points[last].y, 0)),
transform.MultiplyPoint(new Vector3(maxTime, points[last].y, 0))
});
}
}
}
public static void DrawCurveWrapped(float minTime, float maxTime, float rangeStart, float rangeEnd, WrapMode preWrap, WrapMode postWrap, Color color, Matrix4x4 transform, Vector3[] points, Color wrapColor)
{
if (points.Length == 0)
{
return;
}
int num;
int num2;
if (rangeEnd - rangeStart != 0f)
{
num = Mathf.FloorToInt((minTime - rangeStart) / (rangeEnd - rangeStart));
num2 = Mathf.CeilToInt((maxTime - rangeEnd) / (rangeEnd - rangeStart));
}
else
{
preWrap = WrapMode.Once;
postWrap = WrapMode.Once;
num = ((minTime >= rangeStart) ? 0 : -1);
num2 = ((maxTime <= rangeEnd) ? 0 : 1);
}
int num3 = points.Length - 1;
Handles.color = color;
List <Vector3> list = new List <Vector3>();
if (num <= 0 && num2 >= 0)
{
NormalCurveRenderer.DrawPolyLine(transform, 2f, points);
}
else
{
Handles.DrawPolyLine(points);
}
Handles.color = new Color(wrapColor.r, wrapColor.g, wrapColor.b, wrapColor.a * color.a);
if (preWrap == WrapMode.Loop)
{
list = new List <Vector3>();
for (int i = num; i < 0; i++)
{
for (int j = 0; j < points.Length; j++)
{
Vector3 vector = points[j];
vector.x += (float)i * (rangeEnd - rangeStart);
vector = transform.MultiplyPoint(vector);
list.Add(vector);
}
}
list.Add(transform.MultiplyPoint(points[0]));
Handles.DrawPolyLine(list.ToArray());
}
else if (preWrap == WrapMode.PingPong)
{
list = new List <Vector3>();
for (int k = num; k < 0; k++)
{
for (int l = 0; l < points.Length; l++)
{
if ((float)(k / 2) == (float)k / 2f)
{
Vector3 vector2 = points[l];
vector2.x += (float)k * (rangeEnd - rangeStart);
vector2 = transform.MultiplyPoint(vector2);
list.Add(vector2);
}
else
{
Vector3 vector3 = points[num3 - l];
vector3.x = -vector3.x + (float)(k + 1) * (rangeEnd - rangeStart) + rangeStart * 2f;
vector3 = transform.MultiplyPoint(vector3);
list.Add(vector3);
}
}
}
Handles.DrawPolyLine(list.ToArray());
}
else if (num < 0)
{
Handles.DrawPolyLine(new Vector3[]
{
transform.MultiplyPoint(new Vector3(minTime, points[0].y, 0f)),
transform.MultiplyPoint(new Vector3(Mathf.Min(maxTime, points[0].x), points[0].y, 0f))
});
}
if (postWrap == WrapMode.Loop)
{
list = new List <Vector3>();
list.Add(transform.MultiplyPoint(points[num3]));
for (int m = 1; m <= num2; m++)
{
for (int n = 0; n < points.Length; n++)
{
Vector3 vector4 = points[n];
vector4.x += (float)m * (rangeEnd - rangeStart);
vector4 = transform.MultiplyPoint(vector4);
list.Add(vector4);
}
}
Handles.DrawPolyLine(list.ToArray());
}
else if (postWrap == WrapMode.PingPong)
{
list = new List <Vector3>();
for (int num4 = 1; num4 <= num2; num4++)
{
for (int num5 = 0; num5 < points.Length; num5++)
{
if ((float)(num4 / 2) == (float)num4 / 2f)
{
Vector3 vector5 = points[num5];
vector5.x += (float)num4 * (rangeEnd - rangeStart);
vector5 = transform.MultiplyPoint(vector5);
list.Add(vector5);
}
else
{
Vector3 vector6 = points[num3 - num5];
vector6.x = -vector6.x + (float)(num4 + 1) * (rangeEnd - rangeStart) + rangeStart * 2f;
vector6 = transform.MultiplyPoint(vector6);
list.Add(vector6);
}
}
}
Handles.DrawPolyLine(list.ToArray());
}
else if (num2 > 0)
{
Handles.DrawPolyLine(new Vector3[]
{
transform.MultiplyPoint(new Vector3(Mathf.Max(minTime, points[num3].x), points[num3].y, 0f)),
transform.MultiplyPoint(new Vector3(maxTime, points[num3].y, 0f))
});
}
}
public static void DrawCurveWrapped(float minTime, float maxTime, float rangeStart, float rangeEnd, WrapMode preWrap, WrapMode postWrap, Color color, Matrix4x4 transform, Vector3[] points, Color wrapColor)
{
if (points.Length != 0)
{
int num;
int num2;
if ((rangeEnd - rangeStart) != 0f)
{
num = Mathf.FloorToInt((minTime - rangeStart) / (rangeEnd - rangeStart));
num2 = Mathf.CeilToInt((maxTime - rangeEnd) / (rangeEnd - rangeStart));
}
else
{
preWrap = WrapMode.Once;
postWrap = WrapMode.Once;
num = (minTime >= rangeStart) ? 0 : -1;
num2 = (maxTime <= rangeEnd) ? 0 : 1;
}
int index = points.Length - 1;
Handles.color = color;
List <Vector3> list = new List <Vector3>();
if ((num <= 0) && (num2 >= 0))
{
DrawPolyLine(transform, 2f, points);
}
else
{
Handles.DrawPolyLine(points);
}
Handles.color = new Color(wrapColor.r, wrapColor.g, wrapColor.b, wrapColor.a * color.a);
if (preWrap == WrapMode.Loop)
{
list = new List <Vector3>();
for (int i = num; i < 0; i++)
{
for (int j = 0; j < points.Length; j++)
{
Vector3 v = points[j];
v.x += i * (rangeEnd - rangeStart);
v = transform.MultiplyPoint(v);
list.Add(v);
}
}
list.Add(transform.MultiplyPoint(points[0]));
Handles.DrawPolyLine(list.ToArray());
}
else if (preWrap == WrapMode.PingPong)
{
list = new List <Vector3>();
for (int k = num; k < 0; k++)
{
for (int m = 0; m < points.Length; m++)
{
if ((k / 2) == (((float)k) / 2f))
{
Vector3 vector2 = points[m];
vector2.x += k * (rangeEnd - rangeStart);
vector2 = transform.MultiplyPoint(vector2);
list.Add(vector2);
}
else
{
Vector3 vector3 = points[index - m];
vector3.x = (-vector3.x + ((k + 1) * (rangeEnd - rangeStart))) + (rangeStart * 2f);
vector3 = transform.MultiplyPoint(vector3);
list.Add(vector3);
}
}
}
Handles.DrawPolyLine(list.ToArray());
}
else if (num < 0)
{
Vector3[] vectorArray1 = new Vector3[] { transform.MultiplyPoint(new Vector3(minTime, points[0].y, 0f)), transform.MultiplyPoint(new Vector3(Mathf.Min(maxTime, points[0].x), points[0].y, 0f)) };
Handles.DrawPolyLine(vectorArray1);
}
if (postWrap == WrapMode.Loop)
{
list = new List <Vector3> {
transform.MultiplyPoint(points[index])
};
for (int n = 1; n <= num2; n++)
{
for (int num9 = 0; num9 < points.Length; num9++)
{
Vector3 vector4 = points[num9];
vector4.x += n * (rangeEnd - rangeStart);
vector4 = transform.MultiplyPoint(vector4);
list.Add(vector4);
}
}
Handles.DrawPolyLine(list.ToArray());
}
else if (postWrap == WrapMode.PingPong)
{
list = new List <Vector3>();
for (int num10 = 1; num10 <= num2; num10++)
{
for (int num11 = 0; num11 < points.Length; num11++)
{
if ((num10 / 2) == (((float)num10) / 2f))
{
Vector3 vector5 = points[num11];
vector5.x += num10 * (rangeEnd - rangeStart);
vector5 = transform.MultiplyPoint(vector5);
list.Add(vector5);
}
else
{
Vector3 vector6 = points[index - num11];
vector6.x = (-vector6.x + ((num10 + 1) * (rangeEnd - rangeStart))) + (rangeStart * 2f);
vector6 = transform.MultiplyPoint(vector6);
list.Add(vector6);
}
}
}
Handles.DrawPolyLine(list.ToArray());
}
else if (num2 > 0)
{
Vector3[] vectorArray2 = new Vector3[] { transform.MultiplyPoint(new Vector3(Mathf.Max(minTime, points[index].x), points[index].y, 0f)), transform.MultiplyPoint(new Vector3(maxTime, points[index].y, 0f)) };
Handles.DrawPolyLine(vectorArray2);
}
}
}
public static void DrawCurveWrapped(float minTime, float maxTime, float rangeStart, float rangeEnd, WrapMode preWrap, WrapMode postWrap, Color color, Matrix4x4 transform, Vector3[] points, Color wrapColor)
{
if (points.Length == 0)
{
return;
}
int num1;
int num2;
if ((double)rangeEnd - (double)rangeStart != 0.0)
{
num1 = Mathf.FloorToInt((float)(((double)minTime - (double)rangeStart) / ((double)rangeEnd - (double)rangeStart)));
num2 = Mathf.CeilToInt((float)(((double)maxTime - (double)rangeEnd) / ((double)rangeEnd - (double)rangeStart)));
}
else
{
preWrap = WrapMode.Once;
postWrap = WrapMode.Once;
num1 = (double)minTime >= (double)rangeStart ? 0 : -1;
num2 = (double)maxTime <= (double)rangeEnd ? 0 : 1;
}
int index1 = points.Length - 1;
Handles.color = color;
List <Vector3> vector3List1 = new List <Vector3>();
if (num1 <= 0 && num2 >= 0)
{
NormalCurveRenderer.DrawPolyLine(transform, 2f, points);
}
else
{
Handles.DrawPolyLine(points);
}
Handles.color = new Color(wrapColor.r, wrapColor.g, wrapColor.b, wrapColor.a * color.a);
if (preWrap == WrapMode.Loop)
{
List <Vector3> vector3List2 = new List <Vector3>();
for (int index2 = num1; index2 < 0; ++index2)
{
for (int index3 = 0; index3 < points.Length; ++index3)
{
Vector3 point = points[index3];
point.x += (float)index2 * (rangeEnd - rangeStart);
Vector3 vector3 = transform.MultiplyPoint(point);
vector3List2.Add(vector3);
}
}
vector3List2.Add(transform.MultiplyPoint(points[0]));
Handles.DrawPolyLine(vector3List2.ToArray());
}
else if (preWrap == WrapMode.PingPong)
{
List <Vector3> vector3List2 = new List <Vector3>();
for (int index2 = num1; index2 < 0; ++index2)
{
for (int index3 = 0; index3 < points.Length; ++index3)
{
if ((double)(index2 / 2) == (double)index2 / 2.0)
{
Vector3 point = points[index3];
point.x += (float)index2 * (rangeEnd - rangeStart);
Vector3 vector3 = transform.MultiplyPoint(point);
vector3List2.Add(vector3);
}
else
{
Vector3 point = points[index1 - index3];
point.x = (float)(-(double)point.x + (double)(index2 + 1) * ((double)rangeEnd - (double)rangeStart) + (double)rangeStart * 2.0);
Vector3 vector3 = transform.MultiplyPoint(point);
vector3List2.Add(vector3);
}
}
}
Handles.DrawPolyLine(vector3List2.ToArray());
}
else if (num1 < 0)
{
Handles.DrawPolyLine(transform.MultiplyPoint(new Vector3(minTime, points[0].y, 0.0f)), transform.MultiplyPoint(new Vector3(Mathf.Min(maxTime, points[0].x), points[0].y, 0.0f)));
}
if (postWrap == WrapMode.Loop)
{
List <Vector3> vector3List2 = new List <Vector3>();
vector3List2.Add(transform.MultiplyPoint(points[index1]));
for (int index2 = 1; index2 <= num2; ++index2)
{
for (int index3 = 0; index3 < points.Length; ++index3)
{
Vector3 point = points[index3];
point.x += (float)index2 * (rangeEnd - rangeStart);
Vector3 vector3 = transform.MultiplyPoint(point);
vector3List2.Add(vector3);
}
}
Handles.DrawPolyLine(vector3List2.ToArray());
}
else if (postWrap == WrapMode.PingPong)
{
List <Vector3> vector3List2 = new List <Vector3>();
for (int index2 = 1; index2 <= num2; ++index2)
{
for (int index3 = 0; index3 < points.Length; ++index3)
{
if ((double)(index2 / 2) == (double)index2 / 2.0)
{
Vector3 point = points[index3];
point.x += (float)index2 * (rangeEnd - rangeStart);
Vector3 vector3 = transform.MultiplyPoint(point);
vector3List2.Add(vector3);
}
else
{
Vector3 point = points[index1 - index3];
point.x = (float)(-(double)point.x + (double)(index2 + 1) * ((double)rangeEnd - (double)rangeStart) + (double)rangeStart * 2.0);
Vector3 vector3 = transform.MultiplyPoint(point);
vector3List2.Add(vector3);
}
}
}
Handles.DrawPolyLine(vector3List2.ToArray());
}
else
{
if (num2 <= 0)
{
return;
}
Handles.DrawPolyLine(transform.MultiplyPoint(new Vector3(Mathf.Max(minTime, points[index1].x), points[index1].y, 0.0f)), transform.MultiplyPoint(new Vector3(maxTime, points[index1].y, 0.0f)));
}
}
