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