devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Unity——用代码实现序列帧动画(动态加载)_unity rawimage 序列帧

作者：羊村懒王 | 2024-02-25 03:40:50

赞

踩

unity rawimage 序列帧

最近的项目用SpriteRenderer+Animation的方式播放序列帧，unity编辑器里是可以正常播放没问题的，但打包出去后，发现一闪一闪的，什么玩意啊。。。然后搜索了一下文章，看到个大佬写的，换成image播放序列帧就可以了。

原文链接：https://blog.csdn.net/SerenaHaven/article/details/79273114

好了问题解决是解决了。然后我发现挂上脚本后，因为脚本上有个精灵体数组，要自己一个一个添加，比较麻烦。于是我改了下动态加载，代码如下：

  1. using UnityEngine;
  2. using UnityEngine.UI;
  3. using System;
  4.  
  5. /// <summary>
  6. /// 序列帧动画播放器
  7. /// 支持UGUI的Image和Unity2D的SpriteRenderer
  8. /// </summary>
  9. public class FrameAnimator : MonoBehaviour
  10. {
  11.     /// <summary>
  12.     /// 序列帧数
  13.     /// </summary>
  14.     public int _framesCount;
  15.     /// <summary>
  16.     /// 序列帧名字前半部分  例如： image_1.jpg中的   image_为前半部分
  17.     /// </summary>
  18.     public string _framesName;
  19.     /// <summary>
  20.     /// resource文件夹下的文件夹路径 例如：Resources/Test/Sprites  则直接赋值  Test/Sprites   序列帧放在Sprites文件夹下就好
  21.     /// </summary>
  22.     public string _folderPath;
  23.     /// <summary>
  24.     /// 序列帧
  25.     /// </summary>
  26.     private Sprite[] frames = null;
  27.  
  28.     /// <summary>
  29.     /// 帧率，为正时正向播放，为负时反向播放
  30.     /// </summary>
  31.     public float Framerate { get { return framerate; } set { framerate = value; } }
  32.  
  33.     [SerializeField] private float framerate = 20.0f;
  34.  
  35.     /// <summary>
  36.     /// 是否忽略timeScale
  37.     /// </summary>
  38.     public bool IgnoreTimeScale { get { return ignoreTimeScale; } set { ignoreTimeScale = value; } }
  39.  
  40.     [SerializeField] private bool ignoreTimeScale = true;
  41.  
  42.     /// <summary>
  43.     /// 是否循环
  44.     /// </summary>
  45.     public bool Loop { get { return loop; } set { loop = value; } }
  46.  
  47.     [SerializeField] private bool loop = true;
  48.  
  49.     //动画曲线
  50.     [SerializeField] private AnimationCurve curve = new AnimationCurve(new Keyframe(0, 1, 0, 0), new Keyframe(1, 1, 0, 0));
  51.  
  52.     /// <summary>
  53.     /// 结束事件
  54.     /// 在每次播放完一个周期时触发
  55.     /// 在循环模式下触发此事件时，当前帧不一定为结束帧
  56.     /// </summary>
  57.     public event Action FinishEvent;
  58.  
  59.     //目标Image组件
  60.     private Image image;
  61.     //目标SpriteRenderer组件
  62.     private SpriteRenderer spriteRenderer;
  63.     //当前帧索引
  64.     private int currentFrameIndex = 0;
  65.     //下一次更新时间
  66.     private float timer = 0.0f;
  67.     //当前帧率，通过曲线计算而来
  68.     private float currentFramerate = 20.0f;
  69.  
  70.     /// <summary>
  71.     /// 重设动画
  72.     /// </summary>
  73.     public void Reset()
  74.     {
  75.         currentFrameIndex = framerate < 0 ? frames.Length - 1 : 0;
  76.     }
  77.  
  78.     /// <summary>
  79.     /// 从停止的位置播放动画
  80.     /// </summary>
  81.     public void Play()
  82.     {
  83.         this.enabled = true;
  84.     }
  85.  
  86.     /// <summary>
  87.     /// 暂停动画
  88.     /// </summary>
  89.     public void Pause()
  90.     {
  91.         this.enabled = false;
  92.     }
  93.  
  94.     /// <summary>
  95.     /// 停止动画，将位置设为初始位置
  96.     /// </summary>
  97.     public void Stop()
  98.     {
  99.         Pause();
  100.         Reset();
  101.     }
  102.  
  103.     //自动开启动画
  104.     void Start()
  105.     {
  106.         image = this.GetComponent<Image>();
  107.         spriteRenderer = this.GetComponent<SpriteRenderer>();
  108.  
  109.         //初始化精灵体数组
  110.         frames = new Sprite[_framesCount];
  111.         for (int i = 0; i < _framesCount; i++)
  112.             frames[i] = Resources.Load<Sprite>(_folderPath + "/" + _framesName + i) as Sprite;
  113.  
  114.  
  115. #if UNITY_EDITOR
  116.         if (image == null && spriteRenderer == null)
  117.         {
  118.             Debug.LogWarning("No available component found. 'Image' or 'SpriteRenderer' required.", this.gameObject);
  119.         }
  120. #endif
  121.     }
  122.  
  123.     void Update()
  124.     {
  125.         //帧数据无效，禁用脚本
  126.         if (frames == null || frames.Length == 0)
  127.         {
  128.             this.enabled = false;
  129.         }
  130.         else
  131.         {
  132.             //从曲线值计算当前帧率
  133.             float curveValue = curve.Evaluate((float)currentFrameIndex / frames.Length);
  134.             float curvedFramerate = curveValue * framerate;
  135.             //帧率有效
  136.             if (curvedFramerate != 0)
  137.             {
  138.                 //获取当前时间
  139.                 float time = ignoreTimeScale ? Time.unscaledTime : Time.time;
  140.                 //计算帧间隔时间
  141.                 float interval = Mathf.Abs(1.0f / curvedFramerate);
  142.                 //满足更新条件，执行更新操作
  143.                 if (time - timer > interval)
  144.                 {
  145.                     //执行更新操作
  146.                     DoUpdate();
  147.                 }
  148.             }
  149. #if UNITY_EDITOR
  150.             else
  151.             {
  152.                 Debug.LogWarning("Framerate got '0' value, animation stopped.");
  153.             }
  154. #endif
  155.         }
  156.     }
  157.  
  158.     //具体更新操作
  159.     private void DoUpdate()
  160.     {
  161.         //计算新的索引
  162.         int nextIndex = currentFrameIndex + (int)Mathf.Sign(currentFramerate);
  163.         //索引越界，表示已经到结束帧
  164.         if (nextIndex < 0 || nextIndex >= frames.Length)
  165.         {
  166.             //广播事件
  167.             if (FinishEvent != null)
  168.             {
  169.                 FinishEvent();
  170.             }
  171.             //非循环模式，禁用脚本
  172.             if (loop == false)
  173.             {
  174.                 currentFrameIndex = Mathf.Clamp(currentFrameIndex, 0, frames.Length - 1);
  175.                 this.enabled = false;
  176.                 return;
  177.             }
  178.         }
  179.         //钳制索引
  180.         currentFrameIndex = nextIndex % frames.Length;
  181.         //更新图片
  182.         if (image != null)
  183.         {
  184.             image.sprite = frames[currentFrameIndex];
  185.         }
  186.         else if (spriteRenderer != null)
  187.         {
  188.             spriteRenderer.sprite = frames[currentFrameIndex];
  189.         }
  190.         //设置计时器为当前时间
  191.         timer = ignoreTimeScale ? Time.unscaledTime : Time.time;
  192.     }
  193. }

 

