@kiberon-labs/behave-graph-scene 1.0.0 → 2.0.0

package/src/Nodes/Actions/CreateMesh.ts

@@ -0,0 +1,47 @@
+import {
+  makeFlowNodeDefinition,
+  NodeCategory
+} from '@kiberon-labs/behave-graph';
+
+import { GeometryType } from '../../Abstractions/IScene.js';
+
+const geometryChoices = Object.values(GeometryType).map((v) => ({
+  text: v,
+  value: v
+}));
+
+export const CreateMesh = makeFlowNodeDefinition({
+  typeName: 'scene/createMesh',
+  category: NodeCategory.Effect,
+  label: 'Create Mesh',
+  in: {
+    flow: 'flow',
+    name: 'string',
+    geometryType: (_) => ({
+      valueType: 'string',
+      choices: geometryChoices
+    }),
+    sizeX: 'float',
+    sizeY: 'float',
+    sizeZ: 'float'
+  },
+  out: {
+    flow: 'flow'
+  },
+  initialState: undefined,
+  triggered: ({ commit, read, graph }) => {
+    const scene = graph.getDependency('IScene');
+    const name = read<string>('name');
+    const geometryType = read<string>('geometryType');
+    const sizeX = read<number>('sizeX');
+    const sizeY = read<number>('sizeY');
+    const sizeZ = read<number>('sizeZ');
+
+    scene?.createMesh(
+      name,
+      geometryType as (typeof GeometryType)[keyof typeof GeometryType],
+      { x: sizeX, y: sizeY, z: sizeZ }
+    );
+    commit('flow');
+  }
+});

package/src/Nodes/Actions/DeleteMesh.ts

@@ -0,0 +1,29 @@
+import {
+  makeFlowNodeDefinition,
+  NodeCategory
+} from '@kiberon-labs/behave-graph';
+
+export const DeleteMesh = makeFlowNodeDefinition({
+  typeName: 'scene/deleteMesh',
+  category: NodeCategory.Effect,
+  label: 'Delete Mesh',
+  in: {
+    flow: 'flow',
+    name: (_, graphApi) => {
+      const scene = graphApi.getDependency('IScene');
+      return {
+        valueType: 'string',
+        choices: scene?.getMeshNames()
+      };
+    }
+  },
+  out: {
+    flow: 'flow'
+  },
+  initialState: undefined,
+  triggered: ({ commit, read, graph }) => {
+    const scene = graph.getDependency('IScene');
+    scene?.deleteMesh(read<string>('name'));
+    commit('flow');
+  }
+});

package/src/Nodes/Actions/EaseSceneProperty.ts

@@ -1,16 +1,19 @@
 import {
   AsyncNode,
-  type Easing,
   EasingFunctions,
   EasingModes,
   Engine,
   type IGraph,
   type ILifecycleEventEmitter,
+  lerpValue,
   NodeDescription,
   Socket,
   toCamelCase
 } from '@kiberon-labs/behave-graph';
 
