@luma.gl/gltf 9.1.9 → 9.2.0-alpha.2

package/dist/dist.dev.js

@@ -4,6 +4,7 @@
   else if (typeof define === 'function' && define.amd) define([], factory);
         else if (typeof exports === 'object') exports['luma'] = factory();
   else root['luma'] = factory();})(globalThis, function () {
+"use strict";
 var __exports__ = (() => {
   var __create = Object.create;
   var __defProp = Object.defineProperty;
@@ -51,6 +52,13 @@ var __exports__ = (() => {
     }
   });
 
+  // external-global-plugin:@luma.gl/constants
+  var require_constants = __commonJS({
+    "external-global-plugin:@luma.gl/constants"(exports, module) {
+      module.exports = globalThis.luma;
+    }
+  });
+
   // external-global-plugin:@luma.gl/shadertools
   var require_shadertools = __commonJS({
     "external-global-plugin:@luma.gl/shadertools"(exports, module) {
@@ -68,170 +76,6 @@ var __exports__ = (() => {
   });
   __reExport(bundle_exports, __toESM(require_core(), 1));
 
-  // src/pbr/parse-pbr-material.ts
-  var import_core = __toESM(require_core(), 1);
-  function parsePBRMaterial(device, material, attributes, options) {
-    const parsedMaterial = {
-      defines: {
-        // TODO: Use EXT_sRGB if available (Standard in WebGL 2.0)
-        MANUAL_SRGB: 1,
-        SRGB_FAST_APPROXIMATION: 1
-      },
-      bindings: {},
-      uniforms: {
-        // TODO: find better values?
-        camera: [0, 0, 0],
-        // Model should override
-        metallicRoughnessValues: [1, 1]
-        // Default is 1 and 1
-      },
-      parameters: {},
-      glParameters: {},
-      generatedTextures: []
-    };
-    parsedMaterial.defines.USE_TEX_LOD = 1;
-    const { imageBasedLightingEnvironment } = options;
-    if (imageBasedLightingEnvironment) {
-      parsedMaterial.bindings.pbr_diffuseEnvSampler = imageBasedLightingEnvironment.diffuseEnvSampler.texture;
-      parsedMaterial.bindings.pbr_specularEnvSampler = imageBasedLightingEnvironment.specularEnvSampler.texture;
-      parsedMaterial.bindings.pbr_BrdfLUT = imageBasedLightingEnvironment.brdfLutTexture.texture;
-      parsedMaterial.uniforms.scaleIBLAmbient = [1, 1];
-    }
-    if (options?.pbrDebug) {
-      parsedMaterial.defines.PBR_DEBUG = 1;
-      parsedMaterial.uniforms.scaleDiffBaseMR = [0, 0, 0, 0];
-      parsedMaterial.uniforms.scaleFGDSpec = [0, 0, 0, 0];
-    }
-    if (attributes.NORMAL)
-      parsedMaterial.defines.HAS_NORMALS = 1;
-    if (attributes.TANGENT && options?.useTangents)
-      parsedMaterial.defines.HAS_TANGENTS = 1;
-    if (attributes.TEXCOORD_0)
-      parsedMaterial.defines.HAS_UV = 1;
-    if (options?.imageBasedLightingEnvironment)
-      parsedMaterial.defines.USE_IBL = 1;
-    if (options?.lights)
-      parsedMaterial.defines.USE_LIGHTS = 1;
-    if (material) {
-      parseMaterial(device, material, parsedMaterial);
-    }
-    return parsedMaterial;
-  }
-  function parseMaterial(device, material, parsedMaterial) {
-    parsedMaterial.uniforms.unlit = Boolean(material.unlit);
-    if (material.pbrMetallicRoughness) {
-      parsePbrMetallicRoughness(device, material.pbrMetallicRoughness, parsedMaterial);
-    }
-    if (material.normalTexture) {
-      addTexture(
-        device,
-        material.normalTexture,
-        "pbr_normalSampler",
-        "HAS_NORMALMAP",
-        parsedMaterial
-      );
-      const { scale: scale4 = 1 } = material.normalTexture;
-      parsedMaterial.uniforms.normalScale = scale4;
-    }
-    if (material.occlusionTexture) {
-      addTexture(
-        device,
-        material.occlusionTexture,
-        "pbr_occlusionSampler",
-        "HAS_OCCLUSIONMAP",
-        parsedMaterial
-      );
-      const { strength = 1 } = material.occlusionTexture;
-      parsedMaterial.uniforms.occlusionStrength = strength;
-    }
-    if (material.emissiveTexture) {
-      addTexture(
-        device,
-        material.emissiveTexture,
-        "pbr_emissiveSampler",
-        "HAS_EMISSIVEMAP",
-        parsedMaterial
-      );
-      parsedMaterial.uniforms.emissiveFactor = material.emissiveFactor || [0, 0, 0];
-    }
-    switch (material.alphaMode) {
-      case "MASK":
-        const { alphaCutoff = 0.5 } = material;
-        parsedMaterial.defines.ALPHA_CUTOFF = 1;
-        parsedMaterial.uniforms.alphaCutoff = alphaCutoff;
-        break;
-      case "BLEND":
-        import_core.log.warn("glTF BLEND alphaMode might not work well because it requires mesh sorting")();
-        parsedMaterial.parameters.blendColorOperation = "add";
-        parsedMaterial.parameters.blendColorSrcFactor = "src-alpha";
-        parsedMaterial.parameters.blendColorDstFactor = "one-minus-src-alpha";
-        parsedMaterial.parameters.blendAlphaOperation = "add";
-        parsedMaterial.parameters.blendAlphaSrcFactor = "one";
-        parsedMaterial.parameters.blendAlphaDstFactor = "one-minus-src-alpha";
-        parsedMaterial.glParameters.blend = true;
-        parsedMaterial.glParameters.blendEquation = 32774 /* FUNC_ADD */;
-        parsedMaterial.glParameters.blendFunc = [
-          770 /* SRC_ALPHA */,
-          771 /* ONE_MINUS_SRC_ALPHA */,
-          1 /* ONE */,
-          771 /* ONE_MINUS_SRC_ALPHA */
-        ];
-        break;
-    }
-  }
-  function parsePbrMetallicRoughness(device, pbrMetallicRoughness, parsedMaterial) {
-    if (pbrMetallicRoughness.baseColorTexture) {
-      addTexture(
-        device,
-        pbrMetallicRoughness.baseColorTexture,
-        "pbr_baseColorSampler",
-        "HAS_BASECOLORMAP",
-        parsedMaterial
-      );
-    }
-    parsedMaterial.uniforms.baseColorFactor = pbrMetallicRoughness.baseColorFactor || [1, 1, 1, 1];
-    if (pbrMetallicRoughness.metallicRoughnessTexture) {
-      addTexture(
-        device,
-        pbrMetallicRoughness.metallicRoughnessTexture,
-        "pbr_metallicRoughnessSampler",
-        "HAS_METALROUGHNESSMAP",
-        parsedMaterial
-      );
-    }
-    const { metallicFactor = 1, roughnessFactor = 1 } = pbrMetallicRoughness;
-    parsedMaterial.uniforms.metallicRoughnessValues = [metallicFactor, roughnessFactor];
-  }
-  function addTexture(device, gltfTexture, uniformName, define = null, parsedMaterial) {
-    const parameters = gltfTexture?.texture?.sampler?.parameters || {};
-    const image = gltfTexture.texture.source.image;
-    let textureOptions;
-    let specialTextureParameters = {};
-    if (image.compressed) {
-      textureOptions = image;
-      specialTextureParameters = {
-        [10241 /* TEXTURE_MIN_FILTER */]: image.data.length > 1 ? 9985 /* LINEAR_MIPMAP_NEAREST */ : 9729 /* LINEAR */
-      };
-    } else {
-      textureOptions = { data: image };
-    }
-    const texture = device.createTexture({
-      id: gltfTexture.uniformName || gltfTexture.id,
-      parameters: {
-        ...parameters,
-        ...specialTextureParameters
-      },
-      pixelStore: {
-        [37440 /* UNPACK_FLIP_Y_WEBGL */]: false
-      },
-      ...textureOptions
-    });
-    parsedMaterial.bindings[uniformName] = texture;
-    if (define)
-      parsedMaterial.defines[define] = 1;
-    parsedMaterial.generatedTextures.push(texture);
-  }
-
   // src/pbr/pbr-environment.ts
   var import_engine = __toESM(require_engine(), 1);
 
@@ -277,7 +121,7 @@ var __exports__ = (() => {
   }
 
   // ../../node_modules/@loaders.gl/images/dist/lib/utils/version.js
-  var VERSION = true ? "4.2.1" : "latest";
+  var VERSION = true ? "4.3.2" : "latest";
 
   // ../../node_modules/@loaders.gl/images/dist/lib/category-api/image-type.js
   var parseImageNode = globalThis.loaders?.parseImageNode;
@@ -774,10 +618,10 @@ var __exports__ = (() => {
     const brdfLutTexture = new import_engine.AsyncTexture(device, {
       id: "brdfLUT",
       sampler: {
-        wrapS: "clamp-to-edge",
-        wrapT: "clamp-to-edge",
+        addressModeU: "clamp-to-edge",
+        addressModeV: "clamp-to-edge",
         minFilter: "linear",
-        maxFilter: "linear"
+        magFilter: "linear"
       },
       // Texture accepts a promise that returns an image as data (Async Textures)
       data: loadImageTexture(props.brdfLutUrl)
@@ -786,10 +630,10 @@ var __exports__ = (() => {
       id: "DiffuseEnvSampler",
       getTextureForFace: (dir) => loadImageTexture(props.getTexUrl("diffuse", dir, 0)),
       sampler: {
-        wrapS: "clamp-to-edge",
-        wrapT: "clamp-to-edge",
+        addressModeU: "clamp-to-edge",
+        addressModeV: "clamp-to-edge",
         minFilter: "linear",
-        maxFilter: "linear"
+        magFilter: "linear"
       }
     });
     const specularEnvSampler = makeCube(device, {
@@ -802,11 +646,11 @@ var __exports__ = (() => {
         return imageArray;
       },
       sampler: {
-        wrapS: "clamp-to-edge",
-        wrapT: "clamp-to-edge",
+        addressModeU: "clamp-to-edge",
+        addressModeV: "clamp-to-edge",
         minFilter: "linear",
         // [GL.TEXTURE_MIN_FILTER]: GL.LINEAR_MIPMAP_LINEAR,
-        maxFilter: "linear"
+        magFilter: "linear"
       }
     });
     return {
@@ -835,96 +679,311 @@ var __exports__ = (() => {
     });
   }
 
-  // src/gltf/gltf-instantiator.ts
-  var import_engine3 = __toESM(require_engine(), 1);
+  // src/parsers/parse-pbr-material.ts
+  var import_constants2 = __toESM(require_constants(), 1);
+  var import_core = __toESM(require_core(), 1);
 
-  // ../../node_modules/@math.gl/core/dist/lib/common.js
-  var RADIANS_TO_DEGREES = 1 / Math.PI * 180;
-  var DEGREES_TO_RADIANS = 1 / 180 * Math.PI;
-  var DEFAULT_CONFIG = {
-    EPSILON: 1e-12,
-    debug: false,
-    precision: 4,
-    printTypes: false,
-    printDegrees: false,
-    printRowMajor: true,
-    _cartographicRadians: false
-  };
-  globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG } };
-  var config = globalThis.mathgl.config;
-  function formatValue(value, { precision = config.precision } = {}) {
-    value = round(value);
-    return `${parseFloat(value.toPrecision(precision))}`;
-  }
-  function isArray(value) {
-    return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
+  // src/webgl-to-webgpu/convert-webgl-sampler.ts
+  var import_constants = __toESM(require_constants(), 1);
+  function convertSampler(gltfSampler) {
+    return {
+      addressModeU: convertSamplerWrapMode(gltfSampler.wrapS),
+      addressModeV: convertSamplerWrapMode(gltfSampler.wrapT),
+      magFilter: convertSamplerMagFilter(gltfSampler.magFilter),
+      ...convertSamplerMinFilter(gltfSampler.minFilter)
+    };
   }
-  function equals(a, b, epsilon) {
-    const oldEpsilon = config.EPSILON;
-    if (epsilon) {
-      config.EPSILON = epsilon;
-    }
-    try {
-      if (a === b) {
-        return true;
-      }
-      if (isArray(a) && isArray(b)) {
-        if (a.length !== b.length) {
-          return false;
-        }
-        for (let i = 0; i < a.length; ++i) {
-          if (!equals(a[i], b[i])) {
-            return false;
-          }
-        }
-        return true;
-      }
-      if (a && a.equals) {
-        return a.equals(b);
-      }
-      if (b && b.equals) {
-        return b.equals(a);
-      }
-      if (typeof a === "number" && typeof b === "number") {
-        return Math.abs(a - b) <= config.EPSILON * Math.max(1, Math.abs(a), Math.abs(b));
-      }
-      return false;
-    } finally {
-      config.EPSILON = oldEpsilon;
+  function convertSamplerWrapMode(mode) {
+    switch (mode) {
+      case import_constants.GL.CLAMP_TO_EDGE:
+        return "clamp-to-edge";
+      case import_constants.GL.REPEAT:
+        return "repeat";
+      case import_constants.GL.MIRRORED_REPEAT:
+        return "mirror-repeat";
+      default:
+        return void 0;
     }
   }
-  function round(value) {
-    return Math.round(value / config.EPSILON) * config.EPSILON;
+  function convertSamplerMagFilter(mode) {
+    switch (mode) {
+      case import_constants.GL.NEAREST:
+        return "nearest";
+      case import_constants.GL.LINEAR:
+        return "linear";
+      default:
+        return void 0;
+    }
+  }
+  function convertSamplerMinFilter(mode) {
+    switch (mode) {
+      case import_constants.GL.NEAREST:
+        return { minFilter: "nearest" };
+      case import_constants.GL.LINEAR:
+        return { minFilter: "linear" };
+      case import_constants.GL.NEAREST_MIPMAP_NEAREST:
+        return { minFilter: "nearest", mipmapFilter: "nearest" };
+      case import_constants.GL.LINEAR_MIPMAP_NEAREST:
+        return { minFilter: "linear", mipmapFilter: "nearest" };
+      case import_constants.GL.NEAREST_MIPMAP_LINEAR:
+        return { minFilter: "nearest", mipmapFilter: "linear" };
+      case import_constants.GL.LINEAR_MIPMAP_LINEAR:
+        return { minFilter: "linear", mipmapFilter: "linear" };
+      default:
+        return {};
+    }
   }
 
-  // ../../node_modules/@math.gl/core/dist/classes/base/math-array.js
-  var MathArray = class extends Array {
-    // Common methods
-    /**
-     * Clone the current object
-     * @returns a new copy of this object
-     */
-    clone() {
-      return new this.constructor().copy(this);
+  // src/parsers/parse-pbr-material.ts
+  function parsePBRMaterial(device, material, attributes, options) {
+    const parsedMaterial = {
+      defines: {
+        // TODO: Use EXT_sRGB if available (Standard in WebGL 2.0)
+        MANUAL_SRGB: true,
+        SRGB_FAST_APPROXIMATION: true
+      },
+      bindings: {},
+      uniforms: {
+        // TODO: find better values?
+        camera: [0, 0, 0],
+        // Model should override
+        metallicRoughnessValues: [1, 1]
+        // Default is 1 and 1
+      },
+      parameters: {},
+      glParameters: {},
+      generatedTextures: []
+    };
+    parsedMaterial.defines["USE_TEX_LOD"] = true;
+    const { imageBasedLightingEnvironment } = options;
+    if (imageBasedLightingEnvironment) {
+      parsedMaterial.bindings.pbr_diffuseEnvSampler = imageBasedLightingEnvironment.diffuseEnvSampler.texture;
+      parsedMaterial.bindings.pbr_specularEnvSampler = imageBasedLightingEnvironment.specularEnvSampler.texture;
+      parsedMaterial.bindings.pbr_BrdfLUT = imageBasedLightingEnvironment.brdfLutTexture.texture;
+      parsedMaterial.uniforms.scaleIBLAmbient = [1, 1];
     }
-    fromArray(array, offset = 0) {
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        this[i] = array[i + offset];
-      }
-      return this.check();
+    if (options?.pbrDebug) {
+      parsedMaterial.defines["PBR_DEBUG"] = true;
+      parsedMaterial.uniforms.scaleDiffBaseMR = [0, 0, 0, 0];
+      parsedMaterial.uniforms.scaleFGDSpec = [0, 0, 0, 0];
     }
-    toArray(targetArray = [], offset = 0) {
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        targetArray[offset + i] = this[i];
-      }
-      return targetArray;
+    if (attributes["NORMAL"])
+      parsedMaterial.defines["HAS_NORMALS"] = true;
+    if (attributes["TANGENT"] && options?.useTangents)
+      parsedMaterial.defines["HAS_TANGENTS"] = true;
+    if (attributes["TEXCOORD_0"])
+      parsedMaterial.defines["HAS_UV"] = true;
+    if (options?.imageBasedLightingEnvironment)
+      parsedMaterial.defines["USE_IBL"] = true;
+    if (options?.lights)
+      parsedMaterial.defines["USE_LIGHTS"] = true;
+    if (material) {
+      parseMaterial(device, material, parsedMaterial);
     }
-    toObject(targetObject) {
-      return targetObject;
+    return parsedMaterial;
+  }
+  function parseMaterial(device, material, parsedMaterial) {
+    parsedMaterial.uniforms.unlit = Boolean(material.unlit);
+    if (material.pbrMetallicRoughness) {
+      parsePbrMetallicRoughness(device, material.pbrMetallicRoughness, parsedMaterial);
     }
-    from(arrayOrObject) {
-      return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : (
-        // @ts-ignore
+    if (material.normalTexture) {
+      addTexture(
+        device,
+        material.normalTexture,
+        "pbr_normalSampler",
+        "HAS_NORMALMAP",
+        parsedMaterial
+      );
+      const { scale: scale4 = 1 } = material.normalTexture;
+      parsedMaterial.uniforms.normalScale = scale4;
+    }
+    if (material.occlusionTexture) {
+      addTexture(
+        device,
+        material.occlusionTexture,
+        "pbr_occlusionSampler",
+        "HAS_OCCLUSIONMAP",
+        parsedMaterial
+      );
+      const { strength = 1 } = material.occlusionTexture;
+      parsedMaterial.uniforms.occlusionStrength = strength;
+    }
+    if (material.emissiveTexture) {
+      addTexture(
+        device,
+        material.emissiveTexture,
+        "pbr_emissiveSampler",
+        "HAS_EMISSIVEMAP",
+        parsedMaterial
+      );
+      parsedMaterial.uniforms.emissiveFactor = material.emissiveFactor || [0, 0, 0];
+    }
+    switch (material.alphaMode || "MASK") {
+      case "MASK":
+        const { alphaCutoff = 0.5 } = material;
+        parsedMaterial.defines["ALPHA_CUTOFF"] = true;
+        parsedMaterial.uniforms.alphaCutoff = alphaCutoff;
+        break;
+      case "BLEND":
+        import_core.log.warn("glTF BLEND alphaMode might not work well because it requires mesh sorting")();
+        parsedMaterial.parameters.blend = true;
+        parsedMaterial.parameters.blendColorOperation = "add";
+        parsedMaterial.parameters.blendColorSrcFactor = "src-alpha";
+        parsedMaterial.parameters.blendColorDstFactor = "one-minus-src-alpha";
+        parsedMaterial.parameters.blendAlphaOperation = "add";
+        parsedMaterial.parameters.blendAlphaSrcFactor = "one";
+        parsedMaterial.parameters.blendAlphaDstFactor = "one-minus-src-alpha";
+        parsedMaterial.glParameters["blend"] = true;
+        parsedMaterial.glParameters["blendEquation"] = import_constants2.GL.FUNC_ADD;
+        parsedMaterial.glParameters["blendFunc"] = [
+          import_constants2.GL.SRC_ALPHA,
+          import_constants2.GL.ONE_MINUS_SRC_ALPHA,
+          import_constants2.GL.ONE,
+          import_constants2.GL.ONE_MINUS_SRC_ALPHA
+        ];
+        break;
+    }
+  }
+  function parsePbrMetallicRoughness(device, pbrMetallicRoughness, parsedMaterial) {
+    if (pbrMetallicRoughness.baseColorTexture) {
+      addTexture(
+        device,
+        pbrMetallicRoughness.baseColorTexture,
+        "pbr_baseColorSampler",
+        "HAS_BASECOLORMAP",
+        parsedMaterial
+      );
+    }
+    parsedMaterial.uniforms.baseColorFactor = pbrMetallicRoughness.baseColorFactor || [1, 1, 1, 1];
+    if (pbrMetallicRoughness.metallicRoughnessTexture) {
+      addTexture(
+        device,
+        pbrMetallicRoughness.metallicRoughnessTexture,
+        "pbr_metallicRoughnessSampler",
+        "HAS_METALROUGHNESSMAP",
+        parsedMaterial
+      );
+    }
+    const { metallicFactor = 1, roughnessFactor = 1 } = pbrMetallicRoughness;
+    parsedMaterial.uniforms.metallicRoughnessValues = [metallicFactor, roughnessFactor];
+  }
+  function addTexture(device, gltfTexture, uniformName, define, parsedMaterial) {
+    const image = gltfTexture.texture.source.image;
+    let textureOptions;
+    if (image.compressed) {
+      textureOptions = image;
+    } else {
+      textureOptions = { data: image };
+    }
+    const gltfSampler = {
+      wrapS: 10497,
+      // default REPEAT S (U) wrapping mode.
+      wrapT: 10497,
+      // default REPEAT T (V) wrapping mode.
+      ...gltfTexture?.texture?.sampler
+    };
+    const texture = device.createTexture({
+      id: gltfTexture.uniformName || gltfTexture.id,
+      sampler: convertSampler(gltfSampler),
+      ...textureOptions
+    });
+    parsedMaterial.bindings[uniformName] = texture;
+    if (define)
+      parsedMaterial.defines[define] = true;
+    parsedMaterial.generatedTextures.push(texture);
+  }
+
+  // src/parsers/parse-gltf.ts
+  var import_engine3 = __toESM(require_engine(), 1);
+
+  // ../../node_modules/@math.gl/core/dist/lib/common.js
+  var RADIANS_TO_DEGREES = 1 / Math.PI * 180;
+  var DEGREES_TO_RADIANS = 1 / 180 * Math.PI;
+  var DEFAULT_CONFIG = {
+    EPSILON: 1e-12,
+    debug: false,
+    precision: 4,
+    printTypes: false,
+    printDegrees: false,
+    printRowMajor: true,
+    _cartographicRadians: false
+  };
+  globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG } };
+  var config = globalThis.mathgl.config;
+  function formatValue(value, { precision = config.precision } = {}) {
+    value = round(value);
+    return `${parseFloat(value.toPrecision(precision))}`;
+  }
+  function isArray(value) {
+    return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
+  }
+  function equals(a, b, epsilon) {
+    const oldEpsilon = config.EPSILON;
+    if (epsilon) {
+      config.EPSILON = epsilon;
+    }
+    try {
+      if (a === b) {
+        return true;
+      }
+      if (isArray(a) && isArray(b)) {
+        if (a.length !== b.length) {
+          return false;
+        }
+        for (let i = 0; i < a.length; ++i) {
+          if (!equals(a[i], b[i])) {
+            return false;
+          }
+        }
+        return true;
+      }
+      if (a && a.equals) {
+        return a.equals(b);
+      }
+      if (b && b.equals) {
+        return b.equals(a);
+      }
+      if (typeof a === "number" && typeof b === "number") {
+        return Math.abs(a - b) <= config.EPSILON * Math.max(1, Math.abs(a), Math.abs(b));
+      }
+      return false;
+    } finally {
+      config.EPSILON = oldEpsilon;
+    }
+  }
+  function round(value) {
+    return Math.round(value / config.EPSILON) * config.EPSILON;
+  }
+
+  // ../../node_modules/@math.gl/core/dist/classes/base/math-array.js
+  var MathArray = class extends Array {
+    // Common methods
+    /**
+     * Clone the current object
+     * @returns a new copy of this object
+     */
+    clone() {
+      return new this.constructor().copy(this);
+    }
+    fromArray(array, offset = 0) {
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] = array[i + offset];
+      }
+      return this.check();
+    }
+    toArray(targetArray = [], offset = 0) {
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        targetArray[offset + i] = this[i];
+      }
+      return targetArray;
+    }
+    toObject(targetObject) {
+      return targetObject;
+    }
+    from(arrayOrObject) {
+      return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : (
+        // @ts-ignore
         this.fromObject(arrayOrObject)
       );
     }
@@ -1564,8 +1623,8 @@ var __exports__ = (() => {
       vec4_transformMat2(this, this, matrix2);
       return this.check();
     }
-    transformByQuaternion(quaternion2) {
-      transformQuat(this, this, quaternion2);
+    transformByQuaternion(quaternion) {
+      transformQuat(this, this, quaternion);
       return this.check();
     }
     // three.js compatibility
@@ -2549,8 +2608,8 @@ var __exports__ = (() => {
      * @param quaternion Quaternion to create matrix from
      * @returns self
      */
-    fromQuaternion(quaternion2) {
-      fromQuat(this, quaternion2);
+    fromQuaternion(quaternion) {
+      fromQuat(this, quaternion);
       return this.check();
     }
     /**
@@ -3409,184 +3468,26 @@ var __exports__ = (() => {
     }
   };
 
-  // src/gltf/gltf-animator.ts
-  var import_core2 = __toESM(require_core(), 1);
-  var ATTRIBUTE_TYPE_TO_COMPONENTS = {
-    SCALAR: 1,
-    VEC2: 2,
-    VEC3: 3,
-    VEC4: 4,
-    MAT2: 4,
-    MAT3: 9,
-    MAT4: 16
-  };
-  var ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {
-    5120: Int8Array,
-    5121: Uint8Array,
-    5122: Int16Array,
-    5123: Uint16Array,
-    5125: Uint32Array,
-    5126: Float32Array
-  };
-  var GLTFAnimation = class {
-    name;
-    startTime = 0;
-    playing = true;
-    speed = 1;
-    channels = [];
-    constructor(props) {
-      Object.assign(this, props);
-    }
-    animate(timeMs) {
-      if (!this.playing) {
-        return;
-      }
-      const absTime = timeMs / 1e3;
-      const time = (absTime - this.startTime) * this.speed;
-      this.channels.forEach(({ sampler, target, path }) => {
-        interpolate(time, sampler, target, path);
-        applyTranslationRotationScale(target, target._node);
-      });
-    }
-  };
-  var GLTFAnimator = class {
-    animations;
-    constructor(gltf) {
-      this.animations = gltf.animations.map((animation, index) => {
-        const name = animation.name || `Animation-${index}`;
-        const samplers = animation.samplers.map(({ input, interpolation = "LINEAR", output }) => ({
-          input: accessorToJsArray(gltf.accessors[input]),
-          interpolation,
-          output: accessorToJsArray(gltf.accessors[output])
-        }));
-        const channels = animation.channels.map(({ sampler, target }) => ({
-          sampler: samplers[sampler],
-          target: gltf.nodes[target.node],
-          path: target.path
-        }));
-        return new GLTFAnimation({ name, channels });
-      });
-    }
-    /** @deprecated Use .setTime(). Will be removed (deck.gl is using this) */
-    animate(time) {
-      this.setTime(time);
-    }
-    setTime(time) {
-      this.animations.forEach((animation) => animation.animate(time));
-    }
-    getAnimations() {
-      return this.animations;
-    }
-  };
-  function accessorToJsArray(accessor) {
-    if (!accessor._animation) {
-      const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[accessor.componentType];
-      const components = ATTRIBUTE_TYPE_TO_COMPONENTS[accessor.type];
-      const length4 = components * accessor.count;
-      const { buffer, byteOffset } = accessor.bufferView.data;
-      const array = new ArrayType(buffer, byteOffset + (accessor.byteOffset || 0), length4);
-      if (components === 1) {
-        accessor._animation = Array.from(array);
-      } else {
-        const slicedArray = [];
-        for (let i = 0; i < array.length; i += components) {
-          slicedArray.push(Array.from(array.slice(i, i + components)));
-        }
-        accessor._animation = slicedArray;
-      }
-    }
-    return accessor._animation;
-  }
-  var helperMatrix = new Matrix4();
-  function applyTranslationRotationScale(gltfNode, node) {
-    node.matrix.identity();
-    if (gltfNode.translation) {
-      node.matrix.translate(gltfNode.translation);
-    }
-    if (gltfNode.rotation) {
-      const rotationMatrix = helperMatrix.fromQuaternion(gltfNode.rotation);
-      node.matrix.multiplyRight(rotationMatrix);
-    }
-    if (gltfNode.scale) {
-      node.matrix.scale(gltfNode.scale);
-    }
-  }
-  var quaternion = new Quaternion();
-  function linearInterpolate(target, path, start, stop, ratio) {
-    if (path === "rotation") {
-      quaternion.slerp({ start, target: stop, ratio });
-      for (let i = 0; i < quaternion.length; i++) {
-        target[path][i] = quaternion[i];
-      }
-    } else {
-      for (let i = 0; i < start.length; i++) {
-        target[path][i] = ratio * stop[i] + (1 - ratio) * start[i];
-      }
-    }
-  }
-  function cubicsplineInterpolate(target, path, { p0, outTangent0, inTangent1, p1, tDiff, ratio: t }) {
-    for (let i = 0; i < target[path].length; i++) {
-      const m0 = outTangent0[i] * tDiff;
-      const m1 = inTangent1[i] * tDiff;
-      target[path][i] = (2 * Math.pow(t, 3) - 3 * Math.pow(t, 2) + 1) * p0[i] + (Math.pow(t, 3) - 2 * Math.pow(t, 2) + t) * m0 + (-2 * Math.pow(t, 3) + 3 * Math.pow(t, 2)) * p1[i] + (Math.pow(t, 3) - Math.pow(t, 2)) * m1;
-    }
-  }
-  function stepInterpolate(target, path, value) {
-    for (let i = 0; i < value.length; i++) {
-      target[path][i] = value[i];
-    }
-  }
-  function interpolate(time, { input, interpolation, output }, target, path) {
-    const maxTime = input[input.length - 1];
-    const animationTime = time % maxTime;
-    const nextIndex = input.findIndex((t) => t >= animationTime);
-    const previousIndex = Math.max(0, nextIndex - 1);
-    if (!Array.isArray(target[path])) {
-      switch (path) {
-        case "translation":
-          target[path] = [0, 0, 0];
-          break;
-        case "rotation":
-          target[path] = [0, 0, 0, 1];
-          break;
-        case "scale":
-          target[path] = [1, 1, 1];
-          break;
-        default:
-          import_core2.log.warn(`Bad animation path ${path}`)();
-      }
-    }
-    const previousTime = input[previousIndex];
-    const nextTime = input[nextIndex];
-    switch (interpolation) {
-      case "STEP":
-        stepInterpolate(target, path, output[previousIndex]);
-        break;
-      case "LINEAR":
-        if (nextTime > previousTime) {
-          const ratio = (animationTime - previousTime) / (nextTime - previousTime);
-          linearInterpolate(target, path, output[previousIndex], output[nextIndex], ratio);
-        }
-        break;
-      case "CUBICSPLINE":
-        if (nextTime > previousTime) {
-          const ratio = (animationTime - previousTime) / (nextTime - previousTime);
-          const tDiff = nextTime - previousTime;
-          const p0 = output[3 * previousIndex + 1];
-          const outTangent0 = output[3 * previousIndex + 2];
-          const inTangent1 = output[3 * nextIndex + 0];
-          const p1 = output[3 * nextIndex + 1];
-          cubicsplineInterpolate(target, path, { p0, outTangent0, inTangent1, p1, tDiff, ratio });
-        }
-        break;
-      default:
-        import_core2.log.warn(`Interpolation ${interpolation} not supported`)();
-        break;
+  // src/webgl-to-webgpu/convert-webgl-topology.ts
+  function convertGLDrawModeToTopology(drawMode) {
+    switch (drawMode) {
+      case 0 /* POINTS */:
+        return "point-list";
+      case 1 /* LINES */:
+        return "line-list";
+      case 3 /* LINE_STRIP */:
+        return "line-strip";
+      case 4 /* TRIANGLES */:
+        return "triangle-list";
+      case 5 /* TRIANGLE_STRIP */:
+        return "triangle-strip";
+      default:
+        throw new Error(String(drawMode));
     }
   }
 
   // src/gltf/create-gltf-model.ts
-  var import_core4 = __toESM(require_core(), 1);
+  var import_core2 = __toESM(require_core(), 1);
   var import_shadertools = __toESM(require_shadertools(), 1);
   var import_engine2 = __toESM(require_engine(), 1);
   var SHADER = (
@@ -3693,9 +3594,8 @@ layout(0) positions: vec4; // in vec4 POSITION;
 `
   );
   function createGLTFModel(device, options) {
-    const { id, geometry, material, vertexCount, materialOptions, modelOptions } = options;
-    const parsedMaterial = parsePBRMaterial(device, material, geometry.attributes, materialOptions);
-    import_core4.log.info(4, "createGLTFModel defines: ", parsedMaterial.defines)();
+    const { id, geometry, parsedPPBRMaterial, vertexCount, modelOptions = {} } = options;
+    import_core2.log.info(4, "createGLTFModel defines: ", parsedPPBRMaterial.defines)();
     const managedResources = [];
     const parameters = {
       depthWriteEnabled: true,
@@ -3713,180 +3613,353 @@ layout(0) positions: vec4; // in vec4 POSITION;
       vertexCount,
       modules: [import_shadertools.pbrMaterial],
       ...modelOptions,
-      defines: { ...parsedMaterial.defines, ...modelOptions.defines },
-      parameters: { ...parameters, ...parsedMaterial.parameters, ...modelOptions.parameters }
+      defines: { ...parsedPPBRMaterial.defines, ...modelOptions.defines },
+      parameters: { ...parameters, ...parsedPPBRMaterial.parameters, ...modelOptions.parameters }
     };
     const model = new import_engine2.Model(device, modelProps);
     const { camera, ...pbrMaterialProps } = {
-      ...parsedMaterial.uniforms,
+      ...parsedPPBRMaterial.uniforms,
       ...modelOptions.uniforms,
-      ...parsedMaterial.bindings,
+      ...parsedPPBRMaterial.bindings,
       ...modelOptions.bindings
     };
     model.shaderInputs.setProps({ pbrMaterial: pbrMaterialProps, pbrProjection: { camera } });
     return new import_engine2.ModelNode({ managedResources, model });
   }
 
-  // src/gltf/gl-utils.ts
-  function convertGLDrawModeToTopology(drawMode) {
-    switch (drawMode) {
-      case 0 /* POINTS */:
-        return "point-list";
-      case 1 /* LINES */:
-        return "line-list";
-      case 3 /* LINE_STRIP */:
-        return "line-strip";
-      case 4 /* TRIANGLES */:
-        return "triangle-list";
-      case 5 /* TRIANGLE_STRIP */:
-        return "triangle-strip";
-      default:
-        throw new Error(String(drawMode));
-    }
-  }
-
-  // src/gltf/gltf-instantiator.ts
-  var DEFAULT_OPTIONS = {
+  // src/parsers/parse-gltf.ts
+  var defaultOptions = {
     modelOptions: {},
     pbrDebug: false,
-    imageBasedLightingEnvironment: null,
+    imageBasedLightingEnvironment: void 0,
     lights: true,
     useTangents: false
   };
-  var GLTFInstantiator = class {
-    device;
-    options;
-    gltf;
-    constructor(device, options = {}) {
-      this.device = device;
-      this.options = { ...DEFAULT_OPTIONS, ...options };
-    }
-    instantiate(gltf) {
-      this.gltf = deepCopy(gltf);
-      const scenes = (this.gltf.scenes || []).map((scene) => this.createScene(scene));
-      return scenes;
-    }
-    createAnimator() {
-      if (Array.isArray(this.gltf.animations)) {
-        return new GLTFAnimator(this.gltf);
+  function parseGLTF(device, gltf, options_ = {}) {
+    const options = { ...defaultOptions, ...options_ };
+    const sceneNodes = gltf.scenes.map(
+      (gltfScene) => createScene(device, gltfScene, gltf.nodes, options)
+    );
+    return sceneNodes;
+  }
+  function createScene(device, gltfScene, gltfNodes, options) {
+    const gltfSceneNodes = gltfScene.nodes || [];
+    const nodes = gltfSceneNodes.map((node) => createNode(device, node, gltfNodes, options));
+    const sceneNode = new import_engine3.GroupNode({
+      id: gltfScene.name || gltfScene.id,
+      children: nodes
+    });
+    return sceneNode;
+  }
+  function createNode(device, gltfNode, gltfNodes, options) {
+    if (!gltfNode._node) {
+      const gltfChildren = gltfNode.children || [];
+      const children = gltfChildren.map((child) => createNode(device, child, gltfNodes, options));
+      if (gltfNode.mesh) {
+        children.push(createMesh(device, gltfNode.mesh, options));
+      }
+      const node = new import_engine3.GroupNode({
+        id: gltfNode.name || gltfNode.id,
+        children
+      });
+      if (gltfNode.matrix) {
+        node.setMatrix(gltfNode.matrix);
+      } else {
+        node.matrix.identity();
+        if (gltfNode.translation) {
+          node.matrix.translate(gltfNode.translation);
+        }
+        if (gltfNode.rotation) {
+          const rotationMatrix = new Matrix4().fromQuaternion(gltfNode.rotation);
+          node.matrix.multiplyRight(rotationMatrix);
+        }
+        if (gltfNode.scale) {
+          node.matrix.scale(gltfNode.scale);
+        }
       }
-      return null;
+      gltfNode._node = node;
     }
-    createScene(gltfScene) {
-      const gltfNodes = gltfScene.nodes || [];
-      const nodes = gltfNodes.map((node) => this.createNode(node));
-      const scene = new import_engine3.GroupNode({
-        id: gltfScene.name || gltfScene.id,
-        children: nodes
+    const topLevelNode = gltfNodes.find((node) => node.id === gltfNode.id);
+    topLevelNode._node = gltfNode._node;
+    return gltfNode._node;
+  }
+  function createMesh(device, gltfMesh, options) {
+    if (!gltfMesh._mesh) {
+      const gltfPrimitives = gltfMesh.primitives || [];
+      const primitives = gltfPrimitives.map(
+        (gltfPrimitive, i) => createPrimitive(device, gltfPrimitive, i, gltfMesh, options)
+      );
+      const mesh = new import_engine3.GroupNode({
+        id: gltfMesh.name || gltfMesh.id,
+        children: primitives
       });
-      return scene;
-    }
-    createNode(gltfNode) {
-      if (!gltfNode._node) {
-        const gltfChildren = gltfNode.children || [];
-        const children = gltfChildren.map((child) => this.createNode(child));
-        if (gltfNode.mesh) {
-          children.push(this.createMesh(gltfNode.mesh));
+      gltfMesh._mesh = mesh;
+    }
+    return gltfMesh._mesh;
+  }
+  function createPrimitive(device, gltfPrimitive, i, gltfMesh, options) {
+    const id = gltfPrimitive.name || `${gltfMesh.name || gltfMesh.id}-primitive-${i}`;
+    const topology = convertGLDrawModeToTopology(gltfPrimitive.mode || 4);
+    const vertexCount = gltfPrimitive.indices ? gltfPrimitive.indices.count : getVertexCount(gltfPrimitive.attributes);
+    const geometry = createGeometry(id, gltfPrimitive, topology);
+    const parsedPPBRMaterial = parsePBRMaterial(
+      device,
+      gltfPrimitive.material,
+      geometry.attributes,
+      options
+    );
+    const modelNode = createGLTFModel(device, {
+      id,
+      geometry: createGeometry(id, gltfPrimitive, topology),
+      parsedPPBRMaterial,
+      modelOptions: options.modelOptions,
+      vertexCount
+    });
+    modelNode.bounds = [gltfPrimitive.attributes.POSITION.min, gltfPrimitive.attributes.POSITION.max];
+    return modelNode;
+  }
+  function getVertexCount(attributes) {
+    throw new Error("getVertexCount not implemented");
+  }
+  function createGeometry(id, gltfPrimitive, topology) {
+    const attributes = {};
+    for (const [attributeName, attribute] of Object.entries(gltfPrimitive.attributes)) {
+      const { components, size, value } = attribute;
+      attributes[attributeName] = { size: size ?? components, value };
+    }
+    return new import_engine3.Geometry({
+      id,
+      topology,
+      indices: gltfPrimitive.indices.value,
+      attributes
+    });
+  }
+
+  // src/gltf/gltf-animator.ts
+  var import_core6 = __toESM(require_core(), 1);
+
+  // src/gltf/animations/interpolate.ts
+  var import_core4 = __toESM(require_core(), 1);
+  var scratchQuaternion = new Quaternion();
+  function interpolate(time, { input, interpolation, output }, target, path) {
+    const maxTime = input[input.length - 1];
+    const animationTime = time % maxTime;
+    const nextIndex = input.findIndex((t) => t >= animationTime);
+    const previousIndex = Math.max(0, nextIndex - 1);
+    if (!Array.isArray(target[path])) {
+      switch (path) {
+        case "translation":
+          target[path] = [0, 0, 0];
+          break;
+        case "rotation":
+          target[path] = [0, 0, 0, 1];
+          break;
+        case "scale":
+          target[path] = [1, 1, 1];
+          break;
+        default:
+          import_core4.log.warn(`Bad animation path ${path}`)();
+      }
+    }
+    const previousTime = input[previousIndex];
+    const nextTime = input[nextIndex];
+    switch (interpolation) {
+      case "STEP":
+        stepInterpolate(target, path, output[previousIndex]);
+        break;
+      case "LINEAR":
+        if (nextTime > previousTime) {
+          const ratio = (animationTime - previousTime) / (nextTime - previousTime);
+          linearInterpolate(
+            target,
+            path,
+            output[previousIndex],
+            output[nextIndex],
+            ratio
+          );
         }
-        const node = new import_engine3.GroupNode({
-          id: gltfNode.name || gltfNode.id,
-          children
-        });
-        if (gltfNode.matrix) {
-          node.setMatrix(gltfNode.matrix);
-        } else {
-          node.matrix.identity();
-          if (gltfNode.translation) {
-            node.matrix.translate(gltfNode.translation);
-          }
-          if (gltfNode.rotation) {
-            const rotationMatrix = new Matrix4().fromQuaternion(gltfNode.rotation);
-            node.matrix.multiplyRight(rotationMatrix);
-          }
-          if (gltfNode.scale) {
-            node.matrix.scale(gltfNode.scale);
-          }
+        break;
+      case "CUBICSPLINE":
+        if (nextTime > previousTime) {
+          const ratio = (animationTime - previousTime) / (nextTime - previousTime);
+          const tDiff = nextTime - previousTime;
+          const p0 = output[3 * previousIndex + 1];
+          const outTangent0 = output[3 * previousIndex + 2];
+          const inTangent1 = output[3 * nextIndex + 0];
+          const p1 = output[3 * nextIndex + 1];
+          cubicsplineInterpolate(target, path, { p0, outTangent0, inTangent1, p1, tDiff, ratio });
         }
-        gltfNode._node = node;
-      }
-      const topLevelNode = this.gltf.nodes.find((node) => node.id === gltfNode.id);
-      topLevelNode._node = gltfNode._node;
-      return gltfNode._node;
-    }
-    createMesh(gltfMesh) {
-      if (!gltfMesh._mesh) {
-        const gltfPrimitives = gltfMesh.primitives || [];
-        const primitives = gltfPrimitives.map(
-          (gltfPrimitive, i) => this.createPrimitive(gltfPrimitive, i, gltfMesh)
-        );
-        const mesh = new import_engine3.GroupNode({
-          id: gltfMesh.name || gltfMesh.id,
-          children: primitives
-        });
-        gltfMesh._mesh = mesh;
-      }
-      return gltfMesh._mesh;
-    }
-    createPrimitive(gltfPrimitive, i, gltfMesh) {
-      const id = gltfPrimitive.name || `${gltfMesh.name || gltfMesh.id}-primitive-${i}`;
-      const topology = convertGLDrawModeToTopology(gltfPrimitive.mode || 4);
-      const vertexCount = gltfPrimitive.indices ? gltfPrimitive.indices.count : this.getVertexCount(gltfPrimitive.attributes);
-      const modelNode = createGLTFModel(this.device, {
-        id,
-        geometry: this.createGeometry(id, gltfPrimitive, topology),
-        material: gltfPrimitive.material,
-        materialOptions: this.options,
-        modelOptions: this.options.modelOptions,
-        vertexCount
-      });
-      modelNode.bounds = [
-        gltfPrimitive.attributes.POSITION.min,
-        gltfPrimitive.attributes.POSITION.max
-      ];
-      return modelNode;
-    }
-    getVertexCount(attributes) {
-      throw new Error("getVertexCount not implemented");
-    }
-    createGeometry(id, gltfPrimitive, topology) {
-      const attributes = {};
-      for (const [attributeName, attribute] of Object.entries(gltfPrimitive.attributes)) {
-        const { components, size, value } = attribute;
-        attributes[attributeName] = { size: size ?? components, value };
-      }
-      return new import_engine3.Geometry({
-        id,
-        topology,
-        indices: gltfPrimitive.indices.value,
-        attributes
-      });
+        break;
+      default:
+        import_core4.log.warn(`Interpolation ${interpolation} not supported`)();
+        break;
     }
-    createBuffer(attribute, usage) {
-      if (!attribute.bufferView) {
-        attribute.bufferView = {};
+  }
+  function linearInterpolate(target, path, start, stop, ratio) {
+    if (!target[path]) {
+      throw new Error();
+    }
+    if (path === "rotation") {
+      scratchQuaternion.slerp({ start, target: stop, ratio });
+      for (let i = 0; i < scratchQuaternion.length; i++) {
+        target[path][i] = scratchQuaternion[i];
       }
-      const { bufferView } = attribute;
-      if (!bufferView.lumaBuffers) {
-        bufferView.lumaBuffers = {};
+    } else {
+      for (let i = 0; i < start.length; i++) {
+        target[path][i] = ratio * stop[i] + (1 - ratio) * start[i];
       }
-      if (!bufferView.lumaBuffers[usage]) {
-        bufferView.lumaBuffers[usage] = this.device.createBuffer({
-          id: `from-${bufferView.id}`,
-          // Draco decoded files have attribute.value
-          data: bufferView.data || attribute.value
-        });
+    }
+  }
+  function cubicsplineInterpolate(target, path, {
+    p0,
+    outTangent0,
+    inTangent1,
+    p1,
+    tDiff,
+    ratio: t
+  }) {
+    if (!target[path]) {
+      throw new Error();
+    }
+    for (let i = 0; i < target[path].length; i++) {
+      const m0 = outTangent0[i] * tDiff;
+      const m1 = inTangent1[i] * tDiff;
+      target[path][i] = (2 * Math.pow(t, 3) - 3 * Math.pow(t, 2) + 1) * p0[i] + (Math.pow(t, 3) - 2 * Math.pow(t, 2) + t) * m0 + (-2 * Math.pow(t, 3) + 3 * Math.pow(t, 2)) * p1[i] + (Math.pow(t, 3) - Math.pow(t, 2)) * m1;
+    }
+  }
+  function stepInterpolate(target, path, value) {
+    if (!target[path]) {
+      throw new Error();
+    }
+    for (let i = 0; i < value.length; i++) {
+      target[path][i] = value[i];
+    }
+  }
+
+  // src/gltf/gltf-animator.ts
+  var GLTFSingleAnimator = class {
+    animation;
+    startTime = 0;
+    playing = true;
+    speed = 1;
+    constructor(props) {
+      this.animation = props.animation;
+      this.animation.name ||= "unnamed";
+      Object.assign(this, props);
+    }
+    setTime(timeMs) {
+      if (!this.playing) {
+        return;
       }
-      return bufferView.lumaBuffers[usage];
+      const absTime = timeMs / 1e3;
+      const time = (absTime - this.startTime) * this.speed;
+      this.animation.channels.forEach(({ sampler, target, path }) => {
+        interpolate(time, sampler, target, path);
+        applyTranslationRotationScale(target, target._node);
+      });
     }
-    // TODO - create sampler in WebGL2
-    createSampler(gltfSampler) {
-      return gltfSampler;
+  };
+  var GLTFAnimator = class {
+    animations;
+    constructor(props) {
+      this.animations = props.animations.map((animation, index) => {
+        const name = animation.name || `Animation-${index}`;
+        return new GLTFSingleAnimator({
+          animation: { name, channels: animation.channels }
+        });
+      });
     }
-    // Helper methods (move to GLTFLoader.resolve...?)
-    needsPOT() {
-      return false;
+    /** @deprecated Use .setTime(). Will be removed (deck.gl is using this) */
+    animate(time) {
+      import_core6.log.warn("GLTFAnimator#animate is deprecated. Use GLTFAnimator#setTime instead")();
+      this.setTime(time);
+    }
+    setTime(time) {
+      this.animations.forEach((animation) => animation.setTime(time));
+    }
+    getAnimations() {
+      return this.animations;
     }
   };
+  var scratchMatrix = new Matrix4();
+  function applyTranslationRotationScale(gltfNode, node) {
+    node.matrix.identity();
+    if (gltfNode.translation) {
+      node.matrix.translate(gltfNode.translation);
+    }
+    if (gltfNode.rotation) {
+      const rotationMatrix = scratchMatrix.fromQuaternion(gltfNode.rotation);
+      node.matrix.multiplyRight(rotationMatrix);
+    }
+    if (gltfNode.scale) {
+      node.matrix.scale(gltfNode.scale);
+    }
+  }
+
+  // src/webgl-to-webgpu/convert-webgl-attribute.ts
+  var ATTRIBUTE_TYPE_TO_COMPONENTS = {
+    SCALAR: 1,
+    VEC2: 2,
+    VEC3: 3,
+    VEC4: 4,
+    MAT2: 4,
+    MAT3: 9,
+    MAT4: 16
+  };
+  var ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {
+    5120: Int8Array,
+    5121: Uint8Array,
+    5122: Int16Array,
+    5123: Uint16Array,
+    5125: Uint32Array,
+    5126: Float32Array
+  };
+  function accessorToTypedArray(accessor) {
+    const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[accessor.componentType];
+    const components = ATTRIBUTE_TYPE_TO_COMPONENTS[accessor.type];
+    const length4 = components * accessor.count;
+    const { buffer, byteOffset = 0 } = accessor.bufferView?.data ?? {};
+    const typedArray = new ArrayType(buffer, byteOffset + (accessor.byteOffset || 0), length4);
+    return { typedArray, components };
+  }
+
+  // src/parsers/parse-gltf-animations.ts
+  function parseGLTFAnimations(gltf) {
+    const gltfAnimations = gltf.animations || [];
+    return gltfAnimations.map((animation, index) => {
+      const name = animation.name || `Animation-${index}`;
+      const samplers = animation.samplers.map(
+        ({ input, interpolation = "LINEAR", output }) => ({
+          input: accessorToJsArray(gltf.accessors[input]),
+          interpolation,
+          output: accessorToJsArray(gltf.accessors[output])
+        })
+      );
+      const channels = animation.channels.map(({ sampler, target }) => ({
+        sampler: samplers[sampler],
+        target: gltf.nodes[target.node ?? 0],
+        path: target.path
+      }));
+      return { name, channels };
+    });
+  }
+  function accessorToJsArray(accessor) {
+    if (!accessor._animation) {
+      const { typedArray: array, components } = accessorToTypedArray(accessor);
+      if (components === 1) {
+        accessor._animation = Array.from(array);
+      } else {
+        const slicedArray = [];
+        for (let i = 0; i < array.length; i += components) {
+          slicedArray.push(Array.from(array.slice(i, i + components)));
+        }
+        accessor._animation = slicedArray;
+      }
+    }
+    return accessor._animation;
+  }
+
+  // src/utils/deep-copy.ts
   function deepCopy(object) {
     if (ArrayBuffer.isView(object) || object instanceof ArrayBuffer || object instanceof ImageBitmap) {
       return object;
@@ -3904,11 +3977,12 @@ layout(0) positions: vec4; // in vec4 POSITION;
     return object;
   }
 
-  // src/gltf/create-gltf-objects.ts
+  // src/gltf/create-scenegraph-from-gltf.ts
   function createScenegraphsFromGLTF(device, gltf, options) {
-    const instantiator = new GLTFInstantiator(device, options);
-    const scenes = instantiator.instantiate(gltf);
-    const animator = instantiator.createAnimator();
+    gltf = deepCopy(gltf);
+    const scenes = parseGLTF(device, gltf, options);
+    const animations = parseGLTFAnimations(gltf);
+    const animator = new GLTFAnimator({ animations });
     return { scenes, animator };
   }
   return __toCommonJS(bundle_exports);