super-three 0.147.0 → 0.152.0

package/examples/jsm/nodes/code/ScriptableValueNode.js

@@ -0,0 +1,167 @@
+import Node, { addNodeClass } from '../core/Node.js';
+import { arrayBufferToBase64, base64ToArrayBuffer } from '../core/NodeUtils.js';
+import { addNodeElement, nodeProxy, float } from '../shadernode/ShaderNode.js';
+import { EventDispatcher } from 'three';
+
+class ScriptableValueNode extends Node {
+
+	constructor( value = null ) {
+
+		super();
+
+		this._value = value;
+		this._cache = null;
+
+		this.inputType = null;
+		this.outpuType = null;
+
+		this.events = new EventDispatcher();
+
+		this.isScriptableValueNode = true;
+
+	}
+
+	get isScriptableOutputNode() {
+
+		return this.outputType !== null;
+
+	}
+
+	set value( val ) {
+
+		if ( this._value === val ) return;
+
+		if ( this._cache && this.inputType === 'URL' && this.value.value instanceof ArrayBuffer ) {
+
+			URL.revokeObjectURL( this._cache );
+
+			this._cache = null;
+
+		}
+
+		this._value = val;
+
+		this.events.dispatchEvent( { type: 'change' } );
+
+		this.refresh();
+
+	}
+
+	get value() {
+
+		return this._value;
+
+	}
+
+	refresh() {
+
+		this.events.dispatchEvent( { type: 'refresh' } );
+
+	}
+
+	getValue() {
+
+		const value = this.value;
+
+		if ( value && this._cache === null && this.inputType === 'URL' && value.value instanceof ArrayBuffer ) {
+
+			this._cache = URL.createObjectURL( new Blob( [ value.value ] ) );
+
+		} else if ( value && value.value !== null && value.value !== undefined && (
+			( ( this.inputType === 'URL' || this.inputType === 'String' ) && typeof value.value === 'string' ) ||
+			( this.inputType === 'Number' && typeof value.value === 'number' ) ||
+			( this.inputType === 'Vector2' && value.value.isVector2 ) ||
+			( this.inputType === 'Vector3' && value.value.isVector3 ) ||
+			( this.inputType === 'Vector4' && value.value.isVector4 ) ||
+			( this.inputType === 'Color' && value.value.isColor ) ||
+			( this.inputType === 'Matrix3' && value.value.isMatrix3 ) ||
+			( this.inputType === 'Matrix4' && value.value.isMatrix4 )
+		) ) {
+
+			return value.value;
+
+		}
+
+		return this._cache || value;
+
+	}
+
+	getNodeType( builder ) {
+
+		return this.value && this.value.isNode ? this.value.getNodeType( builder ) : 'float';
+
+	}
+
+	construct() {
+
+		return this.value && this.value.isNode ? this.value : float();
+
+	}
+
+	serialize( data ) {
+
+		super.serialize( data );
+
+		if ( this.value !== null ) {
+
+			if ( this.inputType === 'ArrayBuffer' ) {
+
+				data.value = arrayBufferToBase64( this.value );
+
+			} else {
+
+				data.value = this.value ? this.value.toJSON( data.meta ).uuid : null;
+
+			}
+
+		} else {
+
+			data.value = null;
+
+		}
+
+		data.inputType = this.inputType;
+		data.outputType = this.outputType;
+
+	}
+
+	deserialize( data ) {
+
+		super.deserialize( data );
+
+		let value = null;
+
+		if ( data.value !== null ) {
+
+			if ( data.inputType === 'ArrayBuffer' ) {
+
+				value = base64ToArrayBuffer( data.value );
+
+			} else if ( data.inputType === 'Texture' ) {
+
+				value = data.meta.textures[ data.value ];
+
+			} else {
+
+				value = data.meta.nodes[ data.value ] || null;
+
+			}
+
+		}
+
+		this.value = value;
+
+		this.inputType = data.inputType;
+		this.outputType = data.outputType;
+
+	}
+
+}
+
+export default ScriptableValueNode;
+
+export const scriptableValue = nodeProxy( ScriptableValueNode );
+
+addNodeElement( 'scriptableValue', scriptableValue );
+
+addNodeClass( ScriptableValueNode );

