动画帧管理

于 2024-04-28 11:52:18 发布
阅读量178 收藏
点赞数 3
分类专栏： Unity unity animation 动画帧 文章标签： unity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53049789/article/details/138270876
版权

在我们进行开发时，需要对物体进行动画帧处理，常规处理方式为创建animation，对animation进行处理
在这里插入图片描述

这是通过脚本对图片进行控制

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Networking;
using UnityEngine.UI;


public enum LoadMode
{
    Resources,
    StreamingAssets,
    AssetBundle
}

public enum PlayMode
{
    None,
    Normal,
    Inverse,
}

[RequireComponent(typeof(RawImage))]
public class AnimationBase : MonoBehaviour, IDragHandler, IBeginDragHandler, IEndDragHandler
{
    [HideInInspector]
    public RawImage img;

    public LoadMode loadMode;

    [SerializeField]
    private PlayMode playMode = PlayMode.Normal;

    #region 三种加载方式共有参数
    [HideInInspector] public List<Texture> textures;
    public bool isAutoPlay;
    public bool unScaleTime;
    [Tooltip("自动播放时每张图片索引的间隔")]
    public bool canDrag;
    public float sample_Win = 30;
    private float sample;
    public string path;
    public int aniStartIndex;
    public int aniLastIndex;
    public int textureInterval = 1;
    [Tooltip("滑动时每张图片索引的间隔")]
    public int dragInterval = 1;
    //[Tooltip("图片路径中零的个数")]
    public int zeroCount;
    public float delayTime;
    public bool isLoop;
    [Tooltip("是否有间隔的循环")]
    public bool isExtendLoop;
    [Tooltip("每次循环间隔时间")]
    public float loopTime;
    private int index;
    [HideInInspector]
    public float animationTime;
    protected int dir = 1;
    private bool isPlaying;
    private DateTime startUpTime = new DateTime(1970, 1, 1, 0, 0, 0, 0);
    private double nowTime;
    public delegate void AnimationDoneEventHandler();
    /// <summary>
    /// 只播放一次的序列，序列结束事件
    /// </summary>
    public event AnimationDoneEventHandler AnimationOnceDoneEvent;
    /// <summary>
    /// 循环播放的序列，序列结束事件
    /// </summary>
    public event Action AnimationPerLoopDoneEvent;
    public event Action BeginDragEvent;
    public event Action EndDragEvent;
    public event Action OnDragEvent;
    public event Action PlayToDoneEvent;

    protected bool isDraging;
    #endregion

    #region StreamingAssets加载方式参数，存在内存泄漏问题，尽量避免使用
    / <summary>
    / 图片检索格式
    / </summary>
    //[Tooltip("图片格式，例如：png、jpg")]
    //public string pattern;
    / <summary>
    / 图片路径后缀
    / </summary>
    //[Tooltip("路径索引号后缀，例如：001_00050(-\"fs8\")")]
    [HideInInspector] public string suffix;

    private List<FileInfo> fileInfos;
    #endregion

    #region AssetBundle加载方式参数
    private AssetBundle textureBundle;
    private string[] assetsName;
    #endregion

    public int Index
    {
        set
        {
            index = value;
            if (((index == aniLastIndex - textureInterval) && playMode == PlayMode.Normal) || (index == aniStartIndex && playMode == PlayMode.Inverse))
            {
                if (isExtendLoop)
                {
                    //InitIndex();
                    ExtendLoop();
                    if (AnimationPerLoopDoneEvent != null)
                        AnimationPerLoopDoneEvent();
                }
                else if (isLoop)
                {
                    if (AnimationPerLoopDoneEvent != null)
                        AnimationPerLoopDoneEvent();
                }
            }
            if (index >= aniLastIndex && isLoop)
            {
                index = aniStartIndex;
            }
            else if (index < 0 && isLoop)
            {
                index = aniLastIndex - textureInterval;
            }
            else if (((index >= aniLastIndex - textureInterval) && !isLoop && playMode == PlayMode.Normal) || ((index <= aniStartIndex) && !isLoop && playMode == PlayMode.Inverse))
            {
                Pause();
                if (AnimationOnceDoneEvent != null)
                {
                    AnimationOnceDoneEvent();
                }
            }
        }
        get
        {
            return index;
        }
    }

