AutoMovie API
    Preparing search index...

    Interface IAutoMoviePerformShotProps

    The inputs of performShot: the script, the staged world and the beat's performance, the synthesizer and rig lookups that realize it, and the optional context that sharpens framing, gating and coupling.

    Every optional field states what omitting it does; none changes the shot of a caller that omits it beyond what that field documents.

    interface IAutoMoviePerformShotProps {
        blocking?: IAutoMovieBlocking;
        cameraClearance?: IAutoMovieCameraClearanceRuntime;
        formationMotions?: readonly IAutoMovieFormationMotion[];
        formations?: readonly IAutoMovieCompiledFormation[];
        frameFormat?: { height: number; width: number };
        gaits?: (node: string) => readonly string[] | undefined;
        hasActorContext?: (node: string) => boolean;
        jointAxes?: (
            node: string,
        ) =>
            | Partial<Record<AutoMovieHumanoidBone, IAutoMovieJointAxes>>
            | undefined;
        lightMotions?: readonly IAutoMovieClip[];
        models?: readonly IAutoMovieModel[];
        objectMotions?: readonly IAutoMovieClip[];
        performance: IAutoMoviePerformance;
        polygonBodyCues?: readonly IAutoMoviePolygonBodyCue[];
        practicalLights?: readonly IAutoMoviePracticalLightBinding[];
        practicalSurfaces?: readonly IAutoMoviePracticalSurfaceTrack[];
        previous?: IAutoMovieBeatEndState | null;
        props?: readonly IAutoMoviePropSpec[];
        restFrames?: (
            node: string,
        ) =>
            | Partial<Record<AutoMovieHumanoidBone, IAutoMovieRestFrame>>
            | undefined;
        script: IAutoMovieScript;
        shotId?: string;
        skeleton: (node: string) => IAutoMovieSkeleton | null;
        staged: IAutoMovieStagedSet.ISuccess;
        synthesize: IAutoMovieActionSynthesizer;
        targetAt?: (
            target: IAutoMovieActionTarget,
            seconds: number,
        ) => IAutoMovieVector3 | null;
    }
    Index

    The beat's validated blocking. Supplying it arms the coherence gate and the coverage takes.

    Compiler-owned geometry revision and inspection clock. Required once a take's camera declares a physical envelope; a camera without one is unaffected when it is omitted.

    formationMotions?: readonly IAutoMovieFormationMotion[]

    The shot's compact formation cues, so a framed unit is measured where its cue has put it; omitted, every formation is framed at rest.

    formations?: readonly IAutoMovieCompiledFormation[]

    Compiled compact formations present in this shot, so a camera can frame a mass. A group naming a formation this list lacks is a violation.

    frameFormat?: { height: number; width: number }

    Delivery raster for the horizontal half of the framing fit. Omitted, or with a non-positive side, a wide subject is fitted to a square frame, which stands back far enough for any raster of that height.

    Type Declaration

    • height: number

      Delivery height in pixels used as the aspect-ratio denominator; the same non-positive-side fallback applies.

    • width: number

      Delivery width in pixels used only through width/height. A side that is not greater than zero selects the square-frame fallback; finite positive dimensions are the caller's premise.

    gaits?: (node: string) => readonly string[] | undefined

    The gait names each actor supplies; a locomote naming another gait is a violation. Omitted, or undefined for a node, skips the check.

    hasActorContext?: (node: string) => boolean

    Actor-registry membership; omitted, a bone target's actor is not checked against a registry.

    jointAxes?: (
        node: string,
    ) => Partial<Record<AutoMovieHumanoidBone, IAutoMovieJointAxes>> | undefined

    Per-node joint axes the renderer uses, so ground planting and attachment baking read the rig through one basis. Omitted, both use their defaults.

    lightMotions?: readonly IAutoMovieClip[]

    Clips moving the staged lights over this shot's clock, carried onto shot.lightMotions after each track is checked to address a staged light. Omitted, the shot carries no such field.

    models?: readonly IAutoMovieModel[]

    Compiler-owned models for the staged nodes, used to measure what a camera frames. A rig's joint span is not the figure's height, so framing from the rig alone crops a head; omitted, the rig span is the fallback.

    objectMotions?: readonly IAutoMovieClip[]

    Clips the source authored over non-performing scene nodes, such as a door's panel or a prop's hinge, carried onto shot.objectMotions after the baked ones once gateAuthoredObjectMotions admits them.

    The beat's performance: beat id, duration, draft and revise pass.

    polygonBodyCues?: readonly IAutoMoviePolygonBodyCue[]

    Polygon body changes keyed by staged node and rig bone, timed in source-shot seconds.

    practicalLights?: readonly IAutoMoviePracticalLightBinding[]

    Practical lights bound to staged prop emitters. Compiled from the final object clips, using the corresponding prop model in models, and appended to lightMotions. Omit when no practical source follows a prop.

    practicalSurfaces?: readonly IAutoMoviePracticalSurfaceTrack[]

    Shot-local material changes on placed prop parts. Nonempty input requires the corresponding generated rigid models in models. Omit for the staged appearance alone.

    previous?: IAutoMovieBeatEndState | null

    Prior verified beat state, passed to every synthesizer call. The caller restages staged from it beforehand, as compileDefinedShot does.

    props?: readonly IAutoMoviePropSpec[]

    The shot's prop registry, whose articulation lowers the joints an authored object clip may drive and bounds their travel.

    restFrames?: (
        node: string,
    ) => Partial<Record<AutoMovieHumanoidBone, IAutoMovieRestFrame>> | undefined

    Per-node rest frames the renderer uses, so planting and attachTo clips read the visible pose rather than raw rig-space forward kinematics.

    The script whose beats the performance may realize.

    shotId?: string

    Registered source identity for direct code authoring; omitted, the shot id is shot:<beat>.

    skeleton: (node: string) => IAutoMovieSkeleton | null

    Rig lookup by node id; null for a node with no skeleton, whose clip skips the range-of-motion gate and whose subject is measured without a rig span.

    The validated stage result, the one coordinate authority for the shot.

    Synchronous action/actor synthesizer. performShot memoizes each action object and actor pair, including null, and passes previous through; null contributes no motion. Exceptions propagate and input actions must remain stable.

    targetAt?: (
        target: IAutoMovieActionTarget,
        seconds: number,
    ) => IAutoMovieVector3 | null

    Live resolver for targets whose point changes during the shot; its null falls back to the staged placement. Positions are world metres at shot-local seconds.