# HG changeset patch
# User John Tsiombikas <nuclear@member.fsf.org>
# Date 1379721647 -10800
# Node ID 464e1d135d6815cfd5c30cf18583131da569e1a3
# Parent  d797639e0234368668f9db6dc8febecbf4b2756c
hurraaaay!

diff -r d797639e0234 -r 464e1d135d68 sdr.glsl
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sdr.glsl	Sat Sep 21 03:00:47 2013 +0300
@@ -0,0 +1,44 @@
+uniform sampler2D tex;
+uniform float aspect, scale;
+uniform float lens_center_offset;
+uniform vec4 dist_factors;
+
+vec2 distort_texcoords(in vec2 tc, out float dbgrad);
+float barrel_scale(float x, in vec4 k);
+
+void main()
+{
+	float dbgrad;
+	vec2 tc = distort_texcoords(gl_TexCoord[0].xy, dbgrad);
+
+	gl_FragColor.rgb = texture2D(tex, tc).rgb;
+	gl_FragColor.rgb += mix(vec3(1.0, 1.0, 0.0), vec3(0.0), smoothstep(0.01, 0.05, dbgrad));
+	gl_FragColor.a = 1.0;
+}
+
+vec2 distort_texcoords(in vec2 tc, out float dbgrad)
+{
+	// map tc [0, 1] -> [-1, 1]
+	vec2 pt = tc * 2.0 - 1.0;
+
+	pt.x += lens_center_offset * 2.0;
+	pt.y /= aspect;	// correct for aspect ratio
+
+	float rad = barrel_scale(dot(pt, pt), dist_factors);
+	pt *= rad;	// scale the point by the computer distortion radius
+
+	dbgrad = length(pt) * rad;
+
+	pt.y *= aspect;
+	pt.x -= lens_center_offset * 2.0;
+
+	// map back to range [0, 1]
+	return pt * 0.5 + 0.5;
+}
+
+float barrel_scale(float rad, in vec4 k)
+{
+	float radsq = rad * rad;
+	float radquad = radsq * radsq;
+	return k.x + k.y * radsq + k.z * radquad + k.w * radquad * radsq;
+}
diff -r d797639e0234 -r 464e1d135d68 src/main.cc
--- a/src/main.cc	Fri Sep 20 10:14:29 2013 +0300
+++ b/src/main.cc	Sat Sep 21 03:00:47 2013 +0300
@@ -11,6 +11,7 @@
 static void disp();
 static void draw_scene();
 static void draw_teapot();
+static void draw_squares();
 static void draw_grid(float size, float spacing);
 static void idle();
 static void reshape(int x, int y);
@@ -32,7 +33,6 @@
 static int rtarg_width, rtarg_height;
 static unsigned int fbo, tex[2], zbuf;
 
-
 int main(int argc, char **argv)
 {
 	glutInitWindowSize(1280, 800);
@@ -98,6 +98,8 @@
 		rtarg_height = height;
 	}
 
+	printf("render target: %dx%d\n", rtarg_width, rtarg_height);
+
 	// create render targets for each eye
 	GLenum wrap_mode = GL_CLAMP_TO_EDGE;
 	if(!GLEW_SGIS_texture_edge_clamp) {
@@ -142,9 +144,13 @@
 
 	cam.track_vr();
 
-	glMatrixMode(GL_PROJECTION);
+	/*glMatrixMode(GL_PROJECTION);
 	glLoadIdentity();
-	gluPerspective(RAD_TO_DEG(vr_get_fov()), (float)rtarg_width / (float)rtarg_height, 0.5, 500.0);
+	float fov = RAD_TO_DEG(vr_get_fov());
+	gluPerspective(fov, (float)rtarg_width / (float)rtarg_height, 0.25, 500.0);*/
+	float proj_matrix[16];
+
+	float eye_dist = vr_get_eyedist();
 
 	glViewport(0, 0, rtarg_width, rtarg_height);
 
@@ -156,10 +162,14 @@
 
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
+	glMatrixMode(GL_PROJECTION);
+	vr_get_proj_matrix(proj_matrix, VR_EYE_LEFT);
+	glLoadTransposeMatrixf(proj_matrix);
+
 	glMatrixMode(GL_MODELVIEW);
 	glLoadIdentity();
+	glTranslatef(eye_dist / 2.0, 0, 0);
 	cam.use_inverse();
-	glTranslatef(0.32, 0, 0);
 	draw_scene();
 
 
@@ -169,10 +179,14 @@
 
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
+	glMatrixMode(GL_PROJECTION);
+	vr_get_proj_matrix(proj_matrix, VR_EYE_RIGHT);
+	glLoadTransposeMatrixf(proj_matrix);
+
 	glMatrixMode(GL_MODELVIEW);
 	glLoadIdentity();
+	glTranslatef(-eye_dist / 2.0, 0, 0);
 	cam.use_inverse();
-	glTranslatef(-0.32, 0, 0);
 	draw_scene();
 
 	// return to the regular window framebuffer
@@ -187,6 +201,8 @@
 
 	glutSwapBuffers();
 	assert(glGetError() == GL_NO_ERROR);
+
+	glFinish();
 }
 
 
