ClassyGitshadowzzh

setup.rs

setup.rs
//! 設備頁的工程概念設計圖(`src/components/about/Setup.tsx`、`setupDraw.ts`、`setupSheets.ts` 逐行移植):
//! 第一張圖紙 THE WHITE BUILD——爆炸軸測的線稿當底稿,點格、對位記號、編號圈、引線、尺寸線由程式疊上去;
//! 滑過一個零件時底稿退暗,那個零件染成琥珀色、引線換成琥珀色。
//!
//! 只畫線與圈:零件表、標題欄、尺寸線上的數字、編號圈裡的編號都是字,一律不畫
//! (站長不想讓型號、品牌之類的東西出現在分享圖上;這裡的零件 id 只是對照前端用的註解)。
//!
//! 構圖:前端的圖紙是 1200×900,底稿佔左邊 66%;分享圖矮、左邊是字,所以底稿縮到 520px 寬、
//! 靠右擺(x 662 起,見 `ART_W`),零件表的位置空著。最左邊那片側板落在字的漸層邊緣,淡一點。
//!
//! 動態:一直有一個零件是「滑過」的狀態(所以底稿一直是退暗的 0.45,不會整片忽明忽暗——
//! 那會讓每一格都等於整張圖)。輪流換到下一個零件時,它的引線照「設計圖描出來」那段的長法
//! 從編號圈長到零件上,前緣是配線圖上跑的那種琥珀色訊號點(`pulse`);長到了,零件才亮起來。
//! 三個零件輪一圈剛好回到第一格。
#![allow(
    clippy::cast_precision_loss,
    clippy::cast_possible_truncation,
    clippy::cast_sign_loss,
    reason = "格數與零件數都很小;座標是畫布範圍內的浮點數,縮圖的尺寸是正的"
)]

use std::f32::consts::{PI, TAU};

use tiny_skia::Pixmap;

use super::super::apng::{H, W};
use super::super::canvas::{AMBER, Ctx, GROUND, Gradient, Rgba, amber, ink, load_image, resize_image};

/// 一圈 15 秒:三個零件各 5 秒
const FRAMES: usize = 150;
const FRAME_MS: u32 = 100;
/// 一個零件亮著的那一段有幾格:前 `SWITCH` 格亮著,接著換到下一個、引線花 `TRACE` 格長過去
const SEGMENT: usize = FRAMES / LIT.len();
const SWITCH: usize = 35;
/// 前端的引線在描出來的進度 0.3–0.7 之間長完(`DRAWING_MS` 1600ms 的 40%,約 0.64 秒)
const TRACE: usize = 7;

/// 點格的間距(`setupDraw.ts` 的 `GRID`)
const GRID: f32 = 24.0;
/// 編號圈的半徑(`Setup.tsx` 的 `BALLOON_R`,跟 `.su-balloon` 的 22px 一樣)
const BALLOON_R: f32 = 11.0;
/// 底稿在分享圖上的位置與寬(高照底稿的比例,約 434)。前端是圖紙寬的 2%/7%/66%(1200 寬時 792px),
/// 這裡縮到 520px、靠右:左下角那顆顯示卡的編號圈(底稿的 9%)要落在字欄(到 692px)的右邊,
/// 不然英文副標換行時會壓在它上面;右邊電源的編號圈(97%)又得留在畫面裡,寬度就只剩這麼多
const ART_X: f32 = 662.0;
const ART_Y: f32 = 96.0;
const ART_W: u32 = 520;

/// 底稿上的一個零件(`setupSheets.ts` 的 `Callout`):範圍(百分比的多邊形,同 `pct(...)`)、
/// 引線落在哪(`at`)、編號圈擺在哪(`balloon`),都是底稿寬高的百分比
struct Part {
    poly: &'static [&'static [f32]],
    at: [f32; 2],
    balloon: [f32; 2],
}

