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