Skip to content

PS2 games in the browser: static recompilation to WebAssembly with a native runtime

C++

GS: internal resolution scale (PS2_SCALE 1-3)

Samir Nuri37c8d755ff11
diff --git a/runtime/src/gs/gpu/gpu.cpp b/runtime/src/gs/gpu/gpu.cpp
index 457c1fb..9178010 100644
--- a/runtime/src/gs/gpu/gpu.cpp
+++ b/runtime/src/gs/gpu/gpu.cpp
@@ -26,13 +26,12 @@ namespace ps2::gs::gpu {
namespace {
-enum Pipeline { kUpload, kCopyRead, kCopyWrite, kLoadClut, kDisplay, kRaster, kPipelines };
-const char *const kEntryPoints[kPipelines] = {"upload", "copy_read", "copy_write", "load_clut", "display", "raster"};
+enum Pipeline { kUpload, kCopyRead, kCopyWrite, kLoadClut, kDisplay, kRaster, kResolve, kPipelines };
+const char *const kEntryPoints[kPipelines] = {"upload", "copy_read", "copy_write", "load_clut", "display", "raster", "resolve"};
constexpr std::uint32_t kParamStride = 256;
constexpr std::uint32_t kClutSlots = 2048;
constexpr std::uint32_t kClutEntries = 512;
-constexpr std::uint64_t kScratchBytes = 16ull << 20;
constexpr std::uint32_t kPrimWords = 40;
constexpr std::uint32_t kSetupWords = 24;
constexpr int kTileShift = 4;
@@ -52,7 +51,9 @@ WGPUBindGroup g_blit_group = nullptr;
WGPUBuffer g_blit_params = nullptr;
std::uint32_t g_field = 0, g_last_width = 0, g_last_height = 0;
bool g_have_previous = false;
-constexpr std::uint32_t kFieldWords = 2u << 20;
+std::uint32_t g_scale = 1, g_copy_words = 1u << 20, g_field_words = 1u << 19;
+
+std::uint32_t field_base(std::uint32_t field) { return g_copy_words + (field & 1u) * g_field_words; }
bool g_timestamps = false;
WGPUQuerySet g_queries = nullptr;
@@ -685,14 +686,17 @@ bool init(Mode m) {
if (!g_device) return false;
g_queue = wgpuDeviceGetQueue(g_device);
- g_vram = make_buffer(kMemorySize, WGPUBufferUsage_Storage | WGPUBufferUsage_CopySrc | WGPUBufferUsage_CopyDst);
+ if (const char *scale = std::getenv("PS2_SCALE")) g_scale = std::clamp<std::uint32_t>(static_cast<std::uint32_t>(std::atoi(scale)), 1u, 3u);
+ g_copy_words = (1u << 20) * g_scale * g_scale;
+ g_field_words = (1u << 19) * g_scale * g_scale;
+ g_vram = make_buffer(static_cast<std::uint64_t>(kMemorySize) * g_scale * g_scale, WGPUBufferUsage_Storage | WGPUBufferUsage_CopySrc | WGPUBufferUsage_CopyDst);
std::vector<std::uint32_t> tables;
swizzle_tables(tables);
g_tables = make_buffer(tables.size() * 4, WGPUBufferUsage_Storage | WGPUBufferUsage_CopyDst);
wgpuQueueWriteBuffer(g_queue, g_tables, 0, tables.data(), tables.size() * 4);
g_clut = make_buffer(static_cast<std::uint64_t>(kClutSlots) * kClutEntries * 4, WGPUBufferUsage_Storage);
- g_scratch = make_buffer(kScratchBytes, WGPUBufferUsage_Storage | WGPUBufferUsage_CopySrc);
- g_readback = make_buffer(kScratchBytes, WGPUBufferUsage_MapRead | WGPUBufferUsage_CopyDst);
+ g_scratch = make_buffer((static_cast<std::uint64_t>(g_copy_words) + 2ull * g_field_words) * 4, WGPUBufferUsage_Storage | WGPUBufferUsage_CopySrc);
+ g_readback = make_buffer(static_cast<std::uint64_t>(g_copy_words) * 4, WGPUBufferUsage_MapRead | WGPUBufferUsage_CopyDst);
if (g_timestamps) {
WGPUQuerySetDescriptor qd = WGPU_QUERY_SET_DESCRIPTOR_INIT;
qd.type = WGPUQueryType_Timestamp;
@@ -732,6 +736,11 @@ bool init(Mode m) {
cd.layout = g_pipeline_layout;
cd.compute.module = module;
cd.compute.entryPoint = view(kEntryPoints[i]);
+ WGPUConstantEntry constant = WGPU_CONSTANT_ENTRY_INIT;
+ constant.key = view("SCALE");
+ constant.value = static_cast<double>(g_scale);
+ cd.compute.constantCount = 1;
+ cd.compute.constants = &constant;
g_pipelines[i] = wgpuDeviceCreateComputePipeline(g_device, &cd);
if (!g_pipelines[i]) return false;
}
@@ -828,6 +837,10 @@ void draw(const State &st, const Vertex *v, int count) {
default:
return;
}
+ if (g_scale > 1) {
+ --minx;
+ --miny;
+ }
minx = std::max(minx, 0);
miny = std::max(miny, 0);
maxx = std::min(maxx, 2047);
@@ -933,8 +946,8 @@ void local_copy(const State &s) {
const std::uint32_t write = push_params({static_cast<std::uint32_t>(buf >> 32) & 0x3FFFu, static_cast<std::uint32_t>(buf >> 48) & 0x3Fu, static_cast<std::uint32_t>(buf >> 56) & 0x3Fu,
static_cast<std::uint32_t>(pos >> 32) & 0x7FFu, static_cast<std::uint32_t>(pos >> 48) & 0x7FFu, w, h,
static_cast<std::uint32_t>(pos >> 59) & 3u});
- dispatch_linear(kCopyRead, w * h, read);
- dispatch_linear(kCopyWrite, w * h, write);
+ dispatch_linear(kCopyRead, w * h * g_scale * g_scale, read);
+ dispatch_linear(kCopyWrite, w * h * g_scale * g_scale, write);
}
void load_clut(std::uint64_t tex0, std::uint64_t texclut) {
@@ -968,8 +981,14 @@ void flush() {
void download(std::uint8_t *memory) {
flush_all();
+ if (g_scale == 1) {
+ submit();
+ read_back(g_vram, kMemorySize, memory);
+ return;
+ }
+ dispatch_linear(kResolve, kMemorySize / 4, push_params({}));
submit();
- read_back(g_vram, kMemorySize, memory);
+ read_back(g_scratch, kMemorySize, memory);
}
void stats() {
@@ -1100,14 +1119,14 @@ bool has_surface() { return g_surface != nullptr; }
bool present(const DisplaySource &src) {
if (!g_surface) return false;
flush_all();
- const std::uint32_t current = (g_field & 1u) * kFieldWords, previous = ((g_field + 1) & 1u) * kFieldWords;
+ const std::uint32_t current = field_base(g_field), previous = field_base(g_field + 1);
static const bool weave_off = std::getenv("PS2_NO_DEINTERLACE") != nullptr;
const bool blend = src.halved && g_have_previous && g_last_width == src.width && g_last_height == src.height && !weave_off;
const std::uint32_t param = push_params({src.fbp, src.fbw, src.psm, src.dbx, src.dby, src.width, src.height, src.halved ? 1u : 0u, current});
- g_commands.push_back({kDisplay, (src.width + 7) / 8, (src.height + 7) / 8, param});
+ g_commands.push_back({kDisplay, (src.width * g_scale + 7) / 8, (src.height * g_scale + 7) / 8, param});
const float sw = static_cast<float>(g_surface_width), sh = static_cast<float>(g_surface_height);
const float vw = std::min(sw, sh * 4.0f / 3.0f), vh = vw * 3.0f / 4.0f;
- const std::uint32_t blit[8] = {src.width, src.height, current, previous, blend ? 1u : 0u, static_cast<std::uint32_t>(vw), static_cast<std::uint32_t>(vh), 0};
+ const std::uint32_t blit[8] = {src.width * g_scale, src.height * g_scale, current, previous, blend ? 1u : 0u, static_cast<std::uint32_t>(vw), static_cast<std::uint32_t>(vh), 0};
wgpuQueueWriteBuffer(g_queue, g_blit_params, 0, blit, sizeof blit);
++g_field;
g_have_previous = true;
@@ -1174,7 +1193,7 @@ bool display_async(const DisplaySource &src, std::vector<std::uint32_t> &rgba, s
for (Copy &c : g_copies)
if (!c.busy) slot = &c;
if (slot) {
- const std::uint64_t bytes = static_cast<std::uint64_t>(src.width) * src.height * 4;
+ const std::uint64_t bytes = static_cast<std::uint64_t>(src.width) * src.height * g_scale * g_scale * 4;
if (slot->size < bytes) {
if (slot->buffer) wgpuBufferRelease(slot->buffer);
slot->size = bytes;
@@ -1182,7 +1201,7 @@ bool display_async(const DisplaySource &src, std::vector<std::uint32_t> &rgba, s
}
flush_all();
const std::uint32_t param = push_params({src.fbp, src.fbw, src.psm, src.dbx, src.dby, src.width, src.height, src.halved ? 1u : 0u});
- g_commands.push_back({kDisplay, (src.width + 7) / 8, (src.height + 7) / 8, param});
+ g_commands.push_back({kDisplay, (src.width * g_scale + 7) / 8, (src.height * g_scale + 7) / 8, param});
submit();
WGPUCommandEncoder enc = wgpuDeviceCreateCommandEncoder(g_device, nullptr);
wgpuCommandEncoderCopyBufferToBuffer(enc, g_scratch, 0, slot->buffer, 0, bytes);
@@ -1192,8 +1211,8 @@ bool display_async(const DisplaySource &src, std::vector<std::uint32_t> &rgba, s
wgpuCommandEncoderRelease(enc);
slot->busy = true;
slot->order = ++g_copy_order;
- slot->width = src.width;
- slot->height = src.height;
+ slot->width = src.width * g_scale;
+ slot->height = src.height * g_scale;
WGPUBufferMapCallbackInfo cb = WGPU_BUFFER_MAP_CALLBACK_INFO_INIT;
cb.mode = WGPUCallbackMode_AllowProcessEvents;
cb.callback = [](WGPUMapAsyncStatus status, WGPUStringView, void *copy, void *) {
@@ -1207,12 +1226,14 @@ bool display_async(const DisplaySource &src, std::vector<std::uint32_t> &rgba, s
return newest != nullptr;
}
-bool display(const DisplaySource &src, std::vector<std::uint32_t> &rgba) {
+bool display(const DisplaySource &src, std::vector<std::uint32_t> &rgba, std::uint32_t &width, std::uint32_t &height) {
flush_all();
const std::uint32_t param = push_params({src.fbp, src.fbw, src.psm, src.dbx, src.dby, src.width, src.height, src.halved ? 1u : 0u});
- g_commands.push_back({kDisplay, (src.width + 7) / 8, (src.height + 7) / 8, param});
+ g_commands.push_back({kDisplay, (src.width * g_scale + 7) / 8, (src.height * g_scale + 7) / 8, param});
submit();
- rgba.resize(static_cast<std::size_t>(src.width) * src.height);
+ width = src.width * g_scale;
+ height = src.height * g_scale;
+ rgba.resize(static_cast<std::size_t>(width) * height);
read_back(g_scratch, rgba.size() * 4, rgba.data());
return true;
}
diff --git a/runtime/src/gs/gpu/gpu.hpp b/runtime/src/gs/gpu/gpu.hpp
index 4e4b9c9..a606cc9 100644
--- a/runtime/src/gs/gpu/gpu.hpp
+++ b/runtime/src/gs/gpu/gpu.hpp
@@ -32,7 +32,7 @@ void local_copy(const State &s);
void load_clut(std::uint64_t tex0, std::uint64_t texclut);
void flush();
void download(std::uint8_t *memory);
-bool display(const DisplaySource &src, std::vector<std::uint32_t> &rgba);
+bool display(const DisplaySource &src, std::vector<std::uint32_t> &rgba, std::uint32_t &width, std::uint32_t &height);
bool display_async(const DisplaySource &src, std::vector<std::uint32_t> &rgba, std::uint32_t &width, std::uint32_t &height);
bool attach_surface(const SurfaceTarget &target);
void resize_surface(std::uint32_t width, std::uint32_t height);
diff --git a/runtime/src/gs/gpu/gs.wgsl b/runtime/src/gs/gpu/gs.wgsl
index 0e1620a..5280f20 100644
--- a/runtime/src/gs/gpu/gs.wgsl
+++ b/runtime/src/gs/gpu/gs.wgsl
@@ -9,6 +9,8 @@ struct Params {
@group(0) @binding(4) var<storage, read_write> clut: array<u32>;
@group(0) @binding(5) var<storage, read_write> scratch: array<u32>;
+override SCALE: u32 = 1u;
+
const PSMCT32: u32 = 0x00u;
const PSMCT24: u32 = 0x01u;
const PSMCT16: u32 = 0x02u;
@@ -118,19 +120,34 @@ fn locate(psm: u32, bp: u32, bw: u32, x: u32, y: u32) -> Loc {
return Loc((a & 0x3FFFFFu) >> 2u, shift, mask);
}
-fn read_pixel(psm: u32, bp: u32, bw: u32, x: u32, y: u32) -> u32 {
+fn read_sample(psm: u32, bp: u32, bw: u32, x: u32, y: u32, k: u32) -> u32 {
let l = locate(psm, bp, bw, x, y);
- return (atomicLoad(&vram[l.word]) >> l.shift) & l.mask;
+ return (atomicLoad(&vram[l.word * SCALE * SCALE + k]) >> l.shift) & l.mask;
}
-fn write_pixel(psm: u32, bp: u32, bw: u32, x: u32, y: u32, value: u32) {
- let l = locate(psm, bp, bw, x, y);
+fn read_pixel(psm: u32, bp: u32, bw: u32, x: u32, y: u32) -> u32 {
+ return read_sample(psm, bp, bw, x, y, 0u);
+}
+
+fn store(l: Loc, k: u32, value: u32) {
+ let w = l.word * SCALE * SCALE + k;
if (l.mask == 0xFFFFFFFFu) {
- atomicStore(&vram[l.word], value);
+ atomicStore(&vram[w], value);
return;
}
- atomicAnd(&vram[l.word], ~(l.mask << l.shift));
- atomicOr(&vram[l.word], (value & l.mask) << l.shift);
+ atomicAnd(&vram[w], ~(l.mask << l.shift));
+ atomicOr(&vram[w], (value & l.mask) << l.shift);
+}
+
+fn write_sample(psm: u32, bp: u32, bw: u32, x: u32, y: u32, k: u32, value: u32) {
+ store(locate(psm, bp, bw, x, y), k, value);
+}
+
+fn write_pixel(psm: u32, bp: u32, bw: u32, x: u32, y: u32, value: u32) {
+ let l = locate(psm, bp, bw, x, y);
+ for (var k = 0u; k < SCALE * SCALE; k = k + 1u) {
+ store(l, k, value);
+ }
}
fn bits_at(offset: u32, bit: u32, count: u32) -> u32 {
@@ -178,12 +195,14 @@ fn upload(@builtin(global_invocation_id) gid: vec3<u32>) {
fn copy_read(@builtin(global_invocation_id) gid: vec3<u32>) {
let i = gid.x + gid.y * 64u * 1024u;
let w = prm(5u);
- if (i >= w * prm(6u)) {
+ let n = SCALE * SCALE;
+ if (i >= w * prm(6u) * n) {
return;
}
- let x = (prm(3u) + i % w) & 0x7FFu;
- let y = (prm(4u) + i / w) & 0x7FFu;
- scratch[i] = read_pixel(prm(2u), prm(0u), prm(1u), x, y);
+ let pixel = i / n;
+ let x = (prm(3u) + pixel % w) & 0x7FFu;
+ let y = (prm(4u) + pixel / w) & 0x7FFu;
+ scratch[i] = read_sample(prm(2u), prm(0u), prm(1u), x, y, i % n);
}
@compute @workgroup_size(64)
@@ -191,12 +210,14 @@ fn copy_write(@builtin(global_invocation_id) gid: vec3<u32>) {
let i = gid.x + gid.y * 64u * 1024u;
let w = prm(5u);
let h = prm(6u);
- if (i >= w * h) {
+ let n = SCALE * SCALE;
+ if (i >= w * h * n) {
return;
}
let dir = prm(7u);
- let x = i % w;
- let y = i / w;
+ let k = i % n;
+ let x = (i / n) % w;
+ let y = (i / n) / w;
var sx = x;
var sy = y;
if ((dir & 1u) != 0u) {
@@ -205,7 +226,7 @@ fn copy_write(@builtin(global_invocation_id) gid: vec3<u32>) {
if ((dir & 2u) != 0u) {
sy = h - 1u - y;
}
- write_pixel(prm(2u), prm(0u), prm(1u), (prm(3u) + x) & 0x7FFu, (prm(4u) + y) & 0x7FFu, scratch[sy * w + sx]);
+ write_sample(prm(2u), prm(0u), prm(1u), (prm(3u) + x) & 0x7FFu, (prm(4u) + y) & 0x7FFu, k, scratch[(sy * w + sx) * n + k]);
}
@compute @workgroup_size(256)
@@ -249,8 +270,8 @@ fn load_clut(@builtin(local_invocation_index) k: u32) {
@compute @workgroup_size(8, 8)
fn display(@builtin(global_invocation_id) gid: vec3<u32>) {
- let w = prm(5u);
- let h = prm(6u);
+ let w = prm(5u) * SCALE;
+ let h = prm(6u) * SCALE;
if (gid.x >= w || gid.y >= h) {
return;
}
@@ -259,7 +280,7 @@ fn display(@builtin(global_invocation_id) gid: vec3<u32>) {
if (prm(7u) != 0u) {
sy = gid.y / 2u;
}
- var c = read_pixel(psm, prm(0u), prm(1u), prm(3u) + gid.x, prm(4u) + sy);
+ var c = read_sample(psm, prm(0u), prm(1u), prm(3u) + gid.x / SCALE, prm(4u) + sy / SCALE, (sy % SCALE) * SCALE + gid.x % SCALE);
if (psm == PSMCT16 || psm == PSMCT16S) {
c = ((c & 0x1Fu) << 3u) | ((c & 0x3E0u) << 6u) | ((c & 0x7C00u) << 9u);
}
@@ -393,10 +414,19 @@ fn wrap_coord(v: i32, size: i32, m: u32, mn: u32, mx: u32) -> i32 {
}
}
-fn fetch(s: Setup, xi: i32, yi: i32) -> u32 {
- let x = wrap_coord(xi, 1 << s.tw, mode(s, 24u, 2u), s.minu, s.maxu);
- let y = wrap_coord(yi, 1 << s.th, mode(s, 26u, 2u), s.minv, s.maxv);
- let raw = read_pixel(s.tpsm, s.tbp, s.tbw, u32(x), u32(y));
+fn texel_x(s: Setup, xi: i32) -> u32 {
+ return u32(wrap_coord(xi, 1 << s.tw, mode(s, 24u, 2u), s.minu, s.maxu));
+}
+
+fn texel_y(s: Setup, yi: i32) -> u32 {
+ return u32(wrap_coord(yi, 1 << s.th, mode(s, 26u, 2u), s.minv, s.maxv));
+}
+
+fn fetch(s: Setup, xi: i32, yi: i32, k: u32) -> u32 {
+ return convert(s, read_sample(s.tpsm, s.tbp, s.tbw, texel_x(s, xi), texel_y(s, yi), k));
+}
+
+fn convert(s: Setup, raw: u32) -> u32 {
switch s.tpsm {
case 0x00u, 0x30u {
return raw;
@@ -431,20 +461,18 @@ fn fetch(s: Setup, xi: i32, yi: i32) -> u32 {
}
}
-fn sample(s: Setup, uin: f32, vin: f32) -> u32 {
+fn sample(s: Setup, uin: f32, vin: f32, k: u32) -> u32 {
if (!has(s, F_BILINEAR)) {
- return fetch(s, i32(floor(uin)), i32(floor(vin)));
+ return fetch(s, i32(floor(uin)), i32(floor(vin)), k);
}
let u = uin - 0.5;
let v = vin - 0.5;
let x0 = i32(floor(u));
let y0 = i32(floor(v));
- let fx = u - f32(x0);
- let fy = v - f32(y0);
- let c00 = fetch(s, x0, y0);
- let c10 = fetch(s, x0 + 1, y0);
- let c01 = fetch(s, x0, y0 + 1);
- let c11 = fetch(s, x0 + 1, y0 + 1);
+ return blend4(fetch(s, x0, y0, k), fetch(s, x0 + 1, y0, k), fetch(s, x0, y0 + 1, k), fetch(s, x0 + 1, y0 + 1, k), u - f32(x0), v - f32(y0));
+}
+
+fn blend4(c00: u32, c10: u32, c01: u32, c11: u32, fx: f32, fy: f32) -> u32 {
var out = 0u;
for (var ch = 0u; ch < 32u; ch = ch + 8u) {
let a = f32((c00 >> ch) & 0xFFu);
@@ -458,8 +486,8 @@ fn sample(s: Setup, uin: f32, vin: f32) -> u32 {
return out;
}
-fn read_frame(s: Setup, x: u32, y: u32) -> u32 {
- let raw = read_pixel(s.fpsm, s.fbp, s.fbw, x, y);
+fn read_frame(s: Setup, x: u32, y: u32, k: u32) -> u32 {
+ let raw = read_sample(s.fpsm, s.fbp, s.fbw, x, y, k);
switch s.fpsm {
case 0x01u {
return raw | 0x80000000u;
@@ -485,28 +513,28 @@ fn pack16(v: u32) -> u32 {
return ((v >> 3u) & 0x1Fu) | (((v >> 11u) & 0x1Fu) << 5u) | (((v >> 19u) & 0x1Fu) << 10u) | a;
}
-fn write_frame(s: Setup, x: u32, y: u32, c: u32, mask: u32) {
+fn write_frame(s: Setup, x: u32, y: u32, k: u32, c: u32, mask: u32) {
switch s.fpsm {
case 0x02u, 0x0Au {
- let old = read_pixel(s.fpsm, s.fbp, s.fbw, x, y);
+ let old = read_sample(s.fpsm, s.fbp, s.fbw, x, y, k);
var m16 = pack16(mask);
if ((mask & 0x80000000u) != 0u) {
m16 = m16 | 0x8000u;
}
- write_pixel(s.fpsm, s.fbp, s.fbw, x, y, (pack16(c) & ~m16) | (old & m16));
+ write_sample(s.fpsm, s.fbp, s.fbw, x, y, k, (pack16(c) & ~m16) | (old & m16));
}
case 0x01u {
- let old = read_pixel(PSMCT32, s.fbp, s.fbw, x, y);
+ let old = read_sample(PSMCT32, s.fbp, s.fbw, x, y, k);
let m = mask | 0xFF000000u;
- write_pixel(PSMCT32, s.fbp, s.fbw, x, y, (c & ~m) | (old & m));
+ write_sample(PSMCT32, s.fbp, s.fbw, x, y, k, (c & ~m) | (old & m));
}
default {
var v = c;
if (mask != 0u) {
- let old = read_pixel(s.fpsm, s.fbp, s.fbw, x, y);
+ let old = read_sample(s.fpsm, s.fbp, s.fbw, x, y, k);
v = (c & ~mask) | (old & mask);
}
- write_pixel(s.fpsm, s.fbp, s.fbw, x, y, v);
+ write_sample(s.fpsm, s.fbp, s.fbw, x, y, k, v);
}
}
}
@@ -523,7 +551,7 @@ struct Attr {
z: u32,
}
-fn plot(s: Setup, x: i32, y: i32, at: Attr) {
+fn plot(s: Setup, x: i32, y: i32, k: u32, at: Attr) {
if (x < s.scax0 || x > s.scax1 || y < s.scay0 || y > s.scay1) {
return;
}
@@ -556,7 +584,7 @@ fn plot(s: Setup, x: i32, y: i32, at: Attr) {
u = at.s / q * f32(1u << s.tw);
v = at.t / q * f32(1u << s.th);
}
- let t = sample(s, u, v);
+ let t = sample(s, u, v, k);
let tr = i32(t & 0xFFu);
let tg = i32((t >> 8u) & 0xFFu);
let tb = i32((t >> 16u) & 0xFFu);
@@ -661,7 +689,7 @@ fn plot(s: Setup, x: i32, y: i32, at: Attr) {
var dst = 0u;
var have_dst = false;
if (has(s, F_DATE)) {
- dst = read_frame(s, ux, uy);
+ dst = read_frame(s, ux, uy, k);
have_dst = true;
if (((dst & 0x80000000u) != 0u) != has(s, F_DATM)) {
return;
@@ -670,7 +698,7 @@ fn plot(s: Setup, x: i32, y: i32, at: Attr) {
let zte = has(s, F_ZTE);
if (zte) {
- let old = read_pixel(s.zpsm, s.zbp, s.fbw, ux, uy) & s.zmax;
+ let old = read_sample(s.zpsm, s.zbp, s.fbw, ux, uy, k) & s.zmax;
var ok = false;
switch mode(s, 8u, 2u) {
case 0u {
@@ -695,7 +723,7 @@ fn plot(s: Setup, x: i32, y: i32, at: Attr) {
let colclamp = has(s, F_COLCLAMP);
if (has(s, F_ABE) && (!has(s, F_PABE) || (a & 0x80) != 0)) {
if (!have_dst) {
- dst = read_frame(s, ux, uy);
+ dst = read_frame(s, ux, uy, k);
}
let cd = vec3<i32>(i32(dst & 0xFFu), i32((dst >> 8u) & 0xFFu), i32((dst >> 16u) & 0xFFu));
let cs = vec3<i32>(r, g, b);
@@ -750,10 +778,10 @@ fn plot(s: Setup, x: i32, y: i32, at: Attr) {
if (!write_alpha) {
mask = mask | 0xFF000000u;
}
- write_frame(s, ux, uy, u32(r) | (u32(g) << 8u) | (u32(b) << 16u) | (out_a << 24u), mask);
+ write_frame(s, ux, uy, k, u32(r) | (u32(g) << 8u) | (u32(b) << 16u) | (out_a << 24u), mask);
}
if (write_z && zte) {
- write_pixel(s.zpsm, s.zbp, s.fbw, ux, uy, z);
+ write_sample(s.zpsm, s.zbp, s.fbw, ux, uy, k, z);
}
}
@@ -782,9 +810,15 @@ fn z_at(p: u32, d: f32) -> u32 {
}
fn shade(p: u32, s: Setup, x: i32, y: i32) {
+ for (var k = 0u; k < SCALE * SCALE; k = k + 1u) {
+ let px = f32(x) + f32(k % SCALE) / f32(SCALE);
+ let py = f32(y) + f32(k / SCALE) / f32(SCALE);
+ shade_at(p, s, x, y, k, px, py);
+ }
+}
+
+fn shade_at(p: u32, s: Setup, x: i32, y: i32, k: u32, px: f32, py: f32) {
let kind = data[p + 1u];
- let px = f32(x);
- let py = f32(y);
var at: Attr;
switch kind {
case 0u {
@@ -810,6 +844,9 @@ fn shade(p: u32, s: Setup, x: i32, y: i32) {
let y0 = fat(p + 5u);
let dx = fat(p + 6u);
let dy = fat(p + 7u);
+ if (SCALE > 1u && (px < min(x0, x0 + dx) || px >= max(x0, x0 + dx) || py < min(y0, y0 + dy) || py >= max(y0, y0 + dy))) {
+ return;
+ }
let a = vertex_tex(p, 0u);
let b = vertex_tex(p, 1u);
var tx = 0.0;
@@ -871,7 +908,16 @@ fn shade(p: u32, s: Setup, x: i32, y: i32) {
at = Attr(c.x, c.y, c.z, c.w, t.x, t.y, t.z, t.w, data[p + 36u]);
}
}
- plot(s, x, y, at);
+ plot(s, x, y, k, at);
+}
+
+@compute @workgroup_size(64)
+fn resolve(@builtin(global_invocation_id) gid: vec3<u32>) {
+ let i = gid.x + gid.y * 64u * 1024u;
+ if (i >= 1048576u) {
+ return;
+ }
+ scratch[i] = atomicLoad(&vram[i * SCALE * SCALE]);
}
@compute @workgroup_size(16, 16)
diff --git a/runtime/src/gs/gs.cpp b/runtime/src/gs/gs.cpp
index 22262fa..9a53c52 100644
--- a/runtime/src/gs/gs.cpp
+++ b/runtime/src/gs/gs.cpp
@@ -756,9 +756,10 @@ bool display(const DisplayRegs &r, std::vector<std::uint32_t> &rgba, std::uint32
#ifdef PS2_GPU
if (gpu_on()) {
const gpu::DisplaySource src{fbp * 32, fbw, psm, dbx, dby, width, height, halved};
- if (!cpu_raster()) return gpu::display(src, rgba);
+ if (!cpu_raster()) return gpu::display(src, rgba, width, height);
static const bool compare = std::getenv("PS2_GS_COMPARE") != nullptr;
- if (compare) g_gpu_frame.clear(), gpu::display(src, g_gpu_frame);
+ std::uint32_t gw = 0, gh = 0;
+ if (compare) g_gpu_frame.clear(), gpu::display(src, g_gpu_frame, gw, gh);
}
#endif
rgba.resize(static_cast<std::size_t>(width) * height);
diff --git a/web/shell.html b/web/shell.html
index ea79a8a..fc1d6bb 100644
--- a/web/shell.html
+++ b/web/shell.html
@@ -13,6 +13,7 @@
#bar { display: flex; gap: 16px; align-items: center; padding: 6px 12px; background: #141418; border-top: 1px solid #222; }
#status { flex: 1; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
#stats { font-variant-numeric: tabular-nums; color: #9ad; }
+ select { background: #2a3a55; color: #fff; border: 0; padding: 5px 8px; border-radius: 4px; }
button { background: #2a3a55; color: #fff; border: 0; padding: 6px 14px; border-radius: 4px; cursor: pointer; }
#overlay { position: fixed; inset: 0; display: flex; align-items: center; justify-content: center; background: rgba(0,0,0,.6); padding: 16px; }
#panel { display: flex; flex-direction: column; align-items: center; gap: 14px; max-width: 520px; text-align: center; }
@@ -94,7 +95,13 @@
</div>
</div>
</div>
-<div id="bar"><span id="status">Loading…</span><span id="stats"></span><button id="controls-toggle" type="button" hidden>Hide controls</button></div>
+<div id="bar"><span id="status">Loading…</span><span id="stats"></span>
+ <select id="scale" aria-label="Resolution" title="Internal resolution, the page reloads to apply it">
+ <option value="1">640×512</option>
+ <option value="2">1280×1024</option>
+ <option value="3">1920×1536</option>
+ </select>
+ <button id="controls-toggle" type="button" hidden>Hide controls</button></div>
<div id="overlay"><div id="panel"><p id="help" hidden></p><button id="start" disabled>Loading…</button></div></div>
<script>
const statusEl = document.getElementById('status');
@@ -172,6 +179,20 @@ function onTouch(e) {
}
for (const type of ['touchstart', 'touchmove', 'touchend', 'touchcancel']) touchRoot.addEventListener(type, onTouch, { passive: false });
+const scaleSelect = document.getElementById('scale');
+let scale = params.get('PS2_SCALE');
+if (!scale) {
+ try { scale = localStorage.getItem('ps2web-scale'); } catch (e) {}
+}
+scale = ['1', '2', '3'].includes(scale) ? scale : '1';
+scaleSelect.value = scale;
+scaleSelect.addEventListener('change', () => {
+ try { localStorage.setItem('ps2web-scale', scaleSelect.value); } catch (e) {}
+ const url = new URL(location.href);
+ url.searchParams.delete('PS2_SCALE');
+ location.href = url.href;
+});
+
const controlsButton = document.getElementById('controls-toggle');
let hideControls = false;
try { hideControls = localStorage.getItem('ps2web-hide-controls') === '1'; } catch (e) {}
@@ -385,6 +406,7 @@ var Module = {
},
preRun: [() => {
for (const [key, value] of params) if (key.startsWith('PS2_')) Module.ENV[key] = value;
+ Module.ENV.PS2_SCALE = scale;
Module.addRunDependency('disc');
Promise.all([fetch(Module.discUrl, { method: 'HEAD' }), chooseGpu().catch((e) => 'GPU check failed: ' + e)]).then(([r, gpu]) => {
Module.discSize = Number(r.headers.get('content-length')) || 0;