@anov/3d 0.0.4-alpha.1 → 0.0.4-alpha13

package/examples/jsm/renderers/webgpu/nodes/WGSLNodeFunction.js

@@ -1,104 +0,0 @@
-import NodeFunction from '../../../nodes/core/NodeFunction.js';
-import NodeFunctionInput from '../../../nodes/core/NodeFunctionInput.js';
-
-const declarationRegexp = /^[fn]*\s*([a-z_0-9]+)?\s*\(([\s\S]*?)\)\s*[\-\>]*\s*([a-z_0-9]+)?/i;
-const propertiesRegexp = /[a-z_0-9]+/ig;
-
-const wgslTypeLib = {
-	f32: 'float'
-};
-
-const parse = ( source ) => {
-
-	source = source.trim();
-
-	const declaration = source.match( declarationRegexp );
-
-	if ( declaration !== null && declaration.length === 4 ) {
-
-		// tokenizer
-
-		const inputsCode = declaration[ 2 ];
-		const propsMatches = [];
-
-		let nameMatch = null;
-
-		while ( ( nameMatch = propertiesRegexp.exec( inputsCode ) ) !== null ) {
-
-			propsMatches.push( nameMatch );
-
-		}
-
-		// parser
-
-		const inputs = [];
-
-		let i = 0;
-
-		while ( i < propsMatches.length ) {
-
-			// default
-
-			const name = propsMatches[ i ++ ][ 0 ];
-			let type = propsMatches[ i ++ ][ 0 ];
-
-			type = wgslTypeLib[ type ] || type;
-
-			// precision
-
-			if ( i < propsMatches.length && /^[fui]\d{2}$/.test( propsMatches[ i ][ 0 ] ) === true )
-				i ++;
-
-			// add input
-
-			inputs.push( new NodeFunctionInput( type, name ) );
-
-		}
-
-		//
-
-		const blockCode = source.substring( declaration[ 0 ].length );
-
-		const name = declaration[ 1 ] !== undefined ? declaration[ 1 ] : '';
-		const type = declaration[ 3 ] || 'void';
-
-		return {
-			type,
-			inputs,
-			name,
-			inputsCode,
-			blockCode
-		};
-
-	} else {
-
-		throw new Error( 'FunctionNode: Function is not a WGSL code.' );
-
-	}
-
-};
-
-class WGSLNodeFunction extends NodeFunction {
-
-	constructor( source ) {
-
-		const { type, inputs, name, inputsCode, blockCode } = parse( source );
-
-		super( type, inputs, name );
-
-		this.inputsCode = inputsCode;
-		this.blockCode = blockCode;
-
-	}
-
-	getCode( name = this.name ) {
-
-		const type = this.type !== 'void' ? '-> ' + this.type : '';
-
-		return `fn ${ name } ( ${ this.inputsCode.trim() } ) ${ type }` + this.blockCode;
-
-	}
-
-}
-
-export default WGSLNodeFunction;

package/examples/jsm/renderers/webgpu/nodes/WGSLNodeParser.js

@@ -1,14 +0,0 @@
-import NodeParser from '../../../nodes/core/NodeParser.js';
-import WGSLNodeFunction from './WGSLNodeFunction.js';
-
-class WGSLNodeParser extends NodeParser {
-
-	parseFunction( source ) {
-
-		return new WGSLNodeFunction( source );
-
-	}
-
-}
-
-export default WGSLNodeParser;

package/examples/jsm/renderers/webgpu/utils/WebGPUAttributeUtils.js

