@vulfram/engine 0.14.8-alpha → 0.19.2-alpha

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

@@ -1,19 +1,110 @@
 import type { KeyboardEvent } from '../../types/events/keyboard';
 import type { PointerEvent } from '../../types/events/pointer';
+import type { GamepadEvent } from '../../types/events/gamepad';
+import type { SystemEvent } from '../../types/events/system';
+import type { UiEvent } from '../../types/events/ui';
 import type { WindowEvent } from '../../types/events/window';
 import type {
+  GamepadStateComponent,
   InputStateComponent,
+  SystemEventStateComponent,
   System,
+  UiEventStateComponent,
   WindowStateComponent,
 } from '../ecs';
 
 /**
- * InputMirrorSystem: Processes input events and updates InputState component
+ * Mirrors inbound core events into world-level ECS state components.
+ *
+ * This system owns runtime input snapshots for keyboard, pointer, window,
+ * gamepad, system, and UI event streams.
  */
 export const InputMirrorSystem: System = (world) => {
+  const resolveWindowSize = (data: {
+    windowWidth?: number;
+    windowHeight?: number;
+  }): [number, number] | undefined => {
+    if (
+      typeof data.windowWidth === 'number' &&
+      typeof data.windowHeight === 'number'
+    ) {
+      return [data.windowWidth, data.windowHeight];
+    }
+    return undefined;
+  };
+
+  const resolveTargetSize = (data: {
+    targetWidth?: number;
+    targetHeight?: number;
+  }): [number, number] | undefined => {
+    if (
+      typeof data.targetWidth === 'number' &&
+      typeof data.targetHeight === 'number'
+    ) {
+      return [data.targetWidth, data.targetHeight];
+    }
+    return undefined;
+  };
+
+  const applyPointerPosition = (
+    inputState: InputStateComponent,
+    globalPosition: [number, number],
+    targetPosition?: [number, number],
+    targetId?: number,
+    targetUv?: [number, number],
+    windowSize?: [number, number],
+    targetSize?: [number, number],
+  ): void => {
+    const oldGlobalPosition = inputState.pointerPosition;
+    inputState.pointerDelta = [
+      globalPosition[0] - oldGlobalPosition[0],
+      globalPosition[1] - oldGlobalPosition[1],
+    ];
+    inputState.pointerPosition = globalPosition;
+    inputState.pointerWindowSize = windowSize;
+
+    if (targetPosition) {
+      const previousTargetId = inputState.pointerTargetId;
+      const previousTargetPosition = inputState.pointerPositionTarget;
+      if (
+        previousTargetId === targetId &&
+        previousTargetPosition !== undefined
+      ) {
+        inputState.pointerTargetDelta = [
+          targetPosition[0] - previousTargetPosition[0],
+          targetPosition[1] - previousTargetPosition[1],
+        ];
+      } else {
+        inputState.pointerTargetDelta = [0, 0];
+      }
+      inputState.pointerPositionTarget = targetPosition;
+      inputState.pointerTargetId = targetId;
+      inputState.pointerTargetSize = targetSize;
+      inputState.pointerTargetUv = targetUv;
+      return;
+    }
+
+    inputState.pointerPositionTarget = undefined;
+    inputState.pointerTargetDelta = undefined;
+    inputState.pointerTargetId = undefined;
+    inputState.pointerTargetSize = undefined;
+    inputState.pointerTargetUv = undefined;
+  };
+
+  const clearPointerTargetState = (inputState: InputStateComponent): void => {
+    inputState.pointerPositionTarget = undefined;
+    inputState.pointerTargetDelta = undefined;
+    inputState.pointerTargetId = undefined;
+    inputState.pointerTargetSize = undefined;
+    inputState.pointerTargetUv = undefined;
+  };
+
   // Ensure InputState component exists for the world
   let inputState: InputStateComponent | undefined;
   let windowState: WindowStateComponent | undefined;
+  let gamepadState: GamepadStateComponent | undefined;
+  let systemEventState: SystemEventStateComponent | undefined;
+  let uiEventState: UiEventStateComponent | undefined;
 
   // Find or create InputState (attached to a special entity ID 0)
   const WORLD_ENTITY_ID = 0;
@@ -31,12 +122,15 @@ export const InputMirrorSystem: System = (world) => {
       keysPressed: new Set(),
       keysJustPressed: new Set(),
       keysJustReleased: new Set(),
-      mouseButtons: new Set(),
-      mousePosition: [0, 0],
-      mouseJustPressed: new Set(),
-      mouseJustReleased: new Set(),
-      mouseDelta: [0, 0],
+      pointerButtons: new Set(),
+      pointerPosition: [0, 0],
+      pointerDelta: [0, 0],
+      pointerJustPressed: new Set(),
+      pointerJustReleased: new Set(),
+      pointerWindowSize: undefined,
+      pointerTargetSize: undefined,
       scrollDelta: [0, 0],
+      imeEnabled: false,
     };
     worldStore.set('InputState', inputState);
   }
