• 4.基础纹理

    • 纹理的目的：使用一张图片来控制模型的外观
    • 纹理映射技术：把一张图“黏”在模型表面，逐纹素（与像素不同）地控制模型颜色
    • 通常在建模软件中利用纹理展开技术实现，把纹理映射坐标存储在每个顶点上
    • 纹理映射坐标：定义了该顶点在纹理中对应的2D坐标
    • 纹理映射坐标也称UV坐标用二维变量（u，v）表述，u代表横坐标 v代表纵坐标
    • 纹理的大小多种多样，但顶点UV坐标中被归一化到[0,1]范围
    • 纹理采样时使用的纹理坐标不一定在[0,1]
    • OpenGL与DirectX的纹理空间坐标不同，unity中符合OpenGL，原点在左下角

    一、单张纹理

    纹理类型中需要声明一个float4类型的变量_MainTex_ST，其中_MainTex_ST的名字不是任意起的，在unity中，需要使用纹理名_ST的方式来声明某个纹理的属性。

    ST是缩放（scale）和平移（translation）的缩写

    _MainTex_ST可以让我们得到该纹理的缩放和平移（偏移）值

    _MainTex_ST.xy存储的是缩放值，_MainTex_ST.zw存储的是偏移值

    这些值可以在材质面板的纹理属性中调节

    1.实践

    效果如下：

    全部代码：

    1. // Upgrade NOTE: replaced '_Object2World' with 'unity_ObjectToWorld'
    2.  
    3. Shader "Shader/SingleTexture"
    4. {
    5.     Properties
    6.     {
    7.         _MainTex ("Texture", 2D) = "white" {}
    8.         _Color ("Color", Color) = (1,1,1,1)
    9.         _Specular ("Specular", Color) = (1,1,1,1)
    10.         _Gloss ("Gloss", Range(8.0, 256)) = 20 
    11.     }
    12.     SubShader
    13.     {
    14.         Tags { "RenderType"="Opaque" }
    15.  
    16.         Pass
    17.         {
    18.             Tags{"LightMode"="ForwardBase"}//LightMode标签是Pass标签中的一种，用于定义该Pass在unity的光照流水线中的角色
    19.             CGPROGRAM
    20.             #pragma vertex vert
    21.             #pragma fragment frag
    22.  
    23.             #include "UnityCG.cginc"
    24.             #include "Lighting.cginc"
    25.  
    26.             struct appdata
    27.             {
    28.                 float4 vertex : POSITION;
    29.                 float3 normal : NORMAL;
    30.                 float2 uv : TEXCOORD0;
    31.             };
    32.  
    33.             struct v2f
    34.             {
    35.                 float4 pos : SV_POSITION;
    36.                 float3 worldNormal : TEXCOORD0;
    37.                 float3 worldPos : TEXCOORD1;
    38.                 float2 uv : TEXCOORD2;
    39.             };
    40.  
    41.             sampler2D _MainTex;
    42.             float4 _MainTex_ST;
    43.             fixed4 _Color;
    44.             fixed4 _Specular;
    45.             float _Gloss;
    46.  
    47.             v2f vert (appdata v)
    48.             {
    49.                 v2f o;
    50.                 o.pos = UnityObjectToClipPos(v.vertex);
    51.                 o.worldNormal = UnityObjectToWorldNormal(v.normal);
    52.                 o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
    53.                 o.uv = v.uv.xy * _MainTex_ST.xy + _MainTex_ST.zw;
    54.  
    55.                 return o;
    56.             }
    57.  
    58.             fixed4 frag (v2f i) : SV_Target
    59.             {
    60.                 fixed3 worldNormal = normalize(i.worldNormal);
    61.                 fixed3 worldLightDir = normalize(UnityWorldSpaceLightDir(i.worldPos));
    62.  
    63.                 fixed3 albedo = tex2D(_MainTex, i.uv).rgb * _Color.rgb;
    64.  
    65.                 fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * albedo;
    66.  
    67.                 fixed3 diffuse = _LightColor0.rgb * albedo *
    68.                                  max(0, dot(worldNormal, worldLightDir));
    69.  
    70.                 fixed3 viewDir = normalize(UnityWorldSpaceViewDir(i.worldPos));
    71.                 fixed3 halfDir = normalize(worldLightDir + viewDir);
    72.                 fixed3 specular = _LightColor0.rgb * _Specular.rgb * 
    73.                                   pow(max(0, dot(worldNormal, halfDir)), _Gloss);
    74.  
    75.                 return fixed4(ambient + diffuse + specular, 1.0);
    76.             }
    77.             ENDCG
    78.         }
    79.     }
    80.     Fallback "Specular"
    81. }

    2.纹理属性

    我们向unity中导入一张纹理资源，其材质面板上的参数如下，我们可以调节他们

    Texture Type 纹理类型：选择合适的纹理类型，才能让unity知道我们的意图，传递正确的纹理，或对纹理进行优化

    Wrap Mode：决定了当纹理坐标超过[0,1]范围后如何被平铺。

    Wrap Mode有两种模式：

    Repeat，如果纹理超过1，那么它的整数部分将会被舍弃，直接使用小数部分采样。这样的结果是纹理将会不断重复。

    Clamp，如果纹理大于1，那么将会截取到1，如果小于0，那么就会截取到0

    Filter Mode：决定了当纹理由于变化而产生拉伸时将会采用哪种滤波模式

    Filter Mode有三种模式：Point、Bilinear、Trilinear。它们得到的图片滤波效果依次提升，但耗费的性能也依次增大。纹理滤波会影响放大或缩小纹理时得到的图片质量。

    如：把64x64大小的纹理贴在512x512大小的平面上时，就需要放大纹理

    mip map：多级渐远纹理：在一个很小的空间中有许多东西

    多级渐远纹理技术将原纹理提前用滤波处理来得到很多更小的图像，形成了一个图像金字塔，每一层都是对上一层图像采样的结果。这样实时运行，就可以快速得到结果像素。

    如当物体原理相机时，就用较小的纹理

    缺点是需要一定空间存储，通常会多占用33%的内存空间

     

    •  Point：最邻近滤波。在放大或缩小时，它的采样数目通常只有一个，因此图像会看起来有种像素风格
    • Bilinear：线性滤波。对于每个目标像素，会找到4个临近像素，然后对它们进行线性插值混合得到最终像素，因此图像看起来像被模糊了
    • Trilinear：几乎和Bilinear一样，只是Trilinear还会在多级渐远纹理之间进行混合。如果一张纹理没有使用多级渐远纹理技术，那么Trilinear得到的结果和Bilinear一样

    一般情况下选择Bilinear模式，注意，有时我们不希望纹理看起来是模糊的，例如对于一些类似棋盘的纹理，这是就希望是像素风，那么就用Point模式

    不同平台发布游戏时，需要考虑目标平台的纹理和质量问题。

    如果导入的纹理超出最大尺寸，那么unity会把该纹理缩放为这个最大分辨率。

    理想情况下导入的纹理可以是非正方形的，但长宽的大小应该是2的幂。2、4、8、16、32、64

    如果使用非2的幂大小（NPOT），那么纹理会占用跟多的内存空间，而且GPU读取该纹理的速度也会有所下降

    一些平台不支持NPOT纹理，unity会在内部将它缩放为2的幂，为了性能，请尽量使用2的幂大小

    Format：决定了unity内部用哪种格式存储该纹理。使用的纹理格式精度越高，占用的内存空间越大，得到的效果越好。

    在最下方可以查看存储该纹理需要占用的内存空间（若开启多级渐远纹理技术，也会增加纹理的内存占用）。

    二、凹凸纹理（bump mapping）

    凹凸纹理：使用一种纹理来修改模型表面的法线，以便为模型提供更多细节。

    并不会真的改变模型顶点位置，只是让模型看起来凹凸不平，但在模型的轮廓处可以看出破绽

    1.高度纹理

    使用一张高度纹理（height map）来模拟表面位移，然后得到一个修改后的法线值，这种方法也被称为高度映射。

    高度图中存储的是强度值（intensity），它用于表示模型表面局部的海拔高度。

    颜色越浅，越向外凸起，颜色越深，越向内凹陷

    好处：直观，可以从高度图中明确地知道每个模型的表面凹凸情况

    缺点：计算更复杂，在实时计算时不能直接得到表面法线，而需要灰度值计算而得到，需要消耗更多的性能

    高度图一般与法线映射一起使用，用于给出表面凹凸的额外信息。我们通常会用法线映射案例修改光照

    2.法线纹理

    使用一张法线纹理来直接存储表面法线，也被称为法线映射。

    法线纹理中存储的就是表面的发现方向，由于法线方向的分量范围在[-1,1]，而像素的分量范围为[0,1]，因此我们需要做一个映射，通常的映射方法：

    pixel=\frac{normal+1}{2}

    在shader中对纹理法线进行纹理采样后，还需要对结果进行一次反映射的过程，以得到原先的法线方向。反映射即是映射函数的逆函数：

    normal=pixel\times 2-1

    模型顶点自带的法线，它们定义子啊模型空间中，因此一种直接的想法就是将修改后的模型空间中的表面法线存储在一张纹理中，这种纹理被称为模型空间的法线纹理。

    切线空间：模型的每个顶点都有属于自己的切线空间，这个切线空间的原点就是该顶点本身，而z轴是顶点的法线方向（n）,x轴是顶点的切线方向（t），而y轴可由法线和切线叉积而得，称为负切线空间（b）。

    如果选择切线空间，则要把法线纹理中得到的法线方向的切线空间转换到世界空间（或其他空间）中

    使用模型空间存储法线的优点：

    • 实现简单，更加直观。不需要模型原始法线和切线等信息，计算更少。
    • 在纹理坐标的缝合处和尖锐的边角部分，可见的突破（缝隙）较少，即可以提供平滑的边界。

    使用切线空间的优点：

    • 自由的高。模型空间下的法线纹理记录的是绝对法线信息，仅可用于创建它时的那个模型，应用到其他模型上效果就完全错误了
    • 可以进行UV动画。
    • 可以重用法线纹理。
    • 可压缩。由于切线空间下的法线纹理中的法线的Z方向总是正方形，因此我们就可以仅存储XY方向。

    切线空间很多情况下都优于模型空间，而且可以节省美术人员的工作

    3.实践

    在计算光照模型时，要统一各个方向矢量所在的坐标空间。由于法线纹理中存储的法线是切线空间下的方向，因此有两种选择：

    1. 在切线空间下进行光照计算，把光照方向、视角方向变换到切线空间下
    2. 在世界空间下进行光照计算，把采样到的切线方向变换到世界空间下

    效率上，第一种更优：可以在顶点着色器中就完成对光照方向和视角方向的变换，第二种要先对法线纹理进行采样，所以变换过程必须在片元着色器，必须在片元着色器中进行一次矩阵操作。

    通用性，第二种更优：要在世界空间下计算。如果在采样的同时进行法线映射，就需要把法线方向变换到世界空间下。

    也可以选择其他坐标空间计算，如模型空间等，但切线空间和世界空间是最常见的

    在切线空间下：

    效果如下：

    代码如下：

    1. Shader "Shader/NormalMap"
    2. {
    3.     Properties
    4.     {
    5.         _Color ("Color", Color) = (1,1,1,1)
    6.         _MainTex ("Texture", 2D) = "white" {}
    7.         _BumpMap ("Normal Map", 2D) = "bump" {}//unity内置法线纹理bump
    8.         _BumpScale ("Bump Scale", Float) = 1//控制凹凸程度
    9.         _Specular ("Sprcular", Color) = (1,1,1,1)
    10.         _Gloss ("Gloss", Range(8.0, 256)) = 20
    11.     }
    12.     SubShader
    13.     {
    14.         Tags { "RenderType"="Opaque" }
    15.  
    16.         Pass
    17.         {
    18.             CGPROGRAM
    19.             #pragma vertex vert
    20.             #pragma fragment frag
    21.  
    22.             #include "UnityCG.cginc"  
    23.             #include "Lighting.cginc"         
    24.  
    25.             struct appdata
    26.             {
    27.                 float4 vertex : POSITION;
    28.                 float3 normal : NORMAL;
    29.                 float4 tangent : TANGENT;
    30.                 float4 uv : TEXCOORD0;
    31.  
    32.             };
    33.  
    34.             struct v2f
    35.             {
    36.                 float4 pos : SV_POSITION;
    37.                 float4 uv : TEXCOORD0;
    38.                 float3 LightDir : TEXCOORD1;
    39.                 float3 ViewDir : TEXCOORD2;
    40.             };
    41.  
    42.             fixed4 _Color;
    43.             sampler2D _MainTex;
    44.             float4 _MainTex_ST;
    45.             sampler2D _BumpMap;
    46.             float4 _BumpMap_ST;
    47.             float _BumpScale;
    48.             fixed4 _Specular;
    49.             float _Gloss;
    50.  
    51.             v2f vert (appdata v)
    52.             {
    53.                 v2f o;
    54.                 o.pos = UnityObjectToClipPos(v.vertex);
    55.  
    56.                 o.uv.xy = v.uv.xy * _MainTex_ST.xy + _MainTex_ST.zw;
    57.                 o.uv.zw = v.uv.xy * _BumpMap_ST.xy + _BumpMap_ST.zw;
    58.  
    59.                 TANGENT_SPACE_ROTATION;
    60.  
    61.                 o.LightDir = mul(rotation, ObjSpaceLightDir(v.vertex)).xyz;
    62.  
    63.                 o.ViewDir = mul(rotation, ObjSpaceViewDir(v.vertex)).xyz;
    64.  
    65.                 return o;
    66.             }
    67.  
    68.             fixed4 frag (v2f i) : SV_Target
    69.             {
    70.                 fixed3 tlDir = normalize(i.LightDir);
    71.                 fixed3 tvDir = normalize(i.ViewDir);
    72.  
    73.                 fixed4 packedNormal = tex2D(_BumpMap, i.uv.zw);
    74.                 fixed3 tangentNormal;
    75.  
    76.                 tangentNormal = UnpackNormal(packedNormal);
    77.                 tangentNormal.xy *= _BumpScale;
    78.                 tangentNormal.z = sqrt(1.0 - 
    79.                                   saturate(dot(tangentNormal.xy, tangentNormal.xy)));
    80.  
    81.                 fixed3 albedo = tex2D(_MainTex, i.uv).rgb * _Color.rgb;
    82.  
    83.                 fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * albedo;
    84.  
    85.                 fixed3 diffuse = _LightColor0.rgb * albedo * 
    86.                                  max(0, dot(tangentNormal, tlDir));
    87.  
    88.                 fixed3 halfDir = normalize(tlDir + tvDir);
    89.                 fixed3 specular = _LightColor0.rgb * _Specular.rgb * 
    90.                                   pow(max(0, dot(tangentNormal, halfDir)), _Gloss);
    91.  
    92.                 return fixed4(ambient + diffuse + specular, 1.0);
    93.             }
    94.             ENDCG
    95.         }
    96.     }
    97.     Fallback "Specular"
    98. }

    在世界空间下：

     

    1. // Upgrade NOTE: replaced '_Object2World' with 'unity_ObjectToWorld'
    2.  
    3. Shader "Shader/NormalMap"
    4. {
    5.     Properties
    6.     {
    7.         _Color ("Color", Color) = (1,1,1,1)
    8.         _MainTex ("Texture", 2D) = "white" {}
    9.         _BumpMap ("Normal Map", 2D) = "bump" {}//unity内置法线纹理bump
    10.         _BumpScale ("Bump Scale", Float) = 1//控制凹凸程度
    11.         _Specular ("Sprcular", Color) = (1,1,1,1)
    12.         _Gloss ("Gloss", Range(8.0, 256)) = 20
    13.     }
    14.     SubShader
    15.     {
    16.         Tags { "RenderType"="Opaque" }
    17.  
    18.         Pass
    19.         {
    20.             CGPROGRAM
    21.             #pragma vertex vert
    22.             #pragma fragment frag
    23.  
    24.             #include "UnityCG.cginc"  
    25.             #include "Lighting.cginc"         
    26.  
    27.             struct appdata
    28.             {
    29.                 float4 vertex : POSITION;
    30.                 float3 normal : NORMAL;
    31.                 float4 tangent : TANGENT;
    32.                 float4 uv : TEXCOORD0;
    33.  
    34.             };
    35.  
    36.             struct v2f
    37.             {
    38.                 float4 pos : SV_POSITION;
    39.                 float4 uv : TEXCOORD0;
    40.                 float4 TtoW0 : TEXCOORD1;
    41.                 float4 TtoW1 : TEXCOORD2;
    42.                 float4 TtoW2 : TEXCOORD3;
    43.             };
    44.  
    45.             fixed4 _Color;
    46.             sampler2D _MainTex;
    47.             float4 _MainTex_ST;
    48.             sampler2D _BumpMap;
    49.             float4 _BumpMap_ST;
    50.             float _BumpScale;
    51.             fixed4 _Specular;
    52.             float _Gloss;
    53.  
    54.             v2f vert (appdata v)
    55.             {
    56.                 v2f o;
    57.                 o.pos = UnityObjectToClipPos(v.vertex);
    58.  
    59.                 o.uv.xy = v.uv.xy * _MainTex_ST.xy + _MainTex_ST.zw;
    60.                 o.uv.zw = v.uv.xy * _BumpMap_ST.xy + _BumpMap_ST.zw;
    61.  
    62.                 float3 worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
    63.                 fixed3 worldNormal = UnityObjectToWorldNormal(v.normal);
    64.                 fixed3 worldTangent = UnityObjectToWorldDir(v.tangent.xyz);
    65.                 fixed3 worldBinormal = cross(worldNormal, worldTangent) * v.tangent.w;
    66.  
    67.                 o.TtoW0 = float4(worldTangent.x, worldBinormal.x, worldNormal.x, worldPos.x);
    68.                 o.TtoW1 = float4(worldTangent.y, worldBinormal.y, worldNormal.y, worldPos.y);
    69.                 o.TtoW2 = float4(worldTangent.z, worldBinormal.z, worldNormal.z, worldPos.z);
    70.  
    71.                 return o;
    72.             }
    73.  
    74.             fixed4 frag (v2f i) : SV_Target
    75.             {
    76.                 float3 worldPos = float3(i.TtoW0.w, i.TtoW1.w, i.TtoW2.w);
    77.                 fixed3 lightDir = normalize(UnityWorldSpaceLightDir(worldPos));
    78.                 fixed3 viewDir = normalize(UnityWorldSpaceViewDir(worldPos));
    79.  
    80.                 fixed3 bump = UnpackNormal(tex2D(_BumpMap, i.uv.zw));
    81.                 bump.xy *= _BumpScale;
    82.                 bump.z = sqrt(1.0 - saturate(dot(bump.xy, bump.xy)));
    83.  
    84.                 bump = normalize(half3(dot(i.TtoW0.xyz, bump), 
    85.                                        dot(i.TtoW1.xyz, bump), 
    86.                                        dot(i.TtoW2.xyz, bump)));
    87.  
    88.                 fixed3 albedo = tex2D(_MainTex, i.uv).rgb * _Color.rgb;
    89.  
    90.                 fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * albedo;
    91.  
    92.                 fixed3 diffuse = _LightColor0.rgb * albedo * 
    93.                                  max(0, dot(bump, lightDir));
    94.  
    95.                 fixed3 halfDir = normalize(lightDir + viewDir);
    96.                 fixed3 specular = _LightColor0.rgb * _Specular.rgb * 
    97.                                   pow(max(0, dot(bump, halfDir)), _Gloss);
    98.  
    99.                 return fixed4(ambient + diffuse + specular, 1.0);
    100.             }
    101.             ENDCG
    102.         }
    103.     }
    104.     Fallback "Specular"
    105. }

    4.unity中法线纹理类型

    把法线纹理的纹理类型标识成Normal map时，可以使用Unity的内置函数UnpackNormal来得到正确的法线方向

    当我们使用那些包含了法线映射的内置的UnityShader时，必须把使用的法线纹理按上面的方式标识成Normal map，才能得到正确结果

    三、渐变纹理

    纹理可以用于储存任何表面属性。如使用渐变纹理来控制漫反射光照的结果。这样可以更灵活的控制光照结果

    基于冷暖色调的着色技术，这种技术可以保证物体的轮廓线相比于之前使用的传统漫反射光照更加明显，而且能够提供多种色调变化。

    1. // Upgrade NOTE: replaced '_Object2World' with 'unity_ObjectToWorld'
    2.  
    3. Shader "Shader/RampTexture"
    4. {
    5.     Properties
    6.     {
    7.         _Color ("Color", Color) = (1,1,1,1)
    8.         _RampTex ("Ramp Tex", 2D) = "white" {}
    9.         _Specular ("Sprcular", Color) = (1,1,1,1)
    10.         _Gloss ("Gloss", Range(8.0, 256)) = 20
    11.     }
    12.     SubShader
    13.     {
    14.         Tags { "RenderType"="Opaque" }
    15.  
    16.         Pass
    17.         {
    18.             Tags { "LightMode"="ForwardBase" }
    19.  
    20.             CGPROGRAM
    21.             #pragma vertex vert
    22.             #pragma fragment frag
    23.  
    24.             #include "UnityCG.cginc"
    25.             #include "Lighting.cginc"
    26.  
    27.             struct appdata
    28.             {
    29.                 float4 vertex : POSITION;
    30.                 float3 normal : NORMAL;
    31.                 float4 uv     : TEXCOORD0;
    32.             };
    33.  
    34.             struct v2f
    35.             {
    36.                 float4 pos : SV_POSITION;
    37.                 float3 worldNormal : TEXCOORD0;
    38.                 float3 worldPos : TEXCOORD1;
    39.                 float2 uv : TEXCOORD2;
    40.             };
    41.  
    42.             fixed4 _Color;
    43.             sampler2D _RampTex;
    44.             float4 _RampTex_ST;
    45.             fixed4 _Specular;
    46.             float _Gloss;
    47.  
    48.  
    49.             v2f vert (appdata v)
    50.             {
    51.                 v2f o;
    52.                 o.pos = UnityObjectToClipPos(v.vertex);
    53.                 o.worldNormal = UnityObjectToWorldNormal(v.normal);
    54.                 o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
    55.                 o.uv = TRANSFORM_TEX(v.uv, _RampTex);
    56.  
    57.                 return o;
    58.             }
    59.  
    60.             fixed4 frag (v2f i) : SV_Target
    61.             {
    62.                 fixed3 worldNormal = normalize(i.worldNormal);
    63.                 fixed3 worldLightDir = normalize(UnityWorldSpaceLightDir(i.worldPos));
    64.  
    65.                 fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz;
    66.  
    67.                 fixed halfLambert = 0.5 * dot(worldNormal, worldLightDir) + 0.5;
    68.                 fixed3 diffuseColor = tex2D(_RampTex, fixed2(halfLambert, halfLambert)).rgb 
    69.                                       * _Color.rgb;
    70.  
    71.                 fixed3 diffuse = _LightColor0.rgb * diffuseColor;
    72.  
    73.                 fixed3 viewDir = normalize(UnityWorldSpaceViewDir(i.worldPos));
    74.                 fixed3 halfDir = normalize(worldNormal + worldLightDir);
    75.                 fixed3 specular = _LightColor0.rgb * _Specular.rgb * 
    76.                                   pow(max(0, dot(worldNormal, halfDir)), _Gloss);
    77.  
    78.                 return fixed4(ambient + diffuse + specular, 1.0);
    79.             }
    80.             ENDCG
    81.         }
    82.     }
    83. }

    注意：要把渐变纹理的Warp设为Clamp，以防止对纹理进行采样时由于浮点数精度而造成的问题

    四、遮罩纹理

    遮罩允许我们可以保护某些区域，使他们免于某些修改。更细腻的去控制光照。制作地形材质时混合多张图片，使用遮罩可以控制任何混合这些纹理。

    使用遮罩的流程：

    1. 通过采样得到遮罩纹理的纹素值
    2. 然后使用其中某个（或几个）通道值（如texel.r）来与某种表面属性进行相乘
    3. 这样当该通道值为0时，可以保护该表面不是该属性的影响

    总之，使用遮罩可以让美术人员更加精准（像素级别）地控制模型表面的各种性质

    1.实践

    1. Shader "Shader/MaskTexture"
    2. {
    3.     Properties
    4.     {
    5.         _Color ("Color", Color) = (1,1,1,1)
    6.         _MainTex ("Texture", 2D) = "white" {}
    7.         _BumpMap ("Normal Map", 2D) = "bump" {}//unity内置法线纹理bump
    8.         _BumpScale ("Bump Scale", Float) = 1//控制凹凸程度
    9.         _SpecularMask ("Specular Mask", 2D) = "white" {}//高光反射遮罩纹理
    10.         _SpecularScale ("Specular Scale", Float) = 1.0//控制遮罩影响度的系数
    11.         _Specular ("Sprcular", Color) = (1,1,1,1)
    12.         _Gloss ("Gloss", Range(8.0, 256)) = 20
    13.     }
    14.     SubShader
    15.     {
    16.         Tags { "RenderType"="Opaque" }
    17.  
    18.         Pass
    19.         {
    20.             Tags { "LightMode"="ForwardBase" }
    21.  
    22.             CGPROGRAM
    23.             #pragma vertex vert
    24.             #pragma fragment frag
    25.  
    26.             #include "UnityCG.cginc"
    27.             #include "Lighting.cginc"
    28.  
    29.             struct appdata
    30.             {
    31.                 float4 vertex : POSITION;
    32.                 float3 normal : NORMAL;
    33.                 float4 tangent : TANGENT;
    34.                 float4 uv : TEXCOORD0;
    35.             };
    36.  
    37.             struct v2f
    38.             {
    39.                 float4 pos : SV_POSITION;
    40.                 float2 uv : TEXCOORD0;
    41.                 float3 lightDir : TEXCOORD1;
    42.                 float3 viewDir : TEXCOORD2;
    43.             };
    44.  
    45.             fixed4 _Color;
    46.             sampler2D _MainTex;
    47.             float4 _MainTex_ST;
    48.             sampler2D _BumpMap;
    49.             float _BumpScale;
    50.             sampler2D _SpecularMask;
    51.             float _SpecularScale;
    52.             fixed4 _Specular;
    53.             float _Gloss;
    54.  
    55.             v2f vert (appdata v)
    56.             {
    57.                 v2f o;
    58.                 o.pos = UnityObjectToClipPos(v.vertex);
    59.  
    60.                 o.uv.xy = v.uv.xy * _MainTex_ST.xy + _MainTex_ST.zw;
    61.  
    62.                 TANGENT_SPACE_ROTATION;
    63.  
    64.                 o.lightDir = mul(rotation, ObjSpaceLightDir(v.vertex)).xyz;
    65.                 o.viewDir = mul(rotation, ObjSpaceViewDir(v.vertex)).xyz;
    66.  
    67.                 return o;
    68.             }
    69.  
    70.             fixed4 frag (v2f i) : SV_Target
    71.             {
    72.                 fixed3 tangentLightDir = normalize(i.lightDir);
    73.                 fixed3 tangentViewDir = normalize(i.viewDir);
    74.  
    75.                 fixed3 tangentNormal = UnpackNormal(tex2D(_BumpMap, i.uv));
    76.                 tangentNormal.xy *= _BumpScale;
    77.                 tangentNormal.z = sqrt(1.0 - 
    78.                                   saturate(dot(tangentNormal.xy, tangentNormal.xy)));
    79.                 fixed3 albedo = tex2D(_MainTex, i.uv).rgb * _Color.rgb;
    80.  
    81.                 fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz;
    82.  
    83.                 fixed3 diffuse = _LightColor0.rgb * albedo * 
    84.                                  max(0, dot(tangentNormal, tangentLightDir));
    85.  
    86.                 fixed3 halfDir = normalize(tangentLightDir + tangentViewDir);
    87.  
    88.                 fixed specularMask = tex2D(_SpecularMask, i.uv).r * _SpecularScale;
    89.  
    90.                 fixed specular = _LightColor0.rgb * _Specular.rgb * pow(max(
    91.                                 0, dot(tangentNormal, halfDir)), _Gloss) * specularMask;
    92.  
    93.                 return fixed4(ambient + diffuse + specular, 1.0);
    94.             }
    95.             ENDCG
    96.         }
    97.     }
    98. }

    2.其他纹理遮罩

    遮罩纹理不止限于保护某些区域使它们免于某些修改，而是可以存储任何我们希望逐像素控制的表面属性。

    通常我们会充分利用一张纹理的RGBA四个通道，用于存储不同的属性。

    例如，把高光反射的强度存储在R通道，把边缘光照的强度存储在G通道，把高光反射指数部分存储在B通道，最后把自发光存储在A通道

  • 相关阅读:
    并发编程系列之Lock锁可重入性与公平性
    电子元器件B2B电商平台建设方案：优化企业商流，拓宽B2B交易渠道
    severlet运行原理
    成功解决：Xshell 无法连接虚拟机。如何使用Xshell连接CentOS7虚拟机（详细步骤过程）
    RabbitMQ 笔记
    【Flutter】Flutter 使用 RxDart 实现异步编程
    2023年信息院学生科协第二次硬件培训
    华泰证券：达达集团（DADA）3Q23业绩前瞻:短期业绩承压
    网络技术五：IP基本原理
    【C++ 提高编程】- 泛型编程之模板(类型参数化)
  • 原文地址：https://blog.csdn.net/qq_65461674/article/details/139395458