    //public static AnimationBase Instance { private set; get; }

    private void OnEnable()
    {
        InitTimer();
        if (isExtendLoop)
            Play(loopTime);
    }

    private void Awake()
    {
        Init();
    }


    protected virtual void Start()
    {
        //Instance = this;
        //GetAnimationCount();
        InitIndex();
        SetSample(sample_Win);
        LoadAssetBundle();
        GetAnimationTime();
        AutoPlay();
        EnrolEvent();
    }
    private bool isOpen = false;
    public RawImage  Anim;
    public Sprite[] sprites; // 存储图片的数组 
    public static void OnButtonClicTest()
    {
        Debug.Log("666");
    }
    public void OnButtonClick()
    {
        isOpen = !isOpen;

        if (isOpen)
        {
        
     //       Debug.Log("789" + index);
            Anim.gameObject.SetActive(true);
                 
            //  Replay();
            Replay();
           
            Debug.Log("11111");
        }
        else
        {
            RawImage rawImage = GetComponent<RawImage>();
            Texture2D tex = rawImage.texture as Texture2D; //获取截图的位置和大小
             Rect rect = new Rect(0, 0, 100, 100); //创建截图
            Texture2D newTex = new Texture2D((int)rect.width, (int)rect.height); //获取截图数据
             Color[] colors = tex.GetPixels((int)rect.x, (int)rect.y, (int)rect.width, (int)rect.height); //将数据设置到新纹理中
            newTex.SetPixels(colors); //应用修改
            newTex.Apply(); //将截图设置到RawImage中 rawImage.texture = newTex;
            Anim.texture = newTex;
            index = 0;
            Anim.gameObject.SetActive(false);
            
            Debug.Log("22222");
        }
    }

    private void AutoPlay()
    {
        if (isAutoPlay)
            Play(delayTime);
    }

    private void Init()
    {
        img = GetComponent<RawImage>();
        textures = new List<Texture>();
        fileInfos = new List<FileInfo>();
        if (playMode == PlayMode.Normal)
        {
            dir = 1;
        }
        else
        {
            dir = -1;
        }

        if (loadMode == LoadMode.Resources && !string.IsNullOrEmpty(path))
        {
            Texture[] tempTex = Resources.LoadAll<Texture>(path);
            if (tempTex.Length == 0) return;
            //Array.Sort(tempTex, (a, b) => DrawNumFromString(a.name, '_').CompareTo(DrawNumFromString(b.name, '_')));
            textures.AddRange(tempTex);
            aniLastIndex = textures.Count;
        }
        else if (loadMode == LoadMode.StreamingAssets)
        {
#if UNITY_STANDALONE_WIN
            fileInfos.Clear();
            FileInfo[] files = null;
            string filePath = Application.streamingAssetsPath + "/" + path;
            files = new DirectoryInfo(filePath).GetFiles();
#endif
            //Array.Sort(files, (a, b) => DrawNumFromString(a.Name, '_').CompareTo(DrawNumFromString(b.Name, '_')));
#if UNITY_EDITOR&&!UNITY_IOS&&!UNITY_ANDROID
            if (files != null)
            {
                for (int i = 0; i < files.Length; i++)
                {
                    if (files[i].Name.Contains(".meta")) continue;
                    fileInfos.Add(files[i]);
                }
                aniLastIndex = fileInfos.Count;
            }
#elif UNITY_STANDALONE_WIN
            fileInfos.AddRange(files);
            aniLastIndex = fileInfos.Count;
#endif
        }
    }

    public void InitIndex()
    {
        Index = aniStartIndex;
    }

