@auraindustry/aurajs 0.0.7 → 0.1.0

package/src/scene-composition/index.mjs

@@ -0,0 +1,326 @@
+import { createAvatarAnimationGraph } from '../authoring/avatar-animation-graph.mjs';
+import {
+  SCENE_COMPOSITION_RUNTIME_SCHEMA,
+  SCENE_COMPOSITION_SCHEMA,
+  buildSceneCompositionSnapshot,
+  composeWorldTransforms,
+  createNodeStateMap,
+  createTriggerRuntimeState,
+  evaluateTriggers,
+  mergeSceneCompositionConfig,
+  mountSceneNodes,
+  normalizeSceneCompositionConfig,
+  sanitizeSceneCompositionForSerialization,
+  syncRuntimeNodeTransform,
+} from './runtime.mjs';
+
+export {
+  SCENE_COMPOSITION_RUNTIME_SCHEMA,
+  SCENE_COMPOSITION_SCHEMA,
+  mergeSceneCompositionConfig,
+  normalizeSceneCompositionConfig,
+  sanitizeSceneCompositionForSerialization,
+} from './runtime.mjs';
+
+function isPlainObject(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function cloneValue(value) {
+  return value == null ? value : structuredClone(value);
+}
+
+export function createSceneComposition(aura, config = {}) {
+  const state = {
+    aura,
+    config: normalizeSceneCompositionConfig(config),
+    nodeMap: new Map(),
+    avatars: new Map(),
+    triggerState: new Map(),
+    mounted: false,
+    lastTriggerEvents: [],
+  };
+
+  rebuildRuntimeState(state);
+
+  const controller = {
+    aura,
+    mount() {
+      if (state.mounted) {
+        return controller.getState();
+      }
+      mountRuntime(state);
+      state.mounted = true;
+      return controller.getState();
+    },
+    configure(nextConfig = {}) {
+      state.config = mergeSceneCompositionConfig(state.config, nextConfig);
+      rebuildRuntimeState(state);
+      if (state.mounted) {
+        mountRuntime(state);
+      }
+      return controller.getState();
+    },
+    setNodeTransform(nodeId, transform = {}) {
+      const node = state.nodeMap.get(nodeId);
+      if (!node) {
+        throw new Error(`Unknown scene composition node "${nodeId}".`);
+      }
+      const source = isPlainObject(transform) ? transform : {};
+      node.local = {
+        position: source.position ? { ...node.local.position, ...cloneValue(source.position) } : node.local.position,
+        rotation: source.rotation ? { ...node.local.rotation, ...cloneValue(source.rotation) } : node.local.rotation,
+        scale: source.scale ? { ...node.local.scale, ...cloneValue(source.scale) } : node.local.scale,
+      };
+      syncRuntimeNodeTransform(state.aura, node);
+      composeWorldTransforms(state.nodeMap);
+      return cloneValue(node.world);
+    },
+    setAvatarInput(avatarId, input = {}) {
+      const avatar = state.avatars.get(avatarId);
+      if (!avatar || !avatar.controller || typeof avatar.controller.setInput !== 'function') {
+        return { ok: false, reasonCode: 'missing_avatar' };
+      }
+      avatar.definition.input = isPlainObject(input) ? cloneValue(input) : {};
+      avatar.controller.setInput(avatar.definition.input);
+      return { ok: true, avatarId };
+    },
+    getNodeWorldTransform(nodeId) {
+      const node = state.nodeMap.get(nodeId);
+      return node ? cloneValue(node.world) : null;
+    },
+    getAvatar(avatarId) {
+      const avatar = state.avatars.get(avatarId);
+      return avatar?.controller || null;
+    },
+    getTriggerState(triggerId) {
+      const trigger = state.triggerState.get(triggerId);
+      if (!trigger) return null;
+      return {
+        id: trigger.id,
+        activeWatcherIds: [...trigger.activeWatcherIds].sort((left, right) => left.localeCompare(right)),
+        enterCount: trigger.enterCount,
+        exitCount: trigger.exitCount,
+        lastEvent: trigger.lastEvent ? cloneValue(trigger.lastEvent) : null,
+      };
+    },
+    update(dtSeconds) {
+      if (!state.mounted) {
+        controller.mount();
+      }
+      const dt = Number(dtSeconds);
+      if (!Number.isFinite(dt) || dt <= 0) {
+        return { ok: false, reasonCode: 'invalid_dt' };
+      }
+      for (const avatar of state.avatars.values()) {
+        if (avatar.controller && typeof avatar.controller.tick === 'function') {
+          avatar.controller.tick(dt, avatar.definition.input);
+        }
+      }
+      composeWorldTransforms(state.nodeMap);
+      state.lastTriggerEvents = evaluateTriggers(
+        state.nodeMap,
+        state.avatars,
+        state.config.triggers,
+        state.triggerState,
+      );
+      return { ok: true, triggerEvents: cloneValue(state.lastTriggerEvents) };
+    },
+    draw() {
+      if (!state.mounted) {
+        controller.mount();
+      }
+      drawRuntime(state);
+      return controller.getState();
+    },
+    serialize() {
+      return cloneValue(state.config);
+    },
+    getState() {
+      return buildSceneCompositionSnapshot(state);
+    },
+  };
+
+  return controller;
+}
+
+export default createSceneComposition;
+
+function rebuildRuntimeState(state) {
+  state.nodeMap = createNodeStateMap(state.config.nodes);
+  composeWorldTransforms(state.nodeMap);
+  state.avatars = new Map(state.config.avatars.map((entry) => [entry.id, {
+    id: entry.id,
+    definition: cloneValue(entry),
+    controller: null,
+    spawned: false,
+  }]));
+  state.triggerState = new Map(state.config.triggers.map((entry) => [
+    entry.id,
+    createTriggerRuntimeState(entry),
+  ]));
+  state.lastTriggerEvents = [];
+}
+
+function mountRuntime(state) {
+  const { aura, config } = state;
+  configureRuntime(state);
+  if (aura?.scene3d) {
+    mountSceneNodes(aura, state.nodeMap);
+  }
+  for (const avatar of state.avatars.values()) {
+    avatar.controller = instantiateAvatarController(aura, avatar.definition, state.nodeMap);
+    if (avatar.definition.nodeId && avatar.controller?.configure && state.nodeMap.has(avatar.definition.nodeId)) {
+      const node = state.nodeMap.get(avatar.definition.nodeId);
+      const spawnPatch = { position: cloneValue(node.world.position) };
+      avatar.controller.configure({
+        ...(avatar.definition.graph || {}),
+        ...(avatar.definition.options || {}),
+        position: spawnPatch.position,
+      });
+    }
+    if (avatar.definition.autoSpawn !== false && avatar.controller?.spawn) {
+      avatar.controller.spawn(avatar.definition.spawn);
+      avatar.spawned = true;
+    }
+    if (avatar.controller?.setInput && Object.keys(avatar.definition.input).length > 0) {
+      avatar.controller.setInput(avatar.definition.input);
+    }
+  }
+}
+
+function configureRuntime(state) {
+  const { aura, config } = state;
+  const camera3d = aura?.camera3d;
+  if (camera3d) {
+    if (config.camera.mode === 'orthographic' && typeof camera3d.orthographic === 'function') {
+      camera3d.orthographic(config.camera.orthographicHeight, config.camera.near, config.camera.far);
+    } else if (typeof camera3d.perspective === 'function') {
+      camera3d.perspective(config.camera.fovDegrees, config.camera.near, config.camera.far);
+    }
+    if (typeof camera3d.setPosition === 'function') {
+      camera3d.setPosition(
+        config.camera.position.x,
+        config.camera.position.y,
+        config.camera.position.z,
+      );
+    }
+    if (typeof camera3d.lookAt === 'function') {
+      camera3d.lookAt(
+        config.camera.target.x,
+        config.camera.target.y,
+        config.camera.target.z,
+      );
+    }
+  }
+  const light = aura?.light;
+  if (light) {
+    if (typeof light.ambient === 'function') {
+      light.ambient(cloneValue(config.lights.ambient.color), config.lights.ambient.intensity);
+    }
+    if (typeof light.directional === 'function') {
+      for (const entry of config.lights.directional) {
+        light.directional(cloneValue(entry.direction), cloneValue(entry.color), entry.intensity);
+      }
+    }
+    if (typeof light.point === 'function') {
+      for (const entry of config.lights.point) {
+        light.point(cloneValue(entry.position), cloneValue(entry.color), entry.intensity, entry.range);
+      }
+    }
+    if (typeof light.spot === 'function') {
+      for (const entry of config.lights.spot) {
+        light.spot({
+          position: cloneValue(entry.position),
+          direction: cloneValue(entry.direction),
+          color: cloneValue(entry.color),
+          intensity: entry.intensity,
+          range: entry.range,
+          innerConeDegrees: entry.innerConeDegrees,
+          outerConeDegrees: entry.outerConeDegrees,
+        });
+      }
+    }
+  }
+}
+
+function instantiateAvatarController(aura, definition, nodeMap) {
+  if (definition.runtime) {
+    return definition.runtime;
+  }
+  if (typeof definition.factory === 'function') {
+    return definition.factory(aura, cloneValue(definition));
+  }
+  if (definition.graph) {
+    const graphConfig = cloneValue(definition.graph);
+    if (!graphConfig.position && definition.nodeId && nodeMap?.has(definition.nodeId)) {
+      graphConfig.position = cloneValue(nodeMap.get(definition.nodeId).world.position);
+    }
+    return createAvatarAnimationGraph(aura, graphConfig);
+  }
+  if (aura?.scene3d?.createAvatar) {
+    const avatarOptions = cloneValue(definition.options);
+    if (!avatarOptions.position && definition.nodeId && nodeMap?.has(definition.nodeId)) {
+      avatarOptions.position = cloneValue(nodeMap.get(definition.nodeId).world.position);
+    }
+    return aura.scene3d.createAvatar(avatarOptions);
+  }
+  return null;
+}
+
+function drawRuntime(state) {
+  const { aura, config } = state;
+  const draw3d = aura?.draw3d;
+  if (!draw3d) return;
+  if (config.clearColor && typeof draw3d.clear3d === 'function') {
+    draw3d.clear3d(cloneValue(config.clearColor));
+  }
+
+  for (const mesh of config.meshes) {
+    if (!mesh.visible || mesh.mesh == null || mesh.material == null || typeof draw3d.drawMesh !== 'function') {
+      continue;
+    }
+    const world = mesh.nodeId
+      ? state.nodeMap.get(mesh.nodeId)?.world
+      : null;
+    const transform = world
+      ? {
+        position: {
+          x: world.position.x + mesh.transform.position.x,
+          y: world.position.y + mesh.transform.position.y,
+          z: world.position.z + mesh.transform.position.z,
+        },
+        rotation: {
+          x: world.rotation.x + mesh.transform.rotation.x,
+          y: world.rotation.y + mesh.transform.rotation.y,
+          z: world.rotation.z + mesh.transform.rotation.z,
+        },
+        scale: {
+          x: world.scale.x * mesh.transform.scale.x,
+          y: world.scale.y * mesh.transform.scale.y,
+          z: world.scale.z * mesh.transform.scale.z,
+        },
+      }
+      : cloneValue(mesh.transform);
+    draw3d.drawMesh(mesh.mesh, mesh.material, transform);
+  }
+
+  for (const billboard of config.billboards) {
+    if (!billboard.visible || billboard.textureHandle == null || typeof draw3d.billboard !== 'function') {
+      continue;
+    }
+    const world = billboard.nodeId
+      ? state.nodeMap.get(billboard.nodeId)?.world
+      : null;
+    const position = world ? world.position : { x: 0, y: 0, z: 0 };
+    draw3d.billboard(billboard.textureHandle, {
+      x: position.x + billboard.offset.x,
+      y: position.y + billboard.offset.y,
+      z: position.z + billboard.offset.z,
+      width: billboard.width,
+      height: billboard.height,
+      mode: billboard.mode,
+      color: cloneValue(billboard.color),
+    });
+  }
+}