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