gm/texdata.cpp

   1
   2 /*
   3  * Copyright 2011 Google Inc.
   4  *
   5  * Use of this source code is governed by a BSD-style license that can be
   6  * found in the LICENSE file.
   7  */
   8
   9 // This test only works with the GPU backend.
  10
  11 #include "gm.h"
  12
  13 #if SK_SUPPORT_GPU
  14 #include "GrContext.h"
  15 #include "SkColorPriv.h"
  16 #include "effects/GrPorterDuffXferProcessor.h"
  17 #include "effects/GrSimpleTextureEffect.h"
  18
  19 namespace skiagm {
  20
  21 static const int S = 200;
  22
  23 class TexDataGM : public GM {
  24 public:
  25     TexDataGM() {
  26         this->setBGColor(0xff000000);
  27     }
  28
  29 protected:
  30     SkString onShortName() SK_OVERRIDE {
  31         return SkString("texdata");
  32     }
  33
  34     SkISize onISize() SK_OVERRIDE {
  35         return SkISize::Make(2*S, 2*S);
  36     }
  37
  38     void onDraw(SkCanvas* canvas) SK_OVERRIDE {
  39         GrRenderTarget* target = canvas->internal_private_accessTopLayerRenderTarget();
  40         GrContext* ctx = canvas->getGrContext();
  41         if (ctx && target) {
  42             SkAutoTArray<SkPMColor> gTextureData((2 * S) * (2 * S));
  43             static const int stride = 2 * S;
  44             static const SkPMColor gray  = SkPackARGB32(0x40, 0x40, 0x40, 0x40);
  45             static const SkPMColor white = SkPackARGB32(0xff, 0xff, 0xff, 0xff);
  46             static const SkPMColor red   = SkPackARGB32(0x80, 0x80, 0x00, 0x00);
  47             static const SkPMColor blue  = SkPackARGB32(0x80, 0x00, 0x00, 0x80);
  48             static const SkPMColor green = SkPackARGB32(0x80, 0x00, 0x80, 0x00);
  49             static const SkPMColor black = SkPackARGB32(0x00, 0x00, 0x00, 0x00);
  50             for (int i = 0; i < 2; ++i) {
  51                 int offset = 0;
  52                 // fill upper-left
  53                 for (int y = 0; y < S; ++y) {
  54                     for (int x = 0; x < S; ++x) {
  55                         gTextureData[offset + y * stride + x] = gray;
  56                     }
  57                 }
  58                 // fill upper-right
  59                 offset = S;
  60                 for (int y = 0; y < S; ++y) {
  61                     for (int x = 0; x < S; ++x) {
  62                         gTextureData[offset + y * stride + x] = white;
  63                     }
  64                 }
  65                 // fill lower left
  66                 offset = S * stride;
  67                 for (int y = 0; y < S; ++y) {
  68                     for (int x = 0; x < S; ++x) {
  69                         gTextureData[offset + y * stride + x] = black;
  70                     }
  71                 }
  72                 // fill lower right
  73                 offset = S * stride + S;
  74                 for (int y = 0; y < S; ++y) {
  75                     for (int x = 0; x < S; ++x) {
  76                         gTextureData[offset + y * stride + x] = gray;
  77                     }
  78                 }
  79
  80                 GrSurfaceDesc desc;
  81                 // use RT flag bit because in GL it makes the texture be bottom-up
  82                 desc.fFlags     = i ? kRenderTarget_GrSurfaceFlag :
  83                                       kNone_GrSurfaceFlags;
  84                 desc.fConfig    = kSkia8888_GrPixelConfig;
  85                 desc.fWidth     = 2 * S;
  86                 desc.fHeight    = 2 * S;
  87                 GrTexture* texture = ctx->createTexture(desc, false, gTextureData.get(), 0);
  88
  89                 if (!texture) {
  90                     return;
  91                 }
  92                 SkAutoTUnref<GrTexture> au(texture);
  93
  94                 // setup new clip
  95                 GrClip clip(SkRect::MakeWH(2*S, 2*S));
  96
  97                 GrPaint paint;
  98                 paint.setPorterDuffXPFactory(SkXfermode::kSrcOver_Mode);
  99
 100                 SkMatrix vm;
 101                 if (i) {
 102                     vm.setRotate(90 * SK_Scalar1,
 103                                  S * SK_Scalar1,
 104                                  S * SK_Scalar1);
 105                 } else {
 106                     vm.reset();
 107                 }
 108                 SkMatrix tm;
 109                 tm = vm;
 110                 tm.postIDiv(2*S, 2*S);
 111                 paint.addColorTextureProcessor(texture, tm);
 112
 113                 ctx->drawRect(target, clip, paint, vm, SkRect::MakeWH(2*S, 2*S));
 114
 115                 // now update the lower right of the texture in first pass
 116                 // or upper right in second pass
 117                 offset = 0;
 118                 for (int y = 0; y < S; ++y) {
 119                     for (int x = 0; x < S; ++x) {
 120                         gTextureData[offset + y * stride + x] =
 121                             ((x + y) % 2) ? (i ? green : red) : blue;
 122                     }
 123                 }
 124                 texture->writePixels(S, (i ? 0 : S), S, S,
 125                                      texture->config(), gTextureData.get(),
 126                                      4 * stride);
 127                 ctx->drawRect(target, clip, paint, vm, SkRect::MakeWH(2*S, 2*S));
 128             }
 129         } else {
 130             this->drawGpuOnlyMessage(canvas);
 131         }
 132     }
 133
 134 private:
 135     typedef GM INHERITED;
 136 };
 137
 138 //////////////////////////////////////////////////////////////////////////////
 139
 140 static GM* MyFactory(void*) { return new TexDataGM; }
 141 static GMRegistry reg(MyFactory);
 142
 143 }
 144
 145 #endif