Files
Triforce-Source/gpu/vk/bc_scratch.h
ruckus7382sfgsgdf e6f2f248f2 Triforce v0.7.0 "Sage Of Courage"
The 0.6 crashes after warps and area changes fixed (no write-back into memory the capture leaves out), invisible objects fixed (occlusion gate), DLSS frame generation flicker fixed, achievements, the renderer built with a play profile, faster translated game code, helper threads judged on settled scenes, memory, shader preparation, audio effects, launcher, controls and Linux fixes.
2026-11-22 11:59:06 -06:00

67 lines
4.5 KiB
C++

// (Triforce, 11-21, the performance audit's TEX-10, after Source A's) How many layers the BC3 scratch has.
//
// Big ASTC textures are decoded into a 2048 x 2048 RGBA8 scratch and encoded again as BC3 on the GPU, into an output
// buffer. Both were made with 8 layers, 128 + 32 = 160 MB (and the second scratch of the textures encoded at another
// size, 128 MB more), whatever a run used; and a run decodes one layer (RX_VK_BC_LAYERS, the dark-line fix), so 140 MB
// were held and never written, for good once made (RX_VK_BC_IDLE_S is 0). Sized by the layers one run uses they are
// 16 + 4 = 20 MB. Source A measured 139 MiB less GPU memory on a Steam Deck, the median of 7 pairs, at the same fps.
// RX_VK_BC_SCRATCH_FULL=1: all 8 layers, as before.
//
// The rule alone, no Vulkan: tests/test_bc_scratch_layers.py compiles it.
#pragma once
#include <algorithm>
#include <cstdint>
#include <cstdlib>
namespace bc_scratch {
inline constexpr uint32_t kDim = 2048, kMost = 8; // (the largest level a BC3 texture may have; the most layers a run may take)
/// The layers one run decodes and encodes: RX_VK_BC_LAYERS's value, 1 to kMost; not set, or not a number, 1
inline uint32_t run_layers(const char* asked) {
return asked ? std::clamp<uint32_t>((uint32_t)std::max(atoi(asked), 0), 1u, kMost) : 1u;
}
/// The scratch's layers: a run's, or all of them when full (RX_VK_BC_SCRATCH_FULL)
inline uint32_t layers(uint32_t run, bool full) { return full ? kMost : std::clamp(run, 1u, kMost); }
/// The output buffer's bytes: BC3's 16 bytes a block of 4 x 4, every layer
inline uint64_t out_bytes(uint32_t layers) { return (uint64_t)(kDim / 4) * (kDim / 4) * layers * 16; }
/// What the scratch holds, in MB: the image and its output buffer, and the second image when there is one
inline uint64_t mb(uint32_t layers, bool second) {
const uint64_t image = (uint64_t)kDim * kDim * 4 * layers;
return (image + out_bytes(layers) + (second ? image : 0)) >> 20;
}
// ---- (Triforce, 11-21, the performance audit's TEX-09, after Source A's) the small scratch ----
// A run is a decode, an encode, a copy and three full barriers, and one layer a run made a 1365 x 1365 x 90 terrain array
// of 11 levels about 990 of them: the GPU spent most of that time between the runs (Source A, Hyrule Field's entry on an
// RX 9070 XT: 50 ms of GPU an array at one layer a run, 16-17 ms at 8; the lab's own array took 114.8 ms of an RTX 5090 in
// one upload command buffer). Levels of kSmallDim or less each way, the arrays' second level down, go small_layers() layers
// a run through a scratch of their own, kSmallDim x kSmallDim x 8: 32 MB, and the output buffer 8 MB for 4. One layer a
// run was for dark lines between Hyrule Field's ground tiles on an RX 6600, layers after a run's first wrong at the small
// levels, cause never found: so on AMD's cards the default stays 1 until the picture is checked there, and each layer of a
// run is copied by a region of its own, at the encoder's own layer stride. A level of a texture encoded at another size
// keeps the first scratch. RX_VK_BC_SMALL_LAYERS=<n>: the layers a run, 1 to 8; 1: no small scratch, as before.
inline constexpr uint32_t kSmallDim = 1024;
/// The small scratch's layers, a run's of a small level: RX_VK_BC_SMALL_LAYERS, 1 to kMost; not set, kMost, and 1 on AMD's
/// cards (vendor 0x1002)
inline uint32_t small_layers(const char* asked, uint32_t vendor) {
if (asked && *asked) return std::clamp<uint32_t>((uint32_t)std::max(atoi(asked), 0), 1u, kMost);
return vendor == 0x1002 ? 1u : kMost;
}
/// Whether a level decoded at w x h goes through the small scratch: there is one, the level fits it, and the texture is not
/// one encoded at another size (which has the second scratch)
inline bool small_level(uint32_t w, uint32_t h, bool have_small, bool resized) {
return have_small && !resized && w <= kSmallDim && h <= kSmallDim;
}
/// The small scratch's part of the output buffer, and its image, in bytes
inline uint64_t small_out_bytes(uint32_t layers) { return (uint64_t)(kSmallDim / 4) * (kSmallDim / 4) * layers * 16; }
inline uint64_t small_image_bytes(uint32_t layers) { return (uint64_t)kSmallDim * kSmallDim * 4 * layers; }
/// Where layer k of a run begins in the encoder's output: host_shaders/bc_encoder.comp writes block
/// (z * blocks_y + y) * blocks_x + x, 16 bytes a block, 8 where only the colour half is written (an image kept as BC1)
inline uint64_t layer_offset(uint32_t k, uint32_t w, uint32_t h, bool bc1) {
return (uint64_t)k * ((w + 3) / 4) * ((h + 3) / 4) * (bc1 ? 8 : 16);
}
} // namespace bc_scratch