@kiberon-labs/behave-graph-scene 1.0.0

package/src/Values/Internal/Vec2.ts

@@ -0,0 +1,97 @@
+import {
+  EPSILON,
+  equalsTolerance,
+  parseSafeFloats,
+  toSafeString
+} from '@kiberon-labs/behave-graph';
+
+export type Vec2JSON = number[];
+
+export class Vec2 {
+  public x: number;
+  public y: number;
+  constructor(x: number = 0, y: number = 0) {
+    this.x = x;
+    this.y = y;
+  }
+
+  clone(result = new Vec2()): Vec2 {
+    return result.set(this.x, this.y);
+  }
+  set(x: number, y: number): this {
+    this.x = x;
+    this.y = y;
+    return this;
+  }
+}
+
+export function vec2Equals(
+  a: Vec2,
+  b: Vec2,
+  tolerance: number = EPSILON
+): boolean {
+  return (
+    equalsTolerance(a.x, b.x, tolerance) && equalsTolerance(a.y, b.y, tolerance)
+  );
+}
+export function vec2Add(a: Vec2, b: Vec2, result: Vec2 = new Vec2()): Vec2 {
+  return result.set(a.x + b.x, a.y + b.y);
+}
+export function vec2Subtract(
+  a: Vec2,
+  b: Vec2,
+  result: Vec2 = new Vec2()
+): Vec2 {
+  return result.set(a.x - b.x, a.y - b.y);
+}
+export function vec2MultiplyByScalar(
+  a: Vec2,
+  b: number,
+  result: Vec2 = new Vec2()
+): Vec2 {
+  return result.set(a.x * b, a.y * b);
+}
+export function vec2Negate(a: Vec2, result: Vec2 = new Vec2()): Vec2 {
+  return result.set(-a.x, -a.y);
+}
+export function vec2Length(a: Vec2): number {
+  return Math.sqrt(vec2Dot(a, a));
+}
+export function vec2Normalize(a: Vec2, result: Vec2 = new Vec2()): Vec2 {
+  const invLength = 1 / vec2Length(a);
+  return vec2MultiplyByScalar(a, invLength, result);
+}
+export function vec2Dot(a: Vec2, b: Vec2): number {
+  return a.x * b.x + a.y * b.y;
+}
+export function vec2Mix(
+  a: Vec2,
+  b: Vec2,
+  t: number,
+  result = new Vec2()
+): Vec2 {
+  const s = 1 - t;
+  return result.set(a.x * s + b.x * t, a.y * s + b.y * t);
+}
+export function vec2FromArray(
+  array: Float32Array | number[],
+  offset = 0,
+  result: Vec2 = new Vec2()
+): Vec2 {
+  return result.set(array[offset + 0]!, array[offset + 1]!);
+}
+export function vec2ToArray(
+  a: Vec2,
+  array: Float32Array | number[],
+  offset = 0
+): void {
+  array[offset + 0] = a.x;
+  array[offset + 1] = a.y;
+}
+
+export function vec2ToString(a: Vec2): string {
+  return toSafeString([a.x, a.y]);
+}
+export function vec2Parse(text: string, result = new Vec2()): Vec2 {
+  return vec2FromArray(parseSafeFloats(text), 0, result);
+}

package/src/Values/Internal/Vec3.ts

