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