引擎设计跟踪(九.14.3.2) Deferred shading的后续实现和优化

  1 // One per quad - gets expanded in the geometry shader
  2 struct GPUQuadVSOut
  3 {
  4     float4 coords : coords;         // [min.xy, max.xy] in clip space
  5     float quadZ : quadZ;
  6     //Crazii
  7     float quadMaxZ : quadMaxZ;
  8     //-//Crazii
  9     uint lightIndex : lightIndex;
 10 };
 11 
 12 GPUQuadVSOut GPUQuadVS(uint lightIndex : SV_VertexID) 
 13 {
 14     GPUQuadVSOut output;
 15     output.lightIndex = lightIndex;
 16 
 17     // Work out tight clip-space rectangle
 18     PointLight light = gLight[lightIndex];
 19     output.coords = ComputeClipRegion(light.positionView, light.attenuationEnd);
 20     
 21     // Work out nearest depth for quad Z
 22     // Clamp to near plane in case this light intersects the near plane... don‘t want our quad to be clipped
 23     float quadDepth = max(mCameraNearFar.x, light.positionView.z - light.attenuationEnd);
 24 
 25     // Project quad depth into clip space
 26     float4 quadClip = mul(float4(0.0f, 0.0f, quadDepth, 1.0f), mCameraProj);
 27     output.quadZ = quadClip.z / quadClip.w;
 28 
 29     //Crazii
 30     //quadClip = mul(float4(0.0f, 0.0f, light.positionView.z + light.attenuationEnd, 1.0f), mCameraProj);
 31     //output.quadMaxZ = quadClip.z / quadClip.w;
 32     output.quadMaxZ = light.positionView.z + light.attenuationEnd;
 33     //-Crazii
 34 
 35     return output;
 36 }
 37 
 38 struct GPUQuadGSOut
 39 {
 40     float4 positionViewport : SV_Position;
 41     // NOTE: Using a uint4 to work around a compiler bug. Otherwise the SV_SampleIndex input to the per-sample
 42     // shader below gets put into a ‘.y‘ which doesn‘t appear to work on some implementations.
 43     nointerpolation uint4 lightIndex : lightIndex;
 44     //Crazii
 45     nointerpolation float maxDepth : maxDpeth;
 46     //-Crazii
 47 };
 48 
 49 // Takes point output and converts into screen-space quads
 50 [maxvertexcount(4)]
 51 void GPUQuadGS(point GPUQuadVSOut input[1], inout TriangleStream<GPUQuadGSOut> quadStream)
 52 {
 53     GPUQuadGSOut output;
 54     output.lightIndex = input[0].lightIndex;
 55     //Crazii
 56     output.maxDepth = input[0].quadMaxZ;
 57     //-Crazii
 58     output.positionViewport.zw = float2(input[0].quadZ, 1.0f);
 59 
 60     // Branch around empty regions (i.e. light entirely offscreen)
 61     if (all(input[0].coords.xy < input[0].coords.zw)) {
 62         output.positionViewport.xy = input[0].coords.xw;      // [-1,  1]
 63         quadStream.Append(output);
 64         output.positionViewport.xy = input[0].coords.zw;      // [ 1,  1]
 65         quadStream.Append(output);
 66         output.positionViewport.xy = input[0].coords.xy;      // [-1, -1]
 67         quadStream.Append(output);
 68         output.positionViewport.xy = input[0].coords.zy;      // [ 1, -1]
 69         quadStream.Append(output);
 70         quadStream.RestartStrip();
 71     }
 72 }
 73 
 74 float4 GPUQuad(GPUQuadGSOut input, uint sampleIndex)
 75 {
 76     float3 lit = float3(0.0f, 0.0f, 0.0f);
 77     
 78     [branch] if (mUI.visualizeLightCount) {
 79         lit = rcp(255.0f).xxx;
 80     } else {
 81         //Crazii
 82         float zBuffer = gGBufferTextures[3].Load(input.positionViewport.xy, sampleIndex).x;
 83         float viewSpaceZ = mCameraProj._43 / (zBuffer - mCameraProj._33);
 84         if (viewSpaceZ - input.maxDepth > 0)
 85             clip(-1);
 86         //-Crazii
 87         SurfaceData surface = ComputeSurfaceDataFromGBufferSample(uint2(input.positionViewport.xy), sampleIndex);
 88 
 89         // Avoid shading skybox/background pixels
 90         // NOTE: Compiler doesn‘t quite seem to move all the unrelated surface computations inside here
 91         // We could force it to by restructuring the code a bit, but the "all skybox" case isn‘t useful for
 92         // our benchmarking anyways.
 93         if (surface.positionView.z < mCameraNearFar.y) {
 94             PointLight light = gLight[input.lightIndex.x];
 95             AccumulateBRDF(surface, light, lit /*Crazii*/, true /*-Crazii*/);
 96         }    
 97     }
 98 
 99     return float4(lit, 1.0f);
100 }

 1 #if !defined(DIRECTIONAL)
 2     //use outer sphere to make sure rays covers entire volume
 3 #    if defined(POINT)
 4     float4 posVS = float4(viewSpacePos.xyz, 1);
 5     float3 halfSize = viewSpacePos.w;
 6 #    else
 7     float4 posVS = viewSpaceBounding[0];
 8     float3 halfSize = viewSpaceBounding[1].xyz;
 9 #    endif
10 
11     //view space depth range. note posVS.z < 0 in Right handed system
12     outDethRange = float2(-(posVS.z + halfSize.z), -(posVS.z - halfSize.z));    //min,max
13 ...
14 #endif

 1 #if !defined(DIRECTIONAL)
 2     //GBuffer depth
 3     float2 depthUV = UV * depthUVSpace.zw + depthUVSpace.xy;
 4     float depth = tex2D(depthBuffer, depthUV).r;    //INTZ
 5     depth = depth * depthFactor.z + depthFactor.w;    //depth to NDC [0,1] or [-1,1]
 6     float viewDepth = depthFactor.y / (depth + depthFactor.x);    //right handed inverse calculation from NDC to viewZ (viewZ < 0, and make it > 0 )
 7     if (viewDepth - depthRange.x < 0 || viewDepth - depthRange.y > 0)
 8     {
 9         clip(-1);
10         //return float4(0, 0, 0, 0); /optimized level 3(O3) will auto return on clip
11     }
12 ...
13 #endif

 1     /* using farther plane:
 2     light volume: use farther/center plane causing volume not fully covered (filled in x)
 3     +------------------+
 4     |\                /|
 5     |x\              /x|
 6     |xx\            /xx|
 7     |xxx\          /xxx|
 8     +----\        /----+
 9       minRay    maxRay
10     */

1     /* using nearer（front） plane:
2     +--------------------------+
3      \                        /
4       \                   +--/--+ farther plane
5        \                  | /   |
6         \                 |/    | Center
7          \                /     |
8           \              /+-----+ nearer plane  - clipped!
9     */

 1     //screen pos:
 2     posVS.z -= halfSize.z;    //use farther plane, to avoid near clip (xy outrange[-1,1])
 3     float4 projCenter = mul(posVS, projMatrix);
 4     projCenter /= projCenter.w;
 5     //farther plane is too small to cover the volume, scale it to the same projection size of nearer plane
 6     float scale = outDethRange.y / outDethRange.x;
 7     posVS.xy += halfSize.xy*scale;
 8     float4 projMax = mul(posVS, projMatrix);
 9     projMax /= projMax.w;
10 
11     pos.xy = pos.xy*(projMax.xy - projCenter.xy) + projCenter.xy;