usim

# X11 as TV backend.
#CFLAGS  += -I/usr/X11R6/include -I/opt/local/include -DWITH_X11=1
#LDFLAGS += -lX11 -L/usr/X11R6/lib -L/opt/local/lib
#USIM_TV_BACKEND = x11.o

# SDL (version 1) as TV backend.
#CFLAGS += $(shell sdl-config --cflags) -DWITH_SDL1=1 
#LDFLAGS += $(shell sdl-config --libs)
#USIM_TV_BACKEND = sdl1.o

# SDL (version 2) as TV backend.
CFLAGS += $(shell sdl2-config --cflags) -DWITH_SDL2=1 
LDFLAGS += $(shell sdl2-config --libs)
USIM_TV_BACKEND = sdl2.o

# Bullshit hack.
CFLAGS += -I/opt/homebrew/include -Wno-nonportable-include-path

# Headless TV backend.
# CFLAGS +=
# LDFLAGS +=

		DEBUG(TRACE_KBD, "cadet_allup_key() - all-up event; mods = 0%o, shifts = 0%o\n", mods, shifts);
		cadet_shifts = shifts;	 /* Keep track of shifts.  */
		cadet_allup_event(mods); /* Generate all-up event. */
	}
	return allup;
}
#elif WITH_SDL1
bool
cadet_allup_key(void)
{
}
#elif WITH_SDL2
bool
cadet_allup_key(void)
{
}
#endif

static void

/* sdl2.c --- SDL2 routines used by the TV and KBD interfaces
 */

#include <signal.h>

#include <SDL.h>

#include "tv.h"
#include "kbd.h"
#include "mouse.h"
#include "utrace.h"
#include "idle.h"

SDL_Window *window;
SDL_Renderer *renderer;
SDL_Texture *texture;

/*
 * Translation map for the host keyboard to a corresponding Lisp
 * Machine character or modifier.
 */
int sdl2_kbd_map[65535];
int sdl2_modifier_map[8];

/*
 * This is shared between x11.c, and sdl2.c ... the only difference is
 * the hook in send_accumulated_updates.
 */

unsigned long Background;
unsigned long Foreground;

static int u_minh = 0x7fffffff;
static int u_maxh;
static int u_minv = 0x7fffffff;
static int u_maxv;

void
accumulate_update(int h, int v, int hs, int vs)
{
	if (h < u_minh)
		u_minh = h;
	if (h + hs > u_maxh)
		u_maxh = h + hs;
	if (v < u_minv)
		u_minv = v;
	if (v + vs > u_maxv)
		u_maxv = v + vs;
}

static void
send_accumulated_updates(void)
{
	int hs;
	int vs;

	hs = u_maxh - u_minh;
	vs = u_maxv - u_minv;
	if (u_minh != 0x7fffffff && u_minv != 0x7fffffff && u_maxh && u_maxv) {
		SDL_UpdateTexture(texture, NULL, tv_bitmap, tv_width * sizeof (Uint32));
		// Flush
		SDL_RenderClear(renderer);
		SDL_RenderCopy(renderer, texture, NULL, NULL);
		SDL_RenderPresent(renderer);
	}
	u_minh = 0x7fffffff;
	u_maxh = 0;
	u_minv = 0x7fffffff;
	u_maxv = 0;
}

static void
process_key(SDL_KeyboardEvent *e, int keydown)
{
}

void
sdl2_event(void)
{
	SDL_Event ev1, *ev = &ev1;
	
	send_accumulated_updates();
	kbd_dequeue_key_event();
	while (SDL_PollEvent(ev)) {
		switch (ev->type) {
		case SDL_WINDOWEVENT:
			SDL_UpdateTexture(texture, NULL, tv_bitmap, tv_width * sizeof (Uint32));
			// flush
			SDL_RenderClear(renderer);
			SDL_RenderCopy(renderer, texture, NULL, NULL);
			SDL_RenderPresent(renderer);
			break;
		case SDL_QUIT:
			exit(0);
			break;
		}
	}
}

void
sdl2_default_kbd_map(void)
{
	for (int i = 0; i < (int) NELEM(sdl2_kbd_map); i++)
		sdl2_kbd_map[i] = LMCH_NoSymbol;
	for (int i = 0; i < (int) NELEM(sdl2_modifier_map); i++)
		sdl2_modifier_map[i] = KBD_NoSymbol;
}

void
sdl2_init(void)
{
	NOTICE(TRACE_USIM, "tv: using SDL backend for monitor and keyboard\n"); 

	Foreground = 0xff; // White
	Background = 0x0011; // Black

//screen = SDL_CreateWindow("CADR",
//                          SDL_WINDOWPOS_UNDEFINED,
//                          SDL_WINDOWPOS_UNDEFINED,
//                          tv_width, tv_height,
//                          SDL_WINDOW_OPENGL);


	SDL_CreateWindowAndRenderer(tv_width, tv_height, SDL_WINDOW_OPENGL, &window, &renderer);


	SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
	SDL_RenderClear(renderer);
	SDL_RenderPresent(renderer);


	SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");  // make the scaled rendering look smoother.
	SDL_RenderSetLogicalSize(renderer, tv_width, tv_height);

	texture = SDL_CreateTexture(renderer,
				    SDL_PIXELFORMAT_ARGB8888,
				    SDL_TEXTUREACCESS_STREAMING,
				    tv_width, tv_height);




}

#pragma once

#include <SDL2/SDL.h>

extern void sdl2_init(void);
extern void sdl2_default_kbd_map(void);
extern void sdl2_event(void);

extern unsigned long Background;
extern unsigned long Foreground;

extern void accumulate_update(int, int, int, int);

#include "tv.h"
#include "ucode.h"
#include "utrace.h"
#if WITH_X11
#include "x11.h"
#elif WITH_SDL1
#include "sdl1.h"
#elif WITH_SDL2
#include "sdl2.h"
#endif

int tv_monitor = 1;		/* Default is Other (1). */

uint32_t tv_width;
uint32_t tv_height;
uint32_t tv_bitmap[1024 * 1024];

void
tv_poll(void)
{
#ifdef WITH_X11
	x11_event();
#elif WITH_SDL1
	sdl1_event();
#elif WITH_SDL2
	sdl2_event();
#endif
}

void
tv_init(void)
{
	tv_colorbit = 0;

		errx(1, "unknown monitor type: %d", tv_monitor);
		break;
	}
#ifdef WITH_X11
	x11_init();
#elif WITH_SDL1
	sdl1_init();
#elif WITH_SDL2
	sdl2_init();
#endif
	{
		struct itimerval itimer;
		int usecs;

		signal(SIGVTALRM, sigalrm_handler);
		usecs = 16000;

	 */
	do
		XNextEvent(display, &e);
	while (e.type != Expose || e.xexpose.count);
	XFlush(display);
	ximage = XCreateImage(display, visual, (unsigned) color_depth, ZPixmap, 0, (char *) tv_bitmap, tv_width, tv_height, 32, 0);
	ximage->byte_order = LSBFirst;

	idle_gc = XCreateGC(display, window, 0, 0);
	register_idle_change_handler(x11_idle_change_handler);
}