Changed switches to ifs as per discussion in 46294a0f0834c0a9207f3bcda87ef292ffe3e414.

src/core/Color.js

@@ -96,15 +96,41 @@ THREE.Color.prototype = {
 			q = v * ( 1 - ( s * f ) );
 			t = v * ( 1 - ( s * ( 1 - f ) ) );
 
-			switch ( i ) {
-
-				case 1: this.r = q; this.g = v; this.b = p; break;
-				case 2: this.r = p; this.g = v; this.b = t; break;
-				case 3: this.r = p; this.g = q; this.b = v; break;
-				case 4: this.r = t; this.g = p; this.b = v; break;
-				case 5: this.r = v; this.g = p; this.b = q; break;
-				case 6: // fall through
-				case 0: this.r = v; this.g = t; this.b = p; break;
+			if ( i === 0 ) {
+
+				this.r = v;
+				this.g = t;
+				this.b = p;
+
+			} else if ( i === 1 ) {
+
+				this.r = q;
+				this.g = v;
+				this.b = p;
+
+			} else if ( i === 2 ) {
+
+				this.r = p;
+				this.g = v;
+				this.b = t;
+
+			} else if ( i === 3 ) {
+
+				this.r = p;
+				this.g = q;
+				this.b = v;
+
+			} else if ( i === 4 ) {
+
+				this.r = t;
+				this.g = p;
+				this.b = v;
+
+			} else if ( i === 5 ) {
+
+				this.r = v;
+				this.g = p;
+				this.b = q;
 
 			}
 

src/core/Matrix4.js

@@ -418,7 +418,7 @@ THREE.Matrix4.prototype = {
 
 	},
 
-	setRotationFromEuler: function( v, order ) {
+	setRotationFromEuler: function ( v, order ) {
 
 		var te = this.elements;
 
@@ -427,109 +427,101 @@ THREE.Matrix4.prototype = {
 		var c = Math.cos( y ), d = Math.sin( y );
 		var e = Math.cos( z ), f = Math.sin( z );
 
-		switch ( order ) {
+		if ( order === undefined || order === 'XYZ' ) {
 
-			case 'YXZ':
+			var ae = a * e, af = a * f, be = b * e, bf = b * f;
 
-				var ce = c * e, cf = c * f, de = d * e, df = d * f;
+			te[0] = c * e;
+			te[4] = - c * f;
+			te[8] = d;
 
-				te[0] = ce + df * b;
-				te[4] = de * b - cf;
-				te[8] = a * d;
+			te[1] = af + be * d;
+			te[5] = ae - bf * d;
+			te[9] = - b * c;
 
-				te[1] = a * f;
-				te[5] = a * e;
-				te[9] = - b;
+			te[2] = bf - ae * d;
+			te[6] = be + af * d;
+			te[10] = a * c;
 
-				te[2] = cf * b - de;
-				te[6] = df + ce * b;
-				te[10] = a * c;
-				break;
+		} else if ( order === 'YXZ' ) {
 
-			case 'ZXY':
+			var ce = c * e, cf = c * f, de = d * e, df = d * f;
 
-				var ce = c * e, cf = c * f, de = d * e, df = d * f;
+			te[0] = ce + df * b;
+			te[4] = de * b - cf;
+			te[8] = a * d;
 
-				te[0] = ce - df * b;
-				te[4] = - a * f;
-				te[8] = de + cf * b;
+			te[1] = a * f;
+			te[5] = a * e;
+			te[9] = - b;
 
-				te[1] = cf + de * b;
-				te[5] = a * e;
-				te[9] = df - ce * b;
+			te[2] = cf * b - de;
+			te[6] = df + ce * b;
+			te[10] = a * c;
 
-				te[2] = - a * d;
-				te[6] = b;
-				te[10] = a * c;
-				break;
+		} else if ( order === 'ZXY' ) {
 
-			case 'ZYX':
+			var ce = c * e, cf = c * f, de = d * e, df = d * f;
 
-				var ae = a * e, af = a * f, be = b * e, bf = b * f;
+			te[0] = ce - df * b;
+			te[4] = - a * f;
+			te[8] = de + cf * b;
 
-				te[0] = c * e;
-				te[4] = be * d - af;
-				te[8] = ae * d + bf;
+			te[1] = cf + de * b;
+			te[5] = a * e;
+			te[9] = df - ce * b;
 
-				te[1] = c * f;
-				te[5] = bf * d + ae;
-				te[9] = af * d - be;
+			te[2] = - a * d;
+			te[6] = b;
+			te[10] = a * c;
 
-				te[2] = - d;
-				te[6] = b * c;
-				te[10] = a * c;
-				break;
+		} else if ( order === 'ZYX' ) {
 
-			case 'YZX':
+			var ae = a * e, af = a * f, be = b * e, bf = b * f;
 
-				var ac = a * c, ad = a * d, bc = b * c, bd = b * d;
+			te[0] = c * e;
+			te[4] = be * d - af;
+			te[8] = ae * d + bf;
 
-				te[0] = c * e;
-				te[4] = bd - ac * f;
-				te[8] = bc * f + ad;
+			te[1] = c * f;
+			te[5] = bf * d + ae;
+			te[9] = af * d - be;
 
-				te[1] = f;
-				te[5] = a * e;
-				te[9] = - b * e;
+			te[2] = - d;
+			te[6] = b * c;
+			te[10] = a * c;
 
-				te[2] = - d * e;
-				te[6] = ad * f + bc;
-				te[10] = ac - bd * f;
-				break;
+		} else if ( order === 'YZX' ) {
 
-			case 'XZY':
+			var ac = a * c, ad = a * d, bc = b * c, bd = b * d;
 
-				var ac = a * c, ad = a * d, bc = b * c, bd = b * d;
+			te[0] = c * e;
+			te[4] = bd - ac * f;
+			te[8] = bc * f + ad;
 
-				te[0] = c * e;
-				te[4] = - f;
-				te[8] = d * e;
+			te[1] = f;
+			te[5] = a * e;
+			te[9] = - b * e;
 
-				te[1] = ac * f + bd;
-				te[5] = a * e;
-				te[9] = ad * f - bc;
+			te[2] = - d * e;
+			te[6] = ad * f + bc;
+			te[10] = ac - bd * f;
 
-				te[2] = bc * f - ad;
-				te[6] = b * e;
-				te[10] = bd * f + ac;
-				break;
+		} else if ( order === 'XZY' ) {
 
-			default: // 'XYZ'
+			var ac = a * c, ad = a * d, bc = b * c, bd = b * d;
 
-				var ae = a * e, af = a * f, be = b * e, bf = b * f;
+			te[0] = c * e;
+			te[4] = - f;
+			te[8] = d * e;
 
-				te[0] = c * e;
-				te[4] = - c * f;
-				te[8] = d;
+			te[1] = ac * f + bd;
+			te[5] = a * e;
+			te[9] = ad * f - bc;
 
-				te[1] = af + be * d;
-				te[5] = ae - bf * d;
-				te[9] = - b * c;
-
-				te[2] = bf - ae * d;
-				te[6] = be + af * d;
-				te[10] = a * c;
-				break;
+			te[2] = bc * f - ad;
+			te[6] = b * e;
+			te[10] = bd * f + ac;
 
 		}
 
@@ -538,7 +530,7 @@ THREE.Matrix4.prototype = {
 	},
 
 
-	setRotationFromQuaternion: function( q ) {
+	setRotationFromQuaternion: function ( q ) {
 
 		var te = this.elements;
 

src/core/Quaternion.js

@@ -45,70 +45,54 @@ THREE.Quaternion.prototype = {
 		// 	20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/
 		//	content/SpinCalc.m
 	
-		var _order = order || 'XYZ',
-		
-			c1 = Math.cos( v.x / 2 ),
-			c2 = Math.cos( v.y / 2 ),
-			c3 = Math.cos( v.z / 2 ),
-			s1 = Math.sin( v.x / 2 ),
-			s2 = Math.sin( v.y / 2 ),
-			s3 = Math.sin( v.z / 2 );
-				
-		switch ( _order ) {
-	
-			case 'YXZ':
-	
-				this.x = s1 * c2 * c3 + c1 * s2 * s3;
-				this.y = c1 * s2 * c3 - s1 * c2 * s3;
-				this.z = c1 * c2 * s3 - s1 * s2 * c3;
-				this.w = c1 * c2 * c3 + s1 * s2 * s3;
+		var c1 = Math.cos( v.x / 2 );
+		var c2 = Math.cos( v.y / 2 );
+		var c3 = Math.cos( v.z / 2 );
+		var s1 = Math.sin( v.x / 2 );
+		var s2 = Math.sin( v.y / 2 );
+		var s3 = Math.sin( v.z / 2 );
+
+		if ( order === undefined || order === 'XYZ' ) {
+
+			this.x = s1 * c2 * c3 + c1 * s2 * s3;
+			this.y = c1 * s2 * c3 - s1 * c2 * s3;
+			this.z = c1 * c2 * s3 + s1 * s2 * c3;
+			this.w = c1 * c2 * c3 - s1 * s2 * s3;
+
+		} else if ( order === 'YXZ' ) {
 	
-				break;
+			this.x = s1 * c2 * c3 + c1 * s2 * s3;
+			this.y = c1 * s2 * c3 - s1 * c2 * s3;
+			this.z = c1 * c2 * s3 - s1 * s2 * c3;
+			this.w = c1 * c2 * c3 + s1 * s2 * s3;
 				
-			case 'ZXY':
+		} else if ( order === 'ZXY' ) {
 	
-				this.x = s1 * c2 * c3 - c1 * s2 * s3;
-				this.y = c1 * s2 * c3 + s1 * c2 * s3;
-				this.z = c1 * c2 * s3 + s1 * s2 * c3;
-				this.w = c1 * c2 * c3 - s1 * s2 * s3;
-	
-				break;
+			this.x = s1 * c2 * c3 - c1 * s2 * s3;
+			this.y = c1 * s2 * c3 + s1 * c2 * s3;
+			this.z = c1 * c2 * s3 + s1 * s2 * c3;
+			this.w = c1 * c2 * c3 - s1 * s2 * s3;
 				
-			case 'ZYX':
-	
-				this.x = s1 * c2 * c3 - c1 * s2 * s3;
-				this.y = c1 * s2 * c3 + s1 * c2 * s3;
-				this.z = c1 * c2 * s3 - s1 * s2 * c3;
-				this.w = c1 * c2 * c3 + s1 * s2 * s3;
+		} else if ( order === 'ZYX' ) {
 	
-				break;
+			this.x = s1 * c2 * c3 - c1 * s2 * s3;
+			this.y = c1 * s2 * c3 + s1 * c2 * s3;
+			this.z = c1 * c2 * s3 - s1 * s2 * c3;
+			this.w = c1 * c2 * c3 + s1 * s2 * s3;
 				
-			case 'YZX':
+		} else if ( order === 'YZX' ) {
 			
-				this.x = s1 * c2 * c3 + c1 * s2 * s3;
-				this.y = c1 * s2 * c3 + s1 * c2 * s3;
-				this.z = c1 * c2 * s3 - s1 * s2 * c3;
-				this.w = c1 * c2 * c3 - s1 * s2 * s3;
-	
-				break;
+			this.x = s1 * c2 * c3 + c1 * s2 * s3;
+			this.y = c1 * s2 * c3 + s1 * c2 * s3;
+			this.z = c1 * c2 * s3 - s1 * s2 * c3;
+			this.w = c1 * c2 * c3 - s1 * s2 * s3;
 				
-			case 'XZY':
+		} else if ( order === 'XZY' ) {
 			
-				this.x = s1 * c2 * c3 - c1 * s2 * s3;
-				this.y = c1 * s2 * c3 - s1 * c2 * s3;
-				this.z = c1 * c2 * s3 + s1 * s2 * c3;
-				this.w = c1 * c2 * c3 + s1 * s2 * s3;
-	
-				break;
-				
-			default: // 'XYZ'
-	
-				this.x = s1 * c2 * c3 + c1 * s2 * s3;
-				this.y = c1 * s2 * c3 - s1 * c2 * s3;
-				this.z = c1 * c2 * s3 + s1 * s2 * c3;
-				this.w = c1 * c2 * c3 - s1 * s2 * s3;
-		
-				break;
+			this.x = s1 * c2 * c3 - c1 * s2 * s3;
+			this.y = c1 * s2 * c3 - s1 * c2 * s3;
+			this.z = c1 * c2 * s3 + s1 * s2 * c3;
+			this.w = c1 * c2 * c3 + s1 * s2 * s3;
 				
 		}
 		

src/core/Vector3.js

@@ -282,124 +282,107 @@ THREE.Vector3.prototype = {
 			return Math.min( Math.max( x, -1 ), 1 );
 
 		}
+
+		var te = m.elements;
+		var m11 = te[0], m12 = te[4], m13 = te[8];
+		var m21 = te[1], m22 = te[5], m23 = te[9];
+		var m31 = te[2], m32 = te[6], m33 = te[10];
+
+		if ( order === undefined || order === 'XYZ' ) {
+
+			this.y = Math.asin( clamp( m13 ) );
 		
-		var _order = order || 'XYZ',
+			if ( Math.abs( m13 ) < 0.99999 ) {
 		
-			te = m.elements,
+				this.x = Math.atan2( - m23, m33 );
+				this.z = Math.atan2( - m12, m11 );
+		
+			} else {
 			
-			m11 = te[0], m12 = te[4], m13 = te[8],
-			m21 = te[1], m22 = te[5], m23 = te[9],
-			m31 = te[2], m32 = te[6], m33 = te[10];
-	
-		switch ( _order ) {
-	
-			case 'YXZ':
+				this.x = Math.atan2( m21, m22 );
+				this.z = 0;
+		
+			}
+
+		} else if ( order === 'YXZ' ) {
 				
-				this.x = Math.asin( - clamp( m23 ) );
+			this.x = Math.asin( - clamp( m23 ) );
+		
+			if ( Math.abs( m23 ) < 0.99999 ) {
 			
-				if ( Math.abs( m23 ) < 0.99999 ) {
+				this.y = Math.atan2( m13, m33 );
+				this.z = Math.atan2( m21, m22 );
 				
-					this.y = Math.atan2( m13, m33 );
-					this.z = Math.atan2( m21, m22 );
-					
-				} else {
-				
-					this.y = Math.atan2( - m31, m11 );
-					this.z = 0;
-					
-				}
+			} else {
+			
+				this.y = Math.atan2( - m31, m11 );
+				this.z = 0;
 				
-				break;
+			}
 				
-			case 'ZXY':
+		} else if ( order === 'ZXY' ) {
 	
-				this.x = Math.asin( clamp( m32 ) );
+			this.x = Math.asin( clamp( m32 ) );
+		
+			if ( Math.abs( m32 ) < 0.99999 ) {
 			
-				if ( Math.abs( m32 ) < 0.99999 ) {
+				this.y = Math.atan2( - m31, m33 );
+				this.z = Math.atan2( - m12, m22 );
 				
-					this.y = Math.atan2( - m31, m33 );
-					this.z = Math.atan2( - m12, m22 );
-					
-				} else {
-					
-					this.y = 0;
-					this.z = Math.atan2( m13, m11 );
-					
-				}
+			} else {
 				
-				break;
+				this.y = 0;
+				this.z = Math.atan2( m13, m11 );
 				
-			case 'ZYX':
+			}
+
+		} else if ( order === 'ZYX' ) {
 	
-				this.y = Math.asin( - clamp( m31 ) );
-				
-				if ( Math.abs( m31 ) < 0.99999 ) {
-				
-					this.x = Math.atan2( m32, m33 );
-					this.z = Math.atan2( m21, m11 );
-					
-				} else {
-				
-					this.x = 0;
-					this.z = Math.atan2( - m12, m22 );
-					
-				}
-				
-				break;
-				
-			case 'YZX':
+			this.y = Math.asin( - clamp( m31 ) );
 			
-				this.z = Math.asin( clamp( m21 ) );
+			if ( Math.abs( m31 ) < 0.99999 ) {
 			
-				if ( Math.abs( m21 ) < 0.99999 ) {
-			
-					this.x = Math.atan2( - m23, m22 );
-					this.y = Math.atan2( - m31, m11 );
-			
-				} else {
+				this.x = Math.atan2( m32, m33 );
+				this.z = Math.atan2( m21, m11 );
 				
-					this.x = 0;
-					this.y = Math.atan2( m31, m33 );
+			} else {
 			
-				}
+				this.x = 0;
+				this.z = Math.atan2( - m12, m22 );
 				
-				break;
+			}
 				
-			case 'XZY':
-			
-				this.z = Math.asin( - clamp( m12 ) );
+		} else if ( order === 'YZX' ) {
 			
-				if ( Math.abs( m12 ) < 0.99999 ) {
-			
-					this.x = Math.atan2( m32, m22 );
-					this.y = Math.atan2( m13, m11 );
-			
-				} else {
-				
-					this.x = Math.atan2( - m13, m33 );
-					this.y = 0;
+			this.z = Math.asin( clamp( m21 ) );
+		
+			if ( Math.abs( m21 ) < 0.99999 ) {
+		
+				this.x = Math.atan2( - m23, m22 );
+				this.y = Math.atan2( - m31, m11 );
+		
+			} else {
 			
-				}
-				
-				break;
+				this.x = 0;
+				this.y = Math.atan2( m31, m33 );
+		
+			}
 				
-			default: // 'XYZ'
-	
-				this.y = Math.asin( clamp( m13 ) );
+		} else if ( order === 'XZY' ) {
 			
-				if ( Math.abs( m13 ) < 0.99999 ) {
-			
-					this.x = Math.atan2( - m23, m33 );
-					this.z = Math.atan2( - m12, m11 );
-			
-				} else {
-				
-					this.x = Math.atan2( m21, m22 );
-					this.z = 0;
+			this.z = Math.asin( - clamp( m12 ) );
+		
+			if ( Math.abs( m12 ) < 0.99999 ) {
+		
+				this.x = Math.atan2( m32, m22 );
+				this.y = Math.atan2( m13, m11 );
+		
+			} else {
 			
-				}
-				
-				break;
+				this.x = Math.atan2( - m13, m33 );
+				this.y = 0;
+		
+			}
 				
 		}
 		
@@ -425,54 +408,42 @@ THREE.Vector3.prototype = {
 		var sqy = q.y * q.y;
 		var sqz = q.z * q.z;
 		var sqw = q.w * q.w;
+
+		if ( order === undefined || order === 'XYZ' ) {
+
+			this.x = Math.atan2( 2 * ( q.x * q.w - q.y * q.z ), ( sqw - sqx - sqy + sqz ) );
+			this.y = Math.asin(  clamp( 2 * ( q.x * q.z + q.y * q.w ) ) );
+			this.z = Math.atan2( 2 * ( q.z * q.w - q.x * q.y ), ( sqw + sqx - sqy - sqz ) );
 	
-		switch ( order ) {
-	
-			case 'YXZ':
+		} else if ( order ===  'YXZ' ) {
 	
-				this.x = Math.asin(  clamp( 2 * ( q.x * q.w - q.y * q.z ) ) );
-				this.y = Math.atan2( 2 * ( q.x * q.z + q.y * q.w ), ( sqw - sqx - sqy + sqz ) );
-				this.z = Math.atan2( 2 * ( q.x * q.y + q.z * q.w ), ( sqw - sqx + sqy - sqz ) );
-				
-				break;
+			this.x = Math.asin(  clamp( 2 * ( q.x * q.w - q.y * q.z ) ) );
+			this.y = Math.atan2( 2 * ( q.x * q.z + q.y * q.w ), ( sqw - sqx - sqy + sqz ) );
+			this.z = Math.atan2( 2 * ( q.x * q.y + q.z * q.w ), ( sqw - sqx + sqy - sqz ) );
 	
-			case 'ZXY':
+		} else if ( order === 'ZXY' ) {
 			
-				this.x = Math.asin(  clamp( 2 * ( q.x * q.w + q.y * q.z ) ) );
-				this.y = Math.atan2( 2 * ( q.y * q.w - q.z * q.x ), ( sqw - sqx - sqy + sqz ) );
-				this.z = Math.atan2( 2 * ( q.z * q.w - q.x * q.y ), ( sqw - sqx + sqy - sqz ) );
-				
-				break;
+			this.x = Math.asin(  clamp( 2 * ( q.x * q.w + q.y * q.z ) ) );
+			this.y = Math.atan2( 2 * ( q.y * q.w - q.z * q.x ), ( sqw - sqx - sqy + sqz ) );
+			this.z = Math.atan2( 2 * ( q.z * q.w - q.x * q.y ), ( sqw - sqx + sqy - sqz ) );
 			
-			case 'ZYX':
+		} else if ( order === 'ZYX' ) {
 			
-				this.x = Math.atan2( 2 * ( q.x * q.w + q.z * q.y ), ( sqw - sqx - sqy + sqz ) );
-				this.y = Math.asin(  clamp( 2 * ( q.y * q.w - q.x * q.z ) ) );
-				this.z = Math.atan2( 2 * ( q.x * q.y + q.z * q.w ), ( sqw + sqx - sqy - sqz ) );
-				
-				break;
+			this.x = Math.atan2( 2 * ( q.x * q.w + q.z * q.y ), ( sqw - sqx - sqy + sqz ) );
+			this.y = Math.asin(  clamp( 2 * ( q.y * q.w - q.x * q.z ) ) );
+			this.z = Math.atan2( 2 * ( q.x * q.y + q.z * q.w ), ( sqw + sqx - sqy - sqz ) );
 	
-			case 'YZX':
+		} else if ( order === 'YZX' ) {
 			
-				this.x = Math.atan2( 2 * ( q.x * q.w - q.z * q.y ), ( sqw - sqx + sqy - sqz ) );
-				this.y = Math.atan2( 2 * ( q.y * q.w - q.x * q.z ), ( sqw + sqx - sqy - sqz ) );
-				this.z = Math.asin(  clamp( 2 * ( q.x * q.y + q.z * q.w ) ) );
-				
-				break;
+			this.x = Math.atan2( 2 * ( q.x * q.w - q.z * q.y ), ( sqw - sqx + sqy - sqz ) );
+			this.y = Math.atan2( 2 * ( q.y * q.w - q.x * q.z ), ( sqw + sqx - sqy - sqz ) );
+			this.z = Math.asin(  clamp( 2 * ( q.x * q.y + q.z * q.w ) ) );
 			
-			case 'XZY':
+		} else if ( order === 'XZY' ) {
 			
-				this.x = Math.atan2( 2 * ( q.x * q.w + q.y * q.z ), ( sqw - sqx + sqy - sqz ) );
-				this.y = Math.atan2( 2 * ( q.x * q.z + q.y * q.w ), ( sqw + sqx - sqy - sqz ) );
-				this.z = Math.asin(  clamp( 2 * ( q.z * q.w - q.x * q.y ) ) );
-				
-				break;
-	
-			default: // 'XYZ'
-	
-				this.x = Math.atan2( 2 * ( q.x * q.w - q.y * q.z ), ( sqw - sqx - sqy + sqz ) );
-				this.y = Math.asin(  clamp( 2 * ( q.x * q.z + q.y * q.w ) ) );
-				this.z = Math.atan2( 2 * ( q.z * q.w - q.x * q.y ), ( sqw + sqx - sqy - sqz ) );
+			this.x = Math.atan2( 2 * ( q.x * q.w + q.y * q.z ), ( sqw - sqx + sqy - sqz ) );
+			this.y = Math.atan2( 2 * ( q.x * q.z + q.y * q.w ), ( sqw + sqx - sqy - sqz ) );
+			this.z = Math.asin(  clamp( 2 * ( q.z * q.w - q.x * q.y ) ) );
 	
 		}
 		

src/renderers/CanvasRenderer.js

@@ -1040,25 +1040,17 @@ THREE.CanvasRenderer = function ( parameters ) {
 
 		if ( _contextGlobalCompositeOperation !== value ) {
 
-			switch ( value ) {
+			if ( value === THREE.NormalBlending ) {
 
-				case THREE.NormalBlending:
+				_context.globalCompositeOperation = 'source-over';
 
-					_context.globalCompositeOperation = 'source-over';
+			} else if ( value === THREE.AdditiveBlending ) {
 
-					break;
+				_context.globalCompositeOperation = 'lighter';
 
-				case THREE.AdditiveBlending:
+			} else if ( value === THREE.SubtractiveBlending ) {
 
-					_context.globalCompositeOperation = 'lighter';
-
-					break;
-
-				case THREE.SubtractiveBlending:
-
-					_context.globalCompositeOperation = 'darker';
-
-					break;
+				_context.globalCompositeOperation = 'darker';
 
 			}
 

src/renderers/WebGLRenderer.js

@@ -4897,204 +4897,172 @@ THREE.WebGLRenderer = function ( parameters ) {
 			type = uniform.type;
 			value = uniform.value;
 
-			switch ( type ) {
+			if ( type === "i" ) { // single integer
 
-				case "i": // single integer
+				_gl.uniform1i( location, value );
 
-					_gl.uniform1i( location, value );
+			} else if ( type === "f" ) { // single float
 
-					break;
+				_gl.uniform1f( location, value );
 
-				case "f": // single float
+			} else if ( type === "v2" ) { // single THREE.Vector2
 
-					_gl.uniform1f( location, value );
+				_gl.uniform2f( location, value.x, value.y );
 
-					break;
+			} else if ( type === "v3" ) { // single THREE.Vector3
 
-				case "v2": // single THREE.Vector2
+				_gl.uniform3f( location, value.x, value.y, value.z );
 
-					_gl.uniform2f( location, value.x, value.y );
+			} else if ( type === "v4" ) { // single THREE.Vector4
 
-					break;
+				_gl.uniform4f( location, value.x, value.y, value.z, value.w );
 
-				case "v3": // single THREE.Vector3
+			} else if ( type === "c" ) { // single THREE.Color
 
-					_gl.uniform3f( location, value.x, value.y, value.z );
+				_gl.uniform3f( location, value.r, value.g, value.b );
 
-					break;
+			} else if ( type === "fv1" ) { // flat array of floats (JS or typed array)
 
-				case "v4": // single THREE.Vector4
+				_gl.uniform1fv( location, value );
 
-					_gl.uniform4f( location, value.x, value.y, value.z, value.w );
+			} else if ( type === "fv" ) { // flat array of floats with 3 x N size (JS or typed array)
 
-					break;
+				_gl.uniform3fv( location, value );
 
-				case "c": // single THREE.Color
+			} else if ( type === "v2v" ) { // array of THREE.Vector2
 
-					_gl.uniform3f( location, value.r, value.g, value.b );
+				if ( uniform._array === undefined ) {
 
-					break;
+					uniform._array = new Float32Array( 2 * value.length );
 
-				case "fv1": // flat array of floats (JS or typed array)
-
-					_gl.uniform1fv( location, value );
-
-					break;
-
-				case "fv": // flat array of floats with 3 x N size (JS or typed array)
-
-					_gl.uniform3fv( location, value );
-
-					break;
-
-				case "v2v": // array of THREE.Vector2
-
-					if ( ! uniform._array ) {
-
-						uniform._array = new Float32Array( 2 * value.length );
-
-					}
-
-					for ( i = 0, il = value.length; i < il; i ++ ) {
-
-						offset = i * 2;
-
-						uniform._array[ offset ] 	 = value[ i ].x;
-						uniform._array[ offset + 1 ] = value[ i ].y;
-
-					}
-
-					_gl.uniform2fv( location, uniform._array );
-
-					break;
-
-				case "v3v": // array of THREE.Vector3
+				}
 
-					if ( ! uniform._array ) {
+				for ( i = 0, il = value.length; i < il; i ++ ) {
 
-						uniform._array = new Float32Array( 3 * value.length );
+					offset = i * 2;
 
-					}
+					uniform._array[ offset ] 	 = value[ i ].x;
+					uniform._array[ offset + 1 ] = value[ i ].y;
 
-					for ( i = 0, il = value.length; i < il; i ++ ) {
+				}
 
-						offset = i * 3;
+				_gl.uniform2fv( location, uniform._array );
 
-						uniform._array[ offset ] 	 = value[ i ].x;
-						uniform._array[ offset + 1 ] = value[ i ].y;
-						uniform._array[ offset + 2 ] = value[ i ].z;
+			} else if ( type === "v3v" ) { // array of THREE.Vector3
 
-					}
+				if ( uniform._array === undefined ) {
 
-					_gl.uniform3fv( location, uniform._array );
+					uniform._array = new Float32Array( 3 * value.length );
 
-					break;
+				}
 
-				case "v4v": // array of THREE.Vector4
+				for ( i = 0, il = value.length; i < il; i ++ ) {
 
-					if ( ! uniform._array ) {
+					offset = i * 3;
 
-						uniform._array = new Float32Array( 4 * value.length );
+					uniform._array[ offset ] 	 = value[ i ].x;
+					uniform._array[ offset + 1 ] = value[ i ].y;
+					uniform._array[ offset + 2 ] = value[ i ].z;
 
-					}
+				}
 
-					for ( i = 0, il = value.length; i < il; i ++ ) {
+				_gl.uniform3fv( location, uniform._array );
 
-						offset = i * 4;
+			} else if ( type === "v4v" ) { // array of THREE.Vector4
 
-						uniform._array[ offset ] 	 = value[ i ].x;
-						uniform._array[ offset + 1 ] = value[ i ].y;
-						uniform._array[ offset + 2 ] = value[ i ].z;
-						uniform._array[ offset + 3 ] = value[ i ].w;
+				if ( uniform._array === undefined ) {
 
-					}
+					uniform._array = new Float32Array( 4 * value.length );
 
-					_gl.uniform4fv( location, uniform._array );
+				}
 
-					break;
+				for ( i = 0, il = value.length; i < il; i ++ ) {
 
-				case "m4": // single THREE.Matrix4
+					offset = i * 4;
 
-					if ( ! uniform._array ) {
+					uniform._array[ offset ] 	 = value[ i ].x;
+					uniform._array[ offset + 1 ] = value[ i ].y;
+					uniform._array[ offset + 2 ] = value[ i ].z;
+					uniform._array[ offset + 3 ] = value[ i ].w;
 
-						uniform._array = new Float32Array( 16 );
+				}
 
-					}
+				_gl.uniform4fv( location, uniform._array );
 
-					value.flattenToArray( uniform._array );
-					_gl.uniformMatrix4fv( location, false, uniform._array );
+			} else if ( type === "m4") { // single THREE.Matrix4
 
-					break;
+				if ( uniform._array === undefined ) {
 
-				case "m4v": // array of THREE.Matrix4
+					uniform._array = new Float32Array( 16 );
 
-					if ( ! uniform._array ) {
+				}
 
-						uniform._array = new Float32Array( 16 * value.length );
+				value.flattenToArray( uniform._array );
+				_gl.uniformMatrix4fv( location, false, uniform._array );
 
-					}
+			} else if ( type === "m4v" ) { // array of THREE.Matrix4
 
-					for ( i = 0, il = value.length; i < il; i ++ ) {
+				if ( uniform._array === undefined ) {
 
-						value[ i ].flattenToArrayOffset( uniform._array, i * 16 );
+					uniform._array = new Float32Array( 16 * value.length );
 
-					}
+				}
 
-					_gl.uniformMatrix4fv( location, false, uniform._array );
+				for ( i = 0, il = value.length; i < il; i ++ ) {
 
-					break;
+					value[ i ].flattenToArrayOffset( uniform._array, i * 16 );
 
-				case "t": // single THREE.Texture (2d or cube)
+				}
 
-					_gl.uniform1i( location, value );
+				_gl.uniformMatrix4fv( location, false, uniform._array );
 
-					texture = uniform.texture;
+			} else if ( type === "t" ) { // single THREE.Texture (2d or cube)
 
-					if ( !texture ) continue;
+				_gl.uniform1i( location, value );
 
-					if ( texture.image instanceof Array && texture.image.length === 6 ) {
+				texture = uniform.texture;
 
-						setCubeTexture( texture, value );
+				if ( !texture ) continue;
 
-					} else if ( texture instanceof THREE.WebGLRenderTargetCube ) {
+				if ( texture.image instanceof Array && texture.image.length === 6 ) {
 
-						setCubeTextureDynamic( texture, value );
+					setCubeTexture( texture, value );
 
-					} else {
+				} else if ( texture instanceof THREE.WebGLRenderTargetCube ) {
 
-						_this.setTexture( texture, value );
+					setCubeTextureDynamic( texture, value );
 
-					}
+				} else {
 
-					break;
+					_this.setTexture( texture, value );
 
-				case "tv": // array of THREE.Texture (2d)
+				}
 
-					if ( ! uniform._array ) {
+			} else if ( type === "tv" ) { // array of THREE.Texture (2d)
 
-						uniform._array = [];
+				if ( uniform._array === undefined ) {
 
-						for( i = 0, il = uniform.texture.length; i < il; i ++ ) {
+					uniform._array = [];
 
-							uniform._array[ i ] = value + i;
+					for( i = 0, il = uniform.texture.length; i < il; i ++ ) {
 
-						}
+						uniform._array[ i ] = value + i;
 
 					}
 
-					_gl.uniform1iv( location, uniform._array );
+				}
 
-					for( i = 0, il = uniform.texture.length; i < il; i ++ ) {
+				_gl.uniform1iv( location, uniform._array );
 
-						texture = uniform.texture[ i ];
+				for( i = 0, il = uniform.texture.length; i < il; i ++ ) {
 
-						if ( !texture ) continue;
+					texture = uniform.texture[ i ];
 
-						_this.setTexture( texture, uniform._array[ i ] );
+					if ( !texture ) continue;
 
-					}
+					_this.setTexture( texture, uniform._array[ i ] );
 
-					break;
+				}
 
 			}
 
@@ -5435,53 +5403,39 @@ THREE.WebGLRenderer = function ( parameters ) {
 
 		if ( blending !== _oldBlending ) {
 
-			switch ( blending ) {
-
-				case THREE.NoBlending:
-
-					_gl.disable( _gl.BLEND );
-
-					break;
-
-				case THREE.AdditiveBlending:
-
-					_gl.enable( _gl.BLEND );
-					_gl.blendEquation( _gl.FUNC_ADD );
-					_gl.blendFunc( _gl.SRC_ALPHA, _gl.ONE );
+			if ( blending === THREE.NoBlending ) {
 
-					break;
+				_gl.disable( _gl.BLEND );
 
-				case THREE.SubtractiveBlending:
+			} else if ( blending === THREE.AdditiveBlending ) {
 
-					// TODO: Find blendFuncSeparate() combination
-					_gl.enable( _gl.BLEND );
-					_gl.blendEquation( _gl.FUNC_ADD );
-					_gl.blendFunc( _gl.ZERO, _gl.ONE_MINUS_SRC_COLOR );
+				_gl.enable( _gl.BLEND );
+				_gl.blendEquation( _gl.FUNC_ADD );
+				_gl.blendFunc( _gl.SRC_ALPHA, _gl.ONE );
 
-					break;
+			} else if ( blending === THREE.SubtractiveBlending ) {
 
-				case THREE.MultiplyBlending:
+				// TODO: Find blendFuncSeparate() combination
+				_gl.enable( _gl.BLEND );
+				_gl.blendEquation( _gl.FUNC_ADD );
+				_gl.blendFunc( _gl.ZERO, _gl.ONE_MINUS_SRC_COLOR );
 
-					// TODO: Find blendFuncSeparate() combination
-					_gl.enable( _gl.BLEND );
-					_gl.blendEquation( _gl.FUNC_ADD );
-					_gl.blendFunc( _gl.ZERO, _gl.SRC_COLOR );
+			} else if ( blending === THREE.MultiplyBlending ) {
 
-					break;
+				// TODO: Find blendFuncSeparate() combination
+				_gl.enable( _gl.BLEND );
+				_gl.blendEquation( _gl.FUNC_ADD );
+				_gl.blendFunc( _gl.ZERO, _gl.SRC_COLOR );
 
-				case THREE.CustomBlending:
+			} else if ( blending === THREE.CustomBlending ) {
 
-					_gl.enable( _gl.BLEND );
+				_gl.enable( _gl.BLEND );
 
-					break;
-
-				default:
-
-					_gl.enable( _gl.BLEND );
-					_gl.blendEquationSeparate( _gl.FUNC_ADD, _gl.FUNC_ADD );
-					_gl.blendFuncSeparate( _gl.SRC_ALPHA, _gl.ONE_MINUS_SRC_ALPHA, _gl.ONE, _gl.ONE_MINUS_SRC_ALPHA );
+			} else {
 
-					break;
+				_gl.enable( _gl.BLEND );
+				_gl.blendEquationSeparate( _gl.FUNC_ADD, _gl.FUNC_ADD );
+				_gl.blendFuncSeparate( _gl.SRC_ALPHA, _gl.ONE_MINUS_SRC_ALPHA, _gl.ONE, _gl.ONE_MINUS_SRC_ALPHA );
 
 			}
 
@@ -6196,77 +6150,66 @@ THREE.WebGLRenderer = function ( parameters ) {
 
 	function filterFallback ( f ) {
 
-		switch ( f ) {
-
-			case THREE.NearestFilter:
-			case THREE.NearestMipMapNearestFilter:
-			case THREE.NearestMipMapLinearFilter: return _gl.NEAREST; break;
-
-			case THREE.LinearFilter:
-			case THREE.LinearMipMapNearestFilter:
-			case THREE.LinearMipMapLinearFilter:
-			default:
+		if ( f === THREE.NearestFilter || f === THREE.NearestMipMapNearestFilter || f === THREE.NearestMipMapLinearFilter ) {
 
-				return _gl.LINEAR; break;
+			return _gl.NEAREST;
 
 		}
 
+		return _gl.LINEAR;
+
 	};
 
 	// Map three.js constants to WebGL constants
 
 	function paramThreeToGL ( p ) {
 
-		switch ( p ) {
-
-			case THREE.RepeatWrapping: return _gl.REPEAT; break;
-			case THREE.ClampToEdgeWrapping: return _gl.CLAMP_TO_EDGE; break;
-			case THREE.MirroredRepeatWrapping: return _gl.MIRRORED_REPEAT; break;
-
-			case THREE.NearestFilter: return _gl.NEAREST; break;
-			case THREE.NearestMipMapNearestFilter: return _gl.NEAREST_MIPMAP_NEAREST; break;
-			case THREE.NearestMipMapLinearFilter: return _gl.NEAREST_MIPMAP_LINEAR; break;
-
-			case THREE.LinearFilter: return _gl.LINEAR; break;
-			case THREE.LinearMipMapNearestFilter: return _gl.LINEAR_MIPMAP_NEAREST; break;
-			case THREE.LinearMipMapLinearFilter: return _gl.LINEAR_MIPMAP_LINEAR; break;
-
-			case THREE.UnsignedByteType: return _gl.UNSIGNED_BYTE; break;
-			case THREE.UnsignedShort4444Type: return _gl.UNSIGNED_SHORT_4_4_4_4; break;
-			case THREE.UnsignedShort5551Type: return _gl.UNSIGNED_SHORT_5_5_5_1; break;
-			case THREE.UnsignedShort565Type: return _gl.UNSIGNED_SHORT_5_6_5; break;
-
-			case THREE.ByteType: return _gl.BYTE; break;
-			case THREE.ShortType: return _gl.SHORT; break;
-			case THREE.UnsignedShortType: return _gl.UNSIGNED_SHORT; break;
-			case THREE.IntType: return _gl.INT; break;
-			case THREE.UnsignedIntType: return _gl.UNSIGNED_INT; break;
-			case THREE.FloatType: return _gl.FLOAT; break;
-
-			case THREE.AlphaFormat: return _gl.ALPHA; break;
-			case THREE.RGBFormat: return _gl.RGB; break;
-			case THREE.RGBAFormat: return _gl.RGBA; break;
-			case THREE.LuminanceFormat: return _gl.LUMINANCE; break;
-			case THREE.LuminanceAlphaFormat: return _gl.LUMINANCE_ALPHA; break;
-
-			case THREE.AddEquation: return _gl.FUNC_ADD; break;
-			case THREE.SubtractEquation: return _gl.FUNC_SUBTRACT; break;
-			case THREE.ReverseSubtractEquation: return _gl.FUNC_REVERSE_SUBTRACT; break;
-
-			case THREE.ZeroFactor: return _gl.ZERO; break;
-			case THREE.OneFactor: return _gl.ONE; break;
-			case THREE.SrcColorFactor: return _gl.SRC_COLOR; break;
-			case THREE.OneMinusSrcColorFactor: return _gl.ONE_MINUS_SRC_COLOR; break;
-			case THREE.SrcAlphaFactor: return _gl.SRC_ALPHA; break;
-			case THREE.OneMinusSrcAlphaFactor: return _gl.ONE_MINUS_SRC_ALPHA; break;
-			case THREE.DstAlphaFactor: return _gl.DST_ALPHA; break;
-			case THREE.OneMinusDstAlphaFactor: return _gl.ONE_MINUS_DST_ALPHA; break;
-
-			case THREE.DstColorFactor: return _gl.DST_COLOR; break;
-			case THREE.OneMinusDstColorFactor: return _gl.ONE_MINUS_DST_COLOR; break;
-			case THREE.SrcAlphaSaturateFactor: return _gl.SRC_ALPHA_SATURATE; break;
-
-		}
+		if ( p === THREE.RepeatWrapping ) return _gl.REPEAT;
+		if ( p === THREE.ClampToEdgeWrapping ) return _gl.CLAMP_TO_EDGE;
+		if ( p === THREE.MirroredRepeatWrapping ) return _gl.MIRRORED_REPEAT;
+
+		if ( p === THREE.NearestFilter ) return _gl.NEAREST;
+		if ( p === THREE.NearestMipMapNearestFilter ) return _gl.NEAREST_MIPMAP_NEAREST;
+		if ( p === THREE.NearestMipMapLinearFilter ) return _gl.NEAREST_MIPMAP_LINEAR;
+
+		if ( p === THREE.LinearFilter ) return _gl.LINEAR;
+		if ( p === THREE.LinearMipMapNearestFilter ) return _gl.LINEAR_MIPMAP_NEAREST;
+		if ( p === THREE.LinearMipMapLinearFilter ) return _gl.LINEAR_MIPMAP_LINEAR;
+
+		if ( p === THREE.UnsignedByteType ) return _gl.UNSIGNED_BYTE;
+		if ( p === THREE.UnsignedShort4444Type ) return _gl.UNSIGNED_SHORT_4_4_4_4;
+		if ( p === THREE.UnsignedShort5551Type ) return _gl.UNSIGNED_SHORT_5_5_5_1;
+		if ( p === THREE.UnsignedShort565Type ) return _gl.UNSIGNED_SHORT_5_6_5;
+
+		if ( p === THREE.ByteType ) return _gl.BYTE;
+		if ( p === THREE.ShortType ) return _gl.SHORT;
+		if ( p === THREE.UnsignedShortType ) return _gl.UNSIGNED_SHORT;
+		if ( p === THREE.IntType ) return _gl.INT;
+		if ( p === THREE.UnsignedIntType ) return _gl.UNSIGNED_INT;
+		if ( p === THREE.FloatType ) return _gl.FLOAT;
+
+		if ( p === THREE.AlphaFormat ) return _gl.ALPHA;
+		if ( p === THREE.RGBFormat ) return _gl.RGB;
+		if ( p === THREE.RGBAFormat ) return _gl.RGBA;
+		if ( p === THREE.LuminanceFormat ) return _gl.LUMINANCE;
+		if ( p === THREE.LuminanceAlphaFormat ) return _gl.LUMINANCE_ALPHA;
+
+		if ( p === THREE.AddEquation ) return _gl.FUNC_ADD;
+		if ( p === THREE.SubtractEquation ) return _gl.FUNC_SUBTRACT;
+		if ( p === THREE.ReverseSubtractEquation ) return _gl.FUNC_REVERSE_SUBTRACT;
+
+		if ( p === THREE.ZeroFactor ) return _gl.ZERO;
+		if ( p === THREE.OneFactor ) return _gl.ONE;
+		if ( p === THREE.SrcColorFactor ) return _gl.SRC_COLOR;
+		if ( p === THREE.OneMinusSrcColorFactor ) return _gl.ONE_MINUS_SRC_COLOR;
+		if ( p === THREE.SrcAlphaFactor ) return _gl.SRC_ALPHA;
+		if ( p === THREE.OneMinusSrcAlphaFactor ) return _gl.ONE_MINUS_SRC_ALPHA;
+		if ( p === THREE.DstAlphaFactor ) return _gl.DST_ALPHA;
+		if ( p === THREE.OneMinusDstAlphaFactor ) return _gl.ONE_MINUS_DST_ALPHA;
+
+		if ( p === THREE.DstColorFactor ) return _gl.DST_COLOR;
+		if ( p === THREE.OneMinusDstColorFactor ) return _gl.ONE_MINUS_DST_COLOR;
+		if ( p === THREE.SrcAlphaSaturateFactor ) return _gl.SRC_ALPHA_SATURATE;
 
 		return 0;