
## Why Animation Blocks Matter

Animation blocks connect authored graph logic to time-based scene changes.

They are useful when the graph should start, pause, stop, or interpolate values over time instead of reacting only as discrete steps.

## Core Animation Blocks

### `PlayAnimation`

Use `PlayAnimation` when the graph should start a configured animation group.

This block is most useful when the loaded scene already contains animation groups that can be selected from the property panel.

### `PauseAnimation`

Use `PauseAnimation` when a running animation should be paused without being fully reset.

### `StopAnimation`

Use `StopAnimation` when animation playback should stop entirely.

### `Interpolation`

Use `Interpolation` when the graph should move a value over time rather than jump directly between states.

This block is especially helpful in graphs driven by `SceneTickEvent` or other time-sensitive flows.

## Choosing The Right Block

- Use `PlayAnimation`, `PauseAnimation`, and `StopAnimation` for animation-group control.
- Use `Interpolation` when the graph should shape a value over time.



## Why Physics Blocks Matter

The Physics families let graphs respond to simulation events and directly change body state.

These blocks are most useful when the preview scene has Physics V2 enabled and physics bodies are already attached to relevant meshes.

## Physics Events

### `PhysicsCollisionEvent`

Use `PhysicsCollisionEvent` when graph logic should react to collisions.

This block can expose collision-related data such as the other body, contact information, impulse, and penetration details.

## Physics Actions

### `ApplyForce`

Use `ApplyForce` for sustained force-like effects, especially when driven repeatedly over time.

### `ApplyImpulse`

Use `ApplyImpulse` for instant velocity changes.

### `SetLinearVelocity`

Use `SetLinearVelocity` when you want direct control over movement speed and direction.

### `SetAngularVelocity`

Use `SetAngularVelocity` when you want direct rotational motion control.

### `SetPhysicsMotionType`

Use `SetPhysicsMotionType` when the body's motion mode itself should change.

## Physics Data

### `GetLinearVelocity`

Reads the current linear velocity.

### `GetAngularVelocity`

Reads the current angular velocity.

### `GetPhysicsMassProperties`

Reads mass, center of mass, and inertia information.

## Practical Notes

- Physics blocks depend on a physics-enabled scene.
- They are best tested against a preview scene that already contains physics bodies.
- When debugging these graphs, combine runtime stepping with visible scene motion so you can distinguish graph issues from simulation issues.



## Why Event Blocks Matter

Event blocks are the most common starting points for interactive graphs. They define what external occurrence should cause graph execution to begin.

## Scene Lifecycle Events

### `SceneReadyEvent`

Use `SceneReadyEvent` when graph logic should run once the scene is ready.

This is often the best starting point for initialization-style graphs.

### `SceneTickEvent`

Use `SceneTickEvent` when the graph should run every frame.

This is useful for time-based animation logic, continuous checks, or interpolation workflows.

## Pointer And Pick Events

### `MeshPickEvent`

Use `MeshPickEvent` when the graph should react to a mesh being picked. This block can expose information such as the picked mesh and picked point, making it useful for scene interaction workflows.

### `PointerDownEvent`

Use `PointerDownEvent` when a press or click should trigger logic.

### `PointerUpEvent`

Use `PointerUpEvent` when release semantics matter more than press semantics.

### `PointerMoveEvent`

Use `PointerMoveEvent` when continuous pointer motion should drive behavior.

### `PointerOverEvent`

Use `PointerOverEvent` when the graph should react as a pointer enters a target.

### `PointerOutEvent`

Use `PointerOutEvent` when the graph should react as a pointer leaves a target.

Many of these blocks become more precise once you configure their target mesh in the property panel.

## Custom Communication Events

### `ReceiveCustomEvent`

Use `ReceiveCustomEvent` when one graph section should respond to a named event emitted elsewhere.

### `SendCustomEvent`

Use `SendCustomEvent` when a graph section should broadcast a named event, optionally carrying structured payload data.

Together, these blocks are useful for decoupling graph sections that should communicate without being directly connected by execution wires.

## Choosing The Right Event Block

- Use `SceneReadyEvent` for startup.
- Use `SceneTickEvent` for per-frame work.
- Use pointer and pick events for user interaction.
- Use custom events when graph sections should communicate indirectly.


Animation Blocks

Why Animation Blocks Matter

Core Animation Blocks

`PlayAnimation`

`PauseAnimation`

`StopAnimation`

`Interpolation`

Choosing The Right Block

Further reading

Block Reference

First-pass reference for the current blocks available in the Babylon.js Flow Graph Editor.

Validation and Property Editing

Reference for graph validation, type compatibility, and the property panel in the Babylon.js Flow Graph Editor.

Getting Started With The Flow Graph Editor

Learn the basic workflow for creating, testing, saving, and restoring flow graphs in the Babylon.js Flow Graph Editor.