Motor

https://pub.dev/packages/motor
Admin
Motor is a unified motion system for Flutter that brings together physics-based springs,...
Tokens:14,337
Snippets:125
Trust Score:9.9
Update:1 year ago
Show doc for...
Tokens:
Raw
### Flutter App Navigation Setup with Motor Examples

Source: https://pub.dev/packages/motor/versions/1.0.0-dev.3/example

This Dart code snippet demonstrates setting up navigation for a Flutter application using the 'motor' package and 'auto_route'. It defines routes for various motion examples, including one-dimensional, two-dimensional redirection, draggable icons, picture-in-picture, flip cards, and title slides. The `main` function initializes the app with a router configuration.

```dart
import 'package:auto_route/auto_route.dart';
import 'package:flutter/cupertino.dart';
import 'package:motor_example/2d_redirection.dart';
import 'package:motor_example/draggable_icons.dart';
import 'package:motor_example/flip-card.dart';
import 'package:motor_example/one_dimension.dart';
import 'package:motor_example/pip.dart';
import 'package:motor_example/title_slide.dart';

void main() async {
  runApp(
    CupertinoApp.router(
      routerConfig: router.config(),
    ),
  );
}

final motorRoutes = [
  NamedRouteDef(
    name: 'Motor Examples',
    path: '',
    type: RouteType.cupertino(),
    builder: (context, state) => const MotorExample(),
  ),
  NamedRouteDef(
    name: OneDimensionExample.name,
    path: OneDimensionExample.path,
    type: RouteType.cupertino(),
    builder: (context, state) => OneDimensionExample(),
  ),
  NamedRouteDef(
    name: TwoDimensionRedirectionExample.name,
    path: TwoDimensionRedirectionExample.path,
    type: RouteType.cupertino(),
    builder: (context, state) => TwoDimensionRedirectionExample(),
  ),
  NamedRouteDef(
    name: DraggableIconsExample.name,
    path: DraggableIconsExample.path,
    type: RouteType.cupertino(),
    builder: (context, state) => DraggableIconsExample(),
  ),
  NamedRouteDef(
    name: PipExample.name,
    path: PipExample.path,
    type: RouteType.cupertino(),
    builder: (context, state) => PipExample(),
  ),
  NamedRouteDef(
    name: FlipCardExample.name,
    path: FlipCardExample.path,
    type: RouteType.cupertino(),
    builder: (context, state) => FlipCardExample(),
  ),
  NamedRouteDef(
    name: TitleSlideExample.name,
    path: TitleSlideExample.path,
    type: RouteType.cupertino(),
    builder: (context, state) => TitleSlideExample(),
  )
];

final router = RootStackRouter.build(
  routes: [
    NamedRouteDef.shell(
      name: 'Home',
      path: '/',
      type: RouteType.cupertino(),
      children: motorRoutes,
    ),
  ],
);

class MotorExample extends StatelessWidget {
  const MotorExample({super.key});

  @override
  Widget build(BuildContext context) {
    return CupertinoPageScaffold(
      child: CustomScrollView(
        slivers: [
          CupertinoSliverNavigationBar(),
          SliverPadding(
            padding: const EdgeInsets.all(16),
            sliver: SliverToBoxAdapter(
              child: Column(
                crossAxisAlignment: CrossAxisAlignment.stretch,
                spacing: 16,
                children: [
                  for (final route in motorRoutes) ...[
                    if (route.path != '')
                      buildDestinationButton(context, route.name),
                  ],
                ],
              ),
            ),
          )
        ],
      ),
    );
  }

  Widget buildDestinationButton(BuildContext context, String name) {
    return CupertinoButton.filled(
      onPressed: () => context.navigateTo(NamedRoute(name)),
      child: Text(name),
    );
  }
}

```

--------------------------------

### Flutter App Navigation Setup with Motor and AutoRoute

Source: https://pub.dev/packages/motor/versions/1.0.0-dev.0/example

This example demonstrates setting up navigation routes for a Flutter application using the 'motor' package and 'auto_route'. It defines various routes, including examples for one-dimensional and two-dimensional motion, and structures them within a shell route for a home screen. The main function initializes the app with Cupertino-style routing.

