Beispiel #1
0
 protected override void OnUpdate()
 {
     if (endPointPos != endPoint.position || endPointDir != endPoint.forward)
     {
         //Debug.Log(">>>> Update Endpoint and Spline");
         endPointPos = endPoint.position;
         endPointDir = endPoint.forward;
         SplineNode endNode = spline.nodes[spline.nodes.Count - 1];
         endNode.SetPosition(transform.InverseTransformPoint(endPointPos), true);
         endNode.SetDirection(transform.InverseTransformDirection(endPointDir) * endPointDirLength + endNode.position);
     }
 }
    protected override void OnUpdate()
    {
        for (int i = 0; i < 2; i++)
        {
            SplineNode   node  = spline.nodes[i == 0 ? 0 : spline.nodes.Count - 1];
            RefpointInfo rInfo = refPointInfos[i];

            if (rInfo.trans.position != rInfo.lastPos || rInfo.trans.forward != rInfo.lastDir)
            {
                rInfo.lastPos = rInfo.trans.position;
                rInfo.lastDir = rInfo.trans.forward;

                Vector3 dir = transform.InverseTransformDirection(rInfo.trans.right);
                node.SetDirection(dir * rInfo.nodeDirLen + node.position, true);
                node.SetPosition(rInfo.trans.localPosition);
            }
        }
    }
Beispiel #3
0
    void OnSceneGUI()
    {
        Event e = Event.current;

        if (e.type == EventType.mouseDown)
        {
            Undo.RegisterCompleteObjectUndo(spline, "change spline topography");
            // if alt key pressed, we will have to create a new node if node position is changed
            if (e.alt)
            {
                mustCreateNewNode = true;
            }
        }
        if (e.type == EventType.mouseUp)
        {
            mustCreateNewNode = false;
        }

        // disable game object transform gyzmo
        if (Selection.activeGameObject == spline.gameObject)
        {
            Tools.current = Tool.None;
            if (selection == null && spline.nodes.Count > 0)
            {
                selection = spline.nodes[0];
            }
        }

        // draw a bezier curve for each curve in the spline
        foreach (CubicBezierCurve curve in spline.GetCurves())
        {
            Handles.DrawBezier(spline.transform.TransformPoint(curve.n1.position),
                               spline.transform.TransformPoint(curve.n2.position),
                               spline.transform.TransformPoint(curve.n1.direction),
                               spline.transform.TransformPoint(curve.GetInverseDirection()),
                               CURVE_COLOR,
                               null,
                               3);
        }

        // draw the selection handles
        switch (selectionType)
        {
        case SelectionType.Node:
            // place a handle on the node and manage position change
            Vector3 newPosition = spline.transform.InverseTransformPoint(Handles.PositionHandle(spline.transform.TransformPoint(selection.position), Quaternion.identity));
            if (newPosition != selection.position)
            {
                // position handle has been moved
                if (mustCreateNewNode)
                {
                    mustCreateNewNode = false;
                    selection         = AddClonedNode(selection);
                    selection.SetDirection(selection.direction + newPosition - selection.position);
                    selection.SetPosition(newPosition);
                }
                else
                {
                    selection.SetDirection(selection.direction + newPosition - selection.position);
                    selection.SetPosition(newPosition);
                }
            }
            break;

        case SelectionType.Direction:
            selection.SetDirection(spline.transform.InverseTransformPoint(Handles.PositionHandle(spline.transform.TransformPoint(selection.direction), Quaternion.identity)));
            break;

        case SelectionType.InverseDirection:
            selection.SetDirection(2 * selection.position - spline.transform.InverseTransformPoint(Handles.PositionHandle(2 * spline.transform.TransformPoint(selection.position) - spline.transform.TransformPoint(selection.direction), Quaternion.identity)));
            break;
        }

        // draw the handles of all nodes, and manage selection motion
        Handles.BeginGUI();
        foreach (SplineNode n in spline.nodes)
        {
            Vector3 guiPos = HandleUtility.WorldToGUIPoint(spline.transform.TransformPoint(n.position));
            if (n == selection)
            {
                Vector3 guiDir    = HandleUtility.WorldToGUIPoint(spline.transform.TransformPoint(n.direction));
                Vector3 guiInvDir = HandleUtility.WorldToGUIPoint(spline.transform.TransformPoint(2 * n.position - n.direction));

                // for the selected node, we also draw a line and place two buttons for directions
                Handles.color = Color.red;
                Handles.DrawLine(guiDir, guiInvDir);

                // draw quads direction and inverse direction if they are not selected
                if (selectionType != SelectionType.Node)
                {
                    if (Button(guiPos, directionButtonStyle))
                    {
                        selectionType = SelectionType.Node;
                    }
                }
                if (selectionType != SelectionType.Direction)
                {
                    if (Button(guiDir, directionButtonStyle))
                    {
                        selectionType = SelectionType.Direction;
                    }
                }
                if (selectionType != SelectionType.InverseDirection)
                {
                    if (Button(guiInvDir, directionButtonStyle))
                    {
                        selectionType = SelectionType.InverseDirection;
                    }
                }
            }
            else
            {
                if (Button(guiPos, nodeButtonStyle))
                {
                    selection     = n;
                    selectionType = SelectionType.Node;
                }
            }
        }
        Handles.EndGUI();

        if (GUI.changed)
        {
            EditorUtility.SetDirty(target);
        }
    }
Beispiel #4
0
    public Sequence Play(int index, float speed, Action onComplete)
    {
        if (index < 0 || index >= Keyframes.Count)
        {
            return(null);
        }

        tweenSeq = DOTween.Sequence();

        if (index == 0)
        {
            SetKeyframe(0);
            return(tweenSeq);
        }

        SetKeyframe(index - 1);

        List <SplineNode> targetNodes = Keyframes[index].nodes;

        if (targetNodes.Count > spline.nodes.Count)
        {
            Debug.LogWarningFormat("Spline nodes' count is less than keyframe_{0} nodes' count, so extra nodes will be created.", index);
            SplineNode lastNode = spline.nodes[spline.nodes.Count - 1];
            for (int i = spline.nodes.Count; i < targetNodes.Count; i++)
            {
                spline.AddNode(new SplineNode(lastNode.position, lastNode.direction));
            }
        }
        else if (targetNodes.Count < spline.nodes.Count)
        {
            Debug.LogWarningFormat("Spline nodes' count is more than keyframe_{0} nodes' count, so extra nodes will be deleted.", index);
            for (int i = targetNodes.Count; i < spline.nodes.Count; i++)
            {
                spline.RemoveNode(spline.nodes[i]);
            }
        }

        for (int i = 0; i < targetNodes.Count; i++)
        {
            SplineNode node       = spline.nodes[i];
            SplineNode targetNode = targetNodes[i];

            Tweener posTweener = DOTween.To(() => node.position, x => node.SetPosition(x), targetNode.position, speed);
            if (i == 0)
            {
                tweenSeq.Append(posTweener);
            }
            else
            {
                tweenSeq.Join(posTweener);
            }

            Tweener dirTweener = DOTween.To(() => node.direction, x => node.SetDirection(x), targetNode.direction, speed);
            tweenSeq.Join(dirTweener);
        }

        tweenSeq.OnComplete(() =>
        {
            tweenSeq = null;
            if (onComplete != null)
            {
                onComplete();
            }
        });

        CurIndex = index;
        return(tweenSeq);
    }