super-three 0.152.0 → 0.154.0

package/examples/jsm/renderers/webgpu/{WebGPURenderPipeline.js → utils/WebGPUPipelineUtils.js}

@@ -1,57 +1,42 @@
-import { GPUIndexFormat, GPUCompareFunction, GPUFrontFace, GPUCullMode, GPUBlendFactor, GPUBlendOperation, BlendColorFactor, OneMinusBlendColorFactor, GPUColorWriteFlags, GPUStencilOperation, GPUInputStepMode } from './constants.js';
+import { BlendColorFactor, OneMinusBlendColorFactor, } from '../../common/Constants.js';
+
+import {
+	GPUFrontFace, GPUCullMode, GPUColorWriteFlags, GPUCompareFunction, GPUBlendFactor, GPUBlendOperation, GPUIndexFormat, GPUStencilOperation
+} from './WebGPUConstants.js';
+
 import {
-	Float16BufferAttribute,
 	FrontSide, BackSide, DoubleSide,
 	NeverDepth, AlwaysDepth, LessDepth, LessEqualDepth, EqualDepth, GreaterEqualDepth, GreaterDepth, NotEqualDepth,
-	NeverStencilFunc, AlwaysStencilFunc, LessStencilFunc, LessEqualStencilFunc, EqualStencilFunc, GreaterEqualStencilFunc, GreaterStencilFunc, NotEqualStencilFunc,
-	KeepStencilOp, ZeroStencilOp, ReplaceStencilOp, InvertStencilOp, IncrementStencilOp, DecrementStencilOp, IncrementWrapStencilOp, DecrementWrapStencilOp,
 	NoBlending, NormalBlending, AdditiveBlending, SubtractiveBlending, MultiplyBlending, CustomBlending,
+	ZeroFactor, OneFactor, SrcColorFactor, OneMinusSrcColorFactor, SrcAlphaFactor, OneMinusSrcAlphaFactor, DstColorFactor,
+	OneMinusDstColorFactor, DstAlphaFactor, OneMinusDstAlphaFactor, SrcAlphaSaturateFactor,
 	AddEquation, SubtractEquation, ReverseSubtractEquation, MinEquation, MaxEquation,
-	ZeroFactor, OneFactor, SrcColorFactor, OneMinusSrcColorFactor, SrcAlphaFactor, OneMinusSrcAlphaFactor, DstAlphaFactor, OneMinusDstAlphaFactor, DstColorFactor, OneMinusDstColorFactor, SrcAlphaSaturateFactor
+	KeepStencilOp, ZeroStencilOp, ReplaceStencilOp, InvertStencilOp, IncrementStencilOp, DecrementStencilOp, IncrementWrapStencilOp, DecrementWrapStencilOp,
+	NeverStencilFunc, AlwaysStencilFunc, LessStencilFunc, LessEqualStencilFunc, EqualStencilFunc, GreaterEqualStencilFunc, GreaterStencilFunc, NotEqualStencilFunc
 } from 'three';
 
