@srsergio/taptapp-ar 1.0.88 → 1.0.90

package/src/core/protocol.ts

@@ -1,6 +1,7 @@
 import * as msgpack from "@msgpack/msgpack";
 
-export const CURRENT_VERSION = 8;
+export const CURRENT_VERSION = 9; // Bumped for HDC support
+export const HDC_SEED = 0x1337BEEF; // Default system seed
 
 /**
  * Morton Order calculation for spatial sorting
@@ -59,13 +60,19 @@ export function unpack4Bit(packed: Uint8Array, width: number, height: number): U
 /**
  * Columnarizes point data for efficient storage and transfer
  */
-export function columnarize(points: any[], tree: any, width: number, height: number) {
+export function columnarize(points: any[], tree: any, width: number, height: number, useHDC: boolean = false) {
     const count = points.length;
     const x = new Uint16Array(count);
     const y = new Uint16Array(count);
     const angle = new Int16Array(count);
     const scale = new Uint8Array(count);
-    const descriptors = new Uint32Array(count * 2);
+
+    let descriptors: any;
+    if (useHDC) {
+        descriptors = new Uint32Array(count); // HDC Signatures (32-bit)
+    } else {
+        descriptors = new Uint32Array(count * 2); // Raw Descriptors (64-bit)
+    }
 
     for (let i = 0; i < count; i++) {
         x[i] = Math.round((points[i].x / width) * 65535);
@@ -74,8 +81,15 @@ export function columnarize(points: any[], tree: any, width: number, height: num
         scale[i] = Math.round(Math.log2(points[i].scale || 1));
 
         if (points[i].descriptors && points[i].descriptors.length >= 2) {
-            descriptors[i * 2] = points[i].descriptors[0];
-            descriptors[(i * 2) + 1] = points[i].descriptors[1];
+            if (useHDC) {
+                // For HDC, we'd normally call project + compress here
+                // But protocol.ts should be agnostic of the generator.
+                // We'll assume points[i].hdcSignature exists if pre-calculated
+                descriptors[i] = points[i].hdcSignature || 0;
+            } else {
+                descriptors[i * 2] = points[i].descriptors[0];
+                descriptors[(i * 2) + 1] = points[i].descriptors[1];
+            }
         }
     }
 
@@ -85,6 +99,7 @@ export function columnarize(points: any[], tree: any, width: number, height: num
         a: angle,
         s: scale,
         d: descriptors,
+        hdc: useHDC ? 1 : 0, // HDC Flag (renamed from h to avoid collision with height)
         t: compactTree(tree.rootNode),
     };
 }
@@ -209,7 +224,12 @@ export function decodeTaar(buffer: ArrayBuffer | Uint8Array) {
                 }
 
                 if (col.d instanceof Uint8Array) {
-                    col.d = new Uint32Array(col.d.buffer.slice(col.d.byteOffset, col.d.byteOffset + col.d.byteLength));
+                    // Check if it's HDC (Uint32) or Raw (Uint32 x 2)
+                    if (col.hdc === 1) {
+                        col.d = new Uint32Array(col.d.buffer.slice(col.d.byteOffset, col.d.byteOffset + col.d.byteLength));
+                    } else {
+                        col.d = new Uint32Array(col.d.buffer.slice(col.d.byteOffset, col.d.byteOffset + col.d.byteLength));
+                    }
                 }
             }
         }

package/src/runtime/controller.ts

@@ -102,7 +102,10 @@ class Controller {
         if (this.worker) this._setupWorkerListener();
 
         // Moonshot: Full frame detector for better sensitivity
-        this.fullDetector = new DetectorLite(this.inputWidth, this.inputHeight, { useLSH: true });
+        this.fullDetector = new DetectorLite(this.inputWidth, this.inputHeight, {
+            useLSH: true,
+            maxFeaturesPerBucket: 24 // Increased from 12 for better small target density
+        });
 
         this.featureManager.init({
             inputWidth: this.inputWidth,
@@ -111,9 +114,9 @@ class Controller {
             debugMode: this.debugMode
         });
 
-        const near = 10;
-        const far = 100000;
-        const fovy = (45.0 * Math.PI) / 180;
+        const near = 1.0;
+        const far = 10000;
+        const fovy = (60.0 * Math.PI) / 180;
         const f = this.inputHeight / 2 / Math.tan(fovy / 2);
 
         this.projectionTransform = [
@@ -323,10 +326,12 @@ class Controller {
             }
         }
 
-        // STRICT QUALITY CHECK: We only update the transform if we have enough HIGH CONFIDENCE points
-        const stableAndReliable = reliabilities.filter((r: number, idx: number) => r > 0.8 && stabilities[indices[idx]] > 0.6).length;
+        // 🚀 WARMUP FIX: If we just started tracking (less than 15 frames), we are much more relaxed
+        const isWarmup = state.trackCount < 15;
+        const numTracked = finalWorldCoords.length;
+        const minPoints = isWarmup ? 4 : 5; // Start with 4, then require 5
 
-        if (stableAndReliable < 6 || finalWorldCoords.length < 8) {
+        if (numTracked < minPoints) {
             return {
                 modelViewTransform: null,
                 screenCoords: finalScreenCoords,
@@ -335,6 +340,8 @@ class Controller {
             };
         }
 
+        state.trackCount++;
+
         const modelViewTransform = await this._workerTrackUpdate(lastModelViewTransform, {
             worldCoords: finalWorldCoords,
             screenCoords: finalWorldCoords.map((_, i) => {
@@ -670,15 +677,14 @@ class Controller {
     }
 
     _glModelViewMatrix(modelViewTransform: number[][], targetIndex: number) {
-        const height = this.markerDimensions![targetIndex][1];
+        // Transformation to map Computer Vision coordinates (Y-down, Z-forward) 
+        // to OpenGL coordinates (Y-up, Z-backward). 
+        // We negate the 2nd and 3rd rows of the pose matrix.
         return [
             modelViewTransform[0][0], -modelViewTransform[1][0], -modelViewTransform[2][0], 0,
-            -modelViewTransform[0][1], modelViewTransform[1][1], modelViewTransform[2][1], 0,
-            -modelViewTransform[0][2], modelViewTransform[1][2], modelViewTransform[2][2], 0,
-            modelViewTransform[0][1] * height + modelViewTransform[0][3],
-            -(modelViewTransform[1][1] * height + modelViewTransform[1][3]),
-            -(modelViewTransform[2][1] * height + modelViewTransform[2][3]),
-            1,
+            modelViewTransform[0][1], -modelViewTransform[1][1], -modelViewTransform[2][1], 0,
+            modelViewTransform[0][2], -modelViewTransform[1][2], -modelViewTransform[2][2], 0,
+            modelViewTransform[0][3], -modelViewTransform[1][3], -modelViewTransform[2][3], 1,
         ];
     }
 

package/src/runtime/controller.worker.js

@@ -31,7 +31,10 @@ onmessage = (msg) => {
         );
       }
 
-      detector = new DetectorLite(data.inputWidth, data.inputHeight, { useLSH: true });
+      detector = new DetectorLite(data.inputWidth, data.inputHeight, {
+        useLSH: true,
+        maxFeaturesPerBucket: 24
+      });
       break;
 
     case "match":