elation-engine 0.9.113 → 0.9.115

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

@@ -0,0 +1,208 @@
+/**
+ * @author James Baicoianu / http://www.baicoianu.com/
+ */
+
+
+var vertexShaderFlip = [
+     'varying vec2 vUv;',
+
+     'void main() {',
+
+     '  vUv = vec2( uv.x, 1.0 - uv.y );',
+     '  gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+
+     '}'
+].join('\n');
+
+THREE.RecordingPass = function ( ) {
+
+	if ( THREE.CopyShader === undefined )
+		console.error( "THREE.RecordingPass relies on THREE.CopyShader" );
+
+	var shader = THREE.CopyShader;
+
+	this.uniforms = THREE.UniformsUtils.clone( shader.uniforms );
+
+	this.material = new THREE.ShaderMaterial( {
+
+		uniforms: this.uniforms,
+		vertexShader: shader.vertexShader,
+		fragmentShader: shader.fragmentShader
+
+	} );
+	this.flipmaterial = new THREE.ShaderMaterial( {
+
+		uniforms: this.uniforms,
+		vertexShader: vertexShaderFlip,
+		fragmentShader: shader.fragmentShader
+
+	} );
+
+  var parameters = { minFilter: THREE.LinearFilter, magFilter: THREE.LinearFilter, format: THREE.RGBAFormat, stencilBuffer: false };
+  this.recordtarget = new THREE.WebGLRenderTarget(640, 480, parameters);
+  this.lastframe = false;
+
+  this.recording = true;
+
+	this.enabled = true;
+	this.renderToScreen = false;
+	this.needsSwap = true;
+
+  //this.ffmpeg = new FFMPEG({scriptbase: '/scripts/engine/external/ffmpeg/', useWorker: true, quality: 'veryfast'});
+
+
+};
+
+THREE.RecordingPass.prototype = {
+
+	render: function ( renderer, writeBuffer, readBuffer, delta ) {
+
+    this.renderer = renderer;
+		this.uniforms[ "tDiffuse" ].value = readBuffer;
+
+		THREE.EffectComposer.quad.material = this.material;
+
+		if ( this.renderToScreen ) {
+
+			renderer.render( THREE.EffectComposer.scene, THREE.EffectComposer.camera );
+
+		} else {
+
+			renderer.render( THREE.EffectComposer.scene, THREE.EffectComposer.camera, writeBuffer, false );
+
+		}
+    if (this.recording) {
+      this.lastframe = writeBuffer;
+    }
+
+	},
+
+  getCaptureData: function(width, height) {
+    var readBuffer = this.lastframe;
+    var imgdata = false;
+    if (readBuffer) {
+      var size = [readBuffer.width, readBuffer.height];
+      var target = this.recordtarget;
+      if (width && height) {
+        var scale = Math.min(width / size[0], height / size[1]);
+        size[0] = Math.floor(size[0] * scale);
+        size[1] = Math.floor(size[1] * scale);
+      }
+      if (target.width != size[0] || target.height != size[1]) {
+        target.setSize(size[0], size[1]);
+      }
+      this.uniforms[ "tDiffuse" ].value = readBuffer;
+      THREE.EffectComposer.quad.material = this.flipmaterial;
+      this.renderer.render( THREE.EffectComposer.scene, THREE.EffectComposer.camera, target, false );
+
+      var pixeldata = new Uint8Array(size[0] * size[1] * 4);
+      this.renderer.readRenderTargetPixels(target, 0, 0, size[0], size[1], pixeldata);
+      imgdata = new ImageData(new Uint8ClampedArray(pixeldata.buffer), size[0], size[1]);
+    }
+    return imgdata;
+  },
+  captureJPG: function(width, height) {
+    return new Promise(function(resolve, reject) {
+      var start = performance.now();
+      var imgdata = this.getCaptureData(width, height);
+      if (imgdata) {
+        this.encodeImage(imgdata.data, imgdata.width, imgdata.height, 'jpg').then(function(img) {
+          var end = performance.now();
+          resolve({image: img, time: end - start});
+        });
+      } else {
+        reject();
+      }
+    }.bind(this));
+  },
+  capturePNG: function(width, height) {
+    return new Promise(function(resolve, reject) {
+      var start = performance.now();
+      var imgdata = this.getCaptureData(width, height);
+      if (imgdata) {
+        this.encodeImage(imgdata.data, imgdata.width, imgdata.height, 'png').then(function(img) {
+          var end = performance.now();
+          resolve({image: img, time: end - start});
+        });
+      } else {
+        reject();
+      }
+    }.bind(this));
+  },
+  captureGIF: function(width, height, frames, delay) {
+    return new Promise(function(resolve, reject) {
+      var framepromises = [];
+      for (var i = 0; i < frames; i++) {
+        framepromises.push(this.scheduleGIFframe(width, height, i, delay * i));
+      }
+      Promise.all(framepromises).then(function(frames) {
+        var start = performance.now();
+        var gif = new GIF({workers: 2, quality: 10});
+        for (var i = 0; i < frames.length; i++) {
+          gif.addFrame(frames[i].image, {delay: (i == frames.length - 1 ? delay * 8 : delay)});
+        }
+        gif.on('finished', function(blob) {
+          var end = performance.now();
+          resolve({image: blob, time: end - start});
+        });
+        gif.render();
+      });
+    }.bind(this));
+  },
+  scheduleGIFframe: function(width, height, frame, delay) {
+    return new Promise(function(resolve, reject) {
+      setTimeout(function() { 
+        //console.log('get frame', frame);
+        var imgdata = this.getCaptureData(width, height);
+        if (imgdata) {
+          resolve({frame: frame, image: imgdata});
+        } else {
+          reject();
+        }
+      }.bind(this), delay);
+    }.bind(this));
+  },
+  captureMP4: function(width, height, fps, time) {
+    var delay = 1000 / fps;
+    var numframes = time * fps;
+    return new Promise(function(resolve, reject) {
+      var framepromises = [];
+      //var ffmpeg = this.ffmpeg;
+      var ffmpeg = new FFMPEG({scriptbase: '/scripts/engine/external/ffmpeg/', useWorker: true, quality: 'veryfast', fps: fps});
+      for (var i = 0; i < numframes; i++) {
+        var promise = this.scheduleGIFframe(width, height, i, delay * i);
+        framepromises.push(promise);
+        promise.then(function(framedata) {
+          ffmpeg.addFrame(framedata.image);
+        });
+      }
+      framepromises[0].then(function(f) {
+        var start = performance.now();
+        ffmpeg.on('finished', function(blob) {
+          var end = performance.now();
+          resolve({image: blob, time: end - start});
+        });
+        ffmpeg.render('ultrafast');
+      
+      });
+    }.bind(this));
+  },
+  encodeImage: function(pixeldata, width, height, format) {
+    return new Promise(function(resolve, reject) {
+      var worker = new Worker('/scripts/vrcade/imageworker-' + format + '.js');
+      worker.addEventListener('message', function(ev) {
+        resolve(ev.data);          
+      }.bind(this));
+
+      var workermsg = {
+        width: width,
+        height: height,
+        format: format,
+        data: pixeldata.buffer,
+        timeStamp: new Date().getTime()
+      };
+      worker.postMessage(workermsg, [workermsg.data]);
+    }.bind(this));
+  }
+
+};

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