@@ -195,6 +211,8 @@
 	float lpos[] = {0, 60, 0, 1};
 	glLightfv(GL_LIGHT0, GL_POSITION, lpos);
 
+	draw_grid(100.0, 2.5);
+
 	static Vector2 teapos[] = {
 		Vector2(-8, 8), Vector2(8, 8), Vector2(8, -8), Vector2(-8, -8)
 	};
@@ -206,7 +224,7 @@
 		glPopMatrix();
 	}
 
-	draw_grid(100.0, 2.5);
+	draw_squares();
 }
 
 static void draw_teapot()
@@ -225,6 +243,37 @@
 	glFrontFace(GL_CCW);
 }
 
+static void draw_squares()
+{
+	static const int num_sq = 4;
+
+	glPushAttrib(GL_ENABLE_BIT | GL_LINE_BIT);
+	glDisable(GL_LIGHTING);
+
+	glMatrixMode(GL_MODELVIEW);
+	glPushMatrix();
+	glTranslatef(0, 1, 0);
+
+
+	glLineWidth(3.0);
+	glColor3f(1.0, 0.7, 0.2);
+
+	float zdist = 2.0;
+	for(int i=0; i<num_sq; i++) {
+		glBegin(GL_LINE_LOOP);
+		glVertex3f(-1, -1, -zdist);
+		glVertex3f(1, -1, -zdist);
+		glVertex3f(1, 1, -zdist);
+		glVertex3f(-1, 1, -zdist);
+		glEnd();
+
+		zdist += 1.0;
+	}
+
+	glPopMatrix();
+	glPopAttrib();
+}
+
 static void draw_grid(float size, float spacing)
 {
 	int num_lines = size / spacing;
diff -r d797639e0234 -r 464e1d135d68 src/vr.cc
--- a/src/vr.cc	Fri Sep 20 10:14:29 2013 +0300
+++ b/src/vr.cc	Sat Sep 21 03:00:47 2013 +0300
@@ -11,20 +11,24 @@
 	"uniform vec2 scale_in;\n"
 	"uniform vec4 warp_param;\n"
 	"\n"
-	"vec2 warp(in vec2 pt)\n"
+	"vec2 warp(in vec2 pt, out float dbgrad)\n"
 	"{\n"
 	"    vec2 theta = (pt - lens_center) * scale_in;\n"
-	"    float rsq = length(theta);\n"
-	"    vec2 rvec = theta * (warp_param.x + warp_param.y * rsq +\n"
+	"    float rsq = dot(theta, theta);\n"
+	"    vec2 rvec = theta * (warp_param.x + \n"
+	"                         warp_param.y * rsq +\n"
 	"                         warp_param.z * rsq * rsq +\n"
 	"                         warp_param.w * rsq * rsq * rsq);\n"
+	"    dbgrad = length(theta);\n"
 	"    return lens_center + scale * rvec;\n"
 	"}\n"
 	"\n"
 	"void main()\n"
 	"{\n"
-	"    vec2 tc = warp(gl_TexCoord[0].xy);\n"
+	"    float dbgrad;\n"
+	"    vec2 tc = warp(gl_TexCoord[0].xy, dbgrad);\n"
 	"    gl_FragColor.rgb = texture2D(tex, tc).rgb;\n"
+	"    gl_FragColor.rgb += mix(vec3(1.0, 1.0, 0.0), vec3(0.0), smoothstep(0.01, 0.05, dbgrad));\n"
 	"    gl_FragColor.a = 1.0;\n"
 	"}\n";
 
@@ -94,9 +98,6 @@
 		}
 
 		// calculate and store viewing parameters
-		float vhalfsz = info.VScreenSize * 0.5;
-		vr_ctx.info.fov = 2.0 * atan(vhalfsz / info.EyeToScreenDistance);
-
 		vr_ctx.info.width = info.HResolution;
 		vr_ctx.info.height = info.VResolution;
 		vr_ctx.info.aspect = (float)vr_ctx.info.width / (float)vr_ctx.info.height;
@@ -106,7 +107,17 @@
 			vr_ctx.info.distort[i] = info.DistortionK[i];
 		}
 
-		vr_ctx.info.lens_center = info.LensSeparationDistance / info.HScreenSize;
+		vr_ctx.info.scale = 1.0;
+
+		float vhalfsz = vr_ctx.info.scale * info.VScreenSize * 0.5;
+		vr_ctx.info.fov = 2.0 * atan(vhalfsz / info.EyeToScreenDistance);
+
+		vr_ctx.info.lens_center_offset = 0.5 - info.LensSeparationDistance / info.HScreenSize;
+
+		// calculate center of projection shift to match the lens positions
+		float center_dist_meters = info.HScreenSize * 0.25;
+		float proj_shift = center_dist_meters - info.LensSeparationDistance * 0.5;
+		vr_ctx.info.proj_center_offset = 4.0 * proj_shift / info.HScreenSize;
 	}
 
 	// get the sensor device
