@volter/editor-game 0.5.65 → 0.5.66

package/contributions/generation.service.ts

@@ -31,8 +31,8 @@
  */
 
 import { registerDocumentOpener } from '@volter/editor-core/document-open-registry';
-import { CONTRIBUTED_WORKSPACE_UTILITIES } from '@volter/editor-core/workspace-core-utilities';
-import { registerWorkspaceUtility } from '@volter/editor-core/workspace-utility-registry';
+import { CONTRIBUTED_WORKSPACE_UTILITIES } from '@volter/editor-sdk/kit/workspace-core-utilities';
+import { registerWorkspaceUtility } from '@volter/editor-sdk/kit/workspace-utility-registry';
 import { GenerationActivity } from '../src/generation/GenerationActivity';
 import {
   openGenerationCreateDocument,

package/contributions/generations.status.tsx

@@ -9,7 +9,7 @@
  * concern).
  */
 
-import { CONTRIBUTED_WORKSPACE_UTILITIES } from '@volter/editor-core/workspace-core-utilities';
+import { CONTRIBUTED_WORKSPACE_UTILITIES } from '@volter/editor-sdk/kit/workspace-core-utilities';
 import { editorHost } from '@volter/editor-sdk/host';
 import { Button } from '@volter/editor-sdk/widgets';
 import { useSyncExternalStore } from 'react';

package/contributions/godot.palette.json

@@ -0,0 +1,99 @@
+{
+  "schemaVersion": 3,
+  "name": "Godot",
+  "theme": {
+    "id": "godot",
+    "color": {
+      "surface": {
+        "shell": "#1d2229",
+        "panel": "#21262e",
+        "chrome": "#252b34",
+        "raised": "#363d4a",
+        "inset": "#1d2229",
+        "overlay": "rgba(33,38,46,0.96)"
+      },
+      "boundary": {
+        "default": "#363d4a",
+        "strong": "#4a5263",
+        "area": "#1d2229",
+        "indent": "#4a5263",
+        "divider": "#2c323c"
+      },
+      "content": {
+        "primary": "#e0e0e0",
+        "muted": "#c0c3c8",
+        "dim": "#8a8e96",
+        "onAccent": "#ffffff",
+        "menu": "#e0e0e0",
+        "status": "#9a9ea6",
+        "placeholder": "#6a6d73",
+        "active": "#70bafa",
+        "selected": "#70bafa",
+        "onBright": {
+          "primary": "#1d2229",
+          "muted": "rgba(29,34,41,0.82)",
+          "dim": "rgba(29,34,41,0.7)"
+        }
+      },
+      "accent": {
+        "default": "#70bafa",
+        "muted": "#374f66"
+      },
+      "widget": {
+        "regular": "#363d4a",
+        "menu": "#21262e",
+        "field": "#1d2229",
+        "emboss": "rgba(0,0,0,0.12)"
+      },
+      "viewport": {
+        "background": "#4d4d4d",
+        "grid": "#6e6964",
+        "axisX": "#f53352",
+        "axisY": "#87d603",
+        "axisZ": "#298cf5",
+        "selection": "#ff8000",
+        "active": "#ff8000"
+      },
+      "gizmo": {
+        "x": "#f53352",
+        "y": "#87d603",
+        "z": "#298cf5"
+      },
+      "region": {
+        "outliner": "#21262e",
+        "properties": "#21262e"
+      },
+      "category": {
+        "object": "#fc7f7f",
+        "modifier": "#8da5f3",
+        "material": "#ff5d5d",
+        "data": "#8eef97",
+        "scene": "#e0e0e0",
+        "collection": "#e0e0e0",
+        "tool": "#e0e0e0",
+        "operator": "#8eef97"
+      },
+      "semantic": {
+        "danger": "#ff786b",
+        "dangerMuted": "rgba(255,120,107,0.28)",
+        "dangerFaint": "rgba(255,120,107,0.12)",
+        "warning": "#ffdd65",
+        "warningMuted": "rgba(255,221,101,0.28)",
+        "success": "#45ff8b",
+        "successMuted": "rgba(69,255,139,0.28)",
+        "dynamic": "#ffdd65",
+        "dynamicMuted": "rgba(255,221,101,0.18)",
+        "instance": "#70bafa"
+      },
+      "neutralOverlay": {
+        "hover": "rgba(255,255,255,0.07)",
+        "active": "rgba(255,255,255,0.13)"
+      },
+      "scrim": "rgba(0,0,0,0.6)"
+    },
+    "typography": {
+      "sans": "'Noto Sans', 'Inter', system-ui, sans-serif",
+      "mono": "'JetBrains Mono', 'Hack', Menlo, monospace"
+    }
+  }
+}

