@haiyue/extensions 0.1.0 → 0.2.0

package/src/animation3d/Animation3DResource.ts

@@ -1,49 +0,0 @@
-import type {
-  AssetHandle,
-  AssetJobPriority,
-  AssetOwnerScope,
-} from '@haiyue/engine/assets';
-import type { Animation3DClip } from './Animation3DClip';
-import type {
-  Animation3DStateMachineDefinition,
-} from './Animation3DStateMachine';
-
-export type Animation3DClipHandle =
-  AssetHandle<Animation3DClip>;
-
-export type Animation3DStateMachineHandle =
-  AssetHandle<Animation3DStateMachineDefinition>;
-
-export type Animation3DResourceSource =
-  | Readonly<{
-      kind: 'url';
-      url: string;
-      cacheKey?: string;
-    }>
-  | Readonly<{
-      kind: 'buffer';
-      data: ArrayBuffer;
-      /** Required because ArrayBuffer identity is not a persistent cache key. */
-      cacheKey: string;
-    }>;
-
-export interface Animation3DResourceLoadOptions {
-  readonly signal?: AbortSignal;
-  readonly owner?: AssetOwnerScope;
-  readonly priority?: AssetJobPriority | number;
-}
-
-/**
- * Contract for an AssetManager-backed loader. Implementations must return a
- * distinct handle per acquisition and make handle.release() idempotent.
- */
-export interface Animation3DResourceLoader {
-  loadClip(
-    source: Animation3DResourceSource,
-    options?: Animation3DResourceLoadOptions,
-  ): Promise<Animation3DClipHandle>;
-  loadStateMachine(
-    source: Animation3DResourceSource,
-    options?: Animation3DResourceLoadOptions,
-  ): Promise<Animation3DStateMachineHandle>;
-}

package/src/animation3d/Animation3DStateMachine.ts

@@ -1,126 +0,0 @@
-import type { Animation3DBindingMask } from './Animation3DBinding.js';
-import type {
-  Animation3DBlendMode,
-  Animation3DLoopMode,
-} from './Animation3DAction.js';
-
-export type Animation3DParameterDefinition =
-  | Readonly<{
-      name: string;
-      type: 'float';
-      defaultValue: number;
-    }>
-  | Readonly<{
-      name: string;
-      type: 'integer';
-      defaultValue: number;
-    }>
-  | Readonly<{
-      name: string;
-      type: 'boolean';
-      defaultValue: boolean;
-    }>
-  | Readonly<{
-      name: string;
-      type: 'trigger';
-    }>;
-
-export type Animation3DTransitionCondition =
-  | Readonly<{
-      parameter: string;
-      operator: 'greater' | 'greater-or-equal' | 'less' | 'less-or-equal';
-      value: number;
-    }>
-  | Readonly<{
-      parameter: string;
-      operator: 'equal' | 'not-equal';
-      value: number | boolean;
-    }>
-  | Readonly<{
-      parameter: string;
-      operator: 'is-true' | 'is-false' | 'triggered';
-    }>;
-
-export interface Animation3DClipMotion {
-  readonly kind: 'clip';
-  readonly clipId: string;
-}
-
-export interface Animation3DBlend1DChild {
-  readonly threshold: number;
-  readonly motion: Animation3DMotionDefinition;
-}
-
-export interface Animation3DBlend1DMotion {
-  readonly kind: 'blend-1d';
-  readonly parameter: string;
-  readonly children: readonly Animation3DBlend1DChild[];
-}
-
-export interface Animation3DBlend2DChild {
-  readonly position: readonly [number, number];
-  readonly motion: Animation3DMotionDefinition;
-}
-
-export interface Animation3DBlend2DMotion {
-  readonly kind: 'blend-2d';
-  readonly algorithm: 'cartesian' | 'directional';
-  readonly parameterX: string;
-  readonly parameterY: string;
-  readonly children: readonly Animation3DBlend2DChild[];
-}
-
-export type Animation3DMotionDefinition =
-  | Animation3DClipMotion
-  | Animation3DBlend1DMotion
-  | Animation3DBlend2DMotion;
-
-export interface Animation3DStateDefinition {
-  readonly id: string;
-  readonly name: string;
-  readonly motion: Animation3DMotionDefinition;
-  readonly speed?: number;
-  readonly speedParameter?: string;
-  readonly loop?: Animation3DLoopMode;
-}
-
-export type Animation3DTransitionInterruption =
-  | 'none'
-  | 'source'
-  | 'destination'
-  | 'source-then-destination'
-  | 'destination-then-source';
-
-export interface Animation3DTransitionDefinition {
-  readonly id: string;
-  /** '*' means any state in the same layer. */
-  readonly from: string | '*';
-  readonly to: string;
-  readonly conditions: readonly Animation3DTransitionCondition[];
-  readonly duration: number;
-  readonly hasExitTime?: boolean;
-  readonly exitTime?: number;
-  readonly destinationOffset?: number;
-  readonly interruption?: Animation3DTransitionInterruption;
-}
-
-export interface Animation3DStateMachineLayer {
-  readonly id: string;
-  readonly name: string;
-  readonly initialStateId: string;
-  readonly states: readonly Animation3DStateDefinition[];
-  /** Declaration order is transition priority. */
-  readonly transitions: readonly Animation3DTransitionDefinition[];
-  readonly blendMode?: Animation3DBlendMode;
-  readonly weight?: number;
-  readonly mask?: Animation3DBindingMask;
-}
-
-/** Serializable definition; controller state is always stored separately. */
-export interface Animation3DStateMachineDefinition {
-  readonly format: 'haiyue-animation3d-state-machine@1';
-  readonly id: string;
-  readonly name: string;
-  readonly parameters: readonly Animation3DParameterDefinition[];
-  readonly layers: readonly Animation3DStateMachineLayer[];
-}

