From 407b5071a1c44ceb0de055e1ef8b3d15ab6d2fe7 Mon Sep 17 00:00:00 2001
From: angel <sayangel@gmail.com>
Date: Mon, 9 Jun 2014 17:52:10 -0400
Subject: [PATCH 1/2] added oculus rendering and first person controls

---
 Gruntfile.js                          |   4 +-
 examples/index.html                   |   7 +-
 src/client/controls/Controls.js       |  29 +++-
 src/client/controls/Keyboard.js       |  18 ++-
 src/client/webgl/Camera.js            |  76 ++++++++-
 src/client/webgl/Renderer.js          |  14 +-
 src/shared/vendor/OculusBridge.js     | 222 ++++++++++++++++++++++++++
 src/shared/vendor/three/RiftCamera.js | 204 +++++++++++++++++++++++
 8 files changed, 560 insertions(+), 14 deletions(-)
 create mode 100755 src/shared/vendor/OculusBridge.js
 create mode 100755 src/shared/vendor/three/RiftCamera.js

diff --git a/Gruntfile.js b/Gruntfile.js
index d6167ed..9e7a92b 100644
--- a/Gruntfile.js
+++ b/Gruntfile.js
@@ -25,6 +25,8 @@ module.exports = function(grunt) {
 					'src/shared/vendor/q.js',
 					'src/shared/vendor/three/three.js',
 					'src/shared/vendor/three/ColorConverter.js',
+					'src/shared/vendor/three/RiftCamera.js',
+					'src/shared/vendor/OculusBridge.js',
 					'src/shared/vendor/d3.js',
 					'src/shared/vendor/catiline.js',
 					'src/shared/vendor/dat.gui.js',
@@ -158,6 +160,6 @@ module.exports = function(grunt) {
 
 	// Run tests
 	grunt.registerTask('test', ['jshint', 'mocha_phantomjs']);
-	
+
 	grunt.task.run('notify_hooks');
 };
diff --git a/examples/index.html b/examples/index.html
index c1eaf42..2c93679 100644
--- a/examples/index.html
+++ b/examples/index.html
@@ -8,7 +8,7 @@
 	<link href="reset.css" rel="stylesheet" type="text/css">
 
 	<link href="../css/loading.css" rel="stylesheet" type="text/css">
-	
+
 	<style type="text/css">
 		html, body {
 			height: 100%;
@@ -31,6 +31,9 @@
 		VIZI.ENABLE_OUTLINES = false;
 		VIZI.ENABLE_ROADS = true;
 
+		//toggle oculus rendering
+		VIZI.ENABLE_OCULUS = true;
+
 		var city = new VIZI.City();
 		city.init({
 			coords: [-0.01924, 51.50358], // Canary Wharf
@@ -39,4 +42,4 @@
 	</script>
 
 </body>
-</html>
\ No newline at end of file
+</html>
diff --git a/src/client/controls/Controls.js b/src/client/controls/Controls.js
index b928aca..cb6ecb9 100644
--- a/src/client/controls/Controls.js
+++ b/src/client/controls/Controls.js
@@ -1,4 +1,4 @@
-/* globals window, _, Q, VIZI */
+/* globals window, _, Q, VIZI, OculusBridge */
 (function() {
 	"use strict";
 
@@ -12,12 +12,20 @@
 
 			this.mouse = undefined;
 			this.keyboard = undefined;
+			this.bridge = undefined;
 		};
 
 		Controls.prototype.init = function(camera, options) {
 			if (options.enable) {
 				this.mouse = VIZI.Mouse.getInstance(camera);
 				this.keyboard = VIZI.Keyboard.getInstance();
+				if(VIZI.ENABLE_OCULUS){
+						VIZI.Log("Connecting to Oculus Bridge");
+						this.bridge = new OculusBridge(
+							{"debug":false}
+						);
+						this.bridge.connect();
+				}
 
 				this.subscribe("update", this.onUpdate);
 				this.subscribe("orbitControlCap", this.orbitCapReset);
@@ -46,6 +54,19 @@
 				this.publish("orbitControl", mouseState.downPos2dDelta, mouseState.camera.startTheta, mouseState.camera.startPhi);
 			}
 
+			// Oculus
+			if(VIZI.ENABLE_OCULUS){
+				//get quaternion values from oculus bridge
+				var quat = this.bridge.getOrientation();
+				this.publish("oculusControl", quat);
+			}
+
+			// First Person
+			if(keyboardState.keys.up || keyboardState.keys.down || keyboardState.keys.left || keyboardState.keys.right)
+			{
+				this.publish("firstPersonControl", keyboardState.keys);
+			}
+
 			// Zero deltas
 			this.mouse.resetDelta();
 		};
@@ -57,10 +78,10 @@
 		var instance;
 
 		// an emulation of static variables and methods
-		var _static = {   
+		var _static = {
 			name: "VIZI.Controls",
 
-			// Method for getting an instance. It returns 
+			// Method for getting an instance. It returns
 			// a singleton instance of a singleton object
 			getInstance: function() {
 				if ( instance  ===  undefined )  {
@@ -73,4 +94,4 @@
 
 		return _static;
 	}());
-}());
\ No newline at end of file
+}());
diff --git a/src/client/controls/Keyboard.js b/src/client/controls/Keyboard.js
index 74562dc..4b3089b 100644
--- a/src/client/controls/Keyboard.js
+++ b/src/client/controls/Keyboard.js
@@ -54,6 +54,18 @@
 				case 16:
 					key = "shift";
 					break;
+				case 38:
+					key = "up";
+					break;
+				case 40:
+					key = "down";
+					break;
+				case 37:
+					key = "left";
+					break;
+				case 39:
+					key = "right";
+					break;
 				default:
 					key = false;
 			}
@@ -64,10 +76,10 @@
 		var instance;
 
 		// an emulation of static variables and methods
-		var _static = {   
+		var _static = {
 			name: "VIZI.Keyboard",
 
-			// Method for getting an instance. It returns 
+			// Method for getting an instance. It returns
 			// a singleton instance of a singleton object
 			getInstance: function() {
 				if ( instance  ===  undefined )  {
@@ -80,4 +92,4 @@
 
 		return _static;
 	}());
-}());
\ No newline at end of file
+}());
diff --git a/src/client/webgl/Camera.js b/src/client/webgl/Camera.js
index 32e45d5..bc3a30f 100644
--- a/src/client/webgl/Camera.js
+++ b/src/client/webgl/Camera.js
@@ -20,6 +20,11 @@
 		this.camera = this.createCamera();
 		this.lookAtTarget();
 