/// `WHITE_BUILD.parts`,順序照前端(編號圈的 1–9)
const PARTS: [Part; 9] = [
    // rtx-4070ti-super
    Part {
        poly: &[&[18.0, 69.0, 22.5, 66.0, 44.5, 77.0, 44.5, 91.0, 43.0, 92.5, 21.0, 84.5, 18.0, 80.0]],
        at: [31.0, 80.0],
        balloon: [9.0, 90.0],
    },
    // ryzen-9900x
    Part {
        poly: &[&[47.0, 44.6, 50.3, 42.6, 53.6, 44.6, 50.3, 46.8]],
        at: [50.3, 44.7],
        balloon: [59.0, 36.0],
    },
    // eskimo-360
    Part {
        poly: &[
            &[36.5, 6.5, 44.5, 1.5, 70.0, 17.5, 69.5, 23.0, 60.5, 26.5, 36.5, 10.5],
            &[36.5, 10.0, 41.0, 11.0, 46.5, 33.0, 53.5, 33.5, 53.5, 41.5, 46.0, 41.5, 44.5, 35.0, 36.5, 16.0],
        ],
        at: [53.0, 13.0],
        balloon: [78.0, 7.0],
    },
    // xpg-lancer
    Part {
        poly: &[&[53.5, 44.5, 56.5, 42.0, 65.5, 47.5, 65.5, 53.0, 62.0, 54.5, 53.5, 48.0]],
        at: [60.0, 48.0],
        balloon: [81.0, 35.0],
    },
    // b650-a
    Part {
        poly: &[&[31.0, 60.5, 39.0, 50.5, 49.5, 47.0, 60.0, 54.0, 57.0, 60.0, 45.0, 71.5, 31.0, 61.5]],
        at: [37.0, 60.0],
        balloon: [27.0, 50.0],
    },
    // crucial-t500
    Part {
        poly: &[&[48.5, 73.0, 50.0, 72.0, 57.5, 76.5, 56.0, 78.5]],
        at: [53.0, 75.2],
        balloon: [63.0, 70.0],
    },
    // kioxia-exceria
    Part {
        poly: &[&[45.0, 77.0, 46.5, 76.0, 54.0, 80.5, 52.5, 82.5]],
        at: [49.5, 79.3],
        balloon: [52.0, 90.0],
    },
    // leadex-vii
    Part {
        poly: &[&[
            73.5, 70.0, 84.0, 70.0, 87.5, 69.5, 95.0, 74.0, 95.0, 90.0, 86.0, 95.0, 79.0, 90.5, 79.0, 76.0,
        ]],
        at: [87.0, 82.0],
        balloon: [97.0, 63.0],
    },
    // model-5
    Part {
        poly: &[
            &[1.5, 27.0, 23.5, 11.5, 24.5, 13.0, 24.5, 47.0, 13.0, 55.0, 13.0, 73.5, 1.5, 66.0],
            &[28.5, 33.0, 46.5, 20.0, 78.0, 40.5, 77.5, 86.0, 59.5, 98.5, 55.0, 98.0, 28.5, 82.0],
        ],
        at: [72.0, 62.0],
        balloon: [67.0, 99.0],
    },
];

/// 輪流亮的三個零件(`PARTS` 的索引):顯示卡、水冷排、電源——三個都大、都在畫面右半邊,
/// 一個在下、一個在上、一個在右,亮起來時整張圖的三個角落都輪得到
const LIT: [usize; 3] = [0, 2, 7];

/// `WHITE_BUILD.dims`(水冷排那條 360 的尺寸線;數字不畫):[a, b, off],底稿的百分比
const DIM: [[f32; 2]; 3] = [[44.0, 1.5], [69.8, 17.5], [2.2, -3.4]];

/// 底稿在畫布上的範圍
#[derive(Clone, Copy)]
struct Art {
    x: f32,
    y: f32,
    w: f32,
    h: f32,
}

impl Art {
    /// 底稿上的百分比座標 → 畫布座標(前端的 `at`)
    fn at(self, p: [f32; 2]) -> (f32, f32) {
        (self.x + p[0] / 100.0 * self.w, self.y + p[1] / 100.0 * self.h)
    }

    /// 一個零件的引線:從編號圈的邊緣到零件上的那一點(太短的不畫,同前端)
    fn leader(self, part: &Part) -> Option<((f32, f32), (f32, f32))> {
        let (bx, by) = self.at(part.balloon);
        let (cx, cy) = self.at(part.at);
        let len = (cx - bx).hypot(cy - by);
        if len <= BALLOON_R {
            return None;
        }
        let (ux, uy) = ((cx - bx) / len, (cy - by) / len);
        Some(((bx + ux * BALLOON_R, by + uy * BALLOON_R), (cx, cy)))
    }
}

/// 圖紙底下的點格與左上、右上、左下三個角的對位記號(`drawGrid`,鋪完的那一刻:reveal = 1)
fn draw_grid(ctx: &mut Ctx, w: f32, h: f32) {
    let reach = w.hypot(h) * 1.05;
    let mut y = GRID / 2.0;
    while y < h {
        let mut x = GRID / 2.0;
        while x < w {
            let d = x.hypot(y);
            // 剛鋪到的那一圈亮一點,像墨剛印上去(鋪完時只剩離左上角最遠的那個角)
            let fresh = (1.0 - (reach - d) / 120.0).max(0.0);
            ctx.set_fill(if fresh > 0.0 { amber(0.15 + 0.5 * fresh) } else { ink(0.13) });
            ctx.fill_rect(x, y, 1.0, 1.0);
            x += GRID;
        }
        y += GRID;
    }
    ctx.set_stroke(ink(0.35));
    ctx.set_line_width(1.0);
    for (x, y, dx, dy) in [(0.5, 0.5, 1.0, 1.0), (w - 0.5, 0.5, -1.0, 1.0), (0.5, h - 0.5, 1.0, -1.0)] {
        ctx.begin_path();
        ctx.move_to(x + dx * 18.0, y);
        ctx.line_to(x, y);
        ctx.line_to(x, y + dy * 18.0);
        ctx.stroke();
    }
}

