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