@dailies-studio/tsl-textures 3.0.4

package/src/reticular-veins.js

@@ -0,0 +1,72 @@
+
+//	TSL-Textures: Voronoi Cells
+
+
+
+import { Color } from 'three';
+import { exp, Fn, mix, positionGeometry } from 'three/tsl';
+import { noise, voronoi } from './tsl-utils.js';
+
+
+
+var defaults = {
+	$name: 'Reticular veins',
+
+	position: positionGeometry,
+	scale: 2,
+	reticulation: 5,
+	strength: 0.2,
+	organelles: 0.2,
+
+	color: new Color( 0xFFFFF0 ),
+	background: new Color( 0x208020 ),
+
+	seed: 0,
+};
+
+
+
+var reticularVeinsRaw = Fn( ([ position, scale, reticulation, strength, organelles, color, background, seed ])=>{
+
+	var pos = position.mul( exp( scale.div( 2 ).add( 0.5 ) ) ).add( seed ).toVar( );
+
+	var k1 = voronoi( pos );
+	var k2 = voronoi( pos.add( 100 ).mul( reticulation ) ).mul( strength );
+	var dots = noise( pos.mul( 100 ) ).mul( strength, organelles );
+
+	var k = k1.add( k2 ).add( dots );
+
+	return mix( background, color, k );
+
+} ).setLayout( {
+	name: 'reticularVeinsRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'reticulation', type: 'float' },
+		{ name: 'strength', type: 'float' },
+		{ name: 'organelles', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function reticularVeins( params={} ) {
+
+	var { position, scale, reticulation, strength, organelles, color, background, seed } = { ...defaults, ...params };
+
+	return reticularVeinsRaw( position, scale, reticulation, strength, organelles, color, background, seed );
+
+}
+
+
+
+reticularVeins.defaults = defaults;
+
+
+
+export { reticularVeins };

package/src/roman-paving.js

@@ -0,0 +1,58 @@
+
+//	TSL-Textures: Roman paving
+
+
+
+import { exp, Fn, positionGeometry } from 'three/tsl';
+import { voronoi2 } from './tsl-utils.js';
+
+
+
+var defaults = {
+	$name: 'Roman paving',
+
+	position: positionGeometry,
+	scale: 2,
+	depth: 0.5,
+
+	seed: 0,
+};
+
+
+
+var romanPavingRaw = Fn( ([ position, scale, depth, seed ])=>{
+
+	var pos = position.mul( exp( scale ) ).add( seed ).toVar( );
+
+	var k = voronoi2( pos ).toVar();
+
+	return k.y.sub( k.x ).pow( depth.mul( 3 ).sub( 3 ).exp() ).smoothstep( 0, 1 );
+
+} ).setLayout( {
+	name: 'romanPavingRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'depth', type: 'float' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function romanPaving( params={} ) {
+
+	var { position, scale, depth, seed } = { ...defaults, ...params };
+
+	return romanPavingRaw( position, scale, depth, seed );
+
+}
+
+
+
+romanPaving.defaults = defaults;
+
+
+
+export { romanPaving };

package/src/rotator.js

@@ -0,0 +1,120 @@
+
+//	TSL-Textures: Rotator
+
+
+
+import { Vector2, Vector3 } from "three";
+import { cross, Fn, normalLocal, positionGeometry, tangentLocal } from 'three/tsl';
+import { approximateNormal, rotatePivot, selectPlanar, } from './tsl-utils.js';
+
+
+
+var defaults = {
+	$name: 'Rotator',
+	$positionNode: true,
+	$selectorPlanar: true,
+
+	angles: new Vector3( -0.2, 0.7, 0 ),
+	center: new Vector3( 0, 0, 0 ),
+
+	selectorCenter: new Vector3( 0, 0, 0 ),
+	selectorAngles: new Vector2( 0, 0 ),
+	selectorWidth: 2,
+
+};
+
+
+
+var surfacePos = Fn( ([ pos, angles, center, selectorAngles, selectorCenter, selectorWidth ])=>{
+
+	var zone = selectPlanar( pos, selectorAngles, selectorCenter, selectorWidth );
+
+	return rotatePivot( pos, center, angles.mul( zone ) );
+
+} ).setLayout( {
+	name: 'surfacePos',
+	type: 'vec3',
+	inputs: [
+		{ name: 'pos', type: 'vec3' },
+		{ name: 'angles', type: 'vec3' },
+		{ name: 'center', type: 'vec3' },
+		{ name: 'selectorAngles', type: 'vec2' },
+		{ name: 'selectorCenter', type: 'vec3' },
+		{ name: 'selectorWidth', type: 'float' },
+	]
+} );
+
+
+
+var rotatorRaw = Fn( ([ angles, center, selectorAngles, selectorCenter, selectorWidth ])=>{
+
+	return surfacePos( positionGeometry, angles, center, selectorAngles, selectorCenter, selectorWidth );
+
+} ).setLayout( {
+	name: 'rotatorRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'angles', type: 'vec3' },
+		{ name: 'center', type: 'vec3' },
+		{ name: 'selectorAngles', type: 'vec2' },
+		{ name: 'selectorCenter', type: 'vec3' },
+		{ name: 'selectorWidth', type: 'float' },
+	]
+} );
+
+
+
+var rotatorNormalRaw = Fn( ([ angles, center, selectorAngles, selectorCenter, selectorWidth ]) => {
+
+	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();
+
+	var pos = surfacePos( position, angles, center, selectorAngles, selectorCenter, selectorWidth );
+	var posU = surfacePos( position.add( tangent ), angles, center, selectorAngles, selectorCenter, selectorWidth );
+	var posV = surfacePos( position.add( bitangent ), angles, center, selectorAngles, selectorCenter, selectorWidth );
+
+	return approximateNormal( pos, posU, posV );
+
+} ).setLayout( {
+	name: 'rotatorNormalRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'angles', type: 'vec3' },
+		{ name: 'center', type: 'vec3' },
+		{ name: 'selectorAngles', type: 'vec2' },
+		{ name: 'selectorCenter', type: 'vec3' },
+		{ name: 'selectorWidth', type: 'float' },
+	]
+} );
+
+
+
+function rotator( params={} ) {
+
+	var { angles, center, selectorAngles, selectorCenter, selectorWidth } = { ...defaults, ...params };
+
+	return rotatorRaw( angles, center, selectorAngles, selectorCenter, selectorWidth );
+
+}
+
+
+
+rotator.normal = function ( params={} ) {
+
+	var { angles, center, selectorAngles, selectorCenter, selectorWidth } = { ...defaults, ...params };
+
+	return rotatorNormalRaw( angles, center, selectorAngles, selectorCenter, selectorWidth );
+
+};
+
+
+
+rotator.defaults = defaults;
+
+
+
+export { rotator };

package/src/rough-clay.js

@@ -0,0 +1,90 @@
+
+//	TSL-Textures: Rough clay
+
+
+
+import { cross, exp, Fn, normalLocal, positionGeometry, tangentLocal } from 'three/tsl';
+import { approximateNormal, noise, voronoi } from './tsl-utils.js';
+
+
+
+var defaults = {
+	$name: 'Rough clay',
+	$normalNode: true,
+
+	position: positionGeometry,
+	scale: 2,
+	bump: 0.5,
+	curvature: 0.2,
+
+	seed: 0,
+};
+
+
+
+var surfacePos = Fn( ([ pos, normal, curvature ]) => {
+
+	var k1 = voronoi( pos.add( noise( pos ).mul( curvature ) ) ).add( 0.8 ).pow( 5 ).toVar();
+	k1.addAssign( k1.pow( 0.5 ) );
+	return pos.add( normal.mul( k1 ) );
+
+} ).setLayout( {
+	name: 'surfacePos',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'normal', type: 'vec3' },
+		{ name: 'curvature', type: 'float' },
+	] }
+);
+
+
+
+var roughClayRaw = Fn( ([ position, normal, tangent, scale, bump, curvature, seed ]) => {
+
+	const EPS = 0.001;
+
+	var xposition = position.mul( exp( scale.div( 2 ) ) ).add( seed.sin().mul( 10 ) ).toVar( ),
+		xnormal = normal.normalize().toVar(),
+		xtangent = tangent.normalize().mul( EPS ).toVar(),
+		xbitangent = cross( xnormal, xtangent ).normalize().mul( EPS ).toVar();
+
+	xnormal.mulAssign( bump, 1/50 );
+
+	var pos = surfacePos( xposition, xnormal, curvature );
+	var posU = surfacePos( xposition.add( xtangent ), xnormal, curvature );
+	var posV = surfacePos( xposition.add( xbitangent ), xnormal, curvature );
+
+	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: 'bump', type: 'float' },
+		{ name: 'curvature', type: 'float' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function roughClay( params={} ) {
+
+	var { position, scale, bump, curvature, seed } = { ...defaults, ...params };
+
+	return roughClayRaw( position, normalLocal, tangentLocal, scale, bump, curvature, seed );
+
+}
+
+
+
+roughClay.defaults = defaults;
+
+
+
+export { roughClay };

package/src/runny-eggs.js

@@ -0,0 +1,180 @@
+
+//	TSL-Textures: Runny eggs
+
+
+
+import { Color } from 'three';
+import { cross, exp, Fn, mix, normalLocal, positionGeometry, tangentLocal } from 'three/tsl';
+import { approximateNormal, voronoi } from './tsl-utils.js';
+
+
+
+var defaults = {
+	$name: 'Runny eggs',
+
+	position: positionGeometry,
+	scale: 1,
+
+	sizeYolk: 0.2,
+	sizeWhite: 0.7,
+
+	colorYolk: new Color( 'orange' ),
+	colorWhite: new Color( 'white' ),
+	colorBackground: new Color( 'lightgray' ),
+
+	seed: 0,
+};
+
+
+
+var surfacePos = Fn( ([ pos, normal, sizeYolk, sizeWhite ]) => {
+
+	var n = voronoi( pos ).toVar();
+	var whites = n.add( sizeWhite ).pow( 8 ).oneMinus();
+	var yolks = n.add( sizeYolk ).pow( 18 ).oneMinus().clamp( 0, 1 );
+
+	var k = mix( 0, mix( 0, 1, yolks ), whites );
+
+	return pos.add( normal.mul( k ) );
+
+} ).setLayout( {
+	name: 'surfacePos',
+	type: 'vec3',
+	inputs: [
+		{ name: 'pos', type: 'vec3' },
+		{ name: 'normal', type: 'vec3' },
+		{ name: 'sizeYolk', type: 'float' },
+		{ name: 'sizeWhite', type: 'float' },
+	] }
+);
+
+
+
+var runnyEggsRaw = Fn( ([ position, scale, sizeYolk, sizeWhite, colorYolk, colorWhite, colorBackground, seed ]) => {
+
+	var pos = position.mul( exp( scale ) ).add( seed.sin().mul( 10 ) ).toVar( );
+
+	var n = voronoi( pos ).toVar();
+	var whites = n.add( sizeWhite.oneMinus() ).pow( 8 ).oneMinus().clamp( -0.5, 1 );
+	var yolks = n.add( sizeYolk.oneMinus() ).pow( 18 ).oneMinus().clamp( 0, 1 ).pow( 0.4 ).clamp( 0, 1 );
+
+	return mix( colorBackground, mix( colorWhite, colorYolk, yolks ), whites );
+
+} ).setLayout( {
+	name: 'runnyEggsRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'pos', type: 'vec3' },
+		{ name: 'normal', type: 'vec3' },
+		{ name: 'sizeYolk', type: 'float' },
+		{ name: 'sizeWhite', type: 'float' },
+		{ name: 'colorYolk', type: 'vec3' },
+		{ name: 'colorWhite', type: 'vec3' },
+		{ name: 'colorBackground', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+var runnyEggsNormalRaw = Fn( ([ position, normal, tangent, scale, sizeYolk, sizeWhite, /*colorYolk, colorWhite, colorBackground,*/ seed ]) => {
+
+	const EPS = 0.001;
+	const BUMP = 0.05;
+
+	var xposition = position.mul( exp( scale ) ).add( seed.sin().mul( 10 ) ).toVar( ),
+		xnormal = normal.normalize().toVar(),
+		xtangent = tangent.normalize().mul( EPS ).toVar(),
+		bitangent = cross( xnormal, xtangent ).normalize().mul( EPS ).toVar();
+
+	var xSizeYolk = sizeYolk.oneMinus();
+	var xSizeWhite = sizeWhite.oneMinus();
+
+	xnormal.mulAssign( BUMP );
+
+	var pos = surfacePos( xposition, xnormal, xSizeYolk, xSizeWhite );
+	var posU = surfacePos( xposition.add( xtangent ), xnormal, xSizeYolk, xSizeWhite );
+	var posV = surfacePos( xposition.add( bitangent ), xnormal, xSizeYolk, xSizeWhite );
+
+	return approximateNormal( pos, posU, posV );
+
+} ).setLayout( {
+	name: 'runnyEggsNormalRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'normal', type: 'vec3' },
+		{ name: 'tangent', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'sizeYolk', type: 'float' },
+		{ name: 'sizeWhite', type: 'float' },
+		/*{ name: 'colorYolk', type: 'vec3' },*/
+		/*{ name: 'colorWhite', type: 'vec3' },*/
+		/*{ name: 'colorBackground', type: 'vec3' },*/
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+var runnyEggsRoughnessRaw = Fn( ([ position, scale, sizeYolk, /*sizeWhite, colorYolk, colorWhite, colorBackground,*/ seed ]) => {
+
+	var pos = position.mul( exp( scale ) ).add( seed.sin().mul( 10 ) ).toVar( );
+
+	var n = voronoi( pos ).toVar();
+	var yolks = n.add( sizeYolk.oneMinus() ).pow( 18 ).clamp( 0, 1 );
+
+	return yolks;
+
+} ).setLayout( {
+	name: 'runnyEggsRoughnessRaw',
+	type: 'float',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'sizeYolk', type: 'float' },
+		/*{ name: 'sizeWhite', type: 'float' },*/
+		/*{ name: 'colorYolk', type: 'vec3' },*/
+		/*{ name: 'colorWhite', type: 'vec3' },*/
+		/*{ name: 'colorBackground', type: 'vec3' },*/
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function runnyEggs( params={} ) {
+
+	var { position, scale, sizeYolk, sizeWhite, colorYolk, colorWhite, colorBackground, seed } = { ...defaults, ...params };
+
+	return runnyEggsRaw( position, scale, sizeYolk, sizeWhite, colorYolk, colorWhite, colorBackground, seed );
+
+}
+
+
+
+runnyEggs.normal = function ( params={} ) {
+
+	var { position, scale, sizeYolk, sizeWhite, /*colorYolk, colorWhite, colorBackground,*/ seed } = { ...defaults, ...params };
+
+	return runnyEggsNormalRaw( position, normalLocal, tangentLocal, scale, sizeYolk, sizeWhite, /*colorYolk, colorWhite, colorBackground,*/ seed );
+
+};
+
+
+
+runnyEggs.roughness = function ( params={} ) {
+
+	var { position, scale, sizeYolk, /*sizeWhite, colorYolk, colorWhite, colorBackground,*/ seed } = { ...defaults, ...params };
+
+	return runnyEggsRoughnessRaw( position, scale, sizeYolk, /*sizeWhite, colorYolk, colorWhite, colorBackground,*/ seed );
+
+};
+
+
+
+runnyEggs.defaults = defaults;
+
+
+
+export { runnyEggs };

package/src/rust.js

@@ -0,0 +1,144 @@
+
+//	TSL-Textures: Voronoi Cells
+
+
+
+import { Color } from 'three';
+import { exp, Fn, Loop, mix, positionGeometry } from 'three/tsl';
+import { noise } from './tsl-utils.js';
+
+
+
+var defaults = {
+	$name: 'rust',
+
+	position: positionGeometry,
+	scale: 2,
+	iterations: 8,
+	amount: -0.3,
+	opacity: 0.5,
+	noise: 0.5,
+	noiseScale: 0.5,
+
+	color: new Color( 0xC08000 ),
+	background: new Color( 0x000020 ),
+
+	seed: 0,
+};
+
+
+
+var _rust = Fn( ([ position, scale, iterations, amount, seed ])=>{
+
+	var pos = position.mul( exp( scale.div( 4 ).add( -1 ) ) ).add( seed ).toVar( );
+
+	var xamount = amount.mul( noise( pos.mul( amount.div( 2 ).add( 4 ) ) ).add( 4 ) ).toVar();
+
+	var k = noise( pos ).toVar();
+
+	Loop( iterations, ()=>{
+
+		pos.mulAssign( 2 );
+		k.addAssign( noise( pos ) );
+
+	} );
+
+	k.subAssign( noise( pos.mul( 2 ) ).abs() );
+
+	k.assign( k.sub( xamount ).clamp( 0, 15 ) );
+
+	return k;
+
+} ).setLayout( {
+	name: '_rust',
+	type: 'float',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'iterations', type: 'int' },
+		{ name: 'amount', type: 'float' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+var rustRaw = Fn( ([ position, scale, iterations, amount, /*opacity,*/xnoise, noiseScale, color, background, seed ])=>{
+
+	var k = _rust( position, scale, iterations, amount, seed ).mul( 1.25 ).pow( 0.5 );
+
+	var pos = position.mul( exp( scale.add( noiseScale.mul( 3 ), 2 ) ) );
+
+	k.addAssign( xnoise.mul( noise( pos ).abs().add( 0.1 ).pow( 2 ) ) );
+
+	return mix( color, background, k );
+
+} ).setLayout( {
+	name: 'rustRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'iterations', type: 'int' },
+		{ name: 'amount', type: 'float' },
+		/*{ name: 'opacity', type: 'float' },*/
+		{ name: 'xnoise', type: 'float' },
+		{ name: 'noiseScale', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+
+var rustOpacityRaw = Fn( ([ position, scale, iterations, amount, opacity, /*xnoise, noiseScale, color, background,*/ seed ])=>{
+
+	var k = _rust( position, scale, iterations, amount, seed ).mul( opacity.add( 0.2 ) );
+
+	return k.oneMinus();
+
+} ).setLayout( {
+	name: 'rustOpacityRaw',
+	type: 'float',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'iterations', type: 'int' },
+		{ name: 'amount', type: 'float' },
+		{ name: 'opacity', type: 'float' },
+		/*{ name: 'xnoise', type: 'float' },*/
+		/*{ name: 'noiseScale', type: 'float' },*/
+		/*{ name: 'color', type: 'vec3' },*/
+		/*{ name: 'background', type: 'vec3' },*/
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function rust( params={} ) {
+
+	var { position, scale, iterations, amount, /*opacity,*/ noise, noiseScale, color, background, seed } = { ...defaults, ...params };
+
+	return rustRaw( position, scale, iterations, amount, /*opacity,*/noise, noiseScale, color, background, seed );
+
+}
+
+
+
+rust.opacity = function ( params={} ) {
+
+	var { position, scale, iterations, amount, opacity, /*xnoise, noiseScale, color, background,*/ seed } = { ...defaults, ...params };
+
+	return rustOpacityRaw( position, scale, iterations, amount, opacity, /*xnoise, noiseScale, color, background,*/ seed );
+
+};
+
+
+
+rust.defaults = defaults;
+
+
+
+export { rust };