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.txtindex 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.cmakeDEPENDS 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.cppindex 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.hppindex 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.wgslnew file mode 100644index 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.cppindex 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);+#endifif (!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.hppindex 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.cppindex 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.hppindex 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.cppindex 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)); }