@luma.gl/gltf 9.0.0-alpha.43

package/dist/index.cjs

@@ -0,0 +1,635 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  GLTFAnimator: () => GLTFAnimator,
+  createScenegraphsFromGLTF: () => createScenegraphsFromGLTF,
+  parsePBRMaterial: () => parsePBRMaterial
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/pbr/parse-pbr-material.ts
+var import_core = require("@luma.gl/core");
+var import_constants = require("@luma.gl/constants");
+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?
+      u_Camera: [0, 0, 0],
+      // Model should override
+      u_MetallicRoughnessValues: [1, 1]
+      // Default is 1 and 1
+    },
+    parameters: {},
+    glParameters: {},
+    generatedTextures: []
+  };
+  if (device.features.has("glsl-texture-lod")) {
+    parsedMaterial.defines.USE_TEX_LOD = 1;
+  }
+  const { imageBasedLightingEnvironment } = options;
+  if (imageBasedLightingEnvironment) {
+    parsedMaterial.bindings.u_DiffuseEnvSampler = imageBasedLightingEnvironment.diffuseEnvSampler;
+    parsedMaterial.bindings.u_SpecularEnvSampler = imageBasedLightingEnvironment.specularEnvSampler;
+    parsedMaterial.bindings.u_brdfLUT = imageBasedLightingEnvironment.brdfLutTexture;
+    parsedMaterial.uniforms.u_ScaleIBLAmbient = [1, 1];
+  }
+  if (options == null ? void 0 : options.pbrDebug) {
+    parsedMaterial.defines.PBR_DEBUG = 1;
+    parsedMaterial.uniforms.u_ScaleDiffBaseMR = [0, 0, 0, 0];
+    parsedMaterial.uniforms.u_ScaleFGDSpec = [0, 0, 0, 0];
+  }
+  if (attributes.NORMAL)
+    parsedMaterial.defines.HAS_NORMALS = 1;
+  if (attributes.TANGENT && (options == null ? void 0 : options.useTangents))
+    parsedMaterial.defines.HAS_TANGENTS = 1;
+  if (attributes.TEXCOORD_0)
+    parsedMaterial.defines.HAS_UV = 1;
+  if (options == null ? void 0 : options.imageBasedLightingEnvironment)
+    parsedMaterial.defines.USE_IBL = 1;
+  if (options == null ? void 0 : options.lights)
+    parsedMaterial.defines.USE_LIGHTS = 1;
+  if (material) {
+    parseMaterial(device, material, parsedMaterial);
+  }
+  return parsedMaterial;
+}
+function parseMaterial(device, material, parsedMaterial) {
+  parsedMaterial.uniforms.pbr_uUnlit = Boolean(material.unlit);
+  if (material.pbrMetallicRoughness) {
+    parsePbrMetallicRoughness(device, material.pbrMetallicRoughness, parsedMaterial);
+  }
+  if (material.normalTexture) {
+    addTexture(device, material.normalTexture, "u_NormalSampler", "HAS_NORMALMAP", parsedMaterial);
+    const { scale = 1 } = material.normalTexture;
+    parsedMaterial.uniforms.u_NormalScale = scale;
+  }
+  if (material.occlusionTexture) {
+    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
+    );
+    parsedMaterial.uniforms.u_EmissiveFactor = material.emissiveFactor || [0, 0, 0];
+  }
+  switch (material.alphaMode) {
+    case "MASK":
+      const { alphaCutoff = 0.5 } = material;
+      parsedMaterial.defines.ALPHA_CUTOFF = 1;
+      parsedMaterial.uniforms.u_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 = import_constants.GL.FUNC_ADD;
+      parsedMaterial.glParameters.blendFunc = [import_constants.GL.SRC_ALPHA, import_constants.GL.ONE_MINUS_SRC_ALPHA, import_constants.GL.ONE, import_constants.GL.ONE_MINUS_SRC_ALPHA];
+      break;
+  }
+}
+function parsePbrMetallicRoughness(device, pbrMetallicRoughness, parsedMaterial) {
+  if (pbrMetallicRoughness.baseColorTexture) {
+    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
+    );
+  }
+  const { metallicFactor = 1, roughnessFactor = 1 } = pbrMetallicRoughness;
+  parsedMaterial.uniforms.u_MetallicRoughnessValues = [metallicFactor, roughnessFactor];
+}
+function addTexture(device, gltfTexture, uniformName, define = null, parsedMaterial) {
+  var _a, _b;
+  const parameters = ((_b = (_a = gltfTexture == null ? void 0 : gltfTexture.texture) == null ? void 0 : _a.sampler) == null ? void 0 : _b.parameters) || {};
+  const image = gltfTexture.texture.source.image;
+  let textureOptions;
+  let specialTextureParameters = {};
+  if (image.compressed) {
+    textureOptions = image;
+    specialTextureParameters = {
+      [import_constants.GL.TEXTURE_MIN_FILTER]: image.data.length > 1 ? import_constants.GL.LINEAR_MIPMAP_NEAREST : import_constants.GL.LINEAR
+    };
+  } else {
+    textureOptions = { data: image };
+  }
+  const texture = device.createTexture(__spreadValues({
+    id: gltfTexture.uniformName || gltfTexture.id,
+    parameters: __spreadValues(__spreadValues({}, parameters), specialTextureParameters),
+    pixelStore: {
+      [import_constants.GL.UNPACK_FLIP_Y_WEBGL]: false
+    }
+  }, textureOptions));
+  parsedMaterial.bindings[uniformName] = texture;
+  if (define)
+    parsedMaterial.defines[define] = 1;
+  parsedMaterial.generatedTextures.push(texture);
+}
+
+// src/gltf/gltf-instantiator.ts
+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
+var import_core2 = require("@luma.gl/core");
+var import_core3 = require("@math.gl/core");
+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 {
+  constructor(props) {
+    this.startTime = 0;
+    this.playing = true;
+    this.speed = 1;
+    this.channels = [];
+    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 {
+  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 length = components * accessor.count;
+    const { buffer, byteOffset } = accessor.bufferView.data;
+    const array = new ArrayType(buffer, byteOffset + (accessor.byteOffset || 0), length);
+    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 import_core3.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 import_core3.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}`)();
+    }
+  }
+  (0, import_core2.assert)(target[path].length === output[previousIndex].length);
+  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/gltf/create-gltf-model.ts
+var import_core4 = require("@luma.gl/core");
+var import_shadertools = require("@luma.gl/shadertools");
+var import_engine = require("@luma.gl/engine");
+var vs = `
+#pragma vscode_glsllint_stage: vert
+#if (__VERSION__ < 300)
+  #define _attr attribute
+#else
+  #define _attr in
+#endif
+
+  // _attr vec4 POSITION;
+  _attr vec4 positions;
+
+  #ifdef HAS_NORMALS
+    // _attr vec4 NORMAL;
+    _attr vec4 normals;
+  #endif
+
+  #ifdef HAS_TANGENTS
+    _attr vec4 TANGENT;
+  #endif
+
+  #ifdef HAS_UV
+    // _attr vec2 TEXCOORD_0;
+    _attr vec2 texCoords;
+  #endif
+
+  void main(void) {
+    vec4 _NORMAL = vec4(0.);
+    vec4 _TANGENT = vec4(0.);
+    vec2 _TEXCOORD_0 = vec2(0.);
+
+    #ifdef HAS_NORMALS
+      _NORMAL = normals;
+    #endif
+
+    #ifdef HAS_TANGENTS
+      _TANGENT = TANGENT;
+    #endif
+
+    #ifdef HAS_UV
+      _TEXCOORD_0 = texCoords;
+    #endif
+
+    pbr_setPositionNormalTangentUV(positions, _NORMAL, _TANGENT, _TEXCOORD_0);
+    gl_Position = u_MVPMatrix * positions;
+  }
+`;
+var fs = `
+#pragma vscode_glsllint_stage: frag
+#if (__VERSION__ < 300)
+  #define fragmentColor gl_FragColor
+#else
+  out vec4 fragmentColor;
+#endif
+
+  void main(void) {
+    vec3 pos = pbr_vPosition;
+    fragmentColor = pbr_filterColor(vec4(1.0));
+  }
+`;
+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 managedResources = [];
+  const parameters = {
+    depthWriteEnabled: true,
+    depthCompare: "less",
+    depthFormat: "depth24plus",
+    cullMode: "back"
+  };
+  const modelProps = __spreadValues({
+    id,
+    geometry,
+    topology: geometry.topology,
+    vertexCount,
+    modules: [import_shadertools.pbr],
+    defines: parsedMaterial.defines,
+    // parameters: parsedMaterial.parameters,
+    parameters,
+    // TODO use/merge parsedMaterial
+    vs: addVersionToShader(device, vs),
+    fs: addVersionToShader(device, fs),
+    bindings: parsedMaterial.bindings,
+    uniforms: parsedMaterial.uniforms
+  }, modelOptions);
+  const model = new import_engine.Model(device, modelProps);
+  return new import_engine.ModelNode({ managedResources, model });
+}
+function addVersionToShader(device, source) {
+  return device.info.type === "webgl2" ? `#version 300 es
+${source}` : source;
+}
+
+// src/gltf/gltf-instantiator.ts
+var DEFAULT_OPTIONS = {
+  modelOptions: {},
+  pbrDebug: false,
+  imageBasedLightingEnvironment: null,
+  lights: true,
+  useTangents: false
+};
+var GLTFInstantiator = class {
+  constructor(device, options = {}) {
+    this.device = import_webgl.WebGLDevice.attach(device);
+    this.options = __spreadValues(__spreadValues({}, 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);
+    }
+    return null;
+  }
+  createScene(gltfScene) {
+    const gltfNodes = gltfScene.nodes || [];
+    const nodes = gltfNodes.map((node) => this.createNode(node));
+    const scene = new import_engine2.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 import_engine2.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 import_core5.Matrix4().fromQuaternion(gltfNode.rotation);
+          node.matrix.multiplyRight(rotationMatrix);
+        }
+        if (gltfNode.scale) {
+          node.matrix.scale(gltfNode.scale);
+        }
+      }
+      gltfNode._node = 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_engine2.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, value };
+    }
+    ;
+    return new import_engine2.Geometry({
+      id,
+      topology,
+      indices: gltfPrimitive.indices.value,
+      attributes
+    });
+  }
+  createBuffer(attribute, usage) {
+    if (!attribute.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];
+  }
+  // TODO - create sampler in WebGL2
+  createSampler(gltfSampler) {
+    return gltfSampler;
+  }
+  // Helper methods (move to GLTFLoader.resolve...?)
+  needsPOT() {
+    return false;
+  }
+};
+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 2 /* LINE_LOOP */:
+      return "line-loop-webgl";
+    case 4 /* TRIANGLES */:
+      return "triangle-list";
+    case 5 /* TRIANGLE_STRIP */:
+      return "triangle-strip";
+    case 6 /* TRIANGLE_FAN */:
+      return "triangle-fan-webgl";
+    default:
+      throw new Error(drawMode);
+  }
+}
+
+// src/gltf/create-gltf-objects.ts
+function createScenegraphsFromGLTF(device, gltf, options) {
+  const instantiator = new GLTFInstantiator(device, options);
+  const scenes = instantiator.instantiate(gltf);
+  const animator = instantiator.createAnimator();
+  return { scenes, animator };
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export type { PBREnvironment } from './pbr/pbr-environment';
+export type { ParsePBRMaterialOptions, ParsedPBRMaterial } from './pbr/parse-pbr-material';
+export { parsePBRMaterial } from './pbr/parse-pbr-material';
+export { createScenegraphsFromGLTF } from './gltf/create-gltf-objects';
+export { GLTFAnimator } from './gltf/gltf-animator';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,YAAY,EAAC,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAC1D,YAAY,EAAC,uBAAuB,EAAE,iBAAiB,EAAC,MAAM,0BAA0B,CAAC;AACzF,OAAO,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAG1D,OAAO,EAAC,yBAAyB,EAAC,MAAM,4BAA4B,CAAC;AACrE,OAAO,EAAC,YAAY,EAAC,MAAM,sBAAsB,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export { parsePBRMaterial } from "./pbr/parse-pbr-material.js";
+export { createScenegraphsFromGLTF } from "./gltf/create-gltf-objects.js";
+export { GLTFAnimator } from "./gltf/gltf-animator.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["parsePBRMaterial","createScenegraphsFromGLTF","GLTFAnimator"],"sources":["../src/index.ts"],"sourcesContent":["// luma.gl, MIT license\n\nexport type {PBREnvironment} from './pbr/pbr-environment';\nexport type {ParsePBRMaterialOptions, ParsedPBRMaterial} from './pbr/parse-pbr-material';\nexport {parsePBRMaterial} from './pbr/parse-pbr-material';\n\n// glTF Scenegraph Instantiator\nexport {createScenegraphsFromGLTF} from './gltf/create-gltf-objects';\nexport {GLTFAnimator} from './gltf/gltf-animator';\n\n"],"mappings":"SAIQA,gBAAgB;AAAA,SAGhBC,yBAAyB;AAAA,SACzBC,YAAY"}

package/dist/pbr/parse-pbr-material.d.ts

@@ -0,0 +1,26 @@
+import type { Device, Texture, Binding, Parameters } from '@luma.gl/core';
+import { PBREnvironment } from './pbr-environment';
+export type ParsePBRMaterialOptions = {
+    /** Debug PBR shader */
+    pbrDebug?: boolean;
+    /** Enable lights */
+    lights?: any;
+    /** Use tangents */
+    useTangents?: boolean;
+    /** provide an image based (texture cube) lighting environment */
+    imageBasedLightingEnvironment?: PBREnvironment;
+};
+export type ParsedPBRMaterial = {
+    readonly defines: Record<string, number | boolean>;
+    readonly bindings: Record<string, Binding>;
+    readonly uniforms: Record<string, any>;
+    readonly parameters: Parameters;
+    readonly glParameters: Record<string, any>;
+    /** List of all generated textures, makes it easy to destroy them later */
+    readonly generatedTextures: Texture[];
+};
+/**
+ * Parses a GLTF material definition into uniforms and parameters for the PBR shader module
+ */
+export declare function parsePBRMaterial(device: Device, material: any, attributes: Record<string, any>, options: ParsePBRMaterialOptions): ParsedPBRMaterial;
+//# sourceMappingURL=parse-pbr-material.d.ts.map

package/dist/pbr/parse-pbr-material.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-pbr-material.d.ts","sourceRoot":"","sources":["../../src/pbr/parse-pbr-material.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAC,MAAM,eAAe,CAAC;AAGxE,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AAIjD,MAAM,MAAM,uBAAuB,GAAG;IACpC,uBAAuB;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,oBAAoB;IACpB,MAAM,CAAC,EAAE,GAAG,CAAC;IACb,mBAAmB;IACnB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,iEAAiE;IACjE,6BAA6B,CAAC,EAAE,cAAc,CAAC;CAChD,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC;IACnD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC3C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACvC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC3C,0EAA0E;IAC1E,QAAQ,CAAC,iBAAiB,EAAE,OAAO,EAAE,CAAC;CACvC,CAAC;AAEF;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,QAAQ,KAAA,EACR,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC/B,OAAO,EAAE,uBAAuB,GAC/B,iBAAiB,CAoDnB"}