Quote:

Original post by wolf I saw Pat Wilson's screenshots and when the number of overlapping lights increase you can see that the colors are better preserved.

float4 PackDepthNormal(float Z, float3 normal)
{
  float4 output;

  // High depth (currently in the 0..127 range
  Z = saturate(Z);
  output.z = floor(Z*63);
  
  // Low depth 0..1
  output.w = frac(Z*63);
  
  // Normal (xy)
  output.xy = normal.xy*.5+.5;
  
  // Encode sign of 0 in upper portion of high Z
  if(normal.z < 0) 
    output.z += 64;

  // Convert to 0..1
  output.z /= 255;
    
  return output;
}

void UnpackDepthNormal(float4 input, out float Z, out float3 normal)
{
  // Read in the normal xy
  normal.xy = input.xy*2-1;
  
  // Compute the (unsigned) z normal
  normal.z = 1.0 - sqrt(dot(normal.xy, normal.xy));
  float hiDepth = input.z*255;
  
  // Check the sign of the z normal component
  if(hiDepth >= 64)
  {
    normal.z = -normal.z;
    hiDepth -= 64;
  }
  
  Z = (hiDepth + input.w)/63.0;;
}

inline float2 cartesianToSpGPU( in float3 normalizedVec )
{
   float atanYX = atan2( normalizedVec.y, normalizedVec.x );
   float2 ret = float2( atanYX / PI, normalizedVec.z );

   return POS_NEG_ENCODE( ret );
}

inline float2 cartesianToSpGPU( in float3 normalizedVec, in sampler2D atan2Sampler )
{
#ifdef NO_TRIG_LOOKUPS
   return cartesianToSpGPU( normalizedVec );
#else
   float atanYXOut = tex2D( atan2Sampler, floor( POS_NEG_ENCODE(normalizedVec.xy ) * 255.0 ) / 255.0  ).a;
   float2 ret = float2( atanYXOut, POS_NEG_ENCODE( normalizedVec.z ) );
   return ret;
#endif
}

inline float3 spGPUToCartesian( in float2 spGPUAngles )
{
   float2 expSpGPUAngles = POS_NEG_DECODE( spGPUAngles );
   float2 scTheta;

   sincos( expSpGPUAngles.x * PI, scTheta.x, scTheta.y );
   float2 scPhi = float2( sqrt( 1.0 - expSpGPUAngles.y * expSpGPUAngles.y ), expSpGPUAngles.y );

   // Renormalization not needed
   return float3( scTheta.y * scPhi.x, scTheta.x * scPhi.x, scPhi.y );
}

inline float3 spGPUToCartesian( in float2 spGPUAngles, in sampler1D sinCosSampler )
{
#ifdef NO_TRIG_LOOKUPS
   return spGPUToCartesian( spGPUAngles );
#else
   float2 scTheta = POS_NEG_DECODE( tex1D( sinCosSampler, spGPUAngles.x ) );

   float2 expSpGPUAngles = POS_NEG_DECODE( spGPUAngles );
   float2 scPhi = float2( sqrt( 1.0 - expSpGPUAngles.y * expSpGPUAngles.y ), expSpGPUAngles.y );

   // Renormalization not needed
   return float3( scTheta.y * scPhi.x, scTheta.x * scPhi.x, scPhi.y );
#endif
}

Quote:

Original post by wolf I went through the slides but I did not see how they compress the normals .. I probably just missed it. Can you outline how they do this?

• Clear to (0.0), (0x0).
  
• Shared by all render targets.
  

• Clear to (0.0, 0.0, 0.0, 0.0).
  
• rgb = mul(float3x3(worldMatrix), normalObjectSpace.xyz);
  
• a = mul(worldViewMatrix, positionObjectSpace.xyzw) / farClipPlaneDepth;
  

• Clear to (1.0, 1.0, 1.0, 1.0).
  
• Multiplicative blending
  
• rgb = exp2(-(lightColor * NdotL * Attenuation));
  
• a = exp2(-(NdotH)); // Will multiply by luma later.
  

• Clear to (0.0, 0.0, 0.0, 0.0).
  
• Target for final lit image (calculated from light buffer, and material shader)
  
• Used as source/target for post-processing
  

• Interchangeable with RT2.
  

• exp2() and log2() are mapped to hardware instructions, right? So that would make them almost free?
  
• Since the luma extraction trick isn't defined for ranges outside [0, 1], how far off will my results be as I get further outside this range? If the error will be too much, can anyone recommend an alternative trick to extract luminance that would work with this range?
  
• Just so my understanding is clear, RGBA16F textures are supported on sub-SM 3.0 cards, but they don't support blending or filtering?
  
• Does RGBA16F store negative values? Specifically, I need to know this for storing my normals.
  
• Drillian, since I assume you are using the exp2() log2() trick in your own project, have you found a way to handle alpha-blending in this space that works with the hardware?