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
152
153
154
155
156
157
|
#pragma once
#include <mbgl/layout/layout.hpp>
#include <mbgl/renderer/render_pass.hpp>
#include <mbgl/renderer/render_tree.hpp>
#include <mbgl/style/layer_properties.hpp>
#include <mbgl/tile/geometry_tile_data.hpp>
#include <mbgl/util/mat4.hpp>
#include <functional>
#include <memory>
#include <string>
namespace mbgl {
class Bucket;
class TransitionParameters;
class PropertyEvaluationParameters;
class UploadParameters;
class PaintParameters;
class RenderSource;
class RenderTile;
class TransformState;
class PatternAtlas;
class LineAtlas;
class LayerRenderData {
public:
std::shared_ptr<Bucket> bucket;
Immutable<style::LayerProperties> layerProperties;
};
class LayerPlacementData {
public:
std::reference_wrapper<Bucket> bucket;
std::reference_wrapper<const RenderTile> tile;
std::shared_ptr<FeatureIndex> featureIndex;
};
class LayerPrepareParameters {
public:
RenderSource* source;
ImageManager& imageManager;
PatternAtlas& patternAtlas;
LineAtlas& lineAtlas;
const TransformState& state;
};
class LayerRenderItem;
using RenderTiles = std::vector<std::reference_wrapper<const RenderTile>>;
using LayerUploader = std::function<void(gfx::UploadPass&)>;
using LayerRenderer = std::function<void(PaintParameters&, const LayerRenderItem&)>;
class LayerRenderItem final : public RenderItem {
public:
LayerRenderItem(RenderTiles, LayerRenderer, LayerUploader, Immutable<style::LayerProperties>, RenderPass);
~LayerRenderItem();
RenderTiles renderTiles;
LayerRenderer renderer;
LayerUploader uploader;
Immutable<style::LayerProperties> evaluatedProperties;
void checkRenderability(const PaintParameters&, uint32_t activeBindingCount) const;
private:
bool hasRenderPass(RenderPass pass) const override { return bool(renderPass & pass); }
void upload(gfx::UploadPass& pass) const override { if (uploader) uploader(pass);}
void render(PaintParameters& parameters) const override {
assert(renderer);
renderer(parameters, *this);
}
const std::string& getName() const override { return evaluatedProperties->baseImpl->id; }
RenderPass renderPass;
// Some layers may not render correctly on some hardware when the vertex attribute limit of
// that GPU is exceeded. More attributes are used when adding many data driven paint properties
// to a layer.
mutable bool hasRenderFailures = false;
};
class RenderLayer {
protected:
RenderLayer(Immutable<style::LayerProperties>);
public:
virtual ~RenderLayer() = default;
LayerRenderItem createRenderItem();
// Begin transitions for any properties that have changed since the last frame.
virtual void transition(const TransitionParameters&) = 0;
// Overloaded version for transitions to a new layer impl.
void transition(const TransitionParameters&, Immutable<style::Layer::Impl> newImpl);
// Fully evaluate possibly-transitioning paint properties based on a zoom level.
// Updates the contained `evaluatedProperties` member.
virtual void evaluate(const PropertyEvaluationParameters&) = 0;
// Returns true if any paint properties have active transitions.
virtual bool hasTransition() const = 0;
// Returns true if the layer has a pattern property and is actively crossfading.
virtual bool hasCrossfade() const = 0;
// Returns true is the layer is subject to placement.
bool needsPlacement() const;
const std::string& getID() const;
// Checks whether this layer can be rendered.
bool needsRendering() const;
// Checks whether the given zoom is inside this layer zoom range.
bool supportsZoom(float zoom) const;
// Check wether the given geometry intersects
// with the feature
virtual bool queryIntersectsFeature(
const GeometryCoordinates&,
const GeometryTileFeature&,
const float,
const TransformState&,
const float,
const mat4&) const { return false; };
virtual void prepare(const LayerPrepareParameters&);
const std::vector<LayerPlacementData>& getPlacementData() const {
return placementData;
}
// Latest evaluated properties.
Immutable<style::LayerProperties> evaluatedProperties;
// Private implementation
Immutable<style::Layer::Impl> baseImpl;
virtual void markContextDestroyed();
// TODO: Only for background layers.
virtual optional<Color> getSolidBackground() const;
protected:
virtual LayerRenderer createRenderer() = 0;
virtual LayerUploader createUploader();
// Stores current set of tiles to be rendered for this layer.
RenderTiles renderTiles;
// Stores what render passes this layer is currently enabled for. This depends on the
// evaluated StyleProperties object and is updated accordingly.
RenderPass passes = RenderPass::None;
std::vector<LayerPlacementData> placementData;
private:
RenderTiles filterRenderTiles(RenderTiles) const;
};
} // namespace mbgl
|
