@vulfram/engine 0.5.6-alpha

package/src/engine/systems/command-intent.ts

@@ -0,0 +1,74 @@
+import { enqueueCommand } from '../bridge/dispatch';
+import type {
+  CameraComponent,
+  Component,
+  LightComponent,
+  ModelComponent,
+  System,
+} from '../ecs';
+
+export const CommandIntentSystem: System = (world, context) => {
+  const intentsToRemove: number[] = [];
+
+  for (let i = 0; i < world.pendingIntents.length; i++) {
+    const intent = world.pendingIntents[i];
+    if (!intent) continue;
+
+    if (intent.type === 'create-entity') {
+      world.entities.add(intent.entityId);
+      // Initialize default transform
+      let store = world.components.get(intent.entityId);
+      if (!store) {
+        store = new Map();
+        world.components.set(intent.entityId, store);
+      }
+      if (!store.has('Transform')) {
+        store.set('Transform', {
+          type: 'Transform',
+          position: [0, 0, 0],
+          rotation: [0, 0, 0, 1],
+          scale: [1, 1, 1],
+          layerMask: 0xffffffff,
+          visible: true,
+        });
+      }
+      intentsToRemove.push(i);
+    } else if (intent.type === 'remove-entity') {
+      const store = world.components.get(intent.entityId);
+      if (store) {
+        // Emit disposal commands for all components with IDs
+        for (const [type, comp] of store) {
+          if ('id' in comp) {
+            if (type === 'Model') {
+              const modelComp = comp as ModelComponent;
+              enqueueCommand(context.worldId, 'cmd-model-dispose', {
+                windowId: context.worldId,
+                modelId: modelComp.id,
+              });
+            } else if (type === 'Camera') {
+              const cameraComp = comp as CameraComponent;
+              enqueueCommand(context.worldId, 'cmd-camera-dispose', {
+                windowId: context.worldId,
+                cameraId: cameraComp.id,
+              });
+            } else if (type === 'Light') {
+              const lightComp = comp as LightComponent;
+              enqueueCommand(context.worldId, 'cmd-light-dispose', {
+                windowId: context.worldId,
+                lightId: lightComp.id,
+              });
+            }
+          }
+        }
+        world.components.delete(intent.entityId);
+      }
+      world.entities.delete(intent.entityId);
+      intentsToRemove.push(i);
+    }
+  }
+
+  for (let i = intentsToRemove.length - 1; i >= 0; i--) {
+    const idx = intentsToRemove[i];
+    if (idx !== undefined) world.pendingIntents.splice(idx, 1);
+  }
+};

package/src/engine/systems/core-command-builder.ts

