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