@volter/editor-threejs 0.5.66 → 0.5.68

package/src/kit/authoring/object3d-gesture-controller.ts

@@ -0,0 +1,113 @@
+import type { ToolObject3DGesture, ToolObject3DPointerEvent } from '../../object3d-contributions';
+
+export interface Object3DGestureControllerOptions {
+  readonly begin: (event: ToolObject3DPointerEvent) => ToolObject3DGesture | null;
+  readonly persist: (label?: string) => Promise<void>;
+  readonly reportError: (error: unknown) => void;
+}
+
+/** Exactly one project gesture at a time; every terminal path is explicit. */
+export class Object3DGestureController {
+  private active: { pointerId: number; gesture: ToolObject3DGesture } | null = null;
+  private settling = false;
+  private readonly idleWaiters = new Set<() => void>();
+
+  constructor(private readonly options: Object3DGestureControllerOptions) {}
+
+  begin(event: ToolObject3DPointerEvent): boolean {
+    if (this.active || this.settling) return false;
+    try {
+      const gesture = this.options.begin(event);
+      if (!gesture) return false;
+      this.active = { pointerId: event.pointerId, gesture };
+      return true;
+    } catch (error) {
+      this.options.reportError(error);
+      return false;
+    }
+  }
+
+  update(event: ToolObject3DPointerEvent): void {
+    if (!this.active || this.active.pointerId !== event.pointerId) return;
+    try {
+      this.active.gesture.update(event);
+    } catch (error) {
+      void this.cancelWithError(error);
+    }
+  }
+
+  async commit(event: ToolObject3DPointerEvent): Promise<boolean> {
+    const active = this.take(event.pointerId);
+    if (!active) return false;
+    this.settling = true;
+    try {
+      await active.commit(event);
+      await this.options.persist(active.label);
+      return true;
+    } catch (error) {
+      try {
+        await active.cancel();
+      } catch (cancelError) {
+        this.options.reportError({ operationError: error, rollbackError: cancelError });
+        return false;
+      }
+      this.options.reportError(error);
+      return false;
+    } finally {
+      this.settling = false;
+      for (const resolve of this.idleWaiters) resolve();
+      this.idleWaiters.clear();
+    }
+  }
+
+  async cancel(pointerId?: number): Promise<boolean> {
+    const active = this.take(pointerId);
+    if (!active) return false;
+    this.settling = true;
+    try {
+      await active.cancel();
+      return true;
+    } catch (error) {
+      this.options.reportError(error);
+      return false;
+    } finally {
+      this.settling = false;
+      for (const resolve of this.idleWaiters) resolve();
+      this.idleWaiters.clear();
+    }
+  }
+
+  /** A source handoff waits for persistence/rollback, including pointer-up work. */
+  async settle(): Promise<void> {
+    if (this.active) await this.cancel();
+    if (this.settling) await new Promise<void>((resolve) => this.idleWaiters.add(resolve));
+  }
+
+  hasActiveGesture(): boolean {
+    return this.active !== null;
+  }
+
+  private take(pointerId?: number): ToolObject3DGesture | null {
+    if (!this.active || (pointerId !== undefined && this.active.pointerId !== pointerId))
+      return null;
+    const gesture = this.active.gesture;
+    this.active = null;
+    return gesture;
+  }
+
+  private async cancelWithError(error: unknown): Promise<void> {
+    const active = this.take();
+    if (!active) return;
+    this.settling = true;
+    try {
+      await active.cancel();
+      this.options.reportError(error);
+    } catch (rollbackError) {
+      this.options.reportError({ operationError: error, rollbackError });
+    } finally {
+      this.settling = false;
+      for (const resolve of this.idleWaiters) resolve();
+      this.idleWaiters.clear();
+    }
+  }
+}

package/src/kit/authoring/quarks-particle-systems.ts

