@needle-tools/three 0.146.10 → 0.153.0

package/examples/jsm/nodes/utils/MatcapUVNode.js

@@ -1,5 +1,8 @@
 import TempNode from '../core/TempNode.js';
-import { vec2, vec3, negate, normalize, cross, dot, mul, add, transformedNormalView, positionViewDirection } from '../shadernode/ShaderNodeBaseElements.js';
+import { transformedNormalView } from '../accessors/NormalNode.js';
+import { positionViewDirection } from '../accessors/PositionNode.js';
+import { nodeImmutable, vec2, vec3 } from '../shadernode/ShaderNode.js';
+import { addNodeClass } from '../core/Node.js';
 
 class MatcapUVNode extends TempNode {
 
@@ -11,13 +14,17 @@ class MatcapUVNode extends TempNode {
 
 	construct() {
 
-		const x = normalize( vec3( positionViewDirection.z, 0, negate( positionViewDirection.x ) ) );
-		const y = cross( positionViewDirection, x );
+		const x = vec3( positionViewDirection.z, 0, positionViewDirection.x.negate() ).normalize();
+		const y = positionViewDirection.cross( x );
 
-		return add( mul( vec2( dot( x, transformedNormalView ), dot( y, transformedNormalView ) ), 0.495 ), 0.5 );
+		return vec2( x.dot( transformedNormalView ), y.dot( transformedNormalView ) ).mul( 0.495 ).add( 0.5 );
 
 	}
 
 }
 
 export default MatcapUVNode;
+
+export const matcapUV = nodeImmutable( MatcapUVNode );
+
+addNodeClass( MatcapUVNode );

package/examples/jsm/nodes/utils/MaxMipLevelNode.js

@@ -1,24 +1,33 @@
 import UniformNode from '../core/UniformNode.js';
 import { NodeUpdateType } from '../core/constants.js';
+import { nodeProxy } from '../shadernode/ShaderNode.js';
+import { addNodeClass } from '../core/Node.js';
 
 class MaxMipLevelNode extends UniformNode {
 
-	constructor( texture ) {
+	constructor( textureNode ) {
 
 		super( 0 );
 
-		this.texture = texture;
+		this.textureNode = textureNode;
 
 		this.updateType = NodeUpdateType.FRAME;
 
 	}
 
+	get texture() {
+
+		return this.textureNode.value;
+
+	}
+
 	update() {
 
-		const images = this.texture.images;
-		const image = ( images && images.length > 0 ) ? ( images[ 0 ]?.image || images[ 0 ] ) : this.texture.image;
+		const texture = this.texture;
+		const images = texture.images;
+		const image = ( images && images.length > 0 ) ? ( ( images[ 0 ] && images[ 0 ].image ) || images[ 0 ] ) : texture.image;
 
-		if ( image?.width !== undefined ) {
+		if ( image && image.width !== undefined ) {
 
 			const { width, height } = image;
 
@@ -31,3 +40,7 @@ class MaxMipLevelNode extends UniformNode {
 }
 
 export default MaxMipLevelNode;
+
+export const maxMipLevel = nodeProxy( MaxMipLevelNode );
+
+addNodeClass( MaxMipLevelNode );

package/examples/jsm/nodes/utils/OscNode.js

@@ -1,15 +1,10 @@
-import Node from '../core/Node.js';
-import TimerNode from './TimerNode.js';
-import { abs, fract, round, sin, add, sub, mul } from '../shadernode/ShaderNodeBaseElements.js';
+import Node, { addNodeClass } from '../core/Node.js';
+import { timerLocal } from './TimerNode.js';
+import { nodeObject, nodeProxy } from '../shadernode/ShaderNode.js';
 
 class OscNode extends Node {
 
-	static SINE = 'sine';
-	static SQUARE = 'square';
-	static TRIANGLE = 'triangle';
-	static SAWTOOTH = 'sawtooth';
-
-	constructor( method = OscNode.SINE, timeNode = new TimerNode() ) {
+	constructor( method = OscNode.SINE, timeNode = timerLocal() ) {
 
 		super();
 
@@ -27,25 +22,25 @@ class OscNode extends Node {
 	construct() {
 
 		const method = this.method;
-		const timeNode = this.timeNode;
+		const timeNode = nodeObject( this.timeNode );
 
 		let outputNode = null;
 
 		if ( method === OscNode.SINE ) {
 
-			outputNode = add( mul( sin( mul( add( timeNode, .75 ), Math.PI * 2 ) ), .5 ), .5 );
+			outputNode = timeNode.add( 0.75 ).mul( Math.PI * 2 ).sin().mul( 0.5 ).add( 0.5 );
 
 		} else if ( method === OscNode.SQUARE ) {
 
-			outputNode = round( fract( timeNode ) );
+			outputNode = timeNode.fract().round();
 
 		} else if ( method === OscNode.TRIANGLE ) {
 
-			outputNode = abs( sub( 1, mul( fract( add( timeNode, .5 ) ), 2 ) ) );
+			outputNode = timeNode.add( 0.5 ).fract().mul( 2 ).sub( 1 ).abs();
 
 		} else if ( method === OscNode.SAWTOOTH ) {
 
-			outputNode = fract( timeNode );
+			outputNode = timeNode.fract();
 
 		}
 
@@ -71,4 +66,16 @@ class OscNode extends Node {
 
 }
 
+OscNode.SINE = 'sine';
+OscNode.SQUARE = 'square';
+OscNode.TRIANGLE = 'triangle';
+OscNode.SAWTOOTH = 'sawtooth';
+
 export default OscNode;
+
+export const oscSine = nodeProxy( OscNode, OscNode.SINE );
+export const oscSquare = nodeProxy( OscNode, OscNode.SQUARE );
+export const oscTriangle = nodeProxy( OscNode, OscNode.TRIANGLE );
+export const oscSawtooth = nodeProxy( OscNode, OscNode.SAWTOOTH );
+
+addNodeClass( OscNode );

package/examples/jsm/nodes/utils/PackingNode.js

@@ -0,0 +1,55 @@
+import TempNode from '../core/TempNode.js';
+import { addNodeClass } from '../core/Node.js';
+import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
+
+class PackingNode extends TempNode {
+
+	constructor( scope, node ) {
+
+		super();
+
+		this.scope = scope;
+		this.node = node;
+
+	}
+
+	getNodeType( builder ) {
+
+		return this.node.getNodeType( builder );
+
+	}
+
+	construct() {
+
+		const { scope, node } = this;
+
+		let result = null;
+
+		if ( scope === PackingNode.DIRECTION_TO_COLOR ) {
+
+			result = node.mul( 0.5 ).add( 0.5 );
+
+		} else if ( scope === PackingNode.COLOR_TO_DIRECTION ) {
+
+			result = node.mul( 2.0 ).sub( 1 );
+
+		}
+
+		return result;
+
+	}
+
+}
+
+PackingNode.DIRECTION_TO_COLOR = 'directionToColor';
+PackingNode.COLOR_TO_DIRECTION = 'colorToDirection';
+
+export default PackingNode;
+
+export const directionToColor = nodeProxy( PackingNode, PackingNode.DIRECTION_TO_COLOR );
+export const colorToDirection = nodeProxy( PackingNode, PackingNode.COLOR_TO_DIRECTION );
+
+addNodeElement( 'directionToColor', directionToColor );
+addNodeElement( 'colorToDirection', colorToDirection );
+
+addNodeClass( PackingNode );

package/examples/jsm/nodes/utils/RemapNode.js

@@ -1,5 +1,5 @@
-import Node from '../core/Node.js';
-import { add, sub, div, mul, clamp } from '../shadernode/ShaderNodeBaseElements.js';
+import Node, { addNodeClass } from '../core/Node.js';
+import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
 
 class RemapNode extends Node {
 
@@ -21,14 +21,22 @@ class RemapNode extends Node {
 
 		const { node, inLowNode, inHighNode, outLowNode, outHighNode, doClamp } = this;
 
-		let t = div( sub( node, inLowNode ), sub( inHighNode, inLowNode ) );
+		let t = node.sub( inLowNode ).div( inHighNode.sub( inLowNode ) );
 
-		if ( doClamp === true ) t = clamp( t );
+		if ( doClamp === true ) t = t.clamp();
 
-		return add( mul( sub( outHighNode, outLowNode ), t ), outLowNode );
+		return t.mul( outHighNode.sub( outLowNode ) ).add( outLowNode );
 
 	}
 
 }
 
 export default RemapNode;
+
+export const remap = nodeProxy( RemapNode, null, null, { doClamp: false } );
+export const remapClamp = nodeProxy( RemapNode );
+
+addNodeElement( 'remap', remap );
+addNodeElement( 'remapClamp', remapClamp );
+
+addNodeClass( RemapNode );

package/examples/jsm/nodes/utils/RotateUVNode.js

@@ -1,9 +1,10 @@
 import TempNode from '../core/TempNode.js';
-import { vec2, add, sub, mul, cos, sin } from '../shadernode/ShaderNodeBaseElements.js';
+import { addNodeClass } from '../core/Node.js';
+import { addNodeElement, nodeProxy, vec2 } from '../shadernode/ShaderNode.js';
 
 class RotateUVNode extends TempNode {
 
-	constructor( uvNode, rotationNode, centerNode = vec2( .5 ) ) {
+	constructor( uvNode, rotationNode, centerNode = vec2( 0.5 ) ) {
 
 		super( 'vec2' );
 
@@ -17,16 +18,26 @@ class RotateUVNode extends TempNode {
 
 		const { uvNode, rotationNode, centerNode } = this;
 
-		const cosAngle = cos( rotationNode );
-		const sinAngle = sin( rotationNode );
+		const cosAngle = rotationNode.cos();
+		const sinAngle = rotationNode.sin();
 
-		return vec2(
-			add( add( mul( cosAngle, sub( uvNode.x, centerNode.x ) ), mul( sinAngle, sub( uvNode.y, centerNode.y ) ) ), centerNode.x ),
-			add( sub( mul( cosAngle, sub( uvNode.y, centerNode.y ) ), mul( sinAngle, sub( uvNode.x, centerNode.x ) ) ), centerNode.y )
+		const vector = uvNode.sub( centerNode );
+
+		const rotatedVector = vec2( // @TODO: Maybe we can create mat2 and write something like rotationMatrix.mul( vector )?
+			vec2( cosAngle, sinAngle ).dot( vector ),
+			vec2( sinAngle.negate(), cosAngle ).dot( vector )
 		);
 
+		return rotatedVector.add( centerNode );
+
 	}
 
 }
 
 export default RotateUVNode;
+
+export const rotateUV = nodeProxy( RotateUVNode );
+
+addNodeElement( 'rotateUV', rotateUV );
+
+addNodeClass( RotateUVNode );

package/examples/jsm/nodes/utils/SpecularMIPLevelNode.js

@@ -0,0 +1,37 @@
+import Node, { addNodeClass } from '../core/Node.js';
+import { maxMipLevel } from './MaxMipLevelNode.js';
+import { nodeProxy } from '../shadernode/ShaderNode.js';
+
+class SpecularMIPLevelNode extends Node {
+
+	constructor( textureNode, roughnessNode = null ) {
+
+		super( 'float' );
+
+		this.textureNode = textureNode;
+		this.roughnessNode = roughnessNode;
+
+	}
+
+	construct() {
+
+		const { textureNode, roughnessNode } = this;
+
+		// taken from here: http://casual-effects.blogspot.ca/2011/08/plausible-environment-lighting-in-two.html
+
+		const maxMIPLevelScalar = maxMipLevel( textureNode );
+
+		const sigma = roughnessNode.mul( roughnessNode ).mul( Math.PI ).div( roughnessNode.add( 1.0 ) );
+		const desiredMIPLevel = maxMIPLevelScalar.add( sigma.log2() );
+
+		return desiredMIPLevel.clamp( 0.0, maxMIPLevelScalar );
+
+	}
+
+}
+
+export default SpecularMIPLevelNode;
+
+export const specularMIPLevel = nodeProxy( SpecularMIPLevelNode );
+
+addNodeClass( SpecularMIPLevelNode );

package/examples/jsm/nodes/utils/SplitNode.js

@@ -1,7 +1,7 @@
-import Node from '../core/Node.js';
-import { vector } from '../core/NodeBuilder.js';
+import Node, { addNodeClass } from '../core/Node.js';
+import { vectorComponents } from '../core/constants.js';
 
-const vectorComponents = 'xyzw';
+const stringVectorComponents = vectorComponents.join( '' );
 
 class SplitNode extends Node {
 
@@ -20,7 +20,7 @@ class SplitNode extends Node {
 
 		for ( const c of this.components ) {
 
-			vectorLength = Math.max( vector.indexOf( c ) + 1, vectorLength );
+			vectorLength = Math.max( vectorComponents.indexOf( c ) + 1, vectorLength );
 
 		}
 
@@ -57,7 +57,7 @@ class SplitNode extends Node {
 
 			const nodeSnippet = node.build( builder, type );
 
-			if ( this.components.length === nodeTypeLength && this.components === vectorComponents.slice( 0, this.components.length ) ) {
+			if ( this.components.length === nodeTypeLength && this.components === stringVectorComponents.slice( 0, this.components.length ) ) {
 
 				// unecessary swizzle
 
@@ -100,3 +100,5 @@ class SplitNode extends Node {
 }
 
 export default SplitNode;
+
+addNodeClass( SplitNode );

package/examples/jsm/nodes/utils/SpriteSheetUVNode.js

@@ -1,14 +1,10 @@
-import Node from '../core/Node.js';
-import ConstNode from '../core/ConstNode.js';
-import UVNode from '../accessors/UVNode.js';
-import MathNode from '../math/MathNode.js';
-import OperatorNode from '../math/OperatorNode.js';
-import SplitNode from '../utils/SplitNode.js';
-import JoinNode from '../utils/JoinNode.js';
+import Node, { addNodeClass } from '../core/Node.js';
+import { uv } from '../accessors/UVNode.js';
+import { nodeProxy, float, vec2 } from '../shadernode/ShaderNode.js';
 
 class SpriteSheetUVNode extends Node {
 
-	constructor( countNode, uvNode = new UVNode(), frameNode = new ConstNode( 0 ) ) {
+	constructor( countNode, uvNode = uv(), frameNode = float( 0 ) ) {
 
 		super( 'vec2' );
 
@@ -22,35 +18,24 @@ class SpriteSheetUVNode extends Node {
 
 		const { frameNode, uvNode, countNode } = this;
 
-		const one = new ConstNode( 1 );
+		const { width, height } = countNode;
 
-		const width = new SplitNode( countNode, 'x' );
-		const height = new SplitNode( countNode, 'y' );
+		const frameNum = frameNode.mod( width.mul( height ) ).floor();
 
-		const total = new OperatorNode( '*', width, height );
+		const column = frameNum.mod( width );
+		const row = height.sub( frameNum.add( 1 ).div( width ).ceil() );
 
-		const roundFrame = new MathNode( MathNode.FLOOR, new MathNode( MathNode.MOD, frameNode, total ) );
+		const scale = countNode.reciprocal();
+		const uvFrameOffset = vec2( column, row );
 
-		const frameNum = new OperatorNode( '+', roundFrame, one );
-
-		const cell = new MathNode( MathNode.MOD, roundFrame, width );
-		const row = new MathNode( MathNode.CEIL, new OperatorNode( '/', frameNum, width ) );
-		const rowInv = new OperatorNode( '-', height, row );
-
-		const scale = new OperatorNode( '/', one, countNode );
-
-		const uvFrameOffset = new JoinNode( [
-			new OperatorNode( '*', cell, new SplitNode( scale, 'x' ) ),
-			new OperatorNode( '*', rowInv, new SplitNode( scale, 'y' ) )
-		] );
-
-		const uvScale = new OperatorNode( '*', uvNode, scale );
-		const uvFrame = new OperatorNode( '+', uvScale, uvFrameOffset );
-
-		return uvFrame;
+		return uvNode.add( uvFrameOffset ).mul( scale );
 
 	}
 
 }
 
 export default SpriteSheetUVNode;
+
+export const spritesheetUV = nodeProxy( SpriteSheetUVNode );
+
+addNodeClass( SpriteSheetUVNode );

package/examples/jsm/nodes/utils/TimerNode.js

@@ -1,13 +1,10 @@
 import UniformNode from '../core/UniformNode.js';
 import { NodeUpdateType } from '../core/constants.js';
+import { nodeObject, nodeImmutable } from '../shadernode/ShaderNode.js';
+import { addNodeClass } from '../core/Node.js';
 
 class TimerNode extends UniformNode {
 
-	static LOCAL = 'local';
-	static GLOBAL = 'global';
-	static DELTA = 'delta';
-	static FRAME = 'frame';
-
 	constructor( scope = TimerNode.LOCAL, scale = 1, value = 0 ) {
 
 		super( value );
@@ -18,7 +15,7 @@ class TimerNode extends UniformNode {
 		this.updateType = NodeUpdateType.FRAME;
 
 	}
-/*
+	/*
 	@TODO:
 	getNodeType( builder ) {
 
@@ -81,4 +78,17 @@ class TimerNode extends UniformNode {
 
 }
 
+TimerNode.LOCAL = 'local';
+TimerNode.GLOBAL = 'global';
+TimerNode.DELTA = 'delta';
+TimerNode.FRAME = 'frame';
+
 export default TimerNode;
+
+// @TODO: add support to use node in timeScale
+export const timerLocal = ( timeScale, value = 0 ) => nodeObject( new TimerNode( TimerNode.LOCAL, timeScale, value ) );
+export const timerGlobal = ( timeScale, value = 0 ) => nodeObject( new TimerNode( TimerNode.GLOBAL, timeScale, value ) );
+export const timerDelta = ( timeScale, value = 0 ) => nodeObject( new TimerNode( TimerNode.DELTA, timeScale, value ) );
+export const frameId = nodeImmutable( TimerNode, TimerNode.FRAME );
+
+addNodeClass( TimerNode );

package/examples/jsm/nodes/utils/TriplanarTexturesNode.js

@@ -1,5 +1,9 @@
-import Node from '../core/Node.js';
-import { float, vec3, add, mul, div, dot, normalize, abs, texture, positionWorld, normalWorld } from '../shadernode/ShaderNodeBaseElements.js';
+import Node, { addNodeClass } from '../core/Node.js';
+import { add } from '../math/OperatorNode.js';
+import { normalWorld } from '../accessors/NormalNode.js';
+import { positionWorld } from '../accessors/PositionNode.js';
+import { texture } from '../accessors/TextureNode.js';
+import { addNodeElement, nodeProxy, float, vec3 } from '../shadernode/ShaderNode.js';
 
 class TriplanarTexturesNode extends Node {
 
@@ -25,22 +29,22 @@ class TriplanarTexturesNode extends Node {
 		// Ref: https://github.com/keijiro/StandardTriplanar
 
 		// Blending factor of triplanar mapping
-		let bf = normalize( abs( normalNode ) );
-		bf = div( bf, dot( bf, vec3( 1.0 ) ) );
+		let bf = normalNode.abs().normalize();
+		bf = bf.div( bf.dot( vec3( 1.0 ) ) );
 
 		// Triplanar mapping
-		const tx = mul( positionNode.yz, scaleNode );
-		const ty = mul( positionNode.zx, scaleNode );
-		const tz = mul( positionNode.xy, scaleNode );
+		const tx = positionNode.yz.mul( scaleNode );
+		const ty = positionNode.zx.mul( scaleNode );
+		const tz = positionNode.xy.mul( scaleNode );
 
 		// Base color
 		const textureX = textureXNode.value;
 		const textureY = textureYNode !== null ? textureYNode.value : textureX;
 		const textureZ = textureZNode !== null ? textureZNode.value : textureX;
 
-		const cx = mul( texture( textureX, tx ), bf.x );
-		const cy = mul( texture( textureY, ty ), bf.y );
-		const cz = mul( texture( textureZ, tz ), bf.z );
+		const cx = texture( textureX, tx ).mul( bf.x );
+		const cy = texture( textureY, ty ).mul( bf.y );
+		const cz = texture( textureZ, tz ).mul( bf.z );
 
 		return add( cx, cy, cz );
 
@@ -49,3 +53,10 @@ class TriplanarTexturesNode extends Node {
 }
 
 export default TriplanarTexturesNode;
+
+export const triplanarTextures = nodeProxy( TriplanarTexturesNode );
+export const triplanarTexture = ( texture, ...params ) => triplanarTextures( texture, texture, texture, ...params );
+
+addNodeElement( 'triplanarTexture', triplanarTexture );
+
+addNodeClass( TriplanarTexturesNode );

package/examples/jsm/objects/GroundProjectedSkybox.js

@@ -0,0 +1,172 @@
+import { Mesh, IcosahedronGeometry, ShaderMaterial, DoubleSide } from 'three';
+
+/**
+ * Ground projected env map adapted from @react-three/drei.
+ * https://github.com/pmndrs/drei/blob/master/src/core/Environment.tsx
+ */
+class GroundProjectedSkybox extends Mesh {
+
+	constructor( texture, options = {} ) {
+
+		const isCubeMap = texture.isCubeTexture;
+
+		const defines = [
+			isCubeMap ? '#define ENVMAP_TYPE_CUBE' : ''
+		];
+
+		const vertexShader = /* glsl */ `
+			varying vec3 vWorldPosition;
+
+			void main() {
+
+				vec4 worldPosition = ( modelMatrix * vec4( position, 1.0 ) );
+				vWorldPosition = worldPosition.xyz;
+
+				gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+			}
+			`;
+		const fragmentShader = defines.join( '\n' ) + /* glsl */ `
+
+				varying vec3 vWorldPosition;
+
+				uniform float radius;
+				uniform float height;
+				uniform float angle;
+
+				#ifdef ENVMAP_TYPE_CUBE
+
+					uniform samplerCube map;
+
+				#else
+
+					uniform sampler2D map;
+
+				#endif
+
+				// From: https://www.shadertoy.com/view/4tsBD7
+				float diskIntersectWithBackFaceCulling( vec3 ro, vec3 rd, vec3 c, vec3 n, float r ) 
+				{
+
+					float d = dot ( rd, n );
+
+					if( d > 0.0 ) { return 1e6; }
+
+					vec3 o = ro - c;
+					float t = - dot( n, o ) / d;
+					vec3 q = o + rd * t;
+
+					return ( dot( q, q ) < r * r ) ? t : 1e6;
+
+				}
+
+				// From: https://www.iquilezles.org/www/articles/intersectors/intersectors.htm
+				float sphereIntersect( vec3 ro, vec3 rd, vec3 ce, float ra ) {
+
+					vec3 oc = ro - ce;
+					float b = dot( oc, rd );
+					float c = dot( oc, oc ) - ra * ra;
+					float h = b * b - c;
+
+					if( h < 0.0 ) { return -1.0; }
+
+					h = sqrt( h );
+
+					return - b + h;
+
+				}
+
+				vec3 project() {
+
+					vec3 p = normalize( vWorldPosition );
+					vec3 camPos = cameraPosition;
+					camPos.y -= height;
+
+					float intersection = sphereIntersect( camPos, p, vec3( 0.0 ), radius );
+					if( intersection > 0.0 ) {
+
+						vec3 h = vec3( 0.0, - height, 0.0 );
+						float intersection2 = diskIntersectWithBackFaceCulling( camPos, p, h, vec3( 0.0, 1.0, 0.0 ), radius );
+						p = ( camPos + min( intersection, intersection2 ) * p ) / radius;
+
+					} else {
+
+						p = vec3( 0.0, 1.0, 0.0 );
+
+					}
+
+					return p;
+
+				}
+
+				#include <common>
+
+				void main() {
+
+					vec3 projectedWorldPosition = project();
+
+					#ifdef ENVMAP_TYPE_CUBE
+
+						vec3 outcolor = textureCube( map, projectedWorldPosition ).rgb;
+
+					#else
+
+						vec3 direction = normalize( projectedWorldPosition );
+						vec2 uv = equirectUv( direction );
+						vec3 outcolor = texture2D( map, uv ).rgb;
+
+					#endif
+
+					gl_FragColor = vec4( outcolor, 1.0 );
+
+					#include <tonemapping_fragment>
+					#include <encodings_fragment>
+
+				}
+				`;
+
+		const uniforms = {
+			map: { value: texture },
+			height: { value: options.height || 15 },
+			radius: { value: options.radius || 100 },
+		};
+
+		const geometry = new IcosahedronGeometry( 1, 16 );
+		const material = new ShaderMaterial( {
+			uniforms,
+			fragmentShader,
+			vertexShader,
+			side: DoubleSide,
+		} );
+
+		super( geometry, material );
+
+	}
+
+	set radius( radius ) {
+
+		this.material.uniforms.radius.value = radius;
+
+	}
+
+	get radius() {
+
+		return this.material.uniforms.radius.value;
+
+	}
+
+	set height( height ) {
+
+		this.material.uniforms.height.value = height;
+
+	}
+
+	get height() {
+
+		return this.material.uniforms.height.value;
+
+	}
+
+}
+
+export { GroundProjectedSkybox };