election-game/web/src/game/art/avatar/pixel.tsx

234 lines
8.2 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import { useEffect, useReducer, useRef, type ReactNode } from "react";
/**
* 復刻像素風(72×90、16 色的老派電腦遊戲頭像):把畫好的頭像縮成小點陣、
* 套 16 色(從這張頭像自己的顏色挑)、外圍描一圈深色邊,再用方塊放大畫回來(每種顏色一條 path,任何大小都銳利)。
* 同一個頭像只算一次(快取);瀏覽器不讓讀畫布時退回一般畫法。
*/
export const GRID_W = 64;
export const GRID_H = 70;
const COLORS = 16;
const OUTLINE = "#1f1a24";
const MAX_CACHE = 400;
export interface PixelArt {
layers: { fill: string; d: string }[];
}
const cache = new Map<string, PixelArt | "fail">();
const pending = new Map<string, Promise<void>>();
function remember(key: string, v: PixelArt | "fail") {
cache.set(key, v);
if (cache.size > MAX_CACHE) cache.delete(cache.keys().next().value!);
}
function loadImage(url: string): Promise<HTMLImageElement> {
return new Promise((resolve, reject) => {
const img = new Image();
img.onload = () => resolve(img);
img.onerror = () => reject(new Error("頭像轉圖失敗"));
img.src = url;
});
}
const hex = (r: number, g: number, b: number) => `#${[r, g, b].map((v) => Math.round(v).toString(16).padStart(2, "0")).join("")}`;
/** 每個像素格先用 4×4 的小點取樣(挑格子裡的顏色,不是平均:細細的眼睛、嘴巴才不會被糊掉) */
const SUB = 4;
/** 把一張頭像(SVG 字串)變成像素圖 */
export async function pixelate(inner: string): Promise<PixelArt> {
const [w, h] = [GRID_W * SUB, GRID_H * SUB];
const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 200 220" width="${w}" height="${h}" preserveAspectRatio="none">${inner}</svg>`;
const url = URL.createObjectURL(new Blob([svg], { type: "image/svg+xml" }));
try {
const img = await loadImage(url);
const canvas = document.createElement("canvas");
canvas.width = w;
canvas.height = h;
const g = canvas.getContext("2d", { willReadFrequently: true });
if (!g) throw new Error("沒有畫布");
g.drawImage(img, 0, 0, w, h);
return quantize(sampleBlocks(g.getImageData(0, 0, w, h).data, GRID_W, GRID_H), GRID_W, GRID_H);
} finally {
URL.revokeObjectURL(url);
}
}
const luma = (r: number, g: number, b: number) => 0.3 * r + 0.59 * g + 0.11 * b;
/**
* 4×4 取一格:蓋到的不到 6 點就是透明;否則取最多的顏色,但格子裡有夠多(3 點以上)明顯更深的顏色時取深色
* (像素畫家會優先保留輪廓、眼睛、嘴巴)。
*/
export function sampleBlocks(src: Uint8ClampedArray, gw: number, gh: number): Uint8ClampedArray {
const sw = gw * SUB;
const out = new Uint8ClampedArray(gw * gh * 4);
for (let gy = 0; gy < gh; gy++) {
for (let gx = 0; gx < gw; gx++) {
const groups = new Map<number, { n: number; r: number; g: number; b: number }>();
let solid = 0;
for (let y = 0; y < SUB; y++) {
for (let x = 0; x < SUB; x++) {
const i = ((gy * SUB + y) * sw + gx * SUB + x) * 4;
if (src[i + 3]! < 128) continue;
solid += 1;
const [r, g, b] = [src[i]!, src[i + 1]!, src[i + 2]!];
const k = ((r >> 3) << 10) | ((g >> 3) << 5) | (b >> 3);
const e = groups.get(k) ?? { n: 0, r: 0, g: 0, b: 0 };
e.n += 1;
e.r += r;
e.g += g;
e.b += b;
groups.set(k, e);
}
}
const o = (gy * gw + gx) * 4;
if (solid < 6) continue;
const list = [...groups.values()].map((e) => ({ n: e.n, r: e.r / e.n, g: e.g / e.n, b: e.b / e.n }));
let pick = list.reduce((a, b) => (b.n > a.n ? b : a));
const dark = list.filter((e) => e.n >= 3 && luma(e.r, e.g, e.b) < luma(pick.r, pick.g, pick.b) - 50).sort((a, b) => luma(a.r, a.g, a.b) - luma(b.r, b.g, b.b))[0];
if (dark) pick = dark;
out[o] = pick.r;
out[o + 1] = pick.g;
out[o + 2] = pick.b;
out[o + 3] = 255;
}
}
return out;
}
/** 16 色量化(k-means)+外圍描邊+每種顏色一條 path */
export function quantize(data: Uint8ClampedArray, w: number, h: number): PixelArt {
const n = w * h;
const solid = new Uint8Array(n);
const px: number[] = [];
for (let i = 0; i < n; i++) {
if (data[i * 4 + 3]! >= 110) {
solid[i] = 1;
px.push(i);
}
}
// 起始色:最常出現的 16 種(每個顏色取 4 位元分桶)
const buckets = new Map<number, { n: number; r: number; g: number; b: number }>();
for (const i of px) {
const [r, g, b] = [data[i * 4]!, data[i * 4 + 1]!, data[i * 4 + 2]!];
const k = ((r >> 4) << 8) | ((g >> 4) << 4) | (b >> 4);
const e = buckets.get(k) ?? { n: 0, r: 0, g: 0, b: 0 };
e.n += 1;
e.r += r;
e.g += g;
e.b += b;
buckets.set(k, e);
}
let centers = [...buckets.values()]
.sort((a, b) => b.n - a.n)
.slice(0, COLORS)
.map((e) => [e.r / e.n, e.g / e.n, e.b / e.n] as [number, number, number]);
const assign = new Uint8Array(n);
const near = (r: number, g: number, b: number) => {
let best = 0;
let bd = Infinity;
for (let c = 0; c < centers.length; c++) {
const [cr, cg, cb] = centers[c]!;
const d = 0.3 * (r - cr) ** 2 + 0.59 * (g - cg) ** 2 + 0.11 * (b - cb) ** 2;
if (d < bd) {
bd = d;
best = c;
}
}
return best;
};
for (let iter = 0; iter < 4; iter++) {
const sum = centers.map(() => [0, 0, 0, 0]);
for (const i of px) {
const [r, g, b] = [data[i * 4]!, data[i * 4 + 1]!, data[i * 4 + 2]!];
const c = near(r, g, b);
assign[i] = c;
const s = sum[c]!;
s[0]! += r;
s[1]! += g;
s[2]! += b;
s[3]! += 1;
}
centers = centers.map((c, k) => (sum[k]![3]! ? [sum[k]![0]! / sum[k]![3]!, sum[k]![1]! / sum[k]![3]!, sum[k]![2]! / sum[k]![3]!] : c));
}
const fills = centers.map(([r, g, b]) => hex(r, g, b));
const color: (string | null)[] = new Array(n).fill(null);
for (const i of px) color[i] = fills[assign[i]!]!;
// 外圍一圈深色邊(像素角色的輪廓)
for (let i = 0; i < n; i++) {
if (solid[i]) continue;
const x = i % w;
const y = Math.floor(i / w);
if ((x > 0 && solid[i - 1]) || (x < w - 1 && solid[i + 1]) || (y > 0 && solid[i - w]) || (y < h - 1 && solid[i + w])) color[i] = OUTLINE;
}
const paths = new Map<string, string[]>();
for (let y = 0; y < h; y++) {
let x = 0;
while (x < w) {
const c = color[y * w + x];
if (!c) {
x += 1;
continue;
}
let end = x + 1;
while (end < w && color[y * w + end] === c) end += 1;
const list = paths.get(c) ?? [];
list.push(`M${x} ${y}h${end - x}v1h${x - end}z`);
paths.set(c, list);
x = end;
}
}
return { layers: [...paths].map(([fill, d]) => ({ fill, d: d.join("") })) };
}
/**
* 像素風的頭像身體:第一次先把一般畫法畫在看不見的地方,讀出來轉成像素圖,之後直接用快取。
* key 要能代表這張頭像(同一個 key 一定長得一樣)。
*/
export function PixelFigure({ cacheKey, children }: { cacheKey: string; children: ReactNode }) {
const ref = useRef<SVGGElement>(null);
const [, bump] = useReducer((n: number) => n + 1, 0);
const hit = cache.get(cacheKey);
useEffect(() => {
if (cache.has(cacheKey)) return;
let alive = true;
let job = pending.get(cacheKey);
if (!job) {
const node = ref.current?.firstElementChild;
if (!node || typeof XMLSerializer === "undefined") {
remember(cacheKey, "fail");
bump();
return;
}
const markup = new XMLSerializer().serializeToString(node);
job = pixelate(markup).then(
(art) => remember(cacheKey, art),
() => remember(cacheKey, "fail"),
);
pending.set(cacheKey, job);
void job.finally(() => pending.delete(cacheKey));
}
void job.then(() => alive && bump());
return () => {
alive = false;
};
}, [cacheKey]);
if (hit === "fail") return <>{children}</>;
if (hit)
return (
<g transform={`scale(${200 / GRID_W} ${220 / GRID_H})`} shapeRendering="crispEdges">
{hit.layers.map((l) => (
<path key={l.fill} d={l.d} fill={l.fill} />
))}
</g>
);
return (
<g ref={ref} opacity="0">
<g>{children}</g>
</g>
);
}