AAXfermodesGM Class Reference

Inheritance diagram for AAXfermodesGM:

Public Member Functions
	AAXfermodesGM ()
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 Types
enum	DrawingPass { kCheckerboard_Pass , kBackground_Pass , kShape_Pass }

Protected Member Functions
SkString	getName () const override
SkISize	getISize () override
void	onOnceBeforeDraw () override
void	draw_pass (SkCanvas *canvas, DrawingPass drawingPass)
void	onDraw (SkCanvas *canvas) override
void	drawModeName (SkCanvas *canvas, SkBlendMode mode)
void	setupShapePaint (SkCanvas *canvas, SkColor color, SkBlendMode mode, SkPaint *paint)
void	drawShape (SkCanvas *canvas, Shape shape, const SkPaint &paint, SkBlendMode mode)
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

Additional Inherited Members
Public Types inherited from skiagm::GM
enum	Mode { kGM_Mode , kSample_Mode , kBench_Mode }
using	DrawResult = skiagm::DrawResult
using	GraphiteTestContext = skiatest::graphite::GraphiteTestContext
Static Public Attributes inherited from skiagm::GM
static constexpr char	kErrorMsg_DrawSkippedGpuOnly []

Detailed Description

Verifies AA works properly on all Xfermodes, including arithmetic, with both opaque and unknown src colors.

Definition at line 59 of file aaxfermodes.cpp.

Member Enumeration Documentation

DrawingPass

enum AAXfermodesGM::DrawingPass

protected

Enumerator
kCheckerboard_Pass
kBackground_Pass
kShape_Pass

Definition at line 64 of file aaxfermodes.cpp.

                     {
        kCheckerboard_Pass,
        kBackground_Pass,
        kShape_Pass
    };

Constructor & Destructor Documentation

AAXfermodesGM()

AAXfermodesGM::AAXfermodesGM ( )

inline

Definition at line 61 of file aaxfermodes.cpp.

{}

Member Function Documentation

draw_pass()

void AAXfermodesGM::draw_pass ( SkCanvas *  canvas, DrawingPass  drawingPass  )

inlineprotected

Definition at line 105 of file aaxfermodes.cpp.

                                                              {
        SkRect clipRect =
                { -kShapeSize*11/16, -kShapeSize*11/16, kShapeSize*11/16, kShapeSize*11/16 };
 
        canvas->save();
        if (kCheckerboard_Pass == drawingPass) {
            canvas->translate(kMargin, kMargin);
        }
        canvas->translate(0, kTitleSpacing);
 
        for (size_t xfermodeSet = 0; xfermodeSet < 2; xfermodeSet++) {
            size_t firstMode = ((size_t)SkBlendMode::kLastCoeffMode + 1) * xfermodeSet;
            canvas->save();
 
            if (kShape_Pass == drawingPass) {
                SkTextUtils::DrawString(canvas, "Src Unknown",
                        kLabelSpacing + kShapeTypeSpacing * 1.5f + kShapeSpacing / 2,
                        kSubtitleSpacing / 2 + fLabelFont.getSize() / 3, fLabelFont, SkPaint(),
                                        SkTextUtils::kCenter_Align);
                SkTextUtils::DrawString(canvas, "Src Opaque",
                        kLabelSpacing + kShapeTypeSpacing * 1.5f + kShapeSpacing / 2 +
                        kPaintSpacing, kSubtitleSpacing / 2 + fLabelFont.getSize() / 3,
                                        fLabelFont, SkPaint(), SkTextUtils::kCenter_Align);
            }
 
            canvas->translate(0, kSubtitleSpacing + kShapeSpacing/2);
 
            for (size_t m = 0; m <= (size_t)SkBlendMode::kLastCoeffMode; m++) {
                if (firstMode + m > (size_t)SkBlendMode::kLastMode) {
                    break;
                }
                SkBlendMode mode = static_cast<SkBlendMode>(firstMode + m);
                canvas->save();
 
                if (kShape_Pass == drawingPass) {
                    this->drawModeName(canvas, mode);
                }
                canvas->translate(kLabelSpacing + kShapeSpacing/2, 0);
 
                for (size_t colorIdx = 0; colorIdx < std::size(kShapeColors); colorIdx++) {
                    SkPaint paint;
                    this->setupShapePaint(canvas, kShapeColors[colorIdx], mode, &paint);
                    SkASSERT(colorIdx == 0 || 255 == paint.getAlpha());
                    canvas->save();
 
                    for (size_t shapeIdx = 0; shapeIdx <= kLast_Shape; shapeIdx++) {
                        if (kShape_Pass != drawingPass) {
                            canvas->save();
                            canvas->clipRect(clipRect);
                            if (kCheckerboard_Pass == drawingPass) {
                                ToolUtils::draw_checkerboard(canvas, 0xffffffff, 0xffc6c3c6, 10);
                            } else {
                                SkASSERT(kBackground_Pass == drawingPass);
                                canvas->drawColor(kBGColor, SkBlendMode::kSrc);
                            }
                            canvas->restore();
                        } else {
                            this->drawShape(canvas, static_cast<Shape>(shapeIdx), paint, mode);
                        }
                        canvas->translate(kShapeTypeSpacing, 0);
                    }
 
                    canvas->restore();
                    canvas->translate(kPaintSpacing, 0);
                }
 
                canvas->restore();
                canvas->translate(0, kShapeSpacing);
            }
 
            canvas->restore();
            canvas->translate(kXfermodeTypeSpacing, 0);
        }
 
        canvas->restore();
    }