/// 一圈很淡的琥珀色光:亮起來的那一塊底下墊著(`halo`)
fn halo(ctx: &mut Ctx, x: f32, y: f32, r: f32) {
    ctx.set_fill(Gradient::radial(x, y, 0.0, x, y, r).stop(0.0, amber(0.22)).stop(1.0, amber(0.0)));
    ctx.fill_rect(x - r, y - r, r * 2.0, r * 2.0);
}

/// 尺寸線兩端的箭頭(實心小三角,尖端在 (x, y),朝 ang 的方向)
fn arrow(ctx: &mut Ctx, x: f32, y: f32, ang: f32) {
    let s = 6.0;
    ctx.begin_path();
    ctx.move_to(x, y);
    ctx.line_to(x - s * (ang - 0.3).cos(), y - s * (ang - 0.3).sin());
    ctx.line_to(x - s * (ang + 0.3).cos(), y - s * (ang + 0.3).sin());
    ctx.close_path();
    ctx.fill();
}

/// 一道訊號:一個亮點拖一小段尾巴(`pulse`,上行的琥珀色那種)。`at` 把 0–1 的進度換成座標
fn pulse(ctx: &mut Ctx, at: impl Fn(f32) -> (f32, f32), p: f32) {
    for k in (0..=4).rev() {
        let q = p - k as f32 * 0.012;
        if !(0.0..=1.0).contains(&q) {
            continue;
        }
        let (x, y) = at(q);
        let a = if k == 0 { 0.95 } else { 0.35 * (1.0 - k as f32 / 5.0) };
        ctx.dot(x, y, if k == 0 { 2.2 } else { 1.4 }, amber(a));
    }
}

/// 底稿染成琥珀色的一份(`tintOf`:畫上底稿、`source-in` 填琥珀色 → 線的形狀、琥珀的顏色)
fn tint_of(art: &Pixmap) -> Pixmap {
    let mut out = art.clone();
    for px in out.data_mut().as_chunks_mut::<4>().0 {
        let a = u16::from(px[3]);
        for (c, v) in px[..3].iter_mut().zip(AMBER) {
            *c = ((u16::from(v) * a + 127) / 255) as u8;
        }
    }
    out
}

pub struct Setup {
    art: Art,
    /// 點格、對位記號、退暗的底稿:每一格都一樣的部分
    back: Pixmap,
    /// `LIT` 每個零件亮起來時疊上去的那一層:底下那圈光、範圍裡染成琥珀色的底稿(帶光暈)
    lit: Vec<Pixmap>,
}

impl Setup {
    pub fn new() -> Self {
        let src =
            load_image(include_bytes!("../../../../../public/illustrations/setup/sheet-white-build.webp"));
        let art_h = (ART_W as f32 * src.height() as f32 / src.width() as f32).round();
        // 前端的底稿是 <img> 縮到圖紙上,瀏覽器縮小時會好好重新取樣;這裡先縮好再原尺寸貼
        let img = resize_image(&src, ART_W, art_h as u32);
        let art = Art { x: ART_X, y: ART_Y, w: ART_W as f32, h: art_h };

        let mut ctx = Ctx::new(W as u32, H as u32);
        ctx.clear(GROUND);
        draw_grid(&mut ctx, W as f32, H as f32);
        // 滑過零件時底稿退暗(`.su-sheet.has-on .su-art { opacity: 0.45 }`)
        ctx.set_alpha(0.45);
        ctx.draw_image(&img, art.x, art.y);

        let tint = tint_of(&img);
        let lit = LIT
            .iter()
            .map(|&i| {
                let part = &PARTS[i];
                let mut ctx = Ctx::new(W as u32, H as u32);
                let (cx, cy) = art.at(part.at);
                halo(&mut ctx, cx, cy, art.w * 0.12);
                // 範圍裡疊上琥珀色的底稿,帶一圈光(shadowBlur 8)
                ctx.save();
                ctx.begin_path();
                for poly in part.poly {
                    for (k, &uv) in poly.as_chunks::<2>().0.iter().enumerate() {
                        let (x, y) = art.at(uv);
                        if k == 0 { ctx.move_to(x, y) } else { ctx.line_to(x, y) }
                    }
                    ctx.close_path();
                }
                ctx.clip();
                ctx.set_shadow(amber(0.9), 8.0);
                ctx.draw_image(&tint, art.x, art.y);
                ctx.restore();
                ctx.pixmap
            })
            .collect();
        Self { art, back: ctx.pixmap, lit }
    }

