Skip to content

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

C++

gs: present straight to a WebGPU surface

Samir Nuri05659df0b8a7
diff --git a/CMakeLists.txt b/CMakeLists.txt
index d86e9ff..368d5ea 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -54,7 +54,11 @@ if(EMSCRIPTEN OR EXISTS "${PS2_WGPU_DIR}/lib/libwgpu_native.a")
add_custom_command(OUTPUT "${PS2_GS_WGSL}"
COMMAND ${CMAKE_COMMAND} -DSRC=${CMAKE_SOURCE_DIR}/runtime/src/gs/gpu/gs.wgsl -DOUT=${PS2_GS_WGSL} -DNAME=kGsShader -P ${CMAKE_SOURCE_DIR}/cmake/embed.cmake
DEPENDS runtime/src/gs/gpu/gs.wgsl cmake/embed.cmake)
- target_sources(ps2runtime PRIVATE runtime/src/gs/gpu/gpu.cpp "${PS2_GS_WGSL}")
+ set(PS2_BLIT_WGSL "${CMAKE_BINARY_DIR}/blit_wgsl.cpp")
+ add_custom_command(OUTPUT "${PS2_BLIT_WGSL}"
+ COMMAND ${CMAKE_COMMAND} -DSRC=${CMAKE_SOURCE_DIR}/runtime/src/gs/gpu/blit.wgsl -DOUT=${PS2_BLIT_WGSL} -DNAME=kBlitShader -P ${CMAKE_SOURCE_DIR}/cmake/embed.cmake
+ DEPENDS runtime/src/gs/gpu/blit.wgsl cmake/embed.cmake)
+ target_sources(ps2runtime PRIVATE runtime/src/gs/gpu/gpu.cpp "${PS2_GS_WGSL}" "${PS2_BLIT_WGSL}")
target_compile_definitions(ps2runtime PUBLIC PS2_GPU)
if(EMSCRIPTEN)
target_compile_options(ps2runtime PUBLIC --use-port=emdawnwebgpu)
diff --git a/host/window.cpp b/host/window.cpp
index 75c287f..261a612 100644
--- a/host/window.cpp
+++ b/host/window.cpp
@@ -3,9 +3,11 @@
#include "ps2/system.hpp"
#include <SDL.h>
+#include <SDL_syswm.h>
#include <algorithm>
#include <cstdio>
+#include <cstdlib>
#include <vector>
namespace {
@@ -53,6 +55,47 @@ SDL_GameController *g_pad = nullptr;
std::uint32_t g_tex_w = 0, g_tex_h = 0;
std::uint64_t g_last = 0;
std::vector<std::uint32_t> g_pixels;
+bool g_gpu_tried = false, g_gpu_present = false;
+
+bool create_renderer() {
+ g_renderer = SDL_CreateRenderer(g_window, -1, SDL_RENDERER_ACCELERATED);
+ if (!g_renderer) g_renderer = SDL_CreateRenderer(g_window, -1, SDL_RENDERER_SOFTWARE);
+ if (!g_renderer) {
+ std::fprintf(stderr, "SDL: %s\n", SDL_GetError());
+ return false;
+ }
+ return true;
+}
+
+bool attach_gpu() {
+ if (std::getenv("PS2_SDL_RENDERER")) return false;
+ SDL_SysWMinfo info;
+ SDL_VERSION(&info.version);
+ if (!SDL_GetWindowWMInfo(g_window, &info)) return false;
+ ps2::WindowTarget target;
+ int w = 0, h = 0;
+ SDL_GetWindowSizeInPixels(g_window, &w, &h);
+ target.width = static_cast<std::uint32_t>(w);
+ target.height = static_cast<std::uint32_t>(h);
+ switch (info.subsystem) {
+#if defined(SDL_VIDEO_DRIVER_X11)
+ case SDL_SYSWM_X11:
+ target.kind = ps2::WindowTarget::X11;
+ target.display = info.info.x11.display;
+ target.window = static_cast<std::uint64_t>(info.info.x11.window);
+ break;
+#endif
+#if defined(SDL_VIDEO_DRIVER_WAYLAND)
+ case SDL_SYSWM_WAYLAND:
+ target.kind = ps2::WindowTarget::Wayland;
+ target.display = info.info.wl.display;
+ target.surface = info.info.wl.surface;
+ break;
+#endif
+ default: return false;
+ }
+ return ps2::attach_window(target);
+}
std::uint8_t axis(SDL_GameControllerAxis a) {
const int v = SDL_GameControllerGetAxis(g_pad, a);
@@ -63,6 +106,11 @@ void poll() {
SDL_Event e;
while (SDL_PollEvent(&e)) {
if (e.type == SDL_QUIT) ps2::halt("window closed");
+ if (e.type == SDL_WINDOWEVENT && e.window.event == SDL_WINDOWEVENT_SIZE_CHANGED && g_gpu_present) {
+ int w = 0, h = 0;
+ SDL_GetWindowSizeInPixels(g_window, &w, &h);
+ ps2::resize_window(static_cast<std::uint32_t>(w), static_cast<std::uint32_t>(h));
+ }
if (e.type == SDL_CONTROLLERDEVICEADDED && !g_pad) g_pad = SDL_GameControllerOpen(e.cdevice.which);
if (e.type == SDL_CONTROLLERDEVICEREMOVED && g_pad && e.cdevice.which == SDL_JoystickInstanceID(SDL_GameControllerGetJoystick(g_pad))) {
SDL_GameControllerClose(g_pad);
@@ -96,6 +144,17 @@ void poll() {
}
void present() {
+ if (!g_gpu_tried) {
+ g_gpu_tried = true;
+ g_gpu_present = attach_gpu();
+ std::fprintf(stderr, "[window] %s\n", g_gpu_present ? "presenting through WebGPU" : "presenting through SDL");
+ if (!g_gpu_present && !create_renderer()) ps2::halt("no renderer");
+ }
+ if (g_gpu_present) {
+ ps2::present_frame();
+ return;
+ }
+ if (!g_renderer) return;
std::uint32_t w = 0, h = 0;
if (!ps2::display_frame(g_pixels, w, h)) return;
if (w != g_tex_w || h != g_tex_h) {
@@ -141,10 +200,8 @@ bool open_window() {
std::fprintf(stderr, "SDL: %s\n", SDL_GetError());
return false;
}
- g_window = SDL_CreateWindow("ps2-web-recomp", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 960, 720, SDL_WINDOW_RESIZABLE);
- g_renderer = g_window ? SDL_CreateRenderer(g_window, -1, SDL_RENDERER_ACCELERATED) : nullptr;
- if (g_window && !g_renderer) g_renderer = SDL_CreateRenderer(g_window, -1, SDL_RENDERER_SOFTWARE);
- if (!g_renderer) {
+ g_window = SDL_CreateWindow("ps2-web-recomp", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 960, 720, SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
+ if (!g_window) {
std::fprintf(stderr, "SDL: %s\n", SDL_GetError());
return false;
}
diff --git a/runtime/include/ps2/system.hpp b/runtime/include/ps2/system.hpp
index 9e69f96..abe81c9 100644
--- a/runtime/include/ps2/system.hpp
+++ b/runtime/include/ps2/system.hpp
@@ -69,6 +69,20 @@ bool halted();
std::uint64_t frame_count();
bool display_frame(std::vector<std::uint32_t> &rgba, std::uint32_t &width, std::uint32_t &height);
+
+struct WindowTarget {
+ enum Kind { X11, Wayland, Canvas } kind = X11;
+ void *display = nullptr;
+ std::uint64_t window = 0;
+ void *surface = nullptr;
+ const char *selector = nullptr;
+ std::uint32_t width = 0, height = 0;
+};
+
+// Lets the WebGPU renderer present straight to a window or canvas instead of handing frames back.
+bool attach_window(const WindowTarget &target);
+void resize_window(std::uint32_t width, std::uint32_t height);
+bool present_frame();
void set_pad_buttons(std::uint16_t pressed);
void set_pad_axis(int axis, std::uint8_t value);
void set_audio_sink(std::function<void(const std::int16_t *samples, std::size_t frames)> sink);
diff --git a/runtime/src/gs/gpu/blit.wgsl b/runtime/src/gs/gpu/blit.wgsl
new file mode 100644
index 0000000..7582bf2
--- /dev/null
+++ b/runtime/src/gs/gpu/blit.wgsl
@@ -0,0 +1,41 @@
+struct Blit {
+ width: u32,
+ height: u32,
+ pad0: u32,
+ pad1: u32,
+}
+
+@group(0) @binding(0) var<storage, read> pixels: array<u32>;
+@group(0) @binding(1) var<uniform> blit: Blit;
+
+struct VertexOut {
+ @builtin(position) position: vec4<f32>,
+ @location(0) uv: vec2<f32>,
+}
+
+@vertex
+fn vs(@builtin(vertex_index) i: u32) -> VertexOut {
+ let p = vec2<f32>(f32((i << 1u) & 2u), f32(i & 2u));
+ var o: VertexOut;
+ o.position = vec4<f32>(p * 2.0 - 1.0, 0.0, 1.0);
+ o.uv = vec2<f32>(p.x, 1.0 - p.y);
+ return o;
+}
+
+fn texel(x: i32, y: i32) -> vec4<f32> {
+ let cx = u32(clamp(x, 0, i32(blit.width) - 1));
+ let cy = u32(clamp(y, 0, i32(blit.height) - 1));
+ return unpack4x8unorm(pixels[cy * blit.width + cx]);
+}
+
+@fragment
+fn fs(in: VertexOut) -> @location(0) vec4<f32> {
+ let p = in.uv * vec2<f32>(f32(blit.width), f32(blit.height)) - 0.5;
+ let base = floor(p);
+ let f = p - base;
+ let x = i32(base.x);
+ let y = i32(base.y);
+ let top = mix(texel(x, y), texel(x + 1, y), f.x);
+ let bottom = mix(texel(x, y + 1), texel(x + 1, y + 1), f.x);
+ return vec4<f32>(mix(top, bottom, f.y).rgb, 1.0);
+}
diff --git a/runtime/src/gs/gpu/gpu.cpp b/runtime/src/gs/gpu/gpu.cpp
index 5a07e1e..3ce2e7f 100644
--- a/runtime/src/gs/gpu/gpu.cpp
+++ b/runtime/src/gs/gpu/gpu.cpp
@@ -15,6 +15,7 @@
#include <string>
extern const char kGsShader[];
+extern const char kBlitShader[];
namespace ps2::gs {
void swizzle_tables(std::vector<std::uint32_t> &out);
@@ -40,6 +41,14 @@ Mode g_mode = Mode::off;
std::uint64_t g_dispatches[kPipelines] = {}, g_submits = 0;
WGPUInstance g_instance = nullptr;
+WGPUAdapter g_adapter = nullptr;
+WGPUSurface g_surface = nullptr;
+WGPUTextureFormat g_surface_format = WGPUTextureFormat_Undefined;
+WGPUPresentMode g_present_mode = WGPUPresentMode_Fifo;
+std::uint32_t g_surface_width = 0, g_surface_height = 0;
+WGPURenderPipeline g_blit = nullptr;
+WGPUBindGroup g_blit_group = nullptr;
+WGPUBuffer g_blit_params = nullptr;
WGPUDevice g_device = nullptr;
WGPUQueue g_queue = nullptr;
WGPUBuffer g_vram = nullptr, g_tables = nullptr, g_params = nullptr, g_data = nullptr, g_clut = nullptr, g_scratch = nullptr, g_readback = nullptr;
@@ -415,8 +424,8 @@ void ensure_capacity() {
if (changed || !g_group) rebuild_group();
}
-void submit() {
- if (g_commands.empty()) return;
+void submit(WGPUTextureView present_view = nullptr) {
+ if (g_commands.empty() && !present_view) return;
ensure_capacity();
if (!g_arena.empty()) 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);
@@ -436,6 +445,25 @@ void submit() {
}
wgpuComputePassEncoderEnd(pass);
wgpuComputePassEncoderRelease(pass);
+ if (present_view) {
+ WGPURenderPassColorAttachment color = WGPU_RENDER_PASS_COLOR_ATTACHMENT_INIT;
+ color.view = present_view;
+ color.loadOp = WGPULoadOp_Clear;
+ color.storeOp = WGPUStoreOp_Store;
+ color.clearValue = WGPUColor{0.0, 0.0, 0.0, 1.0};
+ WGPURenderPassDescriptor rd = WGPU_RENDER_PASS_DESCRIPTOR_INIT;
+ rd.colorAttachmentCount = 1;
+ rd.colorAttachments = &color;
+ WGPURenderPassEncoder rp = wgpuCommandEncoderBeginRenderPass(enc, &rd);
+ const float w = static_cast<float>(g_surface_width), h = static_cast<float>(g_surface_height);
+ const float vw = std::min(w, h * 4.0f / 3.0f), vh = vw * 3.0f / 4.0f;
+ wgpuRenderPassEncoderSetViewport(rp, (w - vw) * 0.5f, (h - vh) * 0.5f, vw, vh, 0.0f, 1.0f);
+ wgpuRenderPassEncoderSetPipeline(rp, g_blit);
+ wgpuRenderPassEncoderSetBindGroup(rp, 0, g_blit_group, 0, nullptr);
+ wgpuRenderPassEncoderDraw(rp, 3, 1, 0, 0);
+ wgpuRenderPassEncoderEnd(rp);
+ wgpuRenderPassEncoderRelease(rp);
+ }
WGPUCommandBuffer cmd = wgpuCommandEncoderFinish(enc, nullptr);
wgpuQueueSubmit(g_queue, 1, &cmd);
wgpuCommandBufferRelease(cmd);
@@ -531,12 +559,22 @@ Mode mode() { return g_mode; }
bool init(Mode m) {
if (m == Mode::off) return false;
+#ifdef __EMSCRIPTEN__
g_instance = wgpuCreateInstance(nullptr);
+#else
+ WGPUInstanceExtras extras = {};
+ extras.chain.sType = static_cast<WGPUSType>(WGPUSType_InstanceExtras);
+ extras.backends = WGPUInstanceBackend_Primary;
+ WGPUInstanceDescriptor id = WGPU_INSTANCE_DESCRIPTOR_INIT;
+ id.nextInChain = &extras.chain;
+ g_instance = wgpuCreateInstance(&id);
+#endif
if (!g_instance) return false;
WGPUAdapter adapter = nullptr;
bool adapter_done = false;
WGPURequestAdapterOptions options = WGPU_REQUEST_ADAPTER_OPTIONS_INIT;
options.powerPreference = std::getenv("PS2_GPU_LOW_POWER") ? WGPUPowerPreference_LowPower : WGPUPowerPreference_HighPerformance;
+ options.forceFallbackAdapter = std::getenv("PS2_GPU_FALLBACK") != nullptr;
WGPURequestAdapterCallbackInfo acb = WGPU_REQUEST_ADAPTER_CALLBACK_INFO_INIT;
acb.mode = WGPUCallbackMode_AllowSpontaneous;
acb.callback = [](WGPURequestAdapterStatus status, WGPUAdapter a, WGPUStringView, void *out, void *done) {
@@ -576,7 +614,7 @@ bool init(Mode m) {
dcb.userdata2 = &device_done;
wgpuAdapterRequestDevice(adapter, &dd, dcb);
while (!device_done) wgpuInstanceProcessEvents(g_instance);
- wgpuAdapterRelease(adapter);
+ g_adapter = adapter;
if (!g_device) return false;
g_queue = wgpuDeviceGetQueue(g_device);
@@ -866,6 +904,148 @@ void stats() {
std::fprintf(stderr, "\n");
}
+void configure_surface() {
+ WGPUSurfaceConfiguration config = WGPU_SURFACE_CONFIGURATION_INIT;
+ config.device = g_device;
+ config.format = g_surface_format;
+ config.usage = WGPUTextureUsage_RenderAttachment;
+ config.width = std::max(g_surface_width, 1u);
+ config.height = std::max(g_surface_height, 1u);
+ config.presentMode = g_present_mode;
+ config.alphaMode = WGPUCompositeAlphaMode_Auto;
+ wgpuSurfaceConfigure(g_surface, &config);
+}
+
+bool attach_surface(const SurfaceTarget &target) {
+ if (g_mode != Mode::primary || !g_device) return false;
+ WGPUSurfaceDescriptor sd = WGPU_SURFACE_DESCRIPTOR_INIT;
+#ifdef __EMSCRIPTEN__
+ WGPUEmscriptenSurfaceSourceCanvasHTMLSelector canvas = WGPU_EMSCRIPTEN_SURFACE_SOURCE_CANVAS_HTML_SELECTOR_INIT;
+ canvas.selector = view(target.selector ? target.selector : "#canvas");
+ sd.nextInChain = &canvas.chain;
+#else
+ WGPUSurfaceSourceXlibWindow xlib = WGPU_SURFACE_SOURCE_XLIB_WINDOW_INIT;
+ WGPUSurfaceSourceWaylandSurface wayland = WGPU_SURFACE_SOURCE_WAYLAND_SURFACE_INIT;
+ if (target.kind == SurfaceTarget::X11) {
+ xlib.display = target.display;
+ xlib.window = target.window;
+ sd.nextInChain = &xlib.chain;
+ } else if (target.kind == SurfaceTarget::Wayland) {
+ wayland.display = target.display;
+ wayland.surface = target.surface;
+ sd.nextInChain = &wayland.chain;
+ } else {
+ return false;
+ }
+#endif
+ g_surface = wgpuInstanceCreateSurface(g_instance, &sd);
+ if (!g_surface) return false;
+ WGPUSurfaceCapabilities caps = WGPU_SURFACE_CAPABILITIES_INIT;
+ if (wgpuSurfaceGetCapabilities(g_surface, g_adapter, &caps) != WGPUStatus_Success || !caps.formatCount) {
+ wgpuSurfaceRelease(g_surface);
+ g_surface = nullptr;
+ return false;
+ }
+ g_surface_format = caps.formats[0];
+ for (std::size_t i = 0; i < caps.formatCount; ++i)
+ if (caps.formats[i] == WGPUTextureFormat_BGRA8Unorm || caps.formats[i] == WGPUTextureFormat_RGBA8Unorm) {
+ g_surface_format = caps.formats[i];
+ break;
+ }
+ g_present_mode = WGPUPresentMode_Fifo;
+ for (std::size_t i = 0; i < caps.presentModeCount; ++i)
+ if (caps.presentModes[i] == WGPUPresentMode_Mailbox) g_present_mode = WGPUPresentMode_Mailbox;
+ wgpuSurfaceCapabilitiesFreeMembers(caps);
+ g_surface_width = target.width;
+ g_surface_height = target.height;
+ configure_surface();
+
+ WGPUShaderSourceWGSL source = WGPU_SHADER_SOURCE_WGSL_INIT;
+ source.code = view(kBlitShader);
+ WGPUShaderModuleDescriptor md = WGPU_SHADER_MODULE_DESCRIPTOR_INIT;
+ md.nextInChain = &source.chain;
+ WGPUShaderModule module = wgpuDeviceCreateShaderModule(g_device, &md);
+ WGPUBindGroupLayoutEntry le[2] = {WGPU_BIND_GROUP_LAYOUT_ENTRY_INIT, WGPU_BIND_GROUP_LAYOUT_ENTRY_INIT};
+ le[0].binding = 0;
+ le[0].visibility = WGPUShaderStage_Fragment;
+ le[0].buffer.type = WGPUBufferBindingType_ReadOnlyStorage;
+ le[1].binding = 1;
+ le[1].visibility = WGPUShaderStage_Fragment;
+ le[1].buffer.type = WGPUBufferBindingType_Uniform;
+ WGPUBindGroupLayoutDescriptor ld = WGPU_BIND_GROUP_LAYOUT_DESCRIPTOR_INIT;
+ ld.entryCount = 2;
+ ld.entries = le;
+ WGPUBindGroupLayout layout = wgpuDeviceCreateBindGroupLayout(g_device, &ld);
+ WGPUPipelineLayoutDescriptor pld = WGPU_PIPELINE_LAYOUT_DESCRIPTOR_INIT;
+ pld.bindGroupLayoutCount = 1;
+ pld.bindGroupLayouts = &layout;
+ WGPUPipelineLayout pipeline_layout = wgpuDeviceCreatePipelineLayout(g_device, &pld);
+ WGPUColorTargetState color = WGPU_COLOR_TARGET_STATE_INIT;
+ color.format = g_surface_format;
+ WGPUFragmentState fragment = WGPU_FRAGMENT_STATE_INIT;
+ fragment.module = module;
+ fragment.entryPoint = view("fs");
+ fragment.targetCount = 1;
+ fragment.targets = &color;
+ WGPURenderPipelineDescriptor rd = WGPU_RENDER_PIPELINE_DESCRIPTOR_INIT;
+ rd.layout = pipeline_layout;
+ rd.vertex.module = module;
+ rd.vertex.entryPoint = view("vs");
+ rd.fragment = &fragment;
+ g_blit = wgpuDeviceCreateRenderPipeline(g_device, &rd);
+ wgpuShaderModuleRelease(module);
+ wgpuPipelineLayoutRelease(pipeline_layout);
+ g_blit_params = make_buffer(16, WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst);
+ WGPUBindGroupEntry be[2] = {WGPU_BIND_GROUP_ENTRY_INIT, WGPU_BIND_GROUP_ENTRY_INIT};
+ be[0].binding = 0;
+ be[0].buffer = g_scratch;
+ be[0].size = WGPU_WHOLE_SIZE;
+ be[1].binding = 1;
+ be[1].buffer = g_blit_params;
+ be[1].size = 16;
+ WGPUBindGroupDescriptor bd = WGPU_BIND_GROUP_DESCRIPTOR_INIT;
+ bd.layout = layout;
+ bd.entryCount = 2;
+ bd.entries = be;
+ g_blit_group = wgpuDeviceCreateBindGroup(g_device, &bd);
+ wgpuBindGroupLayoutRelease(layout);
+ return g_blit != nullptr;
+}
+
+void resize_surface(std::uint32_t width, std::uint32_t height) {
+ if (!g_surface || (width == g_surface_width && height == g_surface_height)) return;
+ g_surface_width = width;
+ g_surface_height = height;
+ configure_surface();
+}
+
+bool has_surface() { return g_surface != nullptr; }
+
+bool present(const DisplaySource &src) {
+ if (!g_surface) return false;
+ 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});
+ const std::uint32_t size[4] = {src.width, src.height, 0, 0};
+ wgpuQueueWriteBuffer(g_queue, g_blit_params, 0, size, sizeof size);
+ WGPUSurfaceTexture st = WGPU_SURFACE_TEXTURE_INIT;
+ wgpuSurfaceGetCurrentTexture(g_surface, &st);
+ if (st.status != WGPUSurfaceGetCurrentTextureStatus_SuccessOptimal && st.status != WGPUSurfaceGetCurrentTextureStatus_SuccessSuboptimal) {
+ if (st.texture) wgpuTextureRelease(st.texture);
+ submit();
+ configure_surface();
+ return true;
+ }
+ WGPUTextureView target = wgpuTextureCreateView(st.texture, nullptr);
+ submit(target);
+#ifndef __EMSCRIPTEN__
+ wgpuSurfacePresent(g_surface);
+#endif
+ wgpuTextureViewRelease(target);
+ wgpuTextureRelease(st.texture);
+ return true;
+}
+
bool display(const DisplaySource &src, std::vector<std::uint32_t> &rgba) {
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});
diff --git a/runtime/src/gs/gpu/gpu.hpp b/runtime/src/gs/gpu/gpu.hpp
index 56f8dce..498c520 100644
--- a/runtime/src/gs/gpu/gpu.hpp
+++ b/runtime/src/gs/gpu/gpu.hpp
@@ -14,6 +14,15 @@ struct DisplaySource {
bool halved;
};
+struct SurfaceTarget {
+ enum Kind { X11, Wayland, Canvas } kind;
+ void *display;
+ std::uint64_t window;
+ void *surface;
+ const char *selector;
+ std::uint32_t width, height;
+};
+
Mode mode();
bool init(Mode m);
void draw(const State &s, const Vertex *v, int count);
@@ -24,6 +33,10 @@ 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 attach_surface(const SurfaceTarget &target);
+void resize_surface(std::uint32_t width, std::uint32_t height);
+bool has_surface();
+bool present(const DisplaySource &src);
void stats();
}
diff --git a/runtime/src/gs/gs.cpp b/runtime/src/gs/gs.cpp
index 92fdff1..aeee2ba 100644
--- a/runtime/src/gs/gs.cpp
+++ b/runtime/src/gs/gs.cpp
@@ -656,6 +656,42 @@ void vblank(bool start) {
bool interlaced_odd_field() { return g_odd_field; }
+bool attach_window(int kind, void *display, std::uint64_t window, void *surface, const char *selector, std::uint32_t width, std::uint32_t height) {
+#ifdef PS2_GPU
+ if (gpu::mode() != gpu::Mode::primary) return false;
+ const gpu::SurfaceTarget target{static_cast<gpu::SurfaceTarget::Kind>(kind), display, window, surface, selector, width, height};
+ return gpu::attach_surface(target);
+#else
+ (void)kind, (void)display, (void)window, (void)surface, (void)selector, (void)width, (void)height;
+ return false;
+#endif
+}
+
+void resize_window(std::uint32_t width, std::uint32_t height) {
+#ifdef PS2_GPU
+ gpu::resize_surface(width, height);
+#else
+ (void)width, (void)height;
+#endif
+}
+
+bool present() {
+#ifdef PS2_GPU
+ if (!gpu::has_surface()) return false;
+ const int circuit = (g_pmode & 2u) ? 1 : (g_pmode & 1u) ? 0 : -1;
+ if (circuit < 0) return true;
+ const std::uint64_t fb = g_dispfb[circuit], disp = g_display[circuit];
+ const std::uint32_t magh = (static_cast<std::uint32_t>(disp >> 23) & 0xFu) + 1, magv = (static_cast<std::uint32_t>(disp >> 27) & 3u) + 1;
+ const std::uint32_t width = ((static_cast<std::uint32_t>(disp >> 32) & 0xFFFu) + 1) / magh, height = ((static_cast<std::uint32_t>(disp >> 44) & 0x7FFu) + 1) / magv;
+ if (!width || !height || width > 2048 || height > 2048) return true;
+ const gpu::DisplaySource src{(static_cast<std::uint32_t>(fb) & 0x1FFu) * 32, static_cast<std::uint32_t>(fb >> 9) & 0x3Fu, static_cast<std::uint32_t>(fb >> 15) & 0x1Fu,
+ static_cast<std::uint32_t>(fb >> 32) & 0x7FFu, static_cast<std::uint32_t>(fb >> 43) & 0x7FFu, width, height, (g_smode2 & 3u) == 3u};
+ return gpu::present(src);
+#else
+ return false;
+#endif
+}
+
bool display(std::vector<std::uint32_t> &rgba, std::uint32_t &width, std::uint32_t &height) {
const int circuit = (g_pmode & 2u) ? 1 : (g_pmode & 1u) ? 0 : -1;
if (circuit < 0) return false;
diff --git a/runtime/src/gs/gs.hpp b/runtime/src/gs/gs.hpp
index 2bae157..d9712b6 100644
--- a/runtime/src/gs/gs.hpp
+++ b/runtime/src/gs/gs.hpp
@@ -56,6 +56,9 @@ std::uint32_t read_pixel(std::uint32_t psm, std::uint32_t bp, std::uint32_t bw,
void write_pixel(std::uint32_t psm, std::uint32_t bp, std::uint32_t bw, std::uint32_t x, std::uint32_t y, std::uint32_t value);
bool display(std::vector<std::uint32_t> &rgba, std::uint32_t &width, std::uint32_t &height);
+bool attach_window(int kind, void *display, std::uint64_t window, void *surface, const char *selector, std::uint32_t width, std::uint32_t height);
+void resize_window(std::uint32_t width, std::uint32_t height);
+bool present();
std::uint64_t primitives_drawn();
void stats();
diff --git a/runtime/src/system.cpp b/runtime/src/system.cpp
index f53f499..b49bb51 100644
--- a/runtime/src/system.cpp
+++ b/runtime/src/system.cpp
@@ -274,6 +274,9 @@ int run() {
}
bool display_frame(std::vector<std::uint32_t> &rgba, std::uint32_t &width, std::uint32_t &height) { return gs::display(rgba, width, height); }
+bool attach_window(const WindowTarget &t) { return gs::attach_window(static_cast<int>(t.kind), t.display, t.window, t.surface, t.selector, t.width, t.height); }
+void resize_window(std::uint32_t width, std::uint32_t height) { gs::resize_window(width, height); }
+bool present_frame() { return gs::present(); }
void set_pad_buttons(std::uint16_t pressed) { iop::sio2::set_buttons(0, pressed); }
void set_pad_axis(int axis, std::uint8_t value) { iop::sio2::set_axis(0, axis, value); }
void set_audio_sink(std::function<void(const std::int16_t *, std::size_t)> sink) { iop::spu2::set_sink(std::move(sink)); }