UGUI 序列帧动画脚本

2023-10-11 15:48
文章标签 脚本 动画 ugui 序列帧

本文主要是介绍UGUI 序列帧动画脚本，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

using System.Collections;
using System.Collections.Generic;
using System;
using System.IO;
using UnityEngine;
using UnityEngine.UI;
using UnityEditor;

public enum SequencePatternType
{
    /// <summary>
    /// 正循环//自动播放
    /// </summary>
    ForthLoop,

    /// <summary>
    /// 反循环//自动播放
    /// </summary>
    BackLoop,

    /// <summary>
    /// 正反循环//自动播放
    /// </summary>
    ForthBackLoop,

    /// <summary>
    /// 正一次//按钮点击事件
    /// </summary>
    ForthOne,

    /// <summary>
    /// 反一次//按钮点击事件
    /// </summary>
    BackOne,

    /// <summary>
    /// 正反一次//按钮点击事件
    /// </summary>
    ForthBackOne,

    /// <summary>
    /// 空
    /// </summary>
    Max
}

/// <summary>
/// forth back pattern type
/// </summary>
public enum ForthBackState
{
    Forth,
    ForthStop,
    BackStop,
    Back
}

/// <summary>
/// 序列帧动画播放
/// 19.06.28 by Rocketjie
/// </summary>
public class SequenceSprite : MonoBehaviour {

    /// <summary>
    /// sprites 播放模式
    /// </summary>
    [Tooltip("Sequence Pattern (Default Is Loop)")]
    public SequencePatternType PatternType = SequencePatternType.ForthLoop;

    /// <summary>
    /// SpriteList(当SpriteList添加图片后不再读取Texture2D)
    /// </summary>
    [Tooltip("Sequence Sprite List")]
    public List<Sprite> SpriteList = new List<Sprite>();

    /// <summary>
    /// Texture2D
    /// 图集中图片数量大于1；
    /// 图集中图片名称格式为：字母 + “_” + 数字(数字必须以0开始)；
    /// 图集中图片名称格式例如：effect_0、effect_1、effect_2 ；
    /// 当SpriteList没有添加图片时读取Texture2D
    /// </summary>
    [Tooltip("Texture2D Atlas")]
    public Texture2D Texture2DAtlas = null;

    /// <summary>
    /// 间隔时间
    /// </summary>
    [Tooltip("Sequence Sprite Turn Time")]
    public float TurnTime = 0.05f;

    /// <summary>
    /// 序列帧播放 sprite
    /// </summary>
    [Tooltip("Sprite Is Self Component (Default)")]
    public Image TargetSprite = null;

    /// <summary>
    /// 序列帧播放 触发按钮
    /// </summary>
    [Tooltip("Button Is Self Component (Default)")]
    public Button TargetButton = null;

    private int img_index = 0;
    private float deltTime = 0;
    private SequencePatternType currentType = SequencePatternType.Max;

    private void Awake()
    {
        if (TargetSprite == null)
        {
            TargetSprite = gameObject.GetComponent<Image>();
        }

        if (TargetButton == null)
        {
            TargetButton = gameObject.GetComponent<Button>();
        }

        if (SpriteList.Count <= 0 && Texture2DAtlas != null)
        {
            string rootPath = Path.GetDirectoryName(AssetDatabase.GetAssetPath(Texture2DAtlas));
            string path = rootPath + "/" + Texture2DAtlas.name + ".PNG";
            TextureImporter texImp = AssetImporter.GetAtPath(path) as TextureImporter;
            if(texImp.spritesheet.Length <= 1)
            {
                Logger.LogError("Texture2D Format incorrect");
                return;
            }

            int indexOf = 0;
            for (int index = 0; index < texImp.spritesheet.Length; index++)
            {
                foreach (SpriteMetaData temp in texImp.spritesheet)
                {
                    indexOf = temp.name.IndexOf('_');
                    if (indexOf == -1)
                    {
                        Logger.LogError("Texture2D Format incorrect");
                        return;
                    }
                    else
                    {
                        if (int.Parse(temp.name.Substring(indexOf + 1)) == index)
                        {
                            Sprite spr = Sprite.Create(Texture2DAtlas, temp.rect, Vector2.zero);
                            SpriteList.Add(spr);
                        }
                    }
                }
            }
        }
    }


