Class AnimationGroup

constructor

• new AnimationGroup(
      name: string,
      scene?: Nullable<Scene>,
      weight?: number,
      playOrder?: number,
  ): AnimationGroup

  Instantiates a new Animation Group. This helps managing several animations at once.

  Parameters

  • name: string

    Defines the name of the group

  • scene: Nullable<Scene> = null

    Defines the scene the group belongs to

  • weight: number = -1

    Defines the weight to use for animations in the group (-1.0 by default, meaning "no weight")

  • playOrder: number = 0

    Defines the order of play of the animation group (default is 0)

  Returns AnimationGroup

  See

  https://doc.babylonjs.com/features/featuresDeepDive/animation/groupAnimations

metadata

name

onAnimationEndObservable

onAnimationGroupEndObservable

onAnimationGroupLoopObservable

onAnimationGroupPauseObservable

onAnimationGroupPlayObservable

onAnimationLoopObservable

uniqueId

animatables

• get animatables(): Animatable[]

  returning the list of animatables controlled by this animation group.

  Returns Animatable[]

blendingSpeed

• get blendingSpeed(): Nullable<number>

  Gets or sets the animation blending speed Note that a null value means that each animation will use their own existing blending configuration (Animation.blendingSpeed)

  Returns Nullable<number>

• set blendingSpeed(value: Nullable<number>): void

  Parameters

  • value: Nullable<number>

  Returns void

children

• get children(): TargetedAnimation[]

  Gets the list of target animations

  Returns TargetedAnimation[]

enableBlending

• get enableBlending(): Nullable<boolean>

  Allows the animations of the animation group to blend with current running animations Note that a null value means that each animation will use their own existing blending configuration (Animation.enableBlending)

  Returns Nullable<boolean>

• set enableBlending(value: Nullable<boolean>): void

  Parameters

  • value: Nullable<boolean>

  Returns void

from

• get from(): number

  Gets or sets the first frame

  Returns number

• set from(value: number): void

  Parameters

  • value: number

  Returns void

isAdditive

• get isAdditive(): boolean

  Gets or sets if all animations should be evaluated additively

  Returns boolean

• set isAdditive(value: boolean): void

  Parameters

  • value: boolean

  Returns void

isPlaying

• get isPlaying(): boolean

  Gets a value indicating that the current group is playing

  Returns boolean

isStarted

• get isStarted(): boolean

  Define if the animations are started

  Returns boolean

loopAnimation

• get loopAnimation(): boolean

  Gets or sets if all animations should loop or not

  Returns boolean

• set loopAnimation(value: boolean): void

  Parameters

  • value: boolean

  Returns void

mask

• get mask(): Nullable<AnimationGroupMask>

  Gets or sets the mask associated with this animation group. This mask is used to filter which objects should be animated.

  Returns Nullable<AnimationGroupMask>

• set mask(value: Nullable<AnimationGroupMask>): void

  Parameters

  • value: Nullable<AnimationGroupMask>

  Returns void

playOrder

• get playOrder(): number

  Gets or sets the order of play of the animation group (default: 0)

  Returns number

• set playOrder(value: number): void

  Parameters

  • value: number

  Returns void

speedRatio

• get speedRatio(): number

  Gets or sets the speed ratio to use for all animations

  Returns number

• set speedRatio(value: number): void

  Gets or sets the speed ratio to use for all animations

  Parameters

  • value: number

  Returns void

targetedAnimations

• get targetedAnimations(): TargetedAnimation[]

  Gets the targeted animations for this animation group

  Returns TargetedAnimation[]

to

• get to(): number

  Gets or sets the last frame

  Returns number

• set to(value: number): void

  Parameters

  • value: number

  Returns void

weight

• get weight(): number

  Gets or sets the weight to apply to all animations of the group

  Returns number

• set weight(value: number): void

  Parameters

  • value: number

  Returns void

addTargetedAnimation

• addTargetedAnimation(animation: Animation, target: any): TargetedAnimation

  Add an animation (with its target) in the group

  Parameters

  • animation: Animation

    defines the animation we want to add

  • target: any

    defines the target of the animation

  Returns TargetedAnimation

  the TargetedAnimation object

