Conditionally insert gl_PointSize into shaders.

src/gpu/GrProgramDesc.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 GrProgramDesc_DEFINED
 #define GrProgramDesc_DEFINED
 
@@ skipping 10 matching lines @@
 class GrProgramDesc {
 public:
     // Creates an uninitialized key that must be populated by GrGpu::buildProgramDesc()
     GrProgramDesc() {}
 
     /**
     * Builds a program descriptor. Before the descriptor can be used, the client must call finalize
     * on the returned GrProgramDesc.
     *
     * @param GrPrimitiveProcessor The geometry
+    * @param hasPointSize Controls whether the shader will output a point size.
     * @param GrPipeline  The optimized drawstate.  The descriptor will represent a program
     *                        which this optstate can use to draw with.  The optstate contains
     *                        general draw information, as well as the specific color, geometry,
     *                        and coverage stages which will be used to generate the GL Program for
     *                        this optstate.
     * @param GrGLSLCaps     Capabilities of the GLSL backend.
     * @param GrProgramDesc  The built and finalized descriptor
     **/
     static bool Build(GrProgramDesc*,
                       const GrPrimitiveProcessor&,
+                      bool hasPointSize,
                       const GrPipeline&,
                       const GrGLSLCaps&);
 
     // Returns this as a uint32_t array to be used as a key in the program cache.
     const uint32_t* asKey() const {
         return reinterpret_cast<const uint32_t*>(fKey.begin());
     }
 
     // Gets the number of bytes in asKey(). It will be a 4-byte aligned value. When comparing two
     // keys the size of either key can be used with memcmp() since the lengths themselves begin the
@@ skipping 34 matching lines @@
         const uint32_t* bKey = b.asKey();
         for (int i = 0; i < l; ++i) {
             if (aKey[i] != bKey[i]) {
                 return aKey[i] < bKey[i] ? true : false;
             }
         }
         return false;
     }
 
     struct KeyHeader {
-        // Set to uniquely identify the rt's origin, or 0 if the shader does not require this info.
-        uint8_t                     fSurfaceOriginKey;
         // Set to uniquely identify the sample pattern, or 0 if the shader doesn't use sample
         // locations.
         uint8_t                     fSamplePatternKey;
         // Set to uniquely idenitify any swizzling of the shader's output color(s).
         uint8_t                     fOutputSwizzle;
-        uint8_t                     fSnapVerticesToPixelCenters;
-        int8_t                      fColorEffectCnt;
-        int8_t                      fCoverageEffectCnt;
-        uint8_t                     fIgnoresCoverage;
+        uint8_t                     fColorFragmentProcessorCnt : 4;
+        uint8_t                     fCoverageFragmentProcessorCnt : 4;
+        // Set to uniquely identify the rt's origin, or 0 if the shader does not require this info.
+        uint8_t                     fSurfaceOriginKey : 2;
+        uint8_t                     fIgnoresCoverage : 1;
+        uint8_t                     fSnapVerticesToPixelCenters : 1;
+        uint8_t                     fHasPointSize : 1;
+        uint8_t                     fPad : 3;
     };
-
-    int numColorEffects() const {
-        return this->header().fColorEffectCnt;
-    }
-
-    int numCoverageEffects() const {
-        return this->header().fCoverageEffectCnt;
-    }
-
-    int numTotalEffects() const { return this->numColorEffects() + this->numCoverageEffects(); }
+    GR_STATIC_ASSERT(sizeof(KeyHeader) == 4);
 
     // This should really only be used internally, base classes should return their own headers
     const KeyHeader& header() const { return *this->atOffset<KeyHeader, kHeaderOffset>(); }
 
     void finalize() {
         int keyLength = fKey.count();
         SkASSERT(0 == (keyLength % 4));
         *(this->atOffset<uint32_t, GrProgramDesc::kLengthOffset>()) = SkToU32(keyLength);
 
         uint32_t* checksum = this->atOffset<uint32_t, GrProgramDesc::kChecksumOffset>();
@@ skipping 37 matching lines @@
     };
 
     SkSTArray<kPreAllocSize, uint8_t, true>& key() { return fKey; }
     const SkSTArray<kPreAllocSize, uint8_t, true>& key() const { return fKey; }
 
 private:
     SkSTArray<kPreAllocSize, uint8_t, true> fKey;
 };
 
 #endif