package/contributions/godot.style.ts

@@ -0,0 +1,62 @@
+/**
+ * THE GODOT LOOK — Godot 4.4's default editor theme and its 3D viewport's
+ * colours, made only of values (`docs/VIEWPORT-STAGE.md`, the Godot column).
+ *
+ * The viewport group transcribes Godot's axis colours (`theme_modern.cpp`): X (0.96, 0.20,
+ * 0.32), Y (0.53, 0.84, 0.01) and Z (0.16, 0.55, 0.96), named by the world's axes; and the selection
+ * box (1.0, 0.5, 0). The fill is Godot's `default_clear_color` (0.3, 0.3, 0.3),
+ * what shows with the preview environment off. The grid's minor and major
+ * levels are the primary/secondary grid colours at alpha 0.5, fitted against
+ * `engine-reference/godot/tuto_3d3.png` over the preview sky's ground: a line
+ * there peaks near (95, 91, 87) over a (62, 51, 40) floor.
+ * Light, sky and overlays are the VIEW's presentation, not this look's.
+ */
+import type { StyleContribution } from '@volter/editor-sdk/looks';
+import palette from './godot.palette.json';
+
+export const point = 'workspace.style';
+export const style: StyleContribution = {
+  id: 'godot',
+  title: 'Godot',
+  paletteId: 'godot',
+  materialId: 'godot',
+  material: {
+    id: 'godot',
+    title: 'Godot',
+    description: 'Flat blue-grey panels, three-pixel corners, a soft shadow under popups.',
+    shape: { small: '3px', medium: '3px', large: '4px', full: '9999px' },
+    elevation: {
+      small: 'none',
+      medium: '0 3px 10px rgba(0,0,0,0.45)',
+      large: '0 6px 18px rgba(0,0,0,0.5)',
+    },
+    stage: {
+      // Godot's `manipulator_gizmo_size` is 80, but its unit is not ours: the stage's px per
+      // gizmo unit is fitted, not transcribed. At 128 the rotation rings measure ~80 px in
+      // radius on a 1x capture, against ~85 px in `engine-reference/godot/tuto_3d5.png`.
+      gizmoSize: 128,
+      // The move arrows reach 1.6 ring radii with a head about half again three's
+      // (`tuto_3d5.png`: a 142 px tip against a 90 px ring, a 25 px head).
+      gizmoArrowLength: 1.6,
+      gizmoArrowHead: 1.5,
+      // Its rotation rings are about twice three's thickness (`tuto_3d5.png`).
+      gizmoRingWidth: 2,
+      // `manipulator_gizmo_opacity` 0.9; the highlight is the axis colour at a quarter of its
+      // saturation and full value (`node_3d_editor_plugin.cpp`).
+      gizmoOpacity: 0.9,
+      gizmoHighlightSaturation: 0.25,
+      gizmoHighlightValue: 1,
+      // Godot's grid lines are hairlines at both levels.
+      gridLineWidth: 1,
+      gridMajorWidth: 1,
+      gridMajorContrast: 1.3,
+      // Godot's selection is the whole AABB. Its edge is one solid pixel at 1x
+      // (`tuto_3d5.png`); our screen-space line needs 2 to cover one captured pixel.
+      selectionBox: 'edges',
+      // Godot's box turns with the object: its AABB in the object's own frame.
+      selectionBoxFrame: 'object',
+      selectionBoxWidth: 2,
+    },
+  },
+  palette,
+};

package/contributions/godot.view.ts

