@hology/core 0.0.188 → 0.0.191

package/dist/effects/sequence/audio-parameters.d.ts

@@ -0,0 +1,25 @@
+export type AudioParameterId = 'volume' | 'detune' | 'pan' | 'spatialBlend' | 'lowpass' | 'highpass';
+export interface AudioParameterDefinition {
+    id: AudioParameterId;
+    /** Name shown in the track list */
+    displayName: string;
+    /** Label shown for the animated keyframe value */
+    valueLabel: string;
+    /** Short, artist-friendly help text shown in the editor tooltip */
+    helpText: string;
+    /** Optional unit suffix (purely descriptive, not used for formatting) */
+    unit?: string;
+    /** Default keyframe value when adding a keyframe to this sub-track */
+    defaultValue: number;
+    /** Default drag step size in the editor */
+    step: number;
+    /**
+     * Hard bounds for this parameter (if present, editor may clamp and runtime may clamp).
+     * For filters these simply constrain cutoff to a sensible range.
+     */
+    min?: number;
+    max?: number;
+}
+export declare const AUDIO_PARAMETER_DEFINITIONS: Record<AudioParameterId, AudioParameterDefinition>;
+export declare function getAudioParameterDefinition(id: AudioParameterId): AudioParameterDefinition;
+//# sourceMappingURL=audio-parameters.d.ts.map

package/dist/effects/sequence/audio-parameters.js

@@ -0,0 +1,4 @@
+export const AUDIO_PARAMETER_DEFINITIONS={volume:{id:"volume",displayName:"Volume",valueLabel:"Volume",helpText:"Loudness multiplier (0 = silent, 1 = original). Use keyframes to fade, duck, or punch accents over time.",defaultValue:1,step:.01,min:0,max:1},detune:{id:"detune",displayName:"Detune",valueLabel:"Detune (cents)",helpText:"Pitch offset in cents (100 = one semitone). Great for pitch ramps, wobble, or subtle variation; use small values for realism.",defaultValue:0,step:1},pan:{id:"pan",displayName:"Pan",valueLabel:"Pan",helpText:"Stereo left/right for non-spatial audio (-1 = left, 0 = center, 1 = right). Only applies when Spatial Audio is OFF. Use for UI/2D sounds or stylized sweeps.",defaultValue:0,step:.01,min:-1,max:1},spatialBlend:{id:"spatialBlend",displayName:"Spatial Blend",valueLabel:"Spatial Blend",helpText:"Requires Spatial Audio enabled on the track. 0 = sound is pulled to the listener (centered/2D-ish). 1 = fully positional in world. Useful for “cheating” SFX toward camera.",defaultValue:0,step:.01,min:0,max:1},lowpass:{id:"lowpass",displayName:"Low Pass Filter",valueLabel:"Cutoff (Hz)",helpText:"Lets low frequencies through and reduces highs. Lower cutoff = more “muffled/underwater/behind wall”. Typical: ~200–8000 Hz.",unit:"Hz",defaultValue:2e4,step:10,min:20,max:2e4},highpass:{id:"highpass",displayName:"High Pass Filter",valueLabel:"Cutoff (Hz)",helpText:"Lets high frequencies through and reduces lows. Higher cutoff = thinner/brighter/telephone. Typical: ~20–500 Hz (subtle), 1k+ (stylized).",unit:"Hz",defaultValue:20,step:10,min:20,max:2e4}};export function getAudioParameterDefinition(e){return AUDIO_PARAMETER_DEFINITIONS[e]}/*
+ * Copyright (©) 2026 Hology Interactive AB. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/effects/sequence/index.d.ts

@@ -0,0 +1,8 @@
+export * from './sequence-data.js';
+export * from './sequence-event.js';
+export * from './sequence-player.js';
+export * from './sequence-actor.js';
+export * from './sequencer.js';
+export * from './sequence-action.js';
+export * from './audio-parameters.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/effects/sequence/index.js

@@ -0,0 +1,4 @@
+export*from"./sequence-data.js";export*from"./sequence-event.js";export*from"./sequence-player.js";export*from"./sequence-actor.js";export*from"./sequencer.js";export*from"./sequence-action.js";export*from"./audio-parameters.js";/*
+ * Copyright (©) 2026 Hology Interactive AB. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/effects/sequence/sequence-action.d.ts

@@ -0,0 +1,17 @@
+import { SequenceRole } from './sequence-data.js';
+import { BaseActor } from '../../gameplay/actors/actor.js';
+import { Object3D } from 'three';
+/**
+ * SequenceAction is used to play, pause, stop, etc. a sequence.
+ */
+export interface SequenceAction {
+    /** Bind a role to a runtime target for dynamic actor binding */
+    bindRole(role: SequenceRole, target: BaseActor | Object3D): void;
+    play(): void;
+    pause(): void;
+    stop(): void;
+    restart(): void;
+    seek(time: number): void;
+    dispose(): void;
+}
+//# sourceMappingURL=sequence-action.d.ts.map

