Infer sampler precision from pixel config

include/gpu/GrCaps.h

 
 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef GrCaps_DEFINED
 #define GrCaps_DEFINED
 
@@ skipping 58 matching lines @@
     * given shader type. If the shader type is not supported or the precision level is not
     * supported in that shader type then the returned struct will report false when supported() is
     * called.
     */
     const PrecisionInfo& getFloatShaderPrecisionInfo(GrShaderType shaderType,
                                                      GrSLPrecision precision) const {
         return fFloatPrecisions[shaderType][precision];
     };
 
     /**
+    * Returns the effective amount of precision found in floating point types with a given precision
+    * qualifier.
+    *
+    *  e.g. If lowp == mediump, effectiveFloatPrecision(lowp) is mediump.
+    *       If the platform doesn't use precision, effectiveFloatPrecision() is always highp.
+    */
+    GrSLPrecision effectiveFloatPrecision(GrShaderType shaderType, GrSLPrecision precision) const {

[bsalomon, 2016/04/06 13:35:56]

It still feels odd to me that we have a precooked table with SLPrecision values
for PixelConfigs. Are they based on the min specifications for precision
qualifiers in the ES2 spec? That would make me feel better about it. But then
I'd also think that it shouldn't be a global function but backend dependent
(that is, make this function take the config rather than a precision from a
global table).

+        return fEffectiveFloatPrecisions[shaderType][precision];
+    }
+
+    /**
     * Is there any difference between the float shader variable precision types? If this is true
     * then unless the shader type is not supported, any call to getFloatShaderPrecisionInfo() would
     * report the same info for all precisions in all shader types.
     */
     bool floatPrecisionVaries() const { return fShaderPrecisionVaries; }
 
     /**
      * PLS storage size in bytes (0 when not supported). The PLS spec defines a minimum size of 16 
      * bytes whenever PLS is supported.
      */
     int pixelLocalStorageSize() const { return fPixelLocalStorageSize; }
 
     /**
      * True if this context supports the necessary extensions and features to enable the PLS path
      * renderer.
      */
     bool plsPathRenderingSupport() const { 
 #if GR_ENABLE_PLS_PATH_RENDERING
         return fPLSPathRenderingSupport;
 #else
         return false;
 #endif
     }
 
 protected:
+    /** Subclasses must call this after filling in the shader precision table. */
+    void initEffectiveFloatPrecisionTable();
+
     /** Subclasses must call this after initialization in order to apply caps overrides requested by
         the client. Note that overrides will only reduce the caps never expand them. */
     void applyOptionsOverrides(const GrContextOptions& options);
 
     bool fShaderDerivativeSupport : 1;
     bool fGeometryShaderSupport : 1;
     bool fPathRenderingSupport : 1;
     bool fDstReadInShaderSupport : 1;
     bool fDualSourceBlendingSupport : 1;
     bool fIntegerSupport : 1;
 
     bool fShaderPrecisionVaries;
     PrecisionInfo fFloatPrecisions[kGrShaderTypeCount][kGrSLPrecisionCount];
+    GrSLPrecision fEffectiveFloatPrecisions[kGrShaderTypeCount][kGrSLPrecisionCount];
     int fPixelLocalStorageSize;
     bool fPLSPathRenderingSupport;
 
 private:
     virtual void onApplyOptionsOverrides(const GrContextOptions&) {};
     typedef SkRefCnt INHERITED;
 };
 
 /**
  * Represents the capabilities of a GrContext.
@@ skipping 199 matching lines @@
     virtual void onApplyOptionsOverrides(const GrContextOptions&) {};
 
     bool fSuppressPrints : 1;
     bool fImmediateFlush: 1;
     bool fDrawPathMasksToCompressedTextureSupport : 1;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif