AutoMovie API
    Preparing search index...

    The solver's props: the interface chain and target with the engine's certificates and prepared geometry.

    interface IProps {
        bound?: (
            upper: (swivel: number) => IAutoMovieQuaternion,
            posed: (
                swivel: number,
            ) => { lower: IAutoMovieQuaternion; upper: IAutoMovieQuaternion },
        ) => (low: number, high: number) => number;
        closed?: (
            posed: (
                swivel: number,
            ) => { lower: IAutoMovieQuaternion; upper: IAutoMovieQuaternion },
        ) => readonly number[] | null;
        direct?: boolean;
        endOffset: IAutoMovieVector3;
        excluded?: (
            upper: (swivel: number) => IAutoMovieQuaternion,
        ) => (low: number, high: number) => boolean;
        hinge: IAutoMovieVector3;
        incumbent?: IAutoMovieSwivelSeed;
        met?: (upper: IAutoMovieQuaternion, lower: IAutoMovieQuaternion) => boolean;
        midOffset: IAutoMovieVector3;
        midRest: IAutoMovieQuaternion;
        minimum?: { deviation: number; overshoot: number };
        near?: IAutoMovieSwivelNear;
        nearest?: (
            posed: (
                swivel: number,
            ) => { lower: IAutoMovieQuaternion; upper: IAutoMovieQuaternion },
            swivel: number,
        ) => number | null;
        pole?: (
            posed: (
                swivel: number,
            ) => { lower: IAutoMovieQuaternion; upper: IAutoMovieQuaternion },
        ) => number | null;
        prepared?: IAutoMovieHingedArmSwivel.IPreparedTarget;
        range?: { max: number; min: number };
        score: (
            upper: IAutoMovieQuaternion,
            lower: IAutoMovieQuaternion,
            swivel: number,
            posed: (
                swivel: number,
            ) => { lower: IAutoMovieQuaternion; upper: IAutoMovieQuaternion },
        ) => {
            deviation: number;
            exact?: () => number;
            overshoot: number;
            tiebreak?: () => number;
        };
        target: IAutoMovieVector3;
        tie?: number;
        unmet?: (
            posed: (
                swivel: number,
            ) => { lower: IAutoMovieQuaternion; upper: IAutoMovieQuaternion },
        ) => boolean;
        upper: IAutoMovieChainBone;
    }

    Hierarchy

    Index
    bound?: (
        upper: (swivel: number) => IAutoMovieQuaternion,
        posed: (
            swivel: number,
        ) => { lower: IAutoMovieQuaternion; upper: IAutoMovieQuaternion },
    ) => (low: number, high: number) => number

    Given the root's bone-local rotation at a swivel on one bend branch, degrees, and that branch's poser, a certified lower bound of the exact deviation of every candidate at a swivel from low to high degrees; omitted, every step is scored. The cold sweep then scores only the steps the bound cannot place behind a legal candidate (hingedSwivelBounded), with the full sweep's choice: under a tie by the deviation's bucket, and after the minimum certificate's test of the sweep's first candidate.

    closed?: (
        posed: (
            swivel: number,
        ) => { lower: IAutoMovieQuaternion; upper: IAutoMovieQuaternion },
    ) => readonly number[] | null

    Given a branch's poser, every swivel on it, degrees, at which a requested term that only isolated swivels can meet is met (immobileAxisSwivels), in closed form; null or none when the analysis does not apply. A cold fit with no tie or minimum scores those candidates alone and returns the best when it is legal and met accepts it; otherwise the pole start and the sweep decide as without it.

    direct?: boolean

    Whether the score is the start's own term alone, so an unrefused start is the answer.

    Effector's rest offset from the mid joint, in the mid bone's frame.

    excluded?: (
        upper: (swivel: number) => IAutoMovieQuaternion,
    ) => (low: number, high: number) => boolean

    Given the root's bone-local rotation at a swivel on one bend branch, degrees, a test of whether every swivel from low to high degrees is certain to score a positive overshoot (boxExcludedSwivels); omitted, every step is scored. Only a certainty may be returned: the returned pose is then the one the full sweep gives. The factory and returned predicate run synchronously during this solve; exceptions propagate and neither is retained after return. They must not mutate rotations supplied by upper.

    The mid joint's flexion axis in the mid bone's frame; any length.

    A seed the caller holds for a cold fit, a branch and swivel it chose for a nearby target: never the answer by itself, only a legal candidate whose exact deviation starts the bounded sweep's stop (hingedSwivelBounded), which keeps it only where the sweep's choice is legal and no worse than it; read only with bound, never with near.

    met?: (upper: IAutoMovieQuaternion, lower: IAutoMovieQuaternion) => boolean

    Whether a pole-started result meets every requested term; absent, legality alone decides.

    Mid bone's rest offset from the chain root, in the root's bone frame.

    Mid bone's rest rotation relative to the chain root.

    minimum?: { deviation: number; overshoot: number }

    Certified global lower bounds of every actual score in this solve; omission keeps the complete search. With no second key, only the original first coarse candidate may stop early after both keys equal these bounds exactly. The score and all raw inputs must already be admitted; this is a mathematical certificate, not a reach or convergence tolerance.

    The seed of a fit of a nearby target to continue (IAutoMovieSwivelNear): its branch, or the last branch when the target has fewer (two branches meet at the span's ends), and its swivel refined within one step either way to its tolerance, with no sweep; omitted, every swivel is swept.

    nearest?: (
        posed: (
            swivel: number,
        ) => { lower: IAutoMovieQuaternion; upper: IAutoMovieQuaternion },
        swivel: number,
    ) => number | null

    Given a branch's poser and a swivel, degrees, the swivel nearest it at which a requested term met over intervals of swivels can be met, in closed form (distalEndSwivelNearest): the given swivel itself where it is admissible; null where the analysis does not apply or nothing is admissible. A continued fit centres its search there (hingedSwivelNear).

    pole?: (
        posed: (
            swivel: number,
        ) => { lower: IAutoMovieQuaternion; upper: IAutoMovieQuaternion },
    ) => number | null

    Given a branch's poser, the closed-form start swivel, degrees: the pole (mid joint toward the hint) or a term's own minimiser; null when none. A cold fit with no tie or minimum searches from it (hingedSwivelPole) and returns a legal result that met accepts; otherwise the sweep decides.

    Exact source/target geometry of this same unchanged chain, point and hinge range.

    range?: { max: number; min: number }

    The mid joint's legal rotation about hinge, radians, min <= max and no wider than a full turn; every hinge angle is legal when absent.

    Type Declaration

    • max: number

      Upper rig rotation about hinge, radians; caller ensures min <= max <= min + 2*pi.

    • min: number

      Lower rig rotation about hinge, radians.

    score: (
        upper: IAutoMovieQuaternion,
        lower: IAutoMovieQuaternion,
        swivel: number,
        posed: (
            swivel: number,
        ) => { lower: IAutoMovieQuaternion; upper: IAutoMovieQuaternion },
    ) => {
        deviation: number;
        exact?: () => number;
        overshoot: number;
        tiebreak?: () => number;
    }

    Score one candidate's bone-local root and mid rotations: overshoot is the total ROM overshoot in degrees, compared first, and deviation the effort tie-break, compared second. The caller owns the decomposition convention and the rig's constraints. With exact, deviation is a lower bound of the tie-break and exact gives it exactly: a caller whose tie-break ends in a costly non-negative term passes the rest as the bound, and the term is computed only for a comparison the bound cannot decide. With tie, tiebreak is a second key: two deviations in one bucket of width tie are one, and the lesser tiebreak decides (task priority, Siciliano and Slotine 1991: the second objective only among the first's optima), so exact need then be right only to its bucket. The score and its lazy readers describe the same unchanged objective throughout this synchronous solve. The candidate's swivel, degrees, and its branch's poser are passed for a caller that reads them.

    World target the effector should land on.

    tie?: number

    The positive width of the buckets two deviations are one in, the unit of deviation, for a score with a second key (tiebreak); omitted, deviations are compared exactly and tiebreak is not read.

    unmet?: (
        posed: (
            swivel: number,
        ) => { lower: IAutoMovieQuaternion; upper: IAutoMovieQuaternion },
    ) => boolean

    Given a branch's poser, whether it is certain that no candidate on the branch passes met (a certified lower bound of the requested term's miss above its tolerance at every swivel). Where every branch is so certified, a cold fit skips the pole start, whose result met would refuse, and the sweep decides at once; omitted, nothing is certified.

    Chain-root bone (the shoulder or the hip) resolved under the rig's rest FK.