Пример #1
0
        private static async UniTask Sample4()
        {
            using (var shapeObject = new DisposableGameObject(new Vector3(-3f, 0f, 0f)))
            {
                var shape = shapeObject.AddComponent <Rectangle>();
                shape.Type      = Rectangle.RectangleType.RoundedHollow;
                shape.Color     = new Color32(255, 242, 173, 255);
                shape.Thickness = 0.1f;

                var cube = shape;

                await Anime.Delay(0.3f);

                await UniTask.WhenAll(
                    Anime.PlayTo(
                        Moving.Linear(3f, 2f),
                        TranslateTo.LocalPositionX(cube)
                        ),
                    Anime.PlayTo(
                        Animator.Delay(1.8f, Easing.Create <Linear>(Vector3.zero, 0.2f)),
                        TranslateTo.LocalScale(cube)
                        )
                    );

                await Anime.Delay(0.3f);
            }
        }
Пример #2
0
        private async UniTask LineTestElement()
        {
            const byte colorA = 64;

            /*
             * var colors = new[]
             * {
             *  // 114
             *  new Color32(78, 191, 214, colorA),
             *  new Color32(0, 85, 149, colorA),
             *  new Color32(25, 36, 74, colorA),
             *  new Color32(87, 189, 168, colorA),
             *  new Color32(246, 249, 228, colorA),
             *  new Color32(0, 0, 0, colorA),
             *  new Color32(162, 67, 137, colorA),
             *  new Color32(229, 230, 71, colorA),
             * };
             */
            var colors = new[]
            {
                new Color32(255, 0, 0, colorA),
                new Color32(0, 255, 0, colorA),
                new Color32(0, 0, 255, colorA),
                new Color32(255, 255, 0, colorA),
                new Color32(255, 0, 255, colorA),
                new Color32(0, 255, 255, colorA),
            };

            var unitCircle = Random.insideUnitCircle.normalized * Random.Range(2f, 8f);

            using (var shapeObject = new DisposableGameObject(
                       new Vector3(unitCircle.x, unitCircle.y, 50f)
                       ))
            {
                var shape = shapeObject.AddComponent <Line>();
                shape.Geometry  = LineGeometry.Volumetric3D;
                shape.BlendMode = ShapesBlendMode.Additive;
                shape.Color     = colors[Random.Range(0, colors.Length)];
                shape.Start     = new Vector3(0f, 0f, 0f);
                shape.End       = new Vector3(0f, 0f, Random.Range(4f, 10f));
                shape.Thickness = Random.Range(0.1f, 1.0f);

                await UniTask.WhenAll(
                    Anime.PlayTo(
                        Easing.Create <OutCubic>(-20f, Random.Range(1f, 3f)),
                        TranslateTo.LocalPositionZ(shape)
                        ),
                    Anime.Play(
                        Easing.Create <InCubic>(Vector3.zero, Vector3.one, 0.15f),
                        TranslateTo.LocalScale(shape)
                        )
                    );
            }
        }
Пример #3
0
        public async Task Sample01()
        {
            using (var cubes = new SampleCubes(new Vector3(-5f, 0f, 0f)))
            {
                await Anime.Delay(1f);

                await Anime.PlayTo(
                    Easing.Create <OutCubic>(new Vector3(5f, 0f, 0f), 2f),
                    TranslateTo.LocalPosition(cubes[0])
                    );

                await Anime.Delay(1f);
            }
        }
Пример #4
0
        public async Task Sample03()
        {
            using (var cubes = new SampleCubes(new Vector3(-5f, 0f, 0f)))
            {
                await Anime.Delay(1f);

                CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
                cancellationTokenSource.Token.Register(() => Debug.Log("Cancel"));
                cancellationTokenSource.CancelAfter(500);

                await Anime.PlayTo(
                    Easing.Create <OutCubic>(new Vector3(5f, 0f, 0f), 2f),
                    TranslateTo.LocalPosition(cubes[0]),
                    cancellationTokenSource.Token
                    );

                await Anime.Delay(1f);
            }
        }
Пример #5
0
        private static async UniTask AnimationElement()
        {
            using (var shapeObjects = new DisposableGameObject(Vector3.zero))
            {
                var shape = shapeObjects.AddComponent <Disc>();
                shape.Type      = Disc.DiscType.Ring;
                shape.Color     = new Color32(255, 242, 173, 255);
                shape.Radius    = 0.3f;
                shape.Thickness = 0.1f;

                const float xrange    = 5f;
                const float yrangeMin = 5f;
                const float yrangeMax = 10f;
                await Anime.PlayTo(
                    Moving.Gravity(new Vector3(Random.Range(-xrange, xrange), Random.Range(yrangeMin, yrangeMax)), Vector3.down * 9.8f, 3f),
                    TranslateTo.LocalPosition(shape)
                    );
            }
        }
Пример #6
0
        public async Task Sample04()
        {
            using (var cubes = new SampleCubes(new Vector3(-5f, 0f, 0f)))
            {
                await Anime.Delay(1f);

                await UniTask.WhenAll(
                    Anime.PlayTo(
                        Moving.Linear(2f, 2f),
                        TranslateTo.LocalPositionX(cubes[0])
                        ),
                    Anime.PlayTo(
                        Animator.Delay(1.8f, Easing.Create <Linear>(Vector2.zero, 0.2f)),
                        TranslateTo.LocalScale(cubes[0])
                        )
                    );

                await Anime.Delay(1f);
            }
        }