@@ -57,21 +151,60 @@ export const InputMirrorSystem: System = (world) => {
     worldStore.set('WindowState', windowState);
   }
 
+  gamepadState = worldStore.get('GamepadState') as GamepadStateComponent;
+  if (!gamepadState) {
+    gamepadState = {
+      type: 'GamepadState',
+      connected: new Map(),
+      buttons: new Map(),
+      axes: new Map(),
+      eventsThisFrame: [],
+    };
+    worldStore.set('GamepadState', gamepadState);
+  }
+
+  systemEventState = worldStore.get(
+    'SystemEventState',
+  ) as SystemEventStateComponent;
+  if (!systemEventState) {
+    systemEventState = {
+      type: 'SystemEventState',
+      eventsThisFrame: [],
+    };
+    worldStore.set('SystemEventState', systemEventState);
+  }
+
+  uiEventState = worldStore.get('UiEventState') as UiEventStateComponent;
+  if (!uiEventState) {
+    uiEventState = {
+      type: 'UiEventState',
+      eventsThisFrame: [],
+    };
+    worldStore.set('UiEventState', uiEventState);
+  }
+
   // Clear "just pressed/released" from previous frame
   inputState.keysJustPressed.clear();
   inputState.keysJustReleased.clear();
-  inputState.mouseJustPressed.clear();
-  inputState.mouseJustReleased.clear();
-  inputState.mouseDelta = [0, 0];
+  inputState.pointerJustPressed.clear();
+  inputState.pointerJustReleased.clear();
+  inputState.pointerDelta = [0, 0];
+  inputState.pointerTargetDelta = inputState.pointerPositionTarget
+    ? [0, 0]
+    : undefined;
   inputState.scrollDelta = [0, 0];
+  inputState.imeCommitText = undefined;
   windowState.resizedThisFrame = false;
   windowState.movedThisFrame = false;
   windowState.focusChangedThisFrame = false;
   windowState.closeRequested = false;
+  gamepadState.eventsThisFrame.length = 0;
+  systemEventState.eventsThisFrame.length = 0;
+  uiEventState.eventsThisFrame.length = 0;
 
   // Process inbound events
-  while (world.inboundEvents.length > 0) {
-    const event = world.inboundEvents.shift();
+  for (let i = 0; i < world.inboundEvents.length; i++) {
+    const event = world.inboundEvents[i];
     if (!event) continue;
 
     // Keyboard events
@@ -90,6 +223,21 @@ export const InputMirrorSystem: System = (world) => {
           inputState.keysPressed.delete(keyCode);
           inputState.keysJustReleased.add(keyCode);
         }
+      } else if (kbEvent.event === 'on-ime-enable') {
+        inputState.imeEnabled = true;
+      } else if (kbEvent.event === 'on-ime-preedit') {
+        inputState.imeEnabled = true;
+        inputState.imePreeditText = kbEvent.data.text;
+        inputState.imeCursorRange = kbEvent.data.cursorRange;
+      } else if (kbEvent.event === 'on-ime-commit') {
+        inputState.imeEnabled = true;
+        inputState.imeCommitText = kbEvent.data.text;
+        inputState.imePreeditText = undefined;
+        inputState.imeCursorRange = undefined;
+      } else if (kbEvent.event === 'on-ime-disable') {
+        inputState.imeEnabled = false;
+        inputState.imePreeditText = undefined;
+        inputState.imeCursorRange = undefined;
       }
     }
 
