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