void GrTextContext::drawPackedGlyph(GrGlyph::PackedID packed, GrFixed vx, GrFixed vy, GrFontScaler* scaler) { if (NULL == fStrike) { fStrike = fContext->getFontCache()->getStrike(scaler); } GrGlyph* glyph = fStrike->getGlyph(packed, scaler); if (NULL == glyph || glyph->fBounds.isEmpty()) { return; } vx += SkIntToFixed(glyph->fBounds.fLeft); vy += SkIntToFixed(glyph->fBounds.fTop); // keep them as ints until we've done the clip-test GrFixed width = glyph->fBounds.width(); GrFixed height = glyph->fBounds.height(); // check if we clipped out if (true || NULL == glyph->fAtlas) { int x = vx >> 16; int y = vy >> 16; if (fClipRect.quickReject(x, y, x + width, y + height)) { // SkCLZ(3); // so we can set a break-point in the debugger return; } }
void SkScalerContext_Ascender::generateMetrics(SkGlyph* glyph) { glyph->fRsbDelta = 0; glyph->fLsbDelta = 0; aca_GlyphImageRec rec; aca_Vector topLeft; int adv = aca_Get_Adv_Width(fHandle, glyph->getGlyphID()); if (aca_GLYPH_NOT_PRESENT == adv) goto ERROR; aca_Rasterize(glyph->getGlyphID(), fHandle, &rec, &topLeft); if (false) // error { ERROR: glyph->fWidth = 0; glyph->fHeight = 0; glyph->fTop = 0; glyph->fLeft = 0; glyph->fAdvanceX = 0; glyph->fAdvanceY = 0; return; } glyph->fWidth = rec.width; glyph->fHeight = rec.rows; glyph->fRowBytes = rec.width; glyph->fTop = -topLeft.y; glyph->fLeft = topLeft.x; glyph->fAdvanceX = SkIntToFixed(adv); glyph->fAdvanceY = SkIntToFixed(0); }
static void DrawRoundRect() { #ifdef SK_SCALAR_IS_FIXED bool ret = false; SkPaint paint; SkBitmap bitmap; SkCanvas canvas; SkMatrix matrix; matrix.reset(); bitmap.setConfig(SkBitmap::kARGB_8888_Config, 1370, 812); bitmap.allocPixels(); canvas.setBitmapDevice(bitmap); // set up clipper SkRect skclip; skclip.set(SkIntToFixed(284), SkIntToFixed(40), SkIntToFixed(1370), SkIntToFixed(708)); ret = canvas.clipRect(skclip); SkASSERT(ret); matrix.set(SkMatrix::kMTransX, SkFloatToFixed(-1153.28)); matrix.set(SkMatrix::kMTransY, SkFloatToFixed(1180.50)); matrix.set(SkMatrix::kMScaleX, SkFloatToFixed(0.177171)); matrix.set(SkMatrix::kMScaleY, SkFloatToFixed(0.177043)); matrix.set(SkMatrix::kMSkewX, SkFloatToFixed(0.126968)); matrix.set(SkMatrix::kMSkewY, SkFloatToFixed(-0.126876)); matrix.set(SkMatrix::kMPersp0, SkFloatToFixed(0.0)); matrix.set(SkMatrix::kMPersp1, SkFloatToFixed(0.0)); ret = canvas.concat(matrix); paint.setAntiAlias(true); paint.setColor(0xb2202020); paint.setStyle(SkPaint::kStroke_Style); paint.setStrokeWidth(SkFloatToFixed(68.13)); SkRect r; r.set(SkFloatToFixed(-313.714417), SkFloatToFixed(-4.826389), SkFloatToFixed(18014.447266), SkFloatToFixed(1858.154541)); canvas.drawRoundRect(r, SkFloatToFixed(91.756363), SkFloatToFixed(91.756363), paint); #endif }
/** We take the original colors, not our premultiplied PMColors, since we can build a 16bit table as long as the original colors are opaque, even if the paint specifies a non-opaque alpha. */ void SkGradientShaderBase::GradientShaderCache::Build16bitCache( uint16_t cache[], SkColor c0, SkColor c1, int count, bool dither) { SkASSERT(count > 1); SkASSERT(SkColorGetA(c0) == 0xFF); SkASSERT(SkColorGetA(c1) == 0xFF); SkFixed r = SkColorGetR(c0); SkFixed g = SkColorGetG(c0); SkFixed b = SkColorGetB(c0); SkFixed dr = SkIntToFixed(SkColorGetR(c1) - r) / (count - 1); SkFixed dg = SkIntToFixed(SkColorGetG(c1) - g) / (count - 1); SkFixed db = SkIntToFixed(SkColorGetB(c1) - b) / (count - 1); r = SkIntToFixed(r) + 0x8000; g = SkIntToFixed(g) + 0x8000; b = SkIntToFixed(b) + 0x8000; if (dither) { do { unsigned rr = r >> 16; unsigned gg = g >> 16; unsigned bb = b >> 16; cache[0] = SkPackRGB16(SkR32ToR16(rr), SkG32ToG16(gg), SkB32ToB16(bb)); cache[kCache16Count] = SkDitherPack888ToRGB16(rr, gg, bb); cache += 1; r += dr; g += dg; b += db; } while (--count != 0); } else { do {
void SkGradientShaderBase::GradientShaderCache::Build32bitCache( SkPMColor cache[], SkColor c0, SkColor c1, int count, U8CPU paintAlpha, uint32_t gradFlags) { SkASSERT(count > 1); // need to apply paintAlpha to our two endpoints uint32_t a0 = SkMulDiv255Round(SkColorGetA(c0), paintAlpha); uint32_t a1 = SkMulDiv255Round(SkColorGetA(c1), paintAlpha); const bool interpInPremul = SkToBool(gradFlags & SkGradientShader::kInterpolateColorsInPremul_Flag); uint32_t r0 = SkColorGetR(c0); uint32_t g0 = SkColorGetG(c0); uint32_t b0 = SkColorGetB(c0); uint32_t r1 = SkColorGetR(c1); uint32_t g1 = SkColorGetG(c1); uint32_t b1 = SkColorGetB(c1); if (interpInPremul) { r0 = SkMulDiv255Round(r0, a0); g0 = SkMulDiv255Round(g0, a0); b0 = SkMulDiv255Round(b0, a0); r1 = SkMulDiv255Round(r1, a1); g1 = SkMulDiv255Round(g1, a1); b1 = SkMulDiv255Round(b1, a1); } SkFixed da = SkIntToFixed(a1 - a0) / (count - 1); SkFixed dr = SkIntToFixed(r1 - r0) / (count - 1); SkFixed dg = SkIntToFixed(g1 - g0) / (count - 1); SkFixed db = SkIntToFixed(b1 - b0) / (count - 1); /* We pre-add 1/8 to avoid having to add this to our [0] value each time in the loop. Without this, the bias for each would be 0x2000 0xA000 0xE000 0x6000 With this trick, we can add 0 for the first (no-op) and just adjust the others. */ SkUFixed a = SkIntToFixed(a0) + 0x2000; SkUFixed r = SkIntToFixed(r0) + 0x2000; SkUFixed g = SkIntToFixed(g0) + 0x2000; SkUFixed b = SkIntToFixed(b0) + 0x2000; /* * Our dither-cell (spatially) is * 0 2 * 3 1 * Where * [0] -> [-1/8 ... 1/8 ) values near 0 * [1] -> [ 1/8 ... 3/8 ) values near 1/4 * [2] -> [ 3/8 ... 5/8 ) values near 1/2 * [3] -> [ 5/8 ... 7/8 ) values near 3/4 */ if (0xFF == a0 && 0 == da) { do { cache[kCache32Count*0] = SkPackARGB32(0xFF, (r + 0 ) >> 16, (g + 0 ) >> 16, (b + 0 ) >> 16); cache[kCache32Count*1] = SkPackARGB32(0xFF, (r + 0x8000) >> 16, (g + 0x8000) >> 16, (b + 0x8000) >> 16); cache[kCache32Count*2] = SkPackARGB32(0xFF, (r + 0xC000) >> 16, (g + 0xC000) >> 16, (b + 0xC000) >> 16); cache[kCache32Count*3] = SkPackARGB32(0xFF, (r + 0x4000) >> 16, (g + 0x4000) >> 16, (b + 0x4000) >> 16); cache += 1; r += dr; g += dg; b += db; } while (--count != 0); } else if (interpInPremul) {
void SkGradientShaderBase::Build32bitCache(SkPMColor cache[], SkColor c0, SkColor c1, int count, U8CPU paintAlpha) { SkASSERT(count > 1); // need to apply paintAlpha to our two endpoints SkFixed a = SkMulDiv255Round(SkColorGetA(c0), paintAlpha); SkFixed da; { int tmp = SkMulDiv255Round(SkColorGetA(c1), paintAlpha); da = SkIntToFixed(tmp - a) / (count - 1); } /* * r,g,b used to be SkFixed, but on gcc (4.2.1 mac and 4.6.3 goobuntu) in * release builds, we saw a compiler error where the 0xFF parameter in * SkPackARGB32() was being totally ignored whenever it was called with * a non-zero add (e.g. 0x8000). * * We found two work-arounds: * 1. change r,g,b to unsigned (or just one of them) * 2. change SkPackARGB32 to + its (a << SK_A32_SHIFT) value instead * of using | * * We chose #1 just because it was more localized. * See http://code.google.com/p/skia/issues/detail?id=1113 */ uint32_t r = SkColorGetR(c0); uint32_t g = SkColorGetG(c0); uint32_t b = SkColorGetB(c0); SkFixed dr = SkIntToFixed(SkColorGetR(c1) - r) / (count - 1); SkFixed dg = SkIntToFixed(SkColorGetG(c1) - g) / (count - 1); SkFixed db = SkIntToFixed(SkColorGetB(c1) - b) / (count - 1); /* We pre-add 1/8 to avoid having to add this to our [0] value each time in the loop. Without this, the bias for each would be 0x2000 0xA000 0xE000 0x6000 With this trick, we can add 0 for the first (no-op) and just adjust the others. */ r = SkIntToFixed(r) + 0x2000; g = SkIntToFixed(g) + 0x2000; b = SkIntToFixed(b) + 0x2000; /* * Our dither-cell (spatially) is * 0 2 * 3 1 * Where * [0] -> [-1/8 ... 1/8 ) values near 0 * [1] -> [ 1/8 ... 3/8 ) values near 1/4 * [2] -> [ 3/8 ... 5/8 ) values near 1/2 * [3] -> [ 5/8 ... 7/8 ) values near 3/4 */ if (0xFF == a && 0 == da) { do { cache[kCache32Count*0] = SkPackARGB32(0xFF, (r + 0 ) >> 16, (g + 0 ) >> 16, (b + 0 ) >> 16); cache[kCache32Count*1] = SkPackARGB32(0xFF, (r + 0x8000) >> 16, (g + 0x8000) >> 16, (b + 0x8000) >> 16); cache[kCache32Count*2] = SkPackARGB32(0xFF, (r + 0xC000) >> 16, (g + 0xC000) >> 16, (b + 0xC000) >> 16); cache[kCache32Count*3] = SkPackARGB32(0xFF, (r + 0x4000) >> 16, (g + 0x4000) >> 16, (b + 0x4000) >> 16); cache += 1; r += dr; g += dg; b += db; } while (--count != 0); } else {
cache[kCache32Count*1] = SkPackARGB32(0xFF, (r + 0x8000) >> 16, (g + 0x8000) >> 16, (b + 0x8000) >> 16); cache[kCache32Count*2] = SkPackARGB32(0xFF, (r + 0xC000) >> 16, (g + 0xC000) >> 16, (b + 0xC000) >> 16); cache[kCache32Count*3] = SkPackARGB32(0xFF, (r + 0x4000) >> 16, (g + 0x4000) >> 16, (b + 0x4000) >> 16); cache += 1; r += dr; g += dg; b += db; } while (--count != 0); } else { a = SkIntToFixed(a) + 0x2000; do { cache[kCache32Count*0] = SkPremultiplyARGBInline((a + 0 ) >> 16, (r + 0 ) >> 16, (g + 0 ) >> 16, (b + 0 ) >> 16); cache[kCache32Count*1] = SkPremultiplyARGBInline((a + 0x8000) >> 16, (r + 0x8000) >> 16, (g + 0x8000) >> 16, (b + 0x8000) >> 16); cache[kCache32Count*2] = SkPremultiplyARGBInline((a + 0xC000) >> 16, (r + 0xC000) >> 16, (g + 0xC000) >> 16, (b + 0xC000) >> 16); cache[kCache32Count*3] = SkPremultiplyARGBInline((a + 0x4000) >> 16, (r + 0x4000) >> 16,
void SkScalerContext_Windows::generateMetrics(SkGlyph* glyph) { HDC ddc = ::CreateCompatibleDC(NULL); SetBkMode(ddc, TRANSPARENT); SkASSERT(plf); plf->lfHeight = -SkFixedFloor(fRec.fTextSize); HFONT font = CreateFontIndirect(plf); HFONT oldfont = (HFONT)SelectObject(ddc, font); GLYPHMETRICS gm; memset(&gm, 0, sizeof(gm)); glyph->fRsbDelta = 0; glyph->fLsbDelta = 0; // Note: need to use GGO_GRAY8_BITMAP instead of GGO_METRICS because GGO_METRICS returns a smaller // BlackBlox; we need the bigger one in case we need the image. fAdvance is the same. uint32_t ret = GetGlyphOutlineW(ddc, glyph->f_GlyphID, GGO_GRAY8_BITMAP, &gm, 0, NULL, &mat22); if (GDI_ERROR != ret) { if (ret == 0) { // for white space, ret is zero and gmBlackBoxX, gmBlackBoxY are 1 incorrectly! gm.gmBlackBoxX = gm.gmBlackBoxY = 0; } glyph->fWidth = gm.gmBlackBoxX; glyph->fHeight = gm.gmBlackBoxY; glyph->fTop = gm.gmptGlyphOrigin.y - gm.gmBlackBoxY; glyph->fLeft = gm.gmptGlyphOrigin.x; glyph->fAdvanceX = SkIntToFixed(gm.gmCellIncX); glyph->fAdvanceY = -SkIntToFixed(gm.gmCellIncY); } ::SelectObject(ddc, oldfont); ::DeleteObject(font); ::DeleteDC(ddc); }
// Returns true if this method handled the glyph, false if needs to be passed to fallback // bool GrDistanceFieldTextContext::appendGlyph(GrGlyph::PackedID packed, SkScalar sx, SkScalar sy, GrFontScaler* scaler) { if (NULL == fDrawTarget) { return true; } if (NULL == fStrike) { fStrike = fContext->getFontCache()->getStrike(scaler, true); } GrGlyph* glyph = fStrike->getGlyph(packed, scaler); if (NULL == glyph || glyph->fBounds.isEmpty()) { return true; } // fallback to color glyph support if (kA8_GrMaskFormat != glyph->fMaskFormat) { return false; } SkScalar dx = SkIntToScalar(glyph->fBounds.fLeft + SK_DistanceFieldInset); SkScalar dy = SkIntToScalar(glyph->fBounds.fTop + SK_DistanceFieldInset); SkScalar width = SkIntToScalar(glyph->fBounds.width() - 2*SK_DistanceFieldInset); SkScalar height = SkIntToScalar(glyph->fBounds.height() - 2*SK_DistanceFieldInset); SkScalar scale = fTextRatio; dx *= scale; dy *= scale; sx += dx; sy += dy; width *= scale; height *= scale; SkRect glyphRect = SkRect::MakeXYWH(sx, sy, width, height); // check if we clipped out SkRect dstRect; const SkMatrix& ctm = fContext->getMatrix(); (void) ctm.mapRect(&dstRect, glyphRect); if (fClipRect.quickReject(SkScalarTruncToInt(dstRect.left()), SkScalarTruncToInt(dstRect.top()), SkScalarTruncToInt(dstRect.right()), SkScalarTruncToInt(dstRect.bottom()))) { // SkCLZ(3); // so we can set a break-point in the debugger return true; } if (NULL == glyph->fPlot) { if (!fStrike->glyphTooLargeForAtlas(glyph)) { if (fStrike->addGlyphToAtlas(glyph, scaler)) { goto HAS_ATLAS; } // try to clear out an unused plot before we flush if (fContext->getFontCache()->freeUnusedPlot(fStrike, glyph) && fStrike->addGlyphToAtlas(glyph, scaler)) { goto HAS_ATLAS; } if (c_DumpFontCache) { #ifdef SK_DEVELOPER fContext->getFontCache()->dump(); #endif } // before we purge the cache, we must flush any accumulated draws this->flush(); fContext->flush(); // we should have an unused plot now if (fContext->getFontCache()->freeUnusedPlot(fStrike, glyph) && fStrike->addGlyphToAtlas(glyph, scaler)) { goto HAS_ATLAS; } } if (NULL == glyph->fPath) { SkPath* path = SkNEW(SkPath); if (!scaler->getGlyphPath(glyph->glyphID(), path)) { // flag the glyph as being dead? delete path; return true; } glyph->fPath = path; } // flush any accumulated draws before drawing this glyph as a path. this->flush(); GrContext::AutoMatrix am; SkMatrix ctm; ctm.setScale(fTextRatio, fTextRatio); ctm.postTranslate(sx - dx, sy - dy); GrPaint tmpPaint(fPaint); am.setPreConcat(fContext, ctm, &tmpPaint); GrStrokeInfo strokeInfo(SkStrokeRec::kFill_InitStyle); fContext->drawPath(tmpPaint, *glyph->fPath, strokeInfo); // remove this glyph from the vertices we need to allocate fTotalVertexCount -= kVerticesPerGlyph; return true; } HAS_ATLAS: SkASSERT(glyph->fPlot); GrDrawTarget::DrawToken drawToken = fDrawTarget->getCurrentDrawToken(); glyph->fPlot->setDrawToken(drawToken); GrTexture* texture = glyph->fPlot->texture(); SkASSERT(texture); if (fCurrTexture != texture || fCurrVertex + kVerticesPerGlyph > fTotalVertexCount) { this->flush(); fCurrTexture = texture; fCurrTexture->ref(); } bool useColorVerts = !fUseLCDText; if (NULL == fVertices) { int maxQuadVertices = kVerticesPerGlyph * fContext->getQuadIndexBuffer()->maxQuads(); fAllocVertexCount = SkMin32(fTotalVertexCount, maxQuadVertices); fVertices = alloc_vertices(fDrawTarget, fAllocVertexCount, useColorVerts); } SkFixed tx = SkIntToFixed(glyph->fAtlasLocation.fX + SK_DistanceFieldInset); SkFixed ty = SkIntToFixed(glyph->fAtlasLocation.fY + SK_DistanceFieldInset); SkFixed tw = SkIntToFixed(glyph->fBounds.width() - 2*SK_DistanceFieldInset); SkFixed th = SkIntToFixed(glyph->fBounds.height() - 2*SK_DistanceFieldInset); fVertexBounds.joinNonEmptyArg(glyphRect); size_t vertSize = get_vertex_stride(useColorVerts); SkPoint* positions = reinterpret_cast<SkPoint*>( reinterpret_cast<intptr_t>(fVertices) + vertSize * fCurrVertex); positions->setRectFan(glyphRect.fLeft, glyphRect.fTop, glyphRect.fRight, glyphRect.fBottom, vertSize); // The texture coords are last in both the with and without color vertex layouts. SkPoint* textureCoords = reinterpret_cast<SkPoint*>( reinterpret_cast<intptr_t>(positions) + vertSize - sizeof(SkPoint)); textureCoords->setRectFan(SkFixedToFloat(texture->texturePriv().normalizeFixedX(tx)), SkFixedToFloat(texture->texturePriv().normalizeFixedY(ty)), SkFixedToFloat(texture->texturePriv().normalizeFixedX(tx + tw)), SkFixedToFloat(texture->texturePriv().normalizeFixedY(ty + th)), vertSize); if (useColorVerts) { // color comes after position. GrColor* colors = reinterpret_cast<GrColor*>(positions + 1); for (int i = 0; i < 4; ++i) { *colors = fPaint.getColor(); colors = reinterpret_cast<GrColor*>(reinterpret_cast<intptr_t>(colors) + vertSize); } } fCurrVertex += 4; return true; }
void GrDistanceFieldTextContext::drawPackedGlyph(GrGlyph::PackedID packed, GrFixed vx, GrFixed vy, GrFontScaler* scaler) { if (NULL == fDrawTarget) { return; } if (NULL == fStrike) { fStrike = fContext->getFontCache()->getStrike(scaler, true); } GrGlyph* glyph = fStrike->getGlyph(packed, scaler); if (NULL == glyph || glyph->fBounds.isEmpty()) { return; } SkScalar sx = SkFixedToScalar(vx); SkScalar sy = SkFixedToScalar(vy); /* // not valid, need to find a different solution for this vx += SkIntToFixed(glyph->fBounds.fLeft); vy += SkIntToFixed(glyph->fBounds.fTop); // keep them as ints until we've done the clip-test GrFixed width = glyph->fBounds.width(); GrFixed height = glyph->fBounds.height(); // check if we clipped out if (true || NULL == glyph->fPlot) { int x = vx >> 16; int y = vy >> 16; if (fClipRect.quickReject(x, y, x + width, y + height)) { // SkCLZ(3); // so we can set a break-point in the debugger return; } } */ if (NULL == glyph->fPlot) { if (fStrike->getGlyphAtlas(glyph, scaler)) { goto HAS_ATLAS; } // try to clear out an unused plot before we flush fContext->getFontCache()->freePlotExceptFor(fStrike); if (fStrike->getGlyphAtlas(glyph, scaler)) { goto HAS_ATLAS; } if (c_DumpFontCache) { #ifdef SK_DEVELOPER fContext->getFontCache()->dump(); #endif } // before we purge the cache, we must flush any accumulated draws this->flushGlyphs(); fContext->flush(); // try to purge fContext->getFontCache()->purgeExceptFor(fStrike); // need to use new flush count here if (fStrike->getGlyphAtlas(glyph, scaler)) { goto HAS_ATLAS; } if (NULL == glyph->fPath) { SkPath* path = SkNEW(SkPath); if (!scaler->getGlyphPath(glyph->glyphID(), path)) { // flag the glyph as being dead? delete path; return; } glyph->fPath = path; } GrContext::AutoMatrix am; SkMatrix translate; translate.setTranslate(sx, sy); GrPaint tmpPaint(fPaint); am.setPreConcat(fContext, translate, &tmpPaint); SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle); fContext->drawPath(tmpPaint, *glyph->fPath, stroke); return; } HAS_ATLAS: SkASSERT(glyph->fPlot); GrDrawTarget::DrawToken drawToken = fDrawTarget->getCurrentDrawToken(); glyph->fPlot->setDrawToken(drawToken); GrTexture* texture = glyph->fPlot->texture(); SkASSERT(texture); if (fCurrTexture != texture || fCurrVertex + 4 > fMaxVertices) { this->flushGlyphs(); fCurrTexture = texture; fCurrTexture->ref(); } if (NULL == fVertices) { // If we need to reserve vertices allow the draw target to suggest // a number of verts to reserve and whether to perform a flush. fMaxVertices = kMinRequestedVerts; fDrawTarget->drawState()->setVertexAttribs<gTextVertexAttribs>( SK_ARRAY_COUNT(gTextVertexAttribs)); bool flush = fDrawTarget->geometryHints(&fMaxVertices, NULL); if (flush) { this->flushGlyphs(); fContext->flush(); fDrawTarget->drawState()->setVertexAttribs<gTextVertexAttribs>( SK_ARRAY_COUNT(gTextVertexAttribs)); } fMaxVertices = kDefaultRequestedVerts; // ignore return, no point in flushing again. fDrawTarget->geometryHints(&fMaxVertices, NULL); int maxQuadVertices = 4 * fContext->getQuadIndexBuffer()->maxQuads(); if (fMaxVertices < kMinRequestedVerts) { fMaxVertices = kDefaultRequestedVerts; } else if (fMaxVertices > maxQuadVertices) { // don't exceed the limit of the index buffer fMaxVertices = maxQuadVertices; } bool success = fDrawTarget->reserveVertexAndIndexSpace(fMaxVertices, 0, GrTCast<void**>(&fVertices), NULL); GrAlwaysAssert(success); SkASSERT(2*sizeof(GrPoint) == fDrawTarget->getDrawState().getVertexSize()); } SkScalar dx = SkIntToScalar(glyph->fBounds.fLeft); SkScalar dy = SkIntToScalar(glyph->fBounds.fTop); SkScalar width = SkIntToScalar(glyph->fBounds.width()); SkScalar height = SkIntToScalar(glyph->fBounds.height()); SkScalar scale = fTextRatio; dx *= scale; dy *= scale; sx += dx; sy += dy; width *= scale; height *= scale; GrFixed tx = SkIntToFixed(glyph->fAtlasLocation.fX); GrFixed ty = SkIntToFixed(glyph->fAtlasLocation.fY); GrFixed tw = SkIntToFixed(glyph->fBounds.width()); GrFixed th = SkIntToFixed(glyph->fBounds.height()); fVertices[2*fCurrVertex].setRectFan(sx, sy, sx + width, sy + height, 2 * sizeof(SkPoint)); fVertices[2*fCurrVertex+1].setRectFan(SkFixedToFloat(texture->normalizeFixedX(tx)), SkFixedToFloat(texture->normalizeFixedY(ty)), SkFixedToFloat(texture->normalizeFixedX(tx + tw)), SkFixedToFloat(texture->normalizeFixedY(ty + th)), 2 * sizeof(SkPoint)); fCurrVertex += 4; }