@@ -98,25 +246,43 @@ export const InputMirrorSystem: System = (world) => {
       const ptrEvent = event.content as PointerEvent;
 
       if (ptrEvent.event === 'on-move') {
-        const oldPos = inputState.mousePosition;
-        const newPos = ptrEvent.data.position;
-        inputState.mouseDelta = [newPos[0] - oldPos[0], newPos[1] - oldPos[1]];
-        inputState.mousePosition = newPos;
+        inputState.pointerWindowId = ptrEvent.data.windowId;
+        applyPointerPosition(
+          inputState,
+          ptrEvent.data.position,
+          ptrEvent.data.positionTarget,
+          ptrEvent.data.trace?.targetId,
+          ptrEvent.data.trace?.uv,
+          resolveWindowSize(ptrEvent.data),
+          resolveTargetSize(ptrEvent.data),
+        );
       } else if (ptrEvent.event === 'on-button') {
         const button = ptrEvent.data.button;
         const pressed = ptrEvent.data.state === 'pressed';
 
         if (pressed) {
-          if (!inputState.mouseButtons.has(button)) {
-            inputState.mouseJustPressed.add(button);
+          if (!inputState.pointerButtons.has(button)) {
+            inputState.pointerJustPressed.add(button);
           }
-          inputState.mouseButtons.add(button);
+          inputState.pointerButtons.add(button);
         } else {
-          inputState.mouseButtons.delete(button);
-          inputState.mouseJustReleased.add(button);
+          inputState.pointerButtons.delete(button);
+          inputState.pointerJustReleased.add(button);
         }
-        inputState.mousePosition = ptrEvent.data.position;
+        inputState.pointerWindowId = ptrEvent.data.windowId;
+        applyPointerPosition(
+          inputState,
+          ptrEvent.data.position,
+          ptrEvent.data.positionTarget,
+          ptrEvent.data.trace?.targetId,
+          ptrEvent.data.trace?.uv,
+          resolveWindowSize(ptrEvent.data),
+          resolveTargetSize(ptrEvent.data),
+        );
       } else if (ptrEvent.event === 'on-scroll') {
+        inputState.pointerWindowId = ptrEvent.data.windowId;
+        inputState.pointerWindowSize = resolveWindowSize(ptrEvent.data);
+        inputState.pointerTargetSize = resolveTargetSize(ptrEvent.data);
         const delta = ptrEvent.data.delta;
         if (delta.type === 'line') {
           inputState.scrollDelta = delta.value;
@@ -124,6 +290,25 @@ export const InputMirrorSystem: System = (world) => {
           // Convert pixel to approximate line delta (rough estimate)
           inputState.scrollDelta = [delta.value[0] / 20, delta.value[1] / 20];
         }
+      } else if (ptrEvent.event === 'on-touch') {
+        inputState.pointerWindowId = ptrEvent.data.windowId;
+        applyPointerPosition(
+          inputState,
+          ptrEvent.data.position,
+          ptrEvent.data.positionTarget,
+          ptrEvent.data.trace?.targetId,
+          ptrEvent.data.trace?.uv,
+          resolveWindowSize(ptrEvent.data),
+          resolveTargetSize(ptrEvent.data),
+        );
+      } else if (ptrEvent.event === 'on-leave') {
+        inputState.pointerWindowId = ptrEvent.data.windowId;
+        inputState.pointerWindowSize = resolveWindowSize(ptrEvent.data);
+        clearPointerTargetState(inputState);
+      } else if (ptrEvent.event === 'on-enter') {
+        inputState.pointerWindowId = ptrEvent.data.windowId;
+        inputState.pointerWindowSize = resolveWindowSize(ptrEvent.data);
+        inputState.pointerTargetSize = resolveTargetSize(ptrEvent.data);
       }
     }
 
@@ -148,5 +333,56 @@ export const InputMirrorSystem: System = (world) => {
         windowState.scaleFactor = winEvent.data.scaleFactor;
       }
     }
+    // Gamepad events
+    else if (event.type === 'gamepad') {
+      const gpEvent = event.content as GamepadEvent;
+      gamepadState.eventsThisFrame.push(gpEvent);
+      if (gpEvent.event === 'on-connect') {
+        gamepadState.connected.set(gpEvent.data.gamepadId, {
+          name: gpEvent.data.name,
+        });
+      } else if (gpEvent.event === 'on-disconnect') {
+        gamepadState.connected.delete(gpEvent.data.gamepadId);
+        gamepadState.buttons.delete(gpEvent.data.gamepadId);
+        gamepadState.axes.delete(gpEvent.data.gamepadId);
+      } else if (gpEvent.event === 'on-button') {
+        const id = gpEvent.data.gamepadId;
+        let buttons = gamepadState.buttons.get(id);
+        if (!buttons) {
+          buttons = new Map();
+          gamepadState.buttons.set(id, buttons);
+        }
+        buttons.set(gpEvent.data.button, {
+          pressed: gpEvent.data.state === 'pressed',
+          value: gpEvent.data.value,
+        });
+      } else if (gpEvent.event === 'on-axis') {
+        const id = gpEvent.data.gamepadId;
+        let axes = gamepadState.axes.get(id);
+        if (!axes) {
+          axes = new Map();
+          gamepadState.axes.set(id, axes);
+        }
+        axes.set(gpEvent.data.axis, gpEvent.data.value);
+      }
+    }
+    // System events
+    else if (event.type === 'system') {
+      const sysEvent = event.content as SystemEvent;
+      systemEventState.eventsThisFrame.push(sysEvent);
+      if (sysEvent.event === 'error') {
+        systemEventState.lastError = {
+          scope: sysEvent.data.scope,
+          message: sysEvent.data.message,
+          commandId: sysEvent.data.commandId,
+          commandType: sysEvent.data.commandType,
+        };
+      }
+    }
+    // UI events
+    else if (event.type === 'ui') {
+      uiEventState.eventsThisFrame.push(event.content as UiEvent);
+    }
   }
