DegenerateQuadsSlide.cpp File Reference

#include "include/core/SkCanvas.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPathEffect.h"
#include "include/effects/SkDashPathEffect.h"
#include "include/pathops/SkPathOps.h"
#include "include/private/base/SkTPin.h"
#include "src/gpu/ganesh/geometry/GrQuad.h"
#include "src/gpu/ganesh/ops/QuadPerEdgeAA.h"
#include "tools/viewer/ClickHandlerSlide.h"

Go to the source code of this file.

Classes
class	DegenerateQuadSlide
class	DegenerateQuadSlide::Click

Typedefs
using	VertexSpec = skgpu::ganesh::QuadPerEdgeAA::VertexSpec
using	ColorType = skgpu::ganesh::QuadPerEdgeAA::ColorType
using	Subset = skgpu::ganesh::QuadPerEdgeAA::Subset
using	IndexBufferOption = skgpu::ganesh::QuadPerEdgeAA::IndexBufferOption

Functions
static void	draw_extended_line (SkCanvas *canvas, const SkPaint &paint, const SkPoint &p0, const SkPoint &p1)
static void	make_aa_line (const SkPoint &p0, const SkPoint &p1, bool aaOn, bool outset, SkPoint line[2])
static SkScalar	signed_distance (const SkPoint &p, const SkPoint &l0, const SkPoint &l1)
static SkScalar	get_area_coverage (const bool edgeAA[4], const SkPoint corners[4], const SkPoint &point)
static SkScalar	get_edge_dist_coverage (const bool edgeAA[4], const SkPoint corners[4], const SkPoint outsetLines[8], const SkPoint insetLines[8], const SkPoint &point)
static bool	inside_triangle (const SkPoint &point, const SkPoint &t0, const SkPoint &t1, const SkPoint &t2, SkScalar bary[3])
static SkScalar	get_framed_coverage (const SkPoint outer[4], const SkScalar outerCoverages[4], const SkPoint inner[4], const SkScalar innerCoverages[4], const SkRect &geomDomain, const SkPoint &point)

Variables
static constexpr SkScalar	kViewScale = 100.f
static constexpr SkScalar	kViewOffset = 200.f

Typedef Documentation

ColorType

using ColorType = skgpu::ganesh::QuadPerEdgeAA::ColorType

Definition at line 19 of file DegenerateQuadsSlide.cpp.

IndexBufferOption

using IndexBufferOption = skgpu::ganesh::QuadPerEdgeAA::IndexBufferOption

Definition at line 21 of file DegenerateQuadsSlide.cpp.

Subset

using Subset = skgpu::ganesh::QuadPerEdgeAA::Subset

Definition at line 20 of file DegenerateQuadsSlide.cpp.

VertexSpec

using VertexSpec = skgpu::ganesh::QuadPerEdgeAA::VertexSpec

Definition at line 18 of file DegenerateQuadsSlide.cpp.

Function Documentation

draw_extended_line()

static void draw_extended_line ( SkCanvas *  canvas, const SkPaint &  paint, const SkPoint &  p0, const SkPoint &  p1  )

static

Definition at line 24 of file DegenerateQuadsSlide.cpp.

                                                                     {
    SkVector v = p1 - p0;
    v.setLength(v.length() + 3.f);
    canvas->drawLine(p1 - v, p0 + v, paint);
 
    // Draw normal vector too
    SkPaint normalPaint = paint;
    normalPaint.setPathEffect(nullptr);
    normalPaint.setStrokeWidth(paint.getStrokeWidth() / 4.f);
 
    SkVector n = {v.fY, -v.fX};
    n.setLength(.25f);
    SkPoint m = (p0 + p1) * 0.5f;
    canvas->drawLine(m, m + n, normalPaint);
}

get_area_coverage()

static SkScalar get_area_coverage ( const bool  edgeAA[4], const SkPoint  corners[4], const SkPoint &  point  )

static