drawModeName()

void AAXfermodesGM::drawModeName ( SkCanvas *  canvas, SkBlendMode  mode  )

inlineprotected

Definition at line 205 of file aaxfermodes.cpp.

                                                          {
        const char* modeName = SkBlendMode_Name(mode);
        SkTextUtils::DrawString(canvas, modeName, kLabelSpacing - kShapeSize / 4,
                                fLabelFont.getSize() / 4, fLabelFont, SkPaint(),
                                SkTextUtils::kRight_Align);
    }

drawShape()

void AAXfermodesGM::drawShape ( SkCanvas *  canvas, Shape  shape, const SkPaint &  paint, SkBlendMode  mode  )

inlineprotected

Definition at line 241 of file aaxfermodes.cpp.

                                                                                          {
        SkASSERT(mode <= SkBlendMode::kLastMode);
        SkPaint shapePaint(paint);
        shapePaint.setAntiAlias(kSquare_Shape != shape);
        shapePaint.setBlendMode(mode);
 
        switch (shape) {
            case kSquare_Shape:
                canvas->drawRect({ -kShapeSize/2, -kShapeSize/2, kShapeSize/2, kShapeSize/2 },
                                 shapePaint);
                break;
 
            case kDiamond_Shape:
                canvas->save();
                canvas->rotate(45);
                canvas->drawRect({ -kShapeSize/2, -kShapeSize/2, kShapeSize/2, kShapeSize/2 },
                                 shapePaint);
                canvas->restore();
                break;
 
            case kOval_Shape:
                canvas->save();
                canvas->rotate(static_cast<SkScalar>((511 * (int)mode + 257) % 360));
                canvas->drawPath(fOval, shapePaint);
                canvas->restore();
                break;
 
            case kConcave_Shape:
                canvas->drawPath(fConcave, shapePaint);
                break;
 
            default:
                SK_ABORT("Invalid shape.");
        }
    }

getISize()

SkISize AAXfermodesGM::getISize ( )

inlineoverrideprotectedvirtual

Implements skiagm::GM.

Definition at line 72 of file aaxfermodes.cpp.

                                {
        return SkISize::Make(2 * kMargin + 2 * kXfermodeTypeSpacing -
                             (kXfermodeTypeSpacing - (kLabelSpacing + 2 * kPaintSpacing)),
                             2 * kMargin + kTitleSpacing + kSubtitleSpacing +
                             (1 + (int)SkBlendMode::kLastCoeffMode) * kShapeSpacing);
    }

getName()

SkString AAXfermodesGM::getName ( ) const

inlineoverrideprotectedvirtual

Implements skiagm::GM.

Definition at line 70 of file aaxfermodes.cpp.

{ return SkString("aaxfermodes"); }

onDraw()

