Implement support for mixed sampled render targets

src/gpu/GrPipelineBuilder.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrPipelineBuilder_DEFINED
 #define GrPipelineBuilder_DEFINED
 
@@ skipping 27 matching lines @@
     }
 
     virtual ~GrPipelineBuilder();
 
     /**
      * Initializes the GrPipelineBuilder based on a GrPaint, view matrix and render target. Note
      * that GrPipelineBuilder encompasses more than GrPaint. Aspects of GrPipelineBuilder that have
      * no GrPaint equivalents are set to default values with the exception of vertex attribute state
      * which is unmodified by this function and clipping which will be enabled.
      */
-    void setFromPaint(const GrPaint&, GrRenderTarget*, const GrClip&);
+    void setFromPaint(const GrPaint&, GrRenderTarget*, const GrClip&,
+                      GrRenderTarget::PipelineStage pipelineStage =

[Chris Dalton, 2015/03/20 07:01:45]

I think it's a little confusing to pass a parameter named 'pipelineStage' here.
It's not entirely obvious what the purpose of the parameter is just from reading
the code. I'm tryig to brainstorm for an approach I like better but am having a
hard time. Do you like any of these?

 * Give PipelineStage parameter a really descriptive name that says "pipeline
stages that need to be multisampled in order to use HWAA"
  ** What I don't like about this approach is that GrPipelineBuilder decides
whether to use HWAA, when really the calling code is who knows whether we should
use it. In the case of text, we shouldn't have to check
isMultiSampled(StencilBuffer) because we already know it's multisampled.
 * Instead of PipelineStage, add a second setFromPaint() overload with a new
parameter named 'bool useHWAA'. The original version calls this overload with
useHWAA='rt->isMultisampled() && paint.isAntiAlias()'
  ** What I don't like about this approach is that setFromPaint() seems to be
the one that should check paint.isAntiAlias()
 * instead of 'bool useHWAA', add 'bool canUseHWAA' with default value of
'rt->isMultisampled()' and setFromPaint uses 'paint.isAntiAlias() && canUseHWAA'
  ** What I don't like about this approach is that GrStencilAndCoverTextContext
has to send a bool 'true' value, which is confusing to read.
 * Instead of PipelineStage parameter, add PipelineStage member variable to
GrPipelineBuilder. kHWAntialias_StateBit becomes kAntialias_StateBit (whether or
not paint is antialiased) and isHWAntialias() returns '0 != (fFlagBits &
kAntialias_StateBit) &&
fRenderTarget->isMultisampled(fStagesThatHaveToBeMultisampledInOrderToUseHWAA)'
 * ...?

Maybe we could discuss this offline.

+                          GrRenderTarget::kEverywhere_PipelineStage);
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Fragment Processors
     ///
     /// GrFragmentProcessors are used to compute per-pixel color and per-pixel fractional coverage.
     /// There are two chains of FPs, one for color and one for coverage. The first FP in each
     /// chain gets the initial color/coverage from the GrPrimitiveProcessor. It computes an output
     /// color/coverage which is fed to the next FP in the chain. The last color and coverage FPs
     /// feed their output to the GrXferProcessor which controls blending.
     ////
@@ skipping 375 matching lines @@
     mutable GrProcOptInfo fCoverageProcInfo;
     mutable bool fColorProcInfoValid;
     mutable bool fCoverageProcInfoValid;
     mutable GrColor fColorCache;
     mutable GrColor fCoverageCache;
 
     friend class GrPipeline;
 };
 
 #endif