Files
lilygo-t-deck/emulator/src/shim/TFT_eSPI.h
T
Dejvino 21d37486cf Emulator: migrate SDL2 -> SDL3
Port the shared emulator harness (all apps) to SDL 3.4 + SDL3_ttf 3.2:
- window creation without position args; renderer logical size via
  SDL_SetRenderLogicalPresentation(LETTERBOX); SDL_RenderTexture;
  SDL_SaveBMP_IO frame dumps
- SDL_EVENT_* event scheme, flattened SDL_KeyboardEvent, float mouse
  coords; clicks mapped with SDL_ConvertEventToRenderCoordinates, keeping
  the Xwayland global-state cross-check from 260a2b3
- audio shim on the stream API (SDL_OpenAudioDeviceStream +
  SDL_PutAudioStreamData) since SDL_QueueAudio is gone
- TTF_RenderText_Blended (explicit length); SDL3_ttf header layout
  handled via __has_include (Ubuntu installs under SDL3_ttf/)
- e2e freeze-tint pixel assertions updated to the committed
  diagonal-stripe pattern (stale since the freeze rework; pre-existing
  failures at HEAD under SDL2), sampled away from the freeze text

Full suite green: 14 unit + 7 integration + 3 E2E journeys, 0 failures.
MissileCommand, MiataDrive, NetDeck build; CrtTerminal (missing sndBlip
declaration) and Lotus3 (sketch not in repo) fail identically at HEAD -
pre-existing, out of scope.
2026-11-14 17:03:30 +01:00

276 lines
9.4 KiB
C++

