minidraco 0.5.0 → 0.7.0

package/dist/pool.js

@@ -0,0 +1,154 @@
+// src/three/pool.ts
+var decodeError = (message) => {
+  const error = new Error(message);
+  error.isDecodeError = true;
+  return error;
+};
+var WorkerPool = class {
+  // Pool size; the loader keeps it in sync with setWorkerLimit().
+  limit;
+  Ha;
+  D = [];
+  Gc = 0;
+  _ = /* @__PURE__ */ new Map();
+  // Tasks queued during the current microtask; flushed as one batched message
+  // per worker (a 488-primitive scene costs 4 postMessages, not 488).
+  Ia = [];
+  Za = false;
+  // Set when spawning a worker fails (bundler without module-worker support,
+  // file:// pages, …) or a worker errors: the loader then decodes on the main
+  // thread.
+  broken = false;
+  // Same-origin blob bootstrap used when the worker asset lives on a CDN
+  // origin (created lazily, revoked on dispose).
+  pa = null;
+  constructor(limit, workerUrl) {
+    this.limit = limit;
+    this.Ha = workerUrl;
+  }
+  // Spawns the whole pool up front: each fresh worker runs a short JIT warmup
+  // at startup (see worker.ts), so spawning early lets that overlap the model
+  // download instead of the first decode burst.
+  spawnAll() {
+    while (this.D.length < this.limit && this.cc() !== null) {
+    }
+  }
+  dispose() {
+    for (const entry of this.D) entry.worker.terminate();
+    this.D = [];
+    const error = decodeError("MinidracoLoader: disposed while decoding");
+    for (const task of this.Ia) task.reject(error);
+    this.Ia = [];
+    this.Za = false;
+    for (const [, task] of this._) task.reject(error);
+    this._.clear();
+    if (this.pa !== null) {
+      URL.revokeObjectURL(this.pa);
+      this.pa = null;
+    }
+  }
+  decode(buffer, taskConfig) {
+    const id = this.Gc++;
+    return new Promise((resolve, reject) => {
+      this.Ia.push({ id, buffer, taskConfig, resolve, reject });
+      if (!this.Za) {
+        this.Za = true;
+        queueMicrotask(() => this.Hc());
+      }
+    });
+  }
+  cc() {
+    if (this.broken) return null;
+    if (this.D.length < this.limit) {
+      const workerUrl = this.Ha ?? new URL("./worker.js", import.meta.url);
+      let worker;
+      try {
+        worker = new Worker(workerUrl, { type: "module" });
+      } catch {
+        try {
+          if (this.pa === null) {
+            const bootstrap = `import ${JSON.stringify(String(workerUrl))};`;
+            this.pa = URL.createObjectURL(new Blob([bootstrap], { type: "text/javascript" }));
+          }
+          worker = new Worker(this.pa, { type: "module" });
+        } catch {
+          this.broken = true;
+          return null;
+        }
+      }
+      const entry = { worker, pending: 0 };
+      worker.onmessage = (event) => {
+        for (const { id, ok, indices, attributes, error } of event.data.results) {
+          const task = this._.get(id);
+          if (!task) continue;
+          this._.delete(id);
+          task.entry.pending--;
+          if (ok) {
+            task.resolve({ indices, attributes });
+          } else {
+            task.reject(decodeError(error));
+          }
+        }
+      };
+      worker.onerror = (event) => {
+        this.broken = true;
+        for (const [id, task] of this._) {
+          if (task.entry.worker === worker) {
+            this._.delete(id);
+            task.reject(new Error(`MinidracoLoader worker failed: ${event.message ?? "unknown error"}`));
+          }
+        }
+      };
+      this.D.push(entry);
+      return entry;
+    }
+    let best = this.D[0];
+    for (const entry of this.D) if (entry.pending < best.pending) best = entry;
+    return best;
+  }
+  Hc() {
+    this.Za = false;
+    const batch = this.Ia;
+    if (batch.length === 0) return;
+    this.Ia = [];
+    while (this.D.length < Math.min(this.limit, batch.length) && this.cc() !== null) {
+    }
+    if (this.broken || this.D.length === 0) {
+      const error = new Error("MinidracoLoader: worker unavailable");
+      for (const task of batch) task.reject(error);
+      return;
+    }
+    batch.sort((a, b) => b.buffer.byteLength - a.buffer.byteLength);
+    let totalBytes = 0;
+    for (const task of batch) totalBytes += task.buffer.byteLength;
+    const averageBytes = totalBytes / batch.length;
+    const buckets = this.D.map((entry) => ({
+      entry,
+      tasks: [],
+      bytes: entry.pending * averageBytes
+    }));
+    for (const task of batch) {
+      let best = buckets[0];
+      for (const bucket of buckets) if (bucket.bytes < best.bytes) best = bucket;
+      best.tasks.push(task);
+      best.bytes += task.buffer.byteLength;
+    }
+    for (const { entry, tasks } of buckets) {
+      if (tasks.length === 0) continue;
+      entry.pending += tasks.length;
+      for (const task of tasks) this._.set(task.id, { resolve: task.resolve, reject: task.reject, entry });
+      entry.worker.postMessage({
+        tasks: tasks.map((task) => ({
+          id: task.id,
+          buffer: task.buffer,
+          attributeIDs: task.taskConfig.attributeIDs,
+          attributeTypes: task.taskConfig.attributeTypes,
+          useUniqueIDs: task.taskConfig.useUniqueIDs
+        }))
+      });
+    }
+  }
+};
+export {
+  WorkerPool
+};

