@dailies-studio/tsl-textures 3.0.4

package/src/satin.js

@@ -0,0 +1,69 @@
+
+//	TSL-Textures: Satin
+
+
+
+import { Color } from "three";
+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 ),
+	background: new Color( 0x000050 ),
+
+	seed: 0,
+};
+
+
+
+var satinRaw = Fn( ([ position, scale, color, background, seed ]) => {
+
+	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( seed )
+	).abs().pow( 3 ).mul( 20 ).toVar( 'k' );
+
+	return mix( background, 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' },
+	] }
+);
+
+
+
+function satin( params={} ) {
+
+	var { position, scale, color, background, seed } = { ...defaults, ...params };
+
+	return satinRaw( position, scale, color, background, seed );
+
+}
+
+
+
+satin.defaults = defaults;
+
+
+
+export { satin };

package/src/scaler.js

@@ -0,0 +1,111 @@
+
+//	TSL-Textures: Scaler
+
+
+
+import { Vector2, Vector3 } from "three";
+import { cross, Fn, mix, normalLocal, positionGeometry, tangentLocal, vec3 } from 'three/tsl';
+import { approximateNormal, selectPlanar } from './tsl-utils.js';
+
+
+
+var defaults = {
+	$name: 'Scaler',
+	$positionNode: true,
+	$selectorPlanar: true,
+
+	scales: new Vector3( 0.01, 0.9, 1.7 ),
+	center: new Vector3( 0, 0, 0 ),
+
+	selectorCenter: new Vector3( 0, 0, 0 ),
+	selectorAngles: new Vector2( 0, 0 ),
+	selectorWidth: 2,
+
+};
+
+
+
+var surfacePos = Fn( ([ pos, scales, center, selectorAngles, selectorCenter, selectorWidth ])=>{
+
+	var zone = selectPlanar( pos, selectorAngles, selectorCenter, selectorWidth );
+
+	var S = mix( vec3( 1, 1, 1 ), scales, zone );
+
+	return pos.sub( center ).mul( S ).add( center );
+
+} );
+
+
+
+var scalerRaw = Fn( ([ scales, center, selectorAngles, selectorCenter, selectorWidth ])=>{
+
+	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' },
+	]
+} );
+
+
+
+var scalerNormalRaw = Fn( ([ scales, center, selectorAngles, selectorCenter, selectorWidth ]) => {
+
+	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();
+
+	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 };
+
+	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 );
+
+};
+
+
+
+scaler.defaults = defaults;
+
+
+
+export { scaler };

package/src/scepter-head.js

@@ -0,0 +1,94 @@
+
+//	TSL-Textures: Scepter Head
+
+
+
+import { Color } from "three";
+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,
+
+	colorRim: new Color( 0xFFFFFF ),
+	colorA: new Color( 0x70E0FF ),
+	colorB: new Color( 0x3000FF ),
+};
+
+
+
+var scepterHeadRaw = Fn( ([ position, xFactor, yFactor, zFactor, colorRim, colorA, colorB ]) => {
+
+	var pos = position.toVar( 'pos' );
+
+	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 ),
+		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( 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();
+
+	var indexX = ( abs( floor( ( fx.mul( 2/Math.PI ).add( 1 ) ).div( 2 ) ) ) ),
+		indexY = ( abs( floor( ( fy.mul( 2/Math.PI ).add( 1 ) ).div( 2 ) ) ) ),
+		indexZ = ( abs( floor( ( fz.mul( 2/Math.PI ).add( 1 ) ).div( 2 ) ) ) );
+
+	var index = mod( ( add( indexX, indexY, indexZ ) ), 2 );
+
+	HSL.assign( toHsl( mix( colorA, colorB, index ) ) );
+	var color1 = hsl( vec3( HSL.xy, HSL.z.mul( k ) ) ).toVar( 'color1' );
+
+	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 ) );
+
+} ).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;
+
+
+
+export { scepterHead };

package/src/scream.js

@@ -0,0 +1,72 @@
+
+//	TSL-Textures: Scream
+
+
+
+import { Color } from "three";
+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,
+
+	color: new Color( 0xF0F060 ),
+	background: new Color( 0xD09090 ),
+
+	seed: 0,
+};
+
+
+
+var screamRaw = Fn( ([ position, scale, variety, color, background, seed ]) => {
+
+	var pos = position.mul( exp( scale ) ).add( seed ).toVar( 'pos' );
+
+	var k = noise( add( sin( pos.xyz ), cos( pos.yzx ) ) );
+
+	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( background, color, k ).toVar( 'col' );
+
+	var HSL = toHsl( col ).toVar( 'HSL' );
+
+	return hsl( vec3( add( HSL.x, variety.mul( sin( k.mul( Math.PI ) ) ).mul( 0.5 ) ), HSL.yz ) );
+
+} ).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' },
+	] }
+);
+
+
+
+function scream( params={} ) {
+
+	var { position, scale, variety, color, background, seed } = { ...defaults, ...params };
+
+	return screamRaw( position, scale, variety, color, background, seed );
+
+}
+
+
+
+scream.defaults = defaults;
+
+
+
+export { scream };

