@vulfram/engine 0.5.6-alpha

package/src/engine/systems/response-decode.ts

@@ -0,0 +1,28 @@
+import type { System } from '../ecs';
+import { engineState } from '../state';
+
+export const ResponseDecodeSystem: System = (world, context) => {
+  while (world.inboundResponses.length > 0) {
+    const res = world.inboundResponses.shift()!;
+    const content = res.content as { success?: boolean; message?: string };
+
+    if (engineState.flags.debugEnabled) {
+      const debugKey = '__vulframDebugRespAllCount';
+      const count =
+        (globalThis as unknown as Record<string, number>)[debugKey] || 0;
+      if (count < 10) {
+        console.debug('[Debug] Response', res.type, JSON.stringify(content));
+        (globalThis as unknown as Record<string, number>)[debugKey] = count + 1;
+      }
+    }
+
+    if (content && typeof content.success === 'boolean' && !content.success) {
+      console.error(
+        `[World ${context.worldId}] Command ${res.type} (ID: ${res.id}) failed: ${content.message}`,
+      );
+    } else {
+      // DEBUG: Print all successes too for now
+      // console.debug(`[World ${context.worldId}] Command ${res.type} (ID: ${res.id}) succeeded.`);
+    }
+  }
+};

package/src/engine/systems/utils.ts

@@ -0,0 +1,147 @@
+import { mat4, quat, vec3 } from 'gl-matrix';
+import type { MaterialOptions, PbrOptions, StandardOptions } from '../../types/cmds/material';
+import type {
+  CubeOptions,
+  PlaneOptions,
+  PrimitiveOptions,
+  PyramidOptions,
+} from '../../types/cmds/geometry';
+import type { TransformComponent } from '../ecs';
+import type { WorldState } from '../state';
+
+export function toTuple(value: ArrayLike<number>, length: number): number[] {
+  const result = new Array<number>(length);
+  for (let i = 0; i < length; i++) {
+    result[i] = Number(value[i] ?? 0);
+  }
+  return result;
+}
+
+export function toVec2(value: ArrayLike<number>): [number, number] {
+  const result = toTuple(value, 2);
+  return [result[0] ?? 0, result[1] ?? 0];
+}
+
+export function toVec3(value: ArrayLike<number>): [number, number, number] {
+  const result = toTuple(value, 3);
+  return [result[0] ?? 0, result[1] ?? 0, result[2] ?? 0];
+}
+
+export function toVec4(value: ArrayLike<number>): [number, number, number, number] {
+  const result = toTuple(value, 4);
+  return [
+    result[0] ?? 0,
+    result[1] ?? 0,
+    result[2] ?? 0,
+    result[3] ?? 0,
+  ];
+}
+
+export function toQuat(value: ArrayLike<number>): [number, number, number, number] {
+  return toVec4(value);
+}
+
+export function normalizeStandardOptions(options: StandardOptions): StandardOptions {
+  const normalized: StandardOptions = {
+    ...options,
+    baseColor: toVec4(options.baseColor),
+    surfaceType: options.surfaceType,
+  };
+  if (options.specColor !== undefined) {
+    normalized.specColor = options.specColor ? toVec4(options.specColor) : null;
+  }
+  if (options.toonParams !== undefined) {
+    normalized.toonParams = options.toonParams ? toVec4(options.toonParams) : null;
+  }
+  return normalized;
+}
+
+export function normalizePbrOptions(options: PbrOptions): PbrOptions {
+  return {
+    ...options,
+    baseColor: toVec4(options.baseColor),
+    emissiveColor: toVec4(options.emissiveColor),
+  };
+}
+
+export function normalizeMaterialOptions(
+  options: MaterialOptions | undefined,
+): MaterialOptions | undefined {
+  if (!options) return options;
+  if (options.type === 'standard') {
+    return {
+      type: 'standard',
+      content: normalizeStandardOptions(options.content),
+    };
+  }
+  return {
+    type: 'pbr',
+    content: normalizePbrOptions(options.content),
+  };
+}
+
+export function normalizePrimitiveOptions(options: PrimitiveOptions): PrimitiveOptions {
+  if (options.type === 'cube') {
+    const content = options.content as CubeOptions;
+    return {
+      type: 'cube',
+      content: {
+        ...content,
+        size: content.size ? toVec3(content.size) : content.size,
+      },
+    };
+  }
+  if (options.type === 'plane') {
+    const content = options.content as PlaneOptions;
+    return {
+      type: 'plane',
+      content: {
+        ...content,
+        size: content.size ? toVec3(content.size) : content.size,
+      },
+    };
+  }
+  if (options.type === 'pyramid') {
+    const content = options.content as PyramidOptions;
+    return {
+      type: 'pyramid',
+      content: {
+        ...content,
+        size: content.size ? toVec3(content.size) : content.size,
+      },
+    };
+  }
+  return options;
+}
+
+export function getEntityTransformMatrix(
+  world: WorldState,
+  entityId: number,
+): mat4 {
+  const store = world.components.get(entityId);
+  if (!store) return mat4.create();
+
+  const transform = store.get('Transform') as TransformComponent | undefined;
+
+  const m = mat4.create();
+  if (transform) {
+    const rotation = quat.fromValues(
+      transform.rotation[0],
+      transform.rotation[1],
+      transform.rotation[2],
+      transform.rotation[3],
+    );
+    const position = vec3.fromValues(
+      transform.position[0],
+      transform.position[1],
+      transform.position[2],
+    );
+    const scale = vec3.fromValues(
+      transform.scale[0],
+      transform.scale[1],
+      transform.scale[2],
+    );
+    mat4.fromRotationTranslationScale(m, rotation, position, scale);
+  }
+  return m;
+}

