Shader Optimization.

I was playing with the shader and wondered if it could be optimized.

Lets start with the standard Shader

float2 HmdWarp(float2 in01)
{
    float2 theta = (in01 - LensCenter) * ScaleIn; // Scales to [-1, 1]
    float  rSq= theta.x * theta.x + theta.y * theta.y;
    float2 theta1 = theta * (HmdWarpParam.x + HmdWarpParam.y * rSq + 
                    HmdWarpParam.z * rSq * rSq + HmdWarpParam.w * rSq * rSq * rSq);
    return LensCenter + Scale * theta1;
}

float4 main( float2 texCoord : TEXCOORD0,float4 color  : COLOR0 ) : SV_Target 
{
    float2 tc = HmdWarp(texCoord);
    if (any(clamp(tc, ScreenCenter-float2(0.25,0.5), ScreenCenter+float2(0.25, 0.5)) - tc))
        return 0;
    return Texture.Sample(Linear, tc);

};

That's 11 Multiplies, 6 Additions and 3 Subtractions per pixel. (eyeballed the numbers sorry, could be off by one or two) and on my GTX670 takes 0.1447264 milliseconds to execute (based on averaging the time of a 100 frames of just the draw with the shader)

Which could be good, could be bad, nothing to compare it to, so lets compare it to a shader that does not warp and just samples the texture.

float4 pixelShader( float2 texCoord : TEXCOORD0,float4 color  : COLOR0 ) : SV_Target 
{                                                     
    float4 c = Texture.Sample(Linear, texCoord);              
    return c;                                         
}

which takes 0.0272857 milliseconds to execute (again GTX670, 100 frames)

So the warping shader is 5.3 times slower than just bare sampling.

There must be a better way, why are we recalculating the distortion map every frame single frame? seems rather wasteful. Lets render the distortion map to texture instead. We'll use the Red channel for the X distortion, and the Green channel for the Y distortion. If we make a texture of format R32G32_Float it should fit our needs nicely. And the upside is we only have to do the nasty math once!

our shader now looks like this

float2 HmdWarp(float2 in01)
{
 /// Same as above, cut to keep the post size down.
}

float4 main( float2 texCoord : TEXCOORD0,float4 color  : COLOR0 ) : SV_Target 
{
    float2 tc = HmdWarp(texCoord);
    if (any(clamp(tc, ScreenCenter-float2(0.25,0.5), ScreenCenter+float2(0.25, 0.5)) - tc))
		return 0;
	return float4(tc.x, tc.y,0,0);
};

The resulting texture will look kinda like this (Used bad parameters, had to guess since I don't have a rift yet so the horizontal mapping is somewhat off)



Sweet, almost in business! lets update the warping shader to make use of the new texture. First of all the linear sampler has to go, a MinMagMipPoint sampler will fit our needs better.

SamplerState PointSampler : register(s0);
Texture2D Texture    :  register(t0);
Texture2D TextureWarp : register(t1);

float4 main( float2 texCoord : TEXCOORD0,float4 color  : COLOR0 ) : SV_Target 
{
	float4 c = TextureWarp.Sample(PointSampler, texCoord);   
	float2 RealCoord = float2(c.r,c.g);
	return Texture.Sample(PointSampler, RealCoord);
};

Ahh much simpler now! New execution time 0.0598547 milliseconds and no visual difference! 2.5 times speed up from the original shader! Not bad for 20 minutes of tinkering.