diff --git a/include/ge_border_light_shader.h b/include/ge_border_light_shader.h
index 629e291ba98cac16533e16b95ba94211553c063d..4dafb4c24a881ff7f5c7151adf0adcedc3bddc0a 100644
--- a/include/ge_border_light_shader.h
+++ b/include/ge_border_light_shader.h
@@ -20,23 +20,15 @@
 #include "common/rs_vector4.h"
 #include "effect/runtime_shader_builder.h"
 #include "utils/matrix.h"
+#include "ge_shader_filter_params.h"
 
 namespace OHOS {
 namespace Rosen {
 
-struct GE_EXPORT BorderLightParams {
-    Vector3f lightPosition_;
-    Vector4f lightColor_;
-    float lightIntensity_ = 0.0f;
-    float lightWidth_ = 0.0f;
-    Vector3f rotationAngle_;
-    float cornerRadius_ = 0.0f;
-};
-
 class GE_EXPORT GEBorderLightShader : public GEShader {
 public:
     GEBorderLightShader();
-    GEBorderLightShader(BorderLightParams& borderLightParams);
+    GEBorderLightShader(Drawing::GEBorderLightShaderParams& borderLightParams);
 
     ~GEBorderLightShader() override = default;
 
@@ -44,19 +36,13 @@ public:
 
     const std::string GetDescription() const { return "GEBorderLightShader"; }
     
-    void SetBorderLightParams(const BorderLightParams& params)
+    void SetBorderLightParams(const Drawing::GEBorderLightShaderParams& params)
     {
         borderLightParams_ = params;
     }
 
-    void SetRotationAngle(const Vector3f& rotationAngle);
-
-    void SetCornerRadius(float cornerRadius);
-
     std::shared_ptr<Drawing::ShaderEffect> MakeBorderLightShader(const Drawing::Rect& rect);
 
-    static std::shared_ptr<GEBorderLightShader> CreateBorderLightShader(BorderLightParams& param);
-
     std::shared_ptr<Drawing::RuntimeShaderBuilder> GetBorderLightBuilder();
 private:
     GEBorderLightShader(const GEBorderLightShader&) = delete;
@@ -64,7 +50,7 @@ private:
     GEBorderLightShader& operator=(const GEBorderLightShader&) = delete;
     GEBorderLightShader& operator=(const GEBorderLightShader&&) = delete;
 
-    BorderLightParams borderLightParams_;
+    Drawing::GEBorderLightShaderParams borderLightParams_;
     std::shared_ptr<Drawing::RuntimeShaderBuilder> builder_;
 };
 
diff --git a/include/ge_shader_filter_params.h b/include/ge_shader_filter_params.h
index 26dd7bec042a58c19e818dcab0d235e4a933c603..77ad4df7f5590bd843acc24553d74764629ce28b 100644
--- a/include/ge_shader_filter_params.h
+++ b/include/ge_shader_filter_params.h
@@ -337,16 +337,16 @@ struct GEWaveGradientShaderMaskParams {
     float turbulenceStrength_ = 0.f;
 };
 
-constexpr char GE_FILTER_CONTENT_LIGHT[] = "CONTENT_LIGHT";
-constexpr char GE_FILTER_CONTENT_LIGHT_POSITION[] = "CONTENT_LIGHT_POSITION";
-constexpr char GE_FILTER_CONTENT_LIGHT_COLOR[] = "CONTENT_LIGHT_COLOR";
-constexpr char GE_FILTER_CONTENT_LIGHT_INTENSITY[] = "CONTENT_LIGHT_INTENSITY";
-constexpr char GE_FILTER_CONTENT_LIGHT_ROTATION_ANGLE[] = "CONTENT_LIGHT_ROTATION_ANGLE";
+constexpr char GE_FILTER_CONTENT_LIGHT[] = "ContentLight";
+constexpr char GE_FILTER_CONTENT_LIGHT_POSITION[] = "ContentLightPosition";
+constexpr char GE_FILTER_CONTENT_LIGHT_COLOR[] = "ContentLightColor";
+constexpr char GE_FILTER_CONTENT_LIGHT_INTENSITY[] = "ContentLightIntensity";
+constexpr char GE_FILTER_CONTENT_LIGHT_ROTATION_ANGLE[] = "ContentLightRotationAngle";
 struct GEContentLightFilterParams {
-    Vector3f lightPosition;
-    Vector4f lightColor;
-    float lightIntensity;
-    Vector3f rotationAngle;
+    Vector3f position = Vector3f(0.0f, 0.0f, 0.0f);
+    Vector4f color = Vector4f(0.0f, 0.0f, 0.0f, 0.0f);
+    float intensity = 0.0f;
+    Vector3f rotationAngle = Vector3f(0.0f, 0.0f, 0.0f);
 };
 
 // Declare same with in rs_render_shader_base.h
@@ -496,6 +496,23 @@ struct GEXLightCaveShaderParams {
     float progress = 0.0f;
 };
 
+
+constexpr char GE_SHADER_BORDER_LIGHT[] = "BorderLight";
+constexpr char GE_SHADER_BORDER_LIGHT_POSITION[] = "BorderLightPosition";
+constexpr char GE_SHADER_BORDER_LIGHT_COLOR[] = "BorderLightColor";
+constexpr char GE_SHADER_BORDER_LIGHT_INTENSITY[] = "BorderLightIntensity";
+constexpr char GE_SHADER_BORDER_LIGHT_WIDTH[] = "BorderLightWidth";
+constexpr char GE_SHADER_BORDER_LIGHT_ROTATION_ANGLE[] = "BorderLightRotationAngle";
+constexpr char GE_SHADER_BORDER_LIGHT_CORNER_RADIUS[] = "BorderLightCornerRadius";
+struct GEBorderLightShaderParams {
+    Vector3f position = Vector3f(0.0f, 0.0f, 0.0f);
+    Vector4f color = Vector4f(0.0f, 0.0f, 0.0f, 0.0f);
+    float intensity = 0.0f;
+    float width = 0.0f;
+    Vector3f rotationAngle = Vector3f(0.0f, 0.0f, 0.0f);
+    float cornerRadius = 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 bb87044c5d2de2a8b8d9e9f194a16d39b1659e08..98765f40db1d4ce3b63f5edf80633da96fde44e7 100644
--- a/include/ge_visual_effect_impl.h
+++ b/include/ge_visual_effect_impl.h
@@ -1,4 +1,4 @@
-/*
+ /*
  * Copyright (c) 2024 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.
@@ -401,6 +401,16 @@ public:
     {
         return lightCaveShaderParams_;
     }
+    
+    void MakeBorderLightParams()
+    {
+        borderLightParams_ = std::make_shared<GEBorderLightShaderParams>();
+    }
+
+    const std::shared_ptr<GEBorderLightShaderParams>& GetBorderLightParams() const
+    {
+        return borderLightParams_;
+    }
 
 private:
     static std::map<const std::string, std::function<void(GEVisualEffectImpl*)>> g_initialMap;
@@ -443,6 +453,9 @@ private:
     void SetLightCaveParams(const std::string& tag, const Vector4f& param);
     void SetLightCaveParams(const std::string& tag, const std::pair<float, float>& param);
     void SetLightCaveParams(const std::string& tag, float param);
+    void SetBorderLightParams(const std::string& tag, const Vector3f& param);
+    void SetBorderLightParams(const std::string& tag, const Vector4f& param);
+    void SetBorderLightParams(const std::string& tag, float param);
 
     FilterType filterType_ = GEVisualEffectImpl::FilterType::NONE;
 
@@ -476,9 +489,9 @@ private:
     std::shared_ptr<GEAuroraNoiseShaderParams> auroNoiseParams_ = nullptr;
     std::shared_ptr<GEParticleCircularHaloShaderParams> particleCircularHaloParams_ = nullptr;
     std::shared_ptr<GEVariableRadiusBlurShaderFilterParams> variableRadiusBlurParams_ = nullptr;
-
     std::shared_ptr<GEXColorGradientEffectParams> colorGradientEffectParams_ = nullptr;
     std::shared_ptr<GEXLightCaveShaderParams> lightCaveShaderParams_ = nullptr;
+    std::shared_ptr<GEBorderLightShaderParams> borderLightParams_ = nullptr;
 };
 
 } // namespace Drawing
diff --git a/src/ge_border_light_shader.cpp b/src/ge_border_light_shader.cpp
index 22232d21a8cbbb76a94a9d9de7eb6665e04b01de..e48eaa505b6e54cc952b9e9a07de46e12eb2c7eb 100644
--- a/src/ge_border_light_shader.cpp
+++ b/src/ge_border_light_shader.cpp
@@ -27,32 +27,16 @@ constexpr size_t NUM_4 = 4;
 
 GEBorderLightShader::GEBorderLightShader() {}
 
-GEBorderLightShader::GEBorderLightShader(BorderLightParams& param)
+GEBorderLightShader::GEBorderLightShader(Drawing::GEBorderLightShaderParams& param)
 {
     borderLightParams_ = param;
 }
 
-std::shared_ptr<GEBorderLightShader> GEBorderLightShader::CreateBorderLightShader(BorderLightParams& param)
-{
-    std::shared_ptr<GEBorderLightShader> borderLightShader = std::make_shared<GEBorderLightShader>(param);
-    return borderLightShader;
-}
-
 void GEBorderLightShader::MakeDrawingShader(const Drawing::Rect& rect, float progress)
 {
     drShader_ = MakeBorderLightShader(rect);
 }
 
-void GEBorderLightShader::SetRotationAngle(const Vector3f& rotationAngle)
-{
-    borderLightParams_.rotationAngle_ = rotationAngle;
-}
-
-void GEBorderLightShader::SetCornerRadius(const float cornerRadius)
-{
-    borderLightParams_.cornerRadius_ = cornerRadius;
-}
-
 std::shared_ptr<Drawing::RuntimeShaderBuilder> GEBorderLightShader::GetBorderLightBuilder()
 {
     thread_local std::shared_ptr<Drawing::RuntimeEffect> borderLightShaderEffect_ = nullptr;
@@ -187,18 +171,18 @@ std::shared_ptr<Drawing::ShaderEffect> GEBorderLightShader::MakeBorderLightShade
 {
     auto width = rect.GetWidth();
     auto height = rect.GetHeight();
-    float lightColor[NUM_4] = {borderLightParams_.lightColor_[NUM_0], borderLightParams_.lightColor_[NUM_1],
-        borderLightParams_.lightColor_[NUM_2], borderLightParams_.lightColor_[NUM_3]};
+    float lightColor[NUM_4] = {borderLightParams_.color[NUM_0], borderLightParams_.color[NUM_1],
+        borderLightParams_.color[NUM_2], borderLightParams_.color[NUM_3]};
     builder_ = GetBorderLightBuilder();
     builder_->SetUniform("iResolution", width, height);
-    builder_->SetUniform("lightPosition", borderLightParams_.lightPosition_[NUM_0],
-        borderLightParams_.lightPosition_[NUM_1], borderLightParams_.lightPosition_[NUM_2]);
+    builder_->SetUniform("lightPosition", borderLightParams_.position[NUM_0],
+        borderLightParams_.position[NUM_1], borderLightParams_.position[NUM_2]);
     builder_->SetUniform("lightColor", lightColor, NUM_4);
-    builder_->SetUniform("lightIntensity", borderLightParams_.lightIntensity_);
-    builder_->SetUniform("lightWidth", borderLightParams_.lightWidth_);
-    builder_->SetUniform("borderLightRotationAngle", borderLightParams_.rotationAngle_[NUM_0],
-        borderLightParams_.rotationAngle_[NUM_1], borderLightParams_.rotationAngle_[NUM_2]);
-    builder_->SetUniform("cornerRadius", borderLightParams_.cornerRadius_);
+    builder_->SetUniform("lightIntensity", borderLightParams_.intensity);
+    builder_->SetUniform("lightWidth", borderLightParams_.width);
+    builder_->SetUniform("borderLightRotationAngle", borderLightParams_.rotationAngle[NUM_0],
+        borderLightParams_.rotationAngle[NUM_1], borderLightParams_.rotationAngle[NUM_2]);
+    builder_->SetUniform("cornerRadius", borderLightParams_.cornerRadius);
     auto borderLightShader = builder_->MakeShader(nullptr, false);
 
     if (borderLightShader == nullptr) {
diff --git a/src/ge_content_light_shader_filter.cpp b/src/ge_content_light_shader_filter.cpp
index eaf0880e2815b5466571d5fbb1bfaeb0e0b824db..71ea82742f47d8235e5d67643ca214e9437511c2 100644
--- a/src/ge_content_light_shader_filter.cpp
+++ b/src/ge_content_light_shader_filter.cpp
@@ -29,7 +29,7 @@ std::shared_ptr<Drawing::RuntimeEffect> GEContentLightFilter::contentLightShader
 const std::string GEContentLightFilter::type_ = Drawing::GE_FILTER_CONTENT_LIGHT;
 
 GEContentLightFilter::GEContentLightFilter(const Drawing::GEContentLightFilterParams& params)
-    : lightPosition_(params.lightPosition), lightColor_(params.lightColor), lightIntensity_(params.lightIntensity),
+    : lightPosition_(params.position), lightColor_(params.color), lightIntensity_(params.intensity),
     rotationAngle_(params.rotationAngle)
 {}
 
diff --git a/src/ge_render.cpp b/src/ge_render.cpp
index 66f299746863860590fafd3255d09b073bc93ef6..e6946da86c8267fbec8b2128c04a0a6a696f5f67 100755
--- a/src/ge_render.cpp
+++ b/src/ge_render.cpp
@@ -17,6 +17,7 @@
 #include "ge_aibar_shader_filter.h"
 #include "ge_aurora_noise_shader.h"
 #include "ge_bezier_warp_shader_filter.h"
+#include "ge_border_light_shader.h"
 #include "ge_color_gradient_shader_filter.h"
 #include "ge_content_light_shader_filter.h"
 #include "ge_contour_diagonal_flow_light_shader.h"
@@ -130,6 +131,17 @@ static std::unordered_map<GEVisualEffectImpl::FilterType, ShaderCreator> g_shade
             std::shared_ptr<GEShader> dmShader(static_cast<GEShader*>(impl));
             return dmShader;
         }
+    },
+    {GEVisualEffectImpl::FilterType::BORDER_LIGHT, [] (std::shared_ptr<GEVisualEffectImpl> ve)
+        {
+            std::shared_ptr<GEShader> out = nullptr;
+            if (ve == nullptr || ve->GetBorderLightParams() == nullptr) {
+                return out;
+            }
+            const auto& params = ve->GetBorderLightParams();
+            out = std::make_shared<GEBorderLightShader>(*params);
+            return out;
+        }
     }
 };
 
diff --git a/src/ge_visual_effect_impl.cpp b/src/ge_visual_effect_impl.cpp
index 831fe41ff96954efd8e25b0070458b11a2daec2c..d02a6ecfad116c388101956dd647c31d74d98020 100644
--- a/src/ge_visual_effect_impl.cpp
+++ b/src/ge_visual_effect_impl.cpp
@@ -193,6 +193,12 @@ std::map<const std::string, std::function<void(GEVisualEffectImpl*)>> GEVisualEf
             impl->SetFilterType(GEVisualEffectImpl::FilterType::LIGHT_CAVE);
             impl->MakeLightCaveParams();
         }
+    },
+    { GE_SHADER_BORDER_LIGHT,
+        [](GEVisualEffectImpl* impl) {
+            impl->SetFilterType(GEVisualEffectImpl::FilterType::BORDER_LIGHT);
+            impl->MakeBorderLightParams();
+        }
     }
 };
 
@@ -399,6 +405,10 @@ void GEVisualEffectImpl::SetParam(const std::string& tag, float param)
             SetLightCaveParams(tag, param);
             break;
         }
+        case FilterType::BORDER_LIGHT: {
+            SetBorderLightParams(tag, param);
+            break;
+        }
         default:
             break;
     }
@@ -728,7 +738,7 @@ void GEVisualEffectImpl::SetParam(const std::string& tag, const Vector3f& param)
                 return;
             }
             if (tag == GE_FILTER_CONTENT_LIGHT_POSITION) {
-                contentLightParams_->lightPosition = param;
+                contentLightParams_->position = param;
             }
             if (tag == GE_FILTER_CONTENT_LIGHT_ROTATION_ANGLE) {
                 contentLightParams_->rotationAngle = param;
@@ -744,6 +754,10 @@ void GEVisualEffectImpl::SetParam(const std::string& tag, const Vector3f& param)
             }
             break;
         }
+        case FilterType::BORDER_LIGHT: {
+            SetBorderLightParams(tag, param);
+            break;
+        }
         default:
             break;
     }
@@ -754,7 +768,7 @@ void GEVisualEffectImpl::SetParam(const std::string& tag, const Vector4f& param)
     switch (filterType_) {
         case FilterType::CONTENT_LIGHT: {
             if (contentLightParams_ != nullptr && tag == GE_FILTER_CONTENT_LIGHT_COLOR) {
-                contentLightParams_->lightColor = param;
+                contentLightParams_->color = param;
             }
             break;
         }
@@ -790,6 +804,10 @@ void GEVisualEffectImpl::SetParam(const std::string& tag, const Vector4f& param)
             SetSoundWaveParams(tag, color);
             break;
         }
+        case FilterType::BORDER_LIGHT: {
+            SetBorderLightParams(tag, param);
+            break;
+        }
         case FilterType::LIGHT_CAVE: {
             SetLightCaveParams(tag, param);
             break;
@@ -1251,7 +1269,7 @@ void GEVisualEffectImpl::SetContentLightParams(const std::string& tag, float par
  
     static std::unordered_map<std::string, std::function<void(GEVisualEffectImpl*, float)>> actions = {
         { GE_FILTER_CONTENT_LIGHT_INTENSITY,
-            [](GEVisualEffectImpl* obj, float p) { obj->contentLightParams_->lightIntensity = p; } },
+            [](GEVisualEffectImpl* obj, float p) { obj->contentLightParams_->intensity = p; } },
     };
  
     auto it = actions.find(tag);
@@ -1379,6 +1397,45 @@ void GEVisualEffectImpl::SetParticleCircularHaloParams(const std::string& tag, f
     }
 }
 
+void GEVisualEffectImpl::SetBorderLightParams(const std::string& tag, float param)
+{
+    if (borderLightParams_ == nullptr) {
+        return;
+    }
+    if (tag == GE_SHADER_BORDER_LIGHT_INTENSITY) {
+        borderLightParams_->intensity = param;
+    }
+    if (tag == GE_SHADER_BORDER_LIGHT_WIDTH) {
+        borderLightParams_->width = param;
+    }
+    if (tag == GE_SHADER_BORDER_LIGHT_CORNER_RADIUS) {
+        borderLightParams_->cornerRadius = param;
+    }
+}
+
+void GEVisualEffectImpl::SetBorderLightParams(const std::string& tag, const Vector3f& param)
+{
+    if (borderLightParams_ == nullptr) {
+        return;
+    }
+    if (tag == GE_SHADER_BORDER_LIGHT_POSITION) {
+        borderLightParams_->position = param;
+    }
+    if (tag == GE_SHADER_BORDER_LIGHT_ROTATION_ANGLE) {
+        borderLightParams_->rotationAngle = param;
+    }
+}
+
+void GEVisualEffectImpl::SetBorderLightParams(const std::string& tag, const Vector4f& param)
+{
+    if (borderLightParams_ == nullptr) {
+        return;
+    }
+    if (tag == GE_SHADER_BORDER_LIGHT_COLOR) {
+        borderLightParams_->color = param;
+    }
+}
+
 void GEVisualEffectImpl::SetMaskTransitionParamsFloat(const std::string& tag, float param)
 {
     if (maskTransitionParams_ == nullptr) {
diff --git a/test/unittest/ge_border_light_shader_test.cpp b/test/unittest/ge_border_light_shader_test.cpp
index 942e0f46e8f5acd1fc5508ac0b9e85d21c6f194a..13c08afa5e33684fc055b4f247846e79bbf41557 100644
--- a/test/unittest/ge_border_light_shader_test.cpp
+++ b/test/unittest/ge_border_light_shader_test.cpp
@@ -37,32 +37,19 @@ public:
     {}
 };
 
-/**
- * @tc.name: GEBorderLightShaderTest001
- * @tc.type: FUNC
- */
-HWTEST_F(GEBorderLightShaderTest, GEBorderLightShaderTest001, TestSize.Level1)
-{
-    BorderLightParams params{
-        Vector3f{1.0f, 2.0f, 3.0f}, Vector4f{0.1f, 0.2f, 0.3f, 0.4f}, 0.5f, 5.0f, Vector3f{0.0f, 0.0f, 0.0f}};
-    auto shader = GEBorderLightShader::CreateBorderLightShader(params);
-    EXPECT_NE(shader, nullptr);
-}
-
 /**
  * @tc.name: GEBorderLightShaderTest002
  * @tc.type: FUNC
  */
 HWTEST_F(GEBorderLightShaderTest, GEBorderLightShaderTest002, TestSize.Level1)
 {
-    BorderLightParams params{
+    Drawing::GEBorderLightShaderParams params{
         Vector3f{0.0f, 1.0f, 2.0f}, Vector4f{0.2f, 0.3f, 0.4f, 0.5f}, 1.0f, 2.0f, Vector3f{0.1f, 0.2f, 0.3f}};
-    auto shader = GEBorderLightShader::CreateBorderLightShader(params);
-    ASSERT_NE(shader, nullptr);
+    auto shader = GEBorderLightShader(params);
 
-    auto builder1 = shader->GetBorderLightBuilder();
+    auto builder1 = shader.GetBorderLightBuilder();
     EXPECT_NE(builder1, nullptr);
-    auto builder2 = shader->GetBorderLightBuilder();
+    auto builder2 = shader.GetBorderLightBuilder();
     EXPECT_NE(builder2, nullptr);
 }
 
@@ -72,13 +59,12 @@ HWTEST_F(GEBorderLightShaderTest, GEBorderLightShaderTest002, TestSize.Level1)
  */
 HWTEST_F(GEBorderLightShaderTest, GEBorderLightShaderTest003, TestSize.Level1)
 {
-    BorderLightParams params{
+    Drawing::GEBorderLightShaderParams params{
         Vector3f{2.0f, 3.0f, 4.0f}, Vector4f{0.3f, 0.4f, 0.5f, 0.6f}, 1.5f, 3.0f, Vector3f{0.5f, 0.5f, 0.5f}};
-    auto shader = GEBorderLightShader::CreateBorderLightShader(params);
-    ASSERT_NE(shader, nullptr);
+    auto shader = GEBorderLightShader(params);
 
     Drawing::Rect rect{0, 0, 100, 100};
-    auto effect = shader->MakeBorderLightShader(rect);
+    auto effect = shader.MakeBorderLightShader(rect);
     EXPECT_NE(effect, nullptr);
 }
 
@@ -88,27 +74,12 @@ HWTEST_F(GEBorderLightShaderTest, GEBorderLightShaderTest003, TestSize.Level1)
  */
 HWTEST_F(GEBorderLightShaderTest, GEBorderLightShaderTest004, TestSize.Level1)
 {
-    BorderLightParams params{
+    Drawing::GEBorderLightShaderParams params{
         Vector3f{3.0f, 4.0f, 5.0f}, Vector4f{0.4f, 0.5f, 0.6f, 0.7f}, 2.0f, 4.0f, Vector3f{1.0f, 1.0f, 1.0f}};
-    auto shader = GEBorderLightShader::CreateBorderLightShader(params);
-    ASSERT_NE(shader, nullptr);
+    auto shader = GEBorderLightShader(params);
 
     Drawing::Rect rect{0, 0, 50, 50};
-    shader->MakeDrawingShader(rect, 0.5f);
-}
-
-/**
- * @tc.name: GEBorderLightShaderTest005
- * @tc.type: FUNC
- */
-HWTEST_F(GEBorderLightShaderTest, GEBorderLightShaderTest005, TestSize.Level1)
-{
-    BorderLightParams params{
-        Vector3f{4.0f, 5.0f, 6.0f}, Vector4f{0.5f, 0.6f, 0.7f, 0.8f}, 2.5f, 5.0f, Vector3f{2.0f, 2.0f, 2.0f}};
-    auto shader = GEBorderLightShader::CreateBorderLightShader(params);
-    ASSERT_NE(shader, nullptr);
-
-    shader->SetRotationAngle(Vector3f{7.0f, 8.0f, 9.0f});
+    shader.MakeDrawingShader(rect, 0.5f);
 }
 
 /**
@@ -117,14 +88,13 @@ HWTEST_F(GEBorderLightShaderTest, GEBorderLightShaderTest005, TestSize.Level1)
  */
 HWTEST_F(GEBorderLightShaderTest, GEBorderLightShaderTest006, TestSize.Level1)
 {
-    BorderLightParams params{
+    Drawing::GEBorderLightShaderParams params{
         Vector3f{5.0f, 6.0f, 7.0f}, Vector4f{0.6f, 0.7f, 0.8f, 0.9f}, 3.0f, 6.0f, Vector3f{0.0f, 0.0f, 0.0f}};
-    auto shader = GEBorderLightShader::CreateBorderLightShader(params);
-    ASSERT_NE(shader, nullptr);
+    auto shader = GEBorderLightShader(params);
 
     Drawing::Rect rect{0, 0, 100, 100};
-    shader->MakeDrawingShader(rect, 0.75f);
-    shader->SetBorderLightParams(params);
+    shader.MakeDrawingShader(rect, 0.75f);
+    shader.SetBorderLightParams(params);
 }
 }  // namespace Rosen
 }  // namespace OHOS
\ No newline at end of file
diff --git a/test/unittest/ge_visual_effect_impl_test.cpp b/test/unittest/ge_visual_effect_impl_test.cpp
index 270110f61ab755f704557f8435825e5fd48046fc..5971684856eb100f3195f9e7f2814dfb6c8f7030 100644
--- a/test/unittest/ge_visual_effect_impl_test.cpp
+++ b/test/unittest/ge_visual_effect_impl_test.cpp
@@ -756,15 +756,15 @@ HWTEST_F(GEVisualEffectImplTest, SetParam_020, TestSize.Level1)
     geVisualEffectImpl.SetFilterType(Drawing::GEVisualEffectImpl::FilterType::CONTENT_LIGHT);
  
     geVisualEffectImpl.SetParam(Drawing::GE_FILTER_CONTENT_LIGHT_INTENSITY, lightIntensity);
-    EXPECT_EQ(geVisualEffectImpl.GetContentLightParams()->lightIntensity, lightIntensity);
+    EXPECT_EQ(geVisualEffectImpl.GetContentLightParams()->intensity, lightIntensity);
  
     Vector3f lightPosition = Vector3f(0.0f, 0.0f, 0.0f);
     geVisualEffectImpl.SetParam(Drawing::GE_FILTER_CONTENT_LIGHT_POSITION, lightPosition);
-    EXPECT_EQ(geVisualEffectImpl.GetContentLightParams()->lightPosition, lightPosition);
+    EXPECT_EQ(geVisualEffectImpl.GetContentLightParams()->position, lightPosition);
  
     Vector4f lightColor = Vector4f(0.3f, 0.6f, 0.9f, 0.0f);
     geVisualEffectImpl.SetParam(Drawing::GE_FILTER_CONTENT_LIGHT_COLOR, lightColor);
-    EXPECT_EQ(geVisualEffectImpl.GetContentLightParams()->lightColor, lightColor);
+    EXPECT_EQ(geVisualEffectImpl.GetContentLightParams()->color, lightColor);
 }
 
 /**
diff --git a/test/unittest/ge_visual_effect_test.cpp b/test/unittest/ge_visual_effect_test.cpp
index a58b1dd44f29aae514311c05d6b60c89b3901cd9..1d4162030b8baf7b3961beedb73e0a5e9f9ba763 100644
--- a/test/unittest/ge_visual_effect_test.cpp
+++ b/test/unittest/ge_visual_effect_test.cpp
@@ -180,12 +180,12 @@ HWTEST_F(GEVisualEffectTest, SetParam_007, TestSize.Level1)
     
     Vector3f lightPosition = Vector3f(0.0f, 0.f, 0.0f);
     visualEffect->SetParam(GE_FILTER_CONTENT_LIGHT_POSITION, lightPosition);
-    bool ret = visualEffect->visualEffectImpl_->contentLightParams_->lightPosition == lightPosition;
+    bool ret = visualEffect->visualEffectImpl_->contentLightParams_->position == lightPosition;
     EXPECT_TRUE(ret);
  
     Vector4f lightColor = Vector4f(0.2f, 0.4f, 0.6f, 0.5f);
     visualEffect->SetParam(GE_FILTER_CONTENT_LIGHT_COLOR, lightColor);
-    ret = visualEffect->visualEffectImpl_->contentLightParams_->lightColor == lightColor;
+    ret = visualEffect->visualEffectImpl_->contentLightParams_->color == lightColor;
     EXPECT_TRUE(ret);
  
     GTEST_LOG_(INFO) << "GEVisualEffectTest SetParam_007 end";