tsl-textures 2.5.1 → 3.0.1

package/src/cork.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, vnoise } 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: 'Cork',
 
+	position: positionGeometry,
 	scale: 1,
 	straight: 1,
 	noise: 0.3,
@@ -24,39 +25,32 @@ var defaults = {
 
 
 
-var cellCenter = Fn( ([ cell ])=>{
+var corkRaw = Fn( ([ position, scale, straight, xnoise, color, background, seed ])=>{
 
-	return cell.add( vnoise( cell ) );
+	var pos = position.mul( exp( scale.div( 1.5 ).add( 1 ) ) ).add( seed ).toVar( 'pos' );
 
-} );
+	var midCell = pos.round().toConst( 'midCell' );
 
+	var minCell = midCell.toVar( 'minCell' ),
+		minDist = float( 1 ).toVar( 'minDist' );
 
-var cork = TSLFn( ( params )=>{
+	var cell = vec3().toVar( 'cell' ),
+		dist = float().toVar( 'dist' );
 
-	params = prepare( params, defaults );
+	var strtaightness = straight.exp().reciprocal().toVar( 'strtaightness' );
 
-	var pos = positionGeometry.mul( exp( params.scale.div( 1.5 ).add( 1 ) ) ).add( params.seed ).toVar( );
+	var i=int( 0 ).toVar( 'i' ),
+		j=int( 0 ).toVar( 'j' ),
+		k=int( 0 ).toVar( 'k' );
 
-	var midCell = pos.round().toVar();
+	// Loop uses hard-coded i, j, k as indices
+	Loop( 3, 3, 3, () => {
 
-	var minCell = midCell.toVar();
-	var minDist = float( 1 ).toVar();
+		cell.assign( midCell.add( vec3( i, j, k ).sub( 1 ) ) );
+		var cellCenter = cell.add( vnoise( cell ) );
+		dist.assign( pos.distance( cellCenter ) );
 
-	var cell = vec3().toVar();
-	var dist = float().toVar();
-
-	var i = float( 0 ).toVar();
-
-
-	Loop( 27, () => {
-
-		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 ) ) );
-
-		dist.addAssign( noise( pos.add( cell ) ).div( params.straight.exp() ) );
+		dist.addAssign( noise( pos.add( cell ), strtaightness ) );
 
 		If( dist.lessThan( minDist ), ()=>{
 
@@ -64,21 +58,46 @@ var cork = TSLFn( ( params )=>{
 			minCell.assign( cell );
 
 		} );
-		i.addAssign( 1 );
 
 	} );
 
-	var n = noise( minCell.mul( Math.PI ) ).toVar();
-	var r = noise( pos.mul( 12 ) ).toVar();
-	r.assign( r.sign().mul( r.abs().pow3() ) );
-	r.addAssign( noise( pos.mul( 40 ) ).div( 3 ) );
-	var k = n.add( 1 ).div( 2 );
+	var n = noise( minCell.mul( Math.PI ), 0.5, 0.5 ).toVar( 'n' );
+
+	var r = noise( pos.mul( 12 ) ).toVar( 'r' );
+	r.mulAssign( r, r );
+	r.addAssign( noise( pos.mul( 40 ), 1/3 ) );
+
+	var result = mix( color, background, n.add( r.mul( xnoise ) ) );
+
+	return result;
+
+} ).setLayout( {
+	name: 'camouflageRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'straight', type: 'float' },
+		{ name: 'xnoise', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function cork( params={} ) {
+
+	var { position, scale, straight, noise, color, background, seed } = { ...defaults, ...params };
+
+	return corkRaw( position, scale, straight, noise, color, background, seed );
+
+}
 
-	var color = mix( params.color, params.background, k.add( r.mul( params.noise ) ) ).toVar();
 
-	return color;
 
-}, defaults );
+cork.defaults = defaults;
 
 
 

package/src/crumpled-fabric.js

@@ -4,8 +4,8 @@
 
 
 import { Color } from 'three';
-import { exp, Loop, positionGeometry, vec3 } from 'three/tsl';
-import { noise, prepare, TSLFn } from './tsl-utils.js';
+import { exp, Fn, Loop, positionGeometry, vec3 } from 'three/tsl';
+import { noise } from './tsl-utils.js';
 
 
 
@@ -13,6 +13,7 @@ var defaults = {
 	$name: 'Crumpled fabric',
 	$width: 260,
 
+	position: positionGeometry,
 	scale: 2,
 	pinch: 0.5,
 
@@ -25,31 +26,55 @@ var defaults = {
 
 
 
-var crumpledFabric = TSLFn( ( params )=>{
+var crumpledFabricRaw = Fn( ([ position, scale, pinch, color, subcolor, background, seed ])=>{
 
-	params = prepare( params, defaults );
-
-	var pos = positionGeometry.mul( exp( params.scale.sub( 0.5 ) ) ).add( params.seed ).toVar( );
+	var pos = position.mul( exp( scale.sub( 0.5 ) ) ).add( seed ).toVar( );
 
 	Loop( 4, ()=>{
 
-		var x = noise( pos.xyz ).mul( params.pinch );
-		var y = noise( pos.yzx ).mul( params.pinch );
-		var z = noise( pos.zxy ).mul( params.pinch );
+		var x = noise( pos.xyz );
+		var y = noise( pos.yzx );
+		var z = noise( pos.zxy );
 
-		pos.addAssign( vec3( x, y, z ) );
+		pos.addAssign( vec3( x, y, z ).mul( pinch ) );
 
 	} );
 
 	var k = noise( pos ).add( 1 ).div( 2 ).clamp( 0, 1 );
 
-	var color1 = params.color.mul( k.mul( 2 ).sub( 1 ).abs().oneMinus() );
-	var color2 = params.subcolor.mul( k ).pow( 2 );
-	var color3 = params.background.mul( k.oneMinus().pow( 2 ) );
+	var color1 = color.mul( k.mul( 2 ).sub( 1 ).abs().oneMinus() );
+	var color2 = subcolor.mul( k ).pow( 2 );
+	var color3 = background.mul( k.oneMinus().pow( 2 ) );
 
 	return color1.add( color2 ).add( color3 );
 
-}, defaults );
+} ).setLayout( {
+	name: 'crumpledFabricRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'pinch', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'subcolor', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function crumpledFabric( params={} ) {
+
+	var { position, scale, pinch, color, subcolor, background, seed } = { ...defaults, ...params };
+
+	return crumpledFabricRaw( position, scale, pinch, color, subcolor, background, seed );
+
+}
+
+
+
+crumpledFabric.defaults = defaults;
 
 
 

package/src/dalmatian-spots.js

@@ -1,11 +1,11 @@
 
-//	TSL-Textures: Dalmatian coat
+//	TSL-Textures: Dalmatian spots
 
 
 
 import { Color } from "three";
-import { exp, float, Loop, mix, positionGeometry } from 'three/tsl';
-import { noise, prepare, TSLFn } from './tsl-utils.js';
+import { float, Fn, Loop, mix, positionGeometry } from 'three/tsl';
+import { noise } from './tsl-utils.js';
 
 
 
@@ -13,6 +13,8 @@ var defaults = {
 	$name: 'Dalmatian spots',
 	$width: 260,
 
+	position: positionGeometry,
+
 	scale: 2,
 	density: 0.6,
 
@@ -24,16 +26,14 @@ var defaults = {
 
 
 
-var dalmatianSpots = TSLFn( ( params )=>{
-
-	params = prepare( params, defaults );
+var dalmatianSpotsRaw = Fn( ([ position, scale, density, color, background, seed ])=>{
 
-	var pos = positionGeometry.mul( exp( params.scale ) ).add( params.seed ).sub( 1000 ).toVar( );
+	var pos = position.mul( scale.exp( ) ).add( seed ).sub( 1000 ).toVar( 'pos' );
 
-	var k = float( 1 ).toVar();
+	var k = float( 1 ).toVar( 'k' );
 
-	var d = float( 1.5 ).sub( params.density ).mul( 2 ).toVar();
-	var count = params.density.mul( 5 ).add( 5 ).toVar();
+	var d = float( 1.5 ).sub( density ).mul( 2 ).toVar( 'd' );
+	var count = density.mul( 5 ).add( 5 ).toVar( 'count' );
 
 	Loop( count, ()=> {
 
@@ -46,9 +46,34 @@ var dalmatianSpots = TSLFn( ( params )=>{
 
 	} );
 
-	return mix( params.background, params.color, k.clamp( 0, 1 ) );
+	return mix( background, color, k.clamp( 0, 1 ) );
+
+} ).setLayout( {
+	name: 'dalmatianSpotsRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'density', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function dalmatianSpots( params={} ) {
+
+	var { position, scale, density, color, background, seed } = { ...defaults, ...params };
+
+	return dalmatianSpotsRaw( position, scale, density, color, background, seed );
+
+}
+
+
 
-}, defaults );
+dalmatianSpots.defaults = defaults;
 
 
 

package/src/darth-maul.js

@@ -4,14 +4,15 @@
 
 
 import { Color, Vector3 } from "three";
-import { exp, mix, positionGeometry, select, vec3 } from 'three/tsl';
-import { noise, prepare, TSLFn } from './tsl-utils.js';
+import { exp, Fn, mix, positionGeometry, select, vec3 } from 'three/tsl';
+import { noise } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Darth Maul',
 
+	position: positionGeometry,
 	scale: 2,
 	shift: new Vector3( 0, 0, 0 ),
 	complexity: 0,
@@ -28,28 +29,55 @@ var defaults = {
 
 
 
-var darthMaul = TSLFn( ( params ) => {
+var darthMaulRaw = Fn( ([ position, scale, shift, complexity, angle, distance, color, background, balance, seed ]) => {
 
-	params = prepare( params, defaults );
+	var xposition = position.add( shift ).mul( exp( scale.div( 1.5 ).sub( 1 ) ) ).sub( shift ).mul( vec3( 1, 1/2, 1/2 ) ).toVar( );
 
-	var position = positionGeometry.add( params.shift ).mul( exp( params.scale.div( 1.5 ).sub( 1 ) ) ).sub( params.shift ).mul( vec3( 1, 1/2, 1/2 ) ).toVar( );
-
-	var s = select( positionGeometry.y.mul( params.angle.radians().cos() ).add( positionGeometry.z.mul( params.angle.radians().sin() ) ).greaterThan( params.distance ), 1, 0 );
+	var s = select( position.y.mul( angle.radians().cos() ).add( position.z.mul( angle.radians().sin() ) ).greaterThan( distance ), 1, 0 );
 
 	// implement symmetry
-	position.x.assign( position.x.add( params.shift.x ).abs() );
-	position.y.addAssign( params.seed );
-	position.z.mulAssign( params.shift.z );
+	xposition.x.assign( xposition.x.add( shift.x ).abs() );
+	xposition.y.addAssign( seed );
+	xposition.z.mulAssign( shift.z );
+
+	var n = noise( xposition ).toVar();
+
+	var k = n.sin().mul( n.mul( complexity.mul( 2 ).add( 1 ).exp() ).sin() ).remap( 0, 0.2, 1, -1 ).greaterThan( balance ).select( 0, 1 );
+
+	var c = select( xposition.x.greaterThan( noise( xposition.mul( 2.3 ) ).abs().mul( 0.5 ).add( 0.02 )	), 1, 0 );
+
+	return mix( background, color, k.mul( s ).mul( c ).clamp( 0, 1 ) );
+
+} ).setLayout( {
+	name: 'darthMaulRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'shift', type: 'vec3' },
+		{ name: 'complexity', type: 'float' },
+		{ name: 'angle', type: 'float' },
+		{ name: 'distance', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'balance', type: 'float' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function darthMaul( params={} ) {
+
+	var { position, scale, shift, complexity, angle, distance, color, background, balance, seed } = { ...defaults, ...params };
 
-	var n = noise( position ).toVar();
+	return darthMaulRaw( position, scale, shift, complexity, angle, distance, color, background, balance, seed );
 
-	var k = n.sin().mul( n.mul( params.complexity.mul( 2 ).add( 1 ).exp() ).sin() ).remap( 0, 0.2, 1, -1 ).greaterThan( params.balance ).select( 0, 1 );
+}
 
-	var c = select( position.x.greaterThan( noise( position.mul( 2.3 ) ).abs().mul( 0.5 ).add( 0.02 )	), 1, 0 );
 
-	return mix( params.background, params.color, k.mul( s ).mul( c ).clamp( 0, 1 ) );
 
-}, defaults );
+darthMaul.defaults = defaults;
 
 
 

package/src/dyson-sphere.js

@@ -5,13 +5,13 @@
 
 import { Color } from 'three';
 import { exp, float, Fn, Loop, mix, positionGeometry, vec3 } from 'three/tsl';
-import { prepare, TSLFn } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Dyson sphere',
 
+	position: positionGeometry,
 	scale: 2,
 	complexity: 2,
 
@@ -31,15 +31,29 @@ var noisea = Fn( ([ pos ])=>{
 	p.addAssign( p.dot( p.add( vec3( 31.4159, 27.1828, 14.142 ) ) ) );
 	return p.z.mul( p.x.add( p.y ) ).fract().mul( 2 ).sub( 1 );
 
-} );
+} ).setLayout( {
+	name: 'noisea',
+	type: 'float',
+	inputs: [
+		{ name: 'pos', type: 'vec3' },
+	] }
+);
 
 
-var smooth = Fn( ([ x ])=>{
+
+var smoother = Fn( ([ x ])=>{
 
 	var t = x.oneMinus().clamp( 0, 1 ).toVar();
 	return t.mul( t ).mul( float( 3 ).sub( t.mul( 2 ) ) );
 
-} );
+} ).setLayout( {
+	name: 'smoother',
+	type: 'float',
+	inputs: [
+		{ name: 'x', type: 'float' },
+	] }
+);
+
 
 
 var noiseg = Fn( ([ pos ])=>{
@@ -53,13 +67,13 @@ var noiseg = Fn( ([ pos ])=>{
 	var minz = pos.z.floor().toVar();
 	var maxz = minz.add( 1 ).toVar();
 
-	var dx = smooth( pos.x.fract() ).toVar();
-	var dy = smooth( pos.y.fract() ).toVar();
-	var dz = smooth( pos.z.fract() ).toVar();
+	var dx = smoother( pos.x.fract() ).toVar();
+	var dy = smoother( pos.y.fract() ).toVar();
+	var dz = smoother( pos.z.fract() ).toVar();
 
-	var mx = smooth( dx.oneMinus() ).toVar();
-	var my = smooth( dy.oneMinus() ).toVar();
-	var mz = smooth( dz.oneMinus() ).toVar();
+	var mx = smoother( dx.oneMinus() ).toVar();
+	var my = smoother( dy.oneMinus() ).toVar();
+	var mz = smoother( dz.oneMinus() ).toVar();
 
 	var n000 = noisea( vec3( minx, miny, minz ) ).mul( mx ).mul( my ).mul( mz ).toVar();
 	var n001 = noisea( vec3( minx, miny, maxz ) ).mul( mx ).mul( my ).mul( dz ).toVar();
@@ -72,29 +86,58 @@ var noiseg = Fn( ([ pos ])=>{
 
 	return n000.add( n001 ).add( n010 ).add( n011 ).add( n100 ).add( n101 ).add( n110 ).add( n111 );
 
-} );
-
+} ).setLayout( {
+	name: 'noiseg',
+	type: 'float',
+	inputs: [
+		{ name: 'pos', type: 'vec3' },
+	] }
+);
 
 
-var dysonSphere = TSLFn( ( params )=>{
 
-	params = prepare( params, defaults );
+var dysonSphereRaw = Fn( ([ position, scale, complexity, color, background, seed ])=>{
 
-	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 res = vec3().toVar();
 	var factor = float( 1 ).toVar();
 
-	Loop( params.complexity.add( 4 ), ()=>{
+	Loop( complexity.add( 4 ), ()=>{
 
 		res.addAssign( noiseg( pos.mul( factor ) ) );
 		factor.addAssign( factor );
 
 	} );
 
-	return mix( params.background, params.color, res.x.add( 1 ).div( 5 ) );
+	return mix( background, color, res.x.add( 1 ).div( 5 ) );
+
+} ).setLayout( {
+	name: 'dysonSphereRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'complexity', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function dysonSphere( params={} ) {
+
+	var { position, scale, complexity, color, background, seed } = { ...defaults, ...params };
+
+	return dysonSphereRaw( position, scale, complexity, color, background, seed );
+
+}
+
+
 
-}, defaults );
+dysonSphere.defaults = defaults;
 
 
 

package/src/entangled.js

@@ -4,14 +4,15 @@
 
 
 import { Color } from "three";
-import { abs, exp, float, floor, Loop, max, mix, mul, oneMinus, positionGeometry, pow, sin } from 'three/tsl';
-import { noise, prepare, TSLFn } from './tsl-utils.js';
+import { abs, exp, float, Fn, Loop, max, mix, mul, oneMinus, positionGeometry, pow, sin } from 'three/tsl';
+import { noise } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Entangled',
 
+	position: positionGeometry,
 	scale: 2,
 	density: 10,
 
@@ -23,28 +24,51 @@ var defaults = {
 
 
 
-var entangled = TSLFn( ( params ) => {
+var entangledRaw = Fn( ([ position, scale, density, color, background, seed ]) => {
 
-	params = prepare( params, defaults );
-
-	var scale = exp( params.scale.div( 2 ) ).toVar( );
-	var pos = positionGeometry.add( params.seed ).toVar( );
+	var xscale = exp( scale.div( 2 ) ).toVar( );
+	var pos = position.add( seed ).toVar( );
 	var k = float( -10000 ).toVar( );
 	var k1 = float( 0 ).toVar( );
 
-	Loop( floor( float( params.density ) ), ()=> {
+	Loop( density, ()=> {
 
-		k1.assign( sin( noise( mul( pos, scale ) ).mul( 3*Math.PI ) ) );
+		k1.assign( sin( noise( mul( pos, xscale ) ).mul( 3*Math.PI ) ) );
 		k.assign( max( k, k1 ) );
-		scale.mulAssign( 1.2 );
+		xscale.mulAssign( 1.2 );
 
 	} );
 
 	k.assign( oneMinus( pow( abs( k ), 5 ) ).mul( 6 ) );
 
-	return mix( params.color, params.background, k );
+	return mix( color, background, k );
+
+} ).setLayout( {
+	name: 'entangled',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'density', type: 'int' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function entangled( params={} ) {
+
+	var { position, scale, density, color, background, seed } = { ...defaults, ...params };
+
+	return entangledRaw( position, scale, density, color, background, seed );
+
+}
+
+
 
-}, defaults );
+entangled.defaults = defaults;
 
 
 

package/src/fordite.js

@@ -4,41 +4,65 @@
 
 
 import { Color } from 'three';
-import { exp, mul, positionGeometry, sin, vec3 } from 'three/tsl';
-import { hsl, noise, prepare, TSLFn } from './tsl-utils.js';
+import { exp, Fn, mul, positionGeometry, sin, vec3 } from 'three/tsl';
+import { hsl, noise } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Fordite',
+
+	position: positionGeometry,
 	scale: 2,
 	color: new Color( 0, 0, 0 ),
+
 	seed: 0,
 };
 
 
 
-var fordite = TSLFn( ( params ) => {
-
-	params = prepare( params, defaults );
+var forditeRaw = Fn( ([ position, scale, color, seed ]) => {
 
-	var pos = positionGeometry.mul( exp( params.scale ) ).add( params.seed ).toVar( );
+	var pos = position.mul( exp( scale ) ).add( seed ).toVar( );
 
 	var k = noise(
 		vec3(
-			noise( pos ),
-			noise( pos ).mul( 2 ),
-			noise( pos ).mul( 3 ),
+			noise( pos, 1 ),
+			noise( pos, 2 ),
+			noise( pos, 3 ),
 		)
 	).toVar( );
 
-	return hsl(
+	return hsl( vec3(
 		k,
 		1,
 		sin( mul( k, Math.PI, 4 ) ).mul( 0.5 ).add( 0.5 )
-	).add( params.color );
+	) ).add( color );
+
+} ).setLayout( {
+	name: 'forditeRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function fordite( params={} ) {
+
+	var { position, scale, color, seed } = { ...defaults, ...params };
+
+	return forditeRaw( position, scale, color, seed );
+
+}
+
+
 
-}, defaults );
+fordite.defaults = defaults;