我想要的效果是每次显示都要从第一帧开始，但现在的问题是：如果我隐藏掉也就是setactive设为false，那么下次再激活的时候是从你刚刚隐藏的那一帧开始的。如果想要每次初始化，只需在生命周期函数OnEnable中调用一次重置的方法即可：

  1.     private void OnEnable()
  2.     {
  3.         Reset();
  4.     }

后面又更新了一版RawImage，为什么呢，图片一多了，一起拖到Resources文件夹里还是比较慢的，然后还有手动转一下精灵体，又要等好久。。。然后又改了一版。需要的自己选择！

  1. using UnityEngine;
  2. using UnityEngine.UI;
  3. using System;
  4.  
  5. /// <summary>
  6. /// 序列帧动画播放器
  7. /// 支持UGUI的Image和Unity2D的SpriteRenderer
  8. /// </summary>
  9. public class FrameAnimator : MonoBehaviour
  10. {
  11.     /// <summary>
  12.     /// 序列帧数
  13.     /// </summary>
  14.     public int _framesCount;
  15.     /// <summary>
  16.     /// 序列帧名字前半部分  例如： image_1.jpg中的   image_为前半部分
  17.     /// </summary>
  18.     public string _framesName;
  19.     /// <summary>
  20.     /// resource文件夹下的文件夹路径 例如：Resources/Test/Texture  则直接赋值  Test/Texture   序列帧放在Texture文件夹下就好
  21.     /// </summary>
  22.     public string _folderPath;
  23.     /// <summary>
  24.     /// 序列帧
  25.     /// </summary>
  26.     private Texture[] frames = null;
  27.  
  28.     /// <summary>
  29.     /// 帧率，为正时正向播放，为负时反向播放
  30.     /// </summary>
  31.     public float Framerate { get { return framerate; } set { framerate = value; } }
  32.  
  33.     [SerializeField] private float framerate = 20.0f;
  34.  
  35.     /// <summary>
  36.     /// 是否忽略timeScale
  37.     /// </summary>
  38.     public bool IgnoreTimeScale { get { return ignoreTimeScale; } set { ignoreTimeScale = value; } }
  39.  
  40.     [SerializeField] private bool ignoreTimeScale = true;
  41.  
  42.     /// <summary>
  43.     /// 是否循环
  44.     /// </summary>
  45.     public bool Loop { get { return loop; } set { loop = value; } }
  46.  
  47.     [SerializeField] private bool loop = true;
  48.  
  49.     //动画曲线
  50.     [SerializeField] private AnimationCurve curve = new AnimationCurve(new Keyframe(0, 1, 0, 0), new Keyframe(1, 1, 0, 0));
  51.  
  52.     /// <summary>
  53.     /// 是否允许播放
  54.     /// </summary>
  55.     public bool _isPlayFrameAnimator { get { return IsPlayFrameAnimator; } set { IsPlayFrameAnimator = value; } }
  56.     [SerializeField] private bool IsPlayFrameAnimator = false;
  57.  
  58.     /// <summary>
  59.     /// 结束事件
  60.     /// 在每次播放完一个周期时触发
  61.     /// 在循环模式下触发此事件时，当前帧不一定为结束帧
  62.     /// </summary>
  63.     public event Action FinishEvent;
  64.  
  65.     //目标Image组件
  66.     private RawImage image;
  67.     //当前帧索引
  68.     private int currentFrameIndex = 0;
  69.     //下一次更新时间
  70.     private float timer = 0.0f;
  71.     //当前帧率，通过曲线计算而来
  72.     private float currentFramerate = 20.0f;
  73.  
  74.     /// <summary>
  75.     /// 重设动画
  76.     /// </summary>
  77.     public void Reset()
  78.     {
  79.         currentFrameIndex = framerate < 0 ? frames.Length - 1 : 0;
  80.     }
  81.  
  82.     /// <summary>
  83.     /// 从停止的位置播放动画
  84.     /// </summary>
  85.     public void Play()
  86.     {
  87.         this.enabled = true;
  88.     }
  89.  
  90.     /// <summary>
  91.     /// 暂停动画
  92.     /// </summary>
  93.     public void Pause()
  94.     {
  95.         this.enabled = false;
  96.     }
  97.  
  98.     /// <summary>
  99.     /// 停止动画，将位置设为初始位置
  100.     /// </summary>
  101.     public void Stop()
  102.     {
  103.         Pause();
  104.         Reset();
  105.     }
  106.  
  107.     //每次显示时，初始化当前帧数
  108.     private void OnEnable()
  109.     {
  110.         Reset();
  111.     }
  112.  
  113.     void Start()
  114.     {
  115.         image = GetComponent<RawImage>();
  116.  
  117.         //初始化精灵体数组
  118.         frames = new Texture[_framesCount];
  119.         for (int i = 0; i < _framesCount; i++)
  120.             frames[i] = Resources.Load<Texture>(_folderPath + "/" + _framesName + i);
  121. #if UNITY_EDITOR
  122.         if (image == null)
  123.         {
  124.             Debug.LogWarning("No available component found. 'RawImage' required.", this.gameObject);
  125.         }
  126. #endif
  127.     }
  128.  
  129.     void Update()
  130.     {
  131.         //帧数据无效，禁用脚本
  132.         if (frames == null || frames.Length == 0)
  133.         {
  134.             this.enabled = false;
  135.         }
  136.         else
  137.         {
  138.             //是否允许播放
  139.             if (!PlayFrameAnimator()) return;
  140.             //从曲线值计算当前帧率
  141.             float curveValue = curve.Evaluate((float)currentFrameIndex / frames.Length);
  142.             float curvedFramerate = curveValue * framerate;
  143.             //帧率有效
  144.             if (curvedFramerate != 0)
  145.             {
  146.                 //获取当前时间
  147.                 float time = ignoreTimeScale ? Time.unscaledTime : Time.time;
  148.                 //计算帧间隔时间
  149.                 float interval = Mathf.Abs(1.0f / curvedFramerate);
  150.                 //满足更新条件，执行更新操作
  151.                 if (time - timer > interval)
  152.                 {
  153.                     //执行更新操作
  154.                     DoUpdate();
  155.                 }
  156.             }
  157. #if UNITY_EDITOR
  158.             else
  159.             {
  160.                 Debug.LogWarning("Framerate got '0' value, animation stopped.");
  161.             }
  162. #endif
  163.         }
  164.     }
  165.  
  166.     /// <summary>
  167.     /// 判断是否允许播放
  168.     /// </summary>
  169.     /// <returns>是否允许播放</returns>
  170.     public bool PlayFrameAnimator()
  171.     {
  172.         return _isPlayFrameAnimator;
  173.     }
  174.  
  175.     //具体更新操作
  176.     private void DoUpdate()
  177.     {
  178.         //计算新的索引
  179.         int nextIndex = currentFrameIndex + (int)Mathf.Sign(currentFramerate);
  180.         //索引越界，表示已经到结束帧
  181.         if (nextIndex < 0 || nextIndex >= frames.Length)
  182.         {
  183.             //广播事件
  184.             if (FinishEvent != null)
  185.             {
  186.                 FinishEvent();
  187.             }
  188.             //非循环模式，禁用脚本
  189.             if (loop == false)
  190.             {
  191.                 currentFrameIndex = Mathf.Clamp(currentFrameIndex, 0, frames.Length - 1);
  192.                 this.enabled = false;
  193.                 return;
  194.             }
  195.         }
  196.         //钳制索引
  197.         currentFrameIndex = nextIndex % frames.Length;
  198.         //更新图片
  199.         if (image != null)
  200.         {
  201.             image.texture = frames[currentFrameIndex];
  202.         }
  203.         //设置计时器为当前时间
  204.         timer = ignoreTimeScale ? Time.unscaledTime : Time.time;
  205.     }
  206. }

