minidraco 0.6.0 → 0.8.0

package/README.md

@@ -15,8 +15,7 @@ gltfLoader.setDRACOLoader(new MinidracoLoader())
 gltfLoader.load('model.glb', gltf => scene.add(gltf.scene))
 ```
 
-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:
+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: true }) // decode in a pool of 4 workers
@@ -39,36 +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.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 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).
+| single-threaded decode — bun (JSC)                 | 🟢 1.60× faster | 🟢 1.69× faster |
+| single-threaded decode — Chrome (V8)               | 🟢 1.57× faster | 🟢 1.43× faster |
+| `GLTFLoader.parse`, warm worker pool — Chrome (V8) | 🟢 1.57× faster | 🟢 1.06× faster |
+| `GLTFLoader.parse`, cold first load — Chrome (V8)  | 🟢 1.42× faster | 🟢 1.28× faster |
 
 ## Download size
 
-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.
+| download (brotli)             | minidraco | vs draco.js              | vs draco3d wasm          |
+| ----------------------------- | --------- | ------------------------ | ------------------------ |
+| single-threaded (default)     | 21 KB     | 🟢 1.05× smaller (22 KB) | 🟢 3.84× smaller (81 KB) |
+| worker pool (`workers: true`) | 43 KB     | 🟢 not supported         | 🟢 1.85× smaller (81 KB) |
 
 ## Monorepo
 
@@ -84,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,7 +1,6 @@
 declare class DataBuffer {
     _data: Uint8Array;
     update(data: Uint8Array | null, size: number): void;
-    adoptScratch(size: number): void;
     write(bytePos: number, inArray: Uint8Array, dataSize: number): void;
     get data(): Uint8Array;
     _resize(newSize: number): void;
@@ -37,13 +36,6 @@ declare class GeometryAttribute {
     set uniqueId(id: number);
 }
 
-declare class AttributeTransformData {
-    transformType: number;
-    _values: number[];
-    _types: string[];
-    appendParameterValue(value: number, type: string): void;
-}
-
 type ExtractTypedArray = Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;
 type ViewCtor = (new (buffer: ArrayBufferLike) => ExtractTypedArray) & {
     BYTES_PER_ELEMENT: number;
@@ -53,14 +45,21 @@ declare class PointAttribute extends GeometryAttribute {
     _numUniqueEntries: number;
     _indicesMap: number[] | Uint32Array;
     _attributeBuffer: DataBuffer | null;
-    _attributeTransformData: AttributeTransformData | null;
     _cachedViewCtor: ViewCtor | null;
     _cachedViewBuffer: ArrayBufferLike | null;
     _cachedView: ExtractTypedArray | null;
+    _lazyKind: number;
+    _lazyValues: Int32Array | null;
+    _lazyMin: number[];
+    _lazyScale: number;
+    _lazyBounded: boolean;
     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, bounded: boolean): void;
+    setLazyOctahedron(values: Int32Array | null, scale: number, bounded: boolean): void;
     get size(): number;
     mappedIndex(pointIndex: number): number;
     get isMappingIdentity(): boolean;
@@ -70,10 +69,14 @@ declare class PointAttribute extends GeometryAttribute {
     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>;
+    _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 {