Пример #7
0
        private static async UniTask Sample3()
        {
            using (var shapeObject = new DisposableGameObject(new Vector3(1f, -2f, 0f)))
            {
                var shape = shapeObject.AddComponent <Rectangle>();
                shape.Type      = Rectangle.RectangleType.RoundedHollow;
                shape.Color     = new Color32(255, 242, 173, 255);
                shape.Thickness = 0.1f;

                var cube = shape;

                await Anime.Delay(0.3f);

                await Anime.PlayTo(
                    Easing.Create <InCubic>(new Vector3(-5f, 3f, 0f), 2f),
                    TranslateTo.LocalPosition(cube)
                    );

                await Anime.Delay(0.3f);
            }
        }
Пример #8
0
        private static async UniTask ExplosionTestElement()
        {
            using (var shapeObjects = new DisposableGameObject(Vector3.zero))
            {
                var shape = shapeObjects.AddComponent <Disc>();
                shape.Type      = Disc.DiscType.Ring;
                shape.Color     = new Color32(255, 242, 173, 255);
                shape.Radius    = 0.3f;
                shape.Thickness = 0.1f;

                const float rangeMin = 1f;
                const float rangeMax = 3f;
                var         v        = Random.insideUnitCircle.normalized * Random.Range(rangeMin, rangeMax);

                const float duration      = 1f;
                const float eraseDuration = 0.5f;
                await Anime.Delay(0.5f);

                await UniTask.WhenAll(
                    Anime.PlayTo(
                        Easing.Create <OutExpo>(
                            new Vector3(v.x, v.y, 0f),
                            duration
                            ),
                        TranslateTo.LocalPosition(shape)
                        ),
                    Anime.Play(
                        Animator.Delay(duration - eraseDuration - 0.3f, Easing.Create <Linear>(1f, 0f, eraseDuration)),
                        TranslateTo.Action <float>(x =>
                {
                    var tmp     = shape.Color;
                    tmp.a       = x;
                    shape.Color = tmp;
                })
                        )
                    );
            }
        }
Пример #9
0
        private static async UniTask Tweet1()
        {
            using (var shapeObjects = new DisposableGameObjectList(new[]
            {
                new Vector3(-5f, 0f),
                new Vector3(-2.5f, 0f),
                new Vector3(0.0f, 0f),
                new Vector3(2.5f, 0f),
                new Vector3(5f, 0f),
            }))

            {
                var shapes = shapeObjects.GameObjects.Select(x =>
                {
                    var shape              = x.AddComponent <Rectangle>();
                    shape.Type             = Rectangle.RectangleType.RoundedHollow;
                    shape.Width            = 1f;
                    shape.Height           = 1f;
                    shape.Color            = new Color32(255, 242, 173, 0);
                    shape.Thickness        = 0f;
                    shape.CornerRadiusMode = Rectangle.RectangleCornerRadiusMode.PerCorner;
                    shape.CornerRadiii     = Vector4.zero;
                    return(shape);
                }).ToArray();

                async UniTask Anime1(Rectangle shape, int index)
                {
                    await Anime.Delay(index * 0.2f);

                    await UniTask.WhenAll(
                        Anime.Play(
                            Easing.Create <OutSine>(0f, 0.15f, 0.5f),
                            TranslateTo.Action <float>(x => shape.Thickness = x)
                            ),
                        Anime.Play(
                            Easing.Create <OutSine>(0f, 1f, 0.1f),
                            TranslateTo.Action <float>(x =>
                    {
                        var tmp     = shape.Color;
                        tmp.a       = x;
                        shape.Color = tmp;
                    })
                            )
                        );

                    await Anime.Delay(0.5f);

                    for (var i = 0; i < 4; ++i)
                    {
                        const float duration = 0.3f;
                        await Anime.Play(
                            Easing.Create <InOutCubic>(0f, 0.5f, duration),
                            TranslateTo.Action <float>(x =>
                        {
                            var tmp = shape.CornerRadiii;
                            tmp[(i + index) % 4] = x;
                            shape.CornerRadiii   = tmp;
                        })
                            );

                        var tmp2 = shape.CornerRadiii;
                        tmp2[(i + index) % 4] = 100;
                        shape.CornerRadiii    = tmp2;
                    }
                }

                async UniTask Anime2(Rectangle shape, int index)
                {
                    const float duration = 1f;
                    await UniTask.WhenAll(
                        Anime.PlayTo(
                            Easing.Create <InOutExpo>(0f, duration),
                            TranslateTo.LocalPositionX(shape.gameObject)
                            )
                        );

                    if (index != 0)
                    {
                        await UniTask.WhenAll(
                            Anime.Play(
                                Easing.Create <OutSine>(1f, 0f, 0.1f),
                                TranslateTo.Action <float>(x =>
                        {
                            var tmp     = shape.Color;
                            tmp.a       = x;
                            shape.Color = tmp;
                        })
                                )
                            );
                    }
                }

                async UniTask Anime3(Rectangle shape)
                {
                    await Anime.Play(
                        Easing.Create <InOutExpo>(0.5f, 0f, 0.5f),
                        TranslateTo.Action <float>(x => shape.CornerRadiii = Vector4.one *x)
                        );

                    await Anime.Play(
                        Easing.Create <InOutExpo>(0f, -20f, 0.5f),
                        TranslateTo.Action <float>(x => shape.transform.localRotation = Quaternion.Euler(0f, 0f, x))
                        );

                    await Anime.Play(
                        Easing.Create <InCubic>(0f, -7f, 0.5f),
                        TranslateTo.LocalPositionY(shape.gameObject)
                        );
                }

                await UniTask.WhenAll(shapes.Select((x, i) => Anime1(x, i)));

                await Anime.Delay(0.25f);

                await UniTask.WhenAll(shapes.Select((x, i) => Anime2(x, i)));
                await Anime3(shapes[0]);

                await Anime.Delay(0.5f);
            }
        }