@kiberon-labs/behave-graph-scene 1.0.0

package/src/registerSceneProfile.ts

@@ -0,0 +1,105 @@
+import {
+  getCoreValuesMap,
+  getNodeDescriptions,
+  getStringConversionsForValueType,
+  memo
+} from '@kiberon-labs/behave-graph';
+import type {
+  IRegistry,
+  NodeDefinition,
+  ValueType,
+  ValueTypeMap
+} from '@kiberon-labs/behave-graph';
+
+import { SetSceneProperty } from './Nodes/Actions/SetSceneProperty.js';
+import { OnSceneNodeClick } from './Nodes/Events/OnSceneNodeClick.js';
+import * as ColorNodes from './Nodes/Logic/ColorNodes.js';
+import * as EulerNodes from './Nodes/Logic/EulerNodes.js';
+import * as Mat3Nodes from './Nodes/Logic/Mat3Nodes.js';
+import * as Mat4Nodes from './Nodes/Logic/Mat4Nodes.js';
+import * as QuatNodes from './Nodes/Logic/QuatNodes.js';
+import * as Vec2Nodes from './Nodes/Logic/Vec2Nodes.js';
+import * as Vec3Nodes from './Nodes/Logic/Vec3Nodes.js';
+import * as Vec4Nodes from './Nodes/Logic/Vec4Nodes.js';
+import { GetSceneProperty } from './Nodes/Queries/GetSceneProperty.js';
+import { ColorValue } from './Values/ColorValue.js';
+import { EulerValue } from './Values/EulerValue.js';
+import { Mat3Value } from './Values/Mat3Value.js';
+import { Mat4Value } from './Values/Mat4Value.js';
+import { QuatValue } from './Values/QuatValue.js';
+import { Vec2Value } from './Values/Vec2Value.js';
+import { Vec3Value } from './Values/Vec3Value.js';
+import { Vec4Value } from './Values/Vec4Value.js';
+
+export const getSceneValuesMap = memo<ValueTypeMap>(() => {
+  const valueTypes = [
+    Vec2Value,
+    Vec3Value,
+    Vec4Value,
+    ColorValue,
+    EulerValue,
+    QuatValue,
+    Mat3Value,
+    Mat4Value
+  ];
+  const temp = Object.fromEntries(
+    valueTypes.map((valueType) => [valueType.name, valueType])
+  );
+  return temp;
+});
+
+export const getSceneStringConversions = (
+  values: Record<string, ValueType>
+): NodeDefinition[] =>
+  Object.keys(values).flatMap((valueTypeName) =>
+    getStringConversionsForValueType({ values, valueTypeName })
+  );
+
+export const getSceneNodesMap = memo<Record<string, NodeDefinition>>(() => {
+  const allValueTypeNames = Object.keys({
+    ...getCoreValuesMap(),
+    ...getSceneValuesMap()
+  });
+
+  const nodeDefinitions = [
+    // pull in value type nodes
+    ...getNodeDescriptions(Vec2Nodes),
+    ...getNodeDescriptions(Vec3Nodes),
+    ...getNodeDescriptions(Vec4Nodes),
+    ...getNodeDescriptions(ColorNodes),
+    ...getNodeDescriptions(EulerNodes),
+    ...getNodeDescriptions(QuatNodes),
+    ...getNodeDescriptions(Mat3Nodes),
+    ...getNodeDescriptions(Mat4Nodes),
+
+    // events
+    OnSceneNodeClick,
+    // actions
+    ...SetSceneProperty(allValueTypeNames),
+    ...GetSceneProperty(allValueTypeNames),
+
+    ...getSceneStringConversions(getSceneValuesMap())
+  ];
+
+  return Object.fromEntries(
+    nodeDefinitions.map((nodeDefinition) => [
+      nodeDefinition.typeName,
+      nodeDefinition
+    ])
+  );
+});
+
+export const registerSceneProfile = (registry: IRegistry): IRegistry => {
+  const values = {
+    ...registry.values,
+    ...getCoreValuesMap(),
+    ...getSceneValuesMap()
+  };
+  return {
+    values,
+    nodes: { ...registry.nodes, ...getSceneNodesMap() },
+    dependencies: {
+      ...registry.dependencies
+    }
+  };
+};

package/tests/graphs/logic/Color.json