package/examples/jsm/nodes/core/ArrayUniformNode.js

@@ -1,4 +1,5 @@
 import UniformNode from './UniformNode.js';
+import { addNodeClass } from './Node.js';
 
 class ArrayUniformNode extends UniformNode {
 
@@ -21,3 +22,5 @@ class ArrayUniformNode extends UniformNode {
 }
 
 export default ArrayUniformNode;
+
+addNodeClass( ArrayUniformNode );

package/examples/jsm/nodes/core/AttributeNode.js

@@ -1,5 +1,6 @@
-import Node from './Node.js';
-import VaryingNode from './VaryingNode.js';
+import Node, { addNodeClass } from './Node.js';
+import { varying } from './VaryingNode.js';
+import { nodeObject } from '../shadernode/ShaderNode.js';
 
 class AttributeNode extends Node {
 
@@ -29,7 +30,7 @@ class AttributeNode extends Node {
 
 				const attribute = builder.geometry.getAttribute( attributeName );
 
-				nodeType = builder.getTypeFromLength( attribute.itemSize );
+				nodeType = builder.getTypeFromAttribute( attribute );
 
 			} else {
 
@@ -65,23 +66,26 @@ class AttributeNode extends Node {
 
 		if ( geometryAttribute === true ) {
 
-			const nodeAttribute = builder.getAttribute( attributeName, nodeType );
+			const attribute = builder.geometry.getAttribute( attributeName );
+			const attributeType = builder.getTypeFromAttribute( attribute );
+
+			const nodeAttribute = builder.getAttribute( attributeName, attributeType );
 
 			if ( builder.isShaderStage( 'vertex' ) ) {
 
-				return nodeAttribute.name;
+				return builder.format( nodeAttribute.name, attributeType, nodeType );
 
 			} else {
 
-				const nodeVarying = new VaryingNode( this );
+				const nodeVarying = varying( this );
 
-				return nodeVarying.build( builder, nodeAttribute.type );
+				return nodeVarying.build( builder, nodeType );
 
 			}
 
 		} else {
 
-			console.warn( `Attribute "${ attributeName }" not found.` );
+			console.warn( `AttributeNode: Attribute "${ attributeName }" not found.` );
 
 			return builder.getConst( nodeType );
 
@@ -92,3 +96,7 @@ class AttributeNode extends Node {
 }
 
 export default AttributeNode;
+
+export const attribute = ( name, nodeType ) => nodeObject( new AttributeNode( name, nodeType ) );
+
+addNodeClass( AttributeNode );

package/examples/jsm/nodes/core/BypassNode.js

@@ -1,4 +1,5 @@
-import Node from './Node.js';
+import Node, { addNodeClass } from './Node.js';
+import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
 
 class BypassNode extends Node {
 
@@ -25,7 +26,7 @@ class BypassNode extends Node {
 
 		if ( snippet !== '' ) {
 
-			builder.addFlowCode( snippet );
+			builder.addLineFlowCode( snippet );
 
 		}
 
@@ -36,3 +37,9 @@ class BypassNode extends Node {
 }
 
 export default BypassNode;
+
+export const bypass = nodeProxy( BypassNode );
+
+addNodeElement( 'bypass', bypass );
+
+addNodeClass( BypassNode );

package/examples/jsm/nodes/core/CacheNode.js

@@ -0,0 +1,46 @@
+import Node, { addNodeClass } from './Node.js';
+import NodeCache from './NodeCache.js';
+import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
+
+class CacheNode extends Node {
+
+	constructor( node, cache = new NodeCache() ) {
+
+		super();
+
+		this.isCacheNode = true;
+
+		this.node = node;
+		this.cache = cache;
+
+	}
+
+	getNodeType( builder ) {
+
+		return this.node.getNodeType( builder );
+
+	}
+
+	build( builder, ...params ) {
+
+		const previousCache = builder.getCache();
+
+		builder.setCache( this.cache );
+
+		const data = this.node.build( builder, ...params );
+
+		builder.setCache( previousCache );
+
+		return data;
+
+	}
+
+}
+
+export default CacheNode;
+
+export const cache = nodeProxy( CacheNode );
+
+addNodeElement( 'cache', cache );
+
+addNodeClass( CacheNode );

package/examples/jsm/nodes/core/ConstNode.js

@@ -1,4 +1,5 @@
 import InputNode from './InputNode.js';
+import { addNodeClass } from './Node.js';
 
 class ConstNode extends InputNode {
 
@@ -27,3 +28,5 @@ class ConstNode extends InputNode {
 }
 
 export default ConstNode;
+
+addNodeClass( ConstNode );

package/examples/jsm/nodes/core/ContextNode.js

@@ -1,4 +1,5 @@
-import Node from './Node.js';
+import Node, { addNodeClass } from './Node.js';
+import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
 
 class ContextNode extends Node {
 
@@ -50,3 +51,9 @@ class ContextNode extends Node {
 }
 
 export default ContextNode;
+
+export const context = nodeProxy( ContextNode );
+
+addNodeElement( 'context', context );
+
+addNodeClass( ContextNode );

package/examples/jsm/nodes/core/InputNode.js

@@ -1,5 +1,5 @@
-import Node from './Node.js';
-import { getValueType, getValueFromType } from './NodeUtils.js';
+import Node, { addNodeClass } from './Node.js';
+import { getValueType, getValueFromType, arrayBufferToBase64 } from './NodeUtils.js';
 
 class InputNode extends Node {
 
@@ -10,6 +10,7 @@ class InputNode extends Node {
 		this.isInputNode = true;
 
 		this.value = value;
+		this.precision = null;
 
 	}
 
@@ -31,14 +32,29 @@ class InputNode extends Node {
 
 	}
 
+	setPrecision( precision ) {
+
+		this.precision = precision;
+
+		return this;
+
+	}
+
 	serialize( data ) {
 
 		super.serialize( data );
 
-		data.value = this.value?.toArray?.() || this.value;
+		data.value = this.value;
+
+		if ( this.value && this.value.toArray ) data.value = this.value.toArray();
+
 		data.valueType = getValueType( this.value );
 		data.nodeType = this.nodeType;
 
+		if ( data.valueType === 'ArrayBuffer' ) data.value = arrayBufferToBase64( data.value );
+
+		data.precision = this.precision;
+
 	}
 
 	deserialize( data ) {
@@ -46,8 +62,11 @@ class InputNode extends Node {
 		super.deserialize( data );
 
 		this.nodeType = data.nodeType;
-		this.value = getValueFromType( data.valueType );
-		this.value = this.value?.fromArray?.( data.value ) || data.value;
+		this.value = Array.isArray( data.value ) ? getValueFromType( data.valueType, ...data.value ) : data.value;
+
+		this.precision = data.precision || null;
+
+		if ( this.value && this.value.fromArray ) this.value = this.value.fromArray( data.value );
 
 	}
 
@@ -60,3 +79,5 @@ class InputNode extends Node {
 }
 
 export default InputNode;
+
+addNodeClass( InputNode );

package/examples/jsm/nodes/core/InstanceIndexNode.js

@@ -1,4 +1,5 @@
-import Node from './Node.js';
+import Node, { addNodeClass } from './Node.js';
+import { nodeImmutable } from '../shadernode/ShaderNode.js';
 
 class InstanceIndexNode extends Node {
 
@@ -19,3 +20,7 @@ class InstanceIndexNode extends Node {
 }
 
 export default InstanceIndexNode;
+
+export const instanceIndex = nodeImmutable( InstanceIndexNode );
+
+addNodeClass( InstanceIndexNode );

package/examples/jsm/nodes/core/LightingModel.js

@@ -0,0 +1,16 @@
+class LightingModel {
+
+	constructor( direct = null, indirectDiffuse = null, indirectSpecular = null, ambientOcclusion = null ) {
+
+		this.direct = direct;
+		this.indirectDiffuse = indirectDiffuse;
+		this.indirectSpecular = indirectSpecular;
+		this.ambientOcclusion = ambientOcclusion;
+
+	}
+
+}
+
+export default LightingModel;
+
+export const lightingModel = ( ...params ) => new LightingModel( ...params );