@aura3d/editor-runtime 1.3.3 → 1.4.1

package/src/NonlinearAnimationEditor.ts

@@ -1,262 +0,0 @@
-import { TimelineEditorController, type TimelineEditorSnapshot } from "./TimelineEditorController";
-import { TimelineModel, type TimelineClipConfig, type TimelineModelConfig, type TimelineTrackConfig } from "./TimelineModel";
-import { createTimelineTrackConfig, type TimelineEditorTrackKind } from "./TimelineTrackTypes";
-
-export type NonlinearBinAssetKind = "animation" | "audio" | "camera" | "shot" | "sequence" | "caption" | "viseme";
-
-export interface NonlinearBinAsset {
-  readonly id: string;
-  readonly name: string;
-  readonly kind: NonlinearBinAssetKind;
-  readonly assetId?: string | undefined;
-  readonly clipName?: string | undefined;
-  readonly duration?: number | undefined;
-  readonly metadata?: Readonly<Record<string, string | number | boolean>> | undefined;
-}
-
-export interface NonlinearSequenceConfig {
-  readonly id: string;
-  readonly name: string;
-  readonly timeline?: TimelineModelConfig | undefined;
-}
-
-export interface NonlinearSequenceSnapshot {
-  readonly id: string;
-  readonly name: string;
-  readonly trackCount: number;
-  readonly clipCount: number;
-  readonly duration: number;
-}
-
-export interface NonlinearAnimationEditorSnapshot {
-  readonly kind: "nonlinear-animation-editor";
-  readonly activeSequenceId: string;
-  readonly sequenceCount: number;
-  readonly binAssetCount: number;
-  readonly nestedSequenceClipCount: number;
-  readonly totalTrackCount: number;
-  readonly totalClipCount: number;
-  readonly sequences: readonly NonlinearSequenceSnapshot[];
-  readonly activeTimeline: TimelineEditorSnapshot;
-  readonly evidence: {
-    readonly nonlinearSequences: boolean;
-    readonly trimSplitMoveDuplicate: boolean;
-    readonly nestedSequences: boolean;
-    readonly multiTrackTimeline: boolean;
-    readonly serialization: true;
-  };
-}
-
-export interface NonlinearAnimationEditorState {
-  readonly activeSequenceId: string;
-  readonly binAssets: readonly NonlinearBinAsset[];
-  readonly sequences: readonly NonlinearSequenceConfig[];
-}
-
-interface NonlinearSequenceRuntime {
-  readonly id: string;
-  readonly name: string;
-  readonly controller: TimelineEditorController;
-}
-
-export class NonlinearAnimationEditor {
-  private readonly binAssets = new Map<string, NonlinearBinAsset>();
-  private readonly sequences = new Map<string, NonlinearSequenceRuntime>();
-  private activeSequenceId: string;
-
-  constructor(state: NonlinearAnimationEditorState) {
-    if (state.sequences.length === 0) throw new Error("Nonlinear animation editor requires at least one sequence.");
-    for (const asset of state.binAssets) this.addBinAsset(asset);
-    for (const sequence of state.sequences) this.createSequence(sequence);
-    this.activeSequenceId = nonEmpty(state.activeSequenceId, "Active sequence id");
-    this.requireSequence(this.activeSequenceId);
-  }
-
-  addBinAsset(asset: NonlinearBinAsset): NonlinearBinAsset {
-    const clean = sanitizeBinAsset(asset);
-    this.binAssets.set(clean.id, clean);
-    return clean;
-  }
-
-  createSequence(config: NonlinearSequenceConfig): NonlinearSequenceSnapshot {
-    const id = nonEmpty(config.id, "Sequence id");
-    const timeline = new TimelineModel({
-      id,
-      name: config.name,
-      duration: 10,
-      frameRate: 24,
-      loopMode: "none",
-      ...config.timeline
-    });
-    this.sequences.set(id, {
-      id,
-      name: nonEmpty(config.name, "Sequence name"),
-      controller: new TimelineEditorController({ timeline })
-    });
-    return this.sequenceSnapshot(this.requireSequence(id));
-  }
-
-  selectSequence(sequenceId: string): NonlinearAnimationEditorSnapshot {
-    this.activeSequenceId = this.requireSequence(sequenceId).id;
-    return this.snapshot();
-  }
-
-  async addTrack(kind: TimelineEditorTrackKind, name?: string, options: Omit<TimelineTrackConfig, "name" | "type"> = {}): Promise<string> {
-    const track = await this.activeSequence().controller.addTrack(kind, name, options);
-    return track.id;
-  }
-
-  async insertAssetClip(trackId: string, assetId: string, options: Omit<TimelineClipConfig, "name" | "startTime" | "duration" | "assetId" | "clipName"> & {
-    readonly id?: string | undefined;
-    readonly name?: string | undefined;
-    readonly startTime: number;
-    readonly duration?: number | undefined;
-  }): Promise<string> {
-    const asset = this.requireBinAsset(assetId);
-    const clip = await this.activeSequence().controller.addClip(trackId, {
-      ...options,
-      id: options.id ?? `${asset.id}-${Math.round(options.startTime * 1000)}`,
-      name: options.name ?? asset.name,
-      startTime: options.startTime,
-      duration: options.duration ?? asset.duration ?? 1,
-      assetId: asset.assetId ?? asset.id,
-      clipName: asset.clipName ?? asset.name,
-      properties: {
-        ...(options.properties ?? {}),
-        binAssetId: asset.id,
-        binAssetKind: asset.kind
-      }
-    });
-    return clip.id;
-  }
-
-  async insertNestedSequence(trackId: string, sequenceId: string, options: Omit<TimelineClipConfig, "name" | "startTime" | "duration"> & {
-    readonly id?: string | undefined;
-    readonly startTime: number;
-    readonly duration?: number | undefined;
-  }): Promise<string> {
-    const nested = this.requireSequence(sequenceId);
-    const clip = await this.activeSequence().controller.addClip(trackId, {
-      ...options,
-      id: options.id ?? `${sequenceId}-nested-${Math.round(options.startTime * 1000)}`,
-      name: nested.name,
-      startTime: options.startTime,
-      duration: options.duration ?? nested.controller.timeline.duration,
-      properties: {
-        ...(options.properties ?? {}),
-        nestedSequenceId: nested.id
-      }
-    });
-    return clip.id;
-  }
-
-  async moveClip(clipId: string, startTime: number): Promise<void> {
-    await this.activeSequence().controller.moveClip(clipId, startTime);
-  }
-
-  async trimClip(clipId: string, duration: number, startTime?: number): Promise<void> {
-    await this.activeSequence().controller.resizeClip(clipId, duration, startTime);
-  }
-
-  async splitClip(clipId: string, splitTime: number): Promise<readonly string[]> {
-    const clips = await this.activeSequence().controller.splitClip(clipId, splitTime);
-    return clips.map((clip) => clip.id);
-  }
-
-  async duplicateClip(clipId: string, timeOffset?: number): Promise<string> {
-    const clip = await this.activeSequence().controller.duplicateClip(clipId, timeOffset);
-    return clip.id;
-  }
-
-  serialize(): NonlinearAnimationEditorState {
-    return {
-      activeSequenceId: this.activeSequenceId,
-      binAssets: [...this.binAssets.values()],
-      sequences: [...this.sequences.values()].map((sequence) => ({
-        id: sequence.id,
-        name: sequence.name,
-        timeline: sequence.controller.serializeTimeline()
-      }))
-    };
-  }
-
-  snapshot(): NonlinearAnimationEditorSnapshot {
-    const sequences = [...this.sequences.values()];
-    const active = this.activeSequence();
-    const totalTrackCount = sequences.reduce((count, sequence) => count + sequence.controller.timeline.tracks.length, 0);
-    const totalClipCount = sequences.reduce((count, sequence) => count + sequence.controller.timeline.tracks.reduce((clipCount, track) => clipCount + track.clips.length, 0), 0);
-    const nestedSequenceClipCount = sequences.reduce((count, sequence) =>
-      count + sequence.controller.timeline.tracks.reduce((trackCount, track) =>
-        trackCount + track.clips.filter((clip) => typeof clip.properties.nestedSequenceId === "string").length, 0), 0);
-    return {
-      kind: "nonlinear-animation-editor",
-      activeSequenceId: active.id,
-      sequenceCount: sequences.length,
-      binAssetCount: this.binAssets.size,
-      nestedSequenceClipCount,
-      totalTrackCount,
-      totalClipCount,
-      sequences: sequences.map((sequence) => this.sequenceSnapshot(sequence)),
-      activeTimeline: active.controller.snapshot(),
-      evidence: {
-        nonlinearSequences: sequences.length > 1,
-        trimSplitMoveDuplicate: active.controller.history.canUndo || active.controller.history.canRedo,
-        nestedSequences: nestedSequenceClipCount > 0,
-        multiTrackTimeline: totalTrackCount > 1,
-        serialization: true
-      }
-    };
-  }
-
-  private activeSequence(): NonlinearSequenceRuntime {
-    return this.requireSequence(this.activeSequenceId);
-  }
-
-  private requireSequence(id: string): NonlinearSequenceRuntime {
-    const sequence = this.sequences.get(id);
-    if (!sequence) throw new Error(`Unknown nonlinear sequence: ${id}`);
-    return sequence;
-  }
-
-  private requireBinAsset(id: string): NonlinearBinAsset {
-    const asset = this.binAssets.get(id);
-    if (!asset) throw new Error(`Unknown nonlinear bin asset: ${id}`);
-    return asset;
-  }
-
-  private sequenceSnapshot(sequence: NonlinearSequenceRuntime): NonlinearSequenceSnapshot {
-    const timeline = sequence.controller.timeline;
-    return {
-      id: sequence.id,
-      name: sequence.name,
-      trackCount: timeline.tracks.length,
-      clipCount: timeline.tracks.reduce((count, track) => count + track.clips.length, 0),
-      duration: timeline.duration
-    };
-  }
-}
-
-export function createNonlinearAnimationEditor(state: NonlinearAnimationEditorState): NonlinearAnimationEditor {
-  return new NonlinearAnimationEditor(state);
-}
-
-function sanitizeBinAsset(asset: NonlinearBinAsset): NonlinearBinAsset {
-  if (asset.duration !== undefined && (!Number.isFinite(asset.duration) || asset.duration <= 0)) {
-    throw new Error(`Nonlinear bin asset "${asset.id}" duration must be positive when provided.`);
-  }
-  return {
-    id: nonEmpty(asset.id, "Bin asset id"),
-    name: nonEmpty(asset.name, "Bin asset name"),
-    kind: asset.kind,
-    assetId: asset.assetId,
-    clipName: asset.clipName,
-    duration: asset.duration,
-    metadata: asset.metadata
-  };
-}
-
-function nonEmpty(value: string, label: string): string {
-  const trimmed = value.trim();
-  if (!trimmed) throw new Error(`${label} must be a non-empty string.`);
-  return trimmed;
-}

