@kiberon-labs/behave-graph-scene 1.0.0

package/src/Nodes/Logic/Vec2Nodes.ts

@@ -0,0 +1,111 @@
+import { makeInNOutFunctionDesc } from '@kiberon-labs/behave-graph';
+
+import {
+  Vec2,
+  vec2Add,
+  vec2Dot,
+  vec2Equals,
+  vec2Length,
+  vec2Mix,
+  vec2MultiplyByScalar,
+  vec2Negate,
+  vec2Normalize,
+  vec2Subtract,
+  vec2ToArray
+} from '../../Values/Internal/Vec2.js';
+
+export const Constant = makeInNOutFunctionDesc({
+  name: 'math/vec2',
+  label: 'Vec2',
+  in: ['vec2'],
+  out: 'vec2',
+  exec: (a: Vec2) => a
+});
+
+export const Create = makeInNOutFunctionDesc({
+  name: 'math/toVec2/float',
+  label: 'Float to Vec2',
+  in: [{ x: 'float' }, { y: 'float' }],
+  out: 'vec2',
+  exec: (x: number, y: number) => new Vec2(x, y)
+});
+
+export const Elements = makeInNOutFunctionDesc({
+  name: 'math/toFloat/vec2',
+  label: 'Vec2 To Float',
+  in: ['vec2'],
+  out: [{ x: 'float' }, { y: 'float' }],
+  exec: vec2ToArray
+});
+
+export const Add = makeInNOutFunctionDesc({
+  name: 'math/add/vec2',
+  label: '+',
+  in: ['vec2', 'vec2'],
+  out: 'vec2',
+  exec: vec2Add
+});
+
+export const Subtract = makeInNOutFunctionDesc({
+  name: 'math/subtract/vec2',
+  label: '-',
+  in: ['vec2', 'vec2'],
+  out: 'vec2',
+  exec: vec2Subtract
+});
+
+export const Negate = makeInNOutFunctionDesc({
+  name: 'math/negate/vec2',
+  label: '-',
+  in: ['vec2'],
+  out: 'vec2',
+  exec: vec2Negate
+});
+
+export const Scale = makeInNOutFunctionDesc({
+  name: 'math/scale/vec2',
+  label: '×',
+  in: ['vec2', 'float'],
+  out: 'vec2',
+  exec: vec2MultiplyByScalar
+});
+
+export const Length = makeInNOutFunctionDesc({
+  name: 'math/length/vec2',
+  label: 'Length',
+  in: ['vec2'],
+  out: 'float',
+  exec: vec2Length
+});
+
+export const Normalize = makeInNOutFunctionDesc({
+  name: 'math/normalize/vec2',
+  label: 'Normalize',
+  in: ['vec2'],
+  out: 'vec2',
+  exec: vec2Normalize
+});
+
+export const Dot = makeInNOutFunctionDesc({
+  name: 'math/dot/vec2',
+  label: 'Dot Product',
+  in: ['vec2', 'vec2'],
+  out: 'float',
+  exec: vec2Dot
+});
+
+export const Mix = makeInNOutFunctionDesc({
+  name: 'math/mix/vec2',
+  label: '÷',
+  in: [{ a: 'vec2' }, { b: 'vec2' }, { t: 'float' }],
+  out: 'vec2',
+  exec: vec2Mix
+});
+
+export const Equal = makeInNOutFunctionDesc({
+  name: 'math/equal/vec2',
+  label: '=',
+  in: [{ a: 'vec2' }, { b: 'vec2' }, { tolerance: 'float' }],
+  out: 'boolean',
+  exec: vec2Equals
+});

package/src/Nodes/Logic/Vec3Nodes.ts

