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
|
#pragma once
#include <mbgl/text/glyph.hpp>
#include <mbgl/text/glyph_set.hpp>
#include <mbgl/geometry/binpack.hpp>
#include <mbgl/util/noncopyable.hpp>
#include <mbgl/util/optional.hpp>
#include <mbgl/util/font_stack.hpp>
#include <mbgl/util/exclusive.hpp>
#include <mbgl/util/work_queue.hpp>
#include <mbgl/util/image.hpp>
#include <mbgl/gl/texture.hpp>
#include <mbgl/gl/object.hpp>
#include <atomic>
#include <string>
#include <unordered_set>
#include <unordered_map>
#include <mutex>
#include <exception>
#include <vector>
namespace mbgl {
class FileSource;
class GlyphPBF;
class GlyphAtlasObserver;
namespace gl {
class Context;
} // namespace gl
class GlyphAtlas : public util::noncopyable {
public:
GlyphAtlas(Size, FileSource&);
~GlyphAtlas();
util::exclusive<GlyphSet> getGlyphSet(const FontStack&);
// Returns true if the set of GlyphRanges are available and parsed or false
// if they are not. For the missing ranges, a request on the FileSource is
// made and when the glyph if finally parsed, it gets added to the respective
// GlyphSet and a signal is emitted to notify the observers. This method
// can be called from any thread.
bool hasGlyphRanges(const FontStack&, const GlyphRangeSet&);
void setURL(const std::string &url) {
glyphURL = url;
}
std::string getURL() const {
return glyphURL;
}
void setObserver(GlyphAtlasObserver* observer);
void addGlyphs(uintptr_t tileUID,
const std::u16string& text,
const FontStack&,
const GlyphSet&,
GlyphPositions&);
void removeGlyphs(uintptr_t tileUID);
// Binds the atlas texture to the GPU, and uploads data if it is out of date.
void bind(gl::Context&, gl::TextureUnit unit);
// Uploads the texture to the GPU to be available when we need it. This is a lazy operation;
// the texture is only bound when the data is out of date (=dirty).
void upload(gl::Context&, gl::TextureUnit unit);
Size getSize() const;
private:
void requestGlyphRange(const FontStack&, const GlyphRange&);
Rect<uint16_t> addGlyph(uintptr_t tileID,
const FontStack&,
const SDFGlyph&);
FileSource& fileSource;
std::string glyphURL;
std::unordered_map<FontStack, std::map<GlyphRange, std::unique_ptr<GlyphPBF>>, FontStackHash> ranges;
std::mutex rangesMutex;
std::unordered_map<FontStack, std::unique_ptr<GlyphSet>, FontStackHash> glyphSets;
std::mutex glyphSetsMutex;
util::WorkQueue workQueue;
GlyphAtlasObserver* observer = nullptr;
struct GlyphValue {
GlyphValue(Rect<uint16_t> rect_, uintptr_t id)
: rect(std::move(rect_)), ids({ id }) {}
Rect<uint16_t> rect;
std::unordered_set<uintptr_t> ids;
};
std::mutex mtx;
BinPack<uint16_t> bin;
std::unordered_map<FontStack, std::map<uint32_t, GlyphValue>, FontStackHash> index;
const AlphaImage image;
std::atomic<bool> dirty;
mbgl::optional<gl::Texture> texture;
};
} // namespace mbgl
|
