前向渲染对每个物体每个光源都需要一个额外的附加渲染通道，这使得如果灯光变多draw call会急剧的增加。
在每次前向渲染的过程中，我们都要转换模型数据，再进行fragmentshader求出光照。这么麻烦，我们为什么不将几何数据缓存起来。而这对于多个光源的场景来书会节省很多draw call

1.延迟路径第一步：填充几何缓冲区

struct FragmentOutput{
    float4 gBuffer0:SV_TARGET0;
    float4 gBuffer1:SV_TARGET1;
    float4 gBuffer2:SV_TARGET2;
    float4 gBuffer3:SV_TARGET3;
};

1.缓冲区0

第一个G缓冲区用于存储漫反射率和表面遮挡。这是一个ARGB32纹理，就像一个常规的帧缓冲区。反射率存储在RGB通道中，遮挡存储在A通道中。

finalOutput.gBuffer0.xyz=albedo;
    finalOutput.gBuffer0.a=GetAO(i);

2.缓冲区1

第二个G缓冲器用于存储RGB通道中的镜面高光颜色，以及A通道中的平滑度值。它也是一个ARGB32纹理。

finalOutput.gBuffer1.xyz=specular;
finalOutput.gBuffer1.a=smoothness;

3.缓冲区2

第三个G缓冲区包含的是世界空间中的法向量。它们存储在ARGB2101010纹理的RGB通道中。
因为我们输出的值域为0-1，而世界坐标中法线方向的向量范围是-1，1。对此应做映射

finalOutput.gBuffer2=float4(normal*0.5+0.5,1.0);

4.缓冲区3

用于存储积累的光照，格式分为两种一种是储存低动态对比度的ARGB2101010，另一种存高动态对比度颜色ARGBHalf；
对于积累的光照，在写入GBuffer时，应加入SH球谐环境光、和自发光；
也可以加入反射，或者是在延迟光照的方法考虑进去
当关闭HDR时，要将光照进行编码

#pragma multi_compile _ UNITY_HDR_ON
#if !defined(UNITY_HDR_ON)
        finalCol=exp2(-finalCol);
#endif
finalOutput.gBuffer3=float4(finalCol,1.0);

GBuffer-shader

Shader"myshader/DeferredMat"{
    Properties{
        _mainTex("MainTex",2D)="white"{}
        _Tine("Time",Color)=(1,1,1,1)
        [NoScaleOffset]_MetallicMap("MetallicMap",2D)="black"{}
        _Metallic("Metallic",Range(0,1))=0
        _Smoothness("smoothness",Range(0,1))=0

        [NoScaleOffset]_NormalMap("NormalMap",2D)="Bump"{}
        _NormalScale("NormalScale",float)=1

        _AoScale("AoScale",Range(0,1))=1
        [NoScaleOffset]_EmissionMap("EmissionMap",2D)="black"

    }

    SubShader{
        Tags{"RenderType"="Opaque"}


        pass{
            Tags{"LightMode"="Deferred"}
            CGPROGRAM

            #pragma target 3.0
            #pragma vertex vert 
            #pragma fragment frag 
            #pragma multi_compile _ UNITY_HDR_ON

            #include"WriteInGBuffer.cginc"

            ENDCG
        }


    }
    Fallback "Diffuse"
}

#if !defined(MY_LIGHTING_INCLUDED)
#define MY_LIGHTING_INCLUDED

#include"UnityPBSLighting.cginc"
#include"AutoLight.cginc"
#include"UnityStandardUtils.cginc"

sampler2D _mainTex;
float4 _mainTex_ST;
float3 _Tine;

sampler2D _MetallicMap;
float _Metallic;
float _Smoothness;

sampler2D _NormalMap;
float _NormalScale;

float _AoScale;
sampler2D _EmissionMap;

struct a2v{
    float4 vertex:POSITION;
    float3 normal:NORMAL;
    float2 uv:TEXCOORD;
    float4 tangent:TANGENT;
};

