Triforce v0.2.0

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
ruckus7382sfgsgdf
2026-11-10 19:32:48 -06:00
commit 34b3683441
1730 changed files with 554853 additions and 0 deletions

View File

@@ -0,0 +1,289 @@
"""Exercise the actual generic upscale fallback without Vulkan or a GPU.
python tests/test_upscale_fallback.py [--source gpu/vk/vk_draw.cpp] [--cxx clang++]
Use --cxx g++ on Linux, or --cxx cl in a configured Visual Studio compiler shell. No SDK needed.
"""
import argparse
import os
from pathlib import Path
import subprocess
import tempfile
RUN_ALL_ARGS = ["--cxx", "g++"]
ROOT = next(p for p in Path(__file__).resolve().parents if (p / 'gpu/vk/vk_draw.cpp').is_file())
def block(text, marker):
start = text.index(marker)
end = text.index('{', start) + 1
depth = 1
while depth:
depth += (text[end] == '{') - (text[end] == '}')
end += 1
return text[start:end]
PREFIX = r'''
#define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <atomic>
#include <cassert>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <mutex>
#include <string>
#include <unordered_set>
#include <vector>
// Only the Vulkan declarations used by upscale_stub; no Vulkan SDK or runtime.
using VkCommandBuffer = uintptr_t;
using VkImage = uintptr_t;
using VkImageView = uintptr_t;
using VkPhysicalDevice = uintptr_t;
using VkFormat = uint32_t;
using VkFormatFeatureFlags = uint32_t;
using VkImageAspectFlags = uint32_t;
using VkImageType = uint32_t;
using VkImageViewType = uint32_t;
constexpr uint32_t VK_IMAGE_VIEW_TYPE_2D = 1;
using VkSampleCountFlagBits = uint32_t;
using VkImageLayout = uint32_t;
using VkFilter = uint32_t;
constexpr uint32_t VK_FORMAT_UNDEFINED = 0, VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122,
VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, VK_FORMAT_R8G8B8A8_UNORM = 37;
constexpr uint32_t VK_IMAGE_TYPE_2D = 1, VK_IMAGE_ASPECT_COLOR_BIT = 1, VK_SAMPLE_COUNT_1_BIT = 1,
VK_IMAGE_LAYOUT_GENERAL = 1, VK_FILTER_LINEAR = 1;
constexpr uint32_t VK_FORMAT_FEATURE_BLIT_SRC_BIT = 1, VK_FORMAT_FEATURE_BLIT_DST_BIT = 2,
VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 4,
VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 8, VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 16;
struct VkFormatProperties {
VkFormatFeatureFlags optimalTilingFeatures{};
};
struct Subresource {
uint32_t aspectMask{}, mipLevel{}, baseArrayLayer{}, layerCount{};
};
struct Offset {
int32_t x{}, y{}, z{};
};
struct VkImageBlit {
Subresource srcSubresource;
Offset srcOffsets[2];
Subresource dstSubresource;
Offset dstOffsets[2];
};
constexpr int NVN_FORMAT_RGB9E5F = 64, NVN_FORMAT_R11G11B10F = 63;
constexpr unsigned NVN_TEXTURE_SWIZZLE_R = 2, NVN_TEXTURE_SWIZZLE_G = 3, NVN_TEXTURE_SWIZZLE_B = 4;
struct Desc {
int target = 2, format = 64;
unsigned width = 64, height = 32, depth = 1;
unsigned swizzle_r = 2, swizzle_g = 3, swizzle_b = 4;
};
struct nvn_tex {
Desc d;
uint64_t gpu = 10, serial = 99;
};
struct nvn_view {};
struct NvnState {
uint64_t tex[6][128]{}, img[6][32]{};
};
struct Texture {
VkImage image = (VkImage)11;
VkFormat format = VK_FORMAT_B10G11R11_UFLOAT_PACK32;
unsigned width = 64, height = 32, depth = 1, layers = 1, levels = 1, skip = 0;
VkImageType type = VK_IMAGE_TYPE_2D;
VkImageAspectFlags aspect = VK_IMAGE_ASPECT_COLOR_BIT;
bool bc = false;
VkSampleCountFlagBits samples = VK_SAMPLE_COUNT_1_BIT;
};
Texture src, dst;
nvn_tex source, destination;
bool override_view = false, movie = false, pipeline_ok = true;
bool missing_storage = false, missing_sample = false, missing_linear = false;
bool missing_input_view = false, missing_output_view = false;
unsigned blits = 0, typed_calls = 0, views = 0, movie_calls = 0, writes = 0, gameplay_logs = 0, gameplay_warnings = 0;
struct {
VkPhysicalDevice physical{};
} dev;
void cs_slot_counts(const NvnState &, uint32_t *t, uint32_t *i) { *t = *i = 1; }
bool texture_of(int h, nvn_tex *t, nvn_view *v, bool *hv) {
assert(h == 1 || h == 2);
*t = h == 1 ? source : destination;
*v = {};
*hv = override_view;
return true;
}
Texture *texture_get(const nvn_tex *t, bool) { return t->gpu == 10 ? &src : &dst; }
void vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice, VkFormat format, VkFormatProperties *p) {
p->optimalTilingFeatures = VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT |
VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT |
VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT;
if (missing_storage && format == VK_FORMAT_B10G11R11_UFLOAT_PACK32)
p->optimalTilingFeatures &= ~VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT;
if (missing_sample && format == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32)
p->optimalTilingFeatures &= ~VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
if (missing_linear && format == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32)
p->optimalTilingFeatures &= ~VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
}
void end_pass(VkCommandBuffer) {}
// (the temporal upscaler, off here: upscale_stub offers it the frame first, vk_draw.cpp temporal_rejected_network)
bool temporal_wanted() { return false; }
static bool temporal_rejected_network(VkCommandBuffer, uint64_t, Texture *, const nvn_tex *, Texture *, const nvn_tex *) {
return false;
}
void full_barrier(VkCommandBuffer) {}
bool dump_on() { return false; }
void logf(const char *format, ...) {
if (std::strstr(format, "gameplay RGB9E5 upscale uses the typed fallback"))
gameplay_logs++;
if (std::strstr(format, "gameplay RGB9E5 upscale unavailable"))
gameplay_warnings++;
}
void texture_written(Texture *t) {
assert(t == &dst);
writes++;
}
void dump_image(VkCommandBuffer, Texture *, unsigned, unsigned, const char *) {}
bool movie_upscale(VkCommandBuffer, uint64_t, uint64_t, Texture *) {
movie_calls++;
return movie;
}
bool gameplay_network(uint64_t key) {
return key == 0xfd029a317a9a4b94ull || key == 0x9dc98871eb7fc101ull;
}
enum class ViewUse { Sample, Storage };
VkImageView texture_view(Texture *t, const nvn_tex *, const nvn_view *v, VkImageViewType type,
ViewUse use, VkFormat *f, VkFormat forced = VK_FORMAT_UNDEFINED) {
assert(!v && type == VK_IMAGE_VIEW_TYPE_2D);
views++;
if (t == &src) {
assert(use == ViewUse::Sample && forced == VK_FORMAT_UNDEFINED);
*f = VK_FORMAT_E5B9G9R9_UFLOAT_PACK32;
return missing_input_view ? 0 : (VkImageView)101;
}
assert(t == &dst && use == ViewUse::Storage && forced == VK_FORMAT_B10G11R11_UFLOAT_PACK32);
*f = VK_FORMAT_B10G11R11_UFLOAT_PACK32;
return missing_output_view ? 0 : (VkImageView)102;
}
static bool typed_upscale(VkCommandBuffer, VkImageView input, VkImageView output, Texture *t,
uint32_t level, uint64_t, const char *, bool temporal) {
assert(input == (VkImageView)101 && output == (VkImageView)102 && t == &dst && level == 0 &&
!temporal);
typed_calls++;
return pipeline_ok;
}
void vkCmdBlitImage(VkCommandBuffer, VkImage a, VkImageLayout al, VkImage b, VkImageLayout bl,
uint32_t n, const VkImageBlit *r, VkFilter filter) {
assert(a == src.image && b == dst.image && al == VK_IMAGE_LAYOUT_GENERAL &&
bl == VK_IMAGE_LAYOUT_GENERAL && n == 1 && filter == VK_FILTER_LINEAR);
assert(r->srcSubresource.mipLevel == 0 && r->srcSubresource.baseArrayLayer == 0 &&
r->dstSubresource.mipLevel == 0 && r->dstSubresource.baseArrayLayer == 0);
assert(r->srcOffsets[1].x == 64 && r->srcOffsets[1].y == 32 && r->dstOffsets[1].x == 128 &&
r->dstOffsets[1].y == 64);
blits++;
}
'''
SUFFIX = r'''
int main(int argc, char **argv) {
assert(argc == 2);
const std::string mode = argv[1];
uint64_t key = 0x0775215f8da720e6ull;
destination.gpu = 20;
destination.d.format = 63;
destination.d.width = 128;
destination.d.height = 64;
dst.width = 128;
dst.height = 64;
dst.image = (VkImage)22;
if (mode == "r11" || mode == "fd-r11")
source.d.format = 63;
if (mode == "movie") {
dst.format = VK_FORMAT_R8G8B8A8_UNORM;
movie = true;
}
if (mode == "view" || mode == "fd-view")
override_view = true;
if (mode == "skip")
src.skip = 1;
if (mode == "mip")
src.levels = 2;
if (mode == "swizzle")
source.d.swizzle_r = 4;
if (mode.compare(0, 2, "fd") == 0)
key = 0xfd029a317a9a4b94ull;
if (mode == "9dc")
key = 0x9dc98871eb7fc101ull;
if (mode == "pipeline-failure" || mode == "fd-pipeline-failure")
pipeline_ok = false;
if (mode == "no-storage" || mode == "fd-no-storage")
missing_storage = true;
if (mode == "no-e5-sample" || mode == "fd-no-e5-sample")
missing_sample = true;
if (mode == "no-e5-linear" || mode == "fd-no-e5-linear")
missing_linear = true;
if (mode == "null-input-view" || mode == "fd-null-input-view")
missing_input_view = true;
if (mode == "null-output-view" || mode == "fd-null-output-view")
missing_output_view = true;
NvnState state;
state.tex[5][0] = 1;
state.img[5][0] = 2;
assert(upscale_stub((VkCommandBuffer)5, state, key));
if (mode == "captured" || mode == "fd") {
if (typed_calls != 1 || views != 2 || blits != 0) {
puts("RED: RGB9E5 input still used physical-format blit");
return 7;
}
assert(writes == 1);
assert(gameplay_logs == (mode == "fd" ? 1u : 0u) && gameplay_warnings == 0);
} else if (mode == "movie") {
assert(movie_calls == 1 && typed_calls == 0 && blits == 0 && writes == 1);
} else if (mode == "pipeline-failure" || mode == "fd-pipeline-failure") {
assert(typed_calls == 1 && views == 2 && blits == 1 && writes == 1);
} else if (missing_input_view || missing_output_view) {
assert(typed_calls == 0 && views == 2 && blits == 1 && writes == 1);
} else {
assert(typed_calls == 0 && views == 0 && blits == 1 && writes == 1);
}
if (mode == "fd-view" || mode == "fd-pipeline-failure" || mode == "fd-no-storage" ||
mode == "fd-no-e5-sample" || mode == "fd-no-e5-linear" ||
mode == "fd-null-input-view" || mode == "fd-null-output-view")
assert(gameplay_warnings == 1 && gameplay_logs == 0);
if (mode == "fd-r11" || mode == "9dc")
assert(gameplay_warnings == 0 && gameplay_logs == 0);
printf("PASS: %s\n", mode.c_str());
}
'''
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--source', type=Path, default=ROOT / 'gpu/vk/vk_draw.cpp')
parser.add_argument('--cxx', default='clang++')
args = parser.parse_args()
body = block(args.source.read_text(encoding='utf-8'), 'bool upscale_stub(')
env = os.environ.copy()
env.pop('RX_VK_NO_UPSCALE_STUB', None)
with tempfile.TemporaryDirectory(prefix='upscale-fallback-') as tmp:
tmp = Path(tmp)
source = tmp / 'check.cpp'
exe = tmp / ('check.exe' if os.name == 'nt' else 'check')
source.write_text(PREFIX + body + SUFFIX, encoding='utf-8')
if Path(args.cxx).name.lower() in ('cl', 'cl.exe', 'clang-cl', 'clang-cl.exe'):
command = [args.cxx, '/nologo', '/std:c++20', '/EHsc', '/UNDEBUG', str(source),
'/Fo' + str(tmp / 'check.obj'), '/Fe' + str(exe)]
cwd = tmp
else:
command = [args.cxx, '-std=c++20', '-UNDEBUG', str(source), '-o', str(exe)]
cwd = None
subprocess.run(command, cwd=cwd, env=env, check=True)
cases = ('captured', 'r11', 'movie', 'view', 'skip', 'mip', 'swizzle', 'fd', 'fd-r11',
'fd-view', 'fd-pipeline-failure', 'fd-no-storage', 'fd-no-e5-sample',
'fd-no-e5-linear', 'fd-null-input-view', 'fd-null-output-view', '9dc',
'pipeline-failure', 'no-storage', 'no-e5-sample', 'no-e5-linear',
'null-input-view', 'null-output-view')
for case in cases:
subprocess.run([str(exe), case], env=env, check=True)
if __name__ == '__main__':
main()