@dailies-studio/tsl-textures 3.0.4

package/src/cave-art.js

@@ -0,0 +1,83 @@
+
+//	TSL-Textures: Cave Art
+
+
+
+import { Color } from "three";
+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,
+
+	color: new Color( 0xD34545 ),
+	background: new Color( 0xFFF8F0 ),
+
+	seed: 0,
+};
+
+
+
+var caveArtRaw = Fn( ([ position, scale, thinness, xnoise, color, background, seed ]) => {
+
+	var pos = position.mul( scale.exp( ) ).add( seed ).toVar( 'pos' );
+
+	thinness = float( 3 ).sub( thinness ).exp( );
+
+	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 ) ), ()=>{
+
+		k.assign( 0 );
+
+	} );
+
+	If( k.lessThanEqual( 0 ), ()=>{
+
+		k.assign( xnoise.mul( noise( pos.mul( 30 ) ).pow2( ) ) );
+
+	} );
+
+	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 );
+
+}
+
+
+
+caveArt.defaults = defaults;
+
+
+
+export { caveArt };

package/src/circle-decor.js

@@ -0,0 +1,76 @@
+
+//	TSL-Textures: Circle decor
+
+
+
+import { Color } from 'three';
+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,
+
+	complexity: 1,
+	blur: 0.2,
+
+	color: new Color( 0x0 ),
+	background: new Color( 0xFFFFFF ),
+
+	seed: 0,
+};
+
+
+
+var circleDecorRaw = Fn( ([ position, scale, grains, complexity, blur, color, background, seed ])=>{
+
+	var pos = position.mul( exp( scale.div( 4 ) ) ).add( seed ).toVar( 'pos' );
+	var subpos = pos.mul( 2 ).toVar( 'subpos' );
+
+	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( 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 );
+
+}
+
+
+
+circleDecor.defaults = defaults;
+
+
+
+export { circleDecor };

package/src/circles.js

@@ -0,0 +1,83 @@
+
+//	TSL-Textures: Circles
+
+
+
+import { Color } from "three";
+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 ),
+
+	seed: 0,
+};
+
+
+
+var circlesRaw = Fn( ([ position, scale, variety, color, seed ]) => {
+
+	var pos = position.toVar();
+
+	var angle = acos( clamp( pos.y, -1, 1 ) ).mul( 20 );
+
+	var x = angle.div( 3000 ).mul( exp( scale.sub( 1 ) ) );
+
+	var k = seed.sin().mul( 100 ).toVar();
+
+	for ( var n=0; n<=10; n++ ) {
+
+		k.addAssign( sin( x.mul( 2**n ).sub( Math.PI*n/2 ) ).mul( -n*( n+1 )/2 ) );
+
+	}
+
+	k.assign( k.div( 200 ).clamp( -2, 2 ) );
+
+	var HSL = toHsl( color );
+
+	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( 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 );
+
+}
+
+
+
+circles.defaults = defaults;
+
+
+
+export { circles };

package/src/clouds.js

@@ -0,0 +1,114 @@
+
+//	TSL-Textures: Clouds
+
+
+
+import { Color } from "three";
+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,
+
+	color: new Color( 0xFFFFFF ),
+	subcolor: new Color( 0xA0A0B0 ),
+
+	seed: 0,
+};
+
+
+
+var cloud_core = Fn( ([ position, scale, density, seed ]) => {
+
+	const pos = position.mul( exp( scale.div( 1.5 ).sub( 0.5 ) ) ).add( seed ).toVar( 'pos' );
+
+	return fractal( pos, 4 ).add( density.remap( 0, 1, -0.5, 1.5 ) );
+
+} ).setLayout( {
+	name: 'cloud_core',
+	type: 'float',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'density', type: 'float' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+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 ) );
+
+
+} ).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' },
+	] }
+);
+
+
+
+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 ) );
+
+} ).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' },
+	] }
+);
+
+
+
+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;
+
+
+
+export { clouds };

package/src/concrete.js

@@ -0,0 +1,95 @@
+
+// TSL-Textures: Concrete
+
+
+
+import { cross, exp, Fn, normalLocal, positionGeometry, remap, tangentLocal, vec3 } from 'three/tsl';
+import { approximateNormal, noise } from './tsl-utils.js';
+
+
+
+var defaults = {
+	$name: 'Concrete',
+	$normalNode: true,
+
+	position: positionGeometry,
+
+	scale: 2,
+	density: 0.5,
+	bump: 0.5,
+
+	seed: 0,
+};
+
+
+
+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' );
+
+	xnormal.mulAssign( bump );
+
+	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' },
+	] }
+);
+
+
+
+function concrete( params={} ) {
+
+	var { position, scale, density, bump, seed } = { ...defaults, ...params };
+
+	return concreteRaw( position, normalLocal, tangentLocal, scale, density, bump, seed );
+
+}
+
+
+
+concrete.defaults = defaults;
+
+
+
+export { concrete };