+		//set up variables for oculus rendering
+		this.viewAngle = 0;
+		this.bodyAxis = new THREE.Vector3(0, 1, 0);
+		this.bodyAngle = 0;
+
 		this.publish("addToScene", this.camera);
 		this.publish("addToDat", this, {name: "Camera", properties: ["cameraRadius", "theta", "phi"]});
 
@@ -27,6 +32,11 @@
 		this.subscribe("zoomControl", this.zoom);
 		this.subscribe("panControl", this.pan);
 		this.subscribe("orbitControl", this.orbit);
+		if(VIZI.ENABLE_OCULUS)
+		{
+			this.subscribe("oculusControl", this.oculus);
+			this.subscribe("firstPersonControl", this.firstPerson);
+		}
 	};
 
 	VIZI.Camera.prototype.createCamera = function() {
@@ -73,6 +83,11 @@
 		if (this.capZoom) {
 		// Cap zoom to bounds
 			var zoomCapLow = 250;
+			//if the oculus is enabled allow users to zoom in to street level
+			if(VIZI.ENABLE_OCULUS){
+				zoomCapLow = 10;
+			}
+
 			if (this.cameraRadius < zoomCapLow) {
 				this.cameraRadius = zoomCapLow;
 				cameraRadiusDiff = zoomCapLow - oldcameraRadius;
@@ -84,7 +99,7 @@
 				cameraRadiusDiff = zoomCapHigh - oldcameraRadius;
 			}
 		}
-		
+
 		this.camera.translateZ( cameraRadiusDiff );
 
 		this.updatePosition();
@@ -132,8 +147,65 @@
 		this.publish("render");
 	};
 
