submodule/skia/tests/GrPipelineDynamicStateTest.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/SkTypes.h"
   9 #include "tests/Test.h"
  10
  11 #include "include/core/SkColorSpace.h"
  12 #include "include/gpu/GrDirectContext.h"
  13 #include "include/gpu/GrRecordingContext.h"
  14 #include "src/gpu/ganesh/GrColor.h"
  15 #include "src/gpu/ganesh/GrDirectContextPriv.h"
  16 #include "src/gpu/ganesh/GrGeometryProcessor.h"
  17 #include "src/gpu/ganesh/GrImageInfo.h"
  18 #include "src/gpu/ganesh/GrMemoryPool.h"
  19 #include "src/gpu/ganesh/GrOpFlushState.h"
  20 #include "src/gpu/ganesh/GrOpsRenderPass.h"
  21 #include "src/gpu/ganesh/GrProgramInfo.h"
  22 #include "src/gpu/ganesh/GrRecordingContextPriv.h"
  23 #include "src/gpu/ganesh/GrResourceProvider.h"
  24 #include "src/gpu/ganesh/glsl/GrGLSLFragmentShaderBuilder.h"
  25 #include "src/gpu/ganesh/glsl/GrGLSLVarying.h"
  26 #include "src/gpu/ganesh/glsl/GrGLSLVertexGeoBuilder.h"
  27 #include "src/gpu/ganesh/ops/GrDrawOp.h"
  28 #include "src/gpu/ganesh/v1/SurfaceDrawContext_v1.h"
  29
  30 /**
  31  * This is a GPU-backend specific test for dynamic pipeline state. It draws boxes using dynamic
  32  * scissor rectangles then reads back the result to verify a successful test.
  33  */
  34
  35 static constexpr int kScreenSize = 6;
  36 static constexpr int kNumMeshes = 4;
  37 static constexpr int kScreenSplitX = kScreenSize/2;
  38 static constexpr int kScreenSplitY = kScreenSize/2;
  39
  40 static const SkIRect kDynamicScissors[kNumMeshes] = {
  41     SkIRect::MakeLTRB(0,              0,              kScreenSplitX,  kScreenSplitY),
  42     SkIRect::MakeLTRB(0,              kScreenSplitY,  kScreenSplitX,  kScreenSize),
  43     SkIRect::MakeLTRB(kScreenSplitX,  0,              kScreenSize,    kScreenSplitY),
  44     SkIRect::MakeLTRB(kScreenSplitX,  kScreenSplitY,  kScreenSize,    kScreenSize),
  45 };
  46
  47 static const GrColor kMeshColors[kNumMeshes] {
  48     GrColorPackRGBA(255, 0, 0, 255),
  49     GrColorPackRGBA(0, 255, 0, 255),
  50     GrColorPackRGBA(0, 0, 255, 255),
  51     GrColorPackRGBA(0, 0, 0, 255)
  52 };
  53
  54 struct Vertex {
  55     float     fX;
  56     float     fY;
  57     GrColor   fColor;
  58 };
  59
  60 namespace {
  61 class PipelineDynamicStateTestProcessor : public GrGeometryProcessor {
  62 public:
  63     static GrGeometryProcessor* Make(SkArenaAlloc* arena) {
  64         return arena->make(
  65                 [&](void* ptr) { return new (ptr) PipelineDynamicStateTestProcessor(); });
  66     }
  67
  68     const char* name() const override { return "GrPipelineDynamicStateTest Processor"; }
  69
  70     void addToKey(const GrShaderCaps&, skgpu::KeyBuilder*) const final {}
  71
  72     std::unique_ptr<ProgramImpl> makeProgramImpl(const GrShaderCaps&) const final;
  73
  74 private:
  75     PipelineDynamicStateTestProcessor() : INHERITED(kGrPipelineDynamicStateTestProcessor_ClassID) {
  76         this->setVertexAttributesWithImplicitOffsets(kAttributes, SK_ARRAY_COUNT(kAttributes));
  77     }
  78
  79     const Attribute& inVertex() const { return kAttributes[0]; }
  80     const Attribute& inColor() const { return kAttributes[1]; }
  81
  82     inline static constexpr Attribute kAttributes[] = {
  83             {"vertex", kFloat2_GrVertexAttribType, SkSLType::kHalf2},
  84             {"color", kUByte4_norm_GrVertexAttribType, SkSLType::kHalf4},
  85     };
  86
  87     friend class GLSLPipelineDynamicStateTestProcessor;
  88     using INHERITED = GrGeometryProcessor;
  89 };
  90 }  // anonymous namespace
  91
  92 std::unique_ptr<GrGeometryProcessor::ProgramImpl>
  93 PipelineDynamicStateTestProcessor::makeProgramImpl(const GrShaderCaps&) const {
  94     class Impl : public GrGeometryProcessor::ProgramImpl {
  95     public:
  96         void setData(const GrGLSLProgramDataManager&,
  97                      const GrShaderCaps&,
  98                      const GrGeometryProcessor&) final {}
  99
 100         void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) final {
 101             const PipelineDynamicStateTestProcessor& mp =
 102                     args.fGeomProc.cast<PipelineDynamicStateTestProcessor>();
 103             GrGLSLVertexBuilder* v = args.fVertBuilder;
 104             GrGLSLFPFragmentBuilder* f = args.fFragBuilder;
 105
 106             GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;
 107             varyingHandler->emitAttributes(mp);
 108             f->codeAppendf("half4 %s;", args.fOutputColor);
 109             varyingHandler->addPassThroughAttribute(mp.inColor().asShaderVar(), args.fOutputColor);
 110
 111             v->codeAppendf("float2 vertex = %s;", mp.inVertex().name());
 112             gpArgs->fPositionVar.set(SkSLType::kFloat2, "vertex");
 113             f->codeAppendf("const half4 %s = half4(1);", args.fOutputCoverage);
 114         }
 115     };
 116     return std::make_unique<Impl>();
 117 }
 118
 119 namespace {
 120 class GrPipelineDynamicStateTestOp : public GrDrawOp {
 121 public:
 122     DEFINE_OP_CLASS_ID
 123
 124     static GrOp::Owner Make(GrRecordingContext* context,
 125                             GrScissorTest scissorTest,
 126                             sk_sp<const GrBuffer> vbuff) {
 127         return GrOp::Make<GrPipelineDynamicStateTestOp>(context, scissorTest, std::move(vbuff));
 128     }
 129
 130 private:
 131     friend class GrOp;
 132
 133     GrPipelineDynamicStateTestOp(GrScissorTest scissorTest, sk_sp<const GrBuffer> vbuff)
 134         : INHERITED(ClassID())
 135         , fScissorTest(scissorTest)
 136         , fVertexBuffer(std::move(vbuff)) {
 137         this->setBounds(SkRect::MakeIWH(kScreenSize, kScreenSize),
 138                         HasAABloat::kNo, IsHairline::kNo);
 139     }
 140
 141     const char* name() const override { return "GrPipelineDynamicStateTestOp"; }
 142     FixedFunctionFlags fixedFunctionFlags() const override { return FixedFunctionFlags::kNone; }
 143     GrProcessorSet::Analysis finalize(const GrCaps&, const GrAppliedClip*, GrClampType) override {
 144         return GrProcessorSet::EmptySetAnalysis();
 145     }
 146     void onPrePrepare(GrRecordingContext*,
 147                       const GrSurfaceProxyView& writeView,
 148                       GrAppliedClip*,
 149                       const GrDstProxyView&,
 150                       GrXferBarrierFlags renderPassXferBarriers,
 151                       GrLoadOp colorLoadOp) override {}
 152     void onPrepare(GrOpFlushState*) override {}
 153     void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override {
 154         GrPipeline pipeline(fScissorTest, SkBlendMode::kSrc,
 155                             flushState->drawOpArgs().writeView().swizzle());
 156         SkSTArray<kNumMeshes, GrSimpleMesh> meshes;
 157         for (int i = 0; i < kNumMeshes; ++i) {
 158             GrSimpleMesh& mesh = meshes.push_back();
 159             mesh.set(fVertexBuffer, 4, 4 * i);
 160         }
 161
 162         auto geomProc = PipelineDynamicStateTestProcessor::Make(flushState->allocator());
 163
 164         GrProgramInfo programInfo(flushState->caps(),
 165                                   flushState->writeView(),
 166                                   flushState->usesMSAASurface(),
 167                                   &pipeline,
 168                                   &GrUserStencilSettings::kUnused,
 169                                   geomProc,
 170                                   GrPrimitiveType::kTriangleStrip,
 171                                   flushState->renderPassBarriers(),
 172                                   flushState->colorLoadOp());
 173
 174         flushState->bindPipeline(programInfo, SkRect::MakeIWH(kScreenSize, kScreenSize));
 175         for (int i = 0; i < 4; ++i) {
 176             if (fScissorTest == GrScissorTest::kEnabled) {
 177                 flushState->setScissorRect(kDynamicScissors[i]);
 178             }
 179             flushState->drawMesh(meshes[i]);
 180         }
 181     }
 182
 183     GrScissorTest               fScissorTest;
 184     const sk_sp<const GrBuffer> fVertexBuffer;
 185
 186     using INHERITED = GrDrawOp;
 187 };
 188 }  // anonymous namespace
 189
 190 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(GrPipelineDynamicStateTest, reporter, ctxInfo) {
 191     auto dContext = ctxInfo.directContext();
 192     GrResourceProvider* rp = dContext->priv().resourceProvider();
 193
 194     auto sdc = skgpu::v1::SurfaceDrawContext::Make(
 195             dContext, GrColorType::kRGBA_8888, nullptr, SkBackingFit::kExact,
 196             {kScreenSize, kScreenSize}, SkSurfaceProps());
 197     if (!sdc) {
 198         ERRORF(reporter, "could not create render target context.");
 199         return;
 200     }
 201
 202     constexpr float d = (float) kScreenSize;
 203     Vertex vdata[kNumMeshes * 4] = {
 204         {0, 0, kMeshColors[0]},
 205         {0, d, kMeshColors[0]},
 206         {d, 0, kMeshColors[0]},
 207         {d, d, kMeshColors[0]},
 208
 209         {0, 0, kMeshColors[1]},
 210         {0, d, kMeshColors[1]},
 211         {d, 0, kMeshColors[1]},
 212         {d, d, kMeshColors[1]},
 213
 214         {0, 0, kMeshColors[2]},
 215         {0, d, kMeshColors[2]},
 216         {d, 0, kMeshColors[2]},
 217         {d, d, kMeshColors[2]},
 218
 219         {0, 0, kMeshColors[3]},
 220         {0, d, kMeshColors[3]},
 221         {d, 0, kMeshColors[3]},
 222         {d, d, kMeshColors[3]}
 223     };
 224
 225     sk_sp<const GrBuffer> vbuff(rp->createBuffer(sizeof(vdata), GrGpuBufferType::kVertex,
 226                                                  kDynamic_GrAccessPattern, vdata));
 227     if (!vbuff) {
 228         ERRORF(reporter, "vbuff is null.");
 229         return;
 230     }
 231
 232     uint32_t resultPx[kScreenSize * kScreenSize];
 233
 234     for (GrScissorTest scissorTest : {GrScissorTest::kEnabled, GrScissorTest::kDisabled}) {
 235         sdc->clear(SkPMColor4f::FromBytes_RGBA(0xbaaaaaad));
 236         sdc->addDrawOp(GrPipelineDynamicStateTestOp::Make(dContext, scissorTest, vbuff));
 237         auto ii = SkImageInfo::Make(kScreenSize, kScreenSize,
 238                                     kRGBA_8888_SkColorType, kPremul_SkAlphaType);
 239         GrPixmap resultPM(ii, resultPx, kScreenSize*sizeof(uint32_t));
 240         sdc->readPixels(dContext, resultPM, {0, 0});
 241         for (int y = 0; y < kScreenSize; ++y) {
 242             for (int x = 0; x < kScreenSize; ++x) {
 243                 int expectedColorIdx;
 244                 if (GrScissorTest::kEnabled == scissorTest) {
 245                     expectedColorIdx = (x < kScreenSplitX ? 0 : 2) + (y < kScreenSplitY ? 0 : 1);
 246                 } else {
 247                     expectedColorIdx = kNumMeshes - 1;
 248                 }
 249                 uint32_t expected = kMeshColors[expectedColorIdx];
 250                 uint32_t actual = resultPx[y * kScreenSize + x];
 251                 if (expected != actual) {
 252                     ERRORF(reporter, "[scissor=%s] pixel (%i,%i): got 0x%x expected 0x%x",
 253                            GrScissorTest::kEnabled == scissorTest ? "enabled" : "disabled", x, y,
 254                            actual, expected);
 255                     return;
 256                 }
 257             }
 258         }
 259     }
 260 }