EN中文
开发者社区 > 程序

Unity3D基础篇----Shader学习笔记（4）

发表于2017-09-01
评论0 2.2k浏览

这一篇，我们来继续学习Shader中纹理的添加以及实现纹理中凹凸的映射。

首先，我们先来看看实现的效果：


以上就是这一篇中所实现的内容，主要分为两个，一个是纹理，一个是凹凸映射。

实现代码如下：

首先是贴图着色器代码：

[cpp] view plain copy
  1. //Shader模块定义  
  2. Shader "xiaolezi/Simple Texture"  
  3. {  
  4.     //属性设置  
  5.     Properties  
  6.     {  
  7.         //定义一个物体表面颜色,格式：[属性名]([Inspector面板显示名字],属性类型)=[初始值]  
  8.         _DiffuseColor("Main Color", Color) = (1, 1, 1, 1)  
  9.         _MainTex("Albedo(RGB)", 2D) = "white"{}  
  10.         _Glossness("Glossness", Range(8, 256)) = 20  
  11.         _SpecularColor("Specular Color", Color) = (1, 1, 1, 1)  
  12.     }  
  13.     //第一个SubShader块  
  14.     SubShader  
  15.         {  
  16.             //第一个Pass块  
  17.             Pass  
  18.             {  
  19.                 //指定灯光渲染模式  
  20.                 Tags{ "LightMode" = "ForwardBase" }  
  21.   
  22.                 //开启CG着色器编辑模块  
  23.                 CGPROGRAM  
  24.                 //定义顶点着手器函数名  
  25. <span style="white-space:pre">              </span>#pragma vertex vert  
  26.                 //定义片段着色器函数名  
  27. <span style="white-space:pre">              </span>#pragma fragment frag  
  28.   
  29.                 //包含相关头文件  
  30. <span style="white-space:pre">              </span>#include "UnityCG.cginc"   
  31. <span style="white-space:pre">              </span>#include "Lighting.cginc"  
  32.   
  33.                 //定义一个从应用程序到顶点数据的结构体  
  34.                 struct appdata  
  35.                 {  
  36.                     float4 vertex : POSITION;//POSITION语义:表示从该模型中获取到顶点数据  
  37.                     float3 normal : NORMAL;  //NORMAL语义:获取该模型法线  
  38.                     float2 texcoord : TEXCOORD0;//TEXCOORD0语义:获取该模型纹理坐标  
  39.                 };  
  40.                 //定义一个从顶点数据到片段数据的结构体  
  41.                 struct v2f  
  42.                 {  
  43.                     float4 pos : SV_POSITION;//SV_POSITION语义:从顶点输出数据中获取到顶点数据  
  44.                     float3 normal : TEXCOORD0;//TEXCOORD0语义:定义法线变量  
  45.                     float2 uv : TEXCOORD1;//TEXCOORD1语义:定义纹理贴图变量  
  46.                     float3 lightDir : TEXCOORD2;//TEXCOORD2语义:定义灯光方向变量  
  47.                     float3 viewDir : TEXCOORD3;//TEXCOORD3语义:定义观察方向变量  
  48.                 };  
  49.                 //从属性模块中取得该变量  
  50.                 fixed4 _DiffuseColor;  
  51.                 float _Glossness;  
  52.                 fixed4 _SpecularColor;  
  53.                 sampler2D _MainTex;  
  54.                 float4 _MainTex_ST;  
  55.   
  56.                 //顶点着色器函数实现  
  57.                 v2f vert(appdata v)  
  58.                 {  
  59.                     v2f o;  
  60.                     o.pos = UnityObjectToClipPos(v.vertex);//让模型顶点数据坐标从本地坐标转化为屏幕剪裁坐标  
  61.                     o.normal = v.normal;  
  62.   
  63.                     //计算灯光方向  
  64.                     o.lightDir = normalize(ObjSpaceLightDir(v.vertex));           
  65.                     //计算观察方向  
  66.                     o.viewDir = normalize(ObjSpaceViewDir(v.vertex));  
  67.   
  68.                     //计算纹理坐标  
  69.                     //o.uv = v.texcoord.xy * _MainTex_ST.xy   _MainTex_ST.zw;  
  70.                     //这里使用内置宏 TRANSFORM_TEX  
  71.                     o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);  
  72.                     return o;  
  73.                 }  
  74.                 //片段着色器函数实现  
  75.                 fixed4 frag(v2f f) : SV_Target//SV_Target语义:输出片元着色器值，可直接认为是输出到屏幕颜色  
  76.                 {  
  77.                     fixed3 normalDir = normalize(UnityObjectToWorldNormal(f.normal));   //计算世界法线方向  
  78.                     //漫反色  
  79.                     fixed3 albedo = tex2D(_MainTex, f.uv);  
  80.                     float Lambert = 0.5 * dot(normalDir, f.lightDir)   0.5;//兰伯特值  
  81.                     fixed3 diffuse = _LightColor0.rgb * _DiffuseColor.rgb * Lambert * albedo;   //计算漫反色  
  82.                       
  83.                     //环境光  
  84.                     fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * albedo;  
  85.                     //高光  
  86.                     fixed3 halfDir = normalize(f.lightDir   f.viewDir);//根据物体表面法线计算光的反射光方向  
  87.                     fixed3 specular = _LightColor0.rgb * _SpecularColor.rgb * pow(max(0, dot(halfDir, normalDir)), _Glossness);//Phong氏高光计算  
  88.   
  89.                     return fixed4(ambient   diffuse   specular, 1.0);  
  90.                 }  
  91.                     //结束CG着色器编辑模块  
  92.                     ENDCG  
  93.             }  
  94.         }  
  95.   
  96.         Fallback "Diffuse"//默认着色器,这里选择漫反色  
  97. }  


