@vulfram/engine 0.14.8-alpha → 0.19.2-alpha

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

@@ -1,114 +1,31 @@
 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';
+import { toVec3, toVec4 } from './utils';
 
+const WORLD_LIFECYCLE_INTENT_TYPES = [
+  'configure-environment',
+  'configure-shadows',
+  'send-notification',
+] as const;
+
+/**
+ * Applies world-scoped lifecycle/configuration intents.
+ *
+ * Covered intents:
+ * - environment configuration
+ * - shadow configuration
+ * - notification dispatch
+ */
 export const WorldLifecycleSystem: System = (world, context) => {
-  const intentsToRemove: number[] = [];
+  const intents = world.intentStore.takeMany(WORLD_LIFECYCLE_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-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,
-          bufferId: 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') {
+    if (intent.type === 'configure-environment') {
       const config = intent.config as EnvironmentConfig;
       const payload: EnvironmentConfig = {
         msaa: {
@@ -124,6 +41,7 @@ export const WorldLifecycleSystem: System = (world, context) => {
           skyColor: toVec3(config.skybox.skyColor),
           cubemapTextureId: config.skybox.cubemapTextureId ?? null,
         },
+        clearColor: toVec4(config.clearColor ?? [0, 0, 0, 0]),
         post: {
           filterEnabled: config.post.filterEnabled,
           filterExposure: config.post.filterExposure,
@@ -157,12 +75,31 @@ export const WorldLifecycleSystem: System = (world, context) => {
           bloomScatter: config.post.bloomScatter,
         },
       };
-      enqueueCommand(context.worldId, 'cmd-environment-update', {
-        windowId: context.worldId,
+      enqueueCommand(context.worldId, 'cmd-environment-upsert', {
+        environmentId: context.worldId,
         config: payload,
       });
-      intentsToRemove.push(i);
+      // Keep current realm->target bindings synchronized with this environment.
+      for (const binding of world.targetLayerBindings.values()) {
+        binding.environmentId = context.worldId;
+        if (world.coreRealmId === undefined) continue;
+        enqueueCommand(context.worldId, 'cmd-target-layer-upsert', {
+          realmId: world.coreRealmId,
+          targetId: binding.targetId,
+          layout: binding.layout,
+          cameraId: binding.cameraId,
+          environmentId: context.worldId,
+        });
+      }
     } else if (intent.type === 'configure-shadows') {
+      let windowId = world.primaryWindowId;
+      if (windowId === undefined) {
+        for (const boundWindowId of world.targetWindowBindings.values()) {
+          windowId = boundWindowId;
+          break;
+        }
+      }
+      if (windowId === undefined) continue;
       const c = intent.config || {};
       const config: ShadowConfig = {
         tileResolution: c.tileResolution ?? 1024,
@@ -174,10 +111,9 @@ export const WorldLifecycleSystem: System = (world, context) => {
         normalBias: c.normalBias ?? 0.01,
       };
       enqueueCommand(context.worldId, 'cmd-shadow-configure', {
-        windowId: context.worldId,
+        windowId,
         config,
       });
-      intentsToRemove.push(i);
     } else if (intent.type === 'send-notification') {
       enqueueCommand(context.worldId, 'cmd-notification-send', {
         id: `notif-${Date.now()}`,
@@ -186,13 +122,6 @@ export const WorldLifecycleSystem: System = (world, context) => {
         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);
-  }
-
 };

package/src/engine/window/manager.ts

@@ -0,0 +1,168 @@
+import type { CmdWindowCloseArgs, CmdWindowCreateArgs } from '../../types/cmds/window';
+import type {
+  CursorGrabMode,
+  CursorIcon,
+  UserAttentionType,
+  WindowState,
+} from '../../types/kinds';
+import { enqueueGlobalCommand } from '../bridge/dispatch';
+import { requireInitialized } from '../bridge/guards';
+import { engineState } from '../state';
+import type { CommandId, WindowId } from '../world/types';
+import { asCommandId, asWindowId } from '../world/types';
+
+export interface WindowProps {
+  title?: string;
+  position?: [number, number];
+  size?: [number, number];
+  state?: WindowState;
+  resizable?: boolean;
+  decorations?: boolean;
+  cursorVisible?: boolean;
+  cursorGrab?: CursorGrabMode;
+  icon?: number;
+  cursorIcon?: CursorIcon;
+}
+
+export interface CreateWindowProps {
+  title: string;
+  size: [number, number];
+  position: [number, number];
+  canvasId?: string;
+  borderless?: boolean;
+  resizable?: boolean;
+  transparent?: boolean;
+  initialState?: WindowState;
+}
+
+function allocateWindowId(): WindowId {
+  while (engineState.usedWindowIds.has(engineState.nextWindowId)) {
+    engineState.nextWindowId++;
+  }
+  const id = engineState.nextWindowId++;
+  engineState.usedWindowIds.add(id);
+  return asWindowId(id);
+}
+
+/**
+ * Creates a window and returns a typed window id plus the command id.
+ *
+ * IDs are auto-generated by default to avoid collisions. You can pass `windowId`
+ * only when integrating with an existing host-level ID contract.
+ */
+export function createWindow(
+  props: CreateWindowProps,
+  windowId?: WindowId,
+): { windowId: WindowId; commandId: CommandId } {
+  requireInitialized();
+  const resolvedWindowId = windowId ?? allocateWindowId();
+  if (windowId !== undefined) {
+    engineState.usedWindowIds.add(windowId as number);
+  }
+  const payload: CmdWindowCreateArgs = {
+    windowId: resolvedWindowId as number,
+    title: props.title,
+    size: props.size,
+    position: props.position,
+    canvasId: props.canvasId,
+    borderless: props.borderless ?? false,
+    resizable: props.resizable ?? true,
+    transparent: props.transparent ?? false,
+    initialState: props.initialState ?? 'windowed',
+  };
+  const commandId = enqueueGlobalCommand('cmd-window-create', payload);
+  engineState.pendingWindowCreateByCommandId.set(
+    commandId,
+    resolvedWindowId as number,
+  );
+  return { windowId: resolvedWindowId, commandId: asCommandId(commandId) };
+}
+
+export function closeWindow(windowId: WindowId): CommandId {
+  requireInitialized();
+  const payload: CmdWindowCloseArgs = { windowId: windowId as number };
+  const commandId = enqueueGlobalCommand('cmd-window-close', payload);
+  engineState.pendingWindowCloseByCommandId.set(commandId, windowId as number);
+  return asCommandId(commandId);
+}
+
+/**
+ * Applies partial window updates.
+ *
+ * Depending on the provided fields, this may enqueue up to three commands
+ * (`measurement`, `state`, `cursor`) and returns all resulting command ids.
+ */
+export function updateWindow(windowId: WindowId, props: WindowProps): CommandId[] {
+  requireInitialized();
+  const commandIds: CommandId[] = [];
+
+  if (props.position !== undefined || props.size !== undefined) {
+    commandIds.push(asCommandId(
+      enqueueGlobalCommand('cmd-window-measurement', {
+        windowId: windowId as number,
+        position: props.position,
+        size: props.size,
+      }),
+    ));
+  }
+  if (
+    props.title !== undefined ||
+    props.state !== undefined ||
+    props.resizable !== undefined ||
+    props.decorations !== undefined ||
+    props.icon !== undefined
+  ) {
+    commandIds.push(asCommandId(
+      enqueueGlobalCommand('cmd-window-state', {
+        windowId: windowId as number,
+        title: props.title,
+        state: props.state,
+        resizable: props.resizable,
+        decorations: props.decorations,
+        iconBufferId: props.icon,
+      }),
+    ));
+  }
+  if (
+    props.cursorVisible !== undefined ||
+    props.cursorGrab !== undefined ||
+    props.cursorIcon !== undefined
+  ) {
+    commandIds.push(asCommandId(
+      enqueueGlobalCommand('cmd-window-cursor', {
+        windowId: windowId as number,
+        visible: props.cursorVisible,
+        mode: props.cursorGrab,
+        icon: props.cursorIcon,
+      }),
+    ));
+  }
+
+  return commandIds;
+}
+
+/**
+ * Requests user attention for a window.
+ *
+ * This does not guarantee foreground focus; behavior depends on host platform policy.
+ */
+export function requestAttention(
+  windowId: WindowId,
+  attentionType?: UserAttentionType,
+): CommandId {
+  requireInitialized();
+  return asCommandId(enqueueGlobalCommand('cmd-window-state', {
+    windowId: windowId as number,
+    action: 'request-attention',
+    attentionType,
+  }));
+}
+
+/** Requests input focus for a window. */
+export function focusWindow(windowId: WindowId): CommandId {
+  requireInitialized();
+  return asCommandId(enqueueGlobalCommand('cmd-window-state', {
+    windowId: windowId as number,
+    action: 'focus',
+  }));
+}