1 /*
2 * Copyright 2019 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 "gm/gm.h"
9 #include "include/core/SkBlendMode.h"
10 #include "include/core/SkCanvas.h"
11 #include "include/core/SkColorSpace.h"
12 #include "include/core/SkMatrix.h"
13 #include "include/core/SkRect.h"
14 #include "include/core/SkRefCnt.h"
15 #include "include/core/SkSize.h"
16 #include "include/core/SkString.h"
17 #include "include/core/SkTypes.h"
18 #include "include/gpu/GrContext.h"
19 #include "include/gpu/GrTypes.h"
20 #include "include/private/GrRecordingContext.h"
21 #include "include/private/GrTypesPriv.h"
22 #include "include/private/SkColorData.h"
23 #include "src/gpu/GrBuffer.h"
24 #include "src/gpu/GrCaps.h"
25 #include "src/gpu/GrClip.h"
26 #include "src/gpu/GrColorSpaceXform.h"
27 #include "src/gpu/GrContextPriv.h"
28 #include "src/gpu/GrGeometryProcessor.h"
29 #include "src/gpu/GrGpuCommandBuffer.h"
30 #include "src/gpu/GrMemoryPool.h"
31 #include "src/gpu/GrMesh.h"
32 #include "src/gpu/GrOpFlushState.h"
33 #include "src/gpu/GrPaint.h"
34 #include "src/gpu/GrPipeline.h"
35 #include "src/gpu/GrPrimitiveProcessor.h"
36 #include "src/gpu/GrProcessor.h"
37 #include "src/gpu/GrProcessorSet.h"
38 #include "src/gpu/GrRecordingContextPriv.h"
39 #include "src/gpu/GrRenderTargetContext.h"
40 #include "src/gpu/GrRenderTargetContextPriv.h"
41 #include "src/gpu/GrSamplerState.h"
42 #include "src/gpu/GrShaderCaps.h"
43 #include "src/gpu/GrShaderVar.h"
44 #include "src/gpu/GrSurfaceProxy.h"
45 #include "src/gpu/GrTextureProxy.h"
46 #include "src/gpu/GrUserStencilSettings.h"
47 #include "src/gpu/effects/GrPorterDuffXferProcessor.h"
48 #include "src/gpu/glsl/GrGLSLFragmentShaderBuilder.h"
49 #include "src/gpu/glsl/GrGLSLGeometryProcessor.h"
50 #include "src/gpu/glsl/GrGLSLPrimitiveProcessor.h"
51 #include "src/gpu/glsl/GrGLSLProgramBuilder.h"
52 #include "src/gpu/glsl/GrGLSLVarying.h"
53 #include "src/gpu/glsl/GrGLSLVertexGeoBuilder.h"
54 #include "src/gpu/ops/GrDrawOp.h"
55 #include "src/gpu/ops/GrOp.h"
56
57 #include <memory>
58 #include <utility>
59
60 class GrAppliedClip;
61 class GrGLSLProgramDataManager;
62
63 namespace skiagm {
64
65 enum class GradType : bool {
66 kHW,
67 kSW
68 };
69
70 /**
71 * This test ensures that the shaderBuilder's sample offsets and sample mask are correlated with
72 * actual HW sample locations. It does so by drawing pseudo-random subpixel boxes, and only turning
73 * off the samples whose locations fall inside the boxes.
74 */
75 class SampleLocationsGM : public GpuGM {
76 public:
SampleLocationsGM(GradType gradType,GrSurfaceOrigin origin)77 SampleLocationsGM(GradType gradType, GrSurfaceOrigin origin)
78 : fGradType(gradType)
79 , fOrigin(origin) {}
80
81 private:
onShortName()82 SkString onShortName() override {
83 return SkStringPrintf("samplelocations%s%s",
84 (GradType::kHW == fGradType) ? "_hwgrad" : "_swgrad",
85 (kTopLeft_GrSurfaceOrigin == fOrigin) ? "_topleft" : "_botleft");
86 }
87
onISize()88 SkISize onISize() override { return SkISize::Make(200, 200); }
89 DrawResult onDraw(GrContext*, GrRenderTargetContext*, SkCanvas*, SkString* errorMsg) override;
90
91 const GradType fGradType;
92 const GrSurfaceOrigin fOrigin;
93 };
94
95 ////////////////////////////////////////////////////////////////////////////////////////////////////
96 // SkSL code.
97
98 class SampleLocationsTestProcessor : public GrGeometryProcessor {
99 public:
SampleLocationsTestProcessor(GradType gradType)100 SampleLocationsTestProcessor(GradType gradType)
101 : GrGeometryProcessor(kSampleLocationsTestProcessor_ClassID)
102 , fGradType(gradType) {
103 this->setWillUseCustomFeature(CustomFeatures::kSampleLocations);
104 }
name() const105 const char* name() const override { return "SampleLocationsTestProcessor"; }
getGLSLProcessorKey(const GrShaderCaps &,GrProcessorKeyBuilder * b) const106 void getGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder* b) const final {
107 b->add32((uint32_t)fGradType);
108 }
109 GrGLSLPrimitiveProcessor* createGLSLInstance(const GrShaderCaps&) const final;
110
111 private:
112 const GradType fGradType;
113
114 class Impl;
115 };
116
117 class SampleLocationsTestProcessor::Impl : public GrGLSLGeometryProcessor {
onEmitCode(EmitArgs & args,GrGPArgs * gpArgs)118 void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override {
119 const auto& proc = args.fGP.cast<SampleLocationsTestProcessor>();
120 auto* v = args.fVertBuilder;
121 auto* f = args.fFragBuilder;
122
123 GrGLSLVarying coord(kFloat2_GrSLType);
124 GrGLSLVarying grad(kFloat2_GrSLType);
125 args.fVaryingHandler->addVarying("coord", &coord);
126 if (GradType::kSW == proc.fGradType) {
127 args.fVaryingHandler->addVarying("grad", &grad);
128 }
129
130 // Pixel grid.
131 v->codeAppendf("int x = sk_InstanceID %% 200;");
132 v->codeAppendf("int y = sk_InstanceID / 200;");
133
134 // Create pseudo-random rectangles inside a 16x16 subpixel grid. This works out nicely
135 // because there are 17 positions on the grid (including both edges), and 17 is a great
136 // prime number for generating pseudo-random numbers.
137 v->codeAppendf("int ileft = (sk_InstanceID*929) %% 17;");
138 v->codeAppendf("int iright = ileft + 1 + ((sk_InstanceID*1637) %% (17 - ileft));");
139 v->codeAppendf("int itop = (sk_InstanceID*313) %% 17;");
140 v->codeAppendf("int ibot = itop + 1 + ((sk_InstanceID*1901) %% (17 - itop));");
141
142 // Outset (or inset) the rectangle, for the very likely scenario that samples fall on exact
143 // 16ths of a pixel. GL_SUBPIXEL_BITS is allowed to be as low as 4, so try not to let the
144 // outset value to get too small.
145 v->codeAppendf("float outset = 1/32.0;");
146 v->codeAppendf("outset = (0 == (x + y) %% 2) ? -outset : +outset;");
147 v->codeAppendf("float l = ileft/16.0 - outset;");
148 v->codeAppendf("float r = iright/16.0 + outset;");
149 v->codeAppendf("float t = itop/16.0 - outset;");
150 v->codeAppendf("float b = ibot/16.0 + outset;");
151
152 v->codeAppendf("float2 vertexpos;");
153 v->codeAppendf("vertexpos.x = float(x) + ((0 == (sk_VertexID %% 2)) ? l : r);");
154 v->codeAppendf("vertexpos.y = float(y) + ((0 == (sk_VertexID / 2)) ? t : b);");
155 gpArgs->fPositionVar.set(kFloat2_GrSLType, "vertexpos");
156
157 v->codeAppendf("%s.x = (0 == (sk_VertexID %% 2)) ? -1 : +1;", coord.vsOut());
158 v->codeAppendf("%s.y = (0 == (sk_VertexID / 2)) ? -1 : +1;", coord.vsOut());
159 if (GradType::kSW == proc.fGradType) {
160 v->codeAppendf("%s = 2/float2(r - l, b - t);", grad.vsOut());
161 }
162
163 // Fragment shader: Output RED.
164 f->codeAppendf("%s = half4(1,0,0,1);", args.fOutputColor);
165 f->codeAppendf("%s = half4(1);", args.fOutputCoverage);
166
167 // Now turn off all the samples inside our sub-rectangle. As long as the shaderBuilder's
168 // sample offsets and sample mask are correlated with actual HW sample locations, no red
169 // will bleed through.
170 f->codeAppendf("for (int i = 0; i < %i; ++i) {",
171 f->getProgramBuilder()->effectiveSampleCnt());
172 if (GradType::kHW == proc.fGradType) {
173 f->codeAppendf("float2x2 grad = float2x2(dFdx(%s), dFdy(%s));",
174 coord.fsIn(), coord.fsIn());
175 } else {
176 f->codeAppendf("float2x2 grad = float2x2(%s.x, 0, 0, %s.y);", grad.fsIn(), grad.fsIn());
177 }
178 f->codeAppendf( "float2 samplecoord = %s[i] * grad + %s;",
179 f->sampleOffsets(), coord.fsIn());
180 f->codeAppendf( "if (all(lessThanEqual(abs(samplecoord), float2(1)))) {");
181 f->maskOffMultisampleCoverage(
182 "~(1 << i)", GrGLSLFPFragmentBuilder::ScopeFlags::kInsideLoop);
183 f->codeAppendf( "}");
184 f->codeAppendf("}");
185 }
186
setData(const GrGLSLProgramDataManager &,const GrPrimitiveProcessor &,FPCoordTransformIter &&)187 void setData(const GrGLSLProgramDataManager&, const GrPrimitiveProcessor&,
188 FPCoordTransformIter&&) override {}
189 };
190
createGLSLInstance(const GrShaderCaps &) const191 GrGLSLPrimitiveProcessor* SampleLocationsTestProcessor::createGLSLInstance(
192 const GrShaderCaps&) const {
193 return new Impl();
194 }
195
196 ////////////////////////////////////////////////////////////////////////////////////////////////////
197 // Draw Op.
198
199 class SampleLocationsTestOp : public GrDrawOp {
200 public:
201 DEFINE_OP_CLASS_ID
202
Make(GrRecordingContext * ctx,const SkMatrix & viewMatrix,GradType gradType)203 static std::unique_ptr<GrDrawOp> Make(
204 GrRecordingContext* ctx, const SkMatrix& viewMatrix, GradType gradType) {
205 GrOpMemoryPool* pool = ctx->priv().opMemoryPool();
206 return pool->allocate<SampleLocationsTestOp>(gradType);
207 }
208
209 private:
SampleLocationsTestOp(GradType gradType)210 SampleLocationsTestOp(GradType gradType) : GrDrawOp(ClassID()), fGradType(gradType) {
211 this->setBounds(SkRect::MakeIWH(200, 200), HasAABloat::kNo, IsZeroArea::kNo);
212 }
213
name() const214 const char* name() const override { return "SampleLocationsTestOp"; }
fixedFunctionFlags() const215 FixedFunctionFlags fixedFunctionFlags() const override {
216 return FixedFunctionFlags::kUsesHWAA | FixedFunctionFlags::kUsesStencil;
217 }
finalize(const GrCaps &,const GrAppliedClip *,bool hasMixedSampledCoverage,GrClampType)218 GrProcessorSet::Analysis finalize(const GrCaps&, const GrAppliedClip*,
219 bool hasMixedSampledCoverage, GrClampType) override {
220 return GrProcessorSet::EmptySetAnalysis();
221 }
onPrepare(GrOpFlushState *)222 void onPrepare(GrOpFlushState*) override {}
onExecute(GrOpFlushState * flushState,const SkRect & chainBounds)223 void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override {
224 static constexpr GrUserStencilSettings kStencilWrite(
225 GrUserStencilSettings::StaticInit<
226 0x0001,
227 GrUserStencilTest::kAlways,
228 0xffff,
229 GrUserStencilOp::kReplace,
230 GrUserStencilOp::kKeep,
231 0xffff>()
232 );
233
234 GrPipeline pipeline(GrScissorTest::kDisabled, SkBlendMode::kSrcOver,
235 flushState->drawOpArgs().fOutputSwizzle,
236 GrPipeline::InputFlags::kHWAntialias, &kStencilWrite);
237
238 GrMesh mesh(GrPrimitiveType::kTriangleStrip);
239 mesh.setInstanced(nullptr, 200*200, 0, 4);
240 flushState->rtCommandBuffer()->draw(
241 SampleLocationsTestProcessor(fGradType), pipeline, nullptr, nullptr, &mesh, 1,
242 SkRect::MakeIWH(200, 200));
243 }
244
245 const GradType fGradType;
246
247 friend class ::GrOpMemoryPool; // for ctor
248 };
249
250 ////////////////////////////////////////////////////////////////////////////////////////////////////
251 // Test.
252
onDraw(GrContext * ctx,GrRenderTargetContext * rtc,SkCanvas * canvas,SkString * errorMsg)253 DrawResult SampleLocationsGM::onDraw(
254 GrContext* ctx, GrRenderTargetContext* rtc, SkCanvas* canvas, SkString* errorMsg) {
255 if (!ctx->priv().caps()->sampleLocationsSupport()) {
256 *errorMsg = "Requires support for sample locations.";
257 return DrawResult::kSkip;
258 }
259 if (!ctx->priv().caps()->shaderCaps()->sampleVariablesSupport()) {
260 *errorMsg = "Requires support for sample variables.";
261 return DrawResult::kSkip;
262 }
263 if (rtc->numSamples() <= 1 && !ctx->priv().caps()->mixedSamplesSupport()) {
264 *errorMsg = "MSAA and mixed samples only.";
265 return DrawResult::kSkip;
266 }
267
268 auto offscreenRTC = ctx->priv().makeDeferredRenderTargetContext(
269 SkBackingFit::kExact, 200, 200, rtc->colorSpaceInfo().colorType(), nullptr,
270 rtc->numSamples(), GrMipMapped::kNo, fOrigin);
271 if (!offscreenRTC) {
272 *errorMsg = "Failed to create offscreen render target.";
273 return DrawResult::kFail;
274 }
275 if (offscreenRTC->numSamples() <= 1 &&
276 !offscreenRTC->proxy()->canUseMixedSamples(*ctx->priv().caps())) {
277 *errorMsg = "MSAA and mixed samples only.";
278 return DrawResult::kSkip;
279 }
280
281 static constexpr GrUserStencilSettings kStencilCover(
282 GrUserStencilSettings::StaticInit<
283 0x0000,
284 GrUserStencilTest::kNotEqual,
285 0xffff,
286 GrUserStencilOp::kZero,
287 GrUserStencilOp::kKeep,
288 0xffff>()
289 );
290
291 offscreenRTC->clear(nullptr, {0,1,0,1}, GrRenderTargetContext::CanClearFullscreen::kYes);
292
293 // Stencil.
294 offscreenRTC->priv().testingOnly_addDrawOp(
295 SampleLocationsTestOp::Make(ctx, canvas->getTotalMatrix(), fGradType));
296
297 // Cover.
298 GrPaint coverPaint;
299 coverPaint.setColor4f({1,0,0,1});
300 coverPaint.setXPFactory(GrPorterDuffXPFactory::Get(SkBlendMode::kSrcOver));
301 rtc->priv().stencilRect(GrNoClip(), &kStencilCover, std::move(coverPaint), GrAA::kNo,
302 SkMatrix::I(), SkRect::MakeWH(200, 200));
303
304 // Copy offscreen texture to canvas.
305 rtc->drawTexture(
306 GrNoClip(), sk_ref_sp(offscreenRTC->asTextureProxy()),
307 GrSamplerState::Filter::kNearest, SkBlendMode::kSrc, SK_PMColor4fWHITE,
308 {0,0,200,200}, {0,0,200,200}, GrAA::kNo, GrQuadAAFlags::kNone,
309 SkCanvas::SrcRectConstraint::kStrict_SrcRectConstraint, SkMatrix::I(), nullptr);
310
311 return skiagm::DrawResult::kOk;
312 }
313
314 DEF_GM( return new SampleLocationsGM(GradType::kHW, kTopLeft_GrSurfaceOrigin); )
315 DEF_GM( return new SampleLocationsGM(GradType::kHW, kBottomLeft_GrSurfaceOrigin); )
316 DEF_GM( return new SampleLocationsGM(GradType::kSW, kTopLeft_GrSurfaceOrigin); )
317 DEF_GM( return new SampleLocationsGM(GradType::kSW, kBottomLeft_GrSurfaceOrigin); )
318
319 }
320