• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2025 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in comliance with the License.
5  * You may obtian a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14 */
15 
16 #include "dtk_constants.h"
17 #include "dtk_test_ext.h"
18 #include "utils.h"
19 
20 namespace OHOS {
21 namespace Rosen {
22 
23 // Bitmap_Scene_0061
24 // Bitmap构造接口：Bitmap_Build_L1_21
25 // Bitmap操作接口：GetPixmap
26 // cilp：ClipRect
27 // transform：Scale(极小值)
28 // 抗锯齿：非AA
29 // 透明度：半透明
30 // 视效：CreateBlendImageFilter
31 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 1)
32 {
33     /*
34      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
35      */
36     // 1.创建笔刷，设置笔刷是否为抗锯齿效果
37     using namespace Drawing;
38     Drawing::Brush brush;
39     brush.SetAntiAlias(false); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
40 
41     // 2.创建Bitmap
42     Drawing::Bitmap bitmap;
43     Drawing::BitmapFormat format { Drawing::ColorType::COLORTYPE_RGB_565, Drawing::AlphaType::ALPHATYPE_PREMUL };
44     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
45     bitmap.ClearWithColor(0xFF789645); // 固定为不透明，灰绿色
46 
47     // 3.组合Bitmap操作函数，设置透明度, 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
48     Drawing::Bitmap bitmap1;
49     bitmap1.Build(500, 500, format);    // 500 weidth & 500 height
50     bitmap1.ClearWithColor(0x894567FA); // 半透明效果，粉蓝色
51     auto image = Drawing::Image::MakeFromRaster(bitmap1.GetPixmap(), nullptr, nullptr);
52 
53     brush.SetColor(0x4CB21933);
54 
55     // 4.组合transform函数
56     playbackCanvas_->Scale(10100.0f, 1.0f); // ratio
57 
58     for (auto blendMode : blendModes) {
59         auto background = Drawing::ImageFilter::CreateBlurImageFilter(
60             1.0f, 1.0f, Drawing::TileMode::REPEAT, nullptr, Drawing::ImageBlurType::GAUSS);
61         auto foreground = Drawing::ImageFilter::CreateBlurImageFilter(
62             1.0f, 1.0f, Drawing::TileMode::REPEAT, nullptr, Drawing::ImageBlurType::GAUSS);
63         auto filter = Drawing::Filter();
64 
65         // 5.设置视效效果，将效果添加到笔刷
66         filter.SetImageFilter(Drawing::ImageFilter::CreateBlendImageFilter(blendMode, background, foreground));
67         brush.SetFilter(filter);
68 
69         // 6.绘制结果
70         playbackCanvas_->AttachBrush(brush);
71         playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
72         playbackCanvas_->DrawImage(*image, 250, 300, SamplingOptions());
73     }
74     playbackCanvas_->DetachBrush();
75 
76     // 7.组合Clip函数，cilp也有抗锯齿效果，默认和笔刷效果保持一致
77     auto rect = Drawing::Rect(250, 300, 500, 500); // rect region (250, 300, 500, 500)
78     playbackCanvas_->Save();
79     playbackCanvas_->ClipRect(rect, Drawing::ClipOp::DIFFERENCE, false);
80     playbackCanvas_->Clear(Drawing::Color::COLOR_RED);
81     playbackCanvas_->Restore();
82 }
83 
84 // Bitmap_Scene_0062
85 // Bitmap构造接口：Bitmap_Build_L1_21
86 // Bitmap操作接口：MakeImage
87 // cilp：ClipRoundRect(G2)
88 // transform：Shear
89 // 抗锯齿：AA
90 // 透明度：半透明
91 // 视效：CreateBlurMaskFilter
92 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 2)
93 {
94     /*
95      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
96      */
97     // 1.创建笔刷，设置笔刷是否为抗锯齿效果
98     using namespace Drawing;
99     Drawing::Brush brush;
100     brush.SetAntiAlias(true); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
101 
102     // 2.创建Bitmap
103     Drawing::Bitmap bitmap;
104     Drawing::BitmapFormat format { Drawing::ColorType::COLORTYPE_RGB_565, Drawing::ALPHATYPE_PREMUL };
105     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
106     bitmap.ClearWithColor(0xFF789645); // 固定为不透明，灰绿色
107 
108     // 3.组合Bitmap操作函数，设置透明度, 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
109     Drawing::Bitmap bitmap1;
110     bitmap1.Build(500, 500, format);    // 500 weidth & 500 height
111     bitmap1.ClearWithColor(0x894567FA); // 半透明效果，粉蓝色
112     std::shared_ptr<Image> image = bitmap1.MakeImage();
113 
114     brush.SetColor(0x4CB21933);
115 
116     // 4.组合transform函数
117     playbackCanvas_->Shear(10.0f, 10.0f); // slope
118 
119     for (auto blendMode : blendModes) {
120         auto background = Drawing::ImageFilter::CreateBlurImageFilter(
121             1.0f, 1.0f, Drawing::TileMode::REPEAT, nullptr, Drawing::ImageBlurType::GAUSS);
122         auto foreground = Drawing::ImageFilter::CreateBlurImageFilter(
123             1.0f, 1.0f, Drawing::TileMode::REPEAT, nullptr, Drawing::ImageBlurType::GAUSS);
124         auto filter = Drawing::Filter();
125 
126         // 5.设置视效效果，将效果添加到笔刷
127         filter.SetImageFilter(Drawing::ImageFilter::CreateBlendImageFilter(blendMode, background, foreground));
128         brush.SetFilter(filter);
129 
130         // 6.绘制结果
131         playbackCanvas_->AttachBrush(brush);
132         playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
133         playbackCanvas_->DrawImage(*image, 250, 300, SamplingOptions());
134     }
135     playbackCanvas_->DetachBrush();
136 
137     // 7.组合Clip函数，cilp也有抗锯齿效果，默认和笔刷效果保持一致
138     auto rect = Drawing::Rect(250, 250, 400, 400); // rect region (250, 250, 400, 400)
139     auto rrect = Drawing::RoundRect(rect, 30.0f, 30.0f); // 30.0f is angle
140     playbackCanvas_->Save();
141     playbackCanvas_->ClipRoundRect(rrect, Drawing::ClipOp::DIFFERENCE, true);
142     playbackCanvas_->Clear(Drawing::Color::COLOR_RED);
143     playbackCanvas_->Restore();
144 }
145 
146 // Bitmap_Scene_0063
147 // Bitmap构造接口：Bitmap_Build_L1_21
148 // Bitmap操作接口：SetImmutable/IsImmutable
149 // cilp：ClipRoundRect(G2_capsule)
150 // transform：null
151 // 抗锯齿：非AA
152 // 透明度：不透明
153 // 视效：CreateLinearGradient
154 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 3)
155 {
156     /*
157      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
158      */
159     // 1.创建笔刷，设置笔刷是否为抗锯齿效果
160     using namespace Drawing;
161     Drawing::Brush brush;
162     brush.SetAntiAlias(false); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
163 
164     // 2.创建Bitmap
165     Drawing::Bitmap bitmap;
166     Drawing::BitmapFormat format { Drawing::ColorType::COLORTYPE_RGB_565, Drawing::ALPHATYPE_PREMUL };
167     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
168     bitmap.ClearWithColor(0xFF789645); // 固定为不透明，灰绿色
169 
170     // 3.组合Bitmap操作函数，设置透明度, 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
171     Drawing::Bitmap bitmap1;
172     bitmap1.Build(500, 500, format);    // 500 weidth & 500 height
173     bitmap1.ClearWithColor(0xFF4567FA); // 不透明效果，粉蓝色
174     bitmap1.SetImmutable();
175     if (bitmap1.IsImmutable()) {
176         playbackCanvas_->DrawBackground(0xFF675800); // 深棕榈
177     }
178 
179     std::vector<Drawing::ColorQuad> colors = { Drawing::Color::COLOR_RED, Drawing::Color::COLOR_GREEN,
180         Drawing::Color::COLOR_BLUE };
181     std::vector<Drawing::scalar> pos = { 0.00f, 0.50f, 1.00f };
182     auto linearGradient = Drawing::ShaderEffect::CreateLinearGradient(
183         { 0, 0 }, { 1000, 1000 }, colors, pos, Drawing::TileMode::CLAMP); // 0 start pos & 1000 end pos
184     brush.SetShaderEffect(linearGradient);
185 
186     // 4.绘制结果
187     playbackCanvas_->AttachBrush(brush);
188     playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
189     playbackCanvas_->DrawBitmap(bitmap1, 250, 300);
190     playbackCanvas_->DetachBrush();
191 
192     // 5.组合Clip函数，cilp也有抗锯齿效果，默认和笔刷效果保持一致
193     auto rect = Drawing::Rect(250, 300, 400, 500); // rect region (250, 300, 400, 500)
194     auto rrect = Drawing::RoundRect(rect, 50.0f, 50.0f); // 50.0f is angle
195     playbackCanvas_->Save();
196     playbackCanvas_->ClipRoundRect(rrect, Drawing::ClipOp::DIFFERENCE, false);
197     playbackCanvas_->Clear(Drawing::Color::COLOR_RED);
198     playbackCanvas_->Restore();
199 }
200 
201 // Bitmap_Scene_0064
202 // Bitmap构造接口：Bitmap_Build_L1_21
203 // Bitmap操作接口：ClearWithColor
204 // cilp：ClipRoundRect(非G2)
205 // transform：ConcatMatrix
206 // 抗锯齿：AA
207 // 透明度：透明
208 // 视效：CreateColorShader
209 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 4)
210 {
211     /*
212      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
213      */
214     // 1.创建笔刷，设置笔刷是否为抗锯齿效果
215     using namespace Drawing;
216     Drawing::Brush brush;
217     brush.SetAntiAlias(true); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
218 
219     // 2.创建Bitmap
220     Drawing::Bitmap bitmap;
221     Drawing::BitmapFormat format { Drawing::ColorType::COLORTYPE_RGB_565, Drawing::ALPHATYPE_PREMUL };
222     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
223     bitmap.ClearWithColor(0xFF789645); // 固定为不透明，灰绿色
224 
225     // 3.组合Bitmap操作函数，设置透明度, 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
226     Drawing::Bitmap bitmap1;
227     bitmap1.Build(500, 500, format);    // 500 weidth & 500 height
228     bitmap1.ClearWithColor(0x004567FA); // 透明效果，粉蓝色
229 
230     // 4.组合transform函数
231     Drawing::Matrix matrix;
232     matrix.Rotate(15, 10, 10);             // 15 angle 10 position
233     playbackCanvas_->ConcatMatrix(matrix); // ConcatMatrix
234 
235     // 5.设置视效效果，将效果添加到笔刷
236     brush.SetColor(0xFFFF0000); // 红色
237     auto colorShader = Drawing::ShaderEffect::CreateColorShader(Drawing::Color::COLOR_RED);
238     brush.SetShaderEffect(colorShader);
239 
240     // 6.绘制结果
241     playbackCanvas_->AttachBrush(brush);
242     playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
243     playbackCanvas_->DrawBitmap(bitmap1, 250, 300);
244     playbackCanvas_->DetachBrush();
245 
246     // 7.组合Clip函数，cilp也有抗锯齿效果，默认和笔刷效果保持一致
247     auto rect = Drawing::Rect(300, 300, 400, 400); // rect region (300, 300, 400, 400)
248     auto rrect = Drawing::RoundRect(rect, 30.0f, 30.0f); // 30.0f is angle
249     playbackCanvas_->Save();
250     playbackCanvas_->ClipRoundRect(rrect, Drawing::ClipOp::DIFFERENCE, true);
251     playbackCanvas_->Clear(Drawing::Color::COLOR_RED);
252     playbackCanvas_->Restore();
253 }
254 
255 // Bitmap_Scene_0065
256 // Bitmap构造接口：Bitmap_Build_L1_21
257 // Bitmap操作接口：ExtractSubset
258 // cilp：null
259 // transform：Scale(正常值）
260 // 抗锯齿：非AA
261 // 透明度：半透明
262 // 视效：CreateLinearGradient
263 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 5)
264 {
265     /*
266      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
267      */
268     // 1.创建笔刷，设置笔刷是否为抗锯齿效果
269     using namespace Drawing;
270     Drawing::Brush brush;
271     brush.SetAntiAlias(false); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
272 
273     // 2.创建Bitmap
274     Drawing::Bitmap bitmap;
275     Drawing::BitmapFormat format { Drawing::ColorType::COLORTYPE_RGB_565, Drawing::AlphaType::ALPHATYPE_PREMUL };
276     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
277     bitmap.ClearWithColor(0xFF789645); // 固定为不透明，灰绿色
278 
279     // 3.组合Bitmap操作函数，设置透明度, 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
280     Drawing::Bitmap bitmap1;
281     bitmap1.Build(500, 500, format);                       // 500 weidth & 500 height
282     bitmap1.ClearWithColor(0x894567FA);                    // 半透明效果，粉蓝色
283     if (bitmap1.ExtractSubset(bitmap, Rect(0, 1, 2, 2))) { // rect(0, 1, 2, 2)
284         playbackCanvas_->DrawBackground(0xFF675800); // 深棕榈
285     }
286 
287     // 4.组合transform函数
288     playbackCanvas_->Scale(2.0f, 2.0f); // ratio
289 
290     // 5.设置视效效果，将效果添加到笔刷
291     std::vector<Drawing::ColorQuad> colors = { Drawing::Color::COLOR_RED, Drawing::Color::COLOR_GREEN,
292         Drawing::Color::COLOR_BLUE };
293     std::vector<Drawing::scalar> pos = { 0.00f, 0.50f, 1.00f };
294     auto linearGradient = Drawing::ShaderEffect::CreateLinearGradient(
295         { 0, 0 }, { 1000, 1000 }, colors, pos, Drawing::TileMode::CLAMP); // 0 start pos & 1000 end pos
296     brush.SetShaderEffect(linearGradient);
297 
298     // 6.绘制结果
299     playbackCanvas_->AttachBrush(brush);
300     playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
301     playbackCanvas_->DrawBitmap(bitmap1, 250, 300);
302     playbackCanvas_->DetachBrush();
303 }
304 
305 // Bitmap_Scene_0066
306 // Bitmap构造接口：Bitmap_Build_L1_21
307 // Bitmap操作接口：PeekPixels
308 // cilp：ClipPath
309 // transform：Scale(正常值）
310 // 抗锯齿：AA
311 // 透明度：不透明
312 // 视效：CreateColorShader
313 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 6)
314 {
315     /*
316      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
317      */
318     // 1.创建笔刷，设置笔刷是否为抗锯齿效果
319     using namespace Drawing;
320     Drawing::Brush brush;
321     brush.SetAntiAlias(true); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
322 
323     // 2.创建Bitmap
324     Drawing::Bitmap bitmap;
325     Drawing::BitmapFormat format { Drawing::ColorType::COLORTYPE_RGB_565, Drawing::AlphaType::ALPHATYPE_PREMUL };
326     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
327     bitmap.ClearWithColor(0xFF789645); // 固定为不透明，灰绿色
328 
329     // 3.组合Bitmap操作函数，设置透明度, 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
330     Drawing::Bitmap bitmap1;
331     Drawing::Pixmap pixmap;
332     bitmap1.Build(500, 500, format);    // 500 weidth & 500 height
333     bitmap1.ClearWithColor(0xFF4567FA); // 不透明效果，粉蓝色
334     if (bitmap1.PeekPixels(pixmap)) {
335         auto image = Image::MakeFromRaster(pixmap, nullptr, nullptr);
336 
337         // 4.组合transform函数
338         playbackCanvas_->Scale(2.0f, 2.0f); // ratio
339 
340         // 5.设置视效效果，将效果添加到笔刷
341         brush.SetColor(0xFFFF0000); // 红色
342         auto colorShader = Drawing::ShaderEffect::CreateColorShader(Drawing::Color::COLOR_RED);
343         brush.SetShaderEffect(colorShader);
344 
345         // 6.绘制结果
346         playbackCanvas_->AttachBrush(brush);
347         playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
348         playbackCanvas_->DrawImage(*image, 250, 300, SamplingOptions());
349         playbackCanvas_->DetachBrush();
350 
351         // 7.组合Clip函数，cilp也有抗锯齿效果，默认和笔刷效果保持一致
352         Drawing::Path path;
353         path.AddRect({ 200, 300, 700, 800 }); // rect region (200, 300, 700, 800)
354         path.SetFillStyle(Drawing::PathFillType::INVERSE_WINDING);
355         playbackCanvas_->Save();
356         playbackCanvas_->ClipPath(path, Drawing::ClipOp::DIFFERENCE, true);
357         playbackCanvas_->Clear(Drawing::Color::COLOR_GREEN);
358         playbackCanvas_->Restore();
359     }
360 }
361 
362 // Bitmap_Scene_0067
363 // Bitmap构造接口：Bitmap_Build_L1_21
364 // Bitmap操作接口：ReadPixels
365 // cilp：ClipRect
366 // transform：Scale(极大值)
367 // 抗锯齿：非AA
368 // 透明度：透明
369 // 视效：null
370 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 7)
371 {
372     /*
373      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
374      */
375     // 1.创建笔刷，设置笔刷是否为抗锯齿效果
376     using namespace Drawing;
377     Drawing::Brush brush;
378     brush.SetAntiAlias(false); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
379 
380     // 2.创建Bitmap
381     Drawing::Bitmap bitmap;
382     Drawing::BitmapFormat format { Drawing::ColorType::COLORTYPE_RGB_565, Drawing::AlphaType::ALPHATYPE_PREMUL };
383     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
384     bitmap.ClearWithColor(0xFF789645); // 固定为不透明，灰绿色
385 
386     // 3.组合Bitmap操作函数，设置透明度, 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
387     Drawing::Bitmap bitmap1;
388     bitmap1.Build(500, 500, format);    // 500 weidth & 500 height
389     bitmap1.ClearWithColor(0x004567FA); // 透明效果，粉蓝色
390     auto imageInfo = Drawing::ImageInfo(500, 500, Drawing::ColorType::COLORTYPE_RGB_565, Drawing::ALPHATYPE_PREMUL);
391     bitmap1.ReadPixels(imageInfo, bitmap.GetPixels(), bitmap.GetRowBytes(), 50, 50); // (50, 50) is position
392 
393     // 4.组合transform函数
394     playbackCanvas_->Scale(1.0f, 10100.0f); // ratio
395 
396     // 5.绘制结果
397     playbackCanvas_->AttachBrush(brush);
398     playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
399     playbackCanvas_->DrawBitmap(bitmap1, 250, 300);
400     playbackCanvas_->DetachBrush();
401 
402     // 7.组合Clip函数，cilp也有抗锯齿效果，默认和笔刷效果保持一致
403     auto rect = Drawing::Rect(250, 300, 500, 500); // rect region (250, 300, 500, 500)
404     playbackCanvas_->Save();
405     playbackCanvas_->ClipRect(rect, Drawing::ClipOp::DIFFERENCE, false);
406     playbackCanvas_->Clear(Drawing::Color::COLOR_RED);
407     playbackCanvas_->Restore();
408 }
409 
410 // Bitmap_Scene_0068
411 // Bitmap构造接口：Bitmap_Build_L1_21
412 // Bitmap操作接口：CopyPixels
413 // cilp：ClipRoundRect(G2)
414 // transform：Scale(极小值)
415 // 抗锯齿：AA
416 // 透明度：半透明
417 // 视效：CreateBlendModeColorFilter
418 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 8)
419 {
420     /*
421      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
422      */
423     // 1.创建笔刷，设置笔刷是否为抗锯齿效果
424     using namespace Drawing;
425     Drawing::Brush brush;
426     brush.SetAntiAlias(true); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
427 
428     // 2.创建Bitmap
429     Drawing::Bitmap bitmap;
430     Drawing::BitmapFormat format { Drawing::ColorType::COLORTYPE_RGB_565, Drawing::AlphaType::ALPHATYPE_PREMUL };
431     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
432     bitmap.ClearWithColor(0xFF789645); // 固定为不透明，灰绿色
433 
434     // 3.组合Bitmap操作函数，设置透明度, 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
435     Drawing::Bitmap bitmap1;
436     bitmap1.Build(500, 500, format);      // 500 weidth & 500 height
437     bitmap1.ClearWithColor(0x894567FA); // 半透明效果，粉蓝色
438     bitmap1.CopyPixels(bitmap, 500, 500); // 500 width & Height
439 
440     brush.SetColor(0xFFFF0000); // 红色
441 
442     // 4.组合transform函数
443     playbackCanvas_->Scale(10100.0f, 1.0f); // ratio
444 
445     for (auto blendMode : blendModes) {
446         std::shared_ptr<Drawing::ColorFilter> colorFilter =
447             Drawing::ColorFilter::CreateBlendModeColorFilter(0xFFFF0000, blendMode);
448         auto filter = Drawing::Filter();
449 
450         // 5.设置视效效果，将效果添加到笔刷
451         filter.SetColorFilter(colorFilter);
452         brush.SetFilter(filter);
453 
454         // 6.绘制结果
455         playbackCanvas_->AttachBrush(brush);
456         playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
457         playbackCanvas_->DrawBitmap(bitmap1, 250, 300);
458         playbackCanvas_->DetachBrush();
459     }
460 
461     // 7.组合Clip函数，cilp也有抗锯齿效果，默认和笔刷效果保持一致
462     auto rect = Drawing::Rect(250, 250, 400, 400); // rect region (250, 250, 400, 400)
463     auto rrect = Drawing::RoundRect(rect, 30.0f, 30.0f); // 30.0f is angle
464     playbackCanvas_->Save();
465     playbackCanvas_->ClipRoundRect(rrect, Drawing::ClipOp::DIFFERENCE, true);
466     playbackCanvas_->Clear(Drawing::Color::COLOR_RED);
467     playbackCanvas_->Restore();
468 }
469 
470 // Bitmap_Scene_0069
471 // Bitmap构造接口：Bitmap_Build_L1_21
472 // Bitmap操作接口：InstallPixels
473 // cilp：ClipRoundRect(G2_capsule)
474 // transform：Translate
475 // 抗锯齿：非AA
476 // 透明度：不透明
477 // 视效：CreateComposeColorFilter
478 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 9)
479 {
480     /*
481      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
482      */
483     // 1.创建笔刷，设置笔刷是否为抗锯齿效果
484     using namespace Drawing;
485     Drawing::Brush brush;
486     brush.SetAntiAlias(false); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
487 
488     // 2.创建Bitmap
489     Drawing::Bitmap bitmap;
490     Drawing::BitmapFormat format { Drawing::ColorType::COLORTYPE_RGB_565, Drawing::AlphaType::ALPHATYPE_PREMUL };
491     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
492     bitmap.ClearWithColor(0xFF789645); // 固定为不透明，灰绿色
493 
494     // 3.组合Bitmap操作函数，设置透明度, 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
495     Drawing::Bitmap bitmap1;
496     bitmap1.Build(500, 500, format);    // 500 weidth & 500 height
497     bitmap1.ClearWithColor(0xFF4567FA); // 不透明效果，粉蓝色
498     auto imageInfo = Drawing::ImageInfo(500, 500, Drawing::ColorType::COLORTYPE_RGB_565, Drawing::ALPHATYPE_PREMUL);
499     uint32_t pixels[][5] = { { 0xBFA12345, 0xCB9745D2, 0xD0ACB2F4, 0xD34A1234, 0xCDE7AB9F },
500         { 0xD98289C1, 0xC56A2F1A, 0xF3A807CC, 0xBD31C9A2, 0xF05A5378 },
501         { 0xCF19A7E4, 0xF29074BD, 0xC0C35F1A, 0xE73812A7, 0xD98E2B43 },
502         { 0xB6F10D34, 0xD98289C1, 0xC9A4527A, 0xC03D15A2, 0xF4B2C380 },
503         { 0xBF1D68A3, 0xE5A3D1C4, 0xCBF722ED, 0xD7A9BC64, 0xB4C5F219 } };
504     if (bitmap1.InstallPixels(imageInfo, pixels, bitmap.GetRowBytes())) {
505         Drawing::Image image;
506         image.BuildFromBitmap(bitmap1);
507 
508         brush.SetColor(0xFFFF0000); // 红色
509         // 4.组合transform函数
510         playbackCanvas_->Translate(200, 200); // 200 distance
511 
512         for (auto blendMode1 : blendModes) {
513             std::shared_ptr<Drawing::ColorFilter> colorFilter1 =
514                 Drawing::ColorFilter::CreateBlendModeColorFilter(0xFFFF0000, blendMode1);
515             for (auto blendMode2 : blendModes) {
516                 std::shared_ptr<Drawing::ColorFilter> colorFilter2 =
517                     Drawing::ColorFilter::CreateBlendModeColorFilter(0xFFFF00FF, blendMode2);
518                 std::shared_ptr<Drawing::ColorFilter> colorFilter3 =
519                     Drawing::ColorFilter::CreateComposeColorFilter(*colorFilter1, *colorFilter2);
520                 auto filter = Drawing::Filter();
521 
522                 // 5.设置视效效果，将效果添加到笔刷
523                 filter.SetColorFilter(colorFilter3);
524                 brush.SetFilter(filter);
525 
526                 // 6.绘制结果
527                 playbackCanvas_->AttachBrush(brush);
528                 playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
529                 playbackCanvas_->DrawImage(image, 250, 300, SamplingOptions());
530             }
531         }
532         playbackCanvas_->DetachBrush();
533     }
534 
535     // 7.组合Clip函数，cilp也有抗锯齿效果，默认和笔刷效果保持一致
536     auto rect = Drawing::Rect(250, 300, 400, 500); // rect region (250, 300, 400, 500)
537     auto rrect = Drawing::RoundRect(rect, 50.0f, 50.0f); // 50.0f is angle
538     playbackCanvas_->Save();
539     playbackCanvas_->ClipRoundRect(rrect, Drawing::ClipOp::DIFFERENCE, false);
540     playbackCanvas_->Clear(Drawing::Color::COLOR_RED);
541     playbackCanvas_->Restore();
542 }
543 
544 // Bitmap_Scene_0070
545 // Bitmap构造接口：Bitmap_Build_L1_21
546 // Bitmap操作接口：Serialize/Deserialize
547 // cilp：ClipRoundRect(非G2)
548 // transform：Shear
549 // 抗锯齿：AA
550 // 透明度：透明
551 // 视效：CreateSrgbGammaToLinear
552 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 10)
553 {
554     /*
555      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
556      */
557     // 1.创建笔刷，设置笔刷是否为抗锯齿效果
558     using namespace Drawing;
559     Drawing::Brush brush;
560     brush.SetAntiAlias(true); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
561 
562     // 2.创建Bitmap
563     Drawing::Bitmap bitmap;
564     Drawing::BitmapFormat format { Drawing::ColorType::COLORTYPE_RGB_565, Drawing::AlphaType::ALPHATYPE_PREMUL };
565     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
566     bitmap.ClearWithColor(0xFF789645); // 固定为不透明，灰绿色
567 
568     // 3.组合Bitmap操作函数，设置透明度, 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
569     Drawing::Bitmap bitmap1;
570     bitmap1.Build(500, 500, format);    // 500 weidth & 500 height
571     bitmap1.ClearWithColor(0x004567FA); // 透明效果，粉蓝色
572     auto data = bitmap1.Serialize();
573     if (bitmap1.Deserialize(data)) {
574         playbackCanvas_->DrawBackground(0xFF675800); // 深棕榈
575     }
576 
577     brush.SetColor(0xFF4F7091);
578 
579     // 4.组合transform函数
580     playbackCanvas_->Shear(10.0f, 10.0f); // slope
581 
582     // 5.设置视效效果，将效果添加到笔刷
583     auto filter = Drawing::Filter();
584     filter.SetColorFilter(Drawing::ColorFilter::CreateSrgbGammaToLinear());
585     brush.SetFilter(filter);
586 
587     // 6.绘制结果
588     playbackCanvas_->AttachBrush(brush);
589     playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
590     playbackCanvas_->DrawBitmap(bitmap1, 250, 300);
591     playbackCanvas_->DetachBrush();
592 
593     // 7.组合Clip函数，cilp也有抗锯齿效果，默认和笔刷效果保持一致
594     auto rect = Drawing::Rect(300, 300, 400, 400); // rect region (300, 300, 400, 400)
595     auto rrect = Drawing::RoundRect(rect, 30.0f, 30.0f); // 30.0f is angle
596     playbackCanvas_->Save();
597     playbackCanvas_->ClipRoundRect(rrect, Drawing::ClipOp::DIFFERENCE, true);
598     playbackCanvas_->Clear(Drawing::Color::COLOR_RED);
599     playbackCanvas_->Restore();
600 }
601 
602 // Bitmap_Scene_0071
603 // Bitmap构造接口：Bitmap_Build_L1_31
604 // Bitmap操作接口：GetWidth
605 // cilp：null
606 // transform：null
607 // 抗锯齿：非AA
608 // 透明度：不透明
609 // 视效：CreateBlendShader
610 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 11)
611 {
612     /*
613      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
614      */
615     // 1.创建笔刷，设置笔刷是否为抗锯齿效果
616     using namespace Drawing;
617     Drawing::Brush brush;
618     brush.SetAntiAlias(false); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
619     // 2.创建Bitmap
620     Drawing::Bitmap bitmap;
621     Drawing::BitmapFormat format { Drawing::ColorType::COLORTYPE_ARGB_4444, Drawing::AlphaType::ALPHATYPE_UNPREMUL };
622     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
623     bitmap.ClearWithColor(0xFF789645); // 固定为不透明，灰绿色
624 
625     // 3.组合Bitmap操作函数，设置透明度, 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
626     Drawing::Bitmap bitmap1;
627     bitmap1.Build(bitmap.GetWidth(), 500, format); // 500 height
628     bitmap1.ClearWithColor(0xFF4567FA); // 不透明效果，粉蓝色
629 
630     // 4.设置视效效果，将效果添加到笔刷
631 
632     brush.SetColor(0xFFFF0000);
633     auto dst = Drawing::ShaderEffect::CreateColorShader(Drawing::Color::COLOR_RED);
634     auto src = Drawing::ShaderEffect::CreateColorShader(Drawing::Color::COLOR_GREEN);
635     for (auto blendMode : blendModes) {
636         auto blendShader = Drawing::ShaderEffect::CreateBlendShader(*dst, *src, blendMode);
637         brush.SetShaderEffect(blendShader);
638 
639         // 5.绘制部分
640         playbackCanvas_->AttachBrush(brush);
641         playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
642         playbackCanvas_->DrawBitmap(bitmap1, 250, 300); // 250, 300 is bitmap position
643     }
644     playbackCanvas_->DetachBrush();
645 }
646 
647 // Bitmap_Scene_0072
648 // Bitmap构造接口：Bitmap_Build_L1_31
649 // Bitmap操作接口：GetHeight
650 // cilp：ClipPath
651 // transform：ConcatMatrix
652 // 抗锯齿：AA
653 // 透明度：透明
654 // 视效：CreateSrgbGammaToLinear
655 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 12)
656 {
657     /*
658      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
659      */
660     // 1.创建笔刷，设置笔刷是否为抗锯齿效果
661     using namespace Drawing;
662     Drawing::Brush brush;
663     brush.SetAntiAlias(true); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
664     // 2.创建Bitmap
665     Drawing::Bitmap bitmap;
666     Drawing::BitmapFormat format { Drawing::ColorType::COLORTYPE_ARGB_4444, Drawing::AlphaType::ALPHATYPE_UNPREMUL };
667     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
668     bitmap.ClearWithColor(0xFF789645); // 固定为不透明，灰绿色
669 
670     // 3.组合Bitmap操作函数，设置透明度, 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
671     Drawing::Bitmap bitmap1;
672     bitmap1.Build(500, bitmap.GetHeight(), format); // 500 weidth
673     bitmap1.ClearWithColor(0x004567FA);             // 透明效果
674 
675     // 4.设置视效效果，将效果添加到笔刷
676     auto filter = Drawing::Filter();
677     filter.SetColorFilter(Drawing::ColorFilter::CreateSrgbGammaToLinear());
678     brush.SetFilter(filter);
679 
680     // 5.组合transform函数
681     Drawing::Matrix matrix;
682     matrix.Rotate(15, 10, 10); // 15 angle 10 position
683     playbackCanvas_->ConcatMatrix(matrix);
684 
685     // 6.绘制结果
686     playbackCanvas_->AttachBrush(brush);
687     playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
688     playbackCanvas_->DrawBitmap(bitmap1, 250, 300); // 250，300 is bitmap position
689     playbackCanvas_->DetachBrush();
690 
691     // 7.组合Clip函数，cilp也有抗锯齿效果，默认和笔刷效果保持一致
692     Drawing::Path path;
693     path.AddRect({ 200, 300, 700, 800 }); // rect region (200, 300, 700, 800)
694     path.SetFillStyle(Drawing::PathFillType::INVERSE_WINDING);
695     playbackCanvas_->Save();
696     playbackCanvas_->ClipPath(path, Drawing::ClipOp::DIFFERENCE, true);
697     playbackCanvas_->Clear(Drawing::Color::COLOR_GREEN);
698     playbackCanvas_->Restore();
699 }
700 
701 // Bitmap_Scene_0073
702 // Bitmap构造接口：Bitmap_Build_L1_31
703 // Bitmap操作接口：GetColorType
704 // cilp：ClipRect
705 // transform：Rotate
706 // 抗锯齿：非AA
707 // 透明度：半透明
708 // 视效：CreateLumaColorFilter
709 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 13)
710 {
711     /*
712      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
713      */
714     // 1.创建笔刷，设置笔刷是否为抗锯齿效果
715     using namespace Drawing;
716     Drawing::Brush brush;
717     brush.SetAntiAlias(false); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
718     // 2.创建Bitmap
719     Drawing::Bitmap bitmap;
720     Drawing::BitmapFormat format { Drawing::ColorType::COLORTYPE_ARGB_4444, Drawing::AlphaType::ALPHATYPE_UNPREMUL };
721     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
722     bitmap.ClearWithColor(0xFF789645); // 固定为不透明，灰绿色
723 
724     // 3.组合Bitmap操作函数，设置透明度, 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
725     Drawing::Bitmap bitmap1;
726     bitmap1.Build(500, 500, format);    // 500 weidth & 500 height
727     bitmap1.ClearWithColor(0x894567FA); // 半透明效果，粉蓝色
728 
729     // 4.设置视效效果，将效果添加到笔刷
730     brush.SetColor(0xFF0000FF);
731     auto filter = Drawing::Filter();
732     filter.SetColorFilter(Drawing::ColorFilter::CreateLumaColorFilter());
733     brush.SetFilter(filter);
734 
735     // 5.组合transform函数
736     playbackCanvas_->Rotate(30, 10, 10); // 30 angle 10 position
737 
738     // 6.绘制结果
739     playbackCanvas_->AttachBrush(brush);
740     playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
741     playbackCanvas_->DrawBitmap(bitmap1, 250, 300); // 250，300 is bitmap position
742     playbackCanvas_->DetachBrush();
743 
744     // 7.组合Clip函数，cilp也有抗锯齿效果，默认和笔刷效果保持一致
745     auto rect = Drawing::Rect(250, 300, 500, 500); // rect region (250, 300, 500, 500)
746     playbackCanvas_->Save();
747     playbackCanvas_->ClipRect(rect, Drawing::ClipOp::DIFFERENCE, false);
748     playbackCanvas_->Clear(Drawing::Color::COLOR_RED);
749     playbackCanvas_->Restore();
750 }
751 
752 // Bitmap_Scene_0074
753 // Bitmap构造接口：Bitmap_Build_L1_31
754 // Bitmap操作接口：GetAlphaType
755 // cilp：ClipRoundRect(G2)
756 // transform：Scale(正常值）
757 // 抗锯齿：AA
758 // 透明度：透明
759 // 视效：CreateBlendImageFilter
760 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 14)
761 {
762     /*
763      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
764      */
765     // 1.创建笔刷，设置笔刷是否为抗锯齿效果
766     using namespace Drawing;
767     Drawing::Brush brush;
768     brush.SetAntiAlias(true); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
769     // 2.创建Bitmap
770     Drawing::Bitmap bitmap;
771     Drawing::BitmapFormat format { Drawing::ColorType::COLORTYPE_ARGB_4444, Drawing::AlphaType::ALPHATYPE_UNPREMUL };
772     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
773     bitmap.ClearWithColor(0xFF789645); // 固定为不透明，灰绿色
774 
775     // 3.组合Bitmap操作函数，设置透明度, 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
776     Drawing::Bitmap bitmap1;
777     bitmap1.Build(500, 500, format);    // 500 weidth & 500 height
778     bitmap1.ClearWithColor(0x004567FA); // 透明效果
779 
780     // 4.组合transform函数
781     playbackCanvas_->Scale(2.0f, 2.0f); // ratio
782 
783     // 5.设置视效效果，将效果添加到笔刷
784     brush.SetColor(0x4CB21933);
785 
786     for (auto blendMode : blendModes) {
787         auto background = Drawing::ImageFilter::CreateBlurImageFilter(
788             1.0f, 1.0f, Drawing::TileMode::REPEAT, nullptr, Drawing::ImageBlurType::GAUSS);
789         auto foreground = Drawing::ImageFilter::CreateBlurImageFilter(
790             1.0f, 1.0f, Drawing::TileMode::REPEAT, nullptr, Drawing::ImageBlurType::GAUSS);
791         auto filter = Drawing::Filter();
792         filter.SetImageFilter(Drawing::ImageFilter::CreateBlendImageFilter(blendMode, background, foreground));
793         brush.SetFilter(filter);
794 
795         // 6.绘制结果
796         playbackCanvas_->AttachBrush(brush);
797         playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
798         playbackCanvas_->DrawBitmap(bitmap1, 250, 300); // 250，300 is bitmap position
799     }
800     playbackCanvas_->DetachBrush();
801 
802     // 7.组合Clip函数，cilp也有抗锯齿效果，默认和笔刷效果保持一致
803     auto rect = Drawing::Rect(250, 250, 400, 400); // rect region (250, 250, 400, 400)
804     auto rrect = Drawing::RoundRect(rect, 30.0f, 30.0f); // 30.0f is angle
805     playbackCanvas_->Save();
806     playbackCanvas_->ClipRoundRect(rrect, Drawing::ClipOp::DIFFERENCE, true);
807     playbackCanvas_->Clear(Drawing::Color::COLOR_RED);
808     playbackCanvas_->Restore();
809 }
810 
811 // Bitmap_Scene_0075
812 // Bitmap构造接口：Bitmap_Build_L1_31
813 // Bitmap操作接口：GetRowBytes
814 // cilp：ClipRoundRect(G2_capsule)
815 // transform：Scale(极大值)
816 // 抗锯齿：非AA
817 // 透明度：半透明
818 // 视效：CreateBlendShader
819 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 15)
820 {
821     /*
822      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
823      */
824     // 1.创建笔刷，设置笔刷是否为抗锯齿效果
825     using namespace Drawing;
826     Drawing::Brush brush;
827     brush.SetAntiAlias(false); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
828     // 2.创建Bitmap
829     Drawing::Bitmap bitmap;
830     Drawing::BitmapFormat format { Drawing::ColorType::COLORTYPE_ARGB_4444, Drawing::AlphaType::ALPHATYPE_UNPREMUL };
831     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
832     bitmap.ClearWithColor(0xFF789645); // 固定为不透明，灰绿色
833 
834     // 3.组合Bitmap操作函数，设置透明度, 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
835     Drawing::Bitmap bitmap1;
836     bitmap1.Build(500, 500, format); // 500 weidth & 500 height
837     if (bitmap1.GetRowBytes() == sizeof(uint32_t) * bitmap1.GetWidth()) {
838         playbackCanvas_->DrawBackground(0x89675800); // 半透明
839     }
840 
841     // 4.组合transform函数
842     playbackCanvas_->Scale(1.0f, 10100.0f); // ratio
843 
844     // 5.设置视效效果，将效果添加到笔刷
845     brush.SetColor(0xFFFF0000);
846 
847     auto dst = Drawing::ShaderEffect::CreateColorShader(Drawing::Color::COLOR_RED);
848     auto src = Drawing::ShaderEffect::CreateColorShader(Drawing::Color::COLOR_GREEN);
849     for (auto blendMode : blendModes) {
850         auto blendShader = Drawing::ShaderEffect::CreateBlendShader(*dst, *src, blendMode);
851         brush.SetShaderEffect(blendShader);
852 
853         // 6.绘制结果
854         playbackCanvas_->AttachBrush(brush);
855         playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
856         playbackCanvas_->DrawBitmap(bitmap1, 250, 300); // 250，300 is bitmap position
857     }
858     playbackCanvas_->DetachBrush();
859 
860     // 7.组合Clip函数，cilp也有抗锯齿效果，默认和笔刷效果保持一致
861     auto rect = Drawing::Rect(250, 300, 500, 500); // rect region (250, 300, 500, 500)
862     auto rrect = Drawing::RoundRect(rect, 50.0f, 50.0f); // 50.0f is angle
863     playbackCanvas_->Save();
864     playbackCanvas_->ClipRoundRect(rrect, Drawing::ClipOp::DIFFERENCE, false);
865     playbackCanvas_->Clear(Drawing::Color::COLOR_RED);
866     playbackCanvas_->Restore();
867 }
868 
869 // Bitmap_Scene_0076
870 // Bitmap构造接口：Bitmap_Build_L1_31
871 // Bitmap操作接口：GetImageInfo
872 // cilp：ClipRoundRect(非G2)
873 // transform：Scale(极小值)
874 // 抗锯齿：AA
875 // 透明度：不透明
876 // 视效：CreateBlurImageFilter
877 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 16)
878 {
879     /*
880      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
881      */
882     // 1.创建笔刷，设置笔刷是否为抗锯齿效果
883     using namespace Drawing;
884     Drawing::Brush brush;
885     brush.SetAntiAlias(true); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
886     // 2.创建Bitmap
887     Drawing::Bitmap bitmap;
888     Drawing::BitmapFormat format { Drawing::ColorType::COLORTYPE_ARGB_4444, Drawing::AlphaType::ALPHATYPE_UNPREMUL };
889     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
890     bitmap.ClearWithColor(0xFF789645); // 固定为不透明，灰绿色
891 
892     // 3.组合Bitmap操作函数，设置透明度, 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
893     Drawing::Bitmap bitmap1;
894     bitmap1.Build(500, 500, format); // 500 weidth & 500 height
895     bitmap1.TryAllocPixels(bitmap.GetImageInfo());
896     bitmap1.ClearWithColor(0xFF4567FA); // 不透明，粉蓝色
897 
898     // 4.组合transform函数
899     playbackCanvas_->Scale(10100.0f, 1.0f); // ratio
900 
901     // 5.设置视效效果，将效果添加到笔刷
902     brush.SetColor(0xFFFF0000);
903     auto filter = Drawing::Filter();
904     filter.SetImageFilter(Drawing::ImageFilter::CreateBlurImageFilter(
905         10.0f, 10.0f, Drawing::TileMode::CLAMP, nullptr, Drawing::ImageBlurType::GAUSS));
906     brush.SetFilter(filter);
907 
908     // 6.绘制结果
909     playbackCanvas_->AttachBrush(brush);
910     playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
911     playbackCanvas_->DrawBitmap(bitmap1, 250, 300); // 250，300 is bitmap position
912     playbackCanvas_->DetachBrush();
913 
914     // 7.组合Clip函数，cilp也有抗锯齿效果，默认和笔刷效果保持一致
915     auto rect = Drawing::Rect(300, 300, 400, 400); // rect region (300, 300, 400, 400)
916     auto rrect = Drawing::RoundRect(rect, 30.0f, 30.0f); // 30.0f is angle
917     playbackCanvas_->Save();
918     playbackCanvas_->ClipRoundRect(rrect, Drawing::ClipOp::DIFFERENCE, true);
919     playbackCanvas_->Clear(Drawing::Color::COLOR_RED);
920     playbackCanvas_->Restore();
921 }
922 
923 // Bitmap_Scene_0077
924 // Bitmap构造接口：Bitmap_Build_L1_31
925 // Bitmap操作接口：SetInfo
926 // cilp：null
927 // transform：Translate
928 // 抗锯齿：非AA
929 // 透明度：透明
930 // 视效：CreateColorShader
931 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 17)
932 {
933     /*
934      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
935      */
936     // 1.创建笔刷，设置笔刷是否为抗锯齿效果
937     using namespace Drawing;
938     Drawing::Brush brush;
939     brush.SetAntiAlias(false); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
940     // 2.创建Bitmap
941     Drawing::Bitmap bitmap;
942     Drawing::BitmapFormat format { Drawing::ColorType::COLORTYPE_ARGB_4444, Drawing::AlphaType::ALPHATYPE_UNPREMUL };
943     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
944     bitmap.ClearWithColor(0xFF789645); // 固定为不透明，灰绿色
945 
946     // 3.组合Bitmap操作函数，设置透明度, 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
947     Drawing::Bitmap bitmap1;
948     bitmap1.Build(500, 500, format); // 500 weidth & 500 height
949     bitmap1.SetInfo(bitmap.GetImageInfo());
950     bitmap1.ClearWithColor(0x004567FA); // 透明
951 
952     // 4.组合transform函数
953     playbackCanvas_->Translate(200, 200); // 200 distance
954 
955     // 5.设置视效效果，将效果添加到笔刷
956     brush.SetColor(0xFFFF0000);
957     auto colorShader = Drawing::ShaderEffect::CreateColorShader(Drawing::Color::COLOR_RED);
958     brush.SetShaderEffect(colorShader);
959 
960     // 6.绘制结果
961     playbackCanvas_->AttachBrush(brush);
962     playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
963     playbackCanvas_->DrawBitmap(bitmap1, 250, 300); // 250，300 is bitmap position
964     playbackCanvas_->DetachBrush();
965 }
966 
967 // Bitmap_Scene_0078
968 // Bitmap构造接口：Bitmap_Build_L1_31
969 // Bitmap操作接口：ComputeByteSize
970 // cilp：ClipPath
971 // transform：Shear
972 // 抗锯齿：AA
973 // 透明度：半透明
974 // 视效：CreateLinearGradient
975 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 18)
976 {
977     /*
978      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
979      */
980     // 1.创建笔刷，设置笔刷是否为抗锯齿效果
981     using namespace Drawing;
982     Drawing::Brush brush;
983     brush.SetAntiAlias(true); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
984     // 2.创建Bitmap
985     Drawing::Bitmap bitmap;
986     Drawing::BitmapFormat format { Drawing::ColorType::COLORTYPE_ARGB_4444, Drawing::AlphaType::ALPHATYPE_UNPREMUL };
987     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
988     bitmap.ClearWithColor(0xFF789645); // 固定为不透明，灰绿色
989 
990     // 3.组合Bitmap操作函数，设置透明度, 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
991     Drawing::Bitmap bitmap1;
992     bitmap1.Build(500, 500, format); // 500 weidth & 500 height
993     size_t size = bitmap.GetRowBytes() * bitmap.GetHeight();
994     if (bitmap1.ComputeByteSize() == size) {
995         playbackCanvas_->DrawBackground(0x89675800); // 半透明，灰绿色
996     }
997 
998     // 4.组合transform函数
999     playbackCanvas_->Shear(10.0f, 10.0f); // slope
1000 
1001     // 5.设置视效效果，将效果添加到笔刷
1002     std::vector<Drawing::ColorQuad> colors = { Drawing::Color::COLOR_RED, Drawing::Color::COLOR_GREEN,
1003         Drawing::Color::COLOR_BLUE };
1004     std::vector<Drawing::scalar> pos = { 0.00f, 0.50f, 1.00f };
1005     auto linearGradient = Drawing::ShaderEffect::CreateLinearGradient(
1006         { 0, 0 }, { 1000, 1000 }, colors, pos, Drawing::TileMode::CLAMP); // 0 start pos & 1000 end pos
1007     brush.SetShaderEffect(linearGradient);
1008 
1009     // 6.绘制结果
1010     playbackCanvas_->AttachBrush(brush);
1011     playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
1012     playbackCanvas_->DrawBitmap(bitmap1, 250, 300); // 250，300 is bitmap position
1013     playbackCanvas_->DetachBrush();
1014 
1015     // 7.组合Clip函数，cilp也有抗锯齿效果，默认和笔刷效果保持一致
1016     Drawing::Path path;
1017     path.AddRect({ 200, 300, 700, 800 }); // rect region (200, 300, 700, 800)
1018     path.SetFillStyle(Drawing::PathFillType::INVERSE_WINDING);
1019     playbackCanvas_->Save();
1020     playbackCanvas_->ClipPath(path, Drawing::ClipOp::DIFFERENCE, true);
1021     playbackCanvas_->Clear(Drawing::Color::COLOR_GREEN);
1022     playbackCanvas_->Restore();
1023 }
1024 
1025 // Bitmap_Scene_0079
1026 // Bitmap构造接口：Bitmap_Build_L1_31
1027 // Bitmap操作接口：SetPixel/GetPixel
1028 // cilp：ClipRect
1029 // transform：null
1030 // 抗锯齿：非AA
1031 // 透明度：不透明
1032 // 视效：CreateMatrixColorFilter
1033 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 19)
1034 {
1035     /*
1036      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
1037      */
1038     // 1.创建笔刷，设置笔刷是否为抗锯齿效果
1039     using namespace Drawing;
1040     Drawing::Brush brush;
1041     brush.SetAntiAlias(false); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
1042     // 2.创建Bitmap
1043     Drawing::Bitmap bitmap;
1044     Drawing::BitmapFormat format { Drawing::ColorType::COLORTYPE_ARGB_4444, Drawing::AlphaType::ALPHATYPE_UNPREMUL };
1045     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
1046     bitmap.ClearWithColor(0xFF789645); // 固定为不透明，灰绿色
1047 
1048     // 3.组合Bitmap操作函数，设置透明度, 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
1049     Drawing::Bitmap bitmap1;
1050     bitmap1.Build(500, 500, format); // 500 weidth & 500 height
1051     bitmap1.SetPixels(bitmap.GetPixels());
1052 
1053     // 4.设置视效效果，将效果添加到笔刷
1054     Drawing::ColorMatrix matrix;
1055     matrix.SetArray(ARR);
1056     auto cf = Drawing::ColorFilter::CreateMatrixColorFilter(matrix);
1057     auto filter = Drawing::Filter();
1058     filter.SetImageFilter(Drawing::ImageFilter::CreateColorFilterImageFilter(*cf, nullptr));
1059     brush.SetFilter(filter);
1060 
1061     // 5.绘制结果
1062     playbackCanvas_->AttachBrush(brush);
1063     playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
1064     playbackCanvas_->DrawBitmap(bitmap1, 250, 300); // 250，300 is bitmap position
1065     playbackCanvas_->DetachBrush();
1066 
1067     // 6.组合Clip函数，cilp也有抗锯齿效果，默认和笔刷效果保持一致
1068     auto rect = Drawing::Rect(250, 300, 500, 500); // rect region (250, 300, 500, 500)
1069     playbackCanvas_->Save();
1070     playbackCanvas_->ClipRect(rect, Drawing::ClipOp::DIFFERENCE, false);
1071     playbackCanvas_->Clear(Drawing::Color::COLOR_RED);
1072     playbackCanvas_->Restore();
1073 }
1074 
1075 // Bitmap_Scene_0080
1076 // Bitmap构造接口：Bitmap_Build_L1_31
1077 // Bitmap操作接口：IsEmpty
1078 // cilp：ClipRoundRect(G2)
1079 // transform：ConcatMatrix
1080 // 抗锯齿：AA
1081 // 透明度：透明
1082 // 视效：CreateLinearToSrgbGamma
1083 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 20)
1084 {
1085     /*
1086      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
1087      */
1088     // 1.创建笔刷，设置笔刷是否为抗锯齿效果
1089     using namespace Drawing;
1090     Drawing::Brush brush;
1091     brush.SetAntiAlias(true); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
1092     // 2.创建Bitmap
1093     Drawing::Bitmap bitmap;
1094     Drawing::BitmapFormat format { Drawing::ColorType::COLORTYPE_ARGB_4444, Drawing::AlphaType::ALPHATYPE_UNPREMUL };
1095     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
1096     bitmap.ClearWithColor(0xFF789645); // 固定为不透明，灰绿色
1097 
1098     // 3.组合Bitmap操作函数，设置透明度, 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
1099     Drawing::Bitmap bitmap1;
1100     bitmap1.Build(500, 500, format); // 500 weidth & 500 height
1101     if (bitmap1.IsEmpty()) {
1102         playbackCanvas_->DrawBackground(0x00675800); // 透明
1103     }
1104 
1105     // 4.组合transform函数
1106     Drawing::Matrix matrix;
1107     matrix.Rotate(15, 10, 10); // 15 angle 10 position
1108     playbackCanvas_->ConcatMatrix(matrix);
1109 
1110     // 5.设置视效效果，将效果添加到笔刷
1111     brush.SetColor(0xFF4F7091);
1112     auto filter = Drawing::Filter();
1113     filter.SetColorFilter(Drawing::ColorFilter::CreateLinearToSrgbGamma());
1114     brush.SetFilter(filter);
1115 
1116     // 6.绘制结果
1117     playbackCanvas_->AttachBrush(brush);
1118     playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
1119     playbackCanvas_->DrawBitmap(bitmap1, 250, 300); // 250，300 is bitmap position
1120     playbackCanvas_->DetachBrush();
1121 
1122     // 7.组合Clip函数，cilp也有抗锯齿效果，默认和笔刷效果保持一致
1123     auto rect = Drawing::Rect(250, 250, 400, 400); // rect region (250, 250, 400, 400)
1124     auto rrect = Drawing::RoundRect(rect, 30.0f, 30.0f); // 30.0f is angle
1125     playbackCanvas_->Save();
1126     playbackCanvas_->ClipRoundRect(rrect, Drawing::ClipOp::DIFFERENCE, true);
1127     playbackCanvas_->Clear(Drawing::Color::COLOR_RED);
1128     playbackCanvas_->Restore();
1129 }
1130 
1131 // Bitmap构造接口：Bitmap_Build_L1_31
1132 // Bitmap操作接口：IsValid
1133 // cilp：ClipRoundRect(G2_capsule)
1134 // transform：Rotate
1135 // 抗锯齿：非AA
1136 // 透明度：半透明
1137 // 视效：CreateBlurMaskFilter
1138 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 21)
1139 {
1140     /*
1141      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
1142      */
1143     // 1.创建笔刷，设置笔刷是否为抗锯齿效果，抗锯齿：非AA
1144     using namespace Drawing;
1145     Drawing::Brush brush;
1146     brush.SetAntiAlias(false); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
1147 
1148     // 2.创建Bitmap Bitmap_Build_L1_31
1149     Drawing::Bitmap bitmap;
1150     Drawing::BitmapFormat format { COLORTYPE_ARGB_4444, ALPHATYPE_UNPREMUL };
1151     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
1152     bitmap.ClearWithColor(0xFF789645); // 灰绿色
1153 
1154     // 3.组合Bitmap操作函数IsValid，设置透明度, 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
1155     Drawing::Bitmap bitmap1;
1156     bitmap1.Build(500, 500, format);
1157     bitmap1.ClearWithColor(0x89789645); // 半透明效果，灰绿色
1158     if (bitmap1.IsValid()) {
1159         playbackCanvas_->DrawBackground(0xFF675800); // 深棕榈
1160     }
1161 
1162     std::vector<Drawing::BlurType> blurTypes = { Drawing::BlurType::NORMAL, Drawing::BlurType::SOLID,
1163         Drawing::BlurType::OUTER, Drawing::BlurType::INNER };
1164 
1165     brush.SetColor(0xFFFF0000);
1166 
1167     // 4.组合transform函数Rotate
1168     playbackCanvas_->Rotate(30, 10, 10); // 30 angle 10 position
1169 
1170     for (auto& blurType : blurTypes) {
1171         auto filter = Drawing::Filter();
1172         filter.SetMaskFilter(Drawing::MaskFilter::CreateBlurMaskFilter(blurType, 10.0f, true));
1173 
1174         // 5.设置视效效果CreateBlurMaskFilter，将效果添加到笔刷
1175         brush.SetFilter(filter);
1176 
1177         // 6.绘制结果
1178         playbackCanvas_->AttachBrush(brush);
1179         playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
1180         playbackCanvas_->DrawBitmap(bitmap1, 250, 300);
1181     }
1182     playbackCanvas_->DetachBrush();
1183 
1184     // 7.组合Clip函数ClipRoundRect(G2_capsule)，cilp也有抗锯齿效果，默认和笔刷效果保持一致
1185     auto rect = Drawing::Rect(250, 300, 400, 500); // rect region (250, 300, 400, 500)
1186     auto rrect = Drawing::RoundRect(rect, 50.0f, 50.0f); // 50.0f is angle
1187     playbackCanvas_->Save();
1188     playbackCanvas_->ClipRoundRect(rrect, Drawing::ClipOp::DIFFERENCE, false);
1189     playbackCanvas_->Clear(Drawing::Color::COLOR_RED);
1190     playbackCanvas_->Restore();
1191 }
1192 
1193 // Bitmap构造接口：Bitmap_Build_L1_31
1194 // Bitmap操作接口：GetColor
1195 // cilp：ClipRoundRect(非G2)
1196 // transform：Scale(正常值）
1197 // 抗锯齿：AA
1198 // 透明度：不透明
1199 // 视效：null
1200 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 22)
1201 {
1202     /*
1203      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
1204      */
1205     // 1.创建笔刷，设置笔刷是否为抗锯齿效果，抗锯齿：AA
1206     using namespace Drawing;
1207     Drawing::Brush brush;
1208     brush.SetAntiAlias(true); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
1209 
1210     // 2.创建Bitmap，Bitmap_Build_L1_31
1211     Drawing::Bitmap bitmap;
1212     Drawing::BitmapFormat format { COLORTYPE_ARGB_4444, ALPHATYPE_UNPREMUL };
1213     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
1214     bitmap.ClearWithColor(0xFF789645); // 灰绿色
1215 
1216     // 3.组合Bitmap操作函数GetColor，设置透明度,
1217     // 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
1218     Drawing::Bitmap bitmap1;
1219     bitmap1.Build(500, 500, format);
1220     bitmap1.ClearWithColor(bitmap.GetColor(1, 1)); // 1 is color position
1221 
1222     // 4.无视效效果函数
1223     // 5.组合transform函数Scale(正常值）
1224     playbackCanvas_->Scale(2.0f, 2.0f); // ratio
1225 
1226     // 6.绘制结果
1227     playbackCanvas_->AttachBrush(brush);
1228     playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
1229     playbackCanvas_->DrawBitmap(bitmap1, 250, 300);
1230     playbackCanvas_->DetachBrush();
1231 
1232     // 7.组合Clip函数ClipRoundRect(非G2)，cilp也有抗锯齿效果，默认和笔刷效果保持一致
1233     auto rect = Drawing::Rect(300, 300, 400, 400); // rect region (300, 300, 400, 400)
1234     auto rrect = Drawing::RoundRect(rect, 30.0f, 30.0f); // 30.0f is angle
1235     playbackCanvas_->Save();
1236     playbackCanvas_->ClipRoundRect(rrect, Drawing::ClipOp::DIFFERENCE, true);
1237     playbackCanvas_->Clear(Drawing::Color::COLOR_RED);
1238     playbackCanvas_->Restore();
1239 }
1240 
1241 // Bitmap构造接口：Bitmap_Build_L1_31
1242 // Bitmap操作接口：SetFormat/GetFormat
1243 // cilp：null
1244 // transform：Scale(极小值)
1245 // 抗锯齿：非AA
1246 // 透明度：透明
1247 // 视效：CreateBlendModeColorFilter
1248 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 23)
1249 {
1250     /*
1251      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
1252      */
1253     // 1.创建笔刷，设置笔刷是否为抗锯齿效果，抗锯齿：非AA
1254     using namespace Drawing;
1255     Drawing::Brush brush;
1256     brush.SetAntiAlias(false); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
1257 
1258     // 2.创建Bitmap，Bitmap_Build_L1_31
1259     Drawing::Bitmap bitmap;
1260     Drawing::BitmapFormat format { COLORTYPE_ARGB_4444, ALPHATYPE_UNPREMUL };
1261     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
1262     bitmap.ClearWithColor(0xFF789645); // 灰绿色
1263 
1264     // 3.组合Bitmap操作函数SetFormat/GetFormat，设置透明度,
1265     // 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
1266     Drawing::Bitmap bitmap1 = BuildRandomBitmap();
1267     bitmap1.SetFormat(bitmap.GetFormat());
1268     bitmap1.ClearWithColor(0x004567FA); // 透明效果，粉蓝色
1269 
1270 
1271     brush.SetColor(0xFFFF0000); // 红色
1272 
1273     // 4.组合transform函数Scale(极小值)
1274     playbackCanvas_->Scale(10100.0f, 1.0f); // ratio
1275 
1276     for (auto blendMode : blendModes) {
1277         std::shared_ptr<Drawing::ColorFilter> colorFilter =
1278             Drawing::ColorFilter::CreateBlendModeColorFilter(0xFFFF0000, blendMode);
1279         auto filter = Drawing::Filter();
1280 
1281         // 5.设置视效效果CreateBlendModeColorFilter，将效果添加到笔刷
1282         filter.SetColorFilter(colorFilter);
1283         brush.SetFilter(filter);
1284 
1285         // 6.绘制结果
1286         playbackCanvas_->AttachBrush(brush);
1287         playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
1288         playbackCanvas_->DrawBitmap(bitmap1, 250, 300);
1289     }
1290     playbackCanvas_->DetachBrush();
1291 
1292     // 7.无Clip函数
1293 }
1294 
1295 // Bitmap构造接口：Bitmap_Build_L1_31
1296 // Bitmap操作接口：GetPixmap
1297 // cilp：ClipPath
1298 // transform：Translate
1299 // 抗锯齿：AA
1300 // 透明度：半透明
1301 // 视效：CreateComposeColorFilter
1302 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 24)
1303 {
1304     /*
1305      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
1306      */
1307     // 1.创建笔刷，设置笔刷是否为抗锯齿效果，抗锯齿：AA
1308     using namespace Drawing;
1309     Drawing::Brush brush;
1310     brush.SetAntiAlias(true); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
1311 
1312     // 2.创建Bitmap，Bitmap_Build_L1_31
1313     Drawing::Bitmap bitmap;
1314     Drawing::BitmapFormat format { COLORTYPE_ARGB_4444, ALPHATYPE_UNPREMUL };
1315     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
1316     bitmap.ClearWithColor(0xFF789645); // 灰绿色
1317 
1318     // 3.组合Bitmap操作函数GetPixmap，设置透明度,
1319     // 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
1320     Drawing::Bitmap bitmap1;
1321     bitmap1.Build(500, 500, format);    // 500 weidth & 500 height
1322     bitmap1.ClearWithColor(0x89789645); // 半透明效果，灰绿色
1323     auto image = Drawing::Image::MakeFromRaster(bitmap1.GetPixmap(), nullptr, nullptr);
1324 
1325 
1326     brush.SetColor(0xFFFF0000); // 红色
1327 
1328     // 4.组合transform函数Translate
1329     playbackCanvas_->Translate(200, 200); // 200 distance
1330 
1331     for (auto blendMode1 : blendModes) {
1332         std::shared_ptr<Drawing::ColorFilter> colorFilter1 =
1333             Drawing::ColorFilter::CreateBlendModeColorFilter(0xFFFF0000, blendMode1);
1334         for (auto blendMode2 : blendModes) {
1335             std::shared_ptr<Drawing::ColorFilter> colorFilter2 =
1336                 Drawing::ColorFilter::CreateBlendModeColorFilter(0xFFFF00FF, blendMode2);
1337             std::shared_ptr<Drawing::ColorFilter> colorFilter3 =
1338                 Drawing::ColorFilter::CreateComposeColorFilter(*colorFilter1, *colorFilter2);
1339             auto filter = Drawing::Filter();
1340 
1341             // 5.设置视效效果CreateComposeColorFilter，将效果添加到笔刷
1342             filter.SetColorFilter(colorFilter3);
1343             brush.SetFilter(filter);
1344 
1345             // 6.绘制结果
1346             playbackCanvas_->AttachBrush(brush);
1347             playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
1348             playbackCanvas_->DrawImage(*image, 250, 300, SamplingOptions());
1349         }
1350     }
1351     playbackCanvas_->DetachBrush();
1352 
1353     // 7.组合Clip函数ClipPath，cilp也有抗锯齿效果，默认和笔刷效果保持一致
1354     Drawing::Path path;
1355     path.AddRect({ 200, 300, 700, 800 }); // rect region (200, 300, 700, 800)
1356     path.SetFillStyle(Drawing::PathFillType::INVERSE_WINDING);
1357     playbackCanvas_->Save();
1358     playbackCanvas_->ClipPath(path, Drawing::ClipOp::DIFFERENCE, true);
1359     playbackCanvas_->Clear(Drawing::Color::COLOR_GREEN);
1360     playbackCanvas_->Restore();
1361 }
1362 
1363 // Bitmap构造接口：Bitmap_Build_L1_31
1364 // Bitmap操作接口：MakeImage
1365 // cilp：ClipRect
1366 // transform：Translate
1367 // 抗锯齿：非AA
1368 // 透明度：不透明
1369 // 视效：CreateSrgbGammaToLinear
1370 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 25)
1371 {
1372     /*
1373      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
1374      */
1375     // 1.创建笔刷，设置笔刷是否为抗锯齿效果，抗锯齿：非AA
1376     using namespace Drawing;
1377     Drawing::Brush brush;
1378     brush.SetAntiAlias(false); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
1379 
1380     // 2.创建Bitmap，Bitmap_Build_L1_31
1381     Drawing::Bitmap bitmap;
1382     Drawing::BitmapFormat format { COLORTYPE_ARGB_4444, ALPHATYPE_UNPREMUL };
1383     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
1384     bitmap.ClearWithColor(0xFF789645); // 灰绿色
1385 
1386     // 3.组合Bitmap操作函数MakeImage，设置透明度,
1387     // 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
1388     Drawing::Bitmap bitmap1;
1389     bitmap1.Build(500, 500, format);    // bitmap Pixelwidth and Height
1390     bitmap1.ClearWithColor(0xFF789645); // 不透明效果，灰绿色
1391     std::shared_ptr<Image> image = bitmap1.MakeImage();
1392 
1393     // 4.设置视效效果CreateSrgbGammaToLinear，将效果添加到笔刷
1394     brush.SetColor(0xFF4F7091);
1395     auto filter = Drawing::Filter();
1396     filter.SetColorFilter(Drawing::ColorFilter::CreateSrgbGammaToLinear());
1397     brush.SetFilter(filter);
1398 
1399     // 5.组合transform函数Translate
1400     playbackCanvas_->Translate(200, 200); // 200 distance
1401 
1402     // 6.绘制结果
1403     playbackCanvas_->AttachBrush(brush);
1404     playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
1405     playbackCanvas_->DrawImage(*image, 250, 300, SamplingOptions());
1406     playbackCanvas_->DetachBrush();
1407 
1408     // 7.组合Clip函数ClipRect，cilp也有抗锯齿效果，默认和笔刷效果保持一致
1409     auto rect = Drawing::Rect(250, 300, 500, 500); // rect region (250, 300, 500, 500)
1410     playbackCanvas_->Save();
1411     playbackCanvas_->ClipRect(rect, Drawing::ClipOp::DIFFERENCE, false);
1412     playbackCanvas_->Clear(Drawing::Color::COLOR_RED);
1413     playbackCanvas_->Restore();
1414 }
1415 
1416 // Bitmap构造接口：Bitmap_Build_L1_31
1417 // Bitmap操作接口：SetImmutable/IsImmutable
1418 // cilp：ClipRoundRect(G2)
1419 // transform：Shear
1420 // 抗锯齿：AA
1421 // 透明度：透明
1422 // 视效：CreateBlendShader
1423 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 26)
1424 {
1425     /*
1426      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
1427      */
1428     // 1.创建笔刷，设置笔刷是否为抗锯齿效果，抗锯齿：AA
1429     using namespace Drawing;
1430     Drawing::Brush brush;
1431     brush.SetAntiAlias(true); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
1432 
1433     // 2.创建Bitmap，Bitmap_Build_L1_31
1434     Drawing::Bitmap bitmap;
1435     Drawing::BitmapFormat format { COLORTYPE_ARGB_4444, ALPHATYPE_UNPREMUL };
1436     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
1437     bitmap.ClearWithColor(0xFF789645); // 灰绿色
1438 
1439     // 3.组合Bitmap操作函数SetImmutable/IsImmutable，设置透明度,
1440     // 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
1441     Drawing::Bitmap bitmap1;
1442     bitmap1.Build(500, 500, format);    // 500 weidth & 500 height
1443     bitmap1.ClearWithColor(0x00789645); // 透明效果，灰绿色
1444     bitmap1.SetImmutable();
1445     if (bitmap1.IsImmutable()) {
1446         playbackCanvas_->DrawBackground(0xFF675800); // 深棕榈
1447     }
1448 
1449 
1450     brush.SetColor(0xFFFF0000);
1451 
1452     // 4.组合transform函数Shear
1453     playbackCanvas_->Shear(10.0f, 10.0f); // slope
1454 
1455     auto dst = Drawing::ShaderEffect::CreateColorShader(Drawing::Color::COLOR_RED);
1456     auto src = Drawing::ShaderEffect::CreateColorShader(Drawing::Color::COLOR_GREEN);
1457     for (auto blendMode : blendModes) {
1458         auto blendShader = Drawing::ShaderEffect::CreateBlendShader(*dst, *src, blendMode);
1459 
1460         // 5.设置视效效果CreateBlendShader，将效果添加到笔刷
1461         brush.SetShaderEffect(blendShader);
1462 
1463         // 6.绘制结果
1464         playbackCanvas_->AttachBrush(brush);
1465         playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
1466         playbackCanvas_->DrawBitmap(bitmap1, 250, 300);
1467     }
1468     playbackCanvas_->DetachBrush();
1469 
1470     // 7.组合Clip函数ClipRoundRect(G2)，cilp也有抗锯齿效果，默认和笔刷效果保持一致
1471     auto rect = Drawing::Rect(250, 250, 400, 400); // rect region (250, 250, 400, 400)
1472     auto rrect = Drawing::RoundRect(rect, 30.0f, 30.0f); // 30.0f is angle
1473     playbackCanvas_->Save();
1474     playbackCanvas_->ClipRoundRect(rrect, Drawing::ClipOp::DIFFERENCE, true);
1475     playbackCanvas_->Clear(Drawing::Color::COLOR_RED);
1476     playbackCanvas_->Restore();
1477 }
1478 
1479 // Bitmap构造接口：Bitmap_Build_L1_31
1480 // Bitmap操作接口：ClearWithColor
1481 // cilp：ClipRoundRect(G2_capsule)
1482 // transform：null
1483 // 抗锯齿：非AA
1484 // 透明度：半透明
1485 // 视效：CreateBlendModeColorFilter
1486 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 27)
1487 {
1488     /*
1489      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
1490      */
1491     // 1.创建笔刷，设置笔刷是否为抗锯齿效果，抗锯齿：非AA
1492     using namespace Drawing;
1493     Drawing::Brush brush;
1494     brush.SetAntiAlias(false); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
1495 
1496     // 2.创建Bitmap，Bitmap_Build_L1_31
1497     Drawing::Bitmap bitmap;
1498     Drawing::BitmapFormat format { COLORTYPE_ARGB_4444, ALPHATYPE_UNPREMUL };
1499     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
1500     bitmap.ClearWithColor(0xFF789645); // 灰绿色
1501 
1502     // 3.组合Bitmap操作函数ClearWithColor，设置透明度,
1503     // 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
1504     Drawing::Bitmap bitmap1;
1505     bitmap1.Build(500, 500, format);    // 500 weidth & 500 height
1506     bitmap1.ClearWithColor(0x894567FA); // 半透明效果
1507 
1508     // 4.无transform函数
1509 
1510 
1511     brush.SetColor(0xFFFF0000); // 红色
1512 
1513     for (auto blendMode : blendModes) {
1514         std::shared_ptr<Drawing::ColorFilter> colorFilter =
1515             Drawing::ColorFilter::CreateBlendModeColorFilter(0xFFFF0000, blendMode);
1516         auto filter = Drawing::Filter();
1517 
1518         // 5.设置视效效果CreateBlendModeColorFilter，将效果添加到笔刷
1519         filter.SetColorFilter(colorFilter);
1520         brush.SetFilter(filter);
1521 
1522         // 6.绘制结果
1523         playbackCanvas_->AttachBrush(brush);
1524         playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
1525         playbackCanvas_->DrawBitmap(bitmap1, 250, 300);
1526     }
1527     playbackCanvas_->DetachBrush();
1528 
1529     // 7.组合Clip函数ClipRoundRect(G2_capsule)，cilp也有抗锯齿效果，默认和笔刷效果保持一致
1530     auto rect = Drawing::Rect(250, 300, 400, 500); // rect region (250, 300, 400, 500)
1531     auto rrect = Drawing::RoundRect(rect, 50.0f, 50.0f); // 50.0f is angle
1532     playbackCanvas_->Save();
1533     playbackCanvas_->ClipRoundRect(rrect, Drawing::ClipOp::DIFFERENCE, false);
1534     playbackCanvas_->Clear(Drawing::Color::COLOR_RED);
1535     playbackCanvas_->Restore();
1536 }
1537 
1538 // Bitmap构造接口：Bitmap_Build_L1_31
1539 // Bitmap操作接口：ExtractSubset
1540 // cilp：ClipRoundRect(非G2)
1541 // transform：ConcatMatrix
1542 // 抗锯齿：AA
1543 // 透明度：不透明
1544 // 视效：CreateBlurMaskFilter
1545 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 28)
1546 {
1547     /*
1548      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
1549      */
1550     // 1.创建笔刷，设置笔刷是否为抗锯齿效果，抗锯齿：AA
1551     using namespace Drawing;
1552     Drawing::Brush brush;
1553     brush.SetAntiAlias(true); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
1554 
1555     // 2.创建Bitmap，Bitmap_Build_L1_31
1556     Drawing::Bitmap bitmap;
1557     Drawing::BitmapFormat format { COLORTYPE_ARGB_4444, ALPHATYPE_UNPREMUL };
1558     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
1559     bitmap.ClearWithColor(0xFF789645); // 灰绿色
1560 
1561     // 3.组合Bitmap操作函数ExtractSubset，设置透明度,
1562     // 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
1563     Drawing::Bitmap bitmap1;
1564     bitmap1.Build(500, 500, format);                       // 500 weidth & 500 height
1565     bitmap1.ClearWithColor(0xFF789645);                    // 不透明效果，灰绿色
1566     if (bitmap1.ExtractSubset(bitmap, Rect(0, 1, 2, 2))) { // rect(0, 1, 2, 2)
1567         playbackCanvas_->DrawBackground(0xFF675800); // 深棕榈
1568     }
1569 
1570     std::vector<Drawing::BlurType> blurTypes = { Drawing::BlurType::NORMAL, Drawing::BlurType::SOLID,
1571         Drawing::BlurType::OUTER, Drawing::BlurType::INNER };
1572 
1573     brush.SetColor(0xFFFF0000);
1574 
1575     // 4.组合transform函数ConcatMatrix
1576     Drawing::Matrix matrix;
1577     matrix.Rotate(15, 10, 10); // 15 angle 10 position
1578     playbackCanvas_->ConcatMatrix(matrix);
1579 
1580     for (auto& blurType : blurTypes) {
1581         auto filter = Drawing::Filter();
1582         filter.SetMaskFilter(Drawing::MaskFilter::CreateBlurMaskFilter(blurType, 10.0f, true));
1583 
1584         // 5.设置视效效果CreateBlurMaskFilter，将效果添加到笔刷
1585         brush.SetFilter(filter);
1586 
1587         // 6.绘制结果
1588         playbackCanvas_->AttachBrush(brush);
1589         playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
1590         playbackCanvas_->DrawBitmap(bitmap1, 250, 300);
1591     }
1592     playbackCanvas_->DetachBrush();
1593 
1594     // 7.组合Clip函数ClipRoundRect(非G2)，cilp也有抗锯齿效果，默认和笔刷效果保持一致
1595     auto rect = Drawing::Rect(300, 300, 400, 400); // rect region (300, 300, 400, 400)
1596     auto rrect = Drawing::RoundRect(rect, 30.0f, 30.0f); // 30.0f is angle
1597     playbackCanvas_->Save();
1598     playbackCanvas_->ClipRoundRect(rrect, Drawing::ClipOp::DIFFERENCE, true);
1599     playbackCanvas_->Clear(Drawing::Color::COLOR_RED);
1600     playbackCanvas_->Restore();
1601 }
1602 
1603 // Bitmap构造接口：Bitmap_Build_L1_31
1604 // Bitmap操作接口：PeekPixels
1605 // cilp：null
1606 // transform：Rotate
1607 // 抗锯齿：非AA
1608 // 透明度：透明
1609 // 视效：CreateLinearToSrgbGamma
1610 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 29)
1611 {
1612     /*
1613      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
1614      */
1615     // 1.创建笔刷，设置笔刷是否为抗锯齿效果，抗锯齿：非AA
1616     using namespace Drawing;
1617     Drawing::Brush brush;
1618     brush.SetAntiAlias(false); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
1619 
1620     // 2.创建Bitmap，Bitmap_Build_L1_31
1621     Drawing::Bitmap bitmap;
1622     Drawing::BitmapFormat format { COLORTYPE_ARGB_4444, ALPHATYPE_UNPREMUL };
1623     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
1624     bitmap.ClearWithColor(0xFF789645); // 灰绿色
1625 
1626     // 3.组合Bitmap操作函数PeekPixels，设置透明度,
1627     // 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
1628     Drawing::Bitmap bitmap1;
1629     bitmap1.Build(500, 500, format); // bitmap Pixelwidth and Height
1630     bitmap.ClearWithColor(0x00789645); // 透明效果，灰绿色
1631     Drawing::Pixmap pixmap;
1632     if (bitmap1.PeekPixels(pixmap)) {
1633         auto image = Image::MakeFromRaster(pixmap, nullptr, nullptr);
1634 
1635         // 4.设置视效效果CreateLinearToSrgbGamma，将效果添加到笔刷
1636         brush.SetColor(0xFF4F7091);
1637         auto filter = Drawing::Filter();
1638         filter.SetColorFilter(Drawing::ColorFilter::CreateLinearToSrgbGamma());
1639         brush.SetFilter(filter);
1640 
1641         // 5.组合transform函数Rotate
1642         playbackCanvas_->Rotate(30, 10, 10); // 30 angle 10 position
1643 
1644         // 6.绘制结果
1645         playbackCanvas_->AttachBrush(brush);
1646         playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
1647         playbackCanvas_->DrawImage(*image, 250, 300, SamplingOptions());
1648         playbackCanvas_->DetachBrush();
1649 
1650         // 7.无Clip函数
1651     }
1652 }
1653 
1654 // Bitmap构造接口：Bitmap_Build_L1_31
1655 // Bitmap操作接口：ReadPixels
1656 // cilp：ClipPath
1657 // transform：Scale(正常值）
1658 // 抗锯齿：AA
1659 // 透明度：半透明
1660 // 视效：CreateSrgbGammaToLinear
1661 DEF_DTK(Bitmap_Scene3, TestLevel::L2, 30)
1662 {
1663     /*
1664      *绘制流程说明：默认绘制两个Bitmap，即2、3两步，透明度效果只在第3步设置
1665      */
1666     // 1.创建笔刷，设置笔刷是否为抗锯齿效果，抗锯齿：AA
1667     using namespace Drawing;
1668     Drawing::Brush brush;
1669     brush.SetAntiAlias(true); // 设置笔刷抗锯齿，true为AA（抗锯齿），false为非AA（不抗锯齿）
1670 
1671     // 2.创建Bitmap，Bitmap_Build_L1_31
1672     Drawing::Bitmap bitmap;
1673     Drawing::BitmapFormat format { COLORTYPE_ARGB_4444, ALPHATYPE_UNPREMUL };
1674     bitmap.Build(500, 500, format);    // 500 weidth & 500 height
1675     bitmap.ClearWithColor(0xFF789645); // 灰绿色
1676 
1677     // 3.组合Bitmap操作函数ReadPixels，设置透明度,
1678     // 由最后一步填充的颜色值的前两位控制，00为透明效果，89为半透明，FF为不透明
1679     Drawing::Bitmap bitmap1;
1680     bitmap1.Build(500, 500, format);              // 500 weidth & 500 height
1681     bitmap1.ClearWithColor(0x89789645);           // 半透明效果，灰绿色
1682     auto imageInfo = Drawing::ImageInfo(500, 500, // 500 width & Height
1683         Drawing::ColorType::COLORTYPE_UNKNOWN, Drawing::AlphaType::ALPHATYPE_UNKNOWN);
1684     bitmap1.ReadPixels(imageInfo, bitmap.GetPixels(), bitmap.GetRowBytes(), 50, 50); // (50, 50) is position
1685 
1686     // 4.设置视效效果CreateSrgbGammaToLinear，将效果添加到笔刷
1687     brush.SetColor(0xFF4F7091);
1688     auto filter = Drawing::Filter();
1689     filter.SetColorFilter(Drawing::ColorFilter::CreateSrgbGammaToLinear());
1690     brush.SetFilter(filter);
1691 
1692     // 5.组合transform函数Scale(正常值）
1693     playbackCanvas_->Scale(2.0f, 2.0f); // ratio
1694 
1695     // 6.绘制结果
1696     playbackCanvas_->AttachBrush(brush);
1697     playbackCanvas_->DrawBitmap(bitmap, 200, 200); // 200，200 is bitmap position
1698     playbackCanvas_->DrawBitmap(bitmap1, 250, 300);
1699     playbackCanvas_->DetachBrush();
1700 
1701     // 7.组合Clip函数ClipPath，cilp也有抗锯齿效果，默认和笔刷效果保持一致
1702     Drawing::Path path;
1703     path.AddRect({ 200, 300, 700, 800 }); // rect region (200, 300, 700, 800)
1704     path.SetFillStyle(Drawing::PathFillType::INVERSE_WINDING);
1705     playbackCanvas_->Save();
1706     playbackCanvas_->ClipPath(path, Drawing::ClipOp::DIFFERENCE, true);
1707     playbackCanvas_->Clear(Drawing::Color::COLOR_GREEN);
1708     playbackCanvas_->Restore();
1709 }
1710 } // namespace Rosen
1711 } // namespace OHOS