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) {
+        case kShapeTypeCircle:

[egdaniel, 2014/11/20 14:34:15]

we tend to indent the "case" inside the switch statements.

[rosca, 2014/11/20 14:52:10]

Done.

             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]);
                 }
                 fConcavePath.setFillType(SkPath::kEvenOdd_FillType);
                 SkASSERT(!fConcavePath.isConvex());
             }
             canvas->drawPath(fConcavePath, paint);
             break;
+        default:
+            break;
         }
     }
 
     virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
         if (NULL == fBG.get()) {
             static uint32_t kCheckerPixelData[] = { 0xFFFFFFFF,
                                                     0xFFCCCCCC,
                                                     0xFFCCCCCC,
                                                     0xFFFFFFFF };
             SkBitmap bitmap;
@@ skipping 14 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));
 
             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();
         }
+
+        // This draw should not affect the test's result.
+        drawWithHueOnWhite(canvas);
+    }
+
+    /**
+     * Draws white color into a white square using the hue blend mode.
+     * This will test a divide by 0 bug in the setLum function in shaders,
+     * being fixed with https://codereview.chromium.org/666043003/.

[egdaniel, 2014/11/18 14:57:16]

No need to put link to cl in the comment. The comment itself should describe the
bug enough and if need be the cl can always be found through history/blame.

[rosca, 2014/11/20 14:52:10]

Done.

+     * Without the fix, the result would be black (caused by the faulty code).
+     * With this fix the result color is white, so drawing on white should not
+     * change the expected result.
+     */
+    void drawWithHueOnWhite(SkCanvas* canvas) {
+        SkColor color = SkColorSetARGBMacro(225, 255, 255, 255);
+        SkXfermode::Mode mode = SkXfermode::kHue_Mode;
+        ShapeType shapeType = kShapeTypeConvexPath;
+
+        // Make it fit into a square.
+        SkScalar s = 0.15f;
+        // Look for a clean white square.
+        SkScalar dx = 30.f;
+        SkScalar dy = 350.f;
+
+        SkPaint p;
+        p.setAntiAlias(true);
+        p.setColor(color);
+        p.setXfermodeMode(mode);
+        canvas->save();
+        canvas->translate(dx, dy);
+        canvas->scale(s, s);
+        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);
 
 }