path: root/src/render.c

#include "render.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <termios.h>
#include <fcntl.h>
#include <signal.h>
#include <strings.h>
#include <sys/stat.h>
#include <errno.h>

#define UPPER "\xe2\x96\x80"   // ▀ U+2580

static struct termios orig_termios;
static bool raw_active = false;

static void on_winch(int s);

void term_restore(void) {
    if (raw_active) {
        tcsetattr(STDIN_FILENO, TCSAFLUSH, &orig_termios);
        raw_active = false;
    }
    // show cursor, leave alt screen, reset colors
    printf("\x1b[0m\x1b[?25h\x1b[?1049l");
    fflush(stdout);
}

void term_init(void) {
    tcgetattr(STDIN_FILENO, &orig_termios);
    struct termios raw = orig_termios;
    raw.c_lflag &= ~(ECHO | ICANON | ISIG);
    raw.c_iflag &= ~(IXON | ICRNL);
    raw.c_cc[VMIN] = 0;
    raw.c_cc[VTIME] = 0;
    tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw);
    raw_active = true;
    // enter alt screen, hide cursor, clear
    printf("\x1b[?1049h\x1b[?25l\x1b[2J\x1b[H");
    fflush(stdout);
    signal(SIGWINCH, on_winch);
    render_force_full();
    atexit(term_restore);
}

// large reusable output buffer
static char outbuf[SCREEN_W * (SCREEN_H/2) * 40 + 4096];

// previous frame's pixels, for inter-frame diffing
static u8 prev_fb[SCREEN_H][SCREEN_W][3];
static bool need_full = true;              // force a complete repaint
static volatile sig_atomic_t resized = 0;  // set by SIGWINCH

void render_force_full(void) { need_full = true; }
static void on_winch(int s) { (void)s; resized = 1; }

void render_frame(GB *gb) {
    PPU *p = &gb->ppu;
    char *o = outbuf;

    if (resized) { resized = 0; need_full = true; o += sprintf(o, "\x1b[2J"); }

    // Terminal SGR (color) state persists across cursor moves, so we can keep
    // one fg/bg tracker for the whole frame even when we jump over unchanged
    // cells. Reset each frame since we emit a final \x1b[0m.
    int pr = -1, pg = -1, pb = -1;   // last-emitted fg
    int PR = -1, PG = -1, PB = -1;   // last-emitted bg
    int cur_row = -2, cur_col = -2;  // terminal cell just written (0-indexed)

    for (int y = 0; y < SCREEN_H; y += 2) {
        int row = y / 2;
        for (int x = 0; x < SCREEN_W; x++) {
            u8 *top = p->fb[y][x];
            u8 *bot = p->fb[y+1][x];
            if (!need_full) {
                u8 *pt = prev_fb[y][x], *pb2 = prev_fb[y+1][x];
                if (top[0]==pt[0] && top[1]==pt[1] && top[2]==pt[2] &&
                    bot[0]==pb2[0] && bot[1]==pb2[1] && bot[2]==pb2[2])
                    continue;   // cell unchanged -> skip
            }
            // reposition cursor only when we're not already right after the
            // previously written cell
            if (row != cur_row || x != cur_col + 1)
                o += sprintf(o, "\x1b[%d;%dH", row + 1, x + 1);
            if (top[0] != pr || top[1] != pg || top[2] != pb) {
                o += sprintf(o, "\x1b[38;2;%d;%d;%dm", top[0], top[1], top[2]);
                pr = top[0]; pg = top[1]; pb = top[2];
            }
            if (bot[0] != PR || bot[1] != PG || bot[2] != PB) {
                o += sprintf(o, "\x1b[48;2;%d;%d;%dm", bot[0], bot[1], bot[2]);
                PR = bot[0]; PG = bot[1]; PB = bot[2];
            }
            memcpy(o, UPPER, 3); o += 3;
            cur_row = row; cur_col = x;
        }
    }

    // status line: static text, only (re)draw on a full repaint
    if (need_full) {
        o += sprintf(o, "\x1b[0m\x1b[%d;1H\x1b[38;2;150;150;150m %.*s  "
                        "[wasd/arrows] z:A x:B space:sel enter:start q:quit",
                        SCREEN_H/2 + 1, 15, gb->cart.title);
    }

    memcpy(prev_fb, p->fb, sizeof(prev_fb));
    need_full = false;

    if (o != outbuf) {                 // nothing changed -> write nothing
        o += sprintf(o, "\x1b[0m");
        fwrite(outbuf, 1, o - outbuf, stdout);
        fflush(stdout);
    }
}

// ---- input: keyboard (decay-based holds) + optional FIFO control channel ----
// Two independent sources are merged each frame:
//   held    : buttons explicitly held via the FIFO (+x / -x), no decay
//   decay[] : momentary presses (keyboard, or FIFO taps), count down per frame
static int  decay[8];       // frames remaining for each BTN bit position
static u8   held;           // explicitly-held buttons (FIFO)
#define HOLD_FRAMES 4

static int mask_index(int mask) {
    for (int i = 0; i < 8; i++) if ((1 << i) == mask) return i;
    return -1;
}
static void tap(int mask, int frames) {
    int i = mask_index(mask);
    if (i >= 0) decay[i] = frames > 0 ? frames : HOLD_FRAMES;
}