```dart
import 'package:auto_route/auto_route.dart';
import 'package:flutter/cupertino.dart';
import 'package:motor_example/2d_redirection.dart';
import 'package:motor_example/draggable_icons.dart';
import 'package:motor_example/flip-card.dart';
import 'package:motor_example/one_dimension.dart';
import 'package:motor_example/pip.dart';

void main() async {
  runApp(
    CupertinoApp.router(
      routerConfig: router.config(),
    ),
  );
}

final motorRoutes = [
  NamedRouteDef(
    name: 'Motor Examples',
    path: '',
    type: RouteType.cupertino(),
    builder: (context, state) => const MotorExample(),
  ),
  NamedRouteDef(
    name: OneDimensionExample.name,
    path: OneDimensionExample.path,
    type: RouteType.cupertino(),
    builder: (context, state) => OneDimensionExample(),
  ),
  NamedRouteDef(
    name: TwoDimensionRedirectionExample.name,
    path: TwoDimensionRedirectionExample.path,
    type: RouteType.cupertino(),
    builder: (context, state) => TwoDimensionRedirectionExample(),
  ),
  NamedRouteDef(
    name: DraggableIconsExample.name,
    path: DraggableIconsExample.path,
    type: RouteType.cupertino(),
    builder: (context, state) => DraggableIconsExample(),
  ),
  NamedRouteDef(
    name: PipExample.name,
    path: PipExample.path,
    type: RouteType.cupertino(),
    builder: (context, state) => PipExample(),
  ),
  NamedRouteDef(
    name: FlipCardExample.name,
    path: FlipCardExample.path,
    type: RouteType.cupertino(),
    builder: (context, state) => FlipCardExample(),
  ),
];

final router = RootStackRouter.build(
  routes: [
    NamedRouteDef.shell(
      name: 'Home',
      path: '/',
      type: RouteType.cupertino(),
      children: motorRoutes,
    ),
  ],
);

class MotorExample extends StatelessWidget {
  const MotorExample({super.key});

  @override
  Widget build(BuildContext context) {
    return CupertinoPageScaffold(
      child: CustomScrollView(
        slivers: [
          CupertinoSliverNavigationBar(),
          SliverPadding(
            padding: const EdgeInsets.all(16),
            sliver: SliverToBoxAdapter(
              child: Column(
                crossAxisAlignment: CrossAxisAlignment.stretch,
                spacing: 16,
                children: [
                  buildDestinationButton(
                    context,
                    OneDimensionExample.name,
                  ),
                  buildDestinationButton(
                    context,
                    TwoDimensionRedirectionExample.name,
                  ),
                  buildDestinationButton(
                    context,
                    DraggableIconsExample.name,
                  ),
                  buildDestinationButton(
                    context,
                    PipExample.name,
                  ),
                  buildDestinationButton(
                    context,
                    FlipCardExample.name,
                  ),
                ],
              ),
            ),
          )
        ],
      ),
    );
  }

  Widget buildDestinationButton(BuildContext context, String name) {
    return CupertinoButton.filled(
      onPressed: () => context.navigateTo(NamedRoute(name)),
      child: Text(name),
    );
  }
}

```

--------------------------------

### Install Motor via dart pub

Source: https://pub.dev/packages/motor/index

Command to install the Motor package using the Dart package manager.

```bash
dart pub add motor

```

--------------------------------

### Flutter App Navigation with AutoRoute and Motor Examples

Source: https://pub.dev/packages/motor/versions/1.0.0/example

This Flutter code snippet demonstrates setting up a CupertinoApp with AutoRoute for navigation. It defines a series of routes for various animation examples powered by the 'motor' package, including one-dimensional, two-dimensional, draggable icons, picture-in-picture, flip cards, title slides, and sequence animations. The main `MotorExample` widget builds a scrollable view with buttons to navigate to each example.

```dart
import 'package:auto_route/auto_route.dart';
import 'package:flutter/cupertino.dart';
import 'package:motor_example/2d_redirection.dart';
import 'package:motor_example/draggable_icons.dart';
import 'package:motor_example/flip_card.dart';
import 'package:motor_example/one_dimension.dart';
import 'package:motor_example/phase_animation/phase_animation.dart';
import 'package:motor_example/pip.dart';
import 'package:motor_example/title_slide.dart';

void main() async {
  runApp(
    CupertinoApp.router(
      routerConfig: router.config(),
    ),
  );
}

final motorRoutes = [
  NamedRouteDef(
    name: 'Motor Examples',
    path: '',
    type: RouteType.cupertino(),
    builder: (context, state) => const MotorExample(),
  ),
  NamedRouteDef(
    name: OneDimensionExample.name,
    path: OneDimensionExample.path,
    type: RouteType.cupertino(),
    builder: (context, state) => OneDimensionExample(),
  ),
  NamedRouteDef(
    name: TwoDimensionRedirectionExample.name,
    path: TwoDimensionRedirectionExample.path,
    type: RouteType.cupertino(),
    builder: (context, state) => TwoDimensionRedirectionExample(),
  ),
  NamedRouteDef(
    name: DraggableIconsExample.name,
    path: DraggableIconsExample.path,
    type: RouteType.cupertino(),
    builder: (context, state) => DraggableIconsExample(),
  ),
  NamedRouteDef(
    name: PipExample.name,
    path: PipExample.path,
    type: RouteType.cupertino(),
    builder: (context, state) => PipExample(),
  ),
  NamedRouteDef(
    name: FlipCardExample.name,
    path: FlipCardExample.path,
    type: RouteType.cupertino(),
    builder: (context, state) => FlipCardExample(),
  ),
  NamedRouteDef(
    name: TitleSlideExample.name,
    path: TitleSlideExample.path,
    type: RouteType.cupertino(),
    builder: (context, state) => TitleSlideExample(),
  ),
  NamedRouteDef(
    name: SequenceAnimationExamples.name,
    path: SequenceAnimationExamples.path,
    type: RouteType.cupertino(),
    builder: (context, state) => const SequenceAnimationExamples(),
  ),
];

final router = RootStackRouter.build(
  routes: [
    NamedRouteDef.shell(
      name: 'Home',
      path: '/',
      type: RouteType.cupertino(),
      children: motorRoutes,
    ),
  ],
);

class MotorExample extends StatelessWidget {
  const MotorExample({super.key});

  @override
  Widget build(BuildContext context) {
    return CupertinoPageScaffold(
      child: CustomScrollView(
        slivers: [
          CupertinoSliverNavigationBar(),
          SliverPadding(
            padding: const EdgeInsets.all(16),
            sliver: SliverToBoxAdapter(
              child: Column(
                crossAxisAlignment: CrossAxisAlignment.stretch,
                spacing: 16,
                children: [
                  for (final route in motorRoutes) ...[
                    if (route.path != '')
                      buildDestinationButton(context, route.name),
                  ],
                ],
              ),
            ),
          )
        ],
      ),
    );
  }

  Widget buildDestinationButton(BuildContext context, String name) {
    return CupertinoButton.filled(
      onPressed: () => context.navigateTo(NamedRoute(name)),
      child: Text(name),
    );
  }
}

```

--------------------------------

### Example pubspec.yaml dependency

