skiagm::ColorProcessor Class Reference

Inheritance diagram for skiagm::ColorProcessor:

Public Types
enum class	TestMode { kConstColor , kModulateRGBA }

Public Member Functions
	ColorProcessor (TestMode mode)

Protected Member Functions
SkString	getName () const override
SkISize	getISize () override
void	onOnceBeforeDraw () override
DrawResult	onDraw (GrRecordingContext *rContext, SkCanvas *canvas, SkString *errorMsg) override

Detailed Description

This GM directly exercises Color and ModulateRGBA.

Definition at line 50 of file constcolorprocessor.cpp.

Member Enumeration Documentation

TestMode

enum class skiagm::ColorProcessor::TestMode

strong

Enumerator
kConstColor
kModulateRGBA

Definition at line 52 of file constcolorprocessor.cpp.

                        {
        kConstColor,
        kModulateRGBA
    };

Constructor & Destructor Documentation

ColorProcessor()

skiagm::ColorProcessor::ColorProcessor ( TestMode  mode )

inline

Definition at line 57 of file constcolorprocessor.cpp.

                                  : fMode(mode) {
        this->setBGColor(0xFFDDDDDD);
    }

Member Function Documentation

getISize()

SkISize skiagm::ColorProcessor::getISize ( )

inlineoverrideprotected

Definition at line 70 of file constcolorprocessor.cpp.

{ return SkISize::Make(kWidth, kHeight); }

getName()

SkString skiagm::ColorProcessor::getName ( ) const

inlineoverrideprotected

Definition at line 62 of file constcolorprocessor.cpp.

                                      {
        switch (fMode) {
            case TestMode::kConstColor:    return SkString("const_color_processor");
            case TestMode::kModulateRGBA:  return SkString("modulate_rgba");
        }
        SkUNREACHABLE;
    }

onDraw()

DrawResult skiagm::ColorProcessor::onDraw ( GrRecordingContext *  rContext, SkCanvas *  canvas, SkString *  errorMsg  )

inlineoverrideprotected