package/dist/effects/sequence/sequence-action.js

@@ -0,0 +1,4 @@
+export{};/*
+ * Copyright (©) 2026 Hology Interactive AB. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/effects/sequence/sequence-actor.d.ts

@@ -0,0 +1,135 @@
+import { BaseActor } from '../../gameplay/actors/actor.js';
+import { SequenceData, SequenceRole } from './sequence-data.js';
+import { SequencePlaybackState } from './sequence-player.js';
+import { Asset } from '../../scene/model.js';
+import { Subject } from 'rxjs';
+import { Object3D } from 'three';
+import { SequenceAction } from './sequence-action.js';
+/**
+ * SequenceActor is an actor that plays a sequence in the world.
+ *
+ * Similar to VfxActor, it can be placed in a scene for cinematics or
+ * used programmatically for player abilities and gameplay sequences.
+ *
+ * The sequence data can be:
+ * 1. Inline data stored directly on the actor (for one-off scene-specific sequences)
+ * 2. Loaded from a SequenceAsset (for reusable sequences like abilities)
+ *
+ * @example
+ * // Place in scene as cinematic
+ * // Configure sequence data in the editor's sequence panel
+ *
+ * @example
+ * // Use in code for player ability
+ * const sequence = await actorFactory.create(SequenceActor)
+ * sequence.loadFromAssetId('my-ability-sequence')
+ * sequence.bindRole(SequenceRole.Self, playerActor)
+ * sequence.play()
+ */
+export declare class SequenceActor extends BaseActor implements SequenceAction {
+    /**
+     * Inline sequence data - stored directly on the actor.
+     * This is used for scene-specific sequences that aren't reused.
+     */
+    sequenceData: SequenceData;
+    /**
+     * Optional reference to a sequence asset for reusable sequences.
+     * If set, this takes precedence over inline sequenceData.
+     */
+    sequenceAssetId: string | null;
+    /**
+     * Playback rate multiplier
+     */
+    get timescale(): number;
+    set timescale(value: number);
+    /**
+     * Whether the sequence loops
+     */
+    get loop(): boolean;
+    set loop(value: boolean);
+    /**
+     * Current playback state
+     */
+    get state(): SequencePlaybackState;
+    /**
+     * Current playback time in seconds
+     */
+    get time(): number;
+    /**
+     * Total duration of the sequence
+     */
+    get duration(): number;
+    /**
+     * Whether playback is currently paused
+     */
+    get paused(): boolean;
+    /**
+     * When true, the player will not advance time internally.
+     * Time must be controlled externally via seek().
+     * This is useful for editor preview where the UI controls playback position.
+     */
+    get externalTimeControl(): boolean;
+    set externalTimeControl(value: boolean);
+    readonly onComplete: Subject<void>;
+    readonly onLoop: Subject<number>;
+    private player;
+    private viewController;
+    private assetLoader;
+    private world;
+    private actorFactory;
+    private vfxService;
+    private sourceAsset;
+    onInit(): Promise<void>;
+    /**
+     * Load sequence data from an asset
+     */
+    loadFromAsset(asset: Asset): Promise<void>;
+    /**
+     * Load sequence data from an asset ID
+     */
+    loadFromAssetId(assetId: string): Promise<void>;
+    /**
+     * Update inline sequence data directly
+     */
+    setSequenceData(data: SequenceData): void;
+    /**
+     * Bind a role to a runtime target.
+     * This allows tracks with a role to target a different actor at runtime.
+     *
+     * @example
+     * sequenceActor.bindRole(SequenceRole.Self, playerActor)
+     * sequenceActor.bindRole(SequenceRole.Target, enemyActor)
+     */
+    bindRole(role: SequenceRole, target: BaseActor | Object3D): void;
+    /**
+     * Bind a scene object by ID to a target
+     */
+    bindObject(objectId: string, target: Object3D | BaseActor): void;
+    /**
+     * Start or resume playback
+     */
+    play(): void;
+    /**
+     * Pause playback
+     */
+    pause(): void;
+    /**
+     * Stop playback and reset to beginning
+     */
+    stop(): void;
+    /**
+     * Restart playback from the beginning
+     */
+    restart(): void;
+    /**
+     * Seek to a specific time
+     */
+    seek(time: number): void;
+    /**
+     * Update the sequence (called automatically from render loop)
+     */
+    onUpdate(deltaTime: number): void;
+    onEndPlay(): void;
+    dispose(): void;
+}
+//# sourceMappingURL=sequence-actor.d.ts.map

