@needle-tools/engine 4.7.0-alpha → 4.7.0-next.2756168

package/lib/engine-components/postprocessing/utils.js

@@ -1,120 +1,120 @@
-import { isDevEnvironment } from "../../engine/debug/index.js";
-import { addComponent } from "../../engine/engine_components.js";
-import { foreachComponentEnumerator } from "../../engine/engine_gameobject.js";
-import { MODULES } from "../../engine/engine_modules.js";
-import { getParam } from "../../engine/engine_utils.js";
-export const debug = getParam("debugpost");
-let PostprocessingManagerType = null;
-export function setPostprocessingManagerType(type) {
-    PostprocessingManagerType = type;
-}
-export function findPostProcessingManager(effect) {
-    let obj = effect.gameObject;
-    while (obj) {
-        for (const comp of foreachComponentEnumerator(obj)) {
-            if (comp.isPostProcessingManager === true) {
-                return comp;
-            }
-        }
-        obj = obj.parent;
-    }
-    return null;
-}
-export function getPostProcessingManager(effect) {
-    let manager = findPostProcessingManager(effect);
-    if (!manager) {
-        if (PostprocessingManagerType) {
-            if (debug)
-                console.warn("Adding postprocessing manager to the scene.");
-            const scene = effect.scene;
-            manager = addComponent(scene, PostprocessingManagerType);
-        }
-        else {
-            if (isDevEnvironment())
-                console.warn("No post processing manager found");
-        }
-    }
-    return manager;
-}
-/**
- * Default order for post-processing effects. This can be used to sort effects by their rendering order when creating custom effects.
- * E.g. in your custom effect, you can set `order: PostProcessingEffectOrder.Bloom + 1;` to ensure it gets rendered after the bloom effect.
- * OR `order: PostProcessingEffectOrder.Bloom - 1;` to ensure it gets rendered before the bloom effect.
- * @example
- * ```typescript
- * import { PostProcessingEffectOrder } from "@needle-tools/engine"
- *
- * export class MyCustomEffect extends PostProcessingEffect {
- *    order: PostProcessingEffectPriority.Bloom + 1; // render after bloom
- *
- *    // ... your effect code
- * }
- * ```
- */
-export const PostProcessingEffectOrder = {
-    /** Used to render effects at the start of the post-processing chain */
-    AT_START: -10_000,
-    NormalPass: 0,
-    DepthDownsamplingPass: 10,
-    SSAO: 20,
-    SMAA: 30,
-    TiltShift: 40,
-    DepthOfField: 50,
-    ChromaticAberration: 60,
-    Bloom: 70,
-    Vignette: 80,
-    Pixelation: 90,
-    ToneMapping: 100,
-    HueSaturation: 110,
-    BrightnessContrast: 120,
-    Sharpening: 130,
-    /** Used to render effects at the end of the post-processing chain, e.g. for final adjustments or overlays. */
-    AT_END: 10_000,
-};
-// let effectsOrder: Array<Constructor<Effect | Pass>> | null = null;
-let builtinOrder = null;
-export function orderEffects(effects) {
-    if (debug === "verbose")
-        console.debug("Before ordering effects", [...effects]);
-    if (!builtinOrder) {
-        builtinOrder = new Map();
-        builtinOrder.set(MODULES.POSTPROCESSING.MODULE.NormalPass, PostProcessingEffectOrder.NormalPass);
-        builtinOrder.set(MODULES.POSTPROCESSING.MODULE.DepthDownsamplingPass, PostProcessingEffectOrder.DepthDownsamplingPass);
-        builtinOrder.set(MODULES.POSTPROCESSING.MODULE.SMAAEffect, PostProcessingEffectOrder.SMAA);
-        builtinOrder.set(MODULES.POSTPROCESSING.MODULE.SSAOEffect, PostProcessingEffectOrder.SSAO);
-        builtinOrder.set(MODULES.POSTPROCESSING_AO.MODULE.N8AOPostPass, PostProcessingEffectOrder.SSAO);
-        builtinOrder.set(MODULES.POSTPROCESSING_AO.MODULE.N8AOPass, PostProcessingEffectOrder.SSAO);
-        builtinOrder.set(MODULES.POSTPROCESSING.MODULE.TiltShiftEffect, PostProcessingEffectOrder.TiltShift);
-        builtinOrder.set(MODULES.POSTPROCESSING.MODULE.DepthOfFieldEffect, PostProcessingEffectOrder.DepthOfField);
-        builtinOrder.set(MODULES.POSTPROCESSING.MODULE.ChromaticAberrationEffect, PostProcessingEffectOrder.ChromaticAberration);
-        builtinOrder.set(MODULES.POSTPROCESSING.MODULE.BloomEffect, PostProcessingEffectOrder.Bloom);
-        builtinOrder.set(MODULES.POSTPROCESSING.MODULE.SelectiveBloomEffect, PostProcessingEffectOrder.Bloom);
-        builtinOrder.set(MODULES.POSTPROCESSING.MODULE.VignetteEffect, PostProcessingEffectOrder.Vignette);
-        builtinOrder.set(MODULES.POSTPROCESSING.MODULE.PixelationEffect, PostProcessingEffectOrder.Pixelation);
-        builtinOrder.set(MODULES.POSTPROCESSING.MODULE.ToneMappingEffect, PostProcessingEffectOrder.ToneMapping);
-        builtinOrder.set(MODULES.POSTPROCESSING.MODULE.HueSaturationEffect, PostProcessingEffectOrder.HueSaturation);
-        builtinOrder.set(MODULES.POSTPROCESSING.MODULE.BrightnessContrastEffect, PostProcessingEffectOrder.BrightnessContrast);
-    }
-    // enforce correct order of effects (e.g. DOF before Bloom)
-    effects.sort((a, b) => {
-        // we use find index here because sometimes constructor names are prefixed with `_`
-        // TODO: find a more robust solution that isnt name based (not sure if that exists tho... maybe we must give effect TYPES some priority/index)
-        const aidx = typeof a.priority === "number" ? a.priority : builtinOrder.get(a.effect.constructor) ?? Number.NEGATIVE_INFINITY;
-        const bidx = typeof b.priority === "number" ? b.priority : builtinOrder.get(b.effect.constructor) ?? Number.NEGATIVE_INFINITY;
-        // Unknown effects should be rendered first
-        if (aidx === Number.NEGATIVE_INFINITY) {
-            if (debug)
-                console.warn("Unknown effect found: ", a.constructor.name, a);
-            return 1;
-        }
-        else if (bidx === Number.NEGATIVE_INFINITY) {
-            if (debug)
-                console.warn("Unknown effect found: ", b.constructor.name, b);
-            return -1;
-        }
-        return aidx - bidx;
-    });
-    if (debug === "verbose")
-        console.debug("After ordering effects", [...effects]);
-}
+import { isDevEnvironment } from "../../engine/debug/index.js";
+import { addComponent } from "../../engine/engine_components.js";
+import { foreachComponentEnumerator } from "../../engine/engine_gameobject.js";
+import { MODULES } from "../../engine/engine_modules.js";
+import { getParam } from "../../engine/engine_utils.js";
+export const debug = getParam("debugpost");
+let PostprocessingManagerType = null;
+export function setPostprocessingManagerType(type) {
+    PostprocessingManagerType = type;
+}
+export function findPostProcessingManager(effect) {
+    let obj = effect.gameObject;
+    while (obj) {
+        for (const comp of foreachComponentEnumerator(obj)) {
+            if (comp.isPostProcessingManager === true) {
+                return comp;
+            }
+        }
+        obj = obj.parent;
+    }
+    return null;
+}
+export function getPostProcessingManager(effect) {
+    let manager = findPostProcessingManager(effect);
+    if (!manager) {
+        if (PostprocessingManagerType) {
+            if (debug)
+                console.warn("Adding postprocessing manager to the scene.");
+            const scene = effect.scene;
+            manager = addComponent(scene, PostprocessingManagerType);
+        }
+        else {
+            if (isDevEnvironment())
+                console.warn("No post processing manager found");
+        }
+    }
+    return manager;
+}
+/**
+ * Default order for post-processing effects. This can be used to sort effects by their rendering order when creating custom effects.
+ * E.g. in your custom effect, you can set `order: PostProcessingEffectOrder.Bloom + 1;` to ensure it gets rendered after the bloom effect.
+ * OR `order: PostProcessingEffectOrder.Bloom - 1;` to ensure it gets rendered before the bloom effect.
+ * @example
+ * ```typescript
+ * import { PostProcessingEffectOrder } from "@needle-tools/engine"
+ *
+ * export class MyCustomEffect extends PostProcessingEffect {
+ *    order: PostProcessingEffectPriority.Bloom + 1; // render after bloom
+ *
+ *    // ... your effect code
+ * }
+ * ```
+ */
+export const PostProcessingEffectOrder = {
+    /** Used to render effects at the start of the post-processing chain */
+    AT_START: -10_000,
+    NormalPass: 0,
+    DepthDownsamplingPass: 10,
+    SSAO: 20,
+    SMAA: 30,
+    TiltShift: 40,
+    DepthOfField: 50,
+    ChromaticAberration: 60,
+    Bloom: 70,
+    Vignette: 80,
+    Pixelation: 90,
+    ToneMapping: 100,
+    HueSaturation: 110,
+    BrightnessContrast: 120,
+    Sharpening: 130,
+    /** Used to render effects at the end of the post-processing chain, e.g. for final adjustments or overlays. */
+    AT_END: 10_000,
+};
+// let effectsOrder: Array<Constructor<Effect | Pass>> | null = null;
+let builtinOrder = null;
+export function orderEffects(effects) {
+    if (debug === "verbose")
+        console.debug("Before ordering effects", [...effects]);
+    if (!builtinOrder) {
+        builtinOrder = new Map();
+        builtinOrder.set(MODULES.POSTPROCESSING.MODULE.NormalPass, PostProcessingEffectOrder.NormalPass);
+        builtinOrder.set(MODULES.POSTPROCESSING.MODULE.DepthDownsamplingPass, PostProcessingEffectOrder.DepthDownsamplingPass);
+        builtinOrder.set(MODULES.POSTPROCESSING.MODULE.SMAAEffect, PostProcessingEffectOrder.SMAA);
+        builtinOrder.set(MODULES.POSTPROCESSING.MODULE.SSAOEffect, PostProcessingEffectOrder.SSAO);
+        builtinOrder.set(MODULES.POSTPROCESSING_AO.MODULE.N8AOPostPass, PostProcessingEffectOrder.SSAO);
+        builtinOrder.set(MODULES.POSTPROCESSING_AO.MODULE.N8AOPass, PostProcessingEffectOrder.SSAO);
+        builtinOrder.set(MODULES.POSTPROCESSING.MODULE.TiltShiftEffect, PostProcessingEffectOrder.TiltShift);
+        builtinOrder.set(MODULES.POSTPROCESSING.MODULE.DepthOfFieldEffect, PostProcessingEffectOrder.DepthOfField);
+        builtinOrder.set(MODULES.POSTPROCESSING.MODULE.ChromaticAberrationEffect, PostProcessingEffectOrder.ChromaticAberration);
+        builtinOrder.set(MODULES.POSTPROCESSING.MODULE.BloomEffect, PostProcessingEffectOrder.Bloom);
+        builtinOrder.set(MODULES.POSTPROCESSING.MODULE.SelectiveBloomEffect, PostProcessingEffectOrder.Bloom);
+        builtinOrder.set(MODULES.POSTPROCESSING.MODULE.VignetteEffect, PostProcessingEffectOrder.Vignette);
+        builtinOrder.set(MODULES.POSTPROCESSING.MODULE.PixelationEffect, PostProcessingEffectOrder.Pixelation);
+        builtinOrder.set(MODULES.POSTPROCESSING.MODULE.ToneMappingEffect, PostProcessingEffectOrder.ToneMapping);
+        builtinOrder.set(MODULES.POSTPROCESSING.MODULE.HueSaturationEffect, PostProcessingEffectOrder.HueSaturation);
+        builtinOrder.set(MODULES.POSTPROCESSING.MODULE.BrightnessContrastEffect, PostProcessingEffectOrder.BrightnessContrast);
+    }
+    // enforce correct order of effects (e.g. DOF before Bloom)
+    effects.sort((a, b) => {
+        // we use find index here because sometimes constructor names are prefixed with `_`
+        // TODO: find a more robust solution that isnt name based (not sure if that exists tho... maybe we must give effect TYPES some priority/index)
+        const aidx = typeof a.priority === "number" ? a.priority : builtinOrder.get(a.effect.constructor) ?? Number.NEGATIVE_INFINITY;
+        const bidx = typeof b.priority === "number" ? b.priority : builtinOrder.get(b.effect.constructor) ?? Number.NEGATIVE_INFINITY;
+        // Unknown effects should be rendered first
+        if (aidx === Number.NEGATIVE_INFINITY) {
+            if (debug)
+                console.warn("Unknown effect found: ", a.constructor.name, a);
+            return 1;
+        }
+        else if (bidx === Number.NEGATIVE_INFINITY) {
+            if (debug)
+                console.warn("Unknown effect found: ", b.constructor.name, b);
+            return -1;
+        }
+        return aidx - bidx;
+    });
+    if (debug === "verbose")
+        console.debug("After ordering effects", [...effects]);
+}
 //# sourceMappingURL=utils.js.map