凹凸映射着色器代码：

[cpp] view plain copy
  1. //Shader模块定义  
  2. Shader "xiaolezi/Bump Texture"  
  3. {  
  4.     //属性设置  
  5.     Properties  
  6.     {  
  7.         //定义一个物体表面颜色,格式：[属性名]([Inspector面板显示名字],属性类型)=[初始值]  
  8.         _DiffuseColor("Main Color", Color) = (1, 1, 1, 1)  
  9.         _MainTex("Albedo(RGB)", 2D) = "white"{}  
  10.         _BumpMap("Normal Map", 2D) = "bump"{}  
  11.         _BumpScale("Bump Scale",Float)= 1.0  
  12.         _Glossness("Glossness", Range(8, 256)) = 20  
  13.         _SpecularColor("Specular Color", Color) = (1, 1, 1, 1)  
  14.     }  
  15.     //第一个SubShader块  
  16.     SubShader  
  17.         {  
  18.             //第一个Pass块  
  19.             Pass  
  20.             {  
  21.                 //指定灯光渲染模式  
  22.                 Tags{ "LightMode" = "ForwardBase" }  
  23.   
  24.                 //开启CG着色器编辑模块  
  25.                 CGPROGRAM  
  26.                 //定义顶点着手器函数名  
  27. <span style="white-space:pre">              </span>#pragma vertex vert  
  28.                 //定义片段着色器函数名  
  29. <span style="white-space:pre">              </span>#pragma fragment frag  
  30.   
  31.                 //包含相关头文件  
  32. <span style="white-space:pre">              </span>#include "UnityCG.cginc"   
  33. <span style="white-space:pre">              </span>#include "Lighting.cginc"  
  34.   
  35.                 //定义一个从应用程序到顶点数据的结构体  
  36.                 struct appdata  
  37.                 {  
  38.                     float4 vertex : POSITION;//POSITION语义:表示从该模型中获取到顶点数据  
  39.                     float3 normal : NORMAL;  //NORMAL语义:获取该模型法线  
  40.                     float2 texcoord : TEXCOORD0;//TEXCOORD0语义:获取该模型纹理信息  
  41.                     float4 tangent : TANGENT;//TANGENT语义:获取该模型切线坐标  
  42.                 };  
  43.                 //定义一个从顶点数据到片段数据的结构体  
  44.                 struct v2f  
  45.                 {  
  46.                     float4 pos : SV_POSITION;//SV_POSITION语义:从顶点输出数据中获取到顶点数据  
  47.                     float4 uv : TEXCOORD0;//TEXCOORD0语义:定义纹理贴图变量  
  48.                     float3 lightDir : TEXCOORD1;//TEXCOORD1语义:定义灯光方向变量  
  49.                     float3 viewDir : TEXCOORD2;//TEXCOORD2语义:定义观察方向变量  
  50.                 };  
  51.                 //从属性模块中取得该变量  
  52.                 fixed4 _DiffuseColor;  
  53.                 float _Glossness;  
  54.                 fixed4 _SpecularColor;  
  55.                 sampler2D _MainTex;  
  56.                 float4 _MainTex_ST;  
  57.                 sampler2D _BumpMap;  
  58.                 float4 _BumpMap_ST;  
  59.                 float _BumpScale;  
  60.   
  61.                 //顶点着色器函数实现  
  62.                 v2f vert(appdata v)  
  63.                 {  
  64.                     v2f o;  
  65.                     o.pos = UnityObjectToClipPos(v.vertex);//让模型顶点数据坐标从本地坐标转化为屏幕剪裁坐标  
  66.                     //计算纹理坐标  
  67.                     o.uv.xy = TRANSFORM_TEX(v.texcoord,_MainTex);  
  68.                     o.uv.zw = TRANSFORM_TEX(v.texcoord, _BumpMap);  
  69.   
  70.                     //计算切线矩阵  
  71.                     //float3 binormal = cross(normalize(v.normal), normalize(v.tangent.xyz)) * v.tangent.w;  
  72.                     //  float3x3 rotation = float3x3(v.tangent.xyz, binormal, v.normal);  
  73.                     //这里直接使用内置宏 TANGENT_SPACE_ROTATION  
  74.                     TANGENT_SPACE_ROTATION;  
  75.   
  76.                     //计算切线空间下的灯光方向  
  77.                     o.lightDir = normalize(mul(rotation, ObjSpaceLightDir(v.vertex)));  
  78.                     //计算切线空间下的观察方向  
  79.                     o.viewDir = normalize(mul(rotation, ObjSpaceViewDir(v.vertex)));  
  80.   
  81.                     return o;  
  82.                 }  
  83.                 //片段着色器函数实现  
  84.                 fixed4 frag(v2f f) : SV_Target//SV_Target语义:输出片元着色器值，可直接认为是输出到屏幕颜色  
  85.                 {  
  86.                     fixed4 normalAlbedo = tex2D(_BumpMap, f.uv.zw);  
  87.                     fixed3 tangentNormal = UnpackNormal(normalAlbedo);  
  88.                     tangentNormal.xy *= _BumpScale;  
  89.   
  90.                     //漫反色  
  91.                     fixed3 albedo = tex2D(_MainTex, f.uv).rgb;  
  92.                     float Lambert = 0.5 * dot(tangentNormal, f.lightDir)   0.5;//兰伯特值  
  93.                     fixed3 diffuse = _LightColor0.rgb * _DiffuseColor.rgb * Lambert * albedo;   //计算漫反色  
  94.   
  95.                     //环境光  
  96.                     fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * albedo;  
  97.   
  98.                     //高光  
  99.                     fixed3 halfDir = normalize(f.lightDir   f.viewDir);//根据物体表面法线计算光的反射光方向  
  100.                     fixed3 specular = _LightColor0.rgb * _SpecularColor.rgb * pow(max(0, dot(halfDir, tangentNormal)), _Glossness);//Phong氏高光计算  
  101.   
  102.                     return fixed4(ambient   diffuse   specular, 1.0);  
  103.                 }  
  104.                     //结束CG着色器编辑模块  
  105.                     ENDCG  
  106.             }  
  107.         }  
  108.         Fallback "Bump Diffuse"//默认着色器,这里选择凹凸漫反色  
  109. }  

