GrQuad Class Reference

#include <GrQuad.h>

Public Types
enum class	Type {   kAxisAligned , kRectilinear , kGeneral , kPerspective ,   kLast = kPerspective }

Public Member Functions
	GrQuad ()=default
	GrQuad (const GrQuad &)=default
	GrQuad (const SkRect &rect)
GrQuad &	operator= (const GrQuad &)=default
SkPoint3	point3 (int i) const
SkPoint	point (int i) const
void	writeVertex (int cornerIdx, skgpu::VertexWriter &w) const
SkRect	bounds () const
bool	isFinite () const
float	x (int i) const
float	y (int i) const
float	w (int i) const
float	iw (int i) const
skvx::Vec< 4, float >	x4f () const
skvx::Vec< 4, float >	y4f () const
skvx::Vec< 4, float >	w4f () const
skvx::Vec< 4, float >	iw4f () const
Type	quadType () const
bool	hasPerspective () const
bool	aaHasEffectOnRect (GrQuadAAFlags edgeFlags) const
bool	asRect (SkRect *rect) const
const float *	xs () const
float *	xs ()
const float *	ys () const
float *	ys ()
const float *	ws () const
float *	ws ()
void	setQuadType (Type newType)

Static Public Member Functions
static GrQuad	MakeFromRect (const SkRect &, const SkMatrix &)
static GrQuad	MakeFromSkQuad (const SkPoint pts[4], const SkMatrix &)

Static Public Attributes
static const int	kTypeCount = static_cast<int>(Type::kLast) + 1

Friends
template<typename T >
class	GrQuadListBase

Detailed Description

GrQuad is a collection of 4 points which can be used to represent an arbitrary quadrilateral. The points make a triangle strip with CCW triangles (top-left, bottom-left, top-right, bottom-right).

Definition at line 30 of file GrQuad.h.

Member Enumeration Documentation

Type

enum class GrQuad::Type

strong

Enumerator
kAxisAligned
kRectilinear
kGeneral
kPerspective
kLast

Definition at line 35 of file GrQuad.h.

                    {
        // The 4 points remain an axis-aligned rectangle; their logical indices may not respect
        // TL, BL, TR, BR ordering if the transform was a 90 degree rotation or mirror.
        kAxisAligned,
        // The 4 points represent a rectangle subjected to a rotation, its corners are right angles.
        kRectilinear,
        // Arbitrary 2D quadrilateral; may have been a rectangle transformed with skew or some
        // clipped polygon. Its w coordinates will all be 1.
        kGeneral,
        // Even more general-purpose than kGeneral, this allows the w coordinates to be non-unity.
        kPerspective,
        kLast = kPerspective
    };

Constructor & Destructor Documentation

GrQuad() [1/3]

GrQuad::GrQuad ( )

default

GrQuad() [2/3]

GrQuad::GrQuad ( const GrQuad &  )

default

GrQuad() [3/3]

GrQuad::GrQuad ( const SkRect &  rect )

inlineexplicit

Definition at line 54 of file GrQuad.h.

            : fX{rect.fLeft, rect.fLeft, rect.fRight, rect.fRight}
            , fY{rect.fTop, rect.fBottom, rect.fTop, rect.fBottom} {}

Member Function Documentation

aaHasEffectOnRect()

bool GrQuad::aaHasEffectOnRect

(

GrQuadAAFlags

edgeFlags

)

const

Definition at line 135 of file GrQuad.cpp.

                                                            {
    SkASSERT(this->quadType() == Type::kAxisAligned);
    // If rect, ws must all be 1s so no need to divide
    return aa_affects_rect(edgeFlags, fX[0], fY[0], fX[3], fY[3]);
}

asRect()

bool GrQuad::asRect

(

SkRect *

rect

)

const

Definition at line 141 of file GrQuad.cpp.

                                      {
    if (this->quadType() != Type::kAxisAligned) {
        return false;
    }
 
    *rect = this->bounds();
    // v0 at the geometric top-left is unique amongst axis-aligned vertex orders
    // (90, 180, 270 rotations or axis flips all move v0).
    return fX[0] == rect->fLeft && fY[0] == rect->fTop;
}

bounds()

SkRect GrQuad::bounds ( ) const

inline

Definition at line 81 of file GrQuad.h.

                          {
        if (fType == GrQuad::Type::kPerspective) {
            return this->projectedBounds();
        }
        // Calculate min/max directly on the 4 floats, instead of loading/unloading into SIMD. Since
        // there's no horizontal min/max, it's not worth it. Defining non-perspective case in header
        // also leads to substantial performance boost due to inlining.
        auto min = [](const float c[4]) { return std::min(std::min(c[0], c[1]),
                                                          std::min(c[2], c[3]));};
        auto max = [](const float c[4]) { return std::max(std::max(c[0], c[1]),
                                                          std::max(c[2], c[3]));};
        return { min(fX), min(fY), max(fX), max(fY) };
    }

hasPerspective()

bool GrQuad::hasPerspective ( ) const

inline

Definition at line 120 of file GrQuad.h.

{ return fType == Type::kPerspective; }

isFinite()

bool GrQuad::isFinite ( ) const

inline

Definition at line 95 of file GrQuad.h.

                          {
        // If any coordinate is infinity or NaN, then multiplying it with 0 will make accum NaN
        float accum = 0;
        for (int i = 0; i < 4; ++i) {
            accum *= fX[i];
            accum *= fY[i];
            accum *= fW[i];
        }
        SkASSERT(0 == accum || SkIsNaN(accum));
 
        return accum == 0.0f;
    }

iw()

float GrQuad::iw ( int  i ) const

inline

