joshualitt | 8072caa | 2015-02-12 14:20:52 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2013 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 GrPrimitiveProcessor_DEFINED |
| 9 | #define GrPrimitiveProcessor_DEFINED |
| 10 | |
| 11 | #include "GrColor.h" |
| 12 | #include "GrProcessor.h" |
Brian Salomon | ee78396 | 2018-08-01 09:55:10 -0400 | [diff] [blame^] | 13 | #include "GrProxyRef.h" |
joshualitt | 8072caa | 2015-02-12 14:20:52 -0800 | [diff] [blame] | 14 | #include "GrShaderVar.h" |
| 15 | |
Brian Salomon | f7dcd76 | 2018-07-30 14:48:15 -0400 | [diff] [blame] | 16 | class GrCoordTransform; |
| 17 | |
joshualitt | 8072caa | 2015-02-12 14:20:52 -0800 | [diff] [blame] | 18 | /* |
| 19 | * The GrPrimitiveProcessor represents some kind of geometric primitive. This includes the shape |
| 20 | * of the primitive and the inherent color of the primitive. The GrPrimitiveProcessor is |
| 21 | * responsible for providing a color and coverage input into the Ganesh rendering pipeline. Through |
| 22 | * optimization, Ganesh may decide a different color, no color, and / or no coverage are required |
| 23 | * from the GrPrimitiveProcessor, so the GrPrimitiveProcessor must be able to support this |
Brian Salomon | 09d994e | 2016-12-21 11:14:46 -0500 | [diff] [blame] | 24 | * functionality. |
joshualitt | 8072caa | 2015-02-12 14:20:52 -0800 | [diff] [blame] | 25 | * |
| 26 | * There are two feedback loops between the GrFragmentProcessors, the GrXferProcessor, and the |
Brian Salomon | cb30bb2 | 2017-02-12 09:28:54 -0500 | [diff] [blame] | 27 | * GrPrimitiveProcessor. These loops run on the CPU and to determine known properties of the final |
| 28 | * color and coverage inputs to the GrXferProcessor in order to perform optimizations that preserve |
| 29 | * correctness. The GrDrawOp seeds these loops with initial color and coverage, in its |
Brian Salomon | a811b12 | 2017-03-30 08:21:32 -0400 | [diff] [blame] | 30 | * getProcessorAnalysisInputs implementation. These seed values are processed by the |
Brian Salomon | 5298dc8 | 2017-02-22 11:52:03 -0500 | [diff] [blame] | 31 | * subsequent |
Brian Salomon | 92aee3d | 2016-12-21 09:20:25 -0500 | [diff] [blame] | 32 | * stages of the rendering pipeline and the output is then fed back into the GrDrawOp in |
| 33 | * the applyPipelineOptimizations call, where the op can use the information to inform decisions |
| 34 | * about GrPrimitiveProcessor creation. |
joshualitt | 8072caa | 2015-02-12 14:20:52 -0800 | [diff] [blame] | 35 | */ |
| 36 | |
egdaniel | e659a58 | 2015-11-13 09:55:43 -0800 | [diff] [blame] | 37 | class GrGLSLPrimitiveProcessor; |
joshualitt | 8072caa | 2015-02-12 14:20:52 -0800 | [diff] [blame] | 38 | |
joshualitt | 8072caa | 2015-02-12 14:20:52 -0800 | [diff] [blame] | 39 | /* |
joshualitt | 8072caa | 2015-02-12 14:20:52 -0800 | [diff] [blame] | 40 | * GrPrimitiveProcessor defines an interface which all subclasses must implement. All |
| 41 | * GrPrimitiveProcessors must proivide seed color and coverage for the Ganesh color / coverage |
| 42 | * pipelines, and they must provide some notion of equality |
| 43 | */ |
Brian Salomon | e782f84 | 2018-07-31 13:53:11 -0400 | [diff] [blame] | 44 | class GrPrimitiveProcessor : public GrProcessor, public GrProgramElement { |
joshualitt | 8072caa | 2015-02-12 14:20:52 -0800 | [diff] [blame] | 45 | public: |
Brian Salomon | e782f84 | 2018-07-31 13:53:11 -0400 | [diff] [blame] | 46 | class TextureSampler; |
| 47 | |
Brian Salomon | 92be2f7 | 2018-06-19 14:33:47 -0400 | [diff] [blame] | 48 | /** Describes a vertex or instance attribute. */ |
Brian Salomon | 70132d0 | 2018-05-29 15:33:06 -0400 | [diff] [blame] | 49 | class Attribute { |
| 50 | public: |
Brian Salomon | 70132d0 | 2018-05-29 15:33:06 -0400 | [diff] [blame] | 51 | constexpr Attribute() = default; |
Brian Salomon | 92be2f7 | 2018-06-19 14:33:47 -0400 | [diff] [blame] | 52 | constexpr Attribute(const char* name, GrVertexAttribType type) : fName(name), fType(type) {} |
| 53 | constexpr Attribute(const Attribute&) = default; |
Brian Salomon | 70132d0 | 2018-05-29 15:33:06 -0400 | [diff] [blame] | 54 | |
Brian Salomon | 92be2f7 | 2018-06-19 14:33:47 -0400 | [diff] [blame] | 55 | Attribute& operator=(const Attribute&) = default; |
Brian Salomon | 70132d0 | 2018-05-29 15:33:06 -0400 | [diff] [blame] | 56 | |
Brian Salomon | 92be2f7 | 2018-06-19 14:33:47 -0400 | [diff] [blame] | 57 | constexpr bool isInitialized() const { return SkToBool(fName); } |
| 58 | |
| 59 | constexpr const char* name() const { return fName; } |
| 60 | constexpr GrVertexAttribType type() const { return fType; } |
| 61 | |
| 62 | inline constexpr size_t size() const; |
| 63 | constexpr size_t sizeAlign4() const { return SkAlign4(this->size()); } |
Brian Salomon | 70132d0 | 2018-05-29 15:33:06 -0400 | [diff] [blame] | 64 | |
| 65 | GrShaderVar asShaderVar() const { |
| 66 | return {fName, GrVertexAttribTypeToSLType(fType), GrShaderVar::kIn_TypeModifier}; |
| 67 | } |
| 68 | |
| 69 | private: |
| 70 | const char* fName = nullptr; |
| 71 | GrVertexAttribType fType = kFloat_GrVertexAttribType; |
joshualitt | 8072caa | 2015-02-12 14:20:52 -0800 | [diff] [blame] | 72 | }; |
| 73 | |
Brian Salomon | 92be2f7 | 2018-06-19 14:33:47 -0400 | [diff] [blame] | 74 | GrPrimitiveProcessor(ClassID); |
Ethan Nicholas | abff956 | 2017-10-09 10:54:08 -0400 | [diff] [blame] | 75 | |
Brian Salomon | e782f84 | 2018-07-31 13:53:11 -0400 | [diff] [blame] | 76 | int numTextureSamplers() const { return fTextureSamplerCnt; } |
| 77 | const TextureSampler& textureSampler(int index) const; |
Brian Salomon | 92be2f7 | 2018-06-19 14:33:47 -0400 | [diff] [blame] | 78 | int numVertexAttributes() const { return fVertexAttributeCnt; } |
| 79 | const Attribute& vertexAttribute(int i) const; |
| 80 | int numInstanceAttributes() const { return fInstanceAttributeCnt; } |
| 81 | const Attribute& instanceAttribute(int i) const; |
joshualitt | 8072caa | 2015-02-12 14:20:52 -0800 | [diff] [blame] | 82 | |
Brian Salomon | 92be2f7 | 2018-06-19 14:33:47 -0400 | [diff] [blame] | 83 | bool hasVertexAttributes() const { return SkToBool(fVertexAttributeCnt); } |
| 84 | bool hasInstanceAttributes() const { return SkToBool(fInstanceAttributeCnt); } |
Chris Dalton | 1d61635 | 2017-05-31 12:51:23 -0600 | [diff] [blame] | 85 | |
Brian Salomon | 92be2f7 | 2018-06-19 14:33:47 -0400 | [diff] [blame] | 86 | #ifdef SK_DEBUG |
Chris Dalton | 1d61635 | 2017-05-31 12:51:23 -0600 | [diff] [blame] | 87 | /** |
Brian Salomon | 92be2f7 | 2018-06-19 14:33:47 -0400 | [diff] [blame] | 88 | * A common practice is to populate the the vertex/instance's memory using an implicit array of |
| 89 | * structs. In this case, it is best to assert that: |
| 90 | * debugOnly_stride == sizeof(struct) and |
| 91 | * offsetof(struct, field[i]) == debugOnly_AttributeOffset(i) |
| 92 | * In general having Op subclasses assert that attribute offsets and strides agree with their |
| 93 | * tessellation code's expectations is good practice. |
| 94 | * However, these functions walk the attributes to compute offsets and call virtual functions |
| 95 | * to access the attributes. Thus, they are only available in debug builds. |
Chris Dalton | 1d61635 | 2017-05-31 12:51:23 -0600 | [diff] [blame] | 96 | */ |
Brian Salomon | 92be2f7 | 2018-06-19 14:33:47 -0400 | [diff] [blame] | 97 | size_t debugOnly_vertexStride() const; |
| 98 | size_t debugOnly_instanceStride() const; |
| 99 | size_t debugOnly_vertexAttributeOffset(int) const; |
| 100 | size_t debugOnly_instanceAttributeOffset(int) const; |
| 101 | #endif |
Chris Dalton | 1d61635 | 2017-05-31 12:51:23 -0600 | [diff] [blame] | 102 | |
| 103 | // Only the GrGeometryProcessor subclass actually has a geo shader or vertex attributes, but |
| 104 | // we put these calls on the base class to prevent having to cast |
| 105 | virtual bool willUseGeoShader() const = 0; |
joshualitt | 8072caa | 2015-02-12 14:20:52 -0800 | [diff] [blame] | 106 | |
| 107 | /** |
wangyix | a7f4c43 | 2015-08-20 07:25:02 -0700 | [diff] [blame] | 108 | * Computes a transformKey from an array of coord transforms. Will only look at the first |
| 109 | * <numCoords> transforms in the array. |
| 110 | * |
| 111 | * TODO: A better name for this function would be "compute" instead of "get". |
joshualitt | 8072caa | 2015-02-12 14:20:52 -0800 | [diff] [blame] | 112 | */ |
wangyix | a7f4c43 | 2015-08-20 07:25:02 -0700 | [diff] [blame] | 113 | uint32_t getTransformKey(const SkTArray<const GrCoordTransform*, true>& coords, |
| 114 | int numCoords) const; |
joshualitt | 8072caa | 2015-02-12 14:20:52 -0800 | [diff] [blame] | 115 | |
| 116 | /** |
| 117 | * Sets a unique key on the GrProcessorKeyBuilder that is directly associated with this geometry |
| 118 | * processor's GL backend implementation. |
wangyix | a7f4c43 | 2015-08-20 07:25:02 -0700 | [diff] [blame] | 119 | * |
| 120 | * TODO: A better name for this function would be "compute" instead of "get". |
joshualitt | 8072caa | 2015-02-12 14:20:52 -0800 | [diff] [blame] | 121 | */ |
Brian Salomon | 94efbf5 | 2016-11-29 13:43:05 -0500 | [diff] [blame] | 122 | virtual void getGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const = 0; |
joshualitt | 8072caa | 2015-02-12 14:20:52 -0800 | [diff] [blame] | 123 | |
| 124 | |
| 125 | /** Returns a new instance of the appropriate *GL* implementation class |
| 126 | for the given GrProcessor; caller is responsible for deleting |
| 127 | the object. */ |
Brian Salomon | 94efbf5 | 2016-11-29 13:43:05 -0500 | [diff] [blame] | 128 | virtual GrGLSLPrimitiveProcessor* createGLSLInstance(const GrShaderCaps&) const = 0; |
joshualitt | 8072caa | 2015-02-12 14:20:52 -0800 | [diff] [blame] | 129 | |
ethannicholas | 2279325 | 2016-01-30 09:59:10 -0800 | [diff] [blame] | 130 | virtual bool isPathRendering() const { return false; } |
joshualitt | 8072caa | 2015-02-12 14:20:52 -0800 | [diff] [blame] | 131 | |
ethannicholas | 2279325 | 2016-01-30 09:59:10 -0800 | [diff] [blame] | 132 | /** |
| 133 | * If non-null, overrides the dest color returned by GrGLSLFragmentShaderBuilder::dstColor(). |
| 134 | */ |
| 135 | virtual const char* getDestColorOverride() const { return nullptr; } |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 136 | |
Brian Salomon | 92be2f7 | 2018-06-19 14:33:47 -0400 | [diff] [blame] | 137 | virtual float getSampleShading() const { return 0.0; } |
ethannicholas | 28ef445 | 2016-03-25 09:26:03 -0700 | [diff] [blame] | 138 | |
Brian Salomon | e782f84 | 2018-07-31 13:53:11 -0400 | [diff] [blame] | 139 | bool instantiate(GrResourceProvider*) const; |
| 140 | |
joshualitt | 8072caa | 2015-02-12 14:20:52 -0800 | [diff] [blame] | 141 | protected: |
Brian Salomon | e782f84 | 2018-07-31 13:53:11 -0400 | [diff] [blame] | 142 | void setVertexAttributeCnt(int cnt) { |
| 143 | SkASSERT(cnt >= 0); |
| 144 | fVertexAttributeCnt = cnt; |
| 145 | } |
| 146 | void setInstanceAttributeCnt(int cnt) { |
| 147 | SkASSERT(cnt >= 0); |
| 148 | fInstanceAttributeCnt = cnt; |
| 149 | } |
| 150 | void setTextureSamplerCnt(int cnt) { |
| 151 | SkASSERT(cnt >= 0); |
| 152 | fTextureSamplerCnt = cnt; |
| 153 | } |
| 154 | |
| 155 | /** |
| 156 | * Helper for implementing onTextureSampler(). E.g.: |
| 157 | * return IthTexureSampler(i, fMyFirstSampler, fMySecondSampler, fMyThirdSampler); |
| 158 | */ |
| 159 | template <typename... Args> |
| 160 | static const TextureSampler& IthTextureSampler(int i, const TextureSampler& samp0, |
| 161 | const Args&... samps) { |
| 162 | return (0 == i) ? samp0 : IthTextureSampler(i - 1, samps...); |
| 163 | } |
| 164 | inline static const TextureSampler& IthTextureSampler(int i); |
joshualitt | 8072caa | 2015-02-12 14:20:52 -0800 | [diff] [blame] | 165 | |
| 166 | private: |
Brian Salomon | e782f84 | 2018-07-31 13:53:11 -0400 | [diff] [blame] | 167 | void addPendingIOs() const final; |
| 168 | void removeRefs() const final; |
| 169 | void pendingIOComplete() const final; |
Mike Klein | fc6c37b | 2016-09-27 09:34:10 -0400 | [diff] [blame] | 170 | void notifyRefCntIsZero() const final {} |
joshualitt | 8072caa | 2015-02-12 14:20:52 -0800 | [diff] [blame] | 171 | |
Brian Salomon | 92be2f7 | 2018-06-19 14:33:47 -0400 | [diff] [blame] | 172 | virtual const Attribute& onVertexAttribute(int) const = 0; |
| 173 | virtual const Attribute& onInstanceAttribute(int) const = 0; |
Brian Salomon | e782f84 | 2018-07-31 13:53:11 -0400 | [diff] [blame] | 174 | virtual const TextureSampler& onTextureSampler(int) const { return IthTextureSampler(0); } |
Chris Dalton | 1d61635 | 2017-05-31 12:51:23 -0600 | [diff] [blame] | 175 | |
Brian Salomon | 92be2f7 | 2018-06-19 14:33:47 -0400 | [diff] [blame] | 176 | int fVertexAttributeCnt = 0; |
| 177 | int fInstanceAttributeCnt = 0; |
Brian Salomon | e782f84 | 2018-07-31 13:53:11 -0400 | [diff] [blame] | 178 | int fTextureSamplerCnt = 0; |
joshualitt | 8072caa | 2015-02-12 14:20:52 -0800 | [diff] [blame] | 179 | typedef GrProcessor INHERITED; |
| 180 | }; |
| 181 | |
Brian Salomon | 92be2f7 | 2018-06-19 14:33:47 -0400 | [diff] [blame] | 182 | ////////////////////////////////////////////////////////////////////////////// |
| 183 | |
| 184 | /** |
Brian Salomon | e782f84 | 2018-07-31 13:53:11 -0400 | [diff] [blame] | 185 | * Used to represent a texture that is required by a GrPrimitiveProcessor. It holds a GrTextureProxy |
| 186 | * along with an associated GrSamplerState. TextureSamplers don't perform any coord manipulation to |
| 187 | * account for texture origin. |
| 188 | */ |
| 189 | class GrPrimitiveProcessor::TextureSampler { |
| 190 | public: |
| 191 | TextureSampler() = default; |
| 192 | |
| 193 | TextureSampler(sk_sp<GrTextureProxy>, const GrSamplerState&, GrShaderFlags visibility); |
| 194 | |
| 195 | explicit TextureSampler(sk_sp<GrTextureProxy>, |
| 196 | GrSamplerState::Filter = GrSamplerState::Filter::kNearest, |
| 197 | GrSamplerState::WrapMode wrapXAndY = GrSamplerState::WrapMode::kClamp, |
| 198 | GrShaderFlags visibility = kFragment_GrShaderFlag); |
| 199 | |
| 200 | TextureSampler(const TextureSampler&) = delete; |
| 201 | TextureSampler& operator=(const TextureSampler&) = delete; |
| 202 | |
| 203 | void reset(sk_sp<GrTextureProxy>, const GrSamplerState&, |
| 204 | GrShaderFlags visibility = kFragment_GrShaderFlag); |
| 205 | void reset(sk_sp<GrTextureProxy>, |
| 206 | GrSamplerState::Filter = GrSamplerState::Filter::kNearest, |
| 207 | GrSamplerState::WrapMode wrapXAndY = GrSamplerState::WrapMode::kClamp, |
| 208 | GrShaderFlags visibility = kFragment_GrShaderFlag); |
| 209 | |
| 210 | bool instantiate(GrResourceProvider* resourceProvider) const { |
| 211 | return SkToBool(fProxyRef.get()->instantiate(resourceProvider)); |
| 212 | } |
| 213 | |
| 214 | // 'peekTexture' should only ever be called after a successful 'instantiate' call |
| 215 | GrTexture* peekTexture() const { |
Brian Salomon | fd98c2c | 2018-07-31 17:25:29 -0400 | [diff] [blame] | 216 | SkASSERT(fProxyRef.get()->peekTexture()); |
| 217 | return fProxyRef.get()->peekTexture(); |
Brian Salomon | e782f84 | 2018-07-31 13:53:11 -0400 | [diff] [blame] | 218 | } |
| 219 | |
Brian Salomon | ee78396 | 2018-08-01 09:55:10 -0400 | [diff] [blame^] | 220 | GrTextureProxy* proxy() const { return fProxyRef.get(); } |
Brian Salomon | e782f84 | 2018-07-31 13:53:11 -0400 | [diff] [blame] | 221 | GrShaderFlags visibility() const { return fVisibility; } |
| 222 | const GrSamplerState& samplerState() const { return fSamplerState; } |
| 223 | |
| 224 | bool isInitialized() const { return SkToBool(fProxyRef.get()); } |
| 225 | /** |
| 226 | * For internal use by GrPrimitiveProcessor. |
| 227 | */ |
Brian Salomon | ee78396 | 2018-08-01 09:55:10 -0400 | [diff] [blame^] | 228 | const GrTextureProxyRef* proxyRef() const { return &fProxyRef; } |
Brian Salomon | e782f84 | 2018-07-31 13:53:11 -0400 | [diff] [blame] | 229 | |
| 230 | private: |
Brian Salomon | ee78396 | 2018-08-01 09:55:10 -0400 | [diff] [blame^] | 231 | GrTextureProxyRef fProxyRef; |
Brian Salomon | e782f84 | 2018-07-31 13:53:11 -0400 | [diff] [blame] | 232 | GrSamplerState fSamplerState; |
| 233 | GrShaderFlags fVisibility = kNone_GrShaderFlags; |
| 234 | }; |
| 235 | |
| 236 | const GrPrimitiveProcessor::TextureSampler& GrPrimitiveProcessor::IthTextureSampler(int i) { |
| 237 | SK_ABORT("Illegal texture sampler index"); |
| 238 | static const TextureSampler kBogus; |
| 239 | return kBogus; |
| 240 | } |
| 241 | |
| 242 | ////////////////////////////////////////////////////////////////////////////// |
| 243 | |
| 244 | /** |
Brian Salomon | 92be2f7 | 2018-06-19 14:33:47 -0400 | [diff] [blame] | 245 | * Returns the size of the attrib type in bytes. |
| 246 | * This was moved from include/private/GrTypesPriv.h in service of Skia dependents that build |
| 247 | * with C++11. |
| 248 | */ |
| 249 | static constexpr inline size_t GrVertexAttribTypeSize(GrVertexAttribType type) { |
| 250 | switch (type) { |
| 251 | case kFloat_GrVertexAttribType: |
| 252 | return sizeof(float); |
| 253 | case kFloat2_GrVertexAttribType: |
| 254 | return 2 * sizeof(float); |
| 255 | case kFloat3_GrVertexAttribType: |
| 256 | return 3 * sizeof(float); |
| 257 | case kFloat4_GrVertexAttribType: |
| 258 | return 4 * sizeof(float); |
| 259 | case kHalf_GrVertexAttribType: |
| 260 | return sizeof(float); |
| 261 | case kHalf2_GrVertexAttribType: |
| 262 | return 2 * sizeof(float); |
| 263 | case kHalf3_GrVertexAttribType: |
| 264 | return 3 * sizeof(float); |
| 265 | case kHalf4_GrVertexAttribType: |
| 266 | return 4 * sizeof(float); |
| 267 | case kInt2_GrVertexAttribType: |
| 268 | return 2 * sizeof(int32_t); |
| 269 | case kInt3_GrVertexAttribType: |
| 270 | return 3 * sizeof(int32_t); |
| 271 | case kInt4_GrVertexAttribType: |
| 272 | return 4 * sizeof(int32_t); |
Ruiqi Mao | b609e6d | 2018-07-17 10:19:38 -0400 | [diff] [blame] | 273 | case kByte_GrVertexAttribType: |
| 274 | return 1 * sizeof(char); |
| 275 | case kByte2_GrVertexAttribType: |
| 276 | return 2 * sizeof(char); |
| 277 | case kByte3_GrVertexAttribType: |
| 278 | return 3 * sizeof(char); |
| 279 | case kByte4_GrVertexAttribType: |
| 280 | return 4 * sizeof(char); |
| 281 | case kUByte_GrVertexAttribType: |
| 282 | return 1 * sizeof(char); |
| 283 | case kUByte2_GrVertexAttribType: |
| 284 | return 2 * sizeof(char); |
| 285 | case kUByte3_GrVertexAttribType: |
| 286 | return 3 * sizeof(char); |
| 287 | case kUByte4_GrVertexAttribType: |
| 288 | return 4 * sizeof(char); |
Brian Salomon | 92be2f7 | 2018-06-19 14:33:47 -0400 | [diff] [blame] | 289 | case kUByte_norm_GrVertexAttribType: |
| 290 | return 1 * sizeof(char); |
| 291 | case kUByte4_norm_GrVertexAttribType: |
| 292 | return 4 * sizeof(char); |
| 293 | case kShort2_GrVertexAttribType: |
| 294 | return 2 * sizeof(int16_t); |
| 295 | case kUShort2_GrVertexAttribType: // fall through |
| 296 | case kUShort2_norm_GrVertexAttribType: |
| 297 | return 2 * sizeof(uint16_t); |
| 298 | case kInt_GrVertexAttribType: |
| 299 | return sizeof(int32_t); |
| 300 | case kUint_GrVertexAttribType: |
| 301 | return sizeof(uint32_t); |
| 302 | } |
| 303 | // GCC fails because SK_ABORT evaluates to non constexpr. clang and cl.exe think this is |
| 304 | // unreachable and don't complain. |
| 305 | #if defined(__clang__) || !defined(__GNUC__) |
| 306 | SK_ABORT("Unsupported type conversion"); |
| 307 | #endif |
| 308 | return 0; |
| 309 | } |
| 310 | |
| 311 | constexpr size_t GrPrimitiveProcessor::Attribute::size() const { |
| 312 | return GrVertexAttribTypeSize(fType); |
| 313 | } |
| 314 | |
joshualitt | 8072caa | 2015-02-12 14:20:52 -0800 | [diff] [blame] | 315 | #endif |