@@ -1,274 +0,0 @@
-import { Float16BufferAttribute } from 'three';
-import { GPUInputStepMode } from './WebGPUConstants.js';
-
-const typedArraysToVertexFormatPrefix = new Map( [
-	[ Int8Array, [ 'sint8', 'snorm8' ]],
-	[ Uint8Array, [ 'uint8', 'unorm8' ]],
-	[ Int16Array, [ 'sint16', 'snorm16' ]],
-	[ Uint16Array, [ 'uint16', 'unorm16' ]],
-	[ Int32Array, [ 'sint32', 'snorm32' ]],
-	[ Uint32Array, [ 'uint32', 'unorm32' ]],
-	[ Float32Array, [ 'float32', ]],
-] );
-
-const typedAttributeToVertexFormatPrefix = new Map( [
-	[ Float16BufferAttribute, [ 'float16', ]],
-] );
-
-const typeArraysToVertexFormatPrefixForItemSize1 = new Map( [
-	[ Int32Array, 'sint32' ],
-	[ Uint32Array, 'uint32' ],
-	[ Float32Array, 'float32' ]
-] );
-
-class WebGPUAttributeUtils {
-
-	constructor( backend ) {
-
-		this.backend = backend;
-
-	}
-
-	createAttribute( attribute, usage ) {
-
-		const bufferAttribute = this._getBufferAttribute( attribute );
-
-		const backend = this.backend;
-		const bufferData = backend.get( bufferAttribute );
-
-		let buffer = bufferData.buffer;
-
-		if ( buffer === undefined ) {
-
-			const device = backend.device;
-
-			const array = bufferAttribute.array;
-			const size = array.byteLength + ( ( 4 - ( array.byteLength % 4 ) ) % 4 ); // ensure 4 byte alignment, see #20441
-
-			buffer = device.createBuffer( {
-				label: bufferAttribute.name,
-				size: size,
-				usage: usage,
-				mappedAtCreation: true
-			} );
-
-			new array.constructor( buffer.getMappedRange() ).set( array );
-
-			buffer.unmap();
-
-			bufferData.buffer = buffer;
-
-		}
-
-	}
-
-	updateAttribute( attribute ) {
-
-		const bufferAttribute = this._getBufferAttribute( attribute );
-
-		const backend = this.backend;
-		const device = backend.device;
-
-		const buffer = backend.get( bufferAttribute ).buffer;
-
-		const array = bufferAttribute.array;
-		const updateRange = bufferAttribute.updateRange;
-
-		if ( updateRange.count === - 1 ) {
-
-			// Not using update ranges
-
-			device.queue.writeBuffer(
-				buffer,
-				0,
-				array,
-				0
-			);
-
-		} else {
-
-			device.queue.writeBuffer(
-				buffer,
-				0,
-				array,
-				updateRange.offset * array.BYTES_PER_ELEMENT,
-				updateRange.count * array.BYTES_PER_ELEMENT
-			);
-
-			updateRange.count = - 1; // reset range
-
-		}
-
-	}
-
-	createShaderVertexBuffers( renderObject ) {
-
-		const attributes = renderObject.getAttributes();
-		const vertexBuffers = new Map();
-
-		for ( let slot = 0; slot < attributes.length; slot ++ ) {
-
-			const geometryAttribute = attributes[ slot ];
-			const bytesPerElement = geometryAttribute.array.BYTES_PER_ELEMENT;
-			const bufferAttribute = this._getBufferAttribute( geometryAttribute );
-
-			let vertexBufferLayout = vertexBuffers.get( bufferAttribute );
-
-			if ( vertexBufferLayout === undefined ) {
-
-				let arrayStride, stepMode;
-
-				if ( geometryAttribute.isInterleavedBufferAttribute === true ) {
-
-					arrayStride = geometryAttribute.data.stride * bytesPerElement;
-					stepMode = geometryAttribute.data.isInstancedInterleavedBuffer ? GPUInputStepMode.Instance : GPUInputStepMode.Vertex;
-
-				} else {
-
-					arrayStride = geometryAttribute.itemSize * bytesPerElement;
-					stepMode = geometryAttribute.isInstancedBufferAttribute ? GPUInputStepMode.Instance : GPUInputStepMode.Vertex;
-
-				}
-
-				vertexBufferLayout = {
-					arrayStride,
-					attributes: [],
-					stepMode
-				};
-
-				vertexBuffers.set( bufferAttribute, vertexBufferLayout );
-
-			}
-
-			const format = this._getVertexFormat( geometryAttribute );
-			const offset = ( geometryAttribute.isInterleavedBufferAttribute === true ) ? geometryAttribute.offset * bytesPerElement : 0;
-
-			vertexBufferLayout.attributes.push( {
-				shaderLocation: slot,
-				offset,
-				format
-			} );
-
-		}
-
-		return Array.from( vertexBuffers.values() );
-
-	}
-
-	destroyAttribute( attribute ) {
-
-		const backend = this.backend;
-		const data = backend.get( this._getBufferAttribute( attribute ) );
-
-		data.buffer.destroy();
-
-		backend.delete( attribute );
-
-	}
-
-	async getArrayBufferAsync( attribute ) {
-
-		const backend = this.backend;
-		const device = backend.device;
-
-		const data = backend.get( this._getBufferAttribute( attribute ) );
-
-		const bufferGPU = data.buffer;
-		const size = bufferGPU.size;
-
-		let readBufferGPU = data.readBuffer;
-		let needsUnmap = true;
-
-		if ( readBufferGPU === undefined ) {
-
-			readBufferGPU = device.createBuffer( {
-				label: attribute.name,
-				size,
-				usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
-			} );
-
-			needsUnmap = false;
-
-			data.readBuffer = readBufferGPU;
-
-		}
-
-		const cmdEncoder = device.createCommandEncoder( {} );
-
-		cmdEncoder.copyBufferToBuffer(
-			bufferGPU,
-			0,
-			readBufferGPU,
-			0,
-			size
-		);
-
-		if ( needsUnmap ) readBufferGPU.unmap();
-
-		const gpuCommands = cmdEncoder.finish();
-		device.queue.submit( [ gpuCommands ] );
-
-		await readBufferGPU.mapAsync( GPUMapMode.READ );
-
-		const arrayBuffer = readBufferGPU.getMappedRange();
-
-		return arrayBuffer;
-
-	}
-
-	_getVertexFormat( geometryAttribute ) {
-
-		const { itemSize, normalized } = geometryAttribute;
-		const ArrayType = geometryAttribute.array.constructor;
-		const AttributeType = geometryAttribute.constructor;
-
-		let format;
-
-		if ( itemSize == 1 ) {
-
-			format = typeArraysToVertexFormatPrefixForItemSize1.get( ArrayType );
-
-		} else {
-
-			const prefixOptions = typedAttributeToVertexFormatPrefix.get( AttributeType ) || typedArraysToVertexFormatPrefix.get( ArrayType );
-			const prefix = prefixOptions[ normalized ? 1 : 0 ];
-
-			if ( prefix ) {
-
-				const bytesPerUnit = ArrayType.BYTES_PER_ELEMENT * itemSize;
-				const paddedBytesPerUnit = Math.floor( ( bytesPerUnit + 3 ) / 4 ) * 4;
-				const paddedItemSize = paddedBytesPerUnit / ArrayType.BYTES_PER_ELEMENT;
-
-				if ( paddedItemSize % 1 ) {
-
-					throw new Error( 'THREE.WebGPUAttributeUtils: Bad vertex format item size.' );
-
-				}
-
-				format = `${prefix}x${paddedItemSize}`;
-
-			}
-
-		}
-
-		if ( ! format ) {
-
-			console.error( 'THREE.WebGPUAttributeUtils: Vertex format not supported yet.' );
-
-		}
-
-		return format;
-
-	}
-
-	_getBufferAttribute( attribute ) {
-
-		if ( attribute.isInterleavedBufferAttribute ) attribute = attribute.data;
-
-		return attribute;
-
-	}
-
-}
-
-export default WebGPUAttributeUtils;

