Files
Triforce-Source/gpu/vk/vk_game_tex.h
ruckus7382sfgsgdf 34b3683441 Triforce v0.2.0
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 19:32:48 -06:00

222 lines
12 KiB
C++

// (Triforce) The game's own UI textures, read from the player's game files, in memory only (vk_imgui.cpp; never written
// anywhere, never in the repository or a binary). romfs/UI/Layout2Archive/Common.Product.100.Nin_Ounce_NVN2.bntx.zs is zstd with
// the dictionary zs.zsdic (vk_game_font.h Reader); in it a BNTX: a table of BRTI records, each a texture by name. The menus'
// textures are one level, 2D, in two formats: BC4 (0x1d01: one channel, a mask the layout's material colours) and ASTC 4x4
// (0x2d06 sRGB, 0x2d01), stored in the console's block-linear order (the Switch 2's: third_party/suyu decoders.cpp). No
// Vulkan or ImGui here: tests/ui_preview.cpp draws the menu with the same textures offline.
#pragma once
#include <algorithm>
#include <cmath>
#include <cstdint>
#include <cstring>
#include <span>
#include <string>
#include <vector>
#include "video_core/textures/astc.h"
#include "video_core/textures/decoders.h"
namespace mkwvk::game_tex {
struct Image {
uint32_t w = 0, h = 0;
bool mask = false; // (BC4: one channel, in every byte of rgba's pixels' alpha; its colour white)
bool srgb = false;
std::vector<unsigned char> rgba;
};
/// A BC4 block's 16 values (4 x 4, row by row)
inline void bc4_block(const unsigned char* b, unsigned char out[16]) {
unsigned char v[8];
v[0] = b[0], v[1] = b[1];
if (v[0] > v[1]) {
for (int i = 1; i < 7; i++) v[i + 1] = (unsigned char)(((7 - i) * v[0] + i * v[1] + 3) / 7);
} else {
for (int i = 1; i < 5; i++) v[i + 1] = (unsigned char)(((5 - i) * v[0] + i * v[1] + 2) / 5);
v[6] = 0, v[7] = 255;
}
uint64_t bits = 0;
for (int i = 0; i < 6; i++) bits |= (uint64_t)b[2 + i] << (8 * i);
for (int i = 0; i < 16; i++) out[i] = v[bits >> (3 * i) & 7];
}
class Bntx {
public:
struct Entry {
std::string name;
uint32_t w = 0, h = 0, format = 0, size = 0, block_height = 0;
uint64_t data = 0;
};
/// The archive's table (the bytes are kept: decode reads them)
bool parse(std::vector<unsigned char>&& bytes) {
d = std::move(bytes);
entries.clear();
if (d.size() < 0x60 || memcmp(d.data(), "BNTX", 4)) return false;
const uint32_t count = u32(0x24);
const uint64_t table = u64(0x28);
if (count > 65536 || table > d.size() || d.size() - table < (uint64_t)count * 8) return false;
for (uint32_t i = 0; i < count; i++) {
const uint64_t p = u64(table + 8ull * i);
if (p > d.size() || d.size() - p < 0xA0 || memcmp(d.data() + p, "BRTI", 4)) return false;
Entry e;
e.format = u32(p + 0x1C), e.w = u32(p + 0x24), e.h = u32(p + 0x28);
e.block_height = u32(p + 0x34) & 7;
e.size = u32(p + 0x50);
const uint64_t name = u64(p + 0x60), mips = u64(p + 0x70);
if (name + 2 > d.size() || mips + 8 > d.size()) return false;
const size_t len = d[name] | d[name + 1] << 8;
if (name + 2 + len > d.size()) return false;
e.name.assign((const char*)d.data() + name + 2, len);
e.data = u64(mips);
const bool one_level_2d = u32(p + 0x2C) <= 1 && u32(p + 0x30) <= 1;
if (!one_level_2d || e.data > d.size() || d.size() - e.data < e.size) e.size = 0; // (not one this reads)
entries.push_back(std::move(e));
}
return true;
}
const Entry* find(const char* name) const {
for (const Entry& e : entries)
if (e.name == name) return &e;
return nullptr;
}
/// A texture's pixels (RGBA, 8 bits each): false for a format or a shape this does not read
bool decode(const Entry& e, Image& out) const {
const uint32_t kind = e.format >> 8, bw = (e.w + 3) / 4, bh = (e.h + 3) / 4;
const uint32_t bytes = kind == 0x1d ? 8 : kind == 0x2d ? 16 : 0;
if (!bytes || !e.size || !e.w || !e.h || e.w > 8192 || e.h > 8192) return false;
std::vector<unsigned char> blocks((size_t)bw * bh * bytes);
// (the console's block-linear order to rows of blocks)
if (Tegra::Texture::CalculateSize(true, bytes, bw, bh, 1, e.block_height, 0) > e.size) return false;
Tegra::Texture::UnswizzleTexture(std::span<unsigned char>(blocks), std::span<const unsigned char>(d.data() + e.data, e.size), bytes,
bw, bh, 1, e.block_height, 0, 0);
out.w = e.w, out.h = e.h, out.mask = kind == 0x1d, out.srgb = (e.format & 0xff) == 6;
out.rgba.assign((size_t)e.w * e.h * 4, 255);
if (kind == 0x1d) {
for (uint32_t by = 0; by < bh; by++)
for (uint32_t bx = 0; bx < bw; bx++) {
unsigned char v[16];
bc4_block(blocks.data() + ((size_t)by * bw + bx) * 8, v);
for (uint32_t y = 0; y < 4 && by * 4 + y < e.h; y++)
for (uint32_t x = 0; x < 4 && bx * 4 + x < e.w; x++)
out.rgba[((size_t)(by * 4 + y) * e.w + bx * 4 + x) * 4 + 3] = v[y * 4 + x];
}
return true;
}
Tegra::Texture::ASTC::DecompressSerial(std::span<const unsigned char>(blocks), e.w, e.h, 1, 4, 4, std::span<unsigned char>(out.rgba));
return true;
}
std::vector<Entry> entries;
private:
uint32_t u32(uint64_t o) const {
uint32_t v;
memcpy(&v, d.data() + o, 4);
return v;
}
uint64_t u64(uint64_t o) const {
uint64_t v;
memcpy(&v, d.data() + o, 8);
return v;
}
std::vector<unsigned char> d;
};
// ---- the menus' skin: the textures the Options screen is drawn with (vk_ui.h), by the game's own names, and a few made
// from them here as the game's layout shader makes them at each draw: a plate is its shape (BtnThinBase_00's alpha), its
// colour between two browns by the grain texture (BtnThinBase_05), its fine frame line (BtnThinBase_04, or _02 with the
// curls at its corners) over it. The browns are measured from the game's own screens (the Load screen's buttons).
struct Skin {
struct Entry {
std::string name;
Image img;
};
std::vector<Entry> images;
const Image* get(const char* name) const {
for (const Entry& e : images)
if (e.name == name) return &e.img;
return nullptr;
}
};
struct Rgb {
unsigned char r, g, b;
};
// (the plates' browns: the grain's dark and light ends, and the frame line's; the selected row's a little lighter)
// (measured on the game's Options rows: 98,74,37 at a plate's rim to 111,84,44 at its middle, its edge line 122,103,61; the
// selected row's plate is the same: the game marks the selection with the cursor alone)
constexpr Rgb kPlateDark{96, 72, 36}, kPlateLight{112, 85, 45}, kPlateLine{124, 104, 62};
constexpr Rgb kPlateSelDark = kPlateDark, kPlateSelLight = kPlateLight, kPlateSelLine = kPlateLine;
/// A plate from the game's three layers (shape, grain, line): the same size as the shape
inline Image make_plate(const Image& shape, const Image& grain, const Image* line, Rgb dark, Rgb light, Rgb line_col) {
Image out;
out.w = shape.w, out.h = shape.h, out.srgb = true;
out.rgba.resize((size_t)out.w * out.h * 4);
for (uint32_t y = 0; y < out.h; y++)
for (uint32_t x = 0; x < out.w; x++) {
const size_t i = ((size_t)y * out.w + x) * 4;
const uint32_t gx = (std::min)(x, grain.w - 1), gy = (std::min)(y, grain.h - 1);
const float g = grain.rgba[((size_t)gy * grain.w + gx) * 4] / 255.0f;
float c[3] = {dark.r + (light.r - dark.r) * g, dark.g + (light.g - dark.g) * g, dark.b + (light.b - dark.b) * g};
if (line && x < line->w && y < line->h) {
const float a = line->rgba[((size_t)y * line->w + x) * 4 + 3] / 255.0f;
c[0] += (line_col.r - c[0]) * a, c[1] += (line_col.g - c[1]) * a, c[2] += (line_col.b - c[2]) * a;
}
out.rgba[i] = (unsigned char)(c[0] + 0.5f), out.rgba[i + 1] = (unsigned char)(c[1] + 0.5f), out.rgba[i + 2] = (unsigned char)(c[2] + 0.5f);
out.rgba[i + 3] = shape.rgba[i + 3];
}
return out;
}
/// The cursor from the game's two masks, as its layout shader draws it: OptionBtnThinCursorLine is a ramp from the frame's
/// outer edge inwards (0 to 1 over 28 texels: a distance, not a picture of a line), the line a band of it; the glow
/// (OptionBtnThinCursorGlow, a wider ramp) shows outside the line. The band is measured from the game's own cursor on its
/// Options screen (1920 x 1080: the line 13 layout units thick, its inner edge a box of 809 x 114 units in the 960 x 260
/// pane: the ramp from 0.34 to 0.65; about 20 units of blue-white glow outside it, nothing inside).
/// *line and *glow: white, their strength in alpha (the glow is tinted and breathes at the draw)
inline void make_cursor(const Image& ramp, const Image& wide, Image* line, Image* glow) {
auto step = [](float v, float a, float b) {
const float t = std::clamp((v - a) / (b - a), 0.0f, 1.0f);
return t * t * (3 - 2 * t);
};
for (Image* o : {line, glow}) o->w = ramp.w, o->h = ramp.h, o->mask = true, o->rgba.assign((size_t)ramp.w * ramp.h * 4, 255);
for (size_t i = 0; i < (size_t)ramp.w * ramp.h; i++) {
const float l = ramp.rgba[i * 4 + 3] / 255.0f;
const float g = i < (size_t)wide.w * wide.h ? wide.rgba[i * 4 + 3] / 255.0f : 0;
const float la = step(l, 0.31f, 0.37f) * (1 - step(l, 0.62f, 0.69f));
const float outside = std::pow(std::clamp(g / 0.36f, 0.0f, 1.0f), 1.6f) * (1 - step(l, 0.31f, 0.37f));
line->rgba[i * 4 + 3] = (unsigned char)(la * 255 + 0.5f);
glow->rgba[i * 4 + 3] = (unsigned char)(outside * 255 + 0.5f);
}
}
/// The skin from the archive's bytes (a BNTX): false when it is not the game's (a texture of the list missing)
inline bool make_skin(std::vector<unsigned char>&& bntx_bytes, Skin& skin) {
static const char* const names[] = {
"SystemHeader_00", "SystemBg_05", "SystemCaptionBg_00", "SystemGuideBase_00", "BtnThinBase_00", "BtnThinBase_01",
"BtnThinBase_02", "BtnThinBase_04", "BtnThinBase_05", "OptionBtnThinElement_00", "OptionBtnThinCursorLine_00",
"OptionBtnThinCursorGlow_00", "ScrollBarBase_00", "ScrollBar_00", "OptionSeparateMark_00",
"SystemLine_03", "MenuHeaderSelect_00", "OptionCheckMark_00"};
Bntx bntx;
if (!bntx.parse(std::move(bntx_bytes))) return false;
skin.images.clear();
for (const char* n : names) {
const Bntx::Entry* e = bntx.find(n);
Skin::Entry out;
out.name = n;
if (!e || !bntx.decode(*e, out.img)) return false;
skin.images.push_back(std::move(out));
}
const Image *shape = skin.get("BtnThinBase_00"), *grain = skin.get("BtnThinBase_05");
Skin::Entry row{"plate_row", make_plate(*shape, *grain, skin.get("BtnThinBase_04"), kPlateDark, kPlateLight, kPlateLine)};
Skin::Entry row_sel{"plate_row_sel", make_plate(*shape, *grain, skin.get("BtnThinBase_04"), kPlateSelDark, kPlateSelLight, kPlateSelLine)};
Skin::Entry btn{"plate_btn", make_plate(*shape, *grain, skin.get("BtnThinBase_02"), kPlateDark, kPlateLight, kPlateLine)};
skin.images.push_back(std::move(row)), skin.images.push_back(std::move(row_sel)), skin.images.push_back(std::move(btn));
Skin::Entry line{"cursor_line", {}}, glow{"cursor_glow", {}};
make_cursor(*skin.get("OptionBtnThinCursorLine_00"), *skin.get("OptionBtnThinCursorGlow_00"), &line.img, &glow.img);
skin.images.push_back(std::move(line)), skin.images.push_back(std::move(glow));
return true;
}
} // namespace mkwvk::game_tex