ImageNewShaderTest.cpp File Reference

#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 "include/gpu/ganesh/SkSurfaceGanesh.h"
#include "tests/CtsEnforcement.h"
#include "tests/Test.h"
#include "tools/DecodeUtils.h"
#include "tools/Resources.h"
#include <cstring>

Go to the source code of this file.

Functions
static void	test_bitmap_equality (skiatest::Reporter *reporter, SkBitmap &bm1, SkBitmap &bm2)
static void	paint_source (SkSurface *sourceSurface)
static void	run_shader_test (skiatest::Reporter *reporter, SkSurface *sourceSurface, SkSurface *destinationSurface, SkImageInfo &info)
	DEF_TEST (ImageNewShader, reporter)
static void	gpu_to_gpu (skiatest::Reporter *reporter, GrRecordingContext *rContext)
static void	raster_to_gpu (skiatest::Reporter *reporter, GrRecordingContext *rContext)
	DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS (ImageNewShader_GPU, reporter, ctxInfo, CtsEnforcement::kApiLevel_T)
	DEF_TEST (ImageRawShader, reporter)

Function Documentation

DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS()

DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS	(	ImageNewShader_GPU	,
		reporter	,
		ctxInfo	,
		CtsEnforcement::kApiLevel_T
	)

Definition at line 143 of file ImageNewShaderTest.cpp.

                                                                  {
    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() [1/2]

DEF_TEST	(	ImageNewShader	,
		reporter
	)

Definition at line 116 of file ImageNewShaderTest.cpp.

                                   {
    SkImageInfo info = SkImageInfo::MakeN32Premul(5, 5);
 
    auto sourceSurface(SkSurfaces::Raster(info));
    auto destinationSurface(SkSurfaces::Raster(info));
 
    run_shader_test(reporter, sourceSurface.get(), destinationSurface.get(), info);
}

DEF_TEST() [2/2]

DEF_TEST	(	ImageRawShader	,
		reporter
	)

Definition at line 158 of file ImageNewShaderTest.cpp.

                                   {
    auto image = ToolUtils::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(SkFilterMode::kNearest));
 
    // ... but not if we request cubic filtering
    REPORTER_ASSERT(reporter, !image->makeRawShader(SkCubicResampler::Mitchell()));
}

gpu_to_gpu()

static void gpu_to_gpu ( skiatest::Reporter *  reporter, GrRecordingContext *  rContext  )

static

Definition at line 125 of file ImageNewShaderTest.cpp.

                                                                                 {
    SkImageInfo info = SkImageInfo::MakeN32Premul(5, 5);
 
    auto sourceSurface(SkSurfaces::RenderTarget(rContext, skgpu::Budgeted::kNo, info));
    auto destinationSurface(SkSurfaces::RenderTarget(rContext, skgpu::Budgeted::kNo, info));
 
    run_shader_test(reporter, sourceSurface.get(), destinationSurface.get(), info);
}

paint_source()

static void paint_source ( SkSurface *  sourceSurface )

static

Definition at line 41 of file ImageNewShaderTest.cpp.

                                                   {
    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);
}

raster_to_gpu()

static void raster_to_gpu ( skiatest::Reporter *  reporter, GrRecordingContext *  rContext  )

static

Definition at line 134 of file ImageNewShaderTest.cpp.

                                                                                    {
    SkImageInfo info = SkImageInfo::MakeN32Premul(5, 5);
 
    auto sourceSurface(SkSurfaces::Raster(info));
    auto destinationSurface(SkSurfaces::RenderTarget(rContext, skgpu::Budgeted::kNo, info));
 
    run_shader_test(reporter, sourceSurface.get(), destinationSurface.get(), info);
}

run_shader_test()

static void run_shader_test ( skiatest::Reporter *  reporter, SkSurface *  sourceSurface, SkSurface *  destinationSurface, SkImageInfo &  info  )

static

Definition at line 58 of file ImageNewShaderTest.cpp.

                                                                              {
    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));
            }
        }
    }
}

test_bitmap_equality()

static void test_bitmap_equality ( skiatest::Reporter *  reporter, SkBitmap &  bm1, SkBitmap &  bm2  )

static

Definition at line 36 of file ImageNewShaderTest.cpp.

                                                                                           {
    REPORTER_ASSERT(reporter, bm1.computeByteSize() == bm2.computeByteSize());
    REPORTER_ASSERT(reporter, 0 == memcmp(bm1.getPixels(), bm2.getPixels(), bm1.computeByteSize()));
}