@@ -0,0 +1,53 @@
+{
+  "nodes": [
+    {
+      "type": "lifecycle/onStart",
+      "id": "0",
+      "flows": {
+        "flow": {
+          "nodeId": "3",
+          "socket": "flow"
+        }
+      }
+    },
+    {
+      "type": "math/toColor/rgb",
+      "id": "1",
+      "parameters": {
+        "r": {
+          "value": 1
+        },
+        "g": {
+          "value": 0
+        },
+        "b": {
+          "value": 0
+        }
+      }
+    },
+    {
+      "type": "math/toString/color",
+      "id": "2",
+      "parameters": {
+        "a": {
+          "link": {
+            "nodeId": "1",
+            "socket": "result"
+          }
+        }
+      }
+    },
+    {
+      "type": "debug/log",
+      "id": "3",
+      "parameters": {
+        "text": {
+          "link": {
+            "nodeId": "2",
+            "socket": "result"
+          }
+        }
+      }
+    }
+  ]
+}

package/tests/graphs/logic/Euler.json

@@ -0,0 +1,53 @@
+{
+  "nodes": [
+    {
+      "type": "lifecycle/onStart",
+      "id": "0",
+      "flows": {
+        "flow": {
+          "nodeId": "3",
+          "socket": "flow"
+        }
+      }
+    },
+    {
+      "type": "math/toEuler/float",
+      "id": "1",
+      "parameters": {
+        "x": {
+          "value": 1
+        },
+        "y": {
+          "value": 0
+        },
+        "z": {
+          "value": 0
+        }
+      }
+    },
+    {
+      "type": "math/toString/euler",
+      "id": "2",
+      "parameters": {
+        "a": {
+          "link": {
+            "nodeId": "1",
+            "socket": "result"
+          }
+        }
+      }
+    },
+    {
+      "type": "debug/log",
+      "id": "3",
+      "parameters": {
+        "text": {
+          "link": {
+            "nodeId": "2",
+            "socket": "result"
+          }
+        }
+      }
+    }
+  ]
+}

package/tests/graphs/logic/Quaternion.json

@@ -0,0 +1,56 @@
+{
+  "nodes": [
+    {
+      "type": "lifecycle/onStart",
+      "id": "0",
+      "flows": {
+        "flow": {
+          "nodeId": "3",
+          "socket": "flow"
+        }
+      }
+    },
+    {
+      "type": "math/toQuat/float",
+      "id": "1",
+      "parameters": {
+        "x": {
+          "value": 1
+        },
+        "y": {
+          "value": 0
+        },
+        "z": {
+          "value": 0
+        },
+        "w": {
+          "value": 0
+        }
+      }
+    },
+    {
+      "type": "math/toString/quat",
+      "id": "2",
+      "parameters": {
+        "a": {
+          "link": {
+            "nodeId": "1",
+            "socket": "result"
+          }
+        }
+      }
+    },
+    {
+      "type": "debug/log",
+      "id": "3",
+      "parameters": {
+        "text": {
+          "link": {
+            "nodeId": "2",
+            "socket": "result"
+          }
+        }
+      }
+    }
+  ]
+}

package/tests/graphs/logic/Vector2.json

@@ -0,0 +1,50 @@
+{
+  "nodes": [
+    {
+      "type": "lifecycle/onStart",
+      "id": "0",
+      "flows": {
+        "flow": {
+          "nodeId": "3",
+          "socket": "flow"
+        }
+      }
+    },
+    {
+      "type": "math/toVec2/float",
+      "id": "1",
+      "parameters": {
+        "x": {
+          "value": 1
+        },
+        "y": {
+          "value": 0
+        }
+      }
+    },
+    {
+      "type": "math/toString/vec2",
+      "id": "2",
+      "parameters": {
+        "a": {
+          "link": {
+            "nodeId": "1",
+            "socket": "result"
+          }
+        }
+      }
+    },
+    {
+      "type": "debug/log",
+      "id": "3",
+      "parameters": {
+        "text": {
+          "link": {
+            "nodeId": "2",
+            "socket": "result"
+          }
+        }
+      }
+    }
+  ]
+}

package/tests/graphs/logic/Vector3.json

@@ -0,0 +1,53 @@
+{
+  "nodes": [
+    {
+      "type": "lifecycle/onStart",
+      "id": "0",
+      "flows": {
+        "flow": {
+          "nodeId": "3",
+          "socket": "flow"
+        }
+      }
+    },
+    {
+      "type": "math/toVec3/float",
+      "id": "1",
+      "parameters": {
+        "x": {
+          "value": 1
+        },
+        "y": {
+          "value": 0
+        },
+        "z": {
+          "value": 0
+        }
+      }
+    },
+    {
+      "type": "math/toString/vec3",
+      "id": "2",
+      "parameters": {
+        "a": {
+          "link": {
+            "nodeId": "1",
+            "socket": "result"
+          }
+        }
+      }
+    },
+    {
+      "type": "debug/log",
+      "id": "3",
+      "parameters": {
+        "text": {
+          "link": {
+            "nodeId": "2",
+            "socket": "result"
+          }
+        }
+      }
+    }
+  ]
+}

