• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1  /*
2  * Copyright (c) 2024 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 #ifndef GRAPHICS_EFFECT_GE_VISUAL_EFFECT_IMPL_H
16 #define GRAPHICS_EFFECT_GE_VISUAL_EFFECT_IMPL_H
17 
18 #include <memory>
19 #include <vector>
20 #include <any>
21 
22 #include "ge_shader.h"
23 #include "ge_shader_filter.h"
24 #include "ge_shader_filter_params.h"
25 #include "ge_visual_effect.h"
26 
27 #include "common/rs_vector3.h"
28 #include "common/rs_vector4.h"
29 #include "effect/color_filter.h"
30 #include "effect/runtime_effect.h"
31 #include "effect/runtime_shader_builder.h"
32 #include "utils/rect.h"
33 
34 namespace OHOS {
35 namespace Rosen {
36 namespace Drawing {
37 
38 class GE_EXPORT GEVisualEffectImpl {
39 public:
40     enum class FilterType {
41         NONE,
42         KAWASE_BLUR,
43         MESA_BLUR,
44         GREY,
45         AIBAR,
46         LINEAR_GRADIENT_BLUR,
47         MAGNIFIER,
48         WATER_RIPPLE,
49         DISPLACEMENT_DISTORT_FILTER,
50         COLOR_GRADIENT,
51         MASK_TRANSITION,
52         // Mask
53         RIPPLE_MASK,
54         DOUBLE_RIPPLE_MASK,
55         PIXEL_MAP_MASK,
56         RADIAL_GRADIENT_MASK,
57         WAVE_GRADIENT_MASK,
58         // Shader
59         DOT_MATRIX,
60         FLOW_LIGHT_SWEEP,
61         COMPLEX_SHADER,
62         SOUND_WAVE,
63         EDGE_LIGHT,
64         BEZIER_WARP,
65         DISPERSION,
66         CONTENT_LIGHT,
67         BORDER_LIGHT,
68         CONTOUR_DIAGONAL_FLOW_LIGHT,
69         WAVY_RIPPLE_LIGHT,
70         AURORA_NOISE,
71         PARTICLE_CIRCULAR_HALO,
72         DIRECTION_LIGHT,
73         VARIABLE_RADIUS_BLUR,
74         COLOR_GRADIENT_EFFECT,
75         LIGHT_CAVE,
76         MAX
77     };
78 
79     GEVisualEffectImpl(const std::string& name);
80 
81     ~GEVisualEffectImpl();
82 
83     void SetParam(const std::string& tag, int32_t param);
84     void SetParam(const std::string& tag, int64_t param);
85     void SetParam(const std::string& tag, float param);
86     void SetParam(const std::string& tag, double param);
87     void SetParam(const std::string& tag, const char* const param);
88 
89     void SetParam(const std::string& tag, const std::shared_ptr<Drawing::Image> param);
90     void SetParam(const std::string& tag, const std::shared_ptr<Drawing::ColorFilter> param);
91     void SetParam(const std::string& tag, const Drawing::Matrix param);
92     void SetParam(const std::string& tag, const std::pair<float, float>& param);
93     void SetParam(const std::string& tag, const std::vector<std::pair<float, float>>& param);
94     void SetParam(const std::string& tag, const std::vector<Vector2f>& param);
95     void SetParam(const std::string& tag, const std::array<Drawing::Point, POINT_NUM>& param);
96     void SetParam(const std::string& tag, bool param);
97     void SetParam(const std::string& tag, uint32_t param);
98     void SetParam(const std::string& tag, const std::vector<float>& param);
99     void SetParam(const std::string& tag, const std::shared_ptr<Drawing::GEShaderMask> param);
100     void SetParam(const std::string& tag, const Drawing::Color4f& param);
101     void SetParam(const std::string& tag, const Vector3f& param);
102     void SetParam(const std::string& tag, const Vector4f& param);
103     void SetParam(const std::string& tag, const RectF& param);
104 
SetFilterType(FilterType type)105     void SetFilterType(FilterType type)
106     {
107         filterType_ = type;
108     }
109 
GetFilterType()110     const FilterType& GetFilterType() const
111     {
112         return filterType_;
113     }
114 
MakeMESAParams()115     void MakeMESAParams()
116     {
117         mesaParams_ = std::make_shared<GEMESABlurShaderFilterParams>();
118     }
119 
GetMESAParams()120     const std::shared_ptr<GEMESABlurShaderFilterParams>& GetMESAParams() const
121     {
122         return mesaParams_;
123     }
124 
MakeKawaseParams()125     void MakeKawaseParams()
126     {
127         kawaseParams_ = std::make_shared<GEKawaseBlurShaderFilterParams>();
128     }
129 
GetKawaseParams()130     const std::shared_ptr<GEKawaseBlurShaderFilterParams>& GetKawaseParams() const
131     {
132         return kawaseParams_;
133     }
134 
MakeWaterRippleParams()135     void MakeWaterRippleParams()
136     {
137         waterRippleParams_ = std::make_shared<GEWaterRippleFilterParams>();
138     }
139 
GetWaterRippleParams()140     const std::shared_ptr<GEWaterRippleFilterParams>& GetWaterRippleParams() const
141     {
142         return waterRippleParams_;
143     }
144 
MakeAIBarParams()145     void MakeAIBarParams()
146     {
147         aiBarParams_ = std::make_shared<GEAIBarShaderFilterParams>();
148     }
149 
GetAIBarParams()150     const std::shared_ptr<GEAIBarShaderFilterParams>& GetAIBarParams() const
151     {
152         return aiBarParams_;
153     }
154 
MakeGreyParams()155     void MakeGreyParams()
156     {
157         greyParams_ = std::make_shared<GEGreyShaderFilterParams>();
158     }
159 
GetGreyParams()160     const std::shared_ptr<GEGreyShaderFilterParams>& GetGreyParams() const
161     {
162         return greyParams_;
163     }
164 
MakeLinearGradientBlurParams()165     void MakeLinearGradientBlurParams()
166     {
167         linearGradientBlurParams_ = std::make_shared<GELinearGradientBlurShaderFilterParams>();
168     }
169 
GetLinearGradientBlurParams()170     const std::shared_ptr<GELinearGradientBlurShaderFilterParams>& GetLinearGradientBlurParams() const
171     {
172         return linearGradientBlurParams_;
173     }
174 
MakeMagnifierParams()175     void MakeMagnifierParams()
176     {
177         magnifierParams_ = std::make_shared<GEMagnifierShaderFilterParams>();
178     }
179 
GetMagnifierParams()180     const std::shared_ptr<GEMagnifierShaderFilterParams>& GetMagnifierParams() const
181     {
182         return magnifierParams_;
183     }
184 
MakeColorGradientParams()185     void MakeColorGradientParams()
186     {
187         colorGradientParams_ = std::make_shared<GEColorGradientShaderFilterParams>();
188     }
189 
GetColorGradientParams()190     const std::shared_ptr<GEColorGradientShaderFilterParams>& GetColorGradientParams() const
191     {
192         return colorGradientParams_;
193     }
194 
MakeDisplacementDistortParams()195     void MakeDisplacementDistortParams()
196     {
197         displacementDistortParams_ = std::make_shared<GEDisplacementDistortFilterParams>();
198     }
199 
GetDisplacementDistortParams()200     const std::shared_ptr<GEDisplacementDistortFilterParams> &GetDisplacementDistortParams() const
201     {
202         return displacementDistortParams_;
203     }
204 
MakeSoundWaveParams()205     void MakeSoundWaveParams()
206     {
207         soundWaveParams_ = std::make_shared<GESoundWaveFilterParams>();
208     }
209 
GetSoundWaveParams()210     const std::shared_ptr<GESoundWaveFilterParams>& GetSoundWaveParams() const
211     {
212         return soundWaveParams_;
213     }
214 
MakeEdgeLightParams()215     void MakeEdgeLightParams()
216     {
217         edgeLightParams_ = std::make_shared<GEEdgeLightShaderFilterParams>();
218     }
219 
GetEdgeLightParams()220     const std::shared_ptr<GEEdgeLightShaderFilterParams>& GetEdgeLightParams() const
221     {
222         return edgeLightParams_;
223     }
224 
MakeBezierWarpParams()225     void MakeBezierWarpParams()
226     {
227         bezierWarpParams_ = std::make_shared<GEBezierWarpShaderFilterParams>();
228     }
229 
GetBezierWarpParams()230     const std::shared_ptr<GEBezierWarpShaderFilterParams>& GetBezierWarpParams() const
231     {
232         return bezierWarpParams_;
233     }
234 
MakeDispersionParams()235     void MakeDispersionParams()
236     {
237         dispersionParams_ = std::make_shared<GEDispersionShaderFilterParams>();
238     }
239 
GetDispersionParams()240     const std::shared_ptr<GEDispersionShaderFilterParams>& GetDispersionParams() const
241     {
242         return dispersionParams_;
243     }
244 
MakeDirectionLightParams()245     void MakeDirectionLightParams()
246     {
247         directionLightParams_ = std::make_shared<GEDirectionLightShaderFilterParams>();
248     }
249 
GetDirectionLightParams()250     const std::shared_ptr<GEDirectionLightShaderFilterParams>& GetDirectionLightParams() const
251     {
252         return directionLightParams_;
253     }
254 
MakeContentLightParams()255     void MakeContentLightParams()
256     {
257         contentLightParams_ = std::make_shared<GEContentLightFilterParams>();
258     }
259 
GetContentLightParams()260     const std::shared_ptr<GEContentLightFilterParams>& GetContentLightParams() const
261     {
262         return contentLightParams_;
263     }
264 
MakeContentDiagonalParams()265     void MakeContentDiagonalParams()
266     {
267         contentDiagonalParams_ = std::make_shared<GEContentDiagonalFlowLightShaderParams>();
268     }
269 
GetContenDiagonalParams()270     const std::shared_ptr<GEContentDiagonalFlowLightShaderParams>& GetContenDiagonalParams() const
271     {
272         return contentDiagonalParams_;
273     }
274 
MakeWavyRippleLightParams()275     void MakeWavyRippleLightParams()
276     {
277         wavyRippleLightParams_ = std::make_shared<GEWavyRippleLightShaderParams>();
278     }
279 
GetWavyRippleLightParams()280     const std::shared_ptr<GEWavyRippleLightShaderParams>& GetWavyRippleLightParams() const
281     {
282         return wavyRippleLightParams_;
283     }
284 
MakeAuroraNoiseParams()285     void MakeAuroraNoiseParams()
286     {
287         auroNoiseParams_ = std::make_shared<GEAuroraNoiseShaderParams>();
288     }
289 
GetAuroraNoiseParams()290     const std::shared_ptr<GEAuroraNoiseShaderParams>& GetAuroraNoiseParams() const
291     {
292         return auroNoiseParams_;
293     }
294 
MakeParticleCircularHaloParams()295     void MakeParticleCircularHaloParams()
296     {
297         particleCircularHaloParams_ = std::make_shared<GEParticleCircularHaloShaderParams>();
298     }
299 
GetParticleCircularHaloParams()300     const std::shared_ptr<GEParticleCircularHaloShaderParams>& GetParticleCircularHaloParams() const
301     {
302         return particleCircularHaloParams_;
303     }
304 
SetCache(std::shared_ptr<std::any> cacheData)305     void SetCache(std::shared_ptr<std::any> cacheData)
306     {
307         cacheAnyPtr_ = cacheData;
308     }
309 
GetCache()310     std::shared_ptr<std::any> GetCache()
311     {
312         return cacheAnyPtr_;
313     }
314 
MakeRippleMaskParams()315     void MakeRippleMaskParams()
316     {
317         rippleMaskParams_ = std::make_shared<GERippleShaderMaskParams>();
318     }
319 
GetRippleMaskParams()320     const std::shared_ptr<GERippleShaderMaskParams>& GetRippleMaskParams() const
321     {
322         return rippleMaskParams_;
323     }
324 
MakeDoubleRippleMaskParams()325     void MakeDoubleRippleMaskParams()
326     {
327         doubleRippleMaskParams_ = std::make_shared<GEDoubleRippleShaderMaskParams>();
328     }
329 
GetDoubleRippleMaskParams()330     const std::shared_ptr<GEDoubleRippleShaderMaskParams>& GetDoubleRippleMaskParams() const
331     {
332         return doubleRippleMaskParams_;
333     }
334 
MakeRadialGradientMaskParams()335     void MakeRadialGradientMaskParams()
336     {
337         radialGradientMaskParams_ = std::make_shared<GERadialGradientShaderMaskParams>();
338     }
339 
GetRadialGradientMaskParams()340     const std::shared_ptr<GERadialGradientShaderMaskParams>& GetRadialGradientMaskParams() const
341     {
342         return radialGradientMaskParams_;
343     }
344 
MakePixelMapMaskParams()345     void MakePixelMapMaskParams()
346     {
347         pixelMapMaskParams_ = std::make_shared<GEPixelMapMaskParams>();
348     }
349 
GetPixelMapMaskParams()350     const std::shared_ptr<GEPixelMapMaskParams>& GetPixelMapMaskParams() const
351     {
352         return pixelMapMaskParams_;
353     }
354 
MakeWaveGradientMaskParams()355     void MakeWaveGradientMaskParams()
356     {
357         waveGradientMaskParams_ = std::make_shared<GEWaveGradientShaderMaskParams>();
358     }
359 
GetWaveGradientMaskParams()360     const std::shared_ptr<GEWaveGradientShaderMaskParams>& GetWaveGradientMaskParams() const
361     {
362         return waveGradientMaskParams_;
363     }
364 
MakeMaskTransitionParams()365     void MakeMaskTransitionParams()
366     {
367         maskTransitionParams_ = std::make_shared<GEMaskTransitionShaderFilterParams>();
368     }
369 
GetMaskTransitionParams()370     const std::shared_ptr<GEMaskTransitionShaderFilterParams>& GetMaskTransitionParams() const
371     {
372         return maskTransitionParams_;
373     }
374 
MakeVariableRadiusBlurParams()375     void MakeVariableRadiusBlurParams()
376     {
377         variableRadiusBlurParams_ = std::make_shared<GEVariableRadiusBlurShaderFilterParams>();
378     }
379 
GetVariableRadiusBlurParams()380     const std::shared_ptr<GEVariableRadiusBlurShaderFilterParams>& GetVariableRadiusBlurParams() const
381     {
382         return variableRadiusBlurParams_;
383     }
384 
MakeColorGradientEffectParams()385     void MakeColorGradientEffectParams()
386     {
387         colorGradientEffectParams_ = std::make_shared<GEXColorGradientEffectParams>();
388     }
389 
GetColorGradientEffectParams()390     const std::shared_ptr<GEXColorGradientEffectParams>& GetColorGradientEffectParams() const
391     {
392         return colorGradientEffectParams_;
393     }
394 
MakeLightCaveParams()395     void MakeLightCaveParams()
396     {
397         lightCaveShaderParams_ = std::make_shared<GEXLightCaveShaderParams>();
398     }
399 
GetLightCaveParams()400     const std::shared_ptr<GEXLightCaveShaderParams>& GetLightCaveParams() const
401     {
402         return lightCaveShaderParams_;
403     }
404 
MakeBorderLightParams()405     void MakeBorderLightParams()
406     {
407         borderLightParams_ = std::make_shared<GEBorderLightShaderParams>();
408     }
409 
GetBorderLightParams()410     const std::shared_ptr<GEBorderLightShaderParams>& GetBorderLightParams() const
411     {
412         return borderLightParams_;
413     }
414 
415 private:
416     static std::map<const std::string, std::function<void(GEVisualEffectImpl*)>> g_initialMap;
417     std::shared_ptr<std::any> cacheAnyPtr_ = nullptr;
418     void SetMESABlurParams(const std::string& tag, float param);
419     void SetAIBarParams(const std::string& tag, float param);
420     void SetGreyParams(const std::string& tag, float param);
421     void SetLinearGradientBlurParams(const std::string& tag, float param);
422 
423     void SetMagnifierParamsFloat(const std::string& tag, float param);
424     void SetMagnifierParamsUint32(const std::string& tag, uint32_t param);
425 
426     void SetWaterRippleParams(const std::string& tag, float param);
427     void SetRippleMaskParamsFloat(const std::string& tag, float param);
428     void SetDoubleRippleMaskParamsFloat(const std::string& tag, float param);
429     void SetRadialGradientMaskParamsFloat(const std::string& tag, float param);
430     void SetWaveGradientMaskParamsFloat(const std::string& tag, float param);
431     void SetSoundWaveParams(const std::string& tag, float param);
432     void SetSoundWaveParams(const std::string& tag, const Drawing::Color4f& param);
433     void SetDirectionLightParamsFloat(const std::string& tag, float param);
434     void SetEdgeLightParams(const std::string& tag, float param);
435     void SetDispersionParams(const std::string& tag, float param);
436     void SetDispersionParams(const std::string& tag, const std::pair<float, float>& param);
437     void SetContentLightParams(const std::string& tag, float param);
438     void SetContentDiagonalFlowParams(const std::string& tag, const Vector4f& param);
439     void SetContentDiagonalFlowParams(const std::string& tag, float param);
440     void SetWavyRippleLightParams(const std::string& tag, float param);
441     void SetWavyRippleLightParams(const std::string& tag, const std::pair<float, float>& param);
442     void SetAuroraNoiseParams(const std::string& tag, float param);
443     void SetPixelMapMaskParams(const std::string& tag, const RectF& param);
444     void SetPixelMapMaskParams(const std::string& tag, const Vector4f& param);
445     void SetParticleCircularHaloParams(const std::string& tag, float param);
446     void SetParticleCircularHaloParams(const std::string& tag, const std::pair<float, float>& param);
447     void SetMaskTransitionParamsFloat(const std::string& tag, float param);
448     void SetVariableRadiusBlurParams(const std::string& tag, float param);
449     void SetColorGradientEffectParams(const std::string& tag, float param);
450     void SetColorGradientEffectParams(const std::string& tag, const Vector4f& param);
451     void SetColorGradientEffectParams(const std::string& tag, const std::pair<float, float>&  param);
452     void SetBezierWarpParams(const std::string& tag, const std::pair<float, float>& param);
453     void SetLightCaveParams(const std::string& tag, const Vector4f& param);
454     void SetLightCaveParams(const std::string& tag, const std::pair<float, float>& param);
455     void SetLightCaveParams(const std::string& tag, float param);
456     void SetBorderLightParams(const std::string& tag, const Vector3f& param);
457     void SetBorderLightParams(const std::string& tag, const Vector4f& param);
458     void SetBorderLightParams(const std::string& tag, float param);
459 
460     FilterType filterType_ = GEVisualEffectImpl::FilterType::NONE;
461 
462     // ShaderFilter Params
463     std::shared_ptr<GEKawaseBlurShaderFilterParams> kawaseParams_ = nullptr;
464     std::shared_ptr<GEMESABlurShaderFilterParams> mesaParams_ = nullptr;
465     std::shared_ptr<GEAIBarShaderFilterParams> aiBarParams_ = nullptr;
466     std::shared_ptr<GEColorGradientShaderFilterParams> colorGradientParams_ = nullptr;
467     std::shared_ptr<GEGreyShaderFilterParams> greyParams_ = nullptr;
468     std::shared_ptr<GELinearGradientBlurShaderFilterParams> linearGradientBlurParams_ = nullptr;
469 
470     std::shared_ptr<GEMagnifierShaderFilterParams> magnifierParams_ = nullptr;
471     std::shared_ptr<GEWaterRippleFilterParams> waterRippleParams_ = nullptr;
472 
473     std::shared_ptr<GERadialGradientShaderMaskParams> radialGradientMaskParams_ = nullptr;
474     std::shared_ptr<GEPixelMapMaskParams> pixelMapMaskParams_ = nullptr;
475     std::shared_ptr<GERippleShaderMaskParams> rippleMaskParams_ = nullptr;
476     std::shared_ptr<GEDoubleRippleShaderMaskParams> doubleRippleMaskParams_ = nullptr;
477     std::shared_ptr<GEWaveGradientShaderMaskParams> waveGradientMaskParams_ = nullptr;
478     std::shared_ptr<GEDisplacementDistortFilterParams> displacementDistortParams_ = nullptr;
479     std::shared_ptr<GESoundWaveFilterParams> soundWaveParams_ = nullptr;
480     std::shared_ptr<GEEdgeLightShaderFilterParams> edgeLightParams_ = nullptr;
481     std::shared_ptr<GEBezierWarpShaderFilterParams> bezierWarpParams_ = nullptr;
482     std::shared_ptr<GEDispersionShaderFilterParams> dispersionParams_ = nullptr;
483     std::shared_ptr<GEContentLightFilterParams> contentLightParams_ = nullptr;
484     std::shared_ptr<GEDirectionLightShaderFilterParams> directionLightParams_ = nullptr;
485     std::shared_ptr<GEMaskTransitionShaderFilterParams> maskTransitionParams_ = nullptr;
486 
487     std::shared_ptr<GEContentDiagonalFlowLightShaderParams> contentDiagonalParams_ = nullptr;
488     std::shared_ptr<GEWavyRippleLightShaderParams> wavyRippleLightParams_ = nullptr;
489     std::shared_ptr<GEAuroraNoiseShaderParams> auroNoiseParams_ = nullptr;
490     std::shared_ptr<GEParticleCircularHaloShaderParams> particleCircularHaloParams_ = nullptr;
491     std::shared_ptr<GEVariableRadiusBlurShaderFilterParams> variableRadiusBlurParams_ = nullptr;
492     std::shared_ptr<GEXColorGradientEffectParams> colorGradientEffectParams_ = nullptr;
493     std::shared_ptr<GEXLightCaveShaderParams> lightCaveShaderParams_ = nullptr;
494     std::shared_ptr<GEBorderLightShaderParams> borderLightParams_ = nullptr;
495 };
496 
497 } // namespace Drawing
498 } // namespace Rosen
499 } // namespace OHOS
500 
501 #endif // GRAPHICS_EFFECT_GE_VISUAL_EFFECT_IMPL_H
502