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。

相关文章

10个Python自动化办公的脚本分享

10个Python自动化办公的脚本分享

《10个Python自动化办公的脚本分享》在日常办公中,我们常常会被繁琐、重复的任务占据大量时间,本文为大家分享了10个实用的Python自动化办公案例及源码,希望对大家有所帮助... 目录1. 批量处理 Excel 文件2. 自动发送邮件3. 批量重命名文件4. 数据清洗5. 生成 PPT6. 自动化测试
阅读更多...
使用Java实现一个解析CURL脚本小工具

使用Java实现一个解析CURL脚本小工具

《使用Java实现一个解析CURL脚本小工具》文章介绍了如何使用Java实现一个解析CURL脚本的工具,该工具可以将CURL脚本中的Header解析为KVMap结构,获取URL路径、请求类型,解析UR... 目录使用示例实现原理具体实现CurlParserUtilCurlEntityICurlHandler
阅读更多...
10个Python Excel自动化脚本分享

10个Python Excel自动化脚本分享

《10个PythonExcel自动化脚本分享》在数据处理和分析的过程中,Excel文件是我们日常工作中常见的格式,本文将分享10个实用的Excel自动化脚本,希望可以帮助大家更轻松地掌握这些技能... 目录1. Excel单元格批量填充2. 设置行高与列宽3. 根据条件删除行4. 创建新的Excel工作表5
阅读更多...
Linux中shell解析脚本的通配符、元字符、转义符说明

Linux中shell解析脚本的通配符、元字符、转义符说明

《Linux中shell解析脚本的通配符、元字符、转义符说明》：本文主要介绍shell通配符、元字符、转义符以及shell解析脚本的过程,通配符用于路径扩展,元字符用于多命令分割,转义符用于将特殊... 目录一、linux shell通配符(wildcard)二、shell元字符（特殊字符 Meta）三、s
阅读更多...
Python脚本实现自动删除C盘临时文件夹

Python脚本实现自动删除C盘临时文件夹

《Python脚本实现自动删除C盘临时文件夹》在日常使用电脑的过程中,临时文件夹往往会积累大量的无用数据,占用宝贵的磁盘空间,下面我们就来看看Python如何通过脚本实现自动删除C盘临时文件夹吧... 目录一、准备工作二、python脚本编写三、脚本解析四、运行脚本五、案例演示六、注意事项七、总结在日常使用
阅读更多...
java脚本使用不同版本jdk的说明介绍

java脚本使用不同版本jdk的说明介绍

《java脚本使用不同版本jdk的说明介绍》本文介绍了在Java中执行JavaScript脚本的几种方式,包括使用ScriptEngine、Nashorn和GraalVM,ScriptEngine适用... 目录Java脚本使用不同版本jdk的说明1.使用ScriptEngine执行javascript2.
阅读更多...
解决Cron定时任务中Pytest脚本无法发送邮件的问题

解决Cron定时任务中Pytest脚本无法发送邮件的问题

《解决Cron定时任务中Pytest脚本无法发送邮件的问题》文章探讨解决在Cron定时任务中运行Pytest脚本时邮件发送失败的问题,先优化环境变量,再检查Pytest邮件配置,接着配置文件确保SMT... 目录引言1. 环境变量优化：确保Cron任务可以正确执行解决方案：1.1. 创建一个脚本1.2. 修
阅读更多...
python写个唤醒睡眠电脑的脚本

python写个唤醒睡眠电脑的脚本

《python写个唤醒睡眠电脑的脚本》这篇文章主要为大家详细介绍了如何使用python写个唤醒睡眠电脑的脚本,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 环境：win10python3.12问题描述：怎么用python写个唤醒睡眠电脑的脚本？解决方案：1.唤醒处于睡眠状
阅读更多...
多模块的springboot项目发布指定模块的脚本方式

多模块的springboot项目发布指定模块的脚本方式

《多模块的springboot项目发布指定模块的脚本方式》该文章主要介绍了如何在多模块的SpringBoot项目中发布指定模块的脚本,作者原先的脚本会清理并编译所有模块,导致发布时间过长,通过简化脚本... 目录多模块的springboot项目发布指定模块的脚本1、不计成本地全部发布2、指定模块发布总结多模
阅读更多...
shell脚本快速检查192.168.1网段ip是否在用的方法

shell脚本快速检查192.168.1网段ip是否在用的方法

《shell脚本快速检查192.168.1网段ip是否在用的方法》该Shell脚本通过并发ping命令检查192.168.1网段中哪些IP地址正在使用,脚本定义了网络段、超时时间和并行扫描数量,并使用... 目录脚本：检查 192.168.1 网段 IP 是否在用脚本说明使用方法示例输出优化建议总结检查 1
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2