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
|
#pragma once
#include <mbgl/gfx/attribute.hpp>
#include <mbgl/gl/types.hpp>
#include <mbgl/util/ignore.hpp>
#include <mbgl/util/indexed_tuple.hpp>
#include <mbgl/util/optional.hpp>
#include <cstddef>
#include <vector>
#include <set>
#include <functional>
#include <string>
#include <array>
#include <limits>
namespace mbgl {
namespace gl {
using AttributeBindingArray = std::vector<optional<gfx::AttributeBinding>>;
class Context;
void bindAttributeLocation(Context&, ProgramID, AttributeLocation, const char * name);
std::set<std::string> getActiveAttributes(ProgramID);
template <class>
class Attributes;
template <class... As>
class Attributes<TypeList<As...>> final {
public:
using Locations = IndexedTuple<
TypeList<As...>,
TypeList<ExpandToType<As, optional<AttributeLocation>>...>>;
using NamedLocations = std::vector<std::pair<const std::string, AttributeLocation>>;
static Locations bindLocations(Context& context, const ProgramID& id) {
std::set<std::string> activeAttributes = getActiveAttributes(id);
AttributeLocation location = 0;
auto maybeBindLocation = [&](const char* name) -> optional<AttributeLocation> {
if (activeAttributes.count(name)) {
bindAttributeLocation(context, id, location, name);
return location++;
} else {
return {};
}
};
return Locations { maybeBindLocation(As::name())... };
}
template <class Program>
static Locations loadNamedLocations(const Program& program) {
return Locations{ program.attributeLocation(As::name())... };
}
static NamedLocations getNamedLocations(const Locations& locations) {
NamedLocations result;
auto maybeAddLocation = [&] (const std::string& name, const optional<AttributeLocation>& location) {
if (location) {
result.emplace_back(name, *location);
}
};
util::ignore({ (maybeAddLocation(As::name(), locations.template get<As>()), 0)... });
return result;
}
static AttributeBindingArray
toBindingArray(const Locations& locations,
const typename gfx::Attributes<TypeList<As...>>::Bindings& bindings) {
AttributeBindingArray result;
result.resize(sizeof...(As));
auto maybeAddBinding = [&] (const optional<AttributeLocation>& location,
const optional<gfx::AttributeBinding>& binding) {
if (location) {
result.at(*location) = binding;
}
};
util::ignore({ (maybeAddBinding(locations.template get<As>(), bindings.template get<As>()), 0)... });
return result;
}
};
} // namespace gl
} // namespace mbgl
|
