void Start()
{
//create the game object that will hold the spline plus component and catch the SPData to use further
SPData = SplinePlusAPI.CreateSplinePlus(Vector3.zero);
//create the 2 nodes
var node1 = SplinePlusAPI.CreateNode(SPData, new Vector3(10, 0, 0));
var node2 = SplinePlusAPI.CreateNode(SPData, new Vector3(-10, 0, 0));
//connect the 2 node
SplinePlusAPI.ConnectTwoNodes(SPData, node1, node2);
//change the node points to get the oval shape,
// just copy the values from the editor example it's easier this way
node1.Point1.position = new Vector3(10, 0, Power);
node1.Point2.position = new Vector3(10, 0, -Power);
node2.Point1.position = new Vector3(-10, 0, Power);
node2.Point2.position = new Vector3(-10, 0, -Power);
//set looped to true to close the shape
SPData.IsLooped = true;
//trigger a spline plus update
SPData.SplinePlus.SplineCreationClass.UpdateAllBranches(SPData);
}
public static void Node_FlipHandles(object obj)
{
SPData sPData = (SPData)obj;
Undo.RecordObject(sPData.SplinePlus, "handles Fliped");
SplinePlusAPI.Node_FlipHandles(sPData, sPData._NodeIndex);
}
public static void Node_Delete(object obj)
{
SPData sPData = (SPData)obj;
Undo.RecordObject(sPData.SplinePlus, "node deleted");
SplinePlusAPI.Node_Remove(sPData, sPData.Node_Selected());
}
void Shortcuts()
{
var e = Event.current;
if (e == null)
{
return;
}
// Set mode back to selection
if (e.type == EventType.KeyDown && e.keyCode == KeyCode.Escape)
{
Undo.RecordObject(SPData.SplinePlus, "Selection initialised");
SPData.User_Action = User_Actions.None;
FocusSceneView();
}
//focus on path point
else if (e.type == EventType.KeyDown && e.keyCode == KeyCode.C)
{
var selectedNode = SPData.Node_Selected();
SceneView.lastActiveSceneView.LookAt(selectedNode.Point.position);
FocusSceneView();
}
//Delete selected node
else if (e.type == EventType.KeyDown && e.keyCode == KeyCode.Backspace)
{
var selectedNode = SPData.Node_Selected();
Undo.RecordObject(SPData.SplinePlus, "node deleted");
SplinePlusAPI.Node_Remove(SPData, selectedNode);
FocusSceneView();
}
//Hide node handles
else if (e.type == EventType.KeyDown && e.keyCode == KeyCode.H)
{
Undo.RecordObject(SPData.SplinePlus, "node hide unhide handles");
SPData.SplineSettings.Show_SecondaryHandles = !SPData.SplineSettings.Show_SecondaryHandles;
FocusSceneView();
}
//Reverse sPData
else if (e.type == EventType.KeyDown && e.keyCode == KeyCode.R)
{
Undo.RecordObject(SPData.SplinePlus, "Reverse sPData");
SplinePlusAPI.Spline_Reverse(SPData);
SPData.Update( );
FocusSceneView();
}
//Flip node handles
else if (e.type == EventType.KeyDown && e.keyCode == KeyCode.X)
{
Undo.RecordObject(SPData.SplinePlus, "Flip handles sPData");
SplinePlusAPI.Node_FlipHandles(SPData, SPData._NodeIndex);
SPData.Update();
FocusSceneView();
}
}
public static void Spline_Reverse(object obj)
{
SPData sPData = (SPData)obj;
Undo.RecordObject(sPData.SplinePlus, "sPData Reversed");
SplinePlusAPI.Spline_Reverse(sPData);
}
private void OnEnable()
{
TubeMesh = (TubeMesh)target;
TubeMesh.SPData = TubeMesh.gameObject.transform.GetComponent <SplinePlus>().sPData;
if (TubeMesh.MeshHolder == null)
{
var meshHolder = SplinePlusAPI.AddMeshHolder(TubeMesh.SPData, "TubeMesh");
TubeMesh.MeshHolder = meshHolder;
TubeMesh.MeshRenderer = meshHolder.GetComponent <MeshRenderer>();
TubeMesh.Mesh = meshHolder.GetComponent <MeshFilter>();
}
if (Delete == null)
{
Delete = new GUIContent((Texture2D)EditorGUIUtility.Load(SplinePlusEditor.FindAssetPath("Delete.png")));
}
if (TubeMesh.Material == null)
{
TubeMesh.Material = (Material)EditorGUIUtility.Load(SplinePlusEditor.FindAssetPath("Base.mat"));
if (TubeMesh.Material == null)
{
Debug.Log("mat null");
}
}
TubeMesh.SPData.MeshModifier = TubeMesh;
TubeMesh.DrawMesh();
SplineCreationClass.Update_Spline += Update_Spline;
}
public static void Node_Type_Broken(object obj)
{
SPData sPData = (SPData)obj;
Undo.RecordObject(sPData.SplinePlus, "Node insectType changed to broken");
var selectedNode = sPData.Node_Selected();
SplinePlusAPI.Node_Set_Type(sPData, selectedNode, NodeType.Broken);
}
public static void Node_Type_Smooth(object obj)
{
SPData sPData = (SPData)obj;
Undo.RecordObject(sPData.SplinePlus, "Node insectType changed to smooth");
var node = sPData.Node_Selected();
SplinePlusAPI.Node_Set_Type(sPData, node, NodeType.Smooth);
}
void Uvs(int t, int _bIndex, int i)
{
var vertexDist = SPData.VerticesDistance[_bIndex];
var x = Mathf.InverseLerp(0, Segments, i);
var y = Mathf.InverseLerp(0, SPData.Length, vertexDist);
var v = new Vector2(x, y);
_Data.Uvs[t] = SplinePlusAPI.Vector2_Rotate_Around_Pivot(v, UVRotation);
}
public static void Spline_Clear(object obj)
{
SPData sPData = (SPData)obj;
Undo.RecordObject(sPData.SplinePlus, "sPData Reversed");
SplinePlusAPI.Spline_Clear(sPData);
if (sPData.Close)
{
sPData.Close = false;
}
}
public void Start()
{
SPData = SplinePlusAPI.CreateSplinePlus(Vector3.zero);
var pathPoint1 = SplinePlusAPI.CreateNode(SPData, new Vector3(0, 0, 0));
var pathPoint2 = SplinePlusAPI.CreateNode(SPData, new Vector3(10, 0, 0));
var pathPoint3 = SplinePlusAPI.CreateNode(SPData, new Vector3(10, 0, 10));
var pathPoint4 = SplinePlusAPI.CreateNode(SPData, new Vector3(0, 0, 10));
SplinePlusAPI.ConnectTwoNodes(SPData, pathPoint1, pathPoint2);
SplinePlusAPI.ConnectTwoNodes(SPData, pathPoint2, pathPoint3);
SplinePlusAPI.ConnectTwoNodes(SPData, pathPoint3, pathPoint4);
SplinePlusAPI.ConnectTwoNodes(SPData, pathPoint4, pathPoint1);
SplinePlusAPI.SmoothAllSharedNodes(SPData, 0.5f);
FollowerSettings(SPData);
}
public void Uvs()
{
uvs = new Vector2[vertices.Count];
float h = SPData.Length / (Width * 2);
for (int n = 0, i = 0; i < SPData.Vertices.Count; i++, n = n + 2)
{
var x = Mathf.InverseLerp(0, SPData.Length, SPData.VerticesDistance[i]) * h;
uvs[n] = new Vector2(x, 0);
uvs[n + 1] = new Vector2(x, 1);
uvs[n] = SplinePlusAPI.Vector2_Rotate_Around_Pivot(uvs[n], UVRotation);
uvs[n + 1] = SplinePlusAPI.Vector2_Rotate_Around_Pivot(uvs[n + 1], UVRotation);
}
}
public void SmoothSharedPathPoint(SPData SPData)
{
var node = SPData.Selections._PathPoint;
//cach data for restore procedure
SPData.SmoothData.InitNodePos = node.Point.position;
var sharedPathPointIndex = SPData.Selections._SharedPathPointIndex;
SPData.SmoothData.Nodes = new Node[SPData.SharedNodes[sharedPathPointIndex].ConnectedBranches.Count];
SPData.SmoothData.BranchesIndices = SPData.SharedNodes[sharedPathPointIndex].ConnectedBranches.ToArray();
//shared path point breaking
for (int i = 0; i < SPData.SmoothData.Nodes.Length; i++)
{
var branchKey = SPData.SharedNodes[sharedPathPointIndex].ConnectedBranches[i];
var localIndex = node.LocalIndex(SPData, branchKey);
var duplicate = SplinePlusAPI.DuplicatePathPoint(SPData, node);
SPData.SmoothData.Nodes[i] = duplicate;
SPData.DictBranches[branchKey].Nodes[localIndex] = duplicate;
if (localIndex != 0)
{
BranchesClass.FlipHandles(SPData, branchKey, localIndex);
}
}
SPData.SmoothData.newBranchesIndices = new List <int>();
//path points welding
for (int i = 0; i < SPData.SmoothData.Nodes.Length; i++)// path points created after chamfer,
{
for (int n = i; n < SPData.SmoothData.Nodes.Length; n++)
{
if (n == i)
{
continue;
}
//UpdateAllLinks
var t = SplinePlusAPI.ConnectTwoNodes(SPData, SPData.SmoothData.Nodes[n], SPData.SmoothData.Nodes[i]);
SPData.SmoothData.newBranchesIndices.Add(t);
BranchesClass.FlipHandles(SPData, t, 0);
BranchesClass.FlipHandles(SPData, t, 1);
}
}
EditSmoothNodePoint(SPData, SPData.SmoothRadius);
}
public void SmoothNode(SPData SPData)
{
var node = SPData.Selections._PathPoint;
var branch = SPData.DictBranches[SPData.Selections._BranchKey];
var nodeIndex = SPData.Selections._LocalNodeIndex;
SPData.SmoothData.Nodes = new Node[2];
if (branch.Nodes.Count > 2 && nodeIndex > 0 && nodeIndex < (branch.Nodes.Count - 1))
{
SPData.SmoothData.InitNodePos = node.Point.position;
SPData.SmoothData.InitNodePoint1Pos = node.Point1.position;
SPData.SmoothData.Nodes[0] = node;
SPData.SmoothData.Nodes[1] = SplinePlusAPI.DuplicatePathPoint(SPData, node);
branch.Nodes.Insert(nodeIndex + 1, SPData.SmoothData.Nodes[1]);
}
EditSmoothNode(SPData, SPData.SmoothRadius);
}
public void CreatePath()
{
var SplinePlus = SplinePlusAPI.CreateSplinePlus(Vector3.zero);
Node pathPoint1 = new Node();
Node pathPoint2 = new Node();
for (int i = 0; i < Points.Count - 1; i = i + 2)
{
if (Points[i] == null || Points[i + 1] == null)
{
DestroyImmediate(SplinePlus.DataParent);
return;
}
pathPoint1 = SplinePlusAPI.CreateNode(SplinePlus, Points[i].transform.position);
pathPoint2 = SplinePlusAPI.CreateNode(SplinePlus, Points[i + 1].transform.position);
SplinePlusAPI.ConnectTwoNodes(SplinePlus, pathPoint1, pathPoint2);
}
SplinePlusAPI.SmoothAllSharedNodes(SplinePlus, Radius);
}
static void CreateSplinePlus()
{
var sPData = SplinePlusAPI.SplinePlus_Create(Vector3.zero);
Selection.activeGameObject = sPData.SplinePlus.gameObject;
}
public void SplineSettings(SPData SPData)
{
GUIContent buttonContent;
if (!SPData.ShowSplineSettings)
{
buttonContent = SplinePlusEditor.Minus;
}
else
{
buttonContent = SplinePlusEditor.Plus;
}
var rect = EditorGUILayout.BeginHorizontal();
EditorGUI.DrawRect(new Rect(rect.x - 15, rect.y, rect.width + 15, 1), Color.gray);
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
GUILayout.BeginHorizontal();
if (GUILayout.Button(buttonContent, GUIStyle.none, GUILayout.MaxWidth(20), GUILayout.MaxHeight(20)))
{
Undo.RecordObject(SPData.SplinePlus, "Show spline settings changed");
SPData.ShowSplineSettings = !SPData.ShowSplineSettings;
EditorUtility.SetDirty(SPData.SplinePlus);
}
EditorGUILayout.LabelField("Spline settings", EditorStyles.boldLabel);
GUILayout.EndHorizontal();
if (!SPData.ShowSplineSettings)
{
EditorGUILayout.Space();
return;
}
EditorGUILayout.Space();
EditorGUILayout.Space();
EditorGUI.BeginChangeCheck();
var refAxis = (RefAxis)EditorGUILayout.EnumPopup(new GUIContent("Reference axis", "Spline normals reference direction by default"), SPData.ReferenceAxis);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(SPData.SplinePlus, "refAxis changed");
SPData.ReferenceAxis = refAxis;
EditorUtility.SetDirty(SPData.SplinePlus);
SPData.SplinePlus.SplineCreationClass.UpdateAllBranches(SPData);
}
var Smoothness = (int)EditorGUILayout.IntField("Smoothness", SPData.Smoothness);
if (Smoothness != SPData.Smoothness)
{
Undo.RecordObject(SPData.SplinePlus, "Smoothness changed");
SPData.Smoothness = Mathf.Abs(Smoothness);
SPData.SplinePlus.SplineCreationClass.UpdateAllBranches(SPData);
EditorUtility.SetDirty(SPData.SplinePlus);
}
EditorGUILayout.BeginHorizontal();
var attachedSplineplus = (SplinePlus)EditorGUILayout.ObjectField("Attach Spline+ object", SPData.AttachedSplinePlus, typeof(SplinePlus), true);
if (attachedSplineplus != SPData.AttachedSplinePlus)
{
Undo.RecordObject(SPData.SplinePlus, "Attach Spline+ data changed");
SPData.AttachedSplinePlus = attachedSplineplus;
EditorUtility.SetDirty(SPData.SplinePlus);
}
if (GUILayout.Button("Attach", GUILayout.MaxWidth(60)))
{
if (SPData.AttachedSplinePlus != null && EditorUtility.DisplayDialog("Confirm",
"The attached spline plus object will be completely merged after this, do you want to continue! ",
"Yes", "Cancel"))
{
Undo.RecordObject(SPData.SplinePlus, "Attach Spline+ data changed");
Undo.RecordObject(SPData.AttachedSplinePlus, "Recover attach Spline+ data changed");
SplinePlusAPI.Attach(SPData, SPData.AttachedSplinePlus.SPData);
Undo.DestroyObjectImmediate(SPData.AttachedSplinePlus.SPData.DataParent);
EditorUtility.SetDirty(SPData.SplinePlus);
}
else
{
EditorUtility.DisplayDialog("Error",
"Spline plus object is null !! "
, "Okey");
}
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
EditorGUILayout.BeginHorizontal();
var interpolateRotationContent = (SPData.InterpolateRotation) ? SplinePlusEditor.On : SplinePlusEditor.Off;
if (GUILayout.Button(interpolateRotationContent, GUIStyle.none, GUILayout.MaxWidth(40), GUILayout.MaxHeight(20)))
{
Undo.RecordObject(SPData.SplinePlus, "Interpolate rotationchanged");
SPData.InterpolateRotation = !SPData.InterpolateRotation;
EditorUtility.SetDirty(SPData.SplinePlus);
}
EditorGUILayout.LabelField("Interpolate rotation");
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
var constantSpeedContent = (SPData.ConstantSpeed) ? SplinePlusEditor.On : SplinePlusEditor.Off;
if (GUILayout.Button(constantSpeedContent, GUIStyle.none, GUILayout.MaxWidth(40), GUILayout.MaxHeight(20)))
{
Undo.RecordObject(SPData.SplinePlus, "Constant speed value changed");
SPData.ConstantSpeed = !SPData.ConstantSpeed;
EditorUtility.SetDirty(SPData.SplinePlus);
SPData.SplinePlus.SplineCreationClass.UpdateAllBranches(SPData);;
}
EditorGUILayout.LabelField("Constant speed");
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
var splineProjectionContent = (SPData.SplineProjection) ? SplinePlusEditor.On : SplinePlusEditor.Off;
if (GUILayout.Button(splineProjectionContent, GUIStyle.none, GUILayout.MaxWidth(40), GUILayout.MaxHeight(20)))
{
Undo.RecordObject(SPData.SplinePlus, "Spline Projection changed");
SPData.SplineProjection = !SPData.SplineProjection;
SPData.SplinePlus.SplineCreationClass.UpdateAllBranches(SPData);
}
EditorGUILayout.LabelField("Spline Projection");
EditorGUILayout.EndHorizontal();
if (SPData.DictBranches.Count <= 1)
{
EditorGUILayout.BeginHorizontal();
var isLoopedContent = (SPData.IsLooped) ? SplinePlusEditor.On : SplinePlusEditor.Off;
if (GUILayout.Button(isLoopedContent, GUIStyle.none, GUILayout.MaxWidth(40), GUILayout.MaxHeight(20)))
{
Undo.RecordObject(SPData.SplinePlus, "Looped value changed");
SPData.IsLooped = !SPData.IsLooped;
SPData.SplinePlus.SplineCreationClass.UpdateAllBranches(SPData);
SceneView.RepaintAll();
}
EditorGUILayout.LabelField("Looped");
EditorGUILayout.EndHorizontal();
}
GUILayout.Space(2);
}
public static void Node_Add(SPData sPData)
{
SceneView.currentDrawingSceneView.Repaint();
EditorGUIUtility.AddCursorRect(Camera.current.pixelRect, MouseCursor.ArrowPlus);
int nIndex = 0;
string vertexPostion = "init";
Vector3 vert = Vector3.zero;
if (sPData.Nodes.Count >= 2)
{
vert = HandleUtility.ClosestPointToPolyLine(sPData.Vertices.ToArray());
if (sPData.Close)
{
nIndex = BranchClosestNodeToVertex(sPData, vert);
vertexPostion = "mid";
}
else
{
if (Vector3.Distance(sPData.FirstNode.Point.position, vert) <= float.Epsilon)
{
nIndex = 0;
vertexPostion = "beg";
}
else if (Vector3.Distance(sPData.LastNode.Point.position, vert) <= float.Epsilon)
{
nIndex = sPData.Nodes.Count - 1;
vertexPostion = "end";
}
else
{
nIndex = BranchClosestNodeToVertex(sPData, vert);
vertexPostion = "mid";
}
}
}
// convert mouse position to vector3 world space
Func <Vector2, Vector3> MousePos_To_Vector3 = delegate(Vector2 mousePosition)
{
float distance = 0.0f;
RaycastHit Hit;
Ray ray = new Ray();
Plane m_Plane;
Vector3 hitPoint = Vector3.zero;
ray = HandleUtility.GUIPointToWorldRay(mousePosition);
if (Camera.current.transform.eulerAngles == new Vector3(0, 0, 0) || Camera.current.transform.eulerAngles == new Vector3(0, 180, 0))
{
m_Plane = new Plane(Vector3.forward, Vector3.zero);
}
else if (Camera.current.transform.eulerAngles == new Vector3(90, 0, 0) || Camera.current.transform.eulerAngles == new Vector3(270, 0, 0))
{
m_Plane = new Plane(Vector3.up, Vector3.zero);
}
else if (Camera.current.transform.eulerAngles == new Vector3(0, 90, 0) || Camera.current.transform.eulerAngles == new Vector3(0, 270, 0))
{
m_Plane = new Plane(Vector3.right, Vector3.zero);
}
else
{
m_Plane = new Plane(Vector3.up, Vector3.zero);
}
if (Physics.Raycast(ray, out Hit))
{
hitPoint = Hit.point;
}
else if (m_Plane.Raycast(ray, out distance))
{
hitPoint = ray.GetPoint(distance);
}
return(hitPoint);
};
// Add node to branch when click is performed
Action <Vector3> Add_Node_Click = delegate(Vector3 pos)
{
if (Event.current.type == EventType.MouseDown && Event.current.button == 0)
{
Undo.RecordObject(sPData.SplinePlus, "Node added");
Func <string, Vector3, Quaternion, Transform, Transform> CreatePoint = delegate(string name, Vector3 Pos, Quaternion Rot, Transform Parent)
{
var Obj = new GameObject(name);
Obj.hideFlags = HideFlags.HideInHierarchy;
Obj.transform.position = Pos;
Obj.transform.rotation = Rot;
Obj.transform.parent = Parent;
return(Obj.transform);
};
var node = new Node();
node._Type = sPData.SplineSettings.NodeType;
node.Point = CreatePoint("p", pos, Quaternion.identity, sPData.SplinePlus.gameObject.transform);
node.Point1 = CreatePoint("p1", node.Point.position, Quaternion.identity, node.Point);
node.Point2 = CreatePoint("p2", node.Point.position, Quaternion.identity, node.Point);
if (sPData.Close)
{
SplinePlusAPI.Add_Node_At_Index(sPData, node, nIndex + 1);
}
else
{
if (vertexPostion == "beg" || vertexPostion == "init")
{
SplinePlusAPI.Add_Node_Beginning(sPData, node);
}
else if (vertexPostion == "end")
{
SplinePlusAPI.Add_Node_End(sPData, node);
}
else
{
SplinePlusAPI.Add_Node_At_Index(sPData, node, nIndex + 1);
}
}
}
};
//perform node adding when click event happens
if (vertexPostion == "init")
{
var hitPoint = MousePos_To_Vector3(Event.current.mousePosition);
Handles.color = Color.yellow;
Handles.SphereHandleCap(0, hitPoint, Quaternion.identity, sPData.SplineSettings.GizmosSize * 2, EventType.Repaint);
Add_Node_Click(hitPoint);
}
// node added to the beginning of the branch
else if (vertexPostion == "beg")
{
var pos = MousePos_To_Vector3(Event.current.mousePosition);
var node = sPData.Nodes[0];
Preview(sPData, node.Point.position, pos);
Add_Node_Click(pos);
}
// node added to the end of the branch
else if (vertexPostion == "end")
{
var pos = MousePos_To_Vector3(Event.current.mousePosition);
var node = sPData.Nodes[sPData.Nodes.Count - 1];
Preview(sPData, node.Point.position, pos);
Add_Node_Click(pos);
}
// node added in the middle of the branch
else
{
Handles.color = Color.yellow;
Handles.SphereHandleCap(0, vert, Quaternion.identity, sPData.SplineSettings.GizmosSize * 2, EventType.Repaint);
Add_Node_Click(vert);
}
}