clone

• clone(
      newName: string,
      targetConverter?: (oldTarget: any) => any,
      cloneAnimations?: boolean,
      cloneAnimationKeys?: boolean,
  ): AnimationGroup

  Clone the current animation group and returns a copy

  Parameters

  • newName: string

    defines the name of the new group

  • OptionaltargetConverter: (oldTarget: any) => any

    defines an optional function used to convert current animation targets to new ones

  • cloneAnimations: boolean = false

    defines if the animations should be cloned or referenced

  • cloneAnimationKeys: boolean = false

    defines if the animation keys should be cloned when cloning animations (false by default). No effect if cloneAnimations is false

  Returns AnimationGroup

  the new animation group

dispose

• dispose(): void

  Dispose all associated resources

  Returns void

getClassName

• getClassName(): string

  Returns the string "AnimationGroup"

  Returns string

  "AnimationGroup"

getCurrentFrame

• getCurrentFrame(): number

  Helper to get the current frame. This returns 0 when the AnimationGroup is not running and might be inaccurate when animations use different frames.

  Returns number

  current animation frame.

getLength

• getLength(from?: number, to?: number): number

  Gets the length (in seconds) of the animation group This function assumes that all animations are played at the same framePerSecond speed! Note: you can only call this method after you've added at least one targeted animation!

  Parameters

  • Optionalfrom: number

    Starting frame range (default is AnimationGroup.from)

  • Optionalto: number

    Ending frame range (default is AnimationGroup.to)

  Returns number

  The length in seconds

getRetainedCurrentFrame

• getRetainedCurrentFrame(): number

  Gets the last effective frame, retaining it after the group stops.

  Returns number

  current or retained effective animation frame

getScene

• getScene(): Scene

  Gets the scene the animation group belongs to

  Returns Scene

  The scene the animation group belongs to

getVirtualCurrentFrame

• getVirtualCurrentFrame(): number

  Gets the current frame on the unbounded timeline requested by the caller. Unlike getCurrentFrame, this value is not clamped or wrapped by the animation's keyframe range and is retained after the group stops.

  Returns number

  the current virtual animation frame

goToFrame

• goToFrame(frame: number, useWeight?: boolean): AnimationGroup

  Goes to a specific frame in this animation group. Note that the animation group must be in playing or paused status

  Parameters

  • frame: number

    the frame number to go to

  • useWeight: boolean = false

    defines whether the animation weight should be applied to the image to be jumped to (false by default)

  Returns AnimationGroup

  the animationGroup

isValidVirtualStopFrame

• isValidVirtualStopFrame(frame: number): boolean

  Returns whether a frame is inside the requested start/end interval. The end frame is excluded because natural completion takes precedence.

  Parameters

  • frame: number

    virtual frame to test

  Returns boolean

  true when a scheduled stop may occur at the frame

isVirtualFrameReached

• isVirtualFrameReached(frame: number): boolean

  Returns whether the virtual timeline crossed the requested frame.

  Parameters

  • frame: number

    virtual frame to test

  Returns boolean

  true when the frame was reached in the playback direction

normalize

• normalize(
      beginFrame?: Nullable<number>,
      endFrame?: Nullable<number>,
  ): AnimationGroup

  This function will normalize every animation in the group to make sure they all go from beginFrame to endFrame It can add constant keys at begin or end

  Parameters

  • beginFrame: Nullable<number> = null

    defines the new begin frame for all animations or the smallest begin frame of all animations if null (defaults to null)

  • endFrame: Nullable<number> = null

    defines the new end frame for all animations or the largest end frame of all animations if null (defaults to null)

  Returns AnimationGroup

  the animation group

pause

• pause(): AnimationGroup

  Pause all animations

  Returns AnimationGroup

  the animation group

play

• play(loop?: boolean): AnimationGroup

  Play all animations to initial state This function will start() the animations if they were not started or will restart() them if they were paused

  Parameters

  • Optionalloop: boolean

    defines if animations must loop

  Returns AnimationGroup

  the animation group

