Client Distortion Mesh

I implemented client side distortion rendering a while ago as a demo for my thesis that used fixed pipeline stuff and display lists. I later proceeded out of interest switch to a more modern approach with vbo's and shaders.

The overview of what happens is basically:

ovrHmd_CreateDistortionMesh:
The Vertices you get for the left eye will lie in the left plane of your windows while the right values on the right side. So basically two views into one window.

The texture coordinates are in TanEyeAngles, this means if you multiply these value by the distance from eye to hmd (UVScale) and add the vertical or horizontal offset (UVOffset) you get the final texture coordinate. This is why you need ovrHmd_GetRenderScaleAndOffset.

The conversion for the TanEyeAngles to UV is done in the vertex shader somewhere in the SDK there is a quite large .h/.cpp file with different shaders you can use.

The following is the shader I used for my project (without timewarp) so it is quite simple.

/*
Shaders.h
*/

// Vertex Shader
static const char* vertexShader =
"#version 110\n"

"uniform vec2 EyeToSourceUVScale;\n"
"uniform vec2 EyeToSourceUVOffset;\n"

"attribute vec4 Position;\n"
//"attribute vec4 Color;\n"
// Vignette Fade and TimeWarpFactor encoded into Pos.z and Pos.w
"attribute vec2 TexCoord0;\n"
"attribute vec2 TexCoord1;\n"
"attribute vec2 TexCoord2;\n"

"varying vec4 oColor; \n"
"varying vec2 oTexCoord0;\n"
"varying vec2 oTexCoord1;\n"
"varying vec2 oTexCoord2;\n"

"void main() {\n"

"	gl_Position.x = Position.x;\n"
"	gl_Position.y = Position.y;\n"
"	gl_Position.z = 0.5;\n"
"	gl_Position.w = 1.0;\n"

	// Vertex inputs are in TanEyeAngle space for the R,G,B channels 
	// (i.e. after chromatic aberration and distortion). 
	// Scale them into the correct [0-1],[0-1] UV lookup space (depending on eye)
	"   oTexCoord0 = TexCoord0 * EyeToSourceUVScale + EyeToSourceUVOffset;\n"
	"   oTexCoord0.y = 1.0-oTexCoord0.y;\n"
	"   oTexCoord1 = TexCoord1 * EyeToSourceUVScale + EyeToSourceUVOffset;\n"
	"   oTexCoord1.y = 1.0-oTexCoord1.y;\n"
	"   oTexCoord2 = TexCoord2 * EyeToSourceUVScale + EyeToSourceUVOffset;\n"
	"   oTexCoord2.y = 1.0-oTexCoord2.y;\n"

"	oColor = vec4(Position.w, Position.w, Position.w, Position.z);\n"	// Used for VignetteFade.
"}\n";

// Fragment Shader
static const char* fragmentShader =
"#version 110 \n"

"uniform sampler2D Texture;\n"

"varying vec4 oColor;\n"
"varying vec2 oTexCoord0;\n"
"varying vec2 oTexCoord1;\n"
"varying vec2 oTexCoord2;\n"

"void main() {\n"

//"gl_FragColor = oColor * texture2D(Texture, oTexCoord1);\n"
"	gl_FragColor.r = oColor.r * texture2D(Texture, oTexCoord0).r;\n"
"	gl_FragColor.g = oColor.g * texture2D(Texture, oTexCoord1).g;\n"
"	gl_FragColor.b = oColor.b * texture2D(Texture, oTexCoord2).b;\n"
"	gl_FragColor.a = 1.0;\n"
"}\n";

Here my vbo example, it was for testing purposes so don't expect a clean coded source file (but it works) and I think it is quite straight forward to understand. The only thing I did not get to work was direct mode.

CRender.cpp
http://pastebin.com/BChxCgPR

CRender.h
http://pastebin.com/875r1M7v

Shaders.h
http://pastebin.com/hgY1TTiN

Put this in your main.cpp

    oculusVr test;

    test.ovrInit(-1); // debug hmd
    test.ovrSetParams(640,480); // window size
    test.oglInit();
    test.ovrMeshVbo();
    test.loadShader();
    test.loadTexture();
    test.oglRender();
    test.oglDeinit();
    test.ovrDeinit();

Wondering if anyone tried to 'reverse engineer', so to speak, that part of the process for ray casting.