tsl-textures 0.3.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsl-textures",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "A collection of Three.js Shading Language (TSL) textures ",
   "main": "index.js",
   "repository": {

package/src/clouds.js

@@ -0,0 +1,61 @@
+
+//	TSL-Textures: Clouds
+
+
+
+import { Color } from "three";
+import { clamp, exp, min, mix, mul, positionLocal, tslFn, vec4 } from 'three/nodes';
+import { noise } from 'tsl-textures/tsl-utils.js';
+
+
+
+var _clouds = tslFn( ( params ) => {
+
+	var pos = positionLocal.toVar(),
+		scale = exp( params.scale.div( 1.5 ).sub( 0.5 ) ).toVar(),
+		density = params.density.remap( 0, 1, -0.15, 0.15 ).toVar();
+
+	var k = noise( pos.mul( scale ).add( params.seed ) ).add( params.density ).toVar( );
+	k.addAssign( mul( 0.80, noise( pos.mul( scale, 2 ).add( params.seed ) ) ).add( density ) );
+	k.addAssign( mul( 0.10, noise( pos.mul( scale, 6 ).add( params.seed ) ) ).add( density ) );
+	k.addAssign( mul( 0.07, noise( pos.mul( scale, 8 ).add( params.seed ) ), params.opacity ).add( density ) );
+
+	var a = clamp( 0, 1, mul( k, 2 ).pow( 1.5 ).sub( 1 ).mul( params.opacity ) ).toVar();
+
+	return vec4( mix( params.subcolor, params.color, min( 1, k ) ), a );
+
+} );
+
+
+var clouds = tslFn( ( params ) => {
+
+	return _clouds( params ).rgb;
+
+} );
+
+
+
+clouds.opacity = tslFn( ( params ) => {
+
+	return _clouds( params ).a;
+
+} );
+
+
+
+clouds.defaults = {
+	$name: 'Clouds',
+
+	scale: 2,
+	density: 0.5,
+	opacity: 1,
+
+	color: new Color( 0xFFFFFF ),
+	subcolor: new Color( 0xA0A0B0 ),
+
+	seed: 0,
+};
+
+
+
+export { clouds };

package/src/photosphere.js

@@ -0,0 +1,48 @@
+
+//	TSL-Textures: Photosphere
+
+
+
+import { Color } from "three";
+import { exp, loop, mix, positionLocal, tslFn, vec3 } from 'three/nodes';
+import { applyEuler, noise } from 'tsl-textures/tsl-utils.js';
+
+
+
+var photosphere = tslFn( ( params ) => {
+
+	var scale = exp( params.scale.add( 1 ) ).toVar( );
+	var pos = positionLocal.toVar( );
+
+	var vec = vec3( pos ).toVar();
+
+	loop( 6, () => {
+
+		vec.assign( applyEuler( vec, pos.mul( scale ) ) );
+		scale.mulAssign( params.seed.mul( scale ).sin().mul( 0.05 ).add( 1.1 ) );
+
+	} );
+
+
+	var k = noise( vec ).add( 1 ).div( 2 );
+
+	return mix( params.background, params.color, k );
+
+} );
+
+
+
+photosphere.defaults = {
+	$name: 'Photosphere',
+
+	scale: 2,
+
+	color: new Color( 0xFFFF00 ),
+	background: new Color( 0xFF0000 ),
+
+	seed: 0,
+};
+
+
+
+export { photosphere };

package/src/satin.js

@@ -0,0 +1,47 @@
+
+//	TSL-Textures: Satin
+
+
+
+import { Color } from "three";
+import { abs, exp, mix, positionLocal, pow, tslFn, vec3 } from 'three/nodes';
+import { noise } from 'tsl-textures/tsl-utils.js';
+
+
+
+var satin = tslFn( ( params ) => {
+
+	var pos = positionLocal.toVar( );
+
+	var scale = exp( params.scale.div( 3 ) ).toVar();
+
+	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( params.seed )
+	);
+
+	k = pow( abs( k ), 3 ).mul( 20 );
+
+	return mix( params.background, params.color, k );
+
+} );
+
+
+
+satin.defaults = {
+	$name: 'Satin',
+
+	scale: 2,
+
+	color: new Color( 0x7080FF ),
+	background: new Color( 0x000050 ),
+
+	seed: 0,
+};
+
+
+
+export { satin };

package/src/simplex-noise.js