Definition at line 79 of file constcolorprocessor.cpp.

                                                                                                   {
        auto sdc = skgpu::ganesh::TopDeviceSurfaceDrawContext(canvas);
        if (!sdc) {
            *errorMsg = kErrorMsg_DrawSkippedGpuOnly;
            return DrawResult::kSkip;
        }
 
        constexpr GrColor kColors[] = {
            0xFFFFFFFF,
            0xFFFF00FF,
            0x80000000,
            0x00000000,
        };
 
        constexpr GrColor kPaintColors[] = {
            0xFFFFFFFF,
            0xFF0000FF,
            0x80000080,
            0x00000000,
        };
 
        SkScalar y = kPad;
        SkScalar x = kPad;
        SkScalar maxW = 0;
        for (size_t paintType = 0; paintType < std::size(kPaintColors) + 1; ++paintType) {
            for (size_t procColor = 0; procColor < std::size(kColors); ++procColor) {
                // translate by x,y for the canvas draws and the test target draws.
                canvas->save();
                canvas->translate(x, y);
 
                // rect to draw
                SkRect renderRect = SkRect::MakeXYWH(0, 0, kRectSize, kRectSize);
 
                // Create a base-layer FP for the const color processor to draw on top of.
                std::unique_ptr<GrFragmentProcessor> baseFP;
                if (paintType >= std::size(kPaintColors)) {
                    GrColorInfo colorInfo;
                    SkSurfaceProps props;
                    GrFPArgs args(rContext, &colorInfo, props, GrFPArgs::Scope::kDefault);
                    baseFP = GrFragmentProcessors::Make(fShader.get(), args, SkMatrix::I());
                } else {
                    baseFP = GrFragmentProcessor::MakeColor(
                            SkPMColor4f::FromBytes_RGBA(kPaintColors[paintType]));
                }
 
                // Layer a color/modulation FP on top of the base layer, using various colors.
                std::unique_ptr<GrFragmentProcessor> colorFP;
                switch (fMode) {
                    case TestMode::kConstColor:
                        colorFP = GrFragmentProcessor::MakeColor(
                                SkPMColor4f::FromBytes_RGBA(kColors[procColor]));
                        break;
 
                    case TestMode::kModulateRGBA:
                        colorFP = GrFragmentProcessor::ModulateRGBA(
                                std::move(baseFP), SkPMColor4f::FromBytes_RGBA(kColors[procColor]));
                        break;
                }
 
                // Render the FP tree.
                if (auto op = sk_gpu_test::test_ops::MakeRect(rContext,
                                                              std::move(colorFP),
                                                              renderRect.makeOffset(x, y),
                                                              renderRect,
                                                              SkMatrix::I())) {
                    sdc->addDrawOp(std::move(op));
                }
 
                // Draw labels for the input to the processor and the processor to the right of
                // the test rect. The input label appears above the processor label.
                SkFont labelFont;
                labelFont.setTypeface(ToolUtils::DefaultPortableTypeface());
                labelFont.setEdging(SkFont::Edging::kAntiAlias);
                labelFont.setSize(10.f);
                SkPaint labelPaint;
                labelPaint.setAntiAlias(true);
                SkString inputLabel("Input: ");
                if (paintType >= std::size(kPaintColors)) {
                    inputLabel.append("gradient");
                } else {
                    inputLabel.appendf("0x%08x", kPaintColors[paintType]);
                }
                SkString procLabel;
                procLabel.printf("Proc: [0x%08x]", kColors[procColor]);
 
                SkRect inputLabelBounds;
                // get the bounds of the text in order to position it
                labelFont.measureText(inputLabel.c_str(), inputLabel.size(),
                                      SkTextEncoding::kUTF8, &inputLabelBounds);
                canvas->drawString(inputLabel, renderRect.fRight + kPad, -inputLabelBounds.fTop,
                                   labelFont, labelPaint);
                // update the bounds to reflect the offset we used to draw it.
                inputLabelBounds.offset(renderRect.fRight + kPad, -inputLabelBounds.fTop);
 
                SkRect procLabelBounds;
                labelFont.measureText(procLabel.c_str(), procLabel.size(),
                                      SkTextEncoding::kUTF8, &procLabelBounds);
                canvas->drawString(procLabel, renderRect.fRight + kPad,
                                   inputLabelBounds.fBottom + 2.f - procLabelBounds.fTop,
                                   labelFont, labelPaint);
                procLabelBounds.offset(renderRect.fRight + kPad,
                                       inputLabelBounds.fBottom + 2.f - procLabelBounds.fTop);
 
                labelPaint.setStrokeWidth(0);
                labelPaint.setStyle(SkPaint::kStroke_Style);
                canvas->drawRect(renderRect, labelPaint);
 
                canvas->restore();
 
                // update x and y for the next test case.
                SkScalar height = renderRect.height();
                SkScalar width = std::max(inputLabelBounds.fRight, procLabelBounds.fRight);
                maxW = std::max(maxW, width);
                y += height + kPad;
                if (y + height > kHeight) {
                    y = kPad;
                    x += maxW + kPad;
                    maxW = 0;
                }
            }
        }
 
        return DrawResult::kOk;
    }

onOnceBeforeDraw()

void skiagm::ColorProcessor::onOnceBeforeDraw ( )

inlineoverrideprotected

Definition at line 72 of file constcolorprocessor.cpp.

                                     {
        SkColor colors[] = { 0xFFFF0000, 0x2000FF00, 0xFF0000FF};
        SkPoint pts[] = { SkPoint::Make(0, 0), SkPoint::Make(kRectSize, kRectSize) };
        fShader = SkGradientShader::MakeLinear(pts, colors, nullptr, std::size(colors),
                                               SkTileMode::kClamp);
    }

---

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

• third_party/skia/gm/constcolorprocessor.cpp