@needle-tools/three 0.146.9 → 0.153.0

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

@@ -0,0 +1,80 @@
+import Binding from './Binding.js';
+
+let id = 0;
+
+class SampledTexture extends Binding {
+
+	constructor( name, texture ) {
+
+		super( name );
+
+		this.id = id ++;
+
+		this.texture = texture;
+		this.version = texture.version;
+
+		this.isSampledTexture = true;
+
+	}
+
+	get needsBindingsUpdate() {
+
+		const { texture, version } = this;
+
+		return texture.isVideoTexture ? true : version !== texture.version; // @TODO: version === 0 && texture.version > 0 ( add it just to External Textures like PNG,JPG )
+
+	}
+
+	update() {
+
+		if ( this.version !== this.texture.version ) {
+
+			this.version = this.texture.version;
+
+			return true;
+
+		}
+
+		return false;
+
+	}
+
+}
+
+class SampledArrayTexture extends SampledTexture {
+
+	constructor( name, texture ) {
+
+		super( name, texture );
+
+		this.isSampledArrayTexture = true;
+
+	}
+
+}
+
+class Sampled3DTexture extends SampledTexture {
+
+	constructor( name, texture ) {
+
+		super( name, texture );
+
+		this.isSampled3DTexture = true;
+
+	}
+
+}
+
+class SampledCubeTexture extends SampledTexture {
+
+	constructor( name, texture ) {
+
+		super( name, texture );
+
+		this.isSampledCubeTexture = true;
+
+	}
+
+}
+
+export { SampledTexture, SampledArrayTexture, Sampled3DTexture, SampledCubeTexture };

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

@@ -0,0 +1,18 @@
+import Binding from './Binding.js';
+
+class Sampler extends Binding {
+
+	constructor( name, texture ) {
+
+		super( name );
+
+		this.texture = texture;
+		this.version = texture.version;
+
+		this.isSampler = true;
+
+	}
+
+}
+
+export default Sampler;

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

@@ -0,0 +1,17 @@
+import Buffer from './Buffer.js';
+
+class StorageBuffer extends Buffer {
+
+	constructor( name, attribute ) {
+
+		super( name, attribute.array );
+
+		this.attribute = attribute;
+
+		this.isStorageBuffer = true;
+
+	}
+
+}
+
+export default StorageBuffer;

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

