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。

相关文章

【前端学习】AntV G6-08 深入图形与图形分组、自定义节点、节点动画（下）

【前端学习】AntV G6-08 深入图形与图形分组、自定义节点、节点动画（下）

【课程链接】 AntV G6：深入图形与图形分组、自定义节点、节点动画（下）_哔哩哔哩_bilibili 本章十吾老师讲解了一个复杂的自定义节点中，应该怎样去计算和绘制图形，如何给一个图形制作不间断的动画，以及在鼠标事件之后产生动画。（有点难，需要好好理解） <!DOCTYPE html><html><head><meta charset="UTF-8"><title>06
阅读更多...
Flutter 进阶：绘制加载动画

Flutter 进阶：绘制加载动画

绘制加载动画：由小圆组成的大圆 1. 定义 LoadingScreen 类2. 实现 _LoadingScreenState 类3. 定义 LoadingPainter 类4. 总结 实现加载动画 我们需要定义两个类：LoadingScreen 和 LoadingPainter。LoadingScreen 负责控制动画的状态，而 LoadingPainter 则负责绘制动画。
阅读更多...
Linux服务器Java启动脚本

Linux服务器Java启动脚本

Linux服务器Java启动脚本 1、初版2、优化版本3、常用脚本仓库 本文章介绍了如何在Linux服务器上执行Java并启动jar包， 通常我们会使用nohup直接启动，但是还是需要手动停止然后再次启动， 那如何更优雅的在服务器上启动jar包呢，让我们一起探讨一下吧。 1、初版 第一个版本是常用的做法，直接使用nohup后台启动jar包， 并将日志输出到当前文件夹n
阅读更多...
用Unity2D制作一个人物，实现移动、跳起、人物静止和动起来时的动画：中（人物移动、跳起、静止动作）

用Unity2D制作一个人物，实现移动、跳起、人物静止和动起来时的动画：中（人物移动、跳起、静止动作）

上回我们学到创建一个地形和一个人物，今天我们实现一下人物实现移动和跳起，依次点击，我们准备创建一个C#文件 创建好我们点击进去，就会跳转到我们的Vision Studio，然后输入这些代码 using UnityEngine;public class Move : MonoBehaviour // 定义一个名为Move的类，继承自MonoBehaviour{private Rigidbo
阅读更多...
centos6一键安装vsftpd脚本

centos6一键安装vsftpd脚本

centos6一键安装vsftpd脚本 手动安装vsftpd参考教程：Centos下安装Vsftpd的图文教程 vsftpd脚本功能： 1.安装 （命令执行：sh xxx.sh）2.添加ftp用户 （命令执行：sh xxx.sh add）3.卸载vsftpd （命令执行：sh xxx.sh uninstall） 测试环境：centos6 x64 centos6 x86(测试centos7以
阅读更多...
Android逆向(反调，脱壳，过ssl证书脚本)

Android逆向(反调，脱壳，过ssl证书脚本)

文章目录 总结 基础Android基础工具 定位关键代码页面activity定位数据包参数定位堆栈追踪 编写反调脱壳好用的脚本过ssl证书校验抓包反调的脚本打印堆栈bilibili反调的脚本 总结 暑假做了两个月的Android逆向，记录一下自己学到的东西。对于app渗透有了一些思路。 这两个月主要做的是代码分析，对于分析完后的持久化等没有学习。主要是如何反编译源码，如何找到
阅读更多...
Lua 脚本在 Redis 中执行时的原子性以及与redis的事务的区别

Lua 脚本在 Redis 中执行时的原子性以及与redis的事务的区别

在 Redis 中，Lua 脚本具有原子性是因为 Redis 保证在执行脚本时，脚本中的所有操作都会被当作一个不可分割的整体。具体来说，Redis 使用单线程的执行模型来处理命令，因此当 Lua 脚本在 Redis 中执行时，不会有其他命令打断脚本的执行过程。脚本中的所有操作都将连续执行，直到脚本执行完成后，Redis 才会继续处理其他客户端的请求。 Lua 脚本在 Redis 中原子性的原因
阅读更多...
CentOs7上Mysql快速迁移脚本

CentOs7上Mysql快速迁移脚本

因公司业务需要，对原来在/usr/local/mysql/data目录下的数据迁移到/data/local/mysql/mysqlData。 原因是系统盘太小，只有20G，几下就快满了。 参考过几篇文章，基于大神们的思路，我封装成了.sh脚本。 步骤如下： 1） 先修改好/etc/my.cnf,        ##[mysqld]       ##datadir=/data/loc
阅读更多...
PHP抓取网站图片脚本

PHP抓取网站图片脚本

方法一： <?phpheader("Content-type:image/jpeg"); class download_image{function read_url($str) { $file=fopen($str,"r");$result = ''; while(!feof($file)) { $result.=fgets($file,9999); } fclose($file); re
阅读更多...
Python脚本：对文件进行批量重命名

Python脚本：对文件进行批量重命名

字符替换：批量对文件名中指定字符进行替换添加前缀：批量向原文件名添加前缀添加后缀：批量向原文件名添加后缀 import osdef Rename_CharReplace():#对文件名中某字符进行替换(已完结)re_dir = os.getcwd()re_list = os.listdir(re_dir)original_char = input('请输入你要替换的字符：')replace_ch
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2