Pen Settings

JavaScript

Babel is required to process package imports. If you need a different preprocessor remove all packages first.

Behavior

Save Automatically?

If active, Pens will autosave every 30 seconds after being saved once.

Auto-Updating Preview

If enabled, the preview panel updates automatically as you code. If disabled, use the "Run" button to update.

Format on Save

If enabled, your code will be formatted when you actively save your Pen. Note: your code becomes un-folded during formatting.

Editor Settings

Code Indentation

Want to change your Syntax Highlighting theme, Fonts and more?

Visit your global Editor Settings.

Flutter

              
                import 'dart:math';
import 'dart:ui';
import 'package:flutter/material.dart';

void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        brightness: Brightness.dark,
        primarySwatch: Colors.pink,
        sliderTheme: SliderThemeData().copyWith(
            trackHeight: 3.0, overlayShape: SliderComponentShape.noOverlay),
      ),
      home: Scaffold(
        body: SafeArea(
          child: DoublePendulum(
            animationDuration: Duration(seconds: 1),
          ),
        ),
      ),
    );
  }
}

class DoublePendulum extends StatefulWidget {
  final Duration animationDuration;
  DoublePendulum({this.animationDuration});

  @override
  _DoublePendulumState createState() => _DoublePendulumState();
}

class _DoublePendulumState extends State<DoublePendulum>
    with SingleTickerProviderStateMixin {
  AnimationController _animationController;

  PendulumSimulationManager pendulumManager;
  double noOfPendulums = 3;
  double gravity = 9.8;
  double pendulum1Length = 100;
  double pendulum2Length = 100;
  double pendulum1Mass = 7;
  double pendulum2Mass = 5;
  double pendulum1Angle = 70;
  double pendulum2Angle = 30;
  bool showMenu = false;
  bool animationStopped = false;
  @override
  void initState() {
    super.initState();

    // Initializing the animation controller with a defined duraion.
    _animationController = AnimationController(
      vsync: this,
      duration: widget.animationDuration,
    )..repeat();
  }

  @override
  Widget build(BuildContext context) {
    final avlblSize = MediaQuery.of(context).size;

    pendulumManager = PendulumSimulationManager(
      noOfDoublePendulums: noOfPendulums,
      gravity: gravity /
          (60 *
              2), //Dividing gravity accross frames, assuming 60 FPS. Change this correct for the framerate.
      pendulum1Length: pendulum1Length,
      pendulum1Mass: pendulum1Mass,
      pendulum2Length: pendulum2Length,
      pendulum2Mass: pendulum2Mass,
      pendulum1Angle: pendulum1Angle * 0.0174533,
      pendulum2Angle: pendulum2Angle * 0.0174533,
    );
    pendulumManager.initializePendulums();

    return Stack(
      children: <Widget>[
        Center(
          child: AnimatedBuilder(
            animation: _animationController,
            builder: (context, _) {
              pendulumManager.reEstimateAngles();
              return CustomPaint(
                painter:
                    DoublePendulumPainter(pendulumPaintInfos: pendulumManager),
              );
            },
          ),
        ),
        Align(
          alignment: Alignment.topLeft,
          child: Row(
            mainAxisAlignment: MainAxisAlignment.spaceEvenly,
            crossAxisAlignment: CrossAxisAlignment.start,
            children: <Widget>[
              Expanded(
                flex: 1,
                child: Card(
                  child: ExpansionTile(
                    title: Text('Settings'),
                    initiallyExpanded: false,
                    children: <Widget>[
                      ListView(
                        shrinkWrap: true,
                        children: <Widget>[
                          SliderWithLabel(
                            widgetLabel: 'Pendulums : ',
                            min: 1,
                            max: 50,
                            showNDecimal: 0,
                            callBack: (double value) {
                              setState(() {
                                noOfPendulums = value;
                              });
                            },
                            division: 50,
                            initialValue: noOfPendulums,
                          ),
                          SliderWithLabel(
                            widgetLabel: 'Gravity : ',
                            min: 1,
                            max: 20,
                            callBack: (double value) {
                              setState(() {
                                gravity = value;
                              });
                            },
                            initialValue: gravity,
                          ),
                          SliderWithLabel(
                            widgetLabel: 'Pendulum-1 Length : ',
                            min: 1,
                            max: 200,
                            callBack: (double value) {
                              setState(() {
                                pendulum1Length = value;
                              });
                            },
                            initialValue: pendulum1Length,
                          ),
                          SliderWithLabel(
                            widgetLabel: 'Pendulum-2 Length : ',
                            min: 1,
                            max: 200,
                            callBack: (double value) {
                              setState(() {
                                pendulum2Length = value;
                              });
                            },
                            initialValue: pendulum2Length,
                          ),
                          SliderWithLabel(
                            widgetLabel: 'Pendulum-1 Mass : ',
                            min: 0.01,
                            max: 10,
                            callBack: (double value) {
                              setState(() {
                                pendulum1Mass = value;
                              });
                            },
                            initialValue: pendulum1Mass,
                          ),
                          SliderWithLabel(
                            widgetLabel: 'Pendulum-2 Mass : ',
                            min: 0.01,
                            max: 10,
                            callBack: (double value) {
                              setState(() {
                                pendulum2Mass = value;
                              });
                            },
                            initialValue: pendulum2Mass,
                          ),
                          SliderWithLabel(
                            widgetLabel: 'Pendulum-1 Angle : ',
                            min: 0,
                            max: 360,
                            callBack: (double value) {
                              setState(() {
                                pendulum1Angle = value;
                              });
                            },
                            initialValue: pendulum1Angle,
                          ),
                          SliderWithLabel(
                            widgetLabel: 'Pendulum-2 Angle : ',
                            min: 0,
                            max: 360,
                            callBack: (double value) {
                              setState(() {
                                pendulum2Angle = value;
                              });
                            },
                            initialValue: pendulum2Angle,
                          ),
                        ],
                      )
                    ],
                  ),
                ),
              ),
              if (avlblSize.width > 600) Spacer(flex: 2),
              Align(
                alignment: Alignment.bottomRight,
                child: Padding(
                  padding: const EdgeInsets.all(8.0),
                  child: FloatingActionButton.extended(
                    label: Text(animationStopped ? 'Play' : 'Stop',
                        style: TextStyle(color: Colors.grey)),
                    backgroundColor: Theme.of(context).primaryColorDark,
                    onPressed: () {
                      setState(() {
                        animationStopped = !animationStopped;
                        animationStopped
                            ? _animationController.reset()
                            : _animationController.repeat();
                      });
                    },
                    icon: animationStopped
                        ? Icon(
                            Icons.play_arrow,
                            color: Colors.green,
                            size: 32,
                          )
                        : Icon(
                            Icons.stop,
                            color: Colors.red,
                            size: 28,
                          ),
                  ),
                ),
              ),
            ],
          ),
        ),
      ],
    );
  }
}

