blob: 4be3330996bad10d77bb063011c14289999af33e [file] [log] [blame]
mtklein767d2732015-07-16 07:01:39 -07001/*
2 * Copyright 2015 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
Mike Kleinc0bd9f92019-04-23 12:05:21 -05008#include "include/core/SkBitmap.h"
9#include "include/core/SkBlendMode.h"
10#include "include/core/SkCanvas.h"
11#include "include/core/SkColor.h"
12#include "include/core/SkColorSpace.h"
13#include "include/core/SkImageInfo.h"
14#include "include/core/SkPaint.h"
15#include "include/core/SkPoint.h"
16#include "include/core/SkRect.h"
17#include "include/core/SkRefCnt.h"
18#include "include/core/SkSurface.h"
19#include "include/core/SkTypes.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050020#include "include/gpu/GrBackendSurface.h"
21#include "include/gpu/GrContext.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050022#include "include/gpu/GrTypes.h"
Ben Wagner9707a7e2019-05-06 17:17:19 -040023#include "include/private/GrTypesPriv.h"
Robert Phillipse19babf2020-04-06 13:57:30 -040024#include "src/gpu/GrCaps.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050025#include "src/gpu/GrContextPriv.h"
26#include "src/gpu/GrResourceProvider.h"
Greg Daniel456f9b52020-03-05 19:14:18 +000027#include "src/gpu/GrTexture.h"
Ben Wagner9707a7e2019-05-06 17:17:19 -040028#include "tests/Test.h"
Mike Kleinc0bd9f92019-04-23 12:05:21 -050029#include "tools/gpu/GrContextFactory.h"
commit-bot@chromium.org7f428a92014-02-25 21:31:03 +000030
Ben Wagner9707a7e2019-05-06 17:17:19 -040031#include <initializer_list>
Ben Wagnere6b04a12018-03-09 14:41:36 -050032#include <vector>
33
mtklein195fe082015-11-17 08:39:01 -080034struct Results { int diffs, diffs_0x00, diffs_0xff, diffs_by_1; };
commit-bot@chromium.org7f428a92014-02-25 21:31:03 +000035
mtklein195fe082015-11-17 08:39:01 -080036static bool acceptable(const Results& r) {
37#if 0
38 SkDebugf("%d diffs, %d at 0x00, %d at 0xff, %d off by 1, all out of 65536\n",
39 r.diffs, r.diffs_0x00, r.diffs_0xff, r.diffs_by_1);
40#endif
41 return r.diffs_by_1 == r.diffs // never off by more than 1
42 && r.diffs_0x00 == 0 // transparent must stay transparent
43 && r.diffs_0xff == 0; // opaque must stay opaque
commit-bot@chromium.org40ac5e52014-02-26 21:40:07 +000044}
45
mtklein195fe082015-11-17 08:39:01 -080046template <typename Fn>
47static Results test(Fn&& multiply) {
48 Results r = { 0,0,0,0 };
49 for (int x = 0; x < 256; x++) {
50 for (int y = 0; y < 256; y++) {
51 int p = multiply(x, y),
52 ideal = (x*y+127)/255;
53 if (p != ideal) {
54 r.diffs++;
55 if (x == 0x00 || y == 0x00) { r.diffs_0x00++; }
56 if (x == 0xff || y == 0xff) { r.diffs_0xff++; }
57 if (SkTAbs(ideal - p) == 1) { r.diffs_by_1++; }
commit-bot@chromium.org7f428a92014-02-25 21:31:03 +000058 }
mtklein195fe082015-11-17 08:39:01 -080059 }}
60 return r;
commit-bot@chromium.org7f428a92014-02-25 21:31:03 +000061}
62
mtklein195fe082015-11-17 08:39:01 -080063DEF_TEST(Blend_byte_multiply, r) {
64 // These are all temptingly close but fundamentally broken.
65 int (*broken[])(int, int) = {
66 [](int x, int y) { return (x*y)>>8; },
67 [](int x, int y) { return (x*y+128)>>8; },
68 [](int x, int y) { y += y>>7; return (x*y)>>8; },
69 };
70 for (auto multiply : broken) { REPORTER_ASSERT(r, !acceptable(test(multiply))); }
commit-bot@chromium.org7f428a92014-02-25 21:31:03 +000071
mtklein195fe082015-11-17 08:39:01 -080072 // These are fine to use, but not perfect.
73 int (*fine[])(int, int) = {
74 [](int x, int y) { return (x*y+x)>>8; },
75 [](int x, int y) { return (x*y+y)>>8; },
76 [](int x, int y) { return (x*y+255)>>8; },
77 [](int x, int y) { y += y>>7; return (x*y+128)>>8; },
78 };
79 for (auto multiply : fine) { REPORTER_ASSERT(r, acceptable(test(multiply))); }
80
81 // These are pefect.
82 int (*perfect[])(int, int) = {
83 [](int x, int y) { return (x*y+127)/255; }, // Duh.
84 [](int x, int y) { int p = (x*y+128); return (p+(p>>8))>>8; },
85 [](int x, int y) { return ((x*y+128)*257)>>16; },
86 };
87 for (auto multiply : perfect) { REPORTER_ASSERT(r, test(multiply).diffs == 0); }
commit-bot@chromium.org7f428a92014-02-25 21:31:03 +000088}
Eric Karl74480882017-04-03 14:49:05 -070089
Eric Karl74480882017-04-03 14:49:05 -070090namespace {
91static sk_sp<SkSurface> create_gpu_surface_backend_texture_as_render_target(
Brian Salomona56a7462020-02-07 14:17:25 -050092 GrContext* context, int sampleCnt, SkISize dimensions, SkColorType colorType,
Brian Salomon4eb38b72019-08-05 12:58:39 -040093 GrSurfaceOrigin origin, sk_sp<GrTexture>* backingSurface) {
Brian Salomon4eb38b72019-08-05 12:58:39 -040094 auto ct = SkColorTypeToGrColorType(colorType);
Brian Salomon4eb38b72019-08-05 12:58:39 -040095 auto format = context->priv().caps()->getDefaultBackendFormat(ct, GrRenderable::kYes);
Eric Karl74480882017-04-03 14:49:05 -070096
Robert Phillips9da87e02019-02-04 13:26:26 -050097 auto resourceProvider = context->priv().resourceProvider();
Robert Phillips6be756b2018-01-16 15:07:54 -050098
Brian Salomona90382f2019-09-17 09:01:56 -040099 *backingSurface =
Brian Salomona56a7462020-02-07 14:17:25 -0500100 resourceProvider->createTexture(dimensions, format, GrRenderable::kYes, sampleCnt,
Brian Salomona90382f2019-09-17 09:01:56 -0400101 GrMipMapped::kNo, SkBudgeted::kNo, GrProtected::kNo);
Robert Phillipsbf25d432017-04-07 10:08:53 -0400102 if (!(*backingSurface)) {
103 return nullptr;
104 }
Eric Karl74480882017-04-03 14:49:05 -0700105
Robert Phillipsb67821d2017-12-13 15:00:45 -0500106 GrBackendTexture backendTex = (*backingSurface)->getBackendTexture();
107
Eric Karl74480882017-04-03 14:49:05 -0700108 sk_sp<SkSurface> surface =
Greg Daniel7ef28f32017-04-20 16:41:55 +0000109 SkSurface::MakeFromBackendTextureAsRenderTarget(context, backendTex, origin,
Greg Danielfaa095e2017-12-19 13:15:02 -0500110 sampleCnt, colorType, nullptr, nullptr);
Greg Daniel7ef28f32017-04-20 16:41:55 +0000111
Eric Karl74480882017-04-03 14:49:05 -0700112 return surface;
113}
114}
115
116// Tests blending to a surface with no texture available.
117DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ES2BlendWithNoTexture, reporter, ctxInfo) {
118 GrContext* context = ctxInfo.grContext();
Brian Salomona56a7462020-02-07 14:17:25 -0500119 static constexpr SkISize kDimensions{10, 10};
Eric Karl74480882017-04-03 14:49:05 -0700120 const SkColorType kColorType = kRGBA_8888_SkColorType;
121
122 // Build our test cases:
123 struct RectAndSamplePoint {
124 SkRect rect;
125 SkIPoint outPoint;
126 SkIPoint inPoint;
127 } allRectsAndPoints[3] = {
128 {SkRect::MakeXYWH(0, 0, 5, 5), SkIPoint::Make(7, 7), SkIPoint::Make(2, 2)},
Eric Karl72e551e2017-04-04 13:42:10 -0700129 {SkRect::MakeXYWH(2, 2, 5, 5), SkIPoint::Make(1, 1), SkIPoint::Make(4, 4)},
Eric Karl74480882017-04-03 14:49:05 -0700130 {SkRect::MakeXYWH(5, 5, 5, 5), SkIPoint::Make(2, 2), SkIPoint::Make(7, 7)},
131 };
132
133 struct TestCase {
Robert Phillipsbf25d432017-04-07 10:08:53 -0400134 RectAndSamplePoint fRectAndPoints;
135 SkRect fClip;
136 int fSampleCnt;
137 GrSurfaceOrigin fOrigin;
Eric Karl74480882017-04-03 14:49:05 -0700138 };
139 std::vector<TestCase> testCases;
140
Robert Phillipsbf25d432017-04-07 10:08:53 -0400141 for (auto origin : { kTopLeft_GrSurfaceOrigin, kBottomLeft_GrSurfaceOrigin}) {
Brian Salomonbdecacf2018-02-02 20:32:49 -0500142 for (int sampleCnt : {1, 4}) {
Robert Phillipsbf25d432017-04-07 10:08:53 -0400143 for (auto rectAndPoints : allRectsAndPoints) {
144 for (auto clip : {SkRect::MakeXYWH(0, 0, 10, 10), SkRect::MakeXYWH(1, 1, 8, 8)}) {
145 testCases.push_back({rectAndPoints, clip, sampleCnt, origin});
146 }
Eric Karl72e551e2017-04-04 13:42:10 -0700147 }
Eric Karl74480882017-04-03 14:49:05 -0700148 }
149 }
150
151 // Run each test case:
152 for (auto testCase : testCases) {
Robert Phillipsbf25d432017-04-07 10:08:53 -0400153 int sampleCnt = testCase.fSampleCnt;
154 SkRect paintRect = testCase.fRectAndPoints.rect;
155 SkIPoint outPoint = testCase.fRectAndPoints.outPoint;
156 SkIPoint inPoint = testCase.fRectAndPoints.inPoint;
157 GrSurfaceOrigin origin = testCase.fOrigin;
Eric Karl74480882017-04-03 14:49:05 -0700158
159 sk_sp<GrTexture> backingSurface;
160 // BGRA forces a framebuffer blit on ES2.
161 sk_sp<SkSurface> surface = create_gpu_surface_backend_texture_as_render_target(
Brian Salomona56a7462020-02-07 14:17:25 -0500162 context, sampleCnt, kDimensions, kColorType, origin, &backingSurface);
Eric Karl74480882017-04-03 14:49:05 -0700163
Brian Salomonbdecacf2018-02-02 20:32:49 -0500164 if (!surface && sampleCnt > 1) {
Eric Karl74480882017-04-03 14:49:05 -0700165 // Some platforms don't support MSAA.
166 continue;
167 }
168 REPORTER_ASSERT(reporter, !!surface);
169
170 // Fill our canvas with 0xFFFF80
171 SkCanvas* canvas = surface->getCanvas();
Robert Phillipsbf25d432017-04-07 10:08:53 -0400172 canvas->clipRect(testCase.fClip, false);
Eric Karl74480882017-04-03 14:49:05 -0700173 SkPaint black_paint;
174 black_paint.setColor(SkColorSetRGB(0xFF, 0xFF, 0x80));
Brian Salomona56a7462020-02-07 14:17:25 -0500175 canvas->drawRect(SkRect::Make(kDimensions), black_paint);
Eric Karl74480882017-04-03 14:49:05 -0700176
177 // Blend 2x2 pixels at 5,5 with 0x80FFFF. Use multiply blend mode as this will trigger
178 // a copy of the destination.
179 SkPaint white_paint;
180 white_paint.setColor(SkColorSetRGB(0x80, 0xFF, 0xFF));
181 white_paint.setBlendMode(SkBlendMode::kMultiply);
182 canvas->drawRect(paintRect, white_paint);
183
184 // Read the result into a bitmap.
185 SkBitmap bitmap;
Brian Salomona56a7462020-02-07 14:17:25 -0500186 REPORTER_ASSERT(reporter, bitmap.tryAllocPixels(SkImageInfo::Make(kDimensions, kColorType,
187 kPremul_SkAlphaType)));
Eric Karl74480882017-04-03 14:49:05 -0700188 REPORTER_ASSERT(
189 reporter,
190 surface->readPixels(bitmap.info(), bitmap.getPixels(), bitmap.rowBytes(), 0, 0));
191
192 // Check the in/out pixels.
193 REPORTER_ASSERT(reporter, bitmap.getColor(outPoint.x(), outPoint.y()) ==
194 SkColorSetRGB(0xFF, 0xFF, 0x80));
195 REPORTER_ASSERT(reporter, bitmap.getColor(inPoint.x(), inPoint.y()) ==
196 SkColorSetRGB(0x80, 0xFF, 0x80));
197
198 // Clean up - surface depends on backingSurface and must be released first.
Eric Karl74480882017-04-03 14:49:05 -0700199 surface.reset();
200 backingSurface.reset();
201 }
202}