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