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 "src/gpu/ccpr/GrCCPathProcessor.h"
9
10 #include "include/gpu/GrTexture.h"
11 #include "src/gpu/GrOnFlushResourceProvider.h"
12 #include "src/gpu/GrOpsRenderPass.h"
13 #include "src/gpu/GrTexturePriv.h"
14 #include "src/gpu/ccpr/GrCCPerFlushResources.h"
15 #include "src/gpu/glsl/GrGLSLFragmentShaderBuilder.h"
16 #include "src/gpu/glsl/GrGLSLGeometryProcessor.h"
17 #include "src/gpu/glsl/GrGLSLProgramBuilder.h"
18 #include "src/gpu/glsl/GrGLSLVarying.h"
19
20 // Paths are drawn as octagons. Each point on the octagon is the intersection of two lines: one edge
21 // from the path's bounding box and one edge from its 45-degree bounding box. The selectors
22 // below indicate one corner from the bounding box, paired with a corner from the 45-degree bounding
23 // box. The octagon vertex is the point that lies between these two corners, found by intersecting
24 // their edges.
25 static constexpr float kOctoEdgeNorms[8*4] = {
26 // bbox // bbox45
27 0,0, 0,0,
28 0,0, 1,0,
29 1,0, 1,0,
30 1,0, 1,1,
31 1,1, 1,1,
32 1,1, 0,1,
33 0,1, 0,1,
34 0,1, 0,0,
35 };
36
37 GR_DECLARE_STATIC_UNIQUE_KEY(gVertexBufferKey);
38
FindVertexBuffer(GrOnFlushResourceProvider * onFlushRP)39 sk_sp<const GrGpuBuffer> GrCCPathProcessor::FindVertexBuffer(GrOnFlushResourceProvider* onFlushRP) {
40 GR_DEFINE_STATIC_UNIQUE_KEY(gVertexBufferKey);
41 return onFlushRP->findOrMakeStaticBuffer(GrGpuBufferType::kVertex, sizeof(kOctoEdgeNorms),
42 kOctoEdgeNorms, gVertexBufferKey);
43 }
44
45 static constexpr uint16_t kRestartStrip = 0xffff;
46
47 static constexpr uint16_t kOctoIndicesAsStrips[] = {
48 3, 4, 2, 0, 1, kRestartStrip, // First half.
49 7, 0, 6, 4, 5 // Second half.
50 };
51
52 static constexpr uint16_t kOctoIndicesAsTris[] = {
53 // First half.
54 3, 4, 2,
55 4, 0, 2,
56 2, 0, 1,
57
58 // Second half.
59 7, 0, 6,
60 0, 4, 6,
61 6, 4, 5,
62 };
63
64 GR_DECLARE_STATIC_UNIQUE_KEY(gIndexBufferKey);
65
66 constexpr GrPrimitiveProcessor::Attribute GrCCPathProcessor::kInstanceAttribs[];
67 constexpr GrPrimitiveProcessor::Attribute GrCCPathProcessor::kCornersAttrib;
68
FindIndexBuffer(GrOnFlushResourceProvider * onFlushRP)69 sk_sp<const GrGpuBuffer> GrCCPathProcessor::FindIndexBuffer(GrOnFlushResourceProvider* onFlushRP) {
70 GR_DEFINE_STATIC_UNIQUE_KEY(gIndexBufferKey);
71 if (onFlushRP->caps()->usePrimitiveRestart()) {
72 return onFlushRP->findOrMakeStaticBuffer(GrGpuBufferType::kIndex,
73 sizeof(kOctoIndicesAsStrips), kOctoIndicesAsStrips,
74 gIndexBufferKey);
75 } else {
76 return onFlushRP->findOrMakeStaticBuffer(GrGpuBufferType::kIndex,
77 sizeof(kOctoIndicesAsTris), kOctoIndicesAsTris,
78 gIndexBufferKey);
79 }
80 }
81
GrCCPathProcessor(CoverageMode coverageMode,const GrTexture * atlasTexture,const GrSwizzle & swizzle,GrSurfaceOrigin atlasOrigin,const SkMatrix & viewMatrixIfUsingLocalCoords)82 GrCCPathProcessor::GrCCPathProcessor(CoverageMode coverageMode, const GrTexture* atlasTexture,
83 const GrSwizzle& swizzle, GrSurfaceOrigin atlasOrigin,
84 const SkMatrix& viewMatrixIfUsingLocalCoords)
85 : INHERITED(kGrCCPathProcessor_ClassID)
86 , fCoverageMode(coverageMode)
87 , fAtlasAccess(GrSamplerState::Filter::kNearest, atlasTexture->backendFormat(), swizzle)
88 , fAtlasDimensions(atlasTexture->dimensions())
89 , fAtlasOrigin(atlasOrigin) {
90 // TODO: Can we just assert that atlas has GrCCAtlas::kTextureOrigin and remove fAtlasOrigin?
91 this->setInstanceAttributes(kInstanceAttribs, SK_ARRAY_COUNT(kInstanceAttribs));
92 SkASSERT(this->instanceStride() == sizeof(Instance));
93
94 this->setVertexAttributes(&kCornersAttrib, 1);
95 this->setTextureSamplerCnt(1);
96
97 if (!viewMatrixIfUsingLocalCoords.invert(&fLocalMatrix)) {
98 fLocalMatrix.setIdentity();
99 }
100 }
101
102 class GrCCPathProcessor::Impl : public GrGLSLGeometryProcessor {
103 public:
104 void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override;
105
106 private:
setData(const GrGLSLProgramDataManager & pdman,const GrPrimitiveProcessor & primProc,const CoordTransformRange & transformRange)107 void setData(const GrGLSLProgramDataManager& pdman, const GrPrimitiveProcessor& primProc,
108 const CoordTransformRange& transformRange) override {
109 const auto& proc = primProc.cast<GrCCPathProcessor>();
110 pdman.set2f(fAtlasAdjustUniform,
111 1.0f / proc.fAtlasDimensions.fWidth,
112 1.0f / proc.fAtlasDimensions.fHeight);
113 this->setTransformDataHelper(proc.fLocalMatrix, pdman, transformRange);
114 }
115
116 GrGLSLUniformHandler::UniformHandle fAtlasAdjustUniform;
117
118 typedef GrGLSLGeometryProcessor INHERITED;
119 };
120
createGLSLInstance(const GrShaderCaps &) const121 GrGLSLPrimitiveProcessor* GrCCPathProcessor::createGLSLInstance(const GrShaderCaps&) const {
122 return new Impl();
123 }
124
drawPaths(GrOpFlushState * flushState,const GrPipeline & pipeline,const GrPipeline::FixedDynamicState * fixedDynamicState,const GrCCPerFlushResources & resources,int baseInstance,int endInstance,const SkRect & bounds) const125 void GrCCPathProcessor::drawPaths(GrOpFlushState* flushState, const GrPipeline& pipeline,
126 const GrPipeline::FixedDynamicState* fixedDynamicState,
127 const GrCCPerFlushResources& resources, int baseInstance,
128 int endInstance, const SkRect& bounds) const {
129 const GrCaps& caps = flushState->caps();
130 GrPrimitiveType primitiveType = caps.usePrimitiveRestart()
131 ? GrPrimitiveType::kTriangleStrip
132 : GrPrimitiveType::kTriangles;
133 int numIndicesPerInstance = caps.usePrimitiveRestart()
134 ? SK_ARRAY_COUNT(kOctoIndicesAsStrips)
135 : SK_ARRAY_COUNT(kOctoIndicesAsTris);
136 auto enablePrimitiveRestart = GrPrimitiveRestart(flushState->caps().usePrimitiveRestart());
137
138 GrMesh mesh;
139 mesh.setIndexedInstanced(resources.refIndexBuffer(), numIndicesPerInstance,
140 resources.refInstanceBuffer(), endInstance - baseInstance,
141 baseInstance, enablePrimitiveRestart);
142 mesh.setVertexData(resources.refVertexBuffer());
143
144 GrProgramInfo programInfo(flushState->proxy()->numSamples(),
145 flushState->proxy()->numStencilSamples(),
146 flushState->proxy()->backendFormat(),
147 flushState->view()->origin(),
148 &pipeline,
149 this,
150 fixedDynamicState,
151 nullptr, 0, primitiveType);
152
153 flushState->opsRenderPass()->bindPipeline(programInfo, bounds);
154 flushState->opsRenderPass()->drawMeshes(programInfo, &mesh, 1);
155 }
156
onEmitCode(EmitArgs & args,GrGPArgs * gpArgs)157 void GrCCPathProcessor::Impl::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) {
158 using Interpolation = GrGLSLVaryingHandler::Interpolation;
159
160 const GrCCPathProcessor& proc = args.fGP.cast<GrCCPathProcessor>();
161 GrGLSLUniformHandler* uniHandler = args.fUniformHandler;
162 GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;
163 bool isCoverageCount = (CoverageMode::kCoverageCount == proc.fCoverageMode);
164
165 const char* atlasAdjust;
166 fAtlasAdjustUniform = uniHandler->addUniform(
167 kVertex_GrShaderFlag, kFloat2_GrSLType, "atlas_adjust", &atlasAdjust);
168
169 varyingHandler->emitAttributes(proc);
170
171 GrGLSLVarying texcoord((isCoverageCount) ? kFloat3_GrSLType : kFloat2_GrSLType);
172 varyingHandler->addVarying("texcoord", &texcoord);
173
174 GrGLSLVarying color(kHalf4_GrSLType);
175 varyingHandler->addPassThroughAttribute(
176 kInstanceAttribs[kColorAttribIdx], args.fOutputColor, Interpolation::kCanBeFlat);
177
178 // The vertex shader bloats and intersects the devBounds and devBounds45 rectangles, in order to
179 // find an octagon that circumscribes the (bloated) path.
180 GrGLSLVertexBuilder* v = args.fVertBuilder;
181
182 // Are we clockwise? (Positive wind => nonzero fill rule.)
183 // Or counter-clockwise? (negative wind => even/odd fill rule.)
184 v->codeAppendf("float wind = sign(devbounds.z - devbounds.x);");
185
186 // Find our reference corner from the device-space bounding box.
187 v->codeAppendf("float2 refpt = mix(devbounds.xy, devbounds.zw, corners.xy);");
188
189 // Find our reference corner from the 45-degree bounding box.
190 v->codeAppendf("float2 refpt45 = mix(devbounds45.xy, devbounds45.zw, corners.zw);");
191 // Transform back to device space.
192 v->codeAppendf("refpt45 *= float2x2(+1, +1, -wind, +wind) * .5;");
193
194 // Find the normals to each edge, then intersect them to find our octagon vertex.
195 v->codeAppendf("float2x2 N = float2x2("
196 "corners.z + corners.w - 1, corners.w - corners.z, "
197 "corners.xy*2 - 1);");
198 v->codeAppendf("N = float2x2(wind, 0, 0, 1) * N;");
199 v->codeAppendf("float2 K = float2(dot(N[0], refpt), dot(N[1], refpt45));");
200 v->codeAppendf("float2 octocoord = K * inverse(N);");
201
202 // Round the octagon out to ensure we rasterize every pixel the path might touch. (Positive
203 // bloatdir means we should take the "ceil" and negative means to take the "floor".)
204 //
205 // NOTE: If we were just drawing a rect, ceil/floor would be enough. But since there are also
206 // diagonals in the octagon that cross through pixel centers, we need to outset by another
207 // quarter px to ensure those pixels get rasterized.
208 v->codeAppendf("float2 bloatdir = (0 != N[0].x) "
209 "? float2(N[0].x, N[1].y)"
210 ": float2(N[1].x, N[0].y);");
211 v->codeAppendf("octocoord = (ceil(octocoord * bloatdir - 1e-4) + 0.25) * bloatdir;");
212 v->codeAppendf("float2 atlascoord = octocoord + float2(dev_to_atlas_offset);");
213
214 // Convert to atlas coordinates in order to do our texture lookup.
215 if (kTopLeft_GrSurfaceOrigin == proc.fAtlasOrigin) {
216 v->codeAppendf("%s.xy = atlascoord * %s;", texcoord.vsOut(), atlasAdjust);
217 } else {
218 SkASSERT(kBottomLeft_GrSurfaceOrigin == proc.fAtlasOrigin);
219 v->codeAppendf("%s.xy = float2(atlascoord.x * %s.x, 1 - atlascoord.y * %s.y);",
220 texcoord.vsOut(), atlasAdjust, atlasAdjust);
221 }
222 if (isCoverageCount) {
223 v->codeAppendf("%s.z = wind * .5;", texcoord.vsOut());
224 }
225
226 gpArgs->fPositionVar.set(kFloat2_GrSLType, "octocoord");
227 this->emitTransforms(v, varyingHandler, uniHandler, gpArgs->fPositionVar, proc.fLocalMatrix,
228 args.fFPCoordTransformHandler);
229
230 // Fragment shader.
231 GrGLSLFPFragmentBuilder* f = args.fFragBuilder;
232
233 // Look up coverage in the atlas.
234 f->codeAppendf("half coverage = ");
235 f->appendTextureLookup(args.fTexSamplers[0], SkStringPrintf("%s.xy", texcoord.fsIn()).c_str());
236 f->codeAppendf(".a;");
237
238 if (isCoverageCount) {
239 f->codeAppendf("coverage = abs(coverage);");
240
241 // Scale coverage count by .5. Make it negative for even-odd paths and positive for
242 // winding ones. Clamp winding coverage counts at 1.0 (i.e. min(coverage/2, .5)).
243 f->codeAppendf("coverage = min(abs(coverage) * half(%s.z), .5);", texcoord.fsIn());
244
245 // For negative values, this finishes the even-odd sawtooth function. Since positive
246 // (winding) values were clamped at "coverage/2 = .5", this only undoes the previous
247 // multiply by .5.
248 f->codeAppend ("coverage = 1 - abs(fract(coverage) * 2 - 1);");
249 }
250
251 f->codeAppendf("%s = half4(coverage);", args.fOutputCoverage);
252 }
253