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
|
#include <mbgl/renderer/layers/render_background_layer.hpp>
#include <mbgl/style/layers/background_layer_impl.hpp>
#include <mbgl/renderer/bucket.hpp>
#include <mbgl/renderer/paint_parameters.hpp>
#include <mbgl/renderer/image_manager.hpp>
#include <mbgl/renderer/render_static_data.hpp>
#include <mbgl/programs/programs.hpp>
#include <mbgl/programs/background_program.hpp>
#include <mbgl/util/tile_cover.hpp>
#include <mbgl/map/transform_state.hpp>
namespace mbgl {
using namespace style;
RenderBackgroundLayer::RenderBackgroundLayer(Immutable<style::BackgroundLayer::Impl> _impl)
: RenderLayer(std::move(_impl)),
unevaluated(impl().paint.untransitioned()) {
}
const style::BackgroundLayer::Impl& RenderBackgroundLayer::impl() const {
return static_cast<const style::BackgroundLayer::Impl&>(*baseImpl);
}
void RenderBackgroundLayer::transition(const TransitionParameters ¶meters) {
unevaluated = impl().paint.transitioned(parameters, std::move(unevaluated));
}
void RenderBackgroundLayer::evaluate(const PropertyEvaluationParameters ¶meters) {
evaluated = unevaluated.evaluate(parameters);
crossfade = parameters.getCrossfadeParameters();
passes = evaluated.get<style::BackgroundOpacity>() > 0 ? RenderPass::Translucent
: RenderPass::None;
}
bool RenderBackgroundLayer::hasTransition() const {
return unevaluated.hasTransition();
}
bool RenderBackgroundLayer::hasCrossfade() const {
return crossfade.t != 1;
}
void RenderBackgroundLayer::render(PaintParameters& parameters, RenderSource*) {
// Note that for bottommost layers without a pattern, the background color is drawn with
// glClear rather than this method.
const Properties<>::PossiblyEvaluated properties;
const BackgroundProgram::PaintPropertyBinders paintAttributeData(properties, 0);
auto draw = [&](auto& program, auto&& uniformValues) {
const auto allUniformValues = program.computeAllUniformValues(
std::move(uniformValues),
paintAttributeData,
properties,
parameters.state.getZoom()
);
const auto allAttributeBindings = program.computeAllAttributeBindings(
parameters.staticData.tileVertexBuffer,
paintAttributeData,
properties
);
checkRenderability(parameters, program.activeBindingCount(allAttributeBindings));
program.draw(
parameters.context,
gl::Triangles(),
parameters.depthModeForSublayer(0, gl::DepthMode::ReadOnly),
gl::StencilMode::disabled(),
parameters.colorModeForRenderPass(),
gl::CullFaceMode::disabled(),
parameters.staticData.quadTriangleIndexBuffer,
parameters.staticData.tileTriangleSegments,
allUniformValues,
allAttributeBindings,
getID()
);
};
if (!evaluated.get<BackgroundPattern>().to.empty()) {
optional<ImagePosition> imagePosA = parameters.imageManager.getPattern(evaluated.get<BackgroundPattern>().from);
optional<ImagePosition> imagePosB = parameters.imageManager.getPattern(evaluated.get<BackgroundPattern>().to);
if (!imagePosA || !imagePosB)
return;
parameters.imageManager.bind(parameters.context, 0);
for (const auto& tileID : util::tileCover(parameters.state, parameters.state.getIntegerZoom())) {
draw(
parameters.programs.getBackgroundLayerPrograms().backgroundPattern,
BackgroundPatternProgram::uniformValues(
parameters.matrixForTile(tileID),
evaluated.get<BackgroundOpacity>(),
parameters.imageManager.getPixelSize(),
*imagePosA,
*imagePosB,
crossfade,
tileID,
parameters.state
)
);
}
} else {
for (const auto& tileID : util::tileCover(parameters.state, parameters.state.getIntegerZoom())) {
draw(
parameters.programs.getBackgroundLayerPrograms().background,
BackgroundProgram::UniformValues {
uniforms::u_matrix::Value( parameters.matrixForTile(tileID) ),
uniforms::u_color::Value( evaluated.get<BackgroundColor>() ),
uniforms::u_opacity::Value( evaluated.get<BackgroundOpacity>() ),
}
);
}
}
}
optional<Color> RenderBackgroundLayer::getSolidBackground() const {
if (!evaluated.get<BackgroundPattern>().from.empty()) {
return nullopt;
}
return { evaluated.get<BackgroundColor>() * evaluated.get<BackgroundOpacity>() };
}
} // namespace mbgl
|