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