@luma.gl/test-utils 9.2.0-alpha.1 → 9.2.0-alpha.3

package/src/null-device/null-device.ts

@@ -61,7 +61,7 @@ export class NullDevice extends Device {
   constructor(props: DeviceProps) {
     super({...props, id: props.id || 'null-device'});
 
-    const canvasContextProps = props.createCanvasContext === true ? {} : props.createCanvasContext;
+    const canvasContextProps = Device._getCanvasContextProps(props);
     this.canvasContext = new NullCanvasContext(this, canvasContextProps);
     this.lost = new Promise(resolve => {});
     this.commandEncoder = new NullCommandEncoder(this, {id: 'null-command-encoder'});
@@ -79,6 +79,10 @@ export class NullDevice extends Device {
 
   // IMPLEMENTATION OF ABSTRACT DEVICE
 
+  getTextureByteAlignment(): number {
+    return 1;
+  }
+
   createCanvasContext(props: CanvasContextProps): NullCanvasContext {
     return new NullCanvasContext(this, props);
   }

package/src/null-device/resources/null-buffer.ts

@@ -2,14 +2,15 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {BufferProps} from '@luma.gl/core';
-import {Buffer} from '@luma.gl/core';
-import type {NullDevice} from '../null-device';
+import {Buffer, type BufferProps, type BufferMapCallback} from '@luma.gl/core';
+import {type NullDevice} from '../null-device';
 
 export class NullBuffer extends Buffer {
   device: NullDevice;
+  readonly handle: 'null' | null = 'null';
 
   byteLength: number;
+  private _storage: ArrayBuffer;
 
   constructor(device: NullDevice, props: BufferProps = {}) {
     super(device, props);
@@ -18,9 +19,14 @@ export class NullBuffer extends Buffer {
     const byteOffset = props.byteOffset || 0;
     const byteLength = props.byteLength ?? (props.data ? props.data.byteLength + byteOffset : 0);
 
-    // assert(byteLength >= 0);
-
     this.byteLength = byteLength;
+    this._storage = new ArrayBuffer(byteLength);
+
+    // If initial data is provided, copy it in
+    if (props.data) {
+      this.write(props.data, byteOffset);
+    }
+
     this.trackAllocatedMemory(byteLength);
   }
 
@@ -28,15 +34,61 @@ export class NullBuffer extends Buffer {
     if (!this.destroyed) {
       super.destroy();
       this.trackDeallocatedMemory();
+      // @ts-expect-error
+      this.handle = null;
+      // Clear internal storage
+      this._storage = new ArrayBuffer(0);
+    }
+  }
+
+  write(data: ArrayBufferLike | ArrayBufferView, byteOffset: number = 0): void {
+    const source = ArrayBuffer.isView(data)
+      ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
+      : new Uint8Array(data);
+    const target = new Uint8Array(this._storage, byteOffset, source.byteLength);
+
+    if (byteOffset + source.byteLength > this.byteLength) {
+      throw new RangeError(`NullBuffer.write(): write would overflow buffer`);
     }
+
+    target.set(source);
+    this._setDebugData(data, byteOffset, source.byteLength);
+  }
+
+  async mapAndWriteAsync(
+    callback: BufferMapCallback<void>,
+    byteOffset = 0,
+    byteLength = this.byteLength - byteOffset
+  ): Promise<void> {
+    const view = new Uint8Array(this._storage, byteOffset, byteLength);
+    const tempBuffer = new Uint8Array(view.length); // safe scratch copy
+    callback(tempBuffer.buffer, 'copied');
+    view.set(tempBuffer);
+    this._setDebugData(view, byteOffset, byteLength);
   }
 
   async readAsync(byteOffset = 0, byteLength?: number): Promise<Uint8Array> {
     byteLength = byteLength ?? this.byteLength - byteOffset;
-    return new Uint8Array(byteLength);
+
+    if (byteOffset + byteLength > this.byteLength) {
+      throw new RangeError(`NullBuffer.readAsync(): read would overflow buffer`);
+    }
+
+    const view = new Uint8Array(this._storage, byteOffset, byteLength);
+    return new Uint8Array(view); // return a copy
+  }
+
+  async mapAndReadAsync<T>(
+    callback: BufferMapCallback<T>,
+    byteOffset = 0,
+    byteLength = this.byteLength - byteOffset
+  ): Promise<T> {
+    const view = new Uint8Array(this._storage, byteOffset, byteLength);
+    const copy = new Uint8Array(view); // copy to protect memory
+    return callback(copy.buffer, 'copied');
   }
 
-  write(data: ArrayBufferView, byteOffset: number = 0): void {
-    // assert(data.byteLength + byteOffset <= this.byteLength);
+  readSyncWebGL(): Uint8Array {
+    throw new Error('NullBuffer.readSyncWebGL() not implemented');
   }
 }

package/src/null-device/resources/null-framebuffer.ts

@@ -9,6 +9,7 @@ import type {NullTextureView} from './null-texture-view';
 
 export class NullFramebuffer extends Framebuffer {
   device: NullDevice;
+  readonly handle = null;
 
   colorAttachments: NullTextureView[] = [];
   depthStencilAttachment: NullTextureView | null = null;

package/src/null-device/resources/null-query-set.ts

@@ -7,6 +7,7 @@ import {NullDevice} from '../null-device';
 
 export class NullQuerySet extends QuerySet {
   device: NullDevice;
+  readonly handle = null;
 
   constructor(device: NullDevice, props: QuerySetProps) {
     super(device, props);

package/src/null-device/resources/null-render-pass.ts

@@ -7,6 +7,7 @@ import {NullDevice} from '../null-device';
 
 export class NullRenderPass extends RenderPass {
   readonly device: NullDevice;
+  readonly handle = null;
 
   constructor(device: NullDevice, props: RenderPassProps) {
     super(device, props);

package/src/null-device/resources/null-render-pipeline.ts

@@ -17,6 +17,8 @@ import {NullShader} from './null-shader';
 /** Creates a new render pipeline */
 export class NullRenderPipeline extends RenderPipeline {
   device: NullDevice;
+  readonly handle = null;
+
   vs: NullShader;
   fs: NullShader;
 

package/src/null-device/resources/null-sampler.ts

@@ -7,6 +7,7 @@ import type {NullDevice} from '../null-device';
 
 export class NullSampler extends Sampler {
   readonly device: NullDevice;
+  readonly handle = null;
 
   constructor(device: NullDevice, props: SamplerProps) {
     super(device, props);

package/src/null-device/resources/null-shader.ts

@@ -7,6 +7,7 @@ import {NullDevice} from '../null-device';
 
 export class NullShader extends Shader {
   readonly device: NullDevice;
+  readonly handle = null;
 
   constructor(device: NullDevice, props: ShaderProps) {
     super(device, props);

package/src/null-device/resources/null-texture-view.ts

@@ -10,6 +10,8 @@ import type {NullTexture} from './null-texture';
 
 export class NullTextureView extends TextureView {
   readonly device: NullDevice;
+  readonly handle = null;
+
   readonly texture: NullTexture;
 
   constructor(device: NullDevice, props: TextureViewProps & {texture: NullTexture}) {

package/src/null-device/resources/null-texture.ts

@@ -6,7 +6,9 @@ import type {
   TextureProps,
   TextureViewProps,
   CopyExternalImageOptions,
-  CopyImageDataOptions
+  CopyImageDataOptions,
+  Sampler,
+  SamplerProps
 } from '@luma.gl/core';
 
 import {Texture} from '@luma.gl/core';
@@ -16,6 +18,7 @@ import {NullTextureView} from './null-texture-view';
 
 export class NullTexture extends Texture {
   readonly device: NullDevice;
+  readonly handle = null;
 
   sampler: NullSampler;
   view: NullTextureView;
@@ -76,11 +79,15 @@ export class NullTexture extends Texture {
     return {width, height};
   }
 
-  override copyImageData(options: CopyImageDataOptions): void {
+  override setSampler(sampler?: Sampler | SamplerProps): void {
+    // ignore
+  }
+
+  copyImageData(options: CopyImageDataOptions): void {
     throw new Error('copyImageData not implemented');
   }
 
-  override generateMipmapsWebGL(): void {
+  generateMipmapsWebGL(): void {
     // ignore
   }
 }

package/src/null-device/resources/null-transform-feedback.ts

@@ -8,6 +8,7 @@ import type {NullDevice} from '../null-device';
 
 export class NullTransformFeedback extends TransformFeedback {
   readonly device: NullDevice;
+  readonly handle = null;
 
   readonly layout: ShaderLayout;
   buffers: Record<string, Buffer | BufferRange> = {};

package/src/null-device/resources/null-vertex-array.ts

@@ -10,6 +10,7 @@ import type {NullDevice} from '../null-device';
 
 export class NullVertexArray extends VertexArray {
   device: NullDevice;
+  readonly handle = null;
 
   // Create a VertexArray
   constructor(device: NullDevice, props: VertexArrayProps) {

package/src/performance-test-runner.ts

@@ -32,7 +32,7 @@ export class PerformanceTestRunner extends TestRunner {
 
     // @ts-ignore TODO
     if (this._fps.count > this.testOptions.maxFramesToRender) {
-      animationProps.done();
+      animationProps['done']();
     }
 
     return true;