@@ -0,0 +1,121 @@
+import { makeInNOutFunctionDesc } from '@kiberon-labs/behave-graph';
+
+import {
+  Vec3,
+  vec3Add,
+  vec3Cross,
+  vec3Dot,
+  vec3Equals,
+  vec3Length,
+  vec3Mix,
+  vec3MultiplyByScalar,
+  vec3Negate,
+  vec3Normalize,
+  vec3Subtract
+} from '../../Values/Internal/Vec3.js';
+
+export const Constant = makeInNOutFunctionDesc({
+  name: 'math/vec3',
+  label: 'Vec3',
+  in: ['vec3'],
+  out: 'vec3',
+  exec: (a: Vec3) => a
+});
+
+export const Create = makeInNOutFunctionDesc({
+  name: 'math/toVec3/float',
+  label: 'Float to Vec3',
+  in: [{ x: 'float' }, { y: 'float' }, { z: 'float' }],
+  out: 'vec3',
+  exec: (x: number, y: number, z: number) => new Vec3(x, y, z)
+});
+
+export const Elements = makeInNOutFunctionDesc({
+  name: 'math/toFloat/vec3',
+  label: 'Vec3 To Float',
+  in: ['vec3'],
+  out: [{ x: 'float' }, { y: 'float' }, { z: 'float' }],
+  exec: (a: Vec3) => {
+    return { x: a.x, y: a.y, z: a.z };
+  }
+});
+
+export const Add = makeInNOutFunctionDesc({
+  name: 'math/add/vec3',
+  label: '+',
+  in: ['vec3', 'vec3'],
+  out: 'vec3',
+  exec: vec3Add
+});
+
+export const Subtract = makeInNOutFunctionDesc({
+  name: 'math/subtract/vec3',
+  label: '-',
+  in: ['vec3', 'vec3'],
+  out: 'vec3',
+  exec: vec3Subtract
+});
+
+export const Negate = makeInNOutFunctionDesc({
+  name: 'math/negate/vec3',
+  label: '-',
+  in: ['vec3'],
+  out: 'vec3',
+  exec: vec3Negate
+});
+
+export const Scale = makeInNOutFunctionDesc({
+  name: 'math/scale/vec3',
+  label: '×',
+  in: ['vec3', 'float'],
+  out: 'vec3',
+  exec: vec3MultiplyByScalar
+});
+
+export const Length = makeInNOutFunctionDesc({
+  name: 'math/length/vec3',
+  label: 'Length',
+  in: ['vec3'],
+  out: 'float',
+  exec: vec3Length
+});
+
+export const Normalize = makeInNOutFunctionDesc({
+  name: 'math/normalize/vec3',
+  label: 'Normalize',
+  in: ['vec3'],
+  out: 'vec3',
+  exec: vec3Normalize
+});
+
+export const Cross = makeInNOutFunctionDesc({
+  name: 'math/cross/vec3',
+  label: 'Cross',
+  in: ['vec3', 'vec3'],
+  out: 'vec3',
+  exec: vec3Cross
+});
+
+export const Dot = makeInNOutFunctionDesc({
+  name: 'math/dot/vec3',
+  label: 'Dot',
+  in: ['vec3', 'vec3'],
+  out: 'float',
+  exec: vec3Dot
+});
+
+export const Mix = makeInNOutFunctionDesc({
+  name: 'math/mix/vec3',
+  label: '÷',
+  in: [{ a: 'vec3' }, { b: 'vec3' }, { t: 'float' }],
+  out: 'vec3',
+  exec: vec3Mix
+});
+
+export const Equal = makeInNOutFunctionDesc({
+  name: 'math/equal/vec3',
+  label: '=',
+  in: [{ a: 'vec3' }, { b: 'vec3' }, { tolerance: 'float' }],
+  out: 'boolean',
+  exec: vec3Equals
+});

package/src/Nodes/Logic/Vec4Nodes.ts