@@ -0,0 +1,206 @@
+import DataMap from './DataMap.js';
+import { Vector2, DepthTexture, DepthStencilFormat, UnsignedInt248Type } from 'three';
+
+const _size = new Vector2();
+
+class Textures extends DataMap {
+
+	constructor( backend, info ) {
+
+		super();
+
+		this.backend = backend;
+		this.info = info;
+
+	}
+
+	updateRenderTarget( renderTarget ) {
+
+		const renderTargetData = this.get( renderTarget );
+
+		const texture = renderTarget.texture;
+		const size = this.getSize( texture );
+
+		let depthTexture = renderTarget.depthTexture || renderTargetData.depthTexture;
+
+		if ( depthTexture === undefined ) {
+
+			depthTexture = new DepthTexture();
+			depthTexture.format = DepthStencilFormat;
+			depthTexture.type = UnsignedInt248Type;
+			depthTexture.image.width = size.width;
+			depthTexture.image.height = size.height;
+
+		}
+
+		if ( renderTargetData.width !== size.width || size.height !== renderTargetData.height ) {
+
+			texture.needsUpdate = true;
+			depthTexture.needsUpdate = true;
+
+			depthTexture.image.width = size.width;
+			depthTexture.image.height = size.height;
+
+		}
+
+		renderTargetData.width = size.width;
+		renderTargetData.height = size.height;
+		renderTargetData.texture = texture;
+		renderTargetData.depthTexture = depthTexture;
+
+		this.updateTexture( texture );
+		this.updateTexture( depthTexture );
+
+		// dispose handler
+
+		if ( renderTargetData.initialized !== true ) {
+
+			renderTargetData.initialized = true;
+
+			// dispose
+
+			const onDispose = () => {
+
+				renderTarget.removeEventListener( 'dispose', onDispose );
+
+				this._destroyTexture( texture );
+				this._destroyTexture( depthTexture );
+
+			};
+
+			renderTarget.addEventListener( 'dispose', onDispose );
+
+		}
+
+	}
+
+	updateTexture( texture ) {
+
+		const textureData = this.get( texture );
+		if ( textureData.initialized === true && textureData.version === texture.version ) return;
+
+		const isRenderTexture = texture.isRenderTargetTexture || texture.isDepthTexture || texture.isFramebufferTexture;
+		const backend = this.backend;
+
+		if ( isRenderTexture && textureData.initialized === true ) {
+
+			// it's an update
+
+			backend.destroySampler( texture );
+			backend.destroyTexture( texture );
+
+		}
+
+		//
+
+		if ( isRenderTexture ) {
+
+			backend.createSampler( texture );
+			backend.createTexture( texture );
+
+		} else {
+
+			const needsCreate = textureData.initialized !== true;
+
+			if ( needsCreate ) backend.createSampler( texture );
+
+			if ( texture.version > 0 ) {
+
+				const image = texture.image;
+
+				if ( image === undefined ) {
+
+					console.warn( 'THREE.Renderer: Texture marked for update but image is undefined.' );
+
+				} else if ( image.complete === false ) {
+
+					console.warn( 'THREE.Renderer: Texture marked for update but image is incomplete.' );
+
+				} else {
+
+					if ( textureData.isDefaultTexture === undefined || textureData.isDefaultTexture === true ) {
+
+						backend.createTexture( texture );
+
+						textureData.isDefaultTexture = false;
+
+					}
+
+					backend.updateTexture( texture );
+
+				}
+
+			} else {
+
+				// async update
+
+				backend.createDefaultTexture( texture );
+
+				textureData.isDefaultTexture = true;
+
+			}
+
+		}
+
+		// dispose handler
+
+		if ( textureData.initialized !== true ) {
+
+			textureData.initialized = true;
+
+			//
+
+			this.info.memory.textures ++;
+
+			// dispose
+
+			const onDispose = () => {
+
+				texture.removeEventListener( 'dispose', onDispose );
+
+				this._destroyTexture( texture );
+
+				this.info.memory.textures --;
+
+			};
+
+			texture.addEventListener( 'dispose', onDispose );
+
+		}
+
+		//
+
+		textureData.version = texture.version;
+
+	}
+
+	getSize( texture, target = _size ) {
+
+		if ( texture.isCubeTexture ) {
+
+			target.width = texture.image[ 0 ].width;
+			target.height = texture.image[ 0 ].height;
+
+		} else {
+
+			target.width = texture.image.width;
+			target.height = texture.image.height;
+
+		}
+
+		return target;
+
+	}
+
+	_destroyTexture( texture ) {
+
+		this.backend.destroySampler( texture );
+		this.backend.destroyTexture( texture );
+
+		this.delete( texture );
+
+	}
+
+}
+
+export default Textures;

package/examples/jsm/renderers/{webgpu/WebGPUUniform.js → common/Uniform.js}

@@ -1,6 +1,6 @@
 import { Color, Matrix3, Matrix4, Vector2, Vector3, Vector4 } from 'three';
 