/**
* TFT_eSPI shim: renders the same drawing calls into a 320x240 ABGR8888
* framebuffer that the SDL3 host pushes to a window. Text uses SDL3_ttf with
* DejaVu fonts as stand-ins for the TFT_eSPI font set.
*/
#pragma once
#include <Arduino.h>
#include <SDL3/SDL.h>
#if __has_include(<SDL3/SDL_ttf.h>) // upstream install layout
#include <SDL3/SDL_ttf.h>
#else // Debian/Ubuntu package layout
#include <SDL3_ttf/SDL_ttf.h>
#endif
#include "emu_gfx.h"
#include <map>
// ---- TFT_eSPI RGB565 color constants (the ones the game uses) ----
#define TFT_BLACK 0x0000
#define TFT_NAVY 0x000F
#define TFT_DARKGREEN 0x0320
#define TFT_DARKGREY 0x7BEF
#define TFT_BLUE 0x001F
#define TFT_GREEN 0x07E0
#define TFT_CYAN 0x07FF
#define TFT_RED 0xF800
#define TFT_MAGENTA 0xF81F
#define TFT_YELLOW 0xFFE0
#define TFT_ORANGE 0xFDA0
#define TFT_GREENYELLOW 0xAFE5
#define TFT_GOLD 0xFEA0
#define TFT_WHITE 0xFFFF
#define TFT_SKYBLUE 0x867D
enum TextDatum {
TL_DATUM = 0, TC_DATUM = 1, TR_DATUM = 2,
ML_DATUM = 3, MC_DATUM = 4, MR_DATUM = 5,
BL_DATUM = 6, BC_DATUM = 7, BR_DATUM = 8
};
// The .ino only needs the address of these font objects.
struct FreeFontStub { int _; };
extern const FreeFontStub FreeSansBold24pt7b;
extern const FreeFontStub FreeSansBold18pt7b;
extern const FreeFontStub FreeSansOblique12pt7b;
extern const FreeFontStub FreeSans12pt7b;
static inline uint32_t rgb565to888(uint16_t c)
{
uint32_t r = ((c >> 11) & 0x1F) * 255 / 31;
uint32_t g = ((c >> 5) & 0x3F) * 255 / 63;
uint32_t b = (c & 0x1F) * 255 / 31;
return 0xFF000000u | (b << 16) | (g << 8) | r;
}
class TFT_eSPI {
public:
TFT_eSPI() {}
void begin() {}
void startWrite() {}
void endWrite() {}
void setRotation(uint8_t) {}
int width() { return emuGfx::W; }
int height() { return emuGfx::H; }
void fillScreen(uint32_t c) { fillRect(0, 0, emuGfx::W, emuGfx::H, c); }
void drawPixel(int32_t x, int32_t y, uint32_t c)
{
if (x < 0 || y < 0 || x >= emuGfx::W || y >= emuGfx::H) return;
emuGfx::fb[y * emuGfx::W + x] = rgb565to888((uint16_t)c);
emuGfx::dirty = true;
}
void fillRect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t c)
{
uint32_t px = rgb565to888((uint16_t)c);
for (int32_t j = y; j < y + h; j++) {
if (j < 0 || j >= emuGfx::H) continue;
for (int32_t i = x; i < x + w; i++) {
if (i < 0 || i >= emuGfx::W) continue;
emuGfx::fb[j * emuGfx::W + i] = px;
}
}
emuGfx::dirty = true;
}
void drawRect(int32_t x, int32_t y, int32_t w, int32_t h, uint32_t c)
{
drawFastHLine(x, y, w, c);
drawFastHLine(x, y + h - 1, w, c);
drawFastVLine(x, y, h, c);
drawFastVLine(x + w - 1, y, h, c);
}
void drawFastHLine(int32_t x, int32_t y, int32_t w, uint32_t c) { fillRect(x, y, w, 1, c); }
void drawFastVLine(int32_t x, int32_t y, int32_t h, uint32_t c) { fillRect(x, y, 1, h, c); }
void drawLine(int32_t x0, int32_t y0, int32_t x1, int32_t y1, uint32_t c)
{
int dx = std::abs(x1 - x0), sx = x0 < x1 ? 1 : -1;
int dy = -std::abs(y1 - y0), sy = y0 < y1 ? 1 : -1;
int err = dx + dy;
for (;;) {
drawPixel(x0, y0, c);
if (x0 == x1 && y0 == y1) break;
int e2 = 2 * err;
if (e2 >= dy) { err += dy; x0 += sx; }
if (e2 <= dx) { err += dx; y0 += sy; }
}
}
// Blit a 16bpp (RGB565) image — the pattern-stamp primitive that the
// device-side TFT_eSPI / TFT_eSprite pushImage() provides. Clipped.
void pushImage(int32_t x, int32_t y, int32_t w, int32_t h, const uint16_t *data)
{
for (int32_t j = 0; j < h; j++) {
int32_t ty = y + j;
if (ty < 0 || ty >= emuGfx::H) continue;
for (int32_t i = 0; i < w; i++) {
int32_t tx = x + i;
if (tx < 0 || tx >= emuGfx::W) continue;
emuGfx::fb[ty * emuGfx::W + tx] = rgb565to888(data[j * w + i]);
}
}
emuGfx::dirty = true;
}
void fillCircle(int32_t x0, int32_t y0, int32_t r, uint32_t c)
{
for (int dy = -r; dy <= r; dy++) {
int dx = (int)sqrtf((float)(r * r - dy * dy));
drawFastHLine(x0 - dx, y0 + dy, dx * 2 + 1, c);
}
}
void drawCircle(int32_t x0, int32_t y0, int32_t r, uint32_t c)
{
for (int x = -r; x <= r; x++) {
int y = (int)(sqrtf((float)(r * r - x * x)) + 0.5f);
drawPixel(x0 + x, y0 + y, c);
drawPixel(x0 + x, y0 - y, c);
drawPixel(x0 + y, y0 + x, c);
drawPixel(x0 - y, y0 + x, c);
drawPixel(x0 + y, y0 - x, c);
drawPixel(x0 - y, y0 - x, c);
}
}
void fillTriangle(int32_t x0, int32_t y0, int32_t x1, int32_t y1, int32_t x2, int32_t y2,
uint32_t c)
{
int32_t minx = std::min(std::min(x0, x1), x2);
int32_t maxx = std::max(std::max(x0, x1), x2);
int32_t miny = std::min(std::min(y0, y1), y2);
int32_t maxy = std::max(std::max(y0, y1), y2);
float d = (float)((y1 - y2) * (x0 - x2) + (x2 - x1) * (y0 - y2));
if (d == 0) return;
for (int32_t y = miny; y <= maxy; y++) {
for (int32_t x = minx; x <= maxx; x++) {
float l0 = ((y1 - y2) * (x - x2) + (x2 - x1) * (y - y2)) / d;
float l1 = ((y2 - y0) * (x - x2) + (x0 - x2) * (y - y2)) / d;
float l2 = 1.0f - l0 - l1;
if (l0 >= -0.001f && l1 >= -0.001f && l2 >= -0.001f) {
drawPixel(x, y, c);
}
}
}
}
void setTextDatum(uint8_t d) { datum = d; }
void setTextFont(uint8_t f) { fontNum = f; freeFontActive = false; }
void setFreeFont(const void *f) { fontPtr = f; freeFontActive = true; }
void setTextColor(uint16_t fg) { this->fg = fg; bgOpaque = false; }
void setTextColor(uint16_t fg, uint16_t bg) { this->fg = fg; this->bg = bg; bgOpaque = true; }
void drawString(const String &s, int32_t x, int32_t y)
{
if (s.s.empty()) return;
int size = freeFontActive ? freeFontSize(fontPtr) : (fontNum >= 2 ? 15 : 10);
TTF_Font *f = getFont(size, freeFontActive);
if (!f) return;
SDL_Color col = sdlColor(fg);
SDL_Surface *surf = TTF_RenderText_Blended(f, s.s.c_str(), s.s.size(), col);
if (!surf) return;
SDL_Surface *conv = SDL_ConvertSurface(surf, SDL_PIXELFORMAT_ABGR8888);
SDL_DestroySurface(surf);
if (!conv) return;
int w = conv->w, h = conv->h;
int dx = x, dy = y;
switch (datum) {
case TL_DATUM: dx = x; dy = y; break;
case TC_DATUM: dx = x - w/2; dy = y; break;
case TR_DATUM: dx = x - w; dy = y; break;
case ML_DATUM: dx = x; dy = y - h/2; break;
case MC_DATUM: dx = x - w/2; dy = y - h/2; break;
case MR_DATUM: dx = x - w; dy = y - h/2; break;
case BL_DATUM: dx = x; dy = y - h; break;
case BC_DATUM: dx = x - w/2; dy = y - h; break;
case BR_DATUM: dx = x - w; dy = y - h; break;
default: break;
}
if (bgOpaque) fillRect(dx, dy, w, h, bg);
uint32_t *px = (uint32_t *)conv->pixels;
int pitch = conv->pitch / 4;
for (int j = 0; j < h; j++) {
int ty = dy + j;
if (ty < 0 || ty >= emuGfx::H) continue;
for (int i = 0; i < w; i++) {
int tx = dx + i;
if (tx < 0 || tx >= emuGfx::W) continue;
uint32_t p = px[j * pitch + i];
if ((p >> 24) > 0) emuGfx::fb[ty * emuGfx::W + tx] = p;
}
}
SDL_DestroySurface(conv);
emuGfx::dirty = true;
}
private:
static SDL_Color sdlColor(uint16_t c565)
{
uint32_t p = rgb565to888(c565);
SDL_Color c;
c.r = (uint8_t)(p & 0xFF);
c.g = (uint8_t)((p >> 8) & 0xFF);
c.b = (uint8_t)((p >> 16) & 0xFF);
c.a = 255;
return c;
}
static int freeFontSize(const void *f)
{
if (f == (const void *)&FreeSansBold18pt7b) return 24;
if (f == (const void *)&FreeSansOblique12pt7b) return 16;
if (f == (const void *)&FreeSans12pt7b) return 16;
return 32; // 24pt and anything unknown
}
static TTF_Font *getFont(int size, bool bold)
{
static std::map<std::pair<int, bool>, TTF_Font *> cache;
auto key = std::make_pair(size, bold);
auto it = cache.find(key);
if (it != cache.end()) return it->second;
const char *paths[] = {
"/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
"/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
"/usr/share/fonts/dejavu/DejaVuSans.ttf",
"/usr/share/fonts/dejavu/DejaVuSans-Bold.ttf",
};
const char *path = bold ? paths[1] : paths[0];
TTF_Font *f = TTF_OpenFont(path, (float)size);
if (!f) {
f = TTF_OpenFont(paths[2], size);
if (!f) f = TTF_OpenFont(paths[3], size);
}
cache[key] = f;
return f;
}
uint8_t datum = MC_DATUM;
uint8_t fontNum = 1;
const void *fontPtr = nullptr;
bool freeFontActive = false;
uint16_t fg = TFT_WHITE;
uint16_t bg = TFT_BLACK;
bool bgOpaque = false;
};