AutoMovie API
    Preparing search index...

    Interface IAutoMovieMotionHumanPerformanceState

    Everything a performance resolves and its readers share: the people with their placed actions, the props, the laws, the cue tracks and the schedule, built once by the constructor.

    HumanPerformance is the public surface over it. The state's members are public so the HumanPerformance* namespaces, which hold the performance's work by responsibility (placing, contacts, layers, the schedule, aiming and reading), can share them; the public helper signatures expose this shared state contract transitively, while HumanPerformance remains the normal author-facing entry point.

    interface IAutoMovieMotionHumanPerformanceState {
        anchors: Map<string, IAutoMovieMotionHumanSegment & { subject: string }>;
        blasts: readonly IBlast[];
        clipped: Map<number, number>;
        cues: Readonly<Record<string, readonly IAutoMovieScheduleCue[]>>;
        duration: number;
        flight: NonNullable<"physical" | "staged" | undefined>;
        flights: Map<string, readonly IAutoMovieMotionHumanPropFlight.IFlight[]>;
        flying: Map<string, IAutoMovieMotionHumanPropFlight.IFlight[]>;
        forces: readonly IAutoMovieMotionHumanForce[];
        gripCache: Map<string, IAutoMovieMotionHumanPerformanceState.IGrip[]>;
        handovers: Map<IAutoMovieIntent, Map<string, IWarm>>;
        hits: readonly IAutoMovieInteractionEvent[] | undefined;
        intended: Map<string, IAutoMovieIntent[]>;
        laws: Map<string, IAutoMovieMotionHumanActionLaw<never>>;
        layered: Map<string, readonly IAutoMovieScheduleCue[]>;
        meetings: Map<
            string,
            { meeting: IAutoMovieMotionMeeting; subject: string },
        >;
        obstacles: readonly IAutoMovieMotionHumanObstacle[];
        people: Map<string, IAutoMovieMotionHumanSegment.IPerson>;
        performers: readonly IAutoMovieMotionHumanPerformer[];
        placements: number;
        posed: Map<
            string,
            { posed: IAutoMovieMotionHumanProp.IPosed; seconds: number },
        >;
        props: Map<string, IAutoMovieMotionHumanProp>;
        resolving: boolean;
        riding: Set<number>;
        schedule: IAutoMovieSchedule;
        soft: Map<string, IAutoMovieMotionHumanPerformanceSoft.ISolved>;
        strikes: IAutoMovieMotionHumanPerformanceState.IStrike[];
        trial: IAutoMovieMotionHumanPerformanceTrial | undefined;
        writers: Map<string, readonly IWriter[]>;
    }
    Index
    anchors: Map<string, IAutoMovieMotionHumanSegment & { subject: string }>

    The placed actions that carry an anchor, by the anchor, with their performer.

    blasts: readonly IBlast[]

    The scene's blasts (IAutoMovieMotionHumanPerformance.IInput.blasts).

    clipped: Map<number, number>

    Where an action aligned into its performer's previous one ended that one, by the previous one's schedule entry.

    cues: Readonly<Record<string, readonly IAutoMovieScheduleCue[]>>

    The cue tracks, by name.

    duration: number

    Seconds from 0 to the last action's end.

    flight: NonNullable<"physical" | "staged" | undefined>

    The performance's resolved flight policy (IAutoMovieMotionHumanPerformance.IInput.flight), captured once for this input.

    flights: Map<string, readonly IAutoMovieMotionHumanPropFlight.IFlight[]>

    Each launched prop's flights, by the prop, kept once the performance is placed (HumanPropFlight.flights).

    The flights of each prop being found, so a launch reading its prop sees the flights before it; emptied of a prop when its flights are found.

    forces: readonly IAutoMovieMotionHumanForce[]

    The forces on the performers (IAutoMovieMotionHumanPerformance.IInput.forces).

    The spans in which each prop is held or worn, by the prop: who holds it in which hand or wears it on which bone, from when to when and at which offset from the hand or the bone; found once the performance is placed.

    handovers: Map<IAutoMovieIntent, Map<string, IWarm>>

    Incumbent arm solutions lent between plans of one intent while resolving the schedule.

    hits: readonly IAutoMovieInteractionEvent[] | undefined

    Every hit of the placed performance in time order (HumanPerformanceHits.hits), kept on its first read once the performance is placed; none before.

    intended: Map<string, IAutoMovieIntent[]>

    The actions that carry the body the composition gives each person, overlays aside, in walk order: a person's placed ones are its first as many as they have placed, and the rest are still to come.

    laws: Map<string, IAutoMovieMotionHumanActionLaw<never>>

    Every law the performance runs, by name: the vocabulary's and the ones it was given.

    layered: Map<string, readonly IAutoMovieScheduleCue[]>

    The instants of every anchored layer, by its anchor: those known before the schedule from the start, the others once it is placed.

    meetings: Map<string, { meeting: IAutoMovieMotionMeeting; subject: string }>

    The meetings of the mutual actions, by their kind, start and performers: the performer who computed each and the meeting every role reads.

    obstacles: readonly IAutoMovieMotionHumanObstacle[]

    What stands in the performers' way.

    The people with their placed actions, holds, layers and pose caches, by subject.

    performers: readonly IAutoMovieMotionHumanPerformer[]

    The people, as the performance was given them.

    placements: number

    How many actions have been placed so far, the count an alignment trial is checked against.

    posed: Map<string, { posed: IAutoMovieMotionHumanProp.IPosed; seconds: number }>

    Each prop's last posed reading with its film second, by the prop, kept once the performance is placed (HumanPerformanceObject.posed).

    props: Map<string, IAutoMovieMotionHumanProp>

    The props, by subject.

    resolving: boolean

    Whether the schedule is still being resolved: until every action is placed, a pose may read people not placed yet, so nothing is kept.

    riding: Set<number>

    The schedule entries that are overlays, by walk-order index: they ride a carrier and never follow or precede one.

    The resolved schedule.

    Each performer's solved soft parts, by subject, kept once the performance is placed (HumanPerformanceSoft.of).

    The resolved first contacts of every person's striking weapons, in time order, kept for the hit record (HumanPerformanceHits).

    The plan the last alignment trial made, kept until the next placement reads or drops it; none otherwise.

    writers: Map<string, readonly IWriter[]>

    Each prop's articulation writers in film order, by the prop, kept once the performance is placed (HumanPerformanceObject.writers).