//! OG 圖的背景:首頁那顆刻線土星、三條衛星軌道、稀疏的星點,逐格畫成動畫。
//!
//! 土星的畫法是 `src/components/about/colophonSaturn.ts`(此站點遊樂場的平面版)逐行移植,
//! 數字照 `src/lib/saturnSpec.ts`。**兩邊要一起改**,不然分享卡上的土星會跟站上那顆不一樣。
//!
//! 動的只有兩件事:衛星沿軌道繞一圈、少數幾顆星慢慢閃。土星本身不轉——星球一轉每個
//! 像素都變,每一格都得存整張圖,檔案會大十倍。動的東西都排成剛好在 `LOOP_MS` 內
//! 繞完整數圈,所以最後一格接回第一格看不出接縫。
//!
//! 這一張用在首頁與站台預設圖。它比其他頁早寫,畫法是自己逐像素算,沒走 `canvas`:
//! 土星的刷痕本來就是逐像素的著色器(前端也是 `putImageData`)。
#![allow(
clippy::cast_possible_truncation,
clippy::cast_sign_loss,
clippy::cast_precision_loss,
clippy::cast_possible_wrap,
clippy::many_single_char_names,
clippy::suboptimal_flops,
reason = "逐像素的幾何運算:值域都在畫布範圍內(夾過 0–255 或 0–W),單字母變數照抄 TS 原版以便對照"
)]
use std::f32::consts::{PI, TAU};
use tiny_skia::Pixmap;
use super::super::apng::{H, W};
/// 一圈的長度與每格的時間。100ms 一格(10fps):衛星一格移動幾個像素,看起來是連續的,
/// 而格數直接決定檔案大小
const LOOP_MS: u32 = 18_000;
const FRAME_MS: u32 = 100;
const FRAMES: usize = (LOOP_MS / FRAME_MS) as usize;
const GROUND: [f32; 3] = [10.0, 10.0, 12.0];
const INK: [f32; 3] = [241.0, 236.0, 227.0];
const AMBER: [f32; 3] = [233.0, 193.0, 122.0];
// ── saturnSpec.ts ────────────────────────────────────────────────
const TILT: f32 = 0.42;
const ROLL: f32 = -0.2;
const SUN: [f32; 3] = [-0.75, 0.45, 0.5];
/// [緯度°, 寬度°, 亮度增減, 南北對稱]
const SATURN_BANDS: [(f32, f32, f32, bool); 15] = [
(0.0, 9.0, 0.26, false),
(17.0, 4.0, -0.3, true),
(22.5, 2.5, 0.08, true),
(28.0, 2.0, -0.14, true),
(33.0, 2.5, 0.06, true),
(38.0, 1.6, -0.12, true),
(43.0, 2.4, 0.05, true),
(48.0, 1.5, -0.13, true),
(53.0, 2.0, 0.03, true),
(58.0, 1.8, -0.1, true),
(-63.0, 2.5, -0.08, false),
(64.0, 2.0, -0.06, false),
(72.0, 5.0, -0.2, true),
(78.0, 0.9, 0.16, false),
(86.0, 6.0, -0.3, true),
];
const RING_SEGMENTS: [(f32, f32, f32); 9] = [
(1.11, 1.236, 0.08),
(1.239, 1.527, 0.26),
(1.527, 1.64, 0.62),
(1.64, 1.75, 0.88),
(1.75, 1.88, 1.0),
(1.88, 1.951, 0.8),
(1.951, 2.025, 0.1),
(2.025, 2.267, 0.62),
(2.322, 2.33, 0.4),
];
const RING_GAPS: [(f32, f32); 3] = [(2.214, 0.006), (2.265, 0.003), (1.45, 0.006)];
const RING_INNER: f32 = 1.11;
const RING_OUTER: f32 = 2.34;
const PLANET_ROWS: f32 = 22.0;
const RING_ROWS: f32 = 34.0;
const PLANET_COVER: f32 = 0.76;
const RING_COVER: f32 = 0.64;
/// 首頁五條軌道的內三條(外兩條在這個大小下整條都在畫布外)
const ORBITS: [f32; 3] = [2.9, 3.55, 4.25];
const PHASES: [f32; 3] = [0.7, 2.07, 3.44];
// ── 構圖 ─────────────────────────────────────────────────────────
/// 土星在右半邊:左邊 72–712px 是字。環的外緣約 2.4R,所以中心離字要留這麼多
const CX: f32 = 942.0;
const CY: f32 = 292.0;
const R: f32 = 92.0;
/// 琥珀色的是第幾顆(站上的規矩:琥珀只當「一個點」的訊號)
const AMBER_SAT: usize = 0;
/// 會閃的星只在這條線右邊(跟衛星同一塊),見 `Scene::new`
const TWINKLE_FROM_X: f32 = 600.0;
fn smoothstep(e0: f32, e1: f32, x: f32) -> f32 {
let k = ((x - e0) / (e1 - e0)).clamp(0.0, 1.0);
k * k * (3.0 - 2.0 * k)
}
fn hash3(x: i32, y: i32, z: i32) -> f32 {
let mut h = (x as u32)
.wrapping_mul(374_761_393)
.wrapping_add((y as u32).wrapping_mul(668_265_263))
.wrapping_add((z as u32).wrapping_mul(1_274_126_177));
h = (h ^ (h >> 13)).wrapping_mul(1_274_126_177);
((f64::from(h ^ (h >> 16)) / 4_294_967_295.0) * 2.0 - 1.0) as f32
}
fn noise(x: f32, y: f32, z: f32) -> f32 {
let (xi, yi, zi) = (x.floor(), y.floor(), z.floor());
let (fx, fy, fz) = (x - xi, y - yi, z - zi);
let (xi, yi, zi) = (xi as i32, yi as i32, zi as i32);
let u = fx * fx * (3.0 - 2.0 * fx);
let v = fy * fy * (3.0 - 2.0 * fy);
let w = fz * fz * (3.0 - 2.0 * fz);
let lerp = |a: f32, b: f32, k: f32| a + (b - a) * k;
let c = |dx, dy, dz| hash3(xi + dx, yi + dy, zi + dz);
lerp(
lerp(lerp(c(0, 0, 0), c(1, 0, 0), u), lerp(c(0, 1, 0), c(1, 1, 0), u), v),
lerp(lerp(c(0, 0, 1), c(1, 0, 1), u), lerp(c(0, 1, 1), c(1, 1, 1), u), v),
w,
)
}
struct Rot {
cos_r: f32,
sin_r: f32,
cos_t: f32,
sin_t: f32,
sun: [f32; 3],
}
impl Rot {
fn new() -> Self {
let (sin_r, cos_r) = ROLL.sin_cos();
let (sin_t, cos_t) = TILT.sin_cos();
let mut rot = Self { cos_r, sin_r, cos_t, sin_t, sun: [0.0; 3] };
let l = (SUN[0] * SUN[0] + SUN[1] * SUN[1] + SUN[2] * SUN[2]).sqrt();
rot.sun = rot.to_planet(SUN[0] / l, SUN[1] / l, SUN[2] / l);
rot
}
/// 畫面(x 往右、y 往上、z 朝向看的人)→ 星球自己的座標
fn to_planet(&self, x: f32, y: f32, z: f32) -> [f32; 3] {
let x1 = x * self.cos_r + y * self.sin_r;
let y1 = -x * self.sin_r + y * self.cos_r;
[x1, y1 * self.cos_t + z * self.sin_t, -y1 * self.sin_t + z * self.cos_t]
}
/// 環的平面上 (x, z) → 畫面上的 (x, y 往上, 深度)
fn plane_to_view(&self, x: f32, z: f32) -> [f32; 3] {
[
x * self.cos_r + z * self.sin_t * self.sin_r,
x * self.sin_r - z * self.sin_t * self.cos_r,
z * self.cos_t,
]
}
/// 畫面上一點(星球半徑為 1 的單位)落在環平面上的哪裡
fn view_to_plane(&self, x: f32, y: f32) -> (f32, f32) {
(x * self.cos_r + y * self.sin_r, (x * self.sin_r - y * self.cos_r) / self.sin_t)
}
}
fn ring_tone(r: f32) -> f32 {
let mut tone = 0.0;
for (inner, outer, value) in RING_SEGMENTS {
tone +=
smoothstep(inner - 0.004, inner + 0.004, r) * smoothstep(outer + 0.004, outer - 0.004, r) * value;
}
for (at, half) in RING_GAPS {
tone *= smoothstep(half * 0.4, half, (r - at).abs());
}
tone
}
fn strokes(row: f32, ink: f32, cover: f32, fw: f32) -> f32 {
let f = (row - row.floor() - 0.5).abs();
let half = ink * cover / 2.0;
let aa = (fw * 0.75).max(0.001);
smoothstep(half + aa, half - aa, f) * (half / aa).clamp(0.0, 1.0)
}
fn planet_ink(rot: &Rot, n: [f32; 3], fw: f32) -> f32 {
let s = rot.sun;
let lit = smoothstep(-0.12, 0.4, n[0] * s[0] + n[1] * s[1] + n[2] * s[2]);
let lat = n[1].clamp(-1.0, 1.0).asin() * 180.0 / PI;
let mut tone = 0.52;
for (c, w, d, mirror) in SATURN_BANDS {
tone += (-((lat - c) / w).powi(2)).exp() * d * 1.6;
if mirror {
tone += (-((lat + c) / w).powi(2)).exp() * d * 1.6;
}
}
tone *= smoothstep(80.0, 48.0, lat.abs());
let wave = noise(n[0] * 1.1, n[1] * 6.0, n[2] * 1.1);
let row = n[1] * PLANET_ROWS + wave * 0.8;
let swell = noise(n[0] * 2.2, n[1] * 36.0, n[2] * 2.2) * 0.45 + 1.0;
let brush = smoothstep(-0.45, 0.15, noise(n[0] * 2.4, n[1] * 48.0, n[2] * 2.4));
// 環落在星球上的影子
let mut shade = 1.0;
let t = -n[1] / s[1];
if t > 0.0 {
shade = 1.0 - ring_tone((n[0] + s[0] * t).hypot(n[2] + s[2] * t)) * 0.8;
}
let ink = (lit * tone * swell * (0.05 + 0.95 * brush) * shade).clamp(0.0, 1.0).powf(0.8);
strokes(row, ink, PLANET_COVER, fw)
}
fn ring_ink(rot: &Rot, x: f32, z: f32, fw: f32) -> f32 {
let r = x.hypot(z);
if !(RING_INNER - 0.01..=RING_OUTER + 0.01).contains(&r) {
return 0.0;
}
let s = rot.sun;
let ringlets = noise(r * 60.0, 0.0, 0.0) * 0.22 + 0.9;
let brush = smoothstep(-0.55, 0.15, noise(x * 2.4, r * 40.0, z * 2.4));
// 星球投在環上的影子
let along = -(x * s[0] + z * s[2]);
let (cx, cy, cz) = (x + s[0] * along, s[1] * along, z + s[2] * along);
let shade = if along > 0.0 && (cx * cx + cy * cy + cz * cz).sqrt() < 1.0 { 0.12 } else { 1.0 };
let ink = (ring_tone(r) * ringlets * (0.4 + 0.6 * brush) * shade).clamp(0.0, 1.0);
strokes(r * RING_ROWS, ink.powf(0.75), RING_COVER, fw)
}
/// 土星那一塊(含環):預乘過的 RGBA,左上角在 (x0, y0)
struct SaturnLayer {
x0: usize,
y0: usize,
w: usize,
h: usize,
/// 每個像素 [r·a, g·a, b·a, a]
px: Vec<[f32; 4]>,
}
fn render_saturn(rot: &Rot) -> SaturnLayer {
let reach = ((RING_OUTER + 0.05) * R).ceil();
let x0 = (CX - reach).floor().max(0.0) as usize;
let y0 = (CY - reach).floor().max(0.0) as usize;
let x1 = ((CX + reach).ceil() as usize).min(W);
let y1 = ((CY + reach).ceil() as usize).min(H);
let (w, h) = (x1 - x0, y1 - y0);
let mut px = vec![[0.0f32; 4]; w * h];
let sphere = |x: f32, y: f32| (1.0 - x * x - y * y).max(0.0).sqrt();
for py in y0..y1 {
for qx in x0..x1 {
let x = (qx as f32 + 0.5 - CX) / R;
let y = -(py as f32 + 0.5 - CY) / R;
let d = x.hypot(y);
let (mut base_a, mut base) = (0.0, 0.0);
if d < 1.0 + 1.0 / R {
base_a = ((1.0 - d) * R + 0.5).clamp(0.0, 1.0);
let dd = d.min(0.9999);
let k = if d > 0.0 { dd / d } else { 1.0 };
let n = rot.to_planet(x * k, y * k, (1.0 - dd * dd).sqrt());
let nx = rot.to_planet((x + 1.0 / R) * k, y * k, sphere(x + 1.0 / R, y));
let ny = rot.to_planet(x * k, (y - 1.0 / R) * k, sphere(x, y - 1.0 / R));
let fw = PLANET_ROWS * ((nx[1] - n[1]).abs() + (ny[1] - n[1]).abs());
base = planet_ink(rot, n, fw);
}
let mut ring_a = 0.0;
let (rx, rz) = rot.view_to_plane(x, y);
if !(d < 1.0 && rz * rot.cos_t < 0.0) {
let r0 = rx.hypot(rz);
let r1 = (rx + rot.cos_r / R).hypot(rz + rot.sin_r / R / rot.sin_t);
let r2 = (rx - rot.sin_r / R).hypot(rz + rot.cos_r / R / rot.sin_t);
ring_a = ring_ink(rot, rx, rz, RING_ROWS * ((r1 - r0).abs() + (r2 - r0).abs()));
}
let a = ring_a + base_a * (1.0 - ring_a);
if a <= 0.0 {
continue;
}
let mut out = [0.0f32; 4];
for ch in 0..3 {
let planet_c = GROUND[ch] + (INK[ch] - GROUND[ch]) * base;
out[ch] = INK[ch] * ring_a + planet_c * base_a * (1.0 - ring_a);
}
out[3] = a;
px[(py - y0) * w + (qx - x0)] = out;
}
}
SaturnLayer { x0, y0, w, h, px }
}
/// mulberry32:跟設計稿同一個產生器,同樣的種子撒出同樣的星。
/// 航行日誌那張的背景星空也用它(同一組種子,見 `log.rs`)
pub(super) fn rng(seed: u32) -> impl FnMut() -> f32 {
let mut a = seed;
move || {
a = a.wrapping_add(0x6d2b_79f5);
let mut t = a;
t = (t ^ (t >> 15)).wrapping_mul(t | 1);
t ^= t.wrapping_add((t ^ (t >> 7)).wrapping_mul(t | 0x3d));
(f64::from(t ^ (t >> 14)) / 4_294_967_296.0) as f32
}
}
struct Star {
x: f32,
y: f32,
r: f32,
a: f32,
/// 會閃的星:一圈裡閃幾次(整數,接縫才對得上)與起始相位;0 表示不閃
laps: f32,
phase: f32,
}
/// 整張圖不變的部分先畫好,之後每一格從這裡複製
pub struct Saturn {
rot: Rot,
/// 底色+不閃的星+軌道(RGB)
back: Vec<[f32; 3]>,
twinkle: Vec<Star>,
planet: SaturnLayer,
}
/// 反鋸齒的實心圓,`alpha` 是最濃處的不透明度(source-over)
fn disc(buf: &mut [[f32; 3]], x: f32, y: f32, r: f32, color: [f32; 3], alpha: f32) {
let reach = r + 1.0;
let (xa, xb) = ((x - reach).floor().max(0.0) as usize, ((x + reach).ceil() as usize).min(W));
let (ya, yb) = ((y - reach).floor().max(0.0) as usize, ((y + reach).ceil() as usize).min(H));
for py in ya..yb {
for qx in xa..xb {
let d = (qx as f32 + 0.5 - x).hypot(py as f32 + 0.5 - y);
// 半徑不到一像素的小星:面積換成濃度,不然它們會一樣大、只差在閃不閃
let cover =
if r < 0.5 { (0.5 + r - d).clamp(0.0, 1.0) * r * 2.0 } else { (r + 0.5 - d).clamp(0.0, 1.0) };
let k = cover * alpha;
if k > 0.0 {
let p = &mut buf[py * W + qx];
for ch in 0..3 {
p[ch] += (color[ch] - p[ch]) * k;
}
}
}
}
}
/// 一圈淡淡的光暈:中心 `alpha`、到 `r` 線性淡到 0
fn glow(buf: &mut [[f32; 3]], x: f32, y: f32, r: f32, color: [f32; 3], alpha: f32) {
let (xa, xb) = ((x - r).floor().max(0.0) as usize, ((x + r).ceil() as usize).min(W));
let (ya, yb) = ((y - r).floor().max(0.0) as usize, ((y + r).ceil() as usize).min(H));
for py in ya..yb {
for qx in xa..xb {
let d = (qx as f32 + 0.5 - x).hypot(py as f32 + 0.5 - y);
let k = (1.0 - d / r).max(0.0) * alpha;
if k > 0.0 {
let p = &mut buf[py * W + qx];
for ch in 0..3 {
p[ch] += (color[ch] - p[ch]) * k;
}
}
}
}
}
impl Default for Saturn {
fn default() -> Self {
Self::new()
}
}
impl Saturn {
pub fn new() -> Self {
let rot = Rot::new();
let mut back = vec![GROUND; W * H];
// 星:多數很淡很小,少數亮一點。分布避開土星中心那一塊(反正會被星球蓋住)
let mut rand = rng(23);
let mut twinkle = Vec::new();
for i in 0..240 {
let m = rand().powi(4);
let star = Star {
x: rand() * W as f32,
y: rand() * H as f32,
r: 0.35 + m * 0.9,
a: 0.18 + m * 0.6,
laps: 0.0,
phase: rand() * TAU,
};
// 右半邊每四顆有一顆會閃,一圈閃一到三次。只挑右半邊,是因為一格的大小取的是
// 「所有變動像素的外框」:左邊也有星在閃的話每一格都是整張圖寬,檔案大一倍
// (外框裡沒變的像素雖然是透明的,整張 3 MB 的零壓完也還有 3 KB)
if i % 4 == 0 && star.x > TWINKLE_FROM_X {
twinkle.push(Star { laps: 1.0 + (i / 6 % 3) as f32, ..star });
} else {
disc(&mut back, star.x, star.y, star.r, INK, star.a);
}
}
// 軌道:環平面上半徑 r 的圓。每個像素算它落在環平面的哪個半徑、離軌道幾個像素
for py in 0..H {
for qx in 0..W {
let x = (qx as f32 + 0.5 - CX) / R;
let y = -(py as f32 + 0.5 - CY) / R;
let (rx, rz) = rot.view_to_plane(x, y);
let r0 = rx.hypot(rz);
// 往右、往下各一個像素時半徑變多少:線寬固定一像素
let (ax, az) = rot.view_to_plane(x + 1.0 / R, y);
let (bx, bz) = rot.view_to_plane(x, y - 1.0 / R);
let grad = (ax.hypot(az) - r0).hypot(bx.hypot(bz) - r0).max(1e-6);
for (i, orbit) in ORBITS.iter().enumerate() {
let cover = (1.0 - (r0 - orbit).abs() / grad).clamp(0.0, 1.0);
if cover > 0.0 {
let alpha = if i == AMBER_SAT { 0.24 } else { 0.13 };
let p = &mut back[py * W + qx];
for ch in 0..3 {
p[ch] += (INK[ch] - p[ch]) * cover * alpha;
}
}
}
}
}
let planet = render_saturn(&rot);
Self { rot, back, twinkle, planet }
}
fn frame_rgb(&self, index: usize) -> Vec<[f32; 3]> {
let t = index as f32 / FRAMES as f32; // 一圈裡的進度 0–1
let mut buf = self.back.clone();
for s in &self.twinkle {
// 亮度只分五階:連續變化的話這些星每一格都在變,每格都得存它們;分階之後
// 大部分的格子裡它們不動,眼睛看起來一樣是在慢慢閃
let k = 0.55 + 0.45 * ((s.laps * TAU * t + s.phase).sin() * 2.0).round() / 2.0;
disc(&mut buf, s.x, s.y, s.r, INK, s.a * k);
}
// 衛星:一圈剛好繞軌道一圈。在星球後面的先畫(被星球蓋住),前面的後畫
let sats: Vec<(usize, [f32; 3])> = ORBITS
.iter()
.enumerate()
.map(|(i, r)| {
let a = PHASES[i] + TAU * t;
(i, self.rot.plane_to_view(a.cos() * r, a.sin() * r))
})
.collect();
let draw_sat = |buf: &mut [[f32; 3]], i: usize, v: [f32; 3]| {
let (x, y) = (CX + v[0] * R, CY - v[1] * R);
if i == AMBER_SAT {
glow(buf, x, y, 13.0, AMBER, 0.5);
disc(buf, x, y, 3.2, AMBER, 1.0);
} else {
disc(buf, x, y, 2.3, INK, 0.8);
}
};
for &(i, v) in &sats {
if v[2] < 0.0 {
draw_sat(&mut buf, i, v);
}
}
let sl = &self.planet;
for row in 0..sl.h {
for col in 0..sl.w {
let s = sl.px[row * sl.w + col];
if s[3] > 0.0 {
let p = &mut buf[(sl.y0 + row) * W + sl.x0 + col];
for ch in 0..3 {
p[ch] = s[ch] + p[ch] * (1.0 - s[3]);
}
}
}
}
for &(i, v) in &sats {
if v[2] >= 0.0 {
draw_sat(&mut buf, i, v);
}
}
buf
}
}
impl super::Scene for Saturn {
fn frames(&self) -> usize {
FRAMES
}
fn frame_ms(&self) -> u32 {
FRAME_MS
}
fn frame(&self, index: usize) -> Pixmap {
let rgb = self.frame_rgb(index);
let mut data = Vec::with_capacity(W * H * 4);
for p in rgb {
data.extend(p.map(|c| c.round().clamp(0.0, 255.0) as u8));
data.push(255);
}
Pixmap::from_vec(data, tiny_skia::IntSize::from_wh(W as u32, H as u32).expect("常數尺寸"))
.expect("長度剛好是 W×H×4")
}
}