package/src/stars.js

@@ -0,0 +1,72 @@
+
+//	TSL-Textures: Stars
+
+
+
+import { Color } from "three";
+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,
+
+	color: new Color( 0xfff5f0 ),
+	background: new Color( 0x000060 ),
+
+	seed: 0,
+};
+
+
+
+var starsRaw = Fn( ([ position, scale, density, variation, color, background, seed ]) => {
+
+	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( 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 );
+
+}
+
+
+
+stars.defaults = defaults;
+
+
+
+export { stars };

package/src/static-noise.js

@@ -0,0 +1,73 @@
+
+//	TSL-Textures: Noise Pattern
+
+
+
+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,
+
+	delay: 0,
+
+	seed: 0,
+};
+
+
+
+var staticNoiseRaw = Fn( ([ position, time, scale, balance, contrast, delay, seed ]) => {
+
+	var pos = position.div( exp( scale ) ).add( seed );
+
+	var speed = delay.sub( 1 ).mul( 5 ).exp(),
+		t = time.div( speed ).round().mul( speed );
+
+	var offset = vnoise( t.sin() ).mul( 1000 );
+
+	var k = noise( pos.add( offset ) ).min( 1 );
+
+	k = k.mul( 0.5, exp( contrast ) ).add( 0.5, balance );
+
+	return vec3( k );
+
+} ).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;
+
+
+
+export { staticNoise };

package/src/supersphere.js

@@ -0,0 +1,108 @@
+
+//	TSL-Textures: Supersphere
+
+
+
+import { cross, float, Fn, normalLocal, positionGeometry, tangentLocal } from 'three/tsl';
+import { approximateNormal } from './tsl-utils.js';
+
+
+
+var defaults = {
+	$name: 'Supersphere',
+	$positionNode: true,
+
+	exponent: 3,
+
+};
+
+
+
+var surfacePos = Fn( ([ pos, exponent ])=>{
+
+	var xexponent = float( 2 ).pow( exponent );
+	var equPos = pos.div( pos.length() ).toVar();
+	var equPos2 = equPos.abs().pow( xexponent ).toVar();
+
+	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 supersphereRaw = Fn( ([ exponent ])=>{
+
+	return surfacePos( positionGeometry, exponent );
+
+} ).setLayout( {
+	name: 'supersphereRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'exponent', type: 'float' },
+	]
+} );
+
+
+
+var supersphereNormalRaw = Fn( ([ exponent ]) => {
+
+	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, 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 { exponent } = { ...defaults, ...params };
+
+	return supersphereRaw( exponent );
+
+}
+
+
+
+supersphere.normal = function ( params={} ) {
+
+	var { exponent } = { ...defaults, ...params };
+
+	return supersphereNormalRaw( exponent );
+
+};
+
+
+
+supersphere.defaults = defaults;
+
+
+
+export { supersphere };

package/src/tiger-fur.js

@@ -0,0 +1,77 @@
+
+//	TSL-Textures: Tiger fur
+
+
+
+import { Color } from "three";
+import { exp, Fn, mix, positionGeometry, vec3 } from 'three/tsl';
+import { noise } from './tsl-utils.js';
+
+
+
+var defaults = {
+	$name: 'Tiger fur',
+
+	position: positionGeometry,
+	scale: 2,
+	lengths: 4,
+	blur: 0.3,
+	strength: 0.3,
+	hairs: 0.5,
+
+	color: new Color( 0xFFAA00 ),
+	bottomColor: new Color( 0xFFFFEE ),
+
+	seed: 0,
+};
+
+
+
+var tigerFurRaw = Fn( ([ position, scale, lengths, blur, strength, hairs, color, bottomColor, seed ])=>{
+
+	var xscale = scale.div( 2 ).add( 1 ).toVar();
+	var pos = position.mul( exp( xscale ) ).add( seed ).toVar( );
+
+	var len = lengths.add( 5 ).reciprocal().toVar();
+	var hairs = hairs.mul( 0.3 ).toVar();
+	var k = noise( pos.mul( xscale, vec3( 1, len, len ) ) );
+	k = k.add( noise( pos.mul( vec3( 25, 1, 1 ) ) ).add( 1 ).mul( hairs ) );
+	k = k.add( strength.sub( 0.5 ) ).smoothstep( blur.negate(), blur ).oneMinus();
+
+	var n = position.y.add( hairs.sub( 0.5 ) ).smoothstep( -1, 0.5 );
+
+	return mix( bottomColor, color, n ).mul( k );
+
+} ).setLayout( {
+	name: 'tigerFurRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'lengths', type: 'float' },
+		{ name: 'blur', type: 'float' },
+		{ name: 'strength', type: 'float' },
+		{ name: 'hairs', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'bottomColor', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function tigerFur( params={} ) {
+
+	var { position, scale, lengths, blur, strength, hairs, color, bottomColor, seed } = { ...defaults, ...params };
+
+	return tigerFurRaw( position, scale, lengths, blur, strength, hairs, color, bottomColor, seed );
+
+}
+
+
+
+tigerFur.defaults = defaults;
+
+
+
+export { tigerFur };