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