@@ -0,0 +1,57 @@
+/**
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.RenderPass = function ( scene, camera, overrideMaterial, clearColor, clearAlpha ) {
+
+	THREE.Pass.call( this );
+
+	this.scene = scene;
+	this.camera = camera;
+
+	this.overrideMaterial = overrideMaterial;
+
+	this.clearColor = clearColor;
+	this.clearAlpha = ( clearAlpha !== undefined ) ? clearAlpha : 0;
+
+	this.clear = false;
+	this.needsSwap = false;
+
+};
+
+THREE.RenderPass.prototype = Object.assign( Object.create( THREE.Pass.prototype ), {
+
+	constructor: THREE.RenderPass,
+
+	render: function ( renderer, writeBuffer, readBuffer, delta, maskActive ) {
+
+		var oldAutoClear = renderer.autoClear;
+		renderer.autoClear = false;
+
+		this.scene.overrideMaterial = this.overrideMaterial;
+
+		var oldClearColor, oldClearAlpha;
+
+		if ( this.clearColor ) {
+
+			oldClearColor = renderer.getClearColor().getHex();
+			oldClearAlpha = renderer.getClearAlpha();
+
+			renderer.setClearColor( this.clearColor, this.clearAlpha );
+
+		}
+
+		renderer.render( this.scene, this.camera, this.renderToScreen ? null : readBuffer, this.clear );
+
+		if ( this.clearColor ) {
+
+			renderer.setClearColor( oldClearColor, oldClearAlpha );
+
+		}
+
+		this.scene.overrideMaterial = null;
+		renderer.autoClear = oldAutoClear;
+    elation.events.fire({element: this, type: 'render'});
+	}
+
+} );

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

@@ -0,0 +1,259 @@
+/**
+ * @author alteredq / http://alteredqualia.com/
+ *
+ * Screen-space ambient occlusion shader
+ * - ported from
+ *   SSAO GLSL shader v1.2
+ *   assembled by Martins Upitis (martinsh) (http://devlog-martinsh.blogspot.com)
+ *   original technique is made by ArKano22 (http://www.gamedev.net/topic/550699-ssao-no-halo-artifacts/)
+ * - modifications
+ * - modified to use RGBA packed depth texture (use clear color 1,1,1,1 for depth pass)
+ * - made fog more compatible with three.js linear fog
+ * - refactoring and optimizations
+ */
+
+THREE.SSAOShader = {
+
+	uniforms: {
+
+		"tDiffuse":     { type: "t", value: null },
+		"tDepth":       { type: "t", value: null },
+		"size":         { type: "v2", value: new THREE.Vector2( 512, 512 ) },
+		"cameraNear":   { type: "f", value: 1 },
+		"cameraFar":    { type: "f", value: 100 },
+		"fogNear":      { type: "f", value: 5 },
+		"fogFar":       { type: "f", value: 100 },
+		"fogEnabled":   { type: "i", value: 0 },
+		"onlyAO":       { type: "i", value: 0 },
+		"aoClamp":      { type: "f", value: 0.3 },
+		"lumInfluence": { type: "f", value: 0.9 }
+
+	},
+
+	vertexShader: [
+
+		"varying vec2 vUv;",
+
+		"void main() {",
+
+			"vUv = uv;",
+
+			"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+
+		"}"
+
+	].join("\n"),
+
+	fragmentShader: [
+
+		"uniform float cameraNear;",
+		"uniform float cameraFar;",
+
+		"uniform float fogNear;",
+		"uniform float fogFar;",
+
+		"uniform bool fogEnabled;",  // attenuate AO with linear fog
+		"uniform bool onlyAO;",      // use only ambient occlusion pass?
+
+		"uniform vec2 size;",        // texture width, height
+		"uniform float aoClamp;",    // depth clamp - reduces haloing at screen edges
+
+		"uniform float lumInfluence;",  // how much luminance affects occlusion
+
+		"uniform sampler2D tDiffuse;",
+		"uniform sampler2D tDepth;",
+
+		"varying vec2 vUv;",
+
+		// "#define PI 3.14159265",
+		"#define DL 2.399963229728653",  // PI * ( 3.0 - sqrt( 5.0 ) )
+		"#define EULER 2.718281828459045",
+
+		// helpers
+
+		"float width = size.x;",   // texture width
+		"float height = size.y;",  // texture height
+
+		"float cameraFarPlusNear = cameraFar + cameraNear;",
+		"float cameraFarMinusNear = cameraFar - cameraNear;",
+		"float cameraCoef = 2.0 * cameraNear;",
+
+		// user variables
+
+		"const int samples = 8;",     // ao sample count
+		"const float radius = 5.0;",  // ao radius
+
+		"const bool useNoise = false;",      // use noise instead of pattern for sample dithering
+		"const float noiseAmount = 0.0003;", // dithering amount
+
+		"const float diffArea = 0.4;",   // self-shadowing reduction
+		"const float gDisplace = 0.4;",  // gauss bell center
+
+		"const vec3 onlyAOColor = vec3( 1.0, 0.7, 0.5 );",
+		// "const vec3 onlyAOColor = vec3( 1.0, 1.0, 1.0 );",
+
+
+		// RGBA depth
+
+		"float unpackDepth( const in vec4 rgba_depth ) {",
+
+			"const vec4 bit_shift = vec4( 1.0 / ( 256.0 * 256.0 * 256.0 ), 1.0 / ( 256.0 * 256.0 ), 1.0 / 256.0, 1.0 );",
+			"float depth = dot( rgba_depth, bit_shift );",
+			"return depth;",
+
+		"}",
+
+		// generating noise / pattern texture for dithering
+
+		"vec2 rand( const vec2 coord ) {",
+
+			"vec2 noise;",
+
+			"if ( useNoise ) {",
+
+				"float nx = dot ( coord, vec2( 12.9898, 78.233 ) );",
+				"float ny = dot ( coord, vec2( 12.9898, 78.233 ) * 2.0 );",
+
+				"noise = clamp( fract ( 43758.5453 * sin( vec2( nx, ny ) ) ), 0.0, 1.0 );",
+
+			"} else {",
+
+				"float ff = fract( 1.0 - coord.s * ( width / 2.0 ) );",
+				"float gg = fract( coord.t * ( height / 2.0 ) );",
+
+				"noise = vec2( 0.25, 0.75 ) * vec2( ff ) + vec2( 0.75, 0.25 ) * gg;",
+
+			"}",
+
+			"return ( noise * 2.0  - 1.0 ) * noiseAmount;",
+
+		"}",
+
+		"float doFog() {",
+
+			"float zdepth = unpackDepth( texture2D( tDepth, vUv ) );",
+			"float depth = -cameraFar * cameraNear / ( zdepth * cameraFarMinusNear - cameraFar );",
+
+			"return smoothstep( fogNear, fogFar, depth );",
+
+		"}",
+
+		"float readDepth( const in vec2 coord ) {",
+
+			// "return ( 2.0 * cameraNear ) / ( cameraFar + cameraNear - unpackDepth( texture2D( tDepth, coord ) ) * ( cameraFar - cameraNear ) );",
+			"return cameraCoef / ( cameraFarPlusNear - unpackDepth( texture2D( tDepth, coord ) ) * cameraFarMinusNear );",
+
+
+		"}",
+
+		"float compareDepths( const in float depth1, const in float depth2, inout int far ) {",
+
+			"float garea = 2.0;",                         // gauss bell width
+			"float diff = ( depth1 - depth2 ) * 100.0;",  // depth difference (0-100)
+
+			// reduce left bell width to avoid self-shadowing
+
+			"if ( diff < gDisplace ) {",
+
+				"garea = diffArea;",
+
+			"} else {",
+
+				"far = 1;",
+
+			"}",
+
+			"float dd = diff - gDisplace;",
+			"float gauss = pow( EULER, -2.0 * dd * dd / ( garea * garea ) );",
+			"return gauss;",
+
+		"}",
+
+		"float calcAO( float depth, float dw, float dh ) {",
+
+			"float dd = radius - depth * radius;",
+			"vec2 vv = vec2( dw, dh );",
+
+			"vec2 coord1 = vUv + dd * vv;",
+			"vec2 coord2 = vUv - dd * vv;",
+
+			"float temp1 = 0.0;",
+			"float temp2 = 0.0;",
+
+			"int far = 0;",
+			"temp1 = compareDepths( depth, readDepth( coord1 ), far );",
+
+			// DEPTH EXTRAPOLATION
+
+			"if ( far > 0 ) {",
+
+				"temp2 = compareDepths( readDepth( coord2 ), depth, far );",
+				"temp1 += ( 1.0 - temp1 ) * temp2;",
+
+			"}",
+
+			"return temp1;",
+
+		"}",
+
+		"void main() {",
+
+			"vec2 noise = rand( vUv );",
+			"float depth = readDepth( vUv );",
+
+			"float tt = clamp( depth, aoClamp, 1.0 );",
+
+			"float w = ( 1.0 / width )  / tt + ( noise.x * ( 1.0 - noise.x ) );",
+			"float h = ( 1.0 / height ) / tt + ( noise.y * ( 1.0 - noise.y ) );",
+
+			"float pw;",
+			"float ph;",
+
+			"float ao;",
+
+			"float dz = 1.0 / float( samples );",
+			"float z = 1.0 - dz / 2.0;",
+			"float l = 0.0;",
+
+			"for ( int i = 0; i <= samples; i ++ ) {",
+
+				"float r = sqrt( 1.0 - z );",
+
+				"pw = cos( l ) * r;",
+				"ph = sin( l ) * r;",
+				"ao += calcAO( depth, pw * w, ph * h );",
+				"z = z - dz;",
+				"l = l + DL;",
+
+			"}",
+
+			"ao /= float( samples );",
+			"ao = 1.0 - ao;",
+
+			"if ( fogEnabled ) {",
+
+				"ao = mix( ao, 1.0, doFog() );",
+
+			"}",
+
+			"vec3 color = texture2D( tDiffuse, vUv ).rgb;",
+
+			"vec3 lumcoeff = vec3( 0.299, 0.587, 0.114 );",
+			"float lum = dot( color.rgb, lumcoeff );",
+			"vec3 luminance = vec3( lum );",
+
+			"vec3 final = vec3( color * mix( vec3( ao ), vec3( 1.0 ), luminance * lumInfluence ) );",  // mix( color * ao, white, luminance )
+
+			"if ( onlyAO ) {",
+
+				"final = onlyAOColor * vec3( mix( vec3( ao ), vec3( 1.0 ), luminance * lumInfluence ) );",  // ambient occlusion only
+
+			"}",
+
+			"gl_FragColor = vec4( final, 1.0 );",
+
+		"}"
+
+	].join("\n")
+
+};

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