我这里所使用的都是基于Blinn-Phong光照模型进行实现。


好，我们先来了解一下纹理映射技术，该技术是实现在模型对应像素点上通过纹理坐标采样当前贴图的像素点从而控制模型当前像素点的颜色。所以关键的一点就是需要计算贴图的纹理坐标，即UV坐标。而对于不同图形编程语言，其对应的纹理坐标是不一样的，不过庆幸的是，Unity帮我们处理的这一点，统一了纹理坐标系统，如图：


通过上图可知道，纹理坐标是取值[0,1]。如果大于1，它会如何进行采样，则需要看纹理属性所设置的Wrap Mode模式来决定了，而设置该模式的选项在纹理属性面板中可以找到：


Unity提供两种方式，一种是重复(Repeat)采样，一种是拓展(Clamp)采样。

重复采样是指纹理坐标超出其限定范围时，会取其小数部分进行采样，例如目标纹理坐标为[-0.28,2.6]，其实际纹理坐标为[0.72,0.6]；

拓展采样是指纹理坐标超出其限定范围时，会取其限定范围，例如目标纹理坐标为[1.52,-0.5]，其实际纹理坐标为[1,0]。

这里我给出一张纹理图：


我们对该纹理设置不同采样模式附加在材质中进行平铺（Tiling）两次，如下：


