Skip to content

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

C++

gs: faster raster at higher internal resolutions

Samir Nuric4ed5de074e9
diff --git a/runtime/src/gs/gpu/gpu.cpp b/runtime/src/gs/gpu/gpu.cpp
index 502f75b..e5f1d18 100644
--- a/runtime/src/gs/gpu/gpu.cpp
+++ b/runtime/src/gs/gpu/gpu.cpp
@@ -144,7 +144,7 @@ bool uploads_overlap(const PreOp &a, const PreOp &b) {
std::vector<PreOp> g_pre;
std::vector<Range> g_batch_reads;
-int g_tile = 16, g_tiles_per_row = 128;
+int g_tiles_per_row = 128;
std::vector<std::uint32_t> g_tile_count(128 * 128), g_tile_fill(128 * 128);
std::vector<std::uint32_t> g_touched;
@@ -219,6 +219,65 @@ std::uint32_t arena_append(const void *bytes, std::size_t size) {
return offset;
}
+float u2f(std::uint32_t u) {
+ float f;
+ std::memcpy(&f, &u, 4);
+ return f;
+}
+
+struct Span {
+ std::int16_t ty, tx0, tx1;
+};
+std::vector<Span> g_spans;
+std::vector<std::uint32_t> g_span_start;
+
+void add_spans(const std::uint32_t *rec, std::uint32_t lo, std::uint32_t hi) {
+ const int sc = static_cast<int>(g_scale);
+ const int tx0 = static_cast<int>(lo & 0xFFFFu) * sc / 16, ty0 = static_cast<int>(lo >> 16) * sc / 16;
+ const int tx1 = (static_cast<int>(hi & 0xFFFFu) * sc + sc - 1) / 16, ty1 = (static_cast<int>(hi >> 16) * sc + sc - 1) / 16;
+ const auto whole = [&] {
+ for (int ty = ty0; ty <= ty1; ++ty) g_spans.push_back({static_cast<std::int16_t>(ty), static_cast<std::int16_t>(tx0), static_cast<std::int16_t>(tx1)});
+ };
+ if (rec[1] != 0 || tx1 - tx0 < 2) {
+ whole();
+ return;
+ }
+ const double x[3] = {u2f(rec[4]), u2f(rec[6]), u2f(rec[8])}, y[3] = {u2f(rec[5]), u2f(rec[7]), u2f(rec[9])};
+ const double inv = u2f(rec[10]);
+ static const int kEdges[3][2] = {{1, 2}, {2, 0}, {0, 1}};
+ double m[3], q[3];
+ int kind[3];
+ for (int e = 0; e < 3; ++e) {
+ const int a = kEdges[e][0], b = kEdges[e][1];
+ const double ca = (y[a] - y[b]) * inv, cb = (x[b] - x[a]) * inv, cc = (x[a] * y[b] - x[b] * y[a]) * inv;
+ if (!std::isfinite(ca) || !std::isfinite(cb) || !std::isfinite(cc)) {
+ whole();
+ return;
+ }
+ kind[e] = ca > 0.0 ? 1 : ca < 0.0 ? -1 : 0;
+ m[e] = kind[e] ? -cb / ca : cb;
+ q[e] = kind[e] ? -cc / ca : cc;
+ }
+ const double span = 16.0 / static_cast<double>(sc);
+ for (int ty = ty0; ty <= ty1; ++ty) {
+ const double y0 = ty * span - 1.0, y1 = (ty + 1) * span + 1.0;
+ double left = -1e30, right = 1e30;
+ bool empty = false;
+ for (int e = 0; e < 3; ++e) {
+ const double a0 = m[e] * y0, a1 = m[e] * y1;
+ if (kind[e] == 0) empty = empty || std::max(a0, a1) + q[e] < 0.0;
+ else if (kind[e] > 0) left = std::max(left, std::min(a0, a1) + q[e]);
+ else right = std::min(right, std::max(a0, a1) + q[e]);
+ }
+ left -= 1.0;
+ right += 1.0;
+ if (empty || left > right) continue;
+ const int rx0 = std::max(tx0, static_cast<int>(std::floor(std::max(left, -1.0) / span)));
+ const int rx1 = std::min(tx1, static_cast<int>(std::floor(std::min(right, 4096.0) / span)));
+ if (rx0 <= rx1) g_spans.push_back({static_cast<std::int16_t>(ty), static_cast<std::int16_t>(rx0), static_cast<std::int16_t>(rx1)});
+ }
+}
+
void flush_batch() {
Batch &b = g_batch;
if (b.prims.empty()) {
@@ -227,16 +286,19 @@ void flush_batch() {
}
const std::uint32_t prims = static_cast<std::uint32_t>(b.prims.size() / kPrimWords);
g_touched.clear();
+ g_spans.clear();
+ g_span_start.resize(prims + 1);
for (std::uint32_t i = 0; i < prims; ++i) {
- const std::uint32_t lo = b.boxes[i * 2], hi = b.boxes[i * 2 + 1];
- const int tx0 = static_cast<int>(lo & 0xFFFFu) / g_tile, ty0 = static_cast<int>(lo >> 16) / g_tile;
- const int tx1 = static_cast<int>(hi & 0xFFFFu) / g_tile, ty1 = static_cast<int>(hi >> 16) / g_tile;
- for (int ty = ty0; ty <= ty1; ++ty)
- for (int tx = tx0; tx <= tx1; ++tx) {
- const std::uint32_t t = static_cast<std::uint32_t>(ty * g_tiles_per_row + tx);
+ g_span_start[i] = static_cast<std::uint32_t>(g_spans.size());
+ add_spans(b.prims.data() + i * kPrimWords, b.boxes[i * 2], b.boxes[i * 2 + 1]);
+ for (std::size_t k = g_span_start[i]; k < g_spans.size(); ++k) {
+ const Span &sp = g_spans[k];
+ std::uint32_t t = static_cast<std::uint32_t>(sp.ty * g_tiles_per_row + sp.tx0);
+ for (int tx = sp.tx0; tx <= sp.tx1; ++tx, ++t)
if (!g_tile_count[t]++) g_touched.push_back(t);
- }
+ }
}
+ g_span_start[prims] = static_cast<std::uint32_t>(g_spans.size());
const std::uint32_t prim_offset = arena_append(b.prims.data(), b.prims.size() * 4);
const std::uint32_t setup_offset = arena_append(b.setups.data(), b.setups.size() * 4);
std::uint32_t total = 0;
@@ -256,13 +318,13 @@ void flush_batch() {
g_tile_fill[t] = cursor;
cursor += g_tile_count[t];
}
- for (std::uint32_t i = 0; i < prims; ++i) {
- const std::uint32_t lo = b.boxes[i * 2], hi = b.boxes[i * 2 + 1];
- const int tx0 = static_cast<int>(lo & 0xFFFFu) / g_tile, ty0 = static_cast<int>(lo >> 16) / g_tile;
- const int tx1 = static_cast<int>(hi & 0xFFFFu) / g_tile, ty1 = static_cast<int>(hi >> 16) / g_tile;
- for (int ty = ty0; ty <= ty1; ++ty)
- for (int tx = tx0; tx <= tx1; ++tx) g_arena[g_tile_fill[static_cast<std::uint32_t>(ty * g_tiles_per_row + tx)]++] = i;
- }
+ std::uint32_t *arena = g_arena.data();
+ for (std::uint32_t i = 0; i < prims; ++i)
+ for (std::uint32_t k = g_span_start[i]; k < g_span_start[i + 1]; ++k) {
+ const Span &sp = g_spans[k];
+ std::uint32_t t = static_cast<std::uint32_t>(sp.ty * g_tiles_per_row + sp.tx0);
+ for (int tx = sp.tx0; tx <= sp.tx1; ++tx, ++t) arena[g_tile_fill[t]++] = i;
+ }
for (std::uint32_t t : g_touched) g_tile_count[t] = 0;
const std::uint32_t param = push_params({tile_offset, prim_offset, setup_offset, tiles});
g_commands.push_back({kRaster, std::min(tiles, 1024u), (tiles + 1023) / 1024, param});
@@ -439,17 +501,11 @@ void ensure_capacity() {
}
// Browsers copy writes above about 1 MiB through a slower path, so large uploads go in pieces.
-void write_buffer(WGPUBuffer buffer, const void *data, std::uint64_t bytes) {
- constexpr std::uint64_t kPiece = 1u << 20;
- for (std::uint64_t at = 0; at < bytes; at += kPiece)
- wgpuQueueWriteBuffer(g_queue, buffer, at, static_cast<const std::uint8_t *>(data) + at, std::min(kPiece, bytes - at));
-}
-
void submit(WGPUTextureView present_view = nullptr) {
if (g_commands.empty() && !present_view) return;
ensure_capacity();
- write_buffer(g_data, g_arena.data(), g_arena.size() * 4);
- write_buffer(g_params, g_param_records.data(), g_param_records.size() * kParamStride);
+ wgpuQueueWriteBuffer(g_queue, g_data, 0, g_arena.data(), g_arena.size() * 4);
+ wgpuQueueWriteBuffer(g_queue, g_params, 0, g_param_records.data(), g_param_records.size() * kParamStride);
if (g_query_ready) {
const void *mapped = wgpuBufferGetConstMappedRange(g_query_read, 0, 16);
if (mapped) {
@@ -687,8 +743,7 @@ bool init(Mode m) {
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_tile = 16 / static_cast<int>(g_scale);
- g_tiles_per_row = (2048 + g_tile - 1) / g_tile;
+ g_tiles_per_row = (2048 * static_cast<int>(g_scale) + 15) / 16;
g_tile_count.assign(static_cast<std::size_t>(g_tiles_per_row) * g_tiles_per_row, 0);
g_tile_fill.assign(static_cast<std::size_t>(g_tiles_per_row) * g_tiles_per_row, 0);
g_field_words = (1u << 19) * g_scale * g_scale;
diff --git a/runtime/src/gs/gpu/gs.wgsl b/runtime/src/gs/gpu/gs.wgsl
index efdcb0d..d3381ca 100644
--- a/runtime/src/gs/gpu/gs.wgsl
+++ b/runtime/src/gs/gpu/gs.wgsl
@@ -10,8 +10,6 @@ struct Params {
@group(0) @binding(5) var<storage, read_write> scratch: array<u32>;
override SCALE: u32 = 1u;
-override TILE: u32 = 16u / SCALE;
-override WG: u32 = TILE * SCALE;
const PSMCT32: u32 = 0x00u;
const PSMCT24: u32 = 0x01u;
@@ -122,6 +120,104 @@ fn locate(psm: u32, bp: u32, bw: u32, x: u32, y: u32) -> Loc {
return Loc((a & 0x3FFFFFu) >> 2u, shift, mask);
}
+struct Fmt {
+ base: u32,
+ per_row: u32,
+ table: u32,
+ bits: u32,
+ mask: u32,
+}
+
+fn fmt_of(psm: u32, bp: u32, bw: u32) -> Fmt {
+ var pws = 6u;
+ var phs = 5u;
+ var table = T_OFF32;
+ var amask = 0u;
+ var nbit = 0u;
+ var fixed = 0u;
+ var mask = 0xFFFFFFFFu;
+ switch psm {
+ case 0x30u {
+ table = T_OFFZ32;
+ }
+ case 0x31u {
+ table = T_OFFZ32;
+ mask = 0xFFFFFFu;
+ }
+ case 0x01u {
+ mask = 0xFFFFFFu;
+ }
+ case 0x02u {
+ phs = 6u;
+ table = T_OFF16;
+ amask = 2u;
+ mask = 0xFFFFu;
+ }
+ case 0x0Au {
+ phs = 6u;
+ table = T_OFF16S;
+ amask = 2u;
+ mask = 0xFFFFu;
+ }
+ case 0x32u {
+ phs = 6u;
+ table = T_OFFZ16;
+ amask = 2u;
+ mask = 0xFFFFu;
+ }
+ case 0x3Au {
+ phs = 6u;
+ table = T_OFFZ16S;
+ amask = 2u;
+ mask = 0xFFFFu;
+ }
+ case 0x13u {
+ pws = 7u;
+ phs = 6u;
+ table = T_OFF8;
+ amask = 3u;
+ mask = 0xFFu;
+ }
+ case 0x14u {
+ pws = 7u;
+ phs = 7u;
+ table = T_OFF4;
+ amask = 3u;
+ nbit = 1u;
+ mask = 0xFu;
+ }
+ case 0x1Bu {
+ fixed = 24u;
+ mask = 0xFFu;
+ }
+ case 0x24u {
+ fixed = 24u;
+ mask = 0xFu;
+ }
+ case 0x2Cu {
+ fixed = 28u;
+ mask = 0xFu;
+ }
+ default {
+ }
+ }
+ return Fmt(bp * 256u, max(1u, (bw * 64u) >> pws), table, pws | (phs << 4u) | (amask << 8u) | (nbit << 10u) | (fixed << 11u), mask);
+}
+
+fn addr(f: Fmt, x: u32, y: u32) -> Loc {
+ let pws = f.bits & 15u;
+ let phs = (f.bits >> 4u) & 15u;
+ let amask = (f.bits >> 8u) & 3u;
+ let nbit = (f.bits >> 10u) & 1u;
+ let n = tables[f.table + ((y & ((1u << phs) - 1u)) << pws) + (x & ((1u << pws) - 1u))];
+ let a = f.base + ((x >> pws) + (y >> phs) * f.per_row) * 8192u + (n >> nbit);
+ return Loc((a & 0x3FFFFFu) >> 2u, (f.bits >> 11u) + (a & amask) * 8u + (n & nbit) * 4u, f.mask);
+}
+
+fn load_at(l: Loc, k: u32) -> u32 {
+ return (atomicLoad(&vram[l.word * SCALE * SCALE + k]) >> l.shift) & l.mask;
+}
+
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 * SCALE * SCALE + k]) >> l.shift) & l.mask;
@@ -320,6 +416,9 @@ struct Setup {
fogcol: u32,
clut: u32,
zmax: u32,
+ tf: Fmt,
+ ff: Fmt,
+ zf: Fmt,
}
const F_IIP: u32 = 1u;
@@ -371,6 +470,9 @@ fn load_setup(at: u32) -> Setup {
s.fogcol = data[at + 21u];
s.clut = data[at + 22u];
s.zmax = data[at + 23u];
+ s.tf = fmt_of(s.tpsm, s.tbp, s.tbw);
+ s.ff = fmt_of(s.fpsm, s.fbp, s.fbw);
+ s.zf = fmt_of(s.zpsm, s.zbp, s.fbw);
return s;
}
@@ -425,7 +527,7 @@ fn texel_y(s: Setup, yi: i32) -> u32 {
}
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));
+ return convert(s, load_at(addr(s.tf, texel_x(s, xi), texel_y(s, yi)), k));
}
fn convert(s: Setup, raw: u32) -> u32 {
@@ -488,8 +590,8 @@ fn blend4(c00: u32, c10: u32, c01: u32, c11: u32, fx: f32, fy: f32) -> u32 {
return out;
}
-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);
+fn read_frame(s: Setup, l: Loc, k: u32) -> u32 {
+ let raw = load_at(l, k);
switch s.fpsm {
case 0x01u {
return raw | 0x80000000u;
@@ -515,28 +617,29 @@ 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, k: u32, c: u32, mask: u32) {
+fn write_frame(s: Setup, l: Loc, k: u32, c: u32, mask: u32) {
switch s.fpsm {
case 0x02u, 0x0Au {
- let old = read_sample(s.fpsm, s.fbp, s.fbw, x, y, k);
+ let old = load_at(l, k);
var m16 = pack16(mask);
if ((mask & 0x80000000u) != 0u) {
m16 = m16 | 0x8000u;
}
- write_sample(s.fpsm, s.fbp, s.fbw, x, y, k, (pack16(c) & ~m16) | (old & m16));
+ store(l, k, (pack16(c) & ~m16) | (old & m16));
}
case 0x01u {
- let old = read_sample(PSMCT32, s.fbp, s.fbw, x, y, k);
+ let l32 = Loc(l.word, 0u, 0xFFFFFFFFu);
+ let old = load_at(l32, k);
let m = mask | 0xFF000000u;
- write_sample(PSMCT32, s.fbp, s.fbw, x, y, k, (c & ~m) | (old & m));
+ store(l32, k, (c & ~m) | (old & m));
}
default {
var v = c;
if (mask != 0u) {
- let old = read_sample(s.fpsm, s.fbp, s.fbw, x, y, k);
+ let old = load_at(l, k);
v = (c & ~mask) | (old & mask);
}
- write_sample(s.fpsm, s.fbp, s.fbw, x, y, k, v);
+ store(l, k, v);
}
}
}
@@ -567,6 +670,8 @@ fn plot(s: Setup, x: i32, y: i32, k: u32, at: Attr) {
let ux = u32(x);
let uy = u32(y);
let z = min(at.z, s.zmax);
+ let fl = addr(s.ff, ux, uy);
+ var zl = Loc(0u, 0u, 0u);
var r = i32(at.r);
var g = i32(at.g);
@@ -691,7 +796,7 @@ fn plot(s: Setup, x: i32, y: i32, k: u32, at: Attr) {
var dst = 0u;
var have_dst = false;
if (has(s, F_DATE)) {
- dst = read_frame(s, ux, uy, k);
+ dst = read_frame(s, fl, k);
have_dst = true;
if (((dst & 0x80000000u) != 0u) != has(s, F_DATM)) {
return;
@@ -700,7 +805,8 @@ fn plot(s: Setup, x: i32, y: i32, k: u32, at: Attr) {
let zte = has(s, F_ZTE);
if (zte) {
- let old = read_sample(s.zpsm, s.zbp, s.fbw, ux, uy, k) & s.zmax;
+ zl = addr(s.zf, ux, uy);
+ let old = load_at(zl, k) & s.zmax;
var ok = false;
switch mode(s, 8u, 2u) {
case 0u {
@@ -725,7 +831,7 @@ fn plot(s: Setup, x: i32, y: i32, k: u32, 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, k);
+ dst = read_frame(s, fl, k);
}
let cd = vec3<i32>(i32(dst & 0xFFu), i32((dst >> 8u) & 0xFFu), i32((dst >> 16u) & 0xFFu));
let cs = vec3<i32>(r, g, b);
@@ -780,10 +886,10 @@ fn plot(s: Setup, x: i32, y: i32, k: u32, at: Attr) {
if (!write_alpha) {
mask = mask | 0xFF000000u;
}
- write_frame(s, ux, uy, k, u32(r) | (u32(g) << 8u) | (u32(b) << 16u) | (out_a << 24u), mask);
+ write_frame(s, fl, k, u32(r) | (u32(g) << 8u) | (u32(b) << 16u) | (out_a << 24u), mask);
}
if (write_z && zte) {
- write_sample(s.zpsm, s.zbp, s.fbw, ux, uy, k, z);
+ store(zl, k, z);
}
}
@@ -914,18 +1020,20 @@ fn resolve(@builtin(global_invocation_id) gid: vec3<u32>) {
scratch[i] = atomicLoad(&vram[i * SCALE * SCALE]);
}
-@compute @workgroup_size(WG, WG)
+@compute @workgroup_size(16, 16)
fn raster(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) lid: vec3<u32>) {
let tile = prm(0u) + (wid.x + wid.y * 1024u) * 4u;
if (wid.x + wid.y * 1024u >= prm(3u)) {
return;
}
let origin = data[tile];
- let x = i32((origin & 0xFFFFu) * TILE + lid.x / SCALE);
- let y = i32((origin >> 16u) * TILE + lid.y / SCALE);
- let k = (lid.y % SCALE) * SCALE + lid.x % SCALE;
- let px = f32(x) + f32(lid.x % SCALE) / f32(SCALE);
- let py = f32(y) + f32(lid.y % SCALE) / f32(SCALE);
+ let sx = (origin & 0xFFFFu) * 16u + lid.x;
+ let sy = (origin >> 16u) * 16u + lid.y;
+ let x = i32(sx / SCALE);
+ let y = i32(sy / SCALE);
+ let k = (sy % SCALE) * SCALE + sx % SCALE;
+ let px = f32(x) + f32(sx % SCALE) / f32(SCALE);
+ let py = f32(y) + f32(sy % SCALE) / f32(SCALE);
let list = data[tile + 1u];
let count = data[tile + 2u];
let prims = prm(1u);
@@ -934,16 +1042,16 @@ fn raster(@builtin(workgroup_id) wid: vec3<u32>, @builtin(local_invocation_id) l
var s: Setup;
for (var i = 0u; i < count; i = i + 1u) {
let p = prims + data[list + i] * PRIM_WORDS;
- let lo = data[p + 2u];
- let hi = data[p + 3u];
- if (x < i32(lo & 0xFFFFu) || y < i32(lo >> 16u) || x > i32(hi & 0xFFFFu) || y > i32(hi >> 16u)) {
- continue;
- }
let si = data[p];
if (si != last_setup) {
s = load_setup(setups + si * SETUP_WORDS);
last_setup = si;
}
+ let lo = data[p + 2u];
+ let hi = data[p + 3u];
+ if (x < i32(lo & 0xFFFFu) || y < i32(lo >> 16u) || x > i32(hi & 0xFFFFu) || y > i32(hi >> 16u)) {
+ continue;
+ }
shade_at(p, s, x, y, k, px, py);
}
}