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
|
#pragma once
#include <mbgl/layout/layout.hpp>
#include <mbgl/renderer/render_pass.hpp>
#include <mbgl/style/layer_impl.hpp>
#include <mbgl/style/layer_type.hpp>
#include <mbgl/tile/geometry_tile_data.hpp>
#include <mbgl/util/mat4.hpp>
#include <memory>
#include <string>
namespace mbgl {
class Bucket;
class BucketParameters;
class TransitionParameters;
class PropertyEvaluationParameters;
class PaintParameters;
class RenderSource;
class RenderTile;
class TransformState;
class RenderLayer {
protected:
RenderLayer(style::LayerType, Immutable<style::Layer::Impl>);
const style::LayerType type;
public:
static std::unique_ptr<RenderLayer> create(Immutable<style::Layer::Impl>);
virtual ~RenderLayer() = default;
// Begin transitions for any properties that have changed since the last frame.
virtual void transition(const TransitionParameters&) = 0;
// Fully evaluate possibly-transitioning paint properties based on a zoom level.
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;
// Check whether this layer is of the given subtype.
template <class T>
bool is() const;
// Dynamically cast this layer to the given subtype.
template <class T>
T* as() {
return is<T>() ? reinterpret_cast<T*>(this) : nullptr;
}
template <class T>
const T* as() const {
return is<T>() ? reinterpret_cast<const T*>(this) : nullptr;
}
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(float zoom) const;
virtual void render(PaintParameters&, RenderSource*) = 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 std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const = 0;
virtual std::unique_ptr<Layout> createLayout(const BucketParameters&,
const std::vector<const RenderLayer*>&,
std::unique_ptr<GeometryTileLayer>,
GlyphDependencies&,
ImageDependencies&) const {
return nullptr;
}
using RenderTiles = std::vector<std::reference_wrapper<RenderTile>>;
void setRenderTiles(RenderTiles, const TransformState&);
// Private implementation
Immutable<style::Layer::Impl> baseImpl;
void setImpl(Immutable<style::Layer::Impl>);
virtual void markContextDestroyed();
// TODO: Figure out how to remove this or whether layers other than
// RenderHeatmapLayer and RenderLineLayer need paint property updates,
// similar to color ramp. Temporarily moved to the base.
virtual void update();
// TODO: Only for background layers.
virtual optional<Color> getSolidBackground() const;
friend std::string layoutKey(const RenderLayer&);
protected:
// 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);
// Code specific to RenderTiles sorting / filtering
virtual RenderTiles filterRenderTiles(RenderTiles) const;
virtual void sortRenderTiles(const TransformState&);
using FilterFunctionPtr = bool (*)(RenderTile&);
RenderTiles filterRenderTiles(RenderTiles, FilterFunctionPtr) const;
protected:
// renderTiles are exposed directly to CrossTileSymbolIndex and Placement so they
// can update opacities in the symbol buckets immediately before rendering
friend class CrossTileSymbolIndex;
friend class Placement;
// Stores current set of tiles to be rendered for this layer.
std::vector<std::reference_wrapper<RenderTile>> 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;
private:
// 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
|
