@luma.gl/gltf 9.0.0-alpha.54 → 9.0.0-beta.10

package/dist/gltf/gltf-instantiator.js

@@ -1,181 +1,190 @@
 import { Geometry, GroupNode } from '@luma.gl/engine';
-import { WebGLDevice } from '@luma.gl/webgl';
 import { Matrix4 } from '@math.gl/core';
 import { GLTFAnimator } from "./gltf-animator.js";
 import { createGLTFModel } from "./create-gltf-model.js";
 const DEFAULT_OPTIONS = {
-  modelOptions: {},
-  pbrDebug: false,
-  imageBasedLightingEnvironment: null,
-  lights: true,
-  useTangents: false
+    modelOptions: {},
+    pbrDebug: false,
+    imageBasedLightingEnvironment: null,
+    lights: true,
+    useTangents: false
 };
+/**
+ * GLTF instantiator for luma.gl
+ * Walks the parsed and resolved glTF structure and builds a luma.gl scenegraph
+ */
 export class GLTFInstantiator {
-  constructor(device) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    this.device = void 0;
-    this.options = void 0;
-    this.gltf = void 0;
-    this.device = WebGLDevice.attach(device);
-    this.options = {
-      ...DEFAULT_OPTIONS,
-      ...options
-    };
-  }
-  instantiate(gltf) {
-    this.gltf = gltf;
-    const scenes = (gltf.scenes || []).map(scene => this.createScene(scene));
-    return scenes;
-  }
-  createAnimator() {
-    if (Array.isArray(this.gltf.animations)) {
-      return new GLTFAnimator(this.gltf);
+    device;
+    options;
+    gltf;
+    constructor(device, options = {}) {
+        this.device = device;
+        this.options = { ...DEFAULT_OPTIONS, ...options };
     }
-    return null;
-  }
-  createScene(gltfScene) {
-    const gltfNodes = gltfScene.nodes || [];
-    const nodes = gltfNodes.map(node => this.createNode(node));
-    const scene = new GroupNode({
-      id: gltfScene.name || gltfScene.id,
-      children: nodes
-    });
-    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));
-      }
-      const node = new 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);
+    instantiate(gltf) {
+        this.gltf = gltf;
+        const scenes = (gltf.scenes || []).map(scene => this.createScene(scene));
+        return scenes;
+    }
+    createAnimator() {
+        if (Array.isArray(this.gltf.animations)) {
+            return new GLTFAnimator(this.gltf);
         }
-        if (gltfNode.rotation) {
-          const rotationMatrix = new Matrix4().fromQuaternion(gltfNode.rotation);
-          node.matrix.multiplyRight(rotationMatrix);
+        return null;
+    }
+    createScene(gltfScene) {
+        const gltfNodes = gltfScene.nodes || [];
+        const nodes = gltfNodes.map(node => this.createNode(node));
+        const scene = new GroupNode({
+            id: gltfScene.name || gltfScene.id,
+            children: nodes
+        });
+        return scene;
+    }
+    createNode(gltfNode) {
+        if (!gltfNode._node) {
+            const gltfChildren = gltfNode.children || [];
+            const children = gltfChildren.map(child => this.createNode(child));
+            // Node can have children nodes and meshes at the same time
+            if (gltfNode.mesh) {
+                children.push(this.createMesh(gltfNode.mesh));
+            }
+            const node = new 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);
+                }
+            }
+            gltfNode._node = node;
         }
-        if (gltfNode.scale) {
-          node.matrix.scale(gltfNode.scale);
+        return gltfNode._node;
+    }
+    createMesh(gltfMesh) {
+        // TODO: avoid changing the gltf
+        if (!gltfMesh._mesh) {
+            const gltfPrimitives = gltfMesh.primitives || [];
+            const primitives = gltfPrimitives.map((gltfPrimitive, i) => this.createPrimitive(gltfPrimitive, i, gltfMesh));
+            const mesh = new GroupNode({
+                id: gltfMesh.name || gltfMesh.id,
+                children: primitives
+            });
+            gltfMesh._mesh = mesh;
         }
-      }
-      gltfNode._node = node;
+        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
+        ];
+        // TODO this holds on to all the CPU side texture and attribute data
+        // modelNode.material =  gltfPrimitive.material;
+        return modelNode;
     }
-    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 GroupNode({
-        id: gltfMesh.name || gltfMesh.id,
-        children: primitives
-      });
-      gltfMesh._mesh = mesh;
+    getVertexCount(attributes) {
+        throw new Error('getVertexCount not implemented');
     }
