@dailies-studio/tsl-textures 3.0.4

package/src/neon-lights.js

@@ -0,0 +1,107 @@
+
+//	TSL-Textures: Neon Lights
+
+
+
+import { Color } from "three";
+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',
+
+	position: positionGeometry,
+
+	scale: 2,
+	thinness: 0.8,
+	mode: 0, // 0=additive, 1=subtractive
+
+	colorA: new Color( 0xFF0000 ),
+	colorB: new Color( 0x00FF00 ),
+	colorC: new Color( 0x0000FF ),
+	background: new Color( 0x000000 ),
+
+	seed: 0,
+};
+
+
+
+var neonLightsRaw = Fn( ([ position, scale, thinness, mode, colorA, colorB, colorC, background, seed ]) => {
+
+	var pos = position;
+
+	var xscale = exp( scale.remap( 0, 4, -2, 2 ) ).toVar();
+	var xthinness = exp( thinness.remap( 0, 1, 1.5, 0 ) ).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( xscale ).add( seed ) ).toVar();
+	k.assign( oneMinus( sqrt( abs( k ) ) ).pow( 3 ) );
+
+	neon.assign( colorA );
+	var HSL = toHsl( neon );
+	neon.assign( hsl( vec3( HSL.xy, HSL.z.mul( k ) ) ) );
+
+	color.addAssign( select( mode.equal( 0 ), neon, neon.negate() ).mul( xthinness ) );
+
+	k.assign( noise( vec3( y, z, x ).mul( xscale ).sub( seed ) ) );
+	k.assign( oneMinus( sqrt( abs( k ) ) ).pow( 3 ) );
+
+	neon.assign( colorB );
+	var HSL = toHsl( neon );
+	neon.assign( hsl( vec3( HSL.xy, HSL.z.mul( k ) ) ) );
+
+	color.addAssign( select( mode.equal( 0 ), neon, neon.negate() ).mul( xthinness ) );
+
+
+	k.assign( noise( vec3( z, x, y.negate() ).mul( xscale ).add( seed ) ) );
+	k.assign( oneMinus( sqrt( abs( k ) ) ).pow( 3 ) );
+
+	neon.assign( colorC );
+	var HSL = toHsl( neon );
+	neon.assign( hsl( vec3( HSL.xy, HSL.z.mul( k ) ) ) );
+
+	color.addAssign( select( mode.equal( 0 ), neon, neon.negate() ).mul( xthinness ) );
+
+	return color;
+
+} ).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;
+
+
+
+export { neonLights };

package/src/perlin-noise.js

