Beispiel #1
0
    int FindNearestNode()
    {
        TrackNodeTool trackNodeToolScript = (TrackNodeTool)target;
        TrackNode     trackNode           = trackNodeToolScript.trackNode;
        Vector3       result = Vector3.zero;
        int           ind    = -1;

        if (trackNode != null)
        {
            Transform trackNodeToolTransform = trackNodeToolScript.GetComponent <Transform>();

            float distance = float.MaxValue;
            for (int index = 0; index < trackNode.GetNodeCount(); index++)
            {
                float possibleDistance = Vector3.Distance(trackNodeToolTransform.position, trackNode.GetNode(index));
                if (possibleDistance < distance)
                {
                    distance = possibleDistance;
                    result   = trackNodeToolTransform.position;
                    ind      = index;
                }
            }
        }

        return(ind);
    }
Beispiel #2
0
    TrackNode GetTrackNode()
    {
        TrackNodeTool trackNodeToolScript = (TrackNodeTool)target;
        TrackNode     trackNode           = trackNodeToolScript.trackNode;

        return(trackNode);
    }
Beispiel #3
0
    void DebugDraw(SceneView sceneView)
    {
        TrackNodeTool trackNodeToolScript = (TrackNodeTool)target;
        TrackNode     trackNode           = trackNodeToolScript.trackNode;

        if (trackNode.GetNodeCount() <= 0)
        {
            return;
        }

        if (trackNode != null)
        {
            Transform trackNodeToolTransform = null;
            try
            { trackNodeToolTransform = trackNodeToolScript.GetComponent <Transform>(); }
            catch
            {
                doDrawTrajectory = false;

                while (subscribeCount > 0)
                {
                    SceneView.onSceneGUIDelegate -= DebugDraw;
                    subscribeCount--;
                }
                return;
            }



            for (int index = 0; index < trackNode.GetNodeCount(); index++)
            {
                if (trackNode.isLoopOpen && index == 0)
                {
                    continue;
                }

                if ((index & 1) == 1)
                {
                    Handles.color = Color.red;
                }
                else
                {
                    Handles.color = Color.cyan;
                }
                Handles.DrawLine(trackNode.GetNode(index), trackNode.GetNode(index - 1));
            }

            Handles.color = Color.blue;
            Handles.DrawLine(trackNode.GetNode(trackNode.GetNodeCount() - 1), trackNodeToolTransform.position);

            Handles.color = Color.yellow;
            Handles.DrawLine(trackNode.GetNode(0), trackNodeToolTransform.position);
            Handles.color = Color.green;
            Handles.DrawLine(trackNode.GetNode(cycleNodeIndex), trackNodeToolTransform.position);
        }
    }
Beispiel #4
0
    void CycleNode(int dir)
    {
        TrackNodeTool trackNodeToolScript = (TrackNodeTool)target;
        TrackNode     trackNode           = GetTrackNode();

        if (trackNode != null)
        {
            CycleNodeIndex += dir;
        }
    }
Beispiel #5
0
    void SetHandleAtIndex(int index)
    {
        TrackNodeTool trackNodeScript = (TrackNodeTool)target;

        TrackNode trackNode = trackNodeScript.trackNode;

        if (trackNode != null)
        {
            trackNodeScript.GetComponent <Transform>().position = trackNode.GetNode(index);
        }
    }
Beispiel #6
0
    void DebugDraw()
    {
        TrackNodeTool trackNodeScript = (TrackNodeTool)target;

        for (int index = 0; index < trackNodeScript.trackNode.GetNodeCount(); index++)
        {
            Handles.color = Color.red;
            Handles.DrawLine(trackNodeScript.trackNode.GetNode(index), trackNodeScript.trackNode.GetNode(index - 1));
        }

        Handles.color = Color.blue;
        Handles.DrawLine(trackNodeScript.trackNode.GetNode(trackNodeScript.trackNode.GetNodeCount() - 1), trackNodeScript.GetComponent <Transform> ().position);
        Handles.color = Color.yellow;
        Handles.DrawLine(trackNodeScript.trackNode.GetNode(0), trackNodeScript.GetComponent <Transform> ().position);
        Handles.color = Color.green;
        Handles.DrawLine(trackNodeScript.trackNode.GetNode(cycleNodeIndex), trackNodeScript.GetComponent <Transform> ().position);
    }
