├── example
    ├── simpleviewer
    │   ├── views
    │   │   ├── layout.ejs
    │   │   ├── 404.ejs
    │   │   ├── 500.ejs
    │   │   ├── webgl.ejs
    │   │   └── index.ejs
    │   ├── package.json
    │   ├── public
    │   │   ├── stylesheets
    │   │   │   └── style.css
    │   │   └── javascripts
    │   │   │   ├── postprocessing
    │   │   │       ├── TexturePass.js
    │   │   │       ├── ShaderPass.js
    │   │   │       ├── RenderPass.js
    │   │   │       ├── SavePass.js
    │   │   │       ├── DotScreenPass.js
    │   │   │       ├── FilmPass.js
    │   │   │       ├── MaskPass.js
    │   │   │       ├── BloomPass.js
    │   │   │       └── EffectComposer.js
    │   │   │   ├── Detector.js
    │   │   │   ├── Stats.js
    │   │   │   ├── kinect.js
    │   │   │   ├── main.js
    │   │   │   ├── webgl.js
    │   │   │   ├── socket.io.js
    │   │   │   └── ShaderExtras.js
    │   └── server.js
    └── hellokinect
    │   ├── hellokinect.js
    │   └── depthbuffer_sample.js
├── .gitignore
├── .npmignore
├── Makefile
├── freenect.js
├── package.json
├── wscript
├── README.md
├── LICENSE
└── src
    └── node_freenect.cc


/example/simpleviewer/views/layout.ejs:
--------------------------------------------------------------------------------
1 | <%- body %>
2 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | build
2 | node_modules
3 | .lock-wscript
4 | 


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
1 | .git*
2 | .DS_Store
3 | .lock-wscript
4 | example/
5 | node_modules/


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
1 | make:
2 | 	node-waf configure clean build;
3 | 
4 | clean:
5 | 	rm -rf ./build
6 | 
7 | 


--------------------------------------------------------------------------------
/example/simpleviewer/views/404.ejs:
--------------------------------------------------------------------------------
1 | <h2>404 Not Found</h2>
2 | <p>This is not a page you are looking for.</p>


--------------------------------------------------------------------------------
/example/simpleviewer/views/500.ejs:
--------------------------------------------------------------------------------
1 | <h2>500 Internal Server Error</h2>
2 | <p>An unexpected error seems to have occured.</p>
3 | <h3>Error Details</h3>
4 | <pre>
5 |   <%= error %>
6 | </pre>
7 | 


--------------------------------------------------------------------------------
/freenect.js:
--------------------------------------------------------------------------------
 1 | // require the c++ bindings & export to javascript
 2 | var binding = require(__dirname + '/build/default/freenect_binding');
 3 | 
 4 | var LedOptions = {
 5 | 	OFF: 0,
 6 | 	GREEN: 1,
 7 | 	RED: 2,
 8 | 	YELLOW: 3,
 9 | 	BLINK_GREEN: 5,
10 | 	BLINK_RED_YELLOW: 6
11 | };
12 | 
13 | module.exports = {
14 | 	Kinect: binding.Kinect,
15 | 	LedOptions: LedOptions
16 | };
17 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"name" : "freenect",
 3 | 	"description" : "libfreenect bindings for Node.js",
 4 | 	"version" : "0.0.2",
 5 | 	"author" : "Kazuyuki Honda <hakobera@gmail.com>",
 6 | 	"keywords": ["kinect", "libfreenect"],
 7 | 	"repository": "git://github.com/hakobera/node-freenect",
 8 | 	"main" : "freenect",
 9 | 	"scripts" : {
10 | 		"install" : "node-waf configure build"
11 | 	}
12 | }
13 | 


--------------------------------------------------------------------------------
/example/simpleviewer/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "simpleviewer",
 3 |   "description": "A simple node-freenect viewer for kinect with Node.",
 4 |   "version": "0.0.1",
 5 |   "homepage": "https://github.com/hakobera/node-freenect",
 6 |   "author": "Kazuyuki Honda <hakobera@gmail.com>",
 7 |   "directories": {
 8 |     "public": "./public"
 9 |   },
10 |   "engine": {
11 |     "node": ">=-0.4.0"
12 |   },
13 |   "dependencies": {
14 |     "express": "2.2.2",
15 |     "connect": "1.3.0",
16 |     "ejs": "0.4.1",
17 |     "socket.io": "0.6.17",
18 |     "browserify": "0.3.1",
19 |     "jsmin": "1.0.0"
20 |   },
21 |   "bin": {
22 |     "simpleviewer": "./server.js"
23 |   }
24 | }


--------------------------------------------------------------------------------
/example/hellokinect/hellokinect.js:
--------------------------------------------------------------------------------
 1 | var Freenect = require('freenect');
 2 | 
 3 | var kinect = new Freenect.Kinect(),
 4 | 		ledOption = 0,
 5 | 		prev = Date.now();
 6 | 
 7 | setInterval(function() {
 8 | 	var now = Date.now(),
 9 | 			interval = now - prev,
10 | 			depth = kinect.getDepth(),
11 | 			len = depth.length,
12 | 			tiltAngle = kinect.getTiltAngle(),
13 | 			i;
14 | 
15 | 	console.log('Interval: %d, Depth Size: %d, LED Option: %d, Tile Angle: %d',
16 | 							interval, len, ledOption, tiltAngle);
17 | 
18 | 	// Manupulate depth pixel data like following code.
19 | 	for (i = 0; i < len; ++i) {
20 | 		depth[i] = 255 - depth[i];
21 | 	}
22 | 
23 | 	// Change LED color and blink pattern.
24 | 	kinect.setLed(ledOption);
25 | 
26 | 	ledOption += 1;
27 | 	if (ledOption > 6) {
28 | 		ledOption = 0
29 | 	}
30 | 
31 | 	prev = now;
32 | 
33 | }, 200);
34 | 


--------------------------------------------------------------------------------
/example/hellokinect/depthbuffer_sample.js:
--------------------------------------------------------------------------------
 1 | var Freenect = require('freenect');
 2 | 
 3 | var kinect = new Freenect.Kinect(),
 4 | 		ledOption = 0,
 5 | 		prev = Date.now();
 6 | 
 7 | setInterval(function() {
 8 | 	var now = Date.now(),
 9 | 			interval = now - prev,
10 | 			depth = kinect.getDepthBuffer(),
11 | 			len = depth.length,
12 | 			tiltAngle = kinect.getTiltAngle(),
13 | 			i;
14 | 
15 | 	console.log('Interval: %d, Depth Size: %d, LED Option: %d, Tile Angle: %d',
16 | 							interval, len, ledOption, tiltAngle);
17 | 
18 | 	// Manupulate depth pixel data like following code.
19 | 	for (i = 0; i < len; ++i) {
20 | 		depth[i] = 255 - depth[i];
21 | 	}
22 | 
23 | 	// Change LED color and blink pattern.
24 | 	kinect.setLed(ledOption);
25 | 
26 | 	ledOption += 1;
27 | 	if (ledOption > 6) {
28 | 		ledOption = 0
29 | 	}
30 | 
31 | 	prev = now;
32 | 
33 | }, 100);
34 | 


--------------------------------------------------------------------------------
/example/simpleviewer/public/stylesheets/style.css:
--------------------------------------------------------------------------------
 1 | body {
 2 |   margin: 0;
 3 |   padding: 0;
 4 |   color: #fff;
 5 |   background-color: #000;
 6 |   font: 14px "Lucida Grande, "Helvetica Nueue", Arial, sans-serif;
 7 | }
 8 | 
 9 | h1,h2,h3,h4,h5,h6
10 | p,ul,li,div,form {
11 |   margin: 0;
12 |   padding: 0;
13 | }
14 | 
15 | a {
16 |   outline: none;
17 |   -moz-outline-style: none;
18 | }
19 | 
20 | header {
21 | 	padding: 0 20px;
22 | 	color: #000;
23 | 	background-color: #eee;
24 | }
25 | 
26 | #contents {
27 |   padding: 10px 20px;
28 | }
29 | 
30 | fieldset {
31 | 	margin: 10px 0;
32 | }
33 | 
34 | footer {
35 |   margin-top: 15px;
36 |   color: #999;
37 |   font-size: 12px;
38 |   text-align: center;
39 | }
40 | 
41 | input.number {
42 | 	text-align: right;
43 | }
44 | 
45 | ul.horizontal {
46 | 	list-style:: none;
47 | }
48 | 
49 | ul.horizontal li {
50 | 	display: inline-block;
51 | }


--------------------------------------------------------------------------------
/wscript:
--------------------------------------------------------------------------------
 1 | import os
 2 | import Options, Utils
 3 | from os import unlink, symlink, chdir, popen
 4 | from os.path import exists
 5 | 
 6 | VERSION = '0.0.1'
 7 | 
 8 | def set_options(opt):
 9 |   opt.tool_options('compiler_cxx')
10 | 
11 | def configure(conf):
12 |   conf.check_tool('compiler_cxx')
13 |   conf.check_tool('node_addon')
14 |   conf.check_cxx(lib = 'usb-1.0')
15 |   conf.check_cxx(lib = 'freenect')
16 |   conf.check_cxx(lib = 'freenect_sync')
17 | 
18 | def build(bld):
19 |   obj = bld.new_task_gen('cxx', 'shlib', 'node_addon')
20 |   obj.target = 'freenect_binding'
21 |   obj.source = './src/node_freenect.cc'
22 |   obj.includes = [ '/usr/local/include', '/usr/local/include/libfreenect' ]
23 |   obj.lib = [ 'usb-1.0', 'freenect', 'freenect_sync' ]
24 |   obj.name = 'node-freenect'
25 | 
26 | def shutdown():
27 |   t = 'freenect_bindings.node'
28 |   if exists('build/default' + t) and not exists(t):
29 |     symlink('build/default/' + t, t)
30 | 
31 | 


--------------------------------------------------------------------------------
/example/simpleviewer/public/javascripts/postprocessing/TexturePass.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @author alteredq / http://alteredqualia.com/
 3 |  */
 4 | 
 5 | THREE.TexturePass = function( texture, opacity ) {
 6 | 
 7 | 	var shader = THREE.ShaderExtras[ "screen" ];
 8 | 
 9 | 	this.uniforms = THREE.UniformsUtils.clone( shader.uniforms );
10 | 
11 | 	this.uniforms[ "opacity" ].value = ( opacity !== undefined ) ? opacity : 1.0;
12 | 	this.uniforms[ "tDiffuse" ].texture = texture;
13 | 
14 | 	this.material = new THREE.ShaderMaterial( {
15 | 
16 | 		uniforms: this.uniforms,
17 | 		vertexShader: shader.vertexShader,
18 | 		fragmentShader: shader.fragmentShader
19 | 
20 | 	} );
21 | 
22 | 	this.enabled = true;
23 | 	this.needsSwap = false;
24 | 
25 | };
26 | 
27 | THREE.TexturePass.prototype = {
28 | 
29 | 	render: function ( renderer, writeBuffer, readBuffer, delta ) {
30 | 
31 | 		THREE.EffectComposer.quad.material = this.material;
32 | 
33 | 		renderer.render( THREE.EffectComposer.scene, THREE.EffectComposer.camera, readBuffer );
34 | 
35 | 	}
36 | 
37 | };
38 | 


--------------------------------------------------------------------------------
/example/simpleviewer/public/javascripts/postprocessing/ShaderPass.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @author alteredq / http://alteredqualia.com/
 3 |  */
 4 | 
 5 | THREE.ShaderPass = function( shader, textureID ) {
 6 | 
 7 | 	this.textureID = ( textureID !== undefined ) ? textureID : "tDiffuse";
 8 | 
 9 | 	this.uniforms = THREE.UniformsUtils.clone( shader.uniforms );
10 | 
11 | 	this.material = new THREE.ShaderMaterial( {
12 | 
13 | 		uniforms: this.uniforms,
14 | 		vertexShader: shader.vertexShader,
15 | 		fragmentShader: shader.fragmentShader
16 | 
17 | 	} );
18 | 
19 | 	this.renderToScreen = false;
20 | 
21 | 	this.enabled = true;
22 | 	this.needsSwap = true;
23 | 	this.clear = false;
24 | 
25 | };
26 | 
27 | THREE.ShaderPass.prototype = {
28 | 
29 | 	render: function ( renderer, writeBuffer, readBuffer, delta ) {
30 | 
31 | 		if ( this.uniforms[ this.textureID ] ) {
32 | 
33 | 			this.uniforms[ this.textureID ].texture = readBuffer;
34 | 
35 | 		}
36 | 
37 | 		THREE.EffectComposer.quad.material = this.material;
38 | 
39 | 		if ( this.renderToScreen ) {
40 | 
41 | 			renderer.render( THREE.EffectComposer.scene, THREE.EffectComposer.camera );
42 | 
43 | 		} else {
44 | 
45 | 			renderer.render( THREE.EffectComposer.scene, THREE.EffectComposer.camera, writeBuffer, this.clear );
46 | 
47 | 		}
48 | 
49 | 	}
50 | 
51 | };
52 | 