Definition at line 111 of file GrQuad.h.

{ return sk_ieee_float_divide(1.f, fW[i]); }

iw4f()

skvx::Vec< 4, float > GrQuad::iw4f ( ) const

inline

Definition at line 116 of file GrQuad.h.

{ return 1.f / this->w4f(); }

MakeFromRect()

GrQuad GrQuad::MakeFromRect ( const SkRect &  rect, const SkMatrix &  m  )

static

Definition at line 107 of file GrQuad.cpp.

                                                                 {
    V4f x, y, w;
    SkMatrix::TypeMask tm = m.getType();
    Type type;
    if (tm <= (SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask)) {
        map_rect_translate_scale(rect, m, &x, &y);
        w = 1.f;
        type = Type::kAxisAligned;
    } else {
        map_rect_general(rect, m, &x, &y, &w);
        type = quad_type_for_transformed_rect(m);
    }
    return GrQuad(x, y, w, type);
}

MakeFromSkQuad()

GrQuad GrQuad::MakeFromSkQuad ( const SkPoint  pts[4], const SkMatrix &  matrix  )

static

Definition at line 122 of file GrQuad.cpp.

                                                                          {
    V4f xs, ys;
    rearrange_sk_to_gr_points(pts, &xs, &ys);
    Type type = quad_type_for_points(pts, matrix);
    if (matrix.isIdentity()) {
        return GrQuad(xs, ys, 1.f, type);
    } else {
        V4f mx, my, mw;
        map_quad_general(xs, ys, matrix, &mx, &my, &mw);
        return GrQuad(mx, my, mw, type);
    }
}

operator=()

GrQuad & GrQuad::operator= ( const GrQuad &  )

default

point()

SkPoint GrQuad::point ( int  i ) const

inline

Definition at line 69 of file GrQuad.h.

                               {
        if (fType == Type::kPerspective) {
            return {fX[i] / fW[i], fY[i] / fW[i]};
        } else {
            return {fX[i], fY[i]};
        }
    }

point3()

SkPoint3 GrQuad::point3 ( int  i ) const

inline

Definition at line 67 of file GrQuad.h.

{ return {fX[i], fY[i], fW[i]}; }

quadType()

Type GrQuad::quadType ( ) const

inline

Definition at line 118 of file GrQuad.h.

{ return fType; }

setQuadType()

void GrQuad::setQuadType ( Type  newType )

inline

Definition at line 140 of file GrQuad.h.

                                   {
        if (newType != Type::kPerspective && fType == Type::kPerspective) {
            fW[0] = fW[1] = fW[2] = fW[3] = 1.f;
        }
        SkASSERT(newType == Type::kPerspective ||
                 (SkScalarNearlyEqual(fW[0], 1.f) && SkScalarNearlyEqual(fW[1], 1.f) &&
                  SkScalarNearlyEqual(fW[2], 1.f) && SkScalarNearlyEqual(fW[3], 1.f)));
 
        fType = newType;
    }

w()

float GrQuad::w ( int  i ) const

inline

Definition at line 110 of file GrQuad.h.

{ return fW[i]; }

w4f()

skvx::Vec< 4, float > GrQuad::w4f ( ) const

inline

Definition at line 115 of file GrQuad.h.

{ return skvx::Vec<4, float>::Load(fW); }

writeVertex()

void GrQuad::writeVertex ( int  cornerIdx, skgpu::VertexWriter &  w  ) const

inline

Definition at line 77 of file GrQuad.h.

                                                                {
        w << this->point(cornerIdx);
    }

ws() [1/2]

float * GrQuad::ws ( )

inline

Definition at line 137 of file GrQuad.h.

{ return fW; }

ws() [2/2]

const float * GrQuad::ws ( ) const

inline

Definition at line 136 of file GrQuad.h.

{ return fW; }

x()

float GrQuad::x ( int  i ) const

inline

Definition at line 108 of file GrQuad.h.

{ return fX[i]; }

x4f()

skvx::Vec< 4, float > GrQuad::x4f ( ) const

inline

Definition at line 113 of file GrQuad.h.

{ return skvx::Vec<4, float>::Load(fX); }

xs() [1/2]

float * GrQuad::xs ( )

inline

Definition at line 133 of file GrQuad.h.

{ return fX; }

xs() [2/2]

const float * GrQuad::xs ( ) const

inline

Definition at line 132 of file GrQuad.h.

{ return fX; }

y()

float GrQuad::y ( int  i ) const

inline

Definition at line 109 of file GrQuad.h.

{ return fY[i]; }

y4f()

skvx::Vec< 4, float > GrQuad::y4f ( ) const

inline

Definition at line 114 of file GrQuad.h.

{ return skvx::Vec<4, float>::Load(fY); }

ys() [1/2]

float * GrQuad::ys ( )

inline

Definition at line 135 of file GrQuad.h.

{ return fY; }

ys() [2/2]

const float * GrQuad::ys ( ) const

inline

Definition at line 134 of file GrQuad.h.

{ return fY; }

Friends And Related Function Documentation

GrQuadListBase

template<typename T >

friend class GrQuadListBase

friend

Definition at line 152 of file GrQuad.h.

Member Data Documentation

kTypeCount

const int GrQuad::kTypeCount = static_cast<int>(Type::kLast) + 1

static

Definition at line 48 of file GrQuad.h.

---

The documentation for this class was generated from the following files:

• third_party/skia/src/gpu/ganesh/geometry/GrQuad.h
• third_party/skia/src/gpu/ganesh/geometry/GrQuad.cpp
• third_party/skia/src/gpu/ganesh/geometry/GrQuadUtils.cpp