而材质中还有一个关键的属性，就是纹理贴图附加模型中的偏移量（Offset），这个偏移量很容易理解，一般纹理贴图附加在模型上默认有个附加基准点，而偏移量便是对这基准点的坐标进行偏移。

以下是对材质中设置不同偏移量的所显示的结果：


好，了解了纹理映射技术，先来说说实现过程的思路，如下：

1.在属性块中定义纹理属性；

2.Pass块中定义该纹理属性以及纹理平铺偏移量；

3.在结构体中定义相关属性；

3.在顶点着色器中计算纹理坐标；

4.在片段着色器中根据第2步所计算的纹理坐标对纹理贴图进行纹理采样，得到采样后的纹理颜色与表面颜色进行混合即可。


第一步，在属性中定义一张纹理图，默认是一张纯白色贴图：

[cpp] view plain copy
  1. _MainTex("Albedo(RGB)", 2D) = "white"{}  

第二步，Pass块中定义该纹理属性以及纹理平铺偏移量：

[cpp] view plain copy
  1. sampler2D _MainTex;  
  2. float4 _MainTex_ST;  
对于变量“_MainTex_ST”，这是对_MainTex纹理的平铺偏移量进行定义。通常，获取纹理的平铺偏移量，其格式：

[cpp] view plain copy
  1. float4 var = 纹理名##_ST;  
这是一个float4的值，拥有四个属性值：

[cpp] view plain copy
  1. ·x 包含X平铺值  
  2. ·y 包含Y平铺值  
  3. ·z 包含X偏移量  
  4. ·w 包含Y偏移量  
第三步，在结构体中定义相关属性：

[cpp] view plain copy
  1. //定义一个从应用程序到顶点数据的结构体  
  2. struct appdata  
  3.     {  
  4.                 ...  
  5.         float2 texcoord : TEXCOORD0;//TEXCOORD0语义:获取该模型纹理坐标  
  6.     };  
  7. //定义一个从顶点数据到片段数据的结构体  
  8. struct v2f  
  9.         {  
  10.         ...  
  11.         float2 uv : TEXCOORD1;//TEXCOORD1语义:定义纹理贴图变量          
  12.         };  
第四步，在顶点着色器中计算纹理坐标：

[cpp] view plain copy
  1. //计算纹理坐标  
  2. //o.uv = v.texcoord.xy * _MainTex_ST.xy   _MainTex_ST.zw;  
  3. //这里使用内置宏 TRANSFORM_TEX  
  4. o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);  
我这里直接通过宏获得，而这个宏定义在UnityCG.cginc中，我把其实现也列举出来。

计算纹理坐标是通过从应用程序中获取本地纹理坐标，然后对本地纹理坐标进行纹理贴图的一个计算。

第五步，在片段着色器中根据第2步所计算的纹理坐标对纹理贴图进行纹理采样，得到采样后的纹理颜色与表面颜色进行混合：

[cpp] view plain copy
  1. //漫反色  
  2. fixed3 albedo = tex2D(_MainTex, f.uv);  
  3. float Lambert = 0.5 * dot(normalDir, f.lightDir)   0.5;//兰伯特值  
  4. fixed3 diffuse = _LightColor0.rgb * _DiffuseColor.rgb * Lambert * albedo;  
其实实现对纹理的采样并没有我们想象的这么复杂，只需调用其内部函数即可取得，但是实际上其过程是很复杂的，这里也不会去深究探讨。

纹理采样函数tex2D，第一个传入的是需要采样的纹理，第二个参数是采样的纹理坐标，这个我们在顶点着色器已求得，既然是混合，就直接进行相乘操作。


接着来讲讲凹凸映射（bump mapping）的原理。

通过上面的学习了解，我们已经知道如何对模型进行贴图操作。但是往往这是不够的，因为你所看到的可能有些是凹凸不齐的，更多的并不是一张图片贴上去那么简答。比如石头、砖块、墙等等。

有些人会提出，直接在贴图上显示这样的效果不就好了？其实不然，如果你这一面看上去的确参差不齐，但是你换个角度看应该会有不一样的效果的，所以便引申出了凹凸映射。

