super-three 0.136.1 → 0.144.0

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

@@ -1,139 +1,79 @@
-import { TempNode } from '../core/TempNode.js';
-import { NodeLib } from '../core/NodeLib.js';
+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';
 
-class NormalNode extends TempNode {
+class NormalNode extends Node {
 
-	constructor( scope ) {
+	static GEOMETRY = 'geometry';
+	static LOCAL = 'local';
+	static WORLD = 'world';
+	static VIEW = 'view';
 
-		super( 'v3' );
+	constructor( scope = NormalNode.LOCAL ) {
 
-		this.scope = scope || NormalNode.VIEW;
+		super( 'vec3' );
 
-	}
-
-	getShared() {
-
-		// if shared is false, TempNode will not create temp variable (for optimization)
-
-		return this.scope === NormalNode.WORLD;
+		this.scope = scope;
 
 	}
 
-	build( builder, output, uuid, ns ) {
-
-		const contextNormal = builder.context[ this.scope + 'Normal' ];
+	getHash( /*builder*/ ) {
 
-		if ( contextNormal ) {
-
-			return contextNormal.build( builder, output, uuid, ns );
-
-		}
-
-		return super.build( builder, output, uuid );
+		return `normal-${this.scope}`;
 
 	}
 
-	generate( builder, output ) {
-
-		let result;
-
-		switch ( this.scope ) {
-
-			case NormalNode.VIEW:
-
-				if ( builder.isShader( 'vertex' ) ) result = 'transformedNormal';
-				else result = 'geometryNormal';
-
-				break;
-
-			case NormalNode.LOCAL:
-
-				if ( builder.isShader( 'vertex' ) ) {
-
-					result = 'objectNormal';
-
-				} else {
-
-					builder.requires.normal = true;
+	generate( builder ) {
 
-					result = 'vObjectNormal';
+		const scope = this.scope;
 
-				}
+		let outputNode = null;
 
-				break;
+		if ( scope === NormalNode.GEOMETRY ) {
 
-			case NormalNode.WORLD:
+			outputNode = new AttributeNode( 'normal', 'vec3' );
 
-				if ( builder.isShader( 'vertex' ) ) {
+		} else if ( scope === NormalNode.LOCAL ) {
 
-					result = 'inverseTransformDirection( transformedNormal, viewMatrix ).xyz';
+			outputNode = new VaryingNode( new NormalNode( NormalNode.GEOMETRY ) );
 
-				} else {
+		} else if ( scope === NormalNode.VIEW ) {
 
-					builder.requires.worldNormal = true;
+			const vertexNormalNode = new OperatorNode( '*', new ModelNode( ModelNode.NORMAL_MATRIX ), new NormalNode( NormalNode.LOCAL ) );
+			outputNode = new MathNode( MathNode.NORMALIZE, new VaryingNode( vertexNormalNode ) );
 
-					result = 'vWNormal';
+		} else if ( scope === NormalNode.WORLD ) {
 
-				}
-
-				break;
+			// To use INVERSE_TRANSFORM_DIRECTION only inverse the param order like this: MathNode( ..., Vector, Matrix );
+			const vertexNormalNode = new MathNode( MathNode.TRANSFORM_DIRECTION, new NormalNode( NormalNode.VIEW ), new CameraNode( CameraNode.VIEW_MATRIX ) );
+			outputNode = new MathNode( MathNode.NORMALIZE, new VaryingNode( vertexNormalNode ) );
 
 		}
 
-		return builder.format( result, this.getType( builder ), output );
+		return outputNode.build( builder );
 
 	}
 
-	copy( source ) {
-
-		super.copy( source );
+	serialize( data ) {
 
-		this.scope = source.scope;
+		super.serialize( data );
 
-		return this;
+		data.scope = this.scope;
 
 	}
 
-	toJSON( meta ) {
-
-		let data = this.getJSONNode( meta );
+	deserialize( data ) {
 
-		if ( ! data ) {
+		super.deserialize( data );
 
-			data = this.createJSONNode( meta );
-
-			data.scope = this.scope;
-
-		}
-
-		return data;
+		this.scope = data.scope;
 
 	}
 
 }
 
-NormalNode.LOCAL = 'local';
-NormalNode.WORLD = 'world';
-NormalNode.VIEW = 'view';
-
-NormalNode.prototype.nodeType = 'Normal';
-
-NodeLib.addKeyword( 'viewNormal', function () {
-
-	return new NormalNode( NormalNode.VIEW );
-
-} );
-
-NodeLib.addKeyword( 'localNormal', function () {
-
-	return new NormalNode( NormalNode.NORMAL );
-
-} );
-
-NodeLib.addKeyword( 'worldNormal', function () {
-
-	return new NormalNode( NormalNode.WORLD );
-
-} );
-
-export { NormalNode };
+export default NormalNode;

package/examples/jsm/{renderers/nodes → nodes}/accessors/Object3DNode.js

@@ -1,7 +1,6 @@
+import { Vector3 } from 'three';
 import Node from '../core/Node.js';
-import Matrix4Node from '../inputs/Matrix4Node.js';
-import Matrix3Node from '../inputs/Matrix3Node.js';
-import Vector3Node from '../inputs/Vector3Node.js';
+import UniformNode from '../core/UniformNode.js';
 import { NodeUpdateType } from '../core/constants.js';
 
 class Object3DNode extends Node {
@@ -21,7 +20,7 @@ class Object3DNode extends Node {
 
 		this.updateType = NodeUpdateType.Object;
 
-		this._inputNode = null;
+		this._uniformNode = new UniformNode( null );
 
 	}
 
@@ -47,32 +46,34 @@ class Object3DNode extends Node {
 
 	update( frame ) {
 
-		const object = this.object3d !== null ? this.object3d : frame.object;
-		const inputNode = this._inputNode;
-		const camera = frame.camera;
+		const object = this.object3d;
+		const uniformNode = this._uniformNode;
 		const scope = this.scope;
 
 		if ( scope === Object3DNode.VIEW_MATRIX ) {
 
-			inputNode.value = object.modelViewMatrix;
+			uniformNode.value = object.modelViewMatrix;
 
 		} else if ( scope === Object3DNode.NORMAL_MATRIX ) {
 
-			inputNode.value = object.normalMatrix;
+			uniformNode.value = object.normalMatrix;
 
 		} else if ( scope === Object3DNode.WORLD_MATRIX ) {
 
-			inputNode.value = object.matrixWorld;
+			uniformNode.value = object.matrixWorld;
 
 		} else if ( scope === Object3DNode.POSITION ) {
 
-			inputNode.value.setFromMatrixPosition( object.matrixWorld );
+			uniformNode.value.setFromMatrixPosition( object.matrixWorld );
 
 		} else if ( scope === Object3DNode.VIEW_POSITION ) {
 
-			inputNode.value.setFromMatrixPosition( object.matrixWorld );
+			const camera = frame.camera;
 
-			inputNode.value.applyMatrix4( camera.matrixWorldInverse );
+			uniformNode.value = uniformNode.value || new Vector3();
+			uniformNode.value.setFromMatrixPosition( object.matrixWorld );
+
+			uniformNode.value.applyMatrix4( camera.matrixWorldInverse );
 
 		}
 
@@ -84,19 +85,35 @@ class Object3DNode extends Node {
 
 		if ( scope === Object3DNode.WORLD_MATRIX || scope === Object3DNode.VIEW_MATRIX ) {
 
-			this._inputNode = new Matrix4Node( /*null*/ );
+			this._uniformNode.nodeType = 'mat4';
 
 		} else if ( scope === Object3DNode.NORMAL_MATRIX ) {
 
-			this._inputNode = new Matrix3Node( /*null*/ );
+			this._uniformNode.nodeType = 'mat3';
 
 		} else if ( scope === Object3DNode.POSITION || scope === Object3DNode.VIEW_POSITION ) {
 
-			this._inputNode = new Vector3Node();
+			this._uniformNode.nodeType = 'vec3';
 
 		}
 
-		return this._inputNode.build( builder );
+		return this._uniformNode.build( builder );
+
+	}
+
+	serialize( data ) {
+
+		super.serialize( data );
+
+		data.scope = this.scope;
+
+	}
+
+	deserialize( data ) {
+
+		super.deserialize( data );
+
+		this.scope = data.scope;
 
 	}
 

package/examples/jsm/{renderers/nodes → nodes}/accessors/PointUVNode.js

@@ -6,6 +6,8 @@ class PointUVNode extends Node {
 
 		super( 'vec2' );
 
+		this.isPointUVNode = true;
+
 	}
 
 	generate( /*builder*/ ) {
@@ -16,6 +18,4 @@ class PointUVNode extends Node {
 
 }
 
-PointUVNode.prototype.isPointUVNode = true;
-
 export default PointUVNode;

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

@@ -1,152 +1,83 @@
-import { TempNode } from '../core/TempNode.js';
-import { NodeLib } from '../core/NodeLib.js';
+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';
 
-class PositionNode extends TempNode {
+class PositionNode extends Node {
 
-	constructor( scope ) {
+	static GEOMETRY = 'geometry';
+	static LOCAL = 'local';
+	static WORLD = 'world';
+	static VIEW = 'view';
+	static VIEW_DIRECTION = 'viewDirection';
 
-		super( 'v3' );
+	constructor( scope = PositionNode.LOCAL ) {
 
-		this.scope = scope || PositionNode.LOCAL;
+		super( 'vec3' );
 
-	}
-
-	getType( ) {
-
-		switch ( this.scope ) {
-
-			case PositionNode.PROJECTION:
-
-				return 'v4';
-
-		}
-
-		return this.type;
+		this.scope = scope;
 
 	}
 
-	getShared( /* builder */ ) {
-
-		switch ( this.scope ) {
+	getHash( /*builder*/ ) {
 
-			case PositionNode.LOCAL:
-			case PositionNode.WORLD:
-
-				return false;
-
-		}
-
-		return true;
+		return `position-${this.scope}`;
 
 	}
 
-	generate( builder, output ) {
-
-		let result;
-
-		switch ( this.scope ) {
-
-			case PositionNode.LOCAL:
-
-				if ( builder.isShader( 'vertex' ) ) {
-
-					result = 'transformed';
-
-				} else {
-
-					builder.requires.position = true;
-
-					result = 'vPosition';
+	generate( builder ) {
 
-				}
+		const scope = this.scope;
 
-				break;
+		let outputNode = null;
 
-			case PositionNode.WORLD:
+		if ( scope === PositionNode.GEOMETRY ) {
 
-				if ( builder.isShader( 'vertex' ) ) {
+			outputNode = new AttributeNode( 'position', 'vec3' );
 
-					return '( modelMatrix * vec4( transformed, 1.0 ) ).xyz';
+		} else if ( scope === PositionNode.LOCAL ) {
 
-				} else {
+			outputNode = new VaryingNode( new PositionNode( PositionNode.GEOMETRY ) );
 
-					builder.requires.worldPosition = true;
+		} else if ( scope === PositionNode.WORLD ) {
 
-					result = 'vWPosition';
+			const vertexPositionNode = new MathNode( MathNode.TRANSFORM_DIRECTION, new ModelNode( ModelNode.WORLD_MATRIX ), new PositionNode( PositionNode.LOCAL ) );
+			outputNode = new VaryingNode( vertexPositionNode );
 
-				}
+		} else if ( scope === PositionNode.VIEW ) {
 
-				break;
+			const vertexPositionNode = new OperatorNode( '*', new ModelNode( ModelNode.VIEW_MATRIX ), new PositionNode( PositionNode.LOCAL ) );
+			outputNode = new VaryingNode( vertexPositionNode );
 
-			case PositionNode.VIEW:
+		} else if ( scope === PositionNode.VIEW_DIRECTION ) {
 
-				result = builder.isShader( 'vertex' ) ? '-mvPosition.xyz' : 'vViewPosition';
-
-				break;
-
-			case PositionNode.PROJECTION:
-
-				result = builder.isShader( 'vertex' ) ? '( projectionMatrix * modelViewMatrix * vec4( position, 1.0 ) )' : 'vec4( 0.0 )';
-
-				break;
+			const vertexPositionNode = new MathNode( MathNode.NEGATE, new PositionNode( PositionNode.VIEW ) );
+			outputNode = new MathNode( MathNode.NORMALIZE, new VaryingNode( vertexPositionNode ) );
 
 		}
 
-		return builder.format( result, this.getType( builder ), output );
+		return outputNode.build( builder, this.getNodeType( builder ) );
 
 	}
 
-	copy( source ) {
-
-		super.copy( source );
+	serialize( data ) {
 
-		this.scope = source.scope;
+		super.serialize( data );
 
-		return this;
+		data.scope = this.scope;
 
 	}
 
-	toJSON( meta ) {
-
-		let data = this.getJSONNode( meta );
+	deserialize( data ) {
 
-		if ( ! data ) {
+		super.deserialize( data );
 
-			data = this.createJSONNode( meta );
-
-			data.scope = this.scope;
-
-		}
-
-		return data;
+		this.scope = data.scope;
 
 	}
 
 }
 
-PositionNode.LOCAL = 'local';
-PositionNode.WORLD = 'world';
-PositionNode.VIEW = 'view';
-PositionNode.PROJECTION = 'projection';
-
-PositionNode.prototype.nodeType = 'Position';
-
-NodeLib.addKeyword( 'position', function () {
-
-	return new PositionNode();
-
-} );
-
-NodeLib.addKeyword( 'worldPosition', function () {
-
-	return new PositionNode( PositionNode.WORLD );
-
-} );
-
-NodeLib.addKeyword( 'viewPosition', function () {
-
-	return new PositionNode( PositionNode.VIEW );
-
-} );
-
-export { PositionNode };
+export default PositionNode;

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

@@ -0,0 +1,65 @@
+import Node from '../core/Node.js';
+import UniformNode from '../core/UniformNode.js';
+import { NodeUpdateType } from '../core/constants.js';
+
+class ReferenceNode extends Node {
+
+	constructor( property, uniformType, object = null ) {
+
+		super();
+
+		this.property = property;
+
+		this.uniformType = uniformType;
+
+		this.object = object;
+
+		this.node = null;
+
+		this.updateType = NodeUpdateType.Object;
+
+		this.setNodeType( uniformType );
+
+	}
+
+	setNodeType( uniformType ) {
+
+		this.node = new UniformNode( null, uniformType );
+		this.nodeType = uniformType;
+
+		if ( uniformType === 'color' ) {
+
+			this.nodeType = 'vec3';
+
+		} else if ( uniformType === 'texture' ) {
+
+			this.nodeType = 'vec4';
+
+		}
+
+	}
+
+	getNodeType() {
+
+		return this.uniformType;
+
+	}
+
+	update( frame ) {
+
+		const object = this.object !== null ? this.object : frame.object;
+		const value = object[ this.property ];
+
+		this.node.value = value;
+
+	}
+
+	generate( builder ) {
+
+		return this.node.build( builder, this.getNodeType( builder ) );
+
+	}
+
+}
+
+export default ReferenceNode;

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

@@ -0,0 +1,31 @@
+import Node from '../core/Node.js';
+import {
+	transformedNormalView, positionViewDirection,
+	transformDirection, negate, reflect, cameraViewMatrix
+} from '../shadernode/ShaderNodeBaseElements.js';
+
+class ReflectVectorNode extends Node {
+
+	constructor() {
+
+		super( 'vec3' );
+
+	}
+
+	getHash( /*builder*/ ) {
+
+		return 'reflectVector';
+
+	}
+
+	construct() {
+
+		const reflectView = reflect( negate( positionViewDirection ), transformedNormalView );
+
+		return transformDirection( reflectView, cameraViewMatrix );
+
+	}
+
+}
+
+export default ReflectVectorNode;

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

@@ -0,0 +1,102 @@
+import Node from '../core/Node.js';
+import {
+	ShaderNode,
+	attribute,
+	buffer,
+	mat4,
+	uniform,
+	positionLocal,
+	normalLocal,
+	assign,
+	element,
+	add,
+	mul,
+	transformDirection
+} from '../shadernode/ShaderNodeBaseElements.js';
+
+import { NodeUpdateType } from '../core/constants.js';
+
+const Skinning = new ShaderNode( ( inputs, builder ) => {
+
+	const { index, weight, bindMatrix, bindMatrixInverse, boneMatrices } = inputs;
+
+	const boneMatX = element( boneMatrices, index.x );
+	const boneMatY = element( boneMatrices, index.y );
+	const boneMatZ = element( boneMatrices, index.z );
+	const boneMatW = element( boneMatrices, index.w );
+
+	// POSITION
+
+	const skinVertex = mul( bindMatrix, positionLocal );
+
+	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;
+
+	// NORMAL
+
+	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 );
+
+	const skinNormal = transformDirection( skinMatrix, normalLocal ).xyz;
+
+	// ASSIGNS
+
+	assign( positionLocal, skinPosition ).build( builder );
+	assign( normalLocal, skinNormal ).build( builder );
+
+} );
+
+class SkinningNode extends Node {
+
+	constructor( skinnedMesh ) {
+
+		super( 'void' );
+
+		this.skinnedMesh = skinnedMesh;
+
+		this.updateType = NodeUpdateType.Object;
+
+		//
+
+		this.skinIndexNode = attribute( 'skinIndex', 'uvec4' );
+		this.skinWeightNode = attribute( 'skinWeight', 'vec4' );
+
+		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 );
+
+	}
+
+	update() {
+
+		this.skinnedMesh.skeleton.update();
+
+	}
+
+}
+
+export default SkinningNode;