@luma.gl/gltf 9.0.0-alpha.51 → 9.0.0-alpha.52

package/dist/dist.dev.js

@@ -33,6 +33,7 @@ var __exports__ = (() => {
   __export(src_exports, {
     GLTFAnimator: () => GLTFAnimator,
     createScenegraphsFromGLTF: () => createScenegraphsFromGLTF,
+    loadPBREnvironment: () => loadPBREnvironment,
     parsePBRMaterial: () => parsePBRMaterial
   });
 
@@ -809,23 +810,23 @@ var __exports__ = (() => {
 
   // ../core/src/init.ts
   function initializeLuma() {
-    const VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
+    const VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
     const STARTUP_MESSAGE = "set luma.log.level=1 (or higher) to trace rendering";
-    if (globalThis.luma && globalThis.luma.VERSION !== VERSION3) {
-      throw new Error(`luma.gl - multiple VERSIONs detected: ${globalThis.luma.VERSION} vs ${VERSION3}`);
+    if (globalThis.luma && globalThis.luma.VERSION !== VERSION4) {
+      throw new Error(`luma.gl - multiple VERSIONs detected: ${globalThis.luma.VERSION} vs ${VERSION4}`);
     }
     if (!globalThis.luma) {
       if (isBrowser()) {
-        log.log(1, `luma.gl ${VERSION3} - ${STARTUP_MESSAGE}`)();
+        log.log(1, `luma.gl ${VERSION4} - ${STARTUP_MESSAGE}`)();
       }
       globalThis.luma = globalThis.luma || {
-        VERSION: VERSION3,
-        version: VERSION3,
+        VERSION: VERSION4,
+        version: VERSION4,
         log,
         stats: lumaStats
       };
     }
-    return VERSION3;
+    return VERSION4;
   }
   var VERSION2 = initializeLuma();
 
@@ -1502,7 +1503,10 @@ ${htmlLog}
       button.style.width = "100%";
       button.style.textAlign = "left";
       document.body.appendChild(button);
-      document.getElementsByClassName("luma-compiler-log-error")[0]?.scrollIntoView();
+      const errors = document.getElementsByClassName("luma-compiler-log-error");
+      if (errors[0]?.scrollIntoView) {
+        errors[0].scrollIntoView();
+      }
       button.onclick = () => {
         const dataURI = `data:text/plain,${encodeURIComponent(this.source)}`;
         navigator.clipboard.writeText(dataURI);
@@ -2404,9 +2408,9 @@ ${htmlLog}
   // ../core/src/adapter/type-utils/decode-texture-format.ts
   var REGEX = /^(rg?b?a?)([0-9]*)([a-z]*)(-srgb)?(-webgl|-unsized)?$/;
   function decodeTextureFormat(format) {
-    const matches = REGEX.exec(format);
-    if (matches) {
-      const [, format2, length4, type, srgb, suffix] = matches;
+    const matches2 = REGEX.exec(format);
+    if (matches2) {
+      const [, format2, length4, type, srgb, suffix] = matches2;
       if (format2) {
         const dataType = `${type}${length4}`;
         const decodedType = decodeVertexType(dataType);
@@ -2559,7 +2563,7 @@ ${htmlLog}
     return value;
   }
 
-  // ../core/src/lib/utils/uniform.ts
+  // ../core/src/lib/uniforms/uniform.ts
   function isUniformValue(value) {
     return isNumberArray(value) !== null || typeof value === "number" || typeof value === "boolean";
   }
@@ -2700,6 +2704,27 @@ ${htmlLog}
     return false;
   }
 
+  // ../core/src/lib/debug/debug-shader-layout.ts
+  function getDebugTableForShaderLayout(layout, name2 = "") {
+    const table = {};
+    const header = `Shader Layout for ${name2}`;
+    for (const attributeDeclaration of layout.attributes) {
+      if (attributeDeclaration) {
+        const glslDeclaration = `${attributeDeclaration.location} ${attributeDeclaration.name}: ${attributeDeclaration.type}`;
+        table[`in ${glslDeclaration}`] = {
+          [header]: attributeDeclaration.stepMode || "vertex"
+        };
+      }
+    }
+    for (const varyingDeclaration of layout.varyings || []) {
+      const glslDeclaration = `${varyingDeclaration.location} ${varyingDeclaration.name}`;
+      table[`out ${glslDeclaration}`] = {
+        [header]: JSON.stringify(varyingDeclaration.accessor)
+      };
+    }
+    return table;
+  }
+
   // src/pbr/parse-pbr-material.ts
   var GLEnum = function(GLEnum4) {
     GLEnum4[GLEnum4["FUNC_ADD"] = 32774] = "FUNC_ADD";
@@ -2850,11 +2875,616 @@ ${htmlLog}
     parsedMaterial.generatedTextures.push(texture);
   }
 
+  // node_modules/@loaders.gl/loader-utils/dist/lib/env-utils/assert.js
+  function assert3(condition, message2) {
+    if (!condition) {
+      throw new Error(message2 || "loader assertion failed.");
+    }
+  }
+
+  // node_modules/@loaders.gl/loader-utils/dist/lib/path-utils/file-aliases.js
+  var pathPrefix2 = "";
+  var fileAliases = {};
+  function resolvePath(filename) {
+    for (const alias in fileAliases) {
+      if (filename.startsWith(alias)) {
+        const replacement = fileAliases[alias];
+        filename = filename.replace(alias, replacement);
+      }
+    }
+    if (!filename.startsWith("http://") && !filename.startsWith("https://")) {
+      filename = `${pathPrefix2}${filename}`;
+    }
+    return filename;
+  }
+
+  // ../../node_modules/@loaders.gl/images/dist/lib/utils/version.js
+  var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+
+  // ../../node_modules/@loaders.gl/images/node_modules/@loaders.gl/loader-utils/dist/lib/env-utils/assert.js
+  function assert4(condition, message2) {
+    if (!condition) {
+      throw new Error(message2 || "loader assertion failed.");
+    }
+  }
+
+  // ../../node_modules/@loaders.gl/images/node_modules/@loaders.gl/loader-utils/dist/lib/env-utils/globals.js
+  var globals = {
+    self: typeof self !== "undefined" && self,
+    window: typeof window !== "undefined" && window,
+    global: typeof global !== "undefined" && global,
+    document: typeof document !== "undefined" && document
+  };
+  var self_2 = globals.self || globals.window || globals.global || {};
+  var window_2 = globals.window || globals.self || globals.global || {};
+  var global_2 = globals.global || globals.self || globals.window || {};
+  var document_2 = globals.document || {};
+  var isBrowser3 = Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser);
+  var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
+  var nodeVersion = matches && parseFloat(matches[1]) || 0;
+
+  // ../../node_modules/@loaders.gl/images/dist/lib/category-api/image-type.js
+  var _globalThis$loaders;
+  var parseImageNode = (_globalThis$loaders = globalThis.loaders) === null || _globalThis$loaders === void 0 ? void 0 : _globalThis$loaders.parseImageNode;
+  var IMAGE_SUPPORTED = typeof Image !== "undefined";
+  var IMAGE_BITMAP_SUPPORTED = typeof ImageBitmap !== "undefined";
+  var NODE_IMAGE_SUPPORTED = Boolean(parseImageNode);
+  var DATA_SUPPORTED = isBrowser3 ? true : NODE_IMAGE_SUPPORTED;
+  function isImageTypeSupported(type) {
+    switch (type) {
+      case "auto":
+        return IMAGE_BITMAP_SUPPORTED || IMAGE_SUPPORTED || DATA_SUPPORTED;
+      case "imagebitmap":
+        return IMAGE_BITMAP_SUPPORTED;
+      case "image":
+        return IMAGE_SUPPORTED;
+      case "data":
+        return DATA_SUPPORTED;
+      default:
+        throw new Error(`@loaders.gl/images: image ${type} not supported in this environment`);
+    }
+  }
+  function getDefaultImageType() {
+    if (IMAGE_BITMAP_SUPPORTED) {
+      return "imagebitmap";
+    }
+    if (IMAGE_SUPPORTED) {
+      return "image";
+    }
+    if (DATA_SUPPORTED) {
+      return "data";
+    }
+    throw new Error("Install '@loaders.gl/polyfills' to parse images under Node.js");
+  }
+
+  // ../../node_modules/@loaders.gl/images/dist/lib/category-api/parsed-image-api.js
+  function getImageType(image) {
+    const format = getImageTypeOrNull(image);
+    if (!format) {
+      throw new Error("Not an image");
+    }
+    return format;
+  }
+  function getImageSize(image) {
+    return getImageData(image);
+  }
+  function getImageData(image) {
+    switch (getImageType(image)) {
+      case "data":
+        return image;
+      case "image":
+      case "imagebitmap":
+        const canvas = document.createElement("canvas");
+        const context = canvas.getContext("2d");
+        if (!context) {
+          throw new Error("getImageData");
+        }
+        canvas.width = image.width;
+        canvas.height = image.height;
+        context.drawImage(image, 0, 0);
+        return context.getImageData(0, 0, image.width, image.height);
+      default:
+        throw new Error("getImageData");
+    }
+  }
+  function getImageTypeOrNull(image) {
+    if (typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap) {
+      return "imagebitmap";
+    }
+    if (typeof Image !== "undefined" && image instanceof Image) {
+      return "image";
+    }
+    if (image && typeof image === "object" && image.data && image.width && image.height) {
+      return "data";
+    }
+    return null;
+  }
+
+  // ../../node_modules/@loaders.gl/images/dist/lib/parsers/svg-utils.js
+  var SVG_DATA_URL_PATTERN = /^data:image\/svg\+xml/;
+  var SVG_URL_PATTERN = /\.svg((\?|#).*)?$/;
+  function isSVG(url) {
+    return url && (SVG_DATA_URL_PATTERN.test(url) || SVG_URL_PATTERN.test(url));
+  }
+  function getBlobOrSVGDataUrl(arrayBuffer2, url) {
+    if (isSVG(url)) {
+      const textDecoder = new TextDecoder();
+      let xmlText = textDecoder.decode(arrayBuffer2);
+      try {
+        if (typeof unescape === "function" && typeof encodeURIComponent === "function") {
+          xmlText = unescape(encodeURIComponent(xmlText));
+        }
+      } catch (error2) {
+        throw new Error(error2.message);
+      }
+      const src = `data:image/svg+xml;base64,${btoa(xmlText)}`;
+      return src;
+    }
+    return getBlob(arrayBuffer2, url);
+  }
+  function getBlob(arrayBuffer2, url) {
+    if (isSVG(url)) {
+      throw new Error("SVG cannot be parsed directly to imagebitmap");
+    }
+    return new Blob([new Uint8Array(arrayBuffer2)]);
+  }
+
+  // ../../node_modules/@loaders.gl/images/dist/lib/parsers/parse-to-image.js
+  async function parseToImage(arrayBuffer2, options, url) {
+    const blobOrDataUrl = getBlobOrSVGDataUrl(arrayBuffer2, url);
+    const URL = self.URL || self.webkitURL;
+    const objectUrl = typeof blobOrDataUrl !== "string" && URL.createObjectURL(blobOrDataUrl);
+    try {
+      return await loadToImage(objectUrl || blobOrDataUrl, options);
+    } finally {
+      if (objectUrl) {
+        URL.revokeObjectURL(objectUrl);
+      }
+    }
+  }
+  async function loadToImage(url, options) {
+    const image = new Image();
+    image.src = url;
+    if (options.image && options.image.decode && image.decode) {
+      await image.decode();
+      return image;
+    }
+    return await new Promise((resolve, reject) => {
+      try {
+        image.onload = () => resolve(image);
+        image.onerror = (error2) => {
+          const message2 = error2 instanceof Error ? error2.message : "error";
+          reject(new Error(message2));
+        };
+      } catch (error2) {
+        reject(error2);
+      }
+    });
+  }
+
+  // ../../node_modules/@loaders.gl/images/dist/lib/parsers/parse-to-image-bitmap.js
+  var EMPTY_OBJECT = {};
+  var imagebitmapOptionsSupported = true;
+  async function parseToImageBitmap(arrayBuffer2, options, url) {
+    let blob;
+    if (isSVG(url)) {
+      const image = await parseToImage(arrayBuffer2, options, url);
+      blob = image;
+    } else {
+      blob = getBlob(arrayBuffer2, url);
+    }
+    const imagebitmapOptions = options && options.imagebitmap;
+    return await safeCreateImageBitmap(blob, imagebitmapOptions);
+  }
+  async function safeCreateImageBitmap(blob) {
+    let imagebitmapOptions = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;
+    if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) {
+      imagebitmapOptions = null;
+    }
+    if (imagebitmapOptions) {
+      try {
+        return await createImageBitmap(blob, imagebitmapOptions);
+      } catch (error2) {
+        console.warn(error2);
+        imagebitmapOptionsSupported = false;
+      }
+    }
+    return await createImageBitmap(blob);
+  }
+  function isEmptyObject(object) {
+    for (const key in object || EMPTY_OBJECT) {
+      return false;
+    }
+    return true;
+  }
+
+  // ../../node_modules/@loaders.gl/images/dist/lib/category-api/parse-isobmff-binary.js
+  function getISOBMFFMediaType(buffer) {
+    if (!checkString(buffer, "ftyp", 4)) {
+      return null;
+    }
+    if ((buffer[8] & 96) === 0) {
+      return null;
+    }
+    return decodeMajorBrand(buffer);
+  }
+  function decodeMajorBrand(buffer) {
+    const brandMajor = getUTF8String(buffer, 8, 12).replace("\0", " ").trim();
+    switch (brandMajor) {
+      case "avif":
+      case "avis":
+        return {
+          extension: "avif",
+          mimeType: "image/avif"
+        };
+      default:
+        return null;
+    }
+  }
+  function getUTF8String(array, start, end) {
+    return String.fromCharCode(...array.slice(start, end));
+  }
+  function stringToBytes(string) {
+    return [...string].map((character) => character.charCodeAt(0));
+  }
+  function checkString(buffer, header) {
+    let offset = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0;
+    const headerBytes = stringToBytes(header);
+    for (let i = 0; i < headerBytes.length; ++i) {
+      if (headerBytes[i] !== buffer[i + offset]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  // ../../node_modules/@loaders.gl/images/dist/lib/category-api/binary-image-api.js
+  var BIG_ENDIAN = false;
+  var LITTLE_ENDIAN = true;
+  function getBinaryImageMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    return getPngMetadata(dataView) || getJpegMetadata(dataView) || getGifMetadata(dataView) || getBmpMetadata(dataView) || getISOBMFFMetadata(dataView);
+  }
+  function getISOBMFFMetadata(binaryData) {
+    const buffer = new Uint8Array(binaryData instanceof DataView ? binaryData.buffer : binaryData);
+    const mediaType = getISOBMFFMediaType(buffer);
+    if (!mediaType) {
+      return null;
+    }
+    return {
+      mimeType: mediaType.mimeType,
+      width: 0,
+      height: 0
+    };
+  }
+  function getPngMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    const isPng = dataView.byteLength >= 24 && dataView.getUint32(0, BIG_ENDIAN) === 2303741511;
+    if (!isPng) {
+      return null;
+    }
+    return {
+      mimeType: "image/png",
+      width: dataView.getUint32(16, BIG_ENDIAN),
+      height: dataView.getUint32(20, BIG_ENDIAN)
+    };
+  }
+  function getGifMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    const isGif = dataView.byteLength >= 10 && dataView.getUint32(0, BIG_ENDIAN) === 1195984440;
+    if (!isGif) {
+      return null;
+    }
+    return {
+      mimeType: "image/gif",
+      width: dataView.getUint16(6, LITTLE_ENDIAN),
+      height: dataView.getUint16(8, LITTLE_ENDIAN)
+    };
+  }
+  function getBmpMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    const isBmp = dataView.byteLength >= 14 && dataView.getUint16(0, BIG_ENDIAN) === 16973 && dataView.getUint32(2, LITTLE_ENDIAN) === dataView.byteLength;
+    if (!isBmp) {
+      return null;
+    }
+    return {
+      mimeType: "image/bmp",
+      width: dataView.getUint32(18, LITTLE_ENDIAN),
+      height: dataView.getUint32(22, LITTLE_ENDIAN)
+    };
+  }
+  function getJpegMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    const isJpeg = dataView.byteLength >= 3 && dataView.getUint16(0, BIG_ENDIAN) === 65496 && dataView.getUint8(2) === 255;
+    if (!isJpeg) {
+      return null;
+    }
+    const {
+      tableMarkers,
+      sofMarkers
+    } = getJpegMarkers();
+    let i = 2;
+    while (i + 9 < dataView.byteLength) {
+      const marker = dataView.getUint16(i, BIG_ENDIAN);
+      if (sofMarkers.has(marker)) {
+        return {
+          mimeType: "image/jpeg",
+          height: dataView.getUint16(i + 5, BIG_ENDIAN),
+          width: dataView.getUint16(i + 7, BIG_ENDIAN)
+        };
+      }
+      if (!tableMarkers.has(marker)) {
+        return null;
+      }
+      i += 2;
+      i += dataView.getUint16(i, BIG_ENDIAN);
+    }
+    return null;
+  }
+  function getJpegMarkers() {
+    const tableMarkers = /* @__PURE__ */ new Set([65499, 65476, 65484, 65501, 65534]);
+    for (let i = 65504; i < 65520; ++i) {
+      tableMarkers.add(i);
+    }
+    const sofMarkers = /* @__PURE__ */ new Set([65472, 65473, 65474, 65475, 65477, 65478, 65479, 65481, 65482, 65483, 65485, 65486, 65487, 65502]);
+    return {
+      tableMarkers,
+      sofMarkers
+    };
+  }
+  function toDataView(data) {
+    if (data instanceof DataView) {
+      return data;
+    }
+    if (ArrayBuffer.isView(data)) {
+      return new DataView(data.buffer);
+    }
+    if (data instanceof ArrayBuffer) {
+      return new DataView(data);
+    }
+    throw new Error("toDataView");
+  }
+
+  // ../../node_modules/@loaders.gl/images/dist/lib/parsers/parse-to-node-image.js
+  async function parseToNodeImage(arrayBuffer2, options) {
+    var _globalThis$loaders2;
+    const {
+      mimeType
+    } = getBinaryImageMetadata(arrayBuffer2) || {};
+    const parseImageNode2 = (_globalThis$loaders2 = globalThis.loaders) === null || _globalThis$loaders2 === void 0 ? void 0 : _globalThis$loaders2.parseImageNode;
+    assert4(parseImageNode2);
+    return await parseImageNode2(arrayBuffer2, mimeType);
+  }
+
+  // ../../node_modules/@loaders.gl/images/dist/lib/parsers/parse-image.js
+  async function parseImage(arrayBuffer2, options, context) {
+    options = options || {};
+    const imageOptions = options.image || {};
+    const imageType = imageOptions.type || "auto";
+    const {
+      url
+    } = context || {};
+    const loadType = getLoadableImageType(imageType);
+    let image;
+    switch (loadType) {
+      case "imagebitmap":
+        image = await parseToImageBitmap(arrayBuffer2, options, url);
+        break;
+      case "image":
+        image = await parseToImage(arrayBuffer2, options, url);
+        break;
+      case "data":
+        image = await parseToNodeImage(arrayBuffer2, options);
+        break;
+      default:
+        assert4(false);
+    }
+    if (imageType === "data") {
+      image = getImageData(image);
+    }
+    return image;
+  }
+  function getLoadableImageType(type) {
+    switch (type) {
+      case "auto":
+      case "data":
+        return getDefaultImageType();
+      default:
+        isImageTypeSupported(type);
+        return type;
+    }
+  }
+
+  // ../../node_modules/@loaders.gl/images/dist/image-loader.js
+  var EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp", "bmp", "ico", "svg", "avif"];
+  var MIME_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp", "image/avif", "image/bmp", "image/vnd.microsoft.icon", "image/svg+xml"];
+  var DEFAULT_IMAGE_LOADER_OPTIONS = {
+    image: {
+      type: "auto",
+      decode: true
+    }
+  };
+  var ImageLoader = {
+    id: "image",
+    module: "images",
+    name: "Images",
+    version: VERSION3,
+    mimeTypes: MIME_TYPES,
+    extensions: EXTENSIONS,
+    parse: parseImage,
+    tests: [(arrayBuffer2) => Boolean(getBinaryImageMetadata(new DataView(arrayBuffer2)))],
+    options: DEFAULT_IMAGE_LOADER_OPTIONS
+  };
+
+  // node_modules/@loaders.gl/textures/dist/lib/texture-api/generate-url.js
+  function generateUrl(getUrl, options, urlOptions) {
+    let url = typeof getUrl === "function" ? getUrl({
+      ...options,
+      ...urlOptions
+    }) : getUrl;
+    const baseUrl = options.baseUrl;
+    if (baseUrl) {
+      url = baseUrl[baseUrl.length - 1] === "/" ? `${baseUrl}${url}` : `${baseUrl}/${url}`;
+    }
+    return resolvePath(url);
+  }
+
+  // node_modules/@loaders.gl/textures/dist/lib/texture-api/async-deep-map.js
+  var isObject = (value) => value && typeof value === "object";
+  async function asyncDeepMap(tree, func) {
+    let options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    return await mapSubtree(tree, func, options);
+  }
+  async function mapSubtree(object, func, options) {
+    if (Array.isArray(object)) {
+      return await mapArray(object, func, options);
+    }
+    if (isObject(object)) {
+      return await mapObject(object, func, options);
+    }
+    const url = object;
+    return await func(url, options);
+  }
+  async function mapObject(object, func, options) {
+    const promises = [];
+    const values = {};
+    for (const key in object) {
+      const url = object[key];
+      const promise = mapSubtree(url, func, options).then((value) => {
+        values[key] = value;
+      });
+      promises.push(promise);
+    }
+    await Promise.all(promises);
+    return values;
+  }
+  async function mapArray(urlArray, func) {
+    let options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    const promises = urlArray.map((url) => mapSubtree(url, func, options));
+    return await Promise.all(promises);
+  }
+
+  // node_modules/@loaders.gl/textures/dist/lib/texture-api/deep-load.js
+  async function deepLoad(urlTree, load, options) {
+    return await asyncDeepMap(urlTree, (url) => shallowLoad(url, load, options));
+  }
+  async function shallowLoad(url, load, options) {
+    const response = await fetch(url, options.fetch);
+    const arrayBuffer2 = await response.arrayBuffer();
+    return await load(arrayBuffer2, options);
+  }
+
+  // node_modules/@loaders.gl/textures/dist/lib/texture-api/load-image.js
+  async function loadImageTexture(getUrl) {
+    let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    const imageUrls = await getImageUrls(getUrl, options);
+    return await deepLoad(imageUrls, ImageLoader.parse, options);
+  }
+  async function getImageUrls(getUrl, options) {
+    let urlOptions = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    const mipLevels = options && options.image && options.image.mipLevels || 0;
+    return mipLevels !== 0 ? await getMipmappedImageUrls(getUrl, mipLevels, options, urlOptions) : generateUrl(getUrl, options, urlOptions);
+  }
+  async function getMipmappedImageUrls(getUrl, mipLevels, options, urlOptions) {
+    const urls = [];
+    if (mipLevels === "auto") {
+      const url = generateUrl(getUrl, options, {
+        ...urlOptions,
+        lod: 0
+      });
+      const image = await shallowLoad(url, ImageLoader.parse, options);
+      const {
+        width,
+        height
+      } = getImageSize(image);
+      mipLevels = getMipLevels({
+        width,
+        height
+      });
+      urls.push(url);
+    }
+    assert3(mipLevels > 0);
+    for (let mipLevel = urls.length; mipLevel < mipLevels; ++mipLevel) {
+      const url = generateUrl(getUrl, options, {
+        ...urlOptions,
+        lod: mipLevel
+      });
+      urls.push(url);
+    }
+    return urls;
+  }
+  function getMipLevels(size) {
+    return 1 + Math.floor(Math.log2(Math.max(size.width, size.height)));
+  }
+
+  // src/pbr/pbr-environment.ts
+  function loadPBREnvironment(device, props) {
+    const brdfLutTexture = device.createTexture({
+      id: "brdfLUT",
+      sampler: {
+        wrapS: "clamp-to-edge",
+        wrapT: "clamp-to-edge",
+        minFilter: "linear",
+        maxFilter: "linear"
+      },
+      data: loadImageTexture(props.brdfLutUrl)
+    });
+    const diffuseEnvSampler = makeCube(device, {
+      id: "DiffuseEnvSampler",
+      getTextureForFace: (dir) => loadImageTexture(props.getTexUrl("diffuse", dir, 0)),
+      sampler: {
+        wrapS: "clamp-to-edge",
+        wrapT: "clamp-to-edge",
+        minFilter: "linear",
+        maxFilter: "linear"
+      }
+    });
+    const specularEnvSampler = makeCube(device, {
+      id: "SpecularEnvSampler",
+      getTextureForFace: (dir) => {
+        const imageArray = [];
+        for (let lod = 0; lod <= props.specularMipLevels - 1; lod++) {
+          imageArray.push(loadImageTexture(props.getTexUrl("specular", dir, lod)));
+        }
+        return imageArray;
+      },
+      sampler: {
+        wrapS: "clamp-to-edge",
+        wrapT: "clamp-to-edge",
+        minFilter: "linear",
+        maxFilter: "linear"
+      }
+    });
+    return {
+      brdfLutTexture,
+      diffuseEnvSampler,
+      specularEnvSampler
+    };
+  }
+  var FACES = [0, 1, 2, 3, 4, 5];
+  function makeCube(device, {
+    id,
+    getTextureForFace,
+    sampler
+  }) {
+    const data = {};
+    FACES.forEach((face) => {
+      data[String(face)] = getTextureForFace(face);
+    });
+    return device.createTexture({
+      id,
+      dimension: "cube",
+      mipmaps: false,
+      sampler,
+      data
+    });
+  }
+
   // ../shadertools/src/lib/glsl-utils/highlight.ts
   var glsl = (x) => `${x}`;
 
   // ../shadertools/src/lib/utils/assert.ts
-  function assert3(condition, message2) {
+  function assert5(condition, message2) {
     if (!condition) {
       throw new Error(message2 || "shadertools: assertion failed.");
     }
@@ -2887,7 +3517,7 @@ ${htmlLog}
     for (const [key, propsValidator] of Object.entries(propValidators)) {
       if (properties && key in properties && !propsValidator.private) {
         if (propsValidator.validate) {
-          assert3(propsValidator.validate(properties[key], propsValidator), `${errorMessage}: invalid ${key}`);
+          assert5(propsValidator.validate(properties[key], propsValidator), `${errorMessage}: invalid ${key}`);
         }
         validated[key] = properties[key];
       } else {
@@ -3071,7 +3701,7 @@ ${htmlLog}
         if (module instanceof ShaderModuleInstance) {
           return module;
         }
-        assert3(typeof module !== "string", `Shader module use by name is deprecated. Import shader module '${JSON.stringify(module)}' and use it directly.`);
+        assert5(typeof module !== "string", `Shader module use by name is deprecated. Import shader module '${JSON.stringify(module)}' and use it directly.`);
         if (!module.name) {
           console.warn("shader module has no name");
           module.name = `shader-module-${index++}`;
@@ -3093,7 +3723,7 @@ ${htmlLog}
         defines = {},
         inject = {}
       } = props;
-      assert3(typeof name2 === "string");
+      assert5(typeof name2 === "string");
       this.name = name2;
       this.vs = vs3;
       this.fs = fs3;
@@ -3116,7 +3746,7 @@ ${htmlLog}
           moduleSource = this.fs || "";
           break;
         default:
-          assert3(false);
+          assert5(false);
       }
       const moduleName = this.name.toUpperCase().replace(/[^0-9a-z]/gi, "_");
       return `// ----- MODULE ${this.name} ---------------
@@ -3165,7 +3795,7 @@ ${moduleSource}
         const propDef = propTypes[key];
         if (key in opts && !propDef.private) {
           if (propDef.validate) {
-            assert3(propDef.validate(opts[key], propDef), `${this.name}: invalid ${key}`);
+            assert5(propDef.validate(opts[key], propDef), `${this.name}: invalid ${key}`);
           }
           uniforms[key] = opts[key];
         } else {
@@ -3529,7 +4159,7 @@ precision highp float;
       inject = {},
       log: log3
     } = options;
-    assert3(typeof source === "string", "shader source must be a string");
+    assert5(typeof source === "string", "shader source must be a string");
     const coreSource = source;
     const allDefines = {};
     modules.forEach((module) => {
@@ -3603,7 +4233,7 @@ precision highp float;
       prologue = true,
       log: log3
     } = options;
-    assert3(typeof source === "string", "shader source must be a string");
+    assert5(typeof source === "string", "shader source must be a string");
     const sourceVersion = language === "glsl" ? getShaderInfo2(source).version : -1;
     const targetVersion = platformInfo.shaderLanguageVersion;
     const sourceVersionDirective = sourceVersion === 100 ? "#version 100" : "#version 300 es";
@@ -4127,7 +4757,7 @@ ${getApplicationDefines(allDefines)}
   }
 
   // ../../node_modules/@math.gl/core/dist/lib/assert.js
-  function assert4(condition, message2) {
+  function assert6(condition, message2) {
     if (!condition) {
       throw new Error("math.gl assertion ".concat(message2));
     }
@@ -4216,11 +4846,11 @@ ${getApplicationDefines(allDefines)}
       return this.distanceSquared(vector);
     }
     getComponent(i) {
-      assert4(i >= 0 && i < this.ELEMENTS, "index is out of range");
+      assert6(i >= 0 && i < this.ELEMENTS, "index is out of range");
       return checkNumber(this[i]);
     }
     setComponent(i, value) {
-      assert4(i >= 0 && i < this.ELEMENTS, "index is out of range");
+      assert6(i >= 0 && i < this.ELEMENTS, "index is out of range");
       this[i] = value;
       return this.check();
     }
@@ -6985,6 +7615,10 @@ vec4 pbr_filterColor(vec4 colorUnused)
         const moduleName = name2;
         const moduleProps = props[moduleName];
         const module = this.modules[moduleName];
+        if (!module) {
+          log.warn(`Module ${name2} not found`)();
+          continue;
+        }
         const oldUniforms = this.moduleUniforms[moduleName];
         const uniforms = module.getUniforms?.(moduleProps, this.moduleUniforms[moduleName]) || moduleProps;
         this.moduleUniforms[moduleName] = {
@@ -7203,6 +7837,8 @@ vec4 pbr_filterColor(vec4 colorUnused)
   });
 
   // ../engine/src/model/model.ts
+  var LOG_DRAW_PRIORITY = 2;
+  var LOG_DRAW_TIMEOUT = 1e4;
   var _Model = class {
     userData = {};
     instanceCount = 0;
@@ -7298,16 +7934,21 @@ vec4 pbr_filterColor(vec4 colorUnused)
     }
     draw(renderPass) {
       this.predraw();
-      this.pipeline = this._updatePipeline();
-      this.pipeline.setBindings(this.bindings);
-      this.pipeline.setUniforms(this.uniforms);
-      this.pipeline.draw({
-        renderPass,
-        vertexArray: this.vertexArray,
-        vertexCount: this.vertexCount,
-        instanceCount: this.instanceCount,
-        transformFeedback: this.transformFeedback
-      });
+      try {
+        this._logDrawCallStart();
+        this.pipeline = this._updatePipeline();
+        this.pipeline.setBindings(this.bindings);
+        this.pipeline.setUniforms(this.uniforms);
+        this.pipeline.draw({
+          renderPass,
+          vertexArray: this.vertexArray,
+          vertexCount: this.vertexCount,
+          instanceCount: this.instanceCount,
+          transformFeedback: this.transformFeedback
+        });
+      } finally {
+        this._logDrawCallEnd();
+      }
     }
     setGeometry(geometry) {
       const gpuGeometry = geometry && makeGPUGeometry(this.device, geometry);
@@ -7448,6 +8089,27 @@ vec4 pbr_filterColor(vec4 colorUnused)
       }
       return this.pipeline;
     }
+    _lastLogTime = 0;
+    _logOpen = false;
+    _logDrawCallStart() {
+      const logDrawTimeout = log.level > 3 ? 0 : LOG_DRAW_TIMEOUT;
+      if (Date.now() - this._lastLogTime < logDrawTimeout) {
+        return void 0;
+      }
+      this._lastLogTime = Date.now();
+      this._logOpen = true;
+      log.group(LOG_DRAW_PRIORITY, `>>> DRAWING MODEL ${this.id}`, {
+        collapsed: log.level <= 2
+      })();
+    }
+    _logDrawCallEnd() {
+      if (this._logOpen) {
+        const shaderLayoutTable = getDebugTableForShaderLayout(this.pipeline.shaderLayout);
+        log.table(LOG_DRAW_PRIORITY, shaderLayoutTable)();
+        log.groupEnd(LOG_DRAW_PRIORITY)();
+        this._logOpen = false;
+      }
+    }
   };
   var Model = _Model;
   __publicField(Model, "defaultProps", {
@@ -7916,7 +8578,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
     this.cached = [this.size, this.type, this.normalized, this.stride, this.offset].join(":");
   };
   var OESVertexArrayObject = function OESVertexArrayObject2(gl) {
-    const self = this;
+    const self2 = this;
     this.gl = gl;
     wrapGLError(gl);
     const original = this.original = {
@@ -7928,23 +8590,23 @@ vec4 pbr_filterColor(vec4 colorUnused)
       vertexAttribPointer: gl.vertexAttribPointer
     };
     gl.getParameter = function getParameter(pname) {
-      if (pname === self.VERTEX_ARRAY_BINDING_OES) {
-        if (self.currentVertexArrayObject === self.defaultVertexArrayObject) {
+      if (pname === self2.VERTEX_ARRAY_BINDING_OES) {
+        if (self2.currentVertexArrayObject === self2.defaultVertexArrayObject) {
           return null;
         }
-        return self.currentVertexArrayObject;
+        return self2.currentVertexArrayObject;
       }
       return original.getParameter.apply(this, arguments);
     };
     gl.enableVertexAttribArray = function enableVertexAttribArray(index2) {
-      const vao = self.currentVertexArrayObject;
+      const vao = self2.currentVertexArrayObject;
       vao.maxAttrib = Math.max(vao.maxAttrib, index2);
       const attrib = vao.attribs[index2];
       attrib.enabled = true;
       return original.enableVertexAttribArray.apply(this, arguments);
     };
     gl.disableVertexAttribArray = function disableVertexAttribArray(index2) {
-      const vao = self.currentVertexArrayObject;
+      const vao = self2.currentVertexArrayObject;
       vao.maxAttrib = Math.max(vao.maxAttrib, index2);
       const attrib = vao.attribs[index2];
       attrib.enabled = false;
@@ -7953,17 +8615,17 @@ vec4 pbr_filterColor(vec4 colorUnused)
     gl.bindBuffer = function bindBuffer2(target, buffer) {
       switch (target) {
         case gl.ARRAY_BUFFER:
-          self.currentArrayBuffer = buffer;
+          self2.currentArrayBuffer = buffer;
           break;
         case gl.ELEMENT_ARRAY_BUFFER:
-          self.currentVertexArrayObject.elementArrayBuffer = buffer;
+          self2.currentVertexArrayObject.elementArrayBuffer = buffer;
           break;
         default:
       }
       return original.bindBuffer.apply(this, arguments);
     };
     gl.getVertexAttrib = function getVertexAttrib(index2, pname) {
-      const vao = self.currentVertexArrayObject;
+      const vao = self2.currentVertexArrayObject;
       const attrib = vao.attribs[index2];
       switch (pname) {
         case gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
@@ -7983,10 +8645,10 @@ vec4 pbr_filterColor(vec4 colorUnused)
       }
     };
     gl.vertexAttribPointer = function vertexAttribPointer(indx, size, type, normalized, stride, offset) {
-      const vao = self.currentVertexArrayObject;
+      const vao = self2.currentVertexArrayObject;
       vao.maxAttrib = Math.max(vao.maxAttrib, indx);
       const attrib = vao.attribs[indx];
-      attrib.buffer = self.currentArrayBuffer;
+      attrib.buffer = self2.currentArrayBuffer;
       attrib.size = size;
       attrib.type = type;
       attrib.normalized = normalized;
@@ -8001,7 +8663,7 @@ vec4 pbr_filterColor(vec4 colorUnused)
     if (gl.canvas) {
       gl.canvas.addEventListener("webglcontextrestored", () => {
         log2("OESVertexArrayObject emulation library context restored");
-        self.reset_();
+        self2.reset_();
       }, true);
     }
     this.reset_();
@@ -9064,8 +9726,8 @@ vec4 pbr_filterColor(vec4 colorUnused)
   }
   function initializeExtensions(gl) {
     const contextState = getContextData(gl);
-    const EXTENSIONS = gl.getSupportedExtensions() || [];
-    for (const extensionName of EXTENSIONS) {
+    const EXTENSIONS2 = gl.getSupportedExtensions() || [];
+    for (const extensionName of EXTENSIONS2) {
       const extension = gl.getExtension(extensionName);
       contextState._extensions[extensionName] = extension;
     }
@@ -13286,14 +13948,14 @@ ${source2}`;
       };
     }
     const UNIFORM_NAME_REGEXP = /([^[]*)(\[[0-9]+\])?/;
-    const matches = UNIFORM_NAME_REGEXP.exec(name2);
-    if (!matches || matches.length < 2) {
+    const matches2 = UNIFORM_NAME_REGEXP.exec(name2);
+    if (!matches2 || matches2.length < 2) {
       throw new Error(`Failed to parse GLSL uniform name ${name2}`);
     }
     return {
-      name: matches[1],
-      length: matches[2] ? 1 : 0,
-      isArray: Boolean(matches[2])
+      name: matches2[1],
+      length: matches2[2] ? 1 : 0,
+      isArray: Boolean(matches2[2])
     };
   }