GrFP can express distance vector field req., program builder declares variable for it

include/gpu/GrPaint.h

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef GrPaint_DEFINED
@@ skipping 59 matching lines @@
     bool getDisableOutputConversionToSRGB() const { return fDisableOutputConversionToSRGB; }
 
     /**
      * Should sRGB inputs be allowed to perform sRGB to linear conversion. With this flag
      * set to false, sRGB textures will be treated as linear (including filtering).
      */
     void setAllowSRGBInputs(bool allowSRGBInputs) { fAllowSRGBInputs = allowSRGBInputs; }
     bool getAllowSRGBInputs() const { return fAllowSRGBInputs; }
 
     /**
+     * Does one of the fragment processors need a field of distance vectors to the nearest edge?
+     */
+    bool usesDistanceVectorField() const { return fUsesDistanceVectorField; }
+
+    /**
      * Should rendering be gamma-correct, end-to-end. Causes sRGB render targets to behave
      * as such (with linear blending), and sRGB inputs to be filtered and decoded correctly.
      */
     void setGammaCorrect(bool gammaCorrect) {
         setDisableOutputConversionToSRGB(!gammaCorrect);
         setAllowSRGBInputs(gammaCorrect);
     }
 
     void setXPFactory(sk_sp<GrXPFactory> xpFactory) {
         fXPFactory = std::move(xpFactory);
     }
 
     void setPorterDuffXPFactory(SkXfermode::Mode mode) {
         fXPFactory = GrPorterDuffXPFactory::Make(mode);
     }
 
     void setCoverageSetOpXPFactory(SkRegion::Op regionOp, bool invertCoverage = false); 
 
     /**
      * Appends an additional color processor to the color computation.
      */
     void addColorFragmentProcessor(sk_sp<GrFragmentProcessor> fp) {
         SkASSERT(fp);
+        fUsesDistanceVectorField |= fp->usesDistanceVectorField();
         fColorFragmentProcessors.push_back(std::move(fp));
     }
 
     /**
      * Appends an additional coverage processor to the coverage computation.
      */
     void addCoverageFragmentProcessor(sk_sp<GrFragmentProcessor> fp) {
         SkASSERT(fp);
+        fUsesDistanceVectorField |= fp->usesDistanceVectorField();
         fCoverageFragmentProcessors.push_back(std::move(fp));
     }
 
     /**
      * Helpers for adding color or coverage effects that sample a texture. The matrix is applied
      * to the src space position to compute texture coordinates.
      */
     void addColorTextureProcessor(GrTexture*, const SkMatrix&);
     void addCoverageTextureProcessor(GrTexture*, const SkMatrix&);
     void addColorTextureProcessor(GrTexture*, const SkMatrix&, const GrTextureParams&);
@@ skipping 12 matching lines @@
         return fColorFragmentProcessors[i].get();
     }
     GrFragmentProcessor* getCoverageFragmentProcessor(int i) const {
         return fCoverageFragmentProcessors[i].get();
     }
 
     GrPaint& operator=(const GrPaint& paint) {
         fAntiAlias = paint.fAntiAlias;
         fDisableOutputConversionToSRGB = paint.fDisableOutputConversionToSRGB;
         fAllowSRGBInputs = paint.fAllowSRGBInputs;
+        fUsesDistanceVectorField = paint.fUsesDistanceVectorField;
 
         fColor = paint.fColor;
         fColorFragmentProcessors = paint.fColorFragmentProcessors;
         fCoverageFragmentProcessors = paint.fCoverageFragmentProcessors;
 
         fXPFactory = paint.fXPFactory;
 
         return *this;
     }
 
     /**
      * Returns true if the paint's output color will be constant after blending. If the result is
      * true, constantColor will be updated to contain the constant color. Note that we can conflate
      * coverage and color, so the actual values written to pixels with partial coverage may still
      * not seem constant, even if this function returns true.
      */
     bool isConstantBlendedColor(GrColor* constantColor) const;
 
 private:
     mutable sk_sp<GrXPFactory>                fXPFactory;
     SkSTArray<4, sk_sp<GrFragmentProcessor>>  fColorFragmentProcessors;
     SkSTArray<2, sk_sp<GrFragmentProcessor>>  fCoverageFragmentProcessors;
 
     bool                                      fAntiAlias;
     bool                                      fDisableOutputConversionToSRGB;
     bool                                      fAllowSRGBInputs;
+    bool                                      fUsesDistanceVectorField;
 
     GrColor4f                                 fColor;
 };
 
 #endif