super-three 0.158.0 → 0.160.1

package/examples/jsm/loaders/GLTFLoader.js

@@ -151,6 +151,12 @@ class GLTFLoader extends Loader {
 
 		} );
 
+		this.register( function ( parser ) {
+
+			return new GLTFMaterialsBumpExtension( parser );
+
+		} );
+
 		this.register( function ( parser ) {
 
 			return new GLTFLightsExtension( parser );
@@ -183,7 +189,13 @@ class GLTFLoader extends Loader {
 
 		} else if ( this.path !== '' ) {
 
-			resourcePath = this.path;
+			// If a base path is set, resources will be relative paths from that plus the relative path of the gltf file
+			// Example  path = 'https://my-cnd-server.com/', url = 'assets/models/model.gltf'
+			// resourcePath = 'https://my-cnd-server.com/assets/models/'
+			// referenced resource 'model.bin' will be loaded from 'https://my-cnd-server.com/assets/models/model.bin'
+			// referenced resource '../textures/texture.png' will be loaded from 'https://my-cnd-server.com/assets/textures/texture.png'
+			const relativeUrl = LoaderUtils.extractUrlBase( url );
+			resourcePath = LoaderUtils.resolveURL( relativeUrl, this.path );
 
 		} else {
 
@@ -491,6 +503,7 @@ const EXTENSIONS = {
 	KHR_TEXTURE_TRANSFORM: 'KHR_texture_transform',
 	KHR_MESH_QUANTIZATION: 'KHR_mesh_quantization',
 	KHR_MATERIALS_EMISSIVE_STRENGTH: 'KHR_materials_emissive_strength',
+	EXT_MATERIALS_BUMP: 'EXT_materials_bump',
 	EXT_TEXTURE_WEBP: 'EXT_texture_webp',
 	EXT_TEXTURE_AVIF: 'EXT_texture_avif',
 	EXT_MESHOPT_COMPRESSION: 'EXT_meshopt_compression',
@@ -1201,6 +1214,61 @@ class GLTFMaterialsSpecularExtension {
 
 }
 
+
+/**
+ * Materials bump Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/EXT_materials_bump
+ */
+class GLTFMaterialsBumpExtension {
+
+	constructor( parser ) {
+
+		this.parser = parser;
+		this.name = EXTENSIONS.EXT_MATERIALS_BUMP;
+
+	}
+
+	getMaterialType( materialIndex ) {
+
+		const parser = this.parser;
+		const materialDef = parser.json.materials[ materialIndex ];
+
+		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;
+
+		return MeshPhysicalMaterial;
+
+	}
+
+	extendMaterialParams( materialIndex, materialParams ) {
+
+		const parser = this.parser;
+		const materialDef = parser.json.materials[ materialIndex ];
+
+		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {
+
+			return Promise.resolve();
+
+		}
+
+		const pending = [];
+
+		const extension = materialDef.extensions[ this.name ];
+
+		materialParams.bumpScale = extension.bumpFactor !== undefined ? extension.bumpFactor : 1.0;
+
+		if ( extension.bumpTexture !== undefined ) {
+
+			pending.push( parser.assignTexture( materialParams, 'bumpMap', extension.bumpTexture ) );
+
+		}
+
+		return Promise.all( pending );
+
+	}
+
+}
+
 /**
  * Materials anisotropy Extension
  *
@@ -1855,7 +1923,7 @@ class GLTFDracoMeshCompressionExtension {
 
 		return parser.getDependency( 'bufferView', bufferViewIndex ).then( function ( bufferView ) {
 
-			return new Promise( function ( resolve ) {
+			return new Promise( function ( resolve, reject ) {
 
 				dracoLoader.decodeDracoFile( bufferView, function ( geometry ) {
 
@@ -1870,7 +1938,7 @@ class GLTFDracoMeshCompressionExtension {
 
 					resolve( geometry );
 
-				}, threeAttributeMap, attributeTypeMap );
+				}, threeAttributeMap, attributeTypeMap, LinearSRGBColorSpace, reject );
 
 			} );
 

package/examples/jsm/loaders/MaterialXLoader.js

@@ -19,13 +19,13 @@ import {
 	mx_safepower, mx_contrast,
 	mx_srgb_texture_to_lin_rec709,
 	saturation
-} from 'three/nodes';
+} from '../nodes/Nodes.js';
 
 const colorSpaceLib = {
 	mx_srgb_texture_to_lin_rec709
 };
 
-class MtlXElement {
+class MXElement {
 
 	constructor( name, nodeFunc, params = null ) {
 
@@ -39,41 +39,41 @@ class MtlXElement {
 
 // Ref: https://github.com/mrdoob/three.js/issues/24674
 
-const MtlXElements = [
+const MXElements = [
 
 	// << Math >>
-	new MtlXElement( 'add', add, [ 'in1', 'in2' ] ),
-	new MtlXElement( 'subtract', sub, [ 'in1', 'in2' ] ),
-	new MtlXElement( 'multiply', mul, [ 'in1', 'in2' ] ),
-	new MtlXElement( 'divide', div, [ 'in1', 'in2' ] ),
-	new MtlXElement( 'modulo', mod, [ 'in1', 'in2' ] ),
-	new MtlXElement( 'absval', abs, [ 'in1', 'in2' ] ),
-	new MtlXElement( 'sign', sign, [ 'in1', 'in2' ] ),
-	new MtlXElement( 'floor', floor, [ 'in1', 'in2' ] ),
-	new MtlXElement( 'ceil', ceil, [ 'in1', 'in2' ] ),
-	new MtlXElement( 'round', round, [ 'in1', 'in2' ] ),
-	new MtlXElement( 'power', pow, [ 'in1', 'in2' ] ),
-	new MtlXElement( 'sin', sin, [ 'in' ] ),
-	new MtlXElement( 'cos', cos, [ 'in' ] ),
-	new MtlXElement( 'tan', tan, [ 'in' ] ),
-	new MtlXElement( 'asin', asin, [ 'in' ] ),
-	new MtlXElement( 'acos', acos, [ 'in' ] ),
-	new MtlXElement( 'atan2', atan2, [ 'in1', 'in2' ] ),
-	new MtlXElement( 'sqrt', sqrt, [ 'in' ] ),
+	new MXElement( 'add', add, [ 'in1', 'in2' ] ),
+	new MXElement( 'subtract', sub, [ 'in1', 'in2' ] ),
+	new MXElement( 'multiply', mul, [ 'in1', 'in2' ] ),
+	new MXElement( 'divide', div, [ 'in1', 'in2' ] ),
+	new MXElement( 'modulo', mod, [ 'in1', 'in2' ] ),
+	new MXElement( 'absval', abs, [ 'in1', 'in2' ] ),
+	new MXElement( 'sign', sign, [ 'in1', 'in2' ] ),
+	new MXElement( 'floor', floor, [ 'in1', 'in2' ] ),
+	new MXElement( 'ceil', ceil, [ 'in1', 'in2' ] ),
+	new MXElement( 'round', round, [ 'in1', 'in2' ] ),
+	new MXElement( 'power', pow, [ 'in1', 'in2' ] ),
+	new MXElement( 'sin', sin, [ 'in' ] ),
+	new MXElement( 'cos', cos, [ 'in' ] ),
+	new MXElement( 'tan', tan, [ 'in' ] ),
+	new MXElement( 'asin', asin, [ 'in' ] ),
+	new MXElement( 'acos', acos, [ 'in' ] ),
+	new MXElement( 'atan2', atan2, [ 'in1', 'in2' ] ),
+	new MXElement( 'sqrt', sqrt, [ 'in' ] ),
 	//new MtlXElement( 'ln', ... ),
-	new MtlXElement( 'exp', exp, [ 'in' ] ),
-	new MtlXElement( 'clamp', clamp, [ 'in', 'low', 'high' ] ),
-	new MtlXElement( 'min', min, [ 'in1', 'in2' ] ),
-	new MtlXElement( 'max', max, [ 'in1', 'in2' ] ),
-	new MtlXElement( 'normalize', normalize, [ 'in' ] ),
-	new MtlXElement( 'magnitude', length, [ 'in1', 'in2' ] ),
-	new MtlXElement( 'dotproduct', dot, [ 'in1', 'in2' ] ),
-	new MtlXElement( 'crossproduct', cross, [ 'in' ] ),
+	new MXElement( 'exp', exp, [ 'in' ] ),
+	new MXElement( 'clamp', clamp, [ 'in', 'low', 'high' ] ),
+	new MXElement( 'min', min, [ 'in1', 'in2' ] ),
+	new MXElement( 'max', max, [ 'in1', 'in2' ] ),
+	new MXElement( 'normalize', normalize, [ 'in' ] ),
+	new MXElement( 'magnitude', length, [ 'in1', 'in2' ] ),
+	new MXElement( 'dotproduct', dot, [ 'in1', 'in2' ] ),
+	new MXElement( 'crossproduct', cross, [ 'in' ] ),
 	//new MtlXElement( 'transformpoint', ... ),
 	//new MtlXElement( 'transformvector', ... ),
 	//new MtlXElement( 'transformnormal', ... ),
 	//new MtlXElement( 'transformmatrix', ... ),
-	new MtlXElement( 'normalmap', normalMap, [ 'in', 'scale' ] ),
+	new MXElement( 'normalmap', normalMap, [ 'in', 'scale' ] ),
 	//new MtlXElement( 'transpose', ... ),
 	//new MtlXElement( 'determinant', ... ),
 	//new MtlXElement( 'invertmatrix', ... ),
@@ -83,44 +83,44 @@ const MtlXElements = [
 	//new MtlXElement( 'dot', ... ),
 
 	// << Adjustment >>
-	new MtlXElement( 'remap', remap, [ 'in', 'inlow', 'inhigh', 'outlow', 'outhigh' ] ),
-	new MtlXElement( 'smoothstep', smoothstep, [ 'in', 'low', 'high' ] ),
+	new MXElement( 'remap', remap, [ 'in', 'inlow', 'inhigh', 'outlow', 'outhigh' ] ),
+	new MXElement( 'smoothstep', smoothstep, [ 'in', 'low', 'high' ] ),
 	//new MtlXElement( 'curveadjust', ... ),
 	//new MtlXElement( 'curvelookup', ... ),
-	new MtlXElement( 'luminance', luminance, [ 'in', 'lumacoeffs' ] ),
-	new MtlXElement( 'rgbtohsv', mx_rgbtohsv, [ 'in' ] ),
-	new MtlXElement( 'hsvtorgb', mx_hsvtorgb, [ 'in' ] ),
+	new MXElement( 'luminance', luminance, [ 'in', 'lumacoeffs' ] ),
+	new MXElement( 'rgbtohsv', mx_rgbtohsv, [ 'in' ] ),
+	new MXElement( 'hsvtorgb', mx_hsvtorgb, [ 'in' ] ),
 
 	// << Mix >>
-	new MtlXElement( 'mix', mix, [ 'bg', 'fg', 'mix' ] ),
+	new MXElement( 'mix', mix, [ 'bg', 'fg', 'mix' ] ),
 
 	// << Channel >>
-	new MtlXElement( 'combine2', vec2, [ 'in1', 'in2' ] ),
-	new MtlXElement( 'combine3', vec3, [ 'in1', 'in2', 'in3' ] ),
-	new MtlXElement( 'combine4', vec4, [ 'in1', 'in2', 'in3', 'in4' ] ),
+	new MXElement( 'combine2', vec2, [ 'in1', 'in2' ] ),
+	new MXElement( 'combine3', vec3, [ 'in1', 'in2', 'in3' ] ),
+	new MXElement( 'combine4', vec4, [ 'in1', 'in2', 'in3', 'in4' ] ),
 
 	// << Procedural >>
-	new MtlXElement( 'ramplr', mx_ramplr, [ 'valuel', 'valuer', 'texcoord' ] ),
-	new MtlXElement( 'ramptb', mx_ramptb, [ 'valuet', 'valueb', 'texcoord' ] ),
-	new MtlXElement( 'splitlr', mx_splitlr, [ 'valuel', 'valuer', 'texcoord' ] ),
-	new MtlXElement( 'splittb', mx_splittb, [ 'valuet', 'valueb', 'texcoord' ] ),
-	new MtlXElement( 'noise2d', mx_noise_float, [ 'texcoord', 'amplitude', 'pivot' ] ),
-	new MtlXElement( 'noise3d', mx_noise_float, [ 'texcoord', 'amplitude', 'pivot' ] ),
-	new MtlXElement( 'fractal3d', mx_fractal_noise_float, [ 'position', 'octaves', 'lacunarity', 'diminish', 'amplitude' ] ),
-	new MtlXElement( 'cellnoise2d', mx_cell_noise_float, [ 'texcoord' ] ),
-	new MtlXElement( 'cellnoise3d', mx_cell_noise_float, [ 'texcoord' ] ),
-	new MtlXElement( 'worleynoise2d', mx_worley_noise_float, [ 'texcoord', 'jitter' ] ),
-	new MtlXElement( 'worleynoise3d', mx_worley_noise_float, [ 'texcoord', 'jitter' ] ),
+	new MXElement( 'ramplr', mx_ramplr, [ 'valuel', 'valuer', 'texcoord' ] ),
+	new MXElement( 'ramptb', mx_ramptb, [ 'valuet', 'valueb', 'texcoord' ] ),
+	new MXElement( 'splitlr', mx_splitlr, [ 'valuel', 'valuer', 'texcoord' ] ),
+	new MXElement( 'splittb', mx_splittb, [ 'valuet', 'valueb', 'texcoord' ] ),
+	new MXElement( 'noise2d', mx_noise_float, [ 'texcoord', 'amplitude', 'pivot' ] ),
+	new MXElement( 'noise3d', mx_noise_float, [ 'texcoord', 'amplitude', 'pivot' ] ),
+	new MXElement( 'fractal3d', mx_fractal_noise_float, [ 'position', 'octaves', 'lacunarity', 'diminish', 'amplitude' ] ),
+	new MXElement( 'cellnoise2d', mx_cell_noise_float, [ 'texcoord' ] ),
+	new MXElement( 'cellnoise3d', mx_cell_noise_float, [ 'texcoord' ] ),
+	new MXElement( 'worleynoise2d', mx_worley_noise_float, [ 'texcoord', 'jitter' ] ),
+	new MXElement( 'worleynoise3d', mx_worley_noise_float, [ 'texcoord', 'jitter' ] ),
 
 	// << Supplemental >>
 	//new MtlXElement( 'tiledimage', ... ),
 	//new MtlXElement( 'triplanarprojection', triplanarTextures, [ 'filex', 'filey', 'filez' ] ),
 	//new MtlXElement( 'ramp4', ... ),
 	//new MtlXElement( 'place2d', mx_place2d, [ 'texcoord', 'pivot', 'scale', 'rotate', 'offset' ] ),
-	new MtlXElement( 'safepower', mx_safepower, [ 'in1', 'in2' ] ),
-	new MtlXElement( 'contrast', mx_contrast, [ 'in', 'amount', 'pivot' ] ),
+	new MXElement( 'safepower', mx_safepower, [ 'in1', 'in2' ] ),
+	new MXElement( 'contrast', mx_contrast, [ 'in', 'amount', 'pivot' ] ),
 	//new MtlXElement( 'hsvadjust', ... ),
-	new MtlXElement( 'saturate', saturation, [ 'in', 'amount' ] ),
+	new MXElement( 'saturate', saturation, [ 'in', 'amount' ] ),
 	//new MtlXElement( 'extract', ... ),
 	//new MtlXElement( 'separate2', ... ),
 	//new MtlXElement( 'separate3', ... ),
@@ -129,7 +129,7 @@ const MtlXElements = [
 ];
 
 const MtlXLibrary = {};
-MtlXElements.forEach( element => MtlXLibrary[ element.name ] = element );
+MXElements.forEach( element => MtlXLibrary[ element.name ] = element );
 
 class MaterialXLoader extends Loader {
 
@@ -588,11 +588,30 @@ class MaterialXNode {
 
 		//
 
+		let normalNode = null;
+
+		if ( inputs.normal ) normalNode = inputs.normal;
+
+		//
+
+		let emissiveNode = null;
+
+		if ( inputs.emission ) emissiveNode = inputs.emission;
+		if ( inputs.emissionColor )  {
+
+			emissiveNode = emissiveNode ? mul( emissiveNode, inputs.emissionColor ) : emissiveNode;
+
+		}
+
+		//
+
 		material.colorNode = colorNode || color( 0.8, 0.8, 0.8 );
 		material.roughnessNode = roughnessNode || float( 0.2 );
 		material.metalnessNode = metalnessNode || float( 0 );
 		material.clearcoatNode = clearcoatNode || float( 0 );
 		material.clearcoatRoughnessNode = clearcoatRoughnessNode || float( 0 );
+		if ( normalNode ) material.normalNode = normalNode;
+		if ( emissiveNode ) material.emissiveNode = emissiveNode;
 
 	}
 

package/examples/jsm/loaders/NRRDLoader.js

@@ -76,12 +76,6 @@ class NRRDLoader extends Loader {
 
 		function scan( type, chunks ) {
 
-			if ( chunks === undefined || chunks === null ) {
-
-				chunks = 1;
-
-			}
-
 			let _chunkSize = 1;
 			let _array_type = Uint8Array;
 
@@ -138,13 +132,6 @@ class NRRDLoader extends Loader {
 
 			}
 
-			if ( chunks == 1 ) {
-
-				// if only one chunk was requested, just return one value
-				return _bytes[ 0 ];
-
-			}
-
 			// return the byte array
 			return _bytes;
 

package/examples/jsm/loaders/SVGLoader.js

@@ -2968,8 +2968,8 @@ class SVGLoader extends Loader {
 					// Bevel join triangle
 
 					addVertex( currentPointR, u, 1 );
-					addVertex( nextPointR, u, 0 );
-					addVertex( innerPoint, u, 0.5 );
+					addVertex( innerPoint, u, 0 );
+					addVertex( nextPointR, u, 1 );
 
 				}
 
@@ -3106,8 +3106,8 @@ class SVGLoader extends Loader {
 
 						} else {
 
-							tempV2_3.toArray( vertices, vl - 2 * 3 );
-							tempV2_4.toArray( vertices, vl - 1 * 3 );
+							tempV2_4.toArray( vertices, vl - 2 * 3 );
+							tempV2_3.toArray( vertices, vl - 1 * 3 );
 							tempV2_4.toArray( vertices, vl - 4 * 3 );
 
 						}

package/examples/jsm/loaders/USDZLoader.js

@@ -25,9 +25,7 @@ class USDAParser {
 		const data = {};
 
 		const lines = text.split( '\n' );
-		const length = lines.length;
 
-		let current = 0;
 		let string = null;
 		let target = data;
 
@@ -35,9 +33,7 @@ class USDAParser {
 
 		// debugger;
 
-		function parseNextLine() {
-
-			const line = lines[ current ];
+		for ( const line of lines ) {
 
 			// console.log( line );
 
@@ -74,7 +70,7 @@ class USDAParser {
 
 				stack.pop();
 
-				if ( stack.length === 0 ) return;
+				if ( stack.length === 0 ) continue;
 
 				target = stack[ stack.length - 1 ];
 
@@ -100,18 +96,8 @@ class USDAParser {
 
 			}
 
-			current ++;
-
-			if ( current < length ) {
-
-				parseNextLine();
-
-			}
-
 		}
 
-		parseNextLine();
-
 		return data;
 
 	}
@@ -640,7 +626,7 @@ class USDZLoader extends Loader {
 
 						}
 
-					} else  if ( 'float inputs:clearcoat' in surface ) {
+					} else if ( 'float inputs:clearcoat' in surface ) {
 
 						material.clearcoat = parseFloat( surface[ 'float inputs:clearcoat' ] );
 

package/examples/jsm/math/Octree.js

@@ -82,19 +82,18 @@ function lineToLineClosestPoints( line1, line2, target1 = null, target2 = null )
 
 class Octree {
 
-
 	constructor( box ) {
 
-		this.triangles = [];
 		this.box = box;
+		this.bounds = new Box3();
+
 		this.subTrees = [];
+		this.triangles = [];
 
 	}
 
 	addTriangle( triangle ) {
 
-		if ( ! this.bounds ) this.bounds = new Box3();
-
 		this.bounds.min.x = Math.min( this.bounds.min.x, triangle.a.x, triangle.b.x, triangle.c.x );
 		this.bounds.min.y = Math.min( this.bounds.min.y, triangle.a.y, triangle.b.y, triangle.c.y );
 		this.bounds.min.z = Math.min( this.bounds.min.z, triangle.a.z, triangle.b.z, triangle.c.z );
@@ -524,6 +523,18 @@ class Octree {
 
 	}
 
+	clear() {
+
+		this.box = null;
+		this.bounds.makeEmpty();
+
+		this.subTrees.length = 0;
+		this.triangles.length = 0;
+
+		return this;
+
+	}
+
 }
 
 export { Octree };

package/examples/jsm/misc/Timer.js

@@ -0,0 +1,119 @@
+class Timer {
+
+	constructor() {
+
+		this._previousTime = 0;
+		this._currentTime = 0;
+		this._startTime = now();
+
+		this._delta = 0;
+		this._elapsed = 0;
+
+		this._timescale = 1;
+
+		// use Page Visibility API to avoid large time delta values
+
+		this._usePageVisibilityAPI = ( typeof document !== 'undefined' && document.hidden !== undefined );
+
+		if ( this._usePageVisibilityAPI === true ) {
+
+			this._pageVisibilityHandler = handleVisibilityChange.bind( this );
+
+			document.addEventListener( 'visibilitychange', this._pageVisibilityHandler, false );
+
+		}
+
+	}
+
+	getDelta() {
+
+		return this._delta / 1000;
+
+	}
+
+	getElapsed() {
+
+		return this._elapsed / 1000;
+
+	}
+
+	getTimescale() {
+
+		return this._timescale;
+
+	}
+
+	setTimescale( timescale ) {
+
+		this._timescale = timescale;
+
+		return this;
+
+	}
+
+	reset() {
+
+		this._currentTime = now() - this._startTime;
+
+		return this;
+
+	}
+
+	dispose() {
+
+		if ( this._usePageVisibilityAPI === true ) {
+
+			document.removeEventListener( 'visibilitychange', this._pageVisibilityHandler );
+
+		}
+
+		return this;
+
+	}
+
+	update( timestamp ) {
+
+		this._previousTime = this._currentTime;
+		this._currentTime = ( timestamp !== undefined ? timestamp : now() ) - this._startTime;
+
+		this._delta = ( this._currentTime - this._previousTime ) * this._timescale;
+		this._elapsed += this._delta; // _elapsed is the accumulation of all previous deltas
+
+		return this;
+
+	}
+
+}
+
+class FixedTimer extends Timer {
+
+	constructor( fps = 60 ) {
+
+		super();
+		this._delta = ( 1 / fps ) * 1000;
+
+	}
+
+	update() {
+
+		this._elapsed += ( this._delta * this._timescale ); // _elapsed is the accumulation of all previous deltas
+
+		return this;
+
+	}
+
+}
+
+function now() {
+
+	return ( typeof performance === 'undefined' ? Date : performance ).now();
+
+}
+
+function handleVisibilityChange() {
+
+	if ( document.hidden === false ) this.reset();
+
+}
+
+export { Timer, FixedTimer };

package/examples/jsm/misc/TubePainter.js

@@ -176,16 +176,13 @@ function TubePainter() {
 
 		if ( start === end ) return;
 
-		positions.updateRange.offset = start * 3;
-		positions.updateRange.count = ( end - start ) * 3;
+		positions.addUpdateRange( start * 3, ( end - start ) * 3 );
 		positions.needsUpdate = true;
 
-		normals.updateRange.offset = start * 3;
-		normals.updateRange.count = ( end - start ) * 3;
+		normals.addUpdateRange( start * 3, ( end - start ) * 3 );
 		normals.needsUpdate = true;
 
-		colors.updateRange.offset = start * 3;
-		colors.updateRange.count = ( end - start ) * 3;
+		colors.addUpdateRange( start * 3, ( end - start ) * 3 );
 		colors.needsUpdate = true;
 
 		count = geometry.drawRange.count;

package/examples/jsm/modifiers/CurveModifier.js

@@ -214,8 +214,26 @@ export class Flow {
 				child instanceof InstancedMesh
 			) {
 
-				child.material = child.material.clone();
-				modifyShader( child.material, uniforms, numberOfCurves );
+				if ( Array.isArray( child.material ) ) {
+
+					const materials = [];
+
+					for ( const material of child.material ) {
+
+						const newMaterial = material.clone();
+						modifyShader( newMaterial, uniforms, numberOfCurves );
+						materials.push( newMaterial );
+
+					}
+
+					child.material = materials;
+
+				} else {
+
+					child.material = child.material.clone();
+					modifyShader( child.material, uniforms, numberOfCurves );
+
+				}
 
 			}