Beispiel #7
0
    void CycleNode(int dir)
    {
        TrackNodeTool trackNodeScript = (TrackNodeTool)target;

        cycleNodeIndex += dir;

        if (cycleNodeIndex >= trackNodeScript.trackNode.GetNodeCount())
        {
            cycleNodeIndex = 0;
        }


        if (cycleNodeIndex < 0)
        {
            cycleNodeIndex = trackNodeScript.trackNode.GetNodeCount() - 1;
        }
    }
Beispiel #8
0
    void CycleNode(int dir)
    {
        TrackNodeTool trackNodeToolScript = (TrackNodeTool)target;
        TrackNode     trackNode           = GetTrackNode();

        if (trackNode != null)
        {
            cycleNodeIndex += dir;
            trackNode.ClampIndex(ref cycleNodeIndex);

            /*
             *          if (cycleNodeIndex >=trackNode.GetNodeCount ())
             *          {cycleNodeIndex = 0;}
             *          if (cycleNodeIndex < 0)
             *          {cycleNodeIndex =trackNode.GetNodeCount () - 1;}
             */
        }
    }
Beispiel #9
0
    public override void OnInspectorGUI()
    {
        TrackNodeTool trackNodeScript = (TrackNodeTool)target;

        DrawDefaultInspector();

        if (GUILayout.Button("Draw track curve"))
        {
            doDrawTrajectory = !doDrawTrajectory;
            DebugDraw();
        }

        if (GUILayout.Button("Add and Set Node"))
        {
            Vector3 pos = CalculatePositionAboveTheTrack(trackNodeScript.GetComponent <Transform> ().position);
            trackNodeScript.trackNode.AddNode(pos);
            cycleNodeIndex = trackNodeScript.trackNode.GetNodeCount() - 1;
        }

        if (GUILayout.Button("Set selected node"))
        {
            Vector3 pos = CalculatePositionAboveTheTrack(trackNodeScript.GetComponent <Transform> ().position);
            trackNodeScript.trackNode.SetNode(pos, cycleNodeIndex);
        }

        if (GUILayout.Button("Cycle up node"))
        {
            CycleNode(1);
            SetHandle();
        }

        if (GUILayout.Button("Cycle down node"))
        {
            CycleNode(-1);
            SetHandle();
        }

        if (GUILayout.Button("Set handle at selected node"))
        {
            SetHandle();
        }

        SceneView.RepaintAll();
    }
Beispiel #10
0
    void OnSceneGUI()
    {
        TrackNodeTool trackNodeToolScript = (TrackNodeTool)target;

        if (enableOnScreenPlacement && useSpaceBarToSet && EventType.KeyDown == Event.current.type && Event.current.keyCode == KeyCode.Space)
        {
            enableOnScreenPlacement = false;
            TrackNode trackNode = GetTrackNode();
            if (trackNode != null)
            {
                Vector3 pos = CalculatePositionAboveTheTrack(trackNodeToolScript.GetComponent <Transform>().position);

                GetTrackNode().AddNode(pos);
                cycleNodeIndex = GetTrackNode().GetNodeCount() - 1;
            }
        }
        else if (EventType.KeyUp == Event.current.type && Event.current.keyCode == KeyCode.Space)
        {
            enableOnScreenPlacement = true;
        }
    }
Beispiel #11
0
    void OnSceneGUI()
    {
        TrackNodeTool trackNodeToolScript = (TrackNodeTool)target;
        TrackNode     trackNode           = GetTrackNode();

        EditorUtility.SetDirty(trackNodeToolScript);
        EditorUtility.SetDirty(trackNodeToolScript.trackNode);

        if (enableOnScreenPlacement && useSpaceBarToSet && EventType.KeyDown == Event.current.type && Event.current.keyCode == KeyCode.Space)
        {
            enableOnScreenPlacement = false;
            if (trackNode != null)
            {
                Vector3 pos = trackNodeToolScript.GetComponent <Transform>().position;

                GetTrackNode().AddNode(pos);
                CycleNodeIndex = GetTrackNode().GetNodeCount() - 1;
            }
        }
        else if (EventType.KeyUp == Event.current.type && Event.current.keyCode == KeyCode.Space)
        {
            enableOnScreenPlacement = true;
        }
    }
