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