最近有空，之前的脚本其实倒放（原版的也不行）有问题，我一直不知道，现在重新码一遍吧~把一些不常用的功能取消了，并优化了下，要是用到什么动画曲线来调帧率的话，还是选择上面的脚本好一些

  1. using UnityEngine;
  2. using UnityEngine.UI;
  3.  
  4.  
  5. /*
  6.  * 
  7.  *  Writer:June（改）
  8.  * 
  9.  *  Date: 2020.6.6
  10.  * 
  11.  *  Function:序列帧动画播放器
  12.  * 
  13.  *  Remarks:支持Image和SpriteRenderer
  14.  * 
  15.  */
  16.  
  17.  
  18. public class FrameAnimatorPlayScript : MonoBehaviour
  19. {
  20.     /// <summary>
  21.     /// 序列帧帧数
  22.     /// </summary>
  23.     private int _framesCount;
  24.     /// <summary>
  25.     /// 序列帧名字前半部分  例如： image_1.jpg中的   image_为前半部分
  26.     /// </summary>
  27.     public string _framesName;
  28.     /// <summary>
  29.     /// resource文件夹下的文件夹路径 例如：Resources/Test/Sprites  则直接赋值  Test/Sprites   序列帧放在Sprites文件夹下就好
  30.     /// </summary>
  31.     public string _folderPath;
  32.     /// <summary>
  33.     /// 序列帧精灵体数组
  34.     /// </summary>
  35.     private Sprite[] frames = null;
  36.     /// <summary>
  37.     /// 帧率
  38.     /// </summary>
  39.     public float Framerate { get { return framerate; } set { framerate = value; } }
  40.     [Range(20, 60)]
  41.     [SerializeField] private float framerate = 20.0f;
  42.     /// <summary>
  43.     /// 是否忽略timeScale
  44.     /// </summary>
  45.     public bool IgnoreTimeScale { get { return ignoreTimeScale; } set { ignoreTimeScale = value; } }
  46.     [SerializeField] private bool ignoreTimeScale = true;
  47.     /// <summary>
  48.     /// 是否循环
  49.     /// </summary>
  50.     [SerializeField] private bool loop = true;
  51.     public bool Loop { get { return loop; } set { loop = value; } }
  52.     //目标Image组件
  53.     private Image image;
  54.     //目标SpriteRenderer组件
  55.     private SpriteRenderer spriteRenderer;
  56.     //当前帧索引
  57.     private int FrameIndex = 0;
  58.     //下一次更新时间
  59.     private float timer = 0.0f;
  60.     /// <summary>
  61.     /// 是否倒放
  62.     /// </summary>
  63.     public bool IsRewind { get; private set; }
  64.     /// <summary>
  65.     /// 播放状态
  66.     /// </summary>
  67.     public bool IsPlay { get; private set; }
  68.  
  69.  
  70.     /// <summary>
  71.     /// 倒放
  72.     /// </summary>
  73.     public void PlayBackward()
  74.     {
  75.         //循环状态下先把循环关掉，倒放不能循环
  76.         if (loop) loop = false;
  77.         IsRewind = true;
  78.         IsPlay = true;
  79.     }
  80.  
  81.     /// <summary>
  82.     /// 重设动画
  83.     /// </summary>
  84.     public void Reset()
  85.     {
  86.         FrameIndex = IsRewind ? _framesCount - 1 : 0;
  87.     }
  88.  
  89.     /// <summary>
  90.     /// 从停止的位置播放动画
  91.     /// </summary>
  92.     public void PlayForward()
  93.     {
  94.         IsRewind = false;
  95.         IsPlay = true;
  96.     }
  97.  
  98.     /// <summary>
  99.     /// 暂停动画
  100.     /// </summary>
  101.     public void Pause() { IsPlay = false; }
  102.  
  103.     /// <summary>
  104.     /// 停止动画，将位置设为初始位置
  105.     /// </summary>
  106.     public void Stop()
  107.     {
  108.         Pause();
  109.         Reset();
  110.     }
  111.  
  112.     //获取序列帧
  113.     void Start()
  114.     {
  115.         image = GetComponent<Image>();
  116.         spriteRenderer = GetComponent<SpriteRenderer>();
  117.         if (image == null && spriteRenderer == null)
  118.         {
  119.             Debug.LogError("没找到组件", gameObject);
  120.         }
  121.         //读序列帧
  122.         ReadFrames();
  123.     }
  124.  
  125.  
  126.     /// <summary>
  127.     /// 动态读取序列帧
  128.     /// </summary>
  129.     private void ReadFrames()
  130.     {
  131.         //文件夹中的图片数
  132.         _framesCount = GetCountInFolder(Application.dataPath + "/Resources/" + _folderPath);
  133.         //初始化精灵体数组
  134.         frames = new Sprite[_framesCount];
  135.         for (int i = 0; i < frames.Length; i++)
  136.             frames[i] = Resources.Load<Sprite>(_folderPath + "/" + _framesName + i) as Sprite;
  137.     }
  138.  
  139.  
  140.     /// <summary>
  141.     /// 获取文件夹内文件数（不包括meta文件）
  142.     /// </summary>
  143.     /// <param name="_path">目标路径</param>
  144.     /// <returns>文件数</returns>
  145.     private int GetCountInFolder(string _path)
  146.     {
  147.         int _folderNumberSum = 0;
  148.         string[] fileList = System.IO.Directory.GetFileSystemEntries(_path);
  149.         foreach (string item in fileList)
  150.         {
  151.             if (!item.Contains(".meta"))
  152.                 _folderNumberSum++;
  153.         }
  154.         return _folderNumberSum;
  155.     }
  156.  
  157.  
  158.     void Update()
  159.     {
  160.         //帧数据无效，禁用脚本
  161.         if (frames == null || frames.Length == 0 || !IsPlay) return;
  162.         //帧率有效     控制帧率
  163.         if (framerate != 0)
  164.         {
  165.             //获取当前时间
  166.             float time = ignoreTimeScale ? Time.unscaledTime : Time.time;
  167.             //计算帧间隔时间
  168.             float interval = Mathf.Abs(1.0f / framerate);
  169.             //满足更新条件，执行更新操作
  170.             if (time - timer > interval)
  171.             {
  172.                 //执行更新操作
  173.                 DoUpdate();
  174.             }
  175.         }
  176.         else Debug.LogError("帧率必须大于0");
  177.     }
  178.  
  179.     //具体更新操作
  180.     private void DoUpdate()
  181.     {
  182.         //是否打开循环
  183.         if (!loop)
  184.         {
  185.             FrameIndex = Mathf.Clamp(FrameIndex, 0, frames.Length - 1);
  186.             //正向播放判断||倒放判断
  187.             if ((!IsRewind && FrameIndex == (frames.Length - 1)) || (IsRewind && FrameIndex == 0))
  188.             {
  189.                 IsPlay = false;
  190.                 return;
  191.             }
  192.         }
  193.         //帧数赋值，更新图片
  194.         if (image != null) image.sprite = frames[FrameIndex];
  195.         if (spriteRenderer != null) spriteRenderer.sprite = frames[FrameIndex];
  196.         if (!IsRewind) FrameIndex++;//正向播放索引自增
  197.         else
  198.         {
  199.             FrameIndex--;//倒放，索引自减
  200.             if (FrameIndex < 0) FrameIndex = 0;
  201.         }
  202.         FrameIndex = FrameIndex % frames.Length;
  203.         //设置计时器为当前时间
  204.         timer = ignoreTimeScale ? Time.unscaledTime : Time.time;
  205.     }
  206. }

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/138302
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号