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