1/*
2 * Copyright 2012 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#ifndef GrTextureAccess_DEFINED
9#define GrTextureAccess_DEFINED
10
11#include "GrGpuResourceRef.h"
12#include "GrTexture.h"
13#include "SkRefCnt.h"
14#include "SkShader.h"
15
16/**
17 * Represents the filtering and tile modes used to access a texture. It is mostly used with
18 * GrTextureAccess (defined below). Also, some of the texture cache methods require knowledge about
19 * filtering and tiling to perform a cache lookup. If it wasn't for this latter usage this would
20 * be folded into GrTextureAccess. The default is clamp tile modes and no filtering.
21 */
22class GrTextureParams {
23public:
24    GrTextureParams() {
25        this->reset();
26    }
27
28    enum FilterMode {
29        kNone_FilterMode,
30        kBilerp_FilterMode,
31        kMipMap_FilterMode
32    };
33
34    GrTextureParams(SkShader::TileMode tileXAndY, FilterMode filterMode) {
35        this->reset(tileXAndY, filterMode);
36    }
37
38    GrTextureParams(const SkShader::TileMode tileModes[2], FilterMode filterMode) {
39        this->reset(tileModes, filterMode);
40    }
41
42    GrTextureParams(const GrTextureParams& params) {
43        *this = params;
44    }
45
46    GrTextureParams& operator= (const GrTextureParams& params) {
47        fTileModes[0] = params.fTileModes[0];
48        fTileModes[1] = params.fTileModes[1];
49        fFilterMode = params.fFilterMode;
50        return *this;
51    }
52
53    void reset() {
54        this->reset(SkShader::kClamp_TileMode, kNone_FilterMode);
55    }
56
57    void reset(SkShader::TileMode tileXAndY, FilterMode filterMode) {
58        fTileModes[0] = fTileModes[1] = tileXAndY;
59        fFilterMode = filterMode;
60    }
61
62    void reset(const SkShader::TileMode tileModes[2], FilterMode filterMode) {
63        fTileModes[0] = tileModes[0];
64        fTileModes[1] = tileModes[1];
65        fFilterMode = filterMode;
66    }
67
68    void setClampNoFilter() {
69        fTileModes[0] = fTileModes[1] = SkShader::kClamp_TileMode;
70        fFilterMode = kNone_FilterMode;
71    }
72
73    void setClamp() {
74        fTileModes[0] = fTileModes[1] = SkShader::kClamp_TileMode;
75    }
76
77    void setFilterMode(FilterMode filterMode) { fFilterMode = filterMode; }
78
79    void setTileModeX(const SkShader::TileMode tm) { fTileModes[0] = tm; }
80    void setTileModeY(const SkShader::TileMode tm) { fTileModes[1] = tm; }
81    void setTileModeXAndY(const SkShader::TileMode tm) { fTileModes[0] = fTileModes[1] = tm; }
82
83    SkShader::TileMode getTileModeX() const { return fTileModes[0]; }
84
85    SkShader::TileMode getTileModeY() const { return fTileModes[1]; }
86
87    bool isTiled() const {
88        return SkShader::kClamp_TileMode != fTileModes[0] ||
89               SkShader::kClamp_TileMode != fTileModes[1];
90    }
91
92    FilterMode filterMode() const { return fFilterMode; }
93
94    bool operator== (const GrTextureParams& other) const {
95        return fTileModes[0] == other.fTileModes[0] &&
96               fTileModes[1] == other.fTileModes[1] &&
97               fFilterMode == other.fFilterMode;
98    }
99
100    bool operator!= (const GrTextureParams& other) const { return !(*this == other); }
101
102private:
103
104    SkShader::TileMode fTileModes[2];
105    FilterMode         fFilterMode;
106};
107
108/** A class representing the swizzle access pattern for a texture. Note that if the texture is
109 *  an alpha-only texture then the alpha channel is substituted for other components. Any mangling
110 *  to handle the r,g,b->a conversions for alpha textures is automatically included in the stage
111 *  key. However, if a GrProcessor uses different swizzles based on its input then it must
112 *  consider that variation in its key-generation.
113 */
114class GrTextureAccess : public SkNoncopyable {
115public:
116    SK_DECLARE_INST_COUNT_ROOT(GrTextureAccess);
117
118    /**
119     * A default GrTextureAccess must have reset() called on it in a GrProcessor subclass's
120     * constructor if it will be accessible via GrProcessor::textureAccess().
121     */
122    GrTextureAccess();
123
124    /**
125     * Uses the default swizzle, "rgba".
126     */
127    GrTextureAccess(GrTexture*, const GrTextureParams&);
128    explicit GrTextureAccess(GrTexture*,
129                             GrTextureParams::FilterMode = GrTextureParams::kNone_FilterMode,
130                             SkShader::TileMode tileXAndY = SkShader::kClamp_TileMode);
131
132    /**
133     * swizzle must be a string between one and four (inclusive) characters containing only 'r',
134     * 'g', 'b',  and/or 'a'.
135     */
136    GrTextureAccess(GrTexture*, const char* swizzle, const GrTextureParams&);
137    GrTextureAccess(GrTexture*,
138                    const char* swizzle,
139                    GrTextureParams::FilterMode = GrTextureParams::kNone_FilterMode,
140                    SkShader::TileMode tileXAndY = SkShader::kClamp_TileMode);
141
142    void reset(GrTexture*, const GrTextureParams&);
143    void reset(GrTexture*,
144               GrTextureParams::FilterMode = GrTextureParams::kNone_FilterMode,
145               SkShader::TileMode tileXAndY = SkShader::kClamp_TileMode);
146    void reset(GrTexture*, const char* swizzle, const GrTextureParams&);
147    void reset(GrTexture*,
148               const char* swizzle,
149               GrTextureParams::FilterMode = GrTextureParams::kNone_FilterMode,
150               SkShader::TileMode tileXAndY = SkShader::kClamp_TileMode);
151
152    bool operator== (const GrTextureAccess& other) const {
153#ifdef SK_DEBUG
154        // below assumes all chars in fSwizzle are initialized even if string is < 4 chars long.
155        SkASSERT(memcmp(fSwizzle, other.fSwizzle, sizeof(fSwizzle)-1) ==
156                 strcmp(fSwizzle, other.fSwizzle));
157#endif
158        return fParams == other.fParams &&
159               (this->getTexture() == other.getTexture()) &&
160               (0 == memcmp(fSwizzle, other.fSwizzle, sizeof(fSwizzle)-1));
161    }
162
163    bool operator!= (const GrTextureAccess& other) const { return !(*this == other); }
164
165    GrTexture* getTexture() const { return fTexture.get(); }
166
167    /**
168     * For internal use by GrProcessor.
169     */
170    const GrGpuResourceRef* getProgramTexture() const { return &fTexture; }
171
172    /**
173     * Returns a string representing the swizzle. The string is is null-terminated.
174     */
175    const char* getSwizzle() const { return fSwizzle; }
176
177    /** Returns a mask indicating which components are referenced in the swizzle. The return
178        is a bitfield of GrColorComponentFlags. */
179    uint32_t swizzleMask() const { return fSwizzleMask; }
180
181    const GrTextureParams& getParams() const { return fParams; }
182
183private:
184    void setSwizzle(const char*);
185
186    typedef GrTGpuResourceRef<GrTexture> ProgramTexture;
187
188    ProgramTexture                  fTexture;
189    GrTextureParams                 fParams;
190    uint32_t                        fSwizzleMask;
191    char                            fSwizzle[5];
192
193    typedef SkNoncopyable INHERITED;
194};
195
196#endif
197