Beispiel #1
0
    void Update()
    {
        if (copyfrom)
        {
            copyfrom = false;
            moveFrom = transform.position;
        }
        if (copyTo)
        {
            copyTo = false;
            moveTo = transform.position;
        }


        Vector3 truefrom = moveFrom;
        Vector3 trueto   = moveTo;
        Vector3 delta    = moveTo - moveFrom;


        ff = Easing.GetByName(easingType.ToString(), f);
        float truef = ff;

        if (ff > 1)
        {
            truefrom = moveTo;;
            trueto   = moveTo + delta;
            truef   -= 1;
        }
        if (ff < 0)
        {
            trueto   = truefrom;
            truefrom = truefrom - delta;
            truef   += 1;
        }
        if (go)
        {
            transform.position = Vector3.Lerp(truefrom, trueto, truef);
            if (f < 1)
            {
                f += +0.001f * (++progress);
            }
            else
            {
                go = false;

                progress = 0;
                f        = 0;
                if (onComplete != null)
                {
                    onComplete();
                    onComplete = null;
                }
            }
        }
        else
        {
        }
    }
Beispiel #2
0
        /// <summary>
        /// Gets the EasingFunction from EasingType to be used with Storyboard animations
        /// </summary>
        /// <param name="easingType">The EasingType used to determine the EasingFunction</param>
        /// <returns>Return the appropriate EasingFuntion or null if the EasingType is Linear</returns>
        public static EasingFunctionBase GetEasingFunction(EasingType easingType)
        {
            if (easingType == EasingType.Default)
            {
                easingType = DefaultEasingType;
            }

            switch (easingType)
            {
            case EasingType.Linear:
                return(null);

            case EasingType.Cubic:
                return(new CubicEase());

            case EasingType.Back:
                return(new BackEase());

            case EasingType.Bounce:
                return(new BounceEase());

            case EasingType.Elastic:
                return(new ElasticEase());

            case EasingType.Circle:
                return(new CircleEase());

            case EasingType.Quadratic:
                return(new QuadraticEase());

            case EasingType.Quartic:
                return(new QuarticEase());

            case EasingType.Quintic:
                return(new QuinticEase());

            case EasingType.Sine:
                return(new SineEase());

            default:
                throw new NotSupportedException($"{easingType.ToString()} EasingType is not currently supported");
            }
        }
