wasmcart 0.2.0

package/include/wc_fb.h

@@ -0,0 +1,275 @@
+/*
+ * wc_fb.h - 2D framebuffer drawing primitives for wasmcart carts
+ *
+ * Software rendering functions that replace SDL_RenderCopy, SDL_FillRect,
+ * SDL_BlitSurface, etc. for 2D carts using the wasmcart XRGB8888 framebuffer.
+ *
+ * All functions take the framebuffer pointer, width, and height as parameters
+ * so they work with any cart's buffer layout. All are static inline.
+ *
+ * USAGE:
+ *   #include "wc_fb.h"
+ *
+ *   // Fill a rect:
+ *   wc_fb_fill(framebuffer, WIDTH, HEIGHT, 10, 20, 100, 50, 0xFF0000);
+ *
+ *   // Blit indexed sprite with palette:
+ *   wc_fb_blit_indexed(framebuffer, WIDTH, HEIGHT,
+ *                      sprite_data, sprite_stride, palette,
+ *                      sx, sy, sw, sh, dx, dy);
+ *
+ *   // Blit RGBA pixels with transparency:
+ *   wc_fb_blit_rgba(framebuffer, WIDTH, HEIGHT,
+ *                   pixels, src_w, sx, sy, sw, sh, dx, dy);
+ *
+ * PIXEL FORMAT:
+ *   Framebuffer is uint32_t XRGB8888: 0x00RRGGBB
+ *   RGBA source data is uint32_t: 0xAARRGGBB (alpha in high byte)
+ */
+
+#ifndef WC_FB_H
+#define WC_FB_H
+
+#include <stdint.h>
+
+/* ── Color helpers ────────────────────────────────────────────────── */
+
+#define WC_RGB(r, g, b)    (((uint32_t)(r) << 16) | ((uint32_t)(g) << 8) | (uint32_t)(b))
+#define WC_RGBA(r, g, b, a) (((uint32_t)(a) << 24) | ((uint32_t)(r) << 16) | ((uint32_t)(g) << 8) | (uint32_t)(b))
+
+#define WC_R(c) (((c) >> 16) & 0xFF)
+#define WC_G(c) (((c) >>  8) & 0xFF)
+#define WC_B(c) ( (c)        & 0xFF)
+#define WC_A(c) (((c) >> 24) & 0xFF)
+
+/* ── Single pixel ─────────────────────────────────────────────────── */
+
+static inline void wc_fb_pixel(uint32_t *fb, int fb_w, int fb_h,
+                               int x, int y, uint32_t color) {
+    if (x >= 0 && x < fb_w && y >= 0 && y < fb_h)
+        fb[y * fb_w + x] = color;
+}
+
+/* ── Fill rect (solid color, no blending) ─────────────────────────── */
+
+static inline void wc_fb_fill(uint32_t *fb, int fb_w, int fb_h,
+                              int x, int y, int w, int h, uint32_t color) {
+    int x0 = x < 0 ? 0 : x;
+    int y0 = y < 0 ? 0 : y;
+    int x1 = x + w > fb_w ? fb_w : x + w;
+    int y1 = y + h > fb_h ? fb_h : y + h;
+    for (int row = y0; row < y1; row++)
+        for (int col = x0; col < x1; col++)
+            fb[row * fb_w + col] = color;
+}
+
+/* ── Fill rect with alpha blending ────────────────────────────────── */
+
+static inline void wc_fb_fill_alpha(uint32_t *fb, int fb_w, int fb_h,
+                                    int x, int y, int w, int h,
+                                    uint32_t color, int alpha) {
+    int x0 = x < 0 ? 0 : x;
+    int y0 = y < 0 ? 0 : y;
+    int x1 = x + w > fb_w ? fb_w : x + w;
+    int y1 = y + h > fb_h ? fb_h : y + h;
+    int sr = WC_R(color), sg = WC_G(color), sb = WC_B(color);
+    int inv = 255 - alpha;
+    for (int row = y0; row < y1; row++)
+        for (int col = x0; col < x1; col++) {
+            uint32_t dst = fb[row * fb_w + col];
+            int dr = WC_R(dst), dg = WC_G(dst), db = WC_B(dst);
+            int rr = (sr * alpha + dr * inv) / 255;
+            int gg = (sg * alpha + dg * inv) / 255;
+            int bb = (sb * alpha + db * inv) / 255;
+            fb[row * fb_w + col] = WC_RGB(rr, gg, bb);
+        }
+}
+
+/* ── Clear entire framebuffer ─────────────────────────────────────── */
+
+static inline void wc_fb_clear(uint32_t *fb, int fb_w, int fb_h, uint32_t color) {
+    int total = fb_w * fb_h;
+    for (int i = 0; i < total; i++)
+        fb[i] = color;
+}
+
+/* ── Horizontal line (fast) ───────────────────────────────────────── */
+
+static inline void wc_fb_hline(uint32_t *fb, int fb_w, int fb_h,
+                               int x, int y, int w, uint32_t color) {
+    if (y < 0 || y >= fb_h) return;
+    int x0 = x < 0 ? 0 : x;
+    int x1 = x + w > fb_w ? fb_w : x + w;
+    for (int col = x0; col < x1; col++)
+        fb[y * fb_w + col] = color;
+}
+
+/* ── Vertical line ────────────────────────────────────────────────── */
+
+static inline void wc_fb_vline(uint32_t *fb, int fb_w, int fb_h,
+                               int x, int y, int h, uint32_t color) {
+    if (x < 0 || x >= fb_w) return;
+    int y0 = y < 0 ? 0 : y;
+    int y1 = y + h > fb_h ? fb_h : y + h;
+    for (int row = y0; row < y1; row++)
+        fb[row * fb_w + x] = color;
+}
+
+/* ── Rect outline ─────────────────────────────────────────────────── */
+
+static inline void wc_fb_rect(uint32_t *fb, int fb_w, int fb_h,
+                              int x, int y, int w, int h, uint32_t color) {
+    wc_fb_hline(fb, fb_w, fb_h, x, y, w, color);
+    wc_fb_hline(fb, fb_w, fb_h, x, y + h - 1, w, color);
+    wc_fb_vline(fb, fb_w, fb_h, x, y, h, color);
+    wc_fb_vline(fb, fb_w, fb_h, x + w - 1, y, h, color);
+}
+
+/* ── Blit indexed palette sprite ──────────────────────────────────── */
+/*
+ * Blit a region from an indexed (8-bit) image using a palette LUT.
+ * Index 0 = transparent (skipped). No scaling.
+ *
+ *   src       - pointer to indexed pixel data
+ *   src_stride - width of full source image in pixels
+ *   palette   - uint32_t[256] color lookup table (XRGB8888)
+ *   sx,sy     - source region origin
+ *   sw,sh     - source region size
+ *   dx,dy     - destination position in framebuffer
+ */
+static inline void wc_fb_blit_indexed(uint32_t *fb, int fb_w, int fb_h,
+                                      const uint8_t *src, int src_stride,
+                                      const uint32_t *palette,
+                                      int sx, int sy, int sw, int sh,
+                                      int dx, int dy) {
+    for (int py = 0; py < sh; py++) {
+        int dst_y = dy + py;
+        if (dst_y < 0 || dst_y >= fb_h) continue;
+        int src_row = sy + py;
+        if (src_row < 0) continue;
+        for (int px = 0; px < sw; px++) {
+            int dst_x = dx + px;
+            if (dst_x < 0 || dst_x >= fb_w) continue;
+            int src_col = sx + px;
+            if (src_col < 0) continue;
+            uint8_t idx = src[src_row * src_stride + src_col];
+            if (idx == 0) continue; /* transparent */
+            fb[dst_y * fb_w + dst_x] = palette[idx];
+        }
+    }
+}
+
+/* ── Blit indexed with custom transparent index ───────────────────── */
+
+static inline void wc_fb_blit_indexed_key(uint32_t *fb, int fb_w, int fb_h,
+                                          const uint8_t *src, int src_stride,
+                                          const uint32_t *palette,
+                                          int sx, int sy, int sw, int sh,
+                                          int dx, int dy, uint8_t trans_idx) {
+    for (int py = 0; py < sh; py++) {
+        int dst_y = dy + py;
+        if (dst_y < 0 || dst_y >= fb_h) continue;
+        int src_row = sy + py;
+        if (src_row < 0) continue;
+        for (int px = 0; px < sw; px++) {
+            int dst_x = dx + px;
+            if (dst_x < 0 || dst_x >= fb_w) continue;
+            int src_col = sx + px;
+            if (src_col < 0) continue;
+            uint8_t idx = src[src_row * src_stride + src_col];
+            if (idx == trans_idx) continue;
+            fb[dst_y * fb_w + dst_x] = palette[idx];
+        }
+    }
+}
+
+/* ── Blit XRGB pixels (color-key transparency) ────────────────────── */
+/*
+ * Blit a region of uint32_t XRGB pixels. Pixels matching color_key are
+ * treated as transparent. Pass color_key=0xFFFFFFFF to disable keying
+ * (blit all pixels).
+ */
+static inline void wc_fb_blit(uint32_t *fb, int fb_w, int fb_h,
+                              const uint32_t *src, int src_w,
+                              int sx, int sy, int sw, int sh,
+                              int dx, int dy, uint32_t color_key) {
+    for (int py = 0; py < sh; py++) {
+        int dst_y = dy + py;
+        if (dst_y < 0 || dst_y >= fb_h) continue;
+        int src_row = sy + py;
+        for (int px = 0; px < sw; px++) {
+            int dst_x = dx + px;
+            if (dst_x < 0 || dst_x >= fb_w) continue;
+            int src_col = sx + px;
+            uint32_t pixel = src[src_row * src_w + src_col];
+            if (pixel == color_key) continue;
+            fb[dst_y * fb_w + dst_x] = pixel;
+        }
+    }
+}
+
+/* ── Blit RGBA pixels with per-pixel alpha blending ───────────────── */
+/*
+ * Source pixels are uint32_t 0xAARRGGBB. Alpha 0 = transparent,
+ * alpha 255 = opaque. Intermediate values are blended.
+ */
+static inline void wc_fb_blit_rgba(uint32_t *fb, int fb_w, int fb_h,
+                                   const uint32_t *src, int src_w,
+                                   int sx, int sy, int sw, int sh,
+                                   int dx, int dy) {
+    for (int py = 0; py < sh; py++) {
+        int dst_y = dy + py;
+        if (dst_y < 0 || dst_y >= fb_h) continue;
+        int src_row = sy + py;
+        for (int px = 0; px < sw; px++) {
+            int dst_x = dx + px;
+            if (dst_x < 0 || dst_x >= fb_w) continue;
+            int src_col = sx + px;
+            uint32_t spix = src[src_row * src_w + src_col];
+            uint8_t sa = WC_A(spix);
+            if (sa == 0) continue;
+            if (sa == 255) {
+                fb[dst_y * fb_w + dst_x] = spix & 0x00FFFFFF;
+                continue;
+            }
+            /* Alpha blend */
+            uint8_t inv = 255 - sa;
+            uint32_t dpix = fb[dst_y * fb_w + dst_x];
+            int rr = (WC_R(spix) * sa + WC_R(dpix) * inv) / 255;
+            int gg = (WC_G(spix) * sa + WC_G(dpix) * inv) / 255;
+            int bb = (WC_B(spix) * sa + WC_B(dpix) * inv) / 255;
+            fb[dst_y * fb_w + dst_x] = WC_RGB(rr, gg, bb);
+        }
+    }
+}
+
+/* ── Blit with additive blending ──────────────────────────────────── */
+
+static inline void wc_fb_blit_add(uint32_t *fb, int fb_w, int fb_h,
+                                  const uint32_t *src, int src_w,
+                                  int sx, int sy, int sw, int sh,
+                                  int dx, int dy) {
+    for (int py = 0; py < sh; py++) {
+        int dst_y = dy + py;
+        if (dst_y < 0 || dst_y >= fb_h) continue;
+        int src_row = sy + py;
+        for (int px = 0; px < sw; px++) {
+            int dst_x = dx + px;
+            if (dst_x < 0 || dst_x >= fb_w) continue;
+            int src_col = sx + px;
+            uint32_t spix = src[src_row * src_w + src_col];
+            uint8_t sa = WC_A(spix);
+            if (sa == 0) continue;
+            uint32_t dpix = fb[dst_y * fb_w + dst_x];
+            int rr = WC_R(dpix) + (WC_R(spix) * sa / 255);
+            int gg = WC_G(dpix) + (WC_G(spix) * sa / 255);
+            int bb = WC_B(dpix) + (WC_B(spix) * sa / 255);
+            if (rr > 255) rr = 255;
+            if (gg > 255) gg = 255;
+            if (bb > 255) bb = 255;
+            fb[dst_y * fb_w + dst_x] = WC_RGB(rr, gg, bb);
+        }
+    }
+}
+
+#endif /* WC_FB_H */

