elation-engine 0.9.113 → 0.9.115

package/scripts/external/three-old/render/MaskPass.js

@@ -0,0 +1,97 @@
+/**
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.MaskPass = function ( scene, camera ) {
+
+	THREE.Pass.call( this );
+
+	this.scene = scene;
+	this.camera = camera;
+
+	this.clear = true;
+	this.needsSwap = false;
+
+	this.inverse = false;
+
+};
+
+THREE.MaskPass.prototype = Object.assign( Object.create( THREE.Pass.prototype ), {
+
+	constructor: THREE.MaskPass,
+
+	render: function ( renderer, writeBuffer, readBuffer, delta, maskActive ) {
+
+		var context = renderer.context;
+		var state = renderer.state;
+
+		// don't update color or depth
+
+		state.buffers.color.setMask( false );
+		state.buffers.depth.setMask( false );
+
+		// lock buffers
+
+		state.buffers.color.setLocked( true );
+		state.buffers.depth.setLocked( true );
+
+		// set up stencil
+
+		var writeValue, clearValue;
+
+		if ( this.inverse ) {
+
+			writeValue = 0;
+			clearValue = 1;
+
+		} else {
+
+			writeValue = 1;
+			clearValue = 0;
+
+		}
+
+		state.buffers.stencil.setTest( true );
+		state.buffers.stencil.setOp( context.REPLACE, context.REPLACE, context.REPLACE );
+		state.buffers.stencil.setFunc( context.ALWAYS, writeValue, 0xffffffff );
+		state.buffers.stencil.setClear( clearValue );
+
+		// draw into the stencil buffer
+
+		renderer.render( this.scene, this.camera, readBuffer, this.clear );
+		renderer.render( this.scene, this.camera, writeBuffer, this.clear );
+
+		// unlock color and depth buffer for subsequent rendering
+
+		state.buffers.color.setLocked( false );
+		state.buffers.depth.setLocked( false );
+
+		// only render where stencil is set to 1
+
+		state.buffers.stencil.setFunc( context.EQUAL, 1, 0xffffffff );  // draw if == 1
+		state.buffers.stencil.setOp( context.KEEP, context.KEEP, context.KEEP );
+
+	}
+
+} );
+
+
+THREE.ClearMaskPass = function () {
+
+	THREE.Pass.call( this );
+
+	this.needsSwap = false;
+
+};
+
+THREE.ClearMaskPass.prototype = Object.create( THREE.Pass.prototype );
+
+Object.assign( THREE.ClearMaskPass.prototype, {
+
+	render: function ( renderer, writeBuffer, readBuffer, delta, maskActive ) {
+
+		renderer.state.buffers.stencil.setTest( false );
+
+	}
+
+} );

package/scripts/external/three-old/render/OculusRenderPass.js

@@ -0,0 +1,84 @@
+/**
+ * @author jbaicoianu / http://baicoianu.com/
+ */
+
+THREE.OculusRenderPass = function ( scene, camera, overrideMaterial, clearColor, clearAlpha ) {
+
+	this.scene = scene;
+	this.camera = camera;
+
+	this.overrideMaterial = overrideMaterial;
+
+	this.clearColor = clearColor;
+	this.clearAlpha = ( clearAlpha !== undefined ) ? clearAlpha : 1;
+
+	this.oldClearColor = new THREE.Color();
+	this.oldClearAlpha = 1;
+
+  this.oculuseffect = false;
+
+	this.enabled = true;
+	this.clear = false;
+	this.needsSwap = false;
+
+  this.initOculus();
+
+};
+
+THREE.OculusRenderPass.prototype = {
+
+  initOculus: function() {
+    this.oculusparams = {};
+    //document.body.addEventListener('click', this.fullscreen.bind(this));
+  },
+  fullscreen: function() {
+    if (!this.isfullscreen) {
+      if (document.body.webkitRequestFullScreen) {
+        document.body.webkitRequestFullScreen(Element.ALLOW_KEYBOARD_INPUT);
+      } else if (document.body.mozRequestFullScreen) {
+        document.body.mozRequestFullScreen(Element.ALLOW_KEYBOARD_INPUT);
+      } else if (document.body.requestFullScreen) {
+        document.body.requestFullScreen(Element.ALLOW_KEYBOARD_INPUT);
+      }
+    }
+  },
+
+  setOculusParameters: function(params) {
+    this.oculusparams = params;
+  },
+
+	render: function ( renderer, writeBuffer, readBuffer, delta ) {
+
+    this.oculusparams.renderTarget = readBuffer;
+    if (!this.oculuseffect) {
+      this.oculuseffect = new THREE.OculusRiftEffect(renderer, this.oculusparams);
+    } else {
+      this.oculuseffect.setOutputTarget(readBuffer);
+    }
+		this.scene.overrideMaterial = this.overrideMaterial;
+
+		if ( this.clearColor ) {
+
+			this.oldClearColor.copy( renderer.getClearColor() );
+			this.oldClearAlpha = renderer.getClearAlpha();
+
+			renderer.setClearColor( this.clearColor, this.clearAlpha );
+
+		}
+
+		this.oculuseffect.render( this.scene, this.camera, readBuffer, this.clear );
+
+		if ( this.clearColor ) {
+
+			renderer.setClearColor( this.oldClearColor, this.oldClearAlpha );
+
+		}
+		renderer.setViewport(0, 0, window.innerWidth, window.innerHeight);
+
+		this.scene.overrideMaterial = null;
+
+		elation.events.fire({element: this, type: 'render'});
+	}
+
+};
+