@@ -0,0 +1,66 @@
+
+//	TSL-Textures: Perlin Noise
+
+
+
+import { Color } from "three";
+import { clamp, exp, Fn, mix, positionGeometry } from 'three/tsl';
+import { noise } from './tsl-utils.js';
+
+
+
+var defaults = {
+	$name: 'Perlin noise',
+
+	position: positionGeometry,
+	scale: 2,
+	balance: 0,
+	contrast: 0,
+
+	color: new Color( 0xFFFFFF ),
+	background: new Color( 0x000000 ),
+
+	seed: 0,
+};
+
+
+
+var perlinNoiseRaw = Fn( ([ position, scale, balance, contrast, color, background, seed ]) => {
+
+	var pos = position.mul( exp( scale ) ).add( seed );
+
+	var k = noise( pos ).mul( 0.5, exp( contrast ) ).add( 0.5, balance ).min( 1 );
+
+	return mix( background, color, k );
+
+} ).setLayout( {
+	name: 'perlinNoiseRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'balance', type: 'float' },
+		{ name: 'contrast', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function perlinNoise( params={} ) {
+
+	var { position, scale, balance, contrast, color, background, seed } = { ...defaults, ...params };
+
+	return perlinNoiseRaw( position, scale, balance, contrast, color, background, seed );
+
+}
+
+
+
+perlinNoise.defaults = defaults;
+
+
+
+export { perlinNoise };

package/src/photosphere.js

@@ -0,0 +1,73 @@
+
+//	TSL-Textures: Photosphere
+
+
+
+import { Color } from "three";
+import { exp, Fn, Loop, mix, positionGeometry, rotate, vec3 } from 'three/tsl';
+import { noise } from './tsl-utils.js';
+
+
+
+var defaults = {
+	$name: 'Photosphere',
+
+	position: positionGeometry,
+	scale: 2,
+
+	color: new Color( 0xFFFF00 ),
+	background: new Color( 0xFF0000 ),
+
+	seed: 0,
+};
+
+
+
+var photosphereRaw = Fn( ([ position, scale, color, background, seed ]) => {
+
+	var xscale = exp( scale.add( 1 ) ).toVar( );
+	var pos = position.toVar( );
+
+	var vec = vec3( pos ).toVar();
+
+	Loop( 6, () => {
+
+		vec.assign( rotate( vec, pos.mul( xscale ) ) );
+		xscale.mulAssign( seed.mul( xscale ).sin().mul( 0.05 ).add( 1.1 ) );
+
+	} );
+
+
+	var k = noise( vec ).add( 1 ).div( 2 );
+
+	return mix( background, color, k );
+
+} ).setLayout( {
+	name: 'photosphereRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function photosphere( params={} ) {
+
+	var { position, scale, color, background, seed } = { ...defaults, ...params };
+
+	return photosphereRaw( position, scale, color, background, seed );
+
+}
+
+
+
+photosphere.defaults = defaults;
+
+
+
+export { photosphere };

package/src/planet.js

@@ -0,0 +1,168 @@
+
+//	TSL-Textures: Planet
+
+
+
+import { Color } from 'three';
+import { exp, float, Fn, If, Loop, mix, mul, positionGeometry, remap, smoothstep, vec3 } from 'three/tsl';
+import { noise } from './tsl-utils.js';
+
+
+
+
+var defaults = {
+	$name: 'Planet',
+
+	position: positionGeometry,
+	scale: 2,
+
+	iterations: 5,
+
+	levelSea: 0.3,
+	levelMountain: 0.7,
+
+	balanceWater: 0.3,
+	balanceSand: 0.2,
+	balanceSnow: 0.8,
+
+	colorDeep: new Color( 0x123a59 ).convertLinearToSRGB(), // SteelBlue
+	colorShallow: new Color( 0x87CEEB ).convertLinearToSRGB(), // SkyBlue
+	colorBeach: new Color( 0xFFFACD ).convertLinearToSRGB(), // LemonChiffon
+	colorGrass: new Color( 0x3CB371 ).convertLinearToSRGB(), // MediumSeaGreen
+	colorForest: new Color( 0x003000 ).convertLinearToSRGB(), // Dark green
+	colorSnow: new Color( 0xF0FFFF ).convertLinearToSRGB(), // Azure
+
+	seed: 0,
+};
+
+
+
+var planetRaw = Fn( ([ position, scale, iterations, levelSea, levelMountain, balanceWater, balanceSand, balanceSnow, colorDeep, colorShallow, colorBeach, colorGrass, colorForest, colorSnow, seed ])=>{
+
+	var k = float( 0 ).toVar(),
+		sum = float( 0 ).toVar(),
+		xscale = exp( scale.sub( 2 ) ).toVar(),
+		xpower = float( 2 ).toVar();
+
+	Loop( iterations.add( 10 ), ()=>{
+
+		k.addAssign( mul( xpower, noise( position.mul( xscale ).add( seed ) ) ) );
+		sum.addAssign( xpower );
+		xscale.mulAssign( 1.5 );
+		xpower.mulAssign( 0.8 );
+
+	} );
+
+	k.assign( mul( k, k, 0.5 ).div( sum ) );
+
+	var levelSea = levelSea.pow( 2 ).toVar();
+	var levelMountain = levelMountain.pow( 2 ).toVar();
+	var levelSand = mix( levelSea, levelMountain, balanceSand ).toVar();
+	var levelCoast = mix( levelSea, levelSand, 0.4 ).toVar();
+	var levelGrass = mix( levelSea, levelSand, 0.6 ).toVar();
+
+	var color = vec3().toVar();
+
+	// process water
+	If( k.lessThan( levelSea ), ()=>{
+
+		// deep-shallow
+		color.assign( mix(
+			colorDeep,
+			colorShallow,
+			remap( k, 0, levelSea, 0, 1 ).pow( exp( balanceWater.mul( -8 ).add( 4 ) ) )
+		) );
+
+	} )
+		.ElseIf( k.lessThan( levelCoast ), ()=>{
+
+			// shallow-sand
+			color.assign( mix(
+				colorShallow,
+				colorBeach,
+				remap( k, levelSea, levelCoast )
+			) );
+
+		} )
+		.ElseIf( k.lessThan( levelGrass ), ()=>{
+
+			// sand
+			color.assign( colorBeach );
+
+		} )
+		.ElseIf( k.lessThan( levelSand ), ()=>{
+
+			// shallow-sand-grass
+			color.assign( mix(
+				colorBeach,
+				colorGrass,
+				remap( k, levelGrass, levelSand )
+			) );
+
+		} )
+		.ElseIf( k.lessThan( levelMountain ), ()=>{
+
+			// grass-forest
+			color.assign( mix(
+				colorGrass,
+				colorForest,
+				remap( k, levelSand, levelMountain ).pow( 0.75 )
+			) );
+
+		} )
+		.Else( ()=>{
+
+			// forest-snow
+			var levelSnow = mix( 1, levelMountain, balanceSnow );
+			color.assign( mix(
+				colorForest,
+				colorSnow,
+				smoothstep( mix( levelSnow, levelMountain, balanceSnow.pow( 0.5 ) ), levelSnow, k )
+			) );
+
+		} );
+
+	return color;
+
+} ).setLayout( {
+	name: 'planetRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+
+		{ name: 'iterations', type: 'int' },
+		{ name: 'levelSea', type: 'float' },
+		{ name: 'levelMountain', type: 'float' },
+		{ name: 'balanceWater', type: 'float' },
+		{ name: 'balanceSand', type: 'float' },
+		{ name: 'balanceSnow', type: 'float' },
+
+		{ name: 'colorDeep', type: 'vec3' },
+		{ name: 'colorShallow', type: 'vec3' },
+		{ name: 'colorBeach', type: 'vec3' },
+		{ name: 'colorGrass', type: 'vec3' },
+		{ name: 'colorForest', type: 'vec3' },
+		{ name: 'colorSnow', type: 'vec3' },
+
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function planet( params={} ) {
+
+	var { position, scale, iterations, levelSea, levelMountain, balanceWater, balanceSand, balanceSnow, colorDeep, colorShallow, colorBeach, colorGrass, colorForest, colorSnow, seed } = { ...defaults, ...params };
+
+	return planetRaw( position, scale, iterations, levelSea, levelMountain, balanceWater, balanceSand, balanceSnow, colorDeep, colorShallow, colorBeach, colorGrass, colorForest, colorSnow, seed );
+
+}
+
+
+
+planet.defaults = defaults;
+
+
+
+export { planet };

package/src/polka-dots.js

@@ -0,0 +1,106 @@
+
+//	TSL-Textures: Polka Dots
+
+
+
+import { Color } from "three";
+import { acos, add, distance, exp, float, Fn, If, Loop, mat2, max, min, mix, mod, mul, oneMinus, positionGeometry, pow, smoothstep, } from 'three/tsl';
+import { spherical } from './tsl-utils.js';
+
+
+
+var defaults = {
+	$name: 'Polka dots',
+
+	position: positionGeometry,
+	count: 2,
+	size: 0.5,
+	blur: 0.25,
+
+	color: new Color( 0x000000 ),
+	background: new Color( 0xFFFFFF ),
+
+	flat: 0,
+};
+
+
+
+var goldenRatio = ( 1+5**0.5 )/2;
+
+
+
+var polkaDotsRaw = Fn( ([ position, count, size, blur, color, background, xflat ]) => {
+
+	var dist = float( 1 ).toVar();
+
+	If( xflat.equal( 1 ), ()=>{
+
+		var cnt = count.pow( 2 ).sub( 0.5 ).toVar();
+		var pos = position.xy.mul( cnt ).mul( mat2( 1, 1, -1, 1 ) );
+		var posTo = pos.round().toVar();
+
+		dist.assign( pos.distance( posTo ).div( cnt ) );
+
+	} ).Else( ()=>{
+
+		var cnt = pow( 10, count ).toVar();
+		var vec = position.normalize().toVar();
+
+		var besti = oneMinus( vec.y ).mul( cnt ).sub( 1 ).div( 2 );
+
+		var span = max( 10, cnt.pow( 0.5 ) );
+
+		var mini = besti.sub( span ).floor().clamp( 0, cnt );
+		var maxi = besti.add( span ).floor().clamp( 0, cnt );
+
+		dist.assign( 1 ).toVar();
+
+		Loop( maxi.sub( mini ), ( { i } )=> {
+
+			var j = add( i, mini );
+			var theta = mod( mul( 2*Math.PI/goldenRatio, j ), 2*Math.PI );
+			var phi = acos( oneMinus( float( j ).mul( 2 ).add( 1 ).div( cnt ) ) );
+			var pnt = spherical( phi, theta );//.normalize();
+			dist.assign( min( dist, distance( vec, pnt ) ) );
+
+		} ); // Loop
+
+	} ); // Else
+
+	var xsize = exp( size.mul( 5 ).sub( 5 ) ).toVar();
+	var xblur = blur.pow( 4 ).toVar();
+	var k = smoothstep( xsize.sub( xblur ), xsize.add( xblur ), dist );
+
+	return mix( color, background, k );
+
+} ).setLayout( {
+	name: 'polkaDotsRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'count', type: 'float' },
+		{ name: 'size', type: 'float' },
+		{ name: 'blur', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'xflat', type: 'int' },
+	] }
+);
+
+
+
+function polkaDots( params={} ) {
+
+	var { position, count, size, blur, color, background, flat } = { ...defaults, ...params };
+
+	return polkaDotsRaw( position, count, size, blur, color, background, flat );
+
+}
+
+
+
+polkaDots.defaults = defaults;
+
+
+
+export { polkaDots };

package/src/processed-wood.js

@@ -0,0 +1,80 @@
+
+//	TSL-Textures: Processed wood
+
+
+
+import { Color } from "three";
+import { add, cos, exp, Fn, mix, positionGeometry, radians, sin, sub, vec3 } from 'three/tsl';
+import { noise } from './tsl-utils.js';
+
+
+
+var defaults = {
+	$name: 'Processed wood',
+	$width: 260,
+
+	position: positionGeometry,
+	scale: 2,
+	lengths: 4,
+	strength: 0.3,
+	angle: 0,
+
+	color: new Color( 0x702020 ),
+	background: new Color( 0xF0D0A0 ),
+
+	seed: 0,
+};
+
+
+
+var processedWoodRaw = Fn( ([ position, scale, lengths, strength, angle, color, background, seed ])=>{
+
+	var angle = radians( angle ).toVar();
+	var posLocal = vec3(
+		sub( position.x.mul( cos( angle ) ), position.y.mul( sin( angle ) ) ),
+		add( position.x.mul( sin( angle ) ), position.y.mul( cos( angle ) ) ),
+		position.z,
+	).toVar();
+
+	var xscale = scale.div( 2 ).add( 1 ).toVar();
+	var pos = posLocal.mul( exp( scale ) ).add( seed ).toVar( );
+
+	var len = lengths.add( 5 ).reciprocal().toVar();
+	var k = noise( pos.mul( xscale, vec3( 1, len, len ) ) );
+	k = k.mul( noise( pos.mul( vec3( 25, 1, 1 ) ) ).add( -1 ).mul( 0.2 ) );
+	k = k.add( strength.sub( 0.5 ) ).smoothstep( -0.3, 0.3 ).oneMinus();
+
+	return mix( color, background, k );
+
+} ).setLayout( {
+	name: 'processedWoodRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'lengths', type: 'float' },
+		{ name: 'strength', type: 'float' },
+		{ name: 'angle', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function processedWood( params={} ) {
+
+	var { position, scale, lengths, strength, angle, color, background, seed } = { ...defaults, ...params };
+
+	return processedWoodRaw( position, scale, lengths, strength, angle, color, background, seed );
+
+}
+
+
+
+processedWood.defaults = defaults;
+
+
+
+export { processedWood };

package/src/protozoa.js

@@ -0,0 +1,110 @@
+
+//	TSL-Textures: Protozoa
+
+
+
+import { Color } from "three";
+import { exp, float, Fn, Loop, matcapUV, mix, positionGeometry, vec3 } from 'three/tsl';
+import { noise } from './tsl-utils.js';
+
+
+
+var defaults = {
+	$name: 'Protozoa',
+
+	position: positionGeometry,
+	matcap: matcapUV,
+	scale: 1.5,
+	fat: 0.7,
+	amount: 0.4,
+
+	color: new Color( 0xA0A0A0 ),
+	subcolor: new Color( 0xE0E8FF ),
+	background: new Color( 0xF0F8FF ),
+
+	seed: 0,
+};
+
+
+
+var pnoise = Fn( ([ pos, fat ])=>{
+
+	return noise( pos ).mul( fat ).clamp( -3.14, 3.14 ).cos().add( 1 ).div( 2 );
+
+} ).setLayout( {
+	name: 'pnoise',
+	type: 'float',
+	inputs: [
+		{ name: 'pos', type: 'vec3' },
+		{ name: 'fat', type: 'float' },
+	] }
+);
+
+
+
+var protozoaRaw = Fn( ([ position, matcap, scale, fat, amount, color, subcolor, background, seed ])=>{
+
+	var pos = position.mul( exp( scale.sub( 1 ) ) ).add( seed ).toVar( );
+
+	var xmatcap = vec3( matcap, matcap.length() ).toVar();
+
+	var rings1 = float( 0 ).toVar();
+	var rings2 = float( 0 ).toVar();
+
+	var n1 = float( 0 ).toVar();
+	var n2 = float( 0 ).toVar();
+
+	var fat = fat.add( 0.2 ).oneMinus().mul( 60 ).add( 30 ).toVar();
+	var xscale = float( 2 ).toVar();
+
+	var dPos = amount.div( 2 ).add( 0.5 ).exp().toVar();
+
+	Loop( 10, ()=>{
+
+		rings1.assign( pnoise( pos.xyz.add( xmatcap ), fat ) );
+		rings2.assign( pnoise( pos.yzx.add( xmatcap ), fat ) );
+
+		n1.addAssign( rings1.mul( rings2 ).mul( xscale ) );
+		n2.addAssign( rings1.max( rings2 ).mul( xscale ) );
+
+		pos.assign( mix( pos.mul( dPos ), 0, 0.4 ) );
+
+		xscale.mulAssign( 0.9 );
+
+	} );
+
+	return mix( background, mix( color, subcolor, n2.mul( 0.1 ) ), n1 );
+
+} ).setLayout( {
+	name: 'protozoaRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'matcap', type: 'vec2' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'fat', type: 'float' },
+		{ name: 'amount', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'subcolor', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function protozoa( params={} ) {
+
+	var { position, matcap, scale, fat, amount, color, subcolor, background, seed } = { ...defaults, ...params };
+
+	return protozoaRaw( position, matcap, scale, fat, amount, color, subcolor, background, seed );
+
+}
+
+
+
+protozoa.defaults = defaults;
+
+
+
+export { protozoa };