绒毛/短毛渲染

已于 2023-04-21 14:37:21 修改
阅读量659 收藏 1
点赞数 1
分类专栏： 毛发 文章标签： unity 游戏引擎 图形渲染
于 2023-04-20 16:03:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dogman_/article/details/129886440
版权

文章目录

refer：
腾讯游戏学堂
主要来自这里，感谢讲解！

  • 首先说一点，很多文章都把毛发和头发弄混，根本就不是一回事好吧，为了区分，我的两篇文章分别用了长毛短毛来区分

多层毛发模型

1

  • 关于这个模型，大部分文章都会引用这张图，图很好，但是原论文中单独的一张图放到这里，完全没有语境，让人看着非常费解，并且和Unity的实现有一点区别；
  • 这里我把原图的注释翻译并且重写了，希望能帮助你理解这个模型：

当然直接一张图是看不明白的，这里我来用通俗的话来讲明白这个多层毛发模型


2

首先，真实世界的毛发是这样的：

  1. 圆柱形，越靠近末端越细，直到尖尖
  2. 透光，越细越透光（不是因为其有间隙才透光，而是毛发本身就是半透明的）
  3. 虽然透光，但是不是完全透光，因此毛发的根部收到的光照更少

也就是如下这样：
在这里插入图片描述

现实中的毛发就是这样，但是我们不可能去真的一根根建模
于是讨巧的模拟毛发的算法便被提出：
纹理很好用，我们想把所有的毛发信息记录在纹理中，但是纹理只是2维的，如何记录三维的毛发信息呢？
不卖关子，做法就是用很多层纹理叠起来，把毛发分段记录下来：
在这里插入图片描述

  • 只不过这毛发不是实体的，而是分层的面片，侧面看会露馅，不过好解决，只要层数足够多，就可以掩盖这一点
    在这里插入图片描述

  • 将没有毛发的空袭部分alpha值记为0，就像是用透明度这个工具一点点雕刻，这样便可以雕刻出毛皮的样子

  • 至于具体怎么去雕刻毛发，去看下面的代码实现

  • 另外前面还有说到毛发是会透光的，那么我们在渲染的时候就可以修改其透明度，越靠近末梢越透明

  • 我还说到毛发根部受到的光更少，这个现象我们用环境光遮蔽来实现



3

这样一来，便将渲染毛发这种听起来不可思议的事情，转化成了渲染一堆叠起来的纹理了，这听起来就实际多了，不过这仍然会消耗大量的算力

尽管开销很大，但这也是当前渲染毛发最好的方法了（实时），别的开销更大
感兴趣可以看一下这位UP的案例，个人觉得超棒

因为开销很大，所有在性能调优方面就极为重要

  • 王者荣耀中妲己的角色展示界面，其尾巴就是用的这个模型，而其在绝大部分移动平台上都可以流程运行，效果还很棒，说明优化很到位
  • 如果每一层都调用一个pass去绘制的话太浪费了，应该使用实例化（GPU instance）来减少调用，实例化可以看learnopengl，讲的很好
  • 通过改变毛发的形状，可以在较少的层级下接近更多层级的效果：

  • 环境光遮蔽，添加与否的差别，个人觉得差距还挺大的

                 


代码实现

先放出本代码的最终效果

微观细节：

  • 可以看到是一片一片的组成的毛发
    在这里插入图片描述

一点补充说明：

  • 我用了很笨的方法，一个Pass挤出一层，所以我调用了非常多的Pass，性能开销很大，应该用实例化，但是还没学到，学到了来补
  • 由于大量的重复Pass，因此将着色器的主体写在了cginc中，调用即可
  • 另外上图是没有进行任何光照运算的结果（除了AO），本人在尝试用phong进行光照时，效果非常奇怪，推测是多层透明的影响，毕竟本文是讲毛发的，光照不再讨论了，这部分我以后再尝试不同的光照模型（主要试试各向异性的模型，如kajiya）




cginc

就不逐行写注释了，主要的要点如下：

  • v2f vert_fur(appdata v, float layer_offset)
    注意这个，cginc中的vert和frag可以传入参数，这也就是毛发模型能够在每一层细微调整的关键（每个pass的参数不一样，直接properties导入太多太复杂）
  • alpha = step(layer_offset, alpha);
    这个是雕刻毛发的关键，step函数是：step(a,x); x<a 返回0 x>=0 返回1；而step中的alpha是从噪声图中读取的
  • alpha *= (1-layer_offset);
    逐层进行透明度衰减
  • col.xyz *= pow(layer_offset, _AO ); 进行环境光遮蔽，AO具体可以看我的这篇文章（还没写，新坑）
