庄懂的技术美术入门课 - 前向渲染

float lambert = max(0.0, nDotl);
float2 uv = float2(lambert, 0.0);
float4 var_MainTex = tex2D(_MainTex, uv);
return float4(var_MainTex);

Shader "Zhuangdong/AP1/L02/Lambert_U_01" {
    Properties{}
    SubShader{
        Tags { "RenderType" = "Opaque" }
        Pass {
            Name "FORWARD"
            Tags { "LightMode" = "ForwardBase" }
            CGPROGRAM//着色器编译指令
            #pragma vertex vert//声明顶点着色器
            #pragma fragment frag//声明片段着色器
            #include "UnityCG.cginc"//引入 Unity 内置 CG 库
            #pragma multi_compile_fwdbase_fullshadows//启用阴影功能
            #pragma target 3.0//指定 shader 模型版本
            //上面这些类似上下文,但功能更多.
            //声明顶点着色器和片段着色器,下面的 vert,frag 函数才能启用.
            //还可以选择开启和关闭功能,比如启用阴影功能.以及指定 shader 模型版本
            struct VertexInput { 
            //导入模型顶点信息和法线信息
            //POSITION NORMAL 这类词可以看 UNITY 官方 Document 查看意思
                float4 vertex : POSITION;
                float3 normal : NORMAL;
            };
            struct VertexOutput {
            //通过上面的模型顶点信息换算成顶点屏幕位置
            //模型法线信息换算成世界空间法线信息
                float4 pos : SV_POSITION;
                float3 nDirWS : TEXCOORD0;
            };
            VertexOutput vert(VertexInput v) {
            //顶点着色器固定写法 v2f vert (appdata v), Output vert (input 变量名)
                VertexOutput o = (VertexOutput)0;
                o.pos = UnityObjectToClipPos(v.vertex);//模型顶点位置转换成顶点屏幕位置
                o.nDirWS = UnityObjectToWorldNormal(v.normal);//法线转成世界法线
                return o;
            }
            float4 frag(VertexOutput i) : COLOR{
            //片段着色器固定写法
                float3 nDir = i.nDirWS;
                float3 lDir = normalize(_WorldSpaceLightPos0.xyz);
                //0 代表平行光,后面 xyz 代表方向,1 代表点光,xyz 代表点光坐标
                //normalize 归一化保证渲染结果不出错
                float nDotl = (dot(nDir, lDir)*0.5+0.5);//halflambert
                float lambert = max(0.0, nDotl);
                //有的手机机型会把 0 视为 0.1 这类小数,所以最好写 0.0,不然会出错.
                //使用 max 而不是 clamp,是因为 clamp 限制两头,max 限制一头,更省性能,因为点乘不会大于 1
                return float4(lambert, lambert, lambert, 1.0);
            }
            ENDCG
        }
    }
    FallBack "Diffuse"
}

// 片段着色器示例
float3 nDir = normalize(i.nDirWS);
float3 lDir = _WorldSpaceLightPos0.xyz;
float3 vDir = normalize(_WorldSpaceCameraPos.xyz - i.posWS.xyz);
float3 rDir = reflect(-lDir, nDir);
float rDotv = dot(rDir, vDir);
float nDotl = dot(nDir, lDir);
float Lambert = nDotl * 0.5 + 0.5;
float Phong = pow(max(0.0, rDotv), _SpecPow);
float3 FinalColor = _BaseColor * Lambert + Phong;
return float4(FinalColor, 1.0);

float3 nDir = i.nDirWS;
float TopMask = max(0.0, nDir.g);
float BotMask = max(0.0, -nDir.g);
float MidMask = 1 - TopMask - BotMask;
float3 EnvCol = _TopCol * TopMask + _MidCol * MidMask + _BotCol * BotMask;
float AO = tex2D(_AoMap, i.uv);
float3 EnvLighting = EnvCol * AO;
return float4(EnvLighting, 1.0);

