Files
Triforce-Source/gpu/vk/spv_exact.h
ruckus7382sfgsgdf 93eeb714c2 Triforce v0.4.0
What was merged from NX2navi (DLSS frame generation, AMD FSR 4 in Setup builds, texture detail by video memory, sprint, volume, frame caps, safer saves, the above-60 fixes), the ultrawide HUD at the screen edges, camera speed, movies without the AV1 Video Extension, the 5120x2880 + RenoDX HDR start fix, the renderer work of 11-14 and the first float changes of the lift.
2026-11-15 06:39:00 -06:00

116 lines
5.3 KiB
C++

// Which texture bindings of a translated shader are read by texel position or asked for their size (vk_shader.cpp
// make_module, for the texture detail of tex_detail.h): a texture bound there must be whole, as a fetch at a level the
// image lacks, or coordinates worked out from a size that is half the game's, read the wrong texels. A sampled read
// (normalised coordinates and derivatives) picks the same level of the game's texture wherever that level is kept.
// tests/test_spv_exact.py
//
// Counted: OpImageFetch, OpImageQuerySizeLod, OpImageQuerySize and OpImageQueryLevels on a sampled, single-sample 2D
// texture or 2D array, the only kinds the texture detail leaves levels out of. Not counted: a size query on an array
// whose result is used for its third component alone, the layer count, which no level changes.
#pragma once
#include <array>
#include <cstddef>
#include <cstdint>
#include <unordered_map>
#include <vector>
namespace spv_exact {
using Bindings = std::array<uint64_t, 4>; // (a bit a binding, 0 to 255; set 0 is the only set the translation uses)
inline bool any(const Bindings& b) { return (b[0] | b[1] | b[2] | b[3]) != 0; }
inline bool has(const Bindings& b, uint32_t binding) { return binding < 256 && (b[binding >> 6] >> (binding & 63) & 1); }
inline Bindings scan(const uint32_t* w, size_t n) {
Bindings out{};
if (n < 5 || w[0] != 0x07230203u) return out;
enum : uint16_t {
OpTypeImage = 25, OpTypeSampledImage = 27, OpTypeArray = 28, OpTypeRuntimeArray = 29, OpTypePointer = 32,
OpVariable = 59, OpLoad = 61, OpAccessChain = 65, OpInBoundsAccessChain = 66, OpDecorate = 71,
OpCompositeExtract = 81, OpCopyObject = 83, OpImageFetch = 95, OpImage = 100, OpImageQuerySizeLod = 103,
OpImageQuerySize = 104, OpImageQueryLevels = 106,
};
struct Image { bool d2, arrayed, ms, sampled; };
std::unordered_map<uint32_t, uint32_t> binding, inner, pointee, var_type, from;
std::unordered_map<uint32_t, Image> images;
struct Use { uint32_t image, result; bool size; };
std::vector<Use> uses;
for (size_t i = 5; i < n;) {
const uint32_t op = w[i] & 0xffffu, wc = w[i] >> 16;
if (!wc || i + wc > n) break;
const uint32_t* a = w + i + 1;
const uint32_t na = wc - 1;
switch (op) {
case OpDecorate:
if (na >= 3 && a[1] == 33) binding[a[0]] = a[2]; // (Binding)
break;
case OpTypeImage: // (result, sampled type, dim, depth, arrayed, ms, sampled, format)
if (na >= 7) images[a[0]] = Image{a[2] == 1, a[4] != 0, a[5] != 0, a[6] == 1};
break;
case OpTypeSampledImage: case OpTypeArray: case OpTypeRuntimeArray:
if (na >= 2) inner[a[0]] = a[1];
break;
case OpTypePointer:
if (na >= 3) pointee[a[0]] = a[2];
break;
case OpVariable:
if (na >= 2) var_type[a[1]] = a[0];
break;
case OpLoad: case OpAccessChain: case OpInBoundsAccessChain: case OpImage: case OpCopyObject:
if (na >= 3) from[a[1]] = a[2];
break;
case OpImageFetch: case OpImageQueryLevels:
if (na >= 3) uses.push_back({a[2], a[1], false});
break;
case OpImageQuerySizeLod: case OpImageQuerySize:
if (na >= 3) uses.push_back({a[2], a[1], true});
break;
default: break;
}
i += wc;
}
if (uses.empty()) return out;
// (a size query's result used for something other than its third component: every word of every other instruction
// that equals the result's id counts, a literal that happens to as well: the texture then stays whole, the safe side)
std::unordered_map<uint32_t, bool> other_use;
for (const Use& u : uses)
if (u.size) other_use[u.result] = false;
if (!other_use.empty())
for (size_t i = 5; i < n;) {
const uint32_t op = w[i] & 0xffffu, wc = w[i] >> 16;
if (!wc || i + wc > n) break;
const bool layer_only = op == OpCompositeExtract && wc == 5 && w[i + 4] == 2;
for (uint32_t k = (op == OpImageQuerySizeLod || op == OpImageQuerySize) ? 3 : 1; k < wc; k++) {
const auto it = other_use.find(w[i + k]);
if (it != other_use.end() && !(layer_only && k == 3)) it->second = true;
}
i += wc;
}
for (const Use& u : uses) {
uint32_t v = u.image;
for (int hops = 0; hops < 16; hops++) {
const auto f = from.find(v);
if (f == from.end()) break;
v = f->second;
}
const auto vt = var_type.find(v);
const auto b = binding.find(v);
if (vt == var_type.end() || b == binding.end() || b->second >= 256) continue;
const auto p = pointee.find(vt->second);
if (p == pointee.end()) continue;
uint32_t t = p->second;
for (int hops = 0; hops < 8; hops++) {
const auto in = inner.find(t);
if (in == inner.end()) break;
t = in->second;
}
const auto im = images.find(t);
if (im == images.end() || !im->second.d2 || im->second.ms || !im->second.sampled) continue;
if (u.size && im->second.arrayed && !other_use[u.result]) continue; // (the layer count alone)
out[b->second >> 6] |= 1ull << (b->second & 63);
}
return out;
}
} // namespace spv_exact