AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Move to using pointers in simplifyDraw*

Browse Source 
Move to using pointers into buffers. This will allow
multiple runs from blobs to share buffers.

Change-Id: I6ebed2e490c5fe71077ddc921ead145ce17c5ebd
Reviewed-on: https://skia-review.googlesource.com/141049
Commit-Queue: Herb Derby <herb@google.com>
Reviewed-by: Mike Klein <mtklein@google.com>
This commit is contained in:
Herb Derby 2018-07-11 16:07:01 -04:00 committed by Skia Commit-Bot
parent 04aa393045
commit c434ade20e
6 changed files with 79 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/core/SkCanvas.cpp
View File

@ -2429,7 +2429,7 @@ void SkCanvas::onDrawText(const void* text, size_t byteLength, SkScalar x, SkSca
LOOPER_BEGIN(paint, nullptr)
while (iter.next()) {
fScratchGlyphRunBuilder->prepareDrawText(
fScratchGlyphRunBuilder->drawText(
looper.paint(), text, byteLength, SkPoint::Make(x, y));
auto glyphRun = fScratchGlyphRunBuilder->useGlyphRun();
iter.fDevice->drawGlyphRun(looper.paint(), glyphRun);
@ -2444,7 +2444,7 @@ void SkCanvas::onDrawPosText(const void* text, size_t byteLength, const SkPoint
LOOPER_BEGIN(paint, nullptr)
while (iter.next()) {
fScratchGlyphRunBuilder->prepareDrawPosText(looper.paint(), text, byteLength, pos);
fScratchGlyphRunBuilder->drawPosText(looper.paint(), text, byteLength, pos);
auto glyphRun = fScratchGlyphRunBuilder->useGlyphRun();
iter.fDevice->drawGlyphRun(looper.paint(), glyphRun);
}
@ -2458,7 +2458,7 @@ void SkCanvas::onDrawPosTextH(const void* text, size_t byteLength, const SkScala
LOOPER_BEGIN(paint, nullptr)
while (iter.next()) {
fScratchGlyphRunBuilder->prepareDrawPosTextH(
fScratchGlyphRunBuilder->drawPosTextH(
looper.paint(), text, byteLength, xpos, constY);
const auto& glyphRun = fScratchGlyphRunBuilder->useGlyphRun();
iter.fDevice->drawGlyphRun(looper.paint(), glyphRun);

2
src/core/SkDevice.cpp
View File

@ -156,7 +156,7 @@ void SkBaseDevice::drawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
case SkTextBlob::kDefault_Positioning: {
auto origin = SkPoint::Make(x + offset.x(), y + offset.y());
SkGlyphRunBuilder builder;
builder.prepareDrawText(runPaint, (const char*) it.glyphs(), textLen, origin);
builder.drawText(runPaint, (const char*) it.glyphs(), textLen, origin);
auto glyphRun = builder.useGlyphRun();
glyphRun->temporaryShuntToDrawPosText(this);
}

93
src/core/SkGlyphRun.cpp
View File

@ -132,32 +132,34 @@ SkSpan<const SkGlyphID> SkGlyphIDSet::uniquifyGlyphIDs(
}
// -- SkGlyphRunBuilder ----------------------------------------------------------------------------
void SkGlyphRunBuilder::prepareDrawText(
void SkGlyphRunBuilder::drawText(
const SkPaint& paint, const void* bytes, size_t byteLength, SkPoint origin) {
auto glyphIDs = textToGlyphIDs(paint, bytes, byteLength);
if (!glyphIDs.empty()) {
this->initialize(glyphIDs.size());
this->drawText(paint, glyphIDs, origin, SkSpan<const char>(), SkSpan<const uint32_t>());
this->simplifyDrawText(
paint, glyphIDs, origin, fUniqueGlyphIDIndices, fUniqueGlyphIDs, fPositions);
}
}
void SkGlyphRunBuilder::prepareDrawPosTextH(const SkPaint& paint, const void* bytes,
size_t byteLength, const SkScalar* xpos,
SkScalar constY) {
void SkGlyphRunBuilder::drawPosTextH(const SkPaint& paint, const void* bytes,
size_t byteLength, const SkScalar* xpos,
SkScalar constY) {
auto glyphIDs = textToGlyphIDs(paint, bytes, byteLength);
if (!glyphIDs.empty()) {
this->initialize(glyphIDs.size());
this->drawPosTextH(
paint, glyphIDs, xpos, constY, SkSpan<const char>(), SkSpan<const uint32_t>());
this->simplifyDrawPosTextH(
paint, glyphIDs, xpos, constY, fUniqueGlyphIDIndices, fUniqueGlyphIDs, fPositions);
}
}
void SkGlyphRunBuilder::prepareDrawPosText(const SkPaint& paint, const void* bytes,
size_t byteLength, const SkPoint* pos) {
void SkGlyphRunBuilder::drawPosText(const SkPaint& paint, const void* bytes,
size_t byteLength, const SkPoint* pos) {
auto glyphIDs = textToGlyphIDs(paint, bytes, byteLength);
if (!glyphIDs.empty()) {
this->initialize(glyphIDs.size());
this->drawPosText(paint, glyphIDs, pos, SkSpan<const char>(), SkSpan<const uint32_t>());
this->simplifyDrawPosText(
paint, glyphIDs, pos, fUniqueGlyphIDIndices, fUniqueGlyphIDs);
}
}
@ -201,15 +203,18 @@ SkSpan<const SkGlyphID> SkGlyphRunBuilder::textToGlyphIDs(
SkSpan<const SkGlyphID> SkGlyphRunBuilder::addDenseAndUnique(
const SkPaint& paint,
SkSpan<const SkGlyphID> glyphIDs) {
SkSpan<const SkGlyphID> glyphIDs,
uint16_t* uniqueGlyphIDIndices,
SkGlyphID* uniqueGlyphIDs) {
SkSpan<const SkGlyphID> uniquifiedGlyphIDs;
if (!glyphIDs.empty()) {
auto typeface = SkPaintPriv::GetTypefaceOrDefault(paint);
auto glyphUniverseSize = typeface->countGlyphs();
// There better be glyphs in the font if we want to uniqify.
if (glyphUniverseSize > 0) {
uniquifiedGlyphIDs = fGlyphIDSet.uniquifyGlyphIDs(
glyphUniverseSize, glyphIDs, fUniqueGlyphIDs, fUniqueGlyphIDIndices);
glyphUniverseSize, glyphIDs, uniqueGlyphIDs, uniqueGlyphIDIndices);
}
}
@ -243,14 +248,17 @@ void SkGlyphRunBuilder::makeGlyphRun(
}
}
void SkGlyphRunBuilder::drawText(
void SkGlyphRunBuilder::simplifyDrawText(
const SkPaint& paint, SkSpan<const SkGlyphID> glyphIDs, SkPoint origin,
uint16_t* uniqueGlyphIDIndicesBuffer, SkGlyphID* uniqueGlyphIDsBuffer, SkPoint* positions,
SkSpan<const char> text, SkSpan<const uint32_t> clusters) {
SkASSERT(!glyphIDs.empty());
auto runSize = glyphIDs.size();
auto unqiueGlyphIDs = this->addDenseAndUnique(paint, glyphIDs);
auto unqiueGlyphIDs = this->addDenseAndUnique(
paint, glyphIDs, uniqueGlyphIDIndicesBuffer, uniqueGlyphIDsBuffer);
if (!unqiueGlyphIDs.empty()) {
fScratchAdvances.resize(runSize);
@ -262,7 +270,7 @@ void SkGlyphRunBuilder::drawText(
SkPoint endOfLastGlyph = origin;
for (size_t i = 0; i < runSize; i++) {
fPositions[i] = endOfLastGlyph;
positions[i] = endOfLastGlyph;
endOfLastGlyph += fScratchAdvances[fUniqueGlyphIDIndices[i]];
}
@ -271,16 +279,16 @@ void SkGlyphRunBuilder::drawText(
if (paint.getTextAlign() == SkPaint::kCenter_Align) {
len.scale(SK_ScalarHalf);
}
for (auto& pt : SkSpan<SkPoint>{fPositions, runSize}) {
for (auto& pt : SkSpan<SkPoint>{positions, runSize}) {
pt -= len;
}
}
}
this->makeGlyphRun(
paint,
glyphIDs,
SkSpan<const SkPoint>{fPositions, runSize},
SkSpan<const SkPoint>{positions, runSize},
SkSpan<const uint16_t>{fUniqueGlyphIDIndices, runSize},
unqiueGlyphIDs,
text,
@ -288,43 +296,34 @@ void SkGlyphRunBuilder::drawText(
}
}
void SkGlyphRunBuilder::drawPosTextH(const SkPaint& paint, SkSpan<const SkGlyphID> glyphIDs,
const SkScalar* xpos, SkScalar constY,
SkSpan<const char> text, SkSpan<const uint32_t> clusters) {
SkASSERT(!glyphIDs.empty());
auto runSize = glyphIDs.size();
void SkGlyphRunBuilder::simplifyDrawPosTextH(
const SkPaint& paint, SkSpan<const SkGlyphID> glyphIDs,
const SkScalar* xpos, SkScalar constY,
uint16_t* uniqueGlyphIDIndicesBuffer, SkGlyphID* uniqueGlyphIDsBuffer, SkPoint* positions,
SkSpan<const char> text, SkSpan<const uint32_t> clusters) {
// The dense indices are not used by the rest of the stack yet.
#ifdef SK_DEBUG
this->addDenseAndUnique(paint, glyphIDs);
#endif
// TODO: when using the unique glyph system have a guard that there are actually glyphs like
// drawText above.
auto posCursor = fPositions.get();
for (auto x : SkSpan<const SkScalar>{xpos, runSize}) {
auto posCursor = positions;
for (auto x : SkSpan<const SkScalar>{xpos, glyphIDs.size()}) {
*posCursor++ = SkPoint::Make(x, constY);
}
this->makeGlyphRun(
paint,
glyphIDs,
SkSpan<const SkPoint>{fPositions, runSize},
SkSpan<const uint16_t>{},
SkSpan<const SkGlyphID>{},
text,
clusters);
this->simplifyDrawPosText(
paint, glyphIDs, positions,
uniqueGlyphIDIndicesBuffer, uniqueGlyphIDsBuffer,
text, clusters);
}
void SkGlyphRunBuilder::drawPosText(const SkPaint& paint, SkSpan<const SkGlyphID> glyphIDs,
const SkPoint* pos,
SkSpan<const char> text, SkSpan<const uint32_t> clusters) {
SkASSERT(!glyphIDs.empty());
void SkGlyphRunBuilder::simplifyDrawPosText(
const SkPaint& paint, SkSpan<const SkGlyphID> glyphIDs, const SkPoint* pos,
uint16_t* uniqueGlyphIDIndicesBuffer, SkGlyphID* uniqueGlyphIDsBuffer,
SkSpan<const char> text, SkSpan<const uint32_t> clusters) {
auto runSize = glyphIDs.size();
// The dense indices are not used by the rest of the stack yet.
SkSpan<const SkGlyphID> uniqueGlyphIDs;
#ifdef SK_DEBUG
this->addDenseAndUnique(paint, glyphIDs);
uniqueGlyphIDs = this->addDenseAndUnique(
paint, glyphIDs, uniqueGlyphIDIndicesBuffer, uniqueGlyphIDsBuffer);
#endif
// TODO: when using the unique glyph system have a guard that there are actually glyphs like
@ -333,8 +332,8 @@ void SkGlyphRunBuilder::drawPosText(const SkPaint& paint, SkSpan<const SkGlyphID
paint,
glyphIDs,
SkSpan<const SkPoint>{pos, runSize},
SkSpan<const uint16_t>{},
SkSpan<const SkGlyphID>{},
SkSpan<const SkGlyphID>{uniqueGlyphIDIndicesBuffer, runSize},
uniqueGlyphIDs,
text,
clusters);
}

37
src/core/SkGlyphRun.h
View File

@ -95,14 +95,15 @@ private:
class SkGlyphRunBuilder {
public:
SkGlyphRunBuilder() = default;
void prepareDrawText(
const SkPaint& paint, const void* bytes, size_t byteLength, SkPoint origin);
void prepareDrawPosTextH(
void drawText(
const SkPaint& paint, const void* bytes, size_t byteLength,
const SkScalar xpos[], SkScalar constY);
void prepareDrawPosText(
const SkPaint& paint, const void* bytes, size_t byteLength, const SkPoint pos[]);
SkPoint origin);
void drawPosTextH(
const SkPaint& paint, const void* bytes, size_t byteLength,
const SkScalar* xpos, SkScalar constY);
void drawPosText(
const SkPaint& paint, const void* bytes, size_t byteLength,
const SkPoint* pos);
SkGlyphRun* useGlyphRun();
@ -114,7 +115,9 @@ private:
// Returns the span of unique glyph IDs.
SkSpan<const SkGlyphID> addDenseAndUnique(
const SkPaint& paint,
SkSpan<const SkGlyphID> glyphIDs);
SkSpan<const SkGlyphID> glyphIDs,
uint16_t* uniqueGlyphIDIndices,
SkGlyphID* uniqueGlyphIDs);
void makeGlyphRun(
const SkPaint& runPaint,
@ -125,16 +128,22 @@ private:
SkSpan<const char> text,
SkSpan<const uint32_t> clusters);
void drawText(
void simplifyDrawText(
const SkPaint& paint, SkSpan<const SkGlyphID> glyphIDs, SkPoint origin,
SkSpan<const char> text, SkSpan<const uint32_t> clusters);
void drawPosTextH(
uint16_t* uniqueGlyphIDIndices, SkGlyphID* uniqueGlyphIDs, SkPoint* positions,
SkSpan<const char> text = SkSpan<const char>{},
SkSpan<const uint32_t> clusters = SkSpan<const uint32_t>{});
void simplifyDrawPosTextH(
const SkPaint& paint, SkSpan<const SkGlyphID> glyphIDs,
const SkScalar* xpos, SkScalar constY,
SkSpan<const char> text, SkSpan<const uint32_t> clusters);
void drawPosText(
uint16_t* uniqueGlyphIDIndices, SkGlyphID* uniqueGlyphIDs, SkPoint* positions,
SkSpan<const char> text = SkSpan<const char>{},
SkSpan<const uint32_t> clusters = SkSpan<const uint32_t>{});
void simplifyDrawPosText(
const SkPaint& paint, SkSpan<const SkGlyphID> glyphIDs, const SkPoint* pos,
SkSpan<const char> text, SkSpan<const uint32_t> clusters);
uint16_t* uniqueGlyphIDIndices, SkGlyphID* uniqueGlyphIDs,
SkSpan<const char> text = SkSpan<const char>{},
SkSpan<const uint32_t> clusters = SkSpan<const uint32_t>{});
uint64_t fUniqueID{0};

10
src/gpu/text/GrTextContext.cpp
View File

@ -211,8 +211,8 @@ void GrTextContext::regenerateTextBlob(GrTextBlob* cacheBlob,
case SkTextBlob::kDefault_Positioning: {
auto origin = SkPoint::Make(x + offset.x(), y + offset.y());
SkGlyphRunBuilder builder;
builder.prepareDrawText(runPaint.skPaint(),
(const char*)it.glyphs(), textLen, origin);
builder.drawText(runPaint.skPaint(),
(const char*) it.glyphs(), textLen, origin);
auto glyphRun = builder.useGlyphRun();
@ -246,8 +246,8 @@ void GrTextContext::regenerateTextBlob(GrTextBlob* cacheBlob,
case SkTextBlob::kDefault_Positioning: {
auto origin = SkPoint::Make(x + offset.x(), y + offset.y());
SkGlyphRunBuilder builder;
builder.prepareDrawText(runPaint.skPaint(),
(const char*)it.glyphs(), textLen, origin);
builder.drawText(runPaint.skPaint(),
(const char*) it.glyphs(), textLen, origin);
auto glyphRun = builder.useGlyphRun();
@ -780,7 +780,7 @@ std::unique_ptr<GrDrawOp> GrTextContext::createOp_TestingOnly(GrContext* context
auto origin = SkPoint::Make(x, y);
SkGlyphRunBuilder builder;
builder.prepareDrawText(skPaint, text, textLen, origin);
builder.drawText(skPaint, text, textLen, origin);
sk_sp<GrTextBlob> blob;
auto glyphRun = builder.useGlyphRun();

2
tests/GlyphRunTest.cpp
View File

@ -47,5 +47,5 @@ DEF_TEST(GlyphRunBasic, reporter) {
paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
SkGlyphRunBuilder builder;
builder.prepareDrawText(paint, glyphs, count, SkPoint::Make(0, 0));
builder.drawText(paint, glyphs, count, SkPoint::Make(0, 0));
}