Merge the texture detail setting into the combined test line.

One conflict, in the build kit's notes, which keep both the shader cache item and the Texture detail text.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
This commit is contained in:
chrg6
2026-11-10 09:51:33 -05:00
14 changed files with 568 additions and 45 deletions

View File

@@ -67,7 +67,7 @@ static const char *const known[] = {
"WALK_KEY", "WALK_SCALE", "WB_EXACT", "WB_FENCE_LIMIT", "WB_MERGE", "WB_NO_REUP", "WB_MERGE_MAX", "WB_PROBE", "WB_SPLIT", "WB_LAZY", "WB_LAZY_TOUCH", "WINDOW_SIZE", "XLATE", "XLATE_ID", "XLATE_KEEP", "XLATE_PROCS",
"ZSTD_CHECK", "ZSTD_NATIVE",
"BIND_REUSE", "DYN_DELTA", "STG_ARENA", "SUBMIT_BATCH", "ASTC_GPU_DESWIZZLE", "ASTC_SCRATCH_KEEP", "ASTC_ARENA",
"TEXUP_LOG_MS", "DYN_RES", "DYN_RES_TARGET", "DYN_RES_STEP",
"TEXUP_LOG_MS", "DYN_RES", "DYN_RES_TARGET", "DYN_RES_STEP", "TEXTURE_DETAIL",
"RECORDER_CORE", "RECORDER_PRIO", "REPLAY_TIME", "LOCK_TIME", "POOL_CREATE_BUDGET", "POOL_CREATE_MS", "POOL_LOAD_BACKLOG", "POOL_LOAD_MS",
"VMA_BLOCK_MB", "ASTC_BC_PROBE", "SYNC_WAKE_ALL", "LOG_ASYNC",
};
@@ -80,6 +80,7 @@ static const struct { const char *key, *section; } sections[] = {
{"FULLSCREEN", "display"}, {"WINDOW_SIZE", "display"}, {"PERF_OVERLAY", "display"}, {"VK_PRESENT", "display"},
{"GPU_INDEX", "display"}, {"MONITOR", "display"}, {"OUTPUT_RES", "display"}, {"GAME_ASPECT", "display"}, {"GAME_RES", "display"}, {"RENDER_SCALE", "display"}, {"UPSCALER", "display"},
{"SHARPNESS", "display"}, {"ASPECT", "display"}, {"FOV", "display"}, {"ANISO", "display"},
{"TEXTURE_DETAIL", "display"},
{"COLOR_PRESET", "display"},
{"COLOR_BRIGHTNESS", "display"}, {"COLOR_CONTRAST", "display"}, {"COLOR_SATURATION", "display"},
{"COLOR_GAMMA", "display"}, {"HDR", "display"}, {"HDR_LIVE", "display"}, {"HDR_PEAK_NITS", "display"}, {"HDR_GAME_NITS", "display"},
@@ -152,6 +153,7 @@ static const CfgMeta metas[] = {
{"GAME_RES", "1440", "1080|1440|1800|2160|2880|window", RESTART}, // widescreen.c: the picture's height
{"ASPECT", "fit", "fit|stretch", LIVE}, {"FOV", "100", "70..140", LIVE},
{"ANISO", "game", "game|2|4|8|16", LIVE}, // vk_texture.c sampler_features, vk_sampler_aniso_live
{"TEXTURE_DETAIL", "auto", "auto|full|reduced|low", RESTART}, // vk_texture.c "texture detail", read at the first texture
// colour adjustment (vk_color.c); the preset is the menu's, the four values are what the present uses
{"COLOR_PRESET", "default", "default|vivid|clarity|custom", LIVE}, {"COLOR_BRIGHTNESS", "0", "-30..30", LIVE},
{"COLOR_CONTRAST", "100", "70..150", LIVE}, {"COLOR_SATURATION", "100", "50..200", LIVE},

View File

@@ -121,10 +121,13 @@ typedef struct {
uint8_t pool; // TEX: 1 the texture pool, 2 the sampler pool, indexed by bindless handles (set 2)
uint16_t ptr; // SSBO: 0, or 1 + the byte offset of this buffer's address inside the storage buffer that
// cbuf_slot and handle name (a pointer table; the translator's patch 0022, res.json "ptr")
uint8_t exact; // TEX: the module fetches its texels by position or uses its size or level count, so it
// needs every level of the texture as the game made it (gfx_shader.c reflect_exact)
} GfxShaderRes;
typedef struct { uint8_t type, comps, packed; } GfxShaderIo; // GFX_TYPE_*, components, 1 with a Component decoration
int gfx_shader_stage(const GfxShader *s); // GFX_STAGE_VS, GFX_STAGE_FS or GFX_STAGE_CS
int gfx_shader_resources(const GfxShader *s, int kind, const GfxShaderRes **res); // count of GFX_RES_* kind; array in *res
uint32_t gfx_shader_exact_seen(void); // shaders loaded so far with a GfxShaderRes.exact texture (the texture census line)
uint32_t gfx_shader_slot_mask(const GfxShader *s); // texture/image slots whose type its translation read
uint32_t gfx_shader_inputs(const GfxShader *s, GfxShaderIo io[32]); // Input Locations (VS attributes, FS varyings) as a mask
uint32_t gfx_shader_outputs(const GfxShader *s, GfxShaderIo io[32]);

View File

@@ -1078,6 +1078,101 @@ out:
free(cc);
}
// Texture detail (vk_texture.c, "texture detail") makes large material textures without their top mip levels, which a
// shader that samples with normalised coordinates cannot tell. One that reads texels by position can, and so can one
// that works with the size or the level count. This finds the sampled textures a module reads so and sets
// GfxShaderRes.exact on their bindings; the replay then binds such a texture whole (vk_exec_draw.c tex_info_full):
// - OpImageFetch;
// - OpImageQuerySize and OpImageQueryLevels;
// - OpImageQuerySizeLod, unless the image is arrayed and every use of the result is an OpCompositeExtract of
// component 2, the layer count: the translator clamps the layer of an array sample to it, and no level changes it.
// The image of each read is followed back to its variable through the loads, access chains, OpSampledImage and OpImage
// the translator emits. A read that leads to no variable marks every texture of the module. One that leads into the
// texture pool array (a bindless handle picks the texture, so no binding names it) cannot be acted on and is logged:
// none of the 44,081 shaders prepared for game 1.1.1 has one.
static volatile int32_t n_exact_shaders;
uint32_t gfx_shader_exact_seen(void) { return (uint32_t)__atomic_load_n(&n_exact_shaders, __ATOMIC_RELAXED); }
static void reflect_exact(GfxShader *s) {
enum { X_FUNCTION = 54, X_TYPE_IMAGE = 25, X_TYPE_SAMPLED_IMAGE = 27, X_LOAD = 61, X_ACCESS_CHAIN = 65,
X_IN_BOUNDS_ACCESS_CHAIN = 66, X_COMPOSITE_EXTRACT = 81, X_COPY_OBJECT = 83, X_SAMPLED_IMAGE = 86, X_FETCH = 95,
X_IMAGE = 100, X_QUERY_SIZE_LOD = 103, X_QUERY_SIZE = 104, X_QUERY_LEVELS = 106, X_DEC_BINDING = 33 };
static volatile int32_t n_pool_logged;
const uint32_t *w = s->spirv;
uint64_t n = s->words, fn = 0;
if (!s->nres[GFX_RES_TEX] || n < 5) return;
int any = 0; // nine shaders in ten have no such read: they cost this walk over the instruction headers
for (uint64_t i = 5; i < n && !any;) {
uint32_t op = w[i] & 0xffff, len = w[i] >> 16;
if (!len) break;
any = op == X_FETCH || op == X_QUERY_SIZE || op == X_QUERY_LEVELS || op == X_QUERY_SIZE_LOD;
i += len;
}
if (!any) return;
uint32_t bound = w[3] < (1u << 20) ? w[3] : (1u << 20);
// per id: a type's or variable's image is arrayed; a variable's Binding + 1; the variable a value comes from; the
// variable a pending size query read (+ 1); and per variable whether it is read exactly
uint8_t *arrayed = calloc(bound, 1), *need = calloc(bound, 1);
uint32_t *bind = calloc(bound, sizeof *bind), *org = calloc(bound, sizeof *org), *query = calloc(bound, sizeof *query);
int all = 0, queries = 0;
if (!arrayed || !need || !bind || !org || !query) goto out;
for (uint64_t i = 5; i < n;) {
uint32_t op = w[i] & 0xffff, len = w[i] >> 16;
if (!len || i + len > n) break;
const uint32_t *a = w + i;
if (op == X_FUNCTION && !fn) fn = i;
#define ID(x) ((x) < bound)
if (op == OP_DECORATE && len >= 4 && ID(a[1]) && a[2] == X_DEC_BINDING) bind[a[1]] = a[3] + 1;
else if (op == X_TYPE_IMAGE && len >= 9 && ID(a[1])) arrayed[a[1]] = a[5] != 0;
else if (op == X_TYPE_SAMPLED_IMAGE && len >= 3 && ID(a[1]) && ID(a[2])) arrayed[a[1]] = arrayed[a[2]];
else if (op == OP_TYPE_ARRAY && len >= 4 && ID(a[1]) && ID(a[2])) arrayed[a[1]] = arrayed[a[2]];
else if (op == OP_TYPE_POINTER && len >= 4 && ID(a[1]) && ID(a[3])) arrayed[a[1]] = arrayed[a[3]];
else if (op == OP_VARIABLE && len >= 4 && ID(a[1]) && ID(a[2])) {
arrayed[a[2]] = arrayed[a[1]];
if (bind[a[2]]) org[a[2]] = a[2];
} else if ((op == X_ACCESS_CHAIN || op == X_IN_BOUNDS_ACCESS_CHAIN || op == X_LOAD || op == X_COPY_OBJECT ||
op == X_SAMPLED_IMAGE || op == X_IMAGE) && len >= 4 && ID(a[2]) && ID(a[3])) {
org[a[2]] = org[a[3]];
} else if ((op == X_FETCH || op == X_QUERY_SIZE || op == X_QUERY_LEVELS || op == X_QUERY_SIZE_LOD) && len >= 4) {
uint32_t var = ID(a[3]) ? org[a[3]] : 0;
if (!var) all = 1;
else if (op == X_QUERY_SIZE_LOD && arrayed[var] && ID(a[2])) query[a[2]] = var + 1, queries++;
else need[var] = 1;
}
#undef ID
i += len;
}
// every use of a pending size query: anything but the layer count makes its texture exact. Any word that equals
// the result's id counts as a use, so a literal that happens to equal it errs towards exact.
for (uint64_t i = fn; queries && fn && i < n;) {
uint32_t op = w[i] & 0xffff, len = w[i] >> 16;
if (!len || i + len > n) break;
int layer_count = op == X_COMPOSITE_EXTRACT && len == 5 && w[i + 4] == 2;
int defines = op == X_QUERY_SIZE_LOD && len >= 4;
for (uint32_t j = 1; j < len; j++) {
uint32_t x = w[i + j];
if (x >= bound || !query[x]) continue;
if ((defines && j == 2) || (layer_count && j == 3)) continue;
need[query[x] - 1] = 1;
}
i += len;
}
int pooled = 0, some = 0;
for (int k = 0; k < s->nres[GFX_RES_TEX]; k++) {
GfxShaderRes *r = &s->res[GFX_RES_TEX][k];
int hit = 0;
for (uint32_t id = 0; id < bound && !hit; id++) hit = need[id] && bind[id] == (uint32_t)r->binding + 1;
if (r->pool) pooled |= hit;
else r->exact = (uint8_t)(hit || all), some |= r->exact;
}
if (some) plat_inc32(&n_exact_shaders);
if (pooled && plat_inc32(&n_pool_logged) <= 4)
rt_log("gfx_shader: a shader reads a texture of the bindless pool by texel position or uses its size; with "
"texture_detail below full such a texture may be read at the wrong level (vk_texture.c, texture detail)");
out:
free(arrayed), free(need), free(bind), free(org), free(query);
}
static void reflect_stage(GfxShader *s) {
const char *js = s->reflection;
char stage[8];
@@ -1098,6 +1193,7 @@ static void reflect(GfxShader *s) {
json_objects(js, kinds[k], add_res, s, k);
}
reflect_spirv(s);
reflect_exact(s);
patch_txd_transpose(s);
}

View File

@@ -1,12 +1,14 @@
// nx2navi.exe --probe-vkmem: texture memory checks. The CPU part: block-linear copies against an
// independent reference, ASTC void-extent blocks, and the NVN -> VkFormat table against GPU0. The GPU part:
// guest heap imported as a VkBuffer, write watch against CPU, GPU and ReadFile writes, the virtual-pool page table,
// and textures uploaded from block-linear storage and read back.
// and textures uploaded from block-linear storage and read back, among them ASTC textures at the texture detail in
// effect (NX2NAVI_TEXTURE_DETAIL=reduced or low to check the levels left out).
// The reference swizzler walks the GOBs in storage order and places each byte by bit operations, so it shares no
// addressing code with nvn_bl_offset.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cfg.h"
#include "host.h"
#include "nvn_api.h"
#include "tex.h"
@@ -659,6 +661,134 @@ static int image_is_color(VkImage image, uint32_t w, uint32_t h, const uint8_t w
return same;
}
// ---- texture detail (vk_texture.c "texture detail"): an ASTC texture made without its top mip levels
// Every level and layer of t's storage becomes ASTC void-extent blocks of one colour, each channel 0 or 255 so that
// the RGBA8 decode and its BC3 encoding both hold it exactly. The colour says which level and layer it is.
static void detail_color(unsigned lv, unsigned layer, unsigned round, uint8_t c[4]) {
unsigned k = 1 + (lv * 3 + layer + round * 2) % 7; // never black: 1 to 7
c[0] = k & 1 ? 255 : 0, c[1] = k & 2 ? 255 : 0, c[2] = k & 4 ? 255 : 0, c[3] = 255;
}
static int detail_fill(const tex_t *t, unsigned layers, unsigned round) {
for (unsigned lv = 0; lv < t->d.levels; lv++)
for (unsigned ly = 0; ly < layers; ly++) {
uint32_t rb, rows, sl, bpb; uint64_t base; unsigned th, td;
GCHECK(!nvn_deswizzle_geom(&t->d, lv, ly, &rb, &rows, &sl, &base, &th, &td, &bpb), "ASTC geometry of level %u", lv);
size_t n = (size_t)rb * rows;
uint8_t *tight = malloc(n), c[4];
detail_color(lv, ly, round, c);
for (size_t i = 0; i < n; i += 16)
void_block(tight + i, (uint16_t)(c[0] * 257), (uint16_t)(c[1] * 257), (uint16_t)(c[2] * 257), 0xFFFF, 0);
ref_swizzle(tight, t->mem + base, rb, rows, 1, th, td);
free(tight);
}
return 0;
}
// Whether level lv, layer ly of image (RGBA8 or BC3, w x h at that level) is `want` in every texel.
static int detail_level_is(const VkTexImage *img, uint32_t lv, uint32_t ly, uint32_t w, uint32_t h, const uint8_t want[4]) {
VkCtx *c = vk_ctx();
int bc = img->format == VK_FORMAT_BC3_UNORM_BLOCK || img->format == VK_FORMAT_BC3_SRGB_BLOCK;
size_t n = bc ? (size_t)((w + 3) / 4) * ((h + 3) / 4) * 16 : (size_t)w * h * 4;
VkBuffer rb;
VmaAllocation ra;
uint8_t *r = vk_staging(n, &rb, &ra);
VkCommandBuffer cb = vk_upload_begin();
VkMemoryBarrier2 mb = {.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2, .srcStageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
.srcAccessMask = VK_ACCESS_2_MEMORY_WRITE_BIT, .dstStageMask = VK_PIPELINE_STAGE_2_COPY_BIT,
.dstAccessMask = VK_ACCESS_2_TRANSFER_READ_BIT};
VkDependencyInfo di = {.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, .memoryBarrierCount = 1, .pMemoryBarriers = &mb};
vkCmdPipelineBarrier2(cb, &di);
VkBufferImageCopy rg = {.imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, lv, ly, 1}, .imageExtent = {w, h, 1}};
vkCmdCopyImageToBuffer(cb, img->image, VK_IMAGE_LAYOUT_GENERAL, rb, 1, &rg);
mb = (VkMemoryBarrier2){.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2, .srcStageMask = VK_PIPELINE_STAGE_2_COPY_BIT,
.srcAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT, .dstStageMask = VK_PIPELINE_STAGE_2_HOST_BIT,
.dstAccessMask = VK_ACCESS_2_HOST_READ_BIT};
vkCmdPipelineBarrier2(cb, &di);
vk_upload_end();
vk_upload_flush(1);
vmaInvalidateAllocation(c->vma, ra, 0, VK_WHOLE_SIZE);
int same = 1;
if (bc) { // BC3: two 5:6:5 endpoints at bytes 8 to 11; both are the colour, so every texel is
uint16_t e = (uint16_t)((want[0] >> 3) << 11 | (want[1] >> 2) << 5 | want[2] >> 3);
for (size_t i = 0; i < n; i += 16) {
uint16_t e0, e1;
memcpy(&e0, r + i + 8, 2), memcpy(&e1, r + i + 10, 2);
same &= e0 == e && e1 == e;
}
} else {
for (size_t i = 0; i < n; i += 4) same &= !memcmp(r + i, want, 4);
}
vmaDestroyBuffer(c->vma, rb, ra);
return same;
}
// The image of an ASTC texture has the game's levels from the skip the setting gives it: its size is that level's, and
// each of its levels and layers holds that level's blocks, after the upload and after a rewrite of the storage.
static int detail_case(pool_t *pool, uint64_t off, uint64_t room, uint32_t size, uint32_t levels, unsigned layers,
uint64_t serial, uint32_t want_skip) {
tex_t t = make_tex(pool, off, 0x80, size, size, levels, serial); // ASTC 8x8
if (layers > 1) {
t.d.target = NVN_TEXTURE_TARGET_2D_ARRAY, t.d.depth = layers;
nvn_tex_layout(&t.d, &t.L);
}
GCHECK(t.L.size <= room && off + room <= pool->size, "ASTC %ux%u storage of %llu bytes does not fit its %llu in the "
"probe's pool", size, size, (unsigned long long)t.L.size, (unsigned long long)room);
for (unsigned round = 0; round < 2; round++) {
if (detail_fill(&t, layers, round)) return 1;
const VkTexImage *img = vk_texture_get(&t);
GCHECK(img && img->mirrored, "ASTC %ux%u texture image", size, size);
if (img->format != VK_FORMAT_R8G8B8A8_UNORM && img->format != VK_FORMAT_BC3_UNORM_BLOCK) return 0; // native ASTC
GCHECK(img->skip == want_skip && img->levels == levels - want_skip && img->width == size >> want_skip &&
img->height == size >> want_skip && img->layers == layers,
"ASTC %ux%u, %u levels, %u layers: image %ux%u with %u levels, %u layers, made without %u (want %u)", size, size,
levels, layers, img->width, img->height, img->levels, img->layers, img->skip, want_skip);
for (uint32_t lv = 0; lv < img->levels; lv++)
for (uint32_t ly = 0; ly < layers; ly++) {
uint8_t want[4];
uint32_t w = size >> (lv + img->skip) ? size >> (lv + img->skip) : 1;
detail_color(lv + img->skip, ly, round, want);
GCHECK(detail_level_is(img, lv, ly, w, w, want),
"ASTC %ux%u made without %u levels: image level %u layer %u is not the game's level %u (%s)", size, size,
img->skip, lv, ly, lv + img->skip, round ? "after a rewrite of the storage" : "first upload");
g_gpu_checks++;
}
}
vk_texture_release(&t);
return 0;
}
static int test_detail(pool_t *pool) {
const char *v = cfg_value("NX2NAVI_TEXTURE_DETAIL");
int most = !strcmp(v, "full") ? 0 : !strcmp(v, "reduced") ? 1 : !strcmp(v, "low") ? 2 : vk_texture_detail_auto();
// 1024x1024 with 6 levels (two levels less at low), a 256x256 array of 3 layers (one less below full), and the
// ones the rule leaves whole: 128x128, and 512x512 without smaller levels
if (detail_case(pool, 0, 0x80000, 1024, 6, 1, 20, most > 1 ? 2 : (uint32_t)most) ||
detail_case(pool, 0x80000, 0x40000, 256, 4, 3, 21, most ? 1 : 0) ||
detail_case(pool, 0xc0000, 0x10000, 128, 4, 1, 22, 0) || detail_case(pool, 0xd0000, 0x20000, 512, 1, 1, 23, 0))
return 1;
// the sampler of a texture made without levels: an open LOD clamp is the slot's sampler, a closed one moves down
samp_par sp;
memset(&sp, 0, sizeof sp);
sp.minf = NVN_MIN_FILTER_LINEAR_MIPMAP_LINEAR, sp.magf = NVN_MAG_FILTER_LINEAR, sp.ws = sp.wt = sp.wr = NVN_WRAP_MODE_REPEAT;
sp.lod_max = 1000;
vk_sampler_register(2, &sp);
sp.lod_min = 1, sp.lod_max = 4;
vk_sampler_register(3, &sp);
sp.lod_min = 0, sp.lod_max = 3;
vk_texture_lock();
VkSampler open1 = vk_sampler_detail_by_id_locked(2, 1), shut1 = vk_sampler_detail_by_id_locked(3, 1);
vk_texture_unlock();
GCHECK(open1 && open1 == vk_sampler_by_id(2), "the sampler of a reduced texture with an open LOD clamp is not the slot's");
GCHECK(shut1 && shut1 != vk_sampler_by_id(3) && shut1 == vk_sampler_for(&sp),
"the sampler of a reduced texture with LOD 1..4 does not clamp to 0..3");
g_gpu_checks += 2;
printf("probe-vkmem: texture detail %s: ASTC images hold the game's levels from the one they start at, after upload "
"and re-upload (1024x1024, a 256x256 array, and 128x128 and unmipped left whole); sampler LOD clamps follow\n",
most == 0 ? "full" : most == 1 ? "reduced" : "low");
return 0;
}
static int test_textures(pool_t *tpool, pool_t *phys) {
uint8_t *lin[4] = {0};
// block-linear RGBA8 with 3 levels in a CPU-visible pool: uploaded through the GPU, read back from the image
@@ -768,6 +898,11 @@ static int test_gpu(void) {
if (test_import(&pool) || test_readfile(pool.mem + 0x38000) || test_virtual(&phys, &virt)) return 1;
GCHECK(vk_pool_init(&tpool), "vk_pool_init of the texture pool");
if (test_textures(&tpool, &phys)) return 1;
pool_t dpool = {.magic = NVN_POOL_MAGIC, .flags = 0x22, .mem = h + 0x500000, .size = 0x100000, .game_mem = h + 0x500000};
GCHECK(vk_pool_init(&dpool), "vk_pool_init of the texture detail pool");
int detail_bad = test_detail(&dpool);
vk_pool_fini(&dpool);
if (detail_bad) return 1;
VkMemStats st;
vk_mem_stats(&st);
GCHECK(st.imported_pools == 2 && st.physical_pools == 1 && st.virtual_pools == 1 && !st.import_failures,

View File

@@ -71,6 +71,7 @@ int vk_ngxfg_wanted(void); // vk_dlaa.c: DLSS's frame generation th
int vk_ngxfg_max(void); // ... and how many frames it may generate per rendered one (0: it cannot)
int vk_ffx_available(void); // vk_ffx.cpp: FSR 3.1 upscaling can run (asked without loading the library)
int vk_ffx_framegen_available(void); // ... and FSR 3.1 frame generation
int vk_texture_detail_auto(void); // vk_texture.c: the texture detail auto picks on this card, 0 full to 2 low
double frame_step_limit_hz(void);
int frame_limit_follows_display(void);
int frame_limit_adjustable(void);
@@ -672,6 +673,19 @@ static void row_shadow_res(void) {
opt_choice_list("NX2NAVI_SHADOW_RES", UI_MENU_SHADOW_RES, vals, names, N, UI_MENU_SHADOW_RES_DESC);
}
// Texture detail (vk_texture.c "texture detail"): large surface textures made without their largest one or two mip
// levels. Read when the first texture is made, so the row notes the restart. The automatic entry names the level it
// picks on this card.
static void row_texture_detail(void) {
static const char *const vals[] = {"auto", "full", "reduced", "low"};
static const UiTextId level[] = {UI_MENU_TEX_DETAIL_FULL, UI_MENU_TEX_DETAIL_REDUCED, UI_MENU_TEX_DETAIL_LOW};
static char picked[96]; // the row keeps the pointer for the frame
int a = vk_texture_detail_auto();
snprintf(picked, sizeof picked, menu_text(UI_MENU_TEX_DETAIL_AUTO), menu_text(level[a < 0 || a > 2 ? 0 : a]));
const char *names[] = {picked, menu_text(level[0]), menu_text(level[1]), menu_text(level[2])};
opt_choice_list("NX2NAVI_TEXTURE_DETAIL", UI_MENU_TEX_DETAIL, vals, names, 4, UI_MENU_TEX_DETAIL_DESC);
}
static void row_shadow_scale(void) {
static const char *const vals[] = {"1", "2", "3", "4"};
static const char *const names[] = {"960 (1x)", "1920 (2x)", "2880 (3x)", "3840 (4x)"};
@@ -1074,6 +1088,7 @@ static void tab_screen(float scale) {
static const char *const aniso[] = {"game", "2", "4", "8", "16"};
const char *aniso_names[] = {menu_text(UI_MENU_ANISO_GAME), "2x", "4x", "8x", "16x"};
opt_choice_list("NX2NAVI_ANISO", UI_MENU_ANISO, aniso, aniso_names, 5, UI_MENU_ANISO_DESC);
row_texture_detail();
opt_end();
}

View File

@@ -84,6 +84,10 @@ static const char *const text_en[UI_TEXT_COUNT] = {
[UI_MENU_ANISO] = "Texture filtering",
[UI_MENU_ANISO_DESC] = "Anisotropic filtering of surface textures: ground, roads and walls seen at a shallow angle stay sharp into the distance instead of blurring. Game: the level the game asks for, as on the Switch.",
[UI_MENU_ANISO_GAME] = "Game",
[UI_MENU_TEX_DETAIL] = "Texture detail",
[UI_MENU_TEX_DETAIL_DESC] = "Sharpness of large surface textures. Reduced and Low leave out their largest versions, so that an area fits the video memory of 6 and 8 GB cards; only surfaces seen up close look softer. Automatic picks by the card's video memory.",
[UI_MENU_TEX_DETAIL_AUTO] = "Automatic: %s",
[UI_MENU_TEX_DETAIL_FULL] = "Full", [UI_MENU_TEX_DETAIL_REDUCED] = "Reduced", [UI_MENU_TEX_DETAIL_LOW] = "Low",
[UI_MENU_FPS_BOOST] = "Experimental FPS boost",
[UI_MENU_FPS_BOOST_DESC] = "What the game's shaders write into its memory is copied back from the video card only "
"when the game's own code needs it, instead of after every step of a frame. About a "
@@ -649,6 +653,10 @@ static const char *const text_ru[UI_TEXT_COUNT] = {
[UI_MENU_ANISO] = "Фильтрация текстур",
[UI_MENU_ANISO_DESC] = "Анизотропная фильтрация текстур поверхностей: земля, дороги и стены под острым углом остаются чёткими вдали, а не размываются. Игра: уровень, который запрашивает игра, как на Switch.",
[UI_MENU_ANISO_GAME] = "Игра",
[UI_MENU_TEX_DETAIL] = "Детализация текстур",
[UI_MENU_TEX_DETAIL_DESC] = "Чёткость больших текстур поверхностей. «Сниженная» и «Низкая» не загружают их самые крупные версии, чтобы область помещалась в видеопамять карт на 6 и 8 ГБ; мягче выглядят только поверхности вблизи. «Авто» выбирает по объёму видеопамяти.",
[UI_MENU_TEX_DETAIL_AUTO] = "Авто: %s",
[UI_MENU_TEX_DETAIL_FULL] = "Полная", [UI_MENU_TEX_DETAIL_REDUCED] = "Сниженная", [UI_MENU_TEX_DETAIL_LOW] = "Низкая",
[UI_MENU_FPS_BOOST] = "Экспериментальное ускорение FPS",
[UI_MENU_FPS_BOOST_DESC] = "То, что шейдеры игры записывают в её память, копируется с видеокарты обратно только "
"тогда, когда это нужно коду самой игры, а не после каждого этапа кадра. Примерно на "
@@ -1460,6 +1468,13 @@ static const char *const text_pt_br[UI_TEXT_COUNT] = {
"ângulo raso continuam nítidos ao longe em vez de borrar. Jogo: o nível que o jogo pede, "
"como no Switch.",
[UI_MENU_ANISO_GAME] = "Jogo",
[UI_MENU_TEX_DETAIL] = "Detalhe das texturas",
[UI_MENU_TEX_DETAIL_DESC] = "Nitidez das texturas grandes de superfície. Reduzido e Baixo deixam de fora as versões "
"maiores delas, para que uma área caiba na memória de vídeo de placas de 6 e 8 GB; só as "
"superfícies vistas de perto ficam mais suaves. Automático escolhe pela memória de vídeo "
"da placa.",
[UI_MENU_TEX_DETAIL_AUTO] = "Automático: %s",
[UI_MENU_TEX_DETAIL_FULL] = "Completo", [UI_MENU_TEX_DETAIL_REDUCED] = "Reduzido", [UI_MENU_TEX_DETAIL_LOW] = "Baixo",
[UI_MENU_FPS_BOOST] = "Aumento de FPS experimental",
[UI_MENU_FPS_BOOST_DESC] = "O que os shaders do jogo escrevem na memória dele só é copiado de volta da placa de "
"vídeo quando o próprio código do jogo precisa, em vez de após cada etapa do quadro. "
@@ -2145,6 +2160,10 @@ static const char *const text_zh_hans[UI_TEXT_COUNT] = {
[UI_MENU_ANISO] = "纹理过滤",
[UI_MENU_ANISO_DESC] = "表面纹理的各向异性过滤:以小角度看到的地面、道路和墙壁在远处依然清晰,而不会模糊。游戏:使用游戏请求的级别,与 Switch 上相同。",
[UI_MENU_ANISO_GAME] = "游戏",
[UI_MENU_TEX_DETAIL] = "纹理细节",
[UI_MENU_TEX_DETAIL_DESC] = "大型表面纹理的清晰度。“降低”和“低”不加载它们最大的版本,使一个区域能放进 6 GB 和 8 GB 显卡的显存;只有近处的表面看起来略微柔和。“自动”根据显卡的显存选择。",
[UI_MENU_TEX_DETAIL_AUTO] = "自动:%s",
[UI_MENU_TEX_DETAIL_FULL] = "完整", [UI_MENU_TEX_DETAIL_REDUCED] = "降低", [UI_MENU_TEX_DETAIL_LOW] = "低",
[UI_MENU_FPS_BOOST] = "实验性帧率提升",
[UI_MENU_FPS_BOOST_DESC] = "游戏着色器写入其内存的数据,只有在游戏自身的代码需要时才从显卡复制回来,而不是在每帧的每个阶段之后都"
"复制。在大型开放区域中帧率提高约三分之一。实验性功能:开启后个别帧可能闪烁。默认关闭。",

View File

@@ -41,6 +41,9 @@ typedef enum {
UI_MENU_FOV, UI_MENU_FOV_DESC,
UI_MENU_SHADOW_RES, UI_MENU_SHADOW_RES_DESC, UI_MENU_SHADOW_RES_GAME,
UI_MENU_ANISO, UI_MENU_ANISO_DESC, UI_MENU_ANISO_GAME,
UI_MENU_TEX_DETAIL, UI_MENU_TEX_DETAIL_DESC,
UI_MENU_TEX_DETAIL_AUTO, // "Automatic: %s", %s the level it picks on this card
UI_MENU_TEX_DETAIL_FULL, UI_MENU_TEX_DETAIL_REDUCED, UI_MENU_TEX_DETAIL_LOW,
UI_MENU_FPS_BOOST, UI_MENU_FPS_BOOST_DESC,
UI_MENU_SHARPNESS, UI_MENU_SHARPNESS_DESC, UI_MENU_SHARPNESS_NEEDS_FSR,
UI_MENU_COLOR, // group heading over the colour rows

View File

@@ -474,6 +474,9 @@ typedef struct {
uint8_t scale; // 1, or NX2NAVI_SHADOW_SCALE for a shadow map made larger than the game's (vk_texture.c
// shadow_scale_of): width and height above are the larger ones, the game's regions
// are multiplied by it
uint8_t skip; // texture detail (vk_texture.c detail_skip): the game's top mip levels the image was made
// without. Image level i holds the game's level i + skip, and width, height and levels
// above are the image's, so the game's level skip is their base. 0 everywhere else.
uint8_t gone; // destroyed (vk_texture.c destroy_tex, texture lock held): the record stays readable until
// the GPU is past the submission being recorded (vk_defer_free), as the replay and DLSS
// keep pointers to render targets across a command buffer; no view of it is cached
@@ -498,6 +501,16 @@ VkSampler vk_sampler_point_by_id_locked(int id);
// The slot's sampler with its compare on, for a depth-compare read (vk_texture.c, at the definition); the slot's own
// sampler when it compares already. VK_NULL_HANDLE for an empty slot.
VkSampler vk_sampler_compare_by_id_locked(int id);
// Texture detail (vk_texture.c): what texture_detail = auto picks on this device, 0 full, 1 reduced, 2 low (the budget is
// read at the first call). For the menu's row.
int vk_texture_detail_auto(void);
// The slot's sampler for a texture made without its top `skip` mip levels (VkTexImage.skip): its LOD clamp counts the
// game's levels, so it moves down by skip. The slot's own sampler when its clamp is open or skip is 0.
VkSampler vk_sampler_detail_by_id_locked(int id, uint32_t skip);
// Slot id resolved to a texture made without its top levels, and a shader binding that reads texels by position or
// asks for the size wants it: the texture is made again with every level and stays so (vk_texture.c "texture detail").
// Returns what the slot resolves to now, as vk_texture_by_id_locked does.
const VkTexImage *vk_texture_exact_by_id_locked(int id, view_t *view, int *has_view);
uint32_t vk_texture_slots_gen(void);
int vk_texture_slot_count_locked(void);
void vk_texture_create_budget_locked(int n); // slot lookups create at most n entries (mapped storage only); -1 any

View File

@@ -653,9 +653,23 @@ static VkImageView get_view(VkExec *ex, const VkTexImage *img, const view_t *v,
}
if (!ok) return VK_NULL_HANDLE;
uint32_t l0 = hv && v->set_levels ? v->base_level : 0;
if (l0 >= img->levels) return VK_NULL_HANDLE;
uint32_t nl = hv && v->set_levels && v->nlevels ? v->nlevels : img->levels - l0;
if (l0 + nl > img->levels) nl = img->levels - l0;
uint32_t nl;
if (img->skip) {
// Texture detail (vk_texture.c): the image was made without the game's top img->skip levels, so the view's
// levels [l0, end) of the game are the image's [l0 - skip, end - skip). A view that names only levels the image
// lacks shows the first one it has: the nearest content, where a stand-in would show none.
uint32_t sk = img->skip, all = img->levels + sk;
if (l0 >= all) return VK_NULL_HANDLE;
uint32_t end = hv && v->set_levels && v->nlevels ? l0 + v->nlevels : all;
if (end > all) end = all;
l0 = l0 > sk ? l0 - sk : 0;
end = end > sk ? end - sk : 1;
nl = end > l0 ? end - l0 : 1;
} else {
if (l0 >= img->levels) return VK_NULL_HANDLE;
nl = hv && v->set_levels && v->nlevels ? v->nlevels : img->levels - l0;
if (l0 + nl > img->levels) nl = img->levels - l0;
}
if (storage) nl = 1;
uint32_t y0 = 0, ny = 1;
if (vt != VK_IMAGE_VIEW_TYPE_3D) {
@@ -1610,8 +1624,8 @@ static void feedback_written(VkExec *ex, const VkPipeState *s, uint32_t sampled)
ex->fb_read |= sampled;
}
static void tex_info_full(VkExec *ex, const GfxShaderRes *r, uint64_t h, int storage, int separate,
VkDescriptorImageInfo *out, VkImage *image);
static int tex_info_full(VkExec *ex, const GfxShaderRes *r, uint64_t h, int storage, int separate,
VkDescriptorImageInfo *out, VkImage *image);
// Sampled-texture descriptors per (handle, resource type, separate), kept while nothing they derive from changed: the
// slot's resolution and texture entry (slot_still) and the samplers (vk_sampler_gen); the layout is set again on every
@@ -1627,6 +1641,7 @@ static struct {
uint32_t gen, epoch, sgen;
uint16_t type;
uint8_t separate, valid;
uint8_t reduced; // the image was made without its top levels and the resource did not mind (GfxShaderRes.exact)
VkImage image;
VkDescriptorImageInfo out;
} TD[TD_N];
@@ -1635,11 +1650,11 @@ static void tex_info_lookup(VkExec *ex, const GfxShaderRes *r, uint64_t h, int s
VkDescriptorImageInfo *out) {
int td_on = td_mode();
VkImage image;
if (!h || storage || !td_on) return tex_info_full(ex, r, h, storage, separate, out, &image);
if (!h || storage || !td_on) return (void)tex_info_full(ex, r, h, storage, separate, out, &image);
uint32_t gen = vk_texture_slots_gen(), ep = vk_texture_epoch(), sg = vk_sampler_gen(); // before any lookup
typeof(TD[0]) *m = &TD[(h * 0x9E3779B97F4A7C15ull ^ (uint64_t)r->type << 7 ^ (uint64_t)separate) >> 51];
if (m->valid && m->h == h && m->type == r->type && m->separate == separate && m->sgen == sg &&
slot_still(&m->gen, m->tok, h, gen)) {
!(m->reduced && r->exact) && slot_still(&m->gen, m->tok, h, gen)) {
if (m->epoch != ep) { // the slot's first binding in this submission: only its storage check is due
vk_texture_by_id_locked((int)(h & 0xfffff), NULL, NULL);
m->epoch = ep;
@@ -1657,14 +1672,17 @@ static void tex_info_lookup(VkExec *ex, const GfxShaderRes *r, uint64_t h, int s
return;
}
uint64_t tok = token_of(h); // before the lookup
tex_info_full(ex, r, h, storage, separate, out, &image);
int reduced = tex_info_full(ex, r, h, storage, separate, out, &image);
// a lookup that made the texture whole again changed the slot's resolution after the stamps above were read: the
// entry never matches, and the next binding fills it
*m = (typeof(*m)){.h = h, .tok = tok, .gen = gen, .epoch = ep, .sgen = sg, .type = r->type,
.separate = (uint8_t)separate, .valid = 1, .image = image, .out = *out};
.separate = (uint8_t)separate, .valid = 1, .reduced = (uint8_t)reduced, .image = image, .out = *out};
}
static void tex_info_full(VkExec *ex, const GfxShaderRes *r, uint64_t h, int storage, int separate,
VkDescriptorImageInfo *out, VkImage *image) {
int ms = (r->type & 0x200) != 0;
// Returns whether the image bound was made without its top mip levels (texture detail, VkTexImage.skip).
static int tex_info_full(VkExec *ex, const GfxShaderRes *r, uint64_t h, int storage, int separate,
VkDescriptorImageInfo *out, VkImage *image) {
int ms = (r->type & 0x200) != 0, reduced = 0;
*image = VK_NULL_HANDLE;
VkImageView view = VK_NULL_HANDLE;
VkSampler samp = VK_NULL_HANDLE;
@@ -1673,6 +1691,10 @@ static void tex_info_full(VkExec *ex, const GfxShaderRes *r, uint64_t h, int sto
view_t v;
int hv;
const VkTexImage *img = vk_texture_by_id_locked((int)(h & 0xfffff), &v, &hv);
// A shader that reads this binding's texels by position, or asks for its size, needs every level of the
// texture where the game put it (gfx_shader.c reflect_exact): one made without its top levels is made again.
if (img && img->skip && r->exact) img = vk_texture_exact_by_id_locked((int)(h & 0xfffff), &v, &hv);
reduced = img && img->skip;
if (img) view = get_view(ex, img, &v, hv, r->type, storage), *image = img->image;
if (img && storage) vk_texture_storage_bound_locked(img);
if (img && !storage && ex->nfbl && in_fbl(ex, img->image)) layout = VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT;
@@ -1683,7 +1705,8 @@ static void tex_info_full(VkExec *ex, const GfxShaderRes *r, uint64_t h, int sto
int point = img && (img->aspect & VK_IMAGE_ASPECT_DEPTH_BIT) && !(r->type & 0x400) &&
vk_exec_view_aspect(img, &v, hv) != VK_IMAGE_ASPECT_STENCIL_BIT;
samp = point ? vk_sampler_point_by_id_locked(sid)
: r->type & 0x400 ? vk_sampler_compare_by_id_locked(sid) : vk_sampler_by_id_locked(sid);
: r->type & 0x400 ? vk_sampler_compare_by_id_locked(sid)
: reduced ? vk_sampler_detail_by_id_locked(sid, img->skip) : vk_sampler_by_id_locked(sid);
}
}
if (!view) {
@@ -1692,6 +1715,7 @@ static void tex_info_full(VkExec *ex, const GfxShaderRes *r, uint64_t h, int sto
}
if (!samp) samp = r->type & 0x400 ? Z.samp_shadow : Z.samp;
*out = (VkDescriptorImageInfo){separate || storage ? VK_NULL_HANDLE : samp, view, layout};
return reduced;
}
// ---- texture and sampler pools (bindless)

View File

@@ -107,9 +107,11 @@ typedef struct {
view_t v;
tex_t t;
} TexSlot;
typedef struct { samp_par p; VkSampler s, sp, sc; uint8_t used; } SampSlot; // s: vk_sampler_for(&p) once looked up; sp:
typedef struct { samp_par p; VkSampler s, sp, sc, sd[2]; uint8_t used; } SampSlot; // s: vk_sampler_for(&p) once looked up; sp:
// its point-sampled form (vk_sampler_point_by_id_locked),
// sc its comparing form (vk_sampler_compare_by_id_locked)
// sc its comparing form (vk_sampler_compare_by_id_locked),
// sd[n - 1] its form for a texture made without n
// levels (vk_sampler_detail_by_id_locked)
static PlatRMutex tex_lock;
static PlatOnce tex_once = PLAT_ONCE_INIT;
@@ -691,6 +693,104 @@ static void astc_probe_alpha(const tex_t *t, const TexVkFormat *f) {
(unsigned long long)n_probe_alpha, n_probe_bytes_alpha / 1048576.0);
}
// ---- texture detail (NX2NAVI_TEXTURE_DETAIL = auto | full | reduced | low, texture_detail in nx2navi.ini; read at
// the first texture, so a change waits for a restart)
// The material textures of a loaded area are what fills a small card, and three quarters of a mipmapped texture is its
// largest level. Over the budget Windows moves device memory into system memory and the frame rate falls to a
// fraction (a tester's RTX 3060 Laptop, 6 GiB with a budget of 4,730 MiB, ran the world at 5 to 15 fps).
//
// Measured on an RTX 5090 with the budget taken as those 4,730 MiB (NX2NAVI_VRAM_BUDGET_MB), a walk through Castle
// Town at 1440p with DLSS Balanced, device memory in use at its peak and the textures in it:
// full 6,907 MiB, textures 4,302 MiB (2,852 MiB of them ASTC as BC3), 2,589 M ASTC texels decoded
// reduced 5,472 MiB, textures 2,357 MiB (908 MiB), 826 M texels
// low 4,987 MiB, textures 1,997 MiB (548 MiB), 503 M texels
// About 1.1 GiB of each is outside the textures and buffers (DLSS alone reports 0.7 GiB). What a level does not touch
// stays: about 0.8 GiB of BC4, BC5 and BC7 textures the game ships in those formats, 0.65 GiB of render targets and
// 0.9 GiB of buffer mirrors.
//
// reduced makes such a texture without its largest level, low without its two largest when it is 1024x1024 or more
// (detail_skip decides). The image then holds the game's levels from VkTexImage.skip on: image level i is the game's
// level i + skip, at that level's own size, so a level and a texel rectangle inside it mean the same in both and only
// the level index moves. Every path from a game level to the image subtracts skip: the upload and its ASTC regions
// (upload, astc_bl_regions), WriteTexels and the write-back (image_texels, write_back_n), the views (vk_exec_draw.c
// get_view) and the sampler's LOD clamp (vk_sampler_detail_by_id_locked). Shaders sample with normalised coordinates
// and derivatives, which pick the same game level as before wherever it is kept.
//
// Only a texture for which that holds is reduced: an ASTC texture this runtime decodes (not one the device samples as
// ASTC, whose copies run on the image, vk_exec_xfer.c sub_resolve), a 2D texture or 2D array, block-linear, one
// sample, mipmapped, DETAIL_MIN texels or more each way, whose content the CPU provides (tex_mirrored). That leaves
// out render targets and storage images (no ASTC format can be either), 3D and cube textures, the small and unmipped
// ones (interface art, glyph atlases, lookup tables, ramps) and whatever the GPU copies, as texture copies of a
// decoded ASTC texture are not replayed at all. Two more are left whole:
// - a texture made over a live one that holds GPU-written content, which start_at copies in texel for texel;
// - a texture a shader reads by texel position or whose size it asks for (exact, below): a fetch at a level the image
// lacks, or coordinates worked out from the size of another texture, would read the wrong texels. The translated
// shaders do that only through fixed bindings (gfx_shader.c reflect_exact; none of 44,081 prepared shaders of game
// 1.1.1 does it through the texture pool), so the replay sees the texture at the binding and asks for it whole
// (vk_texture_exact_by_id_locked). The key then stays whole for the session.
// The size of a 2D array is also asked for by the layer clamp the translator puts before array samples; that reads
// the layer count alone, which no level changes, and does not count (reflect_exact).
//
// auto: full from DETAIL_FULL_MB of device-local budget on, low under DETAIL_LOW_MB, reduced between. Textures give
// way from 80% of the budget on (sweep_pressure), so a level wants its use at or under that: full, 6.9 to 7.5 GiB in
// the town and in Hyrule Field, on cards of 10 GiB and more (their budgets start near 9 GiB; an 8 GiB card's is about
// 7.2 GiB); reduced, 5.5 GiB, on 8 GiB cards; and every 6 GiB card, whose budget stays under 5.5 GiB, gets low.
#define DETAIL_MIN 256
#define DETAIL_LOW_MIN 1024
#define DETAIL_FULL_MB 8192
#define DETAIL_LOW_MB 6144
#define EXACT_MAX 65536
static nvn_hmap exact = {.klen = sizeof(TexKey)}; // keys made whole whatever the setting; value 1
static uint64_t n_exact; // textures made whole again so far
static int alias_has_gpu_content(const struct Tex *src);
static int64_t detail_budget_mb = -1; // the device-local budget auto went by, in MiB; 0: the device reports none
int vk_texture_detail_auto(void) {
int64_t mb = __atomic_load_n(&detail_budget_mb, __ATOMIC_RELAXED);
if (mb < 0 && !vk_ctx()) return 0; // asked before there is a device: nothing is kept
if (mb < 0) { // read once: the budget moves with what else uses the card, the choice must not
uint64_t used = 0, budget = 0;
int exact_budget = 0;
mb = vk_mem_vram(&used, &budget, &exact_budget) ? (int64_t)(budget >> 20) : 0;
__atomic_store_n(&detail_budget_mb, mb, __ATOMIC_RELAXED);
}
return !mb || mb >= DETAIL_FULL_MB ? 0 : mb >= DETAIL_LOW_MB ? 1 : 2;
}
static int detail_most(void) { // the most levels a texture is made without: 0 full, 1 reduced, 2 low
static const char *const names[3] = {"full", "reduced", "low"};
static int most = -1;
if (most >= 0) return most;
const char *v = cfg_value("NX2NAVI_TEXTURE_DETAIL");
most = !strcmp(v, "full") ? 0 : !strcmp(v, "reduced") ? 1 : !strcmp(v, "low") ? 2 : -1;
if (most >= 0) {
rt_log("vk: texture detail: %s (texture_detail)", v);
} else {
most = vk_texture_detail_auto();
if (!detail_budget_mb)
rt_log("vk: texture detail: full (texture_detail = %s; the device reports no video memory budget)", v);
else
rt_log("vk: texture detail: %s, chosen for a video memory budget of %lld MiB (texture_detail = %s; full from "
"%d MiB, low under %d MiB)", names[most], (long long)detail_budget_mb, v, DETAIL_FULL_MB, DETAIL_LOW_MB);
}
return most;
}
// The top mip levels the image of t is made without (the rule above). w, h, levels: the image as it would be whole.
static uint32_t detail_skip(const tex_t *t, const TexKey *k, const TexVkFormat *f, uint32_t w, uint32_t h, uint32_t levels,
uint32_t samples) {
int most = detail_most();
const nvn_texdesc *d = &t->d;
if (!most || !f->astc_bw || samples > 1 || levels < 2 || w < DETAIL_MIN || h < DETAIL_MIN) return 0;
if ((d->target != NVN_TEXTURE_TARGET_2D && d->target != NVN_TEXTURE_TARGET_2D_ARRAY) || nvn_tex_is_linear(d)) return 0;
if (!tex_mirrored(t) || (exact.n && nvn_hm_get(&exact, k))) return 0;
for (const struct Tex *p = nvn_hm_get(&by_addr, &k->addr); p; p = p->next_at)
if (!p->released && alias_has_gpu_content(p)) return 0;
return most >= 2 && levels >= 4 && w >= DETAIL_LOW_MIN && h >= DETAIL_LOW_MIN ? 2 : 1;
}
// defer_init: the caller records the image's first transition (init_image or alias_copy).
static Tex *create_tex(const tex_t *t, const TexKey *k, int defer_init) {
static volatile int32_t n_unmapped, n_unsupported, n_failed, n_unbound, n_thick;
@@ -729,6 +829,8 @@ static Tex *create_tex(const tex_t *t, const TexKey *k, int defer_init) {
if (levels > most) levels = most;
uint32_t samples = d->samples > 1 ? (uint32_t)d->samples : 1;
if (samples > 1) levels = 1;
uint32_t skip = detail_skip(t, k, &f, w, h, levels, samples); // texture detail: the image starts at this level
if (skip) w = mip(w, skip), h = mip(h, skip), levels -= skip;
VkFormatFeatureFlags ff = features_of(f.vk);
VkImageUsageFlags usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
int ds = f.depth || f.stencil;
@@ -934,6 +1036,7 @@ static Tex *create_tex(const tex_t *t, const TexKey *k, int defer_init) {
p->block_views = (uint8_t)block_views;
p->fb_usage = (uint8_t)fb_usage;
p->scale = (uint8_t)scale;
p->skip = (uint8_t)skip;
if (!defer_init) init_new(e);
return e;
@@ -1731,7 +1834,8 @@ static uint64_t content_hash(const void *p, uint64_t n) {
// The CPU deswizzle moved every 16 bytes through the GOB arithmetic and was most of an ASTC upload's CPU time when an
// area loads. Fills ar (n = levels * layers, level-major as upload's regions) and returns 1 when every level and layer
// qualifies: block-linear, starting 16-byte aligned, its layout inside the storage. NX2NAVI_ASTC_GPU_DESWIZZLE=0 keeps
// the CPU deswizzle.
// the CPU deswizzle. levels counts the image's levels: level lv of the image is the game's level lv + skip (texture
// detail), which is where its blocks lie and what its size is.
static int astc_bl_regions(const Tex *e, uint32_t levels, uint32_t layers, int bw, int bh, VkAstcRegion *ar) {
static int on = -1;
if (on < 0) {
@@ -1740,16 +1844,16 @@ static int astc_bl_regions(const Tex *e, uint32_t levels, uint32_t layers, int b
}
const nvn_texdesc *d = &e->t.d;
if (!on || nvn_tex_is_linear(d)) return 0;
uint32_t k = 0;
uint32_t k = 0, sk = e->pub.skip;
for (uint32_t lv = 0; lv < levels; lv++)
for (uint32_t ly = 0; ly < layers; ly++) {
uint32_t row_bytes, rows, slices, bpb;
uint64_t base;
unsigned th, td;
if (nvn_deswizzle_geom(d, lv, ly, &row_bytes, &rows, &slices, &base, &th, &td, &bpb) || (base & 15) || th > 5 ||
td > 5)
if (nvn_deswizzle_geom(d, lv + sk, ly, &row_bytes, &rows, &slices, &base, &th, &td, &bpb) || (base & 15) ||
th > 5 || td > 5)
return 0;
ar[k] = (VkAstcRegion){.src = base, .w = mip(d->width, lv), .h = mip(d->height, lv), .slices = slices,
ar[k] = (VkAstcRegion){.src = base, .w = mip(d->width, lv + sk), .h = mip(d->height, lv + sk), .slices = slices,
.level = lv, .layer = ly, .bl = 1, .th = (uint8_t)th, .td = (uint8_t)td};
if (base + vk_astc_region_bytes(&ar[k], (uint32_t)bw, (uint32_t)bh) > e->t.L.size) return 0;
k++;
@@ -1773,7 +1877,9 @@ static int astc_arena(void) {
return on;
}
// Copies the whole storage into the image (every level and layer the image has).
// Copies the whole storage into the image (every level and layer the image has). An image made without its top levels
// (texture detail, VkTexImage.skip) has the game's level lv + skip at its level lv: the loops below run over the image's
// levels and read the storage at the game's.
static void upload(Tex *e) {
static volatile int32_t n_bad, n_undecoded, n_split;
const tex_t *t = &e->t;
@@ -1799,20 +1905,23 @@ static void upload(Tex *e) {
uint32_t levels = linear ? 1 : e->pub.levels, layers = linear ? 1 : e->pub.layers;
int astc = e->f.astc_bw != 0, rgb = e->f.expand_rgb;
int agpu = astc && vk_astc_gpu(), acheck = agpu && vk_astc_mode() == VK_ASTC_CHECK; // raw blocks to the GPU
uint32_t n = levels * layers, k = 0;
uint32_t n = levels * layers, k = 0, sk = linear ? 0 : e->pub.skip;
VkBufferImageCopy *rg = calloc(n, sizeof *rg);
VkAstcRegion *ar = agpu ? calloc(n, sizeof *ar) : NULL;
VkDeviceSize total = 0, decoded = 0;
uint64_t src_bytes = 0; // the storage bytes the image's levels take (all of the storage unless levels are left out)
for (uint32_t lv = 0; lv < levels; lv++)
for (uint32_t ly = 0; ly < layers; ly++) {
uint32_t w = mip(d->width, lv), h = one_d ? 1 : mip(d->height, lv), sl = is3d ? mip(d->depth, lv) : 1;
uint32_t w = mip(d->width, lv + sk), h = one_d ? 1 : mip(d->height, lv + sk), sl = is3d ? mip(d->depth, lv + sk) : 1;
uint64_t texels = (uint64_t)w * h * sl, raw = (uint64_t)(w + bw - 1) / bw * bpb * ((h + bh - 1) / bh) * sl;
uint64_t out = agpu ? raw : astc ? texels * 4 : rgb ? texels * (uint64_t)bpb / 3 * 4 : raw;
rg[k++] = (VkBufferImageCopy){.bufferOffset = total, .imageSubresource = {e->pub.aspect, lv, ly, 1},
.imageExtent = {w, h, sl}};
total += (out + 15) & ~15ull;
decoded += texels * 4;
src_bytes += raw;
}
if (!sk) src_bytes = t->L.size;
VkBuffer sb, rbuf = VK_NULL_HANDLE;
VmaAllocation ralloc = NULL;
uint8_t *rmap = NULL, *raw_copy = NULL;
@@ -1827,6 +1936,14 @@ static void upload(Tex *e) {
for (k1 = k0 + 1; k1 < n && (agpu || (k1 + 1 < n ? rg[k1 + 1].bufferOffset : total) - base <= UPLOAD_PART);) k1++;
size = (k1 < n ? rg[k1].bufferOffset : total) - base;
if (gdsw) size = t->L.size; // the storage as it is (one part: the GPU decoder takes every region at once)
// Without its top levels, only the levels the image has: each region's blocks as they lie in the storage, one
// after the other (the top level is three quarters of the bytes, and an array keeps each layer's levels
// together, so the kept levels are no single range).
if (gdsw && sk) {
size = 0;
for (k = 0; k < n; k++) size += vk_astc_region_bytes(&ar[k], (uint32_t)bw, (uint32_t)bh);
src_bytes = size;
}
if (k0) parts++;
VkCommandBuffer cb = vk_upload_begin();
// The part stages in a range of the staging arena (vk_staging_at, its offset added to the regions below), or in
@@ -1850,9 +1967,17 @@ static void upload(Tex *e) {
log_limited(&n_gone, "texture %#llx (%llu bytes): storage released during the upload; uploaded as zeros",
(unsigned long long)e->pub.addr, (unsigned long long)e->t.L.size);
}
if (gdsw) {
if (gdsw && !sk) {
if (held) memcpy(stg, t->mem, size);
else memset(stg, 0, size);
} else if (gdsw) {
VkDeviceSize at = 0;
for (k = 0; k < n; k++) { // astc_bl_regions checked that each lies inside the storage
VkDeviceSize nb = vk_astc_region_bytes(&ar[k], (uint32_t)bw, (uint32_t)bh);
if (held) memcpy(stg + at, t->mem + ar[k].src, nb);
else memset(stg + at, 0, nb);
ar[k].src = at, at += nb;
}
}
for (k = k0; k < k1 && !gdsw; k++) {
uint32_t lv = rg[k].imageSubresource.mipLevel, ly = rg[k].imageSubresource.baseArrayLayer;
@@ -1864,9 +1989,9 @@ static void upload(Tex *e) {
tmps[k - k0] = tmp;
if (!held) {
memset(tmp ? tmp : dst, 0, raw);
} else if (nvn_deswizzle(d, lv, ly, t->mem, tmp ? tmp : dst, rb)) {
} else if (nvn_deswizzle(d, lv + sk, ly, t->mem, tmp ? tmp : dst, rb)) {
log_limited(&n_bad, "texture %#llx fmt %#x target %d: level %u layer %u has no CPU layout; uploaded as zeros",
(unsigned long long)e->pub.addr, d->format, d->target, lv, ly);
(unsigned long long)e->pub.addr, d->format, d->target, lv + sk, ly);
memset(tmp ? tmp : dst, 0, raw);
}
}
@@ -1938,13 +2063,13 @@ static void upload(Tex *e) {
uint64_t dt = kern_now_ns() - u0;
if (e->uploaded) {
n_reuploads++, perf_count(PERF_CNT_TEX_REUP);
ru_n++, ru_bytes += t->L.size, ru_ns += dt;
ru_n++, ru_bytes += src_bytes, ru_ns += dt;
if (e->wt_n) {
ru_wt_n++, ru_wt_bytes += t->L.size, ru_wt_ns += dt;
ru_wt_n++, ru_wt_bytes += src_bytes, ru_wt_ns += dt;
if (rt_trace & RT_TRACE_PERF)
rt_log("perf: frame %llu: re-upload after %u WriteTexels: texture %#llx fmt %#x %ux%u, %.1f KiB, %.3f ms",
(unsigned long long)__atomic_load_n(&gfx_counters.frames, __ATOMIC_RELAXED), e->wt_n,
(unsigned long long)e->pub.addr, d->format, d->width, d->height, t->L.size / 1024.0, dt / 1e6);
(unsigned long long)e->pub.addr, d->format, d->width, d->height, src_bytes / 1024.0, dt / 1e6);
}
} else {
n_uploads++, perf_count(PERF_CNT_TEX_UP);
@@ -1954,7 +2079,7 @@ static void upload(Tex *e) {
e->n_up++;
perf_end(PERF_TEX, p0);
vk_texstat_time(VK_TS_UPLOAD, u0);
vk_texstat_add(VK_TS_UPLOAD, 0, t->L.size);
vk_texstat_add(VK_TS_UPLOAD, 0, src_bytes);
}
// Whether e's storage fills no 4 KiB page of its own, so the write tracking can only see writes to pages it shares.
@@ -2049,6 +2174,7 @@ static int alias_compatible(const Tex *e, const Tex *src, const char **why) {
if (e->f.depth || e->f.stencil || src->f.depth || src->f.stencil || p->samples > 1 || q->samples > 1)
return *why = "depth, stencil or multisample", 0;
if (p->type != q->type) return *why = "another image type", 0;
if (p->skip || q->skip) return *why = "made without its top levels (texture detail)", 0; // level i is not level i
if (nvn_tex_is_linear(&e->t.d) != nvn_tex_is_linear(&src->t.d)) return *why = "linear and block-linear", 0;
int ew, eh, sw, sh, eb = img_block(e, &ew, &eh), sb = img_block(src, &sw, &sh);
if (!eb || eb != sb || ew != sw || eh != sh) return *why = "another block size", 0;
@@ -2367,6 +2493,12 @@ void vk_texture_gpu_written(const tex_t *t) {
}
e->pub.gpu_owned = 1;
e->chash_ok = 0; // the image now holds the GPU's content: matching storage bytes no longer mean "unchanged"
if (e->pub.skip) { // texture detail leaves out what the GPU can write (detail_skip); said if it ever does
static volatile int32_t n_skip_written;
log_limited(&n_skip_written, "texture %#llx (fmt %#x %ux%u), made without its top %u levels, was written by "
"the GPU: its levels are not the game's", (unsigned long long)e->pub.addr, e->t.d.format,
e->t.d.width, e->t.d.height, e->pub.skip);
}
uint64_t f = vk_exec_recording_fence();
if (f > e->wr_fence) e->wr_fence = f;
if (e->pub.mirrored) {
@@ -2683,6 +2815,27 @@ const VkTexImage *vk_texture_by_id_locked(int id, view_t *view, int *has_view) {
return e ? &e->pub : NULL;
}
// Texture detail: the texture slot id resolves to was made without its top levels, and a shader binding reads its
// texels by position or asks for its size (vk_exec_draw.c tex_info_full, GfxShaderRes.exact). Its key joins exact, the
// entry goes and the lookup makes it again whole, uploaded from its storage as a texture seen for the first time. A
// lookup that is out of its creation budget leaves the stand-in for now, as for any new texture. Texture lock held.
const VkTexImage *vk_texture_exact_by_id_locked(int id, view_t *view, int *has_view) {
if (id < 0 || id >= ntslots || !tslots[id].used) return NULL;
TexSlot *s = &tslots[id];
Tex *e = s->ce && s->cgen == agen[sinfo[id] & 0xffff] ? s->ce : NULL; // what the caller's lookup just resolved
if (e && e->pub.skip) {
if (exact.n >= EXACT_MAX) nvn_hm_clear(&exact, NULL); // never seen; they would be found again one by one
nvn_hm_put(&exact, &e->key, (void *)(uintptr_t)1);
n_exact++;
static volatile int32_t n_logged;
log_limited(&n_logged, "texture detail: texture %#llx (fmt %#x %ux%u, %u levels) is read by texel position or its "
"size is asked for: made whole again (%llu so far)", (unsigned long long)e->pub.addr, e->t.d.format,
e->t.d.width, e->t.d.height, e->pub.levels + e->pub.skip, (unsigned long long)n_exact);
destroy_tex(e);
}
return vk_texture_by_id_locked(id, view, has_view);
}
// vk_dump: the swizzle selectors of the descriptor registered in slot id; 0 when the slot is empty.
int vk_texture_slot_swz(int id, uint8_t swz[4]) {
lock();
@@ -2814,8 +2967,8 @@ static int texels_read_record(Tex *e, const Region *g, const NVNcopyRegion *r, T
log_limited(&n_ds, "texels of packed depth-stencil format %#x are not copied", e->t.d.format);
return 0;
}
if (g->level >= e->pub.levels) return 0;
uint32_t w = (uint32_t)r->width, h = (uint32_t)r->height;
if (g->level < e->pub.skip || g->level - e->pub.skip >= e->pub.levels) return 0; // a level the image lacks
uint32_t w = (uint32_t)r->width, h = (uint32_t)r->height, il = g->level - e->pub.skip;
t->w = w;
t->ib = e->f.expand_rgb ? (size_t)g->bpb / 3 * 4 : 0;
t->slice = t->ib ? (size_t)w * h * t->ib : g->wb * g->hb;
@@ -2824,7 +2977,7 @@ static int texels_read_record(Tex *e, const Region *g, const NVNcopyRegion *r, T
if (!rg) rt_fatal("vk: out of memory for a texture read");
for (int z = 0; z < g->nz; z++)
rg[z] = (VkBufferImageCopy){.bufferOffset = t->slice * (size_t)z,
.imageSubresource = {aspect, g->level, g->is3d ? 0 : g->layer0 + (uint32_t)r->zoffset + (uint32_t)z, 1},
.imageSubresource = {aspect, il, g->is3d ? 0 : g->layer0 + (uint32_t)r->zoffset + (uint32_t)z, 1},
.imageOffset = {r->xoffset, r->yoffset, g->is3d ? r->zoffset + z : 0},
.imageExtent = {w, h, 1}};
VkCommandBuffer cb = vk_upload_begin();
@@ -2867,7 +3020,11 @@ static int image_texels(Tex *e, const Region *g, const NVNcopyRegion *r, uint8_t
log_limited(&n_ds, "texels of packed depth-stencil format %#x are not copied", e->t.d.format);
return 0;
}
if (g->level >= e->pub.levels) return 0;
// Texture detail: a level the image was made without takes no texels (the storage holds them, vk_write_texels); the
// others are the image's level g->level - skip, the rectangle unchanged.
if (g->level < e->pub.skip) return 1;
uint32_t il = g->level - e->pub.skip;
if (il >= e->pub.levels) return 0;
uint32_t w = (uint32_t)r->width, h = (uint32_t)r->height;
int rgb = e->f.expand_rgb, astc = e->f.astc_bw != 0, agpu = astc && vk_astc_gpu();
size_t texels = (size_t)w * h, ib = agpu ? 0 : astc ? 4 : rgb ? (size_t)g->bpb / 3 * 4 : 0;
@@ -2894,7 +3051,7 @@ static int image_texels(Tex *e, const Region *g, const NVNcopyRegion *r, uint8_t
for (size_t y = 0; y < g->hb; y++) memcpy(s + y * g->wb, m + y * g->row, g->wb);
}
rg[z] = (VkBufferImageCopy){.bufferOffset = slice * (size_t)z,
.imageSubresource = {aspect, g->level, g->is3d ? 0 : g->layer0 + (uint32_t)r->zoffset + (uint32_t)z, 1},
.imageSubresource = {aspect, il, g->is3d ? 0 : g->layer0 + (uint32_t)r->zoffset + (uint32_t)z, 1},
.imageOffset = {r->xoffset, r->yoffset, g->is3d ? r->zoffset + z : 0},
.imageExtent = {w, h, 1}};
}
@@ -3017,8 +3174,8 @@ static void write_back_n(Tex **v, int n) {
Tex *e = v[i];
const nvn_texdesc *d = &e->t.d;
int linear = nvn_tex_is_linear(d), is3d = d->target == NVN_TEXTURE_TARGET_3D;
uint32_t levels = linear ? 1 : e->pub.levels, layers = linear || is3d ? 1 : e->pub.layers;
for (uint32_t lv = 0; lv < levels; lv++)
uint32_t levels = linear ? 1 : e->pub.levels + e->pub.skip, layers = linear || is3d ? 1 : e->pub.layers;
for (uint32_t lv = linear ? 0 : e->pub.skip; lv < levels; lv++) // the game's levels the image holds
for (uint32_t ly = 0; ly < layers; ly++) {
if (np == cap) {
cap = cap ? cap * 2 : 16;
@@ -3348,7 +3505,7 @@ void vk_sampler_register(int id, const samp_par *s) {
sslots = p, nsslots = n;
}
sslots[id].p = *s;
sslots[id].s = sslots[id].sp = sslots[id].sc = VK_NULL_HANDLE;
sslots[id].s = sslots[id].sp = sslots[id].sc = sslots[id].sd[0] = sslots[id].sd[1] = VK_NULL_HANDLE;
sslots[id].used = 1;
samp_gen++;
unlock();
@@ -3370,7 +3527,8 @@ void vk_sampler_dlss_bias(float b) {
rt_log("vk: texture LOD bias %.2f on the scene's tiled textures (the upscaler's render scale; was %.2f)", b,
dlss_bias);
dlss_bias = b;
for (int i = 0; i < nsslots; i++) sslots[i].s = sslots[i].sp = sslots[i].sc = VK_NULL_HANDLE; // looked up again (the key moves)
for (int i = 0; i < nsslots; i++) // looked up again (the key moves)
sslots[i].s = sslots[i].sp = sslots[i].sc = sslots[i].sd[0] = sslots[i].sd[1] = VK_NULL_HANDLE;
samp_gen++;
}
unlock();
@@ -3391,7 +3549,8 @@ void vk_sampler_aniso_live(void) {
if (sf.init && a != sf.aniso) {
sf.aniso = a;
aniso_log();
for (int i = 0; i < nsslots; i++) sslots[i].s = sslots[i].sp = sslots[i].sc = VK_NULL_HANDLE; // looked up again (the key moves)
for (int i = 0; i < nsslots; i++) // looked up again (the key moves)
sslots[i].s = sslots[i].sp = sslots[i].sc = sslots[i].sd[0] = sslots[i].sd[1] = VK_NULL_HANDLE;
samp_gen++;
}
unlock();
@@ -3474,6 +3633,35 @@ VkSampler vk_sampler_compare_by_id_locked(int id) {
return s->sc;
}
// Texture detail: a texture made without its top `skip` levels has the game's level i + skip at its level i, and the
// LOD the device works out for it is the game's less skip, so the level a sample lands on is the game's wherever that
// level is kept. A sampler's LOD clamp counts the game's levels and has to move down with them: a clamp to levels 0-2
// left alone would let the image's level 2 through, the game's level 4. The bias is relative and stays. A clamp that is
// open (from 0, up to more levels than a texture has) is the same sampler. Only draws that bind texture and sampler
// as one resource come here (vk_exec_draw.c tex_info_full); the sampler pool's entries serve every texture and keep
// the game's clamp.
VkSampler vk_sampler_detail_by_id_locked(int id, uint32_t skip) {
VkCtx *c = vk_ctx();
if (!skip || skip > 2) return vk_sampler_by_id_locked(id);
if (!c || id < 0 || id >= nsslots || !sslots[id].used) return VK_NULL_HANDLE;
SampSlot *s = &sslots[id];
if (!s->sd[skip - 1]) {
samp_par k = s->p;
if (k.lod_min > 0) k.lod_min = fmaxf(k.lod_min - (float)skip, 0);
if (k.lod_max < 32) k.lod_max = fmaxf(k.lod_max - (float)skip, 0); // 32 and more: above any texture's last level
if (k.lod_min == s->p.lod_min && k.lod_max == s->p.lod_max) {
s->sd[skip - 1] = vk_sampler_by_id_locked(id);
} else {
static int told; // a clamp that leaves levels out; one up to a texture's last level changes nothing
if ((s->p.lod_min > 0 || s->p.lod_max < 8) && told++ < 8)
rt_log("vk: texture detail: sampler slot %d clamps the LOD to %g..%g; %g..%g for a texture made without %u "
"levels", id, s->p.lod_min, s->p.lod_max, k.lod_min, k.lod_max, skip);
s->sd[skip - 1] = sampler_for(c, &k);
}
}
return s->sd[skip - 1];
}
VkSampler vk_sampler_by_id(int id) {
lock();
VkSampler v = vk_sampler_by_id_locked(id);
@@ -3527,6 +3715,7 @@ void vk_texture_census_log(uint64_t frame) {
enum { K_BC3, K_RGBA8, K_CPU, K_GPU, K_N };
static const char *const kn[K_N] = {"ASTC as BC3", "ASTC as RGBA8", "other CPU-written", "GPU-written"};
uint64_t n[K_N] = {0}, b[K_N] = {0}, in[K_N] = {0}, ib[K_N] = {0}, bound = 0, dup_n = 0, dup_b = 0;
uint64_t sk_n[3] = {0}, sk_b[3] = {0}; // texture detail: entries made without 1 and 2 levels, and their memory
struct { int fmt; uint64_t n, b; } fm[48];
int nfm = 0;
struct { uint64_t b; uint32_t w, h, d, levels; int fmt, gpu; } big[4] = {{0}}; // copied: read after unlock
@@ -3541,6 +3730,7 @@ void vk_texture_census_log(uint64_t frame) {
if (!e->bytes) { bound += e->bound_to != NULL; continue; }
int k = !comes_back_intact(e) ? K_GPU : e->f.astc_bw ? (e->f.astc_bc ? K_BC3 : K_RGBA8) : K_CPU;
n[k]++, b[k] += e->bytes;
if (e->pub.skip < 3) sk_n[e->pub.skip]++, sk_b[e->pub.skip] += e->bytes;
if (idle(e, now)) in[k]++, ib[k] += e->bytes;
int j = 0;
while (j < nfm && fm[j].fmt != (int)e->f.vk) j++;
@@ -3586,8 +3776,13 @@ void vk_texture_census_log(uint64_t frame) {
for (int k = 0; k < K_N; k++)
o += snprintf(line + o, sizeof line - (size_t)o, " %s %llu %.0f MiB (%llu %.0f MiB);", kn[k], (unsigned long long)n[k],
b[k] / M, (unsigned long long)in[k], ib[k] / M);
snprintf(line + o, sizeof line - (size_t)o, " bound into pool memory %llu; sharing an address with another %llu %.0f MiB",
(unsigned long long)bound, (unsigned long long)dup_n, dup_b / M);
o += snprintf(line + o, sizeof line - (size_t)o, " bound into pool memory %llu; sharing an address with another %llu %.0f MiB",
(unsigned long long)bound, (unsigned long long)dup_n, dup_b / M);
if (detail_most()) // nothing more in the line at full detail
snprintf(line + o, sizeof line - (size_t)o, "; texture detail: made without their top level %llu %.0f MiB, without "
"two %llu %.0f MiB, made whole again for a shader %llu (%u shaders loaded read a texture by texel "
"position or size)", (unsigned long long)sk_n[1], sk_b[1] / M, (unsigned long long)sk_n[2], sk_b[2] / M,
(unsigned long long)n_exact, gfx_shader_exact_seen());
rt_log("%s", line);
for (int x = 0; x < nfm; x++) // by bytes, largest first
for (int y = x + 1; y < nfm; y++)