private void UpdateCurveInformation(string nameOfClip, CurveInformation curveInformationToUpdate, AnimationClipCurveData animationCruveData)
    {
        List <string> curveInformationNames = animationCruveData.path.Split(new string[] { "/" }, StringSplitOptions.RemoveEmptyEntries).ToList();

        curveInformationNames.Insert(0, nameOfClip);
        curveInformationNames.Add(animationCruveData.type.ToString());
        curveInformationNames.Add(animationCruveData.propertyName);

        curveInformationToUpdate.AddIfNonExistant(curveInformationNames, animationCruveData);
    }
Exemplo n.º 2
0
 private void Start()
 {
     t = transform;
     lastAssignedCurve = Instantiate(pathSegments[Random.Range(0, pathSegments.Count)]);
     currentCurve      = 0;
     lastAssignedCurve.transform.SetParent(t);
     curves.Add(lastAssignedCurve);
     for (int i = 0; i < pathLength; i++)
     {
         AppendPath();
     }
 }
Exemplo n.º 3
0
    private void AppendPath()
    {
        float currentAngle   = 0;
        float currentAngle20 = 0;

        //Only check the 10 last roads to make sure we aren't making a boo boo
        for (int i = curves.Count - 1; i >= 0; i--)
        {
            currentAngle += curves[i].angle;
            if (curves.Count - i == 20)
            {
                currentAngle20 = currentAngle;
            }
        }

        CurveInformation curveInfoToSpawn = null;

        while (curveInfoToSpawn == null)
        {
            curveInfoToSpawn = pathSegments[Random.Range(0, pathSegments.Count)];
            // ReSharper disable once CompareOfFloatsByEqualityOperator
            if (Mathf.Abs(curveInfoToSpawn.angle) > 15 && curveInfoToSpawn.angle == lastAssignedCurve.angle)
            {
                curveInfoToSpawn = null;
            }
            else
            {
                float newAngle = currentAngle + curveInfoToSpawn.angle;
                if (newAngle < -90 || newAngle > 90)
                {
                    curveInfoToSpawn = null;
                }
                else
                {
                    float newAngle20 = currentAngle20 + curveInfoToSpawn.angle;
                    if (newAngle20 < -60 || newAngle20 > 60)
                    {
                        curveInfoToSpawn = null;
                    }
                }
            }
        }

        CurveInformation newCurve = Instantiate(curveInfoToSpawn);

        curves.Add(newCurve);
        newCurve.t.position = lastAssignedCurve.curve.KeyPoints[lastAssignedCurve.curve.KeyPointsCount - 1].Position;
        newCurve.t.rotation = lastAssignedCurve.t.rotation * Quaternion.LookRotation(lastAssignedCurve.curve.KeyPoints[lastAssignedCurve.curve.KeyPointsCount - 1].LeftHandleLocalPosition.normalized, Vector3.up);
        lastAssignedCurve   = newCurve;
        lastAssignedCurve.t.SetParent(t);
    }
        public CurveInformation AddIfNonExistant(List <string> path, AnimationClipCurveData animationCLipCurveData)
        {
            if (Name.Equals(path[0]))
            {
                if (path.Count == 1)
                {
                    AnimationClipCurveData = animationCLipCurveData;
                    return(this);
                }
                var pathReduced = path;
                pathReduced.RemoveAt(0);
                foreach (CurveInformation curveInformation in Children)
                {
                    if (curveInformation.Name.Equals(pathReduced[0]))
                    {
                        CurveInformation childResult = curveInformation.AddIfNonExistant(pathReduced, animationCLipCurveData);
                        if (childResult != null)
                        {
                            return(childResult);
                        }
                    }
                }
            }
            CurveInformation newChild = new CurveInformation(path[0]);

            Children.Add(newChild);
            if (path.Count == 1)
            {
                newChild.AnimationClipCurveData = animationCLipCurveData;
                return(newChild);
            }
            else
            {
                var pathReduced = path;
                pathReduced.RemoveAt(0);
                return(newChild.AddIfNonExistant(pathReduced, animationCLipCurveData));
            }
        }
 private void Refresh()
 {
     curveInformation = new CurveInformation(selectedAnimationClip.name);
 }
    public void OnGUI()
    {
        EditorGUILayout.LabelField("");
        var animationClips = Resources.FindObjectsOfTypeAll <AnimationClip>().ToList();

        EditorGUILayout.BeginHorizontal();
        int selectedAnimationClipIndex = EditorGUILayout.Popup("Animation Clips", animationClips.IndexOf(selectedAnimationClip), animationClips.Select(x => x.name).ToArray());

        if (selectedAnimationClipIndex < 0)
        {
            selectedAnimationClipIndex = 0;
        }
        if (selectedAnimationClip != animationClips[selectedAnimationClipIndex] || curveInformation == null)
        {
            curveInformation = new CurveInformation(animationClips[selectedAnimationClipIndex].name);
        }
        selectedAnimationClip = animationClips[selectedAnimationClipIndex];

        if (GUILayout.Button("Copy", EditorStyles.miniButton))
        {
            animationCurveClipboard = curveInformation.GetSelectedAnimationCurves();
        }
        if (GUILayout.Button("Copy All", EditorStyles.miniButton))
        {
            animationCurveClipboard = AnimationUtility.GetAllCurves(selectedAnimationClip, true).ToList();
        }
        if (GUILayout.Button("Paste", EditorStyles.miniButton))
        {
            Paste();
        }
        if (GUILayout.Button("Remove", EditorStyles.miniButton))
        {
            var curvesToDelete = curveInformation.GetSelectedAnimationCurves();
            var allCurves      = curveInformation.GetSelectedAnimationCurves(new List <AnimationClipCurveData>(), true);
            selectedAnimationClip.ClearCurves();
            foreach (var curveInfo in allCurves)
            {
                if (curveInfo == null)
                {
                    continue;
                }
                if (!curvesToDelete.Contains(curveInfo))
                {
                    InsertCurve(curveInfo);
                }
            }
            Refresh();
        }
        if (GUILayout.Button("Refresh", EditorStyles.miniButton))
        {
            Refresh();
        }
        EditorGUILayout.EndHorizontal();
        foreach (AnimationClipCurveData curveData in AnimationUtility.GetAllCurves(selectedAnimationClip, true))
        {
            UpdateCurveInformation(selectedAnimationClip.name, curveInformation, curveData);
        }

        scrollViewVector = EditorGUILayout.BeginScrollView(scrollViewVector);
        curveInformation.DisplayCurveInformation();
        EditorGUILayout.EndScrollView();
    }
    private void Refresh()
    {

        curveInformation = new CurveInformation(selectedAnimationClip.name);
    }
    public void OnGUI()
    {
        EditorGUILayout.LabelField("");
        var animationClips = Resources.FindObjectsOfTypeAll<AnimationClip>().ToList();
        EditorGUILayout.BeginHorizontal();
        int selectedAnimationClipIndex = EditorGUILayout.Popup("Animation Clips", animationClips.IndexOf(selectedAnimationClip), animationClips.Select(x => x.name).ToArray());
        if (selectedAnimationClipIndex < 0)
        {
            selectedAnimationClipIndex = 0;
        }
        if (selectedAnimationClip != animationClips[selectedAnimationClipIndex] || curveInformation == null)
        {
            curveInformation = new CurveInformation(animationClips[selectedAnimationClipIndex].name);
        }
        selectedAnimationClip = animationClips[selectedAnimationClipIndex];

        if (GUILayout.Button("Copy", EditorStyles.miniButton))
        {
            animationCurveClipboard = curveInformation.GetSelectedAnimationCurves();
        }
        if (GUILayout.Button("Copy All", EditorStyles.miniButton))
        {
            animationCurveClipboard = AnimationUtility.GetAllCurves(selectedAnimationClip, true).ToList();
        }
        if (GUILayout.Button("Paste", EditorStyles.miniButton))
        {
            Paste();
        }
        if (GUILayout.Button("Remove", EditorStyles.miniButton))
        {
            var curvesToDelete = curveInformation.GetSelectedAnimationCurves();
            var allCurves = curveInformation.GetSelectedAnimationCurves(new List<AnimationClipCurveData>(), true);
            selectedAnimationClip.ClearCurves();
            foreach (var curveInfo in allCurves)
            {
                if (curveInfo == null)
                {
                    continue;
                }
                if (!curvesToDelete.Contains(curveInfo))
                {
                    InsertCurve(curveInfo);
                }
            }
            Refresh();

        }
        if (GUILayout.Button("Refresh", EditorStyles.miniButton))
        {
            Refresh();
        }
        EditorGUILayout.EndHorizontal();
        foreach (AnimationClipCurveData curveData in AnimationUtility.GetAllCurves(selectedAnimationClip, true))
        {
            UpdateCurveInformation(selectedAnimationClip.name, curveInformation, curveData);

        }

        scrollViewVector = EditorGUILayout.BeginScrollView(scrollViewVector);
        curveInformation.DisplayCurveInformation();
        EditorGUILayout.EndScrollView();
    }
        public CurveInformation AddIfNonExistant(List<string> path, AnimationClipCurveData animationCLipCurveData)
        {

            if (Name.Equals(path[0]))
            {
                if (path.Count == 1)
                {
                    AnimationClipCurveData = animationCLipCurveData;
                    return this;
                }
                var pathReduced = path;
                pathReduced.RemoveAt(0);
                foreach (CurveInformation curveInformation in Children)
                {
                    if (curveInformation.Name.Equals(pathReduced[0]))
                    {
                        CurveInformation childResult = curveInformation.AddIfNonExistant(pathReduced, animationCLipCurveData);
                        if (childResult != null)
                        {
                            return childResult;
                        }
                    }
                }
            }
            CurveInformation newChild = new CurveInformation(path[0]);
            Children.Add(newChild);
            if (path.Count == 1)
            {
                newChild.AnimationClipCurveData = animationCLipCurveData;
                return newChild;
            }
            else
            {
                var pathReduced = path;
                pathReduced.RemoveAt(0);
                return newChild.AddIfNonExistant(pathReduced, animationCLipCurveData);
            }
        }
    private void UpdateCurveInformation(string nameOfClip, CurveInformation curveInformationToUpdate, AnimationClipCurveData animationCruveData)
    {

        List<string> curveInformationNames = animationCruveData.path.Split(new string[] { "/" }, StringSplitOptions.RemoveEmptyEntries).ToList();

        curveInformationNames.Insert(0, nameOfClip);
        curveInformationNames.Add(animationCruveData.type.ToString());
        curveInformationNames.Add(animationCruveData.propertyName);

        curveInformationToUpdate.AddIfNonExistant(curveInformationNames, animationCruveData);
    }