//给 Shader 增加投影
struct VertexOutput { 
...
LIGHTING_COORDS(3,4)};//在 VertexOutput 加入 LIGHT_COORDS
VertexOutput vert(VertexInput v) { 
VertexOutput o = (VertexOutput)0;
...
TRANSFER_VERTEX_TO_FRAGMENT(o)//顶点着色器加入 TRANSFER_VERTEX_TO_FRAGMENT
...
return o;}
float4 frag(VertexOutput i) : COLOR{
float shadow = LIGHT_ATTENUATION(i);//片段着色器加入 LIGHT_ATTENUATION
...}

VertexOutput vert(VertexInput v) { 
    VertexOutput o = (VertexOutput)0;
        o.pos = UnityObjectToClipPos(v.vertex);
        o.uv0 = v.uv0;
        o.posWS = mul(unity_ObjectToWorld, v.vertex);
        o.nDirWS = UnityObjectToWorldNormal(v.normal); 
        o.tDirWS = normalize( mul( unity_ObjectToWorld, float4( v.tangent.xyz, 0.0 ) ).xyz );//切线方向 OStoWS
        o.bDirWS = normalize(cross(o.nDirWS, o.tDirWS) * v.tangent.w);//根据 nDir tDir 求 bDir
        TRANSFER_VERTEX_TO_FRAGMENT(o)
    return o;
}
float4 frag(VertexOutput i) : COLOR{
    //向量
    float3 nDirTS = UnpackNormal(tex2D(_NormalMap, i.uv0)).rgb;
    float3x3 TBN = float3x3(i.tDirWS, i.bDirWS, i.nDirWS);//TBN 矩阵
    float3 nDirWS = normalize(mul(nDirTS, TBN));//转世界空间

float3 vrDirWS = reflect(-vDirWS, nDirWS);
float3 cubemap = texCUBElod(_CubeMap, float4(vrDirWS, _CubemapMip));

uniform sampler2D _MainTex; 
uniform float4 _MainTex_ST

VertexOutput vert(VertexInput v) { 
    VertexOutput o = (VertexOutput)0;
    // 使用TRANSFORM_TEX宏或手动计算
    o.uv0 = TRANSFORM_TEX(v.uv0, _MainTex);
    // 等价于: o.uv0 = v.uv0 * _MainTex_ST.xy + _MainTex_ST.zw;
    return o;
}

float TopMask = max(0.0, nDirWS.g);
float BotMask = max(0.0, -nDirWS.g);
float MidMask = 1 - TopMask - BotMask;
float3 EnvCol = _TopCol * TopMask +
                _MidCol * MidMask +
                _BotCol * BotMask;

float3 TriColAmbient (float3 n, float3 uCol, float3 sCol, float3 dCol){
    float uMask = max(0.0, n.g);
    float dMask = max(0.0, -n.g);
    float sMask = 1.0 - uMask - dMask;
    float3 envCol = uCol * uMask +
                    sCol * sMask +
                    dCol * dMask;
    return envCol;
}

// 使用函数
float3 envCol = TriColAmbient(nDirWS, _EnvUpCol, _EnvSideCol, _EnvDownCol);

#ifndef MY_CGINC
#define MY_CGINC
float3 TriColAmbient (float3 n, float3 uCol, float3 sCol, float3 dCol){
    float uMask = max(0.0, n.g);
    float dMask = max(0.0, -n.g);
    float sMask = 1.0 - uMask - dMask;
    float3 envCol = uCol * uMask +
                    sCol * sMask +
                    dCol * dMask;
    return envCol;
}
#endif

CGPROGRAM
// ... 其他代码 ...
#include "../cginc/MyCginc.cginc"
// ... 其他代码 ...
float3 envCol = TriColAmbient(nDirWS, _EnvUpCol, _EnvSideCol, _EnvDownCol);

Shader "Zhuangdong/AP1/L06/L06_ogre_Feedback" {
    Properties{
        [Header(Texture)]
        _MainTex ("RGB:基础颜色 A:透明贴图", 2D) = "White" {}
        [Normal] _NormalMap ("RGB:法线贴图", 2D) = "bump" {}
        _DetailMap ("RGB: Detail 细节贴图 A: 细节遮罩", 2D) = "black" {}
        _MetalnessMask ("金属遮罩", 2D) = "black" {}
        _SelfIllMask ("SelfIll 自发光遮罩", 2D) = "black" {}
        _SpecTex ("RGB:Spec 高光贴图", 2D) = "gray" {}
        _RimLight ("Rim 边缘光遮罩", 2D) = "black" {}
        _BaseTintMask ("Tint 底色遮罩", 2D) = "White" {}
        _SpecularExponent ("SpecExpo 镜面反射指数", 2D) = "White" {}
        _DiffuseWarp ("Diffuse 扩散遮罩", 2D) = "black" {}
        _CubeMap ("RGB:Cube 环境贴图", Cube) = "_Skybox" {}
        _FresnelWarp("菲涅尔贴图 R:FCol G:FRim B:FSpec", 2D) = "black" {}
        [Header(Diffuse)]
        _LightCol ("主光颜色", Color) = (1.0,1.0,1.0,1.0)
        [Space(10)]
        _TopCol ("顶部颜色", Color) = (0.47,0.96,1,1)
        _MidCol ("中部颜色", Color) = (0.46,0.7,0.45,1)
        _BotCol ("底部颜色", Color) = (0.75,0.39,0.39,1)
        _EnvDiffInt ("EnvDiff 环境漫反射强度", Range(0.0, 5.0)) = 0.2
        [Header(Specular)]
        _SpecPow("高光次幂", Range(0.0, 90.0)) = 5
        _SpecInt("高光强度", Range(0.0, 10.0)) = 5
        [Space(10)]
        _EnvSpecint ("Envspec 环境镜反强度", Range(0.0, 10.0)) = 0.2
        [Header(SelfIll)]
        _SelfIllInt ("SelfIll 自发光强度", Range(0, 10)) = 1
        [HDR]_RimCol ("轮廓光颜色", Color) = (1.0,1.0,1.0,1.0) 
        _RimInt ("轮廓光强度", Range(0.0, 3.0)) = 1.0
        [HideInInspector]
        _Cutoff ("Alpha cutoff", Range(0,1)) = 0.5
        [HideInInspector]
        _Color ("Main Color", Color) = (1,1,1,1)//Fallback Require
    }
    SubShader{
        Tags {
            "RenderType" = "Opaque"
        }
        Pass {
            Name "FORWARD"
            Tags {
                "LightMode" = "ForwardBase"
            }
            Cull Off
            CGPROGRAM 
            #pragma vertex vert 
            #pragma fragment frag 
            #include "UnityCG.cginc" 
            #include "AutoLight.cginc"//自动处理光照衰减来进行阴影处理
            #include "Lighting.cginc"//主要用于访问环境主平行光相关数据
            #pragma multi_compile_fwdbase_fullshadows //启用阴影功能
            #pragma target 3.0 
            //Texture
            uniform sampler2D _MainTex;
            uniform sampler2D _NormalMap;
            uniform sampler2D _DetailMap;
            uniform sampler2D _MetalnessMask;
            uniform sampler2D _SelfIllMask;
            uniform sampler2D _SpecTex;
            uniform sampler2D _RimLight;
            uniform sampler2D _BaseTintMask;
            uniform sampler2D _SpecularExponent;
            uniform sampler2D _DiffuseWarp;
            uniform samplerCUBE _CubeMap;
            uniform sampler2D _FresnelWarp;
            //Diffuse
            uniform half3 _LightCol;
            uniform fixed3 _TopCol;
            uniform fixed3 _MidCol;
            uniform fixed3 _BotCol;
            uniform fixed  _EnvDiffInt;
            //Specular
            uniform half _SpecPow;
            uniform half _SpecInt;
            uniform half _EnvSpecint;
            //SelfIll
            uniform fixed _SelfIllInt;
            uniform half3 _RimCol;
            uniform half _RimInt;
            uniform half _Cutoff;
            struct VertexInput {
            Document查看意思
                float4 vertex  : POSITION; 
                float2 uv0     : TEXCOORD0;
                float3 normal  : NORMAL; 
                float4 tangent : TANGENT; 
            };
            struct VertexOutput { 
            法线信息
                float4 pos : SV_POSITION; 
                float2 uv0 : TEXCOORD0;  
                float3 posWS : TEXCOORD1; 
                float3 nDirWS : TEXCOORD2;  
                float3 tDirWS : TEXCOORD3;  
                float3 bDirWS : TEXCOORD4;  
                LIGHTING_COORDS(5,6)
            };
            VertexOutput vert(VertexInput v) { 
                VertexOutput o = (VertexOutput)0;
                    o.pos = UnityObjectToClipPos(v.vertex); 
                    o.uv0 = v.uv0;
                    o.posWS = mul(unity_ObjectToWorld, v.vertex); 
                    o.nDirWS = UnityObjectToWorldNormal(v.normal);
                    o.tDirWS = normalize( mul( unity_ObjectToWorld,
                     float4( v.tangent.xyz, 0.0 ) ).xyz );
                    o.bDirWS = normalize(cross(o.nDirWS, o.tDirWS) * v.tangent.w);
                    TRANSFER_VERTEX_TO_FRAGMENT(o)
                return o;
            }
            float4 frag(VertexOutput i) : COLOR{ 
                //向量
                half3 nDirTS = UnpackNormal(tex2D(_NormalMap, i.uv0)).rgb;
                half3x3 TBN = float3x3(i.tDirWS, i.bDirWS, i.nDirWS);
                half3 nDirWS = normalize(mul(nDirTS, TBN));
                half3 vDirWS = normalize(_WorldSpaceCameraPos.xyz - i.posWS.xyz);
                half3 vrDirWS = reflect(-vDirWS, nDirWS);
                half3 lDirWS = _WorldSpaceLightPos0.xyz; 
                表点光坐标,归一化比较安全,点乘结果会比较正确点
                half3 lrDirWS = reflect(-lDirWS, nDirWS);
                float shadow = LIGHT_ATTENUATION(i);
                //点乘
                half  rDotv = dot(vDirWS, lrDirWS);//Phong
                half  nDotl = dot(nDirWS, lDirWS);//Lambert
                half  ndotv = dot(nDirWS, vDirWS);
                //采样纹理
                half4 var_MainTex = tex2D(_MainTex, i.uv0);
                half4 var_DetailMap = tex2D(_DetailMap, i.uv0);
                half  var_MetalnessMask = tex2D(_MetalnessMask, i.uv0);
                half var_SelfIllMask = tex2D(_SelfIllMask, i.uv0);
                half var_SpecTex = tex2D(_SpecTex, i.uv0);//specInt
                half  var_RimLight = tex2D(_RimLight, i.uv0);
                half  var_BaseTintMask = tex2D(_BaseTintMask, i.uv0);
                half  var_SpecularExponent = tex2D(_SpecularExponent, i.uv0);//specSize
                half3 var_Cubemap = texCUBElod(_CubeMap, float4(vrDirWS, lerp(8.0, 0.0, 
                var_MetalnessMask))).rgb;
                half3 var_FresnelWarp = tex2D(_FresnelWarp, ndotv);
                //提取信息
                half3 BaseCol = var_MainTex.rgb;
                half  Opacity = var_MainTex.a;
                half  MetalMask = var_MetalnessMask;
                half  RimLightInt = var_RimLight;
                half  TintMask = var_BaseTintMask;
                half  SpecExp = var_SpecularExponent;
                half3 EnvCube = var_Cubemap;
                half  SpecInt = var_SpecTex;
                half  EmitInt = var_SelfIllMask;
                //光照模型
                    half3 DiffCol = lerp(BaseCol, half3(0.0,0.0,0.0), MetalMask);
                    //越接近金属,漫反射越弱
                    half3 SpecCol = lerp(BaseCol, half3(0.3,0.3,0.3), TintMask) * SpecInt;
                    //根据 TintMask 决定高光颜色
                    //0.3 是经验值,这个值乘以高光强度 specInt 得到的高光颜色贴图比较舒服
                    //菲涅尔
                    half3 Fresnel = lerp(var_FresnelWarp, 0.0, MetalMask);
                    //金属度越高,菲涅尔现象越不明显;
                    half  FreCol = Fresnel.r; //无实际用途
                    half  FreRim = Fresnel.g; //轮廓光用 Fresnel
                    half  FreSpec = Fresnel.b; //镜面反射用 Fresnel
                    //主光漫反射
                    half  HalfLambert = nDotl * 0.5 + 0.5;//Halflambert
                    half3 var_DiffuseWarp = tex2D(_DiffuseWarp, half2(HalfLambert, 0.2));
                    //对 Ramptexture 进行采样
                    half3 DirDiff = DiffCol * var_DiffuseWarp * _LightCol;
                    //主光镜面反射
                    half Phong = pow(max(0.0, rDotv), SpecExp * _SpecPow);
                    half Spec = Phong * max(0.0,nDotl);
                    Spec = max(Spec, FreSpec);
                    //会有个油亮的视觉效果,强烈的菲涅尔现象和 Phong 混合在一起
                    Spec = Spec * _SpecInt;
                    //乘以 SpecInt 后,大部分之前 Spec 的效果会消失,只有 SpecInt 指定的范围才有亮点
                    //原 Shader 是将所有镜面反射整合在一起最后再 max(flMetalnessMask, flSpecWarp)
                    //这里作者对镜面反射进行拆分,所以两边最后结算都需要进行一次 max
                    half3 DirSpec = SpecCol * Spec * _LightCol;
                    //环境漫反射
                    float TopMask = max(0.0, nDirWS.g);
                    float BotMask = max(0.0, -nDirWS.g);
                    float MidMask = 1 - TopMask - BotMask;
                    float3 EnvCol = _TopCol * TopMask + 
                                    _MidCol * MidMask + 
                                    _BotCol * BotMask;
                    float3 EnvDiff = DiffCol * EnvCol * _EnvDiffInt;
                    //视频作者只用了单色,这里我是直接复制之前的案例代码没有改
                    //环境镜面反射
                    half ReflectInt = max(FreSpec, MetalMask) * SpecInt;
                    //金属部分 MetalMask 最大,非金属 FreSpec 最大
                    //这样非金属有很强的菲涅尔现象,金属部分则很少,取而代之的有很强的反射现象
                    half3 EnvSpec = SpecCol * ReflectInt * EnvCube * _EnvSpecint;
                    //轮廓光
                    half3 RimLight = _RimCol * FreRim * RimLightInt * max(0.0, nDirWS.g) * _RimInt;
                    //轮廓光只出现在顶部,所以需要用 normal.g
                    //FreRim 定义菲涅尔现象,RimLightInt 定义强度范围,RimInt 定义强度
                    //自发光
                    float3 emission = EmitInt * DiffCol * _SelfIllInt;
                    //Final
                    half3 FinalRGB = (DirDiff + DirSpec) * shadow + EnvDiff + EnvSpec + RimLight + 
                    emission;
                clip(Opacity - _Cutoff);//小于_Cutoff 全部删去,大于的保留
                return float4(FinalRGB, 1.0);
            }
            ENDCG
        }
    }
    Fallback "Legacy Shaders/Transparent/Cutout/VertexLit"
    //注:使用 FallBack 必须声明一个_Color: 颜色,即使你用不到
}