submodule/skia/tests/DefaultPathRendererTest.cpp

   1 /*
   2  * Copyright 2017 Google Inc.
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 #include "include/core/SkBitmap.h"
   9 #include "include/core/SkColor.h"
  10 #include "include/core/SkColorSpace.h"
  11 #include "include/core/SkImageInfo.h"
  12 #include "include/core/SkMatrix.h"
  13 #include "include/core/SkPath.h"
  14 #include "include/core/SkRect.h"
  15 #include "include/core/SkRefCnt.h"
  16 #include "include/core/SkStrokeRec.h"
  17 #include "include/core/SkSurface.h"
  18 #include "include/core/SkTypes.h"
  19 #include "include/gpu/GrBackendSurface.h"
  20 #include "include/gpu/GrContextOptions.h"
  21 #include "include/gpu/GrDirectContext.h"
  22 #include "include/gpu/GrTypes.h"
  23 #include "include/private/SkColorData.h"
  24 #include "include/private/gpu/ganesh/GrTypesPriv.h"
  25 #include "src/gpu/ganesh/GrCaps.h"
  26 #include "src/gpu/ganesh/GrDirectContextPriv.h"
  27 #include "src/gpu/ganesh/GrFragmentProcessor.h"
  28 #include "src/gpu/ganesh/GrImageInfo.h"
  29 #include "src/gpu/ganesh/GrPaint.h"
  30 #include "src/gpu/ganesh/GrStyle.h"
  31 #include "src/gpu/ganesh/v1/SurfaceDrawContext_v1.h"
  32 #include "tests/Test.h"
  33 #include "tools/gpu/GrContextFactory.h"
  34
  35 #include <utility>
  36
  37 static void only_allow_default(GrContextOptions* options) {
  38     options->fGpuPathRenderers = GpuPathRenderers::kNone;
  39 }
  40
  41 static SkBitmap read_back(GrDirectContext* dContext,
  42                           skgpu::v1::SurfaceDrawContext* sdc,
  43                           int width, int height) {
  44
  45     SkImageInfo dstII = SkImageInfo::MakeN32Premul(width, height);
  46
  47     SkBitmap bm;
  48     bm.allocPixels(dstII);
  49
  50     sdc->readPixels(dContext, bm.pixmap(), {0, 0});
  51
  52     return bm;
  53 }
  54
  55 static SkPath make_path(const SkRect& outer, int inset, SkPathFillType fill) {
  56     SkPath p;
  57
  58     p.addRect(outer, SkPathDirection::kCW);
  59     p.addRect(outer.makeInset(inset, inset), SkPathDirection::kCCW);
  60     p.setFillType(fill);
  61     return p;
  62 }
  63
  64
  65 static const int kBigSize = 64; // This should be a power of 2
  66 static const int kPad = 3;
  67
  68 // From crbug.com/769898:
  69 //   create an approx fit render target context that will have extra space (i.e., npot)
  70 //   draw an inverse wound concave path into it - forcing use of the stencil-using path renderer
  71 //   throw the RTC away so the backing GrSurface/GrStencilBuffer can be reused
  72 //   create a new render target context that will reuse the prior GrSurface
  73 //   draw a normally wound concave path that touches outside of the approx fit RTC's content rect
  74 //
  75 // When the bug manifests the DefaultPathRenderer/GrMSAAPathRenderer is/was leaving the stencil
  76 // buffer outside of the first content rect in a bad state and the second draw would be incorrect.
  77
  78 static void run_test(GrDirectContext* dContext, skiatest::Reporter* reporter) {
  79     SkPath invPath = make_path(SkRect::MakeXYWH(0, 0, kBigSize, kBigSize),
  80                                kBigSize/2-1, SkPathFillType::kInverseWinding);
  81     SkPath path = make_path(SkRect::MakeXYWH(0, 0, kBigSize, kBigSize),
  82                             kPad, SkPathFillType::kWinding);
  83
  84     GrStyle style(SkStrokeRec::kFill_InitStyle);
  85
  86     {
  87         auto sdc = skgpu::v1::SurfaceDrawContext::Make(dContext, GrColorType::kRGBA_8888, nullptr,
  88                                                        SkBackingFit::kApprox,
  89                                                        {kBigSize/2 + 1, kBigSize/2 + 1},
  90                                                        SkSurfaceProps());
  91
  92         sdc->clear(SK_PMColor4fBLACK);
  93
  94         GrPaint paint;
  95
  96         const SkPMColor4f color = { 1.0f, 0.0f, 0.0f, 1.0f };
  97         auto fp = GrFragmentProcessor::MakeColor(color);
  98         paint.setColorFragmentProcessor(std::move(fp));
  99
 100         sdc->drawPath(nullptr, std::move(paint), GrAA::kNo, SkMatrix::I(), invPath, style);
 101
 102         dContext->priv().flushSurface(sdc->asSurfaceProxy());
 103     }
 104
 105     {
 106         auto sdc = skgpu::v1::SurfaceDrawContext::Make(dContext, GrColorType::kRGBA_8888, nullptr,
 107                                                        SkBackingFit::kExact, {kBigSize, kBigSize},
 108                                                        SkSurfaceProps());
 109
 110         sdc->clear(SK_PMColor4fBLACK);
 111
 112         GrPaint paint;
 113
 114         const SkPMColor4f color = { 0.0f, 1.0f, 0.0f, 1.0f };
 115         auto fp = GrFragmentProcessor::MakeColor(color);
 116         paint.setColorFragmentProcessor(std::move(fp));
 117
 118         sdc->drawPath(nullptr, std::move(paint), GrAA::kNo,
 119                       SkMatrix::I(), path, style);
 120
 121         SkBitmap bm = read_back(dContext, sdc.get(), kBigSize, kBigSize);
 122
 123         bool correct = true;
 124         for (int y = kBigSize/2+1; y < kBigSize-kPad-1 && correct; ++y) {
 125             for (int x = kPad+1; x < kBigSize-kPad-1 && correct; ++x) {
 126                 correct = bm.getColor(x, y) == SK_ColorBLACK;
 127                 REPORTER_ASSERT(reporter, correct);
 128             }
 129         }
 130     }
 131 }
 132
 133 DEF_GPUTEST_FOR_CONTEXTS(DefaultPathRendererTest,
 134                          sk_gpu_test::GrContextFactory::IsRenderingContext,
 135                          reporter, ctxInfo, only_allow_default) {
 136     auto ctx = ctxInfo.directContext();
 137
 138     run_test(ctx, reporter);
 139 }