@dailies-studio/tsl-textures 3.0.4

package/src/darth-maul.js

@@ -0,0 +1,84 @@
+
+//	TSL-Textures: Darth Maul
+
+
+
+import { Color, Vector3 } from "three";
+import { exp, Fn, mix, positionGeometry, select, vec3 } from 'three/tsl';
+import { noise } from './tsl-utils.js';
+
+
+
+var defaults = {
+	$name: 'Darth Maul',
+
+	position: positionGeometry,
+	scale: 2,
+	shift: new Vector3( 0, 0, 0 ),
+	complexity: 0,
+
+	angle: 60,
+	distance: 1.9,
+
+	color: new Color( 0xF04040 ),
+	background: new Color( 0x000000 ),
+	balance: 0,
+
+	seed: 0,
+};
+
+
+
+var darthMaulRaw = Fn( ([ position, scale, shift, complexity, angle, distance, color, background, balance, seed ]) => {
+
+	var xposition = position.add( shift ).mul( exp( scale.div( 1.5 ).sub( 1 ) ) ).sub( shift ).mul( vec3( 1, 1/2, 1/2 ) ).toVar( );
+
+	var s = select( position.y.mul( angle.radians().cos() ).add( position.z.mul( angle.radians().sin() ) ).greaterThan( distance ), 1, 0 );
+
+	// implement symmetry
+	xposition.x.assign( xposition.x.add( shift.x ).abs() );
+	xposition.y.addAssign( seed );
+	xposition.z.mulAssign( shift.z );
+
+	var n = noise( xposition ).toVar();
+
+	var k = n.sin().mul( n.mul( complexity.mul( 2 ).add( 1 ).exp() ).sin() ).remap( 0, 0.2, 1, -1 ).greaterThan( balance ).select( 0, 1 );
+
+	var c = select( xposition.x.greaterThan( noise( xposition.mul( 2.3 ) ).abs().mul( 0.5 ).add( 0.02 )	), 1, 0 );
+
+	return mix( background, color, k.mul( s ).mul( c ).clamp( 0, 1 ) );
+
+} ).setLayout( {
+	name: 'darthMaulRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'shift', type: 'vec3' },
+		{ name: 'complexity', type: 'float' },
+		{ name: 'angle', type: 'float' },
+		{ name: 'distance', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'balance', type: 'float' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function darthMaul( params={} ) {
+
+	var { position, scale, shift, complexity, angle, distance, color, background, balance, seed } = { ...defaults, ...params };
+
+	return darthMaulRaw( position, scale, shift, complexity, angle, distance, color, background, balance, seed );
+
+}
+
+
+
+darthMaul.defaults = defaults;
+
+
+
+export { darthMaul };

package/src/dyson-sphere.js

@@ -0,0 +1,144 @@
+
+//	TSL-Textures: Dyson sphere
+
+
+
+import { Color } from 'three';
+import { exp, float, Fn, Loop, mix, positionGeometry, vec3 } from 'three/tsl';
+
+
+
+var defaults = {
+	$name: 'Dyson sphere',
+
+	position: positionGeometry,
+	scale: 2,
+	complexity: 2,
+
+	variation: 0,
+
+	color: new Color( 0xc0d0ff ),
+	background: new Color( 0 ),
+
+	seed: 0,
+};
+
+
+
+var noisea = Fn( ([ pos ])=>{
+
+	var p = pos.mul( 5**0.5 ).fract().toVar();
+	p.addAssign( p.dot( p.add( vec3( 31.4159, 27.1828, 14.142 ) ) ) );
+	return p.z.mul( p.x.add( p.y ) ).fract().mul( 2 ).sub( 1 );
+
+} ).setLayout( {
+	name: 'noisea',
+	type: 'float',
+	inputs: [
+		{ name: 'pos', type: 'vec3' },
+	] }
+);
+
+
+
+var smoother = Fn( ([ x ])=>{
+
+	var t = x.oneMinus().clamp( 0, 1 ).toVar();
+	return t.mul( t ).mul( float( 3 ).sub( t.mul( 2 ) ) );
+
+} ).setLayout( {
+	name: 'smoother',
+	type: 'float',
+	inputs: [
+		{ name: 'x', type: 'float' },
+	] }
+);
+
+
+
+var noiseg = Fn( ([ pos ])=>{
+
+	var minx = pos.x.floor().toVar();
+	var maxx = minx.add( 1 ).toVar();
+
+	var miny = pos.y.floor().toVar();
+	var maxy = miny.add( 1 ).toVar();
+
+	var minz = pos.z.floor().toVar();
+	var maxz = minz.add( 1 ).toVar();
+
+	var dx = smoother( pos.x.fract() ).toVar();
+	var dy = smoother( pos.y.fract() ).toVar();
+	var dz = smoother( pos.z.fract() ).toVar();
+
+	var mx = smoother( dx.oneMinus() ).toVar();
+	var my = smoother( dy.oneMinus() ).toVar();
+	var mz = smoother( dz.oneMinus() ).toVar();
+
+	var n000 = noisea( vec3( minx, miny, minz ) ).mul( mx ).mul( my ).mul( mz ).toVar();
+	var n001 = noisea( vec3( minx, miny, maxz ) ).mul( mx ).mul( my ).mul( dz ).toVar();
+	var n010 = noisea( vec3( minx, maxy, minz ) ).mul( mx ).mul( dy ).mul( mz ).toVar();
+	var n011 = noisea( vec3( minx, maxy, maxz ) ).mul( mx ).mul( dy ).mul( dz ).toVar();
+	var n100 = noisea( vec3( maxx, miny, minz ) ).mul( dx ).mul( my ).mul( mz ).toVar();
+	var n101 = noisea( vec3( maxx, miny, maxz ) ).mul( dx ).mul( my ).mul( dz ).toVar();
+	var n110 = noisea( vec3( maxx, maxy, minz ) ).mul( dx ).mul( dy ).mul( mz ).toVar();
+	var n111 = noisea( vec3( maxx, maxy, maxz ) ).mul( dx ).mul( dy ).mul( dz ).toVar();
+
+	return n000.add( n001 ).add( n010 ).add( n011 ).add( n100 ).add( n101 ).add( n110 ).add( n111 );
+
+} ).setLayout( {
+	name: 'noiseg',
+	type: 'float',
+	inputs: [
+		{ name: 'pos', type: 'vec3' },
+	] }
+);
+
+
+
+var dysonSphereRaw = Fn( ([ position, scale, complexity, color, background, seed ])=>{
+
+	var pos = position.mul( exp( scale.div( 2 ).add( 0.5 ) ) ).add( seed ).toVar( );
+
+	var res = vec3().toVar();
+	var factor = float( 1 ).toVar();
+
+	Loop( complexity.add( 4 ), ()=>{
+
+		res.addAssign( noiseg( pos.mul( factor ) ) );
+		factor.addAssign( factor );
+
+	} );
+
+	return mix( background, color, res.x.add( 1 ).div( 5 ) );
+
+} ).setLayout( {
+	name: 'dysonSphereRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'complexity', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function dysonSphere( params={} ) {
+
+	var { position, scale, complexity, color, background, seed } = { ...defaults, ...params };
+
+	return dysonSphereRaw( position, scale, complexity, color, background, seed );
+
+}
+
+
+
+dysonSphere.defaults = defaults;
+
+
+
+export { dysonSphere };

package/src/entangled.js

@@ -0,0 +1,75 @@
+
+//	TSL-Textures: Entangled
+
+
+
+import { Color } from "three";
+import { abs, exp, float, Fn, Loop, max, mix, mul, oneMinus, positionGeometry, pow, sin } from 'three/tsl';
+import { noise } from './tsl-utils.js';
+
+
+
+var defaults = {
+	$name: 'Entangled',
+
+	position: positionGeometry,
+	scale: 2,
+	density: 10,
+
+	color: new Color( 0x002040 ),
+	background: new Color( 0xFFFFFF ),
+
+	seed: 0,
+};
+
+
+
+var entangledRaw = Fn( ([ position, scale, density, color, background, seed ]) => {
+
+	var xscale = exp( scale.div( 2 ) ).toVar( );
+	var pos = position.add( seed ).toVar( );
+	var k = float( -10000 ).toVar( );
+	var k1 = float( 0 ).toVar( );
+
+	Loop( density, ()=> {
+
+		k1.assign( sin( noise( mul( pos, xscale ) ).mul( 3*Math.PI ) ) );
+		k.assign( max( k, k1 ) );
+		xscale.mulAssign( 1.2 );
+
+	} );
+
+	k.assign( oneMinus( pow( abs( k ), 5 ) ).mul( 6 ) );
+
+	return mix( color, background, k );
+
+} ).setLayout( {
+	name: 'entangled',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'density', type: 'int' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function entangled( params={} ) {
+
+	var { position, scale, density, color, background, seed } = { ...defaults, ...params };
+
+	return entangledRaw( position, scale, density, color, background, seed );
+
+}
+
+
+
+entangled.defaults = defaults;
+
+
+
+export { entangled };

package/src/fordite.js

@@ -0,0 +1,69 @@
+
+//	TSL-Textures: Fordite
+
+
+
+import { Color } from 'three';
+import { exp, Fn, mul, positionGeometry, sin, vec3 } from 'three/tsl';
+import { hsl, noise } from './tsl-utils.js';
+
+
+
+var defaults = {
+	$name: 'Fordite',
+
+	position: positionGeometry,
+	scale: 2,
+	color: new Color( 0, 0, 0 ),
+
+	seed: 0,
+};
+
+
+
+var forditeRaw = Fn( ([ position, scale, color, seed ]) => {
+
+	var pos = position.mul( exp( scale ) ).add( seed ).toVar( );
+
+	var k = noise(
+		vec3(
+			noise( pos, 1 ),
+			noise( pos, 2 ),
+			noise( pos, 3 ),
+		)
+	).toVar( );
+
+	return hsl( vec3(
+		k,
+		1,
+		sin( mul( k, Math.PI, 4 ) ).mul( 0.5 ).add( 0.5 )
+	) ).add( color );
+
+} ).setLayout( {
+	name: 'forditeRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function fordite( params={} ) {
+
+	var { position, scale, color, seed } = { ...defaults, ...params };
+
+	return forditeRaw( position, scale, color, seed );
+
+}
+
+
+
+fordite.defaults = defaults;
+
+
+
+export { fordite };

package/src/gas-giant.js

@@ -0,0 +1,94 @@
+
+//	TSL-Textures: Gas giant
+
+
+
+import { Color } from "three";
+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,
+
+	colorA: new Color( 0xFFF8F0 ),
+	colorB: new Color( 0xF0E8B0 ),
+	colorC: new Color( 0xAFA0D0 ),
+
+	seed: 0,
+};
+
+
+
+var gasGiantRaw = Fn( ([ position, scale, turbulence, blur, colorA, colorB, colorC, seed ])=>{
+
+	var xscale = scale.div( 2 ).add( 1 ).toVar();
+	var pos = position.mul( exp( xscale ) ).add( seed ).toVar( );
+
+	// turbulence strength
+	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 )
+		)
+	).mul( 5 ).abs().toVar();
+
+	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( xturbulence.mul( spot.mul( 2 ).exp() ) ) );
+
+
+	var xblur = blur.pow( 0.2 ).oneMinus().mul( xturbulence.add( 1 ) ).toVar();
+
+	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( 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, colorC, xturbulence.mul( 0.3 ) ) );
+
+	return color.mul( k );
+
+} ).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;
+
+
+
+export { gasGiant };

package/src/grid.js

@@ -0,0 +1,84 @@
+
+//	TSL-Textures: Grid
+
+
+
+import { Color } from "three";
+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 ),
+
+};
+
+
+
+var gridRaw = Fn( ([ uvs, countU, countV, aspect, thinness, equirectangular, color, background ]) => {
+
+	var xaspect = max( exp2( aspect ), 1 );
+
+	var a = mul( uvs.x, xaspect, Math.PI ).toVar(),
+		b = mul( uvs.y, Math.PI ).toVar();
+
+	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( mix( 1, sin( b ), equirectangular ) ),
+		angleV = abs( sub( b, bTo ) ),
+		angle = min( angleU, angleV );
+
+	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( 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 );
+
+}
+
+
+
+grid.defaults = defaults;
+
+
+
+export { grid };