package/lib/engine-components/timeline/PlayableDirector.d.ts

@@ -1,163 +1,163 @@
-import { Object3D, Quaternion, Vector3 } from 'three';
-import type { GuidsMap } from '../../engine/engine_types.js';
-import { Behaviour } from '../Component.js';
-import * as Models from "./TimelineModels.js";
-import * as Tracks from "./TimelineTracks.js";
-/**
- * The wrap mode of the {@link PlayableDirector}.
- */
-export declare enum DirectorWrapMode {
-    Hold = 0,
-    Loop = 1,
-    None = 2
-}
-/** How the clip handles time outside its start and end range. */
-export declare enum ClipExtrapolation {
-    /** No extrapolation is applied. */
-    None = 0,
-    /** Hold the time at the end value of the clip. */
-    Hold = 1,
-    /** Repeat time values outside the start/end range. */
-    Loop = 2,
-    /** Repeat time values outside the start/end range, reversing direction at each loop */
-    PingPong = 3,
-    /** Time values are passed in without modification, extending beyond the clips range */
-    Continue = 4
-}
-/** @internal */
-export type CreateTrackFunction = (director: PlayableDirector, track: Models.TrackModel) => Tracks.TrackHandler | undefined | null;
-/**
- * The PlayableDirector component is the main component to control timelines in needle engine.
- * It is used to play, pause, stop and evaluate timelines.
- * Assign a TimelineAsset to the `playableAsset` property to start playing a timeline.
- * @category Animation and Sequencing
- * @group Components
- */
-export declare class PlayableDirector extends Behaviour {
-    private static createTrackFunctions;
-    static registerCreateTrack(type: string, fn: CreateTrackFunction): void;
-    playableAsset?: Models.TimelineAssetModel;
-    /** Set to true to start playing the timeline when the scene starts */
-    playOnAwake?: boolean;
-    extrapolationMode: DirectorWrapMode;
-    /** @returns true if the timeline is currently playing */
-    get isPlaying(): boolean;
-    /** @returns true if the timeline is currently paused */
-    get isPaused(): boolean;
-    /** the current time of the timeline */
-    get time(): number;
-    set time(value: number);
-    /** the duration of the timeline */
-    get duration(): number;
-    set duration(value: number);
-    /** the weight of the timeline. Set to a value below 1 to blend with other timelines */
-    get weight(): number;
-    set weight(value: number);
-    /** the playback speed of the timeline */
-    get speed(): number;
-    set speed(value: number);
-    /** When enabled the timeline will wait for audio tracks to load at the current time before starting to play */
-    waitForAudio: boolean;
-    private _visibilityChangeEvt?;
-    private _clonedPlayableAsset;
-    private _speed;
-    /** @internal */
-    awake(): void;
-    /** @internal */
-    onEnable(): void;
-    /** @internal */
-    onDisable(): void;
-    /** @internal */
-    onDestroy(): void;
-    /** @internal */
-    rebuildGraph(): void;
-    /**
-     * Play the timeline from the current time.
-     * If the timeline is already playing this method does nothing.
-     */
-    play(): Promise<void>;
-    /**
-     * Pause the timeline.
-     */
-    pause(): void;
-    /**
-     * Stop the timeline.
-     */
-    stop(): void;
-    /**
-     * Evaluate the timeline at the current time. This is useful when you want to manually update the timeline e.g. when the timeline is paused and you set `time` to a new value.
-     */
-    evaluate(): void;
-    /**
-     * @returns true if the timeline is valid and has tracks
-     */
-    isValid(): boolean | undefined;
-    /** Iterates over all tracks of the timeline
-     * @returns all tracks of the timeline
-     */
-    forEachTrack(): Generator<Tracks.TrackHandler, void, unknown>;
-    /**
-     * @returns all animation tracks of the timeline
-     */
-    get animationTracks(): Tracks.AnimationTrackHandler[];
-    /**
-     * @returns all audio tracks of the timeline
-     */
-    get audioTracks(): Tracks.AudioTrackHandler[];
-    private _guidsMap?;
-    /** @internal */
-    resolveGuids(map: GuidsMap): void;
-    private _isPlaying;
-    private _internalUpdateRoutine;
-    private _isPaused;
-    /** internal, true during the time stop() is being processed */
-    private _isStopping;
-    private _time;
-    private _duration;
-    private _weight;
-    private _animationTracks;
-    private _audioTracks;
-    private _signalTracks;
-    private _controlTracks;
-    private _customTracks;
-    private _allTracks;
-    /** should be called after evaluate if the director was playing */
-    private invokePauseChangedMethodsOnTracks;
-    private invokeStateChangedMethodsOnTracks;
-    private internalUpdate;
-    /**
-     * PlayableDirector lifecycle should always call this instead of "evaluate"
-     * @param called_by_user If true the evaluation is called by the user (e.g. via evaluate())
-     */
-    private internalEvaluate;
-    private resolveBindings;
-    private findRoot;
-    private updateTimelineDuration;
-    private setupAndCreateTrackHandlers;
-    private setAudioTracksAllowPlaying;
-    /** Experimental support for overriding timeline animation data (position or rotation) */
-    readonly animationCallbackReceivers: ITimelineAnimationCallbacks[];
-    /** Experimental: Receive callbacks for timeline animation. Allows modification of final value */
-    registerAnimationCallback(receiver: ITimelineAnimationCallbacks): void;
-    /** Experimental: Unregister callbacks for timeline animation. Allows modification of final value */
-    unregisterAnimationCallback(receiver: ITimelineAnimationCallbacks): void;
-}
-/**
- * Experimental interface for receiving timeline animation callbacks. Register at the PlayableDirector
- */
-export interface ITimelineAnimationCallbacks {
-    /**
-    * @param director The director that is playing the timeline
-    * @param target The target object that is being animated
-    * @param time The current time of the timeline
-    * @param rotation The evaluated rotation of the target object at the current time
-     */
-    onTimelineRotation?(director: PlayableDirector, target: Object3D, time: number, rotation: Quaternion): any;
-    /**
-    * @param director The director that is playing the timeline
-    * @param target The target object that is being animated
-    * @param time The current time of the timeline
-    * @param position The evaluated position of the target object at the current time
-     */
-    onTimelinePosition?(director: PlayableDirector, target: Object3D, time: number, position: Vector3): any;
-}
+import { Object3D, Quaternion, Vector3 } from 'three';
+import type { GuidsMap } from '../../engine/engine_types.js';
+import { Behaviour } from '../Component.js';
+import * as Models from "./TimelineModels.js";
+import * as Tracks from "./TimelineTracks.js";
+/**
+ * The wrap mode of the {@link PlayableDirector}.
+ */
+export declare enum DirectorWrapMode {
+    Hold = 0,
+    Loop = 1,
+    None = 2
+}
+/** How the clip handles time outside its start and end range. */
+export declare enum ClipExtrapolation {
+    /** No extrapolation is applied. */
+    None = 0,
+    /** Hold the time at the end value of the clip. */
+    Hold = 1,
+    /** Repeat time values outside the start/end range. */
+    Loop = 2,
+    /** Repeat time values outside the start/end range, reversing direction at each loop */
+    PingPong = 3,
+    /** Time values are passed in without modification, extending beyond the clips range */
+    Continue = 4
+}
+/** @internal */
+export type CreateTrackFunction = (director: PlayableDirector, track: Models.TrackModel) => Tracks.TrackHandler | undefined | null;
+/**
+ * The PlayableDirector component is the main component to control timelines in needle engine.
+ * It is used to play, pause, stop and evaluate timelines.
+ * Assign a TimelineAsset to the `playableAsset` property to start playing a timeline.
+ * @category Animation and Sequencing
+ * @group Components
+ */
+export declare class PlayableDirector extends Behaviour {
+    private static createTrackFunctions;
+    static registerCreateTrack(type: string, fn: CreateTrackFunction): void;
+    playableAsset?: Models.TimelineAssetModel;
+    /** Set to true to start playing the timeline when the scene starts */
+    playOnAwake?: boolean;
+    extrapolationMode: DirectorWrapMode;
+    /** @returns true if the timeline is currently playing */
+    get isPlaying(): boolean;
+    /** @returns true if the timeline is currently paused */
+    get isPaused(): boolean;
+    /** the current time of the timeline */
+    get time(): number;
+    set time(value: number);
+    /** the duration of the timeline */
+    get duration(): number;
+    set duration(value: number);
+    /** the weight of the timeline. Set to a value below 1 to blend with other timelines */
+    get weight(): number;
+    set weight(value: number);
+    /** the playback speed of the timeline */
+    get speed(): number;
+    set speed(value: number);
+    /** When enabled the timeline will wait for audio tracks to load at the current time before starting to play */
+    waitForAudio: boolean;
+    private _visibilityChangeEvt?;
+    private _clonedPlayableAsset;
+    private _speed;
+    /** @internal */
+    awake(): void;
+    /** @internal */
+    onEnable(): void;
+    /** @internal */
+    onDisable(): void;
+    /** @internal */
+    onDestroy(): void;
+    /** @internal */
+    rebuildGraph(): void;
+    /**
+     * Play the timeline from the current time.
+     * If the timeline is already playing this method does nothing.
+     */
+    play(): Promise<void>;
+    /**
+     * Pause the timeline.
+     */
+    pause(): void;
+    /**
+     * Stop the timeline.
+     */
+    stop(): void;
+    /**
+     * Evaluate the timeline at the current time. This is useful when you want to manually update the timeline e.g. when the timeline is paused and you set `time` to a new value.
+     */
+    evaluate(): void;
+    /**
+     * @returns true if the timeline is valid and has tracks
+     */
+    isValid(): boolean | undefined;
+    /** Iterates over all tracks of the timeline
+     * @returns all tracks of the timeline
+     */
+    forEachTrack(): Generator<Tracks.TrackHandler, void, unknown>;
+    /**
+     * @returns all animation tracks of the timeline
+     */
+    get animationTracks(): Tracks.AnimationTrackHandler[];
+    /**
+     * @returns all audio tracks of the timeline
+     */
+    get audioTracks(): Tracks.AudioTrackHandler[];
+    private _guidsMap?;
+    /** @internal */
+    resolveGuids(map: GuidsMap): void;
+    private _isPlaying;
+    private _internalUpdateRoutine;
+    private _isPaused;
+    /** internal, true during the time stop() is being processed */
+    private _isStopping;
+    private _time;
+    private _duration;
+    private _weight;
+    private _animationTracks;
+    private _audioTracks;
+    private _signalTracks;
+    private _controlTracks;
+    private _customTracks;
+    private _allTracks;
+    /** should be called after evaluate if the director was playing */
+    private invokePauseChangedMethodsOnTracks;
+    private invokeStateChangedMethodsOnTracks;
+    private internalUpdate;
+    /**
+     * PlayableDirector lifecycle should always call this instead of "evaluate"
+     * @param called_by_user If true the evaluation is called by the user (e.g. via evaluate())
+     */
+    private internalEvaluate;
+    private resolveBindings;
+    private findRoot;
+    private updateTimelineDuration;
+    private setupAndCreateTrackHandlers;
+    private setAudioTracksAllowPlaying;
+    /** Experimental support for overriding timeline animation data (position or rotation) */
+    readonly animationCallbackReceivers: ITimelineAnimationCallbacks[];
+    /** Experimental: Receive callbacks for timeline animation. Allows modification of final value */
+    registerAnimationCallback(receiver: ITimelineAnimationCallbacks): void;
+    /** Experimental: Unregister callbacks for timeline animation. Allows modification of final value */
+    unregisterAnimationCallback(receiver: ITimelineAnimationCallbacks): void;
+}
+/**
+ * Experimental interface for receiving timeline animation callbacks. Register at the PlayableDirector
+ */
+export interface ITimelineAnimationCallbacks {
+    /**
+    * @param director The director that is playing the timeline
+    * @param target The target object that is being animated
+    * @param time The current time of the timeline
+    * @param rotation The evaluated rotation of the target object at the current time
+     */
+    onTimelineRotation?(director: PlayableDirector, target: Object3D, time: number, rotation: Quaternion): any;
+    /**
+    * @param director The director that is playing the timeline
+    * @param target The target object that is being animated
+    * @param time The current time of the timeline
+    * @param position The evaluated position of the target object at the current time
+     */
+    onTimelinePosition?(director: PlayableDirector, target: Object3D, time: number, position: Vector3): any;
+}