+	VIZI.Camera.prototype.oculus = function(quatValues) {
+		// make a quaternion for the the body angle rotated about the Y axis.
+		var quat = new THREE.Quaternion();
+		quat.setFromAxisAngle(this.bodyAxis, this.bodyAngle);
+
+		// make a quaternion for the current orientation of the Rift
+		var quatCam = new THREE.Quaternion(quatValues.x, quatValues.y, quatValues.z, quatValues.w);
+
+		// multiply the body rotation by the Rift rotation.
+		quat.multiply(quatCam);
+
+		// Make a vector pointing along the Z axis and rotate it accoring to the combined look/body angle.
+		var xzVector = new THREE.Vector3(0, 0, 1);
+		xzVector.applyQuaternion(quat);
+
+		// Compute the X/Z angle based on the combined look/body angle.  This will be used for FPS style movement controls
+		// so you can steer with a combination of the keyboard and by moving your head.
+		this.viewAngle = Math.atan2(xzVector.z, xzVector.x) + Math.PI;
+
+		// Apply the combined look/body angle to the camera.
+		this.camera.quaternion.copy(quat);
+
+		//this.updatePosition();
+		//this.lookAtTarget();
+
+		this.publish("render");
+	};
+
+	VIZI.Camera.prototype.firstPerson = function(keys) {
+		//movement step
+		var step = 10;
+
+		//move in the requested direction(s), base movement on view angle
+		if(keys.up){
+			this.target.position.x += Math.cos(this.viewAngle) * step;
+			this.target.position.z += Math.sin(this.viewAngle) * step;
+		}
+
+		if(keys.down){
+			this.target.position.x -= Math.cos(this.viewAngle) * step;
+			this.target.position.z -= Math.sin(this.viewAngle) * step;
+		}
+
+		if(keys.left){
+			this.target.position.x -= Math.cos(this.viewAngle + Math.PI/2) * step;
+      this.target.position.z -= Math.sin(this.viewAngle + Math.PI/2) * step;
+		}
+
+		if(keys.right){
+			this.target.position.x += Math.cos(this.viewAngle + Math.PI/2) * step;
+      this.target.position.z += Math.sin(this.viewAngle + Math.PI/2) * step;
+		}
+
+		this.updatePosition();
+		this.publish("render");
+	};
+
 	VIZI.Camera.prototype.datChange = function() {
 		this.updatePosition();
 		this.lookAtTarget();
 	};
-}());
\ No newline at end of file
+}());
diff --git a/src/client/webgl/Renderer.js b/src/client/webgl/Renderer.js
index 33ecee1..171fad4 100644
--- a/src/client/webgl/Renderer.js
+++ b/src/client/webgl/Renderer.js
@@ -13,6 +13,11 @@
 
 		this.renderer = this.createRenderer();
 
+		//oculus renderer
+		if(VIZI.ENABLE_OCULUS){
+			this.riftCam = new THREE.OculusRiftEffect(this.renderer);
+		}
+
 		// Listeners
 		this.subscribe("render", this.render);
 		this.subscribe("resize", this.resize);
@@ -42,7 +47,12 @@
 
 	VIZI.Renderer.prototype.render = function() {
 		this.publish("fpsTickStart", "render");
-		this.renderer.render( this.scene, this.camera );
+		if(VIZI.ENABLE_OCULUS){
+			this.riftCam.render(this.scene, this.camera );
+		}
+		else{
+			this.renderer.render( this.scene, this.camera );
+		}
 		this.publish("updateRendererInfo", this.renderer.info);
 		this.publish("fpsTickEnd", "render");
 	};
@@ -50,4 +60,4 @@
 	VIZI.Renderer.prototype.resize = function() {
 		this.renderer.setSize( window.innerWidth, window.innerHeight );
 	};