package/tests/graphs/logic/Vector4.json

@@ -0,0 +1,56 @@
+{
+  "nodes": [
+    {
+      "type": "lifecycle/onStart",
+      "id": "0",
+      "flows": {
+        "flow": {
+          "nodeId": "3",
+          "socket": "flow"
+        }
+      }
+    },
+    {
+      "type": "math/toVec4/float",
+      "id": "1",
+      "parameters": {
+        "x": {
+          "value": 1
+        },
+        "y": {
+          "value": 0
+        },
+        "z": {
+          "value": 0
+        },
+        "w": {
+          "value": 0
+        }
+      }
+    },
+    {
+      "type": "math/toString/vec4",
+      "id": "2",
+      "parameters": {
+        "a": {
+          "link": {
+            "nodeId": "1",
+            "socket": "result"
+          }
+        }
+      }
+    },
+    {
+      "type": "debug/log",
+      "id": "3",
+      "parameters": {
+        "text": {
+          "link": {
+            "nodeId": "2",
+            "socket": "result"
+          }
+        }
+      }
+    }
+  ]
+}

package/tests/readSceneGraphs.test.ts

@@ -0,0 +1,57 @@
+import * as colorJson from './graphs/logic/Color.json';
+import * as eulerJson from './graphs/logic/Euler.json';
+import * as quaternionJson from './graphs/logic/Quaternion.json';
+import * as vector2Json from './graphs/logic/Vector2.json';
+import * as vector3Json from './graphs/logic/Vector3.json';
+import * as vector4Json from './graphs/logic/Vector4.json';
+import {
+  readGraphFromJSON,
+  validateGraphLinks,
+  registerCoreProfile,
+  validateGraphAcyclic,
+  type IRegistry,
+  type GraphInstance,
+  type GraphJSON
+} from '@kiberon-labs/behave-graph';
+import { registerSceneProfile } from '@/registerSceneProfile.js';
+import { describe, test, expect } from 'vitest';
+
+let registry: IRegistry = {
+  nodes: {},
+  values: {},
+  dependencies: {}
+};
+registry = registerCoreProfile(registry);
+registry = registerSceneProfile(registry);
+
+const exampleMap: { [key: string]: any } = {
+  vector2Json,
+  vector3Json,
+  vector4Json,
+  quaternionJson,
+  colorJson,
+  eulerJson
+};
+
+for (const key in exampleMap) {
+  describe(`${key}`, () => {
+    const exampleJson = exampleMap[key] as GraphJSON;
+
+    let parsedGraphJson: GraphInstance | undefined;
+    test('parse json to graph', () => {
+      expect(() => {
+        parsedGraphJson = readGraphFromJSON({
+          graphJson: exampleJson,
+          registry
+        });
+      }).not.toThrow();
+      // await fs.writeFile('./examples/test.json', JSON.stringify(writeGraphToJSON(graph), null, ' '), { encoding: 'utf-8' });
+      if (parsedGraphJson !== undefined) {
+        expect(validateGraphLinks(parsedGraphJson.nodes)).toHaveLength(0);
+        expect(validateGraphAcyclic(parsedGraphJson.nodes)).toHaveLength(0);
+      } else {
+        expect(parsedGraphJson).toBeDefined();
+      }
+    });
+  });
+}

package/tests/registerSceneProfile.test.ts