package/src/engine/systems/world-lifecycle.ts

@@ -0,0 +1,164 @@
+import type { EnvironmentConfig } from '../../types/cmds/environment';
+import type { ShadowConfig } from '../../types/cmds/shadow';
+import type { WindowState } from '../../types/kinds';
+import { enqueueCommand } from '../bridge/dispatch';
+import type { System } from '../ecs';
+import { toVec2, toVec3 } from './utils';
+
+export const WorldLifecycleSystem: 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-window') {
+      const cmd = {
+        windowId: context.worldId,
+        title: intent.props.title,
+        size: toVec2(intent.props.size),
+        position: toVec2(intent.props.position),
+        borderless: intent.props.borderless ?? false,
+        resizable: intent.props.resizable ?? true,
+        transparent: intent.props.transparent ?? false,
+        initialState: intent.props.initialState ?? ('windowed' as WindowState),
+      } as const;
+      const payload: typeof cmd & { canvasId?: string } = { ...cmd };
+      if (intent.props.canvasId !== undefined) {
+        payload.canvasId = intent.props.canvasId;
+      }
+      enqueueCommand(context.worldId, 'cmd-window-create', payload);
+      intentsToRemove.push(i);
+    } else if (intent.type === 'close-window') {
+      enqueueCommand(context.worldId, 'cmd-window-close', {
+        windowId: context.worldId,
+      });
+      intentsToRemove.push(i);
+    } else if (intent.type === 'update-window') {
+      const p = intent.props;
+      if (p.title !== undefined) {
+        enqueueCommand(context.worldId, 'cmd-window-set-title', {
+          windowId: context.worldId,
+          title: p.title,
+        });
+      }
+      if (p.position !== undefined) {
+        enqueueCommand(context.worldId, 'cmd-window-set-position', {
+          windowId: context.worldId,
+          position: p.position,
+        });
+      }
+      if (p.size !== undefined) {
+        enqueueCommand(context.worldId, 'cmd-window-set-size', {
+          windowId: context.worldId,
+          size: p.size,
+        });
+      }
+      if (p.state !== undefined) {
+        enqueueCommand(context.worldId, 'cmd-window-set-state', {
+          windowId: context.worldId,
+          state: p.state,
+        });
+      }
+      if (p.resizable !== undefined) {
+        enqueueCommand(context.worldId, 'cmd-window-set-resizable', {
+          windowId: context.worldId,
+          resizable: p.resizable,
+        });
+      }
+      if (p.decorations !== undefined) {
+        enqueueCommand(context.worldId, 'cmd-window-set-decorations', {
+          windowId: context.worldId,
+          decorations: p.decorations,
+        });
+      }
+      if (p.cursorVisible !== undefined) {
+        enqueueCommand(context.worldId, 'cmd-window-set-cursor-visible', {
+          windowId: context.worldId,
+          visible: p.cursorVisible,
+        });
+      }
+      if (p.cursorGrab !== undefined) {
+        enqueueCommand(context.worldId, 'cmd-window-set-cursor-grab', {
+          windowId: context.worldId,
+          mode: p.cursorGrab,
+        });
+      }
+      if (p.icon !== undefined) {
+        enqueueCommand(context.worldId, 'cmd-window-set-icon', {
+          windowId: context.worldId,
+          icon: p.icon,
+        });
+      }
+      if (p.cursorIcon !== undefined) {
+        enqueueCommand(context.worldId, 'cmd-window-set-cursor-icon', {
+          windowId: context.worldId,
+          icon: p.cursorIcon,
+        });
+      }
+      intentsToRemove.push(i);
+    } else if (intent.type === 'request-attention') {
+      enqueueCommand(context.worldId, 'cmd-window-request-attention', {
+        windowId: context.worldId,
+        attentionType: intent.attentionType,
+      });
+      intentsToRemove.push(i);
+    } else if (intent.type === 'focus-window') {
+      enqueueCommand(context.worldId, 'cmd-window-focus', {
+        windowId: context.worldId,
+      });
+      intentsToRemove.push(i);
+    } else if (intent.type === 'configure-environment') {
+      const config = intent.config as EnvironmentConfig;
+      const payload: EnvironmentConfig = {
+        msaa: {
+          enabled: config.msaa.enabled,
+          sampleCount: config.msaa.sampleCount,
+        },
+        skybox: {
+          mode: config.skybox.mode,
+          intensity: config.skybox.intensity,
+          rotation: config.skybox.rotation,
+          tint: toVec3(config.skybox.tint),
+          cubemapTextureId: config.skybox.cubemapTextureId ?? null,
+        },
+      };
+      enqueueCommand(context.worldId, 'cmd-environment-update', {
+        windowId: context.worldId,
+        config: payload,
+      });
+      intentsToRemove.push(i);
+    } else if (intent.type === 'configure-shadows') {
+      const c = intent.config || {};
+      const config: ShadowConfig = {
+        tileResolution: c.tileResolution ?? 1024,
+        atlasTilesW: c.atlasTilesW ?? 8,
+        atlasTilesH: c.atlasTilesH ?? 8,
+        atlasLayers: c.atlasLayers ?? 2,
+        virtualGridSize: c.virtualGridSize ?? 1,
+        smoothing: c.smoothing ?? 2,
+        normalBias: c.normalBias ?? 0.01,
+      };
+      enqueueCommand(context.worldId, 'cmd-shadow-configure', {
+        windowId: context.worldId,
+        config,
+      });
+      intentsToRemove.push(i);
+    } else if (intent.type === 'send-notification') {
+      enqueueCommand(context.worldId, 'cmd-notification-send', {
+        id: `notif-${Date.now()}`,
+        level: intent.level,
+        title: intent.title,
+        body: intent.message,
+        timeout: 5000,
+      });
+      intentsToRemove.push(i);
+    }
+  }
+
+  for (let i = intentsToRemove.length - 1; i >= 0; i--) {
+    const idx = intentsToRemove[i];
+    if (idx !== undefined) world.pendingIntents.splice(idx, 1);
+  }
+
+};