strudel-docker/packages/motion/motion.mjs

// motion.mjs

import { signal } from '../core/signal.mjs';

/**
 *  The accelerometer's x-axis value ranges from 0 to 1.
 * @name accelerationX
 * @return {Pattern}
 * @synonyms accX
 * @example
 * n(accelerationX.segment(4).range(0,7)).scale("C:minor")
 *
 */

/**
 *  The accelerometer's y-axis value ranges from 0 to 1.
 * @name accelerationY
 * @return {Pattern}
 * @synonyms accY
 * @example
 * n(accelerationY.segment(4).range(0,7)).scale("C:minor")
 *
 */

/**
 *  The accelerometer's z-axis value ranges from 0 to 1.
 * @name accelerationZ
 * @return {Pattern}
 * @synonyms accZ
 * @example
 * n(accelerationZ.segment(4).range(0,7)).scale("C:minor")
 *
 */

/**
 *  The device's gravity x-axis value ranges from 0 to 1.
 * @name gravityX
 * @return {Pattern}
 * @synonyms gravX
 * @example
 * n(gravityX.segment(4).range(0,7)).scale("C:minor")
 *
 */

/**
 *  The device's gravity y-axis value ranges from 0 to 1.
 * @name gravityY
 * @return {Pattern}
 * @synonyms gravY
 * @example
 * n(gravityY.segment(4).range(0,7)).scale("C:minor")
 *
 */

/**
 *  The device's gravity z-axis value ranges from 0 to 1.
 * @name gravityZ
 * @return {Pattern}
 * @synonyms gravZ
 * @example
 * n(gravityZ.segment(4).range(0,7)).scale("C:minor")
 *
 */

/**
 *  The device's rotation around the alpha-axis value ranges from 0 to 1.
 * @name rotationAlpha
 * @return {Pattern}
 * @synonyms rotA, rotZ, rotationZ
 * @example
 * n(rotationAlpha.segment(4).range(0,7)).scale("C:minor")
 *
 */

/**
 *  The device's rotation around the beta-axis value ranges from 0 to 1.
 * @name rotationBeta
 * @return {Pattern}
 * @synonyms rotB, rotX, rotationX
 * @example
 * n(rotationBeta.segment(4).range(0,7)).scale("C:minor")
 *
 */

/**
 *  The device's rotation around the gamma-axis value ranges from 0 to 1.
 * @name rotationGamma
 * @return {Pattern}
 * @synonyms rotG, rotY, rotationY
 * @example
 * n(rotationGamma.segment(4).range(0,7)).scale("C:minor")
 *
 */

/**
 *  The device's orientation alpha value ranges from 0 to 1.
 * @name orientationAlpha
 * @return {Pattern}
 * @synonyms oriA, oriZ, orientationZ
 * @example
 * n(orientationAlpha.segment(4).range(0,7)).scale("C:minor")
 *
 */

/**
 *  The device's orientation beta value ranges from 0 to 1.
 * @name orientationBeta
 * @return {Pattern}
 * @synonyms oriB, oriX, orientationX
 * @example
 * n(orientationBeta.segment(4).range(0,7)).scale("C:minor")
 *
 */

/**
 *  The device's orientation gamma value ranges from 0 to 1.
 * @name orientationGamma
 * @return {Pattern}
 * @synonyms oriG, oriY, orientationY
 * @example
 * n(orientationGamma.segment(4).range(0,7)).scale("C:minor")
 *
 */

/**
 *  The device's absolute orientation alpha value ranges from 0 to 1.
 * @name absoluteOrientationAlpha
 * @return {Pattern}
 * @synonyms absOriA, absOriZ, absoluteOrientationZ
 * @example
 * n(absoluteOrientationAlpha.segment(4).range(0,7)).scale("C:minor")
 *
 */

/**
 *  The device's absolute orientation beta value ranges from 0 to 1.
 * @name absoluteOrientationBeta
 * @return {Pattern}
 * @synonyms absOriB, absOriX, absoluteOrientationX
 * @example
 * n(absoluteOrientationBeta.segment(4).range(0,7)).scale("C:minor")
 *
 */

