@unikia/upe-renderer 0.186.110 → 0.187.11

package/examples/jsm/lighting/LightProbeGridWebGL.js

@@ -4,11 +4,11 @@ import {
 	Data3DTexture,
 	FloatType,
 	HalfFloatType,
+	Light,
 	LinearFilter,
 	MathUtils,
 	Mesh,
 	NearestFilter,
-	Object3D,
 	OrthographicCamera,
 	PlaneGeometry,
 	RGBAFormat,
@@ -85,23 +85,25 @@ const ATLAS_PADDING = 1;
  *
  * @three_import import { LightProbeGridWebGL } from 'three/addons/lighting/LightProbeGridWebGL.js';
  */
-class LightProbeGridWebGL extends Object3D {
+class LightProbeGridWebGL extends Light {
 
 	/**
 	 * Constructs a new irradiance probe grid.
 	 *
-	 * The volume is centered at the object's position.
+	 * The volume is centered at the object's position. It is split into one cell
+	 * per probe, with each probe at the center of its cell, so the probes sit half
+	 * a cell inside the volume.
 	 *
 	 * @param {number} [width=1] - Full width of the volume along X.
 	 * @param {number} [height=1] - Full height of the volume along Y.
 	 * @param {number} [depth=1] - Full depth of the volume along Z.
-	 * @param {number} [widthProbes] - Number of probes along X. Defaults to `Math.max( 2, Math.round( width ) + 1 )`.
-	 * @param {number} [heightProbes] - Number of probes along Y. Defaults to `Math.max( 2, Math.round( height ) + 1 )`.
-	 * @param {number} [depthProbes] - Number of probes along Z. Defaults to `Math.max( 2, Math.round( depth ) + 1 )`.
+	 * @param {number} [widthProbes] - Number of probes along X. Defaults to `Math.max( 1, Math.round( width ) )`.
+	 * @param {number} [heightProbes] - Number of probes along Y. Defaults to `Math.max( 1, Math.round( height ) )`.
+	 * @param {number} [depthProbes] - Number of probes along Z. Defaults to `Math.max( 1, Math.round( depth ) )`.
 	 */
 	constructor( width = 1, height = 1, depth = 1, widthProbes, heightProbes, depthProbes ) {
 
-		super();
+		super( 0xffffff, 1 );
 
 		/**
 		 * This flag can be used for type testing.
@@ -112,6 +114,8 @@ class LightProbeGridWebGL extends Object3D {
 		 */
 		this.isLightProbeGrid = true;
 
+		this.type = 'LightProbeGridWebGL';
+
 		/**
 		 * The full width of the volume along X.
 		 *
@@ -139,19 +143,29 @@ class LightProbeGridWebGL extends Object3D {
 		 * @type {Vector3}
 		 */
 		this.resolution = new Vector3(
-			widthProbes !== undefined ? widthProbes : Math.max( 2, Math.round( width ) + 1 ),
-			heightProbes !== undefined ? heightProbes : Math.max( 2, Math.round( height ) + 1 ),
-			depthProbes !== undefined ? depthProbes : Math.max( 2, Math.round( depth ) + 1 )
+			widthProbes !== undefined ? widthProbes : Math.max( 1, Math.round( width ) ),
+			heightProbes !== undefined ? heightProbes : Math.max( 1, Math.round( height ) ),
+			depthProbes !== undefined ? depthProbes : Math.max( 1, Math.round( depth ) )
 		);
 
 		/**
-		 * The world-space bounding box for the grid. Updated automatically
+		 * The world-space bounding box for the grid. This is the volume the grid
+		 * lights, with the probes half a cell inside it. Updated automatically
 		 * by {@link LightProbeGridWebGL#bake}.
 		 *
 		 * @type {Box3}
 		 */
 		this.boundingBox = new Box3();
 
+		/**
+		 * Where grids overlap, the grid with the highest priority lights the
+		 * fragment. On ties, the most recently created grid wins.
+		 *
+		 * @type {number}
+		 * @default 0
+		 */
+		this.priority = 0;
+
 		/**
 		 * The single RGBA atlas 3D texture storing all seven packed SH sub-volumes.
 		 *
@@ -193,9 +207,9 @@ class LightProbeGridWebGL extends Object3D {
 		const w = this.width, h = this.height, d = this.depth;
 
 		target.set(
-			res.x > 1 ? pos.x - w / 2 + ix * w / ( res.x - 1 ) : pos.x,
-			res.y > 1 ? pos.y - h / 2 + iy * h / ( res.y - 1 ) : pos.y,
-			res.z > 1 ? pos.z - d / 2 + iz * d / ( res.z - 1 ) : pos.z
+			pos.x - w / 2 + ( ix + 0.5 ) * w / res.x,
+			pos.y - h / 2 + ( iy + 0.5 ) * h / res.y,
+			pos.z - d / 2 + ( iz + 0.5 ) * d / res.z
 		);
 
 		return target;
@@ -553,6 +567,8 @@ class LightProbeGridWebGL extends Object3D {
 
 		}
 
+		super.dispose();
+
 	}
 
 }

package/examples/jsm/lighting/vxgi/VXGIConeTracer.js

@@ -1,4 +1,4 @@
-import { float, vec3, vec4, If, Loop, Break, max, min, abs, dot, clamp, log2, exp2, select } from 'three/tsl';
+import { float, vec3, vec4, If, Loop, Break, max, min, abs, dot, cross, normalize, clamp, log2, exp2, fract, sqrt, cos, sin, select, EPSILON, PI } from 'three/tsl';
 
 /**
  * Emits the intersection of a ray with the bounds of the given volume.
@@ -14,9 +14,9 @@ export function intersectVolume( volume, origin, direction ) {
 	const boundsMax = boundsMin.add( volume.volumeSizeNode ).toConst();
 
 	const safeDirection = vec3(
-		select( abs( direction.x ).lessThan( 1e-6 ), 1e-6, direction.x ),
-		select( abs( direction.y ).lessThan( 1e-6 ), 1e-6, direction.y ),
-		select( abs( direction.z ).lessThan( 1e-6 ), 1e-6, direction.z )
+		select( abs( direction.x ).lessThan( EPSILON ), EPSILON, direction.x ),
+		select( abs( direction.y ).lessThan( EPSILON ), EPSILON, direction.y ),
+		select( abs( direction.z ).lessThan( EPSILON ), EPSILON, direction.z )
 	).toConst();
 
 	const invDirection = float( 1 ).div( safeDirection ).toConst();
@@ -118,7 +118,7 @@ export function createConeTracer( volume, options = {} ) {
 
 		// AO falloff 1 / ( 1 + r / aoDistance )
 
-		const aoFalloff = aoDistance !== null ? select( aoDistance.greaterThan( 0 ), float( 1 ).div( max( aoDistance, 1e-6 ) ), float( 0 ) ).toConst() : null;
+		const aoFalloff = aoDistance !== null ? select( aoDistance.greaterThan( 0 ), float( 1 ).div( max( aoDistance, EPSILON ) ), float( 0 ) ).toConst() : null;
 
 		If( tExit.greaterThan( t ), () => {
 
@@ -192,3 +192,52 @@ export function createConeTracer( volume, options = {} ) {
 	};
 
 }
+
+/**
+ * Emits a diffuse gather: Traces stratified cosine-weighted cones around the normal and averages them.
+ *
+ * @param {Function} trace - The cone tracing function, see {@link createConeTracer}.
+ * @param {Node<vec3>} origin - The origin of the cones.
+ * @param {Node<vec3>} normal - The normalized surface normal.
+ * @param {Node<uint>|number} coneCount - The number of cones.
+ * @param {Node<float>} tanHalfAngle - The tangent of half the cone angle.
+ * @param {Node<float>} maxDistance - The maximum trace distance.
+ * @param {Node<float>|number} rotation - Rotation of the cones around the normal in `[0, 1)`.
+ * @param {Node<float>|number} elevation - Offset of the cones within their elevation strata in `[0, 1)`.
+ * @param {?Node<float>} [aoDistance=null] - The AO falloff distance. AO is only computed if given.
+ * @return {{color: Node<vec3>, ao: Node<float>}} The mean radiance and the mean AO of the cones.
+ */
+export function gather( trace, origin, normal, coneCount, tanHalfAngle, maxDistance, rotation, elevation, aoDistance = null ) {
+
+	// tangent frame
+
+	const up = select( abs( normal.y ).lessThan( 0.99 ), vec3( 0, 1, 0 ), vec3( 1, 0, 0 ) );
+	const tangent = normalize( cross( normal, up ) ).toConst();
+	const bitangent = cross( normal, tangent ).toConst();
+
+	const color = vec3( 0 ).toVar();
+	const ao = float( 0 ).toVar();
+
+	Loop( { start: 0, end: coneCount, type: 'uint', condition: '<', name: 'c' }, ( { c } ) => {
+
+		// stratified cosine-weighted directions
+
+		const u1 = float( c ).add( elevation ).div( float( coneCount ) ).toConst();
+		const u2 = fract( float( c ).mul( 0.618034 ).add( rotation ) ).toConst();
+		const sinTheta = sqrt( u1 ).toConst();
+		const cosTheta = sqrt( u1.oneMinus() ).toConst();
+		const phi = u2.mul( PI.mul( 2 ) ).toConst();
+
+		const direction = normalize( tangent.mul( cos( phi ).mul( sinTheta ) ).add( bitangent.mul( sin( phi ).mul( sinTheta ) ) ).add( normal.mul( cosTheta ) ) ).toConst();
+
+		const cone = trace( origin, direction, tanHalfAngle, maxDistance, aoDistance );
+
+		color.addAssign( cone.color );
+
+		if ( aoDistance !== null ) ao.addAssign( cone.ao );
+
+	} );
+
+	return { color: color.div( float( coneCount ) ), ao: ao.div( float( coneCount ) ) };
+
+}

package/examples/jsm/lighting/vxgi/VXGIIrradiance.js

@@ -0,0 +1,43 @@
+import { Fn, PI, float, interleavedGradientNoise, screenCoordinate, vec2 } from 'three/tsl';
+import { createConeTracer, gather } from './VXGIConeTracer.js';
+
+/**
+ * Creates a world-space diffuse irradiance sampler for a prepared {@link VXGIVolume}.
+ * Call `volume.update( renderer, scene )` before baking. The sampler traces cosine-weighted
+ * cones through the volume's radiance, including cached bounces.
+ * It can be passed directly to {@link LightMapper}, without a screen-space pass.
+ * The cones are rotated per pixel with interleaved gradient noise like `VXGINode`. When baking, the
+ * pixel is the light map texel. The optional sample index shifts the noise so that accumulated
+ * samples, or a temporal filter like TRAA, converge.
+ *
+ * @param {VXGIVolume} volume - The prepared voxel volume.
+ * @param {Object} [options] - Options.
+ * @param {number} [options.coneCount=8] - The number of cones per sample. Fewer cones are faster but coarser.
+ * @return {function(Node<vec3>, Node<vec3>, ?Node<float>): Node<vec3>} The irradiance sampler.
+ */
+function vxgiIrradiance( volume, { coneCount = 8 } = {} ) {
+
+	const trace = createConeTracer( volume, {
+		radianceNode: volume.radianceNode,
+		directionalNode: volume.directionalRadiance ? volume.directionalNode : null
+	} );
+
+	return ( position, normal, sample = float( 0 ) ) => Fn( () => {
+
+		// interleaved gradient noise offsets of the stratified cone set, see VXGINode
+
+		const shift = screenCoordinate.add( sample.mul( 5.588238 ) ).toConst();
+		const elevation = interleavedGradientNoise( shift.add( vec2( 5.588238, 3.14159 ) ) ).toConst();
+		const rotation = interleavedGradientNoise( shift ).toConst();
+
+		const origin = position.add( normal.mul( volume.voxelSizeNode.mul( 1.5 ) ) ).toConst();
+
+		const { color } = gather( trace, origin, normal, coneCount, float( Math.tan( Math.PI / 9 ) ), volume.traceDistanceNode, rotation, elevation );
+
+		return color.mul( PI );
+
+	} )();
+
+}
+
+export { vxgiIrradiance };

package/examples/jsm/lighting/vxgi/VXGINode.js

@@ -1,8 +1,8 @@
-import { RenderTarget, Vector2, Vector3, TempNode, QuadMesh, NodeMaterial, RendererUtils, HalfFloatType, RGBAFormat, RedFormat, UnsignedByteType } from 'three/webgpu';
-import { Fn, NodeUpdateType, uniform, reference, vec2, vec3, vec4, float, uint, uv, mix, passTexture, getViewPosition, getNormalFromDepth, logarithmicDepthToViewZ, viewZToPerspectiveDepth, screenCoordinate, interleavedGradientNoise, normalize, cross, abs, select, sqrt, fract, floor, cos, sin, exp2, pow, PI, Loop, If, Break, property, outputStruct, context } from 'three/tsl';
+import { RenderTarget, Vector2, Vector3, Node, QuadMesh, NodeMaterial, RendererUtils, HalfFloatType, RGBAFormat, RedFormat, UnsignedByteType } from 'three/webgpu';
+import { Fn, NodeUpdateType, uniform, reference, vec2, vec4, float, uv, mix, passTexture, getViewPosition, getNormalFromDepth, screenCoordinate, interleavedGradientNoise, normalize, floor, exp2, pow, PI, Loop, If, Break, property, outputStruct, context, projectionDepth } from 'three/tsl';
 
 import { VXGIVolume } from './VXGIVolume.js';
-import { createConeTracer, intersectVolume, sampleDirectional } from './VXGIConeTracer.js';
+import { createConeTracer, gather, intersectVolume, sampleDirectional } from './VXGIConeTracer.js';
 
 const _quadMesh = /*@__PURE__*/ new QuadMesh();
 const _size = /*@__PURE__*/ new Vector2();
@@ -40,10 +40,10 @@ const _neutralContext = /*@__PURE__*/ context();
  *
  * Note: This node can only be used with `WebGPURenderer` and a WebGPU backend.
  *
- * @augments TempNode
+ * @augments Node
  * @three_import import { vxgi } from 'three/addons/lighting/vxgi/VXGINode.js';
  */
-class VXGINode extends TempNode {
+class VXGINode extends Node {
 
 	static get type() {
 
@@ -380,7 +380,7 @@ class VXGINode extends TempNode {
 
 		if ( this._sharedContext !== null && this._directional !== this.volume.directionalRadiance ) {
 
-			this._setupMaterial( renderer );
+			this._setupMaterial();
 
 		}
 
@@ -425,7 +425,7 @@ class VXGINode extends TempNode {
 	setup( builder ) {
 
 		this._sharedContext = builder.getSharedContext();
-		this._setupMaterial( builder.renderer );
+		this._setupMaterial();
 
 		return this._aoNode;
 
@@ -435,29 +435,14 @@ class VXGINode extends TempNode {
 	 * Builds the TSL code of the effect into the internal pass material.
 	 *
 	 * @private
-	 * @param {Renderer} renderer - The renderer.
 	 */
-	_setupMaterial( renderer ) {
+	_setupMaterial() {
 
 		const volume = this.volume;
 		const directional = this._directional = volume.directionalRadiance;
 		const uvNode = uv();
 
-		const sampleDepth = ( uv ) => {
-
-			const depth = this.depthNode.sample( uv ).r;
-
-			if ( renderer.logarithmicDepthBuffer === true ) {
-
-				const viewZ = logarithmicDepthToViewZ( depth, this._cameraNear, this._cameraFar );
-
-				return viewZToPerspectiveDepth( viewZ, this._cameraNear, this._cameraFar );
-
-			}
-
-			return depth;
-
-		};
+		const sampleDepth = ( uv ) => projectionDepth( this.depthNode.sample( uv ).r, this._cameraNear, this._cameraFar );
 
 		const sampleNormal = ( uv ) => ( this.normalNode !== null ) ? this.normalNode.sample( uv ).rgb.normalize() : getNormalFromDepth( uv, this.depthNode.value, this._cameraProjectionMatrixInverse );
 
@@ -491,47 +476,19 @@ class VXGINode extends TempNode {
 			const rotationNoise = interleavedGradientNoise( screenCoordinate.add( temporalShift ) ).toConst();
 			const elevationNoise = interleavedGradientNoise( screenCoordinate.add( temporalShift ).add( vec2( 5.588238, 3.14159 ) ) ).toConst();
 
-			// tangent frame
-
-			const up = select( abs( worldNormal.y ).lessThan( 0.99 ), vec3( 0, 1, 0 ), vec3( 1, 0, 0 ) );
-			const tangent = normalize( cross( worldNormal, up ) ).toConst();
-			const bitangent = cross( worldNormal, tangent ).toConst();
-
 			const CONE_COUNT = this.coneCount.toConst();
 			const tanHalfAngle = this.coneAngle.mul( 0.5 ).radians().tan().toConst();
 			const traceDistance = volume.traceDistanceNode;
 			const aoDistance = this.aoDistance;
-			const originOffset = worldNormal.mul( voxelSize.mul( this.normalOffset ) ).toConst();
+			const origin = worldPosition.add( worldNormal.mul( voxelSize.mul( this.normalOffset ) ) ).toConst();
 
-			const color = vec3( 0 ).toVar();
-			const occlusion = float( 0 ).toVar();
-
-			Loop( { start: uint( 0 ), end: CONE_COUNT, type: 'uint', condition: '<', name: 'c' }, ( { c } ) => {
-
-				// stratified cosine-weighted directions
-
-				const u1 = float( c ).add( elevationNoise ).div( float( CONE_COUNT ) ).toConst();
-				const u2 = fract( float( c ).mul( 0.618034 ).add( rotationNoise ) ).toConst();
-				const sinTheta = sqrt( u1 ).toConst();
-				const cosTheta = sqrt( u1.oneMinus() ).toConst();
-				const phi = u2.mul( PI.mul( 2 ) ).toConst();
-
-				const direction = normalize( tangent.mul( cos( phi ).mul( sinTheta ) ).add( bitangent.mul( sin( phi ).mul( sinTheta ) ) ).add( worldNormal.mul( cosTheta ) ) ).toConst();
-				const origin = worldPosition.add( originOffset ).toConst();
-
-				const cone = trace( origin, direction, tanHalfAngle, traceDistance, aoDistance );
-
-				color.addAssign( cone.color );
-				occlusion.addAssign( cone.ao );
-
-			} );
+			const { color: radiance, ao: occlusion } = gather( trace, origin, worldNormal, CONE_COUNT, tanHalfAngle, traceDistance, rotationNoise, elevationNoise, aoDistance );
 
 			// the mean radiance over the cosine-weighted hemisphere times PI is the irradiance
 
-			color.divAssign( float( CONE_COUNT ) );
-			color.mulAssign( this.giIntensity.mul( PI ) );
+			const color = radiance.mul( this.giIntensity.mul( PI ) ).toVar();
 
-			const ao = mix( this.aoMinVisibility, float( 1 ), pow( occlusion.div( float( CONE_COUNT ) ).oneMinus().clamp(), this.aoIntensity ) ).toVar();
+			const ao = mix( this.aoMinVisibility, float( 1 ), pow( occlusion.oneMinus().clamp(), this.aoIntensity ) ).toVar();
 
 			// debug visualization: march the voxels from the camera
 

package/examples/jsm/lighting/vxgi/VXGISceneCollector.js

@@ -1,4 +1,4 @@
-import { Box3, Color, Matrix4, Vector2, Vector3, BackSide, DoubleSide, SRGBColorSpace } from 'three/webgpu';
+import { Box3, Color, MathUtils, Matrix4, Vector2, Vector3, BackSide, DoubleSide, FrontSide, SRGBColorSpace } from 'three/webgpu';
 
 const _matrix = /*@__PURE__*/ new Matrix4();
 const _box = /*@__PURE__*/ new Box3();
@@ -12,8 +12,10 @@ const _uv = /*@__PURE__*/ new Vector2();
 const _color = /*@__PURE__*/ new Color();
 const _albedo = /*@__PURE__*/ new Color();
 const _emissive = /*@__PURE__*/ new Color();
+const _columns = /*@__PURE__*/ new Map();
 
 const IMAGE_SAMPLE_SIZE = 64;
+const POSITION_QUANTIZATION = 131072;
 
 /**
  * Number of floats per triangle record: three positions (vec4 each, w unused),
@@ -476,3 +478,316 @@ export function collectSceneTriangles( scene, options ) {
 	return { data, count: data.length / TRIANGLE_STRIDE };
 
 }
+
+/**
+ * Marks the sub-voxels inside closed meshes, so cones starting within an object are blocked. Only meshes
+ * with visible, opaque and single-sided materials whose geometry is closed and faces outwards are filled.
+ *
+ * @param {Scene} scene - The scene.
+ * @param {Object} options - Options.
+ * @param {Vector3} options.boundsMin - The minimum corner of the voxel grid.
+ * @param {number} options.voxelSize - The size of a voxel in world units.
+ * @param {Vector3} options.gridSize - The number of voxels per axis.
+ * @param {Layers} options.layers - Objects must pass this layer test.
+ * @param {Set<Object3D>} options.exclude - Objects to skip.
+ * @param {Uint8Array} target - One byte per voxel that receives the 2x2x2 sub-voxel bits of the interiors.
+ */
+export function computeSolidVoxels( scene, options, target ) {
+
+	const { boundsMin, voxelSize, gridSize, layers, exclude } = options;
+
+	const closedGeometries = new Map();
+
+	scene.traverseVisible( ( object ) => {
+
+		if ( isVoxelizable( object, layers, exclude ) === false || hasSolidMaterials( object ) === false ) return;
+
+		const geometry = object.geometry;
+
+		if ( closedGeometries.has( geometry ) === false ) closedGeometries.set( geometry, isClosed( geometry ) && facesOutwards( geometry ) );
+
+		if ( closedGeometries.get( geometry ) === false ) return;
+
+		if ( object.isInstancedMesh === true ) {
+
+			for ( let i = 0; i < object.count; i ++ ) {
+
+				object.getMatrixAt( i, _matrix );
+				_matrix.premultiply( object.matrixWorld );
+				fillInterior( geometry, _matrix, boundsMin, voxelSize, gridSize, target );
+
+			}
+
+		} else {
+
+			fillInterior( geometry, object.matrixWorld, boundsMin, voxelSize, gridSize, target );
+
+		}
+
+	} );
+
+}
+
+/**
+ * Returns `true` if all materials of the mesh render an opaque, single-sided surface.
+ *
+ * @private
+ */
+function hasSolidMaterials( mesh ) {
+
+	const materials = Array.isArray( mesh.material ) ? mesh.material : [ mesh.material ];
+
+	for ( const material of materials ) {
+
+		if ( material.visible === false || material.side !== FrontSide || material.transparent === true || material.alphaTest > 0 ) return false;
+
+	}
+
+	return true;
+
+}
+
+/**
+ * Returns `true` if every edge of the geometry is shared by an even number of triangles. Vertices with
+ * the same position (e.g. at uv seams) are treated as one vertex.
+ *
+ * @private
+ */
+function isClosed( geometry ) {
+
+	const position = geometry.getAttribute( 'position' );
+
+	if ( position === undefined ) return false;
+
+	const index = geometry.index;
+	const indices = index !== null ? index.array : null;
+	const count = index !== null ? index.count : position.count;
+
+	_box.setFromBufferAttribute( position );
+
+	const min = _box.min;
+	const size = _box.getSize( _vb );
+	const scaleX = POSITION_QUANTIZATION / Math.max( size.x, 1e-9 );
+	const scaleY = POSITION_QUANTIZATION / Math.max( size.y, 1e-9 );
+	const scaleZ = POSITION_QUANTIZATION / Math.max( size.z, 1e-9 );
+
+	const vertexMask = MathUtils.ceilPowerOfTwo( Math.max( position.count, 1 ) * 2 ) - 1;
+	const vertexKeys = new Int32Array( ( vertexMask + 1 ) * 3 );
+	const vertexSlots = new Int32Array( vertexMask + 1 ).fill( - 1 );
+	const vertexIds = new Int32Array( position.count );
+	let vertexCount = 0;
+
+	for ( let i = 0; i < position.count; i ++ ) {
+
+		const x = Math.round( ( position.getX( i ) - min.x ) * scaleX );
+		const y = Math.round( ( position.getY( i ) - min.y ) * scaleY );
+		const z = Math.round( ( position.getZ( i ) - min.z ) * scaleZ );
+
+		let slot = ( Math.imul( x, 73856093 ) ^ Math.imul( y, 19349663 ) ^ Math.imul( z, 83492791 ) ) & vertexMask;
+
+		while ( vertexSlots[ slot ] !== - 1 && ( vertexKeys[ slot * 3 ] !== x || vertexKeys[ slot * 3 + 1 ] !== y || vertexKeys[ slot * 3 + 2 ] !== z ) ) slot = ( slot + 1 ) & vertexMask;
+
+		if ( vertexSlots[ slot ] === - 1 ) {
+
+			vertexSlots[ slot ] = vertexCount ++;
+			vertexKeys[ slot * 3 ] = x;
+			vertexKeys[ slot * 3 + 1 ] = y;
+			vertexKeys[ slot * 3 + 2 ] = z;
+
+		}
+
+		vertexIds[ i ] = vertexSlots[ slot ];
+
+	}
+
+	const edgeMask = MathUtils.ceilPowerOfTwo( Math.max( count, 1 ) * 2 ) - 1;
+	const edgeKeys = new Int32Array( ( edgeMask + 1 ) * 2 ).fill( - 1 );
+	const edgeParity = new Uint8Array( edgeMask + 1 );
+	let openEdges = 0;
+
+	const toggleEdge = ( a, b ) => {
+
+		if ( a > b ) {
+
+			const t = a; a = b; b = t;
+
+		}
+
+		let slot = ( Math.imul( a, 73856093 ) ^ Math.imul( b, 19349663 ) ) & edgeMask;
+
+		while ( edgeKeys[ slot * 2 ] !== - 1 && ( edgeKeys[ slot * 2 ] !== a || edgeKeys[ slot * 2 + 1 ] !== b ) ) slot = ( slot + 1 ) & edgeMask;
+
+		edgeKeys[ slot * 2 ] = a;
+		edgeKeys[ slot * 2 + 1 ] = b;
+		edgeParity[ slot ] ^= 1;
+		openEdges += edgeParity[ slot ] === 1 ? 1 : - 1;
+
+	};
+
+	for ( let i = 0; i + 2 < count; i += 3 ) {
+
+		const a = vertexIds[ indices !== null ? indices[ i ] : i ];
+		const b = vertexIds[ indices !== null ? indices[ i + 1 ] : i + 1 ];
+		const c = vertexIds[ indices !== null ? indices[ i + 2 ] : i + 2 ];
+
+		if ( a === b || b === c || c === a ) continue;
+
+		toggleEdge( a, b );
+		toggleEdge( b, c );
+		toggleEdge( c, a );
+
+	}
+
+	return openEdges === 0;
+
+}
+
+/**
+ * Returns `true` if the triangles of the given closed geometry face outwards (positive signed volume).
+ *
+ * @private
+ */
+function facesOutwards( geometry ) {
+
+	const position = geometry.getAttribute( 'position' );
+	const index = geometry.index;
+	const indices = index !== null ? index.array : null;
+	const count = index !== null ? index.count : position.count;
+
+	_box.min.fromBufferAttribute( position, 0 );
+
+	let volume = 0;
+
+	for ( let i = 0; i + 2 < count; i += 3 ) {
+
+		_va.fromBufferAttribute( position, indices !== null ? indices[ i ] : i ).sub( _box.min );
+		_vb.fromBufferAttribute( position, indices !== null ? indices[ i + 1 ] : i + 1 ).sub( _box.min );
+		_vc.fromBufferAttribute( position, indices !== null ? indices[ i + 2 ] : i + 2 ).sub( _box.min );
+
+		volume += _va.dot( _vb.cross( _vc ) );
+
+	}
+
+	return volume > 0;
+
+}
+
+/**
+ * Marks the sub-voxels between pairs of surface crossings along each sub-voxel column in x.
+ *
+ * @private
+ */
+function fillInterior( geometry, matrix, boundsMin, voxelSize, gridSize, target ) {
+
+	const position = geometry.getAttribute( 'position' );
+	const index = geometry.index;
+	const count = index !== null ? index.count : position.count;
+
+	const invSubVoxel = 2 / voxelSize;
+	const columnsY = gridSize.y * 2, columnsZ = gridSize.z * 2, length = gridSize.x * 2;
+
+	_columns.clear();
+
+	for ( let i = 0; i + 2 < count; i += 3 ) {
+
+		const a = _va.fromBufferAttribute( position, index !== null ? index.getX( i ) : i ).applyMatrix4( matrix ).sub( boundsMin ).multiplyScalar( invSubVoxel );
+		let b = _vb.fromBufferAttribute( position, index !== null ? index.getX( i + 1 ) : i + 1 ).applyMatrix4( matrix ).sub( boundsMin ).multiplyScalar( invSubVoxel );
+		let c = _vc.fromBufferAttribute( position, index !== null ? index.getX( i + 2 ) : i + 2 ).applyMatrix4( matrix ).sub( boundsMin ).multiplyScalar( invSubVoxel );
+
+		const area = edgeFunction( a, b, c.y, c.z );
+
+		if ( area === 0 ) continue;
+
+		if ( area < 0 ) {
+
+			const t = b; b = c; c = t;
+
+		}
+
+		const j0 = Math.max( Math.ceil( Math.min( a.y, b.y, c.y ) - 0.5 ), 0 );
+		const j1 = Math.min( Math.floor( Math.max( a.y, b.y, c.y ) - 0.5 ), columnsY - 1 );
+		const k0 = Math.max( Math.ceil( Math.min( a.z, b.z, c.z ) - 0.5 ), 0 );
+		const k1 = Math.min( Math.floor( Math.max( a.z, b.z, c.z ) - 0.5 ), columnsZ - 1 );
+
+		for ( let k = k0; k <= k1; k ++ ) {
+
+			for ( let j = j0; j <= j1; j ++ ) {
+
+				const y = j + 0.5, z = k + 0.5;
+
+				const wa = edgeFunction( b, c, y, z );
+				const wb = edgeFunction( c, a, y, z );
+				const wc = edgeFunction( a, b, y, z );
+
+				if ( isInside( wa, b, c ) && isInside( wb, c, a ) && isInside( wc, a, b ) ) {
+
+					const column = j + k * columnsY;
+					let crossings = _columns.get( column );
+
+					if ( crossings === undefined ) {
+
+						crossings = [];
+						_columns.set( column, crossings );
+
+					}
+
+					crossings.push( ( wa * a.x + wb * b.x + wc * c.x ) / ( wa + wb + wc ) );
+
+				}
+
+			}
+
+		}
+
+	}
+
+	for ( const [ column, crossings ] of _columns ) {
+
+		if ( crossings.length % 2 !== 0 ) continue;
+
+		crossings.sort( ( p, q ) => p - q );
+
+		const j = column % columnsY, k = ( column - j ) / columnsY;
+		const offset = gridSize.x * ( ( j >> 1 ) + gridSize.y * ( k >> 1 ) );
+		const bitsYZ = ( ( j & 1 ) << 1 ) | ( ( k & 1 ) << 2 );
+
+		for ( let n = 0; n < crossings.length; n += 2 ) {
+
+			const i0 = Math.max( Math.ceil( crossings[ n ] - 0.5 ), 0 );
+			const i1 = Math.min( Math.ceil( crossings[ n + 1 ] - 0.5 ), length );
+
+			for ( let i = i0; i < i1; i ++ ) target[ offset + ( i >> 1 ) ] |= 1 << ( ( i & 1 ) | bitsYZ );
+
+		}
+
+	}
+
+}
+
+/**
+ * Edge function of the edge from `a` to `b` at the given point in the yz plane. As in the watertight
+ * ray/triangle test, the vertices are taken relative to the point, so a shared edge evaluates exactly
+ * opposite for both of its triangles.
+ *
+ * @private
+ */
+function edgeFunction( a, b, y, z ) {
+
+	return ( a.y - y ) * ( b.z - z ) - ( a.z - z ) * ( b.y - y );
+
+}
+
+/**
+ * Inside test for an edge function value. Points on an edge belong to one triangle only (top-left rule).
+ *
+ * @private
+ */
+function isInside( w, a, b ) {
+
+	if ( w !== 0 ) return w > 0;
+
+	const dz = b.z - a.z;
+
+	return dz < 0 || ( dz === 0 && b.y > a.y );
+
+}