--------------------------------------------------------------------------------
/example/simpleviewer/public/javascripts/postprocessing/RenderPass.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @author alteredq / http://alteredqualia.com/
 3 |  */
 4 | 
 5 | THREE.RenderPass = function ( scene, camera, overrideMaterial, clearColor, clearAlpha ) {
 6 | 
 7 | 	this.scene = scene;
 8 | 	this.camera = camera;
 9 | 
10 | 	this.overrideMaterial = overrideMaterial;
11 | 
12 | 	this.clearColor = clearColor;
13 | 	this.clearAlpha = ( clearAlpha !== undefined ) ? clearAlpha : 1;
14 | 
15 | 	this.oldClearColor = new THREE.Color();
16 | 	this.oldClearAlpha = 1;
17 | 
18 | 	this.enabled = true;
19 | 	this.clear = true;
20 | 	this.needsSwap = false;
21 | 
22 | };
23 | 
24 | THREE.RenderPass.prototype = {
25 | 
26 | 	render: function ( renderer, writeBuffer, readBuffer, delta ) {
27 | 
28 | 		this.scene.overrideMaterial = this.overrideMaterial;
29 | 
30 | 		if ( this.clearColor ) {
31 | 
32 | 			this.oldClearColor.copy( renderer.getClearColor() );
33 | 			this.oldClearAlpha = renderer.getClearAlpha();
34 | 
35 | 			renderer.setClearColor( this.clearColor, this.clearAlpha );
36 | 
37 | 		}
38 | 
39 | 		renderer.render( this.scene, this.camera, readBuffer, this.clear );
40 | 
41 | 		if ( this.clearColor ) {
42 | 
43 | 			renderer.setClearColor( this.oldClearColor, this.oldClearAlpha );
44 | 
45 | 		}
46 | 
47 | 		this.scene.overrideMaterial = null;
48 | 
49 | 	}
50 | 
51 | };
52 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | node-freenect
 2 | =============
 3 | 
 4 | This software is Node.js addon for control Microsoft Kinect device,
 5 | bindings for [libfreenect](https://github.com/OpenKinect/libfreenect).
 6 | 
 7 | 
 8 | This addon can work on Mac OS X environment, maybe linux environment could work.
 9 | 
10 | It cannot work on Windows environment.
11 | 
12 | Requirements
13 | ------------
14 | 
15 | For the addon, you'll need
16 | 
17 | * Mac OS X >= 10.6
18 | * Node.js >= 0.4.0
19 | * libfreenect
20 | * libusb-freenect on Mac OS X,  libusb-1.0-dev on Linux
21 | * python >= 2.6
22 | 
23 | Installation
24 | ------------
25 | 
26 | Just clone this repository, and using npm.
27 | 
28 | 	npm install
29 | 
30 | 
31 | Licence
32 | -------
33 | 
34 | Copyright 2011 Kazuyuki Honda <hakobera@gmail.com>
35 | 
36 | Licensed under the Apache License, Version 2.0 (the "License");
37 | you may not use this file except in compliance with the License.
38 | You may obtain a copy of the License at
39 | 
40 |   http://www.apache.org/licenses/LICENSE-2.0
41 | 
42 | Unless required by applicable law or agreed to in writing, software
43 | distributed under the License is distributed on an "AS IS" BASIS,
44 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
45 | See the License for the specific language governing permissions and
46 | limitations under the License.
47 | 


--------------------------------------------------------------------------------
/example/simpleviewer/public/javascripts/postprocessing/SavePass.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @author alteredq / http://alteredqualia.com/
 3 |  */
 4 | 
 5 | THREE.SavePass = function( renderTarget ) {
 6 | 
 7 | 	var shader = THREE.ShaderExtras[ "screen" ];
 8 | 
 9 | 	this.textureID = "tDiffuse";
10 | 
11 | 	this.uniforms = THREE.UniformsUtils.clone( shader.uniforms );
12 | 
13 | 	this.material = new THREE.ShaderMaterial( {
14 | 
15 | 		uniforms: this.uniforms,
16 | 		vertexShader: shader.vertexShader,
17 | 		fragmentShader: shader.fragmentShader
18 | 
19 | 	} );
20 | 
21 | 	this.renderTarget = renderTarget;
22 | 
23 | 	if ( this.renderTarget === undefined ) {
24 | 
25 | 		this.renderTargetParameters = { minFilter: THREE.LinearFilter, magFilter: THREE.LinearFilter, format: THREE.RGBFormat, stencilBuffer: false };
26 | 		this.renderTarget = new THREE.WebGLRenderTarget( window.innerWidth, window.innerHeight, this.renderTargetParameters );
27 | 
28 | 	}
29 | 
30 | 	this.enabled = true;
31 | 	this.needsSwap = false;
32 | 	this.clear = false;
33 | 
34 | };
35 | 
36 | THREE.SavePass.prototype = {
37 | 
38 | 	render: function ( renderer, writeBuffer, readBuffer, delta ) {
39 | 
40 | 		if ( this.uniforms[ this.textureID ] ) {
41 | 
42 | 			this.uniforms[ this.textureID ].texture = readBuffer;
43 | 
44 | 		}
45 | 
46 | 		THREE.EffectComposer.quad.material = this.material;
47 | 
48 | 		renderer.render( THREE.EffectComposer.scene, THREE.EffectComposer.camera, this.renderTarget, this.clear );
49 | 
50 | 	}
51 | 
52 | };
53 | 


--------------------------------------------------------------------------------
/example/simpleviewer/public/javascripts/postprocessing/DotScreenPass.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @author alteredq / http://alteredqualia.com/
 3 |  */
 4 | 
 5 | THREE.DotScreenPass = function( center, angle, scale ) {
 6 | 
 7 | 	var shader = THREE.ShaderExtras[ "dotscreen" ];
 8 | 
 9 | 	this.uniforms = THREE.UniformsUtils.clone( shader.uniforms );
10 | 
11 | 	if ( center !== undefined )
12 | 		this.uniforms[ "center" ].value.copy( center );
13 | 
14 | 	if ( angle !== undefined )	this.uniforms[ "angle"].value = angle;
15 | 	if ( scale !== undefined )	this.uniforms[ "scale"].value = scale;
16 | 
17 | 	this.material = new THREE.ShaderMaterial( {
18 | 
19 | 		uniforms: this.uniforms,
20 | 		vertexShader: shader.vertexShader,
21 | 		fragmentShader: shader.fragmentShader
22 | 
23 | 	} );
24 | 
25 | 	this.enabled = true;
26 | 	this.renderToScreen = false;
27 | 	this.needsSwap = true;
28 | 
29 | };
30 | 
31 | THREE.DotScreenPass.prototype = {
32 | 
33 | 	render: function ( renderer, writeBuffer, readBuffer, delta ) {
34 | 
35 | 		this.uniforms[ "tDiffuse" ].texture = readBuffer;
36 | 		this.uniforms[ "tSize" ].value.set( readBuffer.width, readBuffer.height );
37 | 
38 | 		THREE.EffectComposer.quad.material = this.material;
39 | 
40 | 		if ( this.renderToScreen ) {
41 | 
42 | 			renderer.render( THREE.EffectComposer.scene, THREE.EffectComposer.camera );
43 | 
44 | 		} else {
45 | 
46 | 			renderer.render( THREE.EffectComposer.scene, THREE.EffectComposer.camera, writeBuffer, false );
47 | 
48 | 		}
49 | 
50 | 	}
51 | 
52 | };
53 | 


--------------------------------------------------------------------------------
/example/simpleviewer/views/webgl.ejs:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |   <head>
 4 |     <meta charset="utf-8"/>
 5 |     <title>Simple Viewer - node-freenect</title>
 6 |     <link rel="stylesheet" href="/stylesheets/style.css"/>
 7 |   </head>
 8 |   <body style="overflow:hidden;">
 9 | 
10 | 
11 | <script src="http://code.jquery.com/jquery-1.5.2.min.js"></script>
12 | <script src="/javascripts/socket.io.js"></script>
13 | <script src="/javascripts/kinect.js"></script>
14 | 
15 | <div id="webgl"></div>
16 | 
17 | <canvas id="screen" width="400" height="300" style="display:none;"></canvas>
18 | <canvas id="depthbuffer" width="80" height="60" style="display:none;"></canvas>
19 | 
20 | <script src="/javascripts/Three.js"></script>
21 | <script src="/javascripts/ShaderExtras.js"></script>
22 | <script src="/javascripts/postprocessing/EffectComposer.js"></script>
23 | <script src="/javascripts/postprocessing/RenderPass.js"></script>
24 | <script src="/javascripts/postprocessing/BloomPass.js"></script>
25 | <script src="/javascripts/postprocessing/FilmPass.js"></script>
26 | <script src="/javascripts/postprocessing/DotScreenPass.js"></script>
27 | <script src="/javascripts/postprocessing/TexturePass.js"></script>
28 | <script src="/javascripts/postprocessing/ShaderPass.js"></script>
29 | <script src="/javascripts/postprocessing/MaskPass.js"></script>
30 | 
31 | <script src="/javascripts/Detector.js"></script>
32 | <script src="/javascripts/Stats.js"></script>
33 | 
34 | <script src="/javascripts/webgl.js"></script>
35 | 
36 | 
37 |   </body>
38 | </html>
39 | 
40 | 
41 | 


--------------------------------------------------------------------------------
/example/simpleviewer/public/javascripts/postprocessing/FilmPass.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @author alteredq / http://alteredqualia.com/
 3 |  */
 4 | 
 5 | THREE.FilmPass = function( noiseIntensity, scanlinesIntensity, scanlinesCount, grayscale ) {
 6 | 
 7 | 	var shader = THREE.ShaderExtras[ "film" ];
 8 | 
 9 | 	this.uniforms = THREE.UniformsUtils.clone( shader.uniforms );
10 | 
11 | 	this.material = new THREE.ShaderMaterial( {
12 | 
13 | 		uniforms: this.uniforms,
14 | 		vertexShader: shader.vertexShader,
15 | 		fragmentShader: shader.fragmentShader
16 | 
17 | 	} );
18 | 
19 | 	if ( grayscale !== undefined )	this.uniforms.grayscale.value = grayscale;
20 | 	if ( noiseIntensity !== undefined ) this.uniforms.nIntensity.value = noiseIntensity;
21 | 	if ( scanlinesIntensity !== undefined ) this.uniforms.sIntensity.value = scanlinesIntensity;
22 | 	if ( scanlinesCount !== undefined ) this.uniforms.sCount.value = scanlinesCount;
23 | 
24 | 	this.enabled = true;
25 | 	this.renderToScreen = false;
26 | 	this.needsSwap = true;
27 | 
28 | };
29 | 
30 | THREE.FilmPass.prototype = {
31 | 
32 | 	render: function ( renderer, writeBuffer, readBuffer, delta ) {
33 | 
34 | 		this.uniforms[ "tDiffuse" ].texture = readBuffer;
35 | 		this.uniforms[ "time" ].value += delta;
36 | 
37 | 		THREE.EffectComposer.quad.material = this.material;
38 | 
39 | 		if ( this.renderToScreen ) {
40 | 
41 | 			renderer.render( THREE.EffectComposer.scene, THREE.EffectComposer.camera );
42 | 
43 | 		} else {
44 | 
45 | 			renderer.render( THREE.EffectComposer.scene, THREE.EffectComposer.camera, writeBuffer, false );
46 | 
47 | 		}
48 | 
49 | 	}
50 | 
51 | };
52 | 


--------------------------------------------------------------------------------
/example/simpleviewer/public/javascripts/postprocessing/MaskPass.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @author alteredq / http://alteredqualia.com/
 3 |  */
 4 | 
 5 | THREE.MaskPass = function ( scene, camera ) {
 6 | 
 7 | 	this.scene = scene;
 8 | 	this.camera = camera;
 9 | 
10 | 	this.enabled = true;
11 | 	this.clear = true;
12 | 	this.needsSwap = false;
13 | 
14 | 	this.inverse = false;
15 | 
16 | };
17 | 
18 | THREE.MaskPass.prototype = {
19 | 
20 | 	render: function ( renderer, writeBuffer, readBuffer, delta ) {
21 | 
22 | 		var context = renderer.context;
23 | 
24 | 		// don't update color or depth
25 | 
26 | 		context.colorMask( false, false, false, false );
27 | 		context.depthMask( false );
28 | 
29 | 		// set up stencil
30 | 
31 | 		var writeValue, clearValue;
32 | 
33 | 		if ( this.inverse ) {
34 | 
35 | 			writeValue = 0;
36 | 			clearValue = 1;
37 | 
38 | 		} else {
39 | 
40 | 			writeValue = 1;
41 | 			clearValue = 0;
42 | 
43 | 		}
44 | 
45 | 		context.enable( context.STENCIL_TEST );
46 | 		context.stencilOp( context.REPLACE, context.REPLACE, context.REPLACE );
47 | 		context.stencilFunc( context.ALWAYS, writeValue, 0xffffffff );
48 | 		context.clearStencil( clearValue );
49 | 
50 | 		// draw into the stencil buffer
51 | 
52 | 		renderer.render( this.scene, this.camera, readBuffer, this.clear );
53 | 		renderer.render( this.scene, this.camera, writeBuffer, this.clear );
54 | 
55 | 		// re-enable update of color and depth
56 | 
57 | 		context.colorMask( true, true, true, true );
58 | 		context.depthMask( true );
59 | 
60 | 		// only render where stencil is set to 1
61 | 
62 | 		context.stencilFunc( context.EQUAL, 1, 0xffffffff );  // draw if == 1
63 | 		context.stencilOp( context.KEEP, context.KEEP, context.KEEP );
64 | 
65 | 	}
66 | 
67 | };
68 | 
69 | 
70 | THREE.ClearMaskPass = function () {
71 | 
72 | 	this.enabled = true;
73 | 
74 | };
75 | 
76 | THREE.ClearMaskPass.prototype = {
77 | 
78 | 	render: function ( renderer, writeBuffer, readBuffer, delta ) {
79 | 
80 | 		var context = renderer.context;
81 | 
82 | 		context.disable( context.STENCIL_TEST );
83 | 
84 | 	}
85 | 
86 | };
87 | 


--------------------------------------------------------------------------------
/example/simpleviewer/public/javascripts/Detector.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @author alteredq / http://alteredqualia.com/
 3 |  * @author mr.doob / http://mrdoob.com/
 4 |  */
 5 | 
 6 | Detector = {
 7 | 
 8 | 	canvas: !! window.CanvasRenderingContext2D,
 9 | 	webgl: ( function () { try { return !! window.WebGLRenderingContext && !! document.createElement( 'canvas' ).getContext( 'experimental-webgl' ); } catch( e ) { return false; } } )(),
10 | 	workers: !! window.Worker,
11 | 	fileapi: window.File && window.FileReader && window.FileList && window.Blob,
12 | 
13 | 	getWebGLErrorMessage: function () {
14 | 
15 | 		var element = document.createElement( 'div' );
16 | 		element.id = 'webgl-error-message';
17 | 		element.style.fontFamily = 'monospace';
18 | 		element.style.fontSize = '13px';
19 | 		element.style.fontWeight = 'normal';
20 | 		element.style.textAlign = 'center';
21 | 		element.style.background = '#fff';
22 | 		element.style.color = '#000';
23 | 		element.style.padding = '1.5em';
24 | 		element.style.width = '400px';
25 | 		element.style.margin = '5em auto 0';
26 | 
27 | 		if ( ! this.webgl ) {
28 | 
29 | 			element.innerHTML = window.WebGLRenderingContext ? [
30 | 				'Your graphics card does not seem to support <a href="http://khronos.org/webgl/wiki/Getting_a_WebGL_Implementation" style="color:#000">WebGL</a>.<br />',
31 | 				'Find out how to get it <a href="http://get.webgl.org/" style="color:#000">here</a>.'
32 | 			].join( '\n' ) : [
33 | 				'Your browser does not seem to support <a href="http://khronos.org/webgl/wiki/Getting_a_WebGL_Implementation" style="color:#000">WebGL</a>.<br/>',
34 | 				'Find out how to get it <a href="http://get.webgl.org/" style="color:#000">here</a>.'
35 | 			].join( '\n' );
36 | 
37 | 		}
38 | 
39 | 		return element;
40 | 
41 | 	},
42 | 
43 | 	addGetWebGLMessage: function ( parameters ) {
44 | 
45 | 		var parent, id, element;
46 | 
47 | 		parameters = parameters || {};
48 | 
49 | 		parent = parameters.parent !== undefined ? parameters.parent : document.body;
50 | 		id = parameters.id !== undefined ? parameters.id : 'oldie';
51 | 
52 | 		element = Detector.getWebGLErrorMessage();
53 | 		element.id = id;
54 | 
55 | 		parent.appendChild( element );
56 | 
57 | 	}
58 | 
59 | };
60 | 


--------------------------------------------------------------------------------
/example/simpleviewer/views/index.ejs:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |   <head>
 4 |     <meta charset="utf-8"/>
 5 |     <title>Simple Viewer - node-freenect</title>
 6 |     <link rel="stylesheet" href="/stylesheets/style.css"/>
 7 |   </head>
 8 |   <body>
 9 |     <header>
10 |       <h1>Simple Viewer</h1>
11 |     </header>
12 |     <section id="contents">
13 | 
14 | 
15 | 
16 | 
17 | <script src="http://code.jquery.com/jquery-1.5.2.min.js"></script>
18 | <script src="/javascripts/socket.io.js"></script>
19 | <script src="/javascripts/kinect.js"></script>
20 | <script src="/javascripts/main.js"></script>
21 | 
22 | <form id="control">
23 | 	<fieldset>
24 | 		<legend>Image Control</legend>
25 | 		<div>
26 | 			<button id="rbgButton">RGB</button>
27 | 			<button id="depthButton">Depth</button>
28 | 			<button id="stopButton">Stop</button>
29 | 			<span id="debug">Wait...</span>
30 | 		</div>
31 | 		<div>
32 | 			<canvas id="screen" width="400" height="300"></canvas>
33 | 			<canvas id="depthbuffer" width="80" height="60"></canvas>
34 | 		</div>
35 | 	</fieldset>
36 | 	<fieldset>
37 | 		<legend>LED Control</legend>
38 | 		<div>
39 | 			<ul class="horizontal">
40 | 				<li><input id="led0" type="radio" name="led" value="0"/> <label for="led0">OFF</label></li>
41 | 				<li><input id="led1" type="radio" name="led" value="1"/> <label for="led1">GREEN</label></li>
42 | 				<li><input id="led2" type="radio" name="led" value="2"/> <label for="led2">RED</label></li>
43 | 				<li><input id="led3" type="radio" name="led" value="3"/> <label for="led3">YELLOW</label></li>
44 | 				<li><input id="led5" type="radio" name="led" value="5"/> <label for="led5">BLINK GREEN</label></li>
45 | 				<li><input id="led6" type="radio" name="led" value="6"/> <label for="led6">BLINK RED YELLOW</label></li>
46 | 			</ul>
47 | 		</div>
48 | 	</fieldset>
49 | 	<fieldset>
50 | 		<legend>Tilt Angle Control</legend>
51 | 		<div>
52 | 			<input type="text" class="number" id="tiltAngleInput" maxlength="5" value="0" size="6"/>
53 | 			<button id="tiltAngleButton">Change</button>
54 | 		</div>
55 | 	</fieldset>
56 | </form>
57 | 
58 | 
59 | 
60 | 
61 | 
62 | 
63 | 
64 | 
65 |     </section>
66 |     <footer>
67 | 			<p>Source Code is availabe on <a href="https://github.com/hakobera/node-freenect">github</a></p>
68 |       <p>&copy;2011 hakobera</p>
69 |     </footer>
70 |   </body>
71 | </html>
72 | 


--------------------------------------------------------------------------------
/example/simpleviewer/public/javascripts/Stats.js:
--------------------------------------------------------------------------------
1 | // stats.js r8 - http://github.com/mrdoob/stats.js
2 | var Stats=function(){var h,a,n=0,o=0,i=Date.now(),u=i,p=i,l=0,q=1E3,r=0,e,j,f,b=[[16,16,48],[0,255,255]],m=0,s=1E3,t=0,d,k,g,c=[[16,48,16],[0,255,0]];h=document.createElement("div");h.style.cursor="pointer";h.style.width="80px";h.style.opacity="0.9";h.style.zIndex="10001";h.addEventListener("mousedown",function(a){a.preventDefault();n=(n+1)%2;n==0?(e.style.display="block",d.style.display="none"):(e.style.display="none",d.style.display="block")},!1);e=document.createElement("div");e.style.textAlign=
3 | "left";e.style.lineHeight="1.2em";e.style.backgroundColor="rgb("+Math.floor(b[0][0]/2)+","+Math.floor(b[0][1]/2)+","+Math.floor(b[0][2]/2)+")";e.style.padding="0 0 3px 3px";h.appendChild(e);j=document.createElement("div");j.style.fontFamily="Helvetica, Arial, sans-serif";j.style.fontSize="9px";j.style.color="rgb("+b[1][0]+","+b[1][1]+","+b[1][2]+")";j.style.fontWeight="bold";j.innerHTML="FPS";e.appendChild(j);f=document.createElement("div");f.style.position="relative";f.style.width="74px";f.style.height=
4 | "30px";f.style.backgroundColor="rgb("+b[1][0]+","+b[1][1]+","+b[1][2]+")";for(e.appendChild(f);f.children.length<74;)a=document.createElement("span"),a.style.width="1px",a.style.height="30px",a.style.cssFloat="left",a.style.backgroundColor="rgb("+b[0][0]+","+b[0][1]+","+b[0][2]+")",f.appendChild(a);d=document.createElement("div");d.style.textAlign="left";d.style.lineHeight="1.2em";d.style.backgroundColor="rgb("+Math.floor(c[0][0]/2)+","+Math.floor(c[0][1]/2)+","+Math.floor(c[0][2]/2)+")";d.style.padding=
5 | "0 0 3px 3px";d.style.display="none";h.appendChild(d);k=document.createElement("div");k.style.fontFamily="Helvetica, Arial, sans-serif";k.style.fontSize="9px";k.style.color="rgb("+c[1][0]+","+c[1][1]+","+c[1][2]+")";k.style.fontWeight="bold";k.innerHTML="MS";d.appendChild(k);g=document.createElement("div");g.style.position="relative";g.style.width="74px";g.style.height="30px";g.style.backgroundColor="rgb("+c[1][0]+","+c[1][1]+","+c[1][2]+")";for(d.appendChild(g);g.children.length<74;)a=document.createElement("span"),
6 | a.style.width="1px",a.style.height=Math.random()*30+"px",a.style.cssFloat="left",a.style.backgroundColor="rgb("+c[0][0]+","+c[0][1]+","+c[0][2]+")",g.appendChild(a);return{domElement:h,update:function(){i=Date.now();m=i-u;s=Math.min(s,m);t=Math.max(t,m);k.textContent=m+" MS ("+s+"-"+t+")";var a=Math.min(30,30-m/200*30);g.appendChild(g.firstChild).style.height=a+"px";u=i;o++;if(i>p+1E3)l=Math.round(o*1E3/(i-p)),q=Math.min(q,l),r=Math.max(r,l),j.textContent=l+" FPS ("+q+"-"+r+")",a=Math.min(30,30-l/
7 | 100*30),f.appendChild(f.firstChild).style.height=a+"px",p=i,o=0}}};
8 | 
9 | 


--------------------------------------------------------------------------------
/example/simpleviewer/public/javascripts/kinect.js:
--------------------------------------------------------------------------------
  1 | (function(global) {
  2 |   var server,
  3 |       socket,
  4 |       host = 'localhost',
  5 |       port = 3000,
  6 |       connected = false,
  7 |       connectionCallback,
  8 | 	    commandCallbacks = {};
  9 | 
 10 |   socket = new io.Socket(host, {
 11 |     port: port,
 12 |     connectTimeout: 10000,
 13 |     reconnect: true
 14 |   });
 15 | 
 16 |   socket.on('connecting', function(transportType) {
 17 |     connected = false;
 18 |     console.log('Connecting to %s:%d using %s', host, port, transportType);
 19 |   });
 20 | 
 21 |   socket.on('connect', function() {
 22 |     connected = true;
 23 |     console.log('Connected to %s:%d', host, port);
 24 | 	  if (connectionCallback) {
 25 | 		  connectionCallback();
 26 | 	  }
 27 |   });
 28 | 
 29 |   socket.on('connect_failed', function() {
 30 |     connected = false;
 31 |     console.log('Connect failed.');
 32 |   });
 33 | 
 34 |   socket.on('close', function() {
 35 |     connected = false;
 36 |     console.log('Connection closed.');
 37 |   });
 38 | 
 39 |   socket.on('disconnect', function() {
 40 |     connected = false;
 41 |     console.log('Connection disconnected.');
 42 |   });
 43 | 
 44 |   socket.on('recconect', function(transportType, reconnectionAttempts) {
 45 |     connected = true;
 46 |     console.log('Reconnecting to %s:%d using %s %s', host, port, transportType, reconnectionAttempts);
 47 |   });
 48 | 
 49 |   socket.on('reconnect_failed', function() {
 50 |     connected = false;
 51 |     console.log('Reconnect failed.');
 52 |   });
 53 | 
 54 |   socket.on('message', function(command) {
 55 | 	  var cmd = JSON.parse(command);
 56 |     // console.log('[callback][%s]', cmd.type);
 57 | 	  if (commandCallbacks.hasOwnProperty(cmd.type)) {
 58 | 		  commandCallbacks[cmd.type].call(Kinect, cmd.result);
 59 | 	  };
 60 |   });
 61 | 
 62 |   Kinect = {
 63 | 
 64 |     connect: function(callback) {
 65 | 	    socket.connect();
 66 | 	    if (callback && typeof(callback) === 'function') {
 67 | 		    connectionCallback = callback
 68 | 	    }
 69 | 	  },
 70 | 
 71 |     sendCommand: function(commandType, options) {
 72 |       if (connected) {
 73 |         var cmd = options || {};
 74 |         cmd.type = commandType
 75 | 	      // console.log('[send][%s]', cmd.type, cmd);
 76 |         socket.send(JSON.stringify(cmd));
 77 |       }
 78 |     },
 79 | 
 80 | 	  on: function(commandType, callback) {
 81 | 		  if (callback && typeof(callback) === 'function') {
 82 | 			  commandCallbacks[commandType] = callback;
 83 | 		  }
 84 | 	  },
 85 | 
 86 | 	  setLed: function(ledOption) {
 87 | 		  this.sendCommand('setLed', { option: ledOption });
 88 | 	  },
 89 | 
 90 | 	  setTiltAngle: function(angle) {
 91 | 			this.sendCommand('setTiltAngle', { angle: angle });
 92 | 		},
 93 | 
 94 | 	  getDepth: function(callback) {
 95 | 		  this.sendCommand('getDepth');
 96 | 		  this.on('getDepth', function(ret) {
 97 | 				if (callback) {
 98 | 					callback.call(Kinect, ret.data);
 99 | 				}
100 | 			});
101 | 	  },
102 | 
103 | 	  getVideo: function(callback) {
104 | 		  this.sendCommand('getVideo');
105 | 		  this.on('getVideo', function(ret) {
106 | 				if (callback) {
107 | 					callback.call(Kinect, ret.data);
108 | 				}
109 | 			});
110 | 	  },
111 | 
112 | 	  stop: function() {
113 | 		  this.sendCommand('stop');
114 | 	  }
115 | 
116 |   };
117 | 
118 | 	Kinect.LED_OPTIONS = {
119 | 		OFF: 0,
120 | 		GREEN: 1,
121 | 		RED: 2,
122 | 		YELLOW: 3,
123 | 		BLINK_GREEN: 5,
124 | 		BLINK_RED_YELLOW: 6
125 |   };
126 | 
127 | 	return Kinect;
128 | })(this);


--------------------------------------------------------------------------------
/example/simpleviewer/public/javascripts/postprocessing/BloomPass.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * @author alteredq / http://alteredqualia.com/
  3 |  */
  4 | 
  5 | THREE.BloomPass = function( strength, kernelSize, sigma, resolution ) {
  6 | 
  7 | 	strength = ( strength !== undefined ) ? strength : 1;
  8 | 	kernelSize = ( kernelSize !== undefined ) ? kernelSize : 25;
  9 | 	sigma = ( sigma !== undefined ) ? sigma : 4.0;
 10 | 	resolution = ( resolution !== undefined ) ? resolution : 256;
 11 | 
 12 | 	// render targets
 13 | 
 14 | 	var pars = { minFilter: THREE.LinearFilter, magFilter: THREE.LinearFilter, format: THREE.RGBFormat };
 15 | 
 16 | 	this.renderTargetX = new THREE.WebGLRenderTarget( resolution, resolution, pars );
 17 | 	this.renderTargetY = new THREE.WebGLRenderTarget( resolution, resolution, pars );
 18 | 
 19 | 	// screen material
 20 | 
 21 | 	var screenShader = THREE.ShaderExtras[ "screen" ];
 22 | 
 23 | 	this.screenUniforms = THREE.UniformsUtils.clone( screenShader.uniforms );
 24 | 
 25 | 	this.screenUniforms[ "opacity" ].value = strength;
 26 | 
 27 | 	this.materialScreen = new THREE.ShaderMaterial( {
 28 | 
 29 | 		uniforms: this.screenUniforms,
 30 | 		vertexShader: screenShader.vertexShader,
 31 | 		fragmentShader: screenShader.fragmentShader,
 32 | 		blending: THREE.AdditiveBlending,
 33 | 		transparent: true
 34 | 
 35 | 	} );
 36 | 
 37 | 	// convolution material
 38 | 
 39 | 	var convolutionShader = THREE.ShaderExtras[ "convolution" ];
 40 | 
 41 | 	this.convolutionUniforms = THREE.UniformsUtils.clone( convolutionShader.uniforms );
 42 | 
 43 | 	this.convolutionUniforms[ "uImageIncrement" ].value = THREE.BloomPass.blurx;
 44 | 	this.convolutionUniforms[ "cKernel" ].value = THREE.ShaderExtras.buildKernel( sigma );
 45 | 
 46 | 	this.materialConvolution = new THREE.ShaderMaterial( {
 47 | 
 48 | 		uniforms: this.convolutionUniforms,
 49 | 		vertexShader:   "#define KERNEL_SIZE " + kernelSize + ".0\n" + convolutionShader.vertexShader,
 50 | 		fragmentShader: "#define KERNEL_SIZE " + kernelSize + "\n"   + convolutionShader.fragmentShader
 51 | 
 52 | 	} );
 53 | 
 54 | 	this.enabled = true;
 55 | 	this.needsSwap = false;
 56 | 	this.clear = false;
 57 | 
 58 | };
 59 | 
 60 | THREE.BloomPass.prototype = {
 61 | 
 62 | 	render: function ( renderer, writeBuffer, readBuffer, delta, maskActive ) {
 63 | 
 64 | 		if ( maskActive ) renderer.context.disable( renderer.context.STENCIL_TEST );
 65 | 
 66 | 		// Render quad with blured scene into texture (convolution pass 1)
 67 | 
 68 | 		THREE.EffectComposer.quad.material = this.materialConvolution;
 69 | 
 70 | 		this.convolutionUniforms[ "tDiffuse" ].texture = readBuffer;
 71 | 		this.convolutionUniforms[ "uImageIncrement" ].value = THREE.BloomPass.blurX;
 72 | 
 73 | 		renderer.render( THREE.EffectComposer.scene, THREE.EffectComposer.camera, this.renderTargetX, true );
 74 | 
 75 | 
 76 | 		// Render quad with blured scene into texture (convolution pass 2)
 77 | 
 78 | 		this.convolutionUniforms[ "tDiffuse" ].texture = this.renderTargetX;
 79 | 		this.convolutionUniforms[ "uImageIncrement" ].value = THREE.BloomPass.blurY;
 80 | 
 81 | 		renderer.render( THREE.EffectComposer.scene, THREE.EffectComposer.camera, this.renderTargetY, true );
 82 | 
 83 | 		// Render original scene with superimposed blur to texture
 84 | 
 85 | 		THREE.EffectComposer.quad.material = this.materialScreen;
 86 | 
 87 | 		this.screenUniforms[ "tDiffuse" ].texture = this.renderTargetY;
 88 | 
 89 | 		if ( maskActive ) renderer.context.enable( renderer.context.STENCIL_TEST );
 90 | 
 91 | 		renderer.render( THREE.EffectComposer.scene, THREE.EffectComposer.camera, readBuffer, this.clear );
 92 | 
 93 | 	}
 94 | 
 95 | };
 96 | 
 97 | THREE.BloomPass.blurX = new THREE.Vector2( 0.001953125, 0.0 );
 98 | THREE.BloomPass.blurY = new THREE.Vector2( 0.0, 0.001953125 );
 99 | 
100 | 
101 | 


--------------------------------------------------------------------------------
/example/simpleviewer/public/javascripts/main.js:
--------------------------------------------------------------------------------
  1 | $(function() {
  2 | 	var rgbButton = $('#rbgButton'),
  3 | 			depthButton = $('#depthButton'),
  4 | 			stopButton = $('#stopButton'),
  5 | 			depthCanvas = document.getElementById('depthbuffer'),
  6 | 			depthContext = depthCanvas.getContext('2d'),
  7 | 			// screenImage = screenContext.createImageData(screenCanvas.width, screenCanvas.height),
  8 | 			depthImage = depthContext.createImageData(80, 60),
  9 | 			depthSize = depthCanvas.width * depthCanvas.height,
 10 | 
 11 | 			screenCanvas = document.getElementById('screen'),
 12 | 			screenContext = screenCanvas.getContext('2d'),
 13 | 			// screenImage = screenContext.createImageData(screenCanvas.width, screenCanvas.height),
 14 | 			screenImage = screenContext.createImageData(400, 300),
 15 | 			screenSize = screenCanvas.width * screenCanvas.height,
 16 | 
 17 | 			ledSwitch = $('input[name=led]'),
 18 | 			tiltAngleInput = $('#tiltAngleInput'),
 19 | 			tiltAngleButton = $('#tiltAngleButton');
 20 | 
 21 | 	Kinect.connect();
 22 | /*
 23 | 	rgbButton.click(function(e) {
 24 | 		e.preventDefault();
 25 | 		Kinect.getVideo(function(data) {
 26 | 			var length = data.length,
 27 | 					pixels = screenImage.data,
 28 | 					i, srcIndex, dstIndex;
 29 | 
 30 | 			console.log(length);
 31 | 
 32 | 			for (i = 0; i < screenSize; i+=4) {
 33 | 				srcIndex = i * 3;
 34 | 				dstIndex = i * 4;
 35 | 				pixels[dstIndex  ] = data[srcIndex  ];
 36 | 				pixels[dstIndex+1] = data[srcIndex+1];
 37 | 				pixels[dstIndex+2] = data[srcIndex+2];
 38 | 				pixels[dstIndex+3] = 255;
 39 | 			}
 40 | 
 41 | 			screenContext.putImageData(screenImage, 0, 0);
 42 | 		});
 43 | 	});
 44 | */
 45 | 
 46 | 	
 47 | 	var last_frametime = 0;
 48 | 	var last_fps = 0;
 49 | 
 50 | 	var getDepthFrame = function() {
 51 | 
 52 | 		Kinect.getDepth(function(data) {
 53 | 			console.log(data);
 54 | 
 55 | 			var offset = 0,
 56 | 					length = data.length,
 57 | 					pixels = depthImage.data,
 58 | 					i, color;
 59 | 
 60 | 			offset = 0;
 61 | 			for (i = 0; i < length; ++i) {
 62 | 				color = data[i] ;
 63 | 				pixels[offset  ] = color;
 64 | 				pixels[offset+1] = color;
 65 | 				pixels[offset+2] = color;
 66 | 				pixels[offset+3] = 255;
 67 | 				offset += 4;
 68 | 			}
 69 | 			depthContext.putImageData(depthImage, 0, 0);
 70 | 			screenContext.drawImage(depthCanvas, 0,0,depthCanvas.width,depthCanvas.height,0,0,screenCanvas.width,screenCanvas.height);
 71 | 
 72 | 			var t =  (new Date()).getTime();
 73 | 			if (last_frametime == 0)
 74 | 				last_frametime = t;
 75 | 
 76 | 			var dt = t - last_frametime;
 77 | 			if( dt >0 ){
 78 | 				var cfps = 1000.0 / dt;
 79 | 
 80 | 				last_fps *= 0.5;
 81 | 				last_fps += cfps*0.5;
 82 | 			}
 83 | 
 84 | 			$('#debug').text('avg. fps: '+Math.round(last_fps,3));
 85 | 
 86 | 				last_frametime = t;
 87 | 			getDepthFrame();
 88 | 		});
 89 | 	};
 90 | 
 91 | 	setTimeout(function(){
 92 | 		getDepthFrame();
 93 | 	}, 500);
 94 | 
 95 | /*
 96 | 	depthButton.click(function(e) {
 97 | 		e.preventDefault();
 98 | 		Kinect.getDepth(function(data) {
 99 | 			var offset = 0,
100 | 					length = data.length,
101 | 					pixels = screenImage.data,
102 | 					scale = 255 / 2047,
103 | 					i, color;
104 | 
105 | 			for (i = 0; i < length; ++i) {
106 | 				offset = 4 * i;
107 | 				color = data[i] * scale | 0;
108 | 				pixels[offset  ] = color;
109 | 				pixels[offset+1] = color;
110 | 				pixels[offset+2] = color;
111 | 				pixels[offset+3] = 255;
112 | 			}
113 | 
114 | 			screenContext.putImageData(screenImage, 0, 0);
115 | 		});
116 | 	});
117 | 
118 | 	stopButton.click(function(e) {
119 | 		e.preventDefault();
120 | 		Kinect.stop();
121 | 	});
122 | */
123 | 	ledSwitch.click(function(e) {
124 | 		Kinect.setLed($(this).val());
125 | 	});
126 | 
127 | 	tiltAngleButton.click(function(e) {
128 | 		e.preventDefault();
129 | 		var v = tiltAngleInput.val(),
130 | 				angle = parseFloat(v);
131 | 		if (!isNaN(angle)) {
132 | 			Kinect.setTiltAngle(angle);
133 | 		}
134 | 	});
135 | 
136 | });
137 | 


--------------------------------------------------------------------------------
/example/simpleviewer/public/javascripts/postprocessing/EffectComposer.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * @author alteredq / http://alteredqualia.com/
  3 |  */
  4 | 
  5 | THREE.EffectComposer = function( renderer, renderTarget ) {
  6 | 
  7 | 	this.renderer = renderer;
  8 | 
  9 | 	this.renderTarget1 = renderTarget;
 10 | 
 11 | 	if ( this.renderTarget1 === undefined ) {
 12 | 
 13 | 		this.renderTargetParameters = { minFilter: THREE.LinearFilter, magFilter: THREE.LinearFilter, format: THREE.RGBFormat, stencilBuffer: false };
 14 | 		this.renderTarget1 = new THREE.WebGLRenderTarget( window.innerWidth, window.innerHeight, this.renderTargetParameters );
 15 | 
 16 | 	}
 17 | 
 18 | 	this.renderTarget2 = this.renderTarget1.clone();
 19 | 
 20 | 	this.writeBuffer = this.renderTarget1;
 21 | 	this.readBuffer = this.renderTarget2;
 22 | 
 23 | 	this.passes = [];
 24 | 
 25 | 	this.copyPass = new THREE.ShaderPass( THREE.ShaderExtras[ "screen" ] );
 26 | 
 27 | };
 28 | 
 29 | THREE.EffectComposer.prototype = {
 30 | 
 31 | 	swapBuffers: function() {
 32 | 
 33 | 		var tmp = this.readBuffer;
 34 | 		this.readBuffer = this.writeBuffer;
 35 | 		this.writeBuffer = tmp;
 36 | 
 37 | 	},
 38 | 
 39 | 	addPass: function ( pass ) {
 40 | 
 41 | 		this.passes.push( pass );
 42 | 
 43 | 	},
 44 | 
 45 | 	render: function ( delta ) {
 46 | 
 47 | 		this.writeBuffer = this.renderTarget1;
 48 | 		this.readBuffer = this.renderTarget2;
 49 | 
 50 | 		var maskActive = false;
 51 | 
 52 | 		var pass, i, il = this.passes.length;
 53 | 
 54 | 		for ( i = 0; i < il; i ++ ) {
 55 | 
 56 | 			pass = this.passes[ i ];
 57 | 
 58 | 			if ( !pass.enabled ) continue;
 59 | 
 60 | 			pass.render( this.renderer, this.writeBuffer, this.readBuffer, delta, maskActive );
 61 | 
 62 | 			if ( pass.needsSwap ) {
 63 | 
 64 | 				if ( maskActive ) {
 65 | 
 66 | 					var context = this.renderer.context;
 67 | 
 68 | 					context.stencilFunc( context.NOTEQUAL, 1, 0xffffffff );
 69 | 
 70 | 					this.copyPass.render( this.renderer, this.writeBuffer, this.readBuffer, delta );
 71 | 
 72 | 					context.stencilFunc( context.EQUAL, 1, 0xffffffff );
 73 | 
 74 | 				}
 75 | 
 76 | 				this.swapBuffers();
 77 | 
 78 | 			}
 79 | 
 80 | 			if ( pass instanceof THREE.MaskPass ) {
 81 | 
 82 | 				maskActive = true;
 83 | 
 84 | 			} else if ( pass instanceof THREE.ClearMaskPass ) {
 85 | 
 86 | 				maskActive = false;
 87 | 
 88 | 			}
 89 | 
 90 | 		}
 91 | 
 92 | 	},
 93 | 
 94 | 	reset: function ( renderTarget ) {
 95 | 
 96 | 		this.renderTarget1 = renderTarget;
 97 | 
 98 | 		if ( this.renderTarget1 === undefined ) {
 99 | 
100 | 			this.renderTarget1 = new THREE.WebGLRenderTarget( window.innerWidth, window.innerHeight, this.renderTargetParameters );
101 | 
102 | 		}
103 | 
104 | 		this.renderTarget2 = this.renderTarget1.clone();
105 | 
106 | 		this.writeBuffer = this.renderTarget1;
107 | 		this.readBuffer = this.renderTarget2;
108 | 
109 | 		THREE.EffectComposer.quad.scale.set( window.innerWidth, window.innerHeight, 1 );
110 | 
111 | 		THREE.EffectComposer.camera.left = window.innerWidth / - 2;
112 | 		THREE.EffectComposer.camera.right = window.innerWidth / 2;
113 | 		THREE.EffectComposer.camera.top = window.innerHeight / 2;
114 | 		THREE.EffectComposer.camera.bottom = window.innerHeight / - 2;
115 | 
116 | 		THREE.EffectComposer.camera.updateProjectionMatrix();
117 | 
118 | 	}
119 | 
120 | };
121 | 
122 | // shared ortho camera
123 | 
124 | THREE.EffectComposer.camera = new THREE.OrthographicCamera( window.innerWidth / - 2, window.innerWidth / 2, window.innerHeight / 2, window.innerHeight / - 2, -10000, 10000 );
125 | 
126 | // shared fullscreen quad scene
127 | 
128 | THREE.EffectComposer.geometry = new THREE.PlaneGeometry( 1, 1 );
129 | 
130 | THREE.EffectComposer.quad = new THREE.Mesh( THREE.EffectComposer.geometry, null );
131 | THREE.EffectComposer.quad.position.z = -100;
132 | THREE.EffectComposer.quad.scale.set( window.innerWidth, window.innerHeight, 1 );
133 | 
134 | THREE.EffectComposer.scene = new THREE.Scene();
135 | THREE.EffectComposer.scene.add( THREE.EffectComposer.quad );
136 | THREE.EffectComposer.scene.add( THREE.EffectComposer.camera );
137 | 


--------------------------------------------------------------------------------
/example/simpleviewer/server.js:
--------------------------------------------------------------------------------
  1 | var express = require('express'),
  2 |     connect = require('connect'),
  3 |     ejs = require('ejs'),
  4 |     sys = require('sys'),
  5 |     path = require('path'),
  6 |     io = require('socket.io'),
  7 | 		freenect = require('../../freenect'),
  8 |     kinect = new freenect.Kinect(),
  9 |     port = 3000,
 10 |     app,
 11 |     socket;
 12 | 
 13 | app = express.createServer();
 14 | 
 15 | app.configure(function() {
 16 |   app.set('views', __dirname + '/views');
 17 |   app.use(express.favicon());
 18 |   app.use(express.bodyParser());
 19 |   app.use(express.cookieParser());
 20 |   app.use(express.logger({ format: '\x1b[1m:method\x1b[0m \x1b[33m:url\x1b]0m :response-time ms' }));
 21 |   app.use(express.methodOverride());
 22 |   app.use(express.static(__dirname + '/public'));
 23 | });
 24 | 
 25 | app.configure('development', function() {
 26 |   app.use(express.errorHandler({ dumpExceptions: true, showStack: true }));
 27 | });
 28 | 
 29 | app.configure('production', function() {
 30 |   app.use(express.errorHandler());
 31 | });
 32 | 
 33 | function NotFound(msg) {
 34 |   this.name = 'NotFound';
 35 |   Error.call(this, msg);
 36 |   Error.captureStackTrace(this, arguments.callee);
 37 | }
 38 | 
 39 | sys.inherits(NotFound, Error);
 40 | 
 41 | app.get('/404', function(req, res) {
 42 |   throw new NotFound();
 43 | });
 44 | 
 45 | app.get('/500', function(req, res) {
 46 |    throw new Error('An expected error');
 47 | });
 48 | 
 49 | app.get('/bad', function(req, res) {
 50 |   unknownMethod();
 51 | });
 52 | 
 53 | app.error(function(err, req, res, next) {
 54 |    if (err instanceof NotFound) {
 55 |      res.render('404.ejs', { status: 404 });
 56 |    } else {
 57 |      next(err);
 58 |    }
 59 | });
 60 | 
 61 | if (app.settings.env === 'production') {
 62 |   app.error(function(err, req, res) {
 63 |     res.render('500.ejs', {
 64 |       status: 500,
 65 |       locals: {
 66 |         error: err
 67 |       }
 68 |     });
 69 |   });
 70 | }
 71 | 
 72 | app.get('/', function(req, res) {
 73 |   res.render('index.ejs');
 74 | });
 75 | 
 76 | app.get('/webgl', function(req, res) {
 77 |   res.render('webgl.ejs');
 78 | });
 79 | 
 80 | var commands = {
 81 |   setLed: function(cmd) {
 82 |     var option = parseInt(cmd.option, 10);
 83 |     if (isNaN(option)) {
 84 |       color = 5; // BLINK GREEN
 85 |     }
 86 |     return kinect.setLed(option);
 87 |   },
 88 | 
 89 | 	setTiltAngle: function(cmd) {
 90 | 		var angle = parseFloat(cmd.angle);
 91 | 		if (isNaN(angle)) {
 92 | 			return false;
 93 | 		}
 94 | 		return kinect.setTiltAngle(angle);
 95 | 	},
 96 | 
 97 | 	stop: function(cmd) {
 98 | 		kinect.stop();
 99 | 		return true;
100 | 	},
101 | 
102 | 	getDepth: function(cmd) {
103 | 		var buffer = kinect.getScaledDepthBuffer(80,60);
104 |     d = Array.prototype.slice.call(buffer,0);
105 |   //  console.log('Buffer:', d);
106 | 		return {
107 | 			data: d
108 | 		};
109 | 	},
110 | 
111 | 	getVideo: function(cmd) {
112 | 		var buffer = kinect.getVideo();
113 | 		return {
114 | 			data: buffer
115 | 		};
116 | 	}
117 | 
118 | };
119 | 
120 | app.listen(port);
121 | console.log('Express server listening on port %d, environment: %s', port, app.settings.env);
122 | console.log('Using connect %s, Express %s, EJS %s', connect.version, express.version, ejs.version);
123 | 
124 | socket = io.listen(app);
125 | 
126 | /*
127 | app.configure('production',function(){
128 |   socket.set('transports', [
129 |     'websocket'
130 |     //,flashsocket'
131 |     //,'htmlfile'
132 |     //,'xhr-polling'
133 |     //,'jsonp-polling'
134 |   ]);
135 | });
136 | */
137 | 
138 | socket.on('connection', function(client) {
139 |   console.log('Connected from');
140 |   console.log(client);
141 | 
142 |   client.on('message', function(message) {
143 |     var command = JSON.parse(message),
144 |         ret = {};
145 | 
146 |     // console.log(command);
147 |     if (commands.hasOwnProperty(command.type)) {
148 |       ret.type = command.type;
149 | 	    ret.result = commands[command.type](command);
150 |       client.send(JSON.stringify(ret));
151 |     } else {
152 | 	    ret.type = command.type;
153 | 	    ret.result = 'Invalid command.';
154 | 	    client.send(JSON.stringify(ret));
155 |     }
156 |   });
157 | 
158 |   client.on('disconnect', function() {
159 |     console.log('Disconnect %s', client);
160 |   });
161 | });
162 | 


--------------------------------------------------------------------------------
/example/simpleviewer/public/javascripts/webgl.js:
--------------------------------------------------------------------------------
  1 | $(function() {
  2 | 
  3 | 	var depthCanvas = document.getElementById('depthbuffer'),
  4 | 			depthContext = depthCanvas.getContext('2d'),
  5 | 			depthImage = depthContext.createImageData(80, 60),
  6 | 			depthSize = depthCanvas.width * depthCanvas.height,
  7 | 
  8 | 			screenCanvas = document.getElementById('screen'),
  9 | 			screenContext = screenCanvas.getContext('2d'),
 10 | 			screenImage = screenContext.createImageData(400, 300),
 11 | 			screenSize = screenCanvas.width * screenCanvas.height;
 12 | 
 13 | 	Kinect.connect();
 14 | 
 15 | 	var last_frametime = 0;
 16 | 	var last_fps = 0;
 17 | 
 18 | 	var getDepthFrame = function() {
 19 | 
 20 | 		Kinect.getDepth(function(data) {
 21 | 			// console.log(data);
 22 | 
 23 | 			var offset = 0,
 24 | 					length = data.length,
 25 | 					pixels = depthImage.data,
 26 | 					i, color;
 27 | 
 28 | 			offset = 0;
 29 | 			for (i = 0; i < length; ++i) {
 30 | 				color = data[i];
 31 | 				if (color < 5) color = 255;
 32 | 				pixels[offset  ] = color;
 33 | 				pixels[offset+1] = color;
 34 | 				pixels[offset+2] = color;
 35 | 				pixels[offset+3] = 255;
 36 | 				offset += 4;
 37 | 			}
 38 | 			depthContext.putImageData(depthImage, 0, 0);
 39 | 			screenContext.drawImage(depthCanvas, 0,0,depthCanvas.width,depthCanvas.height,0,0,screenCanvas.width,screenCanvas.height);
 40 | 			updateBlockZ();
 41 | 
 42 | 			var t =  (new Date()).getTime();
 43 | 			if (last_frametime == 0)
 44 | 				last_frametime = t;
 45 | 
 46 | 			var dt = t - last_frametime;
 47 | 			if( dt >0 ){
 48 | 				var cfps = 1000.0 / dt;
 49 | 
 50 | 				last_fps *= 0.5;
 51 | 				last_fps += cfps*0.5;
 52 | 			}
 53 | 
 54 | 			$('#debug').text('avg. fps: '+Math.round(last_fps,3));
 55 | 
 56 | 				last_frametime = t;
 57 | 
 58 | 			getDepthFrame();
 59 | 		});
 60 | 	};
 61 | 
 62 | 
 63 | 
 64 | 
 65 | 
 66 | 
 67 | 	var container, stats;
 68 | 	var camera, scene, projector, renderer;
 69 | 	var objects = [], plane;
 70 | 
 71 | 	var delta = 0.01;
 72 | 
 73 | 
 74 | 	var gridwidth = 38;
 75 | 	var gridheight = 24;
 76 | 	var gridlength = gridwidth * gridheight;
 77 | 
 78 | 	var objectspacing = 40;
 79 | 
 80 | 	var mouse = new THREE.Vector2(),
 81 | 		offset = new THREE.Vector3(),
 82 | 		INTERSECTED,
 83 | 		SELECTED;
 84 | 
 85 | 	var halfWidth, halfHeight;
 86 | 
 87 | 
 88 | 
 89 | 
 90 | 
 91 | 
 92 | 
 93 | 
 94 | 
 95 | 
 96 | 
 97 | 
 98 | 
 99 | 
100 | 	function init() {
101 | 
102 | 		var halfWidth = window.innerWidth / 2;
103 | 		var halfHeight = window.innerHeight / 2;
104 | 
105 | 		container = document.getElementById('webgl');
106 | 
107 | 		scene = new THREE.Scene();
108 | 
109 | 		camera = new THREE.PerspectiveCamera( 50, window.innerWidth / window.innerHeight, 1, 10000 );
110 | 		camera.position.z = 1000;
111 | 		camera.position.x = 0;
112 | 		scene.add( camera );
113 | 
114 | 		scene.add( new THREE.AmbientLight( 0x505050 ) );
115 | 
116 | 		var light = new THREE.SpotLight( 0xffffff, 1 );
117 | 		light.position.set( -1000, 800, 2500 );
118 | 		light.castShadow = true;
119 | 		light.shadowCameraNear = 200;
120 | 		light.shadowCameraFar = camera.far;
121 | 		light.shadowCameraFov = 50;
122 | 		light.shadowBias = -0.00022;
123 | 		light.shadowDarkness = 0.8;
124 | 		light.shadowMapWidth = 512;
125 | 		light.shadowMapHeight = 512;
126 | 
127 | 		scene.add( light );
128 | 
129 | 		var geometry = new THREE.CubeGeometry( objectspacing*0.8, objectspacing*0.8, 800 );
130 | 
131 | 		for ( var i = 0; i < gridlength; i ++ ) {
132 | 
133 | 		//	var object = new THREE.Mesh( geometry, new THREE.MeshLambertMaterial( { color: Math.random() * 0xffffff } ) );
134 | 			var object = new THREE.Mesh( geometry, new THREE.MeshLambertMaterial( { color: 0xffffff } ) );
135 | 
136 | 			object.material.ambient = object.material.color;
137 | 
138 | 			var row = Math.floor( i / gridwidth );
139 | 			var col = Math.floor( i % gridwidth );
140 | 
141 | 			object.position.x = -objectspacing * (col - (gridwidth-1)/2);
142 | 			object.position.y = -objectspacing * (row - (gridheight-1)/2);
143 | 			object.position.z = 0;
144 | 
145 | 			object.rotation.x = 0;// ( Math.random() * 360 ) * Math.PI / 180;
146 | 			object.rotation.y = 0;// ( Math.random() * 360 ) * Math.PI / 180;
147 | 			object.rotation.z = 0;// ( Math.random() * 360 ) * Math.PI / 180;
148 | 
149 | 			object.castShadow = true;
150 | 			object.receiveShadow = true;
151 | 
152 | 			scene.add( object );
153 | 
154 | 			objects.push( object );
155 | 
156 | 		}
157 | 
158 | 	//	plane = new THREE.Mesh( new THREE.PlaneGeometry( 2000, 2000, 8, 8 ), new THREE.MeshBasicMaterial( { color: 0x000000, opacity: 0.25, transparent: true, wireframe: true } ) );
159 | 	//	plane.lookAt( camera.position );
160 | 	//	plane.visible = false;
161 | 	//	scene.add( plane );
162 | 
163 | 		projector = new THREE.Projector();
164 | 
165 | 		renderer = new THREE.WebGLRenderer( { antialias: false } );
166 | 		renderer.sortObjects = false;
167 | 		renderer.setSize( window.innerWidth, window.innerHeight );
168 | 		renderer.shadowMapEnabled = true;
169 | 		renderer.shadowMapSoft = false;
170 | 
171 | 		var shaderVignette = THREE.ShaderExtras[ "vignette" ];
172 | 		var effectVignette = new THREE.ShaderPass( shaderVignette );
173 | 		effectVignette.uniforms[ "offset" ].value = 0.95;
174 | 		effectVignette.uniforms[ "darkness" ].value = 1.6;
175 | 
176 | 		var effectHBlur = new THREE.ShaderPass( THREE.ShaderExtras[ "horizontalBlur" ] );
177 | 		var effectVBlur = new THREE.ShaderPass( THREE.ShaderExtras[ "verticalBlur" ] );
178 | 		effectHBlur.uniforms[ 'h' ].value = 2 / ( window.innerWidth/2 );
179 | 		effectVBlur.uniforms[ 'v' ].value = 2 / ( window.innerHeight/2 );
180 | 
181 | 		var effectDotScreen = new THREE.DotScreenPass( new THREE.Vector2( 0, 0 ), 0.1, 0.8 );
182 | 
183 | 		var rtWidth  = window.innerWidth;
184 | 		var rtHeight = window.innerHeight;
185 | 		rtParameters = { minFilter: THREE.LinearFilter, magFilter: THREE.LinearFilter, format: THREE.RGBFormat, stencilBuffer: true };
186 | 
187 | 		var renderModel = new THREE.RenderPass( scene, camera );
188 | 		composer1 = new THREE.EffectComposer( renderer, new THREE.WebGLRenderTarget( rtWidth, rtHeight, rtParameters ) );
189 | 		composer1.addPass( renderModel );
190 |  		composer1.addPass( effectVignette );
191 | 		composer1.addPass( effectDotScreen );
192 | 		effectDotScreen.renderToScreen = true;
193 | 		// effectVignette.renderToScreen = true;
194 | 		// renderModel.renderToScreen = true;
195 | 
196 | 		container.appendChild( renderer.domElement );
197 | 
198 | 		// stats = new Stats();
199 | 		// stats.domElement.style.position = 'absolute';
200 | 		// stats.domElement.style.top = '0px';
201 | 		// container.appendChild( stats.domElement );
202 | 	}
203 | 
204 | 	function animate() {
205 | 		requestAnimationFrame( animate );
206 | 		render();
207 | 		// stats.update();
208 | 	}
209 | 
210 | 	function updateBlockZ() {
211 | 		// renderer.render( delta );
212 | 
213 | 		var pixels = depthImage.data;
214 | 		for ( var i = 0; i < gridlength; i ++ ) {
215 | 
216 | 			var row = Math.floor( i / gridwidth );
217 | 			var col = Math.floor( i % gridwidth );
218 | 
219 | 			var object = objects[i];
220 | 
221 | 			var px = Math.round(col * depthImage.width / gridwidth);
222 | 			var py = Math.round(row * depthImage.height / gridheight);
223 | 
224 | 			var pixel = pixels[(py*depthImage.width+px)*4];
225 | 			if( pixel == 0 )
226 | 				pixel = 255;
227 | 
228 | 			object.position.z = -((pixel-128)*5) - 400;
229 | 
230 | //			object.rotation.x += delta;
231 | 	//		object.rotation.y += delta*(i+50)/100;
232 | 		//	object.rotation.z += delta*i/100;
233 | 		}
234 | 	}
235 | 
236 | 	function render() {
237 | 		renderer.clear();
238 | 		composer1.render( delta );
239 | 
240 | 
241 | 	}
242 | 
243 | 
244 | 
245 | 
246 | 	setTimeout(function(){
247 | 		getDepthFrame();
248 | 			init();
249 | 			animate();
250 | 	}, 500);
251 | 
252 | 
253 | });
254 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | 
  2 |                                  Apache License
  3 |                            Version 2.0, January 2004
  4 |                         http://www.apache.org/licenses/
  5 | 
  6 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  7 | 
  8 |    1. Definitions.
  9 | 
 10 |       "License" shall mean the terms and conditions for use, reproduction,
 11 |       and distribution as defined by Sections 1 through 9 of this document.
 12 | 
 13 |       "Licensor" shall mean the copyright owner or entity authorized by
 14 |       the copyright owner that is granting the License.
 15 | 
 16 |       "Legal Entity" shall mean the union of the acting entity and all
 17 |       other entities that control, are controlled by, or are under common
 18 |       control with that entity. For the purposes of this definition,
 19 |       "control" means (i) the power, direct or indirect, to cause the
 20 |       direction or management of such entity, whether by contract or
 21 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 22 |       outstanding shares, or (iii) beneficial ownership of such entity.
 23 | 
 24 |       "You" (or "Your") shall mean an individual or Legal Entity
 25 |       exercising permissions granted by this License.
 26 | 
 27 |       "Source" form shall mean the preferred form for making modifications,
 28 |       including but not limited to software source code, documentation
 29 |       source, and configuration files.
 30 | 
 31 |       "Object" form shall mean any form resulting from mechanical
 32 |       transformation or translation of a Source form, including but
 33 |       not limited to compiled object code, generated documentation,
 34 |       and conversions to other media types.
 35 | 
 36 |       "Work" shall mean the work of authorship, whether in Source or
 37 |       Object form, made available under the License, as indicated by a
 38 |       copyright notice that is included in or attached to the work
 39 |       (an example is provided in the Appendix below).
 40 | 
 41 |       "Derivative Works" shall mean any work, whether in Source or Object
 42 |       form, that is based on (or derived from) the Work and for which the
 43 |       editorial revisions, annotations, elaborations, or other modifications
 44 |       represent, as a whole, an original work of authorship. For the purposes
 45 |       of this License, Derivative Works shall not include works that remain
 46 |       separable from, or merely link (or bind by name) to the interfaces of,
 47 |       the Work and Derivative Works thereof.
 48 | 
 49 |       "Contribution" shall mean any work of authorship, including
 50 |       the original version of the Work and any modifications or additions
 51 |       to that Work or Derivative Works thereof, that is intentionally
 52 |       submitted to Licensor for inclusion in the Work by the copyright owner
 53 |       or by an individual or Legal Entity authorized to submit on behalf of
 54 |       the copyright owner. For the purposes of this definition, "submitted"
 55 |       means any form of electronic, verbal, or written communication sent
 56 |       to the Licensor or its representatives, including but not limited to
 57 |       communication on electronic mailing lists, source code control systems,
 58 |       and issue tracking systems that are managed by, or on behalf of, the
 59 |       Licensor for the purpose of discussing and improving the Work, but
 60 |       excluding communication that is conspicuously marked or otherwise
 61 |       designated in writing by the copyright owner as "Not a Contribution."
 62 | 
 63 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 64 |       on behalf of whom a Contribution has been received by Licensor and
 65 |       subsequently incorporated within the Work.
 66 | 
 67 |    2. Grant of Copyright License. Subject to the terms and conditions of
 68 |       this License, each Contributor hereby grants to You a perpetual,
 69 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 70 |       copyright license to reproduce, prepare Derivative Works of,
 71 |       publicly display, publicly perform, sublicense, and distribute the
 72 |       Work and such Derivative Works in Source or Object form.
 73 | 
 74 |    3. Grant of Patent License. Subject to the terms and conditions of
 75 |       this License, each Contributor hereby grants to You a perpetual,
 76 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 77 |       (except as stated in this section) patent license to make, have made,
 78 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 79 |       where such license applies only to those patent claims licensable
 80 |       by such Contributor that are necessarily infringed by their
 81 |       Contribution(s) alone or by combination of their Contribution(s)
 82 |       with the Work to which such Contribution(s) was submitted. If You
 83 |       institute patent litigation against any entity (including a
 84 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 85 |       or a Contribution incorporated within the Work constitutes direct
 86 |       or contributory patent infringement, then any patent licenses
 87 |       granted to You under this License for that Work shall terminate
 88 |       as of the date such litigation is filed.
 89 | 
 90 |    4. Redistribution. You may reproduce and distribute copies of the
 91 |       Work or Derivative Works thereof in any medium, with or without
 92 |       modifications, and in Source or Object form, provided that You
 93 |       meet the following conditions:
 94 | 
 95 |       (a) You must give any other recipients of the Work or
 96 |           Derivative Works a copy of this License; and
 97 | 
 98 |       (b) You must cause any modified files to carry prominent notices
 99 |           stating that You changed the files; and
100 | 
101 |       (c) You must retain, in the Source form of any Derivative Works
102 |           that You distribute, all copyright, patent, trademark, and
103 |           attribution notices from the Source form of the Work,
104 |           excluding those notices that do not pertain to any part of
105 |           the Derivative Works; and
106 | 
107 |       (d) If the Work includes a "NOTICE" text file as part of its
108 |           distribution, then any Derivative Works that You distribute must
109 |           include a readable copy of the attribution notices contained
110 |           within such NOTICE file, excluding those notices that do not
111 |           pertain to any part of the Derivative Works, in at least one
112 |           of the following places: within a NOTICE text file distributed
113 |           as part of the Derivative Works; within the Source form or
114 |           documentation, if provided along with the Derivative Works; or,
115 |           within a display generated by the Derivative Works, if and
116 |           wherever such third-party notices normally appear. The contents
117 |           of the NOTICE file are for informational purposes only and
118 |           do not modify the License. You may add Your own attribution
119 |           notices within Derivative Works that You distribute, alongside
120 |           or as an addendum to the NOTICE text from the Work, provided
121 |           that such additional attribution notices cannot be construed
122 |           as modifying the License.
123 | 
124 |       You may add Your own copyright statement to Your modifications and
125 |       may provide additional or different license terms and conditions
126 |       for use, reproduction, or distribution of Your modifications, or
127 |       for any such Derivative Works as a whole, provided Your use,
128 |       reproduction, and distribution of the Work otherwise complies with
129 |       the conditions stated in this License.
130 | 
131 |    5. Submission of Contributions. Unless You explicitly state otherwise,
132 |       any Contribution intentionally submitted for inclusion in the Work
133 |       by You to the Licensor shall be under the terms and conditions of
134 |       this License, without any additional terms or conditions.
135 |       Notwithstanding the above, nothing herein shall supersede or modify
136 |       the terms of any separate license agreement you may have executed
137 |       with Licensor regarding such Contributions.
138 | 
139 |    6. Trademarks. This License does not grant permission to use the trade
140 |       names, trademarks, service marks, or product names of the Licensor,
141 |       except as required for reasonable and customary use in describing the
142 |       origin of the Work and reproducing the content of the NOTICE file.
143 | 
144 |    7. Disclaimer of Warranty. Unless required by applicable law or
145 |       agreed to in writing, Licensor provides the Work (and each
146 |       Contributor provides its Contributions) on an "AS IS" BASIS,
147 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
148 |       implied, including, without limitation, any warranties or conditions
149 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
150 |       PARTICULAR PURPOSE. You are solely responsible for determining the
151 |       appropriateness of using or redistributing the Work and assume any
152 |       risks associated with Your exercise of permissions under this License.
153 | 
154 |    8. Limitation of Liability. In no event and under no legal theory,
155 |       whether in tort (including negligence), contract, or otherwise,
156 |       unless required by applicable law (such as deliberate and grossly
157 |       negligent acts) or agreed to in writing, shall any Contributor be
158 |       liable to You for damages, including any direct, indirect, special,
159 |       incidental, or consequential damages of any character arising as a
160 |       result of this License or out of the use or inability to use the
161 |       Work (including but not limited to damages for loss of goodwill,
162 |       work stoppage, computer failure or malfunction, or any and all
163 |       other commercial damages or losses), even if such Contributor
164 |       has been advised of the possibility of such damages.
165 | 
166 |    9. Accepting Warranty or Additional Liability. While redistributing
167 |       the Work or Derivative Works thereof, You may choose to offer,
168 |       and charge a fee for, acceptance of support, warranty, indemnity,
169 |       or other liability obligations and/or rights consistent with this
170 |       License. However, in accepting such obligations, You may act only
171 |       on Your own behalf and on Your sole responsibility, not on behalf
172 |       of any other Contributor, and only if You agree to indemnify,
173 |       defend, and hold each Contributor harmless for any liability
174 |       incurred by, or claims asserted against, such Contributor by reason
175 |       of your accepting any such warranty or additional liability.
176 | 
177 |    END OF TERMS AND CONDITIONS
178 | 
179 |    APPENDIX: How to apply the Apache License to your work.
180 | 
181 |       To apply the Apache License to your work, attach the following
182 |       boilerplate notice, with the fields enclosed by brackets "[]"
183 |       replaced with your own identifying information. (Don't include
184 |       the brackets!)  The text should be enclosed in the appropriate
185 |       comment syntax for the file format. We also recommend that a
186 |       file or class name and description of purpose be included on the
187 |       same "printed page" as the copyright notice for easier
188 |       identification within third-party archives.
189 | 
190 |    Copyright [yyyy] [name of copyright owner]
191 | 
192 |    Licensed under the Apache License, Version 2.0 (the "License");
193 |    you may not use this file except in compliance with the License.
194 |    You may obtain a copy of the License at
195 | 
196 |        http://www.apache.org/licenses/LICENSE-2.0
197 | 
198 |    Unless required by applicable law or agreed to in writing, software
199 |    distributed under the License is distributed on an "AS IS" BASIS,
200 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
201 |    See the License for the specific language governing permissions and
202 |    limitations under the License.


--------------------------------------------------------------------------------
/src/node_freenect.cc:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Node.js addon for libfreenect.
  3 |  */
  4 | 
  5 | //-------------------------------------------------------------------------
  6 | // Includes
  7 | //-------------------------------------------------------------------------
  8 | #include <cstdio>
  9 | #include <cstring>
 10 | #include <cstdlib>
 11 | 
 12 | #include <v8.h>
 13 | #include <node.h>
 14 | #include <node_buffer.h>
 15 | #include <node_object_wrap.h>
 16 | 
 17 | #include <libfreenect_sync.h>
 18 | 
 19 | //-------------------------------------------------------------------------
 20 | // Defines
 21 | //-------------------------------------------------------------------------
 22 | // Taken from node-usb
 23 | #define V8STR(str) v8::String::New(str)
 24 | #define THROW_BAD_ARGS(FAIL_MSG) return v8::ThrowException(v8::Exception::TypeError(V8STR(FAIL_MSG)));
 25 | #define THROW_ERROR(FAIL_MSG) return v8::ThrowException(v8::Exception::Error(V8STR(FAIL_MSG))));
 26 | #define THROW_NOT_YET return v8::ThrowException(v8::Exception::Error(v8::String::Concat(v8::String::New(__FUNCTION__), v8::String::New("not yet supported"))));
 27 | 
 28 | #define MAX_TILT_DEGS (31.0)
 29 | #define MIN_TILT_DEGS (-31.0)
 30 | #define INVALID_TILT_DEGS (-99.0)
 31 | 
 32 | //-------------------------------------------------------------------------
 33 | // libfreenect wrapper for Node.js
 34 | //-------------------------------------------------------------------------
 35 | class Freenect : node::ObjectWrap
 36 | {
 37 | public:
 38 | 
 39 | 	Freenect()
 40 | 	: deviceIndex(0), videoFormat(FREENECT_VIDEO_RGB), depthFormat(FREENECT_DEPTH_11BIT)
 41 | 	{
 42 | 		videoBuffer = malloc(freenect_find_video_mode(FREENECT_RESOLUTION_LOW, FREENECT_VIDEO_RGB).bytes);
 43 | 		depthBuffer = malloc(freenect_find_depth_mode(FREENECT_RESOLUTION_LOW, FREENECT_DEPTH_11BIT).bytes);
 44 | 		tiltState = new freenect_raw_tilt_state();
 45 | 		tiltAngle = GetTiltAngle();
 46 | 	}
 47 | 
 48 | 	virtual ~Freenect()
 49 | 	{
 50 | 		free(videoBuffer);
 51 | 		free(depthBuffer);
 52 | 		freenect_sync_stop();
 53 | 	}
 54 | 
 55 | 	/**
 56 | 	 * Set LED option.
 57 | 	 *
 58 | 	 * @param option LED option to set.
 59 | 	 * @return True if set tilt angle success.
 60 | 	 */
 61 | 	bool SetLed(freenect_led_options option)
 62 | 	{
 63 | 		int ret = freenect_sync_set_led(option, deviceIndex);
 64 | 		if (ret < 0) {
 65 | 			printf("Could set LED %d\n", option);
 66 | 			return false;
 67 | 		}
 68 | 		ledOption = option;
 69 | 		return true;
 70 | 	}
 71 | 
 72 | 	/**
 73 | 	 * Set tilt angle.
 74 | 	 *
 75 | 	 * @param angle Tilt angle toset. Range [-30.0..30.0]
 76 | 	 * @return True if set tilt angle success.
 77 |  	 */
 78 | 	bool SetTiltAngle(double angle)
 79 | 	{
 80 | 	  double deg = angle;
 81 | 		if (deg <= MIN_TILT_DEGS) {
 82 | 			deg = MIN_TILT_DEGS;
 83 | 		}
 84 | 		if (deg >= MAX_TILT_DEGS) {
 85 | 			deg = MAX_TILT_DEGS;
 86 | 		}
 87 | 
 88 | 		int ret = freenect_sync_set_tilt_degs(deg, deviceIndex);
 89 | 		if (ret < 0) {
 90 | 			printf("Could set tilt degs %f\n", deg);
 91 | 			return false;
 92 | 		}
 93 | 		tiltAngle = deg;
 94 | 		return true;
 95 | 	}
 96 | 
 97 | 	/**
 98 | 	 * Get video or IR buffer from kinect.
 99 | 	 *
100 | 	 * @return Video buffer or NULL on error.
101 |  	 */
102 | 	void* GetVideo()
103 | 	{
104 | 		uint32_t timestamp;
105 | 		int ret = freenect_sync_get_video(&videoBuffer, &timestamp, deviceIndex, videoFormat); 
106 | 		if (ret != 0) {
107 | 			printf("Could not get video\n");	
108 | 			return NULL;
109 | 		}
110 | 		return videoBuffer;
111 | 	}
112 | 	
113 | 	/**
114 | 	 * Get depth buffer from kinect.
115 | 	 *
116 | 	 * @return Depth buffer or NULL on error.
117 |  	 */
118 | 	void* GetDepth()
119 | 	{
120 | 		uint32_t timestamp;
121 | 		int ret = freenect_sync_get_depth(&depthBuffer, &timestamp, deviceIndex, depthFormat); 
122 | 		if (ret != 0) {
123 | 			printf("Could not get depth\n");	
124 | 			return NULL;
125 | 		}
126 | 		return depthBuffer;
127 | 	}
128 | 
129 | 	/**
130 | 	 * Get tilt angle of kinect.
131 | 	 *
132 | 	 * @return Depth buffer data
133 | 	 */
134 | 	double GetTiltAngle()
135 | 	{
136 | 		int ret = freenect_sync_get_tilt_state(&tiltState, deviceIndex);
137 | 		if (ret != 0) {
138 | 			printf("Could not get tilt angle\n");
139 | 			return INVALID_TILT_DEGS;
140 | 		}
141 | 		double angle = freenect_get_tilt_degs(tiltState);
142 | 		return angle;
143 | 	}
144 | 
145 | 	/**
146 | 	 * Stop conecting to kinect device.
147 | 	 */
148 | 	 void Stop()
149 | 	 {
150 | 	 	freenect_sync_stop();
151 | 	 }
152 | 
153 | 	//------------------------------------------------------------------------
154 | 
155 | 	//------------------------------------------------------------------------
156 | 	// Export functions.
157 | 	//------------------------------------------------------------------------
158 | 
159 | 	/**
160 | 	 * Constructor for Node.js.
161 | 	 *
162 | 	 * @param args Constructor arguments passed from Node.js
163 | 	 * @return Freenect component for Node.js
164 | 	 */
165 | 	static v8::Handle<v8::Value> New(const v8::Arguments& args)
166 | 	{
167 | 		v8::HandleScope scope;
168 | 
169 | 		Freenect* freenect = new Freenect();
170 | 		freenect->Wrap(args.This());
171 | 		freenect->Ref();
172 | 		return args.This();
173 | 	}
174 | 
175 | 	/**
176 | 	 * Set LED options.
177 | 	 *
178 | 	 * @param args Arguments list.
179 | 	 * @return {Boolean} true if args is valid options.
180 | 	 */
181 | 	static v8::Handle<v8::Value> SetLed(const v8::Arguments& args)
182 | 	{
183 | 	  v8::HandleScope scope;
184 | 
185 | 		if (args.Length() != 1) {
186 | 			THROW_BAD_ARGS("SetLed must have 1 argument.")
187 | 		}
188 | 		
189 | 		v8::Local<v8::Value> ledOption = args[0];
190 | 		if (!ledOption->IsInt32()) {
191 | 			THROW_BAD_ARGS("SetLed must have 1 int argument.")
192 | 		}
193 | 
194 | 		int n = ledOption->Int32Value();
195 | 		if (n < LED_OFF) {
196 | 			n = LED_OFF;
197 | 		}
198 | 		if (n > LED_BLINK_RED_YELLOW) {
199 | 			n = LED_BLINK_RED_YELLOW;
200 | 		}
201 | 
202 | 		Freenect* freenect = getThis(args);
203 | 		bool ret = freenect->SetLed(static_cast<freenect_led_options>(n));
204 | 		return v8::Boolean::New(ret);
205 | 	}
206 | 
207 | 	/**
208 | 	 * Set tilt angle of kinect.
209 | 	 *
210 | 	 * @param args Arguments list.
211 | 	 * @return {Boolean} true if args is valid options.
212 | 	 */
213 | 	static v8::Handle<v8::Value> SetTiltAngle(const v8::Arguments& args)
214 | 	{
215 | 		v8::HandleScope scope;
216 | 
217 | 		if (args.Length() != 1) {
218 | 			THROW_BAD_ARGS("SetTiltAngle must have 1 argument.")
219 | 		}
220 | 		
221 | 		v8::Local<v8::Value> angle = args[0];
222 | 		if (!angle->IsNumber()) {
223 | 			THROW_BAD_ARGS("SetTiltAngle must have 1 number argument.")
224 | 		}
225 | 		
226 | 		double a = angle->NumberValue();
227 |     
228 | 		Freenect* freenect = getThis(args);
229 | 		bool ret = freenect->SetTiltAngle(a);
230 | 		return v8::Boolean::New(ret);
231 | 	}
232 | 
233 | 	/**
234 | 	 * Get RBG image of kinect.
235 | 	 *
236 | 	 * @param args Arguments list.
237 | 	 * @return {Array.<uint32>} RGB pixel data
238 | 	 */
239 | 	static v8::Handle<v8::Value> GetVideo(const v8::Arguments& args)
240 | 	{
241 | 	  v8::HandleScope scope;
242 | 
243 | 		Freenect* freenect = getThis(args);
244 | 		unsigned char* buf = static_cast<unsigned char*>(freenect->GetVideo());
245 | 		int length = freenect_find_video_mode(FREENECT_RESOLUTION_LOW, FREENECT_VIDEO_RGB).bytes;
246 | 		v8::Local<v8::Array> array = v8::Array::New(length);
247 | 		/*
248 | 		for (int i = 0; i < length; i+=16) {
249 | 			array->Set(i   , v8::Uint32::New(buf[i   ]));
250 | 			array->Set(i+1 , v8::Uint32::New(buf[i+ 1]));
251 | 			array->Set(i+2 , v8::Uint32::New(buf[i+ 2]));
252 | 			array->Set(i+3 , v8::Uint32::New(buf[i+ 3]));
253 | 			array->Set(i+4 , v8::Uint32::New(buf[i+ 4]));
254 | 			array->Set(i+5 , v8::Uint32::New(buf[i+ 5]));
255 | 			array->Set(i+6 , v8::Uint32::New(buf[i+ 6]));
256 | 			array->Set(i+7 , v8::Uint32::New(buf[i+ 7]));
257 | 			array->Set(i+8 , v8::Uint32::New(buf[i+ 8]));
258 | 			array->Set(i+9 , v8::Uint32::New(buf[i+ 9]));
259 | 			array->Set(i+10, v8::Uint32::New(buf[i+10]));
260 | 			array->Set(i+11, v8::Uint32::New(buf[i+11]));
261 | 			array->Set(i+12, v8::Uint32::New(buf[i+12]));
262 | 			array->Set(i+13, v8::Uint32::New(buf[i+13]));
263 | 			array->Set(i+14, v8::Uint32::New(buf[i+14]));
264 | 			array->Set(i+15, v8::Uint32::New(buf[i+15]));
265 | 		}
266 | 		*/
267 | 		return array;
268 | 	}
269 | 
270 | 	/**
271 | 	 * Get video buffer of kinect.
272 | 	 *
273 | 	 * @param args Arguments list.
274 | 	 * @return {Buffer} Video buffer data (RGB)
275 | 	 */
276 | 	static v8::Handle<v8::Value> GetVideoBuffer(const v8::Arguments& args)
277 | 	{
278 | 		v8::HandleScope scope;
279 | 
280 | 		Freenect* freenect = getThis(args);
281 | 		char* buf = static_cast<char*>(freenect->GetVideo());
282 | 		node::Buffer* retbuf = node::Buffer::New(buf, freenect_find_video_mode(FREENECT_RESOLUTION_LOW, FREENECT_VIDEO_RGB).bytes);
283 | 		return retbuf->handle_;
284 | 	}
285 | 	
286 | 	/**
287 | 	 * Get depth buffer of kinect.
288 | 	 *
289 | 	 * @param args Arguments list.
290 | 	 * @return {Array.<uint32>} Depth buffer data
291 | 	 */
292 | 	static v8::Handle<v8::Value> GetDepth(const v8::Arguments& args)
293 | 	{
294 | 		v8::HandleScope scope;
295 | 
296 | 		Freenect* freenect = getThis(args);
297 | 		uint16_t* buf = static_cast<uint16_t*>(freenect->GetDepth());
298 | 		int length = 640*480;
299 | 		v8::Local<v8::Array> array = v8::Array::New(length);
300 | 		for (int i = 0; i < length; i+=16) {
301 | 			array->Set(i   , v8::Uint32::New(buf[i   ]));
302 | 			array->Set(i+1 , v8::Uint32::New(buf[i+ 1]));
303 | 			array->Set(i+2 , v8::Uint32::New(buf[i+ 2]));
304 | 			array->Set(i+3 , v8::Uint32::New(buf[i+ 3]));
305 | 			array->Set(i+4 , v8::Uint32::New(buf[i+ 4]));
306 | 			array->Set(i+5 , v8::Uint32::New(buf[i+ 5]));
307 | 			array->Set(i+6 , v8::Uint32::New(buf[i+ 6]));
308 | 			array->Set(i+7 , v8::Uint32::New(buf[i+ 7]));
309 | 			array->Set(i+8 , v8::Uint32::New(buf[i+ 8]));
310 | 			array->Set(i+9 , v8::Uint32::New(buf[i+ 9]));
311 | 			array->Set(i+10, v8::Uint32::New(buf[i+10]));
312 | 			array->Set(i+11, v8::Uint32::New(buf[i+11]));
313 | 			array->Set(i+12, v8::Uint32::New(buf[i+12]));
314 | 			array->Set(i+13, v8::Uint32::New(buf[i+13]));
315 | 			array->Set(i+14, v8::Uint32::New(buf[i+14]));
316 | 			array->Set(i+15, v8::Uint32::New(buf[i+15]));
317 | 		}
318 | 		return array;
319 | 	}
320 | 
321 | 	/**
322 | 	 * Get depth buffer of kinect.
323 | 	 *
324 | 	 * @param args Arguments list.
325 | 	 * @return {Buffer} Depth buffer data
326 | 	 */
327 | 	static v8::Handle<v8::Value> GetDepthBuffer(const v8::Arguments& args)
328 | 	{
329 | 		printf("entering getdepth\n");
330 | 		v8::HandleScope scope;
331 | 		Freenect* freenect = getThis(args);
332 | 		uint16_t* buf = static_cast<uint16_t*>(freenect->GetDepth());
333 | 		freenect_frame_mode mode = freenect_find_depth_mode(FREENECT_RESOLUTION_MEDIUM, FREENECT_DEPTH_11BIT);
334 | 		int length = mode.width * mode.height;
335 | 		printf("valid:%d, width:%d, height:%d, length:%d\n", mode.is_valid, mode.width, mode.height, length);
336 | 		if(!mode.is_valid)
337 | 			return v8::Boolean::New(false);
338 | 		char *buf2 = (char *)malloc(length);//[640*480] = { 0,1,2,3,4,5 };
339 | 		printf("ptr buf=0x%08X, buf2=0x%08X\n", (unsigned long)buf, (unsigned long)buf2);
340 | 		for (int i = 0; i < length; i++) {
341 | 			buf2[i] = rand()&255;//buf[i] >> 2;
342 | 		}
343 | 		node::Buffer* retbuf = node::Buffer::New(buf2, length);
344 | 		free(buf2);
345 | 		printf("leaving getdepth\n");
346 | 		return retbuf->handle_;
347 | 	}
348 | 
349 | 	/**
350 | 	 * Get scaled depth buffer of kinect.
351 | 	 *
352 | 	 * @param args Arguments list.
353 | 	 * @return {Buffer} Depth buffer data
354 | 	 */
355 | 	static v8::Handle<v8::Value> GetScaledDepthBuffer(const v8::Arguments& args)
356 | 	{
357 | 
358 | 		if (args.Length() != 2) {
359 | 			THROW_BAD_ARGS("GetScaledDepthBuffer must have 2 arguments.")
360 | 		}
361 | 		
362 | 		v8::Local<v8::Value> w_param = args[0];
363 | 		v8::Local<v8::Value> h_param = args[1];
364 | 		if (!w_param->IsNumber() && !h_param->IsNumber()) {
365 | 			THROW_BAD_ARGS("SetTiltAngle must have 2 number argument.")
366 | 		}
367 | 		
368 | 		int outputwidth = (int)w_param->NumberValue();
369 | 		int outputheight = (int)h_param->NumberValue();
370 | 
371 | 		v8::HandleScope scope;
372 | 		Freenect* freenect = getThis(args);
373 | 		uint16_t* buf = static_cast<uint16_t*>(freenect->GetDepth());
374 | 		freenect_frame_mode mode = freenect_find_depth_mode(FREENECT_RESOLUTION_MEDIUM, FREENECT_DEPTH_11BIT);
375 | 		int length = mode.width * mode.height;
376 | 		int outputlength = outputwidth * outputheight;
377 | 		printf("valid:%d, width:%d (%d), height:%d (%d), length:%d\n", mode.is_valid, mode.width, outputwidth, mode.height, outputheight, length);
378 | 		char *buf2 = (char *)malloc(length);//[640*480] = { 0,1,2,3,4,5 };
379 | 		char *buf3 = (char *)malloc(outputlength);//[640*480] = { 0,1,2,3,4,5 };
380 | 		printf("ptr buf=0x%08X, buf2=0x%08X\n", (unsigned long)buf, (unsigned long)buf2);
381 | 
382 | 		// scale to bytes
383 | 		for (int i = 0; i < length; i++) {
384 | 			buf2[i] = buf[i] >> 2;
385 | 		}
386 | 
387 | 		// ugly downscaler
388 | 
389 | 		int oo = 0;
390 | 		int istride = mode.width;
391 | 		for(int j=0; j<outputheight; j++) {
392 | 			int iy = (j * mode.height) / outputheight;
393 | 			for(int i=0; i<outputwidth; i++) {
394 | 				int ix = (i * mode.width) / outputwidth;
395 | 				int s = buf2[iy * istride + ix];
396 | 				buf3[oo++] = s;
397 | 			}
398 | 		}
399 | 
400 | 		node::Buffer* retbuf = node::Buffer::New(buf3, outputlength);
401 | 		free(buf2);
402 | 		free(buf3);
403 | 		printf("leaving getdepth\n");
404 | 		return retbuf->handle_;
405 | 	}
406 | 
407 | 	/**
408 | 	 * Get tilt angle of kinect.
409 | 	 *
410 | 	 * @param args Arguments list.
411 | 	 * @return {Number} Depth buffer data
412 | 	 */
413 | 	static v8::Handle<v8::Value> GetTiltAngle(const v8::Arguments& args)
414 | 	{
415 | 	  v8::HandleScope scope;
416 | 
417 | 		Freenect* freenect = getThis(args);
418 | 		double angle = freenect->GetTiltAngle();
419 | 		return v8::Number::New(angle);
420 | 	}
421 | 
422 | 	/**
423 | 	 * Stop connecting to kinect.
424 | 	 *
425 | 	 * @param args Arguments list.
426 | 	 * @return {undefined}
427 | 	 */
428 | 	static v8::Handle<v8::Value> Stop(const v8::Arguments& args)
429 | 	{
430 | 		v8::HandleScope scope;
431 | 
432 | 		Freenect* freenect = getThis(args);
433 | 		freenect->Stop();
434 | 		return v8::Undefined();
435 | 	}
436 | 
437 | private:
438 | 	int deviceIndex;
439 | 	double tiltAngle;
440 | 
441 | 	freenect_led_options ledOption;
442 | 	freenect_raw_tilt_state* tiltState;
443 | 	freenect_video_format videoFormat;
444 | 	freenect_depth_format depthFormat;
445 | 
446 | 	void* videoBuffer;
447 | 	void* depthBuffer;
448 | 
449 | 	/**
450 | 	 * Get this pointer from v8::Arguments.
451 | 	 */
452 | 	static Freenect* getThis(const v8::Arguments& args)
453 | 	{
454 | 		Freenect* freenect = ObjectWrap::Unwrap<Freenect>(args.This());
455 | 		return freenect;
456 | 	}
457 | 
458 | };
459 | 
460 | //-------------------------------------------------------------------------
461 | // Node.js addon interfaces
462 | //-------------------------------------------------------------------------
463 | 
464 | extern "C" void init(v8::Handle<v8::Object> target)
465 | {
466 | 	v8::HandleScope scope;
467 | 
468 |   v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(Freenect::New);
469 | 	t->InstanceTemplate()->SetInternalFieldCount(1);
470 | 	NODE_SET_PROTOTYPE_METHOD(t, "setLed", Freenect::SetLed);
471 | 	NODE_SET_PROTOTYPE_METHOD(t, "setTiltAngle", Freenect::SetTiltAngle);
472 | 	NODE_SET_PROTOTYPE_METHOD(t, "getTiltAngle", Freenect::GetTiltAngle);
473 | 	NODE_SET_PROTOTYPE_METHOD(t, "getVideo", Freenect::GetVideo);
474 | 	NODE_SET_PROTOTYPE_METHOD(t, "getVideoBuffer", Freenect::GetVideoBuffer);
475 | 	NODE_SET_PROTOTYPE_METHOD(t, "getDepth", Freenect::GetDepth);
476 | 	NODE_SET_PROTOTYPE_METHOD(t, "getDepthBuffer", Freenect::GetDepthBuffer);
477 | 	NODE_SET_PROTOTYPE_METHOD(t, "getScaledDepthBuffer", Freenect::GetScaledDepthBuffer);
478 | 	NODE_SET_PROTOTYPE_METHOD(t, "stop", Freenect::Stop);
479 |   target->Set(v8::String::New("Kinect"), t->GetFunction());
480 | }
481 | 
482 | 
483 | 
484 | 


--------------------------------------------------------------------------------
/example/simpleviewer/public/javascripts/socket.io.js:
--------------------------------------------------------------------------------
1 | /* Socket.IO.min 0.6.2 @author Guillermo Rauch <guillermo@learnboost.com>, @license The MIT license., @copyright Copyright (c) 2010 LearnBoost <dev@learnboost.com> */
2 | var io=this.io={version:"0.6.2",setPath:function(a){window.console&&console.error&&console.error("io.setPath will be removed. Please set the variable WEB_SOCKET_SWF_LOCATION pointing to WebSocketMain.swf"),this.path=/\/$/.test(a)?a:a+"/",WEB_SOCKET_SWF_LOCATION=a+"lib/vendor/web-socket-js/WebSocketMain.swf"}};"jQuery"in this&&(jQuery.io=this.io),typeof window!="undefined"&&typeof WEB_SOCKET_SWF_LOCATION=="undefined"&&(WEB_SOCKET_SWF_LOCATION="/socket.io/lib/vendor/web-socket-js/WebSocketMain.swf"),function(){var a=this.io,b=!1;a.util={ios:!1,load:function(a){if(/loaded|complete/.test(document.readyState)||b)return a();"attachEvent"in window?window.attachEvent("onload",a):window.addEventListener("load",a,!1)},inherit:function(a,b){for(var c in b.prototype)a.prototype[c]=b.prototype[c]},indexOf:function(a,b,c){for(var d=a.length,e=c<0?Math.max(0,d+c):c||0;e<d;e++)if(a[e]===b)return e;return-1},isArray:function(a){return Object.prototype.toString.call(a)==="[object Array]"},merge:function(a,b){for(var c in b)b.hasOwnProperty(c)&&(a[c]=b[c])}},a.util.ios=/iphone|ipad/i.test(navigator.userAgent),a.util.android=/android/i.test(navigator.userAgent),a.util.opera=/opera/i.test(navigator.userAgent),a.util.load(function(){b=!0})}(),function(){var a=this.io,b="~m~",c=function(a){if(Object.prototype.toString.call(a)=="[object Object]"){if(!("JSON"in window)){"console"in window&&console.error&&console.error("Trying to encode as JSON, but JSON.stringify is missing.");return'{ "$error": "Invalid message" }'}return"~j~"+JSON.stringify(a)}return String(a)};Transport=a.Transport=function(b,c){this.base=b,this.options={timeout:15e3},a.util.merge(this.options,c)},Transport.prototype.send=function(){throw new Error("Missing send() implementation")},Transport.prototype.connect=function(){throw new Error("Missing connect() implementation")},Transport.prototype.disconnect=function(){throw new Error("Missing disconnect() implementation")},Transport.prototype._encode=function(d){var e="",f,d=a.util.isArray(d)?d:[d];for(var g=0,h=d.length;g<h;g++)f=d[g]===null||d[g]===undefined?"":c(d[g]),e+=b+f.length+b+f;return e},Transport.prototype._decode=function(a){var c=[],d,e;do{if(a.substr(0,3)!==b)return c;a=a.substr(3),d="",e="";for(var f=0,g=a.length;f<g;f++){e=Number(a.substr(f,1));if(a.substr(f,1)==e)d+=e;else{a=a.substr(d.length+b.length),d=Number(d);break}}c.push(a.substr(0,d)),a=a.substr(d)}while(a!=="");return c},Transport.prototype._onData=function(a){this._setTimeout();var b=this._decode(a);if(b&&b.length)for(var c=0,d=b.length;c<d;c++)this._onMessage(b[c])},Transport.prototype._setTimeout=function(){var a=this;this._timeout&&clearTimeout(this._timeout),this._timeout=setTimeout(function(){a._onTimeout()},this.options.timeout)},Transport.prototype._onTimeout=function(){this._onDisconnect()},Transport.prototype._onMessage=function(a){this.sessionid?a.substr(0,3)=="~h~"?this._onHeartbeat(a.substr(3)):a.substr(0,3)=="~j~"?this.base._onMessage(JSON.parse(a.substr(3))):this.base._onMessage(a):(this.sessionid=a,this._onConnect())},Transport.prototype._onHeartbeat=function(a){this.send("~h~"+a)},Transport.prototype._onConnect=function(){this.connected=!0,this.connecting=!1,this.base._onConnect(),this._setTimeout()},Transport.prototype._onDisconnect=function(){this.connecting=!1,this.connected=!1,this.sessionid=null,this.base._onDisconnect()},Transport.prototype._prepareUrl=function(){return(this.base.options.secure?"https":"http")+"://"+this.base.host+":"+this.base.options.port+"/"+this.base.options.resource+"/"+this.type+(this.sessionid?"/"+this.sessionid:"/")}}(),function(){var a=this.io,b=new Function,c=function(){if(!("XMLHttpRequest"in window))return!1;var a=new XMLHttpRequest;return a.withCredentials!=undefined}(),d=function(a){if("XDomainRequest"in window&&a)return new XDomainRequest;if("XMLHttpRequest"in window&&(!a||c))return new XMLHttpRequest;if(!a){try{var b=new ActiveXObject("MSXML2.XMLHTTP");return b}catch(d){}try{var e=new ActiveXObject("Microsoft.XMLHTTP");return e}catch(d){}}return!1},e=a.Transport.XHR=function(){a.Transport.apply(this,arguments),this._sendBuffer=[]};a.util.inherit(e,a.Transport),e.prototype.connect=function(){this._get();return this},e.prototype._checkSend=function(){if(!this._posting&&this._sendBuffer.length){var a=this._encode(this._sendBuffer);this._sendBuffer=[],this._send(a)}},e.prototype.send=function(b){a.util.isArray(b)?this._sendBuffer.push.apply(this._sendBuffer,b):this._sendBuffer.push(b),this._checkSend();return this},e.prototype._send=function(a){var c=this;this._posting=!0,this._sendXhr=this._request("send","POST"),this._sendXhr.onreadystatechange=function(){var a;if(c._sendXhr.readyState==4){c._sendXhr.onreadystatechange=b;try{a=c._sendXhr.status}catch(d){}c._posting=!1,a==200?c._checkSend():c._onDisconnect()}},this._sendXhr.send("data="+encodeURIComponent(a))},e.prototype.disconnect=function(){this._onDisconnect();return this},e.prototype._onDisconnect=function(){if(this._xhr){this._xhr.onreadystatechange=b;try{this._xhr.abort()}catch(c){}this._xhr=null}if(this._sendXhr){this._sendXhr.onreadystatechange=b;try{this._sendXhr.abort()}catch(c){}this._sendXhr=null}this._sendBuffer=[],a.Transport.prototype._onDisconnect.call(this)},e.prototype._request=function(a,b,c){var e=d(this.base._isXDomain());c&&(e.multipart=!0),e.open(b||"GET",this._prepareUrl()+(a?"/"+a:"")),b=="POST"&&"setRequestHeader"in e&&e.setRequestHeader("Content-type","application/x-www-form-urlencoded; charset=utf-8");return e},e.check=function(a){try{if(d(a))return!0}catch(b){}return!1},e.xdomainCheck=function(){return e.check(!0)},e.request=d}(),function(){var a=this.io,b=a.Transport.websocket=function(){a.Transport.apply(this,arguments)};a.util.inherit(b,a.Transport),b.prototype.type="websocket",b.prototype.connect=function(){var a=this;this.socket=new WebSocket(this._prepareUrl()),this.socket.onmessage=function(b){a._onData(b.data)},this.socket.onclose=function(b){a._onClose()},this.socket.onerror=function(b){a._onError(b)};return this},b.prototype.send=function(a){this.socket&&this.socket.send(this._encode(a));return this},b.prototype.disconnect=function(){this.socket&&this.socket.close();return this},b.prototype._onClose=function(){this._onDisconnect();return this},b.prototype._onError=function(a){this.base.emit("error",[a])},b.prototype._prepareUrl=function(){return(this.base.options.secure?"wss":"ws")+"://"+this.base.host+":"+this.base.options.port+"/"+this.base.options.resource+"/"+this.type+(this.sessionid?"/"+this.sessionid:"")},b.check=function(){return"WebSocket"in window&&WebSocket.prototype&&WebSocket.prototype.send&&!!WebSocket.prototype.send.toString().match(/native/i)&&typeof WebSocket!="undefined"},b.xdomainCheck=function(){return!0}}(),function(){var a=this.io,b=a.Transport.flashsocket=function(){a.Transport.websocket.apply(this,arguments)};a.util.inherit(b,a.Transport.websocket),b.prototype.type="flashsocket",b.prototype.connect=function(){var b=this,c=arguments;WebSocket.__addTask(function(){a.Transport.websocket.prototype.connect.apply(b,c)});return this},b.prototype.send=function(){var b=this,c=arguments;WebSocket.__addTask(function(){a.Transport.websocket.prototype.send.apply(b,c)});return this},b.check=function(){if(typeof WebSocket=="undefined"||!("__addTask"in WebSocket))return!1;if(a.util.opera)return!1;if("navigator"in window&&"plugins"in navigator&&navigator.plugins["Shockwave Flash"])return!!navigator.plugins["Shockwave Flash"].description;if("ActiveXObject"in window)try{return!!(new ActiveXObject("ShockwaveFlash.ShockwaveFlash")).GetVariable("$version")}catch(b){}return!1},b.xdomainCheck=function(){return!0}}(),function(){var a=this.io,b=a.Transport.htmlfile=function(){a.Transport.XHR.apply(this,arguments)};a.util.inherit(b,a.Transport.XHR),b.prototype.type="htmlfile",b.prototype._get=function(){var a=this;this._open(),window.attachEvent("onunload",function(){a._destroy()})},b.prototype._open=function(){this._doc=new ActiveXObject("htmlfile"),this._doc.open(),this._doc.write("<html></html>"),this._doc.parentWindow.s=this,this._doc.close();var a=this._doc.createElement("div");this._doc.body.appendChild(a),this._iframe=this._doc.createElement("iframe"),a.appendChild(this._iframe),this._iframe.src=this._prepareUrl()+"/"+ +(new Date)},b.prototype._=function(a,b){this._onData(a);var c=b.getElementsByTagName("script")[0];c.parentNode.removeChild(c)},b.prototype._destroy=function(){this._iframe&&(this._iframe.src="about:blank",this._doc=null,CollectGarbage())},b.prototype.disconnect=function(){this._destroy();return a.Transport.XHR.prototype.disconnect.call(this)},b.check=function(){if("ActiveXObject"in window)try{var b=new ActiveXObject("htmlfile");return b&&a.Transport.XHR.check()}catch(c){}return!1},b.xdomainCheck=function(){return!1}}(),function(){var a=this.io,b=a.Transport["xhr-multipart"]=function(){a.Transport.XHR.apply(this,arguments)};a.util.inherit(b,a.Transport.XHR),b.prototype.type="xhr-multipart",b.prototype._get=function(){var a=this;this._xhr=this._request("","GET",!0),this._xhr.onreadystatechange=function(){a._xhr.readyState==4&&a._onData(a._xhr.responseText)},this._xhr.send(null)},b.check=function(){return"XMLHttpRequest"in window&&"prototype"in XMLHttpRequest&&"multipart"in XMLHttpRequest.prototype},b.xdomainCheck=function(){return!0}}(),function(){var a=this.io,b=new Function,c=a.Transport["xhr-polling"]=function(){a.Transport.XHR.apply(this,arguments)};a.util.inherit(c,a.Transport.XHR),c.prototype.type="xhr-polling",c.prototype.connect=function(){if(a.util.ios||a.util.android){var b=this;a.util.load(function(){setTimeout(function(){a.Transport.XHR.prototype.connect.call(b)},10)})}else a.Transport.XHR.prototype.connect.call(this)},c.prototype._get=function(){var a=this;this._xhr=this._request(+(new Date),"GET"),this._xhr.onreadystatechange=function(){var c;if(a._xhr.readyState==4){a._xhr.onreadystatechange=b;try{c=a._xhr.status}catch(d){}c==200?(a._onData(a._xhr.responseText),a._get()):a._onDisconnect()}},this._xhr.send(null)},c.check=function(){return a.Transport.XHR.check()},c.xdomainCheck=function(){return a.Transport.XHR.xdomainCheck()}}(),function(){var a=this.io;a.JSONP=[],JSONPPolling=a.Transport["jsonp-polling"]=function(){a.Transport.XHR.apply(this,arguments),this._insertAt=document.getElementsByTagName("script")[0],this._index=a.JSONP.length,a.JSONP.push(this)},a.util.inherit(JSONPPolling,a.Transport["xhr-polling"]),JSONPPolling.prototype.type="jsonp-polling",JSONPPolling.prototype._send=function(a){function h(){b._iframe&&b._form.removeChild(b._iframe);try{f=document.createElement('<iframe name="'+b._iframeId+'">')}catch(a){f=document.createElement("iframe"),f.name=b._iframeId}f.id=b._iframeId,b._form.appendChild(f),b._iframe=f}function g(){h(),b._posting=!1,b._checkSend()}var b=this;if(!("_form"in this)){var c=document.createElement("FORM"),d=document.createElement("TEXTAREA"),e=this._iframeId="socket_io_iframe_"+this._index,f;c.style.position="absolute",c.style.top="-1000px",c.style.left="-1000px",c.target=e,c.method="POST",c.action=this._prepareUrl()+"/"+ +(new Date)+"/"+this._index,d.name="data",c.appendChild(d),this._insertAt.parentNode.insertBefore(c,this._insertAt),document.body.appendChild(c),this._form=c,this._area=d}h(),this._posting=!0,this._area.value=a;try{this._form.submit()}catch(i){}this._iframe.attachEvent?f.onreadystatechange=function(){b._iframe.readyState=="complete"&&g()}:this._iframe.onload=g},JSONPPolling.prototype._get=function(){var a=this,b=document.createElement("SCRIPT");this._script&&(this._script.parentNode.removeChild(this._script),this._script=null),b.async=!0,b.src=this._prepareUrl()+"/"+ +(new Date)+"/"+this._index,b.onerror=function(){a._onDisconnect()},this._insertAt.parentNode.insertBefore(b,this._insertAt),this._script=b},JSONPPolling.prototype._=function(){this._onData.apply(this,arguments),this._get();return this},JSONPPolling.check=function(){return!0},JSONPPolling.xdomainCheck=function(){return!0}}(),function(){var a=this.io,b=a.Socket=function(b,c){this.host=b||document.domain,this.options={secure:!1,document:document,port:document.location.port||80,resource:"socket.io",transports:["websocket","flashsocket","htmlfile","xhr-multipart","xhr-polling","jsonp-polling"],transportOptions:{"xhr-polling":{timeout:25e3},"jsonp-polling":{timeout:25e3}},connectTimeout:5e3,reconnect:!0,reconnectionDelay:500,maxReconnectionAttempts:10,tryTransportsOnConnectTimeout:!0,rememberTransport:!0},a.util.merge(this.options,c),this.connected=!1,this.connecting=!1,this._events={},this.transport=this.getTransport(),!this.transport&&"console"in window&&console.error("No transport available")};b.prototype.getTransport=function(b){var c=b||this.options.transports,d;this.options.rememberTransport&&!b&&(d=this.options.document.cookie.match("(?:^|;)\\s*socketio=([^;]*)"),d&&(this._rememberedTransport=!0,c=[decodeURIComponent(d[1])]));for(var e=0,f;f=c[e];e++)if(a.Transport[f]&&a.Transport[f].check()&&(!this._isXDomain()||a.Transport[f].xdomainCheck()))return new a.Transport[f](this,this.options.transportOptions[f]||{});return null},b.prototype.connect=function(){if(this.transport&&!this.connected){this.connecting&&this.disconnect(!0),this.connecting=!0,this.emit("connecting",[this.transport.type]),this.transport.connect();if(this.options.connectTimeout){var a=this;this.connectTimeoutTimer=setTimeout(function(){if(!a.connected){a.disconnect(!0);if(a.options.tryTransportsOnConnectTimeout&&!a._rememberedTransport){a._remainingTransports||(a._remainingTransports=a.options.transports.slice(0));var b=a._remainingTransports;while(b.length>0&&b.splice(0,1)[0]!=a.transport.type);b.length&&(a.transport=a.getTransport(b),a.connect())}(!a._remainingTransports||a._remainingTransports.length==0)&&a.emit("connect_failed")}a._remainingTransports&&a._remainingTransports.length==0&&delete a._remainingTransports},this.options.connectTimeout)}}return this},b.prototype.send=function(a){if(!this.transport||!this.transport.connected)return this._queue(a);this.transport.send(a);return this},b.prototype.disconnect=function(a){this.connectTimeoutTimer&&clearTimeout(this.connectTimeoutTimer),a||(this.options.reconnect=!1),this.transport.disconnect();return this},b.prototype.on=function(a,b){a in this._events||(this._events[a]=[]),this._events[a].push(b);return this},b.prototype.emit=function(a,b){if(a in this._events){var c=this._events[a].concat();for(var d=0,e=c.length;d<e;d++)c[d].apply(this,b===undefined?[]:b)}return this},b.prototype.removeEvent=function(a,b){if(a in this._events)for(var c=0,d=this._events[a].length;c<d;c++)this._events[a][c]==b&&this._events[a].splice(c,1);return this},b.prototype._queue=function(a){"_queueStack"in this||(this._queueStack=[]),this._queueStack.push(a);return this},b.prototype._doQueue=function(){if(!("_queueStack"in this)||!this._queueStack.length)return this;this.transport.send(this._queueStack),this._queueStack=[];return this},b.prototype._isXDomain=function(){var a=window.location.port||80;return this.host!==document.domain||this.options.port!=a},b.prototype._onConnect=function(){this.connected=!0,this.connecting=!1,this._doQueue(),this.options.rememberTransport&&(this.options.document.cookie="socketio="+encodeURIComponent(this.transport.type)),this.emit("connect")},b.prototype._onMessage=function(a){this.emit("message",[a])},b.prototype._onDisconnect=function(){var a=this.connected;this.connected=!1,this.connecting=!1,this._queueStack=[],a&&(this.emit("disconnect"),this.options.reconnect&&!this.reconnecting&&this._onReconnect())},b.prototype._onReconnect=function(){function e(){if(!!a.reconnecting)if(!a.connected){if(a.connecting&&a.reconnecting)return a.reconnectionTimer=setTimeout(e,1e3);a.reconnectionAttempts++>=a.options.maxReconnectionAttempts?a.redoTransports?(a.emit("reconnect_failed"),d()):(a.on("connect_failed",e),a.options.tryTransportsOnConnectTimeout=!0,a.transport=a.getTransport(a.options.transports),a.redoTransports=!0,a.connect()):(a.reconnectionDelay*=2,a.connect(),a.emit("reconnecting",[a.reconnectionDelay,a.reconnectionAttempts]),a.reconnectionTimer=setTimeout(e,a.reconnectionDelay))}else d()}function d(){a.connected&&a.emit("reconnect",[a.transport.type,a.reconnectionAttempts]),a.removeEvent("connect_failed",e).removeEvent("connect",e),delete a.reconnecting,delete a.reconnectionAttempts,delete a.reconnectionDelay,delete a.reconnectionTimer,delete a.redoTransports,a.options.tryTransportsOnConnectTimeout=b,a.options.rememberTransport=c;return}this.reconnecting=!0,this.reconnectionAttempts=0,this.reconnectionDelay=this.options.reconnectionDelay;var a=this,b=this.options.tryTransportsOnConnectTimeout,c=this.options.rememberTransport;this.options.tryTransportsOnConnectTimeout=!1,this.reconnectionTimer=setTimeout(e,this.reconnectionDelay),this.on("connect",e)},b.prototype.fire=b.prototype.emit,b.prototype.addListener=b.prototype.addEvent=b.prototype.addEventListener=b.prototype.on,b.prototype.removeListener=b.prototype.removeEventListener=b.prototype.removeEvent}();var swfobject=function(){function V(b){var c=/[\\\"<>\.;]/,d=c.exec(b)!=null;return d&&typeof encodeURIComponent!=a?encodeURIComponent(b):b}function U(a,b){if(!!x){var c=b?"visible":"hidden";t&&P(a)?P(a).style.visibility=c:T("#"+a,"visibility:"+c)}}function T(c,d,e,f){if(!y.ie||!y.mac){var g=i.getElementsByTagName("head")[0];if(!g)return;var h=e&&typeof e=="string"?e:"screen";f&&(v=null,w=null);if(!v||w!=h){var j=Q("style");j.setAttribute("type","text/css"),j.setAttribute("media",h),v=g.appendChild(j),y.ie&&y.win&&typeof i.styleSheets!=a&&i.styleSheets.length>0&&(v=i.styleSheets[i.styleSheets.length-1]),w=h}y.ie&&y.win?v&&typeof v.addRule==b&&v.addRule(c,d):v&&typeof i.createTextNode!=a&&v.appendChild(i.createTextNode(c+" {"+d+"}"))}}function S(a){var b=y.pv,c=a.split(".");c[0]=parseInt(c[0],10),c[1]=parseInt(c[1],10)||0,c[2]=parseInt(c[2],10)||0;return b[0]>c[0]||b[0]==c[0]&&b[1]>c[1]||b[0]==c[0]&&b[1]==c[1]&&b[2]>=c[2]?!0:!1}function R(a,b,c){a.attachEvent(b,c),o[o.length]=[a,b,c]}function Q(a){return i.createElement(a)}function P(a){var b=null;try{b=i.getElementById(a)}catch(c){}return b}function O(a){var b=P(a);if(b){for(var c in b)typeof b[c]=="function"&&(b[c]=null);b.parentNode.removeChild(b)}}function N(a){var b=P(a);b&&b.nodeName=="OBJECT"&&(y.ie&&y.win?(b.style.display="none",function(){b.readyState==4?O(a):setTimeout(arguments.callee,10)}()):b.parentNode.removeChild(b))}function M(a,b,c){var d=Q("param");d.setAttribute("name",b),d.setAttribute("value",c),a.appendChild(d)}function L(c,d,f){var g,h=P(f);if(y.wk&&y.wk<312)return g;if(h){typeof c.id==a&&(c.id=f);if(y.ie&&y.win){var i="";for(var j in c)c[j]!=Object.prototype[j]&&(j.toLowerCase()=="data"?d.movie=c[j]:j.toLowerCase()=="styleclass"?i+=' class="'+c[j]+'"':j.toLowerCase()!="classid"&&(i+=" "+j+'="'+c[j]+'"'));var k="";for(var l in d)d[l]!=Object.prototype[l]&&(k+='<param name="'+l+'" value="'+d[l]+'" />');h.outerHTML='<object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"'+i+">"+k+"</object>",n[n.length]=c.id,g=P(c.id)}else{var m=Q(b);m.setAttribute("type",e);for(var o in c)c[o]!=Object.prototype[o]&&(o.toLowerCase()=="styleclass"?m.setAttribute("class",c[o]):o.toLowerCase()!="classid"&&m.setAttribute(o,c[o]));for(var p in d)d[p]!=Object.prototype[p]&&p.toLowerCase()!="movie"&&M(m,p,d[p]);h.parentNode.replaceChild(m,h),g=m}}return g}function K(a){var c=Q("div");if(y.win&&y.ie)c.innerHTML=a.innerHTML;else{var d=a.getElementsByTagName(b)[0];if(d){var e=d.childNodes;if(e){var f=e.length;for(var g=0;g<f;g++)(e[g].nodeType!=1||e[g].nodeName!="PARAM")&&e[g].nodeType!=8&&c.appendChild(e[g].cloneNode(!0))}}}return c}function J(a){if(y.ie&&y.win&&a.readyState!=4){var b=Q("div");a.parentNode.insertBefore(b,a),b.parentNode.replaceChild(K(a),b),a.style.display="none",function(){a.readyState==4?a.parentNode.removeChild(a):setTimeout(arguments.callee,10)}()}else a.parentNode.replaceChild(K(a),a)}function I(b,c,d,e){u=!0,r=e||null,s={success:!1,id:d};var g=P(d);if(g){g.nodeName=="OBJECT"?(p=K(g),q=null):(p=g,q=d),b.id=f;if(typeof b.width==a||!/%$/.test(b.width)&&parseInt(b.width,10)<310)b.width="310";if(typeof b.height==a||!/%$/.test(b.height)&&parseInt(b.height,10)<137)b.height="137";i.title=i.title.slice(0,47)+" - Flash Player Installation";var j=y.ie&&y.win?"ActiveX":"PlugIn",k="MMredirectURL="+h.location.toString().replace(/&/g,"%26")+"&MMplayerType="+j+"&MMdoctitle="+i.title;typeof c.flashvars!=a?c.flashvars+="&"+k:c.flashvars=k;if(y.ie&&y.win&&g.readyState!=4){var l=Q("div");d+="SWFObjectNew",l.setAttribute("id",d),g.parentNode.insertBefore(l,g),g.style.display="none",function(){g.readyState==4?g.parentNode.removeChild(g):setTimeout(arguments.callee,10)}()}L(b,c,d)}}function H(){return!u&&S("6.0.65")&&(y.win||y.mac)&&!(y.wk&&y.wk<312)}function G(c){var d=null,e=P(c);if(e&&e.nodeName=="OBJECT")if(typeof e.SetVariable!=a)d=e;else{var f=e.getElementsByTagName(b)[0];f&&(d=f)}return d}function F(){var b=m.length;if(b>0)for(var c=0;c<b;c++){var d=m[c].id,e=m[c].callbackFn,f={success:!1,id:d};if(y.pv[0]>0){var g=P(d);if(g)if(S(m[c].swfVersion)&&!(y.wk&&y.wk<312))U(d,!0),e&&(f.success=!0,f.ref=G(d),e(f));else if(m[c].expressInstall&&H()){var h={};h.data=m[c].expressInstall,h.width=g.getAttribute("width")||"0",h.height=g.getAttribute("height")||"0",g.getAttribute("class")&&(h.styleclass=g.getAttribute("class")),g.getAttribute("align")&&(h.align=g.getAttribute("align"));var i={},j=g.getElementsByTagName("param"),k=j.length;for(var l=0;l<k;l++)j[l].getAttribute("name").toLowerCase()!="movie"&&(i[j[l].getAttribute("name")]=j[l].getAttribute("value"));I(h,i,d,e)}else J(g),e&&e(f)}else{U(d,!0);if(e){var n=G(d);n&&typeof n.SetVariable!=a&&(f.success=!0,f.ref=n),e(f)}}}}function E(){var c=i.getElementsByTagName("body")[0],d=Q(b);d.setAttribute("type",e);var f=c.appendChild(d);if(f){var g=0;(function(){if(typeof f.GetVariable!=a){var b=f.GetVariable("$version");b&&(b=b.split(" ")[1].split(","),y.pv=[parseInt(b[0],10),parseInt(b[1],10),parseInt(b[2],10)])}else if(g<10){g++,setTimeout(arguments.callee,10);return}c.removeChild(d),f=null,F()})()}else F()}function D(){k?E():F()}function C(b){if(typeof h.addEventListener!=a)h.addEventListener("load",b,!1);else if(typeof i.addEventListener!=a)i.addEventListener("load",b,!1);else if(typeof h.attachEvent!=a)R(h,"onload",b);else if(typeof h.onload=="function"){var c=h.onload;h.onload=function(){c(),b()}}else h.onload=b}function B(a){t?a():l[l.length]=a}function A(){if(!t){try{var a=i.getElementsByTagName("body")[0].appendChild(Q("span"));a.parentNode.removeChild(a)}catch(b){return}t=!0;var c=l.length;for(var d=0;d<c;d++)l[d]()}}var a="undefined",b="object",c="Shockwave Flash",d="ShockwaveFlash.ShockwaveFlash",e="application/x-shockwave-flash",f="SWFObjectExprInst",g="onreadystatechange",h=window,i=document,j=navigator,k=!1,l=[D],m=[],n=[],o=[],p,q,r,s,t=!1,u=!1,v,w,x=!0,y=function(){var f=typeof i.getElementById!=a&&typeof i.getElementsByTagName!=a&&typeof i.createElement!=a,g=j.userAgent.toLowerCase(),l=j.platform.toLowerCase(),m=l?/win/.test(l):/win/.test(g),n=l?/mac/.test(l):/mac/.test(g),o=/webkit/.test(g)?parseFloat(g.replace(/^.*webkit\/(\d+(\.\d+)?).*$/,"$1")):!1,p=!1,q=[0,0,0],r=null;if(typeof j.plugins!=a&&typeof j.plugins[c]==b)r=j.plugins[c].description,r&&(typeof j.mimeTypes==a||!j.mimeTypes[e]||!!j.mimeTypes[e].enabledPlugin)&&(k=!0,p=!1,r=r.replace(/^.*\s+(\S+\s+\S+$)/,"$1"),q[0]=parseInt(r.replace(/^(.*)\..*$/,"$1"),10),q[1]=parseInt(r.replace(/^.*\.(.*)\s.*$/,"$1"),10),q[2]=/[a-zA-Z]/.test(r)?parseInt(r.replace(/^.*[a-zA-Z]+(.*)$/,"$1"),10):0);else if(typeof h.ActiveXObject!=a)try{var s=new ActiveXObject(d);s&&(r=s.GetVariable("$version"),r&&(p=!0,r=r.split(" ")[1].split(","),q=[parseInt(r[0],10),parseInt(r[1],10),parseInt(r[2],10)]))}catch(t){}return{w3:f,pv:q,wk:o,ie:p,win:m,mac:n}}(),z=function(){!y.w3||((typeof i.readyState!=a&&i.readyState=="complete"||typeof i.readyState==a&&(i.getElementsByTagName("body")[0]||i.body))&&A(),t||(typeof i.addEventListener!=a&&i.addEventListener("DOMContentLoaded",A,!1),y.ie&&y.win&&(i.attachEvent(g,function(){i.readyState=="complete"&&(i.detachEvent(g,arguments.callee),A())}),h==top&&function(){if(!t){try{i.documentElement.doScroll("left")}catch(a){setTimeout(arguments.callee,0);return}A()}}()),y.wk&&function(){if(!t){if(!/loaded|complete/.test(i.readyState)){setTimeout(arguments.callee,0);return}A()}}(),C(A)))}(),W=function(){y.ie&&y.win&&window.attachEvent("onunload",function(){var a=o.length;for(var b=0;b<a;b++)o[b][0].detachEvent(o[b][1],o[b][2]);var c=n.length;for(var d=0;d<c;d++)N(n[d]);for(var e in y)y[e]=null;y=null;for(var f in swfobject)swfobject[f]=null;swfobject=null})}();return{registerObject:function(a,b,c,d){if(y.w3&&a&&b){var e={};e.id=a,e.swfVersion=b,e.expressInstall=c,e.callbackFn=d,m[m.length]=e,U(a,!1)}else d&&d({success:!1,id:a})},getObjectById:function(a){if(y.w3)return G(a)},embedSWF:function(c,d,e,f,g,h,i,j,k,l){var m={success:!1,id:d};y.w3&&!(y.wk&&y.wk<312)&&c&&d&&e&&f&&g?(U(d,!1),B(function(){e+="",f+="";var n={};if(k&&typeof k===b)for(var o in k)n[o]=k[o];n.data=c,n.width=e,n.height=f;var p={};if(j&&typeof j===b)for(var q in j)p[q]=j[q];if(i&&typeof i===b)for(var r in i)typeof p.flashvars!=a?p.flashvars+="&"+r+"="+i[r]:p.flashvars=r+"="+i[r];if(S(g)){var s=L(n,p,d);n.id==d&&U(d,!0),m.success=!0,m.ref=s}else{if(h&&H()){n.data=h,I(n,p,d,l);return}U(d,!0)}l&&l(m)})):l&&l(m)},switchOffAutoHideShow:function(){x=!1},ua:y,getFlashPlayerVersion:function(){return{major:y.pv[0],minor:y.pv[1],release:y.pv[2]}},hasFlashPlayerVersion:S,createSWF:function(a,b,c){return y.w3?L(a,b,c):undefined},showExpressInstall:function(a,b,c,d){y.w3&&H()&&I(a,b,c,d)},removeSWF:function(a){y.w3&&N(a)},createCSS:function(a,b,c,d){y.w3&&T(a,b,c,d)},addDomLoadEvent:B,addLoadEvent:C,getQueryParamValue:function(a){var b=i.location.search||i.location.hash;if(b){/\?/.test(b)&&(b=b.split("?")[1]);if(a==null)return V(b);var c=b.split("&");for(var d=0;d<c.length;d++)if(c[d].substring(0,c[d].indexOf("="))==a)return V(c[d].substring(c[d].indexOf("=")+1))}return""},expressInstallCallback:function(){if(u){var a=P(f);a&&p&&(a.parentNode.replaceChild(p,a),q&&(U(q,!0),y.ie&&y.win&&(p.style.display="block")),r&&r(s)),u=!1}}}}();(function(){function b(){}if(!window.WebSocket){var a=window.console;if(!a||!a.log||!a.error)a={log:function(){},error:function(){}};if(!swfobject.hasFlashPlayerVersion("10.0.0")){a.error("Flash Player >= 10.0.0 is required.");return}location.protocol=="file:"&&a.error("WARNING: web-socket-js doesn't work in file:///... URL unless you set Flash Security Settings properly. Open the page via Web server i.e. http://..."),WebSocket=function(a,b,c,d,e){var f=this;f.__id=WebSocket.__nextId++,WebSocket.__instances[f.__id]=f,f.readyState=WebSocket.CONNECTING,f.bufferedAmount=0,setTimeout(function(){WebSocket.__addTask(function(){WebSocket.__flash.create(f.__id,a,b,c||null,d||0,e||null)})},0)},WebSocket.prototype.send=function(a){if(this.readyState==WebSocket.CONNECTING)throw"INVALID_STATE_ERR: Web Socket connection has not been established";var b=WebSocket.__flash.send(this.__id,encodeURIComponent(a));if(b<0)return!0;this.bufferedAmount+=b;return!1},WebSocket.prototype.close=function(){this.readyState!=WebSocket.CLOSED&&this.readyState!=WebSocket.CLOSING&&(this.readyState=WebSocket.CLOSING,WebSocket.__flash.close(this.__id))},WebSocket.prototype.addEventListener=function(a,b,c){"__events"in this||(this.__events={}),a in this.__events||(this.__events[a]=[],"function"==typeof this["on"+a]&&(this.__events[a].defaultHandler=this["on"+a],this["on"+a]=this.__createEventHandler(this,a))),this.__events[a].push(b)},WebSocket.prototype.removeEventListener=function(a,b,c){"__events"in this||(this.__events={});if(a in this.__events)for(var d=this.__events.length;d>-1;--d)if(b===this.__events[a][d]){this.__events[a].splice(d,1);break}},WebSocket.prototype.dispatchEvent=function(a){if(!("__events"in this))throw"UNSPECIFIED_EVENT_TYPE_ERR";if(!(a.type in this.__events))throw"UNSPECIFIED_EVENT_TYPE_ERR";for(var b=0,c=this.__events[a.type].length;b<c;++b){this.__events[a.type][b](a);if(a.cancelBubble)break}!1!==a.returnValue&&"function"==typeof this.__events[a.type].defaultHandler&&this.__events[a.type].defaultHandler(a)},WebSocket.prototype.__handleEvent=function(b){"readyState"in b&&(this.readyState=b.readyState);try{if(b.type=="open")this.onopen&&this.onopen();else if(b.type=="close")this.onclose&&this.onclose();else if(b.type=="error")this.onerror&&this.onerror(b);else{if(b.type!="message")throw"unknown event type: "+b.type;if(this.onmessage){var c=decodeURIComponent(b.message),d;window.MessageEvent&&!window.opera?(d=document.createEvent("MessageEvent"),d.initMessageEvent("message",!1,!1,c,null,null,window,null)):d={data:c},this.onmessage(d)}}}catch(d){a.error(d.toString())}},WebSocket.prototype.__createEventHandler=function(a,c){return function(d){var e=new b;e.initEvent(c,!0,!0),e.target=e.currentTarget=a;for(var f in d)e[f]=d[f];a.dispatchEvent(e,arguments)}},WebSocket.CONNECTING=0,WebSocket.OPEN=1,WebSocket.CLOSING=2,WebSocket.CLOSED=3,WebSocket.__flash=null,WebSocket.__instances={},WebSocket.__tasks=[],WebSocket.__nextId=0,WebSocket.__initialize=function(){if(!WebSocket.__flash){WebSocket.__swfLocation&&(window.WEB_SOCKET_SWF_LOCATION=WebSocket.__swfLocation);if(!window.WEB_SOCKET_SWF_LOCATION){a.error("[WebSocket] set WEB_SOCKET_SWF_LOCATION to location of WebSocketMain.swf");return}var b=document.createElement("div");b.id="webSocketContainer",b.style.position="absolute",WebSocket.__isFlashLite()?(b.style.left="0px",b.style.top="0px"):(b.style.left="-100px",b.style.top="-100px");var c=document.createElement("div");c.id="webSocketFlash",b.appendChild(c),document.body.appendChild(b),swfobject.embedSWF(WEB_SOCKET_SWF_LOCATION,"webSocketFlash","1","1","10.0.0",null,null,{hasPriority:!0,swliveconnect:!0,allowScriptAccess:"always"},null,function(b){b.success||a.error("[WebSocket] swfobject.embedSWF failed")})}},WebSocket.loadFlashPolicyFile=function(a){WebSocket.__addTask(function(){WebSocket.__flash.loadManualPolicyFile(a)})},WebSocket.__onFlashInitialized=function(){setTimeout(function(){WebSocket.__flash=document.getElementById("webSocketFlash"),WebSocket.__flash.setCallerUrl(location.href),WebSocket.__flash.setDebug(!!window.WEB_SOCKET_DEBUG);for(var a=0;a<WebSocket.__tasks.length;++a)WebSocket.__tasks[a]();WebSocket.__tasks=[]},0)},WebSocket.__onFlashEvent=function(){setTimeout(function(){var a=WebSocket.__flash.receiveEvents();for(var b=0;b<a.length;++b)WebSocket.__instances[a[b].webSocketId].__handleEvent(a[b])},0);return!0},WebSocket.__log=function(b){a.log(decodeURIComponent(b))},WebSocket.__error=function(b){a.error(decodeURIComponent(b))},WebSocket.__addTask=function(a){WebSocket.__flash?a():WebSocket.__tasks.push(a)},WebSocket.__isFlashLite=function(){if(!window.navigator||!window.navigator.mimeTypes)return!1;var a=window.navigator.mimeTypes["application/x-shockwave-flash"];if(!a||!a.enabledPlugin||!a.enabledPlugin.filename)return!1;return a.enabledPlugin.filename.match(/flashlite/i)?!0:!1},b.prototype.cancelable=!0,b.prototype.cancelBubble=!1,b.prototype.preventDefault=function(){this.cancelable&&(this.returnValue=!1)},b.prototype.stopPropagation=function(){this.cancelBubble=!0},b.prototype.initEvent=function(a,b,c){this.type=a,this.cancelable=c,this.timeStamp=new Date},window.WEB_SOCKET_DISABLE_AUTO_INITIALIZATION||(window.addEventListener?window.addEventListener("load",function(){WebSocket.__initialize()},!1):window.attachEvent("onload",function(){WebSocket.__initialize()}))}})()


--------------------------------------------------------------------------------
/example/simpleviewer/public/javascripts/ShaderExtras.js:
--------------------------------------------------------------------------------
   1 | /**
   2 |  * @author alteredq / http://alteredqualia.com/
   3 |  * @author zz85 / http://www.lab4games.net/zz85/blog
   4 |  *
   5 |  * ShaderExtras currently contains:
   6 |  *
   7 |  *	screen
   8 |  *	convolution
   9 |  *	film
  10 |  * 	bokeh
  11 |  *  sepia
  12 |  *	dotscreen
  13 |  *	vignette
  14 |  *  bleachbypass
  15 |  *	basic
  16 |  *  dofmipmap
  17 |  *  focus
  18 |  *  triangleBlur
  19 |  *  horizontalBlur + verticalBlur
  20 |  *  horizontalTiltShift + verticalTiltShift
  21 |  *  blend
  22 |  *  fxaa
  23 |  *  luminosity
  24 |  *  colorCorrection
  25 |  *  normalmap
  26 |  *  ssao
  27 |  *  colorify
  28 |  *  unpackDepthRGBA
  29 |  */
  30 | 
  31 | THREE.ShaderExtras = {
  32 | 
  33 | 	/* -------------------------------------------------------------------------
  34 | 	//	Full-screen textured quad shader
  35 | 	 ------------------------------------------------------------------------- */
  36 | 
  37 | 	'screen': {
  38 | 
  39 | 		uniforms: {
  40 | 
  41 | 			tDiffuse: { type: "t", value: 0, texture: null },
  42 | 			opacity:  { type: "f", value: 1.0 }
  43 | 
  44 | 		},
  45 | 
  46 | 		vertexShader: [
  47 | 
  48 | 			"varying vec2 vUv;",
  49 | 
  50 | 			"void main() {",
  51 | 
  52 | 				"vUv = vec2( uv.x, 1.0 - uv.y );",
  53 | 				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
  54 | 
  55 | 			"}"
  56 | 
  57 | 		].join("\n"),
  58 | 
  59 | 		fragmentShader: [
  60 | 
  61 | 			"uniform float opacity;",
  62 | 
  63 | 			"uniform sampler2D tDiffuse;",
  64 | 
  65 | 			"varying vec2 vUv;",
  66 | 
  67 | 			"void main() {",
  68 | 
  69 | 				"vec4 texel = texture2D( tDiffuse, vUv );",
  70 | 				"gl_FragColor = opacity * texel;",
  71 | 
  72 | 			"}"
  73 | 
  74 | 		].join("\n")
  75 | 
  76 | 	},
  77 | 
  78 | 	/* ------------------------------------------------------------------------
  79 | 	//	Convolution shader
  80 | 	//	  - ported from o3d sample to WebGL / GLSL
  81 | 	//			http://o3d.googlecode.com/svn/trunk/samples/convolution.html
  82 | 	------------------------------------------------------------------------ */
  83 | 
  84 | 	'convolution': {
  85 | 
  86 | 		uniforms: {
  87 | 
  88 | 			"tDiffuse" : 		{ type: "t", value: 0, texture: null },
  89 | 			"uImageIncrement" : { type: "v2", value: new THREE.Vector2( 0.001953125, 0.0 ) },
  90 | 			"cKernel" : 		{ type: "fv1", value: [] }
  91 | 
  92 | 		},
  93 | 
  94 | 		vertexShader: [
  95 | 
  96 | 			//"#define KERNEL_SIZE 25.0",
  97 | 
  98 | 			"uniform vec2 uImageIncrement;",
  99 | 
 100 | 			"varying vec2 vUv;",
 101 | 
 102 | 			"void main() {",
 103 | 
 104 | 				"vUv = uv - ( ( KERNEL_SIZE - 1.0 ) / 2.0 ) * uImageIncrement;",
 105 | 				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
 106 | 
 107 | 			"}"
 108 | 
 109 | 		].join("\n"),
 110 | 
 111 | 		fragmentShader: [
 112 | 
 113 | 			//"#define KERNEL_SIZE 25",
 114 | 			"uniform float cKernel[ KERNEL_SIZE ];",
 115 | 
 116 | 			"uniform sampler2D tDiffuse;",
 117 | 			"uniform vec2 uImageIncrement;",
 118 | 
 119 | 			"varying vec2 vUv;",
 120 | 
 121 | 			"void main() {",
 122 | 
 123 | 				"vec2 imageCoord = vUv;",
 124 | 				"vec4 sum = vec4( 0.0, 0.0, 0.0, 0.0 );",
 125 | 
 126 | 				"for( int i = 0; i < KERNEL_SIZE; i ++ ) {",
 127 | 
 128 | 					"sum += texture2D( tDiffuse, imageCoord ) * cKernel[ i ];",
 129 | 					"imageCoord += uImageIncrement;",
 130 | 
 131 | 				"}",
 132 | 
 133 | 				"gl_FragColor = sum;",
 134 | 
 135 | 			"}"
 136 | 
 137 | 
 138 | 		].join("\n")
 139 | 
 140 | 	},
 141 | 
 142 | 	/* -------------------------------------------------------------------------
 143 | 
 144 | 	// Film grain & scanlines shader
 145 | 
 146 | 	//	- ported from HLSL to WebGL / GLSL
 147 | 	//	  http://www.truevision3d.com/forums/showcase/staticnoise_colorblackwhite_scanline_shaders-t18698.0.html
 148 | 
 149 | 	// Screen Space Static Postprocessor
 150 | 	//
 151 | 	// Produces an analogue noise overlay similar to a film grain / TV static
 152 | 	//
 153 | 	// Original implementation and noise algorithm
 154 | 	// Pat 'Hawthorne' Shearon
 155 | 	//
 156 | 	// Optimized scanlines + noise version with intensity scaling
 157 | 	// Georg 'Leviathan' Steinrohder
 158 | 
 159 | 	// This version is provided under a Creative Commons Attribution 3.0 License
 160 | 	// http://creativecommons.org/licenses/by/3.0/
 161 | 	 ------------------------------------------------------------------------- */
 162 | 
 163 | 	'film': {
 164 | 
 165 | 		uniforms: {
 166 | 
 167 | 			tDiffuse:   { type: "t", value: 0, texture: null },
 168 | 			time: 	    { type: "f", value: 0.0 },
 169 | 			nIntensity: { type: "f", value: 0.5 },
 170 | 			sIntensity: { type: "f", value: 0.05 },
 171 | 			sCount: 	{ type: "f", value: 4096 },
 172 | 			grayscale:  { type: "i", value: 1 }
 173 | 
 174 | 		},
 175 | 
 176 | 		vertexShader: [
 177 | 
 178 | 			"varying vec2 vUv;",
 179 | 
 180 | 			"void main() {",
 181 | 
 182 | 				"vUv = vec2( uv.x, 1.0 - uv.y );",
 183 | 				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
 184 | 
 185 | 			"}"
 186 | 
 187 | 		].join("\n"),
 188 | 
 189 | 		fragmentShader: [
 190 | 
 191 | 			// control parameter
 192 | 			"uniform float time;",
 193 | 
 194 | 			"uniform bool grayscale;",
 195 | 
 196 | 			// noise effect intensity value (0 = no effect, 1 = full effect)
 197 | 			"uniform float nIntensity;",
 198 | 
 199 | 			// scanlines effect intensity value (0 = no effect, 1 = full effect)
 200 | 			"uniform float sIntensity;",
 201 | 
 202 | 			// scanlines effect count value (0 = no effect, 4096 = full effect)
 203 | 			"uniform float sCount;",
 204 | 
 205 | 			"uniform sampler2D tDiffuse;",
 206 | 
 207 | 			"varying vec2 vUv;",
 208 | 
 209 | 			"void main() {",
 210 | 
 211 | 				// sample the source
 212 | 				"vec4 cTextureScreen = texture2D( tDiffuse, vUv );",
 213 | 
 214 | 				// make some noise
 215 | 				"float x = vUv.x * vUv.y * time *  1000.0;",
 216 | 				"x = mod( x, 13.0 ) * mod( x, 123.0 );",
 217 | 				"float dx = mod( x, 0.01 );",
 218 | 
 219 | 				// add noise
 220 | 				"vec3 cResult = cTextureScreen.rgb + cTextureScreen.rgb * clamp( 0.1 + dx * 100.0, 0.0, 1.0 );",
 221 | 
 222 | 				// get us a sine and cosine
 223 | 				"vec2 sc = vec2( sin( vUv.y * sCount ), cos( vUv.y * sCount ) );",
 224 | 
 225 | 				// add scanlines
 226 | 				"cResult += cTextureScreen.rgb * vec3( sc.x, sc.y, sc.x ) * sIntensity;",
 227 | 
 228 | 				// interpolate between source and result by intensity
 229 | 				"cResult = cTextureScreen.rgb + clamp( nIntensity, 0.0,1.0 ) * ( cResult - cTextureScreen.rgb );",
 230 | 
 231 | 				// convert to grayscale if desired
 232 | 				"if( grayscale ) {",
 233 | 
 234 | 					"cResult = vec3( cResult.r * 0.3 + cResult.g * 0.59 + cResult.b * 0.11 );",
 235 | 
 236 | 				"}",
 237 | 
 238 | 				"gl_FragColor =  vec4( cResult, cTextureScreen.a );",
 239 | 
 240 | 			"}"
 241 | 
 242 | 		].join("\n")
 243 | 
 244 | 	},
 245 | 
 246 | 
 247 | 	/* -------------------------------------------------------------------------
 248 | 	//	Depth-of-field shader with bokeh
 249 | 	//	ported from GLSL shader by Martins Upitis
 250 | 	//	http://artmartinsh.blogspot.com/2010/02/glsl-lens-blur-filter-with-bokeh.html
 251 | 	 ------------------------------------------------------------------------- */
 252 | 
 253 | 	'bokeh'	: {
 254 | 
 255 | 	uniforms: { tColor:   { type: "t", value: 0, texture: null },
 256 | 				tDepth:   { type: "t", value: 1, texture: null },
 257 | 				focus:    { type: "f", value: 1.0 },
 258 | 				aspect:   { type: "f", value: 1.0 },
 259 | 				aperture: { type: "f", value: 0.025 },
 260 | 				maxblur:  { type: "f", value: 1.0 },
 261 | 			  },
 262 | 
 263 | 	vertexShader: [
 264 | 
 265 | 	"varying vec2 vUv;",
 266 | 
 267 | 	"void main() {",
 268 | 
 269 | 		"vUv = vec2( uv.x, 1.0 - uv.y );",
 270 | 		"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
 271 | 
 272 | 	"}"
 273 | 
 274 | 	].join("\n"),
 275 | 
 276 | 	fragmentShader: [
 277 | 
 278 | 	"varying vec2 vUv;",
 279 | 
 280 | 	"uniform sampler2D tColor;",
 281 | 	"uniform sampler2D tDepth;",
 282 | 
 283 | 	"uniform float maxblur;",  	// max blur amount
 284 | 	"uniform float aperture;",	// aperture - bigger values for shallower depth of field
 285 | 
 286 | 	"uniform float focus;",
 287 | 	"uniform float aspect;",
 288 | 
 289 | 	"void main() {",
 290 | 
 291 | 		"vec2 aspectcorrect = vec2( 1.0, aspect );",
 292 | 
 293 | 		"vec4 depth1 = texture2D( tDepth, vUv );",
 294 | 
 295 | 		"float factor = depth1.x - focus;",
 296 | 
 297 | 		"vec2 dofblur = vec2 ( clamp( factor * aperture, -maxblur, maxblur ) );",
 298 | 
 299 | 		"vec2 dofblur9 = dofblur * 0.9;",
 300 | 		"vec2 dofblur7 = dofblur * 0.7;",
 301 | 		"vec2 dofblur4 = dofblur * 0.4;",
 302 | 
 303 | 		"vec4 col = vec4( 0.0 );",
 304 | 
 305 | 		"col += texture2D( tColor, vUv.xy );",
 306 | 		"col += texture2D( tColor, vUv.xy + ( vec2(  0.0,   0.4  ) * aspectcorrect ) * dofblur );",
 307 | 		"col += texture2D( tColor, vUv.xy + ( vec2(  0.15,  0.37 ) * aspectcorrect ) * dofblur );",
 308 | 		"col += texture2D( tColor, vUv.xy + ( vec2(  0.29,  0.29 ) * aspectcorrect ) * dofblur );",
 309 | 		"col += texture2D( tColor, vUv.xy + ( vec2( -0.37,  0.15 ) * aspectcorrect ) * dofblur );",
 310 | 		"col += texture2D( tColor, vUv.xy + ( vec2(  0.40,  0.0  ) * aspectcorrect ) * dofblur );",
 311 | 		"col += texture2D( tColor, vUv.xy + ( vec2(  0.37, -0.15 ) * aspectcorrect ) * dofblur );",
 312 | 		"col += texture2D( tColor, vUv.xy + ( vec2(  0.29, -0.29 ) * aspectcorrect ) * dofblur );",
 313 | 		"col += texture2D( tColor, vUv.xy + ( vec2( -0.15, -0.37 ) * aspectcorrect ) * dofblur );",
 314 | 		"col += texture2D( tColor, vUv.xy + ( vec2(  0.0,  -0.4  ) * aspectcorrect ) * dofblur );",
 315 | 		"col += texture2D( tColor, vUv.xy + ( vec2( -0.15,  0.37 ) * aspectcorrect ) * dofblur );",
 316 | 		"col += texture2D( tColor, vUv.xy + ( vec2( -0.29,  0.29 ) * aspectcorrect ) * dofblur );",
 317 | 		"col += texture2D( tColor, vUv.xy + ( vec2(  0.37,  0.15 ) * aspectcorrect ) * dofblur );",
 318 | 		"col += texture2D( tColor, vUv.xy + ( vec2( -0.4,   0.0  ) * aspectcorrect ) * dofblur );",
 319 | 		"col += texture2D( tColor, vUv.xy + ( vec2( -0.37, -0.15 ) * aspectcorrect ) * dofblur );",
 320 | 		"col += texture2D( tColor, vUv.xy + ( vec2( -0.29, -0.29 ) * aspectcorrect ) * dofblur );",
 321 | 		"col += texture2D( tColor, vUv.xy + ( vec2(  0.15, -0.37 ) * aspectcorrect ) * dofblur );",
 322 | 
 323 | 		"col += texture2D( tColor, vUv.xy + ( vec2(  0.15,  0.37 ) * aspectcorrect ) * dofblur9 );",
 324 | 		"col += texture2D( tColor, vUv.xy + ( vec2( -0.37,  0.15 ) * aspectcorrect ) * dofblur9 );",
 325 | 		"col += texture2D( tColor, vUv.xy + ( vec2(  0.37, -0.15 ) * aspectcorrect ) * dofblur9 );",
 326 | 		"col += texture2D( tColor, vUv.xy + ( vec2( -0.15, -0.37 ) * aspectcorrect ) * dofblur9 );",
 327 | 		"col += texture2D( tColor, vUv.xy + ( vec2( -0.15,  0.37 ) * aspectcorrect ) * dofblur9 );",
 328 | 		"col += texture2D( tColor, vUv.xy + ( vec2(  0.37,  0.15 ) * aspectcorrect ) * dofblur9 );",
 329 | 		"col += texture2D( tColor, vUv.xy + ( vec2( -0.37, -0.15 ) * aspectcorrect ) * dofblur9 );",
 330 | 		"col += texture2D( tColor, vUv.xy + ( vec2(  0.15, -0.37 ) * aspectcorrect ) * dofblur9 );",
 331 | 
 332 | 		"col += texture2D( tColor, vUv.xy + ( vec2(  0.29,  0.29 ) * aspectcorrect ) * dofblur7 );",
 333 | 		"col += texture2D( tColor, vUv.xy + ( vec2(  0.40,  0.0  ) * aspectcorrect ) * dofblur7 );",
 334 | 		"col += texture2D( tColor, vUv.xy + ( vec2(  0.29, -0.29 ) * aspectcorrect ) * dofblur7 );",
 335 | 		"col += texture2D( tColor, vUv.xy + ( vec2(  0.0,  -0.4  ) * aspectcorrect ) * dofblur7 );",
 336 | 		"col += texture2D( tColor, vUv.xy + ( vec2( -0.29,  0.29 ) * aspectcorrect ) * dofblur7 );",
 337 | 		"col += texture2D( tColor, vUv.xy + ( vec2( -0.4,   0.0  ) * aspectcorrect ) * dofblur7 );",
 338 | 		"col += texture2D( tColor, vUv.xy + ( vec2( -0.29, -0.29 ) * aspectcorrect ) * dofblur7 );",
 339 | 		"col += texture2D( tColor, vUv.xy + ( vec2(  0.0,   0.4  ) * aspectcorrect ) * dofblur7 );",
 340 | 
 341 | 		"col += texture2D( tColor, vUv.xy + ( vec2(  0.29,  0.29 ) * aspectcorrect ) * dofblur4 );",
 342 | 		"col += texture2D( tColor, vUv.xy + ( vec2(  0.4,   0.0  ) * aspectcorrect ) * dofblur4 );",
 343 | 		"col += texture2D( tColor, vUv.xy + ( vec2(  0.29, -0.29 ) * aspectcorrect ) * dofblur4 );",
 344 | 		"col += texture2D( tColor, vUv.xy + ( vec2(  0.0,  -0.4  ) * aspectcorrect ) * dofblur4 );",
 345 | 		"col += texture2D( tColor, vUv.xy + ( vec2( -0.29,  0.29 ) * aspectcorrect ) * dofblur4 );",
 346 | 		"col += texture2D( tColor, vUv.xy + ( vec2( -0.4,   0.0  ) * aspectcorrect ) * dofblur4 );",
 347 | 		"col += texture2D( tColor, vUv.xy + ( vec2( -0.29, -0.29 ) * aspectcorrect ) * dofblur4 );",
 348 | 		"col += texture2D( tColor, vUv.xy + ( vec2(  0.0,   0.4  ) * aspectcorrect ) * dofblur4 );",
 349 | 
 350 | 		"gl_FragColor = col / 41.0;",
 351 | 		"gl_FragColor.a = 1.0;",
 352 | 
 353 | 	"}"
 354 | 
 355 | 	].join("\n")
 356 | 
 357 | 	},
 358 | 
 359 | 	/* -------------------------------------------------------------------------
 360 | 	//	Depth-of-field shader using mipmaps
 361 | 	//	- from Matt Handley @applmak
 362 | 	//	- requires power-of-2 sized render target with enabled mipmaps
 363 | 	 ------------------------------------------------------------------------- */
 364 | 
 365 | 	'dofmipmap': {
 366 | 
 367 | 		uniforms: {
 368 | 
 369 | 			tColor:   { type: "t", value: 0, texture: null },
 370 | 			tDepth:   { type: "t", value: 1, texture: null },
 371 | 			focus:    { type: "f", value: 1.0 },
 372 | 			maxblur:  { type: "f", value: 1.0 }
 373 | 
 374 | 		},
 375 | 
 376 | 		vertexShader: [
 377 | 
 378 | 			"varying vec2 vUv;",
 379 | 
 380 | 			"void main() {",
 381 | 
 382 | 				"vUv = vec2( uv.x, 1.0 - uv.y );",
 383 | 				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
 384 | 
 385 | 			"}"
 386 | 
 387 | 		].join("\n"),
 388 | 
 389 | 		fragmentShader: [
 390 | 
 391 | 			"uniform float focus;",
 392 | 			"uniform float maxblur;",
 393 | 
 394 | 			"uniform sampler2D tColor;",
 395 | 			"uniform sampler2D tDepth;",
 396 | 
 397 | 			"varying vec2 vUv;",
 398 | 
 399 | 			"void main() {",
 400 | 
 401 | 				"vec4 depth = texture2D( tDepth, vUv );",
 402 | 
 403 | 				"float factor = depth.x - focus;",
 404 | 
 405 | 				"vec4 col = texture2D( tColor, vUv, 2.0 * maxblur * abs( focus - depth.x ) );",
 406 | 
 407 | 				"gl_FragColor = col;",
 408 | 				"gl_FragColor.a = 1.0;",
 409 | 
 410 | 			"}"
 411 | 
 412 | 		].join("\n")
 413 | 
 414 | 	},
 415 | 
 416 | 	/* -------------------------------------------------------------------------
 417 | 	//	Sepia tone shader
 418 | 	//  - based on glfx.js sepia shader
 419 | 	//		https://github.com/evanw/glfx.js
 420 | 	 ------------------------------------------------------------------------- */
 421 | 
 422 | 	'sepia': {
 423 | 
 424 | 		uniforms: {
 425 | 
 426 | 			tDiffuse: { type: "t", value: 0, texture: null },
 427 | 			amount:   { type: "f", value: 1.0 }
 428 | 
 429 | 		},
 430 | 
 431 | 		vertexShader: [
 432 | 
 433 | 			"varying vec2 vUv;",
 434 | 
 435 | 			"void main() {",
 436 | 
 437 | 				"vUv = vec2( uv.x, 1.0 - uv.y );",
 438 | 				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
 439 | 
 440 | 			"}"
 441 | 
 442 | 		].join("\n"),
 443 | 
 444 | 		fragmentShader: [
 445 | 
 446 | 			"uniform float amount;",
 447 | 
 448 | 			"uniform sampler2D tDiffuse;",
 449 | 
 450 | 			"varying vec2 vUv;",
 451 | 
 452 | 			"void main() {",
 453 | 
 454 | 				"vec4 color = texture2D( tDiffuse, vUv );",
 455 | 				"vec3 c = color.rgb;",
 456 | 
 457 | 				"color.r = dot( c, vec3( 1.0 - 0.607 * amount, 0.769 * amount, 0.189 * amount ) );",
 458 | 				"color.g = dot( c, vec3( 0.349 * amount, 1.0 - 0.314 * amount, 0.168 * amount ) );",
 459 | 				"color.b = dot( c, vec3( 0.272 * amount, 0.534 * amount, 1.0 - 0.869 * amount ) );",
 460 | 
 461 | 				"gl_FragColor = vec4( min( vec3( 1.0 ), color.rgb ), color.a );",
 462 | 
 463 | 			"}"
 464 | 
 465 | 		].join("\n")
 466 | 
 467 | 	},
 468 | 
 469 | 	/* -------------------------------------------------------------------------
 470 | 	//	Dot screen shader
 471 | 	//  - based on glfx.js sepia shader
 472 | 	//		https://github.com/evanw/glfx.js
 473 | 	 ------------------------------------------------------------------------- */
 474 | 
 475 | 	'dotscreen': {
 476 | 
 477 | 		uniforms: {
 478 | 
 479 | 			tDiffuse: { type: "t", value: 0, texture: null },
 480 | 			tSize:    { type: "v2", value: new THREE.Vector2( 256, 256 ) },
 481 | 			center:   { type: "v2", value: new THREE.Vector2( 0.5, 0.5 ) },
 482 | 			angle:	  { type: "f", value: 1.57 },
 483 | 			scale:	  { type: "f", value: 1.0 }
 484 | 
 485 | 		},
 486 | 
 487 | 		vertexShader: [
 488 | 
 489 | 			"varying vec2 vUv;",
 490 | 
 491 | 			"void main() {",
 492 | 
 493 | 				"vUv = vec2( uv.x, 1.0 - uv.y );",
 494 | 				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
 495 | 
 496 | 			"}"
 497 | 
 498 | 		].join("\n"),
 499 | 
 500 | 		fragmentShader: [
 501 | 
 502 | 			"uniform vec2 center;",
 503 | 			"uniform float angle;",
 504 | 			"uniform float scale;",
 505 | 			"uniform vec2 tSize;",
 506 | 
 507 | 			"uniform sampler2D tDiffuse;",
 508 | 
 509 | 			"varying vec2 vUv;",
 510 | 
 511 | 			"float pattern() {",
 512 | 
 513 | 				"float s = sin( angle ), c = cos( angle );",
 514 | 
 515 | 				"vec2 tex = vUv * tSize - center;",
 516 | 				"vec2 point = vec2( c * tex.x - s * tex.y, s * tex.x + c * tex.y ) * scale;",
 517 | 
 518 | 				"return ( sin( point.x ) * sin( point.y ) ) * 4.0;",
 519 | 
 520 | 			"}",
 521 | 
 522 | 			"void main() {",
 523 | 
 524 | 				"vec4 color = texture2D( tDiffuse, vUv );",
 525 | 
 526 | 				"float average = ( color.r + color.g + color.b ) / 3.0;",
 527 | 
 528 | 				"gl_FragColor = vec4( vec3( average * 10.0 - 5.0 + pattern() ), color.a );",
 529 | 
 530 | 			"}"
 531 | 
 532 | 		].join("\n")
 533 | 
 534 | 	},
 535 | 
 536 | 	/* ------------------------------------------------------------------------------------------------
 537 | 	//	Vignette shader
 538 | 	//	- based on PaintEffect postprocess from ro.me
 539 | 	//		http://code.google.com/p/3-dreams-of-black/source/browse/deploy/js/effects/PaintEffect.js
 540 | 	 ------------------------------------------------------------------------------------------------ */
 541 | 
 542 | 	'vignette': {
 543 | 
 544 | 		uniforms: {
 545 | 
 546 | 			tDiffuse: { type: "t", value: 0, texture: null },
 547 | 			offset:   { type: "f", value: 1.0 },
 548 | 			darkness: { type: "f", value: 1.0 }
 549 | 
 550 | 		},
 551 | 
 552 | 		vertexShader: [
 553 | 
 554 | 			"varying vec2 vUv;",
 555 | 
 556 | 			"void main() {",
 557 | 
 558 | 				"vUv = vec2( uv.x, 1.0 - uv.y );",
 559 | 				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
 560 | 
 561 | 			"}"
 562 | 
 563 | 		].join("\n"),
 564 | 
 565 | 		fragmentShader: [
 566 | 
 567 | 			"uniform float offset;",
 568 | 			"uniform float darkness;",
 569 | 
 570 | 			"uniform sampler2D tDiffuse;",
 571 | 
 572 | 			"varying vec2 vUv;",
 573 | 
 574 | 			"void main() {",
 575 | 
 576 | 				// Eskil's vignette
 577 | 
 578 | 				"vec4 texel = texture2D( tDiffuse, vUv );",
 579 | 				"vec2 uv = ( vUv - vec2( 0.5 ) ) * vec2( offset );",
 580 | 				"gl_FragColor = vec4( mix( texel.rgb, vec3( 1.0 - darkness ), dot( uv, uv ) ), texel.a );",
 581 | 
 582 | 				/*
 583 | 				// alternative version from glfx.js
 584 | 				// this one makes more "dusty" look (as opposed to "burned")
 585 | 
 586 | 				"vec4 color = texture2D( tDiffuse, vUv );",
 587 | 				"float dist = distance( vUv, vec2( 0.5 ) );",
 588 | 				"color.rgb *= smoothstep( 0.8, offset * 0.799, dist *( darkness + offset ) );",
 589 | 				"gl_FragColor = color;",
 590 | 				*/
 591 | 
 592 | 			"}"
 593 | 
 594 | 		].join("\n")
 595 | 
 596 | 	},
 597 | 
 598 | 	/* -------------------------------------------------------------------------
 599 | 	//	Bleach bypass shader [http://en.wikipedia.org/wiki/Bleach_bypass]
 600 | 	//	- based on Nvidia example
 601 | 	//		http://developer.download.nvidia.com/shaderlibrary/webpages/shader_library.html#post_bleach_bypass
 602 | 	 ------------------------------------------------------------------------- */
 603 | 
 604 | 	'bleachbypass': {
 605 | 
 606 | 		uniforms: {
 607 | 
 608 | 			tDiffuse: { type: "t", value: 0, texture: null },
 609 | 			opacity:  { type: "f", value: 1.0 }
 610 | 
 611 | 		},
 612 | 
 613 | 		vertexShader: [
 614 | 
 615 | 			"varying vec2 vUv;",
 616 | 
 617 | 			"void main() {",
 618 | 
 619 | 				"vUv = vec2( uv.x, 1.0 - uv.y );",
 620 | 				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
 621 | 
 622 | 			"}"
 623 | 
 624 | 		].join("\n"),
 625 | 
 626 | 		fragmentShader: [
 627 | 
 628 | 			"uniform float opacity;",
 629 | 
 630 | 			"uniform sampler2D tDiffuse;",
 631 | 
 632 | 			"varying vec2 vUv;",
 633 | 
 634 | 			"void main() {",
 635 | 
 636 | 				"vec4 base = texture2D( tDiffuse, vUv );",
 637 | 
 638 | 				"vec3 lumCoeff = vec3( 0.25, 0.65, 0.1 );",
 639 | 				"float lum = dot( lumCoeff, base.rgb );",
 640 | 				"vec3 blend = vec3( lum );",
 641 | 
 642 | 				"float L = min( 1.0, max( 0.0, 10.0 * ( lum - 0.45 ) ) );",
 643 | 
 644 | 				"vec3 result1 = 2.0 * base.rgb * blend;",
 645 | 				"vec3 result2 = 1.0 - 2.0 * ( 1.0 - blend ) * ( 1.0 - base.rgb );",
 646 | 
 647 | 				"vec3 newColor = mix( result1, result2, L );",
 648 | 
 649 | 				"float A2 = opacity * base.a;",
 650 | 				"vec3 mixRGB = A2 * newColor.rgb;",
 651 | 				"mixRGB += ( ( 1.0 - A2 ) * base.rgb );",
 652 | 
 653 | 				"gl_FragColor = vec4( mixRGB, base.a );",
 654 | 
 655 | 			"}"
 656 | 
 657 | 		].join("\n")
 658 | 
 659 | 	},
 660 | 
 661 | 	/* --------------------------------------------------------------------------------------------------
 662 | 	//	Focus shader
 663 | 	//	- based on PaintEffect postprocess from ro.me
 664 | 	//		http://code.google.com/p/3-dreams-of-black/source/browse/deploy/js/effects/PaintEffect.js
 665 | 	 -------------------------------------------------------------------------------------------------- */
 666 | 
 667 | 	'focus': {
 668 | 
 669 | 		uniforms : {
 670 | 
 671 | 			"tDiffuse": 		{ type: "t", value: 0, texture: null },
 672 | 			"screenWidth": 		{ type: "f", value: 1024 },
 673 | 			"screenHeight": 	{ type: "f", value: 1024 },
 674 | 			"sampleDistance": 	{ type: "f", value: 0.94 },
 675 | 			"waveFactor": 		{ type: "f", value: 0.00125 }
 676 | 
 677 | 		},
 678 | 
 679 | 		vertexShader: [
 680 | 
 681 | 			"varying vec2 vUv;",
 682 | 
 683 | 			"void main() {",
 684 | 
 685 | 				"vUv = vec2( uv.x, 1.0 - uv.y );",
 686 | 				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
 687 | 
 688 | 			"}"
 689 | 
 690 | 		].join("\n"),
 691 | 
 692 | 		fragmentShader: [
 693 | 
 694 | 			"uniform float screenWidth;",
 695 | 			"uniform float screenHeight;",
 696 | 			"uniform float sampleDistance;",
 697 | 			"uniform float waveFactor;",
 698 | 
 699 | 			"uniform sampler2D tDiffuse;",
 700 | 
 701 | 			"varying vec2 vUv;",
 702 | 
 703 | 			"void main() {",
 704 | 
 705 | 				"vec4 color, org, tmp, add;",
 706 | 				"float sample_dist, f;",
 707 | 				"vec2 vin;",
 708 | 				"vec2 uv = vUv;",
 709 | 
 710 | 				"add += color = org = texture2D( tDiffuse, uv );",
 711 | 
 712 | 				"vin = ( uv - vec2( 0.5 ) ) * vec2( 1.4 );",
 713 | 				"sample_dist = dot( vin, vin ) * 2.0;",
 714 | 
 715 | 				"f = ( waveFactor * 100.0 + sample_dist ) * sampleDistance * 4.0;",
 716 | 
 717 | 				"vec2 sampleSize = vec2(  1.0 / screenWidth, 1.0 / screenHeight ) * vec2( f );",
 718 | 
 719 | 				"add += tmp = texture2D( tDiffuse, uv + vec2( 0.111964, 0.993712 ) * sampleSize );",
 720 | 				"if( tmp.b < color.b ) color = tmp;",
 721 | 
 722 | 				"add += tmp = texture2D( tDiffuse, uv + vec2( 0.846724, 0.532032 ) * sampleSize );",
 723 | 				"if( tmp.b < color.b ) color = tmp;",
 724 | 
 725 | 				"add += tmp = texture2D( tDiffuse, uv + vec2( 0.943883, -0.330279 ) * sampleSize );",
 726 | 				"if( tmp.b < color.b ) color = tmp;",
 727 | 
 728 | 				"add += tmp = texture2D( tDiffuse, uv + vec2( 0.330279, -0.943883 ) * sampleSize );",
 729 | 				"if( tmp.b < color.b ) color = tmp;",
 730 | 
 731 | 				"add += tmp = texture2D( tDiffuse, uv + vec2( -0.532032, -0.846724 ) * sampleSize );",
 732 | 				"if( tmp.b < color.b ) color = tmp;",
 733 | 
 734 | 				"add += tmp = texture2D( tDiffuse, uv + vec2( -0.993712, -0.111964 ) * sampleSize );",
 735 | 				"if( tmp.b < color.b ) color = tmp;",
 736 | 
 737 | 				"add += tmp = texture2D( tDiffuse, uv + vec2( -0.707107, 0.707107 ) * sampleSize );",
 738 | 				"if( tmp.b < color.b ) color = tmp;",
 739 | 
 740 | 				"color = color * vec4( 2.0 ) - ( add / vec4( 8.0 ) );",
 741 | 				"color = color + ( add / vec4( 8.0 ) - color ) * ( vec4( 1.0 ) - vec4( sample_dist * 0.5 ) );",
 742 | 
 743 | 				"gl_FragColor = vec4( color.rgb * color.rgb * vec3( 0.95 ) + color.rgb, 1.0 );",
 744 | 
 745 | 			"}"
 746 | 
 747 | 
 748 | 		].join("\n")
 749 | 	},
 750 | 
 751 | 	/* -------------------------------------------------------------------------
 752 | 	//	Triangle blur shader
 753 | 	//  - based on glfx.js triangle blur shader
 754 | 	//		https://github.com/evanw/glfx.js
 755 | 
 756 | 	// 	A basic blur filter, which convolves the image with a
 757 | 	// 	pyramid filter. The pyramid filter is separable and is applied as two
 758 | 	//  perpendicular triangle filters.
 759 | 	 ------------------------------------------------------------------------- */
 760 | 
 761 | 	'triangleBlur': {
 762 | 
 763 | 
 764 | 		uniforms : {
 765 | 
 766 | 			"texture": 	{ type: "t", value: 0, texture: null },
 767 | 			"delta": 	{ type: "v2", value:new THREE.Vector2( 1, 1 )  }
 768 | 
 769 | 		},
 770 | 
 771 | 		vertexShader: [
 772 | 
 773 | 			"varying vec2 vUv;",
 774 | 
 775 | 			"void main() {",
 776 | 
 777 | 				"vUv = vec2( uv.x, 1.0 - uv.y );",
 778 | 				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
 779 | 
 780 | 			"}"
 781 | 
 782 | 		].join("\n"),
 783 | 
 784 | 		fragmentShader: [
 785 | 
 786 | 		"#define ITERATIONS 10.0",
 787 | 
 788 | 		"uniform sampler2D texture;",
 789 | 		"uniform vec2 delta;",
 790 | 
 791 | 		"varying vec2 vUv;",
 792 | 
 793 | 		"float random( vec3 scale, float seed ) {",
 794 | 
 795 | 			// use the fragment position for a different seed per-pixel
 796 | 
 797 | 			"return fract( sin( dot( gl_FragCoord.xyz + seed, scale ) ) * 43758.5453 + seed );",
 798 | 
 799 | 		"}",
 800 | 
 801 | 		"void main() {",
 802 | 
 803 | 			"vec4 color = vec4( 0.0 );",
 804 | 
 805 | 			"float total = 0.0;",
 806 | 
 807 | 			// randomize the lookup values to hide the fixed number of samples
 808 | 
 809 | 			"float offset = random( vec3( 12.9898, 78.233, 151.7182 ), 0.0 );",
 810 | 
 811 | 			"for ( float t = -ITERATIONS; t <= ITERATIONS; t ++ ) {",
 812 | 
 813 | 				"float percent = ( t + offset - 0.5 ) / ITERATIONS;",
 814 | 				"float weight = 1.0 - abs( percent );",
 815 | 
 816 | 				"color += texture2D( texture, vUv + delta * percent ) * weight;",
 817 | 				"total += weight;",
 818 | 
 819 | 			"}",
 820 | 
 821 | 			"gl_FragColor = color / total;",
 822 | 
 823 | 		"}",
 824 | 
 825 | 		].join("\n")
 826 | 
 827 | 	},
 828 | 
 829 | 	/* -------------------------------------------------------------------------
 830 | 	//	Simple test shader
 831 | 	 ------------------------------------------------------------------------- */
 832 | 
 833 | 	'basic': {
 834 | 
 835 | 		uniforms: {},
 836 | 
 837 | 		vertexShader: [
 838 | 
 839 | 			"void main() {",
 840 | 
 841 | 				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
 842 | 
 843 | 			"}"
 844 | 
 845 | 		].join("\n"),
 846 | 
 847 | 		fragmentShader: [
 848 | 
 849 | 			"void main() {",
 850 | 
 851 | 				"gl_FragColor = vec4( 1.0, 0.0, 0.0, 0.5 );",
 852 | 
 853 | 			"}"
 854 | 
 855 | 		].join("\n")
 856 | 
 857 | 	},
 858 | 
 859 | 	/* --------------------------------------------------------------------------------------------------
 860 | 	//	Two pass Gaussian blur filter (horizontal and vertical blur shaders)
 861 | 	//	- described in http://www.gamerendering.com/2008/10/11/gaussian-blur-filter-shader/
 862 | 	//	  and used in http://www.cake23.de/traveling-wavefronts-lit-up.html
 863 | 	//
 864 | 	//	- 9 samples per pass
 865 | 	//	- standard deviation 2.7
 866 | 	//	- "h" and "v" parameters should be set to "1 / width" and "1 / height"
 867 | 	 -------------------------------------------------------------------------------------------------- */
 868 | 
 869 | 	'horizontalBlur': {
 870 | 
 871 | 		uniforms: {
 872 | 
 873 | 			"tDiffuse": { type: "t", value: 0, texture: null },
 874 | 			"h": 		{ type: "f", value: 1.0 / 512.0 }
 875 | 
 876 | 		},
 877 | 
 878 | 		vertexShader: [
 879 | 
 880 | 			"varying vec2 vUv;",
 881 | 
 882 | 			"void main() {",
 883 | 
 884 | 				"vUv = vec2( uv.x, 1.0 - uv.y );",
 885 | 				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
 886 | 
 887 | 			"}"
 888 | 
 889 | 		].join("\n"),
 890 | 
 891 | 		fragmentShader: [
 892 | 
 893 | 			"uniform sampler2D tDiffuse;",
 894 | 			"uniform float h;",
 895 | 
 896 | 			"varying vec2 vUv;",
 897 | 
 898 | 			"void main() {",
 899 | 
 900 | 				"vec4 sum = vec4( 0.0 );",
 901 | 
 902 | 				"sum += texture2D( tDiffuse, vec2( vUv.x - 4.0 * h, vUv.y ) ) * 0.051;",
 903 | 				"sum += texture2D( tDiffuse, vec2( vUv.x - 3.0 * h, vUv.y ) ) * 0.0918;",
 904 | 				"sum += texture2D( tDiffuse, vec2( vUv.x - 2.0 * h, vUv.y ) ) * 0.12245;",
 905 | 				"sum += texture2D( tDiffuse, vec2( vUv.x - 1.0 * h, vUv.y ) ) * 0.1531;",
 906 | 				"sum += texture2D( tDiffuse, vec2( vUv.x, 		  	vUv.y ) ) * 0.1633;",
 907 | 				"sum += texture2D( tDiffuse, vec2( vUv.x + 1.0 * h, vUv.y ) ) * 0.1531;",
 908 | 				"sum += texture2D( tDiffuse, vec2( vUv.x + 2.0 * h, vUv.y ) ) * 0.12245;",
 909 | 				"sum += texture2D( tDiffuse, vec2( vUv.x + 3.0 * h, vUv.y ) ) * 0.0918;",
 910 | 				"sum += texture2D( tDiffuse, vec2( vUv.x + 4.0 * h, vUv.y ) ) * 0.051;",
 911 | 
 912 | 				"gl_FragColor = sum;",
 913 | 
 914 | 			"}"
 915 | 
 916 | 
 917 | 		].join("\n")
 918 | 
 919 | 	},
 920 | 
 921 | 	'verticalBlur': {
 922 | 
 923 | 		uniforms: {
 924 | 
 925 | 			"tDiffuse": { type: "t", value: 0, texture: null },
 926 | 			"v": 		{ type: "f", value: 1.0 / 512.0 }
 927 | 
 928 | 		},
 929 | 
 930 | 		vertexShader: [
 931 | 
 932 | 			"varying vec2 vUv;",
 933 | 
 934 | 			"void main() {",
 935 | 
 936 | 				"vUv = vec2( uv.x, 1.0 - uv.y );",
 937 | 				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
 938 | 
 939 | 			"}"
 940 | 
 941 | 		].join("\n"),
 942 | 
 943 | 		fragmentShader: [
 944 | 
 945 | 			"uniform sampler2D tDiffuse;",
 946 | 			"uniform float v;",
 947 | 
 948 | 			"varying vec2 vUv;",
 949 | 
 950 | 			"void main() {",
 951 | 
 952 | 				"vec4 sum = vec4( 0.0 );",
 953 | 
 954 | 				"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 4.0 * v ) ) * 0.051;",
 955 | 				"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 3.0 * v ) ) * 0.0918;",
 956 | 				"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 2.0 * v ) ) * 0.12245;",
 957 | 				"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 1.0 * v ) ) * 0.1531;",
 958 | 				"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y			  ) ) * 0.1633;",
 959 | 				"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 1.0 * v ) ) * 0.1531;",
 960 | 				"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 2.0 * v ) ) * 0.12245;",
 961 | 				"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 3.0 * v ) ) * 0.0918;",
 962 | 				"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 4.0 * v ) ) * 0.051;",
 963 | 
 964 | 				"gl_FragColor = sum;",
 965 | 
 966 | 			"}"
 967 | 
 968 | 
 969 | 		].join("\n")
 970 | 
 971 | 	},
 972 | 
 973 | 	/* --------------------------------------------------------------------------------------------------
 974 | 	//	Simple fake tilt-shift effect, modulating two pass Gaussian blur (see above) by vertical position
 975 | 	//
 976 | 	//	- 9 samples per pass
 977 | 	//	- standard deviation 2.7
 978 | 	//	- "h" and "v" parameters should be set to "1 / width" and "1 / height"
 979 | 	//	- "r" parameter control where "focused" horizontal line lies
 980 | 	 -------------------------------------------------------------------------------------------------- */
 981 | 
 982 | 	'horizontalTiltShift': {
 983 | 
 984 | 		uniforms: {
 985 | 
 986 | 			"tDiffuse": { type: "t", value: 0, texture: null },
 987 | 			"h": 		{ type: "f", value: 1.0 / 512.0 },
 988 | 			"r": 		{ type: "f", value: 0.35 }
 989 | 
 990 | 		},
 991 | 
 992 | 		vertexShader: [
 993 | 
 994 | 			"varying vec2 vUv;",
 995 | 
 996 | 			"void main() {",
 997 | 
 998 | 				"vUv = vec2( uv.x, 1.0 - uv.y );",
 999 | 				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
1000 | 
1001 | 			"}"
1002 | 
1003 | 		].join("\n"),
1004 | 
1005 | 		fragmentShader: [
1006 | 
1007 | 			"uniform sampler2D tDiffuse;",
1008 | 			"uniform float h;",
1009 | 			"uniform float r;",
1010 | 
1011 | 			"varying vec2 vUv;",
1012 | 
1013 | 			"void main() {",
1014 | 
1015 | 				"vec4 sum = vec4( 0.0 );",
1016 | 
1017 | 				"float hh = h * abs( r - vUv.y );",
1018 | 
1019 | 				"sum += texture2D( tDiffuse, vec2( vUv.x - 4.0 * hh, vUv.y ) ) * 0.051;",
1020 | 				"sum += texture2D( tDiffuse, vec2( vUv.x - 3.0 * hh, vUv.y ) ) * 0.0918;",
1021 | 				"sum += texture2D( tDiffuse, vec2( vUv.x - 2.0 * hh, vUv.y ) ) * 0.12245;",
1022 | 				"sum += texture2D( tDiffuse, vec2( vUv.x - 1.0 * hh, vUv.y ) ) * 0.1531;",
1023 | 				"sum += texture2D( tDiffuse, vec2( vUv.x, 		  	 vUv.y ) ) * 0.1633;",
1024 | 				"sum += texture2D( tDiffuse, vec2( vUv.x + 1.0 * hh, vUv.y ) ) * 0.1531;",
1025 | 				"sum += texture2D( tDiffuse, vec2( vUv.x + 2.0 * hh, vUv.y ) ) * 0.12245;",
1026 | 				"sum += texture2D( tDiffuse, vec2( vUv.x + 3.0 * hh, vUv.y ) ) * 0.0918;",
1027 | 				"sum += texture2D( tDiffuse, vec2( vUv.x + 4.0 * hh, vUv.y ) ) * 0.051;",
1028 | 
1029 | 				"gl_FragColor = sum;",
1030 | 
1031 | 			"}"
1032 | 
1033 | 
1034 | 		].join("\n")
1035 | 
1036 | 	},
1037 | 
1038 | 	'verticalTiltShift': {
1039 | 
1040 | 		uniforms: {
1041 | 
1042 | 			"tDiffuse": { type: "t", value: 0, texture: null },
1043 | 			"v": 		{ type: "f", value: 1.0 / 512.0 },
1044 | 			"r": 		{ type: "f", value: 0.35 }
1045 | 
1046 | 		},
1047 | 
1048 | 		vertexShader: [
1049 | 
1050 | 			"varying vec2 vUv;",
1051 | 
1052 | 			"void main() {",
1053 | 
1054 | 				"vUv = vec2( uv.x, 1.0 - uv.y );",
1055 | 				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
1056 | 
1057 | 			"}"
1058 | 
1059 | 		].join("\n"),
1060 | 
1061 | 		fragmentShader: [
1062 | 
1063 | 			"uniform sampler2D tDiffuse;",
1064 | 			"uniform float v;",
1065 | 			"uniform float r;",
1066 | 
1067 | 			"varying vec2 vUv;",
1068 | 
1069 | 			"void main() {",
1070 | 
1071 | 				"vec4 sum = vec4( 0.0 );",
1072 | 
1073 | 				"float vv = v * abs( r - vUv.y );",
1074 | 
1075 | 				"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 4.0 * vv ) ) * 0.051;",
1076 | 				"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 3.0 * vv ) ) * 0.0918;",
1077 | 				"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 2.0 * vv ) ) * 0.12245;",
1078 | 				"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y - 1.0 * vv ) ) * 0.1531;",
1079 | 				"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y			   ) ) * 0.1633;",
1080 | 				"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 1.0 * vv ) ) * 0.1531;",
1081 | 				"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 2.0 * vv ) ) * 0.12245;",
1082 | 				"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 3.0 * vv ) ) * 0.0918;",
1083 | 				"sum += texture2D( tDiffuse, vec2( vUv.x, vUv.y + 4.0 * vv ) ) * 0.051;",
1084 | 
1085 | 				"gl_FragColor = sum;",
1086 | 
1087 | 			"}"
1088 | 
1089 | 
1090 | 		].join("\n")
1091 | 
1092 | 	},
1093 | 
1094 | 	/* -------------------------------------------------------------------------
1095 | 	//	Blend two textures
1096 | 	 ------------------------------------------------------------------------- */
1097 | 
1098 | 	'blend': {
1099 | 
1100 | 		uniforms: {
1101 | 
1102 | 			tDiffuse1: { type: "t", value: 0, texture: null },
1103 | 			tDiffuse2: { type: "t", value: 1, texture: null },
1104 | 			mixRatio:  { type: "f", value: 0.5 },
1105 | 			opacity:   { type: "f", value: 1.0 }
1106 | 
1107 | 		},
1108 | 
1109 | 		vertexShader: [
1110 | 
1111 | 			"varying vec2 vUv;",
1112 | 
1113 | 			"void main() {",
1114 | 
1115 | 				"vUv = vec2( uv.x, 1.0 - uv.y );",
1116 | 				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
1117 | 
1118 | 			"}"
1119 | 
1120 | 		].join("\n"),
1121 | 
1122 | 		fragmentShader: [
1123 | 
1124 | 			"uniform float opacity;",
1125 | 			"uniform float mixRatio;",
1126 | 
1127 | 			"uniform sampler2D tDiffuse1;",
1128 | 			"uniform sampler2D tDiffuse2;",
1129 | 
1130 | 			"varying vec2 vUv;",
1131 | 
1132 | 			"void main() {",
1133 | 
1134 | 				"vec4 texel1 = texture2D( tDiffuse1, vUv );",
1135 | 				"vec4 texel2 = texture2D( tDiffuse2, vUv );",
1136 | 				"gl_FragColor = opacity * mix( texel1, texel2, mixRatio );",
1137 | 
1138 | 			"}"
1139 | 
1140 | 		].join("\n")
1141 | 
1142 | 	},
1143 | 
1144 | 	/* -------------------------------------------------------------------------
1145 | 	//	NVIDIA FXAA by Timothy Lottes
1146 | 	//		http://timothylottes.blogspot.com/2011/06/fxaa3-source-released.html
1147 | 	//	- WebGL port by @supereggbert
1148 | 	//		http://www.glge.org/demos/fxaa/
1149 | 	 ------------------------------------------------------------------------- */
1150 | 
1151 | 	'fxaa': {
1152 | 
1153 | 		uniforms: {
1154 | 
1155 | 			"tDiffuse": 	{ type: "t", value: 0, texture: null },
1156 | 			"resolution": 	{ type: "v2", value: new THREE.Vector2( 1 / 1024, 1 / 512 )  }
1157 | 
1158 | 		},
1159 | 
1160 | 		vertexShader: [
1161 | 
1162 | 			"varying vec2 vUv;",
1163 | 
1164 | 			"void main() {",
1165 | 
1166 | 				"vUv = vec2( uv.x, 1.0 - uv.y );",
1167 | 
1168 | 				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
1169 | 
1170 | 			"}"
1171 | 
1172 | 		].join("\n"),
1173 | 
1174 | 		fragmentShader: [
1175 | 
1176 | 			"uniform sampler2D tDiffuse;",
1177 | 			"uniform vec2 resolution;",
1178 | 
1179 | 			"varying vec2 vUv;",
1180 | 
1181 | 			"#define FXAA_REDUCE_MIN   (1.0/128.0)",
1182 | 			"#define FXAA_REDUCE_MUL   (1.0/8.0)",
1183 | 			"#define FXAA_SPAN_MAX     8.0",
1184 | 
1185 | 			"void main() {",
1186 | 
1187 | 				"vec3 rgbNW = texture2D( tDiffuse, ( gl_FragCoord.xy + vec2( -1.0, -1.0 ) ) * resolution ).xyz;",
1188 | 				"vec3 rgbNE = texture2D( tDiffuse, ( gl_FragCoord.xy + vec2( 1.0, -1.0 ) ) * resolution ).xyz;",
1189 | 				"vec3 rgbSW = texture2D( tDiffuse, ( gl_FragCoord.xy + vec2( -1.0, 1.0 ) ) * resolution ).xyz;",
1190 | 				"vec3 rgbSE = texture2D( tDiffuse, ( gl_FragCoord.xy + vec2( 1.0, 1.0 ) ) * resolution ).xyz;",
1191 | 				"vec3 rgbM  = texture2D( tDiffuse,  gl_FragCoord.xy  * resolution ).xyz;",
1192 | 
1193 | 				"vec3 luma = vec3( 0.299, 0.587, 0.114 );",
1194 | 
1195 | 				"float lumaNW = dot( rgbNW, luma );",
1196 | 				"float lumaNE = dot( rgbNE, luma );",
1197 | 				"float lumaSW = dot( rgbSW, luma );",
1198 | 				"float lumaSE = dot( rgbSE, luma );",
1199 | 				"float lumaM  = dot( rgbM,  luma );",
1200 | 				"float lumaMin = min( lumaM, min( min( lumaNW, lumaNE ), min( lumaSW, lumaSE ) ) );",
1201 | 				"float lumaMax = max( lumaM, max( max( lumaNW, lumaNE) , max( lumaSW, lumaSE ) ) );",
1202 | 
1203 | 				"vec2 dir;",
1204 | 				"dir.x = -((lumaNW + lumaNE) - (lumaSW + lumaSE));",
1205 | 				"dir.y =  ((lumaNW + lumaSW) - (lumaNE + lumaSE));",
1206 | 
1207 | 				"float dirReduce = max( ( lumaNW + lumaNE + lumaSW + lumaSE ) * ( 0.25 * FXAA_REDUCE_MUL ), FXAA_REDUCE_MIN );",
1208 | 
1209 | 				"float rcpDirMin = 1.0 / ( min( abs( dir.x ), abs( dir.y ) ) + dirReduce );",
1210 | 				"dir = min( vec2( FXAA_SPAN_MAX,  FXAA_SPAN_MAX),",
1211 | 					  "max( vec2(-FXAA_SPAN_MAX, -FXAA_SPAN_MAX),",
1212 | 							"dir * rcpDirMin)) * resolution;",
1213 | 
1214 | 				"vec3 rgbA = 0.5 * (",
1215 | 					"texture2D( tDiffuse, gl_FragCoord.xy  * resolution + dir * ( 1.0 / 3.0 - 0.5 ) ).xyz +",
1216 | 					"texture2D( tDiffuse, gl_FragCoord.xy  * resolution + dir * ( 2.0 / 3.0 - 0.5 ) ).xyz );",
1217 | 
1218 | 				"vec3 rgbB = rgbA * 0.5 + 0.25 * (",
1219 | 					"texture2D( tDiffuse, gl_FragCoord.xy  * resolution + dir * -0.5 ).xyz +",
1220 | 					"texture2D( tDiffuse, gl_FragCoord.xy  * resolution + dir * 0.5 ).xyz );",
1221 | 
1222 | 				"float lumaB = dot( rgbB, luma );",
1223 | 
1224 | 				"if ( ( lumaB < lumaMin ) || ( lumaB > lumaMax ) ) {",
1225 | 
1226 | 					"gl_FragColor = vec4( rgbA, 1.0 );",
1227 | 
1228 | 				"} else {",
1229 | 
1230 | 					"gl_FragColor = vec4( rgbB, 1.0 );",
1231 | 
1232 | 				"}",
1233 | 
1234 | 			"}",
1235 | 
1236 | 		].join("\n"),
1237 | 
1238 | 	},
1239 | 
1240 | 	/* -------------------------------------------------------------------------
1241 | 	//	Luminosity
1242 | 	//	http://en.wikipedia.org/wiki/Luminosity
1243 | 	 ------------------------------------------------------------------------- */
1244 | 
1245 | 	'luminosity': {
1246 | 
1247 | 		uniforms: {
1248 | 
1249 | 			"tDiffuse": 	{ type: "t", value: 0, texture: null }
1250 | 
1251 | 		},
1252 | 
1253 | 		vertexShader: [
1254 | 
1255 | 			"varying vec2 vUv;",
1256 | 
1257 | 			"void main() {",
1258 | 
1259 | 				"vUv = vec2( uv.x, 1.0 - uv.y );",
1260 | 
1261 | 				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
1262 | 
1263 | 			"}"
1264 | 
1265 | 		].join("\n"),
1266 | 
1267 | 		fragmentShader: [
1268 | 
1269 | 			"uniform sampler2D tDiffuse;",
1270 | 
1271 | 			"varying vec2 vUv;",
1272 | 
1273 | 			"void main() {",
1274 | 
1275 | 				"vec4 texel = texture2D( tDiffuse, vUv );",
1276 | 
1277 | 				"vec3 luma = vec3( 0.299, 0.587, 0.114 );",
1278 | 
1279 | 				"float v = dot( texel.xyz, luma );",
1280 | 
1281 | 				"gl_FragColor = vec4( v, v, v, texel.w );",
1282 | 
1283 | 			"}"
1284 | 
1285 | 		].join("\n")
1286 | 
1287 | 	},
1288 | 
1289 | 	/* -------------------------------------------------------------------------
1290 | 	//	Color correction
1291 | 	 ------------------------------------------------------------------------- */
1292 | 
1293 | 	'colorCorrection': {
1294 | 
1295 | 		uniforms: {
1296 | 
1297 | 			"tDiffuse" : 	{ type: "t", value: 0, texture: null },
1298 | 			"powRGB" :		{ type: "v3", value: new THREE.Vector3( 2, 2, 2 ) },
1299 | 			"mulRGB" :		{ type: "v3", value: new THREE.Vector3( 1, 1, 1 ) }
1300 | 
1301 | 		},
1302 | 
1303 | 		vertexShader: [
1304 | 
1305 | 			"varying vec2 vUv;",
1306 | 
1307 | 			"void main() {",
1308 | 
1309 | 				"vUv = vec2( uv.x, 1.0 - uv.y );",
1310 | 
1311 | 				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
1312 | 
1313 | 			"}"
1314 | 
1315 | 		].join("\n"),
1316 | 
1317 | 		fragmentShader: [
1318 | 
1319 | 			"uniform sampler2D tDiffuse;",
1320 | 			"uniform vec3 powRGB;",
1321 | 			"uniform vec3 mulRGB;",
1322 | 
1323 | 			"varying vec2 vUv;",
1324 | 
1325 | 			"void main() {",
1326 | 
1327 | 				"gl_FragColor = texture2D( tDiffuse, vUv );",
1328 | 				"gl_FragColor.rgb = mulRGB * pow( gl_FragColor.rgb, powRGB );",
1329 | 
1330 | 			"}"
1331 | 
1332 | 		].join("\n")
1333 | 
1334 | 	},
1335 | 
1336 | 	/* -------------------------------------------------------------------------
1337 | 	//	Normal map shader
1338 | 	//	- compute normals from heightmap
1339 | 	 ------------------------------------------------------------------------- */
1340 | 
1341 | 	'normalmap': {
1342 | 
1343 | 		uniforms: {
1344 | 
1345 | 			"heightMap"	: { type: "t", value: 0, texture: null },
1346 | 			"resolution": { type: "v2", value: new THREE.Vector2( 512, 512 ) },
1347 | 			"scale"		: { type: "v2", value: new THREE.Vector2( 1, 1 ) },
1348 | 			"height"	: { type: "f", value: 0.05 }
1349 | 
1350 | 		},
1351 | 
1352 | 		vertexShader: [
1353 | 
1354 | 			"varying vec2 vUv;",
1355 | 
1356 | 			"void main() {",
1357 | 
1358 | 				"vUv = vec2( uv.x, 1.0 - uv.y );",
1359 | 
1360 | 				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
1361 | 
1362 | 			"}"
1363 | 
1364 | 		].join("\n"),
1365 | 
1366 | 		fragmentShader: [
1367 | 
1368 | 			"uniform float height;",
1369 | 			"uniform vec2 resolution;",
1370 | 			"uniform sampler2D heightMap;",
1371 | 
1372 | 			"varying vec2 vUv;",
1373 | 
1374 | 			"void main() {",
1375 | 
1376 | 				"float val = texture2D( heightMap, vUv ).x;",
1377 | 
1378 | 				"float valU = texture2D( heightMap, vUv + vec2( 1.0 / resolution.x, 0.0 ) ).x;",
1379 | 				"float valV = texture2D( heightMap, vUv + vec2( 0.0, 1.0 / resolution.y ) ).x;",
1380 | 
1381 | 				"gl_FragColor = vec4( ( 0.5 * normalize( vec3( val - valU, val - valV, height  ) ) + 0.5 ), 1.0 );",
1382 | 
1383 | 			"}",
1384 | 
1385 | 		].join("\n")
1386 | 
1387 | 	},
1388 | 
1389 | 	/* -------------------------------------------------------------------------
1390 | 	//	Screen-space ambient occlusion shader
1391 | 	//	- ported from
1392 | 	//		SSAO GLSL shader v1.2
1393 | 	//		assembled by Martins Upitis (martinsh) (http://devlog-martinsh.blogspot.com)
1394 | 	//		original technique is made by ArKano22 (http://www.gamedev.net/topic/550699-ssao-no-halo-artifacts/)
1395 | 	//	- modifications
1396 | 	//		- modified to use RGBA packed depth texture (use clear color 1,1,1,1 for depth pass)
1397 | 	//		- made fog more compatible with three.js linear fog
1398 | 	//		- refactoring and optimizations
1399 | 	 ------------------------------------------------------------------------- */
1400 | 
1401 | 	'ssao': {
1402 | 
1403 | 		uniforms: {
1404 | 
1405 | 			"tDiffuse": 	{ type: "t", value: 0, texture: null },
1406 | 			"tDepth":   	{ type: "t", value: 1, texture: null },
1407 | 			"size": 		{ type: "v2", value: new THREE.Vector2( 512, 512 ) },
1408 | 			"cameraNear":	{ type: "f", value: 1 },
1409 | 			"cameraFar":	{ type: "f", value: 100 },
1410 | 			"fogNear":		{ type: "f", value: 5 },
1411 | 			"fogFar":		{ type: "f", value: 100 },
1412 | 			"fogEnabled":	{ type: "i", value: 0 },
1413 | 			"aoClamp":		{ type: "f", value: 0.3 }
1414 | 
1415 | 		},
1416 | 
1417 | 		vertexShader: [
1418 | 
1419 | 			"varying vec2 vUv;",
1420 | 
1421 | 			"void main() {",
1422 | 
1423 | 				"vUv = vec2( uv.x, 1.0 - uv.y );",
1424 | 
1425 | 				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
1426 | 
1427 | 			"}"
1428 | 
1429 | 		].join("\n"),
1430 | 
1431 | 		fragmentShader: [
1432 | 
1433 | 			"uniform float cameraNear;",
1434 | 			"uniform float cameraFar;",
1435 | 
1436 | 			"uniform float fogNear;",
1437 | 			"uniform float fogFar;",
1438 | 
1439 | 			"uniform bool fogEnabled;",
1440 | 
1441 | 			"uniform vec2 size;",		// texture width, height
1442 | 			"uniform float aoClamp;", 	// depth clamp - reduces haloing at screen edges
1443 | 
1444 | 			"uniform sampler2D tDiffuse;",
1445 | 			"uniform sampler2D tDepth;",
1446 | 
1447 | 			"varying vec2 vUv;",
1448 | 
1449 | 			//"#define PI 3.14159265",
1450 | 			"#define DL 2.399963229728653", // PI * ( 3.0 - sqrt( 5.0 ) )
1451 | 			"#define EULER 2.718281828459045",
1452 | 
1453 | 			// helpers
1454 | 
1455 | 			"float width = size.x;", 	// texture width
1456 | 			"float height = size.y;", 	// texture height
1457 | 
1458 | 			"float cameraFarPlusNear = cameraFar + cameraNear;",
1459 | 			"float cameraFarMinusNear = cameraFar - cameraNear;",
1460 | 			"float cameraCoef = 2.0 * cameraNear;",
1461 | 
1462 | 			// user variables
1463 | 
1464 | 			"const int samples = 8;", 		// ao sample count
1465 | 			"const float radius = 5.0;", 	// ao radius
1466 | 
1467 | 			"const bool useNoise = false;", 		 // use noise instead of pattern for sample dithering
1468 | 			"const float noiseAmount = 0.0002;", // dithering amount
1469 | 
1470 | 			"const float diffArea = 0.4;", 		// self-shadowing reduction
1471 | 			"const float gDisplace = 0.4;", 	// gauss bell center
1472 | 
1473 | 			"const bool onlyAO = false;", 		// use only ambient occlusion pass?
1474 | 			"const float lumInfluence = 0.3;",  // how much luminance affects occlusion
1475 | 
1476 | 			// RGBA depth
1477 | 
1478 | 			"float unpackDepth( const in vec4 rgba_depth ) {",
1479 | 
1480 | 				"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 );",
1481 | 				"float depth = dot( rgba_depth, bit_shift );",
1482 | 				"return depth;",
1483 | 
1484 | 			"}",
1485 | 
1486 | 			// generating noise / pattern texture for dithering
1487 | 
1488 | 			"vec2 rand( const vec2 coord ) {",
1489 | 
1490 | 				"vec2 noise;",
1491 | 
1492 | 				"if ( useNoise ) {",
1493 | 
1494 | 					"float nx = dot ( coord, vec2( 12.9898, 78.233 ) );",
1495 | 					"float ny = dot ( coord, vec2( 12.9898, 78.233 ) * 2.0 );",
1496 | 
1497 | 					"noise = clamp( fract ( 43758.5453 * sin( vec2( nx, ny ) ) ), 0.0, 1.0 );",
1498 | 
1499 | 				"} else {",
1500 | 
1501 | 					"float ff = fract( 1.0 - coord.s * ( width / 2.0 ) );",
1502 | 					"float gg = fract( coord.t * ( height / 2.0 ) );",
1503 | 
1504 | 					"noise = vec2( 0.25, 0.75 ) * vec2( ff ) + vec2( 0.75, 0.25 ) * gg;",
1505 | 
1506 | 				"}",
1507 | 
1508 | 				"return ( noise * 2.0  - 1.0 ) * noiseAmount;",
1509 | 
1510 | 			"}",
1511 | 
1512 | 			"float doFog() {",
1513 | 
1514 | 				"float zdepth = unpackDepth( texture2D( tDepth, vUv ) );",
1515 | 				"float depth = -cameraFar * cameraNear / ( zdepth * cameraFarMinusNear - cameraFar );",
1516 | 
1517 | 				"return smoothstep( fogNear, fogFar, depth );",
1518 | 
1519 | 			"}",
1520 | 
1521 | 			"float readDepth( const in vec2 coord ) {",
1522 | 
1523 | 				//"return ( 2.0 * cameraNear ) / ( cameraFar + cameraNear - unpackDepth( texture2D( tDepth, coord ) ) * ( cameraFar - cameraNear ) );",
1524 | 				"return cameraCoef / ( cameraFarPlusNear - unpackDepth( texture2D( tDepth, coord ) ) * cameraFarMinusNear );",
1525 | 
1526 | 
1527 | 			"}",
1528 | 
1529 | 			"float compareDepths( const in float depth1, const in float depth2, inout int far ) {",
1530 | 
1531 | 				"float garea = 2.0;", 						 // gauss bell width
1532 | 				"float diff = ( depth1 - depth2 ) * 100.0;", // depth difference (0-100)
1533 | 
1534 | 				// reduce left bell width to avoid self-shadowing
1535 | 
1536 | 				"if ( diff < gDisplace ) {",
1537 | 
1538 | 					"garea = diffArea;",
1539 | 
1540 | 				"} else {",
1541 | 
1542 | 					"far = 1;",
1543 | 
1544 | 				"}",
1545 | 
1546 | 				"float dd = diff - gDisplace;",
1547 | 				"float gauss = pow( EULER, -2.0 * dd * dd / ( garea * garea ) );",
1548 | 				"return gauss;",
1549 | 
1550 | 			"}",
1551 | 
1552 | 			"float calcAO( float depth, float dw, float dh ) {",
1553 | 
1554 | 				"float dd = radius - depth * radius;",
1555 | 				"vec2 vv = vec2( dw, dh );",
1556 | 
1557 | 				"vec2 coord1 = vUv + dd * vv;",
1558 | 				"vec2 coord2 = vUv - dd * vv;",
1559 | 
1560 | 				"float temp1 = 0.0;",
1561 | 				"float temp2 = 0.0;",
1562 | 
1563 | 				"int far = 0;",
1564 | 				"temp1 = compareDepths( depth, readDepth( coord1 ), far );",
1565 | 
1566 | 				// DEPTH EXTRAPOLATION
1567 | 
1568 | 				"if ( far > 0 ) {",
1569 | 
1570 | 					"temp2 = compareDepths( readDepth( coord2 ), depth, far );",
1571 | 					"temp1 += ( 1.0 - temp1 ) * temp2;",
1572 | 
1573 | 				"}",
1574 | 
1575 | 				"return temp1;",
1576 | 
1577 | 			"}",
1578 | 
1579 | 			"void main() {",
1580 | 
1581 | 				"vec2 noise = rand( vUv );",
1582 | 				"float depth = readDepth( vUv );",
1583 | 
1584 | 				"float tt = clamp( depth, aoClamp, 1.0 );",
1585 | 
1586 | 				"float w = ( 1.0 / width )  / tt + ( noise.x * ( 1.0 - noise.x ) );",
1587 | 				"float h = ( 1.0 / height ) / tt + ( noise.y * ( 1.0 - noise.y ) );",
1588 | 
1589 | 				"float pw;",
1590 | 				"float ph;",
1591 | 
1592 | 				"float ao;",
1593 | 
1594 | 				"float dz = 1.0 / float( samples );",
1595 | 				"float z = 1.0 - dz / 2.0;",
1596 | 				"float l = 0.0;",
1597 | 
1598 | 				"for ( int i = 0; i <= samples; i ++ ) {",
1599 | 
1600 | 					"float r = sqrt( 1.0 - z );",
1601 | 
1602 | 					"pw = cos( l ) * r;",
1603 | 					"ph = sin( l ) * r;",
1604 | 					"ao += calcAO( depth, pw * w, ph * h );",
1605 | 					"z = z - dz;",
1606 | 					"l = l + DL;",
1607 | 
1608 | 				"}",
1609 | 
1610 | 				"ao /= float( samples );",
1611 | 				"ao = 1.0 - ao;",
1612 | 
1613 | 				"if ( fogEnabled ) {",
1614 | 
1615 | 					"ao = mix( ao, 1.0, doFog() );",
1616 | 
1617 | 				"}",
1618 | 
1619 | 				"vec3 color = texture2D( tDiffuse, vUv ).rgb;",
1620 | 
1621 | 				"vec3 lumcoeff = vec3( 0.299, 0.587, 0.114 );",
1622 | 				"float lum = dot( color.rgb, lumcoeff );",
1623 | 				"vec3 luminance = vec3( lum );",
1624 | 
1625 | 				"vec3 final = vec3( color * mix( vec3( ao ), vec3( 1.0 ), luminance * lumInfluence ) );", // mix( color * ao, white, luminance )
1626 | 
1627 | 				"if ( onlyAO ) {",
1628 | 
1629 | 					"final = vec3( mix( vec3( ao ), vec3( 1.0 ), luminance * lumInfluence ) );", // ambient occlusion only
1630 | 
1631 | 				"}",
1632 | 
1633 | 				"gl_FragColor = vec4( final, 1.0 );",
1634 | 
1635 | 			"}"
1636 | 
1637 | 		].join("\n")
1638 | 
1639 | 	},
1640 | 
1641 | 	/* -------------------------------------------------------------------------
1642 | 	//	Colorify shader
1643 | 	 ------------------------------------------------------------------------- */
1644 | 
1645 | 	'colorify': {
1646 | 
1647 | 		uniforms: {
1648 | 
1649 | 			tDiffuse: { type: "t", value: 0, texture: null },
1650 | 			color:    { type: "c", value: new THREE.Color( 0xffffff ) }
1651 | 
1652 | 		},
1653 | 
1654 | 		vertexShader: [
1655 | 
1656 | 			"varying vec2 vUv;",
1657 | 
1658 | 			"void main() {",
1659 | 
1660 | 				"vUv = vec2( uv.x, 1.0 - uv.y );",
1661 | 				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
1662 | 
1663 | 			"}"
1664 | 
1665 | 		].join("\n"),
1666 | 
1667 | 		fragmentShader: [
1668 | 
1669 | 			"uniform vec3 color;",
1670 | 			"uniform sampler2D tDiffuse;",
1671 | 
1672 | 			"varying vec2 vUv;",
1673 | 
1674 | 			"void main() {",
1675 | 
1676 | 				"vec4 texel = texture2D( tDiffuse, vUv );",
1677 | 
1678 | 				"vec3 luma = vec3( 0.299, 0.587, 0.114 );",
1679 | 				"float v = dot( texel.xyz, luma );",
1680 | 
1681 | 				"gl_FragColor = vec4( v * color, texel.w );",
1682 | 
1683 | 			"}"
1684 | 
1685 | 		].join("\n")
1686 | 
1687 | 	},
1688 | 
1689 | 	/* -------------------------------------------------------------------------
1690 | 	//	Unpack RGBA depth shader
1691 | 	//	- show RGBA encoded depth as monochrome color
1692 | 	 ------------------------------------------------------------------------- */
1693 | 
1694 | 	'unpackDepthRGBA': {
1695 | 
1696 | 		uniforms: {
1697 | 
1698 | 			tDiffuse: { type: "t", value: 0, texture: null },
1699 | 			opacity:  { type: "f", value: 1.0 }
1700 | 
1701 | 		},
1702 | 
1703 | 		vertexShader: [
1704 | 
1705 | 			"varying vec2 vUv;",
1706 | 
1707 | 			"void main() {",
1708 | 
1709 | 				"vUv = vec2( uv.x, 1.0 - uv.y );",
1710 | 				"gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
1711 | 
1712 | 			"}"
1713 | 
1714 | 		].join("\n"),
1715 | 
1716 | 		fragmentShader: [
1717 | 
1718 | 			"uniform float opacity;",
1719 | 
1720 | 			"uniform sampler2D tDiffuse;",
1721 | 
1722 | 			"varying vec2 vUv;",
1723 | 
1724 | 			// RGBA depth
1725 | 
1726 | 			"float unpackDepth( const in vec4 rgba_depth ) {",
1727 | 
1728 | 				"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 );",
1729 | 				"float depth = dot( rgba_depth, bit_shift );",
1730 | 				"return depth;",
1731 | 
1732 | 			"}",
1733 | 
1734 | 			"void main() {",
1735 | 
1736 | 				"float depth = 1.0 - unpackDepth( texture2D( tDiffuse, vUv ) );",
1737 | 				"gl_FragColor = opacity * vec4( vec3( depth ), 1.0 );",
1738 | 
1739 | 			"}"
1740 | 
1741 | 		].join("\n")
1742 | 
1743 | 	},
1744 | 
1745 | 	// METHODS
1746 | 
1747 | 	buildKernel: function( sigma ) {
1748 | 
1749 | 		// We lop off the sqrt(2 * pi) * sigma term, since we're going to normalize anyway.
1750 | 
1751 | 		function gauss( x, sigma ) {
1752 | 
1753 | 			return Math.exp( - ( x * x ) / ( 2.0 * sigma * sigma ) );
1754 | 
1755 | 		}
1756 | 
1757 | 		var i, values, sum, halfWidth, kMaxKernelSize = 25, kernelSize = 2 * Math.ceil( sigma * 3.0 ) + 1;
1758 | 
1759 | 		if ( kernelSize > kMaxKernelSize ) kernelSize = kMaxKernelSize;
1760 | 		halfWidth = ( kernelSize - 1 ) * 0.5
1761 | 
1762 | 		values = new Array( kernelSize );
1763 | 		sum = 0.0;
1764 | 		for ( i = 0; i < kernelSize; ++i ) {
1765 | 
1766 | 			values[ i ] = gauss( i - halfWidth, sigma );
1767 | 			sum += values[ i ];
1768 | 
1769 | 		}
1770 | 
1771 | 		// normalize the kernel
1772 | 
1773 | 		for ( i = 0; i < kernelSize; ++i ) values[ i ] /= sum;
1774 | 
1775 | 		return values;
1776 | 
1777 | 	}
1778 | 
1779 | };
1780 | 


--------------------------------------------------------------------------------