Animation types

export interface TwoBoneRig {
    elbowId: Id;
    upperLength: number;
    lowerLength: number;
    restPose?: {
        root: {
            x: number;
            y: number;
            rotation: number;
        };
        elbowRotation: number;
    };
}

export interface DrawingExposure {
    frame: number;
    drawingId: Id | null;
}

export interface DrawingInterval {
    startFrame: number;
    endFrame: number;
    drawingId: Id | null;
}

export interface DrawingNeighbors {
    current: DrawingInterval;
    previous: DrawingInterval | null;
    next: DrawingInterval | null;
}

export interface Transition {
    type: "cut" | "dissolve" | "wipe-left" | "wipe-right";
    durationFrames: number;
}

export type Easing = "linear" | "ease-in-out" | "hold" | {
    type: "cubic-bezier";
    x1: number;
    y1: number;
    x2: number;
    y2: number;
};

export type CameraChannel = "x" | "y" | "zoom" | "rotation";

export interface CameraKeyframe {
    id: Id;
    frame: number;
    x?: number;
    y?: number;
    zoom?: number;
    rotation?: number;
    easing: Easing;
    channelEasing?: Partial<Record<CameraChannel, Easing>>;
}

export type LayerEffectChannel = "offsetX" | "offsetY" | "opacity";

export interface LayerEffectValue {
    index: number;
    channel?: LayerEffectChannel;
    value: number;
    easing?: Easing;
}

export interface LayerKeyframe {
    effectValues?: LayerEffectValue[];
    id: Id;
    frame: number;
    transform: Partial<Transform>;
    opacity?: number;
    depth?: number;
    easing: Easing;
    channelEasing?: Partial<Record<LayerChannel, Easing>>;
}

export type LayerChannel = keyof Transform | "opacity" | "depth";

export type CameraKeyframeInput = Partial<Pick<CameraKeyframe, CameraChannel | "easing">>;

export type CameraKeyframeChanges = Partial<Omit<CameraKeyframe, "id">>;

export interface LayerKeyframeInput {
    effectValues?: LayerKeyframe["effectValues"];
    transform?: Partial<Transform>;
    opacity?: number;
    depth?: number;
    easing?: LayerKeyframe["easing"];
}

export type LayerKeyframeChanges = Partial<Omit<LayerKeyframe, "id">>;

export interface MouthCue {
    startFrame: number;
    endFrame: number;
    mouth: string;
}

export interface LipSyncOptions {
    startFrame: number;
    endFrame: number;
    mouths: Record<string, string | null>;
    restDrawingId: string | null;
    cues: readonly MouthCue[];
    corrections?: readonly DrawingInterval[];
}

export interface LipSyncTimingOptions {
    sourceRate: RationalRate;
    targetRate: RationalRate;
    rounding?: TimeRounding;
}

export type ShotMergeOptions = ValueMergeOptions;

export type ShotMergeConflict = ValueMergeConflict;

export type ShotMergeReport = ValueMergeReport;

export interface TwoBoneSolution {
    rootRotation: number;
    elbowRotation: number;
    elbow: {
        x: number;
        y: number;
    };
    end: {
        x: number;
        y: number;
    };
    reachable: boolean;
    error: number;
}

export interface RationalRate {
    numerator: number;
    denominator: number;
}

export type TimeRounding = "nearest" | "floor" | "ceil" | "exact";

export interface TimeConversion {
    value: number;
    exact: boolean;
    /** Rounded value minus the exact position, in destination ticks. */
    error: {
        numerator: string;
        denominator: string;
    };
}

export interface EvaluatedCamera {
    x: number;
    y: number;
    zoom: number;
    rotation: number;
}

export interface ShotRetimeReport {
    animationId: string;
    before: {
        durationFrames: number;
        frameRate: RationalRate;
    };
    after: {
        durationFrames: number;
        frameRate: RationalRate;
    };
    rounding: TimeRounding;
    positions: number;
    movedPositions: number;
    quantizedPositions: number;
    audio: {
        policy: ShotRetimeOptions["audio"];
        clips: number;
        movedStarts: number;
    };
}

export interface CoordinateOptions {
    frame?: number;
    camera?: boolean;
}

export interface ArtworkCoordinateSpace {
    layerId: string;
    rootLayerId: string;
    targetId: string;
    frame: number;
    localToFrame: AffineMatrix;
    frameToLocal: AffineMatrix | null;
    parentToFrame: AffineMatrix;
    frameToParent: AffineMatrix | null;
}

export interface ShotCoordinateSpace extends ArtworkCoordinateSpace {
    animationId: string;
}

export type ShotMeshQuery = PageOptions & ({
    collection: "vertices";
    frame?: number;
} | {
    collection: "triangles" | "keyframes" | "joints" | "weights";
});

export interface ShotPointOptions extends CoordinateOptions {
    direction: "localToFrame" | "frameToLocal";
}

export interface ShotPointCandidate {
    point: {
        x: number;
        y: number;
    };
    faces: {
        layerId: string;
        triangleIndex: number;
        weights: number[];
    }[];
}

export type ShotControllerQuery = PageOptions & {
    collection: "targets" | "keyframes";
    frame?: number;
};

export interface ControllerTransferOptions {
    controllers: readonly {
        sourceId: string;
        targetId: string;
    }[];
    layers: readonly {
        sourceId: string;
        targetId: string;
    }[];
    frameOffset: number;
    sourceRange?: {
        startFrame: number;
        endFrame: number;
    };
}

export type ControllerCaptureOptions = {
    id: string;
    name: string;
    frame: number;
    evaluation: "base" | "controlled";
    targets: readonly {
        layerId: string;
        channels: readonly LayerChannel[];
    }[];
} & ({
    mode: "replace";
} | {
    mode: "additive";
    referenceFrame: number;
});

export interface ControllerPerformance {
    format: "codeboard-controller-performance";
    version: 1;
    id: string;
    name: string;
    frameRate: RationalRate;
    controllers: ShotController[];
    sha256: string;
}