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 // This test only works with the GL backend.
9 
10 #include "gm/gm.h"
11 
12 #ifdef SK_GL
13 #include "include/core/SkBitmap.h"
14 #include "include/core/SkCanvas.h"
15 #include "include/core/SkColor.h"
16 #include "include/core/SkFilterQuality.h"
17 #include "include/core/SkImage.h"
18 #include "include/core/SkImageInfo.h"
19 #include "include/core/SkPaint.h"
20 #include "include/core/SkPoint.h"
21 #include "include/core/SkRect.h"
22 #include "include/core/SkRefCnt.h"
23 #include "include/core/SkScalar.h"
24 #include "include/core/SkShader.h"
25 #include "include/core/SkSize.h"
26 #include "include/core/SkString.h"
27 #include "include/core/SkTileMode.h"
28 #include "include/core/SkTypes.h"
29 #include "include/effects/SkGradientShader.h"
30 #include "include/gpu/GrBackendSurface.h"
31 #include "include/gpu/GrDirectContext.h"
32 #include "include/gpu/GrTypes.h"
33 #include "src/core/SkAutoPixmapStorage.h"
34 #include "src/gpu/GrDirectContextPriv.h"
35 #include "src/gpu/GrGpu.h"
36 #include "src/gpu/gl/GrGLCaps.h"
37 #include "src/gpu/gl/GrGLDefines.h"
38 
39 #include <algorithm>
40 #include <cstdint>
41 #include <memory>
42 
43 class GrRenderTargetContext;
44 
45 namespace skiagm {
46 class RectangleTexture : public GpuGM {
47 public:
RectangleTexture()48     RectangleTexture() {
49         this->setBGColor(0xFFFFFFFF);
50     }
51 
52 private:
53     enum class ImageType {
54         kGradientCircle,
55         k2x2
56     };
57 
onShortName()58     SkString onShortName() override {
59         return SkString("rectangle_texture");
60     }
61 
onISize()62     SkISize onISize() override { return SkISize::Make(1180, 710); }
63 
makeImagePixels(int size,ImageType type)64     SkBitmap makeImagePixels(int size, ImageType type) {
65         auto ii = SkImageInfo::Make(size, size, kRGBA_8888_SkColorType, kOpaque_SkAlphaType);
66         switch (type) {
67             case ImageType::kGradientCircle: {
68                 SkBitmap bmp;
69                 bmp.allocPixels(ii);
70                 SkPaint paint;
71                 SkCanvas canvas(bmp);
72                 SkPoint pts[] = {{0, 0}, {0, SkIntToScalar(size)}};
73                 SkColor colors0[] = {0xFF1060B0, 0xFF102030};
74                 paint.setShader(
75                         SkGradientShader::MakeLinear(pts, colors0, nullptr, 2, SkTileMode::kClamp));
76                 canvas.drawPaint(paint);
77                 SkColor colors1[] = {0xFFA07010, 0xFFA02080};
78                 paint.setAntiAlias(true);
79                 paint.setShader(
80                         SkGradientShader::MakeLinear(pts, colors1, nullptr, 2, SkTileMode::kClamp));
81                 canvas.drawCircle(size/2.f, size/2.f, 2.f*size/5, paint);
82                 return bmp;
83             }
84             case ImageType::k2x2: {
85                 SkBitmap bmp;
86                 bmp.allocPixels(ii);
87                 *bmp.getAddr32(0, 0) = 0xFF0000FF;
88                 *bmp.getAddr32(1, 0) = 0xFF00FF00;
89                 *bmp.getAddr32(0, 1) = 0xFFFF0000;
90                 *bmp.getAddr32(1, 1) = 0xFFFFFFFF;
91                 return bmp;
92             }
93         }
94         SkUNREACHABLE;
95     }
96 
createRectangleTextureImg(GrDirectContext * dContext,GrSurfaceOrigin origin,const SkBitmap content)97     sk_sp<SkImage> createRectangleTextureImg(GrDirectContext* dContext, GrSurfaceOrigin origin,
98                                              const SkBitmap content) {
99         SkASSERT(content.colorType() == kRGBA_8888_SkColorType);
100         auto format = GrBackendFormat::MakeGL(GR_GL_RGBA8, GR_GL_TEXTURE_RECTANGLE);
101         auto bet = dContext->createBackendTexture(content.width(), content.height(), format,
102                                                   GrMipmapped::kNo, GrRenderable::kNo);
103         if (!bet.isValid()) {
104             return nullptr;
105         }
106         const SkPixmap* pm = &content.pixmap();
107         SkAutoPixmapStorage tempPM;
108         if (origin == kBottomLeft_GrSurfaceOrigin) {
109             tempPM.alloc(pm->info());
110             const uint32_t* src = pm->addr32();
111             uint32_t* dst = tempPM.writable_addr32(0, content.height() - 1);
112             for (int y = 0; y < content.height(); ++y,
113                                                   src += pm->rowBytesAsPixels(),
114                                                   dst -= tempPM.rowBytesAsPixels()) {
115                 std::copy_n(src, content.width(), dst);
116             }
117             pm = &tempPM;
118         }
119         if (!dContext->updateBackendTexture(bet, pm, 1, nullptr, nullptr)) {
120             dContext->deleteBackendTexture(bet);
121         }
122         return SkImage::MakeFromAdoptedTexture(dContext, bet, origin, kRGBA_8888_SkColorType);
123     }
124 
onGpuSetup(GrDirectContext * context,SkString * errorMsg)125     DrawResult onGpuSetup(GrDirectContext* context, SkString* errorMsg) override {
126         if (!context || context->abandoned()) {
127             return DrawResult::kSkip;
128         }
129 
130         if (context->backend() != GrBackendApi::kOpenGL_GrBackend ||
131             !static_cast<const GrGLCaps*>(context->priv().caps())->rectangleTextureSupport()) {
132             *errorMsg = "This GM requires an OpenGL context that supports texture rectangles.";
133             return DrawResult::kSkip;
134         }
135 
136         auto gradCircle = this->makeImagePixels(50, ImageType::kGradientCircle);
137 
138         fGradImgs[0] = this->createRectangleTextureImg(context, kTopLeft_GrSurfaceOrigin,
139                                                        gradCircle);
140         fGradImgs[1] = this->createRectangleTextureImg(context, kBottomLeft_GrSurfaceOrigin,
141                                                        gradCircle);
142         SkASSERT(SkToBool(fGradImgs[0]) == SkToBool(fGradImgs[1]));
143         if (!fGradImgs[0]) {
144             *errorMsg = "Could not create gradient rectangle texture images.";
145             return DrawResult::kFail;
146         }
147 
148         fSmallImg = this->createRectangleTextureImg(context, kTopLeft_GrSurfaceOrigin,
149                                                     this->makeImagePixels(2, ImageType::k2x2));
150         if (!fSmallImg) {
151             *errorMsg = "Could not create 2x2 rectangle texture image.";
152             return DrawResult::kFail;
153         }
154 
155         return DrawResult::kOk;
156     }
157 
onGpuTeardown()158     void onGpuTeardown() override {
159         fGradImgs[0] = fGradImgs[1] = nullptr;
160         fSmallImg = nullptr;
161     }
162 
onDraw(GrRecordingContext *,GrRenderTargetContext *,SkCanvas * canvas,SkString *)163     DrawResult onDraw(GrRecordingContext*, GrRenderTargetContext*, SkCanvas* canvas,
164                       SkString*) override {
165         SkASSERT(fGradImgs[0] && fGradImgs[1] && fSmallImg);
166 
167         static constexpr SkScalar kPad = 5.f;
168 
169         constexpr SkFilterQuality kQualities[] = {
170                 kNone_SkFilterQuality,
171                 kLow_SkFilterQuality,
172                 kMedium_SkFilterQuality,
173                 kHigh_SkFilterQuality,
174         };
175 
176         constexpr SkScalar kScales[] = {1.0f, 1.2f, 0.75f};
177 
178         canvas->translate(kPad, kPad);
179         for (size_t i = 0; i < kNumGradImages; ++i) {
180             auto img = fGradImgs[i];
181             int w = img->width();
182             int h = img->height();
183             for (auto s : kScales) {
184                 canvas->save();
185                 canvas->scale(s, s);
186                 for (auto q : kQualities) {
187                     // drawImage
188                     SkPaint plainPaint;
189                     plainPaint.setFilterQuality(q);
190                     canvas->drawImage(img, 0, 0, &plainPaint);
191                     canvas->translate(w + kPad, 0);
192 
193                     // clamp/clamp shader
194                     SkPaint clampPaint;
195                     clampPaint.setFilterQuality(q);
196                     clampPaint.setShader(fGradImgs[i]->makeShader());
197                     canvas->drawRect(SkRect::MakeWH(1.5f*w, 1.5f*h), clampPaint);
198                     canvas->translate(1.5f*w + kPad, 0);
199 
200                     // repeat/mirror shader
201                     SkPaint repeatPaint;
202                     repeatPaint.setFilterQuality(q);
203                     repeatPaint.setShader(fGradImgs[i]->makeShader(SkTileMode::kRepeat,
204                                                                    SkTileMode::kMirror));
205                     canvas->drawRect(SkRect::MakeWH(1.5f*w, 1.5f*h), repeatPaint);
206                     canvas->translate(1.5f*w + kPad, 0);
207 
208                     // drawImageRect with kStrict
209                     auto srcRect = SkRect::MakeXYWH(.25f*w, .25f*h, .50f*w, .50f*h);
210                     auto dstRect = SkRect::MakeXYWH(      0,     0, .50f*w, .50f*h);
211                     canvas->drawImageRect(fGradImgs[i], srcRect, dstRect, &plainPaint,
212                                           SkCanvas::kStrict_SrcRectConstraint);
213                     canvas->translate(.5f*w + kPad, 0);
214                 }
215                 canvas->restore();
216                 canvas->translate(0, kPad + 1.5f*h*s);
217             }
218         }
219 
220         static constexpr SkScalar kOutset = 25.f;
221         canvas->translate(kOutset, kOutset);
222         auto dstRect = SkRect::Make(fSmallImg->dimensions()).makeOutset(kOutset, kOutset);
223 
224         for (int fq = kNone_SkFilterQuality; fq <= kLast_SkFilterQuality; ++fq) {
225             if (fq == kMedium_SkFilterQuality) {
226                 // Medium is the same as Low for upscaling.
227                 continue;
228             }
229             canvas->save();
230             for (int ty = 0; ty < kSkTileModeCount; ++ty) {
231                 canvas->save();
232                 for (int tx = 0; tx < kSkTileModeCount; ++tx) {
233                     SkMatrix lm;
234                     lm.setRotate(45.f, 1, 1);
235                     lm.postScale(6.5f, 6.5f);
236                     auto shader = fSmallImg->makeShader(static_cast<SkTileMode>(tx),
237                                                         static_cast<SkTileMode>(ty), &lm);
238                     SkPaint paint;
239                     paint.setShader(std::move(shader));
240                     paint.setFilterQuality(static_cast<SkFilterQuality>(fq));
241                     canvas->drawRect(dstRect, paint);
242                     canvas->translate(dstRect.width() + kPad, 0);
243                 }
244                 canvas->restore();
245                 canvas->translate(0, dstRect.height() + kPad);
246             }
247             canvas->restore();
248             canvas->translate((dstRect.width() + kPad)*kSkTileModeCount, 0);
249         }
250 
251         return DrawResult::kOk;
252     }
253 
254 private:
255     static const int kNumGradImages = 2;
256 
257     sk_sp<SkImage> fGradImgs[kNumGradImages];
258     sk_sp<SkImage> fSmallImg;
259 
260     using INHERITED = GM;
261 };
262 
263 DEF_GM(return new RectangleTexture;)
264 }  // namespace skiagm
265 #endif
266