package/src/animation3d/Animation3DStateMachineRuntime.ts

@@ -1,191 +0,0 @@
-import type { Animation3DClip } from './Animation3DClip.js';
-import { Animation3DMixer } from './Animation3DMixer.js';
-import {
-  animation3DMixerRuntime,
-} from './runtime/mixer/Animation3DMixerRuntimeStore.js';
-import type {
-  Animation3DMutablePose,
-  Animation3DPose,
-} from './Animation3DPose.js';
-import type { Animation3DStateMachineDefinition } from './Animation3DStateMachine.js';
-import {
-  compileAnimation3DStateMachineDefinition as compileInternalDefinition,
-  validateAnimation3DStateMachineDefinition as validateInternalDefinition,
-  type CompiledAnimation3DStateMachine as InternalCompiledStateMachine,
-} from './runtime/state-machine/Animation3DStateMachineCompiler.js';
-import {
-  Animation3DStateMachineMixerIntegration,
-} from './runtime/integration/Animation3DStateMachineMixerIntegration.js';
-
-declare const COMPILED_ANIMATION3D_STATE_MACHINE: unique symbol;
-
-/**
- * Opaque compiler output. Compiled nodes and lookup tables are deliberately
- * hidden so validation/compiler internals can evolve without expanding the
- * facade.
- */
-export interface Animation3DCompiledStateMachine {
-  readonly format: 'haiyue-animation-state-machine-compiled@1';
-  readonly id: string;
-  readonly name: string;
-  readonly [COMPILED_ANIMATION3D_STATE_MACHINE]: true;
-}
-
-export type Animation3DStateMachineValidationCode =
-  | 'invalid-value'
-  | 'duplicate-id'
-  | 'missing-reference'
-  | 'parameter-type-mismatch'
-  | 'invalid-operator'
-  | 'empty-blend-tree'
-  | 'invalid-thresholds'
-  | 'recursive-motion';
-
-export interface Animation3DStateMachineValidationIssue {
-  readonly code: Animation3DStateMachineValidationCode;
-  readonly path: string;
-  readonly message: string;
-}
-
-export class Animation3DStateMachineValidationError extends Error {
-  readonly issues: readonly Animation3DStateMachineValidationIssue[];
-
-  constructor(issues: readonly Animation3DStateMachineValidationIssue[]) {
-    super(
-      `Invalid Animation3D state-machine definition (${issues.length} ${
-        issues.length === 1 ? 'issue' : 'issues'
-      }).`,
-    );
-    this.name = 'Animation3DStateMachineValidationError';
-    this.issues = Object.freeze([...issues]);
-  }
-}
-
-export function validateAnimation3DStateMachineDefinition(
-  definition: Animation3DStateMachineDefinition,
-): readonly Animation3DStateMachineValidationIssue[] {
-  return validateInternalDefinition(definition);
-}
-
-export function compileAnimation3DStateMachineDefinition(
-  definition: Animation3DStateMachineDefinition,
-): Animation3DCompiledStateMachine {
-  const issues = validateAnimation3DStateMachineDefinition(definition);
-  if (issues.length > 0) {
-    throw new Animation3DStateMachineValidationError(issues);
-  }
-  return compileInternalDefinition(definition) as unknown as Animation3DCompiledStateMachine;
-}
-
-export interface Animation3DStateMachineClipResolver {
-  resolve(clipId: string): Animation3DClip | null;
-}
-
-export interface Animation3DStateMachineControllerOptions {
-  readonly maxTransitionsPerUpdate?: number;
-}
-
-export type Animation3DStateMachineControllerStatus =
-  | 'active'
-  | 'destroyed';
-
-export interface Animation3DStateMachineLayerSnapshot {
-  readonly layerId: string;
-  readonly currentStateId: string;
-  readonly currentTime: number;
-  readonly transitionId: string | null;
-  readonly sourceStateId: string | null;
-  readonly destinationStateId: string | null;
-  readonly transitionProgress: number;
-}
-
-/**
- * Public closed-loop controller and minimal Mixer integration.
- *
- * The internal mixer port, action handles, controller transactions and
- * compiled nodes never cross this boundary.
- */
-export class Animation3DStateMachineController {
-  readonly mixer: Animation3DMixer;
-
-  #integration: Animation3DStateMachineMixerIntegration;
-
-  constructor(
-    compiled: Animation3DCompiledStateMachine,
-    mixer: Animation3DMixer,
-    clipResolver: Animation3DStateMachineClipResolver,
-    options: Animation3DStateMachineControllerOptions = {},
-  ) {
-    this.mixer = mixer;
-    this.#integration = new Animation3DStateMachineMixerIntegration(
-      compiled as unknown as InternalCompiledStateMachine,
-      animation3DMixerRuntime(mixer),
-      clipResolver,
-      options,
-    );
-  }
-
-  get status(): Animation3DStateMachineControllerStatus {
-    return this.#integration.state;
-  }
-
-  get time(): number {
-    return this.#integration.time;
-  }
-
-  get layerSnapshots(): readonly Animation3DStateMachineLayerSnapshot[] {
-    return this.#integration.controller.layerSnapshots;
-  }
-
-  getLayerSnapshot(layerId: string): Animation3DStateMachineLayerSnapshot {
-    return this.#integration.controller.getLayerSnapshot(layerId);
-  }
-
-  setFloat(name: string, value: number): this {
-    this.#integration.controller.setFloat(name, value);
-    return this;
-  }
-
-  setInteger(name: string, value: number): this {
-    this.#integration.controller.setInteger(name, value);
-    return this;
-  }
-
-  setBoolean(name: string, value: boolean): this {
-    this.#integration.controller.setBoolean(name, value);
-    return this;
-  }
-
-  setTrigger(name: string): this {
-    this.#integration.controller.setTrigger(name);
-    return this;
-  }
-
-  resetTrigger(name: string): this {
-    this.#integration.controller.resetTrigger(name);
-    return this;
-  }
-
-  getParameter(name: string): number | boolean {
-    return this.#integration.controller.getParameter(name);
-  }
-
-  update(
-    deltaSeconds: number,
-    out: Animation3DMutablePose,
-  ): Animation3DPose {
-    return this.#integration.update(deltaSeconds, out);
-  }
-
-  evaluate(out: Animation3DMutablePose): Animation3DPose {
-    return this.#integration.evaluate(out);
-  }
-
-  reset(out: Animation3DMutablePose): Animation3DPose {
-    return this.#integration.reset(out);
-  }
-
-  destroy(): void {
-    this.#integration.destroy();
-  }
-}

package/src/animation3d/Animation3DTrack.ts

@@ -1,29 +0,0 @@
-import type {
-  Animation3DBinding,
-} from './Animation3DBinding';
-
-export type Animation3DInterpolation =
-  | 'step'
-  | 'linear'
-  | 'cubic-spline';
-
-export interface Animation3DTrackFor<
-  TBinding extends Animation3DBinding,
-> {
-  readonly id: string;
-  readonly binding: TBinding;
-  readonly interpolation: Animation3DInterpolation;
-  /**
-   * Strictly increasing key times in seconds.
-   * The clip resource owns the underlying storage; consumers must not mutate it.
-   */
-  readonly times: Readonly<Float32Array>;
-  /**
-   * step/linear: keyCount * binding.valueSize values.
-   * cubic-spline: keyCount groups of [inTangent, value, outTangent], with each
-   * entry containing binding.valueSize values.
-   */
-  readonly values: Readonly<Float32Array>;
-}
-
-export type Animation3DTrack = Animation3DTrackFor<Animation3DBinding>;