Preventing division by 0 in non-separable blend mode shaders.

gm/mixedxfermodes.cpp

 
 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "gm.h"
 #include "SkBitmap.h"
 #include "SkRandom.h"
 #include "SkShader.h"
 #include "SkXfermode.h"
 
 namespace skiagm {
 
 /**
  * Renders overlapping shapes with random SkXfermode::Modes against a checkerboard.
  */
 class MixedXfermodesGM : public GM {
 public:
     MixedXfermodesGM() {
     }
 
 protected:
+    enum ShapeType {
+        kShapeTypeCircle,
+        kShapeTypeRoundRect,
+        kShapeTypeRect,
+        kShapeTypeConvexPath,
+        kShapeTypeConcavePath,
+        kNumShapeTypes
+    };
+
     virtual SkString onShortName() SK_OVERRIDE {
         return SkString("mixed_xfermodes");
     }
 
     virtual SkISize onISize() SK_OVERRIDE {
         return SkISize::Make(790, 640);
     }
 
     void drawShape(SkCanvas* canvas,
                    const SkPaint& paint,
-                   SkRandom* random) {
+                   ShapeType type) {
         static const SkRect kRect = SkRect::MakeXYWH(SkIntToScalar(-50), SkIntToScalar(-50),
                                                      SkIntToScalar(75), SkIntToScalar(105));
-        int shape = random->nextULessThan(5);
-        switch (shape) {
-        case 0:
+        switch (type) {

[egdaniel, 2014/11/14 16:08:21]

You need to have a default case or else there will be errors for kNumShapeTypes
not being handled by the switch in certain compilers

[rosca, 2014/11/17 16:09:31]

Done.

+        case kShapeTypeCircle:
             canvas->drawCircle(0, 0, 50, paint);
             break;
-        case 1:
+        case kShapeTypeRoundRect:
             canvas->drawRoundRect(kRect, SkIntToScalar(10), SkIntToScalar(20), paint);
             break;
-        case 2:
+        case kShapeTypeRect:
             canvas->drawRect(kRect, paint);
             break;
-        case 3:
+        case kShapeTypeConvexPath:
             if (fConvexPath.isEmpty()) {
                 SkPoint points[4];
                 kRect.toQuad(points);
                 fConvexPath.moveTo(points[0]);
                 fConvexPath.quadTo(points[1], points[2]);
                 fConvexPath.quadTo(points[3], points[0]);
                 SkASSERT(fConvexPath.isConvex());
             }
             canvas->drawPath(fConvexPath, paint);
             break;
-        case 4:
+        case kShapeTypeConcavePath:
             if (fConcavePath.isEmpty()) {
                 SkPoint points[5] = {{0, SkIntToScalar(-50)} };
                 SkMatrix rot;
                 rot.setRotate(SkIntToScalar(360) / 5);
                 for (int i = 1; i < 5; ++i) {
                     rot.mapPoints(points + i, points + i - 1, 1);
                 }
                 fConcavePath.moveTo(points[0]);
                 for (int i = 0; i < 5; ++i) {
                     fConcavePath.lineTo(points[(2 * i) % 5]);
@@ skipping 30 matching lines @@
         SkScalar maxScale = SkScalarSqrt((SkIntToScalar(size.fWidth * size.fHeight))) / 300;
         SkRandom random;
         for (int i = 0; i < kNumShapes; ++i) {
             SkScalar s = random.nextRangeScalar(SK_Scalar1 / 8, SK_Scalar1) * maxScale;
             SkScalar r = random.nextRangeScalar(0, SkIntToScalar(360));
             SkScalar dx = random.nextRangeScalar(0, SkIntToScalar(size.fWidth));
             SkScalar dy = random.nextRangeScalar(0, SkIntToScalar(size.fHeight));
             SkColor color = random.nextU();
             SkXfermode::Mode mode =
                 static_cast<SkXfermode::Mode>(random.nextULessThan(SkXfermode::kLastMode + 1));
+            ShapeType shapeType = static_cast<ShapeType>(random.nextULessThan(kNumShapeTypes));
+
+            if (i == kNumShapes - 1) {

[egdaniel, 2014/11/14 16:08:21]

Since what you want to test ends up drawing nothing (or I believe that's what it
does from your previous patch), it would probably be best to not change any of
the current draws in this loop, and make a function like
draw_lum_zero_whatever_mode(canvas) that you call after the for loop (obviously
you need a better name than that). Give a good comment on the function as to why
it is there, its function, and that it should not actually do any draws.

The main advantage of this is that we can easily document the specific test case
we are looking at, and it shouldn't alter the gm (assuming nothing draws) so you
will not need to rebase afterwards.

[rosca, 2014/11/17 16:09:31]

Done.

+                color = SkColorSetARGBMacro(225, 100, 100, 100);
+                mode = SkXfermode::kSaturation_Mode;
+                shapeType = kShapeTypeConvexPath;
+            }
 
             SkPaint p;
             p.setAntiAlias(true);
             p.setColor(color);
             p.setXfermodeMode(mode);
             canvas->save();
             canvas->translate(dx, dy);
             canvas->scale(s, s);
             canvas->rotate(r);
-            this->drawShape(canvas, p, &random);
+            this->drawShape(canvas, p, shapeType);
             canvas->restore();
         }
     }
 
     virtual uint32_t onGetFlags() const {
         // Skip PDF rasterization since rendering this PDF takes forever.
         return kSkipPDFRasterization_Flag | kSkipTiled_Flag;
     }
 
 private:
     enum {
         kNumShapes = 100,
     };
     SkAutoTUnref<SkShader> fBG;
     SkPath                 fConcavePath;
     SkPath                 fConvexPath;
     typedef GM INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 static GM* MyFactory(void*) { return new MixedXfermodesGM; }
 static GMRegistry reg(MyFactory);
 
 }