package/dist/three.d.ts

@@ -2,13 +2,9 @@ import { Loader, BufferGeometry, LoadingManager, BufferAttribute } from 'three';
 
 declare class DataBuffer {
     _data: Uint8Array;
-    constructor();
-    update(data: Uint8Array | ArrayBufferView | ArrayBuffer | null | undefined, size: number, offset?: number): boolean;
-    resize(newSize: number): void;
-    adoptScratch(size: number): void;
-    write(bytePos: number, inArray: Uint8Array | ArrayBufferView | ArrayBuffer, dataSize: number): void;
+    update(data: Uint8Array | null, size: number): void;
+    write(bytePos: number, inArray: Uint8Array, dataSize: number): void;
     get data(): Uint8Array;
-    get dataSize(): number;
     _resize(newSize: number): void;
 }
 
@@ -21,10 +17,7 @@ declare class GeometryAttribute {
     _byteOffset: number;
     _attributeType: number;
     _uniqueId: number;
-    constructor();
     init(attributeType: number, buffer: DataBuffer | null, numComponents: number, dataType: number, normalized: boolean, byteStride: number, byteOffset: number): void;
-    getAddress(attIndex: number): Uint8Array;
-    copyFrom(srcAtt: GeometryAttribute): boolean;
     resetBuffer(buffer: DataBuffer, byteStride: number, byteOffset: number): void;
     get attributeType(): number;
     get dataType(): number;
@@ -36,72 +29,52 @@ declare class GeometryAttribute {
     set uniqueId(id: number);
 }
 
-declare class AttributeTransformData {
-    _transformType: number;
-    _bytes: Uint8Array;
-    _view: DataView;
-    _size: number;
-    constructor();
-    get transformType(): number;
-    set transformType(type: number);
-    get dataSize(): number;
-    get data(): Uint8Array;
-    _reserve(sizeNeeded: number): void;
-    setParameterValue(byteOffset: number, value: number, type: string): void;
-    appendParameterValue(value: number, type: string): void;
-    _typeSize(type: string): number;
-}
-
 type ExtractTypedArray = Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;
+type ViewCtor = (new (buffer: ArrayBufferLike) => ExtractTypedArray) & {
+    BYTES_PER_ELEMENT: number;
+};
 declare class PointAttribute extends GeometryAttribute {
     _identityMapping: boolean;
     _numUniqueEntries: number;
     _indicesMap: number[] | Uint32Array;
     _attributeBuffer: DataBuffer | null;
-    _attributeTransformData: AttributeTransformData | null;
-    _cachedFloat32View?: Float32Array;
-    _cachedFloat32Buffer?: ArrayBufferLike;
-    _cachedInt32View?: Int32Array;
-    _cachedInt32Buffer?: ArrayBufferLike;
-    _cachedUint32View?: Uint32Array;
-    _cachedUint32Buffer?: ArrayBufferLike;
-    _cachedUint16View?: Uint16Array;
-    _cachedUint16Buffer?: ArrayBufferLike;
-    _cachedInt16View?: Int16Array;
-    _cachedInt16Buffer?: ArrayBufferLike;
-    _cachedUint8View?: Uint8Array;
-    _cachedUint8Buffer?: ArrayBufferLike;
-    _cachedInt8View?: Int8Array;
-    _cachedInt8Buffer?: ArrayBufferLike;
-    _cachedFloat64View?: Float64Array;
-    _cachedFloat64Buffer?: ArrayBufferLike;
-    _cachedDataView?: DataView;
-    _cachedDVBuffer?: ArrayBufferLike;
+    _cachedViewCtor: ViewCtor | null;
+    _cachedViewBuffer: ArrayBufferLike | null;
+    _cachedView: ExtractTypedArray | null;
+    _lazyKind: number;
+    _lazyValues: Int32Array | null;
+    _lazyMin: number[];
+    _lazyScale: number;
     constructor(geometryAttribute?: GeometryAttribute);
     init(attributeType: number, numComponents: number, dataType: number, normalized: boolean, numAttributeValues: number): void;
     reset(numAttributeValues: number): boolean;
-    resetScratch(numAttributeValues: number): boolean;
+    resetLazy(numAttributeValues: number): void;
+    setLazyInteger(values: Int32Array | null): void;
+    setLazyQuantized(values: Int32Array | null, minValues: number[], delta: number): void;
+    setLazyOctahedron(values: Int32Array | null, scale: number): void;
     get size(): number;
     mappedIndex(pointIndex: number): number;
     get isMappingIdentity(): boolean;
     get indicesMapSize(): number;
     get indicesMap(): number[] | Uint32Array;
     setIdentityMapping(): void;
-    setExplicitMapping(numPoints: number): void;
     setExplicitMappingUnfilled(numPoints: number): void;
     setExplicitMappingShared(map: Uint32Array): void;
     setExplicitMappingScratch(numPoints: number): void;
-    setAttributeTransformData(transformData: AttributeTransformData): void;
+    _view(Ctor: ViewCtor, bufData: Uint8Array): ExtractTypedArray;
     convertValue(attIndex: number, outVal: number[] | Int32Array | Uint32Array | Float32Array | Float64Array): void;
     extractTo<C extends new (length: number) => ExtractTypedArray>(OutputTypedArray: C, numPoints: number): InstanceType<C>;
-    copyFrom(srcAtt: PointAttribute): void;
+    _lazyMap(numPoints: number): Uint32Array;
+    _lazyFloatValues(): Int32Array;
+    _extractQuantized(out: ExtractTypedArray, numPoints: number): void;
+    _extractOctahedron(out: ExtractTypedArray, numPoints: number): void;
+    _extractInteger(out: ExtractTypedArray, numPoints: number): void;
 }
 
 declare class PointCloud {
     num_points_: number;
     attributes_: (PointAttribute | null)[];
     named_attribute_index_: number[][];
-    constructor();
     numNamedAttributes(type: number): number;
     getNamedAttributeId(type: number, i?: number): number;
     getNamedAttribute(type: number, i?: number): PointAttribute | null;
@@ -116,26 +89,12 @@ declare class PointCloud {
 }
 
 declare class Mesh extends PointCloud {
-    faces_: Int32Array;
+    faces_: Int32Array<ArrayBuffer>;
     numFaces_: number;
-    attribute_data_: {
-        elementType: number;
-    }[];
-    constructor();
     setNumFaces(numFaces: number): void;
     numFaces(): number;
-    face(faceId: number): number[];
-    setAttribute(attId: number, pa: PointAttribute): void;
 }
 
-type AttributeIDs = Record<string, number | string>;
-type AttributeTypes = Record<string, string>;
-interface MinidracoLoaderOptions {
-    manager?: LoadingManager;
-    workers?: boolean;
-    workerLimit?: number;
-    mainThreadByteThreshold?: number;
-}
 interface TaskConfig {
     attributeIDs: AttributeIDs;
     attributeTypes: AttributeTypes;
@@ -162,23 +121,46 @@ interface QueuedTask {
     resolve: (raw: RawGeometry) => void;
     reject: (error: unknown) => void;
 }
+interface PendingTask {
+    resolve: (raw: RawGeometry) => void;
+    reject: (error: unknown) => void;
+    entry: WorkerEntry;
+}
+declare class WorkerPool {
+    limit: number;
+    _workerUrl: string | URL | null;
+    _workers: WorkerEntry[];
+    _taskId: number;
+    _tasks: Map<number, PendingTask>;
+    _batch: QueuedTask[];
+    _batchScheduled: boolean;
+    broken: boolean;
+    _blobUrl: string | null;
+    constructor(limit: number, workerUrl: string | URL | null);
+    spawnAll(): void;
+    dispose(): void;
+    decode(buffer: ArrayBuffer, taskConfig: TaskConfig): Promise<RawGeometry>;
+    _getWorker(): WorkerEntry | null;
+    _flushBatch(): void;
+}
+
+type AttributeIDs = Record<string, number | string>;
+type AttributeTypes = Record<string, string>;
+interface MinidracoLoaderOptions {
+    manager?: LoadingManager;
+    workers?: boolean;
+    workerLimit?: number;
+    mainThreadByteThreshold?: number;
+}
 declare class MinidracoLoader extends Loader<BufferGeometry> {
     defaultAttributeIDs: AttributeIDs;
     defaultAttributeTypes: AttributeTypes;
     workerLimit: number;
     mainThreadByteThreshold: number;
-    _workers: WorkerEntry[];
-    _taskId: number;
-    _tasks: Map<number, {
-        resolve: (raw: RawGeometry) => void;
-        reject: (error: unknown) => void;
-        entry: WorkerEntry;
-    }>;
-    _batch: QueuedTask[];
-    _batchScheduled: boolean;
+    _pool: WorkerPool | null;
+    _poolPromise: Promise<WorkerPool | null> | null;
     _workersBroken: boolean;
     _workerUrl: string | URL | null;
-    _workerBlobUrl: string | null;
     constructor(managerOrOptions?: LoadingManager | MinidracoLoaderOptions);
     setWorkerUrl(url: string | URL | null): this;
     setDecoderPath(_path?: unknown): this;
@@ -193,9 +175,7 @@ declare class MinidracoLoader extends Loader<BufferGeometry> {
     decodeGeometry(buffer: ArrayBuffer, taskConfig: TaskConfig): Promise<BufferGeometry>;
     _runTask(buffer: ArrayBuffer, taskConfig: TaskConfig): Promise<BufferGeometry>;
     _workersAvailable(): boolean;
-    _getWorker(): WorkerEntry | null;
-    _decodeInWorker(buffer: ArrayBuffer, taskConfig: TaskConfig): Promise<RawGeometry>;
-    _flushBatch(): void;
+    _getPool(): Promise<WorkerPool | null>;
     _buildGeometryFromRaw(raw: RawGeometry, taskConfig: TaskConfig): BufferGeometry;
     _decodeBuffer(buffer: ArrayBuffer, taskConfig: TaskConfig): BufferGeometry;
     _buildGeometry(dracoGeometry: Mesh, taskConfig: TaskConfig): BufferGeometry;