@@ -0,0 +1,265 @@
+import { mat4, vec3 } from 'gl-matrix';
+import type { CameraKind, LightKind } from '../../types/kinds';
+import { enqueueCommand } from '../bridge/dispatch';
+import type {
+  CameraComponent,
+  Component,
+  LightComponent,
+  ModelComponent,
+  System,
+  TransformComponent,
+} from '../ecs';
+import { getEntityTransformMatrix, toQuat, toVec2, toVec3, toVec4 } from './utils';
+
+export const CoreCommandBuilderSystem: System = (world, context) => {
+  const intentsToRemove: number[] = [];
+
+  for (let i = 0; i < world.pendingIntents.length; i++) {
+    const intent = world.pendingIntents[i];
+    if (!intent) continue;
+
+    if (intent.type === 'attach-model') {
+      const modelId = world.nextCoreId++;
+      const transform = getEntityTransformMatrix(world, intent.entityId);
+      const castShadow = intent.props.castShadow ?? true;
+      const receiveShadow = intent.props.receiveShadow ?? true;
+
+      enqueueCommand(context.worldId, 'cmd-model-create', {
+        windowId: context.worldId,
+        modelId,
+        geometryId: intent.props.geometryId,
+        materialId: intent.props.materialId,
+        transform: Array.from(transform),
+        layerMask: 0x7fffffff,
+        castShadow,
+        receiveShadow,
+      });
+
+      let store = world.components.get(intent.entityId);
+      if (!store) {
+        store = new Map();
+        world.components.set(intent.entityId, store);
+      }
+      store.set('Model', {
+        type: 'Model',
+        id: modelId,
+        geometryId: intent.props.geometryId,
+        materialId: intent.props.materialId,
+        castShadow: intent.props.castShadow ?? true,
+        receiveShadow: intent.props.receiveShadow ?? true,
+        skipUpdate: true,
+      });
+
+      intentsToRemove.push(i);
+    } else if (intent.type === 'attach-camera') {
+      const cameraId = world.nextCoreId++;
+      const transform = getEntityTransformMatrix(world, intent.entityId);
+
+      enqueueCommand(context.worldId, 'cmd-camera-create', {
+        windowId: context.worldId,
+        cameraId,
+        label: `Cam ${cameraId}`,
+        kind: intent.props.kind ?? ('perspective' as CameraKind),
+        flags: 0,
+        nearFar: [intent.props.near ?? 0.1, intent.props.far ?? 1000],
+        order: intent.props.order ?? 0,
+        transform: Array.from(transform),
+        layerMask: 0x7fffffff,
+        orthoScale: 1.0,
+      });
+
+      let store = world.components.get(intent.entityId);
+      if (!store) {
+        store = new Map();
+        world.components.set(intent.entityId, store);
+      }
+      store.set('Camera', {
+        type: 'Camera',
+        id: cameraId,
+        kind: intent.props.kind ?? ('perspective' as CameraKind),
+        near: intent.props.near ?? 0.1,
+        far: intent.props.far ?? 1000,
+        order: intent.props.order ?? 0,
+        orthoScale: 1.0,
+        skipUpdate: true,
+      });
+
+      intentsToRemove.push(i);
+    } else if (intent.type === 'attach-light') {
+      const lightId = world.nextCoreId++;
+      const transform = getEntityTransformMatrix(world, intent.entityId);
+
+      const pos = vec3.create();
+      mat4.getTranslation(pos, transform);
+      const direction = intent.props.direction
+        ? toVec3(intent.props.direction)
+        : ([0, 0, -1] as [number, number, number]);
+      const color = intent.props.color
+        ? toVec3(intent.props.color)
+        : ([1, 1, 1] as [number, number, number]);
+
+      const lightCmd: {
+        windowId: number;
+        lightId: number;
+        kind: LightKind;
+        color: [number, number, number, number];
+        intensity: number;
+        range: number;
+        castShadow: boolean;
+        position: [number, number, number, number];
+        layerMask: number;
+        direction?: [number, number, number, number];
+        spotInnerOuter?: [number, number];
+      } = {
+        windowId: context.worldId,
+        lightId,
+        kind: intent.props.kind ?? ('directional' as LightKind),
+        color: [...color, 1] as [number, number, number, number],
+        intensity: intent.props.intensity ?? 1.0,
+        range: intent.props.range ?? 10.0,
+        castShadow: intent.props.castShadow ?? true,
+        position: [pos[0], pos[1], pos[2], 1],
+        layerMask: 0x7fffffff,
+      };
+      if (direction) {
+        const [dirX, dirY, dirZ] = direction;
+        lightCmd.direction = [dirX, dirY, dirZ, 0];
+      }
+      if (intent.props.spotInnerOuter) {
+        lightCmd.spotInnerOuter = toVec2(intent.props.spotInnerOuter);
+      }
+      enqueueCommand(context.worldId, 'cmd-light-create', lightCmd);
+
+      let store = world.components.get(intent.entityId);
+      if (!store) {
+        store = new Map();
+        world.components.set(intent.entityId, store);
+      }
+      store.set('Light', {
+        type: 'Light',
+        id: lightId,
+        kind: intent.props.kind ?? ('directional' as LightKind),
+        color,
+        intensity: intent.props.intensity ?? 1.0,
+        range: intent.props.range ?? 10.0,
+        castShadow: intent.props.castShadow ?? true,
+        direction,
+        spotInnerOuter: intent.props.spotInnerOuter
+          ? toVec2(intent.props.spotInnerOuter)
+          : [0.2, 0.6],
+        skipUpdate: true,
+      });
+
+      intentsToRemove.push(i);
+    } else if (intent.type === 'update-transform') {
+      const store = world.components.get(intent.entityId);
+      if (store) {
+        const transform = store.get('Transform') as
+          | TransformComponent
+          | undefined;
+        if (transform) {
+          const nextProps = { ...intent.props };
+          if (nextProps.position) {
+            nextProps.position = toVec3(nextProps.position);
+          }
+          if (nextProps.rotation) {
+            nextProps.rotation = toQuat(nextProps.rotation);
+          }
+          if (nextProps.scale) {
+            nextProps.scale = toVec3(nextProps.scale);
+          }
+          Object.assign(transform, nextProps);
+          const matrix = getEntityTransformMatrix(world, intent.entityId);
+          const matrixArray = Array.from(matrix);
+
+          const model = store.get('Model') as ModelComponent | undefined;
+          if (model) {
+            if (model.skipUpdate) {
+              model.skipUpdate = false;
+            } else {
+              enqueueCommand(context.worldId, 'cmd-model-update', {
+                windowId: context.worldId,
+                modelId: model.id,
+                transform: matrixArray,
+              });
+            }
+          }
+          const camera = store.get('Camera') as CameraComponent | undefined;
+          if (camera) {
+            if (camera.skipUpdate) {
+              camera.skipUpdate = false;
+            } else {
+              enqueueCommand(context.worldId, 'cmd-camera-update', {
+                windowId: context.worldId,
+                cameraId: camera.id,
+                transform: matrixArray,
+              });
+            }
+          }
+          const light = store.get('Light') as LightComponent | undefined;
+          if (light) {
+            if (light.skipUpdate) {
+              light.skipUpdate = false;
+            } else {
+              const pos = vec3.create();
+              mat4.getTranslation(pos, matrix);
+              enqueueCommand(context.worldId, 'cmd-light-update', {
+                windowId: context.worldId,
+                lightId: light.id,
+                position: [pos[0], pos[1], pos[2], 1],
+              });
+            }
+          }
+        }
+      }
+      intentsToRemove.push(i);
+    } else if (intent.type === 'detach-component') {
+      const store = world.components.get(intent.entityId);
+      if (store) {
+        const comp = store.get(intent.componentType) as Component | undefined;
+        if (comp && 'id' in comp) {
+          if (intent.componentType === 'Model') {
+            const modelComp = comp as ModelComponent;
+            enqueueCommand(context.worldId, 'cmd-model-dispose', {
+              windowId: context.worldId,
+              modelId: modelComp.id,
+            });
+          } else if (intent.componentType === 'Camera') {
+            const cameraComp = comp as CameraComponent;
+            enqueueCommand(context.worldId, 'cmd-camera-dispose', {
+              windowId: context.worldId,
+              cameraId: cameraComp.id,
+            });
+          } else if (intent.componentType === 'Light') {
+            const lightComp = comp as LightComponent;
+            enqueueCommand(context.worldId, 'cmd-light-dispose', {
+              windowId: context.worldId,
+              lightId: lightComp.id,
+            });
+          }
+        }
+        store.delete(intent.componentType);
+      }
+      intentsToRemove.push(i);
+    } else if (intent.type === 'gizmo-draw-line') {
+      enqueueCommand(context.worldId, 'cmd-gizmo-draw-line', {
+        start: toVec3(intent.start),
+        end: toVec3(intent.end),
+        color: toVec4(intent.color),
+      });
+      intentsToRemove.push(i);
+    } else if (intent.type === 'gizmo-draw-aabb') {
+      enqueueCommand(context.worldId, 'cmd-gizmo-draw-aabb', {
+        min: toVec3(intent.min),
+        max: toVec3(intent.max),
+        color: toVec4(intent.color),
+      });
+      intentsToRemove.push(i);
+    }
+  }
+
+  for (let i = intentsToRemove.length - 1; i >= 0; i--) {
+    const idx = intentsToRemove[i];
+    if (idx !== undefined) world.pendingIntents.splice(idx, 1);
+  }
+};

