blob: 1c1363096db300a4d7ea3e667d76a16b3bbbedce [file] [log] [blame]
/*
* Copyright 2014 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "include/core/SkBitmap.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkImage.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPaint.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkSamplingOptions.h"
#include "include/core/SkScalar.h"
#include "include/core/SkShader.h"
#include "include/core/SkSurface.h"
#include "include/core/SkTileMode.h"
#include "include/core/SkTypes.h"
#include "include/gpu/GpuTypes.h"
#include "include/gpu/GrDirectContext.h"
#include "tests/CtsEnforcement.h"
#include "tests/Test.h"
#include "tools/Resources.h"
#include <cstring>
class GrRecordingContext;
struct GrContextOptions;
static void test_bitmap_equality(skiatest::Reporter* reporter, SkBitmap& bm1, SkBitmap& bm2) {
REPORTER_ASSERT(reporter, bm1.computeByteSize() == bm2.computeByteSize());
REPORTER_ASSERT(reporter, 0 == memcmp(bm1.getPixels(), bm2.getPixels(), bm1.computeByteSize()));
}
static void paint_source(SkSurface* sourceSurface) {
SkCanvas* sourceCanvas = sourceSurface->getCanvas();
sourceCanvas->clear(0xFFDEDEDE);
SkPaint paintColor;
paintColor.setColor(0xFFFF0000);
paintColor.setStyle(SkPaint::kFill_Style);
SkRect rect = SkRect::MakeXYWH(
SkIntToScalar(1),
SkIntToScalar(0),
SkIntToScalar(1),
SkIntToScalar(sourceSurface->height()));
sourceCanvas->drawRect(rect, paintColor);
}
static void run_shader_test(skiatest::Reporter* reporter, SkSurface* sourceSurface,
SkSurface* destinationSurface, SkImageInfo& info) {
paint_source(sourceSurface);
sk_sp<SkImage> sourceImage(sourceSurface->makeImageSnapshot());
sk_sp<SkShader> sourceShader = sourceImage->makeShader(
SkTileMode::kRepeat, SkTileMode::kRepeat, SkSamplingOptions());
SkPaint paint;
paint.setShader(sourceShader);
SkCanvas* destinationCanvas = destinationSurface->getCanvas();
destinationCanvas->clear(SK_ColorTRANSPARENT);
destinationCanvas->drawPaint(paint);
SkBitmap bmOrig;
bmOrig.allocN32Pixels(info.width(), info.height());
sourceSurface->readPixels(bmOrig, 0, 0);
SkBitmap bm;
bm.allocN32Pixels(info.width(), info.height());
destinationSurface->readPixels(bm, 0, 0);
test_bitmap_equality(reporter, bmOrig, bm);
// Test with a translated shader
SkMatrix matrix;
matrix.setTranslate(SkIntToScalar(-1), SkIntToScalar(0));
sk_sp<SkShader> sourceShaderTranslated = sourceImage->makeShader(
SkTileMode::kRepeat,
SkTileMode::kRepeat,
SkSamplingOptions(), &matrix);
destinationCanvas->clear(SK_ColorTRANSPARENT);
SkPaint paintTranslated;
paintTranslated.setShader(sourceShaderTranslated);
destinationCanvas->drawPaint(paintTranslated);
SkBitmap bmt;
bmt.allocN32Pixels(info.width(), info.height());
destinationSurface->readPixels(bmt, 0, 0);
// Test correctness
{
for (int y = 0; y < info.height(); y++) {
REPORTER_ASSERT(reporter, 0xFFFF0000 == bmt.getColor(0, y));
for (int x = 1; x < info.width(); x++) {
REPORTER_ASSERT(reporter, 0xFFDEDEDE == bmt.getColor(x, y));
}
}
}
}
DEF_TEST(ImageNewShader, reporter) {
SkImageInfo info = SkImageInfo::MakeN32Premul(5, 5);
auto sourceSurface(SkSurface::MakeRaster(info));
auto destinationSurface(SkSurface::MakeRaster(info));
run_shader_test(reporter, sourceSurface.get(), destinationSurface.get(), info);
}
static void gpu_to_gpu(skiatest::Reporter* reporter, GrRecordingContext* rContext) {
SkImageInfo info = SkImageInfo::MakeN32Premul(5, 5);
auto sourceSurface(SkSurface::MakeRenderTarget(rContext, skgpu::Budgeted::kNo, info));
auto destinationSurface(SkSurface::MakeRenderTarget(rContext, skgpu::Budgeted::kNo, info));
run_shader_test(reporter, sourceSurface.get(), destinationSurface.get(), info);
}
static void raster_to_gpu(skiatest::Reporter* reporter, GrRecordingContext* rContext) {
SkImageInfo info = SkImageInfo::MakeN32Premul(5, 5);
auto sourceSurface(SkSurface::MakeRaster(info));
auto destinationSurface(SkSurface::MakeRenderTarget(rContext, skgpu::Budgeted::kNo, info));
run_shader_test(reporter, sourceSurface.get(), destinationSurface.get(), info);
}
DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(ImageNewShader_GPU,
reporter,
ctxInfo,
CtsEnforcement::kApiLevel_T) {
auto dContext = ctxInfo.directContext();
// GPU -> GPU
gpu_to_gpu(reporter, dContext);
// GPU -> RASTER not currently supported
// RASTER -> GPU
raster_to_gpu(reporter, dContext);
}
DEF_TEST(ImageRawShader, reporter) {
auto image = GetResourceAsImage("images/mandrill_32.png");
REPORTER_ASSERT(reporter, image);
// We should be able to turn this into a "raw" image shader:
REPORTER_ASSERT(reporter, image->makeRawShader(SkSamplingOptions{}));
// ... but not if we request cubic filtering
REPORTER_ASSERT(reporter,
!image->makeRawShader(SkSamplingOptions{SkCubicResampler::Mitchell()}));
}