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