-}());
\ No newline at end of file
+}());
diff --git a/src/shared/vendor/OculusBridge.js b/src/shared/vendor/OculusBridge.js
new file mode 100755
index 0000000..043e651
--- /dev/null
+++ b/src/shared/vendor/OculusBridge.js
@@ -0,0 +1,222 @@
+var OculusBridge = function(config) {
+
+	// ye olde websocket
+	var socket;
+
+	var reconnectTimeout 	= null;
+	var retryOnDisconnect 	= true;
+	var websocketAddress 	= config.hasOwnProperty("address") 			? config["address"] 		: "localhost";
+	var websocketPort 		= config.hasOwnProperty("port") 			? config["port"] 			: 9005;
+	var retryInterval 		= config.hasOwnProperty("retryInterval") 	? config["retryInterval"] 	: 1;
+	var debugEnabled		= config.hasOwnProperty("debug") 			? config["debug"] 			: false;
+
+	// Quaternion values
+	var quaternionValues = {
+		x : 0,
+		y : 0,
+		z : 0,
+		w : 0
+	};
+
+	// Accelerometer readings
+	var accelerationValues = {
+		x : 0,
+		y : 0,
+		z : 0
+	};
+
+	// Display metrics, set to defaults from the dev kit hardware
+	var displayMetrics = {
+		FOV 					: 125.871,
+
+		hScreenSize				: 0.14976,
+		vScreenSize				: 0.0935,
+		vScreenCenter			: 0.0935 / 2,
+
+		eyeToScreenDistance		: 0.041,
+
+		lensSeparationDistance	: 0.067,
+		interpupillaryDistance	: 0.0675,
+
+		hResolution				: 1280,
+		vResolution				: 720,
+
+		distortionK				: [1, .22, .24, 0],
+		chromaAbParameter		: [0.996, -0.004, 1.014, 0]
+	}
+
+	// Callback handlers.
+	var callbacks = {
+		onOrientationUpdate : null,
+		onAccelerationUpdate: null,
+		onConfigUpdate : null,
+		onConnect : null,
+		onDisconnect : null
+	};
+
+	// hook up any callbacks specified in the config object
+	for(var cb in callbacks){
+		if(typeof(config[cb]) == "function"){
+			callbacks[cb] = config[cb];
+		}
+	}
+
+	var updateOrientation = function(data) {
+
+		if(data["o"] && (data["o"].length == 4)) {
+
+			quaternionValues.x = Number(data["o"][1]);
+			quaternionValues.y = Number(data["o"][2]);
+			quaternionValues.z = Number(data["o"][3]);
+			quaternionValues.w = Number(data["o"][0]);
+
+			if(callbacks["onOrientationUpdate"]) {
+				callbacks["onOrientationUpdate"](quaternionValues);
+			}
+		}
+	}
+
+	var updateAcceleration = function(data) {
+
+		if(data["a"] && (data["a"].length == 3)) {
+
+			accelerationValues.x = Number(data["a"][0]);
+			accelerationValues.y = Number(data["a"][1]);
+			accelerationValues.z = Number(data["a"][2]);
+
+			if(callbacks["onAccelerationUpdate"]) {
+				callbacks["onAccelerationUpdate"](accelerationValues);
+			}
+		}
+	}
+
+	var updateConfig = function(data) {
+		displayMetrics.hScreenSize				= data["screenSize"][0];
+		displayMetrics.vScreenSize				= data["screenSize"][1];
+		displayMetrics.vScreenCenter			= data["screenSize"][1] / 2;
+
+		displayMetrics.eyeToScreenDistance		= data["eyeToScreen"];
+
+		displayMetrics.lensSeparationDistance	= data["lensDistance"];
+		displayMetrics.interpupillaryDistance	= data["interpupillaryDistance"];
+
+		displayMetrics.hResolution				= data["screenResolution"][0];
+		displayMetrics.vResolution				= data["screenResolution"][1];
+
+		displayMetrics.distortionK				= [ data["distortion"][0], data["distortion"][1], data["distortion"][2], data["distortion"][3] ];
+
+		displayMetrics.FOV						= data["fov"];
+
+		if(callbacks["onConfigUpdate"]) {
+			callbacks["onConfigUpdate"]( displayMetrics );
+		}
+	}
+
+
+	var connect = function() {
+
+		retryOnDisconnect = true;
+
+		var socketURL = "ws://" + websocketAddress + ":" + websocketPort + "/";
+
+		// attempt to open the socket connection
+	 	socket = new WebSocket(socketURL);
+
+		debug("Attempting to connect: " + socketURL);
+
+
+	 	// hook up websocket events //
+
+		socket.onopen = function(){
+			debug("Connected!")
+
+			if(callbacks["onConnect"]) {
+				callbacks["onConnect"]();
+			}
+		}
+
+		socket.onerror = function(e){
+			debug("Socket error.");
+		}
+
+		socket.onmessage = function(msg) {
+
+			var data = JSON.parse( msg.data );
+
+			var message = data["m"];
+
+			switch(message){
+				case "config" :
+					updateConfig(data);
+				break;
+
+				// For backwards compatability with the bridge application.
+				case "orientation":
+					updateOrientation(data);
+				break;
+
+				case "update":
+					updateOrientation(data);
+					updateAcceleration(data);
+				break;
+
+				default:
+					debug("Unknown message received from server: " + msg.data);
+					disconnect();
+				break;
+			}
+
+		}
+
+		socket.onclose = function() {
+			if(callbacks["onDisconnect"]) {
+				callbacks["onDisconnect"]();
+			}
+
+			if(retryOnDisconnect){
+				debug("Connection failed, retrying in 1 second...");
+				reconnectTimeout = window.setTimeout( reconnect, retryInterval * 1000 );
+			}
+		}
+	}
+
+	var debug = function(message){
+		if(debugEnabled){
+			console.log("OculusBridge: " + message);
+		}
+	}
+
+	var reconnect = function(){
+		connect();
+	}
+
+	var disconnect = function(){
+		retryOnDisconnect = false;
+		window.clearTimeout(reconnectTimeout);
+		socket.close();
+	}
+
+	var getConfiguration = function(){
+		return displayMetrics;
+	}
+
+	var getOrientation = function(){
+		return quaternionValues;
+	}
+
+	var getAcceleration = function(){
+		return accelerationValues;
+	}
+
+	var isConnected = function(){
+		return socket.readyState == 1;
+	}
+
+	return {
+		"isConnected" 		: isConnected,
+		"disconnect" 		: disconnect,
+		"connect" 			: connect,
+		"getOrientation" 	: getOrientation,
+		"getConfiguration" 	: getConfiguration
+	}
+};
diff --git a/src/shared/vendor/three/RiftCamera.js b/src/shared/vendor/three/RiftCamera.js
new file mode 100755
index 0000000..81fd7a8
--- /dev/null
+++ b/src/shared/vendor/three/RiftCamera.js
@@ -0,0 +1,204 @@
+/**
+ * @author troffmo5 / http://github.com/troffmo5
+ *
+ * Effect to render the scene in stereo 3d side by side with lens distortion.
+ * It is written to be used with the Oculus Rift (http://www.oculusvr.com/) but
+ * it works also with other HMD using the same technology
+ */
+
+THREE.OculusRiftEffect = function ( renderer, options ) {
+	// worldFactor indicates how many units is 1 meter
+	var worldFactor = (options && options.worldFactor) ? options.worldFactor: 1.0;
+
+	// Specific HMD parameters
+	var HMD = (options && options.HMD) ? options.HMD: {
+		// Parameters from the Oculus Rift DK1
+		hResolution: 1280,
+		vResolution: 720,
+		hScreenSize: 0.14976,
+		vScreenSize: 0.0935,
+		interpupillaryDistance: 0.064,
+		lensSeparationDistance: 0.0635,
+		eyeToScreenDistance: 0.041,
+		distortionK : [1.0, 0.22, 0.24, 0.0],
+		chromaAbParameter : [0.996, -0.004, 1.014, 0]
+	};
+
+	// Perspective camera
+	var pCamera = new THREE.PerspectiveCamera();
+	pCamera.matrixAutoUpdate = false;
+	pCamera.target = new THREE.Vector3();
+
+	// Orthographic camera
+	var oCamera = new THREE.OrthographicCamera( -1, 1, 1, -1, 0.0001, 100000 );
+	oCamera.position.z = 1;
+
+	// pre-render hooks
+	this.preLeftRender = function() {};
+	this.preRightRender = function() {};
+
+	//renderer.autoClear = false;
+	var emptyColor = new THREE.Color("black");
+
+	// Render target
+	var RTParams = { minFilter: THREE.LinearFilter, magFilter: THREE.NearestFilter, format: THREE.RGBAFormat };
+	var renderTarget = new THREE.WebGLRenderTarget( 640, 800, RTParams );
+	var RTMaterial = new THREE.ShaderMaterial( {
+		uniforms: {
+			"texid": { type: "t", value: renderTarget },
+			"scale": { type: "v2", value: new THREE.Vector2(1.0,1.0) },
+			"scaleIn": { type: "v2", value: new THREE.Vector2(1.0,1.0) },
+			"lensCenter": { type: "v2", value: new THREE.Vector2(0.0,0.0) },
+			"hmdWarpParam": { type: "v4", value: new THREE.Vector4(1.0,0.0,0.0,0.0) },
+			"chromAbParam": { type: "v4", value: new THREE.Vector4(1.0,0.0,0.0,0.0) }
+		},
+		vertexShader: [
+			"varying vec2 vUv;",
+			"void main() {",
+			" vUv = uv;",
+			"	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+			"}"
+		].join("\n"),
+
+		fragmentShader: [
+			"uniform vec2 scale;",
+			"uniform vec2 scaleIn;",
+			"uniform vec2 lensCenter;",
+			"uniform vec4 hmdWarpParam;",
+			'uniform vec4 chromAbParam;',
+			"uniform sampler2D texid;",
+			"varying vec2 vUv;",
+			"void main()",
+			"{",
+			"  vec2 uv = (vUv*2.0)-1.0;", // range from [0,1] to [-1,1]
+			"  vec2 theta = (uv-lensCenter)*scaleIn;",
+			"  float rSq = theta.x*theta.x + theta.y*theta.y;",
+			"  vec2 rvector = theta*(hmdWarpParam.x + hmdWarpParam.y*rSq + hmdWarpParam.z*rSq*rSq + hmdWarpParam.w*rSq*rSq*rSq);",
+			'  vec2 rBlue = rvector * (chromAbParam.z + chromAbParam.w * rSq);',
+			"  vec2 tcBlue = (lensCenter + scale * rBlue);",
+			"  tcBlue = (tcBlue+1.0)/2.0;", // range from [-1,1] to [0,1]
+			"  if (any(bvec2(clamp(tcBlue, vec2(0.0,0.0), vec2(1.0,1.0))-tcBlue))) {",
+			"    gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);",
+			"    return;}",
+			"  vec2 tcGreen = lensCenter + scale * rvector;",
+			"  tcGreen = (tcGreen+1.0)/2.0;", // range from [-1,1] to [0,1]
+			"  vec2 rRed = rvector * (chromAbParam.x + chromAbParam.y * rSq);",
+			"  vec2 tcRed = lensCenter + scale * rRed;",
+			"  tcRed = (tcRed+1.0)/2.0;", // range from [-1,1] to [0,1]
+			"  gl_FragColor = vec4(texture2D(texid, tcRed).r, texture2D(texid, tcGreen).g, texture2D(texid, tcBlue).b, 1);",
+			"}"
+		].join("\n")
+	} );
+
+	var mesh = new THREE.Mesh( new THREE.PlaneGeometry( 2, 2 ), RTMaterial );
+
+	// Final scene
+	var finalScene = new THREE.Scene();
+	finalScene.add( oCamera );
+	finalScene.add( mesh );
+
+    var left = {}, right = {};
+    var distScale = 1.0;
+	this.setHMD = function(v) {
+		HMD = v;
+		// Compute aspect ratio and FOV
+		var aspect = HMD.hResolution / (2*HMD.vResolution);
+
+		// Fov is normally computed with:
+		//   THREE.Math.radToDeg( 2*Math.atan2(HMD.vScreenSize,2*HMD.eyeToScreenDistance) );
+		// But with lens distortion it is increased (see Oculus SDK Documentation)
+		var r = -1.0 - (4 * (HMD.hScreenSize/4 - HMD.lensSeparationDistance/2) / HMD.hScreenSize);
+		distScale = (HMD.distortionK[0] + HMD.distortionK[1] * Math.pow(r,2) + HMD.distortionK[2] * Math.pow(r,4) + HMD.distortionK[3] * Math.pow(r,6));
+		var fov = HMD.fov ? HMD.fov : THREE.Math.radToDeg(2*Math.atan2(HMD.vScreenSize*distScale, 2*HMD.eyeToScreenDistance));
+
+		// Compute camera projection matrices
+		var proj = (new THREE.Matrix4()).makePerspective( fov, aspect, 0.3, 10000 );
+		var h = 4 * (HMD.hScreenSize/4 - HMD.interpupillaryDistance/2) / HMD.hScreenSize;
+		left.proj = ((new THREE.Matrix4()).makeTranslation( h, 0.0, 0.0 )).multiply(proj);
+		right.proj = ((new THREE.Matrix4()).makeTranslation( -h, 0.0, 0.0 )).multiply(proj);
+
+		// Compute camera transformation matrices
+		left.tranform = (new THREE.Matrix4()).makeTranslation( -worldFactor * HMD.interpupillaryDistance/2, 0.0, 0.0 );
+		right.tranform = (new THREE.Matrix4()).makeTranslation( worldFactor * HMD.interpupillaryDistance/2, 0.0, 0.0 );
+
+		// Compute Viewport
+		left.viewport = [0, 0, HMD.hResolution/2, HMD.vResolution];
+		right.viewport = [HMD.hResolution/2, 0, HMD.hResolution/2, HMD.vResolution];
+
+		// Distortion shader parameters
+		var lensShift = 4 * (HMD.hScreenSize/4 - HMD.lensSeparationDistance/2) / HMD.hScreenSize;
+		left.lensCenter = new THREE.Vector2(lensShift, 0.0);
+		right.lensCenter = new THREE.Vector2(-lensShift, 0.0);
+
+		RTMaterial.uniforms['hmdWarpParam'].value = new THREE.Vector4(HMD.distortionK[0], HMD.distortionK[1], HMD.distortionK[2], HMD.distortionK[3]);
+		RTMaterial.uniforms['chromAbParam'].value = new THREE.Vector4(HMD.chromaAbParameter[0], HMD.chromaAbParameter[1], HMD.chromaAbParameter[2], HMD.chromaAbParameter[3]);
+		RTMaterial.uniforms['scaleIn'].value = new THREE.Vector2(1.0,1.0/aspect);
+		RTMaterial.uniforms['scale'].value = new THREE.Vector2(1.0/distScale, 1.0*aspect/distScale);
+		console.log(lensShift);
+		console.log("ScaleIn",  new THREE.Vector2(1.0,1.0/aspect));
+		console.log("Scale",  new THREE.Vector2(1.0,1.0/aspect));
+
+		// Create render target
+		renderTarget = new THREE.WebGLRenderTarget( HMD.hResolution*distScale/2, HMD.vResolution*distScale, RTParams );
+		RTMaterial.uniforms[ "texid" ].value = renderTarget;
+
+	}
+	this.getHMD = function() {return HMD};
+
+	this.setHMD(HMD);
+
+	this.setSize = function ( width, height ) {
+		left.viewport = [width/2 - HMD.hResolution/2, height/2 - HMD.vResolution/2, HMD.hResolution/2, HMD.vResolution];
+		right.viewport = [width/2, height/2 - HMD.vResolution/2, HMD.hResolution/2, HMD.vResolution];
+
+		renderer.setSize( width, height );
+	};
+
+	this.render = function ( scene, camera ) {
+		var cc = renderer.getClearColor().clone();
+		var autoClear = renderer.autoClear;
+
+		renderer.autoClear = false;
+
+		// Clear
+		renderer.setClearColor(emptyColor);
+		renderer.clear();
+		renderer.setClearColor(cc);
+
+		// camera parameters
+		if (camera.matrixAutoUpdate) camera.updateMatrix();
+
+		// Render left
+		this.preLeftRender();
+
+		pCamera.projectionMatrix.copy(left.proj);
+
+		pCamera.matrix.copy(camera.matrix).multiply(left.tranform);
+		pCamera.matrixWorldNeedsUpdate = true;
+
+		renderer.setViewport(left.viewport[0], left.viewport[1], left.viewport[2], left.viewport[3]);
+
+		RTMaterial.uniforms['lensCenter'].value = left.lensCenter;
+		renderer.render( scene, pCamera, renderTarget, true );
+
+		renderer.render( finalScene, oCamera );
+
+		// Render right
+		this.preRightRender();
+
+		pCamera.projectionMatrix.copy(right.proj);
+
+		pCamera.matrix.copy(camera.matrix).multiply(right.tranform);
+		pCamera.matrixWorldNeedsUpdate = true;
+
+		renderer.setViewport(right.viewport[0], right.viewport[1], right.viewport[2], right.viewport[3]);
+
+		RTMaterial.uniforms['lensCenter'].value = right.lensCenter;
+
+		renderer.render( scene, pCamera, renderTarget, true );
+		renderer.render( finalScene, oCamera );
+
+		renderer.autoClear = autoClear;
+	};
+
+};

From 81da4ed93fc7ea14d9afea8ab09376ab46febb38 Mon Sep 17 00:00:00 2001
From: angel <sayangel@gmail.com>
Date: Mon, 9 Jun 2014 18:08:53 -0400
Subject: [PATCH 2/2] updated oculus enabled to false.. makes more sense

---
 examples/index.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/index.html b/examples/index.html
index 2c93679..4dc9a77 100644
--- a/examples/index.html
+++ b/examples/index.html
@@ -32,7 +32,7 @@
 		VIZI.ENABLE_ROADS = true;
 
 		//toggle oculus rendering
-		VIZI.ENABLE_OCULUS = true;
+		VIZI.ENABLE_OCULUS = false;
 
 		var city = new VIZI.City();
 		city.init({