import { MaterialTier, MATERIAL_TIER_ORDER } from "../definitions/materialTiers.js"; import { itemDefinition } from "../definitions/items.js"; /** * Artist convention for tintable pixels (source sprites): * - Tintable when R == B and G < R (magenta family). * - Lightness L = R (= B): (50,0,50) dark … (255,0,255) max light. * - G > 0 (still G < R) desaturates toward white/gray: mix(tint, white, G/R) * L. * - Otherwise leave RGB as-is. World shaders apply darkness after this pass. */ export const MAGENTA_CHANNEL_EPS = 1 / 255; /** Display tint colors per material tier (0–1 RGB). */ export const TIER_TINT_COLOR = Object.freeze({ [MaterialTier.bronze]: Object.freeze({ r: 0.72, g: 0.48, b: 0.28 }), [MaterialTier.iron]: Object.freeze({ r: 0.62, g: 0.64, b: 0.68 }), [MaterialTier.steel]: Object.freeze({ r: 0.78, g: 0.80, b: 0.84 }), [MaterialTier.mithril]: Object.freeze({ r: 0.45, g: 0.55, b: 0.85 }), [MaterialTier.adamantium]: Object.freeze({ r: 0.35, g: 0.75, b: 0.45 }), [MaterialTier.orichalcum]: Object.freeze({ r: 0.85, g: 0.35, b: 0.55 }) }); export function normalizeRgb (color, fallback = { r: 0.7, g: 0.7, b: 0.7 }) { if (!color) { return { r: fallback.r, g: fallback.g, b: fallback.b }; } return { r: clamp01(color.r ?? fallback.r), g: clamp01(color.g ?? fallback.g), b: clamp01(color.b ?? fallback.b) }; } export function tierTintColor (tier) { return normalizeRgb(TIER_TINT_COLOR[tier] ?? TIER_TINT_COLOR[MaterialTier.bronze]); } /** * Resolve tint for an inventory/ground stack or item def. * Priority: potion instance.color → def.tint → tintFromTier + tier. */ export function resolveItemTint (stackOrDef, def = null) { const stack = stackOrDef?.itemId != null ? stackOrDef : null; const definition = def ?? (stack ? itemDefinition(stack.itemId) : stackOrDef) ?? null; if (stack?.instance?.kind === "potion" && stack.instance.color) { return normalizeRgb(stack.instance.color); } if (definition?.tint) { return normalizeRgb(definition.tint); } const tier = resolveTintTier(definition); if (tier) { return tierTintColor(tier); } return null; } export function resolveEquipTint (itemIdOrDef) { const definition = typeof itemIdOrDef === "number" ? itemDefinition(itemIdOrDef) : itemIdOrDef; if (!definition) { return null; } if (definition.tint) { return normalizeRgb(definition.tint); } const tier = resolveTintTier(definition); if (tier) { return tierTintColor(tier); } return null; } function resolveTintTier (definition) { if (!definition) { return null; } if (typeof definition.tintFromTier === "string") { return definition.tintFromTier; } if (definition.tintFromTier === true) { return definition.equipment?.tier ?? definition.tier ?? null; } if (definition.equipment?.tintFromTier) { return definition.equipment.tier ?? null; } return null; } /** Pure pixel transform (channels 0–1). Returns null if pixel is not tintable. */ export function magentaTintedRgb (r, g, b, tintRgb) { if (!isMagentaTintable(r, g, b)) { return null; } const L = r; const gBlend = r > 0 ? Math.min(1, Math.max(0, g / r)) : 0; const tint = normalizeRgb(tintRgb); return { r: clamp01(mix(tint.r, 1, gBlend) * L), g: clamp01(mix(tint.g, 1, gBlend) * L), b: clamp01(mix(tint.b, 1, gBlend) * L) }; } export function isMagentaTintable (r, g, b, eps = MAGENTA_CHANNEL_EPS) { return Math.abs(r - b) <= eps && g < r - eps; } /** Mutate ImageData in place with magenta→tint (alpha unchanged). */ export function applyMagentaTintToImageData (imageData, tintRgb) { const data = imageData.data; const tint = normalizeRgb(tintRgb); for (let i = 0; i < data.length; i += 4) { if (data[i + 3] < 8) { continue; } const r = data[i] / 255; const g = data[i + 1] / 255; const b = data[i + 2] / 255; const next = magentaTintedRgb(r, g, b, tint); if (!next) { continue; } data[i] = Math.round(next.r * 255); data[i + 1] = Math.round(next.g * 255); data[i + 2] = Math.round(next.b * 255); } return imageData; } export function listTierTintPreview () { return MATERIAL_TIER_ORDER.map((tier) => ({ tier, color: tierTintColor(tier) })); } function clamp01 (n) { return Math.min(1, Math.max(0, Number(n) || 0)); } function mix (a, b, t) { return a + (b - a) * t; }