求知若饥，虚心若愚
立方体纹理
在图形学中，立方体纹理（Cubemap） 是环境映射（Environment Mapping） 的一种实现方法。环境映射可以模拟物体周围的环境，而使用了环境映射的物体可以看起来像镀了层金属一样反射出周围的环境。除此之外还能用于天空盒子(SkyBox)。
立方体的每个面表示沿着世界空间下的轴向（上下左右前后）观察所得的图像。使用三维纹理坐标，这个方向矢量从立方体的中心出发向外部延申时，和立方体的6个我哪里之一相交，采样得到的结果就是右该交点计算而来的。
天空盒子
用于模拟背景的一种方法，大多数情况模拟天空，它是个盒子。在Unity中，天空盒子是在所有不透明物体之后渲染的，其背后使用的网格是一个立方体或一个细分后的球体。
使用内置的6Sided材质可以快速创建
TintColor：控制该材质的整体颜色
Exposure：调整天空盒子的亮度
Rotation：调整天空盒子沿+y轴方向旋转的角度
创建用于环境映射的立方体纹理
除了天空盒子，其他最常见的用处是用于环境映射。在Unity5中，创建用于环境映射的立方体纹理的方法有三种：
直接由一些特殊布局的纹理创建
手动创建一个Cubemap资源，再把6张图赋给它
脚本生成
第一种方法，要提供一张具有特殊布局的纹理。一般用HDR图像。
第二种方法是Unity5之前的方法，官方推荐第一种方法，因为可以对纹理数据压缩、支持边缘修正、HDR等功能。
第三种方法，可以根据物体在场景中位置的不同生成不同的立方体纹理。通过Camera.RenderToCubemap来实现。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 using System; using System.Collections; using System.Collections.Generic; using UnityEditor; using UnityEngine; namespace Unity_Shaders_Learn { public class RenderCubemapWizard : ScriptableWizard { public Transform renderFromPosition; public Cubemap cubemap; private void OnWizardUpdate() { helpString = "Select transform to render from and cubemap to render into"; isValid = (renderFromPosition != null) && (cubemap != null); } private void OnWizardCreate() { GameObject go = new GameObject("CubemapCamera"); var camera = go.AddComponent<Camera>(); go.transform.position = renderFromPosition.position; camera.RenderToCubemap(cubemap); DestroyImmediate(go); } [MenuItem("Tools/Render Into Cubemap")] static void RenderCubemap() { ScriptableWizard.DisplayWizard<RenderCubemapWizard>( "Render Cubemap", "Render!"); } } }
使用脚本渲染的Cubemap如下，调整FaceSize改变图像质量。环境映射最常见的应用是反射和折射。
反射
通过入射光线的方向和表面法线的方向，来计算反射方向，再利用反射方向对立方体纹理采样，来模拟反射效果。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 Shader "UnityShadersLearn/Chapter10/Reflection" { Properties { _Color ("Color", Color) = (1,1,1,1) _ReflectColor ("Reflection Color", Color) = (1,1,1,1) _ReflectAmount ("Reflect Amount", Range(0, 1)) = 1 _Cubemap ("Reflection Cubemap", Cube) = "_Skybox" {} } SubShader { Pass { Tags {"LightMode"="ForwardBase"} CGPROGRAM // 容易遗漏！不加就没有阴影 #pragma multi_compile_fwdbase #pragma vertex vert; #pragma fragment frag; #include "Lighting.cginc" #include "AutoLight.cginc" fixed4 _Color; fixed4 _ReflectColor; fixed _ReflectAmount; samplerCUBE _Cubemap; struct a2v { float4 vertex : POSITION; float3 normal : NORMAL; }; struct v2f { float4 pos : SV_POSITION; float3 worldPos : TEXCOORD0; float3 worldNormal : TEXCOORD1; float3 worldViewDir : TEXCOORD2; float3 worldRefl : TEXCOORD3; SHADOW_COORDS(4) }; v2f vert (a2v v) { v2f o; o.pos = UnityObjectToClipPos(v.vertex); o.worldPos = mul(unity_ObjectToWorld, v.vertex); o.worldNormal = UnityObjectToWorldNormal(v.normal); o.worldViewDir = UnityWorldSpaceViewDir(o.worldPos); o.worldRefl = reflect(-o.worldViewDir, o.worldNormal); TRANSFER_SHADOW(o) return o; } fixed4 frag(v2f i) : SV_Target { fixed3 worldNormal = normalize(i.worldNormal); fixed3 worldViewDir = normalize(i.worldViewDir); fixed3 worldLightDir = normalize(UnityWorldSpaceLightDir(i.worldPos)); fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz; fixed3 diffuse = _LightColor0.rbg * _Color.rgb * saturate(dot(worldNormal, worldLightDir)); fixed3 reflection = texCUBE(_Cubemap, i.worldRefl).rgb * _ReflectColor.rgb; UNITY_LIGHT_ATTENUATION(atten, i, i.worldPos); return fixed4(ambient + lerp(diffuse, reflection, _ReflectAmount) * atten, 1); } ENDCG } } FallBack "Reflective/VertexLit" }
这里worldRefl没有进行归一化，因为用于采样的参数仅仅作为方向变量传递，所以没必要。
处于性能考虑，选择在顶点着色器计算反射方向
折射
当光线从一种介质（例如空气）斜射入另一种介质（例如玻璃）时，传播方向一般会发生改变。给定入射角时，使用斯涅尔定律（Snell’s Law）来计算反射角。图形学通常用折射方向来直接对立方体纹理进行采样，尽管在物理学上是讲不通的，但图形学第一定律就是“如果它看起来是对的，那么它就是对的”。
n1和n2是两个介质的折射率（index of refraction）：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 Shader "UnityShadersLearn/Chapter10/Refraction" { Properties { _Color ("Color", Color) = (1,1,1,1) _RefractColor ("Refraction Color", Color) = (1,1,1,1) _RefractAmount ("Refraction Amount", Range(0, 1)) = 1 _RefractRatio ("Refraction Ratio", Range(0.1, 1)) = 0. //介质的透射比 _Cubemap ("Refraction Cubemap", Cube) = "_Skybox" {} } SubShader { Pass { Tags {"LightMode"="ForwardBase"} CGPROGRAM #pragma multi_compile_fwdbase #pragma vertex vert; #pragma fragment frag; #include "Lighting.cginc" #include "AutoLight.cginc" fixed4 _Color; fixed4 _RefractColor; fixed _RefractAmount; fixed _RefractRatio; samplerCUBE _Cubemap; struct a2v { float4 vertex : POSITION; float3 normal : NORMAL; }; struct v2f { float4 pos : SV_POSITION; float3 worldPos : TEXCOORD0; float3 worldNormal : TEXCOORD1; float3 worldViewDir : TEXCOORD2; float3 worldRefr : TEXCOORD3; SHADOW_COORDS(4) }; v2f vert (a2v v) { v2f o; o.pos = UnityObjectToClipPos(v.vertex); o.worldPos = mul(unity_ObjectToWorld, v.vertex); o.worldNormal = UnityObjectToWorldNormal(v.normal); o.worldViewDir = UnityWorldSpaceViewDir(o.worldPos); // 必须使用归一化的参数 o.worldRefr = refract(-normalize(o.worldViewDir), normalize(o.worldNormal), _RefractRatio); TRANSFER_SHADOW(o) return o; } fixed4 frag(v2f i) : SV_Target { fixed3 worldNormal = normalize(i.worldNormal); fixed3 worldViewDir = normalize(i.worldViewDir); fixed3 worldLightDir = normalize(UnityWorldSpaceLightDir(i.worldPos)); fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz; fixed3 diffuse = _LightColor0.rbg * _Color.rgb * saturate(dot(worldNormal, worldLightDir)); fixed3 refraction = texCUBE(_Cubemap, i.worldRefr).rgb * _RefractColor.rgb; UNITY_LIGHT_ATTENUATION(atten, i, i.worldPos); return fixed4(ambient + lerp(diffuse, refraction, _RefractAmount) * atten, 1); } ENDCG } } FallBack "Reflective/VertexLit" }
这里worldRefr没有进行归一化，因为用于采样的参数仅仅作为方向变量传递，所以没必要。
菲涅尔反射
在实时渲染中，经常会用菲涅尔反射（Fresnel reflection） 来根据视角方向控制反射程度 。光线照射到物体表面时，一部分反射，一部分进入物体内部发生折射或散射。
一个著名的近似公式是Schlick菲涅尔近似等式：
其中F0是反射系数，控制菲涅尔反射的强度；v是视角方向，n是表面法线。
另一个应用广泛的等式是Empricial菲涅尔近似等式：
使用上面的菲涅尔近似等式，可以在边界处模拟反射光强、折射光强、漫反射光强之间的变化。
在车漆、水面等材质的渲染中经常使用。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 Shader "UnityShadersLearn/Chapter10/Fresnel" { Properties { _Color ("Color", Color) = (1,1,1,1) _FresnelScale ("Fresnel Scale", Range(0, 1)) = 0.5 _Cubemap ("Reflection Cubemap", Cube) = "_Skybox" {} } SubShader { Pass { Tags {"LightMode"="ForwardBase"} CGPROGRAM #pragma multi_compile_fwdbase #pragma vertex vert; #pragma fragment frag; #include "Lighting.cginc" #include "AutoLight.cginc" fixed4 _Color; fixed _FresnelScale; samplerCUBE _Cubemap; struct a2v { float4 vertex : POSITION; float3 normal : NORMAL; }; struct v2f { float4 pos : SV_POSITION; float3 worldPos : TEXCOORD0; float3 worldNormal : TEXCOORD1; float3 worldViewDir : TEXCOORD2; float3 worldRefl : TEXCOORD3; SHADOW_COORDS(4) }; v2f vert (a2v v) { v2f o; o.pos = UnityObjectToClipPos(v.vertex); o.worldPos = mul(unity_ObjectToWorld, v.vertex); o.worldNormal = UnityObjectToWorldNormal(v.normal); o.worldViewDir = UnityWorldSpaceViewDir(o.worldPos); o.worldRefl = reflect(-o.worldViewDir, o.worldNormal); TRANSFER_SHADOW(o) return o; } fixed4 frag(v2f i) : SV_Target { fixed3 worldNormal = normalize(i.worldNormal); fixed3 worldViewDir = normalize(i.worldViewDir); fixed3 worldLightDir = normalize(UnityWorldSpaceLightDir(i.worldPos)); fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz; fixed3 diffuse = _LightColor0.rbg * _Color.rgb * saturate(dot(worldNormal, worldLightDir)); fixed3 reflection = texCUBE(_Cubemap, i.worldRefl).rgb; fixed fresnel = _FresnelScale + (1 - _FresnelScale) * pow(1 - dot(worldNormal, worldViewDir), 5); UNITY_LIGHT_ATTENUATION(atten, i, i.worldPos); // 也有反射光*菲涅尔来计算边缘光照，然后叠加这个边缘光照到漫反射的方案 fixed3 color = ambient + lerp(diffuse, reflection, saturate(fresnel)) * atten; return fixed4(color, 1); } ENDCG } } FallBack "Reflective/VertexLit" }
渲染纹理
现代GPU允许我们把整个三维场景渲染到一个中间缓冲中，即渲染目标纹理（Render Target Texture, RTT） ，而不是传统的帧缓冲或后备缓冲。与之相关的是多重渲染目标（Multiple Render Target, MRT） ，指GPU允许我们把场景同时渲染到多个渲染目标纹理中（比如延迟渲染中渲染G-Buffer）。
Unity为渲染目标纹理定义了一种专门的纹理类型：渲染纹理（Render Texture） 。在Unity中使用渲染纹理有两种方式：
在Project目录下创建渲染纹理，然后把某个相机的渲染目标设置成该渲染纹理
在屏幕后处理时使用GrabPass命令或OnRenderImage函数来获取当前屏幕图像
镜子效果
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 Shader "UnityShadersLearn/Chapter10/Mirror" { Properties { _MainTex ("Main Tex", 2D) = "white" {} } SubShader { Pass { Tags {"LightMode"="ForwardBase"} CGPROGRAM #pragma vertex vert; #pragma fragment frag; sampler2D _MainTex; struct a2v { float4 vertex : POSITION; float4 texcoord : TEXCOORD0; }; struct v2f { float4 pos : SV_POSITION; float2 uv : TEXCOORD0; }; v2f vert(a2v v) { v2f o; o.pos = UnityObjectToClipPos(v.vertex); o.uv = v.texcoord; o.uv.x = 1 - o.uv.x; return o; } fixed4 frag(v2f i) : SV_Target { return tex2D(_MainTex, i.uv); } ENDCG } } FallBack "Diffuse" }
着色器部分很简单，其实就是对环境纹理进行采样并输出，这里的环境纹理通过摄像机输出到RT获取。有个需要注意的是，摄像机需要从物体背后拍来营造镜子效果。
玻璃效果
GrabPass ，会把当前屏幕的图像绘制在一张纹理中，以便我们在后续的Pass中访问它。通常会使用GrabPass来实现玻璃等透明材质的模拟。由于需要保证所有的不透明物体已经渲染，所以需要使用透明队列（“Queue”=“Transparent”）
用GrabPass模拟玻璃效果的原理：首先使用一张法线纹理来修改模型的法线信息，然后用上节介绍的反射方法，通过Cubemap来模拟玻璃的反射。在模拟折射时，使用GrabPass获取玻璃后面的屏幕图像，并使用切线空间下的法线对屏幕纹理坐标偏移后，再对屏幕图像进行取样来模拟近似的折射效果。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 Shader "UnityShadersLearn/Chapter10/Glass Refraction" { Properties { _MainTex ("Main Tex", 2D) = "white" {} _BumpTex ("Bump Tex", 2D) = "bump" {} _Cubemap ("Evvironment Cubemap", Cube) = "_Skybox" {} _Distortion ("Distortion", Range(0, 100)) = 10 //模拟折射时图像的扭曲程度 _RefractAmount ("Refract Amount", Range(0, 1.0)) = 1.0 //反射程度 } SubShader { Tags {"Queue"="Transparent" "RenderType"="Opaque"} GrabPass {"_RefractionTex"} Pass { Tags {"LightMode"="ForwardBase"} CGPROGRAM #pragma vertex vert #pragma fragment frag #include "UnityCG.cginc" sampler2D _MainTex; float4 _MainTex_ST; sampler2D _BumpTex; float4 _BumpTex_ST; samplerCUBE _Cubemap; float _Distortion; fixed _RefractAmount; sampler2D _RefractionTex; //GrabPass指定的纹理名称 float4 _RefractionTex_TexelSize; //GrabPass得到的纹素大小 struct a2v { float4 vertex : POSITION; float4 texcoord : TEXCOORD0; float3 normal : NORMAL; float4 tangent : TANGENT; }; struct v2f { float4 pos : SV_POSITION; float4 srcPos : TEXCOORD0; float4 uv : TEXCOORD1; float4 TtoW0 : TEXCOORD2; float4 TtoW1 : TEXCOORD3; float4 TtoW2 : TEXCOORD4; }; v2f vert(a2v v) { v2f o; o.pos = UnityObjectToClipPos(v.vertex); o.srcPos = ComputeGrabScreenPos(o.pos); //得到被抓取的屏幕图像的纹理坐标 o.uv.xy = TRANSFORM_TEX(v.texcoord, _MainTex); o.uv.zw = TRANSFORM_TEX(v.texcoord, _BumpTex); float3 worldPos = mul(unity_ObjectToWorld, v.vertex).xyz; float3 worldNormal = UnityObjectToWorldNormal(v.normal); float3 worldTangent = UnityObjectToWorldDir(v.tangent.xyz); float3 worldBinormal = cross(worldNormal, worldTangent) * v.tangent.w; o.TtoW0 = float4(worldTangent.x, worldBinormal.x, worldNormal.x, worldPos.x); o.TtoW1 = float4(worldTangent.y, worldBinormal.y, worldNormal.y, worldPos.y); o.TtoW2 = float4(worldTangent.z, worldBinormal.z, worldNormal.z, worldPos.z); return o; } fixed4 frag(v2f i) : SV_Target { float3 worldPos = float3(i.TtoW0.w, i.TtoW1.w, i.TtoW2.w); fixed3 worldViewDir = normalize(UnityWorldSpaceViewDir(worldPos)); fixed3 bump = UnpackNormal(tex2D(_BumpTex, i.uv.zw)); float2 offset = bump.xy * _Distortion * _RefractionTex_TexelSize.xy; i.srcPos.xy = i.srcPos.xy + offset; fixed3 refrCol = tex2D(_RefractionTex, i.srcPos.xy/i.srcPos.w).rgb; bump = normalize(half3(dot(i.TtoW0.xyz, bump.x), dot(i.TtoW1, bump.y), dot(i.TtoW2, bump.z))); fixed3 reflDir = reflect(-worldViewDir, bump); fixed4 texColor = tex2D(_MainTex, i.uv.xy); fixed3 reflCol = texCUBE(_Cubemap, reflDir).rgb * texColor.rgb; // fixed3 finalColor = lerp(reflCol, refrCol, _RefractAmount); fixed3 finalColor = reflCol*(1-_RefractAmount) + refrCol*_RefractAmount; return fixed4(finalColor, 1); } ENDCG } } FallBack "Diffuse" }
用到的立方体纹理可以用程序生成的方法去采样。
GrabPass不指定名字的话，可以用_GrabTexture来访问，但是这样会为每个使用GrabPass的物体单独获取一次，尽管同一帧的画面是一样的。而指定名字，Unity保证只会执行一次抓取操作（前提是使用同一个名字）。
渲染纹理 vs. GrabPass
使用方便程度：
渲染纹理：要先创建渲染纹理资源和一个额外的相机，再把相机的RenderTarget设置为新建的渲染纹理对象，最后把该渲染纹理传递给相应的Shader
GrabPass：只需要在Shader中写几行代码
效率上渲染纹理往往好于GrabPass，尤其是移动平台：
渲染纹理：可以自定义大小和相机的渲染层
GrabPass：获取到的图像分辨率和屏幕显示是一致的。在移动设备上，需要CPU读取后备缓冲中的数据，破坏了CPU和GPU之间的并行性
Unity5中引入了命令缓冲（Command Buffers）扩展渲染流水线，得到类似抓屏的效果。
程序纹理
程序纹理（Procedural Texture）指那些由计算机生成的图像，我们通常用一些特定的算法来创建个性化图案或非常真实的自然元素，例如木头、石子等。
在Unity中实现简单的程序纹理
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 using System; using UnityEngine; namespace Unity_Shaders_Learn { [ExecuteInEditMode] public class ProceduralTextureGeneration : MonoBehaviour { public Material material = null; private Texture _generatedTexture = null; #region 材质自定义属性 // SetProperty是一个插件实现的自定义特性功能（https://github.com/LMNRY/SetProperty） [SerializeField, SetProperty("TextureWidth")] private int _textureWidth = 512; //纹理的大小，通常是2的整数幂(POT) public int TextureWidth { get => _textureWidth; set { _textureWidth = value; _UpdateMaterial(); } } [SerializeField, SetProperty("BackgroundColor")] private Color _backgroundColor = Color.white; public Color BackgroundColor { get => _backgroundColor; set { _backgroundColor = value; _UpdateMaterial(); } } [SerializeField, SetProperty("CircleColor")] private Color _cicleColor = Color.white; public Color CircleColor { get => _cicleColor; set { _cicleColor = value; _UpdateMaterial(); } } [SerializeField, SetProperty("BlurFactor")] private float _blurFactor = 2.0f; public float BlurFactor { get => _blurFactor; set { _blurFactor = value; _UpdateMaterial(); } } #endregion private void Start() { if (material == null) { Renderer renderer = gameObject.GetComponent<Renderer>(); if (renderer == null) { Debug.LogError("Cannot find a renderer"); } material = renderer.sharedMaterial; } _UpdateMaterial(); } private void _UpdateMaterial() { _generatedTexture = _GenerateProceduralTexture(); if (material != null) { material.SetTexture("_MainTex", _generatedTexture); } } private Texture _GenerateProceduralTexture() { Texture2D proceduralTexture = new Texture2D(TextureWidth, TextureWidth); // 定义圆与圆之间的间距 float circleInterval = TextureWidth / 4.0f; // 定义圆的半径 float radius = TextureWidth / 10.0f; // 定义模糊系数 float edgeBlur = 1.0f / BlurFactor; for (int w = 0; w < TextureWidth; w++) { for (int h = 0; h < TextureWidth; h++) { // 默认颜色 Color pixel = BackgroundColor; // 判断当前像素是否在圆内 for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { // 圆的中心点坐标 Vector2 circleCenter = new Vector2(circleInterval * (i + 1), circleInterval * (j + 1)); // 当前像素到这个圆的距离 float dist = Vector2.Distance(circleCenter, new Vector2(w, h)) - radius; // 模糊圆的边界 Color color = _MixColor( CircleColor, new Color(pixel.r, pixel.g, pixel.b, 0), // dist * edgeBlur 其实就是把圆映射到圆圈 Mathf.SmoothStep(0.0f, 1.0f, dist * edgeBlur)); // Magic！，color.a 外部为1，内部为0，边缘处0-1 pixel = _MixColor(pixel, color, color.a); } } proceduralTexture.SetPixel(w, h, pixel); } } proceduralTexture.Apply(); return proceduralTexture; } private Color _MixColor(Color fromCol, Color toCol, float smoothStep) { float r = Mathf.Lerp(fromCol.r, toCol.r, smoothStep); float g = Mathf.Lerp(fromCol.g, toCol.g, smoothStep); float b = Mathf.Lerp(fromCol.b, toCol.b, smoothStep); float a = Mathf.Lerp(fromCol.a, toCol.a, smoothStep); return new Color(r, g, b, a); } } }
Unity的程序材质
在Unity中，有一类专门使用程序纹理的材质就叫程序材质（Procedural Materials），使用Substance Designer软件创建，这种材质以.sbsar为后缀。