Source: https://pub.dev/packages/motor/versions/1.0.0-dev.3/install

Shows how the motor package dependency is represented in a Flutter or Dart project's pubspec.yaml file after being added via a pub command.

```yaml
dependencies:
  motor: ^1.0.0-dev.3
```

--------------------------------

### Example pubspec.yaml dependency

Source: https://pub.dev/packages/motor/versions/1.0.0-dev.4/install

This snippet shows how the motor package is added as a dependency in a pubspec.yaml file. It specifies the package name and its version constraint.

```yaml
dependencies:
  motor: ^1.0.0-dev.4
```

--------------------------------

### Example pubspec.yaml Dependency

Source: https://pub.dev/packages/motor/versions/1.0.0-dev.7/install

This snippet shows how the 'motor' package dependency is typically represented in a Dart or Flutter project's pubspec.yaml file.

```yaml
dependencies:
  motor: ^1.0.0-dev.7
```

--------------------------------

### Flutter Project Setup with Motor Package

Source: https://pub.dev/packages/motor/versions/1.0

To integrate the Motor package into your Flutter project, add the 'motor' dependency to your pubspec.yaml file. This allows you to use its animation features. Alternatively, you can use the 'dart pub add' command.

```yaml
dependencies:
  motor: ^1.0.0-dev.0

```

```bash
dart pub add motor

```

--------------------------------

### Install Motor Dependency in Flutter

Source: https://context7.com/context7/pub_dev_packages_motor/llms.txt

Instructions for adding the Motor library to your Flutter project's dependencies using either the pubspec.yaml file or the flutter pub add command.

```yaml
dependencies:
  motor: ^1.0.1
```

```bash
flutter pub add motor
```

--------------------------------

### Dart PhaseMotionController Sequence Animation Example

Source: https://context7.com/context7/pub_dev_packages_motor/llms.txt

This Dart snippet showcases the usage of PhaseMotionController to animate a sequence of loading states. It includes defining states, motions, and handling UI updates during animation. Dependencies include Flutter's material and Cupertino libraries.

```dart
enum LoadingState { idle, spinning, complete }

class PhaseControllerExample extends StatefulWidget {
  @override
  State<PhaseControllerExample> createState() => _PhaseControllerExampleState();
}

class _PhaseControllerExampleState extends State<PhaseControllerExample>
    with SingleTickerProviderStateMixin {
  late final PhaseMotionController<LoadingState, double> controller;

  @override
  void initState() {
    super.initState();

    controller = PhaseMotionController<LoadingState, double>(
      motion: CupertinoMotion.smooth(),
      vsync: this,
      converter: MotionConverter.single,
      initialValue: 0.0,
    );

    controller.addListener(() {
      setState(() {});
    });
  }

  @override
  void dispose() {
    controller.dispose();
    super.dispose();
  }

  void startLoadingSequence() async {
    final sequence = MotionSequence<LoadingState, double>.states({
      LoadingState.idle: 0.0,
      LoadingState.spinning: 2 * 3.14159, // Full rotation
      LoadingState.complete: 2 * 3.14159,
    }, motion: CupertinoMotion.smooth());

    // Play the entire sequence
    await controller.playSequence(sequence);

    print('Sequence completed!');
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        Transform.rotate(
          angle: controller.value,
          child: Container(
            width: 100,
            height: 100,
            decoration: BoxDecoration(
              color: controller.isPlayingSequence &&
                     controller.currentSequencePhase == LoadingState.complete
                ? Colors.green
                : Colors.blue,
              shape: BoxShape.circle,
            ),
            child: Icon(
              controller.currentSequencePhase == LoadingState.complete
                ? Icons.check
                : Icons.refresh,
              size: 50,
              color: Colors.white,
            ),
          ),
        ),
        SizedBox(height: 30),
        if (controller.isPlayingSequence) ...[
          Text('Current phase: ${controller.currentSequencePhase}'),
          Text('Progress: ${(controller.sequenceProgress * 100).toStringAsFixed(0)}%'),
          LinearProgressIndicator(value: controller.sequenceProgress),
        ],
        SizedBox(height: 20),
        Row(
          mainAxisAlignment: MainAxisAlignment.center,
          spacing: 10,
          children: [
            ElevatedButton(
              onPressed: controller.isPlayingSequence ? null : startLoadingSequence,
              child: Text('Start Sequence'),
            ),
            ElevatedButton(
              onPressed: () {
                controller.stop();
                controller.animateTo(0.0);
              },
              child: Text('Reset'),
            ),
          ],
        ),
      ],
    );
  }
}

```

--------------------------------

### Create Custom CupertinoMotion (Flutter/Dart)

Source: https://pub.dev/packages/motor/index

Example of creating a custom CupertinoMotion instance with specific duration and bounce parameters. This leverages the flexibility of the Motor package for iOS-style animations.

```dart
final customMotion = CupertinoMotion(
  duration: Duration(milliseconds: 600),
  bounce: 0.3,
);

```

--------------------------------

### Animate with MaterialSpringMotion and MotionBuilder

Source: https://pub.dev/packages/motor/index

This example demonstrates using MaterialSpringMotion tokens with MotionBuilder and a MotionConverter to animate complex types, such as Offset, for Material Design applications. It allows for animations that adhere to Material Design motion guidelines.

```dart
MotionBuilder(
  motion: MaterialSpringMotion.expressiveSpatialDefault,
  value: const Offset(100, 100),
  from: Offset.zero,
  converter: OffsetMotionConverter(),
  builder: (context, value, child) {
    return Transform.translate(
      offset: value,
      child: child,
    );
  },
  child: Container(
    width: 100,
    height: 100,
    color: Colors.green,
  ),
)
```

