Unity3D 序列帧播放

最新推荐文章于 2025-07-04 17:57:58 发布
最新推荐文章于 2025-07-04 17:57:58 发布
阅读量1.2k 收藏 3
点赞数 2
CC 4.0 BY-SA版权
分类专栏： 脚本 文章标签： Unity3D Gif Play
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/yuyingwin/article/details/80235874

一、Image

using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Events;
using System.Collections;
using System;
[RequireComponent(typeof(Image))]
public class GifPlayer_Image : MonoBehaviour
{
    [SerializeField, Header("是否启用加载模式")]
    bool isResourcesLoading;
    [SerializeField]
    Sprite[] frames;
    [SerializeField]
    Image image;
    [SerializeField, Range(0, 30), Header("帧率")]
    float framesRatio = 25f;
    [Header("当前帧图片"), SerializeField]
    Texture2D currentFrameTex;
    [Header("序列帧路径，Resources 文件加下")]
    public string m_Path;
    [Header("最大循环帧数"), Range(0, 500)]
    public int framesMax;
    [SerializeField, Header("当前帧")]
    int frameIndex = 0;
    bool ignoreTimeScale = true;
    [SerializeField, Header("是否循环")]
    bool loop = false;
    float mUpdate = 0f;
    [SerializeField, Header("是否激活Gif")]
    bool isActive;
    [SerializeField, Header("是否使用事件")]
    bool isUsingEvent;
    public UnityEvent onComplete;
    /// <summary>
    /// Returns is the animation is still playing or not
    /// </summary>
    public bool isPlaying
    {
        get { return enabled; }
    }


    /// <summary>
    /// Real time since startup.
    /// </summary>
    public float RealTime
    {
        get { return UnityEngine.Time.unscaledTime; }
    }
    /// <summary>
    /// Real delta time.
    /// </summary>
    public float RealDeltaTime
    {
        get { return UnityEngine.Time.unscaledDeltaTime; }
    }


    public void Start()
    {
        if (!image)
        {
            image = GetComponent<Image>();
        }




    }
    public void SetActive(bool value)
    {


        isActive = value;


        int framesLength = 0;


        if (!isResourcesLoading)
        {
            framesLength = frames.Length;
        }
        else
        {
            framesLength = framesMax;
        }


        if (image != null && framesLength > 0)
        {
            if (!enabled && !loop)
            {
                int newIndex = framesRatio > 0 ? frameIndex + 1 : frameIndex - 1;


                if (newIndex < 0 || newIndex >= framesLength)
                {
                    frameIndex = framesRatio < 0 ? framesLength - 1 : 0;
                }
            }


            enabled = true;
            UpdateSprite();
        }


    }


    /// <summary>
    /// 暂停序列帧动画
    /// </summary>
    public void Pause() { enabled = false; }
    /// <summary>
    /// 继续播放
    /// </summary>
    public void GoOn() { enabled = true; }


