texdata.cpp revision 1c4029296f518a84ef90095243ba210163a1e1f9 
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
19namespace skiagm {
20
21static const int S = 200;
22
23class TexDataGM : public GM {
24public:
25    TexDataGM() {
26        this->setBGColor(0xff000000);
27    }
28
29protected:
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 =
88                    ctx->createUncachedTexture(desc, gTextureData.get(), 0);
89
90                if (!texture) {
91                    return;
92                }
93                SkAutoTUnref<GrTexture> au(texture);
94
95                GrContext::AutoClip acs(ctx, SkRect::MakeWH(2*S, 2*S));
96
97                ctx->setRenderTarget(target);
98
99                GrPaint paint;
100                paint.setPorterDuffXPFactory(SkXfermode::kSrcOver_Mode);
101
102                SkMatrix vm;
103                if (i) {
104                    vm.setRotate(90 * SK_Scalar1,
105                                 S * SK_Scalar1,
106                                 S * SK_Scalar1);
107                } else {
108                    vm.reset();
109                }
110                SkMatrix tm;
111                tm = vm;
112                tm.postIDiv(2*S, 2*S);
113                paint.addColorTextureProcessor(texture, tm);
114
115                ctx->drawRect(paint, vm, SkRect::MakeWH(2*S, 2*S));
116
117                // now update the lower right of the texture in first pass
118                // or upper right in second pass
119                offset = 0;
120                for (int y = 0; y < S; ++y) {
121                    for (int x = 0; x < S; ++x) {
122                        gTextureData[offset + y * stride + x] =
123                            ((x + y) % 2) ? (i ? green : red) : blue;
124                    }
125                }
126                texture->writePixels(S, (i ? 0 : S), S, S,
127                                     texture->config(), gTextureData.get(),
128                                     4 * stride);
129                ctx->drawRect(paint, vm, SkRect::MakeWH(2*S, 2*S));
130            }
131        }
132    }
133
134private:
135    typedef GM INHERITED;
136};
137
138//////////////////////////////////////////////////////////////////////////////
139
140static GM* MyFactory(void*) { return new TexDataGM; }
141static GMRegistry reg(MyFactory);
142
143}
144
145#endif
146