Skip to content

F
Front-End
Commit d3efe7da authored by Adam Barth's avatar Adam Barth Committed by GitHub
Browse files
Options

Remove flutter_sprites (#5996) 

This code is now in its own standalone library. The library is in a private git
repository in the flutter organization because the code is unmaintained. If
you're interested in using and maintaining this code, please contact
flutter-dev@googlegroups.com for more information.
parent b7af062a
Hide whitespace changes
Inline Side-by-side
Showing with 1 addition and 6296 deletions
dev/benchmarks/complex_layout/pubspec.yaml
View file @ d3efe7da
......@@ -6,8 +6,7 @@ dependencies:
path: ../../../packages/flutter
flutter_driver:
path: ../../../packages/flutter_driver
# Also update dev/manual_tests/pubspec.yaml
# and examples/flutter_gallery/pubspec.yaml
# Also update examples/flutter_gallery/pubspec.yaml
flutter_gallery_assets:
git:
url: https://flutter.googlesource.com/gallery-assets
......
dev/bots/test.sh
View file @ d3efe7da
......@@ -31,7 +31,6 @@ fi
# run tests
(cd packages/flutter; flutter test $COVERAGE_FLAG)
(cd packages/flutter_driver; dart -c test/all.dart)
(cd packages/flutter_sprites; flutter test)
(cd packages/flutter_test; flutter test)
(cd packages/flutter_tools; dart -c test/all.dart)
......
dev/manual_tests/fitness_demo.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
import 'dart:async';
import 'dart:math' as math;
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:flutter_sprites/flutter_sprites.dart';
ImageMap _images;
SpriteSheet _sprites;
class FitnessDemo extends StatelessWidget {
FitnessDemo({ Key key }) : super(key: key);
static const String routeName = '/fitness';
@override
Widget build(BuildContext context) {
return new Scaffold(
appBar: new AppBar(
title: new Text('Fitness')
),
body: new _FitnessDemoContents()
);
}
}
class _FitnessDemoContents extends StatefulWidget {
_FitnessDemoContents({ Key key }) : super(key: key);
@override
_FitnessDemoContentsState createState() => new _FitnessDemoContentsState();
}
class _FitnessDemoContentsState extends State<_FitnessDemoContents> {
Future<Null> _loadAssets(AssetBundle bundle) async {
_images = new ImageMap(bundle);
await _images.load(<String>[
'packages/flutter_gallery_assets/fitness_demo/jumpingjack.png',
]);
String json = await DefaultAssetBundle.of(context).loadString('packages/flutter_gallery_assets/fitness_demo/jumpingjack.json');
_sprites = new SpriteSheet(_images['packages/flutter_gallery_assets/fitness_demo/jumpingjack.png'], json);
}
@override
void initState() {
super.initState();
AssetBundle bundle = DefaultAssetBundle.of(context);
_loadAssets(bundle).then((_) {
setState(() {
_assetsLoaded = true;
workoutAnimation = new _WorkoutAnimationNode(
onPerformedJumpingJack: () {
setState(() {
_count += 1;
});
},
onSecondPassed: (int seconds) {
setState(() {
_time = seconds;
});
}
);
});
});
}
bool _assetsLoaded = false;
int _count = 0;
int _time = 0;
int get kcal => (_count * 0.2).toInt();
_WorkoutAnimationNode workoutAnimation;
@override
Widget build(BuildContext context) {
if (!_assetsLoaded)
return new Container();
Color buttonColor;
String buttonText;
VoidCallback onButtonPressed;
if (workoutAnimation.workingOut) {
buttonColor = Colors.red[500];
buttonText = "STOP WORKOUT";
onButtonPressed = endWorkout;
} else {
buttonColor = Theme.of(context).primaryColor;
buttonText = "START WORKOUT";
onButtonPressed = startWorkout;
}
return new Material(
child: new Column(
mainAxisAlignment: MainAxisAlignment.center,
children: <Widget>[
new Flexible(
child: new Container(
decoration: new BoxDecoration(backgroundColor: Colors.grey[800]),
child: new SpriteWidget(workoutAnimation, SpriteBoxTransformMode.scaleToFit)
)
),
new Padding(
padding: new EdgeInsets.only(top: 20.0),
child: new Text('JUMPING JACKS', style: Theme.of(context).textTheme.title)
),
new Padding(
padding: new EdgeInsets.only(top: 20.0, bottom: 20.0),
child: new Row(
mainAxisAlignment: MainAxisAlignment.center,
children: <Widget>[
_createInfoPanelCell(Icons.accessibility, '$_count', 'COUNT'),
_createInfoPanelCell(Icons.timer, _formatSeconds(_time), 'TIME'),
_createInfoPanelCell(Icons.flash_on, '$kcal', 'KCAL')
]
)
),
new Padding(
padding: new EdgeInsets.only(bottom: 16.0),
child: new SizedBox(
width: 300.0,
height: 72.0,
child: new RaisedButton (
onPressed: onButtonPressed,
color: buttonColor,
child: new Text(
buttonText,
style: new TextStyle(color: Colors.white, fontSize: 20.0)
)
)
)
)
]
)
);
}
Widget _createInfoPanelCell(IconData icon, String value, String description) {
Color color;
if (workoutAnimation.workingOut)
color = Colors.black87;
else
color = Theme.of(context).disabledColor;
return new Container(
width: 100.0,
child: new Center(
child: new Column(
children: <Widget>[
new Icon(icon, size: 48.0, color: color),
new Text(value, style: new TextStyle(fontSize: 24.0, color: color)),
new Text(description, style: new TextStyle(color: color))
]
)
)
);
}
String _formatSeconds(int seconds) {
int minutes = seconds ~/ 60;
String secondsStr = "${seconds % 60}".padLeft(2, "0");
return "$minutes:$secondsStr";
}
void startWorkout() {
setState(() {
_count = 0;
_time = 0;
workoutAnimation.start();
});
}
void endWorkout() {
setState(() {
workoutAnimation.stop();
if (_count >= 3) {
showDialog(
context: context,
child: new Stack(children: <Widget>[
new _Fireworks(),
new Dialog(
title: new Text('Awesome workout'),
content: new Text('You have completed $_count jumping jacks. Good going!'),
actions: <Widget>[
new FlatButton(
child: new Text('SWEET'),
onPressed: () { Navigator.pop(context); }
)
]
)
])
);
}
});
}
}
typedef void _SecondPassedCallback(int seconds);
class _WorkoutAnimationNode extends NodeWithSize {
_WorkoutAnimationNode({
this.onPerformedJumpingJack,
this.onSecondPassed
}) : super(const Size(1024.0, 1024.0)) {
reset();
_progress = new _ProgressCircle(const Size(800.0, 800.0));
_progress.pivot = const Point(0.5, 0.5);
_progress.position = const Point(512.0, 512.0);
addChild(_progress);
_jumpingJack = new _JumpingJack((){
onPerformedJumpingJack();
});
_jumpingJack.scale = 0.5;
_jumpingJack.position = const Point(512.0, 550.0);
addChild(_jumpingJack);
}
final VoidCallback onPerformedJumpingJack;
final _SecondPassedCallback onSecondPassed;
int seconds;
bool workingOut;
static const int _kTargetMillis = 1000 * 30;
int _startTimeMillis;
_ProgressCircle _progress;
_JumpingJack _jumpingJack;
void reset() {
seconds = 0;
workingOut = false;
}
void start() {
reset();
_startTimeMillis = new DateTime.now().millisecondsSinceEpoch;
workingOut = true;
_jumpingJack.animateJumping();
}
void stop() {
workingOut = false;
_jumpingJack.neutralPose();
}
@override
void update(double dt) {
if (workingOut) {
int millis = new DateTime.now().millisecondsSinceEpoch - _startTimeMillis;
int newSeconds = (millis) ~/ 1000;
if (newSeconds != seconds) {
seconds = newSeconds;
onSecondPassed(seconds);
}
_progress.value = millis / _kTargetMillis;
} else {
_progress.value = 0.0;
}
}
}
class _ProgressCircle extends NodeWithSize {
_ProgressCircle(Size size, [this.value = 0.0]) : super(size);
static const double _kTwoPI = math.PI * 2.0;
static const double _kEpsilon = .0000001;
static const double _kSweep = _kTwoPI - _kEpsilon;
double value;
@override
void paint(Canvas canvas) {
applyTransformForPivot(canvas);
Paint circlePaint = new Paint()
..color = Colors.white30
..strokeWidth = 24.0
..style = PaintingStyle.stroke;
canvas.drawCircle(
new Point(size.width / 2.0, size.height / 2.0),
size.width / 2.0,
circlePaint
);
Paint pathPaint = new Paint()
..color = Colors.purple[500]
..strokeWidth = 25.0
..style = PaintingStyle.stroke;
double angle = value.clamp(0.0, 1.0) * _kSweep;
Path path = new Path()
..arcTo(Point.origin & size, -math.PI / 2.0, angle, false);
canvas.drawPath(path, pathPaint);
}
}
class _JumpingJack extends Node {
_JumpingJack(VoidCallback onPerformedJumpingJack) {
left = new _JumpingJackSide(false, onPerformedJumpingJack);
right = new _JumpingJackSide(true, null);
addChild(left);
addChild(right);
}
void animateJumping() {
left.animateJumping();
right.animateJumping();
}
void neutralPose() {
left.neutralPosition(true);
right.neutralPosition(true);
}
_JumpingJackSide left;
_JumpingJackSide right;
}
class _JumpingJackSide extends Node {
_JumpingJackSide(bool right, this.onPerformedJumpingJack) {
// Torso and head
torso = _createPart('torso.png', const Point(512.0, 512.0));
addChild(torso);
head = _createPart('head.png', const Point(512.0, 160.0));
torso.addChild(head);
if (right) {
torso.opacity = 0.0;
head.opacity = 0.0;
torso.scaleX = -1.0;
}
// Left side movable parts
upperArm = _createPart('upper-arm.png', const Point(445.0, 220.0));
torso.addChild(upperArm);
lowerArm = _createPart('lower-arm.png', const Point(306.0, 200.0));
upperArm.addChild(lowerArm);
hand = _createPart('hand.png', const Point(215.0, 127.0));
lowerArm.addChild(hand);
upperLeg = _createPart('upper-leg.png', const Point(467.0, 492.0));
torso.addChild(upperLeg);
lowerLeg = _createPart('lower-leg.png', const Point(404.0, 660.0));
upperLeg.addChild(lowerLeg);
foot = _createPart('foot.png', const Point(380.0, 835.0));
lowerLeg.addChild(foot);
torso.setPivotAndPosition(Point.origin);
neutralPosition(false);
}
_JumpingJackPart torso;
_JumpingJackPart head;
_JumpingJackPart upperArm;
_JumpingJackPart lowerArm;
_JumpingJackPart hand;
_JumpingJackPart lowerLeg;
_JumpingJackPart upperLeg;
_JumpingJackPart foot;
final VoidCallback onPerformedJumpingJack;
_JumpingJackPart _createPart(String textureName, Point pivotPosition) {
return new _JumpingJackPart(_sprites[textureName], pivotPosition);
}
void animateJumping() {
actions.stopAll();
actions.run(new ActionSequence(<Action>[
_createPoseAction(null, 0, 0.5),
new ActionCallFunction(_animateJumpingLoop)
]));
}
void _animateJumpingLoop() {
actions.run(new ActionRepeatForever(
new ActionSequence(<Action>[
_createPoseAction(0, 1, 0.30),
_createPoseAction(1, 2, 0.30),
_createPoseAction(2, 1, 0.30),
_createPoseAction(1, 0, 0.30),
new ActionCallFunction(() {
if (onPerformedJumpingJack != null)
onPerformedJumpingJack();
})
])
));
}
void neutralPosition(bool animate) {
actions.stopAll();
if (animate) {
actions.run(_createPoseAction(null, 1, 0.5));
} else {
List<double> d = _dataForPose(1);
upperArm.rotation = d[0];
lowerArm.rotation = d[1];
hand.rotation = d[2];
upperLeg.rotation = d[3];
lowerLeg.rotation = d[4];
foot.rotation = d[5];
torso.position = new Point(0.0, d[6]);
}
}
ActionInterval _createPoseAction(int startPose, int endPose, double duration) {
List<double> d0 = _dataForPose(startPose);
List<double> d1 = _dataForPose(endPose);
List<ActionTween> tweens = <ActionTween>[
_tweenRotation(upperArm, d0[0], d1[0], duration),
_tweenRotation(lowerArm, d0[1], d1[1], duration),
_tweenRotation(hand, d0[2], d1[2], duration),
_tweenRotation(upperLeg, d0[3], d1[3], duration),
_tweenRotation(lowerLeg, d0[4], d1[4], duration),
_tweenRotation(foot, d0[5], d1[5], duration),
new ActionTween(
(Point a) => torso.position = a,
new Point(0.0, d0[6]),
new Point(0.0, d1[6]),
duration
)
];
return new ActionGroup(tweens);
}
ActionTween _tweenRotation(_JumpingJackPart part, double r0, double r1, double duration) {
return new ActionTween(
(double a) => part.rotation = a,
r0,
r1,
duration
);
}
List<double> _dataForPose(int pose) {
if (pose == null)
return _dataForCurrentPose();
if (pose == 0) {
return <double>[
-80.0, // Upper arm rotation
-30.0, // Lower arm rotation
-10.0, // Hand rotation
-15.0, // Upper leg rotation
5.0, // Lower leg rotation
15.0, // Foot rotation
0.0 // Torso y offset
];
} else if (pose == 1) {
return <double>[
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
-70.0
];
} else {
return <double>[
40.0,
30.0,
10.0,
20.0,
-20.0,
15.0,
40.0
];
}
}
List<double> _dataForCurrentPose() {
return <double>[
upperArm.rotation,
lowerArm.rotation,
hand.rotation,
upperLeg.rotation,
lowerLeg.rotation,
foot.rotation,
torso.position.y
];
}
}
class _JumpingJackPart extends Sprite {
_JumpingJackPart(Texture texture, this.pivotPosition) : super(texture);
final Point pivotPosition;
void setPivotAndPosition(Point newPosition) {
pivot = new Point(pivotPosition.x / 1024.0, pivotPosition.y / 1024.0);
position = newPosition;
for (Node child in children) {
_JumpingJackPart subPart = child;
subPart.setPivotAndPosition(
new Point(
subPart.pivotPosition.x - pivotPosition.x,
subPart.pivotPosition.y - pivotPosition.y
)
);
}
}
}
class _Fireworks extends StatefulWidget {
_Fireworks({ Key key }) : super(key: key);
@override
_FireworksState createState() => new _FireworksState();
}
class _FireworksState extends State<_Fireworks> {
@override
void initState() {
super.initState();
fireworks = new _FireworksNode();
}
_FireworksNode fireworks;
@override
Widget build(BuildContext context) {
return new SpriteWidget(fireworks);
}
}
class _FireworksNode extends NodeWithSize {
_FireworksNode() : super(const Size(1024.0, 1024.0));
double _countDown = 0.0;
@override
void update(double dt) {
if (_countDown <= 0.0) {
_addExplosion();
_countDown = randomDouble();
}
_countDown -= dt;
}
Color _randomExplosionColor() {
double rand = randomDouble();
if (rand < 0.25)
return Colors.pink[200];
else if (rand < 0.5)
return Colors.lightBlue[200];
else if (rand < 0.75)
return Colors.purple[200];
else
return Colors.cyan[200];
}
void _addExplosion() {
Color startColor = _randomExplosionColor();
Color endColor = startColor.withAlpha(0);
ParticleSystem system = new ParticleSystem(
_sprites['particle-0.png'],
numParticlesToEmit: 100,
emissionRate: 1000.0,
rotateToMovement: true,
startRotation: 90.0,
endRotation: 90.0,
speed: 100.0,
speedVar: 50.0,
startSize: 1.0,
startSizeVar: 0.5,
gravity: const Offset(0.0, 30.0),
colorSequence: new ColorSequence.fromStartAndEndColor(startColor, endColor)
);
system.position = new Point(randomDouble() * 1024.0, randomDouble() * 1024.0);
addChild(system);
}
}
void main() {
runApp(new MaterialApp(
title: 'Fitness',
home: new FitnessDemo()
));
}
dev/manual_tests/pubspec.yaml
View file @ d3efe7da
......@@ -2,14 +2,6 @@ name: flutter_manual_tests
dependencies:
flutter:
path: ../../packages/flutter
flutter_sprites:
path: ../../packages/flutter_sprites
# Also update dev/manual_tests/pubspec.yaml
# and dev/benchmarks/complex_layout/pubspec.yaml
flutter_gallery_assets:
git:
url: https://flutter.googlesource.com/gallery-assets
ref: ef928550119411358b8b25e16aecde6ace513526
dev_dependencies:
test: any # flutter_test provides the version constraints
......
dev/manual_tests/weather_demo.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
import 'dart:async';
import 'dart:ui' as ui show Image;
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:flutter_sprites/flutter_sprites.dart';
ImageMap _images;
SpriteSheet _sprites;
enum WeatherType {
sun,
rain,
snow
}
class WeatherDemo extends StatefulWidget {
WeatherDemo({ Key key }) : super(key: key);
static const String routeName = '/weather';
@override
_WeatherDemoState createState() => new _WeatherDemoState();
}
class _WeatherDemoState extends State<WeatherDemo> {
Future<Null> _loadAssets(AssetBundle bundle) async {
_images = new ImageMap(bundle);
await _images.load(<String>[
'packages/flutter_gallery_assets/weather_demo/clouds-0.png',
'packages/flutter_gallery_assets/weather_demo/clouds-1.png',
'packages/flutter_gallery_assets/weather_demo/ray.png',
'packages/flutter_gallery_assets/weather_demo/sun.png',
'packages/flutter_gallery_assets/weather_demo/weathersprites.png',
'packages/flutter_gallery_assets/weather_demo/icon-sun.png',
'packages/flutter_gallery_assets/weather_demo/icon-rain.png',
'packages/flutter_gallery_assets/weather_demo/icon-snow.png'
]);
String json = await bundle.loadString('packages/flutter_gallery_assets/weather_demo/weathersprites.json');
_sprites = new SpriteSheet(_images['packages/flutter_gallery_assets/weather_demo/weathersprites.png'], json);
}
@override
void initState() {
super.initState();
AssetBundle bundle = DefaultAssetBundle.of(context);
_loadAssets(bundle).then((_) {
setState(() {
assetsLoaded = true;
weatherWorld = new WeatherWorld();
});
});
}
bool assetsLoaded = false;
WeatherWorld weatherWorld;
@override
Widget build(BuildContext context) {
if (!assetsLoaded) {
return new Scaffold(
appBar: new AppBar(
title: new Text('Weather')
),
body: new Container(
decoration: new BoxDecoration(
backgroundColor: const Color(0xff4aaafb)
)
)
);
}
return new Scaffold(
appBar: new AppBar(
title: new Text('Weather')
),
body: new Material(
child: new Stack(
children: <Widget>[
new SpriteWidget(weatherWorld),
new Align(
alignment: new FractionalOffset(0.5, 0.8),
child: new Row(
mainAxisAlignment: MainAxisAlignment.center,
children: <Widget>[
new WeatherButton(
onPressed: () {
setState(() {
weatherWorld.weatherType = WeatherType.sun;
});
},
selected: weatherWorld.weatherType == WeatherType.sun,
icon: "packages/flutter_gallery_assets/weather_demo/icon-sun.png"
),
new WeatherButton(
onPressed: () {
setState(() {
weatherWorld.weatherType = WeatherType.rain;
});
},
selected: weatherWorld.weatherType == WeatherType.rain,
icon: "packages/flutter_gallery_assets/weather_demo/icon-rain.png"
),
new WeatherButton(
onPressed: () {
setState(() {
weatherWorld.weatherType = WeatherType.snow;
});
},
selected: weatherWorld.weatherType == WeatherType.snow,
icon: "packages/flutter_gallery_assets/weather_demo/icon-snow.png"
)
]
)
)
]
)
)
);
}
}
const double _kWeatherButtonSize = 56.0;
const double _kWeatherIconSize = 36.0;
class WeatherButton extends StatelessWidget {
WeatherButton({ this.icon, this.selected, this.onPressed, Key key }) : super(key: key);
final String icon;
final bool selected;
final VoidCallback onPressed;
@override
Widget build(BuildContext context) {
Color color;
if (selected)
color = Theme.of(context).primaryColor;
else
color = const Color(0x33000000);
return new Padding(
padding: const EdgeInsets.all(15.0),
child: new Material(
color: color,
type: MaterialType.circle,
elevation: 0,
child: new Container(
width: _kWeatherButtonSize,
height: _kWeatherButtonSize,
child: new InkWell(
onTap: onPressed,
child: new Center(
child: new Image.asset(
icon,
width: _kWeatherIconSize,
height: _kWeatherIconSize
)
)
)
)
)
);
}
}
const List<Color> _kBackgroundColorsTop = const <Color>[
const Color(0xff5ebbd5),
const Color(0xff0b2734),
const Color(0xffcbced7)
];
const List<Color> _kBackgroundColorsBottom = const <Color>[
const Color(0xff4aaafb),
const Color(0xff4c5471),
const Color(0xffe0e3ec)
];
class WeatherWorld extends NodeWithSize {
WeatherWorld() : super(const Size(2048.0, 2048.0)) {
_background = new GradientNode(
this.size,
_kBackgroundColorsTop[0],
_kBackgroundColorsBottom[0]
);
addChild(_background);
_cloudsSharp = new CloudLayer(
image: _images['packages/flutter_gallery_assets/weather_demo/clouds-0.png'],
rotated: false,
dark: false,
loopTime: 20.0
);
addChild(_cloudsSharp);
_cloudsDark = new CloudLayer(
image: _images['packages/flutter_gallery_assets/weather_demo/clouds-1.png'],
rotated: true,
dark: true,
loopTime: 40.0
);
addChild(_cloudsDark);
_cloudsSoft = new CloudLayer(
image: _images['packages/flutter_gallery_assets/weather_demo/clouds-1.png'],
rotated: false,
dark: false,
loopTime: 60.0
);
addChild(_cloudsSoft);
_sun = new Sun();
_sun.position = const Point(1024.0, 1024.0);
_sun.scale = 1.5;
addChild(_sun);
_rain = new Rain();
addChild(_rain);
_snow = new Snow();
addChild(_snow);
}
GradientNode _background;
CloudLayer _cloudsSharp;
CloudLayer _cloudsSoft;
CloudLayer _cloudsDark;
Sun _sun;
Rain _rain;
Snow _snow;
WeatherType get weatherType => _weatherType;
WeatherType _weatherType = WeatherType.sun;
set weatherType(WeatherType weatherType) {
if (weatherType == _weatherType)
return;
_weatherType = weatherType;
// Fade the background
_background.actions.stopAll();
_background.actions.run(new ActionTween(
(Color a) => _background.colorTop = a,
_background.colorTop,
_kBackgroundColorsTop[weatherType.index],
1.0
));
_background.actions.run(new ActionTween(
(Color a) => _background.colorBottom = a,
_background.colorBottom,
_kBackgroundColorsBottom[weatherType.index],
1.0
));
_cloudsDark.active = weatherType != WeatherType.sun;
_sun.active = weatherType == WeatherType.sun;
_rain.active = weatherType == WeatherType.rain;
_snow.active = weatherType == WeatherType.snow;
}
@override
void spriteBoxPerformedLayout() {
_sun.position = spriteBox.visibleArea.topLeft + const Offset(350.0, 180.0);
}
}
class GradientNode extends NodeWithSize {
GradientNode(Size size, this.colorTop, this.colorBottom) : super(size);
Color colorTop;
Color colorBottom;
@override
void paint(Canvas canvas) {
applyTransformForPivot(canvas);
Rect rect = Point.origin & size;
Paint gradientPaint = new Paint()..shader = new LinearGradient(
begin: FractionalOffset.topLeft,
end: FractionalOffset.bottomLeft,
colors: <Color>[colorTop, colorBottom],
stops: <double>[0.0, 1.0]
).createShader(rect);
canvas.drawRect(rect, gradientPaint);
}
}
class CloudLayer extends Node {
CloudLayer({ ui.Image image, bool dark, bool rotated, double loopTime }) {
_sprites.add(_createSprite(image, dark, rotated));
_sprites[0].position = const Point(1024.0, 1024.0);
addChild(_sprites[0]);
_sprites.add(_createSprite(image, dark, rotated));
_sprites[1].position = const Point(3072.0, 1024.0);
addChild(_sprites[1]);
actions.run(new ActionRepeatForever(
new ActionTween(
(Point a) => position = a,
Point.origin,
const Point(-2048.0, 0.0),
loopTime)
));
}
List<Sprite> _sprites = <Sprite>[];
Sprite _createSprite(ui.Image image, bool dark, bool rotated) {
Sprite sprite = new Sprite.fromImage(image);
if (rotated)
sprite.scaleX = -1.0;
if (dark) {
sprite.colorOverlay = const Color(0xff000000);
sprite.opacity = 0.0;
}
return sprite;
}
set active(bool active) {
double opacity;
if (active) opacity = 1.0;
else opacity = 0.0;
for (Sprite sprite in _sprites) {
sprite.actions.stopAll();
sprite.actions.run(new ActionTween(
(double a) => sprite.opacity = a,
sprite.opacity,
opacity,
1.0
));
}
}
}
const double _kNumSunRays = 50.0;
class Sun extends Node {
Sun() {
_sun = new Sprite.fromImage(_images['packages/flutter_gallery_assets/weather_demo/sun.png']);
_sun.scale = 4.0;
_sun.transferMode = TransferMode.plus;
addChild(_sun);
_rays = <Ray>[];
for (int i = 0; i < _kNumSunRays; i += 1) {
Ray ray = new Ray();
addChild(ray);
_rays.add(ray);
}
}
Sprite _sun;
List<Ray> _rays;
set active(bool active) {
actions.stopAll();
double targetOpacity;
if (!active) targetOpacity = 0.0;
else targetOpacity = 1.0;
actions.run(
new ActionTween(
(double a) => _sun.opacity = a,
_sun.opacity,
targetOpacity,
2.0
)
);
if (active) {
for (Ray ray in _rays) {
actions.run(new ActionSequence(<Action>[
new ActionDelay(1.5),
new ActionTween(
(double a) => ray.opacity = a,
ray.opacity,
ray.maxOpacity,
1.5
)
]));
}
} else {
for (Ray ray in _rays) {
actions.run(new ActionTween(
(double a) => ray.opacity = a,
ray.opacity,
0.0,
0.2
));
}
}
}
}
class Ray extends Sprite {
double _rotationSpeed;
double maxOpacity;
Ray() : super.fromImage(_images['packages/flutter_gallery_assets/weather_demo/ray.png']) {
pivot = const Point(0.0, 0.5);
transferMode = TransferMode.plus;
rotation = randomDouble() * 360.0;
maxOpacity = randomDouble() * 0.2;
opacity = maxOpacity;
scaleX = 2.5 + randomDouble();
scaleY = 0.3;
_rotationSpeed = randomSignedDouble() * 2.0;
// Scale animation
double scaleTime = randomSignedDouble() * 2.0 + 4.0;
actions.run(new ActionRepeatForever(
new ActionSequence(<Action>[
new ActionTween((double a) => scaleX = a, scaleX, scaleX * 0.5, scaleTime),
new ActionTween((double a) => scaleX = a, scaleX * 0.5, scaleX, scaleTime)
])
));
}
@override
void update(double dt) {
rotation += dt * _rotationSpeed;
}
}
class Rain extends Node {
Rain() {
_addParticles(1.0);
_addParticles(1.5);
_addParticles(2.0);
}
List<ParticleSystem> _particles = <ParticleSystem>[];
void _addParticles(double distance) {
ParticleSystem particles = new ParticleSystem(
_sprites['raindrop.png'],
transferMode: TransferMode.srcATop,
posVar: const Point(1300.0, 0.0),
direction: 90.0,
directionVar: 0.0,
speed: 1000.0 / distance,
speedVar: 100.0 / distance,
startSize: 1.2 / distance,
startSizeVar: 0.2 / distance,
endSize: 1.2 / distance,
endSizeVar: 0.2 / distance,
life: 1.5 * distance,
lifeVar: 1.0 * distance
);
particles.position = const Point(1024.0, -200.0);
particles.rotation = 10.0;
particles.opacity = 0.0;
_particles.add(particles);
addChild(particles);
}
set active(bool active) {
actions.stopAll();
for (ParticleSystem system in _particles) {
if (active) {
actions.run(
new ActionTween(
(double a) => system.opacity = a,
system.opacity,
1.0,
2.0
));
} else {
actions.run(
new ActionTween(
(double a) => system.opacity = a,
system.opacity,
0.0,
0.5
));
}
}
}
}
class Snow extends Node {
Snow() {
_addParticles(_sprites['flake-0.png'], 1.0);
_addParticles(_sprites['flake-1.png'], 1.0);
_addParticles(_sprites['flake-2.png'], 1.0);
_addParticles(_sprites['flake-3.png'], 1.5);
_addParticles(_sprites['flake-4.png'], 1.5);
_addParticles(_sprites['flake-5.png'], 1.5);
_addParticles(_sprites['flake-6.png'], 2.0);
_addParticles(_sprites['flake-7.png'], 2.0);
_addParticles(_sprites['flake-8.png'], 2.0);
}
List<ParticleSystem> _particles = <ParticleSystem>[];
void _addParticles(Texture texture, double distance) {
ParticleSystem particles = new ParticleSystem(
texture,
transferMode: TransferMode.srcATop,
posVar: const Point(1300.0, 0.0),
direction: 90.0,
directionVar: 0.0,
speed: 150.0 / distance,
speedVar: 50.0 / distance,
startSize: 1.0 / distance,
startSizeVar: 0.3 / distance,
endSize: 1.2 / distance,
endSizeVar: 0.2 / distance,
life: 20.0 * distance,
lifeVar: 10.0 * distance,
emissionRate: 2.0,
startRotationVar: 360.0,
endRotationVar: 360.0,
radialAccelerationVar: 10.0 / distance,
tangentialAccelerationVar: 10.0 / distance
);
particles.position = const Point(1024.0, -50.0);
particles.opacity = 0.0;
_particles.add(particles);
addChild(particles);
}
set active(bool active) {
actions.stopAll();
for (ParticleSystem system in _particles) {
if (active) {
actions.run(
new ActionTween((double a) => system.opacity = a, system.opacity, 1.0, 2.0
));
} else {
actions.run(
new ActionTween((double a) => system.opacity = a, system.opacity, 0.0, 0.5
));
}
}
}
}
void main() {
runApp(new MaterialApp(
title: 'Weather',
home: new WeatherDemo()
));
}
examples/flutter_gallery/pubspec.yaml
View file @ d3efe7da
......@@ -9,7 +9,6 @@ dependencies:
flutter_markdown:
path: ../../packages/flutter_markdown
# Also update dev/benchmarks/complex_layout/pubspec.yaml
# and examples/flutter_gallery/pubspec.yaml
flutter_gallery_assets:
git:
url: https://flutter.googlesource.com/gallery-assets
......
packages/flutter_sprites/README.md deleted 100644 → 0
View file @ b7af062a
# Flutter Sprites
Flutter Sprites is a toolkit for building complex, high performance animations and 2D games with Flutter. Your sprite render tree lives inside a SpriteWidget that mixes seamlessly with other Flutter and Material widgets. You can use Flutter Sprites to create anything from an animated icon to a full fledged game.
This guide assumes a basic knowledge of Flutter and Dart. You can find an example of Flutter Sprites in the Flutter Gallery in the Weather demo, or in the flutter/game repository on Github.
## Setting up a SpriteWidget
The first thing you need to do to use Flutter Sprites is to setup a SpriteWidget with a root node that is used to draw it's contents. Any sprite nodes that you add to the root node will be rendered by the SpriteWidget. Typically, your root node is part of your app's state. This is an example of how you can setup a custom stateful widget with Flutter Sprites:
import 'package:flutter/material.dart';
import 'package:flutter_sprites/flutter_sprites.dart';
class MyWidget extends StatefulWidget {
@override
MyWidgetState createState() => new MyWidgetState();
}
class MyWidgetState extends State<MyWidget> {
NodeWithSize rootNode;
@override
void initState() {
super.initState();
rootNode = new NodeWithSize(const Size(1024.0, 1024.0));
}
@override
Widget build(BuildContext context) {
return new SpriteWidget(rootNode);
}
}
The root node that you provide the SpriteWidget is a NodeWithSize, the size of the root node defines the coordinate system used by the SpriteWidget. By default the SpriteWidget uses letterboxing to display its contents. This means that the size that you give the root node will determine how the SpriteWidget's contents will be scaled to fit. If it doesn't fit perfectly in the area of the widget, either its top and bottom or the left and right side will be trimmed. You can optionally pass in a parameter to the SpriteWidget for other scaling options depending on your needs.
When you have added the SpriteWidget to your app's build method it will automatically start running animations and handling user input. There is no need for any other extra setup.
## Adding objects to your node graph
Your SpriteWidget manages a node graph, the root node is the NodeWithSize that is passed in to the SpriteWidget when it's created. To render sprites, particles systems, or any other objects simply add them to the node graph.
Each node in the node graph has a transform. The transform is inherited by its children, this makes it possible to build more complex structures by grouping objects together as children to a node and then manipulating the parent node. For example the following code creates a car sprite with two wheels attached to it. The car is added to the root node.
Sprite car = new Sprite.fromImage(carImage);
Sprite frontWheel = new Sprite.fromImage(wheelImage);
Sprite rearWheel = new Sprite.fromImage(wheelImage);
frontWheel.position = const Point(100, 50);
rearWheel.position = const Point(-100, 50);
car.addChild(frontWheel);
car.addChild(rearWheel);
rootNode.addChild(car);
You can manipulate the transform by setting the position, rotation, scale, and skew properties.
## Sprites, textures, and sprite sheets
The most common node type is the Sprite node. A sprite simply draws an image to the screen. Sprites can be drawn from Image objects or Texture objects. A texture is a part of an Image. Using a SpriteSheet you can pack several texture elements within a single image. This saves space in the device's gpu memory and also make drawing faster. Currently Flutter Sprites supports sprite sheets in json format and produced with a tool such as TexturePacker. It's uncommon to manually edit the sprite sheet files. You can create a SpriteSheet with a definition in json and an image:
SpriteSheet sprites = new SpriteSheet(myImage, jsonCode);
Texture texture = sprites['texture.png'];
## The frame cycle
Each time a new frame is rendered to screen Flutter Sprites will perform a number of actions. Sometimes when creating more advanced interactive animations or games, the order in which these actions are performed may matter.
This is the order things will happen:
1. Handle input events
2. Run animation actions
3. Call update functions on nodes
4. Apply constraints
5. Render the frame to screen
Read more about each of the different phases below.
## Handling user input
You can subclass any node type to handle touches. To receive touches, you need to set the userInteractionEnabled property to true and override the handleEvent method. If the node you are subclassing doesn't have a size, you will also need to override the isPointInside method.
class EventHandlingNode extends NodeWithSize {
EventHandlingNode(Size size) : super(size) {
userInteractionEnabled = true;
}
@override handleEvent(SpriteBoxEvent event) {
if (event.type == PointerDownEvent)
...
else if (event.type == PointerMoveEvent)
...
return true;
}
}
If you want your node to receive multiple touches, set the handleMultiplePointers property to true. Each touch down or dragged touch will generate a separate call to the handleEvent method, you can distinguish each touch by its pointer property.
## Animating using actions
Flutter Sprites provides easy to use functions for animating nodes through actions. You can combine simple action blocks to create more complex animations.
To execute an action animation you first build the action itself, then pass it to the run method of a nodes action manager (see the Tweens section below for an example).
### Tweens
Tweens are the simplest building block for creating an animation. It will interpolate a value or property over a specified time period. You provide the ActionTween class with a setter function, its start and end value, and the duration for the tween.
After creating a tween, execute it by running it through a node's action manager.
Node myNode = new Node();
ActionTween myTween = new ActionTween(
(Point a) => myNode.position = a,
Point.origin,
const Point(100.0, 0.0),
1.0
);
myNode.actions.run(myTween);
You can animate values of different types, such as floats, points, rectangles, and even colors. You can also optionally provide the ActionTween class with an easing function.
### Sequences
When you need to play two or more actions in a sequence, use the ActionSequence class:
ActionSequence sequence = new ActionSequence([
firstAction,
middleAction,
lastAction
]);
### Groups
Use ActionGroup to play actions in parallel:
ActionGroup group = new ActionGroup([
action0,
action1
]);
### Repeat
You can loop any action, either a fixed number of times, or until the end of times:
ActionRepeat repeat = new ActionRepeat(loopedAction, 5);
ActionRepeatForever longLoop = new ActionRepeatForever(loopedAction);
### Composition
It's possible to create more complex actions by composing them in any way:
ActionSequence complexAction = new ActionSequence([
new ActionRepeat(myLoop, 2),
new ActionGroup([
action0,
action1
])
]);
## Handle update events
Each frame, update events are sent to each node in the current node tree. Override the update method to manually do animations or to perform game logic.
MyNode extends Node {
@override
update(double dt) {
// Move the node at a constant speed
position += new Offset(dt * 1.0, 0.0);
}
}
## Defining constraints
Constraints are used to constrain properties of nodes. They can be used to position nodes relative other nodes, or adjust the rotation or scale. You can apply more than one constraint to a single node.
For example, you can use a constraint to make a node follow another node at a specific distance with a specified dampening. The dampening will smoothen out the following node's movement.
followingNode.constraints = [
new ConstraintPositionToNode(
targetNode,
offset: const Offset(0.0, 100.0),
dampening: 0.5
)
];
Constraints are applied at the end of the frame cycle. If you need them to be applied at any other time, you can directly call the applyConstraints method of a Node object.
## Perform custom drawing
Flutter Sprites provides a default set of drawing primitives, but there are cases where you may want to perform custom drawing. To do this you will need to subclass either the Node or NodeWithSize class and override the paint method:
class RedCircle extends Node {
RedCircle(this.radius);
double radius;
@override
void paint(Canvas canvas) {
canvas.drawCircle(
Point.origin,
radius,
new Paint()..color = const Color(0xffff0000)
);
}
}
If you are overriding a NodeWithSize you may want to call applyTransformForPivot before starting drawing to account for the node's pivot point. After the call the coordinate system is setup so you can perform drawing starting at origo to the size of the node.
@override
void paint(Canvas canvas) {
applyTransformForPivot(canvas);
canvas.drawRect(
new Rect.fromLTWH(0.0, 0.0, size.width, size.height),
myPaint
);
}
## Add effects using particle systems
Particle systems are great for creating effects such as rain, smoke, or fire. It's easy to setup a particle system, but there are very many properties that can be tweaked. The best way of to get a feel for how they work is to simply play around with the them.
This is an example of how a particle system can be created, configured, and added to the scene:
ParticleSystem particles = new ParticleSystem(
particleTexture,
posVar: const Point(100, 100.0),
startSize: 1.0,
startSizeVar: 0.5,
endSize: 2.0,
endSizeVar: 1.0,
life: 1.5 * distance,
lifeVar: 1.0 * distance
);
rootNode.addChild(particles);
\ No newline at end of file
packages/flutter_sprites/lib/flutter_sprites.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
/// A sprite toolkit built on top of Flutter.
library flutter_sprites;
import 'dart:async';
import 'dart:convert';
import 'dart:math' as math;
import 'dart:typed_data';
import 'dart:ui' as ui show Image;
import 'package:flutter/gestures.dart';
import 'package:flutter/rendering.dart';
import 'package:flutter/scheduler.dart';
import 'package:flutter/services.dart';
import 'package:flutter/widgets.dart';
import 'package:meta/meta.dart';
import 'package:vector_math/vector_math_64.dart';
part 'src/action.dart';
part 'src/action_spline.dart';
part 'src/color_sequence.dart';
part 'src/constraint.dart';
part 'src/effect_line.dart';
part 'src/image_map.dart';
part 'src/label.dart';
part 'src/layer.dart';
part 'src/nine_slice_sprite.dart';
part 'src/node.dart';
part 'src/node3d.dart';
part 'src/node_with_size.dart';
part 'src/particle_system.dart';
part 'src/sprite.dart';
part 'src/sprite_box.dart';
part 'src/sprite_widget.dart';
part 'src/spritesheet.dart';
part 'src/texture.dart';
part 'src/textured_line.dart';
part 'src/util.dart';
part 'src/virtual_joystick.dart';
packages/flutter_sprites/lib/src/action.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
part of flutter_sprites;
/// Signature for callbacks used by the [ActionCallFunction].
typedef void ActionCallback();
/// Actions are used to animate properties of nodes or any other type of
/// objects. The actions are powered by an [ActionController], typically
/// associated with a [Node]. The most commonly used action is the
/// [ActionTween] which interpolates a property between two values over time.
///
/// Actions can be nested in different ways; played in sequence using the
/// [ActionSequence], or looped using the [ActionRepeat].
///
/// You should typically not override this class directly, instead override
/// [ActionInterval] or [ActionInstant] if you need to create a new action
/// class.
abstract class Action {
Object _tag;
bool _finished = false;
bool _added = false;
/// Moves to the next time step in an action, [dt] is the delta time since
/// the last time step in seconds. Typically this method is called from the
/// [ActionController].
void step(double dt);
/// Sets the action to a specific point in time. The [t] value that is passed
/// in is a normalized value 0.0 to 1.0 of the duration of the action. Every
/// action will always recieve a callback with the end time point (1.0),
/// unless it is cancelled.
void update(double t) {
}
void _reset() {
_finished = false;
}
/// The total time it will take to complete the action, in seconds.
double get duration => 0.0;
}
/// Signature for callbacks for setting properties, used by [ActionTween].
typedef void SetterCallback(dynamic value);
/// The abstract class for an action that changes properties over a time
/// interval, optionally using an easing curve.
abstract class ActionInterval extends Action {
/// Creates a new ActionInterval, typically you will want to pass in a
/// [duration] to specify how long time the action will take to complete.
ActionInterval([this._duration = 0.0, this.curve]);
@override
double get duration => _duration;
double _duration;
/// The animation curve used to ease the animation.
///
/// myAction.curve = bounceOut;
Curve curve;
bool _firstTick = true;
double _elapsed = 0.0;
@override
void step(double dt) {
if (_firstTick) {
_firstTick = false;
} else {
_elapsed += dt;
}
double t;
if (this._duration == 0.0) {
t = 1.0;
} else {
t = (_elapsed / _duration).clamp(0.0, 1.0);
}
if (curve == null) {
update(t);
} else {
update(curve.transform(t));
}
if (t >= 1.0) _finished = true;
}
}
/// An action that repeats another action a fixed number of times.
class ActionRepeat extends ActionInterval {
/// The number of times the [action] is repeated.
final int numRepeats;
/// The action that is repeated.
final ActionInterval action;
int _lastFinishedRepeat = -1;
/// Creates a new action that is repeats the passed in action a fixed number
/// of times.
///
/// var myLoop = new ActionRepeat(myAction);
ActionRepeat(this.action, this.numRepeats) {
_duration = action.duration * numRepeats;
}
@override
void update(double t) {
int currentRepeat = math.min((t * numRepeats.toDouble()).toInt(), numRepeats - 1);
for (int i = math.max(_lastFinishedRepeat, 0); i < currentRepeat; i++) {
if (!action._finished) action.update(1.0);
action._reset();
}
_lastFinishedRepeat = currentRepeat;
double ta = (t * numRepeats.toDouble()) % 1.0;
action.update(ta);
if (t >= 1.0) {
action.update(1.0);
action._finished = true;
}
}
}
/// An action that repeats an action an indefinite number of times.
class ActionRepeatForever extends Action {
/// The action that is repeated indefinitely.
final ActionInterval action;
double _elapsedInAction = 0.0;
/// Creates a new action with the action that is passed in.
///
/// var myInifiniteLoop = new ActionRepeatForever(myAction);
ActionRepeatForever(this.action);
@override
void step(double dt) {
_elapsedInAction += dt;
while (_elapsedInAction > action.duration) {
_elapsedInAction -= action.duration;
if (!action._finished) action.update(1.0);
action._reset();
}
_elapsedInAction = math.max(_elapsedInAction, 0.0);
double t;
if (action._duration == 0.0) {
t = 1.0;
} else {
t = (_elapsedInAction / action._duration).clamp(0.0, 1.0);
}
action.update(t);
}
}
/// An action that plays a number of supplied actions in sequence. The duration
/// of the [ActionSequence] with be the sum of the durations of the actions
/// passed in to the constructor.
class ActionSequence extends ActionInterval {
Action _a;
Action _b;
double _split;
/// Creates a new action with the list of actions passed in.
///
/// var mySequence = new ActionSequence([myAction0, myAction1, myAction2]);
ActionSequence(List<Action> actions) {
assert(actions.length >= 2);
if (actions.length == 2) {
// Base case
_a = actions[0];
_b = actions[1];
} else {
_a = actions[0];
_b = new ActionSequence(actions.sublist(1));
}
// Calculate split and duration
_duration = _a.duration + _b.duration;
if (_duration > 0) {
_split = _a.duration / _duration;
} else {
_split = 1.0;
}
}
@override
void update(double t) {
if (t < _split) {
// Play first action
double ta;
if (_split > 0.0) {
ta = (t / _split).clamp(0.0, 1.0);
} else {
ta = 1.0;
}
_updateWithCurve(_a, ta);
} else if (t >= 1.0) {
// Make sure everything is finished
if (!_a._finished) _finish(_a);
if (!_b._finished) _finish(_b);
} else {
// Play second action, but first make sure the first has finished
if (!_a._finished) _finish(_a);
double tb;
if (_split < 1.0) {
tb = (1.0 - (1.0 - t) / (1.0 - _split)).clamp(0.0, 1.0);
} else {
tb = 1.0;
}
_updateWithCurve(_b, tb);
}
}
void _updateWithCurve(Action action, double t) {
if (action is ActionInterval) {
ActionInterval actionInterval = action;
if (actionInterval.curve == null) {
action.update(t);
} else {
action.update(actionInterval.curve.transform(t));
}
} else {
action.update(t);
}
if (t >= 1.0) {
action._finished = true;
}
}
void _finish(Action action) {
action.update(1.0);
action._finished = true;
}
@override
void _reset() {
super._reset();
_a._reset();
_b._reset();
}
}
/// An action that plays the supplied actions in parallell. The duration of the
/// [ActionGroup] will be the maximum of the durations of the actions used to
/// compose this action.
class ActionGroup extends ActionInterval {
List<Action> _actions;
/// Creates a new action with the list of actions passed in.
///
/// var myGroup = new ActionGroup([myAction0, myAction1, myAction2]);
ActionGroup(this._actions) {
for (Action action in _actions) {
if (action.duration > _duration) {
_duration = action.duration;
}
}
}
@override
void update(double t) {
if (t >= 1.0) {
// Finish all unfinished actions
for (Action action in _actions) {
if (!action._finished) {
action.update(1.0);
action._finished = true;
}
}
} else {
for (Action action in _actions) {
if (action.duration == 0.0) {
// Fire all instant actions immediately
if (!action._finished) {
action.update(1.0);
action._finished = true;
}
} else {
// Update child actions
double ta = (t / (action.duration / duration)).clamp(0.0, 1.0);
if (ta < 1.0) {
if (action is ActionInterval) {
ActionInterval actionInterval = action;
if (actionInterval.curve == null) {
action.update(ta);
} else {
action.update(actionInterval.curve.transform(ta));
}
} else {
action.update(ta);
}
} else if (!action._finished){
action.update(1.0);
action._finished = true;
}
}
}
}
}
@override
void _reset() {
for (Action action in _actions) {
action._reset();
}
}
}
/// An action that doesn't perform any other task than taking time. This action
/// is typically used in a sequence to space out other events.
class ActionDelay extends ActionInterval {
/// Creates a new action with the specified [delay]
ActionDelay(double delay) : super(delay);
}
/// An action that doesn't have a duration. If this class is overridden to
/// create custom instant actions, only the [fire] method should be overriden.
abstract class ActionInstant extends Action {
@override
void step(double dt) {
}
@override
void update(double t) {
fire();
_finished = true;
}
/// Called when the action is executed. If you are implementing your own
/// ActionInstant, override this method.
void fire();
}
/// An action that calls a custom function when it is fired.
class ActionCallFunction extends ActionInstant {
ActionCallback _function;
/// Creates a new callback action with the supplied callback.
///
/// var myAction = new ActionCallFunction(() { print("Hello!";) });
ActionCallFunction(this._function);
@override
void fire() {
_function();
}
}
/// An action that removes the supplied node from its parent when it's fired.
class ActionRemoveNode extends ActionInstant {
Node _node;
/// Creates a new action with the node to remove as its argument.
///
/// var myAction = new ActionRemoveNode(myNode);
ActionRemoveNode(this._node);
@override
void fire() {
_node.removeFromParent();
}
}
/// An action that tweens a property between two values, optionally using an
/// animation curve. This is one of the most common building blocks when
/// creating actions. The tween class can be used to animate properties of the
/// type [Point], [Size], [Rect], [double], or [Color].
class ActionTween extends ActionInterval {
/// Creates a new tween action. The [setter] will be called to update the
/// animated property from [startVal] to [endVal] over the [duration] time in
/// seconds. Optionally an animation [curve] can be passed in for easing the
/// animation.
///
/// // Animate myNode from its current position to 100.0, 100.0 during
/// // 1.0 second and a bounceOut easing
/// var myTween = new ActionTween(
/// (a) => myNode.position = a,
/// myNode.position,
/// new Point(100.0, 100.0,
/// 1.0,
/// bounceOut
/// );
/// myNode.actions.run(myTween);
ActionTween(this.setter, this.startVal, this.endVal, double duration, [Curve curve]) : super(duration, curve) {
_computeDelta();
}
/// The setter method used to set the property being animated.
final SetterCallback setter;
/// The start value of the animation.
final dynamic startVal;
/// The end value of the animation.
final dynamic endVal;
dynamic _delta;
void _computeDelta() {
if (startVal is Point) {
// Point
double xStart = startVal.x;
double yStart = startVal.y;
double xEnd = endVal.x;
double yEnd = endVal.y;
_delta = new Point(xEnd - xStart, yEnd - yStart);
} else if (startVal is Size) {
// Size
double wStart = startVal.width;
double hStart = startVal.height;
double wEnd = endVal.width;
double hEnd = endVal.height;
_delta = new Size(wEnd - wStart, hEnd - hStart);
} else if (startVal is Rect) {
// Rect
double lStart = startVal.left;
double tStart = startVal.top;
double rStart = startVal.right;
double bStart = startVal.bottom;
double lEnd = endVal.left;
double tEnd = endVal.top;
double rEnd = endVal.right;
double bEnd = endVal.bottom;
_delta = new Rect.fromLTRB(lEnd - lStart, tEnd - tStart, rEnd - rStart, bEnd - bStart);
} else if (startVal is double) {
// Double
_delta = endVal - startVal;
} else if (startVal is Color) {
// Color
int aDelta = endVal.alpha - startVal.alpha;
int rDelta = endVal.red - startVal.red;
int gDelta = endVal.green - startVal.green;
int bDelta = endVal.blue - startVal.blue;
_delta = new _ColorDiff(aDelta, rDelta, gDelta, bDelta);
} else {
assert(false);
}
}
@override
void update(double t) {
dynamic newVal;
if (startVal is Point) {
// Point
double xStart = startVal.x;
double yStart = startVal.y;
double xDelta = _delta.x;
double yDelta = _delta.y;
newVal = new Point(xStart + xDelta * t, yStart + yDelta * t);
} else if (startVal is Size) {
// Size
double wStart = startVal.width;
double hStart = startVal.height;
double wDelta = _delta.width;
double hDelta = _delta.height;
newVal = new Size(wStart + wDelta * t, hStart + hDelta * t);
} else if (startVal is Rect) {
// Rect
double lStart = startVal.left;
double tStart = startVal.top;
double rStart = startVal.right;
double bStart = startVal.bottom;
double lDelta = _delta.left;
double tDelta = _delta.top;
double rDelta = _delta.right;
double bDelta = _delta.bottom;
newVal = new Rect.fromLTRB(lStart + lDelta * t, tStart + tDelta * t, rStart + rDelta * t, bStart + bDelta * t);
} else if (startVal is double) {
// Doubles
newVal = startVal + _delta * t;
} else if (startVal is Color) {
// Colors
int aNew = (startVal.alpha + (_delta.alpha * t).toInt()).clamp(0, 255);
int rNew = (startVal.red + (_delta.red * t).toInt()).clamp(0, 255);
int gNew = (startVal.green + (_delta.green * t).toInt()).clamp(0, 255);
int bNew = (startVal.blue + (_delta.blue * t).toInt()).clamp(0, 255);
newVal = new Color.fromARGB(aNew, rNew, gNew, bNew);
} else {
// Oopses
assert(false);
}
setter(newVal);
}
}
/// A class the controls the playback of actions. To play back an action it is
/// passed to the [ActionController]'s [run] method. The [ActionController]
/// itself is typically a property of a [Node] and powered by the [SpriteBox].
class ActionController {
List<Action> _actions = <Action>[];
/// Creates a new [ActionController]. However, for most uses a reference to
/// an [ActionController] is acquired through the [Node.actions] property.
ActionController();
/// Runs an [action], can optionally be passed a [tag]. The [tag] can be used
/// to reference the action or a set of actions with the same tag.
///
/// myNode.actions.run(myAction, "myActionGroup");
void run(Action action, [Object tag]) {
assert(!action._added);
action._tag = tag;
action._added = true;
action.update(0.0);
_actions.add(action);
}
/// Stops an [action] and removes it from the controller.
///
/// myNode.actions.stop(myAction);
void stop(Action action) {
if (_actions.remove(action)) {
action._added = false;
action._reset();
}
}
void _stopAtIndex(int i) {
Action action = _actions[i];
action._added = false;
action._reset();
_actions.removeAt(i);
}
/// Stops all actions with the specified tag and removes them from the
/// controller.
///
/// myNode.actions.stopWithTag("myActionGroup");
void stopWithTag(Object tag) {
for (int i = _actions.length - 1; i >= 0; i--) {
Action action = _actions[i];
if (action._tag == tag) {
_stopAtIndex(i);
}
}
}
/// Stops all actions currently being run by the controller and removes them.
///
/// myNode.actions.stopAll();
void stopAll() {
for (int i = _actions.length - 1; i >= 0; i--) {
_stopAtIndex(i);
}
}
/// Steps the action forward by the specified time, typically there is no need
/// to directly call this method.
void step(double dt) {
for (int i = _actions.length - 1; i >= 0; i--) {
Action action = _actions[i];
action.step(dt);
if (action._finished) {
action._added = false;
_actions.removeAt(i);
}
}
}
}
class _ColorDiff {
final int alpha;
final int red;
final int green;
final int blue;
_ColorDiff(this.alpha, this.red, this.green, this.blue);
}
packages/flutter_sprites/lib/src/action_spline.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
part of flutter_sprites;
Point _cardinalSplineAt(Point p0, Point p1, Point p2, Point p3, double tension, double t) {
double t2 = t * t;
double t3 = t2 * t;
double s = (1.0 - tension) / 2.0;
double b1 = s * ((-t3 + (2.0 * t2)) - t);
double b2 = s * (-t3 + t2) + (2.0 * t3 - 3.0 * t2 + 1.0);
double b3 = s * (t3 - 2.0 * t2 + t) + (-2.0 * t3 + 3.0 * t2);
double b4 = s * (t3 - t2);
double x = p0.x * b1 + p1.x * b2 + p2.x * b3 + p3.x * b4;
double y = p0.y * b1 + p1.y * b2 + p2.y * b3 + p3.y * b4;
return new Point(x, y);
}
/// Signature for callbacks used by the [ActionSpline] to set a [Point] value.
typedef void PointSetterCallback(Point value);
/// The spline action is used to animate a point along a spline definied by
/// a set of points.
class ActionSpline extends ActionInterval {
/// Creates a new spline action with a set of points. The [setter] is a
/// callback for setting the positions, [points] define the spline, and
/// [duration] is the time for the action to complete. Optionally a [curve]
/// can be used for easing.
ActionSpline(this.setter, this.points, double duration, [Curve curve]) : super(duration, curve) {
_dt = 1.0 / (points.length - 1.0);
}
/// The callback used to update a point when the action is run.
final PointSetterCallback setter;
/// A list of points that define the spline.
final List<Point> points;
/// The tension of the spline, defines the roundness of the curve.
double tension = 0.5;
double _dt;
@override
void update(double t) {
int p;
double lt;
if (t < 0.0) t = 0.0;
if (t >= 1.0) {
p = points.length - 1;
lt = 1.0;
} else {
p = (t / _dt).floor();
lt = (t - _dt * p) / _dt;
}
Point p0 = points[(p - 1).clamp(0, points.length - 1)];
Point p1 = points[(p + 0).clamp(0, points.length - 1)];
Point p2 = points[(p + 1).clamp(0, points.length - 1)];
Point p3 = points[(p + 2).clamp(0, points.length - 1)];
Point newPos = _cardinalSplineAt(p0, p1, p2, p3, tension, lt);
setter(newPos);
}
}
packages/flutter_sprites/lib/src/color_sequence.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
part of flutter_sprites;
/// A sequence of colors representing a gradient or a color transition over
/// time. The sequence is represented by a list of [colors] and a list of
/// [colorStops], the stops are normalized values (0.0 to 1.0) and ordered in
/// the list. Both lists have the same number of elements.
class ColorSequence {
/// List of colors.
List<Color> colors;
/// List of color stops, normalized values (0.0 to 1.0) and ordered.
List<double> colorStops;
/// Creates a new color sequence from a list of [colors] and a list of
/// [colorStops].
ColorSequence(this.colors, this.colorStops) {
assert(colors != null);
assert(colorStops != null);
assert(colors.length == colorStops.length);
}
/// Creates a new color sequence from a start and an end color.
ColorSequence.fromStartAndEndColor(Color start, Color end) {
colors = <Color>[start, end];
colorStops = <double>[0.0, 1.0];
}
/// Creates a new color sequence by copying an existing sequence.
ColorSequence.copy(ColorSequence sequence) {
colors = new List<Color>.from(sequence.colors);
colorStops = new List<double>.from(sequence.colorStops);
}
/// Returns the color at a normalized (0.0 to 1.0) position in the color
/// sequence. If a color stop isn't hit, the returned color will be an
/// interpolation of a color between two color stops.
Color colorAtPosition(double pos) {
assert(pos >= 0.0 && pos <= 1.0);
if (pos == 0.0) return colors[0];
double lastStop = colorStops[0];
Color lastColor = colors[0];
for (int i = 0; i < colors.length; i++) {
double currentStop = colorStops[i];
Color currentColor = colors[i];
if (pos <= currentStop) {
double blend = (pos - lastStop) / (currentStop - lastStop);
return _interpolateColor(lastColor, currentColor, blend);
}
lastStop = currentStop;
lastColor = currentColor;
}
return colors[colors.length-1];
}
}
Color _interpolateColor(Color a, Color b, double blend) {
double aa = a.alpha.toDouble();
double ar = a.red.toDouble();
double ag = a.green.toDouble();
double ab = a.blue.toDouble();
double ba = b.alpha.toDouble();
double br = b.red.toDouble();
double bg = b.green.toDouble();
double bb = b.blue.toDouble();
int na = (aa * (1.0 - blend) + ba * blend).toInt();
int nr = (ar * (1.0 - blend) + br * blend).toInt();
int ng = (ag * (1.0 - blend) + bg * blend).toInt();
int nb = (ab * (1.0 - blend) + bb * blend).toInt();
return new Color.fromARGB(na, nr, ng, nb);
}
packages/flutter_sprites/lib/src/constraint.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
part of flutter_sprites;
/// A constraint limits or otherwise controls a [Node]'s properties, such as
/// position or rotation. Add a list of constraints by setting the [Node]'s
/// constraints property.
///
/// Constrains are applied after the update calls are
/// completed. They can also be applied at any time by calling
/// [Node.applyConstraints]. It's possible to create custom constraints by
/// overriding this class and implementing the [constrain] method.
abstract class Constraint {
/// Called before the node's update method is called. This method can be
/// overridden to create setup work that needs to happen before the the
/// node is updated, e.g. to calculate the node's speed.
void preUpdate(Node node, double dt) {
}
/// Called after update is complete, if the constraint has been added to a
/// [Node]. Override this method to modify the node's property according to
/// the constraint.
void constrain(Node node, double dt);
}
double _dampenRotation(double src, double dst, double dampening) {
if (dampening == null)
return dst;
double delta = dst - src;
while (delta > 180.0) delta -= 360;
while (delta < -180) delta += 360;
delta *= dampening;
return src + delta;
}
/// A [Constraint] that aligns a nodes rotation to its movement.
class ConstraintRotationToMovement extends Constraint {
/// Creates a new constraint the aligns a nodes rotation to its movement
/// vector. A [baseRotation] and [dampening] can optionally be set.
ConstraintRotationToMovement({this.baseRotation: 0.0, this.dampening});
/// The filter factor used when constraining the rotation of the node. Valid
/// values are in the range 0.0 to 1.0
final double dampening;
/// The base rotation will be added to a the movement vectors rotation.
final double baseRotation;
Point _lastPosition;
@override
void preUpdate(Node node, double dt) {
_lastPosition = node.position;
}
@override
void constrain(Node node, double dt) {
if (_lastPosition == null) return;
if (_lastPosition == node.position) return;
// Get the target angle
Offset offset = node.position - _lastPosition;
double target = degrees(GameMath.atan2(offset.dy, offset.dx)) + baseRotation;
node.rotation = _dampenRotation(node.rotation, target, dampening);
}
}
/// A [Constraint] that copies a node's rotation, optionally with [dampening].
class ConstraintRotationToNodeRotation extends Constraint {
/// Creates a new constraint that copies a node's rotation, optionally
/// with a [baseRotation] added and using [dampening].
ConstraintRotationToNodeRotation(this.targetNode, { this.baseRotation: 0.0, this.dampening });
/// The node to copy the rotation from
final Node targetNode;
/// The base rotation will be added to the rotation that copied from the targetNode
final double baseRotation;
/// The filter factor used when constraining the rotation of the node. Valid
/// values are in the range 0.0 to 1.0
final double dampening;
@override
void constrain(Node node, double dt) {
double target = targetNode.rotation + baseRotation;
node.rotation = _dampenRotation(node.rotation, target, dampening);
}
}
/// A [Constraint] that rotates a node to point towards another node. The target
/// node is allowed to have a different parent, but they must be in the same
/// [SpriteBox].
class ConstraintRotationToNode extends Constraint {
/// Creates a new [Constraint] that rotates the node towards the [targetNode].
/// The [baseRotation] will be added to the nodes rotation, and [dampening]
/// can be used to ease the rotation.
ConstraintRotationToNode(this.targetNode, {this.baseRotation: 0.0, this.dampening});
/// The node to rotate towards.
final Node targetNode;
/// The base rotation will be added after the target rotation is calculated.
final double baseRotation;
/// The filter factor used when constraining the rotation of the node. Valid
/// values are in the range 0.0 to 1.0
final double dampening;
@override
void constrain(Node node, double dt) {
Offset offset;
if (targetNode.spriteBox != node.spriteBox) {
// The target node is in another sprite box or has been removed
return;
}
if (targetNode.parent == node.parent) {
offset = targetNode.position - node.position;
} else {
offset = node.convertPointToBoxSpace(Point.origin)
- targetNode.convertPointToBoxSpace(Point.origin);
}
double target = degrees(GameMath.atan2(offset.dy, offset.dx)) + baseRotation;
node.rotation = _dampenRotation(node.rotation, target, dampening);
}
}
/// A [Constraint] that constrains the position of a node to equal the position
/// of another node, optionally with dampening.
class ConstraintPositionToNode extends Constraint {
/// Creates a new [Constraint] that constrains the poistion of a node to be
/// equal to the position of the [targetNode]. Optionally an [offset] can
/// be used and also [dampening]. The targetNode doesn't need to have the
/// same parent, but they need to be added to the same [SpriteBox].
ConstraintPositionToNode(this.targetNode, {this.dampening, this.offset: Offset.zero});
/// Target node to follow.
final Node targetNode;
/// Offset to the target node.
final Offset offset;
/// Dampening used when following the [targetNode], value between 0.0 and 1.0.
final double dampening;
@override
void constrain(Node node, double dt) {
Point targetPosition;
if (targetNode.spriteBox != node.spriteBox || node.parent == null) {
// The target node is in another sprite box or has been removed
return;
}
if (targetNode.parent == node.parent) {
targetPosition = targetNode.position;
} else {
targetPosition = node.parent.convertPointFromNode(Point.origin, targetNode);
}
if (offset != null)
targetPosition += offset;
if (dampening == null)
node.position = targetPosition;
else
node.position = GameMath.filterPoint(node.position, targetPosition, dampening);
}
}
packages/flutter_sprites/lib/src/effect_line.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
part of flutter_sprites;
/// Used by [EffectLine] to determine how the width of the line is calculated.
enum EffectLineWidthMode {
/// Linear interpolation between minWidth at the start and maxWidth at the
/// end of the line.
linear,
/// Creates a barrel shaped line, with minWidth at the end points of the line
/// and maxWidth at the middle.
barrel,
}
/// Used by [EffectLine] to determine how the texture of the line is animated.
enum EffectLineAnimationMode {
/// The texture of the line isn't animated.
none,
/// The texture of the line is scrolling.
scroll,
/// The texture of the line is set to a random position at every frame. This
/// mode is useful for creating flashing or electricity styled effects.
random,
}
/// The EffectLine class is using the [TexturedLine] class to draw animated
/// lines. These can be used to draw things such as smoke trails, electricity
/// effects, or other animated types of lines.
class EffectLine extends Node {
/// Creates a new EffectLine with the specified parameters. Only the
/// [texture] parameter is required, all other parameters are optional.
EffectLine({
this.texture: null,
this.transferMode: TransferMode.dstOver,
List<Point> points,
this.widthMode : EffectLineWidthMode.linear,
this.minWidth: 10.0,
this.maxWidth: 10.0,
this.widthGrowthSpeed: 0.0,
this.animationMode: EffectLineAnimationMode.none,
this.scrollSpeed: 0.1,
double scrollStart: 0.0,
this.fadeDuration: null,
this.fadeAfterDelay: null,
this.textureLoopLength: null,
this.simplify: true,
ColorSequence colorSequence
}) {
if (points == null)
this.points = <Point>[];
else
this.points = points;
_colorSequence = colorSequence;
if (_colorSequence == null) {
_colorSequence = new ColorSequence.fromStartAndEndColor(
const Color(0xffffffff),
const Color(0xffffffff)
);
}
_offset = scrollStart;
_painter = new TexturedLinePainter(points, _colors, _widths, texture);
_painter.textureLoopLength = textureLoopLength;
}
/// The texture used to draw the line.
final Texture texture;
/// The transfer mode used to draw the line, default is
/// [TransferMode.dstOver].
final TransferMode transferMode;
/// Mode used to calculate the width of the line.
final EffectLineWidthMode widthMode;
/// The width of the line at its thinnest point.
final double minWidth;
/// The width of the line at its thickest point.
final double maxWidth;
/// The speed at which the line is growing, defined in points per second.
final double widthGrowthSpeed;
/// The mode used to animate the texture of the line.
final EffectLineAnimationMode animationMode;
/// The speed of which the texture of the line is scrolling. This property
/// is only used if the [animationMode] is set to
/// [EffectLineAnimationMode.scroll].
final double scrollSpeed;
/// Color gradient used to draw the line, from start to finish.
ColorSequence get colorSequence => _colorSequence;
ColorSequence _colorSequence;
/// List of points that make up the line. Typically, you will only want to
/// set this at the beginning. Then use [addPoint] to add additional points
/// to the line.
List<Point> get points => _points;
set points(List<Point> points) {
_points = points;
_pointAges = <double>[];
for (int i = 0; i < _points.length; i++) {
_pointAges.add(0.0);
}
}
List<Point> _points;
List<double> _pointAges;
List<Color> _colors;
List<double> _widths;
/// The time it takes for an added point to fade out. It's total life time is
/// [fadeDuration] + [fadeAfterDelay].
final double fadeDuration;
/// The time it takes until an added point starts to fade out.
final double fadeAfterDelay;
/// The length, in points, that the texture is stretched to. If the
/// textureLoopLength is shorter than the line, the texture will be looped.
final double textureLoopLength;
/// True if the line should be simplified by removing points that are close
/// to other points. This makes drawing faster, but can result in a slight
/// jittering effect when points are added.
final bool simplify;
TexturedLinePainter _painter;
double _offset = 0.0;
@override
void update(double dt) {
// Update scrolling position
if (animationMode == EffectLineAnimationMode.scroll) {
_offset += dt * scrollSpeed;
_offset %= 1.0;
} else if (animationMode == EffectLineAnimationMode.random) {
_offset = randomDouble();
}
// Update age of line points and remove if neccesasry
if (fadeDuration != null && fadeAfterDelay != null) {
// Increase age of points
for (int i = _points.length - 1; i >= 0; i--) {
_pointAges[i] += dt;
}
// Check if the first/oldest point should be removed
while(_points.length > 0 && _pointAges[0] > (fadeDuration + fadeAfterDelay)) {
// Update scroll if it isn't the last and only point that is about to removed
if (_points.length > 1 && textureLoopLength != null) {
double dist = GameMath.distanceBetweenPoints(_points[0], _points[1]);
_offset = (_offset - (dist / textureLoopLength)) % 1.0;
if (_offset < 0.0) _offset += 1;
}
// Remove the point
_pointAges.removeAt(0);
_points.removeAt(0);
}
}
}
@override
void paint(Canvas canvas) {
if (points.length < 2) return;
_painter.points = points;
// Calculate colors
List<double> stops = _painter.calculatedTextureStops;
List<Color> colors = <Color>[];
for (int i = 0; i < stops.length; i++) {
double stop = stops[i];
Color color = _colorSequence.colorAtPosition(stop);
if (fadeDuration != null && fadeAfterDelay != null) {
double age = _pointAges[i];
if (age > fadeAfterDelay) {
double fade = 1.0 - (age - fadeAfterDelay) / fadeDuration;
int alpha = (color.alpha * fade).toInt().clamp(0, 255);
color = new Color.fromARGB(alpha, color.red, color.green, color.blue);
}
}
colors.add(color);
}
_painter.colors = colors;
// Calculate widths
List<double> widths = <double>[];
for (int i = 0; i < stops.length; i++) {
double stop = stops[i];
double growth = math.max(widthGrowthSpeed * _pointAges[i], 0.0);
if (widthMode == EffectLineWidthMode.linear) {
double width = minWidth + (maxWidth - minWidth) * stop + growth;
widths.add(width);
} else if (widthMode == EffectLineWidthMode.barrel) {
double width = minWidth + math.sin(stop * math.PI) * (maxWidth - minWidth) + growth;
widths.add(width);
}
}
_painter.widths = widths;
_painter.textureStopOffset = _offset;
_painter.paint(canvas);
}
/// Adds a new point to the end of the line.
void addPoint(Point point) {
// Skip duplicate points
if (points.length > 0 && point.x == points[points.length - 1].x && point.y == points[points.length - 1].y)
return;
if (simplify && points.length >= 2 && GameMath.distanceBetweenPoints(point, points[points.length - 2]) < 10.0) {
// Check if we should remove last point before adding the new one
// Calculate the square distance from the middle point to the line of the
// new point and the second to last point
double dist2 = _distToSeqment2(
points[points.length - 1],
point,
points[points.length - 2]
);
// If the point is on the line, remove it
if (dist2 < 1.0) {
_points.removeAt(_points.length - 1);
}
}
// Add point and point's age
_points.add(point);
_pointAges.add(0.0);
}
double _sqr(double x) => x * x;
double _dist2(Point v, Point w) => _sqr(v.x - w.x) + _sqr(v.y - w.y);
double _distToSeqment2(Point p, Point v, Point w) {
double l2 = _dist2(v, w);
if (l2 == 0.0) return _dist2(p, v);
double t = ((p.x - v.x) * (w.x - v.x) + (p.y - v.y) * (w.y - v.y)) / l2;
if (t < 0) return _dist2(p, v);
if (t > 1) return _dist2(p, w);
return _dist2(p, new Point(v.x + t * (w.x - v.x), v.y + t * (w.y - v.y)));
}
}
packages/flutter_sprites/lib/src/image_map.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
part of flutter_sprites;
/// The ImageMap is a helper class for loading and keeping references to
/// multiple images.
class ImageMap {
/// Creates a new ImageMap where images will be loaded from the specified
/// [bundle].
ImageMap(AssetBundle bundle) : _bundle = bundle;
final AssetBundle _bundle;
final Map<String, ui.Image> _images = new Map<String, ui.Image>();
/// Loads a list of images given their urls.
Future<List<ui.Image>> load(List<String> urls) {
return Future.wait(urls.map(_loadImage));
}
Future<ui.Image> _loadImage(String url) async {
ImageStream stream = new AssetImage(url, bundle: _bundle).resolve(ImageConfiguration.empty);
Completer<ui.Image> completer = new Completer<ui.Image>();
void listener(ImageInfo frame, bool synchronousCall) {
final ui.Image image = frame.image;
_images[url] = image;
completer.complete(image);
stream.removeListener(listener);
}
stream.addListener(listener);
return completer.future;
}
/// Returns a preloaded image, given its [url].
ui.Image getImage(String url) => _images[url];
/// Returns a preloaded image, given its [url].
ui.Image operator [](String url) => _images[url];
}
packages/flutter_sprites/lib/src/label.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
part of flutter_sprites;
/// Labels are used to display a string of text in a the node tree. To align
/// the label, the textAlign property of the [TextStyle] can be set.
class Label extends Node {
/// Creates a new Label with the provided [text] and [textStyle].
Label(this._text, {
TextStyle textStyle,
TextAlign textAlign
}) : _textStyle = textStyle ?? const TextStyle(),
textAlign = textAlign ?? TextAlign.left;
/// The text being drawn by the label.
String get text => _text;
String _text;
set text(String text) {
_text = text;
_painter = null;
}
/// The style to draw the text in.
TextStyle get textStyle => _textStyle;
TextStyle _textStyle;
set textStyle(TextStyle textStyle) {
_textStyle = textStyle;
_painter = null;
}
/// How the text should be aligned horizontally.
TextAlign textAlign;
TextPainter _painter;
double _width;
@override
void paint(Canvas canvas) {
if (_painter == null) {
_painter = new TextPainter(text: new TextSpan(style: _textStyle, text: _text))
..layout();
_width = _painter.size.width;
}
Offset offset = Offset.zero;
if (textAlign == TextAlign.center) {
offset = new Offset(-_width / 2.0, 0.0);
} else if (textAlign == TextAlign.right) {
offset = new Offset(-_width, 0.0);
}
_painter.paint(canvas, offset);
}
}
packages/flutter_sprites/lib/src/layer.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
part of flutter_sprites;
/// A [Node] that provides an intermediate rendering surface in the sprite
/// rendering tree. A [Layer] can be used to change the opacity, color, or to
/// apply an effect to a set of nodes. All nodes that are children to the
/// [Layer] will be rendered into the surface. If the area that is needed for
/// the children to be drawn is know, the [layerRect] property should be set as
/// this can enhance performance.
class Layer extends Node with SpritePaint {
/// The area that the children of the [Layer] will occupy. This value is
/// treated as a hint to the rendering system and may in some cases be
/// ignored. If the area isn't known, the layerRect can be set to [null].
///
/// myLayer.layerRect = new Rect.fromLTRB(0.0, 0.0, 200.0, 100.0);
Rect layerRect;
/// Creates a new layer. The layerRect can optionally be passed as an argument
/// if it is known.
///
/// var myLayer = new Layer();
Layer([this.layerRect = null]);
Paint _cachedPaint = new Paint()
..filterQuality = FilterQuality.low
..isAntiAlias = false;
@override
void _prePaint(Canvas canvas) {
super._prePaint(canvas);
_updatePaint(_cachedPaint);
canvas.saveLayer(layerRect, _cachedPaint);
}
@override
void _postPaint(Canvas canvas) {
canvas.restore();
super._postPaint(canvas);
}
}
packages/flutter_sprites/lib/src/nine_slice_sprite.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
part of flutter_sprites;
/// A NineSliceSprite is similar to a [Sprite], but it it can strech its
/// inner area to fit the size of the [Node]. This is ideal for fast drawing
/// of things like buttons.
class NineSliceSprite extends NodeWithSize with SpritePaint {
/// Creates a new NineSliceSprite from the privided [texture], [size], and
/// texture [insets].
NineSliceSprite(Texture texture, Size size, EdgeInsets insets) : super(size) {
assert(texture != null && !texture.rotated);
assert(size != null);
assert(insets != null);
pivot = const Point(0.5, 0.5);
this.texture = texture;
this.insets = insets;
}
/// Creates a new NineSliceSprite from the provided [image], [size], and
/// texture [insets].
NineSliceSprite.fromImage(ui.Image image, Size size, EdgeInsets insets)
: this(new Texture(image), size, insets);
/// The texture that the sprite will render to screen. Cannot be null.
///
/// my9Sprite.texture = myTexture;
Texture get texture => _texture;
Texture _texture;
set texture(Texture texture) {
_texture = texture;
_isDirty = true;
if (texture == null) {
_cachedPaint = new Paint();
} else {
Matrix4 matrix = new Matrix4.identity();
ImageShader shader = new ImageShader(texture.image,
TileMode.repeated, TileMode.repeated, matrix.storage);
_cachedPaint = new Paint()
..shader = shader;
}
}
/// The insets of the texture as normalized values. The insets define the
/// areas of the texture that will not be deformed as the sprite stretches.
EdgeInsets get insets => _insets;
EdgeInsets _insets;
set insets(EdgeInsets insets) {
assert(insets != null);
_insets = insets;
_isDirty = true;
}
/// If true, the center part of the sprite will be drawn, this is the default
/// behavior.
bool get drawCenterPart => _drawCenterPart;
bool _drawCenterPart = true;
set drawCenterPart(bool drawCenterPart) {
_drawCenterPart = drawCenterPart;
_isDirty = true;
}
@override
set size(Size size) {
super.size = size;
_isDirty = true;
}
Paint _cachedPaint = new Paint()
..filterQuality = FilterQuality.low
..isAntiAlias = false;
// Cached values.
bool _isDirty = true;
List<Point> _vertices;
List<Point> _textureCoordinates;
List<Color> _colors;
List<int> _indices;
@override
void paint(Canvas canvas) {
applyTransformForPivot(canvas);
// Setup paint object for opacity and transfer mode.
_updatePaint(_cachedPaint);
if (_isDirty) {
// Calcuate vertices and indices.
_vertices = <Point>[
Point.origin,
];
// Texture width and height.
double tw = texture.frame.width;
double th = texture.frame.height;
_textureCoordinates = <Point>[];
_vertices = <Point>[];
_colors = <Color>[];
for (int y = 0; y < 4; y += 1) {
double vy;
double ty;
switch(y) {
case 0:
vy = 0.0;
ty = texture.frame.top;
break;
case 1:
vy = insets.top * th;
ty = texture.frame.top + insets.top * th;
break;
case 2:
vy = size.height - insets.bottom * th;
ty = texture.frame.bottom - insets.bottom * th;
break;
case 3:
vy = size.height;
ty = texture.frame.bottom;
break;
}
for (int x = 0; x < 4; x += 1) {
double vx;
double tx;
switch(x) {
case 0:
vx = 0.0;
tx = texture.frame.left;
break;
case 1:
vx = insets.left * tw;
tx = texture.frame.left + insets.left * tw;
break;
case 2:
vx = size.width - insets.right * tw;
tx = texture.frame.right - insets.right * tw;
break;
case 3:
vx = size.width;
tx = texture.frame.right;
break;
}
_vertices.add(new Point(vx, vy));
_textureCoordinates.add(new Point(tx, ty));
_colors.add(const Color(0xffffffff));
}
}
// Build indices.
_indices = <int>[];
for (int y = 0; y < 3; y += 1) {
for (int x = 0; x < 3; x += 1) {
// Check if we should skip the middle rectangle.
if (!drawCenterPart && x == 1 && y == 1)
continue;
// Add a rectangle (two triangles).
int index = y * 4 + x;
_indices.add(index);
_indices.add(index + 1);
_indices.add(index + 4);
_indices.add(index + 1);
_indices.add(index + 5);
_indices.add(index + 4);
}
}
}
canvas.drawVertices(
VertexMode.triangles,
_vertices,
_textureCoordinates,
_colors,
TransferMode.modulate,
_indices,
_cachedPaint
);
}
}
packages/flutter_sprites/lib/src/node.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
part of flutter_sprites;
/// Converts degrees to radians.
double convertDegrees2Radians(double degrees) => degrees * math.PI/180.8;
/// Converts radians to degrees.
double convertRadians2Degrees(double radians) => radians * 180.0/math.PI;
/// A base class for all objects that can be added to the sprite node tree and rendered to screen using [SpriteBox] and
/// [SpriteWidget].
///
/// The [Node] class itself doesn't render any content, but provides the basic functions of any type of node, such as
/// handling transformations and user input. To render the node tree, a root node must be added to a [SpriteBox] or a
/// [SpriteWidget]. Commonly used sub-classes of [Node] are [Sprite], [NodeWithSize], and many more upcoming subclasses.
///
/// Nodes form a hierarchical tree. Each node can have a number of children, and the transformation (positioning,
/// rotation, and scaling) of a node also affects its children.
class Node {
// Constructors
/// Creates a new [Node] without any transformation.
///
/// Node myNode = new Node();
Node();
// Member variables
SpriteBox _spriteBox;
Node _parent;
Point _position = Point.origin;
double _rotation = 0.0;
Matrix4 _transformMatrix = new Matrix4.identity();
Matrix4 _transformMatrixInverse;
Matrix4 _transformMatrixNodeToBox;
Matrix4 _transformMatrixBoxToNode;
double _scaleX = 1.0;
double _scaleY = 1.0;
double _skewX = 0.0;
double _skewY = 0.0;
/// The visibility of this node and its children.
bool visible = true;
double _zPosition = 0.0;
int _addedOrder;
int _childrenLastAddedOrder = 0;
bool _childrenNeedSorting = false;
/// Decides if the node and its children is currently paused.
///
/// A paused node will not receive any input events, update calls, or run any animations.
///
/// myNodeTree.paused = true;
bool paused = false;
bool _userInteractionEnabled = false;
/// If set to true the node will receive multiple pointers, otherwise it will only receive events the first pointer.
///
/// This property is only meaningful if [userInteractionEnabled] is set to true. Default value is false.
///
/// class MyCustomNode extends Node {
/// handleMultiplePointers = true;
/// }
bool handleMultiplePointers = false;
int _handlingPointer;
List<Node> _children = <Node>[];
ActionController _actions;
/// The [ActionController] associated with this node.
///
/// myNode.actions.run(myAction);
ActionController get actions {
if (_actions == null) {
_actions = new ActionController();
if (_spriteBox != null) _spriteBox._actionControllers = null;
}
return _actions;
}
List<Constraint> _constraints;
/// A [List] of [Constraint]s that will be applied to the node.
/// The constraints are applied after the [update] method has been called.
List<Constraint> get constraints {
return _constraints;
}
set constraints(List<Constraint> constraints) {
_constraints = constraints;
if (_spriteBox != null) _spriteBox._constrainedNodes = null;
}
/// Called to apply the [constraints] to the node. Normally, this method is
/// called automatically by the [SpriteBox], but it can be called manually
/// if the constraints need to be applied immediately.
void applyConstraints(double dt) {
if (_constraints == null) return;
for (Constraint constraint in _constraints) {
constraint.constrain(this, dt);
}
}
// Property setters and getters
/// The [SpriteBox] this node is added to, or null if it's not currently added to a [SpriteBox].
///
/// For most applications it's not necessary to access the [SpriteBox] directly.
///
/// // Get the transformMode of the sprite box
/// SpriteBoxTransformMode transformMode = myNode.spriteBox.transformMode;
SpriteBox get spriteBox => _spriteBox;
/// The parent of this node, or null if it doesn't have a parent.
///
/// // Hide the parent
/// myNode.parent.visible = false;
Node get parent => _parent;
/// The rotation of this node in degrees.
///
/// myNode.rotation = 45.0;
double get rotation => _rotation;
set rotation(double rotation) {
assert(rotation != null);
_rotation = rotation;
invalidateTransformMatrix();
}
/// The position of this node relative to its parent.
///
/// myNode.position = new Point(42.0, 42.0);
Point get position => _position;
set position(Point position) {
assert(position != null);
_position = position;
invalidateTransformMatrix();
}
/// The skew along the x-axis of this node in degrees.
///
/// myNode.skewX = 45.0;
double get skewX => _skewX;
set skewX (double skewX) {
assert(skewX != null);
_skewX = skewX;
invalidateTransformMatrix();
}
/// The skew along the y-axis of this node in degrees.
///
/// myNode.skewY = 45.0;
double get skewY => _skewY;
set skewY (double skewY) {
assert(skewY != null);
_skewY = skewY;
invalidateTransformMatrix();
}
/// The draw order of this node compared to its parent and its siblings.
///
/// By default nodes are drawn in the order that they have been added to a parent. To override this behavior the
/// [zPosition] property can be used. A higher value of this property will force the node to be drawn in front of
/// siblings that have a lower value. If a negative value is used the node will be drawn behind its parent.
///
/// nodeInFront.zPosition = 1.0;
/// nodeBehind.zPosition = -1.0;
double get zPosition => _zPosition;
set zPosition(double zPosition) {
assert(zPosition != null);
_zPosition = zPosition;
if (_parent != null) {
_parent._childrenNeedSorting = true;
}
}
/// The scale of this node relative its parent.
///
/// The [scale] property is only valid if [scaleX] and [scaleY] are equal values.
///
/// myNode.scale = 5.0;
double get scale {
assert(_scaleX == _scaleY);
return _scaleX;
}
set scale(double scale) {
assert(scale != null);
_scaleX = _scaleY = scale;
invalidateTransformMatrix();
}
/// The horizontal scale of this node relative its parent.
///
/// myNode.scaleX = 5.0;
double get scaleX => _scaleX;
set scaleX(double scaleX) {
assert(scaleX != null);
_scaleX = scaleX;
invalidateTransformMatrix();
}
/// The vertical scale of this node relative its parent.
///
/// myNode.scaleY = 5.0;
double get scaleY => _scaleY;
set scaleY(double scaleY) {
assert(scaleY != null);
_scaleY = scaleY;
invalidateTransformMatrix();
}
/// A list of the children of this node.
///
/// This list should only be modified by using the [addChild] and [removeChild] methods.
///
/// // Iterate over a nodes children
/// for (Node child in myNode.children) {
/// // Do something with the child
/// }
List<Node> get children {
_sortChildren();
return _children;
}
// Adding and removing children
/// Adds a child to this node.
///
/// The same node cannot be added to multiple nodes.
///
/// addChild(new Sprite(myImage));
void addChild(Node child) {
assert(child != null);
assert(child._parent == null);
assert(() {
Node node = this;
while (node.parent != null)
node = node.parent;
assert(node != child); // indicates we are about to create a cycle
return true;
});
_childrenNeedSorting = true;
_children.add(child);
child._parent = this;
child._spriteBox = this._spriteBox;
_childrenLastAddedOrder += 1;
child._addedOrder = _childrenLastAddedOrder;
if (_spriteBox != null) _spriteBox._registerNode(child);
}
/// Removes a child from this node.
///
/// removeChild(myChildNode);
void removeChild(Node child) {
assert(child != null);
if (_children.remove(child)) {
child._parent = null;
child._spriteBox = null;
if (_spriteBox != null) _spriteBox._deregisterNode(child);
}
}
/// Removes this node from its parent node.
///
/// removeFromParent();
void removeFromParent() {
assert(_parent != null);
_parent.removeChild(this);
}
/// Removes all children of this node.
///
/// removeAllChildren();
void removeAllChildren() {
for (Node child in _children) {
child._parent = null;
child._spriteBox = null;
}
_children = <Node>[];
_childrenNeedSorting = false;
if (_spriteBox != null) _spriteBox._deregisterNode(null);
}
void _sortChildren() {
// Sort children primarily by zPosition, secondarily by added order
if (_childrenNeedSorting) {
_children.sort((Node a, Node b) {
if (a._zPosition == b._zPosition) {
return a._addedOrder - b._addedOrder;
}
else if (a._zPosition > b._zPosition) {
return 1;
}
else {
return -1;
}
});
_childrenNeedSorting = false;
}
}
// Calculating the transformation matrix
/// The transformMatrix describes the transformation from the node's parent.
///
/// You cannot set the transformMatrix directly, instead use the position, rotation and scale properties.
///
/// Matrix4 matrix = myNode.transformMatrix;
Matrix4 get transformMatrix {
if (_transformMatrix == null) {
_transformMatrix = computeTransformMatrix();
}
return _transformMatrix;
}
/// Computes the transformation matrix of this node. This method can be
/// overriden if a custom matrix is required. There is usually no reason to
/// call this method directly.
Matrix4 computeTransformMatrix() {
double cx, sx, cy, sy;
if (_rotation == 0.0) {
cx = 1.0;
sx = 0.0;
cy = 1.0;
sy = 0.0;
}
else {
double radiansX = convertDegrees2Radians(_rotation);
double radiansY = convertDegrees2Radians(_rotation);
cx = math.cos(radiansX);
sx = math.sin(radiansX);
cy = math.cos(radiansY);
sy = math.sin(radiansY);
}
// Create transformation matrix for scale, position and rotation
Matrix4 matrix = new Matrix4(cy * _scaleX, sy * _scaleX, 0.0, 0.0,
-sx * _scaleY, cx * _scaleY, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
_position.x, _position.y, 0.0, 1.0);
if (_skewX != 0.0 || _skewY != 0.0) {
// Needs skew transform
Matrix4 skew = new Matrix4(1.0, math.tan(radians(_skewX)), 0.0, 0.0,
math.tan(radians(_skewY)), 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0);
matrix.multiply(skew);
}
return matrix;
}
/// Invalidates the current transform matrix. If the [computeTransformMatrix]
/// method is overidden, this method should be called whenever a property
/// changes that affects the matrix.
void invalidateTransformMatrix() {
_transformMatrix = null;
_transformMatrixInverse = null;
_invalidateToBoxTransformMatrix();
}
void _invalidateToBoxTransformMatrix () {
_transformMatrixNodeToBox = null;
_transformMatrixBoxToNode = null;
for (Node child in children) {
child._invalidateToBoxTransformMatrix();
}
}
// Transforms to other nodes
Matrix4 _nodeToBoxMatrix() {
assert(_spriteBox != null);
if (_transformMatrixNodeToBox != null) {
return _transformMatrixNodeToBox;
}
if (_parent == null) {
// Base case, we are at the top
assert(this == _spriteBox.rootNode);
_transformMatrixNodeToBox = _spriteBox.transformMatrix.clone()..multiply(transformMatrix);
}
else {
_transformMatrixNodeToBox = _parent._nodeToBoxMatrix().clone()..multiply(transformMatrix);
}
return _transformMatrixNodeToBox;
}
Matrix4 _boxToNodeMatrix() {
assert(_spriteBox != null);
if (_transformMatrixBoxToNode != null) {
return _transformMatrixBoxToNode;
}
_transformMatrixBoxToNode = new Matrix4.copy(_nodeToBoxMatrix());
_transformMatrixBoxToNode.invert();
return _transformMatrixBoxToNode;
}
/// The inverse transform matrix used by this node.
Matrix4 get inverseTransformMatrix {
if (_transformMatrixInverse == null) {
_transformMatrixInverse = new Matrix4.copy(transformMatrix);
_transformMatrixInverse.invert();
}
return _transformMatrixInverse;
}
/// Converts a point from the coordinate system of the [SpriteBox] to the local coordinate system of the node.
///
/// This method is particularly useful when handling pointer events and need the pointers position in a local
/// coordinate space.
///
/// Point localPoint = myNode.convertPointToNodeSpace(pointInBoxCoordinates);
Point convertPointToNodeSpace(Point boxPoint) {
assert(boxPoint != null);
assert(_spriteBox != null);
Vector4 v =_boxToNodeMatrix().transform(new Vector4(boxPoint.x, boxPoint.y, 0.0, 1.0));
return new Point(v[0], v[1]);
}
/// Converts a point from the local coordinate system of the node to the coordinate system of the [SpriteBox].
///
/// Point pointInBoxCoordinates = myNode.convertPointToBoxSpace(localPoint);
Point convertPointToBoxSpace(Point nodePoint) {
assert(nodePoint != null);
assert(_spriteBox != null);
Vector4 v =_nodeToBoxMatrix().transform(new Vector4(nodePoint.x, nodePoint.y, 0.0, 1.0));
return new Point(v[0], v[1]);
}
/// Converts a [point] from another [node]s coordinate system into the local coordinate system of this node.
///
/// Point pointInNodeASpace = nodeA.convertPointFromNode(pointInNodeBSpace, nodeB);
Point convertPointFromNode(Point point, Node node) {
assert(node != null);
assert(point != null);
assert(_spriteBox != null);
assert(_spriteBox == node._spriteBox);
Point boxPoint = node.convertPointToBoxSpace(point);
Point localPoint = convertPointToNodeSpace(boxPoint);
return localPoint;
}
// Hit test
/// Returns true if the [point] is inside the node, the [point] is in the local coordinate system of the node.
///
/// myNode.isPointInside(localPoint);
///
/// [NodeWithSize] provides a basic bounding box check for this method, if you require a more detailed check this
/// method can be overridden.
///
/// bool isPointInside (Point nodePoint) {
/// double minX = -size.width * pivot.x;
/// double minY = -size.height * pivot.y;
/// double maxX = minX + size.width;
/// double maxY = minY + size.height;
/// return (nodePoint.x >= minX && nodePoint.x < maxX &&
/// nodePoint.y >= minY && nodePoint.y < maxY);
/// }
bool isPointInside(Point point) {
assert(point != null);
return false;
}
// Rendering
void _visit(Canvas canvas) {
assert(canvas != null);
if (!visible) return;
_prePaint(canvas);
_visitChildren(canvas);
_postPaint(canvas);
}
@mustCallSuper
void _prePaint(Canvas canvas) {
canvas
..save()
..transform(transformMatrix.storage);
}
/// Paints this node to the canvas.
///
/// Subclasses, such as [Sprite], override this method to do the actual painting of the node. To do custom
/// drawing override this method and make calls to the [canvas] object. All drawing is done in the node's local
/// coordinate system, relative to the node's position. If you want to make the drawing relative to the node's
/// bounding box's origin, override [NodeWithSize] and call the applyTransformForPivot method before making calls for
/// drawing.
///
/// void paint(Canvas canvas) {
/// canvas.save();
/// applyTransformForPivot(canvas);
///
/// // Do painting here
///
/// canvas.restore();
/// }
void paint(Canvas canvas) {
}
void _visitChildren(Canvas canvas) {
// Sort children if needed
_sortChildren();
int i = 0;
// Visit children behind this node
while (i < _children.length) {
Node child = _children[i];
if (child.zPosition >= 0.0) break;
child._visit(canvas);
i++;
}
// Paint this node
paint(canvas);
// Visit children in front of this node
while (i < _children.length) {
Node child = _children[i];
child._visit(canvas);
i++;
}
}
@mustCallSuper
void _postPaint(Canvas canvas) {
canvas.restore();
}
// Receiving update calls
/// Called before a frame is drawn.
///
/// Override this method to do any updates to the node or node tree before it's drawn to screen.
///
/// // Make the node rotate at a fixed speed
/// void update(double dt) {
/// rotation = rotation * 10.0 * dt;
/// }
void update(double dt) {
}
/// Called whenever the [SpriteBox] is modified or resized, or if the device is rotated.
///
/// Override this method to do any updates that may be necessary to correctly display the node or node tree with the
/// new layout of the [SpriteBox].
///
/// void spriteBoxPerformedLayout() {
/// // Move some stuff around here
/// }
void spriteBoxPerformedLayout() {
}
// Handling user interaction
/// The node will receive user interactions, such as pointer (touch or mouse) events.
///
/// class MyCustomNode extends NodeWithSize {
/// userInteractionEnabled = true;
/// }
bool get userInteractionEnabled => _userInteractionEnabled;
set userInteractionEnabled(bool userInteractionEnabled) {
_userInteractionEnabled = userInteractionEnabled;
if (_spriteBox != null) _spriteBox._eventTargets = null;
}
/// Handles an event, such as a pointer (touch or mouse) event.
///
/// Override this method to handle events. The node will only receive events if the [userInteractionEnabled] property
/// is set to true and the [isPointInside] method returns true for the position of the pointer down event (default
/// behavior provided by [NodeWithSize]). Unless [handleMultiplePointers] is set to true, the node will only receive
/// events for the first pointer that is down.
///
/// Return true if the node has consumed the event, if an event is consumed it will not be passed on to nodes behind
/// the current node.
///
/// // MyTouchySprite gets transparent when we touch it
/// class MyTouchySprite extends Sprite {
///
/// MyTouchySprite(Image img) : super (img) {
/// userInteractionEnabled = true;
/// }
///
/// bool handleEvent(SpriteBoxEvent event) {
/// if (event.type == PointerDownEvent) {
/// opacity = 0.5;
/// }
/// else if (event.type == PointerUpEvent) {
/// opacity = 1.0;
/// }
/// return true;
/// }
/// }
bool handleEvent(SpriteBoxEvent event) {
return false;
}
}
packages/flutter_sprites/lib/src/node3d.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
part of flutter_sprites;
/// An node that transforms its children using a 3D perspective projection. This
/// node type can be used to create 3D flips and other similar effects.
///
/// var myNode3D = new Node3D();
/// myNode3D.rotationY = 45.0;
/// myNode3D.addChild(new Sprite(myTexture));
class Node3D extends Node {
double _rotationX = 0.0;
/// The node's rotation around the x axis in degrees.
double get rotationX => _rotationX;
set rotationX(double rotationX) {
_rotationX = rotationX;
invalidateTransformMatrix();
}
double _rotationY = 0.0;
/// The node's rotation around the y axis in degrees.
double get rotationY => _rotationY;
set rotationY(double rotationY) {
_rotationY = rotationY;
invalidateTransformMatrix();
}
double _projectionDepth = 500.0;
/// The projection depth. Default value is 500.0.
double get projectionDepth => _projectionDepth;
set projectionDepth(double projectionDepth) {
_projectionDepth = projectionDepth;
invalidateTransformMatrix();
}
@override
Matrix4 computeTransformMatrix() {
// Apply normal 2d transforms
Matrix4 matrix = super.computeTransformMatrix();
// Apply perspective projection
Matrix4 projection = new Matrix4(1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, -1.0/_projectionDepth,
0.0, 0.0, 0.0, 1.0);
matrix.multiply(projection);
// Rotate around x and y axis
matrix.rotateY(radians(_rotationY));
matrix.rotateX(radians(_rotationX));
return matrix;
}
}
packages/flutter_sprites/lib/src/node_with_size.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
part of flutter_sprites;
/// The super class of any [Node] that has a size.
///
/// NodeWithSize adds the ability for a node to have a size and a pivot point.
class NodeWithSize extends Node {
/// Changing the size will affect the size of the rendering of the node.
///
/// myNode.size = new Size(1024.0, 1024.0);
Size size;
/// The normalized point which the node is transformed around.
///
/// // Position myNode from is middle top
/// myNode.pivot = new Point(0.5, 0.0);
Point pivot;
/// Creates a new NodeWithSize.
///
/// The default [size] is zero and the default [pivot] point is the origin. Subclasses may change the default values.
///
/// var myNodeWithSize = new NodeWithSize(new Size(1024.0, 1024.0));
NodeWithSize(this.size) {
if (size == null)
size = Size.zero;
pivot = Point.origin;
}
/// Call this method in your [paint] method if you want the origin of your drawing to be the top left corner of the
/// node's bounding box.
///
/// If you use this method you will need to save and restore your canvas at the beginning and
/// end of your [paint] method.
///
/// void paint(Canvas canvas) {
/// canvas.save();
/// applyTransformForPivot(canvas);
///
/// // Do painting here
///
/// canvas.restore();
/// }
void applyTransformForPivot(Canvas canvas) {
if (pivot.x != 0 || pivot.y != 0) {
double pivotInPointsX = size.width * pivot.x;
double pivotInPointsY = size.height * pivot.y;
canvas.translate(-pivotInPointsX, -pivotInPointsY);
}
}
@override
bool isPointInside (Point nodePoint) {
double minX = -size.width * pivot.x;
double minY = -size.height * pivot.y;
double maxX = minX + size.width;
double maxY = minY + size.height;
return (nodePoint.x >= minX && nodePoint.x < maxX &&
nodePoint.y >= minY && nodePoint.y < maxY);
}
}
packages/flutter_sprites/lib/src/particle_system.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
part of flutter_sprites;
class _Particle {
Vector2 pos;
Vector2 startPos;
double colorPos = 0.0;
double deltaColorPos = 0.0;
double size = 0.0;
double deltaSize = 0.0;
double rotation = 0.0;
double deltaRotation = 0.0;
double timeToLive = 0.0;
Vector2 dir;
_ParticleAccelerations accelerations;
Float64List simpleColorSequence;
ColorSequence colorSequence;
}
class _ParticleAccelerations {
double radialAccel = 0.0;
double tangentialAccel = 0.0;
}
/// A particle system uses a large number of sprites to draw complex effects
/// such as explosions, smoke, rain, or fire. There are a number of properties
/// that can be set to control the look of the particle system. Most of the
/// properties have a base value and a variance, these values are used when
/// creating each individual particle. For instance, by setting the [life] to
/// 1.0 and the [lifeVar] to 0.5, each particle will get a life time in the
/// range of 0.5 to 1.5.
///
/// Particles are created and added to the system at [emissionRate], but the
/// number of particles can never exceed the [maxParticles] limit.
class ParticleSystem extends Node {
/// Creates a new particle system with the given properties. The only
/// required parameter is the texture, all other parameters are optional.
ParticleSystem(this.texture,
{this.life: 1.5,
this.lifeVar: 1.0,
this.posVar: Point.origin,
this.startSize: 2.5,
this.startSizeVar: 0.5,
this.endSize: 0.0,
this.endSizeVar: 0.0,
this.startRotation: 0.0,
this.startRotationVar: 0.0,
this.endRotation: 0.0,
this.endRotationVar: 0.0,
this.rotateToMovement : false,
this.direction: 0.0,
this.directionVar: 360.0,
this.speed: 100.0,
this.speedVar: 50.0,
this.radialAcceleration: 0.0,
this.radialAccelerationVar: 0.0,
this.tangentialAcceleration: 0.0,
this.tangentialAccelerationVar: 0.0,
this.maxParticles: 100,
this.emissionRate: 50.0,
this.colorSequence,
this.alphaVar: 0,
this.redVar: 0,
this.greenVar: 0,
this.blueVar: 0,
this.transferMode: TransferMode.plus,
this.numParticlesToEmit: 0,
this.autoRemoveOnFinish: true,
Offset gravity
}) {
this.gravity = gravity;
_particles = new List<_Particle>();
_emitCounter = 0.0;
// _elapsedTime = 0.0;
if (_gravity == null)
_gravity = new Vector2.zero();
if (colorSequence == null)
colorSequence = new ColorSequence.fromStartAndEndColor(new Color(0xffffffff), new Color(0x00ffffff));
}
/// The texture used to draw each individual sprite.
Texture texture;
/// The time in seconds each particle will be alive.
double life;
/// Variance of the [life] property.
double lifeVar;
/// The variance of a particles initial position.
Point posVar;
/// The start scale of each individual particle.
double startSize;
/// Variance of the [startSize] property.
double startSizeVar;
/// The end scale of each individual particle.
double endSize;
/// Variance of the [endSize] property.
double endSizeVar;
/// The start rotation of each individual particle.
double startRotation;
/// Variance of the [startRotation] property.
double startRotationVar;
/// The end rotation of each individual particle.
double endRotation;
/// Variance of the [endRotation] property.
double endRotationVar;
/// If true, each particle will be rotated to the direction of the movement
/// of the particle. The calculated rotation will be added to the current
/// rotation as calculated by the [startRotation] and [endRotation]
/// properties.
bool rotateToMovement;
/// The direction in which each particle will be emitted in degrees.
double direction;
/// Variance of the [direction] property.
double directionVar;
/// The speed at which each particle will be emitted.
double speed;
/// Variance of the [direction] property.
double speedVar;
/// The radial acceleration of each induvidual particle.
double radialAcceleration;
/// Variance of the [radialAcceleration] property.
double radialAccelerationVar;
/// The tangential acceleration of each individual particle.
double tangentialAcceleration;
/// Variance of the [tangentialAcceleration] property.
double tangentialAccelerationVar;
/// The gravity vector of the particle system.
Offset get gravity {
if (_gravity == null)
return null;
return new Offset(_gravity.x, _gravity.y);
}
Vector2 _gravity;
set gravity(Offset gravity) {
if (gravity == null)
_gravity = null;
else
_gravity = new Vector2(gravity.dx, gravity.dy);
}
/// The maximum number of particles the system can display at a single time.
int maxParticles;
/// Total number of particles to emit, if the value is set to 0 the system
/// will continue to emit particles for an indifinte period of time.
int numParticlesToEmit;
/// The rate at which particles are emitted, defined in particles per second.
double emissionRate;
/// If set to true, the particle system will be automatically removed as soon
/// as there are no more particles left to draw.
bool autoRemoveOnFinish;
/// The [ColorSequence] used to animate the color of each individual particle
/// over the duration of its [life]. When applied to a particle the sequence's
/// color stops modified in accordance with the [alphaVar], [redVar],
/// [greenVar], and [blueVar] properties.
ColorSequence colorSequence;
/// Alpha varience of the [colorSequence] property.
int alphaVar;
/// Red varience of the [colorSequence] property.
int redVar;
/// Green varience of the [colorSequence] property.
int greenVar;
/// Blue varience of the [colorSequence] property.
int blueVar;
/// The transfer mode used to draw the particle system. Default is
/// [TransferMode.plus].
TransferMode transferMode;
List<_Particle> _particles;
double _emitCounter;
int _numEmittedParticles = 0;
/// The over all opacity of the particle system. This value is multiplied by
/// the opacity of the individual particles.
double opacity = 1.0;
static Paint _paint = new Paint()
..filterQuality = FilterQuality.low
..isAntiAlias = false;
@override
void update(double dt) {
// TODO: Fix this (it's a temp fix for low framerates)
if (dt > 0.1) dt = 0.1;
// Create new particles
double rate = 1.0 / emissionRate;
if (_particles.length < maxParticles) {
_emitCounter += dt;
}
while(_particles.length < maxParticles
&& _emitCounter > rate
&& (numParticlesToEmit == 0 || _numEmittedParticles < numParticlesToEmit)) {
// Add a new particle
_addParticle();
_emitCounter -= rate;
}
// _elapsedTime += dt;
// Iterate over all particles
for (int i = _particles.length -1; i >= 0; i--) {
_Particle particle = _particles[i];
// Manage life time
particle.timeToLive -= dt;
if (particle.timeToLive <= 0) {
_particles.removeAt(i);
continue;
}
// Update the particle
if (particle.accelerations != null) {
// Radial acceleration
Vector2 radial;
if (particle.pos[0] != 0 || particle.pos[1] != 0) {
radial = new Vector2.copy(particle.pos)..normalize();
} else {
radial = new Vector2.zero();
}
Vector2 tangential = new Vector2.copy(radial);
radial.scale(particle.accelerations.radialAccel);
// Tangential acceleration
double newY = tangential.x;
tangential.x = -tangential.y;
tangential.y = newY;
tangential.scale(particle.accelerations.tangentialAccel);
// (gravity + radial + tangential) * dt
final Vector2 accel = (_gravity + radial + tangential)..scale(dt);
particle.dir += accel;
} else if (_gravity[0] != 0.0 || _gravity[1] != 0) {
// gravity
final Vector2 accel = _gravity.clone()..scale(dt);
particle.dir += accel;
}
// Update particle position
particle.pos[0] += particle.dir[0] * dt;
particle.pos[1] += particle.dir[1] * dt;
// Size
particle.size = math.max(particle.size + particle.deltaSize * dt, 0.0);
// Angle
particle.rotation += particle.deltaRotation * dt;
// Color
if (particle.simpleColorSequence != null) {
for (int i = 0; i < 4; i++) {
particle.simpleColorSequence[i] += particle.simpleColorSequence[i + 4] * dt;
}
} else {
particle.colorPos = math.min(particle.colorPos + particle.deltaColorPos * dt, 1.0);
}
}
if (autoRemoveOnFinish && _particles.length == 0 && _numEmittedParticles > 0) {
if (parent != null) removeFromParent();
}
}
void _addParticle() {
_Particle particle = new _Particle();
// Time to live
particle.timeToLive = math.max(life + lifeVar * randomSignedDouble(), 0.0);
// Position
Point srcPos = Point.origin;
particle.pos = new Vector2(srcPos.x + posVar.x * randomSignedDouble(),
srcPos.y + posVar.y * randomSignedDouble());
// Size
particle.size = math.max(startSize + startSizeVar * randomSignedDouble(), 0.0);
double endSizeFinal = math.max(endSize + endSizeVar * randomSignedDouble(), 0.0);
particle.deltaSize = (endSizeFinal - particle.size) / particle.timeToLive;
// Rotation
particle.rotation = startRotation + startRotationVar * randomSignedDouble();
double endRotationFinal = endRotation + endRotationVar * randomSignedDouble();
particle.deltaRotation = (endRotationFinal - particle.rotation) / particle.timeToLive;
// Direction
double dirRadians = convertDegrees2Radians(direction + directionVar * randomSignedDouble());
Vector2 dirVector = new Vector2(math.cos(dirRadians), math.sin(dirRadians));
double speedFinal = speed + speedVar * randomSignedDouble();
particle.dir = dirVector..scale(speedFinal);
// Accelerations
if (radialAcceleration != 0.0 || radialAccelerationVar != 0.0 ||
tangentialAcceleration != 0.0 || tangentialAccelerationVar != 0.0) {
particle.accelerations = new _ParticleAccelerations();
// Radial acceleration
particle.accelerations.radialAccel = radialAcceleration + radialAccelerationVar * randomSignedDouble();
// Tangential acceleration
particle.accelerations.tangentialAccel = tangentialAcceleration + tangentialAccelerationVar * randomSignedDouble();
}
// Color
particle.colorPos = 0.0;
particle.deltaColorPos = 1.0 / particle.timeToLive;
if (alphaVar != 0 || redVar != 0 || greenVar != 0 || blueVar != 0) {
particle.colorSequence = _ColorSequenceUtil.copyWithVariance(colorSequence, alphaVar, redVar, greenVar, blueVar);
}
// Optimizes the case where there are only two colors in the sequence
if (colorSequence.colors.length == 2) {
Color startColor;
Color endColor;
if (particle.colorSequence != null) {
startColor = particle.colorSequence.colors[0];
endColor = particle.colorSequence.colors[1];
} else {
startColor = colorSequence.colors[0];
endColor = colorSequence.colors[1];
}
// First 4 elements are start ARGB, last 4 are delta ARGB
particle.simpleColorSequence = new Float64List(8);
particle.simpleColorSequence[0] = startColor.alpha.toDouble();
particle.simpleColorSequence[1] = startColor.red.toDouble();
particle.simpleColorSequence[2] = startColor.green.toDouble();
particle.simpleColorSequence[3] = startColor.blue.toDouble();
particle.simpleColorSequence[4] = (endColor.alpha.toDouble() - startColor.alpha.toDouble()) / particle.timeToLive;
particle.simpleColorSequence[5] = (endColor.red.toDouble() - startColor.red.toDouble()) / particle.timeToLive;
particle.simpleColorSequence[6] = (endColor.green.toDouble() - startColor.green.toDouble()) / particle.timeToLive;
particle.simpleColorSequence[7] = (endColor.blue.toDouble() - startColor.blue.toDouble()) / particle.timeToLive;
}
_particles.add(particle);
_numEmittedParticles++;
}
@override
void paint(Canvas canvas) {
if (opacity == 0.0)
return;
List<RSTransform> transforms = <RSTransform>[];
List<Rect> rects = <Rect>[];
List<Color> colors = <Color>[];
_paint.transferMode = transferMode;
for (_Particle particle in _particles) {
// Rect
Rect rect = texture.frame;
rects.add(rect);
// Transform
double scos;
double ssin;
if (rotateToMovement) {
double extraRotation = GameMath.atan2(particle.dir[1], particle.dir[0]);
scos = math.cos(convertDegrees2Radians(particle.rotation) + extraRotation) * particle.size;
ssin = math.sin(convertDegrees2Radians(particle.rotation) + extraRotation) * particle.size;
} else if (particle.rotation != 0.0) {
scos = math.cos(convertDegrees2Radians(particle.rotation)) * particle.size;
ssin = math.sin(convertDegrees2Radians(particle.rotation)) * particle.size;
} else {
scos = particle.size;
ssin = 0.0;
}
double ax = rect.width / 2;
double ay = rect.height / 2;
double tx = particle.pos[0] + -scos * ax + ssin * ay;
double ty = particle.pos[1] + -ssin * ax - scos * ay;
RSTransform transform = new RSTransform(scos, ssin, tx, ty);
transforms.add(transform);
// Color
if (particle.simpleColorSequence != null) {
Color particleColor = new Color.fromARGB(
(particle.simpleColorSequence[0] * opacity).toInt().clamp(0, 255),
particle.simpleColorSequence[1].toInt().clamp(0, 255),
particle.simpleColorSequence[2].toInt().clamp(0, 255),
particle.simpleColorSequence[3].toInt().clamp(0, 255));
colors.add(particleColor);
} else {
Color particleColor;
if (particle.colorSequence != null) {
particleColor = particle.colorSequence.colorAtPosition(particle.colorPos);
} else {
particleColor = colorSequence.colorAtPosition(particle.colorPos);
}
if (opacity != 1.0) {
particleColor = particleColor.withAlpha((particleColor.alpha * opacity).toInt().clamp(0, 255));
}
colors.add(particleColor);
}
}
canvas.drawAtlas(texture.image, transforms, rects, colors,
TransferMode.modulate, null, _paint);
}
}
class _ColorSequenceUtil {
static ColorSequence copyWithVariance(
ColorSequence sequence,
int alphaVar,
int redVar,
int greenVar,
int blueVar
) {
ColorSequence copy = new ColorSequence.copy(sequence);
int i = 0;
for (Color color in sequence.colors) {
int aDelta = ((randomDouble() * 2.0 - 1.0) * alphaVar).toInt();
int rDelta = ((randomDouble() * 2.0 - 1.0) * redVar).toInt();
int gDelta = ((randomDouble() * 2.0 - 1.0) * greenVar).toInt();
int bDelta = ((randomDouble() * 2.0 - 1.0) * blueVar).toInt();
int aNew = (color.alpha + aDelta).clamp(0, 255);
int rNew = (color.red + rDelta).clamp(0, 255);
int gNew = (color.green + gDelta).clamp(0, 255);
int bNew = (color.blue + bDelta).clamp(0, 255);
copy.colors[i] = new Color.fromARGB(aNew, rNew, gNew, bNew);
i++;
}
return copy;
}
}
packages/flutter_sprites/lib/src/sprite.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
part of flutter_sprites;
/// A Sprite is a [Node] that renders a bitmap image to the screen.
class Sprite extends NodeWithSize with SpritePaint {
/// The texture that the sprite will render to screen.
///
/// If the texture is null, the sprite will be rendered as a red square
/// marking the bounds of the sprite.
///
/// mySprite.texture = myTexture;
Texture texture;
/// If true, constrains the proportions of the image by scaling it down, if its proportions doesn't match the [size].
///
/// mySprite.constrainProportions = true;
bool constrainProportions = false;
Paint _cachedPaint = new Paint()
..filterQuality = FilterQuality.low
..isAntiAlias = false;
/// Creates a new sprite from the provided [texture].
///
/// var mySprite = new Sprite(myTexture)
Sprite([this.texture]) : super(Size.zero) {
if (texture != null) {
size = texture.size;
pivot = texture.pivot;
} else {
pivot = new Point(0.5, 0.5);
}
}
/// Creates a new sprite from the provided [image].
///
/// var mySprite = new Sprite.fromImage(myImage);
Sprite.fromImage(ui.Image image) : super(Size.zero) {
assert(image != null);
texture = new Texture(image);
size = texture.size;
pivot = new Point(0.5, 0.5);
}
@override
void paint(Canvas canvas) {
// Account for pivot point
applyTransformForPivot(canvas);
if (texture != null) {
double w = texture.size.width;
double h = texture.size.height;
if (w <= 0 || h <= 0) return;
double scaleX = size.width / w;
double scaleY = size.height / h;
if (constrainProportions) {
// Constrain proportions, using the smallest scale and by centering the image
if (scaleX < scaleY) {
canvas.translate(0.0, (size.height - scaleX * h) / 2.0);
scaleY = scaleX;
} else {
canvas.translate((size.width - scaleY * w) / 2.0, 0.0);
scaleX = scaleY;
}
}
canvas.scale(scaleX, scaleY);
// Setup paint object for opacity and transfer mode
_updatePaint(_cachedPaint);
// Do actual drawing of the sprite
texture.drawTexture(canvas, Point.origin, _cachedPaint);
} else {
// Paint a red square for missing texture
canvas.drawRect(new Rect.fromLTRB(0.0, 0.0, size.width, size.height),
new Paint()..color = new Color.fromARGB(255, 255, 0, 0));
}
}
}
/// Defines properties, such as [opacity] and [transferMode] that are shared
/// between [Node]s that render textures to screen.
abstract class SpritePaint {
double _opacity = 1.0;
/// The opacity of the sprite in the range 0.0 to 1.0.
///
/// mySprite.opacity = 0.5;
double get opacity => _opacity;
set opacity(double opacity) {
assert(opacity != null);
assert(opacity >= 0.0 && opacity <= 1.0);
_opacity = opacity;
}
/// The color to draw on top of the sprite, null if no color overlay is used.
///
/// // Color the sprite red
/// mySprite.colorOverlay = new Color(0x77ff0000);
Color colorOverlay;
/// The transfer mode used when drawing the sprite to screen.
///
/// // Add the colors of the sprite with the colors of the background
/// mySprite.transferMode = TransferMode.plusMode;
TransferMode transferMode;
void _updatePaint(Paint paint) {
paint.color = new Color.fromARGB((255.0*_opacity).toInt(), 255, 255, 255);
if (colorOverlay != null) {
paint.colorFilter = new ColorFilter.mode(colorOverlay, TransferMode.srcATop);
}
if (transferMode != null) {
paint.transferMode = transferMode;
}
}
}
packages/flutter_sprites/lib/src/sprite_box.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
part of flutter_sprites;
/// Options for setting up a [SpriteBox]'s coordinate system.
enum SpriteBoxTransformMode {
/// Use the same points as the parent [Widget].
nativePoints,
/// Use the size of the root node for the coordinate system, and constrain the
/// aspect ratio and trim off areas that end up outside the screen.
letterbox,
/// Use the size of the root node for the coordinate system, and scale it to
/// fit the size of the box.
stretch,
/// Similar to the letterbox option, but instead of trimming areas the sprite
/// system will be scaled down to fit the box.
scaleToFit,
/// Use the width of the root node to set the size of the coordinate system,
/// and change the height of the root node to fit the box.
fixedWidth,
/// Use the height of the root node to set the size of the coordinate system,
/// and change the width of the root node to fit the box.
fixedHeight,
}
/// A [RenderBox] that draws a sprite world represented by a [Node] tree.
class SpriteBox extends RenderBox {
// Setup
/// Creates a new SpriteBox with a node as its content, by default uses letterboxing.
///
/// The [rootNode] provides the content of the node tree, typically it's a custom subclass of [NodeWithSize]. The
/// [mode] provides different ways to scale the content to best fit it to the screen. In most cases it's preferred to
/// use a [SpriteWidget] that automatically wraps the SpriteBox.
///
/// var spriteBox = new SpriteBox(myNode, SpriteBoxTransformMode.fixedHeight);
SpriteBox(NodeWithSize rootNode, [SpriteBoxTransformMode mode = SpriteBoxTransformMode.letterbox]) {
assert(rootNode != null);
assert(rootNode._spriteBox == null);
// Setup transform mode
this.transformMode = mode;
// Setup root node
this.rootNode = rootNode;
}
void _removeSpriteBoxReference(Node node) {
node._spriteBox = null;
for (Node child in node._children) {
_removeSpriteBoxReference(child);
}
}
void _addSpriteBoxReference(Node node) {
node._spriteBox = this;
for (Node child in node._children) {
_addSpriteBoxReference(child);
}
}
@override
void attach(PipelineOwner owner) {
super.attach(owner);
_scheduleTick();
}
@override
void detach() {
super.detach();
_unscheduleTick();
}
// Member variables
// Tracking of frame rate and updates
Duration _lastTimeStamp;
double _frameRate = 0.0;
/// An instantaneous estimate of the number of frames per second this sprite box is producing.
double get frameRate => _frameRate;
// Transformation mode
SpriteBoxTransformMode _transformMode;
set transformMode (SpriteBoxTransformMode value) {
if (value == _transformMode)
return;
_transformMode = value;
// Invalidate stuff
markNeedsLayout();
}
/// The transform mode used by the [SpriteBox].
SpriteBoxTransformMode get transformMode => _transformMode;
// Cached transformation matrix
Matrix4 _transformMatrix;
List<Node> _eventTargets;
List<ActionController> _actionControllers;
List<Node> _constrainedNodes;
/// A rectangle that represents the visible area of the sprite world's
/// coordinate system.
Rect get visibleArea {
if (_visibleArea == null)
_calcTransformMatrix();
return _visibleArea;
}
Rect _visibleArea;
bool _initialized = false;
// Properties
/// The root node of the node tree that is rendered by this box.
///
/// var rootNode = mySpriteBox.rootNode;
NodeWithSize get rootNode => _rootNode;
NodeWithSize _rootNode;
set rootNode (NodeWithSize value) {
if (value == _rootNode) return;
// Ensure that the root node has a size
assert(_transformMode == SpriteBoxTransformMode.nativePoints
|| value.size.width > 0);
assert(_transformMode == SpriteBoxTransformMode.nativePoints
|| value.size.height > 0);
// Remove sprite box references
if (_rootNode != null)
_removeSpriteBoxReference(_rootNode);
// Update the value
_rootNode = value;
_actionControllers = null;
// Add new references
_addSpriteBoxReference(_rootNode);
markNeedsLayout();
}
@override
void performLayout() {
size = constraints.biggest;
_invalidateTransformMatrix();
_callSpriteBoxPerformedLayout(_rootNode);
_initialized = true;
}
// Adding and removing nodes
void _registerNode(Node node) {
_actionControllers = null;
_eventTargets = null;
if (node == null || node.constraints != null) _constrainedNodes = null;
}
void _deregisterNode(Node node) {
_actionControllers = null;
_eventTargets = null;
if (node == null || node.constraints != null) _constrainedNodes = null;
}
// Event handling
void _addEventTargets(Node node, List<Node> eventTargets) {
List<Node> children = node.children;
int i = 0;
// Add childrens that are behind this node
while (i < children.length) {
Node child = children[i];
if (child.zPosition >= 0.0)
break;
_addEventTargets(child, eventTargets);
i++;
}
// Add this node
if (node.userInteractionEnabled) {
eventTargets.add(node);
}
// Add children in front of this node
while (i < children.length) {
Node child = children[i];
_addEventTargets(child, eventTargets);
i++;
}
}
@override
void handleEvent(PointerEvent event, _SpriteBoxHitTestEntry entry) {
if (!attached)
return;
if (event is PointerDownEvent) {
// Build list of event targets
if (_eventTargets == null) {
_eventTargets = <Node>[];
_addEventTargets(_rootNode, _eventTargets);
}
// Find the once that are hit by the pointer
List<Node> nodeTargets = <Node>[];
for (int i = _eventTargets.length - 1; i >= 0; i--) {
Node node = _eventTargets[i];
// Check if the node is ready to handle a pointer
if (node.handleMultiplePointers || node._handlingPointer == null) {
// Do the hit test
Point posInNodeSpace = node.convertPointToNodeSpace(entry.localPosition);
if (node.isPointInside(posInNodeSpace)) {
nodeTargets.add(node);
node._handlingPointer = event.pointer;
}
}
}
entry.nodeTargets = nodeTargets;
}
// Pass the event down to nodes that were hit by the pointerdown
List<Node> targets = entry.nodeTargets;
for (Node node in targets) {
// Check if this event should be dispatched
if (node.handleMultiplePointers || event.pointer == node._handlingPointer) {
// Dispatch event
bool consumedEvent = node.handleEvent(new SpriteBoxEvent(globalToLocal(event.position), event.runtimeType, event.pointer));
if (consumedEvent == null || consumedEvent)
break;
}
}
// De-register pointer for nodes that doesn't handle multiple pointers
for (Node node in targets) {
if (event is PointerUpEvent || event is PointerCancelEvent)
node._handlingPointer = null;
}
}
@override
bool hitTest(HitTestResult result, { Point position }) {
result.add(new _SpriteBoxHitTestEntry(this, position));
return true;
}
// Rendering
/// The transformation matrix used to transform the root node to the space of the box.
///
/// It's uncommon to need access to this property.
///
/// var matrix = mySpriteBox.transformMatrix;
Matrix4 get transformMatrix {
// Get cached matrix if available
if (_transformMatrix == null) {
_calcTransformMatrix();
}
return _transformMatrix;
}
void _calcTransformMatrix() {
_transformMatrix = new Matrix4.identity();
// Calculate matrix
double scaleX = 1.0;
double scaleY = 1.0;
double offsetX = 0.0;
double offsetY = 0.0;
double systemWidth = rootNode.size.width;
double systemHeight = rootNode.size.height;
switch(_transformMode) {
case SpriteBoxTransformMode.stretch:
scaleX = size.width/systemWidth;
scaleY = size.height/systemHeight;
break;
case SpriteBoxTransformMode.letterbox:
scaleX = size.width/systemWidth;
scaleY = size.height/systemHeight;
if (scaleX > scaleY) {
scaleY = scaleX;
offsetY = (size.height - scaleY * systemHeight)/2.0;
} else {
scaleX = scaleY;
offsetX = (size.width - scaleX * systemWidth)/2.0;
}
break;
case SpriteBoxTransformMode.scaleToFit:
scaleX = size.width/systemWidth;
scaleY = size.height/systemHeight;
if (scaleX < scaleY) {
scaleY = scaleX;
offsetY = (size.height - scaleY * systemHeight)/2.0;
} else {
scaleX = scaleY;
offsetX = (size.width - scaleX * systemWidth)/2.0;
}
break;
case SpriteBoxTransformMode.fixedWidth:
scaleX = size.width/systemWidth;
scaleY = scaleX;
systemHeight = size.height/scaleX;
rootNode.size = new Size(systemWidth, systemHeight);
break;
case SpriteBoxTransformMode.fixedHeight:
scaleY = size.height/systemHeight;
scaleX = scaleY;
systemWidth = size.width/scaleY;
rootNode.size = new Size(systemWidth, systemHeight);
break;
case SpriteBoxTransformMode.nativePoints:
systemWidth = size.width;
systemHeight = size.height;
break;
default:
assert(false);
break;
}
_visibleArea = new Rect.fromLTRB(-offsetX / scaleX,
-offsetY / scaleY,
systemWidth + offsetX / scaleX,
systemHeight + offsetY / scaleY);
_transformMatrix.translate(offsetX, offsetY);
_transformMatrix.scale(scaleX, scaleY);
}
void _invalidateTransformMatrix() {
_visibleArea = null;
_transformMatrix = null;
_rootNode._invalidateToBoxTransformMatrix();
}
@override
void paint(PaintingContext context, Offset offset) {
final Canvas canvas = context.canvas;
// Move to correct coordinate space before drawing
canvas
..save()
..translate(offset.dx, offset.dy)
..transform(transformMatrix.storage);
// Draw the sprite tree
_rootNode._visit(canvas);
canvas.restore();
}
// Updates
int _frameCallbackId;
void _scheduleTick() {
_frameCallbackId = SchedulerBinding.instance.scheduleFrameCallback(_tick);
}
void _unscheduleTick() {
SchedulerBinding.instance.cancelFrameCallbackWithId(_frameCallbackId);
}
void _tick(Duration timeStamp) {
if (!attached)
return;
// Calculate delta and frame rate
if (_lastTimeStamp == null)
_lastTimeStamp = timeStamp;
double delta = (timeStamp - _lastTimeStamp).inMicroseconds.toDouble() / Duration.MICROSECONDS_PER_SECOND;
_lastTimeStamp = timeStamp;
_frameRate = 1.0 / delta;
if (_initialized) {
_callConstraintsPreUpdate(delta);
_runActions(delta);
_callUpdate(_rootNode, delta);
_callConstraintsConstrain(delta);
}
// Schedule next update
_scheduleTick();
// Make sure the node graph is redrawn
markNeedsPaint();
}
void _runActions(double dt) {
if (_actionControllers == null) {
_rebuildActionControllersAndPhysicsNodes();
}
for (ActionController actions in _actionControllers) {
actions.step(dt);
}
}
void _rebuildActionControllersAndPhysicsNodes() {
_actionControllers = <ActionController>[];
_addActionControllersAndPhysicsNodes(_rootNode);
}
void _addActionControllersAndPhysicsNodes(Node node) {
if (node._actions != null) _actionControllers.add(node._actions);
for (int i = node.children.length - 1; i >= 0; i--) {
Node child = node.children[i];
_addActionControllersAndPhysicsNodes(child);
}
}
void _callUpdate(Node node, double dt) {
node.update(dt);
for (int i = node.children.length - 1; i >= 0; i--) {
Node child = node.children[i];
if (!child.paused) {
_callUpdate(child, dt);
}
}
}
void _callConstraintsPreUpdate(double dt) {
if (_constrainedNodes == null) {
_constrainedNodes = <Node>[];
_addConstrainedNodes(_rootNode, _constrainedNodes);
}
for (Node node in _constrainedNodes) {
for (Constraint constraint in node.constraints) {
constraint.preUpdate(node, dt);
}
}
}
void _callConstraintsConstrain(double dt) {
if (_constrainedNodes == null) {
_constrainedNodes = <Node>[];
_addConstrainedNodes(_rootNode, _constrainedNodes);
}
for (Node node in _constrainedNodes) {
for (Constraint constraint in node.constraints) {
constraint.constrain(node, dt);
}
}
}
void _addConstrainedNodes(Node node, List<Node> nodes) {
if (node._constraints != null && node._constraints.length > 0) {
nodes.add(node);
}
for (Node child in node.children) {
_addConstrainedNodes(child, nodes);
}
}
void _callSpriteBoxPerformedLayout(Node node) {
node.spriteBoxPerformedLayout();
for (Node child in node.children) {
_callSpriteBoxPerformedLayout(child);
}
}
// Hit tests
/// Finds all nodes at a position defined in the box's coordinates.
///
/// Use this method with caution. It searches the complete node tree to locate the nodes, which can be slow if the
/// node tree is large.
///
/// List nodes = mySpriteBox.findNodesAtPosition(new Point(50.0, 50.0));
List<Node> findNodesAtPosition(Point position) {
assert(position != null);
List<Node> nodes = <Node>[];
// Traverse the render tree and find objects at the position
_addNodesAtPosition(_rootNode, position, nodes);
return nodes;
}
void _addNodesAtPosition(Node node, Point position, List<Node> list) {
// Visit children first
for (Node child in node.children) {
_addNodesAtPosition(child, position, list);
}
// Do the hit test
Point posInNodeSpace = node.convertPointToNodeSpace(position);
if (node.isPointInside(posInNodeSpace)) {
list.add(node);
}
}
}
class _SpriteBoxHitTestEntry extends BoxHitTestEntry {
List<Node> nodeTargets;
_SpriteBoxHitTestEntry(RenderBox target, Point localPosition) : super(target, localPosition);
}
/// An event that is passed down the node tree when pointer events occur. The SpriteBoxEvent is typically handled in
/// the handleEvent method of [Node].
class SpriteBoxEvent {
/// The position of the event in box coordinates.
///
/// You can use the convertPointToNodeSpace of [Node] to convert the position to local coordinates.
///
/// bool handleEvent(SpriteBoxEvent event) {
/// Point localPosition = convertPointToNodeSpace(event.boxPosition);
/// if (event.type == 'pointerdown') {
/// // Do something!
/// }
/// }
final Point boxPosition;
/// The type of event, there are currently four valid types, PointerDownEvent, PointerMoveEvent, PointerUpEvent, and
/// PointerCancelEvent.
///
/// if (event.type == PointerDownEvent) {
/// // Do something!
/// }
final Type type;
/// The id of the pointer. Each pointer on the screen will have a unique pointer id.
///
/// if (event.pointer == firstPointerId) {
/// // Do something
/// }
final int pointer;
/// Creates a new SpriteBoxEvent, typically this is done internally inside the SpriteBox.
///
/// var event = new SpriteBoxEvent(new Point(50.0, 50.0), 'pointerdown', 0);
SpriteBoxEvent(this.boxPosition, this.type, this.pointer);
}
packages/flutter_sprites/lib/src/sprite_widget.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
part of flutter_sprites;
/// A widget that uses a [SpriteBox] to render a sprite node tree to the screen.
class SpriteWidget extends SingleChildRenderObjectWidget {
/// The rootNode of the sprite node tree.
///
/// var node = mySpriteWidget.rootNode;
final NodeWithSize rootNode;
/// The transform mode used to fit the sprite node tree to the size of the widget.
final SpriteBoxTransformMode transformMode;
/// Creates a new sprite widget with [rootNode] as its content.
///
/// The widget will setup the coordinate space for the sprite node tree using the size of the [rootNode] in
/// combination with the supplied [transformMode]. By default the letterbox transform mode is used. See
/// [SpriteBoxTransformMode] for more details on the different modes.
///
/// The most common way to setup the sprite node graph is to subclass [NodeWithSize] and pass it to the sprite widget.
/// In the custom subclass it's possible to build the node graph, do animations and handle user events.
///
/// var mySpriteTree = new MyCustomNodeWithSize();
/// var mySpriteWidget = new SpriteWidget(mySpriteTree, SpriteBoxTransformMode.fixedHeight);
SpriteWidget(this.rootNode, [this.transformMode = SpriteBoxTransformMode.letterbox]);
@override
SpriteBox createRenderObject(BuildContext context) => new SpriteBox(rootNode, transformMode);
@override
void updateRenderObject(BuildContext context, SpriteBox renderObject) {
renderObject
..rootNode = rootNode
..transformMode = transformMode;
}
}
packages/flutter_sprites/lib/src/spritesheet.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
part of flutter_sprites;
/// A sprite sheet packs a number of smaller images into a single large image.
///
/// The placement of the smaller images are defined by a json file. The larger image and json file is typically created
/// by a tool such as TexturePacker. The [SpriteSheet] class will take a reference to a larger image and a json string.
/// From the image and the string the [SpriteSheet] creates a number of [Texture] objects. The names of the frames in
/// the sprite sheet definition are used to reference the different textures.
class SpriteSheet {
ui.Image _image;
Map<String, Texture> _textures = new Map<String, Texture>();
/// Creates a new sprite sheet from an [_image] and a sprite sheet [jsonDefinition].
///
/// var mySpriteSheet = new SpriteSheet(myImage, jsonString);
SpriteSheet(this._image, String jsonDefinition) {
assert(_image != null);
assert(jsonDefinition != null);
JsonDecoder decoder = new JsonDecoder();
Map<dynamic, dynamic> file = decoder.convert(jsonDefinition);
assert(file != null);
List<dynamic> frames = file["frames"];
for (Map<dynamic, dynamic> frameInfo in frames) {
String fileName = frameInfo["filename"];
Rect frame = _readJsonRect(frameInfo["frame"]);
bool rotated = frameInfo["rotated"];
bool trimmed = frameInfo["trimmed"];
Rect spriteSourceSize = _readJsonRect(frameInfo["spriteSourceSize"]);
Size sourceSize = _readJsonSize(frameInfo["sourceSize"]);
Point pivot = _readJsonPoint(frameInfo["pivot"]);
Texture texture = new Texture._fromSpriteFrame(_image, fileName, sourceSize, rotated, trimmed, frame,
spriteSourceSize, pivot);
_textures[fileName] = texture;
}
}
Rect _readJsonRect(Map<dynamic, dynamic> data) {
num x = data["x"];
num y = data["y"];
num w = data["w"];
num h = data["h"];
return new Rect.fromLTRB(x.toDouble(), y.toDouble(), (x + w).toDouble(), (y + h).toDouble());
}
Size _readJsonSize(Map<dynamic, dynamic> data) {
num w = data["w"];
num h = data["h"];
return new Size(w.toDouble(), h.toDouble());
}
Point _readJsonPoint(Map<dynamic, dynamic> data) {
num x = data["x"];
num y = data["y"];
return new Point(x.toDouble(), y.toDouble());
}
/// The image used by the sprite sheet.
///
/// var spriteSheetImage = mySpriteSheet.image;
ui.Image get image => _image;
/// Returns a texture by its name.
///
/// var myTexture = mySpriteSheet["example.png"];
Texture operator [](String fileName) => _textures[fileName];
}
packages/flutter_sprites/lib/src/texture.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
part of flutter_sprites;
/// A texture represents a rectangular area of an image and is typically used to draw a sprite to the screen.
///
/// Normally you get a reference to a texture from a [SpriteSheet], but you can also create one from an [Image].
class Texture {
/// Creates a new texture from an [Image] object.
///
/// var myTexture = new Texture(myImage);
Texture(ui.Image image) :
size = new Size(image.width.toDouble(), image.height.toDouble()),
image = image,
trimmed = false,
rotated = false,
frame = new Rect.fromLTRB(0.0, 0.0, image.width.toDouble(), image.height.toDouble()),
spriteSourceSize = new Rect.fromLTRB(0.0, 0.0, image.width.toDouble(), image.height.toDouble()),
pivot = new Point(0.5, 0.5);
Texture._fromSpriteFrame(this.image, this.name, this.size, this.rotated, this.trimmed, this.frame,
this.spriteSourceSize, this.pivot);
/// The image that this texture is a part of.
///
/// var textureImage = myTexture.image;
final ui.Image image;
/// The logical size of the texture, before being trimmed by the texture packer.
///
/// var textureSize = myTexture.size;
final Size size;
/// The name of the image acts as a tag when acquiring a reference to it.
///
/// myTexture.name = "new_texture_name";
String name;
/// The texture was rotated 90 degrees when being packed into a sprite sheet.
///
/// if (myTexture.rotated) drawRotated();
final bool rotated;
/// The texture was trimmed when being packed into a sprite sheet.
///
/// bool trimmed = myTexture.trimmed
final bool trimmed;
/// The frame of the trimmed texture inside the image.
///
/// Rect frame = myTexture.frame;
final Rect frame;
/// The offset and size of the trimmed texture inside the image.
///
/// Position represents the offset from the logical [size], the size of the rect represents the size of the trimmed
/// texture.
///
/// Rect spriteSourceSize = myTexture.spriteSourceSize;
final Rect spriteSourceSize;
/// The default pivot point for this texture. When creating a [Sprite] from the texture, this is the pivot point that
/// will be used.
///
/// myTexture.pivot = new Point(0.5, 0.5);
Point pivot;
/// Creates a new Texture from a part of the current texture.
Texture textureFromRect(Rect rect, [String name = null]) {
assert(rect != null);
assert(!rotated);
Rect srcFrame = new Rect.fromLTWH(rect.left + frame.left, rect.top + frame.top, rect.size.width, rect.size.height);
Rect dstFrame = new Rect.fromLTWH(0.0, 0.0, rect.size.width, rect.size.height);
return new Texture._fromSpriteFrame(image, name, rect.size, false, false, srcFrame, dstFrame, new Point(0.5, 0.5));
}
/// Draws the texture to a [Canvas] at a specified [position] and with the
/// specified [paint].
void drawTexture(Canvas canvas, Point position, Paint paint) {
// Get drawing position
double x = position.x;
double y = position.y;
// Draw the texture
if (rotated) {
// Account for position
bool translate = (x != 0 || y != 0);
if (translate) {
canvas.translate(x, y);
}
// Calculate the rotated frame and spriteSourceSize
Size originalFrameSize = frame.size;
Rect rotatedFrame = frame.topLeft & new Size(originalFrameSize.height, originalFrameSize.width);
Point rotatedSpriteSourcePoint = new Point(
-spriteSourceSize.top - (spriteSourceSize.bottom - spriteSourceSize.top),
spriteSourceSize.left);
Rect rotatedSpriteSourceSize = rotatedSpriteSourcePoint & new Size(originalFrameSize.height, originalFrameSize.width);
// Draw the rotated sprite
canvas.rotate(-math.PI/2.0);
canvas.drawImageRect(image, rotatedFrame, rotatedSpriteSourceSize, paint);
canvas.rotate(math.PI/2.0);
// Translate back
if (translate) {
canvas.translate(-x, -y);
}
} else {
// Draw the sprite
Rect dstRect = new Rect.fromLTWH(x + spriteSourceSize.left, y + spriteSourceSize.top, spriteSourceSize.width, spriteSourceSize.height);
canvas.drawImageRect(image, frame, dstRect, paint);
}
}
}
packages/flutter_sprites/lib/src/textured_line.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
part of flutter_sprites;
/// A [Node] that draws a polyline from a list of points using the provided
/// [Texture]. The textured line draws static lines. If you want to create an
/// animated line, consider using the [EffectLine] instead.
class TexturedLine extends Node {
/// Creates a new TexturedLine.
TexturedLine(List<Point> points, List<Color> colors, List<double> widths, [Texture texture, List<double> textureStops]) {
painter = new TexturedLinePainter(points, colors, widths, texture, textureStops);
}
/// The painter used to draw the line.
TexturedLinePainter painter;
@override
void paint(Canvas canvas) {
painter.paint(canvas);
}
}
/// Draws a polyline to a [Canvas] from a list of points using the provided [Texture].
class TexturedLinePainter {
/// Creates a painter that draws a polyline with a texture.
TexturedLinePainter(this._points, this.colors, this.widths, [Texture texture, this.textureStops]) {
this.texture = texture;
}
/// The points that makes up the polyline.
List<Point> get points => _points;
List<Point> _points;
set points(List<Point> points) {
_points = points;
_calculatedTextureStops = null;
}
/// The color of each point on the polyline. The color of the line will be
/// interpolated between the points.
List<Color> colors;
/// The width of the line at each point on the polyline.
List<double> widths;
/// The texture this line will be drawn using.
Texture get texture => _texture;
Texture _texture;
set texture(Texture texture) {
_texture = texture;
if (texture == null) {
_cachedPaint = new Paint();
} else {
Matrix4 matrix = new Matrix4.identity();
ImageShader shader = new ImageShader(texture.image,
TileMode.repeated, TileMode.repeated, matrix.storage);
_cachedPaint = new Paint()
..shader = shader;
}
}
/// Defines the position in the texture for each point on the polyline.
List<double> textureStops;
/// The [textureStops] used if no explicit texture stops has been provided.
List<double> get calculatedTextureStops {
if (_calculatedTextureStops == null)
_calculateTextureStops();
return _calculatedTextureStops;
}
List<double> _calculatedTextureStops;
double _length;
/// The length of the line.
double get length {
if (_calculatedTextureStops == null)
_calculateTextureStops();
return _length;
}
/// The offset of the texture on the line.
double textureStopOffset = 0.0;
/// The length, in points, that the texture is stretched to. If the
/// textureLoopLength is shorter than the line, the texture will be looped.
double get textureLoopLength => textureLoopLength;
double _textureLoopLength;
set textureLoopLength(double textureLoopLength) {
_textureLoopLength = textureLoopLength;
_calculatedTextureStops = null;
}
/// If true, the textured line attempts to remove artifacts at sharp corners
/// on the polyline.
bool removeArtifacts = true;
/// The [TransferMode] used to draw the line to the [Canvas].
TransferMode transferMode = TransferMode.srcOver;
Paint _cachedPaint = new Paint();
/// Paints the line to the [canvas].
void paint(Canvas canvas) {
// Check input values
assert(_points != null);
if (_points.length < 2) return;
assert(_points.length == colors.length);
assert(_points.length == widths.length);
_cachedPaint.transferMode = transferMode;
// Calculate normals
List<Vector2> vectors = <Vector2>[];
for (Point pt in _points) {
vectors.add(new Vector2(pt.x, pt.y));
}
List<Vector2> miters = _computeMiterList(vectors, false);
List<Point> vertices = <Point>[];
List<int> indices = <int>[];
List<Color> verticeColors = <Color>[];
List<Point> textureCoordinates;
double textureTop;
double textureBottom;
List<double> stops;
// Add first point
Point lastPoint = _points[0];
Vector2 lastMiter = miters[0];
// Add vertices and colors
_addVerticesForPoint(vertices, lastPoint, lastMiter, widths[0]);
verticeColors.add(colors[0]);
verticeColors.add(colors[0]);
if (texture != null) {
assert(texture.rotated == false);
// Setup for calculating texture coordinates
textureTop = texture.frame.top;
textureBottom = texture.frame.bottom;
textureCoordinates = <Point>[];
// Use correct stops
if (textureStops != null) {
assert(_points.length == textureStops.length);
stops = textureStops;
} else {
if (_calculatedTextureStops == null) _calculateTextureStops();
stops = _calculatedTextureStops;
}
// Texture coordinate points
double xPos = _xPosForStop(stops[0]);
textureCoordinates.add(new Point(xPos, textureTop));
textureCoordinates.add(new Point(xPos, textureBottom));
}
// Add the rest of the points
for (int i = 1; i < _points.length; i++) {
// Add vertices
Point currentPoint = _points[i];
Vector2 currentMiter = miters[i];
_addVerticesForPoint(vertices, currentPoint, currentMiter, widths[i]);
// Add references to the triangles
int lastIndex0 = (i - 1) * 2;
int lastIndex1 = (i - 1) * 2 + 1;
int currentIndex0 = i * 2;
int currentIndex1 = i * 2 + 1;
indices.addAll(<int>[lastIndex0, lastIndex1, currentIndex0]);
indices.addAll(<int>[lastIndex1, currentIndex1, currentIndex0]);
// Add colors
verticeColors.add(colors[i]);
verticeColors.add(colors[i]);
if (texture != null) {
// Texture coordinate points
double xPos = _xPosForStop(stops[i]);
textureCoordinates.add(new Point(xPos, textureTop));
textureCoordinates.add(new Point(xPos, textureBottom));
}
// Update last values
lastPoint = currentPoint;
lastMiter = currentMiter;
}
canvas.drawVertices(VertexMode.triangles, vertices, textureCoordinates, verticeColors, TransferMode.modulate, indices, _cachedPaint);
}
double _xPosForStop(double stop) {
if (_textureLoopLength == null) {
return texture.frame.left + texture.frame.width * (stop - textureStopOffset);
} else {
return texture.frame.left + texture.frame.width * (stop - textureStopOffset * (_textureLoopLength / length)) * (length / _textureLoopLength);
}
}
void _addVerticesForPoint(List<Point> vertices, Point point, Vector2 miter, double width) {
double halfWidth = width / 2.0;
Offset offset0 = new Offset(miter[0] * halfWidth, miter[1] * halfWidth);
Offset offset1 = new Offset(-miter[0] * halfWidth, -miter[1] * halfWidth);
Point vertex0 = point + offset0;
Point vertex1 = point + offset1;
int vertexCount = vertices.length;
if (removeArtifacts && vertexCount >= 2) {
Point oldVertex0 = vertices[vertexCount - 2];
Point oldVertex1 = vertices[vertexCount - 1];
Point intersection = GameMath.lineIntersection(oldVertex0, oldVertex1, vertex0, vertex1);
if (intersection != null) {
if (GameMath.distanceBetweenPoints(vertex0, intersection) < GameMath.distanceBetweenPoints(vertex1, intersection)) {
vertex0 = oldVertex0;
} else {
vertex1 = oldVertex1;
}
}
}
vertices.add(vertex0);
vertices.add(vertex1);
}
void _calculateTextureStops() {
List<double> stops = <double>[];
double length = 0.0;
// Add first stop
stops.add(0.0);
// Calculate distance to each point from the first point along the line
for (int i = 1; i < _points.length; i++) {
Point lastPoint = _points[i - 1];
Point currentPoint = _points[i];
double dist = GameMath.distanceBetweenPoints(lastPoint, currentPoint);
length += dist;
stops.add(length);
}
// Normalize the values in the range [0.0, 1.0]
for (int i = 1; i < points.length; i++) {
stops[i] = stops[i] / length;
new Point(512.0, 512.0);
}
_calculatedTextureStops = stops;
_length = length;
}
}
Vector2 _computeMiter(Vector2 lineA, Vector2 lineB) {
Vector2 miter = new Vector2(- (lineA[1] + lineB[1]), lineA[0] + lineB[0]);
miter.normalize();
double dot = dot2(miter, new Vector2(-lineA[1], lineA[0]));
if (dot.abs() < 0.1) {
miter = _vectorNormal(lineA)..normalize();
return miter;
}
double miterLength = 1.0 / dot;
return miter..scale(miterLength);
}
Vector2 _vectorNormal(Vector2 v) {
return new Vector2(-v[1], v[0]);
}
Vector2 _vectorDirection(Vector2 a, Vector2 b) {
Vector2 result = a - b;
return result..normalize();
}
List<Vector2> _computeMiterList(List<Vector2> points, bool closed) {
List<Vector2> out = <Vector2>[];
Vector2 curNormal;
if (closed) {
points = new List<Vector2>.from(points);
points.add(points[0]);
}
int total = points.length;
for (int i = 1; i < total; i++) {
Vector2 last = points[i - 1];
Vector2 cur = points[i];
Vector2 next = (i < total - 1) ? points[i + 1] : null;
Vector2 lineA = _vectorDirection(cur, last);
if (curNormal == null) {
curNormal = _vectorNormal(lineA);
}
if (i == 1) {
out.add(curNormal);
}
if (next == null) {
curNormal = _vectorNormal(lineA);
out.add(curNormal);
} else {
Vector2 lineB = _vectorDirection(next, cur);
Vector2 miter = _computeMiter(lineA, lineB);
out.add(miter);
}
}
return out;
}
packages/flutter_sprites/lib/src/util.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
part of flutter_sprites;
math.Random _random = new math.Random();
// Random methods
/// Returns a random [double] in the range of 0.0 to 1.0.
double randomDouble() {
return _random.nextDouble();
}
/// Returns a random [double] in the range of -1.0 to 1.0.
double randomSignedDouble() {
return _random.nextDouble() * 2.0 - 1.0;
}
/// Returns a random [int] from 0 to max - 1.
int randomInt(int max) {
return _random.nextInt(max);
}
/// Returns either [true] or [false] in a most random fashion.
bool randomBool() {
return _random.nextDouble() < 0.5;
}
// atan2
class _Atan2Constants {
_Atan2Constants() {
for (int i = 0; i <= size; i++) {
double f = i.toDouble() / size.toDouble();
ppy[i] = math.atan(f) * stretch / math.PI;
ppx[i] = stretch * 0.5 - ppy[i];
pny[i] = -ppy[i];
pnx[i] = ppy[i] - stretch * 0.5;
npy[i] = stretch - ppy[i];
npx[i] = ppy[i] + stretch * 0.5;
nny[i] = ppy[i] - stretch;
nnx[i] = -stretch * 0.5 - ppy[i];
}
}
static const int size = 1024;
static const double stretch = math.PI;
static const int ezis = -size;
final Float64List ppy = new Float64List(size + 1);
final Float64List ppx = new Float64List(size + 1);
final Float64List pny = new Float64List(size + 1);
final Float64List pnx = new Float64List(size + 1);
final Float64List npy = new Float64List(size + 1);
final Float64List npx = new Float64List(size + 1);
final Float64List nny = new Float64List(size + 1);
final Float64List nnx = new Float64List(size + 1);
}
/// Provides convenience methods for calculations often carried out in graphics.
/// Some of the methods are returning approximations.
class GameMath {
static final _Atan2Constants _atan2 = new _Atan2Constants();
/// Returns the angle of two vector components. The result is less acurate
/// than the standard atan2 function in the math package.
static double atan2(double y, double x) {
if (x >= 0) {
if (y >= 0) {
if (x >= y)
return _atan2.ppy[(_Atan2Constants.size * y / x + 0.5).toInt()];
else
return _atan2.ppx[(_Atan2Constants.size * x / y + 0.5).toInt()];
} else {
if (x >= -y)
return _atan2.pny[(_Atan2Constants.ezis * y / x + 0.5).toInt()];
else
return _atan2.pnx[(_Atan2Constants.ezis * x / y + 0.5).toInt()];
}
} else {
if (y >= 0) {
if (-x >= y)
return _atan2.npy[(_Atan2Constants.ezis * y / x + 0.5).toInt()];
else
return _atan2.npx[(_Atan2Constants.ezis * x / y + 0.5).toInt()];
} else {
if (x <= y)
return _atan2.nny[(_Atan2Constants.size * y / x + 0.5).toInt()];
else
return _atan2.nnx[(_Atan2Constants.size * x / y + 0.5).toInt()];
}
}
}
/// Approximates the distance between two points. The returned value can be
/// up to 6% wrong in the worst case.
static double distanceBetweenPoints(Point a, Point b) {
double dx = a.x - b.x;
double dy = a.y - b.y;
if (dx < 0.0) dx = -dx;
if (dy < 0.0) dy = -dy;
if (dx > dy) {
return dx + dy/2.0;
}
else {
return dy + dx/2.0;
}
}
/// Interpolates a [double] between [a] and [b] according to the
/// [filterFactor], which should be in the range of 0.0 to 1.0.
static double filter (double a, double b, double filterFactor) {
return (a * (1-filterFactor)) + b * filterFactor;
}
/// Interpolates a [Point] between [a] and [b] according to the
/// [filterFactor], which should be in the range of 0.0 to 1.0.
static Point filterPoint(Point a, Point b, double filterFactor) {
return new Point(filter(a.x, b.x, filterFactor), filter(a.y, b.y, filterFactor));
}
/// Returns the intersection between two line segmentss defined by p0, p1 and
/// q0, q1. If the lines are not intersecting null is returned.
static Point lineIntersection(Point p0, Point p1, Point q0, Point q1) {
double epsilon = 1e-10;
Vector2 r = new Vector2(p1.x - p0.x, p1.y - p0.y);
Vector2 s = new Vector2(q1.x - q0.x, q1.y - q0.y);
Vector2 qp = new Vector2(q0.x - p0.x, q0.y - p0.y);
double rxs = cross2(r, s);
if (rxs.abs() < epsilon) {
// The lines are linear or collinear
return null;
}
double t = cross2(qp, s) / rxs;
double u = cross2(qp, r) / rxs;
if ((0.0 <= t && t <= 1.0) && (0.0 <= u && u <= 1.0)) {
return new Point(p0.x + t * r.x, p0.y + t * r.y);
}
// No intersection between the lines
return null;
}
}
packages/flutter_sprites/lib/src/virtual_joystick.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
part of flutter_sprites;
/// Provides a virtual joystick that can easily be added to your sprite scene.
class VirtualJoystick extends NodeWithSize {
/// Creates a new virtual joystick.
VirtualJoystick() : super(new Size(160.0, 160.0)) {
userInteractionEnabled = true;
handleMultiplePointers = false;
position = new Point(160.0, -20.0);
pivot = new Point(0.5, 1.0);
_center = new Point(size.width / 2.0, size.height / 2.0);
_handlePos = _center;
_paintHandle = new Paint()
..color=new Color(0xffffffff);
_paintControl = new Paint()
..color=new Color(0xffffffff)
..strokeWidth = 1.0
..style = PaintingStyle.stroke;
}
/// Reads the current value of the joystick. A point with from (-1.0, -1.0)
/// to (1.0, 1.0). If the joystick isn't moved it will return (0.0, 0.0).
Point get value => _value;
Point _value = Point.origin;
/// True if the user is currently touching the joystick.
bool get isDown => _isDown;
bool _isDown = false;
Point _pointerDownAt;
Point _center;
Point _handlePos;
Paint _paintHandle;
Paint _paintControl;
@override
bool handleEvent(SpriteBoxEvent event) {
if (event.type == PointerDownEvent) {
_pointerDownAt = event.boxPosition;
actions.stopAll();
_isDown = true;
}
else if (event.type == PointerUpEvent || event.type == PointerCancelEvent) {
_pointerDownAt = null;
_value = Point.origin;
ActionTween moveToCenter = new ActionTween((Point a) => _handlePos = a, _handlePos, _center, 0.4, Curves.elasticOut);
actions.run(moveToCenter);
_isDown = false;
} else if (event.type == PointerMoveEvent) {
Offset movedDist = event.boxPosition - _pointerDownAt;
_value = new Point(
(movedDist.dx / 80.0).clamp(-1.0, 1.0),
(movedDist.dy / 80.0).clamp(-1.0, 1.0));
_handlePos = _center + new Offset(_value.x * 40.0, _value.y * 40.0);
}
return true;
}
@override
void paint(Canvas canvas) {
applyTransformForPivot(canvas);
canvas.drawCircle(_handlePos, 25.0, _paintHandle);
canvas.drawCircle(_center, 40.0, _paintControl);
}
}
packages/flutter_sprites/pubspec.yaml deleted 100644 → 0
View file @ b7af062a
name: flutter_sprites
description: A sprite toolkit built on top of Flutter
version: 0.0.15
author: Flutter Authors <flutter-dev@googlegroups.com>
homepage: http://flutter.io
dependencies:
box2d: '>=0.3.0 <0.4.0'
flutter:
path: ../flutter
dev_dependencies:
flutter_test:
path: ../flutter_test
packages/flutter_sprites/test/action_test.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
import 'dart:ui';
import 'package:flutter_sprites/flutter_sprites.dart';
import 'package:test/test.dart';
const double epsilon = 0.01;
void main() {
test("Actions - ActionTween", () {
// Tween doubles.
double doubleValue;
ActionTween tween = new ActionTween((double a) => doubleValue = a, 0.0, 10.0, 60.0);
tween.update(0.0);
expect(doubleValue, closeTo(0.0, epsilon));
tween.update(0.1);
expect(doubleValue, closeTo(1.0, epsilon));
tween.update(0.5);
expect(doubleValue, closeTo(5.0, epsilon));
tween.update(1.0);
expect(doubleValue, closeTo(10.0, epsilon));
tween.update(1.5);
expect(doubleValue, closeTo(15.0, epsilon));
tween.update(-0.5);
expect(doubleValue, closeTo(-5.0, epsilon));
// Tween Points.
Point pointValue;
tween = new ActionTween((Point a) => pointValue = a, Point.origin, new Point(10.0, 20.0), 60.0);
tween.update(0.0);
expect(pointValue.x, closeTo(0.0, epsilon));
expect(pointValue.y, closeTo(0.0, epsilon));
tween.update(0.1);
expect(pointValue.x, closeTo(1.0, epsilon));
expect(pointValue.y, closeTo(2.0, epsilon));
tween.update(0.5);
expect(pointValue.x, closeTo(5.0, epsilon));
expect(pointValue.y, closeTo(10.0, epsilon));
tween.update(1.0);
expect(pointValue.x, closeTo(10.0, epsilon));
expect(pointValue.y, closeTo(20.0, epsilon));
tween.update(1.5);
expect(pointValue.x, closeTo(15.0, epsilon));
expect(pointValue.y, closeTo(30.0, epsilon));
tween.update(-0.5);
expect(pointValue.x, closeTo(-5.0, epsilon));
expect(pointValue.y, closeTo(-10.0, epsilon));
// Tween Colors.
Color colorValue;
tween = new ActionTween((Color a) => colorValue = a, const Color(0xff000000), const Color(0xffffffff), 60.0);
tween.update(0.0);
expect(colorValue, equals(const Color(0xff000000)));
tween.update(0.5);
expect(colorValue, equals(const Color(0xff7f7f7f)));
tween.update(1.0);
expect(colorValue, equals(const Color(0xffffffff)));
tween.update(-0.5);
expect(colorValue, equals(const Color(0xff000000)));
tween.update(1.5);
expect(colorValue, equals(const Color(0xffffffff)));
// Tween Size.
Size sizeValue;
tween = new ActionTween((Size a) => sizeValue = a, Size.zero, const Size(200.0, 100.0), 60.0);
tween.update(0.0);
expect(sizeValue, equals(Size.zero));
tween.update(1.0);
expect(sizeValue, equals(const Size(200.0, 100.0)));
tween.update(0.5);
expect(sizeValue.width, closeTo(100.0, epsilon));
expect(sizeValue.height, closeTo(50.0, epsilon));
// Tween Rect.
Rect rectValue;
tween = new ActionTween(
(Rect a) => rectValue = a,
new Rect.fromLTWH(0.0, 0.0, 100.0, 100.0),
new Rect.fromLTWH(100.0, 100.0, 200.0, 200.0),
60.0
);
tween.update(0.0);
expect(rectValue, equals(new Rect.fromLTWH(0.0, 0.0, 100.0, 100.0)));
tween.update(1.0);
expect(rectValue, equals(new Rect.fromLTWH(100.0, 100.0, 200.0, 200.0)));
tween.update(0.5);
expect(rectValue.left, closeTo(50.0, epsilon));
expect(rectValue.top, closeTo(50.0, epsilon));
expect(rectValue.width, closeTo(150.0, epsilon));
expect(rectValue.height, closeTo(150.0, epsilon));
});
test("Actions - ActionRepeat", () {
double doubleValue;
ActionTween tween = new ActionTween((double a) => doubleValue = a, 0.0, 1.0, 60.0);
ActionRepeat repeat2x = new ActionRepeat(tween, 2);
expect(repeat2x.duration, closeTo(120.0, epsilon));
repeat2x.update(0.0);
expect(doubleValue, closeTo(0.0, epsilon));
repeat2x.update(0.25);
expect(doubleValue, closeTo(0.5, epsilon));
repeat2x.update(0.75);
expect(doubleValue, closeTo(0.5, epsilon));
repeat2x.update(1.0);
expect(doubleValue, closeTo(1.0, epsilon));
ActionRepeat repeat4x = new ActionRepeat(tween, 4);
expect(repeat4x.duration, closeTo(240.0, epsilon));
repeat4x.update(0.0);
expect(doubleValue, closeTo(0.0, epsilon));
repeat4x.update(0.125);
expect(doubleValue, closeTo(0.5, epsilon));
repeat4x.update(0.875);
expect(doubleValue, closeTo(0.5, epsilon));
repeat4x.update(1.0);
expect(doubleValue, closeTo(1.0, epsilon));
});
test("Actions - ActionGroup", () {
double value0;
double value1;
ActionTween tween0 = new ActionTween((double a) => value0 = a, 0.0, 1.0, 10.0);
ActionTween tween1 = new ActionTween((double a) => value1 = a, 0.0, 1.0, 20.0);
ActionGroup group = new ActionGroup(<ActionTween>[tween0, tween1]);
expect(group.duration, closeTo(20.0, epsilon));
group.update(0.0);
expect(value0, closeTo(0.0, epsilon));
expect(value1, closeTo(0.0, epsilon));
group.update(0.5);
expect(value0, closeTo(1.0, epsilon));
expect(value1, closeTo(0.5, epsilon));
group.update(1.0);
expect(value0, closeTo(1.0, epsilon));
expect(value1, closeTo(1.0, epsilon));
});
test("Actions - ActionSequence", () {
double doubleValue;
ActionTween tween0 = new ActionTween((double a) => doubleValue = a, 0.0, 1.0, 4.0);
ActionTween tween1 = new ActionTween((double a) => doubleValue = a, 1.0, 0.0, 12.0);
ActionSequence sequence = new ActionSequence(<ActionTween>[tween0, tween1]);
expect(sequence.duration, closeTo(16.0, epsilon));
sequence.update(0.0);
expect(doubleValue, closeTo(0.0, epsilon));
sequence.update(0.125);
expect(doubleValue, closeTo(0.5, epsilon));
sequence.update(0.25);
expect(doubleValue, closeTo(1.0, epsilon));
sequence.update(1.0);
expect(doubleValue, closeTo(0.0, epsilon));
});
test("Actions - stepping", () {
double doubleValue;
ActionTween tween = new ActionTween((double a) => doubleValue = a, 0.0, 1.0, 60.0);
tween.step(0.0);
expect(doubleValue, closeTo(0.0, epsilon));
tween.step(30.0);
expect(doubleValue, closeTo(0.5, epsilon));
tween.step(30.0);
expect(doubleValue, closeTo(1.0, epsilon));
});
}
packages/flutter_sprites/test/color_sequence_test.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
import 'dart:ui';
import 'package:flutter_sprites/flutter_sprites.dart';
import 'package:test/test.dart';
void main() {
test("Simple test of ColorSequence", () {
List<Color> colors = <Color>[const Color(0xFFFFFFFF), const Color(0x000000FF)];
List<double> stops = <double>[0.0, 1.0];
ColorSequence cs = new ColorSequence(colors, stops);
expect(cs.colorAtPosition(0.0), equals(const Color(0xFFFFFFFF)));
expect(cs.colorAtPosition(0.5), equals(const Color(0x7F7F7FFF)));
expect(cs.colorAtPosition(1.0), equals(const Color(0x000000FF)));
});
}
packages/flutter_sprites/test/constraint_test.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
import 'dart:ui';
import 'package:flutter_sprites/flutter_sprites.dart';
import 'package:test/test.dart';
const double epsilon = 0.01;
void main() {
test("Constraints - ConstraintPositionToNode", () {
Node parent = new Node();
Node node0 = new Node();
Node node1 = new Node();
parent.addChild(node0);
parent.addChild(node1);
node1.constraints = <Constraint>[(new ConstraintPositionToNode(node0))];
node0.position = const Point(100.0, 50.0);
node1.applyConstraints(0.1);
expect(node1.position.x, closeTo(100.0, epsilon));
expect(node1.position.y, closeTo(50.0, epsilon));
});
test("Constraints - ConstraintRotationToNode", () {
Node parent = new Node();
Node node0 = new Node();
Node node1 = new Node()..position = const Point(0.0, 100.0);
parent.addChild(node0);
parent.addChild(node1);
node1.constraints = <Constraint>[(new ConstraintRotationToNode(node0))];
node1.applyConstraints(0.1);
expect(node1.rotation, closeTo(-90.0, epsilon));
});
test("Constraints - ConstraintRotationToNodeRotation", () {
Node parent = new Node();
Node node0 = new Node();
Node node1 = new Node();
parent.addChild(node0);
parent.addChild(node1);
node1.constraints = <Constraint>[(new ConstraintRotationToNodeRotation(node0, baseRotation: 10.0))];
node0.rotation = 90.0;
node1.applyConstraints(0.1);
expect(node1.rotation, closeTo(100.0, epsilon));
});
test("Constraints - ConstraintRotationToMovement", () {
Node parent = new Node();
Node node0 = new Node();
parent.addChild(node0);
Constraint constraint = new ConstraintRotationToMovement();
node0.constraints = <Constraint>[constraint];
node0.position = const Point(0.0, 0.0);
constraint.preUpdate(node0, 0.1);
node0.position = const Point(0.0, 100.0);
node0.applyConstraints(0.1);
expect(node0.rotation, closeTo(90.0, epsilon));
});
}
packages/flutter_sprites/test/image_map_test.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
import 'dart:async';
import 'dart:convert' show BASE64;
import 'dart:typed_data';
import 'dart:ui' as ui show Image;
import 'package:flutter/services.dart';
import 'package:flutter_sprites/flutter_sprites.dart';
import 'package:mojo/core.dart' as mojo;
import 'package:test/test.dart';
const String kTestManifest = '''
{
"assets/image1.png" : [],
"assets/image2.png" : [],
"assets/image3.png" : []
}
''';
// Base64 encoding of a 1x1 pixel png image.
const String kTestImageBase64 =
'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABAQMAAAAl21bKAAAAA1BMVEUAAACnej3aAAAAAXRSTlMAQObYZgAAAApJREFUCNdjYAAAAAIAAeIhvDMAAAAASUVORK5CYII=';
class TestAssetBundle extends CachingAssetBundle {
@override
Future<mojo.MojoDataPipeConsumer> load(String key) {
mojo.MojoDataPipe dataPipe = new mojo.MojoDataPipe();
final Uint8List bytes =
new Uint8List.fromList(BASE64.decode(kTestImageBase64));
int numBytesWritten = dataPipe.producer.write(bytes.buffer.asByteData());
expect(numBytesWritten, equals(bytes.lengthInBytes));
dataPipe.producer.handle.close();
return new Future<mojo.MojoDataPipeConsumer>.value(dataPipe.consumer);
}
@override
Future<String> loadString(String key, {bool cache: true}) {
if (key == 'AssetManifest.json')
return new Future<String>.value(kTestManifest);
return null;
}
@override
String toString() => '$runtimeType@$hashCode()';
}
final TestAssetBundle _bundle = new TestAssetBundle();
void main() {
test('ImageMap Smoke Test', () async {
ImageMap imageMap = new ImageMap(_bundle);
final List<String> urls = <String>[
'assets/image1.png',
'assets/image2.png',
'assets/image3.png',
];
urls.forEach((String url) {
expect(imageMap.getImage(url), isNull);
});
List<ui.Image> loadedImages = await imageMap.load(urls);
expect(loadedImages.length, equals(urls.length));
urls.forEach((String url) {
expect(imageMap.getImage(url), isNotNull);
});
});
}
packages/flutter_sprites/test/node_test.dart deleted 100644 → 0
View file @ b7af062a
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
import 'dart:ui';
import 'package:flutter_test/flutter_test.dart';
import 'package:flutter_sprites/flutter_sprites.dart';
void main() {
test("Node - adding and removing children", () {
// Create root node.
NodeWithSize rootNode = new NodeWithSize(const Size(1024.0, 1024.0));
expect(rootNode.spriteBox, isNull);
expect(rootNode.children.length, equals(0));
// Create children.
Node child0 = new Node();
Node child1 = new Node();
expect(child0.parent, isNull);
expect(child1.parent, isNull);
expect(child0.spriteBox, isNull);
expect(child1.spriteBox, isNull);
// Create sprite box.
SpriteBox spriteBox = new SpriteBox(rootNode);
expect(rootNode.spriteBox, equals(spriteBox));
// Add children.
rootNode.addChild(child0);
rootNode.addChild(child1);
expect(child0, isIn(rootNode.children));
expect(child1, isIn(rootNode.children));
expect(rootNode.children.length, equals(2));
expect(child0.parent, equals(rootNode));
expect(child1.parent, equals(rootNode));
expect(child0.spriteBox, equals(spriteBox));
expect(child1.spriteBox, equals(spriteBox));
// Remove one of the children.
rootNode.removeChild(child0);
expect(child1, isIn(rootNode.children));
expect(child1.parent, equals(rootNode));
expect(rootNode.children.length, equals(1));
expect(child0.parent, isNull);
expect(child0.spriteBox, isNull);
// Add a child back in.
rootNode.addChild(child0);
expect(child0, isIn(rootNode.children));
expect(child1, isIn(rootNode.children));
expect(rootNode.children.length, equals(2));
expect(child0.parent, equals(rootNode));
expect(child1.parent, equals(rootNode));
expect(child0.spriteBox, equals(spriteBox));
expect(child1.spriteBox, equals(spriteBox));
// Remove all children.
rootNode.removeAllChildren();
expect(rootNode.children.length, equals(0));
expect(child0.parent, isNull);
expect(child1.parent, isNull);
expect(child0.spriteBox, isNull);
expect(child1.spriteBox, isNull);
});
testWidgets("Node - transformations", (WidgetTester tester) async {
const double epsilon = 0.01;
NodeWithSize rootNode = new NodeWithSize(const Size(1024.0, 1024.0));
await tester.pumpWidget(new SpriteWidget(rootNode));
// Translations and transformations adding up correctly.
Node child0 = new Node();
child0.position = const Point(100.0, 0.0);
rootNode.addChild(child0);
Node child1 = new Node();
child1.position = const Point(200.0, 0.0);
child0.addChild(child1);
Point rootPoint = rootNode.convertPointFromNode(Point.origin, child1);
expect(rootPoint.x, closeTo(300.0, epsilon));
expect(rootPoint.y, closeTo(0.0, epsilon));
// Rotations.
Node rotatedChild = new Node();
rotatedChild.rotation = 90.0;
rootNode.addChild(rotatedChild);
rootPoint = rootNode.convertPointFromNode(const Point(1.0, 0.0), rotatedChild);
expect(rootPoint.x, closeTo(0.0, epsilon));
expect(rootPoint.y, closeTo(1.0, epsilon));
// Scale.
Node scaledChild = new Node();
scaledChild.scale = 2.0;
rootNode.addChild(scaledChild);
rootPoint = rootNode.convertPointFromNode(const Point(1.0, 1.0), scaledChild);
expect(rootPoint.x, closeTo(2.0, epsilon));
expect(rootPoint.y, closeTo(2.0, epsilon));
// Scale x-axis only.
Node scaledXChild = new Node();
scaledXChild.scaleX = 2.0;
rootNode.addChild(scaledXChild);
rootPoint = rootNode.convertPointFromNode(const Point(1.0, 1.0), scaledXChild);
expect(rootPoint.x, closeTo(2.0, epsilon));
expect(rootPoint.y, closeTo(1.0, epsilon));
// Scale y-axis only.
Node scaledYChild = new Node();
scaledYChild.scaleY = 2.0;
rootNode.addChild(scaledYChild);
rootPoint = rootNode.convertPointFromNode(const Point(1.0, 1.0), scaledYChild);
expect(rootPoint.x, closeTo(1.0, epsilon));
expect(rootPoint.y, closeTo(2.0, epsilon));
// Skew x-axis.
Node skewedXChild = new Node();
skewedXChild.skewX = 45.0;
rootNode.addChild(skewedXChild);
rootPoint = rootNode.convertPointFromNode(const Point(1.0, 1.0), skewedXChild);
expect(rootPoint.x, closeTo(1.0, epsilon));
expect(rootPoint.y, closeTo(2.0, epsilon));
// Skew y-axis.
Node skewedYChild = new Node();
skewedYChild.skewY = 45.0;
rootNode.addChild(skewedYChild);
rootPoint = rootNode.convertPointFromNode(const Point(1.0, 1.0), skewedYChild);
expect(rootPoint.x, closeTo(2.0, epsilon));
expect(rootPoint.y, closeTo(1.0, epsilon));
});
test("Node - zOrder", () {
// Ensure zOrder takes president over order added.
{
Node rootNode = new Node();
Node node0 = new Node();
Node node1 = new Node();
Node node2 = new Node()..zPosition = 1.0;
Node node3 = new Node()..zPosition = 1.0;
rootNode.addChild(node0);
rootNode.addChild(node2);
rootNode.addChild(node1);
rootNode.addChild(node3);
expect(rootNode.children[0], equals(node0));
expect(rootNode.children[1], equals(node1));
expect(rootNode.children[2], equals(node2));
expect(rootNode.children[3], equals(node3));
}
// Test negative zOrder.
{
Node rootNode = new Node();
Node node0 = new Node()..zPosition = -1.0;
Node node1 = new Node();
Node node2 = new Node()..zPosition = 1.0;
rootNode.addChild(node2);
rootNode.addChild(node1);
rootNode.addChild(node0);
expect(rootNode.children[0], equals(node0));
expect(rootNode.children[1], equals(node1));
expect(rootNode.children[2], equals(node2));
}
});
test("Node - isPointInside", () {
Node node = new Node();
expect(node.isPointInside(Point.origin), equals(false));
NodeWithSize nodeWithSize = new NodeWithSize(const Size(10.0, 10.0));
nodeWithSize.pivot = Point.origin;
expect(nodeWithSize.isPointInside(const Point(1.0, 1.0)), isTrue);
expect(nodeWithSize.isPointInside(const Point(9.0, 9.0)), isTrue);
expect(nodeWithSize.isPointInside(const Point(11.0, 1.0)), isFalse);
expect(nodeWithSize.isPointInside(const Point(-1.0, -1.0)), isFalse);
nodeWithSize.pivot = const Point(0.5, 0.5);
expect(nodeWithSize.isPointInside(const Point(1.0, 1.0)), isTrue);
expect(nodeWithSize.isPointInside(const Point(9.0, 9.0)), isFalse);
expect(nodeWithSize.isPointInside(const Point(11.0, 1.0)), isFalse);
expect(nodeWithSize.isPointInside(const Point(-1.0, -1.0)), isTrue);
});
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment

HIAST - GitLab