GrCCPRPathProcessor.cpp revision 1a325d25b941ef801b3e9b2c0342da43cf35cdba 
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.
19constexpr 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.
25static 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
37GR_DECLARE_STATIC_UNIQUE_KEY(gVertexBufferKey);
38
39// Index buffer for the octagon defined above.
40static 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
49GR_DECLARE_STATIC_UNIQUE_KEY(gIndexBufferKey);
50
51GrCCPRPathProcessor::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
88void GrCCPRPathProcessor::getGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder* b) const {
89    b->add32((fFillType << 16) | this->atlas()->origin());
90}
91
92class GLSLPathProcessor : public GrGLSLGeometryProcessor {
93public:
94    void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override;
95
96private:
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
110GrGLSLPrimitiveProcessor* GrCCPRPathProcessor::createGLSLInstance(const GrShaderCaps&) const {
111    return new GLSLPathProcessor();
112}
113
114void 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
196sk_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
202sk_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