Zhuangdong's Technical Art Introduction Course - Forward Rendering

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//Shader compilation directive
            #pragma vertex vert//Declare vertex shader
            #pragma fragment frag//Declare fragment shader
            #include "UnityCG.cginc"//Include Unity built-in CG library
            #pragma multi_compile_fwdbase_fullshadows//Enable shadow functionality
            #pragma target 3.0//Specify shader model version
            //The above are similar to context, but with more functionality.
            //Declare vertex shader and fragment shader, so the vert, frag functions below can be enabled.
            //You can also choose to enable and disable features, such as enabling shadow functionality. And specify shader model version
            struct VertexInput { 
            //Import model vertex information and normal information
            //Words like POSITION NORMAL can be found in UNITY official Document to see their meaning
                float4 vertex : POSITION;
                float3 normal : NORMAL;
            };
            struct VertexOutput {
            //Convert the above model vertex information to vertex screen position
            //Convert model normal information to world space normal information
                float4 pos : SV_POSITION;
                float3 nDirWS : TEXCOORD0;
            };
            VertexOutput vert(VertexInput v) {
            //Fixed vertex shader writing: v2f vert (appdata v), Output vert (input variable name)
                VertexOutput o = (VertexOutput)0;
                o.pos = UnityObjectToClipPos(v.vertex);//Convert model vertex position to vertex screen position
                o.nDirWS = UnityObjectToWorldNormal(v.normal);//Convert normal to world normal
                return o;
            }
            float4 frag(VertexOutput i) : COLOR{
            //Fixed fragment shader writing
                float3 nDir = i.nDirWS;
                float3 lDir = normalize(_WorldSpaceLightPos0.xyz);
                //0 represents directional light, xyz represents direction, 1 represents point light, xyz represents point light coordinates
                //normalize ensures rendering results don't go wrong
                float nDotl = (dot(nDir, lDir)*0.5+0.5);//halflambert
                float lambert = max(0.0, nDotl);
                //Some mobile devices treat 0 as 0.1 or similar decimals, so it's better to write 0.0, otherwise errors will occur.
                //Using max instead of clamp is because clamp limits both ends, max limits one end, more performance efficient, because dot product won't be greater than 1
                return float4(lambert, lambert, lambert, 1.0);
            }
            ENDCG
        }
    }
    FallBack "Diffuse"
}

// Fragment shader example
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);

