@needle-tools/three 0.146.10 → 0.153.1

package/examples/jsm/renderers/{webgpu/WebGPUAnimation.js → common/Animation.js}

@@ -1,4 +1,4 @@
-class WebGPUAnimation {
+class Animation {
 
 	constructor() {
 
@@ -23,9 +23,9 @@ class WebGPUAnimation {
 
 			this.requestId = self.requestAnimationFrame( update );
 
-			this.animationLoop( time, frame );
+			this.nodes.nodeFrame.update();
 
-			this.nodes.updateFrame();
+			this.animationLoop( time, frame );
 
 		};
 
@@ -55,4 +55,4 @@ class WebGPUAnimation {
 
 }
 
-export default WebGPUAnimation;
+export default Animation;

package/examples/jsm/renderers/common/Attributes.js

@@ -0,0 +1,75 @@
+import DataMap from './DataMap.js';
+import { AttributeType } from './Constants.js';
+import { DynamicDrawUsage } from 'three';
+
+class Attributes extends DataMap {
+
+	constructor( backend ) {
+
+		super();
+
+		this.backend = backend;
+
+	}
+
+	delete( attribute ) {
+
+		const attributeData = super.delete( attribute );
+
+		if ( attributeData !== undefined ) {
+
+			this.backend.destroyAttribute( attribute );
+
+		}
+
+	}
+
+	update( attribute, type ) {
+
+		const data = this.get( attribute );
+
+		if ( data.version === undefined ) {
+
+			if ( type === AttributeType.VERTEX ) {
+
+				this.backend.createAttribute( attribute );
+
+			} else if ( type === AttributeType.INDEX ) {
+
+				this.backend.createIndexAttribute( attribute );
+
+			} else if ( type === AttributeType.STORAGE ) {
+
+				this.backend.createStorageAttribute( attribute );
+
+			}
+
+			data.version = this._getBufferAttribute( attribute ).version;
+
+		} else {
+
+			const bufferAttribute = this._getBufferAttribute( attribute );
+
+			if ( data.version < bufferAttribute.version || bufferAttribute.usage === DynamicDrawUsage ) {
+
+				this.backend.updateAttribute( attribute );
+
+				data.version = bufferAttribute.version;
+
+			}
+
+		}
+
+	}
+
+	_getBufferAttribute( attribute ) {
+
+		if ( attribute.isInterleavedBufferAttribute ) attribute = attribute.data;
+
+		return attribute;
+
+	}
+
+}
+
+export default Attributes;

package/examples/jsm/renderers/common/Backend.js

@@ -0,0 +1,160 @@
+let vector2 = null;
+let vector4 = null;
+
+import { Vector2, Vector4 } from 'three';
+
+class Backend {
+
+	constructor( parameters = {} ) {
+
+		this.parameters = Object.assign( {}, parameters );
+		this.data = new WeakMap();
+		this.renderer = null;
+		this.domElement = null;
+
+	}
+
+	async init( renderer ) {
+
+		this.renderer = renderer;
+
+	}
+
+	// render context
+
+	begin( renderContext ) { }
+
+	finish( renderContext ) { }
+
+	// render object
+
+	draw( renderObject, info ) { }
+
+	// program
+
+	createProgram( program ) { }
+
+	destroyProgram( program ) { }
+
+	// bindings
+
+	createBindings( renderObject ) { }
+
+	updateBindings( renderObject ) { }
+
+	// pipeline
+
+	createRenderPipeline( renderObject ) { }
+
+	createComputePipeline( computeNode, pipeline ) { }
+
+	destroyPipeline( pipeline ) { }
+
+	// cache key
+
+	needsUpdate( renderObject ) { } // return Boolean ( fast test )
+
+	getCacheKey( renderObject ) { } // return String
+
+	// node builder
+
+	createNodeBuilder( renderObject ) { } // return NodeBuilder (ADD IT)
+
+	// textures
+
+	createSampler( texture ) { }
+
+	createDefaultTexture( texture ) { }
+
+	createTexture( texture ) { }
+
+	// attributes
+
+	createAttribute( attribute ) { }
+
+	createIndexAttribute( attribute ) { }
+
+	updateAttribute( attribute ) { }
+
+	destroyAttribute( attribute ) { }
+
+	// canvas
+
+	updateSize() { }
+
+	// utils
+
+	hasFeature( name ) { } // return Boolean
+
+	getInstanceCount( renderObject ) {
+
+		const { object, geometry } = renderObject;
+
+		return geometry.isInstancedBufferGeometry ? geometry.instanceCount : ( object.isInstancedMesh ? object.count : 1 );
+
+	}
+
+	getDrawingBufferSize() {
+
+		vector2 = vector2 || new Vector2();
+
+		return this.renderer.getDrawingBufferSize( vector2 );
+
+	}
+
+	getScissor() {
+
+		vector4 = vector4 || new Vector4();
+
+		return this.renderer.getScissor( vector4 );
+
+	}
+
+	getDomElement() {
+
+		let domElement = this.domElement;
+
+		if ( domElement === null ) {
+
+			this.domElement = domElement = ( this.parameters.canvas !== undefined ) ? this.parameters.canvas : this.createCanvasElement();
+
+		}
+
+		return domElement;
+
+	}
+
+	createCanvasElement() {
+
+		const canvas = document.createElementNS( 'http://www.w3.org/1999/xhtml', 'canvas' );
+		canvas.style.display = 'block';
+		return canvas;
+
+	}
+
+	// resource properties
+
+	get( object ) {
+
+		let map = this.data.get( object );
+
+		if ( map === undefined ) {
+
+			map = {};
+			this.data.set( object, map );
+
+		}
+
+		return map;
+
+	}
+
+	delete( object ) {
+
+		this.data.delete( object );
+
+	}
+
+}
+
+export default Backend;

package/examples/jsm/renderers/common/Background.js

@@ -0,0 +1,133 @@
+import DataMap from './DataMap.js';
+import { Color, Mesh, BoxGeometry, BackSide } from 'three';
+import { context, positionWorldDirection, MeshBasicNodeMaterial } from '../../nodes/Nodes.js';
+
+let _clearAlpha;
+const _clearColor = new Color();
+
+class Background extends DataMap {
+
+	constructor( renderer, nodes ) {
+
+		super();
+
+		this.renderer = renderer;
+		this.nodes = nodes;
+
+		this.boxMesh = null;
+		this.boxMeshNode = null;
+
+	}
+
+	update( scene, renderList, renderContext ) {
+
+		const renderer = this.renderer;
+		const background = ( scene.isScene === true ) ? this.nodes.getBackgroundNode( scene ) || scene.background : null;
+
+		let forceClear = false;
+
+		if ( background === null ) {
+
+			// no background settings, use clear color configuration from the renderer
+
+			_clearColor.copy( renderer._clearColor );
+			_clearAlpha = renderer._clearAlpha;
+
+		} else if ( background.isColor === true ) {
+
+			// background is an opaque color
+
+			_clearColor.copy( background );
+			_clearAlpha = 1;
+			forceClear = true;
+
+		} else if ( background.isNode === true ) {
+
+			const sceneData = this.get( scene );
+			const backgroundNode = background;
+
+			_clearColor.copy( renderer._clearColor );
+			_clearAlpha = renderer._clearAlpha;
+
+			let boxMesh = this.boxMesh;
+
+			if ( boxMesh === null ) {
+
+				this.boxMeshNode = context( backgroundNode, {
+					// @TODO: Add Texture2D support using node context
+					getUVNode: () => positionWorldDirection
+				} );
+
+				const nodeMaterial = new MeshBasicNodeMaterial();
+				nodeMaterial.colorNode = this.boxMeshNode;
+				nodeMaterial.side = BackSide;
+				nodeMaterial.depthTest = false;
+				nodeMaterial.depthWrite = false;
+				nodeMaterial.fog = false;
+
+				this.boxMesh = boxMesh = new Mesh( new BoxGeometry( 1, 1, 1 ), nodeMaterial );
+				boxMesh.frustumCulled = false;
+
+				boxMesh.onBeforeRender = function ( renderer, scene, camera ) {
+
+					const scale = camera.far;
+
+					this.matrixWorld.makeScale( scale, scale, scale ).copyPosition( camera.matrixWorld );
+
+				};
+
+			}
+
+			const backgroundCacheKey = backgroundNode.getCacheKey();
+
+			if ( sceneData.backgroundCacheKey !== backgroundCacheKey ) {
+
+				this.boxMeshNode.node = backgroundNode;
+
+				boxMesh.material.needsUpdate = true;
+
+				sceneData.backgroundCacheKey = backgroundCacheKey;
+
+			}
+
+			renderList.unshift( boxMesh, boxMesh.geometry, boxMesh.material, 0, 0, null );
+
+		} else {
+
+			console.error( 'THREE.Renderer: Unsupported background configuration.', background );
+
+		}
+
+		//
+
+		if ( renderer.autoClear === true || forceClear === true ) {
+
+			_clearColor.multiplyScalar( _clearAlpha );
+
+			const clearColorValue = renderContext.clearColorValue;
+
+			clearColorValue.r = _clearColor.r;
+			clearColorValue.g = _clearColor.g;
+			clearColorValue.b = _clearColor.b;
+			clearColorValue.a = _clearAlpha;
+
+			renderContext.depthClearValue = renderer._clearDepth;
+			renderContext.stencilClearValue = renderer._clearStencil;
+
+			renderContext.clearColor = renderer.autoClearColor === true;
+			renderContext.clearDepth = renderer.autoClearDepth === true;
+			renderContext.clearStencil = renderer.autoClearStencil === true;
+
+		} else {
+
+			renderContext.clearColor = false;
+			renderContext.clearDepth = false;
+			renderContext.clearStencil = false;
+
+		}
+
+	}
+
+}
+
+export default Background;

package/examples/jsm/renderers/common/Binding.js

@@ -0,0 +1,11 @@
+class Binding {
+
+	constructor( name = '' ) {
+
+		this.name = name;
+
+	}
+
+}
+
+export default Binding;

package/examples/jsm/renderers/common/Bindings.js

@@ -0,0 +1,169 @@
+import DataMap from './DataMap.js';
+import { AttributeType } from './Constants.js';
+
+class Bindings extends DataMap {
+
+	constructor( backend, nodes, textures, attributes, pipelines, info ) {
+
+		super();
+
+		this.backend = backend;
+		this.textures = textures;
+		this.pipelines = pipelines;
+		this.attributes = attributes;
+		this.nodes = nodes;
+		this.info = info;
+
+		this.pipelines.bindings = this; // assign bindings to pipelines
+
+		this.updateMap = new WeakMap();
+
+	}
+
+	getForRender( renderObject ) {
+
+		const bindings = renderObject.getBindings();
+
+		const data = this.get( renderObject );
+
+		if ( data.bindings !== bindings ) {
+
+			// each object defines an array of bindings (ubos, textures, samplers etc.)
+
+			data.bindings = bindings;
+
+			this._init( bindings );
+
+			const pipeline = this.pipelines.getForRender( renderObject );
+
+			this.backend.createBindings( bindings, pipeline );
+
+		}
+
+		return data.bindings;
+
+	}
+
+	getForCompute( computeNode ) {
+
+		const data = this.get( computeNode );
+
+		if ( data.bindings === undefined ) {
+
+			const nodeBuilder = this.nodes.getForCompute( computeNode );
+
+			const bindings = nodeBuilder.getBindings();
+
+			data.bindings = bindings;
+
+			this._init( bindings );
+
+			const pipeline = this.pipelines.getForCompute( computeNode );
+
+			this.backend.createBindings( bindings, pipeline );
+
+		}
+
+		return data.bindings;
+
+	}
+
+	updateForCompute( computeNode ) {
+
+		this._update( computeNode, this.getForCompute( computeNode ) );
+
+	}
+
+	updateForRender( renderObject ) {
+
+		this._update( renderObject, this.getForRender( renderObject ) );
+
+	}
+
+	_init( bindings ) {
+
+		for ( const binding of bindings ) {
+
+			if ( binding.isSampler || binding.isSampledTexture ) {
+
+				this.textures.updateTexture( binding.texture );
+
+			} else if ( binding.isStorageBuffer ) {
+
+				const attribute = binding.attribute;
+
+				this.attributes.update( attribute, AttributeType.STORAGE );
+
+			}
+
+		}
+
+	}
+
+	_update( object, bindings ) {
+
+		const { backend } = this;
+
+		const updateMap = this.updateMap;
+		const frame = this.info.render.frame;
+
+		let needsBindingsUpdate = false;
+
+		// iterate over all bindings and check if buffer updates or a new binding group is required
+
+		for ( const binding of bindings ) {
+
+			const isShared = binding.isShared;
+			const isUpdated = updateMap.get( binding ) === frame;
+
+			if ( isShared && isUpdated ) continue;
+
+			if ( binding.isUniformBuffer ) {
+
+				const needsUpdate = binding.update();
+
+				if ( needsUpdate ) {
+
+					backend.updateBinding( binding );
+
+				}
+
+			} else if ( binding.isSampledTexture ) {
+
+				if ( binding.needsBindingsUpdate ) needsBindingsUpdate = true;
+
+				const needsUpdate = binding.update();
+
+				if ( needsUpdate ) {
+
+					this.textures.updateTexture( binding.texture );
+
+				}
+
+			}
+
+			updateMap.set( binding, frame );
+
+		}
+
+		if ( needsBindingsUpdate === true ) {
+
+			const pipeline = this.pipelines.getForRender( object );
+
+			this.backend.updateBindings( bindings, pipeline );
+
+		}
+
+	}
+
+	dispose() {
+
+		super.dispose();
+
+		this.updateMap = new WeakMap();
+
+	}
+
+}
+
+export default Bindings;

package/examples/jsm/renderers/common/Buffer.js

@@ -0,0 +1,38 @@
+import Binding from './Binding.js';
+import { getFloatLength } from './BufferUtils.js';
+
+class Buffer extends Binding {
+
+	constructor( name, buffer = null ) {
+
+		super( name );
+
+		this.isBuffer = true;
+
+		this.bytesPerElement = Float32Array.BYTES_PER_ELEMENT;
+
+		this._buffer = buffer;
+
+	}
+
+	get byteLength() {
+
+		return getFloatLength( this._buffer.byteLength );
+
+	}
+
+	get buffer() {
+
+		return this._buffer;
+
+	}
+
+	update() {
+
+		return true;
+
+	}
+
+}
+
+export default Buffer;

package/examples/jsm/renderers/{webgpu/WebGPUBufferUtils.js → common/BufferUtils.js}

@@ -1,10 +1,10 @@
-import { GPUChunkSize } from './constants.js';
+import { GPU_CHUNK_BYTES } from './Constants.js';
 
 function getFloatLength( floatLength ) {
 
 	// ensure chunk size alignment (STD140 layout)
 
-	return floatLength + ( ( GPUChunkSize - ( floatLength % GPUChunkSize ) ) % GPUChunkSize );
+	return floatLength + ( ( GPU_CHUNK_BYTES - ( floatLength % GPU_CHUNK_BYTES ) ) % GPU_CHUNK_BYTES );
 
 }
 

package/examples/jsm/renderers/common/ChainMap.js

@@ -0,0 +1,89 @@
+export default class ChainMap {
+
+	constructor() {
+
+		this.weakMap = new WeakMap();
+
+	}
+
+	get( keys ) {
+
+		if ( Array.isArray( keys ) ) {
+
+			let map = this.weakMap;
+
+			for ( let i = 0; i < keys.length - 1; i ++ ) {
+
+				map = map.get( keys[ i ] );
+
+				if ( map === undefined ) return undefined;
+
+			}
+
+			return map.get( keys[ keys.length - 1 ] );
+
+		} else {
+
+			return super.get( keys );
+
+		}
+
+	}
+
+	set( keys, value ) {
+
+		if ( Array.isArray( keys ) ) {
+
+			let map = this.weakMap;
+
+			for ( let i = 0; i < keys.length - 1; i ++ ) {
+
+				const key = keys[ i ];
+
+				if ( map.has( key ) === false ) map.set( key, new WeakMap() );
+
+				map = map.get( key );
+
+			}
+
+			return map.set( keys[ keys.length - 1 ], value );
+
+		} else {
+
+			return super.set( keys, value );
+
+		}
+
+	}
+
+	delete( keys ) {
+
+		if ( Array.isArray( keys ) ) {
+
+			let map = this.weakMap;
+
+			for ( let i = 0; i < keys.length - 1; i ++ ) {
+
+				map = map.get( keys[ i ] );
+
+				if ( map === undefined ) return false;
+
+			}
+
+			return map.delete( keys[ keys.length - 1 ] );
+
+		} else {
+
+			return super.delete( keys );
+
+		}
+
+	}
+
+	dispose() {
+
+		this.weakMap.clear();
+
+	}
+
+}