tsl-textures 2.5.1 → 3.0.1

package/src/roman-paving.js

@@ -3,14 +3,15 @@
 
 
 
-import { exp, mx_worley_noise_vec2, positionGeometry } from 'three/tsl';
-import { prepare, TSLFn } from './tsl-utils.js';
+import { exp, Fn, positionGeometry } from 'three/tsl';
+import { voronoi2 } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Roman paving',
 
+	position: positionGeometry,
 	scale: 2,
 	depth: 0.5,
 
@@ -19,17 +20,38 @@ var defaults = {
 
 
 
-var romanPaving = TSLFn( ( params )=>{
+var romanPavingRaw = Fn( ([ position, scale, depth, seed ])=>{
 
-	params = prepare( params, defaults );
+	var pos = position.mul( exp( scale ) ).add( seed ).toVar( );
 
-	var pos = positionGeometry.mul( exp( params.scale ) ).add( params.seed ).toVar( );
+	var k = voronoi2( pos ).toVar();
 
-	var k = mx_worley_noise_vec2( pos ).toVar();
+	return k.y.sub( k.x ).pow( depth.mul( 3 ).sub( 3 ).exp() ).smoothstep( 0, 1 );
 
-	return k.y.sub( k.x ).pow( params.depth.mul( 3 ).sub( 3 ).exp() ).smoothstep( 0, 1 );
+} ).setLayout( {
+	name: 'romanPavingRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'depth', type: 'float' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
 
-}, defaults );
+
+
+function romanPaving( params={} ) {
+
+	var { position, scale, depth, seed } = { ...defaults, ...params };
+
+	return romanPavingRaw( position, scale, depth, seed );
+
+}
+
+
+
+romanPaving.defaults = defaults;
 
 
 

package/src/rotator.js

@@ -4,8 +4,8 @@
 
 
 import { Vector2, Vector3 } from "three";
-import { cross, Fn, normalLocal, positionGeometry, sub, tangentLocal, transformNormalToView, vec4 } from 'three/tsl';
-import { matRotYXZ, matTrans, prepare, selectPlanar, TSLFn } from './tsl-utils.js';
+import { cross, Fn, normalLocal, positionGeometry, tangentLocal } from 'three/tsl';
+import { approximateNormal, rotatePivot, selectPlanar, } from './tsl-utils.js';
 
 
 
@@ -14,7 +14,7 @@ var defaults = {
 	$positionNode: true,
 	$selectorPlanar: true,
 
-	angles: new Vector3( 0.4, -0.6, 0 ),
+	angles: new Vector3( -0.2, 0.7, 0 ),
 	center: new Vector3( 0, 0, 0 ),
 
 	selectorCenter: new Vector3( 0, 0, 0 ),
@@ -25,51 +25,95 @@ var defaults = {
 
 
 
-var surfacePos = Fn( ([ pos, params ])=>{
+var surfacePos = Fn( ([ pos, angles, center, selectorAngles, selectorCenter, selectorWidth ])=>{
 
-	var zone = selectPlanar( pos, params.selectorAngles, params.selectorCenter, params.selectorWidth );
+	var zone = selectPlanar( pos, selectorAngles, selectorCenter, selectorWidth );
 
-	var R = matRotYXZ( params.angles.mul( zone ) ),
-		T = matTrans( params.center ),
-		TN = matTrans( params.center.negate() );
+	return rotatePivot( pos, center, angles.mul( zone ) );
 
-	return T.mul( R ).mul( TN ).mul( vec4( pos, 1 ) ).xyz;
+} ).setLayout( {
+	name: 'surfacePos',
+	type: 'vec3',
+	inputs: [
+		{ name: 'pos', type: 'vec3' },
+		{ name: 'angles', type: 'vec3' },
+		{ name: 'center', type: 'vec3' },
+		{ name: 'selectorAngles', type: 'vec2' },
+		{ name: 'selectorCenter', type: 'vec3' },
+		{ name: 'selectorWidth', type: 'float' },
+	]
+} );
+
+
+
+var rotatorRaw = Fn( ([ angles, center, selectorAngles, selectorCenter, selectorWidth ])=>{
 
+	return surfacePos( positionGeometry, angles, center, selectorAngles, selectorCenter, selectorWidth );
+
+} ).setLayout( {
+	name: 'rotatorRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'angles', type: 'vec3' },
+		{ name: 'center', type: 'vec3' },
+		{ name: 'selectorAngles', type: 'vec2' },
+		{ name: 'selectorCenter', type: 'vec3' },
+		{ name: 'selectorWidth', type: 'float' },
+	]
 } );
 
 
 
-var rotator = TSLFn( ( params )=>{
+var rotatorNormalRaw = Fn( ([ angles, center, selectorAngles, selectorCenter, selectorWidth ]) => {
 
-	params = prepare( params, defaults );
+	const EPS = 0.01;
 
-	return surfacePos( positionGeometry, params );
+	var position = positionGeometry,
+		normal = normalLocal.normalize().toVar(),
+		tangent = tangentLocal.normalize().mul( EPS ).toVar(),
+		bitangent = cross( normal, tangent ).normalize().mul( EPS ).toVar();
+
+	var pos = surfacePos( position, angles, center, selectorAngles, selectorCenter, selectorWidth );
+	var posU = surfacePos( position.add( tangent ), angles, center, selectorAngles, selectorCenter, selectorWidth );
+	var posV = surfacePos( position.add( bitangent ), angles, center, selectorAngles, selectorCenter, selectorWidth );
+
+	return approximateNormal( pos, posU, posV );
+
+} ).setLayout( {
+	name: 'rotatorNormalRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'angles', type: 'vec3' },
+		{ name: 'center', type: 'vec3' },
+		{ name: 'selectorAngles', type: 'vec2' },
+		{ name: 'selectorCenter', type: 'vec3' },
+		{ name: 'selectorWidth', type: 'float' },
+	]
+} );
 
-}, defaults );
 
 
+function rotator( params={} ) {
 
-rotator.normal = TSLFn( ( params ) => {
+	var { angles, center, selectorAngles, selectorCenter, selectorWidth } = { ...defaults, ...params };
 
-	params = prepare( params, defaults );
+	return rotatorRaw( angles, center, selectorAngles, selectorCenter, selectorWidth );
 
-	var eps = 0.01;
+}
 
-	var position = positionGeometry,
-		normal = normalLocal.normalize().toVar(),
-		tangent = tangentLocal.normalize().mul( eps ).toVar(),
-		bitangent = cross( normal, tangent ).normalize().mul( eps ).toVar();
 
-	var pos = surfacePos( position, params );
-	var posU = surfacePos( position.add( tangent ), params );
-	var posV = surfacePos( position.add( bitangent ), params );
 
-	var dU = sub( posU, pos ),
-		dV = sub( posV, pos );
+rotator.normal = function ( params={} ) {
+
+	var { angles, center, selectorAngles, selectorCenter, selectorWidth } = { ...defaults, ...params };
+
+	return rotatorNormalRaw( angles, center, selectorAngles, selectorCenter, selectorWidth );
+
+};
+
 
-	return transformNormalToView( cross( dU, dV ).normalize() );
 
-}, defaults );
+rotator.defaults = defaults;
 
 
 

package/src/rough-clay.js

@@ -3,8 +3,8 @@
 
 
 
-import { cross, exp, Fn, mx_worley_noise_float, normalLocal, positionGeometry, sub, tangentLocal, transformNormalToView } from 'three/tsl';
-import { noise, prepare, TSLFn } from './tsl-utils.js';
+import { cross, exp, Fn, normalLocal, positionGeometry, tangentLocal } from 'three/tsl';
+import { approximateNormal, noise, voronoi } from './tsl-utils.js';
 
 
 
@@ -12,6 +12,7 @@ var defaults = {
 	$name: 'Rough clay',
 	$normalNode: true,
 
+	position: positionGeometry,
 	scale: 2,
 	bump: 0.5,
 	curvature: 0.2,
@@ -21,41 +22,68 @@ var defaults = {
 
 
 
-var surfacePos = Fn( ([ pos, normal, bump, curvature ]) => {
+var surfacePos = Fn( ([ pos, normal, curvature ]) => {
 
-	var k1 = mx_worley_noise_float( pos.add( noise( pos ).mul( curvature ) ) ).add( 0.8 ).pow( 5 ).toVar();
+	var k1 = voronoi( pos.add( noise( pos ).mul( curvature ) ) ).add( 0.8 ).pow( 5 ).toVar();
 	k1.addAssign( k1.pow( 0.5 ) );
-	//k1.addAssign( noise(pos.mul(noiseScale.add(8))).add(1).pow(2).mul(noiseBump) );
-	return pos.add( normal.mul( k1 ).mul( bump ) );
+	return pos.add( normal.mul( k1 ) );
 
-} );
+} ).setLayout( {
+	name: 'surfacePos',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'normal', type: 'vec3' },
+		{ name: 'curvature', type: 'float' },
+	] }
+);
 
 
 
-var roughClay = TSLFn( ( params ) => {
+var roughClayRaw = Fn( ([ position, normal, tangent, scale, bump, curvature, seed ]) => {
 
-	params = prepare( params, defaults );
+	const EPS = 0.001;
 
-	var eps = 0.001;
+	var xposition = position.mul( exp( scale.div( 2 ) ) ).add( seed.sin().mul( 10 ) ).toVar( ),
+		xnormal = normal.normalize().toVar(),
+		xtangent = tangent.normalize().mul( EPS ).toVar(),
+		xbitangent = cross( xnormal, xtangent ).normalize().mul( EPS ).toVar();
 
-	var bump = params.bump.div( 50 ).toVar();
+	xnormal.mulAssign( bump, 1/50 );
 
-	var position = positionGeometry.mul( exp( params.scale.div( 2 ) ) ).add( params.seed.sin().mul( 10 ) ).toVar( ),
-		normal = normalLocal.normalize().toVar(),
-		tangent = tangentLocal.normalize().mul( eps ).toVar(),
-		bitangent = cross( normal, tangent ).normalize().mul( eps ).toVar();
+	var pos = surfacePos( xposition, xnormal, curvature );
+	var posU = surfacePos( xposition.add( xtangent ), xnormal, curvature );
+	var posV = surfacePos( xposition.add( xbitangent ), xnormal, curvature );
 
-	var pos = surfacePos( position, normal, bump, params.curvature );
-	var posU = surfacePos( position.add( tangent ), normal, bump, params.curvature );
-	var posV = surfacePos( position.add( bitangent ), normal, bump, params.curvature );
+	return approximateNormal( pos, posU, posV );
 
-	var dU = sub( posU, pos ),
-		dV = sub( posV, pos );
+} ).setLayout( {
+	name: 'concreteRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'normal', type: 'vec3' },
+		{ name: 'tangent', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'bump', type: 'float' },
+		{ name: 'curvature', type: 'float' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
 
-	return transformNormalToView( cross( dU, dV ).normalize() );
 
 
-}, defaults );
+function roughClay( params={} ) {
+
+	var { position, scale, bump, curvature, seed } = { ...defaults, ...params };
+
+	return roughClayRaw( position, normalLocal, tangentLocal, scale, bump, curvature, seed );
+
+}
+
+
+
+roughClay.defaults = defaults;
 
 
 

package/src/runny-eggs.js

@@ -4,14 +4,15 @@
 
 
 import { Color } from 'three';
-import { cross, exp, Fn, mix, mx_worley_noise_float, normalLocal, positionGeometry, sub, tangentLocal, transformNormalToView } from 'three/tsl';
-import { prepare, TSLFn } from './tsl-utils.js';
+import { cross, exp, Fn, mix, normalLocal, positionGeometry, tangentLocal } from 'three/tsl';
+import { approximateNormal, voronoi } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Runny eggs',
 
+	position: positionGeometry,
 	scale: 1,
 
 	sizeYolk: 0.2,
@@ -26,78 +27,153 @@ var defaults = {
 
 
 
-var runnyEggs = TSLFn( ( params ) => {
+var surfacePos = Fn( ([ pos, normal, sizeYolk, sizeWhite ]) => {
 
-	params = prepare( params, defaults );
+	var n = voronoi( pos ).toVar();
+	var whites = n.add( sizeWhite ).pow( 8 ).oneMinus();
+	var yolks = n.add( sizeYolk ).pow( 18 ).oneMinus().clamp( 0, 1 );
 
-	var pos = positionGeometry.mul( exp( params.scale.div( 1 ) ) ).add( params.seed.sin().mul( 10 ) ).toVar( );
+	var k = mix( 0, mix( 0, 1, yolks ), whites );
 
-	var sizeYolk = params.sizeYolk.oneMinus();
-	var sizeWhite = params.sizeWhite.oneMinus();
+	return pos.add( normal.mul( k ) );
 
-	var n = mx_worley_noise_float( pos ).toVar();
-	var whites = n.add( sizeWhite ).pow( 8 ).oneMinus().clamp( -0.5, 1 );
-	var yolks = n.add( sizeYolk ).pow( 18 ).oneMinus().clamp( 0, 1 ).pow( 0.4 ).clamp( 0, 1 );
+} ).setLayout( {
+	name: 'surfacePos',
+	type: 'vec3',
+	inputs: [
+		{ name: 'pos', type: 'vec3' },
+		{ name: 'normal', type: 'vec3' },
+		{ name: 'sizeYolk', type: 'float' },
+		{ name: 'sizeWhite', type: 'float' },
+	] }
+);
 
-	return mix( params.colorBackground, mix( params.colorWhite, params.colorYolk, yolks ), whites );
 
-}, defaults );
 
+var runnyEggsRaw = Fn( ([ position, scale, sizeYolk, sizeWhite, colorYolk, colorWhite, colorBackground, seed ]) => {
 
-var surfacePos = Fn( ([ pos, normal, bump, sizeYolk, sizeWhite ]) => {
+	var pos = position.mul( exp( scale ) ).add( seed.sin().mul( 10 ) ).toVar( );
 
-	var n = mx_worley_noise_float( pos ).toVar();
-	var whites = n.add( sizeWhite ).pow( 8 ).oneMinus();
-	var yolks = n.add( sizeYolk ).pow( 18 ).oneMinus().clamp( 0, 1 );
+	var n = voronoi( pos ).toVar();
+	var whites = n.add( sizeWhite.oneMinus() ).pow( 8 ).oneMinus().clamp( -0.5, 1 );
+	var yolks = n.add( sizeYolk.oneMinus() ).pow( 18 ).oneMinus().clamp( 0, 1 ).pow( 0.4 ).clamp( 0, 1 );
 
-	var k = mix( 0, mix( 0, 1, yolks ), whites );
+	return mix( colorBackground, mix( colorWhite, colorYolk, yolks ), whites );
 
-	return pos.add( normal.mul( k ).mul( bump ) );
+} ).setLayout( {
+	name: 'runnyEggsRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'pos', type: 'vec3' },
+		{ name: 'normal', type: 'vec3' },
+		{ name: 'sizeYolk', type: 'float' },
+		{ name: 'sizeWhite', type: 'float' },
+		{ name: 'colorYolk', type: 'vec3' },
+		{ name: 'colorWhite', type: 'vec3' },
+		{ name: 'colorBackground', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
 
-} );
 
 
-runnyEggs.normal = TSLFn( ( params ) => {
+var runnyEggsNormalRaw = Fn( ([ position, normal, tangent, scale, sizeYolk, sizeWhite, /*colorYolk, colorWhite, colorBackground,*/ seed ]) => {
 
-	params = prepare( params, defaults );
+	const EPS = 0.001;
+	const BUMP = 0.05;
 
-	var eps = 0.001;
-	var bump = 0.05;
+	var xposition = position.mul( exp( scale ) ).add( seed.sin().mul( 10 ) ).toVar( ),
+		xnormal = normal.normalize().toVar(),
+		xtangent = tangent.normalize().mul( EPS ).toVar(),
+		bitangent = cross( xnormal, xtangent ).normalize().mul( EPS ).toVar();
 
-	var position = positionGeometry.mul( exp( params.scale.div( 1 ) ) ).add( params.seed.sin().mul( 10 ) ).toVar( ),
-		normal = normalLocal.normalize().toVar(),
-		tangent = tangentLocal.normalize().mul( eps ).toVar(),
-		bitangent = cross( normal, tangent ).normalize().mul( eps ).toVar();
+	var xSizeYolk = sizeYolk.oneMinus();
+	var xSizeWhite = sizeWhite.oneMinus();
 
-	var sizeYolk = params.sizeYolk.oneMinus();
-	var sizeWhite = params.sizeWhite.oneMinus();
+	xnormal.mulAssign( BUMP );
 
-	var pos = surfacePos( position, normal, bump, sizeYolk, sizeWhite );
-	var posU = surfacePos( position.add( tangent ), normal, bump, sizeYolk, sizeWhite );
-	var posV = surfacePos( position.add( bitangent ), normal, bump, sizeYolk, sizeWhite );
+	var pos = surfacePos( xposition, xnormal, xSizeYolk, xSizeWhite );
+	var posU = surfacePos( xposition.add( xtangent ), xnormal, xSizeYolk, xSizeWhite );
+	var posV = surfacePos( xposition.add( bitangent ), xnormal, xSizeYolk, xSizeWhite );
 
-	var dU = sub( posU, pos ),
-		dV = sub( posV, pos );
+	return approximateNormal( pos, posU, posV );
 
-	return transformNormalToView( cross( dU, dV ).normalize() );
+} ).setLayout( {
+	name: 'runnyEggsNormalRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'normal', type: 'vec3' },
+		{ name: 'tangent', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'sizeYolk', type: 'float' },
+		{ name: 'sizeWhite', type: 'float' },
+		/*{ name: 'colorYolk', type: 'vec3' },*/
+		/*{ name: 'colorWhite', type: 'vec3' },*/
+		/*{ name: 'colorBackground', type: 'vec3' },*/
+		{ name: 'seed', type: 'float' },
+	] }
+);
 
-}, defaults );
 
 
-runnyEggs.roughness = TSLFn( ( params ) => {
+var runnyEggsRoughnessRaw = Fn( ([ position, scale, sizeYolk, /*sizeWhite, colorYolk, colorWhite, colorBackground,*/ seed ]) => {
 
-	params = prepare( params, defaults );
+	var pos = position.mul( exp( scale ) ).add( seed.sin().mul( 10 ) ).toVar( );
 
-	var pos = positionGeometry.mul( exp( params.scale.div( 1 ) ) ).add( params.seed.sin().mul( 10 ) ).toVar( );
+	var n = voronoi( pos ).toVar();
+	var yolks = n.add( sizeYolk.oneMinus() ).pow( 18 ).clamp( 0, 1 );
 
-	var sizeYolk = params.sizeYolk.oneMinus();
+	return yolks;
+
+} ).setLayout( {
+	name: 'runnyEggsRoughnessRaw',
+	type: 'float',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'sizeYolk', type: 'float' },
+		/*{ name: 'sizeWhite', type: 'float' },*/
+		/*{ name: 'colorYolk', type: 'vec3' },*/
+		/*{ name: 'colorWhite', type: 'vec3' },*/
+		/*{ name: 'colorBackground', type: 'vec3' },*/
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function runnyEggs( params={} ) {
+
+	var { position, scale, sizeYolk, sizeWhite, colorYolk, colorWhite, colorBackground, seed } = { ...defaults, ...params };
+
+	return runnyEggsRaw( position, scale, sizeYolk, sizeWhite, colorYolk, colorWhite, colorBackground, seed );
+
+}
+
+
+
+runnyEggs.normal = function ( params={} ) {
+
+	var { position, scale, sizeYolk, sizeWhite, /*colorYolk, colorWhite, colorBackground,*/ seed } = { ...defaults, ...params };
+
+	return runnyEggsNormalRaw( position, normalLocal, tangentLocal, scale, sizeYolk, sizeWhite, /*colorYolk, colorWhite, colorBackground,*/ seed );
+
+};
+
+
+
+runnyEggs.roughness = function ( params={} ) {
+
+	var { position, scale, sizeYolk, /*sizeWhite, colorYolk, colorWhite, colorBackground,*/ seed } = { ...defaults, ...params };
+
+	return runnyEggsRoughnessRaw( position, scale, sizeYolk, /*sizeWhite, colorYolk, colorWhite, colorBackground,*/ seed );
+
+};
 
-	var n = mx_worley_noise_float( pos ).toVar();
-	var yolks = n.add( sizeYolk ).pow( 18 ).clamp( 0, 1 );
 
-	return yolks;
 
-}, defaults );
+runnyEggs.defaults = defaults;
 
 
 

package/src/rust.js

@@ -5,13 +5,14 @@
 
 import { Color } from 'three';
 import { exp, Fn, Loop, mix, positionGeometry } from 'three/tsl';
-import { noise, prepare, TSLFn } from './tsl-utils.js';
+import { noise } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'rust',
 
+	position: positionGeometry,
 	scale: 2,
 	iterations: 8,
 	amount: -0.3,
@@ -27,15 +28,15 @@ var defaults = {
 
 
 
-var _rust = Fn( ( params )=>{
+var _rust = Fn( ([ position, scale, iterations, amount, seed ])=>{
 
-	var pos = positionGeometry.mul( exp( params.scale.div( 4 ).add( -1 ) ) ).add( params.seed ).toVar( );
+	var pos = position.mul( exp( scale.div( 4 ).add( -1 ) ) ).add( seed ).toVar( );
 
-	var amount = params.amount.mul( noise( pos.mul( params.amount.div( 2 ).add( 4 ) ) ).add( 4 ) ).toVar();
+	var xamount = amount.mul( noise( pos.mul( amount.div( 2 ).add( 4 ) ) ).add( 4 ) ).toVar();
 
 	var k = noise( pos ).toVar();
 
-	Loop( params.iterations, ()=>{
+	Loop( iterations, ()=>{
 
 		pos.mulAssign( 2 );
 		k.addAssign( noise( pos ) );
@@ -44,38 +45,99 @@ var _rust = Fn( ( params )=>{
 
 	k.subAssign( noise( pos.mul( 2 ) ).abs() );
 
-	k.assign( k.sub( amount ).clamp( 0, 15 ) );
+	k.assign( k.sub( xamount ).clamp( 0, 15 ) );
 
 	return k;
 
-} );
+} ).setLayout( {
+	name: '_rust',
+	type: 'float',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'iterations', type: 'int' },
+		{ name: 'amount', type: 'float' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
 
 
-var rust = TSLFn( ( params )=>{
+var rustRaw = Fn( ([ position, scale, iterations, amount, /*opacity,*/xnoise, noiseScale, color, background, seed ])=>{
 
-	params = prepare( params, defaults );
+	var k = _rust( position, scale, iterations, amount, seed ).mul( 1.25 ).pow( 0.5 );
 
-	var k = _rust( params ).mul( 1.25 ).pow( 0.5 );
+	var pos = position.mul( exp( scale.add( noiseScale.mul( 3 ), 2 ) ) );
 
-	var pos = positionGeometry.mul( exp( params.scale.add( params.noiseScale.mul( 3 ), 2 ) ) );
+	k.addAssign( xnoise.mul( noise( pos ).abs().add( 0.1 ).pow( 2 ) ) );
 
-	k.addAssign( params.noise.mul( noise( pos ).abs().add( 0.1 ).pow( 2 ) ) );
+	return mix( color, background, k );
 
-	return mix( params.color, params.background, k );
+} ).setLayout( {
+	name: 'rustRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'iterations', type: 'int' },
+		{ name: 'amount', type: 'float' },
+		/*{ name: 'opacity', type: 'float' },*/
+		{ name: 'xnoise', type: 'float' },
+		{ name: 'noiseScale', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
 
-}, defaults );
 
 
 
-rust.opacity = TSLFn( ( params )=>{
+var rustOpacityRaw = Fn( ([ position, scale, iterations, amount, opacity, /*xnoise, noiseScale, color, background,*/ seed ])=>{
 
-	params = prepare( params, defaults );
-
-	var k = _rust( params ).mul( params.opacity.add( 0.2 ) );
+	var k = _rust( position, scale, iterations, amount, seed ).mul( opacity.add( 0.2 ) );
 
 	return k.oneMinus();
 
-}, defaults );
+} ).setLayout( {
+	name: 'rustOpacityRaw',
+	type: 'float',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'iterations', type: 'int' },
+		{ name: 'amount', type: 'float' },
+		{ name: 'opacity', type: 'float' },
+		/*{ name: 'xnoise', type: 'float' },*/
+		/*{ name: 'noiseScale', type: 'float' },*/
+		/*{ name: 'color', type: 'vec3' },*/
+		/*{ name: 'background', type: 'vec3' },*/
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function rust( params={} ) {
+
+	var { position, scale, iterations, amount, /*opacity,*/ noise, noiseScale, color, background, seed } = { ...defaults, ...params };
+
+	return rustRaw( position, scale, iterations, amount, /*opacity,*/noise, noiseScale, color, background, seed );
+
+}
+
+
+
+rust.opacity = function ( params={} ) {
+
+	var { position, scale, iterations, amount, opacity, /*xnoise, noiseScale, color, background,*/ seed } = { ...defaults, ...params };
+
+	return rustOpacityRaw( position, scale, iterations, amount, opacity, /*xnoise, noiseScale, color, background,*/ seed );
+
+};
+
+
+
+rust.defaults = defaults;