final pendulumPaint = Paint()..strokeWidth = 4.0;
final pendulum2MassPaint = Paint()
  ..color = Colors.red
  ..style = PaintingStyle.fill;
Paint _trailPaint = Paint()
  ..strokeWidth = 0.2
  ..color = Colors.white.withOpacity(0.2);

class DoublePendulumPainter extends CustomPainter {
  final PendulumSimulationManager pendulumPaintInfos;

  DoublePendulumPainter({this.pendulumPaintInfos});

  @override
  void paint(Canvas canvas, Size size) {
    // Trasnslate to the middle of the screen.
    canvas.translate(
        pendulumPaintInfos.origin.dx, pendulumPaintInfos.origin.dy);
    pendulumPaintInfos.allDoublePendulums
        .forEach((List<PendulumInfo> pendulumPaintInfo) {
      // Draws the line for pendulum 1
      canvas.drawLine(
          pendulumPaintInfo[0].origin,
          pendulumPaintInfo[0].endPoint,
          pendulumPaint..color = pendulumPaintInfo[0].paintColor);
      // draws the bob for the first pendulum
      canvas.drawCircle(pendulumPaintInfo[0].endPoint,
          pendulumPaintInfo[0].mass, pendulumPaint);
      // Draws the line for pendulum 2
      canvas.drawLine(
          pendulumPaintInfo[1].origin,
          pendulumPaintInfo[1].endPoint,
          pendulumPaint..color = pendulumPaintInfo[1].paintColor);
      // draws the bob for the second pendulum
      canvas.drawCircle(pendulumPaintInfo[1].endPoint,
          pendulumPaintInfo[1].mass, pendulumPaint..color = Colors.red);
      // draws the trail points.
      canvas.drawPoints(
          PointMode.lines, pendulumPaintInfo[1].trailPoints, _trailPaint);
    });
  }

  @override
  bool shouldRepaint(CustomPainter oldDelegate) {
    return true;
  }
}

class PendulumSimulationManager {
  double noOfDoublePendulums;
  double pendulum1Length;
  double pendulum2Length;
  double pendulum1Mass;
  double pendulum2Mass;
  double pendulum1Angle;
  double pendulum2Angle;
  Offset origin;
  double gravity;

  List<List<PendulumInfo>> allDoublePendulums = [];

  PendulumSimulationManager({
    this.origin = Offset.zero,
    @required this.noOfDoublePendulums,
    @required this.gravity,
    this.pendulum1Length = 200,
    this.pendulum1Mass = 6,
    this.pendulum2Length = 200,
    this.pendulum2Mass = 3,
    this.pendulum1Angle = pi / 2,
    this.pendulum2Angle = pi / 4,
  });