package/dist/effects/sequence/sequence-actor.js

@@ -0,0 +1,4 @@
+import{__decorate as e,__metadata as t}from"tslib";import{Actor as s,BaseActor as r}from"../../gameplay/actors/actor.js";import{inject as a}from"../../gameplay/inject.js";import{ViewController as i}from"../../gameplay/services/render.js";import{AssetLoader as o}from"../../gameplay/services/asset-loader.js";import{World as l}from"../../gameplay/services/world.js";import{ActorFactory as p}from"../../gameplay/actors/factory.js";import{VfxService as n}from"../../effects/vfx/vfx-service.js";import{Parameter as h}from"../../shader/parameter.js";import{createSequenceData as c}from"./sequence-data.js";import{SequencePlayer as y,SequencePlaybackState as d}from"./sequence-player.js";import{Subject as m,takeUntil as u}from"rxjs";let f=class extends r{constructor(){super(...arguments),this.sequenceData=c(),this.sequenceAssetId=null,this.onComplete=new m,this.onLoop=new m,this.player=new y,this.viewController=a(i),this.assetLoader=a(o),this.world=a(l),this.actorFactory=a(p),this.vfxService=a(n),this.sourceAsset=null}get timescale(){return this.player.timescale}set timescale(e){this.player.timescale=e}get loop(){return this.player.loop}set loop(e){this.player.loop=e}get state(){return this.player.state}get time(){return this.player.time}get duration(){return this.player.duration}get paused(){return this.player.state===d.Paused}get externalTimeControl(){return this.player.externalTimeControl}set externalTimeControl(e){this.player.externalTimeControl=e}async onInit(){this.player.setWorld(this.world),this.player.setAudioListener(this.viewController.audioListener),this.player.setAssetLoader(this.assetLoader),this.player.setActorFactory(this.actorFactory),this.player.setVfxService(this.vfxService),this.viewController.onUpdate(this).pipe(u(this.disposed)).subscribe(e=>this.player.update(e)),this.player.onComplete.pipe(u(this.disposed)).subscribe(()=>this.onComplete.next()),this.player.onLoop.pipe(u(this.disposed)).subscribe(e=>this.onLoop.next(e)),this.sequenceAssetId?await this.loadFromAssetId(this.sequenceAssetId):this.sequenceData&&this.player.load(this.sequenceData)}async loadFromAsset(e){if("sequence"!==e.type)throw new Error(`Asset must be a sequence asset but is ${e.type}`);this.sourceAsset=e,this.sourceAsset.sequence&&(this.sequenceData=this.sourceAsset.sequence,this.player.load(this.sequenceData))}async loadFromAssetId(e){const t=await this.assetLoader.getAsset(e);t&&await this.loadFromAsset(t)}setSequenceData(e){this.sequenceData=e,this.player.load(e)}bindRole(e,t){this.player.bindRole(e,t)}bindObject(e,t){this.player.bindObject(e,t)}play(){this.player.play()}pause(){this.player.pause()}stop(){this.player.stop()}restart(){this.player.restart()}seek(e){this.player.seek(e)}onUpdate(e){}onEndPlay(){this.player.dispose()}dispose(){this.world.removeActor(this)}};e([h({label:"Sequence Data"}),t("design:type",Object)],f.prototype,"sequenceData",void 0),f=e([s()],f);export{f as SequenceActor};/*
+ * Copyright (©) 2026 Hology Interactive AB. All rights reserved.
+ * See the LICENSE.md file for details.
+ */