    private void InitTimer()
    {
        nowTime = GetUtcMiliseconds();
        timer = nowTime + sample;
    }

    protected virtual void EnrolEvent()
    {
        //AnimationDoneEvent += ExtendLoop;
    }

    protected virtual void CancelEvent()
    {
        //AnimationDoneEvent -= ExtendLoop;
    }

    private void OnDestroy()
    {
        CancelEvent();
        AssetBundle.UnloadAllAssetBundles(true);
    }

    private void ExtendLoop()
    {
        Pause();
        Play(loopTime);
    }

    protected void LoadAssetBundle()
    {
        if (loadMode == LoadMode.AssetBundle && !string.IsNullOrEmpty(path))
        {
            string tempPath = Application.streamingAssetsPath + "/" + path;
            textureBundle = AssetBundle.LoadFromFile(tempPath);
            assetsName = textureBundle.GetAllAssetNames();
            aniLastIndex = assetsName.Length;
        }
    }

    protected void LoadAnimation()
    {
        if (!isDraging)
        {
            Index += textureInterval * dir;
        }

        if (isPlayTo)
        {
            if (Index == toIndex)
            {
                Pause();
                canDrag = true;
                PlayToDoneEvent?.Invoke();
            }
        }

        if (loadMode == LoadMode.Resources)
        {
            //Texture texture = Resources.Load<Texture>(path + string.Format("{0:D" + zeroCount + "}", Index) + suffix);

            Texture texture = textures[Index];

            if (texture)
                img.texture = texture;
            else
                Debug.LogError("动画路径错误");
        }
        else if (loadMode == LoadMode.StreamingAssets)
        {
            //StartCoroutine(nameof(GetTexture), Application.streamingAssetsPath + "/" + path + string.Format("{0:D" + zeroCount + "}", Index) + suffix);

            //StartCoroutine(nameof(GetTexture), fileInfos[Index].FullName);

#if UNITY_STANDALONE_WIN
            string tempPath = Application.streamingAssetsPath + "/" + path + "/" + fileInfos[Index].Name;
            //string tempPath = Application.streamingAssetsPath + "/" + path+string.Format("{0:D"+zeroCount+"}",Index)+suffix;
#elif UNITY_IOS || UNITY_ANDROID
            string tempPath = Application.streamingAssetsPath + "/" + path+string.Format("{0:D"+zeroCount+"}",Index)+suffix;
#endif
#if UNITY_STANDALONE_WIN || UNITY_IOS
            Texture texture = LoadTexture(tempPath);

            if (texture)
            {
                img.texture = texture;
            }
            else
            {
                Debug.LogError("动画路径错误");
            }
#elif UNITY_ANDROID
            StartCoroutine(nameof(GetTexture), tempPath);
#endif

        }
        else
        {
            img.texture = textureBundle.LoadAsset<Texture>(assetsName[Index]);
        }
        Resources.UnloadUnusedAssets();
    }

    private IEnumerator GetTexture(string name)
    {
        using (UnityWebRequest uwrt = UnityWebRequestTexture.GetTexture(name))
        {
            yield return uwrt.SendWebRequest();
            if (!string.IsNullOrEmpty(uwrt.error))
            {
                Debug.LogError(uwrt.error);
            }
            else
            {
                img.texture = DownloadHandlerTexture.GetContent(uwrt);
                img.SetNativeSize();
                //System.GC.Collect();
            }
        }
    }