//Add shadows to Shader
struct VertexOutput { 
...
LIGHTING_COORDS(3,4)};//Add LIGHT_COORDS to VertexOutput
VertexOutput vert(VertexInput v) { 
VertexOutput o = (VertexOutput)0;
...
TRANSFER_VERTEX_TO_FRAGMENT(o)//Add TRANSFER_VERTEX_TO_FRAGMENT to vertex shader
...
return o;}
float4 frag(VertexOutput i) : COLOR{
float shadow = LIGHT_ATTENUATION(i);//Add LIGHT_ATTENUATION to fragment shader
...}

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 );//Tangent direction OStoWS
        o.bDirWS = normalize(cross(o.nDirWS, o.tDirWS) * v.tangent.w);//Calculate bDir based on nDir tDir
        TRANSFER_VERTEX_TO_FRAGMENT(o)
    return o;
}
float4 frag(VertexOutput i) : COLOR{
    //Vectors
    float3 nDirTS = UnpackNormal(tex2D(_NormalMap, i.uv0)).rgb;
    float3x3 TBN = float3x3(i.tDirWS, i.bDirWS, i.nDirWS);//TBN matrix
    float3 nDirWS = normalize(mul(nDirTS, TBN));//Convert to world space

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

uniform sampler2D _MainTex; uniform float4 _MainTex_ST
...
VertexOutput vert(VertexInput v) { 
...
o.uv0 = TRANSFORM_TEX(v.uv0, _MainTex);& o.uv0 = v.uv0 * _MainTex_ST.xy + _MainTex_ST.zw;
...}

Shader "Zhuangdong/AP1/L06/L06_ogre_Feedback" {
    Properties{
        [Header(Texture)]
        _MainTex ("RGB:Base color A:Transparency texture", 2D) = "White" {}
        [Normal] _NormalMap ("RGB:Normal map", 2D) = "bump" {}
        _DetailMap ("RGB:Detail texture A:Detail mask", 2D) = "black" {}
        _MetalnessMask ("Metal mask", 2D) = "black" {}
        _SelfIllMask ("SelfIll emission mask", 2D) = "black" {}
        _SpecTex ("RGB:Spec highlight texture", 2D) = "gray" {}
        _RimLight ("Rim edge light mask", 2D) = "black" {}
        _BaseTintMask ("Tint base color mask", 2D) = "White" {}
        _SpecularExponent ("SpecExpo specular reflection exponent", 2D) = "White" {}
        _DiffuseWarp ("Diffuse diffusion mask", 2D) = "black" {}
        _CubeMap ("RGB:Cube environment texture", Cube) = "_Skybox" {}
        _FresnelWarp("Fresnel texture R:FCol G:FRim B:FSpec", 2D) = "black" {}
        [Header(Diffuse)]
        _LightCol ("Main light color", Color) = (1.0,1.0,1.0,1.0)
        [Space(10)]
        _TopCol ("Top color", Color) = (0.47,0.96,1,1)
        _MidCol ("Middle color", Color) = (0.46,0.7,0.45,1)
        _BotCol ("Bottom color", Color) = (0.75,0.39,0.39,1)
        _EnvDiffInt ("EnvDiff ambient diffuse intensity", Range(0.0, 5.0)) = 0.2
        [Header(Specular)]
        _SpecPow("Highlight power", Range(0.0, 90.0)) = 5
        _SpecInt("Highlight intensity", Range(0.0, 10.0)) = 5
        [Space(10)]
        _EnvSpecint ("Envspec ambient specular intensity", Range(0.0, 10.0)) = 0.2
        [Header(SelfIll)]
        _SelfIllInt ("SelfIll emission intensity", Range(0, 10)) = 1
        [HDR]_RimCol ("Rim light color", Color) = (1.0,1.0,1.0,1.0) 
        _RimInt ("Rim light intensity", 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"//Automatically handle lighting attenuation for shadow processing
            #include "Lighting.cginc"//Mainly used to access ambient main directional light related data
            #pragma multi_compile_fwdbase_fullshadows //Enable shadow functionality
            #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 {
            //Check Document for meaning
                float4 vertex  : POSITION; 
                float2 uv0     : TEXCOORD0;
                float3 normal  : NORMAL; 
                float4 tangent : TANGENT; 
            };
            struct VertexOutput { 
            //Normal information
                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{ 
                //Vectors
                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; 
                //Represents point light coordinates, normalization is safer, dot product results will be more correct
                half3 lrDirWS = reflect(-lDirWS, nDirWS);
                float shadow = LIGHT_ATTENUATION(i);
                //Dot products
                half  rDotv = dot(vDirWS, lrDirWS);//Phong
                half  nDotl = dot(nDirWS, lDirWS);//Lambert
                half  ndotv = dot(nDirWS, vDirWS);
                //Sample textures
                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);
                //Extract information
                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;
                //Lighting model
                    half3 DiffCol = lerp(BaseCol, half3(0.0,0.0,0.0), MetalMask);
                    //The closer to metal, the weaker the diffuse reflection
                    half3 SpecCol = lerp(BaseCol, half3(0.3,0.3,0.3), TintMask) * SpecInt;
                    //Determine highlight color based on TintMask
                    //0.3 is an empirical value, this value multiplied by highlight intensity specInt gives a comfortable highlight color texture
                    //Fresnel
                    half3 Fresnel = lerp(var_FresnelWarp, 0.0, MetalMask);
                    //The higher the metalness, the less obvious the Fresnel phenomenon
                    half  FreCol = Fresnel.r; //No practical use
                    half  FreRim = Fresnel.g; //Use Fresnel for rim light
                    half  FreSpec = Fresnel.b; //Use Fresnel for specular reflection
                    //Main light diffuse reflection
                    half  HalfLambert = nDotl * 0.5 + 0.5;//Halflambert
                    half3 var_DiffuseWarp = tex2D(_DiffuseWarp, half2(HalfLambert, 0.2));
                    //Sample Ramptexture
                    half3 DirDiff = DiffCol * var_DiffuseWarp * _LightCol;
                    //Main light specular reflection
                    half Phong = pow(max(0.0, rDotv), SpecExp * _SpecPow);
                    half Spec = Phong * max(0.0,nDotl);
                    Spec = max(Spec, FreSpec);
                    //Will have a glossy visual effect, strong Fresnel phenomenon mixed with Phong
                    Spec = Spec * _SpecInt;
                    //After multiplying by SpecInt, most of the previous Spec effects will disappear, only the range specified by SpecInt will have highlights
                    //The original Shader integrates all specular reflections together and finally does max(flMetalnessMask, flSpecWarp)
                    //Here the author splits specular reflections, so both sides need to do a max at the final calculation
                    half3 DirSpec = SpecCol * Spec * _LightCol;
                    //Ambient diffuse reflection
                    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;
                    //The video author only used single color, here I directly copied the previous case code without modification
                    //Ambient specular reflection
                    half ReflectInt = max(FreSpec, MetalMask) * SpecInt;
                    //Metal parts have maximum MetalMask, non-metal parts have maximum FreSpec
                    //This way non-metal has strong Fresnel phenomenon, metal parts have little, instead have strong reflection phenomenon
                    half3 EnvSpec = SpecCol * ReflectInt * EnvCube * _EnvSpecint;
                    //Rim light
                    half3 RimLight = _RimCol * FreRim * RimLightInt * max(0.0, nDirWS.g) * _RimInt;
                    //Rim light only appears on top, so need to use normal.g
                    //FreRim defines Fresnel phenomenon, RimLightInt defines intensity range, RimInt defines intensity
                    //Emission
                    float3 emission = EmitInt * DiffCol * _SelfIllInt;
                    //Final
                    half3 FinalRGB = (DirDiff + DirSpec) * shadow + EnvDiff + EnvSpec + RimLight + 
                    emission;
                clip(Opacity - _Cutoff);//Delete all less than _Cutoff, keep those greater than
                return float4(FinalRGB, 1.0);
            }
            ENDCG
        }
    }
    Fallback "Legacy Shaders/Transparent/Cutout/VertexLit"
    //Note: Using FallBack requires declaring a _Color: color, even if you don't use it
}