    // Use this for initialization
    void Start ()
    {
        if(TargetButton != null)
        {
            TargetButton.onClick.AddListener(OnClick);
        }
    }

    /// <summary>
    /// button click
    /// </summary>
    private void OnClick()
    {
        switch (PatternType)
        {
            case SequencePatternType.BackOne:
                SetBackOneState();
                break;
            case SequencePatternType.ForthOne:
                SetForthOneState();
                break;
            case SequencePatternType.ForthBackOne:
                SetForthBackOneState();
                break;
        }
    }


    /// <summary>
    /// 设置 forth one state
    /// </summary>
    private void SetForthOneState()
    {
        if (forthOne_State == ForthBackState.ForthStop)
        {
            forthOne_State = ForthBackState.Forth;
        }
    }

    /// <summary>
    /// 设置 back one state
    /// </summary>
    private void SetBackOneState()
    {
        if (backOne_State == ForthBackState.BackStop)
        {
            backOne_State = ForthBackState.Back;
        }
    }

    /// <summary>
    /// 设置 forth back one state
    /// </summary>
    private void SetForthBackOneState()
    {
        if (forthBackOneState == ForthBackState.ForthStop)
        {
            forthBackOneState = ForthBackState.Back;
        }
        else if (forthBackOneState == ForthBackState.BackStop)
        {
            forthBackOneState = ForthBackState.Forth;
        }
    }

    /// <summary>
    /// 检测 pattern type
    /// </summary>
    private void CheckPatterType()
    {
        if (currentType != PatternType)
        {
            currentType = PatternType;

            switch (PatternType)
            {
                case SequencePatternType.ForthLoop:
                    img_index = 0;
                    break;
                case SequencePatternType.BackLoop:
                    img_index = SpriteList.Count - 1;
                    break;
                case SequencePatternType.ForthBackLoop:
                    img_index = 0;
                    forthBack_loopState = ForthBackState.Forth;
                    break;
                case SequencePatternType.ForthOne:
                    img_index = 0;
                    forthOne_State = ForthBackState.ForthStop;
                    break;
                case SequencePatternType.BackOne:
                    img_index = SpriteList.Count - 1;
                    backOne_State = ForthBackState.BackStop;
                    break;
                case SequencePatternType.ForthBackOne:
                    img_index = 0;
                    forthBackOneState = ForthBackState.BackStop;
                    break;
            }
        }
    }


    private void SetImageSprite()
    {
        if (img_index >= 0 && img_index < SpriteList.Count)
        {
            TargetSprite.sprite = SpriteList[img_index];
        }
        else
        {
            Logger.LogError("SequenceSprite SpriteList'img_index is error !");
        }
    }

    // Update is called once per frame
    void Update()
    {
        if (TargetSprite == null || SpriteList.Count <= 1)
        {
            return;
        }

        CheckPatterType();

        switch (PatternType)
        {
            case SequencePatternType.ForthLoop:
                SequenceForthLoop();
                break;

            case SequencePatternType.BackLoop:
                SequenceBackLoop();
                break;

            case SequencePatternType.ForthBackLoop:
                SequenceForthBackLoop();
                break;

            case SequencePatternType.ForthOne:
                SequenceForthOne();
                break;

            case SequencePatternType.BackOne:
                SequenceBackOne();
                break;
            case SequencePatternType.ForthBackOne:
                SequenceForthBackOne();
                break;
        }
    }


    #region Forth Loop
    /// <summary>
    /// Forth Loop
    /// </summary>
    private void SequenceForthLoop()
    {
        deltTime += Time.deltaTime;

        if (deltTime > TurnTime)
        {
            deltTime = 0;
            SetImageSprite();//Forth Loop
            img_index++;

            if (img_index == SpriteList.Count - 1)
            {
                img_index = 0;
            }
        }
    }
    #endregion Forth Loop

 

    #region Back Loop
    /// <summary>
    /// Back Loop
    /// </summary>
    private void SequenceBackLoop()
    {
        deltTime += Time.deltaTime;

        if (deltTime > TurnTime)
        {
            deltTime = 0;
            SetImageSprite();//Back Loop
            img_index--;

            if (img_index == 0)
            {
                img_index = SpriteList.Count - 1;
            }
        }

    }
    #endregion Back Loop

 