-    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 !== null && size !== void 0 ? size : components,
-        value
-      };
+    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 Geometry({
+            id,
+            topology,
+            indices: gltfPrimitive.indices.value,
+            attributes
+        });
     }
-    ;
-    return new Geometry({
-      id,
-      topology,
-      indices: gltfPrimitive.indices.value,
-      attributes
-    });
-  }
-  createBuffer(attribute, usage) {
-    if (!attribute.bufferView) {
-      attribute.bufferView = {};
+    createBuffer(attribute, usage) {
+        if (!attribute.bufferView) {
+            // Draco decoded files do not have a bufferView
+            attribute.bufferView = {};
+        }
+        const { bufferView } = attribute;
+        if (!bufferView.lumaBuffers) {
+            bufferView.lumaBuffers = {};
+        }
+        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
+            });
+        }
+        return bufferView.lumaBuffers[usage];
     }
-    const {
-      bufferView
-    } = attribute;
-    if (!bufferView.lumaBuffers) {
-      bufferView.lumaBuffers = {};
+    // TODO - create sampler in WebGL2
+    createSampler(gltfSampler) {
+        return gltfSampler;
     }
-    if (!bufferView.lumaBuffers[usage]) {
-      bufferView.lumaBuffers[usage] = this.device.createBuffer({
-        id: `from-${bufferView.id}`,
-        data: bufferView.data || attribute.value
-      });
+    // Helper methods (move to GLTFLoader.resolve...?)
+    needsPOT() {
+        // Has a wrapping mode (either wrapS or wrapT) equal to REPEAT or MIRRORED_REPEAT, or
+        // Has a minification filter (minFilter) that uses mipmapping
+        // (NEAREST_MIPMAP_NEAREST, NEAREST_MIPMAP_LINEAR,
+        // LINEAR_MIPMAP_NEAREST, or LINEAR_MIPMAP_LINEAR).
+        return false;
     }
-    return bufferView.lumaBuffers[usage];
-  }
-  createSampler(gltfSampler) {
-    return gltfSampler;
-  }
-  needsPOT() {
-    return false;
-  }
 }
-var GLEnum = function (GLEnum) {
-  GLEnum[GLEnum["POINTS"] = 0] = "POINTS";
-  GLEnum[GLEnum["LINES"] = 1] = "LINES";
-  GLEnum[GLEnum["LINE_LOOP"] = 2] = "LINE_LOOP";
-  GLEnum[GLEnum["LINE_STRIP"] = 3] = "LINE_STRIP";
-  GLEnum[GLEnum["TRIANGLES"] = 4] = "TRIANGLES";
-  GLEnum[GLEnum["TRIANGLE_STRIP"] = 5] = "TRIANGLE_STRIP";
-  GLEnum[GLEnum["TRIANGLE_FAN"] = 6] = "TRIANGLE_FAN";
-  return GLEnum;
-}(GLEnum || {});
+// NOTE: Modules other than `@luma.gl/webgl` should not import `GL` from
+// `@luma.gl/constants`. Locally we use `GLEnum` instead of `GL` to avoid
+// conflicts with the `babel-plugin-inline-webgl-constants` plugin.
+var GLEnum;
+(function (GLEnum) {
+    GLEnum[GLEnum["POINTS"] = 0] = "POINTS";
+    GLEnum[GLEnum["LINES"] = 1] = "LINES";
+    GLEnum[GLEnum["LINE_LOOP"] = 2] = "LINE_LOOP";
+    GLEnum[GLEnum["LINE_STRIP"] = 3] = "LINE_STRIP";
+    GLEnum[GLEnum["TRIANGLES"] = 4] = "TRIANGLES";
+    GLEnum[GLEnum["TRIANGLE_STRIP"] = 5] = "TRIANGLE_STRIP";
+    GLEnum[GLEnum["TRIANGLE_FAN"] = 6] = "TRIANGLE_FAN";
+})(GLEnum || (GLEnum = {}));
 export function convertGLDrawModeToTopology(drawMode) {
-  switch (drawMode) {
-    case GLEnum.POINTS:
-      return 'point-list';
-    case GLEnum.LINES:
-      return 'line-list';
-    case GLEnum.LINE_STRIP:
-      return 'line-strip';
-    case GLEnum.LINE_LOOP:
-      return 'line-loop-webgl';
-    case GLEnum.TRIANGLES:
-      return 'triangle-list';
-    case GLEnum.TRIANGLE_STRIP:
-      return 'triangle-strip';
-    case GLEnum.TRIANGLE_FAN:
-      return 'triangle-fan-webgl';
-    default:
-      throw new Error(drawMode);
-  }
+    switch (drawMode) {
+        case GLEnum.POINTS:
+            return 'point-list';
+        case GLEnum.LINES:
+            return 'line-list';
+        case GLEnum.LINE_STRIP:
+            return 'line-strip';
+        case GLEnum.LINE_LOOP:
+            return 'line-loop-webgl';
+        case GLEnum.TRIANGLES:
+            return 'triangle-list';
+        case GLEnum.TRIANGLE_STRIP:
+            return 'triangle-strip';
+        case GLEnum.TRIANGLE_FAN:
+            return 'triangle-fan-webgl';
+        default:
+            throw new Error(drawMode);
+    }
 }