@@ -0,0 +1,244 @@
+import {
+  clamp,
+  EPSILON,
+  equalsTolerance,
+  parseSafeFloats,
+  toSafeString
+} from '@kiberon-labs/behave-graph';
+
+import { Mat3, mat4ToMat3, quatToMat3 } from './Mat3.js';
+import { Mat4 } from './Mat4.js';
+import { Vec4 } from './Vec4.js';
+
+export type Vec3JSON = number[];
+
+export class Vec3 {
+  public x: number;
+  public y: number;
+  public z: number;
+  constructor(x: number = 0, y: number = 0, z: number = 0) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+
+  clone(result = new Vec3()): Vec3 {
+    return result.set(this.x, this.y, this.z);
+  }
+
+  set(x: number, y: number, z: number): this {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    return this;
+  }
+}
+
+export function vec3Equals(
+  a: Vec3,
+  b: Vec3,
+  tolerance: number = EPSILON
+): boolean {
+  return (
+    equalsTolerance(a.x, b.x, tolerance) &&
+    equalsTolerance(a.y, b.y, tolerance) &&
+    equalsTolerance(a.z, b.z, tolerance)
+  );
+}
+export function vec3Add(a: Vec3, b: Vec3, result = new Vec3()): Vec3 {
+  return result.set(a.x + b.x, a.y + b.y, a.z + b.z);
+}
+export function vec3Subtract(a: Vec3, b: Vec3, result = new Vec3()): Vec3 {
+  return result.set(a.x - b.x, a.y - b.y, a.z - b.z);
+}
+export function vec3MultiplyByScalar(
+  a: Vec3,
+  b: number,
+  result = new Vec3()
+): Vec3 {
+  return result.set(a.x * b, a.y * b, a.z * b);
+}
+export function vec3Negate(a: Vec3, result = new Vec3()): Vec3 {
+  return result.set(-a.x, -a.y, -a.z);
+}
+export function vec3Length(a: Vec3): number {
+  return Math.sqrt(vec3Dot(a, a));
+}
+export function vec3Normalize(a: Vec3, result = new Vec3()): Vec3 {
+  const invLength = 1 / vec3Length(a);
+  return vec3MultiplyByScalar(a, invLength, result);
+}
+export function vec3Dot(a: Vec3, b: Vec3): number {
+  return a.x * b.x + a.y * b.y + a.z * b.z;
+}
+export function vec3Cross(a: Vec3, b: Vec3, result = new Vec3()): Vec3 {
+  const ax = a.x;
+  const ay = a.y;
+  const az = a.z;
+  const bx = b.x;
+  const by = b.y;
+  const bz = b.z;
+
+  return result.set(ay * bz - az * by, az * bx - ax * bz, ax * by - ay * bx);
+}
+export function vec3Mix(
+  a: Vec3,
+  b: Vec3,
+  t: number,
+  result = new Vec3()
+): Vec3 {
+  const s = 1 - t;
+  return result.set(a.x * s + b.x * t, a.y * s + b.y * t, a.z * s + b.z * t);
+}
+export function vec3FromArray(
+  array: Float32Array | number[],
+  offset = 0,
+  result = new Vec3()
+): Vec3 {
+  return result.set(array[offset + 0]!, array[offset + 1]!, array[offset + 2]!);
+}
+export function vec3ToArray(
+  a: Vec3,
+  array: Float32Array | number[],
+  offset = 0
+): void {
+  array[offset + 0] = a.x;
+  array[offset + 1] = a.y;
+  array[offset + 2] = a.z;
+}
+export function vec3ToString(a: Vec3): string {
+  return toSafeString([a.x, a.y, a.z]);
+}
+export function vec3Parse(text: string, result = new Vec3()): Vec3 {
+  return vec3FromArray(parseSafeFloats(text), 0, result);
+}
+
+export function hslToRGB(hsl: Vec3, result = new Vec3()): Vec3 {
+  function hue2rgb(p: number, q: number, t: number): number {
+    if (t < 0) {
+      t += 1;
+    }
+    if (t > 1) {
+      t -= 1;
+    }
+    if (t < 1 / 6) {
+      return p + (q - p) * 6 * t;
+    }
+    if (t < 1 / 2) {
+      return q;
+    }
+    if (t < 2 / 3) {
+      return p + (q - p) * 6 * (2 / 3 - t);
+    }
+
+    return p;
+  }
+
+  // h,s,l ranges are in 0.0 - 1.0
+  const h = ((hsl.x % 1) + 1) % 1; // euclidean modulo
+  const s = Math.min(Math.max(hsl.y, 0), 1);
+  const l = Math.min(Math.max(hsl.z, 0), 1);
+
+  if (s === 0) {
+    return result.set(1, 1, 1);
+  }
+
+  const p = l <= 0.5 ? l * (1 + s) : l + s - l * s;
+  const q = 2 * l - p;
+
+  return result.set(
+    hue2rgb(q, p, h + 1 / 3),
+    hue2rgb(q, p, h),
+    hue2rgb(q, p, h - 1 / 3)
+  );
+}
+
+export function rgbToHSL(rgb: Vec3, result = new Vec3()): Vec3 {
+  // h,s,l ranges are in 0.0 - 1.0
+  const r = rgb.x,
+    g = rgb.y,
+    b = rgb.z;
+
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+
+  let hue = 0;
+  let saturation = 0;
+  const lightness = (min + max) / 2;
+
+  if (min === max) {
+    hue = 0;
+    saturation = 0;
+  } else {
+    const delta = max - min;
+
+    saturation =
+      lightness <= 0.5 ? delta / (max + min) : delta / (2 - max - min);
+
+    switch (max) {
+      case r:
+        hue = (g - b) / delta + (g < b ? 6 : 0);
+        break;
+      case g:
+        hue = (b - r) / delta + 2;
+        break;
+      case b:
+        hue = (r - g) / delta + 4;
+        break;
+    }
+
+    hue /= 6;
+  }
+
+  return result.set(hue, saturation, lightness);
+}
+
+export function hexToRGB(hex: number, result = new Vec3()): Vec3 {
+  hex = Math.floor(hex);
+  return result.set(
+    ((hex >> 16) & 255) / 255,
+    ((hex >> 8) & 255) / 255,
+    (hex & 255) / 255
+  );
+}
+
+export function rgbToHex(rgb: Vec3): number {
+  return ((rgb.x * 255) << 16) ^ ((rgb.y * 255) << 8) ^ ((rgb.z * 255) << 0);
+}
+
+// from three.js
+export function mat3ToEuler(m: Mat3, result = new Vec3()): Vec3 {
+  // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
+
+  const te = m.elements;
+  const m11 = te[0],
+    m12 = te[3],
+    m13 = te[6];
+  const m21 = te[1],
+    m22 = te[4],
+    m23 = te[7];
+  const m31 = te[2],
+    m32 = te[5],
+    m33 = te[8];
+
+  result.y = Math.asin(clamp(m13, -1, 1));
+
+  if (Math.abs(m13) < 0.9999999) {
+    result.x = Math.atan2(-m23, m33);
+    result.z = Math.atan2(-m12, m11);
+  } else {
+    result.x = Math.atan2(m32, m22);
+    result.z = 0;
+  }
+
+  return result;
+}
+
+// from three.js
+export function mat4ToEuler(m: Mat4, result = new Vec3()): Vec3 {
+  return mat3ToEuler(mat4ToMat3(m), result);
+}
+
+export function quatToEuler(q: Vec4, result = new Vec3()): Vec3 {
+  return mat3ToEuler(quatToMat3(q), result);
+}