package/dist/effects/sequence/sequence-data.d.ts

@@ -0,0 +1,458 @@
+import { AssetId, CustomParamValue, SerializedParamType } from '../../scene/model.js';
+import { AudioParameterId } from './audio-parameters.js';
+/**
+ * The main sequence data structure containing all tracks and playback settings.
+ * This is stored as a parameter on SequenceActor or as part of a SequenceAsset.
+ */
+export interface SequenceData {
+    /** Total duration of the sequence in seconds */
+    duration: number;
+    /** Whether the sequence should loop */
+    loop: boolean;
+    /** Playback rate multiplier (default 1.0) */
+    playbackRate: number;
+    /** All tracks in this sequence */
+    tracks: SequenceTrack[];
+}
+export declare class Sequence {
+    data: SequenceData;
+    constructor(data: SequenceData);
+}
+/**
+ * Predefined roles for binding actors to sequence tracks at runtime.
+ * Used for abilities, combat sequences, and cinematics where actors
+ * are dynamically bound when the sequence is played.
+ */
+export declare enum SequenceRole {
+    /** The actor executing the sequence (e.g., player casting an ability) */
+    Self = "self",
+    /** Primary target (e.g., enemy being attacked, ally being healed) */
+    Target = "target",
+    /** Second target for multi-target abilities */
+    Target2 = "target2",
+    /** Third target for multi-target abilities */
+    Target3 = "target3",
+    /** Secondary actor (e.g., companion, summoned entity) */
+    Secondary = "secondary"
+}
+export type SequenceTrackType = 'object' | 'camera' | 'audio' | 'vfx' | 'spawn' | 'group';
+/**
+ * Base interface for all track types
+ */
+export interface TrackParenting {
+    /** The ID of the parent track */
+    trackId: string;
+    /** The name of the socket/bone to attach to (optional, defaults to root) */
+    socketName?: string;
+}
+export interface BaseTrack {
+    /** Unique identifier */
+    id: string;
+    /** Display name shown in editor */
+    name: string;
+    /** Track type discriminator */
+    type: SequenceTrackType;
+    /** Whether this track is muted (skipped during playback) */
+    muted: boolean;
+    /** Whether this track is locked (cannot be edited) */
+    locked: boolean;
+    /** Sub-tracks contained within this track */
+    subTracks: SubTrack[];
+    /** Parent track info */
+    parent?: TrackParenting;
+}
+/**
+ * Object track - references a scene object (actor, mesh, light, etc.)
+ * Can animate transforms, properties, and material parameters.
+ */
+export interface ObjectTrack extends BaseTrack {
+    type: 'object';
+    /** Scene object ID being targeted */
+    targetId: string | null;
+    /**
+     * Role for runtime binding. When set, the track can target
+     * a different actor at runtime based on the role (e.g., Self, Target).
+     */
+    role: SequenceRole | null;
+}
+/**
+ * Camera track - controls a sequence-owned camera
+ */
+export interface CameraTrack extends BaseTrack {
+    type: 'camera';
+    /** Camera settings */
+    cameraSettings: {
+        fov: number;
+        near: number;
+        far: number;
+    };
+}
+/**
+ * Audio track - plays audio assets
+ */
+export interface AudioTrack extends BaseTrack {
+    type: 'audio';
+    /** Audio clips placed on the timeline */
+    clips: AudioClipInstance[];
+    /** Track volume multiplier (0-1) */
+    volume: number;
+    /** Whether audio should be spatialized (3D) */
+    spatial: boolean;
+}
+/**
+ * VFX track - spawns and controls visual effects
+ */
+export interface VfxTrack extends BaseTrack {
+    type: 'vfx';
+    /** VFX clips placed on the timeline */
+    clips: VfxClipInstance[];
+    /** Base position relative to sequence root or absolute */
+    position: [number, number, number];
+    /** Base rotation in euler angles */
+    rotation: [number, number, number];
+    /** Base scale */
+    scale: [number, number, number];
+}
+export type SpawnTrackType = 'actor' | 'prefab' | 'mesh';
+/**
+ * Spawn track - spawns actors or prefabs for the duration of a clip
+ */
+export interface SpawnTrack extends BaseTrack {
+    type: 'spawn';
+    /**
+     * What should be spawned
+     */
+    spawnType: SpawnTrackType;
+    /**
+     * Role for runtime binding. When set, the spawned actor is substituted
+     * with a dynamically bound actor at runtime (similar to Unreal's "possessable" system).
+     */
+    role?: SequenceRole | null;
+    /** The class name of an Actor */
+    actorType?: string;
+    /** The asset ID of a Prefab */
+    prefabId?: AssetId | null;
+    /** The asset ID of a Mesh */
+    meshId?: AssetId | null;
+    /** Spawn clips placed on the timeline */
+    clips: SpawnClipInstance[];
+}
+/**
+ * Group track - organizes other tracks without adding functionality
+ */
+export interface GroupTrack extends BaseTrack {
+    type: 'group';
+    /** Collapsed state in editor */
+    collapsed: boolean;
+    /** Child tracks within this group */
+    childTracks: SequenceTrack[];
+}
+export type SequenceTrack = ObjectTrack | CameraTrack | AudioTrack | VfxTrack | SpawnTrack | GroupTrack;
+export type SubTrackType = 'transform' | 'animation' | 'property' | 'material' | 'visibility' | 'event' | 'audioParameter';
+/**
+ * Base interface for sub-tracks
+ */
+export interface BaseSubTrack {
+    /** Unique identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Sub-track type discriminator */
+    type: SubTrackType;
+    /** Whether this sub-track is muted */
+    muted: boolean;
+}
+/**
+ * Transform sub-track - animates position, rotation, and scale
+ */
+export interface TransformSubTrack extends BaseSubTrack {
+    type: 'transform';
+    /** Which transform components are animated */
+    components: {
+        position: boolean;
+        rotation: boolean;
+        scale: boolean;
+    };
+    /** Keyframes for transform animation */
+    keyframes: TransformKeyframe[];
+}
+/**
+ * Animation sub-track - plays animation clips on skeletal meshes
+ */
+export interface AnimationSubTrack extends BaseSubTrack {
+    type: 'animation';
+    /** Animation clips placed on the timeline */
+    clips: AnimationClipInstance[];
+}
+/**
+ * Property sub-track - animates arbitrary numeric/color/vector properties
+ */
+export interface PropertySubTrack extends BaseSubTrack {
+    type: 'property';
+    /** Path to the property (e.g., "light.intensity") */
+    propertyPath: string;
+    /** The type of property being animated */
+    propertyType: SerializedParamType;
+    /** Keyframes for property animation */
+    keyframes: PropertyKeyframe[];
+}
+/**
+ * Material sub-track - animates material shader uniforms
+ */
+export interface MaterialSubTrack extends BaseSubTrack {
+    type: 'material';
+    /** Material slot index or name */
+    materialSlot: string | number;
+    /** Uniform name to animate */
+    uniformName: string;
+    /** The type of uniform being animated */
+    uniformType: SerializedParamType;
+    /** Keyframes for uniform animation */
+    keyframes: PropertyKeyframe[];
+}
+/**
+ * Visibility sub-track - toggles object visibility
+ */
+export interface VisibilitySubTrack extends BaseSubTrack {
+    type: 'visibility';
+    /** Visibility state changes */
+    keyframes: VisibilityKeyframe[];
+}
+/**
+ * Event sub-track - triggers function calls at specific times
+ */
+export interface EventSubTrack extends BaseSubTrack {
+    type: 'event';
+    /** Events to trigger */
+    events: SequenceEventData[];
+}
+/**
+ * Audio parameter sub-track - animates audio parameters like volume and detune
+ */
+export interface AudioParameterSubTrack extends BaseSubTrack {
+    type: 'audioParameter';
+    /** The parameter being animated */
+    parameter: AudioParameterId;
+    /** Keyframes for the parameter */
+    keyframes: PropertyKeyframe[];
+}
+export type SubTrack = TransformSubTrack | AnimationSubTrack | PropertySubTrack | MaterialSubTrack | VisibilitySubTrack | EventSubTrack | AudioParameterSubTrack;
+/**
+ * Interpolation mode for keyframes
+ */
+export type InterpolationMode = 'linear' | 'step' | 'cubic' | 'catmullRom';
+/**
+ * Transform keyframe - stores position, rotation, and scale at a specific time
+ */
+export interface TransformKeyframe {
+    /** Unique identifier */
+    id: string;
+    /** Time in seconds from sequence start */
+    time: number;
+    /** Position [x, y, z] */
+    position?: [number, number, number];
+    /** Rotation in euler angles [x, y, z] */
+    rotation?: [number, number, number];
+    /** Scale [x, y, z] */
+    scale?: [number, number, number];
+    /** Interpolation mode to next keyframe */
+    interpolation: InterpolationMode;
+}
+/**
+ * Property keyframe - stores a property value at a specific time
+ */
+export interface PropertyKeyframe {
+    /** Unique identifier */
+    id: string;
+    /** Time in seconds from sequence start */
+    time: number;
+    /** The property value (type depends on property type) */
+    value: CustomParamValue;
+    /** Interpolation mode to next keyframe */
+    interpolation: InterpolationMode;
+}
+/**
+ * Visibility keyframe - stores visibility state at a specific time
+ */
+export interface VisibilityKeyframe {
+    /** Unique identifier */
+    id: string;
+    /** Time in seconds from sequence start */
+    time: number;
+    /** Whether the object is visible */
+    visible: boolean;
+}
+/**
+ * An instance of an animation clip placed on the timeline
+ */
+export interface AnimationClipInstance {
+    /** Unique identifier */
+    id: string;
+    /** Asset ID of the animation clip */
+    animationClipAssetId: AssetId | null;
+    /** Start time of this clip on the timeline */
+    startTime: number;
+    /** Duration of this clip instance (can be different from original clip) */
+    duration: number;
+    /** Start offset within the original clip */
+    clipStartOffset: number;
+    /** End offset within the original clip (for trimming) */
+    clipEndOffset: number;
+    /** Playback rate multiplier */
+    playbackRate: number;
+    /** Fade in duration */
+    fadeInDuration: number;
+    /** Blend out duration */
+    /** Whether this animation has root motion enabled */
+    rootMotion: boolean;
+}
+/**
+ * An instance of an audio clip placed on the timeline
+ */
+export interface AudioClipInstance {
+    /** Unique identifier */
+    id: string;
+    /** Audio asset ID */
+    audioAssetId: AssetId | null;
+    /** Start time of this clip on the timeline */
+    startTime: number;
+    /** Duration of this clip instance */
+    duration: number;
+    /** Start offset within the audio file (the "crop") */
+    clipStartOffset: number;
+    /** Playback rate multiplier */
+    playbackRate: number;
+    /** Volume multiplier (0-1) */
+    volume: number;
+    /** Fade in duration in seconds */
+    fadeInDuration: number;
+    /** Fade out duration in seconds */
+    fadeOutDuration: number;
+    /** Random volume variation (+/-) */
+    volumeRandomization: number;
+    /** Random pitch/detune variation (+/- cents) */
+    pitchRandomization: number;
+    /** ID of the track to attach this audio to (for spatial audio) */
+    attachedToTrackId?: string;
+    /** Socket/Bone name to attach to on the target track */
+    attachmentSocketName?: string;
+}
+/**
+ * An instance of a visual effect placed on the timeline
+ */
+export interface VfxClipInstance {
+    /** Unique identifier */
+    id: string;
+    /** VFX asset ID */
+    vfxAssetId: AssetId | null;
+    /** Start time of this clip on the timeline */
+    startTime: number;
+    /** Duration of this clip instance */
+    duration: number;
+}
+/**
+ * An instance of a spawn clip placed on the timeline
+ */
+export interface SpawnClipInstance {
+    /** Unique identifier */
+    id: string;
+    /** Start time of this clip on the timeline */
+    startTime: number;
+    /** Duration of this clip instance */
+    duration: number;
+    /** Optional initial position [x, y, z] */
+    initialPosition?: [number, number, number];
+    /** Optional initial rotation in euler angles [x, y, z] */
+    initialRotation?: [number, number, number];
+}
+/**
+ * A function call event at a specific time.
+ * Named SequenceEventData to avoid conflict with @SequenceEvent decorator.
+ */
+export interface SequenceEventData {
+    /** Unique identifier */
+    id: string;
+    /** Time in seconds to trigger the event */
+    time: number;
+    /** Name of the function to call on the target */
+    functionName: string;
+    /** Arguments to pass to the function */
+    arguments: CustomParamValue[];
+}
+/**
+ * Creates a new empty sequence data structure
+ */
+export declare function createSequenceData(): SequenceData;
+/**
+ * Creates a new object track
+ */
+export declare function createObjectTrack(name?: string): ObjectTrack;
+/**
+ * Creates a new camera track
+ */
+export declare function createCameraTrack(name?: string): CameraTrack;
+/**
+ * Creates a new audio track
+ */
+export declare function createAudioTrack(name?: string): AudioTrack;
+/**
+ * Creates a new VFX track
+ */
+export declare function createVfxTrack(name?: string): VfxTrack;
+/**
+ * Creates a new spawn track
+ */
+export declare function createSpawnTrack(name?: string): SpawnTrack;
+/**
+ * Creates a new spawn clip instance
+ */
+export declare function createSpawnClipInstance(startTime: number, duration: number): SpawnClipInstance;
+/**
+ * Creates a new group track
+ */
+export declare function createGroupTrack(name?: string): GroupTrack;
+/**
+ * Creates a new transform sub-track
+ */
+export declare function createTransformSubTrack(): TransformSubTrack;
+/**
+ * Creates a new animation sub-track
+ */
+export declare function createAnimationSubTrack(name?: string): AnimationSubTrack;
+/**
+ * Creates a new audio parameter sub-track
+ */
+export declare function createAudioParameterSubTrack(parameter?: AudioParameterId): AudioParameterSubTrack;
+/**
+ * Creates a new property sub-track
+ */
+export declare function createPropertySubTrack(propertyPath?: string, propertyType?: SerializedParamType): PropertySubTrack;
+/**
+ * Creates a new transform keyframe
+ */
+export declare function createTransformKeyframe(time: number): TransformKeyframe;
+/**
+ * Creates a new property keyframe
+ */
+export declare function createPropertyKeyframe(time: number, value?: CustomParamValue): PropertyKeyframe;
+/**
+ * Creates a new animation clip instance
+ */
+export declare function createAnimationClipInstance(animationClipAssetId: AssetId | null, startTime: number, duration: number): AnimationClipInstance;
+/**
+ * Creates a new audio clip instance
+ */
+export declare function createAudioClipInstance(audioAssetId: AssetId | null, startTime: number, duration: number): AudioClipInstance;
+/**
+ * Creates a new VFX clip instance
+ */
+export declare function createVfxClipInstance(vfxAssetId: AssetId | null, startTime: number, duration: number): VfxClipInstance;
+/**
+ * Creates a new event sub-track
+ */
+export declare function createEventSubTrack(name?: string): EventSubTrack;
+/**
+ * Creates a new sequence event
+ */
+export declare function createSequenceEventData(time: number, functionName?: string): SequenceEventData;
+//# sourceMappingURL=sequence-data.d.ts.map