--------------------------------

### Define Step Sequences with MotionSequence

Source: https://pub.dev/packages/motor/index

Step sequences provide an ordered progression through a series of values. This example creates a color animation sequence that seamlessly loops through red, yellow, green, and blue using a smooth spring motion.

```dart
final MotionSequence<int, Color> colorSequence = MotionSequence.steps([
  Colors.red,
  Colors.yellow, 
  Colors.green,
  Colors.blue,
], motion: .smoothSpring(), loop: .seamless);
```

--------------------------------

### Dart: Bounded Motion Controller Example

Source: https://context7.com/context7/pub_dev_packages_motor/llms.txt

Demonstrates how to create and utilize a BoundedMotionController in Dart for bounded animations. It includes setting initial bounds, listening for changes, and controlling animation playback with forward, reverse, animateTo, and stop methods. This controller is useful for UI elements that need to animate within a specific range, such as opacity or progress indicators.

```dart
class BoundedControllerExample extends StatefulWidget {
  @override
  State<BoundedControllerExample> createState() => _BoundedControllerExampleState();
}

class _BoundedControllerExampleState extends State<BoundedControllerExample>
    with SingleTickerProviderStateMixin {
  late final BoundedMotionController controller;

  @override
  void initState() {
    super.initState();

    // Bounded controller with explicit upper and lower bounds
    controller = BoundedMotionController(
      motion: CupertinoMotion.snappy(),
      vsync: this,
      lowerBound: 0.0,
      upperBound: 1.0,
      initialValue: 0.0,
    );

    controller.addListener(() {
      setState(() {});
    });
  }

  @override
  void dispose() {
    controller.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        Container(
          width: 200,
          height: 200,
          decoration: BoxDecoration(
            border: Border.all(color: Colors.grey, width: 2),
            borderRadius: BorderRadius.circular(20),
          ),
          child: Opacity(
            opacity: controller.value, // 0.0 to 1.0
            child: Container(
              color: Colors.blue,
              child: Center(
                child: Text(
                  'Opacity: ${(controller.value * 100).toInt()}%',
                  style: TextStyle(
                    color: Colors.white,
                    fontSize: 20,
                    fontWeight: FontWeight.bold,
                  ),
                ),
              ),
            ),
          ),
        ),
        SizedBox(height: 30),
        Row(
          mainAxisAlignment: MainAxisAlignment.center,
          spacing: 10,
          children: [
            ElevatedButton(
              onPressed: () {
                controller.forward(); // Animate to upperBound (1.0)
              },
              child: Text('Forward'),
            ),
            ElevatedButton(
              onPressed: () {
                controller.reverse(); // Animate to lowerBound (0.0)
              },
              child: Text('Reverse'),
            ),
            ElevatedButton(
              onPressed: () {
                controller.animateTo(0.5); // Animate to specific value
              },
              child: Text('50%'),
            ),
            ElevatedButton(
              onPressed: () {
                controller.stop(); // Stop current animation
              },
              child: Text('Stop'),
            ),
          ],
        ),
        SizedBox(height: 20),
        LinearProgressIndicator(
          value: controller.value,
          minHeight: 10,
          backgroundColor: Colors.grey.shade300,
          valueColor: AlwaysStoppedAnimation<Color>(Colors.blue),
        ),
      ],
    );
  }
}

```

--------------------------------

### Create Various Motion Types in Dart

Source: https://context7.com/context7/pub_dev_packages_motor/llms.txt

Examples of creating different types of motion animations in Dart, including linear, curved, various physics-based springs (Cupertino, Material Design 3, custom), and instant transitions.

```dart
// Duration-based motion with linear progression
final linearMotion = Motion.linear(Duration(seconds: 1));

// Duration-based motion with easing curve
final curvedMotion = Motion.curved(
  Duration(milliseconds: 800),
  Curves.easeInOut,
);

// Physics-based spring motion with Apple design system
final bouncySpring = CupertinoMotion.bouncy();
final smoothSpring = CupertinoMotion.smooth();
final snappySpring = CupertinoMotion.snappy();
final interactiveSpring = CupertinoMotion.interactive();

// Material Design 3 spring tokens
final materialSpatial = MaterialSpringMotion.standardSpatialDefault();
final materialExpressive = MaterialSpringMotion.expressiveSpatialDefault();
final materialEffects = MaterialSpringMotion.standardEffectsDefault();

// Custom spring with duration and bounce
final customSpring = CupertinoMotion(
  duration: Duration(milliseconds: 500),
  bounce: 0.3, // -1 to 1 range
);

// Spring motion using Flutter SDK's SpringDescription
final advancedSpring = SpringMotion(
  SpringDescription.withDurationAndBounce(
    duration: Duration(milliseconds: 600),
    bounce: 0.25,
  ),
);

// No motion - instant change with optional hold duration
final instant = Motion.none(holdDuration: Duration(milliseconds: 100));
```

--------------------------------

### motor Package pubspec.yaml Dependency

Source: https://pub.dev/packages/motor/versions/1.0.0-dev.0/install

Example of how the 'motor' package dependency is declared in a project's pubspec.yaml file. This entry is automatically managed by `dart pub add` or `flutter pub add`.

```yaml
dependencies:
  motor: ^1.0.0-dev.0
```

--------------------------------

### Define State Sequences with MotionSequence

Source: https://pub.dev/packages/motor/index

State sequences are used for animations with named phases, suitable for state machines or enums. This example defines a sequence for a button's states (idle, pressed, loading) using Offset values and a bouncy spring motion.

```dart
enum ButtonState { idle, pressed, loading }

final MotionSequence<ButtonState, Offset> buttonSequence = .states({
  .idle: Offset(0, 0),
  .pressed: Offset(0, 5),
  .loading: Offset(10, 0),
}, motion: .bouncySpring());
```

