Chris Dalton | 1a325d2 | 2017-07-14 15:17:41 -0600 | [diff] [blame] | 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 | |
Chris Dalton | 383a2ef | 2018-01-08 17:21:41 -0500 | [diff] [blame] | 8 | #ifndef GrCCCoverageProcessor_DEFINED |
| 9 | #define GrCCCoverageProcessor_DEFINED |
Chris Dalton | 1a325d2 | 2017-07-14 15:17:41 -0600 | [diff] [blame] | 10 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 11 | #include "include/private/SkNx.h" |
| 12 | #include "src/gpu/GrCaps.h" |
| 13 | #include "src/gpu/GrGeometryProcessor.h" |
| 14 | #include "src/gpu/GrPipeline.h" |
| 15 | #include "src/gpu/GrShaderCaps.h" |
| 16 | #include "src/gpu/glsl/GrGLSLGeometryProcessor.h" |
Robert Phillips | 03e4c95 | 2019-11-26 16:20:22 -0500 | [diff] [blame] | 17 | #include "src/gpu/glsl/GrGLSLShaderBuilder.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 18 | #include "src/gpu/glsl/GrGLSLVarying.h" |
Chris Dalton | 1a325d2 | 2017-07-14 15:17:41 -0600 | [diff] [blame] | 19 | |
Chris Dalton | 6028361 | 2018-02-14 13:38:14 -0700 | [diff] [blame] | 20 | class GrGLSLFPFragmentBuilder; |
Chris Dalton | 1fbdb61 | 2017-12-12 12:48:47 -0700 | [diff] [blame] | 21 | class GrGLSLVertexGeoBuilder; |
Chris Dalton | 8dfc70f | 2018-03-26 19:15:22 -0600 | [diff] [blame] | 22 | class GrOpFlushState; |
Chris Dalton | 1a325d2 | 2017-07-14 15:17:41 -0600 | [diff] [blame] | 23 | |
| 24 | /** |
Chris Dalton | 1fbdb61 | 2017-12-12 12:48:47 -0700 | [diff] [blame] | 25 | * This is the geometry processor for the simple convex primitive shapes (triangles and closed, |
| 26 | * convex bezier curves) from which ccpr paths are composed. The output is a single-channel alpha |
| 27 | * value, positive for clockwise shapes and negative for counter-clockwise, that indicates coverage. |
Chris Dalton | 1a325d2 | 2017-07-14 15:17:41 -0600 | [diff] [blame] | 28 | * |
Chris Dalton | 8dfc70f | 2018-03-26 19:15:22 -0600 | [diff] [blame] | 29 | * The caller is responsible to draw all primitives as produced by GrCCGeometry into a cleared, |
| 30 | * floating point, alpha-only render target using SkBlendMode::kPlus. Once all of a path's |
| 31 | * primitives have been drawn, the render target contains a composite coverage count that can then |
| 32 | * be used to draw the path (see GrCCPathProcessor). |
Chris Dalton | 1a325d2 | 2017-07-14 15:17:41 -0600 | [diff] [blame] | 33 | * |
Chris Dalton | 8dfc70f | 2018-03-26 19:15:22 -0600 | [diff] [blame] | 34 | * To draw primitives, use appendMesh() and draw() (defined below). |
Chris Dalton | 1a325d2 | 2017-07-14 15:17:41 -0600 | [diff] [blame] | 35 | */ |
Chris Dalton | 383a2ef | 2018-01-08 17:21:41 -0500 | [diff] [blame] | 36 | class GrCCCoverageProcessor : public GrGeometryProcessor { |
Chris Dalton | 1a325d2 | 2017-07-14 15:17:41 -0600 | [diff] [blame] | 37 | public: |
Chris Dalton | 8dfc70f | 2018-03-26 19:15:22 -0600 | [diff] [blame] | 38 | enum class PrimitiveType { |
| 39 | kTriangles, |
Chris Dalton | 2c5e011 | 2019-03-29 13:14:18 -0500 | [diff] [blame] | 40 | kWeightedTriangles, // Triangles (from the tessellator) whose winding magnitude > 1. |
Chris Dalton | 8dfc70f | 2018-03-26 19:15:22 -0600 | [diff] [blame] | 41 | kQuadratics, |
| 42 | kCubics, |
Chris Dalton | 9f2dab0 | 2018-04-18 14:07:03 -0600 | [diff] [blame] | 43 | kConics |
Chris Dalton | 8dfc70f | 2018-03-26 19:15:22 -0600 | [diff] [blame] | 44 | }; |
| 45 | static const char* PrimitiveTypeName(PrimitiveType); |
| 46 | |
Chris Dalton | 84403d7 | 2018-02-13 21:46:17 -0500 | [diff] [blame] | 47 | // Defines a single primitive shape with 3 input points (i.e. Triangles and Quadratics). |
| 48 | // X,Y point values are transposed. |
| 49 | struct TriPointInstance { |
Chris Dalton | c3318f0 | 2019-07-19 14:20:53 -0600 | [diff] [blame] | 50 | float fValues[6]; |
Chris Dalton | c1e5963 | 2017-09-05 00:30:07 -0600 | [diff] [blame] | 51 | |
Chris Dalton | c3318f0 | 2019-07-19 14:20:53 -0600 | [diff] [blame] | 52 | enum class Ordering : bool { |
| 53 | kXYTransposed, |
| 54 | kXYInterleaved, |
| 55 | }; |
| 56 | |
| 57 | void set(const SkPoint[3], const Sk2f& translate, Ordering); |
| 58 | void set(const SkPoint&, const SkPoint&, const SkPoint&, const Sk2f& translate, Ordering); |
| 59 | void set(const Sk2f& P0, const Sk2f& P1, const Sk2f& P2, const Sk2f& translate, Ordering); |
Chris Dalton | c1e5963 | 2017-09-05 00:30:07 -0600 | [diff] [blame] | 60 | }; |
| 61 | |
Chris Dalton | 9f2dab0 | 2018-04-18 14:07:03 -0600 | [diff] [blame] | 62 | // Defines a single primitive shape with 4 input points, or 3 input points plus a "weight" |
| 63 | // parameter duplicated in both lanes of the 4th input (i.e. Cubics, Conics, and Triangles with |
| 64 | // a weighted winding number). X,Y point values are transposed. |
Chris Dalton | 84403d7 | 2018-02-13 21:46:17 -0500 | [diff] [blame] | 65 | struct QuadPointInstance { |
Chris Dalton | a3e9271 | 2017-12-04 11:45:51 -0700 | [diff] [blame] | 66 | float fX[4]; |
| 67 | float fY[4]; |
| 68 | |
| 69 | void set(const SkPoint[4], float dx, float dy); |
Chris Dalton | 9f2dab0 | 2018-04-18 14:07:03 -0600 | [diff] [blame] | 70 | void setW(const SkPoint[3], const Sk2f& trans, float w); |
Chris Dalton | 703b476 | 2018-04-06 16:11:48 -0600 | [diff] [blame] | 71 | void setW(const SkPoint&, const SkPoint&, const SkPoint&, const Sk2f& trans, float w); |
Chris Dalton | 09a7bb2 | 2018-08-31 19:53:15 +0800 | [diff] [blame] | 72 | void setW(const Sk2f& P0, const Sk2f& P1, const Sk2f& P2, const Sk2f& trans, float w); |
Chris Dalton | a3e9271 | 2017-12-04 11:45:51 -0700 | [diff] [blame] | 73 | }; |
Chris Dalton | baf3e78 | 2018-03-08 15:55:58 +0000 | [diff] [blame] | 74 | |
Chris Dalton | 2c5e011 | 2019-03-29 13:14:18 -0500 | [diff] [blame] | 75 | PrimitiveType primitiveType() const { return fPrimitiveType; } |
| 76 | |
| 77 | // Number of bezier points for curves, or 3 for triangles. |
| 78 | int numInputPoints() const { return PrimitiveType::kCubics == fPrimitiveType ? 4 : 3; } |
| 79 | |
| 80 | bool isTriangles() const { |
| 81 | return PrimitiveType::kTriangles == fPrimitiveType || |
| 82 | PrimitiveType::kWeightedTriangles == fPrimitiveType; |
| 83 | } |
| 84 | |
| 85 | int hasInputWeight() const { |
| 86 | return PrimitiveType::kWeightedTriangles == fPrimitiveType || |
| 87 | PrimitiveType::kConics == fPrimitiveType; |
Chris Dalton | a3e9271 | 2017-12-04 11:45:51 -0700 | [diff] [blame] | 88 | } |
| 89 | |
Chris Dalton | 2326177 | 2017-12-10 16:41:45 -0700 | [diff] [blame] | 90 | // GrPrimitiveProcessor overrides. |
Chris Dalton | 8dfc70f | 2018-03-26 19:15:22 -0600 | [diff] [blame] | 91 | const char* name() const override { return PrimitiveTypeName(fPrimitiveType); } |
Chris Dalton | 2c5e011 | 2019-03-29 13:14:18 -0500 | [diff] [blame] | 92 | void getGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder* b) const override { |
| 93 | SkDEBUGCODE(this->getDebugBloatKey(b)); |
| 94 | b->add32((int)fPrimitiveType); |
| 95 | } |
| 96 | GrGLSLPrimitiveProcessor* createGLSLInstance(const GrShaderCaps&) const final; |
Chris Dalton | 2326177 | 2017-12-10 16:41:45 -0700 | [diff] [blame] | 97 | |
| 98 | #ifdef SK_DEBUG |
Chris Dalton | 8d38a7f | 2018-03-19 14:16:44 -0600 | [diff] [blame] | 99 | // Increases the 1/2 pixel AA bloat by a factor of debugBloat. |
| 100 | void enableDebugBloat(float debugBloat) { fDebugBloat = debugBloat; } |
| 101 | bool debugBloatEnabled() const { return fDebugBloat > 0; } |
| 102 | float debugBloat() const { SkASSERT(this->debugBloatEnabled()); return fDebugBloat; } |
Chris Dalton | 2c5e011 | 2019-03-29 13:14:18 -0500 | [diff] [blame] | 103 | void getDebugBloatKey(GrProcessorKeyBuilder* b) const { |
| 104 | uint32_t bloatBits; |
| 105 | memcpy(&bloatBits, &fDebugBloat, 4); |
| 106 | b->add32(bloatBits); |
| 107 | } |
Chris Dalton | 2326177 | 2017-12-10 16:41:45 -0700 | [diff] [blame] | 108 | #endif |
| 109 | |
Chris Dalton | 39ca973 | 2020-03-10 10:34:17 -0600 | [diff] [blame] | 110 | // The caller uses these methods to actualy draw the coverage PrimitiveTypes. For each |
| 111 | // subpassIdx of each PrimitiveType, it calls reset/bind*/drawInstances. |
| 112 | virtual int numSubpasses() const = 0; |
| 113 | virtual void reset(PrimitiveType, int subpassIdx, GrResourceProvider*) = 0; |
| 114 | void bindPipeline(GrOpFlushState*, const GrPipeline&, const SkRect& drawBounds) const; |
Greg Daniel | 426274b | 2020-07-20 11:37:38 -0400 | [diff] [blame] | 115 | virtual void bindBuffers(GrOpsRenderPass*, sk_sp<const GrBuffer> instanceBuffer) const = 0; |
Chris Dalton | 39ca973 | 2020-03-10 10:34:17 -0600 | [diff] [blame] | 116 | virtual void drawInstances(GrOpsRenderPass*, int instanceCount, int baseInstance) const = 0; |
Robert Phillips | cea290f | 2019-11-06 11:21:03 -0500 | [diff] [blame] | 117 | |
Chris Dalton | fe462ef | 2018-03-08 15:54:01 +0000 | [diff] [blame] | 118 | // The Shader provides code to calculate each pixel's coverage in a RenderPass. It also |
| 119 | // provides details about shape-specific geometry. |
Chris Dalton | 6a3dbee | 2017-10-16 10:44:41 -0600 | [diff] [blame] | 120 | class Shader { |
| 121 | public: |
Chris Dalton | 84d36cd | 2019-04-17 14:47:17 -0600 | [diff] [blame] | 122 | // Returns true if the Impl should not calculate the coverage argument for emitVaryings(). |
| 123 | // If true, then "coverage" will have a signed magnitude of 1. |
| 124 | virtual bool calculatesOwnEdgeCoverage() const { return false; } |
| 125 | |
Chris Dalton | 21ba551 | 2018-03-21 17:20:21 -0600 | [diff] [blame] | 126 | // Called before generating geometry. Subclasses may set up internal member variables during |
| 127 | // this time that will be needed during onEmitVaryings (e.g. transformation matrices). |
Chris Dalton | fe462ef | 2018-03-08 15:54:01 +0000 | [diff] [blame] | 128 | // |
Chris Dalton | 9713dcf | 2018-04-10 00:48:41 -0600 | [diff] [blame] | 129 | // If the 'outHull4' parameter is provided, and there are not 4 input points, the subclass |
| 130 | // is required to fill it with the name of a 4-point hull around which the Impl can generate |
| 131 | // its geometry. If it is left unchanged, the Impl will use the regular input points. |
Chris Dalton | 84d36cd | 2019-04-17 14:47:17 -0600 | [diff] [blame] | 132 | virtual void emitSetupCode( |
| 133 | GrGLSLVertexGeoBuilder*, const char* pts, const char** outHull4 = nullptr) const { |
Chris Dalton | 9713dcf | 2018-04-10 00:48:41 -0600 | [diff] [blame] | 134 | SkASSERT(!outHull4); |
| 135 | } |
Chris Dalton | fe462ef | 2018-03-08 15:54:01 +0000 | [diff] [blame] | 136 | |
Chris Dalton | 84d36cd | 2019-04-17 14:47:17 -0600 | [diff] [blame] | 137 | void emitVaryings( |
| 138 | GrGLSLVaryingHandler* varyingHandler, GrGLSLVarying::Scope scope, SkString* code, |
| 139 | const char* position, const char* coverage, const char* cornerCoverage, |
| 140 | const char* wind) { |
Chris Dalton | fe462ef | 2018-03-08 15:54:01 +0000 | [diff] [blame] | 141 | SkASSERT(GrGLSLVarying::Scope::kVertToGeo != scope); |
Chris Dalton | 84d36cd | 2019-04-17 14:47:17 -0600 | [diff] [blame] | 142 | this->onEmitVaryings( |
| 143 | varyingHandler, scope, code, position, coverage, cornerCoverage, wind); |
Chris Dalton | fe462ef | 2018-03-08 15:54:01 +0000 | [diff] [blame] | 144 | } |
Chris Dalton | 622650a | 2018-03-07 17:30:10 -0700 | [diff] [blame] | 145 | |
Chris Dalton | c3318f0 | 2019-07-19 14:20:53 -0600 | [diff] [blame] | 146 | // Writes the signed coverage value at the current pixel to "outputCoverage". |
| 147 | virtual void emitFragmentCoverageCode( |
| 148 | GrGLSLFPFragmentBuilder*, const char* outputCoverage) const = 0; |
| 149 | |
| 150 | // Assigns the built-in sample mask at the current pixel. |
| 151 | virtual void emitSampleMaskCode(GrGLSLFPFragmentBuilder*) const = 0; |
Chris Dalton | 6a3dbee | 2017-10-16 10:44:41 -0600 | [diff] [blame] | 152 | |
Chris Dalton | 6f5e77a | 2018-04-23 21:14:42 -0600 | [diff] [blame] | 153 | // Calculates the winding direction of the input points (+1, -1, or 0). Wind for extremely |
| 154 | // thin triangles gets rounded to zero. |
| 155 | static void CalcWind(const GrCCCoverageProcessor&, GrGLSLVertexGeoBuilder*, const char* pts, |
| 156 | const char* outputWind); |
| 157 | |
Chris Dalton | 0a79381 | 2018-03-07 11:18:30 -0700 | [diff] [blame] | 158 | // Calculates an edge's coverage at a conservative raster vertex. The edge is defined by two |
| 159 | // clockwise-ordered points, 'leftPt' and 'rightPt'. 'rasterVertexDir' is a pair of +/-1 |
| 160 | // values that point in the direction of conservative raster bloat, starting from an |
| 161 | // endpoint. |
| 162 | // |
| 163 | // Coverage values ramp from -1 (completely outside the edge) to 0 (completely inside). |
| 164 | static void CalcEdgeCoverageAtBloatVertex(GrGLSLVertexGeoBuilder*, const char* leftPt, |
| 165 | const char* rightPt, const char* rasterVertexDir, |
| 166 | const char* outputCoverage); |
| 167 | |
Chris Dalton | 8738cf4 | 2018-03-09 11:57:40 -0700 | [diff] [blame] | 168 | // Calculates an edge's coverage at two conservative raster vertices. |
| 169 | // (See CalcEdgeCoverageAtBloatVertex). |
| 170 | static void CalcEdgeCoveragesAtBloatVertices(GrGLSLVertexGeoBuilder*, const char* leftPt, |
| 171 | const char* rightPt, const char* bloatDir1, |
| 172 | const char* bloatDir2, |
| 173 | const char* outputCoverages); |
| 174 | |
Chris Dalton | 04a1de5 | 2018-03-14 02:04:09 -0600 | [diff] [blame] | 175 | // Corner boxes require an additional "attenuation" varying that is multiplied by the |
| 176 | // regular (linearly-interpolated) coverage. This function calculates the attenuation value |
| 177 | // to use in the single, outermost vertex. The remaining three vertices of the corner box |
| 178 | // all use an attenuation value of 1. |
Chris Dalton | 4c23934 | 2018-04-05 18:43:40 -0600 | [diff] [blame] | 179 | static void CalcCornerAttenuation(GrGLSLVertexGeoBuilder*, const char* leftDir, |
| 180 | const char* rightDir, const char* outputAttenuation); |
Chris Dalton | 04a1de5 | 2018-03-14 02:04:09 -0600 | [diff] [blame] | 181 | |
Chris Dalton | 6a3dbee | 2017-10-16 10:44:41 -0600 | [diff] [blame] | 182 | virtual ~Shader() {} |
| 183 | |
| 184 | protected: |
Chris Dalton | 622650a | 2018-03-07 17:30:10 -0700 | [diff] [blame] | 185 | // Here the subclass adds its internal varyings to the handler and produces code to |
Chris Dalton | 21ba551 | 2018-03-21 17:20:21 -0600 | [diff] [blame] | 186 | // initialize those varyings from a given position and coverage values. |
Chris Dalton | 622650a | 2018-03-07 17:30:10 -0700 | [diff] [blame] | 187 | // |
Chris Dalton | 21ba551 | 2018-03-21 17:20:21 -0600 | [diff] [blame] | 188 | // NOTE: the coverage values are signed appropriately for wind. |
| 189 | // 'coverage' will only be +1 or -1 on curves. |
Chris Dalton | 84d36cd | 2019-04-17 14:47:17 -0600 | [diff] [blame] | 190 | virtual void onEmitVaryings( |
| 191 | GrGLSLVaryingHandler*, GrGLSLVarying::Scope, SkString* code, const char* position, |
| 192 | const char* coverage, const char* cornerCoverage, const char* wind) = 0; |
Chris Dalton | 622650a | 2018-03-07 17:30:10 -0700 | [diff] [blame] | 193 | |
Chris Dalton | 90e8fb1 | 2017-12-22 02:24:53 -0700 | [diff] [blame] | 194 | // Returns the name of a Shader's internal varying at the point where where its value is |
| 195 | // assigned. This is intended to work whether called for a vertex or a geometry shader. |
| 196 | const char* OutName(const GrGLSLVarying& varying) const { |
| 197 | using Scope = GrGLSLVarying::Scope; |
| 198 | SkASSERT(Scope::kVertToGeo != varying.scope()); |
| 199 | return Scope::kGeoToFrag == varying.scope() ? varying.gsOut() : varying.vsOut(); |
| 200 | } |
Chris Dalton | 4c23934 | 2018-04-05 18:43:40 -0600 | [diff] [blame] | 201 | |
Chris Dalton | 2c5e011 | 2019-03-29 13:14:18 -0500 | [diff] [blame] | 202 | // Our friendship with GrGLSLShaderBuilder does not propagate to subclasses. |
Chris Dalton | 4c23934 | 2018-04-05 18:43:40 -0600 | [diff] [blame] | 203 | inline static SkString& AccessCodeString(GrGLSLShaderBuilder* s) { return s->code(); } |
Chris Dalton | 6a3dbee | 2017-10-16 10:44:41 -0600 | [diff] [blame] | 204 | }; |
| 205 | |
Chris Dalton | 2c5e011 | 2019-03-29 13:14:18 -0500 | [diff] [blame] | 206 | protected: |
Chris Dalton | 1a325d2 | 2017-07-14 15:17:41 -0600 | [diff] [blame] | 207 | // Slightly undershoot a bloat radius of 0.5 so vertices that fall on integer boundaries don't |
| 208 | // accidentally bleed into neighbor pixels. |
| 209 | static constexpr float kAABloatRadius = 0.491111f; |
| 210 | |
Chris Dalton | 2c5e011 | 2019-03-29 13:14:18 -0500 | [diff] [blame] | 211 | GrCCCoverageProcessor(ClassID classID) : INHERITED(classID) {} |
Chris Dalton | 1fbdb61 | 2017-12-12 12:48:47 -0700 | [diff] [blame] | 212 | |
Chris Dalton | 39ca973 | 2020-03-10 10:34:17 -0600 | [diff] [blame] | 213 | virtual GrPrimitiveType primType() const = 0; |
| 214 | |
Chris Dalton | 2c5e011 | 2019-03-29 13:14:18 -0500 | [diff] [blame] | 215 | virtual GrGLSLPrimitiveProcessor* onCreateGLSLInstance(std::unique_ptr<Shader>) const = 0; |
Chris Dalton | 6f5e77a | 2018-04-23 21:14:42 -0600 | [diff] [blame] | 216 | |
Chris Dalton | 2c5e011 | 2019-03-29 13:14:18 -0500 | [diff] [blame] | 217 | // Our friendship with GrGLSLShaderBuilder does not propagate to subclasses. |
| 218 | inline static SkString& AccessCodeString(GrGLSLShaderBuilder* s) { return s->code(); } |
Chris Dalton | 9f2dab0 | 2018-04-18 14:07:03 -0600 | [diff] [blame] | 219 | |
Chris Dalton | 2c5e011 | 2019-03-29 13:14:18 -0500 | [diff] [blame] | 220 | PrimitiveType fPrimitiveType; |
Chris Dalton | 383a2ef | 2018-01-08 17:21:41 -0500 | [diff] [blame] | 221 | SkDEBUGCODE(float fDebugBloat = 0); |
Chris Dalton | 1a325d2 | 2017-07-14 15:17:41 -0600 | [diff] [blame] | 222 | |
Chris Dalton | 2c5e011 | 2019-03-29 13:14:18 -0500 | [diff] [blame] | 223 | class TriangleShader; |
Chris Dalton | 27059d3 | 2018-01-23 14:06:50 -0700 | [diff] [blame] | 224 | |
Chris Dalton | 6a3dbee | 2017-10-16 10:44:41 -0600 | [diff] [blame] | 225 | typedef GrGeometryProcessor INHERITED; |
Chris Dalton | 1a325d2 | 2017-07-14 15:17:41 -0600 | [diff] [blame] | 226 | }; |
| 227 | |
Chris Dalton | 8dfc70f | 2018-03-26 19:15:22 -0600 | [diff] [blame] | 228 | inline const char* GrCCCoverageProcessor::PrimitiveTypeName(PrimitiveType type) { |
| 229 | switch (type) { |
| 230 | case PrimitiveType::kTriangles: return "kTriangles"; |
Chris Dalton | 703b476 | 2018-04-06 16:11:48 -0600 | [diff] [blame] | 231 | case PrimitiveType::kWeightedTriangles: return "kWeightedTriangles"; |
Chris Dalton | 8dfc70f | 2018-03-26 19:15:22 -0600 | [diff] [blame] | 232 | case PrimitiveType::kQuadratics: return "kQuadratics"; |
| 233 | case PrimitiveType::kCubics: return "kCubics"; |
Chris Dalton | 9f2dab0 | 2018-04-18 14:07:03 -0600 | [diff] [blame] | 234 | case PrimitiveType::kConics: return "kConics"; |
Chris Dalton | 8dfc70f | 2018-03-26 19:15:22 -0600 | [diff] [blame] | 235 | } |
| 236 | SK_ABORT("Invalid PrimitiveType"); |
Chris Dalton | 8dfc70f | 2018-03-26 19:15:22 -0600 | [diff] [blame] | 237 | } |
| 238 | |
Chris Dalton | c3318f0 | 2019-07-19 14:20:53 -0600 | [diff] [blame] | 239 | inline void GrCCCoverageProcessor::TriPointInstance::set( |
| 240 | const SkPoint p[3], const Sk2f& translate, Ordering ordering) { |
| 241 | this->set(p[0], p[1], p[2], translate, ordering); |
Chris Dalton | a3e9271 | 2017-12-04 11:45:51 -0700 | [diff] [blame] | 242 | } |
| 243 | |
Chris Dalton | c3318f0 | 2019-07-19 14:20:53 -0600 | [diff] [blame] | 244 | inline void GrCCCoverageProcessor::TriPointInstance::set( |
| 245 | const SkPoint& p0, const SkPoint& p1, const SkPoint& p2, const Sk2f& translate, |
| 246 | Ordering ordering) { |
Chris Dalton | 09a7bb2 | 2018-08-31 19:53:15 +0800 | [diff] [blame] | 247 | Sk2f P0 = Sk2f::Load(&p0); |
| 248 | Sk2f P1 = Sk2f::Load(&p1); |
| 249 | Sk2f P2 = Sk2f::Load(&p2); |
Chris Dalton | c3318f0 | 2019-07-19 14:20:53 -0600 | [diff] [blame] | 250 | this->set(P0, P1, P2, translate, ordering); |
Chris Dalton | 09a7bb2 | 2018-08-31 19:53:15 +0800 | [diff] [blame] | 251 | } |
| 252 | |
Chris Dalton | c3318f0 | 2019-07-19 14:20:53 -0600 | [diff] [blame] | 253 | inline void GrCCCoverageProcessor::TriPointInstance::set( |
| 254 | const Sk2f& P0, const Sk2f& P1, const Sk2f& P2, const Sk2f& translate, Ordering ordering) { |
| 255 | if (Ordering::kXYTransposed == ordering) { |
| 256 | Sk2f::Store3(fValues, P0 + translate, P1 + translate, P2 + translate); |
| 257 | } else { |
| 258 | (P0 + translate).store(fValues); |
| 259 | (P1 + translate).store(fValues + 2); |
| 260 | (P2 + translate).store(fValues + 4); |
| 261 | } |
Chris Dalton | a3e9271 | 2017-12-04 11:45:51 -0700 | [diff] [blame] | 262 | } |
| 263 | |
Chris Dalton | 84403d7 | 2018-02-13 21:46:17 -0500 | [diff] [blame] | 264 | inline void GrCCCoverageProcessor::QuadPointInstance::set(const SkPoint p[4], float dx, float dy) { |
Chris Dalton | a3e9271 | 2017-12-04 11:45:51 -0700 | [diff] [blame] | 265 | Sk4f X,Y; |
| 266 | Sk4f::Load2(p, &X, &Y); |
| 267 | (X + dx).store(&fX); |
| 268 | (Y + dy).store(&fY); |
| 269 | } |
| 270 | |
Chris Dalton | 9f2dab0 | 2018-04-18 14:07:03 -0600 | [diff] [blame] | 271 | inline void GrCCCoverageProcessor::QuadPointInstance::setW(const SkPoint p[3], const Sk2f& trans, |
| 272 | float w) { |
| 273 | this->setW(p[0], p[1], p[2], trans, w); |
| 274 | } |
| 275 | |
Chris Dalton | 703b476 | 2018-04-06 16:11:48 -0600 | [diff] [blame] | 276 | inline void GrCCCoverageProcessor::QuadPointInstance::setW(const SkPoint& p0, const SkPoint& p1, |
| 277 | const SkPoint& p2, const Sk2f& trans, |
| 278 | float w) { |
Chris Dalton | 09a7bb2 | 2018-08-31 19:53:15 +0800 | [diff] [blame] | 279 | Sk2f P0 = Sk2f::Load(&p0); |
| 280 | Sk2f P1 = Sk2f::Load(&p1); |
| 281 | Sk2f P2 = Sk2f::Load(&p2); |
| 282 | this->setW(P0, P1, P2, trans, w); |
| 283 | } |
| 284 | |
| 285 | inline void GrCCCoverageProcessor::QuadPointInstance::setW(const Sk2f& P0, const Sk2f& P1, |
| 286 | const Sk2f& P2, const Sk2f& trans, |
| 287 | float w) { |
Chris Dalton | 84403d7 | 2018-02-13 21:46:17 -0500 | [diff] [blame] | 288 | Sk2f W = Sk2f(w); |
Chris Dalton | 09a7bb2 | 2018-08-31 19:53:15 +0800 | [diff] [blame] | 289 | Sk2f::Store4(this, P0 + trans, P1 + trans, P2 + trans, W); |
Chris Dalton | 84403d7 | 2018-02-13 21:46:17 -0500 | [diff] [blame] | 290 | } |
| 291 | |
Chris Dalton | 1a325d2 | 2017-07-14 15:17:41 -0600 | [diff] [blame] | 292 | #endif |