Definition at line 63 of file DegenerateQuadsSlide.cpp.

                                                        {
    SkPath shape;
    shape.addPoly(corners, 4, true);
    SkPath pixel;
    pixel.addRect(SkRect::MakeXYWH(point.fX - 0.5f, point.fY - 0.5f, 1.f, 1.f));
 
    SkPath intersection;
    if (!Op(shape, pixel, kIntersect_SkPathOp, &intersection) || intersection.isEmpty()) {
        return 0.f;
    }
 
    // Calculate area of the convex polygon
    SkScalar area = 0.f;
    for (int i = 0; i < intersection.countPoints(); ++i) {
        SkPoint p0 = intersection.getPoint(i);
        SkPoint p1 = intersection.getPoint((i + 1) % intersection.countPoints());
        SkScalar det = p0.fX * p1.fY - p1.fX * p0.fY;
        area += det;
    }
 
    // Scale by 1/2, then take abs value (this area formula is signed based on point winding, but
    // since it's convex, just make it positive).
    area = SkScalarAbs(0.5f * area);
 
    // Now account for the edge AA. If the pixel center is outside of a non-AA edge, turn of its
    // coverage. If the pixel only intersects non-AA edges, then set coverage to 1.
    bool needsNonAA = false;
    SkScalar edgeD[4];
    for (int i = 0; i < 4; ++i) {
        SkPoint e0 = corners[i];
        SkPoint e1 = corners[(i + 1) % 4];
        edgeD[i] = -signed_distance(point, e0, e1);
        if (!edgeAA[i]) {
            if (edgeD[i] < -1e-4f) {
                return 0.f; // Outside of non-AA line
            }
            needsNonAA = true;
        }
    }
    // Otherwise inside the shape, so check if any AA edge exerts influence over nonAA
    if (needsNonAA) {
        for (int i = 0; i < 4; i++) {
            if (edgeAA[i] && edgeD[i] < 0.5f) {
                needsNonAA = false;
                break;
            }
        }
    }
    return needsNonAA ? 1.f : area;
}

get_edge_dist_coverage()

static SkScalar get_edge_dist_coverage ( const bool  edgeAA[4], const SkPoint  corners[4], const SkPoint  outsetLines[8], const SkPoint  insetLines[8], const SkPoint &  point  )

static

Definition at line 116 of file DegenerateQuadsSlide.cpp.

                                                             {
    bool flip = false;
    // If the quad has been inverted, the original corners will not all be on the negative side of
    // every outset line. When that happens, calculate coverage using the "inset" lines and flip
    // the signed distance
    for (int i = 0; i < 4; ++i) {
        for (int j = 0; j < 4; ++j) {
            SkScalar d = signed_distance(corners[i], outsetLines[j * 2], outsetLines[j * 2 + 1]);
            if (d > 1e-4f) {
                flip = true;
                break;
            }
        }
        if (flip) {
            break;
        }
    }
 
    const SkPoint* lines = flip ? insetLines : outsetLines;
 
    SkScalar minCoverage = 1.f;
    for (int i = 0; i < 4; ++i) {
        // Multiply by negative 1 so that outside points have negative distances
        SkScalar d = (flip ? 1 : -1) * signed_distance(point, lines[i * 2], lines[i * 2 + 1]);
        if (!edgeAA[i] && d >= -1e-4f) {
            d = 1.f;
        }
        if (d < minCoverage) {
            minCoverage = d;
            if (minCoverage < 0.f) {
                break; // Outside the shape
            }
        }
    }
    return minCoverage < 0.f ? 0.f : minCoverage;
}

get_framed_coverage()

static SkScalar get_framed_coverage ( const SkPoint  outer[4], const SkScalar  outerCoverages[4], const SkPoint  inner[4], const SkScalar  innerCoverages[4], const SkRect &  geomDomain, const SkPoint &  point  )

static

