Sfoglia il codice sorgente

revert certain files

gero3 10 anni fa
parent
commit
ae57c16436

+ 20 - 21
examples/js/ImprovedNoise.js

@@ -13,37 +13,37 @@ var ImprovedNoise = function () {
 		 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 ++ ) {
+	for (var i = 0; i < 256 ; i ++) {
 
-		p[ 256 + i ] = p[ i ];
+		p[256 + i] = p[i];
 
 	}
 
-	function fade( t ) {
+	function fade(t) {
 
-		return t * t * t * ( t * ( t * 6 - 15 ) + 10 );
+		return t * t * t * (t * (t * 6 - 15) + 10);
 
 	}
 
-	function lerp( t, a, b ) {
+	function lerp(t, a, b) {
 
-		return a + t * ( b - a );
+		return a + t * (b - a);
 
 	}
 
-	function grad( hash, x, y, z ) {
+	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 ((h&1) == 0 ? u : -u) + ((h&2) == 0 ? v : -v);
 
 	}
 
 	return {
 
-		noise: function ( x, y, z ) {
+		noise: function (x, y, z) {
 
-			var floorX = ~~ x, floorY = ~~ y, floorZ = ~~ z;
+			var floorX = ~~x, floorY = ~~y, floorZ = ~~z;
 
 			var X = floorX & 255, Y = floorY & 255, Z = floorZ & 255;
 
@@ -53,20 +53,19 @@ var ImprovedNoise = function () {
 
 			var xMinus1 = x - 1, yMinus1 = y - 1, zMinus1 = z - 1;
 
-			var u = fade( x ), v = fade( y ), w = fade( z );
+			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;
+			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 ) ) ) );
+			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))));
 
 		}
 	}
-
 };

+ 157 - 235
examples/js/SimplexNoise.js

@@ -11,38 +11,33 @@
  * 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 ]];