package/src/cork.js

@@ -0,0 +1,104 @@
+
+//	TSL-Textures: Cork
+
+
+
+import { Color } from 'three';
+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,
+
+	color: new Color( 0xfff0c0 ),
+	background: new Color( 0xd08060 ),
+
+	seed: 0,
+};
+
+
+
+var corkRaw = Fn( ([ position, scale, straight, xnoise, color, background, seed ])=>{
+
+	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 cell = vec3().toVar( 'cell' ),
+		dist = float().toVar( 'dist' );
+
+	var strtaightness = straight.exp().reciprocal().toVar( 'strtaightness' );
+
+	var i=int( 0 ).toVar( 'i' ),
+		j=int( 0 ).toVar( 'j' ),
+		k=int( 0 ).toVar( 'k' );
+
+	// Loop uses hard-coded i, j, k as indices
+	Loop( 3, 3, 3, () => {
+
+		cell.assign( midCell.add( vec3( i, j, k ).sub( 1 ) ) );
+		var cellCenter = cell.add( vnoise( cell ) );
+		dist.assign( pos.distance( cellCenter ) );
+
+		dist.addAssign( noise( pos.add( cell ), strtaightness ) );
+
+		If( dist.lessThan( minDist ), ()=>{
+
+			minDist.assign( dist );
+			minCell.assign( cell );
+
+		} );
+
+	} );
+
+	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 );
+
+}
+
+
+
+cork.defaults = defaults;
+
+
+
+export { cork };

package/src/crumpled-fabric.js

@@ -0,0 +1,81 @@
+
+//	TSL-Textures: Crumpled fabric
+
+
+
+import { Color } from 'three';
+import { exp, Fn, Loop, positionGeometry, vec3 } from 'three/tsl';
+import { noise } from './tsl-utils.js';
+
+
+
+var defaults = {
+	$name: 'Crumpled fabric',
+	$width: 260,
+
+	position: positionGeometry,
+	scale: 2,
+	pinch: 0.5,
+
+	color: new Color( 0xB0F0FF ),
+	subcolor: new Color( 0x4040F0 ),
+	background: new Color( 0x003000 ),
+
+	seed: 0,
+};
+
+
+
+var crumpledFabricRaw = Fn( ([ position, scale, pinch, color, subcolor, background, seed ])=>{
+
+	var pos = position.mul( exp( scale.sub( 0.5 ) ) ).add( seed ).toVar( );
+
+	Loop( 4, ()=>{
+
+		var x = noise( pos.xyz );
+		var y = noise( pos.yzx );
+		var z = noise( pos.zxy );
+
+		pos.addAssign( vec3( x, y, z ).mul( pinch ) );
+
+	} );
+
+	var k = noise( pos ).add( 1 ).div( 2 ).clamp( 0, 1 );
+
+	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 );
+
+} ).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;
+
+
+
+export { crumpledFabric };

package/src/dalmatian-spots.js

@@ -0,0 +1,80 @@
+
+//	TSL-Textures: Dalmatian spots
+
+
+
+import { Color } from "three";
+import { float, Fn, Loop, mix, positionGeometry } from 'three/tsl';
+import { noise } from './tsl-utils.js';
+
+
+
+var defaults = {
+	$name: 'Dalmatian spots',
+	$width: 260,
+
+	position: positionGeometry,
+
+	scale: 2,
+	density: 0.6,
+
+	color: new Color( 0xFFFFFF ),
+	background: new Color( 0x000000 ),
+
+	seed: 0,
+};
+
+
+
+var dalmatianSpotsRaw = Fn( ([ position, scale, density, color, background, seed ])=>{
+
+	var pos = position.mul( scale.exp( ) ).add( seed ).sub( 1000 ).toVar( 'pos' );
+
+	var k = float( 1 ).toVar( 'k' );
+
+	var d = float( 1.5 ).sub( density ).mul( 2 ).toVar( 'd' );
+	var count = density.mul( 5 ).add( 5 ).toVar( 'count' );
+
+	Loop( count, ()=> {
+
+		k.mulAssign( noise( pos ).abs().pow( d ).mul( 100 ).sub( 50 ).clamp( 0, 1 ).oneMinus() );
+		pos.assign( pos.mul( 1.01 ) );
+		k.mulAssign( noise( pos.yzx ).abs().pow( d ).mul( 100 ).sub( 50 ).clamp( 0, 1 ).oneMinus() );
+		pos.assign( pos.mul( 1.01 ) );
+		k.mulAssign( noise( pos.zxy ).abs().pow( d ).mul( 100 ).sub( 50 ).clamp( 0, 1 ).oneMinus() );
+		pos.assign( pos.mul( 1.01 ) );
+
+	} );
+
+	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 );
+
+}
+
+
+
+dalmatianSpots.defaults = defaults;
+
+
+
+export { dalmatianSpots };