@@ -0,0 +1,112 @@
+import { makeInNOutFunctionDesc } from '@kiberon-labs/behave-graph';
+
+import {
+  Vec4,
+  vec4Add,
+  vec4Dot,
+  vec4Equals,
+  vec4Length,
+  vec4Mix,
+  vec4MultiplyByScalar,
+  vec4Negate,
+  vec4Normalize,
+  vec4Subtract
+} from '../../Values/Internal/Vec4.js';
+
+export const Constant = makeInNOutFunctionDesc({
+  name: 'math/vec4',
+  label: 'Vec4',
+  in: ['vec4'],
+  out: 'vec4',
+  exec: (a) => a
+});
+
+export const Create = makeInNOutFunctionDesc({
+  name: 'math/toVec4/float',
+  label: 'Float to Vec4',
+  in: [{ x: 'float' }, { y: 'float' }, { z: 'float' }, { w: 'float' }],
+  out: 'vec4',
+  exec: (x: number, y: number, z: number, w: number) => new Vec4(x, y, z, w)
+});
+
+export const Elements = makeInNOutFunctionDesc({
+  name: 'math/toFloat/vec4',
+  label: 'Vec4 to Float',
+  in: ['vec4'],
+  out: [{ x: 'float' }, { y: 'float' }, { z: 'float' }, { w: 'float' }],
+  exec: (a: Vec4) => {
+    return { x: a.x, y: a.y, z: a.z, w: a.z };
+  }
+});
+
+export const Add = makeInNOutFunctionDesc({
+  name: 'math/add/vec4',
+  label: '+',
+  in: ['vec4', 'vec4'],
+  out: 'vec4',
+  exec: vec4Add
+});
+
+export const Subtract = makeInNOutFunctionDesc({
+  name: 'math/subtract/vec4',
+  label: '-',
+  in: ['vec4', 'vec4'],
+  out: 'vec4',
+  exec: vec4Subtract
+});
+
+export const Negate = makeInNOutFunctionDesc({
+  name: 'math/negate/vec4',
+  label: '-',
+  in: ['vec4'],
+  out: 'vec4',
+  exec: vec4Negate
+});
+
+export const Scale = makeInNOutFunctionDesc({
+  name: 'math/scale/vec4',
+  label: '×',
+  in: ['vec4', 'float'],
+  out: 'vec4',
+  exec: vec4MultiplyByScalar
+});
+
+export const Length = makeInNOutFunctionDesc({
+  name: 'math/length/vec4',
+  label: 'Length',
+  in: ['vec4'],
+  out: 'float',
+  exec: vec4Length
+});
+
+export const Normalize = makeInNOutFunctionDesc({
+  name: 'math/normalize/vec4',
+  label: 'Normalize',
+  in: ['vec4'],
+  out: 'vec4',
+  exec: vec4Normalize
+});
+
+export const Dot = makeInNOutFunctionDesc({
+  name: 'math/dot/vec4',
+  label: 'Dot Product',
+  in: ['vec4', 'vec4'],
+  out: 'float',
+  exec: vec4Dot
+});
+
+export const Mix = makeInNOutFunctionDesc({
+  name: 'math/mix/vec4',
+  label: '÷',
+  in: [{ a: 'vec4' }, { b: 'vec4' }, { t: 'float' }],
+  out: 'vec4',
+  exec: vec4Mix
+});
+
+export const Equal = makeInNOutFunctionDesc({
+  name: 'math/equal/vec4',
+  label: '=',
+  in: [{ a: 'vec4' }, { b: 'vec4' }, { tolerance: 'float' }],
+  out: 'boolean',
+  exec: vec4Equals
+});

package/src/Nodes/Logic/VecElements.ts

@@ -0,0 +1,34 @@
+import {
+  FunctionNode,
+  type IGraph,
+  NodeDescription,
+  Socket
+} from '@kiberon-labs/behave-graph';
+
+export class VecElements<T> extends FunctionNode {
+  constructor(
+    description: NodeDescription,
+    graph: IGraph,
+    valueTypeName: string,
+    elementNames: string[] = ['x', 'y', 'z', 'w'],
+    toArray: (value: T, array: number[], offset: number) => void,
+    id: string
+  ) {
+    super(
+      description,
+      graph,
+      [new Socket(valueTypeName, 'value')],
+      elementNames.map((elementName) => new Socket('float', elementName)),
+      () => {
+        const value = this.readInput('value') as T;
+        const elementValues = elementNames.map(() => 0);
+        toArray(value, elementValues, 0);
+        elementNames.forEach((elementName, index) =>
+          this.writeOutput(elementName, elementValues[index])
+        );
+      },
+      {},
+      id
+    );
+  }
+}

package/src/Nodes/Queries/GetSceneProperty.ts

@@ -0,0 +1,35 @@
+import {
+  makeFunctionNodeDefinition,
+  NodeCategory
+} from '@kiberon-labs/behave-graph';
+import type { IScene } from '../../Abstractions/IScene.js';
+
+export const GetSceneProperty = (valueTypeNames: string[]) =>
+  valueTypeNames.map((valueTypeName) =>
+    makeFunctionNodeDefinition({
+      typeName: `scene/get/${valueTypeName}`,
+      category: NodeCategory.Query,
+      label: `Scene set ${valueTypeName}`,
+      in: {
+        jsonPath: (_, graphApi) => {
+          const scene = graphApi.getDependency<IScene>('IScene');
+
+          return {
+            valueType: 'string',
+            choices: scene?.getProperties()
+          };
+        }
+      },
+      out: {
+        value: valueTypeName
+      },
+      exec: ({ graph, read, write }) => {
+        const scene = graph.getDependency<IScene>('IScene');
+        const propertyValue = scene?.getProperty(
+          read('jsonPath'),
+          valueTypeName
+        );
+        write('value', propertyValue);
+      }
+    })
+  );