--------------------------------

### Custom MotionConverter for Vector3 (Dart)

Source: https://context7.com/context7/pub_dev_packages_motor/llms.txt

Provides an example of creating a custom MotionConverter for a Vector3 type. It shows how to implement the `MotionConverter` interface for custom data types and demonstrates its usage within MotionBuilder, including an alternative using `MotionConverter.custom`.

```dart
// Define custom 3D vector type
class Vector3 {
  final double x, y, z;
  const Vector3(this.x, this.y, this.z);
}

// Implement MotionConverter for Vector3
class Vector3MotionConverter implements MotionConverter<Vector3> {
  @override
  List<double> normalize(Vector3 value) => [value.x, value.y, value.z];

  @override
  Vector3 denormalize(List<double> values) =>
      Vector3(values[0], values[1], values[2]);
}

// Use in MotionBuilder
class Animated3DWidget extends StatefulWidget {
  @override
  State<Animated3DWidget> createState() => _Animated3DWidgetState();
}

class _Animated3DWidgetState extends State<Animated3DWidget> {
  Vector3 targetPosition = Vector3(0, 0, 0);

  @override
  Widget build(BuildContext context) {
    return MotionBuilder(
      motion: CupertinoMotion.bouncy(),
      value: targetPosition,
      from: Vector3(0, 0, 0),
      converter: Vector3MotionConverter(),
      builder: (context, value, child) {
        return Transform(
          transform: Matrix4.identity()
            ..translate(value.x, value.y, value.z),
          child: Container(
            width: 100,
            height: 100,
            color: Colors.green,
          ),
        );
      },
    );
  }
}

// Alternative: Use MotionConverter.custom directly
final quickConverter = MotionConverter.custom(
  normalize: (Vector3 value) => [value.x, value.y, value.z],
  denormalize: (List<double> values) => Vector3(values[0], values[1], values[2]),
);
```

--------------------------------

### Add Motor Package Dependency to Flutter Project

Source: https://pub.dev/packages/motor/versions/1.0.0/install

This command adds the Motor package as a dependency to your Flutter project's `pubspec.yaml` file. It ensures that the package is available for use in your Dart code and automatically runs `flutter pub get`.

```bash
flutter pub add motor
```

--------------------------------

### Custom 3D Vector Motion Converter Implementation

Source: https://pub.dev/packages/motor/index

Provides an example of creating a custom MotionConverter for a 3D vector type (Vector3). It implements the `normalize` and `denormalize` methods to map the Vector3's components (x, y, z) to and from a list of doubles. This allows Motor to animate Vector3 properties independently across each dimension using any specified motion.

```dart
class My3DMotionConverter implements MotionConverter<Vector3> {
  @override
  List<double> normalize(Vector3 value) => [value.x, value.y, value.z];

  @override
  Vector3 denormalize(List<double> values) => Vector3(values[0], values[1], values[2]);
}

Widget build(BuildContext context) {
  return MotionBuilder(
    motion: CupertinoMotion.bouncy(),
    value: Vector3(100, 100, 100),
    converter: My3DMotionConverter(),
    // ...
  );
}

```

--------------------------------

### Add motor Package Dependency (Flutter)

Source: https://pub.dev/packages/motor/versions/1.0.0-dev.0/install

Command to add the 'motor' package as a dependency in a Flutter project using the Flutter CLI. This command updates the pubspec.yaml file and performs a package get.

```bash
$ flutter pub add motor
```

--------------------------------

### Define Spanning Sequences with MotionSequence

Source: https://pub.dev/packages/motor/index

Spanning sequences offer precise timing control where a single motion covers positioned phases proportionally. This example defines a logo animation sequence with opacity and text visibility changes, using a linear motion over a specified duration.

```dart
final logoSequence = MotionSequence.spanning({
  0.0: LogoState(opacity: 0),
  1.0: LogoState(opacity: 1),
  2.0: LogoState(opacity: 1, text: 1),
}, motion: .linear(Duration(seconds: 2)));
```

--------------------------------

### Direct Control with PhaseMotionController

Source: https://pub.dev/packages/motor/index

Shows how to use PhaseMotionController for granular control over animation sequences. This involves initializing the controller with a motion and converter, then manually playing sequences using `playSequence`. The controller provides properties to check playback status, current phase, and progress, enabling complex, state-driven animations.

```dart
final controller = PhaseMotionController<ButtonState, Offset>(
  motion: .smoothSpring(),
  vsync: this,
  converter: .offset,
  initialValue: .zero,
);

// Play a sequence
await controller.playSequence(buttonSequence);

// Check current state
if (controller.isPlayingSequence) {
  print('Current phase: ${controller.currentSequencePhase}');
  print('Progress: ${controller.sequenceProgress}');
}

```

--------------------------------

### Create Motor Animations (Flutter/Dart)

Source: https://pub.dev/packages/motor/index

Demonstrates how to create different types of motion animations using the Motor package, including duration-based and physics-based springs. Requires the Dart SDK.

```dart
// Duration-based motion (traditional Flutter approach)
final linear = Motion.linear(Duration(seconds: 1));

final withCurve = Motion.curved(Duration(seconds: 1), Curves.easeInOut);

// Physics-based motion (natural, responsive)
final spring = CupertinoMotion.bouncy(); // Or `Motion.bouncySpring()`
final material = MaterialSpringMotion.standardSpatialDefault();

```

--------------------------------

### Create Custom Spring Animations

Source: https://pub.dev/packages/motor/index

Illustrates methods for creating custom spring animations using the Motor package. This includes using the CupertinoMotion constructor with specific parameters or leveraging Flutter SDK's SpringDescription.