Beispiel #12
0
    public override void OnInspectorGUI()
    {
        TrackNodeTool trackNodeToolScript = (TrackNodeTool)target;

        DrawDefaultInspector();

        trackNodeToolScript.FindTrackFiles();

        if (GUILayout.Toggle(doDrawTrajectory, "Draw track curve"))
        {
            if (subscribeCount == 0)
            {
                SceneView.onSceneGUIDelegate += DebugDraw;
                subscribeCount++;
            }

            doDrawTrajectory = true;
        }
        else
        {
            while (subscribeCount > 0)
            {
                SceneView.onSceneGUIDelegate -= DebugDraw;
                subscribeCount--;
            }

            doDrawTrajectory = false;
        }

        useSpaceBarToSet = GUILayout.Toggle(useSpaceBarToSet, "Use Space Bar To Add");

        trackNodeToolScript.trackNode.isLoopOpen = GUILayout.Toggle(trackNodeToolScript.trackNode.isLoopOpen, "Is Loop Open");



        {
            GUILayout.BeginHorizontal();
            if (GUILayout.Button("Cycle up selected node"))
            {
                CycleNode(1);
            }

            if (GUILayout.Button("Cycle down selected node"))
            {
                CycleNode(-1);
            }
            GUILayout.EndHorizontal();

            if (GUILayout.Button("Select nearest node"))
            {
                int nearestIndex = FindNearestNode();

                cycleNodeIndex = nearestIndex;
            }

            if (GUILayout.Button("Set handle at selected node"))
            {
                SetHandleAtIndex(cycleNodeIndex);
            }
        }

        GUILayout.BeginVertical();
        if (GUILayout.Button("Add Node"))
        {
            TrackNode trackNode = GetTrackNode();
            if (trackNode != null)
            {
                Vector3 pos = CalculatePositionAboveTheTrack(trackNodeToolScript.GetComponent <Transform> ().position);
                GetTrackNode().AddNode(pos);
                cycleNodeIndex = GetTrackNode().GetNodeCount() - 1;
            }
        }

        if (GUILayout.Button("Set selected node"))
        {
            Vector3   pos       = CalculatePositionAboveTheTrack(trackNodeToolScript.GetComponent <Transform> ().position);
            TrackNode trackNode = GetTrackNode();

            if (trackNode != null)
            {
                trackNode.SetNode(pos, cycleNodeIndex);
            }
        }

        if (GUILayout.Button("Insert Node"))
        {
            float distance    = float.MaxValue;
            int   nearestNode = 0;

            Transform trackNodeToolTransform = trackNodeToolScript.GetComponent <Transform>();
            TrackNode trackNode = GetTrackNode();

            for (int index = 0; index < trackNode.GetNodeCount(); index++)
            {
                if (distance > Vector3.SqrMagnitude(trackNodeToolTransform.position - trackNode.GetNode(index)))
                {
                    distance    = Vector3.SqrMagnitude(trackNodeToolTransform.position - trackNode.GetNode(index));
                    nearestNode = index;
                }
            }

            cycleNodeIndex = nearestNode;

            Vector3 directionForward = trackNode.GetNode(cycleNodeIndex + 1) - trackNode.GetNode(cycleNodeIndex);

            Vector3 directionBackward = trackNode.GetNode(cycleNodeIndex - 1) - trackNode.GetNode(cycleNodeIndex);



            Vector3 pos = CalculatePositionAboveTheTrack(trackNodeToolTransform.position);

            if (Vector3.Dot(directionForward, trackNodeToolTransform.position - trackNode.GetNode(cycleNodeIndex)) > Vector3.Dot(directionBackward, trackNodeToolTransform.position - trackNode.GetNode(cycleNodeIndex)))
            {
                trackNode.InsertNode(pos, cycleNodeIndex + 1);
            }
            else
            {
                trackNode.InsertNode(pos, cycleNodeIndex);
            }
        }

        if (GUILayout.Button("Remove Node"))
        {
            TrackNode trackNode = GetTrackNode();
            trackNode.DeleteNode(cycleNodeIndex);

            if (cycleNodeIndex >= trackNode.GetNodeCount())
            {
                cycleNodeIndex = trackNode.GetNodeCount() - 1;
            }
            else if (cycleNodeIndex < 0)
            {
                cycleNodeIndex = 0;
            }
        }
        GUILayout.EndVertical();

        GUILayout.BeginHorizontal();
        if (GUILayout.Button("Save track node to file"))
        {
            trackNodeToolScript.trackNode.Save(trackNodeToolScript.GetFileName());
        }
        if (GUILayout.Button("Load track node from file"))
        {
            trackNodeToolScript.trackNode.LoadFile(trackNodeToolScript.GetFileName());
        }
        GUILayout.EndHorizontal();

        if (doDrawTrajectory)
        {
            GUILayout.TextField("Debug Draw color legend\n\tMain Track : RED and CYAN\n\tSelected node : GREEN\n\tFirst Node : YELLOW\n\tLast Node : BLUE");
        }

        if (useSpaceBarToSet)
        {
            GUILayout.TextField("Use Space Bar To Add\n\tDrag the tool around the scene and press spacebar to add a new node.\n\tTip : Place the scene in isometric view with a top view.");
        }

        SceneView.RepaintAll();
    }
