1 /*
2 * Copyright 2022 Google LLC
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/graphite/render/AnalyticRRectRenderStep.h"
9
10 #include "include/core/SkM44.h"
11 #include "include/core/SkPaint.h"
12 #include "include/core/SkRRect.h"
13 #include "include/core/SkScalar.h"
14 #include "include/private/base/SkAssert.h"
15 #include "include/private/base/SkFloatingPoint.h"
16 #include "include/private/base/SkPoint_impl.h"
17 #include "src/base/SkEnumBitMask.h"
18 #include "src/base/SkVx.h"
19 #include "src/core/SkRRectPriv.h"
20 #include "src/core/SkSLTypeShared.h"
21 #include "src/gpu/BufferWriter.h"
22 #include "src/gpu/graphite/Attribute.h"
23 #include "src/gpu/graphite/BufferManager.h"
24 #include "src/gpu/graphite/DrawOrder.h"
25 #include "src/gpu/graphite/DrawParams.h"
26 #include "src/gpu/graphite/DrawTypes.h"
27 #include "src/gpu/graphite/DrawWriter.h"
28 #include "src/gpu/graphite/geom/EdgeAAQuad.h"
29 #include "src/gpu/graphite/geom/Geometry.h"
30 #include "src/gpu/graphite/geom/Rect.h"
31 #include "src/gpu/graphite/geom/Shape.h"
32 #include "src/gpu/graphite/geom/Transform_graphite.h"
33 #include "src/gpu/graphite/render/CommonDepthStencilSettings.h"
34
35 #include <cstdint>
36 #include <string_view>
37
38 // This RenderStep is flexible and can draw filled rectangles, filled quadrilaterals with per-edge
39 // AA, filled rounded rectangles with arbitrary corner radii, stroked rectangles with any join,
40 // stroked lines with any cap, stroked rounded rectangles with circular corners (each corner can be
41 // different or square), hairline rectangles, hairline lines, and hairline rounded rectangles with
42 // arbitrary corners.
43 //
44 // We combine all of these together to maximize batching across simple geometric draws and reduce
45 // the number pipeline specializations. Additionally, these primitives are the most common
46 // operations and help us avoid triggering MSAA.
47 //
48 // Each of these "primitives" is represented by a single instance. The instance attributes are
49 // flexible enough to describe any of the above shapes without relying on uniforms to define its
50 // operation. The attributes encode shape as follows:
51 //
52 // float4 xRadiiOrFlags - if any components is > 0, the instance represents a filled round rect
53 // with elliptical corners and these values specify the X radii in top-left CW order.
54 // Otherwise, if .x < -1, the instance represents a stroked or hairline [round] rect or line,
55 // where .y differentiates hairline vs. stroke. If .y is negative, then it is a hairline [round]
56 // rect and xRadiiOrFlags stores (-2 - X radii); if .y is zero, it is a regular stroked [round]
57 // rect; if .y is positive, then it is a stroked *or* hairline line. For .y >= 0, .z holds the
58 // stroke radius and .w stores the join limit (matching StrokeStyle's conventions).
59 // Lastly, if -1 <= .x <= 0, it's a filled quadrilateral with per-edge AA defined by each by the
60 // component: aa != 0.
61 // float4 radiiOrQuadXs - if in filled round rect or hairline [round] rect mode, these values
62 // provide the Y radii in top-left CW order. If in stroked [round] rect mode, these values
63 // provide the circular corner radii (same order). Otherwise, when in per-edge quad mode, these
64 // values provide the X coordinates of the quadrilateral (same order).
65 // float4 ltrbOrQuadYs - if in filled round rect mode or stroked [round] rect mode, these values
66 // define the LTRB edge coordinates of the rectangle surrounding the round rect (or the
67 // rect itself when the radii are 0s). In stroked line mode, LTRB is treated as (x0,y0) and
68 // (x1,y1) that defines the line. Otherwise, in per-edge quad mode, these values provide
69 // the Y coordinates of the quadrilateral.
70 //
71 // From the other direction, shapes produce instance values like:
72 // - filled rect: [-1 -1 -1 -1] [L R R L] [T T B B]
73 // - stroked rect: [-2 0 stroke join] [0 0 0 0] [L T R B]
74 // - hairline rect: [-2 -2 -2 -2] [0 0 0 0] [L T R B]
75 // - filled rrect: [xRadii(tl,tr,br,bl)] [yRadii(tl,tr,br,bl)] [L T R B]
76 // - stroked rrect: [-2 0 stroke join] [radii(tl,tr,br,bl)] [L T R B]
77 // - hairline rrect: [-2-xRadii(tl,tr,br,bl)] [radii(tl,tr,br,bl)] [L T R B]
78 // - filled line: N/A, discarded higher in the stack
79 // - stroked line: [-2 1 stroke cap] [0 0 0 0] [x0,y0,x1,y1]
80 // - hairline line: [-2 1 0 1] [0 0 0 0] [x0,y0,x1,y1]
81 // - per-edge quad: [aa(t,r,b,l) ? -1 : 0] [xs(tl,tr,br,bl)] [ys(tl,tr,br,bl)]
82 //
83 // This encoding relies on the fact that a valid SkRRect with all x radii equal to 0 must have
84 // y radii equal to 0 (so it's a rectangle and we can treat it as a quadrilateral with
85 // all edges AA'ed). This avoids other encodings' inability to represent a quad with all edges
86 // anti-aliased (e.g. checking for negatives in xRadiiOrFlags to turn on per-edge mode).
87 //
88 // From this encoding, data can be unpacked for each corner, which are equivalent under
89 // rotational symmetry. A corner can have an outer curve, be mitered, or be beveled. It can
90 // have an inner curve, an inner miter, or fill the interior. Per-edge quads are always mitered
91 // and fill the interior, but the vertices are placed such that the edge coverage ramps can
92 // collapse to 0 area on non-AA edges.
93 //
94 // The vertices that describe each corner are placed so that edges, miters, and bevels calculate
95 // coverage by interpolating a varying and then clamping in the fragment shader. Triangles that
96 // cover the inner and outer curves calculate distance to the curve within the fragment shader.
97 //
98 // See https://docs.google.com/presentation/d/1MCPstNsSlDBhR8CrsJo0r-cZNbu-sEJEvU9W94GOJoY/edit?usp=sharing
99 // for diagrams and explanation of how the geometry is defined.
100 //
101 // AnalyticRRectRenderStep uses the common technique of approximating distance to the level set by
102 // one expansion of the Taylor's series for the level set's equation. Given a level set function
103 // C(x,y), this amounts to calculating C(px,py)/|∇C(px,py)|. For the straight edges the level set
104 // is linear and calculated in the vertex shader and then interpolated exactly over the rectangle.
105 // This provides distances to all four exterior edges within the fragment shader and allows it to
106 // reconstruct a relative position per elliptical corner. Unfortunately this requires the fragment
107 // shader to calculate the length of the gradient for straight edges instead of interpolating
108 // exact device-space distance.
109 //
110 // All four corner radii are potentially evaluated by the fragment shader although each corner's
111 // coverage is only calculated when the pixel is within the bounding box of its quadrant. For fills
112 // and simple strokes it's theoretically valid to have each pixel calculate a single corner's
113 // coverage that was controlled via the vertex shader. However, testing all four corners is
114 // necessary in order to correctly handle self-intersecting stroke interiors. Similarly, all four
115 // edges must be evaluated in order to handle extremely thin shapes; whereas often you could get
116 // away with tracking a single edge distance per pixel.
117 //
118 // Analytic derivatives are used so that a single pipeline can be used regardless of HW derivative
119 // support or for geometry that would prove difficult for forward differencing. The device-space
120 // gradient for ellipses is calculated per-pixel by transforming a per-pixel local gradient vector
121 // with the Jacobian of the inverse local-to-device transform:
122 //
123 // (px,py) is the projected point of (u,v) transformed by a 3x3 matrix, M:
124 // [x(u,v) / w(u,v)] [x] [m00 m01 m02] [u]
125 // (px,py) = [y(u,v) / w(u,v)] where [y] = [m10 m11 m12]X[v] = M*(u,v,1)
126 // [w] [m20 m21 m22] [1]
127 //
128 // C(px,py) can be defined in terms of a local Cl(u,v) as C(px,py) = Cl(p^-1(px,py)), where p^-1 =
129 //
130 // [x'(px,py) / w'(px,py)] [x'] [m00' m01' * m02'] [px]
131 // (u,v) = [y'(px,py) / w'(px,py)] where [y'] = [m10' m11' * m12']X[py] = M^-1*(px,py,0,1)
132 // [w'] [m20' m21' * m22'] [ 1]
133 //
134 // Note that if the 3x3 M was arrived by dropping the 3rd row and column from a 4x4 since we assume
135 // a local 3rd coordinate of 0, M^-1 is not equal to the 4x4 inverse with dropped rows and columns.
136 //
137 // Using the chain rule, then ∇C(px,py)
138 // = ∇Cl(u,v)X[1/w'(px,py) 0 -x'(px,py)/w'(px,py)^2] [m00' m01']
139 // [ 0 1/w'(px,py) -y'(px,py)/w'(px,py)^2]X[m10' m11']
140 // [m20' m21']
141 //
142 // = 1/w'(px,py)*∇Cl(u,v)X[1 0 -x'(px,py)/w'(px,py)] [m00' m01']
143 // [0 1 -y'(px,py)/w'(px,py)]X[m10' m11']
144 // [m20' m21']
145 //
146 // = w(u,v)*∇Cl(u,v)X[1 0 0 -u] [m00' m01']
147 // [0 1 0 -v]X[m10' m11']
148 // [m20' m21']
149 //
150 // = w(u,v)*∇Cl(u,v)X[m00'-m20'u m01'-m21'u]
151 // [m10'-m20'v m11'-m21'v]
152 //
153 // The vertex shader calculates the rightmost 2x2 matrix and interpolates it across the shape since
154 // each component is linear in (u,v). ∇Cl(u,v) is evaluated per pixel in the fragment shader and
155 // depends on which corner and edge being evaluated. w(u,v) is the device-space W coordinate, so
156 // its reciprocal is provided in sk_FragCoord.w.
157 namespace skgpu::graphite {
158
159 using AAFlags = EdgeAAQuad::Flags;
160
load_x_radii(const SkRRect & rrect)161 static skvx::float4 load_x_radii(const SkRRect& rrect) {
162 return skvx::float4{rrect.radii(SkRRect::kUpperLeft_Corner).fX,
163 rrect.radii(SkRRect::kUpperRight_Corner).fX,
164 rrect.radii(SkRRect::kLowerRight_Corner).fX,
165 rrect.radii(SkRRect::kLowerLeft_Corner).fX};
166 }
load_y_radii(const SkRRect & rrect)167 static skvx::float4 load_y_radii(const SkRRect& rrect) {
168 return skvx::float4{rrect.radii(SkRRect::kUpperLeft_Corner).fY,
169 rrect.radii(SkRRect::kUpperRight_Corner).fY,
170 rrect.radii(SkRRect::kLowerRight_Corner).fY,
171 rrect.radii(SkRRect::kLowerLeft_Corner).fY};
172 }
173
opposite_insets_intersect(const SkRRect & rrect,float strokeRadius,float aaRadius)174 static bool opposite_insets_intersect(const SkRRect& rrect, float strokeRadius, float aaRadius) {
175 // One AA inset per side
176 const float maxInset = strokeRadius + 2.f * aaRadius;
177 return // Horizontal insets would intersect opposite corner's curve
178 maxInset >= rrect.width() - rrect.radii(SkRRect::kLowerLeft_Corner).fX ||
179 maxInset >= rrect.width() - rrect.radii(SkRRect::kLowerRight_Corner).fX ||
180 maxInset >= rrect.width() - rrect.radii(SkRRect::kUpperLeft_Corner).fX ||
181 maxInset >= rrect.width() - rrect.radii(SkRRect::kUpperRight_Corner).fX ||
182 // Vertical insets would intersect opposite corner's curve
183 maxInset >= rrect.height() - rrect.radii(SkRRect::kLowerLeft_Corner).fY ||
184 maxInset >= rrect.height() - rrect.radii(SkRRect::kLowerRight_Corner).fY ||
185 maxInset >= rrect.height() - rrect.radii(SkRRect::kUpperLeft_Corner).fY ||
186 maxInset >= rrect.height() - rrect.radii(SkRRect::kUpperRight_Corner).fY;
187 }
188
opposite_insets_intersect(const Rect & rect,float strokeRadius,float aaRadius)189 static bool opposite_insets_intersect(const Rect& rect, float strokeRadius, float aaRadius) {
190 return any(rect.size() <= 2.f * (strokeRadius + aaRadius));
191 }
192
opposite_insets_intersect(const Geometry & geometry,float strokeRadius,float aaRadius)193 static bool opposite_insets_intersect(const Geometry& geometry,
194 float strokeRadius,
195 float aaRadius) {
196 if (geometry.isEdgeAAQuad()) {
197 SkASSERT(strokeRadius == 0.f);
198 const EdgeAAQuad& quad = geometry.edgeAAQuad();
199 if (quad.edgeFlags() == AAFlags::kNone) {
200 // If all edges are non-AA, there won't be any insetting. This allows completely non-AA
201 // quads to use the fill triangles for simpler fragment shader work.
202 return false;
203 } else if (quad.isRect() && quad.edgeFlags() == AAFlags::kAll) {
204 return opposite_insets_intersect(quad.bounds(), 0.f, aaRadius);
205 } else {
206 // Quads with mixed AA edges are tiles where non-AA edges must seam perfectly together.
207 // If we were to inset along just the axis with AA at a corner, two adjacent quads could
208 // arrive at slightly different inset coordinates and then we wouldn't have a perfect
209 // mesh. Forcing insets to snap to the center means all non-AA edges are formed solely
210 // by the original quad coordinates and should seam perfectly assuming perfect input.
211 // The only downside to this is the fill triangles cannot be used since they would
212 // partially extend into the coverage ramp from adjacent AA edges.
213 return true;
214 }
215 } else {
216 const Shape& shape = geometry.shape();
217 if (shape.isLine()) {
218 return strokeRadius <= aaRadius;
219 } else if (shape.isRect()) {
220 return opposite_insets_intersect(shape.rect(), strokeRadius, aaRadius);
221 } else {
222 SkASSERT(shape.isRRect());
223 return opposite_insets_intersect(shape.rrect(), strokeRadius, aaRadius);
224 }
225 }
226 }
227
is_clockwise(const EdgeAAQuad & quad)228 static bool is_clockwise(const EdgeAAQuad& quad) {
229 if (quad.isRect()) {
230 return true; // by construction, these are always locally clockwise
231 }
232
233 // This assumes that each corner has a consistent winding, which is the case for convex inputs,
234 // which is an assumption of the per-edge AA API. Check the sign of cross product between the
235 // first two edges.
236 const skvx::float4& xs = quad.xs();
237 const skvx::float4& ys = quad.ys();
238
239 float winding = (xs[0] - xs[3])*(ys[1] - ys[0]) - (ys[0] - ys[3])*(xs[1] - xs[0]);
240 if (winding == 0.f) {
241 // The input possibly forms a triangle with duplicate vertices, so check the opposite corner
242 winding = (xs[2] - xs[1])*(ys[3] - ys[2]) - (ys[2] - ys[1])*(xs[3] - xs[2]);
243 }
244
245 // At this point if winding is < 0, the quad's vertices are CCW. If it's still 0, the vertices
246 // form a line, in which case the vertex shader constructs a correct CW winding. Otherwise,
247 // the quad or triangle vertices produce a positive winding and are CW.
248 return winding >= 0.f;
249 }
250
quad_center(const EdgeAAQuad & quad)251 static skvx::float2 quad_center(const EdgeAAQuad& quad) {
252 // The center of the bounding box is *not* a good center to use. Take the average of the
253 // four points instead (which is slightly biased if they form a triangle, but still okay).
254 return skvx::float2(dot(quad.xs(), skvx::float4(0.25f)),
255 dot(quad.ys(), skvx::float4(0.25f)));
256 }
257
258 // Represents the per-vertex attributes used in each instance.
259 struct Vertex {
260 SkV2 fPosition;
261 SkV2 fNormal;
262 float fNormalScale;
263 float fCenterWeight;
264 };
265
266 // Allowed values for the center weight instance value (selected at record time based on style
267 // and transform), and are defined such that when (insance-weight > vertex-weight) is true, the
268 // vertex should be snapped to the center instead of its regular calculation.
269 static constexpr float kSolidInterior = 1.f;
270 static constexpr float kStrokeInterior = 0.f;
271 static constexpr float kFilledStrokeInterior = -1.f;
272
273 // Special value for local AA radius to signal when the self-intersections of a stroke interior
274 // need extra calculations in the vertex shader.
275 static constexpr float kComplexAAInsets = -1.f;
276
277 static constexpr int kCornerVertexCount = 9; // sk_VertexID is divided by this in SkSL
278 static constexpr int kVertexCount = 4 * kCornerVertexCount;
279 static constexpr int kIndexCount = 69;
280
write_index_buffer(VertexWriter writer)281 static void write_index_buffer(VertexWriter writer) {
282 static constexpr uint16_t kTL = 0 * kCornerVertexCount;
283 static constexpr uint16_t kTR = 1 * kCornerVertexCount;
284 static constexpr uint16_t kBR = 2 * kCornerVertexCount;
285 static constexpr uint16_t kBL = 3 * kCornerVertexCount;
286
287 static const uint16_t kIndices[kIndexCount] = {
288 // Exterior AA ramp outset
289 kTL+0,kTL+4,kTL+1,kTL+5,kTL+2,kTL+3,kTL+5,
290 kTR+0,kTR+4,kTR+1,kTR+5,kTR+2,kTR+3,kTR+5,
291 kBR+0,kBR+4,kBR+1,kBR+5,kBR+2,kBR+3,kBR+5,
292 kBL+0,kBL+4,kBL+1,kBL+5,kBL+2,kBL+3,kBL+5,
293 kTL+0,kTL+4, // close and jump to next strip
294 // Outer to inner edges
295 kTL+4,kTL+6,kTL+5,kTL+7,
296 kTR+4,kTR+6,kTR+5,kTR+7,
297 kBR+4,kBR+6,kBR+5,kBR+7,
298 kBL+4,kBL+6,kBL+5,kBL+7,
299 kTL+4,kTL+6, // close and jump to next strip
300 // Fill triangles
301 kTL+6,kTL+8,kTL+7, kTL+7,kTR+8,
302 kTR+6,kTR+8,kTR+7, kTR+7,kBR+8,
303 kBR+6,kBR+8,kBR+7, kBR+7,kBL+8,
304 kBL+6,kBL+8,kBL+7, kBL+7,kTL+8,
305 kTL+6 // close
306 };
307
308 if (writer) {
309 writer << kIndices;
310 } // otherwise static buffer creation failed, so do nothing; Context initialization will fail.
311 }
312
write_vertex_buffer(VertexWriter writer)313 static void write_vertex_buffer(VertexWriter writer) {
314 // Allowed values for the normal scale attribute. +1 signals a device-space outset along the
315 // normal away from the outer edge of the stroke. 0 signals no outset, but placed on the outer
316 // edge of the stroke. -1 signals a local inset along the normal from the inner edge.
317 static constexpr float kOutset = 1.0;
318 static constexpr float kInset = -1.0;
319
320 static constexpr float kCenter = 1.f; // "true" as a float
321
322 // Zero, but named this way to help call out non-zero parameters.
323 static constexpr float _______ = 0.f;
324
325 static constexpr float kHR2 = 0.5f * SK_FloatSqrt2; // "half root 2"
326
327 // This template is repeated 4 times in the vertex buffer, for each of the four corners.
328 // The vertex ID is used to lookup per-corner instance properties such as corner radii or
329 // positions, but otherwise this vertex data produces a consistent clockwise mesh from
330 // TL -> TR -> BR -> BL.
331 static constexpr Vertex kCornerTemplate[kCornerVertexCount] = {
332 // Device-space AA outsets from outer curve
333 { {1.0f, 0.0f}, {1.0f, 0.0f}, kOutset, _______ },
334 { {1.0f, 0.0f}, {kHR2, kHR2}, kOutset, _______ },
335 { {0.0f, 1.0f}, {kHR2, kHR2}, kOutset, _______ },
336 { {0.0f, 1.0f}, {0.0f, 1.0f}, kOutset, _______ },
337
338 // Outer anchors (no local or device-space normal outset)
339 { {1.0f, 0.0f}, {kHR2, kHR2}, _______, _______ },
340 { {0.0f, 1.0f}, {kHR2, kHR2}, _______, _______ },
341
342 // Inner curve (with additional AA inset in the common case)
343 { {1.0f, 0.0f}, {1.0f, 0.0f}, kInset, _______ },
344 { {0.0f, 1.0f}, {0.0f, 1.0f}, kInset, _______ },
345
346 // Center filling vertices (equal to inner AA insets unless 'center' triggers a fill).
347 // TODO: On backends that support "cull" distances (and with SkSL support), these vertices
348 // and their corresponding triangles can be completely removed. The inset vertices can
349 // set their cull distance value to cause all filling triangles to be discarded or not
350 // depending on the instance's style.
351 { {1.0f, 0.0f}, {1.0f, 0.0f}, kInset, kCenter },
352 };
353
354 if (writer) {
355 writer << kCornerTemplate // TL
356 << kCornerTemplate // TR
357 << kCornerTemplate // BR
358 << kCornerTemplate; // BL
359 } // otherwise static buffer creation failed, so do nothing; Context initialization will fail.
360 }
361
AnalyticRRectRenderStep(StaticBufferManager * bufferManager)362 AnalyticRRectRenderStep::AnalyticRRectRenderStep(StaticBufferManager* bufferManager)
363 : RenderStep("AnalyticRRectRenderStep",
364 "",
365 Flags::kPerformsShading | Flags::kEmitsCoverage | Flags::kOutsetBoundsForAA |
366 Flags::kUseNonAAInnerFill,
367 /*uniforms=*/{},
368 PrimitiveType::kTriangleStrip,
369 kDirectDepthGreaterPass,
370 /*vertexAttrs=*/{
371 {"position", VertexAttribType::kFloat2, SkSLType::kFloat2},
372 {"normal", VertexAttribType::kFloat2, SkSLType::kFloat2},
373 // TODO: These values are all +1/0/-1, or +1/0, so could be packed
374 // much more densely than as three floats.
375 {"normalScale", VertexAttribType::kFloat, SkSLType::kFloat},
376 {"centerWeight", VertexAttribType::kFloat, SkSLType::kFloat}
377 },
378 /*instanceAttrs=*/
379 {{"xRadiiOrFlags", VertexAttribType::kFloat4, SkSLType::kFloat4},
380 {"radiiOrQuadXs", VertexAttribType::kFloat4, SkSLType::kFloat4},
381 {"ltrbOrQuadYs", VertexAttribType::kFloat4, SkSLType::kFloat4},
382 // XY stores center of rrect in local coords. Z and W store values to
383 // control interior fill behavior. Z can be -1, 0, or 1:
384 // -1: A stroked interior where AA insets overlap, but isn't solid.
385 // 0: A stroked interior with no complications.
386 // 1: A solid interior (fill or sufficiently large stroke width).
387 // W specifies the size of the AA inset if it's >= 0, or signals that
388 // the inner curves intersect in a complex manner (rare).
389 {"center", VertexAttribType::kFloat4, SkSLType::kFloat4},
390
391 // TODO: pack depth and ssbo index into one 32-bit attribute, if we can
392 // go without needing both render step and paint ssbo index attributes.
393 {"depth", VertexAttribType::kFloat, SkSLType::kFloat},
394 {"ssboIndices", VertexAttribType::kUInt2, SkSLType::kUInt2},
395
396 {"mat0", VertexAttribType::kFloat3, SkSLType::kFloat3},
397 {"mat1", VertexAttribType::kFloat3, SkSLType::kFloat3},
398 {"mat2", VertexAttribType::kFloat3, SkSLType::kFloat3}},
399 /*varyings=*/{
400 // TODO: If the inverse transform is part of the draw's SSBO, we can
401 // reconstruct the Jacobian in the fragment shader using the existing
402 // local coordinates varying
403 {"jacobian", SkSLType::kFloat4}, // float2x2
404 // Distance to LTRB edges of unstroked shape. Depending on
405 // 'perPixelControl' these will either be local or device-space values.
406 {"edgeDistances", SkSLType::kFloat4}, // distance to LTRB edges
407 // TODO: These are constant for all fragments for a given instance,
408 // could we store them in the draw's SSBO?
409 {"xRadii", SkSLType::kFloat4},
410 {"yRadii", SkSLType::kFloat4},
411 // Matches the StrokeStyle struct (X is radius, Y < 0 is round join,
412 // Y = 0 is bevel, Y > 0 is miter join).
413 // TODO: These could easily be considered part of the draw's uniforms.
414 {"strokeParams", SkSLType::kFloat2},
415 // 'perPixelControl' is a tightly packed description of how to
416 // evaluate the possible edges that influence coverage in a pixel.
417 // The decision points and encoded values are spread across X and Y
418 // so that they are consistent regardless of whether or not MSAA is
419 // used and does not require centroid sampling.
420 //
421 // The signs of values are used to determine the type of coverage to
422 // calculate in the fragment shader and depending on the state, extra
423 // varying state is encoded in the fields:
424 // - A positive X value overrides all per-pixel coverage calculations
425 // and sets the pixel to full coverage. Y is ignored in this case.
426 // - A zero X value represents a solid interior shape.
427 // - X much less than 0 represents bidirectional coverage for a
428 // stroke, using a sufficiently negative value to avoid
429 // extrapolation from fill triangles. For actual shapes with
430 // bidirectional coverage, the fill triangles are zero area.
431 //
432 // - Y much greater than 0 takes precedence over the latter two X
433 // rules and signals that 'edgeDistances' holds device-space values
434 // and does not require additional per-pixel calculations. The
435 // coverage scale is encoded as (1+scale*w) and the bias is
436 // reconstructed from that. X is always 0 for non-fill triangles
437 // since device-space edge distance is only used for solid interiors
438 // - Otherwise, any negative Y value represents an additional
439 // reduction in coverage due to a device-space outset. It is clamped
440 // below 0 to avoid adding coverage from extrapolation.
441 {"perPixelControl", SkSLType::kFloat2},
442 }) {
443 // Initialize the static buffers we'll use when recording draw calls.
444 // NOTE: Each instance of this RenderStep gets its own copy of the data. Since there should only
445 // ever be one AnalyticRRectRenderStep at a time, this shouldn't be an issue.
446 write_vertex_buffer(bufferManager->getVertexWriter(sizeof(Vertex) * kVertexCount,
447 &fVertexBuffer));
448 write_index_buffer(bufferManager->getIndexWriter(sizeof(uint16_t) * kIndexCount,
449 &fIndexBuffer));
450 }
451
~AnalyticRRectRenderStep()452 AnalyticRRectRenderStep::~AnalyticRRectRenderStep() {}
453
vertexSkSL() const454 std::string AnalyticRRectRenderStep::vertexSkSL() const {
455 // Returns the body of a vertex function, which must define a float4 devPosition variable and
456 // must write to an already-defined float2 stepLocalCoords variable.
457 return "float4 devPosition = analytic_rrect_vertex_fn("
458 // Vertex Attributes
459 "position, normal, normalScale, centerWeight, "
460 // Instance Attributes
461 "xRadiiOrFlags, radiiOrQuadXs, ltrbOrQuadYs, center, depth, "
462 "float3x3(mat0, mat1, mat2), "
463 // Varyings
464 "jacobian, edgeDistances, xRadii, yRadii, strokeParams, perPixelControl, "
465 // Render Step
466 "stepLocalCoords);\n";
467 }
468
fragmentCoverageSkSL() const469 const char* AnalyticRRectRenderStep::fragmentCoverageSkSL() const {
470 // The returned SkSL must write its coverage into a 'half4 outputCoverage' variable (defined in
471 // the calling code) with the actual coverage splatted out into all four channels.
472 return "outputCoverage = analytic_rrect_coverage_fn(sk_FragCoord, "
473 "jacobian, "
474 "edgeDistances, "
475 "xRadii, "
476 "yRadii, "
477 "strokeParams, "
478 "perPixelControl);";
479 }
480
writeVertices(DrawWriter * writer,const DrawParams & params,skvx::uint2 ssboIndices) const481 void AnalyticRRectRenderStep::writeVertices(DrawWriter* writer,
482 const DrawParams& params,
483 skvx::uint2 ssboIndices) const {
484 SkASSERT(params.geometry().isShape() || params.geometry().isEdgeAAQuad());
485
486 DrawWriter::Instances instance{*writer, fVertexBuffer, fIndexBuffer, kIndexCount};
487 auto vw = instance.append(1);
488
489 // The bounds of a rect is the rect, and the bounds of a rrect is tight (== SkRRect::getRect()).
490 Rect bounds = params.geometry().bounds();
491
492 // aaRadius will be set to a negative value to signal a complex self-intersection that has to
493 // be calculated in the vertex shader.
494 float aaRadius = params.transform().localAARadius(bounds);
495 float strokeInset = 0.f;
496 float centerWeight = kSolidInterior;
497
498 if (params.isStroke()) {
499 // EdgeAAQuads are not stroked so we know it's a Shape, but we support rects, rrects, and
500 // lines that all need to be converted to the same form.
501 const Shape& shape = params.geometry().shape();
502
503 SkASSERT(params.strokeStyle().halfWidth() >= 0.f);
504 SkASSERT(shape.isRect() || shape.isLine() || params.strokeStyle().halfWidth() == 0.f ||
505 (shape.isRRect() && SkRRectPriv::AllCornersCircular(shape.rrect())));
506
507 float strokeRadius = params.strokeStyle().halfWidth();
508
509 skvx::float2 size = shape.isLine() ? skvx::float2(length(shape.p1() - shape.p0()), 0.f)
510 : bounds.size(); // rect or [r]rect
511
512 skvx::float2 innerGap = size - 2.f * params.strokeStyle().halfWidth();
513 if (any(innerGap <= 0.f) && strokeRadius > 0.f) {
514 // AA inset intersections are measured from the *outset* and remain marked as "solid"
515 strokeInset = -strokeRadius;
516 } else {
517 // This will be upgraded to kFilledStrokeInterior if insets intersect
518 centerWeight = kStrokeInterior;
519 strokeInset = strokeRadius;
520 }
521
522 skvx::float4 xRadii = shape.isRRect() ? load_x_radii(shape.rrect()) : skvx::float4(0.f);
523 if (strokeRadius > 0.f || shape.isLine()) {
524 // Regular strokes only need to upload 4 corner radii; hairline lines can be uploaded in
525 // the same manner since it has no real corner radii.
526 float joinStyle = params.strokeStyle().joinLimit();
527 float lineFlag = shape.isLine() ? 1.f : 0.f;
528 auto empty = size == 0.f;
529
530 // Points and lines produce caps instead of joins. However, the capped geometry is
531 // visually equivalent to a joined, stroked [r]rect of the paired join style.
532 if (shape.isLine() || all(empty)) {
533 // However, butt-cap points are defined not to produce any geometry, so that combo
534 // should have been rejected earlier.
535 SkASSERT(shape.isLine() || params.strokeStyle().cap() != SkPaint::kButt_Cap);
536 switch(params.strokeStyle().cap()) {
537 case SkPaint::kRound_Cap: joinStyle = -1.f; break; // round cap == round join
538 case SkPaint::kButt_Cap: joinStyle = 0.f; break; // butt cap == bevel join
539 case SkPaint::kSquare_Cap: joinStyle = 1.f; break; // square cap == miter join
540 }
541 } else if (params.strokeStyle().isMiterJoin()) {
542 // Normal corners are 90-degrees so become beveled if the miter limit is < sqrt(2).
543 // If the [r]rect has a width or height of 0, the corners are actually 180-degrees,
544 // so the must always be beveled (or, equivalently, butt-capped).
545 if (params.strokeStyle().miterLimit() < SK_ScalarSqrt2 || any(empty)) {
546 joinStyle = 0.f; // == bevel (or butt if width or height are zero)
547 } else {
548 // Discard actual miter limit because a 90-degree corner never exceeds it.
549 joinStyle = 1.f;
550 }
551 } // else no join style correction needed for non-empty geometry or round joins
552
553 // Write a negative value outside [-1, 0] to signal a stroked shape, the line flag, then
554 // the style params, followed by corner radii and coords.
555 vw << -2.f << lineFlag << strokeRadius << joinStyle << xRadii
556 << (shape.isLine() ? shape.line() : bounds.ltrb());
557 } else {
558 // Write -2 - cornerRadii to encode the X radii in such a way to trigger stroking but
559 // guarantee the 2nd field is non-zero to signal hairline. Then we upload Y radii as
560 // well to allow for elliptical hairlines.
561 skvx::float4 yRadii = shape.isRRect() ? load_y_radii(shape.rrect()) : skvx::float4(0.f);
562 vw << (-2.f - xRadii) << yRadii << bounds.ltrb();
563 }
564 } else {
565 // Empty fills should not have been recorded at all.
566 SkASSERT(!bounds.isEmptyNegativeOrNaN());
567
568 if (params.geometry().isEdgeAAQuad()) {
569 // NOTE: If quad.isRect() && quad.edgeFlags() == kAll, the written data is identical to
570 // Shape.isRect() case below.
571 const EdgeAAQuad& quad = params.geometry().edgeAAQuad();
572
573 // If all edges are non-AA, set localAARadius to 0 so that the fill triangles cover the
574 // entire shape. Otherwise leave it as-is for the full AA rect case; in the event it's
575 // mixed-AA or a quad, it'll be converted to complex insets down below.
576 if (quad.edgeFlags() == EdgeAAQuad::Flags::kNone) {
577 aaRadius = 0.f;
578 }
579
580 // -1 for AA on, 0 for AA off
581 auto edgeSigns = skvx::float4{quad.edgeFlags() & AAFlags::kLeft ? -1.f : 0.f,
582 quad.edgeFlags() & AAFlags::kTop ? -1.f : 0.f,
583 quad.edgeFlags() & AAFlags::kRight ? -1.f : 0.f,
584 quad.edgeFlags() & AAFlags::kBottom ? -1.f : 0.f};
585
586 // The vertex shader expects points to be in clockwise order. EdgeAAQuad is the only
587 // shape that *might* have counter-clockwise input.
588 if (is_clockwise(quad)) {
589 vw << edgeSigns << quad.xs() << quad.ys();
590 } else {
591 vw << skvx::shuffle<2,1,0,3>(edgeSigns) // swap left and right AA bits
592 << skvx::shuffle<1,0,3,2>(quad.xs()) // swap TL with TR, and BL with BR
593 << skvx::shuffle<1,0,3,2>(quad.ys()); // ""
594 }
595 } else {
596 const Shape& shape = params.geometry().shape();
597 // Filled lines are empty by definition, so they shouldn't have been recorded
598 SkASSERT(!shape.isLine());
599
600 if (shape.isRect() || (shape.isRRect() && shape.rrect().isRect())) {
601 // Rectangles (or rectangles embedded in an SkRRect) are converted to the
602 // quadrilateral case, but with all edges anti-aliased (== -1).
603 skvx::float4 ltrb = bounds.ltrb();
604 vw << /*edge flags*/ skvx::float4(-1.f)
605 << /*xs*/ skvx::shuffle<0,2,2,0>(ltrb)
606 << /*ys*/ skvx::shuffle<1,1,3,3>(ltrb);
607 } else {
608 // A filled rounded rectangle, so make sure at least one corner radii > 0 or the
609 // shader won't detect it as a rounded rect.
610 SkASSERT(any(load_x_radii(shape.rrect()) > 0.f));
611
612 vw << load_x_radii(shape.rrect()) << load_y_radii(shape.rrect()) << bounds.ltrb();
613 }
614 }
615 }
616
617 if (opposite_insets_intersect(params.geometry(), strokeInset, aaRadius)) {
618 aaRadius = kComplexAAInsets;
619 if (centerWeight == kStrokeInterior) {
620 centerWeight = kFilledStrokeInterior;
621 }
622 }
623
624 // All instance types share the remaining instance attribute definitions
625 const SkM44& m = params.transform().matrix();
626 auto center = params.geometry().isEdgeAAQuad() ? quad_center(params.geometry().edgeAAQuad())
627 : bounds.center();
628 vw << center << centerWeight << aaRadius
629 << params.order().depthAsFloat()
630 << ssboIndices
631 << m.rc(0,0) << m.rc(1,0) << m.rc(3,0) // mat0
632 << m.rc(0,1) << m.rc(1,1) << m.rc(3,1) // mat1
633 << m.rc(0,3) << m.rc(1,3) << m.rc(3,3); // mat2
634 }
635
writeUniformsAndTextures(const DrawParams &,PipelineDataGatherer *) const636 void AnalyticRRectRenderStep::writeUniformsAndTextures(const DrawParams&,
637 PipelineDataGatherer*) const {
638 // All data is uploaded as instance attributes, so no uniforms are needed.
639 }
640
641 } // namespace skgpu::graphite
642