```dart
// Using CupertinoMotion constructor
final mySpring = CupertinoMotion(
  duration: Duration(milliseconds: 500),
  bounce: 0.2,   // Bounce amount (-1 to 1)
);

// Or using Flutter SDK's SpringDescription directly
final customSpring = SpringMotion(
  SpringDescription.withDurationAndBounce(
    duration: Duration(milliseconds: 500),
    bounce: 0.2,
  ),
);
```

--------------------------------

### Initialize MotionController for Low-Level Control

Source: https://pub.dev/packages/motor/index

Shows how to initialize a MotionController for fine-grained control over animations. This controller is motion-agnostic and preserves velocity when changing targets, working with any motion type.

```dart
final controller = MotionController(
  motion: CupertinoMotion.bouncy(), // or Motion.duration(), etc.
  vsync: this,
);
```

--------------------------------

### Flutter Built-in Motion Converters with Motor

Source: https://context7.com/context7/pub_dev_packages_motor/llms.txt

Demonstrates using Motor's built-in converters (Size, Color, Alignment, Rect) with MotionBuilder for animating various Flutter types. Requires the 'motor' package.

```dart
class MultipleConvertersExample extends StatefulWidget {
  @override
  State<MultipleConvertersExample> createState() => _MultipleConvertersExampleState();
}

class _MultipleConvertersExampleState extends State<MultipleConvertersExample> {
  Size targetSize = Size(100, 100);
  Color targetColor = Colors.blue;
  Alignment targetAlignment = Alignment.topLeft;
  Rect targetRect = Rect.fromLTWH(0, 0, 100, 100);

  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        // Size animation with SizeMotionConverter
        MotionBuilder(
          motion: MaterialSpringMotion.standardSpatialDefault(),
          value: targetSize,
          from: Size(50, 50),
          converter: SizeMotionConverter(),
          builder: (context, size, child) {
            return Container(
              width: size.width,
              height: size.height,
              color: Colors.purple,
            );
          },
        ),

        // Color animation with ColorRgbMotionConverter
        MotionBuilder(
          motion: MaterialSpringMotion.standardEffectsDefault(),
          value: targetColor,
          from: Colors.red,
          converter: ColorRgbMotionConverter(),
          builder: (context, color, child) {
            return Container(
              width: 100,
              height: 100,
              color: color,
            );
          },
        ),

        // Alignment animation
        MotionBuilder(
          motion: CupertinoMotion.snappy(),
          value: targetAlignment,
          from: Alignment.topLeft,
          converter: AlignmentMotionConverter(),
          builder: (context, alignment, child) {
            return Align(
              alignment: alignment,
              child: Container(width: 50, height: 50, color: Colors.orange),
            );
          },
        ),

        // Rect animation
        MotionBuilder(
          motion: CupertinoMotion.smooth(),
          value: targetRect,
          from: Rect.fromLTWH(0, 0, 50, 50),
          converter: RectMotionConverter(),
          builder: (context, rect, child) {
            return Positioned.fromRect(
              rect: rect,
              child: Container(color: Colors.green),
            );
          },
        ),
      ],
    );
  }
}

```

--------------------------------

### Implement MotionDraggable Widget

Source: https://pub.dev/packages/motor/index

Demonstrates how to use the MotionDraggable widget, which functions similarly to Flutter's Draggable but with motion-driven return animations. It supports native DragTargets and allows for various motion types.

```dart
MotionDraggable(
  motion: CupertinoMotion.bouncy(),
  child: Container(
    width: 100,
    height: 100,
    color: Colors.blue,
  ),
  data: 'my-draggable-data',
)
```

--------------------------------

### Sequence Animation Widget with States

Source: https://pub.dev/packages/motor/index

Demonstrates using SequenceMotionBuilder to animate a sequence of states. It automatically progresses through phases based on the 'playing' property and uses a 'smoothSpring' motion. The builder function defines the UI based on the current phase and animation value, typically a rotation angle. This is suitable for continuous animations like loading indicators.

```dart
enum LoadingState { idle, spinning, complete }

SequenceMotionBuilder<LoadingState, double>(
  sequence: .states({
    .idle: 0.0,
    .spinning: 2 * pi,
    .complete: 2 * pi,
  }, motion: .smoothSpring()),
  converter: .single,
  playing: true, // Auto-progress through phases
  currentPhase: currentState, // Or control manually
  onTransition: (transition) => print('Now in transition: $transition'),
  builder: (context, rotation, phase, child) {
    return Transform.rotate(
      angle: rotation,
      child: Icon(
        phase == .complete ? Icons.check : Icons.refresh,
        color: phase == .complete ? Colors.green : Colors.blue,
      ),
    );
  },
)

```

--------------------------------

### Flutter Sequence Animations with Motor

Source: https://context7.com/context7/pub_dev_packages_motor/llms.txt

Implements multi-phase animations using enums and MotionSequence to manage state transitions. Utilizes SequenceMotionBuilder and requires the 'motor' package.