@@ -0,0 +1,39 @@
+
+//	TSL-Textures: Noise Pattern
+
+
+
+import { Color } from "three";
+import { clamp, exp, mix, positionLocal, tslFn } from 'three/nodes';
+import { noise } from 'tsl-textures/tsl-utils.js';
+
+
+
+var simplexNoise = tslFn( ( params ) => {
+
+	var pos = positionLocal.mul( exp( params.scale ) ).add( params.seed );
+
+	var k = clamp( 0, 1, noise( pos ).mul( 0.5, exp( params.contrast ) ).add( 0.5, params.balance ) );
+
+	return mix( params.background, params.color, k );
+
+} );
+
+
+
+simplexNoise.defaults = {
+	$name: 'Simplex noise',
+
+	scale: 2,
+	balance: 0,
+	contrast: 0,
+
+	color: new Color( 0xFFFFFF ),
+	background: new Color( 0x000000 ),
+
+	seed: 0,
+};
+
+
+
+export { simplexNoise };

package/src/tsl-utils.js

@@ -1,32 +1,15 @@
 
 //	Equirectangular Texture Generator - TSL Utility Functions
 //
-
-import { MathUtils } from 'three';
-import { add, cond, cos, float, If, max, min, sin, sub, tslFn, uniform, vec3 } from 'three/nodes';
-import { mx_perlin_noise_float as noise } from 'three/addons/nodes/materialx/lib/mx_noise.js';
-
-
-
-function map( x, toMin=0, toMax=1, fromMin=0, fromMax=100 ) {
-
-	x = MathUtils.mapLinear( x, fromMin, fromMax, toMin, toMax );
-
-	return x;
-
-}
+//	hsl( h, s, l ):vec3 			- convert from hsl to rgb
+//	toHsl( rgb:vec3 ):vec3			- convert from rgb to hsl
+//	spherical( phi, theta ):vec3	- from angles to point on unit sphere
+//	applyEuler( vec:vec3, eu:vec3 ):vec3 - apply Euler rotation to a vector
 
 
 
-function mapExp( x, toMin, toMax, fromMin=0, fromMax=100 ) {
-
-	x = map( x, 0, 1, fromMin, fromMax );
-	x = 2**( x * Math.log2( toMax/toMin ) + Math.log2( toMin ) );
-
-	return x;
-
-}
-
+import { add, cond, cos, cross, float, If, max, min, mul, sin, sub, tslFn, uniform, vec3, vec4 } from 'three/nodes';
+import { mx_perlin_noise_float as noise } from 'three/addons/nodes/materialx/lib/mx_noise.js';
 
 
 // helper function - convert hsl to rgb, ported to TSL from:
@@ -163,13 +146,53 @@ spherical.setLayout( {
 } );
 
 
+
+// apply Euler rotation to a vector
+const applyEuler = tslFn( ([ vec, eu ]) => {
+
+	var quat = quaternionFromEuler( eu );
+	return applyQuaternion( vec, quat );
+
+} );
+
+
+// convert Euler XYZ angles to quaternion
+const quaternionFromEuler = tslFn( ([ eu ]) => {
+
+	var c1 = cos( eu.x.div( 2 ) );
+	var c2 = cos( eu.y.div( 2 ) );
+	var c3 = cos( eu.z.div( 2 ) );
+
+	var s1 = sin( eu.x.div( 2 ) );
+	var s2 = sin( eu.y.div( 2 ) );
+	var s3 = sin( eu.z.div( 2 ) );
+
+	return vec4(
+		add( mul( s1, c2, c3 ), mul( c1, s2, s3 ) ),
+		sub( mul( c1, s2, c3 ), mul( s1, c2, s3 ) ),
+		add( mul( c1, c2, s3 ), mul( s1, s2, c3 ) ),
+		sub( mul( c1, c2, c3 ), mul( s1, s2, s3 ) ),
+	);
+
+} );
+
+
+// apply quaternion rotation to a vector
+const applyQuaternion = tslFn( ([ vec, quat ]) => {
+
+	var t = cross( quat, vec ).mul( 2 ).toVar( );
+
+	return add( vec, t.mul( quat.w ), cross( quat.xyz, t ) );
+
+} );
+
+
 export
 {
-	map,
-	mapExp,
 	noise,
 	hsl,
 	toHsl,
 	dynamic,
-	spherical
+	spherical,
+	applyEuler
 };