tsl-textures 2.5.1 → 3.0.1

package/src/gas-giant.js

@@ -4,14 +4,15 @@
 
 
 import { Color } from "three";
-import { exp, mix, positionGeometry, vec3 } from 'three/tsl';
-import { hsl, noise, prepare, toHsl, TSLFn } from './tsl-utils.js';
+import { exp, Fn, mix, positionGeometry, vec3 } from 'three/tsl';
+import { hsl, noise, toHsl } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Gas giant',
 
+	position: positionGeometry,
 	scale: 2,
 	turbulence: 0.3,
 	blur: 0.6,
@@ -25,15 +26,13 @@ var defaults = {
 
 
 
-var gasGiant = TSLFn( ( params )=>{
+var gasGiantRaw = Fn( ([ position, scale, turbulence, blur, colorA, colorB, colorC, seed ])=>{
 
-	params = prepare( params, defaults );
-
-	var scale = params.scale.div( 2 ).add( 1 ).toVar();
-	var pos = positionGeometry.mul( exp( scale ) ).add( params.seed ).toVar( );
+	var xscale = scale.div( 2 ).add( 1 ).toVar();
+	var pos = position.mul( exp( xscale ) ).add( seed ).toVar( );
 
 	// turbulence strength
-	var turbulence = params.turbulence.mul(
+	var xturbulence = turbulence.mul(
 		noise( vec3( 0, pos.y.mul( 0.5 ), 0 ).add( 1 ) ).add(
 			noise( vec3( 0, pos.y.mul( 1 ), 0 ).add( 1 ) ).mul( 0.5 ),
 			noise( vec3( 1, pos.y.mul( 2 ), 1 ).add( 1 ) ).mul( 0.25 )
@@ -43,25 +42,52 @@ var gasGiant = TSLFn( ( params )=>{
 	var spot = noise( pos.div( 4 ) ).add( 1 ).div( 2 ).pow( 10 ).mul( 10 ).smoothstep( 0, 1 );
 
 	// apply turbulence
-	pos.addAssign( vec3( noise( pos ), noise( pos.yxz ), noise( pos.yzx ) ).mul( turbulence.mul( spot.mul( 2 ).exp() ) ) );
+	pos.addAssign( vec3( noise( pos ), noise( pos.yxz ), noise( pos.yzx ) ).mul( xturbulence.mul( spot.mul( 2 ).exp() ) ) );
 
 
-	var blur = params.blur.pow( 0.2 ).oneMinus().mul( turbulence.add( 1 ) ).toVar();
+	var xblur = blur.pow( 0.2 ).oneMinus().mul( xturbulence.add( 1 ) ).toVar();
 
-	var k = noise( pos.mul( vec3( 0, scale, 0 ) ) );
-	k = k.add( noise( pos.mul( vec3( 1, 15, 1 ) ) ).mul( blur ) );
+	var k = noise( pos.mul( vec3( 0, xscale, 0 ) ) );
+	k = k.add( noise( pos.mul( vec3( 1, 15, 1 ) ) ).mul( xblur ) );
 	k = k.add( -0.5 ).smoothstep( -1, 1 ).oneMinus();
 
 	var n = noise( vec3( 0, pos.y.mul( 0.75 ), 0 ) ).add( 1 );
 
-	var HSL = toHsl( mix( params.colorB, params.colorA, n ) );
-	var color = hsl( HSL.x.add( noise( pos.mul( vec3( 0, scale, 0 ) ) ).div( 4 ) ), HSL.y, HSL.z ).toVar();
+	var HSL = toHsl( mix( colorB, colorA, n ) );
+	var color = hsl( vec3( HSL.x.add( noise( pos.mul( vec3( 0, xscale, 0 ) ) ).div( 4 ) ), HSL.yz ) ).toVar();
 
-	color.assign( mix( color, params.colorC, turbulence.mul( 0.3 ) ) );
+	color.assign( mix( color, colorC, xturbulence.mul( 0.3 ) ) );
 
 	return color.mul( k );
 
-}, defaults );
+} ).setLayout( {
+	name: 'gasGiantRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'turbulence', type: 'float' },
+		{ name: 'blur', type: 'float' },
+		{ name: 'colorA', type: 'vec3' },
+		{ name: 'colorB', type: 'vec3' },
+		{ name: 'colorC', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function gasGiant( params={} ) {
+
+	var { position, scale, turbulence, blur, colorA, colorB, colorC, seed } = { ...defaults, ...params };
+
+	return gasGiantRaw( position, scale, turbulence, blur, colorA, colorB, colorC, seed );
+
+}
+
+
+
+gasGiant.defaults = defaults;
 
 
 

package/src/grid.js

@@ -4,52 +4,80 @@
 
 
 import { Color } from "three";
-import { abs, add, div, equirectUV, min, mix, mul, oneMinus, positionGeometry, pow, remapClamp, round, screenSize, screenUV, select, sin, smoothstep, sub } from 'three/tsl';
-import { prepare, TSLFn } from './tsl-utils.js';
+import { abs, add, div, equirectUV, exp2, Fn, max, min, mix, mul, oneMinus, positionGeometry, pow, remapClamp, round, screenSize, screenUV, sin, smoothstep, sub } from 'three/tsl';
 
 
 
 var defaults = {
 	$name: 'Grid',
+	$replaceExportUVS: screenUV,
+	$replaceExportASP: screenSize.x.div( screenSize.y ).log2(),
+
+	uvs: equirectUV( positionGeometry.normalize() ),
 
 	countU: 32,
 	countV: 16,
 
+	aspect: 1,
 	thinness: 0.8,
+	equirectangular: true,
 
 	color: new Color( 0x000000 ),
 	background: new Color( 0xFFFFFF ),
 
-	flat: 0,
 };
 
 
 
-var grid = TSLFn( ( params ) => {
-
-	params = prepare( params, defaults );
+var gridRaw = Fn( ([ uvs, countU, countV, aspect, thinness, equirectangular, color, background ]) => {
 
-	var aspect = select( params.flat, screenSize.x.div( screenSize.y ), 2 );
+	var xaspect = max( exp2( aspect ), 1 );
 
-	var uv = select( params.flat, screenUV, equirectUV( positionGeometry.normalize() ) ).toVar(),
-		a = mul( uv.x, aspect, Math.PI ),
-		b = mul( uv.y, Math.PI ).toVar();
+	var a = mul( uvs.x, xaspect, Math.PI ).toVar(),
+		b = mul( uvs.y, Math.PI ).toVar();
 
-	var uTo = div( round( mul( uv.x, params.countU ) ), params.countU ),
-		vTo = div( round( mul( uv.y, params.countV ) ), params.countV ),
-		aTo = mul( uTo, aspect, Math.PI ),
+	var uTo = div( round( mul( uvs.x, countU ) ), countU ),
+		vTo = div( round( mul( uvs.y, countV ) ), countV ),
+		aTo = mul( uTo, xaspect, Math.PI ),
 		bTo = mul( vTo, Math.PI );
 
-	var angleU = abs( sub( a, aTo ) ).mul( select( params.flat, 1, sin( b ) ) ),
+	var angleU = abs( sub( a, aTo ) ).mul( mix( 1, sin( b ), equirectangular ) ),
 		angleV = abs( sub( b, bTo ) ),
 		angle = min( angleU, angleV );
 
-	var treshold = mul( min( div( aspect.mul( Math.PI ), params.countU ), div( Math.PI, params.countV ) ), remapClamp( pow( params.thinness, 0.5 ), 0, 1, 0.9, 0.04 ), 0.5 );
+	var treshold = mul( min( div( xaspect.mul( Math.PI ), countU ), div( Math.PI, countV ) ), remapClamp( pow( thinness, 0.5 ), 0, 1, 0.9, 0.04 ), 0.5 );
 	var k = oneMinus( smoothstep( sub( treshold, 0.002 ), add( treshold, 0.002 ), angle ) );
 
-	return mix( params.background, params.color, k );
+	return mix( background, color, k );
+
+} ).setLayout( {
+	name: 'gridRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'uvs', type: 'vec2' },
+		{ name: 'countU', type: 'float' },
+		{ name: 'countV', type: 'float' },
+		{ name: 'aspect', type: 'float' },
+		{ name: 'thinness', type: 'float' },
+		{ name: 'equirectangular', type: 'int' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+	] }
+);
+
+
+
+function grid( params={} ) {
+
+	var { uvs, countU, countV, aspect, thinness, equirectangular, color, background } = { ...defaults, ...params };
+
+	return gridRaw( uvs, countU, countV, aspect, thinness, equirectangular, color, background );
+
+}
+
+
 
-}, defaults );
+grid.defaults = defaults;
 
 
 

package/src/isolayers.js

@@ -4,14 +4,15 @@
 
 
 import { Color } from 'three';
-import { exp, float, mix, positionGeometry } from 'three/tsl';
-import { hsl, noise, prepare, toHsl, TSLFn } from './tsl-utils.js';
+import { exp, float, Fn, mix, positionGeometry } from 'three/tsl';
+import { hsl, noise, toHsl } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Isolayers',
 
+	position: positionGeometry,
 	scale: 2,
 	layers: 10,
 	edge: 0.5,
@@ -25,28 +26,53 @@ var defaults = {
 
 
 
-var isolayers = TSLFn( ( params )=>{
+var isolayersRaw = Fn( ([ position, scale, layers, edge, darkness, color, background, 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 depth = edge.remap( 0, 1, 40, 10 );
 
-	var depth = params.edge.remap( 0, 1, 40, 10 );
+	var k = noise( pos, 1.2, 1 ).div( 2 );
 
-	var k = noise( pos ).mul( 1.2 ).add( 1 ).div( 2 );
-
-	var i = k.mul( params.layers ).round().div( params.layers ).clamp( 0, 1 );
-	var f = k.sub( float( 0.5+0.03 ).div( params.layers ) )
-		.mul( params.layers ).fract()
+	var i = k.mul( layers ).round().div( layers ).clamp( 0, 1 );
+	var f = k.sub( float( 0.5+0.03 ).div( layers ) )
+		.mul( layers ).fract()
 		.mul( float( 2 ).pow( depth.reciprocal() ) )
 		.pow( depth ).sub( 1 ).abs().oneMinus();
 
-	var hslColor = mix( toHsl( params.background ), toHsl( params.color ), i ).toVar();
-	hslColor.z.mulAssign( mix( 1, i.mul( 1.5 ), params.darkness ).clamp( 0, 1 ) );
+	var hslColor = mix( toHsl( background ), toHsl( color ), i ).toVar();
+	hslColor.z.mulAssign( mix( 1, i.mul( 1.5 ), darkness ).clamp( 0, 1 ) );
+
+	return hsl( hslColor ).sub( f );
+
+} ).setLayout( {
+	name: 'isolayersRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'layers', type: 'int' },
+		{ name: 'edge', type: 'float' },
+		{ name: 'darkness', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function isolayers( params={} ) {
+
+	var { position, scale, layers, edge, darkness, color, background, seed } = { ...defaults, ...params };
+
+	return isolayersRaw( position, scale, layers, edge, darkness, color, background, seed );
+
+}
+
 
-	return hsl( hslColor.x, hslColor.y, hslColor.z ).sub( f );
 
-}, defaults );
+isolayers.defaults = defaults;
 
 
 

package/src/isolines.js

@@ -4,14 +4,15 @@
 
 
 import { Color } from "three";
-import { add, exp, mix, oneMinus, positionGeometry, sin, smoothstep, sub } from 'three/tsl';
-import { noise, prepare, TSLFn } from './tsl-utils.js';
+import { add, exp, Fn, mix, oneMinus, positionGeometry, sin, smoothstep, sub } from 'three/tsl';
+import { noise } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Isolines',
 
+	position: positionGeometry,
 	scale: 2,
 	density: 40,
 	blur: 0.3,
@@ -25,21 +26,46 @@ var defaults = {
 
 
 
-var isolines = TSLFn( ( params )=>{
+var isolinesRaw = Fn( ([ position, scale, density, blur, thinness, color, background, 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 = noise( pos ).mul( params.density );
+	var k = noise( pos, density );
 
 	k = oneMinus( sin( k ) ).div( 2 );
 
-	k = smoothstep( sub( params.thinness, params.blur ), add( params.thinness, params.blur ), k );
+	k = smoothstep( sub( thinness, blur ), add( thinness, blur ), k );
+
+	return mix( color, background, k );
+
+} ).setLayout( {
+	name: 'isolinesRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'density', type: 'float' },
+		{ name: 'blur', type: 'float' },
+		{ name: 'thinness', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function isolines( params={} ) {
+
+	var { position, scale, density, blur, thinness, color, background, seed } = { ...defaults, ...params };
+
+	return isolinesRaw( position, scale, density, blur, thinness, color, background, seed );
+
+}
+
 
-	return mix( params.color, params.background, k );
 
-}, defaults );
+isolines.defaults = defaults;
 
 
 

package/src/karst-rock.js

@@ -4,14 +4,15 @@
 
 
 import { Color } from "three";
-import { exp, mix, positionGeometry } from 'three/tsl';
-import { noise, prepare, TSLFn } from './tsl-utils.js';
+import { exp, Fn, mix, positionGeometry } from 'three/tsl';
+import { noise } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Karst rock',
 
+	position: positionGeometry,
 	scale: 2,
 
 	color: new Color( 0xFFF4F0 ),
@@ -22,11 +23,9 @@ var defaults = {
 
 
 
-var karstRock = TSLFn( ( params )=>{
+var karstRockRaw = Fn( ([ position, scale, color, background, seed ])=>{
 
-	params = prepare( params, defaults );
-
-	var pos = positionGeometry.mul( exp( params.scale ) ).add( params.seed.sin().mul( 5 ) ).toVar( );
+	var pos = position.mul( exp( scale ) ).add( seed.sin().mul( 5 ) ).toVar( );
 
 	var pos2 = pos.add( noise( pos.mul( 2 ) ) ).toVar();
 
@@ -35,9 +34,33 @@ var karstRock = TSLFn( ( params )=>{
 	k.addAssign( noise( pos.mul( 100 ) ).div( 3 ) );
 	k.addAssign( noise( pos.mul( 2 ) ).div( 2 ) );
 
-	return mix( params.background, params.color, k ).mul( k.pow( 0.1 ) );
+	return mix( background, color, k ).mul( k.pow( 0.1 ) );
+
+} ).setLayout( {
+	name: 'karstRockRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function karstRock( params={} ) {
+
+	var { position, scale, color, background, seed } = { ...defaults, ...params };
+
+	return karstRockRaw( position, scale, color, background, seed );
+
+}
+
+
 
-}, defaults );
+karstRock.defaults = defaults;
 
 
 

package/src/marble.js

@@ -4,14 +4,15 @@
 
 
 import { Color } from "three";
-import { add, div, exp, If, mix, mul, oneMinus, positionGeometry, pow } from 'three/tsl';
-import { noise, prepare, TSLFn } from './tsl-utils.js';
+import { add, div, exp, Fn, If, mix, mul, oneMinus, positionGeometry, pow } from 'three/tsl';
+import { noise } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Marble',
 
+	position: positionGeometry,
 	scale: 1.2,
 	thinness: 5,
 	noise: 0.3,
@@ -24,11 +25,9 @@ var defaults = {
 
 
 
-var marble = TSLFn( ( params ) => {
+var marbleRaw = Fn( ([ position, scale, thinness, xnoise, 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( );
 
 	var k = add(
 		noise( pos ),
@@ -38,8 +37,8 @@ var marble = TSLFn( ( params ) => {
 
 	var k = oneMinus( k.abs().pow( 2.5 ) ).toVar();
 
-	var	maxSmooth = oneMinus( pow( 0.5, params.thinness.add( 7 ) ) ).toVar(),
-		minSmooth = oneMinus( pow( 0.5, params.thinness.add( 7 ).mul( 0.5 ) ) ).toVar();
+	var	maxSmooth = oneMinus( pow( 0.5, thinness.add( 7 ) ) ).toVar(),
+		minSmooth = oneMinus( pow( 0.5, thinness.add( 7 ).mul( 0.5 ) ) ).toVar();
 
 	If( k.greaterThan( maxSmooth ), ()=>{
 
@@ -60,11 +59,37 @@ var marble = TSLFn( ( params ) => {
 
 		} );
 
-	k.assign( k.add( mul( params.noise, noise( pos.mul( 150 ) ).abs().pow3() ) ) );
+	k.assign( k.add( mul( xnoise, noise( pos.mul( 150 ) ).abs().pow3() ) ) );
+
+	return mix( background, color, k );
+
+} ).setLayout( {
+	name: 'marbleRaw',
+	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 marble( params={} ) {
+
+	var { position, scale, thinness, noise, color, background, seed } = { ...defaults, ...params };
+
+	return marbleRaw( position, scale, thinness, noise, color, background, seed );
+
+}
+
 
-	return mix( params.background, params.color, k );
 
-}, defaults );
+marble.defaults = defaults;
 
 
 

package/src/melter.js

@@ -11,7 +11,6 @@ import { matTrans, noise, prepare } from './tsl-utils.js';
 
 var surfacePos = Fn( ([ pos, params ])=>{
 
-	//var zone = selectPlanar( pos, params.selectorAngles, params.selectorCenter, params.selectorWidth );
 	var zone = float( 1 ).toVar();
 	var n = noise( pos.mul( 2 ) ).add( 1 ).div( 2 ); // noise factor
 	var k = params.distance.normalize().dot( normalLocal.normalize() ).max( 0 ).pow( 10 );

package/src/neon-lights.js

@@ -4,15 +4,17 @@
 
 
 import { Color } from "three";
-import { abs, exp, oneMinus, positionGeometry, select, sqrt, vec3 } from 'three/tsl';
-import { hsl, noise, prepare, toHsl, TSLFn } from './tsl-utils.js';
+import { abs, exp, Fn, oneMinus, positionGeometry, select, sqrt, vec3 } from 'three/tsl';
+import { hsl, noise, toHsl } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Neon Lights',
 
-	scale: 1.5,
+	position: positionGeometry,
+
+	scale: 2,
 	thinness: 0.8,
 	mode: 0, // 0=additive, 1=subtractive
 
@@ -26,53 +28,79 @@ var defaults = {
 
 
 
-var neonLights = TSLFn( ( params ) => {
-
-	params = prepare( params, defaults );
+var neonLightsRaw = Fn( ([ position, scale, thinness, mode, colorA, colorB, colorC, background, seed ]) => {
 
-	var pos = positionGeometry;//.mul( exp( params.scale ) ).add( params.seed ).toVar( );
+	var pos = position;
 
-	var scale = exp( params.scale.remap( 0, 4, 2, -2 ) ).toVar();
-	var thinness = exp( params.thinness.remap( 0, 1, 1.5, 0 ) ).toVar();
+	var xscale = exp( scale.remap( 0, 4, -2, 2 ) ).toVar();
+	var xthinness = exp( thinness.remap( 0, 1, 1.5, 0 ) ).toVar();
 
-	var color = params.background.toVar();
+	var color = background.toVar();
 	var neon = vec3( 0 ).toVar();
 
 	var x = noise( pos.xyz ).toVar();
 	var y = noise( pos.yzx ).toVar();
 	var z = noise( pos.zxy ).toVar();
 
-	var k = noise( vec3( x, y, z ).mul( scale ).add( params.seed ) ).toVar();
+	var k = noise( vec3( x, y, z ).mul( xscale ).add( seed ) ).toVar();
 	k.assign( oneMinus( sqrt( abs( k ) ) ).pow( 3 ) );
 
-	neon.assign( params.colorA );
+	neon.assign( colorA );
 	var HSL = toHsl( neon );
-	neon.assign( hsl( HSL.x, HSL.y, HSL.z.mul( k ) ) );
+	neon.assign( hsl( vec3( HSL.xy, HSL.z.mul( k ) ) ) );
 
-	color.addAssign( select( params.mode.equal( 0 ), neon, neon.negate() ).mul( thinness ) );
+	color.addAssign( select( mode.equal( 0 ), neon, neon.negate() ).mul( xthinness ) );
 
-	k.assign( noise( vec3( y, z, x ).mul( scale ).sub( params.seed ) ) );
+	k.assign( noise( vec3( y, z, x ).mul( xscale ).sub( seed ) ) );
 	k.assign( oneMinus( sqrt( abs( k ) ) ).pow( 3 ) );
 
-	neon.assign( params.colorB );
+	neon.assign( colorB );
 	var HSL = toHsl( neon );
-	neon.assign( hsl( HSL.x, HSL.y, HSL.z.mul( k ) ) );
+	neon.assign( hsl( vec3( HSL.xy, HSL.z.mul( k ) ) ) );
 
-	color.addAssign( select( params.mode.equal( 0 ), neon, neon.negate() ).mul( thinness ) );
+	color.addAssign( select( mode.equal( 0 ), neon, neon.negate() ).mul( xthinness ) );
 
 
-	k.assign( noise( vec3( z, x, y.negate() ).mul( scale ).add( params.seed ) ) );
+	k.assign( noise( vec3( z, x, y.negate() ).mul( xscale ).add( seed ) ) );
 	k.assign( oneMinus( sqrt( abs( k ) ) ).pow( 3 ) );
 
-	neon.assign( params.colorC );
+	neon.assign( colorC );
 	var HSL = toHsl( neon );
-	neon.assign( hsl( HSL.x, HSL.y, HSL.z.mul( k ) ) );
+	neon.assign( hsl( vec3( HSL.xy, HSL.z.mul( k ) ) ) );
 
-	color.addAssign( select( params.mode.equal( 0 ), neon, neon.negate() ).mul( thinness ) );
+	color.addAssign( select( mode.equal( 0 ), neon, neon.negate() ).mul( xthinness ) );
 
 	return color;
 
-}, defaults );
+} ).setLayout( {
+	name: 'neonLightsRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'thinness', type: 'float' },
+		{ name: 'node', type: 'float' },
+		{ name: 'colorA', type: 'vec3' },
+		{ name: 'colorB', type: 'vec3' },
+		{ name: 'colorC', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function neonLights( params={} ) {
+
+	var { position, scale, thinness, mode, colorA, colorB, colorC, background, seed } = { ...defaults, ...params };
+
+	return neonLightsRaw( position, scale, thinness, mode, colorA, colorB, colorC, background, seed );
+
+}
+
+
+
+neonLights.defaults = defaults;