skiagm::ComplexClip2GM Class Reference

Inheritance diagram for skiagm::ComplexClip2GM:

Public Types
enum	Clip { kRect_Clip , kRRect_Clip , kPath_Clip }
Public Types inherited from skiagm::GM
enum	Mode { kGM_Mode , kSample_Mode , kBench_Mode }
using	DrawResult = skiagm::DrawResult
using	GraphiteTestContext = skiatest::graphite::GraphiteTestContext

Public Member Functions
	ComplexClip2GM (Clip clip, bool antiAlias)
Public Member Functions inherited from skiagm::GM
	GM (SkColor backgroundColor=SK_ColorWHITE)
virtual	~GM ()
void	setMode (Mode mode)
Mode	getMode () const
DrawResult	gpuSetup (SkCanvas *, SkString *errorMsg, GraphiteTestContext *=nullptr)
void	gpuTeardown ()
void	onceBeforeDraw ()
DrawResult	draw (SkCanvas *canvas)
DrawResult	draw (SkCanvas *, SkString *errorMsg)
void	drawBackground (SkCanvas *)
DrawResult	drawContent (SkCanvas *canvas)
DrawResult	drawContent (SkCanvas *, SkString *errorMsg)
virtual bool	runAsBench () const
SkScalar	width ()
SkScalar	height ()
SkColor	getBGColor () const
void	setBGColor (SkColor)
void	drawSizeBounds (SkCanvas *, SkColor)
bool	animate (double)
virtual bool	onChar (SkUnichar)
bool	getControls (SkMetaData *controls)
void	setControls (const SkMetaData &controls)
virtual void	modifyGrContextOptions (GrContextOptions *)
virtual void	modifyGraphiteContextOptions (skgpu::graphite::ContextOptions *) const
virtual bool	isBazelOnly () const
virtual std::map< std::string, std::string >	getGoldKeys () const

Protected Member Functions
void	onOnceBeforeDraw () override
SkString	getName () const override
SkISize	getISize () override
void	onDraw (SkCanvas *canvas) override
Protected Member Functions inherited from skiagm::GM
virtual DrawResult	onGpuSetup (SkCanvas *, SkString *, GraphiteTestContext *)
virtual void	onGpuTeardown ()
virtual DrawResult	onDraw (SkCanvas *, SkString *errorMsg)
virtual bool	onAnimate (double)
virtual bool	onGetControls (SkMetaData *)
virtual void	onSetControls (const SkMetaData &)
GraphiteTestContext *	graphiteTestContext () const

Static Protected Member Functions
static const char *	ClipStr (Clip clip)

Static Protected Attributes
static constexpr int	kRows = 5
static constexpr int	kCols = 5
static constexpr int	kPadX = 20
static constexpr int	kPadY = 20

Additional Inherited Members
Static Public Attributes inherited from skiagm::GM
static constexpr char	kErrorMsg_DrawSkippedGpuOnly []

Detailed Description

Definition at line 24 of file complexclip2.cpp.

Member Enumeration Documentation

Clip

enum skiagm::ComplexClip2GM::Clip

Enumerator
kRect_Clip
kRRect_Clip
kPath_Clip

Definition at line 26 of file complexclip2.cpp.

              {
        kRect_Clip,
        kRRect_Clip,
        kPath_Clip
    };

Constructor & Destructor Documentation

ComplexClip2GM()

skiagm::ComplexClip2GM::ComplexClip2GM ( Clip  clip, bool  antiAlias  )

inline

Definition at line 32 of file complexclip2.cpp.

    : fClip(clip)
    , fAntiAlias(antiAlias) {
        SkScalar xA = 0.65f;
        SkScalar xF = 50.65f;
 
        SkScalar yA = 0.65f;
        SkScalar yF = 50.65f;
 
        fWidth = xF - xA;
        fHeight = yF - yA;
 
        fTotalWidth = kCols * fWidth + SK_Scalar1 * (kCols + 1) * kPadX;
        fTotalHeight = kRows * fHeight + SK_Scalar1 * (kRows + 1) * kPadY;
    }

Member Function Documentation

ClipStr()

static const char * skiagm::ComplexClip2GM::ClipStr ( Clip  clip )

inlinestaticprotected

Definition at line 112 of file complexclip2.cpp.

                                          {
        switch (clip) {
        case kRect_Clip:
            return "rect";
        case kRRect_Clip:
            return "rrect";
        case kPath_Clip:
            return "path";
        }
        SkDEBUGFAIL("Unknown clip type.");
        return "";
    }

getISize()

SkISize skiagm::ComplexClip2GM::getISize ( )

inlineoverrideprotectedvirtual

Implements skiagm::GM.

Definition at line 137 of file complexclip2.cpp.

                                {
        return SkISize::Make(SkScalarRoundToInt(fTotalWidth),
                             SkScalarRoundToInt(fTotalHeight));
    }

getName()

SkString skiagm::ComplexClip2GM::getName ( ) const

inlineoverrideprotectedvirtual

Implements skiagm::GM.

Definition at line 125 of file complexclip2.cpp.

                                      {
        if (kRect_Clip == fClip && !fAntiAlias) {
            return SkString("complexclip2");
        }
 
        SkString str;
        str.printf("complexclip2_%s_%s",
                    ClipStr(fClip),
                    fAntiAlias ? "aa" : "bw");
        return str;
    }

onDraw()

void skiagm::ComplexClip2GM::onDraw ( SkCanvas *  canvas )

inlineoverrideprotectedvirtual