    #region Forth Back Loop

    /// <summary>
    /// Forth Back Loop 状态
    /// </summary>
    private ForthBackState forthBack_loopState = ForthBackState.Forth;

    /// <summary>
    /// Forth Back Loop
    /// </summary>
    private void SequenceForthBackLoop()
    {
        deltTime += Time.deltaTime;

        if (deltTime > TurnTime)
        {
            deltTime = 0;
            SetImageSprite();//Forth Back Loop

            if (forthBack_loopState == ForthBackState.Forth)
            {
                img_index++;
            }
            else if (forthBack_loopState == ForthBackState.Back)
            {
                img_index--;
            }

            if (img_index >= SpriteList.Count - 1)
            {
                img_index = SpriteList.Count - 1;
                forthBack_loopState = ForthBackState.Back;
            }
            else if (img_index <= 0)
            {
                img_index = 0;
                forthBack_loopState = ForthBackState.Forth;
            }
        }
    }
    #endregion Forth Back Loop

 

    #region Forth One

    /// <summary>
    /// Forth One 状态
    /// </summary>
    private ForthBackState forthOne_State = ForthBackState.ForthStop;

    /// <summary>
    /// Forth One
    /// </summary>
    private void SequenceForthOne()
    {
        if (forthOne_State == ForthBackState.Forth)
        {
            deltTime += Time.deltaTime;

            if (deltTime > TurnTime)
            {
                deltTime = 0;
                SetImageSprite();//Forth One
                img_index++;

                if (img_index == SpriteList.Count - 1)
                {
                    img_index = 0;
                    forthOne_State = ForthBackState.ForthStop;
                }
            }
        }
    }
    #endregion Forth One

 

    #region Back One

    /// <summary>
    /// Back One 状态
    /// </summary>
    private ForthBackState backOne_State = ForthBackState.BackStop;

    /// <summary>
    /// Back One
    /// </summary>
    private void SequenceBackOne()
    {
        if (backOne_State == ForthBackState.Back)
        {
            deltTime += Time.deltaTime;

            if (deltTime > TurnTime)
            {
                deltTime = 0;
                SetImageSprite();//Back One
                img_index--;

                if (img_index == 0)
                {
                    img_index = SpriteList.Count - 1;
                    backOne_State = ForthBackState.BackStop;
                }
            }
        }
    }
    #endregion Back One

 

    #region Forth Back One

    /// <summary>
    /// Forth Back One 状态
    /// </summary>
    private ForthBackState forthBackOneState = ForthBackState.BackStop;

    /// <summary>
    /// forth back one
    /// </summary>
    private void SequenceForthBackOne()
    {
        if (forthBackOneState == ForthBackState.Forth)
        {
            deltTime += Time.deltaTime;

            if (deltTime > TurnTime)
            {
                deltTime = 0;
                SetImageSprite();//Forth Back One (Forth)
                img_index++;
            }

            if (img_index == SpriteList.Count - 1)
            {
                forthBackOneState = ForthBackState.ForthStop;
            }
        }
        else if (forthBackOneState == ForthBackState.Back)
        {
            deltTime += Time.deltaTime;
            if (deltTime > TurnTime)
            {
                deltTime = 0;
                SetImageSprite();//Forth Back One (Back)
                img_index--;
            }

            if (img_index == 0)
            {
                forthBackOneState = ForthBackState.BackStop;
            }
        }
    }
    #endregion Forth Back One
}

 

这篇关于UGUI 序列帧动画脚本的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/189119。

相关文章

利用Python脚本实现批量将图片转换为WebP格式

利用Python脚本实现批量将图片转换为WebP格式

《利用Python脚本实现批量将图片转换为WebP格式》Python语言的简洁语法和库支持使其成为图像处理的理想选择,本文将介绍如何利用Python实现批量将图片转换为WebP格式的脚本,WebP作为... 目录简介1. python在图像处理中的应用2. WebP格式的原理和优势2.1 WebP格式与传统
阅读更多...
Linux脚本(shell)的使用方式

Linux脚本(shell)的使用方式

