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