@luma.gl/core 9.0.0-beta.9 → 9.0.3

package/dist/index.cjs

@@ -116,7 +116,7 @@ var lumaStats = new StatsManager();
 
 // dist/init.js
 function initializeLuma() {
-  const VERSION2 = true ? "9.0.0-beta.8" : "running from source";
+  const VERSION2 = true ? "9.0.2" : "running from source";
   const STARTUP_MESSAGE = "set luma.log.level=1 (or higher) to trace rendering";
   if (globalThis.luma && globalThis.luma.VERSION !== VERSION2) {
     throw new Error(`luma.gl - multiple VERSIONs detected: ${globalThis.luma.VERSION} vs ${VERSION2}`);
@@ -647,61 +647,100 @@ function assert(condition, message) {
 }
 
 // dist/lib/luma.js
-var deviceList = /* @__PURE__ */ new Map();
+var deviceMap = /* @__PURE__ */ new Map();
 var luma = class {
   static registerDevices(deviceClasses) {
     for (const deviceClass of deviceClasses) {
       assert(deviceClass.type && deviceClass.isSupported && deviceClass.create);
-      deviceList.set(deviceClass.type, deviceClass);
+      deviceMap.set(deviceClass.type, deviceClass);
     }
   }
   static getAvailableDevices() {
-    return Array.from(deviceList).map((Device2) => Device2.type);
+    return Array.from(deviceMap).map((Device2) => Device2.type);
   }
   static getSupportedDevices() {
-    return Array.from(deviceList).filter((Device2) => Device2.isSupported()).map((Device2) => Device2.type);
+    return Array.from(deviceMap).filter((Device2) => Device2.isSupported()).map((Device2) => Device2.type);
   }
   static setDefaultDeviceProps(props) {
     Object.assign(Device.defaultProps, props);
   }
+  /** Attach to an existing GPU API handle (WebGL2RenderingContext or GPUDevice). */
+  static async attachDevice(props) {
+    const devices = getDeviceMap(props.devices) || deviceMap;
+    if (props.handle instanceof WebGL2RenderingContext) {
+      const WebGLDevice = devices.get("webgl");
+      if (WebGLDevice) {
+        return await WebGLDevice.attach(props.handle);
+      }
+    }
+    if (props.handle === null) {
+      const UnknownDevice = devices.get("unknown");
+      if (UnknownDevice) {
+        return await UnknownDevice.attach(null);
+      }
+    }
+    throw new Error("Failed to attach device. Ensure `@luma.gl/webgl` and/or `@luma.gl/webgpu` modules are imported.");
+  }
   /** Creates a device. Asynchronously. */
   static async createDevice(props = {}) {
+    var _a, _b;
     props = { ...Device.defaultProps, ...props };
     if (props.gl) {
       props.type = "webgl";
     }
-    let DeviceClass;
+    const devices = getDeviceMap(props.devices) || deviceMap;
     switch (props.type) {
       case "webgpu":
-        DeviceClass = deviceList.get("webgpu");
-        if (DeviceClass) {
-          return await DeviceClass.create(props);
+        let WebGPUDevice = devices.get("webgpu");
+        if (WebGPUDevice) {
+          return await WebGPUDevice.create(props);
         }
         break;
       case "webgl":
-        DeviceClass = deviceList.get("webgl");
-        if (DeviceClass) {
-          return await DeviceClass.create(props);
+        let WebGLDevice = devices.get("webgl");
+        if (WebGLDevice) {
+          return await WebGLDevice.create(props);
+        }
+        break;
+      case "unknown":
+        const UnknownDevice = devices.get("unknown");
+        if (UnknownDevice) {
+          return await UnknownDevice.create(props);
         }
         break;
       case "best-available":
-        DeviceClass = deviceList.get("webgpu");
-        if (DeviceClass && DeviceClass.isSupported()) {
-          return await DeviceClass.create(props);
+        WebGPUDevice = devices.get("webgpu");
+        if ((_a = WebGPUDevice == null ? void 0 : WebGPUDevice.isSupported) == null ? void 0 : _a.call(WebGPUDevice)) {
+          return await WebGPUDevice.create(props);
         }
-        DeviceClass = deviceList.get("webgl");
-        if (DeviceClass && DeviceClass.isSupported()) {
-          return await DeviceClass.create(props);
+        WebGLDevice = devices.get("webgl");
+        if ((_b = WebGLDevice == null ? void 0 : WebGLDevice.isSupported) == null ? void 0 : _b.call(WebGLDevice)) {
+          return await WebGLDevice.create(props);
         }
         break;
     }
     throw new Error("No matching device found. Ensure `@luma.gl/webgl` and/or `@luma.gl/webgpu` modules are imported.");
   }
 };
+__publicField(luma, "defaultProps", {
+  ...Device.defaultProps,
+  type: "best-available",
+  devices: void 0
+});
 /** Global stats for all devices */
 __publicField(luma, "stats", lumaStats);
 /** Global log */
 __publicField(luma, "log", log);
+function getDeviceMap(deviceClasses) {
+  if (!deviceClasses || (deviceClasses == null ? void 0 : deviceClasses.length) === 0) {
+    return null;
+  }
+  const map = /* @__PURE__ */ new Map();
+  for (const deviceClass of deviceClasses) {
+    map.set(deviceClass.type, deviceClass);
+  }
+  return map;
+}
 
 // dist/adapter/canvas-context.js
 var import_env2 = require("@probe.gl/env");