1 /*
2 * Copyright 2018 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.h"
9 #include "sk_tool_utils.h"
10 #include "SkTextUtils.h"
11
12 #if SK_SUPPORT_GPU
13
14 #include "GrContext.h"
15 #include "GrGpuCommandBuffer.h"
16 #include "GrMemoryPool.h"
17 #include "GrRenderTargetContext.h"
18 #include "GrRenderTargetContextPriv.h"
19 #include "glsl/GrGLSLFragmentShaderBuilder.h"
20 #include "glsl/GrGLSLGeometryProcessor.h"
21 #include "glsl/GrGLSLVarying.h"
22 #include "glsl/GrGLSLVertexGeoBuilder.h"
23
24 namespace skiagm {
25
26 static constexpr GrGeometryProcessor::Attribute gVertex =
27 {"bboxcoord", kFloat2_GrVertexAttribType, kFloat2_GrSLType};
28
29 /**
30 * This ensures that fwidth() works properly on GPU configs by drawing a squircle.
31 */
32 class FwidthSquircleGM : public GM {
33 private:
onShortName()34 SkString onShortName() final { return SkString("fwidth_squircle"); }
onISize()35 SkISize onISize() override { return SkISize::Make(200, 200); }
36 void onDraw(SkCanvas*) override;
37 };
38
39 ////////////////////////////////////////////////////////////////////////////////////////////////////
40 // SkSL code.
41
42 class FwidthSquircleTestProcessor : public GrGeometryProcessor {
43 public:
FwidthSquircleTestProcessor(const SkMatrix & viewMatrix)44 FwidthSquircleTestProcessor(const SkMatrix& viewMatrix)
45 : GrGeometryProcessor(kFwidthSquircleTestProcessor_ClassID)
46 , fViewMatrix(viewMatrix) {
47 this->setVertexAttributes(&gVertex, 1);
48 }
name() const49 const char* name() const override { return "FwidthSquircleTestProcessor"; }
getGLSLProcessorKey(const GrShaderCaps &,GrProcessorKeyBuilder * b) const50 void getGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder* b) const final {}
51 GrGLSLPrimitiveProcessor* createGLSLInstance(const GrShaderCaps&) const final;
52
53 private:
54 const SkMatrix fViewMatrix;
55
56 class Impl;
57 };
58
59 class FwidthSquircleTestProcessor::Impl : public GrGLSLGeometryProcessor {
onEmitCode(EmitArgs & args,GrGPArgs * gpArgs)60 void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override {
61 const auto& proc = args.fGP.cast<FwidthSquircleTestProcessor>();
62
63 auto* uniforms = args.fUniformHandler;
64 fViewMatrixHandle =
65 uniforms->addUniform(kVertex_GrShaderFlag, kFloat3x3_GrSLType, "viewmatrix");
66
67 auto* varyings = args.fVaryingHandler;
68 varyings->emitAttributes(proc);
69
70 GrGLSLVarying squircleCoord(kFloat2_GrSLType);
71 varyings->addVarying("bboxcoord", &squircleCoord);
72
73 auto* v = args.fVertBuilder;
74 v->codeAppendf("float2x2 R = float2x2(cos(.05), sin(.05), -sin(.05), cos(.05));");
75
76 v->codeAppendf("%s = bboxcoord * 1.25;", squircleCoord.vsOut());
77 v->codeAppendf("float3 vertexpos = float3(bboxcoord * 100 * R + 100, 1);");
78 v->codeAppendf("vertexpos = %s * vertexpos;", uniforms->getUniformCStr(fViewMatrixHandle));
79 gpArgs->fPositionVar.set(kFloat3_GrSLType, "vertexpos");
80
81 auto* f = args.fFragBuilder;
82 f->codeAppendf("float golden_ratio = 1.61803398875;");
83 f->codeAppendf("float pi = 3.141592653589793;");
84 f->codeAppendf("float x = abs(%s.x), y = abs(%s.y);",
85 squircleCoord.fsIn(), squircleCoord.fsIn());
86
87 // Squircle function!
88 f->codeAppendf("float fn = pow(x, golden_ratio*pi) + pow(y, golden_ratio*pi) - 1;");
89 f->codeAppendf("float fnwidth = fwidth(fn);");
90 f->codeAppendf("fnwidth += 1e-10;"); // Guard against divide-by-zero.
91 f->codeAppendf("half coverage = clamp(.5 - fn/fnwidth, 0, 1);");
92
93 f->codeAppendf("%s = half4(.51, .42, .71, 1) * .89;", args.fOutputColor);
94 f->codeAppendf("%s = half4(coverage);", args.fOutputCoverage);
95 }
96
setData(const GrGLSLProgramDataManager & pdman,const GrPrimitiveProcessor & primProc,FPCoordTransformIter && transformIter)97 void setData(const GrGLSLProgramDataManager& pdman, const GrPrimitiveProcessor& primProc,
98 FPCoordTransformIter&& transformIter) override {
99 const auto& proc = primProc.cast<FwidthSquircleTestProcessor>();
100 pdman.setSkMatrix(fViewMatrixHandle, proc.fViewMatrix);
101 }
102
103 UniformHandle fViewMatrixHandle;
104 };
105
createGLSLInstance(const GrShaderCaps &) const106 GrGLSLPrimitiveProcessor* FwidthSquircleTestProcessor::createGLSLInstance(
107 const GrShaderCaps&) const {
108 return new Impl();
109 }
110
111 ////////////////////////////////////////////////////////////////////////////////////////////////////
112 // Draw Op.
113
114 class FwidthSquircleTestOp : public GrDrawOp {
115 public:
116 DEFINE_OP_CLASS_ID
117
Make(GrContext * ctx,const SkMatrix & viewMatrix)118 static std::unique_ptr<GrDrawOp> Make(GrContext* ctx, const SkMatrix& viewMatrix) {
119 GrOpMemoryPool* pool = ctx->contextPriv().opMemoryPool();
120 return pool->allocate<FwidthSquircleTestOp>(viewMatrix);
121 }
122
123 private:
FwidthSquircleTestOp(const SkMatrix & viewMatrix)124 FwidthSquircleTestOp(const SkMatrix& viewMatrix)
125 : GrDrawOp(ClassID())
126 , fViewMatrix(viewMatrix) {
127 this->setBounds(SkRect::MakeIWH(200, 200), HasAABloat::kNo, IsZeroArea::kNo);
128 }
129
name() const130 const char* name() const override { return "ClockwiseTestOp"; }
fixedFunctionFlags() const131 FixedFunctionFlags fixedFunctionFlags() const override { return FixedFunctionFlags::kNone; }
finalize(const GrCaps &,const GrAppliedClip *)132 GrProcessorSet::Analysis finalize(const GrCaps&, const GrAppliedClip*) override {
133 return GrProcessorSet::EmptySetAnalysis();
134 }
onPrepare(GrOpFlushState *)135 void onPrepare(GrOpFlushState*) override {}
onExecute(GrOpFlushState * flushState,const SkRect & chainBounds)136 void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override {
137 SkPoint vertices[4] = {
138 {-1, -1},
139 {+1, -1},
140 {-1, +1},
141 {+1, +1},
142 };
143 sk_sp<const GrBuffer> vertexBuffer(flushState->resourceProvider()->createBuffer(
144 sizeof(vertices), kVertex_GrBufferType, kStatic_GrAccessPattern,
145 GrResourceProvider::Flags::kNone, vertices));
146 if (!vertexBuffer) {
147 return;
148 }
149 GrPipeline pipeline(GrScissorTest::kDisabled, SkBlendMode::kSrcOver);
150 GrMesh mesh(GrPrimitiveType::kTriangleStrip);
151 mesh.setNonIndexedNonInstanced(4);
152 mesh.setVertexData(std::move(vertexBuffer));
153 flushState->rtCommandBuffer()->draw(FwidthSquircleTestProcessor(fViewMatrix), pipeline,
154 nullptr, nullptr, &mesh, 1, SkRect::MakeIWH(100, 100));
155 }
156
157 const SkMatrix fViewMatrix;
158
159 friend class ::GrOpMemoryPool; // for ctor
160 };
161
162 ////////////////////////////////////////////////////////////////////////////////////////////////////
163 // Test.
164
onDraw(SkCanvas * canvas)165 void FwidthSquircleGM::onDraw(SkCanvas* canvas) {
166 GrContext* ctx = canvas->getGrContext();
167 GrRenderTargetContext* rtc = canvas->internal_private_accessTopLayerRenderTargetContext();
168
169 canvas->clear(SK_ColorWHITE);
170
171 if (!ctx || !rtc) {
172 DrawGpuOnlyMessage(canvas);
173 return;
174 }
175
176 if (!ctx->contextPriv().caps()->shaderCaps()->shaderDerivativeSupport()) {
177 SkFont font(sk_tool_utils::create_portable_typeface(), 15);
178 SkTextUtils::DrawString(canvas, "Shader derivatives not supported.", 150,
179 150 - 8, font, SkPaint(), SkTextUtils::kCenter_Align);
180 return;
181 }
182
183 // Draw the test directly to the frame buffer.
184 rtc->priv().testingOnly_addDrawOp(FwidthSquircleTestOp::Make(ctx, canvas->getTotalMatrix()));
185 }
186
187 DEF_GM( return new FwidthSquircleGM(); )
188
189 }
190
191 #endif // SK_SUPPORT_GPU
192