    /// <summary>
    /// 重置序列帧事件
    /// </summary>
    public void ResetEvent()
    {
        int framesLength = 0;


        if (!isResourcesLoading)
        {
            framesLength = frames.Length;
        }
        else
        {
            framesLength = framesMax;
        }
        Resources.UnloadAsset(currentFrameTex);
        frameIndex = 0;
        frameIndex = framesRatio < 0 ? framesLength - 1 : 0;
        UpdateSprite();
        isActive = false;


    }
    /// <summary>
    /// 设置RawImage初始图片
    /// </summary>
    /// <param name="texture"></param>
    public void SetRawImageStartSprite(Sprite texture)
    {
        if (image)
        {
            image.sprite = texture;
        }
    }
    void Update()
    {
        if (isActive)
        {
            int framesLength = 0;


            if (!isResourcesLoading)
            {
                framesLength = frames.Length;
            }
            else
            {
                framesLength = framesMax;
            }


            if (framesLength == 0)
            {
                enabled = false;
            }
            else if (framesRatio != 0)
            {
                float time = ignoreTimeScale ? RealTime : Time.time;


                if (mUpdate < time)
                {
                    mUpdate = time;


                    int newIndex = framesRatio > 0 ? frameIndex + 1 : frameIndex - 1;


                    if (!loop && (newIndex < 0 || newIndex >= framesLength))
                    {
                        enabled = false;
                        return;
                    }


                    frameIndex = RepeatIndex(newIndex, framesLength);
                    UpdateSprite();
                }
            }
        }
    }
    /// <summary>
    /// 立即更新可见的精灵。
    /// </summary>
    void UpdateSprite()
    {
        if (isActive)
        {
            int framesLength = 0;


            if (!isResourcesLoading)
            {
                framesLength = frames.Length;
            }
            else
            {
                framesLength = framesMax;
            }


            float time = ignoreTimeScale ? RealTime : Time.time;


            if (framesRatio != 0)
            {
                mUpdate = time + Mathf.Abs(1f / framesRatio);
            }


            if (image != null)
            {
                if (!isResourcesLoading)
                {
                    image.sprite = frames[frameIndex];
                }
                else
                {
                    Resources.UnloadAsset(currentFrameTex);
                    currentFrameTex = (Texture2D)(Resources.Load(m_Path + "/" + frameIndex.ToString()) as Texture2D);
                    image.sprite = Sprite.Create(currentFrameTex, new Rect(0, 0, currentFrameTex.width, currentFrameTex.height), new Vector2(0.5f, 0.5f));
                }


            }


            if (!loop)
            {


                //-判断当 数字模拟完成后，要执行事件-//
                if (isUsingEvent && frameIndex == framesLength - 1)
                {
                    onComplete.Invoke();
                }
            }
        }
    }


    /// <summary>
    /// 使用重复逻辑包装索引，以便例如+1过去的结果意味着索引为'1'。
    /// </summary>
    [System.Diagnostics.DebuggerHidden]
    [System.Diagnostics.DebuggerStepThrough]
    private int RepeatIndex(int val, int max)
    {
        if (max < 1) return 0;
        while (val < 0) val += max;
        while (val >= max) val -= max;
        return val;
    }

}

二、RawImage

using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Events;
using System.Collections;
using System;
[RequireComponent(typeof(RawImage))]
public class GifPlayer_RawImage : MonoBehaviour
{
    [SerializeField, Header("是否启用加载模式")]
    bool isResourcesLoading;
    [SerializeField]
    Texture[] frames;
    [SerializeField]
    RawImage rawImage;
    [SerializeField, Range(0, 30), Header("帧率")]
    float framesRatio = 25f;
    [Header("当前帧图片"), SerializeField]
    Texture currentFrameTex;
    [Header("序列帧路径，Resources 文件加下")]
    public string m_Path;
    [Header("最大循环帧数"), Range(0, 500)]
    public int framesMax;
    [SerializeField, Header("当前帧")]
    int frameIndex = 0;
    bool ignoreTimeScale = true;
    [SerializeField, Header("是否循环")]
    bool loop = false;
    float mUpdate = 0f;
    [SerializeField, Header("是否激活Gif")]
    bool isActive;
    [SerializeField, Header("是否使用事件")]
    bool isUsingEvent;
    public UnityEvent onComplete;
    /// <summary>
    /// Returns is the animation is still playing or not
    /// </summary>
    public bool isPlaying
    {
        get { return enabled; }
    }


    /// <summary>
    /// Real time since startup.
    /// </summary>
    public float RealTime
    {
        get { return UnityEngine.Time.unscaledTime; }
    }
    /// <summary>
    /// Real delta time.
    /// </summary>
    public float RealDeltaTime
    {
        get { return UnityEngine.Time.unscaledDeltaTime; }
    }


    public void Start()
    {
        if (!rawImage)
        {
            rawImage = gameObject.GetComponent<RawImage>();
        }




    }
    public void SetActive(bool value)
    {


        isActive = value;


        int framesLength = 0;


        if (!isResourcesLoading)
        {
            framesLength = frames.Length;
        }
        else
        {
            framesLength = framesMax;
        }


        if (rawImage != null && framesLength > 0)
        {
            StopCoroutine("FrameAnimationEnd");


            if (!enabled && !loop)
            {
                int newIndex = framesRatio > 0 ? frameIndex + 1 : frameIndex - 1;


                if (newIndex < 0 || newIndex >= framesLength)
                {
                    frameIndex = framesRatio < 0 ? framesLength - 1 : 0;
                }
            }


            enabled = true;
            UpdateSprite();
        }


    }


