AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
e202bd8b71
skia2/tests/GradientTest.cpp

367 lines
14 KiB
C++
Raw Blame History

/*
* Copyright 2011 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkCanvas.h"
#include "SkColorPriv.h"
#include "SkColorShader.h"
#include "SkGradientShader.h"
#include "SkShader.h"
#include "SkSurface.h"
#include "SkTemplates.h"
#include "Test.h"
// https://code.google.com/p/chromium/issues/detail?id=448299
// Giant (inverse) matrix causes overflow when converting/computing using 32.32
// Before the fix, we would assert (and then crash).
static void test_big_grad(skiatest::Reporter* reporter) {
const SkColor colors[] = { SK_ColorRED, SK_ColorBLUE };
const SkPoint pts[] = {{ 15, 14.7112684f }, { 0.709064007f, 12.6108112f }};
SkPaint paint;
paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2,
SkShader::kClamp_TileMode));
SkBitmap bm;
bm.allocN32Pixels(2000, 1);
SkCanvas c(bm);
const SkScalar affine[] = {
1.06608627e-06f, 4.26434525e-07f, 6.2855f, 2.6611f, 273.4393f, 244.0046f
};
SkMatrix matrix;
matrix.setAffine(affine);
c.concat(matrix);
c.drawPaint(paint);
}
struct GradRec {
int fColorCount;
const SkColor* fColors;
const SkScalar* fPos;
const SkPoint* fPoint; // 2
const SkScalar* fRadius; // 2
SkShader::TileMode fTileMode;
void gradCheck(skiatest::Reporter* reporter, const sk_sp<SkShader>& shader,
SkShader::GradientInfo* info,
SkShader::GradientType gt) const {
SkAutoTMalloc<SkColor> colorStorage(fColorCount);
SkAutoTMalloc<SkScalar> posStorage(fColorCount);
info->fColorCount = fColorCount;
info->fColors = colorStorage;
info->fColorOffsets = posStorage.get();
REPORTER_ASSERT(reporter, shader->asAGradient(info) == gt);
REPORTER_ASSERT(reporter, info->fColorCount == fColorCount);
REPORTER_ASSERT(reporter,
!memcmp(info->fColors, fColors, fColorCount * sizeof(SkColor)));
REPORTER_ASSERT(reporter,
!memcmp(info->fColorOffsets, fPos, fColorCount * sizeof(SkScalar)));
REPORTER_ASSERT(reporter, fTileMode == info->fTileMode);
}
};
static void none_gradproc(skiatest::Reporter* reporter, const GradRec&, const GradRec&) {
sk_sp<SkShader> s(SkShader::MakeEmptyShader());
REPORTER_ASSERT(reporter, SkShader::kNone_GradientType == s->asAGradient(nullptr));
}
static void color_gradproc(skiatest::Reporter* reporter, const GradRec& rec, const GradRec&) {
SkAutoTUnref<SkShader> s(new SkColorShader(rec.fColors[0]));
REPORTER_ASSERT(reporter, SkShader::kColor_GradientType == s->asAGradient(nullptr));
SkShader::GradientInfo info;
info.fColors = nullptr;
info.fColorCount = 0;
s->asAGradient(&info);
REPORTER_ASSERT(reporter, 1 == info.fColorCount);
}
static void linear_gradproc(skiatest::Reporter* reporter, const GradRec& buildRec,
const GradRec& checkRec) {
sk_sp<SkShader> s(SkGradientShader::MakeLinear(buildRec.fPoint, buildRec.fColors, buildRec.fPos,
buildRec.fColorCount, buildRec.fTileMode));
SkShader::GradientInfo info;
checkRec.gradCheck(reporter, s, &info, SkShader::kLinear_GradientType);
REPORTER_ASSERT(reporter, !memcmp(info.fPoint, checkRec.fPoint, 2 * sizeof(SkPoint)));
}
static void radial_gradproc(skiatest::Reporter* reporter, const GradRec& buildRec,
const GradRec& checkRec) {
sk_sp<SkShader> s(SkGradientShader::MakeRadial(buildRec.fPoint[0], buildRec.fRadius[0],
buildRec.fColors, buildRec.fPos,
buildRec.fColorCount, buildRec.fTileMode));
SkShader::GradientInfo info;
checkRec.gradCheck(reporter, s, &info, SkShader::kRadial_GradientType);
REPORTER_ASSERT(reporter, info.fPoint[0] == checkRec.fPoint[0]);
REPORTER_ASSERT(reporter, info.fRadius[0] == checkRec.fRadius[0]);
}
static void sweep_gradproc(skiatest::Reporter* reporter, const GradRec& buildRec,
const GradRec& checkRec) {
sk_sp<SkShader> s(SkGradientShader::MakeSweep(buildRec.fPoint[0].fX, buildRec.fPoint[0].fY,
buildRec.fColors, buildRec.fPos,
buildRec.fColorCount));
SkShader::GradientInfo info;
checkRec.gradCheck(reporter, s, &info, SkShader::kSweep_GradientType);
REPORTER_ASSERT(reporter, info.fPoint[0] == checkRec.fPoint[0]);
}
static void conical_gradproc(skiatest::Reporter* reporter, const GradRec& buildRec,
const GradRec& checkRec) {
sk_sp<SkShader> s(SkGradientShader::MakeTwoPointConical(buildRec.fPoint[0],
buildRec.fRadius[0],
buildRec.fPoint[1],
buildRec.fRadius[1],
buildRec.fColors,
buildRec.fPos,
buildRec.fColorCount,
buildRec.fTileMode));
SkShader::GradientInfo info;
checkRec.gradCheck(reporter, s, &info, SkShader::kConical_GradientType);
REPORTER_ASSERT(reporter, !memcmp(info.fPoint, checkRec.fPoint, 2 * sizeof(SkPoint)));
REPORTER_ASSERT(reporter, !memcmp(info.fRadius, checkRec.fRadius, 2 * sizeof(SkScalar)));
}
// Ensure that repeated color gradients behave like drawing a single color
static void TestConstantGradient(skiatest::Reporter*) {
const SkPoint pts[] = {
{ 0, 0 },
{ SkIntToScalar(10), 0 }
};
SkColor colors[] = { SK_ColorBLUE, SK_ColorBLUE };
const SkScalar pos[] = { 0, SK_Scalar1 };
SkPaint paint;
paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 2, SkShader::kClamp_TileMode));
SkBitmap outBitmap;
outBitmap.allocN32Pixels(10, 1);
SkCanvas canvas(outBitmap);
canvas.drawPaint(paint);
SkAutoLockPixels alp(outBitmap);
for (int i = 0; i < 10; i++) {
// The following is commented out because it currently fails
// Related bug: https://code.google.com/p/skia/issues/detail?id=1098
// REPORTER_ASSERT(reporter, SK_ColorBLUE == outBitmap.getColor(i, 0));
}
}
typedef void (*GradProc)(skiatest::Reporter* reporter, const GradRec&, const GradRec&);
static void TestGradientShaders(skiatest::Reporter* reporter) {
static const SkColor gColors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE };
static const SkScalar gPos[] = { 0, SK_ScalarHalf, SK_Scalar1 };
static const SkPoint gPts[] = {
{ 0, 0 },
{ SkIntToScalar(10), SkIntToScalar(20) }
};
static const SkScalar gRad[] = { SkIntToScalar(1), SkIntToScalar(2) };
GradRec rec;
rec.fColorCount = SK_ARRAY_COUNT(gColors);
rec.fColors = gColors;
rec.fPos = gPos;
rec.fPoint = gPts;
rec.fRadius = gRad;
rec.fTileMode = SkShader::kClamp_TileMode;
static const GradProc gProcs[] = {
none_gradproc,
color_gradproc,
linear_gradproc,
radial_gradproc,
sweep_gradproc,
conical_gradproc,
};
for (size_t i = 0; i < SK_ARRAY_COUNT(gProcs); ++i) {
gProcs[i](reporter, rec, rec);
}
}
static void TestGradientOptimization(skiatest::Reporter* reporter) {
static const struct {
GradProc fProc;
bool fIsClampRestricted;
} gProcInfo[] = {
{ linear_gradproc , false },
{ radial_gradproc , false },
{ sweep_gradproc , true }, // sweep is funky in that it always pretends to be kClamp.
{ conical_gradproc, false },
};
static const SkColor gC_00[] = { 0xff000000, 0xff000000 };
static const SkColor gC_01[] = { 0xff000000, 0xffffffff };
static const SkColor gC_11[] = { 0xffffffff, 0xffffffff };
static const SkColor gC_001[] = { 0xff000000, 0xff000000, 0xffffffff };
static const SkColor gC_011[] = { 0xff000000, 0xffffffff, 0xffffffff };
static const SkColor gC_0011[] = { 0xff000000, 0xff000000, 0xffffffff, 0xffffffff };
static const SkScalar gP_01[] = { 0, 1 };
static const SkScalar gP_001[] = { 0, 0, 1 };
static const SkScalar gP_011[] = { 0, 1, 1 };
static const SkScalar gP_0x1[] = { 0, .5f, 1 };
static const SkScalar gP_0011[] = { 0, 0, 1, 1 };
static const SkPoint gPts[] = { {0, 0}, {1, 1} };
static const SkScalar gRadii[] = { 1, 2 };
static const struct {
const SkColor* fCol;
const SkScalar* fPos;
int fCount;
const SkColor* fExpectedCol;
const SkScalar* fExpectedPos;
int fExpectedCount;
bool fRequiresNonClamp;
} gTests[] = {
{ gC_001, gP_001, 3, gC_01, gP_01, 2, false },
{ gC_001, gP_011, 3, gC_00, gP_01, 2, true },
{ gC_001, gP_0x1, 3, gC_001, gP_0x1, 3, false },
{ gC_001, nullptr, 3, gC_001, gP_0x1, 3, false },
{ gC_011, gP_001, 3, gC_11, gP_01, 2, true },
{ gC_011, gP_011, 3, gC_01, gP_01, 2, false },
{ gC_011, gP_0x1, 3, gC_011, gP_0x1, 3, false },
{ gC_011, nullptr, 3, gC_011, gP_0x1, 3, false },
{ gC_0011, gP_0011, 4, gC_0011, gP_0011, 4, false },
};
for (size_t i = 0; i < SK_ARRAY_COUNT(gProcInfo); ++i) {
for (int mode = 0; mode < SkShader::kTileModeCount; ++mode) {
if (gProcInfo[i].fIsClampRestricted && mode != SkShader::kClamp_TileMode) {
continue;
}
for (size_t t = 0; t < SK_ARRAY_COUNT(gTests); ++t) {
GradRec rec;
rec.fColorCount = gTests[t].fCount;
rec.fColors = gTests[t].fCol;
rec.fPos = gTests[t].fPos;
rec.fTileMode = static_cast<SkShader::TileMode>(mode);
rec.fPoint = gPts;
rec.fRadius = gRadii;
GradRec expected = rec;
if (!gTests[t].fRequiresNonClamp || mode != SkShader::kClamp_TileMode) {
expected.fColorCount = gTests[t].fExpectedCount;
expected.fColors = gTests[t].fExpectedCol;
expected.fPos = gTests[t].fExpectedPos;
}
gProcInfo[i].fProc(reporter, rec, expected);
}
}
}
}
static void test_nearly_vertical(skiatest::Reporter* reporter) {
auto surface(SkSurface::MakeRasterN32Premul(200, 200));
const SkPoint pts[] = {{ 100, 50 }, { 100.0001f, 50000 }};
const SkColor colors[] = { SK_ColorBLACK, SK_ColorWHITE };
const SkScalar pos[] = { 0, 1 };
SkPaint paint;
paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 2, SkShader::kClamp_TileMode));
surface->getCanvas()->drawPaint(paint);
}
// A linear gradient interval can, due to numerical imprecision (likely in the divide)
// finish an interval with the final fx not landing outside of [p0...p1].
// The old code had an assert which this test triggered.
// We now explicitly clamp the resulting fx value.
static void test_linear_fuzz(skiatest::Reporter* reporter) {
auto surface(SkSurface::MakeRasterN32Premul(1300, 630));
const SkPoint pts[] = {{ 179.5f, -179.5f }, { 1074.5f, 715.5f }};
const SkColor colors[] = { SK_ColorBLACK, SK_ColorWHITE, SK_ColorBLACK, SK_ColorWHITE };
const SkScalar pos[] = {0, 0.200000003f, 0.800000012f, 1 };
SkPaint paint;
paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 4, SkShader::kClamp_TileMode));
SkRect r = {0, 83, 1254, 620};
surface->getCanvas()->drawRect(r, paint);
}
// https://bugs.chromium.org/p/skia/issues/detail?id=5023
// We should still shade pixels for which the radius is exactly 0.
static void test_two_point_conical_zero_radius(skiatest::Reporter* reporter) {
auto surface(SkSurface::MakeRasterN32Premul(5, 5));
surface->getCanvas()->clear(SK_ColorRED);
const SkColor colors[] = { SK_ColorGREEN, SK_ColorBLUE };
SkPaint p;
p.setShader(SkGradientShader::MakeTwoPointConical(
SkPoint::Make(2.5f, 2.5f), 0,
SkPoint::Make(3.0f, 3.0f), 10,
colors, nullptr, SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode));
surface->getCanvas()->drawPaint(p);
// r == 0 for the center pixel.
// verify that we draw it (no red bleed)
SkPMColor centerPMColor;
surface->readPixels(SkImageInfo::MakeN32Premul(1, 1), &centerPMColor, sizeof(SkPMColor), 2, 2);
REPORTER_ASSERT(reporter, SkGetPackedR32(centerPMColor) == 0);
}
// http://crbug.com/599458
static void test_clamping_overflow(skiatest::Reporter*) {
SkPaint p;
const SkColor colors[] = { SK_ColorRED, SK_ColorGREEN };
const SkPoint pts1[] = { SkPoint::Make(1001, 1000001), SkPoint::Make(1000.99f, 1000000) };
p.setShader(SkGradientShader::MakeLinear(pts1, colors, nullptr, 2, SkShader::kClamp_TileMode));
sk_sp<SkSurface> surface(SkSurface::MakeRasterN32Premul(50, 50));
surface->getCanvas()->scale(100, 100);
surface->getCanvas()->drawPaint(p);
const SkPoint pts2[] = { SkPoint::Make(10000.99f, 1000000), SkPoint::Make(10001, 1000001) };
p.setShader(SkGradientShader::MakeLinear(pts2, colors, nullptr, 2, SkShader::kClamp_TileMode));
surface->getCanvas()->drawPaint(p);
// Passes if we don't trigger asserts.
}
// http://crbug.com/636194
static void text_degenerate_linear(skiatest::Reporter*) {
SkPaint p;
const SkColor colors[] = { SK_ColorRED, SK_ColorGREEN };
const SkPoint pts[] = {
SkPoint::Make(-46058024627067344430605278824628224.0f, 0),
SkPoint::Make(SK_ScalarMax, 0)
};
p.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode));
sk_sp<SkSurface> surface(SkSurface::MakeRasterN32Premul(50, 50));
surface->getCanvas()->drawPaint(p);
// Passes if we don't trigger asserts.
}
DEF_TEST(Gradient, reporter) {
TestGradientShaders(reporter);
TestGradientOptimization(reporter);
TestConstantGradient(reporter);
test_big_grad(reporter);
test_nearly_vertical(reporter);
test_linear_fuzz(reporter);
test_two_point_conical_zero_radius(reporter);
test_clamping_overflow(reporter);
text_degenerate_linear(reporter);
}
Reference in New Issue View Git Blame Copy Permalink