diff --git a/BUILD.gn b/BUILD.gn index 340b28c69ee5e87265e9afaad5442ae4751305ab..1f9cd063816fedb45491996cae0c483f935bbaf3 100755 --- a/BUILD.gn +++ b/BUILD.gn @@ -70,6 +70,7 @@ ohos_source_set("graphics_effect_src") { "src/ge_edge_light_shader_filter.cpp", "src/ge_external_dynamic_loader.cpp", "src/ge_filter_composer.cpp", + "src/ge_frame_gradient_shader_mask.cpp", "src/ge_grey_shader_filter.cpp", "src/ge_kawase_blur_shader_filter.cpp", "src/ge_linear_gradient_blur_shader_filter.cpp", diff --git a/include/ge_frame_gradient_shader_mask.h b/include/ge_frame_gradient_shader_mask.h new file mode 100644 index 0000000000000000000000000000000000000000..4e098ae317a7d14a5d2f5e85585cd5d3c64e3dfe --- /dev/null +++ b/include/ge_frame_gradient_shader_mask.h @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef GRAPHICS_EFFECT_GE_FRAME_GRADIENT_MASK_H +#define GRAPHICS_EFFECT_GE_FRAME_GRADIENT_MASK_H + +#include "draw/canvas.h" +#include "ge_shader_mask.h" +#include "ge_shader_filter_params.h" +#include "ge_log.h" + +namespace OHOS { +namespace Rosen { +namespace Drawing { + +class GE_EXPORT GEFrameGradientShaderMask : public GEShaderMask { +public: + explicit GEFrameGradientShaderMask(const GEFrameGradientMaskParams& param); + GEFrameGradientShaderMask(const GEFrameGradientShaderMask&) = delete; + GEFrameGradientShaderMask operator=(const GEFrameGradientShaderMask&) = delete; + GEFrameGradientShaderMask(GEFrameGradientShaderMask&&) = delete; + GEFrameGradientShaderMask& operator=(GEFrameGradientShaderMask&&) = delete; + ~GEFrameGradientShaderMask() override = default; + + std::shared_ptr GenerateDrawingShader(float width, float height) const override; + std::shared_ptr GenerateDrawingShaderHasNormal(float width, float height) const override; + +private: + void MakeFrameGradientMaskShaderEffect() const; + Vector4f gradientBezierControlPoints_; + float cornerRadius_ = 0.0f; + float frameWidth_ = 0.0f; +}; +} // Drawing +} // namespace Rosen +} // namespace OHOS + +#endif // GRAPHICS_EFFECT_GE_FRAME_GRADIENT_MASK_H \ No newline at end of file diff --git a/include/ge_shader_filter_params.h b/include/ge_shader_filter_params.h index 25b5b4a6cb2b8dd4b073ff8ec8df1c297fac3f81..3a16d8bbbcb5d57e3cc45472107a7abb47e8a4dd 100644 --- a/include/ge_shader_filter_params.h +++ b/include/ge_shader_filter_params.h @@ -17,6 +17,7 @@ #include #include +#include #include #include "common/rs_vector2.h" @@ -520,6 +521,92 @@ struct GEBorderLightShaderParams { float cornerRadius = 0.0f; }; +constexpr int ARRAY_SIZE_FOUR = 4; + +const char GEX_SHADER_AIBAR_GLOW[] = "AIBarGlow"; +const char GEX_SHADER_AIBAR_GLOW_LTWH[] = "AIBarGlow_LTWH"; +const char GEX_SHADER_AIBAR_GLOW_STRECTCH_FACTOR[] = "AIBarGlow_StretchFactor"; +const char GEX_SHADER_AIBAR_GLOW_BAR_ANGLE[] = "AIBarGlow_BarAngle"; +const char GEX_SHADER_AIBAR_GLOW_COLOR0[] = "AIBarGlow_Color0"; +const char GEX_SHADER_AIBAR_GLOW_COLOR1[] = "AIBarGlow_Color1"; +const char GEX_SHADER_AIBAR_GLOW_COLOR2[] = "AIBarGlow_Color2"; +const char GEX_SHADER_AIBAR_GLOW_COLOR3[] = "AIBarGlow_Color3"; +const char GEX_SHADER_AIBAR_GLOW_POS0[] = "AIBarGlow_Position0"; +const char GEX_SHADER_AIBAR_GLOW_POS1[] = "AIBarGlow_Position1"; +const char GEX_SHADER_AIBAR_GLOW_POS2[] = "AIBarGlow_Position2"; +const char GEX_SHADER_AIBAR_GLOW_POS3[] = "AIBarGlow_Position3"; +const char GEX_SHADER_AIBAR_GLOW_STRENGTH[] = "AIBarGlow_Strength"; +const char GEX_SHADER_AIBAR_GLOW_BRIGHTNESS[] = "AIBarGlow_Brightness"; +const char GEX_SHADER_AIBAR_GLOW_PROGRESS[] = "AIBarGlow_Progress"; +struct GEXAIBarGlowEffectParams { + Vector4f LTWH; + float stretchFactor = 0.0f; + float barAngle = 0.0f; + std::array colors; + std::array, ARRAY_SIZE_FOUR> positions; + Vector4f strengths; + float brightness; + float progress; +}; + +const char GEX_SHADER_ROUNDED_RECT_FLOWLIGHT[] = "RoundedRectFlowlight"; +const char GEX_SHADER_ROUNDED_RECT_FLOWLIGHT_START_END_POS[] = "RoundedRectFlowlight_StartEndPosition"; +const char GEX_SHADER_ROUNDED_RECT_FLOWLIGHT_WAVE_LENGTH[] = "RoundedRectFlowlight_WaveLength"; +const char GEX_SHADER_ROUNDED_RECT_FLOWLIGHT_WAVE_TOP[] = "RoundedRectFlowlight_WaveTop"; +const char GEX_SHADER_ROUNDED_RECT_FLOWLIGHT_CORNER_RADIUS[] = "RoundedRectFlowlight_CornerRadius"; +const char GEX_SHADER_ROUNDED_RECT_FLOWLIGHT_BRIGHTNESS[] = "RoundedRectFlowlight_Brightness"; +const char GEX_SHADER_ROUNDED_RECT_FLOWLIGHT_SCALE[] = "RoundedRectFlowlight_Scale"; +const char GEX_SHADER_ROUNDED_RECT_FLOWLIGHT_SHARPING[] = "RoundedRectFlowlight_Sharping"; +const char GEX_SHADER_ROUNDED_RECT_FLOWLIGHT_FEATHERING[] = "RoundedRectFlowlight_Feathering"; +const char GEX_SHADER_ROUNDED_RECT_FLOWLIGHT_FEATHERING_BEZIER_CONTROL_POINTS[] = + "RoundedRectFlowlight_FeatheringBezierControlPoints"; +const char GEX_SHADER_ROUNDED_RECT_FLOWLIGHT_GRADIENT_BEZIER_CONTROL_POINTS[] = + "RoundedRectFlowlight_GradientBezierControlPoints"; +const char GEX_SHADER_ROUNDED_RECT_FLOWLIGHT_COLOR[] = "RoundedRectFlowlight_Color"; +const char GEX_SHADER_ROUNDED_RECT_FLOWLIGHT_PROGRESS[] = "RoundedRectFlowlight_Progress"; +struct GEXRoundedRectFlowlightEffectParams { + std::pair startEndPosition; + float waveLength = 0.0f; + float waveTop = 0.0f; + float cornerRadius = 0.0f; + float brightness = 0.0f; + float scale = 0.0f; + float sharping = 0.0f; + float feathering = 0.0f; + Vector4f featheringBezierControlPoints; + Vector4f gradientBezierControlPoints; + Vector4f color; + float progress = 0.0f; +}; + +const char GEX_SHADER_GRADIENT_FLOW_COLORS[] = "GradientFlowColors"; +const char GEX_SHADER_GRADIENT_FLOW_COLORS_COLOR0[] = "GradientFlowColors_Color0"; +const char GEX_SHADER_GRADIENT_FLOW_COLORS_COLOR1[] = "GradientFlowColors_Color1"; +const char GEX_SHADER_GRADIENT_FLOW_COLORS_COLOR2[] = "GradientFlowColors_Color2"; +const char GEX_SHADER_GRADIENT_FLOW_COLORS_COLOR3[] = "GradientFlowColors_Color3"; +const char GEX_SHADER_GRADIENT_FLOW_COLORS_GRADIENT_BEGIN[] = "GradientFlowColors_GradientBegin"; +const char GEX_SHADER_GRADIENT_FLOW_COLORS_GRADIENT_END[] = "GradientFlowColors_GradientEnd"; +const char GEX_SHADER_GRADIENT_FLOW_COLORS_EFFECT_ALPHA[] = "GradientFlowColors_EffectAlpha"; +const char GEX_SHADER_GRADIENT_FLOW_COLORS_PROGRESS[] = "GradientFlowColors_Progress"; +struct GEXGradientFlowColorsEffectParams { + std::array colors; + float gradientBegin = 0.0f; + float gradientEnd = 0.0f; + float effectAlpha = 0.0f; + float progress = 0.0f; +}; + +const char GE_MASK_FRAME_GRADIENT[] = "FrameGradientMask"; +const char GE_MASK_FRAME_GRADIENT_GRADIENT_BEZIER_CONTROL_POINTS[] = + "FrameGradientMask_GradientBezierControlPoints"; +const char GE_MASK_FRAME_GRADIENT_CORNER_RADIUS[] = "FrameGradientMask_CornerRadius"; +const char GE_MASK_FRAME_GRADIENT_FRAME_WIDTH[] = "FrameGradientMask_FrameWidth"; +struct GEFrameGradientMaskParams { + Vector4f gradientBezierControlPoints; + float cornerRadius = 0.0f; + float frameWidth = 0.0f; +}; + } // namespace Drawing } // namespace Rosen } // namespace OHOS diff --git a/include/ge_visual_effect_impl.h b/include/ge_visual_effect_impl.h index 4f022135e34c0726c763f6be52431d8ac53a7a5b..2f36ba31a4e20c7237b0b1c9e83772a5ac0dccee 100644 --- a/include/ge_visual_effect_impl.h +++ b/include/ge_visual_effect_impl.h @@ -15,7 +15,11 @@ #ifndef GRAPHICS_EFFECT_GE_VISUAL_EFFECT_IMPL_H #define GRAPHICS_EFFECT_GE_VISUAL_EFFECT_IMPL_H +#include +#include +#include #include +#include #include #include #include @@ -56,6 +60,7 @@ public: PIXEL_MAP_MASK, RADIAL_GRADIENT_MASK, WAVE_GRADIENT_MASK, + FRAME_GRADIENT_MASK, // Shader DOT_MATRIX, FLOW_LIGHT_SWEEP, @@ -74,6 +79,9 @@ public: VARIABLE_RADIUS_BLUR, COLOR_GRADIENT_EFFECT, LIGHT_CAVE, + AIBAR_GLOW, + ROUNDED_RECT_FLOWLIGHT, + GRADIENT_FLOW_COLORS, MAX }; @@ -81,6 +89,13 @@ public: ~GEVisualEffectImpl(); + template + using TagMap = std::map&, const std::any&)>>; + + template + void ApplyTagParams(const std::string& tag, const std::any& value, + std::shared_ptr& params, const TagMap& tagMap); + void SetParam(const std::string& tag, int32_t param); void SetParam(const std::string& tag, int64_t param); void SetParam(const std::string& tag, float param); @@ -423,6 +438,46 @@ public: return canvasInfo_; } + void MakeAIBarGlowEffectParams() + { + AIBarGlowEffectParams_ = std::make_shared(); + } + + const std::shared_ptr& GetAIBarGlowEffectParams() const + { + return AIBarGlowEffectParams_; + } + + void MakeRoundedRectFlowlightEffectParams() + { + roundedRectFlowlightEffectParams_ = std::make_shared(); + } + + const std::shared_ptr& GetRoundedRectFlowlightEffectParams() const + { + return roundedRectFlowlightEffectParams_; + } + + void MakeGradientFlowColorsEffectParams() + { + gradientFlowColorsEffectParams_ = std::make_shared(); + } + + const std::shared_ptr& GetGradientFlowColorsEffectParams() const + { + return gradientFlowColorsEffectParams_; + } + + void MakeFrameGradientMaskParams() + { + frameGradientMaskParams_ = std::make_shared(); + } + + const std::shared_ptr& GetFrameGradientMaskParams() const + { + return frameGradientMaskParams_; + } + private: static std::map> g_initialMap; std::shared_ptr cacheAnyPtr_ = nullptr; @@ -504,10 +559,13 @@ private: std::shared_ptr colorGradientEffectParams_ = nullptr; std::shared_ptr lightCaveShaderParams_ = nullptr; std::shared_ptr borderLightParams_ = nullptr; + std::shared_ptr AIBarGlowEffectParams_ = nullptr; + std::shared_ptr roundedRectFlowlightEffectParams_ = nullptr; + std::shared_ptr gradientFlowColorsEffectParams_ = nullptr; + std::shared_ptr frameGradientMaskParams_ = nullptr; }; } // namespace Drawing } // namespace Rosen } // namespace OHOS - #endif // GRAPHICS_EFFECT_GE_VISUAL_EFFECT_IMPL_H diff --git a/src/ge_frame_gradient_shader_mask.cpp b/src/ge_frame_gradient_shader_mask.cpp new file mode 100644 index 0000000000000000000000000000000000000000..542fa2903ab7b842f9bd554afa5fb6c193714f6c --- /dev/null +++ b/src/ge_frame_gradient_shader_mask.cpp @@ -0,0 +1,122 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#include "ge_log.h" +#include "ge_frame_gradient_shader_mask.h" + +namespace OHOS { +namespace Rosen { +namespace Drawing { +namespace { +thread_local static std::shared_ptr frameGradientMaskShaderEffect_ = nullptr; +} +GEFrameGradientShaderMask::GEFrameGradientShaderMask(const GEFrameGradientMaskParams& param) + : gradientBezierControlPoints_(param.gradientBezierControlPoints), + cornerRadius_(param.cornerRadius), + frameWidth_(param.frameWidth) + {} + +std::shared_ptr GEFrameGradientShaderMask::GenerateDrawingShader(float width, float height) const +{ + MakeFrameGradientMaskShaderEffect(); + if (!frameGradientMaskShaderEffect_ || cornerRadius_ < 0.0 || frameWidth_ < 0.0 || width <= 0.0 || height <= 0.0) { + LOGE("GEFrameGradientShaderMask::GenerateDrawingShader create builder error"); + return nullptr; + } + auto maskBuilder = std::make_shared(frameGradientMaskShaderEffect_); + maskBuilder->SetUniform("iResolution", width, height); + std::array gradientBezier = {gradientBezierControlPoints_[0], + gradientBezierControlPoints_[1], gradientBezierControlPoints_[2], gradientBezierControlPoints_[3]}; + maskBuilder->SetUniform("gradientBezierControlPoints", gradientBezier.data(), ARRAY_SIZE_FOUR); + maskBuilder->SetUniform("cornerRadius", cornerRadius_); + maskBuilder->SetUniform("frameWidth", frameWidth_); + auto maskShader = maskBuilder->MakeShader(nullptr, false); + if (!maskShader) { + LOGE("GEFrameGradientShaderMask::GenerateDrawingShader effect error"); + } + return maskShader; +} + +std::shared_ptr GEFrameGradientShaderMask::GenerateDrawingShaderHasNormal(float width, float height) const +{ + MakeFrameGradientMaskShaderEffect(); + if (!frameGradientMaskShaderEffect_ || cornerRadius_ < 0.0 || frameWidth_ < 0.0 || width <= 0.0 || height <= 0.0) { + LOGE("GEFrameGradientShaderMask::GenerateDrawingShader create builder error"); + return nullptr; + } + auto maskBuilder = std::make_shared(frameGradientMaskShaderEffect_); + maskBuilder->SetUniform("iResolution", width, height); + std::array gradientBezier = {gradientBezierControlPoints_[0], + gradientBezierControlPoints_[1], gradientBezierControlPoints_[2], gradientBezierControlPoints_[3]}; + maskBuilder->SetUniform("gradientBezierControlPoints", gradientBezier.data(), ARRAY_SIZE_FOUR); + maskBuilder->SetUniform("cornerRadius", cornerRadius_); + maskBuilder->SetUniform("frameWidth", frameWidth_); + auto maskShader = maskBuilder->MakeShader(nullptr, false); + if (!maskShader) { + LOGE("GEFrameGradientShaderMask::GenerateDrawingShaderHasNormal effect error"); + } + return maskShader; +} + +void GEFrameGradientShaderMask::MakeFrameGradientMaskShaderEffect() const +{ + if (frameGradientMaskShaderEffect_) { + return ; + } + + static const std::string maskString(R"( + uniform half2 iResolution; + uniform half4 gradientBezierControlPoints; + uniform half frameWidth; + uniform half cornerRadius; + + half sdRoundedBox(half2 p, half2 b, half r) + { + half2 q = abs(p) - b + r; + return (min(max(q.x, q.y), 0.0) + length(max(q, 0.0)) - r); + } + + half cubicBezierInterpolation(half4 controlPoints, half t) + { + // [(1-t)^3 * {0,0} + 3(1-t)^2 * t * CP.xy + 3t^2 * (1-t) * CP.zw + t^3 * {1,1}].y + half2 XY = controlPoints.yw + controlPoints.yw + controlPoints.yw; + return (((1.0 + XY.x - XY.y) * t - XY.x - XY.x + XY.y) * t + XY.x) * t; + } + + half4 main(float2 fragCoord) { + half2 uv = fragCoord.xy / iResolution.xy; + half screenRatio = iResolution.x / iResolution.y; + uv = uv * 2.0 - 1.0; + uv.x *= screenRatio; + half sdfRRect = + abs(sdRoundedBox(uv.xy, vec2(screenRatio, 1.0), + clamp(cornerRadius, 0.0, min(screenRatio, 1.0)))); + sdfRRect = (sdfRRect - frameWidth) / (-frameWidth - 1e-6); + sdfRRect = cubicBezierInterpolation(gradientBezierControlPoints, clamp(sdfRRect, 0.0, 1.0)); + return half4(sdfRRect); + } + )"); + + frameGradientMaskShaderEffect_ = Drawing::RuntimeEffect::CreateForShader(maskString); + if (frameGradientMaskShaderEffect_ == nullptr) { + LOGE("GEFrameGradientShaderMask::MakeFrameGradientMaskShaderEffect error"); + } +} + +} // namespace Drawing +} // namespace Rosen +} // namespace OHOS \ No newline at end of file diff --git a/src/ge_render.cpp b/src/ge_render.cpp index 413f251737098ca0f17a9ac3c70e9cd86e31e1c1..0d3452a21327beb8ff22fcecff5b5acbbe2a4c20 100755 --- a/src/ge_render.cpp +++ b/src/ge_render.cpp @@ -142,7 +142,70 @@ static std::unordered_map g_shade out = std::make_shared(*params); return out; } - } + }, + {GEVisualEffectImpl::FilterType::AIBAR_GLOW, [] (std::shared_ptr ve) + { + std::shared_ptr out = nullptr; + if (!ve) { + return out; + } + const auto& params = ve->GetAIBarGlowEffectParams(); + if (params == nullptr) { + return out; + } + auto type = static_cast(Drawing::GEVisualEffectImpl::FilterType::AIBAR_GLOW); + auto impl = GEExternalDynamicLoader::GetInstance().CreateGEXObjectByType( + type, sizeof(GEXAIBarGlowEffectParams), static_cast(params.get())); + if (!impl) { + GE_LOGE("GEXAIBarGlowEffect::CreateDynamicImpl create object failed."); + return out; + } + std::shared_ptr dmShader(static_cast(impl)); + return dmShader; + } + }, + {GEVisualEffectImpl::FilterType::ROUNDED_RECT_FLOWLIGHT, [] (std::shared_ptr ve) + { + std::shared_ptr out = nullptr; + if (!ve) { + return out; + } + const auto& params = ve->GetRoundedRectFlowlightEffectParams(); + if (params == nullptr) { + return out; + } + auto type = static_cast(Drawing::GEVisualEffectImpl::FilterType::ROUNDED_RECT_FLOWLIGHT); + auto impl = GEExternalDynamicLoader::GetInstance().CreateGEXObjectByType( + type, sizeof(GEXRoundedRectFlowlightEffectParams), static_cast(params.get())); + if (!impl) { + GE_LOGE("GEXRoundedRectFlowlightEffect::CreateDynamicImpl create object failed."); + return out; + } + std::shared_ptr dmShader(static_cast(impl)); + return dmShader; + } + }, + {GEVisualEffectImpl::FilterType::GRADIENT_FLOW_COLORS, [] (std::shared_ptr ve) + { + std::shared_ptr out = nullptr; + if (!ve) { + return out; + } + const auto& params = ve->GetGradientFlowColorsEffectParams(); + if (params == nullptr) { + return out; + } + auto type = static_cast(Drawing::GEVisualEffectImpl::FilterType::GRADIENT_FLOW_COLORS); + auto impl = GEExternalDynamicLoader::GetInstance().CreateGEXObjectByType( + type, sizeof(GEXGradientFlowColorsEffectParams), static_cast(params.get())); + if (!impl) { + GE_LOGE("GEXGradientFlowColorsEffect::CreateDynamicImpl create object failed."); + return out; + } + std::shared_ptr dmShader(static_cast(impl)); + return dmShader; + } + }, }; GERender::GERender() {} diff --git a/src/ge_visual_effect.cpp b/src/ge_visual_effect.cpp index ef90d5078c6cf2431aad15b6f5a8e82b33db703d..e5d9a491b633474e8c060be421d700d6c1f457ec 100644 --- a/src/ge_visual_effect.cpp +++ b/src/ge_visual_effect.cpp @@ -22,6 +22,7 @@ #include "ge_ripple_shader_mask.h" #include "ge_double_ripple_shader_mask.h" #include "ge_wave_gradient_shader_mask.h" +#include "ge_frame_gradient_shader_mask.h" namespace OHOS { namespace Rosen { @@ -178,6 +179,13 @@ const std::shared_ptr GEVisualEffect::GenerateShaderMask( } return std::make_shared(*waveParams); } + case GEVisualEffectImpl::FilterType::FRAME_GRADIENT_MASK: { + auto frameParams = impl->GetFrameGradientMaskParams(); + if (frameParams == nullptr) { + return nullptr; + } + return std::make_shared(*frameParams); + } default: return nullptr; } diff --git a/src/ge_visual_effect_impl.cpp b/src/ge_visual_effect_impl.cpp index 96bfed228ae894a258bc03fe73aee2a375d82b0a..71fbdd5e5200357a364dcc0f0c8b6776bbd3b7b4 100644 --- a/src/ge_visual_effect_impl.cpp +++ b/src/ge_visual_effect_impl.cpp @@ -24,6 +24,84 @@ namespace OHOS { namespace Rosen { namespace Drawing { +namespace { +#define ADD_TAG_HANDLER(type, tag, member, valueType) \ + {tag, [](std::shared_ptr¶ms, const std::any& value) { \ + params->member = std::any_cast(value); \ + }} + +using PairFloat = std::pair; + +GEVisualEffectImpl::TagMap AIBarGlowEffectTagMap_{ + ADD_TAG_HANDLER(GEXAIBarGlowEffectParams, GEX_SHADER_AIBAR_GLOW_LTWH, LTWH, Vector4f), + ADD_TAG_HANDLER(GEXAIBarGlowEffectParams, GEX_SHADER_AIBAR_GLOW_STRECTCH_FACTOR, + stretchFactor, float), + ADD_TAG_HANDLER(GEXAIBarGlowEffectParams, GEX_SHADER_AIBAR_GLOW_BAR_ANGLE, barAngle, float), + ADD_TAG_HANDLER(GEXAIBarGlowEffectParams, GEX_SHADER_AIBAR_GLOW_COLOR0, colors[0], Vector4f), + ADD_TAG_HANDLER(GEXAIBarGlowEffectParams, GEX_SHADER_AIBAR_GLOW_COLOR1, colors[1], Vector4f), + ADD_TAG_HANDLER(GEXAIBarGlowEffectParams, GEX_SHADER_AIBAR_GLOW_COLOR2, colors[2], Vector4f), + ADD_TAG_HANDLER(GEXAIBarGlowEffectParams, GEX_SHADER_AIBAR_GLOW_COLOR3, colors[3], Vector4f), + ADD_TAG_HANDLER(GEXAIBarGlowEffectParams, GEX_SHADER_AIBAR_GLOW_POS0, positions[0], PairFloat), + ADD_TAG_HANDLER(GEXAIBarGlowEffectParams, GEX_SHADER_AIBAR_GLOW_POS1, positions[1], PairFloat), + ADD_TAG_HANDLER(GEXAIBarGlowEffectParams, GEX_SHADER_AIBAR_GLOW_POS2, positions[2], PairFloat), + ADD_TAG_HANDLER(GEXAIBarGlowEffectParams, GEX_SHADER_AIBAR_GLOW_POS3, positions[3], PairFloat), + ADD_TAG_HANDLER(GEXAIBarGlowEffectParams, GEX_SHADER_AIBAR_GLOW_BRIGHTNESS, brightness, float), + ADD_TAG_HANDLER(GEXAIBarGlowEffectParams, GEX_SHADER_AIBAR_GLOW_PROGRESS, progress, float), + ADD_TAG_HANDLER(GEXAIBarGlowEffectParams, GEX_SHADER_AIBAR_GLOW_STRENGTH, strengths, Vector4f), +}; + +GEVisualEffectImpl::TagMap roundedRectFlowlightEffectTagMap_{ + ADD_TAG_HANDLER(GEXRoundedRectFlowlightEffectParams, GEX_SHADER_ROUNDED_RECT_FLOWLIGHT_START_END_POS, + startEndPosition, PairFloat), + ADD_TAG_HANDLER(GEXRoundedRectFlowlightEffectParams, GEX_SHADER_ROUNDED_RECT_FLOWLIGHT_WAVE_LENGTH, + waveLength, float), + ADD_TAG_HANDLER(GEXRoundedRectFlowlightEffectParams, GEX_SHADER_ROUNDED_RECT_FLOWLIGHT_WAVE_TOP, + waveTop, float), + ADD_TAG_HANDLER(GEXRoundedRectFlowlightEffectParams, GEX_SHADER_ROUNDED_RECT_FLOWLIGHT_CORNER_RADIUS, + cornerRadius, float), + ADD_TAG_HANDLER(GEXRoundedRectFlowlightEffectParams, GEX_SHADER_ROUNDED_RECT_FLOWLIGHT_BRIGHTNESS, + brightness, float), + ADD_TAG_HANDLER(GEXRoundedRectFlowlightEffectParams, GEX_SHADER_ROUNDED_RECT_FLOWLIGHT_SCALE, + scale, float), + ADD_TAG_HANDLER(GEXRoundedRectFlowlightEffectParams, GEX_SHADER_ROUNDED_RECT_FLOWLIGHT_SHARPING, + sharping, float), + ADD_TAG_HANDLER(GEXRoundedRectFlowlightEffectParams, GEX_SHADER_ROUNDED_RECT_FLOWLIGHT_FEATHERING, + feathering, float), + ADD_TAG_HANDLER(GEXRoundedRectFlowlightEffectParams, + GEX_SHADER_ROUNDED_RECT_FLOWLIGHT_FEATHERING_BEZIER_CONTROL_POINTS, + featheringBezierControlPoints, Vector4f), + ADD_TAG_HANDLER(GEXRoundedRectFlowlightEffectParams, + GEX_SHADER_ROUNDED_RECT_FLOWLIGHT_GRADIENT_BEZIER_CONTROL_POINTS, + gradientBezierControlPoints, Vector4f), + ADD_TAG_HANDLER(GEXRoundedRectFlowlightEffectParams, GEX_SHADER_ROUNDED_RECT_FLOWLIGHT_COLOR, + color, Vector4f), + ADD_TAG_HANDLER(GEXRoundedRectFlowlightEffectParams, GEX_SHADER_ROUNDED_RECT_FLOWLIGHT_PROGRESS, + progress, float), +}; + +GEVisualEffectImpl::TagMap gradientFlowColorsEffectTagMap_{ + ADD_TAG_HANDLER(GEXGradientFlowColorsEffectParams, GEX_SHADER_GRADIENT_FLOW_COLORS_COLOR0, colors[0], Vector4f), + ADD_TAG_HANDLER(GEXGradientFlowColorsEffectParams, GEX_SHADER_GRADIENT_FLOW_COLORS_COLOR1, colors[1], Vector4f), + ADD_TAG_HANDLER(GEXGradientFlowColorsEffectParams, GEX_SHADER_GRADIENT_FLOW_COLORS_COLOR2, colors[2], Vector4f), + ADD_TAG_HANDLER(GEXGradientFlowColorsEffectParams, GEX_SHADER_GRADIENT_FLOW_COLORS_COLOR3, colors[3], Vector4f), + ADD_TAG_HANDLER(GEXGradientFlowColorsEffectParams, GEX_SHADER_GRADIENT_FLOW_COLORS_GRADIENT_BEGIN, + gradientBegin, float), + ADD_TAG_HANDLER(GEXGradientFlowColorsEffectParams, GEX_SHADER_GRADIENT_FLOW_COLORS_GRADIENT_END, + gradientEnd, float), + ADD_TAG_HANDLER(GEXGradientFlowColorsEffectParams, GEX_SHADER_GRADIENT_FLOW_COLORS_EFFECT_ALPHA, + effectAlpha, float), + ADD_TAG_HANDLER(GEXGradientFlowColorsEffectParams, GEX_SHADER_GRADIENT_FLOW_COLORS_PROGRESS, progress, float), +}; + +GEVisualEffectImpl::TagMap frameGradientMaskTagMap_{ + ADD_TAG_HANDLER(GEFrameGradientMaskParams, GE_MASK_FRAME_GRADIENT_GRADIENT_BEZIER_CONTROL_POINTS, + gradientBezierControlPoints, Vector4f), + ADD_TAG_HANDLER(GEFrameGradientMaskParams, GE_MASK_FRAME_GRADIENT_CORNER_RADIUS, cornerRadius, float), + ADD_TAG_HANDLER(GEFrameGradientMaskParams, GE_MASK_FRAME_GRADIENT_FRAME_WIDTH, frameWidth, float), +}; + +#undef ADD_TAG_HANDLER +} std::map> GEVisualEffectImpl::g_initialMap = { { GE_FILTER_KAWASE_BLUR, @@ -199,7 +277,32 @@ std::map> GEVisualEf impl->SetFilterType(GEVisualEffectImpl::FilterType::BORDER_LIGHT); impl->MakeBorderLightParams(); } - } + }, + { GEX_SHADER_AIBAR_GLOW, + [](GEVisualEffectImpl* impl) { + impl->SetFilterType(GEVisualEffectImpl::FilterType::AIBAR_GLOW); + impl->MakeAIBarGlowEffectParams(); + } + }, + { GEX_SHADER_ROUNDED_RECT_FLOWLIGHT, + [](GEVisualEffectImpl* impl) { + impl->SetFilterType(GEVisualEffectImpl::FilterType::ROUNDED_RECT_FLOWLIGHT); + impl->MakeRoundedRectFlowlightEffectParams(); + } + }, + { GEX_SHADER_GRADIENT_FLOW_COLORS, + [](GEVisualEffectImpl* impl) { + impl->SetFilterType(GEVisualEffectImpl::FilterType::GRADIENT_FLOW_COLORS); + impl->MakeGradientFlowColorsEffectParams(); + } + }, + { GE_MASK_FRAME_GRADIENT, + [](GEVisualEffectImpl* impl) { + impl->SetFilterType(GEVisualEffectImpl::FilterType::FRAME_GRADIENT_MASK); + impl->MakeFrameGradientMaskParams(); + } + }, + }; GEVisualEffectImpl::GEVisualEffectImpl(const std::string& name, const std::optional& canvasInfo) @@ -213,6 +316,23 @@ GEVisualEffectImpl::GEVisualEffectImpl(const std::string& name, const std::optio GEVisualEffectImpl::~GEVisualEffectImpl() {} +template +void GEVisualEffectImpl::ApplyTagParams(const std::string& tag, const std::any& value, + std::shared_ptr& params, const TagMap& tagMap) +{ + if (!params) { + GE_LOGE("GEVisualEffectImpl params for tag %{public}s not found", tag.c_str()); + return; + } + auto it = tagMap.find(tag); + if (it != tagMap.end()) { + it->second(params, value); + } else { + GE_LOGE("GEVisualEffectImpl tag %{public}s not found", tag.c_str()); + } +} + + void GEVisualEffectImpl::SetParam(const std::string& tag, int32_t param) { switch (filterType_) { @@ -410,6 +530,22 @@ void GEVisualEffectImpl::SetParam(const std::string& tag, float param) SetBorderLightParams(tag, param); break; } + case FilterType::FRAME_GRADIENT_MASK: { + ApplyTagParams(tag, param, frameGradientMaskParams_, frameGradientMaskTagMap_); + break; + } + case FilterType::AIBAR_GLOW: { + ApplyTagParams(tag, param, AIBarGlowEffectParams_, AIBarGlowEffectTagMap_); + break; + } + case FilterType::ROUNDED_RECT_FLOWLIGHT: { + ApplyTagParams(tag, param, roundedRectFlowlightEffectParams_, roundedRectFlowlightEffectTagMap_); + break; + } + case FilterType::GRADIENT_FLOW_COLORS: { + ApplyTagParams(tag, param, gradientFlowColorsEffectParams_, gradientFlowColorsEffectTagMap_); + break; + } default: break; } @@ -531,6 +667,14 @@ void GEVisualEffectImpl::SetParam(const std::string& tag, const std::pair + +#include "ge_frame_gradient_shader_mask.h" + +using namespace testing; +using namespace testing::ext; + +namespace OHOS { +namespace Rosen { +namespace Drawing { + +class GEFrameGradientShaderMaskTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp() override; + void TearDown() override; +}; + +void GEFrameGradientShaderMaskTest::SetUpTestCase(void) {} + +void GEFrameGradientShaderMaskTest::TearDownTestCase(void) {} + +void GEFrameGradientShaderMaskTest::SetUp() {} + +void GEFrameGradientShaderMaskTest::TearDown() {} + +/** + * @tc.name: GenerateDrawingShader_001 + * @tc.desc: Verify the GenerateDrawingShader function + * @tc.type: FUNC + */ +HWTEST_F(GEFrameGradientShaderMaskTest, GenerateDrawingShader_001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GEVisualEffectTest GenerateDrawingShader_001 start"; + + GEFrameGradientMaskParams param; + param.gradientBezierControlPoints = {0.0f, 0.0f, 0.0f, 0.0f}; + param.cornerRadius = 0.0f; + param.frameWidth = 0.0f; + + GEFrameGradientShaderMask mask(param); + auto shaderEffect = mask.GenerateDrawingShader(0.f, 50.f); + EXPECT_EQ(shaderEffect, nullptr); + + GTEST_LOG_(INFO) << "GEVisualEffectTest GenerateDrawingShader_001 end"; +} + +/** + * @tc.name: GenerateDrawingShader_002 + * @tc.desc: Verify the GenerateDrawingShader function + * @tc.type: FUNC + */ +HWTEST_F(GEFrameGradientShaderMaskTest, GenerateDrawingShader_002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GEVisualEffectTest GenerateDrawingShader_002 start"; + + GEFrameGradientMaskParams param; + param.gradientBezierControlPoints = {0.0f, 0.0f, 0.0f, 0.0f}; + param.cornerRadius = -1.0f; + param.frameWidth = 0.0f; + + GEFrameGradientShaderMask mask(param); + auto shaderEffect = mask.GenerateDrawingShader(50.f, 50.f); + EXPECT_EQ(shaderEffect, nullptr); + + GTEST_LOG_(INFO) << "GEVisualEffectTest GenerateDrawingShader_002 end"; +} + +/** + * @tc.name: GenerateDrawingShader_003 + * @tc.desc: Verify the GenerateDrawingShader function + * @tc.type: FUNC + */ +HWTEST_F(GEFrameGradientShaderMaskTest, GenerateDrawingShader_003, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GEVisualEffectTest GenerateDrawingShader_003 start"; + + GEFrameGradientMaskParams param; + param.gradientBezierControlPoints = {0.0f, 0.0f, 0.0f, 0.0f}; + param.cornerRadius = 0.0f; + param.frameWidth = -1.0f; + + GEFrameGradientShaderMask mask(param); + auto shaderEffect = mask.GenerateDrawingShader(50.f, 50.f); + EXPECT_EQ(shaderEffect, nullptr); + + GTEST_LOG_(INFO) << "GEVisualEffectTest GenerateDrawingShader_003 end"; +} + +/** + * @tc.name: GenerateDrawingShaderHasNormal_001 + * @tc.desc: Verify the GenerateDrawingShaderHasNormal function + * @tc.type: FUNC + */ +HWTEST_F(GEFrameGradientShaderMaskTest, GenerateDrawingShaderHasNormal_001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GEVisualEffectTest GenerateDrawingShaderHasNormal_001 start"; + + GEFrameGradientMaskParams param; + param.gradientBezierControlPoints = {0.0f, 0.0f, 0.0f, 0.0f}; + param.cornerRadius = 0.0f; + param.frameWidth = 0.0f; + + GEFrameGradientShaderMask mask(param); + auto shaderEffect = mask.GenerateDrawingShaderHasNormal(0.f, 50.f); + EXPECT_EQ(shaderEffect, nullptr); + + GTEST_LOG_(INFO) << "GEVisualEffectTest GenerateDrawingShaderHasNormal_001 end"; +} + +/** + * @tc.name: GenerateDrawingShaderHasNormal_002 + * @tc.desc: Verify the GenerateDrawingShaderHasNormal function + * @tc.type: FUNC + */ +HWTEST_F(GEFrameGradientShaderMaskTest, GenerateDrawingShaderHasNormal_002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GEVisualEffectTest GenerateDrawingShaderHasNormal_002 start"; + + GEFrameGradientMaskParams param; + param.gradientBezierControlPoints = {0.0f, 0.0f, 0.0f, 0.0f}; + param.cornerRadius = -1.0f; + param.frameWidth = 0.0f; + + GEFrameGradientShaderMask mask(param); + auto shaderEffect = mask.GenerateDrawingShaderHasNormal(50.f, 50.f); + EXPECT_EQ(shaderEffect, nullptr); + + GTEST_LOG_(INFO) << "GEVisualEffectTest GenerateDrawingShaderHasNormal_002 end"; +} + +/** + * @tc.name: GenerateDrawingShaderHasNormal_003 + * @tc.desc: Verify the GenerateDrawingShader function + * @tc.type: FUNC + */ +HWTEST_F(GEFrameGradientShaderMaskTest, GenerateDrawingShaderHasNormal_003, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "GEVisualEffectTest GenerateDrawingShaderHasNormal_003 start"; + + GEFrameGradientMaskParams param; + param.gradientBezierControlPoints = {0.0f, 0.0f, 0.0f, 0.0f}; + param.cornerRadius = 0.0f; + param.frameWidth = -1.0f; + + GEFrameGradientShaderMask mask(param); + auto shaderEffect = mask.GenerateDrawingShader(50.f, 50.f); + EXPECT_EQ(shaderEffect, nullptr); + + GTEST_LOG_(INFO) << "GEVisualEffectTest GenerateDrawingShaderHasNormal_003 end"; +} +} // namespace Drawing +} // namespace Rosen +} // namespace OHOS