removeTargetedAnimation

• removeTargetedAnimation(animation: Animation): void

  Remove an animation from the group

  Parameters

  • animation: Animation

    defines the animation we want to remove

  Returns void

removeUnmaskedAnimations

• removeUnmaskedAnimations(): void

  Removes all animations for the targets not retained by the animation group mask. Use this function if you know you won't need those animations anymore and if you want to free memory.

  Returns void

reset

• reset(): AnimationGroup

  Reset all animations to initial state

  Returns AnimationGroup

  the animation group

restart

• restart(): AnimationGroup

  Restart animations from after pausing it

  Returns AnimationGroup

  the animation group

serialize

• serialize(): any

  Serializes the animationGroup to an object

  Returns any

  Serialized object

setVirtualCurrentFrame

• setVirtualCurrentFrame(frame: number): void

  Snaps both retained playheads to an exact virtual timeline position.

  Parameters

  • frame: number

    virtual frame to retain

  Returns void

setWeightForAllAnimatables

• setWeightForAllAnimatables(weight: number): AnimationGroup
  Since

  Set animation weight for all animatables

  6.12.4 You can pass the weight to the AnimationGroup constructor, or use the weight property to set it after the group has been created, making it easier to define the overall animation weight than calling setWeightForAllAnimatables() after the animation group has been started

  Parameters

  • weight: number

    defines the weight to use

  Returns AnimationGroup

  the animationGroup

  See

  https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#animation-weights

start

• start(
      loop?: boolean,
      speedRatio?: number,
      from?: number,
      to?: number,
      isAdditive?: boolean,
  ): AnimationGroup

  Start all animations on given targets

  Parameters

  • loop: boolean = false

    defines if animations must loop

  • speedRatio: number = 1

    defines the ratio to apply to animation speed (1 by default)

  • Optionalfrom: number

    defines the from key (optional)

  • Optionalto: number

    defines the to key (optional)

  • OptionalisAdditive: boolean

    defines the additive state for the resulting animatables (optional)

  Returns AnimationGroup

  the current animation group

startWithVirtualTimeline

• startWithVirtualTimeline(
      loop?: boolean,
      speedRatio?: number,
      from?: number,
      to?: number,
      isAdditive?: boolean,
  ): AnimationGroup

  Starts all animations using an unbounded requested timeline mapped to the animation's effective keyframe range.

  Parameters

  • loop: boolean = false

    defines if animations must loop

  • speedRatio: number = 1

    defines the ratio to apply to animation speed

  • Optionalfrom: number

    defines the requested start frame

  • Optionalto: number

    defines the requested end frame

  • OptionalisAdditive: boolean

    defines the additive state for the resulting animatables

  Returns AnimationGroup

  the current animation group

stop

• stop(skipOnAnimationEnd?: boolean): AnimationGroup

  Stop all animations

  Parameters

  • skipOnAnimationEnd: boolean = false

    defines if the system should not raise onAnimationEnd. Default is false

  Returns AnimationGroup

  the animation group

syncAllAnimationsWith

• syncAllAnimationsWith(root: Nullable<Animatable>): AnimationGroup

  Synchronize and normalize all animatables with a source animatable

  Parameters

  • root: Nullable<Animatable>

    defines the root animatable to synchronize with (null to stop synchronizing)

  Returns AnimationGroup

  the animationGroup

  See

  https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#animation-weights

syncWithMask

• syncWithMask(forceUpdate?: boolean): void

  Makes sure that the animations are either played or stopped according to the animation group mask. Note however that the call won't have any effect if the animation group has not been started yet.

  Parameters

  • forceUpdate: boolean = false

    If true, forces to loop over the animatables even if no mask is defined (used internally, you shouldn't need to use it). Default: false.

  Returns void

toString

• toString(fullDetails?: boolean): string

  Creates a detailed string about the object

  Parameters

  • OptionalfullDetails: boolean

    defines if the output string will support multiple levels of logging within scene loading

  Returns string

  a string representing the object