Beispiel #13
0
    void SetHandle()
    {
        TrackNodeTool trackNodeScript = (TrackNodeTool)target;

        trackNodeScript.GetComponent <Transform> ().position = trackNodeScript.trackNode.GetNode(cycleNodeIndex);
    }
Beispiel #14
0
    public override void OnInspectorGUI()
    {
        TrackNodeTool trackNodeToolScript = (TrackNodeTool)target;

        EditorUtility.SetDirty(trackNodeToolScript.trackNode);
        EditorUtility.SetDirty(trackNodeToolScript.trackNodeToolSettings);

        DrawDefaultInspector();

        trackNodeToolScript.FindTrackFiles();
        doDrawTrajectory = trackNodeToolScript.trackNodeToolSettings.doDrawTrajectory;
        doDrawTrajectory = GUILayout.Toggle(doDrawTrajectory, "Draw track curve");
        useSpaceBarToSet = GUILayout.Toggle(useSpaceBarToSet, "Use Space Bar To Add");


        trackNodeToolScript.trackNode.isLoopOpen = GUILayout.Toggle(trackNodeToolScript.trackNode.isLoopOpen, "Is Loop Open");


        GUILayout.BeginHorizontal();
        if (GUILayout.Button("Cycle up selected node"))
        {
            CycleNode(1);
        }

        if (GUILayout.Button("Cycle down selected node"))
        {
            CycleNode(-1);
        }
        GUILayout.EndHorizontal();

        if (GUILayout.Button("Select nearest node"))
        {
            int nearestIndex = FindNearestNode();

            CycleNodeIndex = nearestIndex;
        }

        if (GUILayout.Button("Set handle at selected node"))
        {
            SetHandleAtIndex(CycleNodeIndex);
        }


        GUILayout.BeginVertical();
        if (GUILayout.Button("Add Node"))
        {
            TrackNode trackNode = GetTrackNode();
            if (trackNode != null)
            {
                Vector3 pos = trackNodeToolScript.GetComponent <Transform>().position;
                GetTrackNode().AddNode(pos);
                CycleNodeIndex = GetTrackNode().GetNodeCount() - 1;
            }
        }

        if (GUILayout.Button("Set selected node"))
        {
            Vector3   pos       = trackNodeToolScript.GetComponent <Transform>().position;
            TrackNode trackNode = GetTrackNode();

            if (trackNode != null)
            {
                trackNode.SetNode(pos, CycleNodeIndex);
            }
        }

        if (GUILayout.Button("Insert Node"))
        {
            float distance    = float.MaxValue;
            int   nearestNode = 0;

            Transform trackNodeToolTransform = trackNodeToolScript.GetComponent <Transform>();
            TrackNode trackNode = GetTrackNode();

            for (int index = 0; index < trackNode.GetNodeCount(); index++)
            {
                if (distance > Vector3.SqrMagnitude(trackNodeToolTransform.position - trackNode.GetNode(index)))
                {
                    distance    = Vector3.SqrMagnitude(trackNodeToolTransform.position - trackNode.GetNode(index));
                    nearestNode = index;
                }
            }

            CycleNodeIndex = nearestNode;

            Vector3 directionForward = trackNode.GetNode(CycleNodeIndex + 1) - trackNode.GetNode(CycleNodeIndex);

            Vector3 directionBackward = trackNode.GetNode(CycleNodeIndex - 1) - trackNode.GetNode(CycleNodeIndex);



            Vector3 pos = trackNodeToolTransform.position;

            if (Vector3.Dot(directionForward, trackNodeToolTransform.position - trackNode.GetNode(CycleNodeIndex)) > Vector3.Dot(directionBackward, trackNodeToolTransform.position - trackNode.GetNode(CycleNodeIndex)))
            {
                CycleNodeIndex = CycleNodeIndex + 1;
            }
            trackNode.InsertNode(pos, CycleNodeIndex);
        }

        if (GUILayout.Button("Remove Node"))
        {
            TrackNode trackNode = GetTrackNode();
            trackNode.DeleteNode(CycleNodeIndex);

            if (CycleNodeIndex >= trackNode.GetNodeCount())
            {
                CycleNodeIndex = trackNode.GetNodeCount() - 1;
            }
            else if (CycleNodeIndex < 0)
            {
                CycleNodeIndex = 0;
            }
        }
        GUILayout.EndVertical();

        GUILayout.BeginHorizontal();
        if (GUILayout.Button("Save track node to file"))
        {
            trackNodeToolScript.trackNode.Save(trackNodeToolScript.GetFileName(), trackNodeToolScript.saveLoad.dataPath);
        }
        if (GUILayout.Button("Load track node from file"))
        {
            trackNodeToolScript.trackNode.Load(trackNodeToolScript.GetFileName(), trackNodeToolScript.saveLoad.dataPath);
        }
        GUILayout.EndHorizontal();

        if (trackNodeToolScript.sourceBesierSpline == null)
        {
            GUILayout.TextField("Drag a reference to a bezier spline to import track from bezier.");
        }
        else
        {
            if (GUILayout.Button("Import Track from bezier"))
            {
                TrackNode trackNode = GetTrackNode();
                trackNodeToolScript.PopulateTrackNodeWithBesier(trackNodeToolScript.PointsFromBezier);
                for (int i = 0; i < trackNodeToolScript.PointsFromBezier; i++)
                {
                    trackNode.SetNode(trackNode.GetNode(i), i);
                }
            }
        }

        GUILayout.BeginHorizontal();
        GUILayout.TextField("Selected Node number");
        CycleNodeIndex = EditorGUILayout.IntField(CycleNodeIndex);
        GUILayout.EndHorizontal();

        if (doDrawTrajectory)
        {
            GUILayout.TextField("Debug Draw color legend\n\tMain Track : RED, CYAN and WHITE (if track node is a closed loop) \n\tSelected node : GREEN\n\tFirst Node : YELLOW\n\tLast Node : BLUE");
        }

        if (useSpaceBarToSet)
        {
            GUILayout.TextField("Use Space Bar To Add\n\tDrag the tool around the scene and press spacebar to add a new node.\n\tTip : Place the scene in isometric view with a top view.");
        }

        trackNodeToolScript.trackNodeToolSettings.doDrawTrajectory = doDrawTrajectory;
        trackNodeToolScript.trackNodeToolSettings.cycleNodeIndex   = cycleNodeIndex;

        SceneView.RepaintAll();
    }
Beispiel #15
0
    private void OnEnable()
    {
        TrackNodeTool trackNodeToolScript = (TrackNodeTool)target;

        EditorUtility.SetDirty(trackNodeToolScript.trackNodeToolSettings);
    }