使用资产

通过网盘分享的文件：PBR测试内容链接: https://pan.baidu.com/s/1MpDbI4TXPY2lKaz2uZC3_w?pwd=2psd 提取码: 2psd
完整代码

 Shader "Unlit/PBRShader"
{
    properties
    {
        _MainTex("MainTex", 2D) = "white"{}

        _NormalMap("NormalMap", 2D) = "bump"{}
        _NormalMapScale("NormalMapScale", Range(0,5)) = 1

        _RoughnessTex("RoughnessTex", 2D)= "white"{}
        _MetallicTex("MetallicTex", 2D)= "white"{}
        _HeightTex("HeightTex", 2D)= "white"{}
        _AOTex("AOTex", 2D)= "white"{}
        _CubeMap("CubeMap", cube)= "white"{}

        _SpecularColor("SpecularColor",color) = (1,1,1,1)
        _SpecularIntensity("SpecularIntensity", Range(0,50)) = 1
        _SpecularShininess("SpecularShininess", Range(0,10)) = 2

        [Header(Roughness Adjustment)]
        [Space]
        _RoughnessIntensity ("RoughnessIntensity", Range(0, 2)) = 1
        [Space]
        _RoughnessBias ("Bias", Range(-1.0, 1.0)) = 0
        [Space]
        _RoughnessRemapMin ("Remap Min", Range(0, 1)) = 0
        _RoughnessRemapMax ("Remap Max", Range(0, 1)) = 1
        [Header(ParallaxMapping Basic)]
        _ParallaxScale ("Parallax Scale 未使用", Range(0, 10)) = 0.1
        [Header(ParallaxOcclusionMapping)]
        _HeightScale ("Height Scale", Range(0, 0.2)) = 0.05
        _MinLayers("Parallax Min Layers", Range(1, 128)) = 10
        _MaxLayers("Parallax Max Layers", Range(1, 128)) = 50
        _HeightReferencePlane ("Height Reference Plane", Range(0, 1)) = 0.5  // 解决凹凸问题
        //_POMFadeDistance ("POM Near Fade Distance", Range(0, 10)) = 2.0  
        _ShadowSoftness("POM Shadow Strength" ,Range(0, 10)) = 1.0
        _ShadowSteps("POM Shadow Steps" ,Range(0, 16)) = 8

        [Header(EnvBRDFLUT)]
        [Toggle]_UseCustomLUT("Custom BRDF LUT", float) = 1.0
        _CustomBRDFLUT("Custom BRDF LUT", 2D) = "white" {}

    }

    Subshader
    {
        Tags
        {
            "RenderType"="Opaque"
            "Queue"="Geometry"
        }

        Pass
        {
            Name"FORWARD"
            Tags{"LightMode"="ForwardBase"}

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma multi_compile_fwdbase

            #include "UnityCG.cginc"
            #include "Lighting.cginc"
            #include "AutoLight.cginc"
             
            struct appdata
            {
                float4 vertex   : POSITION;
                float3 normal   : NORMAL;
                float4 tangent  : TANGENT;
                float2 uv       : TEXCOORD0;
                
            };

            struct v2f
            {
                float4 pos          : SV_POSITION;
                float4 positionWS   : TEXCOORD0;
                float3 normalWS     : TEXCOORD1;
                float3 tangentWS    : TEXCOORD2;
                float3 bitangentWS  : TEXCOORD3;
                float2 texcoord     : TEXCOORD4;
                float3 viewDirTS    : TEXCOORD5;
                float3 lightDirTS   : TEXCOORD6;
                UNITY_SHADOW_COORDS(7)
            };

            sampler2D _MainTex;
            half4 _MainTex_ST;
            sampler2D _NormalMap;
            sampler2D _RoughnessTex;
            sampler2D _MetallicTex;
            sampler2D _HeightTex;
            sampler2D _AOTex;
            samplerCUBE _CubeMap;
            float4 _CubeMap_HDR; //此参数声明后，Unity会自动配置
            half _NormalMapScale;
            half4 _SpecularColor;
            half _SpecularIntensity;
            half _SpecularShininess;
           

            half _RoughnessIntensity;
            half _RoughnessBias;
            half _RoughnessRemapMin;
            half _RoughnessRemapMax;
            half _RoughnessBoost;

            half _ParallaxScale;

            half _HeightScale;
            half _MinLayers;
            half _MaxLayers;
            half _HeightReferencePlane;
            half _POMFadeDistance;

            half _ShadowSoftness;
            half _ShadowSteps;

            half _UseCustomLUT;
            sampler2D _CustomBRDFLUT;

            float3 ParallaxOcclusionMapping(float2 uv, float3 viewDirTS, float3 lightDirTS)
            {
                
                // === 保存原始UV导数 ===
                float2 dx = ddx(uv);
                float2 dy = ddy(uv);
                
                // 这个系数能保证在极低角度时视差平滑消失
                //float angleFade = saturate(viewDirTS.z * 5.0);
                float angleFade = saturate(pow(viewDirTS.z, 0.5));
                //float angleFade = smoothstep(0.15, 0.4, viewDirTS.z);

                // 截断淡出，效果较差
                // float2 rawOffset = viewDirTS.xy / max(viewDirTS.z, 0.0001) * _HeightScale;
                // float maxLen = _HeightScale * 2.0; 
                // float currentLen = length(rawOffset);
                // float2 maxParallaxOffset = rawOffset * (min(currentLen, maxLen) / max(currentLen, 0.001));

                // === 1. 动态调整采样层数 ===
                float numLayers = lerp(_MaxLayers, _MinLayers, abs(viewDirTS.z));
                // === 2. 计算步进参数 ===
                float layerStepDistance = 1.0 / numLayers;              // 步进距离
                float2 maxParallaxOffset = viewDirTS.xy / max(viewDirTS.z, 0.001) * _HeightScale * angleFade; //最大步进距离
                float2 deltaUV = maxParallaxOffset / numLayers; //步进UV
                // === 3. 初始化 第一层数据===
                float currentLayerDistance = 0.0;         //起始层基准
                float2 currentUV = uv + maxParallaxOffset * (1.0 - _HeightReferencePlane);   // 当前UV坐标
                //float currentHeight = 1 - tex2D(_HeightTex, currentUV).r; // 初始表面高度
                float currentHeight = 1.0 - tex2Dgrad(_HeightTex, currentUV, dx, dy).r;

                // 缓存上一步的数据，避免循环结束后重复采样
                float prevHeight = currentHeight;
                float prevLayerDistance = 0.0;

                //[unroll(50)] // 展开循环优化（数字要≥_MaxLayers）
                [loop] //标记循环
                for(int i = 0; i < numLayers; i++)
                {
                    // 1.检查是否当前位置数值是否大于当前高度值
                    if(currentLayerDistance >= currentHeight)
                        break;
                    
                    // 2.记录旧状态
                    prevHeight = currentHeight;
                    prevLayerDistance = currentLayerDistance;

                    // 3.步进操作
                    // 沿视线方向步进，下一层的数据，这里虽然命名是current，但是数据已经是下一层的了
                    currentUV -= deltaUV;                               //UV步进1层
                    currentLayerDistance +=  layerStepDistance;         //当前位置步进1层 

                    // 4.采样新高度
                    //currentHeight = 1 - tex2Dlod(_HeightTex, float4(currentUV, 0, 0)).r; //深度值随UV步进1层
                    currentHeight = 1.0 - tex2Dgrad(_HeightTex, currentUV, dx, dy).r;
                }
                // 步进操作前，也就是当前UV
                float2 prevUV = currentUV + deltaUV;

                //当前步进距离对高度值影响              
                float beforeDistance = prevHeight - prevLayerDistance;
                 
                //下一层，总步进距离对高度值影响
                float afterDistance = currentHeight - currentLayerDistance;  
    
                // 插值权重，两个端点之间的线性插值
                float weight = afterDistance / (afterDistance - beforeDistance);

                // 最终UV = 加权平均
                // 对每一次步进的UV插值
                float2 finalUV = lerp(currentUV, prevUV, weight);
                //float finalHeight = lerp(currentLayerDistance, prevLayerDistance, weight);

                // === 自阴影循环 (Soft Shadows) ===
                float shadow = 1.0;
                
                //float lightAngleFade = smoothstep(0.05, 0.25, lightDirTS.z);
                float lightAngleFade = saturate(pow(lightDirTS.z, 0.5));
                
                if(_ShadowSoftness > 0.0 && angleFade > 0.01 && lightDirTS.z > 0.0)
                {
                    float hitDepth = 1.0 - tex2Dgrad(_HeightTex, finalUV, dx, dy).r;
                    
                    if(hitDepth > 0.001)
                    {
                        // 计算完整的UV偏移方向（从交点到光源方向在UV上的投影）
                        float2 lightDirUV = lightDirTS.xy / max(lightDirTS.z, 0.001) * _HeightScale;
                        
                        // 限制最大追踪距离，防止低角度时偏移过大
                        float maxOffset = _HeightScale * 2.0;
                        float offsetLen = length(lightDirUV);
                        if(offsetLen > maxOffset)
                        {
                            lightDirUV = lightDirUV / offsetLen * maxOffset;
                        }
                        
                        // 按深度比例的总UV偏移
                        float2 totalUV = lightDirUV * hitDepth;
                        
                        // 均匀分配到每一步
                        float2 stepUV = totalUV / _ShadowSteps;
                        float stepDepth = hitDepth / _ShadowSteps;
                        
                        float currentDepth = hitDepth;
                        float2 currentUV = finalUV;
                        
                        [loop]
                        for(int j = 0; j < _ShadowSteps; j++)
                        {
                            currentDepth -= stepDepth;
                            currentUV += stepUV;
                            
                            if(currentDepth <= 0.0)
                                break;
                            
                            float terrainDepth = 1.0 - tex2Dgrad(_HeightTex, currentUV, dx, dy).r;
                            
                            if(terrainDepth < currentDepth)
                            {
                                float occlusion = currentDepth - terrainDepth;
                                shadow = min(shadow, 1.0 - saturate(occlusion * _ShadowSoftness));
                                
                                if(shadow < 0.01)
                                {
                                    shadow = 0.0;
                                    break;
                                }
                            }
                        }
                    }
                }
                // 根据淡出系数混合阴影
                shadow = lerp(1.0, shadow, angleFade * lightAngleFade);
                
                // 根据淡出系数混合阴影（让阴影也随视角淡出）
                //shadow = lerp(1.0, shadow, angleFade);

                //return finalUV;
                return float3(finalUV,shadow);
            }

            float2 EnvBRDFApprox(float roughness, float NoV)
            {
                // Epic Games通过拟合大量数据得出的魔法系数
                const float4 c0 = float4(-1.0, -0.0275, -0.572, 0.022);
                const float4 c1 = float4(1.0, 0.0425, 1.04, -0.04);

                float4 r = roughness * c0 + c1;
                float a004 = min(r.x * r.x, exp2(-9.28 * NoV)) * r.x + r.y;
                float2 AB = float2(-1.04, 1.04) * a004 + r.zw;

                return AB;  // AB.x = scale, AB.y = bias
            }

            v2f vert(appdata v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                o.positionWS = mul(unity_ObjectToWorld, v.vertex);

                o.normalWS = UnityObjectToWorldNormal(v.normal);
                o.tangentWS = UnityObjectToWorldDir(v.tangent.xyz);
                //* v.tangent.w处理平台差异
                o.bitangentWS = cross(o.normalWS, o.tangentWS) * v.tangent.w;
                o.texcoord = TRANSFORM_TEX(v.uv,_MainTex);

                //ParallaxMapping_Basic start
                float3x3 TBN = float3x3(o.tangentWS, o.bitangentWS, o.normalWS);
                float3 worldViewDir = normalize(_WorldSpaceCameraPos - o.positionWS);       
                o.viewDirTS = mul(TBN, worldViewDir); 

                half3 lightWS = normalize(_WorldSpaceLightPos0.xyz);
                o.lightDirTS= mul(TBN, lightWS); 

                //ParallaxMapping_Basic end
                TRANSFER_SHADOW(o);
                return o;
            }
            

            float4 frag(v2f i) : SV_Target
            {
                //vectors
                float3 positionWS = i.positionWS; 
                float3 normalWS = normalize(i.normalWS);
                float3 tangentWS = normalize(i.tangentWS);
                float3 bitangentWS = normalize(i.bitangentWS);
                float3x3 TBN = float3x3(tangentWS, bitangentWS, normalWS);
                half3 lightWS = normalize(_WorldSpaceLightPos0.xyz);
                float3 viewDir = normalize(_WorldSpaceCameraPos - positionWS);

                half3 lightDirTS = i.lightDirTS; 
                //************tex*************
                //ParallaxMapping_Basic start
                //float height = 1.0 - tex2D(_HeightTex, i.texcoord).r;
                //float2 offset = i.viewDirTS.xy / i.viewDirTS.z * height * _ParallaxScale * 0.01;
                //float2 texcoord = i.texcoord - offset;
                //ParallaxMapping_Basic end

                float3 POMData = ParallaxOcclusionMapping(i.texcoord, i.viewDirTS,  lightDirTS);
                float2 texcoord = POMData.xy;
                float  POMShadow = POMData.z;

                float3 lightColor = _LightColor0.xyz;
                float4 baseCol = tex2D(_MainTex, texcoord);
                float3 normalMapData = UnpackNormal(tex2D(_NormalMap, texcoord)).xyz;
                normalMapData.xy *= _NormalMapScale;
                float metallic = tex2D(_MetallicTex, texcoord).b;
                float roughness = tex2D(_RoughnessTex, texcoord).r + _RoughnessBoost;

                //halfLambet
                float3 pixelNormal = normalize(mul(normalMapData, TBN));
                float nol = max(0, dot(pixelNormal, lightWS));
                float halfLambet = nol*0.5 + 0.5;
                float3 diffuseColor = baseCol * nol * lightColor;
                //Specular
                //phong
                half3 reflectDir = reflect(-lightWS, pixelNormal);
                half phongItem = max(0, dot(reflectDir, viewDir));
               
                //Blinn-phong
                half3 halfDir = normalize(lightWS + viewDir);
                half blinnPhongItem = max(0, dot(pixelNormal, halfDir));       

               
              
                //整体漫反射剔除金属的的漫反射(错误写法，能量不守恒)
                //float3 pbrDiffuseColor = lerp(0.96 * diffuseColor, 0, metallic);
                
                roughness = roughness * _RoughnessIntensity + _RoughnessBias;
                roughness = clamp(roughness, _RoughnessRemapMin, _RoughnessRemapMax);

                //GGXSpecular
                float3 f0 = lerp(float3(0.04,0.04,0.04), baseCol, metallic);
                float roughness2 = roughness * roughness;
                float d = roughness2*roughness2/(3.14159*(blinnPhongItem * blinnPhongItem * (roughness2 * roughness2 - 1) + 1)*(blinnPhongItem * blinnPhongItem * (roughness2 * roughness2 - 1) + 1));

                float k = (roughness + 1) * (roughness + 1) / 8;
                float nov = max(0, dot(pixelNormal, viewDir));
                float gv = nov / (nov * (1 - k) + k);
                float gl = nol / (nol * (1 - k) + k);
                float g = gv * gl; 
                float3 f = f0 + (1-f0) * pow(1 - max(0,(dot(viewDir, halfDir))), 5);
                float3 KD_GGX =  (1 - f)* (1 - metallic);
                float3 ggxBRDF = d * f * g / (4 * nol * nov  + 0.001);
                float3 pbrSpecularColor = ggxBRDF * _SpecularColor * lightColor * nol;
                float3 pbrDiffuseColor =  baseCol /3.14159 * KD_GGX * nol * lightColor;


                //******环境光处理**********

                /******************漫反射环境光*********************/
                //EnvironmentColor
                //1.环境光（Unity 自动处理）
                fixed3 envColor = UNITY_LIGHTMODEL_AMBIENT.rgb * baseCol.rgb;
                //               ^^^^^^^^^^^^^^^^^^^^^^^ Unity 内置的环境光颜色
                //2.SH环境光（支持 Skybox/Gradient/Color）
                fixed3 envColorSH = ShadeSH9(half4(normalWS, 1.0)) * baseCol.rgb;
                //               ^^^^^^^ Unity 的球谐函数，根据法线方向采样环境光
                /******************镜面反射环境光*********************/
                //1.采样反射探针（Reflection Probe）
                half4 skyData = UNITY_SAMPLE_TEXCUBE(unity_SpecCube0, reflectDir);
                half3 skyColor = DecodeHDR(skyData, unity_SpecCube0_HDR);
                    
                // 计算反射方向
                float3 reflviewDir = reflect(-viewDir, normalize(pixelNormal));
               
                //环境光漫反射
                float3 f_indirect = f0 + (1-f0) * pow(1 - max(0,(dot(viewDir, pixelNormal))), 5);
                float3 kD_indirect  = (1.0 - f_indirect) * (1.0 - metallic);
                float3 indirectDiffuse  = kD_indirect * envColorSH;
                
                //环境光镜面漫反射
                float mipLevel = roughness* 7.0;
                float4 envSpecularRaw = texCUBElod(_CubeMap, float4(reflviewDir, mipLevel));
                half3 envSpecular = DecodeHDR(envSpecularRaw, _CubeMap_HDR); 

                //1.拟合BRDF(未使用)
                float2 envBRDF = EnvBRDFApprox(roughness, nov);
                float3 envSpecularEasy = envSpecular * f_indirect;
                //2.采样BRDFLUT
                float2 brdfLUT = tex2D(unity_NHxRoughness, float2(roughness, nov)).rg;
                float2 CustombrdfLUT = tex2D(_CustomBRDFLUT, float2(roughness, nov)).rg;
                
                if(_UseCustomLUT > 0.5)
                {
                    brdfLUT = CustombrdfLUT;
                }
                envSpecular =  envSpecular * (f0 * brdfLUT.x + brdfLUT.y);
                
                //AO
                float AO = tex2D(_AOTex, texcoord).r;
                //float fakeAO = saturate(dot(normalWS, float3(0,1,0))) * 0.6 + 0.4;



                //Shadow
                float shadow = SHADOW_ATTENUATION(i);
 
                //output
                float3 finalColor = (pbrDiffuseColor + pbrSpecularColor) * shadow + (indirectDiffuse + envSpecular )* AO * POMShadow ;


                return float4(finalColor, 1); 
            }
            ENDCG
        }
        
    }FallBack"Diffuse"

}
 
Lv.3 Unity主线：一个简单的PBRShader

使用资产

完整代码

测试大致效果

Enjoy Reading This Article?