凹凸映射实际上就是使用一张纹理来修改模型表面的法线，以便为模型提供更多的细节。

对于凹凸映射所使用的纹理，主要有两种：

一种是高度图（height map），这种纹理是模拟表面位移，然后得到一个修改后法线的值；

一种是法线贴图（normal map），这一种是直接存储表面法线。如下图所示：



关于法线贴图，我们来探讨一下下面两个问题：

1.为什么模型空间下和切线空间下的法线贴图所展现的区别很大。

2.模型空间下的法线贴图和切线空间下的法线贴图使用的优劣。


在这之前，我们需要知道，法线纹理存储的是模型表面法线的方向。而表面法线（normal）方向取值[-1,1]，像素（pixel）的分量为范围是[0,1]。所以这里存在着这么一个转换关系：pixel = (normal 1) / 2；

这就意味着当我们对法线贴图进行采样后还需要对其进行相对应的映射才能得到正确的法线方向。

好，现在再来解决上面的两个问题：

第一个问题：为什么模型空间下和切线空间下的法线贴图所展现的区别很大？

模型空间下的法线贴图显得五颜六色。这是由于在模型空间下，所有法线的坐标空间是同一坐标空间，即模型空间，又因为每个顶点的法线方向是各异的，所以通过纹理映射后取值结果会很多，例如法线(1,0,1)，通过映射之后得到颜色值为(1,0.5,1)，即紫色，又或者法线(0,1,0)，通过映射之后得到颜色值为(0.5,1,0.5)，即浅绿色。

切线空间下的法线贴图就显得偏浅蓝色，这是因为每个顶点法线所在的坐标空间都不一样，即表面每个顶点的切线空间，这种法线纹理所存储的其实就是各个顶点在各自的切线空间中的法线扰动方向，下图展示的是模型中某地所在的切线空间：


所以我们来假设一下，如果每个顶点的法线方向是不变的，那么在它的切线空间中，新的法线方向就是z轴方向，即值为(0,0,1)，通过映射可得到其颜色值为(0.5,0.5,1)，即浅蓝色。所以这些蓝色说明了顶点的大部分法线是和模型本身法线一致，不需要改变。

第二个问题：模型空间下的法线贴图和切线空间下的法线贴图使用的优劣。

可以看出，使用模型空间下的法线贴图更符合人类的直观认识，但是，模型空间中的法线贴图是绝对法线信息，如果使用另外的模型，那么，一切也将变得错误。而相对而言，切线空间下的法线贴图是相对法线信息，即便模型改变，但是依旧可以很好的融合进去，借助这一有点，很多像水、熔岩等动态凹凸效果，可以很好的被使用进来。当然，这里只是点一下主要的优劣。相信通过这个主要的优劣，我觉得很多人都会选择使用切线空间下的法线贴图来进行纹理的凹凸映射。


好，现在我们来看看切线空间下实现凹凸映射的着色器代码。

实现过程思路：

1.在属性块中定义凹凸映射相关属性；

2.在Pass块中重新定义凹凸映射相关属性；

3.在结构体中定义相关属性；

4.在顶点着色器中把光照方向以及观察坐标方向转换为切线空间下坐标；

5.在片段着色器中采样切线空间下的法线贴图并得到正确的法线，使用该法线进行相关计算得到最终效果。

有了上面的思路，我们再来一步一步分析：

第一步，在属性块中定义凹凸映射相关属性：

[cpp] view plain copy
  1. //属性设置  
  2. Properties  
  3. {  
  4.     ...  
  5.     _BumpMap("Normal Map", 2D) = "bump"{}  
  6.     _BumpScale("Bump Scale",Float)= 1.0  
  7. }  
定义法线贴图属性_BumpMap，默认赋值为默认的法线贴图bump；凹凸程度属性_BumpScale，默认为正常凹凸。


第二步，在Pass块中重新定义凹凸映射相关属性：

[cpp] view plain copy
  1. sampler2D _BumpMap;  
  2. float4 _BumpMap_ST;  
  3. float _BumpScale;  


第三步，在结构体中定义相关属性：

