minidraco 0.7.0 → 0.9.0

package/dist/pool.js

@@ -7,70 +7,70 @@ var decodeError = (message) => {
 var WorkerPool = class {
   // Pool size; the loader keeps it in sync with setWorkerLimit().
   limit;
-  Ha;
+  Ga;
   D = [];
-  Gc = 0;
-  _ = /* @__PURE__ */ new Map();
+  Ec = 0;
+  da = /* @__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;
+  Ha = [];
+  Ya = 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;
+  oa = null;
   constructor(limit, workerUrl) {
     this.limit = limit;
-    this.Ha = workerUrl;
+    this.Ga = 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) {
+    while (this.D.length < this.limit && this.ac() !== 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;
+    for (const task of this.Ha) task.reject(error);
+    this.Ha = [];
+    this.Ya = false;
+    for (const [, task] of this.da) task.reject(error);
+    this.da.clear();
+    if (this.oa !== null) {
+      URL.revokeObjectURL(this.oa);
+      this.oa = null;
     }
   }
   decode(buffer, taskConfig) {
-    const id = this.Gc++;
+    const id = this.Ec++;
     return new Promise((resolve, reject) => {
-      this.Ia.push({ id, buffer, taskConfig, resolve, reject });
-      if (!this.Za) {
-        this.Za = true;
-        queueMicrotask(() => this.Hc());
+      this.Ha.push({ id, buffer, taskConfig, resolve, reject });
+      if (!this.Ya) {
+        this.Ya = true;
+        queueMicrotask(() => this.Fc());
       }
     });
   }
-  cc() {
+  ac() {
     if (this.broken) return null;
     if (this.D.length < this.limit) {
-      const workerUrl = this.Ha ?? new URL("./worker.js", import.meta.url);
+      const workerUrl = this.Ga ?? new URL("./worker.js", import.meta.url);
       let worker;
       try {
         worker = new Worker(workerUrl, { type: "module" });
       } catch {
         try {
-          if (this.pa === null) {
+          if (this.oa === null) {
             const bootstrap = `import ${JSON.stringify(String(workerUrl))};`;
-            this.pa = URL.createObjectURL(new Blob([bootstrap], { type: "text/javascript" }));
+            this.oa = URL.createObjectURL(new Blob([bootstrap], { type: "text/javascript" }));
           }
-          worker = new Worker(this.pa, { type: "module" });
+          worker = new Worker(this.oa, { type: "module" });
         } catch {
           this.broken = true;
           return null;
@@ -79,9 +79,9 @@ var WorkerPool = class {
       const entry = { worker, pending: 0 };
       worker.onmessage = (event) => {
         for (const { id, ok, indices, attributes, error } of event.data.results) {
-          const task = this._.get(id);
+          const task = this.da.get(id);
           if (!task) continue;
-          this._.delete(id);
+          this.da.delete(id);
           task.entry.pending--;
           if (ok) {
             task.resolve({ indices, attributes });
@@ -92,9 +92,9 @@ var WorkerPool = class {
       };
       worker.onerror = (event) => {
         this.broken = true;
-        for (const [id, task] of this._) {
+        for (const [id, task] of this.da) {
           if (task.entry.worker === worker) {
-            this._.delete(id);
+            this.da.delete(id);
             task.reject(new Error(`MinidracoLoader worker failed: ${event.message ?? "unknown error"}`));
           }
         }
@@ -106,12 +106,12 @@ var WorkerPool = class {
     for (const entry of this.D) if (entry.pending < best.pending) best = entry;
     return best;
   }
-  Hc() {
-    this.Za = false;
-    const batch = this.Ia;
+  Fc() {
+    this.Ya = false;
+    const batch = this.Ha;
     if (batch.length === 0) return;
-    this.Ia = [];
-    while (this.D.length < Math.min(this.limit, batch.length) && this.cc() !== null) {
+    this.Ha = [];
+    while (this.D.length < Math.min(this.limit, batch.length) && this.ac() !== null) {
     }
     if (this.broken || this.D.length === 0) {
       const error = new Error("MinidracoLoader: worker unavailable");
@@ -136,7 +136,7 @@ var WorkerPool = class {
     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 });
+      for (const task of tasks) this.da.set(task.id, { resolve: task.resolve, reject: task.reject, entry });
       entry.worker.postMessage({
         tasks: tasks.map((task) => ({
           id: task.id,

package/dist/three.d.ts

@@ -45,13 +45,15 @@ declare class PointAttribute extends GeometryAttribute {
     _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;
+    resetWithData(data: Uint8Array, numAttributeValues: number): void;
     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;
+    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;
@@ -66,8 +68,8 @@ declare class PointAttribute extends GeometryAttribute {
     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;
+    _extractQuantized(out: Float32Array, numPoints: number): void;
+    _extractOctahedron(out: Float32Array, numPoints: number): void;
     _extractInteger(out: ExtractTypedArray, numPoints: number): void;
 }