    private Texture LoadTexture(string path)
    {
        using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read))
        {
            fs.Seek(0, SeekOrigin.Begin);
            byte[] data = new byte[fs.Length];
            fs.Read(data, 0, data.Length);
            Texture2D texture = new Texture2D(100, 100, TextureFormat.ARGB32, false);
            texture.LoadImage(data);
            if (texture)
            {
                texture.name = Index.ToString();
                return texture;
            }
            else
            {
                return null;
            }
        }
    }

    private double timer;
    private bool isStartPlay;
    private void Update()
    {
        CheckAnimation();
    }

    private void CheckAnimation()
    {
        if (isStartPlay || isPlayTo)
        {
            nowTime = GetUtcMiliseconds();
            if (nowTime.CompareTo(timer) > 0)
            {
                timer = GetUtcMiliseconds();
                timer += sample;
                LoadAnimation();
            }
        }
    }

    private IEnumerator DelayPlay(float delay)
    {
        yield return new WaitForSeconds(delay);
        InitIndex();
        nowTime = GetUtcMiliseconds();
        timer = nowTime + sample;
        isStartPlay = true;
        isPlaying = true;
    }

    public virtual void OnBeginDrag(PointerEventData eventData)
    {
        if (!canDrag || Input.touchCount > 1) return;
        isDraging = true;
        isStartPlay = false;
        BeginDragEvent?.Invoke();
    }

    public virtual void OnDrag(PointerEventData eventData)
    {
        if (!canDrag || Input.touchCount > 1) return;

        if (eventData.delta.x < 0)
        {
            dir = -1;
            dragInterval = Mathf.Clamp(Mathf.RoundToInt(Mathf.Abs(eventData.delta.x) * Time.deltaTime), 1, 5);
            Index -= dragInterval;
        }
        else if (eventData.delta.x > 0)
        {
            dir = 1;
            dragInterval = Mathf.Clamp(Mathf.RoundToInt(eventData.delta.x * Time.deltaTime), 1, 5);
            Index += dragInterval;
        }

        if (!isLoop || !isExtendLoop)
        {
            Index = Mathf.Clamp(Index, aniStartIndex, aniLastIndex - 1);
        }
        OnDragEvent?.Invoke();
        LoadAnimation();
    }

    public virtual void OnEndDrag(PointerEventData eventData)
    {
        if (!canDrag || Input.touchCount > 1) return;
        isDraging = false;
        EndDragEvent?.Invoke();
    }

    #region ToolMethod

    private int DrawNumFromString(string str, char splitChar)
    {
        int index = str.LastIndexOf(splitChar);
        return int.Parse(System.Text.RegularExpressions.Regex.Replace(str.Substring(index), @"[^0-9]+", ""));
    }

    private double GetUtcMiliseconds()
    {
        TimeSpan ts = DateTime.UtcNow - startUpTime;
        return ts.TotalMilliseconds;
    }

    public void SetSample(float val)
    {
        sample = 1.0f / val * 1000;
        nowTime = GetUtcMiliseconds();
        timer = nowTime + sample;
    }

    public void SetAssetBundle(AssetBundle bundle)
    {
        textureBundle = bundle;
        assetsName = textureBundle.GetAllAssetNames();
        aniLastIndex = assetsName.Length;
    }

    public void SetLoadMode(LoadMode model)
    {
        loadMode = model;
    }

    public void ChangePath(string path, int aniStartIndex, int aniLastIndex)
    {
        this.path = path;
        this.aniStartIndex = aniStartIndex;
        this.aniLastIndex = aniLastIndex;
        Index = aniStartIndex;
        if (loadMode == LoadMode.StreamingAssets)
        {
#if UNITY_STANDALONE_WIN
            fileInfos.Clear();
            FileInfo[] files = null;
            string filePath = Application.streamingAssetsPath + "/" + path;
            files = new DirectoryInfo(filePath).GetFiles();
#endif
            //Array.Sort(files, (a, b) => DrawNumFromString(a.Name, '_').CompareTo(DrawNumFromString(b.Name, '_')));
#if UNITY_EDITOR&&!UNITY_IOS&&!UNITY_ANDROID
            if (files != null)
            {
                for (int i = 0; i < files.Length; i++)
                {
                    if (files[i].Name.Contains(".meta")) continue;
                    fileInfos.Add(files[i]);
                }
                this.aniLastIndex = fileInfos.Count;
            }
#elif UNITY_STANDALONE_WIN
            fileInfos.AddRange(files);
            this.aniLastIndex = fileInfos.Count;
#endif

#if UNITY_STANDALONE_WIN
            string tempPath = Application.streamingAssetsPath + "/" + path + "/" + fileInfos[Index].Name;
            //string tempPath = Application.streamingAssetsPath + "/" + path + string.Format("{0:D" + zeroCount + "}", Index) + suffix;
#elif UNITY_IOS || UNITY_ANDROID
            string tempPath = Application.streamingAssetsPath + "/" + path+ string.Format("{0:D" + zeroCount + "}", Index) + suffix;
#endif

#if UNITY_STANDALONE_WIN || UNITY_IOS
            Texture texture = LoadTexture(tempPath);

            if (texture)
                img.texture = texture;
            else
                Debug.LogError("动画路径错误");
#elif UNITY_ANDROID
            StartCoroutine(nameof(GetTexture), tempPath);
#endif
        }
        else if (loadMode == LoadMode.Resources)
        {
            textures.Clear();

            textures.AddRange(Resources.LoadAll<Texture>(path));

            this.aniLastIndex = textures.Count;

            //Texture texture = Resources.Load<Texture>(path + string.Format("{0:D" + zeroCount + "}", Index) + suffix);            

            Texture texture = textures[Index];

            if (texture)
                img.texture = texture;
            else
                Debug.LogError("动画路径错误");
        }
        else
        {
            AssetBundle.UnloadAllAssetBundles(true);
            string tempPath = Application.streamingAssetsPath + "/" + path;
            textureBundle = AssetBundle.LoadFromFile(tempPath);
            assetsName = textureBundle.GetAllAssetNames();
            this.aniLastIndex = assetsName.Length;
            img.texture = textureBundle.LoadAsset<Texture>(assetsName[Index]);
        }
        img.SetNativeSize();
        Resources.UnloadUnusedAssets();
    }

    public float GetProgress()
    {
        return Index / aniLastIndex * 1.0f;
    }

    public void GetAnimationTime()
    {
        animationTime = aniLastIndex * sample / 1000;
    }
    public void Pause()
    {
        isPlaying = false;
        isStartPlay = false;
        isPlayTo = false;
    }

    public void Play(float delay = 0, PlayMode mode = PlayMode.None)
    {
        if (isPlaying) return;
        if (mode != PlayMode.None)
            playMode = mode;
        if (playMode == PlayMode.Normal)
            dir = 1;
        else
            dir = -1;

        StopAllCoroutines();
        StartCoroutine(DelayPlay(delay));
    }

    public void Replay(float delay = 0, PlayMode mode = PlayMode.Normal)
    {
        //if (isPlaying) return;
        playMode = mode;
        if (playMode == PlayMode.Normal)
            dir = 1;
        else
            dir = -1;
        //InitIndex();
        Debug.Log("123456");
        StopAllCoroutines();
        StartCoroutine(DelayPlay(delay));
    }

    private bool isPlayTo;
    private int toIndex;
    public void PlayTo(int to, int from = 0)
    {
        if (isPlayTo) return;
        if ((to >= aniLastIndex) || (from >= aniLastIndex) || from < 0 || to < 0)
        {
            Debug.LogError("超出序列范围");
            return;
        }
        if (from != 0)
        {
            Index = from;
        }
        PlayMode mode = from <= to ? PlayMode.Normal : PlayMode.Inverse;
        SetPlayMode(mode);
        isPlayTo = true;
        canDrag = false;
        toIndex = to;
    }

    public void ClearPlayToEvent()
    {
        PlayToDoneEvent = null;
    }

    public void ClearBeginDragEvent()
    {
        BeginDragEvent = null;
    }

    public void ClearEndDragEvent()
    {
        EndDragEvent = null;
    }

    public void ClearOnDragEvent()
    {
        OnDragEvent = null;
    }

    public void ClearAllEvent()
    {
        AnimationPerLoopDoneEvent = null;
        AnimationOnceDoneEvent = null;
        BeginDragEvent = null;
        EndDragEvent = null;
        PlayToDoneEvent = null;
        OnDragEvent = null;
    }

    public void SetPlayMode(PlayMode mode)
    {
        playMode = mode;
        if (mode == PlayMode.Normal)
            dir = 1;
        else
            dir = -1;
    }

    public void SetCurrentIndex(int index)
    {
        Index = index;
    }

    public void ChangeCurtSprite()
    {
        Texture texture = textures[0];
        img.texture = texture;
    }
    #endregion
}
Mints_Wxx
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Andriod动画效果总结以及帧动画实现
fjnu_se的博客
12-15 2402
文章目录前言一、帧动画1.1概述1.2使用步骤（可见文末代码）：1.3属性介绍二、补间动画2.1概述2.2使用步骤2.3相关属性三、属性动画3.1概述3.2使用步骤3.3相关属性四.京东小哥送快递的帧动画实现4.1 导入图片资源，将其放在drawable文件夹下面4.2创建animation_list的xml4.3修改总的布局文件4.4 通过动画对象的start(),stop()方法来开启或者是停止动画 前言 安卓比较简单和基础的动画效果有三种，分别是帧动画（Drawable Animation）、补间动
制作序列帧动画
天蝎
11-06 2249
1、新建一个空白项目，并且把图片放到assets目录下的images文件夹 2、创建一个场景以及一个精灵 3、选中刚才创建的精灵，然后点击顶部的导航栏的面板-动画编辑器 4、这时候会提示说，要制作动画，需要先为当前节点添加动画组件。 5、确保选中节点，然后给改节点添加动画组件 6、添加动画组件后，会再次提示 “当前动画组件缺少clip” 这时，鼠标移到资源管理器中，选中a...
Unity 帧动画
爱上游戏开发
08-17 1882
前言 动画在游戏中是很重要的一环，通过动画，可以体现出当前角色的行为状态，带给玩家更加丰富的游戏体验 Unity中的动画具体有三种： 序列帧动画：通过快速播放一系列图片产生动画的效果，类似于Gif一样关节动画：把角色分成若干独立部分，一个部分对应一个网格模型，部分的动画连接成一 个整体的动画，角色比较灵活骨骼动画：应用最广泛的动画，结合上面两种动画形式，内部骨骼，外部蒙皮 关于骨骼动画可以查看我之前的博客，而关节动画用途比较小，往往是那些高成本的2D游戏角色动画才会用到，而在2D游戏领域，帧动画是应用最广
requestAnimationFrame 请求动画帧
别告诉我有Bug
04-02 3467
requestAnimationFrame动画请求帧-----它是一个浏览器的宏任务。 requestAnimationFrame的用法与setTimeout、setInterval很相似，只是不需要设置时间间隔而已。requestAnimationFrame使用一个回调函数作为参数，这个回调函数会在浏览器重绘之前调用。它返回一个整数，表示定时器的编号，这个值可以传递给cancelAnimationFrame用于取消这个函数的执行
css动画帧动画效果,CSS3动画之逐帧动画
weixin_39942191的博客
08-03 729
什么是逐帧动画要了解 CSS3 逐帧动画，首先要明确什么是逐帧动画。看一下维基百科中的定义：定格动画，又名逐帧动画，是一种动画技术，其原理即将每帧不同的图像连续播放，从而产生动画效果。简而言之，实现逐帧动画需要两个条件：(1)相关联的不同图像，即动画帧；(2)连续播放。我们儿时的记忆，手翻书，他所实现的就是逐帧动画：逐帧动画(图片来源：知乎)前端逐帧动画实现方案在细聊 css3 逐帧动画之前，我们...
html逐帧动画,CSS3动画之逐帧动画_html/css_WEB-ITnose
weixin_42309178的博客
06-09 591
要了解 CSS3 逐帧动画，首先要明确什么是逐帧动画。看一下 维基百科 中的定义：定格动画，又名逐帧动画，是一种动画技术，其原理即将每帧不同的图像连续播放，从而产生动画效果。简而言之，实现逐帧动画需要两个条件： (1)相关联的不同图像，即动画帧；(2)连续播放。我们儿时的记忆，手翻书，他所实现的就是逐帧动画：(图片来源： 知乎 )前端逐帧动画实现方案在细聊 css3 逐帧动画之前，我们先大致了解下...
Android 解决帧动画卡顿问题
广靓 的博客
11-30 3204
Android帧动画一次性加载会造成ui卡顿，所以就有了这份代码。通过handle队列和Bitmap复用，每次加载一张并显示，可以解决帧动画卡顿问题。   使用方法： int[] right_res_id = new int[]{R.drawable.r_00072, R.drawable.r_00073, R.drawable.r_00074, R.drawable.r_00075}; ...
android 解决帧动画卡顿情况
weixin_38117236的博客
05-22 1万+
      最近公司有一个项目需求，需要在一个特定的android设备上做一组帧动画的效果，当时感觉这个功能很容易，相信大家都知道，android的原生帧动画实现方法，但是问题就出现在这，如果使用原生的帧动画，在手机上是没有问题的，但是在公司的设备上就非常卡顿，也就是低端机，由于图片过多，效果异常卡顿，所以在这篇文章中就说一下帧动画的优化问题。      首先还是先来看一下android原生的帧动...