@@ -0,0 +1,69 @@
+/**
+ * GODOT'S DEFAULT 3D VIEWPORT: its preview sun and procedural sky (the kit's sky, which is
+ * Godot's own `ProceduralSkyMaterial` default) under its Filmic curve, the sky as backdrop, an
+ * 8-cell grid, all three axis lines with Y vertical, the full selection box, and its Select
+ * gizmo's arrows and rings without the extra handles. Judged against `tuto_3d3.png`/`tuto_3d5.png`.
+ * A named view (`@volter/editor-sdk/kit/viewport-presentation` `ViewPreset`): what the view does
+ * and how it is lit, never its look — pair it with the Godot style for the whole target.
+ */
+import type { ViewPreset } from '@volter/editor-sdk/kit/viewport-presentation';
+
+export const point = 'workspace.view';
+export const view: ViewPreset = {
+  id: 'godot',
+  title: 'Godot',
+  layer: {
+    all: {
+      lighting: {
+        source: 'preview',
+        preview: {
+          sun: {
+            enabled: true,
+            color: '#ffffff',
+            energy: 1,
+            altitude: 60,
+            azimuth: 150,
+            shadowDistance: 100,
+          },
+          environment: {
+            enabled: true,
+            energy: 1,
+            rotation: 0,
+          },
+        },
+        tone: {
+          mapper: 'filmic',
+          exposure: 1,
+        },
+      },
+      backdrop: {
+        source: 'environment',
+        opacity: 1,
+        blur: 0,
+      },
+    },
+    overlays: {
+      grid: {
+        visible: true,
+        majorEvery: 8,
+      },
+      selection: {
+        outline: false,
+        wire: false,
+        box: true,
+      },
+      axes: {
+        x: true,
+        y: true,
+        z: true,
+      },
+    },
+    interaction: {
+      transformHandles: {
+        scale: false,
+        viewRotate: false,
+        freeMove: false,
+      },
+    },
+  },
+};

package/contributions/ingest.service.ts

@@ -40,10 +40,10 @@
  * `mount-ingest-root.ts` binds itself on — read at launch time rather than
  * captured, so neither ordering can leave the launch holding `null`.
  */
-import { editorConsole } from '@volter/editor-core/editor-console';
+import { editorConsole } from '@volter/editor-sdk/kit/editor-console';
 import { importIngestAdapterModule, ingestAdapterModulePath } from '../src/host/ingest/registry';
 import { registerAdapterDefinitionSource } from '@volter/editor-core/project-adapter';
-import { shellStoreForHost } from '@volter/editor-core/shell-store-door';
+import { threeStoreForHost } from '@volter/editor-core/shell-store-door';
 import { editorHost } from '@volter/editor-sdk/host';
 import { autoLaunchIngest } from '../src/ingest/mount-ingest-root';
 
