tsl-textures 2.5.1 → 3.0.1

package/src/turbulent-smoke.js

@@ -3,8 +3,8 @@
 
 
 
-import { exp, mx_fractal_noise_float, mx_fractal_noise_vec3, mx_worley_noise_float, positionGeometry, time, vec3 } from 'three/tsl';
-import { prepare, TSLFn } from './tsl-utils.js';
+import { exp, Fn, positionGeometry, time, vec3 } from 'three/tsl';
+import { fractal, fractal3, voronoi } from './tsl-utils.js';
 
 
 
@@ -12,36 +12,61 @@ var defaults = {
 	$name: 'Turbulent smoke',
 	$width: 260,
 
+	position: positionGeometry,
 	scale: 2,
 	speed: 0,
 	details: 5,
+	time: time,
 
 	seed: 0,
 };
 
 
 
-var turbulentSmoke = TSLFn( ( params )=>{
+var turbulentSmokeRaw = Fn( ([ position, scale, speed, details, time, seed ])=>{
 
-	params = prepare( params, defaults );
+	var pos = position.mul( exp( scale.sub( 1 ) ) ).add( seed ).toVar( );
 
-	var pos = positionGeometry.mul( exp( params.scale.sub( 1 ) ) ).add( params.seed ).toVar( );
-
-	var t = time.mul( params.speed.sub( 1 ).exp() );
+	var t = time.mul( speed.sub( 1 ).exp() );
 
 	var q = pos.add( vec3(
-		mx_fractal_noise_float( pos.add( vec3( 1, t.sin(), -1 ) ) ),
-		mx_fractal_noise_float( pos.add( vec3( t.add( 2*Math.PI/3 ).sin(), 1, -1 ) ) ),
-		mx_fractal_noise_float( pos.add( vec3( 1, -1, t.add( 4*Math.PI/3 ).sin() ) ) ),
+		fractal( pos.add( vec3( 1, t.sin(), -1 ) ) ),
+		fractal( pos.add( vec3( t.add( 2*Math.PI/3 ).sin(), 1, -1 ) ) ),
+		fractal( pos.add( vec3( 1, -1, t.add( 4*Math.PI/3 ).sin() ) ) ),
 	) );
 
-	var p = mx_fractal_noise_vec3( q, params.details );
+	var p = fractal3( q, details );
 
-	var k = mx_worley_noise_float( pos.add( p.div( 2 ) ) ).pow( 4 ).mul( 4 ).oneMinus();
+	var k = voronoi( pos.add( p.div( 2 ) ) ).pow( 4 ).mul( 4 ).oneMinus();
 
 	return k;
 
-}, defaults );
+} ).setLayout( {
+	name: 'turbulentSmokeRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'speed', type: 'float' },
+		{ name: 'details', type: 'int' },
+		{ name: 'time', type: 'float' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function turbulentSmoke( params={} ) {
+
+	var { position, scale, speed, details, time, seed } = { ...defaults, ...params };
+
+	return turbulentSmokeRaw( position, scale, speed, details, time, seed );
+
+}
+
+
+
+turbulentSmoke.defaults = defaults;
 
 
 

package/src/voronoi-cells.js

@@ -4,14 +4,15 @@
 
 
 import { Color } from 'three';
-import { exp, float, Fn, If, Loop, mix, positionGeometry, vec3 } from 'three/tsl';
-import { noise, prepare, TSLFn } from './tsl-utils.js';
+import { exp, float, Fn, If, int, Loop, mix, positionGeometry, vec3 } from 'three/tsl';
+import { noise, vnoise } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Voronoi cells',
 
+	position: positionGeometry,
 	scale: 2,
 	variation: 0,
 	facet: 0,
@@ -24,18 +25,9 @@ var defaults = {
 
 
 
-var cellCenter = Fn( ([ cell ])=>{
+var voronoiCellsRaw = Fn( ([ position, scale, variation, facet, color, background, seed ])=>{
 
-	return cell.add( noise( cell.mul( Math.PI ) ) );
-
-} );
-
-
-var voronoiCells = TSLFn( ( params )=>{
-
-	params = prepare( params, defaults );
-
-	var pos = positionGeometry.mul( exp( params.scale.div( 2 ).add( 0.5 ) ) ).add( params.seed ).toVar( );
+	var pos = position.mul( exp( scale.div( 2 ).add( 0.5 ) ) ).add( seed ).toVar( );
 
 	var midCell = pos.round().toVar();
 
@@ -45,15 +37,17 @@ var voronoiCells = TSLFn( ( params )=>{
 	var cell = vec3().toVar();
 	var dist = float().toVar();
 
-	var i = float( 0 ).toVar();
+	var i=int( 0 ).toVar( 'i' ),
+		j=int( 0 ).toVar( 'j' ),
+		k=int( 0 ).toVar( 'k' );
 
-	Loop( 27, () => {
+	// Loop uses hard-coded i, j, k as indices
+	Loop( 3, 3, 3, () => {
 
-		var ix = i.mod( 3 ).sub( 1 );
-		var iy = i.div( 3 ).floor().mod( 3 ).sub( 1 );
-		var iz = i.div( 9 ).floor().sub( 1 );
-		cell.assign( midCell.add( vec3( ix, iy, iz ) ) );
-		dist.assign( pos.distance( cellCenter( cell ) ).add( noise( pos ).div( 5 ) ) );
+		cell.assign( midCell.add( vec3( i, j, k ).sub( 1 ) ) );
+		//var cellCenter = cell.add( noise( cell.mul( Math.PI ) ) ); // too slow on WebGL2
+		var cellCenter = cell.add( vnoise( cell.mul( Math.PI*2 ) ).div( 2 ) );
+		dist.assign( pos.distance( cellCenter ) );
 
 		If( dist.lessThan( minDist ), ()=>{
 
@@ -61,20 +55,44 @@ var voronoiCells = TSLFn( ( params )=>{
 			minCell.assign( cell );
 
 		} );
-		i.addAssign( 1 );
 
 	} );
 
-
 	var n = noise( minCell.mul( Math.PI ) ).toVar();
-	var k = mix( minDist, n.add( 1 ).div( 2 ), params.facet );
+	var m = mix( minDist, n.add( 1 ).div( 2 ), facet );
 
-	var color = mix( params.color, params.background, k ).toVar();
+	var color = mix( color, background, m ).toVar();
 	var randomColor = vec3( n.mul( 16.8 ), n.mul( 31.4159 ), n.mul( 27.1828 ) ).sin().add( 1 ).div( 2 );
 
-	return mix( color, mix( color, randomColor, params.variation ), params.variation );
+	return mix( color, mix( color, randomColor, variation ), variation );
+
+} ).setLayout( {
+	name: 'voronoiCellsRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'variation', type: 'float' },
+		{ name: 'facet', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function voronoiCells( params={} ) {
+
+	var { position, scale, variation, facet, color, background, seed } = { ...defaults, ...params };
+
+	return voronoiCellsRaw( position, scale, variation, facet, color, background, seed );
+
+}
+
+
 
-}, defaults );
+voronoiCells.defaults = defaults;
 
 
 

package/src/water-drops.js

@@ -3,8 +3,8 @@
 
 
 
-import { cos, cross, exp, Fn, normalLocal, positionGeometry, remap, sin, sub, tangentLocal, transformNormalToView, vec3 } from 'three/tsl';
-import { noise, prepare, TSLFn } from './tsl-utils.js';
+import { cos, cross, exp, Fn, normalLocal, positionGeometry, remap, tangentLocal, vec3 } from 'three/tsl';
+import { approximateNormal, noise } from './tsl-utils.js';
 
 
 
@@ -12,6 +12,8 @@ var defaults = {
 	$name: 'Water Drops',
 	$normalNode: true,
 
+	position: positionGeometry,
+
 	scale: 1.4,
 	density: 0.5,
 	bump: 0.6,
@@ -21,42 +23,73 @@ var defaults = {
 
 
 
-var surfacePos = Fn( ([ pos, normal, bump, density, seed ]) => {
+var surfacePos = Fn( ([ pos, normal, density ]) => {
 
-	var k = noise( pos.add( seed ) ).add( density ).clamp( 0, 1 );
+	var k = noise( pos, 1, density ).clamp( 0, 1 );
 	k = cos( k.mul( Math.PI ) ).add( 1 ).pow( 0.5 ).toVar();
 
-	return pos.add( k.mul( normal, bump ) );
+	return pos.add( normal.mul( k ) );
+
+} ).setLayout( {
+	name: 'surfacePos',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'normal', type: 'vec3' },
+		{ name: 'density', type: 'float' },
+	] }
+);
+
+
+
+var waterDropsRaw = Fn( ([ position, normal, tangent, scale, density, bump, seed ]) => {
+
+	var EPS = 0.001;
+
+	var seed3d = vec3( 1, 2, 3 ).mul( seed ).sin().mul( 100 ).toVar( );
+
+	var xposition = position.mul( exp( scale.div( 1 ).add( 1 ) ) ).add( seed3d ).toVar( ),
+		xnormal = normal.normalize().toVar(),
+		xtangent = tangent.normalize().mul( EPS ).toVar(),
+		xbitangent = cross( xnormal, xtangent ).normalize().mul( EPS ).toVar();
+
+	var xdensity = remap( density, 0, 1, 1.5, 0.7 ).toVar();
 
-} );
+	xnormal.mulAssign( bump );
 
+	var pos = surfacePos( xposition, xnormal, xdensity ),
+		posU = surfacePos( xposition.add( xtangent ), xnormal, xdensity ),
+		posV = surfacePos( xposition.add( xbitangent ), xnormal, xdensity );
 
+	return approximateNormal( pos, posU, posV );
 
-var waterDrops = TSLFn( ( params ) => {
+} ).setLayout( {
+	name: 'waterDropsRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'normal', type: 'vec3' },
+		{ name: 'tangent', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'density', type: 'float' },
+		{ name: 'bump', type: 'float' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
 
-	params = prepare( params, defaults );
 
-	var eps = 0.001;
 
-	var position = positionGeometry.mul( exp( params.scale.div( 1 ).add( 1 ) ) ).toVar( ),
-		normal = normalLocal.normalize().toVar(),
-		tangent = tangentLocal.normalize().mul( eps ).toVar(),
-		bitangent = cross( normal, tangent ).normalize().mul( eps ).toVar();
+function waterDrops( params={} ) {
 
-	var density = remap( params.density, 0, 1, 1.5, 0.7 ).toVar();
-	var seed = vec3( sin( params.seed ).mul( 100 ), cos( params.seed.div( 2 ) ).mul( 100 ), sin( params.seed.div( 3 ) ).mul( 100 ) ).toVar();
+	var { position, scale, density, bump, seed } = { ...defaults, ...params };
 
-	var pos = surfacePos( position, normal, params.bump, density, seed );
+	return waterDropsRaw( position, normalLocal, tangentLocal, scale, density, bump, seed );
 
-	var posU = surfacePos( position.add( tangent ), normal, params.bump, density, seed );
-	var posV = surfacePos( position.add( bitangent ), normal, params.bump, density, seed );
+}
 
-	var dU = sub( posU, pos ),
-		dV = sub( posV, pos );
 
-	return transformNormalToView( cross( dU, dV ).normalize() );
 
-}, defaults );
+waterDrops.defaults = defaults;
 
 
 

package/src/watermelon.js

@@ -4,13 +4,17 @@
 
 
 import { Color } from 'three';
-import { equirectUV, exp, mix, positionGeometry, screenUV, select, vec3 } from 'three/tsl';
-import { noise, prepare, TSLFn } from './tsl-utils.js';
+import { equirectUV, exp, Fn, mix, positionGeometry, screenUV, vec3 } from 'three/tsl';
+import { noise } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Watermelon',
+	$replaceExportUVS: screenUV,
+
+	position: positionGeometry,
+	uvs: equirectUV( positionGeometry.normalize() ),
 
 	scale: 2,
 	stripes: 12,
@@ -20,42 +24,63 @@ var defaults = {
 	color: new Color( 'yellowgreen' ),
 	background: new Color( 'darkgreen' ),
 
-	flat: 0,
-
 	seed: 0,
 };
 
 
 
-var watermelon = TSLFn( ( params )=>{
-
-	params = prepare( params, defaults );
-
-	var variation = select( params.flat, params.variation.mul( 0.85 ).add( 0.15 ), params.variation );
+var watermelonRaw = Fn( ([ position, uvs, scale, stripes, variation, xnoise, color, background, seed ])=>{
 
-	var pos = positionGeometry.mul( exp( params.scale.div( 4 ).add( 2 ) ) ).add( params.seed ).toVar( );
+	var pos = position.mul( exp( scale.div( 4 ).add( 2 ) ) ).add( seed ).toVar( );
 
-	var uv = select( params.flat, screenUV, equirectUV( positionGeometry.normalize() ) ).toVar(),
-		a = uv.x.mul( params.stripes.round(), select( params.flat, Math.PI, 2*Math.PI ) ).add( noise( pos.mul( vec3( 1, 0.3, 1 ) ) ).mul( 2 ) );
+	var a = uvs.x.mul( stripes, 2*Math.PI ).add( noise( pos.mul( vec3( 1, 0.3, 1 ) ) ).mul( 2 ) );
 
-	var k = a.sin().add( 0.5 ).div( 2 ).mul( uv.y.remap( 0, 1, -Math.PI, Math.PI ).cos().add( 1.2 ).clamp( 0, 1 ) )
+	var k = a.sin().add( 0.5 ).div( 2 ).mul( uvs.y.remap( 0, 1, -Math.PI, Math.PI ).cos().add( 1.2 ).clamp( 0, 1 ) )
 		.add( variation.mul( 2, noise( pos.mul( 1.5 ) ).div( 2 ) ) )
 		.add( variation.mul( 2, noise( pos.mul( 4 ) ).div( 6 ) ) )
 		.toVar();
 
 	k.assign(
 		k.mix( k.round(), 0.75 )
-			.add( noise( pos.mul( 2 ) ).mul( params.noise, 0.5 ) )
-			.add( noise( pos.mul( 3 ) ).mul( params.noise, 1 ) )
-			.add( noise( pos.mul( 15 ) ).mul( params.noise, 0.2 ) )
+			.add( noise( pos.mul( 2 ) ).mul( xnoise, 0.5 ) )
+			.add( noise( pos.mul( 3 ) ).mul( xnoise, 1 ) )
+			.add( noise( pos.mul( 15 ) ).mul( xnoise, 0.2 ) )
 			.clamp( 0, 1 )
 	);
 
-	var color = mix( params.background, params.color, k ).toVar();
+	var color = mix( background, color, k ).toVar();
 
 	return color;
 
-}, defaults );
+} ).setLayout( {
+	name: 'watermelonRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'uvs', type: 'vec2' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'stripes', type: 'int' },
+		{ name: 'variation', type: 'float' },
+		{ name: 'xnoise', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function watermelon( params={} ) {
+
+	var { position, uvs, scale, stripes, variation, noise, color, background, seed } = { ...defaults, ...params };
+
+	return watermelonRaw( position, uvs, scale, stripes, variation, noise, color, background, seed );
+
+}
+
+
+
+watermelon.defaults = defaults;
 
 
 

package/src/wood.js

@@ -4,51 +4,55 @@
 
 
 import { Color } from 'three';
-import { add, cos, exp, float, Loop, mix, mul, positionGeometry, radians, reciprocal, sin, sub, vec3 } from 'three/tsl';
-import { noise, prepare, TSLFn } from './tsl-utils.js';
+import { add, cos, exp, float, Fn, Loop, mix, mul, positionGeometry, radians, reciprocal, sin, sub, vec3 } from 'three/tsl';
+import { noise } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Wood',
+
+	position: positionGeometry,
 	scale: 2.5,
+
 	rings: 4.5,
 	lengths: 1,
 	angle: 0,
+
 	fibers: 0.3,
 	fibersDensity: 10,
+
 	color: new Color( 0.8, 0.4, 0 ),
 	background: new Color( 0.4, 0.1, 0 ),
+
 	seed: 0,
 };
 
 
 
-var wood = TSLFn( ( params ) => {
-
-	params = prepare( params, defaults );
+var woodRaw = Fn( ([ position, scale, rings, lengths, angle, fibers, fibersDensity, color, background, seed ]) => {
 
-	var angle = radians( params.angle ).toVar();
+	var angle = radians( angle ).toVar();
 	var posLocal = vec3(
-		sub( positionGeometry.x.mul( cos( angle ) ), positionGeometry.y.mul( sin( angle ) ) ),
-		add( positionGeometry.x.mul( sin( angle ) ), positionGeometry.y.mul( cos( angle ) ) ),
-		positionGeometry.z,
+		sub( position.x.mul( cos( angle ) ), position.y.mul( sin( angle ) ) ),
+		add( position.x.mul( sin( angle ) ), position.y.mul( cos( angle ) ) ),
+		position.z,
 	).toVar();
 
 
 	// main pattern with rings
-	var pos = posLocal.mul( exp( params.scale.sub( 3 ) ).mul( vec3( reciprocal( params.lengths ), 4, reciprocal( params.lengths ) ) ) ).add( params.seed ).toVar( );
-	var k = noise( pos ).add( 1 ).mul( 10 ).mul( params.rings );
+	var pos = posLocal.mul( exp( scale.sub( 3 ) ).mul( vec3( reciprocal( lengths ), 4, reciprocal( lengths ) ) ) ).add( seed ).toVar( );
+	var k = noise( pos ).add( 1 ).mul( 10 ).mul( rings );
 	k = k.add( k.cos() ).cos().add( 1 ).div( 2 );
 
 	var kk = float( 0 ).toVar(),
 		sum = float( 0 ).toVar(),
-		scale = exp( params.scale.sub( 2 ) ).mul( vec3( 1, params.fibersDensity, 1 ) ).toVar(),
+		scale = exp( scale.sub( 2 ) ).mul( vec3( 1, fibersDensity, 1 ) ).toVar(),
 		power = float( 2 ).toVar();
 
 	Loop( 10, ()=>{
 
-		kk.addAssign( mul( power, noise( posLocal.mul( scale ).add( params.seed ) ) ) );
+		kk.addAssign( mul( power, noise( posLocal.mul( scale ).add( seed ) ) ) );
 		sum.addAssign( power );
 		scale.mulAssign( 1.8 );
 		power.mulAssign( 0.6 );
@@ -57,9 +61,38 @@ var wood = TSLFn( ( params ) => {
 
 	kk.assign( mul( kk, 5 ).div( sum ).mul( 10 ).sin().add( 1 ).div( 2 ) );
 
-	return mix( params.color, params.background, mix( k, kk, params.fibers ) );
+	return mix( color, background, mix( k, kk, fibers ) );
+
+} ).setLayout( {
+	name: 'woodRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'rings', type: 'float' },
+		{ name: 'lengths', type: 'float' },
+		{ name: 'angle', type: 'float' },
+		{ name: 'fibers', type: 'float' },
+		{ name: 'fibersDensity', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function wood( params={} ) {
+
+	var { position, scale, rings, lengths, angle, fibers, fibersDensity, color, background, seed } = { ...defaults, ...params };
+
+	return woodRaw( position, scale, rings, lengths, angle, fibers, fibersDensity, color, background, seed );
+
+}
+
+
 
-}, defaults );
+wood.defaults = defaults;
 
 
 

package/src/zebra-lines.js

@@ -4,14 +4,15 @@
 
 
 import { Color } from "three";
-import { acos, clamp, cos, exp, mix, positionGeometry, select, sin, vec2 } from 'three/tsl';
-import { prepare, spherical, TSLFn } from './tsl-utils.js';
+import { acos, clamp, cos, exp, Fn, mix, positionGeometry, select, sin, vec2 } from 'three/tsl';
+import { spherical } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Zebra lines',
 
+	position: positionGeometry,
 	scale: 2,
 	thinness: 0.5,
 	phi: 0,
@@ -26,25 +27,50 @@ var defaults = {
 
 
 
-var zebraLines = TSLFn( ( params ) => {
+var zebraLinesRaw = Fn( ([ position, scale, thinness, phi, theta, color, background, xflat ]) => {
 
-	params = prepare( params, defaults );
+	var pos = select( xflat, position, position.normalize() ).toVar( );
 
-	var pos = select( params.flat, positionGeometry, positionGeometry.normalize() ).toVar( );
+	var dir = select( xflat, vec2( cos( phi ), sin( phi ) ), spherical( phi, theta ) ).toVar();
 
-	var dir = select( params.flat, vec2( cos( params.phi ), sin( params.phi ) ), spherical( params.phi, params.theta ) ).toVar();
+	var angle = select( xflat, clamp( dir.dot( pos ), -2, 2 ), acos( clamp( dir.dot( pos ), -1, 1 ) ) ).toVar();
 
-	var angle = select( params.flat, clamp( dir.dot( pos ), -2, 2 ), acos( clamp( dir.dot( pos ), -1, 1 ) ) ).toVar();
+	var scale = exp( scale.add( 1 ) ).toVar();
 
-	var scale = exp( params.scale.add( 1 ) ).toVar();
-
-	var k = sin( angle.mul( scale ) ).sub( params.thinness.sub( 0.5 ).mul( 2 ) );
+	var k = sin( angle.mul( scale ) ).sub( thinness.sub( 0.5 ).mul( 2 ) );
 
 	k = clamp( k.mul( 1000 ).div( scale ), -1, 1 ).mul( 0.5 ).add( 0.5 );
 
-	return mix( params.background, params.color, k );
+	return mix( background, color, k );
+
+} ).setLayout( {
+	name: 'zebraLinesRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'thinness', type: 'float' },
+		{ name: 'phi', type: 'float' },
+		{ name: 'theta', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'xflat', type: 'int' },
+	] }
+);
+
+
+
+function zebraLines( params={} ) {
+
+	var { position, scale, thinness, phi, theta, color, background, flat } = { ...defaults, ...params };
+
+	return zebraLinesRaw( position, scale, thinness, phi, theta, color, background, flat );
+
+}
+
+
 
-}, defaults );
+zebraLines.defaults = defaults;
 
 
 

package/src/simplex-noise.js

@@ -1,41 +0,0 @@
-
-//	TSL-Textures: Noise Pattern
-
-
-
-import { Color } from "three";
-import { clamp, exp, mix, positionGeometry } from 'three/tsl';
-import { noise, prepare, TSLFn } from './tsl-utils.js';
-
-
-
-var defaults = {
-	$name: 'Simplex noise',
-
-	scale: 2,
-	balance: 0,
-	contrast: 0,
-
-	color: new Color( 0xFFFFFF ),
-	background: new Color( 0x000000 ),
-
-	seed: 0,
-};
-
-
-
-var simplexNoise = TSLFn( ( params ) => {
-
-	params = prepare( params, defaults );
-
-	var pos = positionGeometry.mul( exp( params.scale ) ).add( params.seed );
-
-	var k = clamp( 0, 1, noise( pos ).mul( 0.5, exp( params.contrast ) ).add( 0.5, params.balance ) );
-
-	return mix( params.background, params.color, k );
-
-}, defaults );
-
-
-
-export { simplexNoise };