package/src/engine/systems/diagnostics.ts

@@ -0,0 +1,42 @@
+import type { EngineCmd } from '../../types/cmds';
+import { enqueueCommand } from '../bridge/dispatch';
+import type { System } from '../ecs';
+
+export const DiagnosticsSystem: System = (world, context) => {
+  const intentsToRemove: number[] = [];
+
+  for (let i = 0; i < world.pendingIntents.length; i++) {
+    const intent = world.pendingIntents[i];
+    if (intent?.type === 'request-resource-list') {
+      const type = intent.resourceType;
+      const cmdType = `cmd-${type}-list` as EngineCmd['type'];
+      enqueueCommand(context.worldId, cmdType, {
+        windowId: context.worldId,
+      });
+      intentsToRemove.push(i);
+    }
+  }
+
+  for (let i = intentsToRemove.length - 1; i >= 0; i--) {
+    const idx = intentsToRemove[i];
+    if (idx !== undefined) world.pendingIntents.splice(idx, 1);
+  }
+
+  // Simple diagnostic log every 600 frames
+  if (world.entities.size > 0 && world.nextCoreId > 2) {
+    // We only log if there is something interesting
+    const globalCounters = globalThis as unknown as Record<string, number>;
+    const frame = globalCounters.vulframFrameCount || 0;
+    globalCounters.vulframFrameCount = frame + 1;
+
+    if (frame % 600 === 0) {
+      console.debug(
+        `[Diagnostics] World ${context.worldId} | Entities: ${
+          world.entities.size
+        } | Intents: ${world.pendingIntents.length} | Core objects: ${
+          world.nextCoreId - 2
+        }`,
+      );
+    }
+  }
+};

