@loaders.gl/scene 5.0.0-beta.1 → 5.0.0-beta.10

package/dist/draco/lib/draco-builder.cjs

@@ -0,0 +1,660 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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/draco/lib/draco-builder.ts
+var draco_builder_exports = {};
+__export(draco_builder_exports, {
+  default: () => DracoBuilder
+});
+module.exports = __toCommonJS(draco_builder_exports);
+var GLTF_TO_DRACO_ATTRIBUTE_NAME_MAP = {
+  POSITION: "POSITION",
+  NORMAL: "NORMAL",
+  COLOR_0: "COLOR",
+  TEXCOORD_0: "TEX_COORD"
+};
+var noop = () => {
+};
+var DracoBuilder = class {
+  draco;
+  dracoEncoder;
+  dracoMeshBuilder;
+  dracoMetadataBuilder;
+  log = noop;
+  // draco - the draco decoder, either import `draco3d` or load dynamically
+  constructor(draco) {
+    this.draco = draco;
+    this.dracoEncoder = new this.draco.Encoder();
+    this.dracoMeshBuilder = new this.draco.MeshBuilder();
+    this.dracoMetadataBuilder = new this.draco.MetadataBuilder();
+  }
+  destroy() {
+    this.destroyEncodedObject(this.dracoMeshBuilder);
+    this.destroyEncodedObject(this.dracoEncoder);
+    this.destroyEncodedObject(this.dracoMetadataBuilder);
+  }
+  // TBD - when does this need to be called?
+  destroyEncodedObject(object) {
+    if (object) {
+      this.draco.destroy(object);
+    }
+  }
+  /**
+   * Encode mesh or point cloud
+   * @param mesh =({})
+   * @param options
+   */
+  encodeSync(mesh, options = {}) {
+    return this._encodeSync(mesh, options, false).data;
+  }
+  /** Encodes a mesh or point cloud and returns native encoding diagnostics. */
+  encodeSyncWithReport(mesh, options = {}) {
+    return this._encodeSync(mesh, options, true);
+  }
+  /** Shared implementation for ordinary encoding and report-producing encoding. */
+  _encodeSync(mesh, options, trackEncodedProperties) {
+    options = applyDracoEncodingPreset(options);
+    this.log = options.log || noop;
+    return options.pointcloud ? this._encodePointCloud(mesh, options, trackEncodedProperties) : this._encodeMesh(mesh, options, trackEncodedProperties);
+  }
+  // PRIVATE
+  _getAttributesFromMesh(mesh) {
+    return {
+      ...mesh.indices ? { indices: mesh.indices } : {},
+      ...mesh.attributes
+    };
+  }
+  _encodePointCloud(pointcloud, options, trackEncodedProperties) {
+    const dracoPointCloud = new this.draco.PointCloud();
+    const dracoData = new this.draco.DracoInt8Array();
+    let expertEncoder = null;
+    try {
+      if (options.metadata) {
+        this._addGeometryMetadata(dracoPointCloud, options.metadata);
+      }
+      const attributes = this._getAttributesFromMesh(pointcloud);
+      const attributeInfo = this._createDracoPointCloud(dracoPointCloud, attributes, options);
+      const useExpertEncoder = hasAttributeQuantization(options);
+      let encodedLen;
+      let activeEncoder;
+      if (useExpertEncoder) {
+        expertEncoder = new this.draco.ExpertEncoder(dracoPointCloud);
+        this._setExpertOptions(expertEncoder, attributeInfo, options);
+        activeEncoder = expertEncoder;
+        if (trackEncodedProperties) {
+          activeEncoder.SetTrackEncodedProperties(true);
+        }
+        encodedLen = expertEncoder.EncodeToDracoBuffer(
+          options.deduplicateValues ?? false,
+          dracoData
+        );
+      } else {
+        this._setOptions(options);
+        activeEncoder = this.dracoEncoder;
+        if (trackEncodedProperties) {
+          activeEncoder.SetTrackEncodedProperties(true);
+        }
+        encodedLen = this.dracoEncoder.EncodePointCloudToDracoBuffer(
+          dracoPointCloud,
+          options.deduplicateValues ?? false,
+          dracoData
+        );
+      }
+      if (!(encodedLen > 0)) {
+        throw new Error("Draco encoding failed.");
+      }
+      this.log(`DRACO encoded ${dracoPointCloud.num_points()} points
+        with ${dracoPointCloud.num_attributes()} attributes into ${encodedLen} bytes`);
+      const data = dracoInt8ArrayToArrayBuffer(dracoData);
+      return {
+        data,
+        report: this._getEncodingReport(
+          "point-cloud",
+          data.byteLength,
+          dracoPointCloud,
+          activeEncoder,
+          attributeInfo,
+          options,
+          trackEncodedProperties
+        )
+      };
+    } finally {
+      this.destroyEncodedObject(expertEncoder);
+      this.destroyEncodedObject(dracoData);
+      this.destroyEncodedObject(dracoPointCloud);
+    }
+  }
+  _encodeMesh(mesh, options, trackEncodedProperties) {
+    const dracoMesh = new this.draco.Mesh();
+    const dracoData = new this.draco.DracoInt8Array();
+    let expertEncoder = null;
+    try {
+      if (options.metadata) {
+        this._addGeometryMetadata(dracoMesh, options.metadata);
+      }
+      const attributes = this._getAttributesFromMesh(mesh);
+      const attributeInfo = this._createDracoMesh(dracoMesh, attributes, options);
+      const useExpertEncoder = hasAttributeQuantization(options);
+      let encodedLen;
+      let activeEncoder;
+      if (useExpertEncoder) {
+        expertEncoder = new this.draco.ExpertEncoder(dracoMesh);
+        this._setExpertOptions(expertEncoder, attributeInfo, options);
+        activeEncoder = expertEncoder;
+        if (trackEncodedProperties) {
+          activeEncoder.SetTrackEncodedProperties(true);
+        }
+        encodedLen = expertEncoder.EncodeToDracoBuffer(false, dracoData);
+      } else {
+        this._setOptions(options);
+        activeEncoder = this.dracoEncoder;
+        if (trackEncodedProperties) {
+          activeEncoder.SetTrackEncodedProperties(true);
+        }
+        encodedLen = this.dracoEncoder.EncodeMeshToDracoBuffer(dracoMesh, dracoData);
+      }
+      if (encodedLen <= 0) {
+        throw new Error("Draco encoding failed.");
+      }
+      this.log(`DRACO encoded ${dracoMesh.num_points()} points
+        with ${dracoMesh.num_attributes()} attributes into ${encodedLen} bytes`);
+      const data = dracoInt8ArrayToArrayBuffer(dracoData);
+      return {
+        data,
+        report: this._getEncodingReport(
+          "mesh",
+          data.byteLength,
+          dracoMesh,
+          activeEncoder,
+          attributeInfo,
+          options,
+          trackEncodedProperties
+        )
+      };
+    } finally {
+      this.destroyEncodedObject(expertEncoder);
+      this.destroyEncodedObject(dracoData);
+      this.destroyEncodedObject(dracoMesh);
+    }
+  }
+  /** Applies encoder speed, method, and quantization options. */
+  _setOptions(options) {
+    if (options.speed) {
+      this.dracoEncoder.SetSpeedOptions(...options.speed);
+    }
+    if (options.method) {
+      const dracoMethod = this.draco[options.method];
+      this.dracoEncoder.SetEncodingMethod(dracoMethod);
+    }
+    if (options.quantization) {
+      for (const attribute in options.quantization) {
+        const attributeType = attribute;
+        const bits = options.quantization[attributeType];
+        if (bits !== void 0) {
+          validateQuantizationBits(attributeType, bits, attributeType);
+          this.dracoEncoder.SetAttributeQuantization(this.draco[attributeType], bits);
+        }
+      }
+    }
+  }
+  /** Applies common options and per-attribute quantization to an expert encoder. */
+  _setExpertOptions(expertEncoder, attributes, options) {
+    if (options.speed) {
+      expertEncoder.SetSpeedOptions(...options.speed);
+    }
+    if (options.method) {
+      expertEncoder.SetEncodingMethod(this.draco[options.method]);
+    }
+    const quantization = this._getAttributeQuantization(attributes, options);
+    for (const [attributeName, setting] of quantization) {
+      const attribute = attributes[attributeName];
+      if (typeof setting === "number") {
+        expertEncoder.SetAttributeQuantization(attribute.attributeId, setting);
+      } else {
+        expertEncoder.SetAttributeExplicitQuantization(
+          attribute.attributeId,
+          setting.bits,
+          attribute.componentCount,
+          setting.origin,
+          setting.range
+        );
+      }
+    }
+  }
+  /** Resolves category and exact quantization settings for every encoded attribute. */
+  _getAttributeQuantization(attributes, options) {
+    const categoryQuantization = /* @__PURE__ */ new Map();
+    for (const attributeType of Object.keys(options.quantization || {})) {
+      const bits = options.quantization?.[attributeType];
+      if (bits !== void 0) {
+        validateQuantizationBits(attributeType, bits, attributeType);
+        categoryQuantization.set(this.draco[attributeType], bits);
+      }
+    }
+    const quantization = /* @__PURE__ */ new Map();
+    for (const [attributeName, attribute] of Object.entries(attributes)) {
+      const bits = categoryQuantization.get(attribute.attributeType);
+      if (bits !== void 0) {
+        quantization.set(attributeName, bits);
+      }
+    }
+    for (const [attributeName, setting] of Object.entries(options.attributeQuantization || {})) {
+      const attribute = attributes[attributeName];
+      if (!attribute) {
+        throw new Error(`DracoWriter: quantized attribute "${attributeName}" does not exist`);
+      }
+      if (typeof setting === "number") {
+        validateQuantizationBits(attributeName, setting, attribute.attributeTypeName);
+      } else {
+        if (attribute.attributeTypeName === "NORMAL") {
+          throw new Error(
+            `DracoWriter: explicit quantization transforms are not supported for NORMAL attribute "${attributeName}"`
+          );
+        }
+        validateExplicitQuantization(
+          attributeName,
+          attributes[attributeName].componentCount,
+          setting
+        );
+      }
+      quantization.set(attributeName, setting);
+    }
+    for (const attributeName of quantization.keys()) {
+      if (!attributes[attributeName].supportsQuantization) {
+        throw new Error(
+          `DracoWriter: quantization for "${attributeName}" requires floating-point attribute data`
+        );
+      }
+    }
+    return quantization;
+  }
+  /** Builds public diagnostics for a completed native encoding. */
+  _getEncodingReport(geometryType, byteLength, geometry, encoder, attributes, options, trackEncodedProperties) {
+    const quantization = this._getAttributeQuantization(attributes, options);
+    const attributeReports = {};
+    for (const [attributeName, attribute] of Object.entries(attributes)) {
+      attributeReports[attributeName] = {
+        id: attribute.attributeId,
+        type: attribute.attributeTypeName,
+        componentCount: attribute.componentCount,
+        ...quantization.has(attributeName) ? { quantization: quantization.get(attributeName) } : {}
+      };
+    }
+    return {
+      geometryType,
+      byteLength,
+      pointCount: trackEncodedProperties ? encoder.GetNumberOfEncodedPoints() : geometry.num_points(),
+      faceCount: trackEncodedProperties ? encoder.GetNumberOfEncodedFaces() : geometryType === "mesh" ? typeof geometry.num_faces === "function" ? geometry.num_faces() : 0 : 0,
+      attributeCount: geometry.num_attributes(),
+      ...options.method ? { method: options.method } : {},
+      ...options.speed ? { speed: options.speed } : {},
+      attributes: attributeReports
+    };
+  }
+  /**
+   * @param {Mesh} dracoMesh
+   * @param {object} attributes
+   * @returns {Mesh}
+   */
+  _createDracoMesh(dracoMesh, attributes, options) {
+    const optionalMetadata = options.attributesMetadata || {};
+    const attributeInfo = {};
+    const vertexCount = this._getVertexCount(attributes, options);
+    for (const [attributeName, attribute] of Object.entries(attributes)) {
+      const uniqueId = this._addAttributeToMesh(
+        dracoMesh,
+        attributeName,
+        attribute,
+        vertexCount,
+        options
+      );
+      if (uniqueId !== -1) {
+        const attributeValue = getAttributeValue(attribute);
+        const attributeType = this._getDracoAttributeType(
+          attributeName,
+          options.attributeTypes
+        );
+        attributeInfo[attributeName] = {
+          attributeId: uniqueId,
+          attributeType,
+          attributeTypeName: getDracoAttributeTypeName(this.draco, attributeType),
+          componentCount: getAttributeSize(attribute, attributeValue.length / vertexCount),
+          supportsQuantization: attributeValue instanceof Float32Array
+        };
+        this._addAttributeMetadata(dracoMesh, uniqueId, {
+          [options.attributeNameEntry || "name"]: attributeName,
+          ...optionalMetadata[attributeName] || {}
+        });
+      }
+    }
+    return attributeInfo;
+  }
+  /**
+   * @param {} dracoPointCloud
+   * @param {object} attributes
+   */
+  _createDracoPointCloud(dracoPointCloud, attributes, options) {
+    const optionalMetadata = options.attributesMetadata || {};
+    const attributeInfo = {};
+    const vertexCount = this._getVertexCount(attributes, options);
+    for (const [attributeName, attribute] of Object.entries(attributes)) {
+      const uniqueId = this._addAttributeToMesh(
+        dracoPointCloud,
+        attributeName,
+        attribute,
+        vertexCount,
+        options
+      );
+      if (uniqueId !== -1) {
+        const attributeValue = getAttributeValue(attribute);
+        const attributeType = this._getDracoAttributeType(
+          attributeName,
+          options.attributeTypes
+        );
+        attributeInfo[attributeName] = {
+          attributeId: uniqueId,
+          attributeType,
+          attributeTypeName: getDracoAttributeTypeName(this.draco, attributeType),
+          componentCount: getAttributeSize(attribute, attributeValue.length / vertexCount),
+          supportsQuantization: attributeValue instanceof Float32Array
+        };
+        this._addAttributeMetadata(dracoPointCloud, uniqueId, {
+          [options.attributeNameEntry || "name"]: attributeName,
+          ...optionalMetadata[attributeName] || {}
+        });
+      }
+    }
+    return attributeInfo;
+  }
+  /**
+   * @param mesh
+   * @param attributeName
+   * @param attribute
+   * @param vertexCount
+   */
+  _addAttributeToMesh(mesh, attributeName, attribute, vertexCount, options = {}) {
+    const attributeValue = getAttributeValue(attribute);
+    if (!attributeValue) {
+      throw new Error(`DracoWriter: attribute "${attributeName}" must contain a typed array`);
+    }
+    const type = this._getDracoAttributeType(attributeName, options.attributeTypes);
+    const size = getAttributeSize(attribute, attributeValue.length / vertexCount);
+    if (type === "indices") {
+      if (attributeValue.length % 3 !== 0) {
+        throw new Error("DracoWriter: triangle indices length must be divisible by 3");
+      }
+      validateIndices(attributeValue, vertexCount);
+      const numFaces = attributeValue.length / 3;
+      this.log(`Adding attribute ${attributeName}, size ${numFaces}`);
+      const indices = attributeValue instanceof Uint16Array || attributeValue instanceof Uint32Array ? attributeValue : Uint32Array.from(attributeValue);
+      this.dracoMeshBuilder.AddFacesToMesh(mesh, numFaces, indices);
+      return -1;
+    }
+    if (!Number.isInteger(size) || size <= 0 || attributeValue.length !== vertexCount * size) {
+      throw new Error(
+        `DracoWriter: attribute "${attributeName}" has ${attributeValue.length} values, expected ${vertexCount * size}`
+      );
+    }
+    this.log(`Adding attribute ${attributeName}, size ${size}`);
+    const builder = this.dracoMeshBuilder;
+    let uniqueAttributeId = -1;
+    if (attributeValue instanceof Int8Array) {
+      uniqueAttributeId = builder.AddInt8Attribute(mesh, type, vertexCount, size, attributeValue);
+    } else if (attributeValue instanceof Int16Array) {
+      uniqueAttributeId = builder.AddInt16Attribute(mesh, type, vertexCount, size, attributeValue);
+    } else if (attributeValue instanceof Int32Array) {
+      uniqueAttributeId = builder.AddInt32Attribute(mesh, type, vertexCount, size, attributeValue);
+    } else if (attributeValue instanceof Uint8Array) {
+      uniqueAttributeId = builder.AddUInt8Attribute(mesh, type, vertexCount, size, attributeValue);
+    } else if (attributeValue instanceof Uint8ClampedArray) {
+      const uint8Value = new Uint8Array(
+        attributeValue.buffer,
+        attributeValue.byteOffset,
+        attributeValue.byteLength
+      );
+      uniqueAttributeId = builder.AddUInt8Attribute(mesh, type, vertexCount, size, uint8Value);
+    } else if (attributeValue instanceof Uint16Array) {
+      uniqueAttributeId = builder.AddUInt16Attribute(mesh, type, vertexCount, size, attributeValue);
+    } else if (attributeValue instanceof Uint32Array) {
+      uniqueAttributeId = builder.AddUInt32Attribute(mesh, type, vertexCount, size, attributeValue);
+    } else if (attributeValue instanceof Float32Array) {
+      uniqueAttributeId = builder.AddFloatAttribute(mesh, type, vertexCount, size, attributeValue);
+    } else {
+      throw new Error(
+        `DracoWriter: attribute "${attributeName}" uses unsupported ${attributeValue.constructor.name}`
+      );
+    }
+    if (!ArrayBuffer.isView(attribute) && attribute.normalized !== void 0) {
+      builder.SetNormalizedFlagForAttribute(mesh, uniqueAttributeId, attribute.normalized);
+    }
+    return uniqueAttributeId;
+  }
+  /**
+   * DRACO can compress attributes of know type better
+   * @param attributeName
+   */
+  _getDracoAttributeType(attributeName, attributeTypes = {}) {
+    if (attributeName.toLowerCase() === "indices") {
+      return "indices";
+    }
+    const explicitType = attributeTypes[attributeName];
+    if (explicitType) {
+      return this.draco[explicitType];
+    }
+    const gltfAttributeName = GLTF_TO_DRACO_ATTRIBUTE_NAME_MAP[attributeName];
+    if (gltfAttributeName) {
+      return this.draco[gltfAttributeName];
+    }
+    switch (attributeName.toLowerCase()) {
+      case "position":
+      case "positions":
+      case "vertices":
+        return this.draco.POSITION;
+      case "normal":
+      case "normals":
+        return this.draco.NORMAL;
+      case "color":
+      case "colors":
+        return this.draco.COLOR;
+      case "texcoord":
+      case "texcoords":
+        return this.draco.TEX_COORD;
+      default:
+        if (/^color_\d+$/i.test(attributeName)) {
+          return this.draco.COLOR;
+        }
+        if (/^texcoord_\d+$/i.test(attributeName)) {
+          return this.draco.TEX_COORD;
+        }
+        return this.draco.GENERIC;
+    }
+  }
+  /** Returns the common vertex count after validating the required position attribute. */
+  _getVertexCount(attributes, options) {
+    const positions = this._getPositionAttribute(attributes, options.attributeTypes);
+    const positionValues = positions && getAttributeValue(positions);
+    if (!positions || !positionValues) {
+      throw new Error("DracoWriter: POSITION attribute is required");
+    }
+    const size = getAttributeSize(positions, 3);
+    if (!Number.isInteger(size) || size <= 0 || positionValues.length % size !== 0) {
+      throw new Error("DracoWriter: POSITION attribute has an invalid size or value count");
+    }
+    return positionValues.length / size;
+  }
+  _getPositionAttribute(attributes, attributeTypes = {}) {
+    for (const attributeName in attributes) {
+      const attribute = attributes[attributeName];
+      const dracoType = this._getDracoAttributeType(attributeName, attributeTypes);
+      if (dracoType === this.draco.POSITION && getAttributeValue(attribute)) {
+        return attribute;
+      }
+    }
+    return null;
+  }
+  /**
+   * Add metadata for the geometry.
+   * @param dracoGeometry - WASM Draco Object
+   * @param metadata
+   */
+  _addGeometryMetadata(dracoGeometry, metadata) {
+    const dracoMetadata = new this.draco.Metadata();
+    this._populateDracoMetadata(dracoMetadata, metadata);
+    this.dracoMeshBuilder.AddMetadata(dracoGeometry, dracoMetadata);
+  }
+  /**
+   * Add metadata for an attribute to geometry.
+   * @param dracoGeometry - WASM Draco Object
+   * @param uniqueAttributeId
+   * @param metadata
+   */
+  _addAttributeMetadata(dracoGeometry, uniqueAttributeId, metadata) {
+    const dracoAttributeMetadata = new this.draco.Metadata();
+    this._populateDracoMetadata(dracoAttributeMetadata, metadata);
+    this.dracoMeshBuilder.SetMetadataForAttribute(
+      dracoGeometry,
+      uniqueAttributeId,
+      dracoAttributeMetadata
+    );
+  }
+  /**
+   * Add contents of object or map to a WASM Draco Metadata Object
+   * @param dracoMetadata - WASM Draco Object
+   * @param metadata
+   */
+  _populateDracoMetadata(dracoMetadata, metadata) {
+    for (const [key, value] of getEntries(metadata)) {
+      switch (typeof value) {
+        case "number":
+          if (Math.trunc(value) === value) {
+            this.dracoMetadataBuilder.AddIntEntry(dracoMetadata, key, value);
+          } else {
+            this.dracoMetadataBuilder.AddDoubleEntry(dracoMetadata, key, value);
+          }
+          break;
+        case "object":
+          if (value instanceof Int32Array) {
+            this.dracoMetadataBuilder.AddIntEntryArray(dracoMetadata, key, value, value.length);
+          }
+          break;
+        case "string":
+        default:
+          this.dracoMetadataBuilder.AddStringEntry(dracoMetadata, key, value);
+      }
+    }
+  }
+};
+function dracoInt8ArrayToArrayBuffer(dracoData) {
+  const byteLength = dracoData.size();
+  const outputBuffer = new ArrayBuffer(byteLength);
+  const outputData = new Int8Array(outputBuffer);
+  for (let i = 0; i < byteLength; ++i) {
+    outputData[i] = dracoData.GetValue(i);
+  }
+  return outputBuffer;
+}
+function getEntries(container) {
+  return container instanceof Map ? container.entries() : Object.entries(container);
+}
+function getAttributeValue(attribute) {
+  if (ArrayBuffer.isView(attribute)) {
+    return attribute;
+  }
+  if (attribute && typeof attribute === "object" && "value" in attribute && ArrayBuffer.isView(attribute.value)) {
+    return attribute.value;
+  }
+  return null;
+}
+function getAttributeSize(attribute, inferredSize) {
+  return ArrayBuffer.isView(attribute) ? inferredSize : attribute.size;
+}
+function validateIndices(indices, vertexCount) {
+  for (const index of indices) {
+    if (!Number.isInteger(index) || index < 0 || index >= vertexCount) {
+      throw new Error(
+        `DracoWriter: triangle index ${index} is outside vertex range 0-${vertexCount - 1}`
+      );
+    }
+  }
+}
+function hasAttributeQuantization(options) {
+  return Boolean(
+    options.attributeQuantization && Object.keys(options.attributeQuantization).length
+  );
+}
+function validateQuantizationBits(attributeName, bits, attributeType) {
+  if (!Number.isInteger(bits) || bits < 1 || bits > 30) {
+    throw new Error(
+      `DracoWriter: quantization bits for "${attributeName}" must be an integer from 1 to 30`
+    );
+  }
+  if (attributeType === "NORMAL" && (bits < 2 || bits > 29)) {
+    throw new Error(
+      `DracoWriter: quantization bits for NORMAL attribute "${attributeName}" must be an integer from 2 to 29`
+    );
+  }
+}
+function validateExplicitQuantization(attributeName, componentCount, quantization) {
+  validateQuantizationBits(attributeName, quantization.bits);
+  if (!Array.isArray(quantization.origin) || quantization.origin.length !== componentCount) {
+    throw new Error(
+      `DracoWriter: quantization origin for "${attributeName}" must contain ${componentCount} values`
+    );
+  }
+  if (!quantization.origin.every(Number.isFinite)) {
+    throw new Error(`DracoWriter: quantization origin for "${attributeName}" must be finite`);
+  }
+  if (!Number.isFinite(quantization.range) || quantization.range <= 0) {
+    throw new Error(`DracoWriter: quantization range for "${attributeName}" must be positive`);
+  }
+}
+function getDracoAttributeTypeName(draco, attributeType) {
+  for (const name of ["POSITION", "NORMAL", "COLOR", "TEX_COORD", "GENERIC"]) {
+    if (draco[name] === attributeType) {
+      return name;
+    }
+  }
+  return "GENERIC";
+}
+function applyDracoEncodingPreset(options) {
+  const presetOptions = {
+    gltf: {
+      method: "MESH_EDGEBREAKER_ENCODING",
+      speed: [5, 5],
+      quantization: { POSITION: 14, NORMAL: 10, TEX_COORD: 12 }
+    },
+    webgpu: {
+      method: "MESH_SEQUENTIAL_ENCODING",
+      speed: [5, 5],
+      quantization: { POSITION: 14, NORMAL: 10, TEX_COORD: 12 }
+    },
+    balanced: {
+      method: "MESH_EDGEBREAKER_ENCODING",
+      speed: [5, 5],
+      quantization: { POSITION: 12, NORMAL: 10, TEX_COORD: 10 }
+    }
+  };
+  const preset = options.preset ? presetOptions[options.preset] : {};
+  return {
+    ...preset,
+    ...options,
+    quantization: { ...preset.quantization, ...options.quantization }
+  };
+}
+//# sourceMappingURL=draco-builder.cjs.map