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
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
|
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrAtlasTextBatch_DEFINED
#define GrAtlasTextBatch_DEFINED
#include "batches/GrVertexBatch.h"
#include "text/GrAtlasTextContext.h"
#include "text/GrDistanceFieldAdjustTable.h"
class GrAtlasTextBatch : public GrVertexBatch {
public:
DEFINE_BATCH_CLASS_ID
static const int kVerticesPerGlyph = GrAtlasTextBlob::kVerticesPerGlyph;
static const int kIndicesPerGlyph = 6;
typedef GrAtlasTextBlob Blob;
typedef Blob::Run Run;
typedef Run::SubRunInfo TextInfo;
struct Geometry {
Blob* fBlob;
int fRun;
int fSubRun;
GrColor fColor;
SkScalar fTransX;
SkScalar fTransY;
};
static GrAtlasTextBatch* CreateBitmap(GrMaskFormat maskFormat, int glyphCount,
GrBatchFontCache* fontCache) {
GrAtlasTextBatch* batch = new GrAtlasTextBatch;
batch->fFontCache = fontCache;
switch (maskFormat) {
case kA8_GrMaskFormat:
batch->fMaskType = kGrayscaleCoverageMask_MaskType;
break;
case kA565_GrMaskFormat:
batch->fMaskType = kLCDCoverageMask_MaskType;
break;
case kARGB_GrMaskFormat:
batch->fMaskType = kColorBitmapMask_MaskType;
break;
}
batch->fBatch.fNumGlyphs = glyphCount;
batch->fGeoCount = 1;
batch->fFilteredColor = 0;
batch->fFontCache = fontCache;
batch->fUseBGR = false;
return batch;
}
static GrAtlasTextBatch* CreateDistanceField(
int glyphCount, GrBatchFontCache* fontCache,
const GrDistanceFieldAdjustTable* distanceAdjustTable,
SkColor filteredColor, bool isLCD,
bool useBGR) {
GrAtlasTextBatch* batch = new GrAtlasTextBatch;
batch->fFontCache = fontCache;
batch->fMaskType = isLCD ? kLCDDistanceField_MaskType : kGrayscaleDistanceField_MaskType;
batch->fDistanceAdjustTable.reset(SkRef(distanceAdjustTable));
batch->fFilteredColor = filteredColor;
batch->fUseBGR = useBGR;
batch->fBatch.fNumGlyphs = glyphCount;
batch->fGeoCount = 1;
return batch;
}
// to avoid even the initial copy of the struct, we have a getter for the first item which
// is used to seed the batch with its initial geometry. After seeding, the client should call
// init() so the Batch can initialize itself
Geometry& geometry() { return fGeoData[0]; }
void init() {
const Geometry& geo = fGeoData[0];
fBatch.fColor = geo.fColor;
fBatch.fViewMatrix = geo.fBlob->viewMatrix();
geo.fBlob->computeSubRunBounds(&fBounds, geo.fRun, geo.fSubRun);
}
const char* name() const override { return "TextBatch"; }
SkString dumpInfo() const override;
protected:
void computePipelineOptimizations(GrInitInvariantOutput* color,
GrInitInvariantOutput* coverage,
GrBatchToXPOverrides* overrides) const override;
private:
void initBatchTracker(const GrXPOverridesForBatch& overrides) override;
struct FlushInfo {
SkAutoTUnref<const GrVertexBuffer> fVertexBuffer;
SkAutoTUnref<const GrIndexBuffer> fIndexBuffer;
int fGlyphsToFlush;
int fVertexOffset;
};
void onPrepareDraws(Target* target) const override;
GrAtlasTextBatch() : INHERITED(ClassID()) {} // initialized in factory functions.
~GrAtlasTextBatch() {
for (int i = 0; i < fGeoCount; i++) {
fGeoData[i].fBlob->unref();
}
}
GrMaskFormat maskFormat() const {
switch (fMaskType) {
case kLCDCoverageMask_MaskType:
return kA565_GrMaskFormat;
case kColorBitmapMask_MaskType:
return kARGB_GrMaskFormat;
case kGrayscaleCoverageMask_MaskType:
case kGrayscaleDistanceField_MaskType:
case kLCDDistanceField_MaskType:
return kA8_GrMaskFormat;
}
return kA8_GrMaskFormat; // suppress warning
}
bool usesDistanceFields() const {
return kGrayscaleDistanceField_MaskType == fMaskType ||
kLCDDistanceField_MaskType == fMaskType;
}
bool isLCD() const {
return kLCDCoverageMask_MaskType == fMaskType ||
kLCDDistanceField_MaskType == fMaskType;
}
template <bool regenTexCoords, bool regenPos, bool regenCol, bool regenGlyphs>
inline void regenBlob(Target* target, FlushInfo* flushInfo, Blob* blob, Run* run,
TextInfo* info, SkGlyphCache** cache,
SkTypeface** typeface, GrFontScaler** scaler, const SkDescriptor** desc,
const GrGeometryProcessor* gp, int glyphCount, size_t vertexStride,
GrColor color, SkScalar transX, SkScalar transY) const;
inline void flush(GrVertexBatch::Target* target, FlushInfo* flushInfo) const;
GrColor color() const { return fBatch.fColor; }
const SkMatrix& viewMatrix() const { return fBatch.fViewMatrix; }
bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
int numGlyphs() const { return fBatch.fNumGlyphs; }
bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override;
// TODO just use class params
// TODO trying to figure out why lcd is so whack
GrGeometryProcessor* setupDfProcessor(const SkMatrix& viewMatrix, SkColor filteredColor,
GrColor color, GrTexture* texture) const;
struct BatchTracker {
GrColor fColor;
SkMatrix fViewMatrix;
bool fUsesLocalCoords;
bool fColorIgnored;
bool fCoverageIgnored;
int fNumGlyphs;
};
BatchTracker fBatch;
// The minimum number of Geometry we will try to allocate.
enum { kMinGeometryAllocated = 4 };
SkAutoSTMalloc<kMinGeometryAllocated, Geometry> fGeoData;
int fGeoCount;
enum MaskType {
kGrayscaleCoverageMask_MaskType,
kLCDCoverageMask_MaskType,
kColorBitmapMask_MaskType,
kGrayscaleDistanceField_MaskType,
kLCDDistanceField_MaskType,
} fMaskType;
bool fUseBGR; // fold this into the enum?
GrBatchFontCache* fFontCache;
// Distance field properties
SkAutoTUnref<const GrDistanceFieldAdjustTable> fDistanceAdjustTable;
SkColor fFilteredColor;
typedef GrVertexBatch INHERITED;
};
#endif
|
