tsl-textures 2.5.1 → 3.0.1

package/src/satin.js

@@ -4,14 +4,15 @@
 
 
 import { Color } from "three";
-import { abs, exp, mix, positionGeometry, pow, vec3 } from 'three/tsl';
-import { noise, prepare, TSLFn } from './tsl-utils.js';
+import { Fn, mix, positionGeometry, vec3 } from 'three/tsl';
+import { noise } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Satin',
 
+	position: positionGeometry,
 	scale: 2,
 
 	color: new Color( 0x7080FF ),
@@ -22,40 +23,46 @@ var defaults = {
 
 
 
-var satin = TSLFn( ( params ) => {
+var satinRaw = Fn( ([ position, scale, color, background, seed ]) => {
 
-	params = prepare( params, defaults );
-
-	var pos = positionGeometry.toVar( );
-
-	var scale = exp( params.scale.div( 3 ) ).toVar();
+	var pos = position.toVar( 'pos' ),
+		scale = scale.div( 3 ).exp( ).toVar( 'xscale' );
 
 	var k = noise(
 		vec3(
 			noise( vec3( pos.x.mul( 2 ), pos.y, pos.z ).mul( scale ) ),
 			noise( vec3( pos.x, pos.y.mul( 2 ), pos.z ).mul( scale ) ),
 			noise( vec3( pos.x, pos.y, pos.z.mul( 2 ) ).mul( scale ) ),
-		).mul( scale ).add( params.seed )
-	);
+		).mul( scale ).add( seed )
+	).abs().pow( 3 ).mul( 20 ).toVar( 'k' );
 
-	k = pow( abs( k ), 3 ).mul( 20 );
+	return mix( background, color, k );
 
-	return mix( params.background, params.color, k );
+} ).setLayout( {
+	name: 'satinRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
 
-}, defaults );
 
 
+function satin( params={} ) {
 
-satin.defaults = {
-	$name: 'Satin',
+	var { position, scale, color, background, seed } = { ...defaults, ...params };
 
-	scale: 2,
+	return satinRaw( position, scale, color, background, seed );
 
-	color: new Color( 0x7080FF ),
-	background: new Color( 0x000050 ),
+}
 
-	seed: 0,
-};
+
+
+satin.defaults = defaults;
 
 
 

package/src/scaler.js

@@ -4,8 +4,8 @@
 
 
 import { Vector2, Vector3 } from "three";
-import { cross, Fn, mix, normalLocal, positionGeometry, sub, tangentLocal, transformNormalToView, vec3, vec4 } from 'three/tsl';
-import { matScale, matTrans, prepare, selectPlanar, TSLFn } from './tsl-utils.js';
+import { cross, Fn, mix, normalLocal, positionGeometry, tangentLocal, vec3 } from 'three/tsl';
+import { approximateNormal, selectPlanar } from './tsl-utils.js';
 
 
 
@@ -25,51 +25,86 @@ var defaults = {
 
 
 
-var surfacePos = Fn( ([ pos, params ])=>{
+var surfacePos = Fn( ([ pos, scales, center, selectorAngles, selectorCenter, selectorWidth ])=>{
 
-	var zone = selectPlanar( pos, params.selectorAngles, params.selectorCenter, params.selectorWidth );
+	var zone = selectPlanar( pos, selectorAngles, selectorCenter, selectorWidth );
 
-	var S = matScale( mix( vec3( 1, 1, 1 ), params.scales, zone ) ),
-		T = matTrans( params.center ),
-		TN = matTrans( params.center.negate() );
+	var S = mix( vec3( 1, 1, 1 ), scales, zone );
 
-	return T.mul( S ).mul( TN ).mul( vec4( pos, 1 ) ).xyz;
+	return pos.sub( center ).mul( S ).add( center );
 
 } );
 
 
 
-var scaler = TSLFn( ( params )=>{
+var scalerRaw = Fn( ([ scales, center, selectorAngles, selectorCenter, selectorWidth ])=>{
 
-	params = prepare( params, defaults );
-
-	return surfacePos( positionGeometry, params );
-
-}, defaults );
+	return surfacePos( positionGeometry, scales, center, selectorAngles, selectorCenter, selectorWidth );
 
+} ).setLayout( {
+	name: 'scalerRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'scales', type: 'vec3' },
+		{ name: 'center', type: 'vec3' },
+		{ name: 'selectorAngles', type: 'vec2' },
+		{ name: 'selectorCenter', type: 'vec3' },
+		{ name: 'selectorWidth', type: 'float' },
+	]
+} );
 
 
-scaler.normal = TSLFn( ( params ) => {
 
-	params = prepare( params, defaults );
+var scalerNormalRaw = Fn( ([ scales, center, selectorAngles, selectorCenter, selectorWidth ]) => {
 
-	var eps = 0.01;
+	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();
+		tangent = tangentLocal.normalize().mul( EPS ).toVar(),
+		bitangent = cross( normal, tangent ).normalize().mul( EPS ).toVar();
+
+	var pos = surfacePos( position, scales, center, selectorAngles, selectorCenter, selectorWidth );
+	var posU = surfacePos( position.add( tangent ), scales, center, selectorAngles, selectorCenter, selectorWidth );
+	var posV = surfacePos( position.add( bitangent ), scales, center, selectorAngles, selectorCenter, selectorWidth );
+
+	return approximateNormal( pos, posU, posV );
+
+} ).setLayout( {
+	name: 'scalerNormalRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'scales', type: 'vec3' },
+		{ name: 'center', type: 'vec3' },
+		{ name: 'selectorAngles', type: 'vec2' },
+		{ name: 'selectorCenter', type: 'vec3' },
+		{ name: 'selectorWidth', type: 'float' },
+	]
+} );
+
+
+
+function scaler( params={} ) {
+
+	var { scales, center, selectorAngles, selectorCenter, selectorWidth } = { ...defaults, ...params };
 
-	var pos = surfacePos( position, params );
-	var posU = surfacePos( position.add( tangent ), params );
-	var posV = surfacePos( position.add( bitangent ), params );
+	return scalerRaw( scales, center, selectorAngles, selectorCenter, selectorWidth );
+
+}
+
+
+
+scaler.normal = function ( params={} ) {
+
+	var { scales, center, selectorAngles, selectorCenter, selectorWidth } = { ...defaults, ...params };
+
+	return scalerNormalRaw( scales, center, selectorAngles, selectorCenter, selectorWidth );
+
+};
 
-	var dU = sub( posU, pos ),
-		dV = sub( posV, pos );
 
-	return transformNormalToView( cross( dU, dV ).normalize() );
 
-}, defaults );
+scaler.defaults = defaults;
 
 
 

package/src/scepter-head.js

@@ -4,14 +4,16 @@
 
 
 import { Color } from "three";
-import { abs, add, cos, floor, max, mix, mod, mul, positionGeometry, remapClamp, sign, tan, vec3 } from 'three/tsl';
-import { hsl, noise, prepare, remapExp, toHsl, TSLFn } from './tsl-utils.js';
+import { abs, add, cos, floor, Fn, max, mix, mod, mul, positionGeometry, remapClamp, sign, tan, vec3 } from 'three/tsl';
+import { hsl, noise, remapExp, toHsl } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Scepter head',
 
+	position: positionGeometry,
+
 	xFactor: 10,
 	yFactor: 22,
 	zFactor: 10,
@@ -23,27 +25,25 @@ var defaults = {
 
 
 
-var scepterHead = TSLFn( ( params ) => {
-
-	params = prepare( params, defaults );
+var scepterHeadRaw = Fn( ([ position, xFactor, yFactor, zFactor, colorRim, colorA, colorB ]) => {
 
-	var pos = positionGeometry;
+	var pos = position.toVar( 'pos' );
 
-	var fx = pos.x.mul( remapExp( params.xFactor, 0, 100, 1.35, 30 ) ).toVar( ),
-		fy = pos.y.mul( remapExp( params.yFactor, 0, 100, 1.35, 30 ) ).toVar( ),
-		fz = pos.z.mul( remapExp( params.zFactor, 0, 100, 1.35, 30 ) ).toVar( );
+	var fx = pos.x.mul( remapExp( xFactor, 0, 100, 1.35, 30 ) ).toVar( 'fx' ),
+		fy = pos.y.mul( remapExp( yFactor, 0, 100, 1.35, 30 ) ).toVar( 'fy' ),
+		fz = pos.z.mul( remapExp( zFactor, 0, 100, 1.35, 30 ) ).toVar( 'fz' );
 
-	var cosX = cos( fx ).toVar(),
-		cosY = cos( fy ).toVar(),
-		cosZ = cos( fz ).toVar();
+	var cosX = cos( fx ),
+		cosY = cos( fy ),
+		cosZ = cos( fz );
 
 	var k = noise( vec3( pos.x.div( cosX ), pos.y.div( cosY ), pos.z.div( cosZ ) ) );
 
 	k = sign( k ).mul( abs( k ).pow( 0.75 ) );
 
-	var dx = abs( mul( fx, tan( fx ) ).add( 1 ).div( cos( fx ) ) ),
-		dy = abs( mul( fy, tan( fy ) ).add( 1 ).div( cos( fy ) ) ),
-		dz = abs( mul( fz, tan( fz ) ).add( 1 ).div( cos( fz ) ) );
+	var dx = abs( mul( fx, tan( fx ) ).add( 1 ).div( cosX ) ),
+		dy = abs( mul( fy, tan( fy ) ).add( 1 ).div( cosY ) ),
+		dz = abs( mul( fz, tan( fz ) ).add( 1 ).div( cosZ ) );
 
 	var HSL = vec3().toVar();
 
@@ -53,15 +53,41 @@ var scepterHead = TSLFn( ( params ) => {
 
 	var index = mod( ( add( indexX, indexY, indexZ ) ), 2 );
 
-	HSL.assign( toHsl( mix( params.colorA, params.colorB, index ) ) );
-	var color1 = hsl( HSL.x, HSL.y, HSL.z.mul( k ) ).toVar();
+	HSL.assign( toHsl( mix( colorA, colorB, index ) ) );
+	var color1 = hsl( vec3( HSL.xy, HSL.z.mul( k ) ) ).toVar( 'color1' );
 
-	HSL.assign( toHsl( params.colorRim ) );
-	var color2 = hsl( HSL.x, HSL.y, mul( 2, k, HSL.z ) ).toVar();
+	HSL.assign( toHsl( colorRim ) );
+	var color2 = hsl( vec3( HSL.xy, mul( 2, k, HSL.z ) ) ).toVar( 'color2' );
 
 	return mix( color1, color2, remapClamp( max( dx, max( dy, dz ) ), 55-10, 55+10 ) );
 
-}, defaults );
+} ).setLayout( {
+	name: 'scepterHeadRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'xFactor', type: 'float' },
+		{ name: 'yFactor', type: 'float' },
+		{ name: 'zFactor', type: 'float' },
+		{ name: 'colorRim', type: 'vec3' },
+		{ name: 'colorA', type: 'vec3' },
+		{ name: 'colorB', type: 'vec3' },
+	] }
+);
+
+
+
+function scepterHead( params={} ) {
+
+	var { position, xFactor, yFactor, zFactor, colorRim, colorA, colorB } = { ...defaults, ...params };
+
+	return scepterHeadRaw( position, xFactor, yFactor, zFactor, colorRim, colorA, colorB );
+
+}
+
+
+
+scepterHead.defaults = defaults;
 
 
 

package/src/scream.js

@@ -4,14 +4,15 @@
 
 
 import { Color } from "three";
-import { add, cos, exp, mix, positionGeometry, sin } from 'three/tsl';
-import { hsl, noise, prepare, toHsl, TSLFn } from './tsl-utils.js';
+import { add, cos, exp, Fn, mix, positionGeometry, sin, vec3 } from 'three/tsl';
+import { hsl, noise, toHsl } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Scream',
 
+	position: positionGeometry,
 	scale: 2,
 	variety: 1,
 
@@ -23,39 +24,48 @@ var defaults = {
 
 
 
-var scream = TSLFn( ( params ) => {
+var screamRaw = Fn( ([ position, scale, variety, color, background, seed ]) => {
 
-	params = prepare( params, defaults );
-
-	var pos = positionGeometry.mul( exp( params.scale ) ).add( params.seed ).toVar( );
+	var pos = position.mul( exp( scale ) ).add( seed ).toVar( 'pos' );
 
 	var k = noise( add( sin( pos.xyz ), cos( pos.yzx ) ) );
 
-	pos.assign( positionGeometry.mul( exp( params.scale ).mul( k ) ).add( params.seed ) );
+	pos.assign( position.mul( exp( scale ).mul( k ) ).add( seed ) );
 
 	var k = noise( add( sin( pos.xyz ), cos( pos.yzx ) ).mul( 2 ) );
 
-	var col = mix( params.background, params.color, k ).toVar();
+	var col = mix( background, color, k ).toVar( 'col' );
 
-	var HSL = toHsl( col ).toVar();
+	var HSL = toHsl( col ).toVar( 'HSL' );
 
-	return hsl( add( HSL.x, params.variety.mul( sin( k.mul( Math.PI ) ) ).mul( 0.5 ) ), HSL.y, HSL.z );
+	return hsl( vec3( add( HSL.x, variety.mul( sin( k.mul( Math.PI ) ) ).mul( 0.5 ) ), HSL.yz ) );
 
-}, defaults );
+} ).setLayout( {
+	name: 'satinRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'variety', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
 
 
 
-scream.defaults = {
-	$name: 'Scream',
+function scream( params={} ) {
 
-	scale: 2,
-	variety: 1,
+	var { position, scale, variety, color, background, seed } = { ...defaults, ...params };
 
-	color: new Color( 0xF0F060 ),
-	background: new Color( 0xD09090 ),
+	return screamRaw( position, scale, variety, color, background, seed );
 
-	seed: 0,
-};
+}
+
+
+
+scream.defaults = defaults;
 
 
 

package/src/stars.js

@@ -4,14 +4,15 @@
 
 
 import { Color } from "three";
-import { abs, add, exp, mix, positionGeometry, select } from 'three/tsl';
-import { hsl, noise, prepare, toHsl, TSLFn } from './tsl-utils.js';
+import { abs, add, exp, Fn, mix, positionGeometry, select, vec3 } from 'three/tsl';
+import { hsl, noise, toHsl } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Stars',
 
+	position: positionGeometry,
 	scale: 2,
 	density: 2,
 	variation: 0,
@@ -24,23 +25,47 @@ var defaults = {
 
 
 
-var stars = TSLFn( ( params ) => {
+var starsRaw = Fn( ([ position, scale, density, variation, color, background, seed ]) => {
 
-	params = prepare( params, defaults );
-
-	var pos = positionGeometry.mul( exp( params.scale.div( 2 ).add( 3 ) ) ).add( params.seed ).toVar( );
+	var pos = position.mul( exp( scale.div( 2 ).add( 3 ) ) ).add( seed ).toVar( );
 
 	var k = abs( noise( pos ) ).pow( 10 ).mul( 10 );
 
-	k = k.mul( exp( params.density.sub( 2 ) ) );
+	k = k.mul( exp( density.sub( 2 ) ) );
+
+	var dS = select( k.greaterThan( 0.1 ), variation.mul( noise( pos ) ), 0 );
+
+	var col = toHsl( mix( background, color, k ) );
+
+	return hsl( vec3( add( col.x, dS ), col.yz ) );
+
+} ).setLayout( {
+	name: 'starsRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'density', type: 'float' },
+		{ name: 'variation', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function stars( params={} ) {
+
+	var { position, scale, density, variation, color, background, seed } = { ...defaults, ...params };
+
+	return starsRaw( position, scale, density, variation, color, background, seed );
 
-	var dS = select( k.greaterThan( 0.1 ), params.variation.mul( noise( pos ) ), 0 );
+}
 
-	var col = toHsl( mix( params.background, params.color, k ) );
 
-	return hsl( add( col.x, dS ), col.y, col.z );
 
-}, defaults );
+stars.defaults = defaults;
 
 
 

package/src/static-noise.js

@@ -3,14 +3,17 @@
 
 
 
-import { clamp, exp, screenCoordinate, time, vec3 } from 'three/tsl';
-import { noise, prepare, TSLFn, vnoise } from './tsl-utils.js';
+import { clamp, exp, Fn, screenCoordinate, time, vec3 } from 'three/tsl';
+import { noise, vnoise } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Static noise',
 
+	position: screenCoordinate,
+	time: time,
+
 	scale: 2,
 	balance: 0,
 	contrast: 0,
@@ -22,24 +25,48 @@ var defaults = {
 
 
 
-var staticNoise = TSLFn( ( params ) => {
-
-	params = prepare( params, defaults );
+var staticNoiseRaw = Fn( ([ position, time, scale, balance, contrast, delay, seed ]) => {
 
-	var pos = screenCoordinate.div( exp( params.scale ) ).add( params.seed );
+	var pos = position.div( exp( scale ) ).add( seed );
 
-	var speed = params.delay.sub( 1 ).mul( 5 ).exp(),
+	var speed = delay.sub( 1 ).mul( 5 ).exp(),
 		t = time.div( speed ).round().mul( speed );
 
 	var offset = vnoise( t.sin() ).mul( 1000 );
 
 	var k = clamp( 0, 1, noise( pos.add( offset ) ) );
 
-	k = k.mul( 0.5, exp( params.contrast ) ).add( 0.5, params.balance );
+	k = k.mul( 0.5, exp( contrast ) ).add( 0.5, balance );
 
 	return vec3( k );
 
-}, defaults );
+} ).setLayout( {
+	name: 'staticNoiseRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec2' },
+		{ name: 'time', type: 'float' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'balance', type: 'float' },
+		{ name: 'contrast', type: 'float' },
+		{ name: 'delay', type: 'float' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function staticNoise( params={} ) {
+
+	var { position, time, scale, balance, contrast, delay, seed } = { ...defaults, ...params };
+
+	return staticNoiseRaw( position, time, scale, balance, contrast, delay, seed );
+
+}
+
+
+
+staticNoise.defaults = defaults;
 
 
 

package/src/supersphere.js

@@ -3,8 +3,8 @@
 
 
 
-import { cross, float, Fn, normalLocal, positionGeometry, sub, tangentLocal, transformNormalToView } from 'three/tsl';
-import { prepare, TSLFn } from './tsl-utils.js';
+import { cross, float, Fn, normalLocal, positionGeometry, tangentLocal } from 'three/tsl';
+import { approximateNormal } from './tsl-utils.js';
 
 
 
@@ -18,53 +18,90 @@ var defaults = {
 
 
 
-var surfacePos = Fn( ([ pos, params ])=>{
+var surfacePos = Fn( ([ pos, exponent ])=>{
 
-	var exponent = float( 2 ).pow( params.exponent );
+	var xexponent = float( 2 ).pow( exponent );
 	var equPos = pos.div( pos.length() ).toVar();
+	var equPos2 = equPos.abs().pow( xexponent ).toVar();
 
-	var p = equPos.x.abs().pow( exponent )
-		.add( equPos.y.abs().pow( exponent ) )
-		.add( equPos.z.abs().pow( exponent ) )
-		.pow( float( 1 ).div( exponent ) );
+	var p = equPos2.x
+		.add( equPos2.y )
+		.add( equPos2.z )
+		.pow( xexponent.reciprocal( ) );
 
 	return equPos.div( p );
 
+} ).setLayout( {
+	name: 'surfacePos',
+	type: 'vec3',
+	inputs: [
+		{ name: 'pos', type: 'vec3' },
+		{ name: 'exponent', type: 'float' },
+	]
 } );
 
 
 
-var supersphere = TSLFn( ( params )=>{
+var supersphereRaw = Fn( ([ exponent ])=>{
 
-	params = prepare( params, defaults );
-
-	return surfacePos( positionGeometry, params );
-
-}, defaults );
+	return surfacePos( positionGeometry, exponent );
 
+} ).setLayout( {
+	name: 'supersphereRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'exponent', type: 'float' },
+	]
+} );
 
 
-supersphere.normal = TSLFn( ( params ) => {
 
-	params = prepare( params, defaults );
+var supersphereNormalRaw = Fn( ([ exponent ]) => {
 
-	var eps = 0.01;
+	const EPS = 0.01;
 
 	var position = positionGeometry,
 		normal = normalLocal.normalize().toVar(),
-		tangent = tangentLocal.normalize().mul( eps ).toVar(),
-		bitangent = cross( normal, tangent ).normalize().mul( eps ).toVar();
+		tangent = tangentLocal.normalize().mul( EPS ).toVar(),
+		bitangent = cross( normal, tangent ).normalize().mul( EPS ).toVar();
+
+	var pos = surfacePos( position, exponent );
+	var posU = surfacePos( position.add( tangent ), exponent );
+	var posV = surfacePos( position.add( bitangent ), exponent );
+
+	return approximateNormal( pos, posU, posV );
+
+} ).setLayout( {
+	name: 'supersphereRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'exponent', type: 'float' },
+	]
+} );
+
+
+
+function supersphere( params={} ) {
 
-	var pos = surfacePos( position, params );
-	var posU = surfacePos( position.add( tangent ), params );
-	var posV = surfacePos( position.add( bitangent ), params );
+	var { exponent } = { ...defaults, ...params };
+
+	return supersphereRaw( exponent );
+
+}
+
+
+
+supersphere.normal = function ( params={} ) {
+
+	var { exponent } = { ...defaults, ...params };
+
+	return supersphereNormalRaw( exponent );
+
+};
 
-	var dU = sub( posU, pos ),
-		dV = sub( posV, pos );
 
-	return transformNormalToView( cross( dU, dV ).normalize() );
 
-}, defaults );
+supersphere.defaults = defaults;