Reimplemented from skiagm::GM.

Definition at line 142 of file complexclip2.cpp.

                                           {
        SkPaint rectPaint;
        rectPaint.setStyle(SkPaint::kStroke_Style);
        rectPaint.setStrokeWidth(-1);
 
        SkPaint fillPaint;
        fillPaint.setColor(SkColorSetRGB(0xA0,0xDD,0xA0));
 
        for (int i = 0; i < kRows; ++i) {
            for (int j = 0; j < kCols; ++j) {
                canvas->save();
 
                canvas->translate(kPadX * SK_Scalar1 + (fWidth + kPadX * SK_Scalar1)*j,
                                  kPadY * SK_Scalar1 + (fHeight + kPadY * SK_Scalar1)*i);
 
                // draw the original shapes first so we can see the
                // antialiasing on the clipped draw
                for (int k = 0; k < 5; ++k) {
                    rectPaint.setColor(fRectColors[k]);
                    switch (fClip) {
                        case kRect_Clip:
                            canvas->drawRect(fRects[k], rectPaint);
                            break;
                        case kRRect_Clip:
                            canvas->drawRRect(fRRects[k], rectPaint);
                            break;
                        case kPath_Clip:
                            canvas->drawPath(fPaths[k], rectPaint);
                            break;
                    }
                }
 
                for (int k = 0; k < 5; ++k) {
                    switch (fClip) {
                        case kRect_Clip:
                            canvas->clipRect(fRects[k],
                                             fOps[j*kRows+i][k],
                                             fAntiAlias);
                            break;
                        case kRRect_Clip:
                            canvas->clipRRect(fRRects[k],
                                              fOps[j*kRows+i][k],
                                              fAntiAlias);
                            break;
                        case kPath_Clip:
                            canvas->clipPath(fPaths[k],
                                             fOps[j*kRows+i][k],
                                             fAntiAlias);
                            break;
                    }
                }
                canvas->drawRect(SkRect::MakeWH(fWidth, fHeight), fillPaint);
                canvas->restore();
            }
        }
    }

onOnceBeforeDraw()

void skiagm::ComplexClip2GM::onOnceBeforeDraw ( )

inlineoverrideprotectedvirtual

Reimplemented from skiagm::GM.

Definition at line 49 of file complexclip2.cpp.

                                     {
        this->setBGColor(SkColorSetRGB(0xDD,0xA0,0xDD));
 
        // offset the rects a bit so we get antialiasing even in the rect case
        SkScalar xA = 0.65f;
        SkScalar xB = 10.65f;
        SkScalar xC = 20.65f;
        SkScalar xD = 30.65f;
        SkScalar xE = 40.65f;
        SkScalar xF = 50.65f;
 
        SkScalar yA = 0.65f;
        SkScalar yB = 10.65f;
        SkScalar yC = 20.65f;
        SkScalar yD = 30.65f;
        SkScalar yE = 40.65f;
        SkScalar yF = 50.65f;
 
        fRects[0].setLTRB(xB, yB, xE, yE);
        fRRects[0].setRectXY(fRects[0], 7, 7);
        fPaths[0] = SkPath::RRect(fRects[0], 5, 5);
        fRectColors[0] = SK_ColorRED;
 
        fRects[1].setLTRB(xA, yA, xD, yD);
        fRRects[1].setRectXY(fRects[1], 7, 7);
        fPaths[1] = SkPath::RRect(fRects[1], 5, 5);
        fRectColors[1] = SK_ColorGREEN;
 
        fRects[2].setLTRB(xC, yA, xF, yD);
        fRRects[2].setRectXY(fRects[2], 7, 7);
        fPaths[2] = SkPath::RRect(fRects[2], 5, 5);
        fRectColors[2] = SK_ColorBLUE;
 
        fRects[3].setLTRB(xA, yC, xD, yF);
        fRRects[3].setRectXY(fRects[3], 7, 7);
        fPaths[3] = SkPath::RRect(fRects[3], 5, 5);
        fRectColors[3] = SK_ColorYELLOW;
 
        fRects[4].setLTRB(xC, yC, xF, yF);
        fRRects[4].setRectXY(fRects[4], 7, 7);
        fPaths[4] = SkPath::RRect(fRects[4], 5, 5);
        fRectColors[4] = SK_ColorCYAN;
 
        const SkClipOp ops[] = {
            SkClipOp::kDifference,
            SkClipOp::kIntersect,
        };
 
        SkRandom r;
        for (int i = 0; i < kRows; ++i) {
            for (int j = 0; j < kCols; ++j) {
                for (int k = 0; k < 5; ++k) {
                    fOps[j*kRows+i][k] = ops[r.nextU() % std::size(ops)];
                }
            }
        }
    }

Member Data Documentation

kCols

constexpr int skiagm::ComplexClip2GM::kCols = 5

inlinestaticconstexprprotected

Definition at line 108 of file complexclip2.cpp.

kPadX

constexpr int skiagm::ComplexClip2GM::kPadX = 20

inlinestaticconstexprprotected

Definition at line 109 of file complexclip2.cpp.

kPadY

constexpr int skiagm::ComplexClip2GM::kPadY = 20

inlinestaticconstexprprotected

Definition at line 110 of file complexclip2.cpp.

kRows

constexpr int skiagm::ComplexClip2GM::kRows = 5

inlinestaticconstexprprotected

Definition at line 107 of file complexclip2.cpp.

---

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

• third_party/skia/gm/complexclip2.cpp