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