babylonjs-editor 4.5.0 → 5.4.0-alpha.2

package/declaration/src/editor/layout/cinematic/curves/tools/sound.d.ts

@@ -0,0 +1,2 @@
+import { ICinematicTrack } from "babylonjs-editor-tools";
+export declare function normalizeSoundVolumeKeys(track: ICinematicTrack): void;

package/declaration/src/editor/layout/cinematic/curves/tools/tools.d.ts

@@ -0,0 +1,34 @@
+export declare function screenToSvg(svg: SVGSVGElement, clientX: number, clientY: number): {
+    x: number;
+    y: number;
+};
+export declare function valueToSVGY(value: number, height: number): number;
+export declare function SVGYToValue(value: number, scale: number, height: number): number;
+export interface IConvertKeysToBezierOptions {
+    frame1: number;
+    frame2: number;
+    value1: number;
+    value2: number;
+    outTangent: number;
+    inTangent: number;
+}
+export declare function convertKeysToBezier(options: IConvertKeysToBezierOptions): {
+    p0: [number, number];
+    p1: [number, number];
+    c1: [number, number];
+    c2: [number, number];
+};
+export interface IConvertKeysToTangentsOptions {
+    p0: [number, number];
+    p1: [number, number];
+    c1: [number, number];
+    c2: [number, number];
+}
+export declare function convertBezierToTangents(options: IConvertKeysToTangentsOptions): {
+    frame1: number;
+    value1: number;
+    frame2: number;
+    value2: number;
+    outTangent: number;
+    inTangent: number;
+};

package/declaration/src/editor/layout/cinematic/curves.d.ts

@@ -0,0 +1,21 @@
+import { Component } from "react";
+import { Vector2 } from "babylonjs";
+import { ICinematicTrack } from "babylonjs-editor-tools";
+import { CinematicEditor } from "./editor";
+import { CinematicEditorTracker } from "./tracker";
+export interface ICinematicEditorCurvesProps {
+    scale: number;
+    currentTime: number;
+    selectedTrack: ICinematicTrack | null;
+    cinematicEditor: CinematicEditor;
+}
+export interface ICinematicEditorCurvesState {
+    translation: Vector2;
+}
+export declare class CinematicEditorCurves extends Component<ICinematicEditorCurvesProps, ICinematicEditorCurvesState> {
+    tracker: CinematicEditorTracker;
+    private _divRef;
+    constructor(props: ICinematicEditorCurvesProps);
+    render(): React.ReactNode;
+    private _handleMainDivPointerDown;
+}

package/declaration/src/editor/layout/cinematic/editor.d.ts

