+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
-
-
-
-
Your browser doesn't support the features required by impress.js, so you are presented with a simplified version of this presentation.
-
For the best experience please use the latest Chrome, Safari or Firefox browser.
-
-
-
-
-
-
- Aren’t you just bored with all those slides-based presentations?
-
-
-
-
- Don’t you think that presentations given in modern browsers shouldn’t copy the limits of ‘classic’ slide decks?
-
-
-
- Would you like to impress your audience with stunning visualization of your talk?
-
-
-
-
- then you should try
-
impress.js*
-
-
-
-
-
-
It’s a presentation tool
- inspired by the idea behind prezi.com
- and based on the power of CSS3 transforms and transitions in modern browsers.
-
-
-
-
visualize your big thoughts
-
-
-
-
-
-
-
-
by positioning, rotating and scaling them on an infinite canvas
-
-
-
-
the only limit is your imagination
-
-
-
-
-
-
-
-
-
have you noticed it’s in 3D*?
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
Use a spacebar or arrow keys to navigate.
- Press 'P' to launch speaker console.
-
-
+
+
+
+
+
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/js/impress.js b/js/impress.js
index bb99522d6..39e3434a1 100644
--- a/js/impress.js
+++ b/js/impress.js
@@ -18,6 +18,8 @@
* source: http://github.com/impress/impress.js/
*/
+let GlobalDuration = 300;
+let currentState = null;
// You are one of those who like to know how things work inside?
// Let me show you the cogs that make impress.js run...
( function( document, window ) {
@@ -168,14 +170,14 @@
// Some default config values.
var defaults = {
- width: 1024,
- height: 768,
+ width: 1920,
+ height: 1080,
maxScale: 1,
minScale: 0,
perspective: 1000,
- transitionDuration: 1000
+ transitionDuration: GlobalDuration
};
// It's just an empty function ... and a useless comment.
@@ -224,7 +226,7 @@
var activeStep = null;
// Current state (position, rotation and scale) of the presentation
- var currentState = null;
+ //var currentState = null;
// Array of step elements
var steps = null;
@@ -2402,6 +2404,7 @@
// 82: R
registerKeyEvent( [ 82 ], timerReset );
+
// Cleanup
consoleWindow.onbeforeunload = function() {
diff --git a/three/jsutil/AnimationClipCreator.js b/three/jsutil/AnimationClipCreator.js
new file mode 100644
index 000000000..b87f7153e
--- /dev/null
+++ b/three/jsutil/AnimationClipCreator.js
@@ -0,0 +1,114 @@
+/**
+ *
+ * Creator of typical test AnimationClips / KeyframeTracks
+ *
+ * @author Ben Houston / http://clara.io/
+ * @author David Sarno / http://lighthaus.us/
+ */
+
+THREE.AnimationClipCreator = function () {};
+
+THREE.AnimationClipCreator.CreateRotationAnimation = function ( period, axis ) {
+
+ var times = [ 0, period ], values = [ 0, 360 ];
+
+ axis = axis || 'x';
+ var trackName = '.rotation[' + axis + ']';
+
+ var track = new THREE.NumberKeyframeTrack( trackName, times, values );
+
+ return new THREE.AnimationClip( null, period, [ track ] );
+
+};
+
+THREE.AnimationClipCreator.CreateScaleAxisAnimation = function ( period, axis ) {
+
+ var times = [ 0, period ], values = [ 0, 1 ];
+
+ axis = axis || 'x';
+ var trackName = '.scale[' + axis + ']';
+
+ var track = new THREE.NumberKeyframeTrack( trackName, times, values );
+
+ return new THREE.AnimationClip( null, period, [ track ] );
+
+};
+
+THREE.AnimationClipCreator.CreateShakeAnimation = function ( duration, shakeScale ) {
+
+ var times = [], values = [], tmp = new THREE.Vector3();
+
+ for ( var i = 0; i < duration * 10; i ++ ) {
+
+ times.push( i / 10 );
+
+ tmp.set( Math.random() * 2.0 - 1.0, Math.random() * 2.0 - 1.0, Math.random() * 2.0 - 1.0 ).
+ multiply( shakeScale ).
+ toArray( values, values.length );
+
+ }
+
+ var trackName = '.position';
+
+ var track = new THREE.VectorKeyframeTrack( trackName, times, values );
+
+ return new THREE.AnimationClip( null, duration, [ track ] );
+
+};
+
+
+THREE.AnimationClipCreator.CreatePulsationAnimation = function ( duration, pulseScale ) {
+
+ var times = [], values = [], tmp = new THREE.Vector3();
+
+ for ( var i = 0; i < duration * 10; i ++ ) {
+
+ times.push( i / 10 );
+
+ var scaleFactor = Math.random() * pulseScale;
+ tmp.set( scaleFactor, scaleFactor, scaleFactor ).
+ toArray( values, values.length );
+
+ }
+
+ var trackName = '.scale';
+
+ var track = new THREE.VectorKeyframeTrack( trackName, times, values );
+
+ return new THREE.AnimationClip( null, duration, [ track ] );
+
+};
+
+
+THREE.AnimationClipCreator.CreateVisibilityAnimation = function ( duration ) {
+
+ var times = [ 0, duration / 2, duration ], values = [ true, false, true ];
+
+ var trackName = '.visible';
+
+ var track = new THREE.BooleanKeyframeTrack( trackName, times, values );
+
+ return new THREE.AnimationClip( null, duration, [ track ] );
+
+};
+
+
+THREE.AnimationClipCreator.CreateMaterialColorAnimation = function ( duration, colors ) {
+
+ var times = [], values = [],
+ timeStep = duration / colors.length;
+
+ for ( var i = 0; i <= colors.length; i ++ ) {
+
+ times.push( i * timeStep );
+ values.push( colors[ i % colors.length ] );
+
+ }
+
+ var trackName = '.material[0].color';
+
+ var track = new THREE.ColorKeyframeTrack( trackName, times, values );
+
+ return new THREE.AnimationClip( null, duration, [ track ] );
+
+};
diff --git a/three/jsutil/Car.js b/three/jsutil/Car.js
new file mode 100644
index 000000000..8a9791a0b
--- /dev/null
+++ b/three/jsutil/Car.js
@@ -0,0 +1,305 @@
+/**
+ * @author alteredq / http://alteredqualia.com/
+ * @author Lewy Blue https://github.com/looeee
+ *
+ * The model is expected to follow real world car proportions. You can try unusual car types
+ * but your results may be unexpected. Scaled models are also not supported.
+ *
+ * Defaults are rough estimates for a real world scale car model
+ *
+ */
+
+THREE.Car = ( function ( ) {
+
+ // private variables
+ var steeringWheelSpeed = 1.5;
+ var maxSteeringRotation = 0.6;
+
+ var acceleration = 0;
+
+ var maxSpeedReverse, accelerationReverse, deceleration;
+
+ var controlKeys = { LEFT: 37, UP: 38, RIGHT: 39, DOWN: 40, BRAKE: 32 };
+
+ var wheelOrientation = 0;
+ var carOrientation = 0;
+
+ var root = null;
+
+ var frontLeftWheelRoot = null;
+ var frontRightWheelRoot = null;
+
+ var frontLeftWheel = new THREE.Group();
+ var frontRightWheel = new THREE.Group();
+ var backLeftWheel = null;
+ var backRightWheel = null;
+
+ var steeringWheel = null;
+
+ var wheelDiameter = 1;
+ var length = 1;
+
+ var loaded = false;
+
+ var controls = {
+
+ brake: false,
+ moveForward: false,
+ moveBackward: false,
+ moveLeft: false,
+ moveRight: false
+
+ };
+
+ function Car( maxSpeed, acceleration, brakePower, turningRadius, keys ) {
+
+ this.enabled = true;
+
+ this.elemNames = {
+ flWheel: 'wheel_fl',
+ frWheel: 'wheel_fr',
+ rlWheel: 'wheel_rl',
+ rrWheel: 'wheel_rr',
+ steeringWheel: 'steering_wheel', // set to null to disable
+ };
+
+ // km/hr
+ this.maxSpeed = maxSpeed || 180;
+ maxSpeedReverse = - this.maxSpeed * 0.25;
+
+ // m/s
+ this.acceleration = acceleration || 10;
+ accelerationReverse = this.acceleration * 0.5;
+
+ // metres
+ this.turningRadius = turningRadius || 6;
+
+ // m/s
+ deceleration = this.acceleration * 2;
+
+ // multiplied with deceleration, so breaking deceleration = ( acceleration * 2 * brakePower ) m/s
+ this.brakePower = brakePower || 10;
+
+ // exposed so that a user can use this for various effect, e.g blur
+ this.speed = 0;
+
+ // keys used to control car - by default the arrow keys and space to brake
+ controlKeys = keys || controlKeys;
+
+ // local axes of rotation - these are likely to vary between models
+ this.wheelRotationAxis = 'x';
+ this.wheelTurnAxis = 'z';
+ this.steeringWheelTurnAxis = 'y';
+
+ document.addEventListener( 'keydown', this.onKeyDown, false );
+ document.addEventListener( 'keyup', this.onKeyUp, false );
+
+ }
+
+ Car.prototype = {
+
+ constructor: Car,
+
+ onKeyDown: function ( event ) {
+
+ switch ( event.keyCode ) {
+
+ case controlKeys.BRAKE:
+ controls.brake = true;
+ controls.moveForward = false;
+ controls.moveBackward = false;
+ break;
+
+ case controlKeys.UP: controls.moveForward = true; break;
+
+ case controlKeys.DOWN: controls.moveBackward = true; break;
+
+ case controlKeys.LEFT: controls.moveLeft = true; break;
+
+ case controlKeys.RIGHT: controls.moveRight = true; break;
+
+ }
+
+ },
+
+ onKeyUp: function ( event ) {
+
+ switch ( event.keyCode ) {
+
+ case controlKeys.BRAKE: controls.brake = false; break;
+
+ case controlKeys.UP: controls.moveForward = false; break;
+
+ case controlKeys.DOWN: controls.moveBackward = false; break;
+
+ case controlKeys.LEFT: controls.moveLeft = false; break;
+
+ case controlKeys.RIGHT: controls.moveRight = false; break;
+
+ }
+
+ },
+
+ dispose: function () {
+
+ document.removeEventListener( 'keydown', this.onKeyDown, false );
+ document.removeEventListener( 'keyup', this.onKeyUp, false );
+
+ },
+
+ update: function ( delta ) {
+
+ if ( ! loaded || ! this.enabled ) return;
+
+ var brakingDeceleration = 1;
+
+ if ( controls.brake ) brakingDeceleration = this.brakePower;
+
+ if ( controls.moveForward ) {
+
+ this.speed = THREE.Math.clamp( this.speed + delta * this.acceleration, maxSpeedReverse, this.maxSpeed );
+ acceleration = THREE.Math.clamp( acceleration + delta, - 1, 1 );
+
+ }
+
+ if ( controls.moveBackward ) {
+
+ this.speed = THREE.Math.clamp( this.speed - delta * accelerationReverse, maxSpeedReverse, this.maxSpeed );
+ acceleration = THREE.Math.clamp( acceleration - delta, - 1, 1 );
+
+ }
+
+ if ( controls.moveLeft ) {
+
+ wheelOrientation = THREE.Math.clamp( wheelOrientation + delta * steeringWheelSpeed, - maxSteeringRotation, maxSteeringRotation );
+
+ }
+
+ if ( controls.moveRight ) {
+
+ wheelOrientation = THREE.Math.clamp( wheelOrientation - delta * steeringWheelSpeed, - maxSteeringRotation, maxSteeringRotation );
+
+ }
+
+ // this.speed decay
+ if ( ! ( controls.moveForward || controls.moveBackward ) ) {
+
+ if ( this.speed > 0 ) {
+
+ var k = exponentialEaseOut( this.speed / this.maxSpeed );
+
+ this.speed = THREE.Math.clamp( this.speed - k * delta * deceleration * brakingDeceleration, 0, this.maxSpeed );
+ acceleration = THREE.Math.clamp( acceleration - k * delta, 0, 1 );
+
+ } else {
+
+ var k = exponentialEaseOut( this.speed / maxSpeedReverse );
+
+ this.speed = THREE.Math.clamp( this.speed + k * delta * accelerationReverse * brakingDeceleration, maxSpeedReverse, 0 );
+ acceleration = THREE.Math.clamp( acceleration + k * delta, - 1, 0 );
+
+ }
+
+ }
+
+ // steering decay
+ if ( ! ( controls.moveLeft || controls.moveRight ) ) {
+
+ if ( wheelOrientation > 0 ) {
+
+ wheelOrientation = THREE.Math.clamp( wheelOrientation - delta * steeringWheelSpeed, 0, maxSteeringRotation );
+
+ } else {
+
+ wheelOrientation = THREE.Math.clamp( wheelOrientation + delta * steeringWheelSpeed, - maxSteeringRotation, 0 );
+
+ }
+
+ }
+
+ var forwardDelta = - this.speed * delta;
+
+ carOrientation -= ( forwardDelta * this.turningRadius * 0.02 ) * wheelOrientation;
+
+ // movement of car
+ root.position.x += Math.sin( carOrientation ) * forwardDelta * length;
+ root.position.z += Math.cos( carOrientation ) * forwardDelta * length;
+
+ // angle of car
+ root.rotation.y = carOrientation;
+
+ // wheels rolling
+ var angularSpeedRatio = - 2 / wheelDiameter;
+
+ var wheelDelta = forwardDelta * angularSpeedRatio * length;
+
+ frontLeftWheel.rotation[ this.wheelRotationAxis ] -= wheelDelta;
+ frontRightWheel.rotation[ this.wheelRotationAxis ] -= wheelDelta;
+ backLeftWheel.rotation[ this.wheelRotationAxis ] -= wheelDelta;
+ backRightWheel.rotation[ this.wheelRotationAxis ] -= wheelDelta;
+
+ // rotation while steering
+ frontLeftWheelRoot.rotation[ this.wheelTurnAxis ] = wheelOrientation;
+ frontRightWheelRoot.rotation[ this.wheelTurnAxis ] = wheelOrientation;
+
+ steeringWheel.rotation[ this.steeringWheelTurnAxis ] = -wheelOrientation * 6;
+
+ },
+
+ setModel: function ( model, elemNames ) {
+
+ if ( elemNames ) this.elemNames = elemNames;
+
+ root = model;
+
+ this.setupWheels();
+ this.computeDimensions();
+
+ loaded = true;
+
+ },
+
+ setupWheels: function () {
+
+ frontLeftWheelRoot = root.getObjectByName( this.elemNames.flWheel );
+ frontRightWheelRoot = root.getObjectByName( this.elemNames.frWheel );
+ backLeftWheel = root.getObjectByName( this.elemNames.rlWheel );
+ backRightWheel = root.getObjectByName( this.elemNames.rrWheel );
+
+ if ( this.elemNames.steeringWheel !== null ) steeringWheel = root.getObjectByName( this.elemNames.steeringWheel );
+
+ while ( frontLeftWheelRoot.children.length > 0 ) frontLeftWheel.add( frontLeftWheelRoot.children[ 0 ] );
+ while ( frontRightWheelRoot.children.length > 0 ) frontRightWheel.add( frontRightWheelRoot.children[ 0 ] );
+
+ frontLeftWheelRoot.add( frontLeftWheel );
+ frontRightWheelRoot.add( frontRightWheel );
+
+ },
+
+ computeDimensions: function () {
+
+ var bb = new THREE.Box3().setFromObject( frontLeftWheelRoot );
+
+ var size = new THREE.Vector3();
+ bb.getSize( size );
+
+ wheelDiameter = Math.max( size.x, size.y, size.z );
+
+ bb.setFromObject( root );
+
+ size = bb.getSize( size );
+ length = Math.max( size.x, size.y, size.z );
+
+ }
+
+ };
+
+ function exponentialEaseOut( k ) {
+
+ return k === 1 ? 1 : - Math.pow( 2, - 10 * k ) + 1;
+
+ }
+
+ return Car;
+
+} )();
diff --git a/three/jsutil/Cloth.js b/three/jsutil/Cloth.js
new file mode 100644
index 000000000..47c78b89a
--- /dev/null
+++ b/three/jsutil/Cloth.js
@@ -0,0 +1,336 @@
+/*
+ * Cloth Simulation using a relaxed constraints solver
+ */
+
+// Suggested Readings
+
+// Advanced Character Physics by Thomas Jakobsen Character
+// http://freespace.virgin.net/hugo.elias/models/m_cloth.htm
+// http://en.wikipedia.org/wiki/Cloth_modeling
+// http://cg.alexandra.dk/tag/spring-mass-system/
+// Real-time Cloth Animation http://www.darwin3d.com/gamedev/articles/col0599.pdf
+
+var DAMPING = 0.03;
+var DRAG = 1 - DAMPING;
+var MASS = 0.1;
+var restDistance = 25;
+
+var xSegs = 10;
+var ySegs = 10;
+
+var clothFunction = plane( restDistance * xSegs, restDistance * ySegs );
+
+var cloth = new Cloth( xSegs, ySegs );
+
+var GRAVITY = 981 * 1.4;
+var gravity = new THREE.Vector3( 0, - GRAVITY, 0 ).multiplyScalar( MASS );
+
+
+var TIMESTEP = 18 / 1000;
+var TIMESTEP_SQ = TIMESTEP * TIMESTEP;
+
+var pins = [];
+
+
+var wind = true;
+var windStrength = 2;
+var windForce = new THREE.Vector3( 0, 0, 0 );
+
+var ballPosition = new THREE.Vector3( 0, - 45, 0 );
+var ballSize = 60; //40
+
+var tmpForce = new THREE.Vector3();
+
+var lastTime;
+
+
+function plane( width, height ) {
+
+ return function ( u, v, target ) {
+
+ var x = ( u - 0.5 ) * width;
+ var y = ( v + 0.5 ) * height;
+ var z = 0;
+
+ target.set( x, y, z );
+
+ };
+
+}
+
+function Particle( x, y, z, mass ) {
+
+ this.position = new THREE.Vector3();
+ this.previous = new THREE.Vector3();
+ this.original = new THREE.Vector3();
+ this.a = new THREE.Vector3( 0, 0, 0 ); // acceleration
+ this.mass = mass;
+ this.invMass = 1 / mass;
+ this.tmp = new THREE.Vector3();
+ this.tmp2 = new THREE.Vector3();
+
+ // init
+
+ clothFunction( x, y, this.position ); // position
+ clothFunction( x, y, this.previous ); // previous
+ clothFunction( x, y, this.original );
+
+}
+
+// Force -> Acceleration
+
+Particle.prototype.addForce = function ( force ) {
+
+ this.a.add(
+ this.tmp2.copy( force ).multiplyScalar( this.invMass )
+ );
+
+};
+
+
+// Performs Verlet integration
+
+Particle.prototype.integrate = function ( timesq ) {
+
+ var newPos = this.tmp.subVectors( this.position, this.previous );
+ newPos.multiplyScalar( DRAG ).add( this.position );
+ newPos.add( this.a.multiplyScalar( timesq ) );
+
+ this.tmp = this.previous;
+ this.previous = this.position;
+ this.position = newPos;
+
+ this.a.set( 0, 0, 0 );
+
+};
+
+
+var diff = new THREE.Vector3();
+
+function satisfyConstraints( p1, p2, distance ) {
+
+ diff.subVectors( p2.position, p1.position );
+ var currentDist = diff.length();
+ if ( currentDist === 0 ) return; // prevents division by 0
+ var correction = diff.multiplyScalar( 1 - distance / currentDist );
+ var correctionHalf = correction.multiplyScalar( 0.5 );
+ p1.position.add( correctionHalf );
+ p2.position.sub( correctionHalf );
+
+}
+
+
+function Cloth( w, h ) {
+
+ w = w || 10;
+ h = h || 10;
+ this.w = w;
+ this.h = h;
+
+ var particles = [];
+ var constraints = [];
+
+ var u, v;
+
+ // Create particles
+ for ( v = 0; v <= h; v ++ ) {
+
+ for ( u = 0; u <= w; u ++ ) {
+
+ particles.push(
+ new Particle( u / w, v / h, 0, MASS )
+ );
+
+ }
+
+ }
+
+ // Structural
+
+ for ( v = 0; v < h; v ++ ) {
+
+ for ( u = 0; u < w; u ++ ) {
+
+ constraints.push( [
+ particles[ index( u, v ) ],
+ particles[ index( u, v + 1 ) ],
+ restDistance
+ ] );
+
+ constraints.push( [
+ particles[ index( u, v ) ],
+ particles[ index( u + 1, v ) ],
+ restDistance
+ ] );
+
+ }
+
+ }
+
+ for ( u = w, v = 0; v < h; v ++ ) {
+
+ constraints.push( [
+ particles[ index( u, v ) ],
+ particles[ index( u, v + 1 ) ],
+ restDistance
+
+ ] );
+
+ }
+
+ for ( v = h, u = 0; u < w; u ++ ) {
+
+ constraints.push( [
+ particles[ index( u, v ) ],
+ particles[ index( u + 1, v ) ],
+ restDistance
+ ] );
+
+ }
+
+
+ // While many systems use shear and bend springs,
+ // the relaxed constraints model seems to be just fine
+ // using structural springs.
+ // Shear
+ // var diagonalDist = Math.sqrt(restDistance * restDistance * 2);
+
+
+ // for (v=0;v
0
+
+ if ( ! object.geometry.isBufferGeometry ) {
+
+ console.error( 'THREE.ConvexObjectBreaker.prepareBreakableObject(): Parameter object must have a BufferGeometry.' );
+
+ }
+
+ var userData = object.userData;
+ userData.mass = mass;
+ userData.velocity = velocity.clone();
+ userData.angularVelocity = angularVelocity.clone();
+ userData.breakable = breakable;
+
+ },
+
+ /*
+ * @param {int} maxRadialIterations Iterations for radial cuts.
+ * @param {int} maxRandomIterations Max random iterations for not-radial cuts
+ *
+ * Returns the array of pieces
+ */
+ subdivideByImpact: function ( object, pointOfImpact, normal, maxRadialIterations, maxRandomIterations ) {
+
+ var debris = [];
+
+ var tempPlane1 = this.tempPlane1;
+ var tempPlane2 = this.tempPlane2;
+
+ this.tempVector3.addVectors( pointOfImpact, normal );
+ tempPlane1.setFromCoplanarPoints( pointOfImpact, object.position, this.tempVector3 );
+
+ var maxTotalIterations = maxRandomIterations + maxRadialIterations;
+
+ var scope = this;
+
+ function subdivideRadial( subObject, startAngle, endAngle, numIterations ) {
+
+ if ( Math.random() < numIterations * 0.05 || numIterations > maxTotalIterations ) {
+
+ debris.push( subObject );
+
+ return;
+
+ }
+
+ var angle = Math.PI;
+
+ if ( numIterations === 0 ) {
+
+ tempPlane2.normal.copy( tempPlane1.normal );
+ tempPlane2.constant = tempPlane1.constant;
+
+ } else {
+
+ if ( numIterations <= maxRadialIterations ) {
+
+ angle = ( endAngle - startAngle ) * ( 0.2 + 0.6 * Math.random() ) + startAngle;
+
+ // Rotate tempPlane2 at impact point around normal axis and the angle
+ scope.tempVector3_2.copy( object.position ).sub( pointOfImpact ).applyAxisAngle( normal, angle ).add( pointOfImpact );
+ tempPlane2.setFromCoplanarPoints( pointOfImpact, scope.tempVector3, scope.tempVector3_2 );
+
+ } else {
+
+ angle = ( ( 0.5 * ( numIterations & 1 ) ) + 0.2 * ( 2 - Math.random() ) ) * Math.PI;
+
+ // Rotate tempPlane2 at object position around normal axis and the angle
+ scope.tempVector3_2.copy( pointOfImpact ).sub( subObject.position ).applyAxisAngle( normal, angle ).add( subObject.position );
+ scope.tempVector3_3.copy( normal ).add( subObject.position );
+ tempPlane2.setFromCoplanarPoints( subObject.position, scope.tempVector3_3, scope.tempVector3_2 );
+
+ }
+
+ }
+
+ // Perform the cut
+ scope.cutByPlane( subObject, tempPlane2, scope.tempResultObjects );
+
+ var obj1 = scope.tempResultObjects.object1;
+ var obj2 = scope.tempResultObjects.object2;
+
+ if ( obj1 ) {
+
+ subdivideRadial( obj1, startAngle, angle, numIterations + 1 );
+
+ }
+
+ if ( obj2 ) {
+
+ subdivideRadial( obj2, angle, endAngle, numIterations + 1 );
+
+ }
+
+ }
+
+ subdivideRadial( object, 0, 2 * Math.PI, 0 );
+
+ return debris;
+
+ },
+
+ cutByPlane: function ( object, plane, output ) {
+
+ // Returns breakable objects in output.object1 and output.object2 members, the resulting 2 pieces of the cut.
+ // object2 can be null if the plane doesn't cut the object.
+ // object1 can be null only in case of internal error
+ // Returned value is number of pieces, 0 for error.
+
+ var geometry = object.geometry;
+ var coords = geometry.attributes.position.array;
+ var normals = geometry.attributes.normal.array;
+
+ var numPoints = coords.length / 3;
+ var numFaces = numPoints / 3;
+
+ var indices = geometry.getIndex();
+
+ if ( indices ) {
+
+ indices = indices.array;
+ numFaces = indices.length / 3;
+
+ }
+
+ function getVertexIndex( faceIdx, vert ) {
+
+ // vert = 0, 1 or 2.
+
+ var idx = faceIdx * 3 + vert;
+
+ return indices ? indices[ idx ] : idx;
+
+ }
+
+ var points1 = [];
+ var points2 = [];
+
+ var delta = this.smallDelta;
+
+ // Reset segments mark
+ var numPointPairs = numPoints * numPoints;
+ for ( var i = 0; i < numPointPairs; i ++ ) this.segments[ i ] = false;
+
+ var p0 = this.tempVector3_P0;
+ var p1 = this.tempVector3_P1;
+ var n0 = this.tempVector3_N0;
+ var n1 = this.tempVector3_N1;
+
+ // Iterate through the faces to mark edges shared by coplanar faces
+ for ( var i = 0; i < numFaces - 1; i ++ ) {
+
+ var a1 = getVertexIndex( i, 0 );
+ var b1 = getVertexIndex( i, 1 );
+ var c1 = getVertexIndex( i, 2 );
+
+ // Assuming all 3 vertices have the same normal
+ n0.set( normals[ a1 ], normals[ a1 ] + 1, normals[ a1 ] + 2 );
+
+ for ( var j = i + 1; j < numFaces; j ++ ) {
+
+ var a2 = getVertexIndex( j, 0 );
+ var b2 = getVertexIndex( j, 1 );
+ var c2 = getVertexIndex( j, 2 );
+
+ // Assuming all 3 vertices have the same normal
+ n1.set( normals[ a2 ], normals[ a2 ] + 1, normals[ a2 ] + 2 );
+
+ var coplanar = 1 - n0.dot( n1 ) < delta;
+
+ if ( coplanar ) {
+
+ if ( a1 === a2 || a1 === b2 || a1 === c2 ) {
+
+ if ( b1 === a2 || b1 === b2 || b1 === c2 ) {
+
+ this.segments[ a1 * numPoints + b1 ] = true;
+ this.segments[ b1 * numPoints + a1 ] = true;
+
+ } else {
+
+ this.segments[ c1 * numPoints + a1 ] = true;
+ this.segments[ a1 * numPoints + c1 ] = true;
+
+ }
+
+ } else if ( b1 === a2 || b1 === b2 || b1 === c2 ) {
+
+ this.segments[ c1 * numPoints + b1 ] = true;
+ this.segments[ b1 * numPoints + c1 ] = true;
+
+ }
+
+ }
+
+ }
+
+ }
+
+ // Transform the plane to object local space
+ var localPlane = this.tempPlane_Cut;
+ object.updateMatrix();
+ THREE.ConvexObjectBreaker.transformPlaneToLocalSpace( plane, object.matrix, localPlane );
+
+ // Iterate through the faces adding points to both pieces
+ for ( var i = 0; i < numFaces; i ++ ) {
+
+ var va = getVertexIndex( i, 0 );
+ var vb = getVertexIndex( i, 1 );
+ var vc = getVertexIndex( i, 2 );
+
+ for ( var segment = 0; segment < 3; segment ++ ) {
+
+ var i0 = segment === 0 ? va : ( segment === 1 ? vb : vc );
+ var i1 = segment === 0 ? vb : ( segment === 1 ? vc : va );
+
+ var segmentState = this.segments[ i0 * numPoints + i1 ];
+
+ if ( segmentState ) continue; // The segment already has been processed in another face
+
+ // Mark segment as processed (also inverted segment)
+ this.segments[ i0 * numPoints + i1 ] = true;
+ this.segments[ i1 * numPoints + i0 ] = true;
+
+ p0.set( coords[ 3 * i0 ], coords[ 3 * i0 + 1 ], coords[ 3 * i0 + 2 ] );
+ p1.set( coords[ 3 * i1 ], coords[ 3 * i1 + 1 ], coords[ 3 * i1 + 2 ] );
+
+ // mark: 1 for negative side, 2 for positive side, 3 for coplanar point
+ var mark0 = 0;
+
+ var d = localPlane.distanceToPoint( p0 );
+
+ if ( d > delta ) {
+
+ mark0 = 2;
+ points2.push( p0.clone() );
+
+ } else if ( d < - delta ) {
+
+ mark0 = 1;
+ points1.push( p0.clone() );
+
+ } else {
+
+ mark0 = 3;
+ points1.push( p0.clone() );
+ points2.push( p0.clone() );
+
+ }
+
+ // mark: 1 for negative side, 2 for positive side, 3 for coplanar point
+ var mark1 = 0;
+
+ var d = localPlane.distanceToPoint( p1 );
+
+ if ( d > delta ) {
+
+ mark1 = 2;
+ points2.push( p1.clone() );
+
+ } else if ( d < - delta ) {
+
+ mark1 = 1;
+ points1.push( p1.clone() );
+
+ } else {
+
+ mark1 = 3;
+ points1.push( p1.clone() );
+ points2.push( p1.clone() );
+
+ }
+
+ if ( ( mark0 === 1 && mark1 === 2 ) || ( mark0 === 2 && mark1 === 1 ) ) {
+
+ // Intersection of segment with the plane
+
+ this.tempLine1.start.copy( p0 );
+ this.tempLine1.end.copy( p1 );
+
+ var intersection = new THREE.Vector3();
+ intersection = localPlane.intersectLine( this.tempLine1, intersection );
+
+ if ( intersection === undefined ) {
+
+ // Shouldn't happen
+ console.error( "Internal error: segment does not intersect plane." );
+ output.segmentedObject1 = null;
+ output.segmentedObject2 = null;
+ return 0;
+
+ }
+
+ points1.push( intersection );
+ points2.push( intersection.clone() );
+
+ }
+
+ }
+
+ }
+
+ // Calculate debris mass (very fast and imprecise):
+ var newMass = object.userData.mass * 0.5;
+
+ // Calculate debris Center of Mass (again fast and imprecise)
+ this.tempCM1.set( 0, 0, 0 );
+ var radius1 = 0;
+ var numPoints1 = points1.length;
+
+ if ( numPoints1 > 0 ) {
+
+ for ( var i = 0; i < numPoints1; i ++ ) this.tempCM1.add( points1[ i ] );
+
+ this.tempCM1.divideScalar( numPoints1 );
+ for ( var i = 0; i < numPoints1; i ++ ) {
+
+ var p = points1[ i ];
+ p.sub( this.tempCM1 );
+ radius1 = Math.max( radius1, p.x, p.y, p.z );
+
+ }
+ this.tempCM1.add( object.position );
+
+ }
+
+ this.tempCM2.set( 0, 0, 0 );
+ var radius2 = 0;
+ var numPoints2 = points2.length;
+ if ( numPoints2 > 0 ) {
+
+ for ( var i = 0; i < numPoints2; i ++ ) this.tempCM2.add( points2[ i ] );
+
+ this.tempCM2.divideScalar( numPoints2 );
+ for ( var i = 0; i < numPoints2; i ++ ) {
+
+ var p = points2[ i ];
+ p.sub( this.tempCM2 );
+ radius2 = Math.max( radius2, p.x, p.y, p.z );
+
+ }
+ this.tempCM2.add( object.position );
+
+ }
+
+ var object1 = null;
+ var object2 = null;
+
+ var numObjects = 0;
+
+ if ( numPoints1 > 4 ) {
+
+ object1 = new THREE.Mesh( new THREE.ConvexBufferGeometry( points1 ), object.material );
+ object1.position.copy( this.tempCM1 );
+ object1.quaternion.copy( object.quaternion );
+
+ this.prepareBreakableObject( object1, newMass, object.userData.velocity, object.userData.angularVelocity, 2 * radius1 > this.minSizeForBreak );
+
+ numObjects ++;
+
+ }
+
+ if ( numPoints2 > 4 ) {
+
+ object2 = new THREE.Mesh( new THREE.ConvexBufferGeometry( points2 ), object.material );
+ object2.position.copy( this.tempCM2 );
+ object2.quaternion.copy( object.quaternion );
+
+ this.prepareBreakableObject( object2, newMass, object.userData.velocity, object.userData.angularVelocity, 2 * radius2 > this.minSizeForBreak );
+
+ numObjects ++;
+
+ }
+
+ output.object1 = object1;
+ output.object2 = object2;
+
+ return numObjects;
+
+ }
+
+};
+
+THREE.ConvexObjectBreaker.transformFreeVector = function ( v, m ) {
+
+ // input:
+ // vector interpreted as a free vector
+ // THREE.Matrix4 orthogonal matrix (matrix without scale)
+
+ var x = v.x, y = v.y, z = v.z;
+ var e = m.elements;
+
+ v.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z;
+ v.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z;
+ v.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z;
+
+ return v;
+
+};
+
+THREE.ConvexObjectBreaker.transformFreeVectorInverse = function ( v, m ) {
+
+ // input:
+ // vector interpreted as a free vector
+ // THREE.Matrix4 orthogonal matrix (matrix without scale)
+
+ var x = v.x, y = v.y, z = v.z;
+ var e = m.elements;
+
+ v.x = e[ 0 ] * x + e[ 1 ] * y + e[ 2 ] * z;
+ v.y = e[ 4 ] * x + e[ 5 ] * y + e[ 6 ] * z;
+ v.z = e[ 8 ] * x + e[ 9 ] * y + e[ 10 ] * z;
+
+ return v;
+
+};
+
+THREE.ConvexObjectBreaker.transformTiedVectorInverse = function ( v, m ) {
+
+ // input:
+ // vector interpreted as a tied (ordinary) vector
+ // THREE.Matrix4 orthogonal matrix (matrix without scale)
+
+ var x = v.x, y = v.y, z = v.z;
+ var e = m.elements;
+
+ v.x = e[ 0 ] * x + e[ 1 ] * y + e[ 2 ] * z - e[ 12 ];
+ v.y = e[ 4 ] * x + e[ 5 ] * y + e[ 6 ] * z - e[ 13 ];
+ v.z = e[ 8 ] * x + e[ 9 ] * y + e[ 10 ] * z - e[ 14 ];
+
+ return v;
+
+};
+
+THREE.ConvexObjectBreaker.transformPlaneToLocalSpace = function () {
+
+ var v1 = new THREE.Vector3();
+
+ return function transformPlaneToLocalSpace( plane, m, resultPlane ) {
+
+ resultPlane.normal.copy( plane.normal );
+ resultPlane.constant = plane.constant;
+
+ var referencePoint = THREE.ConvexObjectBreaker.transformTiedVectorInverse( plane.coplanarPoint( v1 ), m );
+
+ THREE.ConvexObjectBreaker.transformFreeVectorInverse( resultPlane.normal, m );
+
+ // recalculate constant (like in setFromNormalAndCoplanarPoint)
+ resultPlane.constant = - referencePoint.dot( resultPlane.normal );
+
+
+ };
+
+}();
diff --git a/three/jsutil/CurveExtras.js b/three/jsutil/CurveExtras.js
new file mode 100644
index 000000000..5ffd804e0
--- /dev/null
+++ b/three/jsutil/CurveExtras.js
@@ -0,0 +1,425 @@
+/*
+ * A bunch of parametric curves
+ * @author zz85
+ *
+ * Formulas collected from various sources
+ * http://mathworld.wolfram.com/HeartCurve.html
+ * http://mathdl.maa.org/images/upload_library/23/stemkoski/knots/page6.html
+ * http://en.wikipedia.org/wiki/Viviani%27s_curve
+ * http://mathdl.maa.org/images/upload_library/23/stemkoski/knots/page4.html
+ * http://www.mi.sanu.ac.rs/vismath/taylorapril2011/Taylor.pdf
+ * http://prideout.net/blog/?p=44
+ */
+
+( function ( Curves ) {
+
+ // GrannyKnot
+
+ function GrannyKnot() {
+
+ THREE.Curve.call( this );
+
+ }
+
+ GrannyKnot.prototype = Object.create( THREE.Curve.prototype );
+ GrannyKnot.prototype.constructor = GrannyKnot;
+
+ GrannyKnot.prototype.getPoint = function ( t, optionalTarget ) {
+
+ var point = optionalTarget || new THREE.Vector3();
+
+ t = 2 * Math.PI * t;
+
+ var x = - 0.22 * Math.cos( t ) - 1.28 * Math.sin( t ) - 0.44 * Math.cos( 3 * t ) - 0.78 * Math.sin( 3 * t );
+ var y = - 0.1 * Math.cos( 2 * t ) - 0.27 * Math.sin( 2 * t ) + 0.38 * Math.cos( 4 * t ) + 0.46 * Math.sin( 4 * t );
+ var z = 0.7 * Math.cos( 3 * t ) - 0.4 * Math.sin( 3 * t );
+
+ return point.set( x, y, z ).multiplyScalar( 20 );
+
+ };
+
+ // HeartCurve
+
+ function HeartCurve( scale ) {
+
+ THREE.Curve.call( this );
+
+ this.scale = ( scale === undefined ) ? 5 : scale;
+
+ }
+
+ HeartCurve.prototype = Object.create( THREE.Curve.prototype );
+ HeartCurve.prototype.constructor = HeartCurve;
+
+ HeartCurve.prototype.getPoint = function ( t, optionalTarget ) {
+
+ var point = optionalTarget || new THREE.Vector3();
+
+ t *= 2 * Math.PI;
+
+ var x = 16 * Math.pow( Math.sin( t ), 3 );
+ var y = 13 * Math.cos( t ) - 5 * Math.cos( 2 * t ) - 2 * Math.cos( 3 * t ) - Math.cos( 4 * t );
+ var z = 0;
+
+ return point.set( x, y, z ).multiplyScalar( this.scale );
+
+ };
+
+ // Viviani's Curve
+
+ function VivianiCurve( scale ) {
+
+ THREE.Curve.call( this );
+
+ this.scale = ( scale === undefined ) ? 70 : scale;
+
+ }
+
+ VivianiCurve.prototype = Object.create( THREE.Curve.prototype );
+ VivianiCurve.prototype.constructor = VivianiCurve;
+
+ VivianiCurve.prototype.getPoint = function ( t, optionalTarget ) {
+
+ var point = optionalTarget || new THREE.Vector3();
+
+ t = t * 4 * Math.PI; // normalized to 0..1
+ var a = this.scale / 2;
+
+ var x = a * ( 1 + Math.cos( t ) );
+ var y = a * Math.sin( t );
+ var z = 2 * a * Math.sin( t / 2 );
+
+ return point.set( x, y, z );
+
+ };
+
+ // KnotCurve
+
+ function KnotCurve() {
+
+ THREE.Curve.call( this );
+
+ }
+
+ KnotCurve.prototype = Object.create( THREE.Curve.prototype );
+ KnotCurve.prototype.constructor = KnotCurve;
+
+ KnotCurve.prototype.getPoint = function ( t, optionalTarget ) {
+
+ var point = optionalTarget || new THREE.Vector3();
+
+ t *= 2 * Math.PI;
+
+ var R = 10;
+ var s = 50;
+
+ var x = s * Math.sin( t );
+ var y = Math.cos( t ) * ( R + s * Math.cos( t ) );
+ var z = Math.sin( t ) * ( R + s * Math.cos( t ) );
+
+ return point.set( x, y, z );
+
+ };
+
+ // HelixCurve
+
+ function HelixCurve() {
+
+ THREE.Curve.call( this );
+
+ }
+
+ HelixCurve.prototype = Object.create( THREE.Curve.prototype );
+ HelixCurve.prototype.constructor = HelixCurve;
+
+ HelixCurve.prototype.getPoint = function ( t, optionalTarget ) {
+
+ var point = optionalTarget || new THREE.Vector3();
+
+ var a = 30; // radius
+ var b = 150; // height
+
+ var t2 = 2 * Math.PI * t * b / 30;
+
+ var x = Math.cos( t2 ) * a;
+ var y = Math.sin( t2 ) * a;
+ var z = b * t;
+
+ return point.set( x, y, z );
+
+ };
+
+ // TrefoilKnot
+
+ function TrefoilKnot( scale ) {
+
+ THREE.Curve.call( this );
+
+ this.scale = ( scale === undefined ) ? 10 : scale;
+
+ }
+
+ TrefoilKnot.prototype = Object.create( THREE.Curve.prototype );
+ TrefoilKnot.prototype.constructor = TrefoilKnot;
+
+ TrefoilKnot.prototype.getPoint = function ( t, optionalTarget ) {
+
+ var point = optionalTarget || new THREE.Vector3();
+
+ t *= Math.PI * 2;
+
+ var x = ( 2 + Math.cos( 3 * t ) ) * Math.cos( 2 * t );
+ var y = ( 2 + Math.cos( 3 * t ) ) * Math.sin( 2 * t );
+ var z = Math.sin( 3 * t );
+
+ return point.set( x, y, z ).multiplyScalar( this.scale );
+
+ };
+
+ // TorusKnot
+
+ function TorusKnot( scale ) {
+
+ THREE.Curve.call( this );
+
+ this.scale = ( scale === undefined ) ? 10 : scale;
+
+ }
+
+ TorusKnot.prototype = Object.create( THREE.Curve.prototype );
+ TorusKnot.prototype.constructor = TorusKnot;
+
+ TorusKnot.prototype.getPoint = function ( t, optionalTarget ) {
+
+ var point = optionalTarget || new THREE.Vector3();
+
+ var p = 3;
+ var q = 4;
+
+ t *= Math.PI * 2;
+
+ var x = ( 2 + Math.cos( q * t ) ) * Math.cos( p * t );
+ var y = ( 2 + Math.cos( q * t ) ) * Math.sin( p * t );
+ var z = Math.sin( q * t );
+
+ return point.set( x, y, z ).multiplyScalar( this.scale );
+
+ };
+
+ // CinquefoilKnot
+
+ function CinquefoilKnot( scale ) {
+
+ THREE.Curve.call( this );
+
+ this.scale = ( scale === undefined ) ? 10 : scale;
+
+ }
+
+ CinquefoilKnot.prototype = Object.create( THREE.Curve.prototype );
+ CinquefoilKnot.prototype.constructor = CinquefoilKnot;
+
+ CinquefoilKnot.prototype.getPoint = function ( t, optionalTarget ) {
+
+ var point = optionalTarget || new THREE.Vector3();
+
+ var p = 2;
+ var q = 5;
+
+ t *= Math.PI * 2;
+
+ var x = ( 2 + Math.cos( q * t ) ) * Math.cos( p * t );
+ var y = ( 2 + Math.cos( q * t ) ) * Math.sin( p * t );
+ var z = Math.sin( q * t );
+
+ return point.set( x, y, z ).multiplyScalar( this.scale );
+
+ };
+
+ // TrefoilPolynomialKnot
+
+ function TrefoilPolynomialKnot( scale ) {
+
+ THREE.Curve.call( this );
+
+ this.scale = ( scale === undefined ) ? 10 : scale;
+
+ }
+
+ TrefoilPolynomialKnot.prototype = Object.create( THREE.Curve.prototype );
+ TrefoilPolynomialKnot.prototype.constructor = TrefoilPolynomialKnot;
+
+ TrefoilPolynomialKnot.prototype.getPoint = function ( t, optionalTarget ) {
+
+ var point = optionalTarget || new THREE.Vector3();
+
+ t = t * 4 - 2;
+
+ var x = Math.pow( t, 3 ) - 3 * t;
+ var y = Math.pow( t, 4 ) - 4 * t * t;
+ var z = 1 / 5 * Math.pow( t, 5 ) - 2 * t;
+
+ return point.set( x, y, z ).multiplyScalar( this.scale );
+
+ };
+
+ var scaleTo = function ( x, y, t ) {
+
+ var r = y - x;
+ return t * r + x;
+
+ };
+
+ // FigureEightPolynomialKnot
+
+ function FigureEightPolynomialKnot( scale ) {
+
+ THREE.Curve.call( this );
+
+ this.scale = ( scale === undefined ) ? 1 : scale;
+
+ }
+
+ FigureEightPolynomialKnot.prototype = Object.create( THREE.Curve.prototype );
+ FigureEightPolynomialKnot.prototype.constructor = FigureEightPolynomialKnot;
+
+ FigureEightPolynomialKnot.prototype.getPoint = function ( t, optionalTarget ) {
+
+ var point = optionalTarget || new THREE.Vector3();
+
+ t = scaleTo( - 4, 4, t );
+
+ var x = 2 / 5 * t * ( t * t - 7 ) * ( t * t - 10 );
+ var y = Math.pow( t, 4 ) - 13 * t * t;
+ var z = 1 / 10 * t * ( t * t - 4 ) * ( t * t - 9 ) * ( t * t - 12 );
+
+ return point.set( x, y, z ).multiplyScalar( this.scale );
+
+ };
+
+ // DecoratedTorusKnot4a
+
+ function DecoratedTorusKnot4a( scale ) {
+
+ THREE.Curve.call( this );
+
+ this.scale = ( scale === undefined ) ? 40 : scale;
+
+ }
+
+ DecoratedTorusKnot4a.prototype = Object.create( THREE.Curve.prototype );
+ DecoratedTorusKnot4a.prototype.constructor = DecoratedTorusKnot4a;
+
+ DecoratedTorusKnot4a.prototype.getPoint = function ( t, optionalTarget ) {
+
+ var point = optionalTarget || new THREE.Vector3();
+
+ t *= Math.PI * 2;
+
+ var x = Math.cos( 2 * t ) * ( 1 + 0.6 * ( Math.cos( 5 * t ) + 0.75 * Math.cos( 10 * t ) ) );
+ var y = Math.sin( 2 * t ) * ( 1 + 0.6 * ( Math.cos( 5 * t ) + 0.75 * Math.cos( 10 * t ) ) );
+ var z = 0.35 * Math.sin( 5 * t );
+
+ return point.set( x, y, z ).multiplyScalar( this.scale );
+
+ };
+
+ // DecoratedTorusKnot4b
+
+ function DecoratedTorusKnot4b( scale ) {
+
+ THREE.Curve.call( this );
+
+ this.scale = ( scale === undefined ) ? 40 : scale;
+
+ }
+
+ DecoratedTorusKnot4b.prototype = Object.create( THREE.Curve.prototype );
+ DecoratedTorusKnot4b.prototype.constructor = DecoratedTorusKnot4b;
+
+ DecoratedTorusKnot4b.prototype.getPoint = function ( t, optionalTarget ) {
+
+ var point = optionalTarget || new THREE.Vector3();
+
+ var fi = t * Math.PI * 2;
+
+ var x = Math.cos( 2 * fi ) * ( 1 + 0.45 * Math.cos( 3 * fi ) + 0.4 * Math.cos( 9 * fi ) );
+ var y = Math.sin( 2 * fi ) * ( 1 + 0.45 * Math.cos( 3 * fi ) + 0.4 * Math.cos( 9 * fi ) );
+ var z = 0.2 * Math.sin( 9 * fi );
+
+ return point.set( x, y, z ).multiplyScalar( this.scale );
+
+ };
+
+ // DecoratedTorusKnot5a
+
+ function DecoratedTorusKnot5a( scale ) {
+
+ THREE.Curve.call( this );
+
+ this.scale = ( scale === undefined ) ? 40 : scale;
+
+ }
+
+ DecoratedTorusKnot5a.prototype = Object.create( THREE.Curve.prototype );
+ DecoratedTorusKnot5a.prototype.constructor = DecoratedTorusKnot5a;
+
+ DecoratedTorusKnot5a.prototype.getPoint = function ( t, optionalTarget ) {
+
+ var point = optionalTarget || new THREE.Vector3();
+
+ var fi = t * Math.PI * 2;
+
+ var x = Math.cos( 3 * fi ) * ( 1 + 0.3 * Math.cos( 5 * fi ) + 0.5 * Math.cos( 10 * fi ) );
+ var y = Math.sin( 3 * fi ) * ( 1 + 0.3 * Math.cos( 5 * fi ) + 0.5 * Math.cos( 10 * fi ) );
+ var z = 0.2 * Math.sin( 20 * fi );
+
+ return point.set( x, y, z ).multiplyScalar( this.scale );
+
+ };
+
+ // DecoratedTorusKnot5c
+
+ function DecoratedTorusKnot5c( scale ) {
+
+ THREE.Curve.call( this );
+
+ this.scale = ( scale === undefined ) ? 40 : scale;
+
+ }
+
+ DecoratedTorusKnot5c.prototype = Object.create( THREE.Curve.prototype );
+ DecoratedTorusKnot5c.prototype.constructor = DecoratedTorusKnot5c;
+
+ DecoratedTorusKnot5c.prototype.getPoint = function ( t, optionalTarget ) {
+
+ var point = optionalTarget || new THREE.Vector3();
+
+ var fi = t * Math.PI * 2;
+
+ var x = Math.cos( 4 * fi ) * ( 1 + 0.5 * ( Math.cos( 5 * fi ) + 0.4 * Math.cos( 20 * fi ) ) );
+ var y = Math.sin( 4 * fi ) * ( 1 + 0.5 * ( Math.cos( 5 * fi ) + 0.4 * Math.cos( 20 * fi ) ) );
+ var z = 0.35 * Math.sin( 15 * fi );
+
+ return point.set( x, y, z ).multiplyScalar( this.scale );
+
+ };
+
+ // export
+
+ Curves.GrannyKnot = GrannyKnot;
+ Curves.HeartCurve = HeartCurve;
+ Curves.VivianiCurve = VivianiCurve;
+ Curves.KnotCurve = KnotCurve;
+ Curves.HelixCurve = HelixCurve;
+ Curves.TrefoilKnot = TrefoilKnot;
+ Curves.TorusKnot = TorusKnot;
+ Curves.CinquefoilKnot = CinquefoilKnot;
+ Curves.TrefoilPolynomialKnot = TrefoilPolynomialKnot;
+ Curves.FigureEightPolynomialKnot = FigureEightPolynomialKnot;
+ Curves.DecoratedTorusKnot4a = DecoratedTorusKnot4a;
+ Curves.DecoratedTorusKnot4b = DecoratedTorusKnot4b;
+ Curves.DecoratedTorusKnot5a = DecoratedTorusKnot5a;
+ Curves.DecoratedTorusKnot5c = DecoratedTorusKnot5c;
+
+} )( THREE.Curves = THREE.Curves || {} );
diff --git a/three/jsutil/GPUComputationRenderer.js b/three/jsutil/GPUComputationRenderer.js
new file mode 100644
index 000000000..c9b22e8ef
--- /dev/null
+++ b/three/jsutil/GPUComputationRenderer.js
@@ -0,0 +1,368 @@
+/**
+ * @author yomboprime https://github.com/yomboprime
+ *
+ * GPUComputationRenderer, based on SimulationRenderer by zz85
+ *
+ * The GPUComputationRenderer uses the concept of variables. These variables are RGBA float textures that hold 4 floats
+ * for each compute element (texel)
+ *
+ * Each variable has a fragment shader that defines the computation made to obtain the variable in question.
+ * You can use as many variables you need, and make dependencies so you can use textures of other variables in the shader
+ * (the sampler uniforms are added automatically) Most of the variables will need themselves as dependency.
+ *
+ * The renderer has actually two render targets per variable, to make ping-pong. Textures from the current frame are used
+ * as inputs to render the textures of the next frame.
+ *
+ * The render targets of the variables can be used as input textures for your visualization shaders.
+ *
+ * Variable names should be valid identifiers and should not collide with THREE GLSL used identifiers.
+ * a common approach could be to use 'texture' prefixing the variable name; i.e texturePosition, textureVelocity...
+ *
+ * The size of the computation (sizeX * sizeY) is defined as 'resolution' automatically in the shader. For example:
+ * #DEFINE resolution vec2( 1024.0, 1024.0 )
+ *
+ * -------------
+ *
+ * Basic use:
+ *
+ * // Initialization...
+ *
+ * // Create computation renderer
+ * var gpuCompute = new GPUComputationRenderer( 1024, 1024, renderer );
+ *
+ * // Create initial state float textures
+ * var pos0 = gpuCompute.createTexture();
+ * var vel0 = gpuCompute.createTexture();
+ * // and fill in here the texture data...
+ *
+ * // Add texture variables
+ * var velVar = gpuCompute.addVariable( "textureVelocity", fragmentShaderVel, pos0 );
+ * var posVar = gpuCompute.addVariable( "texturePosition", fragmentShaderPos, vel0 );
+ *
+ * // Add variable dependencies
+ * gpuCompute.setVariableDependencies( velVar, [ velVar, posVar ] );
+ * gpuCompute.setVariableDependencies( posVar, [ velVar, posVar ] );
+ *
+ * // Add custom uniforms
+ * velVar.material.uniforms.time = { value: 0.0 };
+ *
+ * // Check for completeness
+ * var error = gpuCompute.init();
+ * if ( error !== null ) {
+ * console.error( error );
+ * }
+ *
+ *
+ * // In each frame...
+ *
+ * // Compute!
+ * gpuCompute.compute();
+ *
+ * // Update texture uniforms in your visualization materials with the gpu renderer output
+ * myMaterial.uniforms.myTexture.value = gpuCompute.getCurrentRenderTarget( posVar ).texture;
+ *
+ * // Do your rendering
+ * renderer.render( myScene, myCamera );
+ *
+ * -------------
+ *
+ * Also, you can use utility functions to create ShaderMaterial and perform computations (rendering between textures)
+ * Note that the shaders can have multiple input textures.
+ *
+ * var myFilter1 = gpuCompute.createShaderMaterial( myFilterFragmentShader1, { theTexture: { value: null } } );
+ * var myFilter2 = gpuCompute.createShaderMaterial( myFilterFragmentShader2, { theTexture: { value: null } } );
+ *
+ * var inputTexture = gpuCompute.createTexture();
+ *
+ * // Fill in here inputTexture...
+ *
+ * myFilter1.uniforms.theTexture.value = inputTexture;
+ *
+ * var myRenderTarget = gpuCompute.createRenderTarget();
+ * myFilter2.uniforms.theTexture.value = myRenderTarget.texture;
+ *
+ * var outputRenderTarget = gpuCompute.createRenderTarget();
+ *
+ * // Now use the output texture where you want:
+ * myMaterial.uniforms.map.value = outputRenderTarget.texture;
+ *
+ * // And compute each frame, before rendering to screen:
+ * gpuCompute.doRenderTarget( myFilter1, myRenderTarget );
+ * gpuCompute.doRenderTarget( myFilter2, outputRenderTarget );
+ *
+ *
+ *
+ * @param {int} sizeX Computation problem size is always 2d: sizeX * sizeY elements.
+ * @param {int} sizeY Computation problem size is always 2d: sizeX * sizeY elements.
+ * @param {WebGLRenderer} renderer The renderer
+ */
+
+function GPUComputationRenderer( sizeX, sizeY, renderer ) {
+
+ this.variables = [];
+
+ this.currentTextureIndex = 0;
+
+ var scene = new THREE.Scene();
+
+ var camera = new THREE.Camera();
+ camera.position.z = 1;
+
+ var passThruUniforms = {
+ texture: { value: null }
+ };
+
+ var passThruShader = createShaderMaterial( getPassThroughFragmentShader(), passThruUniforms );
+
+ var mesh = new THREE.Mesh( new THREE.PlaneBufferGeometry( 2, 2 ), passThruShader );
+ scene.add( mesh );
+
+
+ this.addVariable = function( variableName, computeFragmentShader, initialValueTexture ) {
+
+ var material = this.createShaderMaterial( computeFragmentShader );
+
+ var variable = {
+ name: variableName,
+ initialValueTexture: initialValueTexture,
+ material: material,
+ dependencies: null,
+ renderTargets: [],
+ wrapS: null,
+ wrapT: null,
+ minFilter: THREE.NearestFilter,
+ magFilter: THREE.NearestFilter
+ };
+
+ this.variables.push( variable );
+
+ return variable;
+
+ };
+
+ this.setVariableDependencies = function( variable, dependencies ) {
+
+ variable.dependencies = dependencies;
+
+ };
+
+ this.init = function() {
+
+ if ( ! renderer.extensions.get( "OES_texture_float" ) ) {
+
+ return "No OES_texture_float support for float textures.";
+
+ }
+
+ if ( renderer.capabilities.maxVertexTextures === 0 ) {
+
+ return "No support for vertex shader textures.";
+
+ }
+
+ for ( var i = 0; i < this.variables.length; i++ ) {
+
+ var variable = this.variables[ i ];
+
+ // Creates rendertargets and initialize them with input texture
+ variable.renderTargets[ 0 ] = this.createRenderTarget( sizeX, sizeY, variable.wrapS, variable.wrapT, variable.minFilter, variable.magFilter );
+ variable.renderTargets[ 1 ] = this.createRenderTarget( sizeX, sizeY, variable.wrapS, variable.wrapT, variable.minFilter, variable.magFilter );
+ this.renderTexture( variable.initialValueTexture, variable.renderTargets[ 0 ] );
+ this.renderTexture( variable.initialValueTexture, variable.renderTargets[ 1 ] );
+
+ // Adds dependencies uniforms to the ShaderMaterial
+ var material = variable.material;
+ var uniforms = material.uniforms;
+ if ( variable.dependencies !== null ) {
+
+ for ( var d = 0; d < variable.dependencies.length; d++ ) {
+
+ var depVar = variable.dependencies[ d ];
+
+ if ( depVar.name !== variable.name ) {
+
+ // Checks if variable exists
+ var found = false;
+ for ( var j = 0; j < this.variables.length; j++ ) {
+
+ if ( depVar.name === this.variables[ j ].name ) {
+ found = true;
+ break;
+ }
+
+ }
+ if ( ! found ) {
+ return "Variable dependency not found. Variable=" + variable.name + ", dependency=" + depVar.name;
+ }
+
+ }
+
+ uniforms[ depVar.name ] = { value: null };
+
+ material.fragmentShader = "\nuniform sampler2D " + depVar.name + ";\n" + material.fragmentShader;
+
+ }
+ }
+ }
+
+ this.currentTextureIndex = 0;
+
+ return null;
+
+ };
+
+ this.compute = function() {
+
+ var currentTextureIndex = this.currentTextureIndex;
+ var nextTextureIndex = this.currentTextureIndex === 0 ? 1 : 0;
+
+ for ( var i = 0, il = this.variables.length; i < il; i++ ) {
+
+ var variable = this.variables[ i ];
+
+ // Sets texture dependencies uniforms
+ if ( variable.dependencies !== null ) {
+
+ var uniforms = variable.material.uniforms;
+ for ( var d = 0, dl = variable.dependencies.length; d < dl; d++ ) {
+
+ var depVar = variable.dependencies[ d ];
+
+ uniforms[ depVar.name ].value = depVar.renderTargets[ currentTextureIndex ].texture;
+
+ }
+
+ }
+
+ // Performs the computation for this variable
+ this.doRenderTarget( variable.material, variable.renderTargets[ nextTextureIndex ] );
+
+ }
+
+ this.currentTextureIndex = nextTextureIndex;
+ };
+
+ this.getCurrentRenderTarget = function( variable ) {
+
+ return variable.renderTargets[ this.currentTextureIndex ];
+
+ };
+
+ this.getAlternateRenderTarget = function( variable ) {
+
+ return variable.renderTargets[ this.currentTextureIndex === 0 ? 1 : 0 ];
+
+ };
+
+ function addResolutionDefine( materialShader ) {
+
+ materialShader.defines.resolution = 'vec2( ' + sizeX.toFixed( 1 ) + ', ' + sizeY.toFixed( 1 ) + " )";
+
+ }
+ this.addResolutionDefine = addResolutionDefine;
+
+
+ // The following functions can be used to compute things manually
+
+ function createShaderMaterial( computeFragmentShader, uniforms ) {
+
+ uniforms = uniforms || {};
+
+ var material = new THREE.ShaderMaterial( {
+ uniforms: uniforms,
+ vertexShader: getPassThroughVertexShader(),
+ fragmentShader: computeFragmentShader
+ } );
+
+ addResolutionDefine( material );
+
+ return material;
+ }
+ this.createShaderMaterial = createShaderMaterial;
+
+ this.createRenderTarget = function( sizeXTexture, sizeYTexture, wrapS, wrapT, minFilter, magFilter ) {
+
+ sizeXTexture = sizeXTexture || sizeX;
+ sizeYTexture = sizeYTexture || sizeY;
+
+ wrapS = wrapS || THREE.ClampToEdgeWrapping;
+ wrapT = wrapT || THREE.ClampToEdgeWrapping;
+
+ minFilter = minFilter || THREE.NearestFilter;
+ magFilter = magFilter || THREE.NearestFilter;
+
+ var renderTarget = new THREE.WebGLRenderTarget( sizeXTexture, sizeYTexture, {
+ wrapS: wrapS,
+ wrapT: wrapT,
+ minFilter: minFilter,
+ magFilter: magFilter,
+ format: THREE.RGBAFormat,
+ type: ( /(iPad|iPhone|iPod)/g.test( navigator.userAgent ) ) ? THREE.HalfFloatType : THREE.FloatType,
+ stencilBuffer: false,
+ depthBuffer: false
+ } );
+
+ return renderTarget;
+
+ };
+
+ this.createTexture = function() {
+
+ var a = new Float32Array( sizeX * sizeY * 4 );
+ var texture = new THREE.DataTexture( a, sizeX, sizeY, THREE.RGBAFormat, THREE.FloatType );
+ texture.needsUpdate = true;
+
+ return texture;
+
+ };
+
+
+ this.renderTexture = function( input, output ) {
+
+ // Takes a texture, and render out in rendertarget
+ // input = Texture
+ // output = RenderTarget
+
+ passThruUniforms.texture.value = input;
+
+ this.doRenderTarget( passThruShader, output);
+
+ passThruUniforms.texture.value = null;
+
+ };
+
+ this.doRenderTarget = function( material, output ) {
+
+ mesh.material = material;
+ renderer.render( scene, camera, output );
+ mesh.material = passThruShader;
+
+ };
+
+ // Shaders
+
+ function getPassThroughVertexShader() {
+
+ return "void main() {\n" +
+ "\n" +
+ " gl_Position = vec4( position, 1.0 );\n" +
+ "\n" +
+ "}\n";
+
+ }
+
+ function getPassThroughFragmentShader() {
+
+ return "uniform sampler2D texture;\n" +
+ "\n" +
+ "void main() {\n" +
+ "\n" +
+ " vec2 uv = gl_FragCoord.xy / resolution.xy;\n" +
+ "\n" +
+ " gl_FragColor = texture2D( texture, uv );\n" +
+ "\n" +
+ "}\n";
+
+ }
+
+}
diff --git a/three/jsutil/GPUParticleSystem.js b/three/jsutil/GPUParticleSystem.js
new file mode 100644
index 000000000..7c59aa536
--- /dev/null
+++ b/three/jsutil/GPUParticleSystem.js
@@ -0,0 +1,501 @@
+/*
+ * GPU Particle System
+ * @author flimshaw - Charlie Hoey - http://charliehoey.com
+ *
+ * A simple to use, general purpose GPU system. Particles are spawn-and-forget with
+ * several options available, and do not require monitoring or cleanup after spawning.
+ * Because the paths of all particles are completely deterministic once spawned, the scale
+ * and direction of time is also variable.
+ *
+ * Currently uses a static wrapping perlin noise texture for turbulence, and a small png texture for
+ * particles, but adding support for a particle texture atlas or changing to a different type of turbulence
+ * would be a fairly light day's work.
+ *
+ * Shader and javascript packing code derrived from several Stack Overflow examples.
+ *
+ */
+
+THREE.GPUParticleSystem = function ( options ) {
+
+ THREE.Object3D.apply( this, arguments );
+
+ options = options || {};
+
+ // parse options and use defaults
+
+ this.PARTICLE_COUNT = options.maxParticles || 1000000;
+ this.PARTICLE_CONTAINERS = options.containerCount || 1;
+
+ this.PARTICLE_NOISE_TEXTURE = options.particleNoiseTex || null;
+ this.PARTICLE_SPRITE_TEXTURE = options.particleSpriteTex || null;
+
+ this.PARTICLES_PER_CONTAINER = Math.ceil( this.PARTICLE_COUNT / this.PARTICLE_CONTAINERS );
+ this.PARTICLE_CURSOR = 0;
+ this.time = 0;
+ this.particleContainers = [];
+ this.rand = [];
+
+ // custom vertex and fragement shader
+
+ var GPUParticleShader = {
+
+ vertexShader: [
+
+ 'uniform float uTime;',
+ 'uniform float uScale;',
+ 'uniform sampler2D tNoise;',
+
+ 'attribute vec3 positionStart;',
+ 'attribute float startTime;',
+ 'attribute vec3 velocity;',
+ 'attribute float turbulence;',
+ 'attribute vec3 color;',
+ 'attribute float size;',
+ 'attribute float lifeTime;',
+
+ 'varying vec4 vColor;',
+ 'varying float lifeLeft;',
+
+ 'void main() {',
+
+ // unpack things from our attributes'
+
+ ' vColor = vec4( color, 1.0 );',
+
+ // convert our velocity back into a value we can use'
+
+ ' vec3 newPosition;',
+ ' vec3 v;',
+
+ ' float timeElapsed = uTime - startTime;',
+
+ ' lifeLeft = 1.0 - ( timeElapsed / lifeTime );',
+
+ ' gl_PointSize = ( uScale * size ) * lifeLeft;',
+
+ ' v.x = ( velocity.x - 0.5 ) * 3.0;',
+ ' v.y = ( velocity.y - 0.5 ) * 3.0;',
+ ' v.z = ( velocity.z - 0.5 ) * 3.0;',
+
+ ' newPosition = positionStart + ( v * 10.0 ) * timeElapsed;',
+
+ ' vec3 noise = texture2D( tNoise, vec2( newPosition.x * 0.015 + ( uTime * 0.05 ), newPosition.y * 0.02 + ( uTime * 0.015 ) ) ).rgb;',
+ ' vec3 noiseVel = ( noise.rgb - 0.5 ) * 30.0;',
+
+ ' newPosition = mix( newPosition, newPosition + vec3( noiseVel * ( turbulence * 5.0 ) ), ( timeElapsed / lifeTime ) );',
+
+ ' if( v.y > 0. && v.y < .05 ) {',
+
+ ' lifeLeft = 0.0;',
+
+ ' }',
+
+ ' if( v.x < - 1.45 ) {',
+
+ ' lifeLeft = 0.0;',
+
+ ' }',
+
+ ' if( timeElapsed > 0.0 ) {',
+
+ ' gl_Position = projectionMatrix * modelViewMatrix * vec4( newPosition, 1.0 );',
+
+ ' } else {',
+
+ ' gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+ ' lifeLeft = 0.0;',
+ ' gl_PointSize = 0.;',
+
+ ' }',
+
+ '}'
+
+ ].join( '\n' ),
+
+ fragmentShader: [
+
+ 'float scaleLinear( float value, vec2 valueDomain ) {',
+
+ ' return ( value - valueDomain.x ) / ( valueDomain.y - valueDomain.x );',
+
+ '}',
+
+ 'float scaleLinear( float value, vec2 valueDomain, vec2 valueRange ) {',
+
+ ' return mix( valueRange.x, valueRange.y, scaleLinear( value, valueDomain ) );',
+
+ '}',
+
+ 'varying vec4 vColor;',
+ 'varying float lifeLeft;',
+
+ 'uniform sampler2D tSprite;',
+
+ 'void main() {',
+
+ ' float alpha = 0.;',
+
+ ' if( lifeLeft > 0.995 ) {',
+
+ ' alpha = scaleLinear( lifeLeft, vec2( 1.0, 0.995 ), vec2( 0.0, 1.0 ) );',
+
+ ' } else {',
+
+ ' alpha = lifeLeft * 0.75;',
+
+ ' }',
+
+ ' vec4 tex = texture2D( tSprite, gl_PointCoord );',
+ ' gl_FragColor = vec4( vColor.rgb * tex.a, alpha * tex.a );',
+
+ '}'
+
+ ].join( '\n' )
+
+ };
+
+ // preload a million random numbers
+
+ var i;
+
+ for ( i = 1e5; i > 0; i -- ) {
+
+ this.rand.push( Math.random() - 0.5 );
+
+ }
+
+ this.random = function () {
+
+ return ++ i >= this.rand.length ? this.rand[ i = 1 ] : this.rand[ i ];
+
+ };
+
+ var textureLoader = new THREE.TextureLoader();
+
+ this.particleNoiseTex = this.PARTICLE_NOISE_TEXTURE || textureLoader.load( 'textures/perlin-512.png' );
+ this.particleNoiseTex.wrapS = this.particleNoiseTex.wrapT = THREE.RepeatWrapping;
+
+ this.particleSpriteTex = this.PARTICLE_SPRITE_TEXTURE || textureLoader.load( 'textures/particle2.png' );
+ this.particleSpriteTex.wrapS = this.particleSpriteTex.wrapT = THREE.RepeatWrapping;
+
+ this.particleShaderMat = new THREE.ShaderMaterial( {
+ transparent: true,
+ depthWrite: false,
+ uniforms: {
+ 'uTime': {
+ value: 0.0
+ },
+ 'uScale': {
+ value: 1.0
+ },
+ 'tNoise': {
+ value: this.particleNoiseTex
+ },
+ 'tSprite': {
+ value: this.particleSpriteTex
+ }
+ },
+ blending: THREE.AdditiveBlending,
+ vertexShader: GPUParticleShader.vertexShader,
+ fragmentShader: GPUParticleShader.fragmentShader
+ } );
+
+ // define defaults for all values
+
+ this.particleShaderMat.defaultAttributeValues.particlePositionsStartTime = [ 0, 0, 0, 0 ];
+ this.particleShaderMat.defaultAttributeValues.particleVelColSizeLife = [ 0, 0, 0, 0 ];
+
+ this.init = function () {
+
+ for ( var i = 0; i < this.PARTICLE_CONTAINERS; i ++ ) {
+
+ var c = new THREE.GPUParticleContainer( this.PARTICLES_PER_CONTAINER, this );
+ this.particleContainers.push( c );
+ this.add( c );
+
+ }
+
+ };
+
+ this.spawnParticle = function ( options ) {
+
+ this.PARTICLE_CURSOR ++;
+
+ if ( this.PARTICLE_CURSOR >= this.PARTICLE_COUNT ) {
+
+ this.PARTICLE_CURSOR = 1;
+
+ }
+
+ var currentContainer = this.particleContainers[ Math.floor( this.PARTICLE_CURSOR / this.PARTICLES_PER_CONTAINER ) ];
+
+ currentContainer.spawnParticle( options );
+
+ };
+
+ this.update = function ( time ) {
+
+ for ( var i = 0; i < this.PARTICLE_CONTAINERS; i ++ ) {
+
+ this.particleContainers[ i ].update( time );
+
+ }
+
+ };
+
+ this.dispose = function () {
+
+ this.particleShaderMat.dispose();
+ this.particleNoiseTex.dispose();
+ this.particleSpriteTex.dispose();
+
+ for ( var i = 0; i < this.PARTICLE_CONTAINERS; i ++ ) {
+
+ this.particleContainers[ i ].dispose();
+
+ }
+
+ };
+
+ this.init();
+
+};
+
+THREE.GPUParticleSystem.prototype = Object.create( THREE.Object3D.prototype );
+THREE.GPUParticleSystem.prototype.constructor = THREE.GPUParticleSystem;
+
+
+// Subclass for particle containers, allows for very large arrays to be spread out
+
+THREE.GPUParticleContainer = function ( maxParticles, particleSystem ) {
+
+ THREE.Object3D.apply( this, arguments );
+
+ this.PARTICLE_COUNT = maxParticles || 100000;
+ this.PARTICLE_CURSOR = 0;
+ this.time = 0;
+ this.offset = 0;
+ this.count = 0;
+ this.DPR = window.devicePixelRatio;
+ this.GPUParticleSystem = particleSystem;
+ this.particleUpdate = false;
+
+ // geometry
+
+ this.particleShaderGeo = new THREE.BufferGeometry();
+
+ this.particleShaderGeo.addAttribute( 'position', new THREE.BufferAttribute( new Float32Array( this.PARTICLE_COUNT * 3 ), 3 ).setDynamic( true ) );
+ this.particleShaderGeo.addAttribute( 'positionStart', new THREE.BufferAttribute( new Float32Array( this.PARTICLE_COUNT * 3 ), 3 ).setDynamic( true ) );
+ this.particleShaderGeo.addAttribute( 'startTime', new THREE.BufferAttribute( new Float32Array( this.PARTICLE_COUNT ), 1 ).setDynamic( true ) );
+ this.particleShaderGeo.addAttribute( 'velocity', new THREE.BufferAttribute( new Float32Array( this.PARTICLE_COUNT * 3 ), 3 ).setDynamic( true ) );
+ this.particleShaderGeo.addAttribute( 'turbulence', new THREE.BufferAttribute( new Float32Array( this.PARTICLE_COUNT ), 1 ).setDynamic( true ) );
+ this.particleShaderGeo.addAttribute( 'color', new THREE.BufferAttribute( new Float32Array( this.PARTICLE_COUNT * 3 ), 3 ).setDynamic( true ) );
+ this.particleShaderGeo.addAttribute( 'size', new THREE.BufferAttribute( new Float32Array( this.PARTICLE_COUNT ), 1 ).setDynamic( true ) );
+ this.particleShaderGeo.addAttribute( 'lifeTime', new THREE.BufferAttribute( new Float32Array( this.PARTICLE_COUNT ), 1 ).setDynamic( true ) );
+
+ // material
+
+ this.particleShaderMat = this.GPUParticleSystem.particleShaderMat;
+
+ var position = new THREE.Vector3();
+ var velocity = new THREE.Vector3();
+ var color = new THREE.Color();
+
+ this.spawnParticle = function ( options ) {
+
+ var positionStartAttribute = this.particleShaderGeo.getAttribute( 'positionStart' );
+ var startTimeAttribute = this.particleShaderGeo.getAttribute( 'startTime' );
+ var velocityAttribute = this.particleShaderGeo.getAttribute( 'velocity' );
+ var turbulenceAttribute = this.particleShaderGeo.getAttribute( 'turbulence' );
+ var colorAttribute = this.particleShaderGeo.getAttribute( 'color' );
+ var sizeAttribute = this.particleShaderGeo.getAttribute( 'size' );
+ var lifeTimeAttribute = this.particleShaderGeo.getAttribute( 'lifeTime' );
+
+ options = options || {};
+
+ // setup reasonable default values for all arguments
+
+ position = options.position !== undefined ? position.copy( options.position ) : position.set( 0, 0, 0 );
+ velocity = options.velocity !== undefined ? velocity.copy( options.velocity ) : velocity.set( 0, 0, 0 );
+ color = options.color !== undefined ? color.set( options.color ) : color.set( 0xffffff );
+
+ var positionRandomness = options.positionRandomness !== undefined ? options.positionRandomness : 0;
+ var velocityRandomness = options.velocityRandomness !== undefined ? options.velocityRandomness : 0;
+ var colorRandomness = options.colorRandomness !== undefined ? options.colorRandomness : 1;
+ var turbulence = options.turbulence !== undefined ? options.turbulence : 1;
+ var lifetime = options.lifetime !== undefined ? options.lifetime : 5;
+ var size = options.size !== undefined ? options.size : 10;
+ var sizeRandomness = options.sizeRandomness !== undefined ? options.sizeRandomness : 0;
+ var smoothPosition = options.smoothPosition !== undefined ? options.smoothPosition : false;
+
+ if ( this.DPR !== undefined ) size *= this.DPR;
+
+ var i = this.PARTICLE_CURSOR;
+
+ // position
+
+ positionStartAttribute.array[ i * 3 + 0 ] = position.x + ( particleSystem.random() * positionRandomness );
+ positionStartAttribute.array[ i * 3 + 1 ] = position.y + ( particleSystem.random() * positionRandomness );
+ positionStartAttribute.array[ i * 3 + 2 ] = position.z + ( particleSystem.random() * positionRandomness );
+
+ if ( smoothPosition === true ) {
+
+ positionStartAttribute.array[ i * 3 + 0 ] += - ( velocity.x * particleSystem.random() );
+ positionStartAttribute.array[ i * 3 + 1 ] += - ( velocity.y * particleSystem.random() );
+ positionStartAttribute.array[ i * 3 + 2 ] += - ( velocity.z * particleSystem.random() );
+
+ }
+
+ // velocity
+
+ var maxVel = 2;
+
+ var velX = velocity.x + particleSystem.random() * velocityRandomness;
+ var velY = velocity.y + particleSystem.random() * velocityRandomness;
+ var velZ = velocity.z + particleSystem.random() * velocityRandomness;
+
+ velX = THREE.Math.clamp( ( velX - ( - maxVel ) ) / ( maxVel - ( - maxVel ) ), 0, 1 );
+ velY = THREE.Math.clamp( ( velY - ( - maxVel ) ) / ( maxVel - ( - maxVel ) ), 0, 1 );
+ velZ = THREE.Math.clamp( ( velZ - ( - maxVel ) ) / ( maxVel - ( - maxVel ) ), 0, 1 );
+
+ velocityAttribute.array[ i * 3 + 0 ] = velX;
+ velocityAttribute.array[ i * 3 + 1 ] = velY;
+ velocityAttribute.array[ i * 3 + 2 ] = velZ;
+
+ // color
+
+ color.r = THREE.Math.clamp( color.r + particleSystem.random() * colorRandomness, 0, 1 );
+ color.g = THREE.Math.clamp( color.g + particleSystem.random() * colorRandomness, 0, 1 );
+ color.b = THREE.Math.clamp( color.b + particleSystem.random() * colorRandomness, 0, 1 );
+
+ colorAttribute.array[ i * 3 + 0 ] = color.r;
+ colorAttribute.array[ i * 3 + 1 ] = color.g;
+ colorAttribute.array[ i * 3 + 2 ] = color.b;
+
+ // turbulence, size, lifetime and starttime
+
+ turbulenceAttribute.array[ i ] = turbulence;
+ sizeAttribute.array[ i ] = size + particleSystem.random() * sizeRandomness;
+ lifeTimeAttribute.array[ i ] = lifetime;
+ startTimeAttribute.array[ i ] = this.time + particleSystem.random() * 2e-2;
+
+ // offset
+
+ if ( this.offset === 0 ) {
+
+ this.offset = this.PARTICLE_CURSOR;
+
+ }
+
+ // counter and cursor
+
+ this.count ++;
+ this.PARTICLE_CURSOR ++;
+
+ if ( this.PARTICLE_CURSOR >= this.PARTICLE_COUNT ) {
+
+ this.PARTICLE_CURSOR = 0;
+
+ }
+
+ this.particleUpdate = true;
+
+ };
+
+ this.init = function () {
+
+ this.particleSystem = new THREE.Points( this.particleShaderGeo, this.particleShaderMat );
+ this.particleSystem.frustumCulled = false;
+ this.add( this.particleSystem );
+
+ };
+
+ this.update = function ( time ) {
+
+ this.time = time;
+ this.particleShaderMat.uniforms.uTime.value = time;
+
+ this.geometryUpdate();
+
+ };
+
+ this.geometryUpdate = function () {
+
+ if ( this.particleUpdate === true ) {
+
+ this.particleUpdate = false;
+
+ var positionStartAttribute = this.particleShaderGeo.getAttribute( 'positionStart' );
+ var startTimeAttribute = this.particleShaderGeo.getAttribute( 'startTime' );
+ var velocityAttribute = this.particleShaderGeo.getAttribute( 'velocity' );
+ var turbulenceAttribute = this.particleShaderGeo.getAttribute( 'turbulence' );
+ var colorAttribute = this.particleShaderGeo.getAttribute( 'color' );
+ var sizeAttribute = this.particleShaderGeo.getAttribute( 'size' );
+ var lifeTimeAttribute = this.particleShaderGeo.getAttribute( 'lifeTime' );
+
+ if ( this.offset + this.count < this.PARTICLE_COUNT ) {
+
+ positionStartAttribute.updateRange.offset = this.offset * positionStartAttribute.itemSize;
+ startTimeAttribute.updateRange.offset = this.offset * startTimeAttribute.itemSize;
+ velocityAttribute.updateRange.offset = this.offset * velocityAttribute.itemSize;
+ turbulenceAttribute.updateRange.offset = this.offset * turbulenceAttribute.itemSize;
+ colorAttribute.updateRange.offset = this.offset * colorAttribute.itemSize;
+ sizeAttribute.updateRange.offset = this.offset * sizeAttribute.itemSize;
+ lifeTimeAttribute.updateRange.offset = this.offset * lifeTimeAttribute.itemSize;
+
+ positionStartAttribute.updateRange.count = this.count * positionStartAttribute.itemSize;
+ startTimeAttribute.updateRange.count = this.count * startTimeAttribute.itemSize;
+ velocityAttribute.updateRange.count = this.count * velocityAttribute.itemSize;
+ turbulenceAttribute.updateRange.count = this.count * turbulenceAttribute.itemSize;
+ colorAttribute.updateRange.count = this.count * colorAttribute.itemSize;
+ sizeAttribute.updateRange.count = this.count * sizeAttribute.itemSize;
+ lifeTimeAttribute.updateRange.count = this.count * lifeTimeAttribute.itemSize;
+
+ } else {
+
+ positionStartAttribute.updateRange.offset = 0;
+ startTimeAttribute.updateRange.offset = 0;
+ velocityAttribute.updateRange.offset = 0;
+ turbulenceAttribute.updateRange.offset = 0;
+ colorAttribute.updateRange.offset = 0;
+ sizeAttribute.updateRange.offset = 0;
+ lifeTimeAttribute.updateRange.offset = 0;
+
+ // Use -1 to update the entire buffer, see #11476
+ positionStartAttribute.updateRange.count = - 1;
+ startTimeAttribute.updateRange.count = - 1;
+ velocityAttribute.updateRange.count = - 1;
+ turbulenceAttribute.updateRange.count = - 1;
+ colorAttribute.updateRange.count = - 1;
+ sizeAttribute.updateRange.count = - 1;
+ lifeTimeAttribute.updateRange.count = - 1;
+
+ }
+
+ positionStartAttribute.needsUpdate = true;
+ startTimeAttribute.needsUpdate = true;
+ velocityAttribute.needsUpdate = true;
+ turbulenceAttribute.needsUpdate = true;
+ colorAttribute.needsUpdate = true;
+ sizeAttribute.needsUpdate = true;
+ lifeTimeAttribute.needsUpdate = true;
+
+ this.offset = 0;
+ this.count = 0;
+
+ }
+
+ };
+
+ this.dispose = function () {
+
+ this.particleShaderGeo.dispose();
+
+ };
+
+ this.init();
+
+};
+
+THREE.GPUParticleContainer.prototype = Object.create( THREE.Object3D.prototype );
+THREE.GPUParticleContainer.prototype.constructor = THREE.GPUParticleContainer;
diff --git a/three/jsutil/Gyroscope.js b/three/jsutil/Gyroscope.js
new file mode 100644
index 000000000..a235a51ca
--- /dev/null
+++ b/three/jsutil/Gyroscope.js
@@ -0,0 +1,65 @@
+/**
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.Gyroscope = function () {
+
+ THREE.Object3D.call( this );
+
+};
+
+THREE.Gyroscope.prototype = Object.create( THREE.Object3D.prototype );
+THREE.Gyroscope.prototype.constructor = THREE.Gyroscope;
+
+THREE.Gyroscope.prototype.updateMatrixWorld = ( function () {
+
+ var translationObject = new THREE.Vector3();
+ var quaternionObject = new THREE.Quaternion();
+ var scaleObject = new THREE.Vector3();
+
+ var translationWorld = new THREE.Vector3();
+ var quaternionWorld = new THREE.Quaternion();
+ var scaleWorld = new THREE.Vector3();
+
+ return function updateMatrixWorld( force ) {
+
+ this.matrixAutoUpdate && this.updateMatrix();
+
+ // update matrixWorld
+
+ if ( this.matrixWorldNeedsUpdate || force ) {
+
+ if ( this.parent !== null ) {
+
+ this.matrixWorld.multiplyMatrices( this.parent.matrixWorld, this.matrix );
+
+ this.matrixWorld.decompose( translationWorld, quaternionWorld, scaleWorld );
+ this.matrix.decompose( translationObject, quaternionObject, scaleObject );
+
+ this.matrixWorld.compose( translationWorld, quaternionObject, scaleWorld );
+
+
+ } else {
+
+ this.matrixWorld.copy( this.matrix );
+
+ }
+
+
+ this.matrixWorldNeedsUpdate = false;
+
+ force = true;
+
+ }
+
+ // update children
+
+ for ( var i = 0, l = this.children.length; i < l; i ++ ) {
+
+ this.children[ i ].updateMatrixWorld( force );
+
+ }
+
+ };
+
+}() );
diff --git a/three/jsutil/ImprovedNoise.js b/three/jsutil/ImprovedNoise.js
new file mode 100644
index 000000000..35db42695
--- /dev/null
+++ b/three/jsutil/ImprovedNoise.js
@@ -0,0 +1,71 @@
+// http://mrl.nyu.edu/~perlin/noise/
+
+var ImprovedNoise = function () {
+
+ var p = [ 151,160,137,91,90,15,131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,
+ 23,190,6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,88,237,149,56,87,
+ 174,20,125,136,171,168,68,175,74,165,71,134,139,48,27,166,77,146,158,231,83,111,229,122,60,211,
+ 133,230,220,105,92,41,55,46,245,40,244,102,143,54,65,25,63,161,1,216,80,73,209,76,132,187,208,
+ 89,18,169,200,196,135,130,116,188,159,86,164,100,109,198,173,186,3,64,52,217,226,250,124,123,5,
+ 202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,223,183,170,213,119,
+ 248,152,2,44,154,163,70,221,153,101,155,167,43,172,9,129,22,39,253,19,98,108,110,79,113,224,232,
+ 178,185,112,104,218,246,97,228,251,34,242,193,238,210,144,12,191,179,162,241,81,51,145,235,249,
+ 14,239,107,49,192,214,31,181,199,106,157,184,84,204,176,115,121,50,45,127,4,150,254,138,236,205,
+ 93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180 ];
+
+ for (var i = 0; i < 256 ; i ++) {
+
+ p[256 + i] = p[i];
+
+ }
+
+ function fade(t) {
+
+ return t * t * t * (t * (t * 6 - 15) + 10);
+
+ }
+
+ function lerp(t, a, b) {
+
+ return a + t * (b - a);
+
+ }
+
+ function grad(hash, x, y, z) {
+
+ var h = hash & 15;
+ var u = h < 8 ? x : y, v = h < 4 ? y : h == 12 || h == 14 ? x : z;
+ return ((h&1) == 0 ? u : -u) + ((h&2) == 0 ? v : -v);
+
+ }
+
+ return {
+
+ noise: function (x, y, z) {
+
+ var floorX = Math.floor(x), floorY = Math.floor(y), floorZ = Math.floor(z);
+
+ var X = floorX & 255, Y = floorY & 255, Z = floorZ & 255;
+
+ x -= floorX;
+ y -= floorY;
+ z -= floorZ;
+
+ var xMinus1 = x - 1, yMinus1 = y - 1, zMinus1 = z - 1;
+
+ var u = fade(x), v = fade(y), w = fade(z);
+
+ var A = p[X] + Y, AA = p[A] + Z, AB = p[A + 1] + Z, B = p[X + 1] + Y, BA = p[B] + Z, BB = p[B + 1] + Z;
+
+ return lerp(w, lerp(v, lerp(u, grad(p[AA], x, y, z),
+ grad(p[BA], xMinus1, y, z)),
+ lerp(u, grad(p[AB], x, yMinus1, z),
+ grad(p[BB], xMinus1, yMinus1, z))),
+ lerp(v, lerp(u, grad(p[AA + 1], x, y, zMinus1),
+ grad(p[BA + 1], xMinus1, y, z - 1)),
+ lerp(u, grad(p[AB + 1], x, yMinus1, zMinus1),
+ grad(p[BB + 1], xMinus1, yMinus1, zMinus1))));
+
+ }
+ }
+};
diff --git a/three/jsutil/MD2Character.js b/three/jsutil/MD2Character.js
new file mode 100644
index 000000000..155eccb9c
--- /dev/null
+++ b/three/jsutil/MD2Character.js
@@ -0,0 +1,259 @@
+/**
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.MD2Character = function () {
+
+ var scope = this;
+
+ this.scale = 1;
+ this.animationFPS = 6;
+
+ this.root = new THREE.Object3D();
+
+ this.meshBody = null;
+ this.meshWeapon = null;
+
+ this.skinsBody = [];
+ this.skinsWeapon = [];
+
+ this.weapons = [];
+
+ this.activeAnimation = null;
+
+ this.mixer = null;
+
+ this.onLoadComplete = function () {};
+
+ this.loadCounter = 0;
+
+ this.loadParts = function ( config ) {
+
+ this.loadCounter = config.weapons.length * 2 + config.skins.length + 1;
+
+ var weaponsTextures = [];
+ for ( var i = 0; i < config.weapons.length; i ++ ) weaponsTextures[ i ] = config.weapons[ i ][ 1 ];
+ // SKINS
+
+ this.skinsBody = loadTextures( config.baseUrl + "skins/", config.skins );
+ this.skinsWeapon = loadTextures( config.baseUrl + "skins/", weaponsTextures );
+
+ // BODY
+
+ var loader = new THREE.MD2Loader();
+
+ loader.load( config.baseUrl + config.body, function ( geo ) {
+
+ geo.computeBoundingBox();
+ scope.root.position.y = - scope.scale * geo.boundingBox.min.y;
+
+ var mesh = createPart( geo, scope.skinsBody[ 0 ] );
+ mesh.scale.set( scope.scale, scope.scale, scope.scale );
+
+ scope.root.add( mesh );
+
+ scope.meshBody = mesh;
+
+ scope.meshBody.clipOffset = 0;
+ scope.activeAnimationClipName = mesh.geometry.animations[ 0 ].name;
+
+ scope.mixer = new THREE.AnimationMixer( mesh );
+
+ checkLoadingComplete();
+
+ } );
+
+ // WEAPONS
+
+ var generateCallback = function ( index, name ) {
+
+ return function ( geo ) {
+
+ var mesh = createPart( geo, scope.skinsWeapon[ index ] );
+ mesh.scale.set( scope.scale, scope.scale, scope.scale );
+ mesh.visible = false;
+
+ mesh.name = name;
+
+ scope.root.add( mesh );
+
+ scope.weapons[ index ] = mesh;
+ scope.meshWeapon = mesh;
+
+ checkLoadingComplete();
+
+ };
+
+ };
+
+ for ( var i = 0; i < config.weapons.length; i ++ ) {
+
+ loader.load( config.baseUrl + config.weapons[ i ][ 0 ], generateCallback( i, config.weapons[ i ][ 0 ] ) );
+
+ }
+
+ };
+
+ this.setPlaybackRate = function ( rate ) {
+
+ if ( rate !== 0 ) {
+
+ this.mixer.timeScale = 1 / rate;
+
+ } else {
+
+ this.mixer.timeScale = 0;
+
+ }
+
+ };
+
+ this.setWireframe = function ( wireframeEnabled ) {
+
+ if ( wireframeEnabled ) {
+
+ if ( this.meshBody ) this.meshBody.material = this.meshBody.materialWireframe;
+ if ( this.meshWeapon ) this.meshWeapon.material = this.meshWeapon.materialWireframe;
+
+ } else {
+
+ if ( this.meshBody ) this.meshBody.material = this.meshBody.materialTexture;
+ if ( this.meshWeapon ) this.meshWeapon.material = this.meshWeapon.materialTexture;
+
+ }
+
+ };
+
+ this.setSkin = function ( index ) {
+
+ if ( this.meshBody && this.meshBody.material.wireframe === false ) {
+
+ this.meshBody.material.map = this.skinsBody[ index ];
+
+ }
+
+ };
+
+ this.setWeapon = function ( index ) {
+
+ for ( var i = 0; i < this.weapons.length; i ++ ) this.weapons[ i ].visible = false;
+
+ var activeWeapon = this.weapons[ index ];
+
+ if ( activeWeapon ) {
+
+ activeWeapon.visible = true;
+ this.meshWeapon = activeWeapon;
+
+ scope.syncWeaponAnimation();
+
+ }
+
+ };
+
+ this.setAnimation = function ( clipName ) {
+
+ if ( this.meshBody ) {
+
+ if ( this.meshBody.activeAction ) {
+
+ this.meshBody.activeAction.stop();
+ this.meshBody.activeAction = null;
+
+ }
+
+ var action = this.mixer.clipAction( clipName, this.meshBody );
+
+ if ( action ) {
+
+ this.meshBody.activeAction = action.play();
+
+ }
+
+ }
+
+ scope.activeClipName = clipName;
+
+ scope.syncWeaponAnimation();
+
+ };
+
+ this.syncWeaponAnimation = function () {
+
+ var clipName = scope.activeClipName;
+
+ if ( scope.meshWeapon ) {
+
+ if ( this.meshWeapon.activeAction ) {
+
+ this.meshWeapon.activeAction.stop();
+ this.meshWeapon.activeAction = null;
+
+ }
+
+ var action = this.mixer.clipAction( clipName, this.meshWeapon );
+
+ if ( action ) {
+
+ this.meshWeapon.activeAction = action.syncWith( this.meshBody.activeAction ).play();
+
+ }
+
+ }
+
+ };
+
+ this.update = function ( delta ) {
+
+ if ( this.mixer ) this.mixer.update( delta );
+
+ };
+
+ function loadTextures( baseUrl, textureUrls ) {
+
+ var textureLoader = new THREE.TextureLoader();
+ var textures = [];
+
+ for ( var i = 0; i < textureUrls.length; i ++ ) {
+
+ textures[ i ] = textureLoader.load( baseUrl + textureUrls[ i ], checkLoadingComplete );
+ textures[ i ].mapping = THREE.UVMapping;
+ textures[ i ].name = textureUrls[ i ];
+
+ }
+
+ return textures;
+
+ }
+
+ function createPart( geometry, skinMap ) {
+
+ var materialWireframe = new THREE.MeshLambertMaterial( { color: 0xffaa00, wireframe: true, morphTargets: true, morphNormals: true } );
+ var materialTexture = new THREE.MeshLambertMaterial( { color: 0xffffff, wireframe: false, map: skinMap, morphTargets: true, morphNormals: true } );
+
+ //
+
+ var mesh = new THREE.Mesh( geometry, materialTexture );
+ mesh.rotation.y = - Math.PI / 2;
+
+ mesh.castShadow = true;
+ mesh.receiveShadow = true;
+
+ //
+
+ mesh.materialTexture = materialTexture;
+ mesh.materialWireframe = materialWireframe;
+
+ return mesh;
+
+ }
+
+ function checkLoadingComplete() {
+
+ scope.loadCounter -= 1;
+
+ if ( scope.loadCounter === 0 ) scope.onLoadComplete();
+
+ }
+
+};
diff --git a/three/jsutil/MD2CharacterComplex.js b/three/jsutil/MD2CharacterComplex.js
new file mode 100644
index 000000000..699c82b8a
--- /dev/null
+++ b/three/jsutil/MD2CharacterComplex.js
@@ -0,0 +1,560 @@
+/**
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.MD2CharacterComplex = function () {
+
+ var scope = this;
+
+ this.scale = 1;
+
+ // animation parameters
+
+ this.animationFPS = 6;
+ this.transitionFrames = 15;
+
+ // movement model parameters
+
+ this.maxSpeed = 275;
+ this.maxReverseSpeed = - 275;
+
+ this.frontAcceleration = 600;
+ this.backAcceleration = 600;
+
+ this.frontDecceleration = 600;
+
+ this.angularSpeed = 2.5;
+
+ // rig
+
+ this.root = new THREE.Object3D();
+
+ this.meshBody = null;
+ this.meshWeapon = null;
+
+ this.controls = null;
+
+ // skins
+
+ this.skinsBody = [];
+ this.skinsWeapon = [];
+
+ this.weapons = [];
+
+ this.currentSkin = undefined;
+
+ //
+
+ this.onLoadComplete = function () {};
+
+ // internals
+
+ this.meshes = [];
+ this.animations = {};
+
+ this.loadCounter = 0;
+
+ // internal movement control variables
+
+ this.speed = 0;
+ this.bodyOrientation = 0;
+
+ this.walkSpeed = this.maxSpeed;
+ this.crouchSpeed = this.maxSpeed * 0.5;
+
+ // internal animation parameters
+
+ this.activeAnimation = null;
+ this.oldAnimation = null;
+
+ // API
+
+ this.enableShadows = function ( enable ) {
+
+ for ( var i = 0; i < this.meshes.length; i ++ ) {
+
+ this.meshes[ i ].castShadow = enable;
+ this.meshes[ i ].receiveShadow = enable;
+
+ }
+
+ };
+
+ this.setVisible = function ( enable ) {
+
+ for ( var i = 0; i < this.meshes.length; i ++ ) {
+
+ this.meshes[ i ].visible = enable;
+ this.meshes[ i ].visible = enable;
+
+ }
+
+ };
+
+
+ this.shareParts = function ( original ) {
+
+ this.animations = original.animations;
+ this.walkSpeed = original.walkSpeed;
+ this.crouchSpeed = original.crouchSpeed;
+
+ this.skinsBody = original.skinsBody;
+ this.skinsWeapon = original.skinsWeapon;
+
+ // BODY
+
+ var mesh = createPart( original.meshBody.geometry, this.skinsBody[ 0 ] );
+ mesh.scale.set( this.scale, this.scale, this.scale );
+
+ this.root.position.y = original.root.position.y;
+ this.root.add( mesh );
+
+ this.meshBody = mesh;
+
+ this.meshes.push( mesh );
+
+ // WEAPONS
+
+ for ( var i = 0; i < original.weapons.length; i ++ ) {
+
+ var meshWeapon = createPart( original.weapons[ i ].geometry, this.skinsWeapon[ i ] );
+ meshWeapon.scale.set( this.scale, this.scale, this.scale );
+ meshWeapon.visible = false;
+
+ meshWeapon.name = original.weapons[ i ].name;
+
+ this.root.add( meshWeapon );
+
+ this.weapons[ i ] = meshWeapon;
+ this.meshWeapon = meshWeapon;
+
+ this.meshes.push( meshWeapon );
+
+ }
+
+ };
+
+ this.loadParts = function ( config ) {
+
+ this.animations = config.animations;
+ this.walkSpeed = config.walkSpeed;
+ this.crouchSpeed = config.crouchSpeed;
+
+ this.loadCounter = config.weapons.length * 2 + config.skins.length + 1;
+
+ var weaponsTextures = [];
+ for ( var i = 0; i < config.weapons.length; i ++ ) weaponsTextures[ i ] = config.weapons[ i ][ 1 ];
+
+ // SKINS
+
+ this.skinsBody = loadTextures( config.baseUrl + "skins/", config.skins );
+ this.skinsWeapon = loadTextures( config.baseUrl + "skins/", weaponsTextures );
+
+ // BODY
+
+ var loader = new THREE.MD2Loader();
+
+ loader.load( config.baseUrl + config.body, function( geo ) {
+
+ geo.computeBoundingBox();
+ scope.root.position.y = - scope.scale * geo.boundingBox.min.y;
+
+ var mesh = createPart( geo, scope.skinsBody[ 0 ] );
+ mesh.scale.set( scope.scale, scope.scale, scope.scale );
+
+ scope.root.add( mesh );
+
+ scope.meshBody = mesh;
+ scope.meshes.push( mesh );
+
+ checkLoadingComplete();
+
+ } );
+
+ // WEAPONS
+
+ var generateCallback = function ( index, name ) {
+
+ return function( geo ) {
+
+ var mesh = createPart( geo, scope.skinsWeapon[ index ] );
+ mesh.scale.set( scope.scale, scope.scale, scope.scale );
+ mesh.visible = false;
+
+ mesh.name = name;
+
+ scope.root.add( mesh );
+
+ scope.weapons[ index ] = mesh;
+ scope.meshWeapon = mesh;
+ scope.meshes.push( mesh );
+
+ checkLoadingComplete();
+
+ }
+
+ };
+
+ for ( var i = 0; i < config.weapons.length; i ++ ) {
+
+ loader.load( config.baseUrl + config.weapons[ i ][ 0 ], generateCallback( i, config.weapons[ i ][ 0 ] ) );
+
+ }
+
+ };
+
+ this.setPlaybackRate = function ( rate ) {
+
+ if ( this.meshBody ) this.meshBody.duration = this.meshBody.baseDuration / rate;
+ if ( this.meshWeapon ) this.meshWeapon.duration = this.meshWeapon.baseDuration / rate;
+
+ };
+
+ this.setWireframe = function ( wireframeEnabled ) {
+
+ if ( wireframeEnabled ) {
+
+ if ( this.meshBody ) this.meshBody.material = this.meshBody.materialWireframe;
+ if ( this.meshWeapon ) this.meshWeapon.material = this.meshWeapon.materialWireframe;
+
+ } else {
+
+ if ( this.meshBody ) this.meshBody.material = this.meshBody.materialTexture;
+ if ( this.meshWeapon ) this.meshWeapon.material = this.meshWeapon.materialTexture;
+
+ }
+
+ };
+
+ this.setSkin = function( index ) {
+
+ if ( this.meshBody && this.meshBody.material.wireframe === false ) {
+
+ this.meshBody.material.map = this.skinsBody[ index ];
+ this.currentSkin = index;
+
+ }
+
+ };
+
+ this.setWeapon = function ( index ) {
+
+ for ( var i = 0; i < this.weapons.length; i ++ ) this.weapons[ i ].visible = false;
+
+ var activeWeapon = this.weapons[ index ];
+
+ if ( activeWeapon ) {
+
+ activeWeapon.visible = true;
+ this.meshWeapon = activeWeapon;
+
+ if ( this.activeAnimation ) {
+
+ activeWeapon.playAnimation( this.activeAnimation );
+ this.meshWeapon.setAnimationTime( this.activeAnimation, this.meshBody.getAnimationTime( this.activeAnimation ) );
+
+ }
+
+ }
+
+ };
+
+ this.setAnimation = function ( animationName ) {
+
+ if ( animationName === this.activeAnimation || ! animationName ) return;
+
+ if ( this.meshBody ) {
+
+ this.meshBody.setAnimationWeight( animationName, 0 );
+ this.meshBody.playAnimation( animationName );
+
+ this.oldAnimation = this.activeAnimation;
+ this.activeAnimation = animationName;
+
+ this.blendCounter = this.transitionFrames;
+
+ }
+
+ if ( this.meshWeapon ) {
+
+ this.meshWeapon.setAnimationWeight( animationName, 0 );
+ this.meshWeapon.playAnimation( animationName );
+
+ }
+
+
+ };
+
+ this.update = function ( delta ) {
+
+ if ( this.controls ) this.updateMovementModel( delta );
+
+ if ( this.animations ) {
+
+ this.updateBehaviors( delta );
+ this.updateAnimations( delta );
+
+ }
+
+ };
+
+ this.updateAnimations = function ( delta ) {
+
+ var mix = 1;
+
+ if ( this.blendCounter > 0 ) {
+
+ mix = ( this.transitionFrames - this.blendCounter ) / this.transitionFrames;
+ this.blendCounter -= 1;
+
+ }
+
+ if ( this.meshBody ) {
+
+ this.meshBody.update( delta );
+
+ this.meshBody.setAnimationWeight( this.activeAnimation, mix );
+ this.meshBody.setAnimationWeight( this.oldAnimation, 1 - mix );
+
+ }
+
+ if ( this.meshWeapon ) {
+
+ this.meshWeapon.update( delta );
+
+ this.meshWeapon.setAnimationWeight( this.activeAnimation, mix );
+ this.meshWeapon.setAnimationWeight( this.oldAnimation, 1 - mix );
+
+ }
+
+ };
+
+ this.updateBehaviors = function ( delta ) {
+
+ var controls = this.controls;
+ var animations = this.animations;
+
+ var moveAnimation, idleAnimation;
+
+ // crouch vs stand
+
+ if ( controls.crouch ) {
+
+ moveAnimation = animations[ "crouchMove" ];
+ idleAnimation = animations[ "crouchIdle" ];
+
+ } else {
+
+ moveAnimation = animations[ "move" ];
+ idleAnimation = animations[ "idle" ];
+
+ }
+
+ // actions
+
+ if ( controls.jump ) {
+
+ moveAnimation = animations[ "jump" ];
+ idleAnimation = animations[ "jump" ];
+
+ }
+
+ if ( controls.attack ) {
+
+ if ( controls.crouch ) {
+
+ moveAnimation = animations[ "crouchAttack" ];
+ idleAnimation = animations[ "crouchAttack" ];
+
+ } else {
+
+ moveAnimation = animations[ "attack" ];
+ idleAnimation = animations[ "attack" ];
+
+ }
+
+ }
+
+ // set animations
+
+ if ( controls.moveForward || controls.moveBackward || controls.moveLeft || controls.moveRight ) {
+
+ if ( this.activeAnimation !== moveAnimation ) {
+
+ this.setAnimation( moveAnimation );
+
+ }
+
+ }
+
+
+ if ( Math.abs( this.speed ) < 0.2 * this.maxSpeed && ! ( controls.moveLeft || controls.moveRight || controls.moveForward || controls.moveBackward ) ) {
+
+ if ( this.activeAnimation !== idleAnimation ) {
+
+ this.setAnimation( idleAnimation );
+
+ }
+
+ }
+
+ // set animation direction
+
+ if ( controls.moveForward ) {
+
+ if ( this.meshBody ) {
+
+ this.meshBody.setAnimationDirectionForward( this.activeAnimation );
+ this.meshBody.setAnimationDirectionForward( this.oldAnimation );
+
+ }
+
+ if ( this.meshWeapon ) {
+
+ this.meshWeapon.setAnimationDirectionForward( this.activeAnimation );
+ this.meshWeapon.setAnimationDirectionForward( this.oldAnimation );
+
+ }
+
+ }
+
+ if ( controls.moveBackward ) {
+
+ if ( this.meshBody ) {
+
+ this.meshBody.setAnimationDirectionBackward( this.activeAnimation );
+ this.meshBody.setAnimationDirectionBackward( this.oldAnimation );
+
+ }
+
+ if ( this.meshWeapon ) {
+
+ this.meshWeapon.setAnimationDirectionBackward( this.activeAnimation );
+ this.meshWeapon.setAnimationDirectionBackward( this.oldAnimation );
+
+ }
+
+ }
+
+ };
+
+ this.updateMovementModel = function ( delta ) {
+
+ var controls = this.controls;
+
+ // speed based on controls
+
+ if ( controls.crouch ) this.maxSpeed = this.crouchSpeed;
+ else this.maxSpeed = this.walkSpeed;
+
+ this.maxReverseSpeed = - this.maxSpeed;
+
+ if ( controls.moveForward ) this.speed = THREE.Math.clamp( this.speed + delta * this.frontAcceleration, this.maxReverseSpeed, this.maxSpeed );
+ if ( controls.moveBackward ) this.speed = THREE.Math.clamp( this.speed - delta * this.backAcceleration, this.maxReverseSpeed, this.maxSpeed );
+
+ // orientation based on controls
+ // (don't just stand while turning)
+
+ var dir = 1;
+
+ if ( controls.moveLeft ) {
+
+ this.bodyOrientation += delta * this.angularSpeed;
+ this.speed = THREE.Math.clamp( this.speed + dir * delta * this.frontAcceleration, this.maxReverseSpeed, this.maxSpeed );
+
+ }
+
+ if ( controls.moveRight ) {
+
+ this.bodyOrientation -= delta * this.angularSpeed;
+ this.speed = THREE.Math.clamp( this.speed + dir * delta * this.frontAcceleration, this.maxReverseSpeed, this.maxSpeed );
+
+ }
+
+ // speed decay
+
+ if ( ! ( controls.moveForward || controls.moveBackward ) ) {
+
+ if ( this.speed > 0 ) {
+
+ var k = exponentialEaseOut( this.speed / this.maxSpeed );
+ this.speed = THREE.Math.clamp( this.speed - k * delta * this.frontDecceleration, 0, this.maxSpeed );
+
+ } else {
+
+ var k = exponentialEaseOut( this.speed / this.maxReverseSpeed );
+ this.speed = THREE.Math.clamp( this.speed + k * delta * this.backAcceleration, this.maxReverseSpeed, 0 );
+
+ }
+
+ }
+
+ // displacement
+
+ var forwardDelta = this.speed * delta;
+
+ this.root.position.x += Math.sin( this.bodyOrientation ) * forwardDelta;
+ this.root.position.z += Math.cos( this.bodyOrientation ) * forwardDelta;
+
+ // steering
+
+ this.root.rotation.y = this.bodyOrientation;
+
+ };
+
+ // internal helpers
+
+ function loadTextures( baseUrl, textureUrls ) {
+
+ var textureLoader = new THREE.TextureLoader();
+ var textures = [];
+
+ for ( var i = 0; i < textureUrls.length; i ++ ) {
+
+ textures[ i ] = textureLoader.load( baseUrl + textureUrls[ i ], checkLoadingComplete );
+ textures[ i ].mapping = THREE.UVMapping;
+ textures[ i ].name = textureUrls[ i ];
+
+ }
+
+ return textures;
+
+ }
+
+ function createPart( geometry, skinMap ) {
+
+ var materialWireframe = new THREE.MeshLambertMaterial( { color: 0xffaa00, wireframe: true, morphTargets: true, morphNormals: true } );
+ var materialTexture = new THREE.MeshLambertMaterial( { color: 0xffffff, wireframe: false, map: skinMap, morphTargets: true, morphNormals: true } );
+
+ //
+
+ var mesh = new THREE.MorphBlendMesh( geometry, materialTexture );
+ mesh.rotation.y = - Math.PI / 2;
+
+ //
+
+ mesh.materialTexture = materialTexture;
+ mesh.materialWireframe = materialWireframe;
+
+ //
+
+ mesh.autoCreateAnimations( scope.animationFPS );
+
+ return mesh;
+
+ }
+
+ function checkLoadingComplete() {
+
+ scope.loadCounter -= 1;
+ if ( scope.loadCounter === 0 ) scope.onLoadComplete();
+
+ }
+
+ function exponentialEaseOut( k ) {
+
+ return k === 1 ? 1 : - Math.pow( 2, - 10 * k ) + 1;
+
+ }
+
+};
diff --git a/three/jsutil/MarchingCubes.js b/three/jsutil/MarchingCubes.js
new file mode 100644
index 000000000..c56491530
--- /dev/null
+++ b/three/jsutil/MarchingCubes.js
@@ -0,0 +1,1067 @@
+/**
+ * @author alteredq / http://alteredqualia.com/
+ * @author mrdoob / http://mrdoob.com
+ * Port of http://webglsamples.org/blob/blob.html
+ */
+
+THREE.MarchingCubes = function ( resolution, material, enableUvs, enableColors ) {
+
+ THREE.ImmediateRenderObject.call( this, material );
+
+ var scope = this;
+
+ // temp buffers used in polygonize
+
+ var vlist = new Float32Array( 12 * 3 );
+ var nlist = new Float32Array( 12 * 3 );
+
+ this.enableUvs = enableUvs !== undefined ? enableUvs : false;
+ this.enableColors = enableColors !== undefined ? enableColors : false;
+
+ // functions have to be object properties
+ // prototype functions kill performance
+ // (tested and it was 4x slower !!!)
+
+ this.init = function ( resolution ) {
+
+ this.resolution = resolution;
+
+ // parameters
+
+ this.isolation = 80.0;
+
+ // size of field, 32 is pushing it in Javascript :)
+
+ this.size = resolution;
+ this.size2 = this.size * this.size;
+ this.size3 = this.size2 * this.size;
+ this.halfsize = this.size / 2.0;
+
+ // deltas
+
+ this.delta = 2.0 / this.size;
+ this.yd = this.size;
+ this.zd = this.size2;
+
+ this.field = new Float32Array( this.size3 );
+ this.normal_cache = new Float32Array( this.size3 * 3 );
+
+ // immediate render mode simulator
+
+ this.maxCount = 4096; // TODO: find the fastest size for this buffer
+ this.count = 0;
+
+ this.hasPositions = false;
+ this.hasNormals = false;
+ this.hasColors = false;
+ this.hasUvs = false;
+
+ this.positionArray = new Float32Array( this.maxCount * 3 );
+ this.normalArray = new Float32Array( this.maxCount * 3 );
+
+ if ( this.enableUvs ) {
+
+ this.uvArray = new Float32Array( this.maxCount * 2 );
+
+ }
+
+ if ( this.enableColors ) {
+
+ this.colorArray = new Float32Array( this.maxCount * 3 );
+
+ }
+
+ };
+
+ ///////////////////////
+ // Polygonization
+ ///////////////////////
+
+ function lerp( a, b, t ) {
+
+ return a + ( b - a ) * t;
+
+ }
+
+ function VIntX( q, offset, isol, x, y, z, valp1, valp2 ) {
+
+ var mu = ( isol - valp1 ) / ( valp2 - valp1 ),
+ nc = scope.normal_cache;
+
+ vlist[ offset + 0 ] = x + mu * scope.delta;
+ vlist[ offset + 1 ] = y;
+ vlist[ offset + 2 ] = z;
+
+ nlist[ offset + 0 ] = lerp( nc[ q + 0 ], nc[ q + 3 ], mu );
+ nlist[ offset + 1 ] = lerp( nc[ q + 1 ], nc[ q + 4 ], mu );
+ nlist[ offset + 2 ] = lerp( nc[ q + 2 ], nc[ q + 5 ], mu );
+
+ }
+
+ function VIntY( q, offset, isol, x, y, z, valp1, valp2 ) {
+
+ var mu = ( isol - valp1 ) / ( valp2 - valp1 ),
+ nc = scope.normal_cache;
+
+ vlist[ offset + 0 ] = x;
+ vlist[ offset + 1 ] = y + mu * scope.delta;
+ vlist[ offset + 2 ] = z;
+
+ var q2 = q + scope.yd * 3;
+
+ nlist[ offset + 0 ] = lerp( nc[ q + 0 ], nc[ q2 + 0 ], mu );
+ nlist[ offset + 1 ] = lerp( nc[ q + 1 ], nc[ q2 + 1 ], mu );
+ nlist[ offset + 2 ] = lerp( nc[ q + 2 ], nc[ q2 + 2 ], mu );
+
+ }
+
+ function VIntZ( q, offset, isol, x, y, z, valp1, valp2 ) {
+
+ var mu = ( isol - valp1 ) / ( valp2 - valp1 ),
+ nc = scope.normal_cache;
+
+ vlist[ offset + 0 ] = x;
+ vlist[ offset + 1 ] = y;
+ vlist[ offset + 2 ] = z + mu * scope.delta;
+
+ var q2 = q + scope.zd * 3;
+
+ nlist[ offset + 0 ] = lerp( nc[ q + 0 ], nc[ q2 + 0 ], mu );
+ nlist[ offset + 1 ] = lerp( nc[ q + 1 ], nc[ q2 + 1 ], mu );
+ nlist[ offset + 2 ] = lerp( nc[ q + 2 ], nc[ q2 + 2 ], mu );
+
+ }
+
+ function compNorm( q ) {
+
+ var q3 = q * 3;
+
+ if ( scope.normal_cache[ q3 ] === 0.0 ) {
+
+ scope.normal_cache[ q3 + 0 ] = scope.field[ q - 1 ] - scope.field[ q + 1 ];
+ scope.normal_cache[ q3 + 1 ] = scope.field[ q - scope.yd ] - scope.field[ q + scope.yd ];
+ scope.normal_cache[ q3 + 2 ] = scope.field[ q - scope.zd ] - scope.field[ q + scope.zd ];
+
+ }
+
+ }
+
+ // Returns total number of triangles. Fills triangles.
+ // (this is where most of time is spent - it's inner work of O(n3) loop )
+
+ function polygonize( fx, fy, fz, q, isol, renderCallback ) {
+
+ // cache indices
+ var q1 = q + 1,
+ qy = q + scope.yd,
+ qz = q + scope.zd,
+ q1y = q1 + scope.yd,
+ q1z = q1 + scope.zd,
+ qyz = q + scope.yd + scope.zd,
+ q1yz = q1 + scope.yd + scope.zd;
+
+ var cubeindex = 0,
+ field0 = scope.field[ q ],
+ field1 = scope.field[ q1 ],
+ field2 = scope.field[ qy ],
+ field3 = scope.field[ q1y ],
+ field4 = scope.field[ qz ],
+ field5 = scope.field[ q1z ],
+ field6 = scope.field[ qyz ],
+ field7 = scope.field[ q1yz ];
+
+ if ( field0 < isol ) cubeindex |= 1;
+ if ( field1 < isol ) cubeindex |= 2;
+ if ( field2 < isol ) cubeindex |= 8;
+ if ( field3 < isol ) cubeindex |= 4;
+ if ( field4 < isol ) cubeindex |= 16;
+ if ( field5 < isol ) cubeindex |= 32;
+ if ( field6 < isol ) cubeindex |= 128;
+ if ( field7 < isol ) cubeindex |= 64;
+
+ // if cube is entirely in/out of the surface - bail, nothing to draw
+
+ var bits = THREE.edgeTable[ cubeindex ];
+ if ( bits === 0 ) return 0;
+
+ var d = scope.delta,
+ fx2 = fx + d,
+ fy2 = fy + d,
+ fz2 = fz + d;
+
+ // top of the cube
+
+ if ( bits & 1 ) {
+
+ compNorm( q );
+ compNorm( q1 );
+ VIntX( q * 3, 0, isol, fx, fy, fz, field0, field1 );
+
+ }
+
+ if ( bits & 2 ) {
+
+ compNorm( q1 );
+ compNorm( q1y );
+ VIntY( q1 * 3, 3, isol, fx2, fy, fz, field1, field3 );
+
+ }
+
+ if ( bits & 4 ) {
+
+ compNorm( qy );
+ compNorm( q1y );
+ VIntX( qy * 3, 6, isol, fx, fy2, fz, field2, field3 );
+
+ }
+
+ if ( bits & 8 ) {
+
+ compNorm( q );
+ compNorm( qy );
+ VIntY( q * 3, 9, isol, fx, fy, fz, field0, field2 );
+
+ }
+
+ // bottom of the cube
+
+ if ( bits & 16 ) {
+
+ compNorm( qz );
+ compNorm( q1z );
+ VIntX( qz * 3, 12, isol, fx, fy, fz2, field4, field5 );
+
+ }
+
+ if ( bits & 32 ) {
+
+ compNorm( q1z );
+ compNorm( q1yz );
+ VIntY( q1z * 3, 15, isol, fx2, fy, fz2, field5, field7 );
+
+ }
+
+ if ( bits & 64 ) {
+
+ compNorm( qyz );
+ compNorm( q1yz );
+ VIntX( qyz * 3, 18, isol, fx, fy2, fz2, field6, field7 );
+
+ }
+
+ if ( bits & 128 ) {
+
+ compNorm( qz );
+ compNorm( qyz );
+ VIntY( qz * 3, 21, isol, fx, fy, fz2, field4, field6 );
+
+ }
+
+ // vertical lines of the cube
+
+ if ( bits & 256 ) {
+
+ compNorm( q );
+ compNorm( qz );
+ VIntZ( q * 3, 24, isol, fx, fy, fz, field0, field4 );
+
+ }
+
+ if ( bits & 512 ) {
+
+ compNorm( q1 );
+ compNorm( q1z );
+ VIntZ( q1 * 3, 27, isol, fx2, fy, fz, field1, field5 );
+
+ }
+
+ if ( bits & 1024 ) {
+
+ compNorm( q1y );
+ compNorm( q1yz );
+ VIntZ( q1y * 3, 30, isol, fx2, fy2, fz, field3, field7 );
+
+ }
+
+ if ( bits & 2048 ) {
+
+ compNorm( qy );
+ compNorm( qyz );
+ VIntZ( qy * 3, 33, isol, fx, fy2, fz, field2, field6 );
+
+ }
+
+ cubeindex <<= 4; // re-purpose cubeindex into an offset into triTable
+
+ var o1, o2, o3, numtris = 0, i = 0;
+
+ // here is where triangles are created
+
+ while ( THREE.triTable[ cubeindex + i ] != - 1 ) {
+
+ o1 = cubeindex + i;
+ o2 = o1 + 1;
+ o3 = o1 + 2;
+
+ posnormtriv( vlist, nlist,
+ 3 * THREE.triTable[ o1 ],
+ 3 * THREE.triTable[ o2 ],
+ 3 * THREE.triTable[ o3 ],
+ renderCallback );
+
+ i += 3;
+ numtris ++;
+
+ }
+
+ return numtris;
+
+ }
+
+ /////////////////////////////////////
+ // Immediate render mode simulator
+ /////////////////////////////////////
+
+ function posnormtriv( pos, norm, o1, o2, o3, renderCallback ) {
+
+ var c = scope.count * 3;
+
+ // positions
+
+ scope.positionArray[ c + 0 ] = pos[ o1 ];
+ scope.positionArray[ c + 1 ] = pos[ o1 + 1 ];
+ scope.positionArray[ c + 2 ] = pos[ o1 + 2 ];
+
+ scope.positionArray[ c + 3 ] = pos[ o2 ];
+ scope.positionArray[ c + 4 ] = pos[ o2 + 1 ];
+ scope.positionArray[ c + 5 ] = pos[ o2 + 2 ];
+
+ scope.positionArray[ c + 6 ] = pos[ o3 ];
+ scope.positionArray[ c + 7 ] = pos[ o3 + 1 ];
+ scope.positionArray[ c + 8 ] = pos[ o3 + 2 ];
+
+ // normals
+
+ if ( scope.material.flatShading === true ) {
+
+ var nx = ( norm[ o1 + 0 ] + norm[ o2 + 0 ] + norm[ o3 + 0 ] ) / 3;
+ var ny = ( norm[ o1 + 1 ] + norm[ o2 + 1 ] + norm[ o3 + 1 ] ) / 3;
+ var nz = ( norm[ o1 + 2 ] + norm[ o2 + 2 ] + norm[ o3 + 2 ] ) / 3;
+
+ scope.normalArray[ c + 0 ] = nx;
+ scope.normalArray[ c + 1 ] = ny;
+ scope.normalArray[ c + 2 ] = nz;
+
+ scope.normalArray[ c + 3 ] = nx;
+ scope.normalArray[ c + 4 ] = ny;
+ scope.normalArray[ c + 5 ] = nz;
+
+ scope.normalArray[ c + 6 ] = nx;
+ scope.normalArray[ c + 7 ] = ny;
+ scope.normalArray[ c + 8 ] = nz;
+
+
+ } else {
+
+ scope.normalArray[ c + 0 ] = norm[ o1 + 0 ];
+ scope.normalArray[ c + 1 ] = norm[ o1 + 1 ];
+ scope.normalArray[ c + 2 ] = norm[ o1 + 2 ];
+
+ scope.normalArray[ c + 3 ] = norm[ o2 + 0 ];
+ scope.normalArray[ c + 4 ] = norm[ o2 + 1 ];
+ scope.normalArray[ c + 5 ] = norm[ o2 + 2 ];
+
+ scope.normalArray[ c + 6 ] = norm[ o3 + 0 ];
+ scope.normalArray[ c + 7 ] = norm[ o3 + 1 ];
+ scope.normalArray[ c + 8 ] = norm[ o3 + 2 ];
+
+ }
+
+ // uvs
+
+ if ( scope.enableUvs ) {
+
+ var d = scope.count * 2;
+
+ scope.uvArray[ d + 0 ] = pos[ o1 + 0 ];
+ scope.uvArray[ d + 1 ] = pos[ o1 + 2 ];
+
+ scope.uvArray[ d + 2 ] = pos[ o2 + 0 ];
+ scope.uvArray[ d + 3 ] = pos[ o2 + 2 ];
+
+ scope.uvArray[ d + 4 ] = pos[ o3 + 0 ];
+ scope.uvArray[ d + 5 ] = pos[ o3 + 2 ];
+
+ }
+
+ // colors
+
+ if ( scope.enableColors ) {
+
+ scope.colorArray[ c + 0 ] = pos[ o1 + 0 ];
+ scope.colorArray[ c + 1 ] = pos[ o1 + 1 ];
+ scope.colorArray[ c + 2 ] = pos[ o1 + 2 ];
+
+ scope.colorArray[ c + 3 ] = pos[ o2 + 0 ];
+ scope.colorArray[ c + 4 ] = pos[ o2 + 1 ];
+ scope.colorArray[ c + 5 ] = pos[ o2 + 2 ];
+
+ scope.colorArray[ c + 6 ] = pos[ o3 + 0 ];
+ scope.colorArray[ c + 7 ] = pos[ o3 + 1 ];
+ scope.colorArray[ c + 8 ] = pos[ o3 + 2 ];
+
+ }
+
+ scope.count += 3;
+
+ if ( scope.count >= scope.maxCount - 3 ) {
+
+ scope.hasPositions = true;
+ scope.hasNormals = true;
+
+ if ( scope.enableUvs ) {
+
+ scope.hasUvs = true;
+
+ }
+
+ if ( scope.enableColors ) {
+
+ scope.hasColors = true;
+
+ }
+
+ renderCallback( scope );
+
+ }
+
+ }
+
+ this.begin = function () {
+
+ this.count = 0;
+
+ this.hasPositions = false;
+ this.hasNormals = false;
+ this.hasUvs = false;
+ this.hasColors = false;
+
+ };
+
+ this.end = function ( renderCallback ) {
+
+ if ( this.count === 0 ) return;
+
+ for ( var i = this.count * 3; i < this.positionArray.length; i ++ ) {
+
+ this.positionArray[ i ] = 0.0;
+
+ }
+
+ this.hasPositions = true;
+ this.hasNormals = true;
+
+ if ( this.enableUvs && this.material.map ) {
+
+ this.hasUvs = true;
+
+ }
+
+ if ( this.enableColors && this.material.vertexColors !== THREE.NoColors ) {
+
+ this.hasColors = true;
+
+ }
+
+ renderCallback( this );
+
+ };
+
+ /////////////////////////////////////
+ // Metaballs
+ /////////////////////////////////////
+
+ // Adds a reciprocal ball (nice and blobby) that, to be fast, fades to zero after
+ // a fixed distance, determined by strength and subtract.
+
+ this.addBall = function ( ballx, bally, ballz, strength, subtract ) {
+
+ var sign = Math.sign( strength );
+ strength = Math.abs( strength );
+
+ // Let's solve the equation to find the radius:
+ // 1.0 / (0.000001 + radius^2) * strength - subtract = 0
+ // strength / (radius^2) = subtract
+ // strength = subtract * radius^2
+ // radius^2 = strength / subtract
+ // radius = sqrt(strength / subtract)
+
+ var radius = this.size * Math.sqrt( strength / subtract ),
+ zs = ballz * this.size,
+ ys = bally * this.size,
+ xs = ballx * this.size;
+
+ var min_z = Math.floor( zs - radius ); if ( min_z < 1 ) min_z = 1;
+ var max_z = Math.floor( zs + radius ); if ( max_z > this.size - 1 ) max_z = this.size - 1;
+ var min_y = Math.floor( ys - radius ); if ( min_y < 1 ) min_y = 1;
+ var max_y = Math.floor( ys + radius ); if ( max_y > this.size - 1 ) max_y = this.size - 1;
+ var min_x = Math.floor( xs - radius ); if ( min_x < 1 ) min_x = 1;
+ var max_x = Math.floor( xs + radius ); if ( max_x > this.size - 1 ) max_x = this.size - 1;
+
+
+ // Don't polygonize in the outer layer because normals aren't
+ // well-defined there.
+
+ var x, y, z, y_offset, z_offset, fx, fy, fz, fz2, fy2, val;
+
+ for ( z = min_z; z < max_z; z ++ ) {
+
+ z_offset = this.size2 * z;
+ fz = z / this.size - ballz;
+ fz2 = fz * fz;
+
+ for ( y = min_y; y < max_y; y ++ ) {
+
+ y_offset = z_offset + this.size * y;
+ fy = y / this.size - bally;
+ fy2 = fy * fy;
+
+ for ( x = min_x; x < max_x; x ++ ) {
+
+ fx = x / this.size - ballx;
+ val = strength / ( 0.000001 + fx * fx + fy2 + fz2 ) - subtract;
+ if ( val > 0.0 ) this.field[ y_offset + x ] += val * sign;
+
+ }
+
+ }
+
+ }
+
+ };
+
+ this.addPlaneX = function ( strength, subtract ) {
+
+ var x, y, z, xx, val, xdiv, cxy,
+
+ // cache attribute lookups
+ size = this.size,
+ yd = this.yd,
+ zd = this.zd,
+ field = this.field,
+
+ dist = size * Math.sqrt( strength / subtract );
+
+ if ( dist > size ) dist = size;
+
+ for ( x = 0; x < dist; x ++ ) {
+
+ xdiv = x / size;
+ xx = xdiv * xdiv;
+ val = strength / ( 0.0001 + xx ) - subtract;
+
+ if ( val > 0.0 ) {
+
+ for ( y = 0; y < size; y ++ ) {
+
+ cxy = x + y * yd;
+
+ for ( z = 0; z < size; z ++ ) {
+
+ field[ zd * z + cxy ] += val;
+
+ }
+
+ }
+
+ }
+
+ }
+
+ };
+
+ this.addPlaneY = function ( strength, subtract ) {
+
+ var x, y, z, yy, val, ydiv, cy, cxy,
+
+ // cache attribute lookups
+ size = this.size,
+ yd = this.yd,
+ zd = this.zd,
+ field = this.field,
+
+ dist = size * Math.sqrt( strength / subtract );
+
+ if ( dist > size ) dist = size;
+
+ for ( y = 0; y < dist; y ++ ) {
+
+ ydiv = y / size;
+ yy = ydiv * ydiv;
+ val = strength / ( 0.0001 + yy ) - subtract;
+
+ if ( val > 0.0 ) {
+
+ cy = y * yd;
+
+ for ( x = 0; x < size; x ++ ) {
+
+ cxy = cy + x;
+
+ for ( z = 0; z < size; z ++ )
+ field[ zd * z + cxy ] += val;
+
+ }
+
+ }
+
+ }
+
+ };
+
+ this.addPlaneZ = function ( strength, subtract ) {
+
+ var x, y, z, zz, val, zdiv, cz, cyz,
+
+ // cache attribute lookups
+ size = this.size,
+ yd = this.yd,
+ zd = this.zd,
+ field = this.field,
+
+ dist = size * Math.sqrt( strength / subtract );
+
+ if ( dist > size ) dist = size;
+
+ for ( z = 0; z < dist; z ++ ) {
+
+ zdiv = z / size;
+ zz = zdiv * zdiv;
+ val = strength / ( 0.0001 + zz ) - subtract;
+ if ( val > 0.0 ) {
+
+ cz = zd * z;
+
+ for ( y = 0; y < size; y ++ ) {
+
+ cyz = cz + y * yd;
+
+ for ( x = 0; x < size; x ++ )
+ field[ cyz + x ] += val;
+
+ }
+
+ }
+
+ }
+
+ };
+
+ /////////////////////////////////////
+ // Updates
+ /////////////////////////////////////
+
+ this.reset = function () {
+
+ var i;
+
+ // wipe the normal cache
+
+ for ( i = 0; i < this.size3; i ++ ) {
+
+ this.normal_cache[ i * 3 ] = 0.0;
+ this.field[ i ] = 0.0;
+
+ }
+
+ };
+
+ this.render = function ( renderCallback ) {
+
+ this.begin();
+
+ // Triangulate. Yeah, this is slow.
+
+ var smin2 = this.size - 2;
+
+ for ( var z = 1; z < smin2; z ++ ) {
+
+ var z_offset = this.size2 * z;
+ var fz = ( z - this.halfsize ) / this.halfsize; //+ 1
+
+ for ( var y = 1; y < smin2; y ++ ) {
+
+ var y_offset = z_offset + this.size * y;
+ var fy = ( y - this.halfsize ) / this.halfsize; //+ 1
+
+ for ( var x = 1; x < smin2; x ++ ) {
+
+ var fx = ( x - this.halfsize ) / this.halfsize; //+ 1
+ var q = y_offset + x;
+
+ polygonize( fx, fy, fz, q, this.isolation, renderCallback );
+
+ }
+
+ }
+
+ }
+
+ this.end( renderCallback );
+
+ };
+
+ this.generateGeometry = function () {
+
+ console.warn( 'THREE.MarchingCubes: generateGeometry() now returns THREE.BufferGeometry' );
+ return this.generateBufferGeometry();
+
+ };
+
+ function concatenate( a, b, length ) {
+
+ var result = new Float32Array( a.length + length );
+ result.set( a, 0 );
+ result.set( b.slice( 0, length ), a.length );
+ return result;
+
+ }
+
+ this.generateBufferGeometry = function () {
+
+ var geo = new THREE.BufferGeometry();
+ var posArray = new Float32Array();
+ var normArray = new Float32Array();
+ var colorArray = new Float32Array();
+ var uvArray = new Float32Array();
+ var scope = this;
+
+ var geo_callback = function ( object ) {
+
+ if ( scope.hasPositions ) posArray = concatenate( posArray, object.positionArray, object.count * 3 );
+ if ( scope.hasNormals ) normArray = concatenate( normArray, object.normalArray, object.count * 3 );
+ if ( scope.hasColors ) colorArray = concatenate( colorArray, object.colorArray, object.count * 3 );
+ if ( scope.hasUvs ) uvArray = concatenate( uvArray, object.uvArray, object.count * 2 );
+
+ object.count = 0;
+
+ };
+
+ this.render( geo_callback );
+
+ if ( this.hasPositions ) geo.addAttribute( 'position', new THREE.BufferAttribute( posArray, 3 ) );
+ if ( this.hasNormals ) geo.addAttribute( 'normal', new THREE.BufferAttribute( normArray, 3 ) );
+ if ( this.hasColors ) geo.addAttribute( 'color', new THREE.BufferAttribute( colorArray, 3 ) );
+ if ( this.hasUvs ) geo.addAttribute( 'uv', new THREE.BufferAttribute( uvArray, 2 ) );
+
+ return geo;
+
+ };
+
+ this.init( resolution );
+
+};
+
+THREE.MarchingCubes.prototype = Object.create( THREE.ImmediateRenderObject.prototype );
+THREE.MarchingCubes.prototype.constructor = THREE.MarchingCubes;
+
+
+/////////////////////////////////////
+// Marching cubes lookup tables
+/////////////////////////////////////
+
+// These tables are straight from Paul Bourke's page:
+// http://local.wasp.uwa.edu.au/~pbourke/geometry/polygonise/
+// who in turn got them from Cory Gene Bloyd.
+
+THREE.edgeTable = new Int32Array( [
+ 0x0, 0x109, 0x203, 0x30a, 0x406, 0x50f, 0x605, 0x70c,
+ 0x80c, 0x905, 0xa0f, 0xb06, 0xc0a, 0xd03, 0xe09, 0xf00,
+ 0x190, 0x99, 0x393, 0x29a, 0x596, 0x49f, 0x795, 0x69c,
+ 0x99c, 0x895, 0xb9f, 0xa96, 0xd9a, 0xc93, 0xf99, 0xe90,
+ 0x230, 0x339, 0x33, 0x13a, 0x636, 0x73f, 0x435, 0x53c,
+ 0xa3c, 0xb35, 0x83f, 0x936, 0xe3a, 0xf33, 0xc39, 0xd30,
+ 0x3a0, 0x2a9, 0x1a3, 0xaa, 0x7a6, 0x6af, 0x5a5, 0x4ac,
+ 0xbac, 0xaa5, 0x9af, 0x8a6, 0xfaa, 0xea3, 0xda9, 0xca0,
+ 0x460, 0x569, 0x663, 0x76a, 0x66, 0x16f, 0x265, 0x36c,
+ 0xc6c, 0xd65, 0xe6f, 0xf66, 0x86a, 0x963, 0xa69, 0xb60,
+ 0x5f0, 0x4f9, 0x7f3, 0x6fa, 0x1f6, 0xff, 0x3f5, 0x2fc,
+ 0xdfc, 0xcf5, 0xfff, 0xef6, 0x9fa, 0x8f3, 0xbf9, 0xaf0,
+ 0x650, 0x759, 0x453, 0x55a, 0x256, 0x35f, 0x55, 0x15c,
+ 0xe5c, 0xf55, 0xc5f, 0xd56, 0xa5a, 0xb53, 0x859, 0x950,
+ 0x7c0, 0x6c9, 0x5c3, 0x4ca, 0x3c6, 0x2cf, 0x1c5, 0xcc,
+ 0xfcc, 0xec5, 0xdcf, 0xcc6, 0xbca, 0xac3, 0x9c9, 0x8c0,
+ 0x8c0, 0x9c9, 0xac3, 0xbca, 0xcc6, 0xdcf, 0xec5, 0xfcc,
+ 0xcc, 0x1c5, 0x2cf, 0x3c6, 0x4ca, 0x5c3, 0x6c9, 0x7c0,
+ 0x950, 0x859, 0xb53, 0xa5a, 0xd56, 0xc5f, 0xf55, 0xe5c,
+ 0x15c, 0x55, 0x35f, 0x256, 0x55a, 0x453, 0x759, 0x650,
+ 0xaf0, 0xbf9, 0x8f3, 0x9fa, 0xef6, 0xfff, 0xcf5, 0xdfc,
+ 0x2fc, 0x3f5, 0xff, 0x1f6, 0x6fa, 0x7f3, 0x4f9, 0x5f0,
+ 0xb60, 0xa69, 0x963, 0x86a, 0xf66, 0xe6f, 0xd65, 0xc6c,
+ 0x36c, 0x265, 0x16f, 0x66, 0x76a, 0x663, 0x569, 0x460,
+ 0xca0, 0xda9, 0xea3, 0xfaa, 0x8a6, 0x9af, 0xaa5, 0xbac,
+ 0x4ac, 0x5a5, 0x6af, 0x7a6, 0xaa, 0x1a3, 0x2a9, 0x3a0,
+ 0xd30, 0xc39, 0xf33, 0xe3a, 0x936, 0x83f, 0xb35, 0xa3c,
+ 0x53c, 0x435, 0x73f, 0x636, 0x13a, 0x33, 0x339, 0x230,
+ 0xe90, 0xf99, 0xc93, 0xd9a, 0xa96, 0xb9f, 0x895, 0x99c,
+ 0x69c, 0x795, 0x49f, 0x596, 0x29a, 0x393, 0x99, 0x190,
+ 0xf00, 0xe09, 0xd03, 0xc0a, 0xb06, 0xa0f, 0x905, 0x80c,
+ 0x70c, 0x605, 0x50f, 0x406, 0x30a, 0x203, 0x109, 0x0 ] );
+
+THREE.triTable = new Int32Array( [
+ - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 0, 8, 3, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 0, 1, 9, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 1, 8, 3, 9, 8, 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 1, 2, 10, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 0, 8, 3, 1, 2, 10, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 9, 2, 10, 0, 2, 9, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 2, 8, 3, 2, 10, 8, 10, 9, 8, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 3, 11, 2, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 0, 11, 2, 8, 11, 0, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 1, 9, 0, 2, 3, 11, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 1, 11, 2, 1, 9, 11, 9, 8, 11, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 3, 10, 1, 11, 10, 3, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 0, 10, 1, 0, 8, 10, 8, 11, 10, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 3, 9, 0, 3, 11, 9, 11, 10, 9, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 9, 8, 10, 10, 8, 11, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 4, 7, 8, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 4, 3, 0, 7, 3, 4, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 0, 1, 9, 8, 4, 7, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 4, 1, 9, 4, 7, 1, 7, 3, 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 1, 2, 10, 8, 4, 7, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 3, 4, 7, 3, 0, 4, 1, 2, 10, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 9, 2, 10, 9, 0, 2, 8, 4, 7, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 2, 10, 9, 2, 9, 7, 2, 7, 3, 7, 9, 4, - 1, - 1, - 1, - 1,
+ 8, 4, 7, 3, 11, 2, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 11, 4, 7, 11, 2, 4, 2, 0, 4, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 9, 0, 1, 8, 4, 7, 2, 3, 11, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 4, 7, 11, 9, 4, 11, 9, 11, 2, 9, 2, 1, - 1, - 1, - 1, - 1,
+ 3, 10, 1, 3, 11, 10, 7, 8, 4, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 1, 11, 10, 1, 4, 11, 1, 0, 4, 7, 11, 4, - 1, - 1, - 1, - 1,
+ 4, 7, 8, 9, 0, 11, 9, 11, 10, 11, 0, 3, - 1, - 1, - 1, - 1,
+ 4, 7, 11, 4, 11, 9, 9, 11, 10, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 9, 5, 4, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 9, 5, 4, 0, 8, 3, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 0, 5, 4, 1, 5, 0, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 8, 5, 4, 8, 3, 5, 3, 1, 5, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 1, 2, 10, 9, 5, 4, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 3, 0, 8, 1, 2, 10, 4, 9, 5, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 5, 2, 10, 5, 4, 2, 4, 0, 2, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 2, 10, 5, 3, 2, 5, 3, 5, 4, 3, 4, 8, - 1, - 1, - 1, - 1,
+ 9, 5, 4, 2, 3, 11, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 0, 11, 2, 0, 8, 11, 4, 9, 5, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 0, 5, 4, 0, 1, 5, 2, 3, 11, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 2, 1, 5, 2, 5, 8, 2, 8, 11, 4, 8, 5, - 1, - 1, - 1, - 1,
+ 10, 3, 11, 10, 1, 3, 9, 5, 4, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 4, 9, 5, 0, 8, 1, 8, 10, 1, 8, 11, 10, - 1, - 1, - 1, - 1,
+ 5, 4, 0, 5, 0, 11, 5, 11, 10, 11, 0, 3, - 1, - 1, - 1, - 1,
+ 5, 4, 8, 5, 8, 10, 10, 8, 11, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 9, 7, 8, 5, 7, 9, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 9, 3, 0, 9, 5, 3, 5, 7, 3, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 0, 7, 8, 0, 1, 7, 1, 5, 7, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 1, 5, 3, 3, 5, 7, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 9, 7, 8, 9, 5, 7, 10, 1, 2, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 10, 1, 2, 9, 5, 0, 5, 3, 0, 5, 7, 3, - 1, - 1, - 1, - 1,
+ 8, 0, 2, 8, 2, 5, 8, 5, 7, 10, 5, 2, - 1, - 1, - 1, - 1,
+ 2, 10, 5, 2, 5, 3, 3, 5, 7, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 7, 9, 5, 7, 8, 9, 3, 11, 2, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 9, 5, 7, 9, 7, 2, 9, 2, 0, 2, 7, 11, - 1, - 1, - 1, - 1,
+ 2, 3, 11, 0, 1, 8, 1, 7, 8, 1, 5, 7, - 1, - 1, - 1, - 1,
+ 11, 2, 1, 11, 1, 7, 7, 1, 5, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 9, 5, 8, 8, 5, 7, 10, 1, 3, 10, 3, 11, - 1, - 1, - 1, - 1,
+ 5, 7, 0, 5, 0, 9, 7, 11, 0, 1, 0, 10, 11, 10, 0, - 1,
+ 11, 10, 0, 11, 0, 3, 10, 5, 0, 8, 0, 7, 5, 7, 0, - 1,
+ 11, 10, 5, 7, 11, 5, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 10, 6, 5, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 0, 8, 3, 5, 10, 6, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 9, 0, 1, 5, 10, 6, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 1, 8, 3, 1, 9, 8, 5, 10, 6, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 1, 6, 5, 2, 6, 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 1, 6, 5, 1, 2, 6, 3, 0, 8, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 9, 6, 5, 9, 0, 6, 0, 2, 6, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 5, 9, 8, 5, 8, 2, 5, 2, 6, 3, 2, 8, - 1, - 1, - 1, - 1,
+ 2, 3, 11, 10, 6, 5, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 11, 0, 8, 11, 2, 0, 10, 6, 5, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 0, 1, 9, 2, 3, 11, 5, 10, 6, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 5, 10, 6, 1, 9, 2, 9, 11, 2, 9, 8, 11, - 1, - 1, - 1, - 1,
+ 6, 3, 11, 6, 5, 3, 5, 1, 3, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 0, 8, 11, 0, 11, 5, 0, 5, 1, 5, 11, 6, - 1, - 1, - 1, - 1,
+ 3, 11, 6, 0, 3, 6, 0, 6, 5, 0, 5, 9, - 1, - 1, - 1, - 1,
+ 6, 5, 9, 6, 9, 11, 11, 9, 8, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 5, 10, 6, 4, 7, 8, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 4, 3, 0, 4, 7, 3, 6, 5, 10, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 1, 9, 0, 5, 10, 6, 8, 4, 7, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 10, 6, 5, 1, 9, 7, 1, 7, 3, 7, 9, 4, - 1, - 1, - 1, - 1,
+ 6, 1, 2, 6, 5, 1, 4, 7, 8, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 1, 2, 5, 5, 2, 6, 3, 0, 4, 3, 4, 7, - 1, - 1, - 1, - 1,
+ 8, 4, 7, 9, 0, 5, 0, 6, 5, 0, 2, 6, - 1, - 1, - 1, - 1,
+ 7, 3, 9, 7, 9, 4, 3, 2, 9, 5, 9, 6, 2, 6, 9, - 1,
+ 3, 11, 2, 7, 8, 4, 10, 6, 5, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 5, 10, 6, 4, 7, 2, 4, 2, 0, 2, 7, 11, - 1, - 1, - 1, - 1,
+ 0, 1, 9, 4, 7, 8, 2, 3, 11, 5, 10, 6, - 1, - 1, - 1, - 1,
+ 9, 2, 1, 9, 11, 2, 9, 4, 11, 7, 11, 4, 5, 10, 6, - 1,
+ 8, 4, 7, 3, 11, 5, 3, 5, 1, 5, 11, 6, - 1, - 1, - 1, - 1,
+ 5, 1, 11, 5, 11, 6, 1, 0, 11, 7, 11, 4, 0, 4, 11, - 1,
+ 0, 5, 9, 0, 6, 5, 0, 3, 6, 11, 6, 3, 8, 4, 7, - 1,
+ 6, 5, 9, 6, 9, 11, 4, 7, 9, 7, 11, 9, - 1, - 1, - 1, - 1,
+ 10, 4, 9, 6, 4, 10, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 4, 10, 6, 4, 9, 10, 0, 8, 3, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 10, 0, 1, 10, 6, 0, 6, 4, 0, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 8, 3, 1, 8, 1, 6, 8, 6, 4, 6, 1, 10, - 1, - 1, - 1, - 1,
+ 1, 4, 9, 1, 2, 4, 2, 6, 4, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 3, 0, 8, 1, 2, 9, 2, 4, 9, 2, 6, 4, - 1, - 1, - 1, - 1,
+ 0, 2, 4, 4, 2, 6, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 8, 3, 2, 8, 2, 4, 4, 2, 6, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 10, 4, 9, 10, 6, 4, 11, 2, 3, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 0, 8, 2, 2, 8, 11, 4, 9, 10, 4, 10, 6, - 1, - 1, - 1, - 1,
+ 3, 11, 2, 0, 1, 6, 0, 6, 4, 6, 1, 10, - 1, - 1, - 1, - 1,
+ 6, 4, 1, 6, 1, 10, 4, 8, 1, 2, 1, 11, 8, 11, 1, - 1,
+ 9, 6, 4, 9, 3, 6, 9, 1, 3, 11, 6, 3, - 1, - 1, - 1, - 1,
+ 8, 11, 1, 8, 1, 0, 11, 6, 1, 9, 1, 4, 6, 4, 1, - 1,
+ 3, 11, 6, 3, 6, 0, 0, 6, 4, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 6, 4, 8, 11, 6, 8, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 7, 10, 6, 7, 8, 10, 8, 9, 10, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 0, 7, 3, 0, 10, 7, 0, 9, 10, 6, 7, 10, - 1, - 1, - 1, - 1,
+ 10, 6, 7, 1, 10, 7, 1, 7, 8, 1, 8, 0, - 1, - 1, - 1, - 1,
+ 10, 6, 7, 10, 7, 1, 1, 7, 3, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 1, 2, 6, 1, 6, 8, 1, 8, 9, 8, 6, 7, - 1, - 1, - 1, - 1,
+ 2, 6, 9, 2, 9, 1, 6, 7, 9, 0, 9, 3, 7, 3, 9, - 1,
+ 7, 8, 0, 7, 0, 6, 6, 0, 2, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 7, 3, 2, 6, 7, 2, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 2, 3, 11, 10, 6, 8, 10, 8, 9, 8, 6, 7, - 1, - 1, - 1, - 1,
+ 2, 0, 7, 2, 7, 11, 0, 9, 7, 6, 7, 10, 9, 10, 7, - 1,
+ 1, 8, 0, 1, 7, 8, 1, 10, 7, 6, 7, 10, 2, 3, 11, - 1,
+ 11, 2, 1, 11, 1, 7, 10, 6, 1, 6, 7, 1, - 1, - 1, - 1, - 1,
+ 8, 9, 6, 8, 6, 7, 9, 1, 6, 11, 6, 3, 1, 3, 6, - 1,
+ 0, 9, 1, 11, 6, 7, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 7, 8, 0, 7, 0, 6, 3, 11, 0, 11, 6, 0, - 1, - 1, - 1, - 1,
+ 7, 11, 6, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 7, 6, 11, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 3, 0, 8, 11, 7, 6, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 0, 1, 9, 11, 7, 6, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 8, 1, 9, 8, 3, 1, 11, 7, 6, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 10, 1, 2, 6, 11, 7, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 1, 2, 10, 3, 0, 8, 6, 11, 7, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 2, 9, 0, 2, 10, 9, 6, 11, 7, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 6, 11, 7, 2, 10, 3, 10, 8, 3, 10, 9, 8, - 1, - 1, - 1, - 1,
+ 7, 2, 3, 6, 2, 7, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 7, 0, 8, 7, 6, 0, 6, 2, 0, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 2, 7, 6, 2, 3, 7, 0, 1, 9, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 1, 6, 2, 1, 8, 6, 1, 9, 8, 8, 7, 6, - 1, - 1, - 1, - 1,
+ 10, 7, 6, 10, 1, 7, 1, 3, 7, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 10, 7, 6, 1, 7, 10, 1, 8, 7, 1, 0, 8, - 1, - 1, - 1, - 1,
+ 0, 3, 7, 0, 7, 10, 0, 10, 9, 6, 10, 7, - 1, - 1, - 1, - 1,
+ 7, 6, 10, 7, 10, 8, 8, 10, 9, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 6, 8, 4, 11, 8, 6, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 3, 6, 11, 3, 0, 6, 0, 4, 6, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 8, 6, 11, 8, 4, 6, 9, 0, 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 9, 4, 6, 9, 6, 3, 9, 3, 1, 11, 3, 6, - 1, - 1, - 1, - 1,
+ 6, 8, 4, 6, 11, 8, 2, 10, 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 1, 2, 10, 3, 0, 11, 0, 6, 11, 0, 4, 6, - 1, - 1, - 1, - 1,
+ 4, 11, 8, 4, 6, 11, 0, 2, 9, 2, 10, 9, - 1, - 1, - 1, - 1,
+ 10, 9, 3, 10, 3, 2, 9, 4, 3, 11, 3, 6, 4, 6, 3, - 1,
+ 8, 2, 3, 8, 4, 2, 4, 6, 2, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 0, 4, 2, 4, 6, 2, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 1, 9, 0, 2, 3, 4, 2, 4, 6, 4, 3, 8, - 1, - 1, - 1, - 1,
+ 1, 9, 4, 1, 4, 2, 2, 4, 6, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 8, 1, 3, 8, 6, 1, 8, 4, 6, 6, 10, 1, - 1, - 1, - 1, - 1,
+ 10, 1, 0, 10, 0, 6, 6, 0, 4, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 4, 6, 3, 4, 3, 8, 6, 10, 3, 0, 3, 9, 10, 9, 3, - 1,
+ 10, 9, 4, 6, 10, 4, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 4, 9, 5, 7, 6, 11, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 0, 8, 3, 4, 9, 5, 11, 7, 6, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 5, 0, 1, 5, 4, 0, 7, 6, 11, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 11, 7, 6, 8, 3, 4, 3, 5, 4, 3, 1, 5, - 1, - 1, - 1, - 1,
+ 9, 5, 4, 10, 1, 2, 7, 6, 11, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 6, 11, 7, 1, 2, 10, 0, 8, 3, 4, 9, 5, - 1, - 1, - 1, - 1,
+ 7, 6, 11, 5, 4, 10, 4, 2, 10, 4, 0, 2, - 1, - 1, - 1, - 1,
+ 3, 4, 8, 3, 5, 4, 3, 2, 5, 10, 5, 2, 11, 7, 6, - 1,
+ 7, 2, 3, 7, 6, 2, 5, 4, 9, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 9, 5, 4, 0, 8, 6, 0, 6, 2, 6, 8, 7, - 1, - 1, - 1, - 1,
+ 3, 6, 2, 3, 7, 6, 1, 5, 0, 5, 4, 0, - 1, - 1, - 1, - 1,
+ 6, 2, 8, 6, 8, 7, 2, 1, 8, 4, 8, 5, 1, 5, 8, - 1,
+ 9, 5, 4, 10, 1, 6, 1, 7, 6, 1, 3, 7, - 1, - 1, - 1, - 1,
+ 1, 6, 10, 1, 7, 6, 1, 0, 7, 8, 7, 0, 9, 5, 4, - 1,
+ 4, 0, 10, 4, 10, 5, 0, 3, 10, 6, 10, 7, 3, 7, 10, - 1,
+ 7, 6, 10, 7, 10, 8, 5, 4, 10, 4, 8, 10, - 1, - 1, - 1, - 1,
+ 6, 9, 5, 6, 11, 9, 11, 8, 9, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 3, 6, 11, 0, 6, 3, 0, 5, 6, 0, 9, 5, - 1, - 1, - 1, - 1,
+ 0, 11, 8, 0, 5, 11, 0, 1, 5, 5, 6, 11, - 1, - 1, - 1, - 1,
+ 6, 11, 3, 6, 3, 5, 5, 3, 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 1, 2, 10, 9, 5, 11, 9, 11, 8, 11, 5, 6, - 1, - 1, - 1, - 1,
+ 0, 11, 3, 0, 6, 11, 0, 9, 6, 5, 6, 9, 1, 2, 10, - 1,
+ 11, 8, 5, 11, 5, 6, 8, 0, 5, 10, 5, 2, 0, 2, 5, - 1,
+ 6, 11, 3, 6, 3, 5, 2, 10, 3, 10, 5, 3, - 1, - 1, - 1, - 1,
+ 5, 8, 9, 5, 2, 8, 5, 6, 2, 3, 8, 2, - 1, - 1, - 1, - 1,
+ 9, 5, 6, 9, 6, 0, 0, 6, 2, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 1, 5, 8, 1, 8, 0, 5, 6, 8, 3, 8, 2, 6, 2, 8, - 1,
+ 1, 5, 6, 2, 1, 6, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 1, 3, 6, 1, 6, 10, 3, 8, 6, 5, 6, 9, 8, 9, 6, - 1,
+ 10, 1, 0, 10, 0, 6, 9, 5, 0, 5, 6, 0, - 1, - 1, - 1, - 1,
+ 0, 3, 8, 5, 6, 10, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 10, 5, 6, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 11, 5, 10, 7, 5, 11, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 11, 5, 10, 11, 7, 5, 8, 3, 0, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 5, 11, 7, 5, 10, 11, 1, 9, 0, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 10, 7, 5, 10, 11, 7, 9, 8, 1, 8, 3, 1, - 1, - 1, - 1, - 1,
+ 11, 1, 2, 11, 7, 1, 7, 5, 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 0, 8, 3, 1, 2, 7, 1, 7, 5, 7, 2, 11, - 1, - 1, - 1, - 1,
+ 9, 7, 5, 9, 2, 7, 9, 0, 2, 2, 11, 7, - 1, - 1, - 1, - 1,
+ 7, 5, 2, 7, 2, 11, 5, 9, 2, 3, 2, 8, 9, 8, 2, - 1,
+ 2, 5, 10, 2, 3, 5, 3, 7, 5, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 8, 2, 0, 8, 5, 2, 8, 7, 5, 10, 2, 5, - 1, - 1, - 1, - 1,
+ 9, 0, 1, 5, 10, 3, 5, 3, 7, 3, 10, 2, - 1, - 1, - 1, - 1,
+ 9, 8, 2, 9, 2, 1, 8, 7, 2, 10, 2, 5, 7, 5, 2, - 1,
+ 1, 3, 5, 3, 7, 5, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 0, 8, 7, 0, 7, 1, 1, 7, 5, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 9, 0, 3, 9, 3, 5, 5, 3, 7, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 9, 8, 7, 5, 9, 7, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 5, 8, 4, 5, 10, 8, 10, 11, 8, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 5, 0, 4, 5, 11, 0, 5, 10, 11, 11, 3, 0, - 1, - 1, - 1, - 1,
+ 0, 1, 9, 8, 4, 10, 8, 10, 11, 10, 4, 5, - 1, - 1, - 1, - 1,
+ 10, 11, 4, 10, 4, 5, 11, 3, 4, 9, 4, 1, 3, 1, 4, - 1,
+ 2, 5, 1, 2, 8, 5, 2, 11, 8, 4, 5, 8, - 1, - 1, - 1, - 1,
+ 0, 4, 11, 0, 11, 3, 4, 5, 11, 2, 11, 1, 5, 1, 11, - 1,
+ 0, 2, 5, 0, 5, 9, 2, 11, 5, 4, 5, 8, 11, 8, 5, - 1,
+ 9, 4, 5, 2, 11, 3, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 2, 5, 10, 3, 5, 2, 3, 4, 5, 3, 8, 4, - 1, - 1, - 1, - 1,
+ 5, 10, 2, 5, 2, 4, 4, 2, 0, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 3, 10, 2, 3, 5, 10, 3, 8, 5, 4, 5, 8, 0, 1, 9, - 1,
+ 5, 10, 2, 5, 2, 4, 1, 9, 2, 9, 4, 2, - 1, - 1, - 1, - 1,
+ 8, 4, 5, 8, 5, 3, 3, 5, 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 0, 4, 5, 1, 0, 5, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 8, 4, 5, 8, 5, 3, 9, 0, 5, 0, 3, 5, - 1, - 1, - 1, - 1,
+ 9, 4, 5, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 4, 11, 7, 4, 9, 11, 9, 10, 11, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 0, 8, 3, 4, 9, 7, 9, 11, 7, 9, 10, 11, - 1, - 1, - 1, - 1,
+ 1, 10, 11, 1, 11, 4, 1, 4, 0, 7, 4, 11, - 1, - 1, - 1, - 1,
+ 3, 1, 4, 3, 4, 8, 1, 10, 4, 7, 4, 11, 10, 11, 4, - 1,
+ 4, 11, 7, 9, 11, 4, 9, 2, 11, 9, 1, 2, - 1, - 1, - 1, - 1,
+ 9, 7, 4, 9, 11, 7, 9, 1, 11, 2, 11, 1, 0, 8, 3, - 1,
+ 11, 7, 4, 11, 4, 2, 2, 4, 0, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 11, 7, 4, 11, 4, 2, 8, 3, 4, 3, 2, 4, - 1, - 1, - 1, - 1,
+ 2, 9, 10, 2, 7, 9, 2, 3, 7, 7, 4, 9, - 1, - 1, - 1, - 1,
+ 9, 10, 7, 9, 7, 4, 10, 2, 7, 8, 7, 0, 2, 0, 7, - 1,
+ 3, 7, 10, 3, 10, 2, 7, 4, 10, 1, 10, 0, 4, 0, 10, - 1,
+ 1, 10, 2, 8, 7, 4, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 4, 9, 1, 4, 1, 7, 7, 1, 3, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 4, 9, 1, 4, 1, 7, 0, 8, 1, 8, 7, 1, - 1, - 1, - 1, - 1,
+ 4, 0, 3, 7, 4, 3, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 4, 8, 7, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 9, 10, 8, 10, 11, 8, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 3, 0, 9, 3, 9, 11, 11, 9, 10, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 0, 1, 10, 0, 10, 8, 8, 10, 11, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 3, 1, 10, 11, 3, 10, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 1, 2, 11, 1, 11, 9, 9, 11, 8, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 3, 0, 9, 3, 9, 11, 1, 2, 9, 2, 11, 9, - 1, - 1, - 1, - 1,
+ 0, 2, 11, 8, 0, 11, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 3, 2, 11, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 2, 3, 8, 2, 8, 10, 10, 8, 9, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 9, 10, 2, 0, 9, 2, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 2, 3, 8, 2, 8, 10, 0, 1, 8, 1, 10, 8, - 1, - 1, - 1, - 1,
+ 1, 10, 2, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 1, 3, 8, 9, 1, 8, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 0, 9, 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ 0, 3, 8, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1,
+ - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1, - 1 ] );
diff --git a/three/jsutil/MorphAnimMesh.js b/three/jsutil/MorphAnimMesh.js
new file mode 100644
index 000000000..a0d206368
--- /dev/null
+++ b/three/jsutil/MorphAnimMesh.js
@@ -0,0 +1,69 @@
+/**
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.MorphAnimMesh = function ( geometry, material ) {
+
+ THREE.Mesh.call( this, geometry, material );
+
+ this.type = 'MorphAnimMesh';
+
+ this.mixer = new THREE.AnimationMixer( this );
+ this.activeAction = null;
+};
+
+THREE.MorphAnimMesh.prototype = Object.create( THREE.Mesh.prototype );
+THREE.MorphAnimMesh.prototype.constructor = THREE.MorphAnimMesh;
+
+THREE.MorphAnimMesh.prototype.setDirectionForward = function () {
+
+ this.mixer.timeScale = 1.0;
+
+};
+
+THREE.MorphAnimMesh.prototype.setDirectionBackward = function () {
+
+ this.mixer.timeScale = -1.0;
+
+};
+
+THREE.MorphAnimMesh.prototype.playAnimation = function ( label, fps ) {
+
+ if( this.activeAction ) {
+
+ this.activeAction.stop();
+ this.activeAction = null;
+
+ }
+
+ var clip = THREE.AnimationClip.findByName( this, label );
+
+ if ( clip ) {
+
+ var action = this.mixer.clipAction( clip );
+ action.timeScale = ( clip.tracks.length * fps ) / clip.duration;
+ this.activeAction = action.play();
+
+ } else {
+
+ throw new Error( 'THREE.MorphAnimMesh: animations[' + label + '] undefined in .playAnimation()' );
+
+ }
+
+};
+
+THREE.MorphAnimMesh.prototype.updateAnimation = function ( delta ) {
+
+ this.mixer.update( delta );
+
+};
+
+THREE.MorphAnimMesh.prototype.copy = function ( source ) {
+
+ THREE.Mesh.prototype.copy.call( this, source );
+
+ this.mixer = new THREE.AnimationMixer( this );
+
+ return this;
+
+};
diff --git a/three/jsutil/MorphBlendMesh.js b/three/jsutil/MorphBlendMesh.js
new file mode 100644
index 000000000..f37d69491
--- /dev/null
+++ b/three/jsutil/MorphBlendMesh.js
@@ -0,0 +1,319 @@
+/**
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.MorphBlendMesh = function ( geometry, material ) {
+
+ THREE.Mesh.call( this, geometry, material );
+
+ this.animationsMap = {};
+ this.animationsList = [];
+
+ // prepare default animation
+ // (all frames played together in 1 second)
+
+ var numFrames = Object.keys( this.morphTargetDictionary ).length;
+
+ var name = '__default';
+
+ var startFrame = 0;
+ var endFrame = numFrames - 1;
+
+ var fps = numFrames / 1;
+
+ this.createAnimation( name, startFrame, endFrame, fps );
+ this.setAnimationWeight( name, 1 );
+
+};
+
+THREE.MorphBlendMesh.prototype = Object.assign( Object.create( THREE.Mesh.prototype ), {
+
+ constructor: THREE.MorphBlendMesh,
+
+ createAnimation: function ( name, start, end, fps ) {
+
+ var animation = {
+
+ start: start,
+ end: end,
+
+ length: end - start + 1,
+
+ fps: fps,
+ duration: ( end - start ) / fps,
+
+ lastFrame: 0,
+ currentFrame: 0,
+
+ active: false,
+
+ time: 0,
+ direction: 1,
+ weight: 1,
+
+ directionBackwards: false,
+ mirroredLoop: false
+
+ };
+
+ this.animationsMap[ name ] = animation;
+ this.animationsList.push( animation );
+
+ },
+
+ autoCreateAnimations: function ( fps ) {
+
+ var pattern = /([a-z]+)_?(\d+)/i;
+
+ var firstAnimation, frameRanges = {};
+
+ var i = 0;
+
+ for ( var key in this.morphTargetDictionary ) {
+
+ var chunks = key.match( pattern );
+
+ if ( chunks && chunks.length > 1 ) {
+
+ var name = chunks[ 1 ];
+
+ if ( ! frameRanges[ name ] ) frameRanges[ name ] = { start: Infinity, end: - Infinity };
+
+ var range = frameRanges[ name ];
+
+ if ( i < range.start ) range.start = i;
+ if ( i > range.end ) range.end = i;
+
+ if ( ! firstAnimation ) firstAnimation = name;
+
+ }
+
+ i ++;
+
+ }
+
+ for ( var name in frameRanges ) {
+
+ var range = frameRanges[ name ];
+ this.createAnimation( name, range.start, range.end, fps );
+
+ }
+
+ this.firstAnimation = firstAnimation;
+
+ },
+
+ setAnimationDirectionForward: function ( name ) {
+
+ var animation = this.animationsMap[ name ];
+
+ if ( animation ) {
+
+ animation.direction = 1;
+ animation.directionBackwards = false;
+
+ }
+
+ },
+
+ setAnimationDirectionBackward: function ( name ) {
+
+ var animation = this.animationsMap[ name ];
+
+ if ( animation ) {
+
+ animation.direction = - 1;
+ animation.directionBackwards = true;
+
+ }
+
+ },
+
+ setAnimationFPS: function ( name, fps ) {
+
+ var animation = this.animationsMap[ name ];
+
+ if ( animation ) {
+
+ animation.fps = fps;
+ animation.duration = ( animation.end - animation.start ) / animation.fps;
+
+ }
+
+ },
+
+ setAnimationDuration: function ( name, duration ) {
+
+ var animation = this.animationsMap[ name ];
+
+ if ( animation ) {
+
+ animation.duration = duration;
+ animation.fps = ( animation.end - animation.start ) / animation.duration;
+
+ }
+
+ },
+
+ setAnimationWeight: function ( name, weight ) {
+
+ var animation = this.animationsMap[ name ];
+
+ if ( animation ) {
+
+ animation.weight = weight;
+
+ }
+
+ },
+
+ setAnimationTime: function ( name, time ) {
+
+ var animation = this.animationsMap[ name ];
+
+ if ( animation ) {
+
+ animation.time = time;
+
+ }
+
+ },
+
+ getAnimationTime: function ( name ) {
+
+ var time = 0;
+
+ var animation = this.animationsMap[ name ];
+
+ if ( animation ) {
+
+ time = animation.time;
+
+ }
+
+ return time;
+
+ },
+
+ getAnimationDuration: function ( name ) {
+
+ var duration = - 1;
+
+ var animation = this.animationsMap[ name ];
+
+ if ( animation ) {
+
+ duration = animation.duration;
+
+ }
+
+ return duration;
+
+ },
+
+ playAnimation: function ( name ) {
+
+ var animation = this.animationsMap[ name ];
+
+ if ( animation ) {
+
+ animation.time = 0;
+ animation.active = true;
+
+ } else {
+
+ console.warn( "THREE.MorphBlendMesh: animation[" + name + "] undefined in .playAnimation()" );
+
+ }
+
+ },
+
+ stopAnimation: function ( name ) {
+
+ var animation = this.animationsMap[ name ];
+
+ if ( animation ) {
+
+ animation.active = false;
+
+ }
+
+ },
+
+ update: function ( delta ) {
+
+ for ( var i = 0, il = this.animationsList.length; i < il; i ++ ) {
+
+ var animation = this.animationsList[ i ];
+
+ if ( ! animation.active ) continue;
+
+ var frameTime = animation.duration / animation.length;
+
+ animation.time += animation.direction * delta;
+
+ if ( animation.mirroredLoop ) {
+
+ if ( animation.time > animation.duration || animation.time < 0 ) {
+
+ animation.direction *= - 1;
+
+ if ( animation.time > animation.duration ) {
+
+ animation.time = animation.duration;
+ animation.directionBackwards = true;
+
+ }
+
+ if ( animation.time < 0 ) {
+
+ animation.time = 0;
+ animation.directionBackwards = false;
+
+ }
+
+ }
+
+ } else {
+
+ animation.time = animation.time % animation.duration;
+
+ if ( animation.time < 0 ) animation.time += animation.duration;
+
+ }
+
+ var keyframe = animation.start + THREE.Math.clamp( Math.floor( animation.time / frameTime ), 0, animation.length - 1 );
+ var weight = animation.weight;
+
+ if ( keyframe !== animation.currentFrame ) {
+
+ this.morphTargetInfluences[ animation.lastFrame ] = 0;
+ this.morphTargetInfluences[ animation.currentFrame ] = 1 * weight;
+
+ this.morphTargetInfluences[ keyframe ] = 0;
+
+ animation.lastFrame = animation.currentFrame;
+ animation.currentFrame = keyframe;
+
+ }
+
+ var mix = ( animation.time % frameTime ) / frameTime;
+
+ if ( animation.directionBackwards ) mix = 1 - mix;
+
+ if ( animation.currentFrame !== animation.lastFrame ) {
+
+ this.morphTargetInfluences[ animation.currentFrame ] = mix * weight;
+ this.morphTargetInfluences[ animation.lastFrame ] = ( 1 - mix ) * weight;
+
+ } else {
+
+ this.morphTargetInfluences[ animation.currentFrame ] = weight;
+
+ }
+
+ }
+
+ }
+
+} );
diff --git a/three/jsutil/Ocean.js b/three/jsutil/Ocean.js
new file mode 100644
index 000000000..276d81035
--- /dev/null
+++ b/three/jsutil/Ocean.js
@@ -0,0 +1,359 @@
+THREE.Ocean = function ( renderer, camera, scene, options ) {
+
+ // flag used to trigger parameter changes
+ this.changed = true;
+ this.initial = true;
+
+ // Assign required parameters as object properties
+ this.oceanCamera = new THREE.OrthographicCamera(); //camera.clone();
+ this.oceanCamera.position.z = 1;
+ this.renderer = renderer;
+ this.renderer.clearColor( 0xffffff );
+
+ this.scene = new THREE.Scene();
+
+ // Assign optional parameters as variables and object properties
+ function optionalParameter( value, defaultValue ) {
+
+ return value !== undefined ? value : defaultValue;
+
+ }
+ options = options || {};
+ this.clearColor = optionalParameter( options.CLEAR_COLOR, [ 1.0, 1.0, 1.0, 0.0 ] );
+ this.geometryOrigin = optionalParameter( options.GEOMETRY_ORIGIN, [ - 1000.0, - 1000.0 ] );
+ this.sunDirectionX = optionalParameter( options.SUN_DIRECTION[ 0 ], - 1.0 );
+ this.sunDirectionY = optionalParameter( options.SUN_DIRECTION[ 1 ], 1.0 );
+ this.sunDirectionZ = optionalParameter( options.SUN_DIRECTION[ 2 ], 1.0 );
+ this.oceanColor = optionalParameter( options.OCEAN_COLOR, new THREE.Vector3( 0.004, 0.016, 0.047 ) );
+ this.skyColor = optionalParameter( options.SKY_COLOR, new THREE.Vector3( 3.2, 9.6, 12.8 ) );
+ this.exposure = optionalParameter( options.EXPOSURE, 0.35 );
+ this.geometryResolution = optionalParameter( options.GEOMETRY_RESOLUTION, 32 );
+ this.geometrySize = optionalParameter( options.GEOMETRY_SIZE, 2000 );
+ this.resolution = optionalParameter( options.RESOLUTION, 64 );
+ this.floatSize = optionalParameter( options.SIZE_OF_FLOAT, 4 );
+ this.windX = optionalParameter( options.INITIAL_WIND[ 0 ], 10.0 );
+ this.windY = optionalParameter( options.INITIAL_WIND[ 1 ], 10.0 );
+ this.size = optionalParameter( options.INITIAL_SIZE, 250.0 );
+ this.choppiness = optionalParameter( options.INITIAL_CHOPPINESS, 1.5 );
+
+ //
+ this.matrixNeedsUpdate = false;
+
+ // Setup framebuffer pipeline
+ var renderTargetType = optionalParameter( options.USE_HALF_FLOAT, false ) ? THREE.HalfFloatType : THREE.FloatType;
+ var LinearClampParams = {
+ minFilter: THREE.LinearFilter,
+ magFilter: THREE.LinearFilter,
+ wrapS: THREE.ClampToEdgeWrapping,
+ wrapT: THREE.ClampToEdgeWrapping,
+ format: THREE.RGBAFormat,
+ stencilBuffer: false,
+ depthBuffer: false,
+ premultiplyAlpha: false,
+ type: renderTargetType
+ };
+ var NearestClampParams = {
+ minFilter: THREE.NearestFilter,
+ magFilter: THREE.NearestFilter,
+ wrapS: THREE.ClampToEdgeWrapping,
+ wrapT: THREE.ClampToEdgeWrapping,
+ format: THREE.RGBAFormat,
+ stencilBuffer: false,
+ depthBuffer: false,
+ premultiplyAlpha: false,
+ type: renderTargetType
+ };
+ var NearestRepeatParams = {
+ minFilter: THREE.NearestFilter,
+ magFilter: THREE.NearestFilter,
+ wrapS: THREE.RepeatWrapping,
+ wrapT: THREE.RepeatWrapping,
+ format: THREE.RGBAFormat,
+ stencilBuffer: false,
+ depthBuffer: false,
+ premultiplyAlpha: false,
+ type: renderTargetType
+ };
+ this.initialSpectrumFramebuffer = new THREE.WebGLRenderTarget( this.resolution, this.resolution, NearestRepeatParams );
+ this.spectrumFramebuffer = new THREE.WebGLRenderTarget( this.resolution, this.resolution, NearestClampParams );
+ this.pingPhaseFramebuffer = new THREE.WebGLRenderTarget( this.resolution, this.resolution, NearestClampParams );
+ this.pongPhaseFramebuffer = new THREE.WebGLRenderTarget( this.resolution, this.resolution, NearestClampParams );
+ this.pingTransformFramebuffer = new THREE.WebGLRenderTarget( this.resolution, this.resolution, NearestClampParams );
+ this.pongTransformFramebuffer = new THREE.WebGLRenderTarget( this.resolution, this.resolution, NearestClampParams );
+ this.displacementMapFramebuffer = new THREE.WebGLRenderTarget( this.resolution, this.resolution, LinearClampParams );
+ this.normalMapFramebuffer = new THREE.WebGLRenderTarget( this.resolution, this.resolution, LinearClampParams );
+
+ // Define shaders and constant uniforms
+ ////////////////////////////////////////
+
+ // 0 - The vertex shader used in all of the simulation steps
+ var fullscreeenVertexShader = THREE.ShaderLib[ "ocean_sim_vertex" ];
+
+ // 1 - Horizontal wave vertices used for FFT
+ var oceanHorizontalShader = THREE.ShaderLib[ "ocean_subtransform" ];
+ var oceanHorizontalUniforms = THREE.UniformsUtils.clone( oceanHorizontalShader.uniforms );
+ this.materialOceanHorizontal = new THREE.ShaderMaterial( {
+ uniforms: oceanHorizontalUniforms,
+ vertexShader: fullscreeenVertexShader.vertexShader,
+ fragmentShader: "#define HORIZONTAL \n" + oceanHorizontalShader.fragmentShader
+ } );
+ this.materialOceanHorizontal.uniforms.u_transformSize = { value: this.resolution };
+ this.materialOceanHorizontal.uniforms.u_subtransformSize = { value: null };
+ this.materialOceanHorizontal.uniforms.u_input = { value: null };
+ this.materialOceanHorizontal.depthTest = false;
+
+ // 2 - Vertical wave vertices used for FFT
+ var oceanVerticalShader = THREE.ShaderLib[ "ocean_subtransform" ];
+ var oceanVerticalUniforms = THREE.UniformsUtils.clone( oceanVerticalShader.uniforms );
+ this.materialOceanVertical = new THREE.ShaderMaterial( {
+ uniforms: oceanVerticalUniforms,
+ vertexShader: fullscreeenVertexShader.vertexShader,
+ fragmentShader: oceanVerticalShader.fragmentShader
+ } );
+ this.materialOceanVertical.uniforms.u_transformSize = { value: this.resolution };
+ this.materialOceanVertical.uniforms.u_subtransformSize = { value: null };
+ this.materialOceanVertical.uniforms.u_input = { value: null };
+ this.materialOceanVertical.depthTest = false;
+
+ // 3 - Initial spectrum used to generate height map
+ var initialSpectrumShader = THREE.ShaderLib[ "ocean_initial_spectrum" ];
+ var initialSpectrumUniforms = THREE.UniformsUtils.clone( initialSpectrumShader.uniforms );
+ this.materialInitialSpectrum = new THREE.ShaderMaterial( {
+ uniforms: initialSpectrumUniforms,
+ vertexShader: fullscreeenVertexShader.vertexShader,
+ fragmentShader: initialSpectrumShader.fragmentShader
+ } );
+ this.materialInitialSpectrum.uniforms.u_wind = { value: new THREE.Vector2() };
+ this.materialInitialSpectrum.uniforms.u_resolution = { value: this.resolution };
+ this.materialInitialSpectrum.depthTest = false;
+
+ // 4 - Phases used to animate heightmap
+ var phaseShader = THREE.ShaderLib[ "ocean_phase" ];
+ var phaseUniforms = THREE.UniformsUtils.clone( phaseShader.uniforms );
+ this.materialPhase = new THREE.ShaderMaterial( {
+ uniforms: phaseUniforms,
+ vertexShader: fullscreeenVertexShader.vertexShader,
+ fragmentShader: phaseShader.fragmentShader
+ } );
+ this.materialPhase.uniforms.u_resolution = { value: this.resolution };
+ this.materialPhase.depthTest = false;
+
+ // 5 - Shader used to update spectrum
+ var spectrumShader = THREE.ShaderLib[ "ocean_spectrum" ];
+ var spectrumUniforms = THREE.UniformsUtils.clone( spectrumShader.uniforms );
+ this.materialSpectrum = new THREE.ShaderMaterial( {
+ uniforms: spectrumUniforms,
+ vertexShader: fullscreeenVertexShader.vertexShader,
+ fragmentShader: spectrumShader.fragmentShader
+ } );
+ this.materialSpectrum.uniforms.u_initialSpectrum = { value: null };
+ this.materialSpectrum.uniforms.u_resolution = { value: this.resolution };
+ this.materialSpectrum.depthTest = false;
+
+ // 6 - Shader used to update spectrum normals
+ var normalShader = THREE.ShaderLib[ "ocean_normals" ];
+ var normalUniforms = THREE.UniformsUtils.clone( normalShader.uniforms );
+ this.materialNormal = new THREE.ShaderMaterial( {
+ uniforms: normalUniforms,
+ vertexShader: fullscreeenVertexShader.vertexShader,
+ fragmentShader: normalShader.fragmentShader
+ } );
+ this.materialNormal.uniforms.u_displacementMap = { value: null };
+ this.materialNormal.uniforms.u_resolution = { value: this.resolution };
+ this.materialNormal.depthTest = false;
+
+ // 7 - Shader used to update normals
+ var oceanShader = THREE.ShaderLib[ "ocean_main" ];
+ var oceanUniforms = THREE.UniformsUtils.clone( oceanShader.uniforms );
+ this.materialOcean = new THREE.ShaderMaterial( {
+ uniforms: oceanUniforms,
+ vertexShader: oceanShader.vertexShader,
+ fragmentShader: oceanShader.fragmentShader
+ } );
+ // this.materialOcean.wireframe = true;
+ this.materialOcean.uniforms.u_geometrySize = { value: this.resolution };
+ this.materialOcean.uniforms.u_displacementMap = { value: this.displacementMapFramebuffer.texture };
+ this.materialOcean.uniforms.u_normalMap = { value: this.normalMapFramebuffer.texture };
+ this.materialOcean.uniforms.u_oceanColor = { value: this.oceanColor };
+ this.materialOcean.uniforms.u_skyColor = { value: this.skyColor };
+ this.materialOcean.uniforms.u_sunDirection = { value: new THREE.Vector3( this.sunDirectionX, this.sunDirectionY, this.sunDirectionZ ) };
+ this.materialOcean.uniforms.u_exposure = { value: this.exposure };
+
+ // Disable blending to prevent default premultiplied alpha values
+ this.materialOceanHorizontal.blending = 0;
+ this.materialOceanVertical.blending = 0;
+ this.materialInitialSpectrum.blending = 0;
+ this.materialPhase.blending = 0;
+ this.materialSpectrum.blending = 0;
+ this.materialNormal.blending = 0;
+ this.materialOcean.blending = 0;
+
+ // Create the simulation plane
+ this.screenQuad = new THREE.Mesh( new THREE.PlaneBufferGeometry( 2, 2 ) );
+ this.scene.add( this.screenQuad );
+
+ // Initialise spectrum data
+ this.generateSeedPhaseTexture();
+
+ // Generate the ocean mesh
+ this.generateMesh();
+
+};
+
+THREE.Ocean.prototype.generateMesh = function () {
+
+ var geometry = new THREE.PlaneBufferGeometry( this.geometrySize, this.geometrySize, this.geometryResolution, this.geometryResolution );
+
+ geometry.rotateX( - Math.PI / 2 );
+
+ this.oceanMesh = new THREE.Mesh( geometry, this.materialOcean );
+
+};
+
+THREE.Ocean.prototype.render = function () {
+
+ this.scene.overrideMaterial = null;
+
+ if ( this.changed )
+ this.renderInitialSpectrum();
+
+ this.renderWavePhase();
+ this.renderSpectrum();
+ this.renderSpectrumFFT();
+ this.renderNormalMap();
+ this.scene.overrideMaterial = null;
+
+};
+
+THREE.Ocean.prototype.generateSeedPhaseTexture = function() {
+
+ // Setup the seed texture
+ this.pingPhase = true;
+ var phaseArray = new window.Float32Array( this.resolution * this.resolution * 4 );
+ for ( var i = 0; i < this.resolution; i ++ ) {
+
+ for ( var j = 0; j < this.resolution; j ++ ) {
+
+ phaseArray[ i * this.resolution * 4 + j * 4 ] = Math.random() * 2.0 * Math.PI;
+ phaseArray[ i * this.resolution * 4 + j * 4 + 1 ] = 0.0;
+ phaseArray[ i * this.resolution * 4 + j * 4 + 2 ] = 0.0;
+ phaseArray[ i * this.resolution * 4 + j * 4 + 3 ] = 0.0;
+
+ }
+
+ }
+
+ this.pingPhaseTexture = new THREE.DataTexture( phaseArray, this.resolution, this.resolution, THREE.RGBAFormat );
+ this.pingPhaseTexture.wrapS = THREE.ClampToEdgeWrapping;
+ this.pingPhaseTexture.wrapT = THREE.ClampToEdgeWrapping;
+ this.pingPhaseTexture.type = THREE.FloatType;
+ this.pingPhaseTexture.needsUpdate = true;
+
+};
+
+THREE.Ocean.prototype.renderInitialSpectrum = function () {
+
+ this.scene.overrideMaterial = this.materialInitialSpectrum;
+ this.materialInitialSpectrum.uniforms.u_wind.value.set( this.windX, this.windY );
+ this.materialInitialSpectrum.uniforms.u_size.value = this.size;
+ this.renderer.render( this.scene, this.oceanCamera, this.initialSpectrumFramebuffer, true );
+
+};
+
+THREE.Ocean.prototype.renderWavePhase = function () {
+
+ this.scene.overrideMaterial = this.materialPhase;
+ this.screenQuad.material = this.materialPhase;
+ if ( this.initial ) {
+
+ this.materialPhase.uniforms.u_phases.value = this.pingPhaseTexture;
+ this.initial = false;
+
+ }else {
+
+ this.materialPhase.uniforms.u_phases.value = this.pingPhase ? this.pingPhaseFramebuffer.texture : this.pongPhaseFramebuffer.texture;
+
+ }
+ this.materialPhase.uniforms.u_deltaTime.value = this.deltaTime;
+ this.materialPhase.uniforms.u_size.value = this.size;
+ this.renderer.render( this.scene, this.oceanCamera, this.pingPhase ? this.pongPhaseFramebuffer : this.pingPhaseFramebuffer );
+ this.pingPhase = ! this.pingPhase;
+
+};
+
+THREE.Ocean.prototype.renderSpectrum = function () {
+
+ this.scene.overrideMaterial = this.materialSpectrum;
+ this.materialSpectrum.uniforms.u_initialSpectrum.value = this.initialSpectrumFramebuffer.texture;
+ this.materialSpectrum.uniforms.u_phases.value = this.pingPhase ? this.pingPhaseFramebuffer.texture : this.pongPhaseFramebuffer.texture;
+ this.materialSpectrum.uniforms.u_choppiness.value = this.choppiness;
+ this.materialSpectrum.uniforms.u_size.value = this.size;
+ this.renderer.render( this.scene, this.oceanCamera, this.spectrumFramebuffer );
+
+};
+
+THREE.Ocean.prototype.renderSpectrumFFT = function() {
+
+ // GPU FFT using Stockham formulation
+ var iterations = Math.log( this.resolution ) / Math.log( 2 ); // log2
+
+ this.scene.overrideMaterial = this.materialOceanHorizontal;
+
+ for ( var i = 0; i < iterations; i ++ ) {
+
+ if ( i === 0 ) {
+
+ this.materialOceanHorizontal.uniforms.u_input.value = this.spectrumFramebuffer.texture;
+ this.materialOceanHorizontal.uniforms.u_subtransformSize.value = Math.pow( 2, ( i % ( iterations ) ) + 1 );
+ this.renderer.render( this.scene, this.oceanCamera, this.pingTransformFramebuffer );
+
+ } else if ( i % 2 === 1 ) {
+
+ this.materialOceanHorizontal.uniforms.u_input.value = this.pingTransformFramebuffer.texture;
+ this.materialOceanHorizontal.uniforms.u_subtransformSize.value = Math.pow( 2, ( i % ( iterations ) ) + 1 );
+ this.renderer.render( this.scene, this.oceanCamera, this.pongTransformFramebuffer );
+
+ } else {
+
+ this.materialOceanHorizontal.uniforms.u_input.value = this.pongTransformFramebuffer.texture;
+ this.materialOceanHorizontal.uniforms.u_subtransformSize.value = Math.pow( 2, ( i % ( iterations ) ) + 1 );
+ this.renderer.render( this.scene, this.oceanCamera, this.pingTransformFramebuffer );
+
+ }
+
+ }
+ this.scene.overrideMaterial = this.materialOceanVertical;
+ for ( var i = iterations; i < iterations * 2; i ++ ) {
+
+ if ( i === iterations * 2 - 1 ) {
+
+ this.materialOceanVertical.uniforms.u_input.value = ( iterations % 2 === 0 ) ? this.pingTransformFramebuffer.texture : this.pongTransformFramebuffer.texture;
+ this.materialOceanVertical.uniforms.u_subtransformSize.value = Math.pow( 2, ( i % ( iterations ) ) + 1 );
+ this.renderer.render( this.scene, this.oceanCamera, this.displacementMapFramebuffer );
+
+ } else if ( i % 2 === 1 ) {
+
+ this.materialOceanVertical.uniforms.u_input.value = this.pingTransformFramebuffer.texture;
+ this.materialOceanVertical.uniforms.u_subtransformSize.value = Math.pow( 2, ( i % ( iterations ) ) + 1 );
+ this.renderer.render( this.scene, this.oceanCamera, this.pongTransformFramebuffer );
+
+ } else {
+
+ this.materialOceanVertical.uniforms.u_input.value = this.pongTransformFramebuffer.texture;
+ this.materialOceanVertical.uniforms.u_subtransformSize.value = Math.pow( 2, ( i % ( iterations ) ) + 1 );
+ this.renderer.render( this.scene, this.oceanCamera, this.pingTransformFramebuffer );
+
+ }
+
+ }
+
+};
+
+THREE.Ocean.prototype.renderNormalMap = function () {
+
+ this.scene.overrideMaterial = this.materialNormal;
+ if ( this.changed ) this.materialNormal.uniforms.u_size.value = this.size;
+ this.materialNormal.uniforms.u_displacementMap.value = this.displacementMapFramebuffer.texture;
+ this.renderer.render( this.scene, this.oceanCamera, this.normalMapFramebuffer, true );
+
+};
diff --git a/three/jsutil/Octree.js b/three/jsutil/Octree.js
new file mode 100644
index 000000000..7b9fbe315
--- /dev/null
+++ b/three/jsutil/Octree.js
@@ -0,0 +1,2138 @@
+/*!
+ *
+ * threeoctree.js (r60) / https://github.com/collinhover/threeoctree
+ * (sparse) dynamic 3D spatial representation structure for fast searches.
+ *
+ * @author Collin Hover / http://collinhover.com/
+ * based on Dynamic Octree by Piko3D @ http://www.piko3d.com/ and Octree by Marek Pawlowski @ pawlowski.it
+ *
+ */
+( function ( THREE ) {
+
+ "use strict";
+
+ /*===================================================
+
+ utility
+
+ =====================================================*/
+
+ function isNumber( n ) {
+
+ return ! isNaN( n ) && isFinite( n );
+
+ }
+
+ function isArray( target ) {
+
+ return Object.prototype.toString.call( target ) === '[object Array]';
+
+ }
+
+ function toArray( target ) {
+
+ return target ? ( isArray( target ) !== true ? [ target ] : target ) : [];
+
+ }
+
+ function indexOfValue( array, value ) {
+
+ for ( var i = 0, il = array.length; i < il; i ++ ) {
+
+ if ( array[ i ] === value ) {
+
+ return i;
+
+ }
+
+ }
+
+ return - 1;
+
+ }
+
+ function indexOfPropertyWithValue( array, property, value ) {
+
+ for ( var i = 0, il = array.length; i < il; i ++ ) {
+
+ if ( array[ i ][ property ] === value ) {
+
+ return i;
+
+ }
+
+ }
+
+ return - 1;
+
+ }
+
+ /*===================================================
+
+ octree
+
+ =====================================================*/
+
+ THREE.Octree = function ( parameters ) {
+
+ // handle parameters
+
+ parameters = parameters || {};
+
+ parameters.tree = this;
+
+ // static properties ( modification is not recommended )
+
+ this.nodeCount = 0;
+
+ this.INDEX_INSIDE_CROSS = - 1;
+ this.INDEX_OUTSIDE_OFFSET = 2;
+
+ this.INDEX_OUTSIDE_POS_X = isNumber( parameters.INDEX_OUTSIDE_POS_X ) ? parameters.INDEX_OUTSIDE_POS_X : 0;
+ this.INDEX_OUTSIDE_NEG_X = isNumber( parameters.INDEX_OUTSIDE_NEG_X ) ? parameters.INDEX_OUTSIDE_NEG_X : 1;
+ this.INDEX_OUTSIDE_POS_Y = isNumber( parameters.INDEX_OUTSIDE_POS_Y ) ? parameters.INDEX_OUTSIDE_POS_Y : 2;
+ this.INDEX_OUTSIDE_NEG_Y = isNumber( parameters.INDEX_OUTSIDE_NEG_Y ) ? parameters.INDEX_OUTSIDE_NEG_Y : 3;
+ this.INDEX_OUTSIDE_POS_Z = isNumber( parameters.INDEX_OUTSIDE_POS_Z ) ? parameters.INDEX_OUTSIDE_POS_Z : 4;
+ this.INDEX_OUTSIDE_NEG_Z = isNumber( parameters.INDEX_OUTSIDE_NEG_Z ) ? parameters.INDEX_OUTSIDE_NEG_Z : 5;
+
+ this.INDEX_OUTSIDE_MAP = [];
+ this.INDEX_OUTSIDE_MAP[ this.INDEX_OUTSIDE_POS_X ] = { index: this.INDEX_OUTSIDE_POS_X, count: 0, x: 1, y: 0, z: 0 };
+ this.INDEX_OUTSIDE_MAP[ this.INDEX_OUTSIDE_NEG_X ] = { index: this.INDEX_OUTSIDE_NEG_X, count: 0, x: - 1, y: 0, z: 0 };
+ this.INDEX_OUTSIDE_MAP[ this.INDEX_OUTSIDE_POS_Y ] = { index: this.INDEX_OUTSIDE_POS_Y, count: 0, x: 0, y: 1, z: 0 };
+ this.INDEX_OUTSIDE_MAP[ this.INDEX_OUTSIDE_NEG_Y ] = { index: this.INDEX_OUTSIDE_NEG_Y, count: 0, x: 0, y: - 1, z: 0 };
+ this.INDEX_OUTSIDE_MAP[ this.INDEX_OUTSIDE_POS_Z ] = { index: this.INDEX_OUTSIDE_POS_Z, count: 0, x: 0, y: 0, z: 1 };
+ this.INDEX_OUTSIDE_MAP[ this.INDEX_OUTSIDE_NEG_Z ] = { index: this.INDEX_OUTSIDE_NEG_Z, count: 0, x: 0, y: 0, z: - 1 };
+
+ this.FLAG_POS_X = 1 << ( this.INDEX_OUTSIDE_POS_X + 1 );
+ this.FLAG_NEG_X = 1 << ( this.INDEX_OUTSIDE_NEG_X + 1 );
+ this.FLAG_POS_Y = 1 << ( this.INDEX_OUTSIDE_POS_Y + 1 );
+ this.FLAG_NEG_Y = 1 << ( this.INDEX_OUTSIDE_NEG_Y + 1 );
+ this.FLAG_POS_Z = 1 << ( this.INDEX_OUTSIDE_POS_Z + 1 );
+ this.FLAG_NEG_Z = 1 << ( this.INDEX_OUTSIDE_NEG_Z + 1 );
+
+ this.utilVec31Search = new THREE.Vector3();
+ this.utilVec32Search = new THREE.Vector3();
+
+ // pass scene to see octree structure
+
+ this.scene = parameters.scene;
+
+ if ( this.scene ) {
+
+ var helper = new THREE.BoxHelper( new THREE.Mesh( new THREE.BoxBufferGeometry( 1, 1, 1 ) ), 0xff0066 );
+ this.visualGeometry = helper.geometry;
+ this.visualMaterial = helper.material;
+
+ }
+
+ // properties
+
+ this.objects = [];
+ this.objectsMap = {};
+ this.objectsData = [];
+ this.objectsDeferred = [];
+
+ this.depthMax = isNumber( parameters.depthMax ) ? parameters.depthMax : Infinity;
+ this.objectsThreshold = isNumber( parameters.objectsThreshold ) ? parameters.objectsThreshold : 8;
+ this.overlapPct = isNumber( parameters.overlapPct ) ? parameters.overlapPct : 0.15;
+ this.undeferred = parameters.undeferred || false;
+
+ this.root = parameters.root instanceof THREE.OctreeNode ? parameters.root : new THREE.OctreeNode( parameters );
+
+ };
+
+ THREE.Octree.prototype = {
+
+ update: function () {
+
+ // add any deferred objects that were waiting for render cycle
+
+ if ( this.objectsDeferred.length > 0 ) {
+
+ for ( var i = 0, il = this.objectsDeferred.length; i < il; i ++ ) {
+
+ var deferred = this.objectsDeferred[ i ];
+
+ this.addDeferred( deferred.object, deferred.options );
+
+ }
+
+ this.objectsDeferred.length = 0;
+
+ }
+
+ },
+
+ add: function ( object, options ) {
+
+ // add immediately
+
+ if ( this.undeferred ) {
+
+ this.updateObject( object );
+
+ this.addDeferred( object, options );
+
+ } else {
+
+ // defer add until update called
+
+ this.objectsDeferred.push( { object: object, options: options } );
+
+ }
+
+ },
+
+ addDeferred: function ( object, options ) {
+
+ var i, l,
+ geometry,
+ faces,
+ useFaces,
+ vertices,
+ useVertices,
+ objectData;
+
+ // ensure object is not object data
+
+ if ( object instanceof THREE.OctreeObjectData ) {
+
+ object = object.object;
+
+ }
+
+ // check uuid to avoid duplicates
+
+ if ( ! object.uuid ) {
+
+ object.uuid = THREE.Math.generateUUID();
+
+ }
+
+ if ( ! this.objectsMap[ object.uuid ] ) {
+
+ // store
+
+ this.objects.push( object );
+ this.objectsMap[ object.uuid ] = object;
+
+ // check options
+
+ if ( options ) {
+
+ useFaces = options.useFaces;
+ useVertices = options.useVertices;
+
+ }
+
+ if ( useVertices === true ) {
+
+ geometry = object.geometry;
+ vertices = geometry.vertices;
+
+ for ( i = 0, l = vertices.length; i < l; i ++ ) {
+
+ this.addObjectData( object, vertices[ i ] );
+
+ }
+
+ } else if ( useFaces === true ) {
+
+ geometry = object.geometry;
+ faces = geometry.faces;
+
+ for ( i = 0, l = faces.length; i < l; i ++ ) {
+
+ this.addObjectData( object, faces[ i ] );
+
+ }
+
+ } else {
+
+ this.addObjectData( object );
+
+ }
+
+ }
+
+ },
+
+ addObjectData: function ( object, part ) {
+
+ var objectData = new THREE.OctreeObjectData( object, part );
+
+ // add to tree objects data list
+
+ this.objectsData.push( objectData );
+
+ // add to nodes
+
+ this.root.addObject( objectData );
+
+ },
+
+ remove: function ( object ) {
+
+ var i, l,
+ objectData = object,
+ index,
+ objectsDataRemoved;
+
+ // ensure object is not object data for index search
+
+ if ( object instanceof THREE.OctreeObjectData ) {
+
+ object = object.object;
+
+ }
+
+ // check uuid
+
+ if ( this.objectsMap[ object.uuid ] ) {
+
+ this.objectsMap[ object.uuid ] = undefined;
+
+ // check and remove from objects, nodes, and data lists
+
+ index = indexOfValue( this.objects, object );
+
+ if ( index !== - 1 ) {
+
+ this.objects.splice( index, 1 );
+
+ // remove from nodes
+
+ objectsDataRemoved = this.root.removeObject( objectData );
+
+ // remove from objects data list
+
+ for ( i = 0, l = objectsDataRemoved.length; i < l; i ++ ) {
+
+ objectData = objectsDataRemoved[ i ];
+
+ index = indexOfValue( this.objectsData, objectData );
+
+ if ( index !== - 1 ) {
+
+ this.objectsData.splice( index, 1 );
+
+ }
+
+ }
+
+ }
+
+ } else if ( this.objectsDeferred.length > 0 ) {
+
+ // check and remove from deferred
+
+ index = indexOfPropertyWithValue( this.objectsDeferred, 'object', object );
+
+ if ( index !== - 1 ) {
+
+ this.objectsDeferred.splice( index, 1 );
+
+ }
+
+ }
+
+ },
+
+ extend: function ( octree ) {
+
+ var i, l,
+ objectsData,
+ objectData;
+
+ if ( octree instanceof THREE.Octree ) {
+
+ // for each object data
+
+ objectsData = octree.objectsData;
+
+ for ( i = 0, l = objectsData.length; i < l; i ++ ) {
+
+ objectData = objectsData[ i ];
+
+ this.add( objectData, { useFaces: objectData.faces, useVertices: objectData.vertices } );
+
+ }
+
+ }
+
+ },
+
+ rebuild: function () {
+
+ var i, l,
+ node,
+ object,
+ objectData,
+ indexOctant,
+ indexOctantLast,
+ objectsUpdate = [];
+
+ // check all object data for changes in position
+ // assumes all object matrices are up to date
+
+ for ( i = 0, l = this.objectsData.length; i < l; i ++ ) {
+
+ objectData = this.objectsData[ i ];
+
+ node = objectData.node;
+
+ // update object
+
+ objectData.update();
+
+ // if position has changed since last organization of object in tree
+
+ if ( node instanceof THREE.OctreeNode && ! objectData.positionLast.equals( objectData.position ) ) {
+
+ // get octant index of object within current node
+
+ indexOctantLast = objectData.indexOctant;
+
+ indexOctant = node.getOctantIndex( objectData );
+
+ // if object octant index has changed
+
+ if ( indexOctant !== indexOctantLast ) {
+
+ // add to update list
+
+ objectsUpdate.push( objectData );
+
+ }
+
+ }
+
+ }
+
+ // update changed objects
+
+ for ( i = 0, l = objectsUpdate.length; i < l; i ++ ) {
+
+ objectData = objectsUpdate[ i ];
+
+ // remove object from current node
+
+ objectData.node.removeObject( objectData );
+
+ // add object to tree root
+
+ this.root.addObject( objectData );
+
+ }
+
+ },
+
+ updateObject: function ( object ) {
+
+ var i, l,
+ parentCascade = [ object ],
+ parent,
+ parentUpdate;
+
+ // search all parents between object and root for world matrix update
+
+ parent = object.parent;
+
+ while ( parent ) {
+
+ parentCascade.push( parent );
+ parent = parent.parent;
+
+ }
+
+ for ( i = 0, l = parentCascade.length; i < l; i ++ ) {
+
+ parent = parentCascade[ i ];
+
+ if ( parent.matrixWorldNeedsUpdate === true ) {
+
+ parentUpdate = parent;
+
+ }
+
+ }
+
+ // update world matrix starting at uppermost parent that needs update
+
+ if ( typeof parentUpdate !== 'undefined' ) {
+
+ parentUpdate.updateMatrixWorld();
+
+ }
+
+ },
+
+ search: function ( position, radius, organizeByObject, direction ) {
+
+ var i, l,
+ node,
+ objects,
+ objectData,
+ object,
+ results,
+ resultData,
+ resultsObjectsIndices,
+ resultObjectIndex,
+ directionPct;
+
+ // add root objects
+
+ objects = [].concat( this.root.objects );
+
+ // ensure radius (i.e. distance of ray) is a number
+
+ if ( ! ( radius > 0 ) ) {
+
+ radius = Number.MAX_VALUE;
+
+ }
+
+ // if direction passed, normalize and find pct
+
+ if ( direction instanceof THREE.Vector3 ) {
+
+ direction = this.utilVec31Search.copy( direction ).normalize();
+ directionPct = this.utilVec32Search.set( 1, 1, 1 ).divide( direction );
+
+ }
+
+ // search each node of root
+
+ for ( i = 0, l = this.root.nodesIndices.length; i < l; i ++ ) {
+
+ node = this.root.nodesByIndex[ this.root.nodesIndices[ i ] ];
+
+ objects = node.search( position, radius, objects, direction, directionPct );
+
+ }
+
+ // if should organize results by object
+
+ if ( organizeByObject === true ) {
+
+ results = [];
+ resultsObjectsIndices = [];
+
+ // for each object data found
+
+ for ( i = 0, l = objects.length; i < l; i ++ ) {
+
+ objectData = objects[ i ];
+ object = objectData.object;
+
+ resultObjectIndex = indexOfValue( resultsObjectsIndices, object );
+
+ // if needed, create new result data
+
+ if ( resultObjectIndex === - 1 ) {
+
+ resultData = {
+ object: object,
+ faces: [],
+ vertices: []
+ };
+
+ results.push( resultData );
+
+ resultsObjectsIndices.push( object );
+
+ } else {
+
+ resultData = results[ resultObjectIndex ];
+
+ }
+
+ // object data has faces or vertices, add to list
+
+ if ( objectData.faces ) {
+
+ resultData.faces.push( objectData.faces );
+
+ } else if ( objectData.vertices ) {
+
+ resultData.vertices.push( objectData.vertices );
+
+ }
+
+ }
+
+ } else {
+
+ results = objects;
+
+ }
+
+ return results;
+
+ },
+
+ setRoot: function ( root ) {
+
+ if ( root instanceof THREE.OctreeNode ) {
+
+ // store new root
+
+ this.root = root;
+
+ // update properties
+
+ this.root.updateProperties();
+
+ }
+
+ },
+
+ getDepthEnd: function () {
+
+ return this.root.getDepthEnd();
+
+ },
+
+ getNodeCountEnd: function () {
+
+ return this.root.getNodeCountEnd();
+
+ },
+
+ getObjectCountEnd: function () {
+
+ return this.root.getObjectCountEnd();
+
+ },
+
+ toConsole: function () {
+
+ this.root.toConsole();
+
+ }
+
+ };
+
+ /*===================================================
+
+ object data
+
+ =====================================================*/
+
+ THREE.OctreeObjectData = function ( object, part ) {
+
+ // properties
+
+ this.object = object;
+
+ // handle part by type
+
+ if ( part instanceof THREE.Face3 ) {
+
+ this.faces = part;
+ this.face3 = true;
+ this.utilVec31FaceBounds = new THREE.Vector3();
+
+ } else if ( part instanceof THREE.Vector3 ) {
+
+ this.vertices = part;
+
+ }
+
+ this.radius = 0;
+ this.position = new THREE.Vector3();
+
+ // initial update
+
+ if ( this.object instanceof THREE.Object3D ) {
+
+ this.update();
+
+ }
+
+ this.positionLast = this.position.clone();
+
+ };
+
+ THREE.OctreeObjectData.prototype = {
+
+ update: function () {
+
+ if ( this.face3 ) {
+
+ this.radius = this.getFace3BoundingRadius( this.object, this.faces );
+ this.position.copy( this.faces.centroid ).applyMatrix4( this.object.matrixWorld );
+
+ } else if ( this.vertices ) {
+
+ this.radius = this.object.material.size || 1;
+ this.position.copy( this.vertices ).applyMatrix4( this.object.matrixWorld );
+
+ } else {
+
+ if ( this.object.geometry ) {
+
+ if ( this.object.geometry.boundingSphere === null ) {
+
+ this.object.geometry.computeBoundingSphere();
+
+ }
+
+ this.radius = this.object.geometry.boundingSphere.radius;
+ this.position.copy( this.object.geometry.boundingSphere.center ).applyMatrix4( this.object.matrixWorld );
+
+ } else {
+
+ this.radius = this.object.boundRadius;
+ this.position.setFromMatrixPosition( this.object.matrixWorld );
+
+ }
+
+ }
+
+ this.radius = this.radius * Math.max( this.object.scale.x, this.object.scale.y, this.object.scale.z );
+
+ },
+
+ getFace3BoundingRadius: function ( object, face ) {
+
+ if ( face.centroid === undefined ) face.centroid = new THREE.Vector3();
+
+ var geometry = object.geometry || object,
+ vertices = geometry.vertices,
+ centroid = face.centroid,
+ va = vertices[ face.a ], vb = vertices[ face.b ], vc = vertices[ face.c ],
+ centroidToVert = this.utilVec31FaceBounds,
+ radius;
+
+ centroid.addVectors( va, vb ).add( vc ).divideScalar( 3 );
+ radius = Math.max( centroidToVert.subVectors( centroid, va ).length(), centroidToVert.subVectors( centroid, vb ).length(), centroidToVert.subVectors( centroid, vc ).length() );
+
+ return radius;
+
+ }
+
+ };
+
+ /*===================================================
+
+ node
+
+ =====================================================*/
+
+ THREE.OctreeNode = function ( parameters ) {
+
+ // utility
+
+ this.utilVec31Branch = new THREE.Vector3();
+ this.utilVec31Expand = new THREE.Vector3();
+ this.utilVec31Ray = new THREE.Vector3();
+
+ // handle parameters
+
+ parameters = parameters || {};
+
+ // store or create tree
+
+ if ( parameters.tree instanceof THREE.Octree ) {
+
+ this.tree = parameters.tree;
+
+ } else if ( parameters.parent instanceof THREE.OctreeNode !== true ) {
+
+ parameters.root = this;
+
+ this.tree = new THREE.Octree( parameters );
+
+ }
+
+ // basic properties
+
+ this.id = this.tree.nodeCount ++;
+ this.position = parameters.position instanceof THREE.Vector3 ? parameters.position : new THREE.Vector3();
+ this.radius = parameters.radius > 0 ? parameters.radius : 1;
+ this.indexOctant = parameters.indexOctant;
+ this.depth = 0;
+
+ // reset and assign parent
+
+ this.reset();
+ this.setParent( parameters.parent );
+
+ // additional properties
+
+ this.overlap = this.radius * this.tree.overlapPct;
+ this.radiusOverlap = this.radius + this.overlap;
+ this.left = this.position.x - this.radiusOverlap;
+ this.right = this.position.x + this.radiusOverlap;
+ this.bottom = this.position.y - this.radiusOverlap;
+ this.top = this.position.y + this.radiusOverlap;
+ this.back = this.position.z - this.radiusOverlap;
+ this.front = this.position.z + this.radiusOverlap;
+
+ // visual
+
+ if ( this.tree.scene ) {
+
+ this.visual = new THREE.LineSegments( this.tree.visualGeometry, this.tree.visualMaterial );
+ this.visual.scale.set( this.radiusOverlap * 2, this.radiusOverlap * 2, this.radiusOverlap * 2 );
+ this.visual.position.copy( this.position );
+ this.tree.scene.add( this.visual );
+
+ }
+
+ };
+
+ THREE.OctreeNode.prototype = {
+
+ setParent: function ( parent ) {
+
+ // store new parent
+
+ if ( parent !== this && this.parent !== parent ) {
+
+ this.parent = parent;
+
+ // update properties
+
+ this.updateProperties();
+
+ }
+
+ },
+
+ updateProperties: function () {
+
+ var i, l;
+
+ // properties
+
+ if ( this.parent instanceof THREE.OctreeNode ) {
+
+ this.tree = this.parent.tree;
+ this.depth = this.parent.depth + 1;
+
+ } else {
+
+ this.depth = 0;
+
+ }
+
+ // cascade
+
+ for ( i = 0, l = this.nodesIndices.length; i < l; i ++ ) {
+
+ this.nodesByIndex[ this.nodesIndices[ i ] ].updateProperties();
+
+ }
+
+ },
+
+ reset: function ( cascade, removeVisual ) {
+
+ var i, l,
+ node,
+ nodesIndices = this.nodesIndices || [],
+ nodesByIndex = this.nodesByIndex;
+
+ this.objects = [];
+ this.nodesIndices = [];
+ this.nodesByIndex = {};
+
+ // unset parent in nodes
+
+ for ( i = 0, l = nodesIndices.length; i < l; i ++ ) {
+
+ node = nodesByIndex[ nodesIndices[ i ] ];
+
+ node.setParent( undefined );
+
+ if ( cascade === true ) {
+
+ node.reset( cascade, removeVisual );
+
+ }
+
+ }
+
+ // visual
+
+ if ( removeVisual === true && this.visual && this.visual.parent ) {
+
+ this.visual.parent.remove( this.visual );
+
+ }
+
+ },
+
+ addNode: function ( node, indexOctant ) {
+
+ node.indexOctant = indexOctant;
+
+ if ( indexOfValue( this.nodesIndices, indexOctant ) === - 1 ) {
+
+ this.nodesIndices.push( indexOctant );
+
+ }
+
+ this.nodesByIndex[ indexOctant ] = node;
+
+ if ( node.parent !== this ) {
+
+ node.setParent( this );
+
+ }
+
+ },
+
+ removeNode: function ( indexOctant ) {
+
+ var index,
+ node;
+
+ index = indexOfValue( this.nodesIndices, indexOctant );
+
+ this.nodesIndices.splice( index, 1 );
+
+ node = node || this.nodesByIndex[ indexOctant ];
+
+ delete this.nodesByIndex[ indexOctant ];
+
+ if ( node.parent === this ) {
+
+ node.setParent( undefined );
+
+ }
+
+ },
+
+ addObject: function ( object ) {
+
+ var index,
+ indexOctant,
+ node;
+
+ // get object octant index
+
+ indexOctant = this.getOctantIndex( object );
+
+ // if object fully contained by an octant, add to subtree
+ if ( indexOctant > - 1 && this.nodesIndices.length > 0 ) {
+
+ node = this.branch( indexOctant );
+
+ node.addObject( object );
+
+ } else if ( indexOctant < - 1 && this.parent instanceof THREE.OctreeNode ) {
+
+ // if object lies outside bounds, add to parent node
+
+ this.parent.addObject( object );
+
+ } else {
+
+ // add to this objects list
+
+ index = indexOfValue( this.objects, object );
+
+ if ( index === - 1 ) {
+
+ this.objects.push( object );
+
+ }
+
+ // node reference
+
+ object.node = this;
+
+ // check if need to expand, split, or both
+
+ this.checkGrow();
+
+ }
+
+ },
+
+ addObjectWithoutCheck: function ( objects ) {
+
+ var i, l,
+ object;
+
+ for ( i = 0, l = objects.length; i < l; i ++ ) {
+
+ object = objects[ i ];
+
+ this.objects.push( object );
+
+ object.node = this;
+
+ }
+
+ },
+
+ removeObject: function ( object ) {
+
+ var i, l,
+ nodesRemovedFrom,
+ removeData;
+
+ // cascade through tree to find and remove object
+
+ removeData = this.removeObjectRecursive( object, { searchComplete: false, nodesRemovedFrom: [], objectsDataRemoved: [] } );
+
+ // if object removed, try to shrink the nodes it was removed from
+
+ nodesRemovedFrom = removeData.nodesRemovedFrom;
+
+ if ( nodesRemovedFrom.length > 0 ) {
+
+ for ( i = 0, l = nodesRemovedFrom.length; i < l; i ++ ) {
+
+ nodesRemovedFrom[ i ].shrink();
+
+ }
+
+ }
+
+ return removeData.objectsDataRemoved;
+
+ },
+
+ removeObjectRecursive: function ( object, removeData ) {
+
+ var i, l,
+ index = - 1,
+ objectData,
+ node,
+ objectRemoved;
+
+ // find index of object in objects list
+
+ // search and remove object data (fast)
+ if ( object instanceof THREE.OctreeObjectData ) {
+
+ // remove from this objects list
+
+ index = indexOfValue( this.objects, object );
+
+ if ( index !== - 1 ) {
+
+ this.objects.splice( index, 1 );
+ object.node = undefined;
+
+ removeData.objectsDataRemoved.push( object );
+
+ removeData.searchComplete = objectRemoved = true;
+
+ }
+
+ } else {
+
+ // search each object data for object and remove (slow)
+
+ for ( i = this.objects.length - 1; i >= 0; i -- ) {
+
+ objectData = this.objects[ i ];
+
+ if ( objectData.object === object ) {
+
+ this.objects.splice( i, 1 );
+ objectData.node = undefined;
+
+ removeData.objectsDataRemoved.push( objectData );
+
+ objectRemoved = true;
+
+ if ( ! objectData.faces && ! objectData.vertices ) {
+
+ removeData.searchComplete = true;
+ break;
+
+ }
+
+ }
+
+ }
+
+ }
+
+ // if object data removed and this is not on nodes removed from
+
+ if ( objectRemoved === true ) {
+
+ removeData.nodesRemovedFrom.push( this );
+
+ }
+
+ // if search not complete, search nodes
+
+ if ( removeData.searchComplete !== true ) {
+
+ for ( i = 0, l = this.nodesIndices.length; i < l; i ++ ) {
+
+ node = this.nodesByIndex[ this.nodesIndices[ i ] ];
+
+ // try removing object from node
+
+ removeData = node.removeObjectRecursive( object, removeData );
+
+ if ( removeData.searchComplete === true ) {
+
+ break;
+
+ }
+
+ }
+
+ }
+
+ return removeData;
+
+ },
+
+ checkGrow: function () {
+
+ // if object count above max
+
+ if ( this.objects.length > this.tree.objectsThreshold && this.tree.objectsThreshold > 0 ) {
+
+ this.grow();
+
+ }
+
+ },
+
+ grow: function () {
+
+ var indexOctant,
+ object,
+ objectsExpand = [],
+ objectsExpandOctants = [],
+ objectsSplit = [],
+ objectsSplitOctants = [],
+ objectsRemaining = [],
+ i, l;
+
+ // for each object
+
+ for ( i = 0, l = this.objects.length; i < l; i ++ ) {
+
+ object = this.objects[ i ];
+
+ // get object octant index
+
+ indexOctant = this.getOctantIndex( object );
+
+ // if lies within octant
+ if ( indexOctant > - 1 ) {
+
+ objectsSplit.push( object );
+ objectsSplitOctants.push( indexOctant );
+
+ } else if ( indexOctant < - 1 ) {
+
+ // lies outside radius
+
+ objectsExpand.push( object );
+ objectsExpandOctants.push( indexOctant );
+
+ } else {
+
+ // lies across bounds between octants
+
+ objectsRemaining.push( object );
+
+ }
+
+ }
+
+ // if has objects to split
+
+ if ( objectsSplit.length > 0 ) {
+
+ objectsRemaining = objectsRemaining.concat( this.split( objectsSplit, objectsSplitOctants ) );
+
+ }
+
+ // if has objects to expand
+
+ if ( objectsExpand.length > 0 ) {
+
+ objectsRemaining = objectsRemaining.concat( this.expand( objectsExpand, objectsExpandOctants ) );
+
+ }
+
+ // store remaining
+
+ this.objects = objectsRemaining;
+
+ // merge check
+
+ this.checkMerge();
+
+ },
+
+ split: function ( objects, octants ) {
+
+ var i, l,
+ indexOctant,
+ object,
+ node,
+ objectsRemaining;
+
+ // if not at max depth
+
+ if ( this.depth < this.tree.depthMax ) {
+
+ objects = objects || this.objects;
+
+ octants = octants || [];
+
+ objectsRemaining = [];
+
+ // for each object
+
+ for ( i = 0, l = objects.length; i < l; i ++ ) {
+
+ object = objects[ i ];
+
+ // get object octant index
+
+ indexOctant = octants[ i ];
+
+ // if object contained by octant, branch this tree
+
+ if ( indexOctant > - 1 ) {
+
+ node = this.branch( indexOctant );
+
+ node.addObject( object );
+
+ } else {
+
+ objectsRemaining.push( object );
+
+ }
+
+ }
+
+ // if all objects, set remaining as new objects
+
+ if ( objects === this.objects ) {
+
+ this.objects = objectsRemaining;
+
+ }
+
+ } else {
+
+ objectsRemaining = this.objects;
+
+ }
+
+ return objectsRemaining;
+
+ },
+
+ branch: function ( indexOctant ) {
+
+ var node,
+ overlap,
+ radius,
+ radiusOffset,
+ offset,
+ position;
+
+ // node exists
+
+ if ( this.nodesByIndex[ indexOctant ] instanceof THREE.OctreeNode ) {
+
+ node = this.nodesByIndex[ indexOctant ];
+
+ } else {
+
+ // properties
+
+ radius = ( this.radiusOverlap ) * 0.5;
+ overlap = radius * this.tree.overlapPct;
+ radiusOffset = radius - overlap;
+ offset = this.utilVec31Branch.set( indexOctant & 1 ? radiusOffset : - radiusOffset, indexOctant & 2 ? radiusOffset : - radiusOffset, indexOctant & 4 ? radiusOffset : - radiusOffset );
+ position = new THREE.Vector3().addVectors( this.position, offset );
+
+ // node
+
+ node = new THREE.OctreeNode( {
+ tree: this.tree,
+ parent: this,
+ position: position,
+ radius: radius,
+ indexOctant: indexOctant
+ } );
+
+ // store
+
+ this.addNode( node, indexOctant );
+
+ }
+
+ return node;
+
+ },
+
+ expand: function ( objects, octants ) {
+
+ var i, l,
+ object,
+ objectsRemaining,
+ objectsExpand,
+ indexOctant,
+ flagsOutside,
+ indexOutside,
+ indexOctantInverse,
+ iom = this.tree.INDEX_OUTSIDE_MAP,
+ indexOutsideCounts,
+ infoIndexOutside1,
+ infoIndexOutside2,
+ infoIndexOutside3,
+ indexOutsideBitwise1,
+ indexOutsideBitwise2,
+ infoPotential1,
+ infoPotential2,
+ infoPotential3,
+ indexPotentialBitwise1,
+ indexPotentialBitwise2,
+ octantX, octantY, octantZ,
+ overlap,
+ radius,
+ radiusOffset,
+ radiusParent,
+ overlapParent,
+ offset = this.utilVec31Expand,
+ position,
+ parent;
+
+ // handle max depth down tree
+
+ if ( this.tree.root.getDepthEnd() < this.tree.depthMax ) {
+
+ objects = objects || this.objects;
+ octants = octants || [];
+
+ objectsRemaining = [];
+ objectsExpand = [];
+
+ // reset counts
+
+ for ( i = 0, l = iom.length; i < l; i ++ ) {
+
+ iom[ i ].count = 0;
+
+ }
+
+ // for all outside objects, find outside octants containing most objects
+
+ for ( i = 0, l = objects.length; i < l; i ++ ) {
+
+ object = objects[ i ];
+
+ // get object octant index
+
+ indexOctant = octants[ i ];
+
+ // if object outside this, include in calculations
+
+ if ( indexOctant < - 1 ) {
+
+ // convert octant index to outside flags
+
+ flagsOutside = - indexOctant - this.tree.INDEX_OUTSIDE_OFFSET;
+
+ // check against bitwise flags
+
+ // x
+
+ if ( flagsOutside & this.tree.FLAG_POS_X ) {
+
+ iom[ this.tree.INDEX_OUTSIDE_POS_X ].count ++;
+
+ } else if ( flagsOutside & this.tree.FLAG_NEG_X ) {
+
+ iom[ this.tree.INDEX_OUTSIDE_NEG_X ].count ++;
+
+ }
+
+ // y
+
+ if ( flagsOutside & this.tree.FLAG_POS_Y ) {
+
+ iom[ this.tree.INDEX_OUTSIDE_POS_Y ].count ++;
+
+ } else if ( flagsOutside & this.tree.FLAG_NEG_Y ) {
+
+ iom[ this.tree.INDEX_OUTSIDE_NEG_Y ].count ++;
+
+ }
+
+ // z
+
+ if ( flagsOutside & this.tree.FLAG_POS_Z ) {
+
+ iom[ this.tree.INDEX_OUTSIDE_POS_Z ].count ++;
+
+ } else if ( flagsOutside & this.tree.FLAG_NEG_Z ) {
+
+ iom[ this.tree.INDEX_OUTSIDE_NEG_Z ].count ++;
+
+ }
+
+ // store in expand list
+
+ objectsExpand.push( object );
+
+ } else {
+
+ objectsRemaining.push( object );
+
+ }
+
+ }
+
+ // if objects to expand
+
+ if ( objectsExpand.length > 0 ) {
+
+ // shallow copy index outside map
+
+ indexOutsideCounts = iom.slice( 0 );
+
+ // sort outside index count so highest is first
+
+ indexOutsideCounts.sort( function ( a, b ) {
+
+ return b.count - a.count;
+
+ } );
+
+ // get highest outside indices
+
+ // first is first
+ infoIndexOutside1 = indexOutsideCounts[ 0 ];
+ indexOutsideBitwise1 = infoIndexOutside1.index | 1;
+
+ // second is ( one of next two bitwise OR 1 ) that is not opposite of ( first bitwise OR 1 )
+
+ infoPotential1 = indexOutsideCounts[ 1 ];
+ infoPotential2 = indexOutsideCounts[ 2 ];
+
+ infoIndexOutside2 = ( infoPotential1.index | 1 ) !== indexOutsideBitwise1 ? infoPotential1 : infoPotential2;
+ indexOutsideBitwise2 = infoIndexOutside2.index | 1;
+
+ // third is ( one of next three bitwise OR 1 ) that is not opposite of ( first or second bitwise OR 1 )
+
+ infoPotential1 = indexOutsideCounts[ 2 ];
+ infoPotential2 = indexOutsideCounts[ 3 ];
+ infoPotential3 = indexOutsideCounts[ 4 ];
+
+ indexPotentialBitwise1 = infoPotential1.index | 1;
+ indexPotentialBitwise2 = infoPotential2.index | 1;
+
+ infoIndexOutside3 = indexPotentialBitwise1 !== indexOutsideBitwise1 && indexPotentialBitwise1 !== indexOutsideBitwise2 ? infoPotential1 : indexPotentialBitwise2 !== indexOutsideBitwise1 && indexPotentialBitwise2 !== indexOutsideBitwise2 ? infoPotential2 : infoPotential3;
+
+ // get this octant normal based on outside octant indices
+
+ octantX = infoIndexOutside1.x + infoIndexOutside2.x + infoIndexOutside3.x;
+ octantY = infoIndexOutside1.y + infoIndexOutside2.y + infoIndexOutside3.y;
+ octantZ = infoIndexOutside1.z + infoIndexOutside2.z + infoIndexOutside3.z;
+
+ // get this octant indices based on octant normal
+
+ indexOctant = this.getOctantIndexFromPosition( octantX, octantY, octantZ );
+ indexOctantInverse = this.getOctantIndexFromPosition( - octantX, - octantY, - octantZ );
+
+ // properties
+
+ overlap = this.overlap;
+ radius = this.radius;
+
+ // radius of parent comes from reversing overlap of this, unless overlap percent is 0
+
+ radiusParent = this.tree.overlapPct > 0 ? overlap / ( ( 0.5 * this.tree.overlapPct ) * ( 1 + this.tree.overlapPct ) ) : radius * 2;
+ overlapParent = radiusParent * this.tree.overlapPct;
+
+ // parent offset is difference between radius + overlap of parent and child
+
+ radiusOffset = ( radiusParent + overlapParent ) - ( radius + overlap );
+ offset.set( indexOctant & 1 ? radiusOffset : - radiusOffset, indexOctant & 2 ? radiusOffset : - radiusOffset, indexOctant & 4 ? radiusOffset : - radiusOffset );
+ position = new THREE.Vector3().addVectors( this.position, offset );
+
+ // parent
+
+ parent = new THREE.OctreeNode( {
+ tree: this.tree,
+ position: position,
+ radius: radiusParent
+ } );
+
+ // set self as node of parent
+
+ parent.addNode( this, indexOctantInverse );
+
+ // set parent as root
+
+ this.tree.setRoot( parent );
+
+ // add all expand objects to parent
+
+ for ( i = 0, l = objectsExpand.length; i < l; i ++ ) {
+
+ this.tree.root.addObject( objectsExpand[ i ] );
+
+ }
+
+ }
+
+ // if all objects, set remaining as new objects
+
+ if ( objects === this.objects ) {
+
+ this.objects = objectsRemaining;
+
+ }
+
+ } else {
+
+ objectsRemaining = objects;
+
+ }
+
+ return objectsRemaining;
+
+ },
+
+ shrink: function () {
+
+ // merge check
+
+ this.checkMerge();
+
+ // contract check
+
+ this.tree.root.checkContract();
+
+ },
+
+ checkMerge: function () {
+
+ var nodeParent = this,
+ nodeMerge;
+
+ // traverse up tree as long as node + entire subtree's object count is under minimum
+
+ while ( nodeParent.parent instanceof THREE.OctreeNode && nodeParent.getObjectCountEnd() < this.tree.objectsThreshold ) {
+
+ nodeMerge = nodeParent;
+ nodeParent = nodeParent.parent;
+
+ }
+
+ // if parent node is not this, merge entire subtree into merge node
+
+ if ( nodeParent !== this ) {
+
+ nodeParent.merge( nodeMerge );
+
+ }
+
+ },
+
+ merge: function ( nodes ) {
+
+ var i, l,
+ j, k,
+ node;
+
+ // handle nodes
+
+ nodes = toArray( nodes );
+
+ for ( i = 0, l = nodes.length; i < l; i ++ ) {
+
+ node = nodes[ i ];
+
+ // gather node + all subtree objects
+
+ this.addObjectWithoutCheck( node.getObjectsEnd() );
+
+ // reset node + entire subtree
+
+ node.reset( true, true );
+
+ // remove node
+
+ this.removeNode( node.indexOctant, node );
+
+ }
+
+ // merge check
+
+ this.checkMerge();
+
+ },
+
+ checkContract: function () {
+
+ var i, l,
+ node,
+ nodeObjectsCount,
+ nodeHeaviest,
+ nodeHeaviestObjectsCount,
+ outsideHeaviestObjectsCount;
+
+ // find node with highest object count
+
+ if ( this.nodesIndices.length > 0 ) {
+
+ nodeHeaviestObjectsCount = 0;
+ outsideHeaviestObjectsCount = this.objects.length;
+
+ for ( i = 0, l = this.nodesIndices.length; i < l; i ++ ) {
+
+ node = this.nodesByIndex[ this.nodesIndices[ i ] ];
+
+ nodeObjectsCount = node.getObjectCountEnd();
+ outsideHeaviestObjectsCount += nodeObjectsCount;
+
+ if ( nodeHeaviest instanceof THREE.OctreeNode === false || nodeObjectsCount > nodeHeaviestObjectsCount ) {
+
+ nodeHeaviest = node;
+ nodeHeaviestObjectsCount = nodeObjectsCount;
+
+ }
+
+ }
+
+ // subtract heaviest count from outside count
+
+ outsideHeaviestObjectsCount -= nodeHeaviestObjectsCount;
+
+ // if should contract
+
+ if ( outsideHeaviestObjectsCount < this.tree.objectsThreshold && nodeHeaviest instanceof THREE.OctreeNode ) {
+
+ this.contract( nodeHeaviest );
+
+ }
+
+ }
+
+ },
+
+ contract: function ( nodeRoot ) {
+
+ var i, l,
+ node;
+
+ // handle all nodes
+
+ for ( i = 0, l = this.nodesIndices.length; i < l; i ++ ) {
+
+ node = this.nodesByIndex[ this.nodesIndices[ i ] ];
+
+ // if node is not new root
+
+ if ( node !== nodeRoot ) {
+
+ // add node + all subtree objects to root
+
+ nodeRoot.addObjectWithoutCheck( node.getObjectsEnd() );
+
+ // reset node + entire subtree
+
+ node.reset( true, true );
+
+ }
+
+ }
+
+ // add own objects to root
+
+ nodeRoot.addObjectWithoutCheck( this.objects );
+
+ // reset self
+
+ this.reset( false, true );
+
+ // set new root
+
+ this.tree.setRoot( nodeRoot );
+
+ // contract check on new root
+
+ nodeRoot.checkContract();
+
+ },
+
+ getOctantIndex: function ( objectData ) {
+
+ var i, l,
+ positionObj,
+ radiusObj,
+ position = this.position,
+ radiusOverlap = this.radiusOverlap,
+ overlap = this.overlap,
+ deltaX, deltaY, deltaZ,
+ distX, distY, distZ,
+ distance,
+ indexOctant = 0;
+
+ // handle type
+
+ if ( objectData instanceof THREE.OctreeObjectData ) {
+
+ radiusObj = objectData.radius;
+
+ positionObj = objectData.position;
+
+ // update object data position last
+
+ objectData.positionLast.copy( positionObj );
+
+ } else if ( objectData instanceof THREE.OctreeNode ) {
+
+ positionObj = objectData.position;
+
+ radiusObj = 0;
+
+ }
+
+ // find delta and distance
+
+ deltaX = positionObj.x - position.x;
+ deltaY = positionObj.y - position.y;
+ deltaZ = positionObj.z - position.z;
+
+ distX = Math.abs( deltaX );
+ distY = Math.abs( deltaY );
+ distZ = Math.abs( deltaZ );
+ distance = Math.max( distX, distY, distZ );
+
+ // if outside, use bitwise flags to indicate on which sides object is outside of
+
+ if ( distance + radiusObj > radiusOverlap ) {
+
+ // x
+
+ if ( distX + radiusObj > radiusOverlap ) {
+
+ indexOctant = indexOctant ^ ( deltaX > 0 ? this.tree.FLAG_POS_X : this.tree.FLAG_NEG_X );
+
+ }
+
+ // y
+
+ if ( distY + radiusObj > radiusOverlap ) {
+
+ indexOctant = indexOctant ^ ( deltaY > 0 ? this.tree.FLAG_POS_Y : this.tree.FLAG_NEG_Y );
+
+ }
+
+ // z
+
+ if ( distZ + radiusObj > radiusOverlap ) {
+
+ indexOctant = indexOctant ^ ( deltaZ > 0 ? this.tree.FLAG_POS_Z : this.tree.FLAG_NEG_Z );
+
+ }
+
+ objectData.indexOctant = - indexOctant - this.tree.INDEX_OUTSIDE_OFFSET;
+
+ return objectData.indexOctant;
+
+ }
+
+ // return octant index from delta xyz
+
+ if ( deltaX - radiusObj > - overlap ) {
+
+ // x right
+
+ indexOctant = indexOctant | 1;
+
+ } else if ( ! ( deltaX + radiusObj < overlap ) ) {
+
+ // x left
+
+ objectData.indexOctant = this.tree.INDEX_INSIDE_CROSS;
+ return objectData.indexOctant;
+
+ }
+
+ if ( deltaY - radiusObj > - overlap ) {
+
+ // y right
+
+ indexOctant = indexOctant | 2;
+
+ } else if ( ! ( deltaY + radiusObj < overlap ) ) {
+
+ // y left
+
+ objectData.indexOctant = this.tree.INDEX_INSIDE_CROSS;
+ return objectData.indexOctant;
+
+ }
+
+
+ if ( deltaZ - radiusObj > - overlap ) {
+
+ // z right
+
+ indexOctant = indexOctant | 4;
+
+ } else if ( ! ( deltaZ + radiusObj < overlap ) ) {
+
+ // z left
+
+ objectData.indexOctant = this.tree.INDEX_INSIDE_CROSS;
+ return objectData.indexOctant;
+
+ }
+
+ objectData.indexOctant = indexOctant;
+ return objectData.indexOctant;
+
+ },
+
+ getOctantIndexFromPosition: function ( x, y, z ) {
+
+ var indexOctant = 0;
+
+ if ( x > 0 ) {
+
+ indexOctant = indexOctant | 1;
+
+ }
+
+ if ( y > 0 ) {
+
+ indexOctant = indexOctant | 2;
+
+ }
+
+ if ( z > 0 ) {
+
+ indexOctant = indexOctant | 4;
+
+ }
+
+ return indexOctant;
+
+ },
+
+ search: function ( position, radius, objects, direction, directionPct ) {
+
+ var i, l,
+ node,
+ intersects;
+
+ // test intersects by parameters
+
+ if ( direction ) {
+
+ intersects = this.intersectRay( position, direction, radius, directionPct );
+
+ } else {
+
+ intersects = this.intersectSphere( position, radius );
+
+ }
+
+ // if intersects
+
+ if ( intersects === true ) {
+
+ // gather objects
+
+ objects = objects.concat( this.objects );
+
+ // search subtree
+
+ for ( i = 0, l = this.nodesIndices.length; i < l; i ++ ) {
+
+ node = this.nodesByIndex[ this.nodesIndices[ i ] ];
+
+ objects = node.search( position, radius, objects, direction );
+
+ }
+
+ }
+
+ return objects;
+
+ },
+
+ intersectSphere: function ( position, radius ) {
+
+ var distance = radius * radius,
+ px = position.x,
+ py = position.y,
+ pz = position.z;
+
+ if ( px < this.left ) {
+
+ distance -= Math.pow( px - this.left, 2 );
+
+ } else if ( px > this.right ) {
+
+ distance -= Math.pow( px - this.right, 2 );
+
+ }
+
+ if ( py < this.bottom ) {
+
+ distance -= Math.pow( py - this.bottom, 2 );
+
+ } else if ( py > this.top ) {
+
+ distance -= Math.pow( py - this.top, 2 );
+
+ }
+
+ if ( pz < this.back ) {
+
+ distance -= Math.pow( pz - this.back, 2 );
+
+ } else if ( pz > this.front ) {
+
+ distance -= Math.pow( pz - this.front, 2 );
+
+ }
+
+ return distance >= 0;
+
+ },
+
+ intersectRay: function ( origin, direction, distance, directionPct ) {
+
+ if ( typeof directionPct === 'undefined' ) {
+
+ directionPct = this.utilVec31Ray.set( 1, 1, 1 ).divide( direction );
+
+ }
+
+ var t1 = ( this.left - origin.x ) * directionPct.x,
+ t2 = ( this.right - origin.x ) * directionPct.x,
+ t3 = ( this.bottom - origin.y ) * directionPct.y,
+ t4 = ( this.top - origin.y ) * directionPct.y,
+ t5 = ( this.back - origin.z ) * directionPct.z,
+ t6 = ( this.front - origin.z ) * directionPct.z,
+ tmax = Math.min( Math.min( Math.max( t1, t2 ), Math.max( t3, t4 ) ), Math.max( t5, t6 ) ),
+ tmin;
+
+ // ray would intersect in reverse direction, i.e. this is behind ray
+ if ( tmax < 0 ) {
+
+ return false;
+
+ }
+
+ tmin = Math.max( Math.max( Math.min( t1, t2 ), Math.min( t3, t4 ) ), Math.min( t5, t6 ) );
+
+ // if tmin > tmax or tmin > ray distance, ray doesn't intersect AABB
+ if ( tmin > tmax || tmin > distance ) {
+
+ return false;
+
+ }
+
+ return true;
+
+ },
+
+ getDepthEnd: function ( depth ) {
+
+ var i, l,
+ node;
+
+ if ( this.nodesIndices.length > 0 ) {
+
+ for ( i = 0, l = this.nodesIndices.length; i < l; i ++ ) {
+
+ node = this.nodesByIndex[ this.nodesIndices[ i ] ];
+
+ depth = node.getDepthEnd( depth );
+
+ }
+
+ } else {
+
+ depth = ! depth || this.depth > depth ? this.depth : depth;
+
+ }
+
+ return depth;
+
+ },
+
+ getNodeCountEnd: function () {
+
+ return this.tree.root.getNodeCountRecursive() + 1;
+
+ },
+
+ getNodeCountRecursive: function () {
+
+ var i, l,
+ count = this.nodesIndices.length;
+
+ for ( i = 0, l = this.nodesIndices.length; i < l; i ++ ) {
+
+ count += this.nodesByIndex[ this.nodesIndices[ i ] ].getNodeCountRecursive();
+
+ }
+
+ return count;
+
+ },
+
+ getObjectsEnd: function ( objects ) {
+
+ var i, l,
+ node;
+
+ objects = ( objects || [] ).concat( this.objects );
+
+ for ( i = 0, l = this.nodesIndices.length; i < l; i ++ ) {
+
+ node = this.nodesByIndex[ this.nodesIndices[ i ] ];
+
+ objects = node.getObjectsEnd( objects );
+
+ }
+
+ return objects;
+
+ },
+
+ getObjectCountEnd: function () {
+
+ var i, l,
+ count = this.objects.length;
+
+ for ( i = 0, l = this.nodesIndices.length; i < l; i ++ ) {
+
+ count += this.nodesByIndex[ this.nodesIndices[ i ] ].getObjectCountEnd();
+
+ }
+
+ return count;
+
+ },
+
+ getObjectCountStart: function () {
+
+ var count = this.objects.length,
+ parent = this.parent;
+
+ while ( parent instanceof THREE.OctreeNode ) {
+
+ count += parent.objects.length;
+ parent = parent.parent;
+
+ }
+
+ return count;
+
+ },
+
+ toConsole: function ( space ) {
+
+ var i, l,
+ node,
+ spaceAddition = ' ';
+
+ space = typeof space === 'string' ? space : spaceAddition;
+
+ console.log( ( this.parent ? space + ' octree NODE > ' : ' octree ROOT > ' ), this, ' // id: ', this.id, ' // indexOctant: ', this.indexOctant, ' // position: ', this.position.x, this.position.y, this.position.z, ' // radius: ', this.radius, ' // depth: ', this.depth );
+ console.log( ( this.parent ? space + ' ' : ' ' ), '+ objects ( ', this.objects.length, ' ) ', this.objects );
+ console.log( ( this.parent ? space + ' ' : ' ' ), '+ children ( ', this.nodesIndices.length, ' )', this.nodesIndices, this.nodesByIndex );
+
+ for ( i = 0, l = this.nodesIndices.length; i < l; i ++ ) {
+
+ node = this.nodesByIndex[ this.nodesIndices[ i ] ];
+
+ node.toConsole( space + spaceAddition );
+
+ }
+
+ }
+
+ };
+
+ /*===================================================
+
+ raycaster additional functionality
+
+ =====================================================*/
+
+ THREE.Raycaster.prototype.intersectOctreeObject = function ( object, recursive ) {
+
+ var intersects,
+ octreeObject,
+ facesAll,
+ facesSearch;
+
+ if ( object.object instanceof THREE.Object3D ) {
+
+ octreeObject = object;
+ object = octreeObject.object;
+
+ // temporarily replace object geometry's faces with octree object faces
+
+ facesSearch = octreeObject.faces;
+ facesAll = object.geometry.faces;
+
+ if ( facesSearch.length > 0 ) {
+
+ object.geometry.faces = facesSearch;
+
+ }
+
+ // intersect
+
+ intersects = this.intersectObject( object, recursive );
+
+ // revert object geometry's faces
+
+ if ( facesSearch.length > 0 ) {
+
+ object.geometry.faces = facesAll;
+
+ }
+
+ } else {
+
+ intersects = this.intersectObject( object, recursive );
+
+ }
+
+ return intersects;
+
+ };
+
+ THREE.Raycaster.prototype.intersectOctreeObjects = function ( objects, recursive ) {
+
+ var i, il,
+ intersects = [];
+
+ for ( i = 0, il = objects.length; i < il; i ++ ) {
+
+ intersects = intersects.concat( this.intersectOctreeObject( objects[ i ], recursive ) );
+
+ }
+
+ return intersects;
+
+ };
+
+}( THREE ) );
diff --git a/three/jsutil/PRNG.js b/three/jsutil/PRNG.js
new file mode 100644
index 000000000..ab811a820
--- /dev/null
+++ b/three/jsutil/PRNG.js
@@ -0,0 +1,23 @@
+// Park-Miller-Carta Pseudo-Random Number Generator
+// https://github.com/pnitsch/BitmapData.js/blob/master/js/BitmapData.js
+
+var PRNG = function () {
+
+ this.seed = 1;
+ this.next = function() {
+
+ return ( this.gen() / 2147483647 );
+
+ };
+ this.nextRange = function( min, max ) {
+
+ return min + ( ( max - min ) * this.next() )
+
+ };
+ this.gen = function() {
+
+ return this.seed = ( this.seed * 16807 ) % 2147483647;
+
+ };
+
+};
diff --git a/three/jsutil/ParametricGeometries.js b/three/jsutil/ParametricGeometries.js
new file mode 100644
index 000000000..25a65231c
--- /dev/null
+++ b/three/jsutil/ParametricGeometries.js
@@ -0,0 +1,263 @@
+/*
+ * @author zz85
+ *
+ * Experimenting of primitive geometry creation using Surface Parametric equations
+ *
+ */
+
+THREE.ParametricGeometries = {
+
+ klein: function ( v, u, target ) {
+
+ u *= Math.PI;
+ v *= 2 * Math.PI;
+
+ u = u * 2;
+ var x, y, z;
+ if ( u < Math.PI ) {
+
+ x = 3 * Math.cos( u ) * ( 1 + Math.sin( u ) ) + ( 2 * ( 1 - Math.cos( u ) / 2 ) ) * Math.cos( u ) * Math.cos( v );
+ z = - 8 * Math.sin( u ) - 2 * ( 1 - Math.cos( u ) / 2 ) * Math.sin( u ) * Math.cos( v );
+
+ } else {
+
+ x = 3 * Math.cos( u ) * ( 1 + Math.sin( u ) ) + ( 2 * ( 1 - Math.cos( u ) / 2 ) ) * Math.cos( v + Math.PI );
+ z = - 8 * Math.sin( u );
+
+ }
+
+ y = - 2 * ( 1 - Math.cos( u ) / 2 ) * Math.sin( v );
+
+ target.set( x, y, z );
+
+ },
+
+ plane: function ( width, height ) {
+
+ return function ( u, v, target ) {
+
+ var x = u * width;
+ var y = 0;
+ var z = v * height;
+
+ target.set( x, y, z );
+
+ };
+
+ },
+
+ mobius: function ( u, t, target ) {
+
+ // flat mobius strip
+ // http://www.wolframalpha.com/input/?i=M%C3%B6bius+strip+parametric+equations&lk=1&a=ClashPrefs_*Surface.MoebiusStrip.SurfaceProperty.ParametricEquations-
+ u = u - 0.5;
+ var v = 2 * Math.PI * t;
+
+ var x, y, z;
+
+ var a = 2;
+
+ x = Math.cos( v ) * ( a + u * Math.cos( v / 2 ) );
+ y = Math.sin( v ) * ( a + u * Math.cos( v / 2 ) );
+ z = u * Math.sin( v / 2 );
+
+ target.set( x, y, z );
+
+ },
+
+ mobius3d: function ( u, t, target ) {
+
+ // volumetric mobius strip
+
+ u *= Math.PI;
+ t *= 2 * Math.PI;
+
+ u = u * 2;
+ var phi = u / 2;
+ var major = 2.25, a = 0.125, b = 0.65;
+
+ var x, y, z;
+
+ x = a * Math.cos( t ) * Math.cos( phi ) - b * Math.sin( t ) * Math.sin( phi );
+ z = a * Math.cos( t ) * Math.sin( phi ) + b * Math.sin( t ) * Math.cos( phi );
+ y = ( major + x ) * Math.sin( u );
+ x = ( major + x ) * Math.cos( u );
+
+ target.set( x, y, z );
+
+ }
+
+};
+
+
+/*********************************************
+ *
+ * Parametric Replacement for TubeGeometry
+ *
+ *********************************************/
+
+THREE.ParametricGeometries.TubeGeometry = function ( path, segments, radius, segmentsRadius, closed, debug ) {
+
+ this.path = path;
+ this.segments = segments || 64;
+ this.radius = radius || 1;
+ this.segmentsRadius = segmentsRadius || 8;
+ this.closed = closed || false;
+ if ( debug ) this.debug = new THREE.Object3D();
+
+ var scope = this, numpoints = this.segments + 1;
+
+ var frames = path.computeFrenetFrames( segments, closed ),
+ tangents = frames.tangents,
+ normals = frames.normals,
+ binormals = frames.binormals;
+
+ // proxy internals
+
+ this.tangents = tangents;
+ this.normals = normals;
+ this.binormals = binormals;
+
+ var ParametricTube = function ( u, v, target ) {
+
+ v *= 2 * Math.PI;
+
+ var i = u * ( numpoints - 1 );
+ i = Math.floor( i );
+
+ var pos = path.getPointAt( u );
+
+ var tangent = tangents[ i ];
+ var normal = normals[ i ];
+ var binormal = binormals[ i ];
+
+ if ( scope.debug ) {
+
+ scope.debug.add( new THREE.ArrowHelper( tangent, pos, radius, 0x0000ff ) );
+ scope.debug.add( new THREE.ArrowHelper( normal, pos, radius, 0xff0000 ) );
+ scope.debug.add( new THREE.ArrowHelper( binormal, pos, radius, 0x00ff00 ) );
+
+ }
+
+ var cx = - scope.radius * Math.cos( v ); // TODO: Hack: Negating it so it faces outside.
+ var cy = scope.radius * Math.sin( v );
+
+ pos.x += cx * normal.x + cy * binormal.x;
+ pos.y += cx * normal.y + cy * binormal.y;
+ pos.z += cx * normal.z + cy * binormal.z;
+
+ target.copy( pos );
+
+ };
+
+ THREE.ParametricGeometry.call( this, ParametricTube, segments, segmentsRadius );
+
+};
+
+THREE.ParametricGeometries.TubeGeometry.prototype = Object.create( THREE.Geometry.prototype );
+THREE.ParametricGeometries.TubeGeometry.prototype.constructor = THREE.ParametricGeometries.TubeGeometry;
+
+
+/*********************************************
+ *
+ * Parametric Replacement for TorusKnotGeometry
+ *
+ *********************************************/
+THREE.ParametricGeometries.TorusKnotGeometry = function ( radius, tube, segmentsT, segmentsR, p, q ) {
+
+ this.radius = radius || 200;
+ this.tube = tube || 40;
+ this.segmentsT = segmentsT || 64;
+ this.segmentsR = segmentsR || 8;
+ this.p = p || 2;
+ this.q = q || 3;
+
+ function TorusKnotCurve() {
+
+ THREE.Curve.call( this );
+
+ }
+
+ TorusKnotCurve.prototype = Object.create( THREE.Curve.prototype );
+ TorusKnotCurve.prototype.constructor = TorusKnotCurve;
+
+ TorusKnotCurve.prototype.getPoint = function ( t, optionalTarget ) {
+
+ var point = optionalTarget || new THREE.Vector3();
+
+ t *= Math.PI * 2;
+
+ var r = 0.5;
+
+ var x = ( 1 + r * Math.cos( q * t ) ) * Math.cos( p * t );
+ var y = ( 1 + r * Math.cos( q * t ) ) * Math.sin( p * t );
+ var z = r * Math.sin( q * t );
+
+ return point.set( x, y, z ).multiplyScalar( radius );
+
+ };
+
+ var segments = segmentsT;
+ var radiusSegments = segmentsR;
+ var extrudePath = new TorusKnotCurve();
+
+ THREE.ParametricGeometries.TubeGeometry.call( this, extrudePath, segments, tube, radiusSegments, true, false );
+
+};
+
+THREE.ParametricGeometries.TorusKnotGeometry.prototype = Object.create( THREE.Geometry.prototype );
+THREE.ParametricGeometries.TorusKnotGeometry.prototype.constructor = THREE.ParametricGeometries.TorusKnotGeometry;
+
+
+/*********************************************
+ *
+ * Parametric Replacement for SphereGeometry
+ *
+ *********************************************/
+THREE.ParametricGeometries.SphereGeometry = function ( size, u, v ) {
+
+ function sphere( u, v, target ) {
+
+ u *= Math.PI;
+ v *= 2 * Math.PI;
+
+ var x = size * Math.sin( u ) * Math.cos( v );
+ var y = size * Math.sin( u ) * Math.sin( v );
+ var z = size * Math.cos( u );
+
+ target.set( x, y, z );
+
+ }
+
+ THREE.ParametricGeometry.call( this, sphere, u, v );
+
+};
+
+THREE.ParametricGeometries.SphereGeometry.prototype = Object.create( THREE.Geometry.prototype );
+THREE.ParametricGeometries.SphereGeometry.prototype.constructor = THREE.ParametricGeometries.SphereGeometry;
+
+
+/*********************************************
+ *
+ * Parametric Replacement for PlaneGeometry
+ *
+ *********************************************/
+
+THREE.ParametricGeometries.PlaneGeometry = function ( width, depth, segmentsWidth, segmentsDepth ) {
+
+ function plane( u, v, target ) {
+
+ var x = u * width;
+ var y = 0;
+ var z = v * depth;
+
+ target.set( x, y, z );
+
+ }
+
+ THREE.ParametricGeometry.call( this, plane, segmentsWidth, segmentsDepth );
+
+};
+
+THREE.ParametricGeometries.PlaneGeometry.prototype = Object.create( THREE.Geometry.prototype );
+THREE.ParametricGeometries.PlaneGeometry.prototype.constructor = THREE.ParametricGeometries.PlaneGeometry;
diff --git a/three/jsutil/QuickHull.js b/three/jsutil/QuickHull.js
new file mode 100644
index 000000000..ec9f77545
--- /dev/null
+++ b/three/jsutil/QuickHull.js
@@ -0,0 +1,1217 @@
+/**
+ * @author Mugen87 / https://github.com/Mugen87
+ *
+ * Ported from: https://github.com/maurizzzio/quickhull3d/ by Mauricio Poppe (https://github.com/maurizzzio)
+ *
+ */
+
+( function () {
+
+ var Visible = 0;
+ var Deleted = 1;
+
+ function QuickHull() {
+
+ this.tolerance = - 1;
+
+ this.faces = []; // the generated faces of the convex hull
+ this.newFaces = []; // this array holds the faces that are generated within a single iteration
+
+ // the vertex lists work as follows:
+ //
+ // let 'a' and 'b' be 'Face' instances
+ // let 'v' be points wrapped as instance of 'Vertex'
+ //
+ // [v, v, ..., v, v, v, ...]
+ // ^ ^
+ // | |
+ // a.outside b.outside
+ //
+ this.assigned = new VertexList();
+ this.unassigned = new VertexList();
+
+ this.vertices = []; // vertices of the hull (internal representation of given geometry data)
+
+ }
+
+ Object.assign( QuickHull.prototype, {
+
+ setFromPoints: function ( points ) {
+
+ if ( Array.isArray( points ) !== true ) {
+
+ console.error( 'THREE.QuickHull: Points parameter is not an array.' );
+
+ }
+
+ if ( points.length < 4 ) {
+
+ console.error( 'THREE.QuickHull: The algorithm needs at least four points.' );
+
+ }
+
+ this.makeEmpty();
+
+ for ( var i = 0, l = points.length; i < l; i ++ ) {
+
+ this.vertices.push( new VertexNode( points[ i ] ) );
+
+ }
+
+ this.compute();
+
+ return this;
+
+ },
+
+ setFromObject: function ( object ) {
+
+ var points = [];
+
+ object.updateMatrixWorld( true );
+
+ object.traverse( function ( node ) {
+
+ var i, l, point;
+
+ var geometry = node.geometry;
+
+ if ( geometry !== undefined ) {
+
+ if ( geometry.isGeometry ) {
+
+ var vertices = geometry.vertices;
+
+ for ( i = 0, l = vertices.length; i < l; i ++ ) {
+
+ point = vertices[ i ].clone();
+ point.applyMatrix4( node.matrixWorld );
+
+ points.push( point );
+
+ }
+
+ } else if ( geometry.isBufferGeometry ) {
+
+ var attribute = geometry.attributes.position;
+
+ if ( attribute !== undefined ) {
+
+ for ( i = 0, l = attribute.count; i < l; i ++ ) {
+
+ point = new THREE.Vector3();
+
+ point.fromBufferAttribute( attribute, i ).applyMatrix4( node.matrixWorld );
+
+ points.push( point );
+
+ }
+
+ }
+
+ }
+
+ }
+
+ } );
+
+ return this.setFromPoints( points );
+
+ },
+
+ makeEmpty: function () {
+
+ this.faces = [];
+ this.vertices = [];
+
+ return this;
+
+ },
+
+ // Adds a vertex to the 'assigned' list of vertices and assigns it to the given face
+
+ addVertexToFace: function ( vertex, face ) {
+
+ vertex.face = face;
+
+ if ( face.outside === null ) {
+
+ this.assigned.append( vertex );
+
+ } else {
+
+ this.assigned.insertBefore( face.outside, vertex );
+
+ }
+
+ face.outside = vertex;
+
+ return this;
+
+ },
+
+ // Removes a vertex from the 'assigned' list of vertices and from the given face
+
+ removeVertexFromFace: function ( vertex, face ) {
+
+ if ( vertex === face.outside ) {
+
+ // fix face.outside link
+
+ if ( vertex.next !== null && vertex.next.face === face ) {
+
+ // face has at least 2 outside vertices, move the 'outside' reference
+
+ face.outside = vertex.next;
+
+ } else {
+
+ // vertex was the only outside vertex that face had
+
+ face.outside = null;
+
+ }
+
+ }
+
+ this.assigned.remove( vertex );
+
+ return this;
+
+ },
+
+ // Removes all the visible vertices that a given face is able to see which are stored in the 'assigned' vertext list
+
+ removeAllVerticesFromFace: function ( face ) {
+
+ if ( face.outside !== null ) {
+
+ // reference to the first and last vertex of this face
+
+ var start = face.outside;
+ var end = face.outside;
+
+ while ( end.next !== null && end.next.face === face ) {
+
+ end = end.next;
+
+ }
+
+ this.assigned.removeSubList( start, end );
+
+ // fix references
+
+ start.prev = end.next = null;
+ face.outside = null;
+
+ return start;
+
+ }
+
+ },
+
+ // Removes all the visible vertices that 'face' is able to see
+
+ deleteFaceVertices: function ( face, absorbingFace ) {
+
+ var faceVertices = this.removeAllVerticesFromFace( face );
+
+ if ( faceVertices !== undefined ) {
+
+ if ( absorbingFace === undefined ) {
+
+ // mark the vertices to be reassigned to some other face
+
+ this.unassigned.appendChain( faceVertices );
+
+
+ } else {
+
+ // if there's an absorbing face try to assign as many vertices as possible to it
+
+ var vertex = faceVertices;
+
+ do {
+
+ // we need to buffer the subsequent vertex at this point because the 'vertex.next' reference
+ // will be changed by upcoming method calls
+
+ var nextVertex = vertex.next;
+
+ var distance = absorbingFace.distanceToPoint( vertex.point );
+
+ // check if 'vertex' is able to see 'absorbingFace'
+
+ if ( distance > this.tolerance ) {
+
+ this.addVertexToFace( vertex, absorbingFace );
+
+ } else {
+
+ this.unassigned.append( vertex );
+
+ }
+
+ // now assign next vertex
+
+ vertex = nextVertex;
+
+ } while ( vertex !== null );
+
+ }
+
+ }
+
+ return this;
+
+ },
+
+ // Reassigns as many vertices as possible from the unassigned list to the new faces
+
+ resolveUnassignedPoints: function ( newFaces ) {
+
+ if ( this.unassigned.isEmpty() === false ) {
+
+ var vertex = this.unassigned.first();
+
+ do {
+
+ // buffer 'next' reference, see .deleteFaceVertices()
+
+ var nextVertex = vertex.next;
+
+ var maxDistance = this.tolerance;
+
+ var maxFace = null;
+
+ for ( var i = 0; i < newFaces.length; i ++ ) {
+
+ var face = newFaces[ i ];
+
+ if ( face.mark === Visible ) {
+
+ var distance = face.distanceToPoint( vertex.point );
+
+ if ( distance > maxDistance ) {
+
+ maxDistance = distance;
+ maxFace = face;
+
+ }
+
+ if ( maxDistance > 1000 * this.tolerance ) break;
+
+ }
+
+ }
+
+ // 'maxFace' can be null e.g. if there are identical vertices
+
+ if ( maxFace !== null ) {
+
+ this.addVertexToFace( vertex, maxFace );
+
+ }
+
+ vertex = nextVertex;
+
+ } while ( vertex !== null );
+
+ }
+
+ return this;
+
+ },
+
+ // Computes the extremes of a simplex which will be the initial hull
+
+ computeExtremes: function () {
+
+ var min = new THREE.Vector3();
+ var max = new THREE.Vector3();
+
+ var minVertices = [];
+ var maxVertices = [];
+
+ var i, l, j;
+
+ // initially assume that the first vertex is the min/max
+
+ for ( i = 0; i < 3; i ++ ) {
+
+ minVertices[ i ] = maxVertices[ i ] = this.vertices[ 0 ];
+
+ }
+
+ min.copy( this.vertices[ 0 ].point );
+ max.copy( this.vertices[ 0 ].point );
+
+ // compute the min/max vertex on all six directions
+
+ for ( i = 0, l = this.vertices.length; i < l; i ++ ) {
+
+ var vertex = this.vertices[ i ];
+ var point = vertex.point;
+
+ // update the min coordinates
+
+ for ( j = 0; j < 3; j ++ ) {
+
+ if ( point.getComponent( j ) < min.getComponent( j ) ) {
+
+ min.setComponent( j, point.getComponent( j ) );
+ minVertices[ j ] = vertex;
+
+ }
+
+ }
+
+ // update the max coordinates
+
+ for ( j = 0; j < 3; j ++ ) {
+
+ if ( point.getComponent( j ) > max.getComponent( j ) ) {
+
+ max.setComponent( j, point.getComponent( j ) );
+ maxVertices[ j ] = vertex;
+
+ }
+
+ }
+
+ }
+
+ // use min/max vectors to compute an optimal epsilon
+
+ this.tolerance = 3 * Number.EPSILON * (
+ Math.max( Math.abs( min.x ), Math.abs( max.x ) ) +
+ Math.max( Math.abs( min.y ), Math.abs( max.y ) ) +
+ Math.max( Math.abs( min.z ), Math.abs( max.z ) )
+ );
+
+ return { min: minVertices, max: maxVertices };
+
+ },
+
+ // Computes the initial simplex assigning to its faces all the points
+ // that are candidates to form part of the hull
+
+ computeInitialHull: function () {
+
+ var line3, plane, closestPoint;
+
+ return function computeInitialHull() {
+
+ if ( line3 === undefined ) {
+
+ line3 = new THREE.Line3();
+ plane = new THREE.Plane();
+ closestPoint = new THREE.Vector3();
+
+ }
+
+ var vertex, vertices = this.vertices;
+ var extremes = this.computeExtremes();
+ var min = extremes.min;
+ var max = extremes.max;
+
+ var v0, v1, v2, v3;
+ var i, l, j;
+
+ // 1. Find the two vertices 'v0' and 'v1' with the greatest 1d separation
+ // (max.x - min.x)
+ // (max.y - min.y)
+ // (max.z - min.z)
+
+ var distance, maxDistance = 0;
+ var index = 0;
+
+ for ( i = 0; i < 3; i ++ ) {
+
+ distance = max[ i ].point.getComponent( i ) - min[ i ].point.getComponent( i );
+
+ if ( distance > maxDistance ) {
+
+ maxDistance = distance;
+ index = i;
+
+ }
+
+ }
+
+ v0 = min[ index ];
+ v1 = max[ index ];
+
+ // 2. The next vertex 'v2' is the one farthest to the line formed by 'v0' and 'v1'
+
+ maxDistance = 0;
+ line3.set( v0.point, v1.point );
+
+ for ( i = 0, l = this.vertices.length; i < l; i ++ ) {
+
+ vertex = vertices[ i ];
+
+ if ( vertex !== v0 && vertex !== v1 ) {
+
+ line3.closestPointToPoint( vertex.point, true, closestPoint );
+
+ distance = closestPoint.distanceToSquared( vertex.point );
+
+ if ( distance > maxDistance ) {
+
+ maxDistance = distance;
+ v2 = vertex;
+
+ }
+
+ }
+
+ }
+
+ // 3. The next vertex 'v3' is the one farthest to the plane 'v0', 'v1', 'v2'
+
+ maxDistance = - 1;
+ plane.setFromCoplanarPoints( v0.point, v1.point, v2.point );
+
+ for ( i = 0, l = this.vertices.length; i < l; i ++ ) {
+
+ vertex = vertices[ i ];
+
+ if ( vertex !== v0 && vertex !== v1 && vertex !== v2 ) {
+
+ distance = Math.abs( plane.distanceToPoint( vertex.point ) );
+
+ if ( distance > maxDistance ) {
+
+ maxDistance = distance;
+ v3 = vertex;
+
+ }
+
+ }
+
+ }
+
+ var faces = [];
+
+ if ( plane.distanceToPoint( v3.point ) < 0 ) {
+
+ // the face is not able to see the point so 'plane.normal' is pointing outside the tetrahedron
+
+ faces.push(
+ Face.create( v0, v1, v2 ),
+ Face.create( v3, v1, v0 ),
+ Face.create( v3, v2, v1 ),
+ Face.create( v3, v0, v2 )
+ );
+
+ // set the twin edge
+
+ for ( i = 0; i < 3; i ++ ) {
+
+ j = ( i + 1 ) % 3;
+
+ // join face[ i ] i > 0, with the first face
+
+ faces[ i + 1 ].getEdge( 2 ).setTwin( faces[ 0 ].getEdge( j ) );
+
+ // join face[ i ] with face[ i + 1 ], 1 <= i <= 3
+
+ faces[ i + 1 ].getEdge( 1 ).setTwin( faces[ j + 1 ].getEdge( 0 ) );
+
+ }
+
+ } else {
+
+ // the face is able to see the point so 'plane.normal' is pointing inside the tetrahedron
+
+ faces.push(
+ Face.create( v0, v2, v1 ),
+ Face.create( v3, v0, v1 ),
+ Face.create( v3, v1, v2 ),
+ Face.create( v3, v2, v0 )
+ );
+
+ // set the twin edge
+
+ for ( i = 0; i < 3; i ++ ) {
+
+ j = ( i + 1 ) % 3;
+
+ // join face[ i ] i > 0, with the first face
+
+ faces[ i + 1 ].getEdge( 2 ).setTwin( faces[ 0 ].getEdge( ( 3 - i ) % 3 ) );
+
+ // join face[ i ] with face[ i + 1 ]
+
+ faces[ i + 1 ].getEdge( 0 ).setTwin( faces[ j + 1 ].getEdge( 1 ) );
+
+ }
+
+ }
+
+ // the initial hull is the tetrahedron
+
+ for ( i = 0; i < 4; i ++ ) {
+
+ this.faces.push( faces[ i ] );
+
+ }
+
+ // initial assignment of vertices to the faces of the tetrahedron
+
+ for ( i = 0, l = vertices.length; i < l; i ++ ) {
+
+ vertex = vertices[ i ];
+
+ if ( vertex !== v0 && vertex !== v1 && vertex !== v2 && vertex !== v3 ) {
+
+ maxDistance = this.tolerance;
+ var maxFace = null;
+
+ for ( j = 0; j < 4; j ++ ) {
+
+ distance = this.faces[ j ].distanceToPoint( vertex.point );
+
+ if ( distance > maxDistance ) {
+
+ maxDistance = distance;
+ maxFace = this.faces[ j ];
+
+ }
+
+ }
+
+ if ( maxFace !== null ) {
+
+ this.addVertexToFace( vertex, maxFace );
+
+ }
+
+ }
+
+ }
+
+ return this;
+
+ };
+
+ }(),
+
+ // Removes inactive faces
+
+ reindexFaces: function () {
+
+ var activeFaces = [];
+
+ for ( var i = 0; i < this.faces.length; i ++ ) {
+
+ var face = this.faces[ i ];
+
+ if ( face.mark === Visible ) {
+
+ activeFaces.push( face );
+
+ }
+
+ }
+
+ this.faces = activeFaces;
+
+ return this;
+
+ },
+
+ // Finds the next vertex to create faces with the current hull
+
+ nextVertexToAdd: function () {
+
+ // if the 'assigned' list of vertices is empty, no vertices are left. return with 'undefined'
+
+ if ( this.assigned.isEmpty() === false ) {
+
+ var eyeVertex, maxDistance = 0;
+
+ // grap the first available face and start with the first visible vertex of that face
+
+ var eyeFace = this.assigned.first().face;
+ var vertex = eyeFace.outside;
+
+ // now calculate the farthest vertex that face can see
+
+ do {
+
+ var distance = eyeFace.distanceToPoint( vertex.point );
+
+ if ( distance > maxDistance ) {
+
+ maxDistance = distance;
+ eyeVertex = vertex;
+
+ }
+
+ vertex = vertex.next;
+
+ } while ( vertex !== null && vertex.face === eyeFace );
+
+ return eyeVertex;
+
+ }
+
+ },
+
+ // Computes a chain of half edges in CCW order called the 'horizon'.
+ // For an edge to be part of the horizon it must join a face that can see
+ // 'eyePoint' and a face that cannot see 'eyePoint'.
+
+ computeHorizon: function ( eyePoint, crossEdge, face, horizon ) {
+
+ // moves face's vertices to the 'unassigned' vertex list
+
+ this.deleteFaceVertices( face );
+
+ face.mark = Deleted;
+
+ var edge;
+
+ if ( crossEdge === null ) {
+
+ edge = crossEdge = face.getEdge( 0 );
+
+ } else {
+
+ // start from the next edge since 'crossEdge' was already analyzed
+ // (actually 'crossEdge.twin' was the edge who called this method recursively)
+
+ edge = crossEdge.next;
+
+ }
+
+ do {
+
+ var twinEdge = edge.twin;
+ var oppositeFace = twinEdge.face;
+
+ if ( oppositeFace.mark === Visible ) {
+
+ if ( oppositeFace.distanceToPoint( eyePoint ) > this.tolerance ) {
+
+ // the opposite face can see the vertex, so proceed with next edge
+
+ this.computeHorizon( eyePoint, twinEdge, oppositeFace, horizon );
+
+ } else {
+
+ // the opposite face can't see the vertex, so this edge is part of the horizon
+
+ horizon.push( edge );
+
+ }
+
+ }
+
+ edge = edge.next;
+
+ } while ( edge !== crossEdge );
+
+ return this;
+
+ },
+
+ // Creates a face with the vertices 'eyeVertex.point', 'horizonEdge.tail' and 'horizonEdge.head' in CCW order
+
+ addAdjoiningFace: function ( eyeVertex, horizonEdge ) {
+
+ // all the half edges are created in ccw order thus the face is always pointing outside the hull
+
+ var face = Face.create( eyeVertex, horizonEdge.tail(), horizonEdge.head() );
+
+ this.faces.push( face );
+
+ // join face.getEdge( - 1 ) with the horizon's opposite edge face.getEdge( - 1 ) = face.getEdge( 2 )
+
+ face.getEdge( - 1 ).setTwin( horizonEdge.twin );
+
+ return face.getEdge( 0 ); // the half edge whose vertex is the eyeVertex
+
+
+ },
+
+ // Adds 'horizon.length' faces to the hull, each face will be linked with the
+ // horizon opposite face and the face on the left/right
+
+ addNewFaces: function ( eyeVertex, horizon ) {
+
+ this.newFaces = [];
+
+ var firstSideEdge = null;
+ var previousSideEdge = null;
+
+ for ( var i = 0; i < horizon.length; i ++ ) {
+
+ var horizonEdge = horizon[ i ];
+
+ // returns the right side edge
+
+ var sideEdge = this.addAdjoiningFace( eyeVertex, horizonEdge );
+
+ if ( firstSideEdge === null ) {
+
+ firstSideEdge = sideEdge;
+
+ } else {
+
+ // joins face.getEdge( 1 ) with previousFace.getEdge( 0 )
+
+ sideEdge.next.setTwin( previousSideEdge );
+
+ }
+
+ this.newFaces.push( sideEdge.face );
+ previousSideEdge = sideEdge;
+
+ }
+
+ // perform final join of new faces
+
+ firstSideEdge.next.setTwin( previousSideEdge );
+
+ return this;
+
+ },
+
+ // Adds a vertex to the hull
+
+ addVertexToHull: function ( eyeVertex ) {
+
+ var horizon = [];
+
+ this.unassigned.clear();
+
+ // remove 'eyeVertex' from 'eyeVertex.face' so that it can't be added to the 'unassigned' vertex list
+
+ this.removeVertexFromFace( eyeVertex, eyeVertex.face );
+
+ this.computeHorizon( eyeVertex.point, null, eyeVertex.face, horizon );
+
+ this.addNewFaces( eyeVertex, horizon );
+
+ // reassign 'unassigned' vertices to the new faces
+
+ this.resolveUnassignedPoints( this.newFaces );
+
+ return this;
+
+ },
+
+ cleanup: function () {
+
+ this.assigned.clear();
+ this.unassigned.clear();
+ this.newFaces = [];
+
+ return this;
+
+ },
+
+ compute: function () {
+
+ var vertex;
+
+ this.computeInitialHull();
+
+ // add all available vertices gradually to the hull
+
+ while ( ( vertex = this.nextVertexToAdd() ) !== undefined ) {
+
+ this.addVertexToHull( vertex );
+
+ }
+
+ this.reindexFaces();
+
+ this.cleanup();
+
+ return this;
+
+ }
+
+ } );
+
+ //
+
+ function Face() {
+
+ this.normal = new THREE.Vector3();
+ this.midpoint = new THREE.Vector3();
+ this.area = 0;
+
+ this.constant = 0; // signed distance from face to the origin
+ this.outside = null; // reference to a vertex in a vertex list this face can see
+ this.mark = Visible;
+ this.edge = null;
+
+ }
+
+ Object.assign( Face, {
+
+ create: function ( a, b, c ) {
+
+ var face = new Face();
+
+ var e0 = new HalfEdge( a, face );
+ var e1 = new HalfEdge( b, face );
+ var e2 = new HalfEdge( c, face );
+
+ // join edges
+
+ e0.next = e2.prev = e1;
+ e1.next = e0.prev = e2;
+ e2.next = e1.prev = e0;
+
+ // main half edge reference
+
+ face.edge = e0;
+
+ return face.compute();
+
+ }
+
+ } );
+
+ Object.assign( Face.prototype, {
+
+ getEdge: function ( i ) {
+
+ var edge = this.edge;
+
+ while ( i > 0 ) {
+
+ edge = edge.next;
+ i --;
+
+ }
+
+ while ( i < 0 ) {
+
+ edge = edge.prev;
+ i ++;
+
+ }
+
+ return edge;
+
+ },
+
+ compute: function () {
+
+ var triangle;
+
+ return function compute() {
+
+ if ( triangle === undefined ) triangle = new THREE.Triangle();
+
+ var a = this.edge.tail();
+ var b = this.edge.head();
+ var c = this.edge.next.head();
+
+ triangle.set( a.point, b.point, c.point );
+
+ triangle.getNormal( this.normal );
+ triangle.getMidpoint( this.midpoint );
+ this.area = triangle.getArea();
+
+ this.constant = this.normal.dot( this.midpoint );
+
+ return this;
+
+ };
+
+ }(),
+
+ distanceToPoint: function ( point ) {
+
+ return this.normal.dot( point ) - this.constant;
+
+ }
+
+ } );
+
+ // Entity for a Doubly-Connected Edge List (DCEL).
+
+ function HalfEdge( vertex, face ) {
+
+ this.vertex = vertex;
+ this.prev = null;
+ this.next = null;
+ this.twin = null;
+ this.face = face;
+
+ }
+
+ Object.assign( HalfEdge.prototype, {
+
+ head: function () {
+
+ return this.vertex;
+
+ },
+
+ tail: function () {
+
+ return this.prev ? this.prev.vertex : null;
+
+ },
+
+ length: function () {
+
+ var head = this.head();
+ var tail = this.tail();
+
+ if ( tail !== null ) {
+
+ return tail.point.distanceTo( head.point );
+
+ }
+
+ return - 1;
+
+ },
+
+ lengthSquared: function () {
+
+ var head = this.head();
+ var tail = this.tail();
+
+ if ( tail !== null ) {
+
+ return tail.point.distanceToSquared( head.point );
+
+ }
+
+ return - 1;
+
+ },
+
+ setTwin: function ( edge ) {
+
+ this.twin = edge;
+ edge.twin = this;
+
+ return this;
+
+ }
+
+ } );
+
+ // A vertex as a double linked list node.
+
+ function VertexNode( point ) {
+
+ this.point = point;
+ this.prev = null;
+ this.next = null;
+ this.face = null; // the face that is able to see this vertex
+
+ }
+
+ // A double linked list that contains vertex nodes.
+
+ function VertexList() {
+
+ this.head = null;
+ this.tail = null;
+
+ }
+
+ Object.assign( VertexList.prototype, {
+
+ first: function () {
+
+ return this.head;
+
+ },
+
+ last: function () {
+
+ return this.tail;
+
+ },
+
+ clear: function () {
+
+ this.head = this.tail = null;
+
+ return this;
+
+ },
+
+ // Inserts a vertex before the target vertex
+
+ insertBefore: function ( target, vertex ) {
+
+ vertex.prev = target.prev;
+ vertex.next = target;
+
+ if ( vertex.prev === null ) {
+
+ this.head = vertex;
+
+ } else {
+
+ vertex.prev.next = vertex;
+
+ }
+
+ target.prev = vertex;
+
+ return this;
+
+ },
+
+ // Inserts a vertex after the target vertex
+
+ insertAfter: function ( target, vertex ) {
+
+ vertex.prev = target;
+ vertex.next = target.next;
+
+ if ( vertex.next === null ) {
+
+ this.tail = vertex;
+
+ } else {
+
+ vertex.next.prev = vertex;
+
+ }
+
+ target.next = vertex;
+
+ return this;
+
+ },
+
+ // Appends a vertex to the end of the linked list
+
+ append: function ( vertex ) {
+
+ if ( this.head === null ) {
+
+ this.head = vertex;
+
+ } else {
+
+ this.tail.next = vertex;
+
+ }
+
+ vertex.prev = this.tail;
+ vertex.next = null; // the tail has no subsequent vertex
+
+ this.tail = vertex;
+
+ return this;
+
+ },
+
+ // Appends a chain of vertices where 'vertex' is the head.
+
+ appendChain: function ( vertex ) {
+
+ if ( this.head === null ) {
+
+ this.head = vertex;
+
+ } else {
+
+ this.tail.next = vertex;
+
+ }
+
+ vertex.prev = this.tail;
+
+ // ensure that the 'tail' reference points to the last vertex of the chain
+
+ while ( vertex.next !== null ) {
+
+ vertex = vertex.next;
+
+ }
+
+ this.tail = vertex;
+
+ return this;
+
+ },
+
+ // Removes a vertex from the linked list
+
+ remove: function ( vertex ) {
+
+ if ( vertex.prev === null ) {
+
+ this.head = vertex.next;
+
+ } else {
+
+ vertex.prev.next = vertex.next;
+
+ }
+
+ if ( vertex.next === null ) {
+
+ this.tail = vertex.prev;
+
+ } else {
+
+ vertex.next.prev = vertex.prev;
+
+ }
+
+ return this;
+
+ },
+
+ // Removes a list of vertices whose 'head' is 'a' and whose 'tail' is b
+
+ removeSubList: function ( a, b ) {
+
+ if ( a.prev === null ) {
+
+ this.head = b.next;
+
+ } else {
+
+ a.prev.next = b.next;
+
+ }
+
+ if ( b.next === null ) {
+
+ this.tail = a.prev;
+
+ } else {
+
+ b.next.prev = a.prev;
+
+ }
+
+ return this;
+
+ },
+
+ isEmpty: function () {
+
+ return this.head === null;
+
+ }
+
+ } );
+
+ // export
+
+ THREE.QuickHull = QuickHull;
+
+
+} )();
diff --git a/three/jsutil/RollerCoaster.js b/three/jsutil/RollerCoaster.js
new file mode 100644
index 000000000..95538b99a
--- /dev/null
+++ b/three/jsutil/RollerCoaster.js
@@ -0,0 +1,544 @@
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+function RollerCoasterGeometry( curve, divisions ) {
+
+ THREE.BufferGeometry.call( this );
+
+ var vertices = [];
+ var normals = [];
+ var colors = [];
+
+ var color1 = [ 1, 1, 1 ];
+ var color2 = [ 1, 1, 0 ];
+
+ var up = new THREE.Vector3( 0, 1, 0 );
+ var forward = new THREE.Vector3();
+ var right = new THREE.Vector3();
+
+ var quaternion = new THREE.Quaternion();
+ var prevQuaternion = new THREE.Quaternion();
+ prevQuaternion.setFromAxisAngle( up, Math.PI / 2 );
+
+ var point = new THREE.Vector3();
+ var prevPoint = new THREE.Vector3();
+ prevPoint.copy( curve.getPointAt( 0 ) );
+
+ // shapes
+
+ var step = [
+ new THREE.Vector3( - 0.225, 0, 0 ),
+ new THREE.Vector3( 0, - 0.050, 0 ),
+ new THREE.Vector3( 0, - 0.175, 0 ),
+
+ new THREE.Vector3( 0, - 0.050, 0 ),
+ new THREE.Vector3( 0.225, 0, 0 ),
+ new THREE.Vector3( 0, - 0.175, 0 )
+ ];
+
+ var PI2 = Math.PI * 2;
+
+ var sides = 5;
+ var tube1 = [];
+
+ for ( var i = 0; i < sides; i ++ ) {
+
+ var angle = ( i / sides ) * PI2;
+ tube1.push( new THREE.Vector3( Math.sin( angle ) * 0.06, Math.cos( angle ) * 0.06, 0 ) );
+
+ }
+
+ var sides = 6;
+ var tube2 = [];
+
+ for ( var i = 0; i < sides; i ++ ) {
+
+ var angle = ( i / sides ) * PI2;
+ tube2.push( new THREE.Vector3( Math.sin( angle ) * 0.025, Math.cos( angle ) * 0.025, 0 ) );
+
+ }
+
+ var vector = new THREE.Vector3();
+ var normal = new THREE.Vector3();
+
+ function drawShape( shape, color ) {
+
+ normal.set( 0, 0, - 1 ).applyQuaternion( quaternion );
+
+ for ( var j = 0; j < shape.length; j ++ ) {
+
+ vector.copy( shape[ j ] );
+ vector.applyQuaternion( quaternion );
+ vector.add( point );
+
+ vertices.push( vector.x, vector.y, vector.z );
+ normals.push( normal.x, normal.y, normal.z );
+ colors.push( color[ 0 ], color[ 1 ], color[ 2 ] );
+
+ }
+
+ normal.set( 0, 0, 1 ).applyQuaternion( quaternion );
+
+ for ( var j = shape.length - 1; j >= 0; j -- ) {
+
+ vector.copy( shape[ j ] );
+ vector.applyQuaternion( quaternion );
+ vector.add( point );
+
+ vertices.push( vector.x, vector.y, vector.z );
+ normals.push( normal.x, normal.y, normal.z );
+ colors.push( color[ 0 ], color[ 1 ], color[ 2 ] );
+
+ }
+
+ }
+
+ var vector1 = new THREE.Vector3();
+ var vector2 = new THREE.Vector3();
+ var vector3 = new THREE.Vector3();
+ var vector4 = new THREE.Vector3();
+
+ var normal1 = new THREE.Vector3();
+ var normal2 = new THREE.Vector3();
+ var normal3 = new THREE.Vector3();
+ var normal4 = new THREE.Vector3();
+
+ function extrudeShape( shape, offset, color ) {
+
+ for ( var j = 0, jl = shape.length; j < jl; j ++ ) {
+
+ var point1 = shape[ j ];
+ var point2 = shape[ ( j + 1 ) % jl ];
+
+ vector1.copy( point1 ).add( offset );
+ vector1.applyQuaternion( quaternion );
+ vector1.add( point );
+
+ vector2.copy( point2 ).add( offset );
+ vector2.applyQuaternion( quaternion );
+ vector2.add( point );
+
+ vector3.copy( point2 ).add( offset );
+ vector3.applyQuaternion( prevQuaternion );
+ vector3.add( prevPoint );
+
+ vector4.copy( point1 ).add( offset );
+ vector4.applyQuaternion( prevQuaternion );
+ vector4.add( prevPoint );
+
+ vertices.push( vector1.x, vector1.y, vector1.z );
+ vertices.push( vector2.x, vector2.y, vector2.z );
+ vertices.push( vector4.x, vector4.y, vector4.z );
+
+ vertices.push( vector2.x, vector2.y, vector2.z );
+ vertices.push( vector3.x, vector3.y, vector3.z );
+ vertices.push( vector4.x, vector4.y, vector4.z );
+
+ //
+
+ normal1.copy( point1 );
+ normal1.applyQuaternion( quaternion );
+ normal1.normalize();
+
+ normal2.copy( point2 );
+ normal2.applyQuaternion( quaternion );
+ normal2.normalize();
+
+ normal3.copy( point2 );
+ normal3.applyQuaternion( prevQuaternion );
+ normal3.normalize();
+
+ normal4.copy( point1 );
+ normal4.applyQuaternion( prevQuaternion );
+ normal4.normalize();
+
+ normals.push( normal1.x, normal1.y, normal1.z );
+ normals.push( normal2.x, normal2.y, normal2.z );
+ normals.push( normal4.x, normal4.y, normal4.z );
+
+ normals.push( normal2.x, normal2.y, normal2.z );
+ normals.push( normal3.x, normal3.y, normal3.z );
+ normals.push( normal4.x, normal4.y, normal4.z );
+
+ colors.push( color[ 0 ], color[ 1 ], color[ 2 ] );
+ colors.push( color[ 0 ], color[ 1 ], color[ 2 ] );
+ colors.push( color[ 0 ], color[ 1 ], color[ 2 ] );
+
+ colors.push( color[ 0 ], color[ 1 ], color[ 2 ] );
+ colors.push( color[ 0 ], color[ 1 ], color[ 2 ] );
+ colors.push( color[ 0 ], color[ 1 ], color[ 2 ] );
+
+ }
+
+ }
+
+ var offset = new THREE.Vector3();
+
+ for ( var i = 1; i <= divisions; i ++ ) {
+
+ point.copy( curve.getPointAt( i / divisions ) );
+
+ up.set( 0, 1, 0 );
+
+ forward.subVectors( point, prevPoint ).normalize();
+ right.crossVectors( up, forward ).normalize();
+ up.crossVectors( forward, right );
+
+ var angle = Math.atan2( forward.x, forward.z );
+
+ quaternion.setFromAxisAngle( up, angle );
+
+ if ( i % 2 === 0 ) {
+
+ drawShape( step, color2 );
+
+ }
+
+ extrudeShape( tube1, offset.set( 0, - 0.125, 0 ), color2 );
+ extrudeShape( tube2, offset.set( 0.2, 0, 0 ), color1 );
+ extrudeShape( tube2, offset.set( - 0.2, 0, 0 ), color1 );
+
+ prevPoint.copy( point );
+ prevQuaternion.copy( quaternion );
+
+ }
+
+ // console.log( vertices.length );
+
+ this.addAttribute( 'position', new THREE.BufferAttribute( new Float32Array( vertices ), 3 ) );
+ this.addAttribute( 'normal', new THREE.BufferAttribute( new Float32Array( normals ), 3 ) );
+ this.addAttribute( 'color', new THREE.BufferAttribute( new Float32Array( colors ), 3 ) );
+
+}
+
+RollerCoasterGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
+
+function RollerCoasterLiftersGeometry( curve, divisions ) {
+
+ THREE.BufferGeometry.call( this );
+
+ var vertices = [];
+ var normals = [];
+
+ var quaternion = new THREE.Quaternion();
+
+ var up = new THREE.Vector3( 0, 1, 0 );
+
+ var point = new THREE.Vector3();
+ var tangent = new THREE.Vector3();
+
+ // shapes
+
+ var tube1 = [
+ new THREE.Vector3( 0, 0.05, - 0.05 ),
+ new THREE.Vector3( 0, 0.05, 0.05 ),
+ new THREE.Vector3( 0, - 0.05, 0 )
+ ];
+
+ var tube2 = [
+ new THREE.Vector3( - 0.05, 0, 0.05 ),
+ new THREE.Vector3( - 0.05, 0, - 0.05 ),
+ new THREE.Vector3( 0.05, 0, 0 )
+ ];
+
+ var tube3 = [
+ new THREE.Vector3( 0.05, 0, - 0.05 ),
+ new THREE.Vector3( 0.05, 0, 0.05 ),
+ new THREE.Vector3( - 0.05, 0, 0 )
+ ];
+
+ var vector1 = new THREE.Vector3();
+ var vector2 = new THREE.Vector3();
+ var vector3 = new THREE.Vector3();
+ var vector4 = new THREE.Vector3();
+
+ var normal1 = new THREE.Vector3();
+ var normal2 = new THREE.Vector3();
+ var normal3 = new THREE.Vector3();
+ var normal4 = new THREE.Vector3();
+
+ function extrudeShape( shape, fromPoint, toPoint ) {
+
+ for ( var j = 0, jl = shape.length; j < jl; j ++ ) {
+
+ var point1 = shape[ j ];
+ var point2 = shape[ ( j + 1 ) % jl ];
+
+ vector1.copy( point1 );
+ vector1.applyQuaternion( quaternion );
+ vector1.add( fromPoint );
+
+ vector2.copy( point2 );
+ vector2.applyQuaternion( quaternion );
+ vector2.add( fromPoint );
+
+ vector3.copy( point2 );
+ vector3.applyQuaternion( quaternion );
+ vector3.add( toPoint );
+
+ vector4.copy( point1 );
+ vector4.applyQuaternion( quaternion );
+ vector4.add( toPoint );
+
+ vertices.push( vector1.x, vector1.y, vector1.z );
+ vertices.push( vector2.x, vector2.y, vector2.z );
+ vertices.push( vector4.x, vector4.y, vector4.z );
+
+ vertices.push( vector2.x, vector2.y, vector2.z );
+ vertices.push( vector3.x, vector3.y, vector3.z );
+ vertices.push( vector4.x, vector4.y, vector4.z );
+
+ //
+
+ normal1.copy( point1 );
+ normal1.applyQuaternion( quaternion );
+ normal1.normalize();
+
+ normal2.copy( point2 );
+ normal2.applyQuaternion( quaternion );
+ normal2.normalize();
+
+ normal3.copy( point2 );
+ normal3.applyQuaternion( quaternion );
+ normal3.normalize();
+
+ normal4.copy( point1 );
+ normal4.applyQuaternion( quaternion );
+ normal4.normalize();
+
+ normals.push( normal1.x, normal1.y, normal1.z );
+ normals.push( normal2.x, normal2.y, normal2.z );
+ normals.push( normal4.x, normal4.y, normal4.z );
+
+ normals.push( normal2.x, normal2.y, normal2.z );
+ normals.push( normal3.x, normal3.y, normal3.z );
+ normals.push( normal4.x, normal4.y, normal4.z );
+
+ }
+
+ }
+
+ var fromPoint = new THREE.Vector3();
+ var toPoint = new THREE.Vector3();
+
+ for ( var i = 1; i <= divisions; i ++ ) {
+
+ point.copy( curve.getPointAt( i / divisions ) );
+ tangent.copy( curve.getTangentAt( i / divisions ) );
+
+ var angle = Math.atan2( tangent.x, tangent.z );
+
+ quaternion.setFromAxisAngle( up, angle );
+
+ //
+
+ if ( point.y > 10 ) {
+
+ fromPoint.set( - 0.75, - 0.35, 0 );
+ fromPoint.applyQuaternion( quaternion );
+ fromPoint.add( point );
+
+ toPoint.set( 0.75, - 0.35, 0 );
+ toPoint.applyQuaternion( quaternion );
+ toPoint.add( point );
+
+ extrudeShape( tube1, fromPoint, toPoint );
+
+ fromPoint.set( - 0.7, - 0.3, 0 );
+ fromPoint.applyQuaternion( quaternion );
+ fromPoint.add( point );
+
+ toPoint.set( - 0.7, - point.y, 0 );
+ toPoint.applyQuaternion( quaternion );
+ toPoint.add( point );
+
+ extrudeShape( tube2, fromPoint, toPoint );
+
+ fromPoint.set( 0.7, - 0.3, 0 );
+ fromPoint.applyQuaternion( quaternion );
+ fromPoint.add( point );
+
+ toPoint.set( 0.7, - point.y, 0 );
+ toPoint.applyQuaternion( quaternion );
+ toPoint.add( point );
+
+ extrudeShape( tube3, fromPoint, toPoint );
+
+ } else {
+
+ fromPoint.set( 0, - 0.2, 0 );
+ fromPoint.applyQuaternion( quaternion );
+ fromPoint.add( point );
+
+ toPoint.set( 0, - point.y, 0 );
+ toPoint.applyQuaternion( quaternion );
+ toPoint.add( point );
+
+ extrudeShape( tube3, fromPoint, toPoint );
+
+ }
+
+ }
+
+ this.addAttribute( 'position', new THREE.BufferAttribute( new Float32Array( vertices ), 3 ) );
+ this.addAttribute( 'normal', new THREE.BufferAttribute( new Float32Array( normals ), 3 ) );
+
+}
+
+RollerCoasterLiftersGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
+
+function RollerCoasterShadowGeometry( curve, divisions ) {
+
+ THREE.BufferGeometry.call( this );
+
+ var vertices = [];
+
+ var up = new THREE.Vector3( 0, 1, 0 );
+ var forward = new THREE.Vector3();
+
+ var quaternion = new THREE.Quaternion();
+ var prevQuaternion = new THREE.Quaternion();
+ prevQuaternion.setFromAxisAngle( up, Math.PI / 2 );
+
+ var point = new THREE.Vector3();
+
+ var prevPoint = new THREE.Vector3();
+ prevPoint.copy( curve.getPointAt( 0 ) );
+ prevPoint.y = 0;
+
+ var vector1 = new THREE.Vector3();
+ var vector2 = new THREE.Vector3();
+ var vector3 = new THREE.Vector3();
+ var vector4 = new THREE.Vector3();
+
+ for ( var i = 1; i <= divisions; i ++ ) {
+
+ point.copy( curve.getPointAt( i / divisions ) );
+ point.y = 0;
+
+ forward.subVectors( point, prevPoint );
+
+ var angle = Math.atan2( forward.x, forward.z );
+
+ quaternion.setFromAxisAngle( up, angle );
+
+ vector1.set( - 0.3, 0, 0 );
+ vector1.applyQuaternion( quaternion );
+ vector1.add( point );
+
+ vector2.set( 0.3, 0, 0 );
+ vector2.applyQuaternion( quaternion );
+ vector2.add( point );
+
+ vector3.set( 0.3, 0, 0 );
+ vector3.applyQuaternion( prevQuaternion );
+ vector3.add( prevPoint );
+
+ vector4.set( - 0.3, 0, 0 );
+ vector4.applyQuaternion( prevQuaternion );
+ vector4.add( prevPoint );
+
+ vertices.push( vector1.x, vector1.y, vector1.z );
+ vertices.push( vector2.x, vector2.y, vector2.z );
+ vertices.push( vector4.x, vector4.y, vector4.z );
+
+ vertices.push( vector2.x, vector2.y, vector2.z );
+ vertices.push( vector3.x, vector3.y, vector3.z );
+ vertices.push( vector4.x, vector4.y, vector4.z );
+
+ prevPoint.copy( point );
+ prevQuaternion.copy( quaternion );
+
+ }
+
+ this.addAttribute( 'position', new THREE.BufferAttribute( new Float32Array( vertices ), 3 ) );
+
+}
+
+RollerCoasterShadowGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
+
+function SkyGeometry() {
+
+ THREE.BufferGeometry.call( this );
+
+ var vertices = [];
+
+ for ( var i = 0; i < 100; i ++ ) {
+
+ var x = Math.random() * 800 - 400;
+ var y = Math.random() * 50 + 50;
+ var z = Math.random() * 800 - 400;
+
+ var size = Math.random() * 40 + 20;
+
+ vertices.push( x - size, y, z - size );
+ vertices.push( x + size, y, z - size );
+ vertices.push( x - size, y, z + size );
+
+ vertices.push( x + size, y, z - size );
+ vertices.push( x + size, y, z + size );
+ vertices.push( x - size, y, z + size );
+
+ }
+
+
+ this.addAttribute( 'position', new THREE.BufferAttribute( new Float32Array( vertices ), 3 ) );
+
+}
+
+SkyGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
+
+function TreesGeometry( landscape ) {
+
+ THREE.BufferGeometry.call( this );
+
+ var vertices = [];
+ var colors = [];
+
+ var raycaster = new THREE.Raycaster();
+ raycaster.ray.direction.set( 0, - 1, 0 );
+
+ for ( var i = 0; i < 2000; i ++ ) {
+
+ var x = Math.random() * 500 - 250;
+ var z = Math.random() * 500 - 250;
+
+ raycaster.ray.origin.set( x, 50, z );
+
+ var intersections = raycaster.intersectObject( landscape );
+
+ if ( intersections.length === 0 ) continue;
+
+ var y = intersections[ 0 ].point.y;
+
+ var height = Math.random() * 5 + 0.5;
+
+ var angle = Math.random() * Math.PI * 2;
+
+ vertices.push( x + Math.sin( angle ), y, z + Math.cos( angle ) );
+ vertices.push( x, y + height, z );
+ vertices.push( x + Math.sin( angle + Math.PI ), y, z + Math.cos( angle + Math.PI ) );
+
+ angle += Math.PI / 2;
+
+ vertices.push( x + Math.sin( angle ), y, z + Math.cos( angle ) );
+ vertices.push( x, y + height, z );
+ vertices.push( x + Math.sin( angle + Math.PI ), y, z + Math.cos( angle + Math.PI ) );
+
+ var random = Math.random() * 0.1;
+
+ for ( var j = 0; j < 6; j ++ ) {
+
+ colors.push( 0.2 + random, 0.4 + random, 0 );
+
+ }
+
+ }
+
+ this.addAttribute( 'position', new THREE.BufferAttribute( new Float32Array( vertices ), 3 ) );
+ this.addAttribute( 'color', new THREE.BufferAttribute( new Float32Array( colors ), 3 ) );
+
+}
+
+TreesGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
diff --git a/three/jsutil/ShaderGodRays.js b/three/jsutil/ShaderGodRays.js
new file mode 100644
index 000000000..c59fa7755
--- /dev/null
+++ b/three/jsutil/ShaderGodRays.js
@@ -0,0 +1,332 @@
+/**
+ * @author huwb / http://huwbowles.com/
+ *
+ * God-rays (crepuscular rays)
+ *
+ * Similar implementation to the one used by Crytek for CryEngine 2 [Sousa2008].
+ * Blurs a mask generated from the depth map along radial lines emanating from the light
+ * source. The blur repeatedly applies a blur filter of increasing support but constant
+ * sample count to produce a blur filter with large support.
+ *
+ * My implementation performs 3 passes, similar to the implementation from Sousa. I found
+ * just 6 samples per pass produced acceptible results. The blur is applied three times,
+ * with decreasing filter support. The result is equivalent to a single pass with
+ * 6*6*6 = 216 samples.
+ *
+ * References:
+ *
+ * Sousa2008 - Crysis Next Gen Effects, GDC2008, http://www.crytek.com/sites/default/files/GDC08_SousaT_CrysisEffects.ppt
+ */
+
+THREE.ShaderGodRays = {
+
+ 'godrays_depthMask': {
+
+ uniforms: {
+
+ tInput: {
+ value: null
+ }
+
+ },
+
+ vertexShader: [
+
+ "varying vec2 vUv;",
+
+ "void main() {",
+
+ " vUv = uv;",
+ " gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+
+ "}"
+
+ ].join( "\n" ),
+
+ fragmentShader: [
+
+ "varying vec2 vUv;",
+
+ "uniform sampler2D tInput;",
+
+ "void main() {",
+
+ " gl_FragColor = vec4( 1.0 ) - texture2D( tInput, vUv );",
+
+
+ "}"
+
+ ].join( "\n" )
+
+ },
+
+
+ /**
+ * The god-ray generation shader.
+ *
+ * First pass:
+ *
+ * The depth map is blurred along radial lines towards the "sun". The
+ * output is written to a temporary render target (I used a 1/4 sized
+ * target).
+ *
+ * Pass two & three:
+ *
+ * The results of the previous pass are re-blurred, each time with a
+ * decreased distance between samples.
+ */
+
+ 'godrays_generate': {
+
+ uniforms: {
+
+ tInput: {
+ value: null
+ },
+ fStepSize: {
+ value: 1.0
+ },
+ vSunPositionScreenSpace: {
+ value: new THREE.Vector2( 0.5, 0.5 )
+ }
+
+ },
+
+ vertexShader: [
+
+ "varying vec2 vUv;",
+
+ "void main() {",
+
+ "vUv = uv;",
+ "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+
+ "}"
+
+ ].join( "\n" ),
+
+ fragmentShader: [
+
+ "#define TAPS_PER_PASS 6.0",
+
+ "varying vec2 vUv;",
+
+ "uniform sampler2D tInput;",
+
+ "uniform vec2 vSunPositionScreenSpace;",
+ "uniform float fStepSize;", // filter step size
+
+ "void main() {",
+
+ // delta from current pixel to "sun" position
+
+ "vec2 delta = vSunPositionScreenSpace - vUv;",
+ "float dist = length( delta );",
+
+ // Step vector (uv space)
+
+ "vec2 stepv = fStepSize * delta / dist;",
+
+ // Number of iterations between pixel and sun
+
+ "float iters = dist/fStepSize;",
+
+ "vec2 uv = vUv.xy;",
+ "float col = 0.0;",
+
+ // This breaks ANGLE in Chrome 22
+ // - see http://code.google.com/p/chromium/issues/detail?id=153105
+
+ /*
+ // Unrolling didnt do much on my hardware (ATI Mobility Radeon 3450),
+ // so i've just left the loop
+
+ "for ( float i = 0.0; i < TAPS_PER_PASS; i += 1.0 ) {",
+
+ // Accumulate samples, making sure we dont walk past the light source.
+
+ // The check for uv.y < 1 would not be necessary with "border" UV wrap
+ // mode, with a black border color. I don't think this is currently
+ // exposed by three.js. As a result there might be artifacts when the
+ // sun is to the left, right or bottom of screen as these cases are
+ // not specifically handled.
+
+ "col += ( i <= iters && uv.y < 1.0 ? texture2D( tInput, uv ).r : 0.0 );",
+ "uv += stepv;",
+
+ "}",
+ */
+
+ // Unrolling loop manually makes it work in ANGLE
+
+ "if ( 0.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r;",
+ "uv += stepv;",
+
+ "if ( 1.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r;",
+ "uv += stepv;",
+
+ "if ( 2.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r;",
+ "uv += stepv;",
+
+ "if ( 3.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r;",
+ "uv += stepv;",
+
+ "if ( 4.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r;",
+ "uv += stepv;",
+
+ "if ( 5.0 <= iters && uv.y < 1.0 ) col += texture2D( tInput, uv ).r;",
+ "uv += stepv;",
+
+ // Should technically be dividing by 'iters', but 'TAPS_PER_PASS' smooths out
+ // objectionable artifacts, in particular near the sun position. The side
+ // effect is that the result is darker than it should be around the sun, as
+ // TAPS_PER_PASS is greater than the number of samples actually accumulated.
+ // When the result is inverted (in the shader 'godrays_combine', this produces
+ // a slight bright spot at the position of the sun, even when it is occluded.
+
+ "gl_FragColor = vec4( col/TAPS_PER_PASS );",
+ "gl_FragColor.a = 1.0;",
+
+ "}"
+
+ ].join( "\n" )
+
+ },
+
+ /**
+ * Additively applies god rays from texture tGodRays to a background (tColors).
+ * fGodRayIntensity attenuates the god rays.
+ */
+
+ 'godrays_combine': {
+
+ uniforms: {
+
+ tColors: {
+ value: null
+ },
+
+ tGodRays: {
+ value: null
+ },
+
+ fGodRayIntensity: {
+ value: 0.69
+ },
+
+ vSunPositionScreenSpace: {
+ value: new THREE.Vector2( 0.5, 0.5 )
+ }
+
+ },
+
+ vertexShader: [
+
+ "varying vec2 vUv;",
+
+ "void main() {",
+
+ "vUv = uv;",
+ "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+
+ "}"
+
+ ].join( "\n" ),
+
+ fragmentShader: [
+
+ "varying vec2 vUv;",
+
+ "uniform sampler2D tColors;",
+ "uniform sampler2D tGodRays;",
+
+ "uniform vec2 vSunPositionScreenSpace;",
+ "uniform float fGodRayIntensity;",
+
+ "void main() {",
+
+ // Since THREE.MeshDepthMaterial renders foreground objects white and background
+ // objects black, the god-rays will be white streaks. Therefore value is inverted
+ // before being combined with tColors
+
+ "gl_FragColor = texture2D( tColors, vUv ) + fGodRayIntensity * vec4( 1.0 - texture2D( tGodRays, vUv ).r );",
+ "gl_FragColor.a = 1.0;",
+
+ "}"
+
+ ].join( "\n" )
+
+ },
+
+
+ /**
+ * A dodgy sun/sky shader. Makes a bright spot at the sun location. Would be
+ * cheaper/faster/simpler to implement this as a simple sun sprite.
+ */
+
+ 'godrays_fake_sun': {
+
+ uniforms: {
+
+ vSunPositionScreenSpace: {
+ value: new THREE.Vector2( 0.5, 0.5 )
+ },
+
+ fAspect: {
+ value: 1.0
+ },
+
+ sunColor: {
+ value: new THREE.Color( 0xffee00 )
+ },
+
+ bgColor: {
+ value: new THREE.Color( 0x000000 )
+ }
+
+ },
+
+ vertexShader: [
+
+ "varying vec2 vUv;",
+
+ "void main() {",
+
+ "vUv = uv;",
+ "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+
+ "}"
+
+ ].join( "\n" ),
+
+ fragmentShader: [
+
+ "varying vec2 vUv;",
+
+ "uniform vec2 vSunPositionScreenSpace;",
+ "uniform float fAspect;",
+
+ "uniform vec3 sunColor;",
+ "uniform vec3 bgColor;",
+
+ "void main() {",
+
+ "vec2 diff = vUv - vSunPositionScreenSpace;",
+
+ // Correct for aspect ratio
+
+ "diff.x *= fAspect;",
+
+ "float prop = clamp( length( diff ) / 0.5, 0.0, 1.0 );",
+ "prop = 0.35 * pow( 1.0 - prop, 3.0 );",
+
+ "gl_FragColor.xyz = mix( sunColor, bgColor, 1.0 - prop );",
+ "gl_FragColor.w = 1.0;",
+
+ "}"
+
+ ].join( "\n" )
+
+ }
+
+};
diff --git a/three/jsutil/ShaderSkin.js b/three/jsutil/ShaderSkin.js
new file mode 100644
index 000000000..f7dbd70d1
--- /dev/null
+++ b/three/jsutil/ShaderSkin.js
@@ -0,0 +1,698 @@
+/**
+ * @author alteredq / http://alteredqualia.com/
+ *
+ */
+
+
+THREE.ShaderSkin = {
+
+ /* ------------------------------------------------------------------------------------------
+ // Simple skin shader
+ // - per-pixel Blinn-Phong diffuse term mixed with half-Lambert wrap-around term (per color component)
+ // - physically based specular term (Kelemen/Szirmay-Kalos specular reflectance)
+ //
+ // - diffuse map
+ // - bump map
+ // - specular map
+ // - point, directional and hemisphere lights (use with "lights: true" material option)
+ // - fog (use with "fog: true" material option)
+ // - shadow maps
+ //
+ // ------------------------------------------------------------------------------------------ */
+
+ 'skinSimple' : {
+
+ uniforms: THREE.UniformsUtils.merge( [
+
+ THREE.UniformsLib[ "fog" ],
+ THREE.UniformsLib[ "lights" ],
+
+ {
+
+ "enableBump": { value: 0 },
+ "enableSpecular": { value: 0 },
+
+ "tDiffuse": { value: null },
+ "tBeckmann": { value: null },
+
+ "diffuse": { value: new THREE.Color( 0xeeeeee ) },
+ "specular": { value: new THREE.Color( 0x111111 ) },
+ "opacity": { value: 1 },
+
+ "uRoughness": { value: 0.15 },
+ "uSpecularBrightness": { value: 0.75 },
+
+ "bumpMap": { value: null },
+ "bumpScale": { value: 1 },
+
+ "specularMap": { value: null },
+
+ "offsetRepeat": { value: new THREE.Vector4( 0, 0, 1, 1 ) },
+
+ "uWrapRGB": { value: new THREE.Vector3( 0.75, 0.375, 0.1875 ) }
+
+ }
+
+ ] ),
+
+ fragmentShader: [
+
+ "#define USE_BUMPMAP",
+
+ "uniform bool enableBump;",
+ "uniform bool enableSpecular;",
+
+ "uniform vec3 diffuse;",
+ "uniform vec3 specular;",
+ "uniform float opacity;",
+
+ "uniform float uRoughness;",
+ "uniform float uSpecularBrightness;",
+
+ "uniform vec3 uWrapRGB;",
+
+ "uniform sampler2D tDiffuse;",
+ "uniform sampler2D tBeckmann;",
+
+ "uniform sampler2D specularMap;",
+
+ "varying vec3 vNormal;",
+ "varying vec2 vUv;",
+
+ "varying vec3 vViewPosition;",
+
+ THREE.ShaderChunk[ "common" ],
+ THREE.ShaderChunk[ "bsdfs" ],
+ THREE.ShaderChunk[ "packing" ],
+ THREE.ShaderChunk[ "lights_pars_begin" ],
+ THREE.ShaderChunk[ "shadowmap_pars_fragment" ],
+ THREE.ShaderChunk[ "fog_pars_fragment" ],
+ THREE.ShaderChunk[ "bumpmap_pars_fragment" ],
+
+ // Fresnel term
+
+ "float fresnelReflectance( vec3 H, vec3 V, float F0 ) {",
+
+ "float base = 1.0 - dot( V, H );",
+ "float exponential = pow( base, 5.0 );",
+
+ "return exponential + F0 * ( 1.0 - exponential );",
+
+ "}",
+
+ // Kelemen/Szirmay-Kalos specular BRDF
+
+ "float KS_Skin_Specular( vec3 N,", // Bumped surface normal
+ "vec3 L,", // Points to light
+ "vec3 V,", // Points to eye
+ "float m,", // Roughness
+ "float rho_s", // Specular brightness
+ ") {",
+
+ "float result = 0.0;",
+ "float ndotl = dot( N, L );",
+
+ "if( ndotl > 0.0 ) {",
+
+ "vec3 h = L + V;", // Unnormalized half-way vector
+ "vec3 H = normalize( h );",
+
+ "float ndoth = dot( N, H );",
+
+ "float PH = pow( 2.0 * texture2D( tBeckmann, vec2( ndoth, m ) ).x, 10.0 );",
+
+ "float F = fresnelReflectance( H, V, 0.028 );",
+ "float frSpec = max( PH * F / dot( h, h ), 0.0 );",
+
+ "result = ndotl * rho_s * frSpec;", // BRDF * dot(N,L) * rho_s
+
+ "}",
+
+ "return result;",
+
+ "}",
+
+ "void main() {",
+
+ "vec3 outgoingLight = vec3( 0.0 );", // outgoing light does not have an alpha, the surface does
+ "vec4 diffuseColor = vec4( diffuse, opacity );",
+
+ "vec4 colDiffuse = texture2D( tDiffuse, vUv );",
+ "colDiffuse.rgb *= colDiffuse.rgb;",
+
+ "diffuseColor = diffuseColor * colDiffuse;",
+
+ "vec3 normal = normalize( vNormal );",
+ "vec3 viewerDirection = normalize( vViewPosition );",
+
+ "float specularStrength;",
+
+ "if ( enableSpecular ) {",
+
+ "vec4 texelSpecular = texture2D( specularMap, vUv );",
+ "specularStrength = texelSpecular.r;",
+
+ "} else {",
+
+ "specularStrength = 1.0;",
+
+ "}",
+
+ "#ifdef USE_BUMPMAP",
+
+ "if ( enableBump ) normal = perturbNormalArb( -vViewPosition, normal, dHdxy_fwd() );",
+
+ "#endif",
+
+ // point lights
+
+ "vec3 totalSpecularLight = vec3( 0.0 );",
+ "vec3 totalDiffuseLight = vec3( 0.0 );",
+
+ "#if NUM_POINT_LIGHTS > 0",
+
+ "for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {",
+
+ "vec3 lVector = pointLights[ i ].position + vViewPosition.xyz;",
+
+ "float attenuation = calcLightAttenuation( length( lVector ), pointLights[ i ].distance, pointLights[ i ].decay );",
+
+ "lVector = normalize( lVector );",
+
+ "float pointDiffuseWeightFull = max( dot( normal, lVector ), 0.0 );",
+ "float pointDiffuseWeightHalf = max( 0.5 * dot( normal, lVector ) + 0.5, 0.0 );",
+ "vec3 pointDiffuseWeight = mix( vec3 ( pointDiffuseWeightFull ), vec3( pointDiffuseWeightHalf ), uWrapRGB );",
+
+ "float pointSpecularWeight = KS_Skin_Specular( normal, lVector, viewerDirection, uRoughness, uSpecularBrightness );",
+
+ "totalDiffuseLight += pointLight[ i ].color * ( pointDiffuseWeight * attenuation );",
+ "totalSpecularLight += pointLight[ i ].color * specular * ( pointSpecularWeight * specularStrength * attenuation );",
+
+ "}",
+
+ "#endif",
+
+ // directional lights
+
+ "#if NUM_DIR_LIGHTS > 0",
+
+ "for( int i = 0; i < NUM_DIR_LIGHTS; i++ ) {",
+
+ "vec3 dirVector = directionalLights[ i ].direction;",
+
+ "float dirDiffuseWeightFull = max( dot( normal, dirVector ), 0.0 );",
+ "float dirDiffuseWeightHalf = max( 0.5 * dot( normal, dirVector ) + 0.5, 0.0 );",
+ "vec3 dirDiffuseWeight = mix( vec3 ( dirDiffuseWeightFull ), vec3( dirDiffuseWeightHalf ), uWrapRGB );",
+
+ "float dirSpecularWeight = KS_Skin_Specular( normal, dirVector, viewerDirection, uRoughness, uSpecularBrightness );",
+
+ "totalDiffuseLight += directionalLights[ i ].color * dirDiffuseWeight;",
+ "totalSpecularLight += directionalLights[ i ].color * ( dirSpecularWeight * specularStrength );",
+
+ "}",
+
+ "#endif",
+
+ // hemisphere lights
+
+ "#if NUM_HEMI_LIGHTS > 0",
+
+ "for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {",
+
+ "vec3 lVector = hemisphereLightDirection[ i ];",
+
+ "float dotProduct = dot( normal, lVector );",
+ "float hemiDiffuseWeight = 0.5 * dotProduct + 0.5;",
+
+ "totalDiffuseLight += mix( hemisphereLightGroundColor[ i ], hemisphereLightSkyColor[ i ], hemiDiffuseWeight );",
+
+ // specular (sky light)
+
+ "float hemiSpecularWeight = 0.0;",
+ "hemiSpecularWeight += KS_Skin_Specular( normal, lVector, viewerDirection, uRoughness, uSpecularBrightness );",
+
+ // specular (ground light)
+
+ "vec3 lVectorGround = -lVector;",
+ "hemiSpecularWeight += KS_Skin_Specular( normal, lVectorGround, viewerDirection, uRoughness, uSpecularBrightness );",
+
+ "vec3 hemiSpecularColor = mix( hemisphereLightGroundColor[ i ], hemisphereLightSkyColor[ i ], hemiDiffuseWeight );",
+
+ "totalSpecularLight += hemiSpecularColor * specular * ( hemiSpecularWeight * specularStrength );",
+
+ "}",
+
+ "#endif",
+
+ "outgoingLight += diffuseColor.xyz * ( totalDiffuseLight + ambientLightColor * diffuse ) + totalSpecularLight;",
+
+ "gl_FragColor = linearToOutputTexel( vec4( outgoingLight, diffuseColor.a ) );", // TODO, this should be pre-multiplied to allow for bright highlights on very transparent objects
+
+ THREE.ShaderChunk[ "fog_fragment" ],
+
+ "}"
+
+ ].join( "\n" ),
+
+ vertexShader: [
+
+ "uniform vec4 offsetRepeat;",
+
+ "varying vec3 vNormal;",
+ "varying vec2 vUv;",
+
+ "varying vec3 vViewPosition;",
+
+ THREE.ShaderChunk[ "common" ],
+ THREE.ShaderChunk[ "lights_pars_begin" ],
+ THREE.ShaderChunk[ "shadowmap_pars_vertex" ],
+ THREE.ShaderChunk[ "fog_pars_vertex" ],
+
+ "void main() {",
+
+ "vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );",
+ "vec4 worldPosition = modelMatrix * vec4( position, 1.0 );",
+
+ "vViewPosition = -mvPosition.xyz;",
+
+ "vNormal = normalize( normalMatrix * normal );",
+
+ "vUv = uv * offsetRepeat.zw + offsetRepeat.xy;",
+
+ "gl_Position = projectionMatrix * mvPosition;",
+
+ THREE.ShaderChunk[ "shadowmap_vertex" ],
+ THREE.ShaderChunk[ "fog_vertex" ],
+
+ "}"
+
+ ].join( "\n" )
+
+ },
+
+ /* ------------------------------------------------------------------------------------------
+ // Skin shader
+ // - Blinn-Phong diffuse term (using normal + diffuse maps)
+ // - subsurface scattering approximation by four blur layers
+ // - physically based specular term (Kelemen/Szirmay-Kalos specular reflectance)
+ //
+ // - point and directional lights (use with "lights: true" material option)
+ //
+ // - based on Nvidia Advanced Skin Rendering GDC 2007 presentation
+ // and GPU Gems 3 Chapter 14. Advanced Techniques for Realistic Real-Time Skin Rendering
+ //
+ // http://developer.download.nvidia.com/presentations/2007/gdc/Advanced_Skin.pdf
+ // http://http.developer.nvidia.com/GPUGems3/gpugems3_ch14.html
+ // ------------------------------------------------------------------------------------------ */
+
+ 'skin' : {
+
+ uniforms: THREE.UniformsUtils.merge( [
+
+ THREE.UniformsLib[ "fog" ],
+ THREE.UniformsLib[ "lights" ],
+
+ {
+
+ "passID": { value: 0 },
+
+ "tDiffuse" : { value: null },
+ "tNormal" : { value: null },
+
+ "tBlur1" : { value: null },
+ "tBlur2" : { value: null },
+ "tBlur3" : { value: null },
+ "tBlur4" : { value: null },
+
+ "tBeckmann" : { value: null },
+
+ "uNormalScale": { value: 1.0 },
+
+ "diffuse": { value: new THREE.Color( 0xeeeeee ) },
+ "specular": { value: new THREE.Color( 0x111111 ) },
+ "opacity": { value: 1 },
+
+ "uRoughness": { value: 0.15 },
+ "uSpecularBrightness": { value: 0.75 }
+
+ }
+
+ ] ),
+
+ fragmentShader: [
+
+ "uniform vec3 diffuse;",
+ "uniform vec3 specular;",
+ "uniform float opacity;",
+
+ "uniform float uRoughness;",
+ "uniform float uSpecularBrightness;",
+
+ "uniform int passID;",
+
+ "uniform sampler2D tDiffuse;",
+ "uniform sampler2D tNormal;",
+
+ "uniform sampler2D tBlur1;",
+ "uniform sampler2D tBlur2;",
+ "uniform sampler2D tBlur3;",
+ "uniform sampler2D tBlur4;",
+
+ "uniform sampler2D tBeckmann;",
+
+ "uniform float uNormalScale;",
+
+ "varying vec3 vNormal;",
+ "varying vec2 vUv;",
+
+ "varying vec3 vViewPosition;",
+
+ THREE.ShaderChunk[ "common" ],
+ THREE.ShaderChunk[ "lights_pars_begin" ],
+ THREE.ShaderChunk[ "fog_pars_fragment" ],
+
+ "float fresnelReflectance( vec3 H, vec3 V, float F0 ) {",
+
+ "float base = 1.0 - dot( V, H );",
+ "float exponential = pow( base, 5.0 );",
+
+ "return exponential + F0 * ( 1.0 - exponential );",
+
+ "}",
+
+ // Kelemen/Szirmay-Kalos specular BRDF
+
+ "float KS_Skin_Specular( vec3 N,", // Bumped surface normal
+ "vec3 L,", // Points to light
+ "vec3 V,", // Points to eye
+ "float m,", // Roughness
+ "float rho_s", // Specular brightness
+ ") {",
+
+ "float result = 0.0;",
+ "float ndotl = dot( N, L );",
+
+ "if( ndotl > 0.0 ) {",
+
+ "vec3 h = L + V;", // Unnormalized half-way vector
+ "vec3 H = normalize( h );",
+
+ "float ndoth = dot( N, H );",
+
+ "float PH = pow( 2.0 * texture2D( tBeckmann, vec2( ndoth, m ) ).x, 10.0 );",
+ "float F = fresnelReflectance( H, V, 0.028 );",
+ "float frSpec = max( PH * F / dot( h, h ), 0.0 );",
+
+ "result = ndotl * rho_s * frSpec;", // BRDF * dot(N,L) * rho_s
+
+ "}",
+
+ "return result;",
+
+ "}",
+
+ "void main() {",
+
+ "vec3 outgoingLight = vec3( 0.0 );", // outgoing light does not have an alpha, the surface does
+ "vec4 diffuseColor = vec4( diffuse, opacity );",
+
+ "vec4 mSpecular = vec4( specular, opacity );",
+
+ "vec4 colDiffuse = texture2D( tDiffuse, vUv );",
+ "colDiffuse *= colDiffuse;",
+
+ "diffuseColor *= colDiffuse;",
+
+ // normal mapping
+
+ "vec4 posAndU = vec4( -vViewPosition, vUv.x );",
+ "vec4 posAndU_dx = dFdx( posAndU ), posAndU_dy = dFdy( posAndU );",
+ "vec3 tangent = posAndU_dx.w * posAndU_dx.xyz + posAndU_dy.w * posAndU_dy.xyz;",
+ "vec3 normal = normalize( vNormal );",
+ "vec3 binormal = normalize( cross( tangent, normal ) );",
+ "tangent = cross( normal, binormal );", // no normalization required
+ "mat3 tsb = mat3( tangent, binormal, normal );",
+
+ "vec3 normalTex = texture2D( tNormal, vUv ).xyz * 2.0 - 1.0;",
+ "normalTex.xy *= uNormalScale;",
+ "normalTex = normalize( normalTex );",
+
+ "vec3 finalNormal = tsb * normalTex;",
+ "normal = normalize( finalNormal );",
+
+ "vec3 viewerDirection = normalize( vViewPosition );",
+
+ // point lights
+
+ "vec3 totalDiffuseLight = vec3( 0.0 );",
+ "vec3 totalSpecularLight = vec3( 0.0 );",
+
+ "#if NUM_POINT_LIGHTS > 0",
+
+ "for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {",
+
+ "vec3 pointVector = normalize( pointLights[ i ].direction );",
+ "float attenuation = calcLightAttenuation( length( lVector ), pointLights[ i ].distance, pointLights[ i ].decay );",
+
+ "float pointDiffuseWeight = max( dot( normal, pointVector ), 0.0 );",
+
+ "totalDiffuseLight += pointLightColor[ i ] * ( pointDiffuseWeight * attenuation );",
+
+ "if ( passID == 1 ) {",
+
+ "float pointSpecularWeight = KS_Skin_Specular( normal, pointVector, viewerDirection, uRoughness, uSpecularBrightness );",
+
+ "totalSpecularLight += pointLightColor[ i ] * mSpecular.xyz * ( pointSpecularWeight * attenuation );",
+
+ "}",
+
+ "}",
+
+ "#endif",
+
+ // directional lights
+
+ "#if NUM_DIR_LIGHTS > 0",
+
+ "for( int i = 0; i < NUM_DIR_LIGHTS; i++ ) {",
+
+ "vec3 dirVector = directionalLights[ i ].direction;",
+
+ "float dirDiffuseWeight = max( dot( normal, dirVector ), 0.0 );",
+
+
+ "totalDiffuseLight += directionalLights[ i ].color * dirDiffuseWeight;",
+
+ "if ( passID == 1 ) {",
+
+ "float dirSpecularWeight = KS_Skin_Specular( normal, dirVector, viewerDirection, uRoughness, uSpecularBrightness );",
+
+ "totalSpecularLight += directionalLights[ i ].color * mSpecular.xyz * dirSpecularWeight;",
+
+ "}",
+
+ "}",
+
+ "#endif",
+
+
+ "outgoingLight += diffuseColor.rgb * ( totalDiffuseLight + totalSpecularLight );",
+
+ "if ( passID == 0 ) {",
+
+ "outgoingLight = sqrt( outgoingLight );",
+
+ "} else if ( passID == 1 ) {",
+
+ //"#define VERSION1",
+
+ "#ifdef VERSION1",
+
+ "vec3 nonblurColor = sqrt(outgoingLight );",
+
+ "#else",
+
+ "vec3 nonblurColor = outgoingLight;",
+
+ "#endif",
+
+ "vec3 blur1Color = texture2D( tBlur1, vUv ).xyz;",
+ "vec3 blur2Color = texture2D( tBlur2, vUv ).xyz;",
+ "vec3 blur3Color = texture2D( tBlur3, vUv ).xyz;",
+ "vec3 blur4Color = texture2D( tBlur4, vUv ).xyz;",
+
+
+ //"gl_FragColor = vec4( blur1Color, gl_FragColor.w );",
+
+ //"gl_FragColor = vec4( vec3( 0.22, 0.5, 0.7 ) * nonblurColor + vec3( 0.2, 0.5, 0.3 ) * blur1Color + vec3( 0.58, 0.0, 0.0 ) * blur2Color, gl_FragColor.w );",
+
+ //"gl_FragColor = vec4( vec3( 0.25, 0.6, 0.8 ) * nonblurColor + vec3( 0.15, 0.25, 0.2 ) * blur1Color + vec3( 0.15, 0.15, 0.0 ) * blur2Color + vec3( 0.45, 0.0, 0.0 ) * blur3Color, gl_FragColor.w );",
+
+
+ "outgoingLight = vec3( vec3( 0.22, 0.437, 0.635 ) * nonblurColor + ",
+ "vec3( 0.101, 0.355, 0.365 ) * blur1Color + ",
+ "vec3( 0.119, 0.208, 0.0 ) * blur2Color + ",
+ "vec3( 0.114, 0.0, 0.0 ) * blur3Color + ",
+ "vec3( 0.444, 0.0, 0.0 ) * blur4Color );",
+
+ "outgoingLight *= sqrt( colDiffuse.xyz );",
+
+ "outgoingLight += ambientLightColor * diffuse * colDiffuse.xyz + totalSpecularLight;",
+
+ "#ifndef VERSION1",
+
+ "outgoingLight = sqrt( outgoingLight );",
+
+ "#endif",
+
+ "}",
+
+ "gl_FragColor = vec4( outgoingLight, diffuseColor.a );", // TODO, this should be pre-multiplied to allow for bright highlights on very transparent objects
+
+ THREE.ShaderChunk[ "fog_fragment" ],
+
+ "}"
+
+ ].join( "\n" ),
+
+ vertexShader: [
+
+ "#ifdef VERTEX_TEXTURES",
+
+ "uniform sampler2D tDisplacement;",
+ "uniform float uDisplacementScale;",
+ "uniform float uDisplacementBias;",
+
+ "#endif",
+
+ "varying vec3 vNormal;",
+ "varying vec2 vUv;",
+
+ "varying vec3 vViewPosition;",
+
+ THREE.ShaderChunk[ "common" ],
+ THREE.ShaderChunk[ "fog_pars_vertex" ],
+
+ "void main() {",
+
+ "vec4 worldPosition = modelMatrix * vec4( position, 1.0 );",
+
+ "vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );",
+
+ "vViewPosition = -mvPosition.xyz;",
+
+ "vNormal = normalize( normalMatrix * normal );",
+
+ "vUv = uv;",
+
+ // displacement mapping
+
+ "#ifdef VERTEX_TEXTURES",
+
+ "vec3 dv = texture2D( tDisplacement, uv ).xyz;",
+ "float df = uDisplacementScale * dv.x + uDisplacementBias;",
+ "vec4 displacedPosition = vec4( vNormal.xyz * df, 0.0 ) + mvPosition;",
+ "gl_Position = projectionMatrix * displacedPosition;",
+
+ "#else",
+
+ "gl_Position = projectionMatrix * mvPosition;",
+
+ "#endif",
+
+ THREE.ShaderChunk[ "fog_vertex" ],
+
+ "}",
+
+
+ ].join( "\n" ),
+
+ vertexShaderUV: [
+
+ "varying vec3 vNormal;",
+ "varying vec2 vUv;",
+
+ "varying vec3 vViewPosition;",
+
+ THREE.ShaderChunk[ "common" ],
+
+ "void main() {",
+
+ "vec4 worldPosition = modelMatrix * vec4( position, 1.0 );",
+
+ "vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );",
+
+ "vViewPosition = -mvPosition.xyz;",
+
+ "vNormal = normalize( normalMatrix * normal );",
+
+ "vUv = uv;",
+
+ "gl_Position = vec4( uv.x * 2.0 - 1.0, uv.y * 2.0 - 1.0, 0.0, 1.0 );",
+
+ "}"
+
+ ].join( "\n" )
+
+ },
+
+ /* ------------------------------------------------------------------------------------------
+ // Beckmann distribution function
+ // - to be used in specular term of skin shader
+ // - render a screen-aligned quad to precompute a 512 x 512 texture
+ //
+ // - from http://developer.nvidia.com/node/171
+ ------------------------------------------------------------------------------------------ */
+
+ "beckmann" : {
+
+ uniforms: {},
+
+ vertexShader: [
+
+ "varying vec2 vUv;",
+
+ "void main() {",
+
+ "vUv = uv;",
+ "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+
+ "}"
+
+ ].join( "\n" ),
+
+ fragmentShader: [
+
+ "varying vec2 vUv;",
+
+ "float PHBeckmann( float ndoth, float m ) {",
+
+ "float alpha = acos( ndoth );",
+ "float ta = tan( alpha );",
+
+ "float val = 1.0 / ( m * m * pow( ndoth, 4.0 ) ) * exp( -( ta * ta ) / ( m * m ) );",
+ "return val;",
+
+ "}",
+
+ "float KSTextureCompute( vec2 tex ) {",
+
+ // Scale the value to fit within [0,1] invert upon lookup.
+
+ "return 0.5 * pow( PHBeckmann( tex.x, tex.y ), 0.1 );",
+
+ "}",
+
+ "void main() {",
+
+ "float x = KSTextureCompute( vUv );",
+
+ "gl_FragColor = vec4( x, x, x, 1.0 );",
+
+ "}"
+
+ ].join( "\n" )
+
+ }
+
+};
diff --git a/three/jsutil/ShaderTerrain.js b/three/jsutil/ShaderTerrain.js
new file mode 100644
index 000000000..2b8b68eb9
--- /dev/null
+++ b/three/jsutil/ShaderTerrain.js
@@ -0,0 +1,324 @@
+/**
+ * @author alteredq / http://alteredqualia.com/
+ *
+ */
+
+THREE.ShaderTerrain = {
+
+ /* -------------------------------------------------------------------------
+ // Dynamic terrain shader
+ // - Blinn-Phong
+ // - height + normal + diffuse1 + diffuse2 + specular + detail maps
+ // - point, directional and hemisphere lights (use with "lights: true" material option)
+ // - shadow maps receiving
+ ------------------------------------------------------------------------- */
+
+ 'terrain' : {
+
+ uniforms: THREE.UniformsUtils.merge( [
+
+ THREE.UniformsLib[ "fog" ],
+ THREE.UniformsLib[ "lights" ],
+
+ {
+
+ "enableDiffuse1": { value: 0 },
+ "enableDiffuse2": { value: 0 },
+ "enableSpecular": { value: 0 },
+ "enableReflection": { value: 0 },
+
+ "tDiffuse1": { value: null },
+ "tDiffuse2": { value: null },
+ "tDetail": { value: null },
+ "tNormal": { value: null },
+ "tSpecular": { value: null },
+ "tDisplacement": { value: null },
+
+ "uNormalScale": { value: 1.0 },
+
+ "uDisplacementBias": { value: 0.0 },
+ "uDisplacementScale": { value: 1.0 },
+
+ "diffuse": { value: new THREE.Color( 0xeeeeee ) },
+ "specular": { value: new THREE.Color( 0x111111 ) },
+ "shininess": { value: 30 },
+ "opacity": { value: 1 },
+
+ "uRepeatBase": { value: new THREE.Vector2( 1, 1 ) },
+ "uRepeatOverlay": { value: new THREE.Vector2( 1, 1 ) },
+
+ "uOffset": { value: new THREE.Vector2( 0, 0 ) }
+
+ }
+
+ ] ),
+
+ fragmentShader: [
+
+ "uniform vec3 diffuse;",
+ "uniform vec3 specular;",
+ "uniform float shininess;",
+ "uniform float opacity;",
+
+ "uniform bool enableDiffuse1;",
+ "uniform bool enableDiffuse2;",
+ "uniform bool enableSpecular;",
+
+ "uniform sampler2D tDiffuse1;",
+ "uniform sampler2D tDiffuse2;",
+ "uniform sampler2D tDetail;",
+ "uniform sampler2D tNormal;",
+ "uniform sampler2D tSpecular;",
+ "uniform sampler2D tDisplacement;",
+
+ "uniform float uNormalScale;",
+
+ "uniform vec2 uRepeatOverlay;",
+ "uniform vec2 uRepeatBase;",
+
+ "uniform vec2 uOffset;",
+
+ "varying vec3 vTangent;",
+ "varying vec3 vBinormal;",
+ "varying vec3 vNormal;",
+ "varying vec2 vUv;",
+
+ "varying vec3 vViewPosition;",
+
+ THREE.ShaderChunk[ "common" ],
+ THREE.ShaderChunk[ "bsdfs" ],
+ THREE.ShaderChunk[ "lights_pars_begin" ],
+ THREE.ShaderChunk[ "shadowmap_pars_fragment" ],
+ THREE.ShaderChunk[ "fog_pars_fragment" ],
+
+ "float calcLightAttenuation( float lightDistance, float cutoffDistance, float decayExponent ) {",
+ "if ( decayExponent > 0.0 ) {",
+ "return pow( saturate( - lightDistance / cutoffDistance + 1.0 ), decayExponent );",
+ "}",
+ "return 1.0;",
+ "}",
+
+ "void main() {",
+
+ "vec3 outgoingLight = vec3( 0.0 );", // outgoing light does not have an alpha, the surface does
+ "vec4 diffuseColor = vec4( diffuse, opacity );",
+
+ "vec3 specularTex = vec3( 1.0 );",
+
+ "vec2 uvOverlay = uRepeatOverlay * vUv + uOffset;",
+ "vec2 uvBase = uRepeatBase * vUv;",
+
+ "vec3 normalTex = texture2D( tDetail, uvOverlay ).xyz * 2.0 - 1.0;",
+ "normalTex.xy *= uNormalScale;",
+ "normalTex = normalize( normalTex );",
+
+ "if( enableDiffuse1 && enableDiffuse2 ) {",
+
+ "vec4 colDiffuse1 = texture2D( tDiffuse1, uvOverlay );",
+ "vec4 colDiffuse2 = texture2D( tDiffuse2, uvOverlay );",
+
+ "colDiffuse1 = GammaToLinear( colDiffuse1, float( GAMMA_FACTOR ) );",
+ "colDiffuse2 = GammaToLinear( colDiffuse2, float( GAMMA_FACTOR ) );",
+
+ "diffuseColor *= mix ( colDiffuse1, colDiffuse2, 1.0 - texture2D( tDisplacement, uvBase ) );",
+
+ " } else if( enableDiffuse1 ) {",
+
+ "diffuseColor *= texture2D( tDiffuse1, uvOverlay );",
+
+ "} else if( enableDiffuse2 ) {",
+
+ "diffuseColor *= texture2D( tDiffuse2, uvOverlay );",
+
+ "}",
+
+ "if( enableSpecular )",
+ "specularTex = texture2D( tSpecular, uvOverlay ).xyz;",
+
+ "mat3 tsb = mat3( vTangent, vBinormal, vNormal );",
+ "vec3 finalNormal = tsb * normalTex;",
+
+ "vec3 normal = normalize( finalNormal );",
+ "vec3 viewPosition = normalize( vViewPosition );",
+
+ "vec3 totalDiffuseLight = vec3( 0.0 );",
+ "vec3 totalSpecularLight = vec3( 0.0 );",
+
+ // point lights
+
+ "#if NUM_POINT_LIGHTS > 0",
+
+ "for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {",
+
+ "vec3 lVector = pointLights[ i ].position + vViewPosition.xyz;",
+
+ "float attenuation = calcLightAttenuation( length( lVector ), pointLights[ i ].distance, pointLights[ i ].decay );",
+
+ "lVector = normalize( lVector );",
+
+ "vec3 pointHalfVector = normalize( lVector + viewPosition );",
+
+ "float pointDotNormalHalf = max( dot( normal, pointHalfVector ), 0.0 );",
+ "float pointDiffuseWeight = max( dot( normal, lVector ), 0.0 );",
+
+ "float pointSpecularWeight = specularTex.r * max( pow( pointDotNormalHalf, shininess ), 0.0 );",
+
+ "totalDiffuseLight += attenuation * pointLights[ i ].color * pointDiffuseWeight;",
+ "totalSpecularLight += attenuation * pointLights[ i ].color * specular * pointSpecularWeight * pointDiffuseWeight;",
+
+ "}",
+
+ "#endif",
+
+ // directional lights
+
+ "#if NUM_DIR_LIGHTS > 0",
+
+ "vec3 dirDiffuse = vec3( 0.0 );",
+ "vec3 dirSpecular = vec3( 0.0 );",
+
+ "for( int i = 0; i < NUM_DIR_LIGHTS; i++ ) {",
+
+ "vec3 dirVector = directionalLights[ i ].direction;",
+ "vec3 dirHalfVector = normalize( dirVector + viewPosition );",
+
+ "float dirDotNormalHalf = max( dot( normal, dirHalfVector ), 0.0 );",
+ "float dirDiffuseWeight = max( dot( normal, dirVector ), 0.0 );",
+
+ "float dirSpecularWeight = specularTex.r * max( pow( dirDotNormalHalf, shininess ), 0.0 );",
+
+ "totalDiffuseLight += directionalLights[ i ].color * dirDiffuseWeight;",
+ "totalSpecularLight += directionalLights[ i ].color * specular * dirSpecularWeight * dirDiffuseWeight;",
+
+ "}",
+
+ "#endif",
+
+ // hemisphere lights
+
+ "#if NUM_HEMI_LIGHTS > 0",
+
+ "vec3 hemiDiffuse = vec3( 0.0 );",
+ "vec3 hemiSpecular = vec3( 0.0 );",
+
+ "for( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {",
+
+ "vec3 lVector = hemisphereLightDirection[ i ];",
+
+ // diffuse
+
+ "float dotProduct = dot( normal, lVector );",
+ "float hemiDiffuseWeight = 0.5 * dotProduct + 0.5;",
+
+ "totalDiffuseLight += mix( hemisphereLights[ i ].groundColor, hemisphereLights[ i ].skyColor, hemiDiffuseWeight );",
+
+ // specular (sky light)
+
+ "float hemiSpecularWeight = 0.0;",
+
+ "vec3 hemiHalfVectorSky = normalize( lVector + viewPosition );",
+ "float hemiDotNormalHalfSky = 0.5 * dot( normal, hemiHalfVectorSky ) + 0.5;",
+ "hemiSpecularWeight += specularTex.r * max( pow( hemiDotNormalHalfSky, shininess ), 0.0 );",
+
+ // specular (ground light)
+
+ "vec3 lVectorGround = -lVector;",
+
+ "vec3 hemiHalfVectorGround = normalize( lVectorGround + viewPosition );",
+ "float hemiDotNormalHalfGround = 0.5 * dot( normal, hemiHalfVectorGround ) + 0.5;",
+ "hemiSpecularWeight += specularTex.r * max( pow( hemiDotNormalHalfGround, shininess ), 0.0 );",
+
+ "totalSpecularLight += specular * mix( hemisphereLights[ i ].groundColor, hemisphereLights[ i ].skyColor, hemiDiffuseWeight ) * hemiSpecularWeight * hemiDiffuseWeight;",
+
+ "}",
+
+ "#endif",
+
+ "outgoingLight += diffuseColor.xyz * ( totalDiffuseLight + ambientLightColor + totalSpecularLight );",
+
+ "gl_FragColor = vec4( outgoingLight, diffuseColor.a );", // TODO, this should be pre-multiplied to allow for bright highlights on very transparent objects
+
+ THREE.ShaderChunk[ "fog_fragment" ],
+
+ "}"
+
+ ].join( "\n" ),
+
+ vertexShader: [
+
+ "attribute vec4 tangent;",
+
+ "uniform vec2 uRepeatBase;",
+
+ "uniform sampler2D tNormal;",
+
+ "#ifdef VERTEX_TEXTURES",
+
+ "uniform sampler2D tDisplacement;",
+ "uniform float uDisplacementScale;",
+ "uniform float uDisplacementBias;",
+
+ "#endif",
+
+ "varying vec3 vTangent;",
+ "varying vec3 vBinormal;",
+ "varying vec3 vNormal;",
+ "varying vec2 vUv;",
+
+ "varying vec3 vViewPosition;",
+
+ THREE.ShaderChunk[ "shadowmap_pars_vertex" ],
+ THREE.ShaderChunk[ "fog_pars_vertex" ],
+
+ "void main() {",
+
+ "vNormal = normalize( normalMatrix * normal );",
+
+ // tangent and binormal vectors
+
+ "vTangent = normalize( normalMatrix * tangent.xyz );",
+
+ "vBinormal = cross( vNormal, vTangent ) * tangent.w;",
+ "vBinormal = normalize( vBinormal );",
+
+ // texture coordinates
+
+ "vUv = uv;",
+
+ "vec2 uvBase = uv * uRepeatBase;",
+
+ // displacement mapping
+
+ "#ifdef VERTEX_TEXTURES",
+
+ "vec3 dv = texture2D( tDisplacement, uvBase ).xyz;",
+ "float df = uDisplacementScale * dv.x + uDisplacementBias;",
+ "vec3 displacedPosition = normal * df + position;",
+
+ "vec4 worldPosition = modelMatrix * vec4( displacedPosition, 1.0 );",
+ "vec4 mvPosition = modelViewMatrix * vec4( displacedPosition, 1.0 );",
+
+ "#else",
+
+ "vec4 worldPosition = modelMatrix * vec4( position, 1.0 );",
+ "vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );",
+
+ "#endif",
+
+ "gl_Position = projectionMatrix * mvPosition;",
+
+ "vViewPosition = -mvPosition.xyz;",
+
+ "vec3 normalTex = texture2D( tNormal, uvBase ).xyz * 2.0 - 1.0;",
+ "vNormal = normalMatrix * normalTex;",
+
+ THREE.ShaderChunk[ "shadowmap_vertex" ],
+ THREE.ShaderChunk[ "fog_vertex" ],
+
+ "}"
+
+ ].join( "\n" )
+
+ }
+
+};
diff --git a/three/jsutil/ShaderToon.js b/three/jsutil/ShaderToon.js
new file mode 100644
index 000000000..4566ce9a9
--- /dev/null
+++ b/three/jsutil/ShaderToon.js
@@ -0,0 +1,331 @@
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author alteredq / http://alteredqualia.com/
+ *
+ * ShaderToon currently contains:
+ *
+ * toon1
+ * toon2
+ * hatching
+ * dotted
+ */
+
+THREE.ShaderToon = {
+
+ 'toon1' : {
+
+ uniforms: {
+
+ "uDirLightPos": { value: new THREE.Vector3() },
+ "uDirLightColor": { value: new THREE.Color( 0xeeeeee ) },
+
+ "uAmbientLightColor": { value: new THREE.Color( 0x050505 ) },
+
+ "uBaseColor": { value: new THREE.Color( 0xffffff ) }
+
+ },
+
+ vertexShader: [
+
+ "varying vec3 vNormal;",
+ "varying vec3 vRefract;",
+
+ "void main() {",
+
+ "vec4 worldPosition = modelMatrix * vec4( position, 1.0 );",
+ "vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );",
+ "vec3 worldNormal = normalize ( mat3( modelMatrix[0].xyz, modelMatrix[1].xyz, modelMatrix[2].xyz ) * normal );",
+
+ "vNormal = normalize( normalMatrix * normal );",
+
+ "vec3 I = worldPosition.xyz - cameraPosition;",
+ "vRefract = refract( normalize( I ), worldNormal, 1.02 );",
+
+ "gl_Position = projectionMatrix * mvPosition;",
+
+ "}"
+
+ ].join( "\n" ),
+
+ fragmentShader: [
+
+ "uniform vec3 uBaseColor;",
+
+ "uniform vec3 uDirLightPos;",
+ "uniform vec3 uDirLightColor;",
+
+ "uniform vec3 uAmbientLightColor;",
+
+ "varying vec3 vNormal;",
+
+ "varying vec3 vRefract;",
+
+ "void main() {",
+
+ "float directionalLightWeighting = max( dot( normalize( vNormal ), uDirLightPos ), 0.0);",
+ "vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;",
+
+ "float intensity = smoothstep( - 0.5, 1.0, pow( length(lightWeighting), 20.0 ) );",
+ "intensity += length(lightWeighting) * 0.2;",
+
+ "float cameraWeighting = dot( normalize( vNormal ), vRefract );",
+ "intensity += pow( 1.0 - length( cameraWeighting ), 6.0 );",
+ "intensity = intensity * 0.2 + 0.3;",
+
+ "if ( intensity < 0.50 ) {",
+
+ "gl_FragColor = vec4( 2.0 * intensity * uBaseColor, 1.0 );",
+
+ "} else {",
+
+ "gl_FragColor = vec4( 1.0 - 2.0 * ( 1.0 - intensity ) * ( 1.0 - uBaseColor ), 1.0 );",
+
+ "}",
+
+ "}"
+
+ ].join( "\n" )
+
+ },
+
+ 'toon2' : {
+
+ uniforms: {
+
+ "uDirLightPos": { value: new THREE.Vector3() },
+ "uDirLightColor": { value: new THREE.Color( 0xeeeeee ) },
+
+ "uAmbientLightColor": { value: new THREE.Color( 0x050505 ) },
+
+ "uBaseColor": { value: new THREE.Color( 0xeeeeee ) },
+ "uLineColor1": { value: new THREE.Color( 0x808080 ) },
+ "uLineColor2": { value: new THREE.Color( 0x000000 ) },
+ "uLineColor3": { value: new THREE.Color( 0x000000 ) },
+ "uLineColor4": { value: new THREE.Color( 0x000000 ) }
+
+ },
+
+ vertexShader: [
+
+ "varying vec3 vNormal;",
+
+ "void main() {",
+
+ "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+ "vNormal = normalize( normalMatrix * normal );",
+
+ "}"
+
+ ].join( "\n" ),
+
+ fragmentShader: [
+
+ "uniform vec3 uBaseColor;",
+ "uniform vec3 uLineColor1;",
+ "uniform vec3 uLineColor2;",
+ "uniform vec3 uLineColor3;",
+ "uniform vec3 uLineColor4;",
+
+ "uniform vec3 uDirLightPos;",
+ "uniform vec3 uDirLightColor;",
+
+ "uniform vec3 uAmbientLightColor;",
+
+ "varying vec3 vNormal;",
+
+ "void main() {",
+
+ "float camera = max( dot( normalize( vNormal ), vec3( 0.0, 0.0, 1.0 ) ), 0.4);",
+ "float light = max( dot( normalize( vNormal ), uDirLightPos ), 0.0);",
+
+ "gl_FragColor = vec4( uBaseColor, 1.0 );",
+
+ "if ( length(uAmbientLightColor + uDirLightColor * light) < 1.00 ) {",
+
+ "gl_FragColor *= vec4( uLineColor1, 1.0 );",
+
+ "}",
+
+ "if ( length(uAmbientLightColor + uDirLightColor * camera) < 0.50 ) {",
+
+ "gl_FragColor *= vec4( uLineColor2, 1.0 );",
+
+ "}",
+
+ "}"
+
+ ].join( "\n" )
+
+ },
+
+ 'hatching' : {
+
+ uniforms: {
+
+ "uDirLightPos": { value: new THREE.Vector3() },
+ "uDirLightColor": { value: new THREE.Color( 0xeeeeee ) },
+
+ "uAmbientLightColor": { value: new THREE.Color( 0x050505 ) },
+
+ "uBaseColor": { value: new THREE.Color( 0xffffff ) },
+ "uLineColor1": { value: new THREE.Color( 0x000000 ) },
+ "uLineColor2": { value: new THREE.Color( 0x000000 ) },
+ "uLineColor3": { value: new THREE.Color( 0x000000 ) },
+ "uLineColor4": { value: new THREE.Color( 0x000000 ) }
+
+ },
+
+ vertexShader: [
+
+ "varying vec3 vNormal;",
+
+ "void main() {",
+
+ "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+ "vNormal = normalize( normalMatrix * normal );",
+
+ "}"
+
+ ].join( "\n" ),
+
+ fragmentShader: [
+
+ "uniform vec3 uBaseColor;",
+ "uniform vec3 uLineColor1;",
+ "uniform vec3 uLineColor2;",
+ "uniform vec3 uLineColor3;",
+ "uniform vec3 uLineColor4;",
+
+ "uniform vec3 uDirLightPos;",
+ "uniform vec3 uDirLightColor;",
+
+ "uniform vec3 uAmbientLightColor;",
+
+ "varying vec3 vNormal;",
+
+ "void main() {",
+
+ "float directionalLightWeighting = max( dot( normalize(vNormal), uDirLightPos ), 0.0);",
+ "vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;",
+
+ "gl_FragColor = vec4( uBaseColor, 1.0 );",
+
+ "if ( length(lightWeighting) < 1.00 ) {",
+
+ "if ( mod(gl_FragCoord.x + gl_FragCoord.y, 10.0) == 0.0) {",
+
+ "gl_FragColor = vec4( uLineColor1, 1.0 );",
+
+ "}",
+
+ "}",
+
+ "if ( length(lightWeighting) < 0.75 ) {",
+
+ "if (mod(gl_FragCoord.x - gl_FragCoord.y, 10.0) == 0.0) {",
+
+ "gl_FragColor = vec4( uLineColor2, 1.0 );",
+
+ "}",
+ "}",
+
+ "if ( length(lightWeighting) < 0.50 ) {",
+
+ "if (mod(gl_FragCoord.x + gl_FragCoord.y - 5.0, 10.0) == 0.0) {",
+
+ "gl_FragColor = vec4( uLineColor3, 1.0 );",
+
+ "}",
+ "}",
+
+ "if ( length(lightWeighting) < 0.3465 ) {",
+
+ "if (mod(gl_FragCoord.x - gl_FragCoord.y - 5.0, 10.0) == 0.0) {",
+
+ "gl_FragColor = vec4( uLineColor4, 1.0 );",
+
+ "}",
+ "}",
+
+ "}"
+
+ ].join( "\n" )
+
+ },
+
+ 'dotted' : {
+
+ uniforms: {
+
+ "uDirLightPos": { value: new THREE.Vector3() },
+ "uDirLightColor": { value: new THREE.Color( 0xeeeeee ) },
+
+ "uAmbientLightColor": { value: new THREE.Color( 0x050505 ) },
+
+ "uBaseColor": { value: new THREE.Color( 0xffffff ) },
+ "uLineColor1": { value: new THREE.Color( 0x000000 ) }
+
+ },
+
+ vertexShader: [
+
+ "varying vec3 vNormal;",
+
+ "void main() {",
+
+ "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+ "vNormal = normalize( normalMatrix * normal );",
+
+ "}"
+
+ ].join( "\n" ),
+
+ fragmentShader: [
+
+ "uniform vec3 uBaseColor;",
+ "uniform vec3 uLineColor1;",
+ "uniform vec3 uLineColor2;",
+ "uniform vec3 uLineColor3;",
+ "uniform vec3 uLineColor4;",
+
+ "uniform vec3 uDirLightPos;",
+ "uniform vec3 uDirLightColor;",
+
+ "uniform vec3 uAmbientLightColor;",
+
+ "varying vec3 vNormal;",
+
+ "void main() {",
+
+ "float directionalLightWeighting = max( dot( normalize(vNormal), uDirLightPos ), 0.0);",
+ "vec3 lightWeighting = uAmbientLightColor + uDirLightColor * directionalLightWeighting;",
+
+ "gl_FragColor = vec4( uBaseColor, 1.0 );",
+
+ "if ( length(lightWeighting) < 1.00 ) {",
+
+ "if ( ( mod(gl_FragCoord.x, 4.001) + mod(gl_FragCoord.y, 4.0) ) > 6.00 ) {",
+
+ "gl_FragColor = vec4( uLineColor1, 1.0 );",
+
+ "}",
+
+ "}",
+
+ "if ( length(lightWeighting) < 0.50 ) {",
+
+ "if ( ( mod(gl_FragCoord.x + 2.0, 4.001) + mod(gl_FragCoord.y + 2.0, 4.0) ) > 6.00 ) {",
+
+ "gl_FragColor = vec4( uLineColor1, 1.0 );",
+
+ "}",
+
+ "}",
+
+ "}"
+
+ ].join( "\n" )
+
+ }
+
+};
diff --git a/three/jsutil/ShaderTranslucent.js b/three/jsutil/ShaderTranslucent.js
new file mode 100644
index 000000000..515bd7fdb
--- /dev/null
+++ b/three/jsutil/ShaderTranslucent.js
@@ -0,0 +1,206 @@
+/**
+ * @author daoshengmu / http://dsmu.me/
+ *
+ */
+
+
+THREE.TranslucentShader = function TranslucentShader() {
+
+ /* ------------------------------------------------------------------------------------------
+ // Subsurface Scattering shader
+ // - Base on GDC 2011 – Approximating Translucency for a Fast, Cheap and Convincing Subsurface Scattering Look
+ // https://colinbarrebrisebois.com/2011/03/07/gdc-2011-approximating-translucency-for-a-fast-cheap-and-convincing-subsurface-scattering-look/
+ // ------------------------------------------------------------------------------------------ */
+
+ this.uniforms = THREE.UniformsUtils.merge( [
+
+ THREE.UniformsLib[ "common" ],
+ THREE.UniformsLib[ "lights" ],
+
+ {
+ "color": { value: new THREE.Color( 0xffffff ) },
+ "diffuse": { value: new THREE.Color( 0xffffff ) },
+ "specular": { value: new THREE.Color( 0xffffff ) },
+ "emissive": { value: new THREE.Color( 0x000000 ) },
+ "opacity": { value: 1 },
+ "shininess": { value: 1 },
+
+ "thicknessMap": { value: null },
+ "thicknessColor": { value: new THREE.Color( 0xffffff ) },
+ "thicknessDistortion": { value: 0.1 },
+ "thicknessAmbient": { value: 0.0 },
+ "thicknessAttenuation": { value: 0.1 },
+ "thicknessPower": { value: 2.0 },
+ "thicknessScale": { value: 10.0 }
+ }
+
+ ] );
+
+ this.fragmentShader = [
+ "#define USE_MAP",
+ "#define PHONG",
+ "#define TRANSLUCENT",
+ "#include ",
+ "#include ",
+ "#include ",
+ "#include ",
+ "#include ",
+
+ "varying vec3 vColor;",
+
+ "uniform vec3 diffuse;",
+ "uniform vec3 specular;",
+ "uniform vec3 emissive;",
+ "uniform float opacity;",
+ "uniform float shininess;",
+
+ // Translucency
+ "uniform sampler2D thicknessMap;",
+ "uniform float thicknessPower;",
+ "uniform float thicknessScale;",
+ "uniform float thicknessDistortion;",
+ "uniform float thicknessAmbient;",
+ "uniform float thicknessAttenuation;",
+ "uniform vec3 thicknessColor;",
+
+ THREE.ShaderChunk[ "lights_pars_begin" ],
+
+ "void RE_Direct_Scattering(const in IncidentLight directLight, const in vec2 uv, const in GeometricContext geometry, inout ReflectedLight reflectedLight) {",
+ " vec3 thickness = thicknessColor * texture2D(thicknessMap, uv).r;",
+ " vec3 scatteringHalf = normalize(directLight.direction + (geometry.normal * thicknessDistortion));",
+ " float scatteringDot = pow(saturate(dot(geometry.viewDir, -scatteringHalf)), thicknessPower) * thicknessScale;",
+ " vec3 scatteringIllu = (scatteringDot + thicknessAmbient) * thickness;",
+ " reflectedLight.directDiffuse += scatteringIllu * thicknessAttenuation * directLight.color;",
+ "}",
+
+ "void main() {",
+
+ " vec3 normal = normalize( vNormal );",
+
+ " vec3 viewerDirection = normalize( vViewPosition );",
+
+ " vec4 diffuseColor = vec4( diffuse, opacity );",
+ " ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );",
+
+ THREE.ShaderChunk[ "map_fragment" ],
+ THREE.ShaderChunk[ "color_fragment" ],
+ THREE.ShaderChunk[ "specularmap_fragment" ],
+
+ " vec3 totalEmissiveRadiance = emissive;",
+
+ THREE.ShaderChunk["lights_phong_fragment"],
+
+ // Doing lights fragment begin.
+ " GeometricContext geometry;",
+ " geometry.position = - vViewPosition;",
+ " geometry.normal = normal;",
+ " geometry.viewDir = normalize( vViewPosition );",
+
+ " IncidentLight directLight;",
+
+ " #if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )",
+
+ " PointLight pointLight;",
+
+ " #pragma unroll_loop",
+ " for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {",
+ " pointLight = pointLights[ i ];",
+ " getPointDirectLightIrradiance( pointLight, geometry, directLight );",
+
+ " #ifdef USE_SHADOWMAP",
+ " directLight.color *= all( bvec2( pointLight.shadow, directLight.visible ) ) ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;",
+ " #endif",
+
+ " RE_Direct( directLight, geometry, material, reflectedLight );",
+
+ " #if defined( TRANSLUCENT ) && defined( USE_MAP )",
+ " RE_Direct_Scattering(directLight, vUv, geometry, reflectedLight);",
+ " #endif",
+ " }",
+
+ " #endif",
+
+ " #if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )",
+
+ " DirectionalLight directionalLight;",
+
+ " #pragma unroll_loop",
+ " for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {",
+ " directionalLight = directionalLights[ i ];",
+ " getDirectionalDirectLightIrradiance( directionalLight, geometry, directLight );",
+
+ " #ifdef USE_SHADOWMAP",
+ " directLight.color *= all( bvec2( directionalLight.shadow, directLight.visible ) ) ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;",
+ " #endif",
+
+ " RE_Direct( directLight, geometry, material, reflectedLight );",
+
+ " #if defined( TRANSLUCENT ) && defined( USE_MAP )",
+ " RE_Direct_Scattering(directLight, vUv, geometry, reflectedLight);",
+ " #endif",
+ " }",
+
+ " #endif",
+
+ " #if defined( RE_IndirectDiffuse )",
+
+ " vec3 irradiance = getAmbientLightIrradiance( ambientLightColor );",
+
+ " #if ( NUM_HEMI_LIGHTS > 0 )",
+
+ " #pragma unroll_loop",
+ " for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {",
+
+ " irradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );",
+
+ " }",
+
+ " #endif",
+
+ " #endif",
+
+ " #if defined( RE_IndirectSpecular )",
+
+ " vec3 radiance = vec3( 0.0 );",
+ " vec3 clearCoatRadiance = vec3( 0.0 );",
+
+ " #endif",
+ THREE.ShaderChunk["lights_fragment_end"],
+
+ " vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;",
+ " gl_FragColor = vec4( outgoingLight, diffuseColor.a );", // TODO, this should be pre-multiplied to allow for bright highlights on very transparent objects
+
+ THREE.ShaderChunk["encodings_fragment"],
+
+ "}"
+
+ ].join( "\n" ),
+
+ this.vertexShader = [
+
+ "varying vec3 vNormal;",
+ "varying vec2 vUv;",
+
+ "varying vec3 vViewPosition;",
+
+ THREE.ShaderChunk[ "common" ],
+
+ "void main() {",
+
+ " vec4 worldPosition = modelMatrix * vec4( position, 1.0 );",
+
+ " vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );",
+
+ " vViewPosition = -mvPosition.xyz;",
+
+ " vNormal = normalize( normalMatrix * normal );",
+
+ " vUv = uv;",
+
+ " gl_Position = projectionMatrix * mvPosition;",
+
+ "}",
+
+ ].join( "\n" )
+
+};
diff --git a/three/jsutil/SimplexNoise.js b/three/jsutil/SimplexNoise.js
new file mode 100644
index 000000000..235b6accb
--- /dev/null
+++ b/three/jsutil/SimplexNoise.js
@@ -0,0 +1,324 @@
+// Ported from Stefan Gustavson's java implementation
+// http://staffwww.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf
+// Read Stefan's excellent paper for details on how this code works.
+//
+// Sean McCullough banksean@gmail.com
+//
+// Added 4D noise
+// Joshua Koo zz85nus@gmail.com
+
+/**
+ * You can pass in a random number generator object if you like.
+ * It is assumed to have a random() method.
+ */
+var SimplexNoise = function(r) {
+ if (r == undefined) r = Math;
+ this.grad3 = [[ 1,1,0 ],[ -1,1,0 ],[ 1,-1,0 ],[ -1,-1,0 ],
+ [ 1,0,1 ],[ -1,0,1 ],[ 1,0,-1 ],[ -1,0,-1 ],
+ [ 0,1,1 ],[ 0,-1,1 ],[ 0,1,-1 ],[ 0,-1,-1 ]];
+
+ this.grad4 = [[ 0,1,1,1 ], [ 0,1,1,-1 ], [ 0,1,-1,1 ], [ 0,1,-1,-1 ],
+ [ 0,-1,1,1 ], [ 0,-1,1,-1 ], [ 0,-1,-1,1 ], [ 0,-1,-1,-1 ],
+ [ 1,0,1,1 ], [ 1,0,1,-1 ], [ 1,0,-1,1 ], [ 1,0,-1,-1 ],
+ [ -1,0,1,1 ], [ -1,0,1,-1 ], [ -1,0,-1,1 ], [ -1,0,-1,-1 ],
+ [ 1,1,0,1 ], [ 1,1,0,-1 ], [ 1,-1,0,1 ], [ 1,-1,0,-1 ],
+ [ -1,1,0,1 ], [ -1,1,0,-1 ], [ -1,-1,0,1 ], [ -1,-1,0,-1 ],
+ [ 1,1,1,0 ], [ 1,1,-1,0 ], [ 1,-1,1,0 ], [ 1,-1,-1,0 ],
+ [ -1,1,1,0 ], [ -1,1,-1,0 ], [ -1,-1,1,0 ], [ -1,-1,-1,0 ]];
+
+ this.p = [];
+ for (var i = 0; i < 256; i ++) {
+ this.p[i] = Math.floor(r.random() * 256);
+ }
+ // To remove the need for index wrapping, double the permutation table length
+ this.perm = [];
+ for (var i = 0; i < 512; i ++) {
+ this.perm[i] = this.p[i & 255];
+ }
+
+ // A lookup table to traverse the simplex around a given point in 4D.
+ // Details can be found where this table is used, in the 4D noise method.
+ this.simplex = [
+ [ 0,1,2,3 ],[ 0,1,3,2 ],[ 0,0,0,0 ],[ 0,2,3,1 ],[ 0,0,0,0 ],[ 0,0,0,0 ],[ 0,0,0,0 ],[ 1,2,3,0 ],
+ [ 0,2,1,3 ],[ 0,0,0,0 ],[ 0,3,1,2 ],[ 0,3,2,1 ],[ 0,0,0,0 ],[ 0,0,0,0 ],[ 0,0,0,0 ],[ 1,3,2,0 ],
+ [ 0,0,0,0 ],[ 0,0,0,0 ],[ 0,0,0,0 ],[ 0,0,0,0 ],[ 0,0,0,0 ],[ 0,0,0,0 ],[ 0,0,0,0 ],[ 0,0,0,0 ],
+ [ 1,2,0,3 ],[ 0,0,0,0 ],[ 1,3,0,2 ],[ 0,0,0,0 ],[ 0,0,0,0 ],[ 0,0,0,0 ],[ 2,3,0,1 ],[ 2,3,1,0 ],
+ [ 1,0,2,3 ],[ 1,0,3,2 ],[ 0,0,0,0 ],[ 0,0,0,0 ],[ 0,0,0,0 ],[ 2,0,3,1 ],[ 0,0,0,0 ],[ 2,1,3,0 ],
+ [ 0,0,0,0 ],[ 0,0,0,0 ],[ 0,0,0,0 ],[ 0,0,0,0 ],[ 0,0,0,0 ],[ 0,0,0,0 ],[ 0,0,0,0 ],[ 0,0,0,0 ],
+ [ 2,0,1,3 ],[ 0,0,0,0 ],[ 0,0,0,0 ],[ 0,0,0,0 ],[ 3,0,1,2 ],[ 3,0,2,1 ],[ 0,0,0,0 ],[ 3,1,2,0 ],
+ [ 2,1,0,3 ],[ 0,0,0,0 ],[ 0,0,0,0 ],[ 0,0,0,0 ],[ 3,1,0,2 ],[ 0,0,0,0 ],[ 3,2,0,1 ],[ 3,2,1,0 ]];
+};
+
+SimplexNoise.prototype.dot = function(g, x, y) {
+ return g[0] * x + g[1] * y;
+};
+
+SimplexNoise.prototype.dot3 = function(g, x, y, z) {
+ return g[0] * x + g[1] * y + g[2] * z;
+};
+
+SimplexNoise.prototype.dot4 = function(g, x, y, z, w) {
+ return g[0] * x + g[1] * y + g[2] * z + g[3] * w;
+};
+
+SimplexNoise.prototype.noise = function(xin, yin) {
+ var n0, n1, n2; // Noise contributions from the three corners
+ // Skew the input space to determine which simplex cell we're in
+ var F2 = 0.5 * (Math.sqrt(3.0) - 1.0);
+ var s = (xin + yin) * F2; // Hairy factor for 2D
+ var i = Math.floor(xin + s);
+ var j = Math.floor(yin + s);
+ var G2 = (3.0 - Math.sqrt(3.0)) / 6.0;
+ var t = (i + j) * G2;
+ var X0 = i - t; // Unskew the cell origin back to (x,y) space
+ var Y0 = j - t;
+ var x0 = xin - X0; // The x,y distances from the cell origin
+ var y0 = yin - Y0;
+ // For the 2D case, the simplex shape is an equilateral triangle.
+ // Determine which simplex we are in.
+ var i1, j1; // Offsets for second (middle) corner of simplex in (i,j) coords
+ if (x0 > y0) {i1 = 1; j1 = 0;} // lower triangle, XY order: (0,0)->(1,0)->(1,1)
+ else {i1 = 0; j1 = 1;} // upper triangle, YX order: (0,0)->(0,1)->(1,1)
+ // A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
+ // a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
+ // c = (3-sqrt(3))/6
+ var x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords
+ var y1 = y0 - j1 + G2;
+ var x2 = x0 - 1.0 + 2.0 * G2; // Offsets for last corner in (x,y) unskewed coords
+ var y2 = y0 - 1.0 + 2.0 * G2;
+ // Work out the hashed gradient indices of the three simplex corners
+ var ii = i & 255;
+ var jj = j & 255;
+ var gi0 = this.perm[ii + this.perm[jj]] % 12;
+ var gi1 = this.perm[ii + i1 + this.perm[jj + j1]] % 12;
+ var gi2 = this.perm[ii + 1 + this.perm[jj + 1]] % 12;
+ // Calculate the contribution from the three corners
+ var t0 = 0.5 - x0 * x0 - y0 * y0;
+ if (t0 < 0) n0 = 0.0;
+ else {
+ t0 *= t0;
+ n0 = t0 * t0 * this.dot(this.grad3[gi0], x0, y0); // (x,y) of grad3 used for 2D gradient
+ }
+ var t1 = 0.5 - x1 * x1 - y1 * y1;
+ if (t1 < 0) n1 = 0.0;
+ else {
+ t1 *= t1;
+ n1 = t1 * t1 * this.dot(this.grad3[gi1], x1, y1);
+ }
+ var t2 = 0.5 - x2 * x2 - y2 * y2;
+ if (t2 < 0) n2 = 0.0;
+ else {
+ t2 *= t2;
+ n2 = t2 * t2 * this.dot(this.grad3[gi2], x2, y2);
+ }
+ // Add contributions from each corner to get the final noise value.
+ // The result is scaled to return values in the interval [-1,1].
+ return 70.0 * (n0 + n1 + n2);
+};
+
+// 3D simplex noise
+SimplexNoise.prototype.noise3d = function(xin, yin, zin) {
+ var n0, n1, n2, n3; // Noise contributions from the four corners
+ // Skew the input space to determine which simplex cell we're in
+ var F3 = 1.0 / 3.0;
+ var s = (xin + yin + zin) * F3; // Very nice and simple skew factor for 3D
+ var i = Math.floor(xin + s);
+ var j = Math.floor(yin + s);
+ var k = Math.floor(zin + s);
+ var G3 = 1.0 / 6.0; // Very nice and simple unskew factor, too
+ var t = (i + j + k) * G3;
+ var X0 = i - t; // Unskew the cell origin back to (x,y,z) space
+ var Y0 = j - t;
+ var Z0 = k - t;
+ var x0 = xin - X0; // The x,y,z distances from the cell origin
+ var y0 = yin - Y0;
+ var z0 = zin - Z0;
+ // For the 3D case, the simplex shape is a slightly irregular tetrahedron.
+ // Determine which simplex we are in.
+ var i1, j1, k1; // Offsets for second corner of simplex in (i,j,k) coords
+ var i2, j2, k2; // Offsets for third corner of simplex in (i,j,k) coords
+ if (x0 >= y0) {
+ if (y0 >= z0)
+ { i1 = 1; j1 = 0; k1 = 0; i2 = 1; j2 = 1; k2 = 0; } // X Y Z order
+ else if (x0 >= z0) { i1 = 1; j1 = 0; k1 = 0; i2 = 1; j2 = 0; k2 = 1; } // X Z Y order
+ else { i1 = 0; j1 = 0; k1 = 1; i2 = 1; j2 = 0; k2 = 1; } // Z X Y order
+ }
+ else { // x0 y0) ? 32 : 0;
+ var c2 = (x0 > z0) ? 16 : 0;
+ var c3 = (y0 > z0) ? 8 : 0;
+ var c4 = (x0 > w0) ? 4 : 0;
+ var c5 = (y0 > w0) ? 2 : 0;
+ var c6 = (z0 > w0) ? 1 : 0;
+ var c = c1 + c2 + c3 + c4 + c5 + c6;
+ var i1, j1, k1, l1; // The integer offsets for the second simplex corner
+ var i2, j2, k2, l2; // The integer offsets for the third simplex corner
+ var i3, j3, k3, l3; // The integer offsets for the fourth simplex corner
+ // simplex[c] is a 4-vector with the numbers 0, 1, 2 and 3 in some order.
+ // Many values of c will never occur, since e.g. x>y>z>w makes x= 3 ? 1 : 0;
+ j1 = simplex[c][1] >= 3 ? 1 : 0;
+ k1 = simplex[c][2] >= 3 ? 1 : 0;
+ l1 = simplex[c][3] >= 3 ? 1 : 0;
+ // The number 2 in the "simplex" array is at the second largest coordinate.
+ i2 = simplex[c][0] >= 2 ? 1 : 0;
+ j2 = simplex[c][1] >= 2 ? 1 : 0; k2 = simplex[c][2] >= 2 ? 1 : 0;
+ l2 = simplex[c][3] >= 2 ? 1 : 0;
+ // The number 1 in the "simplex" array is at the second smallest coordinate.
+ i3 = simplex[c][0] >= 1 ? 1 : 0;
+ j3 = simplex[c][1] >= 1 ? 1 : 0;
+ k3 = simplex[c][2] >= 1 ? 1 : 0;
+ l3 = simplex[c][3] >= 1 ? 1 : 0;
+ // The fifth corner has all coordinate offsets = 1, so no need to look that up.
+ var x1 = x0 - i1 + G4; // Offsets for second corner in (x,y,z,w) coords
+ var y1 = y0 - j1 + G4;
+ var z1 = z0 - k1 + G4;
+ var w1 = w0 - l1 + G4;
+ var x2 = x0 - i2 + 2.0 * G4; // Offsets for third corner in (x,y,z,w) coords
+ var y2 = y0 - j2 + 2.0 * G4;
+ var z2 = z0 - k2 + 2.0 * G4;
+ var w2 = w0 - l2 + 2.0 * G4;
+ var x3 = x0 - i3 + 3.0 * G4; // Offsets for fourth corner in (x,y,z,w) coords
+ var y3 = y0 - j3 + 3.0 * G4;
+ var z3 = z0 - k3 + 3.0 * G4;
+ var w3 = w0 - l3 + 3.0 * G4;
+ var x4 = x0 - 1.0 + 4.0 * G4; // Offsets for last corner in (x,y,z,w) coords
+ var y4 = y0 - 1.0 + 4.0 * G4;
+ var z4 = z0 - 1.0 + 4.0 * G4;
+ var w4 = w0 - 1.0 + 4.0 * G4;
+ // Work out the hashed gradient indices of the five simplex corners
+ var ii = i & 255;
+ var jj = j & 255;
+ var kk = k & 255;
+ var ll = l & 255;
+ var gi0 = perm[ii + perm[jj + perm[kk + perm[ll]]]] % 32;
+ var gi1 = perm[ii + i1 + perm[jj + j1 + perm[kk + k1 + perm[ll + l1]]]] % 32;
+ var gi2 = perm[ii + i2 + perm[jj + j2 + perm[kk + k2 + perm[ll + l2]]]] % 32;
+ var gi3 = perm[ii + i3 + perm[jj + j3 + perm[kk + k3 + perm[ll + l3]]]] % 32;
+ var gi4 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] % 32;
+ // Calculate the contribution from the five corners
+ var t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0 - w0 * w0;
+ if (t0 < 0) n0 = 0.0;
+ else {
+ t0 *= t0;
+ n0 = t0 * t0 * this.dot4(grad4[gi0], x0, y0, z0, w0);
+ }
+ var t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1 - w1 * w1;
+ if (t1 < 0) n1 = 0.0;
+ else {
+ t1 *= t1;
+ n1 = t1 * t1 * this.dot4(grad4[gi1], x1, y1, z1, w1);
+ }
+ var t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2 - w2 * w2;
+ if (t2 < 0) n2 = 0.0;
+ else {
+ t2 *= t2;
+ n2 = t2 * t2 * this.dot4(grad4[gi2], x2, y2, z2, w2);
+ } var t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3 - w3 * w3;
+ if (t3 < 0) n3 = 0.0;
+ else {
+ t3 *= t3;
+ n3 = t3 * t3 * this.dot4(grad4[gi3], x3, y3, z3, w3);
+ }
+ var t4 = 0.6 - x4 * x4 - y4 * y4 - z4 * z4 - w4 * w4;
+ if (t4 < 0) n4 = 0.0;
+ else {
+ t4 *= t4;
+ n4 = t4 * t4 * this.dot4(grad4[gi4], x4, y4, z4, w4);
+ }
+ // Sum up and scale the result to cover the range [-1,1]
+ return 27.0 * (n0 + n1 + n2 + n3 + n4);
+};
diff --git a/three/jsutil/TimelinerController.js b/three/jsutil/TimelinerController.js
new file mode 100644
index 000000000..7e1b29199
--- /dev/null
+++ b/three/jsutil/TimelinerController.js
@@ -0,0 +1,280 @@
+/**
+ * Controller class for the Timeliner GUI.
+ *
+ * Timeliner GUI library (required to use this class):
+ *
+ * ./libs/timeliner_gui.min.js
+ *
+ * Source code:
+ *
+ * https://github.com/tschw/timeliner_gui
+ * https://github.com/zz85/timeliner (fork's origin)
+ *
+ * @author tschw
+ *
+ */
+
+THREE.TimelinerController = function TimelinerController( scene, trackInfo, onUpdate ) {
+
+ this._scene = scene;
+ this._trackInfo = trackInfo;
+
+ this._onUpdate = onUpdate;
+
+ this._mixer = new THREE.AnimationMixer( scene );
+ this._clip = null;
+ this._action = null;
+
+ this._tracks = {};
+ this._propRefs = {};
+ this._channelNames = [];
+
+};
+
+THREE.TimelinerController.prototype = {
+
+ constructor: THREE.TimelinerController,
+
+ init: function( timeliner ) {
+
+ var tracks = [],
+ trackInfo = this._trackInfo;
+
+ for ( var i = 0, n = trackInfo.length; i !== n; ++ i ) {
+
+ var spec = trackInfo[ i ];
+
+ tracks.push( this._addTrack(
+ spec.type, spec.propertyPath,
+ spec.initialValue, spec.interpolation ) );
+ }
+
+ this._clip = new THREE.AnimationClip( 'editclip', 0, tracks );
+ this._action = this._mixer.clipAction( this._clip ).play();
+
+ },
+
+ setDisplayTime: function( time ) {
+
+ this._action.time = time;
+ this._mixer.update( 0 );
+
+ this._onUpdate();
+
+ },
+
+ setDuration: function( duration ) {
+
+ this._clip.duration = duration;
+
+ },
+
+ getChannelNames: function() {
+
+ return this._channelNames;
+
+ },
+
+ getChannelKeyTimes: function( channelName ) {
+
+ return this._tracks[ channelName ].times;
+
+ },
+
+ setKeyframe: function( channelName, time ) {
+
+ var track = this._tracks[ channelName ],
+ times = track.times,
+ index = Timeliner.binarySearch( times, time ),
+ values = track.values,
+ stride = track.getValueSize(),
+ offset = index * stride;
+
+ if ( index < 0 ) {
+
+ // insert new keyframe
+
+ index = ~ index;
+ offset = index * stride;
+
+ var nTimes = times.length + 1,
+ nValues = values.length + stride;
+
+ for ( var i = nTimes - 1; i !== index; -- i ) {
+
+ times[ i ] = times[ i - 1 ];
+
+ }
+
+ for ( var i = nValues - 1,
+ e = offset + stride - 1; i !== e; -- i ) {
+
+ values[ i ] = values[ i - stride ];
+
+ }
+
+ }
+
+ times[ index ] = time;
+ this._propRefs[ channelName ].getValue( values, offset );
+
+ },
+
+ delKeyframe: function( channelName, time ) {
+
+ var track = this._tracks[ channelName ],
+ times = track.times,
+ index = Timeliner.binarySearch( times, time );
+
+ // we disallow to remove the keyframe when it is the last one we have,
+ // since the animation system is designed to always produce a defined
+ // state
+
+ if ( times.length > 1 && index >= 0 ) {
+
+ var nTimes = times.length - 1,
+ values = track.values,
+ stride = track.getValueSize(),
+ nValues = values.length - stride;
+
+ // note: no track.getValueSize when array sizes are out of sync
+
+ for ( var i = index; i !== nTimes; ++ i ) {
+
+ times[ i ] = times[ i + 1 ];
+
+ }
+
+ times.pop();
+
+ for ( var offset = index * stride; offset !== nValues; ++ offset ) {
+
+ values[ offset ] = values[ offset + stride ];
+
+ }
+
+ values.length = nValues;
+
+ }
+
+ },
+
+ moveKeyframe: function( channelName, time, delta, moveRemaining ) {
+
+ var track = this._tracks[ channelName ],
+ times = track.times,
+ index = Timeliner.binarySearch( times, time );
+
+ if ( index >= 0 ) {
+
+ var endAt = moveRemaining ? times.length : index + 1,
+ needsSort = times[ index - 1 ] <= time ||
+ ! moveRemaining && time >= times[ index + 1 ];
+
+ while ( index !== endAt ) times[ index ++ ] += delta;
+
+ if ( needsSort ) this._sort( track );
+
+ }
+
+ },
+
+ serialize: function() {
+
+ var result = {
+ duration: this._clip.duration,
+ channels: {}
+ },
+
+ names = this._channelNames,
+ tracks = this._tracks,
+
+ channels = result.channels;
+
+ for ( var i = 0, n = names.length; i !== n; ++ i ) {
+
+ var name = names[ i ],
+ track = tracks[ name ];
+
+ channels[ name ] = {
+
+ times: track.times,
+ values: track.values
+
+ };
+
+ }
+
+ return result;
+
+ },
+
+ deserialize: function( structs ) {
+
+ var names = this._channelNames,
+ tracks = this._tracks,
+
+ channels = structs.channels;
+
+ this.setDuration( structs.duration );
+
+ for ( var i = 0, n = names.length; i !== n; ++ i ) {
+
+ var name = names[ i ],
+ track = tracks[ name ],
+ data = channels[ name ];
+
+ this._setArray( track.times, data.times );
+ this._setArray( track.values, data.values );
+
+ }
+
+ // update display
+ this.setDisplayTime( this._mixer.time );
+
+ },
+
+ _sort: function( track ) {
+
+ var times = track.times,
+ order = THREE.AnimationUtils.getKeyframeOrder( times );
+
+ this._setArray( times,
+ THREE.AnimationUtils.sortedArray( times, 1, order ) );
+
+ var values = track.values,
+ stride = track.getValueSize();
+
+ this._setArray( values,
+ THREE.AnimationUtils.sortedArray( values, stride, order ) );
+
+ },
+
+ _setArray: function( dst, src ) {
+
+ dst.length = 0;
+ dst.push.apply( dst, src );
+
+ },
+
+ _addTrack: function( type, prop, initialValue, interpolation ) {
+
+ var track = new type(
+ prop, [ 0 ], initialValue, interpolation );
+
+ // data must be in JS arrays so it can be resized
+ track.times = Array.prototype.slice.call( track.times );
+ track.values = Array.prototype.slice.call( track.values );
+
+ this._channelNames.push( prop );
+ this._tracks[ prop ] = track;
+
+ // for recording the state:
+ this._propRefs[ prop ] =
+ new THREE.PropertyBinding( this._scene, prop );
+
+ return track;
+
+ }
+
+};
diff --git a/three/jsutil/TypedArrayUtils.js b/three/jsutil/TypedArrayUtils.js
new file mode 100644
index 000000000..22024ce72
--- /dev/null
+++ b/three/jsutil/TypedArrayUtils.js
@@ -0,0 +1,602 @@
+
+THREE.TypedArrayUtils = {};
+
+/**
+ * In-place quicksort for typed arrays (e.g. for Float32Array)
+ * provides fast sorting
+ * useful e.g. for a custom shader and/or BufferGeometry
+ *
+ * @author Roman Bolzern , 2013
+ * @author I4DS http://www.fhnw.ch/i4ds, 2013
+ * @license MIT License
+ *
+ * Complexity: http://bigocheatsheet.com/ see Quicksort
+ *
+ * Example:
+ * points: [x, y, z, x, y, z, x, y, z, ...]
+ * eleSize: 3 //because of (x, y, z)
+ * orderElement: 0 //order according to x
+ */
+
+THREE.TypedArrayUtils.quicksortIP = function ( arr, eleSize, orderElement ) {
+
+ var stack = [];
+ var sp = - 1;
+ var left = 0;
+ var right = arr.length / eleSize - 1;
+ var tmp = 0.0, x = 0, y = 0;
+
+ var swapF = function ( a, b ) {
+
+ a *= eleSize; b *= eleSize;
+
+ for ( y = 0; y < eleSize; y ++ ) {
+
+ tmp = arr[ a + y ];
+ arr[ a + y ] = arr[ b + y ];
+ arr[ b + y ] = tmp;
+
+ }
+
+ };
+
+ var i, j, swap = new Float32Array( eleSize ), temp = new Float32Array( eleSize );
+
+ while ( true ) {
+
+ if ( right - left <= 25 ) {
+
+ for ( j = left + 1; j <= right; j ++ ) {
+
+ for ( x = 0; x < eleSize; x ++ ) {
+
+ swap[ x ] = arr[ j * eleSize + x ];
+
+ }
+
+ i = j - 1;
+
+ while ( i >= left && arr[ i * eleSize + orderElement ] > swap[ orderElement ] ) {
+
+ for ( x = 0; x < eleSize; x ++ ) {
+
+ arr[ ( i + 1 ) * eleSize + x ] = arr[ i * eleSize + x ];
+
+ }
+
+ i --;
+
+ }
+
+ for ( x = 0; x < eleSize; x ++ ) {
+
+ arr[ ( i + 1 ) * eleSize + x ] = swap[ x ];
+
+ }
+
+ }
+
+ if ( sp == - 1 ) break;
+
+ right = stack[ sp -- ]; //?
+ left = stack[ sp -- ];
+
+ } else {
+
+ var median = ( left + right ) >> 1;
+
+ i = left + 1;
+ j = right;
+
+ swapF( median, i );
+
+ if ( arr[ left * eleSize + orderElement ] > arr[ right * eleSize + orderElement ] ) {
+
+ swapF( left, right );
+
+ }
+
+ if ( arr[ i * eleSize + orderElement ] > arr[ right * eleSize + orderElement ] ) {
+
+ swapF( i, right );
+
+ }
+
+ if ( arr[ left * eleSize + orderElement ] > arr[ i * eleSize + orderElement ] ) {
+
+ swapF( left, i );
+
+ }
+
+ for ( x = 0; x < eleSize; x ++ ) {
+
+ temp[ x ] = arr[ i * eleSize + x ];
+
+ }
+
+ while ( true ) {
+
+ do i ++; while ( arr[ i * eleSize + orderElement ] < temp[ orderElement ] );
+ do j --; while ( arr[ j * eleSize + orderElement ] > temp[ orderElement ] );
+
+ if ( j < i ) break;
+
+ swapF( i, j );
+
+ }
+
+ for ( x = 0; x < eleSize; x ++ ) {
+
+ arr[ ( left + 1 ) * eleSize + x ] = arr[ j * eleSize + x ];
+ arr[ j * eleSize + x ] = temp[ x ];
+
+ }
+
+ if ( right - i + 1 >= j - left ) {
+
+ stack[ ++ sp ] = i;
+ stack[ ++ sp ] = right;
+ right = j - 1;
+
+ } else {
+
+ stack[ ++ sp ] = left;
+ stack[ ++ sp ] = j - 1;
+ left = i;
+
+ }
+
+ }
+
+ }
+
+ return arr;
+
+};
+
+
+
+/**
+ * k-d Tree for typed arrays (e.g. for Float32Array), in-place
+ * provides fast nearest neighbour search
+ * useful e.g. for a custom shader and/or BufferGeometry, saves tons of memory
+ * has no insert and remove, only buildup and neares neighbour search
+ *
+ * Based on https://github.com/ubilabs/kd-tree-javascript by Ubilabs
+ *
+ * @author Roman Bolzern , 2013
+ * @author I4DS http://www.fhnw.ch/i4ds, 2013
+ * @license MIT License
+ *
+ * Requires typed array quicksort
+ *
+ * Example:
+ * points: [x, y, z, x, y, z, x, y, z, ...]
+ * metric: function(a, b){ return Math.pow(a[0] - b[0], 2) + Math.pow(a[1] - b[1], 2) + Math.pow(a[2] - b[2], 2); } //Manhatten distance
+ * eleSize: 3 //because of (x, y, z)
+ *
+ * Further information (including mathematical properties)
+ * http://en.wikipedia.org/wiki/Binary_tree
+ * http://en.wikipedia.org/wiki/K-d_tree
+ *
+ * If you want to further minimize memory usage, remove Node.depth and replace in search algorithm with a traversal to root node (see comments at THREE.TypedArrayUtils.Kdtree.prototype.Node)
+ */
+
+ THREE.TypedArrayUtils.Kdtree = function ( points, metric, eleSize ) {
+
+ var self = this;
+
+ var maxDepth = 0;
+
+ var getPointSet = function ( points, pos ) {
+
+ return points.subarray( pos * eleSize, pos * eleSize + eleSize );
+
+ };
+
+ function buildTree( points, depth, parent, pos ) {
+
+ var dim = depth % eleSize,
+ median,
+ node,
+ plength = points.length / eleSize;
+
+ if ( depth > maxDepth ) maxDepth = depth;
+
+ if ( plength === 0 ) return null;
+ if ( plength === 1 ) {
+
+ return new self.Node( getPointSet( points, 0 ), depth, parent, pos );
+
+ }
+
+ THREE.TypedArrayUtils.quicksortIP( points, eleSize, dim );
+
+ median = Math.floor( plength / 2 );
+
+ node = new self.Node( getPointSet( points, median ), depth, parent, median + pos );
+ node.left = buildTree( points.subarray( 0, median * eleSize ), depth + 1, node, pos );
+ node.right = buildTree( points.subarray( ( median + 1 ) * eleSize, points.length ), depth + 1, node, pos + median + 1 );
+
+ return node;
+
+ }
+
+ this.root = buildTree( points, 0, null, 0 );
+
+ this.getMaxDepth = function () {
+
+ return maxDepth;
+
+ };
+
+ this.nearest = function ( point, maxNodes, maxDistance ) {
+
+ /* point: array of size eleSize
+ maxNodes: max amount of nodes to return
+ maxDistance: maximum distance to point result nodes should have
+ condition (not implemented): function to test node before it's added to the result list, e.g. test for view frustum
+ */
+
+ var i,
+ result,
+ bestNodes;
+
+ bestNodes = new THREE.TypedArrayUtils.Kdtree.BinaryHeap(
+
+ function ( e ) {
+
+ return - e[ 1 ];
+
+ }
+
+ );
+
+ function nearestSearch( node ) {
+
+ var bestChild,
+ dimension = node.depth % eleSize,
+ ownDistance = metric( point, node.obj ),
+ linearDistance = 0,
+ otherChild,
+ i,
+ linearPoint = [];
+
+ function saveNode( node, distance ) {
+
+ bestNodes.push( [ node, distance ] );
+
+ if ( bestNodes.size() > maxNodes ) {
+
+ bestNodes.pop();
+
+ }
+
+ }
+
+ for ( i = 0; i < eleSize; i += 1 ) {
+
+ if ( i === node.depth % eleSize ) {
+
+ linearPoint[ i ] = point[ i ];
+
+ } else {
+
+ linearPoint[ i ] = node.obj[ i ];
+
+ }
+
+ }
+
+ linearDistance = metric( linearPoint, node.obj );
+
+ // if it's a leaf
+
+ if ( node.right === null && node.left === null ) {
+
+ if ( bestNodes.size() < maxNodes || ownDistance < bestNodes.peek()[ 1 ] ) {
+
+ saveNode( node, ownDistance );
+
+ }
+
+ return;
+
+ }
+
+ if ( node.right === null ) {
+
+ bestChild = node.left;
+
+ } else if ( node.left === null ) {
+
+ bestChild = node.right;
+
+ } else {
+
+ if ( point[ dimension ] < node.obj[ dimension ] ) {
+
+ bestChild = node.left;
+
+ } else {
+
+ bestChild = node.right;
+
+ }
+
+ }
+
+ // recursive search
+
+ nearestSearch( bestChild );
+
+ if ( bestNodes.size() < maxNodes || ownDistance < bestNodes.peek()[ 1 ] ) {
+
+ saveNode( node, ownDistance );
+
+ }
+
+ // if there's still room or the current distance is nearer than the best distance
+
+ if ( bestNodes.size() < maxNodes || Math.abs( linearDistance ) < bestNodes.peek()[ 1 ] ) {
+
+ if ( bestChild === node.left ) {
+
+ otherChild = node.right;
+
+ } else {
+
+ otherChild = node.left;
+
+ }
+
+ if ( otherChild !== null ) {
+
+ nearestSearch( otherChild );
+
+ }
+
+ }
+
+ }
+
+ if ( maxDistance ) {
+
+ for ( i = 0; i < maxNodes; i += 1 ) {
+
+ bestNodes.push( [ null, maxDistance ] );
+
+ }
+
+ }
+
+ nearestSearch( self.root );
+
+ result = [];
+
+ for ( i = 0; i < maxNodes; i += 1 ) {
+
+ if ( bestNodes.content[ i ][ 0 ] ) {
+
+ result.push( [ bestNodes.content[ i ][ 0 ], bestNodes.content[ i ][ 1 ] ] );
+
+ }
+
+ }
+
+ return result;
+
+ };
+
+};
+
+/**
+ * If you need to free up additional memory and agree with an additional O( log n ) traversal time you can get rid of "depth" and "pos" in Node:
+ * Depth can be easily done by adding 1 for every parent (care: root node has depth 0, not 1)
+ * Pos is a bit tricky: Assuming the tree is balanced (which is the case when after we built it up), perform the following steps:
+ * By traversing to the root store the path e.g. in a bit pattern (01001011, 0 is left, 1 is right)
+ * From buildTree we know that "median = Math.floor( plength / 2 );", therefore for each bit...
+ * 0: amountOfNodesRelevantForUs = Math.floor( (pamountOfNodesRelevantForUs - 1) / 2 );
+ * 1: amountOfNodesRelevantForUs = Math.ceil( (pamountOfNodesRelevantForUs - 1) / 2 );
+ * pos += Math.floor( (pamountOfNodesRelevantForUs - 1) / 2 );
+ * when recursion done, we still need to add all left children of target node:
+ * pos += Math.floor( (pamountOfNodesRelevantForUs - 1) / 2 );
+ * and I think you need to +1 for the current position, not sure.. depends, try it out ^^
+ *
+ * I experienced that for 200'000 nodes you can get rid of 4 MB memory each, leading to 8 MB memory saved.
+ */
+THREE.TypedArrayUtils.Kdtree.prototype.Node = function ( obj, depth, parent, pos ) {
+
+ this.obj = obj;
+ this.left = null;
+ this.right = null;
+ this.parent = parent;
+ this.depth = depth;
+ this.pos = pos;
+
+};
+
+/**
+ * Binary heap implementation
+ * @author http://eloquentjavascript.net/appendix2.htm
+ */
+
+THREE.TypedArrayUtils.Kdtree.BinaryHeap = function ( scoreFunction ) {
+
+ this.content = [];
+ this.scoreFunction = scoreFunction;
+
+};
+
+THREE.TypedArrayUtils.Kdtree.BinaryHeap.prototype = {
+
+ push: function ( element ) {
+
+ // Add the new element to the end of the array.
+ this.content.push( element );
+
+ // Allow it to bubble up.
+ this.bubbleUp( this.content.length - 1 );
+
+ },
+
+ pop: function () {
+
+ // Store the first element so we can return it later.
+ var result = this.content[ 0 ];
+
+ // Get the element at the end of the array.
+ var end = this.content.pop();
+
+ // If there are any elements left, put the end element at the
+ // start, and let it sink down.
+ if ( this.content.length > 0 ) {
+
+ this.content[ 0 ] = end;
+ this.sinkDown( 0 );
+
+ }
+
+ return result;
+
+ },
+
+ peek: function () {
+
+ return this.content[ 0 ];
+
+ },
+
+ remove: function ( node ) {
+
+ var len = this.content.length;
+
+ // To remove a value, we must search through the array to find it.
+ for ( var i = 0; i < len; i ++ ) {
+
+ if ( this.content[ i ] == node ) {
+
+ // When it is found, the process seen in 'pop' is repeated
+ // to fill up the hole.
+ var end = this.content.pop();
+
+ if ( i != len - 1 ) {
+
+ this.content[ i ] = end;
+
+ if ( this.scoreFunction( end ) < this.scoreFunction( node ) ) {
+
+ this.bubbleUp( i );
+
+ } else {
+
+ this.sinkDown( i );
+
+ }
+
+ }
+
+ return;
+
+ }
+
+ }
+
+ throw new Error( "Node not found." );
+
+ },
+
+ size: function () {
+
+ return this.content.length;
+
+ },
+
+ bubbleUp: function ( n ) {
+
+ // Fetch the element that has to be moved.
+ var element = this.content[ n ];
+
+ // When at 0, an element can not go up any further.
+ while ( n > 0 ) {
+
+ // Compute the parent element's index, and fetch it.
+ var parentN = Math.floor( ( n + 1 ) / 2 ) - 1,
+ parent = this.content[ parentN ];
+
+ // Swap the elements if the parent is greater.
+ if ( this.scoreFunction( element ) < this.scoreFunction( parent ) ) {
+
+ this.content[ parentN ] = element;
+ this.content[ n ] = parent;
+
+ // Update 'n' to continue at the new position.
+ n = parentN;
+
+ } else {
+
+ // Found a parent that is less, no need to move it further.
+ break;
+
+ }
+
+ }
+
+ },
+
+ sinkDown: function ( n ) {
+
+ // Look up the target element and its score.
+ var length = this.content.length,
+ element = this.content[ n ],
+ elemScore = this.scoreFunction( element );
+
+ while ( true ) {
+
+ // Compute the indices of the child elements.
+ var child2N = ( n + 1 ) * 2, child1N = child2N - 1;
+
+ // This is used to store the new position of the element, if any.
+ var swap = null;
+
+ // If the first child exists (is inside the array)...
+ if ( child1N < length ) {
+
+ // Look it up and compute its score.
+ var child1 = this.content[ child1N ],
+ child1Score = this.scoreFunction( child1 );
+
+ // If the score is less than our element's, we need to swap.
+ if ( child1Score < elemScore ) swap = child1N;
+
+ }
+
+ // Do the same checks for the other child.
+ if ( child2N < length ) {
+
+ var child2 = this.content[ child2N ],
+ child2Score = this.scoreFunction( child2 );
+
+ if ( child2Score < ( swap === null ? elemScore : child1Score ) ) swap = child2N;
+
+ }
+
+ // If the element needs to be moved, swap it, and continue.
+ if ( swap !== null ) {
+
+ this.content[ n ] = this.content[ swap ];
+ this.content[ swap ] = element;
+ n = swap;
+
+ } else {
+
+ // Otherwise, we are done.
+ break;
+
+ }
+
+ }
+
+ }
+
+};
diff --git a/three/jsutil/UCSCharacter.js b/three/jsutil/UCSCharacter.js
new file mode 100644
index 000000000..a3978c9f1
--- /dev/null
+++ b/three/jsutil/UCSCharacter.js
@@ -0,0 +1,141 @@
+THREE.UCSCharacter = function () {
+
+ var scope = this;
+
+ var mesh;
+
+ this.scale = 1;
+
+ this.root = new THREE.Object3D();
+
+ this.numSkins = undefined;
+ this.numMorphs = undefined;
+
+ this.skins = [];
+ this.materials = [];
+ this.morphs = [];
+
+ this.mixer = new THREE.AnimationMixer( this.root );
+
+ this.onLoadComplete = function () {};
+
+ this.loadCounter = 0;
+
+ this.loadParts = function ( config ) {
+
+ this.numSkins = config.skins.length;
+ this.numMorphs = config.morphs.length;
+
+ // Character geometry + number of skins
+ this.loadCounter = 1 + config.skins.length;
+
+ // SKINS
+ this.skins = loadTextures( config.baseUrl + "skins/", config.skins );
+ this.materials = createMaterials( this.skins );
+
+ // MORPHS
+ this.morphs = config.morphs;
+
+ // CHARACTER
+ var loader = new THREE.JSONLoader();
+ console.log( config.baseUrl + config.character );
+ loader.load( config.baseUrl + config.character, function ( geometry ) {
+
+ geometry.computeBoundingBox();
+ geometry.computeVertexNormals();
+
+ mesh = new THREE.SkinnedMesh( geometry, [] );
+ mesh.name = config.character;
+ scope.root.add( mesh );
+
+ var bb = geometry.boundingBox;
+ scope.root.scale.set( config.s, config.s, config.s );
+ scope.root.position.set( config.x, config.y - bb.min.y * config.s, config.z );
+
+ mesh.castShadow = true;
+ mesh.receiveShadow = true;
+
+ scope.mixer.clipAction( geometry.animations[ 0 ], mesh ).play();
+
+ scope.setSkin( 0 );
+
+ scope.checkLoadComplete();
+
+ } );
+
+ };
+
+ this.setSkin = function ( index ) {
+
+ if ( mesh && scope.materials ) {
+
+ mesh.material = scope.materials[ index ];
+
+ }
+
+ };
+
+ this.updateMorphs = function ( influences ) {
+
+ if ( mesh ) {
+
+ for ( var i = 0; i < scope.numMorphs; i ++ ) {
+
+ mesh.morphTargetInfluences[ i ] = influences[ scope.morphs[ i ] ] / 100;
+
+ }
+
+ }
+
+ };
+
+ function loadTextures( baseUrl, textureUrls ) {
+
+ var textureLoader = new THREE.TextureLoader();
+ var textures = [];
+
+ for ( var i = 0; i < textureUrls.length; i ++ ) {
+
+ textures[ i ] = textureLoader.load( baseUrl + textureUrls[ i ], scope.checkLoadComplete );
+ textures[ i ].mapping = THREE.UVMapping;
+ textures[ i ].name = textureUrls[ i ];
+
+ }
+
+ return textures;
+
+ }
+
+ function createMaterials( skins ) {
+
+ var materials = [];
+
+ for ( var i = 0; i < skins.length; i ++ ) {
+
+ materials[ i ] = new THREE.MeshLambertMaterial( {
+ color: 0xeeeeee,
+ specular: 10.0,
+ map: skins[ i ],
+ skinning: true,
+ morphTargets: true
+ } );
+
+ }
+
+ return materials;
+
+ }
+
+ this.checkLoadComplete = function () {
+
+ scope.loadCounter -= 1;
+
+ if ( scope.loadCounter === 0 ) {
+
+ scope.onLoadComplete();
+
+ }
+
+ };
+
+};
diff --git a/three/jsutil/Volume.js b/three/jsutil/Volume.js
new file mode 100644
index 000000000..d404b6ec3
--- /dev/null
+++ b/three/jsutil/Volume.js
@@ -0,0 +1,447 @@
+/**
+ * This class had been written to handle the output of the NRRD loader.
+ * It contains a volume of data and informations about it.
+ * For now it only handles 3 dimensional data.
+ * See the webgl_loader_nrrd.html example and the loaderNRRD.js file to see how to use this class.
+ * @class
+ * @author Valentin Demeusy / https://github.com/stity
+ * @param {number} xLength Width of the volume
+ * @param {number} yLength Length of the volume
+ * @param {number} zLength Depth of the volume
+ * @param {string} type The type of data (uint8, uint16, ...)
+ * @param {ArrayBuffer} arrayBuffer The buffer with volume data
+ */
+THREE.Volume = function ( xLength, yLength, zLength, type, arrayBuffer ) {
+
+ if ( arguments.length > 0 ) {
+
+ /**
+ * @member {number} xLength Width of the volume in the IJK coordinate system
+ */
+ this.xLength = Number( xLength ) || 1;
+ /**
+ * @member {number} yLength Height of the volume in the IJK coordinate system
+ */
+ this.yLength = Number( yLength ) || 1;
+ /**
+ * @member {number} zLength Depth of the volume in the IJK coordinate system
+ */
+ this.zLength = Number( zLength ) || 1;
+
+ /**
+ * @member {TypedArray} data Data of the volume
+ */
+
+ switch ( type ) {
+
+ case 'Uint8' :
+ case 'uint8' :
+ case 'uchar' :
+ case 'unsigned char' :
+ case 'uint8_t' :
+ this.data = new Uint8Array( arrayBuffer );
+ break;
+ case 'Int8' :
+ case 'int8' :
+ case 'signed char' :
+ case 'int8_t' :
+ this.data = new Int8Array( arrayBuffer );
+ break;
+ case 'Int16' :
+ case 'int16' :
+ case 'short' :
+ case 'short int' :
+ case 'signed short' :
+ case 'signed short int' :
+ case 'int16_t' :
+ this.data = new Int16Array( arrayBuffer );
+ break;
+ case 'Uint16' :
+ case 'uint16' :
+ case 'ushort' :
+ case 'unsigned short' :
+ case 'unsigned short int' :
+ case 'uint16_t' :
+ this.data = new Uint16Array( arrayBuffer );
+ break;
+ case 'Int32' :
+ case 'int32' :
+ case 'int' :
+ case 'signed int' :
+ case 'int32_t' :
+ this.data = new Int32Array( arrayBuffer );
+ break;
+ case 'Uint32' :
+ case 'uint32' :
+ case 'uint' :
+ case 'unsigned int' :
+ case 'uint32_t' :
+ this.data = new Uint32Array( arrayBuffer );
+ break;
+ case 'longlong' :
+ case 'long long' :
+ case 'long long int' :
+ case 'signed long long' :
+ case 'signed long long int' :
+ case 'int64' :
+ case 'int64_t' :
+ case 'ulonglong' :
+ case 'unsigned long long' :
+ case 'unsigned long long int' :
+ case 'uint64' :
+ case 'uint64_t' :
+ throw 'Error in THREE.Volume constructor : this type is not supported in JavaScript';
+ break;
+ case 'Float32' :
+ case 'float32' :
+ case 'float' :
+ this.data = new Float32Array( arrayBuffer );
+ break;
+ case 'Float64' :
+ case 'float64' :
+ case 'double' :
+ this.data = new Float64Array( arrayBuffer );
+ break;
+ default :
+ this.data = new Uint8Array( arrayBuffer );
+
+ }
+
+ if ( this.data.length !== this.xLength * this.yLength * this.zLength ) {
+
+ throw 'Error in THREE.Volume constructor, lengths are not matching arrayBuffer size';
+
+ }
+
+ }
+
+ /**
+ * @member {Array} spacing Spacing to apply to the volume from IJK to RAS coordinate system
+ */
+ this.spacing = [ 1, 1, 1 ];
+ /**
+ * @member {Array} offset Offset of the volume in the RAS coordinate system
+ */
+ this.offset = [ 0, 0, 0 ];
+ /**
+ * @member {THREE.Martrix3} matrix The IJK to RAS matrix
+ */
+ this.matrix = new THREE.Matrix3();
+ this.matrix.identity();
+ /**
+ * @member {THREE.Martrix3} inverseMatrix The RAS to IJK matrix
+ */
+ /**
+ * @member {number} lowerThreshold The voxels with values under this threshold won't appear in the slices.
+ * If changed, geometryNeedsUpdate is automatically set to true on all the slices associated to this volume
+ */
+ var lowerThreshold = - Infinity;
+ Object.defineProperty( this, 'lowerThreshold', {
+ get: function () {
+
+ return lowerThreshold;
+
+ },
+ set: function ( value ) {
+
+ lowerThreshold = value;
+ this.sliceList.forEach( function ( slice ) {
+
+ slice.geometryNeedsUpdate = true;
+
+ } );
+
+ }
+ } );
+ /**
+ * @member {number} upperThreshold The voxels with values over this threshold won't appear in the slices.
+ * If changed, geometryNeedsUpdate is automatically set to true on all the slices associated to this volume
+ */
+ var upperThreshold = Infinity;
+ Object.defineProperty( this, 'upperThreshold', {
+ get: function () {
+
+ return upperThreshold;
+
+ },
+ set: function ( value ) {
+
+ upperThreshold = value;
+ this.sliceList.forEach( function ( slice ) {
+
+ slice.geometryNeedsUpdate = true;
+
+ } );
+
+ }
+ } );
+
+
+ /**
+ * @member {Array} sliceList The list of all the slices associated to this volume
+ */
+ this.sliceList = [];
+
+
+ /**
+ * @member {Array} RASDimensions This array holds the dimensions of the volume in the RAS space
+ */
+
+};
+
+THREE.Volume.prototype = {
+
+ constructor: THREE.Volume,
+
+ /**
+ * @member {Function} getData Shortcut for data[access(i,j,k)]
+ * @memberof THREE.Volume
+ * @param {number} i First coordinate
+ * @param {number} j Second coordinate
+ * @param {number} k Third coordinate
+ * @returns {number} value in the data array
+ */
+ getData: function ( i, j, k ) {
+
+ return this.data[ k * this.xLength * this.yLength + j * this.xLength + i ];
+
+ },
+
+ /**
+ * @member {Function} access compute the index in the data array corresponding to the given coordinates in IJK system
+ * @memberof THREE.Volume
+ * @param {number} i First coordinate
+ * @param {number} j Second coordinate
+ * @param {number} k Third coordinate
+ * @returns {number} index
+ */
+ access: function ( i, j, k ) {
+
+ return k * this.xLength * this.yLength + j * this.xLength + i;
+
+ },
+
+ /**
+ * @member {Function} reverseAccess Retrieve the IJK coordinates of the voxel corresponding of the given index in the data
+ * @memberof THREE.Volume
+ * @param {number} index index of the voxel
+ * @returns {Array} [x,y,z]
+ */
+ reverseAccess: function ( index ) {
+
+ var z = Math.floor( index / ( this.yLength * this.xLength ) );
+ var y = Math.floor( ( index - z * this.yLength * this.xLength ) / this.xLength );
+ var x = index - z * this.yLength * this.xLength - y * this.xLength;
+ return [ x, y, z ];
+
+ },
+
+ /**
+ * @member {Function} map Apply a function to all the voxels, be careful, the value will be replaced
+ * @memberof THREE.Volume
+ * @param {Function} functionToMap A function to apply to every voxel, will be called with the following parameters :
+ * value of the voxel
+ * index of the voxel
+ * the data (TypedArray)
+ * @param {Object} context You can specify a context in which call the function, default if this Volume
+ * @returns {THREE.Volume} this
+ */
+ map: function ( functionToMap, context ) {
+
+ var length = this.data.length;
+ context = context || this;
+
+ for ( var i = 0; i < length; i ++ ) {
+
+ this.data[ i ] = functionToMap.call( context, this.data[ i ], i, this.data );
+
+ }
+
+ return this;
+
+ },
+
+ /**
+ * @member {Function} extractPerpendicularPlane Compute the orientation of the slice and returns all the information relative to the geometry such as sliceAccess, the plane matrix (orientation and position in RAS coordinate) and the dimensions of the plane in both coordinate system.
+ * @memberof THREE.Volume
+ * @param {string} axis the normal axis to the slice 'x' 'y' or 'z'
+ * @param {number} index the index of the slice
+ * @returns {Object} an object containing all the usefull information on the geometry of the slice
+ */
+ extractPerpendicularPlane: function ( axis, RASIndex ) {
+
+ var iLength,
+ jLength,
+ sliceAccess,
+ planeMatrix = ( new THREE.Matrix4() ).identity(),
+ volume = this,
+ planeWidth,
+ planeHeight,
+ firstSpacing,
+ secondSpacing,
+ positionOffset,
+ IJKIndex;
+
+ var axisInIJK = new THREE.Vector3(),
+ firstDirection = new THREE.Vector3(),
+ secondDirection = new THREE.Vector3();
+
+ var dimensions = new THREE.Vector3( this.xLength, this.yLength, this.zLength );
+
+
+ switch ( axis ) {
+
+ case 'x' :
+ axisInIJK.set( 1, 0, 0 );
+ firstDirection.set( 0, 0, - 1 );
+ secondDirection.set( 0, - 1, 0 );
+ firstSpacing = this.spacing[ 2 ];
+ secondSpacing = this.spacing[ 1 ];
+ IJKIndex = new THREE.Vector3( RASIndex, 0, 0 );
+
+ planeMatrix.multiply( ( new THREE.Matrix4() ).makeRotationY( Math.PI / 2 ) );
+ positionOffset = ( volume.RASDimensions[ 0 ] - 1 ) / 2;
+ planeMatrix.setPosition( new THREE.Vector3( RASIndex - positionOffset, 0, 0 ) );
+ break;
+ case 'y' :
+ axisInIJK.set( 0, 1, 0 );
+ firstDirection.set( 1, 0, 0 );
+ secondDirection.set( 0, 0, 1 );
+ firstSpacing = this.spacing[ 0 ];
+ secondSpacing = this.spacing[ 2 ];
+ IJKIndex = new THREE.Vector3( 0, RASIndex, 0 );
+
+ planeMatrix.multiply( ( new THREE.Matrix4() ).makeRotationX( - Math.PI / 2 ) );
+ positionOffset = ( volume.RASDimensions[ 1 ] - 1 ) / 2;
+ planeMatrix.setPosition( new THREE.Vector3( 0, RASIndex - positionOffset, 0 ) );
+ break;
+ case 'z' :
+ default :
+ axisInIJK.set( 0, 0, 1 );
+ firstDirection.set( 1, 0, 0 );
+ secondDirection.set( 0, - 1, 0 );
+ firstSpacing = this.spacing[ 0 ];
+ secondSpacing = this.spacing[ 1 ];
+ IJKIndex = new THREE.Vector3( 0, 0, RASIndex );
+
+ positionOffset = ( volume.RASDimensions[ 2 ] - 1 ) / 2;
+ planeMatrix.setPosition( new THREE.Vector3( 0, 0, RASIndex - positionOffset ) );
+ break;
+
+ }
+
+ firstDirection.applyMatrix4( volume.inverseMatrix ).normalize();
+ firstDirection.argVar = 'i';
+ secondDirection.applyMatrix4( volume.inverseMatrix ).normalize();
+ secondDirection.argVar = 'j';
+ axisInIJK.applyMatrix4( volume.inverseMatrix ).normalize();
+ iLength = Math.floor( Math.abs( firstDirection.dot( dimensions ) ) );
+ jLength = Math.floor( Math.abs( secondDirection.dot( dimensions ) ) );
+ planeWidth = Math.abs( iLength * firstSpacing );
+ planeHeight = Math.abs( jLength * secondSpacing );
+
+ IJKIndex = Math.abs( Math.round( IJKIndex.applyMatrix4( volume.inverseMatrix ).dot( axisInIJK ) ) );
+ var base = [ new THREE.Vector3( 1, 0, 0 ), new THREE.Vector3( 0, 1, 0 ), new THREE.Vector3( 0, 0, 1 ) ];
+ var iDirection = [ firstDirection, secondDirection, axisInIJK ].find( function ( x ) {
+
+ return Math.abs( x.dot( base[ 0 ] ) ) > 0.9;
+
+ } );
+ var jDirection = [ firstDirection, secondDirection, axisInIJK ].find( function ( x ) {
+
+ return Math.abs( x.dot( base[ 1 ] ) ) > 0.9;
+
+ } );
+ var kDirection = [ firstDirection, secondDirection, axisInIJK ].find( function ( x ) {
+
+ return Math.abs( x.dot( base[ 2 ] ) ) > 0.9;
+
+ } );
+ var argumentsWithInversion = [ 'volume.xLength-1-', 'volume.yLength-1-', 'volume.zLength-1-' ];
+ var argArray = [ iDirection, jDirection, kDirection ].map( function ( direction, n ) {
+
+ return ( direction.dot( base[ n ] ) > 0 ? '' : argumentsWithInversion[ n ] ) + ( direction === axisInIJK ? 'IJKIndex' : direction.argVar );
+
+ } );
+ var argString = argArray.join( ',' );
+ sliceAccess = eval( '(function sliceAccess (i,j) {return volume.access( ' + argString + ');})' );
+
+
+ return {
+ iLength: iLength,
+ jLength: jLength,
+ sliceAccess: sliceAccess,
+ matrix: planeMatrix,
+ planeWidth: planeWidth,
+ planeHeight: planeHeight
+ };
+
+ },
+
+ /**
+ * @member {Function} extractSlice Returns a slice corresponding to the given axis and index
+ * The coordinate are given in the Right Anterior Superior coordinate format
+ * @memberof THREE.Volume
+ * @param {string} axis the normal axis to the slice 'x' 'y' or 'z'
+ * @param {number} index the index of the slice
+ * @returns {THREE.VolumeSlice} the extracted slice
+ */
+ extractSlice: function ( axis, index ) {
+
+ var slice = new THREE.VolumeSlice( this, index, axis );
+ this.sliceList.push( slice );
+ return slice;
+
+ },
+
+ /**
+ * @member {Function} repaintAllSlices Call repaint on all the slices extracted from this volume
+ * @see THREE.VolumeSlice.repaint
+ * @memberof THREE.Volume
+ * @returns {THREE.Volume} this
+ */
+ repaintAllSlices: function () {
+
+ this.sliceList.forEach( function ( slice ) {
+
+ slice.repaint();
+
+ } );
+
+ return this;
+
+ },
+
+ /**
+ * @member {Function} computeMinMax Compute the minimum and the maximum of the data in the volume
+ * @memberof THREE.Volume
+ * @returns {Array} [min,max]
+ */
+ computeMinMax: function () {
+
+ var min = Infinity;
+ var max = - Infinity;
+
+ // buffer the length
+ var datasize = this.data.length;
+
+ var i = 0;
+ for ( i = 0; i < datasize; i ++ ) {
+
+ if ( ! isNaN( this.data[ i ] ) ) {
+
+ var value = this.data[ i ];
+ min = Math.min( min, value );
+ max = Math.max( max, value );
+
+ }
+
+ }
+ this.min = min;
+ this.max = max;
+
+ return [ min, max ];
+
+ }
+
+};
diff --git a/three/jsutil/VolumeSlice.js b/three/jsutil/VolumeSlice.js
new file mode 100644
index 000000000..a66de0754
--- /dev/null
+++ b/three/jsutil/VolumeSlice.js
@@ -0,0 +1,214 @@
+/**
+ * This class has been made to hold a slice of a volume data
+ * @class
+ * @author Valentin Demeusy / https://github.com/stity
+ * @param {THREE.Volume} volume The associated volume
+ * @param {number} [index=0] The index of the slice
+ * @param {string} [axis='z'] For now only 'x', 'y' or 'z' but later it will change to a normal vector
+ * @see THREE.Volume
+ */
+THREE.VolumeSlice = function ( volume, index, axis ) {
+
+ var slice = this;
+ /**
+ * @member {THREE.Volume} volume The associated volume
+ */
+ this.volume = volume;
+ /**
+ * @member {Number} index The index of the slice, if changed, will automatically call updateGeometry at the next repaint
+ */
+ index = index || 0;
+ Object.defineProperty( this, 'index', {
+ get: function () {
+
+ return index;
+
+ },
+ set: function ( value ) {
+
+ index = value;
+ slice.geometryNeedsUpdate = true;
+ return index;
+
+ }
+ } );
+ /**
+ * @member {String} axis The normal axis
+ */
+ this.axis = axis || 'z';
+
+ /**
+ * @member {HTMLCanvasElement} canvas The final canvas used for the texture
+ */
+ /**
+ * @member {CanvasRenderingContext2D} ctx Context of the canvas
+ */
+ this.canvas = document.createElement( 'canvas' );
+ /**
+ * @member {HTMLCanvasElement} canvasBuffer The intermediary canvas used to paint the data
+ */
+ /**
+ * @member {CanvasRenderingContext2D} ctxBuffer Context of the canvas buffer
+ */
+ this.canvasBuffer = document.createElement( 'canvas' );
+ this.updateGeometry();
+
+
+ var canvasMap = new THREE.Texture( this.canvas );
+ canvasMap.minFilter = THREE.LinearFilter;
+ canvasMap.wrapS = canvasMap.wrapT = THREE.ClampToEdgeWrapping;
+ var material = new THREE.MeshBasicMaterial( { map: canvasMap, side: THREE.DoubleSide, transparent: true } );
+ /**
+ * @member {THREE.Mesh} mesh The mesh ready to get used in the scene
+ */
+ this.mesh = new THREE.Mesh( this.geometry, material );
+ /**
+ * @member {Boolean} geometryNeedsUpdate If set to true, updateGeometry will be triggered at the next repaint
+ */
+ this.geometryNeedsUpdate = true;
+ this.repaint();
+
+ /**
+ * @member {Number} iLength Width of slice in the original coordinate system, corresponds to the width of the buffer canvas
+ */
+
+ /**
+ * @member {Number} jLength Height of slice in the original coordinate system, corresponds to the height of the buffer canvas
+ */
+
+ /**
+ * @member {Function} sliceAccess Function that allow the slice to access right data
+ * @see THREE.Volume.extractPerpendicularPlane
+ * @param {Number} i The first coordinate
+ * @param {Number} j The second coordinate
+ * @returns {Number} the index corresponding to the voxel in volume.data of the given position in the slice
+ */
+
+
+};
+
+THREE.VolumeSlice.prototype = {
+
+ constructor: THREE.VolumeSlice,
+
+ /**
+ * @member {Function} repaint Refresh the texture and the geometry if geometryNeedsUpdate is set to true
+ * @memberof THREE.VolumeSlice
+ */
+ repaint: function () {
+
+ if ( this.geometryNeedsUpdate ) {
+
+ this.updateGeometry();
+
+ }
+
+ var iLength = this.iLength,
+ jLength = this.jLength,
+ sliceAccess = this.sliceAccess,
+ volume = this.volume,
+ canvas = this.canvasBuffer,
+ ctx = this.ctxBuffer;
+
+
+ // get the imageData and pixel array from the canvas
+ var imgData = ctx.getImageData( 0, 0, iLength, jLength );
+ var data = imgData.data;
+ var volumeData = volume.data;
+ var upperThreshold = volume.upperThreshold;
+ var lowerThreshold = volume.lowerThreshold;
+ var windowLow = volume.windowLow;
+ var windowHigh = volume.windowHigh;
+
+ // manipulate some pixel elements
+ var pixelCount = 0;
+
+ if ( volume.dataType === 'label' ) {
+
+ //this part is currently useless but will be used when colortables will be handled
+ for ( var j = 0; j < jLength; j ++ ) {
+
+ for ( var i = 0; i < iLength; i ++ ) {
+
+ var label = volumeData[ sliceAccess( i, j ) ];
+ label = label >= this.colorMap.length ? ( label % this.colorMap.length ) + 1 : label;
+ var color = this.colorMap[ label ];
+ data[ 4 * pixelCount ] = ( color >> 24 ) & 0xff;
+ data[ 4 * pixelCount + 1 ] = ( color >> 16 ) & 0xff;
+ data[ 4 * pixelCount + 2 ] = ( color >> 8 ) & 0xff;
+ data[ 4 * pixelCount + 3 ] = color & 0xff;
+ pixelCount ++;
+
+ }
+
+ }
+
+ } else {
+
+ for ( var j = 0; j < jLength; j ++ ) {
+
+ for ( var i = 0; i < iLength; i ++ ) {
+
+ var value = volumeData[ sliceAccess( i, j ) ];
+ var alpha = 0xff;
+ //apply threshold
+ alpha = upperThreshold >= value ? ( lowerThreshold <= value ? alpha : 0 ) : 0;
+ //apply window level
+ value = Math.floor( 255 * ( value - windowLow ) / ( windowHigh - windowLow ) );
+ value = value > 255 ? 255 : ( value < 0 ? 0 : value | 0 );
+
+ data[ 4 * pixelCount ] = value;
+ data[ 4 * pixelCount + 1 ] = value;
+ data[ 4 * pixelCount + 2 ] = value;
+ data[ 4 * pixelCount + 3 ] = alpha;
+ pixelCount ++;
+
+ }
+
+ }
+
+ }
+ ctx.putImageData( imgData, 0, 0 );
+ this.ctx.drawImage( canvas, 0, 0, iLength, jLength, 0, 0, this.canvas.width, this.canvas.height );
+
+
+ this.mesh.material.map.needsUpdate = true;
+
+ },
+
+ /**
+ * @member {Function} Refresh the geometry according to axis and index
+ * @see THREE.Volume.extractPerpendicularPlane
+ * @memberof THREE.VolumeSlice
+ */
+ updateGeometry: function () {
+
+ var extracted = this.volume.extractPerpendicularPlane( this.axis, this.index );
+ this.sliceAccess = extracted.sliceAccess;
+ this.jLength = extracted.jLength;
+ this.iLength = extracted.iLength;
+ this.matrix = extracted.matrix;
+
+ this.canvas.width = extracted.planeWidth;
+ this.canvas.height = extracted.planeHeight;
+ this.canvasBuffer.width = this.iLength;
+ this.canvasBuffer.height = this.jLength;
+ this.ctx = this.canvas.getContext( '2d' );
+ this.ctxBuffer = this.canvasBuffer.getContext( '2d' );
+
+ this.geometry = new THREE.PlaneBufferGeometry( extracted.planeWidth, extracted.planeHeight );
+
+ if ( this.mesh ) {
+
+ this.mesh.geometry = this.geometry;
+ //reset mesh matrix
+ this.mesh.matrix = ( new THREE.Matrix4() ).identity();
+ this.mesh.applyMatrix( this.matrix );
+
+ }
+
+ this.geometryNeedsUpdate = false;
+
+ }
+
+};
diff --git a/three/jsutil/WebGL.js b/three/jsutil/WebGL.js
new file mode 100644
index 000000000..adf94502e
--- /dev/null
+++ b/three/jsutil/WebGL.js
@@ -0,0 +1,94 @@
+/**
+ * @author alteredq / http://alteredqualia.com/
+ * @author mr.doob / http://mrdoob.com/
+ */
+
+var WEBGL = {
+
+ isWebGLAvailable: function () {
+
+ try {
+
+ var canvas = document.createElement( 'canvas' );
+ return !! ( window.WebGLRenderingContext && ( canvas.getContext( 'webgl' ) || canvas.getContext( 'experimental-webgl' ) ) );
+
+ } catch ( e ) {
+
+ return false;
+
+ }
+
+ },
+
+ isWebGL2Available: function () {
+
+ try {
+
+ var canvas = document.createElement( 'canvas' );
+ return !! ( window.WebGL2RenderingContext && canvas.getContext( 'webgl2' ) );
+
+ } catch ( e ) {
+
+ return false;
+
+ }
+
+ },
+
+ getWebGLErrorMessage: function () {
+
+ return this.getErrorMessage( 1 );
+
+ },
+
+ getWebGL2ErrorMessage: function () {
+
+ return this.getErrorMessage( 2 );
+
+ },
+
+ getErrorMessage: function ( version ) {
+
+ var names = {
+ 1: 'WebGL',
+ 2: 'WebGL 2'
+ };
+
+ var contexts = {
+ 1: window.WebGLRenderingContext,
+ 2: window.WebGL2RenderingContext
+ };
+
+ var message = 'Your $0 does not seem to support $1';
+
+ var element = document.createElement( 'div' );
+ element.id = 'webglmessage';
+ element.style.fontFamily = 'monospace';
+ element.style.fontSize = '13px';
+ element.style.fontWeight = 'normal';
+ element.style.textAlign = 'center';
+ element.style.background = '#fff';
+ element.style.color = '#000';
+ element.style.padding = '1.5em';
+ element.style.width = '400px';
+ element.style.margin = '5em auto 0';
+
+ if ( contexts[ version ] ) {
+
+ message = message.replace( '$0', 'graphics card' );
+
+ } else {
+
+ message = message.replace( '$0', 'browser' );
+
+ }
+
+ message = message.replace( '$1', names[ version ] );
+
+ element.innerHTML = message;
+
+ return element;
+
+ }
+
+};
diff --git a/three/jsutil/animation/CCDIKSolver.js b/three/jsutil/animation/CCDIKSolver.js
new file mode 100644
index 000000000..b1473038f
--- /dev/null
+++ b/three/jsutil/animation/CCDIKSolver.js
@@ -0,0 +1,455 @@
+/**
+ * @author takahiro / https://github.com/takahirox
+ *
+ * CCD Algorithm
+ * - https://sites.google.com/site/auraliusproject/ccd-algorithm
+ *
+ * // ik parameter example
+ * //
+ * // target, effector, index in links are bone index in skeleton.bones.
+ * // the bones relation should be
+ * // <-- parent child -->
+ * // links[ n ], links[ n - 1 ], ..., links[ 0 ], effector
+ * iks = [ {
+ * target: 1,
+ * effector: 2,
+ * links: [ { index: 5, limitation: new THREE.Vector3( 1, 0, 0 ) }, { index: 4, enabled: false }, { index : 3 } ],
+ * iteration: 10,
+ * minAngle: 0.0,
+ * maxAngle: 1.0,
+ * } ];
+ */
+
+THREE.CCDIKSolver = ( function () {
+
+ /**
+ * @param {THREE.SkinnedMesh} mesh
+ * @param {Array