package/src/PickingService.ts

@@ -1,174 +0,0 @@
-import type { Ray } from "@aura3d/math";
-import type { SceneNode } from "@aura3d/scene";
-
-type Tuple3 = readonly [number, number, number];
-
-export interface EditorPickTarget {
-  readonly id: string;
-  readonly node: SceneNode;
-  readonly bounds: {
-    readonly min: Tuple3;
-    readonly max: Tuple3;
-  };
-}
-
-export interface EditorPickHit {
-  readonly target: EditorPickTarget;
-  readonly distance: number;
-}
-
-export interface EditorPickingColorId {
-  readonly targetId: string;
-  readonly encodedId: number;
-  readonly color: readonly [number, number, number, number];
-}
-
-export interface EditorPickingEvidenceSnapshot {
-  readonly source: "origin-master-gpu-picking-adapted";
-  readonly registeredTargetCount: number;
-  readonly width: number;
-  readonly height: number;
-  readonly needsUpdate: boolean;
-  readonly idCapacity: number;
-  readonly sampleColorId: EditorPickingColorId | null;
-  readonly decodedSampleTargetId: string | null;
-  readonly colorIds: readonly EditorPickingColorId[];
-  readonly evidence: {
-    readonly colorIdEncoding: boolean;
-    readonly colorIdDecoding: boolean;
-    readonly framebufferResizeBoundary: boolean;
-    readonly raycastFallback: boolean;
-  };
-  readonly blockedClaims: readonly string[];
-}
-
-export class PickingService {
-  private readonly targets = new Map<string, EditorPickTarget>();
-  private width = 1024;
-  private height = 768;
-  private needsUpdate = true;
-
-  setTargets(targets: readonly EditorPickTarget[]): void {
-    this.targets.clear();
-    for (const target of targets) {
-      this.targets.set(target.id, target);
-    }
-    this.needsUpdate = true;
-  }
-
-  addTarget(target: EditorPickTarget): void {
-    this.targets.set(target.id, target);
-    this.needsUpdate = true;
-  }
-
-  removeTarget(id: string): void {
-    this.targets.delete(id);
-    this.needsUpdate = true;
-  }
-
-  pick(ray: Ray): EditorPickHit | undefined {
-    const hit = [...this.targets.values()]
-      .map((target) => ({ target, distance: intersectBounds(ray, target.bounds) }))
-      .filter((hit): hit is EditorPickHit => hit.distance !== undefined)
-      .sort((a, b) => a.distance - b.distance)[0];
-    this.needsUpdate = false;
-    return hit;
-  }
-
-  resizePickingBuffer(width: number, height: number): void {
-    if (!Number.isInteger(width) || !Number.isInteger(height) || width < 1 || height < 1) {
-      throw new RangeError("Picking buffer dimensions must be positive integers.");
-    }
-    this.width = width;
-    this.height = height;
-    this.needsUpdate = true;
-  }
-
-  invalidatePickingBuffer(): void {
-    this.needsUpdate = true;
-  }
-
-  colorIdForTarget(targetId: string): EditorPickingColorId | undefined {
-    const ids = this.colorIds();
-    return ids.find((entry) => entry.targetId === targetId);
-  }
-
-  targetIdFromColor(color: readonly [number, number, number] | readonly [number, number, number, number]): string | undefined {
-    const encodedId = PickingService.colorToId(color[0] ?? 0, color[1] ?? 0, color[2] ?? 0);
-    const entry = this.colorIds().find((candidate) => candidate.encodedId === encodedId);
-    return entry?.targetId;
-  }
-
-  snapshot(): EditorPickingEvidenceSnapshot {
-    const colorIds = this.colorIds();
-    const sampleColorId = colorIds[0] ?? null;
-    const decodedSampleTargetId = sampleColorId ? this.targetIdFromColor(sampleColorId.color) ?? null : null;
-    return {
-      source: "origin-master-gpu-picking-adapted",
-      registeredTargetCount: this.targets.size,
-      width: this.width,
-      height: this.height,
-      needsUpdate: this.needsUpdate,
-      idCapacity: 0xffffff,
-      sampleColorId,
-      decodedSampleTargetId,
-      colorIds,
-      evidence: {
-        colorIdEncoding: colorIds.every((entry) => entry.color[3] === 255 && entry.encodedId >= 1),
-        colorIdDecoding: sampleColorId !== null && decodedSampleTargetId === sampleColorId.targetId,
-        framebufferResizeBoundary: this.width > 0 && this.height > 0,
-        raycastFallback: true
-      },
-      blockedClaims: [
-        "production GPU framebuffer picking pass",
-        "depth-buffer world-position reconstruction",
-        "GPU picking performance parity with Unity Scene View",
-        "GPU picking performance parity with Unreal Editor viewport"
-      ]
-    };
-  }
-
-  static idToColor(id: number): readonly [number, number, number, number] {
-    if (!Number.isInteger(id) || id < 1 || id > 0xffffff) {
-      throw new RangeError("Picking color id must be an integer in the 1..16777215 range.");
-    }
-    return [id & 0xff, (id >> 8) & 0xff, (id >> 16) & 0xff, 255];
-  }
-
-  static colorToId(red: number, green: number, blue: number): number {
-    return (red & 0xff) | ((green & 0xff) << 8) | ((blue & 0xff) << 16);
-  }
-
-  private colorIds(): readonly EditorPickingColorId[] {
-    return [...this.targets.keys()].map((targetId, index) => {
-      const encodedId = index + 1;
-      return { targetId, encodedId, color: PickingService.idToColor(encodedId) };
-    });
-  }
-}
-
-function intersectBounds(ray: Ray, bounds: EditorPickTarget["bounds"]): number | undefined {
-  let tmin = Number.NEGATIVE_INFINITY;
-  let tmax = Number.POSITIVE_INFINITY;
-
-  for (const axis of [0, 1, 2] as const) {
-    const origin = axis === 0 ? ray.origin.x : axis === 1 ? ray.origin.y : ray.origin.z;
-    const direction = axis === 0 ? ray.direction.x : axis === 1 ? ray.direction.y : ray.direction.z;
-    const min = bounds.min[axis];
-    const max = bounds.max[axis];
-    if (Math.abs(direction) < 1e-8) {
-      if (origin < min || origin > max) return undefined;
-      continue;
-    }
-    const invD = 1 / direction;
-    let near = (min - origin) * invD;
-    let far = (max - origin) * invD;
-    if (near > far) [near, far] = [far, near];
-    tmin = Math.max(tmin, near);
-    tmax = Math.min(tmax, far);
-    if (tmin > tmax) return undefined;
-  }
-
-  const distance = tmin >= 0 ? tmin : tmax;
-  return distance >= 0 ? distance : undefined;
-}