-//# sourceMappingURL=gltf-instantiator.js.map

package/dist/index.cjs

@@ -16,18 +16,29 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
+// dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
   GLTFAnimator: () => GLTFAnimator,
   createScenegraphsFromGLTF: () => createScenegraphsFromGLTF,
   loadPBREnvironment: () => loadPBREnvironment,
   parsePBRMaterial: () => parsePBRMaterial
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(dist_exports);
 
-// src/pbr/parse-pbr-material.ts
+// dist/pbr/parse-pbr-material.js
 var import_core = require("@luma.gl/core");
+var GLEnum;
+(function(GLEnum3) {
+  GLEnum3[GLEnum3["FUNC_ADD"] = 32774] = "FUNC_ADD";
+  GLEnum3[GLEnum3["ONE"] = 1] = "ONE";
+  GLEnum3[GLEnum3["SRC_ALPHA"] = 770] = "SRC_ALPHA";
+  GLEnum3[GLEnum3["ONE_MINUS_SRC_ALPHA"] = 771] = "ONE_MINUS_SRC_ALPHA";
+  GLEnum3[GLEnum3["TEXTURE_MIN_FILTER"] = 10241] = "TEXTURE_MIN_FILTER";
+  GLEnum3[GLEnum3["LINEAR"] = 9729] = "LINEAR";
+  GLEnum3[GLEnum3["LINEAR_MIPMAP_NEAREST"] = 9985] = "LINEAR_MIPMAP_NEAREST";
+  GLEnum3[GLEnum3["UNPACK_FLIP_Y_WEBGL"] = 37440] = "UNPACK_FLIP_Y_WEBGL";
+})(GLEnum || (GLEnum = {}));
 function parsePBRMaterial(device, material, attributes, options) {
   const parsedMaterial = {
     defines: {
@@ -47,9 +58,7 @@ function parsePBRMaterial(device, material, attributes, options) {
     glParameters: {},
     generatedTextures: []
   };
-  if (device.features.has("glsl-texture-lod")) {
-    parsedMaterial.defines.USE_TEX_LOD = 1;
-  }
+  parsedMaterial.defines.USE_TEX_LOD = 1;
   const { imageBasedLightingEnvironment } = options;
   if (imageBasedLightingEnvironment) {
     parsedMaterial.bindings.u_DiffuseEnvSampler = imageBasedLightingEnvironment.diffuseEnvSampler;
@@ -88,24 +97,12 @@ function parseMaterial(device, material, parsedMaterial) {
     parsedMaterial.uniforms.u_NormalScale = scale;
   }
   if (material.occlusionTexture) {
-    addTexture(
-      device,
-      material.occlusionTexture,
-      "u_OcclusionSampler",
-      "HAS_OCCLUSIONMAP",
-      parsedMaterial
-    );
+    addTexture(device, material.occlusionTexture, "u_OcclusionSampler", "HAS_OCCLUSIONMAP", parsedMaterial);
     const { strength = 1 } = material.occlusionTexture;
     parsedMaterial.uniforms.u_OcclusionStrength = strength;
   }
   if (material.emissiveTexture) {
-    addTexture(
-      device,
-      material.emissiveTexture,
-      "u_EmissiveSampler",
-      "HAS_EMISSIVEMAP",
-      parsedMaterial
-    );
+    addTexture(device, material.emissiveTexture, "u_EmissiveSampler", "HAS_EMISSIVEMAP", parsedMaterial);
     parsedMaterial.uniforms.u_EmissiveFactor = material.emissiveFactor || [0, 0, 0];
   }
   switch (material.alphaMode) {
@@ -123,30 +120,23 @@ function parseMaterial(device, material, parsedMaterial) {
       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 */];
+      parsedMaterial.glParameters.blendEquation = GLEnum.FUNC_ADD;
+      parsedMaterial.glParameters.blendFunc = [
+        GLEnum.SRC_ALPHA,
+        GLEnum.ONE_MINUS_SRC_ALPHA,
+        GLEnum.ONE,
+        GLEnum.ONE_MINUS_SRC_ALPHA
+      ];
       break;
   }
 }
 function parsePbrMetallicRoughness(device, pbrMetallicRoughness, parsedMaterial) {
   if (pbrMetallicRoughness.baseColorTexture) {
-    addTexture(
-      device,
-      pbrMetallicRoughness.baseColorTexture,
-      "u_BaseColorSampler",
-      "HAS_BASECOLORMAP",
-      parsedMaterial
-    );
+    addTexture(device, pbrMetallicRoughness.baseColorTexture, "u_BaseColorSampler", "HAS_BASECOLORMAP", parsedMaterial);
   }
   parsedMaterial.uniforms.u_BaseColorFactor = pbrMetallicRoughness.baseColorFactor || [1, 1, 1, 1];
   if (pbrMetallicRoughness.metallicRoughnessTexture) {
-    addTexture(
-      device,
-      pbrMetallicRoughness.metallicRoughnessTexture,
-      "u_MetallicRoughnessSampler",
-      "HAS_METALROUGHNESSMAP",
-      parsedMaterial
-    );
+    addTexture(device, pbrMetallicRoughness.metallicRoughnessTexture, "u_MetallicRoughnessSampler", "HAS_METALROUGHNESSMAP", parsedMaterial);
   }
   const { metallicFactor = 1, roughnessFactor = 1 } = pbrMetallicRoughness;
   parsedMaterial.uniforms.u_MetallicRoughnessValues = [metallicFactor, roughnessFactor];
@@ -160,7 +150,7 @@ function addTexture(device, gltfTexture, uniformName, define = null, parsedMater
   if (image.compressed) {
     textureOptions = image;
     specialTextureParameters = {
-      [10241 /* TEXTURE_MIN_FILTER */]: image.data.length > 1 ? 9985 /* LINEAR_MIPMAP_NEAREST */ : 9729 /* LINEAR */
+      [GLEnum.TEXTURE_MIN_FILTER]: image.data.length > 1 ? GLEnum.LINEAR_MIPMAP_NEAREST : GLEnum.LINEAR
     };
   } else {
     textureOptions = { data: image };
@@ -172,7 +162,7 @@ function addTexture(device, gltfTexture, uniformName, define = null, parsedMater
       ...specialTextureParameters
     },
     pixelStore: {
-      [37440 /* UNPACK_FLIP_Y_WEBGL */]: false
+      [GLEnum.UNPACK_FLIP_Y_WEBGL]: false
     },
     ...textureOptions
   });
@@ -182,7 +172,7 @@ function addTexture(device, gltfTexture, uniformName, define = null, parsedMater
   parsedMaterial.generatedTextures.push(texture);
 }
 
-// src/pbr/pbr-environment.ts
+// dist/pbr/pbr-environment.js
 var import_textures = require("@loaders.gl/textures");
 function loadPBREnvironment(device, props) {
   const brdfLutTexture = device.createTexture({
@@ -244,12 +234,11 @@ function makeCube(device, { id, getTextureForFace, sampler }) {
   });
 }
 
-// src/gltf/gltf-instantiator.ts
+// dist/gltf/gltf-instantiator.js
 var import_engine2 = require("@luma.gl/engine");
-var import_webgl = require("@luma.gl/webgl");
 var import_core5 = require("@math.gl/core");
 
-// src/gltf/gltf-animator.ts
+// dist/gltf/gltf-animator.js
 var import_core2 = require("@luma.gl/core");
 var import_core3 = require("@math.gl/core");
 var ATTRIBUTE_TYPE_TO_COMPONENTS = {
@@ -427,7 +416,7 @@ function interpolate(time, { input, interpolation, output }, target, path) {
   }
 }
 
-// src/gltf/create-gltf-model.ts
+// dist/gltf/create-gltf-model.js
 var import_core4 = require("@luma.gl/core");
 var import_shadertools = require("@luma.gl/shadertools");
 var import_engine = require("@luma.gl/engine");
@@ -519,11 +508,11 @@ function createGLTFModel(device, options) {
   return new import_engine.ModelNode({ managedResources, model });
 }
 function addVersionToShader(device, source) {
-  return device.info.type === "webgl2" ? `#version 300 es
-${source}` : source;
+  return `#version 300 es
+${source}`;
 }
 
-// src/gltf/gltf-instantiator.ts
+// dist/gltf/gltf-instantiator.js
 var DEFAULT_OPTIONS = {
   modelOptions: {},
   pbrDebug: false,
@@ -532,12 +521,11 @@ var DEFAULT_OPTIONS = {
   useTangents: false
 };
 var GLTFInstantiator = class {
-  // TODO - replace with Device
   device;
   options;
   gltf;
   constructor(device, options = {}) {
-    this.device = import_webgl.WebGLDevice.attach(device);
+    this.device = device;
     this.options = { ...DEFAULT_OPTIONS, ...options };
   }
   instantiate(gltf) {
@@ -593,9 +581,7 @@ var GLTFInstantiator = class {
   createMesh(gltfMesh) {
     if (!gltfMesh._mesh) {
       const gltfPrimitives = gltfMesh.primitives || [];
-      const primitives = gltfPrimitives.map(
-        (gltfPrimitive, i) => this.createPrimitive(gltfPrimitive, i, gltfMesh)
-      );
+      const primitives = gltfPrimitives.map((gltfPrimitive, i) => this.createPrimitive(gltfPrimitive, i, gltfMesh));
       const mesh = new import_engine2.GroupNode({
         id: gltfMesh.name || gltfMesh.id,
         children: primitives
@@ -616,7 +602,10 @@ var GLTFInstantiator = class {
       modelOptions: this.options.modelOptions,
       vertexCount
     });
-    modelNode.bounds = [gltfPrimitive.attributes.POSITION.min, gltfPrimitive.attributes.POSITION.max];
+    modelNode.bounds = [
+      gltfPrimitive.attributes.POSITION.min,
+      gltfPrimitive.attributes.POSITION.max
+    ];
     return modelNode;
   }
   getVertexCount(attributes) {
@@ -628,7 +617,6 @@ var GLTFInstantiator = class {
       const { components, size, value } = attribute;
       attributes[attributeName] = { size: size ?? components, value };
     }
-    ;
     return new import_engine2.Geometry({
       id,
       topology,
@@ -662,31 +650,42 @@ var GLTFInstantiator = class {
     return false;
   }
 };
+var GLEnum2;
+(function(GLEnum3) {
+  GLEnum3[GLEnum3["POINTS"] = 0] = "POINTS";
+  GLEnum3[GLEnum3["LINES"] = 1] = "LINES";
+  GLEnum3[GLEnum3["LINE_LOOP"] = 2] = "LINE_LOOP";
+  GLEnum3[GLEnum3["LINE_STRIP"] = 3] = "LINE_STRIP";
+  GLEnum3[GLEnum3["TRIANGLES"] = 4] = "TRIANGLES";
+  GLEnum3[GLEnum3["TRIANGLE_STRIP"] = 5] = "TRIANGLE_STRIP";
+  GLEnum3[GLEnum3["TRIANGLE_FAN"] = 6] = "TRIANGLE_FAN";
+})(GLEnum2 || (GLEnum2 = {}));
 function convertGLDrawModeToTopology(drawMode) {
   switch (drawMode) {
-    case 0 /* POINTS */:
+    case GLEnum2.POINTS:
       return "point-list";
-    case 1 /* LINES */:
+    case GLEnum2.LINES:
       return "line-list";
-    case 3 /* LINE_STRIP */:
+    case GLEnum2.LINE_STRIP:
       return "line-strip";
-    case 2 /* LINE_LOOP */:
+    case GLEnum2.LINE_LOOP:
       return "line-loop-webgl";
-    case 4 /* TRIANGLES */:
+    case GLEnum2.TRIANGLES:
       return "triangle-list";
-    case 5 /* TRIANGLE_STRIP */:
+    case GLEnum2.TRIANGLE_STRIP:
       return "triangle-strip";
-    case 6 /* TRIANGLE_FAN */:
+    case GLEnum2.TRIANGLE_FAN:
       return "triangle-fan-webgl";
     default:
       throw new Error(drawMode);
   }
 }
 
-// src/gltf/create-gltf-objects.ts
+// dist/gltf/create-gltf-objects.js
 function createScenegraphsFromGLTF(device, gltf, options) {
   const instantiator = new GLTFInstantiator(device, options);
   const scenes = instantiator.instantiate(gltf);
   const animator = instantiator.createAnimator();
   return { scenes, animator };
 }
+//# sourceMappingURL=index.cjs.map