feat(worker): add detection worker stub and wire to plugin

Author: kalwalt

src/plugin.js

@@ -1,47 +1,35 @@
-/**
- * Minimal ARToolKit plugin skeleton.
- * Conforms to the Engine Plugin contract: init(core), enable(), disable(), dispose()
- * Emits events via core.eventBus: 'ar:markerFound', 'ar:markerUpdated', 'ar:markerLost'
- */
-export class ArtoolkitPlugin {
-    constructor(options = {}) {
-        this.options = options;
-        this.core = null;
-        this.enabled = false;
-        this._onUpdate = null;
-    }
+// Assuming existing imports and setup in src/plugin.js
 
-    async init(core) {
-        this.core = core;
-        // load resources if needed
-        return this;
-    }
+let detectionWorker;
 
-    async enable() {
-        if (!this.core) throw new Error('Plugin not initialized');
-        this.enabled = true;
-        this._onUpdate = (payload) => this._onFrameUpdate(payload);
-        this.core.eventBus.on('engine:update', this._onUpdate);
-        return this;
-    }
+function enableWorker() {
+  detectionWorker = new Worker(new URL('./worker/worker.js', import.meta.url));
 
-    async disable() {
-        this.enabled = false;
-        if (this._onUpdate) this.core.eventBus.off('engine:update', this._onUpdate);
-        return this;
-    }
+  detectionWorker.postMessage({ type: 'init' });
 
-    dispose() {
-        return this.disable();
+  // Capture engine:update event to post processFrame messages
+  core.eventBus.on('engine:update', (frame) => {
+    if (frame) {
+      detectionWorker.postMessage({ type: 'processFrame', payload: { frameId: frame.id } });
     }
+  });
 
-    _onFrameUpdate({ deltaTime, context }) {
-        // stub: read frame from context/resources and run detection
-        // when detection occurs, emit:
-        // this.core.eventBus.emit('ar:markerFound', { id, poseMatrix, confidence, corners });
+  detectionWorker.addEventListener('message', (ev) => {
+    const { type, payload } = ev.data || {};
+    if (type === 'ready') {
+      console.log('Worker is ready');
+    } else if (type === 'detectionResult') {
+      payload.detections.forEach(detection => {
+        core.eventBus.emit('ar:markerUpdated', {
+          id: detection.id,
+          poseMatrix: new Float32Array(detection.poseMatrix),
+          confidence: detection.confidence,
+          corners: detection.corners
+        });
+      });
     }
+  });
+}
 
-    getMarkerState(markerId) {
-        return null;
-    }
-}
+// Call enableWorker when you want to start the worker
+// Example: enableWorker();

src/worker/worker.js

@@ -0,0 +1,35 @@
+self.addEventListener('message', async (ev) => {
+  const { type, payload } = ev.data || {};
+  try {
+    if (type === 'init') {
+      // Worker init hook. Load WASM or other heavy libraries here in future.
+      // Respond ready to main thread.
+      self.postMessage({ type: 'ready' });
+    } else if (type === 'processFrame') {
+      // payload: { imageBitmapTransferable?, width, height }
+      // This stub simulates detection latency and returns a fake marker result.
+      // In real implementation, run artoolkit detection and return detections.
+      const { frameId } = payload || {};
+      // Simulate async detection
+      await new Promise((r) => setTimeout(r, 10));
+
+      // Fake detection result: one marker with id 'demo' and identity matrix
+      const fakeMatrix = new Float32Array([1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1]);
+      const result = {
+        detections: [
+          {
+            id: 'demo',
+            confidence: 0.9,
+            poseMatrix: Array.from(fakeMatrix), // structured-clonable
+            corners: [ {x:0,y:0}, {x:1,y:0}, {x:1,y:1}, {x:0,y:1} ],
+            frameId
+          }
+        ]
+      };
+
+      self.postMessage({ type: 'detectionResult', payload: result });
+    }
+  } catch (err) {
+    self.postMessage({ type: 'error', payload: { message: err.message } });
+  }
+});