(function (global, factory) {
  if (typeof define === "function" && define.amd) {
    define(["exports"], factory);
  } else if (typeof exports !== "undefined") {
    factory(exports);
  } else {
    var mod = {
      exports: {}
    };
    factory(mod.exports);
    global.DRACOExporter = mod.exports;
  }
})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports) {
  "use strict";

  Object.defineProperty(_exports, "__esModule", {
    value: true
  });
  _exports.DRACOExporter = void 0;

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }

  /**
   * Export draco compressed files from threejs geometry objects.
   *
   * Draco files are compressed and usually are smaller than conventional 3D file formats.
   *
   * The exporter receives a options object containing
   *  - decodeSpeed, indicates how to tune the encoder regarding decode speed (0 gives better speed but worst quality)
   *  - encodeSpeed, indicates how to tune the encoder parameters (0 gives better speed but worst quality)
   *  - encoderMethod
   *  - quantization, indicates the presision of each type of data stored in the draco file in the order (POSITION, NORMAL, COLOR, TEX_COORD, GENERIC)
   *  - exportUvs
   *  - exportNormals
   */

  /* global DracoEncoderModule */
  var DRACOExporter = /*#__PURE__*/function () {
    function DRACOExporter() {
      _classCallCheck(this, DRACOExporter);
    }

    _createClass(DRACOExporter, [{
      key: "parse",
      value: function parse(object) {
        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
          decodeSpeed: 5,
          encodeSpeed: 5,
          encoderMethod: DRACOExporter.MESH_EDGEBREAKER_ENCODING,
          quantization: [16, 8, 8, 8, 8],
          exportUvs: true,
          exportNormals: true,
          exportColor: false
        };

        if (object.isBufferGeometry === true) {
          throw new Error('DRACOExporter: The first parameter of parse() is now an instance of Mesh or Points.');
        }

        if (DracoEncoderModule === undefined) {
          throw new Error('THREE.DRACOExporter: required the draco_encoder to work.');
        }

        var geometry = object.geometry;
        var dracoEncoder = DracoEncoderModule();
        var encoder = new dracoEncoder.Encoder();
        var builder;
        var dracoObject;

        if (geometry.isBufferGeometry !== true) {
          throw new Error('THREE.DRACOExporter.parse(geometry, options): geometry is not a THREE.BufferGeometry instance.');
        }

        if (object.isMesh === true) {
          builder = new dracoEncoder.MeshBuilder();
          dracoObject = new dracoEncoder.Mesh();
          var vertices = geometry.getAttribute('position');
          builder.AddFloatAttributeToMesh(dracoObject, dracoEncoder.POSITION, vertices.count, vertices.itemSize, vertices.array);
          var faces = geometry.getIndex();

          if (faces !== null) {
            builder.AddFacesToMesh(dracoObject, faces.count / 3, faces.array);
          } else {
            var _faces = new (vertices.count > 65535 ? Uint32Array : Uint16Array)(vertices.count);

            for (var i = 0; i < _faces.length; i++) {
              _faces[i] = i;
            }

            builder.AddFacesToMesh(dracoObject, vertices.count, _faces);
          }

          if (options.exportNormals === true) {
            var normals = geometry.getAttribute('normal');

            if (normals !== undefined) {
              builder.AddFloatAttributeToMesh(dracoObject, dracoEncoder.NORMAL, normals.count, normals.itemSize, normals.array);
            }
          }

          if (options.exportUvs === true) {
            var uvs = geometry.getAttribute('uv');

            if (uvs !== undefined) {
              builder.AddFloatAttributeToMesh(dracoObject, dracoEncoder.TEX_COORD, uvs.count, uvs.itemSize, uvs.array);
            }
          }

          if (options.exportColor === true) {
            var colors = geometry.getAttribute('color');

            if (colors !== undefined) {
              builder.AddFloatAttributeToMesh(dracoObject, dracoEncoder.COLOR, colors.count, colors.itemSize, colors.array);
            }
          }
        } else if (object.isPoints === true) {
          builder = new dracoEncoder.PointCloudBuilder();
          dracoObject = new dracoEncoder.PointCloud();

          var _vertices = geometry.getAttribute('position');

          builder.AddFloatAttribute(dracoObject, dracoEncoder.POSITION, _vertices.count, _vertices.itemSize, _vertices.array);

          if (options.exportColor === true) {
            var _colors = geometry.getAttribute('color');

            if (_colors !== undefined) {
              builder.AddFloatAttribute(dracoObject, dracoEncoder.COLOR, _colors.count, _colors.itemSize, _colors.array);
            }
          }
        } else {
          throw new Error('DRACOExporter: Unsupported object type.');
        } //Compress using draco encoder


        var encodedData = new dracoEncoder.DracoInt8Array(); //Sets the desired encoding and decoding speed for the given options from 0 (slowest speed, but the best compression) to 10 (fastest, but the worst compression).

        var encodeSpeed = options.encodeSpeed !== undefined ? options.encodeSpeed : 5;
        var decodeSpeed = options.decodeSpeed !== undefined ? options.decodeSpeed : 5;
        encoder.SetSpeedOptions(encodeSpeed, decodeSpeed); // Sets the desired encoding method for a given geometry.

        if (options.encoderMethod !== undefined) {
          encoder.SetEncodingMethod(options.encoderMethod);
        } // Sets the quantization (number of bits used to represent) compression options for a named attribute.
        // The attribute values will be quantized in a box defined by the maximum extent of the attribute values.


        if (options.quantization !== undefined) {
          for (var _i = 0; _i < 5; _i++) {
            if (options.quantization[_i] !== undefined) {
              encoder.SetAttributeQuantization(_i, options.quantization[_i]);
            }
          }
        }

        var length;

        if (object.isMesh === true) {
          length = encoder.EncodeMeshToDracoBuffer(dracoObject, encodedData);
        } else {
          length = encoder.EncodePointCloudToDracoBuffer(dracoObject, true, encodedData);
        }

        dracoEncoder.destroy(dracoObject);

        if (length === 0) {
          throw new Error('THREE.DRACOExporter: Draco encoding failed.');
        } //Copy encoded data to buffer.


        var outputData = new Int8Array(new ArrayBuffer(length));

        for (var _i2 = 0; _i2 < length; _i2++) {
          outputData[_i2] = encodedData.GetValue(_i2);
        }

        dracoEncoder.destroy(encodedData);
        dracoEncoder.destroy(encoder);
        dracoEncoder.destroy(builder);
        return outputData;
      }
    }]);

    return DRACOExporter;
  }(); // Encoder methods


  _exports.DRACOExporter = DRACOExporter;
  DRACOExporter.MESH_EDGEBREAKER_ENCODING = 1;
  DRACOExporter.MESH_SEQUENTIAL_ENCODING = 0; // Geometry type

  DRACOExporter.POINT_CLOUD = 0;
  DRACOExporter.TRIANGULAR_MESH = 1; // Attribute type

  DRACOExporter.INVALID = -1;
  DRACOExporter.POSITION = 0;
  DRACOExporter.NORMAL = 1;
  DRACOExporter.COLOR = 2;
  DRACOExporter.TEX_COORD = 3;
  DRACOExporter.GENERIC = 4;
});