@viji-dev/core 0.3.0 → 0.3.1

package/dist/assets/{viji.worker-b3XR7zKX.js → viji.worker-Be0jZvYj.js}

@@ -2132,6 +2132,8 @@ class ShaderWorkerAdapter {
   }
   static MAX_STREAMS = 8;
   // Maximum number of compositor input streams
+  static MAX_EXTERNAL_DEVICES = 8;
+  // Maximum number of external devices
   gl;
   program = null;
   uniformLocations = /* @__PURE__ */ new Map();
@@ -2431,6 +2433,58 @@ uniform vec2 u_rightAnklePosition; // Right ankle landmark position in pixels
 uniform sampler2D u_segmentationMask; // Body segmentation mask texture (0=background, 1=person)
 uniform vec2 u_segmentationRes; // Segmentation mask resolution in pixels
 
+// Device Sensors - Internal Device (viji.device)
+uniform vec3 u_deviceAcceleration; // Acceleration without gravity (m/s²) - x, y, z
+uniform vec3 u_deviceAccelerationGravity; // Acceleration with gravity (m/s²) - x, y, z
+uniform vec3 u_deviceRotationRate; // Rotation rate (deg/s) - alpha, beta, gamma
+uniform vec3 u_deviceOrientation; // Device orientation (degrees) - alpha, beta, gamma
+uniform bool u_deviceOrientationAbsolute; // True if orientation uses magnetometer (compass)
+uniform vec2 u_deviceLocation; // Geolocation (degrees) - latitude, longitude
+uniform vec4 u_deviceLocationExt; // Extended geolocation - altitude(m), accuracy(m), heading(deg), speed(m/s)
+
+// Device Sensors - External Devices (viji.devices[0-7])
+uniform int u_externalDeviceCount; // Number of connected external devices (0-8)
+uniform vec3 u_device0Acceleration; // Device 0 acceleration without gravity (m/s²)
+uniform vec3 u_device0AccelerationGravity; // Device 0 acceleration with gravity (m/s²)
+uniform vec3 u_device0RotationRate; // Device 0 rotation rate (deg/s)
+uniform vec3 u_device0Orientation; // Device 0 orientation (degrees) - alpha, beta, gamma
+uniform vec2 u_device0Location; // Device 0 location - latitude, longitude
+uniform vec3 u_device1Acceleration; // Device 1 acceleration without gravity (m/s²)
+uniform vec3 u_device1AccelerationGravity; // Device 1 acceleration with gravity (m/s²)
+uniform vec3 u_device1RotationRate; // Device 1 rotation rate (deg/s)
+uniform vec3 u_device1Orientation; // Device 1 orientation (degrees) - alpha, beta, gamma
+uniform vec2 u_device1Location; // Device 1 location - latitude, longitude
+uniform vec3 u_device2Acceleration; // Device 2 acceleration without gravity (m/s²)
+uniform vec3 u_device2AccelerationGravity; // Device 2 acceleration with gravity (m/s²)
+uniform vec3 u_device2RotationRate; // Device 2 rotation rate (deg/s)
+uniform vec3 u_device2Orientation; // Device 2 orientation (degrees) - alpha, beta, gamma
+uniform vec2 u_device2Location; // Device 2 location - latitude, longitude
+uniform vec3 u_device3Acceleration; // Device 3 acceleration without gravity (m/s²)
+uniform vec3 u_device3AccelerationGravity; // Device 3 acceleration with gravity (m/s²)
+uniform vec3 u_device3RotationRate; // Device 3 rotation rate (deg/s)
+uniform vec3 u_device3Orientation; // Device 3 orientation (degrees) - alpha, beta, gamma
+uniform vec2 u_device3Location; // Device 3 location - latitude, longitude
+uniform vec3 u_device4Acceleration; // Device 4 acceleration without gravity (m/s²)
+uniform vec3 u_device4AccelerationGravity; // Device 4 acceleration with gravity (m/s²)
+uniform vec3 u_device4RotationRate; // Device 4 rotation rate (deg/s)
+uniform vec3 u_device4Orientation; // Device 4 orientation (degrees) - alpha, beta, gamma
+uniform vec2 u_device4Location; // Device 4 location - latitude, longitude
+uniform vec3 u_device5Acceleration; // Device 5 acceleration without gravity (m/s²)
+uniform vec3 u_device5AccelerationGravity; // Device 5 acceleration with gravity (m/s²)
+uniform vec3 u_device5RotationRate; // Device 5 rotation rate (deg/s)
+uniform vec3 u_device5Orientation; // Device 5 orientation (degrees) - alpha, beta, gamma
+uniform vec2 u_device5Location; // Device 5 location - latitude, longitude
+uniform vec3 u_device6Acceleration; // Device 6 acceleration without gravity (m/s²)
+uniform vec3 u_device6AccelerationGravity; // Device 6 acceleration with gravity (m/s²)
+uniform vec3 u_device6RotationRate; // Device 6 rotation rate (deg/s)
+uniform vec3 u_device6Orientation; // Device 6 orientation (degrees) - alpha, beta, gamma
+uniform vec2 u_device6Location; // Device 6 location - latitude, longitude
+uniform vec3 u_device7Acceleration; // Device 7 acceleration without gravity (m/s²)
+uniform vec3 u_device7AccelerationGravity; // Device 7 acceleration with gravity (m/s²)
+uniform vec3 u_device7RotationRate; // Device 7 rotation rate (deg/s)
+uniform vec3 u_device7Orientation; // Device 7 orientation (degrees) - alpha, beta, gamma
+uniform vec2 u_device7Location; // Device 7 location - latitude, longitude
+
 // Backbuffer (previous frame feedback)
 ${this.backbufferEnabled ? "uniform sampler2D backbuffer; // Previous frame texture for feedback effects" : "// backbuffer not enabled"}
 `;
@@ -2741,6 +2795,134 @@ ${error}`);
     } else {
       this.setUniform("u_segmentationRes", "vec2", [0, 0]);
     }
