public static void LoadPrefs()
{
defaultAlwaysDraw = EditorPrefs.GetBool("Dreamteck.Splines.defaultAlwaysDraw", false);
defaultShowThickness = EditorPrefs.GetBool("Dreamteck.Splines.defaultShowThickness", false);
default2D = EditorPrefs.GetBool("Dreamteck.Splines.default2D", false);
showPointNumbers = EditorPrefs.GetBool("Dreamteck.Splines.showPointNumbers", false);
defaultColor = LoadColor("Dreamteck.Splines.defaultColor", Color.white);
highlightColor = LoadColor("Dreamteck.Splines.highlightColor", new Color(0f, 0.564f, 1f, 1f));
highlightContentColor = LoadColor("Dreamteck.Splines.highlightContentColor", new Color(1f, 1f, 1f, 0.95f));
defaultComputerSpace = (SplineComputer.Space)EditorPrefs.GetInt("Dreamteck.Splines.defaultComputerSpace", 0);
defaultType = (Spline.Type)EditorPrefs.GetInt("Dreamteck.Splines.defaultType", 0);
loaded = true;
}
/// <summary>
/// Set a point of this computer's spline. The point must be in world coordinates.
/// </summary>
/// <param name="index"></param>
/// <param name="point"></param>
/// <param name="updateNodes">If there are nodes, connected to this point, should they be updated?</param>
public void SetPoint(int index, SplinePoint point, SplineComputer.Space setSpace = SplineComputer.Space.World)
{
if (index < 0 || index >= spline.points.Length)
{
return;
}
bool rebuild = false;
SplinePoint newPoint = point;
if (_space == SplineComputer.Space.Local && setSpace == SplineComputer.Space.World)
{
newPoint.position = InverseTransformPoint(point.position);
newPoint.tangent = InverseTransformPoint(point.tangent);
newPoint.tangent2 = InverseTransformPoint(point.tangent2);
newPoint.normal = InverseTransformDirection(point.normal);
}
if (newPoint.position != spline.points[index].position)
{
rebuild = true;
}
else if (newPoint.tangent != spline.points[index].tangent)
{
rebuild = true;
}
else if (newPoint.tangent2 != spline.points[index].tangent2)
{
rebuild = true;
}
else if (newPoint.size != spline.points[index].size)
{
rebuild = true;
}
else if (newPoint.type != spline.points[index].type)
{
rebuild = true;
}
else if (newPoint.color != spline.points[index].color)
{
rebuild = true;
}
else if (newPoint.normal != spline.points[index].normal)
{
rebuild = true;
}
spline.points[index] = newPoint;
if (rebuild)
{
Rebuild();
SetNodeForPoint(index, point);
}
}
/// <summary>
/// Get the points from this computer's spline. All points are transformed in world coordinates.
/// </summary>
/// <returns></returns>
public SplinePoint[] GetPoints(SplineComputer.Space getSpace = SplineComputer.Space.World)
{
SplinePoint[] points = new SplinePoint[spline.points.Length];
for (int i = 0; i < points.Length; i++)
{
points[i] = spline.points[i];
if (_space == SplineComputer.Space.Local && getSpace == SplineComputer.Space.World)
{
points[i].position = TransformPoint(points[i].position);
points[i].tangent = TransformPoint(points[i].tangent);
points[i].tangent2 = TransformPoint(points[i].tangent2);
points[i].normal = TransformDirection(points[i].normal);
}
}
return(points);
}
public static void OnGUI()
{
if (!loaded)
{
LoadPrefs();
}
EditorGUILayout.LabelField("Newly created splines:", EditorStyles.boldLabel);
startInCreationMode = EditorGUILayout.Toggle("Start in Creation Mode", startInCreationMode);
defaultComputerSpace = (SplineComputer.Space)EditorGUILayout.EnumPopup("Space", defaultComputerSpace);
defaultType = (Spline.Type)EditorGUILayout.EnumPopup("Type", defaultType);
defaultAlwaysDraw = EditorGUILayout.Toggle("Always draw", defaultAlwaysDraw);
defaultShowThickness = EditorGUILayout.Toggle("Show thickness", defaultShowThickness);
default2D = EditorGUILayout.Toggle("2D Mode", default2D);
defaultColor = EditorGUILayout.ColorField("Spline color", defaultColor);
EditorGUILayout.Space();
EditorGUILayout.LabelField("Newly created points:", EditorStyles.boldLabel);
createPointSize = EditorGUILayout.FloatField("Default Size", createPointSize);
createPointColor = EditorGUILayout.ColorField("Default Color", createPointColor);
EditorGUILayout.Space();
EditorGUILayout.LabelField("Editor", EditorStyles.boldLabel);
highlightColor = EditorGUILayout.ColorField("Highlight color", highlightColor);
highlightContentColor = EditorGUILayout.ColorField("Highlight content color", highlightContentColor);
duplicationDirection = (DuplicationDirection)EditorGUILayout.EnumPopup("Duplicate Direction", duplicationDirection);
showPointNumbers = EditorGUILayout.Toggle("Show point numbers", showPointNumbers);
if (GUILayout.Button("Use Defaults", GUILayout.Width(120)))
{
duplicationDirection = DuplicationDirection.Forward;
defaultAlwaysDraw = false;
defaultShowThickness = false;
default2D = false;
startInCreationMode = true;
defaultColor = Color.white;
highlightColor = new Color(0f, 0.564f, 1f, 1f);
highlightContentColor = new Color(1f, 1f, 1f, 0.95f);
showPointNumbers = false;
defaultComputerSpace = SplineComputer.Space.Local;
defaultType = Spline.Type.Hermite;
createPointSize = 1f;
createPointColor = Color.white;
SavePrefs();
}
if (GUI.changed)
{
SavePrefs();
}
}
public static void LoadPrefs()
{
defaultAlwaysDraw = EditorPrefs.GetBool("Dreamteck.Splines.defaultAlwaysDraw", false);
defaultShowThickness = EditorPrefs.GetBool("Dreamteck.Splines.defaultShowThickness", false);
default2D = EditorPrefs.GetBool("Dreamteck.Splines.default2D", false);
startInCreationMode = EditorPrefs.GetBool("Dreamteck.Splines.startInCreationMode", true);
showPointNumbers = EditorPrefs.GetBool("Dreamteck.Splines.showPointNumbers", false);
pointEditSpace = (SplineComputer.Space)EditorPrefs.GetInt("Dreamteck.Splines.pointEditSpace", 1);
defaultColor = LoadColor("Dreamteck.Splines.defaultColor", Color.white);
highlightColor = LoadColor("Dreamteck.Splines.highlightColor", new Color(0f, 0.564f, 1f, 1f));
highlightContentColor = LoadColor("Dreamteck.Splines.highlightContentColor", new Color(1f, 1f, 1f, 0.95f));
defaultComputerSpace = (SplineComputer.Space)EditorPrefs.GetInt("Dreamteck.Splines.defaultComputerSpace", 0);
defaultType = (Spline.Type)EditorPrefs.GetInt("Dreamteck.Splines.defaultType", 0);
duplicationDirection = (DuplicationDirection)EditorPrefs.GetInt("Dreamteck.Splines.duplicationDirection", 0);
createPointSize = EditorPrefs.GetFloat("Dreamteck.Splines.createPointSize", 1f);
createPointColor = LoadColor("Dreamteck.Splines.createPointColor", Color.white);
loaded = true;
}
/// <summary>
/// Get a point from this computer's spline. The point is transformed in world coordinates.
/// </summary>
/// <param name="index">Point index</param>
/// <returns></returns>
public SplinePoint GetPoint(int index, SplineComputer.Space getSpace = SplineComputer.Space.World)
{
if (index < 0 || index >= spline.points.Length)
{
return(new SplinePoint());
}
if (_space == SplineComputer.Space.Local && getSpace == SplineComputer.Space.World)
{
SplinePoint point = spline.points[index];
point.position = TransformPoint(point.position);
point.tangent = TransformPoint(point.tangent);
point.tangent2 = TransformPoint(point.tangent2);
point.normal = TransformDirection(point.normal);
return(point);
}
else
{
return(spline.points[index]);
}
}
void PointMenu()
{
if (selectedPoints.Count == 0 || points.Length == 0)
{
return;
}
//Otherwise show the editing menu + the point selection menu
Vector3 avgPos = Vector3.zero;
Vector3 avgTan = Vector3.zero;
Vector3 avgTan2 = Vector3.zero;
Vector3 avgNormal = Vector3.zero;
float avgSize = 0f;
Color avgColor = Color.clear;
for (int i = 0; i < selectedPoints.Count; i++)
{
avgPos += points[selectedPoints[i]].position;
avgNormal += points[selectedPoints[i]].normal;
avgSize += points[selectedPoints[i]].size;
avgTan += points[selectedPoints[i]].tangent;
avgTan2 += points[selectedPoints[i]].tangent2;
avgColor += points[selectedPoints[i]].color;
}
avgPos /= selectedPoints.Count;
avgTan /= selectedPoints.Count;
avgTan2 /= selectedPoints.Count;
avgSize /= selectedPoints.Count;
avgColor /= selectedPoints.Count;
avgNormal.Normalize();
SplinePoint avgPoint = new SplinePoint(avgPos, avgPos);
avgPoint.tangent = avgTan;
avgPoint.tangent2 = avgTan2;
avgPoint.size = avgSize;
avgPoint.color = avgColor;
avgPoint.type = points[selectedPoints[0]].type;
SplinePoint.Type lastType = avgPoint.type;
avgPoint.normal = avgNormal;
EditorGUI.BeginChangeCheck();
SplineComputer.Space lastSpace = SplinePrefs.pointEditSpace;
SplinePrefs.pointEditSpace = (SplineComputer.Space)EditorGUILayout.EnumPopup("Edit Space", SplinePrefs.pointEditSpace);
if (lastSpace != SplinePrefs.pointEditSpace)
{
SplinePrefs.SavePrefs();
}
if (splineType == Spline.Type.Bezier)
{
if (is2D)
{
avgPoint.SetTangentPosition(TransformedPositionField2D("Tangent 1", avgPoint.tangent));
avgPoint.SetTangent2Position(TransformedPositionField2D("Tangent 2", avgPoint.tangent2));
}
else
{
avgPoint.SetTangentPosition(TransformedPositionField("Tangent 1", avgPoint.tangent));
avgPoint.SetTangent2Position(TransformedPositionField("Tangent 2", avgPoint.tangent2));
}
}
if (is2D)
{
avgPoint.SetPosition(TransformedPositionField2D("Position", avgPoint.position));
}
else
{
avgPoint.SetPosition(TransformedPositionField("Position", avgPoint.position));
}
if (!is2D)
{
if (SplinePrefs.pointEditSpace == SplineComputer.Space.Local)
{
avgPoint.normal = _matrix.inverse.MultiplyVector(avgPoint.normal);
}
avgPoint.normal = TransformedPositionField("Normal", avgPoint.normal);
if (SplinePrefs.pointEditSpace == SplineComputer.Space.Local)
{
avgPoint.normal = _matrix.MultiplyVector(avgPoint.normal);
}
}
avgPoint.size = EditorGUILayout.FloatField("Size", avgPoint.size);
avgPoint.color = EditorGUILayout.ColorField("Color", avgPoint.color);
if (splineType == Spline.Type.Bezier)
{
avgPoint.type = (SplinePoint.Type)EditorGUILayout.EnumPopup("Point Type", avgPoint.type);
}
if (!EditorGUI.EndChangeCheck())
{
return;
}
RecordUndo("Edit Points");
for (int i = 0; i < selectedPoints.Count; i++)
{
points[selectedPoints[i]].SetPosition(GetChangedVector(avgPos, avgPoint.position, points[selectedPoints[i]].position));
points[selectedPoints[i]].normal = GetChangedVector(avgNormal, avgPoint.normal, points[selectedPoints[i]].normal);
if (splineType == Spline.Type.Bezier)
{
points[selectedPoints[i]].SetTangentPosition(GetChangedVector(avgTan, avgPoint.tangent, points[selectedPoints[i]].tangent));
points[selectedPoints[i]].SetTangent2Position(GetChangedVector(avgTan2, avgPoint.tangent2, points[selectedPoints[i]].tangent2));
}
if (avgPoint.size != avgSize)
{
points[selectedPoints[i]].size = avgPoint.size;
}
if (avgColor != avgPoint.color)
{
points[selectedPoints[i]].color = avgPoint.color;
}
if (lastType != avgPoint.type)
{
points[selectedPoints[i]].type = avgPoint.type;
}
}
}
/// <summary>
/// Set the points of this computer's spline.
/// </summary>
/// <param name="points"></param>
/// <param name="updateNodes">Should it also update any linked nodes?</param>
public void SetPoints(SplinePoint[] points, SplineComputer.Space setSpace = SplineComputer.Space.World)
{
bool rebuild = false;
if (points.Length != spline.points.Length)
{
rebuild = true;
if (points.Length < 4)
{
Break();
}
spline.points = new SplinePoint[points.Length];
}
SplinePoint newPoint;
for (int i = 0; i < points.Length; i++)
{
newPoint = points[i];
if (_space == SplineComputer.Space.Local && setSpace == SplineComputer.Space.World)
{
newPoint.position = InverseTransformPoint(points[i].position);
newPoint.tangent = InverseTransformPoint(points[i].tangent);
newPoint.tangent2 = InverseTransformPoint(points[i].tangent2);
newPoint.normal = InverseTransformDirection(points[i].normal);
}
if (!rebuild)
{
if (newPoint.position != spline.points[i].position)
{
rebuild = true;
}
else if (newPoint.tangent != spline.points[i].tangent)
{
rebuild = true;
}
else if (newPoint.tangent2 != spline.points[i].tangent2)
{
rebuild = true;
}
else if (newPoint.size != spline.points[i].size)
{
rebuild = true;
}
else if (newPoint.type != spline.points[i].type)
{
rebuild = true;
}
else if (newPoint.color != spline.points[i].color)
{
rebuild = true;
}
else if (newPoint.normal != spline.points[i].normal)
{
rebuild = true;
}
}
spline.points[i] = newPoint;
}
if (rebuild)
{
Rebuild();
UpdateConnectedNodes(points);
}
}