-class WebGPUUniform {
+class Uniform {
 
 	constructor( name, value = null ) {
 
@@ -28,7 +28,7 @@ class WebGPUUniform {
 
 }
 
-class FloatUniform extends WebGPUUniform {
+class FloatUniform extends Uniform {
 
 	constructor( name, value = 0 ) {
 
@@ -43,7 +43,7 @@ class FloatUniform extends WebGPUUniform {
 
 }
 
-class Vector2Uniform extends WebGPUUniform {
+class Vector2Uniform extends Uniform {
 
 	constructor( name, value = new Vector2() ) {
 
@@ -58,7 +58,7 @@ class Vector2Uniform extends WebGPUUniform {
 
 }
 
-class Vector3Uniform extends WebGPUUniform {
+class Vector3Uniform extends Uniform {
 
 	constructor( name, value = new Vector3() ) {
 
@@ -73,7 +73,7 @@ class Vector3Uniform extends WebGPUUniform {
 
 }
 
-class Vector4Uniform extends WebGPUUniform {
+class Vector4Uniform extends Uniform {
 
 	constructor( name, value = new Vector4() ) {
 
@@ -88,7 +88,7 @@ class Vector4Uniform extends WebGPUUniform {
 
 }
 
-class ColorUniform extends WebGPUUniform {
+class ColorUniform extends Uniform {
 
 	constructor( name, value = new Color() ) {
 
@@ -103,7 +103,7 @@ class ColorUniform extends WebGPUUniform {
 
 }
 
-class Matrix3Uniform extends WebGPUUniform {
+class Matrix3Uniform extends Uniform {
 
 	constructor( name, value = new Matrix3() ) {
 
@@ -118,7 +118,7 @@ class Matrix3Uniform extends WebGPUUniform {
 
 }
 
-class Matrix4Uniform extends WebGPUUniform {
+class Matrix4Uniform extends Uniform {
 
 	constructor( name, value = new Matrix4() ) {
 
@@ -133,4 +133,8 @@ class Matrix4Uniform extends WebGPUUniform {
 
 }
 
-export { FloatUniform, Vector2Uniform, Vector3Uniform, Vector4Uniform, ColorUniform, Matrix3Uniform, Matrix4Uniform };
+export {
+	FloatUniform,
+	Vector2Uniform, Vector3Uniform, Vector4Uniform, ColorUniform,
+	Matrix3Uniform, Matrix4Uniform
+};

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

@@ -0,0 +1,15 @@
+import Buffer from './Buffer.js';
+
+class UniformBuffer extends Buffer {
+
+	constructor( name, buffer = null ) {
+
+		super( name, buffer );
+
+		this.isUniformBuffer = true;
+
+	}
+
+}
+
+export default UniformBuffer;

package/examples/jsm/renderers/{webgpu/WebGPUUniformsGroup.js → common/UniformsGroup.js}

@@ -1,7 +1,7 @@
-import WebGPUUniformBuffer from './WebGPUUniformBuffer.js';
-import { GPUChunkSize } from './constants.js';
+import UniformBuffer from './UniformBuffer.js';
+import { GPU_CHUNK_BYTES } from './Constants.js';
 
-class WebGPUUniformsGroup extends WebGPUUniformBuffer {
+class UniformsGroup extends UniformBuffer {
 
 	constructor( name ) {
 
@@ -37,17 +37,17 @@ class WebGPUUniformsGroup extends WebGPUUniformBuffer {
 
 	}
 
-	getBuffer() {
+	get buffer() {
 
-		let buffer = this.buffer;
+		let buffer = this._buffer;
 
 		if ( buffer === null ) {
 
-			const byteLength = this.getByteLength();
+			const byteLength = this.byteLength;
 
 			buffer = new Float32Array( new ArrayBuffer( byteLength ) );
 
-			this.buffer = buffer;
+			this._buffer = buffer;
 
 		}
 
@@ -55,7 +55,7 @@ class WebGPUUniformsGroup extends WebGPUUniformBuffer {
 
 	}
 
-	getByteLength() {
+	get byteLength() {
 
 		let offset = 0; // global buffer offset in bytes
 
@@ -65,8 +65,8 @@ class WebGPUUniformsGroup extends WebGPUUniformBuffer {
 
 			// offset within a single chunk in bytes
 
-			const chunkOffset = offset % GPUChunkSize;
-			const remainingSizeInChunk = GPUChunkSize - chunkOffset;
+			const chunkOffset = offset % GPU_CHUNK_BYTES;
+			const remainingSizeInChunk = GPU_CHUNK_BYTES - chunkOffset;
 
 			// conformance tests
 
@@ -74,7 +74,7 @@ class WebGPUUniformsGroup extends WebGPUUniformBuffer {
 
 				// check for chunk overflow
 
-				offset += ( GPUChunkSize - chunkOffset );
+				offset += ( GPU_CHUNK_BYTES - chunkOffset );
 
 			} else if ( chunkOffset % uniform.boundary !== 0 ) {
 
@@ -90,7 +90,7 @@ class WebGPUUniformsGroup extends WebGPUUniformBuffer {
 
 		}
 
-		return offset;
+		return Math.ceil( offset / GPU_CHUNK_BYTES ) * GPU_CHUNK_BYTES;
 
 	}
 
@@ -296,4 +296,4 @@ function arraysEqual( a, b, offset ) {
 
 }
 
-export default WebGPUUniformsGroup;
+export default UniformsGroup;