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