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/GrContext.h"
12 #include "include/private/GrRecordingContext.h"
13 #include "src/core/SkMakeUnique.h"
14 #include "src/gpu/GrColor.h"
15 #include "src/gpu/GrContextPriv.h"
16 #include "src/gpu/GrGeometryProcessor.h"
17 #include "src/gpu/GrGpuCommandBuffer.h"
18 #include "src/gpu/GrMemoryPool.h"
19 #include "src/gpu/GrOpFlushState.h"
20 #include "src/gpu/GrRecordingContextPriv.h"
21 #include "src/gpu/GrRenderTargetContext.h"
22 #include "src/gpu/GrRenderTargetContextPriv.h"
23 #include "src/gpu/GrResourceProvider.h"
24 #include "src/gpu/glsl/GrGLSLFragmentShaderBuilder.h"
25 #include "src/gpu/glsl/GrGLSLGeometryProcessor.h"
26 #include "src/gpu/glsl/GrGLSLVarying.h"
27 #include "src/gpu/glsl/GrGLSLVertexGeoBuilder.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 class GrPipelineDynamicStateTestProcessor : public GrGeometryProcessor {
60 public:
GrPipelineDynamicStateTestProcessor()61 GrPipelineDynamicStateTestProcessor()
62 : INHERITED(kGrPipelineDynamicStateTestProcessor_ClassID) {
63 this->setVertexAttributes(kAttributes, SK_ARRAY_COUNT(kAttributes));
64 }
65
name() const66 const char* name() const override { return "GrPipelineDynamicStateTest Processor"; }
67
getGLSLProcessorKey(const GrShaderCaps &,GrProcessorKeyBuilder *) const68 void getGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const final {}
69
70 GrGLSLPrimitiveProcessor* createGLSLInstance(const GrShaderCaps&) const final;
71
inVertex() const72 const Attribute& inVertex() const { return kAttributes[0]; }
inColor() const73 const Attribute& inColor() const { return kAttributes[1]; }
74
75 private:
76 static constexpr Attribute kAttributes[] = {
77 {"vertex", kFloat2_GrVertexAttribType, kHalf2_GrSLType},
78 {"color", kUByte4_norm_GrVertexAttribType, kHalf4_GrSLType},
79 };
80
81 friend class GLSLPipelineDynamicStateTestProcessor;
82 typedef GrGeometryProcessor INHERITED;
83 };
84 constexpr GrPrimitiveProcessor::Attribute GrPipelineDynamicStateTestProcessor::kAttributes[];
85
86 class GLSLPipelineDynamicStateTestProcessor : public GrGLSLGeometryProcessor {
setData(const GrGLSLProgramDataManager & pdman,const GrPrimitiveProcessor &,FPCoordTransformIter && transformIter)87 void setData(const GrGLSLProgramDataManager& pdman, const GrPrimitiveProcessor&,
88 FPCoordTransformIter&& transformIter) final {}
89
onEmitCode(EmitArgs & args,GrGPArgs * gpArgs)90 void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) final {
91 const GrPipelineDynamicStateTestProcessor& mp =
92 args.fGP.cast<GrPipelineDynamicStateTestProcessor>();
93
94 GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;
95 varyingHandler->emitAttributes(mp);
96 varyingHandler->addPassThroughAttribute(mp.inColor(), args.fOutputColor);
97
98 GrGLSLVertexBuilder* v = args.fVertBuilder;
99 v->codeAppendf("float2 vertex = %s;", mp.inVertex().name());
100 gpArgs->fPositionVar.set(kFloat2_GrSLType, "vertex");
101
102 GrGLSLFPFragmentBuilder* f = args.fFragBuilder;
103 f->codeAppendf("%s = half4(1);", args.fOutputCoverage);
104 }
105 };
106
107 GrGLSLPrimitiveProcessor*
createGLSLInstance(const GrShaderCaps &) const108 GrPipelineDynamicStateTestProcessor::createGLSLInstance(const GrShaderCaps&) const {
109 return new GLSLPipelineDynamicStateTestProcessor;
110 }
111
112 class GrPipelineDynamicStateTestOp : public GrDrawOp {
113 public:
114 DEFINE_OP_CLASS_ID
115
Make(GrRecordingContext * context,GrScissorTest scissorTest,sk_sp<const GrBuffer> vbuff)116 static std::unique_ptr<GrDrawOp> Make(GrRecordingContext* context,
117 GrScissorTest scissorTest,
118 sk_sp<const GrBuffer> vbuff) {
119 GrOpMemoryPool* pool = context->priv().opMemoryPool();
120
121 return pool->allocate<GrPipelineDynamicStateTestOp>(scissorTest, std::move(vbuff));
122 }
123
124 private:
125 friend class GrOpMemoryPool;
126
GrPipelineDynamicStateTestOp(GrScissorTest scissorTest,sk_sp<const GrBuffer> vbuff)127 GrPipelineDynamicStateTestOp(GrScissorTest scissorTest, sk_sp<const GrBuffer> vbuff)
128 : INHERITED(ClassID())
129 , fScissorTest(scissorTest)
130 , fVertexBuffer(std::move(vbuff)) {
131 this->setBounds(SkRect::MakeIWH(kScreenSize, kScreenSize),
132 HasAABloat::kNo, IsZeroArea::kNo);
133 }
134
name() const135 const char* name() const override { return "GrPipelineDynamicStateTestOp"; }
fixedFunctionFlags() const136 FixedFunctionFlags fixedFunctionFlags() const override { return FixedFunctionFlags::kNone; }
finalize(const GrCaps &,const GrAppliedClip *,bool hasMixedSampledCoverage,GrClampType)137 GrProcessorSet::Analysis finalize(const GrCaps&, const GrAppliedClip*,
138 bool hasMixedSampledCoverage, GrClampType) override {
139 return GrProcessorSet::EmptySetAnalysis();
140 }
onPrepare(GrOpFlushState *)141 void onPrepare(GrOpFlushState*) override {}
onExecute(GrOpFlushState * state,const SkRect & chainBounds)142 void onExecute(GrOpFlushState* state, const SkRect& chainBounds) override {
143 GrPipeline pipeline(fScissorTest, SkBlendMode::kSrc, state->drawOpArgs().fOutputSwizzle);
144 SkSTArray<kNumMeshes, GrMesh> meshes;
145 for (int i = 0; i < kNumMeshes; ++i) {
146 GrMesh& mesh = meshes.emplace_back(GrPrimitiveType::kTriangleStrip);
147 mesh.setNonIndexedNonInstanced(4);
148 mesh.setVertexData(fVertexBuffer, 4 * i);
149 }
150 GrPipeline::DynamicStateArrays dynamicState;
151 dynamicState.fScissorRects = kDynamicScissors;
152 state->rtCommandBuffer()->draw(GrPipelineDynamicStateTestProcessor(), pipeline, nullptr,
153 &dynamicState, meshes.begin(), 4,
154 SkRect::MakeIWH(kScreenSize, kScreenSize));
155 }
156
157 GrScissorTest fScissorTest;
158 const sk_sp<const GrBuffer> fVertexBuffer;
159
160 typedef GrDrawOp INHERITED;
161 };
162
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(GrPipelineDynamicStateTest,reporter,ctxInfo)163 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(GrPipelineDynamicStateTest, reporter, ctxInfo) {
164 GrContext* context = ctxInfo.grContext();
165 GrResourceProvider* rp = context->priv().resourceProvider();
166
167 sk_sp<GrRenderTargetContext> rtc(context->priv().makeDeferredRenderTargetContext(
168 SkBackingFit::kExact, kScreenSize, kScreenSize, GrColorType::kRGBA_8888, nullptr));
169 if (!rtc) {
170 ERRORF(reporter, "could not create render target context.");
171 return;
172 }
173
174 constexpr float d = (float) kScreenSize;
175 Vertex vdata[kNumMeshes * 4] = {
176 {0, 0, kMeshColors[0]},
177 {0, d, kMeshColors[0]},
178 {d, 0, kMeshColors[0]},
179 {d, d, kMeshColors[0]},
180
181 {0, 0, kMeshColors[1]},
182 {0, d, kMeshColors[1]},
183 {d, 0, kMeshColors[1]},
184 {d, d, kMeshColors[1]},
185
186 {0, 0, kMeshColors[2]},
187 {0, d, kMeshColors[2]},
188 {d, 0, kMeshColors[2]},
189 {d, d, kMeshColors[2]},
190
191 {0, 0, kMeshColors[3]},
192 {0, d, kMeshColors[3]},
193 {d, 0, kMeshColors[3]},
194 {d, d, kMeshColors[3]}
195 };
196
197 sk_sp<const GrBuffer> vbuff(rp->createBuffer(sizeof(vdata), GrGpuBufferType::kVertex,
198 kDynamic_GrAccessPattern, vdata));
199 if (!vbuff) {
200 ERRORF(reporter, "vbuff is null.");
201 return;
202 }
203
204 uint32_t resultPx[kScreenSize * kScreenSize];
205
206 for (GrScissorTest scissorTest : {GrScissorTest::kEnabled, GrScissorTest::kDisabled}) {
207 rtc->clear(nullptr, SkPMColor4f::FromBytes_RGBA(0xbaaaaaad),
208 GrRenderTargetContext::CanClearFullscreen::kYes);
209 rtc->priv().testingOnly_addDrawOp(
210 GrPipelineDynamicStateTestOp::Make(context, scissorTest, vbuff));
211 rtc->readPixels(SkImageInfo::Make(kScreenSize, kScreenSize,
212 kRGBA_8888_SkColorType, kPremul_SkAlphaType),
213 resultPx, 4 * kScreenSize, {0, 0});
214 for (int y = 0; y < kScreenSize; ++y) {
215 for (int x = 0; x < kScreenSize; ++x) {
216 int expectedColorIdx;
217 if (GrScissorTest::kEnabled == scissorTest) {
218 expectedColorIdx = (x < kScreenSplitX ? 0 : 2) + (y < kScreenSplitY ? 0 : 1);
219 } else {
220 expectedColorIdx = kNumMeshes - 1;
221 }
222 uint32_t expected = kMeshColors[expectedColorIdx];
223 uint32_t actual = resultPx[y * kScreenSize + x];
224 if (expected != actual) {
225 ERRORF(reporter, "[scissor=%s] pixel (%i,%i): got 0x%x expected 0x%x",
226 GrScissorTest::kEnabled == scissorTest ? "enabled" : "disabled", x, y,
227 actual, expected);
228 return;
229 }
230 }
231 }
232 }
233 }
234