    /// 尺寸線(`drawDrawing` 的後半,拉滿的那一刻:pull = 1;數字與它底下那塊底色不畫)
    fn draw_dim(&self, ctx: &mut Ctx) {
        let [a, b, off] = DIM;
        let (ax, ay) = self.art.at(a);
        let (bx, by) = self.art.at(b);
        let (ox, oy) = (off[0] / 100.0 * self.art.w, off[1] / 100.0 * self.art.h);
        let (a2x, a2y, b2x, b2y) = (ax + ox, ay + oy, bx + ox, by + oy);
        ctx.set_stroke(ink(0.55));
        ctx.set_fill(ink(0.75));
        ctx.set_line_width(1.0);
        // 延伸線:從量的那兩點往外拉,超過尺寸線一點點
        let ext = 1.0 + 6.0 / ox.hypot(oy).max(1.0);
        ctx.set_line_dash(&[]);
        ctx.begin_path();
        ctx.move_to(ax + ox * 0.15, ay + oy * 0.15);
        ctx.line_to(ax + ox * ext, ay + oy * ext);
        ctx.move_to(bx + ox * 0.15, by + oy * 0.15);
        ctx.line_to(bx + ox * ext, by + oy * ext);
        ctx.stroke();
        let ang = (b2y - a2y).atan2(b2x - a2x);
        ctx.begin_path();
        ctx.move_to(a2x, a2y);
        ctx.line_to(b2x, b2y);
        ctx.stroke();
        arrow(ctx, a2x, a2y, ang + PI);
        arrow(ctx, b2x, b2y, ang);
    }
}

impl super::Scene for Setup {
    fn frames(&self) -> usize {
        FRAMES
    }
    fn frame_ms(&self) -> u32 {
        FRAME_MS
    }
    fn frame(&self, index: usize) -> Pixmap {
        // 這一格滑過的是哪一個零件(`on`),它的引線描到哪裡(`grow`,1 是描完、零件亮著)
        let seg = (index / SEGMENT) % LIT.len();
        let f = index % SEGMENT;
        let (slot, grow) = if f < SWITCH {
            (seg, 1.0)
        } else {
            ((seg + 1) % LIT.len(), ((f - SWITCH + 1) as f32 / TRACE as f32).min(1.0))
        };
        let on = LIT[slot];

        let mut ctx = Ctx::new(W as u32, H as u32);
        ctx.draw_image(&self.back, 0.0, 0.0);
        if grow >= 1.0 {
            ctx.draw_image(&self.lit[slot], 0.0, 0.0);
        }

        // 引線:從編號圈的邊緣拉到零件上的一個點;亮著的那個是琥珀色
        ctx.set_line_width(1.0);
        for (i, part) in PARTS.iter().enumerate() {
            let Some(((sx, sy), (cx, cy))) = self.art.leader(part) else { continue };
            let lit = i == on && grow >= 1.0;
            let color = if lit { amber(0.95) } else { ink(0.4) };
            ctx.set_stroke(color);
            ctx.begin_path();
            ctx.move_to(sx, sy);
            ctx.line_to(cx, cy);
            ctx.stroke();
            ctx.dot(cx, cy, if lit { 3.0 } else { 2.0 }, color);
            if i == on && grow < 1.0 {
                // 換到這個零件:引線照描出來的那段從編號圈長出去,前緣是一顆琥珀色的訊號點
                let along = |p: f32| (sx + (cx - sx) * p, sy + (cy - sy) * p);
                let (ex, ey) = along(grow);
                ctx.set_stroke(amber(0.95));
                ctx.begin_path();
                ctx.move_to(sx, sy);
                ctx.line_to(ex, ey);
                ctx.stroke();
                pulse(&mut ctx, along, grow);
            }
        }

        self.draw_dim(&mut ctx);

        // 編號圈(DOM 疊在畫布上面):墊一層紙色、細框;滑過的那個整顆填成琥珀色。編號是字,不畫
        for (i, part) in PARTS.iter().enumerate() {
            let (bx, by) = self.art.at(part.balloon);
            let hit = i == on;
            ctx.dot(bx, by, BALLOON_R, if hit { amber(1.0) } else { Rgba(GROUND, 1.0) });
            ctx.set_stroke(if hit { amber(1.0) } else { ink(0.7) });
            ctx.begin_path();
            ctx.arc(bx, by, BALLOON_R - 0.5, 0.0, TAU, false);
            ctx.stroke();
        }
        ctx.pixmap
    }
}