@@ -0,0 +1,62 @@
+import {
+  validateValueRegistry,
+  registerCoreProfile,
+  validateNodeRegistry,
+  type IRegistry
+} from '@kiberon-labs/behave-graph';
+
+import { registerSceneProfile } from '../src/registerSceneProfile.js';
+import { describe, test, expect } from 'vitest';
+
+describe('scene profile', () => {
+  let registry: IRegistry = {
+    nodes: {},
+    values: {},
+    dependencies: {
+      IScene: null
+    }
+  };
+  registry = registerCoreProfile(registry);
+  registry = registerSceneProfile(registry);
+
+  test('validate node registry', () => {
+    expect(validateNodeRegistry(registry)).toHaveLength(0);
+  });
+  test('validate value registry', () => {
+    expect(validateValueRegistry(registry.values)).toHaveLength(0);
+  });
+
+  const valueTypeNameToExampleValues: { [key: string]: any[] } = {
+    vec2: ['(0,0)', '1,0', '(100,-60.0)', { x: 0, y: 0 }, { x: -60, y: 100 }],
+    vec3: [
+      '(0,0,0)',
+      '1,0,0',
+      '100,-60.0,40',
+      { x: 0, y: 0, z: 1 },
+      { x: -60, y: 100, z: 0 }
+    ],
+    vec4: [
+      '(0,0,0,0)',
+      '1,0,0,0',
+      '(100,-60.0,40,-9e9)',
+      { x: 0, y: 0, z: 1, w: 2 },
+      { x: -60, y: 100, z: 0, w: -10 }
+    ]
+  };
+
+  for (const valueTypeName in valueTypeNameToExampleValues) {
+    test(`${valueTypeName} serialization/deserialization`, () => {
+      const valueType = registry.values[valueTypeName]!;
+
+      const exampleValues: any[] = valueTypeNameToExampleValues[valueTypeName]!;
+      exampleValues.forEach((exampleValue: any) => {
+        const deserializedValue = valueType.deserialize(exampleValue);
+        const serializedValue = valueType.serialize(deserializedValue);
+        const redeserializedValue = valueType.deserialize(serializedValue);
+        const reserializedValue = valueType.serialize(redeserializedValue);
+
+        expect(serializedValue).toStrictEqual(reserializedValue);
+      });
+    });
+  }
+});

package/tests/tsconfig.json

@@ -0,0 +1,11 @@
+{
+    "extends": "../tsconfig.json",
+    "compilerOptions": {
+        "rootDir": "../",
+        "lib": []
+    },
+    "include": [
+        "**/*.ts",
+        "**/*.json"
+    ]
+}

package/tests/values/internal/Vec2.test.ts

@@ -0,0 +1,74 @@
+import {
+  Vec2,
+  vec2Add,
+  vec2Dot,
+  vec2FromArray,
+  vec2Length,
+  vec2MultiplyByScalar,
+  vec2Negate,
+  vec2Normalize,
+  vec2Parse,
+  vec2Subtract,
+  vec2ToArray,
+  vec2ToString
+} from '@/Values/Internal/Vec2.js';
+import { describe, test, expect } from 'vitest';
+
+describe('vec2 value type', () => {
+  test('constructor', () => {
+    const value = new Vec2(1, 2);
+    expect(value.x).toEqual(1);
+    expect(value.y).toEqual(2);
+  });
+  test('add', () => {
+    const value = vec2Add(new Vec2(1, 2), new Vec2(3, 4));
+    expect(value.x).toEqual(4);
+    expect(value.y).toEqual(6);
+  });
+  test('subtract', () => {
+    const value = vec2Subtract(new Vec2(1, 2), new Vec2(3, 8));
+    expect(value.x).toEqual(-2);
+    expect(value.y).toEqual(-6);
+  });
+  test('scale', () => {
+    const value = vec2MultiplyByScalar(new Vec2(1, 2), 2);
+    expect(value.x).toEqual(2);
+    expect(value.y).toEqual(4);
+  });
+  test('negate', () => {
+    const value = vec2Negate(new Vec2(1, 2));
+    expect(value.x).toEqual(-1);
+    expect(value.y).toEqual(-2);
+  });
+  test('length', () => {
+    const value = vec2Length(new Vec2(1, 2));
+    expect(value).toEqual(Math.sqrt(1 + 2 * 2));
+  });
+  test('normalize', () => {
+    const value = vec2Normalize(new Vec2(0, 2));
+    expect(value.x).toEqual(0);
+    expect(value.y).toEqual(1);
+  });
+  test('dot', () => {
+    const value = vec2Dot(new Vec2(0, 2), new Vec2(3, 4));
+    expect(value).toEqual(8);
+  });
+  test('fromArray', () => {
+    const value = vec2FromArray([1, 2, 3], 1);
+    expect(value.x).toEqual(2);
+    expect(value.y).toEqual(3);
+  });
+  test('fromArray', () => {
+    const array = [1, 2, 3];
+    vec2ToArray(new Vec2(6, 7), array, 1);
+    expect(array[1]).toEqual(6);
+    expect(array[2]).toEqual(7);
+  });
+  test('toString/parser', () => {
+    const v = new Vec2(10, 5.5);
+    const text = vec2ToString(v);
+    const v2 = vec2Parse(text);
+    expect(v.x).toEqual(v2.x);
+    expect(v.y).toEqual(v2.y);
+  });
+});