super-three 0.147.1 → 0.154.0

package/examples/jsm/nodes/accessors/PositionNode.js

@@ -1,19 +1,12 @@
-import Node from '../core/Node.js';
-import AttributeNode from '../core/AttributeNode.js';
-import VaryingNode from '../core/VaryingNode.js';
-import ModelNode from '../accessors/ModelNode.js';
-import MathNode from '../math/MathNode.js';
-import OperatorNode from '../math/OperatorNode.js';
+import Node, { addNodeClass } from '../core/Node.js';
+import { attribute } from '../core/AttributeNode.js';
+import { varying } from '../core/VaryingNode.js';
+import { normalize } from '../math/MathNode.js';
+import { modelWorldMatrix, modelViewMatrix } from './ModelNode.js';
+import { nodeImmutable } from '../shadernode/ShaderNode.js';
 
 class PositionNode extends Node {
 
-	static GEOMETRY = 'geometry';
-	static LOCAL = 'local';
-	static WORLD = 'world';
-	static WORLD_DIRECTION = 'worldDirection';
-	static VIEW = 'view';
-	static VIEW_DIRECTION = 'viewDirection';
-
 	constructor( scope = PositionNode.LOCAL ) {
 
 		super( 'vec3' );
@@ -22,6 +15,12 @@ class PositionNode extends Node {
 
 	}
 
+	isGlobal() {
+
+		return true;
+
+	}
+
 	getHash( /*builder*/ ) {
 
 		return `position-${this.scope}`;
@@ -36,31 +35,31 @@ class PositionNode extends Node {
 
 		if ( scope === PositionNode.GEOMETRY ) {
 
-			outputNode = new AttributeNode( 'position', 'vec3' );
+			outputNode = attribute( 'position', 'vec3' );
 
 		} else if ( scope === PositionNode.LOCAL ) {
 
-			outputNode = new VaryingNode( new PositionNode( PositionNode.GEOMETRY ) );
+			outputNode = varying( positionGeometry );
 
 		} else if ( scope === PositionNode.WORLD ) {
 
-			const vertexPositionNode = new MathNode( MathNode.TRANSFORM_DIRECTION, new ModelNode( ModelNode.WORLD_MATRIX ), new PositionNode( PositionNode.LOCAL ) );
-			outputNode = new VaryingNode( vertexPositionNode );
+			const vertexPositionNode = modelWorldMatrix.mul( positionLocal );
+			outputNode = varying( vertexPositionNode );
 
 		} else if ( scope === PositionNode.VIEW ) {
 
-			const vertexPositionNode = new OperatorNode( '*', new ModelNode( ModelNode.VIEW_MATRIX ), new PositionNode( PositionNode.LOCAL ) );
-			outputNode = new VaryingNode( vertexPositionNode );
+			const vertexPositionNode = modelViewMatrix.mul( positionLocal );
+			outputNode = varying( vertexPositionNode );
 
 		} else if ( scope === PositionNode.VIEW_DIRECTION ) {
 
-			const vertexPositionNode = new MathNode( MathNode.NEGATE, new PositionNode( PositionNode.VIEW ) );
-			outputNode = new MathNode( MathNode.NORMALIZE, new VaryingNode( vertexPositionNode ) );
+			const vertexPositionNode = positionView.negate();
+			outputNode = normalize( varying( vertexPositionNode ) );
 
 		} else if ( scope === PositionNode.WORLD_DIRECTION ) {
 
-			const vertexPositionNode = new MathNode( MathNode.NEGATE, new PositionNode( PositionNode.WORLD ) );
-			outputNode = new MathNode( MathNode.NORMALIZE, new VaryingNode( vertexPositionNode ) );
+			const vertexPositionNode = positionLocal.transformDirection( modelWorldMatrix );
+			outputNode = normalize( varying( vertexPositionNode ) );
 
 		}
 
@@ -86,4 +85,20 @@ class PositionNode extends Node {
 
 }
 
+PositionNode.GEOMETRY = 'geometry';
+PositionNode.LOCAL = 'local';
+PositionNode.WORLD = 'world';
+PositionNode.WORLD_DIRECTION = 'worldDirection';
+PositionNode.VIEW = 'view';
+PositionNode.VIEW_DIRECTION = 'viewDirection';
+
 export default PositionNode;
+
+export const positionGeometry = nodeImmutable( PositionNode, PositionNode.GEOMETRY );
+export const positionLocal = nodeImmutable( PositionNode, PositionNode.LOCAL );
+export const positionWorld = nodeImmutable( PositionNode, PositionNode.WORLD );
+export const positionWorldDirection = nodeImmutable( PositionNode, PositionNode.WORLD_DIRECTION );
+export const positionView = nodeImmutable( PositionNode, PositionNode.VIEW );
+export const positionViewDirection = nodeImmutable( PositionNode, PositionNode.VIEW_DIRECTION );
+
+addNodeClass( PositionNode );

package/examples/jsm/nodes/accessors/ReferenceNode.js

@@ -1,6 +1,8 @@
-import Node from '../core/Node.js';
-import UniformNode from '../core/UniformNode.js';
+import Node, { addNodeClass } from '../core/Node.js';
 import { NodeUpdateType } from '../core/constants.js';
+import { uniform } from '../core/UniformNode.js';
+import { texture } from './TextureNode.js';
+import { nodeObject } from '../shadernode/ShaderNode.js';
 
 class ReferenceNode extends Node {
 
@@ -24,42 +26,47 @@ class ReferenceNode extends Node {
 
 	setNodeType( uniformType ) {
 
-		this.node = new UniformNode( null, uniformType );
-		this.nodeType = uniformType;
+		let node = null;
 
-		if ( uniformType === 'color' ) {
+		if ( uniformType === 'texture' ) {
 
-			this.nodeType = 'vec3';
+			node = texture( null );
 
-		} else if ( uniformType === 'texture' ) {
+		} else {
 
-			this.nodeType = 'vec4';
+			node = uniform( uniformType );
 
 		}
 
+		this.node = node;
+
 	}
 
-	getNodeType() {
+	getNodeType( builder ) {
 
-		return this.uniformType;
+		return this.node.getNodeType( builder );
 
 	}
 
 	update( frame ) {
 
 		const object = this.object !== null ? this.object : frame.object;
-		const value = object[ this.property ];
+		const property = this.property;
 
-		this.node.value = value;
+		this.node.value = object[ property ];
 
 	}
 
-	generate( builder ) {
+	construct( /*builder*/ ) {
 
-		return this.node.build( builder, this.getNodeType( builder ) );
+		return this.node;
 
 	}
 
 }
 
 export default ReferenceNode;
+
+export const reference = ( name, type, object ) => nodeObject( new ReferenceNode( name, type, object ) );
+
+addNodeClass( ReferenceNode );

package/examples/jsm/nodes/accessors/ReflectVectorNode.js

@@ -1,8 +1,8 @@
-import Node from '../core/Node.js';
-import {
-	transformedNormalView, positionViewDirection,
-	transformDirection, negate, reflect, cameraViewMatrix
-} from '../shadernode/ShaderNodeBaseElements.js';
+import Node, { addNodeClass } from '../core/Node.js';
+import { cameraViewMatrix } from './CameraNode.js';
+import { transformedNormalView } from './NormalNode.js';
+import { positionViewDirection } from './PositionNode.js';
+import { nodeImmutable } from '../shadernode/ShaderNode.js';
 
 class ReflectVectorNode extends Node {
 
@@ -20,12 +20,16 @@ class ReflectVectorNode extends Node {
 
 	construct() {
 
-		const reflectView = reflect( negate( positionViewDirection ), transformedNormalView );
+		const reflectView = positionViewDirection.negate().reflect( transformedNormalView );
 
-		return transformDirection( reflectView, cameraViewMatrix );
+		return reflectView.transformDirection( cameraViewMatrix );
 
 	}
 
 }
 
 export default ReflectVectorNode;
+
+export const reflectVector = nodeImmutable( ReflectVectorNode );
+
+addNodeClass( ReflectVectorNode );

package/examples/jsm/nodes/accessors/SceneNode.js

@@ -0,0 +1,46 @@
+import Node from '../core/Node.js';
+import { addNodeClass } from '../core/Node.js';
+import { nodeImmutable } from '../shadernode/ShaderNode.js';
+import { reference } from './ReferenceNode.js';
+
+class SceneNode extends Node {
+
+	constructor( scope = SceneNode.BACKGROUND_BLURRINESS, scene = null ) {
+
+		super();
+
+		this.scope = scope;
+		this.scene = scene;
+
+	}
+
+	construct( builder ) {
+
+		const scope = this.scope;
+		const scene = this.scene !== null ? this.scene : builder.scene;
+
+		let output;
+
+		if ( scope === SceneNode.BACKGROUND_BLURRINESS ) {
+
+			output = reference( 'backgroundBlurriness', 'float', scene );
+
+		} else {
+
+			console.error( 'THREE.SceneNode: Unknown scope:', scope );
+
+		}
+
+		return output;
+
+	}
+
+}
+
+SceneNode.BACKGROUND_BLURRINESS = 'backgroundBlurriness';
+
+export default SceneNode;
+
+export const backgroundBlurriness = nodeImmutable( SceneNode, SceneNode.BACKGROUND_BLURRINESS );
+
+addNodeClass( SceneNode );

package/examples/jsm/nodes/accessors/SkinningNode.js

@@ -1,100 +1,80 @@
-import Node from '../core/Node.js';
-import {
-	ShaderNode,
-	attribute,
-	buffer,
-	mat4,
-	uniform,
-	positionLocal,
-	normalLocal,
-	tangentLocal,
-	assign,
-	element,
-	add,
-	mul,
-	transformDirection
-} from '../shadernode/ShaderNodeBaseElements.js';
-
+import Node, { addNodeClass } from '../core/Node.js';
 import { NodeUpdateType } from '../core/constants.js';
+import { nodeProxy } from '../shadernode/ShaderNode.js';
+import { attribute } from '../core/AttributeNode.js';
+import { uniform } from '../core/UniformNode.js';
+import { add } from '../math/OperatorNode.js';
+import { buffer } from './BufferNode.js';
+import { normalLocal } from './NormalNode.js';
+import { positionLocal } from './PositionNode.js';
+import { tangentLocal } from './TangentNode.js';
 
-const Skinning = new ShaderNode( ( inputs, builder ) => {
+class SkinningNode extends Node {
 
-	const { index, weight, bindMatrix, bindMatrixInverse, boneMatrices } = inputs;
+	constructor( skinnedMesh ) {
 
-	const boneMatX = element( boneMatrices, index.x );
-	const boneMatY = element( boneMatrices, index.y );
-	const boneMatZ = element( boneMatrices, index.z );
-	const boneMatW = element( boneMatrices, index.w );
+		super( 'void' );
 
-	// POSITION
+		this.skinnedMesh = skinnedMesh;
 
-	const skinVertex = mul( bindMatrix, positionLocal );
+		this.updateType = NodeUpdateType.OBJECT;
 
-	const skinned = add(
-		mul( mul( boneMatX, skinVertex ), weight.x ),
-		mul( mul( boneMatY, skinVertex ), weight.y ),
-		mul( mul( boneMatZ, skinVertex ), weight.z ),
-		mul( mul( boneMatW, skinVertex ), weight.w )
-	);
+		//
 
-	const skinPosition = mul( bindMatrixInverse, skinned ).xyz;
+		this.skinIndexNode = attribute( 'skinIndex', 'uvec4' );
+		this.skinWeightNode = attribute( 'skinWeight', 'vec4' );
 
-	// NORMAL
+		this.bindMatrixNode = uniform( skinnedMesh.bindMatrix, 'mat4' );
+		this.bindMatrixInverseNode = uniform( skinnedMesh.bindMatrixInverse, 'mat4' );
+		this.boneMatricesNode = buffer( skinnedMesh.skeleton.boneMatrices, 'mat4', skinnedMesh.skeleton.bones.length );
 
-	let skinMatrix = add(
-		mul( weight.x, boneMatX ),
-		mul( weight.y, boneMatY ),
-		mul( weight.z, boneMatZ ),
-		mul( weight.w, boneMatW )
-	);
+	}
 
-	skinMatrix = mul( mul( bindMatrixInverse, skinMatrix ), bindMatrix );
+	construct( builder ) {
 
-	const skinNormal = transformDirection( skinMatrix, normalLocal ).xyz;
+		const { skinIndexNode, skinWeightNode, bindMatrixNode, bindMatrixInverseNode, boneMatricesNode } = this;
 
-	// ASSIGNS
+		const boneMatX = boneMatricesNode.element( skinIndexNode.x );
+		const boneMatY = boneMatricesNode.element( skinIndexNode.y );
+		const boneMatZ = boneMatricesNode.element( skinIndexNode.z );
+		const boneMatW = boneMatricesNode.element( skinIndexNode.w );
 
-	assign( positionLocal, skinPosition ).build( builder );
-	assign( normalLocal, skinNormal ).build( builder );
+		// POSITION
 
-	if ( builder.hasGeometryAttribute( 'tangent' ) ) {
+		const skinVertex = bindMatrixNode.mul( positionLocal );
 
-		assign( tangentLocal, skinNormal ).build( builder );
+		const skinned = add(
+			boneMatX.mul( skinWeightNode.x ).mul( skinVertex ),
+			boneMatY.mul( skinWeightNode.y ).mul( skinVertex ),
+			boneMatZ.mul( skinWeightNode.z ).mul( skinVertex ),
+			boneMatW.mul( skinWeightNode.w ).mul( skinVertex )
+		);
 
-	}
+		const skinPosition = bindMatrixInverseNode.mul( skinned ).xyz;
 
-} );
+		// NORMAL
 
-class SkinningNode extends Node {
+		let skinMatrix = add(
+			skinWeightNode.x.mul( boneMatX ),
+			skinWeightNode.y.mul( boneMatY ),
+			skinWeightNode.z.mul( boneMatZ ),
+			skinWeightNode.w.mul( boneMatW )
+		);
 
-	constructor( skinnedMesh ) {
+		skinMatrix = bindMatrixInverseNode.mul( skinMatrix ).mul( bindMatrixNode );
 
-		super( 'void' );
+		const skinNormal = skinMatrix.transformDirection( normalLocal ).xyz;
 
-		this.skinnedMesh = skinnedMesh;
+		// ASSIGNS
 
-		this.updateType = NodeUpdateType.OBJECT;
+		builder.stack.assign( positionLocal, skinPosition );
+		builder.stack.assign( normalLocal, skinNormal );
 
-		//
+		if ( builder.hasGeometryAttribute( 'tangent' ) ) {
 
-		this.skinIndexNode = attribute( 'skinIndex', 'uvec4' );
-		this.skinWeightNode = attribute( 'skinWeight', 'vec4' );
+			builder.stack.assign( tangentLocal, skinNormal );
 
-		this.bindMatrixNode = uniform( mat4( skinnedMesh.bindMatrix ) );
-		this.bindMatrixInverseNode = uniform( mat4( skinnedMesh.bindMatrixInverse ) );
-		this.boneMatricesNode = buffer( skinnedMesh.skeleton.boneMatrices, 'mat4', skinnedMesh.skeleton.bones.length );
-
-	}
-
-	generate( builder ) {
-
-		Skinning.call( {
-			index: this.skinIndexNode,
-			weight: this.skinWeightNode,
-			bindMatrix: this.bindMatrixNode,
-			bindMatrixInverse: this.bindMatrixInverseNode,
-			boneMatrices: this.boneMatricesNode
-		}, builder );
+		}
 
 	}
 
@@ -107,3 +87,7 @@ class SkinningNode extends Node {
 }
 
 export default SkinningNode;
+
+export const skinning = nodeProxy( SkinningNode );
+
+addNodeClass( SkinningNode );

package/examples/jsm/nodes/accessors/StorageBufferNode.js

@@ -1,4 +1,6 @@
 import BufferNode from './BufferNode.js';
+import { addNodeClass } from '../core/Node.js';
+import { nodeObject } from '../shadernode/ShaderNode.js';
 
 class StorageBufferNode extends BufferNode {
 
@@ -19,3 +21,7 @@ class StorageBufferNode extends BufferNode {
 }
 
 export default StorageBufferNode;
+
+export const storage = ( value, type, count ) => nodeObject( new StorageBufferNode( value, type, count ) );
+
+addNodeClass( StorageBufferNode );

package/examples/jsm/nodes/accessors/TangentNode.js

@@ -1,19 +1,14 @@
-import Node from '../core/Node.js';
-import AttributeNode from '../core/AttributeNode.js';
-import VaryingNode from '../core/VaryingNode.js';
-import ModelNode from '../accessors/ModelNode.js';
-import CameraNode from '../accessors/CameraNode.js';
-import OperatorNode from '../math/OperatorNode.js';
-import MathNode from '../math/MathNode.js';
-import SplitNode from '../utils/SplitNode.js';
+import Node, { addNodeClass } from '../core/Node.js';
+import { attribute } from '../core/AttributeNode.js';
+import { temp } from '../core/VarNode.js';
+import { varying } from '../core/VaryingNode.js';
+import { normalize } from '../math/MathNode.js';
+import { cameraViewMatrix } from './CameraNode.js';
+import { modelViewMatrix } from './ModelNode.js';
+import { nodeImmutable } from '../shadernode/ShaderNode.js';
 
 class TangentNode extends Node {
 
-	static GEOMETRY = 'geometry';
-	static LOCAL = 'local';
-	static VIEW = 'view';
-	static WORLD = 'world';
-
 	constructor( scope = TangentNode.LOCAL ) {
 
 		super();
@@ -51,22 +46,21 @@ class TangentNode extends Node {
 
 		if ( scope === TangentNode.GEOMETRY ) {
 
-			outputNode = new AttributeNode( 'tangent', 'vec4' );
+			outputNode = attribute( 'tangent', 'vec4' );
 
 		} else if ( scope === TangentNode.LOCAL ) {
 
-			outputNode = new VaryingNode( new SplitNode( new TangentNode( TangentNode.GEOMETRY ), 'xyz' ) );
+			outputNode = varying( tangentGeometry.xyz );
 
 		} else if ( scope === TangentNode.VIEW ) {
 
-			const vertexNode = new SplitNode( new OperatorNode( '*', new ModelNode( ModelNode.VIEW_MATRIX ), new TangentNode( TangentNode.LOCAL ) ), 'xyz' );
-
-			outputNode = new MathNode( MathNode.NORMALIZE, new VaryingNode( vertexNode ) );
+			const vertexNode = modelViewMatrix.mul( tangentLocal ).xyz;
+			outputNode = normalize( varying( vertexNode ) );
 
 		} else if ( scope === TangentNode.WORLD ) {
 
-			const vertexNode = new MathNode( MathNode.TRANSFORM_DIRECTION, new TangentNode( TangentNode.VIEW ), new CameraNode( CameraNode.VIEW_MATRIX ) );
-			outputNode = new MathNode( MathNode.NORMALIZE, new VaryingNode( vertexNode ) );
+			const vertexNode = tangentView.transformDirection( cameraViewMatrix );
+			outputNode = normalize( varying( vertexNode ) );
 
 		}
 
@@ -92,4 +86,18 @@ class TangentNode extends Node {
 
 }
 
+TangentNode.GEOMETRY = 'geometry';
+TangentNode.LOCAL = 'local';
+TangentNode.VIEW = 'view';
+TangentNode.WORLD = 'world';
+
 export default TangentNode;
+
+export const tangentGeometry = nodeImmutable( TangentNode, TangentNode.GEOMETRY );
+export const tangentLocal = nodeImmutable( TangentNode, TangentNode.LOCAL );
+export const tangentView = nodeImmutable( TangentNode, TangentNode.VIEW );
+export const tangentWorld = nodeImmutable( TangentNode, TangentNode.WORLD );
+export const transformedTangentView = temp( tangentView, 'TransformedTangentView' );
+export const transformedTangentWorld = normalize( transformedTangentView.transformDirection( cameraViewMatrix ) );
+
+addNodeClass( TangentNode );

package/examples/jsm/nodes/accessors/TextureBicubicNode.js

@@ -0,0 +1,94 @@
+import TempNode from '../core/TempNode.js';
+import { addNodeClass } from '../core/Node.js';
+import { add, mul, div } from '../math/OperatorNode.js';
+import { floor, ceil, fract, pow } from '../math/MathNode.js';
+import { nodeProxy, addNodeElement, float, vec2, vec4, int } from '../shadernode/ShaderNode.js';
+
+// Mipped Bicubic Texture Filtering by N8
+// https://www.shadertoy.com/view/Dl2SDW
+
+const bC = 1.0 / 6.0;
+
+const w0 = ( a ) => mul( bC, mul( a, mul( a, a.negate().add( 3.0 ) ).sub( 3.0 ) ).add( 1.0 ) );
+
+const w1 = ( a ) => mul( bC, mul( a, mul( a, mul( 3.0, a ).sub( 6.0 ) ) ).add( 4.0 ) );
+
+const w2 = ( a ) => mul( bC, mul( a, mul( a, mul( - 3.0, a ).add( 3.0 ) ).add( 3.0 ) ).add( 1.0 ) );
+
+const w3 = ( a ) => mul( bC, pow( a, 3 ) );
+
+const g0 = ( a ) => w0( a ).add( w1( a ) );
+
+const g1 = ( a ) => w2( a ).add( w3( a ) );
+
+// h0 and h1 are the two offset functions
+const h0 = ( a ) => add( - 1.0, w1( a ).div( w0( a ).add( w1( a ) ) ) );
+
+const h1 = ( a ) => add( 1.0, w3( a ).div( w2( a ).add( w3( a ) ) ) );
+
+const bicubic = ( textureNode, texelSize, lod ) => {
+
+	const uv = textureNode.uvNode;
+	const uvScaled = mul( uv, texelSize.zw ).add( 0.5 );
+
+	const iuv = floor( uvScaled );
+	const fuv = fract( uvScaled );
+
+	const g0x = g0( fuv.x );
+	const g1x = g1( fuv.x );
+	const h0x = h0( fuv.x );
+	const h1x = h1( fuv.x );
+	const h0y = h0( fuv.y );
+	const h1y = h1( fuv.y );
+
+	const p0 = vec2( iuv.x.add( h0x ), iuv.y.add( h0y ) ).sub( 0.5 ).mul( texelSize.xy );
+	const p1 = vec2( iuv.x.add( h1x ), iuv.y.add( h0y ) ).sub( 0.5 ).mul( texelSize.xy );
+	const p2 = vec2( iuv.x.add( h0x ), iuv.y.add( h1y ) ).sub( 0.5 ).mul( texelSize.xy );
+	const p3 = vec2( iuv.x.add( h1x ), iuv.y.add( h1y ) ).sub( 0.5 ).mul( texelSize.xy );
+
+	const a = g0( fuv.y ).mul( add( g0x.mul( textureNode.uv( p0 ).level( lod ) ), g1x.mul( textureNode.uv( p1 ).level( lod ) ) ) );
+	const b = g1( fuv.y ).mul( add( g0x.mul( textureNode.uv( p2 ).level( lod ) ), g1x.mul( textureNode.uv( p3 ).level( lod ) ) ) );
+
+	return a.add( b );
+
+};
+
+const textureBicubicMethod = ( textureNode, lodNode ) => {
+
+	const fLodSize = vec2( textureNode.size( int( lodNode ) ) );
+	const cLodSize = vec2( textureNode.size( int( lodNode.add( 1.0 ) ) ) );
+	const fLodSizeInv = div( 1.0, fLodSize );
+	const cLodSizeInv = div( 1.0, cLodSize );
+	const fSample = bicubic( textureNode, vec4( fLodSizeInv, fLodSize ), floor( lodNode ) );
+	const cSample = bicubic( textureNode, vec4( cLodSizeInv, cLodSize ), ceil( lodNode ) );
+
+	return fract( lodNode ).mix( fSample, cSample );
+
+};
+
+class TextureBicubicNode extends TempNode {
+
+	constructor( textureNode, blurNode = float( 3 ) ) {
+
+		super( 'vec4' );
+
+		this.textureNode = textureNode;
+		this.blurNode = blurNode;
+
+	}
+
+	construct() {
+
+		return textureBicubicMethod( this.textureNode, this.blurNode );
+
+	}
+
+}
+
+export default TextureBicubicNode;
+
+export const textureBicubic = nodeProxy( TextureBicubicNode );
+
+addNodeElement( 'bicubic', textureBicubic );
+
+addNodeClass( TextureBicubicNode );