《Linux脚本(shell)的使用方式》：本文主要介绍Linux脚本(shell)的使用方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录概述语法详解数学运算表达式Shell变量变量分类环境变量Shell内部变量自定义变量：定义、赋值自定义变量：引用、修改、删
阅读更多...
Golang实现Redis分布式锁(Lua脚本+可重入+自动续期)

Golang实现Redis分布式锁(Lua脚本+可重入+自动续期)

《Golang实现Redis分布式锁(Lua脚本+可重入+自动续期)》本文主要介绍了Golang分布式锁实现,采用Redis+Lua脚本确保原子性,持可重入和自动续期,用于防止超卖及重复下单,具有一定... 目录1 概念应用场景分布式锁必备特性2 思路分析宕机与过期防止误删keyLua保证原子性可重入锁自动
阅读更多...
Kotlin Compose Button 实现长按监听并实现动画效果(完整代码)

Kotlin Compose Button 实现长按监听并实现动画效果(完整代码)

《KotlinComposeButton实现长按监听并实现动画效果(完整代码)》想要实现长按按钮开始录音,松开发送的功能,因此为了实现这些功能就需要自己写一个Button来解决问题,下面小编给大... 目录Button 实现原理1. Surface 的作用（关键）2. InteractionSource3.
阅读更多...
使用WPF实现窗口抖动动画效果

使用WPF实现窗口抖动动画效果

《使用WPF实现窗口抖动动画效果》在用户界面设计中,适当的动画反馈可以提升用户体验,尤其是在错误提示、操作失败等场景下,窗口抖动作为一种常见且直观的视觉反馈方式,常用于提醒用户注意当前状态,本文将详细... 目录前言实现思路概述核心代码实现1、 获取目标窗口2、初始化基础位置值3、创建抖动动画4、动画完成后
阅读更多...
使用animation.css库快速实现CSS3旋转动画效果

使用animation.css库快速实现CSS3旋转动画效果

《使用animation.css库快速实现CSS3旋转动画效果》随着Web技术的不断发展，动画效果已经成为了网页设计中不可或缺的一部分，本文将深入探讨animation.css的工作原理，如何使用以及... 目录1. css3动画技术简介2. animation.css库介绍2.1 animation.cs
阅读更多...
CentOS和Ubuntu系统使用shell脚本创建用户和设置密码

CentOS和Ubuntu系统使用shell脚本创建用户和设置密码

《CentOS和Ubuntu系统使用shell脚本创建用户和设置密码》在Linux系统中,你可以使用useradd命令来创建新用户,使用echo和chpasswd命令来设置密码,本文写了一个shell... 在linux系统中,你可以使用useradd命令来创建新用户,使用echo和chpasswd命令来设
阅读更多...
redis中使用lua脚本的原理与基本使用详解

redis中使用lua脚本的原理与基本使用详解

《redis中使用lua脚本的原理与基本使用详解》在Redis中使用Lua脚本可以实现原子性操作、减少网络开销以及提高执行效率,下面小编就来和大家详细介绍一下在redis中使用lua脚本的原理... 目录Redis 执行 Lua 脚本的原理基本使用方法使用EVAL命令执行 Lua 脚本使用EVALSHA命令
阅读更多...
Java使用ANTLR4对Lua脚本语法校验详解

Java使用ANTLR4对Lua脚本语法校验详解

《Java使用ANTLR4对Lua脚本语法校验详解》ANTLR是一个强大的解析器生成器,用于读取、处理、执行或翻译结构化文本或二进制文件,下面就跟随小编一起看看Java如何使用ANTLR4对Lua脚本... 目录什么是ANTLR？第一个例子ANTLR4 的工作流程Lua脚本语法校验准备一个Lua Gramm
阅读更多...
微信公众号脚本-获取热搜自动新建草稿并发布文章

微信公众号脚本-获取热搜自动新建草稿并发布文章

《微信公众号脚本-获取热搜自动新建草稿并发布文章》本来想写一个自动化发布微信公众号的小绿书的脚本,但是微信公众号官网没有小绿书的接口,那就写一个获取热搜微信普通文章的脚本吧,：本文主要介绍微信公众... 目录介绍思路前期准备环境要求获取接口token获取热搜获取热搜数据下载热搜图片给图片加上标题文字上传图片
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2