@@ -132,10 +143,30 @@
 	return true;
 }
 
+#define EXTERNAL_SHADER
+
 static bool init_sdr()
 {
 	int status;
 
+#ifdef EXTERNAL_SHADER
+	FILE *fp = fopen("sdr.glsl", "rb");
+	if(!fp) {
+		perror("failed to load sdr.glsl");
+		return false;
+	}
+	fseek(fp, 0, SEEK_END);
+	long sz = ftell(fp);
+	rewind(fp);
+
+	char *buf = (char*)alloca(sz + 1);
+	fread(buf, 1, sz, fp);
+	buf[sz] = 0;
+	sdr_src = buf;
+
+	fclose(fp);
+#endif
+
 	unsigned int sdr = glCreateShader(GL_FRAGMENT_SHADER);
 	glShaderSource(sdr, 1, &sdr_src, 0);
 	glCompileShader(sdr);
@@ -161,19 +192,23 @@
 	if((loc = glGetUniformLocation(sdrprog, "tex")) != -1) {
 		glUniform1i(loc, 0);
 	}
-	if((loc = glGetUniformLocation(sdrprog, "lens_center")) != -1) {
-		glUniform2f(loc, 0.5, 0.5);
+	if((loc = glGetUniformLocation(sdrprog, "lens_center_offset")) != -1) {
+		glUniform1f(loc, 0);
 	}
 	if((loc = glGetUniformLocation(sdrprog, "scr_center")) != -1) {
 		glUniform2f(loc, 0, 0);
 	}
 	if((loc = glGetUniformLocation(sdrprog, "scale")) != -1) {
-		glUniform2f(loc, 1, 1);
+		glUniform1f(loc, vr_ctx.info.scale);
+	}
+	if((loc = glGetUniformLocation(sdrprog, "aspect")) != -1) {
+		printf("setting aspect: %f\n", vr_ctx.info.aspect / 2.0);
+		glUniform1f(loc, vr_ctx.info.aspect / 2.0);
 	}
 	if((loc = glGetUniformLocation(sdrprog, "scale_in")) != -1) {
 		glUniform2f(loc, 1, 1);
 	}
-	if((loc = glGetUniformLocation(sdrprog, "warp_param")) != -1) {
+	if((loc = glGetUniformLocation(sdrprog, "dist_factors")) != -1) {
 		glUniform4f(loc, vr_ctx.info.distort[0], vr_ctx.info.distort[1],
 				vr_ctx.info.distort[2], vr_ctx.info.distort[3]);
 	}
@@ -231,6 +266,21 @@
 	return vr_ctx.ovr_sfusion.GetPredictionDelta();
 }
 
+extern "C" void vr_get_view_matrix(float *res, int eye)
+{
+	// TODO
+}
+
+extern "C" void vr_get_proj_matrix(float *res, int eye)
+{
+	static float eye_scale[] = {0.0, 1.0, -1.0};
+
+	Matrix4f proj = Matrix4f::PerspectiveRH(vr_ctx.info.fov, vr_ctx.info.aspect / 2.0, 0.3, 1000.0);
+	proj = Matrix4f::Translation(vr_ctx.info.proj_center_offset * eye_scale[eye], 0, 0) * proj;
+
+	memcpy(res, proj.M[0], 16 * sizeof(float));
+}
+
 extern "C" void vr_get_translation(float *offs)
 {
 	// current oculus devkit doesn't do translation
@@ -276,11 +326,12 @@
 
 	glUseProgram(sdrprog);
 
-	int loc;
-	if((loc = glGetUniformLocation(sdrprog, "lens_center")) != -1) {
-		float lens_center = 0.5 - vr_ctx.info.lens_center * offs_scale[eye];
-		glUniform2f(loc, lens_center, 0.5);
-		printf("lens_center = %f\n", lens_center);
+	if(sdrprog) {
+		int loc;
+		if((loc = glGetUniformLocation(sdrprog, "lens_center_offset")) != -1) {
+			float offset = vr_ctx.info.lens_center_offset * offs_scale[eye];
+			glUniform1f(loc, offset);
+		}
 	}
 
 	glBindTexture(GL_TEXTURE_2D, tex);
diff -r d797639e0234 -r 464e1d135d68 src/vr_impl.h
--- a/src/vr_impl.h	Fri Sep 20 10:14:29 2013 +0300
+++ b/src/vr_impl.h	Sat Sep 21 03:00:47 2013 +0300
@@ -20,7 +20,9 @@
 		float ipd;
 		float distort[4];
 		// the right lens center offset (negate for left)
-		float lens_center;
+		float lens_center_offset;
+		float proj_center_offset;
+		float scale;	// scaling to be applied to the two views to fill the screen
 	} info;
 };