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