```dart
enum ButtonState { idle, pressed, loading, success }

class StateSequenceExample extends StatefulWidget {
  @override
  State<StateSequenceExample> createState() => _StateSequenceExampleState();
}

class _StateSequenceExampleState extends State<StateSequenceExample> {
  ButtonState currentState = ButtonState.idle;

  // Define sequence with state-value mappings
  final buttonSequence = MotionSequence<ButtonState, Offset>.states({
    ButtonState.idle: Offset(0, 0),
    ButtonState.pressed: Offset(0, 5),
    ButtonState.loading: Offset(10, 0),
    ButtonState.success: Offset(0, -10),
  }, motion: CupertinoMotion.bouncy());

  @override
  Widget build(BuildContext context) {
    return SequenceMotionBuilder<ButtonState, Offset>(
      sequence: buttonSequence,
      converter: OffsetMotionConverter(),
      playing: false, // Manual control via currentPhase
      currentPhase: currentState,
      onTransition: (transition) {
        print('Transitioning from ${transition.from} to ${transition.to}');
      },
      builder: (context, offset, phase, child) {
        return Transform.translate(
          offset: offset,
          child: ElevatedButton(
            onPressed: () {
              setState(() {
                currentState = ButtonState.values[
                  (currentState.index + 1) % ButtonState.values.length
                ];
              });
            },
            style: ElevatedButton.styleFrom(
              backgroundColor: phase == ButtonState.success
                ? Colors.green
                : Colors.blue,
            ),
            child: Text(_getButtonText(phase)),
          ),
        );
      },
    );
  }

  String _getButtonText(ButtonState phase) {
    switch (phase) {
      case ButtonState.idle: return 'Press Me';
      case ButtonState.pressed: return 'Pressed';
      case ButtonState.loading: return 'Loading...';
      case ButtonState.success: return 'Success!';
    }
  }
}

```

--------------------------------

### Custom Motion Converter using MotionConverter.custom

Source: https://pub.dev/packages/motor/index

Demonstrates a more concise way to create a custom MotionConverter using the `MotionConverter.custom` factory constructor. This approach requires providing lambda functions for `normalize` and `denormalize` operations, similar to the full class implementation but often shorter for simple type conversions.

```dart
final converter = MotionConverter.custom(
  normalize: (value) => [value.x, value.y, value.z],
  denormalize: (values) => Vector3(values[0], values[1], values[2]),
);

```

--------------------------------

### Add Motor to pubspec.yaml

Source: https://pub.dev/packages/motor/index

Instructions on how to add the Motor package as a dependency to your Flutter project's pubspec.yaml file.

```yaml
dependencies:
  motor: ^1.0.0-dev.0

```

--------------------------------

### Step-Based Sequence Animations in Dart

Source: https://context7.com/context7/pub_dev_packages_motor/llms.txt

Demonstrates creating step-based sequences for ordered progressions of values, such as colors. It supports various loop modes like seamless, none, pingPong, and regular looping. This functionality is useful for creating cyclical or one-off animations through a defined set of states.

```dart
class StepSequenceExample extends StatefulWidget {
  @override
  State<StepSequenceExample> createState() => _StepSequenceExampleState();
}

class _StepSequenceExampleState extends State<StepSequenceExample> {
  // Step sequence with loop mode
  final colorSequence = MotionSequence<int, Color>.steps(
    [
      Colors.red,
      Colors.orange,
      Colors.yellow,
      Colors.green,
      Colors.blue,
      Colors.purple,
    ],
    motion: CupertinoMotion.smooth(),
    loop: LoopMode.seamless, // Smooth circular loop
  );

  @override
  Widget build(BuildContext context) {
    return SequenceMotionBuilder<int, Color>(
      sequence: colorSequence,
      converter: ColorRgbMotionConverter(),
      playing: true, // Auto-play through all steps
      builder: (context, color, phase, child) {
        return Container(
          width: 200,
          height: 200,
          decoration: BoxDecoration(
            color: color,
            shape: BoxShape.circle,
            boxShadow: [
              BoxShadow(
                color: color.withOpacity(0.5),
                blurRadius: 20,
                spreadRadius: 5,
              ),
            ],
          ),
          child: Center(
            child: Text(
              'Step $phase',
              style: TextStyle(color: Colors.white, fontSize: 24),
            ),
          ),
        );
      },
    );
  }
}

// Alternative loop modes
final loopNone = MotionSequence<int, double>.steps(
  [0.0, 100.0, 200.0],
  motion: Motion.linear(Duration(seconds: 1)),
  loop: LoopMode.none, // Play once and stop
);

final loopPingPong = MotionSequence<int, double>.steps(
  [0.0, 100.0, 200.0],
  motion: Motion.linear(Duration(seconds: 1)),
  loop: LoopMode.pingPong, // Forward then backward
);

final loopRegular = MotionSequence<int, double>.steps(
  [0.0, 100.0, 200.0],
  motion: Motion.linear(Duration(seconds: 1)),
  loop: LoopMode.loop, // Jump back to start and repeat
);

```

--------------------------------

### Flutter: Define Animation Motions

Source: https://pub.dev/packages/motor/versions/1

Demonstrates how to define different types of motion for Flutter animations using the Motor package. Includes duration-based (linear, curved) and physics-based (spring, Cupertino, Material) motions.

```dart
// Duration-based motion (traditional Flutter approach)
final linear = Motion.linear(Duration(seconds: 1));

final withCurve = Motion.curved(Duration(seconds: 1), Curves.easeInOut);

// Physics-based motion (natural, responsive)
final spring = CupertinoMotion.bouncy(); // Or `Motion.bouncySpring()`
final material = MaterialSpringMotion.standardSpatialDefault();
```

--------------------------------

### Defining Complex Sequences with Varying Motions

Source: https://pub.dev/packages/motor/index

Illustrates how to define a MotionSequence where each state can have a different associated motion type. This allows for fine-tuned animation characteristics, such as using a 'smoothSpring' for loading, a 'bouncySpring' for errors, and a 'curved' motion for success states, providing distinct visual feedback for each phase.

```dart
final complexSequence = MotionSequence<AppState, ButtonStyle>.statesWithMotions({
  .loading: (loadingStyle, .smoothSpring()),
  .error: (errorStyle, .bouncySpring()), // Extra bounce for attention
  .success: (successStyle, .curved(Duration(seconds: 2), Curves.ease)),
});

```

