kA8_GrMaskFormat, //!< 1-byte per pixel
kA565_GrMaskFormat, //!< 2-bytes per pixel
kA888_GrMaskFormat, //!< 4-bytes per pixel
+ kARGB_GrMaskFormat, //!< 4-bytes per pixel, color format
- kLast_GrMaskFormat = kA888_GrMaskFormat
+ kLast_GrMaskFormat = kARGB_GrMaskFormat
};
static const int kMaskFormatCount = kLast_GrMaskFormat + 1;
* Return the number of bytes-per-pixel for the specified mask format.
*/
static inline int GrMaskFormatBytesPerPixel(GrMaskFormat format) {
- SkASSERT((unsigned)format <= 2);
+ SkASSERT((unsigned)format <= 3);
// kA8 (0) -> 1
// kA565 (1) -> 2
// kA888 (2) -> 4
- return 1 << (int)format;
+ // kARGB (3) -> 4
+ static const int sBytesPerPixel[] = { 1, 2, 4, 4 };
+ SK_COMPILE_ASSERT(SK_ARRAY_COUNT(sBytesPerPixel) == kMaskFormatCount, array_size_mismatch);
+
+ return sBytesPerPixel[(int) format];
}
/**
GrCustomCoordsTextureEffect::Create(fCurrTexture, params),
kGlyphCoordsAttributeIndex)->unref();
- if (!GrPixelConfigIsAlphaOnly(fCurrTexture->config())) {
+ if (NULL != fStrike && kARGB_GrMaskFormat == fStrike->getMaskFormat()) {
+ drawState->setBlendFunc(fPaint.getSrcBlendCoeff(), fPaint.getDstBlendCoeff());
+ drawState->setColor(0xffffffff);
+ } else if (!GrPixelConfigIsAlphaOnly(fCurrTexture->config())) {
if (kOne_GrBlendCoeff != fPaint.getSrcBlendCoeff() ||
kISA_GrBlendCoeff != fPaint.getDstBlendCoeff() ||
fPaint.numColorStages()) {
GrFontCache::GrFontCache(GrGpu* gpu) : fGpu(gpu) {
gpu->ref();
- for (int i = 0; i < kMaskFormatCount; ++i) {
+ for (int i = 0; i < kAtlasCount; ++i) {
fAtlasMgr[i] = NULL;
}
GrFontCache::~GrFontCache() {
fCache.deleteAll();
- for (int i = 0; i < kMaskFormatCount; ++i) {
+ for (int i = 0; i < kAtlasCount; ++i) {
delete fAtlasMgr[i];
}
fGpu->unref();
}
static GrPixelConfig mask_format_to_pixel_config(GrMaskFormat format) {
- switch (format) {
- case kA8_GrMaskFormat:
- return kAlpha_8_GrPixelConfig;
- case kA565_GrMaskFormat:
- return kRGB_565_GrPixelConfig;
- case kA888_GrMaskFormat:
- return kSkia8888_GrPixelConfig;
- default:
- SkDEBUGFAIL("unknown maskformat");
- }
- return kUnknown_GrPixelConfig;
+ static const GrPixelConfig sPixelConfigs[] = {
+ kAlpha_8_GrPixelConfig,
+ kRGB_565_GrPixelConfig,
+ kSkia8888_GrPixelConfig,
+ kSkia8888_GrPixelConfig
+ };
+ SK_COMPILE_ASSERT(SK_ARRAY_COUNT(sPixelConfigs) == kMaskFormatCount, array_size_mismatch);
+
+ return sPixelConfigs[format];
+}
+
+static int mask_format_to_atlas_index(GrMaskFormat format) {
+ static const int sAtlasIndices[] = {
+ GrFontCache::kA8_AtlasType,
+ GrFontCache::k565_AtlasType,
+ GrFontCache::k8888_AtlasType,
+ GrFontCache::k8888_AtlasType
+ };
+ SK_COMPILE_ASSERT(SK_ARRAY_COUNT(sAtlasIndices) == kMaskFormatCount, array_size_mismatch);
+
+ SkASSERT(sAtlasIndices[format] < GrFontCache::kAtlasCount);
+ return sAtlasIndices[format];
}
GrTextStrike* GrFontCache::generateStrike(GrFontScaler* scaler,
const Key& key) {
GrMaskFormat format = scaler->getMaskFormat();
GrPixelConfig config = mask_format_to_pixel_config(format);
- if (NULL == fAtlasMgr[format]) {
- fAtlasMgr[format] = SkNEW_ARGS(GrAtlasMgr, (fGpu, config));
+ int atlasIndex = mask_format_to_atlas_index(format);
+ if (NULL == fAtlasMgr[atlasIndex]) {
+ fAtlasMgr[atlasIndex] = SkNEW_ARGS(GrAtlasMgr, (fGpu, config));
}
GrTextStrike* strike = SkNEW_ARGS(GrTextStrike,
- (this, scaler->getKey(), format, fAtlasMgr[format]));
+ (this, scaler->getKey(), format, fAtlasMgr[atlasIndex]));
fCache.insert(key, strike);
if (fHead) {
void GrFontCache::freeAll() {
fCache.deleteAll();
- for (int i = 0; i < kMaskFormatCount; ++i) {
+ for (int i = 0; i < kAtlasCount; ++i) {
delete fAtlasMgr[i];
fAtlasMgr[i] = NULL;
}
#ifdef SK_DEVELOPER
void GrFontCache::dump() const {
static int gDumpCount = 0;
- for (int i = 0; i < kMaskFormatCount; ++i) {
+ for (int i = 0; i < kAtlasCount; ++i) {
if (NULL != fAtlasMgr[i]) {
GrTexture* texture = fAtlasMgr[i]->getTexture();
if (NULL != texture) {
void dump() const;
#endif
+ enum AtlasType {
+ kA8_AtlasType, //!< 1-byte per pixel
+ k565_AtlasType, //!< 2-bytes per pixel
+ k8888_AtlasType, //!< 4-bytes per pixel
+
+ kLast_AtlasType = k8888_AtlasType
+ };
+ static const int kAtlasCount = kLast_AtlasType + 1;
+
private:
friend class GrFontPurgeListener;
GrTextStrike* fTail;
GrGpu* fGpu;
- GrAtlasMgr* fAtlasMgr[kMaskFormatCount];
+ GrAtlasMgr* fAtlasMgr[kAtlasCount];
GrTextStrike* generateStrike(GrFontScaler*, const Key&);
inline void detachStrikeFromList(GrTextStrike*);
return kA8_GrMaskFormat;
case SkMask::kLCD16_Format:
return kA565_GrMaskFormat;
- // TODO: properly support kARGB32_Format.
- case SkMask::kARGB32_Format:
case SkMask::kLCD32_Format:
return kA888_GrMaskFormat;
+ case SkMask::kARGB32_Format:
+ return kARGB_GrMaskFormat;
default:
SkDEBUGFAIL("unsupported SkMask::Format");
return kA8_GrMaskFormat;
expand_bits(rgba8888, bits, width, height, dstRB, srcRB);
break;
}
- default:
- GrCrash("Unknown GrMaskFormat");
+ default:
+ GrCrash("Invalid GrMaskFormat");
}
} else if (srcRB == dstRB) {
memcpy(dst, src, dstRB * height);