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