public void Collapse() { SplineComputer lastComputer = _elements[_elements.Length - 1].computer; int lastStart = _elements[_elements.Length - 1].startPoint; int lastEnd = _elements[_elements.Length - 1].endPoint; _elements = new Element[1]; _elements[0] = new Element(); _elements[0].computer = lastComputer; _elements[0].startPoint = lastStart; _elements[0].endPoint = lastEnd; }
public static void UnregisterComputer(SplineComputer comp) { for (int i = 0; i < drawComputers.Count; i++) { if (drawComputers[i] == comp) { drawComputers[i].alwaysDraw = false; drawComputers.RemoveAt(i); return; } } }
public void Collapse() { SplineComputer computer = _elements[_elements.Length - 1].computer; int startPoint = _elements[_elements.Length - 1].startPoint; int endPoint = _elements[_elements.Length - 1].endPoint; _elements = new Element[1]; _elements[0] = new Element(); _elements[0].computer = computer; _elements[0].startPoint = startPoint; _elements[0].endPoint = endPoint; }
public BendProperty(Transform t, bool isParent = false) { parent = isParent; transform = new TS_Transform(t); originalPosition = t.localPosition; originalScale = t.localScale; originalRotation = t.localRotation; parentRotation = t.transform.rotation; if (t.transform.parent != null) { parentRotation = t.transform.parent.rotation; } filter = t.GetComponent <MeshFilter>(); collider = t.GetComponent <MeshCollider>(); if (filter != null && filter.sharedMesh != null) { originalMesh = filter.sharedMesh; normals = originalMesh.normals; for (int i = 0; i < normals.Length; i++) { normals[i] = transform.transform.TransformDirection(normals[i]).normalized; } } if (collider != null && collider.sharedMesh != null) { originalColliderMesh = collider.sharedMesh; colliderNormals = originalColliderMesh.normals; for (int i = 0; i < colliderNormals.Length; i++) { colliderNormals[i] = transform.transform.TransformDirection(colliderNormals[i]); } } if (!parent) { splineComputer = t.GetComponent <SplineComputer>(); } if (splineComputer != null) { if (splineComputer.isClosed) { originalSpline.Close(); } destinationSpline = new Spline(originalSpline.type); destinationSpline.points = new SplinePoint[originalSpline.points.Length]; destinationSpline.points = splineComputer.GetPoints(); if (splineComputer.isClosed) { destinationSpline.Close(); } } }
public override void OnInspectorGUI() { Node node = (Node)target; SplineComputer lastComp = addComp; addComp = (SplineComputer)EditorGUILayout.ObjectField("Add Computer", addComp, typeof(SplineComputer), true); if (lastComp != addComp) { SceneView.RepaintAll(); if (addComp != null) { availablePoints = GetAvailablePoints(addComp); } } if (addComp != null) { string[] pointNames = new string[availablePoints.Length]; for (int i = 0; i < pointNames.Length; i++) { pointNames[i] = "Point " + availablePoints[i]; } if (availablePoints.Length > 0) { addPoint = EditorGUILayout.Popup("Link point", addPoint, pointNames); } else { EditorGUILayout.LabelField("No Points Available"); } if (GUILayout.Button("Cancel")) { addComp = null; addPoint = 0; } if (addPoint >= 0 && availablePoints.Length > addPoint) { if (node.HasConnection(addComp, availablePoints[addPoint])) { EditorGUILayout.HelpBox("Connection already exists (" + addComp.name + "," + availablePoints[addPoint], MessageType.Error); } else if (GUILayout.Button("Link")) { AddConnection(addComp, availablePoints[addPoint]); } } } else { RenderConnections(); } }
/// <summary> /// Adds new columns. /// New points of the spline are added. Their positions are calculated from their twin predecessor in the spline. /// </summary> /// <param name="newPoints"> Overall count of points wanted in the new spline. </param> /// <param name="sc"> SplineComputer of the spline that is being adjusted. </param> protected void AddColumns(int newPoints, SplineComputer sc) { for (int i = 0; i < newPoints; ++i) { int index = currentPointCount - basePointCount + 1; var twinPoint = sc.GetPoint(index); sc.SetPointPosition(currentPointCount, new Vector3(twinPoint.position.x + width, twinPoint.position.y, twinPoint.position.z)); sc.SetPointSize(currentPointCount, point_size); sc.SetPointColor(currentPointCount, Color.white); sc.SetPointNormal(currentPointCount, sc.GetPointNormal(index)); currentPointCount++; } }
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); }
List <SplineComputer> GetSelectedSplines() { List <SplineComputer> selected = new List <SplineComputer>(); foreach (GameObject obj in Selection.gameObjects) { SplineComputer comp = obj.GetComponent <SplineComputer>(); if (comp != null) { selected.Add(comp); } } return(selected); }
/// <summary> /// Enter a junction address. /// </summary> /// <param name="element">The address element to add to the address</param> public virtual void AddComputer(SplineComputer computer, int connectionIndex, int connectedIndex, Spline.Direction direction = Spline.Direction.Forward) { if (sampleUser) { return; } int lastDepth = _address.depth; address.AddSpline(computer, connectionIndex, connectedIndex, direction); if (_address.depth != lastDepth) { Rebuild(true); } }
public virtual bool HasConnection(SplineComputer computer, int pointIndex) { for (int num = connections.Length - 1; num >= 0; num--) { if (!connections[num].isValid) { RemoveConnection(num); } else if (connections[num].computer == computer && connections[num].pointIndex == pointIndex) { return(true); } } return(false); }
Vector3 GetOrigin(SplineComputer comp) { Vector3 avg = Vector3.zero; SplinePoint[] points = comp.GetPoints(SplineComputer.Space.Local); for (int i = 0; i < comp.pointCount; i++) { avg += points[i].position; } if (points.Length > 0) { avg /= points.Length; } return(avg); }
private void GetObjects() { List <Transform> found = new List <Transform>(); GetTransformsRecursively(transform, ref found); BendProperty[] newProperties = new BendProperty[found.Count]; for (int i = 0; i < found.Count; i++) { CreateProperty(ref newProperties[i], found[i]); } bendProperties = newProperties; SplineComputer splineComponent = GetComponent <SplineComputer>(); _parentIsTheSpline = splineComponent == spline; }
protected override void OnSplineRemoved(SplineComputer spline) { base.OnSplineRemoved(spline); for (int i = 0; i < collections.Count; i++) { if (collections[i].spline == spline) { collections[i].Clear(); collections.RemoveAt(i); spline.onRebuild -= Rebuild; Rebuild(); return; } } }
protected override void OnSplineRemoved(SplineComputer spline) { base.OnSplineAdded(spline); for (int i = 0; i < controllers.Count; i++) { if (controllers[i].computer == spline) { GameObject.DestroyImmediate(controllers[i].gameObject); controllers.RemoveAt(i); i--; continue; } } Rebuild(); }
protected ObjectController CreateController(SplineComputer computer, string name) { GameObject obj = new GameObject(name); obj.transform.position = computer.transform.position; obj.transform.rotation = computer.transform.rotation; obj.transform.localScale = computer.transform.localScale; obj.transform.parent = computer.transform; obj.transform.localPosition = Vector3.zero; obj.transform.localRotation = Quaternion.identity; obj.transform.localScale = Vector3.one; ObjectController controller = obj.AddComponent <ObjectController>(); controller.computer = computer; return(controller); }
public virtual bool HasConnection(SplineComputer computer, int pointIndex) { for (int i = connections.Length - 1; i >= 0; i--) { if (!connections[i].isValid) { RemoveConnection(i); continue; } if (connections[i].computer == computer && connections[i].pointIndex == pointIndex) { return(true); } } return(false); }
public SplineEditorToolbar(SplineEditor edit, SplineComputer comp) { editor = edit; computer = comp; Texture2D tex = SplineEditorGUI.LoadTexture("presets.png"); if (tex != null) { presetButtonContent.image = tex; presetButtonContent.text = ""; } tex = SplineEditorGUI.LoadTexture("move.png"); if (tex != null) { moveButtonContent.image = tex; moveButtonContent.text = ""; } tex = SplineEditorGUI.LoadTexture("rotate.png"); if (tex != null) { rotateButtonContent.image = tex; rotateButtonContent.text = ""; } tex = SplineEditorGUI.LoadTexture("scale.png"); if (tex != null) { scaleButtonContent.image = tex; scaleButtonContent.text = ""; } tex = SplineEditorGUI.LoadTexture("normals.png"); if (tex != null) { normalsButtonContent.image = tex; normalsButtonContent.text = ""; } tex = SplineEditorGUI.LoadTexture("mirror.png"); if (tex != null) { mirrorButtonContent.image = tex; mirrorButtonContent.text = ""; } tex = SplineEditorGUI.LoadTexture("merge.png"); if (tex != null) { mergeButtonContent.image = tex; mergeButtonContent.text = ""; } }
protected virtual void BuildObject(SplineComputer computer, string name) { if (obj != null) { GameObject.DestroyImmediate(obj); } obj = new GameObject(name); obj.transform.position = computer.transform.position; obj.transform.rotation = computer.transform.rotation; obj.transform.localScale = computer.transform.localScale; obj.transform.parent = computer.transform; obj.transform.localPosition = Vector3.zero; obj.transform.localRotation = Quaternion.identity; obj.transform.localScale = Vector3.one; spawner = obj.AddComponent <ObjectController>(); spawner.computer = computer; }
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 virtual void RemoveConnection(SplineComputer computer, int pointIndex) { int index = -1; for (int i = 0; i < connections.Length; i++) { if (connections[i].pointIndex == pointIndex && connections[i].spline == computer) { index = i; break; } } if (index < 0) { return; } RemoveConnection(index); }
public virtual void RemoveConnection(SplineComputer computer, int pointIndex) { int index = -1; for (int i = 0; i < connections.Length; i++) { if (connections[i].computer == computer && connections[i].pointIndex == pointIndex) { index = i; break; } } if (index < 0) { Debug.LogError("Connection not found in " + name); return; } RemoveConnection(index); }
public static int PointSelectionMenu(SplineComputer computer, int selected = 0, string title = "Select point") { GUILayout.Box(title, GUILayout.Width(Screen.width - 45), GUILayout.Height(50)); GUI.BeginGroup(GUILayoutUtility.GetLastRect()); string[] options = new string[(computer.isClosed ? computer.pointCount - 1 : computer.pointCount) + 1]; for (int i = 0; i < options.Length - 1; i++) { options[i + 1] = "Point " + i; if (computer.type == Spline.Type.Bezier) { options[i + 1] = "Point " + i + " Bezier " + (computer.GetPoint(i, SplineComputer.Space.Local).type == SplinePoint.Type.Smooth ? "(smooth)" : "(broken)"); } } options[0] = "- Select -"; int selection = EditorGUI.Popup(new Rect(10, 25, Screen.width - 65, 30), selected, options) - 1; GUI.EndGroup(); return(selection); }
void MergeComputer(SplineComputer from, double mapFrom, double mapTo) { SplineUser[] subs = from.GetSubscribers(); for (int i = 0; i < subs.Length; i++) { from.Unsubscribe(subs[i]); subs[i].computer = computer; subs[i].clipFrom = DMath.Lerp(mapFrom, mapTo, subs[i].clipFrom); subs[i].clipTo = DMath.Lerp(mapFrom, mapTo, subs[i].clipTo); } if (EditorUtility.DisplayDialog("Keep merged computer's GameObject?", "Do you want to keep the merged computer's game object? This will transfer all subscribed users to the current computer.", "Yes", "No")) { GameObject.DestroyImmediate(from); } else { GameObject.DestroyImmediate(from.gameObject); } }
void SplitAtPercent(double percent, ref SplinePoint[] points) { Undo.RecordObject(computer, "Split At Percent "); EditorUtility.SetDirty(computer); float pointValue = (computer.pointCount - 1) * (float)percent; int lastPointIndex = Mathf.FloorToInt(pointValue); int nextPointIndex = Mathf.CeilToInt(pointValue); SplinePoint[] splitPoints = new SplinePoint[computer.pointCount - lastPointIndex]; float lerpPercent = Mathf.InverseLerp(lastPointIndex, nextPointIndex, pointValue); SplinePoint splitPoint = SplinePoint.Lerp(computer.GetPoint(lastPointIndex), computer.GetPoint(nextPointIndex), lerpPercent); splitPoint.SetPosition(computer.EvaluatePosition(percent)); splitPoints[0] = splitPoint; for (int i = 1; i < splitPoints.Length; i++) { splitPoints[i] = computer.GetPoint(lastPointIndex + i); } SplineComputer spline = CreateNewSpline(); spline.SetPoints(splitPoints); SplineUser[] users = spline.GetSubscribers(); for (int i = 0; i < users.Length; i++) { users[i].clipFrom = DMath.InverseLerp(percent, 1.0, users[i].clipFrom); users[i].clipTo = DMath.InverseLerp(percent, 1.0, users[i].clipTo); } splitPoints = new SplinePoint[lastPointIndex + 2]; for (int i = 0; i <= lastPointIndex; i++) { splitPoints[i] = computer.GetPoint(i); } splitPoints[splitPoints.Length - 1] = splitPoint; points = splitPoints; users = computer.GetSubscribers(); for (int i = 0; i < users.Length; i++) { users[i].clipFrom = DMath.InverseLerp(0.0, percent, users[i].clipFrom); users[i].clipTo = DMath.InverseLerp(0.0, percent, users[i].clipTo); } HandleNodes(spline, lastPointIndex); }
void GetAvailable() { if (user == null) { return; } currentComputer = user.address.elements[user.address.depth - 1].computer; if (currentComputer == null) { return; } double startPercent = (double)user.address.elements[user.address.depth - 1].startPoint / (currentComputer.pointCount - 1); Spline.Direction dir = Spline.Direction.Forward; if (user.address.elements[user.address.depth - 1].startPoint > user.address.elements[user.address.depth - 1].endPoint) { dir = Spline.Direction.Backward; } int[] available = currentComputer.GetAvailableNodeLinksAtPosition(startPercent, dir); nodes = new List <Node>(); connectionIndices = new List <int>(); pointIndices = new List <int>(); for (int i = 0; i < available.Length; i++) { Node node = currentComputer.nodeLinks[available[i]].node; if (currentComputer.nodeLinks[available[i]].pointIndex == user.address.elements[user.address.depth - 1].startPoint) { continue; } Node.Connection[] connections = node.GetConnections(); for (int n = 0; n < connections.Length; n++) { if (connections[n].computer == currentComputer) { continue; } nodes.Add(node); connectionIndices.Add(n); pointIndices.Add(currentComputer.nodeLinks[available[i]].pointIndex); } } }
SplineComputer CreateNewSpline() { GameObject go = GameObject.Instantiate(computer.gameObject); go.name = computer.name + "_split"; SplineUser[] users = go.GetComponents <SplineUser>(); SplineComputer spline = go.GetComponent <SplineComputer>(); for (int i = 0; i < users.Length; i++) { computer.Unsubscribe(users[i]); users[i].computer = spline; spline.Subscribe(users[i]); } for (int i = go.transform.childCount - 1; i >= 0; i--) { GameObject.DestroyImmediate(go.transform.GetChild(i).gameObject); } return(spline); }
public void UpdateConnectedComputers(SplineComputer excludeComputer = null) { for (int i = connections.Length - 1; i >= 0; i--) { if (!connections[i].isValid) { RemoveConnection(i); continue; } if (connections[i].computer == excludeComputer) { continue; } if (type == Type.Smooth && i != 0) { SetPoint(i, GetPoint(0)); } connections[i].computer.SetPoint(connections[i].pointIndex, GetPoint(i)); } }
public virtual void AddConnection(SplineComputer computer, int pointIndex) { RemoveInvalidConnections(); Node connected = computer.GetNode(pointIndex); if (connected != null) { Debug.LogError(computer.name + " is already connected to node " + connected.name + " at point " + pointIndex); return; } SplinePoint point = computer.GetPoint(pointIndex); point.SetPosition(transform.position); ArrayUtility.Add(ref connections, new Connection(computer, pointIndex, PointToLocal(point))); if (connections.Length == 1) { SetPoint(connections.Length - 1, point, true); } UpdateConnectedComputers(); }
/// <summary> /// Used to get the available junctions. Call this to update the junction list on the GUI. /// </summary> public void GetAvailableJunctions() { //Get the last SplineComputer in the junction address currentComputer = follower.address.elements[follower.address.depth - 1].computer; if (currentComputer == null) { return; } //Get the available junctions at the current address double startPercent = (double)follower.address.elements[follower.address.depth - 1].startPoint / (currentComputer.pointCount - 1); Spline.Direction dir = Spline.Direction.Forward; if (follower.address.elements[follower.address.depth - 1].startPoint > follower.address.elements[follower.address.depth - 1].endPoint) { dir = Spline.Direction.Backward; } int[] available = currentComputer.GetAvailableNodeLinksAtPosition(startPercent, dir); nodes.Clear(); connectionIndices.Clear(); pointIndices.Clear(); //Make a list of the available junctions which to use in OnGUI for the buttons for (int i = 0; i < available.Length; i++) { Node node = currentComputer.nodeLinks[available[i]].node; if (currentComputer.nodeLinks[available[i]].pointIndex == follower.address.elements[follower.address.depth - 1].startPoint) { continue; } Node.Connection[] connections = node.GetConnections(); for (int n = 0; n < connections.Length; n++) { if (connections[n].computer == currentComputer) { continue; } nodes.Add(node); connectionIndices.Add(n); pointIndices.Add(currentComputer.nodeLinks[available[i]].pointIndex); } } }
public virtual void RemoveConnection(SplineComputer computer, int pointIndex) { int num = -1; for (int i = 0; i < connections.Length; i++) { if (connections[i].computer == computer && connections[i].pointIndex == pointIndex) { num = i; break; } } if (num < 0) { UnityEngine.Debug.LogError("Connection not found in " + base.name); } else { RemoveConnection(num); } }