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
158
159
160
161
162
163
164
165
166
167
168
169
170
|
#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 needs to be rendered in the given render pass.
bool hasRenderPass(RenderPass) 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;
virtual void render(PaintParameters&) = 0;
// 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();
virtual LayerUploader createUploader();
// Checks whether the current hardware can render this layer. If it can't, we'll show a warning
// in the console to inform the developer.
void checkRenderability(const PaintParameters&, uint32_t activeBindingCount);
protected:
// 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;
// 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.
bool hasRenderFailures = false;
};
} // namespace mbgl
|
