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

234 lines
8.2 KiB
TypeScript
Raw Normal View History

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>
);
}