package/include/wc_gl.h

@@ -0,0 +1,224 @@
+/*
+ * wc_gl.h - Common OpenGL ES 3.0 utilities for wasmcart GL carts
+ *
+ * Single-header library providing shader compilation, program linking,
+ * and other GL boilerplate that's identical across all GL carts.
+ *
+ * USAGE:
+ *   #include "wasmcart.h"   // must define WC_USE_GL before including
+ *   #include "wc_gl.h"
+ *
+ * All functions are static inline. No separate .c file needed.
+ */
+
+#ifndef WC_GL_H
+#define WC_GL_H
+
+/* ── Shader compilation ───────────────────────────────────────────── */
+
+/*
+ * Compile a single shader (vertex or fragment).
+ * Returns the shader handle. No error checking (WASM has no stderr).
+ */
+static inline GLuint wc_compile_shader(GLenum type, const char *src) {
+    GLuint s = glCreateShader(type);
+    const char *strings[1] = { src };
+    glShaderSource(s, 1, strings, 0);
+    glCompileShader(s);
+    return s;
+}
+
+/*
+ * Compile vertex + fragment shaders and link into a program.
+ * Deletes the individual shaders after linking.
+ * Returns the program handle.
+ */
+static inline GLuint wc_link_program(const char *vs_src, const char *fs_src) {
+    GLuint vs = wc_compile_shader(GL_VERTEX_SHADER, vs_src);
+    GLuint fs = wc_compile_shader(GL_FRAGMENT_SHADER, fs_src);
+    GLuint prog = glCreateProgram();
+    glAttachShader(prog, vs);
+    glAttachShader(prog, fs);
+    glLinkProgram(prog);
+    glDeleteShader(vs);
+    glDeleteShader(fs);
+    return prog;
+}
+
+/* ── Resolution negotiation ───────────────────────────────────────── */
+
+/*
+ * Read host preferred resolution, clamp to max, update width/height.
+ * Call in wc_init() after host_info has been written.
+ *
+ *   host      - pointer to host_info struct (written by host before wc_init)
+ *   width     - pointer to current width (updated in place)
+ *   height    - pointer to current height (updated in place)
+ *   max_w     - maximum width the cart supports
+ *   max_h     - maximum height the cart supports
+ */
+static inline void wc_negotiate_resolution(const wc_host_info_t *host,
+                                           uint32_t *width, uint32_t *height,
+                                           uint32_t max_w, uint32_t max_h) {
+    if (host->preferred_width > 0 && host->preferred_height > 0) {
+        *width  = host->preferred_width;
+        *height = host->preferred_height;
+        if (*width  > max_w) *width  = max_w;
+        if (*height > max_h) *height = max_h;
+    }
+}
+
+/* ── Common GL state setup ────────────────────────────────────────── */
+
+/*
+ * Set up typical 2D GL state: viewport, alpha blending, no depth test.
+ * Good default for 2D games, menus, HUD rendering.
+ */
+static inline void wc_gl_setup_2d(uint32_t width, uint32_t height) {
+    glViewport(0, 0, width, height);
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    glDisable(GL_DEPTH_TEST);
+}
+
+/*
+ * Set up typical 3D GL state: viewport, alpha blending, depth test enabled.
+ * Good default for 3D games.
+ */
+static inline void wc_gl_setup_3d(uint32_t width, uint32_t height) {
+    glViewport(0, 0, width, height);
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    glEnable(GL_DEPTH_TEST);
+    glDepthFunc(GL_LEQUAL);
+}
+
+/* ── VAO/VBO creation helpers ─────────────────────────────────────── */
+
+/*
+ * Create a simple VAO + VBO pair for dynamic vertex data.
+ * Allocates max_bytes of GL_DYNAMIC_DRAW storage.
+ * Returns the VBO handle (for later glBufferSubData calls).
+ * The VAO is bound after this call.
+ */
+static inline GLuint wc_create_dynamic_vbo(GLuint *vao, int max_bytes) {
+    GLuint vbo;
+    glGenVertexArrays(1, vao);
+    glBindVertexArray(*vao);
+    glGenBuffers(1, &vbo);
+    glBindBuffer(GL_ARRAY_BUFFER, vbo);
+    glBufferData(GL_ARRAY_BUFFER, max_bytes, 0, GL_DYNAMIC_DRAW);
+    return vbo;
+}
+
+/*
+ * Create a VAO + VBO pair with static vertex data.
+ * Uploads data immediately. Returns the VBO handle.
+ * The VAO is bound after this call.
+ */
+static inline GLuint wc_create_static_vbo(GLuint *vao,
+                                          const void *data, int size_bytes) {
+    GLuint vbo;
+    glGenVertexArrays(1, vao);
+    glBindVertexArray(*vao);
+    glGenBuffers(1, &vbo);
+    glBindBuffer(GL_ARRAY_BUFFER, vbo);
+    glBufferData(GL_ARRAY_BUFFER, size_bytes, data, GL_STATIC_DRAW);
+    return vbo;
+}
+
+/* ── Texture loading from WASM memory ─────────────────────────────── */
+
+/*
+ * IMPORTANT: Texture vertical flip convention
+ *
+ * stb_image loads images top-to-bottom (row 0 = top of image).
+ * Whether you need to flip before uploading depends on the original
+ * game's framework:
+ *
+ *   SDL games:  Flip vertically before glTexImage2D.
+ *               SDL + standard GL convention: V=0 = bottom of image.
+ *               The game's tex coords expect V=0 at the bottom.
+ *
+ *   SFML games: Do NOT flip. SFML convention: V=0 = top of image.
+ *               stb_image's top-first output already matches.
+ *               Flipping will invert ALL textures (trees, sprites,
+ *               skybox, HUD - everything).
+ *
+ *   Raw GL:     Check the game's tex coord usage to determine which
+ *               convention it expects.
+ *
+ * The functions below upload pixels as-is (no flip). If you need to
+ * flip for an SDL-based port, do it before calling these functions.
+ */
+
+/*
+ * Upload RGBA pixel data to a new GL texture with typical settings.
+ * Returns the texture handle.
+ *
+ * Use with stb_image: decode image → get RGBA pixels → call this.
+ */
+static inline GLuint wc_create_texture_rgba(const unsigned char *pixels,
+                                            int width, int height) {
+    GLuint tex;
+    glGenTextures(1, &tex);
+    glBindTexture(GL_TEXTURE_2D, tex);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0,
+                 GL_RGBA, GL_UNSIGNED_BYTE, pixels);
+    return tex;
+}
+
+/*
+ * Create a texture with nearest-neighbor filtering (pixel art).
+ */
+static inline GLuint wc_create_texture_nearest(const unsigned char *pixels,
+                                               int width, int height) {
+    GLuint tex;
+    glGenTextures(1, &tex);
+    glBindTexture(GL_TEXTURE_2D, tex);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0,
+                 GL_RGBA, GL_UNSIGNED_BYTE, pixels);
+    return tex;
+}
+
+/* ── Simple PRNG (xorshift32) ─────────────────────────────────────── */
+/* Duplicated in 5+ carts. Included here since GL carts commonly need it
+ * for particle effects, procedural generation, etc. */
+
+static unsigned int _wc_rng_state = 12345;
+
+static inline void wc_srand(unsigned int seed) {
+    _wc_rng_state = seed ? seed : 1;
+}
+
+static inline unsigned int wc_rand(void) {
+    _wc_rng_state ^= _wc_rng_state << 13;
+    _wc_rng_state ^= _wc_rng_state >> 17;
+    _wc_rng_state ^= _wc_rng_state << 5;
+    return _wc_rng_state;
+}
+
+/* Random float in [0, 1) */
+static inline float wc_randf(void) {
+    return (float)(wc_rand() % 10000) / 10000.0f;
+}
+
+/* Random float in [lo, hi) */
+static inline float wc_randf_range(float lo, float hi) {
+    return lo + wc_randf() * (hi - lo);
+}
+
+/* Random int in [0, max) */
+static inline int wc_rand_range(int max) {
+    return (int)(wc_rand() % (unsigned int)max);
+}
+
+#endif /* WC_GL_H */