iOS之深入探究动画渲染降帧
热门推荐
╰つ栺尖篴夢ゞ
10-17 2万+
一、为什么要对动画降帧？ 众所周知，刷新频率越高体验越好，对于 iOS app 的刷新频率应该是越接近越 60fps 越好，主动给动画降帧，肯定会影响动画的体验。但是另一方面，我们也知道动画渲染的过程中需要消耗大量的 GPU 资源，所以给动画降帧则可以给 GPU 减负，降低 GPU 使用率峰值。 所以给动画降帧，实际上是一种用体验换性能的决策，在动画不复杂但是数量很多的情况下（比如一些弹幕动画、点赞动画），给动画降帧并不会影响动画效果，此时降帧就能累计节约大量的 GPU 性能。 二、动画渲染对性能
Unity2D创建帧动画片段
充满智慧的博客
10-06 798
动画是游戏中一种使对象表现出运动或变换的方式。当涉及到动画时，我们通常就会用到Animator组件。它允许我们在Unity编辑器中创建、管理和控制这些动画，并将其应用于游戏对象。这篇文章将对Animator组件的使用进行部分讲解。
智慧教学管理系统，框架 vs2019 + c语言 + 双向链表 + 动画帧
11-17
框架 vs2019 + c语言 + 双向链表 + 动画帧 管理员用户密码 admin 123456 教师用户密码 qqq 123456 学生 ttt 123456 模块介绍 管理员 登陆模块 教学活动 教师管理 学生管理 退出模块 教师用户 登陆模块 课程...
补间动画 帧动画 属性动画
07-28
2. **ValueAnimator**：基础动画类，用于管理动画的时间线，但不直接操作视图。开发者需要手动更新视图状态。 3. **AnimatorSet**：用于组合多个动画，可以控制动画的执行顺序和同步。 属性动画还提供了一些辅助类...
如何更改导入unity动画的关键帧
06-06
在Unity引擎中，修改导入的动画关键帧是一个常见的需求，特别是在游戏开发或交互式应用中。下面我们将详细探讨如何在Unity中更改导入的动画关键帧，以及与之相关的知识点。 首先，我们需要理解FBX文件格式。FBX是...
Android 使用帧动画内存溢出解决方案
08-31
总结来说，解决Android帧动画内存溢出的关键在于合理管理内存，包括压缩图片、分批加载和适时释放资源。通过上述的自定义类，我们能够有效地避免因一次性加载大量图片而导致的内存溢出问题，同时保持动画的流畅性。...
数据结构试题参考及答案.doc
08-29
内容概要：本资源提供了一份详尽的数据结构试题参考及答案，覆盖了从基础概念到复杂算法的多个层面。读者可以通过这份材料，系统地学习和复习数据结构的理论知识和应用实践，包括但不限于时间复杂度分析、线性表操作、树与图的遍历、排序算法等。 适合人群：适合计算机科学与技术专业的学生、准备数据结构考试或面试的研发人员，以及任何希望提升数据结构和算法知识的编程爱好者。 能学到什么： 1. 如何分析和计算算法的时间复杂度，掌握不同算法性能评估的方法。 2. 线性表的存储结构，包括顺序表和链表的特点及其操作实现。 3. 图和树的遍历算法，理解深度优先搜索和广度优先搜索的应用场景。 4. 排序算法的原理和实现，包括快速排序、归并排序等。 5. 哈希表的设计与冲突解决策略，理解哈希函数的重要性。 6. 递归算法和非递归算法的设计思想，学习如何选择合适的算法实现。 阅读建议：此资源不仅包含了数据结构的基础知识点，还提供了丰富的例题和解答，适合读者进行自我测试和深化理解。在学习过程中，建议结合实际编程实践，将理论知识应用到具体的算法实现中。同时，鼓励读者在理解的基础上，自行推导和验证答案，以加深记忆和理解。
有住网（装修小程序源码）.zip
08-29
有住网（装修小程序源码）.zip
d3dcsx_46.dll
08-29
Windows 8 SDK 此 SDK 于 2012 年 11 月发布，可用于创建适用于 Windows 8 或更早版本的 Windows 应用 () 使用 Web 技术、本机和托管代码;或使用本机或托管编程模型的桌面应用。
汇编语言I/O专题教程.ppt
最新发布
08-29
资源描述： 内容概要：《汇编语言》资源是一本深入浅出介绍汇编编程语言的教程，覆盖了从基础语法到高级程序设计技巧的全方位知识。通过本教程，读者将学习到汇编语言的基本概念、输入输出程序设计、中断处理、以及如何利用汇编语言直接控制硬件等核心内容。 适合人群：本资源适合对计算机底层工作原理感兴趣的学习者，包括计算机科学专业的学生、嵌入式系统开发者、硬件工程师以及任何希望深入理解计算机系统工作的编程爱好者。 能学到什么： 1. 汇编语言的基础知识，包括指令集、寄存器使用、内存管理等。 2. I/O设备的数据传送方式，如无条件传送、查询式传送和中断传送方式。 3. 程序直接控制I/O方式，包括I/O端口的使用、I/O指令的应用以及实际的I/O程序设计示例。 4. 中断传送方式的工作原理和实现，包括中断类型、中断向量表、中断处理过程和中断优先级管理。 5. 汇编语言在性能优化和硬件交互中的应用，以及如何编写高效的I/O程序。 6. 实际的汇编程序设计技巧，如发声程序、打印字符程序和中断处理程序的编写。 阅读建议：此资源不仅注重代码的编写实现，也强调对汇编语言程序设计背后的原理和硬件操作的理解
提供题库的创建和管理，试卷的设计和管理，考试的安排和管理，灵活的评分系统，全面的分析系统以及及时的反馈系统.zip
08-29
提供题库的创建和管理，试卷的设计和管理，考试的安排和管理，灵活的评分系统，全面的分析系统以及及时的反馈系统，为用户量身打造适合自己
Flash动画制作：帧与图层管理
本文主要介绍了在Flash中管理和操作图层及图层文件夹的方法，以及帧在动画制作中的重要性和使用技巧。 在Flash动画制作中，图层和图层文件夹是组织和管理元素的关键工具。图层允许你独立地处理动画的不同部分，而...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值