| /* |
| * Copyright 2022 Google LLC |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "src/gpu/graphite/render/AnalyticRRectRenderStep.h" |
| |
| #include "src/core/SkRRectPriv.h" |
| #include "src/gpu/graphite/DrawParams.h" |
| #include "src/gpu/graphite/DrawWriter.h" |
| #include "src/gpu/graphite/render/CommonDepthStencilSettings.h" |
| |
| // This RenderStep is flexible and can draw filled rectangles, filled quadrilaterals with per-edge |
| // AA, filled rounded rectangles with arbitrary corner radii, stroked rectangles with any join, |
| // and stroked rounded rectangles with circular corners (each corner can be different or square). |
| // We combine all of these together to maximize batching across simple geometric draws and reduce |
| // the number pipeline specializations. Additionally, these primitives are the most common |
| // operations and help us avoid triggering MSAA. |
| // |
| // Each of these "primitives" is represented by a single instance. The instance attributes are |
| // flexible enough to describe any of the above shapes without relying on uniforms to define its |
| // operation. The attributes encode shape as follows: |
| // |
| // float4 xRadiiOrFlags - if any components is > 0, the instance represents a filled round rect |
| // with elliptical corners and these values specify the X radii in top-left CW order. |
| // Otherwise, if .x < -1, the instance represents a stroked [round] rect and .y holds the |
| // stroke radius and .z holds the join limit (matching StrokeStyle's conventions). |
| // Else it's a filled quadrilateral with per-edge AA defined by each component: aa != 0. |
| // float4 radiiOrQuadXs - if in filled round rect mode, these values provide the Y radii in |
| // top-left CW order. If in stroked [round] rect mode, these values provide the circular |
| // corner radii (same order). Otherwise, when in per-edge quad mode, these values provide |
| // the X coordinates of the quadrilateral (same order). |
| // float4 ltrbOrQuadYs - if in filled round rect mode or stroked [round] rect mode, these values |
| // define the LTRB edge coordinates of the rectangle surrounding the round rect (or the |
| // rect itself when the radii are 0s). Otherwise, in per-edge quad mode, these values provide |
| // the Y coordinates of the quadrilateral. |
| // |
| // From the other direction, shapes produce instance values like: |
| // - filled rect: [-1 -1 -1 -1] [L R R L] [T T B B] |
| // - stroked rect: [-2 stroke join 0] [0 0 0 0] [L T R B] |
| // - filled rrect: [xRadii(tl,tr,br,bl)] [yRadii(tl,tr,br,bl)] [L T R B] |
| // - stroked rrect: [-2 stroke join 0] [radii(tl,tr,br,bl)] [L T R B] |
| // - per-edge quad: [aa(tl,tr,br,bl) ? -1 : 0] [xs(tl,tr,br,bl)] [ys(tl,tr,br,bl)] |
| // |
| // This encoding relies on the fact that a valid SkRRect with all x radii equal to 0 must have |
| // y radii equal to 0 (so it's a rectangle and we can treat it as a quadrilateral with |
| // all edges AA'ed). This avoids other encodings' inability to represent a quad with all edges |
| // anti-aliased (e.g. checking for negatives in xRadiiOrFlags to turn on per-edge mode). |
| // |
| // From this encoding, data can be unpacked for each corner, which are equivalent under |
| // rotational symmetry. A corner can have an outer curve, be mitered, or be beveled. It can |
| // have an inner curve, an inner miter, or fill the interior. Per-edge quads are always mitered |
| // and fill the interior, but the vertices are placed such that the edge coverage ramps can |
| // collapse to 0 area on non-AA edges. |
| // |
| // The vertices that describe each corner are placed so that edges, miters, and bevels calculate |
| // coverage by interpolating a varying and then clamping in the fragment shader. Triangles that |
| // cover the inner and outer curves calculate distance to the curve within the fragment shader. |
| // |
| // See https://docs.google.com/presentation/d/1MCPstNsSlDBhR8CrsJo0r-cZNbu-sEJEvU9W94GOJoY/edit?usp=sharing |
| // for diagrams and explanation of how the geometry is defined. |
| |
| namespace skgpu::graphite { |
| |
| static skvx::float4 loadXRadii(const SkRRect& rrect) { |
| // We swizzle X and Y radii for the anti-diagonal corners to match overall winding of the rrect |
| // when processed as vertices on the GPU. |
| return skvx::float4{rrect.radii(SkRRect::kUpperLeft_Corner).fX, |
| rrect.radii(SkRRect::kUpperRight_Corner).fY, |
| rrect.radii(SkRRect::kLowerRight_Corner).fX, |
| rrect.radii(SkRRect::kLowerLeft_Corner).fY}; |
| } |
| static skvx::float4 loadYRadii(const SkRRect& rrect) { |
| return skvx::float4{rrect.radii(SkRRect::kUpperLeft_Corner).fY, |
| rrect.radii(SkRRect::kUpperRight_Corner).fX, |
| rrect.radii(SkRRect::kLowerRight_Corner).fY, |
| rrect.radii(SkRRect::kLowerLeft_Corner).fX}; |
| } |
| |
| static float localAARadius(const Transform& t, const SkV2& p) { |
| // TODO: This should be the logic for Transform::scaleFactor() |
| // [m00 m01 * m03] [f(u,v)] |
| // Assuming M = [m10 m11 * m13], define the projected p'(u,v) = [g(u,v)] where |
| // [ * * * * ] |
| // [m30 m31 * m33] |
| // [x] [u] |
| // f(u,v) = x(u,v) / w(u,v), g(u,v) = y(u,v) / w(u,v) and [y] = M*[v] |
| // [*] = [0] |
| // [w] [1] |
| // |
| // x(u,v) = m00*u + m01*v + m03 |
| // y(u,v) = m10*u + m11*v + m13 |
| // w(u,v) = m30*u + m31*v + m33 |
| // |
| // dx/du = m00, dx/dv = m01, |
| // dy/du = m10, dy/dv = m11 |
| // dw/du = m30, dw/dv = m31 |
| // |
| // df/du = (dx/du*w - x*dw/du)/w^2 = (m00*w - m30*x)/w^2 |
| // df/dv = (dx/dv*w - x*dw/dv)/w^2 = (m01*w - m31*x)/w^2 |
| // dg/du = (dy/du*w - y*dw/du)/w^2 = (m10*w - m30*y)/w^2 |
| // dg/dv = (dy/dv*w - y*dw/du)/w^2 = (m11*w - m31*y)/w^2 |
| // |
| // Singular values of [df/du df/dv] define perspective correct minimum and maximum scale factors |
| // [dg/du dg/dv] |
| // for M evaluated at (u,v) |
| const SkM44& matrix = t.matrix(); |
| SkV4 devP = matrix.map(p.x, p.y, 0.f, 1.f); |
| |
| const float dxdu = matrix.rc(0,0); |
| const float dxdv = matrix.rc(0,1); |
| const float dydu = matrix.rc(1,0); |
| const float dydv = matrix.rc(1,1); |
| const float dwdu = matrix.rc(3,0); |
| const float dwdv = matrix.rc(3,1); |
| |
| float invW2 = sk_ieee_float_divide(1.f, (devP.w * devP.w)); |
| // non-persp has invW2 = 1, devP.w = 1, dwdu = 0, dwdv = 0 |
| float dfdu = (devP.w*dxdu - devP.x*dwdu) * invW2; // non-persp -> dxdu -> m00 |
| float dfdv = (devP.w*dxdv - devP.x*dwdv) * invW2; // non-persp -> dxdv -> m01 |
| float dgdu = (devP.w*dydu - devP.y*dwdu) * invW2; // non-persp -> dydu -> m10 |
| float dgdv = (devP.w*dydv - devP.y*dwdv) * invW2; // non-persp -> dydv -> m11 |
| |
| // no-persp, these are the singular values of [m00,m01][m10,m11], which is just the upper 2x2 |
| // and equivalent to SkMatrix::getMinmaxScales(). |
| float s1 = dfdu*dfdu + dfdv*dfdv + dgdu*dgdu + dgdv*dgdv; |
| |
| float e = dfdu*dfdu + dfdv*dfdv - dgdu*dgdu - dgdv*dgdv; |
| float f = dfdu*dgdu + dfdv*dgdv; |
| float s2 = SkScalarSqrt(e*e + 4*f*f); |
| |
| float singular1 = SkScalarSqrt(0.5f * (s1 + s2)); |
| float singular2 = SkScalarSqrt(0.5f * (s1 - s2)); |
| |
| // singular1 and 2 represent the minimum and maximum scale factors at that transformed point. |
| // Moving 1 from 'p' before transforming will move at least minimum and at most maximum from |
| // the transformed point. Thus moving between [1/max, 1/min] pre-transformation means post |
| // transformation moves between [1,max/min] so using 1/min as the local AA radius ensures that |
| // the post-transformed point is at least 1px away from the original. |
| float aaRadius = sk_ieee_float_divide(1.f, std::min(singular1, singular2)); |
| if (sk_float_isfinite(aaRadius)) { |
| return aaRadius; |
| } else { |
| // Treat NaNs and infinities as +inf, which will always trigger the inset self-intersection |
| // logic that snaps inner vertices to the center instead of insetting by the local AA radius |
| return SK_FloatInfinity; |
| } |
| } |
| |
| static float localAARadius(const Transform& t, const Rect& bounds) { |
| // Use the maximum radius of the 4 corners so that every local vertex uses the same offset |
| // even if it's more conservative on some corners (when the min/max scale isn't constant due |
| // to perspective). |
| if (t.type() < Transform::Type::kProjection) { |
| // Scale factors are constant, so the point doesn't really matter |
| return localAARadius(t, SkV2{0.f, 0.f}); |
| } else { |
| // TODO can we share calculation here? |
| float tl = localAARadius(t, SkV2{bounds.left(), bounds.top()}); |
| float tr = localAARadius(t, SkV2{bounds.right(), bounds.top()}); |
| float br = localAARadius(t, SkV2{bounds.right(), bounds.bot()}); |
| float bl = localAARadius(t, SkV2{bounds.left(), bounds.bot()}); |
| return std::max(std::max(tl, tr), std::max(bl, br)); |
| } |
| } |
| |
| static bool cornerInsetsIntersect(const SkRRect& rrect, float maxInset) { |
| return // Horizontal insets would intersect opposite corner's curve |
| maxInset >= rrect.width() - rrect.radii(SkRRect::kLowerLeft_Corner).fX || |
| maxInset >= rrect.width() - rrect.radii(SkRRect::kLowerRight_Corner).fX || |
| maxInset >= rrect.width() - rrect.radii(SkRRect::kUpperLeft_Corner).fX || |
| maxInset >= rrect.width() - rrect.radii(SkRRect::kUpperRight_Corner).fX || |
| // Vertical insets would intersect opposite corner's curve |
| maxInset >= rrect.height() - rrect.radii(SkRRect::kLowerLeft_Corner).fY || |
| maxInset >= rrect.height() - rrect.radii(SkRRect::kLowerRight_Corner).fY || |
| maxInset >= rrect.height() - rrect.radii(SkRRect::kUpperLeft_Corner).fY || |
| maxInset >= rrect.height() - rrect.radii(SkRRect::kUpperRight_Corner).fY; |
| } |
| |
| // Represents the per-vertex attributes used in each instance. |
| struct Vertex { |
| SkV2 fPosition; |
| SkV2 fNormal; |
| float fStrokeControl; |
| float fMirrorOffset; |
| float fCenterWeight; |
| }; |
| |
| // Allowed values for the center weight instance value (selected at record time based on style |
| // and transform), and are defined such that when (insance-weight > vertex-weight) is true, the |
| // vertex should be snapped to the center instead of its regular calculation. |
| static constexpr float kDontSnapToCenter = 0.f; |
| static constexpr float kFillCenter = 1.f; |
| static constexpr float kInsetsIntersect = 2.f; |
| |
| static constexpr int kCornerVertexCount = 19; // sk_VertexID is divided by this in SkSL |
| static constexpr int kVertexCount = 4 * kCornerVertexCount; |
| static constexpr int kIndexCount = 153; |
| |
| static size_t indexBufferSize() { return kIndexCount * sizeof(uint16_t); } |
| static void writeIndexBuffer(VertexWriter writer, size_t size) { |
| SkASSERT(indexBufferSize() == size); |
| |
| static constexpr uint16_t kTL = 0 * kCornerVertexCount; |
| static constexpr uint16_t kTR = 1 * kCornerVertexCount; |
| static constexpr uint16_t kBR = 2 * kCornerVertexCount; |
| static constexpr uint16_t kBL = 3 * kCornerVertexCount; |
| |
| static const uint16_t kIndices[kIndexCount] = { |
| // Exterior AA ramp outset |
| kTL+0,kTL+6,kTL+1,kTL+7,kTL+2,kTL+8,kTL+3,kTL+8,kTL+4,kTL+9,kTL+5,kTL+9, |
| kTR+0,kTR+6,kTR+1,kTR+7,kTR+2,kTR+8,kTR+3,kTR+8,kTR+4,kTR+9,kTR+5,kTR+9, |
| kBR+0,kBR+6,kBR+1,kBR+7,kBR+2,kBR+8,kBR+3,kBR+8,kBR+4,kBR+9,kBR+5,kBR+9, |
| kBL+0,kBL+6,kBL+1,kBL+7,kBL+2,kBL+8,kBL+3,kBL+8,kBL+4,kBL+9,kBL+5,kBL+9, |
| kTL+0,kTL+6,kTL+6, // close and extra vertex to jump to next strip |
| // Outer to central curve |
| kTL+6,kTL+10,kTL+7,kTL+11,kTL+8,kTL+12,kTL+9,kTL+13, |
| kTR+6,kTR+10,kTR+7,kTR+11,kTR+8,kTR+12,kTR+9,kTR+13, |
| kBR+6,kBR+10,kBR+7,kBR+11,kBR+8,kBR+12,kBR+9,kBR+13, |
| kBL+6,kBL+10,kBL+7,kBL+11,kBL+8,kBL+12,kBL+9,kBL+13, |
| kTL+6,kTL+10,kTL+10, // close and extra vertex to jump to next strip |
| // Center to inner curve's insets |
| kTL+10,kTL+14,kTL+11,kTL+15,kTL+12,kTL+16,kTL+13,kTL+16, |
| kTR+10,kTR+14,kTR+11,kTR+15,kTR+12,kTR+16,kTR+13,kTR+16, |
| kBR+10,kBR+14,kBR+11,kBR+15,kBR+12,kBR+16,kBR+13,kBR+16, |
| kBL+10,kBL+14,kBL+11,kBL+15,kBL+12,kBL+16,kBL+13,kBL+16, |
| kTL+10,kTL+14,kTL+14, // close and extra vertex to jump to next strip |
| // Inner inset to center of shape |
| kTL+14,kTL+17,kTL+15,kTL+17,kTL+16,kTL+16,kTL+18,kTR+14, |
| kTR+14,kTR+17,kTR+15,kTR+17,kTR+16,kTR+16,kTR+18,kBR+14, |
| kBR+14,kBR+17,kBR+15,kBR+17,kBR+16,kBR+16,kBR+18,kBL+14, |
| kBL+14,kBL+17,kBL+15,kBL+17,kBL+16,kBL+16,kBL+18,kTL+14 // close |
| }; |
| |
| writer << kIndices; |
| } |
| |
| static size_t vertexBufferSize() { return kVertexCount * sizeof(Vertex); } |
| static void writeVertexBuffer(VertexWriter writer, size_t size) { |
| SkASSERT(vertexBufferSize() == size); |
| |
| // Allowed values for the stroke control vertex attribute. This is multiplied with the stroke |
| // radius of the instance to get the final effect on the corner positions. When the stroke |
| // radius is zero (for fills or hairlines), the three possible curves are coincident. |
| static constexpr float kOuterStroke = 1.f; |
| static constexpr float kInnerStroke = -1.f; |
| static constexpr float kCenterStroke = 0.f; |
| |
| // Allowed values for the mirror offset attribute. The full normalized position for a vertex is |
| // position + join-scale*mirror-offset*position.yx; where join-scale is a scalar determined by |
| // the bevel, round, or miter join style of the instance and corner's radii. |
| static constexpr float kNoOffset = 0.f; |
| static constexpr float kMirrorOffset = 1.f; |
| |
| // Allowed values for each vertex's center weight (assuming only the allowed instance center |
| // weights are used, defined earlier). |
| static constexpr float kNeverSnapToCenter = 2.f; |
| static constexpr float kSnapIfInsetsIntersect = 1.f; |
| static constexpr float kSnapForFills = 0.f; |
| static constexpr float kHR2 = 0.5f * SK_FloatSqrt2; // "half root 2" |
| |
| // This template is repeated 4 times in the vertex buffer, for each of the four corners. |
| // The vertex ID is used to determine which corner the normalized position is transformed to. |
| static constexpr Vertex kCornerTemplate[kCornerVertexCount] = { |
| // Device-space AA outsets from outer curve |
| { {1.0f, 0.0f}, { 1.0f, 0.0f}, kOuterStroke, kNoOffset, kNeverSnapToCenter }, |
| { {1.0f, 0.0f}, { 1.0f, 0.0f}, kOuterStroke, kMirrorOffset, kNeverSnapToCenter }, |
| { {1.0f, 0.0f}, { kHR2, kHR2}, kOuterStroke, kMirrorOffset, kNeverSnapToCenter }, |
| { {0.0f, 1.0f}, { kHR2, kHR2}, kOuterStroke, kMirrorOffset, kNeverSnapToCenter }, |
| { {0.0f, 1.0f}, { 0.0f, 1.0f}, kOuterStroke, kMirrorOffset, kNeverSnapToCenter }, |
| { {0.0f, 1.0f}, { 0.0f, 1.0f}, kOuterStroke, kNoOffset, kNeverSnapToCenter }, |
| |
| // Outer anchors (no local or device-space normal outset) |
| { {1.0f, 0.0f}, { 0.0f, 0.0f}, kOuterStroke, kNoOffset, kNeverSnapToCenter }, |
| { {1.0f, 0.0f}, { 0.0f, 0.0f}, kOuterStroke, kMirrorOffset, kNeverSnapToCenter }, |
| { {0.0f, 1.0f}, { 0.0f, 0.0f}, kOuterStroke, kMirrorOffset, kNeverSnapToCenter }, |
| { {0.0f, 1.0f}, { 0.0f, 0.0f}, kOuterStroke, kNoOffset, kNeverSnapToCenter }, |
| |
| // Center of stroke (equivalent to outer anchors when filling) |
| { {1.0f, 0.0f}, { 0.0f, 0.0f}, kCenterStroke, kNoOffset, kNeverSnapToCenter }, |
| { {1.0f, 0.0f}, { 0.0f, 0.0f}, kCenterStroke, kMirrorOffset, kNeverSnapToCenter }, |
| { {0.0f, 1.0f}, { 0.0f, 0.0f}, kCenterStroke, kMirrorOffset, kNeverSnapToCenter }, |
| { {0.0f, 1.0f}, { 0.0f, 0.0f}, kCenterStroke, kNoOffset, kNeverSnapToCenter }, |
| |
| // Inner AA insets from inner curve |
| { {1.0f, 0.0f}, {-1.0f, 0.0f}, kInnerStroke, kNoOffset, kSnapIfInsetsIntersect }, |
| { {0.5f, 0.5f}, {-kHR2, -kHR2}, kInnerStroke, kMirrorOffset, kSnapIfInsetsIntersect }, |
| { {0.0f, 1.0f}, { 0.0f, -1.0f}, kInnerStroke, kNoOffset, kSnapIfInsetsIntersect }, |
| |
| // Center filling vertices (equal to inner AA insets unless instance weight = kFillCenter) |
| { {0.5f, 0.5f}, {-kHR2, -kHR2}, kInnerStroke, kMirrorOffset, kSnapForFills }, |
| { {0.0f, 1.0f}, { 0.0f, -1.0f}, kInnerStroke, kNoOffset, kSnapForFills }, |
| }; |
| |
| writer << kCornerTemplate // TL |
| << kCornerTemplate // TR |
| << kCornerTemplate // BR |
| << kCornerTemplate; // BL |
| } |
| |
| AnalyticRRectRenderStep::AnalyticRRectRenderStep() |
| : RenderStep("AnalyticRRectRenderStep", |
| "", |
| Flags::kPerformsShading | |
| Flags::kEmitsCoverage, |
| /*uniforms=*/{}, |
| PrimitiveType::kTriangleStrip, |
| kDirectDepthGreaterPass, |
| /*vertexAttrs=*/{ |
| {"position", VertexAttribType::kFloat2, SkSLType::kFloat2}, |
| {"normal", VertexAttribType::kFloat2, SkSLType::kFloat2}, |
| {"strokeControl", VertexAttribType::kFloat, SkSLType::kFloat}, |
| {"mirrorOffset", VertexAttribType::kFloat, SkSLType::kFloat}, |
| {"centerWeight", VertexAttribType::kFloat, SkSLType::kFloat} |
| }, |
| /*instanceAttrs=*/ |
| {{"xRadiiOrFlags", VertexAttribType::kFloat4, SkSLType::kFloat4}, |
| {"radiiOrQuadXs", VertexAttribType::kFloat4, SkSLType::kFloat4}, |
| {"ltrbOrQuadYs", VertexAttribType::kFloat4, SkSLType::kFloat4}, |
| // xy stores center of rrect in local coords, z stores a control value |
| // added to each vertex's centerWeight to handle snapping when needed. |
| // w stores the local AA radius calculated from the full transform. |
| {"center", VertexAttribType::kFloat4, SkSLType::kFloat4}, |
| |
| // TODO: pack depth and ssboIndex into 32-bits |
| {"depth", VertexAttribType::kFloat, SkSLType::kFloat}, |
| {"ssboIndex", VertexAttribType::kInt, SkSLType::kInt}, |
| |
| {"mat0", VertexAttribType::kFloat3, SkSLType::kFloat3}, |
| {"mat1", VertexAttribType::kFloat3, SkSLType::kFloat3}, |
| {"mat2", VertexAttribType::kFloat3, SkSLType::kFloat3}, |
| // We need the first two columns of the inverse transform to calculate |
| // the normal matrix. |
| {"invMat0", VertexAttribType::kFloat3, SkSLType::kFloat3}, |
| {"invMat1", VertexAttribType::kFloat3, SkSLType::kFloat3}}, |
| /*varyings=*/{}) {} |
| |
| AnalyticRRectRenderStep::~AnalyticRRectRenderStep() {} |
| |
| const char* AnalyticRRectRenderStep::vertexSkSL() const { |
| // TODO: Move this into a module |
| return R"( |
| const float kMiterScale = 1.0; |
| const float kBevelScale = 0.0; |
| const float kRoundScale = 0.41421356237; // sqrt(2)-1 |
| |
| int cornerID = sk_VertexID / 19; // KEEP IN SYNC WITH kCornerVertexCount |
| |
| float4 xs, ys; // should be BR, TR, TL, BL |
| float2 cornerRadii = float2(0.0); |
| float strokeRadius = 0.0; // fill and hairline are differentiated by center weighting |
| if (xRadiiOrFlags.x < -1.0) { |
| // Stroked rect or round rect |
| strokeRadius = xRadiiOrFlags.y; |
| cornerRadii = float2(radiiOrQuadXs[cornerID]); // strokes require circular corners |
| xs = ltrbOrQuadYs.LRRL; |
| ys = ltrbOrQuadYs.TTBB; |
| } else if (any(greaterThan(xRadiiOrFlags, float4(0.0)))) { |
| // Filled round rect |
| cornerRadii = float2(xRadiiOrFlags[cornerID], radiiOrQuadXs[cornerID]); |
| xs = ltrbOrQuadYs.LRRL; |
| ys = ltrbOrQuadYs.TTBB; |
| } else { |
| // Per-edge quadrilateral, so we have to calculate the corner's basis from the |
| // quad's edges. |
| xs = radiiOrQuadXs; |
| ys = ltrbOrQuadYs; |
| } |
| |
| float2 corner = float2(xs.xyzw[cornerID], ys.xyzw[cornerID]); |
| float2 cornerCW = float2(xs.yzwx[cornerID], ys.yzwx[cornerID]); |
| float2 cornerCCW = float2(xs.wxyz[cornerID], ys.wxyz[cornerID]); |
| float2 xAxis = normalize(corner - cornerCW); |
| float2 yAxis = normalize(corner - cornerCCW); |
| |
| // Determine the amount of mirror offsetting to apply based on fill/hairline/stroke join |
| // TODO should this analysis be done on the CPU and we upload 4 joinScales instead of |
| // 1 join style that has to be combined with the per-corner radii? |
| float joinScale; |
| if (cornerRadii.x > 0.000124 || cornerRadii.y > 0.000124) { |
| // A rounded corner is always rounded regardless of style |
| joinScale = kRoundScale; |
| } else if (strokeRadius > 0.0 && xRadiiOrFlags.z <= 0.0) { |
| // A rect corner of a non-hairline stroke changes based on the join type |
| joinScale = xRadiiOrFlags.z == 0.0 ? kBevelScale : kRoundScale; |
| } else { |
| // A filled or hairline rect corner is always mitered |
| joinScale = kMiterScale; |
| } |
| |
| float2 scale = cornerRadii + strokeRadius*strokeControl; |
| float2 localPos; |
| if (center.z > centerWeight) { |
| // It's either a fill and this vertex is designated to fill to the center, or it's a |
| // self-intersecting stroke that snaps to the center so geometry stays well-defined. |
| localPos = center.xy; |
| } else { |
| float2 p = scale*(position + joinScale*mirrorOffset*position.yx); |
| |
| if (strokeControl < 0.0) { |
| // An inset, so check for and avoid self-intersections |
| float localAARadius = center.w; |
| float2 maxInset = scale - localAARadius; |
| if (any(lessThan(maxInset, float2(0.0)))) { |
| p = min(maxInset, float2(0.0)); |
| } else { |
| p += localAARadius * normal; |
| } |
| } |
| |
| // Orient and place p relative to the corner's location in the local rectangle |
| localPos = float2x2(xAxis, yAxis)*(p - cornerRadii) + corner; |
| } |
| |
| float3 devPos = float3x3(mat0, mat1, mat2)*localPos.xy1; |
| if (strokeControl > 0.0 && (normal.x > 0.0 || normal.y > 0.0)) { |
| // We need a device-space normal added to devPos. Transform the local normal by the |
| // normal matrix (A^-1)^T where A = M*T(corner)*scale; but since we know the structure |
| // of T(corner)*scale and that we're in 2D, we can skip computing the entire matrix. |
| float3 localNx = calc_line_eq(-yAxis, corner); |
| float3 localNy = calc_line_eq( xAxis, corner); |
| |
| float sx = (scale.y + 0.000124) / (scale.x + 0.000124); |
| float2 nx = sx * normal.x * float2(dot(invMat0, localNx), dot(invMat1, localNx)); |
| float2 ny = normal.y * float2(dot(invMat0, localNy), dot(invMat1, localNy)); |
| |
| if (joinScale == 1.0 && all(greaterThan(normal, float2(0.0)))) { |
| // Produce a bisecting vector in device space. |
| nx = normalize(nx); |
| ny = normalize(ny); |
| if (dot(nx, ny) < -0.8) { |
| // Normals are in nearly opposite directions, so adjust to avoid float error. |
| float s = sign(cross_length_2d(nx, ny)); |
| nx = s*ortho(nx); |
| ny = -s*ortho(ny); |
| } |
| } |
| // Adding the normal components together directly results in what we'd have |
| // calculated if we'd just transformed 'normal' in one go, assuming they weren't |
| // normalized in the if-block above. If they were normalized, the sum equals the |
| // bisector between the original nx and ny. |
| // |
| // We multiply by W so that after perspective division the new point is offset by the |
| // normal. |
| devPos.xy += devPos.z * normalize(nx + ny); |
| } |
| |
| // Write out final results |
| stepLocalCoords = localPos; |
| float4 devPosition = float4(devPos.xy, devPos.z*depth, devPos.z); |
| )"; |
| } |
| |
| const char* AnalyticRRectRenderStep::fragmentCoverageSkSL() const { |
| // TODO: Actually implement this for linear edges (that get clamp a varying to [0,1]) and for |
| // corners calculating distance to an ellipse. |
| return R"( |
| outputCoverage = half4(1.0); |
| )"; |
| } |
| |
| void AnalyticRRectRenderStep::writeVertices(DrawWriter* writer, |
| const DrawParams& params, |
| int ssboIndex) const { |
| SkASSERT(params.geometry().isShape()); |
| const Shape& shape = params.geometry().shape(); |
| |
| BindBufferInfo vertices = |
| writer->bufferManager()->getStaticBuffer(BufferType::kVertex, |
| writeVertexBuffer, vertexBufferSize); |
| BindBufferInfo indices = writer->bufferManager()->getStaticBuffer(BufferType::kIndex, |
| writeIndexBuffer, |
| indexBufferSize); |
| DrawWriter::Instances instance{*writer, vertices, indices, kIndexCount}; |
| auto vw = instance.append(1); |
| |
| // The bounds of a rect is the rect, and the bounds of a rrect is tight |
| Rect bounds = params.geometry().bounds(); |
| const float aaRadius = localAARadius(params.transform(), bounds); |
| float centerWeight; |
| |
| if (params.isStroke()) { |
| SkASSERT(params.strokeStyle().halfWidth() >= 0.f); |
| SkASSERT(shape.isRect() || |
| (shape.isRRect() && SkRRectPriv::AllCornersCircular(shape.rrect()))); |
| |
| const float maxInset = aaRadius + params.strokeStyle().halfWidth(); |
| bool insetsIntersect = any(2.f * maxInset >= bounds.size()); |
| |
| skvx::float4 cornerRadii; |
| if (shape.isRRect()) { |
| // X and Y radii are the same, but each corner could be different. Take X arbitrarily. |
| cornerRadii = loadXRadii(shape.rrect()); |
| insetsIntersect |= cornerInsetsIntersect(shape.rrect(), maxInset); |
| } else { |
| // All four corner radii are 0s for a rectangle |
| cornerRadii = 0.f; |
| } |
| |
| // Write a negative value outside [-1, 0] to signal a stroked shape, then the style params, |
| // followed by corner radii and bounds. |
| vw << -2.f << params.strokeStyle().halfWidth() << params.strokeStyle().joinLimit() << 0.f |
| << cornerRadii << bounds.ltrb(); |
| centerWeight = insetsIntersect ? kInsetsIntersect : kDontSnapToCenter; |
| } else { |
| // TODO: Add quadrilateral support to Shape with per-edge flags. |
| if (shape.isRect() || (shape.isRRect() && shape.rrect().isRect())) { |
| // Rectangles (or rectangles embedded in an SkRRect) are converted to the quadrilateral |
| // case, but with all edges anti-aliased (== -1). |
| skvx::float4 ltrb = bounds.ltrb(); |
| vw << /*edge flags*/ skvx::float4(-1.f) |
| << /*xs*/ skvx::shuffle<0,2,2,0>(ltrb) |
| << /*ys*/ skvx::shuffle<1,1,3,3>(ltrb); |
| // For simplicity, it's assumed arbitrary quad insets could self-intersect, so force |
| // all interior vertices to the center. |
| centerWeight = kInsetsIntersect; |
| } else { |
| // A filled rounded rectangle |
| const SkRRect& rrect = shape.rrect(); |
| SkASSERT(any(loadXRadii(rrect) > 0.f)); // If not, the shader won't detect this case |
| |
| vw << loadXRadii(rrect) << loadYRadii(rrect) << bounds.ltrb(); |
| centerWeight = cornerInsetsIntersect(rrect, aaRadius) ? kInsetsIntersect : kFillCenter; |
| } |
| } |
| |
| // All instance types share the remaining instance attribute definitions |
| const SkM44& m = params.transform().matrix(); |
| const SkM44& invM = params.transform().inverse(); |
| vw << bounds.center() << centerWeight << aaRadius |
| << params.order().depthAsFloat() |
| << ssboIndex |
| << m.rc(0,0) << m.rc(1,0) << m.rc(3,0) // mat0 |
| << m.rc(0,1) << m.rc(1,1) << m.rc(3,1) // mat1 |
| << m.rc(0,3) << m.rc(1,3) << m.rc(3,3) // mat2 |
| << invM.rc(0,0) << invM.rc(1,0) << invM.rc(3,0) // invMat0 |
| << invM.rc(0,1) << invM.rc(1,1) << invM.rc(3,1); // invMat1 |
| } |
| |
| void AnalyticRRectRenderStep::writeUniformsAndTextures(const DrawParams&, |
| PipelineDataGatherer*) const { |
| // All data is uploaded as instance attributes, so no uniforms are needed. |
| } |
| |
| } // namespace skgpu::graphite |
