-
-
Notifications
You must be signed in to change notification settings - Fork 879
/
renderable_layer.dart
151 lines (126 loc) · 4.17 KB
/
renderable_layer.dart
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
import 'package:flame/extensions.dart';
import 'package:flame/game.dart';
import 'package:flame_tiled/src/renderable_layers/group_layer.dart';
import 'package:flame_tiled/src/renderable_layers/image_layer.dart';
import 'package:flame_tiled/src/renderable_layers/object_layer.dart';
import 'package:flame_tiled/src/renderable_layers/tile_layers/tile_layer.dart';
import 'package:flame_tiled/src/tile_animation.dart';
import 'package:flame_tiled/src/tile_atlas.dart';
import 'package:meta/meta.dart';
import 'package:tiled/tiled.dart';
@internal
abstract class RenderableLayer<T extends Layer> {
final T layer;
final Vector2 destTileSize;
final TiledMap map;
/// The parent [Group] layer (if it exists)
final GroupLayer? parent;
RenderableLayer({
required this.layer,
required this.parent,
required this.map,
required this.destTileSize,
});
/// [load] is a factory method to create [RenderableLayer] by type of [layer].
static Future<RenderableLayer> load({
required Layer layer,
required GroupLayer? parent,
required TiledMap map,
required Vector2 destTileSize,
required Camera? camera,
required Map<Tile, TileFrames> animationFrames,
required TiledAtlas atlas,
bool? ignoreFlip,
}) async {
if (layer is TileLayer) {
return FlameTileLayer.load(
layer: layer,
parent: parent,
map: map,
destTileSize: destTileSize,
animationFrames: animationFrames,
atlas: atlas.clone(),
ignoreFlip: ignoreFlip,
);
} else if (layer is ImageLayer) {
return FlameImageLayer.load(
layer: layer,
parent: parent,
camera: camera,
map: map,
destTileSize: destTileSize,
);
} else if (layer is ObjectGroup) {
return ObjectLayer.load(
layer,
map,
destTileSize,
);
} else if (layer is Group) {
final groupLayer = layer;
return GroupLayer(
layer: groupLayer,
parent: parent,
map: map,
destTileSize: destTileSize,
);
}
return UnsupportedLayer(
layer: layer,
parent: parent,
map: map,
destTileSize: destTileSize,
);
}
bool get visible => layer.visible;
void render(Canvas canvas, Camera? camera);
void handleResize(Vector2 canvasSize);
void refreshCache();
void update(double dt);
double get scaleX => destTileSize.x / map.tileWidth;
double get scaleY => destTileSize.y / map.tileHeight;
late double offsetX = layer.offsetX * scaleX + (parent?.offsetX ?? 0);
late double offsetY = layer.offsetY * scaleY + (parent?.offsetY ?? 0);
late double opacity = layer.opacity * (parent?.opacity ?? 1);
late double parallaxX = layer.parallaxX * (parent?.parallaxX ?? 1);
late double parallaxY = layer.parallaxY * (parent?.parallaxY ?? 1);
/// Calculates the offset we need to apply to the canvas to compensate for
/// parallax positioning and scroll for the layer and the current camera
/// position
/// https://doc.mapeditor.org/en/latest/manual/layers/#parallax-scrolling-factor
void applyParallaxOffset(Canvas canvas, Camera camera) {
final cameraX = camera.position.x;
final cameraY = camera.position.y;
final vpCenterX = camera.viewport.effectiveSize.x / 2;
final vpCenterY = camera.viewport.effectiveSize.y / 2;
// Due to how Tiled treats the center of the view as the reference
// point for parallax positioning (see Tiled docs), we need to offset the
// entire layer
var x = (1 - parallaxX) * vpCenterX;
var y = (1 - parallaxY) * vpCenterY;
// compensate the offset for zoom
x /= camera.zoom;
y /= camera.zoom;
// Now add the scroll for the current camera position
x += cameraX - (cameraX * parallaxX);
y += cameraY - (cameraY * parallaxY);
canvas.translate(x, y);
}
}
@internal
class UnsupportedLayer extends RenderableLayer {
UnsupportedLayer({
required super.layer,
required super.parent,
required super.map,
required super.destTileSize,
});
@override
void render(Canvas canvas, Camera? camera) {}
@override
void handleResize(Vector2 canvasSize) {}
@override
void refreshCache() {}
@override
void update(double dt) {}
}