commit-bot@chromium.org | aa64fbf | 2014-04-03 14:59:19 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2014 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 | */ |
commit-bot@chromium.org | 2af1a2d | 2014-04-04 13:50:50 +0000 | [diff] [blame^] | 7 | |
commit-bot@chromium.org | aa64fbf | 2014-04-03 14:59:19 +0000 | [diff] [blame] | 8 | #if SK_SUPPORT_GPU |
| 9 | #include "SkTwoPointConicalGradient_gpu.h" |
| 10 | #include "GrTBackendEffectFactory.h" |
| 11 | |
| 12 | #include "SkTwoPointConicalGradient.h" |
| 13 | |
| 14 | // For brevity |
| 15 | typedef GrGLUniformManager::UniformHandle UniformHandle; |
| 16 | |
commit-bot@chromium.org | 2af1a2d | 2014-04-04 13:50:50 +0000 | [diff] [blame^] | 17 | ////////////////////////////////////////////////////////////////////////////// |
| 18 | |
| 19 | static void set_matrix_default_conical(const SkTwoPointConicalGradient& shader, |
| 20 | SkMatrix* invLMatrix) { |
| 21 | // Inverse of the current local matrix is passed in then, |
| 22 | // translate to center1, rotate so center2 is on x axis. |
| 23 | const SkPoint& center1 = shader.getStartCenter(); |
| 24 | const SkPoint& center2 = shader.getEndCenter(); |
| 25 | |
| 26 | invLMatrix->postTranslate(-center1.fX, -center1.fY); |
| 27 | |
| 28 | SkPoint diff = center2 - center1; |
| 29 | SkScalar diffLen = diff.length(); |
| 30 | if (0 != diffLen) { |
| 31 | SkScalar invDiffLen = SkScalarInvert(diffLen); |
| 32 | SkMatrix rot; |
| 33 | rot.setSinCos(-SkScalarMul(invDiffLen, diff.fY), |
| 34 | SkScalarMul(invDiffLen, diff.fX)); |
| 35 | invLMatrix->postConcat(rot); |
| 36 | } |
| 37 | } |
| 38 | |
| 39 | class GLDefault2PtConicalEffect; |
| 40 | |
| 41 | class Default2PtConicalEffect : public GrGradientEffect { |
commit-bot@chromium.org | aa64fbf | 2014-04-03 14:59:19 +0000 | [diff] [blame] | 42 | public: |
| 43 | |
commit-bot@chromium.org | 2af1a2d | 2014-04-04 13:50:50 +0000 | [diff] [blame^] | 44 | static GrEffectRef* Create(GrContext* ctx, |
| 45 | const SkTwoPointConicalGradient& shader, |
| 46 | const SkMatrix& matrix, |
| 47 | SkShader::TileMode tm) { |
| 48 | AutoEffectUnref effect(SkNEW_ARGS(Default2PtConicalEffect, (ctx, shader, matrix, tm))); |
| 49 | return CreateEffectRef(effect); |
| 50 | } |
| 51 | |
| 52 | virtual ~Default2PtConicalEffect() { } |
| 53 | |
| 54 | static const char* Name() { return "Two-Point Conical Gradient"; } |
| 55 | virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE; |
| 56 | |
| 57 | // The radial gradient parameters can collapse to a linear (instead of quadratic) equation. |
| 58 | bool isDegenerate() const { return SkScalarAbs(fDiffRadius) == SkScalarAbs(fCenterX1); } |
| 59 | SkScalar center() const { return fCenterX1; } |
| 60 | SkScalar diffRadius() const { return fDiffRadius; } |
| 61 | SkScalar radius() const { return fRadius0; } |
| 62 | |
| 63 | typedef GLDefault2PtConicalEffect GLEffect; |
| 64 | |
| 65 | private: |
| 66 | virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE { |
| 67 | const Default2PtConicalEffect& s = CastEffect<Default2PtConicalEffect>(sBase); |
| 68 | return (INHERITED::onIsEqual(sBase) && |
| 69 | this->fCenterX1 == s.fCenterX1 && |
| 70 | this->fRadius0 == s.fRadius0 && |
| 71 | this->fDiffRadius == s.fDiffRadius); |
| 72 | } |
| 73 | |
| 74 | Default2PtConicalEffect(GrContext* ctx, |
| 75 | const SkTwoPointConicalGradient& shader, |
| 76 | const SkMatrix& matrix, |
| 77 | SkShader::TileMode tm) |
| 78 | : INHERITED(ctx, shader, matrix, tm), |
| 79 | fCenterX1(shader.getCenterX1()), |
| 80 | fRadius0(shader.getStartRadius()), |
| 81 | fDiffRadius(shader.getDiffRadius()) { |
| 82 | // We pass the linear part of the quadratic as a varying. |
| 83 | // float b = -2.0 * (fCenterX1 * x + fRadius0 * fDiffRadius * z) |
| 84 | fBTransform = this->getCoordTransform(); |
| 85 | SkMatrix& bMatrix = *fBTransform.accessMatrix(); |
| 86 | SkScalar r0dr = SkScalarMul(fRadius0, fDiffRadius); |
| 87 | bMatrix[SkMatrix::kMScaleX] = -2 * (SkScalarMul(fCenterX1, bMatrix[SkMatrix::kMScaleX]) + |
| 88 | SkScalarMul(r0dr, bMatrix[SkMatrix::kMPersp0])); |
| 89 | bMatrix[SkMatrix::kMSkewX] = -2 * (SkScalarMul(fCenterX1, bMatrix[SkMatrix::kMSkewX]) + |
| 90 | SkScalarMul(r0dr, bMatrix[SkMatrix::kMPersp1])); |
| 91 | bMatrix[SkMatrix::kMTransX] = -2 * (SkScalarMul(fCenterX1, bMatrix[SkMatrix::kMTransX]) + |
| 92 | SkScalarMul(r0dr, bMatrix[SkMatrix::kMPersp2])); |
| 93 | this->addCoordTransform(&fBTransform); |
| 94 | } |
| 95 | |
| 96 | GR_DECLARE_EFFECT_TEST; |
| 97 | |
| 98 | // @{ |
| 99 | // Cache of values - these can change arbitrarily, EXCEPT |
| 100 | // we shouldn't change between degenerate and non-degenerate?! |
| 101 | |
| 102 | GrCoordTransform fBTransform; |
| 103 | SkScalar fCenterX1; |
| 104 | SkScalar fRadius0; |
| 105 | SkScalar fDiffRadius; |
| 106 | |
| 107 | // @} |
| 108 | |
| 109 | typedef GrGradientEffect INHERITED; |
| 110 | }; |
| 111 | |
| 112 | class GLDefault2PtConicalEffect : public GrGLGradientEffect { |
| 113 | public: |
| 114 | GLDefault2PtConicalEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&); |
| 115 | virtual ~GLDefault2PtConicalEffect() { } |
commit-bot@chromium.org | aa64fbf | 2014-04-03 14:59:19 +0000 | [diff] [blame] | 116 | |
| 117 | virtual void emitCode(GrGLShaderBuilder*, |
| 118 | const GrDrawEffect&, |
| 119 | EffectKey, |
| 120 | const char* outputColor, |
| 121 | const char* inputColor, |
| 122 | const TransformedCoordsArray&, |
| 123 | const TextureSamplerArray&) SK_OVERRIDE; |
| 124 | virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE; |
| 125 | |
| 126 | static EffectKey GenKey(const GrDrawEffect&, const GrGLCaps& caps); |
| 127 | |
| 128 | protected: |
commit-bot@chromium.org | aa64fbf | 2014-04-03 14:59:19 +0000 | [diff] [blame] | 129 | UniformHandle fParamUni; |
| 130 | |
| 131 | const char* fVSVaryingName; |
| 132 | const char* fFSVaryingName; |
| 133 | |
| 134 | bool fIsDegenerate; |
| 135 | |
| 136 | // @{ |
| 137 | /// Values last uploaded as uniforms |
| 138 | |
| 139 | SkScalar fCachedCenter; |
| 140 | SkScalar fCachedRadius; |
| 141 | SkScalar fCachedDiffRadius; |
| 142 | |
| 143 | // @} |
| 144 | |
| 145 | private: |
commit-bot@chromium.org | aa64fbf | 2014-04-03 14:59:19 +0000 | [diff] [blame] | 146 | typedef GrGLGradientEffect INHERITED; |
| 147 | |
| 148 | }; |
| 149 | |
commit-bot@chromium.org | 2af1a2d | 2014-04-04 13:50:50 +0000 | [diff] [blame^] | 150 | const GrBackendEffectFactory& Default2PtConicalEffect::getFactory() const { |
| 151 | return GrTBackendEffectFactory<Default2PtConicalEffect>::getInstance(); |
commit-bot@chromium.org | aa64fbf | 2014-04-03 14:59:19 +0000 | [diff] [blame] | 152 | } |
skia.committer@gmail.com | 221b911 | 2014-04-04 03:04:32 +0000 | [diff] [blame] | 153 | |
commit-bot@chromium.org | 2af1a2d | 2014-04-04 13:50:50 +0000 | [diff] [blame^] | 154 | GR_DEFINE_EFFECT_TEST(Default2PtConicalEffect); |
commit-bot@chromium.org | aa64fbf | 2014-04-03 14:59:19 +0000 | [diff] [blame] | 155 | |
commit-bot@chromium.org | 2af1a2d | 2014-04-04 13:50:50 +0000 | [diff] [blame^] | 156 | GrEffectRef* Default2PtConicalEffect::TestCreate(SkRandom* random, |
commit-bot@chromium.org | aa64fbf | 2014-04-03 14:59:19 +0000 | [diff] [blame] | 157 | GrContext* context, |
| 158 | const GrDrawTargetCaps&, |
| 159 | GrTexture**) { |
| 160 | SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()}; |
| 161 | SkScalar radius1 = random->nextUScalar1(); |
| 162 | SkPoint center2; |
| 163 | SkScalar radius2; |
| 164 | do { |
| 165 | center2.set(random->nextUScalar1(), random->nextUScalar1()); |
| 166 | radius2 = random->nextUScalar1 (); |
| 167 | // If the circles are identical the factory will give us an empty shader. |
| 168 | } while (radius1 == radius2 && center1 == center2); |
| 169 | |
| 170 | SkColor colors[kMaxRandomGradientColors]; |
| 171 | SkScalar stopsArray[kMaxRandomGradientColors]; |
| 172 | SkScalar* stops = stopsArray; |
| 173 | SkShader::TileMode tm; |
| 174 | int colorCount = RandomGradientParams(random, colors, &stops, &tm); |
| 175 | SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center1, radius1, |
| 176 | center2, radius2, |
| 177 | colors, stops, colorCount, |
| 178 | tm)); |
| 179 | SkPaint paint; |
| 180 | return shader->asNewEffect(context, paint); |
| 181 | } |
| 182 | |
| 183 | |
| 184 | ///////////////////////////////////////////////////////////////////// |
| 185 | |
commit-bot@chromium.org | 2af1a2d | 2014-04-04 13:50:50 +0000 | [diff] [blame^] | 186 | GLDefault2PtConicalEffect::GLDefault2PtConicalEffect(const GrBackendEffectFactory& factory, |
commit-bot@chromium.org | aa64fbf | 2014-04-03 14:59:19 +0000 | [diff] [blame] | 187 | const GrDrawEffect& drawEffect) |
| 188 | : INHERITED(factory) |
| 189 | , fVSVaryingName(NULL) |
| 190 | , fFSVaryingName(NULL) |
| 191 | , fCachedCenter(SK_ScalarMax) |
| 192 | , fCachedRadius(-SK_ScalarMax) |
| 193 | , fCachedDiffRadius(-SK_ScalarMax) { |
| 194 | |
commit-bot@chromium.org | 2af1a2d | 2014-04-04 13:50:50 +0000 | [diff] [blame^] | 195 | const Default2PtConicalEffect& data = drawEffect.castEffect<Default2PtConicalEffect>(); |
commit-bot@chromium.org | aa64fbf | 2014-04-03 14:59:19 +0000 | [diff] [blame] | 196 | fIsDegenerate = data.isDegenerate(); |
| 197 | } |
| 198 | |
commit-bot@chromium.org | 2af1a2d | 2014-04-04 13:50:50 +0000 | [diff] [blame^] | 199 | void GLDefault2PtConicalEffect::emitCode(GrGLShaderBuilder* builder, |
commit-bot@chromium.org | aa64fbf | 2014-04-03 14:59:19 +0000 | [diff] [blame] | 200 | const GrDrawEffect&, |
| 201 | EffectKey key, |
| 202 | const char* outputColor, |
| 203 | const char* inputColor, |
| 204 | const TransformedCoordsArray& coords, |
| 205 | const TextureSamplerArray& samplers) { |
| 206 | this->emitUniforms(builder, key); |
| 207 | fParamUni = builder->addUniformArray(GrGLShaderBuilder::kFragment_Visibility, |
| 208 | kFloat_GrSLType, "Conical2FSParams", 6); |
| 209 | |
| 210 | SkString cName("c"); |
| 211 | SkString ac4Name("ac4"); |
| 212 | SkString dName("d"); |
| 213 | SkString qName("q"); |
| 214 | SkString r0Name("r0"); |
| 215 | SkString r1Name("r1"); |
| 216 | SkString tName("t"); |
| 217 | SkString p0; // 4a |
| 218 | SkString p1; // 1/a |
| 219 | SkString p2; // distance between centers |
| 220 | SkString p3; // start radius |
| 221 | SkString p4; // start radius squared |
| 222 | SkString p5; // difference in radii (r1 - r0) |
| 223 | |
| 224 | builder->getUniformVariable(fParamUni).appendArrayAccess(0, &p0); |
| 225 | builder->getUniformVariable(fParamUni).appendArrayAccess(1, &p1); |
| 226 | builder->getUniformVariable(fParamUni).appendArrayAccess(2, &p2); |
| 227 | builder->getUniformVariable(fParamUni).appendArrayAccess(3, &p3); |
| 228 | builder->getUniformVariable(fParamUni).appendArrayAccess(4, &p4); |
| 229 | builder->getUniformVariable(fParamUni).appendArrayAccess(5, &p5); |
| 230 | |
| 231 | // We interpolate the linear component in coords[1]. |
| 232 | SkASSERT(coords[0].type() == coords[1].type()); |
| 233 | const char* coords2D; |
| 234 | SkString bVar; |
| 235 | if (kVec3f_GrSLType == coords[0].type()) { |
| 236 | builder->fsCodeAppendf("\tvec3 interpolants = vec3(%s.xy, %s.x) / %s.z;\n", |
| 237 | coords[0].c_str(), coords[1].c_str(), coords[0].c_str()); |
| 238 | coords2D = "interpolants.xy"; |
| 239 | bVar = "interpolants.z"; |
| 240 | } else { |
| 241 | coords2D = coords[0].c_str(); |
| 242 | bVar.printf("%s.x", coords[1].c_str()); |
| 243 | } |
| 244 | |
| 245 | // output will default to transparent black (we simply won't write anything |
| 246 | // else to it if invalid, instead of discarding or returning prematurely) |
| 247 | builder->fsCodeAppendf("\t%s = vec4(0.0,0.0,0.0,0.0);\n", outputColor); |
| 248 | |
| 249 | // c = (x^2)+(y^2) - params[4] |
| 250 | builder->fsCodeAppendf("\tfloat %s = dot(%s, %s) - %s;\n", |
| 251 | cName.c_str(), coords2D, coords2D, p4.c_str()); |
| 252 | |
| 253 | // Non-degenerate case (quadratic) |
| 254 | if (!fIsDegenerate) { |
| 255 | |
| 256 | // ac4 = params[0] * c |
| 257 | builder->fsCodeAppendf("\tfloat %s = %s * %s;\n", ac4Name.c_str(), p0.c_str(), |
| 258 | cName.c_str()); |
| 259 | |
| 260 | // d = b^2 - ac4 |
| 261 | builder->fsCodeAppendf("\tfloat %s = %s * %s - %s;\n", dName.c_str(), |
| 262 | bVar.c_str(), bVar.c_str(), ac4Name.c_str()); |
| 263 | |
| 264 | // only proceed if discriminant is >= 0 |
| 265 | builder->fsCodeAppendf("\tif (%s >= 0.0) {\n", dName.c_str()); |
| 266 | |
| 267 | // intermediate value we'll use to compute the roots |
| 268 | // q = -0.5 * (b +/- sqrt(d)) |
| 269 | builder->fsCodeAppendf("\t\tfloat %s = -0.5 * (%s + (%s < 0.0 ? -1.0 : 1.0)" |
| 270 | " * sqrt(%s));\n", qName.c_str(), bVar.c_str(), |
| 271 | bVar.c_str(), dName.c_str()); |
| 272 | |
| 273 | // compute both roots |
| 274 | // r0 = q * params[1] |
| 275 | builder->fsCodeAppendf("\t\tfloat %s = %s * %s;\n", r0Name.c_str(), |
| 276 | qName.c_str(), p1.c_str()); |
| 277 | // r1 = c / q |
| 278 | builder->fsCodeAppendf("\t\tfloat %s = %s / %s;\n", r1Name.c_str(), |
| 279 | cName.c_str(), qName.c_str()); |
| 280 | |
| 281 | // Note: If there are two roots that both generate radius(t) > 0, the |
| 282 | // Canvas spec says to choose the larger t. |
| 283 | |
| 284 | // so we'll look at the larger one first: |
| 285 | builder->fsCodeAppendf("\t\tfloat %s = max(%s, %s);\n", tName.c_str(), |
| 286 | r0Name.c_str(), r1Name.c_str()); |
| 287 | |
| 288 | // if r(t) > 0, then we're done; t will be our x coordinate |
| 289 | builder->fsCodeAppendf("\t\tif (%s * %s + %s > 0.0) {\n", tName.c_str(), |
| 290 | p5.c_str(), p3.c_str()); |
| 291 | |
| 292 | builder->fsCodeAppend("\t\t"); |
| 293 | this->emitColor(builder, tName.c_str(), key, outputColor, inputColor, samplers); |
| 294 | |
| 295 | // otherwise, if r(t) for the larger root was <= 0, try the other root |
| 296 | builder->fsCodeAppend("\t\t} else {\n"); |
| 297 | builder->fsCodeAppendf("\t\t\t%s = min(%s, %s);\n", tName.c_str(), |
| 298 | r0Name.c_str(), r1Name.c_str()); |
| 299 | |
| 300 | // if r(t) > 0 for the smaller root, then t will be our x coordinate |
| 301 | builder->fsCodeAppendf("\t\t\tif (%s * %s + %s > 0.0) {\n", |
| 302 | tName.c_str(), p5.c_str(), p3.c_str()); |
| 303 | |
| 304 | builder->fsCodeAppend("\t\t\t"); |
| 305 | this->emitColor(builder, tName.c_str(), key, outputColor, inputColor, samplers); |
| 306 | |
| 307 | // end if (r(t) > 0) for smaller root |
| 308 | builder->fsCodeAppend("\t\t\t}\n"); |
| 309 | // end if (r(t) > 0), else, for larger root |
| 310 | builder->fsCodeAppend("\t\t}\n"); |
| 311 | // end if (discriminant >= 0) |
| 312 | builder->fsCodeAppend("\t}\n"); |
| 313 | } else { |
| 314 | |
| 315 | // linear case: t = -c/b |
| 316 | builder->fsCodeAppendf("\tfloat %s = -(%s / %s);\n", tName.c_str(), |
| 317 | cName.c_str(), bVar.c_str()); |
| 318 | |
| 319 | // if r(t) > 0, then t will be the x coordinate |
| 320 | builder->fsCodeAppendf("\tif (%s * %s + %s > 0.0) {\n", tName.c_str(), |
| 321 | p5.c_str(), p3.c_str()); |
| 322 | builder->fsCodeAppend("\t"); |
| 323 | this->emitColor(builder, tName.c_str(), key, outputColor, inputColor, samplers); |
| 324 | builder->fsCodeAppend("\t}\n"); |
| 325 | } |
| 326 | } |
| 327 | |
commit-bot@chromium.org | 2af1a2d | 2014-04-04 13:50:50 +0000 | [diff] [blame^] | 328 | void GLDefault2PtConicalEffect::setData(const GrGLUniformManager& uman, |
commit-bot@chromium.org | aa64fbf | 2014-04-03 14:59:19 +0000 | [diff] [blame] | 329 | const GrDrawEffect& drawEffect) { |
| 330 | INHERITED::setData(uman, drawEffect); |
commit-bot@chromium.org | 2af1a2d | 2014-04-04 13:50:50 +0000 | [diff] [blame^] | 331 | const Default2PtConicalEffect& data = drawEffect.castEffect<Default2PtConicalEffect>(); |
commit-bot@chromium.org | aa64fbf | 2014-04-03 14:59:19 +0000 | [diff] [blame] | 332 | SkASSERT(data.isDegenerate() == fIsDegenerate); |
| 333 | SkScalar centerX1 = data.center(); |
| 334 | SkScalar radius0 = data.radius(); |
| 335 | SkScalar diffRadius = data.diffRadius(); |
| 336 | |
| 337 | if (fCachedCenter != centerX1 || |
| 338 | fCachedRadius != radius0 || |
| 339 | fCachedDiffRadius != diffRadius) { |
| 340 | |
| 341 | SkScalar a = SkScalarMul(centerX1, centerX1) - diffRadius * diffRadius; |
| 342 | |
| 343 | // When we're in the degenerate (linear) case, the second |
| 344 | // value will be INF but the program doesn't read it. (We |
| 345 | // use the same 6 uniforms even though we don't need them |
| 346 | // all in the linear case just to keep the code complexity |
| 347 | // down). |
| 348 | float values[6] = { |
| 349 | SkScalarToFloat(a * 4), |
| 350 | 1.f / (SkScalarToFloat(a)), |
| 351 | SkScalarToFloat(centerX1), |
| 352 | SkScalarToFloat(radius0), |
| 353 | SkScalarToFloat(SkScalarMul(radius0, radius0)), |
| 354 | SkScalarToFloat(diffRadius) |
| 355 | }; |
| 356 | |
| 357 | uman.set1fv(fParamUni, 6, values); |
| 358 | fCachedCenter = centerX1; |
| 359 | fCachedRadius = radius0; |
| 360 | fCachedDiffRadius = diffRadius; |
| 361 | } |
| 362 | } |
| 363 | |
commit-bot@chromium.org | 2af1a2d | 2014-04-04 13:50:50 +0000 | [diff] [blame^] | 364 | GrGLEffect::EffectKey GLDefault2PtConicalEffect::GenKey(const GrDrawEffect& drawEffect, |
commit-bot@chromium.org | aa64fbf | 2014-04-03 14:59:19 +0000 | [diff] [blame] | 365 | const GrGLCaps&) { |
| 366 | enum { |
| 367 | kIsDegenerate = 1 << kBaseKeyBitCnt, |
| 368 | }; |
| 369 | |
| 370 | EffectKey key = GenBaseGradientKey(drawEffect); |
commit-bot@chromium.org | 2af1a2d | 2014-04-04 13:50:50 +0000 | [diff] [blame^] | 371 | if (drawEffect.castEffect<Default2PtConicalEffect>().isDegenerate()) { |
commit-bot@chromium.org | aa64fbf | 2014-04-03 14:59:19 +0000 | [diff] [blame] | 372 | key |= kIsDegenerate; |
| 373 | } |
| 374 | return key; |
| 375 | } |
commit-bot@chromium.org | 2af1a2d | 2014-04-04 13:50:50 +0000 | [diff] [blame^] | 376 | |
| 377 | ////////////////////////////////////////////////////////////////////////////// |
| 378 | |
| 379 | GrEffectRef* Gr2PtConicalGradientEffect::Create(GrContext* ctx, |
| 380 | const SkTwoPointConicalGradient& shader, |
| 381 | SkShader::TileMode tm) { |
| 382 | |
| 383 | SkMatrix matrix; |
| 384 | if (!shader.getLocalMatrix().invert(&matrix)) { |
| 385 | return NULL; |
| 386 | } |
| 387 | |
| 388 | set_matrix_default_conical(shader, &matrix); |
| 389 | return Default2PtConicalEffect::Create(ctx, shader, matrix, tm); |
| 390 | } |
| 391 | |
commit-bot@chromium.org | aa64fbf | 2014-04-03 14:59:19 +0000 | [diff] [blame] | 392 | #endif |