+  world.inboundEvents.length = 0;
 };

package/src/engine/systems/resource-upload.ts

@@ -1,13 +1,95 @@
 import type { TextureCreateMode } from '../../types/kinds';
+import type {
+  PrimitiveOptions,
+} from '../../types/cmds/geometry';
 import { enqueueCommand } from '../bridge/dispatch';
-import type { System } from '../ecs';
+import type { GeometryProps, System } from '../ecs';
 import { normalizeMaterialOptions, normalizePrimitiveOptions } from './utils';
 
+const RESOURCE_INTENT_TYPES = [
+  'create-material',
+  'dispose-material',
+  'create-geometry',
+  'dispose-geometry',
+  'create-texture',
+  'dispose-texture',
+] as const;
+
+function buildPrimitiveOptions(
+  primitiveProps: Extract<GeometryProps, { type: 'primitive' }>,
+): PrimitiveOptions {
+  const { shape, options } = primitiveProps;
+  if (shape === 'cube') {
+    return {
+      type: 'cube',
+      content: {
+        size: options?.size ?? [1.0, 1.0, 1.0],
+        subdivisions: 1,
+      },
+    };
+  }
+  if (shape === 'plane') {
+    return {
+      type: 'plane',
+      content: {
+        size: options?.size ?? [1.0, 1.0, 1.0],
+        subdivisions: options?.subdivisions ?? 1,
+      },
+    };
+  }
+  if (shape === 'sphere') {
+    return {
+      type: 'sphere',
+      content: {
+        radius: options?.radius ?? 0.5,
+        sectors: options?.sectors ?? 32,
+        stacks: options?.stacks ?? 16,
+      },
+    };
+  }
+  if (shape === 'cylinder') {
+    return {
+      type: 'cylinder',
+      content: {
+        radius: options?.radius ?? 0.5,
+        height: options?.height ?? 1.0,
+        sectors: options?.sectors ?? options?.segments ?? 32,
+      },
+    };
+  }
+  if (shape === 'torus') {
+    return {
+      type: 'torus',
+      content: {
+        majorRadius: options?.majorRadius ?? 0.5,
+        minorRadius: options?.minorRadius ?? 0.25,
+        majorSegments: options?.majorSegments ?? options?.radialSegments ?? 32,
+        minorSegments: options?.minorSegments ?? options?.tubularSegments ?? 16,
+      },
+    };
+  }
+  return {
+    type: 'pyramid',
+    content: {
+      size: options?.size ?? [1.0, 1.0, 1.0],
+      subdivisions: options?.subdivisions ?? 1,
+    },
+  };
+}
+
+/**
+ * Processes resource intents and emits corresponding core resource commands.
+ *
+ * Covered resources:
+ * - material
+ * - geometry (custom and primitive)
+ * - texture (from buffer or solid color)
+ */
 export const ResourceUploadSystem: System = (world, context) => {
-  const intentsToRemove: number[] = [];
+  const intents = world.intentStore.takeMany(RESOURCE_INTENT_TYPES);
 
-  for (let i = 0; i < world.pendingIntents.length; i++) {
-    const intent = world.pendingIntents[i];
+  for (let i = 0; i < intents.length; i++) {
+    const intent = intents[i];
     if (!intent) continue;
 
     if (intent.type === 'create-material') {
@@ -20,78 +102,49 @@ export const ResourceUploadSystem: System = (world, context) => {
         },
       };
 
-      enqueueCommand(context.worldId, 'cmd-material-create', {
-        windowId: context.worldId,
+      enqueueCommand(context.worldId, 'cmd-material-upsert', {
         materialId: intent.resourceId,
         label: intent.props.label || `Mat ${intent.resourceId}`,
         kind: intent.props.kind ?? 'standard',
         options: options,
       });
-      intentsToRemove.push(i);
     } else if (intent.type === 'dispose-material') {
       enqueueCommand(context.worldId, 'cmd-material-dispose', {
-        windowId: context.worldId,
         materialId: intent.resourceId,
       });
-      intentsToRemove.push(i);
     } else if (intent.type === 'create-geometry') {
       if (intent.props.type === 'primitive') {
-        const shape = intent.props.shape ?? 'cube';
-        let content: any;
-
-        const shapeOptions = intent.props.options;
-        if (shapeOptions) {
-          content = shapeOptions;
-        } else {
-          if (shape === 'cube' || shape === 'plane' || shape === 'pyramid') {
-            content = { size: [1.0, 1.0, 1.0], subdivisions: 1 };
-          } else if (shape === 'sphere') {
-            content = { radius: 0.5, sectors: 32, stacks: 16 };
-          } else if (shape === 'torus') {
-            content = {
-              majorRadius: 0.5,
-              minorRadius: 0.25,
-              majorSegments: 32,
-              minorSegments: 16,
-            };
-          } else if (shape === 'cylinder') {
-            content = { radius: 0.5, height: 1.0, sectors: 32 };
-          } else {
-            content = { size: [1.0, 1.0, 1.0], subdivisions: 1 };
-          }
-        }
-
-        const options = normalizePrimitiveOptions({
-          type: shape,
-          content: content,
-        } as any);
+        const options = normalizePrimitiveOptions(
+          buildPrimitiveOptions(intent.props),
+        );
 
         enqueueCommand(context.worldId, 'cmd-primitive-geometry-create', {
-          windowId: context.worldId,
           geometryId: intent.resourceId,
           label: intent.props.label || `Geo ${intent.resourceId}`,
-          shape: shape,
+          shape: intent.props.shape,
           options: options,
         });
       } else {
-        enqueueCommand(context.worldId, 'cmd-geometry-create', {
-          windowId: context.worldId,
+        enqueueCommand(context.worldId, 'cmd-geometry-upsert', {
           geometryId: intent.resourceId,
           label: intent.props.label || `Geo ${intent.resourceId}`,
           entries: intent.props.entries,
         });
       }
-      intentsToRemove.push(i);
     } else if (intent.type === 'dispose-geometry') {
       enqueueCommand(context.worldId, 'cmd-geometry-dispose', {
-        windowId: context.worldId,
         geometryId: intent.resourceId,
       });
-      intentsToRemove.push(i);
     } else if (intent.type === 'create-texture') {
       if (intent.props.source.type === 'color') {
-        enqueueCommand(context.worldId, 'cmd-texture-create-solid-color', {
-          windowId: context.worldId,
+        const cmd: {
+          textureId: number;
+          label: string;
+          color: [number, number, number, number];
+          srgb: boolean;
+          mode?: TextureCreateMode;
+          atlasOptions?: { tilePx: number; layers: number };
+        } = {
           textureId: intent.resourceId,
           label: intent.props.label || `Tex ${intent.resourceId}`,
           color: Array.from(intent.props.source.color) as [
@@ -101,10 +154,16 @@ export const ResourceUploadSystem: System = (world, context) => {
             number,
           ],
           srgb: intent.props.srgb ?? true,
-        });
+        };
+        if (intent.props.mode !== undefined) {
+          cmd.mode = intent.props.mode;
+        }
+        if (intent.props.atlasOptions !== undefined) {
+          cmd.atlasOptions = intent.props.atlasOptions;
+        }
+        enqueueCommand(context.worldId, 'cmd-texture-create-solid-color', cmd);
       } else {
         const cmd: {
-          windowId: number;
           textureId: number;
           label: string;
           bufferId: number;
@@ -112,7 +171,6 @@ export const ResourceUploadSystem: System = (world, context) => {
           mode?: TextureCreateMode;
           atlasOptions?: { tilePx: number; layers: number };
         } = {
-          windowId: context.worldId,
           textureId: intent.resourceId,
           label: intent.props.label || `Tex ${intent.resourceId}`,
           bufferId: intent.props.source.bufferId,
@@ -126,18 +184,10 @@ export const ResourceUploadSystem: System = (world, context) => {
         }
         enqueueCommand(context.worldId, 'cmd-texture-create-from-buffer', cmd);
       }
-      intentsToRemove.push(i);
     } else if (intent.type === 'dispose-texture') {
       enqueueCommand(context.worldId, 'cmd-texture-dispose', {
-        windowId: context.worldId,
         textureId: intent.resourceId,
       });
-      intentsToRemove.push(i);
     }
   }
-
-  for (let i = intentsToRemove.length - 1; i >= 0; i--) {
-    const idx = intentsToRemove[i];
-    if (idx !== undefined) world.pendingIntents.splice(idx, 1);
-  }
 };