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