JavaScript preprocessors can help make authoring JavaScript easier and more convenient.
Babel includes JSX processing.
Search for and use JavaScript packages from npm here. By selecting a package, an import
statement will be added to the top of the JavaScript editor for this package.
Using packages here is powered by Skypack, which makes packages from npm not only available on a CDN, but prepares them for native JavaScript ES6 import
usage.
All packages are different, so refer to their docs for how they work.
If you're using React / ReactDOM, make sure to turn on Babel for the JSX processing.
If active, Pens will autosave every 30 seconds after being saved once.
If enabled, the preview panel updates automatically as you code. If disabled, use the "Run" button to update.
If enabled, your code will be formatted when you actively save your Pen. Note: your code becomes un-folded during formatting.
Visit your global Editor Settings.
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';
}
Also see: Tab Triggers