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