gm/mixedxfermodes.cpp - Issue 1215703005: kill mixedxfermodes

Side by Side Diff: gm/mixedxfermodes.cpp

Issue 1215703005: kill mixedxfermodes (Closed) Base URL: https://skia.googlesource.com/skia@master

Patch Set: Created 5 years, 6 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

OLD	NEW
	(Empty)
1

2 /*

3 * Copyright 2013 Google Inc.

4 *

5 * Use of this source code is governed by a BSD-style license that can be

6 * found in the LICENSE file.

7 */

8 #include "gm.h"

9 #include "SkBitmap.h"

10 #include "SkRandom.h"

11 #include "SkShader.h"

12 #include "SkXfermode.h"

13

14 namespace skiagm {

15

16 /**

17 * Renders overlapping shapes with random SkXfermode::Modes against a checkerboa rd.

18 */

19 class MixedXfermodesGM : public GM {

20 public:

21 MixedXfermodesGM() {

22 }

23

24 protected:

25 enum ShapeType {

26 kShapeTypeCircle,

27 kShapeTypeRoundRect,

28 kShapeTypeRect,

29 kShapeTypeConvexPath,

30 kShapeTypeConcavePath,

31 kNumShapeTypes

32 };

33

34 SkString onShortName() override {

35 return SkString("mixed_xfermodes");

36 }

37

38 SkISize onISize() override {

39 return SkISize::Make(790, 640);

40 }

41

42 void drawShape(SkCanvas* canvas,

43 const SkPaint& paint,

44 ShapeType type) {

45 static const SkRect kRect = SkRect::MakeXYWH(SkIntToScalar(-50), SkIntTo Scalar(-50),

46 SkIntToScalar(75), SkIntToS calar(105));

47 switch (type) {

48 case kShapeTypeCircle:

49 canvas->drawCircle(0, 0, 50, paint);

50 break;

51 case kShapeTypeRoundRect:

52 canvas->drawRoundRect(kRect, SkIntToScalar(10), SkIntToScalar(20 ), paint);

53 break;

54 case kShapeTypeRect:

55 canvas->drawRect(kRect, paint);

56 break;

57 case kShapeTypeConvexPath:

58 if (fConvexPath.isEmpty()) {

59 SkPoint points[4];

60 kRect.toQuad(points);

61 fConvexPath.moveTo(points[0]);

62 fConvexPath.quadTo(points[1], points[2]);

63 fConvexPath.quadTo(points[3], points[0]);

64 SkASSERT(fConvexPath.isConvex());

65 }

66 canvas->drawPath(fConvexPath, paint);

67 break;

68 case kShapeTypeConcavePath:

69 if (fConcavePath.isEmpty()) {

70 SkPoint points[5] = {{0, SkIntToScalar(-50)} };

71 SkMatrix rot;

72 rot.setRotate(SkIntToScalar(360) / 5);

73 for (int i = 1; i < 5; ++i) {

74 rot.mapPoints(points + i, points + i - 1, 1);

75 }

76 fConcavePath.moveTo(points[0]);

77 for (int i = 0; i < 5; ++i) {

78 fConcavePath.lineTo(points[(2 * i) % 5]);

79 }

80 fConcavePath.setFillType(SkPath::kEvenOdd_FillType);

81 SkASSERT(!fConcavePath.isConvex());

82 }

83 canvas->drawPath(fConcavePath, paint);

84 break;

85 default:

86 break;

87 }

88 }

89

90 void onDraw(SkCanvas* canvas) override {

91 if (NULL == fBG.get()) {

92 static uint32_t kCheckerPixelData[] = { 0xFFFFFFFF,

93 0xFFCCCCCC,

94 0xFFCCCCCC,

95 0xFFFFFFFF };

96 SkBitmap bitmap;

97 bitmap.allocN32Pixels(2, 2);

98 memcpy(bitmap.getPixels(), kCheckerPixelData, sizeof(kCheckerPixelDa ta));

99 SkMatrix lm;

100 lm.setScale(SkIntToScalar(20), SkIntToScalar(20));

101 fBG.reset(SkShader::CreateBitmapShader(bitmap,

102 SkShader::kRepeat_TileMode,

103 SkShader::kRepeat_TileMode,

104 &lm));

105 }

106

107 SkPaint bgPaint;

108 bgPaint.setShader(fBG.get());

109 canvas->drawPaint(bgPaint);

110 SkISize size = canvas->getDeviceSize();

111 SkScalar maxScale = SkScalarSqrt((SkIntToScalar(size.fWidth * size.fHeig ht))) / 300;

112 SkRandom random;

113 for (int i = 0; i < kNumShapes; ++i) {

114 SkScalar s = random.nextRangeScalar(SK_Scalar1 / 8, SK_Scalar1) * ma xScale;

115 SkScalar r = random.nextRangeScalar(0, SkIntToScalar(360));

116 SkScalar dx = random.nextRangeScalar(0, SkIntToScalar(size.fWidth));

117 SkScalar dy = random.nextRangeScalar(0, SkIntToScalar(size.fHeight)) ;

118 SkColor color = random.nextU();

119 SkXfermode::Mode mode =

120 static_cast<SkXfermode::Mode>(random.nextULessThan(SkXfermode::k LastMode + 1));

121 ShapeType shapeType = static_cast<ShapeType>(random.nextULessThan(kN umShapeTypes));

122

123 SkPaint p;

124 p.setAntiAlias(true);

125 p.setColor(color);

126 p.setXfermodeMode(mode);

127 canvas->save();

128 canvas->translate(dx, dy);

129 canvas->scale(s, s);

130 canvas->rotate(r);

131 this->drawShape(canvas, p, shapeType);

132 canvas->restore();

133 }

134

135 // This draw should not affect the test's result.

136 drawWithHueOnWhite(canvas);

137 }

138

139 /**

140 * Draws white color into a white square using the hue blend mode.

141 * The result color should be white, so it doesn't change the expectations.

142 * This will test a divide by 0 bug in shaders' setLum function,

143 * which used to output black pixels.

144 */

145 void drawWithHueOnWhite(SkCanvas* canvas) {

146 SkColor color = SkColorSetARGBMacro(225, 255, 255, 255);

147 SkXfermode::Mode mode = SkXfermode::kHue_Mode;

148 ShapeType shapeType = kShapeTypeConvexPath;

149

150 // Make it fit into a square.

151 SkScalar s = 0.15f;

152 // Look for a clean white square.

153 SkScalar dx = 30.f;

154 SkScalar dy = 350.f;

155

156 SkPaint p;

157 p.setAntiAlias(true);

158 p.setColor(color);

159 p.setXfermodeMode(mode);

160 canvas->save();

161 canvas->translate(dx, dy);

162 canvas->scale(s, s);

163 this->drawShape(canvas, p, shapeType);

164 canvas->restore();

165 }

166

167 private:

168 enum {

169 kNumShapes = 100,

170 };

171 SkAutoTUnref<SkShader> fBG;

172 SkPath fConcavePath;

173 SkPath fConvexPath;

174 typedef GM INHERITED;

175 };

176

177 //////////////////////////////////////////////////////////////////////////////

178

179 static GM* MyFactory(void*) { return new MixedXfermodesGM; }

180 static GMRegistry reg(MyFactory);

181

182 }

OLD	NEW

« no previous file with comments | « no previous file | no next file » | no next file with comments »