    /// <summary>
    /// 暂停序列帧动画
    /// </summary>
    public void Pause() { enabled = false; }
    /// <summary>
    /// 继续播放
    /// </summary>
    public void GoOn() { enabled = true; }


    /// <summary>
    /// 重置序列帧事件
    /// </summary>
    public void ResetEvent()
    {
        int framesLength = 0;


        if (!isResourcesLoading)
        {
            framesLength = frames.Length;
        }
        else
        {
            framesLength = framesMax;
        }
        Resources.UnloadAsset(currentFrameTex);
        frameIndex = 0;
        frameIndex = framesRatio < 0 ? framesLength - 1 : 0;
        UpdateSprite();
        isActive = false;


    }
    /// <summary>
    /// 设置RawImage初始图片
    /// </summary>
    /// <param name="texture"></param>
    public void SetRawImageStartSprite(Texture texture)
    {
        if (rawImage)
        {
            rawImage.texture = texture;
        }
    }
    void Update()
    {
        if (isActive)
        {
            int framesLength = 0;


            if (!isResourcesLoading)
            {
                framesLength = frames.Length;
            }
            else
            {
                framesLength = framesMax;
            }


            if (framesLength == 0)
            {
                enabled = false;
            }
            else if (framesRatio != 0)
            {
                float time = ignoreTimeScale ? RealTime : Time.time;


                if (mUpdate < time)
                {
                    mUpdate = time;


                    int newIndex = framesRatio > 0 ? frameIndex + 1 : frameIndex - 1;


                    if (!loop && (newIndex < 0 || newIndex >= framesLength))
                    {
                        enabled = false;
                        return;
                    }


                    frameIndex = RepeatIndex(newIndex, framesLength);
                    UpdateSprite();
                }
            }
        }
    }
    /// <summary>
    /// 立即更新可见的精灵。
    /// </summary>
    void UpdateSprite()
    {
        if (isActive)
        {
            int framesLength = 0;


            if (!isResourcesLoading)
            {
                framesLength = frames.Length;
            }
            else
            {
                framesLength = framesMax;
            }


            float time = ignoreTimeScale ? RealTime : Time.time;


            if (framesRatio != 0)
            {
                mUpdate = time + Mathf.Abs(1f / framesRatio);
            }


            if (rawImage != null)
            {
                if (!isResourcesLoading)
                {
                    rawImage.texture = frames[frameIndex];
                }
                else
                {
                    Resources.UnloadAsset(currentFrameTex);
                    currentFrameTex = (Texture)(Resources.Load(m_Path + "/" + frameIndex.ToString()) as Texture2D);
                    rawImage.texture = currentFrameTex;
                }


            }


            if (!loop)
            {


                //-判断当 数字模拟完成后，要执行事件-//
                if (isUsingEvent && frameIndex == framesLength - 1)
                {
                    onComplete.Invoke();
                }
            }
        }
    }


    /// <summary>
    /// 使用重复逻辑包装索引，以便例如+1过去的结果意味着索引为'1'。
    /// </summary>
    [System.Diagnostics.DebuggerHidden]
    [System.Diagnostics.DebuggerStepThrough]
    private int RepeatIndex(int val, int max)
    {
        if (max < 1) return 0;
        while (val < 0) val += max;
        while (val >= max) val -= max;
        return val;
    }
}

三、Material