--------------------------------

### Flutter: Create Custom CupertinoMotion

Source: https://pub.dev/packages/motor/versions/1

Shows how to create a custom CupertinoMotion instance in Flutter by specifying duration and bounce parameters. This allows for tailored iOS-style spring animations.

```dart
final customMotion = CupertinoMotion(
  duration: Duration(milliseconds: 600),
  bounce: 0.3,
);
```

--------------------------------

### Add Motor Dependency to Flutter Project

Source: https://pub.dev/packages/motor/install

This command adds the motor package as a dependency to your Flutter project's `pubspec.yaml` file. It ensures that the package is available for use in your Dart code. The command `flutter pub add motor` automatically updates the `pubspec.yaml` and fetches the package.

```bash
$ flutter pub add motor

```

--------------------------------

### Motor Package pubspec.yaml Configuration

Source: https://pub.dev/packages/motor/versions/1.0.0-dev.10/install

This snippet shows how the motor package is declared as a dependency in a project's pubspec.yaml file. This configuration is typically added automatically when using `dart pub add` or `flutter pub add`.

```yaml
dependencies:
  motor: ^1.0.0-dev.10
```

--------------------------------

### Add motor package dependency

Source: https://pub.dev/packages/motor/versions/1.0.0-dev.5/install

Instructions on how to add the motor package as a dependency to your Dart or Flutter project using the `dart pub add` or `flutter pub add` commands. This automatically updates your pubspec.yaml file.

```shell
$ dart pub add motor
```

```shell
$ flutter pub add motor
```

--------------------------------

### Add motor dependency for Dart

Source: https://pub.dev/packages/motor/versions/1.0.0-dev.2/install

Command to add the 'motor' package as a dependency in a Dart project using the Dart package manager.

```bash
dart pub add motor
```

--------------------------------

### SequenceMotionBuilder for State Animations (Dart)

Source: https://pub.dev/packages/motor/versions/1.0

Demonstrates using SequenceMotionBuilder to animate UI elements based on different states. It supports defining states, motions, and a builder function to render the UI. Automatic playback is enabled by default.

```dart
enum LoadingState { idle, spinning, complete }

SequenceMotionBuilder<LoadingState, double>(
  sequence: .states({
    .idle: 0.0,
    .spinning: 2 * pi,
    .complete: 2 * pi,
  }, motion: .smoothSpring()),
  converter: .single,
  playing: true, // Auto-progress through phases
  currentPhase: currentState, // Or control manually
  onPhaseChanged: (phase) => print('Now in phase: $phase'),
  builder: (context, rotation, phase, child) {
    return Transform.rotate(
      angle: rotation,
      child: Icon(
        phase == .complete ? Icons.check : Icons.refresh,
        color: phase == .complete ? Colors.green : Colors.blue,
      ),
    );
  },
)

```

--------------------------------

### Animate Single Dimension with SingleMotionBuilder in Flutter

Source: https://context7.com/context7/pub_dev_packages_motor/llms.txt

Demonstrates how to use the SingleMotionBuilder widget to animate single-dimensional values like size and color, automatically handling transitions driven by the specified motion.

```dart
class AnimatedContainer extends StatefulWidget {
  @override
  State<AnimatedContainer> createState() => _AnimatedContainerState();
}

class _AnimatedContainerState extends State<AnimatedContainer> {
  double targetSize = 100.0;

  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        SingleMotionBuilder(
          motion: CupertinoMotion.bouncy(),
          value: targetSize,
          builder: (context, value, child) {
            return Container(
              width: value,
              height: value,
              decoration: BoxDecoration(
                color: Colors.blue,
                borderRadius: BorderRadius.circular(value * 0.2),
              ),
              child: child,
            );
          },
          child: Icon(Icons.star, color: Colors.white),
        ),
        SizedBox(height: 20),
        ElevatedButton(
          onPressed: () {
            setState(() {
              targetSize = targetSize == 100.0 ? 200.0 : 100.0;
            });
          },
          child: Text('Toggle Size'),
        ),
      ],
    );
  }
}
```

--------------------------------

### Animate Offset with MotionBuilder Widget (Dart)

Source: https://context7.com/context7/pub_dev_packages_motor/llms.txt

Demonstrates how to use the MotionBuilder widget with an Offset type and the built-in OffsetMotionConverter to animate a widget's position. It includes a button to trigger the animation by updating the target position.

```dart
class AnimatedOffsetWidget extends StatefulWidget {
  @override
  State<AnimatedOffsetWidget> createState() => _AnimatedOffsetWidgetState();
}

class _AnimatedOffsetWidgetState extends State<AnimatedOffsetWidget> {
  Offset targetPosition = Offset.zero;

  @override
  Widget build(BuildContext context) {
    return Stack(
      children: [
        MotionBuilder(
          motion: CupertinoMotion.bouncy(),
          value: targetPosition,
          from: Offset.zero,
          converter: OffsetMotionConverter(),
          builder: (context, value, child) {
            return Transform.translate(
              offset: value,
              child: child,
            );
          },
          child: Container(
            width: 100,
            height: 100,
            decoration: BoxDecoration(
              color: Colors.red,
              borderRadius: BorderRadius.circular(20),
            ),
          ),
        ),
        Positioned(
          bottom: 20,
          left: 20,
          right: 20,
          child: ElevatedButton(
            onPressed: () {
              setState(() {
                targetPosition = Offset(
                  (targetPosition.dx == 0) ? 200 : 0,
                  (targetPosition.dy == 0) ? 300 : 0,
                );
              });
            },
            child: Text('Move'),
          ),
        ),
      ],
    );
  }
}
```
Tokens:
Raw