void AAXfermodesGM::onDraw ( SkCanvas *  canvas )

inlineoverrideprotectedvirtual

Reimplemented from skiagm::GM.

Definition at line 182 of file aaxfermodes.cpp.

                                           {
        draw_pass(canvas, kCheckerboard_Pass);
        canvas->saveLayer(nullptr, nullptr);
 
        canvas->translate(kMargin, kMargin);
        draw_pass(canvas, kBackground_Pass);
 
        SkFont titleFont(fLabelFont);
        titleFont.setSize(9 * titleFont.getSize() / 8);
        titleFont.setEmbolden(true);
        SkTextUtils::DrawString(canvas, "Porter Duff",
                                kLabelSpacing + 4 * kShapeTypeSpacing,
                                kTitleSpacing / 2 + titleFont.getSize() / 3, titleFont, SkPaint(),
                                SkTextUtils::kCenter_Align);
        SkTextUtils::DrawString(canvas, "Advanced",
                                kXfermodeTypeSpacing + kLabelSpacing + 4 * kShapeTypeSpacing,
                                kTitleSpacing / 2 + titleFont.getSize() / 3, titleFont, SkPaint(),
                                SkTextUtils::kCenter_Align);
 
        draw_pass(canvas, kShape_Pass);
        canvas->restore();
    }

onOnceBeforeDraw()

void AAXfermodesGM::onOnceBeforeDraw ( )

inlineoverrideprotectedvirtual

Reimplemented from skiagm::GM.

Definition at line 79 of file aaxfermodes.cpp.

                                     {
        fLabelFont.setTypeface(ToolUtils::DefaultPortableTypeface());
        fLabelFont.setSize(5 * kShapeSize/8);
        fLabelFont.setSubpixel(true);
 
        constexpr SkScalar radius = -1.4f * kShapeSize/2;
        SkPoint pts[4] = {
            {-radius, 0},
            {0, -1.33f * radius},
            {radius, 0},
            {0, 1.33f * radius}
        };
        fOval = SkPathBuilder().moveTo(pts[0])
                               .quadTo(pts[1], pts[2])
                               .quadTo(pts[3], pts[0])
                               .detach();
 
        fConcave = SkPathBuilder().moveTo(-radius, 0)
                                  .quadTo(0, 0, 0, -radius)
                                  .quadTo(0, 0, radius, 0)
                                  .quadTo(0, 0, 0, radius)
                                  .quadTo(0, 0, -radius, 0)
                                  .close()
                                  .detach();
    }

setupShapePaint()

void AAXfermodesGM::setupShapePaint ( SkCanvas *  canvas, SkColor  color, SkBlendMode  mode, SkPaint *  paint  )

inlineprotected

Definition at line 212 of file aaxfermodes.cpp.

                                                                                            {
        paint->setColor(color);
 
        if (mode == SkBlendMode::kPlus) {
            // Check for overflow, otherwise we might get confusing AA artifacts.
            int maxSum = std::max(std::max(SkColorGetA(kBGColor) + SkColorGetA(color),
                                       SkColorGetR(kBGColor) + SkColorGetR(color)),
                                std::max(SkColorGetG(kBGColor) + SkColorGetG(color),
                                       SkColorGetB(kBGColor) + SkColorGetB(color)));
 
            if (maxSum > 255) {
                SkPaint dimPaint;
                dimPaint.setAntiAlias(false);
                dimPaint.setBlendMode(SkBlendMode::kDstIn);
                if (255 != paint->getAlpha()) {
                    // Dim the src and dst colors.
                    dimPaint.setARGB(255 * 255 / maxSum, 0, 0, 0);
                    paint->setAlpha(255 * paint->getAlpha() / maxSum);
                } else {
                    // Just clear the dst, we need to preserve the paint's opacity.
                    dimPaint.setARGB(0, 0, 0, 0);
                }
                canvas->drawRect({ -kShapeSpacing/2, -kShapeSpacing/2,
                                   kShapeSpacing/2 + 3 * kShapeTypeSpacing, kShapeSpacing/2 },
                                 dimPaint);
            }
        }
    }

---

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

• third_party/skia/gm/aaxfermodes.cpp