rayzee 9.1.1 → 9.2.0

package/src/Platform.js

@@ -0,0 +1,76 @@
+/**
+ * What the engine needs from its host that a browser provides by itself. A browser host configures
+ * nothing. A host without one (Node, Deno) supplies each service here rather than patching globals,
+ * so a new browser dependency shows up as a missing service instead of a ReferenceError.
+ *
+ *   import { configurePlatform } from 'rayzee';
+ *   import { nodePlatform } from 'rayzee/node';
+ *   configurePlatform( nodePlatform( { decodeImage } ) );   // { Worker: NodeWorker, decodeImage }
+ *
+ * Call before constructing PathTracerApp.
+ */
+
+const platform = {
+	/** A class with the Web Worker API. The engine's bundled workers start through it. */
+	Worker: null,
+	/**
+	 * `( bytes: Uint8Array, mimeType: string ) => Promise<{ data: Uint8Array | Uint8ClampedArray, width, height }>`:
+	 * an image a model carries (PNG, JPEG, WebP) to RGBA8 pixels, top row first. Where set, it decodes
+	 * every glTF image in place of the browser.
+	 */
+	decodeImage: null,
+};
+
+/** @param {Partial<typeof platform>} overrides - only the keys given are replaced */
+export function configurePlatform( overrides ) {
+
+	if ( overrides ) Object.assign( platform, overrides );
+
+}
+
+export function getPlatform() {
+
+	return platform;
+
+}
+
+/** Logical cores, as the browser reports them; 4 where nothing does. */
+export function hardwareThreads() {
+
+	return ( typeof navigator !== 'undefined' && navigator.hardwareConcurrency ) || 4;
+
+}
+
+/** Whether a worker can be started at all: the browser's or the host's. */
+export function hasWorkers() {
+
+	return !! platform.Worker || typeof Worker !== 'undefined';
+
+}
+
+/**
+ * Starts one of the engine's bundled workers. Their bundled constructors call the global `Worker`
+ * themselves, so the host's class stands in for it while one is constructed.
+ * @param {new ( options?: Object ) => Worker} WorkerClass
+ */
+export function createWorker( WorkerClass, options ) {
+
+	const Host = platform.Worker;
+	if ( ! Host ) return new WorkerClass( options );
+
+	const had = Object.prototype.hasOwnProperty.call( globalThis, 'Worker' );
+	const previous = globalThis.Worker;
+	globalThis.Worker = Host;
+
+	try {
+
+		return new WorkerClass( options );
+
+	} finally {
+
+		if ( had ) globalThis.Worker = previous;
+		else delete globalThis.Worker;
+
+	}
+
+}

package/src/Processor/AssetLoader.js

@@ -25,6 +25,8 @@ import { VERSION } from '../version.js';
 import { disposeEngineOwnedResources, disposeObjectFromMemory, updateLoading } from './utils';
 import { BuildTimer } from './BuildTimer.js';
 import { getAssetConfig } from '../AssetConfig.js';
+import { getPlatform } from '../Platform.js';
+import { loadPlatformImage, platformImagesPlugin } from './PlatformImageLoader.js';
 import { loadPBRTScene, pickEntryPath, VirtualFS, PBRT_BUILD_REVISION } from './PBRT/index.js';
 import { extractSceneMetadata } from './SceneMetadata.js';
 import { ISSUE_CODES, ISSUE_SEVERITY } from '../EngineIssues.js';