/**
 *  The device's absolute orientation gamma value ranges from 0 to 1.
 * @name absoluteOrientationGamma
 * @return {Pattern}
 * @synonyms absOriG, absOriY, absoluteOrientationY
 * @example
 * n(absoluteOrientationGamma.segment(4).range(0,7)).scale("C:minor")
 *
 */

class DeviceMotionHandler {
  constructor() {
    this.GRAVITY = 9.81;

    // Initialize sensor values
    this._acceleration = {
      x: 0,
      y: 0,
      z: 0,
    };

    this._gravity = {
      x: 0,
      y: 0,
      z: 0,
    };

    this._rotation = {
      alpha: 0,
      beta: 0,
      gamma: 0,
    };

    this._orientation = {
      alpha: 0,
      beta: 0,
      gamma: 0,
    };

    this._absoluteOrientation = {
      alpha: 0,
      beta: 0,
      gamma: 0,
    };

    this._permissionStatus = 'unknown';
  }

  async requestPermissions() {
    if (typeof DeviceMotionEvent?.requestPermission === 'function') {
      try {
        // iOS requires explicit permission
        const motionPermission = await DeviceMotionEvent.requestPermission();
        const orientationPermission = await DeviceOrientationEvent.requestPermission();

        this._permissionStatus =
          motionPermission === 'granted' && orientationPermission === 'granted' ? 'granted' : 'denied';
        this.setupEventListeners();
      } catch (error) {
        console.error('Permission request failed:', error);
        this._permissionStatus = 'denied';
      }
    } else {
      this._permissionStatus = 'granted';
      this.setupEventListeners();
    }
  }

  setupEventListeners() {
    if (this._permissionStatus === 'granted') {
      // Device Motion handler
      window.addEventListener('devicemotion', this.handleDeviceMotion.bind(this), true);
      window.addEventListener('deviceorientation', this.handleDeviceOrientation.bind(this), true);
      window.addEventListener('deviceorientationabsolute', this.handleAbsoluteDeviceOrientation.bind(this), true);
    }
  }

  handleDeviceMotion(event) {
    //console.log(event);
    if (event.acceleration) {
      // Normalize acceleration values to 0-1 range
      this._acceleration.x = (event.acceleration.x + 1) / 2;
      this._acceleration.y = (event.acceleration.y + 1) / 2;
      this._acceleration.z = (event.acceleration.z + 1) / 2;
    }

    if (event.accelerationIncludingGravity) {
      // Normalize acceleration values to 0-1 range
      this._gravity.x = (event.accelerationIncludingGravity.x + this.GRAVITY) / (2 * this.GRAVITY);
      this._gravity.y = (event.accelerationIncludingGravity.y + this.GRAVITY) / (2 * this.GRAVITY);
      this._gravity.z = (event.accelerationIncludingGravity.z + this.GRAVITY) / (2 * this.GRAVITY);
    }

    if (event.rotationRate) {
      // Normalize rotation values to 0-1 range
      this._rotation.alpha = (event.rotationRate.alpha + 180) / 360;
      this._rotation.beta = (event.rotationRate.beta + 180) / 360;
      this._rotation.gamma = (event.rotationRate.gamma + 180) / 360;
    }
  }

  handleDeviceOrientation(event) {
    this._orientation.alpha = event.alpha / 360; //a(0~360)
    this._orientation.beta = (event.beta + 180) / 360; //b(-180~180)
    this._orientation.gamma = (event.gamma + 90) / 180; //g(-90~90)
  }

  handleAbsoluteDeviceOrientation(event) {
    this._absoluteOrientation.alpha = event.alpha / 360; //a(0~360)
    this._absoluteOrientation.beta = (event.beta + 180) / 360; //b(-180~180)
    this._absoluteOrientation.gamma = (event.gamma + 90) / 180; //g(-90~90)
  }

