@vulfram/engine 0.19.2-alpha → 0.20.1-alpha

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vulfram/engine",
-  "version": "0.19.2-alpha",
+  "version": "0.20.1-alpha",
   "module": "src/index.ts",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -62,9 +62,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@vulfram/transport-types": "^0.2.6",
+    "@vulfram/transport-types": "^0.3.0",
     "gl-matrix": "^3.4.4",
-    "msgpackr": "^1.11.8"
+    "msgpackr": "^1.11.9"
   },
   "devDependencies": {
     "@types/bun": "^1.3.10",

package/src/engine/ecs/components.ts

@@ -5,9 +5,11 @@ import type { ForwardAtlasOptions } from '../../types/cmds/texture';
 import type { GamepadEvent, SystemEvent, UiEvent } from '../../types/events';
 import type {
   CameraKind,
+  CursorGrabMode,
   LightKind,
   MaterialKind,
   TextureCreateMode,
+  WindowState,
 } from '../../types/kinds';
 import type { JsonObject, JsonValue } from '../../types/json';
 
@@ -134,6 +136,12 @@ export interface WindowStateComponent {
   size: [number, number];
   position: [number, number];
   scaleFactor: number;
+  lifecycleState?: WindowState;
+  pointerCapture?: {
+    mode: CursorGrabMode;
+    active: boolean;
+    reason?: string;
+  };
   closeRequested: boolean;
   resizedThisFrame: boolean;
   movedThisFrame: boolean;

package/src/engine/systems/input-mirror.ts

@@ -143,6 +143,8 @@ export const InputMirrorSystem: System = (world) => {
       size: [800, 600],
       position: [0, 0],
       scaleFactor: 1.0,
+      lifecycleState: undefined,
+      pointerCapture: undefined,
       closeRequested: false,
       resizedThisFrame: false,
       movedThisFrame: false,
@@ -331,6 +333,14 @@ export const InputMirrorSystem: System = (world) => {
         windowState.movedThisFrame = true;
       } else if (winEvent.event === 'on-scale-factor-change') {
         windowState.scaleFactor = winEvent.data.scaleFactor;
+      } else if (winEvent.event === 'on-state-change') {
+        windowState.lifecycleState = winEvent.data.state;
+      } else if (winEvent.event === 'on-pointer-capture-change') {
+        windowState.pointerCapture = {
+          mode: winEvent.data.capture.mode,
+          active: winEvent.data.capture.active,
+          reason: winEvent.data.capture.reason,
+        };
       }
     }
     // Gamepad events

package/src/engine/world/entities/audio.ts

@@ -0,0 +1,193 @@
+import type {
+  CmdAudioListenerCreateArgs,
+  CmdAudioListenerDisposeArgs,
+  CmdAudioListenerUpsertArgs,
+  CmdAudioListenerUpdateArgs,
+  CmdAudioResourceUpsertArgs,
+  CmdAudioResourceDisposeArgs,
+  CmdAudioSourceTransportArgs,
+  CmdAudioSourceCreateArgs,
+  CmdAudioSourceDisposeArgs,
+  CmdAudioSourceUpsertArgs,
+  CmdAudioSourceUpdateArgs,
+  CmdAudioStateGetArgs,
+} from '../../../types/cmds/audio';
+import type { CmdPoseUpdateArgs } from '../../../types/cmds/model';
+import type { CmdTextureBindTargetArgs } from '../../../types/cmds/texture';
+import { enqueueCommand } from '../../bridge/dispatch';
+
+/**
+ * Sends an audio listener update command.
+ */
+export function audioListenerUpdate(
+  worldId: number,
+  args: CmdAudioListenerUpdateArgs,
+): number {
+  return enqueueCommand(worldId, 'cmd-audio-listener-upsert', args);
+}
+
+/**
+ * Binds a texture id to a texture target output.
+ */
+export function bindTextureToTarget(
+  worldId: number,
+  args: CmdTextureBindTargetArgs,
+): number {
+  return enqueueCommand(worldId, 'cmd-texture-bind-target', args);
+}
+
+/**
+ * Binds the audio listener to a model.
+ */
+export function audioListenerCreate(
+  worldId: number,
+  args: CmdAudioListenerCreateArgs,
+): number {
+  return enqueueCommand(worldId, 'cmd-audio-listener-upsert', args);
+}
+
+/**
+ * Upserts audio listener params or binding.
+ */
+export function audioListenerUpsert(
+  worldId: number,
+  args: CmdAudioListenerUpsertArgs,
+): number {
+  return enqueueCommand(worldId, 'cmd-audio-listener-upsert', args);
+}
+
+/**
+ * Disposes the audio listener binding.
+ */
+export function audioListenerDispose(
+  worldId: number,
+  args: CmdAudioListenerDisposeArgs,
+): number {
+  return enqueueCommand(worldId, 'cmd-audio-listener-dispose', args);
+}
+
+/**
+ * Creates an audio resource from an uploaded buffer.
+ */
+export function audioResourceCreate(
+  worldId: number,
+  args: CmdAudioResourceUpsertArgs,
+): number {
+  return enqueueCommand(worldId, 'cmd-audio-resource-upsert', args);
+}
+
+/**
+ * Pushes a chunk into a streaming audio resource.
+ */
+export function audioResourcePush(
+  worldId: number,
+  args: CmdAudioResourceUpsertArgs,
+): number {
+  return enqueueCommand(worldId, 'cmd-audio-resource-upsert', args);
+}
+
+/**
+ * Disposes an audio resource.
+ */
+export function audioResourceDispose(
+  worldId: number,
+  args: CmdAudioResourceDisposeArgs,
+): number {
+  return enqueueCommand(worldId, 'cmd-audio-resource-dispose', args);
+}
+
+/**
+ * Creates an audio source bound to a model.
+ */
+export function audioSourceCreate(
+  worldId: number,
+  args: CmdAudioSourceCreateArgs,
+): number {
+  return enqueueCommand(worldId, 'cmd-audio-source-upsert', args);
+}
+
+/**
+ * Updates an audio source.
+ */
+export function audioSourceUpdate(
+  worldId: number,
+  args: CmdAudioSourceUpdateArgs,
+): number {
+  return enqueueCommand(worldId, 'cmd-audio-source-upsert', args);
+}
+
+/**
+ * Upserts audio source params or binding.
+ */
+export function audioSourceUpsert(
+  worldId: number,
+  args: CmdAudioSourceUpsertArgs,
+): number {
+  return enqueueCommand(worldId, 'cmd-audio-source-upsert', args);
+}
+
+/**
+ * Starts playback for an audio source.
+ */
+export function audioSourcePlay(
+  worldId: number,
+  args: Omit<CmdAudioSourceTransportArgs, 'action'>,
+): number {
+  return enqueueCommand(worldId, 'cmd-audio-source-transport', {
+    ...args,
+    action: 'play',
+  });
+}
+
+/**
+ * Pauses playback for an audio source.
+ */
+export function audioSourcePause(
+  worldId: number,
+  args: Omit<CmdAudioSourceTransportArgs, 'action'>,
+): number {
+  return enqueueCommand(worldId, 'cmd-audio-source-transport', {
+    ...args,
+    action: 'pause',
+  });
+}
+
+/**
+ * Stops playback for an audio source.
+ */
+export function audioSourceStop(
+  worldId: number,
+  args: Omit<CmdAudioSourceTransportArgs, 'action'>,
+): number {
+  return enqueueCommand(worldId, 'cmd-audio-source-transport', {
+    ...args,
+    action: 'stop',
+  });
+}
+
+/**
+ * Requests a snapshot of audio runtime state.
+ */
+export function audioStateGet(
+  worldId: number,
+  args: CmdAudioStateGetArgs = {},
+): number {
+  return enqueueCommand(worldId, 'cmd-audio-state-get', args);
+}
+
+/**
+ * Disposes an audio source.
+ */
+export function audioSourceDispose(
+  worldId: number,
+  args: CmdAudioSourceDisposeArgs,
+): number {
+  return enqueueCommand(worldId, 'cmd-audio-source-dispose', args);
+}
+
+/**
+ * Updates a model pose (skinning) using an uploaded matrices buffer.
+ */
+export function poseUpdate(worldId: number, args: CmdPoseUpdateArgs): number {
+  return enqueueCommand(worldId, 'cmd-pose-update', args);
+}

package/src/engine/world/entities/common.ts

@@ -0,0 +1,30 @@
+import { getWorldOrThrow } from '../../bridge/guards';
+import { engineState } from '../../state';
+
+export const WORLD_ENTITY_ID = 0;
+
+export function allocateGlobalId(): number {
+  return engineState.nextGlobalId++;
+}
+
+export function recalculateWorldWindowBindings(
+  world: ReturnType<typeof getWorldOrThrow>,
+): void {
+  world.boundWindowIds.clear();
+  for (const windowId of world.targetWindowBindings.values()) {
+    world.boundWindowIds.add(windowId);
+  }
+
+  if (world.boundWindowIds.size === 0) {
+    world.primaryWindowId = undefined;
+    return;
+  }
+
+  let primary = Number.POSITIVE_INFINITY;
+  for (const windowId of world.boundWindowIds) {
+    if (windowId < primary) {
+      primary = windowId;
+    }
+  }
+  world.primaryWindowId = primary;
+}

package/src/engine/world/entities/intents.ts

@@ -0,0 +1,12 @@
+import { getWorldOrThrow, requireInitialized } from '../../bridge/guards';
+import type { Intent } from '../../ecs';
+
+/**
+ * Emits an intent to the specified world.
+ * Intents are processed by systems at the beginning of each tick.
+ */
+export function emitIntent(worldId: number, intent: Intent): void {
+  requireInitialized();
+  const world = getWorldOrThrow(worldId);
+  world.intentStore.enqueue(intent);
+}

package/src/engine/world/entities/resources.ts

@@ -0,0 +1,185 @@
+import type { ShadowConfig } from '../../../types/cmds/shadow';
+import type {
+  EnvironmentConfig,
+  CmdEnvironmentDisposeArgs,
+} from '../../../types/cmds/environment';
+import type {
+  CmdRealmRenderGraphBindArgs,
+  CmdRenderGraphDisposeArgs,
+  CmdRenderGraphListArgs,
+  CmdRenderGraphUpsertArgs,
+} from '../../../types/cmds/render-graph';
+import type { NotificationLevel } from '../../../types/kinds';
+import { EngineError } from '../../errors';
+import { enqueueCommand } from '../../bridge/dispatch';
+import { getWorldOrThrow } from '../../bridge/guards';
+import { emitIntent } from './intents';
+
+/**
+ * Requests a list of resources from the engine for debugging.
+ */
+export function requestResourceList(
+  worldId: number,
+  resourceType:
+    | 'model'
+    | 'material'
+    | 'texture'
+    | 'geometry'
+    | 'light'
+    | 'camera',
+): void {
+  emitIntent(worldId, {
+    type: 'request-resource-list',
+    resourceType,
+  });
+}
+
+function resolveWorldWindowId(worldId: number): number {
+  const world = getWorldOrThrow(worldId);
+  if (world.primaryWindowId === undefined) {
+    for (const windowId of world.targetWindowBindings.values()) {
+      return windowId;
+    }
+    throw new EngineError(
+      'WindowNotFound',
+      `World ${worldId} has no window binding available for this command.`,
+    );
+  }
+  return world.primaryWindowId;
+}
+
+/** Requests model list for a world window context. */
+export function listModels(worldId: number): number {
+  return enqueueCommand(worldId, 'cmd-model-list', {
+    windowId: resolveWorldWindowId(worldId),
+  });
+}
+
+/** Requests material list for a world window context. */
+export function listMaterials(worldId: number): number {
+  return enqueueCommand(worldId, 'cmd-material-list', {
+    windowId: resolveWorldWindowId(worldId),
+  });
+}
+
+/** Requests texture list for a world window context. */
+export function listTextures(worldId: number): number {
+  return enqueueCommand(worldId, 'cmd-texture-list', {
+    windowId: resolveWorldWindowId(worldId),
+  });
+}
+
+/** Requests geometry list for a world window context. */
+export function listGeometries(worldId: number): number {
+  return enqueueCommand(worldId, 'cmd-geometry-list', {
+    windowId: resolveWorldWindowId(worldId),
+  });
+}
+
+/** Requests light list for a world window context. */
+export function listLights(worldId: number): number {
+  return enqueueCommand(worldId, 'cmd-light-list', {
+    windowId: resolveWorldWindowId(worldId),
+  });
+}
+
+/** Requests camera list for a world window context. */
+export function listCameras(worldId: number): number {
+  return enqueueCommand(worldId, 'cmd-camera-list', {
+    windowId: resolveWorldWindowId(worldId),
+  });
+}
+
+/** Creates or updates a render graph in the core catalog. */
+export function upsertRenderGraph(
+  worldId: number,
+  args: CmdRenderGraphUpsertArgs,
+): number {
+  return enqueueCommand(worldId, 'cmd-render-graph-upsert', args);
+}
+
+/** Disposes a render graph from the core catalog. */
+export function disposeRenderGraph(
+  worldId: number,
+  args: CmdRenderGraphDisposeArgs,
+): number {
+  return enqueueCommand(worldId, 'cmd-render-graph-dispose', args);
+}
+
+/** Requests the current render graph catalog. */
+export function listRenderGraphs(
+  worldId: number,
+  args: CmdRenderGraphListArgs = {},
+): number {
+  return enqueueCommand(worldId, 'cmd-render-graph-list', args);
+}
+
+/** Binds a realm to a render graph id. */
+export function bindRealmRenderGraph(
+  worldId: number,
+  args: CmdRealmRenderGraphBindArgs,
+): number {
+  return enqueueCommand(worldId, 'cmd-realm-render-graph-bind', args);
+}
+
+/** Disposes a material. */
+export function disposeMaterial(worldId: number, resourceId: number): void {
+  emitIntent(worldId, { type: 'dispose-material', resourceId });
+}
+
+/** Disposes a texture. */
+export function disposeTexture(worldId: number, resourceId: number): void {
+  emitIntent(worldId, { type: 'dispose-texture', resourceId });
+}
+
+/** Disposes a geometry. */
+export function disposeGeometry(worldId: number, resourceId: number): void {
+  emitIntent(worldId, { type: 'dispose-geometry', resourceId });
+}
+
+/** Sends a system notification. */
+export function sendNotification(
+  worldId: number,
+  props: {
+    level: NotificationLevel;
+    title: string;
+    message: string;
+  },
+): void {
+  emitIntent(worldId, {
+    type: 'send-notification',
+    level: props.level,
+    title: props.title,
+    message: props.message,
+  });
+}
+
+/** Configures shadow settings for the world. */
+export function configureShadows(worldId: number, config: ShadowConfig): void {
+  emitIntent(worldId, {
+    type: 'configure-shadows',
+    config,
+  });
+}
+
+/** Configures environment settings for the world. */
+export function configureEnvironment(
+  worldId: number,
+  config: EnvironmentConfig,
+): void {
+  emitIntent(worldId, {
+    type: 'configure-environment',
+    config,
+  });
+}
+
+/**
+ * Disposes an environment profile.
+ * If omitted, defaults to this world id (engine convention).
+ */
+export function disposeEnvironment(
+  worldId: number,
+  args: CmdEnvironmentDisposeArgs = { environmentId: worldId },
+): number {
+  return enqueueCommand(worldId, 'cmd-environment-dispose', args);
+}