package/src/engine/systems/index.ts

@@ -0,0 +1,7 @@
+export { InputMirrorSystem } from './input-mirror';
+export { CommandIntentSystem } from './command-intent';
+export { CoreCommandBuilderSystem } from './core-command-builder';
+export { ResourceUploadSystem } from './resource-upload';
+export { ResponseDecodeSystem } from './response-decode';
+export { WorldLifecycleSystem } from './world-lifecycle';
+export { DiagnosticsSystem } from './diagnostics';

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

@@ -0,0 +1,152 @@
+import type { KeyboardEvent } from '../../types/events/keyboard';
+import type { PointerEvent } from '../../types/events/pointer';
+import type { WindowEvent } from '../../types/events/window';
+import type {
+  InputStateComponent,
+  System,
+  WindowStateComponent,
+} from '../ecs';
+
+/**
+ * InputMirrorSystem: Processes input events and updates InputState component
+ */
+export const InputMirrorSystem: System = (world) => {
+  // Ensure InputState component exists for the world
+  let inputState: InputStateComponent | undefined;
+  let windowState: WindowStateComponent | undefined;
+
+  // Find or create InputState (attached to a special entity ID 0)
+  const WORLD_ENTITY_ID = 0;
+  let worldStore = world.components.get(WORLD_ENTITY_ID);
+  if (!worldStore) {
+    worldStore = new Map();
+    world.components.set(WORLD_ENTITY_ID, worldStore);
+    world.entities.add(WORLD_ENTITY_ID);
+  }
+
+  inputState = worldStore.get('InputState') as InputStateComponent;
+  if (!inputState) {
+    inputState = {
+      type: 'InputState',
+      keysPressed: new Set(),
+      keysJustPressed: new Set(),
+      keysJustReleased: new Set(),
+      mouseButtons: new Set(),
+      mousePosition: [0, 0],
+      mouseJustPressed: new Set(),
+      mouseJustReleased: new Set(),
+      mouseDelta: [0, 0],
+      scrollDelta: [0, 0],
+    };
+    worldStore.set('InputState', inputState);
+  }
+
+  windowState = worldStore.get('WindowState') as WindowStateComponent;
+  if (!windowState) {
+    windowState = {
+      type: 'WindowState',
+      focused: true,
+      size: [800, 600],
+      position: [0, 0],
+      scaleFactor: 1.0,
+      closeRequested: false,
+      resizedThisFrame: false,
+      movedThisFrame: false,
+      focusChangedThisFrame: false,
+    };
+    worldStore.set('WindowState', windowState);
+  }
+
+  // Clear "just pressed/released" from previous frame
+  inputState.keysJustPressed.clear();
+  inputState.keysJustReleased.clear();
+  inputState.mouseJustPressed.clear();
+  inputState.mouseJustReleased.clear();
+  inputState.mouseDelta = [0, 0];
+  inputState.scrollDelta = [0, 0];
+  windowState.resizedThisFrame = false;
+  windowState.movedThisFrame = false;
+  windowState.focusChangedThisFrame = false;
+  windowState.closeRequested = false;
+
+  // Process inbound events
+  while (world.inboundEvents.length > 0) {
+    const event = world.inboundEvents.shift();
+    if (!event) continue;
+
+    // Keyboard events
+    if (event.type === 'keyboard') {
+      const kbEvent = event.content as KeyboardEvent;
+      if (kbEvent.event === 'on-input') {
+        const keyCode = kbEvent.data.keyCode;
+        const pressed = kbEvent.data.state === 'pressed';
+
+        if (pressed) {
+          if (!inputState.keysPressed.has(keyCode)) {
+            inputState.keysJustPressed.add(keyCode);
+          }
+          inputState.keysPressed.add(keyCode);
+        } else {
+          inputState.keysPressed.delete(keyCode);
+          inputState.keysJustReleased.add(keyCode);
+        }
+      }
+    }
+
+    // Pointer events
+    else if (event.type === 'pointer') {
+      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;
+      } 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);
+          }
+          inputState.mouseButtons.add(button);
+        } else {
+          inputState.mouseButtons.delete(button);
+          inputState.mouseJustReleased.add(button);
+        }
+        inputState.mousePosition = ptrEvent.data.position;
+      } else if (ptrEvent.event === 'on-scroll') {
+        const delta = ptrEvent.data.delta;
+        if (delta.type === 'line') {
+          inputState.scrollDelta = delta.value;
+        } else if (delta.type === 'pixel') {
+          // Convert pixel to approximate line delta (rough estimate)
+          inputState.scrollDelta = [delta.value[0] / 20, delta.value[1] / 20];
+        }
+      }
+    }
+
+    // Window events
+    else if (event.type === 'window') {
+      const winEvent = event.content as WindowEvent;
+
+      if (winEvent.event === 'on-close-request') {
+        windowState.closeRequested = true;
+      } else if (winEvent.event === 'on-focus') {
+        if (windowState.focused !== winEvent.data.focused) {
+          windowState.focusChangedThisFrame = true;
+        }
+        windowState.focused = winEvent.data.focused;
+      } else if (winEvent.event === 'on-resize') {
+        windowState.size = [winEvent.data.width, winEvent.data.height];
+        windowState.resizedThisFrame = true;
+      } else if (winEvent.event === 'on-move') {
+        windowState.position = winEvent.data.position;
+        windowState.movedThisFrame = true;
+      } else if (winEvent.event === 'on-scale-factor-change') {
+        windowState.scaleFactor = winEvent.data.scaleFactor;
+      }
+    }
+  }
+};

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