package/examples/jsm/renderers/webgpu/utils/WebGPUBindingUtils.js

@@ -1,223 +0,0 @@
-import {
-	GPUTextureAspect, GPUTextureViewDimension, GPUBufferBindingType
-} from './WebGPUConstants.js';
-
-class WebGPUBindingUtils {
-
-	constructor( backend ) {
-
-		this.backend = backend;
-
-	}
-
-	createBindingsLayout( bindings ) {
-
-		const backend = this.backend;
-		const device = backend.device;
-
-		const entries = [];
-
-		let index = 0;
-
-		for ( const binding of bindings ) {
-
-			const bindingGPU = {
-				binding: index ++,
-				visibility: binding.visibility
-			};
-
-			if ( binding.isUniformBuffer || binding.isStorageBuffer ) {
-
-				const buffer = {}; // GPUBufferBindingLayout
-
-				if ( binding.isStorageBuffer ) {
-
-					buffer.type = GPUBufferBindingType.Storage;
-
-				}
-
-				bindingGPU.buffer = buffer;
-
-			} else if ( binding.isSampler ) {
-
-				const sampler = {}; // GPUSamplerBindingLayout
-
-				if ( binding.texture.isDepthTexture ) {
-
-					if ( binding.texture.compareFunction !== null ) {
-
-						sampler.type = 'comparison';
-
-					}
-
-				}
-
-				bindingGPU.sampler = sampler;
-
-			} else if ( binding.isSampledTexture && binding.texture.isVideoTexture ) {
-
-				bindingGPU.externalTexture = {}; // GPUExternalTextureBindingLayout
-
-			} else if ( binding.isSampledTexture ) {
-
-				const texture = {}; // GPUTextureBindingLayout
-
-				if ( binding.texture.isDepthTexture ) {
-
-					texture.sampleType = 'depth';
-
-				}
-
-				if ( binding.isSampledCubeTexture ) {
-
-					texture.viewDimension = GPUTextureViewDimension.Cube;
-
-				}
-
-				bindingGPU.texture = texture;
-
-			} else {
-
-				console.error( 'WebGPUBindingUtils: Unsupported binding "${ binding }".' );
-
-			}
-
-			entries.push( bindingGPU );
-
-		}
-
-		return device.createBindGroupLayout( { entries } );
-
-	}
-
-	createBindings( bindings ) {
-
-		const backend = this.backend;
-		const bindingsData = backend.get( bindings );
-
-		// setup (static) binding layout and (dynamic) binding group
-
-		const bindLayoutGPU = this.createBindingsLayout( bindings );
-		const bindGroupGPU = this.createBindGroup( bindings, bindLayoutGPU );
-
-		bindingsData.layout = bindLayoutGPU;
-		bindingsData.group = bindGroupGPU;
-		bindingsData.bindings = bindings;
-
-	}
-
-	updateBinding( binding ) {
-
-		const backend = this.backend;
-		const device = backend.device;
-
-		const buffer = binding.buffer;
-		const bufferGPU = backend.get( binding ).buffer;
-
-		device.queue.writeBuffer( bufferGPU, 0, buffer, 0 );
-
-	}
-
-	createBindGroup( bindings, layoutGPU ) {
-
-		const backend = this.backend;
-		const device = backend.device;
-
-		let bindingPoint = 0;
-		const entriesGPU = [];
-
-		for ( const binding of bindings ) {
-
-			if ( binding.isUniformBuffer ) {
-
-				const bindingData = backend.get( binding );
-
-				if ( bindingData.buffer === undefined ) {
-
-					const byteLength = binding.byteLength;
-
-					const usage = GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST;
-
-					const bufferGPU = device.createBuffer( {
-						label: 'bindingBuffer',
-						size: byteLength,
-						usage: usage
-					} );
-
-					bindingData.buffer = bufferGPU;
-
-				}
-
-				entriesGPU.push( { binding: bindingPoint, resource: { buffer: bindingData.buffer } } );
-
-			} else if ( binding.isStorageBuffer ) {
-
-				const bindingData = backend.get( binding );
-
-				if ( bindingData.buffer === undefined ) {
-
-					const attribute = binding.attribute;
-					//const usage = GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX | /*GPUBufferUsage.COPY_SRC |*/ GPUBufferUsage.COPY_DST;
-
-					//backend.attributeUtils.createAttribute( attribute, usage ); // @TODO: Move it to universal renderer
-
-					bindingData.buffer = backend.get( attribute ).buffer;
-
-				}
-
-				entriesGPU.push( { binding: bindingPoint, resource: { buffer: bindingData.buffer } } );
-
-			} else if ( binding.isSampler ) {
-
-				const textureGPU = backend.get( binding.texture );
-
-				entriesGPU.push( { binding: bindingPoint, resource: textureGPU.sampler } );
-
-			} else if ( binding.isSampledTexture ) {
-
-				const textureData = backend.get( binding.texture );
-
-				let dimensionViewGPU;
-
-				if ( binding.isSampledCubeTexture ) {
-
-					dimensionViewGPU = GPUTextureViewDimension.Cube;
-
-				} else {
-
-					dimensionViewGPU = GPUTextureViewDimension.TwoD;
-
-				}
-
-				let resourceGPU;
-
-				if ( textureData.externalTexture !== undefined ) {
-
-					resourceGPU = device.importExternalTexture( { source: textureData.externalTexture } );
-
-				} else {
-
-					const aspectGPU = GPUTextureAspect.All;
-
-					resourceGPU = textureData.texture.createView( { aspect: aspectGPU, dimension: dimensionViewGPU } );
-
-				}
-
-				entriesGPU.push( { binding: bindingPoint, resource: resourceGPU } );
-
-			}
-
-			bindingPoint ++;
-
-		}
-
-		return device.createBindGroup( {
-			layout: layoutGPU,
-			entries: entriesGPU
-		} );
-
-	}
-
-}
-
-export default WebGPUBindingUtils;