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 "GrCCPathProcessor.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 sk_sp<const GrBuffer> GrCCPathProcessor::FindVertexBuffer(GrOnFlushResourceProvider* onFlushRP) { 40 GR_DEFINE_STATIC_UNIQUE_KEY(gVertexBufferKey); 41 return onFlushRP->findOrMakeStaticBuffer(kVertex_GrBufferType, sizeof(kOctoEdgeNorms), 42 kOctoEdgeNorms, gVertexBufferKey); 43 } 44 45 static constexpr uint16_t kRestartStrip = 0xffff; 46 47 static constexpr uint16_t kOctoIndicesAsStrips[] = { 48 1, 0, 2, 4, 3, kRestartStrip, // First half. 49 5, 4, 6, 0, 7 // Second half. 50 }; 51 52 static constexpr uint16_t kOctoIndicesAsTris[] = { 53 // First half. 54 1, 0, 2, 55 0, 4, 2, 56 2, 4, 3, 57 58 // Second half. 59 5, 4, 6, 60 4, 0, 6, 61 6, 0, 7, 62 }; 63 64 GR_DECLARE_STATIC_UNIQUE_KEY(gIndexBufferKey); 65 66 sk_sp<const GrBuffer> GrCCPathProcessor::FindIndexBuffer(GrOnFlushResourceProvider* onFlushRP) { 67 GR_DEFINE_STATIC_UNIQUE_KEY(gIndexBufferKey); 68 if (onFlushRP->caps()->usePrimitiveRestart()) { 69 return onFlushRP->findOrMakeStaticBuffer(kIndex_GrBufferType, sizeof(kOctoIndicesAsStrips), 70 kOctoIndicesAsStrips, gIndexBufferKey); 71 } else { 72 return onFlushRP->findOrMakeStaticBuffer(kIndex_GrBufferType, sizeof(kOctoIndicesAsTris), 73 kOctoIndicesAsTris, gIndexBufferKey); 74 } 75 } 76 77 int GrCCPathProcessor::NumIndicesPerInstance(const GrCaps& caps) { 78 return caps.usePrimitiveRestart() ? SK_ARRAY_COUNT(kOctoIndicesAsStrips) 79 : SK_ARRAY_COUNT(kOctoIndicesAsTris); 80 } 81 82 GrCCPathProcessor::GrCCPathProcessor(GrResourceProvider* resourceProvider, 83 sk_sp<GrTextureProxy> atlas, SkPath::FillType fillType) 84 : INHERITED(kGrCCPathProcessor_ClassID) 85 , fFillType(fillType) 86 , fAtlasAccess(std::move(atlas), GrSamplerState::Filter::kNearest, 87 GrSamplerState::WrapMode::kClamp, kFragment_GrShaderFlag) { 88 this->addInstanceAttrib("devbounds", kFloat4_GrVertexAttribType); 89 this->addInstanceAttrib("devbounds45", kFloat4_GrVertexAttribType); 90 this->addInstanceAttrib("view_matrix", kFloat4_GrVertexAttribType); 91 this->addInstanceAttrib("view_translate", kFloat2_GrVertexAttribType); 92 this->addInstanceAttrib("atlas_offset", kShort2_GrVertexAttribType); 93 this->addInstanceAttrib("color", kUByte4_norm_GrVertexAttribType); 94 95 SkASSERT(offsetof(Instance, fDevBounds) == 96 this->getInstanceAttrib(InstanceAttribs::kDevBounds).fOffsetInRecord); 97 SkASSERT(offsetof(Instance, fDevBounds45) == 98 this->getInstanceAttrib(InstanceAttribs::kDevBounds45).fOffsetInRecord); 99 SkASSERT(offsetof(Instance, fViewMatrix) == 100 this->getInstanceAttrib(InstanceAttribs::kViewMatrix).fOffsetInRecord); 101 SkASSERT(offsetof(Instance, fViewTranslate) == 102 this->getInstanceAttrib(InstanceAttribs::kViewTranslate).fOffsetInRecord); 103 SkASSERT(offsetof(Instance, fAtlasOffset) == 104 this->getInstanceAttrib(InstanceAttribs::kAtlasOffset).fOffsetInRecord); 105 SkASSERT(offsetof(Instance, fColor) == 106 this->getInstanceAttrib(InstanceAttribs::kColor).fOffsetInRecord); 107 SkASSERT(sizeof(Instance) == this->getInstanceStride()); 108 109 GR_STATIC_ASSERT(6 == kNumInstanceAttribs); 110 111 this->addVertexAttrib("edge_norms", kFloat4_GrVertexAttribType); 112 113 fAtlasAccess.instantiate(resourceProvider); 114 this->addTextureSampler(&fAtlasAccess); 115 116 if (resourceProvider->caps()->usePrimitiveRestart()) { 117 this->setWillUsePrimitiveRestart(); 118 } 119 } 120 121 void GrCCPathProcessor::getGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder* b) const { 122 b->add32((fFillType << 16) | this->atlasProxy()->origin()); 123 } 124 125 class GLSLPathProcessor : public GrGLSLGeometryProcessor { 126 public: 127 void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override; 128 129 private: 130 void setData(const GrGLSLProgramDataManager& pdman, const GrPrimitiveProcessor& primProc, 131 FPCoordTransformIter&& transformIter) override { 132 const GrCCPathProcessor& proc = primProc.cast<GrCCPathProcessor>(); 133 pdman.set2f(fAtlasAdjustUniform, 1.0f / proc.atlas()->width(), 134 1.0f / proc.atlas()->height()); 135 this->setTransformDataHelper(SkMatrix::I(), pdman, &transformIter); 136 } 137 138 GrGLSLUniformHandler::UniformHandle fAtlasAdjustUniform; 139 140 typedef GrGLSLGeometryProcessor INHERITED; 141 }; 142 143 GrGLSLPrimitiveProcessor* GrCCPathProcessor::createGLSLInstance(const GrShaderCaps&) const { 144 return new GLSLPathProcessor(); 145 } 146 147 void GLSLPathProcessor::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { 148 using InstanceAttribs = GrCCPathProcessor::InstanceAttribs; 149 using Interpolation = GrGLSLVaryingHandler::Interpolation; 150 151 const GrCCPathProcessor& proc = args.fGP.cast<GrCCPathProcessor>(); 152 GrGLSLUniformHandler* uniHandler = args.fUniformHandler; 153 GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler; 154 155 const char* atlasAdjust; 156 fAtlasAdjustUniform = uniHandler->addUniform( 157 kVertex_GrShaderFlag, 158 kFloat2_GrSLType, "atlas_adjust", &atlasAdjust); 159 160 varyingHandler->emitAttributes(proc); 161 162 GrGLSLVarying texcoord(kFloat2_GrSLType); 163 GrGLSLVarying color(kHalf4_GrSLType); 164 varyingHandler->addVarying("texcoord", &texcoord); 165 varyingHandler->addPassThroughAttribute(&proc.getInstanceAttrib(InstanceAttribs::kColor), 166 args.fOutputColor, Interpolation::kCanBeFlat); 167 168 // The vertex shader bloats and intersects the devBounds and devBounds45 rectangles, in order to 169 // find an octagon that circumscribes the (bloated) path. 170 GrGLSLVertexBuilder* v = args.fVertBuilder; 171 172 // Each vertex is the intersection of one edge from devBounds and one from devBounds45. 173 // 'N' holds the normals to these edges as column vectors. 174 // 175 // NOTE: "float2x2(float4)" is valid and equivalent to "float2x2(float4.xy, float4.zw)", 176 // however Intel compilers crash when we use the former syntax in this shader. 177 v->codeAppendf("float2x2 N = float2x2(%s.xy, %s.zw);", 178 proc.getEdgeNormsAttrib().fName, proc.getEdgeNormsAttrib().fName); 179 180 // N[0] is the normal for the edge we are intersecting from the regular bounding box, pointing 181 // out of the octagon. 182 v->codeAppendf("float2 refpt = float2[2](%s.xy, %s.zw)[sk_VertexID >> 2];", 183 proc.getInstanceAttrib(InstanceAttribs::kDevBounds).fName, 184 proc.getInstanceAttrib(InstanceAttribs::kDevBounds).fName); 185 v->codeAppendf("refpt += N[0] * %f;", kAABloatRadius); // bloat for AA. 186 187 // N[1] is the normal for the edge we are intersecting from the 45-degree bounding box, pointing 188 // out of the octagon. 189 v->codeAppendf("float2 refpt45 = float2[2](%s.xy, %s.zw)[((sk_VertexID + 1) >> 2) & 1];", 190 proc.getInstanceAttrib(InstanceAttribs::kDevBounds45).fName, 191 proc.getInstanceAttrib(InstanceAttribs::kDevBounds45).fName); 192 v->codeAppendf("refpt45 *= float2x2(.5,.5,-.5,.5);"); // transform back to device space. 193 v->codeAppendf("refpt45 += N[1] * %f;", kAABloatRadius); // bloat for AA. 194 195 v->codeAppend ("float2 K = float2(dot(N[0], refpt), dot(N[1], refpt45));"); 196 v->codeAppendf("float2 octocoord = K * inverse(N);"); 197 198 gpArgs->fPositionVar.set(kFloat2_GrSLType, "octocoord"); 199 200 // Convert to atlas coordinates in order to do our texture lookup. 201 v->codeAppendf("float2 atlascoord = octocoord + float2(%s);", 202 proc.getInstanceAttrib(InstanceAttribs::kAtlasOffset).fName); 203 if (kTopLeft_GrSurfaceOrigin == proc.atlasProxy()->origin()) { 204 v->codeAppendf("%s = atlascoord * %s;", texcoord.vsOut(), atlasAdjust); 205 } else { 206 SkASSERT(kBottomLeft_GrSurfaceOrigin == proc.atlasProxy()->origin()); 207 v->codeAppendf("%s = float2(atlascoord.x * %s.x, 1 - atlascoord.y * %s.y);", 208 texcoord.vsOut(), atlasAdjust, atlasAdjust); 209 } 210 211 // Convert to path/local cordinates. 212 v->codeAppendf("float2x2 viewmatrix = float2x2(%s.xy, %s.zw);", // float2x2(float4) busts Intel. 213 proc.getInstanceAttrib(InstanceAttribs::kViewMatrix).fName, 214 proc.getInstanceAttrib(InstanceAttribs::kViewMatrix).fName); 215 v->codeAppendf("float2 pathcoord = inverse(viewmatrix) * (octocoord - %s);", 216 proc.getInstanceAttrib(InstanceAttribs::kViewTranslate).fName); 217 218 this->emitTransforms(v, varyingHandler, uniHandler, GrShaderVar("pathcoord", kFloat2_GrSLType), 219 args.fFPCoordTransformHandler); 220 221 // Fragment shader. 222 GrGLSLFPFragmentBuilder* f = args.fFragBuilder; 223 224 f->codeAppend ("half coverage_count = "); 225 f->appendTextureLookup(args.fTexSamplers[0], texcoord.fsIn(), kFloat2_GrSLType); 226 f->codeAppend (".a;"); 227 228 if (SkPath::kWinding_FillType == proc.fillType()) { 229 f->codeAppendf("%s = half4(min(abs(coverage_count), 1));", args.fOutputCoverage); 230 } else { 231 SkASSERT(SkPath::kEvenOdd_FillType == proc.fillType()); 232 f->codeAppend ("half t = mod(abs(coverage_count), 2);"); 233 f->codeAppendf("%s = half4(1 - abs(t - 1));", args.fOutputCoverage); 234 } 235 } 236
