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