+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 );
-
+	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 
+  // 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 ];
-
+	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. 
+  // 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 ], 
@@ -52,163 +47,111 @@ var SimplexNoise = function( r ) {
     [ 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.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.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.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 ) { 
-
+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; 
+  // 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. 
+  // 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 
+	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 
+  // 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 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; 
+	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 
-
+		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; 
+	if (t1 < 0) n1 = 0.0; 
 	else { 
-
 		t1 *= t1; 
-		n1 = t1 * t1 * this.dot( this.grad3[ gi1 ], x1, y1 ); 
-
+		n1 = t1 * t1 * this.dot(this.grad3[gi1], x1, y1); 
 	}
 	var t2 = 0.5 - x2 * x2 - y2 * y2; 
-	if ( t2 < 0 ) n2 = 0.0; 
+	if (t2 < 0) n2 = 0.0; 
 	else { 
-
 		t2 *= t2; 
-		n2 = t2 * t2 * this.dot( this.grad3[ gi2 ], x2, y2 ); 
-
+		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 ); 
-
+  // 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 ) { 
-
+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 
+  // 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 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 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. 
+  // 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 
-
+	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 
-		if ( y0 < z0 ) {
-
-			i1 = 0; j1 = 0; k1 = 1; i2 = 0; j2 = 1; k2 = 1;
-
-		} // Z Y X order 
-		else if ( x0 < z0 ) {
-
-			i1 = 0; j1 = 1; k1 = 0; i2 = 0; j2 = 1; k2 = 1;
-
-		} // Y Z X order 
-		else {
-
-			i1 = 0; j1 = 1; k1 = 0; i2 = 1; j2 = 1; k2 = 0;
-
-		} // Y X Z order 
-
+	else { // x0<y0 
+		if (y0 < z0) { i1 = 0; j1 = 0; k1 = 1; i2 = 0; j2 = 1; k2 = 1; } // Z Y X order 
+    else if (x0 < z0) { i1 = 0; j1 = 1; k1 = 0; i2 = 0; j2 = 1; k2 = 1; } // Y Z X order 
+		else { i1 = 0; j1 = 1; k1 = 0; i2 = 1; j2 = 1; k2 = 0; } // Y X Z order 
 	} 
-	// A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z), 
-	// a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and 
-	// a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where 
-	// c = 1/6.
+  // A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z), 
+  // a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and 
+  // a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where 
+  // c = 1/6.
 	var x1 = x0 - i1 + G3; // Offsets for second corner in (x,y,z) coords 
 	var y1 = y0 - j1 + G3; 
 	var z1 = z0 - k1 + G3; 
@@ -218,72 +161,62 @@ SimplexNoise.prototype.noise3d = function( xin, yin, zin ) {
 	var x3 = x0 - 1.0 + 3.0 * G3; // Offsets for last corner in (x,y,z) coords 
 	var y3 = y0 - 1.0 + 3.0 * G3; 
 	var z3 = z0 - 1.0 + 3.0 * G3; 
-	// Work out the hashed gradient indices of the four simplex corners 
+  // Work out the hashed gradient indices of the four simplex corners 
 	var ii = i & 255; 
 	var jj = j & 255; 
 	var kk = k & 255; 
-	var gi0 = this.perm[ ii + this.perm[ jj + this.perm[ kk ]]] % 12; 
-	var gi1 = this.perm[ ii + i1 + this.perm[ jj + j1 + this.perm[ kk + k1 ]]] % 12; 
-	var gi2 = this.perm[ ii + i2 + this.perm[ jj + j2 + this.perm[ kk + k2 ]]] % 12; 
-	var gi3 = this.perm[ ii + 1 + this.perm[ jj + 1 + this.perm[ kk + 1 ]]] % 12; 
-	// Calculate the contribution from the four corners 
+	var gi0 = this.perm[ii + this.perm[jj + this.perm[kk]]] % 12; 
+	var gi1 = this.perm[ii + i1 + this.perm[jj + j1 + this.perm[kk + k1]]] % 12; 
+	var gi2 = this.perm[ii + i2 + this.perm[jj + j2 + this.perm[kk + k2]]] % 12; 
+	var gi3 = this.perm[ii + 1 + this.perm[jj + 1 + this.perm[kk + 1]]] % 12; 
+  // Calculate the contribution from the four corners 
 	var t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0; 
-	if ( t0 < 0 ) n0 = 0.0; 
+	if (t0 < 0) n0 = 0.0; 
 	else { 
-
 		t0 *= t0; 
-		n0 = t0 * t0 * this.dot3( this.grad3[ gi0 ], x0, y0, z0 ); 
-
+		n0 = t0 * t0 * this.dot3(this.grad3[gi0], x0, y0, z0); 
 	}
 	var t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1; 
-	if ( t1 < 0 ) n1 = 0.0; 
+	if (t1 < 0) n1 = 0.0; 
 	else { 
-
 		t1 *= t1; 
-		n1 = t1 * t1 * this.dot3( this.grad3[ gi1 ], x1, y1, z1 ); 
-
+		n1 = t1 * t1 * this.dot3(this.grad3[gi1], x1, y1, z1); 
 	} 
 	var t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2; 
-	if ( t2 < 0 ) n2 = 0.0; 
+	if (t2 < 0) n2 = 0.0; 
 	else { 
-
 		t2 *= t2; 
-		n2 = t2 * t2 * this.dot3( this.grad3[ gi2 ], x2, y2, z2 ); 
-
+		n2 = t2 * t2 * this.dot3(this.grad3[gi2], x2, y2, z2); 
 	} 
 	var t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3; 
-	if ( t3 < 0 ) n3 = 0.0; 
+	if (t3 < 0) n3 = 0.0; 
 	else { 
-
 		t3 *= t3; 
-		n3 = t3 * t3 * this.dot3( this.grad3[ gi3 ], x3, y3, z3 ); 
-
+		n3 = t3 * t3 * this.dot3(this.grad3[gi3], x3, y3, z3); 
 	} 
-	// Add contributions from each corner to get the final noise value. 
-	// The result is scaled to stay just inside [-1,1] 
-	return 32.0 * ( n0 + n1 + n2 + n3 ); 
-
+  // Add contributions from each corner to get the final noise value. 
+  // The result is scaled to stay just inside [-1,1] 
+	return 32.0 * (n0 + n1 + n2 + n3); 
 };
 
 // 4D simplex noise
 SimplexNoise.prototype.noise4d = function( x, y, z, w ) {
-
 	// For faster and easier lookups
 	var grad4 = this.grad4;
 	var simplex = this.simplex;
 	var perm = this.perm;
 	
-	// The skewing and unskewing factors are hairy again for the 4D case
-	var F4 = ( Math.sqrt( 5.0 ) - 1.0 ) / 4.0;
-	var G4 = ( 5.0 - Math.sqrt( 5.0 ) ) / 20.0;
+   // The skewing and unskewing factors are hairy again for the 4D case
+	var F4 = (Math.sqrt(5.0) - 1.0) / 4.0;
+	var G4 = (5.0 - Math.sqrt(5.0)) / 20.0;
 	var n0, n1, n2, n3, n4; // Noise contributions from the five corners
-	// Skew the (x,y,z,w) space to determine which cell of 24 simplices we're in
-	var s = ( x + y + z + w ) * F4; // Factor for 4D skewing
-	var i = Math.floor( x + s );
-	var j = Math.floor( y + s );
-	var k = Math.floor( z + s );
-	var l = Math.floor( w + s );
-	var t = ( i + j + k + l ) * G4; // Factor for 4D unskewing
+   // Skew the (x,y,z,w) space to determine which cell of 24 simplices we're in
+	var s = (x + y + z + w) * F4; // Factor for 4D skewing
+	var i = Math.floor(x + s);
+	var j = Math.floor(y + s);
+	var k = Math.floor(z + s);
+	var l = Math.floor(w + s);
+	var t = (i + j + k + l) * G4; // Factor for 4D unskewing
 	var X0 = i - t; // Unskew the cell origin back to (x,y,z,w) space
 	var Y0 = j - t;
 	var Z0 = k - t;
@@ -293,43 +226,43 @@ SimplexNoise.prototype.noise4d = function( x, y, z, w ) {
 	var z0 = z - Z0;
 	var w0 = w - W0;
 
-	// For the 4D case, the simplex is a 4D shape I won't even try to describe.
-	// To find out which of the 24 possible simplices we're in, we need to
-	// determine the magnitude ordering of x0, y0, z0 and w0.
-	// The method below is a good way of finding the ordering of x,y,z,w and
-	// then find the correct traversal order for the simplex we’re in.
-	// First, six pair-wise comparisons are performed between each possible pair
-	// of the four coordinates, and the results are used to add up binary bits
-	// for an integer index.
-	var c1 = ( 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;
+   // For the 4D case, the simplex is a 4D shape I won't even try to describe.
+   // To find out which of the 24 possible simplices we're in, we need to
+   // determine the magnitude ordering of x0, y0, z0 and w0.
+   // The method below is a good way of finding the ordering of x,y,z,w and
+   // then find the correct traversal order for the simplex we’re in.
+   // First, six pair-wise comparisons are performed between each possible pair
+   // of the four coordinates, and the results are used to add up binary bits
+   // for an integer index.
+	var c1 = (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<z, y<w and x<w
-	// impossible. Only the 24 indices which have non-zero entries make any sense.
-	// We use a thresholding to set the coordinates in turn from the largest magnitude.
-	// The number 3 in the "simplex" array is at the position of the largest coordinate.
-	i1 = simplex[ c ][ 0 ] >= 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.
+   // 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<z, y<w and x<w
+   // impossible. Only the 24 indices which have non-zero entries make any sense.
+   // We use a thresholding to set the coordinates in turn from the largest magnitude.
+   // The number 3 in the "simplex" array is at the position of the largest coordinate.
+	i1 = simplex[c][0] >= 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;
@@ -346,57 +279,46 @@ SimplexNoise.prototype.noise4d = function( x, y, z, w ) {
 	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
+   // 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 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;
+	if (t0 < 0) n0 = 0.0;
 	else {
-
 		t0 *= t0;
-		n0 = t0 * t0 * this.dot4( grad4[ gi0 ], x0, y0, z0, w0 );
-
+		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;
+	if (t1 < 0) n1 = 0.0;
 	else {
-
 		t1 *= t1;
-		n1 = t1 * t1 * this.dot4( grad4[ gi1 ], x1, y1, z1, w1 );
-
+		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;
+	if (t2 < 0) n2 = 0.0;
 	else {
-
 		t2 *= t2;
-		n2 = t2 * t2 * this.dot4( grad4[ gi2 ], x2, y2, z2, w2 );
-
+		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;
+	if (t3 < 0) n3 = 0.0;
 	else {
-
 		t3 *= t3;
-		n3 = t3 * t3 * this.dot4( grad4[ gi3 ], x3, y3, z3, w3 );
-
+		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;
+	if (t4 < 0) n4 = 0.0;
 	else {
-
 		t4 *= t4;
-		n4 = t4 * t4 * this.dot4( grad4[ gi4 ], x4, y4, z4, w4 );
-
+		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 );
-
+   // Sum up and scale the result to cover the range [-1,1]
+	return 27.0 * (n0 + n1 + n2 + n3 + n4);
 };

+ 66 - 86
examples/js/loaders/UTF8Loader.js

@@ -133,18 +133,18 @@ THREE.UTF8Loader.BufferGeometryCreator.prototype.create = function ( attribArray
 
 var DEFAULT_DECODE_PARAMS = {
 
-	decodeOffsets: [ - 4095, - 4095, - 4095, 0, 0, - 511, - 511, - 511 ],
-	decodeScales: [ 1 / 8191, 1 / 8191, 1 / 8191, 1 / 1023, 1 / 1023, 1 / 1023, 1 / 1023, 1 / 1023 ]
-
-	// TODO: normal decoding? (see walt.js)
-	// needs to know: input, output (from vertex format!)
-	//
-	// Should split attrib/index.
-	// 1) Decode position and non-normal attributes.
-	// 2) Decode indices, computing normals
-	// 3) Maybe normalize normals? Only necessary for refinement, or fixed?
-	// 4) Maybe refine normals? Should this be part of regular refinement?
-	// 5) Morphing
+    decodeOffsets: [ -4095, -4095, -4095, 0, 0, -511, -511, -511 ],
+    decodeScales: [ 1 / 8191, 1 / 8191, 1 / 8191, 1 / 1023, 1 / 1023, 1 / 1023, 1 / 1023, 1 / 1023 ]
+
+    // TODO: normal decoding? (see walt.js)
+    // needs to know: input, output (from vertex format!)
+    //
+    // Should split attrib/index.
+    // 1) Decode position and non-normal attributes.
+    // 2) Decode indices, computing normals
+    // 3) Maybe normalize normals? Only necessary for refinement, or fixed?
+    // 4) Maybe refine normals? Should this be part of regular refinement?
+    // 5) Morphing
 
 };
 
@@ -163,7 +163,7 @@ THREE.UTF8Loader.prototype.decompressAttribsInner_ = function ( str, inputStart,
 	for ( var j = inputStart; j < inputEnd; j ++ ) {
 
 		var code = str.charCodeAt( j );
-		prev += ( code >> 1 ) ^ ( - ( code & 1 ) );
+		prev += ( code >> 1 ) ^ ( -( code & 1 ) );
 
 		output[ outputStart ] = decodeScale * ( prev + decodeOffset );
 		outputStart += stride;
@@ -195,7 +195,6 @@ THREE.UTF8Loader.prototype.decompressIndices_ = function( str, inputStart, numIn
 
 THREE.UTF8Loader.prototype.decompressAABBs_ = function ( str, inputStart, numBBoxen,
                                                            decodeOffsets, decodeScales ) {
-
 	var numFloats = 6 * numBBoxen;
 
 	var inputEnd = inputStart + numFloats;
@@ -205,21 +204,21 @@ THREE.UTF8Loader.prototype.decompressAABBs_ = function ( str, inputStart, numBBo
 
 	for ( var i = inputStart; i < inputEnd; i += 6 ) {
 
-		var minX = str.charCodeAt( i + 0 ) + decodeOffsets[ 0 ];
-		var minY = str.charCodeAt( i + 1 ) + decodeOffsets[ 1 ];
-		var minZ = str.charCodeAt( i + 2 ) + decodeOffsets[ 2 ];
+		var minX = str.charCodeAt(i + 0) + decodeOffsets[0];
+		var minY = str.charCodeAt(i + 1) + decodeOffsets[1];
+		var minZ = str.charCodeAt(i + 2) + decodeOffsets[2];
 
-		var radiusX = ( str.charCodeAt( i + 3 ) + 1 ) >> 1;
-		var radiusY = ( str.charCodeAt( i + 4 ) + 1 ) >> 1;
-		var radiusZ = ( str.charCodeAt( i + 5 ) + 1 ) >> 1;
+		var radiusX = (str.charCodeAt(i + 3) + 1) >> 1;
+		var radiusY = (str.charCodeAt(i + 4) + 1) >> 1;
+		var radiusZ = (str.charCodeAt(i + 5) + 1) >> 1;
 
-		bboxen[ outputStart ++ ] = decodeScales[ 0 ] * ( minX + radiusX );
-		bboxen[ outputStart ++ ] = decodeScales[ 1 ] * ( minY + radiusY );
-		bboxen[ outputStart ++ ] = decodeScales[ 2 ] * ( minZ + radiusZ );
+		bboxen[ outputStart ++ ] = decodeScales[0] * (minX + radiusX);
+		bboxen[ outputStart ++ ] = decodeScales[1] * (minY + radiusY);
+		bboxen[ outputStart ++ ] = decodeScales[2] * (minZ + radiusZ);
 
-		bboxen[ outputStart ++ ] = decodeScales[ 0 ] * radiusX;
-		bboxen[ outputStart ++ ] = decodeScales[ 1 ] * radiusY;
-		bboxen[ outputStart ++ ] = decodeScales[ 2 ] * radiusZ;
+		bboxen[ outputStart ++ ] = decodeScales[0] * radiusX;
+		bboxen[ outputStart ++ ] = decodeScales[1] * radiusY;
+		bboxen[ outputStart ++ ] = decodeScales[2] * radiusZ;
 
 	}
 
@@ -229,36 +228,35 @@ THREE.UTF8Loader.prototype.decompressAABBs_ = function ( str, inputStart, numBBo
 
 THREE.UTF8Loader.prototype.decompressMesh =  function ( str, meshParams, decodeParams, name, idx, callback ) {
 
-	// Extract conversion parameters from attribArrays.
+    // Extract conversion parameters from attribArrays.
 
 	var stride = decodeParams.decodeScales.length;
 
 	var decodeOffsets = decodeParams.decodeOffsets;
 	var decodeScales = decodeParams.decodeScales;
 
-	var attribStart = meshParams.attribRange[ 0 ];
-	var numVerts = meshParams.attribRange[ 1 ];
+	var attribStart = meshParams.attribRange[0];
+	var numVerts = meshParams.attribRange[1];
 
-	// Decode attributes.
+    // Decode attributes.
 
 	var inputOffset = attribStart;
 	var attribsOut = new Float32Array( stride * numVerts );
 
-	for ( var j = 0; j < stride; j ++ ) {
+	for (var j = 0; j < stride; j ++ ) {
 
 		var end = inputOffset + numVerts;
 
-		var decodeScale = decodeScales[ j ];
+		var decodeScale = decodeScales[j];
 
 		if ( decodeScale ) {
 
-			// Assume if decodeScale is never set, simply ignore the
-			// attribute.
+            // Assume if decodeScale is never set, simply ignore the
+            // attribute.
 
 			this.decompressAttribsInner_( str, inputOffset, end,
                 attribsOut, j, stride,
-                decodeOffsets[ j ], decodeScale );
-
+                decodeOffsets[j], decodeScale );
 		}
 
 		inputOffset = end;
@@ -272,7 +270,7 @@ THREE.UTF8Loader.prototype.decompressMesh =  function ( str, meshParams, decodeP
 
 	this.decompressIndices_( str, inputOffset, numIndices, indicesOut, 0 );
 
-	// Decode bboxen.
+    // Decode bboxen.
 
 	var bboxen = undefined;
 	var bboxOffset = meshParams.bboxes;
@@ -280,7 +278,6 @@ THREE.UTF8Loader.prototype.decompressMesh =  function ( str, meshParams, decodeP
 	if ( bboxOffset ) {
 
 		bboxen = this.decompressAABBs_( str, bboxOffset, meshParams.names.length, decodeOffsets, decodeScales );
-
 	}
 
 	callback( name, idx, attribsOut, indicesOut, bboxen, meshParams );
@@ -304,12 +301,11 @@ THREE.UTF8Loader.prototype.decodeAttrib2 = function ( str, stride, decodeOffsets
 	for ( var j = 0; j < 5; j ++ ) {
 
 		var code = str.charCodeAt( deltaStart + numVerts * j + index );
-		var delta = ( code >> 1 ) ^ ( - ( code & 1 ) );
+		var delta = ( code >> 1) ^ (-(code & 1));
 
 		lastAttrib[ j ] += delta;
 		attribsOutFixed[ stride * index + j ] = lastAttrib[ j ];
 		attribsOut[ stride * index + j ] = decodeScales[ j ] * ( lastAttrib[ j ] + decodeOffsets[ j ] );
-
 	}
 
 };
@@ -358,7 +354,7 @@ THREE.UTF8Loader.prototype.decompressMesh2 = function( str, meshParams, decodePa
 
 	var MAX_BACKREF = 96;
 
-	// Extract conversion parameters from attribArrays.
+    // Extract conversion parameters from attribArrays.
 
 	var stride = decodeParams.decodeScales.length;
 
@@ -393,7 +389,7 @@ THREE.UTF8Loader.prototype.decompressMesh2 = function( str, meshParams, decodePa
 
 		if ( code < max_backref ) {
 
-			// Parallelogram
+            // Parallelogram
 
 			var winding = code % 3;
 			var backref = i - ( code - winding );
@@ -434,16 +430,16 @@ THREE.UTF8Loader.prototype.decompressMesh2 = function( str, meshParams, decodePa
 
 			if ( code === 0 ) {
 
-				for ( var j = 0; j < 5; j ++ ) {
+				for (var j = 0; j < 5; j ++ ) {
 
 					var deltaCode = str.charCodeAt( deltaStart + numVerts * j + highest );
 
-					var prediction = ( ( deltaCode >> 1 ) ^ ( - ( deltaCode & 1 ) ) ) +
-                        attribsOutFixed[ stride * i0 + j ] +
-                        attribsOutFixed[ stride * i1 + j ] -
-                        attribsOutFixed[ stride * i2 + j ];
+					var prediction = ((deltaCode >> 1) ^ (-(deltaCode & 1))) +
+                        attribsOutFixed[stride * i0 + j] +
+                        attribsOutFixed[stride * i1 + j] -
+                        attribsOutFixed[stride * i2 + j];
 
-					lastAttrib[ j ] = prediction;
+					lastAttrib[j] = prediction;
 
 					attribsOutFixed[ stride * highest + j ] = prediction;
 					attribsOut[ stride * highest + j ] = decodeScales[ j ] * ( prediction + decodeOffsets[ j ] );
@@ -462,7 +458,7 @@ THREE.UTF8Loader.prototype.decompressMesh2 = function( str, meshParams, decodePa
 
 		} else {
 
-			// Simple
+            // Simple
 
 			var index0 = highest - ( code - max_backref );
 
@@ -476,7 +472,7 @@ THREE.UTF8Loader.prototype.decompressMesh2 = function( str, meshParams, decodePa
 
 			} else {
 
-				this.copyAttrib( stride, attribsOutFixed, lastAttrib, index0 );
+				this.copyAttrib(stride, attribsOutFixed, lastAttrib, index0);
 
 			}
 
@@ -538,10 +534,9 @@ THREE.UTF8Loader.prototype.decompressMesh2 = function( str, meshParams, decodePa
 		var cy = str.charCodeAt( deltaStart + 6 * numVerts + i );
 		var cz = str.charCodeAt( deltaStart + 7 * numVerts + i );
 
-		attribsOut[ stride * i + 5 ] = norm * nx + ( ( cx >> 1 ) ^ ( - ( cx & 1 ) ) );
-		attribsOut[ stride * i + 6 ] = norm * ny + ( ( cy >> 1 ) ^ ( - ( cy & 1 ) ) );
-		attribsOut[ stride * i + 7 ] = norm * nz + ( ( cz >> 1 ) ^ ( - ( cz & 1 ) ) );
-
+		attribsOut[ stride * i + 5 ] = norm * nx + ((cx >> 1) ^ (-(cx & 1)));
+		attribsOut[ stride * i + 6 ] = norm * ny + ((cy >> 1) ^ (-(cy & 1)));
+		attribsOut[ stride * i + 7 ] = norm * nz + ((cz >> 1) ^ (-(cz & 1)));
 	}
 
 	callback( name, idx, attribsOut, indicesOut, undefined, meshParams );
@@ -576,7 +571,6 @@ THREE.UTF8Loader.prototype.downloadMesh = function ( path, name, meshEntry, deco
 				if ( req.responseText.length < meshEnd ) break;
 
 				loader.decompressMesh2( req.responseText, meshParams, decodeParams, name, idx, callback );
-
 			}
 
 			++ idx;
@@ -593,7 +587,7 @@ THREE.UTF8Loader.prototype.downloadMesh = function ( path, name, meshEntry, deco
 
 		}
 
-		// TODO: handle errors.
+        // TODO: handle errors.
 
 	}, onprogress );
 
@@ -603,7 +597,7 @@ THREE.UTF8Loader.prototype.downloadMeshes = function ( path, meshUrlMap, decodeP
 
 	for ( var url in meshUrlMap ) {
 
-		var meshEntry = meshUrlMap[ url ];
+		var meshEntry = meshUrlMap[url];
 		this.downloadMesh( path + url, url, meshEntry, decodeParams, callback );
 
 	}
@@ -635,7 +629,7 @@ THREE.UTF8Loader.prototype.createMeshCallback = function( materialBaseUrl, loadM
 
 	var model = new THREE.Object3D();
 
-	// Prepare materials first...
+    // Prepare materials first...
 
 	var materialCreator = new THREE.MTLLoader.MaterialCreator( materialBaseUrl, loadModelInfo.options );
 	materialCreator.setMaterials( loadModelInfo.materials );
@@ -648,14 +642,14 @@ THREE.UTF8Loader.prototype.createMeshCallback = function( materialBaseUrl, loadM
 
 	var meshCallback = function( name, idx, attribArray, indexArray, bboxen, meshParams ) {
 
-		// Got ourselves a new mesh
+        // Got ourselves a new mesh
 
-		// name identifies this part of the model (url)
-		// idx is the mesh index of this mesh of the part
-		// attribArray defines the vertices
-		// indexArray defines the faces
-		// bboxen defines the bounding box
-		// meshParams contains the material info
+        // name identifies this part of the model (url)
+        // idx is the mesh index of this mesh of the part
+        // attribArray defines the vertices
+        // indexArray defines the faces
+        // bboxen defines the bounding box
+        // meshParams contains the material info
 
 		var geometry = bufferGeometryCreator.create( attribArray, indexArray );
 		var material = materialCreator.create( meshParams.material );
@@ -663,7 +657,7 @@ THREE.UTF8Loader.prototype.createMeshCallback = function( materialBaseUrl, loadM
 		var mesh = new THREE.Mesh( geometry, material );
 		modelParts[ name ].add( mesh );
 
-		//model.add(new THREE.Mesh(geometry, material));
+        //model.add(new THREE.Mesh(geometry, material));
 
 		decodedMeshesPerUrl[ name ] ++;
 
@@ -675,7 +669,7 @@ THREE.UTF8Loader.prototype.createMeshCallback = function( materialBaseUrl, loadM
 
 			if ( nCompletedUrls === nExpectedUrls ) {
 
-				// ALL DONE!!!
+                // ALL DONE!!!
 
 				allDoneCallback( model );
 
@@ -755,47 +749,33 @@ function getHttpRequest( url, onload, opt_onprogress ) {
 
 	var LISTENERS = {
 
-		load: function( e ) {
-
-			onload( req, e );
+        load: function( e ) { onload( req, e ); },
+        progress: function( e ) { opt_onprogress( req, e ); }
 
-		},
-		progress: function( e ) {
-
-			opt_onprogress( req, e );
-
-		}
-
-	};
+    };
 
 	var req = new XMLHttpRequest();
 	addListeners( req, LISTENERS );
 
 	req.open( 'GET', url, true );
 	req.send( null );
-
 }
 
 function getJsonRequest( url, onjson ) {
 
 	getHttpRequest( url,
-        function( e ) {
-
-	onjson( JSON.parse( e.responseText ) );
-
- },
+        function( e ) { onjson( JSON.parse( e.responseText ) ); },
         function() {} );
 
 }
 
 function addListeners( dom, listeners ) {
 
-	// TODO: handle event capture, object binding.
+    // TODO: handle event capture, object binding.
 
 	for ( var key in listeners ) {
 
 		dom.addEventListener( key, listeners[ key ] );
 
 	}
-
 }

+ 5 - 1
utils/codestyle/config.json

@@ -1,5 +1,6 @@
 {
     "preset": "mdcs",
+    "disallowNewlineBeforeBlockStatements": true,
     "excludeFiles": [ 
         "../../.c9/", 
         "../../.c9version/", 
@@ -20,7 +21,10 @@
         "../../examples/js/libs/",
         "../../examples/js/loaders/ctm/",
         "../../examples/js/loaders/gltf/",
-        "../../examples/js/loaders/sea3d/"
+        "../../examples/js/loaders/sea3d/",
+        "../../examples/js/ImprovedNoise.js",
+        "../../examples/js/SimplexNoise.js",
+        "../../examples/js/loaders/UTF8Loader.js"
         ]
     
 }