@@ -60,7 +60,7 @@ export function start(): () => void {
     importModule: async (rootId) => await importIngestAdapterModule(rootId),
   });
   const stopReady = editorHost().project.onReady(async () => {
-    const store = shellStoreForHost();
+    const store = threeStoreForHost();
     if (!store) {
       // The store arrives with `AppRoot`, long before any boot chain reaches
       // ready, so this cannot happen quietly — say so rather than skipping an

package/contributions/play.command.ts

@@ -31,7 +31,7 @@
 import { getActiveSystems } from '@volter/editor-core/authoring/active-systems';
 import { setGameplayExportActive } from '@volter/editor-core/gameplay-export-state';
 import { stopGameplayRecording } from '../src/host/gameplay-recording';
-import { liveInstanceContainer } from '@volter/editor-core/live-session-registry';
+import { liveInstanceContainer } from '@volter/editor-sdk/kit/live-session-registry';
 import type { CommandContribution } from '@volter/editor-sdk/commands';
 import { editorHost } from '@volter/editor-sdk/host';
 import type { OfflineAudioRenderer } from '@volter/editor-project/adapter';

package/contributions/react/react-inspector.service.ts

@@ -64,9 +64,9 @@
  * structural write pipe (`authoring/r3f-source-authoring-adapter.ts`,
  * `@vgai/canvas/pixi-source-write-target.ts`); the breakpoint state
  * (`components/BoardRulers.tsx`); `authoring/react-story-board.ts`, the
- * board's geometry, which four host surfaces read
+ * board's geometry, which three host surfaces read
  * (`components/RootSelectionOverlay.tsx:98`,
- * `components/ReactCanvasControls.tsx:15`, `pasteboard-materialize.ts:20`,
+ * `components/ReactCanvasControls.tsx:15`,
  * `canvas-board/CanvasBoardDocument.tsx:57`) because they draw chrome OVER
  * the board. Each is its own unit with its own seam; none of them is in the
  * host's EAGER closure, which is what these cuts buy.

package/contributions/scene-document.service.ts

@@ -10,16 +10,16 @@
  * (`@volter/editor-core/shell-store-door`'s `onShellStore`, as Play's
  * autoplay entry does) and unbinds the previous store's binding first.
  */
-import { onShellStore } from '@volter/editor-core/shell-store-door';
+import { onThreeStore } from '@volter/editor-core/shell-store-door';
 import { unregisterAvailableWorkspaceDocument } from '@volter/editor-core/workspace-available-documents';
-import { SCENE_DOCUMENT_ID } from '@volter/editor-core/workspace-document-ids';
+import { SCENE_DOCUMENT_ID } from '@volter/editor-sdk/kit/workspace-document-ids';
 import { bindSceneDocument } from '../src/host/components/scene-document';
 
 export const point = 'workspace.service';
 
 export function start(): () => void {
   let unbind: (() => void) | null = null;
-  const stopStore = onShellStore((store) => {
+  const stopStore = onThreeStore((store) => {
     unbind?.();
     unbind = bindSceneDocument(store);
   });

package/contributions/three/component-verbs.command.ts

@@ -28,7 +28,7 @@ import { getActiveAuthoring } from '@volter/editor-core/authoring/active-adapter
 import type { EditorShellStore } from '@volter/editor-core/editor-shell-store';
 import { canExtractNode, isExtractedHint } from '../../src/host/instance-extract-actions';
 import { canForkInstance, isForkedHint } from '../../src/host/instance-fork-actions';
-import { shellStoreForHost } from '@volter/editor-core/shell-store-door';
+import { threeStoreForHost } from '@volter/editor-core/shell-store-door';
 import type { CommandContribution } from '@volter/editor-sdk/commands';
 import { instanceExtractSourceFor } from '../../src/three/component-verbs/extract-menu';
 import { instanceForkSourceFor } from '../../src/three/component-verbs/fork-menu';
@@ -51,7 +51,7 @@ export const commands: CommandContribution['commands'] = {
     derivedRefresh: 'always',
     handle: async (cmd) => {
       try {
-        const store = shellStoreForHost();
+        const store = threeStoreForHost();
         if (!store) return NO_STORE;
         const id = subjectId(cmd, store);
         if (!id) return { ok: false, error: 'extract-component needs an id or a selected row.' };
@@ -82,7 +82,7 @@ export const commands: CommandContribution['commands'] = {
     derivedRefresh: 'always',
     handle: async (cmd) => {
       try {
-        const store = shellStoreForHost();
+        const store = threeStoreForHost();
         if (!store) return NO_STORE;
         const id = subjectId(cmd, store);
         if (!id) return { ok: false, error: 'fork-component needs an id or a selected row.' };

package/contributions/unity.palette.json

@@ -0,0 +1,102 @@
+{
+  "schemaVersion": 3,
+  "name": "Unity",
+  "theme": {
+    "id": "unity",
+    "color": {
+      "surface": {
+        "shell": "#191919",
+        "panel": "#383838",
+        "chrome": "#282828",
+        "raised": "#585858",
+        "inset": "#2a2a2a",
+        "overlay": "rgba(40,40,40,0.96)"
+      },
+      "boundary": {
+        "default": "#232323",
+        "strong": "#191919",
+        "area": "#191919",
+        "indent": "#4a4a4a",
+        "divider": "#2f2f2f"
+      },
+      "content": {
+        "primary": "#d2d2d2",
+        "muted": "#c4c4c4",
+        "dim": "#8f8f8f",
+        "onAccent": "#ffffff",
+        "menu": "#d2d2d2",
+        "status": "#a0a0a0",
+        "placeholder": "#6f6f6f",
+        "active": "#7bbcff",
+        "selected": "#ffffff",
+        "onBright": {
+          "primary": "#191919",
+          "muted": "rgba(25,25,25,0.82)",
+          "dim": "rgba(25,25,25,0.7)"
+        }
+      },
+      "accent": {
+        "default": "#3a79bb",
+        "muted": "#2c5d87"
+      },
+      "widget": {
+        "regular": "#585858",
+        "menu": "#383838",
+        "field": "#2a2a2a",
+        "emboss": "rgba(0,0,0,0.2)"
+      },
+      "viewport": {
+        "background": "#474747",
+        "grid": "#76726f",
+        "axisX": "#db3e1d",
+        "axisY": "#9af348",
+        "axisZ": "#3a7af8",
+        "selection": "#ff6600",
+        "wire": "#5e779b",
+        "active": "#ff6600"
+      },
+      "gizmo": {
+        "x": "#db3e1d",
+        "y": "#9af348",
+        "z": "#3a7af8",
+        "hover": "#c9c890",
+        "drag": "#f6f232"
+      },
+      "region": {
+        "outliner": "#383838",
+        "properties": "#383838"
+      },
+      "category": {
+        "object": "#8fb8f0",
+        "modifier": "#8fb8f0",
+        "material": "#e0a060",
+        "data": "#9fd88c",
+        "scene": "#d2d2d2",
+        "collection": "#d2d2d2",
+        "tool": "#d2d2d2",
+        "operator": "#9fd88c"
+      },
+      "semantic": {
+        "danger": "#ff6b5b",
+        "dangerMuted": "rgba(255,120,107,0.28)",
+        "dangerFaint": "rgba(255,120,107,0.12)",
+        "warning": "#ffc107",
+        "warningMuted": "rgba(255,221,101,0.28)",
+        "success": "#7cc576",
+        "successMuted": "rgba(69,255,139,0.28)",
+        "dynamic": "#ffdd65",
+        "dynamicMuted": "rgba(255,221,101,0.18)",
+        "instance": "#7bbcff"
+      },
+      "neutralOverlay": {
+        "hover": "rgba(255,255,255,0.07)",
+        "active": "rgba(255,255,255,0.13)"
+      },
+      "scrim": "rgba(0,0,0,0.6)"
+    },
+    "typography": {
+      "sans": "'Inter', 'Segoe UI', system-ui, sans-serif",
+      "mono": "'Roboto Mono', Menlo, monospace"
+    }
+  }
+}

package/contributions/unity.style.ts

@@ -0,0 +1,62 @@
+/**
+ * THE UNITY LOOK — Unity 6's dark editor skin and its Scene view's colours,
+ * made only of values (`docs/VIEWPORT-STAGE.md`, the Unity column).
+ *
+ * The viewport group transcribes UnityCsReference: the fill is the Scene
+ * view's flat colour with the skybox off (0.278, 0.278, 0.278); selection is
+ * `Handles.selectedColor`'s outline `#ff6600`. The grid (0.5, 0.5, 0.5, 0.4)
+ * is fitted against `engine-reference/unity/NewEmptyScene_01.png`: its lines
+ * sit about 10 levels over the skybox ground (104, 97, 92). The axis colours, named by the world's axes, are
+ * `Handles.xAxisColor`, `yAxisColor` and `zAxisColor`; Unity's floor draws no axis
+ * lines, which is its view's presentation (`overlays.axes` all off), not this look's.
+ * Light, skybox and overlays are the VIEW's presentation, not this look's.
+ */
+import type { StyleContribution } from '@volter/editor-sdk/looks';
+import palette from './unity.palette.json';
+
+export const point = 'workspace.style';
+export const style: StyleContribution = {
+  id: 'unity',
+  title: 'Unity',
+  paletteId: 'unity',
+  materialId: 'unity',
+  material: {
+    id: 'unity',
+    title: 'Unity',
+    description: 'Flat grey panels, three-pixel control corners, a shadow under popups.',
+    shape: { small: '3px', medium: '3px', large: '4px', full: '9999px' },
+    elevation: {
+      small: 'none',
+      medium: '0 2px 8px rgba(0,0,0,0.5)',
+      large: '0 6px 18px rgba(0,0,0,0.55)',
+    },
+    stage: {
+      // `HandleUtility.GetHandleSize` keeps a handle a constant size on screen; the stage's
+      // px per gizmo unit is fitted, not transcribed: at 128 the move arrows reach ~95 px on
+      // a 1x capture, as in `engine-reference/unity/PrimitiveCube.png`.
+      gizmoSize: 128,
+      // Unity's scene gizmo: cones round a grey cube (`Editor-SceneGizmo.png`).
+      navigationGizmo: 'cones',
+      // Unity's move arrow is a thin shaft ending at the rotate ring, with a long cone head
+      // (`TransformGizmo35.png`, `game-objects-transform-modes.png`).
+      gizmoArrowLength: 1.1,
+      gizmoArrowHead: 1.2,
+      // The axis colours' alpha (`Handles.cs`); hover and drag are fixed colours (the palette).
+      gizmoOpacity: 0.93,
+      // `SceneViewGrid`: one-pixel lines at both levels, the ten-cell level a little stronger.
+      gridLineWidth: 1,
+      gridMajorWidth: 1,
+      gridMajorContrast: 1.25,
+      // Unity's selection outline is a hard orange line about two pixels wide at 1x, around
+      // the whole silhouette, occluded parts included (`game-objects-transform-modes.png`,
+      // `SceneVisExVisible.png`, where it crosses the rock in front of the structure); at 3
+      // device px the crisp line measures one full and one partial pixel on a 1x capture, as there.
+      outlineStyle: 'crisp',
+      outlineWidth: 3,
+      outlineHidden: true,
+      // The Selection Wire's alpha: `(94, 119, 155, 64)` (the palette holds its colour).
+      wireOpacity: 0.25,
+    },
+  },
+  palette,
+};

package/contributions/unity.view.ts

@@ -0,0 +1,76 @@
+/**
+ * UNITY'S DEFAULT SCENE VIEW: its procedural sky with a narrow horizon band (colours fitted to
+ * `NewEmptyScene_01.png`, not transcribed), the grid, no axis lines, the outline alone, the Move
+ * tool without a free-move centre.
+ * A named view (`@volter/editor-sdk/kit/viewport-presentation` `ViewPreset`): what the view does
+ * and how it is lit, never its look — pair it with the Unity style for the whole target.
+ */
+import type { ViewPreset } from '@volter/editor-sdk/kit/viewport-presentation';
+
+export const point = 'workspace.view';
+export const view: ViewPreset = {
+  id: 'unity',
+  title: 'Unity',
+  layer: {
+    all: {
+      lighting: {
+        source: 'preview',
+        preview: {
+          sun: {
+            enabled: true,
+            color: '#fff4d6',
+            energy: 1,
+            altitude: 50,
+            azimuth: 150,
+            shadowDistance: 100,
+          },
+          environment: {
+            enabled: true,
+            sky: {
+              top: '#4a84c2',
+              horizon: '#f0ffff',
+              ground: '#68615c',
+              topCurve: 0.04,
+              groundCurve: 0.003,
+            },
+            energy: 1,
+            rotation: 0,
+          },
+        },
+        tone: {
+          mapper: 'none',
+          exposure: 1,
+        },
+      },
+      backdrop: {
+        source: 'environment',
+        opacity: 1,
+        blur: 0,
+      },
+    },
+    overlays: {
+      grid: {
+        visible: true,
+        majorEvery: 10,
+      },
+      selection: {
+        outline: true,
+        wire: false,
+        box: false,
+      },
+      axes: {
+        x: false,
+        y: false,
+        z: false,
+      },
+    },
+    interaction: {
+      bootTool: 'move',
+      transformHandles: {
+        scale: false,
+        viewRotate: false,
+        freeMove: false,
+      },
+    },
+  },
+};