minidraco 0.5.0 → 0.7.0

package/README.md

@@ -1,8 +1,8 @@
 # 🐲 minidraco
 
 A fast, pure-TypeScript [Draco](https://google.github.io/draco/) mesh decoder with a drop-in
-`DRACOLoader` for [Three.js](https://threejs.org/) — no wasm to host or fetch, and a worker pool
-so decoding never blocks the main thread.
+`DRACOLoader` for [Three.js](https://threejs.org/) — no wasm to host or fetch, and an optional
+worker pool so decoding never blocks the main thread.
 
 ## Usage
 
@@ -15,12 +15,11 @@ gltfLoader.setDRACOLoader(new MinidracoLoader())
 gltfLoader.load('model.glb', gltf => scene.add(gltf.scene))
 ```
 
-A drop-in for `THREE.DRACOLoader`, no cast needed. Decoding runs in a worker pool by default, with
-a main-thread fallback. Options:
+A drop-in for `THREE.DRACOLoader`. Decoding runs on the main thread by default. Opt into a worker pool if you prefer to keep it free:
 
 ```ts
-new MinidracoLoader({ workers: false }) // decode on the main thread
-new MinidracoLoader({ workerLimit: 8 }) // pool size (default 4)
+new MinidracoLoader({ workers: true }) // decode in a pool of 4 workers
+new MinidracoLoader({ workerLimit: 8 }) // pool of 8
 ```
 
 Or decode a raw bitstream without Three.js:
@@ -39,28 +38,23 @@ const mesh = decodeDracoMesh(new Uint8Array(bytes))
 
 ## Performance
 
-Median across an 18-model corpus vs [draco.js](https://github.com/mrdoob/draco.js) and the official
+Median across 18 models vs [draco.js](https://github.com/mrdoob/draco.js) and the official
 [draco3d](https://www.npmjs.com/package/draco3d) wasm decoder (full results in
 [BENCH.md](https://github.com/verekia/minidraco/blob/main/BENCH.md)):
 
 | benchmark                                          | vs draco.js     | vs draco3d wasm |
 | -------------------------------------------------- | --------------- | --------------- |
-| single-threaded decode — bun (JSC)                 | 🟢 1.27× faster | 🟢 1.38× faster |
-| single-threaded decode — Chrome (V8)               | 🟢 1.29× faster | 🟢 1.11× faster |
-| `GLTFLoader.parse`, warm worker pool — Chrome (V8) | 🟢 1.62× faster | ⚪ even         |
-| `GLTFLoader.parse`, cold first load — Chrome (V8)  | 🟢 1.31× faster | ⚪ even         |
-
-Faster than draco.js across the corpus, ahead of the wasm decoder single-threaded, and even with
-it in a real `GLTFLoader.parse` with the main thread left free — both warm and on the first load
-of a session, where minidraco's worker pool is still JIT-warming while the wasm decoder is
-fetching and compiling its module (no `draco_decoder.wasm` to host or download here).
+| single-threaded decode — bun (JSC)                 | 🟢 1.53× faster | 🟢 1.53× faster |
+| single-threaded decode — Chrome (V8)               | 🟢 1.44× faster | 🟢 1.27× faster |
+| `GLTFLoader.parse`, warm worker pool — Chrome (V8) | 🟢 1.47× faster | 🟢 1.03× faster |
+| `GLTFLoader.parse`, cold first load — Chrome (V8)  | 🟢 1.42× faster | 🟢 1.26× faster |
 
 ## Download size
 
-Over the wire (brotli): **~23 KB** ships in your app bundle. With the worker pool on (default) the
-browser also fetches a **~22 KB** worker chunk on the first decode — **~45 KB** total; `workers: false`
-skips that fetch. **draco.js ~22 KB**, **draco3d wasm ~76 KB** — the wasm is a separate file you
-must host, while the JS decoders ship inside your bundle.
+| download (brotli)             | minidraco | vs draco.js              | vs draco3d wasm          |
+| ----------------------------- | --------- | ------------------------ | ------------------------ |
+| single-threaded (default)     | 21 KB     | 🟢 1.04× smaller (22 KB) | 🟢 3.82× smaller (81 KB) |
+| worker pool (`workers: true`) | 44 KB     | 🟢 not supported         | 🟢 1.84× smaller (81 KB) |
 
 ## Monorepo
 
@@ -76,5 +70,5 @@ bun run bench  # cross-decoder benchmark
 
 ## License
 
-MIT — derived from [mrdoob/draco.js](https://github.com/mrdoob/draco.js) (MIT), implementing
+MIT — initially derived from [mrdoob/draco.js](https://github.com/mrdoob/draco.js) (MIT), implementing
 Google's [Draco](https://github.com/google/draco) bitstream (Apache-2.0).

package/dist/index.d.ts

@@ -1,12 +1,8 @@
 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;
 }
 
@@ -28,10 +24,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;
@@ -43,72 +36,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;
@@ -123,16 +96,10 @@ 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;
 }
 
 declare const decodeDracoMesh: (data: Uint8Array) => Mesh;