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