1 /*
2 * Copyright 2019 Google LLC
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 "tools/gpu/TestOps.h"
9
10 #include "src/core/SkPointPriv.h"
11 #include "src/gpu/BufferWriter.h"
12 #include "src/gpu/GrCaps.h"
13 #include "src/gpu/GrGeometryProcessor.h"
14 #include "src/gpu/GrMemoryPool.h"
15 #include "src/gpu/GrOpFlushState.h"
16 #include "src/gpu/GrProgramInfo.h"
17 #include "src/gpu/KeyBuilder.h"
18 #include "src/gpu/glsl/GrGLSLFragmentShaderBuilder.h"
19 #include "src/gpu/glsl/GrGLSLVarying.h"
20 #include "src/gpu/glsl/GrGLSLVertexGeoBuilder.h"
21 #include "src/gpu/ops/GrSimpleMeshDrawOpHelper.h"
22
23 namespace {
24
25 class GP : public GrGeometryProcessor {
26 public:
GP(const SkMatrix & localMatrix,bool wideColor)27 GP(const SkMatrix& localMatrix, bool wideColor)
28 : GrGeometryProcessor(kTestRectOp_ClassID), fLocalMatrix(localMatrix) {
29 fInColor = MakeColorAttribute("color", wideColor);
30 this->setVertexAttributesWithImplicitOffsets(&fInPosition, 3);
31 }
32
name() const33 const char* name() const override { return "TestRectOp::GP"; }
34
makeProgramImpl(const GrShaderCaps &) const35 std::unique_ptr<ProgramImpl> makeProgramImpl(const GrShaderCaps&) const override {
36 class Impl : public ProgramImpl {
37 public:
38 void setData(const GrGLSLProgramDataManager& pdman,
39 const GrShaderCaps& shaderCaps,
40 const GrGeometryProcessor& geomProc) override {
41 const auto& gp = geomProc.cast<GP>();
42 SetTransform(pdman, shaderCaps, fLocalMatrixUni, gp.fLocalMatrix);
43 }
44
45 private:
46 void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override {
47 const auto& gp = args.fGeomProc.cast<GP>();
48 args.fVaryingHandler->emitAttributes(gp);
49 GrGLSLVarying colorVarying(SkSLType::kHalf4);
50 args.fVaryingHandler->addVarying("color", &colorVarying,
51 GrGLSLVaryingHandler::Interpolation::kCanBeFlat);
52 args.fVertBuilder->codeAppendf("%s = %s;", colorVarying.vsOut(), gp.fInColor.name());
53 args.fFragBuilder->codeAppendf("half4 %s = %s;",
54 args.fOutputColor, colorVarying.fsIn());
55 args.fFragBuilder->codeAppendf("const half4 %s = half4(1);", args.fOutputCoverage);
56 WriteOutputPosition(args.fVertBuilder, gpArgs, gp.fInPosition.name());
57 WriteLocalCoord(args.fVertBuilder,
58 args.fUniformHandler,
59 *args.fShaderCaps,
60 gpArgs,
61 gp.fInLocalCoords.asShaderVar(),
62 gp.fLocalMatrix,
63 &fLocalMatrixUni);
64 }
65
66 UniformHandle fLocalMatrixUni;
67 };
68
69 return std::make_unique<Impl>();
70 }
71
addToKey(const GrShaderCaps & shaderCaps,skgpu::KeyBuilder * b) const72 void addToKey(const GrShaderCaps& shaderCaps, skgpu::KeyBuilder* b) const override {
73 b->add32(ProgramImpl::ComputeMatrixKey(shaderCaps, fLocalMatrix));
74 }
75
wideColor() const76 bool wideColor() const { return fInColor.cpuType() != kUByte4_norm_GrVertexAttribType; }
77
78 private:
79 Attribute fInPosition = { "inPosition", kFloat2_GrVertexAttribType, SkSLType::kFloat2};
80 Attribute fInLocalCoords = {"inLocalCoords", kFloat2_GrVertexAttribType, SkSLType::kFloat2};
81 Attribute fInColor;
82
83 SkMatrix fLocalMatrix;
84 };
85
86 class TestRectOp final : public GrMeshDrawOp {
87 public:
88 static GrOp::Owner Make(GrRecordingContext*,
89 GrPaint&&,
90 const SkRect& drawRect,
91 const SkRect& localRect,
92 const SkMatrix& localM);
93
name() const94 const char* name() const override { return "TestRectOp"; }
95
fixedFunctionFlags() const96 FixedFunctionFlags fixedFunctionFlags() const override { return FixedFunctionFlags::kNone; }
97
98 GrProcessorSet::Analysis finalize(const GrCaps&,
99 const GrAppliedClip*,
100 GrClampType) override;
101
visitProxies(const GrVisitProxyFunc & func) const102 void visitProxies(const GrVisitProxyFunc& func) const override {
103 if (fProgramInfo) {
104 fProgramInfo->visitFPProxies(func);
105 } else {
106 fProcessorSet.visitProxies(func);
107 }
108 }
109
110 private:
111 DEFINE_OP_CLASS_ID
112
113 TestRectOp(const GrCaps*,
114 GrPaint&&,
115 const SkRect& drawRect,
116 const SkRect& localRect,
117 const SkMatrix& localMatrix);
118
programInfo()119 GrProgramInfo* programInfo() override { return fProgramInfo; }
120 void onCreateProgramInfo(const GrCaps*,
121 SkArenaAlloc*,
122 const GrSurfaceProxyView& writeView,
123 bool usesMSAASurface,
124 GrAppliedClip&&,
125 const GrDstProxyView&,
126 GrXferBarrierFlags renderPassXferBarriers,
127 GrLoadOp colorLoadOp) override;
128
129 void onPrepareDraws(GrMeshDrawTarget*) override;
130 void onExecute(GrOpFlushState*, const SkRect& chainBounds) override;
131
132 SkRect fDrawRect;
133 SkRect fLocalRect;
134 SkPMColor4f fColor;
135 GP fGP;
136 GrProcessorSet fProcessorSet;
137
138 // If this op is prePrepared the created programInfo will be stored here for use in
139 // onExecute. In the prePrepared case it will have been stored in the record-time arena.
140 GrProgramInfo* fProgramInfo = nullptr;
141 GrSimpleMesh* fMesh = nullptr;
142
143 friend class ::GrOp;
144 };
145
Make(GrRecordingContext * context,GrPaint && paint,const SkRect & drawRect,const SkRect & localRect,const SkMatrix & localM)146 GrOp::Owner TestRectOp::Make(GrRecordingContext* context,
147 GrPaint&& paint,
148 const SkRect& drawRect,
149 const SkRect& localRect,
150 const SkMatrix& localM) {
151 const auto* caps = context->priv().caps();
152 return GrOp::Make<TestRectOp>(context, caps, std::move(paint), drawRect, localRect, localM);
153 }
154
finalize(const GrCaps & caps,const GrAppliedClip * clip,GrClampType clampType)155 GrProcessorSet::Analysis TestRectOp::finalize(const GrCaps& caps,
156 const GrAppliedClip* clip,
157 GrClampType clampType) {
158 return fProcessorSet.finalize(GrProcessorAnalysisColor::Opaque::kYes,
159 GrProcessorAnalysisCoverage::kSingleChannel, clip,
160 &GrUserStencilSettings::kUnused, caps, clampType, &fColor);
161 }
162
use_wide_color(const GrPaint & paint,const GrCaps * caps)163 static bool use_wide_color(const GrPaint& paint, const GrCaps* caps) {
164 return !paint.getColor4f().fitsInBytes() && caps->halfFloatVertexAttributeSupport();
165 }
TestRectOp(const GrCaps * caps,GrPaint && paint,const SkRect & drawRect,const SkRect & localRect,const SkMatrix & localMatrix)166 TestRectOp::TestRectOp(const GrCaps* caps,
167 GrPaint&& paint,
168 const SkRect& drawRect,
169 const SkRect& localRect,
170 const SkMatrix& localMatrix)
171 : GrMeshDrawOp(ClassID())
172 , fDrawRect(drawRect)
173 , fLocalRect(localRect)
174 , fColor(paint.getColor4f())
175 , fGP(localMatrix, use_wide_color(paint, caps))
176 , fProcessorSet(std::move(paint)) {
177 this->setBounds(drawRect.makeSorted(), HasAABloat::kNo, IsHairline::kNo);
178 }
179
onCreateProgramInfo(const GrCaps * caps,SkArenaAlloc * arena,const GrSurfaceProxyView & writeView,bool usesMSAASurface,GrAppliedClip && appliedClip,const GrDstProxyView & dstProxyView,GrXferBarrierFlags renderPassXferBarriers,GrLoadOp colorLoadOp)180 void TestRectOp::onCreateProgramInfo(const GrCaps* caps,
181 SkArenaAlloc* arena,
182 const GrSurfaceProxyView& writeView,
183 bool usesMSAASurface,
184 GrAppliedClip&& appliedClip,
185 const GrDstProxyView& dstProxyView,
186 GrXferBarrierFlags renderPassXferBarriers,
187 GrLoadOp colorLoadOp) {
188 fProgramInfo = GrSimpleMeshDrawOpHelper::CreateProgramInfo(caps,
189 arena,
190 writeView,
191 usesMSAASurface,
192 std::move(appliedClip),
193 dstProxyView,
194 &fGP,
195 std::move(fProcessorSet),
196 GrPrimitiveType::kTriangles,
197 renderPassXferBarriers,
198 colorLoadOp,
199 GrPipeline::InputFlags::kNone);
200 }
201
onPrepareDraws(GrMeshDrawTarget * target)202 void TestRectOp::onPrepareDraws(GrMeshDrawTarget* target) {
203 QuadHelper helper(target, fGP.vertexStride(), 1);
204 skgpu::VertexWriter writer{helper.vertices()};
205 auto pos = skgpu::VertexWriter::TriStripFromRect(fDrawRect);
206 auto local = skgpu::VertexWriter::TriStripFromRect(fLocalRect);
207 skgpu::VertexColor color(fColor, fGP.wideColor());
208 writer.writeQuad(pos, local, color);
209
210 fMesh = helper.mesh();
211 }
212
onExecute(GrOpFlushState * flushState,const SkRect & chainBounds)213 void TestRectOp::onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) {
214 if (!fProgramInfo) {
215 this->createProgramInfo(flushState);
216 }
217
218 flushState->bindPipelineAndScissorClip(*fProgramInfo, chainBounds);
219 flushState->bindTextures(fProgramInfo->geomProc(), nullptr, fProgramInfo->pipeline());
220 flushState->drawMesh(*fMesh);
221 }
222
223 } // anonymous namespace
224
225 namespace sk_gpu_test::test_ops {
226
MakeRect(GrRecordingContext * context,GrPaint && paint,const SkRect & drawRect,const SkRect & localRect,const SkMatrix & localM)227 GrOp::Owner MakeRect(GrRecordingContext* context,
228 GrPaint&& paint,
229 const SkRect& drawRect,
230 const SkRect& localRect,
231 const SkMatrix& localM) {
232 return TestRectOp::Make(context, std::move(paint), drawRect, localRect, localM);
233 }
234
MakeRect(GrRecordingContext * context,std::unique_ptr<GrFragmentProcessor> fp,const SkRect & drawRect,const SkRect & localRect,const SkMatrix & localM)235 GrOp::Owner MakeRect(GrRecordingContext* context,
236 std::unique_ptr<GrFragmentProcessor> fp,
237 const SkRect& drawRect,
238 const SkRect& localRect,
239 const SkMatrix& localM) {
240 GrPaint paint;
241 paint.setColorFragmentProcessor(std::move(fp));
242 return TestRectOp::Make(context, std::move(paint), drawRect, localRect, localM);
243 }
244
MakeRect(GrRecordingContext * context,GrPaint && paint,const SkRect & rect)245 GrOp::Owner MakeRect(GrRecordingContext* context,
246 GrPaint&& paint,
247 const SkRect& rect) {
248 return TestRectOp::Make(context, std::move(paint), rect, rect, SkMatrix::I());
249 }
250
251 } // namespace sk_gpu_test::test_ops
252