package/src/Values/Internal/Vec4.ts

@@ -0,0 +1,350 @@
+import {
+  EPSILON,
+  equalsTolerance,
+  parseSafeFloats,
+  toSafeString
+} from '@kiberon-labs/behave-graph';
+
+import { Mat3, mat4ToMat3 } from './Mat3.js';
+import { Mat4 } from './Mat4.js';
+import { Vec3 } from './Vec3.js';
+
+export type Vec4JSON = number[];
+
+export class Vec4 {
+  public x: number;
+  public y: number;
+  public z: number;
+  public w: number;
+  constructor(x: number = 0, y: number = 0, z: number = 0, w: number = 0) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.w = w;
+  }
+  clone(result = new Vec4()): Vec4 {
+    return result.set(this.x, this.y, this.z, this.w);
+  }
+  set(x: number, y: number, z: number, w: number): this {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.w = w;
+    return this;
+  }
+}
+export function vec4Equals(
+  a: Vec4,
+  b: Vec4,
+  tolerance: number = EPSILON
+): boolean {
+  return (
+    equalsTolerance(a.x, b.x, tolerance) &&
+    equalsTolerance(a.y, b.y, tolerance) &&
+    equalsTolerance(a.z, b.z, tolerance) &&
+    equalsTolerance(a.w, b.w, tolerance)
+  );
+}
+export function vec4Add(a: Vec4, b: Vec4, result = new Vec4()): Vec4 {
+  return result.set(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w);
+}
+export function vec4Subtract(a: Vec4, b: Vec4, result = new Vec4()): Vec4 {
+  return result.set(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w);
+}
+export function vec4MultiplyByScalar(
+  a: Vec4,
+  b: number,
+  result = new Vec4()
+): Vec4 {
+  return result.set(a.x * b, a.y * b, a.z * b, a.w * b);
+}
+export function vec4Negate(a: Vec4, result = new Vec4()): Vec4 {
+  return result.set(-a.x, -a.y, -a.z, -a.w);
+}
+export function vec4Length(a: Vec4): number {
+  return Math.sqrt(vec4Dot(a, a));
+}
+export function vec4Normalize(a: Vec4, result = new Vec4()): Vec4 {
+  const invLength = 1 / vec4Length(a);
+  return vec4MultiplyByScalar(a, invLength, result);
+}
+export function vec4Dot(a: Vec4, b: Vec4): number {
+  return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
+}
+export function vec4Mix(
+  a: Vec4,
+  b: Vec4,
+  t: number,
+  result = new Vec4()
+): Vec4 {
+  const s = 1 - t;
+  return result.set(
+    a.x * s + b.x * t,
+    a.y * s + b.y * t,
+    a.z * s + b.z * t,
+    a.w * s + b.w * t
+  );
+}
+export function vec4FromArray(
+  array: Float32Array | number[],
+  offset = 0,
+  result = new Vec4()
+): Vec4 {
+  return result.set(
+    array[offset + 0]!,
+    array[offset + 1]!,
+    array[offset + 2]!,
+    array[offset + 3]!
+  );
+}
+export function vec4ToArray(
+  a: Vec4,
+  array: Float32Array | number[],
+  offset = 0
+): void {
+  array[offset + 0] = a.x;
+  array[offset + 1] = a.y;
+  array[offset + 2] = a.z;
+  array[offset + 3] = a.w;
+}
+export function vec4ToString(a: Vec4): string {
+  return toSafeString([a.x, a.y, a.z, a.w]);
+}
+export function vec4Parse(text: string, result = new Vec4()): Vec4 {
+  return vec4FromArray(parseSafeFloats(text), 0, result);
+}
+export function quatConjugate(a: Vec4, result = new Vec4()): Vec4 {
+  return result.set(-a.x, -a.y, -a.z, a.w);
+}
+export function quatMultiply(a: Vec4, b: Vec4, result = new Vec4()): Vec4 {
+  // from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm
+
+  const qax = a.x;
+  const qay = a.y;
+  const qaz = a.z;
+  const qaw = a.w;
+  const qbx = b.x;
+  const qby = b.y;
+  const qbz = b.z;
+  const qbw = b.w;
+
+  return result.set(
+    qax * qbw + qaw * qbx + qay * qbz - qaz * qby,
+    qay * qbw + qaw * qby + qaz * qbx - qax * qbz,
+    qaz * qbw + qaw * qbz + qax * qby - qay * qbx,
+    qaw * qbw - qax * qbx - qay * qby - qaz * qbz
+  );
+}
+
+export function quatSlerp(
+  a: Vec4,
+  b: Vec4,
+  t: number,
+  result = new Vec4()
+): Vec4 {
+  if (t <= 0) return a.clone(result);
+  if (t >= 1) return b.clone(result);
+
+  // http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/slerp/
+
+  let cosHalfTheta = vec4Dot(a, b);
+
+  if (cosHalfTheta < 0) {
+    vec4Negate(b, result);
+
+    cosHalfTheta = -cosHalfTheta;
+  } else {
+    b.clone(result);
+  }
+
+  if (cosHalfTheta >= 1) {
+    return result;
+  }
+
+  const sqrSinHalfTheta = 1 - cosHalfTheta * cosHalfTheta;
+
+  if (sqrSinHalfTheta <= Number.EPSILON) {
+    vec4Mix(a, result, t);
+    vec4Normalize(result, result);
+
+    return result;
+  }
+
+  const sinHalfTheta = Math.sqrt(sqrSinHalfTheta);
+  const halfTheta = Math.atan2(sinHalfTheta, cosHalfTheta);
+  const ratioA = Math.sin((1 - t) * halfTheta) / sinHalfTheta;
+  const ratioB = Math.sin(t * halfTheta) / sinHalfTheta;
+
+  result.w = a.w * ratioA + result.w * ratioB;
+  result.x = a.x * ratioA + result.x * ratioB;
+  result.y = a.y * ratioA + result.y * ratioB;
+  result.z = a.z * ratioA + result.z * ratioB;
+
+  return result;
+}
+
+/**
+ * Calculate the exponential of a unit quaternion.
+ *
+ * @param {quat} out the receiving quaternion
+ * @param {ReadonlyQuat} a quat to calculate the exponential of
+ * @returns {quat} out
+ */
+export function quatExp(a: Vec4, result = new Vec4()): Vec4 {
+  const x = a.x,
+    y = a.y,
+    z = a.z,
+    w = a.w;
+
+  const r = Math.sqrt(x * x + y * y + z * z);
+  const et = Math.exp(w);
+  const s = r > 0 ? (et * Math.sin(r)) / r : 0;
+
+  return result.set(x * s, y * s, z * s, et * Math.cos(r));
+}
+
+// from gl-matrix
+export function quatLn(a: Vec4, result = new Vec4()): Vec4 {
+  const x = a.x,
+    y = a.y,
+    z = a.z,
+    w = a.w;
+
+  const r = Math.sqrt(x * x + y * y + z * z);
+  const t = r > 0 ? Math.atan2(r, w) / r : 0;
+
+  return result.set(
+    x * t,
+    y * t,
+    z * t,
+    0.5 * Math.log(x * x + y * y + z * z + w * w)
+  );
+}
+
+// from gl-matrix
+export function quatPow(a: Vec4, b: number, result = new Vec4()): Vec4 {
+  const ln = quatLn(a);
+  const lnScaled = vec4MultiplyByScalar(ln, b);
+  quatExp(lnScaled, result);
+  return result;
+}
+
+export function eulerToQuat(euler: Vec3, result: Vec4 = new Vec4()): Vec4 {
+  // eslint-disable-next-line max-len
+  // http://www.mathworks.com/matlabcentral/fileexchange/20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/content/SpinCalc.m
+
+  const c1 = Math.cos(euler.x / 2);
+  const c2 = Math.cos(euler.y / 2);
+  const c3 = Math.cos(euler.z / 2);
+
+  const s1 = Math.sin(euler.x / 2);
+  const s2 = Math.sin(euler.y / 2);
+  const s3 = Math.sin(euler.z / 2);
+
+  // XYZ order only
+  return result.set(
+    s1 * c2 * c3 + c1 * s2 * s3,
+    c1 * s2 * c3 - s1 * c2 * s3,
+    c1 * c2 * s3 + s1 * s2 * c3,
+    c1 * c2 * c3 - s1 * s2 * s3
+  );
+}
+
+export function angleAxisToQuat(
+  angle: number,
+  axis: Vec3,
+  result = new Vec4()
+): Vec4 {
+  // http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm
+
+  // assumes axis is normalized
+
+  const halfAngle = angle / 2;
+  const s = Math.sin(halfAngle);
+
+  return result.set(axis.x * s, axis.y * s, axis.z * s, Math.cos(halfAngle));
+}
+
+// from gl-matrix
+export function quatToAngleAxis(
+  q: Vec4,
+  result = new Vec3()
+): [angle: number, axis: Vec3] {
+  const rad = Math.acos(q.w) * 2;
+  const s = Math.sin(rad / 2);
+  if (s > EPSILON) {
+    result.x = q.x / s;
+    result.y = q.y / s;
+    result.z = q.z / s;
+  } else {
+    // If s is zero, return any axis (no rotation - axis does not matter)
+    result.x = 1;
+    result.y = 0;
+    result.z = 0;
+  }
+  return [rad, result];
+}
+
+export function mat4ToQuat(m: Mat4, result = new Vec4()): Vec4 {
+  return mat3ToQuat(mat4ToMat3(m), result);
+}
+
+export function mat3ToQuat(m: Mat3, result = new Vec4()): Vec4 {
+  // http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm
+
+  // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
+
+  // TODO, allocate x, y, z, w and only set q.* at the end.
+
+  const te = m.elements,
+    m11 = te[0],
+    m12 = te[3],
+    m13 = te[6],
+    m21 = te[1],
+    m22 = te[4],
+    m23 = te[7],
+    m31 = te[2],
+    m32 = te[5],
+    m33 = te[8],
+    trace = m11 + m22 + m33;
+
+  if (trace > 0) {
+    const s = 0.5 / Math.sqrt(trace + 1);
+
+    return result.set(
+      (m32 - m23) * s,
+      (m13 - m31) * s,
+      (m21 - m12) * s,
+      0.25 / s
+    );
+  }
+  if (m11 > m22 && m11 > m33) {
+    const s = 2 * Math.sqrt(1 + m11 - m22 - m33);
+
+    return result.set(
+      0.25 * s,
+      (m12 + m21) / s,
+      (m13 + m31) / s,
+      (m32 - m23) / s
+    );
+  }
+  if (m22 > m33) {
+    const s = 2 * Math.sqrt(1 + m22 - m11 - m33);
+
+    return result.set(
+      (m12 + m21) / s,
+      0.25 * s,
+      (m23 + m32) / s,
+      (m13 - m31) / s
+    );
+  }
+
+  const s = 2 * Math.sqrt(1 + m33 - m11 - m22);
+
+  return result.set(
+    (m13 + m31) / s,
+    (m23 + m32) / s,
+    0.25 * s,
+    (m21 - m12) / s
+  );
+}

package/src/Values/Mat3Value.ts

@@ -0,0 +1,20 @@
+import type { ValueType } from '@kiberon-labs/behave-graph';
+
+import {
+  Mat3,
+  mat3Equals,
+  type Mat3JSON,
+  mat3Mix,
+  mat3Parse
+} from './Internal/Mat3.js';
+
+export const Mat3Value: ValueType = {
+  name: 'mat3',
+  creator: () => new Mat3(),
+  deserialize: (value: string | Mat3JSON) =>
+    typeof value === 'string' ? mat3Parse(value) : new Mat3(value),
+  serialize: (value) => value.elements as Mat3JSON,
+  lerp: (start: Mat3, end: Mat3, t: number) => mat3Mix(start, end, t),
+  equals: (a: Mat3, b: Mat3) => mat3Equals(a, b),
+  clone: (value: Mat3) => value.clone()
+};