#ifndef FUR_INCLUDE
#define FUR_INCLUDE

#include "UnityCG.cginc"
#include "Lighting.cginc"

struct appdata
{
    float3 normal : NORMAL;
    float4 vertex : POSITION;
    float2 uv : TEXCOORD0;
};

struct v2f
{
    float2 uv : TEXCOORD0;
    float2 uv_layer : TEXCOORD1;
    float4 vertex : SV_POSITION;
};

float _Length;
sampler2D _MainTex;
sampler2D _LayerMap;
float4 _MainTex_ST;
float4 _LayerMap_ST;
float _AO;

v2f vert_fur(appdata v, float layer_offset)
{
    v2f o;
    v.vertex.xyz += v.normal * _Length * layer_offset;
    o.vertex = UnityObjectToClipPos(v.vertex);
    o.uv = TRANSFORM_TEX(v.uv, _MainTex);
    o.uv_layer = TRANSFORM_TEX(v.uv, _LayerMap);

    return o;
}

fixed4 frag_fur(v2f i, float layer_offset) 
{
    float alpha = tex2D(_LayerMap, i.uv_layer).r;//读取layer纹理
    
    alpha = step(layer_offset, alpha); //雕刻毛发
    alpha *= 1-layer_offset; //透明度衰减计算
    fixed4 col = fixed4(tex2D(_MainTex, i.uv).rgb, alpha);//应用上述得到的透明度
    
    col.xyz *= pow(layer_offset, _AO ); //AO计算

    return col;
}

#endif




shader

