blob: 553730de24e2232f408ca06bfb3c7246594fd0e7 (
plain)
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
|
#pragma once
#include <list>
#include <mbgl/layout/layout.hpp>
#include <mbgl/renderer/render_pass.hpp>
#include <mbgl/renderer/render_source.hpp>
#include <mbgl/style/layer_properties.hpp>
#include <mbgl/tile/geometry_tile_data.hpp>
#include <mbgl/util/mat4.hpp>
#include <memory>
#include <string>
namespace mbgl {
class Bucket;
class TransitionParameters;
class PropertyEvaluationParameters;
class UploadParameters;
class PaintParameters;
class RenderTile;
class TransformState;
class PatternAtlas;
class LineAtlas;
class SymbolBucket;
class DynamicFeatureIndex;
class LayerRenderData {
public:
std::shared_ptr<Bucket> bucket;
Immutable<style::LayerProperties> layerProperties;
};
class SortKeyRange {
public:
bool isFirstRange() const { return start == 0u; }
float sortKey;
size_t start;
size_t end;
};
class BucketPlacementData {
public:
std::reference_wrapper<Bucket> bucket;
std::reference_wrapper<const RenderTile> tile;
std::shared_ptr<FeatureIndex> featureIndex;
std::string sourceId;
optional<SortKeyRange> sortKeyRange;
};
using LayerPlacementData = std::list<BucketPlacementData>;
class LayerPrepareParameters {
public:
RenderSource* source;
ImageManager& imageManager;
PatternAtlas& patternAtlas;
LineAtlas& lineAtlas;
const TransformState& state;
};
class RenderLayer {
protected:
RenderLayer(Immutable<style::LayerProperties>);
public:
virtual ~RenderLayer() = default;
// 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 if layer writes to depth buffer by drawing using PaintParameters::depthModeFor3D().
virtual bool is3D() const { return false; }
// 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 upload(gfx::UploadPass&) {}
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 FeatureState&) const {
return false;
};
virtual void populateDynamicRenderFeatureIndex(DynamicFeatureIndex&) const {}
virtual void prepare(const LayerPrepareParameters&);
const 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:
// 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);
void addRenderPassesFromTiles();
const LayerRenderData* getRenderDataForPass(const RenderTile&, RenderPass) const;
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;
LayerPlacementData placementData;
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;
};
using RenderLayerReferences = std::vector<std::reference_wrapper<RenderLayer>>;
} // namespace mbgl
|