package/include/wc_gl_blit.h

@@ -0,0 +1,129 @@
+/*
+ * wc_gl_blit.h - Upload CPU pixels to GPU via GL texture + fullscreen quad
+ *
+ * The standard display path for ALL wasmcart carts. Even 2D framebuffer
+ * carts upload their pixels as a GL texture and draw a fullscreen quad.
+ * This means every cart uses gpu_api=1 and the host always uses the GL
+ * display path (swapBuffers).
+ *
+ * USAGE:
+ *
+ *   #define WC_USE_GL
+ *   #include "wasmcart.h"
+ *   #include "wc_gl_blit.h"
+ *
+ *   // In wc_get_info():
+ *   info.gpu_api = 1;  // always GL
+ *
+ *   // In wc_render(), after drawing to your pixel buffer:
+ *   wc_gl_blit(pixels, width, height);
+ *
+ * The first call compiles a blit shader and creates a texture.
+ * Subsequent calls just upload pixels and draw the quad.
+ *
+ * Pixel format: RGBA8888 (4 bytes per pixel, R first).
+ * If your buffer is XRGB/BGRA, convert before calling.
+ *
+ * For carts that render via GL directly (WebGL, three.js, etc.),
+ * don't call wc_gl_blit - the GL output is already on screen.
+ *
+ * STB-STYLE SINGLE-HEADER LIBRARY
+ * Define WC_GL_BLIT_IMPLEMENTATION in exactly ONE .c file before including.
+ */
+
+#ifndef WC_GL_BLIT_H
+#define WC_GL_BLIT_H
+
+#ifndef WASMCART_H
+#error "Include wasmcart.h (with WC_USE_GL) before wc_gl_blit.h"
+#endif
+
+/* Upload RGBA pixels to a GL texture and draw a fullscreen quad.
+ * Call once per frame after all CPU rendering is done. */
+static void wc_gl_blit(const void *pixels, int width, int height);
+
+#ifdef WC_GL_BLIT_IMPLEMENTATION
+
+static GLuint _wc_blit_tex = 0;
+static GLuint _wc_blit_program = 0;
+static GLuint _wc_blit_vao = 0;
+static GLuint _wc_blit_vbo = 0;
+static int _wc_blit_ready = 0;
+
+static void _wc_blit_init(int width, int height) {
+    const char *vs_src =
+        "#version 300 es\n"
+        "in vec2 aPos;\n"
+        "out vec2 vUV;\n"
+        "void main() {\n"
+        "  vUV = aPos * 0.5 + 0.5;\n"
+        "  vUV.y = 1.0 - vUV.y;\n"
+        "  gl_Position = vec4(aPos, 0.0, 1.0);\n"
+        "}\n";
+    const char *fs_src =
+        "#version 300 es\n"
+        "precision mediump float;\n"
+        "in vec2 vUV;\n"
+        "uniform sampler2D uTex;\n"
+        "out vec4 fragColor;\n"
+        "void main() {\n"
+        "  fragColor = texture(uTex, vUV);\n"
+        "}\n";
+
+    GLuint vs = glCreateShader(GL_VERTEX_SHADER);
+    GLint vs_len = (GLint)__builtin_strlen(vs_src);
+    glShaderSource(vs, 1, &vs_src, &vs_len);
+    glCompileShader(vs);
+
+    GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
+    GLint fs_len = (GLint)__builtin_strlen(fs_src);
+    glShaderSource(fs, 1, &fs_src, &fs_len);
+    glCompileShader(fs);
+
+    _wc_blit_program = glCreateProgram();
+    glAttachShader(_wc_blit_program, vs);
+    glAttachShader(_wc_blit_program, fs);
+    glLinkProgram(_wc_blit_program);
+
+    float quad[] = { -1,-1, 1,-1, -1,1, 1,1 };
+    glGenVertexArrays(1, &_wc_blit_vao);
+    glBindVertexArray(_wc_blit_vao);
+    glGenBuffers(1, &_wc_blit_vbo);
+    glBindBuffer(GL_ARRAY_BUFFER, _wc_blit_vbo);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(quad), quad, GL_STATIC_DRAW);
+
+    GLint aPos = glGetAttribLocation(_wc_blit_program, "aPos");
+    glEnableVertexAttribArray(aPos);
+    glVertexAttribPointer(aPos, 2, GL_FLOAT, GL_FALSE, 0, 0);
+
+    glGenTextures(1, &_wc_blit_tex);
+    glBindTexture(GL_TEXTURE_2D, _wc_blit_tex);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+    _wc_blit_ready = 1;
+}
+
+static void wc_gl_blit(const void *pixels, int width, int height) {
+    if (!_wc_blit_ready) _wc_blit_init(width, height);
+    if (!_wc_blit_ready) return;
+
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+    glViewport(0, 0, width, height);
+    glDisable(GL_DEPTH_TEST);
+    glDisable(GL_BLEND);
+
+    glBindTexture(GL_TEXTURE_2D, _wc_blit_tex);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0,
+                  GL_RGBA, GL_UNSIGNED_BYTE, pixels);
+
+    glUseProgram(_wc_blit_program);
+    glUniform1i(glGetUniformLocation(_wc_blit_program, "uTex"), 0);
+    glBindVertexArray(_wc_blit_vao);
+    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+}
+
+#endif /* WC_GL_BLIT_IMPLEMENTATION */
+#endif /* WC_GL_BLIT_H */