Shader "Unlit/fur"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _LayerMap ("Layer map", 2D) = "white"{}
        _Length ("fur length", range(0,1)) = 0.5
        _AO ("AO", range(0,1)) = 0.5
    }
    SubShader
    {
        Tags { "RenderType"="Transparent" "Queue" = "Transparent"}
        Blend SrcAlpha OneMinusSrcAlpha


        Cull off



        Pass{
            CGPROGRAM
            #pragma vertex vert0
            #pragma fragment frag0
            #include "layers.cginc"

            v2f vert0(appdata v){return vert_fur(v,0);}
            fixed4 frag0(v2f i):SV_TARGET{return frag_fur(i,0);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert1
            #pragma fragment frag1
            #include "layers.cginc"

            v2f vert1(appdata v){return vert_fur(v,0.01);}
            fixed4 frag1(v2f i):SV_TARGET{return frag_fur(i,0.01);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert2
            #pragma fragment frag2
            #include "layers.cginc"

            v2f vert2(appdata v){return vert_fur(v,0.02);}
            fixed4 frag2(v2f i):SV_TARGET{return frag_fur(i,0.02);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert3
            #pragma fragment frag3
            #include "layers.cginc"

            v2f vert3(appdata v){return vert_fur(v,0.03);}
            fixed4 frag3(v2f i):SV_TARGET{return frag_fur(i,0.03);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert4
            #pragma fragment frag4
            #include "layers.cginc"

            v2f vert4(appdata v){return vert_fur(v,0.04);}
            fixed4 frag4(v2f i):SV_TARGET{return frag_fur(i,0.04);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert5
            #pragma fragment frag5
            #include "layers.cginc"

            v2f vert5(appdata v){return vert_fur(v,0.05);}
            fixed4 frag5(v2f i):SV_TARGET{return frag_fur(i,0.05);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert6
            #pragma fragment frag6
            #include "layers.cginc"

            v2f vert6(appdata v){return vert_fur(v,0.06);}
            fixed4 frag6(v2f i):SV_TARGET{return frag_fur(i,0.06);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert7
            #pragma fragment frag7
            #include "layers.cginc"

            v2f vert7(appdata v){return vert_fur(v,0.07);}
            fixed4 frag7(v2f i):SV_TARGET{return frag_fur(i,0.07);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert8
            #pragma fragment frag8
            #include "layers.cginc"

            v2f vert8(appdata v){return vert_fur(v,0.08);}
            fixed4 frag8(v2f i):SV_TARGET{return frag_fur(i,0.08);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert9
            #pragma fragment frag9
            #include "layers.cginc"

            v2f vert9(appdata v){return vert_fur(v,0.09);}
            fixed4 frag9(v2f i):SV_TARGET{return frag_fur(i,0.09);}

            ENDCG
        }
       Pass{
            CGPROGRAM
            #pragma vertex vert10
            #pragma fragment frag10
            #include "layers.cginc"

            v2f vert10(appdata v){return vert_fur(v,0.10);}
            fixed4 frag10(v2f i):SV_TARGET{return frag_fur(i,0.1);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert11
            #pragma fragment frag11
            #include "layers.cginc"

            v2f vert11(appdata v){return vert_fur(v,0.11);}
            fixed4 frag11(v2f i):SV_TARGET{return frag_fur(i,0.11);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert12
            #pragma fragment frag12
            #include "layers.cginc"

            v2f vert12(appdata v){return vert_fur(v,0.12);}
            fixed4 frag12(v2f i):SV_TARGET{return frag_fur(i,0.12);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert13
            #pragma fragment frag13
            #include "layers.cginc"

            v2f vert13(appdata v){return vert_fur(v,0.13);}
            fixed4 frag13(v2f i):SV_TARGET{return frag_fur(i,0.13);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert14
            #pragma fragment frag14
            #include "layers.cginc"

            v2f vert14(appdata v){return vert_fur(v,0.14);}
            fixed4 frag14(v2f i):SV_TARGET{return frag_fur(i,0.14);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert15
            #pragma fragment frag15
            #include "layers.cginc"

            v2f vert15(appdata v){return vert_fur(v,0.15);}
            fixed4 frag15(v2f i):SV_TARGET{return frag_fur(i,0.15);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert16
            #pragma fragment frag16
            #include "layers.cginc"

            v2f vert16(appdata v){return vert_fur(v,0.16);}
            fixed4 frag16(v2f i):SV_TARGET{return frag_fur(i,0.16);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert17
            #pragma fragment frag17
            #include "layers.cginc"

            v2f vert17(appdata v){return vert_fur(v,0.17);}
            fixed4 frag17(v2f i):SV_TARGET{return frag_fur(i,0.17);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert18
            #pragma fragment frag18
            #include "layers.cginc"

            v2f vert18(appdata v){return vert_fur(v,0.18);}
            fixed4 frag18(v2f i):SV_TARGET{return frag_fur(i,0.18);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert19
            #pragma fragment frag19
            #include "layers.cginc"

            v2f vert19(appdata v){return vert_fur(v,0.19);}
            fixed4 frag19(v2f i):SV_TARGET{return frag_fur(i,0.19);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert20
            #pragma fragment frag20
            #include "layers.cginc"

            v2f vert20(appdata v){return vert_fur(v,0.20);}
            fixed4 frag20(v2f i):SV_TARGET{return frag_fur(i,0.20);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert21
            #pragma fragment frag21
            #include "layers.cginc"

            v2f vert21(appdata v){return vert_fur(v,0.21);}
            fixed4 frag21(v2f i):SV_TARGET{return frag_fur(i,0.21);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert22
            #pragma fragment frag22
            #include "layers.cginc"

            v2f vert22(appdata v){return vert_fur(v,0.22);}
            fixed4 frag22(v2f i):SV_TARGET{return frag_fur(i,0.22);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert23
            #pragma fragment frag23
            #include "layers.cginc"

            v2f vert23(appdata v){return vert_fur(v,0.23);}
            fixed4 frag23(v2f i):SV_TARGET{return frag_fur(i,0.23);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert24
            #pragma fragment frag24
            #include "layers.cginc"

            v2f vert24(appdata v){return vert_fur(v,0.24);}
            fixed4 frag24(v2f i):SV_TARGET{return frag_fur(i,0.24);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert25
            #pragma fragment frag25
            #include "layers.cginc"

            v2f vert25(appdata v){return vert_fur(v,0.25);}
            fixed4 frag25(v2f i):SV_TARGET{return frag_fur(i,0.25);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert26
            #pragma fragment frag26
            #include "layers.cginc"

            v2f vert26(appdata v){return vert_fur(v,0.26);}
            fixed4 frag26(v2f i):SV_TARGET{return frag_fur(i,0.26);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert27
            #pragma fragment frag27
            #include "layers.cginc"

            v2f vert27(appdata v){return vert_fur(v,0.27);}
            fixed4 frag27(v2f i):SV_TARGET{return frag_fur(i,0.27);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert28
            #pragma fragment frag28
            #include "layers.cginc"

            v2f vert28(appdata v){return vert_fur(v,0.28);}
            fixed4 frag28(v2f i):SV_TARGET{return frag_fur(i,0.28);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert29
            #pragma fragment frag29
            #include "layers.cginc"

            v2f vert29(appdata v){return vert_fur(v,0.29);}
            fixed4 frag29(v2f i):SV_TARGET{return frag_fur(i,0.29);}

            ENDCG
        }
        Pass{
            CGPROGRAM
            #pragma vertex vert30
            #pragma fragment frag30
            #include "layers.cginc"

            v2f vert30(appdata v){return vert_fur(v,0.3);}
            fixed4 frag30(v2f i):SV_TARGET{return frag_fur(i,0.3);}

            ENDCG
        }
    }

}
狗狗人
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
opencloth:在OpenGL中实现布料模拟算法的源代码集合-Source code collection
03-24
#OpenCloth此项目先前托管在Google代码上。 现在，Google代码将逐步淘汰，我们已将存储库移至github。 #Introduction介绍基于OpenGL的布料模拟代码库。 我们以尽可能简单的方法来实现所有现有的布料模拟算法，以使学习者可以确切地知道要使布料模拟系统在OpenGL中运行并以最小的麻烦进行到底需要什么。 OpenCloth项目的启动是为了帮助初学者和研究人员使用OpenGL API实现布料模拟的基本算法。 它不打算作为另一个可以直接插入游戏引擎的库。 相反，您可以从中学习，然后在自己的游戏/物理引擎中实施一种或两种技术。 稍加努力，就可以直接在其他平台和Graphics API上实现所讨论的算法。 重点在于如何处理实施这些技术所需的最低限度的费用。 而不是将代码包装到类中，我们将整个代码实现在一个源文件中。 ＃使用OpenCloth M.Vo，SG Na
使用曲面细分渲染毛发
qq_22393417的专栏
12-04 1024
使用曲面细分渲染毛发 original link 几周前，我无意间找到了一篇让很有趣的论文，主要讲述的是使用曲面细分技术去渲染头发，并且是在Direct3D 11类型的GPU上。这是我多年前在曲面细分技术上的实践，那时候我也才刚接触D3D11，当时就在尝试基于曲面细分技术的毛发渲染。那时候，我各种收集和挖掘有关资料，同时也决定将它发布在博客中，说不定会有人对它感兴趣。 在开始之前，我会先简短的对曲面细分进行一个总结，当然了，如果你很了解这部分知识，你可以直接跳过，请随意。 曲面细分 101 曲面细分(tes
【unity shader】毛发材质、绒毛材质着色器
又渲染又建模的一般通过工科绘画人的BLOG
12-11 2596
unity shader：通过多pass实现绒毛材质
绒毛
02-23
民意调查 Epicodus学校为期两天的项目，与Firestore，React和Redux合作 Zahnen Garner，David Sterry和Danielle Thompson 项目开始于2.22.21。 最后更新2.23.21。 保持联系 ...已知错误 目前没有已知的错误。...
绒毛芯
03-04
Vivliostyle核心 ... :globe_showing_Asia-Australia: :open_book: :handshake: 将Vivliostyle Core集成到您的项目中 npm install @vivliostyle/core 请参阅。 使用Vivliostyle Core的Vivliostyle官方软件包 ...
毛皮渲染(带源码例程)
07-11
在Unity3D中，毛皮渲染通常采用"Shell"方式来实现，这种方法尤其适用于表现短毛的细节。 Shell渲染的核心在于通过在顶点着色器（VS）中沿着法线方向偏移顶点的位置，模拟毛发的厚度和层次感。首先进行一次基本的...
Clojure绒毛作用
02-02
Clojure Lint Action（使用clj-kondo） 运行clj-kondo并在结果中注释源代码更改。 用法 steps : - uses : actions/checkout@v1 - uses : DeLaGuardo/clojure-lint-action@master with : clj-kondo-args : --...
vary渲染参数 玻璃 布料 等
06-29
- **绒毛**：通过添加绒毛效果来模拟毛织物或绒面布。 - **纤维**：设置纤维方向和密度，影响布料的质感和光泽。 在渲染参数中，还有其他重要设置，如全局光照、灯光、阴影、抗锯齿、运动模糊等。全局光照（GI）...
maya制作“魔法绒毛”
04-19
maya制作“魔法绒毛”一个制作maya静帧的文档教程，是个思路问题！
利用OpenGL渲染写出毛笔字的算法
10-13
一个做毛笔模拟的小程序，对于非真实感图形学很有用 利用VC++实现，调用opengl的库进行渲染 （网络转载，非本人原创，并向原作者致敬）
unity shader - 毛发渲染，飘逸的毛发
alla_Candy的博客
11-20 8038
渲染原理： 第一步： 分层layer，渲染不同长度的毛发。 层越多，绘制的越细节。 因为毛发有长短，所以，在上层，没有毛发的部分alpha设置为0，不显示 多个layer，可以使用shader等多个pass进行绘制 每一个 Pass 即表示一层。当渲染每一层时，使用法线将顶点位置挤出模型表面 第二步： 根据噪音贴图， 在随机毛发的长度。控制alpha的值 层次不同，毛发的uv位置偏移应该也有所不同，这样制作的才能更自然，否则uv一直不变，那么毛发的方向不变就变成了刺猬 毛发..
OpenGL Fur Rendering毛发渲染的实例
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-25 626
OpenGL Fur Rendering毛发渲染先上图，再解答。完整主要的源代码源代码剖析 先上图，再解答。 完整主要的源代码 #include "vapp.h" #include "vutils.h" #include "vbm.h" #include "vmath.h" #include <stdio.h> #include <stdlib.h> BEGIN_APP_DECLARATION(FurApplication) // Override functions fr
一张GPU实时模拟布料碰撞特效，元宇宙时装秀栩栩如生，王华民团队最新成果 | SIGGRAPH 2022...
量子位
05-23 650
杨净 发自 凹非寺量子位 | 公众号 QbitAI在元宇宙里看时装秀，会是什么赶脚？各种布料摩擦细节，不光看得一清二楚，而且就跟真的一样。裙摆随着模特的走动飞舞起来~光是看看，就能知道这件衣服是不是轻盈。这是图形学大牛王华民团队的最新成果，提出了一个基于GPU的预处理器MAS，一张GPU完成实时布料碰撞特效。比如这件羊毛大衣，就能以每秒37帧的速度实时模拟出来，仿真精度可...
毛发渲染之fin方法
最新发布
qq_40924071的博客
07-09 352
实现毛发着色器的方法有多种，其中最常用的是shell方法和fin方法。Fin方法通过在多边形表面上添加垂直于表面的许多细长几何体，然后在这些几何体上贴上毛发纹理来表现毛发的外观。这个方法的概念就像在多边形上“种植”许多“鱼鳍”一样。通过将许多细长的几何体放置在多边形表面上，可以模拟出毛发的外观，并使用毛发纹理来增加细节和真实感。这种方法允许毛发与光线进行交互，并在每个几何体上进行光照和阴影计算，从而实现更加逼真的毛发效果。关于Fin方法中毛发表现的光照处理，有许多不同的方法被提出。
[Shader] Shader Cookbook 高级着色技术[9]
unity尧明的博客
11-20 387
本章将介绍一些你可以在游戏中使用的高级着色器技术。你应该记住，你在游戏中看到的许多最引人注目的效果都是通过测试着色器的极限而产生的。这本书为你提供了修改和创建着色器的技术基础，但强烈鼓励你尽可能多地玩和实验它们。制作一款优秀的游戏并不是为了追求真实感;你不应该带着复制现实的意图接近着色器，因为这是不可能发生的。相反地，你应该尝试着将着色器作为一种工具去创造出真正独特的游戏。有了本章的知识，你将能够创建你想要的材质。
毛发渲染（一）--基于多pass透明混合
微小的鱼的博客
12-30 1820
移动端毛发的渲染，主要是通过多pass实现。只能模拟短发，动物的毛发，无法模拟长发。
unity urp 实现衣服绒毛效果
现在学习也不晚
11-02 3078
接下来，到了重点了，就是为什么要用dcc生成的模型，那是我们是为了要用模型生成深度信息，如果你是在renderFeature里面去做，是没有多pass的深度和法向的，效果肯定不如这个。接下来处理最下面的那层基础的衣服不显示的问题，我们使用step以0.01进行区分，最下面一层是0，比0.01的值小的alpha直接使用1，比0.01大的我们还是使用之前的结果。在模型编辑器里面的制作是为了实现模型的多次复制，然后将其顶点颜色修改进行分层，比如，最低层的使用颜色为0，最外层的颜色为1，中间就线性过渡就好。
gb/t 8567-2006 下载
07-03
该标准的全称是《绒毛纺织品染色牢度试验方法》。它规定了对绒毛纺织品进行染色牢度试验的方法和要求。 GB/T 8567-2006标准包括了实验室条件的要求、试样的准备、试剂的使用、试验过程的步骤、测试结果的评价等内容...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值