  void initializePendulums() {
    for (int i = 0; i < noOfDoublePendulums; i++) {
      Color pednulumColor =
          Colors.primaries[i+20 % Colors.primaries.length];
      PendulumInfo pendulum1 = PendulumInfo(
        angle: pendulum1Angle +
            (i * 0.0174533), // to account for degrees to radians.
        length: pendulum1Length,
        mass: pendulum1Mass,
        origin: Offset.zero,
        angularVel: 0,
        acc: 0,
        paintColor: pednulumColor,
      );
      PendulumInfo pendulum2 = PendulumInfo(
        angle: pendulum2Angle,
        length: pendulum2Length,
        mass: pendulum2Mass,
        origin: pendulum1.endPoint,
        angularVel: 0,
        acc: 0,
        paintColor: pednulumColor,
      );
      allDoublePendulums.add([pendulum1, pendulum2]);
    }
  }

  void reEstimateAngles() {
    allDoublePendulums.forEach((List<PendulumInfo> pendulums) {
      pendulums[0].angularVel += _simulatedAnglePendulum1(pendulums);
      pendulums[1].angularVel += _simulatedAnglePendulum2(pendulums);
      pendulums[0].angle += pendulums[0].angularVel;
      pendulums[1].angle += pendulums[1].angularVel;
      pendulums[1].origin = pendulums[0].endPoint;
      pendulums[1].trailPoints.add(pendulums[1].endPoint);
      if (pendulums[1].trailPoints.length > 100)
        pendulums[1].trailPoints.removeAt(0);
    });
  }

  double _simulatedAnglePendulum1(List<PendulumInfo> pendulums) {
    PendulumInfo p1 = pendulums[0];
    PendulumInfo p2 = pendulums[1];

    double numerator = (-gravity * (2 * p1.mass + p2.mass)) *
            (sin(p1.angle) - p2.mass * gravity * sin(p1.angle - 2 * p2.angle)) -
        (2 * sin(p1.angle - p2.angle) * p2.mass) *
            (pow(p2.angularVel, 2) * p2.length +
                pow(p1.angularVel, 2) * p1.length * cos(p1.angle - p2.angle));

    double denominator = p1.length *
        (2 * p1.mass + p2.mass - p2.mass * cos(2 * p1.angle - 2 * p2.angle));

    return numerator / denominator;
  }

  double _simulatedAnglePendulum2(List<PendulumInfo> pendulums) {
    PendulumInfo p1 = pendulums[0];
    PendulumInfo p2 = pendulums[1];
    double numerator = 2 *
        sin(p1.angle - p2.angle) *
        (p1.angularVel * p1.angularVel * p1.length * (p1.mass + p2.mass) +
            gravity * (p1.mass + p2.mass) * cos(p1.angle) +
            p2.angularVel *
                p2.angularVel *
                p2.length *
                p2.mass *
                cos(p1.angle - p2.angle));
    double denominator = p2.length *
        (2 * p1.mass + p2.mass - p2.mass * cos(2 * p1.angle - 2 * p2.angle));

    return numerator / denominator;
  }

  List<List<PendulumInfo>> get allPendudlums => allDoublePendulums;
}

typedef Callback = void Function(double newValue);

class SliderWithLabel extends StatefulWidget {
  final String widgetLabel;
  final int division;
  final double min;
  final double max;
  final Callback callBack;
  final int showNDecimal;
  final double initialValue;

  SliderWithLabel({
    this.widgetLabel,
    this.division,
    @required this.min,
    @required this.max,
    @required this.callBack,
    @required this.initialValue,
    this.showNDecimal = 1,
  });

  @override
  _SliderWithLabelState createState() => _SliderWithLabelState();
}

class _SliderWithLabelState extends State<SliderWithLabel> {
  double value;
  @override
  void initState() {
    super.initState();
    value = widget.initialValue;
  }

  @override
  Widget build(BuildContext context) {
    return Padding(
      padding: const EdgeInsets.all(4.0),
      child: Column(
        crossAxisAlignment: CrossAxisAlignment.start,
        mainAxisAlignment: MainAxisAlignment.spaceAround,
        children: <Widget>[
          Text(widget.widgetLabel + value.toStringAsFixed(widget.showNDecimal)),
          Slider(
              divisions: widget.division,
              value: value,
              min: widget.min,
              max: widget.max,
              onChanged: (newValue) {
                setState(() {
                  value = newValue;
                  widget.callBack(newValue);
                });
              }),
        ],
      ),
    );
  }
}

class PendulumInfo {
  double length;
  double mass;
  double angle;

  ///Angular Velocity
  double angularVel;

  /// acceleration
  double acc;

  Color paintColor;
  Offset origin;
  List<Offset> trailPoints = [];

  PendulumInfo(
      {this.length,
      this.mass,
      this.angle,
      this.origin,
      this.angularVel = 1,
      this.acc = 1,
      this.paintColor});

  Offset get endPoint =>
      Offset((length * sin(angle)), (length * cos(angle))) + origin;

  @override
  toString() => 'Pendulum has end point at $endPoint';
}

              
            
!
999px

Console