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 compliance with the License.
5 * You may obtain 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 "ui_effect/property/include/rs_ui_mask_base.h"
17
18 #include "platform/common/rs_log.h"
19 #include "pixel_map.h"
20 #include "ui_effect/mask/include/pixel_map_mask_para.h"
21 #include "ui_effect/mask/include/radial_gradient_mask_para.h"
22 #include "ui_effect/mask/include/ripple_mask_para.h"
23 #include "ui_effect/mask/include/wave_gradient_mask_para.h"
24
25 #undef LOG_TAG
26 #define LOG_TAG "RSNGMaskBase"
27
28 namespace OHOS {
29 namespace Rosen {
30 using MaskCreator = std::function<std::shared_ptr<RSNGMaskBase>()>;
31 using MaskConvertor = std::function<std::shared_ptr<RSNGMaskBase>(std::shared_ptr<MaskPara>)>;
32
33 static std::unordered_map<RSNGEffectType, MaskCreator> creatorLUT = {
__anon27629e0f0102null34 {RSNGEffectType::RIPPLE_MASK, [] {
35 return std::make_shared<RSNGRippleMask>();
36 }
37 },
__anon27629e0f0202null38 {RSNGEffectType::PIXEL_MAP_MASK, [] {
39 return std::make_shared<RSNGPixelMapMask>();
40 }
41 },
__anon27629e0f0302null42 {RSNGEffectType::RADIAL_GRADIENT_MASK, [] {
43 return std::make_shared<RSNGRadialGradientMask>();
44 }
45 },
__anon27629e0f0402null46 {RSNGEffectType::WAVE_GRADIENT_MASK, [] {
47 return std::make_shared<RSNGWaveGradientMask>();
48 }
49 },
50 };
51
52 namespace {
ConvertRippleMaskPara(std::shared_ptr<MaskPara> maskPara)53 std::shared_ptr<RSNGMaskBase> ConvertRippleMaskPara(std::shared_ptr<MaskPara> maskPara)
54 {
55 auto mask = RSNGMaskBase::Create(RSNGEffectType::RIPPLE_MASK);
56 if (mask == nullptr) {
57 return nullptr;
58 }
59 auto rippleMask = std::static_pointer_cast<RSNGRippleMask>(mask);
60 auto rippleMaskPara = std::static_pointer_cast<RippleMaskPara>(maskPara);
61 rippleMask->Setter<RippleMaskRadiusTag>(rippleMaskPara->GetRadius());
62 rippleMask->Setter<RippleMaskWidthTag>(rippleMaskPara->GetWidth());
63 rippleMask->Setter<RippleMaskCenterTag>(rippleMaskPara->GetCenter());
64 rippleMask->Setter<RippleMaskOffsetTag>(rippleMaskPara->GetWidthCenterOffset());
65 return rippleMask;
66 }
67
ConvertPixelMapMaskPara(std::shared_ptr<MaskPara> maskPara)68 std::shared_ptr<RSNGMaskBase> ConvertPixelMapMaskPara(std::shared_ptr<MaskPara> maskPara)
69 {
70 auto mask = RSNGMaskBase::Create(RSNGEffectType::PIXEL_MAP_MASK);
71 if (mask == nullptr) {
72 return nullptr;
73 }
74 auto pixelMapMask = std::static_pointer_cast<RSNGPixelMapMask>(mask);
75 auto pixelMapMaskPara = std::static_pointer_cast<PixelMapMaskPara>(maskPara);
76 pixelMapMask->Setter<PixelMapMaskSrcTag>(pixelMapMaskPara->GetSrc());
77 pixelMapMask->Setter<PixelMapMaskDstTag>(pixelMapMaskPara->GetDst());
78 pixelMapMask->Setter<PixelMapMaskFillColorTag>(pixelMapMaskPara->GetFillColor());
79 pixelMapMask->Setter<PixelMapMaskImageTag>(pixelMapMaskPara->GetPixelMap());
80 return pixelMapMask;
81 }
82
ConvertRadialGradientMaskPara(std::shared_ptr<MaskPara> maskPara)83 std::shared_ptr<RSNGMaskBase> ConvertRadialGradientMaskPara(std::shared_ptr<MaskPara> maskPara)
84 {
85 auto mask = RSNGMaskBase::Create(RSNGEffectType::RADIAL_GRADIENT_MASK);
86 if (mask == nullptr) {
87 return nullptr;
88 }
89 auto radialGradientMask = std::static_pointer_cast<RSNGRadialGradientMask>(mask);
90 auto radialGradientMaskPara = std::static_pointer_cast<RadialGradientMaskPara>(maskPara);
91 radialGradientMask->Setter<RadialGradientMaskCenterTag>(radialGradientMaskPara->GetCenter());
92 radialGradientMask->Setter<RadialGradientMaskRadiusXTag>(radialGradientMaskPara->GetRadiusX());
93 radialGradientMask->Setter<RadialGradientMaskRadiusYTag>(radialGradientMaskPara->GetRadiusY());
94 radialGradientMask->Setter<RadialGradientMaskColorsTag>(radialGradientMaskPara->GetColors());
95 radialGradientMask->Setter<RadialGradientMaskPositionsTag>(radialGradientMaskPara->GetPositions());
96 return radialGradientMask;
97 }
98
ConvertWaveGradientMaskPara(std::shared_ptr<MaskPara> maskPara)99 std::shared_ptr<RSNGMaskBase> ConvertWaveGradientMaskPara(std::shared_ptr<MaskPara> maskPara)
100 {
101 auto mask = RSNGMaskBase::Create(RSNGEffectType::WAVE_GRADIENT_MASK);
102 if (mask == nullptr) {
103 return nullptr;
104 }
105 auto waveGradientMask = std::static_pointer_cast<RSNGWaveGradientMask>(mask);
106 auto waveGradientMaskPara = std::static_pointer_cast<WaveGradientMaskPara>(maskPara);
107 waveGradientMask->Setter<WaveGradientMaskWaveCenterTag>(waveGradientMaskPara->GetWaveCenter());
108 waveGradientMask->Setter<WaveGradientMaskWaveWidthTag>(waveGradientMaskPara->GetWaveWidth());
109 waveGradientMask->Setter<WaveGradientMaskPropagationRadiusTag>(waveGradientMaskPara->GetPropagationRadius());
110 waveGradientMask->Setter<WaveGradientMaskBlurRadiusTag>(waveGradientMaskPara->GetBlurRadius());
111 waveGradientMask->Setter<WaveGradientMaskTurbulenceStrengthTag>(waveGradientMaskPara->GetTurbulenceStrength());
112
113 return waveGradientMask;
114 }
115 }
116
117 static std::unordered_map<MaskPara::Type, MaskConvertor> convertorLUT = {
118 { MaskPara::Type::RIPPLE_MASK, ConvertRippleMaskPara },
119 { MaskPara::Type::PIXEL_MAP_MASK, ConvertPixelMapMaskPara },
120 { MaskPara::Type::RADIAL_GRADIENT_MASK, ConvertRadialGradientMaskPara },
121 { MaskPara::Type::WAVE_GRADIENT_MASK, ConvertWaveGradientMaskPara },
122 };
123
Create(RSNGEffectType type)124 std::shared_ptr<RSNGMaskBase> RSNGMaskBase::Create(RSNGEffectType type)
125 {
126 auto it = creatorLUT.find(type);
127 return it != creatorLUT.end() ? it->second() : nullptr;
128 }
129
Create(std::shared_ptr<MaskPara> maskPara)130 std::shared_ptr<RSNGMaskBase> RSNGMaskBase::Create(std::shared_ptr<MaskPara> maskPara)
131 {
132 if (!maskPara) {
133 return nullptr;
134 }
135
136 auto it = convertorLUT.find(maskPara->GetMaskParaType());
137 return it != convertorLUT.end() ? it->second(maskPara) : nullptr;
138 }
139
140 } // namespace Rosen
141 } // namespace OHOS
142