minidraco 0.5.0 → 0.6.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,12 @@ 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`, no cast needed. Decoding runs on the main thread by default;
+opt into a worker pool (with a main-thread fallback) 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:
@@ -45,22 +45,30 @@ Median across an 18-model corpus vs [draco.js](https://github.com/mrdoob/draco.j
 
 | 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         |
+| single-threaded decode — bun (JSC)                 | 🟢 1.37× faster | 🟢 1.49× faster |
+| single-threaded decode — Chrome (V8)               | 🟢 1.41× faster | 🟢 1.26× faster |
+| `GLTFLoader.parse`, warm worker pool — Chrome (V8) | 🟢 1.45× faster | 🟢 1.03× faster |
+| `GLTFLoader.parse`, cold first load — Chrome (V8)  | 🟢 1.37× faster | 🟢 1.23× faster |
 
-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).
+Faster than draco.js across the corpus, ahead of the wasm decoder single-threaded, and level with
+it in a real `GLTFLoader.parse` with `workers: true` and the main thread left free — warm, and
+level to ahead on the first load of a session (cold numbers swing run to run), 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).
 
 ## 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.
+Minified + brotli, vs the same two decoders (regenerate with `bun run sizes`):
+
+| download (brotli)             | minidraco | vs draco.js      | vs draco3d wasm         |
+| ----------------------------- | --------- | ---------------- | ----------------------- |
+| single-threaded (default)     | 22 KB     | ⚪ even (22 KB)  | 🟢 3.7× smaller (81 KB) |
+| worker pool (`workers: true`) | 45 KB     | 🟢 not supported | 🟢 1.8× smaller (81 KB) |
+
+With `workers: true` the browser also fetches the pool module and a worker chunk holding a second
+copy of the decoder on the first decode. draco.js has no worker pool. The wasm path ships three's
+`DRACOLoader` in your bundle and fetches the wrapper and `draco_decoder.wasm`, which you must
+host, before the first decode.
 
 ## Monorepo
 

package/dist/index.d.ts

@@ -1,12 +1,9 @@
 declare class DataBuffer {
     _data: Uint8Array;
-    constructor();
-    update(data: Uint8Array | ArrayBufferView | ArrayBuffer | null | undefined, size: number, offset?: number): boolean;
-    resize(newSize: number): void;
+    update(data: Uint8Array | null, size: number): void;
     adoptScratch(size: number): void;
-    write(bytePos: number, inArray: Uint8Array | ArrayBufferView | ArrayBuffer, dataSize: number): void;
+    write(bytePos: number, inArray: Uint8Array, dataSize: number): void;
     get data(): Uint8Array;
-    get dataSize(): number;
     _resize(newSize: number): void;
 }
 
@@ -28,10 +25,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;
@@ -44,46 +38,25 @@ declare class GeometryAttribute {
 }
 
 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;
+    transformType: number;
+    _values: number[];
+    _types: string[];
     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;
     constructor(geometryAttribute?: GeometryAttribute);
     init(attributeType: number, numComponents: number, dataType: number, normalized: boolean, numAttributeValues: number): void;
     reset(numAttributeValues: number): boolean;
@@ -94,21 +67,19 @@ declare class PointAttribute extends GeometryAttribute {
     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;
 }
 
 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 +94,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;