GrQuad.cpp File Reference

#include "src/gpu/ganesh/geometry/GrQuad.h"
#include "include/core/SkMatrix.h"
#include "include/private/gpu/ganesh/GrTypesPriv.h"

Go to the source code of this file.

Typedefs
using	V4f = skvx::Vec< 4, float >

Functions
static bool	aa_affects_rect (GrQuadAAFlags edgeFlags, float ql, float qt, float qr, float qb)
static void	map_rect_translate_scale (const SkRect &rect, const SkMatrix &m, V4f *xs, V4f *ys)
static void	map_quad_general (const V4f &qx, const V4f &qy, const SkMatrix &m, V4f *xs, V4f *ys, V4f *ws)
static void	map_rect_general (const SkRect &rect, const SkMatrix &matrix, V4f *xs, V4f *ys, V4f *ws)
static void	rearrange_sk_to_gr_points (const SkPoint skQuadPts[4], V4f *xs, V4f *ys)
static GrQuad::Type	quad_type_for_transformed_rect (const SkMatrix &matrix)
static GrQuad::Type	quad_type_for_points (const SkPoint pts[4], const SkMatrix &matrix)

Typedef Documentation

V4f

using V4f = skvx::Vec<4, float>

Definition at line 13 of file GrQuad.cpp.

Function Documentation

aa_affects_rect()

static bool aa_affects_rect ( GrQuadAAFlags  edgeFlags, float  ql, float  qt, float  qr, float  qb  )

static

Definition at line 15 of file GrQuad.cpp.

                                                                                             {
    // Edge coordinates for non-AA edges do not need to be integers; any AA-enabled edge that is
    // at an integer coordinate could be drawn non-AA and be visually identical to non-AA.
    return ((edgeFlags & GrQuadAAFlags::kLeft)   && !SkScalarIsInt(ql)) ||
           ((edgeFlags & GrQuadAAFlags::kRight)  && !SkScalarIsInt(qr)) ||
           ((edgeFlags & GrQuadAAFlags::kTop)    && !SkScalarIsInt(qt)) ||
           ((edgeFlags & GrQuadAAFlags::kBottom) && !SkScalarIsInt(qb));
}

map_quad_general()

static void map_quad_general ( const V4f &  qx, const V4f &  qy, const SkMatrix &  m, V4f *  xs, V4f *  ys, V4f *  ws  )

static

Definition at line 43 of file GrQuad.cpp.

                                                        {
    *xs = m.getScaleX() * qx + (m.getSkewX() * qy + m.getTranslateX());
    *ys = m.getSkewY() * qx + (m.getScaleY() * qy + m.getTranslateY());
    if (m.hasPerspective()) {
        V4f w = m.getPerspX() * qx + (m.getPerspY() * qy + m.get(SkMatrix::kMPersp2));
        if (ws) {
            // Output the calculated w coordinates
            *ws = w;
        } else {
            // Apply perspective division immediately
            V4f iw = 1.f / w;
            *xs *= iw;
            *ys *= iw;
        }
    } else if (ws) {
        *ws = 1.f;
    }
}

map_rect_general()

static void map_rect_general ( const SkRect &  rect, const SkMatrix &  matrix, V4f *  xs, V4f *  ys, V4f *  ws  )

static

Definition at line 63 of file GrQuad.cpp.

                                                        {
    V4f rx{rect.fLeft, rect.fLeft, rect.fRight, rect.fRight};
    V4f ry{rect.fTop, rect.fBottom, rect.fTop, rect.fBottom};
    map_quad_general(rx, ry, matrix, xs, ys, ws);
}

map_rect_translate_scale()

static void map_rect_translate_scale ( const SkRect &  rect, const SkMatrix &  m, V4f *  xs, V4f *  ys  )

static

Definition at line 24 of file GrQuad.cpp.

                                                       {
    SkMatrix::TypeMask tm = m.getType();
    SkASSERT(tm <= (SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask));
 
    V4f r = V4f::Load(&rect);
    if (tm > SkMatrix::kIdentity_Mask) {
        const V4f t{m.getTranslateX(), m.getTranslateY(), m.getTranslateX(), m.getTranslateY()};
        if (tm <= SkMatrix::kTranslate_Mask) {
            r += t;
        } else {
            const V4f s{m.getScaleX(), m.getScaleY(), m.getScaleX(), m.getScaleY()};
            r = r * s + t;
        }
    }
    *xs = skvx::shuffle<0, 0, 2, 2>(r);
    *ys = skvx::shuffle<1, 3, 1, 3>(r);
}

quad_type_for_points()

static GrQuad::Type quad_type_for_points ( const SkPoint  pts[4], const SkMatrix &  matrix  )

static

Definition at line 92 of file GrQuad.cpp.

                                                                                     {
    if (matrix.hasPerspective()) {
        return GrQuad::Type::kPerspective;
    }
    // If 'pts' was formed by SkRect::toQuad() and not transformed further, it is safe to use the
    // quad type derived from 'matrix'. Otherwise don't waste any more time and assume kStandard
    // (most general 2D quad).
    if ((pts[0].fX == pts[3].fX && pts[1].fX == pts[2].fX) &&
        (pts[0].fY == pts[1].fY && pts[2].fY == pts[3].fY)) {
        return quad_type_for_transformed_rect(matrix);
    } else {
        return GrQuad::Type::kGeneral;
    }
}

quad_type_for_transformed_rect()

static GrQuad::Type quad_type_for_transformed_rect ( const SkMatrix &  matrix )

static

Definition at line 78 of file GrQuad.cpp.

                                                                         {
    if (matrix.rectStaysRect()) {
        return GrQuad::Type::kAxisAligned;
    } else if (matrix.preservesRightAngles()) {
        return GrQuad::Type::kRectilinear;
    } else if (matrix.hasPerspective()) {
        return GrQuad::Type::kPerspective;
    } else {
        return GrQuad::Type::kGeneral;
    }
}

rearrange_sk_to_gr_points()

static void rearrange_sk_to_gr_points ( const SkPoint  skQuadPts[4], V4f *  xs, V4f *  ys  )

static

Definition at line 72 of file GrQuad.cpp.

                                                                                    {
    *xs = V4f{skQuadPts[0].fX, skQuadPts[3].fX, skQuadPts[1].fX, skQuadPts[2].fX};
    *ys = V4f{skQuadPts[0].fY, skQuadPts[3].fY, skQuadPts[1].fY, skQuadPts[2].fY};
}