public static double ScreenPointToSplinePercent(SplineComputer computer, Vector2 screenPoint)
{
SplinePoint[] points = computer.GetPoints();
float closestDistance = (screenPoint - HandleUtility.WorldToGUIPoint(points[0].position)).sqrMagnitude;
double closestPercent = 0.0;
double add = computer.moveStep;
if (computer.type == Spline.Type.Linear)
{
add /= 2f;
}
int count = 0;
for (double i = add; i < 1.0; i += add)
{
SplineResult result = computer.Evaluate(i);
Vector2 point = HandleUtility.WorldToGUIPoint(result.position);
float dist = (point - screenPoint).sqrMagnitude;
if (dist < closestDistance)
{
closestDistance = dist;
closestPercent = i;
}
count++;
}
return(closestPercent);
}
void AddConnection(SplineComputer computer, int pointIndex)
{
Node node = (Node)target;
Node.Connection[] connections = node.GetConnections();
if (EditorUtility.DisplayDialog("Link point?", "Add point " + pointIndex + " to connections?", "Yes", "No"))
{
Undo.RecordObject(addComp, "Add connection");
Undo.RecordObject(node, "Add Connection");
if (connections.Length == 0)
{
switch (EditorUtility.DisplayDialogComplex("Align node to point?", "This is the first connection for the node, would you like to snap or align the node's Transform the spline point.", "No", "Snap", "Snap and Align"))
{
case 1: SplinePoint point = addComp.GetPoint(pointIndex);
node.transform.position = point.position;
break;
case 2:
SplineResult result = addComp.Evaluate((double)pointIndex / (addComp.pointCount - 1));
node.transform.position = result.position;
node.transform.rotation = result.rotation;
break;
}
}
node.AddConnection(computer, pointIndex);
addComp = null;
addPoint = 0;
SceneView.RepaintAll();
Repaint();
}
}
void PaintHeightMap(Terrain terrain, SplineComputer computer, ref float[,] drawLayer, ref float[,] alphaLayer)
{
if (heights == null)
{
GetBase();
}
SplineResult[] results = new SplineResult[computer.iterations];
for (int i = 0; i < results.Length; i++)
{
float percent = (float)i / (results.Length - 1);
results[i] = computer.Evaluate(percent);
}
Draw(results, ref drawLayer, ref alphaLayer);
}
void PaintHeightMap(Terrain terrain, SplineComputer computer, ref float[,] drawLayer, ref float[,] alphaLayer)
{
if (heights == null)
{
GetBase();
}
SplineSample[] results = new SplineSample[computer.iterations];
computer.Evaluate(ref results, clipFrom, clipTo);
/*
* for(int i = 0; i < results.Length; i++)
* {
* float percent = (float)i/(results.Length-1);
* results[i] = computer.Evaluate(percent);
* }
*/
Draw(results, ref drawLayer, ref alphaLayer);
}
public static void DrawSplineComputer(SplineComputer comp, double fromPercent = 0.0, double toPercent = 1.0, float alpha = 1f)
{
if (comp == null)
{
return;
}
Color prevColor = Handles.color;
Color orange = new Color(1f, 0.564f, 0f);
Color handleColor = comp.hasMorph && !MorphWindow.editShapeMode ? orange : comp.editorPathColor;
handleColor.a = alpha;
Handles.color = handleColor;
if (comp.pointCount < 2)
{
return;
}
double add = comp.moveStep;
if (add < 0.0025)
{
add = 0.0025;
}
if (comp.type == Spline.Type.BSpline && comp.pointCount > 1)
{
SplinePoint[] compPoints = comp.GetPoints();
Handles.color = new Color(handleColor.r, handleColor.g, handleColor.b, 0.5f * alpha);
for (int i = 0; i < compPoints.Length - 1; i++)
{
Handles.DrawLine(compPoints[i].position, compPoints[i + 1].position);
}
Handles.color = handleColor;
}
if (!comp.drawThinckness)
{
double percent = fromPercent;
fromPos = comp.EvaluatePosition(percent);
toPos = Vector3.zero;
while (true)
{
percent = DMath.Move(percent, toPercent, add);
toPos = comp.EvaluatePosition(percent);
Handles.DrawLine(fromPos, toPos);
if (percent == toPercent)
{
break;
}
fromPos = toPos;
}
return;
}
else
{
Camera editorCamera = SceneView.currentDrawingSceneView.camera;
double percent = fromPercent;
comp.Evaluate(fromResult, percent);
Vector3 fromNormal = fromResult.normal;
if (comp.billboardThickness)
{
fromNormal = (editorCamera.transform.position - fromResult.position).normalized;
}
Vector3 fromRight = Vector3.Cross(fromResult.direction, fromNormal).normalized *fromResult.size * 0.5f;
while (true)
{
percent = DMath.Move(percent, toPercent, add);
toResult = comp.Evaluate(percent);
Vector3 toNormal = toResult.normal;
if (comp.billboardThickness)
{
toNormal = (editorCamera.transform.position - toResult.position).normalized;
}
Vector3 toRight = Vector3.Cross(toResult.direction, toNormal).normalized *toResult.size * 0.5f;
Handles.DrawLine(fromResult.position + fromRight, toResult.position + toRight);
Handles.DrawLine(fromResult.position - fromRight, toResult.position - toRight);
Handles.DrawLine(fromResult.position + fromRight, fromResult.position - fromRight);
if (percent == toPercent)
{
break;
}
fromResult = toResult;
fromNormal = toNormal;
fromRight = toRight;
}
}
Handles.color = prevColor;
}
public void Generate()
{
if (_extrudeComputer != null)
{
_extrudeComputer.Evaluate(ref extrudeResults, _extrudeFrom, _extrudeTo);
}
int capVertexCount = clippedSamples.Length;
int wallVertexCount = 0;
int totalVertexCount = 0;
if (computer.isClosed)
{
capVertexCount--;
}
bool pathExtrude = _extrudeComputer != null && extrudeResults.Length > 0;
bool simpleExtrude = !pathExtrude && _extrude != 0f;
totalVertexCount = capVertexCount;
if (pathExtrude)
{
wallVertexCount = clippedSamples.Length * extrudeResults.Length;
totalVertexCount = capVertexCount * 2 + wallVertexCount;
}
else if (simpleExtrude)
{
wallVertexCount = clippedSamples.Length * 2;
totalVertexCount = capVertexCount * 2 + wallVertexCount;
}
if (tsMesh.vertexCount != totalVertexCount)
{
tsMesh.vertices = new Vector3[totalVertexCount];
tsMesh.normals = new Vector3[totalVertexCount];
tsMesh.colors = new Color[totalVertexCount];
tsMesh.uv = new Vector2[totalVertexCount];
}
Vector3 avgPos = Vector3.zero;
Vector3 avgNormal = Vector3.zero;
for (int i = 0; i < capVertexCount; i++)
{
tsMesh.vertices[i] = clippedSamples[i].position;
tsMesh.normals[i] = clippedSamples[i].normal;
tsMesh.colors[i] = clippedSamples[i].color;
tsMesh.colors[i] *= color;
avgPos += tsMesh.vertices[i];
avgNormal += tsMesh.normals[i];
}
avgNormal.Normalize();
avgPos /= capVertexCount;
GetProjectedVertices(tsMesh.vertices, avgNormal, avgPos, capVertexCount);
Vector2 min = projectedVerts[0];
Vector2 max = projectedVerts[0];
for (int i = 1; i < projectedVerts.Length; i++)
{
if (min.x < projectedVerts[i].x)
{
min.x = projectedVerts[i].x;
}
if (min.y < projectedVerts[i].y)
{
min.y = projectedVerts[i].y;
}
if (max.x > projectedVerts[i].x)
{
max.x = projectedVerts[i].x;
}
if (max.y > projectedVerts[i].y)
{
max.y = projectedVerts[i].y;
}
}
for (int i = 0; i < projectedVerts.Length; i++)
{
tsMesh.uv[i].x = Mathf.InverseLerp(max.x, min.x, projectedVerts[i].x) * uvScale.x - uvScale.x * 0.5f + uvOffset.x + 0.5f;
tsMesh.uv[i].y = Mathf.InverseLerp(min.y, max.y, projectedVerts[i].y) * uvScale.y - uvScale.y * 0.5f + uvOffset.y + 0.5f;
}
bool clockwise = IsClockwise(projectedVerts);
bool flipCap = flipFaces;
bool flipSide = flipFaces;
if (!clockwise)
{
flipSide = !flipSide;
}
if (simpleExtrude && _extrude < 0f)
{
flipCap = !flipCap;
flipSide = !flipSide;
}
GenerateCapTris(flipCap);
if (flipCap)
{
for (int i = 0; i < capVertexCount; i++)
{
tsMesh.normals[i] *= -1f;
}
}
if (pathExtrude)
{
GetIdentityVerts(avgPos, avgNormal, clockwise);
//Generate cap vertices with flipped normals
for (int i = 0; i < capVertexCount; i++)
{
tsMesh.vertices[i + capVertexCount] = extrudeResults[0].position + extrudeResults[0].rotation * identityVertices[i];
tsMesh.normals[i + capVertexCount] = -extrudeResults[0].direction;
tsMesh.colors[i + capVertexCount] = tsMesh.colors[i] * extrudeResults[0].color;
tsMesh.uv[i + capVertexCount] = new Vector2(1f - tsMesh.uv[i].x, tsMesh.uv[i].y);
tsMesh.vertices[i] = extrudeResults[extrudeResults.Length - 1].position + extrudeResults[extrudeResults.Length - 1].rotation * identityVertices[i];
tsMesh.normals[i] = extrudeResults[extrudeResults.Length - 1].direction;
tsMesh.colors[i] *= extrudeResults[extrudeResults.Length - 1].color;
}
//Add wall vertices
float totalLength = 0f;
for (int i = 0; i < extrudeResults.Length; i++)
{
if (_uniformUvs && i > 0)
{
totalLength += Vector3.Distance(extrudeResults[i].position, extrudeResults[i - 1].position);
}
int startIndex = capVertexCount * 2 + i * clippedSamples.Length;
for (int n = 0; n < identityVertices.Length; n++)
{
tsMesh.vertices[startIndex + n] = extrudeResults[i].position + extrudeResults[i].rotation * identityVertices[n];
tsMesh.normals[startIndex + n] = extrudeResults[i].rotation * identityNormals[n];
if (_uniformUvs)
{
tsMesh.uv[startIndex + n] = new Vector2((float)n / (identityVertices.Length - 1) * _sideUvScale.x + _sideUvOffset.x, totalLength * _sideUvScale.y + _sideUvOffset.y);
}
else
{
tsMesh.uv[startIndex + n] = new Vector2((float)n / (identityVertices.Length - 1) * _sideUvScale.x + _sideUvOffset.x, (float)i / (extrudeResults.Length - 1) * _sideUvScale.y + _sideUvOffset.y);
}
if (clockwise)
{
tsMesh.uv[startIndex + n].x = 1f - tsMesh.uv[startIndex + n].x;
}
}
}
wallTris = MeshUtility.GeneratePlaneTriangles(clippedSamples.Length - 1, extrudeResults.Length, flipSide);
tsMesh.triangles = new int[capTris.Length * 2 + wallTris.Length];
int written = WriteTris(ref capTris, ref tsMesh.triangles, 0, 0, false);
written = WriteTris(ref capTris, ref tsMesh.triangles, capVertexCount, written, true);
written = WriteTris(ref wallTris, ref tsMesh.triangles, capVertexCount * 2, written, false);
}
else if (simpleExtrude)
{
//Duplicate cap vertices with flipped normals
for (int i = 0; i < capVertexCount; i++)
{
tsMesh.vertices[i + capVertexCount] = tsMesh.vertices[i];
if (_expand != 0f)
{
tsMesh.vertices[i + capVertexCount] += (clockwise ? -clippedSamples[i].right : clippedSamples[i].right) * _expand;
}
tsMesh.normals[i + capVertexCount] = -tsMesh.normals[i];
tsMesh.colors[i + capVertexCount] = tsMesh.colors[i];
tsMesh.uv[i + capVertexCount] = new Vector2(1f - tsMesh.uv[i].x, tsMesh.uv[i].y);
tsMesh.vertices[i] += avgNormal * _extrude;
if (_expand != 0f)
{
tsMesh.vertices[i] += (clockwise ? -clippedSamples[i].right : clippedSamples[i].right) * _expand;
}
}
//Add wall vertices
for (int i = 0; i < clippedSamples.Length; i++)
{
tsMesh.vertices[i + capVertexCount * 2] = clippedSamples[i].position;
if (_expand != 0f)
{
tsMesh.vertices[i + capVertexCount * 2] += (clockwise ? -clippedSamples[i].right : clippedSamples[i].right) * _expand;
}
tsMesh.normals[i + capVertexCount * 2] = clockwise ? -clippedSamples[i].right : clippedSamples[i].right;
tsMesh.colors[i + capVertexCount * 2] = clippedSamples[i].color;
tsMesh.uv[i + capVertexCount * 2] = new Vector2((float)i / (capVertexCount - 1) * _sideUvScale.x + _sideUvOffset.x, 0f + _sideUvOffset.y);
if (clockwise)
{
tsMesh.uv[i + capVertexCount * 2].x = 1f - tsMesh.uv[i + capVertexCount * 2].x;
}
tsMesh.vertices[i + capVertexCount * 2 + clippedSamples.Length] = tsMesh.vertices[i + capVertexCount * 2] + avgNormal * _extrude;
tsMesh.normals[i + capVertexCount * 2 + clippedSamples.Length] = clockwise ? -clippedSamples[i].right : clippedSamples[i].right;
tsMesh.colors[i + capVertexCount * 2 + clippedSamples.Length] = clippedSamples[i].color;
if (_uniformUvs)
{
tsMesh.uv[i + capVertexCount * 2 + clippedSamples.Length] = new Vector2((float)i / (capVertexCount - 1) * _sideUvScale.x + _sideUvOffset.x, _extrude * _sideUvScale.y + _sideUvOffset.y);
}
else
{
tsMesh.uv[i + capVertexCount * 2 + clippedSamples.Length] = new Vector2((float)i / (capVertexCount - 1) * _sideUvScale.x + _sideUvOffset.x, 1f * _sideUvScale.y + _sideUvOffset.y);
}
if (clockwise)
{
tsMesh.uv[i + capVertexCount * 2 + clippedSamples.Length].x = 1f - tsMesh.uv[i + capVertexCount * 2 + clippedSamples.Length].x;
}
}
wallTris = MeshUtility.GeneratePlaneTriangles(clippedSamples.Length - 1, 2, flipSide);
tsMesh.triangles = new int[capTris.Length * 2 + wallTris.Length];
int written = WriteTris(ref capTris, ref tsMesh.triangles, 0, 0, false);
written = WriteTris(ref capTris, ref tsMesh.triangles, capVertexCount, written, true);
written = WriteTris(ref wallTris, ref tsMesh.triangles, capVertexCount * 2, written, false);
}
else
{
//for (int i = 0; i < tsMesh.vertices.Length; i++) tsMesh.vertices[i] += clockwise ? -clippedSamples[i].right : clippedSamples[i].right;
tsMesh.triangles = new int[capTris.Length];
WriteTris(ref capTris, ref tsMesh.triangles, 0, 0, false);
}
}
public void Generate()
{
int surfaceVertexCount = sampleCount;
if (spline.isClosed)
{
surfaceVertexCount--;
}
int vertexCount = surfaceVertexCount;
if (_extrudeSpline != null)
{
_extrudeSpline.Evaluate(ref extrudeResults, _extrudeFrom, _extrudeTo);
}
else if (extrudeResults.Length > 0)
{
extrudeResults = new SplineSample[0];
}
bool pathExtrude = _extrudeSpline && extrudeResults.Length > 0;
bool simpleExtrude = !pathExtrude && _extrude != 0f;
if (pathExtrude)
{
vertexCount *= 2;
vertexCount += sampleCount * extrudeResults.Length;
}
else if (simpleExtrude)
{
vertexCount *= 4;
vertexCount += 2;
}
Vector3 center, normal;
GetProjectedVertices(surfaceVertexCount, out center, out normal);
bool clockwise = IsClockwise(projectedVerts);
bool flipCap = false;
bool flipSide = false;
if (!clockwise)
{
flipSide = !flipSide;
}
if (simpleExtrude && _extrude < 0f)
{
flipCap = !flipCap;
flipSide = !flipSide;
}
GenerateSurfaceTris(flipCap);
int totalTrisCount = surfaceTris.Length;
if (simpleExtrude)
{
totalTrisCount *= 2;
totalTrisCount += 2 * sampleCount * 2 * 3;
}
else
{
totalTrisCount *= 2;
totalTrisCount += extrudeResults.Length * sampleCount * 2 * 3;
}
AllocateMesh(vertexCount, totalTrisCount);
Vector3 off = trs.right * offset.x + trs.up * offset.y + trs.forward * offset.z;
for (int i = 0; i < surfaceVertexCount; i++)
{
GetSample(i, evalResult);
tsMesh.vertices[i] = evalResult.position + off;
tsMesh.normals[i] = evalResult.up;
tsMesh.colors[i] = evalResult.color * color;
}
#region UVs
Vector2 min = projectedVerts[0];
Vector2 max = projectedVerts[0];
for (int i = 1; i < projectedVerts.Length; i++)
{
if (min.x < projectedVerts[i].x)
{
min.x = projectedVerts[i].x;
}
if (min.y < projectedVerts[i].y)
{
min.y = projectedVerts[i].y;
}
if (max.x > projectedVerts[i].x)
{
max.x = projectedVerts[i].x;
}
if (max.y > projectedVerts[i].y)
{
max.y = projectedVerts[i].y;
}
}
for (int i = 0; i < projectedVerts.Length; i++)
{
tsMesh.uv[i].x = Mathf.InverseLerp(max.x, min.x, projectedVerts[i].x) * uvScale.x - uvScale.x * 0.5f + uvOffset.x + 0.5f;
tsMesh.uv[i].y = Mathf.InverseLerp(min.y, max.y, projectedVerts[i].y) * uvScale.y - uvScale.y * 0.5f + uvOffset.y + 0.5f;
}
#endregion
if (flipCap)
{
for (int i = 0; i < surfaceVertexCount; i++)
{
tsMesh.normals[i] *= -1f;
}
}
if (_expand != 0f)
{
for (int i = 0; i < surfaceVertexCount; i++)
{
GetSample(i, evalResult);
tsMesh.vertices[i] += (clockwise ? -evalResult.right : evalResult.right) * _expand;
}
}
if (pathExtrude)
{
GetIdentityVerts(center, normal, clockwise);
//Generate cap vertices with flipped normals
for (int i = 0; i < surfaceVertexCount; i++)
{
tsMesh.vertices[i + surfaceVertexCount] = extrudeResults[0].position + extrudeResults[0].rotation * identityVertices[i] + off;
tsMesh.normals[i + surfaceVertexCount] = -extrudeResults[0].forward;
tsMesh.colors[i + surfaceVertexCount] = tsMesh.colors[i] * extrudeResults[0].color;
tsMesh.uv[i + surfaceVertexCount] = new Vector2(1f - tsMesh.uv[i].x, tsMesh.uv[i].y);
tsMesh.vertices[i] = extrudeResults[extrudeResults.Length - 1].position + extrudeResults[extrudeResults.Length - 1].rotation * identityVertices[i] + off;
tsMesh.normals[i] = extrudeResults[extrudeResults.Length - 1].forward;
tsMesh.colors[i] *= extrudeResults[extrudeResults.Length - 1].color;
}
//Add wall vertices
float totalLength = 0f;
for (int i = 0; i < extrudeResults.Length; i++)
{
if (_uniformUvs && i > 0)
{
totalLength += Vector3.Distance(extrudeResults[i].position, extrudeResults[i - 1].position);
}
int startIndex = surfaceVertexCount * 2 + i * sampleCount;
for (int n = 0; n < identityVertices.Length; n++)
{
tsMesh.vertices[startIndex + n] = extrudeResults[i].position + extrudeResults[i].rotation * identityVertices[n] + off;
tsMesh.normals[startIndex + n] = extrudeResults[i].rotation * identityNormals[n];
if (_uniformUvs)
{
tsMesh.uv[startIndex + n] = new Vector2((float)n / (identityVertices.Length - 1) * _sideUvScale.x + _sideUvOffset.x, totalLength * _sideUvScale.y + _sideUvOffset.y);
}
else
{
tsMesh.uv[startIndex + n] = new Vector2((float)n / (identityVertices.Length - 1) * _sideUvScale.x + _sideUvOffset.x, (float)i / (extrudeResults.Length - 1) * _sideUvScale.y + _sideUvOffset.y);
}
if (clockwise)
{
tsMesh.uv[startIndex + n].x = 1f - tsMesh.uv[startIndex + n].x;
}
}
}
int written = WriteTris(ref surfaceTris, ref tsMesh.triangles, 0, 0, false);
written = WriteTris(ref surfaceTris, ref tsMesh.triangles, surfaceVertexCount, written, true);
MeshUtility.GeneratePlaneTriangles(ref wallTris, sampleCount - 1, extrudeResults.Length, flipSide, 0, 0, true);
WriteTris(ref wallTris, ref tsMesh.triangles, surfaceVertexCount * 2, written, false);
}
else if (simpleExtrude)
{
//Duplicate cap vertices with flipped normals
for (int i = 0; i < surfaceVertexCount; i++)
{
tsMesh.vertices[i + surfaceVertexCount] = tsMesh.vertices[i];
tsMesh.normals[i + surfaceVertexCount] = -tsMesh.normals[i];
tsMesh.colors[i + surfaceVertexCount] = tsMesh.colors[i];
tsMesh.uv[i + surfaceVertexCount] = new Vector2(1f - tsMesh.uv[i].x, tsMesh.uv[i].y);
tsMesh.vertices[i] += normal * _extrude;
}
//Add wall vertices
for (int i = 0; i < surfaceVertexCount + 1; i++)
{
int index = i;
if (i >= surfaceVertexCount)
{
index = i - surfaceVertexCount;
}
GetSample(index, evalResult);
tsMesh.vertices[i + surfaceVertexCount * 2] = tsMesh.vertices[index] - normal * _extrude;
tsMesh.normals[i + surfaceVertexCount * 2] = clockwise ? -evalResult.right : evalResult.right;
tsMesh.colors[i + surfaceVertexCount * 2] = tsMesh.colors[index];
tsMesh.uv[i + surfaceVertexCount * 2] = new Vector2((float)i / (surfaceVertexCount - 1) * _sideUvScale.x + _sideUvOffset.x, 0f + _sideUvOffset.y);
if (clockwise)
{
tsMesh.uv[i + surfaceVertexCount * 2].x = 1f - tsMesh.uv[i + surfaceVertexCount * 2].x;
}
int offsetIndex = i + surfaceVertexCount * 3 + 1;
tsMesh.vertices[offsetIndex] = tsMesh.vertices[index];
tsMesh.normals[offsetIndex] = tsMesh.normals[i + surfaceVertexCount * 2];
tsMesh.colors[offsetIndex] = tsMesh.colors[index];
if (_uniformUvs)
{
tsMesh.uv[offsetIndex] = new Vector2((float)i / surfaceVertexCount * _sideUvScale.x + _sideUvOffset.x, _extrude * _sideUvScale.y + _sideUvOffset.y);
}
else
{
tsMesh.uv[offsetIndex] = new Vector2((float)i / surfaceVertexCount * _sideUvScale.x + _sideUvOffset.x, 1f * _sideUvScale.y + _sideUvOffset.y);
}
if (clockwise)
{
tsMesh.uv[offsetIndex].x = 1f - tsMesh.uv[offsetIndex].x;
}
}
int written = WriteTris(ref surfaceTris, ref tsMesh.triangles, 0, 0, false);
written = WriteTris(ref surfaceTris, ref tsMesh.triangles, surfaceVertexCount, written, true);
MeshUtility.GeneratePlaneTriangles(ref wallTris, sampleCount - 1, 2, flipSide, 0, 0, true);
WriteTris(ref wallTris, ref tsMesh.triangles, surfaceVertexCount * 2, written, false);
}
else
{
WriteTris(ref surfaceTris, ref tsMesh.triangles, 0, 0, false);
}
}
public static void DrawSplineComputer(SplineComputer comp, double fromPercent = 0.0, double toPercent = 1.0, float alpha = 1f)
{
if (comp == null)
{
return;
}
Color prevColor = Handles.color;
Color orange = new Color(1f, 0.564f, 0f);
Color handleColor = comp.hasMorph && !MorphWindow.editShapeMode ? orange : comp.editorPathColor;
handleColor.a = alpha;
Handles.color = handleColor;
int iterations = Mathf.CeilToInt(comp.iterations * Mathf.Abs((float)(toPercent - fromPercent)));
if (comp.pointCount < 2)
{
return;
}
if (comp.type == Spline.Type.BSpline && comp.pointCount > 1)
{
SplinePoint[] compPoints = comp.GetPoints();
Handles.color = new Color(handleColor.r, handleColor.g, handleColor.b, 0.5f * alpha);
for (int i = 0; i < compPoints.Length - 1; i++)
{
Handles.DrawLine(compPoints[i].position, compPoints[i + 1].position);
}
Handles.color = handleColor;
}
if (!comp.drawThinckness)
{
if (positions.Length != iterations * 2)
{
positions = new Vector3[iterations * 2];
}
Vector3 prevPoint = comp.EvaluatePosition(fromPercent);
int pointIndex = 0;
for (int i = 1; i < iterations; i++)
{
double p = DMath.Lerp(fromPercent, toPercent, (double)i / (iterations - 1));
positions[pointIndex] = prevPoint;
pointIndex++;
positions[pointIndex] = comp.EvaluatePosition(p);
pointIndex++;
prevPoint = positions[pointIndex - 1];
}
Handles.DrawLines(positions);
}
else
{
Transform editorCamera = SceneView.currentDrawingSceneView.camera.transform;
if (positions.Length != iterations * 6)
{
positions = new Vector3[iterations * 6];
}
SplineResult prevResult = comp.Evaluate(fromPercent);
Vector3 prevNormal = prevResult.normal;
if (comp.billboardThickness)
{
prevNormal = (editorCamera.position - prevResult.position).normalized;
}
Vector3 prevRight = Vector3.Cross(prevResult.direction, prevNormal).normalized *prevResult.size * 0.5f;
int pointIndex = 0;
for (int i = 1; i < iterations; i++)
{
double p = DMath.Lerp(fromPercent, toPercent, (double)i / (iterations - 1));
SplineResult newResult = comp.Evaluate(p);
Vector3 newNormal = newResult.normal;
if (comp.billboardThickness)
{
newNormal = (editorCamera.position - newResult.position).normalized;
}
Vector3 newRight = Vector3.Cross(newResult.direction, newNormal).normalized *newResult.size * 0.5f;
positions[pointIndex] = prevResult.position + prevRight;
positions[pointIndex + iterations * 2] = prevResult.position - prevRight;
positions[pointIndex + iterations * 4] = newResult.position - newRight;
pointIndex++;
positions[pointIndex] = newResult.position + newRight;
positions[pointIndex + iterations * 2] = newResult.position - newRight;
positions[pointIndex + iterations * 4] = newResult.position + newRight;
pointIndex++;
prevResult = newResult;
prevRight = newRight;
prevNormal = newNormal;
}
Handles.DrawLines(positions);
}
Handles.color = prevColor;
}
public void Generate()
{
if (_extrudeComputer != null)
{
_extrudeComputer.Evaluate(ref extrudeResults, _extrudeFrom, _extrudeTo);
}
int num = base.clippedSamples.Length;
int num2 = 0;
int num3 = 0;
if (base.computer.isClosed)
{
num--;
}
bool flag = _extrudeComputer != null && extrudeResults.Length > 0;
bool flag2 = !flag && _extrude != 0f;
num3 = num;
if (flag)
{
num2 = base.clippedSamples.Length * extrudeResults.Length;
num3 = num * 2 + num2;
}
else if (flag2)
{
num2 = base.clippedSamples.Length * 2;
num3 = num * 2 + num2;
}
AllocateMesh(num3, tsMesh.triangles.Length);
Vector3 a = Vector3.zero;
Vector3 vector = Vector3.zero;
Vector3 right = base.transform.right;
Vector3 offset = base.offset;
Vector3 a2 = right * offset.x;
Vector3 up = base.transform.up;
Vector3 offset2 = base.offset;
Vector3 a3 = a2 + up * offset2.y;
Vector3 forward = base.transform.forward;
Vector3 offset3 = base.offset;
Vector3 b = a3 + forward * offset3.z;
for (int i = 0; i < num; i++)
{
tsMesh.vertices[i] = base.clippedSamples[i].position + b;
tsMesh.normals[i] = base.clippedSamples[i].normal;
tsMesh.colors[i] = base.clippedSamples[i].color;
tsMesh.colors[i] *= base.color;
a += tsMesh.vertices[i];
vector += tsMesh.normals[i];
}
vector.Normalize();
a /= num;
GetProjectedVertices(tsMesh.vertices, vector, a, num);
Vector2 vector2 = projectedVerts[0];
Vector2 vector3 = projectedVerts[0];
for (int j = 1; j < projectedVerts.Length; j++)
{
if (vector2.x < projectedVerts[j].x)
{
vector2.x = projectedVerts[j].x;
}
if (vector2.y < projectedVerts[j].y)
{
vector2.y = projectedVerts[j].y;
}
if (vector3.x > projectedVerts[j].x)
{
vector3.x = projectedVerts[j].x;
}
if (vector3.y > projectedVerts[j].y)
{
vector3.y = projectedVerts[j].y;
}
}
for (int k = 0; k < projectedVerts.Length; k++)
{
ref Vector2 reference = ref tsMesh.uv[k];
float num4 = Mathf.InverseLerp(vector3.x, vector2.x, projectedVerts[k].x);
Vector2 uvScale = base.uvScale;
float num5 = num4 * uvScale.x;
Vector2 uvScale2 = base.uvScale;
float num6 = num5 - uvScale2.x * 0.5f;
Vector2 uvOffset = base.uvOffset;
reference.x = num6 + uvOffset.x + 0.5f;
ref Vector2 reference2 = ref tsMesh.uv[k];