@@ -0,0 +1,143 @@
+import type { TextureCreateMode } from '../../types/kinds';
+import { enqueueCommand } from '../bridge/dispatch';
+import type { System } from '../ecs';
+import { normalizeMaterialOptions, normalizePrimitiveOptions } from './utils';
+
+export const ResourceUploadSystem: System = (world, context) => {
+  const intentsToRemove: number[] = [];
+
+  for (let i = 0; i < world.pendingIntents.length; i++) {
+    const intent = world.pendingIntents[i];
+    if (!intent) continue;
+
+    if (intent.type === 'create-material') {
+      const options = normalizeMaterialOptions(intent.props.options) || {
+        type: 'standard',
+        content: {
+          baseColor: [1, 1, 1, 1],
+          surfaceType: 'opaque',
+          flags: 0,
+        },
+      };
+
+      enqueueCommand(context.worldId, 'cmd-material-create', {
+        windowId: context.worldId,
+        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);
+
+        enqueueCommand(context.worldId, 'cmd-primitive-geometry-create', {
+          windowId: context.worldId,
+          geometryId: intent.resourceId,
+          label: intent.props.label || `Geo ${intent.resourceId}`,
+          shape: shape,
+          options: options,
+        });
+      } else {
+        enqueueCommand(context.worldId, 'cmd-geometry-create', {
+          windowId: context.worldId,
+          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,
+          textureId: intent.resourceId,
+          label: intent.props.label || `Tex ${intent.resourceId}`,
+          color: Array.from(intent.props.source.color) as [
+            number,
+            number,
+            number,
+            number,
+          ],
+          srgb: intent.props.srgb ?? true,
+        });
+      } else {
+        const cmd: {
+          windowId: number;
+          textureId: number;
+          label: string;
+          bufferId: number;
+          srgb: boolean;
+          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,
+          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-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);
+  }
+};