struct v2f{
    float4 pos:SV_POSITION;
    float3 worldPos:TEXCOORD0;
    float3 normal:TEXCOORD1;
    float4 tangent:TEXCOORD2;
    float2 uv:TEXCOORD3;

};



v2f vert(a2v v){
    v2f o;
    o.pos=UnityObjectToClipPos(v.vertex);
    o.worldPos=mul(unity_ObjectToWorld,v.vertex).xyz;
    o.normal=UnityObjectToWorldNormal(v.normal);
    o.tangent=float4(UnityObjectToWorldDir(v.tangent.xyz),v.tangent.w);
    o.uv=TRANSFORM_TEX(v.uv,_mainTex);
    return o;
}

float3 GetAlbedo(v2f i){
    return tex2D(_mainTex,i.uv).xyz * _Tine.xyz;
}

float GetMetallic(v2f i){
    return tex2D(_MetallicMap,i.uv).r + _Metallic;
}

float GetSmoothness(v2f i){
    return _Smoothness;
}

float3 GetNormal(v2f i){
    float3 worldNormal=normalize(i.normal);
    float3 worldTangent=normalize(i.tangent.xyz);
    float3 worldBinormal=cross(worldNormal,worldTangent) * i.tangent.w * unity_WorldTransformParams.w;

    float3 tangentNormal=UnpackScaleNormal(tex2D(_NormalMap,i.uv),_NormalScale);
    return float3(
        tangentNormal.x*worldTangent+
        tangentNormal.y*worldBinormal+
        tangentNormal.z*worldNormal
    );
}

float GetAO(v2f i){
    return 1.;
}

UnityLight GetdirLight(v2f i){
    UnityLight dirLight;
    dirLight.dir=UnityWorldSpaceLightDir(i.worldPos);

    UNITY_LIGHT_ATTENUATION(attenuation,i,i.worldPos);
    dirLight.color=_LightColor0.xyz * attenuation;
    return dirLight;
}

UnityIndirect GetindirLight(v2f i,float3 viewDir){
    UnityIndirect indirLight;
    indirLight.diffuse=0;
    indirLight.specular=0;

    indirLight.diffuse-=max(0,ShadeSH9(float4(i.normal,1)));

    Unity_GlossyEnvironmentData envData;
    envData.roughness = 1 - GetSmoothness(i);
    float3 reflectDir=reflect(-viewDir,i.normal);

    float3 reflectDir1=BoxProjectedCubemapDirection(reflectDir, i.worldPos,unity_SpecCube0_ProbePosition,unity_SpecCube0_BoxMin, unity_SpecCube0_BoxMax);
    envData.reflUVW = reflectDir1;
    float3 probe0 = Unity_GlossyEnvironment(UNITY_PASS_TEXCUBE(unity_SpecCube0), unity_SpecCube0_HDR, envData);

    float3 reflectDir2=BoxProjectedCubemapDirection(reflectDir, i.worldPos,unity_SpecCube1_ProbePosition,unity_SpecCube1_BoxMin, unity_SpecCube1_BoxMax);
    envData.reflUVW = reflectDir2;
    float3 probe1= Unity_GlossyEnvironment(UNITY_PASS_TEXCUBE_SAMPLER(unity_SpecCube1, unity_SpecCube0),unity_SpecCube0_HDR, envData);
    indirLight.specular = lerp(probe1, probe0, unity_SpecCube0_BoxMin.w);

    float AO = GetAO(i);
    indirLight.diffuse*=AO;
    indirLight.specular*=AO;

    #if defined(UNITY_ENABLE_REFLECTION_BUFFERS)
        indirLight.specular=0;
    #endif

    
    return indirLight;
}

float3 GetEmission(v2f i){
    float3 emission=tex2D(_EmissionMap,i.uv).xyz;
    return emission;
}

struct FragmentOutput{
    float4 gBuffer0:SV_TARGET0;
    float4 gBuffer1:SV_TARGET1;
    float4 gBuffer2:SV_TARGET2;
    float4 gBuffer3:SV_TARGET3;
};

