Change type of SkGlyph::fAdvance[XY] to float.
BUG=skia:4632
GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1737693006
Review URL: https://codereview.chromium.org/1737693006
diff --git a/src/core/SkAutoKern.h b/src/core/SkAutoKern.h
index 0b22e56..27df6da 100644
--- a/src/core/SkAutoKern.h
+++ b/src/core/SkAutoKern.h
@@ -12,11 +12,10 @@
#include "SkGlyph.h"
-#define SkAutoKern_AdjustF(prev, next) (((next) - (prev) + 32) >> 6 << 16)
-#define SkAutoKern_AdjustS(prev, next) SkIntToScalar(((next) - (prev) + 32) >> 6)
+#define SkAutoKern_Adjust(prev, next) SkIntToScalar(((next) - (prev) + 32) >> 6)
/* this is a helper class to perform auto-kerning
- * the adjust() method returns a SkFixed corresponding
+ * the adjust() method returns a SkScalar corresponding
* to a +1/0/-1 pixel adjustment
*/
@@ -24,7 +23,7 @@
public:
SkAutoKern() : fPrevRsbDelta(0) {}
- SkFixed adjust(const SkGlyph& glyph)
+ SkScalar adjust(const SkGlyph& glyph)
{
// if (SkAbs32(glyph.fLsbDelta) > 47 || SkAbs32(glyph.fRsbDelta) > 47)
// printf("------- %d> L %d R %d\n", glyph.f_GlyphID, glyph.fLsbDelta, glyph.fRsbDelta);
@@ -35,13 +34,13 @@
fPrevRsbDelta = glyph.fRsbDelta;
if (distort >= 32)
- return -SK_Fixed1;
+ return -SK_Scalar1;
else if (distort < -32)
- return +SK_Fixed1;
+ return +SK_Scalar1;
else
return 0;
#else
- SkFixed adjust = SkAutoKern_AdjustF(fPrevRsbDelta, glyph.fLsbDelta);
+ SkScalar adjust = SkAutoKern_Adjust(fPrevRsbDelta, glyph.fLsbDelta);
fPrevRsbDelta = glyph.fRsbDelta;
return adjust;
#endif
diff --git a/src/core/SkDrawProcs.h b/src/core/SkDrawProcs.h
index a861a0a..15c5cf8 100644
--- a/src/core/SkDrawProcs.h
+++ b/src/core/SkDrawProcs.h
@@ -51,12 +51,12 @@
if (SkPaint::kLeft_Align == fAlign) {
dst->set(loc.fX, loc.fY);
} else if (SkPaint::kCenter_Align == fAlign) {
- dst->set(loc.fX - SkFixedToScalar(glyph.fAdvanceX >> 1),
- loc.fY - SkFixedToScalar(glyph.fAdvanceY >> 1));
+ dst->set(loc.fX - SkFloatToScalar(glyph.fAdvanceX) / 2,
+ loc.fY - SkFloatToScalar(glyph.fAdvanceY) / 2);
} else {
SkASSERT(SkPaint::kRight_Align == fAlign);
- dst->set(loc.fX - SkFixedToScalar(glyph.fAdvanceX),
- loc.fY - SkFixedToScalar(glyph.fAdvanceY));
+ dst->set(loc.fX - SkFloatToScalar(glyph.fAdvanceX),
+ loc.fY - SkFloatToScalar(glyph.fAdvanceY));
}
}
private:
diff --git a/src/core/SkFDot6.h b/src/core/SkFDot6.h
index b536729..91f3dda 100644
--- a/src/core/SkFDot6.h
+++ b/src/core/SkFDot6.h
@@ -63,6 +63,7 @@
#define SkScalarToFDot6(x) (SkFDot6)((x) * 64)
#define SkFDot6ToScalar(x) ((SkScalar)(x) * 0.015625f)
+#define SkFDot6ToFloat SkFDot6ToScalar
inline SkFixed SkFDot6Div(SkFDot6 a, SkFDot6 b) {
SkASSERT(b != 0);
diff --git a/src/core/SkFindAndPlaceGlyph.h b/src/core/SkFindAndPlaceGlyph.h
index 35ae77c..48cc0fa 100644
--- a/src/core/SkFindAndPlaceGlyph.h
+++ b/src/core/SkFindAndPlaceGlyph.h
@@ -347,11 +347,11 @@
case SkPaint::kLeft_Align:
return {0.0f, 0.0f};
case SkPaint::kCenter_Align:
- return {SkFixedToScalar(glyph.fAdvanceX >> 1),
- SkFixedToScalar(glyph.fAdvanceY >> 1)};
+ return {SkFloatToScalar(glyph.fAdvanceX) / 2,
+ SkFloatToScalar(glyph.fAdvanceY) / 2};
case SkPaint::kRight_Align:
- return {SkFixedToScalar(glyph.fAdvanceX),
- SkFixedToScalar(glyph.fAdvanceY)};
+ return {SkFloatToScalar(glyph.fAdvanceX),
+ SkFloatToScalar(glyph.fAdvanceY)};
}
// Even though the entire enum is covered above, MVSC doesn't think so. Make it happy.
SkFAIL("Should never get here.");
@@ -447,8 +447,8 @@
if (metricGlyph.fWidth <= 0) {
// Exiting early, be sure to update text pointer.
*text = tempText;
- return finalPosition + SkPoint{SkFixedToScalar(metricGlyph.fAdvanceX),
- SkFixedToScalar(metricGlyph.fAdvanceY)};
+ return finalPosition + SkPoint{SkFloatToScalar(metricGlyph.fAdvanceX),
+ SkFloatToScalar(metricGlyph.fAdvanceY)};
}
// Adjust the final position by the alignment adjustment.
@@ -465,8 +465,8 @@
processOneGlyph(renderGlyph, finalPosition,
SubpixelPositionRounding(kAxisAlignment));
}
- return finalPosition + SkPoint{SkFixedToScalar(renderGlyph.fAdvanceX),
- SkFixedToScalar(renderGlyph.fAdvanceY)};
+ return finalPosition + SkPoint{SkFloatToScalar(renderGlyph.fAdvanceX),
+ SkFloatToScalar(renderGlyph.fAdvanceY)};
}
private:
@@ -497,14 +497,14 @@
SkPoint finalPosition = position;
const SkGlyph& glyph = fGlyphFinder->lookupGlyph(text);
if (kUseKerning) {
- finalPosition += {SkFixedToScalar(fAutoKern.adjust(glyph)), 0.0f};
+ finalPosition += {fAutoKern.adjust(glyph), 0.0f};
}
if (glyph.fWidth > 0) {
finalPosition -= TextAlignmentAdjustment(kTextAlignment, glyph);
processOneGlyph(glyph, finalPosition, {SK_ScalarHalf, SK_ScalarHalf});
}
- return finalPosition + SkPoint{SkFixedToScalar(glyph.fAdvanceX),
- SkFixedToScalar(glyph.fAdvanceY)};
+ return finalPosition + SkPoint{SkFloatToScalar(glyph.fAdvanceX),
+ SkFloatToScalar(glyph.fAdvanceY)};
}
private:
@@ -564,7 +564,7 @@
}
static SkPoint MeasureText(LookupGlyph& glyphFinder, const char text[], size_t byteLength) {
- SkFixed x = 0, y = 0;
+ SkScalar x = 0, y = 0;
const char* stop = text + byteLength;
SkAutoKern autokern;
@@ -574,11 +574,11 @@
// same advance
const SkGlyph& glyph = glyphFinder->lookupGlyph(&text);
- x += autokern.adjust(glyph) + glyph.fAdvanceX;
- y += glyph.fAdvanceY;
+ x += autokern.adjust(glyph) + SkFloatToScalar(glyph.fAdvanceX);
+ y += SkFloatToScalar(glyph.fAdvanceY);
}
SkASSERT(text == stop);
- return {SkFixedToScalar(x), SkFixedToScalar(y)};
+ return {x, y};
}
};
diff --git a/src/core/SkGlyph.h b/src/core/SkGlyph.h
index 55d5ddc..91aa842 100644
--- a/src/core/SkGlyph.h
+++ b/src/core/SkGlyph.h
@@ -56,7 +56,7 @@
static const uint32_t kImpossibleID = ~0;
void* fImage;
PathData* fPathData;
- SkFixed fAdvanceX, fAdvanceY;
+ float fAdvanceX, fAdvanceY;
uint16_t fWidth, fHeight;
int16_t fTop, fLeft;
diff --git a/src/core/SkPaint.cpp b/src/core/SkPaint.cpp
index 6fe9d75..2ced3f6 100644
--- a/src/core/SkPaint.cpp
+++ b/src/core/SkPaint.cpp
@@ -733,28 +733,26 @@
SkIntToScalar(g.fTop + g.fHeight));
}
-static void join_bounds_x(const SkGlyph& g, SkRect* bounds, Sk48Dot16 dx) {
- SkScalar sx = Sk48Dot16ToScalar(dx);
- bounds->join(SkIntToScalar(g.fLeft) + sx,
+static void join_bounds_x(const SkGlyph& g, SkRect* bounds, SkScalar dx) {
+ bounds->join(SkIntToScalar(g.fLeft) + dx,
SkIntToScalar(g.fTop),
- SkIntToScalar(g.fLeft + g.fWidth) + sx,
+ SkIntToScalar(g.fLeft + g.fWidth) + dx,
SkIntToScalar(g.fTop + g.fHeight));
}
-static void join_bounds_y(const SkGlyph& g, SkRect* bounds, Sk48Dot16 dy) {
- SkScalar sy = Sk48Dot16ToScalar(dy);
+static void join_bounds_y(const SkGlyph& g, SkRect* bounds, SkScalar dy) {
bounds->join(SkIntToScalar(g.fLeft),
- SkIntToScalar(g.fTop) + sy,
+ SkIntToScalar(g.fTop) + dy,
SkIntToScalar(g.fLeft + g.fWidth),
- SkIntToScalar(g.fTop + g.fHeight) + sy);
+ SkIntToScalar(g.fTop + g.fHeight) + dy);
}
-typedef void (*JoinBoundsProc)(const SkGlyph&, SkRect*, Sk48Dot16);
+typedef void (*JoinBoundsProc)(const SkGlyph&, SkRect*, SkScalar);
// xyIndex is 0 for fAdvanceX or 1 for fAdvanceY
-static SkFixed advance(const SkGlyph& glyph, int xyIndex) {
+static SkScalar advance(const SkGlyph& glyph, int xyIndex) {
SkASSERT(0 == xyIndex || 1 == xyIndex);
- return (&glyph.fAdvanceX)[xyIndex];
+ return SkFloatToScalar((&glyph.fAdvanceX)[xyIndex]);
}
SkScalar SkPaint::measure_text(SkGlyphCache* cache,
@@ -784,20 +782,14 @@
int n = 1;
const char* stop = (const char*)text + byteLength;
const SkGlyph* g = &glyphCacheProc(cache, &text);
- // our accumulated fixed-point advances might overflow 16.16, so we use
- // a 48.16 (64bit) accumulator, and then convert that to scalar at the
- // very end.
- Sk48Dot16 x = advance(*g, xyIndex);
-
- SkAutoKern autokern;
+ SkScalar x = advance(*g, xyIndex);
if (nullptr == bounds) {
if (this->isDevKernText()) {
- int rsb;
for (; text < stop; n++) {
- rsb = g->fRsbDelta;
+ const int rsb = g->fRsbDelta;
g = &glyphCacheProc(cache, &text);
- x += SkAutoKern_AdjustF(rsb, g->fLsbDelta) + advance(*g, xyIndex);
+ x += SkAutoKern_Adjust(rsb, g->fLsbDelta) + advance(*g, xyIndex);
}
} else {
for (; text < stop; n++) {
@@ -807,11 +799,10 @@
} else {
set_bounds(*g, bounds);
if (this->isDevKernText()) {
- int rsb;
for (; text < stop; n++) {
- rsb = g->fRsbDelta;
+ const int rsb = g->fRsbDelta;
g = &glyphCacheProc(cache, &text);
- x += SkAutoKern_AdjustF(rsb, g->fLsbDelta);
+ x += SkAutoKern_Adjust(rsb, g->fLsbDelta);
joinBoundsProc(*g, bounds, x);
x += advance(*g, xyIndex);
}
@@ -826,7 +817,7 @@
SkASSERT(text == stop);
*count = n;
- return Sk48Dot16ToScalar(x);
+ return x;
}
SkScalar SkPaint::measureText(const void* textData, size_t length, SkRect* bounds) const {
@@ -896,19 +887,15 @@
GlyphCacheProc glyphCacheProc = paint.getGlyphCacheProc(false);
const int xyIndex = paint.isVerticalText() ? 1 : 0;
- // use 64bits for our accumulator, to avoid overflowing 16.16
- Sk48Dot16 max = SkScalarTo48Dot16(maxWidth);
- Sk48Dot16 width = 0;
-
- SkAutoKern autokern;
+ SkScalar width = 0;
if (this->isDevKernText()) {
int rsb = 0;
while (text < stop) {
const char* curr = text;
const SkGlyph& g = glyphCacheProc(cache, &text);
- SkFixed x = SkAutoKern_AdjustF(rsb, g.fLsbDelta) + advance(g, xyIndex);
- if ((width += x) > max) {
+ SkScalar x = SkAutoKern_Adjust(rsb, g.fLsbDelta) + advance(g, xyIndex);
+ if ((width += x) > maxWidth) {
width -= x;
text = curr;
break;
@@ -918,8 +905,8 @@
} else {
while (text < stop) {
const char* curr = text;
- SkFixed x = advance(glyphCacheProc(cache, &text), xyIndex);
- if ((width += x) > max) {
+ SkScalar x = advance(glyphCacheProc(cache, &text), xyIndex);
+ if ((width += x) > maxWidth) {
width -= x;
text = curr;
break;
@@ -928,11 +915,10 @@
}
if (measuredWidth) {
- SkScalar scalarWidth = Sk48Dot16ToScalar(width);
if (scale) {
- scalarWidth = SkScalarMul(scalarWidth, scale);
+ width *= scale;
}
- *measuredWidth = scalarWidth;
+ *measuredWidth = width;
}
// return the number of bytes measured
@@ -1022,17 +1008,16 @@
if (this->isDevKernText()) {
// we adjust the widths returned here through auto-kerning
SkAutoKern autokern;
- SkFixed prevWidth = 0;
+ SkScalar prevWidth = 0;
if (scale) {
while (text < stop) {
const SkGlyph& g = glyphCacheProc(cache, &text);
if (widths) {
- SkFixed adjust = autokern.adjust(g);
+ SkScalar adjust = autokern.adjust(g);
if (count > 0) {
- SkScalar w = SkFixedToScalar(prevWidth + adjust);
- *widths++ = SkScalarMul(w, scale);
+ *widths++ = SkScalarMul(prevWidth + adjust, scale);
}
prevWidth = advance(g, xyIndex);
}
@@ -1042,16 +1027,16 @@
++count;
}
if (count > 0 && widths) {
- *widths = SkScalarMul(SkFixedToScalar(prevWidth), scale);
+ *widths = SkScalarMul(prevWidth, scale);
}
} else {
while (text < stop) {
const SkGlyph& g = glyphCacheProc(cache, &text);
if (widths) {
- SkFixed adjust = autokern.adjust(g);
+ SkScalar adjust = autokern.adjust(g);
if (count > 0) {
- *widths++ = SkFixedToScalar(prevWidth + adjust);
+ *widths++ = prevWidth + adjust;
}
prevWidth = advance(g, xyIndex);
}
@@ -1061,7 +1046,7 @@
++count;
}
if (count > 0 && widths) {
- *widths = SkFixedToScalar(prevWidth);
+ *widths = prevWidth;
}
}
} else { // no devkern
@@ -1069,7 +1054,7 @@
while (text < stop) {
const SkGlyph& g = glyphCacheProc(cache, &text);
if (widths) {
- *widths++ = SkScalarMul(SkFixedToScalar(advance(g, xyIndex)),
+ *widths++ = SkScalarMul(advance(g, xyIndex),
scale);
}
if (bounds) {
@@ -1081,7 +1066,7 @@
while (text < stop) {
const SkGlyph& g = glyphCacheProc(cache, &text);
if (widths) {
- *widths++ = SkFixedToScalar(advance(g, xyIndex));
+ *widths++ = advance(g, xyIndex);
}
if (bounds) {
set_bounds(g, bounds++);
@@ -2297,7 +2282,7 @@
if (fText < fStop) {
const SkGlyph& glyph = fGlyphCacheProc(fCache, &fText);
- fXPos += SkScalarMul(SkFixedToScalar(fPrevAdvance + fAutoKern.adjust(glyph)), fScale);
+ fXPos += SkScalarMul(fPrevAdvance + fAutoKern.adjust(glyph), fScale);
fPrevAdvance = advance(glyph, fXYIndex); // + fPaint.getTextTracking();
if (glyph.fWidth) {
@@ -2319,7 +2304,7 @@
bool SkTextInterceptsIter::next(SkScalar* array, int* count) {
const SkGlyph& glyph = fGlyphCacheProc(fCache, &fText);
- fXPos += SkScalarMul(SkFixedToScalar(fPrevAdvance + fAutoKern.adjust(glyph)), fScale);
+ fXPos += SkScalarMul(fPrevAdvance + fAutoKern.adjust(glyph), fScale);
fPrevAdvance = advance(glyph, fXYIndex); // + fPaint.getTextTracking();
if (fCache->findPath(glyph)) {
fCache->findIntercepts(fBounds, fScale, fXPos, SkToBool(fXYIndex),
diff --git a/src/core/SkTextToPathIter.h b/src/core/SkTextToPathIter.h
index 435c1c7..dcd5a01 100644
--- a/src/core/SkTextToPathIter.h
+++ b/src/core/SkTextToPathIter.h
@@ -22,7 +22,7 @@
SkGlyphCache* fCache;
SkPaint fPaint;
SkScalar fScale;
- SkFixed fPrevAdvance;
+ SkScalar fPrevAdvance;
const char* fText;
const char* fStop;
SkPaint::GlyphCacheProc fGlyphCacheProc;
@@ -75,7 +75,7 @@
&& fPaint.getTextAlign() != SkPaint::kLeft_Align) { // need to measure first
const char* text = fText;
const SkGlyph& glyph = fGlyphCacheProc(fCache, &text);
- SkScalar width = SkScalarMul(SkFixedToScalar((&glyph.fAdvanceX)[0]), fScale);
+ SkScalar width = SkScalarMul(SkFloatToScalar((&glyph.fAdvanceX)[0]), fScale);
if (fPaint.getTextAlign() == SkPaint::kCenter_Align) {
width = SkScalarHalf(width);
}
diff --git a/src/fonts/SkGScalerContext.cpp b/src/fonts/SkGScalerContext.cpp
index d2d0cac..9766e34 100644
--- a/src/fonts/SkGScalerContext.cpp
+++ b/src/fonts/SkGScalerContext.cpp
@@ -77,20 +77,20 @@
fProxy->getAdvance(glyph);
SkVector advance;
- fMatrix.mapXY(SkFixedToScalar(glyph->fAdvanceX),
- SkFixedToScalar(glyph->fAdvanceY), &advance);
- glyph->fAdvanceX = SkScalarToFixed(advance.fX);
- glyph->fAdvanceY = SkScalarToFixed(advance.fY);
+ fMatrix.mapXY(SkFloatToScalar(glyph->fAdvanceX),
+ SkFloatToScalar(glyph->fAdvanceY), &advance);
+ glyph->fAdvanceX = SkScalarToFloat(advance.fX);
+ glyph->fAdvanceY = SkScalarToFloat(advance.fY);
}
void SkGScalerContext::generateMetrics(SkGlyph* glyph) {
fProxy->getMetrics(glyph);
SkVector advance;
- fMatrix.mapXY(SkFixedToScalar(glyph->fAdvanceX),
- SkFixedToScalar(glyph->fAdvanceY), &advance);
- glyph->fAdvanceX = SkScalarToFixed(advance.fX);
- glyph->fAdvanceY = SkScalarToFixed(advance.fY);
+ fMatrix.mapXY(SkFloatToScalar(glyph->fAdvanceX),
+ SkFloatToScalar(glyph->fAdvanceY), &advance);
+ glyph->fAdvanceX = SkScalarToFloat(advance.fX);
+ glyph->fAdvanceY = SkScalarToFloat(advance.fY);
SkPath path;
fProxy->getPath(*glyph, &path);
diff --git a/src/fonts/SkTestScalerContext.cpp b/src/fonts/SkTestScalerContext.cpp
index 7afe652..600e2de 100644
--- a/src/fonts/SkTestScalerContext.cpp
+++ b/src/fonts/SkTestScalerContext.cpp
@@ -120,7 +120,8 @@
}
void SkTestTypeface::getAdvance(SkGlyph* glyph) {
- glyph->fAdvanceX = fTestFont->fWidths[glyph->getGlyphID()];
+ // TODO(benjaminwagner): Update users to use floats.
+ glyph->fAdvanceX = SkFixedToFloat(fTestFont->fWidths[glyph->getGlyphID()]);
glyph->fAdvanceY = 0;
}
@@ -129,7 +130,8 @@
}
void SkTestTypeface::getMetrics(SkGlyph* glyph) {
- glyph->fAdvanceX = fTestFont->fWidths[glyph->getGlyphID()];
+ // TODO(benjaminwagner): Update users to use floats.
+ glyph->fAdvanceX = SkFixedToFloat(fTestFont->fWidths[glyph->getGlyphID()]);
glyph->fAdvanceY = 0;
}
@@ -206,19 +208,19 @@
void generateAdvance(SkGlyph* glyph) override {
fFace->getAdvance(glyph);
- const SkVector advance = fMatrix.mapXY(SkFixedToScalar(glyph->fAdvanceX),
- SkFixedToScalar(glyph->fAdvanceY));
- glyph->fAdvanceX = SkScalarToFixed(advance.fX);
- glyph->fAdvanceY = SkScalarToFixed(advance.fY);
+ const SkVector advance = fMatrix.mapXY(SkFloatToScalar(glyph->fAdvanceX),
+ SkFloatToScalar(glyph->fAdvanceY));
+ glyph->fAdvanceX = SkScalarToFloat(advance.fX);
+ glyph->fAdvanceY = SkScalarToFloat(advance.fY);
}
void generateMetrics(SkGlyph* glyph) override {
fFace->getMetrics(glyph);
- const SkVector advance = fMatrix.mapXY(SkFixedToScalar(glyph->fAdvanceX),
- SkFixedToScalar(glyph->fAdvanceY));
- glyph->fAdvanceX = SkScalarToFixed(advance.fX);
- glyph->fAdvanceY = SkScalarToFixed(advance.fY);
+ const SkVector advance = fMatrix.mapXY(SkFloatToScalar(glyph->fAdvanceX),
+ SkFloatToScalar(glyph->fAdvanceY));
+ glyph->fAdvanceX = SkScalarToFloat(advance.fX);
+ glyph->fAdvanceY = SkScalarToFloat(advance.fY);
SkPath path;
fFace->getPath(*glyph, &path);
diff --git a/src/gpu/text/GrStencilAndCoverTextContext.cpp b/src/gpu/text/GrStencilAndCoverTextContext.cpp
index 661f225..4c2a615 100644
--- a/src/gpu/text/GrStencilAndCoverTextContext.cpp
+++ b/src/gpu/text/GrStencilAndCoverTextContext.cpp
@@ -457,8 +457,8 @@
// Measure first if needed.
if (fFont.getTextAlign() != SkPaint::kLeft_Align) {
- SkFixed stopX = 0;
- SkFixed stopY = 0;
+ SkScalar stopX = 0;
+ SkScalar stopY = 0;
const char* textPtr = text;
while (textPtr < stop) {
@@ -466,13 +466,13 @@
// same advance.
const SkGlyph& glyph = glyphCacheProc(glyphCache, &textPtr);
- stopX += glyph.fAdvanceX;
- stopY += glyph.fAdvanceY;
+ stopX += SkFloatToScalar(glyph.fAdvanceX);
+ stopY += SkFloatToScalar(glyph.fAdvanceY);
}
SkASSERT(textPtr == stop);
- SkScalar alignX = SkFixedToScalar(stopX) * fTextRatio;
- SkScalar alignY = SkFixedToScalar(stopY) * fTextRatio;
+ SkScalar alignX = stopX * fTextRatio;
+ SkScalar alignY = stopY * fTextRatio;
if (fFont.getTextAlign() == SkPaint::kCenter_Align) {
alignX = SkScalarHalf(alignX);
@@ -485,21 +485,16 @@
SkAutoKern autokern;
- SkFixed fixedSizeRatio = SkScalarToFixed(fTextRatio);
-
- SkFixed fx = SkScalarToFixed(x);
- SkFixed fy = SkScalarToFixed(y);
FallbackBlobBuilder fallback;
while (text < stop) {
const SkGlyph& glyph = glyphCacheProc(glyphCache, &text);
- fx += SkFixedMul(autokern.adjust(glyph), fixedSizeRatio);
+ x += autokern.adjust(glyph) * fTextRatio;
if (glyph.fWidth) {
- this->appendGlyph(glyph, SkPoint::Make(SkFixedToScalar(fx), SkFixedToScalar(fy)),
- &fallback);
+ this->appendGlyph(glyph, SkPoint::Make(x, y), &fallback);
}
- fx += SkFixedMul(glyph.fAdvanceX, fixedSizeRatio);
- fy += SkFixedMul(glyph.fAdvanceY, fixedSizeRatio);
+ x += SkFloatToScalar(glyph.fAdvanceX) * fTextRatio;
+ y += SkFloatToScalar(glyph.fAdvanceY) * fTextRatio;
}
fFallbackTextBlob.reset(fallback.buildIfNeeded(&fFallbackGlyphCount));
diff --git a/src/gpu/text/GrTextUtils.cpp b/src/gpu/text/GrTextUtils.cpp
index edf813d..0b26c84 100644
--- a/src/gpu/text/GrTextUtils.cpp
+++ b/src/gpu/text/GrTextUtils.cpp
@@ -267,12 +267,12 @@
SkTArray<SkScalar> positions;
const char* textPtr = text;
- SkFixed stopX = 0;
- SkFixed stopY = 0;
- SkFixed origin = 0;
+ SkScalar stopX = 0;
+ SkScalar stopY = 0;
+ SkScalar origin = 0;
switch (skPaint.getTextAlign()) {
- case SkPaint::kRight_Align: origin = SK_Fixed1; break;
- case SkPaint::kCenter_Align: origin = SK_FixedHalf; break;
+ case SkPaint::kRight_Align: origin = SK_Scalar1; break;
+ case SkPaint::kCenter_Align: origin = SK_ScalarHalf; break;
case SkPaint::kLeft_Align: origin = 0; break;
}
@@ -283,11 +283,11 @@
// same advance
const SkGlyph& glyph = glyphCacheProc(origPaintCache, &textPtr);
- SkFixed width = glyph.fAdvanceX + autokern.adjust(glyph);
- positions.push_back(SkFixedToScalar(stopX + SkFixedMul(origin, width)));
+ SkScalar width = SkFloatToScalar(glyph.fAdvanceX) + autokern.adjust(glyph);
+ positions.push_back(stopX + origin * width);
- SkFixed height = glyph.fAdvanceY;
- positions.push_back(SkFixedToScalar(stopY + SkFixedMul(origin, height)));
+ SkScalar height = SkFloatToScalar(glyph.fAdvanceY);
+ positions.push_back(stopY + origin * height);
stopX += width;
stopY += height;
@@ -297,8 +297,8 @@
SkGlyphCache::AttachCache(origPaintCache);
// now adjust starting point depending on alignment
- SkScalar alignX = SkFixedToScalar(stopX);
- SkScalar alignY = SkFixedToScalar(stopY);
+ SkScalar alignX = stopX;
+ SkScalar alignY = stopY;
if (skPaint.getTextAlign() == SkPaint::kCenter_Align) {
alignX = SkScalarHalf(alignX);
alignY = SkScalarHalf(alignY);
@@ -387,8 +387,8 @@
SkScalar x = offset.x() + pos[0];
SkScalar y = offset.y() + (2 == scalarsPerPosition ? pos[1] : 0);
- SkScalar advanceX = SkFixedToScalar(glyph.fAdvanceX) * alignMul * textRatio;
- SkScalar advanceY = SkFixedToScalar(glyph.fAdvanceY) * alignMul * textRatio;
+ SkScalar advanceX = SkFloatToScalar(glyph.fAdvanceX) * alignMul * textRatio;
+ SkScalar advanceY = SkFloatToScalar(glyph.fAdvanceY) * alignMul * textRatio;
if (!DfAppendGlyph(blob,
runIndex,
diff --git a/src/pdf/SkPDFDevice.cpp b/src/pdf/SkPDFDevice.cpp
index 9ab3b0d..0054143 100644
--- a/src/pdf/SkPDFDevice.cpp
+++ b/src/pdf/SkPDFDevice.cpp
@@ -95,26 +95,24 @@
const char* start = reinterpret_cast<const char*>(glyphs);
const char* stop = reinterpret_cast<const char*>(glyphs + len);
- SkFixed xAdv = 0, yAdv = 0;
+ SkScalar xAdv = 0, yAdv = 0;
// TODO(vandebo): This probably needs to take kerning into account.
while (start < stop) {
const SkGlyph& glyph = glyphCacheProc(cache, &start);
- xAdv += glyph.fAdvanceX;
- yAdv += glyph.fAdvanceY;
+ xAdv += SkFloatToScalar(glyph.fAdvanceX);
+ yAdv += SkFloatToScalar(glyph.fAdvanceY);
};
if (paint.getTextAlign() == SkPaint::kLeft_Align) {
return;
}
- SkScalar xAdj = SkFixedToScalar(xAdv);
- SkScalar yAdj = SkFixedToScalar(yAdv);
if (paint.getTextAlign() == SkPaint::kCenter_Align) {
- xAdj = SkScalarHalf(xAdj);
- yAdj = SkScalarHalf(yAdj);
+ xAdv = SkScalarHalf(xAdv);
+ yAdv = SkScalarHalf(yAdv);
}
- *x = *x - xAdj;
- *y = *y - yAdj;
+ *x = *x - xAdv;
+ *y = *y - yAdv;
}
static int max_glyphid_for_typeface(SkTypeface* typeface) {
diff --git a/src/pdf/SkPDFFont.cpp b/src/pdf/SkPDFFont.cpp
index 27b5a45..cc84a67 100644
--- a/src/pdf/SkPDFFont.cpp
+++ b/src/pdf/SkPDFFont.cpp
@@ -1343,13 +1343,13 @@
encDiffs->appendName(characterName.c_str());
const SkGlyph& glyph = cache->getGlyphIDMetrics(gID);
- widthArray->appendScalar(SkFixedToScalar(glyph.fAdvanceX));
+ widthArray->appendScalar(SkFloatToScalar(glyph.fAdvanceX));
SkIRect glyphBBox = SkIRect::MakeXYWH(glyph.fLeft, glyph.fTop,
glyph.fWidth, glyph.fHeight);
bbox.join(glyphBBox);
SkDynamicMemoryWStream content;
- setGlyphWidthAndBoundingBox(SkFixedToScalar(glyph.fAdvanceX), glyphBBox,
+ setGlyphWidthAndBoundingBox(SkFloatToScalar(glyph.fAdvanceX), glyphBBox,
&content);
const SkPath* path = cache->findPath(glyph);
if (path) {
diff --git a/src/ports/SkFontHost_FreeType.cpp b/src/ports/SkFontHost_FreeType.cpp
index e7cb6d2..5c00d1b 100644
--- a/src/ports/SkFontHost_FreeType.cpp
+++ b/src/ports/SkFontHost_FreeType.cpp
@@ -1006,6 +1006,10 @@
return 0;
}
+static SkScalar SkFT_FixedToScalar(FT_Fixed x) {
+ return SkFixedToScalar(x);
+}
+
void SkScalerContext_FreeType::generateAdvance(SkGlyph* glyph) {
/* unhinted and light hinted text have linearly scaled advances
* which are very cheap to compute with some font formats...
@@ -1027,8 +1031,9 @@
if (0 == error) {
glyph->fRsbDelta = 0;
glyph->fLsbDelta = 0;
- glyph->fAdvanceX = SkFixedMul(fMatrix22.xx, advance);
- glyph->fAdvanceY = - SkFixedMul(fMatrix22.yx, advance);
+ const SkScalar advanceScalar = SkFT_FixedToScalar(advance);
+ glyph->fAdvanceX = SkScalarToFloat(fMatrix22Scalar.getScaleX() * advanceScalar);
+ glyph->fAdvanceY = -SkScalarToFloat(fMatrix22Scalar.getSkewY() * advanceScalar);
return;
}
}
@@ -1108,9 +1113,9 @@
glyph.fTop *= scale;
glyph.fLeft *= scale;
- SkFixed fixedScale = SkScalarToFixed(scale);
- glyph.fAdvanceX = SkFixedMul(glyph.fAdvanceX, fixedScale);
- glyph.fAdvanceY = SkFixedMul(glyph.fAdvanceY, fixedScale);
+ float floatScale = SkScalarToFloat(scale);
+ glyph.fAdvanceX *= floatScale;
+ glyph.fAdvanceY *= floatScale;
}
void SkScalerContext_FreeType::generateMetrics(SkGlyph* glyph) {
@@ -1181,19 +1186,21 @@
if (fRec.fFlags & SkScalerContext::kVertical_Flag) {
if (fDoLinearMetrics) {
- glyph->fAdvanceX = -SkFixedMul(fMatrix22.xy, fFace->glyph->linearVertAdvance);
- glyph->fAdvanceY = SkFixedMul(fMatrix22.yy, fFace->glyph->linearVertAdvance);
+ const SkScalar advanceScalar = SkFT_FixedToScalar(fFace->glyph->linearVertAdvance);
+ glyph->fAdvanceX = -SkScalarToFloat(fMatrix22Scalar.getSkewX() * advanceScalar);
+ glyph->fAdvanceY = SkScalarToFloat(fMatrix22Scalar.getScaleY() * advanceScalar);
} else {
- glyph->fAdvanceX = -SkFDot6ToFixed(fFace->glyph->advance.x);
- glyph->fAdvanceY = SkFDot6ToFixed(fFace->glyph->advance.y);
+ glyph->fAdvanceX = -SkFDot6ToFloat(fFace->glyph->advance.x);
+ glyph->fAdvanceY = SkFDot6ToFloat(fFace->glyph->advance.y);
}
} else {
if (fDoLinearMetrics) {
- glyph->fAdvanceX = SkFixedMul(fMatrix22.xx, fFace->glyph->linearHoriAdvance);
- glyph->fAdvanceY = -SkFixedMul(fMatrix22.yx, fFace->glyph->linearHoriAdvance);
+ const SkScalar advanceScalar = SkFT_FixedToScalar(fFace->glyph->linearHoriAdvance);
+ glyph->fAdvanceX = SkScalarToFloat(fMatrix22Scalar.getScaleX() * advanceScalar);
+ glyph->fAdvanceY = -SkScalarToFloat(fMatrix22Scalar.getSkewY() * advanceScalar);
} else {
- glyph->fAdvanceX = SkFDot6ToFixed(fFace->glyph->advance.x);
- glyph->fAdvanceY = -SkFDot6ToFixed(fFace->glyph->advance.y);
+ glyph->fAdvanceX = SkFDot6ToFloat(fFace->glyph->advance.x);
+ glyph->fAdvanceY = -SkFDot6ToFloat(fFace->glyph->advance.y);
if (fRec.fFlags & kDevKernText_Flag) {
glyph->fRsbDelta = SkToS8(fFace->glyph->rsb_delta);
diff --git a/src/ports/SkFontHost_mac.cpp b/src/ports/SkFontHost_mac.cpp
index f47add0..98eeaec 100644
--- a/src/ports/SkFontHost_mac.cpp
+++ b/src/ports/SkFontHost_mac.cpp
@@ -277,13 +277,22 @@
static SkScalar CGToScalar(CGFloat cgFloat) {
if (sizeof(CGFloat) == sizeof(float)) {
- return cgFloat;
+ return SkFloatToScalar(cgFloat);
} else {
SkASSERT(sizeof(CGFloat) == sizeof(double));
return SkDoubleToScalar(cgFloat);
}
}
+static float CGToFloat(CGFloat cgFloat) {
+ if (sizeof(CGFloat) == sizeof(float)) {
+ return cgFloat;
+ } else {
+ SkASSERT(sizeof(CGFloat) == sizeof(double));
+ return static_cast<float>(cgFloat);
+ }
+}
+
static CGAffineTransform MatrixToCGAffineTransform(const SkMatrix& matrix,
SkScalar sx = SK_Scalar1,
SkScalar sy = SK_Scalar1) {
@@ -1054,8 +1063,8 @@
&cgGlyph, &cgAdvance, 1);
}
cgAdvance = CGSizeApplyAffineTransform(cgAdvance, fTransform);
- glyph->fAdvanceX = SkFloatToFixed_Check(cgAdvance.width);
- glyph->fAdvanceY = -SkFloatToFixed_Check(cgAdvance.height);
+ glyph->fAdvanceX = CGToFloat(cgAdvance.width);
+ glyph->fAdvanceY = -CGToFloat(cgAdvance.height);
// The following produces skBounds in SkGlyph units (pixels, y down),
// or returns early if skBounds would be empty.
diff --git a/src/ports/SkFontHost_win.cpp b/src/ports/SkFontHost_win.cpp
index 8aefd14..f772d8c 100644
--- a/src/ports/SkFontHost_win.cpp
+++ b/src/ports/SkFontHost_win.cpp
@@ -584,6 +584,10 @@
return SkFixedToFIXED(SkFloatToFixed(x));
}
+static inline float FIXED2float(FIXED x) {
+ return SkFixedToFloat(SkFIXEDToFixed(x));
+}
+
static BYTE compute_quality(const SkScalerContext::Rec& rec) {
switch (rec.fMaskFormat) {
case SkMask::kBW_Format:
@@ -856,7 +860,7 @@
// Bitmap FON cannot underhang, but vector FON may.
// There appears no means of determining underhang of vector FON.
glyph->fLeft = SkToS16(0);
- glyph->fAdvanceX = SkIntToFixed(glyph->fWidth);
+ glyph->fAdvanceX = glyph->fWidth;
glyph->fAdvanceY = 0;
// Vector FON will transform nicely, but bitmap FON do not.
@@ -876,8 +880,8 @@
}
// Apply matrix to advance.
- glyph->fAdvanceY = SkFixedMul(-SkFIXEDToFixed(fMat22.eM12), glyph->fAdvanceX);
- glyph->fAdvanceX = SkFixedMul(SkFIXEDToFixed(fMat22.eM11), glyph->fAdvanceX);
+ glyph->fAdvanceY = -FIXED2float(fMat22.eM12) * glyph->fAdvanceX;
+ glyph->fAdvanceX *= FIXED2float(fMat22.eM11);
return;
}
@@ -922,8 +926,9 @@
glyph->fTop -= 2;
glyph->fLeft -= 2;
}
- glyph->fAdvanceX = SkIntToFixed(gm.gmCellIncX);
- glyph->fAdvanceY = SkIntToFixed(gm.gmCellIncY);
+ // TODO(benjaminwagner): What is the type of gm.gmCellInc[XY]?
+ glyph->fAdvanceX = (float)((int)gm.gmCellIncX);
+ glyph->fAdvanceY = (float)((int)gm.gmCellIncY);
glyph->fRsbDelta = 0;
glyph->fLsbDelta = 0;
@@ -933,16 +938,16 @@
if (GDI_ERROR != status) {
SkPoint advance;
fHiResMatrix.mapXY(SkIntToScalar(gm.gmCellIncX), SkIntToScalar(gm.gmCellIncY), &advance);
- glyph->fAdvanceX = SkScalarToFixed(advance.fX);
- glyph->fAdvanceY = SkScalarToFixed(advance.fY);
+ glyph->fAdvanceX = SkScalarToFloat(advance.fX);
+ glyph->fAdvanceY = SkScalarToFloat(advance.fY);
}
} else if (!isAxisAligned(this->fRec)) {
status = GetGlyphOutlineW(fDDC, glyphId, GGO_METRICS | GGO_GLYPH_INDEX, &gm, 0, nullptr, &fGsA);
if (GDI_ERROR != status) {
SkPoint advance;
fG_inv.mapXY(SkIntToScalar(gm.gmCellIncX), SkIntToScalar(gm.gmCellIncY), &advance);
- glyph->fAdvanceX = SkScalarToFixed(advance.fX);
- glyph->fAdvanceY = SkScalarToFixed(advance.fY);
+ glyph->fAdvanceX = SkScalarToFloat(advance.fX);
+ glyph->fAdvanceY = SkScalarToFloat(advance.fY);
}
}
}
diff --git a/src/ports/SkScalerContext_win_dw.cpp b/src/ports/SkScalerContext_win_dw.cpp
index 097db86..f276762 100644
--- a/src/ports/SkScalerContext_win_dw.cpp
+++ b/src/ports/SkScalerContext_win_dw.cpp
@@ -388,8 +388,8 @@
fSkXform.mapVectors(vecs, SK_ARRAY_COUNT(vecs));
}
- glyph->fAdvanceX = SkScalarToFixed(vecs[0].fX);
- glyph->fAdvanceY = SkScalarToFixed(vecs[0].fY);
+ glyph->fAdvanceX = SkScalarToFloat(vecs[0].fX);
+ glyph->fAdvanceY = SkScalarToFloat(vecs[0].fY);
}
HRESULT SkScalerContext_DW::getBoundingBox(SkGlyph* glyph,