rayzee 9.3.2 → 9.4.0

package/src/Processor/Workers/TexturesWorker.js

@@ -2,15 +2,112 @@ let canvas, ctx;
 
 // Memory limits and chunking configuration
 const MEMORY_LIMITS = {
-	MAX_BYTES_PER_TEXTURE: 256 * 1024 * 1024, // 256MB per texture array
 	MAX_TEXTURE_DIMENSION: 8192, // Hardware ceiling (WebGPU maxTextureDimension2D guaranteed min); the per-scene maxTextureSize setting is the actual knob
 	CHUNK_SIZE: 8, // Optimized: Process textures in chunks of 8 for better memory locality
 	ADAPTIVE_CHUNK_SIZE: true, // Enable adaptive chunk sizing based on texture dimensions
 	MEMORY_SAFETY_FACTOR: 0.8 // Use only 80% of estimated available memory
 };
 
+let stream = null;
+
+function handleStream( msg ) {
+
+	if ( msg.stream === 'begin' ) {
+
+		const { width, height, depth } = msg;
+		const target = new OffscreenCanvas( width, height );
+		const context = target.getContext( '2d', { willReadFrequently: true, alpha: true, desynchronized: true } );
+		stream = { width, height, depth, context, data: new Uint8Array( width * height * depth * 4 ) };
+		return;
+
+	}
+
+	const { width, height, depth, context, data } = stream;
+
+	if ( msg.stream === 'layer' ) {
+
+		context.clearRect( 0, 0, width, height );
+		context.drawImage( msg.bitmap, 0, 0 );
+		msg.bitmap.close();
+		data.set( context.getImageData( 0, 0, width, height ).data, width * height * 4 * msg.index );
+		self.postMessage( { stream: 'ack', index: msg.index } );
+		return;
+
+	}
+
+	stream = null;
+	self.postMessage( { data: data.buffer, width, height, depth }, [ data.buffer ] );
+
+}
+
+async function processIntoShared( { shared, width, height, layers } ) {
+
+	if ( canvas.width !== width || canvas.height !== height ) {
+
+		canvas.width = width;
+		canvas.height = height;
+
+	}
+
+	ctx.imageSmoothingEnabled = true;
+	ctx.imageSmoothingQuality = 'high';
+
+	const data = new Uint8Array( shared );
+	const bytes = width * height * 4;
+
+	for ( const { index, texture } of layers ) {
+
+		try {
+
+			await processSingleTextureOptimized( texture, data, index * bytes, width, height );
+
+		} catch ( error ) {
+
+			console.warn( `Failed to process texture ${index}:`, error );
+			data.fill( 0, index * bytes, ( index + 1 ) * bytes );
+
+		}
+
+	}
+
+}
+
 self.onmessage = async function ( e ) {
 
+	if ( e.data.shared ) {
+
+		try {
+
+			if ( ! canvas ) initializeWorker( e.data.maxTextureSize );
+			await processIntoShared( e.data );
+			self.postMessage( { done: true } );
+
+		} catch ( error ) {
+
+			self.postMessage( { error: error.message } );
+
+		}
+
+		return;
+
+	}
+
+	if ( e.data.stream ) {
+
+		try {
+
+			handleStream( e.data );
+
+		} catch ( error ) {
+
+			self.postMessage( { error: error.message } );
+
+		}
+
+		return;
+
+	}
+
 	const { textures, maxTextureSize, method = 'direct-transfer' } = e.data;
 
 	try {
@@ -51,17 +148,6 @@ function initializeWorker( maxTextureSize ) {
 
 async function processTextures( textures, maxTextureSize, method ) {
 
-	// Check if we need to use chunked processing
-	const dimensions = calculateOptimalDimensions( textures, maxTextureSize );
-	const estimatedBytes = dimensions.maxWidth * dimensions.maxHeight * textures.length * 4;
-
-	if ( estimatedBytes > MEMORY_LIMITS.MAX_BYTES_PER_TEXTURE ) {
-
-		console.log( `Large texture array detected (${( estimatedBytes / 1024 / 1024 ).toFixed( 2 )}MB), using chunked processing` );
-		return await processTexturesInChunks( textures, maxTextureSize, method );
-
-	}
-
 	switch ( method ) {
 
 		case 'direct-transfer':

package/src/Stages/PathTracer.js

@@ -118,6 +118,7 @@ export class PathTracer extends PathTracerStage {
 		// so when one lands cannot change the image. { due, read, apply } while one is in flight.
 		this._lockstep = false;
 		this._lockstepRead = null;
+		this._accumulationLockstep = false;
 
 		// Tier-2: last settled active-pixel count (maxRays − frozen), sizes next frame's bounce-0 grid.
 		// 0 until a settled readback lands (and on reset/camera-move/resize) → grid stays full-size until then.
@@ -240,8 +241,8 @@ export class PathTracer extends PathTracerStage {
 		// Kernels not built yet (first frame / mid-resize) — skip until ready.
 		if ( ! this.isReady || ! this._wavefrontReady ) return;
 
-		// The packed light buffer was grow-reallocated at runtime (emissive set grew) —
-		// the compiled kernels still bind the old attribute, so rebuild before rendering.
+		// The packed light buffer was grow-reallocated at runtime (emissive set grew) or a light list grew —
+		// the compiled kernels still bind the old one, so rebuild before rendering.
 		if ( this._lightBufferRealloc ) {
 
 			if ( this._kernelManager ) this._kernelManager.dispose();
@@ -320,6 +321,7 @@ export class PathTracer extends PathTracerStage {
 		this.frame.value = frameValue;
 		this.seedFrame.value = this._seedTick ++;
 		this.tracedFrames ++;
+		if ( ! this._lockstep ) this._accumulationLockstep = false;
 
 		this._setWfDispatch();
 
@@ -661,6 +663,8 @@ export class PathTracer extends PathTracerStage {
 		this._convergedFraction = state.convergedFraction ?? 0;
 		this._convergedGeometryFraction = state.convergedGeometryFraction ?? 0;
 		this.isComplete = false;
+		// The survivor curve is not in a checkpoint, so a continuation is not the lockstep render.
+		this._accumulationLockstep = false;
 
 	}
 
@@ -711,6 +715,13 @@ export class PathTracer extends PathTracerStage {
 
 	}
 
+	/** Whether the current image was traced in lockstep from a reset made in it; with no sample yet, the setting. */
+	get accumulationLockstep() {
+
+		return this.frameCount > 0 ? this._accumulationLockstep : this._lockstep;
+
+	}
+
 	/**
 	 * While a lockstep readback is due and has not landed, render() traces nothing: await this
 	 * before the next frame. Null otherwise.

package/src/Stages/PathTracerStage.js

@@ -10,7 +10,7 @@ import { RenderStage, StageExecutionMode } from '../Pipeline/RenderStage.js';
 import { CameraOptimizer } from '../Processor/CameraOptimizer.js';
 import { createPerformanceMonitor, calculateAccumulationAlpha, updateCompletionThreshold } from '../Processor/utils.js';
 import { StorageTexturePool } from '../Processor/StorageTexturePool.js';
-import { UniformManager } from '../managers/UniformManager.js';
+import { UniformManager, LIGHT_FLOATS, lightListCapacity } from '../managers/UniformManager.js';
 import { MaterialDataManager } from '../managers/MaterialDataManager.js';
 import { EnvironmentManager } from '../managers/EnvironmentManager.js';
 import { ShaderBuilder } from '../Processor/ShaderBuilder.js';
@@ -218,8 +218,8 @@ export class PathTracerStage extends RenderStage {
 		// Initialized with dummy data so TSL compilation never sees null.
 		this.lightStorageAttr = new StorageInstancedBufferAttribute( new Float32Array( 16 ), 4 );
 		this.lightStorageNode = storage( this.lightStorageAttr, 'vec4', 1 ).toReadOnly();
-		// Set when _rebuildLightBuffer had to grow-reallocate the attribute: compiled
-		// kernels still bind the old one and must be rebuilt to see the new data.
+		// Set when _rebuildLightBuffer had to grow-reallocate the attribute, or a light list grew
+		// (_writeLightList): compiled kernels still bind the old one and must be rebuilt to see the new data.
 		this._lightBufferRealloc = false;
 
 		// Cached CPU-side data — rebuilt into the packed buffer whenever any source changes.
@@ -492,53 +492,36 @@ export class PathTracerStage extends RenderStage {
 	 */
 	_updateLightBufferNodes() {
 
-		// Directional lights (12 floats per light — 8 light fields + gobo {index, signed intensity, scale, pad})
-		if ( this.directionalLightsData && this.directionalLightsData.length > 0 ) {
+		this._writeLightList( 'directional', this.directionalLightsData, this.numDirectionalLights );
+		this._writeLightList( 'area', this.areaLightsData, this.numAreaLights );
+		this._writeLightList( 'point', this.pointLightsData, this.numPointLights );
+		this._writeLightList( 'spot', this.spotLightsData, this.numSpotLights );
 
-			this.directionalLightsBufferNode.array = Array.from( this.directionalLightsData );
-			this.numDirectionalLights.value = Math.floor( this.directionalLightsData.length / 12 );
-
-		} else {
-
-			this.numDirectionalLights.value = 0;
-
-		}
-
-		// Area lights (16 floats per light — 13 base + normalize/spread/shape)
-		if ( this.areaLightsData && this.areaLightsData.length > 0 ) {
-
-			this.areaLightsBufferNode.array = Array.from( this.areaLightsData );
-			this.numAreaLights.value = Math.floor( this.areaLightsData.length / 16 );
-
-		} else {
-
-			this.numAreaLights.value = 0;
+	}
 
-		}
+	/**
+	 * In place, because the shader bakes the list's length: sized per scene it compiled a program per
+	 * light count, and three.js uploads only what fits the length it was built with, so a light added
+	 * after a build was dropped. A list grows only past its capacity, and that rebuilds the kernels.
+	 * @private
+	 */
+	_writeLightList( type, data, count ) {
 
-		// Point lights (9 floats per light)
-		if ( this.pointLightsData && this.pointLightsData.length > 0 ) {
+		const floats = LIGHT_FLOATS[ type ];
+		const node = this[ `${type}LightsBufferNode` ];
+		const lights = data ? Math.floor( data.length / floats ) : 0;
+		const used = lights * floats;
 
-			this.pointLightsBufferNode.array = Array.from( this.pointLightsData );
-			this.numPointLights.value = Math.floor( this.pointLightsData.length / 9 );
+		if ( used > node.array.length ) {
 
-		} else {
-
-			this.numPointLights.value = 0;
+			node.array = new Float32Array( lightListCapacity( type, lights ) * floats );
+			this._lightBufferRealloc = true;
 
 		}
 
-		// Spot lights (20 floats per light — 14 light fields + gobo {idx, signed intensity} + IES {idx, intensity} + 2 reserved)
-		if ( this.spotLightsData && this.spotLightsData.length > 0 ) {
-
-			this.spotLightsBufferNode.array = Array.from( this.spotLightsData );
-			this.numSpotLights.value = Math.floor( this.spotLightsData.length / 20 );
-
-		} else {
-
-			this.numSpotLights.value = 0;
-
-		}
+		if ( used > 0 ) node.array.set( data.subarray( 0, used ) );
+		node.array.fill( 0, used );
+		count.value = lights;
 
 	}
 
@@ -565,6 +548,7 @@ export class PathTracerStage extends RenderStage {
 
 		// Only deterministic mode and lockstep readbacks rewind the seed axis; see _pinSeedToFrame.
 		if ( this._pinSeedToFrame || this._lockstep ) this._seedTick = 0;
+		this._accumulationLockstep = !! this._lockstep;
 
 	}
 
@@ -1102,17 +1086,34 @@ export class PathTracerStage extends RenderStage {
 
 	}
 
-	/** Update BVH node data in the existing GPU buffer (full). */
-	updateBVHData( bvhData ) {
+	/**
+	 * Update BVH node data in the existing GPU buffer.
+	 * @param {Object} [bvhData]
+	 * @param {Array<{offset:number,count:number}>} [ranges] - only these, in floats; every node when omitted
+	 */
+	updateBVHData( bvhData, ranges ) {
 
 		if ( this._bvhRecords ) {
 
-			uploadStorageChunks( this.renderer, this.bvhStorageAttr, this._bvhRecords.chunks );
+			if ( bvhData?.chunks?.length > 1 ) this._bvhRecords = bvhData;
+			if ( ranges ) this.updateBufferRanges( [], ranges );
+			else uploadStorageChunks( this.renderer, this.bvhStorageAttr, this._bvhRecords.chunks );
+			return;
+
+		}
+
+		const flat = bvhData?.chunks ? bvhData.chunks[ 0 ] : bvhData;
+		if ( ! ranges ) {
+
+			this._updateStorageBuffer( this.bvhStorageAttr, flat );
 			return;
 
 		}
 
-		this._updateStorageBuffer( this.bvhStorageAttr, bvhData?.chunks ? bvhData.chunks[ 0 ] : bvhData );
+		// The attribute keeps its own array once the refit has moved the nodes into shared memory.
+		const own = this.bvhStorageAttr?.array;
+		if ( flat && own && flat !== own ) for ( const r of ranges ) own.set( flat.subarray( r.offset, r.offset + r.count ), r.offset );
+		this.updateBufferRanges( [], ranges );
 
 	}
 
@@ -1271,6 +1272,7 @@ export class PathTracerStage extends RenderStage {
 
 			this.createStorageTextures( width, height );
 			this.frameCount = 0;
+			this._accumulationLockstep = false;
 
 		}
 

package/src/Storage/StorageManager.js

@@ -17,6 +17,8 @@ const MAX_DEFAULT_BUDGET = 100 * 1024 ** 3;
 const FREE_MARGIN = 64 * 1024 ** 2;
 const STREAM_BATCH = 8 * 1024 ** 2;
 const STREAM_WINDOW = 4;
+// Other tabs write too, so the cache total kept in memory is listed again at most this often.
+const CACHE_TOTAL_TTL_MS = 30_000;
 
 const encoder = new TextEncoder();
 
@@ -152,6 +154,7 @@ export class EntryWriter {
 		this._sizes = { ...sizes };
 		this._append = append;
 		this._done = false;
+		this._committedBytes = append ? Object.values( sizes ).reduce( ( n, b ) => n + b, 0 ) : 0;
 
 	}
 
@@ -313,6 +316,7 @@ export class EntryWriter {
 
 			const { args, list } = transferable( JSON.stringify( meta ), { copy: false } );
 			await this._transport.call( 'writeFile', { path: this._path, name: META, ...args }, list );
+			if ( this.area.kind === STORAGE_KIND.CACHE ) this.area.manager._countCacheBytes( meta.bytes - this._committedBytes );
 			this.area.manager._changed( this.area.name );
 			return meta;
 
@@ -700,6 +704,7 @@ export class StorageManager extends Emitter {
 		this._transport = transport;
 		this._areas = new Map();
 		this._budget = null;
+		this._cacheTotal = null;
 
 		for ( const name of Object.values( ENGINE_AREAS ) ) this.defineArea( name, { kind: name === ENGINE_AREAS.SPILL ? STORAGE_KIND.SCRATCH : STORAGE_KIND.CACHE } );
 
@@ -775,6 +780,40 @@ export class StorageManager extends Emitter {
 
 	}
 
+	/**
+	 * What cache areas hold together. Every new download asks, and a listing reads every entry's
+	 * metadata, so it is listed once and kept current by this manager's own commits.
+	 */
+	async _cacheBytes() {
+
+		let total = this._cacheTotal;
+		if ( ! total || Date.now() - total.at > CACHE_TOTAL_TTL_MS ) {
+
+			total = this._cacheTotal = { at: Date.now(), bytes: 0, ready: null };
+			total.ready = this._cacheEntries().then( ( entries ) => {
+
+				total.bytes += entries.reduce( ( n, e ) => n + ( e.meta.bytes ?? 0 ), 0 );
+
+			} );
+			total.ready.catch( () => {
+
+				if ( this._cacheTotal === total ) this._cacheTotal = null;
+
+			} );
+
+		}
+
+		await total.ready;
+		return total.bytes;
+
+	}
+
+	_countCacheBytes( bytes ) {
+
+		if ( this._cacheTotal ) this._cacheTotal.bytes += bytes;
+
+	}
+
 	async _cacheEntries() {
 
 		const out = [];
@@ -816,8 +855,8 @@ export class StorageManager extends Emitter {
 
 		const entries = await this._cacheEntries();
 		const budget = await this.budget();
-		let cacheBytes = entries.reduce( ( n, e ) => n + ( e.meta.bytes ?? 0 ), 0 );
-		const target = freeBytes ?? Math.max( 0, cacheBytes - budget );
+		const total = this._cacheTotal = { at: Date.now(), bytes: entries.reduce( ( n, e ) => n + ( e.meta.bytes ?? 0 ), 0 ), ready: null };
+		const target = freeBytes ?? Math.max( 0, total.bytes - budget );
 		if ( target <= 0 ) return 0;
 
 		const held = await heldLockNames();
@@ -832,7 +871,7 @@ export class StorageManager extends Emitter {
 			if ( await area.removeById( meta.id ) ) {
 
 				freed += meta.bytes ?? 0;
-				cacheBytes -= meta.bytes ?? 0;
+				total.bytes -= meta.bytes ?? 0;
 
 			}
 
@@ -855,8 +894,7 @@ export class StorageManager extends Emitter {
 			const free = bytes + FREE_MARGIN - ( quota - usage );
 			if ( kind !== STORAGE_KIND.CACHE ) return { free, budget: 0 };
 
-			const cacheBytes = ( await this._cacheEntries() ).reduce( ( n, e ) => n + ( e.meta.bytes ?? 0 ), 0 );
-			return { free, budget: cacheBytes + bytes - await this.budget() };
+			return { free, budget: await this._cacheBytes() + bytes - await this.budget() };
 
 		};
 

package/src/managers/AnimationManager.js

@@ -10,6 +10,23 @@
 import { AnimationMixer, EventDispatcher, Timer, Vector3, LoopRepeat, LoopOnce, PropertyBinding } from 'three';
 import { EngineEvents } from '../EngineEvents.js';
 
+/** The nodes of `nodes` with no ancestor in it, or null when updating each would cost more than one pass over `root`. */
+function subtreeRoots( nodes, root ) {
+
+	const roots = [ ...nodes ].filter( node => {
+
+		for ( let o = node.parent; o; o = o.parent ) if ( nodes.has( o ) ) return false;
+		return true;
+
+	} );
+
+	let total = 0, covered = 0;
+	root.traverse?.( () => total ++ );
+	for ( const node of roots ) node.traverse?.( () => covered ++ );
+	return covered + roots.length / 2 < total ? roots : null;
+
+}
+
 export class AnimationManager extends EventDispatcher {
 
 	constructor() {
@@ -162,11 +179,19 @@ export class AnimationManager extends EventDispatcher {
 
 			const animated = new Set();
 			let visibility = false;
+			let unresolved = false;
 			for ( const track of clip.tracks ) {
 
 				const { nodeName, propertyName } = PropertyBinding.parseTrackName( track.name );
-				const node = byName.get( nodeName );
-				if ( ! node ) continue;
+				// As PropertyBinding.findNode: no node name binds the root itself.
+				const node = nodeName === '' || nodeName === '.' ? root : byName.get( nodeName );
+				if ( ! node ) {
+
+					unresolved = true;
+					continue;
+
+				}
+
 				animated.add( node );
 				if ( propertyName === 'visible' ) visibility = true;
 
@@ -191,7 +216,7 @@ export class AnimationManager extends EventDispatcher {
 			const cameras = new Set();
 			for ( const node of animated ) node.traverse( o => o.isCamera && cameras.add( o ) );
 
-			return { meshes: Int32Array.from( meshes ), visibility, cameras: [ ...cameras ] };
+			return { meshes: Int32Array.from( meshes ), visibility, cameras: [ ...cameras ], nodes: unresolved ? null : animated, roots: unresolved ? null : subtreeRoots( animated, root ) };
 
 		} );
 
@@ -218,15 +243,18 @@ export class AnimationManager extends EventDispatcher {
 
 			const meshes = new Set(), cameras = new Set();
 			let visibility = false;
+			let nodes = new Set();
 			for ( const plan of this._plans ) {
 
 				plan.meshes.forEach( m => meshes.add( m ) );
 				plan.cameras.forEach( c => cameras.add( c ) );
 				visibility ||= plan.visibility;
+				if ( nodes && plan.nodes ) plan.nodes.forEach( n => nodes.add( n ) );
+				else nodes = null;
 
 			}
 
-			this._allPlan = { meshes: Int32Array.from( meshes ), visibility, cameras: [ ...cameras ] };
+			this._allPlan = { meshes: Int32Array.from( meshes ), visibility, cameras: [ ...cameras ], nodes, roots: nodes ? subtreeRoots( nodes, this._mixerRoot ) : null };
 
 		}
 
@@ -491,7 +519,10 @@ export class AnimationManager extends EventDispatcher {
 
 		// Bones live outside mesh subtrees so per-mesh updateMatrixWorld() misses them. Doing it
 		// once here, on mixerRoot rather than the scene, keeps unrelated static objects out of it.
-		this._mixerRoot.updateMatrixWorld( true );
+		// A rigid clip moves only what its tracks name, so only those subtrees are updated.
+		const roots = this._rigid ? this._planFor( this._activeClip )?.roots : null;
+		if ( roots ) for ( const node of roots ) node.updateMatrixWorld( true );
+		else this._mixerRoot.updateMatrixWorld( true );
 
 		if ( this._rigid ) {
 

package/src/managers/GoboManager.js

@@ -71,6 +71,7 @@ export class GoboManager {
 		cnv.width = width;
 		cnv.height = height;
 		const ctx = cnv.getContext( '2d', { willReadFrequently: true } );
+		let lastYield = performance.now();
 
 		for ( let i = 0; i < depth; i ++ ) {
 
@@ -79,6 +80,14 @@ export class GoboManager {
 			const img = ctx.getImageData( 0, 0, width, height );
 			data.set( img.data, i * width * height * 4 );
 
+			// Each first draw decodes its image, so the library packs in short tasks.
+			if ( performance.now() - lastYield > 16 ) {
+
+				await new Promise( resolve => setTimeout( resolve, 0 ) );
+				lastYield = performance.now();
+
+			}
+
 		}
 
 		const tex = new DataArrayTexture( data, width, height, depth );

package/src/managers/UniformManager.js

@@ -19,6 +19,31 @@ const SHADER_NAMES = {
 	cameraProjectionMatrix: 'ptCameraProjectionMatrix',
 };
 
+/** Floats per light in each type's list (see LightSerializer). */
+export const LIGHT_FLOATS = Object.freeze( {
+	directional: 12, // 8 light fields + gobo { index, signed intensity, scale, pad }
+	area: 16, // 13 base + normalize, spread, shape
+	point: 9,
+	spot: 20, // 14 light fields + gobo { index, signed intensity } + IES { index, intensity } + 2 reserved
+} );
+
+/** Lights a list holds before it has to grow. */
+export const LIGHT_LIST_STEP = 16;
+
+// A uniform array gives each float its own vec4; WebGPU guarantees 64 KiB a binding.
+const MAX_UNIFORM_ELEMENTS = 65536 / 16;
+
+/**
+ * Lights a list of this type must hold for `lights`: a whole number of steps, but never past what
+ * fits a binding unless `lights` alone already does — a count that did not fit never did.
+ */
+export function lightListCapacity( type, lights ) {
+
+	const stepped = Math.ceil( lights / LIGHT_LIST_STEP ) * LIGHT_LIST_STEP;
+	return Math.max( lights, Math.min( stepped, Math.floor( MAX_UNIFORM_ELEMENTS / LIGHT_FLOATS[ type ] ) ) );
+
+}
+
 export class UniformManager {
 
 	constructor( width = 1920, height = 1080 ) {
@@ -266,13 +291,11 @@ export class UniformManager {
 		u( 'numPointLights', 0, 'int' );
 		u( 'numSpotLights', 0, 'int' );
 
-		// Light buffer nodes - pre-allocate for up to 16 lights per type (shader hard cap)
-		this._lightBuffers = {
-			directional: uniformArray( new Float32Array( 12 * 16 ), 'float' ),
-			area: uniformArray( new Float32Array( 16 * 16 ), 'float' ),
-			point: uniformArray( new Float32Array( 9 * 16 ), 'float' ),
-			spot: uniformArray( new Float32Array( 20 * 16 ), 'float' ),
-		};
+		// The shader bakes each list's length, so lights are written into these in place and a list is
+		// only replaced when a scene has more lights than it holds (PathTracerStage._writeLightList).
+		this._lightBuffers = Object.fromEntries( Object.entries( LIGHT_FLOATS ).map(
+			( [ type, floats ] ) => [ type, uniformArray( new Float32Array( floats * LIGHT_LIST_STEP ), 'float' ) ]
+		) );
 
 		// Camera matrices
 		u( 'cameraWorldMatrix', new Matrix4(), 'mat4' );