FragmentOutput frag(v2f i){
    float3 albedo=GetAlbedo(i);

    float metallic=GetMetallic(i);
    float3 specular;
    float OneMinuseReflectivity;
    albedo = DiffuseAndSpecularFromMetallic(albedo,metallic,specular,OneMinuseReflectivity);

    float smoothness=GetSmoothness(i);
    float3 normal=GetNormal(i);
    float3 viewDir=normalize(UnityWorldSpaceViewDir(i.worldPos));

    UnityLight dirLight;            //将直接光照设置为0，
    dirLight.dir=float3(0,1,0);
    dirLight.color=float3(0,0,0);
    UnityIndirect indirLight=GetindirLight(i,viewDir);

    fixed3 BRDF=UNITY_BRDF_PBS(albedo,specular,OneMinuseReflectivity,smoothness,normal,viewDir,dirLight,indirLight);
    fixed3 emissionCol=GetEmission(i);
    fixed3 finalCol=BRDF+emissionCol;

    #if !defined(UNITY_HDR_ON)
        finalCol=exp2(-finalCol);
    #endif
    
    FragmentOutput finalOutput;
    finalOutput.gBuffer0.xyz=albedo;
    finalOutput.gBuffer0.a=GetAO(i);
    finalOutput.gBuffer1.xyz=specular;
    finalOutput.gBuffer1.a=smoothness;
    finalOutput.gBuffer2=float4(normal*0.5+0.5,1.0);
    finalOutput.gBuffer3=float4(finalCol,1.0);

    return finalOutput;
}

#endif

二、延迟光照

目前我们已经得到4个缓冲区，现在我们利用这些缓冲区在lightingshader中计算灯光

1.deferredLighting中的两个Pass

第一个pass中用来计算光照，第二个pass是，当关闭HDR时，才会被调用，用来将HDR转换为LDR

SubShader{
        pass{
            Blend [_SrcBlend] [_DstBlend]
            Cull Off
            ZTest Always
            ZWrite Off

            CGPROGRAM
            #pragma target 3.0
            #pragma vertex vert 
            #pragma fragment frag 
            #pragma exclude_renderers nomrt
            #pragma multi_compile_lightpass
            #pragma multi_compile _ UNITY_HDR_ON
            
            #include "DeferredLighting.cginc"


            ENDCG
        }

        pass{
            Cull off 
            ZTest Always 
            ZWrite off 
            //用蒙版缓冲区消除对背景的影响
            Stencil{
                Ref [_StencilNonBackground]
                ReadMask [_StencilNonBackground]
                CompBack Equal
                CompFront Equal
            }

            CGPROGRAM
            #pragma target 3.0
            #pragma vertex vert 
            #pragma fragment frag 
            #pragma exclude_renderers nomrt
            #include"UnityCG.cginc"

            struct a2v{
                float4 vertex:POSITION;
                float2 uv:TEXCOORD0;
            };
            struct v2f{
                float4 pos:SV_POSITION;
                float2 uv:TEXCOORD0;
            };

            sampler2D _LightBuffer;


            v2f vert(a2v v){
                v2f o;
                o.uv=v.uv;
                o.pos=UnityObjectToClipPos(v.vertex);
                return o;
            }


            float4 frag(v2f i):SV_TARGET{
                return -log2(tex2D(_LightBuffer,i.uv));
            }
            ENDCG
        }
    }

灯光计算（第一个pass）

1.读取G缓冲区的uv坐标

    i.pos = UnityObjectToClipPos(v.vertex);
    i.uv = ComputeScreenPos(i.pos);
    float2 uv = i.uv.xy / i.uv.w;

2.世界坐标

normal的法线信息是沿着视角射线的方向的

UNITY_DECLARE_DEPTH_TEXTURE(_CameraDepthTexture);

i.ray = v.normal;