package/dist/effects/sequence/sequence-data.js

@@ -0,0 +1,4 @@
+import{SerializedParamType as e}from"../../scene/model.js";import{randomString as t}from"../../utils/math.js";import{getAudioParameterDefinition as r}from"./audio-parameters.js";export class Sequence{constructor(e){this.data=e}}export var SequenceRole;!function(e){e.Self="self",e.Target="target",e.Target2="target2",e.Target3="target3",e.Secondary="secondary"}(SequenceRole||(SequenceRole={}));export function createSequenceData(){return{duration:5,loop:!1,playbackRate:1,tracks:[]}}export function createObjectTrack(e="Object Track"){return{id:t(),name:e,type:"object",muted:!1,locked:!1,targetId:null,role:null,subTracks:[]}}export function createCameraTrack(e="Camera Track"){return{id:t(),name:e,type:"camera",muted:!1,locked:!1,cameraSettings:{fov:60,near:.1,far:1e3},subTracks:[]}}export function createAudioTrack(e="Audio Track"){return{id:t(),name:e,type:"audio",muted:!1,locked:!1,clips:[],subTracks:[],volume:1,spatial:!1}}export function createVfxTrack(e="VFX Track"){return{id:t(),name:e,type:"vfx",muted:!1,locked:!1,clips:[],position:[0,0,0],rotation:[0,0,0],scale:[1,1,1],subTracks:[]}}export function createSpawnTrack(e="Spawn Track"){return{id:t(),name:e,type:"spawn",muted:!1,locked:!1,spawnType:"mesh",role:null,clips:[],subTracks:[]}}export function createSpawnClipInstance(e,r){return{id:t(),startTime:e,duration:r}}export function createGroupTrack(e="Group"){return{id:t(),name:e,type:"group",muted:!1,locked:!1,collapsed:!1,childTracks:[],subTracks:[]}}export function createTransformSubTrack(){return{id:t(),name:"Transform",type:"transform",muted:!1,components:{position:!0,rotation:!0,scale:!0},keyframes:[]}}export function createAnimationSubTrack(e="Animation"){return{id:t(),name:e,type:"animation",muted:!1,clips:[]}}export function createAudioParameterSubTrack(e="volume"){const a=r(e);return{id:t(),name:a.displayName,type:"audioParameter",muted:!1,parameter:e,keyframes:[]}}export function createPropertySubTrack(r="",a=e.Number){return{id:t(),name:r||"Property",type:"property",muted:!1,propertyPath:r,propertyType:a,keyframes:[]}}export function createTransformKeyframe(e){return{id:t(),time:e,position:[0,0,0],rotation:[0,0,0],scale:[1,1,1],interpolation:"cubic"}}export function createPropertyKeyframe(r,a={type:e.Number,value:0}){return{id:t(),time:r,value:a,interpolation:"linear"}}export function createAnimationClipInstance(e,r,a){return{id:t(),animationClipAssetId:e,startTime:r,duration:a,clipStartOffset:0,clipEndOffset:0,playbackRate:1,fadeInDuration:.2,rootMotion:!1}}export function createAudioClipInstance(e,r,a){return{id:t(),audioAssetId:e,startTime:r,duration:a,clipStartOffset:0,playbackRate:1,volume:1,fadeInDuration:0,fadeOutDuration:0,volumeRandomization:0,pitchRandomization:0}}export function createVfxClipInstance(e,r,a){return{id:t(),vfxAssetId:e,startTime:r,duration:a}}export function createEventSubTrack(e="Events"){return{id:t(),name:e,type:"event",muted:!1,events:[]}}export function createSequenceEventData(e,r=""){return{id:t(),time:e,functionName:r,arguments:[]}}/*
+ * Copyright (©) 2026 Hology Interactive AB. All rights reserved.
+ * See the LICENSE.md file for details.
+ */