@@ -0,0 +1,78 @@
+import { Component, ReactNode } from "react";
+import { AnimationGroup } from "babylonjs";
+import { ICinematic, ICinematicTrack } from "babylonjs-editor-tools";
+import { Editor } from "../../main";
+import { RenderType } from "./render/render";
+import { CinematicEditorTracks } from "./tracks";
+import { CinematicEditorCurves } from "./curves";
+import { CinematicEditorTimelines } from "./timelines";
+import { CinematicEditorInspector } from "./inspector";
+export interface ICinematicEditorProps {
+    editor: Editor;
+    absolutePath: string;
+    cinematic: ICinematic;
+}
+export interface ICinematicEditorState {
+    timelinesScale: number;
+    curvesZoom: number;
+    currentTime: number;
+    editType: "keyframes" | "curves";
+    tracksFilter: string;
+    hoverTrack: ICinematicTrack | null;
+    selectedTrack: ICinematicTrack | null;
+    playing: boolean;
+    renderType: RenderType;
+}
+export declare class CinematicEditor extends Component<ICinematicEditorProps, ICinematicEditorState> {
+    /**
+     * Defines the reference to the tracks panel used to display and edit the cinematic tracks.
+     */
+    tracks: CinematicEditorTracks;
+    /**
+     * Defines the reference to the timelines panel used to display and edit the cinematic timelines.
+     */
+    timelines: CinematicEditorTimelines;
+    /**
+     * Defines the reference to the curves panel used to edit animation curves in selected track.
+     */
+    curves: CinematicEditorCurves;
+    /**
+     * Defines the reference to the inspector used to display and edit the cinematic properties.
+     */
+    inspector: CinematicEditorInspector;
+    /**
+     * Defines the reference to the editor instance that owns this cinematic editor.
+     */
+    readonly editor: Editor;
+    /**
+     * Defines the reference to the cinematic object being edited.
+     */
+    readonly cinematic: ICinematic;
+    private _renderer;
+    private _renderDialog;
+    private _undoObserver;
+    private _redoObserver;
+    private _keydownListener;
+    private _temporaryAnimationGroup;
+    private _playAnimation;
+    private _currentTimeBeforePlay;
+    private _animatedCurrentTime;
+    private _playRenderLoop;
+    private _focused;
+    constructor(props: ICinematicEditorProps);
+    render(): ReactNode;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    forceUpdate(): void;
+    setCurrentTime(time: number): void;
+    updateTracksAtCurrentTime(): void;
+    prepareTemporaryAnimationGroup(): void;
+    createTemporaryAnimationGroup(): AnimationGroup;
+    disposeTemporaryAnimationGroup(): void;
+    play(): void;
+    stop(): void;
+    save(): Promise<void>;
+    saveAs(): Promise<void>;
+    openRenderDialog(renderType: RenderType): void;
+    renderCinematic(from: number, to: number): void;
+}

package/declaration/src/editor/layout/cinematic/inspector/animation-group.d.ts

@@ -0,0 +1,8 @@
+import { ICinematicAnimationGroup, ICinematicTrack } from "babylonjs-editor-tools";
+import { CinematicEditor } from "../editor";
+export interface ICinematicEditorAnimationGroupKeyInspectorProps {
+    cinematicEditor: CinematicEditor;
+    cinematicKey: ICinematicAnimationGroup;
+    track: ICinematicTrack;
+}
+export declare function CinematicEditorAnimationGroupKeyInspector(props: ICinematicEditorAnimationGroupKeyInspectorProps): import("react/jsx-runtime").JSX.Element | null;

package/declaration/src/editor/layout/cinematic/inspector/events/apply-impulse.d.ts

