skia2/gm/constcolorprocessor.cpp

228 lines
8.8 KiB
C++
Raw Normal View History

/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
// This test only works with the GPU backend.
#include "gm/gm.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkFont.h"
#include "include/core/SkFontTypes.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkScalar.h"
#include "include/core/SkShader.h"
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/core/SkTileMode.h"
#include "include/core/SkTypeface.h"
#include "include/core/SkTypes.h"
#include "include/effects/SkGradientShader.h"
#include "include/gpu/GrConfig.h"
#include "include/private/GrTypesPriv.h"
#include "include/private/SkColorData.h"
#include "src/core/SkCanvasPriv.h"
#include "src/core/SkMatrixProvider.h"
#include "src/gpu/GrColor.h"
#include "src/gpu/GrFragmentProcessor.h"
#include "src/gpu/GrPaint.h"
#include "src/gpu/SkGr.h"
#include "src/gpu/ops/GrOp.h"
#include "src/gpu/v1/SurfaceDrawContext_v1.h"
#include "tools/ToolUtils.h"
#include "tools/gpu/TestOps.h"
#include <utility>
namespace skiagm {
/**
* This GM directly exercises Color, ModulateRGBA and ModulateAlpha.
*/
class ColorProcessor : public GpuGM {
public:
enum class TestMode {
kConstColor,
kModulateRGBA,
kModulateAlpha
};
ColorProcessor(TestMode mode) : fMode(mode) {
this->setBGColor(0xFFDDDDDD);
}
protected:
SkString onShortName() override {
switch (fMode) {
case TestMode::kConstColor: return SkString("const_color_processor");
case TestMode::kModulateRGBA: return SkString("modulate_rgba");
case TestMode::kModulateAlpha: return SkString("modulate_alpha");
}
SkUNREACHABLE;
}
SkISize onISize() override {
return SkISize::Make(kWidth, kHeight);
}
void onOnceBeforeDraw() override {
SkColor colors[] = { 0xFFFF0000, 0x2000FF00, 0xFF0000FF};
SkPoint pts[] = { SkPoint::Make(0, 0), SkPoint::Make(kRectSize, kRectSize) };
fShader = SkGradientShader::MakeLinear(pts, colors, nullptr, SK_ARRAY_COUNT(colors),
SkTileMode::kClamp);
}
DrawResult onDraw(GrRecordingContext* rContext, SkCanvas* canvas, SkString* errorMsg) override {
auto sdc = SkCanvasPriv::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 < SK_ARRAY_COUNT(kPaintColors) + 1; ++paintType) {
for (size_t procColor = 0; procColor < SK_ARRAY_COUNT(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 >= SK_ARRAY_COUNT(kPaintColors)) {
GrColorInfo colorInfo;
GrFPArgs args(rContext, SkSimpleMatrixProvider(SkMatrix::I()), &colorInfo);
baseFP = as_SB(fShader)->asFragmentProcessor(args);
} 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;
case TestMode::kModulateAlpha:
colorFP = GrFragmentProcessor::ModulateAlpha(
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::create_portable_typeface());
labelFont.setEdging(SkFont::Edging::kAntiAlias);
labelFont.setSize(10.f);
SkPaint labelPaint;
labelPaint.setAntiAlias(true);
SkString inputLabel("Input: ");
if (paintType >= SK_ARRAY_COUNT(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;
}
private:
// Use this as a way of generating an input FP
sk_sp<SkShader> fShader;
TestMode fMode;
inline static constexpr SkScalar kPad = 10.f;
inline static constexpr SkScalar kRectSize = 20.f;
inline static constexpr int kWidth = 820;
inline static constexpr int kHeight = 500;
using INHERITED = GM;
};
DEF_GM(return new ColorProcessor{ColorProcessor::TestMode::kConstColor};)
DEF_GM(return new ColorProcessor{ColorProcessor::TestMode::kModulateRGBA};)
DEF_GM(return new ColorProcessor{ColorProcessor::TestMode::kModulateAlpha};)
} // namespace skiagm