BlueGit

timfa questward

Files

questward / client / src / play / characterPreview.js

characterPreview.js

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