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