// ---- FIFO control channel ----
static int  fifo_fd = -1;
static bool fifo_created = false;
static char fifo_path[512];
static char linebuf[256];
static int  linelen = 0;

static int name_mask(const char *s) {
    if (!strcasecmp(s, "a"))      return BTN_A;
    if (!strcasecmp(s, "b"))      return BTN_B;
    if (!strcasecmp(s, "start"))  return BTN_START;
    if (!strcasecmp(s, "select") || !strcasecmp(s, "sel")) return BTN_SELECT;
    if (!strcasecmp(s, "up"))     return BTN_UP;
    if (!strcasecmp(s, "down"))   return BTN_DOWN;
    if (!strcasecmp(s, "left"))   return BTN_LEFT;
    if (!strcasecmp(s, "right"))  return BTN_RIGHT;
    return 0;
}

// Parse one token: "+a" hold, "-a" release, "a" tap, "a:20" tap N frames,
// "release" clears all held.
static void handle_token(char *t) {
    if (!*t) return;
    if (!strcasecmp(t, "release") || !strcasecmp(t, "none")) { held = 0; return; }
    if (t[0] == '+') { held |= name_mask(t + 1); return; }
    if (t[0] == '-') { held &= ~name_mask(t + 1); return; }
    int frames = HOLD_FRAMES;
    char *colon = strchr(t, ':');
    if (colon) { *colon = 0; frames = atoi(colon + 1); }
    int m = name_mask(t);
    if (m) tap(m, frames);
}

static void handle_line(char *line) {
    for (char *t = strtok(line, " \t,"); t; t = strtok(NULL, " \t,"))
        handle_token(t);
}

void input_open_fifo(const char *path) {
    snprintf(fifo_path, sizeof(fifo_path), "%s", path);
    if (mkfifo(fifo_path, 0666) == 0) fifo_created = true;
    else if (errno != EEXIST) { perror("mkfifo"); return; }
    // O_RDWR keeps a writer end open so we never see persistent EOF and the
    // open never blocks waiting for an external writer.
    fifo_fd = open(fifo_path, O_RDWR | O_NONBLOCK);
    if (fifo_fd < 0) perror("open fifo");
}

void input_close_fifo(void) {
    if (fifo_fd >= 0) { close(fifo_fd); fifo_fd = -1; }
    if (fifo_created) { unlink(fifo_path); fifo_created = false; }
}

static void poll_fifo(void) {
    if (fifo_fd < 0) return;
    char buf[512];
    int n;
    while ((n = read(fifo_fd, buf, sizeof(buf))) > 0) {
        for (int i = 0; i < n; i++) {
            char c = buf[i];
            if (c == '\n' || c == '\r') {
                linebuf[linelen] = 0;
                if (linelen) handle_line(linebuf);
                linelen = 0;
            } else if (linelen < (int)sizeof(linebuf) - 1) {
                linebuf[linelen++] = c;
            }
        }
    }
}

bool input_poll(GB *gb) {
    unsigned char buf[64];
    int n = read(STDIN_FILENO, buf, sizeof(buf));
    bool quit = false;
    for (int i = 0; i < n; i++) {
        unsigned char ch = buf[i];
        if (ch == 0x1b && i + 2 < n && buf[i+1] == '[') {
            switch (buf[i+2]) {
                case 'A': tap(BTN_UP, HOLD_FRAMES); break;
                case 'B': tap(BTN_DOWN, HOLD_FRAMES); break;
                case 'C': tap(BTN_RIGHT, HOLD_FRAMES); break;
                case 'D': tap(BTN_LEFT, HOLD_FRAMES); break;
            }
            i += 2;
            continue;
        }
        switch (ch) {
            case 'w': tap(BTN_UP, HOLD_FRAMES); break;
            case 's': tap(BTN_DOWN, HOLD_FRAMES); break;
            case 'a': tap(BTN_LEFT, HOLD_FRAMES); break;
            case 'd': tap(BTN_RIGHT, HOLD_FRAMES); break;
            case 'z': case 'j': tap(BTN_A, HOLD_FRAMES); break;
            case 'x': case 'k': tap(BTN_B, HOLD_FRAMES); break;
            case '\r': case '\n': tap(BTN_START, HOLD_FRAMES); break;
            case ' ': tap(BTN_SELECT, HOLD_FRAMES); break;
            case 'q': case 3: quit = true; break;
        }
    }

    poll_fifo();

    // merge held + decaying momentary presses into the joypad state
    u8 b = held;
    for (int i = 0; i < 8; i++)
        if (decay[i] > 0) { decay[i]--; b |= (1 << i); }
    if (b & ~gb->buttons) gb_request_interrupt(gb, INT_JOYPAD);
    static bool dbg_init = false, dbg = false;
    if (!dbg_init) { dbg = getenv("GBC_INPUT_DEBUG") != NULL; dbg_init = true; }
    if (dbg && b != gb->buttons)
        fprintf(stderr, "[input] %c%c%c%c %c%c%c%c\n",
            b&BTN_UP?'U':'.', b&BTN_DOWN?'D':'.', b&BTN_LEFT?'L':'.', b&BTN_RIGHT?'R':'.',
            b&BTN_A?'A':'.', b&BTN_B?'B':'.', b&BTN_SELECT?'s':'.', b&BTN_START?'S':'.');
    gb->buttons = b;
    return !quit;
}