float depth = SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, uv);
depth = Linear01Depth(depth);
float3 rayToFarPlane = i.ray * _ProjectionParams.z / i.ray.z;
float3 viewPos = rayToFarPlane * depth;
float3 worldPos = mul(unity_CameraToWorld, float4(viewPos, 1)).xyz;

3.读取G缓冲数据

sampler2D _CameraGBufferTexture0;
sampler2D _CameraGBufferTexture1;
sampler2D _CameraGBufferTexture2;

float3 worldPos = mul(unity_CameraToWorld, float4(viewPos, 1)).xyz;
float3 albedo = tex2D(_CameraGBufferTexture0, uv).rgb;
float3 specularTint = tex2D(_CameraGBufferTexture1, uv).rgb;
float3 smoothness = tex2D(_CameraGBufferTexture1, uv).a;
float3 normal = tex2D(_CameraGBufferTexture2, uv).rgb * 2 - 1;

4.计算BRDF

float3 viewDir = normalize(_WorldSpaceCameraPos - worldPos);
float3 albedo = tex2D(_CameraGBufferTexture0, uv).rgb;
float3 specularTint = tex2D(_CameraGBufferTexture1, uv).rgb;
float3 smoothness = tex2D(_CameraGBufferTexture1, uv).a;
float3 normal = tex2D(_CameraGBufferTexture2, uv).rgb * 2 - 1;
float oneMinusReflectivity = 1 - SpecularStrength(specularTint);
UnityLight light;
light.color = 0;
light.dir = 0;
UnityIndirect indirectLight;
indirectLight.diffuse = 0;
indirectLight.specular = 0;
float4 color = UNITY_BRDF_PBS(albedo, specularTint, oneMinusReflectivity, smoothness,normal, viewDir, light, indirectLight);

5.平行光灯光参数

间接灯光在写入GBuffer中时已经加入了，所以indirLight继续填0
灯光方向和颜色是从float4 _LightColor, _LightDir 中读取,注意LightDir为灯光前进方向，应取反

float4 _LightColor, _LightDir;
UnityLight CreateLight () {
    UnityLight light;
    light.dir =- _LightDir;
    light.color = _LightColor.rgb;
    return light;
}

6.平行光阴影+COOKIE

1.依靠AutoLight的宏来确定由阴影引起的光衰减。 不幸的是，该文件没有写入延迟光源。 所以我们自己来进行阴影采样。阴影贴图可以通过_ShadowMapTexture变量来访问。但是，我们不能随便声明这个变量。 它已经为UnityShadowLibrary中被定义点光源和聚光光源的阴影，我们间接导入了它们。 所以我们不应该自己定义它，除非使用方向光源的阴影。
2.UnityComputeShadowFadeDistance(worldPos, viewZ) 计算阴影衰减
UnityComputeShadowFade 计算衰减距离

#if defined (SHADOWS_SCREEN)
    sampler2D _ShadowMapTexture;
#endif

    float attenuation = 1;
    float shadowAttenuation =1.0;
    #if defined(DIRECTIONAL) || defined(DIRECTIONAL_COOKIE)
        #if defined(DIRECTIONAL_COOKIE)
            float2 uvCookie = mul(unity_WorldToLight, float4(worldPos, 1)).xy;
            attenuation *= tex2Dbias(_LightTexture0, float4(uvCookie, 0, -8)).w;
            //attenuation *= tex2D(_LightTexture0, uvCookie).w;
        #endif

        #if defined (SHADOWS_SCREEN)
            shadowAttenuation = tex2D(_ShadowMapTexture, uv).r;
            float shadowFadeDistance = UnityComputeShadowFadeDistance(worldPos, viewZ);
            float shadowFade = UnityComputeShadowFade(shadowFadeDistance);
            shadowAttenuation = saturate(shadowAttenuation + shadowFade);
        #endif
    #else
        light.dir = 1;
    #endif

    light.color = _LightColor.rgb * shadowAttenuation * attenuation;

不要忘记LDR的编码，像GBuffer写入时 一样

#if !defined(UNITY_HDR_ON)
    color = exp2(-color);
#endif

7.加入聚光灯