[cpp] view plain copy
  1. //定义一个从应用程序到顶点数据的结构体  
  2. struct appdata  
  3. {  
  4. <span style="white-space:pre">  </span>...  
  5.     float3 normal : NORMAL;  //NORMAL语义:获取该模型法线  
  6.     float2 texcoord : TEXCOORD0;//TEXCOORD0语义:获取该模型纹理信息  
  7.         float4 tangent : TANGENT;//TANGENT语义:获取该模型切线坐标  
  8. };  
  9. //定义一个从顶点数据到片段数据的结构体  
  10. struct v2f  
  11. {  
  12.        ...  
  13.        float4 uv : TEXCOORD0;//TEXCOORD0语义:定义纹理贴图变量  
  14. };  
这里v2f结构体中，uv变量类型获取为float4，则使用TEXCOORD获取的纹理坐标的xy存储主纹理的纹理坐标，zw存储法线纹理的纹理坐标。


第四步：在顶点着色器中把光照方向以及观察坐标方向转换为切线空间下坐标：

[cpp] view plain copy
  1. //顶点着色器函数实现  
  2. v2f vert(appdata v)  
  3. {  
  4.     v2f o;  
  5.     ...  
  6.     //计算纹理坐标  
  7.     ...  
  8.     o.uv.zw = TRANSFORM_TEX(v.texcoord, _BumpMap);  
  9.   
  10.     //计算切线矩阵  
  11.     //float3 binormal = cross(normalize(v.normal), normalize(v.tangent.xyz)) * v.tangent.w;  
  12.     //  float3x3 rotation = float3x3(v.tangent.xyz, binormal, v.normal);  
  13.     //这里直接使用内置宏 TANGENT_SPACE_ROTATION  
  14.     TANGENT_SPACE_ROTATION;  
  15.     //计算切线空间下的灯光方向  
  16.     o.lightDir = normalize(mul(rotation, ObjSpaceLightDir(v.vertex)));  
  17.         //计算切线空间下的观察方向  
  18.     o.viewDir = normalize(mul(rotation, ObjSpaceViewDir(v.vertex)));  
  19.   
  20.     return o;  
  21. }  
我们在这里计算切线矩阵时，通过法线和切线叉积求得副轴，而v.tangent.w代表切线的方向。

求得切线矩阵之后，我们直接对光方向以及观察方向与切线矩阵进行相乘完成切线空间下的转化。


第五步，在片段着色器中采样切线空间下的法线贴图并得到正确的法线，使用该法线进行相关计算得到最终效果：

[cpp] view plain copy
  1. //片段着色器函数实现  
  2. fixed4 frag(v2f f) : SV_Target//SV_Target语义:输出片元着色器值，可直接认为是输出到屏幕颜色  
  3. {  
  4.     fixed4 normalAlbedo = tex2D(_BumpMap, f.uv.zw);  
  5.     fixed3 tangentNormal = UnpackNormal(normalAlbedo);  
  6.     tangentNormal.xy *= _BumpScale;  
  7.   
  8.     //漫反色  
  9.     fixed3 albedo = tex2D(_MainTex, f.uv).rgb;  
  10.     float Lambert = 0.5 * dot(tangentNormal, f.lightDir)   0.5;//兰伯特值  
  11.     fixed3 diffuse = _LightColor0.rgb * _DiffuseColor.rgb * Lambert * albedo;     
  12.   
  13.     //环境光  
  14.     fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * albedo;  
  15.   
  16.     //高光  
  17.     fixed3 halfDir = normalize(f.lightDir   f.viewDir);//根据物体表面法线计算光的反射光方向  
  18.     fixed3 specular = _LightColor0.rgb * _SpecularColor.rgb * pow(max(0, dot(halfDir, tangentNormal)), _Glossness);//Phong氏高光计算  
  19.     return fixed4(ambient   diffuse   specular, 1.0);  
  20. }  
我们通过对切线空间下的法线贴图进行采样后作为参数传入UnpackNormal方法即可获得正确的法线。而对求得的法线，我们在再原有的基础上与凹凸属性值_BumpScale相乘变化该法线的大小从而达到凹凸程度的不同。后续漫反色、环境光以及高光就不多说了。

还有一个关键点，就是对于你的法线贴图，需要在Unity编辑器中对其属性中的贴图类型进行设置，把Texture Type设置为“Normal map”即可：



以上便是在Unity中使用Shader中实现对模型纹理的添加以及实现纹理中凹凸的映射。希望对读者有所帮助。

如果你想要下载源码，可以在GitHub仓库中找到：GitHub仓库

Happy Coding...

如社区发表内容存在侵权行为，您可以点击这里查看侵权投诉指引

标签：

List法线贴图Map环境光Unity纹理映射
0

0个评论