+/** An easing curve: maps a normalized time `t` in [0,1] to an eased value. */
+type Easing = (typeof EasingFunctions)[keyof typeof EasingFunctions];
+
 import type { IScene } from '../../Abstractions/IScene.js';
 
 export class EaseSceneProperty extends AsyncNode {
@@ -129,7 +132,8 @@ export class EaseSceneProperty extends AsyncNode {
       this.elapsedDuration = (Date.now() - this.startTime) / 1000;
 
       const t = Math.min(this.elapsedDuration / this.duration, 1);
-      const easedValue = valueType.lerp(
+      const easedValue = lerpValue(
+        valueType,
         this.initialValue,
         this.targetValue,
         this.easing(t)

package/src/Nodes/Actions/LookAt.ts

@@ -0,0 +1,34 @@
+import type { Vec3 } from '@/Values/Internal/Vec3';
+import {
+  makeFlowNodeDefinition,
+  NodeCategory
+} from '@kiberon-labs/behave-graph';
+
+// Orient a mesh to face a world-space target position.
+export const LookAt = makeFlowNodeDefinition({
+  typeName: 'scene/lookAt',
+  category: NodeCategory.Effect,
+  label: 'Look At',
+  in: {
+    flow: 'flow',
+    meshName: (_, graphApi) => {
+      const scene = graphApi.getDependency('IScene');
+      return {
+        valueType: 'string',
+        choices: scene?.getMeshNames()
+      };
+    },
+    target: 'vec3'
+  },
+  out: {
+    flow: 'flow'
+  },
+  initialState: undefined,
+  triggered: ({ commit, read, graph }) => {
+    const scene = graph.getDependency('IScene');
+    const meshName = read<string>('meshName');
+    const target = read<Vec3>('target');
+    scene?.lookAt(meshName, { x: target.x, y: target.y, z: target.z });
+    commit('flow');
+  }
+});

package/src/Nodes/Actions/MoveTowards.ts

@@ -0,0 +1,55 @@
+import {
+  makeFlowNodeDefinition,
+  NodeCategory
+} from '@kiberon-labs/behave-graph';
+
+// Move a mesh towards a target position by (speed * deltaSeconds).
+// Outputs 'done' when the mesh has arrived, otherwise 'ongoing'.
+// Designed to be driven from an OnTick loop.
+export const MoveTowards = makeFlowNodeDefinition({
+  typeName: 'scene/moveTowards',
+  category: NodeCategory.Effect,
+  label: 'Move Towards',
+  in: {
+    flow: 'flow',
+    meshName: (_, graphApi) => {
+      const scene = graphApi.getDependency('IScene');
+      return {
+        valueType: 'string',
+        choices: scene?.getMeshNames()
+      };
+    },
+    targetX: 'float',
+    targetY: 'float',
+    targetZ: 'float',
+    speed: 'float',
+    deltaSeconds: 'float'
+  },
+  out: {
+    ongoing: 'flow',
+    done: 'flow'
+  },
+  initialState: undefined,
+  triggered: ({ commit, read, graph }) => {
+    const scene = graph.getDependency('IScene');
+    const meshName = read<string>('meshName');
+    const targetX = read<number>('targetX');
+    const targetY = read<number>('targetY');
+    const targetZ = read<number>('targetZ');
+    const speed = read<number>('speed');
+    const deltaSeconds = read<number>('deltaSeconds');
+
+    const arrived = scene?.moveTowards(
+      meshName,
+      { x: targetX, y: targetY, z: targetZ },
+      speed,
+      deltaSeconds
+    );
+
+    if (arrived) {
+      commit('done');
+    } else {
+      commit('ongoing');
+    }
+  }
+});

package/src/Nodes/Actions/RemoveLight.ts

@@ -0,0 +1,29 @@
+import {
+  makeFlowNodeDefinition,
+  NodeCategory
+} from '@kiberon-labs/behave-graph';
+
+export const RemoveLight = makeFlowNodeDefinition({
+  typeName: 'scene/removeLight',
+  category: NodeCategory.Effect,
+  label: 'Remove Light',
+  in: {
+    flow: 'flow',
+    name: (_, graphApi) => {
+      const scene = graphApi.getDependency('IScene');
+      return {
+        valueType: 'string',
+        choices: scene?.getLightNames()
+      };
+    }
+  },
+  out: {
+    flow: 'flow'
+  },
+  initialState: undefined,
+  triggered: ({ commit, read, graph }) => {
+    const scene = graph.getDependency('IScene');
+    scene?.removeLight(read<string>('name'));
+    commit('flow');
+  }
+});

package/src/Nodes/Actions/SetLightProperty.ts

@@ -0,0 +1,60 @@
+import {
+  makeFlowNodeDefinition,
+  NodeCategory
+} from '@kiberon-labs/behave-graph';
+
+const lightPropertyChoices = [
+  { text: 'color', value: 'color' },
+  { text: 'intensity', value: 'intensity' },
+  { text: 'position', value: 'position' }
+];
+
+export const SetLightProperty = makeFlowNodeDefinition({
+  typeName: 'scene/setLightProperty',
+  category: NodeCategory.Effect,
+  label: 'Set Light Property',
+  in: {
+    flow: 'flow',
+    name: (_, graphApi) => {
+      const scene = graphApi.getDependency('IScene');
+      return {
+        valueType: 'string',
+        choices: scene?.getLightNames()
+      };
+    },
+    property: (_) => ({
+      valueType: 'string',
+      choices: lightPropertyChoices
+    }),
+    floatValue: 'float',
+    colorValue: 'color',
+    vec3Value: 'vec3'
+  },
+  out: {
+    flow: 'flow'
+  },
+  initialState: undefined,
+  triggered: ({ commit, read, graph }) => {
+    const scene = graph.getDependency('IScene');
+    const name = read<string>('name');
+    const property = read<string>('property');
+
+    let value: unknown;
+    switch (property) {
+      case 'intensity':
+        value = read<number>('floatValue');
+        break;
+      case 'color':
+        value = read('colorValue');
+        break;
+      case 'position':
+        value = read('vec3Value');
+        break;
+      default:
+        value = read<number>('floatValue');
+    }
+
+    scene?.setLightProperty(name, property, value);
+    commit('flow');
+  }
+});

package/src/Nodes/Actions/SetMaterialProperty.ts

@@ -0,0 +1,62 @@
+import {
+  makeFlowNodeDefinition,
+  NodeCategory
+} from '@kiberon-labs/behave-graph';
+
+const materialPropertyChoices = [
+  { text: 'color', value: 'color' },
+  { text: 'opacity', value: 'opacity' },
+  { text: 'visible', value: 'visible' },
+  { text: 'wireframe', value: 'wireframe' }
+];
+
+export const SetMaterialProperty = makeFlowNodeDefinition({
+  typeName: 'scene/setMaterialProperty',
+  category: NodeCategory.Effect,
+  label: 'Set Material Property',
+  in: {
+    flow: 'flow',
+    meshName: (_, graphApi) => {
+      const scene = graphApi.getDependency('IScene');
+      return {
+        valueType: 'string',
+        choices: scene?.getMeshNames()
+      };
+    },
+    property: (_) => ({
+      valueType: 'string',
+      choices: materialPropertyChoices
+    }),
+    floatValue: 'float',
+    booleanValue: 'boolean',
+    colorValue: 'color'
+  },
+  out: {
+    flow: 'flow'
+  },
+  initialState: undefined,
+  triggered: ({ commit, read, graph }) => {
+    const scene = graph.getDependency('IScene');
+    const meshName = read<string>('meshName');
+    const property = read<string>('property');
+
+    let value: unknown;
+    switch (property) {
+      case 'color':
+        value = read('colorValue');
+        break;
+      case 'opacity':
+        value = read<number>('floatValue');
+        break;
+      case 'visible':
+      case 'wireframe':
+        value = read<boolean>('booleanValue');
+        break;
+      default:
+        value = read<number>('floatValue');
+    }
+
+    scene?.setMaterialProperty(meshName, property, value);
+    commit('flow');
+  }
+});

package/src/Nodes/Actions/SetMeshPosition.ts

@@ -0,0 +1,37 @@
+import {
+  makeFlowNodeDefinition,
+  NodeCategory
+} from '@kiberon-labs/behave-graph';
+
+// Directly set a mesh's world position.
+export const SetMeshPosition = makeFlowNodeDefinition({
+  typeName: 'scene/setMeshPosition',
+  category: NodeCategory.Effect,
+  label: 'Set Mesh Position',
+  in: {
+    flow: 'flow',
+    meshName: (_, graphApi) => {
+      const scene = graphApi.getDependency('IScene');
+      return {
+        valueType: 'string',
+        choices: scene?.getMeshNames()
+      };
+    },
+    x: 'float',
+    y: 'float',
+    z: 'float'
+  },
+  out: {
+    flow: 'flow'
+  },
+  initialState: undefined,
+  triggered: ({ commit, read, graph }) => {
+    const scene = graph.getDependency('IScene');
+    scene?.setMeshPosition(read<string>('meshName'), {
+      x: read<number>('x'),
+      y: read<number>('y'),
+      z: read<number>('z')
+    });
+    commit('flow');
+  }
+});

package/src/Nodes/Actions/SetMeshVisible.ts

@@ -0,0 +1,31 @@
+import {
+  makeFlowNodeDefinition,
+  NodeCategory
+} from '@kiberon-labs/behave-graph';
+
+// Show or hide a mesh.
+export const SetMeshVisible = makeFlowNodeDefinition({
+  typeName: 'scene/setMeshVisible',
+  category: NodeCategory.Effect,
+  label: 'Set Mesh Visible',
+  in: {
+    flow: 'flow',
+    meshName: (_, graphApi) => {
+      const scene = graphApi.getDependency('IScene');
+      return {
+        valueType: 'string',
+        choices: scene?.getMeshNames()
+      };
+    },
+    visible: 'boolean'
+  },
+  out: {
+    flow: 'flow'
+  },
+  initialState: undefined,
+  triggered: ({ commit, read, graph }) => {
+    const scene = graph.getDependency('IScene');
+    scene?.setMeshVisible(read<string>('meshName'), read<boolean>('visible'));
+    commit('flow');
+  }
+});

package/src/Nodes/Actions/SetSceneProperty.ts

@@ -3,8 +3,6 @@ import {
   NodeCategory
 } from '@kiberon-labs/behave-graph';
 
-import type { IScene } from '../../Abstractions/IScene.js';
-
 export const SetSceneProperty = (valueTypeNames: string[]) =>
   valueTypeNames.map((valueTypeName) =>
     makeFlowNodeDefinition({
@@ -13,10 +11,10 @@ export const SetSceneProperty = (valueTypeNames: string[]) =>
       label: `Set Scene ${valueTypeName}`,
       in: {
         jsonPath: (_, graphApi) => {
-          const scene = graphApi.getDependency<IScene>('IScene');
+          const scene = graphApi.getDependency('IScene');
           return {
             valueType: 'string',
-            choices: scene?.getProperties()
+            choices: scene?.getProperties(valueTypeName)
           };
         },
         value: valueTypeName,
@@ -27,7 +25,7 @@ export const SetSceneProperty = (valueTypeNames: string[]) =>
       },
       initialState: undefined,
       triggered: ({ commit, read, graph }) => {
-        const scene = graph.getDependency<IScene>('IScene');
+        const scene = graph.getDependency('IScene');
         scene?.setProperty(read('jsonPath'), valueTypeName, read('value'));
         commit('flow');
       }

package/src/Nodes/Events/OnAnyMeshClicked.ts

@@ -0,0 +1,48 @@
+import {
+  makeEventNodeDefinition,
+  NodeCategory
+} from '@kiberon-labs/behave-graph';
+
+type State = {
+  handleMeshClicked?: ((meshName: string) => void) | undefined;
+};
+
+const initialState = (): State => ({});
+
+// Fires whenever any mesh in the scene is clicked, outputting which mesh.
+export const OnAnyMeshClicked = makeEventNodeDefinition({
+  typeName: 'scene/onAnyMeshClicked',
+  category: NodeCategory.Event,
+  label: 'On Any Mesh Clicked',
+  in: {},
+  out: {
+    flow: 'flow',
+    meshName: 'string'
+  },
+  initialState: initialState(),
+  init: ({ commit, write, graph }) => {
+    const handleMeshClicked = (meshName: string) => {
+      write('meshName', meshName);
+      commit('flow');
+    };
+
+    const scene = graph.getDependency('IScene');
+    console.log('[OnAnyMeshClicked] init , scene dependency:', !!scene);
+
+    scene?.addOnAnyMeshClickedListener(handleMeshClicked);
+
+    const state: State = {
+      handleMeshClicked
+    };
+
+    return state;
+  },
+  dispose: ({ state: { handleMeshClicked }, graph: { getDependency } }) => {
+    if (!handleMeshClicked) return {};
+
+    const scene = getDependency('IScene');
+    scene?.removeOnAnyMeshClickedListener(handleMeshClicked);
+
+    return {};
+  }
+});

package/src/Nodes/Events/OnSceneChanged.ts

@@ -0,0 +1,43 @@
+import {
+  makeEventNodeDefinition,
+  NodeCategory
+} from '@kiberon-labs/behave-graph';
+
+type State = {
+  handleSceneChanged?: (() => void) | undefined;
+};
+
+const initialState = (): State => ({});
+
+export const OnSceneChanged = makeEventNodeDefinition({
+  typeName: 'scene/onSceneChanged',
+  category: NodeCategory.Event,
+  label: 'On Scene Changed',
+  in: {},
+  out: {
+    flow: 'flow'
+  },
+  initialState: initialState(),
+  init: ({ commit, graph }) => {
+    const handleSceneChanged = () => {
+      commit('flow');
+    };
+
+    const scene = graph.getDependency('IScene');
+    scene?.addOnSceneChangedListener(handleSceneChanged);
+
+    const state: State = {
+      handleSceneChanged
+    };
+
+    return state;
+  },
+  dispose: ({ state: { handleSceneChanged }, graph: { getDependency } }) => {
+    if (!handleSceneChanged) return {};
+
+    const scene = getDependency('IScene');
+    scene?.removeOnSceneChangedListener(handleSceneChanged);
+
+    return {};
+  }
+});

package/src/Nodes/Events/OnSceneNodeClick.ts

@@ -20,7 +20,7 @@ export const OnSceneNodeClick = makeEventNodeDefinition({
   label: 'On Scene Node Click',
   in: {
     jsonPath: (_, graphApi) => {
-      const scene = graphApi.getDependency<IScene>('IScene');
+      const scene = graphApi.getDependency('IScene');
 
       return {
         valueType: 'string',
@@ -39,7 +39,7 @@ export const OnSceneNodeClick = makeEventNodeDefinition({
 
     const jsonPath = read<string>('jsonPath');
 
-    const scene = graph.getDependency<IScene>('IScene');
+    const scene = graph.getDependency('IScene');
     scene?.addOnClickedListener(jsonPath, handleNodeClick);
 
     const state: State = {
@@ -58,7 +58,7 @@ export const OnSceneNodeClick = makeEventNodeDefinition({
 
     if (!jsonPath || !handleNodeClick) return {};
 
-    const scene = getDependency<IScene>('scene');
+    const scene = getDependency('IScene');
     scene?.removeOnClickedListener(jsonPath, handleNodeClick);
 
     return {};

package/src/Nodes/Logic/Mat3Nodes.ts

@@ -55,16 +55,6 @@ export const SetRow = makeInNOutFunctionDesc({
   exec: mat3SetRow3
 });
 
-export const Elements = makeInNOutFunctionDesc({
-  name: 'math/toVec3/mat3',
-  label: 'Mat3 To Vec3',
-  in: ['mat3'],
-  out: [{ x: 'vec3' }, { y: 'vec3' }, { z: 'vec3' }],
-  exec: (a: Mat3) => {
-    throw new Error('not implemented');
-  }
-});
-
 export const Add = makeInNOutFunctionDesc({
   name: 'math/add/mat3',
   label: '+',

package/src/Nodes/Logic/QuatNodes.ts

@@ -20,17 +20,17 @@ import {
   vec4ToArray
 } from '../../Values/Internal/Vec4.js';
 
-/*
-- from Angle Axis
-- from Euler
-- to Angle Axis
-- to Euler
-- Conjugate
-- Multiply
-- Slerp
-- Squad
-- Scale
-- 
+/*
+- from Angle Axis
+- from Euler
+- to Angle Axis
+- to Euler
+- Conjugate
+- Multiply
+- Slerp
+- Squad
+- Scale
+- 
 */
 
 export const Constant = makeInNOutFunctionDesc({

package/src/Nodes/Queries/GetDistanceBetween.ts

@@ -0,0 +1,37 @@
+import {
+  makeFunctionNodeDefinition,
+  NodeCategory
+} from '@kiberon-labs/behave-graph';
+
+// Compute the distance between two meshes.
+export const GetDistanceBetween = makeFunctionNodeDefinition({
+  typeName: 'scene/getDistanceBetween',
+  category: NodeCategory.Query,
+  label: 'Get Distance Between',
+  in: {
+    meshA: (_, graphApi) => {
+      const scene = graphApi.getDependency('IScene');
+      return {
+        valueType: 'string',
+        choices: scene?.getMeshNames()
+      };
+    },
+    meshB: (_, graphApi) => {
+      const scene = graphApi.getDependency('IScene');
+      return {
+        valueType: 'string',
+        choices: scene?.getMeshNames()
+      };
+    }
+  },
+  out: {
+    distance: 'float'
+  },
+  exec: ({ graph, read, write }) => {
+    const scene = graph.getDependency('IScene');
+    const distance =
+      scene?.getDistanceBetween(read<string>('meshA'), read<string>('meshB')) ??
+      0;
+    write('distance', distance);
+  }
+});