blob: abb773513818081ed7f9439677c89b05893155b9 [file] [log] [blame]
brianosman2c4b64e2016-09-07 07:04:44 -07001/*
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 "gm.h"
Mike Klein33d20552017-03-22 13:47:51 -04009#include "sk_tool_utils.h"
brianosman2c4b64e2016-09-07 07:04:44 -070010
raftias7c602de2016-10-13 10:45:44 -070011#include "SkColorSpace_Base.h"
brianosman2c4b64e2016-09-07 07:04:44 -070012#include "SkGradientShader.h"
Brian Osman0d4ff6c2017-01-17 16:10:07 -050013#include "SkImagePriv.h"
brianosman2c4b64e2016-09-07 07:04:44 -070014#include "SkPM4fPriv.h"
raftias7c602de2016-10-13 10:45:44 -070015#include "SkSurface.h"
Mike Reed887cdf12017-04-03 11:11:09 -040016#include "SkVertices.h"
brianosman2c4b64e2016-09-07 07:04:44 -070017
18static const int gRectSize = 50;
19static const SkScalar gScalarSize = SkIntToScalar(gRectSize);
20static const int gTestWidth = 700;
21static const int gTestHeight = 300;
22
23struct CellRenderer {
24 virtual void draw(SkCanvas* canvas) = 0;
25 virtual const char* label() = 0;
26 virtual ~CellRenderer() {}
27};
28
29struct PaintColorCellRenderer : public CellRenderer {
30 PaintColorCellRenderer(SkColor color) : fColor(color) {}
31 void draw(SkCanvas* canvas) override {
32 canvas->drawColor(fColor);
33 }
34 const char* label() override {
35 return "Paint Color";
36 }
37protected:
38 SkColor fColor;
39};
40
41struct BitmapCellRenderer : public CellRenderer {
42 BitmapCellRenderer(SkColor color, SkFilterQuality quality, float scale = 1.0f)
43 : fQuality(quality) {
Mike Reed35ee0e02017-08-06 22:29:57 -040044 int scaledSize = sk_float_round2int(scale * gRectSize);
brianosman2c4b64e2016-09-07 07:04:44 -070045 fBitmap.allocPixels(SkImageInfo::MakeS32(scaledSize, scaledSize, kPremul_SkAlphaType));
46 fBitmap.eraseColor(color);
47 const char* qualityNames[] = { "None", "Low", "Medium", "High" };
48 fLabel = SkStringPrintf("Bitmap (%s)", qualityNames[quality]);
49 }
50 void draw(SkCanvas* canvas) override {
51 SkPaint paint;
52 paint.setFilterQuality(fQuality);
53 canvas->drawBitmapRect(fBitmap, SkRect::MakeIWH(gRectSize, gRectSize), &paint);
54 }
55 const char* label() override {
56 return fLabel.c_str();
57 }
58protected:
59 SkFilterQuality fQuality;
60 SkBitmap fBitmap;
61 SkString fLabel;
62};
63
64struct GradientCellRenderer : public CellRenderer {
brianosmand4546092016-09-22 12:31:58 -070065 GradientCellRenderer(SkColor colorOne, SkColor colorTwo, bool manyStops) {
brianosman2c4b64e2016-09-07 07:04:44 -070066 fColors[0] = colorOne;
67 fColors[1] = colorTwo;
brianosmand4546092016-09-22 12:31:58 -070068 fManyStops = manyStops;
brianosman2c4b64e2016-09-07 07:04:44 -070069 }
70 void draw(SkCanvas* canvas) override {
71 SkPoint points[2] = {
72 SkPoint::Make(0, 0),
73 SkPoint::Make(0, gScalarSize)
74 };
75 SkPaint paint;
brianosmand4546092016-09-22 12:31:58 -070076 if (fManyStops) {
77 SkColor colors[4] ={
78 fColors[0], fColors[0], fColors[1], fColors[1]
79 };
80 paint.setShader(SkGradientShader::MakeLinear(points, colors, nullptr, 4,
81 SkShader::kClamp_TileMode));
82 } else {
83 paint.setShader(SkGradientShader::MakeLinear(points, fColors, nullptr, 2,
84 SkShader::kClamp_TileMode));
85 }
brianosman2c4b64e2016-09-07 07:04:44 -070086 canvas->drawPaint(paint);
87 }
88 const char* label() override {
89 return "Linear Gradient";
90 }
91protected:
92 SkColor fColors[2];
brianosmand4546092016-09-22 12:31:58 -070093 bool fManyStops;
brianosman2c4b64e2016-09-07 07:04:44 -070094};
95
96struct VerticesCellRenderer : public CellRenderer {
97 VerticesCellRenderer(SkColor colorOne, SkColor colorTwo) {
98 fColors[0] = fColors[1] = colorOne;
99 fColors[2] = fColors[3] = colorTwo;
100 }
101 void draw(SkCanvas* canvas) override {
102 SkPaint paint;
103 SkPoint vertices[4] = {
104 SkPoint::Make(0, 0),
105 SkPoint::Make(gScalarSize, 0),
106 SkPoint::Make(gScalarSize, gScalarSize),
107 SkPoint::Make(0, gScalarSize)
108 };
Mike Reed887cdf12017-04-03 11:11:09 -0400109 canvas->drawVertices(SkVertices::MakeCopy(SkVertices::kTriangleFan_VertexMode, 4, vertices,
110 nullptr, fColors),
111 SkBlendMode::kModulate, paint);
brianosman2c4b64e2016-09-07 07:04:44 -0700112 }
113 const char* label() override {
114 return "Vertices";
115 }
116protected:
117 SkColor fColors[4];
118};
119
Ben Wagner145dbcd2016-11-03 14:40:50 -0400120static void draw_gamut_grid(SkCanvas* canvas, SkTArray<std::unique_ptr<CellRenderer>>& renderers) {
brianosman2c4b64e2016-09-07 07:04:44 -0700121 // We want our colors in our wide gamut to be obviously visibly distorted from sRGB, so we use
122 // Wide Gamut RGB (with sRGB gamma, for HW acceleration) as the working space for this test:
123 const float gWideGamutRGB_toXYZD50[]{
brianosmande68d6c2016-09-09 10:36:17 -0700124 0.7161046f, 0.1009296f, 0.1471858f, // -> X
125 0.2581874f, 0.7249378f, 0.0168748f, // -> Y
126 0.0000000f, 0.0517813f, 0.7734287f, // -> Z
brianosman2c4b64e2016-09-07 07:04:44 -0700127 };
128
129 SkMatrix44 wideGamutRGB_toXYZD50(SkMatrix44::kUninitialized_Constructor);
130 wideGamutRGB_toXYZD50.set3x3RowMajorf(gWideGamutRGB_toXYZD50);
131
132 // Use the original canvas' color type, but account for gamma requirements
fmalitaed387722016-09-30 06:14:49 -0700133 SkImageInfo origInfo = canvas->imageInfo();
raftias94888332016-10-18 10:02:51 -0700134 sk_sp<SkColorSpace> srgbCS;
135 sk_sp<SkColorSpace> wideCS;
fmalitaed387722016-09-30 06:14:49 -0700136 switch (origInfo.colorType()) {
brianosman2c4b64e2016-09-07 07:04:44 -0700137 case kRGBA_8888_SkColorType:
138 case kBGRA_8888_SkColorType:
Matt Sarett77a7a1b2017-02-07 13:56:11 -0500139 srgbCS = SkColorSpace::MakeSRGB();
Brian Osman526972e2016-10-24 09:24:02 -0400140 wideCS = SkColorSpace::MakeRGB(SkColorSpace::kSRGB_RenderTargetGamma,
raftias94888332016-10-18 10:02:51 -0700141 wideGamutRGB_toXYZD50);
brianosman2c4b64e2016-09-07 07:04:44 -0700142 break;
143 case kRGBA_F16_SkColorType:
Matt Sarett77a7a1b2017-02-07 13:56:11 -0500144 srgbCS = SkColorSpace::MakeSRGBLinear();
Brian Osman526972e2016-10-24 09:24:02 -0400145 wideCS = SkColorSpace::MakeRGB(SkColorSpace::kLinear_RenderTargetGamma,
raftias94888332016-10-18 10:02:51 -0700146 wideGamutRGB_toXYZD50);
brianosman2c4b64e2016-09-07 07:04:44 -0700147 break;
148 default:
149 return;
150 }
raftias94888332016-10-18 10:02:51 -0700151 SkASSERT(srgbCS);
152 SkASSERT(wideCS);
brianosman2c4b64e2016-09-07 07:04:44 -0700153
Brian Osman0d4ff6c2017-01-17 16:10:07 -0500154 // Make our two working surfaces (one sRGB, one Wide)
fmalitaed387722016-09-30 06:14:49 -0700155 SkImageInfo srgbGamutInfo = SkImageInfo::Make(gRectSize, gRectSize, origInfo.colorType(),
brianosman2c4b64e2016-09-07 07:04:44 -0700156 kPremul_SkAlphaType, srgbCS);
fmalitaed387722016-09-30 06:14:49 -0700157 SkImageInfo wideGamutInfo = SkImageInfo::Make(gRectSize, gRectSize, origInfo.colorType(),
brianosman2c4b64e2016-09-07 07:04:44 -0700158 kPremul_SkAlphaType, wideCS);
Brian Osman0d4ff6c2017-01-17 16:10:07 -0500159
brianosman2c4b64e2016-09-07 07:04:44 -0700160 sk_sp<SkSurface> srgbGamutSurface = canvas->makeSurface(srgbGamutInfo);
161 sk_sp<SkSurface> wideGamutSurface = canvas->makeSurface(wideGamutInfo);
fmalitaed387722016-09-30 06:14:49 -0700162 if (!srgbGamutSurface || !wideGamutSurface) {
163 return;
brianosman2c4b64e2016-09-07 07:04:44 -0700164 }
165 SkCanvas* srgbGamutCanvas = srgbGamutSurface->getCanvas();
166 SkCanvas* wideGamutCanvas = wideGamutSurface->getCanvas();
167
168 SkPaint textPaint;
169 textPaint.setAntiAlias(true);
170 textPaint.setColor(SK_ColorWHITE);
171 sk_tool_utils::set_portable_typeface(&textPaint);
172
173 SkScalar x = 0, y = 0;
174 SkScalar textHeight = textPaint.getFontSpacing();
175
176 for (const auto& renderer : renderers) {
177 srgbGamutCanvas->clear(SK_ColorBLACK);
178 renderer->draw(srgbGamutCanvas);
179 wideGamutCanvas->clear(SK_ColorBLACK);
180 renderer->draw(wideGamutCanvas);
181
Cary Clark2a475ea2017-04-28 15:35:12 -0400182 canvas->drawString(renderer->label(), x, y + textHeight, textPaint);
brianosman2c4b64e2016-09-07 07:04:44 -0700183
Brian Osman0d4ff6c2017-01-17 16:10:07 -0500184 // Re-interpret the off-screen images, so we can see the raw data (eg, Wide gamut squares
185 // will look desaturated, relative to sRGB).
186 auto srgbImage = srgbGamutSurface->makeImageSnapshot();
187 srgbImage = SkImageMakeRasterCopyAndAssignColorSpace(srgbImage.get(),
188 origInfo.colorSpace());
189 canvas->drawImage(srgbImage, x, y + textHeight + 5);
brianosman2c4b64e2016-09-07 07:04:44 -0700190 x += (gScalarSize + 1);
191
Brian Osman0d4ff6c2017-01-17 16:10:07 -0500192 auto wideImage = wideGamutSurface->makeImageSnapshot();
193 wideImage = SkImageMakeRasterCopyAndAssignColorSpace(wideImage.get(),
194 origInfo.colorSpace());
195 canvas->drawImage(wideImage, x, y + textHeight + 5);
brianosman2c4b64e2016-09-07 07:04:44 -0700196 x += (gScalarSize + 10);
197
198 if (x + (2 * gScalarSize + 1) > gTestWidth) {
199 x = 0;
200 y += (textHeight + gScalarSize + 10);
201 }
202 }
203}
204
205DEF_SIMPLE_GM_BG(gamut, canvas, gTestWidth, gTestHeight, SK_ColorBLACK) {
Ben Wagner145dbcd2016-11-03 14:40:50 -0400206 SkTArray<std::unique_ptr<CellRenderer>> renderers;
brianosman2c4b64e2016-09-07 07:04:44 -0700207
208 // sRGB primaries, rendered as paint color
Ben Wagner145dbcd2016-11-03 14:40:50 -0400209 renderers.emplace_back(new PaintColorCellRenderer(SK_ColorRED));
210 renderers.emplace_back(new PaintColorCellRenderer(SK_ColorGREEN));
brianosman2c4b64e2016-09-07 07:04:44 -0700211
212 // sRGB primaries, rendered as bitmaps
Ben Wagner145dbcd2016-11-03 14:40:50 -0400213 renderers.emplace_back(new BitmapCellRenderer(SK_ColorRED, kNone_SkFilterQuality));
214 renderers.emplace_back(new BitmapCellRenderer(SK_ColorGREEN, kLow_SkFilterQuality));
brianosman2c4b64e2016-09-07 07:04:44 -0700215 // Larger bitmap to trigger mipmaps
Ben Wagner145dbcd2016-11-03 14:40:50 -0400216 renderers.emplace_back(new BitmapCellRenderer(SK_ColorRED, kMedium_SkFilterQuality, 2.0f));
brianosman2c4b64e2016-09-07 07:04:44 -0700217 // Smaller bitmap to trigger bicubic
Ben Wagner145dbcd2016-11-03 14:40:50 -0400218 renderers.emplace_back(new BitmapCellRenderer(SK_ColorGREEN, kHigh_SkFilterQuality, 0.5f));
brianosman2c4b64e2016-09-07 07:04:44 -0700219
220 // Various gradients involving sRGB primaries and white/black
brianosmand4546092016-09-22 12:31:58 -0700221
222 // First with just two stops (implemented with uniforms on GPU)
Ben Wagner145dbcd2016-11-03 14:40:50 -0400223 renderers.emplace_back(new GradientCellRenderer(SK_ColorRED, SK_ColorGREEN, false));
224 renderers.emplace_back(new GradientCellRenderer(SK_ColorGREEN, SK_ColorBLACK, false));
225 renderers.emplace_back(new GradientCellRenderer(SK_ColorGREEN, SK_ColorWHITE, false));
brianosmand4546092016-09-22 12:31:58 -0700226
227 // ... and then with four stops (implemented with textures on GPU)
Ben Wagner145dbcd2016-11-03 14:40:50 -0400228 renderers.emplace_back(new GradientCellRenderer(SK_ColorRED, SK_ColorGREEN, true));
229 renderers.emplace_back(new GradientCellRenderer(SK_ColorGREEN, SK_ColorBLACK, true));
230 renderers.emplace_back(new GradientCellRenderer(SK_ColorGREEN, SK_ColorWHITE, true));
brianosman2c4b64e2016-09-07 07:04:44 -0700231
232 // Vertex colors
Ben Wagner145dbcd2016-11-03 14:40:50 -0400233 renderers.emplace_back(new VerticesCellRenderer(SK_ColorRED, SK_ColorRED));
234 renderers.emplace_back(new VerticesCellRenderer(SK_ColorRED, SK_ColorGREEN));
brianosman2c4b64e2016-09-07 07:04:44 -0700235
236 draw_gamut_grid(canvas, renderers);
237}