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