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