From 513b0a1eb333fa804fb26d277aa3eea7383885e4 Mon Sep 17 00:00:00 2001 From: Cat Flynn Date: Fri, 12 Mar 2021 14:33:05 +0000 Subject: [PATCH 01/19] import pathcreator --- game/Assets/PathCreator.meta | 8 + game/Assets/PathCreator/Core.meta | 10 + game/Assets/PathCreator/Core/Editor.meta | 8 + .../PathCreator/Core/Editor/Helper.meta | 8 + .../Core/Editor/Helper/MouseUtility.cs | 43 + .../Core/Editor/Helper/MouseUtility.cs.meta | 11 + .../Core/Editor/Helper/PathHandle.cs | 237 ++ .../Core/Editor/Helper/PathHandle.cs.meta | 11 + .../Core/Editor/Helper/ScreenSpacePolyLine.cs | 215 ++ .../Editor/Helper/ScreenSpacePolyLine.cs.meta | 11 + .../Core/Editor/PathCreatorEditor.asmdef | 16 + .../Core/Editor/PathCreatorEditor.asmdef.meta | 7 + .../PathCreator/Core/Editor/PathEditor.cs | 736 +++++++ .../Core/Editor/PathEditor.cs.meta | 13 + game/Assets/PathCreator/Core/Runtime.meta | 8 + .../PathCreator/Core/Runtime/Objects.meta | 8 + .../Core/Runtime/Objects/BezierPath.cs | 678 ++++++ .../Core/Runtime/Objects/BezierPath.cs.meta | 13 + .../Runtime/Objects/EndOfPathInstruction.cs | 3 + .../Objects/EndOfPathInstruction.cs.meta | 11 + .../Runtime/Objects/GlobalDisplaySettings.cs | 70 + .../Objects/GlobalDisplaySettings.cs.meta | 11 + .../Core/Runtime/Objects/MinMax3D.cs | 21 + .../Core/Runtime/Objects/MinMax3D.cs.meta | 11 + .../Core/Runtime/Objects/PathCreator.cs | 112 + .../Core/Runtime/Objects/PathCreator.cs.meta | 13 + .../Core/Runtime/Objects/PathCreatorData.cs | 136 ++ .../Runtime/Objects/PathCreatorData.cs.meta | 11 + .../Core/Runtime/Objects/PathSpace.cs | 3 + .../Core/Runtime/Objects/PathSpace.cs.meta | 11 + .../Core/Runtime/Objects/VertexPath.cs | 345 +++ .../Core/Runtime/Objects/VertexPath.cs.meta | 11 + .../Core/Runtime/PathCreator.asmdef | 3 + .../Core/Runtime/PathCreator.asmdef.meta | 7 + .../PathCreator/Core/Runtime/Utility.meta | 8 + .../Runtime/Utility/CubicBezierUtility.cs | 136 ++ .../Utility/CubicBezierUtility.cs.meta | 13 + .../Core/Runtime/Utility/MathUtility.cs | 162 ++ .../Core/Runtime/Utility/MathUtility.cs.meta | 11 + .../Core/Runtime/Utility/VertexPathUtility.cs | 139 ++ .../Runtime/Utility/VertexPathUtility.cs.meta | 11 + game/Assets/PathCreator/Core/Settings.meta | 8 + .../Core/Settings/GlobalDisplaySettings.asset | 36 + .../Settings/GlobalDisplaySettings.asset.meta | 8 + game/Assets/PathCreator/Documentation.meta | 8 + .../Documentation/Documentation.pdf | Bin 0 -> 524885 bytes .../Documentation/Documentation.pdf.meta | 7 + game/Assets/PathCreator/Examples.meta | 9 + .../PathCreator/Examples/Materials.meta | 8 + .../PathCreator/Examples/Materials/Black.mat | 76 + .../Examples/Materials/Black.mat.meta | 8 + .../PathCreator/Examples/Materials/Blue.mat | 76 + .../Examples/Materials/Blue.mat.meta | 8 + .../PathCreator/Examples/Materials/Brown.mat | 77 + .../Examples/Materials/Brown.mat.meta | 10 + .../Examples/Materials/Dark Grey.mat | 77 + .../Examples/Materials/Dark Grey.mat.meta | 8 + .../PathCreator/Examples/Materials/Green.mat | 76 + .../Examples/Materials/Green.mat.meta | 8 + .../PathCreator/Examples/Materials/Red.mat | 76 + .../Examples/Materials/Red.mat.meta | 8 + .../Examples/Materials/Road Texture.png | 3 + .../Examples/Materials/Road Texture.png.meta | 74 + .../Examples/Materials/Road Underside.mat | 76 + .../Materials/Road Underside.mat.meta | 10 + .../PathCreator/Examples/Materials/Road.mat | 76 + .../Examples/Materials/Road.mat.meta | 9 + game/Assets/PathCreator/Examples/Prefabs.meta | 8 + .../PathCreator/Examples/Prefabs/Cube.prefab | 79 + .../Examples/Prefabs/Cube.prefab.meta | 7 + .../Examples/Prefabs/Follower.prefab | 450 ++++ .../Examples/Prefabs/Follower.prefab.meta | 8 + .../PathCreator/Examples/Prefabs/Path.prefab | 106 + .../Examples/Prefabs/Path.prefab.meta | 8 + .../Examples/Prefabs/Sphere.prefab | 79 + .../Examples/Prefabs/Sphere.prefab.meta | 7 + game/Assets/PathCreator/Examples/Scenes.meta | 8 + .../Examples/Scenes/Follow Path.unity | 393 ++++ .../Examples/Scenes/Follow Path.unity.meta | 7 + .../Examples/Scenes/Generate Path.unity | 973 +++++++++ .../Examples/Scenes/Generate Path.unity.meta | 7 + .../Examples/Scenes/Object Placement.unity | 1944 +++++++++++++++++ .../Scenes/Object Placement.unity.meta | 7 + .../Examples/Scenes/Path as Prefab.unity | 517 +++++ .../Examples/Scenes/Path as Prefab.unity.meta | 7 + .../PathCreator/Examples/Scenes/Road.unity | 678 ++++++ .../Examples/Scenes/Road.unity.meta | 7 + game/Assets/PathCreator/Examples/Scripts.meta | 8 + .../PathCreator/Examples/Scripts/Editor.meta | 8 + .../Scripts/Editor/PathSceneToolEditor.cs | 108 + .../Editor/PathSceneToolEditor.cs.meta | 11 + .../Examples/Scripts/GeneratePathExample.cs | 20 + .../Scripts/GeneratePathExample.cs.meta | 11 + .../Examples/Scripts/PathFollower.cs | 38 + .../Examples/Scripts/PathFollower.cs.meta | 11 + .../Examples/Scripts/PathPlacer.cs | 46 + .../Examples/Scripts/PathPlacer.cs.meta | 11 + .../Examples/Scripts/PathSceneTool.cs | 31 + .../Examples/Scripts/PathSceneTool.cs.meta | 11 + .../Examples/Scripts/PathSpawner.cs | 25 + .../Examples/Scripts/PathSpawner.cs.meta | 11 + .../Examples/Scripts/RoadMeshCreator.cs | 155 ++ .../Examples/Scripts/RoadMeshCreator.cs.meta | 15 + 103 files changed, 9960 insertions(+) create mode 100644 game/Assets/PathCreator.meta create mode 100644 game/Assets/PathCreator/Core.meta create mode 100644 game/Assets/PathCreator/Core/Editor.meta create mode 100644 game/Assets/PathCreator/Core/Editor/Helper.meta create mode 100644 game/Assets/PathCreator/Core/Editor/Helper/MouseUtility.cs create mode 100644 game/Assets/PathCreator/Core/Editor/Helper/MouseUtility.cs.meta create mode 100644 game/Assets/PathCreator/Core/Editor/Helper/PathHandle.cs create mode 100644 game/Assets/PathCreator/Core/Editor/Helper/PathHandle.cs.meta create mode 100644 game/Assets/PathCreator/Core/Editor/Helper/ScreenSpacePolyLine.cs create mode 100644 game/Assets/PathCreator/Core/Editor/Helper/ScreenSpacePolyLine.cs.meta create mode 100644 game/Assets/PathCreator/Core/Editor/PathCreatorEditor.asmdef create mode 100644 game/Assets/PathCreator/Core/Editor/PathCreatorEditor.asmdef.meta create mode 100644 game/Assets/PathCreator/Core/Editor/PathEditor.cs create mode 100644 game/Assets/PathCreator/Core/Editor/PathEditor.cs.meta create mode 100644 game/Assets/PathCreator/Core/Runtime.meta create mode 100644 game/Assets/PathCreator/Core/Runtime/Objects.meta create mode 100644 game/Assets/PathCreator/Core/Runtime/Objects/BezierPath.cs create mode 100644 game/Assets/PathCreator/Core/Runtime/Objects/BezierPath.cs.meta create mode 100644 game/Assets/PathCreator/Core/Runtime/Objects/EndOfPathInstruction.cs create mode 100644 game/Assets/PathCreator/Core/Runtime/Objects/EndOfPathInstruction.cs.meta create mode 100644 game/Assets/PathCreator/Core/Runtime/Objects/GlobalDisplaySettings.cs create mode 100644 game/Assets/PathCreator/Core/Runtime/Objects/GlobalDisplaySettings.cs.meta create mode 100644 game/Assets/PathCreator/Core/Runtime/Objects/MinMax3D.cs create mode 100644 game/Assets/PathCreator/Core/Runtime/Objects/MinMax3D.cs.meta create mode 100644 game/Assets/PathCreator/Core/Runtime/Objects/PathCreator.cs create mode 100644 game/Assets/PathCreator/Core/Runtime/Objects/PathCreator.cs.meta create mode 100644 game/Assets/PathCreator/Core/Runtime/Objects/PathCreatorData.cs create mode 100644 game/Assets/PathCreator/Core/Runtime/Objects/PathCreatorData.cs.meta create mode 100644 game/Assets/PathCreator/Core/Runtime/Objects/PathSpace.cs create mode 100644 game/Assets/PathCreator/Core/Runtime/Objects/PathSpace.cs.meta create mode 100644 game/Assets/PathCreator/Core/Runtime/Objects/VertexPath.cs create mode 100644 game/Assets/PathCreator/Core/Runtime/Objects/VertexPath.cs.meta create mode 100644 game/Assets/PathCreator/Core/Runtime/PathCreator.asmdef create mode 100644 game/Assets/PathCreator/Core/Runtime/PathCreator.asmdef.meta create mode 100644 game/Assets/PathCreator/Core/Runtime/Utility.meta create mode 100644 game/Assets/PathCreator/Core/Runtime/Utility/CubicBezierUtility.cs create mode 100644 game/Assets/PathCreator/Core/Runtime/Utility/CubicBezierUtility.cs.meta create mode 100644 game/Assets/PathCreator/Core/Runtime/Utility/MathUtility.cs create mode 100644 game/Assets/PathCreator/Core/Runtime/Utility/MathUtility.cs.meta create mode 100644 game/Assets/PathCreator/Core/Runtime/Utility/VertexPathUtility.cs create mode 100644 game/Assets/PathCreator/Core/Runtime/Utility/VertexPathUtility.cs.meta create mode 100644 game/Assets/PathCreator/Core/Settings.meta create mode 100644 game/Assets/PathCreator/Core/Settings/GlobalDisplaySettings.asset create mode 100644 game/Assets/PathCreator/Core/Settings/GlobalDisplaySettings.asset.meta create mode 100644 game/Assets/PathCreator/Documentation.meta create mode 100644 game/Assets/PathCreator/Documentation/Documentation.pdf create mode 100644 game/Assets/PathCreator/Documentation/Documentation.pdf.meta create mode 100644 game/Assets/PathCreator/Examples.meta create mode 100644 game/Assets/PathCreator/Examples/Materials.meta create mode 100644 game/Assets/PathCreator/Examples/Materials/Black.mat create mode 100644 game/Assets/PathCreator/Examples/Materials/Black.mat.meta create mode 100644 game/Assets/PathCreator/Examples/Materials/Blue.mat create mode 100644 game/Assets/PathCreator/Examples/Materials/Blue.mat.meta create mode 100644 game/Assets/PathCreator/Examples/Materials/Brown.mat create mode 100644 game/Assets/PathCreator/Examples/Materials/Brown.mat.meta create mode 100644 game/Assets/PathCreator/Examples/Materials/Dark Grey.mat create mode 100644 game/Assets/PathCreator/Examples/Materials/Dark Grey.mat.meta create mode 100644 game/Assets/PathCreator/Examples/Materials/Green.mat create mode 100644 game/Assets/PathCreator/Examples/Materials/Green.mat.meta create mode 100644 game/Assets/PathCreator/Examples/Materials/Red.mat create mode 100644 game/Assets/PathCreator/Examples/Materials/Red.mat.meta create mode 100644 game/Assets/PathCreator/Examples/Materials/Road Texture.png create mode 100644 game/Assets/PathCreator/Examples/Materials/Road Texture.png.meta create mode 100644 game/Assets/PathCreator/Examples/Materials/Road Underside.mat create mode 100644 game/Assets/PathCreator/Examples/Materials/Road Underside.mat.meta create mode 100644 game/Assets/PathCreator/Examples/Materials/Road.mat create mode 100644 game/Assets/PathCreator/Examples/Materials/Road.mat.meta create mode 100644 game/Assets/PathCreator/Examples/Prefabs.meta create mode 100644 game/Assets/PathCreator/Examples/Prefabs/Cube.prefab create mode 100644 game/Assets/PathCreator/Examples/Prefabs/Cube.prefab.meta create mode 100644 game/Assets/PathCreator/Examples/Prefabs/Follower.prefab create mode 100644 game/Assets/PathCreator/Examples/Prefabs/Follower.prefab.meta create mode 100644 game/Assets/PathCreator/Examples/Prefabs/Path.prefab create mode 100644 game/Assets/PathCreator/Examples/Prefabs/Path.prefab.meta create mode 100644 game/Assets/PathCreator/Examples/Prefabs/Sphere.prefab create mode 100644 game/Assets/PathCreator/Examples/Prefabs/Sphere.prefab.meta create mode 100644 game/Assets/PathCreator/Examples/Scenes.meta create mode 100644 game/Assets/PathCreator/Examples/Scenes/Follow Path.unity create mode 100644 game/Assets/PathCreator/Examples/Scenes/Follow Path.unity.meta create mode 100644 game/Assets/PathCreator/Examples/Scenes/Generate Path.unity create mode 100644 game/Assets/PathCreator/Examples/Scenes/Generate Path.unity.meta create mode 100644 game/Assets/PathCreator/Examples/Scenes/Object Placement.unity create mode 100644 game/Assets/PathCreator/Examples/Scenes/Object Placement.unity.meta create mode 100644 game/Assets/PathCreator/Examples/Scenes/Path as Prefab.unity create mode 100644 game/Assets/PathCreator/Examples/Scenes/Path as Prefab.unity.meta create mode 100644 game/Assets/PathCreator/Examples/Scenes/Road.unity create mode 100644 game/Assets/PathCreator/Examples/Scenes/Road.unity.meta create mode 100644 game/Assets/PathCreator/Examples/Scripts.meta create mode 100644 game/Assets/PathCreator/Examples/Scripts/Editor.meta create mode 100644 game/Assets/PathCreator/Examples/Scripts/Editor/PathSceneToolEditor.cs create mode 100644 game/Assets/PathCreator/Examples/Scripts/Editor/PathSceneToolEditor.cs.meta create mode 100644 game/Assets/PathCreator/Examples/Scripts/GeneratePathExample.cs create mode 100644 game/Assets/PathCreator/Examples/Scripts/GeneratePathExample.cs.meta create mode 100644 game/Assets/PathCreator/Examples/Scripts/PathFollower.cs create mode 100644 game/Assets/PathCreator/Examples/Scripts/PathFollower.cs.meta create mode 100644 game/Assets/PathCreator/Examples/Scripts/PathPlacer.cs create mode 100644 game/Assets/PathCreator/Examples/Scripts/PathPlacer.cs.meta create mode 100644 game/Assets/PathCreator/Examples/Scripts/PathSceneTool.cs create mode 100644 game/Assets/PathCreator/Examples/Scripts/PathSceneTool.cs.meta create mode 100644 game/Assets/PathCreator/Examples/Scripts/PathSpawner.cs create mode 100644 game/Assets/PathCreator/Examples/Scripts/PathSpawner.cs.meta create mode 100644 game/Assets/PathCreator/Examples/Scripts/RoadMeshCreator.cs create mode 100644 game/Assets/PathCreator/Examples/Scripts/RoadMeshCreator.cs.meta diff --git a/game/Assets/PathCreator.meta b/game/Assets/PathCreator.meta new file mode 100644 index 0000000..e3aaeef --- /dev/null +++ b/game/Assets/PathCreator.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: c78921add991a914aa4263c80d69a9d6 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/game/Assets/PathCreator/Core.meta b/game/Assets/PathCreator/Core.meta new file mode 100644 index 0000000..af53750 --- /dev/null +++ b/game/Assets/PathCreator/Core.meta @@ -0,0 +1,10 @@ +fileFormatVersion: 2 +guid: fded9f896ea32473eb30ae61b640a176 +folderAsset: yes +timeCreated: 1519645413 +licenseType: Store +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/game/Assets/PathCreator/Core/Editor.meta b/game/Assets/PathCreator/Core/Editor.meta new file mode 100644 index 0000000..081c996 --- /dev/null +++ b/game/Assets/PathCreator/Core/Editor.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 76c2f3171eae9954aa317277dbffd478 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/game/Assets/PathCreator/Core/Editor/Helper.meta b/game/Assets/PathCreator/Core/Editor/Helper.meta new file mode 100644 index 0000000..c7dd6da --- /dev/null +++ b/game/Assets/PathCreator/Core/Editor/Helper.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 366e41d4e3408334aad31e48f28757e4 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/game/Assets/PathCreator/Core/Editor/Helper/MouseUtility.cs b/game/Assets/PathCreator/Core/Editor/Helper/MouseUtility.cs new file mode 100644 index 0000000..0ae6b33 --- /dev/null +++ b/game/Assets/PathCreator/Core/Editor/Helper/MouseUtility.cs @@ -0,0 +1,43 @@ +using UnityEngine; +using UnityEditor; +using PathCreation; + +namespace PathCreationEditor +{ + public static class MouseUtility + { + /// + /// Determines mouse position in world. If PathSpace is xy/xz, the position will be locked to that plane. + /// If PathSpace is xyz, then depthFor3DSpace will be used as distance from scene camera. + /// + public static Vector3 GetMouseWorldPosition(PathSpace space, float depthFor3DSpace = 10) + { + Ray mouseRay = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition); + Vector3 worldMouse = mouseRay.GetPoint(depthFor3DSpace); + + // Mouse can only move on XY plane + if (space == PathSpace.xy) + { + float zDir = mouseRay.direction.z; + if (zDir != 0) + { + float dstToXYPlane = Mathf.Abs(mouseRay.origin.z / zDir); + worldMouse = mouseRay.GetPoint(dstToXYPlane); + } + } + // Mouse can only move on XZ plane + else if (space == PathSpace.xz) + { + float yDir = mouseRay.direction.y; + if (yDir != 0) + { + float dstToXZPlane = Mathf.Abs(mouseRay.origin.y / yDir); + worldMouse = mouseRay.GetPoint(dstToXZPlane); + } + } + + return worldMouse; + } + + } +} \ No newline at end of file diff --git a/game/Assets/PathCreator/Core/Editor/Helper/MouseUtility.cs.meta b/game/Assets/PathCreator/Core/Editor/Helper/MouseUtility.cs.meta new file mode 100644 index 0000000..4b5ec6b --- /dev/null +++ b/game/Assets/PathCreator/Core/Editor/Helper/MouseUtility.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: bd0de63ca5c52504a8d2063418a326c3 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/game/Assets/PathCreator/Core/Editor/Helper/PathHandle.cs b/game/Assets/PathCreator/Core/Editor/Helper/PathHandle.cs new file mode 100644 index 0000000..613fdb8 --- /dev/null +++ b/game/Assets/PathCreator/Core/Editor/Helper/PathHandle.cs @@ -0,0 +1,237 @@ +using System.Collections.Generic; +using UnityEngine; +using UnityEditor; +using PathCreation; + +namespace PathCreationEditor +{ + public static class PathHandle + { + + public const float extraInputRadius = .005f; + + static Vector2 handleDragMouseStart; + static Vector2 handleDragMouseEnd; + static Vector3 handleDragWorldStart; + + static int selectedHandleID; + static bool mouseIsOverAHandle; + + public enum HandleInputType + { + None, + LMBPress, + LMBClick, + LMBDrag, + LMBRelease, + }; + + static float dstMouseToDragPointStart; + + static List ids; + static HashSet idHash; + + static PathHandle() + { + ids = new List(); + idHash = new HashSet(); + + dstMouseToDragPointStart = float.MaxValue; + } + + public static Vector3 DrawHandle(Vector3 position, PathSpace space, bool isInteractive, float handleDiameter, Handles.CapFunction capFunc, HandleColours colours, out HandleInputType inputType, int handleIndex) + { + int id = GetID(handleIndex); + Vector3 screenPosition = Handles.matrix.MultiplyPoint(position); + Matrix4x4 cachedMatrix = Handles.matrix; + + inputType = HandleInputType.None; + + EventType eventType = Event.current.GetTypeForControl(id); + float handleRadius = handleDiameter / 2f; + float dstToHandle = HandleUtility.DistanceToCircle(position, handleRadius + extraInputRadius); + float dstToMouse = HandleUtility.DistanceToCircle(position, 0); + + // Handle input events + if (isInteractive) + { + // Repaint if mouse is entering/exiting handle (for highlight colour) + if (dstToHandle == 0) + { + if (!mouseIsOverAHandle) + { + HandleUtility.Repaint(); + mouseIsOverAHandle = true; + } + } + else + { + if (mouseIsOverAHandle) + { + HandleUtility.Repaint(); + mouseIsOverAHandle = false; + } + } + switch (eventType) + { + case EventType.MouseDown: + if (Event.current.button == 0 && Event.current.modifiers != EventModifiers.Alt) + { + if (dstToHandle == 0 && dstToMouse < dstMouseToDragPointStart) + { + dstMouseToDragPointStart = dstToMouse; + GUIUtility.hotControl = id; + handleDragMouseEnd = handleDragMouseStart = Event.current.mousePosition; + handleDragWorldStart = position; + selectedHandleID = id; + inputType = HandleInputType.LMBPress; + } + } + break; + + case EventType.MouseUp: + dstMouseToDragPointStart = float.MaxValue; + if (GUIUtility.hotControl == id && Event.current.button == 0) + { + GUIUtility.hotControl = 0; + selectedHandleID = -1; + Event.current.Use(); + + inputType = HandleInputType.LMBRelease; + + + if (Event.current.mousePosition == handleDragMouseStart) + { + inputType = HandleInputType.LMBClick; + } + } + break; + + case EventType.MouseDrag: + if (GUIUtility.hotControl == id && Event.current.button == 0) + { + handleDragMouseEnd += new Vector2(Event.current.delta.x, -Event.current.delta.y); + Vector3 position2 = Camera.current.WorldToScreenPoint(Handles.matrix.MultiplyPoint(handleDragWorldStart)) + + (Vector3)(handleDragMouseEnd - handleDragMouseStart); + inputType = HandleInputType.LMBDrag; + // Handle can move freely in 3d space + if (space == PathSpace.xyz) + { + position = Handles.matrix.inverse.MultiplyPoint(Camera.current.ScreenToWorldPoint(position2)); + } + // Handle is clamped to xy or xz plane + else + { + position = MouseUtility.GetMouseWorldPosition(space); + } + + GUI.changed = true; + Event.current.Use(); + } + break; + } + } + + switch (eventType) + { + case EventType.Repaint: + Color originalColour = Handles.color; + Handles.color = (isInteractive) ? colours.defaultColour : colours.disabledColour; + + if (id == GUIUtility.hotControl) + { + Handles.color = colours.selectedColour; + } + else if (dstToHandle == 0 && selectedHandleID == -1 && isInteractive) + { + Handles.color = colours.highlightedColour; + } + + + Handles.matrix = Matrix4x4.identity; + Vector3 lookForward = Vector3.up; + Camera cam = Camera.current; + if (cam != null) + { + if (cam.orthographic) + { + lookForward= -cam.transform.forward; + } + else + { + lookForward = (cam.transform.position - position); + } + } + + capFunc(id, screenPosition, Quaternion.LookRotation(lookForward), handleDiameter, EventType.Repaint); + Handles.matrix = cachedMatrix; + + Handles.color = originalColour; + break; + + case EventType.Layout: + Handles.matrix = Matrix4x4.identity; + HandleUtility.AddControl(id, HandleUtility.DistanceToCircle(screenPosition, handleDiameter / 2f)); + Handles.matrix = cachedMatrix; + break; + } + + return position; + } + + public struct HandleColours + { + public Color defaultColour; + public Color highlightedColour; + public Color selectedColour; + public Color disabledColour; + + public HandleColours(Color defaultColour, Color highlightedColour, Color selectedColour, Color disabledColour) + { + this.defaultColour = defaultColour; + this.highlightedColour = highlightedColour; + this.selectedColour = selectedColour; + this.disabledColour = disabledColour; + } + } + + static void AddIDs(int upToIndex) + { + int numIDAtStart = ids.Count; + int numToAdd = (upToIndex - numIDAtStart) + 1; + for (int i = 0; i < numToAdd; i++) + { + string hashString = string.Format("pathhandle({0})", numIDAtStart + i); + int hash = hashString.GetHashCode(); + + int id = GUIUtility.GetControlID(hash, FocusType.Passive); + int numIts = 0; + + // This is a bit of a shot in the dark at fixing a reported bug that I've been unable to reproduce. + // The problem is that multiple handles are being selected when just one is clicked on. + // I assume this is because they're somehow being assigned the same id. + while (idHash.Contains(id)) { + numIts ++; + id += numIts * numIts; + if (numIts > 100) { + Debug.LogError("Failed to generate unique handle id."); + break; + } + } + + idHash.Add(id); + ids.Add(id); + } + } + + static int GetID(int handleIndex) + { + if (handleIndex >= ids.Count) + { + AddIDs(handleIndex); + } + + return ids[handleIndex]; + } + } +} \ No newline at end of file diff --git a/game/Assets/PathCreator/Core/Editor/Helper/PathHandle.cs.meta b/game/Assets/PathCreator/Core/Editor/Helper/PathHandle.cs.meta new file mode 100644 index 0000000..4dee2f9 --- /dev/null +++ b/game/Assets/PathCreator/Core/Editor/Helper/PathHandle.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 804ddb43548540a4ca3b0a534a75c4b3 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/game/Assets/PathCreator/Core/Editor/Helper/ScreenSpacePolyLine.cs b/game/Assets/PathCreator/Core/Editor/Helper/ScreenSpacePolyLine.cs new file mode 100644 index 0000000..50b28a2 --- /dev/null +++ b/game/Assets/PathCreator/Core/Editor/Helper/ScreenSpacePolyLine.cs @@ -0,0 +1,215 @@ +using System.Collections.Generic; +using UnityEngine; +using UnityEditor; +using PathCreation; +using PathCreation.Utility; + +namespace PathCreationEditor +{ + public class ScreenSpacePolyLine + { + const int accuracyMultiplier = 10; + // dont allow vertices to be spaced too far apart, as screenspace-worldspace conversion can then be noticeably off + const float intermediaryThreshold = .2f; + + public readonly List verticesWorld; + // For each point in the polyline, says which bezier segment it belongs to + readonly List vertexToPathSegmentMap; + // Stores the index in the vertices list where the start point of each segment is + readonly int[] segmentStartIndices; + + readonly float pathLengthWorld; + readonly float[] cumululativeLengthWorld; + + Vector2[] points; + + Vector3 prevCamPos; + Quaternion prevCamRot; + bool premCamIsOrtho; + + readonly Transform transform; + readonly Vector3 transformPosition; + readonly Quaternion transformRotation; + readonly Vector3 transformScale; + + public ScreenSpacePolyLine(BezierPath bezierPath, Transform transform, float maxAngleError, float minVertexDst, float accuracy = 1) + { + this.transform = transform; + transformPosition = transform.position; + transformRotation = transform.rotation; + transformScale = transform.localScale; + + // Split path in vertices based on angle error + verticesWorld = new List(); + vertexToPathSegmentMap = new List(); + segmentStartIndices = new int[bezierPath.NumSegments+1]; + + verticesWorld.Add(bezierPath[0]); + vertexToPathSegmentMap.Add(0); + Vector3 prevPointOnPath = bezierPath[0]; + float dstSinceLastVertex = 0; + Vector3 lastAddedPoint = prevPointOnPath; + float dstSinceLastIntermediary = 0; + + for (int segmentIndex = 0; segmentIndex < bezierPath.NumSegments; segmentIndex++) + { + Vector3[] segmentPoints = bezierPath.GetPointsInSegment(segmentIndex); + verticesWorld.Add(segmentPoints[0]); + vertexToPathSegmentMap.Add(segmentIndex); + segmentStartIndices[segmentIndex] = verticesWorld.Count-1; + + prevPointOnPath = segmentPoints[0]; + lastAddedPoint = prevPointOnPath; + dstSinceLastVertex = 0; + dstSinceLastIntermediary = 0; + + float estimatedSegmentLength = CubicBezierUtility.EstimateCurveLength(segmentPoints[0], segmentPoints[1], segmentPoints[2], segmentPoints[3]); + int divisions = Mathf.CeilToInt(estimatedSegmentLength * accuracy * accuracyMultiplier); + float increment = 1f / divisions; + + for (float t = increment; t <= 1; t += increment) + { + Vector3 pointOnPath = CubicBezierUtility.EvaluateCurve(segmentPoints[0], segmentPoints[1], segmentPoints[2], segmentPoints[3], t); + Vector3 nextPointOnPath = CubicBezierUtility.EvaluateCurve(segmentPoints[0], segmentPoints[1], segmentPoints[2], segmentPoints[3], t + increment); + + // angle at current point on path + float localAngle = 180 - MathUtility.MinAngle(prevPointOnPath, pointOnPath, nextPointOnPath); + // angle between the last added vertex, the current point on the path, and the next point on the path + float angleFromPrevVertex = 180 - MathUtility.MinAngle(lastAddedPoint, pointOnPath, nextPointOnPath); + float angleError = Mathf.Max(localAngle, angleFromPrevVertex); + + + if (angleError > maxAngleError && dstSinceLastVertex >= minVertexDst) + { + dstSinceLastVertex = 0; + dstSinceLastIntermediary = 0; + verticesWorld.Add(pointOnPath); + vertexToPathSegmentMap.Add(segmentIndex); + lastAddedPoint = pointOnPath; + } + else + { + if (dstSinceLastIntermediary > intermediaryThreshold) + { + verticesWorld.Add(pointOnPath); + vertexToPathSegmentMap.Add(segmentIndex); + dstSinceLastIntermediary = 0; + } + else + { + dstSinceLastIntermediary += (pointOnPath - prevPointOnPath).magnitude; + } + dstSinceLastVertex += (pointOnPath - prevPointOnPath).magnitude; + } + prevPointOnPath = pointOnPath; + } + } + + segmentStartIndices[bezierPath.NumSegments] = verticesWorld.Count; + + // ensure final point gets added (unless path is closed loop) + if (!bezierPath.IsClosed) + { + verticesWorld.Add(bezierPath[bezierPath.NumPoints - 1]); + } + else + { + verticesWorld.Add(bezierPath[0]); + } + + // Calculate length + cumululativeLengthWorld = new float[verticesWorld.Count]; + for (int i = 0; i < verticesWorld.Count; i++) + { + verticesWorld[i] = MathUtility.TransformPoint(verticesWorld[i], transform, bezierPath.Space); + if (i > 0) { + pathLengthWorld += (verticesWorld[i - 1] - verticesWorld[i]).magnitude; + cumululativeLengthWorld[i] = pathLengthWorld; + } + } + + } + + void ComputeScreenSpace() + { + if (Camera.current.transform.position != prevCamPos || Camera.current.transform.rotation != prevCamRot || Camera.current.orthographic != premCamIsOrtho) + { + points = new Vector2[verticesWorld.Count]; + for (int i = 0; i < verticesWorld.Count; i++) + { + points[i] = HandleUtility.WorldToGUIPoint(verticesWorld[i]); + } + + prevCamPos = Camera.current.transform.position; + prevCamRot = Camera.current.transform.rotation; + premCamIsOrtho = Camera.current.orthographic; + } + } + + public MouseInfo CalculateMouseInfo() + { + ComputeScreenSpace(); + + Vector2 mousePos = Event.current.mousePosition; + float minDst = float.MaxValue; + int closestPolyLineSegmentIndex = 0; + int closestBezierSegmentIndex = 0; + + for (int i = 0; i < points.Length - 1; i++) + { + float dst = HandleUtility.DistancePointToLineSegment(mousePos, points[i], points[i + 1]); + + if (dst < minDst) + { + minDst = dst; + closestPolyLineSegmentIndex = i; + closestBezierSegmentIndex = vertexToPathSegmentMap[i]; + } + } + + Vector2 closestPointOnLine = MathUtility.ClosestPointOnLineSegment(mousePos, points[closestPolyLineSegmentIndex], points[closestPolyLineSegmentIndex + 1]); + float dstToPointOnLine = (points[closestPolyLineSegmentIndex] - closestPointOnLine).magnitude; + float percentBetweenVertices = dstToPointOnLine / (points[closestPolyLineSegmentIndex] - points[closestPolyLineSegmentIndex + 1]).magnitude; + Vector3 closestPoint3D = Vector3.Lerp(verticesWorld[closestPolyLineSegmentIndex], verticesWorld[closestPolyLineSegmentIndex + 1], percentBetweenVertices); + + float distanceAlongPathWorld = cumululativeLengthWorld[closestPolyLineSegmentIndex] + Vector3.Distance(verticesWorld[closestPolyLineSegmentIndex], closestPoint3D); + float timeAlongPath = distanceAlongPathWorld / pathLengthWorld; + + // Calculate how far between the current bezier segment the closest point on the line is + + int bezierSegmentStartIndex = segmentStartIndices[closestBezierSegmentIndex]; + int bezierSegmentEndIndex = segmentStartIndices[closestBezierSegmentIndex+1]; + float bezierSegmentLength = cumululativeLengthWorld[bezierSegmentEndIndex] - cumululativeLengthWorld[bezierSegmentStartIndex]; + float distanceAlongBezierSegment = distanceAlongPathWorld - cumululativeLengthWorld[bezierSegmentStartIndex]; + float timeAlongBezierSegment = distanceAlongBezierSegment/bezierSegmentLength; + + return new MouseInfo(minDst, closestPoint3D, distanceAlongPathWorld, timeAlongPath, timeAlongBezierSegment, closestBezierSegmentIndex); + } + + public bool TransformIsOutOfDate() { + return transform.position != transformPosition || transform.rotation != transformRotation || transform.localScale != transformScale; + } + + + public struct MouseInfo + { + public readonly float mouseDstToLine; + public readonly Vector3 closestWorldPointToMouse; + public readonly float distanceAlongPathWorld; + public readonly float timeOnPath; + public readonly float timeOnBezierSegment; + public readonly int closestSegmentIndex; + + + public MouseInfo(float mouseDstToLine, Vector3 closestWorldPointToMouse, float distanceAlongPathWorld, float timeOnPath, float timeOnBezierSegment, int closestSegmentIndex) + { + this.mouseDstToLine = mouseDstToLine; + this.closestWorldPointToMouse = closestWorldPointToMouse; + this.distanceAlongPathWorld = distanceAlongPathWorld; + this.timeOnPath = timeOnPath; + this.timeOnBezierSegment = timeOnBezierSegment; + this.closestSegmentIndex = closestSegmentIndex; + } + } + } +} \ No newline at end of file diff --git a/game/Assets/PathCreator/Core/Editor/Helper/ScreenSpacePolyLine.cs.meta b/game/Assets/PathCreator/Core/Editor/Helper/ScreenSpacePolyLine.cs.meta new file mode 100644 index 0000000..d860ffe --- /dev/null +++ b/game/Assets/PathCreator/Core/Editor/Helper/ScreenSpacePolyLine.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 05aed72a972059e45a62e31c2bb60fc4 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/game/Assets/PathCreator/Core/Editor/PathCreatorEditor.asmdef b/game/Assets/PathCreator/Core/Editor/PathCreatorEditor.asmdef new file mode 100644 index 0000000..a53287d --- /dev/null +++ b/game/Assets/PathCreator/Core/Editor/PathCreatorEditor.asmdef @@ -0,0 +1,16 @@ +{ + "name": "PathCreatorEditor", + "references": [ + "PathCreator" + ], + "optionalUnityReferences": [], + "includePlatforms": [ + "Editor" + ], + "excludePlatforms": [], + "allowUnsafeCode": false, + "overrideReferences": false, + "precompiledReferences": [], + "autoReferenced": true, + "defineConstraints": [] +} \ No newline at end of file diff --git a/game/Assets/PathCreator/Core/Editor/PathCreatorEditor.asmdef.meta b/game/Assets/PathCreator/Core/Editor/PathCreatorEditor.asmdef.meta new file mode 100644 index 0000000..0c83f71 --- /dev/null +++ b/game/Assets/PathCreator/Core/Editor/PathCreatorEditor.asmdef.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 92ee438f32d811247a22ca14bf2a3fe0 +AssemblyDefinitionImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/game/Assets/PathCreator/Core/Editor/PathEditor.cs b/game/Assets/PathCreator/Core/Editor/PathEditor.cs new file mode 100644 index 0000000..7c52cc6 --- /dev/null +++ b/game/Assets/PathCreator/Core/Editor/PathEditor.cs @@ -0,0 +1,736 @@ +using System.Collections.Generic; +using PathCreation; +using PathCreation.Utility; +using UnityEditor; +using UnityEditor.IMGUI.Controls; +using UnityEngine; + +namespace PathCreationEditor { + /// Editor class for the creation of Bezier and Vertex paths + + [CustomEditor (typeof (PathCreator))] + public class PathEditor : Editor { + + #region Fields + + // Interaction: + const float segmentSelectDistanceThreshold = 10f; + const float screenPolylineMaxAngleError = .3f; + const float screenPolylineMinVertexDst = .01f; + + // Help messages: + const string helpInfo = "Shift-click to add or insert new points. Control-click to delete points. For more detailed infomation, please refer to the documentation."; + static readonly string[] spaceNames = { "3D (xyz)", "2D (xy)", "Top-down (xz)" }; + static readonly string[] tabNames = { "Bézier Path", "Vertex Path" }; + const string constantSizeTooltip = "If true, anchor and control points will keep a constant size when zooming in the editor."; + + // Display + const int inspectorSectionSpacing = 10; + const float constantHandleScale = .01f; + const float normalsSpacing = .2f; + GUIStyle boldFoldoutStyle; + + // References: + PathCreator creator; + Editor globalDisplaySettingsEditor; + ScreenSpacePolyLine screenSpaceLine; + ScreenSpacePolyLine.MouseInfo pathMouseInfo; + GlobalDisplaySettings globalDisplaySettings; + PathHandle.HandleColours splineAnchorColours; + PathHandle.HandleColours splineControlColours; + Dictionary capFunctions; + ArcHandle anchorAngleHandle = new ArcHandle (); + VertexPath normalsVertexPath; + + // State variables: + int selectedSegmentIndex; + int draggingHandleIndex; + int mouseOverHandleIndex; + int handleIndexToDisplayAsTransform; + + bool shiftLastFrame; + bool hasUpdatedScreenSpaceLine; + bool hasUpdatedNormalsVertexPath; + bool editingNormalsOld; + + Vector3 transformPos; + Vector3 transformScale; + Quaternion transformRot; + + Color handlesStartCol; + + // Constants + const int bezierPathTab = 0; + const int vertexPathTab = 1; + + #endregion + + #region Inspectors + + public override void OnInspectorGUI () { + // Initialize GUI styles + if (boldFoldoutStyle == null) { + boldFoldoutStyle = new GUIStyle (EditorStyles.foldout); + boldFoldoutStyle.fontStyle = FontStyle.Bold; + } + + Undo.RecordObject (creator, "Path settings changed"); + + // Draw Bezier and Vertex tabs + int tabIndex = GUILayout.Toolbar (data.tabIndex, tabNames); + if (tabIndex != data.tabIndex) { + data.tabIndex = tabIndex; + TabChanged (); + } + + // Draw inspector for active tab + switch (data.tabIndex) { + case bezierPathTab: + DrawBezierPathInspector (); + break; + case vertexPathTab: + DrawVertexPathInspector (); + break; + } + + // Notify of undo/redo that might modify the path + if (Event.current.type == EventType.ValidateCommand && Event.current.commandName == "UndoRedoPerformed") { + data.PathModifiedByUndo (); + } + } + + void DrawBezierPathInspector () { + using (var check = new EditorGUI.ChangeCheckScope ()) { + // Path options: + data.showPathOptions = EditorGUILayout.Foldout (data.showPathOptions, new GUIContent ("Bézier Path Options"), true, boldFoldoutStyle); + if (data.showPathOptions) { + bezierPath.Space = (PathSpace) EditorGUILayout.Popup ("Space", (int) bezierPath.Space, spaceNames); + bezierPath.ControlPointMode = (BezierPath.ControlMode) EditorGUILayout.EnumPopup (new GUIContent ("Control Mode"), bezierPath.ControlPointMode); + if (bezierPath.ControlPointMode == BezierPath.ControlMode.Automatic) { + bezierPath.AutoControlLength = EditorGUILayout.Slider (new GUIContent ("Control Spacing"), bezierPath.AutoControlLength, 0, 1); + } + + bezierPath.IsClosed = EditorGUILayout.Toggle ("Closed Path", bezierPath.IsClosed); + data.showTransformTool = EditorGUILayout.Toggle (new GUIContent ("Enable Transforms"), data.showTransformTool); + + Tools.hidden = !data.showTransformTool; + + // Check if out of bounds (can occur after undo operations) + if (handleIndexToDisplayAsTransform >= bezierPath.NumPoints) { + handleIndexToDisplayAsTransform = -1; + } + + // If a point has been selected + if (handleIndexToDisplayAsTransform != -1) { + EditorGUILayout.LabelField ("Selected Point:"); + + using (new EditorGUI.IndentLevelScope ()) { + var currentPosition = creator.bezierPath[handleIndexToDisplayAsTransform]; + var newPosition = EditorGUILayout.Vector3Field ("Position", currentPosition); + if (newPosition != currentPosition) { + Undo.RecordObject (creator, "Move point"); + creator.bezierPath.MovePoint (handleIndexToDisplayAsTransform, newPosition); + } + // Don't draw the angle field if we aren't selecting an anchor point/not in 3d space + if (handleIndexToDisplayAsTransform % 3 == 0 && creator.bezierPath.Space == PathSpace.xyz) { + var anchorIndex = handleIndexToDisplayAsTransform / 3; + var currentAngle = creator.bezierPath.GetAnchorNormalAngle (anchorIndex); + var newAngle = EditorGUILayout.FloatField ("Angle", currentAngle); + if (newAngle != currentAngle) { + Undo.RecordObject (creator, "Set Angle"); + creator.bezierPath.SetAnchorNormalAngle (anchorIndex, newAngle); + } + } + } + } + + if (data.showTransformTool & (handleIndexToDisplayAsTransform == -1)) { + if (GUILayout.Button ("Centre Transform")) { + + Vector3 worldCentre = bezierPath.CalculateBoundsWithTransform (creator.transform).center; + Vector3 transformPos = creator.transform.position; + if (bezierPath.Space == PathSpace.xy) { + transformPos = new Vector3 (transformPos.x, transformPos.y, 0); + } else if (bezierPath.Space == PathSpace.xz) { + transformPos = new Vector3 (transformPos.x, 0, transformPos.z); + } + Vector3 worldCentreToTransform = transformPos - worldCentre; + + if (worldCentre != creator.transform.position) { + //Undo.RecordObject (creator, "Centralize Transform"); + if (worldCentreToTransform != Vector3.zero) { + Vector3 localCentreToTransform = MathUtility.InverseTransformVector (worldCentreToTransform, creator.transform, bezierPath.Space); + for (int i = 0; i < bezierPath.NumPoints; i++) { + bezierPath.SetPoint (i, bezierPath.GetPoint (i) + localCentreToTransform, true); + } + } + + creator.transform.position = worldCentre; + bezierPath.NotifyPathModified (); + } + } + } + + if (GUILayout.Button ("Reset Path")) { + Undo.RecordObject (creator, "Reset Path"); + bool in2DEditorMode = EditorSettings.defaultBehaviorMode == EditorBehaviorMode.Mode2D; + data.ResetBezierPath (creator.transform.position, in2DEditorMode); + EditorApplication.QueuePlayerLoopUpdate (); + } + + GUILayout.Space (inspectorSectionSpacing); + } + + data.showNormals = EditorGUILayout.Foldout (data.showNormals, new GUIContent ("Normals Options"), true, boldFoldoutStyle); + if (data.showNormals) { + bezierPath.FlipNormals = EditorGUILayout.Toggle (new GUIContent ("Flip Normals"), bezierPath.FlipNormals); + if (bezierPath.Space == PathSpace.xyz) { + bezierPath.GlobalNormalsAngle = EditorGUILayout.Slider (new GUIContent ("Global Angle"), bezierPath.GlobalNormalsAngle, 0, 360); + + if (GUILayout.Button ("Reset Normals")) { + Undo.RecordObject (creator, "Reset Normals"); + bezierPath.FlipNormals = false; + bezierPath.ResetNormalAngles (); + } + } + GUILayout.Space (inspectorSectionSpacing); + } + + // Editor display options + data.showDisplayOptions = EditorGUILayout.Foldout (data.showDisplayOptions, new GUIContent ("Display Options"), true, boldFoldoutStyle); + if (data.showDisplayOptions) { + data.showPathBounds = GUILayout.Toggle (data.showPathBounds, new GUIContent ("Show Path Bounds")); + data.showPerSegmentBounds = GUILayout.Toggle (data.showPerSegmentBounds, new GUIContent ("Show Segment Bounds")); + data.displayAnchorPoints = GUILayout.Toggle (data.displayAnchorPoints, new GUIContent ("Show Anchor Points")); + if (!(bezierPath.ControlPointMode == BezierPath.ControlMode.Automatic && globalDisplaySettings.hideAutoControls)) { + data.displayControlPoints = GUILayout.Toggle (data.displayControlPoints, new GUIContent ("Show Control Points")); + } + data.keepConstantHandleSize = GUILayout.Toggle (data.keepConstantHandleSize, new GUIContent ("Constant Point Size", constantSizeTooltip)); + data.bezierHandleScale = Mathf.Max (0, EditorGUILayout.FloatField (new GUIContent ("Handle Scale"), data.bezierHandleScale)); + DrawGlobalDisplaySettingsInspector (); + } + + if (check.changed) { + SceneView.RepaintAll (); + EditorApplication.QueuePlayerLoopUpdate (); + } + } + } + + void DrawVertexPathInspector () { + + GUILayout.Space (inspectorSectionSpacing); + EditorGUILayout.LabelField ("Vertex count: " + creator.path.NumPoints); + GUILayout.Space (inspectorSectionSpacing); + + data.showVertexPathOptions = EditorGUILayout.Foldout (data.showVertexPathOptions, new GUIContent ("Vertex Path Options"), true, boldFoldoutStyle); + if (data.showVertexPathOptions) { + using (var check = new EditorGUI.ChangeCheckScope ()) { + data.vertexPathMaxAngleError = EditorGUILayout.Slider (new GUIContent ("Max Angle Error"), data.vertexPathMaxAngleError, 0, 45); + data.vertexPathMinVertexSpacing = EditorGUILayout.Slider (new GUIContent ("Min Vertex Dst"), data.vertexPathMinVertexSpacing, 0, 1); + + GUILayout.Space (inspectorSectionSpacing); + if (check.changed) { + data.VertexPathSettingsChanged (); + SceneView.RepaintAll (); + EditorApplication.QueuePlayerLoopUpdate (); + } + } + } + + data.showVertexPathDisplayOptions = EditorGUILayout.Foldout (data.showVertexPathDisplayOptions, new GUIContent ("Display Options"), true, boldFoldoutStyle); + if (data.showVertexPathDisplayOptions) { + using (var check = new EditorGUI.ChangeCheckScope ()) { + data.showNormalsInVertexMode = GUILayout.Toggle (data.showNormalsInVertexMode, new GUIContent ("Show Normals")); + data.showBezierPathInVertexMode = GUILayout.Toggle (data.showBezierPathInVertexMode, new GUIContent ("Show Bezier Path")); + + if (check.changed) { + SceneView.RepaintAll (); + EditorApplication.QueuePlayerLoopUpdate (); + } + } + DrawGlobalDisplaySettingsInspector (); + } + } + + void DrawGlobalDisplaySettingsInspector () { + using (var check = new EditorGUI.ChangeCheckScope ()) { + data.globalDisplaySettingsFoldout = EditorGUILayout.InspectorTitlebar (data.globalDisplaySettingsFoldout, globalDisplaySettings); + if (data.globalDisplaySettingsFoldout) { + CreateCachedEditor (globalDisplaySettings, null, ref globalDisplaySettingsEditor); + globalDisplaySettingsEditor.OnInspectorGUI (); + } + if (check.changed) { + UpdateGlobalDisplaySettings (); + SceneView.RepaintAll (); + } + } + } + + #endregion + + #region Scene GUI + + void OnSceneGUI () { + if (!globalDisplaySettings.visibleBehindObjects) { + Handles.zTest = UnityEngine.Rendering.CompareFunction.LessEqual; + } + + EventType eventType = Event.current.type; + + using (var check = new EditorGUI.ChangeCheckScope ()) { + handlesStartCol = Handles.color; + switch (data.tabIndex) { + case bezierPathTab: + if (eventType != EventType.Repaint && eventType != EventType.Layout) { + ProcessBezierPathInput (Event.current); + } + + DrawBezierPathSceneEditor (); + break; + case vertexPathTab: + if (eventType == EventType.Repaint) { + DrawVertexPathSceneEditor (); + } + break; + } + + // Don't allow clicking over empty space to deselect the object + if (eventType == EventType.Layout) { + HandleUtility.AddDefaultControl (0); + } + + if (check.changed) { + EditorApplication.QueuePlayerLoopUpdate (); + } + } + + SetTransformState (); + } + + void DrawVertexPathSceneEditor () { + + Color bezierCol = globalDisplaySettings.bezierPath; + bezierCol.a *= .5f; + + if (data.showBezierPathInVertexMode) { + for (int i = 0; i < bezierPath.NumSegments; i++) { + Vector3[] points = bezierPath.GetPointsInSegment (i); + for (int j = 0; j < points.Length; j++) { + points[j] = MathUtility.TransformPoint (points[j], creator.transform, bezierPath.Space); + } + Handles.DrawBezier (points[0], points[3], points[1], points[2], bezierCol, null, 2); + } + } + + Handles.color = globalDisplaySettings.vertexPath; + + for (int i = 0; i < creator.path.NumPoints; i++) { + int nextIndex = (i + 1) % creator.path.NumPoints; + if (nextIndex != 0 || bezierPath.IsClosed) { + Handles.DrawLine (creator.path.GetPoint (i), creator.path.GetPoint (nextIndex)); + } + } + + if (data.showNormalsInVertexMode) { + Handles.color = globalDisplaySettings.normals; + Vector3[] normalLines = new Vector3[creator.path.NumPoints * 2]; + for (int i = 0; i < creator.path.NumPoints; i++) { + normalLines[i * 2] = creator.path.GetPoint (i); + normalLines[i * 2 + 1] = creator.path.GetPoint (i) + creator.path.localNormals[i] * globalDisplaySettings.normalsLength; + } + Handles.DrawLines (normalLines); + } + } + + void ProcessBezierPathInput (Event e) { + // Find which handle mouse is over. Start by looking at previous handle index first, as most likely to still be closest to mouse + int previousMouseOverHandleIndex = (mouseOverHandleIndex == -1) ? 0 : mouseOverHandleIndex; + mouseOverHandleIndex = -1; + for (int i = 0; i < bezierPath.NumPoints; i += 3) { + + int handleIndex = (previousMouseOverHandleIndex + i) % bezierPath.NumPoints; + float handleRadius = GetHandleDiameter (globalDisplaySettings.anchorSize * data.bezierHandleScale, bezierPath[handleIndex]) / 2f; + Vector3 pos = MathUtility.TransformPoint (bezierPath[handleIndex], creator.transform, bezierPath.Space); + float dst = HandleUtility.DistanceToCircle (pos, handleRadius); + if (dst == 0) { + mouseOverHandleIndex = handleIndex; + break; + } + } + + // Shift-left click (when mouse not over a handle) to split or add segment + if (mouseOverHandleIndex == -1) { + if (e.type == EventType.MouseDown && e.button == 0 && e.shift) { + UpdatePathMouseInfo (); + // Insert point along selected segment + if (selectedSegmentIndex != -1 && selectedSegmentIndex < bezierPath.NumSegments) { + Vector3 newPathPoint = pathMouseInfo.closestWorldPointToMouse; + newPathPoint = MathUtility.InverseTransformPoint (newPathPoint, creator.transform, bezierPath.Space); + Undo.RecordObject (creator, "Split segment"); + bezierPath.SplitSegment (newPathPoint, selectedSegmentIndex, pathMouseInfo.timeOnBezierSegment); + } + // If path is not a closed loop, add new point on to the end of the path + else if (!bezierPath.IsClosed) { + // insert new point at same dst from scene camera as the point that comes before it (for a 3d path) + float dstCamToEndpoint = (Camera.current.transform.position - bezierPath[bezierPath.NumPoints - 1]).magnitude; + Vector3 newPathPoint = MouseUtility.GetMouseWorldPosition (bezierPath.Space, dstCamToEndpoint); + newPathPoint = MathUtility.InverseTransformPoint (newPathPoint, creator.transform, bezierPath.Space); + + Undo.RecordObject (creator, "Add segment"); + if (e.control || e.command) { + bezierPath.AddSegmentToStart (newPathPoint); + } else { + bezierPath.AddSegmentToEnd (newPathPoint); + } + + } + + } + } + + // Control click or backspace/delete to remove point + if (e.keyCode == KeyCode.Backspace || e.keyCode == KeyCode.Delete || ((e.control || e.command) && e.type == EventType.MouseDown && e.button == 0)) { + + if (mouseOverHandleIndex != -1) { + Undo.RecordObject (creator, "Delete segment"); + bezierPath.DeleteSegment (mouseOverHandleIndex); + if (mouseOverHandleIndex == handleIndexToDisplayAsTransform) { + handleIndexToDisplayAsTransform = -1; + } + mouseOverHandleIndex = -1; + Repaint (); + } + } + + // Holding shift and moving mouse (but mouse not over a handle/dragging a handle) + if (draggingHandleIndex == -1 && mouseOverHandleIndex == -1) { + bool shiftDown = e.shift && !shiftLastFrame; + if (shiftDown || ((e.type == EventType.MouseMove || e.type == EventType.MouseDrag) && e.shift)) { + + UpdatePathMouseInfo (); + + if (pathMouseInfo.mouseDstToLine < segmentSelectDistanceThreshold) { + if (pathMouseInfo.closestSegmentIndex != selectedSegmentIndex) { + selectedSegmentIndex = pathMouseInfo.closestSegmentIndex; + HandleUtility.Repaint (); + } + } else { + selectedSegmentIndex = -1; + HandleUtility.Repaint (); + } + + } + } + + shiftLastFrame = e.shift; + + } + + void DrawBezierPathSceneEditor () { + + bool displayControlPoints = data.displayControlPoints && (bezierPath.ControlPointMode != BezierPath.ControlMode.Automatic || !globalDisplaySettings.hideAutoControls); + Bounds bounds = bezierPath.CalculateBoundsWithTransform (creator.transform); + + if (Event.current.type == EventType.Repaint) { + for (int i = 0; i < bezierPath.NumSegments; i++) { + Vector3[] points = bezierPath.GetPointsInSegment (i); + for (int j = 0; j < points.Length; j++) { + points[j] = MathUtility.TransformPoint (points[j], creator.transform, bezierPath.Space); + } + + if (data.showPerSegmentBounds) { + Bounds segmentBounds = CubicBezierUtility.CalculateSegmentBounds (points[0], points[1], points[2], points[3]); + Handles.color = globalDisplaySettings.segmentBounds; + Handles.DrawWireCube (segmentBounds.center, segmentBounds.size); + } + + // Draw lines between control points + if (displayControlPoints) { + Handles.color = (bezierPath.ControlPointMode == BezierPath.ControlMode.Automatic) ? globalDisplaySettings.handleDisabled : globalDisplaySettings.controlLine; + Handles.DrawLine (points[1], points[0]); + Handles.DrawLine (points[2], points[3]); + } + + // Draw path + bool highlightSegment = (i == selectedSegmentIndex && Event.current.shift && draggingHandleIndex == -1 && mouseOverHandleIndex == -1); + Color segmentCol = (highlightSegment) ? globalDisplaySettings.highlightedPath : globalDisplaySettings.bezierPath; + Handles.DrawBezier (points[0], points[3], points[1], points[2], segmentCol, null, 2); + } + + if (data.showPathBounds) { + Handles.color = globalDisplaySettings.bounds; + Handles.DrawWireCube (bounds.center, bounds.size); + } + + // Draw normals + if (data.showNormals) { + if (!hasUpdatedNormalsVertexPath) { + normalsVertexPath = new VertexPath (bezierPath, creator.transform, normalsSpacing); + hasUpdatedNormalsVertexPath = true; + } + + if (editingNormalsOld != data.showNormals) { + editingNormalsOld = data.showNormals; + Repaint (); + } + + Vector3[] normalLines = new Vector3[normalsVertexPath.NumPoints * 2]; + Handles.color = globalDisplaySettings.normals; + for (int i = 0; i < normalsVertexPath.NumPoints; i++) { + normalLines[i * 2] = normalsVertexPath.GetPoint (i); + normalLines[i * 2 + 1] = normalsVertexPath.GetPoint (i) + normalsVertexPath.GetNormal (i) * globalDisplaySettings.normalsLength; + } + Handles.DrawLines (normalLines); + } + } + + if (data.displayAnchorPoints) { + for (int i = 0; i < bezierPath.NumPoints; i += 3) { + DrawHandle (i); + } + } + if (displayControlPoints) { + for (int i = 1; i < bezierPath.NumPoints - 1; i += 3) { + DrawHandle (i); + DrawHandle (i + 1); + } + } + } + + void DrawHandle (int i) { + Vector3 handlePosition = MathUtility.TransformPoint (bezierPath[i], creator.transform, bezierPath.Space); + + float anchorHandleSize = GetHandleDiameter (globalDisplaySettings.anchorSize * data.bezierHandleScale, bezierPath[i]); + float controlHandleSize = GetHandleDiameter (globalDisplaySettings.controlSize * data.bezierHandleScale, bezierPath[i]); + + bool isAnchorPoint = i % 3 == 0; + bool isInteractive = isAnchorPoint || bezierPath.ControlPointMode != BezierPath.ControlMode.Automatic; + float handleSize = (isAnchorPoint) ? anchorHandleSize : controlHandleSize; + bool doTransformHandle = i == handleIndexToDisplayAsTransform; + + PathHandle.HandleColours handleColours = (isAnchorPoint) ? splineAnchorColours : splineControlColours; + if (i == handleIndexToDisplayAsTransform) { + handleColours.defaultColour = (isAnchorPoint) ? globalDisplaySettings.anchorSelected : globalDisplaySettings.controlSelected; + } + var cap = capFunctions[(isAnchorPoint) ? globalDisplaySettings.anchorShape : globalDisplaySettings.controlShape]; + PathHandle.HandleInputType handleInputType; + handlePosition = PathHandle.DrawHandle (handlePosition, bezierPath.Space, isInteractive, handleSize, cap, handleColours, out handleInputType, i); + + if (doTransformHandle) { + // Show normals rotate tool + if (data.showNormals && Tools.current == Tool.Rotate && isAnchorPoint && bezierPath.Space == PathSpace.xyz) { + Handles.color = handlesStartCol; + + int attachedControlIndex = (i == bezierPath.NumPoints - 1) ? i - 1 : i + 1; + Vector3 dir = (bezierPath[attachedControlIndex] - handlePosition).normalized; + float handleRotOffset = (360 + bezierPath.GlobalNormalsAngle) % 360; + anchorAngleHandle.radius = handleSize * 3; + anchorAngleHandle.angle = handleRotOffset + bezierPath.GetAnchorNormalAngle (i / 3); + Vector3 handleDirection = Vector3.Cross (dir, Vector3.up); + Matrix4x4 handleMatrix = Matrix4x4.TRS ( + handlePosition, + Quaternion.LookRotation (handleDirection, dir), + Vector3.one + ); + + using (new Handles.DrawingScope (handleMatrix)) { + // draw the handle + EditorGUI.BeginChangeCheck (); + anchorAngleHandle.DrawHandle (); + if (EditorGUI.EndChangeCheck ()) { + Undo.RecordObject (creator, "Set angle"); + bezierPath.SetAnchorNormalAngle (i / 3, anchorAngleHandle.angle - handleRotOffset); + } + } + + } else { + handlePosition = Handles.DoPositionHandle (handlePosition, Quaternion.identity); + } + + } + + switch (handleInputType) { + case PathHandle.HandleInputType.LMBDrag: + draggingHandleIndex = i; + handleIndexToDisplayAsTransform = -1; + Repaint (); + break; + case PathHandle.HandleInputType.LMBRelease: + draggingHandleIndex = -1; + handleIndexToDisplayAsTransform = -1; + Repaint (); + break; + case PathHandle.HandleInputType.LMBClick: + draggingHandleIndex = -1; + if (Event.current.shift) { + handleIndexToDisplayAsTransform = -1; // disable move tool if new point added + } else { + if (handleIndexToDisplayAsTransform == i) { + handleIndexToDisplayAsTransform = -1; // disable move tool if clicking on point under move tool + } else { + handleIndexToDisplayAsTransform = i; + } + } + Repaint (); + break; + case PathHandle.HandleInputType.LMBPress: + if (handleIndexToDisplayAsTransform != i) { + handleIndexToDisplayAsTransform = -1; + Repaint (); + } + break; + } + + Vector3 localHandlePosition = MathUtility.InverseTransformPoint (handlePosition, creator.transform, bezierPath.Space); + + if (bezierPath[i] != localHandlePosition) { + Undo.RecordObject (creator, "Move point"); + bezierPath.MovePoint (i, localHandlePosition); + + } + + } + + #endregion + + #region Internal methods + + void OnDisable () { + Tools.hidden = false; + } + + void OnEnable () { + creator = (PathCreator) target; + bool in2DEditorMode = EditorSettings.defaultBehaviorMode == EditorBehaviorMode.Mode2D; + creator.InitializeEditorData (in2DEditorMode); + + data.bezierCreated -= ResetState; + data.bezierCreated += ResetState; + Undo.undoRedoPerformed -= OnUndoRedo; + Undo.undoRedoPerformed += OnUndoRedo; + + LoadDisplaySettings (); + UpdateGlobalDisplaySettings (); + ResetState (); + SetTransformState (true); + } + + void SetTransformState (bool initialize = false) { + Transform t = creator.transform; + if (!initialize) { + if (transformPos != t.position || t.localScale != transformScale || t.rotation != transformRot) { + data.PathTransformed (); + } + } + transformPos = t.position; + transformScale = t.localScale; + transformRot = t.rotation; + } + + void OnUndoRedo () { + hasUpdatedScreenSpaceLine = false; + hasUpdatedNormalsVertexPath = false; + selectedSegmentIndex = -1; + + Repaint (); + } + + void TabChanged () { + SceneView.RepaintAll (); + RepaintUnfocusedSceneViews (); + } + + void LoadDisplaySettings () { + globalDisplaySettings = GlobalDisplaySettings.Load (); + + capFunctions = new Dictionary (); + capFunctions.Add (GlobalDisplaySettings.HandleType.Circle, Handles.CylinderHandleCap); + capFunctions.Add (GlobalDisplaySettings.HandleType.Sphere, Handles.SphereHandleCap); + capFunctions.Add (GlobalDisplaySettings.HandleType.Square, Handles.CubeHandleCap); + } + + void UpdateGlobalDisplaySettings () { + var gds = globalDisplaySettings; + splineAnchorColours = new PathHandle.HandleColours (gds.anchor, gds.anchorHighlighted, gds.anchorSelected, gds.handleDisabled); + splineControlColours = new PathHandle.HandleColours (gds.control, gds.controlHighlighted, gds.controlSelected, gds.handleDisabled); + + anchorAngleHandle.fillColor = new Color (1, 1, 1, .05f); + anchorAngleHandle.wireframeColor = Color.grey; + anchorAngleHandle.radiusHandleColor = Color.clear; + anchorAngleHandle.angleHandleColor = Color.white; + } + + void ResetState () { + selectedSegmentIndex = -1; + draggingHandleIndex = -1; + mouseOverHandleIndex = -1; + handleIndexToDisplayAsTransform = -1; + hasUpdatedScreenSpaceLine = false; + hasUpdatedNormalsVertexPath = false; + + bezierPath.OnModified -= OnPathModifed; + bezierPath.OnModified += OnPathModifed; + + SceneView.RepaintAll (); + EditorApplication.QueuePlayerLoopUpdate (); + } + + void OnPathModifed () { + hasUpdatedScreenSpaceLine = false; + hasUpdatedNormalsVertexPath = false; + + RepaintUnfocusedSceneViews (); + } + + void RepaintUnfocusedSceneViews () { + // If multiple scene views are open, repaint those which do not have focus. + if (SceneView.sceneViews.Count > 1) { + foreach (SceneView sv in SceneView.sceneViews) { + if (EditorWindow.focusedWindow != (EditorWindow) sv) { + sv.Repaint (); + } + } + } + } + + void UpdatePathMouseInfo () { + + if (!hasUpdatedScreenSpaceLine || (screenSpaceLine != null && screenSpaceLine.TransformIsOutOfDate ())) { + screenSpaceLine = new ScreenSpacePolyLine (bezierPath, creator.transform, screenPolylineMaxAngleError, screenPolylineMinVertexDst); + hasUpdatedScreenSpaceLine = true; + } + pathMouseInfo = screenSpaceLine.CalculateMouseInfo (); + } + + float GetHandleDiameter (float diameter, Vector3 handlePosition) { + float scaledDiameter = diameter * constantHandleScale; + if (data.keepConstantHandleSize) { + scaledDiameter *= HandleUtility.GetHandleSize (handlePosition) * 2.5f; + } + return scaledDiameter; + } + + BezierPath bezierPath { + get { + return data.bezierPath; + } + } + + PathCreatorData data { + get { + return creator.EditorData; + } + } + + bool editingNormals { + get { + return Tools.current == Tool.Rotate && handleIndexToDisplayAsTransform % 3 == 0 && bezierPath.Space == PathSpace.xyz; + } + } + + #endregion + + } + +} \ No newline at end of file diff --git a/game/Assets/PathCreator/Core/Editor/PathEditor.cs.meta b/game/Assets/PathCreator/Core/Editor/PathEditor.cs.meta new file mode 100644 index 0000000..40e26f1 --- /dev/null +++ b/game/Assets/PathCreator/Core/Editor/PathEditor.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: 45d81a20743ff42a3b0dfbd499d4797e +timeCreated: 1516864234 +licenseType: Store +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/game/Assets/PathCreator/Core/Runtime.meta b/game/Assets/PathCreator/Core/Runtime.meta new file mode 100644 index 0000000..3756548 --- /dev/null +++ b/game/Assets/PathCreator/Core/Runtime.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: c62dae0f992c5174a951248617cc5720 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/game/Assets/PathCreator/Core/Runtime/Objects.meta b/game/Assets/PathCreator/Core/Runtime/Objects.meta new file mode 100644 index 0000000..be235b4 --- /dev/null +++ b/game/Assets/PathCreator/Core/Runtime/Objects.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 2b76edb14a39ed944b9c906e5f1d3aaa +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/game/Assets/PathCreator/Core/Runtime/Objects/BezierPath.cs b/game/Assets/PathCreator/Core/Runtime/Objects/BezierPath.cs new file mode 100644 index 0000000..a3912b2 --- /dev/null +++ b/game/Assets/PathCreator/Core/Runtime/Objects/BezierPath.cs @@ -0,0 +1,678 @@ +using System.Collections.Generic; +using System.Linq; +using PathCreation.Utility; +using UnityEngine; + +namespace PathCreation { + /// A bezier path is a path made by stitching together any number of (cubic) bezier curves. + /// A single cubic bezier curve is defined by 4 points: anchor1, control1, control2, anchor2 + /// The curve moves between the 2 anchors, and the shape of the curve is affected by the positions of the 2 control points + + /// When two curves are stitched together, they share an anchor point (end anchor of curve 1 = start anchor of curve 2). + /// So while one curve alone consists of 4 points, two curves are defined by 7 unique points. + + /// Apart from storing the points, this class also provides methods for working with the path. + /// For example, adding, inserting, and deleting points. + + [System.Serializable] + public class BezierPath { + public event System.Action OnModified; + public enum ControlMode { Aligned, Mirrored, Free, Automatic }; + + #region Fields + + [SerializeField, HideInInspector] + List points; + [SerializeField, HideInInspector] + bool isClosed; + [SerializeField, HideInInspector] + PathSpace space; + [SerializeField, HideInInspector] + ControlMode controlMode; + [SerializeField, HideInInspector] + float autoControlLength = .3f; + [SerializeField, HideInInspector] + bool boundsUpToDate; + [SerializeField, HideInInspector] + Bounds bounds; + + // Normals settings + [SerializeField, HideInInspector] + List perAnchorNormalsAngle; + [SerializeField, HideInInspector] + float globalNormalsAngle; + [SerializeField, HideInInspector] + bool flipNormals; + + #endregion + + #region Constructors + + /// Creates a two-anchor path centred around the given centre point + /// Should the end point connect back to the start point? + /// Determines if the path is in 3d space, or clamped to the xy/xz plane + public BezierPath (Vector3 centre, bool isClosed = false, PathSpace space = PathSpace.xyz) { + + Vector3 dir = (space == PathSpace.xz) ? Vector3.forward : Vector3.up; + float width = 2; + float controlHeight = .5f; + float controlWidth = 1f; + points = new List { + centre + Vector3.left * width, + centre + Vector3.left * controlWidth + dir * controlHeight, + centre + Vector3.right * controlWidth - dir * controlHeight, + centre + Vector3.right * width + }; + + perAnchorNormalsAngle = new List () { 0, 0 }; + + Space = space; + IsClosed = isClosed; + } + + /// Creates a path from the supplied 3D points + /// List or array of points to create the path from. + /// Should the end point connect back to the start point? + /// Determines if the path is in 3d space, or clamped to the xy/xz plane + public BezierPath (IEnumerable points, bool isClosed = false, PathSpace space = PathSpace.xyz) { + Vector3[] pointsArray = points.ToArray (); + + if (pointsArray.Length < 2) { + Debug.LogError ("Path requires at least 2 anchor points."); + } else { + controlMode = ControlMode.Automatic; + this.points = new List { pointsArray[0], Vector3.zero, Vector3.zero, pointsArray[1] }; + perAnchorNormalsAngle = new List (new float[] { 0, 0 }); + + for (int i = 2; i < pointsArray.Length; i++) { + AddSegmentToEnd (pointsArray[i]); + perAnchorNormalsAngle.Add (0); + } + } + + this.Space = space; + this.IsClosed = isClosed; + } + + /// Creates a path from the positions of the supplied 2D points + /// List or array of transforms to create the path from. + /// Should the end point connect back to the start point? + /// Determines if the path is in 3d space, or clamped to the xy/xz plane + public BezierPath (IEnumerable transforms, bool isClosed = false, PathSpace space = PathSpace.xy): + this (transforms.Select (p => new Vector3 (p.x, p.y)), isClosed, space) { } + + /// Creates a path from the positions of the supplied transforms + /// List or array of transforms to create the path from. + /// Should the end point connect back to the start point? + /// Determines if the path is in 3d space, or clamped to the xy/xz plane + public BezierPath (IEnumerable transforms, bool isClosed = false, PathSpace space = PathSpace.xy): + this (transforms.Select (t => t.position), isClosed, space) { } + + /// Creates a path from the supplied 2D points + /// List or array of 2d points to create the path from. + /// Should the end point connect back to the start point? + /// Determines if the path is in 3d space, or clamped to the xy/xz plane + public BezierPath (IEnumerable points, PathSpace space = PathSpace.xyz, bool isClosed = false): + this (points.Select (p => new Vector3 (p.x, p.y)), isClosed, space) { } + + #endregion + + #region Public methods and accessors + + /// Get world space position of point + public Vector3 this [int i] { + get { + return GetPoint (i); + } + } + + /// Get world space position of point + public Vector3 GetPoint (int i) { + return points[i]; + } + + /// Get world space position of point + public void SetPoint (int i, Vector3 localPosition, bool suppressPathModifiedEvent = false) { + points[i] = localPosition; + if (!suppressPathModifiedEvent) { + NotifyPathModified(); + } + } + + /// Total number of points in the path (anchors and controls) + public int NumPoints { + get { + return points.Count; + } + } + + /// Number of anchor points making up the path + public int NumAnchorPoints { + get { + return (IsClosed) ? points.Count / 3 : (points.Count + 2) / 3; + } + } + + /// Number of bezier curves making up this path + public int NumSegments { + get { + return points.Count / 3; + } + } + + /// Path can exist in 3D (xyz), 2D (xy), or Top-Down (xz) space + /// In xy or xz space, points will be clamped to that plane (so in a 2D path, for example, points will always be at 0 on z axis) + public PathSpace Space { + get { + return space; + } + set { + if (value != space) { + PathSpace previousSpace = space; + space = value; + UpdateToNewPathSpace (previousSpace); + } + } + } + + /// If closed, path will loop back from end point to start point + public bool IsClosed { + get { + return isClosed; + } + set { + if (isClosed != value) { + isClosed = value; + UpdateClosedState (); + } + } + } + + /// The control mode determines the behaviour of control points. + /// Possible modes are: + /// Aligned = controls stay in straight line around their anchor + /// Mirrored = controls stay in straight, equidistant line around their anchor + /// Free = no constraints (use this if sharp corners are needed) + /// Automatic = controls placed automatically to try make the path smooth + public ControlMode ControlPointMode { + get { + return controlMode; + } + set { + if (controlMode != value) { + controlMode = value; + if (controlMode == ControlMode.Automatic) { + AutoSetAllControlPoints (); + NotifyPathModified (); + } + } + } + } + + /// When using automatic control point placement, this value scales how far apart controls are placed + public float AutoControlLength { + get { + return autoControlLength; + } + set { + value = Mathf.Max (value, .01f); + if (autoControlLength != value) { + autoControlLength = value; + AutoSetAllControlPoints (); + NotifyPathModified (); + } + } + } + + /// Add new anchor point to end of the path + public void AddSegmentToEnd (Vector3 anchorPos) { + if (isClosed) { + return; + } + + int lastAnchorIndex = points.Count - 1; + // Set position for new control to be mirror of its counterpart + Vector3 secondControlForOldLastAnchorOffset = (points[lastAnchorIndex] - points[lastAnchorIndex - 1]); + if (controlMode != ControlMode.Mirrored && controlMode != ControlMode.Automatic) { + // Set position for new control to be aligned with its counterpart, but with a length of half the distance from prev to new anchor + float dstPrevToNewAnchor = (points[lastAnchorIndex] - anchorPos).magnitude; + secondControlForOldLastAnchorOffset = (points[lastAnchorIndex] - points[lastAnchorIndex - 1]).normalized * dstPrevToNewAnchor * .5f; + } + Vector3 secondControlForOldLastAnchor = points[lastAnchorIndex] + secondControlForOldLastAnchorOffset; + Vector3 controlForNewAnchor = (anchorPos + secondControlForOldLastAnchor) * .5f; + + points.Add (secondControlForOldLastAnchor); + points.Add (controlForNewAnchor); + points.Add (anchorPos); + perAnchorNormalsAngle.Add (perAnchorNormalsAngle[perAnchorNormalsAngle.Count - 1]); + + if (controlMode == ControlMode.Automatic) { + AutoSetAllAffectedControlPoints (points.Count - 1); + } + + NotifyPathModified (); + } + + /// Add new anchor point to start of the path + public void AddSegmentToStart (Vector3 anchorPos) { + if (isClosed) { + return; + } + + // Set position for new control to be mirror of its counterpart + Vector3 secondControlForOldFirstAnchorOffset = (points[0] - points[1]); + if (controlMode != ControlMode.Mirrored && controlMode != ControlMode.Automatic) { + // Set position for new control to be aligned with its counterpart, but with a length of half the distance from prev to new anchor + float dstPrevToNewAnchor = (points[0] - anchorPos).magnitude; + secondControlForOldFirstAnchorOffset = secondControlForOldFirstAnchorOffset.normalized * dstPrevToNewAnchor * .5f; + } + + Vector3 secondControlForOldFirstAnchor = points[0] + secondControlForOldFirstAnchorOffset; + Vector3 controlForNewAnchor = (anchorPos + secondControlForOldFirstAnchor) * .5f; + points.Insert (0, anchorPos); + points.Insert (1, controlForNewAnchor); + points.Insert (2, secondControlForOldFirstAnchor); + perAnchorNormalsAngle.Insert (0, perAnchorNormalsAngle[0]); + + if (controlMode == ControlMode.Automatic) { + AutoSetAllAffectedControlPoints (0); + } + NotifyPathModified (); + } + + /// Insert new anchor point at given position. Automatically place control points around it so as to keep shape of curve the same + public void SplitSegment (Vector3 anchorPos, int segmentIndex, float splitTime) { + splitTime = Mathf.Clamp01 (splitTime); + + if (controlMode == ControlMode.Automatic) { + points.InsertRange (segmentIndex * 3 + 2, new Vector3[] { Vector3.zero, anchorPos, Vector3.zero }); + AutoSetAllAffectedControlPoints (segmentIndex * 3 + 3); + } else { + // Split the curve to find where control points can be inserted to least affect shape of curve + // Curve will probably be deformed slightly since splitTime is only an estimate (for performance reasons, and so doesn't correspond exactly with anchorPos) + Vector3[][] splitSegment = CubicBezierUtility.SplitCurve (GetPointsInSegment (segmentIndex), splitTime); + points.InsertRange (segmentIndex * 3 + 2, new Vector3[] { splitSegment[0][2], splitSegment[1][0], splitSegment[1][1] }); + int newAnchorIndex = segmentIndex * 3 + 3; + MovePoint (newAnchorIndex - 2, splitSegment[0][1], true); + MovePoint (newAnchorIndex + 2, splitSegment[1][2], true); + MovePoint (newAnchorIndex, anchorPos, true); + + if (controlMode == ControlMode.Mirrored) { + float avgDst = ((splitSegment[0][2] - anchorPos).magnitude + (splitSegment[1][1] - anchorPos).magnitude) / 2; + MovePoint (newAnchorIndex + 1, anchorPos + (splitSegment[1][1] - anchorPos).normalized * avgDst, true); + } + } + + // Insert angle for new anchor (value should be set inbetween neighbour anchor angles) + int newAnchorAngleIndex = (segmentIndex + 1) % perAnchorNormalsAngle.Count; + int numAngles = perAnchorNormalsAngle.Count; + float anglePrev = perAnchorNormalsAngle[segmentIndex]; + float angleNext = perAnchorNormalsAngle[newAnchorAngleIndex]; + float splitAngle = Mathf.LerpAngle (anglePrev, angleNext, splitTime); + perAnchorNormalsAngle.Insert (newAnchorAngleIndex, splitAngle); + + NotifyPathModified (); + } + + /// Delete the anchor point at given index, as well as its associated control points + public void DeleteSegment (int anchorIndex) { + // Don't delete segment if its the last one remaining (or if only two segments in a closed path) + if (NumSegments > 2 || !isClosed && NumSegments > 1) { + if (anchorIndex == 0) { + if (isClosed) { + points[points.Count - 1] = points[2]; + } + points.RemoveRange (0, 3); + } else if (anchorIndex == points.Count - 1 && !isClosed) { + points.RemoveRange (anchorIndex - 2, 3); + } else { + points.RemoveRange (anchorIndex - 1, 3); + } + + perAnchorNormalsAngle.RemoveAt (anchorIndex / 3); + + if (controlMode == ControlMode.Automatic) { + AutoSetAllControlPoints (); + } + + NotifyPathModified (); + } + } + + /// Returns an array of the 4 points making up the segment (anchor1, control1, control2, anchor2) + public Vector3[] GetPointsInSegment (int segmentIndex) { + segmentIndex = Mathf.Clamp (segmentIndex, 0, NumSegments - 1); + return new Vector3[] { this [segmentIndex * 3], this [segmentIndex * 3 + 1], this [segmentIndex * 3 + 2], this [LoopIndex (segmentIndex * 3 + 3)] }; + } + + /// Move an existing point to a new position + public void MovePoint (int i, Vector3 pointPos, bool suppressPathModifiedEvent = false) { + + if (space == PathSpace.xy) { + pointPos.z = 0; + } else if (space == PathSpace.xz) { + pointPos.y = 0; + } + Vector3 deltaMove = pointPos - points[i]; + bool isAnchorPoint = i % 3 == 0; + + // Don't process control point if control mode is set to automatic + if (isAnchorPoint || controlMode != ControlMode.Automatic) { + points[i] = pointPos; + + if (controlMode == ControlMode.Automatic) { + AutoSetAllAffectedControlPoints (i); + } else { + // Move control points with anchor point + if (isAnchorPoint) { + if (i + 1 < points.Count || isClosed) { + points[LoopIndex (i + 1)] += deltaMove; + } + if (i - 1 >= 0 || isClosed) { + points[LoopIndex (i - 1)] += deltaMove; + } + } + // If not in free control mode, then move attached control point to be aligned/mirrored (depending on mode) + else if (controlMode != ControlMode.Free) { + bool nextPointIsAnchor = (i + 1) % 3 == 0; + int attachedControlIndex = (nextPointIsAnchor) ? i + 2 : i - 2; + int anchorIndex = (nextPointIsAnchor) ? i + 1 : i - 1; + + if (attachedControlIndex >= 0 && attachedControlIndex < points.Count || isClosed) { + float distanceFromAnchor = 0; + // If in aligned mode, then attached control's current distance from anchor point should be maintained + if (controlMode == ControlMode.Aligned) { + distanceFromAnchor = (points[LoopIndex (anchorIndex)] - points[LoopIndex (attachedControlIndex)]).magnitude; + } + // If in mirrored mode, then both control points should have the same distance from the anchor point + else if (controlMode == ControlMode.Mirrored) { + distanceFromAnchor = (points[LoopIndex (anchorIndex)] - points[i]).magnitude; + + } + Vector3 dir = (points[LoopIndex (anchorIndex)] - pointPos).normalized; + points[LoopIndex (attachedControlIndex)] = points[LoopIndex (anchorIndex)] + dir * distanceFromAnchor; + } + } + } + + if (!suppressPathModifiedEvent) { + NotifyPathModified (); + } + } + } + + /// Update the bounding box of the path + public Bounds CalculateBoundsWithTransform (Transform transform) { + // Loop through all segments and keep track of the minmax points of all their bounding boxes + MinMax3D minMax = new MinMax3D (); + + for (int i = 0; i < NumSegments; i++) { + Vector3[] p = GetPointsInSegment (i); + for (int j = 0; j < p.Length; j++) { + p[j] = MathUtility.TransformPoint (p[j], transform, space); + } + + minMax.AddValue (p[0]); + minMax.AddValue (p[3]); + + List extremePointTimes = CubicBezierUtility.ExtremePointTimes (p[0], p[1], p[2], p[3]); + foreach (float t in extremePointTimes) { + minMax.AddValue (CubicBezierUtility.EvaluateCurve (p, t)); + } + } + + return new Bounds ((minMax.Min + minMax.Max) / 2, minMax.Max - minMax.Min); + } + + /// Flip the normal vectors 180 degrees + public bool FlipNormals { + get { + return flipNormals; + } + set { + if (flipNormals != value) { + flipNormals = value; + NotifyPathModified (); + } + } + } + + /// Global angle that all normal vectors are rotated by (only relevant for paths in 3D space) + public float GlobalNormalsAngle { + get { + return globalNormalsAngle; + } + set { + if (value != globalNormalsAngle) { + globalNormalsAngle = value; + NotifyPathModified (); + } + } + } + + /// Get the desired angle of the normal vector at a particular anchor (only relevant for paths in 3D space) + public float GetAnchorNormalAngle (int anchorIndex) { + return perAnchorNormalsAngle[anchorIndex] % 360; + } + + /// Set the desired angle of the normal vector at a particular anchor (only relevant for paths in 3D space) + public void SetAnchorNormalAngle (int anchorIndex, float angle) { + angle = (angle + 360) % 360; + if (perAnchorNormalsAngle[anchorIndex] != angle) { + perAnchorNormalsAngle[anchorIndex] = angle; + NotifyPathModified (); + } + } + + /// Reset global and anchor normal angles to 0 + public void ResetNormalAngles () { + for (int i = 0; i < perAnchorNormalsAngle.Count; i++) { + perAnchorNormalsAngle[i] = 0; + } + globalNormalsAngle = 0; + NotifyPathModified (); + } + + /// Bounding box containing the path + public Bounds PathBounds { + get { + if (!boundsUpToDate) { + UpdateBounds (); + } + return bounds; + } + } + + #endregion + + #region Internal methods and accessors + + /// Update the bounding box of the path + void UpdateBounds () { + if (boundsUpToDate) { + return; + } + + // Loop through all segments and keep track of the minmax points of all their bounding boxes + MinMax3D minMax = new MinMax3D (); + + for (int i = 0; i < NumSegments; i++) { + Vector3[] p = GetPointsInSegment (i); + minMax.AddValue (p[0]); + minMax.AddValue (p[3]); + + List extremePointTimes = CubicBezierUtility.ExtremePointTimes (p[0], p[1], p[2], p[3]); + foreach (float t in extremePointTimes) { + minMax.AddValue (CubicBezierUtility.EvaluateCurve (p, t)); + } + } + + boundsUpToDate = true; + bounds = new Bounds ((minMax.Min + minMax.Max) / 2, minMax.Max - minMax.Min); + } + + /// Determines good positions (for a smooth path) for the control points affected by a moved/inserted anchor point + void AutoSetAllAffectedControlPoints (int updatedAnchorIndex) { + for (int i = updatedAnchorIndex - 3; i <= updatedAnchorIndex + 3; i += 3) { + if (i >= 0 && i < points.Count || isClosed) { + AutoSetAnchorControlPoints (LoopIndex (i)); + } + } + + AutoSetStartAndEndControls (); + } + + /// Determines good positions (for a smooth path) for all control points + void AutoSetAllControlPoints () { + if (NumAnchorPoints > 2) { + for (int i = 0; i < points.Count; i += 3) { + AutoSetAnchorControlPoints (i); + } + } + + AutoSetStartAndEndControls (); + } + + /// Calculates good positions (to result in smooth path) for the controls around specified anchor + void AutoSetAnchorControlPoints (int anchorIndex) { + // Calculate a vector that is perpendicular to the vector bisecting the angle between this anchor and its two immediate neighbours + // The control points will be placed along that vector + Vector3 anchorPos = points[anchorIndex]; + Vector3 dir = Vector3.zero; + float[] neighbourDistances = new float[2]; + + if (anchorIndex - 3 >= 0 || isClosed) { + Vector3 offset = points[LoopIndex (anchorIndex - 3)] - anchorPos; + dir += offset.normalized; + neighbourDistances[0] = offset.magnitude; + } + if (anchorIndex + 3 >= 0 || isClosed) { + Vector3 offset = points[LoopIndex (anchorIndex + 3)] - anchorPos; + dir -= offset.normalized; + neighbourDistances[1] = -offset.magnitude; + } + + dir.Normalize (); + + // Set the control points along the calculated direction, with a distance proportional to the distance to the neighbouring control point + for (int i = 0; i < 2; i++) { + int controlIndex = anchorIndex + i * 2 - 1; + if (controlIndex >= 0 && controlIndex < points.Count || isClosed) { + points[LoopIndex (controlIndex)] = anchorPos + dir * neighbourDistances[i] * autoControlLength; + } + } + } + + /// Determines good positions (for a smooth path) for the control points at the start and end of a path + void AutoSetStartAndEndControls () { + if (isClosed) { + // Handle case with only 2 anchor points separately, as will otherwise result in straight line () + if (NumAnchorPoints == 2) { + Vector3 dirAnchorAToB = (points[3] - points[0]).normalized; + float dstBetweenAnchors = (points[0] - points[3]).magnitude; + Vector3 perp = Vector3.Cross (dirAnchorAToB, (space == PathSpace.xy) ? Vector3.forward : Vector3.up); + points[1] = points[0] + perp * dstBetweenAnchors / 2f; + points[5] = points[0] - perp * dstBetweenAnchors / 2f; + points[2] = points[3] + perp * dstBetweenAnchors / 2f; + points[4] = points[3] - perp * dstBetweenAnchors / 2f; + + } else { + AutoSetAnchorControlPoints (0); + AutoSetAnchorControlPoints (points.Count - 3); + } + } else { + // Handle case with 2 anchor points separately, as otherwise minor adjustments cause path to constantly flip + if (NumAnchorPoints == 2) { + points[1] = points[0] + (points[3] - points[0]) * .25f; + points[2] = points[3] + (points[0] - points[3]) * .25f; + } else { + points[1] = (points[0] + points[2]) * .5f; + points[points.Count - 2] = (points[points.Count - 1] + points[points.Count - 3]) * .5f; + } + } + } + + /// Update point positions for new path space + /// (for example, if changing from xy to xz path, y and z axes will be swapped so the path keeps its shape in the new space) + void UpdateToNewPathSpace (PathSpace previousSpace) { + // If changing from 3d to 2d space, first find the bounds of the 3d path. + // The axis with the smallest bounds will be discarded. + if (previousSpace == PathSpace.xyz) { + Vector3 boundsSize = PathBounds.size; + float minBoundsSize = Mathf.Min (boundsSize.x, boundsSize.y, boundsSize.z); + + for (int i = 0; i < NumPoints; i++) { + if (space == PathSpace.xy) { + float x = (minBoundsSize == boundsSize.x) ? points[i].z : points[i].x; + float y = (minBoundsSize == boundsSize.y) ? points[i].z : points[i].y; + points[i] = new Vector3 (x, y, 0); + } else if (space == PathSpace.xz) { + float x = (minBoundsSize == boundsSize.x) ? points[i].y : points[i].x; + float z = (minBoundsSize == boundsSize.z) ? points[i].y : points[i].z; + points[i] = new Vector3 (x, 0, z); + } + } + } else { + // Nothing needs to change when going to 3d space + if (space != PathSpace.xyz) { + for (int i = 0; i < NumPoints; i++) { + // from xz to xy + if (space == PathSpace.xy) { + points[i] = new Vector3 (points[i].x, points[i].z, 0); + } + // from xy to xz + else if (space == PathSpace.xz) { + points[i] = new Vector3 (points[i].x, 0, points[i].y); + } + } + } + } + + NotifyPathModified (); + } + + /// Add/remove the extra 2 controls required for a closed path + void UpdateClosedState () { + if (isClosed) { + // Set positions for new controls to mirror their counterparts + Vector3 lastAnchorSecondControl = points[points.Count - 1] * 2 - points[points.Count - 2]; + Vector3 firstAnchorSecondControl = points[0] * 2 - points[1]; + if (controlMode != ControlMode.Mirrored && controlMode != ControlMode.Automatic) { + // Set positions for new controls to be aligned with their counterparts, but with a length of half the distance between start/end anchor + float dstBetweenStartAndEndAnchors = (points[points.Count - 1] - points[0]).magnitude; + lastAnchorSecondControl = points[points.Count - 1] + (points[points.Count - 1] - points[points.Count - 2]).normalized * dstBetweenStartAndEndAnchors * .5f; + firstAnchorSecondControl = points[0] + (points[0] - points[1]).normalized * dstBetweenStartAndEndAnchors * .5f; + } + points.Add (lastAnchorSecondControl); + points.Add (firstAnchorSecondControl); + } else { + points.RemoveRange (points.Count - 2, 2); + + } + + if (controlMode == ControlMode.Automatic) { + AutoSetStartAndEndControls (); + } + + if (OnModified != null) { + OnModified (); + } + } + + /// Loop index around to start/end of points array if out of bounds (useful when working with closed paths) + int LoopIndex (int i) { + return (i + points.Count) % points.Count; + } + + // Called when the path is modified + public void NotifyPathModified () { + boundsUpToDate = false; + if (OnModified != null) { + OnModified (); + } + } + + #endregion + + } +} \ No newline at end of file diff --git a/game/Assets/PathCreator/Core/Runtime/Objects/BezierPath.cs.meta b/game/Assets/PathCreator/Core/Runtime/Objects/BezierPath.cs.meta new file mode 100644 index 0000000..c1c193e --- /dev/null +++ b/game/Assets/PathCreator/Core/Runtime/Objects/BezierPath.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: 756209f371f304fb1920c53a8a25a5e2 +timeCreated: 1516786483 +licenseType: Store +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/game/Assets/PathCreator/Core/Runtime/Objects/EndOfPathInstruction.cs b/game/Assets/PathCreator/Core/Runtime/Objects/EndOfPathInstruction.cs new file mode 100644 index 0000000..697e361 --- /dev/null +++ b/game/Assets/PathCreator/Core/Runtime/Objects/EndOfPathInstruction.cs @@ -0,0 +1,3 @@ +namespace PathCreation { + public enum EndOfPathInstruction {Loop, Reverse, Stop}; +} diff --git a/game/Assets/PathCreator/Core/Runtime/Objects/EndOfPathInstruction.cs.meta b/game/Assets/PathCreator/Core/Runtime/Objects/EndOfPathInstruction.cs.meta new file mode 100644 index 0000000..6f25bdf --- /dev/null +++ b/game/Assets/PathCreator/Core/Runtime/Objects/EndOfPathInstruction.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c0d7fa70c03166e4180909b6e5d546c7 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/game/Assets/PathCreator/Core/Runtime/Objects/GlobalDisplaySettings.cs b/game/Assets/PathCreator/Core/Runtime/Objects/GlobalDisplaySettings.cs new file mode 100644 index 0000000..0d9254d --- /dev/null +++ b/game/Assets/PathCreator/Core/Runtime/Objects/GlobalDisplaySettings.cs @@ -0,0 +1,70 @@ +using System.Collections; +using System.Collections.Generic; +using UnityEngine; + +namespace PathCreation +{ + //[CreateAssetMenu()] + public class GlobalDisplaySettings : ScriptableObject + { + + public enum HandleType { Sphere, Circle, Square }; + + [Header("Appearance")] + public float anchorSize = 10; + public float controlSize = 7f; + + [Tooltip("Should the path still be drawn when behind objects in the scene?")] + public bool visibleBehindObjects = true; + [Tooltip("Should the path be drawn even when the path object is not selected?")] + public bool visibleWhenNotSelected = true; + [Tooltip("If true, control points will be hidden when the control point mode is set to automatic. Otherwise they will inactive, but still visible.")] + public bool hideAutoControls = true; + public HandleType anchorShape; + public HandleType controlShape; + + + [Header("Anchor Colours")] + public Color anchor = new Color(0.95f, 0.25f, 0.25f, 0.85f); + public Color anchorHighlighted = new Color(1, 0.57f, 0.4f); + public Color anchorSelected = Color.white; + + [Header("Control Colours")] + public Color control = new Color(0.35f, 0.6f, 1, 0.85f); + public Color controlHighlighted = new Color(0.8f, 0.67f, 0.97f); + public Color controlSelected = Color.white; + public Color handleDisabled = new Color(1, 1, 1, 0.2f); + public Color controlLine = new Color(0, 0, 0, 0.35f); + + [Header("Bezier Path Colours")] + public Color bezierPath = Color.green; + public Color highlightedPath = new Color(1, 0.6f, 0); + public Color bounds = new Color(1, 1, 1, .4f); + public Color segmentBounds = new Color(1, 1, 1, .4f); + + [Header("Vertex Path Colours")] + public Color vertexPath = Color.white; + + [Header("Normals")] + public Color normals = Color.yellow; + [Range(0,1)] + public float normalsLength = .1f; + +#if UNITY_EDITOR + public static GlobalDisplaySettings Load() { + string[] guids = UnityEditor.AssetDatabase.FindAssets("t:GlobalDisplaySettings"); + if (guids.Length == 0) + { + Debug.LogWarning("Could not find DisplaySettings asset. Will use default settings instead."); + return ScriptableObject.CreateInstance(); + } + else + { + string path = UnityEditor.AssetDatabase.GUIDToAssetPath(guids[0]); + return UnityEditor.AssetDatabase.LoadAssetAtPath(path); + } + } +#endif + + } +} diff --git a/game/Assets/PathCreator/Core/Runtime/Objects/GlobalDisplaySettings.cs.meta b/game/Assets/PathCreator/Core/Runtime/Objects/GlobalDisplaySettings.cs.meta new file mode 100644 index 0000000..cd66ac9 --- /dev/null +++ b/game/Assets/PathCreator/Core/Runtime/Objects/GlobalDisplaySettings.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 46d5e8d803e252f4499b52e657f8e1a2 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/game/Assets/PathCreator/Core/Runtime/Objects/MinMax3D.cs b/game/Assets/PathCreator/Core/Runtime/Objects/MinMax3D.cs new file mode 100644 index 0000000..4229602 --- /dev/null +++ b/game/Assets/PathCreator/Core/Runtime/Objects/MinMax3D.cs @@ -0,0 +1,21 @@ +using UnityEngine; + +namespace PathCreation { + public class MinMax3D { + + public Vector3 Min { get; private set; } + public Vector3 Max { get; private set; } + + public MinMax3D() + { + Min = Vector3.one * float.MaxValue; + Max = Vector3.one * float.MinValue; + } + + public void AddValue(Vector3 v) + { + Min = new Vector3(Mathf.Min(Min.x, v.x), Mathf.Min(Min.y,v.y), Mathf.Min(Min.z,v.z)); + Max = new Vector3(Mathf.Max(Max.x, v.x), Mathf.Max(Max.y,v.y), Mathf.Max(Max.z,v.z)); + } + } +} \ No newline at end of file diff --git a/game/Assets/PathCreator/Core/Runtime/Objects/MinMax3D.cs.meta b/game/Assets/PathCreator/Core/Runtime/Objects/MinMax3D.cs.meta new file mode 100644 index 0000000..f96e783 --- /dev/null +++ b/game/Assets/PathCreator/Core/Runtime/Objects/MinMax3D.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 194e1b7893dcbf940a71eb507d8b10f3 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/game/Assets/PathCreator/Core/Runtime/Objects/PathCreator.cs b/game/Assets/PathCreator/Core/Runtime/Objects/PathCreator.cs new file mode 100644 index 0000000..e8ecc19 --- /dev/null +++ b/game/Assets/PathCreator/Core/Runtime/Objects/PathCreator.cs @@ -0,0 +1,112 @@ +using System.Collections.Generic; +using UnityEngine; + +namespace PathCreation { + public class PathCreator : MonoBehaviour { + + /// This class stores data for the path editor, and provides accessors to get the current vertex and bezier path. + /// Attach to a GameObject to create a new path editor. + + public event System.Action pathUpdated; + + [SerializeField, HideInInspector] + PathCreatorData editorData; + [SerializeField, HideInInspector] + bool initialized; + + GlobalDisplaySettings globalEditorDisplaySettings; + + // Vertex path created from the current bezier path + public VertexPath path { + get { + if (!initialized) { + InitializeEditorData (false); + } + return editorData.GetVertexPath(transform); + } + } + + // The bezier path created in the editor + public BezierPath bezierPath { + get { + if (!initialized) { + InitializeEditorData (false); + } + return editorData.bezierPath; + } + set { + if (!initialized) { + InitializeEditorData (false); + } + editorData.bezierPath = value; + } + } + + #region Internal methods + + /// Used by the path editor to initialise some data + public void InitializeEditorData (bool in2DMode) { + if (editorData == null) { + editorData = new PathCreatorData (); + } + editorData.bezierOrVertexPathModified -= TriggerPathUpdate; + editorData.bezierOrVertexPathModified += TriggerPathUpdate; + + editorData.Initialize (in2DMode); + initialized = true; + } + + public PathCreatorData EditorData { + get { + return editorData; + } + + } + + public void TriggerPathUpdate () { + if (pathUpdated != null) { + pathUpdated (); + } + } + +#if UNITY_EDITOR + + // Draw the path when path objected is not selected (if enabled in settings) + void OnDrawGizmos () { + + // Only draw path gizmo if the path object is not selected + // (editor script is resposible for drawing when selected) + GameObject selectedObj = UnityEditor.Selection.activeGameObject; + if (selectedObj != gameObject) { + + if (path != null) { + path.UpdateTransform (transform); + + if (globalEditorDisplaySettings == null) { + globalEditorDisplaySettings = GlobalDisplaySettings.Load (); + } + + if (globalEditorDisplaySettings.visibleWhenNotSelected) { + + Gizmos.color = globalEditorDisplaySettings.bezierPath; + + for (int i = 0; i < path.NumPoints; i++) { + int nextI = i + 1; + if (nextI >= path.NumPoints) { + if (path.isClosedLoop) { + nextI %= path.NumPoints; + } else { + break; + } + } + Gizmos.DrawLine (path.GetPoint (i), path.GetPoint (nextI)); + } + } + } + } + } +#endif + + #endregion + } +} \ No newline at end of file diff --git a/game/Assets/PathCreator/Core/Runtime/Objects/PathCreator.cs.meta b/game/Assets/PathCreator/Core/Runtime/Objects/PathCreator.cs.meta new file mode 100644 index 0000000..242d3f5 --- /dev/null +++ b/game/Assets/PathCreator/Core/Runtime/Objects/PathCreator.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: 8e5ac92bc18f545cc84cd886ece82b4d +timeCreated: 1516864223 +licenseType: Store +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/game/Assets/PathCreator/Core/Runtime/Objects/PathCreatorData.cs b/game/Assets/PathCreator/Core/Runtime/Objects/PathCreatorData.cs new file mode 100644 index 0000000..8002be6 --- /dev/null +++ b/game/Assets/PathCreator/Core/Runtime/Objects/PathCreatorData.cs @@ -0,0 +1,136 @@ +using System.Collections.Generic; +using UnityEngine; + +namespace PathCreation { + /// Stores state data for the path creator editor + + [System.Serializable] + public class PathCreatorData { + public event System.Action bezierOrVertexPathModified; + public event System.Action bezierCreated; + + [SerializeField] + BezierPath _bezierPath; + VertexPath _vertexPath; + + [SerializeField] + bool vertexPathUpToDate; + + // vertex path settings + public float vertexPathMaxAngleError = .3f; + public float vertexPathMinVertexSpacing = 0.01f; + + // bezier display settings + public bool showTransformTool = true; + public bool showPathBounds; + public bool showPerSegmentBounds; + public bool displayAnchorPoints = true; + public bool displayControlPoints = true; + public float bezierHandleScale = 1; + public bool globalDisplaySettingsFoldout; + public bool keepConstantHandleSize; + + // vertex display settings + public bool showNormalsInVertexMode; + public bool showBezierPathInVertexMode; + + // Editor display states + public bool showDisplayOptions; + public bool showPathOptions = true; + public bool showVertexPathDisplayOptions; + public bool showVertexPathOptions = true; + public bool showNormals; + public bool showNormalsHelpInfo; + public int tabIndex; + + public void Initialize (bool defaultIs2D) { + if (_bezierPath == null) { + CreateBezier (Vector3.zero, defaultIs2D); + } + vertexPathUpToDate = false; + _bezierPath.OnModified -= BezierPathEdited; + _bezierPath.OnModified += BezierPathEdited; + } + + public void ResetBezierPath (Vector3 centre, bool defaultIs2D = false) { + CreateBezier (centre, defaultIs2D); + } + + void CreateBezier (Vector3 centre, bool defaultIs2D = false) { + if (_bezierPath != null) { + _bezierPath.OnModified -= BezierPathEdited; + } + + var space = (defaultIs2D) ? PathSpace.xy : PathSpace.xyz; + _bezierPath = new BezierPath (centre, false, space); + + _bezierPath.OnModified += BezierPathEdited; + vertexPathUpToDate = false; + + if (bezierOrVertexPathModified != null) { + bezierOrVertexPathModified (); + } + if (bezierCreated != null) { + bezierCreated (); + } + } + + public BezierPath bezierPath { + get { + return _bezierPath; + } + set { + _bezierPath.OnModified -= BezierPathEdited; + vertexPathUpToDate = false; + _bezierPath = value; + _bezierPath.OnModified += BezierPathEdited; + + if (bezierOrVertexPathModified != null) { + bezierOrVertexPathModified (); + } + if (bezierCreated != null) { + bezierCreated (); + } + + } + } + + // Get the current vertex path + public VertexPath GetVertexPath (Transform transform) { + // create new vertex path if path was modified since this vertex path was created + if (!vertexPathUpToDate || _vertexPath == null) { + vertexPathUpToDate = true; + _vertexPath = new VertexPath (bezierPath, transform, vertexPathMaxAngleError, vertexPathMinVertexSpacing); + } + return _vertexPath; + } + + public void PathTransformed () { + if (bezierOrVertexPathModified != null) { + bezierOrVertexPathModified (); + } + } + + public void VertexPathSettingsChanged () { + vertexPathUpToDate = false; + if (bezierOrVertexPathModified != null) { + bezierOrVertexPathModified (); + } + } + + public void PathModifiedByUndo () { + vertexPathUpToDate = false; + if (bezierOrVertexPathModified != null) { + bezierOrVertexPathModified (); + } + } + + void BezierPathEdited () { + vertexPathUpToDate = false; + if (bezierOrVertexPathModified != null) { + bezierOrVertexPathModified (); + } + } + + } +} \ No newline at end of file diff --git a/game/Assets/PathCreator/Core/Runtime/Objects/PathCreatorData.cs.meta b/game/Assets/PathCreator/Core/Runtime/Objects/PathCreatorData.cs.meta new file mode 100644 index 0000000..b626c46 --- /dev/null +++ b/game/Assets/PathCreator/Core/Runtime/Objects/PathCreatorData.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 19547029ffb83484e90d00c182104817 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/game/Assets/PathCreator/Core/Runtime/Objects/PathSpace.cs b/game/Assets/PathCreator/Core/Runtime/Objects/PathSpace.cs new file mode 100644 index 0000000..8bb0052 --- /dev/null +++ b/game/Assets/PathCreator/Core/Runtime/Objects/PathSpace.cs @@ -0,0 +1,3 @@ +namespace PathCreation { + public enum PathSpace {xyz, xy, xz}; +} diff --git a/game/Assets/PathCreator/Core/Runtime/Objects/PathSpace.cs.meta b/game/Assets/PathCreator/Core/Runtime/Objects/PathSpace.cs.meta new file mode 100644 index 0000000..2c89861 --- /dev/null +++ b/game/Assets/PathCreator/Core/Runtime/Objects/PathSpace.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 407af8f85a5bae449bce4730c5d97d1a +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/game/Assets/PathCreator/Core/Runtime/Objects/VertexPath.cs b/game/Assets/PathCreator/Core/Runtime/Objects/VertexPath.cs new file mode 100644 index 0000000..5fd6e6b --- /dev/null +++ b/game/Assets/PathCreator/Core/Runtime/Objects/VertexPath.cs @@ -0,0 +1,345 @@ +using System.Collections.Generic; +using PathCreation.Utility; +using UnityEngine; + + +namespace PathCreation { + /// A vertex path is a collection of points (vertices) that lie along a bezier path. + /// This allows one to do things like move at a constant speed along the path, + /// which is not possible with a bezier path directly due to how they're constructed mathematically. + + /// This class also provides methods for getting the position along the path at a certain distance or time + /// (where time = 0 is the start of the path, and time = 1 is the end of the path). + /// Other info about the path (tangents, normals, rotation) can also be retrieved in this manner. + + public class VertexPath { + #region Fields + + public readonly PathSpace space; + public readonly bool isClosedLoop; + public readonly Vector3[] localPoints; + public readonly Vector3[] localTangents; + public readonly Vector3[] localNormals; + + /// Percentage along the path at each vertex (0 being start of path, and 1 being the end) + public readonly float[] times; + /// Total distance between the vertices of the polyline + public readonly float length; + /// Total distance from the first vertex up to each vertex in the polyline + public readonly float[] cumulativeLengthAtEachVertex; + /// Bounding box of the path + public readonly Bounds bounds; + /// Equal to (0,0,-1) for 2D paths, and (0,1,0) for XZ paths + public readonly Vector3 up; + + // Default values and constants: + const int accuracy = 10; // A scalar for how many times bezier path is divided when determining vertex positions + const float minVertexSpacing = .01f; + + Transform transform; + + #endregion + + #region Constructors + + /// Splits bezier path into array of vertices along the path. + ///How much can the angle of the path change before a vertex is added. This allows fewer vertices to be generated in straighter sections. + ///Vertices won't be added closer together than this distance, regardless of angle error. + public VertexPath (BezierPath bezierPath, Transform transform, float maxAngleError = 0.3f, float minVertexDst = 0): + this (bezierPath, VertexPathUtility.SplitBezierPathByAngleError (bezierPath, maxAngleError, minVertexDst, VertexPath.accuracy), transform) { } + + /// Splits bezier path into array of vertices along the path. + ///How much can the angle of the path change before a vertex is added. This allows fewer vertices to be generated in straighter sections. + ///Vertices won't be added closer together than this distance, regardless of angle error. + ///Higher value means the change in angle is checked more frequently. + public VertexPath (BezierPath bezierPath, Transform transform, float vertexSpacing): + this (bezierPath, VertexPathUtility.SplitBezierPathEvenly (bezierPath, Mathf.Max (vertexSpacing, minVertexSpacing), VertexPath.accuracy), transform) { } + + /// Internal contructor + VertexPath (BezierPath bezierPath, VertexPathUtility.PathSplitData pathSplitData, Transform transform) { + this.transform = transform; + space = bezierPath.Space; + isClosedLoop = bezierPath.IsClosed; + int numVerts = pathSplitData.vertices.Count; + length = pathSplitData.cumulativeLength[numVerts - 1]; + + localPoints = new Vector3[numVerts]; + localNormals = new Vector3[numVerts]; + localTangents = new Vector3[numVerts]; + cumulativeLengthAtEachVertex = new float[numVerts]; + times = new float[numVerts]; + bounds = new Bounds ((pathSplitData.minMax.Min + pathSplitData.minMax.Max) / 2, pathSplitData.minMax.Max - pathSplitData.minMax.Min); + + // Figure out up direction for path + up = (bounds.size.z > bounds.size.y) ? Vector3.up : -Vector3.forward; + Vector3 lastRotationAxis = up; + + // Loop through the data and assign to arrays. + for (int i = 0; i < localPoints.Length; i++) { + localPoints[i] = pathSplitData.vertices[i]; + localTangents[i] = pathSplitData.tangents[i]; + cumulativeLengthAtEachVertex[i] = pathSplitData.cumulativeLength[i]; + times[i] = cumulativeLengthAtEachVertex[i] / length; + + // Calculate normals + if (space == PathSpace.xyz) { + if (i == 0) { + localNormals[0] = Vector3.Cross (lastRotationAxis, pathSplitData.tangents[0]).normalized; + } else { + // First reflection + Vector3 offset = (localPoints[i] - localPoints[i - 1]); + float sqrDst = offset.sqrMagnitude; + Vector3 r = lastRotationAxis - offset * 2 / sqrDst * Vector3.Dot (offset, lastRotationAxis); + Vector3 t = localTangents[i - 1] - offset * 2 / sqrDst * Vector3.Dot (offset, localTangents[i - 1]); + + // Second reflection + Vector3 v2 = localTangents[i] - t; + float c2 = Vector3.Dot (v2, v2); + + Vector3 finalRot = r - v2 * 2 / c2 * Vector3.Dot (v2, r); + Vector3 n = Vector3.Cross (finalRot, localTangents[i]).normalized; + localNormals[i] = n; + lastRotationAxis = finalRot; + } + } else { + localNormals[i] = Vector3.Cross (localTangents[i], up) * ((bezierPath.FlipNormals) ? 1 : -1); + } + } + + // Apply correction for 3d normals along a closed path + if (space == PathSpace.xyz && isClosedLoop) { + // Get angle between first and last normal (if zero, they're already lined up, otherwise we need to correct) + float normalsAngleErrorAcrossJoin = Vector3.SignedAngle (localNormals[localNormals.Length - 1], localNormals[0], localTangents[0]); + // Gradually rotate the normals along the path to ensure start and end normals line up correctly + if (Mathf.Abs (normalsAngleErrorAcrossJoin) > 0.1f) // don't bother correcting if very nearly correct + { + for (int i = 1; i < localNormals.Length; i++) { + float t = (i / (localNormals.Length - 1f)); + float angle = normalsAngleErrorAcrossJoin * t; + Quaternion rot = Quaternion.AngleAxis (angle, localTangents[i]); + localNormals[i] = rot * localNormals[i] * ((bezierPath.FlipNormals) ? -1 : 1); + } + } + } + + // Rotate normals to match up with user-defined anchor angles + if (space == PathSpace.xyz) { + for (int anchorIndex = 0; anchorIndex < pathSplitData.anchorVertexMap.Count - 1; anchorIndex++) { + int nextAnchorIndex = (isClosedLoop) ? (anchorIndex + 1) % bezierPath.NumSegments : anchorIndex + 1; + + float startAngle = bezierPath.GetAnchorNormalAngle (anchorIndex) + bezierPath.GlobalNormalsAngle; + float endAngle = bezierPath.GetAnchorNormalAngle (nextAnchorIndex) + bezierPath.GlobalNormalsAngle; + float deltaAngle = Mathf.DeltaAngle (startAngle, endAngle); + + int startVertIndex = pathSplitData.anchorVertexMap[anchorIndex]; + int endVertIndex = pathSplitData.anchorVertexMap[anchorIndex + 1]; + + int num = endVertIndex - startVertIndex; + if (anchorIndex == pathSplitData.anchorVertexMap.Count - 2) { + num += 1; + } + for (int i = 0; i < num; i++) { + int vertIndex = startVertIndex + i; + float t = i / (num - 1f); + float angle = startAngle + deltaAngle * t; + Quaternion rot = Quaternion.AngleAxis (angle, localTangents[vertIndex]); + localNormals[vertIndex] = (rot * localNormals[vertIndex]) * ((bezierPath.FlipNormals) ? -1 : 1); + } + } + } + } + + #endregion + + #region Public methods and accessors + + public void UpdateTransform (Transform transform) { + this.transform = transform; + } + public int NumPoints { + get { + return localPoints.Length; + } + } + + public Vector3 GetTangent (int index) { + return MathUtility.TransformDirection (localTangents[index], transform, space); + } + + public Vector3 GetNormal (int index) { + return MathUtility.TransformDirection (localNormals[index], transform, space); + } + + public Vector3 GetPoint (int index) { + return MathUtility.TransformPoint (localPoints[index], transform, space); + } + + /// Gets point on path based on distance travelled. + public Vector3 GetPointAtDistance (float dst, EndOfPathInstruction endOfPathInstruction = EndOfPathInstruction.Loop) { + float t = dst / length; + return GetPointAtTime (t, endOfPathInstruction); + } + + /// Gets forward direction on path based on distance travelled. + public Vector3 GetDirectionAtDistance (float dst, EndOfPathInstruction endOfPathInstruction = EndOfPathInstruction.Loop) { + float t = dst / length; + return GetDirection (t, endOfPathInstruction); + } + + /// Gets normal vector on path based on distance travelled. + public Vector3 GetNormalAtDistance (float dst, EndOfPathInstruction endOfPathInstruction = EndOfPathInstruction.Loop) { + float t = dst / length; + return GetNormal (t, endOfPathInstruction); + } + + /// Gets a rotation that will orient an object in the direction of the path at this point, with local up point along the path's normal + public Quaternion GetRotationAtDistance (float dst, EndOfPathInstruction endOfPathInstruction = EndOfPathInstruction.Loop) { + float t = dst / length; + return GetRotation (t, endOfPathInstruction); + } + + /// Gets point on path based on 'time' (where 0 is start, and 1 is end of path). + public Vector3 GetPointAtTime (float t, EndOfPathInstruction endOfPathInstruction = EndOfPathInstruction.Loop) { + var data = CalculatePercentOnPathData (t, endOfPathInstruction); + return Vector3.Lerp (GetPoint (data.previousIndex), GetPoint (data.nextIndex), data.percentBetweenIndices); + } + + /// Gets forward direction on path based on 'time' (where 0 is start, and 1 is end of path). + public Vector3 GetDirection (float t, EndOfPathInstruction endOfPathInstruction = EndOfPathInstruction.Loop) { + var data = CalculatePercentOnPathData (t, endOfPathInstruction); + Vector3 dir = Vector3.Lerp (localTangents[data.previousIndex], localTangents[data.nextIndex], data.percentBetweenIndices); + return MathUtility.TransformDirection (dir, transform, space); + } + + /// Gets normal vector on path based on 'time' (where 0 is start, and 1 is end of path). + public Vector3 GetNormal (float t, EndOfPathInstruction endOfPathInstruction = EndOfPathInstruction.Loop) { + var data = CalculatePercentOnPathData (t, endOfPathInstruction); + Vector3 normal = Vector3.Lerp (localNormals[data.previousIndex], localNormals[data.nextIndex], data.percentBetweenIndices); + return MathUtility.TransformDirection (normal, transform, space); + } + + /// Gets a rotation that will orient an object in the direction of the path at this point, with local up point along the path's normal + public Quaternion GetRotation (float t, EndOfPathInstruction endOfPathInstruction = EndOfPathInstruction.Loop) { + var data = CalculatePercentOnPathData (t, endOfPathInstruction); + Vector3 direction = Vector3.Lerp (localTangents[data.previousIndex], localTangents[data.nextIndex], data.percentBetweenIndices); + Vector3 normal = Vector3.Lerp (localNormals[data.previousIndex], localNormals[data.nextIndex], data.percentBetweenIndices); + return Quaternion.LookRotation (MathUtility.TransformDirection (direction, transform, space), MathUtility.TransformDirection (normal, transform, space)); + } + + /// Finds the closest point on the path from any point in the world + public Vector3 GetClosestPointOnPath (Vector3 worldPoint) { + TimeOnPathData data = CalculateClosestPointOnPathData (worldPoint); + return Vector3.Lerp (GetPoint (data.previousIndex), GetPoint (data.nextIndex), data.percentBetweenIndices); + } + + /// Finds the 'time' (0=start of path, 1=end of path) along the path that is closest to the given point + public float GetClosestTimeOnPath (Vector3 worldPoint) { + TimeOnPathData data = CalculateClosestPointOnPathData (worldPoint); + return Mathf.Lerp (times[data.previousIndex], times[data.nextIndex], data.percentBetweenIndices); + } + + /// Finds the distance along the path that is closest to the given point + public float GetClosestDistanceAlongPath (Vector3 worldPoint) { + TimeOnPathData data = CalculateClosestPointOnPathData (worldPoint); + return Mathf.Lerp (cumulativeLengthAtEachVertex[data.previousIndex], cumulativeLengthAtEachVertex[data.nextIndex], data.percentBetweenIndices); + } + + #endregion + + #region Internal methods + + /// For a given value 't' between 0 and 1, calculate the indices of the two vertices before and after t. + /// Also calculate how far t is between those two vertices as a percentage between 0 and 1. + TimeOnPathData CalculatePercentOnPathData (float t, EndOfPathInstruction endOfPathInstruction) { + // Constrain t based on the end of path instruction + switch (endOfPathInstruction) { + case EndOfPathInstruction.Loop: + // If t is negative, make it the equivalent value between 0 and 1 + if (t < 0) { + t += Mathf.CeilToInt (Mathf.Abs (t)); + } + t %= 1; + break; + case EndOfPathInstruction.Reverse: + t = Mathf.PingPong (t, 1); + break; + case EndOfPathInstruction.Stop: + t = Mathf.Clamp01 (t); + break; + } + + int prevIndex = 0; + int nextIndex = NumPoints - 1; + int i = Mathf.RoundToInt (t * (NumPoints - 1)); // starting guess + + // Starts by looking at middle vertex and determines if t lies to the left or to the right of that vertex. + // Continues dividing in half until closest surrounding vertices have been found. + while (true) { + // t lies to left + if (t <= times[i]) { + nextIndex = i; + } + // t lies to right + else { + prevIndex = i; + } + i = (nextIndex + prevIndex) / 2; + + if (nextIndex - prevIndex <= 1) { + break; + } + } + + float abPercent = Mathf.InverseLerp (times[prevIndex], times[nextIndex], t); + return new TimeOnPathData (prevIndex, nextIndex, abPercent); + } + + /// Calculate time data for closest point on the path from given world point + TimeOnPathData CalculateClosestPointOnPathData (Vector3 worldPoint) { + float minSqrDst = float.MaxValue; + Vector3 closestPoint = Vector3.zero; + int closestSegmentIndexA = 0; + int closestSegmentIndexB = 0; + + for (int i = 0; i < localPoints.Length; i++) { + int nextI = i + 1; + if (nextI >= localPoints.Length) { + if (isClosedLoop) { + nextI %= localPoints.Length; + } else { + break; + } + } + + Vector3 closestPointOnSegment = MathUtility.ClosestPointOnLineSegment (worldPoint, GetPoint (i), GetPoint (nextI)); + float sqrDst = (worldPoint - closestPointOnSegment).sqrMagnitude; + if (sqrDst < minSqrDst) { + minSqrDst = sqrDst; + closestPoint = closestPointOnSegment; + closestSegmentIndexA = i; + closestSegmentIndexB = nextI; + } + + } + float closestSegmentLength = (GetPoint (closestSegmentIndexA) - GetPoint (closestSegmentIndexB)).magnitude; + float t = (closestPoint - GetPoint (closestSegmentIndexA)).magnitude / closestSegmentLength; + return new TimeOnPathData (closestSegmentIndexA, closestSegmentIndexB, t); + } + + public struct TimeOnPathData { + public readonly int previousIndex; + public readonly int nextIndex; + public readonly float percentBetweenIndices; + + public TimeOnPathData (int prev, int next, float percentBetweenIndices) { + this.previousIndex = prev; + this.nextIndex = next; + this.percentBetweenIndices = percentBetweenIndices; + } + } + + #endregion + + } + +} \ No newline at end of file diff --git a/game/Assets/PathCreator/Core/Runtime/Objects/VertexPath.cs.meta b/game/Assets/PathCreator/Core/Runtime/Objects/VertexPath.cs.meta new file mode 100644 index 0000000..b8cf388 --- /dev/null +++ b/game/Assets/PathCreator/Core/Runtime/Objects/VertexPath.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 223183313f20d4049a397d83fab3151e +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/game/Assets/PathCreator/Core/Runtime/PathCreator.asmdef b/game/Assets/PathCreator/Core/Runtime/PathCreator.asmdef new file mode 100644 index 0000000..26c0dac --- /dev/null +++ b/game/Assets/PathCreator/Core/Runtime/PathCreator.asmdef @@ -0,0 +1,3 @@ +{ + "name": "PathCreator" +} diff --git a/game/Assets/PathCreator/Core/Runtime/PathCreator.asmdef.meta b/game/Assets/PathCreator/Core/Runtime/PathCreator.asmdef.meta new file mode 100644 index 0000000..4b98d32 --- /dev/null +++ b/game/Assets/PathCreator/Core/Runtime/PathCreator.asmdef.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 626070ea3273cb844a310aa4f53b31fa +AssemblyDefinitionImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/game/Assets/PathCreator/Core/Runtime/Utility.meta b/game/Assets/PathCreator/Core/Runtime/Utility.meta new file mode 100644 index 0000000..14dfdff --- /dev/null +++ b/game/Assets/PathCreator/Core/Runtime/Utility.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 4c55bdfe2cdafc04ba5f909d4f1f192b +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/game/Assets/PathCreator/Core/Runtime/Utility/CubicBezierUtility.cs b/game/Assets/PathCreator/Core/Runtime/Utility/CubicBezierUtility.cs new file mode 100644 index 0000000..ceded9f --- /dev/null +++ b/game/Assets/PathCreator/Core/Runtime/Utility/CubicBezierUtility.cs @@ -0,0 +1,136 @@ +using System.Collections; +using System.Collections.Generic; +using UnityEngine; + +namespace PathCreation.Utility { + + /// Collection of functions related to cubic bezier curves + /// (a curve with a start and end 'anchor' point, and two 'control' points to define the shape of the curve between the anchors) + public static class CubicBezierUtility { + + /// Returns point at time 't' (between 0 and 1) along bezier curve defined by 4 points (anchor_1, control_1, control_2, anchor_2) + public static Vector3 EvaluateCurve (Vector3[] points, float t) { + return EvaluateCurve (points[0], points[1], points[2], points[3], t); + } + + /// Returns point at time 't' (between 0 and 1) along bezier curve defined by 4 points (anchor_1, control_1, control_2, anchor_2) + public static Vector3 EvaluateCurve (Vector3 a1, Vector3 c1, Vector3 c2, Vector3 a2, float t) { + t = Mathf.Clamp01 (t); + return (1 - t) * (1 - t) * (1 - t) * a1 + 3 * (1 - t) * (1 - t) * t * c1 + 3 * (1 - t) * t * t * c2 + t * t * t * a2; + } + + /// Returns a vector tangent to the point at time 't' + /// This is the vector tangent to the curve at that point + public static Vector3 EvaluateCurveDerivative (Vector3[] points, float t) { + return EvaluateCurveDerivative (points[0], points[1], points[2], points[3], t); + } + + /// Calculates the derivative of the curve at time 't' + /// This is the vector tangent to the curve at that point + public static Vector3 EvaluateCurveDerivative (Vector3 a1, Vector3 c1, Vector3 c2, Vector3 a2, float t) { + t = Mathf.Clamp01 (t); + return 3 * (1 - t) * (1 - t) * (c1 - a1) + 6 * (1 - t) * t * (c2 - c1) + 3 * t * t * (a2 - c2); + } + + /// Returns the second derivative of the curve at time 't' + public static Vector3 EvaluateCurveSecondDerivative (Vector3[] points, float t) { + return EvaluateCurveSecondDerivative (points[0], points[1], points[2], points[3], t); + } + + ///Returns the second derivative of the curve at time 't' + public static Vector3 EvaluateCurveSecondDerivative (Vector3 a1, Vector3 c1, Vector3 c2, Vector3 a2, float t) { + t = Mathf.Clamp01 (t); + return 6 * (1 - t) * (c2 - 2 * c1 + a1) + 6 * t * (a2 - 2 * c2 + c1); + } + + /// Calculates the normal vector (vector perpendicular to the curve) at specified time + public static Vector3 Normal (Vector3[] points, float t) { + return Normal (points[0], points[1], points[2], points[3], t); + } + + /// Calculates the normal vector (vector perpendicular to the curve) at specified time + public static Vector3 Normal (Vector3 a1, Vector3 c1, Vector3 c2, Vector3 a2, float t) { + Vector3 tangent = EvaluateCurveDerivative (a1, c1, c2, a2, t); + Vector3 nextTangent = EvaluateCurveSecondDerivative (a1, c1, c2, a2, t); + Vector3 c = Vector3.Cross (nextTangent, tangent); + return Vector3.Cross (c, tangent).normalized; + } + + public static Bounds CalculateSegmentBounds (Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3) { + MinMax3D minMax = new MinMax3D (); + minMax.AddValue (p0); + minMax.AddValue (p3); + + List extremePointTimes = ExtremePointTimes (p0,p1,p2,p3); + foreach (float t in extremePointTimes) { + minMax.AddValue (CubicBezierUtility.EvaluateCurve (p0, p1, p2, p3, t)); + } + + return new Bounds ((minMax.Min + minMax.Max) / 2, minMax.Max - minMax.Min); + } + + /// Splits curve into two curves at time t. Returns 2 arrays of 4 points. + public static Vector3[][] SplitCurve (Vector3[] points, float t) { + Vector3 a1 = Vector3.Lerp (points[0], points[1], t); + Vector3 a2 = Vector3.Lerp (points[1], points[2], t); + Vector3 a3 = Vector3.Lerp (points[2], points[3], t); + Vector3 b1 = Vector3.Lerp (a1, a2, t); + Vector3 b2 = Vector3.Lerp (a2, a3, t); + Vector3 pointOnCurve = Vector3.Lerp (b1, b2, t); + + return new Vector3[][] { + new Vector3[] { points[0], a1, b1, pointOnCurve }, + new Vector3[] { pointOnCurve, b2, a3, points[3] } + }; + } + + // Crude, but fast estimation of curve length. + public static float EstimateCurveLength (Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3) { + float controlNetLength = (p0 - p1).magnitude + (p1 - p2).magnitude + (p2 - p3).magnitude; + float estimatedCurveLength = (p0 - p3).magnitude + controlNetLength / 2f; + return estimatedCurveLength; + } + + /// Times of stationary points on curve (points where derivative is zero on any axis) + public static List ExtremePointTimes (Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3) { + // coefficients of derivative function + Vector3 a = 3 * (-p0 + 3 * p1 - 3 * p2 + p3); + Vector3 b = 6 * (p0 - 2 * p1 + p2); + Vector3 c = 3 * (p1 - p0); + + List times = new List (); + times.AddRange (StationaryPointTimes (a.x, b.x, c.x)); + times.AddRange (StationaryPointTimes (a.y, b.y, c.y)); + times.AddRange (StationaryPointTimes (a.z, b.z, c.z)); + return times; + } + + // Finds times of stationary points on curve defined by ax^2 + bx + c. + // Only times between 0 and 1 are considered as Bezier only uses values in that range + static IEnumerable StationaryPointTimes (float a, float b, float c) { + List times = new List (); + + // from quadratic equation: y = [-b +- sqrt(b^2 - 4ac)]/2a + if (a != 0) { + float discriminant = b * b - 4 * a * c; + if (discriminant >= 0) { + float s = Mathf.Sqrt (discriminant); + float t1 = (-b + s) / (2 * a); + if (t1 >= 0 && t1 <= 1) { + times.Add (t1); + } + + if (discriminant != 0) { + float t2 = (-b - s) / (2 * a); + + if (t2 >= 0 && t2 <= 1) { + times.Add (t2); + } + } + } + } + return times; + } + + } +} \ No newline at end of file diff --git a/game/Assets/PathCreator/Core/Runtime/Utility/CubicBezierUtility.cs.meta b/game/Assets/PathCreator/Core/Runtime/Utility/CubicBezierUtility.cs.meta new file mode 100644 index 0000000..ebf6cae --- /dev/null +++ b/game/Assets/PathCreator/Core/Runtime/Utility/CubicBezierUtility.cs.meta @@ -0,0 +1,13 @@ +fileFormatVersion: 2 +guid: c66a6536bb2d641558729d6da1ec7594 +timeCreated: 1519565538 +licenseType: Store +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/game/Assets/PathCreator/Core/Runtime/Utility/MathUtility.cs b/game/Assets/PathCreator/Core/Runtime/Utility/MathUtility.cs new file mode 100644 index 0000000..af862ba --- /dev/null +++ b/game/Assets/PathCreator/Core/Runtime/Utility/MathUtility.cs @@ -0,0 +1,162 @@ +using System.Collections.Generic; +using UnityEngine; + +namespace PathCreation.Utility { + public static class MathUtility { + + static PosRotScale LockTransformToSpace (Transform t, PathSpace space) { + var original = new PosRotScale (t); + if (space == PathSpace.xy) { + t.eulerAngles = new Vector3 (0, 0, t.eulerAngles.z); + t.position = new Vector3 (t.position.x, t.position.y, 0); + } else if (space == PathSpace.xz) { + t.eulerAngles = new Vector3 (0, t.eulerAngles.y, 0); + t.position = new Vector3 (t.position.x, 0, t.position.z); + } + + //float maxScale = Mathf.Max (t.localScale.x * t.parent.localScale.x, t.localScale.y * t.parent.localScale.y, t.localScale.z * t.parent.localScale.z); + float maxScale = Mathf.Max (t.lossyScale.x, t.lossyScale.y, t.lossyScale.z); + + t.localScale = Vector3.one * maxScale; + + return original; + } + + public static Vector3 TransformPoint (Vector3 p, Transform t, PathSpace space) { + var original = LockTransformToSpace (t, space); + Vector3 transformedPoint = t.TransformPoint (p); + original.SetTransform (t); + return transformedPoint; + } + + public static Vector3 InverseTransformPoint (Vector3 p, Transform t, PathSpace space) { + var original = LockTransformToSpace (t, space); + Vector3 transformedPoint = t.InverseTransformPoint (p); + original.SetTransform (t); + return transformedPoint; + } + + public static Vector3 TransformVector (Vector3 p, Transform t, PathSpace space) { + var original = LockTransformToSpace (t, space); + Vector3 transformedPoint = t.TransformVector (p); + original.SetTransform (t); + return transformedPoint; + } + + public static Vector3 InverseTransformVector (Vector3 p, Transform t, PathSpace space) { + var original = LockTransformToSpace (t, space); + Vector3 transformedPoint = t.InverseTransformVector (p); + original.SetTransform (t); + return transformedPoint; + } + + public static Vector3 TransformDirection (Vector3 p, Transform t, PathSpace space) { + var original = LockTransformToSpace (t, space); + Vector3 transformedPoint = t.TransformDirection (p); + original.SetTransform (t); + return transformedPoint; + } + + public static Vector3 InverseTransformDirection (Vector3 p, Transform t, PathSpace space) { + var original = LockTransformToSpace (t, space); + Vector3 transformedPoint = t.InverseTransformDirection (p); + original.SetTransform (t); + return transformedPoint; + } + + public static bool LineSegmentsIntersect (Vector2 a1, Vector2 a2, Vector2 b1, Vector2 b2) { + float d = (b2.x - b1.x) * (a1.y - a2.y) - (a1.x - a2.x) * (b2.y - b1.y); + if (d == 0) + return false; + float t = ((b1.y - b2.y) * (a1.x - b1.x) + (b2.x - b1.x) * (a1.y - b1.y)) / d; + float u = ((a1.y - a2.y) * (a1.x - b1.x) + (a2.x - a1.x) * (a1.y - b1.y)) / d; + + return t >= 0 && t <= 1 && u >= 0 && u <= 1; + } + + public static bool LinesIntersect (Vector2 a1, Vector2 a2, Vector2 a3, Vector2 a4) { + return (a1.x - a2.x) * (a3.y - a4.y) - (a1.y - a2.y) * (a3.x - a4.x) != 0; + } + + public static Vector2 PointOfLineLineIntersection (Vector2 a1, Vector2 a2, Vector2 a3, Vector2 a4) { + float d = (a1.x - a2.x) * (a3.y - a4.y) - (a1.y - a2.y) * (a3.x - a4.x); + if (d == 0) { + Debug.LogError ("Lines are parallel, please check that this is not the case before calling line intersection method"); + return Vector2.zero; + } else { + float n = (a1.x - a3.x) * (a3.y - a4.y) - (a1.y - a3.y) * (a3.x - a4.x); + float t = n / d; + return a1 + (a2 - a1) * t; + } + } + + public static Vector2 ClosestPointOnLineSegment (Vector2 p, Vector2 a, Vector2 b) { + Vector2 aB = b - a; + Vector2 aP = p - a; + float sqrLenAB = aB.sqrMagnitude; + + if (sqrLenAB == 0) + return a; + + float t = Mathf.Clamp01 (Vector2.Dot (aP, aB) / sqrLenAB); + return a + aB * t; + } + + public static Vector3 ClosestPointOnLineSegment (Vector3 p, Vector3 a, Vector3 b) { + Vector3 aB = b - a; + Vector3 aP = p - a; + float sqrLenAB = aB.sqrMagnitude; + + if (sqrLenAB == 0) + return a; + + float t = Mathf.Clamp01 (Vector3.Dot (aP, aB) / sqrLenAB); + return a + aB * t; + } + + public static int SideOfLine (Vector2 a, Vector2 b, Vector2 c) { + return (int) Mathf.Sign ((c.x - a.x) * (-b.y + a.y) + (c.y - a.y) * (b.x - a.x)); + } + + /// returns the smallest angle between ABC. Never greater than 180 + public static float MinAngle (Vector3 a, Vector3 b, Vector3 c) { + return Vector3.Angle ((a - b), (c - b)); + } + + public static bool PointInTriangle (Vector2 a, Vector2 b, Vector2 c, Vector2 p) { + float area = 0.5f * (-b.y * c.x + a.y * (-b.x + c.x) + a.x * (b.y - c.y) + b.x * c.y); + float s = 1 / (2 * area) * (a.y * c.x - a.x * c.y + (c.y - a.y) * p.x + (a.x - c.x) * p.y); + float t = 1 / (2 * area) * (a.x * b.y - a.y * b.x + (a.y - b.y) * p.x + (b.x - a.x) * p.y); + return s >= 0 && t >= 0 && (s + t) <= 1; + } + + public static bool PointsAreClockwise (Vector2[] points) { + float signedArea = 0; + for (int i = 0; i < points.Length; i++) { + int nextIndex = (i + 1) % points.Length; + signedArea += (points[nextIndex].x - points[i].x) * (points[nextIndex].y + points[i].y); + } + + return signedArea >= 0; + } + + class PosRotScale { + public readonly Vector3 position; + public readonly Quaternion rotation; + public readonly Vector3 scale; + + public PosRotScale (Transform t) { + this.position = t.position; + this.rotation = t.rotation; + this.scale = t.localScale; + } + + public void SetTransform (Transform t) { + t.position = position; + t.rotation = rotation; + t.localScale = scale; + + } + } + } +} \ No newline at end of file diff --git a/game/Assets/PathCreator/Core/Runtime/Utility/MathUtility.cs.meta b/game/Assets/PathCreator/Core/Runtime/Utility/MathUtility.cs.meta new file mode 100644 index 0000000..277ff19 --- /dev/null +++ b/game/Assets/PathCreator/Core/Runtime/Utility/MathUtility.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 096bae1d1ed960d4bb7605dce06767c1 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/game/Assets/PathCreator/Core/Runtime/Utility/VertexPathUtility.cs b/game/Assets/PathCreator/Core/Runtime/Utility/VertexPathUtility.cs new file mode 100644 index 0000000..69ab950 --- /dev/null +++ b/game/Assets/PathCreator/Core/Runtime/Utility/VertexPathUtility.cs @@ -0,0 +1,139 @@ +using System.Collections.Generic; +using UnityEngine; + +namespace PathCreation.Utility +{ + public static class VertexPathUtility + { + + public static PathSplitData SplitBezierPathByAngleError(BezierPath bezierPath, float maxAngleError, float minVertexDst, float accuracy) + { + PathSplitData splitData = new PathSplitData(); + + splitData.vertices.Add(bezierPath[0]); + splitData.tangents.Add(CubicBezierUtility.EvaluateCurveDerivative(bezierPath.GetPointsInSegment(0), 0).normalized); + splitData.cumulativeLength.Add(0); + splitData.anchorVertexMap.Add(0); + splitData.minMax.AddValue(bezierPath[0]); + + Vector3 prevPointOnPath = bezierPath[0]; + Vector3 lastAddedPoint = bezierPath[0]; + + float currentPathLength = 0; + float dstSinceLastVertex = 0; + + // Go through all segments and split up into vertices + for (int segmentIndex = 0; segmentIndex < bezierPath.NumSegments; segmentIndex++) + { + Vector3[] segmentPoints = bezierPath.GetPointsInSegment(segmentIndex); + float estimatedSegmentLength = CubicBezierUtility.EstimateCurveLength(segmentPoints[0], segmentPoints[1], segmentPoints[2], segmentPoints[3]); + int divisions = Mathf.CeilToInt(estimatedSegmentLength * accuracy); + float increment = 1f / divisions; + + for (float t = increment; t <= 1; t += increment) + { + bool isLastPointOnPath = (t + increment > 1 && segmentIndex == bezierPath.NumSegments - 1); + if (isLastPointOnPath) + { + t = 1; + } + Vector3 pointOnPath = CubicBezierUtility.EvaluateCurve(segmentPoints, t); + Vector3 nextPointOnPath = CubicBezierUtility.EvaluateCurve(segmentPoints, t + increment); + + // angle at current point on path + float localAngle = 180 - MathUtility.MinAngle(prevPointOnPath, pointOnPath, nextPointOnPath); + // angle between the last added vertex, the current point on the path, and the next point on the path + float angleFromPrevVertex = 180 - MathUtility.MinAngle(lastAddedPoint, pointOnPath, nextPointOnPath); + float angleError = Mathf.Max(localAngle, angleFromPrevVertex); + + + if ((angleError > maxAngleError && dstSinceLastVertex >= minVertexDst) || isLastPointOnPath) + { + + currentPathLength += (lastAddedPoint - pointOnPath).magnitude; + splitData.cumulativeLength.Add(currentPathLength); + splitData.vertices.Add(pointOnPath); + splitData.tangents.Add(CubicBezierUtility.EvaluateCurveDerivative(segmentPoints, t).normalized); + splitData.minMax.AddValue(pointOnPath); + dstSinceLastVertex = 0; + lastAddedPoint = pointOnPath; + } + else + { + dstSinceLastVertex += (pointOnPath - prevPointOnPath).magnitude; + } + prevPointOnPath = pointOnPath; + } + splitData.anchorVertexMap.Add(splitData.vertices.Count - 1); + } + return splitData; + } + + public static PathSplitData SplitBezierPathEvenly(BezierPath bezierPath, float spacing, float accuracy) + { + PathSplitData splitData = new PathSplitData(); + + splitData.vertices.Add(bezierPath[0]); + splitData.tangents.Add(CubicBezierUtility.EvaluateCurveDerivative(bezierPath.GetPointsInSegment(0), 0).normalized); + splitData.cumulativeLength.Add(0); + splitData.anchorVertexMap.Add(0); + splitData.minMax.AddValue(bezierPath[0]); + + Vector3 prevPointOnPath = bezierPath[0]; + Vector3 lastAddedPoint = bezierPath[0]; + + float currentPathLength = 0; + float dstSinceLastVertex = 0; + + // Go through all segments and split up into vertices + for (int segmentIndex = 0; segmentIndex < bezierPath.NumSegments; segmentIndex++) + { + Vector3[] segmentPoints = bezierPath.GetPointsInSegment(segmentIndex); + float estimatedSegmentLength = CubicBezierUtility.EstimateCurveLength(segmentPoints[0], segmentPoints[1], segmentPoints[2], segmentPoints[3]); + int divisions = Mathf.CeilToInt(estimatedSegmentLength * accuracy); + float increment = 1f / divisions; + + for (float t = increment; t <= 1; t += increment) + { + bool isLastPointOnPath = (t + increment > 1 && segmentIndex == bezierPath.NumSegments - 1); + if (isLastPointOnPath) + { + t = 1; + } + Vector3 pointOnPath = CubicBezierUtility.EvaluateCurve(segmentPoints, t); + dstSinceLastVertex += (pointOnPath - prevPointOnPath).magnitude; + + // If vertices are now too far apart, go back by amount we overshot by + if (dstSinceLastVertex > spacing) { + float overshootDst = dstSinceLastVertex - spacing; + pointOnPath += (prevPointOnPath-pointOnPath).normalized * overshootDst; + t-=increment; + } + + if (dstSinceLastVertex >= spacing || isLastPointOnPath) + { + currentPathLength += (lastAddedPoint - pointOnPath).magnitude; + splitData.cumulativeLength.Add(currentPathLength); + splitData.vertices.Add(pointOnPath); + splitData.tangents.Add(CubicBezierUtility.EvaluateCurveDerivative(segmentPoints, t).normalized); + splitData.minMax.AddValue(pointOnPath); + dstSinceLastVertex = 0; + lastAddedPoint = pointOnPath; + } + prevPointOnPath = pointOnPath; + } + splitData.anchorVertexMap.Add(splitData.vertices.Count - 1); + } + return splitData; + } + + + public class PathSplitData { + public List vertices = new List(); + public List tangents = new List(); + public List cumulativeLength = new List(); + public List anchorVertexMap = new List(); + public MinMax3D minMax = new MinMax3D(); + } + } +} \ No newline at end of file diff --git a/game/Assets/PathCreator/Core/Runtime/Utility/VertexPathUtility.cs.meta b/game/Assets/PathCreator/Core/Runtime/Utility/VertexPathUtility.cs.meta new file mode 100644 index 0000000..a36c3a7 --- /dev/null +++ b/game/Assets/PathCreator/Core/Runtime/Utility/VertexPathUtility.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5505526f3c472e8499fa7ce169410ace +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/game/Assets/PathCreator/Core/Settings.meta b/game/Assets/PathCreator/Core/Settings.meta new file mode 100644 index 0000000..8ecf40c --- /dev/null +++ b/game/Assets/PathCreator/Core/Settings.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 4f9b1508dc64040469b4b1ee117d27a9 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/game/Assets/PathCreator/Core/Settings/GlobalDisplaySettings.asset b/game/Assets/PathCreator/Core/Settings/GlobalDisplaySettings.asset new file mode 100644 index 0000000..53dbd17 --- /dev/null +++ b/game/Assets/PathCreator/Core/Settings/GlobalDisplaySettings.asset @@ -0,0 +1,36 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!114 &11400000 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 46d5e8d803e252f4499b52e657f8e1a2, type: 3} + m_Name: GlobalDisplaySettings + m_EditorClassIdentifier: + anchorSize: 10 + controlSize: 7 + visibleBehindObjects: 1 + visibleWhenNotSelected: 1 + hideAutoControls: 1 + anchorShape: 0 + controlShape: 0 + anchor: {r: 1, g: 0.3726415, b: 0.3726415, a: 1} + anchorHighlighted: {r: 0.735849, g: 0.03818085, b: 0.03818085, a: 1} + anchorSelected: {r: 1, g: 1, b: 1, a: 1} + control: {r: 0.35, g: 0.6, b: 1, a: 1} + controlHighlighted: {r: 0.19579923, g: 0.19579923, b: 0.754717, a: 1} + controlSelected: {r: 1, g: 1, b: 1, a: 1} + handleDisabled: {r: 1, g: 1, b: 1, a: 0.2} + controlLine: {r: 0, g: 0, b: 0, a: 0.7254902} + bezierPath: {r: 0, g: 1, b: 0, a: 1} + highlightedPath: {r: 1, g: 0.6, b: 0, a: 1} + bounds: {r: 1, g: 1, b: 1, a: 0.4} + segmentBounds: {r: 1, g: 1, b: 1, a: 0.4} + vertexPath: {r: 1, g: 1, b: 1, a: 1} + normals: {r: 1, g: 0.92156863, b: 0.015686275, a: 1} + normalsLength: 0.198 diff --git a/game/Assets/PathCreator/Core/Settings/GlobalDisplaySettings.asset.meta b/game/Assets/PathCreator/Core/Settings/GlobalDisplaySettings.asset.meta new file mode 100644 index 0000000..b4c86c8 --- /dev/null +++ b/game/Assets/PathCreator/Core/Settings/GlobalDisplaySettings.asset.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 35fab21375bf12f4b96eba4dafa4ad30 +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 11400000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/game/Assets/PathCreator/Documentation.meta b/game/Assets/PathCreator/Documentation.meta new file mode 100644 index 0000000..10b2fce --- /dev/null +++ b/game/Assets/PathCreator/Documentation.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 7f53e212088d741abad12e1f2315eee7 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/game/Assets/PathCreator/Documentation/Documentation.pdf b/game/Assets/PathCreator/Documentation/Documentation.pdf new file mode 100644 index 0000000000000000000000000000000000000000..208013adc01b6e1c7736202950ec272042bd75bc GIT binary patch literal 524885 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

LNr%O`Xg8;m&ID- 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%0AP1N>bp&bRZr98zp~ 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

|u!d6+ShJQEU;PYTvS!`P(4U_ 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