OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2014 Google Inc. | 2 * Copyright 2014 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 #include "Benchmark.h" | 7 #include "Benchmark.h" |
8 #include "SkBitmap.h" | |
9 #include "SkCanvas.h" | 8 #include "SkCanvas.h" |
10 #include "SkColorPriv.h" | |
11 #include "SkGradientShader.h" | 9 #include "SkGradientShader.h" |
12 #include "SkPaint.h" | 10 #include "SkPaint.h" |
13 #include "SkPatchUtils.h" | 11 #include "SkPatchUtils.h" |
14 #include "SkRandom.h" | |
15 #include "SkShader.h" | |
16 #include "SkString.h" | 12 #include "SkString.h" |
17 #include "SkTArray.h" | 13 |
| 14 /** |
| 15 * This bench measures the rendering time of the call SkCanvas::drawPatch with d
ifferent types of |
| 16 * input patches (regular case, with loops, a square, with a big difference betw
een "parallel" |
| 17 * sides). This bench also tests the different combination of optional parameter
s for the function |
| 18 * (passing texture coordinates and colors, only textures coordinates, only colo
rs or none). |
| 19 * Finally, it applies a scale to test if the size affects the rendering time. |
| 20 */ |
18 | 21 |
19 class PatchBench : public Benchmark { | 22 class PatchBench : public Benchmark { |
20 | 23 |
21 public: | 24 public: |
22 | 25 |
23 enum VertexMode { | 26 enum VertexMode { |
24 kNone_VertexMode, | 27 kNone_VertexMode, |
25 kColors_VertexMode, | 28 kColors_VertexMode, |
26 kTexCoords_VertexMode, | 29 kTexCoords_VertexMode, |
27 kBoth_VertexMode | 30 kBoth_VertexMode |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
85 case kNone_VertexMode: | 88 case kNone_VertexMode: |
86 vertexMode.set("meshlines"); | 89 vertexMode.set("meshlines"); |
87 break; | 90 break; |
88 case kColors_VertexMode: | 91 case kColors_VertexMode: |
89 vertexMode.set("colors"); | 92 vertexMode.set("colors"); |
90 break; | 93 break; |
91 case kTexCoords_VertexMode: | 94 case kTexCoords_VertexMode: |
92 vertexMode.set("texs"); | 95 vertexMode.set("texs"); |
93 break; | 96 break; |
94 case kBoth_VertexMode: | 97 case kBoth_VertexMode: |
95 vertexMode.set("colors&texs"); | 98 vertexMode.set("colors_texs"); |
96 break; | 99 break; |
97 default: | 100 default: |
98 break; | 101 break; |
99 } | 102 } |
100 SkString type; | 103 SkString type; |
101 this->appendName(&type); | 104 this->appendName(&type); |
102 fName.printf("patch_%s_%s_[%f,%f]", type.c_str(), vertexMode.c_str(), | 105 fName.printf("patch_%s_%s_[%f,%f]", type.c_str(), vertexMode.c_str(), |
103 fScale.x(), fScale.y()); | 106 fScale.x(), fScale.y()); |
104 return fName.c_str(); | 107 return fName.c_str(); |
105 } | 108 } |
106 | 109 |
107 virtual void preDraw() { | 110 virtual void onPreDraw() SK_OVERRIDE { |
108 | |
109 } | |
110 | |
111 virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE { | |
112 | |
113 this->setCubics(); | 111 this->setCubics(); |
114 this->setColors(); | 112 this->setColors(); |
115 this->setTexCoords(); | 113 this->setTexCoords(); |
116 this->setupPaint(&fPaint); | 114 this->setupPaint(&fPaint); |
117 switch (fVertexMode) { | 115 switch (fVertexMode) { |
118 case kTexCoords_VertexMode: | 116 case kTexCoords_VertexMode: |
119 case kBoth_VertexMode: | 117 case kBoth_VertexMode: |
120 fPaint.setShader(this->createShader())->unref(); | 118 fPaint.setShader(this->createShader())->unref(); |
121 break; | 119 break; |
122 default: | 120 default: |
123 fPaint.setShader(NULL); | 121 fPaint.setShader(NULL); |
124 break; | 122 break; |
125 } | 123 } |
| 124 } |
126 | 125 |
| 126 virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE { |
127 canvas->scale(fScale.x(), fScale.y()); | 127 canvas->scale(fScale.x(), fScale.y()); |
128 for (int i = 0; i < loops; i++) { | 128 for (int i = 0; i < loops; i++) { |
129 switch (fVertexMode) { | 129 switch (fVertexMode) { |
130 case kNone_VertexMode: | 130 case kNone_VertexMode: |
131 canvas->drawPatch(fCubics, NULL, NULL, NULL, fPaint); | 131 canvas->drawPatch(fCubics, NULL, NULL, NULL, fPaint); |
132 break; | 132 break; |
133 case kColors_VertexMode: | 133 case kColors_VertexMode: |
134 canvas->drawPatch(fCubics, fColors, NULL, NULL, fPaint); | 134 canvas->drawPatch(fCubics, fColors, NULL, NULL, fPaint); |
135 break; | 135 break; |
136 case kTexCoords_VertexMode: | 136 case kTexCoords_VertexMode: |
(...skipping 21 matching lines...) Expand all Loading... |
158 | 158 |
159 class SquarePatchBench : public PatchBench { | 159 class SquarePatchBench : public PatchBench { |
160 public: | 160 public: |
161 SquarePatchBench(SkPoint scale, VertexMode vertexMode) | 161 SquarePatchBench(SkPoint scale, VertexMode vertexMode) |
162 : INHERITED(scale, vertexMode) { } | 162 : INHERITED(scale, vertexMode) { } |
163 | 163 |
164 virtual void appendName(SkString* name) SK_OVERRIDE { | 164 virtual void appendName(SkString* name) SK_OVERRIDE { |
165 name->append("square"); | 165 name->append("square"); |
166 } | 166 } |
167 | 167 |
168 virtual void setCubics() { | 168 virtual void setCubics() SK_OVERRIDE { |
169 const SkPoint points[SkPatchUtils::kNumCtrlPts] = { | 169 const SkPoint points[SkPatchUtils::kNumCtrlPts] = { |
170 //top points | 170 //top points |
171 {100,100},{150,100},{250,100}, {300,100}, | 171 {100,100},{150,100},{250,100}, {300,100}, |
172 //right points | 172 //right points |
173 {300, 150},{300,250}, | 173 {300, 150},{300,250}, |
174 //bottom points | 174 //bottom points |
175 {300,300},{250,300},{150,300},{100,300}, | 175 {300,300},{250,300},{150,300},{100,300}, |
176 //left points | 176 //left points |
177 {100,250},{100,150} | 177 {100,250},{100,150} |
178 }; | 178 }; |
179 memcpy(fCubics, points, SkPatchUtils::kNumCtrlPts * sizeof(SkPoint)); | 179 memcpy(fCubics, points, SkPatchUtils::kNumCtrlPts * sizeof(SkPoint)); |
180 } | 180 } |
181 private: | 181 private: |
182 typedef PatchBench INHERITED; | 182 typedef PatchBench INHERITED; |
183 }; | 183 }; |
184 | 184 |
185 class LODDiffPatchBench : public PatchBench { | 185 class LODDiffPatchBench : public PatchBench { |
186 public: | 186 public: |
187 LODDiffPatchBench(SkPoint scale, VertexMode vertexMode) | 187 LODDiffPatchBench(SkPoint scale, VertexMode vertexMode) |
188 : INHERITED(scale, vertexMode) { } | 188 : INHERITED(scale, vertexMode) { } |
189 | 189 |
190 virtual void appendName(SkString* name) SK_OVERRIDE { | 190 virtual void appendName(SkString* name) SK_OVERRIDE { |
191 name->append("LOD_Diff"); | 191 name->append("LOD_Diff"); |
192 } | 192 } |
193 | 193 |
194 virtual void setCubics() { | 194 virtual void setCubics() SK_OVERRIDE { |
195 const SkPoint points[SkPatchUtils::kNumCtrlPts] = { | 195 const SkPoint points[SkPatchUtils::kNumCtrlPts] = { |
196 //top points | 196 //top points |
197 {100,175},{150,100},{250,100}, {300,0}, | 197 {100,175},{150,100},{250,100}, {300,0}, |
198 //right points | 198 //right points |
199 {300, 150},{300,250}, | 199 {300, 150},{300,250}, |
200 //bottom points | 200 //bottom points |
201 {300,400},{250,300},{150,300},{100,225}, | 201 {300,400},{250,300},{150,300},{100,225}, |
202 //left points | 202 //left points |
203 {100,215},{100,185} | 203 {100,215},{100,185} |
204 }; | 204 }; |
205 memcpy(fCubics, points, SkPatchUtils::kNumCtrlPts * sizeof(SkPoint)); | 205 memcpy(fCubics, points, SkPatchUtils::kNumCtrlPts * sizeof(SkPoint)); |
206 } | 206 } |
207 private: | 207 private: |
208 typedef PatchBench INHERITED; | 208 typedef PatchBench INHERITED; |
209 }; | 209 }; |
210 | 210 |
211 class LoopPatchBench : public PatchBench { | 211 class LoopPatchBench : public PatchBench { |
212 public: | 212 public: |
213 LoopPatchBench(SkPoint scale, VertexMode vertexMode) | 213 LoopPatchBench(SkPoint scale, VertexMode vertexMode) |
214 : INHERITED(scale, vertexMode) { } | 214 : INHERITED(scale, vertexMode) { } |
215 | 215 |
216 virtual void appendName(SkString* name) SK_OVERRIDE { | 216 virtual void appendName(SkString* name) SK_OVERRIDE { |
217 name->append("loop"); | 217 name->append("loop"); |
218 } | 218 } |
219 | 219 |
220 virtual void setCubics() { | 220 virtual void setCubics() SK_OVERRIDE { |
221 const SkPoint points[SkPatchUtils::kNumCtrlPts] = { | 221 const SkPoint points[SkPatchUtils::kNumCtrlPts] = { |
222 //top points | 222 //top points |
223 {100,100},{300,200},{100,200}, {300,100}, | 223 {100,100},{300,200},{100,200}, {300,100}, |
224 //right points | 224 //right points |
225 {380, 400},{380,0}, | 225 {380, 400},{380,0}, |
226 //bottom points | 226 //bottom points |
227 {300,300},{250,250},{30,200},{100,300}, | 227 {300,300},{250,250},{30,200},{100,300}, |
228 //left points | 228 //left points |
229 {140,325},{150,150} | 229 {140,325},{150,150} |
230 }; | 230 }; |
(...skipping 85 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
316 DEF_BENCH( return new LoopPatchBench(SkVector::Make(1.0f, 1.0f), | 316 DEF_BENCH( return new LoopPatchBench(SkVector::Make(1.0f, 1.0f), |
317 PatchBench::kBoth_VertexMode); ) | 317 PatchBench::kBoth_VertexMode); ) |
318 DEF_BENCH( return new LoopPatchBench(SkVector::Make(3.0f, 3.0f), | 318 DEF_BENCH( return new LoopPatchBench(SkVector::Make(3.0f, 3.0f), |
319 PatchBench::kNone_VertexMode); ) | 319 PatchBench::kNone_VertexMode); ) |
320 DEF_BENCH( return new LoopPatchBench(SkVector::Make(3.0f, 3.0f), | 320 DEF_BENCH( return new LoopPatchBench(SkVector::Make(3.0f, 3.0f), |
321 PatchBench::kColors_VertexMode); ) | 321 PatchBench::kColors_VertexMode); ) |
322 DEF_BENCH( return new LoopPatchBench(SkVector::Make(3.0f, 3.0f), | 322 DEF_BENCH( return new LoopPatchBench(SkVector::Make(3.0f, 3.0f), |
323 PatchBench::kTexCoords_VertexMode); ) | 323 PatchBench::kTexCoords_VertexMode); ) |
324 DEF_BENCH( return new LoopPatchBench(SkVector::Make(3.0f, 3.0f), | 324 DEF_BENCH( return new LoopPatchBench(SkVector::Make(3.0f, 3.0f), |
325 PatchBench::kBoth_VertexMode); ) | 325 PatchBench::kBoth_VertexMode); ) |
OLD | NEW |