Derek Sollenberger | 35934cc | 2016-03-23 14:59:10 -0400 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2016 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | #include "tests/common/TestUtils.h" |
| 18 | |
| 19 | #include <gtest/gtest.h> |
| 20 | #include <RecordingCanvas.h> |
Derek Sollenberger | 792fb32 | 2017-03-03 14:02:09 -0500 | [diff] [blame] | 21 | #include <SkBlurDrawLooper.h> |
Matt Sarett | 44dc270 | 2017-04-13 09:33:18 -0400 | [diff] [blame] | 22 | #include <SkCanvasStateUtils.h> |
Derek Sollenberger | 35934cc | 2016-03-23 14:59:10 -0400 | [diff] [blame] | 23 | #include <SkPicture.h> |
| 24 | #include <SkPictureRecorder.h> |
| 25 | |
| 26 | using namespace android; |
| 27 | using namespace android::uirenderer; |
| 28 | |
| 29 | /** |
| 30 | * Verify that we get the same culling bounds for text for (1) drawing glyphs |
| 31 | * directly to a Canvas or (2) going through a SkPicture as an intermediate step. |
| 32 | */ |
Greg Daniel | 98c78da | 2017-01-04 14:45:56 -0500 | [diff] [blame] | 33 | OPENGL_PIPELINE_TEST(SkiaCanvasProxy, drawGlyphsViaPicture) { |
Derek Sollenberger | 35934cc | 2016-03-23 14:59:10 -0400 | [diff] [blame] | 34 | auto dl = TestUtils::createDisplayList<RecordingCanvas>(200, 200, [](RecordingCanvas& canvas) { |
| 35 | // setup test variables |
| 36 | SkPaint paint; |
| 37 | paint.setAntiAlias(true); |
| 38 | paint.setTextSize(20); |
Derek Sollenberger | 58691b6 | 2016-03-28 16:17:36 -0400 | [diff] [blame] | 39 | paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding); |
Derek Sollenberger | 35934cc | 2016-03-23 14:59:10 -0400 | [diff] [blame] | 40 | static const char* text = "testing text bounds"; |
| 41 | |
| 42 | // draw text directly into Recording canvas |
| 43 | TestUtils::drawUtf8ToCanvas(&canvas, text, paint, 25, 25); |
| 44 | |
| 45 | // record the same text draw into a SkPicture and replay it into a Recording canvas |
| 46 | SkPictureRecorder recorder; |
| 47 | SkCanvas* skCanvas = recorder.beginRecording(200, 200, NULL, 0); |
Derek Sollenberger | fa3e340 | 2017-08-04 08:35:10 -0400 | [diff] [blame] | 48 | std::unique_ptr<Canvas> pictCanvas(Canvas::create_canvas(skCanvas)); |
Derek Sollenberger | 35934cc | 2016-03-23 14:59:10 -0400 | [diff] [blame] | 49 | TestUtils::drawUtf8ToCanvas(pictCanvas.get(), text, paint, 25, 25); |
Derek Sollenberger | 050bb6a | 2016-10-26 12:05:24 -0400 | [diff] [blame] | 50 | sk_sp<SkPicture> picture = recorder.finishRecordingAsPicture(); |
Derek Sollenberger | 35934cc | 2016-03-23 14:59:10 -0400 | [diff] [blame] | 51 | |
| 52 | canvas.asSkCanvas()->drawPicture(picture); |
| 53 | }); |
| 54 | |
| 55 | // verify that the text bounds and matrices match |
| 56 | ASSERT_EQ(2U, dl->getOps().size()); |
| 57 | auto directOp = dl->getOps()[0]; |
| 58 | auto pictureOp = dl->getOps()[1]; |
| 59 | ASSERT_EQ(RecordedOpId::TextOp, directOp->opId); |
| 60 | EXPECT_EQ(directOp->opId, pictureOp->opId); |
| 61 | EXPECT_EQ(directOp->unmappedBounds, pictureOp->unmappedBounds); |
| 62 | EXPECT_EQ(directOp->localMatrix, pictureOp->localMatrix); |
| 63 | } |
Derek Sollenberger | 792fb32 | 2017-03-03 14:02:09 -0500 | [diff] [blame] | 64 | |
| 65 | TEST(SkiaCanvas, drawShadowLayer) { |
| 66 | auto surface = SkSurface::MakeRasterN32Premul(10, 10); |
Derek Sollenberger | fa3e340 | 2017-08-04 08:35:10 -0400 | [diff] [blame] | 67 | SkiaCanvas canvas(surface->getCanvas()); |
Derek Sollenberger | 792fb32 | 2017-03-03 14:02:09 -0500 | [diff] [blame] | 68 | |
| 69 | // clear to white |
| 70 | canvas.drawColor(SK_ColorWHITE, SkBlendMode::kSrc); |
| 71 | |
| 72 | SkPaint paint; |
| 73 | // it is transparent to ensure that we still draw the rect since it has a looper |
| 74 | paint.setColor(SK_ColorTRANSPARENT); |
| 75 | // this is how view's shadow layers are implemented |
| 76 | paint.setLooper(SkBlurDrawLooper::Make(0xF0000000, 6.0f, 0, 10)); |
| 77 | canvas.drawRect(3, 3, 7, 7, paint); |
| 78 | |
| 79 | ASSERT_EQ(TestUtils::getColor(surface, 0, 0), SK_ColorWHITE); |
| 80 | ASSERT_NE(TestUtils::getColor(surface, 5, 5), SK_ColorWHITE); |
| 81 | } |
Matt Sarett | ea70d22 | 2017-03-29 16:25:10 -0400 | [diff] [blame] | 82 | |
| 83 | TEST(SkiaCanvas, colorSpaceXform) { |
| 84 | sk_sp<SkColorSpace> adobe = SkColorSpace::MakeRGB(SkColorSpace::kSRGB_RenderTargetGamma, |
| 85 | SkColorSpace::kAdobeRGB_Gamut); |
| 86 | |
| 87 | SkImageInfo adobeInfo = SkImageInfo::Make(1, 1, kN32_SkColorType, kOpaque_SkAlphaType, adobe); |
| 88 | sk_sp<Bitmap> adobeBitmap = Bitmap::allocateHeapBitmap(adobeInfo); |
| 89 | SkBitmap adobeSkBitmap; |
| 90 | adobeBitmap->getSkBitmap(&adobeSkBitmap); |
Matt Sarett | ea70d22 | 2017-03-29 16:25:10 -0400 | [diff] [blame] | 91 | *adobeSkBitmap.getAddr32(0, 0) = 0xFF0000F0; // Opaque, almost fully-red |
| 92 | |
| 93 | SkImageInfo info = adobeInfo.makeColorSpace(nullptr); |
| 94 | sk_sp<Bitmap> bitmap = Bitmap::allocateHeapBitmap(info); |
| 95 | SkBitmap skBitmap; |
| 96 | bitmap->getSkBitmap(&skBitmap); |
| 97 | |
| 98 | // Create a software canvas. |
| 99 | SkiaCanvas canvas(skBitmap); |
| 100 | canvas.drawBitmap(*adobeBitmap, 0, 0, nullptr); |
| 101 | // The result should be fully red, since we convert to sRGB at draw time. |
Matt Sarett | ea70d22 | 2017-03-29 16:25:10 -0400 | [diff] [blame] | 102 | ASSERT_EQ(0xFF0000FF, *skBitmap.getAddr32(0, 0)); |
| 103 | |
Matt Sarett | ca9b703 | 2017-04-13 12:18:47 -0400 | [diff] [blame] | 104 | // Create a software canvas with an Adobe color space. |
| 105 | SkiaCanvas adobeSkCanvas(adobeSkBitmap); |
| 106 | adobeSkCanvas.drawBitmap(*bitmap, 0, 0, nullptr); |
| 107 | // The result should be less than fully red, since we convert to Adobe RGB at draw time. |
| 108 | ASSERT_EQ(0xFF0000DC, *adobeSkBitmap.getAddr32(0, 0)); |
| 109 | |
Derek Sollenberger | fa3e340 | 2017-08-04 08:35:10 -0400 | [diff] [blame] | 110 | // Test picture recording. |
Matt Sarett | ea70d22 | 2017-03-29 16:25:10 -0400 | [diff] [blame] | 111 | SkPictureRecorder recorder; |
| 112 | SkCanvas* skPicCanvas = recorder.beginRecording(1, 1, NULL, 0); |
Derek Sollenberger | fa3e340 | 2017-08-04 08:35:10 -0400 | [diff] [blame] | 113 | SkiaCanvas picCanvas(skPicCanvas); |
Matt Sarett | ea70d22 | 2017-03-29 16:25:10 -0400 | [diff] [blame] | 114 | picCanvas.drawBitmap(*adobeBitmap, 0, 0, nullptr); |
| 115 | sk_sp<SkPicture> picture = recorder.finishRecordingAsPicture(); |
| 116 | |
Derek Sollenberger | fa3e340 | 2017-08-04 08:35:10 -0400 | [diff] [blame] | 117 | // Playback to an software canvas. The result should be fully red. |
Matt Sarett | ea70d22 | 2017-03-29 16:25:10 -0400 | [diff] [blame] | 118 | canvas.asSkCanvas()->drawPicture(picture); |
| 119 | ASSERT_EQ(0xFF0000FF, *skBitmap.getAddr32(0, 0)); |
| 120 | } |
Matt Sarett | 44dc270 | 2017-04-13 09:33:18 -0400 | [diff] [blame] | 121 | |
| 122 | TEST(SkiaCanvas, captureCanvasState) { |
| 123 | // Create a software canvas. |
| 124 | SkImageInfo info = SkImageInfo::Make(1, 1, kN32_SkColorType, kOpaque_SkAlphaType); |
| 125 | sk_sp<Bitmap> bitmap = Bitmap::allocateHeapBitmap(info); |
| 126 | SkBitmap skBitmap; |
| 127 | bitmap->getSkBitmap(&skBitmap); |
| 128 | skBitmap.eraseColor(0); |
| 129 | SkiaCanvas canvas(skBitmap); |
| 130 | |
| 131 | // Translate, then capture and verify the CanvasState. |
| 132 | canvas.translate(1.0f, 1.0f); |
| 133 | SkCanvasState* state = canvas.captureCanvasState(); |
| 134 | ASSERT_NE(state, nullptr); |
| 135 | std::unique_ptr<SkCanvas> newCanvas = SkCanvasStateUtils::MakeFromCanvasState(state); |
| 136 | ASSERT_NE(newCanvas.get(), nullptr); |
| 137 | newCanvas->translate(-1.0f, -1.0f); |
| 138 | ASSERT_TRUE(newCanvas->getTotalMatrix().isIdentity()); |
| 139 | SkCanvasStateUtils::ReleaseCanvasState(state); |
| 140 | |
| 141 | // Create a picture canvas. |
| 142 | SkPictureRecorder recorder; |
| 143 | SkCanvas* skPicCanvas = recorder.beginRecording(1, 1, NULL, 0); |
Derek Sollenberger | fa3e340 | 2017-08-04 08:35:10 -0400 | [diff] [blame] | 144 | SkiaCanvas picCanvas(skPicCanvas); |
Matt Sarett | 44dc270 | 2017-04-13 09:33:18 -0400 | [diff] [blame] | 145 | state = picCanvas.captureCanvasState(); |
| 146 | |
| 147 | // Verify that we cannot get the CanvasState. |
| 148 | ASSERT_EQ(state, nullptr); |
| 149 | } |