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