@@ -0,0 +1,54 @@
+/**
+ * @author alteredq / http://alteredqualia.com/
+ *
+ * Sepia tone shader
+ * based on glfx.js sepia shader
+ * https://github.com/evanw/glfx.js
+ */
+
+THREE.SepiaShader = {
+
+	uniforms: {
+
+		"tDiffuse": { type: "t", value: null },
+		"amount":   { type: "f", value: 1.0 }
+
+	},
+
+	vertexShader: [
+
+		"varying vec2 vUv;",
+
+		"void main() {",
+
+			"vUv = uv;",
+			"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+
+		"}"
+
+	].join("\n"),
+
+	fragmentShader: [
+
+		"uniform float amount;",
+
+		"uniform sampler2D tDiffuse;",
+
+		"varying vec2 vUv;",
+
+		"void main() {",
+
+			"vec4 color = texture2D( tDiffuse, vUv );",
+			"vec3 c = color.rgb;",
+
+			"color.r = dot( c, vec3( 1.0 - 0.607 * amount, 0.769 * amount, 0.189 * amount ) );",
+			"color.g = dot( c, vec3( 0.349 * amount, 1.0 - 0.314 * amount, 0.168 * amount ) );",
+			"color.b = dot( c, vec3( 0.272 * amount, 0.534 * amount, 1.0 - 0.869 * amount ) );",
+
+			"gl_FragColor = vec4( min( vec3( 1.0 ), color.rgb ), color.a );",
+
+		"}"
+
+	].join("\n")
+
+};

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

