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 "GrCCPRPathProcessor.h"
9
10 #include "GrOnFlushResourceProvider.h"
11 #include "GrTexture.h"
12 #include "glsl/GrGLSLFragmentShaderBuilder.h"
13 #include "glsl/GrGLSLGeometryProcessor.h"
14 #include "glsl/GrGLSLProgramBuilder.h"
15 #include "glsl/GrGLSLVarying.h"
16
17 // Slightly undershoot an AA bloat radius of 0.5 so vertices that fall on integer boundaries don't
18 // accidentally reach into neighboring path masks within the atlas.
19 constexpr float kAABloatRadius = 0.491111f;
20
21 // Paths are drawn as octagons. Each point on the octagon is the intersection of two lines: one edge
22 // from the path's bounding box and one edge from its 45-degree bounding box. The below inputs
23 // define a vertex by the two edges that need to be intersected. Normals point out of the octagon,
24 // and the bounding boxes are sent in as instance attribs.
25 static constexpr float kOctoEdgeNorms[8 * 4] = {
26 // bbox // bbox45
27 -1, 0, -1,+1,
28 -1, 0, -1,-1,
29 0,-1, -1,-1,
30 0,-1, +1,-1,
31 +1, 0, +1,-1,
32 +1, 0, +1,+1,
33 0,+1, +1,+1,
34 0,+1, -1,+1,
35 };
36
37 GR_DECLARE_STATIC_UNIQUE_KEY(gVertexBufferKey);
38
39 // Index buffer for the octagon defined above.
40 static uint16_t kOctoIndices[GrCCPRPathProcessor::kPerInstanceIndexCount] = {
41 0, 4, 2,
42 0, 6, 4,
43 0, 2, 1,
44 2, 4, 3,
45 4, 6, 5,
46 6, 0, 7,
47 };
48
49 GR_DECLARE_STATIC_UNIQUE_KEY(gIndexBufferKey);
50
GrCCPRPathProcessor(GrResourceProvider * rp,sk_sp<GrTextureProxy> atlas,SkPath::FillType fillType,const GrShaderCaps & shaderCaps)51 GrCCPRPathProcessor::GrCCPRPathProcessor(GrResourceProvider* rp, sk_sp<GrTextureProxy> atlas,
52 SkPath::FillType fillType, const GrShaderCaps& shaderCaps)
53 : fFillType(fillType) {
54 this->addInstanceAttrib("devbounds", kVec4f_GrVertexAttribType, kHigh_GrSLPrecision);
55 this->addInstanceAttrib("devbounds45", kVec4f_GrVertexAttribType, kHigh_GrSLPrecision);
56 this->addInstanceAttrib("view_matrix", kVec4f_GrVertexAttribType, kHigh_GrSLPrecision);
57 this->addInstanceAttrib("view_translate", kVec2f_GrVertexAttribType, kHigh_GrSLPrecision);
58 // FIXME: this could be a vector of two shorts if it were supported by Ganesh.
59 this->addInstanceAttrib("atlas_offset", kVec2i_GrVertexAttribType, kHigh_GrSLPrecision);
60 this->addInstanceAttrib("color", kVec4ub_GrVertexAttribType, kLow_GrSLPrecision);
61
62 SkASSERT(offsetof(Instance, fDevBounds) ==
63 this->getInstanceAttrib(InstanceAttribs::kDevBounds).fOffsetInRecord);
64 SkASSERT(offsetof(Instance, fDevBounds45) ==
65 this->getInstanceAttrib(InstanceAttribs::kDevBounds45).fOffsetInRecord);
66 SkASSERT(offsetof(Instance, fViewMatrix) ==
67 this->getInstanceAttrib(InstanceAttribs::kViewMatrix).fOffsetInRecord);
68 SkASSERT(offsetof(Instance, fViewTranslate) ==
69 this->getInstanceAttrib(InstanceAttribs::kViewTranslate).fOffsetInRecord);
70 SkASSERT(offsetof(Instance, fAtlasOffset) ==
71 this->getInstanceAttrib(InstanceAttribs::kAtlasOffset).fOffsetInRecord);
72 SkASSERT(offsetof(Instance, fColor) ==
73 this->getInstanceAttrib(InstanceAttribs::kColor).fOffsetInRecord);
74 SkASSERT(sizeof(Instance) == this->getInstanceStride());
75
76 GR_STATIC_ASSERT(6 == kNumInstanceAttribs);
77
78 this->addVertexAttrib("edge_norms", kVec4f_GrVertexAttribType, kHigh_GrSLPrecision);
79
80 fAtlasAccess.reset(std::move(atlas), GrSamplerParams::FilterMode::kNone_FilterMode,
81 SkShader::TileMode::kClamp_TileMode, kFragment_GrShaderFlag);
82 fAtlasAccess.instantiate(rp);
83 this->addTextureSampler(&fAtlasAccess);
84
85 this->initClassID<GrCCPRPathProcessor>();
86 }
87
getGLSLProcessorKey(const GrShaderCaps &,GrProcessorKeyBuilder * b) const88 void GrCCPRPathProcessor::getGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder* b) const {
89 b->add32((fFillType << 16) | this->atlas()->origin());
90 }
91
92 class GLSLPathProcessor : public GrGLSLGeometryProcessor {
93 public:
94 void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override;
95
96 private:
setData(const GrGLSLProgramDataManager & pdman,const GrPrimitiveProcessor & primProc,FPCoordTransformIter && transformIter)97 void setData(const GrGLSLProgramDataManager& pdman, const GrPrimitiveProcessor& primProc,
98 FPCoordTransformIter&& transformIter) override {
99 const GrCCPRPathProcessor& proc = primProc.cast<GrCCPRPathProcessor>();
100 pdman.set2f(fAtlasAdjustUniform, 1.0f / proc.atlas()->width(),
101 1.0f / proc.atlas()->height());
102 this->setTransformDataHelper(SkMatrix::I(), pdman, &transformIter);
103 }
104
105 GrGLSLUniformHandler::UniformHandle fAtlasAdjustUniform;
106
107 typedef GrGLSLGeometryProcessor INHERITED;
108 };
109
createGLSLInstance(const GrShaderCaps &) const110 GrGLSLPrimitiveProcessor* GrCCPRPathProcessor::createGLSLInstance(const GrShaderCaps&) const {
111 return new GLSLPathProcessor();
112 }
113
onEmitCode(EmitArgs & args,GrGPArgs * gpArgs)114 void GLSLPathProcessor::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) {
115 using InstanceAttribs = GrCCPRPathProcessor::InstanceAttribs;
116 const GrCCPRPathProcessor& proc = args.fGP.cast<GrCCPRPathProcessor>();
117 GrGLSLUniformHandler* uniHandler = args.fUniformHandler;
118 GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;
119
120 const char* atlasAdjust;
121 fAtlasAdjustUniform = uniHandler->addUniform(
122 kVertex_GrShaderFlag,
123 kVec2f_GrSLType, kHigh_GrSLPrecision, "atlas_adjust", &atlasAdjust);
124
125 varyingHandler->emitAttributes(proc);
126
127 GrGLSLVertToFrag texcoord(kVec2f_GrSLType);
128 GrGLSLVertToFrag color(kVec4f_GrSLType);
129 varyingHandler->addVarying("texcoord", &texcoord, kHigh_GrSLPrecision);
130 varyingHandler->addFlatPassThroughAttribute(&proc.getInstanceAttrib(InstanceAttribs::kColor),
131 args.fOutputColor, kLow_GrSLPrecision);
132
133 // Vertex shader.
134 GrGLSLVertexBuilder* v = args.fVertBuilder;
135
136 // Find the intersections of (bloated) devBounds and devBounds45 in order to come up with an
137 // octagon that circumscribes the (bloated) path. A vertex is the intersection of two lines:
138 // one edge from the path's bounding box and one edge from its 45-degree bounding box.
139 v->codeAppendf("highp mat2 N = mat2(%s);", proc.getEdgeNormsAttrib().fName);
140
141 // N[0] is the normal for the edge we are intersecting from the regular bounding box, pointing
142 // out of the octagon.
143 v->codeAppendf("highp vec2 refpt = (min(N[0].x, N[0].y) < 0) ? %s.xy : %s.zw;",
144 proc.getInstanceAttrib(InstanceAttribs::kDevBounds).fName,
145 proc.getInstanceAttrib(InstanceAttribs::kDevBounds).fName);
146 v->codeAppendf("refpt += N[0] * %f;", kAABloatRadius); // bloat for AA.
147
148 // N[1] is the normal for the edge we are intersecting from the 45-degree bounding box, pointing
149 // out of the octagon.
150 v->codeAppendf("highp vec2 refpt45 = (N[1].x < 0) ? %s.xy : %s.zw;",
151 proc.getInstanceAttrib(InstanceAttribs::kDevBounds45).fName,
152 proc.getInstanceAttrib(InstanceAttribs::kDevBounds45).fName);
153 v->codeAppendf("refpt45 *= mat2(.5,.5,-.5,.5);"); // transform back to device space.
154 v->codeAppendf("refpt45 += N[1] * %f;", kAABloatRadius); // bloat for AA.
155
156 v->codeAppend ("highp vec2 K = vec2(dot(N[0], refpt), dot(N[1], refpt45));");
157 v->codeAppendf("highp vec2 octocoord = K * inverse(N);");
158
159 gpArgs->fPositionVar.set(kVec2f_GrSLType, "octocoord");
160
161 // Convert to atlas coordinates in order to do our texture lookup.
162 v->codeAppendf("highp vec2 atlascoord = octocoord + vec2(%s);",
163 proc.getInstanceAttrib(InstanceAttribs::kAtlasOffset).fName);
164 if (kTopLeft_GrSurfaceOrigin == proc.atlas()->origin()) {
165 v->codeAppendf("%s = atlascoord * %s;", texcoord.vsOut(), atlasAdjust);
166 } else {
167 SkASSERT(kBottomLeft_GrSurfaceOrigin == proc.atlas()->origin());
168 v->codeAppendf("%s = vec2(atlascoord.x * %s.x, 1 - atlascoord.y * %s.y);",
169 texcoord.vsOut(), atlasAdjust, atlasAdjust);
170 }
171
172 // Convert to (local) path cordinates.
173 v->codeAppendf("highp vec2 pathcoord = inverse(mat2(%s)) * (octocoord - %s);",
174 proc.getInstanceAttrib(InstanceAttribs::kViewMatrix).fName,
175 proc.getInstanceAttrib(InstanceAttribs::kViewTranslate).fName);
176
177 this->emitTransforms(v, varyingHandler, uniHandler, gpArgs->fPositionVar, "pathcoord",
178 args.fFPCoordTransformHandler);
179
180 // Fragment shader.
181 GrGLSLPPFragmentBuilder* f = args.fFragBuilder;
182
183 f->codeAppend ("mediump float coverage_count = ");
184 f->appendTextureLookup(args.fTexSamplers[0], texcoord.fsIn(), kVec2f_GrSLType);
185 f->codeAppend (".a;");
186
187 if (SkPath::kWinding_FillType == proc.fillType()) {
188 f->codeAppendf("%s = vec4(min(abs(coverage_count), 1));", args.fOutputCoverage);
189 } else {
190 SkASSERT(SkPath::kEvenOdd_FillType == proc.fillType());
191 f->codeAppend ("mediump float t = mod(abs(coverage_count), 2);");
192 f->codeAppendf("%s = vec4(1 - abs(t - 1));", args.fOutputCoverage);
193 }
194 }
195
FindOrMakeIndexBuffer(GrOnFlushResourceProvider * onFlushRP)196 sk_sp<GrBuffer> GrCCPRPathProcessor::FindOrMakeIndexBuffer(GrOnFlushResourceProvider* onFlushRP) {
197 GR_DEFINE_STATIC_UNIQUE_KEY(gIndexBufferKey);
198 return onFlushRP->findOrMakeStaticBuffer(gIndexBufferKey, kIndex_GrBufferType,
199 sizeof(kOctoIndices), kOctoIndices);
200 }
201
FindOrMakeVertexBuffer(GrOnFlushResourceProvider * onFlushRP)202 sk_sp<GrBuffer> GrCCPRPathProcessor::FindOrMakeVertexBuffer(GrOnFlushResourceProvider* onFlushRP) {
203 GR_DEFINE_STATIC_UNIQUE_KEY(gVertexBufferKey);
204 return onFlushRP->findOrMakeStaticBuffer(gVertexBufferKey, kVertex_GrBufferType,
205 sizeof(kOctoEdgeNorms), kOctoEdgeNorms);
206 }
207