package/src/Values/ColorValue.ts

@@ -0,0 +1,22 @@
+import type { ValueType } from '@kiberon-labs/behave-graph';
+
+import {
+  Vec3,
+  vec3Equals,
+  type Vec3JSON,
+  vec3Mix,
+  vec3Parse
+} from './Internal/Vec3.js';
+
+export const ColorValue: ValueType = {
+  name: 'color',
+  creator: () => new Vec3(),
+  deserialize: (value: string | Vec3JSON) =>
+    typeof value === 'string'
+      ? vec3Parse(value)
+      : new Vec3(value[0], value[1], value[2]),
+  serialize: (value) => [value.x, value.y, value.z] as Vec3JSON,
+  lerp: (start: Vec3, end: Vec3, t: number) => vec3Mix(start, end, t),
+  equals: (a: Vec3, b: Vec3) => vec3Equals(a, b),
+  clone: (value: Vec3) => value.clone()
+};

package/src/Values/EulerValue.ts

@@ -0,0 +1,22 @@
+import type { ValueType } from '@kiberon-labs/behave-graph';
+
+import {
+  Vec3,
+  vec3Equals,
+  type Vec3JSON,
+  vec3Mix,
+  vec3Parse
+} from './Internal/Vec3.js';
+
+export const EulerValue: ValueType = {
+  name: 'euler',
+  creator: () => new Vec3(),
+  deserialize: (value: string | Vec3JSON) =>
+    typeof value === 'string'
+      ? vec3Parse(value)
+      : new Vec3(value[0], value[1], value[2]),
+  serialize: (value) => [value.x, value.y, value.z] as Vec3JSON,
+  lerp: (start: Vec3, end: Vec3, t: number) => vec3Mix(start, end, t),
+  equals: (a: Vec3, b: Vec3) => vec3Equals(a, b),
+  clone: (value: Vec3) => value.clone()
+};

package/src/Values/Internal/Mat2.ts

