124 lines
4.6 KiB
Python
124 lines
4.6 KiB
Python
"""Holographic scanline/sweep/noise overlay — same treatment and tuning as
|
|
astro-menu's lib/hologram.py (itself matching orbit-menu's), reused here so
|
|
horizon-dock reads as one more orbit of the same Cosmonaut Shell suite. No
|
|
radial vignette mask: the dock's own module borders/canvas already bound it,
|
|
so covering the full rectangle reads as one continuous "HUD screen".
|
|
|
|
Owns its own animation clock (advanced by dock.py's tick callback via
|
|
.tick(dt)) and a persistent particle list for the noise specs, exactly like
|
|
astro-menu/orbit-menu's hologram: each spec keeps its position/color for a
|
|
real randomized lifetime (fade in, hold, fade out) instead of every spec
|
|
teleporting to a new position every frame.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import math
|
|
import random
|
|
|
|
import cairo
|
|
import gi
|
|
|
|
gi.require_version("Gtk", "4.0")
|
|
from gi.repository import Gtk # noqa: E402
|
|
|
|
# Same CyberQueer violet/magenta/red combo as orbit-menu's/astro-menu's hologram.
|
|
_VIOLET = (0x50 / 255, 0x18 / 255, 0xDD / 255)
|
|
_MAGENTA = (0.92, 0.0, 0.65)
|
|
_ACCENT = (0xE4 / 255, 0x00 / 255, 0x46 / 255)
|
|
|
|
|
|
class HologramOverlay:
|
|
SCANLINE_GAP = 4.0
|
|
SCANLINE_ALPHA = 0.16 # fixed grid — kept clearly visible, not just a faint texture
|
|
SWEEP_PERIOD = 3.4 # seconds for one top-to-bottom pass
|
|
SWEEP_HALF_HEIGHT = 90.0
|
|
NOISE_COUNT = 95 # specs alive at once (each with its own lifetime)
|
|
NOISE_COLORS = [_MAGENTA, _ACCENT]
|
|
NOISE_LIFETIME = (0.5, 1.4)
|
|
NOISE_FADE_IN = 0.2
|
|
NOISE_FADE_OUT = 0.35
|
|
NOISE_ALPHA_RANGE = (0.10, 0.34)
|
|
|
|
def __init__(self, enabled: bool = True) -> None:
|
|
self.enabled = enabled
|
|
self._sat_time = 0.0
|
|
self._particles: list[dict] = []
|
|
|
|
self.widget = Gtk.DrawingArea()
|
|
self.widget.set_can_target(False) # never steals clicks from content underneath
|
|
self.widget.add_css_class("horizon-hologram")
|
|
self.widget.set_hexpand(True)
|
|
self.widget.set_vexpand(True)
|
|
self.widget.set_halign(Gtk.Align.FILL)
|
|
self.widget.set_valign(Gtk.Align.FILL)
|
|
self.widget.set_draw_func(self._draw_frame)
|
|
|
|
def tick(self, dt: float) -> None:
|
|
if not self.enabled:
|
|
return
|
|
self._sat_time += dt
|
|
self.widget.queue_draw()
|
|
|
|
# -- drawing --------------------------------------------------------------
|
|
def _draw_frame(self, _area, cr, width: float, height: float) -> None:
|
|
if not self.enabled or width <= 0 or height <= 0:
|
|
return
|
|
r, g, b = _VIOLET
|
|
|
|
cr.save()
|
|
cr.set_source_rgba(r, g, b, self.SCANLINE_ALPHA)
|
|
cr.set_line_width(1.0)
|
|
y = 0.0
|
|
while y < height:
|
|
cr.move_to(0, y)
|
|
cr.line_to(width, y)
|
|
y += self.SCANLINE_GAP
|
|
cr.stroke()
|
|
cr.restore()
|
|
|
|
phase = (self._sat_time % self.SWEEP_PERIOD) / self.SWEEP_PERIOD
|
|
sweep_y = phase * height
|
|
hh = self.SWEEP_HALF_HEIGHT
|
|
grad = cairo.LinearGradient(0, sweep_y - hh, 0, sweep_y + hh)
|
|
grad.add_color_stop_rgba(0.0, r, g, b, 0.0)
|
|
grad.add_color_stop_rgba(0.5, r, g, b, 0.07)
|
|
grad.add_color_stop_rgba(1.0, r, g, b, 0.0)
|
|
cr.set_source(grad)
|
|
cr.rectangle(0, sweep_y - hh, width, hh * 2)
|
|
cr.fill()
|
|
|
|
flicker = 0.012 + 0.007 * math.sin(self._sat_time * 11.0)
|
|
cr.set_source_rgba(r, g, b, max(0.0, flicker))
|
|
cr.paint()
|
|
|
|
self._draw_noise(cr, width, height)
|
|
|
|
def _draw_noise(self, cr, width: float, height: float) -> None:
|
|
now = self._sat_time
|
|
self._particles = [p for p in self._particles if now - p["birth"] < p["life"]]
|
|
while len(self._particles) < self.NOISE_COUNT:
|
|
self._particles.append({
|
|
"x": random.uniform(0, width),
|
|
"y": random.uniform(0, height),
|
|
"w": random.uniform(1.0, 2.6),
|
|
"h": random.uniform(1.0, 2.0),
|
|
"color": random.choice(self.NOISE_COLORS),
|
|
"peak_alpha": random.uniform(*self.NOISE_ALPHA_RANGE),
|
|
"birth": now,
|
|
"life": random.uniform(*self.NOISE_LIFETIME),
|
|
})
|
|
|
|
for p in self._particles:
|
|
t = (now - p["birth"]) / p["life"]
|
|
if t < self.NOISE_FADE_IN:
|
|
envelope = t / self.NOISE_FADE_IN
|
|
elif t > 1.0 - self.NOISE_FADE_OUT:
|
|
envelope = max(0.0, (1.0 - t) / self.NOISE_FADE_OUT)
|
|
else:
|
|
envelope = 1.0
|
|
r, g, b = p["color"]
|
|
cr.set_source_rgba(r, g, b, p["peak_alpha"] * envelope)
|
|
cr.rectangle(p["x"], p["y"], p["w"], p["h"])
|
|
cr.fill()
|