Merge pull request 'Add a drop shadow cast by the frame' (#12) from feature/drop-shadow into develop

Reviewed-on: #12

CLAUDE.md

@@ -59,6 +59,11 @@ Config values live under `plugin:hyprchrome:*` and are declared in `src/GlobalSt
 - `extent` (int, px the border extends past the window edge)
 - `follow_hyprland_border_color` (bool) — when true (default), the border tracks Hyprland's own resolved active/inactive border color instead of `active_color`/`inactive_color`
 - `active_color` / `inactive_color` (gradient — one or more colors + optional angle, same syntax as `general:col.active_border`) — used when `follow_hyprland_border_color` is false, or when Hyprland reports no border color at all
+- `glow_size` (int, px the border's color bleeds inward past the window edge, over the window itself — 0, the default, disables it)
+- `glow_strength` (float 0–1, peak opacity of that glow at the window edge, as a fraction of the border color's own alpha)
+- `shadow_size` (int, px the frame's drop shadow reaches past its own outline — 0, the default, disables it)
+- `shadow_color` (color, its alpha being the shadow's opacity)
+- `shadow_offset` (vec2, px the shadow is displaced by; positive is right/down)
 - `titlebar_height` (int, px)
 - `titlebar_text_size` (int, px)
 - `titlebar_font` (string, passed to `cairo_select_font_face`)
@@ -78,7 +83,9 @@ Per-window decoration (`src/ChromeDecoration.hpp/.cpp`): implements `IHyprWindow
 - `getPositioningInfo()` reserves screen space around the window (`DECORATION_POSITION_ABSOLUTE`, all four edges) sized by `extent` (+ `titlebarHeight` on top) — this is what makes Hyprland leave room for the border/title bar instead of it overlapping neighboring windows.
 - `draw()` doesn't render directly; it enqueues a `ChromePassElement` into Hyprland's render pass each frame.
 - `GetBorderTexture(...)` and `GetTitleTexture(...)` are the actual cairo/Pango rendering entry points, each memoizing against their own last-seen parameters (size, extent, chamfer, color, title text, font, etc.) so unchanged frames reuse the cached `Render::ITexture` instead of re-rendering.
-- `FullDecorationExtentGlobal()` computes the decoration's box in global logical coordinates, accounting for workspace animation offset and floating-window offset.
+- `FullDecorationExtentGlobal()` computes the decoration's box in global logical coordinates, accounting for workspace animation offset and floating-window offset. It deliberately excludes the drop shadow (below), which is drawn outside it.
+- `GetShadowTexture(...)` renders the drop shadow. The silhouette is `AppendFrameOuterPath` — the same outline `GetBorderTexture` fills, extracted specifically so the two can't drift apart — filled solid into an A8 mask, blurred, then tinted. Three things about it are load-bearing: (1) the window's interior is cleared *after* the blur, not before, since punching it first would smear shadow inward across the window's own content; the cut lands exactly on the ring's inner boundary so the frame's opaque pixels hide it. (2) The shadow is not part of `getPositioningInfo`'s reserved extents — reserving it would push neighbouring windows away by the shadow's width — so it's simply drawn past the decoration's box, which is why `damageEntire()` and `boundingBox()` have to expand by `ShadowMarginLogical()` by hand. (3) It's rendered at most `kShadowMaxDim` px on the long edge and upscaled by the GPU; a blurred blob loses nothing to that, and it caps a cost that would otherwise be paid per frame of a resize animation. The blur itself is three box passes (`BlurA8Surface`), transposing between each so the vertical pass reuses the horizontal one's cache-friendly row code.
+- The inward glow (`glow_size`/`glow_strength`) is drawn by `DrawInwardGlow` into the hole the ring's even-odd fill leaves behind, so it lands on the window's own pixels (this decoration is `DECORATION_LAYER_OVER`, and the texture spans the whole window box, not just the ring). Its falloff is built from *overlapping* fills (one layer per px of depth, clamped to `kGlowMinLayers`/`kGlowMaxLayers`) — layer *i* covers the window edge inward to depth `glowPx * i / layers`, so a pixel `d` from the edge is painted by every layer deeper than `d`. The profile is stated explicitly (`strength * (1 - d/glowPx)^kGlowFalloffExponent` — fast off the edge, easing into a tail that reaches zero tangentially so there's no ring where it stops), and since each layer composites over every deeper one, a layer's own alpha is *not* its target: it's solved outermost-inward as `1 - a_j = (1 - T_j) / (1 - T_j+1)`. Changing the profile means changing `targetAt`, not the per-layer alphas. Abutting disjoint bands instead would leave an antialiasing seam at every shared edge; that's the reason for the overlap, don't "optimize" it away. Every layer's *outer* edge is the ring's inner boundary verbatim, chamfer vertices and all — filleting or otherwise altering it detaches the glow from the frame and opens a sliver of unpainted window at each corner. The corner softening lives entirely on the layers' *inner* edges, which are what the accumulated falloff's contours actually follow: each is inset by its own depth, filleted by `kGlowCornerSmoothing` × that depth (`AppendFilletedPolygon`, a quadratic Bezier through each vertex), and has its chamfer shrunk by `kChamferInsetShrink` × that depth. That last correction is not optional cosmetics — insetting a chamfered rect while holding its chamfer constant moves the 45° face in by `d·√2` rather than `d`, so without it the glow runs ~41% deeper at every corner than along the sides. The per-layer alpha is baked into the gradient pattern (`CreateGradientPattern`'s `alphaScale`) specifically so each layer can be a `cairo_fill` of its own band rather than a clip + `cairo_paint_with_alpha`, which would rasterize the clip's full extents — i.e. the whole window area — once per layer.
 
 Render-pass element (`src/ChromePassElement.hpp/.cpp`): an `EK_CUSTOM` pass element (`ChromePassElement::draw()`) that runs once per frame per window and:
 - Derives the corner chamfer live from the window's own `rounding()` (in device px, scaled by monitor scale) — so the border's cut corners track the window's rounding through config reloads, per-window rules, and animations.

src/ChromeConfig.hpp

@@ -18,6 +18,26 @@ struct ChromeConfig {
   SP<GradientValue> activeColor;
   SP<GradientValue> inactiveColor;
 
+  // How far the border's glow bleeds inward past the window edge, over the
+  // window's own pixels, in logical pixels. 0 disables the glow entirely.
+  SP<IntValue> glowSize;
+
+  // Peak opacity of that glow, at the window edge, as a fraction of the
+  // border color's own alpha.
+  SP<FloatValue> glowStrength;
+
+  // How far the frame's drop shadow reaches past its own outline, in logical
+  // pixels. 0 disables the shadow entirely.
+  SP<IntValue> shadowSize;
+
+  // Color the shadow is tinted with - its alpha is the shadow's opacity at
+  // full coverage.
+  SP<ColorValue> shadowColor;
+
+  // How far the shadow is displaced from the frame, in logical pixels;
+  // positive is right/down.
+  SP<Vec2Value> shadowOffset;
+
   // Height of the title bar hanging off the floating top-border cutout, in
   // logical pixels.
   SP<IntValue> titlebarHeight;

src/ChromeDecoration.cpp

@@ -11,6 +11,9 @@
 #include <cairo/cairo.h>
 
 #include <algorithm>
+#include <cmath>
+#include <limits>
+#include <numbers>
 #include <vector>
 
 namespace {
@@ -36,7 +39,11 @@ std::vector<size_t> Utf8CodepointStarts(const std::string& s) {
 // compositor's own border, and it only costs anything on a cache miss.
 constexpr int kStopsPerSegment = 8;
 
-cairo_pattern_t* CreateGradientPattern(const ChromeGradient& gradient, double w, double h) {
+// `alphaScale` multiplies every stop's own alpha - the glow layers below
+// reuse the border's gradient at a fraction of its opacity, and baking that
+// into the pattern lets them cairo_fill() (which only touches the filled
+// band) instead of clip+paint (which rasterizes the clip's whole extents).
+cairo_pattern_t* CreateGradientPattern(const ChromeGradient& gradient, double w, double h, double alphaScale = 1.0) {
   const auto axis = gradient.AxisFor(w, h);
   const auto pattern = cairo_pattern_create_linear(axis.x0, axis.y0, axis.x1, axis.y1);
 
@@ -45,11 +52,324 @@ cairo_pattern_t* CreateGradientPattern(const ChromeGradient& gradient, double w,
   for (int i = 0; i <= steps; ++i) {
     const double t = static_cast<double>(i) / steps;
     const auto color = gradient.SampleAt(static_cast<float>(t));
-    cairo_pattern_add_color_stop_rgba(pattern, t, color.r, color.g, color.b, color.a);
+    cairo_pattern_add_color_stop_rgba(pattern, t, color.r, color.g, color.b, color.a * alphaScale);
   }
 
   return pattern;
 }
+
+struct Point {
+  double x = 0, y = 0;
+};
+
+// The corners of a chamfered rectangle spanning [x0,x1]x[y0,y1], cut by
+// `chamfer` (clamped to what the rect can fit) - eight points, or the plain
+// four if the chamfer rounds away to nothing. Empty if the rect has collapsed.
+std::vector<Point> ChamferedRectPoints(float x0, float y0, float x1, float y1, float chamfer) {
+  if (x1 <= x0 || y1 <= y0)
+    return {};
+
+  const float c = std::clamp(chamfer, 0.F, std::min(x1 - x0, y1 - y0) / 2.F);
+  if (c <= 0.F)
+    return {{x0, y0}, {x1, y0}, {x1, y1}, {x0, y1}};
+
+  return {{x0 + c, y0}, {x1 - c, y0}, {x1, y0 + c}, {x1, y1 - c},
+          {x1 - c, y1}, {x0 + c, y1}, {x0, y1 - c}, {x0, y0 + c}};
+}
+
+// Appends `pts` as a closed subpath, with every vertex rounded off by a
+// `smooth`-px fillet: the path leaves the incoming edge `smooth` px early and
+// rejoins the outgoing one `smooth` px late, bridged by a quadratic Bezier
+// through the vertex itself (written as the equivalent cubic, which is all
+// cairo takes). `smooth` is capped at half the shortest edge so two adjacent
+// fillets meet at that edge's midpoint at worst instead of overrunning each
+// other; at 0 this is just a polyline.
+void AppendFilletedPolygon(cairo_t* cr, const std::vector<Point>& pts, double smooth) {
+  const size_t n = pts.size();
+  if (n < 3)
+    return;
+
+  double maxSmooth = std::numeric_limits<double>::max();
+  for (size_t i = 0; i < n; ++i) {
+    const auto& a = pts[i];
+    const auto& b = pts[(i + 1) % n];
+    maxSmooth = std::min(maxSmooth, std::hypot(b.x - a.x, b.y - a.y) / 2.0);
+  }
+
+  const double s = std::clamp(smooth, 0.0, maxSmooth);
+  if (s <= 0.0) {
+    cairo_move_to(cr, pts[0].x, pts[0].y);
+    for (size_t i = 1; i < n; ++i)
+      cairo_line_to(cr, pts[i].x, pts[i].y);
+    cairo_close_path(cr);
+    return;
+  }
+
+  // `s` px from `from` towards `to`.
+  const auto along = [](const Point& from, const Point& to, double d) {
+    const double dx = to.x - from.x, dy = to.y - from.y;
+    const double len = std::hypot(dx, dy);
+    return len > 0 ? Point{from.x + dx / len * d, from.y + dy / len * d} : from;
+  };
+
+  for (size_t i = 0; i < n; ++i) {
+    const auto& prev = pts[(i + n - 1) % n];
+    const auto& cur = pts[i];
+    const auto& next = pts[(i + 1) % n];
+
+    const auto in = along(cur, prev, s);
+    const auto out = along(cur, next, s);
+
+    if (i == 0)
+      cairo_move_to(cr, in.x, in.y);
+    else
+      cairo_line_to(cr, in.x, in.y);
+
+    cairo_curve_to(cr,
+      cur.x + (in.x - cur.x) / 3.0, cur.y + (in.y - cur.y) / 3.0,
+      cur.x + (out.x - cur.x) / 3.0, cur.y + (out.y - cur.y) / 3.0,
+      out.x, out.y);
+  }
+
+  cairo_close_path(cr);
+}
+
+// Appends a closed chamfered-rectangle subpath spanning [x0,x1]x[y0,y1], its
+// corners cut by `chamfer` and then optionally softened by a `smooth`-px
+// fillet. Returns false without touching the path if the rect has collapsed
+// to nothing.
+bool AppendChamferedRect(cairo_t* cr, float x0, float y0, float x1, float y1, float chamfer, float smooth = 0.F) {
+  const auto pts = ChamferedRectPoints(x0, y0, x1, y1, chamfer);
+  if (pts.empty())
+    return false;
+
+  AppendFilletedPolygon(cr, pts, smooth);
+  return true;
+}
+
+// Appends the frame's outer boundary as a closed subpath: the chamfered ring
+// edge, the title bar plateau hanging off the top-left (or, below the fullSpan
+// threshold, a flat top edge at the plateau's own height, since there's no
+// room for the dip back down), and the notch cut into either side edge. The
+// ring itself starts at geo.topPad rather than 0, leaving the strip above it
+// for the title bar to stick up into.
+//
+// Both the frame's own fill and the drop shadow's silhouette walk this, so the
+// shadow can't drift out of step with the shape casting it.
+void AppendFrameOuterPath(cairo_t* cr, const ChromeDecorationGeometry& geo) {
+  const float w = geo.w;
+  const float h = geo.h;
+
+  cairo_move_to(cr, geo.chamfer + geo.topPad, 0);
+
+  /* *** Top Edge *** */
+  if (geo.fullSpan) {
+    cairo_line_to(cr, w - geo.chamfer - geo.topPad, 0);
+    cairo_line_to(cr, w, geo.topPad + geo.chamfer);
+  } else {
+    cairo_line_to(cr, geo.titleBarWidth, 0);
+    cairo_line_to(cr, geo.titleBarWidth + geo.topPad + geo.extent, geo.topPad + geo.extent);
+
+    cairo_line_to(cr, geo.dipReturnX, geo.topPad + geo.extent);
+    cairo_line_to(cr, geo.dipReturnX + geo.extent, geo.topPad);
+    cairo_line_to(cr, w - geo.chamfer, geo.topPad);
+    cairo_line_to(cr, w, geo.topPad + geo.chamfer);
+  }
+
+  /* *** Right Edge *** */
+
+  cairo_line_to(cr, w, geo.insetStart);
+  cairo_line_to(cr, w - geo.insetDepth, geo.insetStart + geo.insetChamfer);
+  cairo_line_to(cr, w - geo.insetDepth, geo.insetEnd - geo.insetChamfer);
+  cairo_line_to(cr, w, geo.insetEnd);
+
+  cairo_line_to(cr, w, h - geo.chamfer);
+  cairo_line_to(cr, w - geo.chamfer, h);
+
+  /* *** Bottom Edge *** */
+
+  cairo_line_to(cr, geo.chamfer, h);
+  cairo_line_to(cr, 0, h - geo.chamfer);
+  cairo_line_to(cr, 0, geo.topPad + geo.chamfer);
+
+  /* *** Left Edge *** */
+  cairo_line_to(cr, 0, geo.insetEnd);
+  cairo_line_to(cr, 0 + geo.insetDepth, geo.insetEnd - geo.insetChamfer);
+  cairo_line_to(cr, 0 + geo.insetDepth, geo.insetStart + geo.insetChamfer);
+  cairo_line_to(cr, 0, geo.insetStart);
+
+  cairo_line_to(cr, 0, geo.topPad + geo.chamfer);
+
+  cairo_close_path(cr);
+}
+
+// How many overlapping layers the inward glow's falloff is built from - one
+// per px of depth, so the bands stay sub-pixel-ish either way, bounded so a
+// hairline glow doesn't waste fills and a huge one doesn't run away with them
+// (each layer is another band-shaped fill, only on a cache miss).
+constexpr int kGlowMinLayers = 16;
+constexpr int kGlowMaxLayers = 64;
+
+// Shape of the falloff: alpha at depth d is strength * (1 - d/glowPx)^this.
+// Above 1 the glow drops off steeply at the window edge and then eases out
+// into a long tail - and, because it reaches zero tangentially rather than
+// at an angle, without a visible ring where the tail finally stops.
+constexpr float kGlowFalloffExponent = 2.2F;
+
+// How much of its own depth each glow layer's inner edge is filleted by, so
+// the glow's contours round off the further in they go. Only the inner edges
+// get this - the outermost one has to stay the ring's inner boundary exactly,
+// chamfer vertices and all, or the corners open up a sliver of unpainted
+// window between the frame and the glow.
+constexpr float kGlowCornerSmoothing = 0.5F;
+
+// A chamfered rect inset by `d` only stays a constant `d` away from its
+// original on the straight edges: holding the chamfer itself constant pushes
+// the 45-degree face in by d*sqrt(2) rather than d, so the band would run
+// ~41% deeper at each corner than along the sides. Shrinking the chamfer by
+// this much per px of inset makes the offset properly parallel instead.
+constexpr float kChamferInsetShrink = 2.F - std::numbers::sqrt2_v<float>;
+
+// Bleeds the border color inward past the window edge - over the window's own
+// pixels, since this decoration renders on DECORATION_LAYER_OVER - fading out
+// over `glowPx` and peaking at `strength` (times the gradient's own alpha) at
+// the edge itself.
+//
+// Each layer covers the region from the window edge inward to a progressively
+// greater depth, so a pixel `d` from the edge is painted by every layer deeper
+// than `d`. Overlapping the layers rather than abutting disjoint bands is what
+// keeps the ramp free of the antialiasing seams their shared edges would
+// otherwise leave - the price being that a layer can't just be given the alpha
+// the profile calls for, since it composites on top of every deeper layer too.
+//
+// Band j (between depths j-1 and j) is covered by layers j..n, landing at
+// 1 - prod(1 - a_i) for i >= j. Walking outermost-inward, each layer's own
+// alpha then falls out of the profile directly:
+//
+//     1 - a_j = (1 - T_j) / (1 - T_j+1)
+//
+// with T_j the target alpha sampled at band j's midpoint, and T_n+1 = 0.
+void DrawInwardGlow(cairo_t* cr, const ChromeDecorationGeometry& geo, const ChromeGradient& gradient, float glowPx, float strength, int w, int h) {
+  if (glowPx < 1.F || strength <= 0.F || geo.innerW <= 0 || geo.innerH <= 0)
+    return;
+
+  const int layers = std::clamp(static_cast<int>(std::ceil(glowPx)), kGlowMinLayers, kGlowMaxLayers);
+  const double peak = std::clamp(strength, 0.F, 1.F);
+  const auto targetAt = [&](double depth) {
+    return peak * std::pow(1.0 - std::clamp(depth / glowPx, 0.0, 1.0), kGlowFalloffExponent);
+  };
+
+  cairo_save(cr);
+  cairo_set_fill_rule(cr, CAIRO_FILL_RULE_EVEN_ODD);
+
+  // Deepest (faintest) layer first, so each iteration already knows the
+  // accumulated target of everything that will composite under it.
+  double deeperTarget = 0.0;
+  for (int i = layers; i >= 1; --i) {
+    const float depth = glowPx * static_cast<float>(i) / layers;
+    // Sampled at the band's shallow (brighter) edge rather than its midpoint,
+    // so the innermost band lands on `strength` exactly instead of half a
+    // band short of it. The half-band brightness bias that trades for is a
+    // sub-pixel shift at these layer counts.
+    const double target = targetAt(glowPx * (static_cast<double>(i) - 1.0) / layers);
+
+    const auto pattern = CreateGradientPattern(gradient, w, h, 1.0 - (1.0 - target) / (1.0 - deeperTarget));
+    cairo_set_source(cr, pattern);
+    deeperTarget = target;
+
+    // Every layer's outer edge is the ring's inner boundary verbatim, so the
+    // glow always meets the frame exactly.
+    AppendChamferedRect(cr, geo.innerX0, geo.innerY0, geo.innerX1, geo.innerY1, geo.innerChamfer);
+    // Punches this layer's un-glowed middle back out - inset by `depth`, with
+    // the corner both parallel-corrected and rounded off in proportion to how
+    // deep it is. Since it's these edges that the accumulated falloff's
+    // contours follow, the glow reads as chamfered where it meets the frame
+    // and progressively rounder inward. On a window smaller than the glow is
+    // deep the middle collapses to nothing and the layer just covers all of
+    // it, which is the right answer anyway.
+    AppendChamferedRect(cr,
+      geo.innerX0 + depth, geo.innerY0 + depth, geo.innerX1 - depth, geo.innerY1 - depth,
+      geo.innerChamfer - depth * kChamferInsetShrink, depth * kGlowCornerSmoothing);
+    cairo_fill(cr);
+
+    cairo_pattern_destroy(pattern);
+  }
+
+  cairo_restore(cr);
+}
+
+// One box blur pass over an A8 surface's rows, `radius` either side, with a
+// running sum so the cost is independent of the radius. Reads past the row's
+// ends clamp to its end pixels - which for the shadow means clamping to the
+// transparent margin the silhouette is guaranteed to sit inside, i.e. the
+// same answer zero-padding would give.
+void BoxBlurRows(const uint8_t* src, uint8_t* dst, int w, int h, int srcStride, int dstStride, int radius) {
+  const int window = radius * 2 + 1;
+
+  for (int y = 0; y < h; ++y) {
+    const uint8_t* s = src + static_cast<size_t>(y) * srcStride;
+    uint8_t* d = dst + static_cast<size_t>(y) * dstStride;
+
+    int sum = 0;
+    for (int i = -radius; i <= radius; ++i)
+      sum += s[std::clamp(i, 0, w - 1)];
+
+    for (int x = 0; x < w; ++x) {
+      d[x] = static_cast<uint8_t>(sum / window);
+      sum += s[std::clamp(x + radius + 1, 0, w - 1)] - s[std::clamp(x - radius, 0, w - 1)];
+    }
+  }
+}
+
+// Three passes of a box blur, which converges on a Gaussian fast enough that
+// nobody can tell the difference in a shadow. Transposing on each pass means
+// the column blur is the same (cache-friendly, row-major) code as the row one.
+constexpr int kShadowBlurPasses = 3;
+
+void BlurA8Surface(cairo_surface_t* surface, int radius) {
+  if (radius < 1)
+    return;
+
+  const int w = cairo_image_surface_get_width(surface);
+  const int h = cairo_image_surface_get_height(surface);
+  const int stride = cairo_image_surface_get_stride(surface);
+  uint8_t* data = cairo_image_surface_get_data(surface);
+  if (!data || w < 1 || h < 1)
+    return;
+
+  // Ping-pong buffer, sized for either orientation.
+  std::vector<uint8_t> scratch(static_cast<size_t>(w) * h);
+  std::vector<uint8_t> packed(static_cast<size_t>(w) * h);
+  for (int y = 0; y < h; ++y)
+    std::copy_n(data + static_cast<size_t>(y) * stride, w, packed.begin() + static_cast<size_t>(y) * w);
+
+  const auto transpose = [](const std::vector<uint8_t>& in, std::vector<uint8_t>& out, int inW, int inH) {
+    for (int y = 0; y < inH; ++y)
+      for (int x = 0; x < inW; ++x)
+        out[static_cast<size_t>(x) * inH + y] = in[static_cast<size_t>(y) * inW + x];
+  };
+
+  for (int pass = 0; pass < kShadowBlurPasses * 2; ++pass) {
+    // Alternates orientation: rows, then (transposed) columns, then rows...
+    const bool horizontal = pass % 2 == 0;
+    const int curW = horizontal ? w : h;
+    const int curH = horizontal ? h : w;
+
+    BoxBlurRows(packed.data(), scratch.data(), curW, curH, curW, curW, radius);
+    transpose(scratch, packed, curW, curH);
+  }
+
+  for (int y = 0; y < h; ++y)
+    std::copy_n(packed.begin() + static_cast<size_t>(y) * w, w, data + static_cast<size_t>(y) * stride);
+
+  cairo_surface_mark_dirty(surface);
+}
+
+// The shadow is a blurred blob - rendering it at full window resolution buys
+// nothing but cost, and the cost is paid again on every frame of a resize
+// animation. Past this many pixels on the long edge it's rendered smaller and
+// left to the GPU's bilinear filter on the way back up.
+constexpr double kShadowMaxDim = 512.0;
 }
 
 ChromeDecoration::ChromeDecoration(PHLWINDOW window) : IHyprWindowDecoration(window) {
@@ -105,7 +425,15 @@ eDecorationType ChromeDecoration::getDecorationType() { return DECORATION_CUSTOM
 void ChromeDecoration::updateWindow(PHLWINDOW window) { damageEntire(); }
 
 void ChromeDecoration::damageEntire() {
-  g_pHyprRenderer->damageBox(FullDecorationExtentGlobal());
+  // The shadow hangs outside the decoration's own box (it's drawn, not
+  // reserved - see ShadowMarginLogical), so damaging just that box would
+  // leave its outer reaches stale.
+  g_pHyprRenderer->damageBox(FullDecorationExtentGlobal().expand(ShadowMarginLogical()));
+}
+
+double ChromeDecoration::ShadowMarginLogical() {
+  const auto offset = PluginState->config.shadowOffset->value();
+  return ShadowMarginPx(static_cast<float>(PluginState->config.shadowSize->value()), {offset.x, offset.y});
 }
 
 eDecorationLayer ChromeDecoration::getDecorationLayer() { return DECORATION_LAYER_OVER; }
@@ -114,13 +442,14 @@ uint64_t ChromeDecoration::getDecorationFlags() { return DECORATION_PART_OF_MAIN
 
 PHLWINDOW ChromeDecoration::GetOwner() { return windowRef.lock(); }
 
-SP<Render::ITexture> ChromeDecoration::GetBorderTexture(const Vector2D& sizePx, float extentPx, float chamferPx, const ChromeGradient& gradient, float titleBarHeightPx, float titleBarWidthPx) {
+SP<Render::ITexture> ChromeDecoration::GetBorderTexture(const Vector2D& sizePx, float extentPx, float chamferPx, const ChromeGradient& gradient, float titleBarHeightPx, float titleBarWidthPx, float glowPx, float glowStrength) {
   if (sizePx.x < 1 || sizePx.y < 1)
     return nullptr;
 
   if (cachedTexture && cachedTexture->ok() && cachedTexSize == sizePx &&
       cachedExtent == extentPx && cachedChamfer == chamferPx && cachedGradient == gradient &&
-      cachedTitleBarHeight == titleBarHeightPx && cachedTitleBarWidth == titleBarWidthPx)
+      cachedTitleBarHeight == titleBarHeightPx && cachedTitleBarWidth == titleBarWidthPx &&
+      cachedGlowSize == glowPx && cachedGlowStrength == glowStrength)
     return cachedTexture;
 
   const int w = static_cast<int>(sizePx.x);
@@ -141,81 +470,11 @@ SP<Render::ITexture> ChromeDecoration::GetBorderTexture(const Vector2D& sizePx,
 
   cairo_set_fill_rule(cr, CAIRO_FILL_RULE_EVEN_ODD);
 
-  // outer boundary, chamfered - the ring itself starts at geo.topPad, not 0,
-  // leaving the reserved strip above it for the title bar.
-  cairo_move_to(cr, geo.chamfer + geo.topPad, 0);
-
-  /* *** Top Edge *** */
-  if (geo.fullSpan) {
-    // Not enough width for a partial plateau + return trip to the normal
-    // topPad-height edge (see ChromeDecorationGeometry::fullSpan) - the
-    // whole top edge stays at y=0, both corners chamfered the same way the
-    // top-left one already is.
-    cairo_line_to(cr, w - geo.chamfer - geo.topPad, 0);
-    cairo_line_to(cr, w, geo.topPad + geo.chamfer);
-  } else {
-    cairo_line_to(cr, geo.titleBarWidth, 0);
-    cairo_line_to(cr, geo.titleBarWidth + geo.topPad + geo.extent, geo.topPad + geo.extent);
-
-    cairo_line_to(cr, geo.dipReturnX, geo.topPad + geo.extent);
-    cairo_line_to(cr, geo.dipReturnX + geo.extent, geo.topPad);
-    cairo_line_to(cr, w - geo.chamfer, geo.topPad);
-    cairo_line_to(cr, w, geo.topPad + geo.chamfer);
-  }
-
-  /* *** Right Edge *** */
-
-  cairo_line_to(cr, w, geo.insetStart);
-  cairo_line_to(cr, w - geo.insetDepth, geo.insetStart + geo.insetChamfer);
-  cairo_line_to(cr, w - geo.insetDepth, geo.insetEnd - geo.insetChamfer);
-  cairo_line_to(cr, w, geo.insetEnd);
-
-  cairo_line_to(cr, w, h - geo.chamfer);
-  cairo_line_to(cr, w - geo.chamfer, h);
-
-  /* *** Bottom Edge *** */
-
-  cairo_line_to(cr, geo.chamfer, h);
-  cairo_line_to(cr, 0, h - geo.chamfer);
-  cairo_line_to(cr, 0, geo.topPad + geo.chamfer);
-
-  /* *** Left Edge *** */
-  cairo_line_to(cr, 0, geo.insetEnd);
-  cairo_line_to(cr, 0 + geo.insetDepth, geo.insetEnd - geo.insetChamfer);
-  cairo_line_to(cr, 0 + geo.insetDepth, geo.insetStart + geo.insetChamfer);
-  cairo_line_to(cr, 0, geo.insetStart);
-
-  cairo_line_to(cr, 0, geo.topPad + geo.chamfer);
-
-  cairo_close_path(cr);
+  AppendFrameOuterPath(cr, geo);
 
   // inner boundary (window edge), inset by extent, chamfered - punches the
   // hole out of the outer path via even-odd fill, leaving just the ring.
-  if (geo.innerW > 0 && geo.innerH > 0) {
-
-    cairo_move_to(cr, geo.innerX0 + geo.innerChamfer, geo.innerY0);
-
-    /* *** Top Edge *** */
-
-    cairo_line_to(cr, geo.innerX1 - geo.innerChamfer, geo.innerY0);
-    cairo_line_to(cr, geo.innerX1, geo.innerY0 + geo.innerChamfer);
-
-    /* *** Right Edge *** */
-
-    cairo_line_to(cr, geo.innerX1, geo.innerY1 - geo.innerChamfer);
-    cairo_line_to(cr, geo.innerX1 - geo.innerChamfer, geo.innerY1);
-
-    /* *** Bottom Edge *** */
-
-    cairo_line_to(cr, geo.innerX0 + geo.innerChamfer, geo.innerY1);
-    cairo_line_to(cr, geo.innerX0, geo.innerY1 - geo.innerChamfer);
-
-    /* *** Left Edge *** */
-
-    cairo_line_to(cr, geo.innerX0, geo.innerY0 + geo.innerChamfer);
-
-    cairo_close_path(cr);
-  }
+  AppendChamferedRect(cr, geo.innerX0, geo.innerY0, geo.innerX1, geo.innerY1, geo.innerChamfer);
 
   // The gradient's axis spans the whole texture (frame + title bar), not just
   // the ring, so opposite sides of the frame land at opposite ends of it the
@@ -225,6 +484,9 @@ SP<Render::ITexture> ChromeDecoration::GetBorderTexture(const Vector2D& sizePx,
   cairo_fill(cr);
   cairo_pattern_destroy(pattern);
 
+  // Drawn after the ring, into the hole the fill above just left behind.
+  DrawInwardGlow(cr, geo, gradient, glowPx, glowStrength, w, h);
+
   cairo_surface_flush(surface);
 
   cachedTexture = g_pHyprRenderer->createTexture(surface);
@@ -234,6 +496,8 @@ SP<Render::ITexture> ChromeDecoration::GetBorderTexture(const Vector2D& sizePx,
   cachedGradient = gradient;
   cachedTitleBarHeight = titleBarHeightPx;
   cachedTitleBarWidth = titleBarWidthPx;
+  cachedGlowSize = glowPx;
+  cachedGlowStrength = glowStrength;
 
   cairo_destroy(cr);
   cairo_surface_destroy(surface);
@@ -241,6 +505,104 @@ SP<Render::ITexture> ChromeDecoration::GetBorderTexture(const Vector2D& sizePx,
   return cachedTexture;
 }
 
+float ChromeDecoration::ShadowMarginPx(float shadowSizePx, const Vector2D& offsetPx) {
+  if (shadowSizePx < 1)
+    return 0.F;
+
+  // The blur reaches `shadowSizePx` past the silhouette on every side (see
+  // GetShadowTexture's per-pass radius), and the offset slides all of that
+  // one way - so the margin has to cover both, on whichever side is worse.
+  return shadowSizePx + static_cast<float>(std::max(std::abs(offsetPx.x), std::abs(offsetPx.y)));
+}
+
+SP<Render::ITexture> ChromeDecoration::GetShadowTexture(const Vector2D& sizePx, float extentPx, float chamferPx, float titleBarHeightPx, float titleBarWidthPx, float shadowSizePx, const CHyprColor& color, const Vector2D& offsetPx) {
+  if (sizePx.x < 1 || sizePx.y < 1 || shadowSizePx < 1 || color.a <= 0)
+    return nullptr;
+
+  if (cachedShadowTex && cachedShadowTex->ok() && cachedShadowTexSize == sizePx &&
+      cachedShadowExtent == extentPx && cachedShadowChamfer == chamferPx &&
+      cachedShadowTitleBarHeight == titleBarHeightPx && cachedShadowTitleBarWidth == titleBarWidthPx &&
+      cachedShadowSize == shadowSizePx && cachedShadowColor == color && cachedShadowOffset == offsetPx)
+    return cachedShadowTex;
+
+  const auto geo = ChromeDecorationGeometry::ComputeBase(sizePx, extentPx, chamferPx, titleBarHeightPx).WithTitleBarWidth(titleBarWidthPx);
+
+  const float margin = ShadowMarginPx(shadowSizePx, offsetPx);
+  const double fullW = sizePx.x + 2.0 * margin;
+  const double fullH = sizePx.y + 2.0 * margin;
+  const double scale = std::min(1.0, kShadowMaxDim / std::max(fullW, fullH));
+
+  const int w = std::max(1, static_cast<int>(std::ceil(fullW * scale)));
+  const int h = std::max(1, static_cast<int>(std::ceil(fullH * scale)));
+
+  // The silhouette goes into an alpha-only mask, which is what gets blurred -
+  // one channel instead of four, and the color is applied afterwards.
+  const auto mask = cairo_image_surface_create(CAIRO_FORMAT_A8, w, h);
+  const auto maskCr = cairo_create(mask);
+
+  cairo_save(maskCr);
+  cairo_set_operator(maskCr, CAIRO_OPERATOR_CLEAR);
+  cairo_paint(maskCr);
+  cairo_restore(maskCr);
+
+  cairo_scale(maskCr, scale, scale);
+  cairo_translate(maskCr, margin, margin);
+
+  // Solid, hole and all: the frame's own cutouts (the side notches, the strip
+  // beside the title bar) are part of the outline, so they cast their shape
+  // for free, but the window's interior must stay filled for now - punching
+  // it before the blur would smear the shadow inward across the window.
+  cairo_set_source_rgba(maskCr, 1, 1, 1, 1);
+  AppendFrameOuterPath(maskCr, geo);
+  cairo_fill(maskCr);
+
+  cairo_surface_flush(mask);
+  BlurA8Surface(mask, std::max(1, static_cast<int>(std::lround(shadowSizePx * scale / kShadowBlurPasses))));
+
+  // Now clear where the window itself is. The cut lands exactly on the ring's
+  // inner boundary, so the frame's own opaque pixels cover it and the hard
+  // edge never shows - while anything that would have fallen on the window's
+  // own content is gone. Offset back out, since the whole texture is drawn
+  // shifted by `offsetPx` and this has to end up over the real window.
+  cairo_save(maskCr);
+  cairo_set_operator(maskCr, CAIRO_OPERATOR_CLEAR);
+  AppendChamferedRect(maskCr,
+    geo.innerX0 - static_cast<float>(offsetPx.x), geo.innerY0 - static_cast<float>(offsetPx.y),
+    geo.innerX1 - static_cast<float>(offsetPx.x), geo.innerY1 - static_cast<float>(offsetPx.y),
+    geo.innerChamfer);
+  cairo_fill(maskCr);
+  cairo_restore(maskCr);
+
+  const auto surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, w, h);
+  const auto cr = cairo_create(surface);
+
+  cairo_save(cr);
+  cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
+  cairo_paint(cr);
+  cairo_restore(cr);
+
+  cairo_set_source_rgba(cr, color.r, color.g, color.b, color.a);
+  cairo_mask_surface(cr, mask, 0, 0);
+  cairo_surface_flush(surface);
+
+  cachedShadowTex = g_pHyprRenderer->createTexture(surface);
+  cachedShadowTexSize = sizePx;
+  cachedShadowExtent = extentPx;
+  cachedShadowChamfer = chamferPx;
+  cachedShadowTitleBarHeight = titleBarHeightPx;
+  cachedShadowTitleBarWidth = titleBarWidthPx;
+  cachedShadowSize = shadowSizePx;
+  cachedShadowColor = color;
+  cachedShadowOffset = offsetPx;
+
+  cairo_destroy(cr);
+  cairo_surface_destroy(surface);
+  cairo_destroy(maskCr);
+  cairo_surface_destroy(mask);
+
+  return cachedShadowTex;
+}
+
 SP<Render::ITexture> ChromeDecoration::GetTitleTexture(const std::string& title, float textSizePx, float alpha, const std::string& fontFamily, int maxWidthPx, bool isActive) {
   if (title.empty())
     return nullptr;

src/ChromeDecoration.hpp

@@ -44,9 +44,25 @@ public:
   // `titleBarWidthPx` (already measured/clamped by the caller - see
   // ChromeDecorationGeometry) hanging off the floating top-border
   // cutout. Filled with `gradient` swept across the whole texture along that
-  // gradient's own axis (a single-stop gradient is just a flat fill). Cached
-  // and only regenerated when any of these change from the last call.
-  SP<Render::ITexture> GetBorderTexture(const Vector2D& sizePx, float extentPx, float chamferPx, const ChromeGradient& gradient, float titleBarHeightPx, float titleBarWidthPx);
+  // gradient's own axis (a single-stop gradient is just a flat fill), plus -
+  // if `glowPx` is non-zero - that same gradient bled `glowPx` inward past
+  // the ring's inner boundary, over the window's own pixels, fading out from
+  // `glowStrength` of its alpha at the window edge. Cached and only
+  // regenerated when any of these change from the last call.
+  SP<Render::ITexture> GetBorderTexture(const Vector2D& sizePx, float extentPx, float chamferPx, const ChromeGradient& gradient, float titleBarHeightPx, float titleBarWidthPx, float glowPx, float glowStrength);
+
+  // Returns a texture of the frame's drop shadow: the same outer silhouette
+  // GetBorderTexture fills, blurred by `shadowSizePx` and tinted `color`,
+  // with the window's own interior cleared back out afterwards so the shadow
+  // never lands on the window's content. The texture covers the frame's box
+  // grown by ShadowMarginPx on every side, and is meant to be drawn at that
+  // box translated by `offsetPx`. Cached like the others; nullptr when the
+  // shadow is off (`shadowSizePx` < 1) or fully transparent.
+  SP<Render::ITexture> GetShadowTexture(const Vector2D& sizePx, float extentPx, float chamferPx, float titleBarHeightPx, float titleBarWidthPx, float shadowSizePx, const CHyprColor& color, const Vector2D& offsetPx);
+
+  // How far past the frame's own box the shadow reaches, on every side, in
+  // whatever units `shadowSizePx`/`offsetPx` are given in.
+  static float ShadowMarginPx(float shadowSizePx, const Vector2D& offsetPx);
 
   // Returns a texture of `title` rendered via Hyprland's own text renderer
   // (Pango, through IHyprRenderer::renderText) at `textSizePx` using
@@ -70,6 +86,18 @@ private:
   ChromeGradient cachedGradient;
   float cachedTitleBarHeight = -1.F;
   float cachedTitleBarWidth = -1.F;
+  float cachedGlowSize = -1.F;
+  float cachedGlowStrength = -1.F;
+
+  SP<Render::ITexture> cachedShadowTex;
+  Vector2D cachedShadowTexSize = {-1, -1};
+  float cachedShadowExtent = -1.F;
+  float cachedShadowChamfer = -1.F;
+  float cachedShadowTitleBarHeight = -1.F;
+  float cachedShadowTitleBarWidth = -1.F;
+  float cachedShadowSize = -1.F;
+  CHyprColor cachedShadowColor;
+  Vector2D cachedShadowOffset = {0, 0};
 
   SP<Render::ITexture> cachedTitleTex;
   std::string cachedTitleTexTitle;
@@ -81,8 +109,15 @@ private:
 
   // The border frame's box in global (monitor-independent) logical
   // coordinates: the window's own box, expanded by `extent` and offset by
-  // the window's workspace/floating animation offsets.
+  // the window's workspace/floating animation offsets. Note this does NOT
+  // include the shadow, which is drawn outside it - see ShadowMarginLogical.
   CBox FullDecorationExtentGlobal();
 
+  // ShadowMarginPx for the configured shadow, in logical px. The shadow is
+  // deliberately not part of the decoration's reserved extents (that would
+  // push neighbouring windows away by the shadow's width); it's simply drawn
+  // past them, so damage and bounding boxes have to account for it by hand.
+  static double ShadowMarginLogical();
+
   friend class ChromePassElement;
 };

src/ChromePassElement.cpp

@@ -44,6 +44,8 @@ std::vector<UP<IPassElement>> ChromePassElement::draw() {
     ? hyprlandBorder
     : (isActive ? PluginState->config.activeColor->value() : PluginState->config.inactiveColor->value()));
   const float borderAlpha = gradient.FirstAlpha();
+  const float glowPx = static_cast<float>(PluginState->config.glowSize->value()) * monitor->m_scale;
+  const float glowStrength = static_cast<float>(PluginState->config.glowStrength->value());
   const float titleBarHeightPx = static_cast<float>(PluginState->config.titlebarHeight->value()) * monitor->m_scale;
   const float textSizePx = static_cast<float>(PluginState->config.titlebarTextSize->value()) * monitor->m_scale;
   const std::string fontFamily = PluginState->config.titlebarFont->value();
@@ -73,16 +75,39 @@ std::vector<UP<IPassElement>> ChromePassElement::draw() {
   // with title length - otherwise every title change would needlessly
   // regenerate an identical border texture.
   const float borderTitleBarWidthPx = geo.fullSpan ? geo.MaxTitleBarWidth() : geo.titleBarWidth;
-  const auto tex = data.decoration->GetBorderTexture({box.w, box.h}, extentPx, chamferPx, gradient, titleBarHeightPx, borderTitleBarWidthPx);
+  const auto tex = data.decoration->GetBorderTexture({box.w, box.h}, extentPx, chamferPx, gradient, titleBarHeightPx, borderTitleBarWidthPx, glowPx, glowStrength);
   if (!tex || !tex->ok())
     return {};
 
+  std::vector<UP<IPassElement>> children;
+
+  // Emitted first so it lands under the frame - which matters, because the
+  // shadow does run under the frame's own outline (only the window's interior
+  // is cleared out of it), and the frame is what hides that cut.
+  const float shadowSizePx = static_cast<float>(PluginState->config.shadowSize->value()) * monitor->m_scale;
+  const auto configOffset = PluginState->config.shadowOffset->value();
+  const Vector2D shadowOffsetPx = {configOffset.x * monitor->m_scale, configOffset.y * monitor->m_scale};
+  const CHyprColor shadowColor{static_cast<uint64_t>(PluginState->config.shadowColor->value())};
+
+  if (const auto shadowTex = data.decoration->GetShadowTexture({box.w, box.h}, extentPx, chamferPx, titleBarHeightPx, borderTitleBarWidthPx, shadowSizePx, shadowColor, shadowOffsetPx);
+      shadowTex && shadowTex->ok()) {
+    const float margin = ChromeDecoration::ShadowMarginPx(shadowSizePx, shadowOffsetPx);
+
+    CTexPassElement::SRenderData shadowData;
+    shadowData.tex = shadowTex;
+    shadowData.box = CBox{
+      box.x - margin + shadowOffsetPx.x, box.y - margin + shadowOffsetPx.y,
+      box.w + 2.0 * margin, box.h + 2.0 * margin,
+    };
+    shadowData.a = data.alpha;
+    children.emplace_back(makeUnique<CTexPassElement>(shadowData));
+  }
+
   CTexPassElement::SRenderData texData;
   texData.tex = tex;
   texData.box = box;
   texData.a = data.alpha;
 
-  std::vector<UP<IPassElement>> children;
   children.emplace_back(makeUnique<CTexPassElement>(texData));
 
   if (titleTex && titleTex->ok() && titleTex->m_size.x > 0 && titleTex->m_size.y > 0) {
@@ -111,5 +136,5 @@ std::optional<CBox> ChromePassElement::boundingBox() {
 
   return data.decoration->FullDecorationExtentGlobal()
     .translate(-monitor->m_position)
-    .expand(4);
+    .expand(4 + ChromeDecoration::ShadowMarginLogical());
 }

src/Common.hpp

@@ -4,18 +4,28 @@
 
 #include <hyprland/src/config/values/types/BoolValue.hpp>
 #include <hyprland/src/config/values/types/ColorValue.hpp>
+#include <hyprland/src/config/values/types/FloatValue.hpp>
 #include <hyprland/src/config/values/types/GradientValue.hpp>
 #include <hyprland/src/config/values/types/IntValue.hpp>
 #include <hyprland/src/config/values/types/StringValue.hpp>
+#include <hyprland/src/config/values/types/Vec2Value.hpp>
 #include <hyprland/src/plugins/PluginAPI.hpp>
 
 using IntValue = Config::Values::CIntValue;
+using FloatValue = Config::Values::CFloatValue;
 using BoolValue = Config::Values::CBoolValue;
 using ColorValue = Config::Values::CColorValue;
 // Accepts the same syntax as Hyprland's own general:col.* values - a single
 // color, or several plus an optional trailing angle ("... 45deg").
 using GradientValue = Config::Values::CGradientValue;
 using StringValue = Config::Values::CStringValue;
+using Vec2Value = Config::Values::CVec2Value;
+
+// The trailing options argument of the *Value constructors (min/max/...).
+// makeShared forwards its arguments through a template parameter, which a
+// bare braced-init-list can't be deduced from - these have to be named.
+using IntValueOptions = Config::Values::SIntValueOptions;
+using FloatValueOptions = Config::Values::SFloatValueOptions;
 
 // Hyprland's raw color ints (and CHyprColor(uint64_t)) are AARRGGBB, but
 // literals are easier to read/write as the more common RRGGBBAA. Convert so

src/GlobalState.hpp

@@ -33,6 +33,29 @@ struct GlobalState {
           "plugin:hyprchrome:inactive_color",
           "Color (or gradient) of the border on unfocused windows, used when follow_hyprland_border_color is false",
           CHyprColor{RGBAToARGB(0x6C6C6CFF)}),
+        .glowSize = makeShared<IntValue>(
+          "plugin:hyprchrome:glow_size",
+          "How far the border's glow bleeds inward over the window, in pixels (0 disables it)",
+          0,
+          IntValueOptions{.min = 0}),
+        .glowStrength = makeShared<FloatValue>(
+          "plugin:hyprchrome:glow_strength",
+          "Peak opacity of the inward glow at the window edge, 0-1",
+          0.35F,
+          FloatValueOptions{.min = 0.F, .max = 1.F}),
+        .shadowSize = makeShared<IntValue>(
+          "plugin:hyprchrome:shadow_size",
+          "How far the frame's drop shadow reaches past its outline, in pixels (0 disables it)",
+          0,
+          IntValueOptions{.min = 0}),
+        .shadowColor = makeShared<ColorValue>(
+          "plugin:hyprchrome:shadow_color",
+          "Color of the frame's drop shadow; its alpha is the shadow's opacity",
+          RGBAToARGB(0x000000B3)),
+        .shadowOffset = makeShared<Vec2Value>(
+          "plugin:hyprchrome:shadow_offset",
+          "How far the shadow is displaced from the frame, in pixels (positive is right/down)",
+          Config::VEC2{0.F, 0.F}),
         .titlebarHeight = makeShared<IntValue>(
           "plugin:hyprchrome:titlebar_height",
           "Height of the title bar hanging off the floating top-border cutout, in pixels",
@@ -52,6 +75,11 @@ struct GlobalState {
     HyprlandAPI::addConfigValueV2(plugin, config.followHyprlandBorderColor);
     HyprlandAPI::addConfigValueV2(plugin, config.activeColor);
     HyprlandAPI::addConfigValueV2(plugin, config.inactiveColor);
+    HyprlandAPI::addConfigValueV2(plugin, config.glowSize);
+    HyprlandAPI::addConfigValueV2(plugin, config.glowStrength);
+    HyprlandAPI::addConfigValueV2(plugin, config.shadowSize);
+    HyprlandAPI::addConfigValueV2(plugin, config.shadowColor);
+    HyprlandAPI::addConfigValueV2(plugin, config.shadowOffset);
     HyprlandAPI::addConfigValueV2(plugin, config.titlebarHeight);
     HyprlandAPI::addConfigValueV2(plugin, config.titlebarTextSize);
     HyprlandAPI::addConfigValueV2(plugin, config.titlebarFont);