Definition at line 193 of file DegenerateQuadsSlide.cpp.

                                                                                    {
    // Triangles are ordered clock wise. Indices >= 4 refer to inner[i - 4]. Otherwise its outer[i].
    static const int kFrameTris[] = {
        0, 1, 4,   4, 1, 5,
        1, 2, 5,   5, 2, 6,
        2, 3, 6,   6, 3, 7,
        3, 0, 7,   7, 0, 4,
        4, 5, 7,   7, 5, 6
    };
    static const int kNumTris = 10;
 
    SkScalar bary[3];
    for (int i = 0; i < kNumTris; ++i) {
        int i0 = kFrameTris[i * 3];
        int i1 = kFrameTris[i * 3 + 1];
        int i2 = kFrameTris[i * 3 + 2];
 
        SkPoint t0 = i0 >= 4 ? inner[i0 - 4] : outer[i0];
        SkPoint t1 = i1 >= 4 ? inner[i1 - 4] : outer[i1];
        SkPoint t2 = i2 >= 4 ? inner[i2 - 4] : outer[i2];
        if (inside_triangle(point, t0, t1, t2, bary)) {
            // Calculate coverage by barycentric interpolation of coverages
            SkScalar c0 = i0 >= 4 ? innerCoverages[i0 - 4] : outerCoverages[i0];
            SkScalar c1 = i1 >= 4 ? innerCoverages[i1 - 4] : outerCoverages[i1];
            SkScalar c2 = i2 >= 4 ? innerCoverages[i2 - 4] : outerCoverages[i2];
 
            SkScalar coverage = bary[0] * c0 + bary[1] * c1 + bary[2] * c2;
            if (coverage < 0.5f) {
                // Check distances to domain
                SkScalar l = SkTPin(point.fX - geomDomain.fLeft, 0.f, 1.f);
                SkScalar t = SkTPin(point.fY - geomDomain.fTop, 0.f, 1.f);
                SkScalar r = SkTPin(geomDomain.fRight - point.fX, 0.f, 1.f);
                SkScalar b = SkTPin(geomDomain.fBottom - point.fY, 0.f, 1.f);
                coverage = std::min(coverage, l * t * r * b);
            }
            return coverage;
        }
    }
    // Not inside any triangle
    return 0.f;
}

inside_triangle()

static bool inside_triangle ( const SkPoint &  point, const SkPoint &  t0, const SkPoint &  t1, const SkPoint &  t2, SkScalar  bary[3]  )

static

Definition at line 155 of file DegenerateQuadsSlide.cpp.

                                                                 {
    // Check sign of t0 to (t1,t2). If it is positive, that means the normals point into the
    // triangle otherwise the normals point outside the triangle so update edge distances as
    // necessary
    bool flip = signed_distance(t0, t1, t2) < 0.f;
 
    SkScalar d0 = (flip ? -1 : 1) * signed_distance(point, t0, t1);
    SkScalar d1 = (flip ? -1 : 1) * signed_distance(point, t1, t2);
    SkScalar d2 = (flip ? -1 : 1) * signed_distance(point, t2, t0);
    // Be a little forgiving
    if (d0 < -1e-4f || d1 < -1e-4f || d2 < -1e-4f) {
        return false;
    }
 
    // Inside, so calculate barycentric coords from the sideline distances
    SkScalar d01 = (t0 - t1).length();
    SkScalar d12 = (t1 - t2).length();
    SkScalar d20 = (t2 - t0).length();
 
    if (SkScalarNearlyZero(d12) || SkScalarNearlyZero(d20) || SkScalarNearlyZero(d01)) {
        // Empty degenerate triangle
        return false;
    }
 
    // Coordinates for a vertex use distances to the opposite edge
    bary[0] = d1 * d12;
    bary[1] = d2 * d20;
    bary[2] = d0 * d01;
    // And normalize
    SkScalar sum = bary[0] + bary[1] + bary[2];
    bary[0] /= sum;
    bary[1] /= sum;
    bary[2] /= sum;
 
    return true;
}

make_aa_line()

static void make_aa_line ( const SkPoint &  p0, const SkPoint &  p1, bool  aaOn, bool  outset, SkPoint  line[2]  )

static

Definition at line 41 of file DegenerateQuadsSlide.cpp.

                                                       {
    SkVector n = {0.f, 0.f};
    if (aaOn) {
        SkVector v = p1 - p0;
        n = outset ? SkVector::Make(v.fY, -v.fX) : SkVector::Make(-v.fY, v.fX);
        n.setLength(0.5f);
    }
 
    line[0] = p0 + n;
    line[1] = p1 + n;
}

signed_distance()

static SkScalar signed_distance ( const SkPoint &  p, const SkPoint &  l0, const SkPoint &  l1  )

static

Definition at line 55 of file DegenerateQuadsSlide.cpp.

                                                                                        {
    SkVector v = l1 - l0;
    v.normalize();
    SkVector n = {v.fY, -v.fX};
    SkScalar c = -n.dot(l0);
    return n.dot(p) + c;
}

Variable Documentation

kViewOffset

constexpr SkScalar kViewOffset = 200.f

staticconstexpr

Definition at line 238 of file DegenerateQuadsSlide.cpp.

kViewScale

constexpr SkScalar kViewScale = 100.f

staticconstexpr

Definition at line 237 of file DegenerateQuadsSlide.cpp.