123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570 |
- /*
- * Copyright 2015 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
- #include "src/gpu/ops/GrAtlasTextOp.h"
- #include "include/core/SkPoint3.h"
- #include "include/private/GrRecordingContext.h"
- #include "src/core/SkMathPriv.h"
- #include "src/core/SkMatrixPriv.h"
- #include "src/core/SkStrikeCache.h"
- #include "src/gpu/GrCaps.h"
- #include "src/gpu/GrMemoryPool.h"
- #include "src/gpu/GrOpFlushState.h"
- #include "src/gpu/GrRecordingContextPriv.h"
- #include "src/gpu/GrResourceProvider.h"
- #include "src/gpu/effects/GrBitmapTextGeoProc.h"
- #include "src/gpu/effects/GrDistanceFieldGeoProc.h"
- #include "src/gpu/text/GrAtlasManager.h"
- #include "src/gpu/text/GrStrikeCache.h"
- ///////////////////////////////////////////////////////////////////////////////////////////////////
- std::unique_ptr<GrAtlasTextOp> GrAtlasTextOp::MakeBitmap(GrRecordingContext* context,
- GrPaint&& paint,
- GrMaskFormat maskFormat,
- int glyphCount,
- bool needsTransform) {
- GrOpMemoryPool* pool = context->priv().opMemoryPool();
- std::unique_ptr<GrAtlasTextOp> op = pool->allocate<GrAtlasTextOp>(std::move(paint));
- switch (maskFormat) {
- case kA8_GrMaskFormat:
- op->fMaskType = kGrayscaleCoverageMask_MaskType;
- break;
- case kA565_GrMaskFormat:
- op->fMaskType = kLCDCoverageMask_MaskType;
- break;
- case kARGB_GrMaskFormat:
- op->fMaskType = kColorBitmapMask_MaskType;
- break;
- }
- op->fNumGlyphs = glyphCount;
- op->fGeoCount = 1;
- op->fLuminanceColor = 0;
- op->fNeedsGlyphTransform = needsTransform;
- return op;
- }
- std::unique_ptr<GrAtlasTextOp> GrAtlasTextOp::MakeDistanceField(
- GrRecordingContext* context,
- GrPaint&& paint,
- int glyphCount,
- const GrDistanceFieldAdjustTable* distanceAdjustTable,
- bool useGammaCorrectDistanceTable,
- SkColor luminanceColor,
- const SkSurfaceProps& props,
- bool isAntiAliased,
- bool useLCD) {
- GrOpMemoryPool* pool = context->priv().opMemoryPool();
- std::unique_ptr<GrAtlasTextOp> op = pool->allocate<GrAtlasTextOp>(std::move(paint));
- bool isBGR = SkPixelGeometryIsBGR(props.pixelGeometry());
- bool isLCD = useLCD && SkPixelGeometryIsH(props.pixelGeometry());
- op->fMaskType = !isAntiAliased ? kAliasedDistanceField_MaskType
- : isLCD ? (isBGR ? kLCDBGRDistanceField_MaskType
- : kLCDDistanceField_MaskType)
- : kGrayscaleDistanceField_MaskType;
- op->fDistanceAdjustTable.reset(SkRef(distanceAdjustTable));
- op->fUseGammaCorrectDistanceTable = useGammaCorrectDistanceTable;
- op->fLuminanceColor = luminanceColor;
- op->fNumGlyphs = glyphCount;
- op->fGeoCount = 1;
- return op;
- }
- static const int kDistanceAdjustLumShift = 5;
- void GrAtlasTextOp::init() {
- const Geometry& geo = fGeoData[0];
- if (this->usesDistanceFields()) {
- bool isLCD = this->isLCD();
- const SkMatrix& viewMatrix = geo.fViewMatrix;
- fDFGPFlags = viewMatrix.isSimilarity() ? kSimilarity_DistanceFieldEffectFlag : 0;
- fDFGPFlags |= viewMatrix.isScaleTranslate() ? kScaleOnly_DistanceFieldEffectFlag : 0;
- fDFGPFlags |= viewMatrix.hasPerspective() ? kPerspective_DistanceFieldEffectFlag : 0;
- fDFGPFlags |= fUseGammaCorrectDistanceTable ? kGammaCorrect_DistanceFieldEffectFlag : 0;
- fDFGPFlags |= (kAliasedDistanceField_MaskType == fMaskType)
- ? kAliased_DistanceFieldEffectFlag
- : 0;
- if (isLCD) {
- fDFGPFlags |= kUseLCD_DistanceFieldEffectFlag;
- fDFGPFlags |=
- (kLCDBGRDistanceField_MaskType == fMaskType) ? kBGR_DistanceFieldEffectFlag : 0;
- }
- fNeedsGlyphTransform = true;
- }
- SkRect bounds;
- geo.fBlob->computeSubRunBounds(&bounds, geo.fRun, geo.fSubRun, geo.fViewMatrix, geo.fX, geo.fY,
- fNeedsGlyphTransform);
- // We don't have tight bounds on the glyph paths in device space. For the purposes of bounds
- // we treat this as a set of non-AA rects rendered with a texture.
- this->setBounds(bounds, HasAABloat::kNo, IsZeroArea::kNo);
- }
- void GrAtlasTextOp::visitProxies(const VisitProxyFunc& func) const {
- fProcessors.visitProxies(func);
- }
- #ifdef SK_DEBUG
- SkString GrAtlasTextOp::dumpInfo() const {
- SkString str;
- for (int i = 0; i < fGeoCount; ++i) {
- str.appendf("%d: Color: 0x%08x Trans: %.2f,%.2f Runs: %d\n",
- i,
- fGeoData[i].fColor.toBytes_RGBA(),
- fGeoData[i].fX,
- fGeoData[i].fY,
- fGeoData[i].fBlob->runCountLimit());
- }
- str += fProcessors.dumpProcessors();
- str += INHERITED::dumpInfo();
- return str;
- }
- #endif
- GrDrawOp::FixedFunctionFlags GrAtlasTextOp::fixedFunctionFlags() const {
- return FixedFunctionFlags::kNone;
- }
- GrProcessorSet::Analysis GrAtlasTextOp::finalize(
- const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
- GrClampType clampType) {
- GrProcessorAnalysisCoverage coverage;
- GrProcessorAnalysisColor color;
- if (kColorBitmapMask_MaskType == fMaskType) {
- color.setToUnknown();
- } else {
- color.setToConstant(this->color());
- }
- switch (fMaskType) {
- case kGrayscaleCoverageMask_MaskType:
- case kAliasedDistanceField_MaskType:
- case kGrayscaleDistanceField_MaskType:
- coverage = GrProcessorAnalysisCoverage::kSingleChannel;
- break;
- case kLCDCoverageMask_MaskType:
- case kLCDDistanceField_MaskType:
- case kLCDBGRDistanceField_MaskType:
- coverage = GrProcessorAnalysisCoverage::kLCD;
- break;
- case kColorBitmapMask_MaskType:
- coverage = GrProcessorAnalysisCoverage::kNone;
- break;
- }
- auto analysis = fProcessors.finalize(
- color, coverage, clip, &GrUserStencilSettings::kUnused, hasMixedSampledCoverage, caps,
- clampType, &fGeoData[0].fColor);
- fUsesLocalCoords = analysis.usesLocalCoords();
- return analysis;
- }
- static void clip_quads(const SkIRect& clipRect, char* currVertex, const char* blobVertices,
- size_t vertexStride, int glyphCount) {
- for (int i = 0; i < glyphCount; ++i) {
- const SkPoint* blobPositionLT = reinterpret_cast<const SkPoint*>(blobVertices);
- const SkPoint* blobPositionRB =
- reinterpret_cast<const SkPoint*>(blobVertices + 3 * vertexStride);
- // positions for bitmap glyphs are pixel boundary aligned
- SkIRect positionRect = SkIRect::MakeLTRB(SkScalarRoundToInt(blobPositionLT->fX),
- SkScalarRoundToInt(blobPositionLT->fY),
- SkScalarRoundToInt(blobPositionRB->fX),
- SkScalarRoundToInt(blobPositionRB->fY));
- if (clipRect.contains(positionRect)) {
- memcpy(currVertex, blobVertices, 4 * vertexStride);
- currVertex += 4 * vertexStride;
- } else {
- // Pull out some more data that we'll need.
- // In the LCD case the color will be garbage, but we'll overwrite it with the texcoords
- // and it avoids a lot of conditionals.
- auto color = *reinterpret_cast<const SkColor*>(blobVertices + sizeof(SkPoint));
- size_t coordOffset = vertexStride - 2*sizeof(uint16_t);
- auto* blobCoordsLT = reinterpret_cast<const uint16_t*>(blobVertices + coordOffset);
- auto* blobCoordsRB = reinterpret_cast<const uint16_t*>(blobVertices + 3 * vertexStride +
- coordOffset);
- // Pull out the texel coordinates and texture index bits
- uint16_t coordsRectL = blobCoordsLT[0] >> 1;
- uint16_t coordsRectT = blobCoordsLT[1] >> 1;
- uint16_t coordsRectR = blobCoordsRB[0] >> 1;
- uint16_t coordsRectB = blobCoordsRB[1] >> 1;
- uint16_t pageIndexX = blobCoordsLT[0] & 0x1;
- uint16_t pageIndexY = blobCoordsLT[1] & 0x1;
- int positionRectWidth = positionRect.width();
- int positionRectHeight = positionRect.height();
- SkASSERT(positionRectWidth == (coordsRectR - coordsRectL));
- SkASSERT(positionRectHeight == (coordsRectB - coordsRectT));
- // Clip position and texCoords to the clipRect
- unsigned int delta;
- delta = SkTMin(SkTMax(clipRect.fLeft - positionRect.fLeft, 0), positionRectWidth);
- coordsRectL += delta;
- positionRect.fLeft += delta;
- delta = SkTMin(SkTMax(clipRect.fTop - positionRect.fTop, 0), positionRectHeight);
- coordsRectT += delta;
- positionRect.fTop += delta;
- delta = SkTMin(SkTMax(positionRect.fRight - clipRect.fRight, 0), positionRectWidth);
- coordsRectR -= delta;
- positionRect.fRight -= delta;
- delta = SkTMin(SkTMax(positionRect.fBottom - clipRect.fBottom, 0), positionRectHeight);
- coordsRectB -= delta;
- positionRect.fBottom -= delta;
- // Repack texel coordinates and index
- coordsRectL = coordsRectL << 1 | pageIndexX;
- coordsRectT = coordsRectT << 1 | pageIndexY;
- coordsRectR = coordsRectR << 1 | pageIndexX;
- coordsRectB = coordsRectB << 1 | pageIndexY;
- // Set new positions and coords
- SkPoint* currPosition = reinterpret_cast<SkPoint*>(currVertex);
- currPosition->fX = positionRect.fLeft;
- currPosition->fY = positionRect.fTop;
- *(reinterpret_cast<SkColor*>(currVertex + sizeof(SkPoint))) = color;
- uint16_t* currCoords = reinterpret_cast<uint16_t*>(currVertex + coordOffset);
- currCoords[0] = coordsRectL;
- currCoords[1] = coordsRectT;
- currVertex += vertexStride;
- currPosition = reinterpret_cast<SkPoint*>(currVertex);
- currPosition->fX = positionRect.fLeft;
- currPosition->fY = positionRect.fBottom;
- *(reinterpret_cast<SkColor*>(currVertex + sizeof(SkPoint))) = color;
- currCoords = reinterpret_cast<uint16_t*>(currVertex + coordOffset);
- currCoords[0] = coordsRectL;
- currCoords[1] = coordsRectB;
- currVertex += vertexStride;
- currPosition = reinterpret_cast<SkPoint*>(currVertex);
- currPosition->fX = positionRect.fRight;
- currPosition->fY = positionRect.fTop;
- *(reinterpret_cast<SkColor*>(currVertex + sizeof(SkPoint))) = color;
- currCoords = reinterpret_cast<uint16_t*>(currVertex + coordOffset);
- currCoords[0] = coordsRectR;
- currCoords[1] = coordsRectT;
- currVertex += vertexStride;
- currPosition = reinterpret_cast<SkPoint*>(currVertex);
- currPosition->fX = positionRect.fRight;
- currPosition->fY = positionRect.fBottom;
- *(reinterpret_cast<SkColor*>(currVertex + sizeof(SkPoint))) = color;
- currCoords = reinterpret_cast<uint16_t*>(currVertex + coordOffset);
- currCoords[0] = coordsRectR;
- currCoords[1] = coordsRectB;
- currVertex += vertexStride;
- }
- blobVertices += 4 * vertexStride;
- }
- }
- void GrAtlasTextOp::onPrepareDraws(Target* target) {
- auto resourceProvider = target->resourceProvider();
- // if we have RGB, then we won't have any SkShaders so no need to use a localmatrix.
- // TODO actually only invert if we don't have RGBA
- SkMatrix localMatrix;
- if (this->usesLocalCoords() && !fGeoData[0].fViewMatrix.invert(&localMatrix)) {
- return;
- }
- GrAtlasManager* atlasManager = target->atlasManager();
- GrStrikeCache* glyphCache = target->glyphCache();
- GrMaskFormat maskFormat = this->maskFormat();
- unsigned int numActiveProxies;
- const sk_sp<GrTextureProxy>* proxies = atlasManager->getProxies(maskFormat, &numActiveProxies);
- if (!proxies) {
- SkDebugf("Could not allocate backing texture for atlas\n");
- return;
- }
- SkASSERT(proxies[0]);
- static constexpr int kMaxTextures = GrBitmapTextGeoProc::kMaxTextures;
- GR_STATIC_ASSERT(GrDistanceFieldA8TextGeoProc::kMaxTextures == kMaxTextures);
- GR_STATIC_ASSERT(GrDistanceFieldLCDTextGeoProc::kMaxTextures == kMaxTextures);
- auto fixedDynamicState = target->makeFixedDynamicState(kMaxTextures);
- for (unsigned i = 0; i < numActiveProxies; ++i) {
- fixedDynamicState->fPrimitiveProcessorTextures[i] = proxies[i].get();
- }
- FlushInfo flushInfo;
- flushInfo.fFixedDynamicState = fixedDynamicState;
- bool vmPerspective = fGeoData[0].fViewMatrix.hasPerspective();
- if (this->usesDistanceFields()) {
- flushInfo.fGeometryProcessor = this->setupDfProcessor(*target->caps().shaderCaps(),
- proxies, numActiveProxies);
- } else {
- GrSamplerState samplerState = fNeedsGlyphTransform ? GrSamplerState::ClampBilerp()
- : GrSamplerState::ClampNearest();
- flushInfo.fGeometryProcessor = GrBitmapTextGeoProc::Make(
- *target->caps().shaderCaps(), this->color(), false, proxies, numActiveProxies,
- samplerState, maskFormat, localMatrix, vmPerspective);
- }
- flushInfo.fGlyphsToFlush = 0;
- size_t vertexStride = flushInfo.fGeometryProcessor->vertexStride();
- int glyphCount = this->numGlyphs();
- void* vertices = target->makeVertexSpace(vertexStride, glyphCount * kVerticesPerGlyph,
- &flushInfo.fVertexBuffer, &flushInfo.fVertexOffset);
- flushInfo.fIndexBuffer = resourceProvider->refQuadIndexBuffer();
- if (!vertices || !flushInfo.fVertexBuffer) {
- SkDebugf("Could not allocate vertices\n");
- return;
- }
- char* currVertex = reinterpret_cast<char*>(vertices);
- SkExclusiveStrikePtr autoGlyphCache;
- // each of these is a SubRun
- for (int i = 0; i < fGeoCount; i++) {
- const Geometry& args = fGeoData[i];
- Blob* blob = args.fBlob;
- // TODO4F: Preserve float colors
- GrTextBlob::VertexRegenerator regenerator(
- resourceProvider, blob, args.fRun, args.fSubRun, args.fViewMatrix, args.fX, args.fY,
- args.fColor.toBytes_RGBA(), target->deferredUploadTarget(), glyphCache,
- atlasManager, &autoGlyphCache);
- bool done = false;
- while (!done) {
- GrTextBlob::VertexRegenerator::Result result;
- if (!regenerator.regenerate(&result)) {
- break;
- }
- done = result.fFinished;
- // Copy regenerated vertices from the blob to our vertex buffer.
- size_t vertexBytes = result.fGlyphsRegenerated * kVerticesPerGlyph * vertexStride;
- if (args.fClipRect.isEmpty()) {
- memcpy(currVertex, result.fFirstVertex, vertexBytes);
- } else {
- SkASSERT(!vmPerspective);
- clip_quads(args.fClipRect, currVertex, result.fFirstVertex, vertexStride,
- result.fGlyphsRegenerated);
- }
- if (fNeedsGlyphTransform && !args.fViewMatrix.isIdentity()) {
- // We always do the distance field view matrix transformation after copying rather
- // than during blob vertex generation time in the blob as handling successive
- // arbitrary transformations would be complicated and accumulate error.
- if (args.fViewMatrix.hasPerspective()) {
- auto* pos = reinterpret_cast<SkPoint3*>(currVertex);
- SkMatrixPriv::MapHomogeneousPointsWithStride(
- args.fViewMatrix, pos, vertexStride, pos, vertexStride,
- result.fGlyphsRegenerated * kVerticesPerGlyph);
- } else {
- auto* pos = reinterpret_cast<SkPoint*>(currVertex);
- SkMatrixPriv::MapPointsWithStride(
- args.fViewMatrix, pos, vertexStride,
- result.fGlyphsRegenerated * kVerticesPerGlyph);
- }
- }
- flushInfo.fGlyphsToFlush += result.fGlyphsRegenerated;
- if (!result.fFinished) {
- this->flush(target, &flushInfo);
- }
- currVertex += vertexBytes;
- }
- }
- this->flush(target, &flushInfo);
- }
- void GrAtlasTextOp::onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) {
- flushState->executeDrawsAndUploadsForMeshDrawOp(
- this, chainBounds, std::move(fProcessors), GrPipeline::InputFlags::kNone);
- }
- void GrAtlasTextOp::flush(GrMeshDrawOp::Target* target, FlushInfo* flushInfo) const {
- if (!flushInfo->fGlyphsToFlush) {
- return;
- }
- auto atlasManager = target->atlasManager();
- GrGeometryProcessor* gp = flushInfo->fGeometryProcessor.get();
- GrMaskFormat maskFormat = this->maskFormat();
- unsigned int numActiveProxies;
- const sk_sp<GrTextureProxy>* proxies = atlasManager->getProxies(maskFormat, &numActiveProxies);
- SkASSERT(proxies);
- if (gp->numTextureSamplers() != (int) numActiveProxies) {
- // During preparation the number of atlas pages has increased.
- // Update the proxies used in the GP to match.
- for (unsigned i = gp->numTextureSamplers(); i < numActiveProxies; ++i) {
- flushInfo->fFixedDynamicState->fPrimitiveProcessorTextures[i] = proxies[i].get();
- }
- if (this->usesDistanceFields()) {
- if (this->isLCD()) {
- reinterpret_cast<GrDistanceFieldLCDTextGeoProc*>(gp)->addNewProxies(
- proxies, numActiveProxies, GrSamplerState::ClampBilerp());
- } else {
- reinterpret_cast<GrDistanceFieldA8TextGeoProc*>(gp)->addNewProxies(
- proxies, numActiveProxies, GrSamplerState::ClampBilerp());
- }
- } else {
- GrSamplerState samplerState = fNeedsGlyphTransform ? GrSamplerState::ClampBilerp()
- : GrSamplerState::ClampNearest();
- reinterpret_cast<GrBitmapTextGeoProc*>(gp)->addNewProxies(proxies, numActiveProxies,
- samplerState);
- }
- }
- int maxGlyphsPerDraw = static_cast<int>(flushInfo->fIndexBuffer->size() / sizeof(uint16_t) / 6);
- GrMesh* mesh = target->allocMesh(GrPrimitiveType::kTriangles);
- mesh->setIndexedPatterned(flushInfo->fIndexBuffer, kIndicesPerGlyph, kVerticesPerGlyph,
- flushInfo->fGlyphsToFlush, maxGlyphsPerDraw);
- mesh->setVertexData(flushInfo->fVertexBuffer, flushInfo->fVertexOffset);
- target->recordDraw(
- flushInfo->fGeometryProcessor, mesh, 1, flushInfo->fFixedDynamicState, nullptr);
- flushInfo->fVertexOffset += kVerticesPerGlyph * flushInfo->fGlyphsToFlush;
- flushInfo->fGlyphsToFlush = 0;
- }
- GrOp::CombineResult GrAtlasTextOp::onCombineIfPossible(GrOp* t, const GrCaps& caps) {
- GrAtlasTextOp* that = t->cast<GrAtlasTextOp>();
- if (fProcessors != that->fProcessors) {
- return CombineResult::kCannotCombine;
- }
- if (fMaskType != that->fMaskType) {
- return CombineResult::kCannotCombine;
- }
- const SkMatrix& thisFirstMatrix = fGeoData[0].fViewMatrix;
- const SkMatrix& thatFirstMatrix = that->fGeoData[0].fViewMatrix;
- if (this->usesLocalCoords() && !thisFirstMatrix.cheapEqualTo(thatFirstMatrix)) {
- return CombineResult::kCannotCombine;
- }
- if (fNeedsGlyphTransform != that->fNeedsGlyphTransform) {
- return CombineResult::kCannotCombine;
- }
- if (fNeedsGlyphTransform &&
- (thisFirstMatrix.hasPerspective() != thatFirstMatrix.hasPerspective())) {
- return CombineResult::kCannotCombine;
- }
- if (this->usesDistanceFields()) {
- if (fDFGPFlags != that->fDFGPFlags) {
- return CombineResult::kCannotCombine;
- }
- if (fLuminanceColor != that->fLuminanceColor) {
- return CombineResult::kCannotCombine;
- }
- } else {
- if (kColorBitmapMask_MaskType == fMaskType && this->color() != that->color()) {
- return CombineResult::kCannotCombine;
- }
- }
- // Keep the batch vertex buffer size below 32K so we don't have to create a special one
- // We use the largest possible vertex size for this
- static const int kVertexSize = sizeof(SkPoint) + sizeof(SkColor) + 2 * sizeof(uint16_t);
- static const int kMaxGlyphs = 32768 / (kVerticesPerGlyph * kVertexSize);
- if (this->fNumGlyphs + that->fNumGlyphs > kMaxGlyphs) {
- return CombineResult::kCannotCombine;
- }
- fNumGlyphs += that->numGlyphs();
- // Reallocate space for geo data if necessary and then import that geo's data.
- int newGeoCount = that->fGeoCount + fGeoCount;
- // We reallocate at a rate of 1.5x to try to get better total memory usage
- if (newGeoCount > fGeoDataAllocSize) {
- int newAllocSize = fGeoDataAllocSize + fGeoDataAllocSize / 2;
- while (newAllocSize < newGeoCount) {
- newAllocSize += newAllocSize / 2;
- }
- fGeoData.realloc(newAllocSize);
- fGeoDataAllocSize = newAllocSize;
- }
- // We steal the ref on the blobs from the other AtlasTextOp and set its count to 0 so that
- // it doesn't try to unref them.
- memcpy(&fGeoData[fGeoCount], that->fGeoData.get(), that->fGeoCount * sizeof(Geometry));
- #ifdef SK_DEBUG
- for (int i = 0; i < that->fGeoCount; ++i) {
- that->fGeoData.get()[i].fBlob = (Blob*)0x1;
- }
- #endif
- that->fGeoCount = 0;
- fGeoCount = newGeoCount;
- return CombineResult::kMerged;
- }
- // TODO trying to figure out why lcd is so whack
- // (see comments in GrTextContext::ComputeCanonicalColor)
- sk_sp<GrGeometryProcessor> GrAtlasTextOp::setupDfProcessor(const GrShaderCaps& caps,
- const sk_sp<GrTextureProxy>* proxies,
- unsigned int numActiveProxies) const {
- bool isLCD = this->isLCD();
- SkMatrix localMatrix = SkMatrix::I();
- if (this->usesLocalCoords()) {
- // If this fails we'll just use I().
- bool result = fGeoData[0].fViewMatrix.invert(&localMatrix);
- (void)result;
- }
- // see if we need to create a new effect
- if (isLCD) {
- float redCorrection = fDistanceAdjustTable->getAdjustment(
- SkColorGetR(fLuminanceColor) >> kDistanceAdjustLumShift,
- fUseGammaCorrectDistanceTable);
- float greenCorrection = fDistanceAdjustTable->getAdjustment(
- SkColorGetG(fLuminanceColor) >> kDistanceAdjustLumShift,
- fUseGammaCorrectDistanceTable);
- float blueCorrection = fDistanceAdjustTable->getAdjustment(
- SkColorGetB(fLuminanceColor) >> kDistanceAdjustLumShift,
- fUseGammaCorrectDistanceTable);
- GrDistanceFieldLCDTextGeoProc::DistanceAdjust widthAdjust =
- GrDistanceFieldLCDTextGeoProc::DistanceAdjust::Make(
- redCorrection, greenCorrection, blueCorrection);
- return GrDistanceFieldLCDTextGeoProc::Make(caps, proxies, numActiveProxies,
- GrSamplerState::ClampBilerp(), widthAdjust,
- fDFGPFlags, localMatrix);
- } else {
- #ifdef SK_GAMMA_APPLY_TO_A8
- float correction = 0;
- if (kAliasedDistanceField_MaskType != fMaskType) {
- U8CPU lum = SkColorSpaceLuminance::computeLuminance(SK_GAMMA_EXPONENT,
- fLuminanceColor);
- correction = fDistanceAdjustTable->getAdjustment(lum >> kDistanceAdjustLumShift,
- fUseGammaCorrectDistanceTable);
- }
- return GrDistanceFieldA8TextGeoProc::Make(caps, proxies, numActiveProxies,
- GrSamplerState::ClampBilerp(),
- correction, fDFGPFlags, localMatrix);
- #else
- return GrDistanceFieldA8TextGeoProc::Make(caps, proxies, numActiveProxies,
- GrSamplerState::ClampBilerp(),
- fDFGPFlags, localMatrix);
- #endif
- }
- }
|