super-three 0.136.1 → 0.137.0

package/examples/js/loaders/MD2Loader.js

@@ -114,7 +114,7 @@
 
 				for ( let j = 0; j < 16; j ++ ) {
 
-					const character = data.getUint8( offset + j, true );
+					const character = data.getUint8( offset + j );
 					if ( character === 0 ) break;
 					string[ j ] = character;
 
@@ -129,11 +129,11 @@
 
 				for ( let j = 0; j < header.num_vertices; j ++ ) {
 
-					let x = data.getUint8( offset ++, true );
-					let y = data.getUint8( offset ++, true );
-					let z = data.getUint8( offset ++, true );
+					let x = data.getUint8( offset ++ );
+					let y = data.getUint8( offset ++ );
+					let z = data.getUint8( offset ++ );
 
-					const n = _normalData[ data.getUint8( offset ++, true ) ];
+					const n = _normalData[ data.getUint8( offset ++ ) ];
 
 					x = x * scale.x + translation.x;
 					y = y * scale.y + translation.y;

package/examples/js/loaders/MTLLoader.js

@@ -327,6 +327,13 @@
 				map.offset.copy( texParams.offset );
 				map.wrapS = scope.wrap;
 				map.wrapT = scope.wrap;
+
+				if ( mapType === 'map' || mapType === 'emissiveMap' ) {
+
+					map.encoding = THREE.sRGBEncoding;
+
+				}
+
 				params[ mapType ] = map;
 
 			}
@@ -342,17 +349,17 @@
 					// Ns is material specular exponent
 					case 'kd':
 						// Diffuse color (color under white light) using RGB values
-						params.color = new THREE.Color().fromArray( value );
+						params.color = new THREE.Color().fromArray( value ).convertSRGBToLinear();
 						break;
 
 					case 'ks':
 						// Specular color (color when light is reflected from shiny surface) using RGB values
-						params.specular = new THREE.Color().fromArray( value );
+						params.specular = new THREE.Color().fromArray( value ).convertSRGBToLinear();
 						break;
 
 					case 'ke':
 						// Emissive using RGB values
-						params.emissive = new THREE.Color().fromArray( value );
+						params.emissive = new THREE.Color().fromArray( value ).convertSRGBToLinear();
 						break;
 
 					case 'map_kd':

package/examples/js/loaders/PCDLoader.js

@@ -262,9 +262,9 @@
 
 					if ( offset.rgb !== undefined ) {
 
-						color.push( dataview.getUint8( PCDheader.points * offset.rgb + PCDheader.size[ 3 ] * i + 0 ) / 255.0 );
-						color.push( dataview.getUint8( PCDheader.points * offset.rgb + PCDheader.size[ 3 ] * i + 1 ) / 255.0 );
 						color.push( dataview.getUint8( PCDheader.points * offset.rgb + PCDheader.size[ 3 ] * i + 2 ) / 255.0 );
+						color.push( dataview.getUint8( PCDheader.points * offset.rgb + PCDheader.size[ 3 ] * i + 1 ) / 255.0 );
+						color.push( dataview.getUint8( PCDheader.points * offset.rgb + PCDheader.size[ 3 ] * i + 0 ) / 255.0 );
 
 					}
 

package/examples/js/loaders/STLLoader.js

@@ -134,7 +134,7 @@
 				// Check if each byte in query matches the corresponding byte from the current offset
 				for ( let i = 0, il = query.length; i < il; i ++ ) {
 
-					if ( query[ i ] !== reader.getUint8( offset + i, false ) ) return false;
+					if ( query[ i ] !== reader.getUint8( offset + i ) ) return false;
 
 				}
 

package/examples/js/loaders/SVGLoader.js

@@ -110,7 +110,8 @@
 
 					case 'use':
 						style = parseStyle( node, style );
-						const usedNodeId = node.href.baseVal.substring( 1 );
+						const href = node.getAttributeNS( 'http://www.w3.org/1999/xlink', 'href' ) || '';
+						const usedNodeId = href.substring( 1 );
 						const usedNode = node.viewportElement.getElementById( usedNodeId );
 
 						if ( usedNode ) {
@@ -561,7 +562,7 @@
 					for ( let j = 0; j < selectorList.length; j ++ ) {
 
 						// Remove empty rules
-						const definitions = Object.fromEntries( Object.entries( stylesheet.style ).filter( ( [ _, v ] ) => v !== '' ) );
+						const definitions = Object.fromEntries( Object.entries( stylesheet.style ).filter( ( [ , v ] ) => v !== '' ) );
 						stylesheets[ selectorList[ j ] ] = Object.assign( stylesheets[ selectorList[ j ] ] || {}, definitions );
 
 					}

package/examples/js/modifiers/EdgeSplitModifier.js

@@ -166,12 +166,6 @@
 
 			if ( geometry.index == null ) {
 
-				if ( THREE.BufferGeometryUtils === undefined ) {
-
-					throw new Error( 'THREE.EdgeSplitModifier relies on THREE.BufferGeometryUtils' );
-
-				}
-
 				geometry = THREE.BufferGeometryUtils.mergeVertices( geometry );
 
 			}

package/examples/js/modifiers/SimplifyModifier.js

@@ -13,16 +13,6 @@
 
 	class SimplifyModifier {
 
-		constructor() {
-
-			if ( THREE.BufferGeometryUtils === undefined ) {
-
-				throw new Error( 'THREE.SimplifyModifier relies on THREE.BufferGeometryUtils' );
-
-			}
-
-		}
-
 		modify( geometry, count ) {
 
 			if ( geometry.isGeometry === true ) {

package/examples/js/objects/Lensflare.js

@@ -15,8 +15,8 @@
 			const positionScreen = new THREE.Vector3();
 			const positionView = new THREE.Vector3(); // textures
 
-			const tempMap = new THREE.FramebufferTexture( 16, 16, THREE.RGBFormat );
-			const occlusionMap = new THREE.FramebufferTexture( 16, 16, THREE.RGBFormat ); // material
+			const tempMap = new THREE.FramebufferTexture( 16, 16, THREE.RGBAFormat );
+			const occlusionMap = new THREE.FramebufferTexture( 16, 16, THREE.RGBAFormat ); // material
 
 			const geometry = Lensflare.Geometry;
 			const material1a = new THREE.RawShaderMaterial( {

package/examples/js/postprocessing/OutlinePass.js

@@ -25,10 +25,6 @@
 			};
 			const resx = Math.round( this.resolution.x / this.downSampleRatio );
 			const resy = Math.round( this.resolution.y / this.downSampleRatio );
-			this.maskBufferMaterial = new THREE.MeshBasicMaterial( {
-				color: 0xffffff
-			} );
-			this.maskBufferMaterial.side = THREE.DoubleSide;
 			this.renderTargetMaskBuffer = new THREE.WebGLRenderTarget( this.resolution.x, this.resolution.y, pars );
 			this.renderTargetMaskBuffer.texture.name = 'OutlinePass.mask';
 			this.renderTargetMaskBuffer.texture.generateMipmaps = false;
@@ -93,7 +89,7 @@
 
 			function replaceDepthToViewZ( string, camera ) {
 
-				var type = camera.isPerspectiveCamera ? 'perspective' : 'orthographic';
+				const type = camera.isPerspectiveCamera ? 'perspective' : 'orthographic';
 				return string.replace( /DEPTH_TO_VIEW_Z/g, type + 'DepthToViewZ' );
 
 			}

package/examples/js/renderers/CSS2DRenderer.js

@@ -102,38 +102,44 @@
 
 				if ( object.isCSS2DObject ) {
 
-					object.onBeforeRender( _this, scene, camera );
+					const visible = object.visible && _vector.z >= - 1 && _vector.z <= 1 && object.layers.test( camera.layers );
+					object.element.style.display = visible ? '' : 'none';
 
-					_vector.setFromMatrixPosition( object.matrixWorld );
+					if ( visible ) {
 
-					_vector.applyMatrix4( _viewProjectionMatrix );
+						object.onBeforeRender( _this, scene, camera );
 
-					const element = object.element;
+						_vector.setFromMatrixPosition( object.matrixWorld );
 
-					if ( /apple/i.test( navigator.vendor ) ) {
+						_vector.applyMatrix4( _viewProjectionMatrix );
 
-						// https://github.com/mrdoob/three.js/issues/21415
-						element.style.transform = 'translate(-50%,-50%) translate(' + Math.round( _vector.x * _widthHalf + _widthHalf ) + 'px,' + Math.round( - _vector.y * _heightHalf + _heightHalf ) + 'px)';
+						const element = object.element;
 
-					} else {
+						if ( /apple/i.test( navigator.vendor ) ) {
 
-						element.style.transform = 'translate(-50%,-50%) translate(' + ( _vector.x * _widthHalf + _widthHalf ) + 'px,' + ( - _vector.y * _heightHalf + _heightHalf ) + 'px)';
+							// https://github.com/mrdoob/three.js/issues/21415
+							element.style.transform = 'translate(-50%,-50%) translate(' + Math.round( _vector.x * _widthHalf + _widthHalf ) + 'px,' + Math.round( - _vector.y * _heightHalf + _heightHalf ) + 'px)';
 
-					}
+						} else {
 
-					element.style.display = object.visible && _vector.z >= - 1 && _vector.z <= 1 ? '' : 'none';
-					const objectData = {
-						distanceToCameraSquared: getDistanceToSquared( camera, object )
-					};
-					cache.objects.set( object, objectData );
+							element.style.transform = 'translate(-50%,-50%) translate(' + ( _vector.x * _widthHalf + _widthHalf ) + 'px,' + ( - _vector.y * _heightHalf + _heightHalf ) + 'px)';
 
-					if ( element.parentNode !== domElement ) {
+						}
 
-						domElement.appendChild( element );
+						const objectData = {
+							distanceToCameraSquared: getDistanceToSquared( camera, object )
+						};
+						cache.objects.set( object, objectData );
 
-					}
+						if ( element.parentNode !== domElement ) {
+
+							domElement.appendChild( element );
 
-					object.onAfterRender( _this, scene, camera );
+						}
+
+						object.onAfterRender( _this, scene, camera );
+
+					}
 
 				}
 

package/examples/js/renderers/CSS3DRenderer.js

@@ -181,57 +181,62 @@
 
 				if ( object.isCSS3DObject ) {
 
-					object.onBeforeRender( _this, scene, camera );
-					let style;
+					const visible = object.visible && object.layers.test( camera.layers );
+					object.element.style.display = visible ? '' : 'none'; // only getObjectCSSMatrix when object.visible
 
-					if ( object.isCSS3DSprite ) {
+					if ( visible ) {
 
-						// http://swiftcoder.wordpress.com/2008/11/25/constructing-a-billboard-matrix/
-						_matrix.copy( camera.matrixWorldInverse );
+						object.onBeforeRender( _this, scene, camera );
+						let style;
 
-						_matrix.transpose();
+						if ( object.isCSS3DSprite ) {
 
-						if ( object.rotation2D !== 0 ) _matrix.multiply( _matrix2.makeRotationZ( object.rotation2D ) );
-						object.matrixWorld.decompose( _position, _quaternion, _scale );
+							// http://swiftcoder.wordpress.com/2008/11/25/constructing-a-billboard-matrix/
+							_matrix.copy( camera.matrixWorldInverse );
 
-						_matrix.setPosition( _position );
+							_matrix.transpose();
 
-						_matrix.scale( _scale );
+							if ( object.rotation2D !== 0 ) _matrix.multiply( _matrix2.makeRotationZ( object.rotation2D ) );
+							object.matrixWorld.decompose( _position, _quaternion, _scale );
 
-						_matrix.elements[ 3 ] = 0;
-						_matrix.elements[ 7 ] = 0;
-						_matrix.elements[ 11 ] = 0;
-						_matrix.elements[ 15 ] = 1;
-						style = getObjectCSSMatrix( _matrix );
+							_matrix.setPosition( _position );
 
-					} else {
+							_matrix.scale( _scale );
 
-						style = getObjectCSSMatrix( object.matrixWorld );
+							_matrix.elements[ 3 ] = 0;
+							_matrix.elements[ 7 ] = 0;
+							_matrix.elements[ 11 ] = 0;
+							_matrix.elements[ 15 ] = 1;
+							style = getObjectCSSMatrix( _matrix );
 
-					}
+						} else {
 
-					const element = object.element;
-					const cachedObject = cache.objects.get( object );
+							style = getObjectCSSMatrix( object.matrixWorld );
 
-					if ( cachedObject === undefined || cachedObject.style !== style ) {
+						}
 
-						element.style.transform = style;
-						const objectData = {
-							style: style
-						};
-						cache.objects.set( object, objectData );
+						const element = object.element;
+						const cachedObject = cache.objects.get( object );
 
-					}
+						if ( cachedObject === undefined || cachedObject.style !== style ) {
 
-					element.style.display = object.visible ? '' : 'none';
+							element.style.transform = style;
+							const objectData = {
+								style: style
+							};
+							cache.objects.set( object, objectData );
 
-					if ( element.parentNode !== cameraElement ) {
+						}
 
-						cameraElement.appendChild( element );
+						if ( element.parentNode !== cameraElement ) {
 
-					}
+							cameraElement.appendChild( element );
 
-					object.onAfterRender( _this, scene, camera );
+						}
+
+						object.onAfterRender( _this, scene, camera );
+
+					}
 
 				}
 

package/examples/js/utils/LDrawUtils.js

@@ -0,0 +1,182 @@
+( function () {
+
+	class LDrawUtils {
+
+		static mergeObject( object ) {
+
+			// Merges geometries in object by materials and returns new object. Use on not indexed geometries.
+			// The object buffers reference the old object ones.
+			// Special treatment is done to the conditional lines generated by LDrawLoader.
+			function extractGroup( geometry, group, elementSize, isConditionalLine ) {
+
+				// Extracts a group from a geometry as a new geometry (with attribute buffers referencing original buffers)
+				const newGeometry = new THREE.BufferGeometry();
+				const originalPositions = geometry.getAttribute( 'position' ).array;
+				const originalNormals = elementSize === 3 ? geometry.getAttribute( 'normal' ).array : null;
+				const numVertsGroup = Math.min( group.count, Math.floor( originalPositions.length / 3 ) - group.start );
+				const vertStart = group.start * 3;
+				const vertEnd = ( group.start + numVertsGroup ) * 3;
+				const positions = originalPositions.subarray( vertStart, vertEnd );
+				const normals = originalNormals !== null ? originalNormals.subarray( vertStart, vertEnd ) : null;
+				newGeometry.setAttribute( 'position', new THREE.BufferAttribute( positions, 3 ) );
+				if ( normals !== null ) newGeometry.setAttribute( 'normal', new THREE.BufferAttribute( normals, 3 ) );
+
+				if ( isConditionalLine ) {
+
+					const controlArray0 = geometry.getAttribute( 'control0' ).array.subarray( vertStart, vertEnd );
+					const controlArray1 = geometry.getAttribute( 'control1' ).array.subarray( vertStart, vertEnd );
+					const directionArray = geometry.getAttribute( 'direction' ).array.subarray( vertStart, vertEnd );
+					newGeometry.setAttribute( 'control0', new THREE.BufferAttribute( controlArray0, 3, false ) );
+					newGeometry.setAttribute( 'control1', new THREE.BufferAttribute( controlArray1, 3, false ) );
+					newGeometry.setAttribute( 'direction', new THREE.BufferAttribute( directionArray, 3, false ) );
+
+				}
+
+				return newGeometry;
+
+			}
+
+			function addGeometry( mat, geometry, geometries ) {
+
+				const geoms = geometries[ mat.uuid ];
+
+				if ( ! geoms ) {
+
+					geometries[ mat.uuid ] = {
+						mat: mat,
+						arr: [ geometry ]
+					};
+
+				} else {
+
+					geoms.arr.push( geometry );
+
+				}
+
+			}
+
+			function permuteAttribute( attribute, elemSize ) {
+
+				// Permutes first two vertices of each attribute element
+				if ( ! attribute ) return;
+				const verts = attribute.array;
+				const numVerts = Math.floor( verts.length / 3 );
+				let offset = 0;
+
+				for ( let i = 0; i < numVerts; i ++ ) {
+
+					const x = verts[ offset ];
+					const y = verts[ offset + 1 ];
+					const z = verts[ offset + 2 ];
+					verts[ offset ] = verts[ offset + 3 ];
+					verts[ offset + 1 ] = verts[ offset + 4 ];
+					verts[ offset + 2 ] = verts[ offset + 5 ];
+					verts[ offset + 3 ] = x;
+					verts[ offset + 4 ] = y;
+					verts[ offset + 5 ] = z;
+					offset += elemSize * 3;
+
+				}
+
+			} // Traverse the object hierarchy collecting geometries and transforming them to world space
+
+
+			const meshGeometries = {};
+			const linesGeometries = {};
+			const condLinesGeometries = {};
+			object.updateMatrixWorld( true );
+			const normalMatrix = new THREE.Matrix3();
+			object.traverse( c => {
+
+				if ( c.isMesh | c.isLineSegments ) {
+
+					const elemSize = c.isMesh ? 3 : 2;
+					const geometry = c.geometry.clone();
+					const matrixIsInverted = c.matrixWorld.determinant() < 0;
+
+					if ( matrixIsInverted ) {
+
+						permuteAttribute( geometry.attributes.position, elemSize );
+						permuteAttribute( geometry.attributes.normal, elemSize );
+
+					}
+
+					geometry.applyMatrix4( c.matrixWorld );
+
+					if ( c.isConditionalLine ) {
+
+						geometry.attributes.control0.applyMatrix4( c.matrixWorld );
+						geometry.attributes.control1.applyMatrix4( c.matrixWorld );
+						normalMatrix.getNormalMatrix( c.matrixWorld );
+						geometry.attributes.direction.applyNormalMatrix( normalMatrix );
+
+					}
+
+					const geometries = c.isMesh ? meshGeometries : c.isConditionalLine ? condLinesGeometries : linesGeometries;
+
+					if ( Array.isArray( c.material ) ) {
+
+						for ( const groupIndex in geometry.groups ) {
+
+							const group = geometry.groups[ groupIndex ];
+							const mat = c.material[ group.materialIndex ];
+							const newGeometry = extractGroup( geometry, group, elemSize, c.isConditionalLine );
+							addGeometry( mat, newGeometry, geometries );
+
+						}
+
+					} else {
+
+						addGeometry( c.material, geometry, geometries );
+
+					}
+
+				}
+
+			} ); // Create object with merged geometries
+
+			const mergedObject = new THREE.Group();
+			const meshMaterialsIds = Object.keys( meshGeometries );
+
+			for ( const i in meshMaterialsIds ) {
+
+				const meshGeometry = meshGeometries[ meshMaterialsIds[ i ] ];
+				const mergedGeometry = THREE.mergeBufferGeometries( meshGeometry.arr );
+				mergedObject.add( new THREE.Mesh( mergedGeometry, meshGeometry.mat ) );
+
+			}
+
+			const linesMaterialsIds = Object.keys( linesGeometries );
+
+			for ( const i in linesMaterialsIds ) {
+
+				const lineGeometry = linesGeometries[ linesMaterialsIds[ i ] ];
+				const mergedGeometry = THREE.mergeBufferGeometries( lineGeometry.arr );
+				mergedObject.add( new THREE.LineSegments( mergedGeometry, lineGeometry.mat ) );
+
+			}
+
+			const condLinesMaterialsIds = Object.keys( condLinesGeometries );
+
+			for ( const i in condLinesMaterialsIds ) {
+
+				const condLineGeometry = condLinesGeometries[ condLinesMaterialsIds[ i ] ];
+				const mergedGeometry = THREE.mergeBufferGeometries( condLineGeometry.arr );
+				const condLines = new THREE.LineSegments( mergedGeometry, condLineGeometry.mat );
+				condLines.isConditionalLine = true;
+				mergedObject.add( condLines );
+
+			}
+
+			mergedObject.userData.constructionStep = 0;
+			mergedObject.userData.numConstructionSteps = 1;
+			return mergedObject;
+
+		}
+
+	}
+
+	THREE.LDrawUtils = {};
+	THREE.LDrawUtils.LDrawUtils = LDrawUtils;
+
+} )();

package/examples/jsm/exporters/GLTFExporter.js

@@ -17,6 +17,7 @@ import {
 	RGBAFormat,
 	RepeatWrapping,
 	Scene,
+	Texture,
 	Vector3
 } from 'three';
 
@@ -688,6 +689,79 @@ class GLTFWriter {
 
 	}
 
+	buildORMTexture( material ) {
+
+		const occlusion = material.aoMap?.image;
+		const roughness = material.roughnessMap?.image;
+		const metalness = material.metalnessMap?.image;
+
+		if ( occlusion === roughness && roughness === metalness ) return occlusion;
+
+		if ( occlusion || roughness || metalness ) {
+
+			const width = Math.max( occlusion?.width || 0, roughness?.width || 0, metalness?.width || 0 );
+			const height = Math.max( occlusion?.height || 0, roughness?.height || 0, metalness?.height || 0 );
+
+			const canvas = document.createElement( 'canvas' );
+			canvas.width = width;
+			canvas.height = height;
+
+			const context = canvas.getContext( '2d' );
+			context.fillStyle = '#ffffff';
+			context.fillRect( 0, 0, width, height );
+
+			const composite = context.getImageData( 0, 0, width, height );
+
+			if ( occlusion ) {
+
+				context.drawImage( occlusion, 0, 0, width, height );
+
+				const data = context.getImageData( 0, 0, width, height ).data;
+
+				for ( let i = 0; i < data.length; i += 4 ) {
+
+					composite.data[ i ] = data[ i ];
+
+				}
+
+			}
+
+			if ( roughness ) {
+
+				context.drawImage( roughness, 0, 0, width, height );
+
+				const data = context.getImageData( 0, 0, width, height ).data;
+
+				for ( let i = 1; i < data.length; i += 4 ) {
+
+					composite.data[ i ] = data[ i ];
+
+				}
+
+			}
+
+			if ( metalness ) {
+
+				context.drawImage( metalness, 0, 0, width, height );
+
+				const data = context.getImageData( 0, 0, width, height ).data;
+
+				for ( let i = 2; i < data.length; i += 4 ) {
+
+					composite.data[ i ] = data[ i ];
+
+				}
+
+			}
+
+			context.putImageData( composite, 0, 0 );
+
+			return new Texture( canvas );
+
+		}
+
+	}
+
 	/**
 	 * Process a buffer to append to the default one.
 	 * @param  {ArrayBuffer} buffer
@@ -1178,20 +1252,14 @@ class GLTFWriter {
 
 		}
 
+		const ormTexture = this.buildORMTexture( material );
+
 		// pbrMetallicRoughness.metallicRoughnessTexture
 		if ( material.metalnessMap || material.roughnessMap ) {
 
-			if ( material.metalnessMap === material.roughnessMap ) {
-
-				const metalRoughMapDef = { index: this.processTexture( material.metalnessMap ) };
-				this.applyTextureTransform( metalRoughMapDef, material.metalnessMap );
-				materialDef.pbrMetallicRoughness.metallicRoughnessTexture = metalRoughMapDef;
-
-			} else {
-
-				console.warn( 'THREE.GLTFExporter: Ignoring metalnessMap and roughnessMap because they are not the same Texture.' );
-
-			}
+			const metalRoughMapDef = { index: this.processTexture( ormTexture ) };
+			this.applyTextureTransform( metalRoughMapDef, material.metalnessMap || material.roughnessMap );
+			materialDef.pbrMetallicRoughness.metallicRoughnessTexture = metalRoughMapDef;
 
 		}
 
@@ -1257,7 +1325,7 @@ class GLTFWriter {
 		if ( material.aoMap ) {
 
 			const occlusionMapDef = {
-				index: this.processTexture( material.aoMap ),
+				index: this.processTexture( ormTexture ),
 				texCoord: 1
 			};
 

package/examples/jsm/geometries/TextGeometry.js

@@ -16,7 +16,6 @@
  */
 
 import {
-	BufferGeometry,
 	ExtrudeGeometry
 } from 'three';
 
@@ -26,26 +25,27 @@ class TextGeometry extends ExtrudeGeometry {
 
 		const font = parameters.font;
 
-		if ( ! ( font && font.isFont ) ) {
+		if ( font === undefined ) {
 
-			console.error( 'THREE.TextGeometry: font parameter is not an instance of THREE.Font.' );
-			return new BufferGeometry();
+			super(); // generate default extrude geometry
 
-		}
+		} else {
+
+			const shapes = font.generateShapes( text, parameters.size );
 
-		const shapes = font.generateShapes( text, parameters.size );
+			// translate parameters to ExtrudeGeometry API
 
-		// translate parameters to ExtrudeGeometry API
+			parameters.depth = parameters.height !== undefined ? parameters.height : 50;
 
-		parameters.depth = parameters.height !== undefined ? parameters.height : 50;
+			// defaults
 
-		// defaults
+			if ( parameters.bevelThickness === undefined ) parameters.bevelThickness = 10;
+			if ( parameters.bevelSize === undefined ) parameters.bevelSize = 8;
+			if ( parameters.bevelEnabled === undefined ) parameters.bevelEnabled = false;
 
-		if ( parameters.bevelThickness === undefined ) parameters.bevelThickness = 10;
-		if ( parameters.bevelSize === undefined ) parameters.bevelSize = 8;
-		if ( parameters.bevelEnabled === undefined ) parameters.bevelEnabled = false;
+			super( shapes, parameters );
 
-		super( shapes, parameters );
+		}
 
 		this.type = 'TextGeometry';