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