react-native-tgfx 0.0.0 → 0.0.2-alpha.0

package/cpp/third_party/tgfx/src/layers/layerstyles/DropShadowStyle.cpp

@@ -0,0 +1,180 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2024 Tencent. All rights reserved.
+//
+//  Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+//  in compliance with the License. You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/BSD-3-Clause
+//
+//  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 "tgfx/layers/layerstyles/DropShadowStyle.h"
+#include "core/utils/Log.h"
+#include "core/utils/MathExtra.h"
+#include "layers/SpreadUtils.h"
+#include "tgfx/core/ImageFilter.h"
+
+namespace tgfx {
+
+std::shared_ptr<DropShadowStyle> DropShadowStyle::Make(float offsetX, float offsetY,
+                                                       float blurrinessX, float blurrinessY,
+                                                       const Color& color, bool showBehindLayer) {
+  return std::shared_ptr<DropShadowStyle>(
+      new DropShadowStyle(offsetX, offsetY, blurrinessX, blurrinessY, color, showBehindLayer));
+}
+
+void DropShadowStyle::setOffsetX(float offsetX) {
+  if (_offsetX == offsetX) {
+    return;
+  }
+  _offsetX = offsetX;
+  invalidateFilter();
+}
+
+void DropShadowStyle::setOffsetY(float offsetY) {
+  if (_offsetY == offsetY) {
+    return;
+  }
+  _offsetY = offsetY;
+  invalidateFilter();
+}
+
+void DropShadowStyle::setBlurrinessX(float blurrinessX) {
+  if (_blurrinessX == blurrinessX) {
+    return;
+  }
+  _blurrinessX = blurrinessX;
+  invalidateFilter();
+}
+
+void DropShadowStyle::setBlurrinessY(float blurrinessY) {
+  if (_blurrinessY == blurrinessY) {
+    return;
+  }
+  _blurrinessY = blurrinessY;
+  invalidateFilter();
+}
+
+void DropShadowStyle::setColor(const Color& color) {
+  if (_color == color) {
+    return;
+  }
+  _color = color;
+  invalidateFilter();
+}
+
+void DropShadowStyle::setShowBehindLayer(bool showBehindLayer) {
+  if (_showBehindLayer == showBehindLayer) {
+    return;
+  }
+  _showBehindLayer = showBehindLayer;
+  invalidateTransform();
+}
+
+void DropShadowStyle::setSpread(float spread) {
+  if (_spread == spread) {
+    return;
+  }
+  _spread = spread;
+  // Spread does not affect the cached ImageFilter. Only trigger a redraw to regenerate the
+  // spread shape image.
+  invalidateTransform();
+}
+
+DropShadowStyle::DropShadowStyle(float offsetX, float offsetY, float blurrinessX, float blurrinessY,
+                                 const Color& color, bool showBehindLayer)
+    : _offsetX(offsetX), _offsetY(offsetY), _blurrinessX(blurrinessX), _blurrinessY(blurrinessY),
+      _color(color), _showBehindLayer(showBehindLayer) {
+}
+
+Rect DropShadowStyle::filterBounds(const Rect& srcRect, float contentScale) {
+  auto filter = getShadowFilter(contentScale);
+  if (!filter) {
+    return srcRect;
+  }
+  auto bounds = srcRect;
+  if (!FloatNearlyZero(_spread)) {
+    bounds.outset(_spread * contentScale, _spread * contentScale);
+  }
+  return filter->filterBounds(bounds);
+}
+
+LayerStyleExtraSourceType DropShadowStyle::extraSourceType() const {
+  return (!_showBehindLayer || !FloatNearlyZero(_spread)) ? LayerStyleExtraSourceType::Contour
+                                                          : LayerStyleExtraSourceType::None;
+}
+
+void DropShadowStyle::onDraw(Canvas* canvas, const LayerStyleInput& input, float alpha,
+                             BlendMode blendMode) {
+  Point offset = {};
+  auto filter = getShadowFilter(input.contentScale);
+  if (!filter) {
+    return;
+  }
+  std::shared_ptr<Image> filterSource = input.content;
+  Point filterSourceOffset = {};
+  if (!FloatNearlyZero(_spread)) {
+    auto spreadImage = SpreadUtils::MakeSpreadShapeImage(input, _spread);
+    // The spread shadow is drawn from the spread shape image. When the vector shape is unavailable
+    // (e.g. a group layer with only children) or exceeds the content image, the spread cannot be
+    // applied; skip drawing rather than falling back, since filterBounds cannot reflect the
+    // fallback geometry.
+    if (spreadImage.collapsed || spreadImage.image == nullptr) {
+      return;
+    }
+    filterSource = std::move(spreadImage.image);
+    filterSourceOffset = spreadImage.offset;
+  }
+  DEBUG_ASSERT(filterSource != nullptr);
+  auto shadowImage = filterSource->makeWithFilter(filter, &offset);
+  DEBUG_ASSERT(shadowImage != nullptr);
+  if (shadowImage == nullptr) {
+    return;
+  }
+
+  // Use nearest filtering when there's no blur to avoid edge artifacts caused by linear
+  // interpolation. When the texture is scaled up, linear filtering produces intermediate alpha
+  // values at edges, which causes visible borders in the shadow.
+  auto sampling = (FloatNearlyZero(_blurrinessX) && FloatNearlyZero(_blurrinessY))
+                      ? SamplingOptions(FilterMode::Nearest, MipmapMode::None)
+                      : SamplingOptions();
+  Paint paint = {};
+  if (!_showBehindLayer && input.extraSource != nullptr) {
+    auto shader = Shader::MakeImageShader(input.extraSource->image(), TileMode::Decal,
+                                          TileMode::Decal, sampling);
+    auto contourOffset = input.extraSource->imageOffset();
+    auto matrixShader = shader->makeWithMatrix(Matrix::MakeTrans(contourOffset.x, contourOffset.y));
+    paint.setMaskFilter(MaskFilter::MakeShader(matrixShader, true));
+  }
+  paint.setBlendMode(blendMode);
+  paint.setAlpha(alpha);
+  canvas->drawImage(shadowImage, filterSourceOffset.x + offset.x, filterSourceOffset.y + offset.y,
+                    sampling, &paint);
+}
+
+std::shared_ptr<ImageFilter> DropShadowStyle::getShadowFilter(float scale) {
+  if (shadowFilter && scale == currentScale) {
+    return shadowFilter;
+  }
+
+  shadowFilter = ImageFilter::DropShadowOnly(_offsetX * scale, _offsetY * scale,
+                                             _blurrinessX * scale, _blurrinessY * scale, _color);
+  currentScale = scale;
+
+  return shadowFilter;
+}
+
+void DropShadowStyle::invalidateFilter() {
+  shadowFilter = nullptr;
+  invalidateTransform();
+}
+
+}  // namespace tgfx