@@ -0,0 +1,19 @@
+import type * as THREE from 'three';
+import type { ParticleSystem } from 'three.quarks';
+
+/** Native three.quarks systems owned by ParticleEmitter nodes in this graph.
+ * Detection is structural because a project can bring its own compatible
+ * three.quarks module instance; `instanceof` would make that ordinary case
+ * disappear across package boundaries. */
+export function quarksParticleSystems(root: THREE.Object3D): ParticleSystem[] {
+  const systems: ParticleSystem[] = [];
+  const seen = new Set<ParticleSystem>();
+  root.traverse((object) => {
+    if (object.type !== 'ParticleEmitter') return;
+    const system = (object as THREE.Object3D & { system?: ParticleSystem }).system;
+    if (!system || typeof system.getRendererSettings !== 'function' || seen.has(system)) return;
+    seen.add(system);
+    systems.push(system);
+  });
+  return systems;
+}

package/src/kit/authoring/shell-viewport-policy.ts

@@ -0,0 +1,48 @@
+/**
+ * THE SHELL'S ANSWERS to `ViewportAuthoringPolicy` — the composition the
+ * editor installs at boot (`EditorContext.tsx`'s `EditorProvider`).
+ *
+ * Every member here is a one-line delegation to the module that already owned
+ * that answer. Nothing moved and nothing was reimplemented: the point of the
+ * seam is only that `editor-viewport.ts` no longer imports these modules, so
+ * the gizmo viewport does not carry the composite adapter, the workspace
+ * document registry, or the layered-pick walk in its own closure
+ * (ARCHITECTURE-CORE §Editor chrome, "the viewport stack is separable").
+ *
+ * This file is the shell side of that boundary and is free to import all of
+ * them.
+ */
+
+import type { ViewportAuthoringPolicy } from '../viewport-authoring-policy';
+import { getActiveAuthoring } from '@volter/editor-sdk/kit/authoring/active-adapter';
+import { CompositeAuthoringAdapter } from '@volter/editor-sdk/kit/authoring/composite-authoring-adapter';
+import { pickTopmost } from '@volter/editor-sdk/kit/authoring/layered-pick';
+import { resolvePanelAuthoring } from '@volter/editor-sdk/kit/authoring/panel-authoring';
+import { isViewportToolContextVisible, resolveViewportToolContext } from '@volter/editor-sdk/kit/authoring/viewport-tool-context';
+import {
+  applyRootHiddenVisibility,
+  isThreejsSurfaceVisible,
+  resolveThreeViewportRootId,
+  suppressRootEnvironment,
+} from './world-hidden-viewport';
+
+export const SHELL_VIEWPORT_AUTHORING_POLICY: ViewportAuthoringPolicy = {
+  activeAuthoring: (store) => getActiveAuthoring(store),
+  panelAuthoring: (store) => resolvePanelAuthoring(store).adapter,
+  pick: (store, clientX, clientY, intent) => pickTopmost(store, clientX, clientY, { intent }),
+  toolOwner: (adapter, selectedIds) => resolveViewportToolContext(adapter, selectedIds),
+  // Both halves of "is this owner painted here" — visibility says a three
+  // surface is drawn at all, selection ownership says it is the world being
+  // edited. The viewport ANDs the result with `kind === 'three'`, exactly as it
+  // did when it called these two itself.
+  toolOwnerPainted: (store, owner) =>
+    isThreejsSurfaceVisible(store) && isViewportToolContextVisible(store, owner),
+  threeSurfaceShowing: (store, adapter) =>
+    isThreejsSurfaceVisible(store) &&
+    (adapter instanceof CompositeAuthoringAdapter
+      ? adapter.childAdapters().some((child) => child.kind === 'three')
+      : !adapter.rects && typeof adapter.hierarchy.object3D === 'function'),
+  threeViewportRootId: (store) => resolveThreeViewportRootId(store),
+  applyRootHiddenVisibility,
+  suppressRootEnvironment,
+};