BlueGit

timfa questward

Files

questward / client / src / play / characterPreview.js

characterPreview.js

characterPreview.js 8.1 KiB Download Raw
1import { applyMagentaTintToImageData, applyDualChannelTintToImageData } from "/shared/render/tint.js";
2import { layersForHairPreview } from "/shared/appearance/hair.js";
3import { PIVOT_FROM_BOTTOM_PX } from "/shared/protocol/constants.js";
4
5/**
6 * Draw stacked character layers (body + hair + optional gear) onto a canvas.
7 * Magenta hair/gear tints applied in 2D for UI previews.
8 * Layers may differ in size (e.g. body 16×24, shirt equip 20×24); they share
9 * the world pivot (horizontal centre, `PIVOT_FROM_BOTTOM_PX` from the bottom).
10 */
11export async function paintCharacterPreview (canvas, {
12 sex,
13 bag = null,
14 hair = null,
15 hideHeadgear = true,
16 resolveSpriteUrl,
17 scale = 4
18} = {})
19{
20 if (!canvas)
21 { return; }
22 const layers = layersForHairPreview(sex, bag, hair, { hideHeadgear });
23 const images = [];
24 for (const layer of layers)
25 {
26 const url = resolveSpriteUrl?.(layer.sprite);
27 if (!url)
28 { continue; }
29 const img = await loadHtmlImage(url);
30 images.push({ img, tint: layer.tint ?? null });
31 }
32 if (!images.length)
33 { return; }
34
35 let maxW = 1;
36 let maxH = 1;
37 for (const entry of images)
38 {
39 maxW = Math.max(maxW, entry.img.naturalWidth || entry.img.width || 1);
40 maxH = Math.max(maxH, entry.img.naturalHeight || entry.img.height || 1);
41 }
42
43 canvas.width = maxW * scale;
44 canvas.height = maxH * scale;
45 const ctx = canvas.getContext("2d");
46 ctx.imageSmoothingEnabled = false;
47 ctx.clearRect(0, 0, canvas.width, canvas.height);
48
49 const pivotX = maxW * 0.5;
50 const pivotY = maxH - PIVOT_FROM_BOTTOM_PX;
51 for (const entry of images)
52 {
53 const source = entry.tint ? tintedCanvas(entry.img, entry.tint) : entry.img;
54 const sw = source.naturalWidth || source.width || 1;
55 const sh = source.naturalHeight || source.height || 1;
56 const ox = (pivotX - sw * 0.5) * scale;
57 const oy = (pivotY - (sh - PIVOT_FROM_BOTTOM_PX)) * scale;
58 ctx.drawImage(source, ox, oy, sw * scale, sh * scale);
59 }
60}
61
62/**
63 * Sync composite of live `appearanceLayers` onto a fixed-size canvas.
64 * Crops a top-aligned square from each frame (e.g. 16×16 from a 16×24 body)
65 * then scales that crop up to `size` (e.g. 64) without squishing the tall frame.
66 * `resolveImage(name)` should return a Framework `image` (with `g_image` /
67 * `getSubImage`) or a plain HTMLImageElement / canvas already in memory.
68 */
69export function paintAppearanceSnapshot (canvas, layers, {
70 resolveImage,
71 size = 64,
72 frame = 0
73} = {})
74{
75 if (!canvas)
76 { return false; }
77 const draws = [];
78 for (const layer of layers ?? [])
79 {
80 const name = layer?.sprite;
81 if (!name)
82 { continue; }
83 const entry = resolveImage?.(name);
84 if (!entry)
85 { continue; }
86 draws.push({ entry, tint: layer.tint ?? null, frame });
87 }
88 return paintDrawListSnapshot(canvas, draws, { size });
89}
90
91/**
92 * Offline / list UI portrait from public appearance layers (hair + clothing tints).
93 * Prefers in-memory Framework images; falls back to loading catalog URLs.
94 * @returns {HTMLDivElement}
95 */
96export function mountLayerPreview (layers, {
97 resolveImage = null,
98 resolveSpriteUrl = null,
99 size = 48,
100 className = "char-preview"
101} = {})
102{
103 const wrap = document.createElement("div");
104 wrap.className = className;
105 const canvas = document.createElement("canvas");
106 canvas.width = size;
107 canvas.height = size;
108 canvas.style.width = "100%";
109 canvas.style.height = "100%";
110 canvas.style.imageRendering = "pixelated";
111 wrap.append(canvas);
112
113 const list = layers ?? [];
114 const allInMemory = list.length > 0 && list.every((layer) =>
115 !layer?.sprite || !!resolveImage?.(layer.sprite));
116 const painted = allInMemory
117 ? paintAppearanceSnapshot(canvas, list, { resolveImage, size })
118 : false;
119 if (!painted && resolveSpriteUrl)
120 {
121 void paintLayersFromUrls(canvas, list, { resolveSpriteUrl, size }).catch(() =>
122 { /* preview is best-effort */ });
123 }
124 return wrap;
125}
126
127/**
128 * Load layer sprites by URL and composite with magenta tints (async fallback).
129 */
130export async function paintLayersFromUrls (canvas, layers, {
131 resolveSpriteUrl,
132 size = 48
133} = {})
134{
135 if (!canvas)
136 { return false; }
137 const draws = [];
138 for (const layer of layers ?? [])
139 {
140 const url = resolveSpriteUrl?.(layer?.sprite);
141 if (!url)
142 { continue; }
143 try
144 {
145 const img = await loadHtmlImage(url);
146 draws.push({ entry: img, tint: layer.tint ?? null, frame: 0 });
147 }
148 catch
149 { /* skip missing art */ }
150 }
151 return paintDrawListSnapshot(canvas, draws, { size });
152}
153
154/**
155 * Composite the live world render stack (body GameObject + overlays + tints).
156 * Matches what the player sees in-world, including hair overlays.
157 */
158export function paintLiveEntitySnapshot (canvas, entity, { size = 64 } = {})
159{
160 if (!canvas || !entity?.object?.renderer?.sprite)
161 { return false; }
162 const draws = [{
163 entry: entity.object.renderer.sprite,
164 tint: null,
165 frame: entity.object.renderer.subImage | 0
166 }];
167 const overlays = entity.overlays ?? [];
168 const tints = entity.overlayTints ?? [];
169 const dualTints = entity.overlayDualTints ?? [];
170 for (let index = 0; index < overlays.length; index++)
171 {
172 const sprite = overlays[index]?.renderer?.sprite;
173 if (!sprite)
174 { continue; }
175 draws.push({
176 entry: sprite,
177 tint: tints[index] ?? null,
178 dualTint: dualTints[index] ?? null,
179 frame: overlays[index].renderer.subImage | 0
180 });
181 }
182 return paintDrawListSnapshot(canvas, draws, { size });
183}
184
185function paintDrawListSnapshot (canvas, draws, { size = 64 } = {})
186{
187 if (!canvas || !draws?.length)
188 { return false; }
189 canvas.width = size;
190 canvas.height = size;
191 const ctx = canvas.getContext("2d");
192 ctx.imageSmoothingEnabled = false;
193 ctx.clearRect(0, 0, size, size);
194 let drew = false;
195 for (const draw of draws)
196 {
197 const entry = draw.entry;
198 const html = entry?.g_image ?? entry;
199 if (!html || !(html.naturalWidth || html.width))
200 { continue; }
201 let sx = 0;
202 let sy = 0;
203 let sw = html.naturalWidth || html.width;
204 let sh = html.naturalHeight || html.height;
205 if (typeof entry?.getSubImage === "function")
206 {
207 const sub = entry.getSubImage(draw.frame | 0);
208 sx = sub.sx;
209 sy = sub.sy;
210 sw = sub.sw;
211 sh = sub.sh;
212 }
213 // Top-aligned square crop of the frame (e.g. 16×16 from 16×24).
214 const crop = Math.min(sw, sh);
215 const cropSx = sx + Math.floor((sw - crop) / 2);
216 const cropSy = sy;
217 let source = null;
218 if (draw.dualTint)
219 { source = dualTintedSubCanvas(html, cropSx, cropSy, crop, crop, draw.dualTint); }
220 else if (draw.tint)
221 { source = tintedSubCanvas(html, cropSx, cropSy, crop, crop, draw.tint); }
222 if (source)
223 { ctx.drawImage(source, 0, 0, size, size); }
224 else
225 { ctx.drawImage(html, cropSx, cropSy, crop, crop, 0, 0, size, size); }
226 drew = true;
227 }
228 return drew;
229}
230
231function loadHtmlImage (url)
232{
233 return new Promise((resolve, reject) =>
234 {
235 const img = new Image();
236 img.onload = () => resolve(img);
237 img.onerror = () => reject(new Error(`Failed to load ${url}`));
238 img.src = url;
239 });
240}
241
242function tintedCanvas (sourceImg, tintRgb)
243{
244 const canvas = document.createElement("canvas");
245 canvas.width = sourceImg.naturalWidth || sourceImg.width;
246 canvas.height = sourceImg.naturalHeight || sourceImg.height;
247 const ctx = canvas.getContext("2d");
248 ctx.imageSmoothingEnabled = false;
249 ctx.drawImage(sourceImg, 0, 0);
250 const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
251 applyMagentaTintToImageData(imageData, tintRgb);
252 ctx.putImageData(imageData, 0, 0);
253 return canvas;
254}
255
256function tintedSubCanvas (sourceImg, sx, sy, sw, sh, tintRgb)
257{
258 const canvas = document.createElement("canvas");
259 canvas.width = sw;
260 canvas.height = sh;
261 const ctx = canvas.getContext("2d");
262 ctx.imageSmoothingEnabled = false;
263 ctx.drawImage(sourceImg, sx, sy, sw, sh, 0, 0, sw, sh);
264 const imageData = ctx.getImageData(0, 0, sw, sh);
265 applyMagentaTintToImageData(imageData, tintRgb);
266 ctx.putImageData(imageData, 0, 0);
267 return canvas;
268}
269
270function dualTintedSubCanvas (sourceImg, sx, sy, sw, sh, dualTint)
271{
272 const canvas = document.createElement("canvas");
273 canvas.width = sw;
274 canvas.height = sh;
275 const ctx = canvas.getContext("2d");
276 ctx.imageSmoothingEnabled = false;
277 ctx.drawImage(sourceImg, sx, sy, sw, sh, 0, 0, sw, sh);
278 const imageData = ctx.getImageData(0, 0, sw, sh);
279 applyDualChannelTintToImageData(imageData, dualTint);
280 ctx.putImageData(imageData, 0, 0);
281 return canvas;
282}