Beispiel #3
0
        private static CompositionEasingFunction GenerateCompositionEasingFunctionFromEasingType(EasingType easingType, Compositor compositor)
        {
            if (easingType == EasingType.Default)
            {
                easingType = DefaultEasingType;
            }

            switch (easingType)
            {
            case EasingType.Linear:
                return(compositor.CreateLinearEasingFunction());

            case EasingType.Cubic:
                return(compositor.CreateCubicBezierEasingFunction(new Vector2(0.215f, 0.61f), new Vector2(0.355f, 1f)));

            case EasingType.Back:
                return(compositor.CreateCubicBezierEasingFunction(new Vector2(0.175f, 0.885f), new Vector2(0.32f, 1.275f)));

            case EasingType.Bounce:
                return(compositor.CreateCubicBezierEasingFunction(new Vector2(0.58f, 1.93f), new Vector2(.08f, .36f)));

            case EasingType.Elastic:
                return(compositor.CreateCubicBezierEasingFunction(new Vector2(0.37f, 2.68f), new Vector2(0f, 0.22f)));

            case EasingType.Circle:
                return(compositor.CreateCubicBezierEasingFunction(new Vector2(0.075f, 0.82f), new Vector2(0.165f, 1f)));

            case EasingType.Quadratic:
                return(compositor.CreateCubicBezierEasingFunction(new Vector2(0.25f, 0.46f), new Vector2(0.45f, 0.94f)));

            case EasingType.Quartic:
                return(compositor.CreateCubicBezierEasingFunction(new Vector2(0.165f, 0.84f), new Vector2(0.44f, 1f)));

            case EasingType.Quintic:
                return(compositor.CreateCubicBezierEasingFunction(new Vector2(0.23f, 1f), new Vector2(0.32f, 1f)));

            case EasingType.Sine:
                return(compositor.CreateCubicBezierEasingFunction(new Vector2(0.39f, 0.575f), new Vector2(0.565f, 1f)));

            default:
                throw new NotSupportedException($"{easingType.ToString()} EasingType is not currently supported");
            }
        }
        internal static CompositionEasingFunction CreateEasingFunction(this Compositor compositor, EasingType easingType, EasingMode mode)
        {
            var key = $"{easingType.ToString()}.{mode.ToString()}";

            if (_easings.TryGetValue(key, out var easingFunc))
            {
                return(easingFunc);
            }

            CompositionEasingFunction newEasing;

            switch (easingType)
            {
            case EasingType.Back when mode == EasingMode.EaseIn:
                newEasing = compositor.CreateCubicBezierEasingFunction(new Vector2(0.6f, -0.28f), new Vector2(0.735f, 0.045f));
                break;

            case EasingType.Back when mode == EasingMode.EaseOut:
                newEasing = compositor.CreateCubicBezierEasingFunction(new Vector2(0.175f, 0.885f), new Vector2(0.32f, 1.275f));
                break;

            case EasingType.Back when mode == EasingMode.EaseInOut:
                newEasing = compositor.CreateCubicBezierEasingFunction(new Vector2(0.68f, -0.55f), new Vector2(0.265f, 1.55f));
                break;

            case EasingType.Bounce when mode == EasingMode.EaseIn:
                newEasing = compositor.CreateCubicBezierEasingFunction(new Vector2(0.93f, 0.7f), new Vector2(0.4f, -0.93f));
                break;

            case EasingType.Bounce when mode == EasingMode.EaseOut:
                newEasing = compositor.CreateCubicBezierEasingFunction(new Vector2(0.58f, 1.93f), new Vector2(0.08f, 0.36f));
                break;

            case EasingType.Bounce when mode == EasingMode.EaseInOut:
                newEasing = compositor.CreateCubicBezierEasingFunction(new Vector2(0.65f, -0.85f), new Vector2(0.35f, 1.85f));
                break;

            case EasingType.Circle when mode == EasingMode.EaseIn:
                newEasing = compositor.CreateCubicBezierEasingFunction(new Vector2(0.6f, 0.04f), new Vector2(0.98f, 0.335f));
                break;

            case EasingType.Circle when mode == EasingMode.EaseOut:
                newEasing = compositor.CreateCubicBezierEasingFunction(new Vector2(0.075f, 0.82f), new Vector2(0.165f, 1f));
                break;

            case EasingType.Circle when mode == EasingMode.EaseInOut:
                newEasing = compositor.CreateCubicBezierEasingFunction(new Vector2(0.785f, 0.135f), new Vector2(0.15f, 0.86f));
                break;

            case EasingType.Cubic when mode == EasingMode.EaseIn:
                newEasing = compositor.CreateCubicBezierEasingFunction(new Vector2(0.55f, 0.055f), new Vector2(0.675f, 0.19f));
                break;

            case EasingType.Cubic when mode == EasingMode.EaseOut:
                newEasing = compositor.CreateCubicBezierEasingFunction(new Vector2(0.215f, 0.61f), new Vector2(0.355f, 1f));
                break;

            case EasingType.Cubic when mode == EasingMode.EaseInOut:
                newEasing = compositor.CreateCubicBezierEasingFunction(new Vector2(0.645f, 0.045f), new Vector2(0.355f, 1f));
                break;

            case EasingType.Elastic when mode == EasingMode.EaseIn:
                newEasing = compositor.CreateCubicBezierEasingFunction(new Vector2(1, 0.78f), new Vector2(.63f, -1.68f));
                break;

            case EasingType.Elastic when mode == EasingMode.EaseOut:
                newEasing = compositor.CreateCubicBezierEasingFunction(new Vector2(0.37f, 2.68f), new Vector2(0f, 0.22f));
                break;

            case EasingType.Elastic when mode == EasingMode.EaseInOut:
                newEasing = compositor.CreateCubicBezierEasingFunction(new Vector2(0.9f, -1.2f), new Vector2(0.1f, 2.2f));
                break;

            case EasingType.Quadratic when mode == EasingMode.EaseIn:
                newEasing = compositor.CreateCubicBezierEasingFunction(new Vector2(0.55f, 0.085f), new Vector2(0.68f, 0.53f));
                break;

            case EasingType.Quadratic when mode == EasingMode.EaseOut:
                newEasing = compositor.CreateCubicBezierEasingFunction(new Vector2(0.25f, 0.46f), new Vector2(0.45f, 0.94f));
                break;

            case EasingType.Quadratic when mode == EasingMode.EaseInOut:
                newEasing = compositor.CreateCubicBezierEasingFunction(new Vector2(0.445f, 0.03f), new Vector2(0.515f, 0.955f));
                break;

            case EasingType.Quartic when mode == EasingMode.EaseIn:
                newEasing = compositor.CreateCubicBezierEasingFunction(new Vector2(0.895f, 0.03f), new Vector2(0.685f, 0.22f));
                break;

            case EasingType.Quartic when mode == EasingMode.EaseOut:
                newEasing = compositor.CreateCubicBezierEasingFunction(new Vector2(0.165f, 0.84f), new Vector2(0.44f, 1f));
                break;

            case EasingType.Quartic when mode == EasingMode.EaseInOut:
                newEasing = compositor.CreateCubicBezierEasingFunction(new Vector2(0.77f, 0f), new Vector2(0.175f, 1f));
                break;

            case EasingType.Quintic when mode == EasingMode.EaseIn:
                newEasing = compositor.CreateCubicBezierEasingFunction(new Vector2(0.755f, 0.05f), new Vector2(0.855f, 0.06f));
                break;

            case EasingType.Quintic when mode == EasingMode.EaseOut:
                newEasing = compositor.CreateCubicBezierEasingFunction(new Vector2(0.23f, 1f), new Vector2(0.32f, 1f));
                break;

            case EasingType.Quintic when mode == EasingMode.EaseInOut:
                newEasing = compositor.CreateCubicBezierEasingFunction(new Vector2(0.86f, 0f), new Vector2(0.07f, 1f));
                break;

            case EasingType.Sine when mode == EasingMode.EaseIn:
                newEasing = compositor.CreateCubicBezierEasingFunction(new Vector2(0.47f, 0f), new Vector2(0.745f, 0.715f));
                break;

            case EasingType.Sine when mode == EasingMode.EaseOut:
                newEasing = compositor.CreateCubicBezierEasingFunction(new Vector2(0.39f, 0.575f), new Vector2(0.565f, 1f));
                break;

            case EasingType.Sine when mode == EasingMode.EaseInOut:
                newEasing = compositor.CreateCubicBezierEasingFunction(new Vector2(0.445f, 0.05f), new Vector2(0.55f, 0.95f));
                break;

            default:
                newEasing = compositor.CreateLinearEasingFunction();
                break;
            }

            _easings.Add(key, newEasing);

            return(newEasing);
        }
