tsl-textures 2.5.1 → 3.0.1

package/src/perlin-noise.js

@@ -0,0 +1,66 @@
+
+//	TSL-Textures: Perlin Noise
+
+
+
+import { Color } from "three";
+import { clamp, exp, Fn, mix, positionGeometry } from 'three/tsl';
+import { noise } from './tsl-utils.js';
+
+
+
+var defaults = {
+	$name: 'Perlin noise',
+
+	position: positionGeometry,
+	scale: 2,
+	balance: 0,
+	contrast: 0,
+
+	color: new Color( 0xFFFFFF ),
+	background: new Color( 0x000000 ),
+
+	seed: 0,
+};
+
+
+
+var perlinNoiseRaw = Fn( ([ position, scale, balance, contrast, color, background, seed ]) => {
+
+	var pos = position.mul( exp( scale ) ).add( seed );
+
+	var k = clamp( 0, 1, noise( pos ).mul( 0.5, exp( contrast ) ).add( 0.5, balance ) );
+
+	return mix( background, color, k );
+
+} ).setLayout( {
+	name: 'perlinNoiseRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'balance', type: 'float' },
+		{ name: 'contrast', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function perlinNoise( params={} ) {
+
+	var { position, scale, balance, contrast, color, background, seed } = { ...defaults, ...params };
+
+	return perlinNoiseRaw( position, scale, balance, contrast, color, background, seed );
+
+}
+
+
+
+perlinNoise.defaults = defaults;
+
+
+
+export { perlinNoise };

package/src/photosphere.js

@@ -4,14 +4,15 @@
 
 
 import { Color } from "three";
-import { exp, Loop, mix, positionGeometry, vec3 } from 'three/tsl';
-import { applyEuler, noise, prepare, TSLFn } from './tsl-utils.js';
+import { exp, Fn, Loop, mix, positionGeometry, rotate, vec3 } from 'three/tsl';
+import { noise } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Photosphere',
 
+	position: positionGeometry,
 	scale: 2,
 
 	color: new Color( 0xFFFF00 ),
@@ -22,28 +23,50 @@ var defaults = {
 
 
 
-var photosphere = TSLFn( ( params ) => {
+var photosphereRaw = Fn( ([ position, scale, color, background, seed ]) => {
 
-	params = prepare( params, defaults );
-
-	var scale = exp( params.scale.add( 1 ) ).toVar( );
-	var pos = positionGeometry.toVar( );
+	var xscale = exp( scale.add( 1 ) ).toVar( );
+	var pos = position.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 ) );
+		vec.assign( rotate( vec, pos.mul( xscale ) ) );
+		xscale.mulAssign( seed.mul( xscale ).sin().mul( 0.05 ).add( 1.1 ) );
 
 	} );
 
 
 	var k = noise( vec ).add( 1 ).div( 2 );
 
-	return mix( params.background, params.color, k );
+	return mix( background, color, k );
+
+} ).setLayout( {
+	name: 'photosphereRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function photosphere( params={} ) {
+
+	var { position, scale, color, background, seed } = { ...defaults, ...params };
+
+	return photosphereRaw( position, scale, color, background, seed );
+
+}
+
+
 
-}, defaults );
+photosphere.defaults = defaults;
 
 
 

package/src/planet.js

@@ -4,8 +4,8 @@
 
 
 import { Color } from 'three';
-import { exp, float, If, Loop, mix, mul, positionGeometry, remap, smoothstep, vec3 } from 'three/tsl';
-import { noise, prepare, TSLFn } from './tsl-utils.js';
+import { exp, float, Fn, If, Loop, mix, mul, positionGeometry, remap, smoothstep, vec3 } from 'three/tsl';
+import { noise } from './tsl-utils.js';
 
 
 
@@ -13,6 +13,7 @@ import { noise, prepare, TSLFn } from './tsl-utils.js';
 var defaults = {
 	$name: 'Planet',
 
+	position: positionGeometry,
 	scale: 2,
 
 	iterations: 5,
@@ -36,29 +37,27 @@ var defaults = {
 
 
 
-var planet = TSLFn( ( params )=>{
-
-	params = prepare( params, defaults );
+var planetRaw = Fn( ([ position, scale, iterations, levelSea, levelMountain, balanceWater, balanceSand, balanceSnow, colorDeep, colorShallow, colorBeach, colorGrass, colorForest, colorSnow, seed ])=>{
 
 	var k = float( 0 ).toVar(),
 		sum = float( 0 ).toVar(),
-		scale = exp( params.scale.sub( 2 ) ).toVar(),
-		power = float( 2 ).toVar();
+		xscale = exp( scale.sub( 2 ) ).toVar(),
+		xpower = float( 2 ).toVar();
 
-	Loop( params.iterations.add( 10 ), ()=>{
+	Loop( iterations.add( 10 ), ()=>{
 
-		k.addAssign( mul( power, noise( positionGeometry.mul( scale ).add( params.seed ) ) ) );
-		sum.addAssign( power );
-		scale.mulAssign( 1.5 );
-		power.mulAssign( 0.8 );
+		k.addAssign( mul( xpower, noise( position.mul( xscale ).add( seed ) ) ) );
+		sum.addAssign( xpower );
+		xscale.mulAssign( 1.5 );
+		xpower.mulAssign( 0.8 );
 
 	} );
 
 	k.assign( mul( k, k, 0.5 ).div( sum ) );
 
-	var levelSea = params.levelSea.pow( 2 ).toVar();
-	var levelMountain = params.levelMountain.pow( 2 ).toVar();
-	var levelSand = mix( levelSea, levelMountain, params.balanceSand ).toVar();
+	var levelSea = levelSea.pow( 2 ).toVar();
+	var levelMountain = levelMountain.pow( 2 ).toVar();
+	var levelSand = mix( levelSea, levelMountain, balanceSand ).toVar();
 	var levelCoast = mix( levelSea, levelSand, 0.4 ).toVar();
 	var levelGrass = mix( levelSea, levelSand, 0.6 ).toVar();
 
@@ -69,9 +68,9 @@ var planet = TSLFn( ( params )=>{
 
 		// deep-shallow
 		color.assign( mix(
-			params.colorDeep,
-			params.colorShallow,
-			remap( k, 0, levelSea, 0, 1 ).pow( exp( params.balanceWater.mul( -8 ).add( 4 ) ) )
+			colorDeep,
+			colorShallow,
+			remap( k, 0, levelSea, 0, 1 ).pow( exp( balanceWater.mul( -8 ).add( 4 ) ) )
 		) );
 
 	} )
@@ -79,8 +78,8 @@ var planet = TSLFn( ( params )=>{
 
 			// shallow-sand
 			color.assign( mix(
-				params.colorShallow,
-				params.colorBeach,
+				colorShallow,
+				colorBeach,
 				remap( k, levelSea, levelCoast )
 			) );
 
@@ -88,15 +87,15 @@ var planet = TSLFn( ( params )=>{
 		.ElseIf( k.lessThan( levelGrass ), ()=>{
 
 			// sand
-			color.assign( params.colorBeach );
+			color.assign( colorBeach );
 
 		} )
 		.ElseIf( k.lessThan( levelSand ), ()=>{
 
 			// shallow-sand-grass
 			color.assign( mix(
-				params.colorBeach,
-				params.colorGrass,
+				colorBeach,
+				colorGrass,
 				remap( k, levelGrass, levelSand )
 			) );
 
@@ -105,8 +104,8 @@ var planet = TSLFn( ( params )=>{
 
 			// grass-forest
 			color.assign( mix(
-				params.colorGrass,
-				params.colorForest,
+				colorGrass,
+				colorForest,
 				remap( k, levelSand, levelMountain ).pow( 0.75 )
 			) );
 
@@ -114,18 +113,55 @@ var planet = TSLFn( ( params )=>{
 		.Else( ()=>{
 
 			// forest-snow
-			var levelSnow = mix( 1, levelMountain, params.balanceSnow );
+			var levelSnow = mix( 1, levelMountain, balanceSnow );
 			color.assign( mix(
-				params.colorForest,
-				params.colorSnow,
-				smoothstep( mix( levelSnow, levelMountain, params.balanceSnow.pow( 0.5 ) ), levelSnow, k )
+				colorForest,
+				colorSnow,
+				smoothstep( mix( levelSnow, levelMountain, balanceSnow.pow( 0.5 ) ), levelSnow, k )
 			) );
 
 		} );
 
 	return color;
 
-}, defaults );
+} ).setLayout( {
+	name: 'planetRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+
+		{ name: 'iterations', type: 'int' },
+		{ name: 'levelSea', type: 'float' },
+		{ name: 'levelMountain', type: 'float' },
+		{ name: 'balanceWater', type: 'float' },
+		{ name: 'balanceSand', type: 'float' },
+		{ name: 'balanceSnow', type: 'float' },
+
+		{ name: 'colorDeep', type: 'vec3' },
+		{ name: 'colorShallow', type: 'vec3' },
+		{ name: 'colorBeach', type: 'vec3' },
+		{ name: 'colorGrass', type: 'vec3' },
+		{ name: 'colorForest', type: 'vec3' },
+		{ name: 'colorSnow', type: 'vec3' },
+
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function planet( params={} ) {
+
+	var { position, scale, iterations, levelSea, levelMountain, balanceWater, balanceSand, balanceSnow, colorDeep, colorShallow, colorBeach, colorGrass, colorForest, colorSnow, seed } = { ...defaults, ...params };
+
+	return planetRaw( position, scale, iterations, levelSea, levelMountain, balanceWater, balanceSand, balanceSnow, colorDeep, colorShallow, colorBeach, colorGrass, colorForest, colorSnow, seed );
+
+}
+
+
+
+planet.defaults = defaults;
 
 
 

package/src/polka-dots.js

@@ -4,14 +4,15 @@
 
 
 import { Color } from "three";
-import { acos, add, distance, exp, float, If, Loop, mat2, max, min, mix, mod, mul, oneMinus, positionGeometry, pow, smoothstep, } from 'three/tsl';
-import { prepare, spherical, TSLFn } from './tsl-utils.js';
+import { acos, add, distance, exp, float, Fn, If, Loop, mat2, max, min, mix, mod, mul, oneMinus, positionGeometry, pow, smoothstep, } from 'three/tsl';
+import { spherical } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Polka dots',
 
+	position: positionGeometry,
 	count: 2,
 	size: 0.5,
 	blur: 0.25,
@@ -28,24 +29,22 @@ var goldenRatio = ( 1+5**0.5 )/2;
 
 
 
-var polkaDots = TSLFn( ( params ) => {
-
-	params = prepare( params, defaults );
+var polkaDotsRaw = Fn( ([ position, count, size, blur, color, background, xflat ]) => {
 
 	var dist = float( 1 ).toVar();
 
-	If( params.flat.equal( 1 ), ()=>{
+	If( xflat.equal( 1 ), ()=>{
 
-		var cnt = params.count.pow( 2 ).sub( 0.5 ).toVar();
-		var pos = positionGeometry.xy.mul( cnt ).mul( mat2( 1, 1, -1, 1 ) );
+		var cnt = count.pow( 2 ).sub( 0.5 ).toVar();
+		var pos = position.xy.mul( cnt ).mul( mat2( 1, 1, -1, 1 ) );
 		var posTo = pos.round().toVar();
 
 		dist.assign( pos.distance( posTo ).div( cnt ) );
 
-	} ).Else( ()=>{
+	} ).Else( ()=>{
 
-		var cnt = pow( 10, params.count ).toVar();
-		var vec = positionGeometry.normalize().toVar();
+		var cnt = pow( 10, count ).toVar();
+		var vec = position.normalize().toVar();
 
 		var besti = oneMinus( vec.y ).mul( cnt ).sub( 1 ).div( 2 );
 
@@ -65,16 +64,42 @@ var polkaDots = TSLFn( ( params ) => {
 			dist.assign( min( dist, distance( vec, pnt ) ) );
 
 		} ); // Loop
-
+
 	} ); // Else
 
-	var size = exp( params.size.mul( 5 ).sub( 5 ) ).toVar();
-	var blur = params.blur.pow( 4 ).toVar();
-	var k = smoothstep( size.sub( blur ), size.add( blur ), dist );
+	var xsize = exp( size.mul( 5 ).sub( 5 ) ).toVar();
+	var xblur = blur.pow( 4 ).toVar();
+	var k = smoothstep( xsize.sub( xblur ), xsize.add( xblur ), dist );
+
+	return mix( color, background, k );
+
+} ).setLayout( {
+	name: 'polkaDotsRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'count', type: 'float' },
+		{ name: 'size', type: 'float' },
+		{ name: 'blur', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'xflat', type: 'int' },
+	] }
+);
+
+
+
+function polkaDots( params={} ) {
+
+	var { position, count, size, blur, color, background, flat } = { ...defaults, ...params };
+
+	return polkaDotsRaw( position, count, size, blur, color, background, flat );
+
+}
+
 
-	return mix( params.color, params.background, k );
 
-}, defaults );
+polkaDots.defaults = defaults;
 
 
 

package/src/processed-wood.js

@@ -4,8 +4,8 @@
 
 
 import { Color } from "three";
-import { add, cos, exp, mix, positionGeometry, radians, sin, sub, vec3 } from 'three/tsl';
-import { noise, prepare, TSLFn } from './tsl-utils.js';
+import { add, cos, exp, Fn, mix, positionGeometry, radians, sin, sub, vec3 } from 'three/tsl';
+import { noise } from './tsl-utils.js';
 
 
 
@@ -13,6 +13,7 @@ var defaults = {
 	$name: 'Processed wood',
 	$width: 260,
 
+	position: positionGeometry,
 	scale: 2,
 	lengths: 4,
 	strength: 0.3,
@@ -26,28 +27,53 @@ var defaults = {
 
 
 
-var processedWood = TSLFn( ( params )=>{
+var processedWoodRaw = Fn( ([ position, scale, lengths, strength, angle, color, background, seed ])=>{
 
-	params = prepare( params, defaults );
-
-	var angle = radians( params.angle ).toVar();
+	var angle = radians( angle ).toVar();
 	var posLocal = vec3(
-		sub( positionGeometry.x.mul( cos( angle ) ), positionGeometry.y.mul( sin( angle ) ) ),
-		add( positionGeometry.x.mul( sin( angle ) ), positionGeometry.y.mul( cos( angle ) ) ),
-		positionGeometry.z,
+		sub( position.x.mul( cos( angle ) ), position.y.mul( sin( angle ) ) ),
+		add( position.x.mul( sin( angle ) ), position.y.mul( cos( angle ) ) ),
+		position.z,
 	).toVar();
 
-	var scale = params.scale.div( 2 ).add( 1 ).toVar();
-	var pos = posLocal.mul( exp( scale ) ).add( params.seed ).toVar( );
+	var xscale = scale.div( 2 ).add( 1 ).toVar();
+	var pos = posLocal.mul( exp( scale ) ).add( seed ).toVar( );
 
-	var len = params.lengths.add( 5 ).reciprocal().toVar();
-	var k = noise( pos.mul( scale, vec3( 1, len, len ) ) );
+	var len = lengths.add( 5 ).reciprocal().toVar();
+	var k = noise( pos.mul( xscale, vec3( 1, len, len ) ) );
 	k = k.mul( noise( pos.mul( vec3( 25, 1, 1 ) ) ).add( -1 ).mul( 0.2 ) );
-	k = k.add( params.strength.sub( 0.5 ) ).smoothstep( -0.3, 0.3 ).oneMinus();
+	k = k.add( strength.sub( 0.5 ) ).smoothstep( -0.3, 0.3 ).oneMinus();
+
+	return mix( color, background, k );
+
+} ).setLayout( {
+	name: 'processedWoodRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'lengths', type: 'float' },
+		{ name: 'strength', type: 'float' },
+		{ name: 'angle', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function processedWood( params={} ) {
+
+	var { position, scale, lengths, strength, angle, color, background, seed } = { ...defaults, ...params };
+
+	return processedWoodRaw( position, scale, lengths, strength, angle, color, background, seed );
+
+}
+
 
-	return mix( params.color, params.background, k );
 
-}, defaults );
+processedWood.defaults = defaults;
 
 
 

package/src/protozoa.js

@@ -5,13 +5,15 @@
 
 import { Color } from "three";
 import { exp, float, Fn, Loop, matcapUV, mix, positionGeometry, vec3 } from 'three/tsl';
-import { noise, prepare, TSLFn } from './tsl-utils.js';
+import { noise } from './tsl-utils.js';
 
 
 
 var defaults = {
 	$name: 'Protozoa',
 
+	position: positionGeometry,
+	matcap: matcapUV,
 	scale: 1.5,
 	fat: 0.7,
 	amount: 0.4,
@@ -29,17 +31,22 @@ var pnoise = Fn( ([ pos, fat ])=>{
 
 	return noise( pos ).mul( fat ).clamp( -3.14, 3.14 ).cos().add( 1 ).div( 2 );
 
-} );
+} ).setLayout( {
+	name: 'pnoise',
+	type: 'float',
+	inputs: [
+		{ name: 'pos', type: 'vec3' },
+		{ name: 'fat', type: 'float' },
+	] }
+);
 
 
 
-var protozoa = TSLFn( ( params )=>{
+var protozoaRaw = Fn( ([ position, matcap, scale, fat, amount, color, subcolor, background, seed ])=>{
 
-	params = prepare( params, defaults );
+	var pos = position.mul( exp( scale.sub( 1 ) ) ).add( seed ).toVar( );
 
-	var pos = positionGeometry.mul( exp( params.scale.sub( 1 ) ) ).add( params.seed ).toVar( );
-
-	var matcap = vec3( matcapUV, matcapUV.length() ).toVar();
+	var xmatcap = vec3( matcap, matcap.length() ).toVar();
 
 	var rings1 = float( 0 ).toVar();
 	var rings2 = float( 0 ).toVar();
@@ -47,18 +54,18 @@ var protozoa = TSLFn( ( params )=>{
 	var n1 = float( 0 ).toVar();
 	var n2 = float( 0 ).toVar();
 
-	var fat = params.fat.add( 0.2 ).oneMinus().mul( 60 ).add( 30 ).toVar();
-	var scale = float( 2 ).toVar();
+	var fat = fat.add( 0.2 ).oneMinus().mul( 60 ).add( 30 ).toVar();
+	var xscale = float( 2 ).toVar();
 
-	var dPos = params.amount.div( 2 ).add( 0.5 ).exp().toVar();
+	var dPos = amount.div( 2 ).add( 0.5 ).exp().toVar();
 
 	Loop( 10, ()=>{
 
-		rings1.assign( pnoise( pos.xyz.add( matcap ), fat ) );
-		rings2.assign( pnoise( pos.yzx.add( matcap ), fat ) );
+		rings1.assign( pnoise( pos.xyz.add( xmatcap ), fat ) );
+		rings2.assign( pnoise( pos.yzx.add( xmatcap ), fat ) );
 
-		n1.addAssign( rings1.mul( rings2 ).mul( scale ) );
-		n2.addAssign( rings1.max( rings2 ).mul( scale ) );
+		n1.addAssign( rings1.mul( rings2 ).mul( xscale ) );
+		n2.addAssign( rings1.max( rings2 ).mul( xscale ) );
 
 		pos.assign( mix( pos.mul( dPos ), 0, 0.4 ) );
 
@@ -66,9 +73,37 @@ var protozoa = TSLFn( ( params )=>{
 
 	} );
 
-	return mix( params.background, mix( params.color, params.subcolor, n2.mul( 0.1 ) ), n1 );
+	return mix( background, mix( color, subcolor, n2.mul( 0.1 ) ), n1 );
+
+} ).setLayout( {
+	name: 'protozoaRaw',
+	type: 'vec3',
+	inputs: [
+		{ name: 'position', type: 'vec3' },
+		{ name: 'matcap', type: 'vec2' },
+		{ name: 'scale', type: 'float' },
+		{ name: 'fat', type: 'float' },
+		{ name: 'amount', type: 'float' },
+		{ name: 'color', type: 'vec3' },
+		{ name: 'subcolor', type: 'vec3' },
+		{ name: 'background', type: 'vec3' },
+		{ name: 'seed', type: 'float' },
+	] }
+);
+
+
+
+function protozoa( params={} ) {
+
+	var { position, matcap, scale, fat, amount, color, subcolor, background, seed } = { ...defaults, ...params };
+
+	return protozoaRaw( position, matcap, scale, fat, amount, color, subcolor, background, seed );
+
+}
+
+
 
-}, defaults );
+protozoa.defaults = defaults;
 
 
 

package/src/reticular-veins.js

@@ -4,14 +4,15 @@
 
 
 import { Color } from 'three';
-import { exp, mix, mx_worley_noise_float, positionGeometry } from 'three/tsl';
-import { noise, prepare, TSLFn } from './tsl-utils.js';
+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,
@@ -25,21 +26,46 @@ var defaults = {
 
 
 
-var reticularVeins = TSLFn( ( params )=>{
+var reticularVeinsRaw = Fn( ([ position, scale, reticulation, strength, organelles, color, background, seed ])=>{
 
-	params = prepare( params, defaults );
+	var pos = position.mul( exp( scale.div( 2 ).add( 0.5 ) ) ).add( seed ).toVar( );
 
-	var pos = positionGeometry.mul( exp( params.scale.div( 2 ).add( 0.5 ) ) ).add( params.seed ).toVar( );
-
-	var k1 = mx_worley_noise_float( pos.mul( 1 ) );
-	var k2 = mx_worley_noise_float( pos.add( 100 ).mul( params.reticulation ) ).mul( params.strength );
-	var dots = noise( pos.mul( 100 ) ).mul( params.strength, params.organelles );
+	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( params.background, params.color, k );
+	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 );
+
+}
+
+
 
-}, defaults );
+reticularVeins.defaults = defaults;