@@ -0,0 +1,66 @@
+/**
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.ShaderPass = function ( shader, textureID ) {
+
+	THREE.Pass.call( this );
+
+	this.textureID = ( textureID !== undefined ) ? textureID : "tDiffuse";
+
+	if ( shader instanceof THREE.ShaderMaterial ) {
+
+		this.uniforms = shader.uniforms;
+
+		this.material = shader;
+
+	} else if ( shader ) {
+
+		this.uniforms = THREE.UniformsUtils.clone( shader.uniforms );
+
+		this.material = new THREE.ShaderMaterial( {
+
+			defines: shader.defines || {},
+			uniforms: this.uniforms,
+			vertexShader: shader.vertexShader,
+			fragmentShader: shader.fragmentShader
+
+		} );
+
+	}
+
+	this.camera = new THREE.OrthographicCamera( - 1, 1, 1, - 1, 0, 1 );
+	this.scene = new THREE.Scene();
+
+	this.quad = new THREE.Mesh( new THREE.PlaneBufferGeometry( 2, 2 ), null );
+	this.scene.add( this.quad );
+
+};
+
+THREE.ShaderPass.prototype = Object.assign( Object.create( THREE.Pass.prototype ), {
+
+	constructor: THREE.ShaderPass,
+
+	render: function( renderer, writeBuffer, readBuffer, delta, maskActive ) {
+
+		if ( this.uniforms[ this.textureID ] ) {
+
+			this.uniforms[ this.textureID ].value = readBuffer.texture;
+
+		}
+
+		this.quad.material = this.material;
+
+		if ( this.renderToScreen ) {
+
+			renderer.render( this.scene, this.camera );
+
+		} else {
+
+			renderer.render( this.scene, this.camera, writeBuffer, this.clear );
+
+		}
+
+	}
+
+} );