Tweak distance field path renderer behavior in gamma-correct mode

src/gpu/batches/GrAADistanceFieldPathRenderer.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAADistanceFieldPathRenderer.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 130 matching lines @@
         SkPath fPath;
         // The unique ID of the path involved in this draw. This may be different than the ID
         // in fPath since that path may have resulted from a SkStrokeRec::applyToPath call.
         uint32_t fGenID;
         SkStrokeRec fStroke;
         GrColor fColor;
         bool fAntiAlias;
     };
 
     static GrDrawBatch* Create(const Geometry& geometry, const SkMatrix& viewMatrix,
-                               GrBatchAtlas* atlas, PathCache* pathCache, PathDataList* pathList) {
-        return new AADistanceFieldPathBatch(geometry, viewMatrix, atlas, pathCache, pathList);
+                               GrBatchAtlas* atlas, PathCache* pathCache, PathDataList* pathList,
+                               bool gammaCorrect) {
+        return new AADistanceFieldPathBatch(geometry, viewMatrix, atlas, pathCache, pathList,
+                                            gammaCorrect);
     }
 
     const char* name() const override { return "AADistanceFieldPathBatch"; }
 
     void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
         color->setKnownFourComponents(fGeoData[0].fColor);
         coverage->setUnknownSingleComponent();
     }
@@ skipping 26 matching lines @@
         SkMatrix invert;
         if (this->usesLocalCoords() && !this->viewMatrix().invert(&invert)) {
             SkDebugf("Could not invert viewmatrix\n");
             return;
         }
 
         const SkMatrix& ctm = this->viewMatrix();
         uint32_t flags = 0;
         flags |= ctm.isScaleTranslate() ? kScaleOnly_DistanceFieldEffectFlag : 0;
         flags |= ctm.isSimilarity() ? kSimilarity_DistanceFieldEffectFlag : 0;
+        flags |= fGammaCorrect ? kGammaCorrect_DistanceFieldEffectFlag : 0;
 
         GrTextureParams params(SkShader::kRepeat_TileMode, GrTextureParams::kBilerp_FilterMode);
 
         FlushInfo flushInfo;
 
         // Setup GrGeometryProcessor
         GrBatchAtlas* atlas = fAtlas;
         flushInfo.fGeometryProcessor.reset(
                 GrDistanceFieldPathGeoProc::Create(this->color(),
                                                    this->viewMatrix(),
@@ skipping 80 matching lines @@
         }
 
         this->flush(target, &flushInfo);
     }
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
     AADistanceFieldPathBatch(const Geometry& geometry,
                              const SkMatrix& viewMatrix,
                              GrBatchAtlas* atlas,
-                             PathCache* pathCache, PathDataList* pathList)
+                             PathCache* pathCache, PathDataList* pathList,
+                             bool gammaCorrect)
         : INHERITED(ClassID()) {
         fBatch.fViewMatrix = viewMatrix;
         fGeoData.push_back(geometry);
 
         fAtlas = atlas;
         fPathCache = pathCache;
         fPathList = pathList;
+        fGammaCorrect = gammaCorrect;
 
         // Compute bounds
         fBounds = geometry.fPath.getBounds();
         viewMatrix.mapRect(&fBounds);
     }
 
     bool addPathToAtlas(GrVertexBatch::Target* target,
                         FlushInfo* flushInfo,
                         GrBatchAtlas* atlas,
                         PathData* pathData,
@@ skipping 200 matching lines @@
         bool fUsesLocalCoords;
         bool fColorIgnored;
         bool fCoverageIgnored;
     };
 
     BatchTracker fBatch;
     SkSTArray<1, Geometry, true> fGeoData;
     GrBatchAtlas* fAtlas;
     PathCache* fPathCache;
     PathDataList* fPathList;
+    bool fGammaCorrect;
 
     typedef GrVertexBatch INHERITED;
 };
 
 bool GrAADistanceFieldPathRenderer::onDrawPath(const DrawPathArgs& args) {
     GR_AUDIT_TRAIL_AUTO_FRAME(args.fTarget->getAuditTrail(),
                               "GrAADistanceFieldPathRenderer::onDrawPath");
     // we've already bailed on inverse filled paths, so this is safe
     if (args.fPath->isEmpty()) {
         return true;
@@ skipping 18 matching lines @@
     }
     geometry.fColor = args.fColor;
     geometry.fAntiAlias = args.fAntiAlias;
     // Note: this is the generation ID of the _original_ path. When a new path is
     // generated due to stroking it is important that the original path's id is used
     // for caching.
     geometry.fGenID = args.fPath->getGenerationID();
 
     SkAutoTUnref<GrDrawBatch> batch(AADistanceFieldPathBatch::Create(geometry,
                                                                      *args.fViewMatrix, fAtlas,
-                                                                     &fPathCache, &fPathList));
+                                                                     &fPathCache, &fPathList,
+                                                                     args.fGammaCorrect));
     args.fTarget->drawBatch(*args.fPipelineBuilder, batch);
 
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef GR_TEST_UTILS
 
 struct PathTestStruct {
@@ skipping 47 matching lines @@
         gTestStruct.fAtlas =
                 context->resourceProvider()->createAtlas(kAlpha_8_GrPixelConfig,
                                                      ATLAS_TEXTURE_WIDTH, ATLAS_TEXTURE_HEIGHT,
                                                      NUM_PLOTS_X, NUM_PLOTS_Y,
                                                      &PathTestStruct::HandleEviction,
                                                      (void*)&gTestStruct);
     }
 
     SkMatrix viewMatrix = GrTest::TestMatrix(random);
     GrColor color = GrRandomColor(random);
+    bool gammaCorrect = random->nextBool();
 
     AADistanceFieldPathBatch::Geometry geometry(GrTest::TestStrokeRec(random));
     geometry.fColor = color;
     geometry.fPath = GrTest::TestPath(random);
     geometry.fAntiAlias = random->nextBool();
     geometry.fGenID = random->nextU();
 
     return AADistanceFieldPathBatch::Create(geometry, viewMatrix,
                                             gTestStruct.fAtlas,
                                             &gTestStruct.fPathCache,
-                                            &gTestStruct.fPathList);
+                                            &gTestStruct.fPathList,
+                                            gammaCorrect);
 }
 
 #endif