@@ -627,6 +629,11 @@ export class AssetLoader extends EventDispatcher {
 					: ( this.loaderCache.exr || ( this.loaderCache.exr = new EXRLoader( this._loadingManager ).setDataType( FloatType ) ) );
 				texture = await loader.loadAsync( source.url, onProgress );
 
+			} else if ( getPlatform().decodeImage ) {
+
+				texture = await loadPlatformImage( source.url, `image/${extension === 'jpg' ? 'jpeg' : extension}` );
+				texture.colorSpace = SRGBColorSpace;
+
 			} else {
 
 				if ( ! this.loaderCache.texture ) this.loaderCache.texture = new TextureLoader( this._loadingManager );
@@ -1578,6 +1585,17 @@ export class AssetLoader extends EventDispatcher {
 					loader.parse( gltfContent, '',
 						gltf => {
 
+							try {
+
+								this._throwDeferred();
+
+							} catch ( error ) {
+
+								reject( error );
+								return;
+
+							}
+
 							this.releaseTargetModel();
 							this.targetModel = gltf.scene;
 							this.sceneMetadata = extractSceneMetadata( gltf );
@@ -1889,11 +1907,40 @@ export class AssetLoader extends EventDispatcher {
 		loader.setDRACOLoader( dracoLoader );
 		loader.setKTX2Loader( ktx2Loader );
 		loader.setMeshoptDecoder( MeshoptDecoder );
+		if ( getPlatform().decodeImage ) loader.register( ( parser ) => platformImagesPlugin( parser, ( where, error ) => this._reportImageFailure( where, error ) ) );
 
 		return loader;
 
 	}
 
+	// GLTFLoader swallows the failure and loads the model untextured, so a strict host's throw is kept
+	// for the end of the load (_throwDeferred).
+	_reportImageFailure( where, error ) {
+
+		try {
+
+			this._issues?.record(
+				ISSUE_CODES.TEXTURE_BUILD_FAILED,
+				`image ${where} could not be decoded — the surfaces using it render untextured`,
+				{ image: where, cause: String( error?.message ?? error ) }
+			);
+
+		} catch ( strictError ) {
+
+			this._deferredError ??= strictError;
+
+		}
+
+	}
+
+	_throwDeferred() {
+
+		const error = this._deferredError;
+		this._deferredError = null;
+		if ( error ) throw error;
+
+	}
+
 	_disposeGLTFLoader( loader ) {
 
 		if ( ! loader ) return;
@@ -1934,6 +1981,7 @@ export class AssetLoader extends EventDispatcher {
 			if ( source.cached ) loader.setResourcePath( LoaderUtils.extractUrlBase( modelUrl ) );
 			const data = await loader.loadAsync( source.url, source.cached ? undefined : this._downloadProgress( "Downloading Model...", cancelable ) );
 			this._downloadComplete();
+			this._throwDeferred();
 
 			this.releaseTargetModel();
 			this._sourceKey = cancelable ? this._keyed( 'url', options.cacheKey ?? modelUrl ) : null;
@@ -1996,6 +2044,7 @@ export class AssetLoader extends EventDispatcher {
 			if ( source.cached ) loader.setResourcePath( LoaderUtils.extractUrlBase( url ) );
 			const data = await loader.loadAsync( source.url, source.cached ? undefined : this._downloadProgress( "Downloading Model...", cancelable ) );
 			this._downloadComplete();
+			this._throwDeferred();
 			this._appended = true;
 			this._processAndParent( data.scene );
 			return { root: data.scene, animations: data.animations || [] };
@@ -2055,6 +2104,7 @@ export class AssetLoader extends EventDispatcher {
 			await new Promise( r => setTimeout( r, 0 ) );
 
 			const data = await loader.parseAsync( arrayBuffer, '' );
+			this._throwDeferred();
 
 			this.releaseTargetModel();
 
@@ -2520,6 +2570,7 @@ export class AssetLoader extends EventDispatcher {
 		// Split after the walk: traverse() caches children.length, so splitting in place
 		// shifts later siblings down a slot and skips one.
 		const multiMaterialMeshes = [];
+		const skippedPlaceholders = [];
 		model.traverse( ( object ) => {
 
 			const userData = object.userData;
@@ -2551,11 +2602,12 @@ export class AssetLoader extends EventDispatcher {
 
 			}
 
+			const placeholder = object.name.startsWith( 'RectAreaLightPlaceholder' );
+			if ( placeholder && ! ( userData.name && userData.type === 'RectAreaLight' )
+				&& ! object.parent?.name?.startsWith( 'RectAreaLightPlaceholder' ) ) skippedPlaceholders.push( object.name );
+
 			// Process ceiling lights
-			if ( object.name.startsWith( 'RectAreaLightPlaceholder' ) &&
-				userData.name
-				// && userData.name.includes( "ceilingLight" )
-			) {
+			if ( placeholder && userData.name ) {
 
 				if ( userData.type === 'RectAreaLight' ) {
 
@@ -2588,6 +2640,16 @@ export class AssetLoader extends EventDispatcher {
 
 		} );
 
+		if ( skippedPlaceholders.length ) {
+
+			this._issues?.record(
+				ISSUE_CODES.LIGHT_PLACEHOLDER_SKIPPED,
+				`${skippedPlaceholders.length} area-light placeholder(s) lack userData.name or userData.type 'RectAreaLight' — no light was made for them`,
+				{ count: skippedPlaceholders.length, names: skippedPlaceholders.slice( 0, 10 ) }
+			);
+
+		}
+
 		const shared = model.userData.__rayzeeExternal === true;
 
 		for ( const object of multiMaterialMeshes ) {

package/src/Processor/BVHBuilder.js

@@ -3,6 +3,7 @@ import { ReinsertionOptimizer } from './ReinsertionOptimizer.js';
 // Logger is worker-safe (globalThis only, storage access guarded), unlike Constants.js below.
 import { createLogger, fmt } from '../utils/Logger.js';
 import { foldLeaves } from './BVHLeafFold.js';
+import { hasWorkers } from '../Platform.js';
 
 const log = createLogger( 'bvh' );
 
@@ -423,7 +424,7 @@ export class BVHBuilder {
 		this.processedTriangles = 0;
 		this.lastProgressUpdate = performance.now();
 
-		if ( this.useWorker && createBVHWorker && typeof Worker !== 'undefined' ) {
+		if ( this.useWorker && createBVHWorker && hasWorkers() ) {
 
 			return new Promise( ( resolve, reject ) => {
 

package/src/Processor/EquirectHDRInfo.js

@@ -1,5 +1,6 @@
 import { DataUtils, HalfFloatType, FloatType, SRGBColorSpace } from 'three';
 import CDFWorker from './Workers/CDFWorker.js?worker&inline';
+import { createWorker } from '../Platform.js';
 
 /**
  * Binary search to find the closest index
@@ -222,7 +223,7 @@ export class EquirectHDRInfo {
 		const { floatData, width, height } = extractFloatData( hdr );
 
 		// Fresh worker per call — terminated in finally to avoid ~30 MB residency.
-		this._worker = new CDFWorker();
+		this._worker = createWorker( CDFWorker );
 
 		try {
 

package/src/Processor/HostMemory.js

@@ -59,6 +59,20 @@ export const SAFE_SCENE_BYTES = 7040 * 1024 * 1024;
  */
 export const MAX_SCENE_BYTES = 9216 * 1024 * 1024;
 
+/**
+ * The host's memory in GB: the host's own figure when it gives one, else Chrome's
+ * `navigator.deviceMemory`, else an assumed 4 (every other runtime lacks it).
+ * @param {number} [stated]
+ * @returns {{gb: number, assumed: boolean}}
+ */
+export function deviceMemoryGB( stated ) {
+
+	if ( stated > 0 ) return { gb: stated, assumed: false };
+	const reported = typeof navigator !== 'undefined' ? navigator.deviceMemory : undefined;
+	return reported > 0 ? { gb: reported, assumed: false } : { gb: 4, assumed: true };
+
+}
+
 /** Headroom a single build step wants over its own size before it is called safe. */
 export const PREFLIGHT_SAFETY = 1.15;
 

package/src/Processor/IESParser.js

@@ -302,9 +302,8 @@ function tokenize( text ) {
 function remainderAfterTokens( text, count ) {
 
 	const re = /\S+/g;
-	let m;
 	let n = 0;
-	while ( ( m = re.exec( text ) ) !== null ) {
+	while ( re.exec( text ) !== null ) {
 
 		n ++;
 		if ( n === count ) return text.slice( re.lastIndex );

package/src/Processor/PBRT/PBRTSceneBuilder.js

@@ -211,6 +211,18 @@ export class PBRTSceneBuilder {
 		// Built again for their moving placements after the static ones, so never freed early.
 		this._keepShapes = new Set();
 		for ( const { name } of ir.animatedInstances ?? [] ) for ( const shape of ir.objects.get( name ) ?? [] ) this._keepShapes.add( shape );
+		// One decoded .ply serves every shape naming it: a merge frees it only as its last direct
+		// user, and never while a template or an unmerged shape holds its geometry.
+		this._plyUsers = new Map();
+		this._plyHeld = new Set();
+		for ( const shape of ir.shapes ) if ( shape?.type === 'plymesh' ) {
+
+			const file = pString( shape.params, 'filename', null );
+			this._plyUsers.set( file, ( this._plyUsers.get( file ) ?? 0 ) + 1 );
+
+		}
+
+		for ( const template of ir.objects.values() ) for ( const shape of template ) if ( shape.type === 'plymesh' ) this._plyHeld.add( pString( shape.params, 'filename', null ) );
 		this._recoveredColors = 0;
 		this.reportedMeshes = 0;
 		this.triangleCount = 0; // stored triangles — a shared geometry counts once
@@ -252,6 +264,8 @@ export class PBRTSceneBuilder {
 
 			}
 
+			if ( shape.type === 'plymesh' ) this._plyHeld.add( pString( shape.params, 'filename', null ) );
+
 			const mesh = this._meshFromGeometry( shape, geometry, sharedMaterial, shape.ctm, `shape_${i}` );
 			if ( ! mesh ) continue;
 			group.add( mesh );
@@ -759,12 +773,24 @@ export class PBRTSceneBuilder {
 	_releaseMerged( shape, geometry ) {
 
 		if ( this._keepShapes?.has( shape ) ) return;
+		if ( shape.type === 'plymesh' && ! this._lastPlyUse( pString( shape.params, 'filename', null ) ) ) return;
 		for ( const name in geometry.attributes ) freeNow( geometry.attributes[ name ].array );
 		freeNow( geometry.index?.array );
 		for ( const name in shape.params ) if ( ArrayBuffer.isView( shape.params[ name ]?.value ) ) freeNow( shape.params[ name ].value );
 
 	}
 
+	/** Whether this merge was the last use of a .ply, which then leaves the cache. @private */
+	_lastPlyUse( file ) {
+
+		const left = ( this._plyUsers.get( file ) ?? 1 ) - 1;
+		this._plyUsers.set( file, left );
+		if ( left > 0 || this._plyHeld.has( file ) ) return false;
+		this._plyCache.delete( file );
+		return true;
+
+	}
+
 	/**
 	 * Copy one shape's triangles, moved by `transform`, into the batch for its material.
 	 * @returns {object|null} the batch, taken out of `batches`, once it is full

package/src/Processor/ParallelBVHBuilder.js

@@ -11,8 +11,9 @@ import BVHWorker from './Workers/BVHWorker.js?worker&inline';
 import BVHSubtreeWorker from './Workers/BVHSubtreeWorker.js?worker&inline';
 import { setBVHWorkerFactory } from './BVHBuilder.js';
 import { createLogger, fmt } from '../utils/Logger.js';
+import { createWorker, hardwareThreads, hasWorkers } from '../Platform.js';
 
-setBVHWorkerFactory( () => new BVHWorker() );
+setBVHWorkerFactory( () => createWorker( BVHWorker ) );
 
 const log = createLogger( 'bvh' );
 
@@ -38,7 +39,7 @@ const MAX_PARALLEL_WORKERS = 8;
 export function buildBVHParallel( triangles, depth, progressCallback, config ) {
 
 	const triangleCount = triangles.byteLength / ( FPT * 4 );
-	const numWorkers = Math.min( navigator.hardwareConcurrency || 4, MAX_PARALLEL_WORKERS );
+	const numWorkers = Math.min( hardwareThreads(), MAX_PARALLEL_WORKERS );
 	const parallelDepth = Math.ceil( Math.log2( numWorkers * 2.5 + 1 ) );
 
 	log.debug( `parallel build ${fmt.n( triangleCount )} triangles · ${numWorkers} workers · parallelDepth ${parallelDepth}` );
@@ -63,7 +64,7 @@ export function buildBVHParallel( triangles, depth, progressCallback, config ) {
 			const sharedReorderBuffer = null;
 
 			// Phase 1: Coordinator worker
-			const coordinatorWorker = new BVHWorker();
+			const coordinatorWorker = createWorker( BVHWorker );
 
 			let phase1Stats = null;
 			const allWorkers = [ coordinatorWorker ];
@@ -326,7 +327,7 @@ async function handlePhase2(
 		const bucket = workerTaskBuckets[ w ];
 		if ( bucket.length === 0 ) continue;
 
-		const subtreeWorker = new BVHSubtreeWorker();
+		const subtreeWorker = createWorker( BVHSubtreeWorker );
 
 		allWorkers.push( subtreeWorker );
 
@@ -431,7 +432,7 @@ function buildSingleWorker( triangles, depth, progressCallback, config ) {
 
 		( async () => {
 
-			const worker = new BVHWorker();
+			const worker = createWorker( BVHWorker );
 
 			const triangleCount = triangles.byteLength / ( FPT * 4 );
 			const useShared = typeof SharedArrayBuffer !== 'undefined';
@@ -506,7 +507,7 @@ function buildSingleWorker( triangles, depth, progressCallback, config ) {
  */
 export function shouldUseParallelBuild( triangleCount ) {
 
-	return typeof Worker !== 'undefined'
+	return hasWorkers()
 		&& typeof SharedArrayBuffer !== 'undefined'
 		&& triangleCount >= PARALLEL_THRESHOLD;
 

package/src/Processor/PlatformImageLoader.js

@@ -0,0 +1,118 @@
+import { DataTexture, LoaderUtils, RGBAFormat, UnsignedByteType } from 'three';
+import { getPlatform } from '../Platform.js';
+
+const MIME_BY_EXTENSION = [[ /\.jpe?g(\?|#|$)/i, 'image/jpeg' ], [ /\.webp(\?|#|$)/i, 'image/webp' ], [ /\.avif(\?|#|$)/i, 'image/avif' ]];
+
+function mimeTypeOf( def ) {
+
+	if ( def.mimeType ) return def.mimeType;
+	if ( def.uri?.startsWith( 'data:' ) ) return def.uri.slice( 5, def.uri.indexOf( ';' ) );
+	return MIME_BY_EXTENSION.find( ( [ pattern ] ) => pattern.test( def.uri ?? '' ) )?.[ 1 ] ?? 'image/png';
+
+}
+
+// Browsers ignore bytes after IEND and exporters leave them there; strict decoders reject the file.
+function trimPNG( bytes ) {
+
+	for ( let i = 8; i + 12 <= bytes.length; ) {
+
+		const length = ( ( bytes[ i ] << 24 ) | ( bytes[ i + 1 ] << 16 ) | ( bytes[ i + 2 ] << 8 ) | bytes[ i + 3 ] ) >>> 0;
+		const end = i + 12 + length;
+		if ( bytes[ i + 4 ] === 0x49 && bytes[ i + 5 ] === 0x45 && bytes[ i + 6 ] === 0x4E && bytes[ i + 7 ] === 0x44 ) return bytes.subarray( 0, end );
+		i = end;
+
+	}
+
+	return bytes;
+
+}
+
+// A model's images go to the texture pack worker, which reads a SharedArrayBuffer where they lie.
+function pixelTexture( { data, width, height }, { shared = false } = {} ) {
+
+	const view = new Uint8Array( data.buffer, data.byteOffset, width * height * 4 );
+	let pixels = view;
+	if ( shared && typeof SharedArrayBuffer !== 'undefined' && ! ( view.buffer instanceof SharedArrayBuffer ) ) {
+
+		pixels = new Uint8Array( new SharedArrayBuffer( view.byteLength ) );
+		pixels.set( view );
+
+	}
+
+	const texture = new DataTexture( pixels, width, height, RGBAFormat, UnsignedByteType );
+	texture.needsUpdate = true;
+	return texture;
+
+}
+
+function decodeBytes( bytes, mimeType ) {
+
+	return getPlatform().decodeImage( mimeType === 'image/png' ? trimPNG( bytes ) : bytes, mimeType );
+
+}
+
+async function fetchBytes( url ) {
+
+	const response = await fetch( url );
+	if ( ! response.ok ) throw new Error( `HTTP ${response.status}` );
+	return new Uint8Array( await response.arrayBuffer() );
+
+}
+
+/**
+ * An image file as a texture, decoded by the platform: the counterpart of TextureLoader for hosts
+ * with no DOM. Rows stay top first with `flipY` on, exactly as TextureLoader leaves an image.
+ */
+export async function loadPlatformImage( url, mimeType = mimeTypeOf( { uri: url } ) ) {
+
+	const texture = pixelTexture( await decodeBytes( await fetchBytes( url ), mimeType ) );
+	texture.flipY = true;
+	return texture;
+
+}
+
+/**
+ * A GLTFLoader plugin for hosts with the platform's `decodeImage`: every image of the model, embedded
+ * or not, is decoded by the host and becomes a DataTexture of its pixels, which the texture packer
+ * copies without a canvas. three.js would otherwise need the DOM or createImageBitmap, and `self.URL`
+ * for the blob URL it makes of an embedded image.
+ *
+ * GLTFLoader turns a texture that fails into no texture at all, silently; `onFailure( where, error )`
+ * is how that is heard.
+ */
+export function platformImagesPlugin( parser, onFailure = null ) {
+
+	parser.loadImageSource = function ( sourceIndex ) {
+
+		if ( this.sourceCache[ sourceIndex ] !== undefined ) return this.sourceCache[ sourceIndex ].then( ( texture ) => texture.clone() );
+
+		const def = this.json.images[ sourceIndex ];
+		const mimeType = mimeTypeOf( def );
+		const where = def.uri ?? `bufferView ${def.bufferView}`;
+
+		const bytes = def.bufferView !== undefined
+			? this.getDependency( 'bufferView', def.bufferView ).then( ( buffer ) => new Uint8Array( buffer ) )
+			: fetchBytes( this.options.manager.resolveURL( LoaderUtils.resolveURL( def.uri, this.options.path ) ) );
+
+		const promise = bytes.then( ( data ) => decodeBytes( data, mimeType ) ).then( ( pixels ) => {
+
+			const texture = pixelTexture( pixels, { shared: true } );
+			if ( def.extras && typeof def.extras === 'object' ) Object.assign( texture.userData, def.extras );
+			texture.userData.mimeType = mimeType;
+			return texture;
+
+		} ).catch( ( error ) => {
+
+			onFailure?.( where, error );
+			throw error;
+
+		} );
+
+		this.sourceCache[ sourceIndex ] = promise;
+		return promise;
+
+	};
+
+	return { name: 'RAYZEE_platform_images' };
+
+}

package/src/Processor/ResampleRGBA8.js

@@ -0,0 +1,102 @@
+/**
+ * One RGBA8 layer into its slot of a packed array: bilinear with texel centres aligned, a plain copy
+ * when the sizes match. flipY puts the last row first. Shared by the main thread and PackWorker.
+ */
+export function resampleRGBA8( { data: src, width: sw, height: sh, flipY }, dst, offset, dw, dh ) {
+
+	const rowBytes = dw * 4;
+
+	if ( sw === dw && sh === dh ) {
+
+		if ( ! flipY ) {
+
+			dst.set( src.subarray( 0, dh * rowBytes ), offset );
+			return;
+
+		}
+
+		for ( let y = 0; y < dh; y ++ ) dst.set( src.subarray( y * rowBytes, ( y + 1 ) * rowBytes ), offset + ( dh - 1 - y ) * rowBytes );
+		return;
+
+	}
+
+	// Every row samples the same columns. Enlarged, neighbouring rows also share source rows, so each
+	// source row is blended across once, and the slot holding the other row of a pair is never evicted.
+	const left = new Int32Array( dw ), right = new Int32Array( dw ), weight = new Float64Array( dw );
+
+	for ( let x = 0; x < dw; x ++ ) {
+
+		const fx = Math.min( Math.max( ( x + 0.5 ) * sw / dw - 0.5, 0 ), sw - 1 );
+		const x0 = Math.floor( fx );
+		left[ x ] = x0 * 4;
+		right[ x ] = Math.min( x0 + 1, sw - 1 ) * 4;
+		weight[ x ] = fx - x0;
+
+	}
+
+	if ( dh <= sh ) {
+
+		for ( let y = 0; y < dh; y ++ ) {
+
+			const fy = Math.min( Math.max( ( y + 0.5 ) * sh / dh - 0.5, 0 ), sh - 1 );
+			const y0 = Math.floor( fy ), y1 = Math.min( y0 + 1, sh - 1 ), ty = fy - y0;
+			const top = y0 * sw * 4, bottom = y1 * sw * 4;
+			let out = offset + ( flipY ? dh - 1 - y : y ) * rowBytes;
+
+			for ( let x = 0; x < dw; x ++, out += 4 ) {
+
+				const a = top + left[ x ], b = top + right[ x ], c = bottom + left[ x ], d = bottom + right[ x ], tx = weight[ x ];
+
+				for ( let ch = 0; ch < 4; ch ++ ) {
+
+					const t = src[ a + ch ] + ( src[ b + ch ] - src[ a + ch ] ) * tx;
+					const u = src[ c + ch ] + ( src[ d + ch ] - src[ c + ch ] ) * tx;
+					dst[ out + ch ] = Math.round( t + ( u - t ) * ty );
+
+				}
+
+			}
+
+		}
+
+		return;
+
+	}
+
+	const slots = [ { row: - 1, data: new Float64Array( rowBytes ) }, { row: - 1, data: new Float64Array( rowBytes ) } ];
+
+	const across = ( sy, keep ) => {
+
+		for ( const slot of slots ) if ( slot.row === sy ) return slot.data;
+
+		const slot = slots[ 0 ].row === keep ? slots[ 1 ] : slots[ 0 ];
+		const base = sy * sw * 4, row = slot.data;
+
+		for ( let x = 0, o = 0; x < dw; x ++, o += 4 ) {
+
+			const a = base + left[ x ], b = base + right[ x ], tx = weight[ x ];
+			row[ o ] = src[ a ] + ( src[ b ] - src[ a ] ) * tx;
+			row[ o + 1 ] = src[ a + 1 ] + ( src[ b + 1 ] - src[ a + 1 ] ) * tx;
+			row[ o + 2 ] = src[ a + 2 ] + ( src[ b + 2 ] - src[ a + 2 ] ) * tx;
+			row[ o + 3 ] = src[ a + 3 ] + ( src[ b + 3 ] - src[ a + 3 ] ) * tx;
+
+		}
+
+		slot.row = sy;
+		return row;
+
+	};
+
+	for ( let y = 0; y < dh; y ++ ) {
+
+		const fy = Math.min( Math.max( ( y + 0.5 ) * sh / dh - 0.5, 0 ), sh - 1 );
+		const y0 = Math.floor( fy ), y1 = Math.min( y0 + 1, sh - 1 ), ty = fy - y0;
+		const top = across( y0, y1 );
+		const bottom = y1 === y0 ? top : across( y1, y0 );
+		const out = offset + ( flipY ? dh - 1 - y : y ) * rowBytes;
+
+		for ( let i = 0; i < rowBytes; i ++ ) dst[ out + i ] = Math.round( top[ i ] + ( bottom[ i ] - top[ i ] ) * ty );
+
+	}
+
+}