  // Getter methods for current values
  getAcceleration() {
    return this._acceleration;
  }
  getGravity() {
    return this._gravity;
  }
  getRotation() {
    return this._rotation;
  }
  getOrientation() {
    return this._orientation;
  }
  getAbsoluteOrientation() {
    return this._absoluteOrientation;
  }
}

// Create singleton instance
const deviceMotion = new DeviceMotionHandler();

// Export a function to request permission
export async function enableMotion() {
  return deviceMotion.requestPermissions();
}

// Create signals for acceleration
export const accelerationX = signal(() => deviceMotion.getAcceleration().x);
export const accelerationY = signal(() => deviceMotion.getAcceleration().y);
export const accelerationZ = signal(() => deviceMotion.getAcceleration().z);

// Aliases for shorter names
export const accX = accelerationX;
export const accY = accelerationY;
export const accZ = accelerationZ;

// Create signals for gravity
export const gravityX = signal(() => deviceMotion.getGravity().x);
export const gravityY = signal(() => deviceMotion.getGravity().y);
export const gravityZ = signal(() => deviceMotion.getGravity().z);

// Aliases for shorter names
export const gravX = gravityX;
export const gravY = gravityY;
export const gravZ = gravityZ;

// Create signals for orientation
export const orientationAlpha = signal(() => deviceMotion.getOrientation().alpha);
export const orientationBeta = signal(() => deviceMotion.getOrientation().beta);
export const orientationGamma = signal(() => deviceMotion.getOrientation().gamma);
// Aliases for shorter names
export const orientationA = orientationAlpha;
export const orientationB = orientationBeta;
export const orientationG = orientationGamma;

// Aliases mapping to X,Y,Z coordinates
export const orientationX = orientationBeta;
export const orientationY = orientationGamma;
export const orientationZ = orientationAlpha;

// Short aliases for A,B,G,X,Y,Z

export const oriA = orientationAlpha;
export const oriB = orientationBeta;
export const oriG = orientationGamma;

export const oriX = orientationX;
export const oriY = orientationY;
export const oriZ = orientationZ;

// Create signals for absolute orientation
export const absoluteOrientationAlpha = signal(() => deviceMotion.getAbsoluteOrientation().alpha);
export const absoluteOrientationBeta = signal(() => deviceMotion.getAbsoluteOrientation().beta);
export const absoluteOrientationGamma = signal(() => deviceMotion.getAbsoluteOrientation().gamma);

// Aliases for shorter names
export const absOriA = absoluteOrientationAlpha;
export const absOriB = absoluteOrientationBeta;
export const absOriG = absoluteOrientationGamma;

// Aliases mapping to X,Y,Z coordinates
export const absoluteOrientationX = absoluteOrientationBeta;
export const absoluteOrientationY = absoluteOrientationGamma;
export const absoluteOrientationZ = absoluteOrientationAlpha;

// Short aliases for X,Y,Z
export const absOriX = absoluteOrientationX;
export const absOriY = absoluteOrientationY;
export const absOriZ = absoluteOrientationZ;

// Create signals for rotation
export const rotationAlpha = signal(() => deviceMotion.getRotation().alpha);
export const rotationBeta = signal(() => deviceMotion.getRotation().beta);
export const rotationGamma = signal(() => deviceMotion.getRotation().gamma);
export const rotationX = rotationBeta;
export const rotationY = rotationGamma;
export const rotationZ = rotationAlpha;

// Aliases for shorter names
export const rotA = rotationAlpha;
export const rotB = rotationBeta;
export const rotG = rotationGamma;
export const rotX = rotationX;
export const rotY = rotationY;
export const rotZ = rotationZ;

// // Bipolar versions (ranging from -1 to 1 instead of 0 to 1)
// export const accX2 = accX.toBipolar();
// export const accY2 = accY.toBipolar();
// export const accZ2 = accZ.toBipolar();

// export const rotA2 = rotA.toBipolar();
// export const rotB2 = rotB.toBipolar();
// export const rotG2 = rotG.toBipolar();