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