@luma.gl/test-utils 9.3.0-alpha.4 → 9.3.0-alpha.8

package/dist/index.cjs

@@ -29,13 +29,14 @@ __export(dist_exports, {
   deepCopy: () => deepCopy,
   getLeakedResources: () => getLeakedResources,
   getNullTestDevice: () => getNullTestDevice,
+  getPresentationWebGLTestDevice: () => getPresentationWebGLTestDevice,
   getResourceCounts: () => getResourceCounts,
   getTestDevice: () => getTestDevice,
   getTestDevices: () => getTestDevices,
   getWebGLTestDevice: () => getWebGLTestDevice,
   getWebGPUTestDevice: () => getWebGPUTestDevice,
   nullAdapter: () => nullAdapter,
-  webglDevice: () => webglDevice2
+  webglDevice: () => webglDevice
 });
 module.exports = __toCommonJS(dist_exports);
 
@@ -132,6 +133,7 @@ var NullCanvasContext = class extends import_core4.CanvasContext {
     this.device = device;
     this._setAutoCreatedCanvasId(`${this.device.id}-canvas`);
     this._configureDevice();
+    this._startObservers();
   }
   _getCurrentFramebuffer() {
     this._framebuffer = this._framebuffer || new NullFramebuffer(this.device, { handle: null });
@@ -231,21 +233,26 @@ var NullCommandBuffer = class extends import_core7.CommandBuffer {
     super(device, props);
     this.device = device;
   }
-  copyBufferToBuffer(options) {
+  copyBufferToBuffer(_options) {
+    throw new Error("copyBufferToBuffer is not supported on NullDevice");
   }
-  copyBufferToTexture(options) {
+  copyBufferToTexture(_options) {
+    throw new Error("copyBufferToTexture is not supported on NullDevice");
   }
-  copyTextureToBuffer(options) {
+  copyTextureToBuffer(_options) {
+    throw new Error("copyTextureToBuffer is not supported on NullDevice");
   }
-  copyTextureToTexture(options) {
+  copyTextureToTexture(_options) {
+    throw new Error("copyTextureToTexture is not supported on NullDevice");
   }
   pushDebugGroup(groupLabel) {
   }
   popDebugGroup() {
   }
-  insertDebugMarker(markerLabel) {
+  insertDebugMarker(_markerLabel) {
   }
-  resolveQuerySet(querySet) {
+  resolveQuerySet(_querySet) {
+    throw new Error("resolveQuerySet is not supported on NullDevice");
   }
 };
 
@@ -259,6 +266,10 @@ var NullRenderPass = class extends import_core8.RenderPass {
     this.device = device;
   }
   end() {
+    if (this.destroyed) {
+      return;
+    }
+    this.destroy();
   }
   pushDebugGroup(groupLabel) {
   }
@@ -282,24 +293,34 @@ var NullCommandEncoder = class extends import_core9.CommandEncoder {
     super(device, props);
     this.device = device;
   }
-  finish(props) {
-    return new NullCommandBuffer(this.device, props);
+  destroy() {
+    this.destroyResource();
+  }
+  finish(props = {}) {
+    const commandBuffer = new NullCommandBuffer(this.device, props);
+    this.destroy();
+    return commandBuffer;
   }
   beginRenderPass(props) {
     return new NullRenderPass(this.device, props);
   }
-  beginComputePass(props) {
-    throw new Error("ComputePass not supported in WebGL");
+  beginComputePass(_props) {
+    throw new Error("ComputePass is not supported on NullDevice");
   }
-  copyBufferToBuffer(options) {
+  copyBufferToBuffer(_options) {
+    throw new Error("copyBufferToBuffer is not supported on NullDevice");
   }
-  copyBufferToTexture(options) {
+  copyBufferToTexture(_options) {
+    throw new Error("copyBufferToTexture is not supported on NullDevice");
   }
-  copyTextureToBuffer(options) {
+  copyTextureToBuffer(_options) {
+    throw new Error("copyTextureToBuffer is not supported on NullDevice");
   }
-  copyTextureToTexture(options) {
+  copyTextureToTexture(_options) {
+    throw new Error("copyTextureToTexture is not supported on NullDevice");
   }
-  resolveQuerySet(querySet) {
+  resolveQuerySet(_querySet) {
+    throw new Error("resolveQuerySet is not supported on NullDevice");
   }
   pushDebugGroup(groupLabel) {
   }
@@ -355,6 +376,7 @@ var NullTexture = class extends import_core12.Texture {
       mipLevelCount: 1,
       arrayLayerCount: 1
     });
+    this.trackAllocatedMemory(this.getAllocatedByteLength(), "Texture");
     Object.seal(this);
   }
   destroy() {
@@ -367,21 +389,21 @@ var NullTexture = class extends import_core12.Texture {
     return new NullTextureView(this.device, { ...props, texture: this });
   }
   copyExternalImage(options) {
-    this.trackDeallocatedMemory("Texture");
-    const bytesPerPixel = 4;
-    this.trackAllocatedMemory(this.width * this.height * bytesPerPixel, "Texture");
     return { width: this.width, height: this.height };
   }
   setSampler(sampler) {
   }
   copyImageData(options) {
-    throw new Error("copyImageData not implemented");
+    super.copyImageData(options);
   }
-  readBuffer(options = {}, buffer) {
-    return this.device.createBuffer({});
+  readBuffer(_options = {}, buffer) {
+    if (!buffer) {
+      throw new Error("buffer required");
+    }
+    return buffer;
   }
-  async readDataAsync(options = {}) {
-    return new ArrayBuffer(0);
+  async readDataAsync(_options = {}) {
+    throw new Error(`${this} readDataAsync is deprecated; use readBuffer() with an explicit destination buffer or DynamicTexture.readAsync()`);
   }
   writeBuffer(buffer, options = {}) {
   }
@@ -396,8 +418,6 @@ var NullRenderPipeline = class extends import_core13.RenderPipeline {
   handle = null;
   vs;
   fs;
-  uniforms = {};
-  bindings = {};
   constructor(device, props) {
     super(device, props);
     this.device = device;
@@ -409,9 +429,6 @@ var NullRenderPipeline = class extends import_core13.RenderPipeline {
       uniforms: []
     };
   }
-  setBindings(bindings) {
-    Object.assign(this.bindings, bindings);
-  }
   draw(options) {
     const { renderPass, vertexArray } = options;
     vertexArray.bindBeforeRender(renderPass);
@@ -492,6 +509,17 @@ var NullQuerySet = class extends import_core16.QuerySet {
     super(device, props);
     this.device = device;
   }
+  isResultAvailable(_queryIndex) {
+    return false;
+  }
+  async readResults(options) {
+    const firstQuery = (options == null ? void 0 : options.firstQuery) || 0;
+    const queryCount = (options == null ? void 0 : options.queryCount) || this.props.count - firstQuery;
+    return new Array(queryCount).fill(0n);
+  }
+  async readTimestampDuration(_beginIndex, _endIndex) {
+    return 0;
+  }
 };
 
 // dist/null-device/resources/null-fence.js
@@ -539,6 +567,8 @@ var NullDevice = class extends import_core18.Device {
    * @note Has no effect for null contexts
    */
   destroy() {
+    var _a;
+    (_a = this.commandEncoder) == null ? void 0 : _a.destroy();
   }
   get isLost() {
     return false;
@@ -547,6 +577,9 @@ var NullDevice = class extends import_core18.Device {
   createCanvasContext(props) {
     return new NullCanvasContext(this, props);
   }
+  createPresentationContext(_props) {
+    throw new Error("PresentationContext is not supported on NullDevice");
+  }
   createBuffer(props) {
     const newProps = this._normalizeBufferProps(props);
     return new NullBuffer(this, newProps);
@@ -584,13 +617,19 @@ var NullDevice = class extends import_core18.Device {
   createRenderPipeline(props) {
     return new NullRenderPipeline(this, props);
   }
-  createComputePipeline(props) {
-    throw new Error("ComputePipeline not supported in WebGL");
+  createComputePipeline(_props) {
+    throw new Error("ComputePipeline is not supported on NullDevice");
   }
   createCommandEncoder(props = {}) {
     return new NullCommandEncoder(this, props);
   }
-  submit() {
+  submit(commandBuffer) {
+    if (!commandBuffer) {
+      commandBuffer = this.commandEncoder.finish({ id: `${this.id}-default-command-buffer` });
+      this.commandEncoder.destroy();
+      this.commandEncoder = this.createCommandEncoder({ id: `${this.id}-default-command-encoder` });
+    }
+    commandBuffer.destroy();
   }
   setParametersWebGL(parameters) {
   }
@@ -638,9 +677,8 @@ var nullAdapter = new NullAdapter();
 
 // dist/create-test-device.js
 var DEFAULT_CANVAS_CONTEXT_PROPS = { width: 1, height: 1 };
-var nullDevicePromise = makeNullTestDevice();
-var webglDevicePromise = makeWebGLTestDevice();
-var webgpuDevicePromise = makeWebGPUTestDevice();
+var TEST_DEVICE_CACHE_KEY = "__lumaTestDeviceCache";
+var testDeviceCache = getOrCreateTestDeviceCache();
 async function getTestDevices(types = ["webgl", "webgpu"]) {
   const promises = types.map((type) => getTestDevice(type));
   const devices = await Promise.all(promises);
@@ -649,23 +687,49 @@ async function getTestDevices(types = ["webgl", "webgpu"]) {
 async function getTestDevice(type) {
   switch (type) {
     case "webgl":
-      return webglDevicePromise;
+      return getOrCreateWebGLTestDevicePromise();
     case "webgpu":
-      return webgpuDevicePromise;
+      return getWebGPUTestDevice();
     case "null":
-      return nullDevicePromise;
+      return getOrCreateNullTestDevicePromise();
     case "unknown":
       return null;
   }
 }
-function getWebGPUTestDevice() {
-  return webgpuDevicePromise;
+async function getWebGPUTestDevice() {
+  const webgpuDevice = await getOrCreateWebGPUTestDevicePromise();
+  if (webgpuDevice == null ? void 0 : webgpuDevice.isLost) {
+    if (testDeviceCache.webgpuDevicePromise) {
+      testDeviceCache.webgpuDevicePromise = null;
+    }
+    return getOrCreateWebGPUTestDevicePromise();
+  }
+  return webgpuDevice;
 }
 async function getWebGLTestDevice() {
-  return webglDevicePromise;
+  return getOrCreateWebGLTestDevicePromise();
+}
+async function getPresentationWebGLTestDevice() {
+  return getOrCreatePresentationWebGLTestDevicePromise();
 }
 async function getNullTestDevice() {
-  return nullDevicePromise;
+  return getOrCreateNullTestDevicePromise();
+}
+function getOrCreateWebGPUTestDevicePromise() {
+  testDeviceCache.webgpuDevicePromise ||= makeWebGPUTestDevice();
+  return testDeviceCache.webgpuDevicePromise;
+}
+function getOrCreateWebGLTestDevicePromise() {
+  testDeviceCache.webglDevicePromise ||= makeWebGLTestDevice();
+  return testDeviceCache.webglDevicePromise;
+}
+function getOrCreatePresentationWebGLTestDevicePromise() {
+  testDeviceCache.presentationWebglDevicePromise ||= makePresentationWebGLTestDevice();
+  return testDeviceCache.presentationWebglDevicePromise;
+}
+function getOrCreateNullTestDevicePromise() {
+  testDeviceCache.nullDevicePromise ||= makeNullTestDevice();
+  return testDeviceCache.nullDevicePromise;
 }
 async function makeWebGPUTestDevice() {
   const webgpuDeviceResolvers = withResolvers();
@@ -677,6 +741,11 @@ async function makeWebGPUTestDevice() {
       createCanvasContext: DEFAULT_CANVAS_CONTEXT_PROPS,
       debug: true
     });
+    webgpuDevice.lost.finally(() => {
+      if (testDeviceCache.webgpuDevicePromise === webgpuDeviceResolvers.promise) {
+        testDeviceCache.webgpuDevicePromise = null;
+      }
+    });
     webgpuDeviceResolvers.resolve(webgpuDevice);
   } catch (error) {
     import_core20.log.error(String(error))();
@@ -687,20 +756,50 @@ async function makeWebGPUTestDevice() {
 async function makeWebGLTestDevice() {
   const webglDeviceResolvers = withResolvers();
   try {
-    const webglDevice3 = await import_core20.luma.createDevice({
+    const webglDevice2 = await import_core20.luma.createDevice({
       id: "webgl-test-device",
       type: "webgl",
       adapters: [import_webgl2.webgl2Adapter],
       createCanvasContext: DEFAULT_CANVAS_CONTEXT_PROPS,
       debug: true
     });
-    webglDeviceResolvers.resolve(webglDevice3);
+    webglDevice2.lost.finally(() => {
+      if (testDeviceCache.webglDevicePromise === webglDeviceResolvers.promise) {
+        testDeviceCache.webglDevicePromise = null;
+      }
+    });
+    webglDeviceResolvers.resolve(webglDevice2);
   } catch (error) {
     import_core20.log.error(String(error))();
     webglDeviceResolvers.resolve(null);
   }
   return webglDeviceResolvers.promise;
 }
+async function makePresentationWebGLTestDevice() {
+  if (typeof OffscreenCanvas === "undefined") {
+    return null;
+  }
+  const presentationWebGLDeviceResolvers = withResolvers();
+  try {
+    const webglDevice2 = await import_core20.luma.createDevice({
+      id: "webgl-presentation-context-test-device",
+      type: "webgl",
+      adapters: [import_webgl2.webgl2Adapter],
+      createCanvasContext: { canvas: new OffscreenCanvas(4, 4) },
+      debug: true
+    });
+    webglDevice2.lost.finally(() => {
+      if (testDeviceCache.presentationWebglDevicePromise === presentationWebGLDeviceResolvers.promise) {
+        testDeviceCache.presentationWebglDevicePromise = null;
+      }
+    });
+    presentationWebGLDeviceResolvers.resolve(webglDevice2);
+  } catch (error) {
+    import_core20.log.error(String(error))();
+    presentationWebGLDeviceResolvers.resolve(null);
+  }
+  return presentationWebGLDeviceResolvers.promise;
+}
 async function makeNullTestDevice() {
   const nullDeviceResolvers = withResolvers();
   try {
@@ -714,10 +813,20 @@ async function makeNullTestDevice() {
     nullDeviceResolvers.resolve(nullDevice);
   } catch (error) {
     import_core20.log.error(String(error))();
-    nullDevicePromise = Promise.resolve(null);
+    testDeviceCache.nullDevicePromise = Promise.resolve(null);
   }
   return nullDeviceResolvers.promise;
 }
+function getOrCreateTestDeviceCache() {
+  const rootObject = globalThis;
+  rootObject[TEST_DEVICE_CACHE_KEY] ||= {
+    nullDevicePromise: null,
+    webglDevicePromise: null,
+    presentationWebglDevicePromise: null,
+    webgpuDevicePromise: null
+  };
+  return rootObject[TEST_DEVICE_CACHE_KEY];
+}
 function withResolvers() {
   let resolve;
   let reject;
@@ -728,11 +837,36 @@ function withResolvers() {
   return { promise, resolve, reject };
 }
 
+// dist/deprecated/sync-test-device.js
+var import_webgl3 = require("@luma.gl/webgl");
+var DEFAULT_CANVAS_CONTEXT_PROPS2 = {
+  width: 1,
+  height: 1
+};
+function createTestDevice() {
+  if (cachedWebglDevice) {
+    return cachedWebglDevice;
+  }
+  if (typeof navigator === "undefined" || typeof document === "undefined" || typeof HTMLCanvasElement === "undefined") {
+    return null;
+  }
+  try {
+    cachedWebglDevice = new import_webgl3.WebGLDevice({ createCanvasContext: DEFAULT_CANVAS_CONTEXT_PROPS2 });
+    return cachedWebglDevice;
+  } catch (error) {
+    console.error(`Failed to created device: ${error.message}`);
+    debugger;
+    return null;
+  }
+}
+var cachedWebglDevice = null;
+var webglDevice = createTestDevice();
+
 // dist/deprecated/classic-animation-loop.js
 var import_core21 = require("@luma.gl/core");
 var import_engine = require("@luma.gl/engine");
 var import_env = require("@probe.gl/env");
-var import_webgl3 = require("@luma.gl/webgl");
+var import_webgl4 = require("@luma.gl/webgl");
 var isPage = (0, import_env.isBrowser)() && typeof document !== "undefined";
 function getHTMLCanvasElement(canvas) {
   return typeof HTMLCanvasElement !== "undefined" && canvas instanceof HTMLCanvasElement ? canvas : null;
@@ -798,9 +932,9 @@ var ClassicAnimationLoop = class {
     this.device = props.device;
     this.gl = this.device && this.device.gl || props.gl;
     this.stats = props.stats;
+    this.frameRate = this.stats.get("Frame Rate");
     this.cpuTime = this.stats.get("CPU Time");
     this.gpuTime = this.stats.get("GPU Time");
-    this.frameRate = this.stats.get("Frame Rate");
     this.setProps({
       autoResizeViewport: props.autoResizeViewport,
       autoResizeDrawingBuffer: props.autoResizeDrawingBuffer,
@@ -1091,7 +1225,7 @@ var ClassicAnimationLoop = class {
     const deviceProps = { ...this.props, ...props, ...this.props.glOptions };
     this.device = await this.onCreateDevice(deviceProps);
     this.gl = this.device.gl;
-    (0, import_webgl3.resetGLParameters)(this.gl);
+    (0, import_webgl4.resetGLParameters)(this.gl);
     this._createInfoDiv();
   }
   _createInfoDiv() {
@@ -1119,13 +1253,7 @@ var ClassicAnimationLoop = class {
   _getSizeAndAspect() {
     const width = this.gl.drawingBufferWidth;
     const height = this.gl.drawingBufferHeight;
-    let aspect = 1;
-    const canvas = getHTMLCanvasElement(this.gl.canvas);
-    if (canvas && canvas.clientHeight) {
-      aspect = canvas.clientWidth / canvas.clientHeight;
-    } else if (width > 0 && height > 0) {
-      aspect = width / height;
-    }
+    const aspect = width > 0 && height > 0 ? width / height : 1;
     return { width, height, aspect };
   }
   /** Default viewport setup */
@@ -1198,7 +1326,7 @@ var DEFAULT_TEST_PROPS = {
   imageDiffOptions: void 0
 };
 var TestRunner = class {
-  device = webglDevice;
+  device = createTestDevice();
   props;
   isRunning = false;
   testOptions = { ...DEFAULT_TEST_PROPS };
@@ -1470,7 +1598,7 @@ function deepCopy(object) {
 
 // dist/utils/resource-tracker.js
 function getResourceCounts() {
-  const resourceStats = luma.stats.get("Resource Counts");
+  const resourceStats = luma.stats.get("GPU Resource Counts");
   return {
     Texture2D: resourceStats.get("Texture2Ds Active").count,
     Buffer: resourceStats.get("Buffers Active").count
@@ -1490,21 +1618,4 @@ function getLeakedResources(startCounts, endCounts) {
   }
   return leakedResources;
 }
-
-// dist/deprecated/sync-test-device.js
-var import_webgl4 = require("@luma.gl/webgl");
-var DEFAULT_CANVAS_CONTEXT_PROPS2 = {
-  width: 1,
-  height: 1
-};
-function createTestDevice() {
-  try {
-    return new import_webgl4.WebGLDevice({ createCanvasContext: DEFAULT_CANVAS_CONTEXT_PROPS2 });
-  } catch (error) {
-    console.error(`Failed to created device: ${error.message}`);
-    debugger;
-    return null;
-  }
-}
-var webglDevice2 = createTestDevice();
 //# sourceMappingURL=index.cjs.map