@@ -0,0 +1,214 @@
+import {
+  EPSILON,
+  equalsTolerance,
+  parseSafeFloats,
+  toSafeString
+} from '@kiberon-labs/behave-graph';
+
+import { Mat3 } from './Mat3.js';
+import { Mat4 } from './Mat4.js';
+import { Vec2 } from './Vec2.js';
+
+// uses OpenGL matrix layout where each column is specified subsequently in order from left to right.
+// ( x, y ) x [ 0  2 ] = ( x', y' )
+//            [ 1  3 ]
+
+const NUM_ROWS = 2;
+const NUM_COLUMNS = 2;
+const NUM_ELEMENTS = NUM_ROWS * NUM_COLUMNS;
+
+export type Mat2JSON = number[];
+
+type Mat2Elements = [number, number, number, number];
+
+export class Mat2 {
+  public elements: Mat2Elements;
+  constructor(elements: Mat2Elements = [1, 0, 0, 1]) {
+    this.elements = elements;
+    if (elements.length !== NUM_ELEMENTS) {
+      throw new Error(
+        `elements must have length ${NUM_ELEMENTS}, got ${elements.length}`
+      );
+    }
+  }
+
+  clone(result = new Mat2()): Mat2 {
+    return result.set(this.elements);
+  }
+  set(elements: Mat2Elements): this {
+    if (elements.length !== NUM_ELEMENTS) {
+      throw new Error(
+        `elements must have length ${NUM_ELEMENTS}, got ${elements.length}`
+      );
+    }
+    this.elements = [...elements];
+    return this;
+  }
+}
+
+export function mat2SetColumn3(
+  m: Mat2,
+  columnIndex: number,
+  column: Vec2,
+  result = new Mat2()
+): Mat2 {
+  const re = result.set(m.elements).elements;
+  const base = columnIndex * NUM_ROWS;
+  re[base + 0] = column.x;
+  re[base + 1] = column.y;
+  return result;
+}
+
+export function mat2SetRow3(
+  m: Mat2,
+  rowIndex: number,
+  row: Vec2,
+  result = new Mat2()
+): Mat2 {
+  const re = result.set(m.elements).elements;
+  re[rowIndex + NUM_COLUMNS * 0] = row.x;
+  re[rowIndex + NUM_COLUMNS * 1] = row.y;
+  return result;
+}
+
+export function column3ToMat2(
+  a: Vec2,
+  b: Vec2,
+  c: Vec2,
+  result = new Mat2()
+): Mat2 {
+  const re = result.elements;
+  const columns = [a, b, c];
+  for (let c = 0; c < columns.length; c++) {
+    const base = c * NUM_ROWS;
+    const column = columns[c]!;
+    re[base + 0] = column.x;
+    re[base + 1] = column.y;
+  }
+  return result;
+}
+
+export function mat2Equals(a: Mat2, b: Mat2, tolerance = EPSILON): boolean {
+  for (let i = 0; i < NUM_ELEMENTS; i++) {
+    if (!equalsTolerance(a.elements[i]!, b.elements[i]!, tolerance))
+      return false;
+  }
+  return true;
+}
+export function mat2Add(a: Mat2, b: Mat2, result: Mat2 = new Mat2()): Mat2 {
+  for (let i = 0; i < NUM_ELEMENTS; i++) {
+    result.elements[i] = a.elements[i]! + b.elements[i]!;
+  }
+  return result;
+}
+export function mat2Subtract(
+  a: Mat2,
+  b: Mat2,
+  result: Mat2 = new Mat2()
+): Mat2 {
+  for (let i = 0; i < NUM_ELEMENTS; i++) {
+    result.elements[i] = a.elements[i]! - b.elements[i]!;
+  }
+  return result;
+}
+export function mat2MultiplyByScalar(
+  a: Mat2,
+  b: number,
+  result: Mat2 = new Mat2()
+): Mat2 {
+  for (let i = 0; i < NUM_ELEMENTS; i++) {
+    result.elements[i] = a.elements[i]! * b;
+  }
+  return result;
+}
+export function mat2Negate(a: Mat2, result: Mat2 = new Mat2()): Mat2 {
+  for (let i = 0; i < NUM_ELEMENTS; i++) {
+    result.elements[i] = -a.elements[i]!;
+  }
+  return result;
+}
+
+export function mat2Multiply(a: Mat2, b: Mat2, result = new Mat2()): Mat2 {
+  throw new Error('not implemented');
+}
+
+export function mat2Determinant(m: Mat2): number {
+  throw new Error('not implemented');
+}
+
+export function mat2Transpose(m: Mat2, result = new Mat2()): Mat2 {
+  const me = m.elements;
+  const te = result.elements;
+
+  te[0] = me[0];
+  te[1] = me[2];
+  te[2] = me[1];
+  te[3] = me[3];
+
+  return result;
+}
+
+export function mat2Inverse(m: Mat2, result = new Mat2()): Mat2 {
+  throw new Error('not implemented');
+}
+
+export function mat2Mix(
+  a: Mat2,
+  b: Mat2,
+  t: number,
+  result = new Mat2()
+): Mat2 {
+  const s = 1 - t;
+  for (let i = 0; i < NUM_ELEMENTS; i++) {
+    result.elements[i] = a.elements[i]! * s + b.elements[i]! * t;
+  }
+  return result;
+}
+export function mat2FromArray(
+  array: Float32Array | number[],
+  offset = 0,
+  result: Mat2 = new Mat2()
+): Mat2 {
+  for (let i = 0; i < NUM_ELEMENTS; i++) {
+    result.elements[i] = array[offset + i]!;
+  }
+  return result;
+}
+export function mat2ToArray(
+  a: Mat2,
+  array: Float32Array | number[],
+  offset = 0
+): void {
+  for (let i = 0; i < NUM_ELEMENTS; i++) {
+    array[offset + i] = a.elements[i]!;
+  }
+}
+
+export function mat2ToString(a: Mat2): string {
+  return toSafeString(a.elements);
+}
+export function mat2Parse(text: string, result = new Mat2()): Mat2 {
+  return mat2FromArray(parseSafeFloats(text), 0, result);
+}
+
+export function scale2ToMat2(s: Vec2, result = new Mat2()): Mat2 {
+  return result.set([s.x, 0, 0, s.y]);
+}
+// from gl-matrix
+export function mat2ToScale2(m: Mat4, result = new Vec2()): Vec2 {
+  const mat = m.elements;
+  const m11 = mat[0];
+  const m12 = mat[1];
+  const m21 = mat[2];
+  const m22 = mat[3];
+
+  return result.set(
+    Math.sqrt(m11 * m11 + m12 * m12),
+    Math.sqrt(m21 * m21 + m22 * m22)
+  );
+}
+
+export function mat3ToMat2(a: Mat3, result = new Mat2()): Mat2 {
+  const ae = a.elements;
+  return result.set([ae[0], ae[1], ae[3], ae[4]]);
+}