OLD | NEW |
1 | 1 |
2 /* | 2 /* |
3 * Copyright 2014 Google Inc. | 3 * Copyright 2014 Google Inc. |
4 * | 4 * |
5 * Use of this source code is governed by a BSD-style license that can be | 5 * Use of this source code is governed by a BSD-style license that can be |
6 * found in the LICENSE file. | 6 * found in the LICENSE file. |
7 */ | 7 */ |
8 | 8 |
9 // This test only works with the GPU backend. | 9 #include "gm.h" |
| 10 #include "SkGradientShader.h" |
| 11 #include "SkPatchUtils.h" |
10 | 12 |
11 #include "gm.h" | 13 static SkShader* make_shader() { |
| 14 const SkColor colors[] = { |
| 15 SK_ColorRED, SK_ColorCYAN, SK_ColorGREEN, SK_ColorWHITE, SK_ColorMAGENTA
, SK_ColorBLUE, |
| 16 SK_ColorYELLOW, |
| 17 }; |
| 18 const SkPoint pts[] = { { 100.f / 4.f, 0.f }, { 3.f * 100.f / 4.f, 100.f } }
; |
| 19 |
| 20 return SkGradientShader::CreateLinear(pts, colors, NULL, SK_ARRAY_COUNT(colo
rs), |
| 21 SkShader::kMirror_TileMode); |
| 22 } |
12 | 23 |
13 #if SK_SUPPORT_GPU | 24 static void draw_control_points(SkCanvas* canvas, const SkPoint cubics[12]) { |
14 | |
15 #include "GrContext.h" | |
16 #include "GrTest.h" | |
17 #include "SkPatch.h" | |
18 | |
19 static void draw_control_points(SkCanvas* canvas, const SkPatch& patch) { | |
20 //draw control points | 25 //draw control points |
21 SkPaint paint; | 26 SkPaint paint; |
22 SkPoint bottom[SkPatch::kNumPtsCubic]; | 27 SkPoint bottom[SkPatchUtils::kNumPtsCubic]; |
23 patch.getBottomPoints(bottom); | 28 SkPatchUtils::getBottomCubic(cubics, bottom); |
24 SkPoint top[SkPatch::kNumPtsCubic]; | 29 SkPoint top[SkPatchUtils::kNumPtsCubic]; |
25 patch.getTopPoints(top); | 30 SkPatchUtils::getTopCubic(cubics, top); |
26 SkPoint left[SkPatch::kNumPtsCubic]; | 31 SkPoint left[SkPatchUtils::kNumPtsCubic]; |
27 patch.getLeftPoints(left); | 32 SkPatchUtils::getLeftCubic(cubics, left); |
28 SkPoint right[SkPatch::kNumPtsCubic]; | 33 SkPoint right[SkPatchUtils::kNumPtsCubic]; |
29 patch.getRightPoints(right); | 34 SkPatchUtils::getRightCubic(cubics, right); |
30 | 35 |
31 paint.setColor(SK_ColorBLACK); | 36 paint.setColor(SK_ColorBLACK); |
32 paint.setStrokeWidth(0.5); | 37 paint.setStrokeWidth(0.5f); |
33 SkPoint corners[4] = { bottom[0], bottom[3], top[0], top[3] }; | 38 SkPoint corners[4] = { bottom[0], bottom[3], top[0], top[3] }; |
34 canvas->drawPoints(SkCanvas::kLines_PointMode, 4, bottom, paint); | 39 canvas->drawPoints(SkCanvas::kLines_PointMode, 4, bottom, paint); |
35 canvas->drawPoints(SkCanvas::kLines_PointMode, 2, bottom+1, paint); | 40 canvas->drawPoints(SkCanvas::kLines_PointMode, 2, bottom + 1, paint); |
36 canvas->drawPoints(SkCanvas::kLines_PointMode, 4, top, paint); | 41 canvas->drawPoints(SkCanvas::kLines_PointMode, 4, top, paint); |
37 canvas->drawPoints(SkCanvas::kLines_PointMode, 4, left, paint); | 42 canvas->drawPoints(SkCanvas::kLines_PointMode, 4, left, paint); |
38 canvas->drawPoints(SkCanvas::kLines_PointMode, 4, right, paint); | 43 canvas->drawPoints(SkCanvas::kLines_PointMode, 4, right, paint); |
39 | 44 |
40 canvas->drawPoints(SkCanvas::kLines_PointMode, 2, top+1, paint); | 45 canvas->drawPoints(SkCanvas::kLines_PointMode, 2, top + 1, paint); |
41 canvas->drawPoints(SkCanvas::kLines_PointMode, 2, left+1, paint); | 46 canvas->drawPoints(SkCanvas::kLines_PointMode, 2, left + 1, paint); |
42 canvas->drawPoints(SkCanvas::kLines_PointMode, 2, right+1, paint); | 47 canvas->drawPoints(SkCanvas::kLines_PointMode, 2, right + 1, paint); |
43 | 48 |
44 paint.setStrokeWidth(2); | 49 paint.setStrokeWidth(2); |
45 | 50 |
46 paint.setColor(SK_ColorRED); | 51 paint.setColor(SK_ColorRED); |
47 canvas->drawPoints(SkCanvas::kPoints_PointMode, 4, corners, paint); | 52 canvas->drawPoints(SkCanvas::kPoints_PointMode, 4, corners, paint); |
48 | 53 |
49 paint.setColor(SK_ColorBLUE); | 54 paint.setColor(SK_ColorBLUE); |
50 canvas->drawPoints(SkCanvas::kPoints_PointMode, 2, bottom+1, paint); | 55 canvas->drawPoints(SkCanvas::kPoints_PointMode, 2, bottom + 1, paint); |
51 | 56 |
52 paint.setColor(SK_ColorCYAN); | 57 paint.setColor(SK_ColorCYAN); |
53 canvas->drawPoints(SkCanvas::kPoints_PointMode, 2, top+1, paint); | 58 canvas->drawPoints(SkCanvas::kPoints_PointMode, 2, top + 1, paint); |
54 | 59 |
55 paint.setColor(SK_ColorYELLOW); | 60 paint.setColor(SK_ColorYELLOW); |
56 canvas->drawPoints(SkCanvas::kPoints_PointMode, 2, left+1, paint); | 61 canvas->drawPoints(SkCanvas::kPoints_PointMode, 2, left + 1, paint); |
57 | 62 |
58 paint.setColor(SK_ColorGREEN); | 63 paint.setColor(SK_ColorGREEN); |
59 canvas->drawPoints(SkCanvas::kPoints_PointMode, 2, right+1, paint); | 64 canvas->drawPoints(SkCanvas::kPoints_PointMode, 2, right + 1, paint); |
60 } | 65 } |
61 | 66 |
62 namespace skiagm { | 67 namespace skiagm { |
63 /** | 68 /** |
64 * This GM draws a SkPatch. | 69 * This GM draws a cubics coons patch using the specialized call SkCanvas::drawP
atch. |
65 */ | 70 */ |
66 class SkPatchGM : public GM { | 71 class SkPatchGM : public GM { |
67 | 72 |
68 public: | 73 public: |
69 SkPatchGM() { | 74 SkPatchGM() { |
70 this->setBGColor(0xFFFFFFFF); | 75 this->setBGColor(0xFFFFFFFF); |
71 } | 76 } |
72 | 77 |
73 protected: | 78 protected: |
74 virtual SkString onShortName() SK_OVERRIDE { | 79 virtual SkString onShortName() SK_OVERRIDE { |
75 return SkString("patch_primitive"); | 80 return SkString("patch_primitive"); |
76 } | 81 } |
77 | 82 |
78 virtual SkISize onISize() SK_OVERRIDE { | 83 virtual SkISize onISize() SK_OVERRIDE { |
79 return SkISize::Make(800, 800); | 84 return SkISize::Make(800, 800); |
80 } | 85 } |
81 | 86 |
82 virtual uint32_t onGetFlags() const SK_OVERRIDE { | 87 virtual uint32_t onGetFlags() const SK_OVERRIDE { |
83 return kSkipTiled_Flag; | 88 return kSkipTiled_Flag; |
84 } | 89 } |
85 | 90 |
86 virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE { | 91 virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE { |
87 | 92 |
88 SkPaint paint; | 93 SkPaint paint; |
89 | 94 |
90 // The order of the colors and points is clockwise starting at upper-lef
t corner. | 95 // The order of the colors and points is clockwise starting at upper-lef
t corner. |
91 SkColor colors[SkPatch::kNumColors] = { | 96 const SkPoint cubics[SkPatchUtils::kNumCtrlPts] = { |
| 97 //top points |
| 98 {100,100},{150,50},{250,150}, {300,100}, |
| 99 //right points |
| 100 {250, 150},{350,250}, |
| 101 //bottom points |
| 102 {300,300},{250,250},{150,350},{100,300}, |
| 103 //left points |
| 104 {50,250},{150,150} |
| 105 }; |
| 106 |
| 107 const SkColor colors[SkPatchUtils::kNumCorners] = { |
92 SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorCYAN | 108 SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorCYAN |
93 }; | 109 }; |
94 SkPoint points[SkPatch::kNumCtrlPts] = { | 110 const SkPoint texCoords[SkPatchUtils::kNumCorners] = { |
95 //top points | 111 {0.0f, 0.0f}, {100.0f, 0.0f}, {100.0f,100.0f}, {0.0f, 100.0f}} |
96 {50,50},{75,20},{125,80}, {150,50}, | 112 ; |
97 //right points | 113 |
98 {120,75},{180,125}, | 114 const SkXfermode::Mode modes[] = { |
99 //bottom points | 115 SkXfermode::kSrc_Mode, |
100 {150,150},{125,120},{75,180},{50,150}, | 116 SkXfermode::kDst_Mode, |
101 //left points | 117 SkXfermode::kModulate_Mode, |
102 {20,125},{80,75} | |
103 }; | 118 }; |
104 | 119 |
105 SkPatch patch(points, colors); | 120 SkAutoTUnref<SkShader> shader(make_shader()); |
106 static const SkScalar kScale = 0.5f; | 121 |
107 canvas->translate(100, 100); | |
108 canvas->save(); | 122 canvas->save(); |
109 for (SkScalar x = 0; x < 4; x++) { | 123 for (int y = 0; y < 3; y++) { |
110 canvas->save(); | 124 SkAutoTUnref<SkXfermode> xfer(SkXfermode::Create(modes[y])); |
111 canvas->scale(kScale * (x + 1), kScale * (x + 1)); | 125 |
112 canvas->translate(x * 100, 0); | 126 for (int x = 0; x < 4; x++) { |
113 canvas->drawPatch(patch, paint); | 127 canvas->save(); |
114 draw_control_points(canvas, patch); | 128 canvas->translate(x * 350.0f, y * 350.0f); |
115 canvas->restore(); | 129 switch (x) { |
116 } | 130 case 0: |
117 | 131 canvas->drawPatch(cubics, NULL, NULL, xfer, paint); |
118 canvas->translate(0, 270); | 132 break; |
119 | 133 case 1: |
120 static const SkScalar kSkew = 0.2f; | 134 canvas->drawPatch(cubics, colors, NULL, xfer, paint); |
121 for (SkScalar x = 0; x < 4; x++) { | 135 break; |
122 canvas->save(); | 136 case 2: |
123 canvas->scale(kScale * (x + 1), kScale * (x + 1)); | 137 paint.setShader(shader); |
124 canvas->translate(x * 100, 0); | 138 canvas->drawPatch(cubics, NULL, texCoords, xfer, paint); |
125 canvas->skew(kSkew * (x + 1), kSkew * (x + 1)); | 139 paint.setShader(NULL); |
126 canvas->drawPatch(patch, paint); | 140 break; |
127 draw_control_points(canvas, patch); | 141 case 3: |
128 canvas->restore(); | 142 paint.setShader(shader); |
| 143 canvas->drawPatch(cubics, colors, texCoords, xfer, paint
); |
| 144 paint.setShader(NULL); |
| 145 break; |
| 146 default: |
| 147 break; |
| 148 } |
| 149 |
| 150 draw_control_points(canvas, cubics); |
| 151 canvas->restore(); |
| 152 } |
129 } | 153 } |
130 canvas->restore(); | 154 canvas->restore(); |
131 } | 155 } |
132 | 156 |
133 private: | 157 private: |
134 typedef GM INHERITED; | 158 typedef GM INHERITED; |
135 }; | 159 }; |
136 | 160 |
137 DEF_GM(return SkNEW(SkPatchGM); ) | 161 DEF_GM(return SkNEW(SkPatchGM); ) |
138 | 162 |
139 } | 163 } |
140 | |
141 #endif | |
OLD | NEW |