1.金字塔区域被渲染为一个常规的3D对象。

摄像机可能会在聚光光源照亮的体积的内部。 甚至可能近平面的一部分都在聚光光源照亮的体积的内部，而其余部分位于聚光光源照亮的体积的外部。在这些情况下，模板缓冲区不能用于限制渲染。

Blend [_SrcBlend] [_DstBlend]
//Cull Off
//ZTest Always
ZWrite Off

2.计算光源方向

float4 _LightColor, _LightDir, _LightPos;
float3 lightVec = _LightPos.xyz - worldPos;
light.dir = normalize(lightVec);

3.再次计算世界坐标

当时平行光的时候，_LightAsQuad=1

float _LightAsQuad;
i.ray = lerp(UnityObjectToViewPos(v.vertex) * float3(-1, -1, 1),v.normal,_LightAsQuad);

4.Cookie衰减

_LightTexture0存入Cookie的数值

float4 uvCookie = mul(unity_WorldToLight, float4(worldPos, 1));
uvCookie.xy /= uvCookie.w;
attenuation *= tex2Dbias(_LightTexture0, float4(uvCookie.xy, 0, -8)).w;
attenuation *= uvCookie.w < 0;

5.距离衰减

聚光光源的光线也会根据距离进行衰减。该衰减存储在查找纹理中，可通过_LightTextureB0获得。
光源的范围存储在_LightPos的第四个变量中。
使用哪个纹理通道，因平台而异，由UNITY_ATTEN_CHANNEL宏进行定义。

sampler2D _LightTexture0, _LightTextureB0;
attenuation *= tex2D(_LightTextureB0,(dot(lightVec, lightVec) * _LightPos.w).rr).UNITY_ATTEN_CHANNEL;

6.阴影

当聚光光源有阴影的时候，会定义SHADOWS_DEPTH关键字。

#if defined(SHADOWS_DEPTH)
    shadowed = true;
#endif
shadowAttenuation = UnitySampleShadowmap(mul(unity_WorldToShadow[0], float4(worldPos, 1)));

8.点光源

与聚光灯原理类似
完整的光源衰减

UnityLight CreateLight (float2 uv, float3 worldPos, float viewZ) {
    UnityLight light;
    float attenuation = 1;
    float shadowAttenuation = 1;
    bool shadowed = false;

    #if defined(DIRECTIONAL) || defined(DIRECTIONAL_COOKIE)
        light.dir = -_LightDir;

        #if defined(DIRECTIONAL_COOKIE)
            float2 uvCookie = mul(unity_WorldToLight, float4(worldPos, 1)).xy;
            attenuation *= tex2Dbias(_LightTexture0, float4(uvCookie, 0, -8)).w;
        #endif

        #if defined(SHADOWS_SCREEN)
            shadowed = true;
            shadowAttenuation = tex2D(_ShadowMapTexture, uv).r;
        #endif
    #else
        float3 lightVec = _LightPos.xyz - worldPos;
        light.dir = normalize(lightVec);

        attenuation *= tex2D(
            _LightTextureB0,
            (dot(lightVec, lightVec) * _LightPos.w).rr
        ).UNITY_ATTEN_CHANNEL;

        #if defined(SPOT)
            float4 uvCookie = mul(unity_WorldToLight, float4(worldPos, 1));
            uvCookie.xy /= uvCookie.w;
            attenuation *=
                tex2Dbias(_LightTexture0, float4(uvCookie.xy, 0, -8)).w;
            attenuation *= uvCookie.w < 0;

            #if defined(SHADOWS_DEPTH)
                shadowed = true;
                shadowAttenuation = UnitySampleShadowmap(
                    mul(unity_WorldToShadow[0], float4(worldPos, 1))
                );
            #endif
        #else
            #if defined(POINT_COOKIE)
                float3 uvCookie =
                    mul(unity_WorldToLight, float4(worldPos, 1)).xyz;
                attenuation *=
                    texCUBEbias(_LightTexture0, float4(uvCookie, -8)).w;
            #endif
            
            #if defined(SHADOWS_CUBE)
                shadowed = true;
                shadowAttenuation = UnitySampleShadowmap(-lightVec);
            #endif
        #endif
    #endif

    if (shadowed) {
        float shadowFadeDistance =
            UnityComputeShadowFadeDistance(worldPos, viewZ);
        float shadowFade = UnityComputeShadowFade(shadowFadeDistance);
        shadowAttenuation = saturate(shadowAttenuation + shadowFade);

        #if defined(UNITY_FAST_COHERENT_DYNAMIC_BRANCHING) && defined(SHADOWS_SOFT)
            UNITY_BRANCH
            if (shadowFade > 0.99) {
                shadowAttenuation = 1;
            }
        #endif
    }

    light.color = _LightColor.rgb * (attenuation * shadowAttenuation);
    return light;
}

