@luma.gl/test-utils 9.2.6 → 9.3.0-alpha.10

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);
 
@@ -46,15 +47,15 @@ var import_webgpu = require("@luma.gl/webgpu");
 import_core.luma.registerAdapters([import_webgl.webgl2Adapter, import_webgpu.webgpuAdapter]);
 
 // dist/create-test-device.js
-var import_core19 = require("@luma.gl/core");
+var import_core20 = require("@luma.gl/core");
 var import_webgl2 = require("@luma.gl/webgl");
 var import_webgpu2 = require("@luma.gl/webgpu");
 
 // dist/null-device/null-adapter.js
-var import_core18 = require("@luma.gl/core");
+var import_core19 = require("@luma.gl/core");
 
 // dist/null-device/null-device.js
-var import_core17 = require("@luma.gl/core");
+var import_core18 = require("@luma.gl/core");
 
 // dist/null-device/null-device-info.js
 var NullDeviceInfo = {
@@ -131,13 +132,14 @@ var NullCanvasContext = class extends import_core4.CanvasContext {
     super(props);
     this.device = device;
     this._setAutoCreatedCanvasId(`${this.device.id}-canvas`);
-    this._updateDevice();
+    this._configureDevice();
+    this._startObservers();
   }
-  getCurrentFramebuffer() {
+  _getCurrentFramebuffer() {
     this._framebuffer = this._framebuffer || new NullFramebuffer(this.device, { handle: null });
     return this._framebuffer;
   }
-  _updateDevice() {
+  _configureDevice() {
   }
 };
 
@@ -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,22 +389,25 @@ var NullTexture = class extends import_core12.Texture {
     return new NullTextureView(this.device, { ...props, texture: this });
   }
   copyExternalImage(options) {
-    this.trackDeallocatedMemory("Texture");
-    const { image: data } = options;
-    const bytesPerPixel = 4;
-    this.trackAllocatedMemory(this.width * this.height * bytesPerPixel, "Texture");
-    const width = options.width ?? data.width;
-    const height = options.height ?? data.height;
-    this.width = width;
-    this.height = height;
-    return { width, height };
+    return { width: this.width, height: this.height };
   }
   setSampler(sampler) {
   }
   copyImageData(options) {
-    throw new Error("copyImageData not implemented");
+    super.copyImageData(options);
   }
-  generateMipmapsWebGL() {
+  readBuffer(_options = {}, buffer) {
+    if (!buffer) {
+      throw new Error("buffer required");
+    }
+    return buffer;
+  }
+  async readDataAsync(_options = {}) {
+    throw new Error(`${this} readDataAsync is deprecated; use readBuffer() with an explicit destination buffer or DynamicTexture.readAsync()`);
+  }
+  writeBuffer(buffer, options = {}) {
+  }
+  writeData(data, options = {}) {
   }
 };
 
@@ -393,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;
@@ -406,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);
@@ -489,10 +509,38 @@ 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
+var import_core17 = require("@luma.gl/core");
+var NullFence = class extends import_core17.Fence {
+  device;
+  handle = null;
+  signaled = Promise.resolve();
+  constructor(device, props = {}) {
+    super(device, props);
+    this.device = device;
+  }
+  destroy() {
+  }
+  isSignaled() {
+    return true;
+  }
 };
 
 // dist/null-device/null-device.js
-var NullDevice = class extends import_core17.Device {
+var NullDevice = class extends import_core18.Device {
   static isSupported() {
     return true;
   }
@@ -500,7 +548,7 @@ var NullDevice = class extends import_core17.Device {
   handle = null;
   preferredColorFormat = "rgba8unorm";
   preferredDepthFormat = "depth24plus";
-  features = new import_core17.DeviceFeatures([], this.props._disabledFeatures);
+  features = new import_core18.DeviceFeatures([], this.props._disabledFeatures);
   limits = new NullDeviceLimits();
   info = NullDeviceInfo;
   canvasContext;
@@ -508,7 +556,7 @@ var NullDevice = class extends import_core17.Device {
   lost;
   constructor(props) {
     super({ ...props, id: props.id || "null-device" });
-    const canvasContextProps = import_core17.Device._getCanvasContextProps(props);
+    const canvasContextProps = import_core18.Device._getCanvasContextProps(props);
     this.canvasContext = new NullCanvasContext(this, canvasContextProps);
     this.lost = new Promise((resolve) => {
     });
@@ -519,17 +567,19 @@ var NullDevice = class extends import_core17.Device {
    * @note Has no effect for null contexts
    */
   destroy() {
+    var _a;
+    (_a = this.commandEncoder) == null ? void 0 : _a.destroy();
   }
   get isLost() {
     return false;
   }
   // IMPLEMENTATION OF ABSTRACT DEVICE
-  getTextureByteAlignment() {
-    return 1;
-  }
   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);
@@ -561,16 +611,25 @@ var NullDevice = class extends import_core17.Device {
   createQuerySet(props) {
     return new NullQuerySet(this, props);
   }
+  createFence() {
+    return new NullFence(this);
+  }
   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) {
   }
@@ -594,7 +653,7 @@ var NullDevice = class extends import_core17.Device {
 };
 
 // dist/null-device/null-adapter.js
-var NullAdapter = class extends import_core18.Adapter {
+var NullAdapter = class extends import_core19.Adapter {
   /** type of device's created by this adapter */
   type = "null";
   constructor() {
@@ -618,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);
@@ -629,37 +687,68 @@ 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();
   try {
-    const webgpuDevice = await import_core19.luma.createDevice({
+    const webgpuDevice = await import_core20.luma.createDevice({
       id: "webgpu-test-device",
       type: "webgpu",
       adapters: [import_webgpu2.webgpuAdapter],
       createCanvasContext: DEFAULT_CANVAS_CONTEXT_PROPS,
       debug: true
     });
+    webgpuDevice.lost.finally(() => {
+      if (testDeviceCache.webgpuDevicePromise === webgpuDeviceResolvers.promise) {
+        testDeviceCache.webgpuDevicePromise = null;
+      }
+    });
     webgpuDeviceResolvers.resolve(webgpuDevice);
   } catch (error) {
-    import_core19.log.error(String(error))();
+    import_core20.log.error(String(error))();
     webgpuDeviceResolvers.resolve(null);
   }
   return webgpuDeviceResolvers.promise;
@@ -667,39 +756,77 @@ async function makeWebGPUTestDevice() {
 async function makeWebGLTestDevice() {
   const webglDeviceResolvers = withResolvers();
   try {
-    const webglDevice3 = await import_core19.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,
-      debugWebGL: true
+      debug: true
+    });
+    webglDevice2.lost.finally(() => {
+      if (testDeviceCache.webglDevicePromise === webglDeviceResolvers.promise) {
+        testDeviceCache.webglDevicePromise = null;
+      }
     });
-    webglDeviceResolvers.resolve(webglDevice3);
+    webglDeviceResolvers.resolve(webglDevice2);
   } catch (error) {
-    import_core19.log.error(String(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 {
-    const nullDevice = await import_core19.luma.createDevice({
+    const nullDevice = await import_core20.luma.createDevice({
       id: "null-test-device",
       type: "null",
       adapters: [nullAdapter],
       createCanvasContext: DEFAULT_CANVAS_CONTEXT_PROPS,
-      debug: true,
-      debugWebGL: true
+      debug: true
     });
     nullDeviceResolvers.resolve(nullDevice);
   } catch (error) {
-    import_core19.log.error(String(error))();
-    nullDevicePromise = Promise.resolve(null);
+    import_core20.log.error(String(error))();
+    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;
@@ -710,18 +837,43 @@ 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_core20 = require("@luma.gl/core");
+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;
 }
 var statIdCounter = 0;
 var DEFAULT_CLASSIC_ANIMATION_LOOP_PROPS = {
-  onCreateDevice: (props) => import_core20.luma.createDevice({ ...props, debug: true }),
+  onCreateDevice: (props) => import_core21.luma.createDevice({ ...props, debug: true }),
   onCreateContext: void 0,
   onAddHTML: void 0,
   onInitialize: () => ({}),
@@ -737,7 +889,7 @@ var DEFAULT_CLASSIC_ANIMATION_LOOP_PROPS = {
   useDevicePixels: true,
   autoResizeViewport: true,
   autoResizeDrawingBuffer: true,
-  stats: import_core20.luma.stats.get(`animation-loop-${statIdCounter++}`),
+  stats: import_core21.luma.stats.get(`animation-loop-${statIdCounter++}`),
   // deprecated
   // onCreateContext: (opts) => createGLContext(opts),
   gl: void 0,
@@ -774,15 +926,15 @@ var ClassicAnimationLoop = class {
     props = this.props;
     let { useDevicePixels = true } = this.props;
     if ("useDevicePixelRatio" in props) {
-      import_core20.log.deprecated("useDevicePixelRatio", "useDevicePixels")();
+      import_core21.log.deprecated("useDevicePixelRatio", "useDevicePixels")();
       useDevicePixels = props.useDevicePixelRatio;
     }
     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,
@@ -1073,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() {
@@ -1101,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 */
@@ -1180,7 +1326,7 @@ var DEFAULT_TEST_PROPS = {
   imageDiffOptions: void 0
 };
 var TestRunner = class {
-  device = webglDevice;
+  device = createTestDevice();
   props;
   isRunning = false;
   testOptions = { ...DEFAULT_TEST_PROPS };
@@ -1452,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
@@ -1472,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