using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Events;
using System.Collections;
using System;
[RequireComponent(typeof(MeshRenderer))]
public class GifPlayer_Material : MonoBehaviour
{
    [SerializeField, Header("是否启用加载模式")]
    bool isResourcesLoading;
    [SerializeField, Header("序列帧数组")]
    Texture[] frames;
    [SerializeField]
    Material mat;
    [SerializeField, Range(0, 30), Header("帧率")]
    float framesRatio = 25f;
    [Header("当前帧图片"), SerializeField]
    Texture currentFrameTex;
    [Header("序列帧路径，Resources 文件加下")]
    public string m_Path;
    [Header("最大循环帧数"), Range(0, 500)]
    public int framesMax;
    [SerializeField, Header("当前帧")]
    int frameIndex = 0;
    bool ignoreTimeScale = true;
    [SerializeField, Header("是否循环")]
    bool loop = false;
    float mUpdate = 0f;
    [SerializeField, Header("是否激活Gif")]
    bool isActive;
    [SerializeField, Header("是否使用事件")]
    bool isUsingEvent;
    public UnityEvent onComplete;
    /// <summary>
    /// Returns is the animation is still playing or not
    /// </summary>
    public bool isPlaying
    {
        get { return enabled; }
    }


    /// <summary>
    /// Real time since startup.
    /// </summary>
    public float RealTime
    {
        get { return UnityEngine.Time.unscaledTime; }
    }
    /// <summary>
    /// Real delta time.
    /// </summary>
    public float RealDeltaTime
    {
        get { return UnityEngine.Time.unscaledDeltaTime; }
    }


    public void Start()
    {
        if (!mat)
        {
            mat = GetComponent<MeshRenderer>().sharedMaterial;
        }




    }
    public void SetActive(bool value)
    {


        isActive = value;


        int framesLength = 0;


        if (!isResourcesLoading)
        {
            framesLength = frames.Length;
        }
        else
        {
            framesLength = framesMax;
        }


        if (mat != null && framesLength > 0)
        {
            if (!enabled && !loop)
            {
                int newIndex = framesRatio > 0 ? frameIndex + 1 : frameIndex - 1;


                if (newIndex < 0 || newIndex >= framesLength)
                {
                    frameIndex = framesRatio < 0 ? framesLength - 1 : 0;
                }
            }


            enabled = true;
            UpdateSprite();
        }


    }


    /// <summary>
    /// 暂停序列帧动画
    /// </summary>
    public void Pause() { enabled = false; }
    /// <summary>
    /// 继续播放
    /// </summary>
    public void GoOn() { enabled = true; }


    /// <summary>
    /// 重置序列帧事件
    /// </summary>
    public void ResetEvent()
    {
        int framesLength = 0;


        if (!isResourcesLoading)
        {
            framesLength = frames.Length;
        }
        else
        {
            framesLength = framesMax;
        }
        Resources.UnloadAsset(currentFrameTex);
        frameIndex = 0;
        frameIndex = framesRatio < 0 ? framesLength - 1 : 0;
        UpdateSprite();
        isActive = false;


    }
    /// <summary>
    /// 设置RawImage初始图片
    /// </summary>
    /// <param name="texture"></param>
    public void SetRawImageStartSprite(Texture texture)
    {
        if (mat)
        {
            mat.mainTexture = texture;
        }
    }
    void Update()
    {
        if (isActive)
        {
            int framesLength = 0;


            if (!isResourcesLoading)
            {
                framesLength = frames.Length;
            }
            else
            {
                framesLength = framesMax;
            }


            if (framesLength == 0)
            {
                enabled = false;
            }
            else if (framesRatio != 0)
            {
                float time = ignoreTimeScale ? RealTime : Time.time;


                if (mUpdate < time)
                {
                    mUpdate = time;


                    int newIndex = framesRatio > 0 ? frameIndex + 1 : frameIndex - 1;


                    if (!loop && (newIndex < 0 || newIndex >= framesLength))
                    {
                        enabled = false;
                        return;
                    }


                    frameIndex = RepeatIndex(newIndex, framesLength);
                    UpdateSprite();
                }
            }
        }
    }
    /// <summary>
    /// 立即更新可见的精灵。
    /// </summary>
    void UpdateSprite()
    {
        if (isActive)
        {
            int framesLength = 0;


            if (!isResourcesLoading)
            {
                framesLength = frames.Length;
            }
            else
            {
                framesLength = framesMax;
            }


            float time = ignoreTimeScale ? RealTime : Time.time;


            if (framesRatio != 0)
            {
                mUpdate = time + Mathf.Abs(1f / framesRatio);
            }


            if (mat != null)
            {
                if (!isResourcesLoading)
                {
                    mat.mainTexture = frames[frameIndex];
                }
                else
                {
                    Resources.UnloadAsset(currentFrameTex);
                    currentFrameTex = (Texture)(Resources.Load(m_Path + "/" + frameIndex.ToString()) as Texture2D);
                    mat.mainTexture = currentFrameTex;
                }


            }


            if (!loop)
            {


                //-判断当 数字模拟完成后，要执行事件-//
                if (isUsingEvent && frameIndex == framesLength - 1)
                {
                    onComplete.Invoke();
                }
            }
        }
    }