-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', ]],
-] );
+class WebGPUPipelineUtils {
 
-const typeArraysToVertexFormatPrefixForItemSize1 = new Map( [
-	[ Int32Array, 'sint32' ],
-	[ Uint32Array, 'uint32' ],
-	[ Float32Array, 'float32' ]
-] );
+	constructor( backend ) {
 
-class WebGPURenderPipeline {
+		this.backend = backend;
 
-	constructor( device, utils ) {
-
-		this.cacheKey = null;
-		this.shaderAttributes = null;
-		this.stageVertex = null;
-		this.stageFragment = null;
-		this.usedTimes = 0;
+	}
 
-		this._device = device;
-		this._utils = utils;
+	createRenderPipeline( renderObject ) {
 
-	}
+		const { object, material, geometry, pipeline } = renderObject;
+		const { vertexProgram, fragmentProgram } = pipeline;
 
-	init( cacheKey, stageVertex, stageFragment, renderObject, nodeBuilder ) {
+		const backend = this.backend;
+		const device = backend.device;
+		const utils = backend.utils;
 
-		const { object, material, geometry } = renderObject;
+		const pipelineData = backend.get( pipeline );
 
 		// determine shader attributes
 
-		const shaderAttributes = this._getShaderAttributes( nodeBuilder, geometry );
+		const shaderAttributes = backend.attributeUtils.createShaderAttributes( renderObject );
 
 		// vertex buffers
 
@@ -59,32 +44,24 @@ class WebGPURenderPipeline {
 
 		for ( const attribute of shaderAttributes ) {
 
-			const name = attribute.name;
-			const geometryAttribute = geometry.getAttribute( name );
-			const stepMode = ( geometryAttribute !== undefined && geometryAttribute.isInstancedBufferAttribute ) ? GPUInputStepMode.Instance : GPUInputStepMode.Vertex;
-
 			vertexBuffers.push( {
 				arrayStride: attribute.arrayStride,
 				attributes: [ { shaderLocation: attribute.slot, offset: attribute.offset, format: attribute.format } ],
-				stepMode: stepMode
+				stepMode: attribute.stepMode
 			} );
 
 		}
 
-		this.cacheKey = cacheKey;
-		this.shaderAttributes = shaderAttributes;
-		this.stageVertex = stageVertex;
-		this.stageFragment = stageFragment;
-
 		// blending
 
-		let alphaBlend = {};
-		let colorBlend = {};
+		let blending;
 
 		if ( material.transparent === true && material.blending !== NoBlending ) {
 
-			alphaBlend = this._getAlphaBlend( material );
-			colorBlend = this._getColorBlend( material );
+			blending = {
+				alpha: this._getAlphaBlend( material ),
+				color: this._getColorBlend( material )
+			};
 
 		}
 
@@ -105,21 +82,21 @@ class WebGPURenderPipeline {
 
 		//
 
+		const vertexModule = backend.get( vertexProgram ).module;
+		const fragmentModule = backend.get( fragmentProgram ).module;
+
 		const primitiveState = this._getPrimitiveState( object, geometry, material );
 		const colorWriteMask = this._getColorWriteMask( material );
 		const depthCompare = this._getDepthCompare( material );
-		const colorFormat = this._utils.getCurrentColorFormat();
-		const depthStencilFormat = this._utils.getCurrentDepthStencilFormat();
-		const sampleCount = this._utils.getSampleCount();
+		const colorFormat = utils.getCurrentColorFormat( renderObject.context );
+		const depthStencilFormat = utils.getCurrentDepthStencilFormat( renderObject.context );
+		const sampleCount = utils.getSampleCount( renderObject.context );
 
-		this.pipeline = this._device.createRenderPipeline( {
-			vertex: Object.assign( {}, stageVertex.stage, { buffers: vertexBuffers } ),
-			fragment: Object.assign( {}, stageFragment.stage, { targets: [ {
+		pipelineData.pipeline = device.createRenderPipeline( {
+			vertex: Object.assign( {}, vertexModule, { buffers: vertexBuffers } ),
+			fragment: Object.assign( {}, fragmentModule, { targets: [ {
 				format: colorFormat,
-				blend: {
-					alpha: alphaBlend,
-					color: colorBlend
-				},
+				blend: blending,
 				writeMask: colorWriteMask
 			} ] } ),
 			primitive: primitiveState,
@@ -140,6 +117,22 @@ class WebGPURenderPipeline {
 
 	}
 
+	createComputePipeline( pipeline ) {
+
+		const backend = this.backend;
+		const device = backend.device;
+
+		const computeProgram = backend.get( pipeline.computeProgram ).module;
+
+		const pipelineGPU = backend.get( pipeline );
+
+		pipelineGPU.pipeline = device.createComputePipeline( {
+			compute: computeProgram,
+			layout: 'auto'
+		} );
+
+	}
+
 	_getAlphaBlend( material ) {
 
 		const blending = material.blending;
@@ -286,7 +279,6 @@ class WebGPURenderPipeline {
 				blendFactor = GPUBlendFactor.OneMinusBlendColor;
 				break;
 
-
 			default:
 				console.error( 'THREE.WebGPURenderer: Blend factor not supported.', blend );
 
@@ -296,41 +288,6 @@ class WebGPURenderPipeline {
 
 	}
 
-	_getBlendOperation( blendEquation ) {
-
-		let blendOperation;
-
-		switch ( blendEquation ) {
-
-			case AddEquation:
-				blendOperation = GPUBlendOperation.Add;
-				break;
-
-			case SubtractEquation:
-				blendOperation = GPUBlendOperation.Subtract;
-				break;
-
-			case ReverseSubtractEquation:
-				blendOperation = GPUBlendOperation.ReverseSubtract;
-				break;
-
-			case MinEquation:
-				blendOperation = GPUBlendOperation.Min;
-				break;
-
-			case MaxEquation:
-				blendOperation = GPUBlendOperation.Max;
-				break;
-
-			default:
-				console.error( 'THREE.WebGPURenderer: Blend equation not supported.', blendEquation );
-
-		}
-
-		return blendOperation;
-
-	}
-
 	_getColorBlend( material ) {
 
 		const blending = material.blending;
@@ -383,109 +340,6 @@ class WebGPURenderPipeline {
 
 	}
 
-	_getColorWriteMask( material ) {
-
-		return ( material.colorWrite === true ) ? GPUColorWriteFlags.All : GPUColorWriteFlags.None;
-
-	}
-
-	_getDepthCompare( material ) {
-
-		let depthCompare;
-
-		if ( material.depthTest === false ) {
-
-			depthCompare = GPUCompareFunction.Always;
-
-		} else {
-
-			const depthFunc = material.depthFunc;
-
-			switch ( depthFunc ) {
-
-				case NeverDepth:
-					depthCompare = GPUCompareFunction.Never;
-					break;
-
-				case AlwaysDepth:
-					depthCompare = GPUCompareFunction.Always;
-					break;
-
-				case LessDepth:
-					depthCompare = GPUCompareFunction.Less;
-					break;
-
-				case LessEqualDepth:
-					depthCompare = GPUCompareFunction.LessEqual;
-					break;
-
-				case EqualDepth:
-					depthCompare = GPUCompareFunction.Equal;
-					break;
-
-				case GreaterEqualDepth:
-					depthCompare = GPUCompareFunction.GreaterEqual;
-					break;
-
-				case GreaterDepth:
-					depthCompare = GPUCompareFunction.Greater;
-					break;
-
-				case NotEqualDepth:
-					depthCompare = GPUCompareFunction.NotEqual;
-					break;
-
-				default:
-					console.error( 'THREE.WebGPURenderer: Invalid depth function.', depthFunc );
-
-			}
-
-		}
-
-		return depthCompare;
-
-	}
-
-	_getPrimitiveState( object, geometry, material ) {
-
-		const descriptor = {};
-
-		descriptor.topology = this._utils.getPrimitiveTopology( object, material );
-
-		if ( object.isLine === true && object.isLineSegments !== true ) {
-
-			const count = ( geometry.index ) ? geometry.index.count : geometry.attributes.position.count;
-			descriptor.stripIndexFormat = ( count > 65535 ) ? GPUIndexFormat.Uint32 : GPUIndexFormat.Uint16; // define data type for primitive restart value
-
-		}
-
-		switch ( material.side ) {
-
-			case FrontSide:
-				descriptor.frontFace = GPUFrontFace.CW;
-				descriptor.cullMode = GPUCullMode.Front;
-				break;
-
-			case BackSide:
-				descriptor.frontFace = GPUFrontFace.CW;
-				descriptor.cullMode = GPUCullMode.Back;
-				break;
-
-			case DoubleSide:
-				descriptor.frontFace = GPUFrontFace.CW;
-				descriptor.cullMode = GPUCullMode.None;
-				break;
-
-			default:
-				console.error( 'THREE.WebGPURenderer: Unknown Material.side value.', material.side );
-				break;
-
-		}
-
-		return descriptor;
-
-	}
-
 	_getStencilCompare( material ) {
 
 		let stencilCompare;
@@ -582,92 +436,145 @@ class WebGPURenderPipeline {
 
 	}
 
-	_getVertexFormat( geometryAttribute ) {
+	_getBlendOperation( blendEquation ) {
+
+		let blendOperation;
+
+		switch ( blendEquation ) {
 
-		const { itemSize, normalized } = geometryAttribute;
-		const ArrayType = geometryAttribute.array.constructor;
-		const AttributeType = geometryAttribute.constructor;
+			case AddEquation:
+				blendOperation = GPUBlendOperation.Add;
+				break;
 
-		let format;
+			case SubtractEquation:
+				blendOperation = GPUBlendOperation.Subtract;
+				break;
 
-		if ( itemSize == 1 ) {
+			case ReverseSubtractEquation:
+				blendOperation = GPUBlendOperation.ReverseSubtract;
+				break;
 
-			format = typeArraysToVertexFormatPrefixForItemSize1.get( ArrayType );
+			case MinEquation:
+				blendOperation = GPUBlendOperation.Min;
+				break;
 
-		} else {
+			case MaxEquation:
+				blendOperation = GPUBlendOperation.Max;
+				break;
 
-			const prefixOptions = typedAttributeToVertexFormatPrefix.get( AttributeType ) || typedArraysToVertexFormatPrefix.get( ArrayType );
-			const prefix = prefixOptions[ normalized ? 1 : 0 ];
+			default:
+				console.error( 'THREE.WebGPUPipelineUtils: Blend equation not supported.', blendEquation );
 
-			if ( prefix ) {
+		}
 
-				const bytesPerUnit = ArrayType.BYTES_PER_ELEMENT * itemSize;
-				const paddedBytesPerUnit = Math.floor( ( bytesPerUnit + 3 ) / 4 ) * 4;
-				const paddedItemSize = paddedBytesPerUnit / ArrayType.BYTES_PER_ELEMENT;
+		return blendOperation;
 
-				if ( paddedItemSize % 1 ) {
+	}
 
-					throw new Error( 'THREE.WebGPURenderer: Bad vertex format item size.' );
+	_getPrimitiveState( object, geometry, material ) {
 
-				}
+		const descriptor = {};
+		const utils = this.backend.utils;
 
-				format = `${prefix}x${paddedItemSize}`;
+		descriptor.topology = utils.getPrimitiveTopology( object, material );
 
-			}
+		if ( object.isLine === true && object.isLineSegments !== true ) {
+
+			const count = ( geometry.index ) ? geometry.index.count : geometry.attributes.position.count;
+			descriptor.stripIndexFormat = ( count > 65535 ) ? GPUIndexFormat.Uint32 : GPUIndexFormat.Uint16; // define data type for primitive restart value
 
 		}
 
-		if ( ! format ) {
+		switch ( material.side ) {
+
+			case FrontSide:
+				descriptor.frontFace = GPUFrontFace.CW;
+				descriptor.cullMode = GPUCullMode.Front;
+				break;
+
+			case BackSide:
+				descriptor.frontFace = GPUFrontFace.CW;
+				descriptor.cullMode = GPUCullMode.Back;
+				break;
+
+			case DoubleSide:
+				descriptor.frontFace = GPUFrontFace.CW;
+				descriptor.cullMode = GPUCullMode.None;
+				break;
 
-			console.error( 'THREE.WebGPURenderer: Vertex format not supported yet.' );
+			default:
+				console.error( 'THREE.WebGPUPipelineUtils: Unknown material.side value.', material.side );
+				break;
 
 		}
 
-		return format;
+		return descriptor;
 
 	}
 
-	_getShaderAttributes( nodeBuilder, geometry ) {
+	_getColorWriteMask( material ) {
 
-		const nodeAttributes = nodeBuilder.attributes;
-		const attributes = [];
+		return ( material.colorWrite === true ) ? GPUColorWriteFlags.All : GPUColorWriteFlags.None;
 
-		for ( let slot = 0; slot < nodeAttributes.length; slot ++ ) {
+	}
 
-			const nodeAttribute = nodeAttributes[ slot ];
-			const name = nodeAttribute.name;
+	_getDepthCompare( material ) {
 
-			const geometryAttribute = geometry.getAttribute( name );
-			const bytesPerElement = geometryAttribute.array.BYTES_PER_ELEMENT;
+		let depthCompare;
 
-			const format = this._getVertexFormat( geometryAttribute );
+		if ( material.depthTest === false ) {
 
-			let arrayStride = geometryAttribute.itemSize * bytesPerElement;
-			let offset = 0;
+			depthCompare = GPUCompareFunction.Always;
 
-			if ( geometryAttribute.isInterleavedBufferAttribute === true ) {
+		} else {
 
-				// @TODO: It can be optimized for "vertexBuffers" on RenderPipeline
+			const depthFunc = material.depthFunc;
 
-				arrayStride = geometryAttribute.data.stride * bytesPerElement;
-				offset = geometryAttribute.offset * bytesPerElement;
+			switch ( depthFunc ) {
 
-			}
+				case NeverDepth:
+					depthCompare = GPUCompareFunction.Never;
+					break;
 
-			attributes.push( {
-				name,
-				arrayStride,
-				offset,
-				format,
-				slot
-			} );
+				case AlwaysDepth:
+					depthCompare = GPUCompareFunction.Always;
+					break;
+
+				case LessDepth:
+					depthCompare = GPUCompareFunction.Less;
+					break;
+
+				case LessEqualDepth:
+					depthCompare = GPUCompareFunction.LessEqual;
+					break;
+
+				case EqualDepth:
+					depthCompare = GPUCompareFunction.Equal;
+					break;
+
+				case GreaterEqualDepth:
+					depthCompare = GPUCompareFunction.GreaterEqual;
+					break;
+
+				case GreaterDepth:
+					depthCompare = GPUCompareFunction.Greater;
+					break;
+
+				case NotEqualDepth:
+					depthCompare = GPUCompareFunction.NotEqual;
+					break;
+
+				default:
+					console.error( 'THREE.WebGPUPipelineUtils: Invalid depth function.', depthFunc );
+
+			}
 
 		}
 
-		return attributes;
+		return depthCompare;
 
 	}
 
 }
 
-export default WebGPURenderPipeline;
+export default WebGPUPipelineUtils;

package/examples/jsm/renderers/webgpu/{WebGPUTextureUtils.js → utils/WebGPUTextureMipmapUtils.js}

@@ -1,28 +1,6 @@
-// Copyright 2020 Brandon Jones
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
+import { GPUTextureViewDimension, GPUIndexFormat, GPUFilterMode, GPUPrimitiveTopology, GPULoadOp, GPUStoreOp } from './WebGPUConstants.js';
 
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-import { GPUTextureViewDimension, GPUIndexFormat, GPUFilterMode, GPUPrimitiveTopology, GPULoadOp, GPUStoreOp } from './constants.js';
-
-// ported from https://github.com/toji/web-texture-tool/blob/master/src/webgpu-mipmap-generator.js
-
-class WebGPUTextureUtils {
+class WebGPUTextureMipmapUtils {
 
 	constructor( device ) {
 
@@ -182,4 +160,4 @@ fn main( @location( 0 ) vTex : vec2<f32> ) -> @location( 0 ) vec4<f32> {
 
 }
 
-export default WebGPUTextureUtils;
+export default WebGPUTextureMipmapUtils;