Implement support for mixed sampled render targets

src/gpu/GrDrawContext.cpp

 
 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAARectRenderer.h"
 #include "GrBatch.h"
@@ skipping 138 matching lines @@
          SkScalarIsInt(r.fRight) && SkScalarIsInt(r.fBottom);
 }
 
 static bool apply_aa_to_rect(GrDrawTarget* target,
                              GrPipelineBuilder* pipelineBuilder,
                              SkRect* devBoundRect,
                              const SkRect& rect,
                              SkScalar strokeWidth,
                              const SkMatrix& combinedMatrix,
                              GrColor color) {
-    if (pipelineBuilder->getRenderTarget()->isMultisampled()) {
+    if (pipelineBuilder->getRenderTarget()->isUnifiedMultisampled()) {
         return false;
     }
 
 #if defined(SHADER_AA_FILL_RECT) || !defined(IGNORE_ROT_AA_RECT_OPT)
     if (strokeWidth >= 0) {
 #endif
         if (!combinedMatrix.preservesAxisAlignment()) {
             return false;
         }
 
@@ skipping 245 matching lines @@
                 if (paint.isConstantBlendedColor(&clearColor)) {
                     fDrawTarget->clear(NULL, clearColor, true, rt);
                     return;
                 }
             }
         }
     }
 
     GrColor color = paint.getColor();
     SkRect devBoundRect;
-    bool needAA = paint.isAntiAlias() && !pipelineBuilder.getRenderTarget()->isMultisampled();
+    bool needAA = paint.isAntiAlias() &&
+                  !pipelineBuilder.getRenderTarget()->isUnifiedMultisampled();
     bool doAA = needAA && apply_aa_to_rect(fDrawTarget, &pipelineBuilder, &devBoundRect, rect,
                                            width, viewMatrix, color);
 
     if (doAA) {
         if (width >= 0) {
             GrAARectRenderer::StrokeAARect(fDrawTarget,
                                            &pipelineBuilder,
                                            color,
                                            viewMatrix,
                                            rect,
@@ skipping 12 matching lines @@
     }
 
     if (width >= 0) {
         StrokeRectBatch::Geometry geometry;
         geometry.fViewMatrix = viewMatrix;
         geometry.fColor = color;
         geometry.fRect = rect;
         geometry.fStrokeWidth = width;
 
         // Non-AA hairlines are snapped to pixel centers to make which pixels are hit deterministic
-        bool snapToPixelCenters = (0 == width && !rt->isMultisampled());
+        bool snapToPixelCenters = (0 == width && !rt->isUnifiedMultisampled());
         SkAutoTUnref<GrBatch> batch(StrokeRectBatch::Create(geometry, snapToPixelCenters));
 
         // Depending on sub-pixel coordinates and the particular GPU, we may lose a corner of
         // hairline rects. We jam all the vertices to pixel centers to avoid this, but not when MSAA
         // is enabled because it can cause ugly artifacts.
         pipelineBuilder.setState(GrPipelineBuilder::kSnapVerticesToPixelCenters_Flag,
                                  snapToPixelCenters);
         fDrawTarget->drawBatch(&pipelineBuilder, batch);
     } else {
         // filled BW rect
@@ skipping 538 matching lines @@
     // the writePixels that uploads to the scratch will perform a flush so we're
     // OK.
     AutoCheckFlush acf(fContext);
     GrPipelineBuilder pipelineBuilder;
     if (!this->prepareToDraw(&pipelineBuilder, rt, clip, &paint)) {
         return;
     }
 
     if (!strokeInfo.isDashed()) {
         bool useCoverageAA = paint.isAntiAlias() &&
-                !pipelineBuilder.getRenderTarget()->isMultisampled();
+                !pipelineBuilder.getRenderTarget()->isUnifiedMultisampled();
 
         if (useCoverageAA && strokeInfo.getWidth() < 0 && !path.isConvex()) {
             // Concave AA paths are expensive - try to avoid them for special cases
             SkRect rects[2];
 
             if (is_nested_rects(fDrawTarget, &pipelineBuilder, color, viewMatrix, path, strokeInfo,
                                 rects)) {
                 GrAARectRenderer::FillAANestedRects(fDrawTarget, &pipelineBuilder, color,
                                                     viewMatrix, rects);
                 return;
@@ skipping 27 matching lines @@
                                      const GrStrokeInfo& strokeInfo) {
     RETURN_IF_ABANDONED
     SkASSERT(!path.isEmpty());
 
 
     // An Assumption here is that path renderer would use some form of tweaking
     // the src color (either the input alpha or in the frag shader) to implement
     // aa. If we have some future driver-mojo path AA that can do the right
     // thing WRT to the blend then we'll need some query on the PR.
     bool useCoverageAA = useAA &&
-        !pipelineBuilder->getRenderTarget()->isMultisampled();
+        !pipelineBuilder->getRenderTarget()->isUnifiedMultisampled();
 
 
     GrPathRendererChain::DrawType type =
         useCoverageAA ? GrPathRendererChain::kColorAntiAlias_DrawType :
                         GrPathRendererChain::kColor_DrawType;
 
     const SkPath* pathPtr = &path;
     SkTLazy<SkPath> tmpPath;
     const GrStrokeInfo* strokeInfoPtr = &strokeInfo;
 
@@ skipping 190 matching lines @@
     return DrawVerticesBatch::Create(geometry, type, viewMatrix,
                                      positions.begin(), vertexCount,
                                      indices.begin(), hasIndices ? vertexCount : 0,
                                      colors.begin(),
                                      texCoords.begin(),
                                      bounds);
 }
 
 #endif