package/scripts/external/three-old/render/OculusRiftEffect.js

@@ -0,0 +1,240 @@
+/**
+ * @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: window.innerWidth,
+		vResolution: window.innerHeight,
+		hScreenSize: 0.14976,
+		vScreenSize: 0.0936,
+		interpupillaryDistance: 0.064,
+		lensSeparationDistance: 0.064,
+		eyeToScreenDistance: 0.041,
+		distortionK : [1.0, 0.22, 0.24, 0.0],
+		chromaAbParameter: [ 0.996, -0.004, 1.014, 0.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, 1, 1000 );
+	oCamera.position.z = 1;
+
+	// pre-render hooks
+	this.preLeftRender = function() {};
+	this.preRightRender = function() {};
+
+  this.renderTarget = false;
+  this.outputTarget = false;
+
+	renderer.autoClear = false;
+	var emptyColor = new THREE.Color("black");
+
+  this.setRenderTarget = function( renderTarget ) {
+
+    this.renderTarget = renderTarget;
+		RTMaterial.uniforms[ "texid" ].value = renderTarget;
+
+  }
+  this.setOutputTarget = function( outputTarget ) {
+
+    this.outputTarget = outputTarget;
+
+  }
+
+
+	// Render target
+	var RTParams = { minFilter: THREE.LinearFilter, magFilter: THREE.NearestFilter, format: THREE.RGBAFormat };
+	//var renderTarget = new THREE.WebGLRenderTarget( HMD.hResolution / 2, HMD.vResolution, RTParams );
+	var RTMaterial = new THREE.ShaderMaterial( {
+		uniforms: {
+			"texid": { type: "t", value: this.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( 1, 2 ), RTMaterial );
+  mesh.position.x = -.5;
+
+	// 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 = THREE.Math.radToDeg(2*Math.atan2(HMD.vScreenSize*distScale, 2*HMD.eyeToScreenDistance));
+    //var fov = 94;
+    //var aspect = 47 / 53;
+
+		// Compute camera projection matrices
+		var proj = (new THREE.Matrix4()).makePerspective( fov, aspect, 0.1, 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);
+
+		// Create render target
+		if ( this.renderTarget ) this.renderTarget.dispose();
+		//renderTarget = new THREE.WebGLRenderTarget( HMD.hResolution*distScale/2, HMD.vResolution*distScale, RTParams );
+    this.setRenderTarget(new THREE.WebGLRenderTarget( HMD.hResolution*distScale/2, HMD.vResolution*distScale, RTParams ));
+    this.setOutputTarget(options && options.renderTarget ? options.renderTarget : null);
+
+	}	
+	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();
+
+		// Clear
+		//renderer.setClearColor(emptyColor);
+		//renderer.clear();
+		//renderer.setClearColor(cc);
+
+		// camera parameters
+		if (camera.matrixAutoUpdate) camera.updateMatrix();
+
+		// Render left
+		this.preLeftRender();
+    mesh.position.x = -.5;
+
+		pCamera.projectionMatrix.copy(left.proj);
+
+		pCamera.matrix.copy(camera.matrix).multiply(left.tranform);
+		pCamera.matrixWorldNeedsUpdate = true;
+
+		if (pCamera.parent && pCamera.parent != camera.parent) {
+			pCamera.parent.remove(pCamera);
+		}
+		if (camera.parent && camera.parent != pCamera.parent) {
+			camera.parent.add(pCamera);
+		}
+    pCamera.near = camera.near;
+    pCamera.far = camera.far;
+
+		renderer.setViewport(left.viewport[0], left.viewport[1], left.viewport[2], left.viewport[3]);
+
+		RTMaterial.uniforms['lensCenter'].value = left.lensCenter;
+		renderer.render( scene, pCamera, this.renderTarget, true );
+		renderer.render( finalScene, oCamera, this.outputTarget );
+
+		// Render right
+		this.preRightRender();
+    mesh.position.x = .5;
+
+		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, this.renderTarget, true );
+		renderer.render( finalScene, oCamera, this.outputTarget );
+
+		renderer.setViewport(left.viewport[0], left.viewport[1], left.viewport[2] * 2, left.viewport[3]);
+
+	};
+
+	this.dispose = function() {
+		if ( RTMaterial ) {
+			RTMaterial.dispose();
+		}
+		if ( this.renderTarget ) {
+			this.renderTarget.dispose();
+		}
+	};
+
+};

package/scripts/external/three-old/render/PortalRenderPass.js

@@ -0,0 +1,166 @@
+/**
+ * @author James Baicoianu
+ */
+
+THREE.PortalRenderPass = function ( camera ) {
+
+	THREE.Pass.call( this );
+
+  this.portals = [];
+  this.maincamera = camera;
+  this.clipscene = new THREE.Scene();
+  this.clipmesh = new THREE.Mesh();
+  this.clipmaterial = new THREE.MeshBasicMaterial({color: 0xff0000});
+  this.clipmesh.matrixAutoUpdate = false;
+  this.clipscene.add(this.clipmesh);
+
+	this.clear = false;
+	this.needsSwap = false;
+
+};
+
+THREE.PortalRenderPass.prototype = Object.assign( Object.create( THREE.Pass.prototype ), {
+
+	constructor: THREE.PortalRenderPass,
+
+	render: function ( renderer, writeBuffer, readBuffer, delta, maskActive ) {
+    this.drawPortals(renderer, this.portals, writeBuffer, readBuffer);
+    this.drawPortalsStencil(renderer, this.portals, writeBuffer, readBuffer);
+  },
+/*
+  drawPortal: function ( renderer, portal, writeBuffer, readBuffer ) {
+    this.drawPortalStencil(renderer, portal, writeBuffer, readBuffer);
+    this.drawPortalScene(renderer, portal, writeBuffer, readBuffer);
+  },
+*/
+
+  drawPortals: function(renderer, portals, writeBuffer, readBuffer) {
+    for (var i = 0; i < portals.length; i++) {
+      this.drawPortal(renderer, portals[i], writeBuffer, readBuffer);
+    }
+  },
+  drawPortalsStencil: function(renderer, portals, writeBuffer, readBuffer) {
+    var stencilscene = new THREE.Scene(); 
+		var context = renderer.context;
+		var state = renderer.state;
+    // Finally, we render the portal object into the depth buffer without touching the color buffer, to prevent what's behind it from being drawn
+		state.buffers.color.setLocked( false );
+		state.buffers.depth.setLocked( false );
+		state.buffers.stencil.setTest( false );
+		state.buffers.color.setMask( false );
+		state.buffers.depth.setMask( true );
+
+		state.buffers.color.setLocked( true );
+		state.buffers.depth.setLocked( true );
+		//state.buffers.depth.setClear(true);
+    renderer.clearDepth();
+    for (var i = 0; i < portals.length; i++) {
+      var portal = portals[i];
+
+      var mesh = this.clipmesh;
+      var portalmesh = portal.mesh;
+      mesh.geometry = portal.clipmesh.geometry;
+      mesh.material = new THREE.MeshBasicMaterial({color: 0xffffff * Math.random()});
+      mesh.matrix.copy(portal.mesh.matrixWorld);
+      mesh.matrixWorld.copy(portal.mesh.matrixWorld);
+/*
+      mesh.matrixAutoUpdate = false;
+      mesh.matrixWorld.copy(portals[i].clipmesh.matrixWorld);
+      stencilscene.add(mesh);
+*/
+      renderer.render( this.clipscene, portal.camera, readBuffer, this.clear );
+      renderer.render( this.clipscene, portal.camera, writeBuffer, this.clear );
+    }
+
+
+/*
+		var context = renderer.context;
+		var state = renderer.state;
+		state.buffers.stencil.setTest( false );
+		state.buffers.depth.setClear(true);
+		state.buffers.color.setMask( true );
+		state.buffers.depth.setMask( true );
+
+console.log('clip cover', stencilscene, this.maincamera);
+		state.buffers.stencil.setTest( false );
+		renderer.render( stencilscene, this.maincamera, writeBuffer, this.clear );
+
+		//state.buffers.depth.setClear(false);
+		state.buffers.color.setMask( true );
+		state.buffers.depth.setMask( true );
+*/
+  },
+
+  drawPortal: function ( renderer, portal, writeBuffer, readBuffer ) {
+		var context = renderer.context;
+		var state = renderer.state;
+
+    var mesh = this.clipmesh;
+    var portalmesh = portal.mesh;
+    mesh.geometry = portal.clipmesh.geometry;
+    mesh.material = this.clipmaterial;
+    mesh.matrix.copy(portal.mesh.matrixWorld);
+    mesh.matrixWorld.copy(portal.mesh.matrixWorld);
+
+		// set up stencil
+
+		var writeValue, clearValue;
+
+		if ( this.inverse ) {
+
+			writeValue = 0;
+			clearValue = 1;
+
+		} else {
+
+			writeValue = 1;
+			clearValue = 0;
+
+		}
+
+		// First, we draw the stencil pattern
+		state.buffers.color.setLocked( false );
+		state.buffers.depth.setLocked( false );
+		state.buffers.color.setMask( false );
+		state.buffers.depth.setMask( false );
+		state.buffers.stencil.setTest( true );
+		state.buffers.stencil.setFunc( context.NEVER, 0, 0xffffffff );  // draw if == 1
+		state.buffers.stencil.setOp( context.INCR, context.KEEP, context.KEEP );
+		state.buffers.color.setLocked( true );
+		state.buffers.depth.setLocked( true );
+		renderer.render( this.clipscene, portal.camera, readBuffer, this.clear );
+		renderer.render( this.clipscene, portal.camera, writeBuffer, this.clear );
+
+
+    // Next, we render the scene inside of the portal, clipped to the stencil we set above
+		state.buffers.color.setLocked( false );
+		state.buffers.depth.setLocked( false );
+		state.buffers.color.setMask( true );
+		state.buffers.depth.setMask( true );
+    
+		state.buffers.stencil.setFunc( context.EQUAL, 1, 0xffffffff );  // draw if == 1
+		state.buffers.stencil.setOp( context.KEEP, context.KEEP, context.KEEP );
+
+		state.buffers.color.setLocked( true );
+		state.buffers.depth.setLocked( true );
+		renderer.render( portal.scene, portal.camera, this.renderToScreen ? null : readBuffer, this.clear );
+
+/*
+    // Finally, we render the portal object into the depth buffer without touching the color buffer, to prevent what's behind it from being drawn
+		state.buffers.color.setLocked( false );
+		state.buffers.depth.setLocked( false );
+		state.buffers.stencil.setTest( false );
+		state.buffers.color.setMask( false );
+		state.buffers.depth.setMask( true );
+
+		state.buffers.color.setLocked( true );
+		state.buffers.depth.setLocked( true );
+		renderer.render( this.clipscene, portal.camera, readBuffer, this.clear );
+		renderer.render( this.clipscene, portal.camera, writeBuffer, this.clear );
+*/
+  },
+  drawPortalScene: function( renderer, portal, writeBuffer, readBuffer ) {
+
+  }
+} );
+