tsl-textures 2.5.1 → 3.0.1

package/src/caustics.js

@@ -1,19 +1,21 @@
 
-//	TSL-Textures: Voronoi Cells
+//	TSL-Textures: Caustics
 
 
 
 import { Color } from 'three';
-import { exp, mx_worley_noise_float, mx_worley_noise_vec3, positionGeometry, time, vec3 } from 'three/tsl';
-import { prepare, TSLFn } from './tsl-utils.js';
+import { exp, Fn, positionGeometry, time, vec3 } from 'three/tsl';
+import { voronoi, voronoi3 } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Caustics',
 
+	position: positionGeometry,
 	scale: 2,
 	speed: 0,
+	time: time,
 
 	color: new Color( 0x50A8C0 ),
 
@@ -22,28 +24,51 @@ var defaults = {
 
 
 
-var caustics = TSLFn( ( params )=>{
+var causticsRaw = Fn( ([ position, scale, speed, time, color, 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() )
 		.add( vec3( 0, 2*Math.PI/3, 4*Math.PI/3 ) )
 		.sin();
 
-	var p = mx_worley_noise_vec3(
+	var p = voronoi3(
 		pos.add( vec3(
-			mx_worley_noise_float( pos.add( t.xyz ) ),
-			mx_worley_noise_float( pos.add( t.yzx ) ),
-			mx_worley_noise_float( pos.add( t.zxy ) ),
+			voronoi( pos.add( t.xyz ) ),
+			voronoi( pos.add( t.yzx ) ),
+			voronoi( pos.add( t.zxy ) ),
 		) ) );
 
 	var k = p.length().div( Math.sqrt( 3 ) );
 
-	return k.add( params.color.sub( 0.5 ).mul( 2 ) );
+	return k.add( color.sub( 0.5 ).mul( 2 ) );
+
+} ).setLayout( {
+	name: 'causticsRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'speed', type: 'float' },
+		{ name: 'time', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function caustics( params={} ) {
+
+	var { position, scale, speed, time, color, seed } = { ...defaults, ...params };
+
+	return causticsRaw( position, scale, speed, time, color, seed );
+
+}
+
+
 
-}, defaults );
+caustics.defaults = defaults;
 
 
 

package/src/cave-art.js

@@ -4,15 +4,17 @@
 
 
 import { Color } from "three";
-import { abs, add, exp, float, If, mix, or, positionGeometry, pow2, sub } from 'three/tsl';
-import { noise, prepare, TSLFn } from './tsl-utils.js';
+import { float, Fn, If, mix, or, positionGeometry } from 'three/tsl';
+import { noise } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Cave art',
 
+	position: positionGeometry,
 	scale: 2,
+
 	thinness: 2,
 	noise: 0.3,
 
@@ -24,17 +26,15 @@ var defaults = {
 
 
 
-var caveArt = TSLFn( ( params ) => {
-
-	params = prepare( params, defaults );
+var caveArtRaw = Fn( ([ position, scale, thinness, xnoise, color, background, seed ]) => {
 
-	var pos = positionGeometry.mul( exp( params.scale ) ).add( params.seed ).toVar( );
+	var pos = position.mul( scale.exp( ) ).add( seed ).toVar( 'pos' );
 
-	var k1 = noise( pos, 4 ).sin().toVar();
-	var k2 = noise( pos.mul( 1.5 ), 4 ).cos().toVar();
+	thinness = float( 3 ).sub( thinness ).exp( );
 
-	var thinness = exp( sub( float( 3 ), params.thinness ) );
-	var k = sub( thinness, pow2( abs( add( k1, k2 ) ) ).mul( 20 ) ).toVar();
+	var k1 = noise( pos, 4 ).sin().toVar( 'k1' ),
+		k2 = noise( pos.mul( 1.5 ), 4 ).cos().toVar( 'k2' ),
+		k = thinness.sub( k1.add( k2 ).abs( ).pow2( ).mul( 20 ) ).toVar( 'k' );
 
 	If( or( k1.greaterThan( k2 ), k.lessThan( 0 ) ), ()=>{
 
@@ -44,13 +44,39 @@ var caveArt = TSLFn( ( params ) => {
 
 	If( k.lessThanEqual( 0 ), ()=>{
 
-		k.assign( params.noise.mul( pow2( noise( pos.mul( 30 ) ) ) ) );
+		k.assign( xnoise.mul( noise( pos.mul( 30 ) ).pow2( ) ) );
 
 	} );
 
-	return mix( params.background, params.color, k );
+	return mix( background, color, k );
+
+} ).setLayout( {
+	name: 'caveArtRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'thinness', type: 'float' },
+		{ name: 'xnoise', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function caveArt( params={} ) {
+
+	var { position, scale, thinness, noise, color, background, seed } = { ...defaults, ...params };
+
+	return caveArtRaw( position, scale, thinness, noise, color, background, seed );
+
+}
+
+
 
-}, defaults );
+caveArt.defaults = defaults;
 
 
 

package/src/circle-decor.js

@@ -4,14 +4,15 @@
 
 
 import { Color } from 'three';
-import { exp, mix, mx_worley_noise_float, positionGeometry } from 'three/tsl';
-import { noise, prepare, TSLFn } from './tsl-utils.js';
+import { exp, Fn, mix, positionGeometry } from 'three/tsl';
+import { noise, voronoi } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Circle decor',
 
+	position: positionGeometry,
 	scale: 2,
 	grains: 0.2,
 
@@ -26,24 +27,49 @@ var defaults = {
 
 
 
-var circleDecor = TSLFn( ( params )=>{
+var circleDecorRaw = Fn( ([ position, scale, grains, complexity, blur, color, background, seed ])=>{
 
-	params = prepare( params, defaults );
+	var pos = position.mul( exp( scale.div( 4 ) ) ).add( seed ).toVar( 'pos' );
+	var subpos = pos.mul( 2 ).toVar( 'subpos' );
 
-	var pos = positionGeometry.mul( exp( params.scale.div( 4 ) ) ).add( params.seed ).toVar( );
-	var subpos = pos.mul( 2 ).toVar( );
-
-	var k1 = mx_worley_noise_float( pos );
-	var k2 = mx_worley_noise_float( subpos );
-	var k3 = mx_worley_noise_float( pos.mul( params.grains.mul( 4 ).add( 2 ) ) ).mul( 2 );
+	var k1 = voronoi( pos );
+	var k2 = voronoi( subpos );
+	var k3 = voronoi( pos.mul( grains.mul( 4 ).add( 2 ) ) ).mul( 2 );
 
 	var compScale = noise( pos ).div( 2 ).add( 1 );
 
-	var k = k1.min( k2, k3 ).clamp( 0, 1 ).mul( params.complexity.add( 2 ).exp(), compScale, Math.PI ).sin().smoothstep( params.blur.negate(), params.blur );
+	var k = k1.min( k2, k3 ).clamp( 0, 1 ).mul( complexity.add( 2 ).exp(), compScale, Math.PI ).sin().smoothstep( blur.negate(), blur );
+
+	return mix( color, background, k.oneMinus() );
+
+} ).setLayout( {
+	name: 'camouflageRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'grains', type: 'float' },
+		{ name: 'complexity', type: 'float' },
+		{ name: 'blur', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function circleDecor( params={} ) {
+
+	var { position, scale, grains, complexity, blur, color, background, seed } = { ...defaults, ...params };
+
+	return circleDecorRaw( position, scale, grains, complexity, blur, color, background, seed );
+
+}
+
 
-	return mix( params.color, params.background, k.oneMinus() );
 
-}, defaults );
+circleDecor.defaults = defaults;
 
 
 

package/src/circles.js

@@ -4,39 +4,35 @@
 
 
 import { Color } from "three";
-import { acos, clamp, exp, float, positionGeometry, select, sin } from 'three/tsl';
-import { hsl, prepare, toHsl, TSLFn } from './tsl-utils.js';
+import { acos, clamp, exp, Fn, positionGeometry, select, sin, vec3 } from 'three/tsl';
+import { hsl, toHsl } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Circles',
 
+	position: positionGeometry,
+
 	scale: 2,
 	variety: 1,
 
 	color: new Color( 0xF0E0D0 ),
 
-	flat: 0,
-
 	seed: 0,
 };
 
 
 
-var circles = TSLFn( ( params ) => {
+var circlesRaw = Fn( ([ position, scale, variety, color, seed ]) => {
 
-	params = prepare( params, defaults );
-
-	var pos = select( params.flat, positionGeometry, positionGeometry.normalize() );
+	var pos = position.toVar();
 
 	var angle = acos( clamp( pos.y, -1, 1 ) ).mul( 20 );
 
-	var scale = exp( params.scale.sub( 1 ) );
-
-	var x = angle.div( 3000 ).mul( scale );
+	var x = angle.div( 3000 ).mul( exp( scale.sub( 1 ) ) );
 
-	var k = float( params.seed.sin().mul( 100 ) ).toVar();
+	var k = seed.sin().mul( 100 ).toVar();
 
 	for ( var n=0; n<=10; n++ ) {
 
@@ -46,17 +42,41 @@ var circles = TSLFn( ( params ) => {
 
 	k.assign( k.div( 200 ).clamp( -2, 2 ) );
 
-	var HSL = toHsl( params.color );
+	var HSL = toHsl( color );
 
-	var hue = HSL.x.add( k.mul( params.variety ) ).mod( 1 ).mul( 10 );
+	var hue = HSL.x.add( k.mul( variety ) ).mod( 1 ).mul( 10 );
 
 	var huei = hue.floor();
 	var huef = hue.sub( huei );
 	huef = select( huef.lessThan( 0.5 ), huef.pow( 1.5 ), huef.pow( 1/1.5 ) );
 
-	return hsl( huei.add( huef ).div( 10 ), HSL.y, HSL.z );
+	return hsl( vec3( huei.add( huef ).div( 10 ), HSL.yz ) );
+
+} ).setLayout( {
+	name: 'circlesRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'variety', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function circles( params={} ) {
+
+	var { position, scale, variety, color, seed } = { ...defaults, ...params };
+
+	return circlesRaw( position, scale, variety, color, seed );
+
+}
+
+
 
-}, defaults );
+circles.defaults = defaults;
 
 
 

package/src/clouds.js

@@ -4,14 +4,15 @@
 
 
 import { Color } from "three";
-import { add, clamp, exp, Fn, mix, mul, positionGeometry, vec4 } from 'three/tsl';
-import { noised, prepare, TSLFn } from './tsl-utils.js';
+import { clamp, exp, Fn, mix, mul, positionGeometry } from 'three/tsl';
+import { fractal } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Clouds',
 
+	position: positionGeometry,
 	scale: 2,
 	density: 0.5,
 	opacity: 1,
@@ -24,49 +25,89 @@ var defaults = {
 
 
 
-var _clouds = Fn( ( params ) => {
+var cloud_core = Fn( ([ position, scale, density, seed ]) => {
 
-	const pos = positionGeometry;
-	const scale = exp( params.scale.div( 1.5 ).sub( 0.5 ) );
+	const pos = position.mul( exp( scale.div( 1.5 ).sub( 0.5 ) ) ).add( seed ).toVar( 'pos' );
 
-	// color blending
-	const k = add(
-		noised( pos, scale, 1, params.seed ),
-		noised( pos, scale, 2, params.seed ).mul( 0.80 ),
-		noised( pos, scale, 6, params.seed ).mul( 0.10 ),
-		noised( pos, scale, 8, params.seed ).mul( 0.07, params.opacity ),
-		params.density.remap( 0, 1, -0.5, 1.5 )
-	);
+	return fractal( pos, 4 ).add( density.remap( 0, 1, -0.5, 1.5 ) );
 
-	// opacity
-	const a = clamp( 0, 1, mul( k, 2 ).pow( 1.5 ).sub( 1 ).mul( params.opacity ) );
+} ).setLayout( {
+	name: 'cloud_core',
+	type: 'float',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'density', type: 'float' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
 
-	// final color+opacity
-	return vec4( mix( params.subcolor, params.color, k.clamp( 0, 1 ) ), a );
 
-} );
 
+var cloudsRaw = Fn( ([ position, scale, density, /*opacity,*/color, subcolor, seed ]) => {
 
+	var k = cloud_core( position, scale, density, seed );
+	return mix( subcolor, color, k.clamp( 0, 1 ) );
 
-var clouds = TSLFn( ( params ) => {
 
-	// prepare parameters
-	params = prepare( params, defaults );
+} ).setLayout( {
+	name: 'cloudsRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'density', type: 'float' },
+		/*{ name: 'opacity', type: 'float' },*/
+		{ name: 'color', type: 'vec3' },
+		{ name: 'subcolor', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
 
-	return _clouds( params ).rgb;
 
-}, defaults );
 
+var cloudsOpacityRaw = Fn( ([ position, scale, density, opacity, /*color,subcolor,*/seed ]) => {
 
+	var k = cloud_core( position, scale, density, seed );
+	return clamp( 0, 1, mul( k, 2 ).pow( 1.5 ).sub( 1 ).mul( opacity ) );
 
-clouds.opacity = TSLFn( ( params ) => {
+} ).setLayout( {
+	name: 'cloudsOpacityRaw',
+	type: 'float',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'density', type: 'float' },
+		{ name: 'opacity', type: 'float' },
+		/*{ name: 'color', type: 'vec3' },*/
+		/*{ name: 'subcolor', type: 'vec3' },*/
+		{ name: 'seed', type: 'float' },
+	] }
+);
 
-	// prepare parameters
-	params = prepare( params, defaults );
 
-	return _clouds( params ).a;
 
-}, defaults );
+function clouds( params={} ) {
+
+	var { position, scale, density, /*opacity,*/color, subcolor, seed } = { ...defaults, ...params };
+
+	return cloudsRaw( position, scale, density, /*opacity,*/color, subcolor, seed );
+
+}
+
+
+
+clouds.opacity = function ( params={} ) {
+
+	var { position, scale, density, opacity, /*color,subcolor,*/seed } = { ...defaults, ...params };
+
+	return cloudsOpacityRaw( position, scale, density, opacity, /*color,subcolor,*/seed );
+
+};
+
+
+
+clouds.defaults = defaults;
 
 
 

package/src/concrete.js

@@ -3,8 +3,8 @@
 
 
 
-import { abs, cos, cross, exp, Fn, normalLocal, positionGeometry, pow, remap, sin, sub, tangentLocal, transformNormalToView, vec3 } from 'three/tsl';
-import { noise, prepare, TSLFn } from './tsl-utils.js';
+import { 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: 'Concrete',
 	$normalNode: true,
 
+	position: positionGeometry,
+
 	scale: 2,
 	density: 0.5,
 	bump: 0.5,
@@ -21,40 +23,72 @@ var defaults = {
 
 
 
-var surfacePos = Fn( ([ pos, normal, bump, density, seed ]) => {
+var surfacePos = Fn( ([ position, normal, density ]) => {
+
+	var k = noise( position, 0.5, 0.5 ).abs().pow( density );
+
+	return position.add( normal.mul( k ) );
+
+} ).setLayout( {
+	name: 'surfacePos',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'normal', type: 'vec3' },
+		{ name: 'density', type: 'float' },
+	] }
+);
+
+
+
+var concreteRaw = Fn( ([ position, normal, tangent, scale, density, bump, seed ]) => {
+
+	const EPS = 0.001;
+
+	var seed3d = vec3( 1, 2, 3 ).mul( seed ).sin().mul( 100 ).toVar( 'seed3d' );
+
+	var xposition = position.mul( exp( scale.div( 2 ).add( 2 ) ) ).add( seed3d ).toVar( 'xposition' ),
+		xnormal = normal.normalize().toVar( 'xnormal' ),
+		xtangent = tangent.normalize().mul( EPS ).toVar( 'xtangent' ),
+		xbitangent = cross( xnormal, xtangent ).normalize().mul( EPS ).toVar( 'xbitangent' );
+
+	var xdensity = remap( density, 0, 1, 10, 0.5 ).toVar( 'xdensity' );
 
-	var k = noise( pos.add( seed ) ).mul( 0.5 ).add( 0.5 );
-	k = bump.mul( pow( abs( k ), density ) );
+	xnormal.mulAssign( bump );
 
-	return pos.add( k.mul( normal ) );
+	var pos = surfacePos( xposition, xnormal, xdensity ).toVar( 'pos' ),
+		posU = surfacePos( xposition.add( xtangent ), xnormal, xdensity ).toVar( 'posU' ),
+		posV = surfacePos( xposition.add( xbitangent ), xnormal, xdensity ).toVar( 'posV' );
 
-} );
+	return approximateNormal( pos, posU, posV );
 
+} ).setLayout( {
+	name: 'concreteRaw',
+	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' },
+	] }
+);
 
-var concrete = TSLFn( ( params ) => {
 
-	params = prepare( params, defaults );
 
-	var eps = 0.001;
+function concrete( params={} ) {
 
-	var position = positionGeometry.mul( exp( params.scale.div( 2 ).add( 2 ) ) ).toVar( ),
-		normal = normalLocal.normalize().toVar(),
-		tangent = tangentLocal.normalize().mul( eps ).toVar(),
-		bitangent = cross( normal, tangent ).normalize().mul( eps ).toVar();
+	var { position, scale, density, bump, seed } = { ...defaults, ...params };
 
-	var density = remap( params.density, 0, 1, 10, 0.5 ).toVar();
-	var seed = vec3( sin( params.seed ).mul( 100 ), cos( params.seed.div( 2 ) ).mul( 100 ), sin( params.seed.div( 3 ) ).mul( 100 ) ).toVar();
+	return concreteRaw( position, normalLocal, tangentLocal, scale, density, bump, seed );
 
-	var pos = surfacePos( position, normal, params.bump, density, 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 );
+concrete.defaults = defaults;