@@ -0,0 +1,7 @@
+import { Scene } from "babylonjs";
+import { ICinematicKeyEvent } from "babylonjs-editor-tools";
+export interface ICinematicEditorApplyImpulseKeyInspectorProps {
+    scene: Scene;
+    cinematicKey: ICinematicKeyEvent;
+}
+export declare function CinematicEditorApplyImpulseKeyInspector(props: ICinematicEditorApplyImpulseKeyInspectorProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/cinematic/inspector/events/base.d.ts

@@ -0,0 +1,8 @@
+import { ICinematicKeyEvent, ICinematicTrack } from "babylonjs-editor-tools";
+import { CinematicEditor } from "../../editor";
+export interface ICinematicEditorBaseEventKeyInspectorProps {
+    cinematicEditor: CinematicEditor;
+    cinematicKey: ICinematicKeyEvent;
+    track: ICinematicTrack;
+}
+export declare function CinematicEditorBaseEventKeyInspector(props: ICinematicEditorBaseEventKeyInspectorProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/cinematic/inspector/events/event.d.ts

@@ -0,0 +1,5 @@
+import { ICinematicKeyEvent } from "babylonjs-editor-tools";
+export interface ICinematicEditorEventKeyInspectorProps {
+    cinematicKey: ICinematicKeyEvent;
+}
+export declare function CinematicEditorEventKeyInspector(props: ICinematicEditorEventKeyInspectorProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/cinematic/inspector/events/set-enabled.d.ts

@@ -0,0 +1,7 @@
+import { Scene } from "babylonjs";
+import { ICinematicKeyEvent } from "babylonjs-editor-tools";
+export interface ICinematicEditorSetEnabledKeyInspectorProps {
+    scene: Scene;
+    cinematicKey: ICinematicKeyEvent;
+}
+export declare function CinematicEditorSetEnabledKeyInspector(props: ICinematicEditorSetEnabledKeyInspectorProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/cinematic/inspector/key-cut.d.ts

@@ -0,0 +1,8 @@
+import { ICinematicKeyCut, ICinematicTrack } from "babylonjs-editor-tools";
+import { CinematicEditor } from "../editor";
+export interface ICinematicEditorKeyCutInspectorProps {
+    cinematicEditor: CinematicEditor;
+    cinematicKey: ICinematicKeyCut;
+    track: ICinematicTrack;
+}
+export declare function CinematicEditorKeyCutInspector(props: ICinematicEditorKeyCutInspectorProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/cinematic/inspector/key.d.ts

@@ -0,0 +1,9 @@
+import { IAnimationKey } from "babylonjs";
+import { ICinematicTrack } from "babylonjs-editor-tools";
+import { CinematicEditor } from "../editor";
+export interface ICinematicEditorKeyInspectorProps {
+    cinematicEditor: CinematicEditor;
+    cinematicKey: IAnimationKey;
+    track: ICinematicTrack;
+}
+export declare function CinematicEditorKeyInspector(props: ICinematicEditorKeyInspectorProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/cinematic/inspector/sound.d.ts

@@ -0,0 +1,8 @@
+import { ICinematicSound, ICinematicTrack } from "babylonjs-editor-tools";
+import { CinematicEditor } from "../editor";
+export interface ICinematicEditorSoundKeyInspectorProps {
+    cinematicEditor: CinematicEditor;
+    cinematicKey: ICinematicSound;
+    track: ICinematicTrack;
+}
+export declare function CinematicEditorSoundKeyInspector(props: ICinematicEditorSoundKeyInspectorProps): import("react/jsx-runtime").JSX.Element | null;

package/declaration/src/editor/layout/cinematic/inspector/tools.d.ts

@@ -0,0 +1,13 @@
+import { IAnimationKey, Vector2, Vector3, Quaternion, Color3, Color4 } from "babylonjs";
+import { CinematicEditor } from "../editor";
+export type PropertyInspectorType = {
+    animationType: number | null;
+    object: any;
+    property: string;
+    label: string;
+    step: number;
+    onChange: () => void;
+};
+export declare function getPropertyInspector(options: PropertyInspectorType): import("react/jsx-runtime").JSX.Element | undefined;
+export declare function getTangentDefaultValue(key: IAnimationKey): number | Vector2 | Vector3 | Quaternion | Color3 | Color4 | null;
+export declare function getTangentInspector(key: IAnimationKey, property: "inTangent" | "outTangent", cinematicEditor: CinematicEditor): import("react/jsx-runtime").JSX.Element | null;

package/declaration/src/editor/layout/cinematic/inspector.d.ts

@@ -0,0 +1,16 @@
+import { Component, ReactNode } from "react";
+import { ICinematicTrack } from "babylonjs-editor-tools";
+import { CinematicEditor } from "./editor";
+export interface ICinematicEditorInspectorProps {
+    cinematicEditor: CinematicEditor;
+}
+export interface ICinematicEditorInspectorState {
+    editedObject: any;
+    editedTrack: ICinematicTrack | null;
+}
+export declare class CinematicEditorInspector extends Component<ICinematicEditorInspectorProps, ICinematicEditorInspectorState> {
+    constructor(props: ICinematicEditorInspectorProps);
+    render(): ReactNode;
+    setEditedObject(editedObject: any, editedTrack: ICinematicTrack): void;
+    private _getComponent;
+}

package/declaration/src/editor/layout/cinematic/render/convert.d.ts

@@ -0,0 +1,21 @@
+import { Editor } from "../../../main";
+export type CinematicEditorConvertOptions = {
+    editor: Editor;
+    folderAbsolutePath: string;
+    absolutePath: string;
+    framesCount: number;
+    framesPerSecond: number;
+};
+export declare function convertCinematicVideoToMp4(options: CinematicEditorConvertOptions): Promise<void>;
+import { Component, ReactNode } from "react";
+export interface ICinematicConvertProgressComponentProps {
+    onCancel: () => void;
+}
+export interface IEditorExportProjectProgressComponentState {
+    progress: number;
+}
+export declare class CinematicConvertProgressComponent extends Component<ICinematicConvertProgressComponentProps, IEditorExportProjectProgressComponentState> {
+    constructor(props: ICinematicConvertProgressComponentProps);
+    render(): ReactNode;
+    setProgress(progress: number): void;
+}

package/declaration/src/editor/layout/cinematic/render/dialog.d.ts

@@ -0,0 +1,19 @@
+import { Component, ReactNode } from "react";
+import { AnimationGroup } from "babylonjs";
+import { CinematicEditor } from "../editor";
+export interface ICinematicEditorRenderDialogProps {
+    cinematicEditor: CinematicEditor;
+    onRender: (from: number, to: number) => void;
+}
+export interface ICinematicEditorRenderDialogState {
+    open: boolean;
+    animationGroup: AnimationGroup | null;
+}
+export declare class CinematicEditorRenderDialog extends Component<ICinematicEditorRenderDialogProps, ICinematicEditorRenderDialogState> {
+    private _from;
+    private _to;
+    constructor(props: ICinematicEditorRenderDialogProps);
+    render(): ReactNode;
+    open(): void;
+    close(): void;
+}

package/declaration/src/editor/layout/cinematic/render/render.d.ts

@@ -0,0 +1,18 @@
+import { AnimationGroup } from "babylonjs";
+import { CinematicEditor } from "../editor";
+export type RenderType = "720p" | "1080p" | "4k";
+export type RenderCinematicBaseOptionsType = {
+    from: number;
+    to: number;
+    type: RenderType;
+};
+export type RenderCinematicOptionsType = RenderCinematicBaseOptionsType & {
+    cancelled: boolean;
+    destination: string;
+    animationGroup: AnimationGroup;
+    onProgress: (progress: number) => void;
+};
+export declare function renderCinematic(cinematicEditor: CinematicEditor, options: RenderCinematicOptionsType): Promise<{
+    framesCount: number;
+    destinationFolder: string;
+}>;

package/declaration/src/editor/layout/cinematic/render/renderer.d.ts

@@ -0,0 +1,16 @@
+import { Component, ReactNode } from "react";
+import { CinematicEditor } from "../editor";
+import { RenderCinematicBaseOptionsType } from "./render";
+export interface ICinematicEditorRendererProps {
+    cinematicEditor: CinematicEditor;
+}
+export interface ICinematicEditorRendererState {
+    progress: number;
+    rendering: boolean;
+}
+export declare class CinematicEditorRenderer extends Component<ICinematicEditorRendererProps, ICinematicEditorRendererState> {
+    private _renderConfiguration;
+    constructor(props: ICinematicEditorRendererProps);
+    render(): ReactNode;
+    renderCinematic(options: RenderCinematicBaseOptionsType): Promise<void>;
+}

package/declaration/src/editor/layout/cinematic/render/tools.d.ts

@@ -0,0 +1,21 @@
+import { ArrayBufferTarget, Muxer } from "webm-muxer";
+import { ISize } from "babylonjs";
+import { RenderType } from "./render";
+export declare function getVideoDimensions(type: RenderType): ISize;
+export declare function createVideoEncoder(width: number, height: number): {
+    muxer: Muxer<ArrayBufferTarget>;
+    videoEncoder: VideoEncoder;
+};
+export declare function encodeVideoFrame(canvas: HTMLCanvasElement, videoEncoder: VideoEncoder, frame: number): void;
+export type FlushVideoEncoderOptions = {
+    destinationFolder: string;
+    videoIndex: number;
+    width: number;
+    height: number;
+    videoEncoder: VideoEncoder;
+    muxer: Muxer<ArrayBufferTarget>;
+};
+export declare function flushVideoEncoder(options: FlushVideoEncoderOptions): Promise<{
+    muxer: Muxer<ArrayBufferTarget>;
+    videoEncoder: VideoEncoder;
+}>;

package/declaration/src/editor/layout/cinematic/serialization/parse.d.ts

@@ -0,0 +1,21 @@
+import { Scene, Sound } from "babylonjs";
+import { ICinematic, ICinematicKey, ICinematicKeyCut, ICinematicTrack } from "babylonjs-editor-tools";
+export declare function parseCinematic(data: ICinematic, scene: Scene): ICinematic;
+export declare function parseCinematicTrack(track: ICinematicTrack, scene: Scene): {
+    node: any;
+    sound: Sound | null;
+    propertyPath: string | undefined;
+    defaultRenderingPipeline: boolean | undefined;
+    animationGroup: import("babylonjs").Nullable<import("babylonjs").AnimationGroup>;
+    animationGroups: import("babylonjs-editor-tools").ICinematicAnimationGroup[] | undefined;
+    animationGroupWeight: (ICinematicKey | ICinematicKeyCut)[];
+    sounds: import("babylonjs-editor-tools").ICinematicSound[] | undefined;
+    soundVolume: (ICinematicKey | ICinematicKeyCut)[];
+    keyFrameEvents: {
+        type: "event";
+        frame: number;
+        data?: any;
+    }[] | undefined;
+    keyFrameAnimations: any;
+} | null;
+export declare function parseKeyFrameAnimations(keyFrameAnimations: (ICinematicKey | ICinematicKeyCut)[], animationType: number): (ICinematicKey | ICinematicKeyCut)[];

package/declaration/src/editor/layout/cinematic/serialization/serialize.d.ts

@@ -0,0 +1,4 @@
+import { ICinematic, ICinematicKey, ICinematicKeyCut } from "babylonjs-editor-tools";
+export declare function serializeCinematic(cinematic: ICinematic): ICinematic;
+export declare function serializeCinematicKeyValue(value: any, type: number): any;
+export declare function serializeKeyFrameAnimations(keyFrameAnimations: (ICinematicKey | ICinematicKeyCut)[], animationType: number): (ICinematicKey | ICinematicKeyCut)[];

package/declaration/src/editor/layout/cinematic/timelines/add.d.ts

@@ -0,0 +1,6 @@
+import { ICinematicKey, ICinematicKeyCut, ICinematicTrack } from "babylonjs-editor-tools";
+import { CinematicEditor } from "../editor";
+export declare function addAnimationKey(cinematicEditor: CinematicEditor, type: "key" | "cut", track: ICinematicTrack, positionX: number | null, keyFrameAnimations?: (ICinematicKey | ICinematicKeyCut)[]): void;
+export declare function addSoundKey(cinematicEditor: CinematicEditor, track: ICinematicTrack, positionX?: number | null): import("../../../../ui/dialog").DialogReturnType | undefined;
+export declare function addEventKey(cinematicEditor: CinematicEditor, track: ICinematicTrack, positionX?: number | null): void;
+export declare function addAnimationGroupKey(cinematicEditor: CinematicEditor, track: ICinematicTrack, positionX?: number | null): void;

package/declaration/src/editor/layout/cinematic/timelines/keys/animation-group.d.ts

@@ -0,0 +1,9 @@
+import { ICinematicAnimationGroup } from "babylonjs-editor-tools";
+import { CinematicEditor } from "../../editor";
+export interface ICinematicEditorAnimationGroupKeyProps {
+    cinematicEditor: CinematicEditor;
+    scale: number;
+    move: boolean;
+    cinematicKey: ICinematicAnimationGroup;
+}
+export declare function CinematicEditorAnimationGroupKey(props: ICinematicEditorAnimationGroupKeyProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/cinematic/timelines/keys/base.d.ts

@@ -0,0 +1,22 @@
+import { Component, ReactNode } from "react";
+import { CinematicKeyType, ICinematicTrack } from "babylonjs-editor-tools";
+import { CinematicEditor } from "../../editor";
+export interface ICinematicEditorKeyBaseProps {
+    cinematicEditor: CinematicEditor;
+    scale: number;
+    track: ICinematicTrack;
+    cinematicKey: CinematicKeyType;
+    onRemoved: () => void;
+}
+export interface ICinematicEditorKeyBaseState {
+    move: boolean;
+}
+export declare class CinematicEditorKeyBase extends Component<ICinematicEditorKeyBaseProps, ICinematicEditorKeyBaseState> {
+    private _divRef;
+    constructor(props: ICinematicEditorKeyBaseProps);
+    render(): ReactNode;
+    componentDidMount(): void;
+    private _getComponent;
+    private _handleDoubleClick;
+    private _getTooltipContent;
+}

package/declaration/src/editor/layout/cinematic/timelines/keys/event.d.ts

@@ -0,0 +1,9 @@
+import { ICinematicKeyEvent } from "babylonjs-editor-tools";
+import { CinematicEditor } from "../../editor";
+export interface ICinematicEditorEventKeyProps {
+    cinematicEditor: CinematicEditor;
+    scale: number;
+    move: boolean;
+    cinematicKey: ICinematicKeyEvent;
+}
+export declare function CinematicEditorEventKey(props: ICinematicEditorEventKeyProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/cinematic/timelines/keys/property.d.ts

@@ -0,0 +1,9 @@
+import { ICinematicKey, ICinematicKeyCut } from "babylonjs-editor-tools";
+import { CinematicEditor } from "../../editor";
+export interface ICinematicEditorPropertyKeyProps {
+    cinematicEditor: CinematicEditor;
+    scale: number;
+    move: boolean;
+    cinematicKey: ICinematicKey | ICinematicKeyCut;
+}
+export declare function CinematicEditorPropertyKey(props: ICinematicEditorPropertyKeyProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/cinematic/timelines/keys/sound.d.ts

@@ -0,0 +1,9 @@
+import { ICinematicSound } from "babylonjs-editor-tools";
+import { CinematicEditor } from "../../editor";
+export interface ICinematicEditorSoundKeyProps {
+    cinematicEditor: CinematicEditor;
+    scale: number;
+    move: boolean;
+    cinematicKey: ICinematicSound;
+}
+export declare function CinematicEditorSoundKey(props: ICinematicEditorSoundKeyProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/cinematic/timelines/move.d.ts

@@ -0,0 +1,18 @@
+import { CinematicKeyType } from "babylonjs-editor-tools";
+import { CinematicEditor } from "../editor";
+export interface ICinematicKeyConfigurationToMove {
+    startPosition: number;
+    startValue?: number;
+    key: CinematicKeyType;
+}
+export interface IConfigureDivEventsOptions {
+    div: HTMLDivElement;
+    cinematicEditor: CinematicEditor;
+    cinematicKey: CinematicKeyType;
+    onMoveStart?: () => void;
+    onMove?: () => void;
+    onMoveEnd?: () => void;
+    onClicked?: () => void;
+}
+export declare function configureDivEvents(options: IConfigureDivEventsOptions): void;
+export declare function registerKeysMovedUndoRedo(cinematicEditor: CinematicEditor, animationsKeyConfigurationsToMove: ICinematicKeyConfigurationToMove[][]): void;

package/declaration/src/editor/layout/cinematic/timelines/options.d.ts

@@ -0,0 +1,5 @@
+import { CinematicEditor } from "../editor";
+export interface ICinematicEditorTimelineOptionsProps {
+    cinematicEditor: CinematicEditor;
+}
+export declare function CinematicEditorTimelineOptions(props: ICinematicEditorTimelineOptionsProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/cinematic/timelines/remove.d.ts

@@ -0,0 +1,6 @@
+import { ICinematicAnimationGroup, ICinematicKey, ICinematicKeyCut, ICinematicKeyEvent, ICinematicSound, ICinematicTrack } from "babylonjs-editor-tools";
+import { CinematicEditor } from "../editor";
+export declare function removeAnimationKey(cinematicEditor: CinematicEditor, track: ICinematicTrack, keyframe: ICinematicKey | ICinematicKeyCut): void;
+export declare function removeSoundKey(cinematicEditor: CinematicEditor, track: ICinematicTrack, soundKey: ICinematicSound): void;
+export declare function removeEventKey(cinematicEditor: CinematicEditor, track: ICinematicTrack, eventKey: ICinematicKeyEvent): void;
+export declare function removeAnimationGroupKey(cinematicEditor: CinematicEditor, track: ICinematicTrack, animationGroup: ICinematicAnimationGroup): void;

package/declaration/src/editor/layout/cinematic/timelines/tools.d.ts

@@ -0,0 +1,4 @@
+import { CinematicKeyType, ICinematicKey, ICinematicKeyCut } from "babylonjs-editor-tools";
+import { CinematicEditor } from "../editor";
+export declare function getKeyFrame(key: CinematicKeyType): number;
+export declare function transformKeyAs(cinematicEditor: CinematicEditor, cinematicKey: ICinematicKey | ICinematicKeyCut): void;

package/declaration/src/editor/layout/cinematic/timelines.d.ts

@@ -0,0 +1,26 @@
+import { Component, ReactNode } from "react";
+import { CinematicEditor } from "./editor";
+import { CinematicEditorTracker } from "./tracker";
+export interface ICinematicEditorTimelinesProps {
+    scale: number;
+    currentTime: number;
+    tracksFilter: string;
+    cinematicEditor: CinematicEditor;
+}
+export interface ICinematicEditorTimelinesState {
+    rightClickPositionX: number | null;
+}
+export declare class CinematicEditorTimelines extends Component<ICinematicEditorTimelinesProps, ICinematicEditorTimelinesState> {
+    tracker: CinematicEditorTracker;
+    private _divRef;
+    constructor(props: ICinematicEditorTimelinesProps);
+    render(): ReactNode;
+    private _getTrack;
+    getMaxWidthForTimelines(): number;
+    getMaxFrameForTimelines(): number;
+    /**
+     * Sorts all the keys in the track based on their frame value.
+     */
+    sortAnimationsKeys(): void;
+    private _handlePointerDown;
+}

package/declaration/src/editor/layout/cinematic/toolbar.d.ts

@@ -0,0 +1,6 @@
+import { CinematicEditor } from "./editor";
+export interface ICinematicEditorToolbarProps {
+    cinematicEditor: CinematicEditor;
+    playing: boolean;
+}
+export declare function CinematicEditorToolbar(props: ICinematicEditorToolbarProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/cinematic/tools/state.d.ts

@@ -0,0 +1,3 @@
+import { Scene } from "babylonjs";
+export declare function saveSceneState(scene: Scene): void;
+export declare function restoreSceneState(): void;

package/declaration/src/editor/layout/cinematic/tools/sync.d.ts

@@ -0,0 +1,6 @@
+import { ICinematic } from "babylonjs-editor-tools";
+export interface ISyncAnimationGroupsToFrameOptions {
+    pauseAfterSync: boolean;
+}
+export declare function syncAnimationGroupsToFrame(frame: number, cinematic: ICinematic, options: ISyncAnimationGroupsToFrameOptions): void;
+export declare function syncSoundsToFrame(frame: number, cinematic: ICinematic): void;

package/declaration/src/editor/layout/cinematic/tools/tracks.d.ts

@@ -0,0 +1,2 @@
+import { ICinematicTrack } from "babylonjs-editor-tools";
+export declare function isTrackInFilter(track: ICinematicTrack, filter: string): boolean;

package/declaration/src/editor/layout/cinematic/tracker.d.ts

@@ -0,0 +1,11 @@
+import { Component, ReactNode } from "react";
+export interface ICinematicEditorTrackerProps {
+    scale: number;
+    currentTime: number;
+    translationX?: number;
+}
+export declare class CinematicEditorTracker extends Component<ICinematicEditorTrackerProps> {
+    private _forcedCurrentTime;
+    render(): ReactNode;
+    setForcedCurrentTime(time: number | null): void;
+}

package/declaration/src/editor/layout/cinematic/tracks/add.d.ts

@@ -0,0 +1,5 @@
+import { CinematicEditor } from "../editor";
+export interface ICinematicEditorTrackAddProps {
+    cinematicEditor: CinematicEditor;
+}
+export declare function CinematicEditorTrackAdd(props: ICinematicEditorTrackAddProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/cinematic/tracks/animation-group.d.ts

@@ -0,0 +1,7 @@
+import { ICinematicTrack } from "babylonjs-editor-tools";
+import { CinematicEditor } from "../editor";
+export interface ICinematicEditorAnimationGroupTrackProps {
+    track: ICinematicTrack;
+    cinematicEditor: CinematicEditor;
+}
+export declare function CinematicEditorAnimationGroupTrack(props: ICinematicEditorAnimationGroupTrackProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/cinematic/tracks/event.d.ts

@@ -0,0 +1,7 @@
+import { ICinematicTrack } from "babylonjs-editor-tools";
+import { CinematicEditor } from "../editor";
+export interface ICinematicEditorEventTrackProps {
+    track: ICinematicTrack;
+    cinematicEditor: CinematicEditor;
+}
+export declare function CinematicEditorEventTrack(props: ICinematicEditorEventTrackProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/cinematic/tracks/property.d.ts

@@ -0,0 +1,7 @@
+import { ICinematicTrack } from "babylonjs-editor-tools";
+import { CinematicEditor } from "../editor";
+export interface ICinematicEditorPropertyTrackProps {
+    track: ICinematicTrack;
+    cinematicEditor: CinematicEditor;
+}
+export declare function CinematicEditorPropertyTrack(props: ICinematicEditorPropertyTrackProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/cinematic/tracks/remove.d.ts

@@ -0,0 +1,7 @@
+import { ICinematicTrack } from "babylonjs-editor-tools";
+import { CinematicEditor } from "../editor";
+export interface ICinematicEditorRemoveTrackButtonProps {
+    track: ICinematicTrack;
+    cinematicEditor: CinematicEditor;
+}
+export declare function CinematicEditorRemoveTrackButton(props: ICinematicEditorRemoveTrackButtonProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/cinematic/tracks/sound.d.ts

@@ -0,0 +1,7 @@
+import { ICinematicTrack } from "babylonjs-editor-tools";
+import { CinematicEditor } from "../editor";
+export interface ICinematicEditorSoundTrackProps {
+    track: ICinematicTrack;
+    cinematicEditor: CinematicEditor;
+}
+export declare function CinematicEditorSoundTrack(props: ICinematicEditorSoundTrackProps): import("react/jsx-runtime").JSX.Element;

package/declaration/src/editor/layout/cinematic/tracks.d.ts

@@ -0,0 +1,21 @@
+import { Component, ReactNode } from "react";
+import { ICinematicTrack } from "babylonjs-editor-tools";
+import { CinematicEditor } from "./editor";
+export interface ICinematicEditorTracksProps {
+    tracksFilter: string;
+    cinematicEditor: CinematicEditor;
+}
+export interface ICinematicEditorTracksState {
+}
+export declare class CinematicEditorTracks extends Component<ICinematicEditorTracksProps, ICinematicEditorTracksState> {
+    constructor(props: ICinematicEditorTracksProps);
+    render(): ReactNode;
+    componentDidMount(): void;
+    private _getTrack;
+    addPropertyTrack(options?: Partial<ICinematicTrack>): void;
+    addAnimationGroupTrack(): void;
+    addSoundTrack(): void;
+    addEventTrack(): void;
+    private _handleAddTrackUndoRedo;
+    removeTrack(track: ICinematicTrack): void;
+}