• 《HDAO》


    #version 440
    #define int2 ivec2
    
    #define int3 ivec3
    
    #define int4 ivec4
    
    
    
    #define half float
    
    #define half2 vec2
    
    #define half3 vec3
    
    #define half4 vec4
    
    
    
    #define float2 vec2
    
    #define float3 vec3
    
    #define float4 vec4
    
    
    
    #define float2x2 mat2
    
    #define float3x3 mat3
    
    #define float3x4 mat3x4
    
    #define float4x4 mat4
    
    #define saturate(value) clamp((value), 0.0f, 1.0f)
    
    #define rsqrt(value) inversesqrt(value)
    
    #define RING_1    (1)
    #define RING_2    (2)
    #define RING_3    (3)
    #define RING_4    (4)
    #define NUM_RING_1_GATHERS    2
    #define NUM_RING_2_GATHERS    6
    #define NUM_RING_3_GATHERS    12
    #define NUM_RING_4_GATHERS    20
    
    // Ring sample pattern
    const float2 g_f2HDAORingPattern[NUM_RING_4_GATHERS] =
    {
        // Ring 1
        { 1, -1 },
        { 0, 1 },
    
        // Ring 2
        { 0, 3 },
        { 2, 1 },
        { 3, -1 },
        { 1, -3 },
    
        // Ring 3
        { 1, -5 },
        { 3, -3 },
        { 5, -1 },
        { 4, 1 },
        { 2, 3 },
        { 0, 5 },
    
        // Ring 4
        { 0, 7 },
        { 2, 5 },
        { 4, 3 },
        { 6, 1 },
        { 7, -1 },
        { 5, -3 },
        { 3, -5 },
        { 1, -7 },
    };
    
    // Ring weights
    const float4 g_f4HDAORingWeight[NUM_RING_4_GATHERS] =
    {
        // Ring 1 (Sum = 5.30864)
        { 1.00000, 0.50000, 0.44721, 0.70711 },
        { 0.50000, 0.44721, 0.70711, 1.00000 },
    
        // Ring 2 (Sum = 6.08746)
        { 0.30000, 0.29104, 0.37947, 0.40000 },
        { 0.42426, 0.33282, 0.37947, 0.53666 },
        { 0.40000, 0.30000, 0.29104, 0.37947 },
        { 0.53666, 0.42426, 0.33282, 0.37947 },
    
        // Ring 3 (Sum = 6.53067)
        { 0.31530, 0.29069, 0.24140, 0.25495 },
        { 0.36056, 0.29069, 0.26000, 0.30641 },
        { 0.26000, 0.21667, 0.21372, 0.25495 },
        { 0.29069, 0.24140, 0.25495, 0.31530 },
        { 0.29069, 0.26000, 0.30641, 0.36056 },
        { 0.21667, 0.21372, 0.25495, 0.26000 },
    
        // Ring 4 (Sum = 7.00962)
        { 0.17500, 0.17365, 0.19799, 0.20000 },
        { 0.22136, 0.20870, 0.24010, 0.25997 },
        { 0.24749, 0.21864, 0.24010, 0.28000 },
        { 0.22136, 0.19230, 0.19799, 0.23016 },
        { 0.20000, 0.17500, 0.17365, 0.19799 },
        { 0.25997, 0.22136, 0.20870, 0.24010 },
        { 0.28000, 0.24749, 0.21864, 0.24010 },
        { 0.23016, 0.22136, 0.19230, 0.19799 },
    };
    
    const float g_fRingWeightsTotal[RING_4] =
    {
        5.30864,
        11.39610,
        17.92677,
        24.93639,
    };
    
    #define NUM_NORMAL_LOADS 4
    const int2 g_i2NormalLoadPattern[NUM_NORMAL_LOADS] =
    {
        { 1, 8 },
        { 8, -1 },
        { 5, 4 },
        { 4, -4 },
    };
    
    //--------------------------------------------------------------------------------------
    // Helper function to gather Z values
    //--------------------------------------------------------------------------------------
    float LinearEyeDepth(float d, float2 zConstants)
    {
        float z1 = zConstants.x;
        float z2 = zConstants.y;
        float z = (1.0f / (d * z1 + z2));
        return z;
    }
    
    float4 LinearEyeDepth(float4 d, float2 zConstants)
    {
        float4 z1 = zConstants.xxxx;
        float4 z2 = zConstants.yyyy;
        float4 z = (1.0f / (d * z1 + z2));
        return z;
    }
    
    float4 GatherZSamples(sampler2D depthTex, float2 f2TexCoord, float2 zConstants)
    {
        float4 f4Gather;
        f4Gather.x = textureLodOffset(depthTex,f2TexCoord, 0, int2(0, 1)).x;   
        f4Gather.y = textureLodOffset(depthTex,f2TexCoord, 0, int2(1, 1)).x;   
        f4Gather.z = textureLodOffset(depthTex,f2TexCoord, 0, int2(1, 0)).x;   
        f4Gather.w = textureLodOffset(depthTex,f2TexCoord, 0, int2(0, 0)).x;   
    
        float4 f4Ret = LinearEyeDepth(f4Gather, zConstants);
        return f4Ret;
    }
    
    float3 ReconstructCSPosition(float2 posInNDC, float projZ, float4x4 mInvProj)
    {
        float4 pos = float4(posInNDC, projZ * 2 - 1, 1);
    
        //float4 posInCS = mul(pos, mInvProj);
        float4 posInCS = mInvProj * pos;
        return posInCS.xyz / posInCS.w;
    }
    
    float3 GetPosition(sampler2D depthTex,float2 uv, float4x4 mInvProj)
    {
        float3 P;
        P.z = textureLod(depthTex, uv, 0).x;
        // assume DirectX style UV,
        // remap x: [0,1]->[-1,1]    y:[0,1]->[1,-1]
        float2 ndcPos = (uv - 0.5f) * float2(2, -2);
        P = ReconstructCSPosition(ndcPos, P.z, mInvProj);
        return P;
    }
    
    float3 GetCameraXYZFromDepth(float depth, float2 UV, float4x4 invProj)
    {
        float4 ndcPos = float4(UV.x * 2.0f - 1.0f, (1.0f - UV.y) * 2.0f - 1.0f, depth, 1);
        return ReconstructCSPosition(ndcPos.xy, ndcPos.z, invProj);
    }
    
    float GeometryRejectionTest( int2 i2ScreenCoord, float2 rtSize, float4x4 invProj, sampler2D a_depthTex)
    {
        float3 f3N[3];
        float3 f3Pos[3];
        float3 f3Dir[2];
        float fDot;
        float fSummedDot = 0.0f;
        int2 i2MirrorPattern;
        int2 i2OffsetScreenCoord;
        int2 i2MirrorOffsetScreenCoord;
        float fDepth;
        
        fDepth = texelFetch(a_depthTex,i2ScreenCoord, 0 ).x;
        
        f3Pos[0] = GetCameraXYZFromDepth( fDepth, i2ScreenCoord / rtSize.xy, invProj);
    
        for( int iNormal=0; iNormal<NUM_NORMAL_LOADS; iNormal++ )
        {
            i2MirrorPattern = ( g_i2NormalLoadPattern[iNormal] + int2( 1, 1 ) ) * int2( -1, -1 );
            i2OffsetScreenCoord = i2ScreenCoord + g_i2NormalLoadPattern[iNormal];
            i2MirrorOffsetScreenCoord = i2ScreenCoord + i2MirrorPattern;
    
            // Clamp our test to screen coordinates
            //i2OffsetScreenCoord = ( i2OffsetScreenCoord > (rtSize.xy - float2( 1.0f, 1.0f ) ) ) ? (rtSize.xy - float2( 1.0f, 1.0f ) ) : ( i2OffsetScreenCoord );
            int2 rtSizeMinusOne = ivec2(rtSize.xy - float2( 1.0f, 1.0f ));
            i2OffsetScreenCoord.x = i2OffsetScreenCoord.x > rtSizeMinusOne.x?rtSizeMinusOne.x:i2OffsetScreenCoord.x;
            i2OffsetScreenCoord.y = i2OffsetScreenCoord.y > rtSizeMinusOne.y?rtSizeMinusOne.y:i2OffsetScreenCoord.y;
    
            //i2MirrorOffsetScreenCoord = ( i2MirrorOffsetScreenCoord > (rtSize.xy - float2( 1.0f, 1.0f ) ) ) ? (rtSize.xy - float2( 1.0f, 1.0f ) ) : ( i2MirrorOffsetScreenCoord );
            i2MirrorOffsetScreenCoord.x = i2MirrorOffsetScreenCoord.x > rtSizeMinusOne.x?rtSizeMinusOne.x:i2MirrorOffsetScreenCoord.x;
            i2MirrorOffsetScreenCoord.y = i2MirrorOffsetScreenCoord.y > rtSizeMinusOne.y?rtSizeMinusOne.y:i2MirrorOffsetScreenCoord.y;
    
            //i2OffsetScreenCoord = ( i2OffsetScreenCoord < 0 ) ? ( 0 ) : ( i2OffsetScreenCoord );
            //i2MirrorOffsetScreenCoord = ( i2MirrorOffsetScreenCoord < 0 ) ? ( 0 ) : ( i2MirrorOffsetScreenCoord );
            if(i2OffsetScreenCoord.x<0) {i2OffsetScreenCoord.x = 0;}
            if(i2OffsetScreenCoord.y<0) {i2OffsetScreenCoord.y = 0;}
            if(i2MirrorOffsetScreenCoord.x<0) {i2MirrorOffsetScreenCoord.x = 0;}
            if(i2MirrorOffsetScreenCoord.y<0) {i2MirrorOffsetScreenCoord.y = 0;}
    
            fDepth = texelFetch(a_depthTex,i2OffsetScreenCoord,0).x;
            f3Pos[1] = GetCameraXYZFromDepth( fDepth, i2OffsetScreenCoord / rtSize.xy, invProj );
            fDepth = texelFetch(a_depthTex,i2MirrorOffsetScreenCoord,0).x;
            f3Pos[2] = GetCameraXYZFromDepth( fDepth, i2MirrorOffsetScreenCoord / rtSize.xy, invProj);
            
            f3Dir[0] = f3Pos[1] - f3Pos[0];
            f3Dir[1] = f3Pos[2] - f3Pos[0];
            
            f3Dir[0] = normalize( f3Dir[0] );
            f3Dir[1] = normalize( f3Dir[1] );
            
            fDot = dot( f3Dir[0], f3Dir[1] );
            
            fSummedDot += ( fDot + 2.0f );
        }
            
        return ( fSummedDot * 0.125f );
    }
    
    ////////////////////////////these functions are used for generating ao.gb for ssaoblur/////////////////////////////
    /** Used for packing Z into the GB channels */
    float CSZToKey(float z, float a_fZFar)
    {
        return saturate(z * (1.0 / a_fZFar));
    }
    
    /** Used for packing Z into the GB channels */
    float2 packKey(float key)
    {
        float2 outp;
        // Round to the nearest 1/256.0
        float temp = floor(key * 256.0);
    
        // Integer part
        outp.x = temp * (1.0 / 256.0);
    
        // Fractional part
        outp.y = key * 256.0 - temp;
        return outp;
    }
    
    float UnpackKey(float2 fDepthGb)
    {
        return fDepthGb.x * (256.0 / 257.0) + fDepthGb.y * (1.0 / 257.0);
    }
    
    layout(binding = 12 ) uniform HardcodeConstantBuffer
    {
        vec4 dummy0;
        vec4 dummy1;
        vec4 dummy2;
        vec4 dummy3;
        vec4 dummy4;
        vec4 dummy5;
        vec4 dummy6;
        vec4 dummy7;
        vec4 dummy8;
        vec4 dummy9;
        vec4 dummy10;
        vec4 dummy11;
        vec4 dummy12;
        vec4 dummy13;
        vec4 dummy14;
        vec4 dummy15;
        vec4 dummy16;
        float4x4 g_mInvProj;
        float4x4 g_mInvTransposeWorldToCamera;
        vec4 g_RTSize;
        vec4 g_HDAO_ZConstants;
        vec4 g_Falloff;
        vec4 g_MiscParam0;
        vec4 g_MiscParam1;
    };
    
    #define g_FadeoutScale  g_MiscParam0.x // Param : FadeoutScale
    #define g_RejectRadius  g_MiscParam0.y // Param : RejectRadius
    #define g_AcceptRadius  g_MiscParam0.z // Param : AcceptRadius
    #define g_AcceptAngle   g_MiscParam0.w // Param : AcceptAngle
    
    #define g_HDAOIntensity g_MiscParam1.x // Param : Intensity
    #define g_KernelScale   g_MiscParam1.y // Param : KernelScale
    #define g_CameraFar     g_MiscParam1.z // Param : CameraFar
    #define g_UseNormal     false
    #define g_HDAO_NormalScale 1.0f
    
    layout(binding = 0) uniform sampler2D g_depthTex;
    //layout(binding = 1) uniform sampler2D g_normalTex;
    
    struct PS_Input
    {
        float4 Position;
        float2 uv;
    };
    
    in PS_Input IN;
    out vec4 myOut;
    void main()
    {
        float2 rYuv = float2(IN.uv.x, 1 - IN.uv.y);
    
        // Compute integer screen coord, and store off the inverse of the RT Size
        float2 f2InvRTSize = 1.0f / g_RTSize.xy;
        float2 f2ScreenCoord = rYuv * g_RTSize.xy;
        int2 i2ScreenCoord = int2(f2ScreenCoord);
    
        // View space point being shaded
        float3 f3CameraPos = GetPosition(g_depthTex, rYuv.xy, g_mInvProj);
        // generate .gb for ssaoblur
        float2 f2Ogb = packKey(CSZToKey(f3CameraPos.z, g_CameraFar));
    
        float fDot = GeometryRejectionTest(i2ScreenCoord, g_RTSize.xy, g_mInvProj, g_depthTex);
    
        if (fDot > 0.5f)
        {
            // Sample the center pixel for camera Z
            float2 f2TexCoord = float2(f2ScreenCoord * f2InvRTSize);
    
            float fDepth = textureLod(g_depthTex, f2TexCoord,0).x;
    
            float fCenterZ = LinearEyeDepth(fDepth, g_HDAO_ZConstants.xy);
    
            float fOffsetCenterZ = fCenterZ;
    
            float2 f2KernelScale = float2(g_KernelScale, g_KernelScale);
    
            float4 f4Occlusion = float4(0.0f);
    
            // Loop through each gather location, and compare with its mirrored location
            for (int iGather = 0; iGather < NUM_RING_4_GATHERS; iGather++)
            {
                float4 f4Diff = float4(0.0f);
                float4 f4SampledZ[2];
                float4 f4Compare[2];
    
                float2 f2MirrorScreenCoord = ((f2KernelScale * g_f2HDAORingPattern[iGather]) + float2(1.0f, 1.0f)) * float2(-1.0f, -1.0f);
    
                f2TexCoord = float2((f2ScreenCoord + (f2KernelScale * g_f2HDAORingPattern[iGather])) * f2InvRTSize);
                float2 f2MirrorTexCoord = float2((f2ScreenCoord + (f2MirrorScreenCoord)) * f2InvRTSize);
    
                // Sample
                f4SampledZ[0] = GatherZSamples(g_depthTex, f2TexCoord, g_HDAO_ZConstants.xy);
                f4SampledZ[1] = GatherZSamples(g_depthTex, f2MirrorTexCoord, g_HDAO_ZConstants.xy);
    
                // Detect valleys
                f4Diff = fCenterZ.xxxx - f4SampledZ[0];
    
                //f4Compare[0] = (f4Diff < g_RejectRadius.xxxx) ? (1.0f) : (0.0f);
                f4Compare[0] = vec4(lessThan(f4Diff, g_RejectRadius.xxxx));
                //f4Compare[0] *= (f4Diff > g_AcceptRadius.xxxx) ? (1.0f) : (0.0f);
                f4Compare[0] *= vec4(greaterThan(f4Diff,  g_AcceptRadius.xxxx));
    
                f4Diff = fCenterZ.xxxx - f4SampledZ[1];
    
                //f4Compare[1] = (f4Diff < g_RejectRadius.xxxx) ? (1.0f) : (0.0f);
                f4Compare[1] = vec4(lessThan(f4Diff, g_RejectRadius.xxxx));
                //f4Compare[1] *= (f4Diff > g_AcceptRadius.xxxx) ? (1.0f) : (0.0f);
                 f4Compare[1] *= vec4(greaterThan(f4Diff,  g_AcceptRadius.xxxx));
    
                f4Occlusion.xyzw += (g_f4HDAORingWeight[iGather].xyzw * (f4Compare[0].xyzw * f4Compare[1].zwxy) * fDot);
            }
    
            // Finally calculate the HDAO occlusion value
            float fOcclusion = 0;
            fOcclusion = ((f4Occlusion.x + f4Occlusion.y + f4Occlusion.z + f4Occlusion.w) / (2.0f * g_fRingWeightsTotal[RING_4 - 1]));
    
            float falloff = 1 - saturate((fCenterZ - g_Falloff.x) / (g_Falloff.y));
    
            fOcclusion *= g_HDAOIntensity * falloff;
    
            fOcclusion = 1.0f - saturate(fOcclusion);
    
            myOut = float4(fOcclusion, f2Ogb, 1.0f);
        }
        else
        {
            myOut = float4(1.0f, f2Ogb, 1.0f);
        }
    }
    #version 440
    #define int2 ivec2
    
    #define int3 ivec3
    
    #define int4 ivec4
    
    
    
    #define half float
    
    #define half2 vec2
    
    #define half3 vec3
    
    #define half4 vec4
    
    
    
    #define float2 vec2
    
    #define float3 vec3
    
    #define float4 vec4
    
    
    
    #define float2x2 mat2
    
    #define float3x3 mat3
    
    #define float3x4 mat3x4
    
    #define float4x4 mat4
    
    
    #define saturate(value) clamp((value), 0.0f, 1.0f)
    
    #define rsqrt(value) inversesqrt(value)
    
    
    float UnpackKey(float2 fDepthGb)
    {
        return fDepthGb.x * (256.0 / 257.0) + fDepthGb.y * (1.0 / 257.0);
    }
    
    layout(binding = 12 ) uniform HardcodeConstantBuffer
    {
        vec4 dummy0;
        vec4 dummy1;
        vec4 dummy2;
        vec4 dummy3;
        vec4 dummy4;
        vec4 dummy5;
        vec4 dummy6;
        vec4 dummy7;
        vec4 dummy8;
        vec4 dummy9;
        vec4 dummy10;
        vec4 dummy11;
        vec4 dummy12;
        vec4 dummy13;
        vec4 dummy14;
        vec4 dummy15;
        vec4 dummy16;
        vec4 v4_g_ssao_BlurFilterDistance;
        vec4 v4_g_mainTex_TexelSize;
        vec4 v4_g_BlurAxis;
        vec4 v4_g_EdgeSharpness;
    };
    
    #define g_ssao_BlurFilterDistance v4_g_ssao_BlurFilterDistance.x
    #define g_mainTex_TexelSize v4_g_mainTex_TexelSize.xy
    #define g_BlurAxis v4_g_BlurAxis.xy
    #define g_EdgeSharpness v4_g_EdgeSharpness.x
    
    struct PS_Input
    {
        float4 Position;
        float2 uv ;
    };
    
    //--------------------------------------------------------------------------------------
    // After pack z value in aoTex.gb(integer and fraction)  unpack it  to add together and in (0,1)
    //--------------------------------------------------------------------------------------
    const float gaussian[5] = { 0.153170, 0.144893, 0.122649, 0.092902, 0.062970 };  // stddev = 2.0
    
    layout(binding = 0) uniform sampler2D g_mainTex;
    //--------------------------------------------------------------------------------------
    // Blur SSAO ways
    //--------------------------------------------------------------------------------------
    in PS_Input IN;
    out vec4 myOut;
    void main()
    {
        float4 fragment = float4(1, 1, 1, 1);
    //reverse y axis
        //float2 ssC = IN.uv.xy;
        float2 rYuv = float2(IN.uv.x, 1 - IN.uv.y);
        float2 ssC = rYuv.xy;
        float4 temp = textureLod(g_mainTex,rYuv, 0);
    
        float2 passthrough2 = temp.gb;
        float key = UnpackKey(passthrough2);
    
        float sum = temp.r;
    
        // Base weight for depth falloff. Increase this for more blurriness, decrease it for better edge discrimination
    
        float BASE = gaussian[0] * 0.5; // ole: i decreased
        float totalWeight = BASE;
        sum *= totalWeight;
    
    
        // We already handled the zero case above.  This loop should be unrolled and the branch discarded
        {
            temp = textureLod(g_mainTex, ssC + g_BlurAxis * g_mainTex_TexelSize.xy * (-4.0f * g_ssao_BlurFilterDistance), 0);
            float tapKey = UnpackKey(temp.gb);
            float value = temp.r;
    
            // spatial domain: offset gaussian tap
            float weight = 0.3 + gaussian[4];
    
            // range domain (the "bilateral" weight). As depth difference increases, decrease weight.
            // these two keys is depth value which we stored in AoTex generate in .gb
            weight *= max(0.0, 1.0 - (2000.0 * g_EdgeSharpness) * abs(tapKey - key));
            sum += value * weight;
            totalWeight += weight;
        }
        {
            temp = textureLod(g_mainTex, ssC + g_BlurAxis * g_mainTex_TexelSize.xy * (-3.0f * g_ssao_BlurFilterDistance), 0);
    
            float tapKey = UnpackKey(temp.gb);
            float value = temp.r;
    
            // spatial domain: offset gaussian tap
            float weight = 0.3 + gaussian[3];
    
            // range domain (the "bilateral" weight). As depth difference increases, decrease weight.
            // these two keys is depth value which we stored in AoTex generate in .gb
            weight *= max(0.0, 1.0 - (2000.0 * g_EdgeSharpness) * abs(tapKey - key));
            sum += value * weight;
            totalWeight += weight;
        }
        {
            temp = textureLod(g_mainTex, ssC + g_BlurAxis * g_mainTex_TexelSize.xy * (-2.0f * g_ssao_BlurFilterDistance), 0);
            float tapKey = UnpackKey(temp.gb);
            float value = temp.r;
    
            // spatial domain: offset gaussian tap
            float weight = 0.3 + gaussian[2];
    
            // range domain (the "bilateral" weight). As depth difference increases, decrease weight.
            // these two keys is depth value which we stored in AoTex generate in .gb
            weight *= max(0.0, 1.0 - (2000.0 * g_EdgeSharpness) * abs(tapKey - key));
            sum += value * weight;
            totalWeight += weight;
        }
        {
            temp = textureLod(g_mainTex,ssC + g_BlurAxis * g_mainTex_TexelSize.xy * (-1.0f * g_ssao_BlurFilterDistance), 0);
            float tapKey = UnpackKey(temp.gb);
            float value = temp.r;
    
            // spatial domain: offset gaussian tap
            float weight = 0.3 + gaussian[1];
    
            // range domain (the "bilateral" weight). As depth difference increases, decrease weight.
            // these two keys is depth value which we stored in AoTex generate in .gb
            weight *= max(0.0, 1.0 - (2000.0 * g_EdgeSharpness) * abs(tapKey - key));
            sum += value * weight;
            totalWeight += weight;
        }
        {
            temp = textureLod(g_mainTex,ssC + g_BlurAxis * g_mainTex_TexelSize.xy * (1.0f * g_ssao_BlurFilterDistance), 0);
    
            float tapKey = UnpackKey(temp.gb);
            float value = temp.r;
    
            // spatial domain: offset gaussian tap
            float weight = 0.3 + gaussian[1];
    
            // range domain (the "bilateral" weight). As depth difference increases, decrease weight.
            //these two keys is depth value which we stored in AoTex generate in .gb
            weight *= max(0.0, 1.0 - (2000.0 * g_EdgeSharpness) * abs(tapKey - key));
            sum += value * weight;
            totalWeight += weight;
        }
        {
            temp = textureLod(g_mainTex,ssC + g_BlurAxis * g_mainTex_TexelSize.xy * (2.0f * g_ssao_BlurFilterDistance),0);
            float tapKey = UnpackKey(temp.gb);
            float value = temp.r;
    
            // spatial domain: offset gaussian tap
            float weight = 0.3 + gaussian[2];
    
            // range domain (the "bilateral" weight). As depth difference increases, decrease weight.
            // these two keys is depth value which we stored in AoTex generate in .gb
            weight *= max(0.0, 1.0 - (2000.0 * g_EdgeSharpness) * abs(tapKey - key));
            sum += value * weight;
            totalWeight += weight;
        }
        {
            temp = textureLod(g_mainTex,ssC + g_BlurAxis * g_mainTex_TexelSize.xy * (3.0f * g_ssao_BlurFilterDistance),0);
            float tapKey = UnpackKey(temp.gb);
            float value = temp.r;
    
            // spatial domain: offset gaussian tap
            float weight = 0.3 + gaussian[3];
    
            // range domain (the "bilateral" weight). As depth difference increases, decrease weight.
            // these two keys is depth value which we stored in AoTex generate in .gb
            weight *= max(0.0, 1.0 - (2000.0 * g_EdgeSharpness) * abs(tapKey - key));
            sum += value * weight;
            totalWeight += weight;
        }
        {
            temp = textureLod(g_mainTex,ssC + g_BlurAxis * g_mainTex_TexelSize.xy * (4.0f * g_ssao_BlurFilterDistance), 0);
            float tapKey = UnpackKey(temp.gb);
            float value = temp.r;
    
            // spatial domain: offset gaussian tap
            float weight = 0.3 + gaussian[4];
    
            // range domain (the "bilateral" weight). As depth difference increases, decrease weight.
            //these two keys is depth value which we stored in AoTex generate in .gb
            weight *= max(0.0, 1.0 - (2000.0 * g_EdgeSharpness) * abs(tapKey - key));
            sum += value * weight;
            totalWeight += weight;
        }
    
        const float epsilon = 0.0001;
    
        fragment = vec4(sum / (totalWeight + epsilon));
    
        fragment.gb = passthrough2;
    
        myOut = fragment;
    }
  • 相关阅读:
    实验吧_简单的sql注入_1、2、3
    实验吧_天下武功唯快不破&让我进去(哈希长度拓展攻击)
    实验吧_密码忘记了(vim编辑器+代码审计)&天网管理系统(php弱比较+反序列化)
    实验吧_Guess Next Session&Once More(代码审计)
    实验吧_NSCTF web200&FALSE(代码审计)
    实验吧_程序逻辑问题(代码审计)&上传绕过
    实验吧_貌似有点难(php代码审计)&头有点大
    网络安全实验室_上传关writeup
    php文件包含漏洞(input与filter)
    我为什么要写LeetCode的博客?
  • 原文地址:https://www.cnblogs.com/DeanWang/p/6992393.html
Copyright © 2020-2023  润新知