package/src/PlayModeBridge.ts

@@ -1,27 +0,0 @@
-export interface SnapshotAdapter<T> {
-  capture(): T;
-  restore(snapshot: T): void;
-}
-
-export class PlayModeBridge<TSnapshot> {
-  private snapshot?: TSnapshot;
-
-  constructor(private readonly adapter: SnapshotAdapter<TSnapshot>) {}
-
-  enter(): void {
-    if (this.snapshot !== undefined) {
-      throw new Error("Play mode is already active");
-    }
-    this.snapshot = this.adapter.capture();
-  }
-
-  exit({ restore = true } = {}): void {
-    if (this.snapshot === undefined) {
-      return;
-    }
-    if (restore) {
-      this.adapter.restore(this.snapshot);
-    }
-    this.snapshot = undefined;
-  }
-}

package/src/PrefabRegistry.ts

@@ -1,164 +0,0 @@
-export type EditorPrefabSchemaVersion = "aura3d-prefab";
-
-export interface EditorPrefabNodeBase {
-  readonly id: string;
-  readonly name: string;
-  readonly parentId: string | null;
-}
-
-export interface EditorPrefab<TNode extends EditorPrefabNodeBase = EditorPrefabNodeBase> {
-  readonly schemaVersion: EditorPrefabSchemaVersion;
-  readonly id: string;
-  readonly name: string;
-  readonly rootNodeId: string;
-  readonly sourceNodeId?: string;
-  readonly createdAt: string;
-  readonly nodes: readonly TNode[];
-}
-
-export interface CreatePrefabOptions<TNode extends EditorPrefabNodeBase> {
-  readonly id: string;
-  readonly name: string;
-  readonly rootNodeId: string;
-  readonly sourceNodeId?: string;
-  readonly createdAt?: string;
-  readonly nodes: readonly TNode[];
-}
-
-export interface InstantiatePrefabOptions {
-  readonly idPrefix: string;
-  readonly rootParentId?: string | null;
-  readonly nameSuffix?: string;
-}
-
-export class PrefabRegistry<TNode extends EditorPrefabNodeBase = EditorPrefabNodeBase> {
-  private readonly prefabsById = new Map<string, EditorPrefab<TNode>>();
-
-  create(options: CreatePrefabOptions<TNode>): EditorPrefab<TNode> {
-    const prefab: EditorPrefab<TNode> = {
-      schemaVersion: "aura3d-prefab",
-      id: normalizeId(options.id, "prefab id"),
-      name: normalizeName(options.name, "prefab name"),
-      rootNodeId: normalizeId(options.rootNodeId, "prefab rootNodeId"),
-      ...(options.sourceNodeId ? { sourceNodeId: normalizeId(options.sourceNodeId, "prefab sourceNodeId") } : {}),
-      createdAt: options.createdAt ?? new Date().toISOString(),
-      nodes: options.nodes.map((node) => cloneNode(node))
-    };
-    validatePrefab(prefab);
-    return prefab;
-  }
-
-  register(prefab: EditorPrefab<TNode>): EditorPrefab<TNode> {
-    validatePrefab(prefab);
-    if (this.prefabsById.has(prefab.id)) {
-      throw new Error(`Prefab already registered: ${prefab.id}`);
-    }
-    const cloned = clonePrefab(prefab);
-    this.prefabsById.set(cloned.id, cloned);
-    return cloned;
-  }
-
-  upsert(prefab: EditorPrefab<TNode>): EditorPrefab<TNode> {
-    validatePrefab(prefab);
-    const cloned = clonePrefab(prefab);
-    this.prefabsById.set(cloned.id, cloned);
-    return cloned;
-  }
-
-  get(id: string): EditorPrefab<TNode> | undefined {
-    const prefab = this.prefabsById.get(id);
-    return prefab ? clonePrefab(prefab) : undefined;
-  }
-
-  list(): readonly EditorPrefab<TNode>[] {
-    return [...this.prefabsById.values()].map((prefab) => clonePrefab(prefab));
-  }
-
-  remove(id: string): boolean {
-    return this.prefabsById.delete(id);
-  }
-
-  clear(): void {
-    this.prefabsById.clear();
-  }
-
-  instantiate(prefabOrId: EditorPrefab<TNode> | string, options: InstantiatePrefabOptions): readonly TNode[] {
-    const prefab = typeof prefabOrId === "string" ? this.get(prefabOrId) : clonePrefab(prefabOrId);
-    if (!prefab) {
-      throw new Error(`Unknown prefab: ${prefabOrId}`);
-    }
-    validatePrefab(prefab);
-    const idPrefix = normalizeId(options.idPrefix, "prefab instance idPrefix");
-    const idMap = new Map(prefab.nodes.map((node) => [node.id, `${idPrefix}-${node.id}`]));
-    const rootParentId = options.rootParentId ?? null;
-    const nameSuffix = options.nameSuffix ?? " Instance";
-    return prefab.nodes.map((node) => {
-      const cloned = cloneNode(node);
-      const remappedParent = node.id === prefab.rootNodeId
-        ? rootParentId
-        : node.parentId ? idMap.get(node.parentId) ?? null : null;
-      return {
-        ...cloned,
-        id: idMap.get(node.id)!,
-        name: `${node.name}${nameSuffix}`,
-        parentId: remappedParent
-      };
-    });
-  }
-}
-
-export function validatePrefab<TNode extends EditorPrefabNodeBase>(prefab: EditorPrefab<TNode>): void {
-  if (prefab.schemaVersion !== "aura3d-prefab") {
-    throw new Error(`Unsupported prefab schemaVersion: ${String(prefab.schemaVersion)}`);
-  }
-  normalizeId(prefab.id, "prefab id");
-  normalizeName(prefab.name, "prefab name");
-  normalizeId(prefab.rootNodeId, "prefab rootNodeId");
-  if (prefab.nodes.length === 0) {
-    throw new Error("Prefab must contain at least one node.");
-  }
-  const ids = new Set<string>();
-  for (const node of prefab.nodes) {
-    normalizeId(node.id, "prefab node id");
-    normalizeName(node.name, "prefab node name");
-    if (ids.has(node.id)) {
-      throw new Error(`Prefab node id is duplicated: ${node.id}`);
-    }
-    ids.add(node.id);
-  }
-  if (!ids.has(prefab.rootNodeId)) {
-    throw new Error(`Prefab rootNodeId ${prefab.rootNodeId} is not present in nodes.`);
-  }
-  for (const node of prefab.nodes) {
-    if (node.parentId !== null && !ids.has(node.parentId)) {
-      throw new Error(`Prefab node ${node.id} references external parent ${node.parentId}`);
-    }
-  }
-}
-
-function clonePrefab<TNode extends EditorPrefabNodeBase>(prefab: EditorPrefab<TNode>): EditorPrefab<TNode> {
-  return {
-    ...prefab,
-    nodes: prefab.nodes.map((node) => cloneNode(node))
-  };
-}
-
-function cloneNode<TNode extends EditorPrefabNodeBase>(node: TNode): TNode {
-  return JSON.parse(JSON.stringify(node)) as TNode;
-}
-
-function normalizeId(value: string, label: string): string {
-  const normalized = value.trim();
-  if (!/^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(normalized)) {
-    throw new Error(`${label} must be a non-empty stable id.`);
-  }
-  return normalized;
-}
-
-function normalizeName(value: string, label: string): string {
-  const normalized = value.trim();
-  if (normalized.length === 0) {
-    throw new Error(`${label} cannot be empty.`);
-  }
-  return normalized;
-}