    /// <summary>
    /// 使用重复逻辑包装索引，以便例如+1过去的结果意味着索引为'1'。
    /// </summary>
    [System.Diagnostics.DebuggerHidden]
    [System.Diagnostics.DebuggerStepThrough]
    private int RepeatIndex(int val, int max)
    {
        if (max < 1) return 0;
        while (val < 0) val += max;
        while (val >= max) val -= max;
        return val;
    }
}





 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Unity播放序列帧
Devil1997的博客
06-23 3700
在U3D中播放序列帧应该算是一个非常常见的需求了，基本做过一些正式项目的朋友或多或少都会遇到，包括我自己，所以自己就写了一个非常简单但又好用的播放序列帧的小插件，今天就拿出来给大家分享分享，话不多说直接上图撸代码！ 效果展示： 单组序列帧循环播放 多组序列帧顺序播放 OK说一下使用方法，方法很简单几张图一目了然 1.准备序列帧资源 2.在场景中给要播放的Image挂上FramesAnimation.cs脚本 3.在某个地方存储你要使用Sprite图片组（我这里为了演示图省事直接挂在
【Unity】在Unity中播放序列帧动画、播放图集动画
一个普普通通的游戏开发者
10-16 6325
本文通过两种方式播放序列动画，第一种（逐图播放）简单易操作但性能略差，第二种（图集播放）性能相对更好一些但操作相对复杂。不过还是建议使用第二种，因为第二种更适合做合理的架构，不仅仅是序列动画，平时用的 UI 资源也可以一起放到图集资源中，通过不同的名称进行获取。注意【Unity】在Unity 3D中使用Spine开发2D动画。
[Unity]在UI上循环播放序列图
PangCoder的博客
08-05 1675
一、思路 1.获取播放组件 一般我们使用UI的Raw Image或者Image来显示图片 Image：仅支持Sprite类型图片，需要更改图片的格式（注意：在StreamingAssets文件夹里的图片是更改不了类型的，在这里必须放在Assets/Resources路径下） Raw Image：支持图片的原格式，一般我们将其转换成Texture2D使用 2.加载图片 Resources提供了一个Load方法，可以从Re...
U3D 播放序列帧图片代码
09-01
U3D自动播放序列帧图片，支持序列帧的播放，暂停，停止，还有播放一次，循环播放，乒乓播放等状态。非常灵活哟~
Unity学习--2D动画--[序列帧动画]2D序列帧动画
最新发布
misco43的博客
07-04 518
摘要：Unity序列帧动画制作指南 本文介绍了Unity中制作序列帧动画的两种方法：代码控制和Animation窗口制作。通过代码方式可以动态改变SpriteRender参数实现动画效果，而Animation窗口则提供了更便捷的拖拽操作方式。文章还讲解了如何利用Animator进行动画状态控制，包括设置条件参数实现idle、run、jump等状态的切换逻辑。最后提供了常见问题的解决方案，如精灵图片无法显示的调整方法，以及序列帧轴心点的合理设置建议。制作时建议先设置好轴心点再制作动画，避免后期调整带来的不便。
Unity自定义组件之序列帧播放组件
weixin_30871905的博客
09-10 555
　　我们知道在unity中播放序列帧动画有两种方式，第一种是利用Unity自带的animation组件来播放，我们只需要在工程目录中全选选中所有我们需要播放的图片，将其拖动到Hiercarchy上，Unity就会帮我们自动创建一个animation片段，我们就可以用animation组件来控制我们的动画，不过这种方式创建的图片Sprite Renderer类型的。第二种方式就是创建一个I...
Unity代码实现序列帧动画播放器
08-26
主要为大家详细介绍了Unity代码实现序列帧动画播放器，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Unity3D逐帧播放动画脚本1
08-08
标题中的“Unity3D逐帧播放动画脚本1”指的是在Unity3D游戏引擎中，通过编写脚本来实现动画的逐帧播放功能。这种技术常用于2D游戏或某些特殊的3D动画效果，例如像素动画或者低帧率的过场动画。 描述中提到的关键点...
Unity3D制作序列帧动画的方法
12-31
unity自带的帧动画机很方便，我们首先选择所要播放序列帧动画的Image，然后在Window下选择Animation，会弹出一个动画制动的界面，我们选择Create，然后进入如下界面： 我们按照如下添加动画控制的属性， 然后将...
unity导出特效模型等动画序列帧
11-15
文件中提到的“教程_Unity导出粒子模型序列帧Png教程.docx”文件无疑是一个详细的指南，指导用户如何在Unity中操作导出粒子模型到序列帧PNG格式的完整流程。文档可能涵盖了设置动画序列、导出参数配置、以及可能遇到...
Unity中播放序列图
Alone_Qifan的博客
05-15 1387
愿明天更美好
序列帧播放(unity2020.3.15版本).zip
11-15
可以控制序列帧的播放、暂停、停止、重新播放、是否自动播放、滑动屏幕正反向播放序列帧、帧数控制、可以添加回调事件等
Unity3D_切图以及序列帧动画
10-28
在Cocos2dx中，对大图的处理已经封装好了一套自己的API，但是在Unity3D中貌似没有类似的API，或者说我没找到。不过这也在情理之中，毕竟Unity3D是做3D的，要切割图片的地方还是很少的。 因为我用Unity3D主要是用于做2D游戏的（PS：很蛋疼吧？我也觉得），所以就不得不考虑切图和播放序列帧这两个在2D上常见的功能了，下面废话不多说。我的任务是把下面这张图切割成16块，并且按照动画的序列播放出来。
unity 播放 序列帧图片 动画
qq_37524903的博客
12-09 4777
适用于一下简单的动态效果，不建议大量使用序列帧。好记性不如烂笔头！
Unity播放序列帧，功能丰富
weixin_45265453的博客
11-17 3712
Unity播放序列帧，功能丰富 话不多说，直接上代码 /*********************************** * Description：描述这是一个图片序列帧播放脚本，适用于少量的一组序列帧，且分辨率较小，若出现花屏，打包不成功等情况，请先排除序列帧分辨率过大、序列帧组数过多 * Mountpoint：将其挂载在Image组件上 * Date：2021.11 * Version： * Author：九八 ***************************
Unity自定义序列帧播放器
qq_27050589的博客
10-03 814
主要解决Animator针对序列帧动画控制重新播放和指定帧播放这些操作上的不方便
unity 代码播放序列帧动画
qq_41614248的博客
07-16 1443
using UnityEngine; using UnityEngine.UI; using System; /// <summary> /// 序列帧动画播放器 /// 支持UGUI的Image和Unity2D的SpriteRenderer /// </summary> public class FrameAnimator : MonoBehaviour { /// <summary> /// 序列帧 /// </summary&...
Unity通过偏移UV播放序列帧动画
阿赵的博客
09-02 1631
在Unity引擎里面用shader播放序列图，估计很多人都有用到了，我自己而已写过好几个版本。这里大概介绍一下。
Unity——用代码实现序列帧动画(动态加载)
小小小小羽的博客
11-14 5965
最近的项目用SpriteRenderer+Animation的方式播放序列帧，我那项目序列帧很多，项目大小差不多40G。。。 unity编辑器里是可以正常播放没问题的，但打包出去后，发现一闪一闪的，什么玩意啊。。。然后搜索了一下文章，看到个大佬写的，换成image播放序列帧就可以了。 原文链接：https://blog.youkuaiyun.com/SerenaHaven/article/details/...
Unity3D 实现序列帧动画控制教程
**Unity3D序列帧基础概念** 首先，需要了解的是序列帧动画的基本原理：通过将一系列连续动作的图片按顺序排列，并在短时间内快速连续播放，观众的视觉系统会因为视觉暂留现象，看到一个连续运动的图像效果。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值