package/cpp/third_party/tgfx/src/layers/layerstyles/GlassStyle.cpp

@@ -0,0 +1,413 @@
+/////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Tencent is pleased to support the open source community by making tgfx available.
+//
+//  Copyright (C) 2026 Tencent. All rights reserved.
+//
+//  Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
+//  in compliance with the License. You may obtain a copy of the License at
+//
+//      https://opensource.org/licenses/BSD-3-Clause
+//
+//  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 "tgfx/layers/layerstyles/GlassStyle.h"
+#include <algorithm>
+#include <cmath>
+#include "core/images/TextureImage.h"
+#include "core/utils/Log.h"
+#include "core/utils/MathExtra.h"
+#include "gpu/DrawingManager.h"
+#include "gpu/processors/TiledTextureEffect.h"
+#include "gpu/proxies/RenderTargetProxy.h"
+#include "layers/imagefilters/GlassRefractionImageFilter.h"
+#include "layers/processors/TentBlur1DFragmentProcessor.h"
+#include "tgfx/core/ImageFilter.h"
+#include "tgfx/core/SamplingOptions.h"
+#include "tgfx/core/Surface.h"
+#include "tgfx/gpu/Context.h"
+#include "tgfx/gpu/GPU.h"
+#include "tgfx/layers/Layer.h"
+
+namespace tgfx {
+
+static constexpr float MaxFrostSigma = 50.0f;
+static constexpr int MaxTentRadius = 64;
+
+static std::shared_ptr<Image> MakeTentBlurImage(Context* context,
+                                                const std::shared_ptr<Image>& source, float radiusX,
+                                                float radiusY) {
+  if (context == nullptr || source == nullptr || radiusX <= 0.0f || radiusY <= 0.0f) {
+    return nullptr;
+  }
+  auto textureImage = source->makeTextureImage(context);
+  if (textureImage == nullptr) {
+    return nullptr;
+  }
+  auto textureProxy = std::static_pointer_cast<TextureImage>(textureImage)->getTextureProxy();
+  SamplingArgs samplingArgs = {TileMode::Decal, TileMode::Decal, {}, SrcRectConstraint::Fast};
+  auto allocator = context->drawingAllocator();
+  auto sourceProcessor = TiledTextureEffect::Make(allocator, textureProxy, samplingArgs);
+  auto horizontalTarget =
+      RenderTargetProxy::Make(context, source->width(), source->height(), false, 1, false,
+                              ImageOrigin::TopLeft, BackingFit::Exact);
+  if (sourceProcessor == nullptr || horizontalTarget == nullptr) {
+    return nullptr;
+  }
+  auto horizontalProcessor =
+      TentBlur1DFragmentProcessor::Make(allocator, std::move(sourceProcessor), radiusX,
+                                        TentBlurDirection::Horizontal, 1.0f, MaxTentRadius, false);
+  if (!context->drawingManager()->fillRTWithFP(horizontalTarget, std::move(horizontalProcessor),
+                                               0)) {
+    return nullptr;
+  }
+  auto verticalSource =
+      TiledTextureEffect::Make(allocator, horizontalTarget->asTextureProxy(), samplingArgs);
+  auto verticalTarget = RenderTargetProxy::Make(context, source->width(), source->height(), false,
+                                                1, false, ImageOrigin::TopLeft, BackingFit::Exact);
+  if (verticalSource == nullptr || verticalTarget == nullptr) {
+    return nullptr;
+  }
+  auto verticalProcessor =
+      TentBlur1DFragmentProcessor::Make(allocator, std::move(verticalSource), radiusY,
+                                        TentBlurDirection::Vertical, 1.0f, MaxTentRadius, true);
+  if (!context->drawingManager()->fillRTWithFP(verticalTarget, std::move(verticalProcessor), 0)) {
+    return nullptr;
+  }
+  return TextureImage::Wrap(verticalTarget->asTextureProxy(), nullptr);
+}
+
+std::shared_ptr<GlassStyle> GlassStyle::Make(float refraction, float depth, float frost,
+                                             float dispersion, float splay, float lightAngle,
+                                             float lightIntensity) {
+  return std::shared_ptr<GlassStyle>(
+      new GlassStyle(refraction, depth, frost, dispersion, splay, lightAngle, lightIntensity));
+}
+
+GlassStyle::GlassStyle(float refraction, float depth, float frost, float dispersion, float splay,
+                       float lightAngle, float lightIntensity)
+    : _refraction(refraction), _depth(depth), _frost(frost), _dispersion(dispersion), _splay(splay),
+      _lightAngle(lightAngle), _lightIntensity(lightIntensity) {
+}
+
+void GlassStyle::setRefraction(float value) {
+  if (_refraction == value) {
+    return;
+  }
+  _refraction = value;
+  invalidateTransform();
+}
+
+void GlassStyle::setDepth(float value) {
+  if (_depth == value) {
+    return;
+  }
+  _depth = value;
+  invalidateTransform();
+}
+
+void GlassStyle::setFrost(float value) {
+  if (_frost == value) {
+    return;
+  }
+  _frost = value;
+  invalidateFrostFilter();
+}
+
+void GlassStyle::setDispersion(float value) {
+  if (_dispersion == value) {
+    return;
+  }
+  _dispersion = value;
+  invalidateTransform();
+}
+
+void GlassStyle::setSplay(float value) {
+  if (_splay == value) {
+    return;
+  }
+  _splay = value;
+  invalidateTransform();
+}
+
+void GlassStyle::setLightAngle(float degrees) {
+  if (_lightAngle == degrees) {
+    return;
+  }
+  _lightAngle = degrees;
+  invalidateTransform();
+}
+
+void GlassStyle::setLightIntensity(float value) {
+  if (_lightIntensity == value) {
+    return;
+  }
+  _lightIntensity = value;
+  invalidateTransform();
+}
+
+Rect GlassStyle::filterBackground(const Rect& srcRect, float contentScale) {
+  auto result = srcRect;
+  auto sizeBounds = srcRect;
+  // Layer::updateRenderBounds passes an empty rectangle and reads right/bottom as pure outset
+  // amounts. Refraction depends on layer dimensions, so use the owner's bounds in root coordinates
+  // for that call. Non-empty rectangles come from dirty-region propagation and must retain their
+  // original position.
+  if (sizeBounds.isEmpty() && !owners.empty() && owners[0] != nullptr) {
+    auto owner = owners[0];
+    sizeBounds = owner->getBounds(owner->root(), false);
+  }
+  // Do not cache the frost filter: onDraw applies frost at a different scale
+  // (contentScale * bgScale) to the downsampled background image, invalidating any cache here.
+  if (_frost > 0) {
+    float sigma = (_frost / 100.0f) * MaxFrostSigma * contentScale;
+    auto filter = ImageFilter::Blur(sigma, sigma, TileMode::Mirror);
+    result = filter->filterBounds(srcRect);
+  }
+  // Refraction outset: cover the shader's clamped displacement for the most offset chromatic
+  // channel. The shader clamps each displacement component to 0.999 * refractionDistance before
+  // multiplying R/B offsets by (1 +/- dispersion).
+  if (_refraction > 0 || _lightIntensity > 0) {
+    auto halfW = sizeBounds.width() * 0.5f;
+    auto halfH = sizeBounds.height() * 0.5f;
+    auto minHalf = std::min(halfW, halfH);
+    float refractionFactor = getRefractionFactor();
+    float depthRatio = getDepthRatio();
+    float depthT = std::clamp(depthRatio / 0.1f, 0.0f, 1.0f);
+    float depthScale = depthT * depthT * (3.0f - 2.0f * depthT);
+    float refractionDistance = minHalf * refractionFactor * depthRatio * depthScale;
+    float dispersion = (_dispersion / 100.0f) * 0.2f;
+    float refractionOutset = 0.999f * refractionDistance * (1.0f + dispersion);
+    refractionOutset = std::max(refractionOutset, 1.0f);
+    result.join(srcRect.makeOutset(refractionOutset, refractionOutset));
+  }
+  return result;
+}
+
+void GlassStyle::onDraw(Canvas* canvas, const LayerStyleInput& input, float alpha,
+                        BlendMode blendMode) {
+  if (input.extraSource == nullptr) {
+    DEBUG_ASSERT(false);
+    return;
+  }
+
+  auto bgImage = input.extraSource->image();
+  if (bgImage == nullptr || input.content == nullptr || FloatNearlyZero(input.contentScale)) {
+    return;
+  }
+  auto bgOffset = input.extraSource->imageOffset();
+
+  // Down-scale the background to avoid huge GPU textures when zoomed in.
+  // The background image includes outset beyond layer content bounds (for refraction sampling).
+  // Use bgImage's actual dimensions to compute scale ratio so coordinates stay aligned.
+  auto surface = canvas->getSurface();
+  auto context = surface ? surface->getContext() : nullptr;
+  if (context == nullptr) {
+    return;
+  }
+  auto maxTextureSize = context->gpu()->limits()->maxTextureDimension2D;
+  auto origWidth = static_cast<float>(input.content->width()) / input.contentScale;
+  auto origHeight = static_cast<float>(input.content->height()) / input.contentScale;
+  auto origBounds = Rect::MakeWH(origWidth, origHeight);
+  static constexpr float MAX_BG_SIZE = 2048.0f;
+  float bgMaxDim = static_cast<float>(std::max(bgImage->width(), bgImage->height()));
+  float targetMaxDim =
+      std::min(bgMaxDim, std::min(static_cast<float>(maxTextureSize), MAX_BG_SIZE));
+  float bgScale = targetMaxDim / bgMaxDim;
+  int scaledW =
+      std::max(1, static_cast<int>(std::round(static_cast<float>(bgImage->width()) * bgScale)));
+  int scaledH =
+      std::max(1, static_cast<int>(std::round(static_cast<float>(bgImage->height()) * bgScale)));
+  float scaleRatioX = static_cast<float>(scaledW) / static_cast<float>(bgImage->width());
+  float scaleRatioY = static_cast<float>(scaledH) / static_cast<float>(bgImage->height());
+  bgImage = bgImage->makeScaled(scaledW, scaledH, SamplingOptions(FilterMode::Linear));
+  if (bgImage == nullptr) {
+    return;
+  }
+  bgOffset.x *= scaleRatioX;
+  bgOffset.y *= scaleRatioY;
+
+  // Step 1: Frost - apply Gaussian blur to the background
+  std::shared_ptr<Image> processedBg = bgImage;
+  Point processedOffset = bgOffset;
+  if (_frost > 0) {
+    auto blurFilter = getFrostFilter(input.contentScale * bgScale);
+    if (blurFilter) {
+      Point blurOffset = {};
+      auto clipRect = Rect::MakeWH(bgImage->width(), bgImage->height());
+      processedBg = bgImage->makeWithFilter(blurFilter, &blurOffset, &clipRect);
+      processedOffset += blurOffset;
+    }
+  }
+  // Step 2 & 3: Apply refraction with dispersion and lighting (computed entirely in GPU shader)
+  if (_refraction > 0 || _lightIntensity > 0) {
+    // layerWidth/Height must match processedBg dimensions for correct UV mapping in shader.
+    int layerWidth = processedBg->width();
+    int layerHeight = processedBg->height();
+
+    // Use origBounds (not zoom-affected) for all refraction parameters so the effect is
+    // zoom-invariant regardless of bgScale downsampling.
+    float halfW = origBounds.width() * 0.5f;
+    float halfH = origBounds.height() * 0.5f;
+    float udfPixelToLayerPixel = 1.0f;
+    // For AlphaMask shape, generate a UDF height map:
+    // Tent-blur the binary alpha to approximate UDF (triangular kernel gives more linear
+    // transition than Gaussian, closer to a true distance field).
+    // The maskImage is rebuilt every frame via MakeTentBlurImage (input.content changes).
+    // UDF is capped at MAX_UDF_SIZE to prevent excessive texture allocation. The mask UVs
+    // are normalized (0-1), so lower resolution does not affect the refraction shader.
+    static constexpr float MAX_UDF_SIZE = 512.0f;
+    std::shared_ptr<Image> maskImage = nullptr;
+    std::shared_ptr<Image> coarseMaskImage = nullptr;
+    // Use original layer bounds (not zoom-affected) for blur radius calculation.
+    // depth 1-100 maps linearly to blurRadius 1-60, minimum 5.
+    float blurRadius = std::max(std::min((_depth / 100.0f) * 60.0f, 60.0f), 5.0f);
+    // UDF texture size follows the original content bounds and is capped at MAX_UDF_SIZE.
+    // udfPixelToLayerPixel and blurRadius scale with udfScale, so the shader's refraction
+    // distance in layer space remains consistent regardless of UDF resolution.
+    float origMaxDim = std::max(origBounds.width(), origBounds.height());
+    if (origMaxDim <= 0.0f) {
+      return;
+    }
+    float udfScale = std::min({1.0f, MAX_UDF_SIZE / origMaxDim});
+    int udfWidth = std::max(1, static_cast<int>(std::round(origBounds.width() * udfScale)));
+    int udfHeight = std::max(1, static_cast<int>(std::round(origBounds.height() * udfScale)));
+    // udfPixelToLayerPixel converts UDF pixel coordinates to layer pixel coordinates in the
+    // shader. Both UDF size and layer params are origBounds-based, so the ratio is zoom-invariant.
+    udfPixelToLayerPixel = static_cast<float>(origBounds.width()) / static_cast<float>(udfWidth);
+    // Scale the content image to the fixed UDF resolution.
+    std::shared_ptr<Image> udfContent = input.content;
+    if (udfWidth != input.content->width() || udfHeight != input.content->height()) {
+      udfContent =
+          input.content->makeScaled(udfWidth, udfHeight, SamplingOptions(FilterMode::Linear));
+      if (udfContent == nullptr) {
+        return;
+      }
+    }
+    // Blur radius in UDF pixel space. Since UDF size is origBounds-based, the radius is
+    // zoom-invariant.
+    float udfBlurRadiusX = blurRadius * udfScale;
+    float udfBlurRadiusY = blurRadius * udfScale;
+    // depthRatio stays as _depth/100 for shader use (step calculation).
+    maskImage = MakeTentBlurImage(context, udfContent, udfBlurRadiusX, udfBlurRadiusY);
+    if (!maskImage) {
+      LOGE("GlassStyle: Failed to blur alpha for UDF, falling back to content.");
+      maskImage = udfContent;
+    }
+
+    if (_lightIntensity > 0) {
+      // Edge light UDF: half the resolution of the fine UDF, fixed small blur radius.
+      // Used for edge lighting (edgeWeight) while the fine UDF is used for refraction direction.
+      static constexpr float EDGE_LIGHT_BLUR_RADIUS = 5.0f;
+      int edgeLightWidth = std::max(1, udfWidth / 2);
+      int edgeLightHeight = std::max(1, udfHeight / 2);
+      std::shared_ptr<Image> edgeLightContent = udfContent;
+      if (edgeLightWidth != udfWidth || edgeLightHeight != udfHeight) {
+        edgeLightContent = udfContent->makeScaled(edgeLightWidth, edgeLightHeight,
+                                                  SamplingOptions(FilterMode::Linear));
+        if (edgeLightContent == nullptr) {
+          return;
+        }
+      }
+      float edgeLightRadiusX = EDGE_LIGHT_BLUR_RADIUS * udfScale;
+      float edgeLightRadiusY = EDGE_LIGHT_BLUR_RADIUS * udfScale;
+      coarseMaskImage =
+          MakeTentBlurImage(context, edgeLightContent, edgeLightRadiusX, edgeLightRadiusY);
+      if (!coarseMaskImage) {
+        LOGE("GlassStyle: Failed to blur alpha for edge light UDF, falling back to content.");
+        coarseMaskImage = edgeLightContent;
+      }
+    }
+    auto filter = getRefractionFilter(layerWidth, layerHeight, halfW, halfH, udfPixelToLayerPixel,
+                                      maskImage, coarseMaskImage);
+    Point refractOffset = {};
+    auto clipRect = Rect::MakeWH(static_cast<float>(processedBg->width()),
+                                 static_cast<float>(processedBg->height()));
+    auto refractedImage = processedBg->makeWithFilter(filter, &refractOffset, &clipRect);
+    if (refractedImage) {
+      processedBg = refractedImage;
+      processedOffset += refractOffset;
+    }
+  }
+
+  float finalOffsetX = processedOffset.x / scaleRatioX;
+  float finalOffsetY = processedOffset.y / scaleRatioY;
+  float finalScaleX = 1.0f / scaleRatioX;
+  float finalScaleY = 1.0f / scaleRatioY;
+
+  Paint paint = {};
+  paint.setBlendMode(blendMode);
+  paint.setAlpha(alpha);
+
+  // Draw the pre-rasterized refraction result (at capped resolution) into content pixel space,
+  // clipped to the layer shape via the content alpha mask.
+  auto imageShader = Shader::MakeImageShader(processedBg, TileMode::Decal, TileMode::Decal,
+                                             SamplingOptions(FilterMode::Linear));
+  auto imageMatrix =
+      Matrix::MakeAll(finalScaleX, 0.0f, finalOffsetX, 0.0f, finalScaleY, finalOffsetY);
+  imageShader = imageShader->makeWithMatrix(imageMatrix);
+  paint.setShader(imageShader);
+
+  // The refraction has been pre-rasterized into processedBg (a low-resolution image). Draw it
+  // through the content alpha mask so the glass effect is clipped to the layer shape.
+  auto maskShader = Shader::MakeImageShader(input.content, TileMode::Decal, TileMode::Decal);
+  paint.setMaskFilter(MaskFilter::MakeShader(maskShader, false));
+  auto contentRect = Rect::MakeWH(static_cast<float>(input.content->width()),
+                                  static_cast<float>(input.content->height()));
+  canvas->drawRect(contentRect, paint);
+}
+
+std::shared_ptr<ImageFilter> GlassStyle::getFrostFilter(float contentScale) {
+  if (_frost <= 0) {
+    return nullptr;
+  }
+  if (frostFilter && FloatNearlyEqual(currentFrostScale, contentScale)) {
+    return frostFilter;
+  }
+  currentFrostScale = contentScale;
+  float sigma = (_frost / 100.0f) * MaxFrostSigma * contentScale;
+  frostFilter = ImageFilter::Blur(sigma, sigma, TileMode::Mirror);
+  return frostFilter;
+}
+
+void GlassStyle::invalidateFrostFilter() {
+  frostFilter = nullptr;
+  invalidateTransform();
+}
+
+std::shared_ptr<ImageFilter> GlassStyle::getRefractionFilter(
+    int layerWidth, int layerHeight, float halfWidth, float halfHeight, float udfPixelToLayerPixel,
+    std::shared_ptr<Image> maskImage, std::shared_ptr<Image> coarseMaskImage) {
+  float minHalf = std::min(halfWidth, halfHeight);
+  float depthRatio = getDepthRatio();
+  GlassRefractionParams params = {};
+  params.glassWidth = static_cast<float>(layerWidth);
+  params.glassHeight = static_cast<float>(layerHeight);
+  params.halfW = halfWidth;
+  params.halfH = halfHeight;
+  params.minHalf = minHalf;
+  // glassThickness and origMinHalf are legacy SDF padding slots retained for GPU uniform
+  // layout stability. The shader no longer reads them, so they are set to 0.
+  params.glassThickness = 0.0f;
+  params.refractionFactor = std::clamp(_refraction / 100.0f, 0.0f, 1.0f);
+  // Scale dispersion to [0, 0.2]: the shader offsets R/B UVs by uvOffset * (1 ± dispersion),
+  // so 0.2 means max 20% additional offset, keeping chromatic aberration subtle.
+  params.dispersion = (_dispersion / 100.0f) * 0.2f;
+  params.splay = std::clamp(_splay / 100.0f, 0.0f, 1.0f);
+  params.depthRatio = depthRatio;
+  params.lightAngle = _lightAngle;
+  params.lightIntensity = (_lightIntensity > 0) ? _lightIntensity / 100.0f : 0.0f;
+  params.origMinHalf = 0.0f;
+  params.origWidth = halfWidth * 2.0f;
+  params.origHeight = halfHeight * 2.0f;
+  params.udfPixelToLayerPixel = udfPixelToLayerPixel;
+  return std::make_shared<GlassRefractionImageFilter>(params, std::move(maskImage),
+                                                      std::move(coarseMaskImage));
+}
+
+}  // namespace tgfx