+    const internalDevice = viji.device;
+    if (internalDevice) {
+      const motion = internalDevice.motion;
+      if (motion?.acceleration) {
+        this.setUniform("u_deviceAcceleration", "vec3", [
+          motion.acceleration.x ?? 0,
+          motion.acceleration.y ?? 0,
+          motion.acceleration.z ?? 0
+        ]);
+      } else {
+        this.setUniform("u_deviceAcceleration", "vec3", [0, 0, 0]);
+      }
+      if (motion?.accelerationIncludingGravity) {
+        this.setUniform("u_deviceAccelerationGravity", "vec3", [
+          motion.accelerationIncludingGravity.x ?? 0,
+          motion.accelerationIncludingGravity.y ?? 0,
+          motion.accelerationIncludingGravity.z ?? 0
+        ]);
+      } else {
+        this.setUniform("u_deviceAccelerationGravity", "vec3", [0, 0, 0]);
+      }
+      if (motion?.rotationRate) {
+        this.setUniform("u_deviceRotationRate", "vec3", [
+          motion.rotationRate.alpha ?? 0,
+          motion.rotationRate.beta ?? 0,
+          motion.rotationRate.gamma ?? 0
+        ]);
+      } else {
+        this.setUniform("u_deviceRotationRate", "vec3", [0, 0, 0]);
+      }
+      const orientation = internalDevice.orientation;
+      if (orientation) {
+        this.setUniform("u_deviceOrientation", "vec3", [
+          orientation.alpha ?? 0,
+          orientation.beta ?? 0,
+          orientation.gamma ?? 0
+        ]);
+        this.setUniform("u_deviceOrientationAbsolute", "bool", orientation.absolute);
+      } else {
+        this.setUniform("u_deviceOrientation", "vec3", [0, 0, 0]);
+        this.setUniform("u_deviceOrientationAbsolute", "bool", false);
+      }
+      const geolocation = internalDevice.geolocation;
+      if (geolocation) {
+        this.setUniform("u_deviceLocation", "vec2", [
+          geolocation.latitude ?? 0,
+          geolocation.longitude ?? 0
+        ]);
+        this.setUniform("u_deviceLocationExt", "vec4", [
+          geolocation.altitude ?? 0,
+          geolocation.accuracy ?? 0,
+          geolocation.heading ?? 0,
+          geolocation.speed ?? 0
+        ]);
+      } else {
+        this.setUniform("u_deviceLocation", "vec2", [0, 0]);
+        this.setUniform("u_deviceLocationExt", "vec4", [0, 0, 0, 0]);
+      }
+    } else {
+      this.setUniform("u_deviceAcceleration", "vec3", [0, 0, 0]);
+      this.setUniform("u_deviceAccelerationGravity", "vec3", [0, 0, 0]);
+      this.setUniform("u_deviceRotationRate", "vec3", [0, 0, 0]);
+      this.setUniform("u_deviceOrientation", "vec3", [0, 0, 0]);
+      this.setUniform("u_deviceOrientationAbsolute", "bool", false);
+      this.setUniform("u_deviceLocation", "vec2", [0, 0]);
+      this.setUniform("u_deviceLocationExt", "vec4", [0, 0, 0, 0]);
+    }
+    const externalDevices = viji.devices || [];
+    const externalDeviceCount = Math.min(externalDevices.length, ShaderWorkerAdapter.MAX_EXTERNAL_DEVICES);
+    this.setUniform("u_externalDeviceCount", "int", externalDeviceCount);
+    for (let i = 0; i < ShaderWorkerAdapter.MAX_EXTERNAL_DEVICES; i++) {
+      if (i < externalDeviceCount) {
+        const device = externalDevices[i];
+        const motion = device.motion;
+        if (motion?.acceleration) {
+          this.setUniform(`u_device${i}Acceleration`, "vec3", [
+            motion.acceleration.x ?? 0,
+            motion.acceleration.y ?? 0,
+            motion.acceleration.z ?? 0
+          ]);
+        } else {
+          this.setUniform(`u_device${i}Acceleration`, "vec3", [0, 0, 0]);
+        }
+        if (motion?.accelerationIncludingGravity) {
+          this.setUniform(`u_device${i}AccelerationGravity`, "vec3", [
+            motion.accelerationIncludingGravity.x ?? 0,
+            motion.accelerationIncludingGravity.y ?? 0,
+            motion.accelerationIncludingGravity.z ?? 0
+          ]);
+        } else {
+          this.setUniform(`u_device${i}AccelerationGravity`, "vec3", [0, 0, 0]);
+        }
+        if (motion?.rotationRate) {
+          this.setUniform(`u_device${i}RotationRate`, "vec3", [
+            motion.rotationRate.alpha ?? 0,
+            motion.rotationRate.beta ?? 0,
+            motion.rotationRate.gamma ?? 0
+          ]);
+        } else {
+          this.setUniform(`u_device${i}RotationRate`, "vec3", [0, 0, 0]);
+        }
+        const orientation = device.orientation;
+        if (orientation) {
+          this.setUniform(`u_device${i}Orientation`, "vec3", [
+            orientation.alpha ?? 0,
+            orientation.beta ?? 0,
+            orientation.gamma ?? 0
+          ]);
+        } else {
+          this.setUniform(`u_device${i}Orientation`, "vec3", [0, 0, 0]);
+        }
+        const geolocation = device.geolocation;
+        if (geolocation) {
+          this.setUniform(`u_device${i}Location`, "vec2", [
+            geolocation.latitude ?? 0,
+            geolocation.longitude ?? 0
+          ]);
+        } else {
+          this.setUniform(`u_device${i}Location`, "vec2", [0, 0]);
+        }
+      } else {
+        this.setUniform(`u_device${i}Acceleration`, "vec3", [0, 0, 0]);
+        this.setUniform(`u_device${i}AccelerationGravity`, "vec3", [0, 0, 0]);
+        this.setUniform(`u_device${i}RotationRate`, "vec3", [0, 0, 0]);
+        this.setUniform(`u_device${i}Orientation`, "vec3", [0, 0, 0]);
+        this.setUniform(`u_device${i}Location`, "vec2", [0, 0]);
+      }
+    }
   }
   /**
    * Update parameter uniforms from parameter objects
@@ -3822,18 +4004,12 @@ class VijiWorkerRuntime {
       if (!tctx) throw new Error("Failed to get 2D context");
       tctx.drawImage(sourceCanvas, sx, sy, sWidth, sHeight, 0, 0, targetWidth, targetHeight);
       const blob = await temp.convertToBlob({ type: mimeType });
-      const arrayBuffer = await blob.arrayBuffer();
       self.postMessage({
         type: "capture-frame-result",
         id: message.id,
         timestamp: Date.now(),
-        data: {
-          mimeType,
-          buffer: arrayBuffer,
-          width: targetWidth,
-          height: targetHeight
-        }
-      }, [arrayBuffer]);
+        data: { blob }
+      });
     } catch (error) {
       this.postMessage("error", {
         id: message.id,
@@ -4018,4 +4194,4 @@ async function setSceneCode(sceneCode) {
   }
 }
 self.setSceneCode = setSceneCode;
-//# sourceMappingURL=viji.worker-b3XR7zKX.js.map
+//# sourceMappingURL=viji.worker-Be0jZvYj.js.map