Beispiel #5
0
        public static Texture2D GenerateCanvasItemBackground(int width, int height, UiAnimationClipSegmentType type, EasingType processorType, bool transparent = false)
        {
            string id = width + ":" + height + ":" + type.ToString() + ":" + processorType.ToString() + ":" + (transparent ? "transparent" : "normal");

            if (ItemsBackgroundsCache.ContainsKey(id))
            {
                return(ItemsBackgroundsCache[id]);
            }

            Color colorA = Color.black;
            Color colorB = Color.black;
            Color colorC = Color.black;

            switch (type)
            {
            case UiAnimationClipSegmentType.Alpha:
                colorA = new Color(84f / 255f, 152f / 255f, 199f / 255f, 1f);
                colorB = new Color(118f / 255f, 174f / 255f, 211f / 255f, 1f);
                colorC = new Color(67f / 255f, 123f / 255f, 160f / 255f, 1f);
                break;

            case UiAnimationClipSegmentType.Color:
                colorA = new Color(36f / 255f, 174f / 255f, 96f / 255f, 1f);
                colorB = new Color(80f / 255f, 190f / 255f, 129f / 255f, 1f);
                colorC = new Color(29f / 255f, 139f / 255f, 78f / 255f, 1f);
                break;

            case UiAnimationClipSegmentType.Position:
                colorA = new Color(192f / 255f, 56f / 255f, 44f / 255f, 1f);
                colorB = new Color(207f / 255f, 96f / 255f, 77f / 255f, 1f);
                colorC = new Color(153f / 255f, 45f / 255f, 35f / 255f, 1f);
                break;

            case UiAnimationClipSegmentType.Rotation:
                colorA = new Color(210f / 255f, 84f / 255f, 0f / 255f, 1f);
                colorB = new Color(210f / 255f, 119f / 255f, 51f / 255f, 1f);
                colorC = new Color(169f / 255f, 67f / 255f, 1f / 255f, 1f);
                break;

            case UiAnimationClipSegmentType.Scale:
                colorA = new Color(243f / 255f, 156f / 255f, 14f / 255f, 1f);
                colorB = new Color(247f / 255f, 192f / 255f, 101f / 255f, 1f);
                colorC = new Color(196f / 255f, 141f / 255f, 50f / 255f, 1f);
                break;
            }

            Texture2D texture = new Texture2D(width, height);

            if (transparent)
            {
                colorA.a = 0.4f;
                colorB.a = 0.4f;
                colorC.a = 0.4f;
            }

            // Background
            for (int x = 1; x < width - 1; x++)
            {
                for (int y = 1; y < height - 1; y++)
                {
                    //colorA.a = isLine ? 0.2f : 1;

                    texture.SetPixel(x, y, colorA);
                }
            }

            // Border top
            for (int x = 0; x < width; x++)
            {
                texture.SetPixel(x, height - 1, colorB);
            }


            // Border left
            for (int y = 0; y < height; y++)
            {
                texture.SetPixel(0, y, colorB);
            }

            // Border bottom
            for (int x = 0; x < width; x++)
            {
                texture.SetPixel(x, 0, colorC);
            }

            // Border right
            for (int y = 0; y < height; y++)
            {
                texture.SetPixel(width - 1, y, colorC);
            }

            // Curve
            for (int i = 0; i < width; i++)
            {
                float value = Easing.Interpolate((float)i / (float)width, processorType) * (float)(height - 2) / 2;

                if (transparent)
                {
                    value = 0;
                }

                int x = i;
                int y = (int)(height / 4 + value);

                texture.SetPixel(i, y + 1, colorB);
                texture.SetPixel(i, y, colorC);
            }

            texture.Apply();

            ItemsBackgroundsCache.Add(id, texture);

            return(texture);
        }
Beispiel #6
0
 public static Easing MakeEasing(EasingType easingType)
 {
     var type = System.Type.GetType("TweenySupport." + easingType.ToString());
     return (Easing)System.Activator.CreateInstance(type);
 }