Add "sample locations" feature to GrProcessor

src/gpu/glsl/GrGLSLFragmentShaderBuilder.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLSLFragmentShaderBuilder_DEFINED
 #define GrGLSLFragmentShaderBuilder_DEFINED
 
@@ skipping 49 matching lines @@
 };
 
 /*
  * This class is used by fragment processors to build their fragment code.
  */
 class GrGLSLFPFragmentBuilder : virtual public GrGLSLFragmentBuilder {
 public:
     /** Appease the compiler; the derived class initializes GrGLSLFragmentBuilder. */
     GrGLSLFPFragmentBuilder() : GrGLSLFragmentBuilder(nullptr) {}
 
+    enum Coordinates {

[bsalomon, 2016/03/01 14:28:55]

Why do we need both of these?

[Chris Dalton, 2016/03/01 20:37:47]

The short answer is that it makes life easier for the GrProcessor.
interpolateAtOffset requires window coordinates, whereas for any coord
transforms it's easier (less bug prone) to just stay in Skia device coordinates.
This is especially true considering the conversion between device space and
window space depends on the origin and therefore must also be reflected in the
program key.

Generally a shader won't use both, but in the event that it does, the generated
byte code ought to be about the same anyway whether or not there are two
different arrays.

e.g. "interpolateAtOffset(v, deviceSpaceOffset * vec2(1, -1))": that second
parameter would get constant folded anyway so the call would still compile into
just a call to interpolateAtOffset with a constant value.

Now, the *real* answer is that the NVIDIA compiler has a bug if you call
"interpolateAtOffset(v, offset * vec2(1, -1))". And the workaround is to use a
separate array where the constant folding has already happend :-(

+        kSkiaDevice_Coordinates,
+        kGLSLWindow_Coordinates,
+
+        kLast_Coordinates = kGLSLWindow_Coordinates
+    };
+
+    /**
+     * Appends the offset from the center of the pixel to a specified sample.
+     *
+     * @param sampleIdx      GLSL expression of the sample index.
+     * @param Coordinates    Coordinate space in which to emit the offset.
+     *
+     * A processor must call setWillUseSampleLocations in its constructor before using this method.
+     */
+    virtual void appendOffsetToSample(const char* sampleIdx, Coordinates) = 0;
+
     /**
      * Subtracts sample coverage from the fragment. Any sample whose corresponding bit is not found
      * in the mask will not be written out to the framebuffer.
      *
      * @param mask      int that contains the sample mask. Bit N corresponds to the Nth sample.
      * @param invert    perform a bit-wise NOT on the provided mask before applying it?
      *
      * Requires GLSL support for sample variables.
      */
     virtual void maskSampleCoverage(const char* mask, bool invert = false) = 0;
@@ skipping 66 matching lines @@
 
     GrGLSLFragmentShaderBuilder(GrGLSLProgramBuilder* program, uint8_t fragPosKey);
 
     // Shared GrGLSLFragmentBuilder interface.
     bool enableFeature(GLSLFeature) override;
     virtual SkString ensureFSCoords2D(const GrGLSLTransformedCoordsArray& coords,
                                       int index) override;
     const char* fragmentPosition() override;
 
     // GrGLSLFPFragmentBuilder interface.
+    void appendOffsetToSample(const char* sampleIdx, Coordinates) override;
     void maskSampleCoverage(const char* mask, bool invert = false) override;
     void overrideSampleCoverage(const char* mask) override;
     const SkString& getMangleString() const override { return fMangleString; }
     void onBeforeChildProcEmitCode() override;
     void onAfterChildProcEmitCode() override;
 
     // GrGLSLXPFragmentBuilder interface.
     bool hasCustomColorOutput() const override { return fHasCustomColorOutput; }
     bool hasSecondaryOutput() const override { return fHasSecondaryOutput; }
     const char* dstColor() override;
     void enableAdvancedBlendEquationIfNeeded(GrBlendEquation) override;
 
 private:
-    bool hasFragmentPosition() const;
-
     // Private public interface, used by GrGLProgramBuilder to build a fragment shader
     void enableCustomOutput();
     void enableSecondaryOutput();
     const char* getPrimaryColorOutputName() const;
     const char* getSecondaryColorOutputName() const;
+    void defineSampleOffsetArray(const char* name, const SkMatrix&);
 
 #ifdef SK_DEBUG
     // As GLSLProcessors emit code, there are some conditions we need to verify.  We use the below
     // state to track this.  The reset call is called per processor emitted.
     GrProcessor::RequiredFeatures usedProcessorFeatures() const { return fUsedProcessorFeatures; }
     bool hasReadDstColor() const { return fHasReadDstColor; }
     void resetVerification() {
         fUsedProcessorFeatures = GrProcessor::kNone_RequiredFeatures;
         fHasReadDstColor = false;
     }
@@ skipping 31 matching lines @@
     /*
      * The mangle string is used to mangle the names of uniforms/functions emitted by the child
      * procs so no duplicate uniforms/functions appear in the generated shader program. The mangle
      * string is simply based on fSubstageIndices. For example, if fSubstageIndices = [3, 1, 2, 0],
      * then the manglestring will be "_c3_c1_c2", and any uniform/function emitted by that proc will
      * have "_c3_c1_c2" appended to its name, which can be interpreted as "base proc's 3rd child's
      * 1st child's 2nd child".
      */
     SkString fMangleString;
 
-    bool fSetupFragPosition;
-    bool fTopLeftFragPosRead;
-    bool fHasCustomColorOutput;
-    int  fCustomColorOutputIndex;
-    bool fHasSecondaryOutput;
-    bool fHasInitializedSampleMask;
+    bool       fSetupFragPosition;
+    bool       fTopLeftFragPosRead;
+    bool       fHasCustomColorOutput;
+    int        fCustomColorOutputIndex;
+    bool       fHasSecondaryOutput;
+    uint8_t    fUsedSampleOffsetArrays;
+    bool       fHasInitializedSampleMask;
 
 #ifdef SK_DEBUG
     // some state to verify shaders and effects are consistent, this is reset between effects by
     // the program creator
     GrProcessor::RequiredFeatures fUsedProcessorFeatures;
     bool fHasReadDstColor;
 #endif
 
     friend class GrGLSLProgramBuilder;
     friend class GrGLProgramBuilder;
 };
 
 #endif