完整光照计算Shader

Shader "Custom/DeferredShading" {
    
    Properties {
    }

    SubShader {

        Pass {
            Blend [_SrcBlend] [_DstBlend]
            ZWrite Off

            CGPROGRAM

            #pragma target 3.0
            #pragma vertex VertexProgram
            #pragma fragment FragmentProgram

            #pragma exclude_renderers nomrt

            #pragma multi_compile_lightpass
            #pragma multi_compile _ UNITY_HDR_ON

            #include "MyDeferredShading.cginc"

            ENDCG
        }

        Pass {
            Cull Off
            ZTest Always
            ZWrite Off

            Stencil {
                Ref [_StencilNonBackground]
                ReadMask [_StencilNonBackground]
                CompBack Equal
                CompFront Equal
            }

            CGPROGRAM

            #pragma target 3.0
            #pragma vertex VertexProgram
            #pragma fragment FragmentProgram

            #pragma exclude_renderers nomrt

            #include "UnityCG.cginc"

            sampler2D _LightBuffer;

            struct VertexData {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct Interpolators {
                float4 pos : SV_POSITION;
                float2 uv : TEXCOORD0;
            };

            Interpolators VertexProgram (VertexData v) {
                Interpolators i;
                i.pos = UnityObjectToClipPos(v.vertex);
                i.uv = v.uv;
                return i;
            }

            float4 FragmentProgram (Interpolators i) : SV_Target {
                return -log2(tex2D(_LightBuffer, i.uv));
            }

            ENDCG
        }
    }
}

#if !defined(MY_DEFERRED_SHADING)
#define MY_DEFERRED_SHADING

#include "UnityPBSLighting.cginc"

UNITY_DECLARE_DEPTH_TEXTURE(_CameraDepthTexture);

sampler2D _CameraGBufferTexture0;
sampler2D _CameraGBufferTexture1;
sampler2D _CameraGBufferTexture2;

#if defined(POINT_COOKIE)
    samplerCUBE _LightTexture0;
#else
    sampler2D _LightTexture0;
#endif

sampler2D _LightTextureB0;
float4x4 unity_WorldToLight;

#if defined (SHADOWS_SCREEN)
    sampler2D _ShadowMapTexture;
#endif

float4 _LightColor, _LightDir, _LightPos;

float _LightAsQuad;

struct VertexData {
    float4 vertex : POSITION;
    float3 normal : NORMAL;
};

struct Interpolators {
    float4 pos : SV_POSITION;
    float4 uv : TEXCOORD0;
    float3 ray : TEXCOORD1;
};

UnityLight CreateLight (float2 uv, float3 worldPos, float viewZ) {
    UnityLight light;
    float attenuation = 1;
    float shadowAttenuation = 1;
    bool shadowed = false;

    #if defined(DIRECTIONAL) || defined(DIRECTIONAL_COOKIE)
        light.dir = -_LightDir;

        #if defined(DIRECTIONAL_COOKIE)
            float2 uvCookie = mul(unity_WorldToLight, float4(worldPos, 1)).xy;
            attenuation *= tex2Dbias(_LightTexture0, float4(uvCookie, 0, -8)).w;
        #endif

        #if defined(SHADOWS_SCREEN)
            shadowed = true;
            shadowAttenuation = tex2D(_ShadowMapTexture, uv).r;
        #endif
    #else
        float3 lightVec = _LightPos.xyz - worldPos;
        light.dir = normalize(lightVec);

        attenuation *= tex2D(
            _LightTextureB0,
            (dot(lightVec, lightVec) * _LightPos.w).rr
        ).UNITY_ATTEN_CHANNEL;

        #if defined(SPOT)
            float4 uvCookie = mul(unity_WorldToLight, float4(worldPos, 1));
            uvCookie.xy /= uvCookie.w;
            attenuation *=
                tex2Dbias(_LightTexture0, float4(uvCookie.xy, 0, -8)).w;
            attenuation *= uvCookie.w < 0;

            #if defined(SHADOWS_DEPTH)
                shadowed = true;
                shadowAttenuation = UnitySampleShadowmap(
                    mul(unity_WorldToShadow[0], float4(worldPos, 1))
                );
            #endif
        #else
            #if defined(POINT_COOKIE)
                float3 uvCookie =
                    mul(unity_WorldToLight, float4(worldPos, 1)).xyz;
                attenuation *=
                    texCUBEbias(_LightTexture0, float4(uvCookie, -8)).w;
            #endif
            
            #if defined(SHADOWS_CUBE)
                shadowed = true;
                shadowAttenuation = UnitySampleShadowmap(-lightVec);
            #endif
        #endif
    #endif

    if (shadowed) {
        float shadowFadeDistance =
            UnityComputeShadowFadeDistance(worldPos, viewZ);
        float shadowFade = UnityComputeShadowFade(shadowFadeDistance);
        shadowAttenuation = saturate(shadowAttenuation + shadowFade);

        #if defined(UNITY_FAST_COHERENT_DYNAMIC_BRANCHING) && defined(SHADOWS_SOFT)
            UNITY_BRANCH
            if (shadowFade > 0.99) {
                shadowAttenuation = 1;
            }
        #endif
    }

    light.color = _LightColor.rgb * (attenuation * shadowAttenuation);
    return light;
}

Interpolators VertexProgram (VertexData v) {
    Interpolators i;
    i.pos = UnityObjectToClipPos(v.vertex);
    i.uv = ComputeScreenPos(i.pos);
    i.ray = lerp(
        UnityObjectToViewPos(v.vertex) * float3(-1, -1, 1),
        v.normal,
        _LightAsQuad
    );
    return i;
}

float4 FragmentProgram (Interpolators i) : SV_Target {
    float2 uv = i.uv.xy / i.uv.w;

    float depth = SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, uv);
    depth = Linear01Depth(depth);

    float3 rayToFarPlane = i.ray * _ProjectionParams.z / i.ray.z;
    float3 viewPos = rayToFarPlane * depth;
    float3 worldPos = mul(unity_CameraToWorld, float4(viewPos, 1)).xyz;
    float3 viewDir = normalize(_WorldSpaceCameraPos - worldPos);

    float3 albedo = tex2D(_CameraGBufferTexture0, uv).rgb;
    float3 specularTint = tex2D(_CameraGBufferTexture1, uv).rgb;
    float3 smoothness = tex2D(_CameraGBufferTexture1, uv).a;
    float3 normal = tex2D(_CameraGBufferTexture2, uv).rgb * 2 - 1;
    float oneMinusReflectivity = 1 - SpecularStrength(specularTint);

    UnityLight light = CreateLight(uv, worldPos, viewPos.z);
    UnityIndirect indirectLight;
    indirectLight.diffuse = 0;
    indirectLight.specular = 0;

    float4 color = UNITY_BRDF_PBS(
        albedo, specularTint, oneMinusReflectivity, smoothness,
        normal, viewDir, light, indirectLight
    );
    #if !defined(UNITY_HDR_ON)
        color = exp2(-color);
    #endif
    return color;
}

#endif