1 /*
2 * Copyright 2016 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
8 #include "include/core/SkAlphaType.h"
9 #include "include/core/SkBitmap.h"
10 #include "include/core/SkBlendMode.h"
11 #include "include/core/SkBlender.h"
12 #include "include/core/SkCanvas.h"
13 #include "include/core/SkColor.h"
14 #include "include/core/SkColorType.h"
15 #include "include/core/SkData.h"
16 #include "include/core/SkImage.h"
17 #include "include/core/SkImageInfo.h"
18 #include "include/core/SkMatrix.h"
19 #include "include/core/SkPaint.h"
20 #include "include/core/SkPixmap.h"
21 #include "include/core/SkPoint.h"
22 #include "include/core/SkRRect.h"
23 #include "include/core/SkRefCnt.h"
24 #include "include/core/SkSamplingOptions.h"
25 #include "include/core/SkShader.h"
26 #include "include/core/SkSize.h"
27 #include "include/core/SkString.h"
28 #include "include/core/SkSurface.h"
29 #include "include/core/SkTileMode.h"
30 #include "include/effects/SkPerlinNoiseShader.h"
31 #include "include/effects/SkRuntimeEffect.h"
32 #include "include/private/base/SkAssert.h"
33 #include "tests/CtsEnforcement.h"
34 #include "tests/Test.h"
35
36 #include <cmath>
37 #include <vector>
38
39 #if defined(SK_GANESH) || defined(SK_GRAPHITE)
40 #include "include/gpu/GpuTypes.h"
41 #endif
42
43 #if defined(SK_GANESH)
44 #include "include/gpu/ganesh/GrDirectContext.h"
45 #include "include/gpu/ganesh/SkSurfaceGanesh.h"
46 struct GrContextOptions;
47 #endif
48
49 #if defined(SK_GRAPHITE)
50 #include "include/gpu/graphite/Context.h"
51 #include "include/gpu/graphite/Surface.h"
52 #endif
53
check_isaimage(skiatest::Reporter * reporter,SkShader * shader,int expectedW,int expectedH,SkTileMode expectedX,SkTileMode expectedY,const SkMatrix & expectedM)54 static void check_isaimage(skiatest::Reporter* reporter, SkShader* shader,
55 int expectedW, int expectedH,
56 SkTileMode expectedX, SkTileMode expectedY,
57 const SkMatrix& expectedM) {
58 SkTileMode tileModes[2];
59 SkMatrix localM;
60
61 // wack these so we don't get a false positive
62 localM.setScale(9999, -9999);
63 tileModes[0] = tileModes[1] = (SkTileMode)99;
64
65 SkImage* image = shader->isAImage(&localM, tileModes);
66 REPORTER_ASSERT(reporter, image);
67 REPORTER_ASSERT(reporter, image->width() == expectedW);
68 REPORTER_ASSERT(reporter, image->height() == expectedH);
69 REPORTER_ASSERT(reporter, localM == expectedM);
70 REPORTER_ASSERT(reporter, tileModes[0] == expectedX);
71 REPORTER_ASSERT(reporter, tileModes[1] == expectedY);
72 }
73
DEF_TEST(Shader_isAImage,reporter)74 DEF_TEST(Shader_isAImage, reporter) {
75 const int W = 100;
76 const int H = 100;
77 SkBitmap bm;
78 bm.allocN32Pixels(W, H);
79 auto img = bm.asImage();
80 const SkMatrix localM = SkMatrix::Scale(2, 3);
81 const SkTileMode tmx = SkTileMode::kRepeat;
82 const SkTileMode tmy = SkTileMode::kMirror;
83
84 auto shader0 = bm.makeShader(tmx, tmy, SkSamplingOptions(), localM);
85 auto shader1 = bm.asImage()->makeShader(tmx, tmy, SkSamplingOptions(), localM);
86
87 check_isaimage(reporter, shader0.get(), W, H, tmx, tmy, localM);
88 check_isaimage(reporter, shader1.get(), W, H, tmx, tmy, localM);
89 }
90
91 // Make sure things are ok with just a single leg.
DEF_TEST(ComposeShaderSingle,reporter)92 DEF_TEST(ComposeShaderSingle, reporter) {
93 SkBitmap srcBitmap;
94 srcBitmap.allocN32Pixels(10, 10);
95 srcBitmap.eraseColor(SK_ColorRED);
96 SkCanvas canvas(srcBitmap);
97 SkPaint p;
98 p.setShader(SkShaders::Blend(SkBlendMode::kClear,
99 SkShaders::Empty(),
100 SkShaders::MakeFractalNoise(1.0f, 1.0f, 2, 0.0f)));
101 SkRRect rr;
102 SkVector rd[] = {{0, 0}, {0, 0}, {0, 0}, {0, 0}};
103 rr.setRectRadii({0, 0, 0, 0}, rd);
104 canvas.drawRRect(rr, p);
105 }
106
107 // Tests that nested blending will render as expected.
test_nested_blends(skiatest::Reporter * reporter,SkSurface * surface)108 static void test_nested_blends(skiatest::Reporter* reporter, SkSurface* surface) {
109 auto [redEffect, redError] = SkRuntimeEffect::MakeForShader(SkString(R"(
110 half4 main(float2 coord) {
111 return half4(1, 0, 0, 1);
112 }
113 )"));
114
115 auto [greenEffect, greenError] = SkRuntimeEffect::MakeForShader(SkString(R"(
116 half4 main(float2 coord) {
117 return half4(0, 1, 0, 1);
118 }
119 )"));
120
121 auto [blendEffect, blenderError] = SkRuntimeEffect::MakeForBlender(SkString(R"(
122 half4 main(half4 src, half4 dst) {
123 return (src + dst) * 0.5;
124 }
125 )"));
126
127 auto [nestedBlendEffect, nestedBlenderError] = SkRuntimeEffect::MakeForBlender(SkString(R"(
128 uniform blender child_blender;
129 half4 main(half4 src, half4 dst) {
130 return (child_blender.eval(src, dst) + dst) * 0.5;
131 }
132 )"));
133
134 sk_sp<SkShader> redShader = redEffect->makeShader(nullptr, {});
135 sk_sp<SkShader> greenShader = greenEffect->makeShader(nullptr, {});
136 sk_sp<SkBlender> blender = blendEffect->makeBlender(nullptr);
137 std::vector<SkRuntimeEffect::ChildPtr> children = {SkRuntimeEffect::ChildPtr(blender)};
138 sk_sp<SkBlender> nestedBlender = nestedBlendEffect->makeBlender(nullptr, children);
139
140 SkPaint paint;
141 paint.setShader(SkShaders::Blend(nestedBlender, greenShader, redShader));
142 paint.setBlender(blender);
143
144 // Do the drawing.
145 SkCanvas* canvas = surface->getCanvas();
146 canvas->drawPaint(paint);
147
148 // Read pixels.
149 SkBitmap bitmap;
150 SkPixmap pixmap;
151 bitmap.allocPixels(surface->imageInfo());
152 SkAssertResult(bitmap.peekPixels(&pixmap));
153 if (!surface->readPixels(pixmap, 0, 0)) {
154 ERRORF(reporter, "readPixels failed");
155 return;
156 }
157
158 // Check the resulting blended color.
159 // First, in the paint's shader, red and green are averaged in the child blender to get
160 // (0.5, 0.5, 0, 1), which is then averaged with green in the parent blender to get
161 // (0.25, 0.75, 0, 1). Then, in the paint's blender this is averaged with a transparent
162 // background to get (0.125, 0.375, 0, 0.5) and then unpremuled to get (0.25, 0.75, 0, 0.5).
163 constexpr SkColor4f kExpected = {0.25f, 0.75f, 0.0f, 0.5f};
164 constexpr float kTolerance[4] = {0.01f, 0.01f, 0.0f, 0.01f};
165 SkColor4f color = pixmap.getColor4f(0, 0);
166 for (int i = 0; i < 4; ++i) {
167 if (std::abs(color[i] - kExpected[i]) > kTolerance[i]) {
168 ERRORF(reporter,
169 "Wrong color, expected (%.2f %.2f %.2f %.2f), actual (%.2f, %.2f, %.2f, %.2f)",
170 kExpected.fR, kExpected.fG, kExpected.fB, kExpected.fA,
171 color.fR, color.fG, color.fB, color.fA);
172 break;
173 }
174 }
175 }
176
DEF_TEST(ShaderTestNestedBlendsCpu,reporter)177 DEF_TEST(ShaderTestNestedBlendsCpu, reporter) {
178 SkImageInfo ii = SkImageInfo::Make(SkISize::Make(1, 1),
179 SkColorType::kRGBA_8888_SkColorType,
180 SkAlphaType::kPremul_SkAlphaType);
181 sk_sp<SkSurface> surface = SkSurfaces::Raster(ii);
182 test_nested_blends(reporter, surface.get());
183 }
184
185 #if defined(SK_GANESH)
DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(ShaderTestNestedBlendsGanesh,reporter,contextInfo,CtsEnforcement::kApiLevel_V)186 DEF_GANESH_TEST_FOR_RENDERING_CONTEXTS(ShaderTestNestedBlendsGanesh,
187 reporter,
188 contextInfo,
189 CtsEnforcement::kApiLevel_V) {
190 SkImageInfo ii = SkImageInfo::Make(SkISize::Make(1, 1),
191 SkColorType::kRGBA_8888_SkColorType,
192 SkAlphaType::kPremul_SkAlphaType);
193 GrDirectContext* context = contextInfo.directContext();
194 sk_sp<SkSurface> surface = SkSurfaces::RenderTarget(context, skgpu::Budgeted::kYes, ii);
195 test_nested_blends(reporter, surface.get());
196 }
197 #endif
198
199 #if defined(SK_GRAPHITE)
DEF_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS(ShaderTestNestedBlendsGraphite,reporter,context,CtsEnforcement::kApiLevel_V)200 DEF_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS(ShaderTestNestedBlendsGraphite, reporter, context,
201 CtsEnforcement::kApiLevel_V) {
202 using namespace skgpu::graphite;
203
204 SkImageInfo ii = SkImageInfo::Make(SkISize::Make(1, 1),
205 SkColorType::kRGBA_8888_SkColorType,
206 SkAlphaType::kPremul_SkAlphaType);
207 std::unique_ptr<Recorder> recorder = context->makeRecorder();
208 sk_sp<SkSurface> surface = SkSurfaces::RenderTarget(recorder.get(), ii);
209 test_nested_blends(reporter, surface.get());
210 }
211 #endif
212