Files
lilygo-t-deck/floorplan3d-demo/rcore_emu.c
T
Dejvino 0f22c6afca Add raylib-esp32 lib and FloorPlan3D demo (3D floor plan via rlsw)
Vendor raylib-esp32 v1.0.3 (63db94b) under lib/ — raylib 6.x core with
the rlsw software renderer plus the ESP32-S3 port layer (SPI display
drivers, async double-buffered flush). raylib/examples, projects, tools
and logo are trimmed (~80 MB of content nothing here compiles); see
lib/raylib-esp32/VENDOR.md for provenance.

New floorplan3d-demo (emulator-template base) renders the NetDeck demo
map (nd_demomap.h) as a 3D floor plan — bulkhead walls, blast door,
cover crates, airlock pad, terminal — through the real on-device 3D
stack on the desktop:

- rcore_emu.c: desktop PLATFORM_CUSTOM layer mirroring rcore_esp32.c,
  flushing the RGB565 sw-renderer buffer into emuGfx::fb instead of SPI
- raylib_emu_config.h: same module/limit defines as the device build
- HUD via 3x5 bitmap font into fb: rlsw's 2D textured-quad path
  (DrawText/DrawRectangle) misplaces/flips quads and samples wrong
  atlas texels in this build; the 3D path is pixel-accurate

Verified: dual build (make netdeck) green, demo smoke test clean at
~59 FPS, 600-frame stability run OK.
2026-11-16 21:46:31 +01:00

163 lines
6.8 KiB
C

/**
* rcore_emu.c — raylib platform layer for the FloorPlan3D emulator demo.
*
* Desktop counterpart of raylib-esp32's src/platform/rcore_esp32.c: provides
* all symbols that rcore.c expects from a PLATFORM_CUSTOM backend, but
* instead of pushing the RGB565 software-renderer buffer to an SPI panel it
* hands it to the SDL host via emu_raylib_present() (implemented by the
* sketch in C++, which converts 565→8888 into emuGfx::fb).
*
* Everything else mirrors rcore_esp32.c so the demo and the on-device build
* exercise the same code paths (rlsw renderer, SwapScreenBuffer flow).
*/
#include "raylib_emu_config.h"
#include "raylib.h"
#include "rlgl.h"
#include <string.h>
#include <stdint.h>
#include <time.h>
// --- Internal state --------------------------------------------------------
static int screen_width = 0;
static int screen_height = 0;
extern void *swGetColorBuffer(int *width, int *height);
extern void *swSwapColorBuffer(int *width, int *height);
// Provided by the sketch (C++): converts the RGB565 buffer into the
// emulator's ABGR8888 framebuffer and marks it dirty.
extern void emu_raylib_present(const unsigned short *rgb565, int w, int h);
// Called by the sketch before InitWindow(), mirroring raylib_esp32_init()
// (which tells the port layer the panel size on device).
void emu_raylib_set_framebuffer(int w, int h)
{
screen_width = w;
screen_height = h;
}
// ---------------------------------------------------------------------------
// Window management stubs
// ---------------------------------------------------------------------------
bool WindowShouldClose(void) { return false; }
void ToggleFullscreen(void) { TRACELOG(LOG_WARNING, "ToggleFullscreen() not available in the emulator"); }
void ToggleBorderlessWindowed(void) { TRACELOG(LOG_WARNING, "ToggleBorderlessWindowed() not available in the emulator"); }
void MaximizeWindow(void) { TRACELOG(LOG_WARNING, "MaximizeWindow() not available in the emulator"); }
void MinimizeWindow(void) { TRACELOG(LOG_WARNING, "MinimizeWindow() not available in the emulator"); }
void RestoreWindow(void) { TRACELOG(LOG_WARNING, "RestoreWindow() not available in the emulator"); }
void SetWindowState(unsigned int flags) { (void)flags; }
void ClearWindowState(unsigned int flags){ (void)flags; }
void SetWindowIcon(Image image) { (void)image; }
void SetWindowIcons(Image *imgs, int n) { (void)imgs; (void)n; }
void SetWindowTitle(const char *title) { (void)title; }
void SetWindowPosition(int x, int y) { (void)x; (void)y; }
void SetWindowMonitor(int m) { (void)m; }
void SetWindowMinSize(int w, int h) { (void)w; (void)h; }
void SetWindowMaxSize(int w, int h) { (void)w; (void)h; }
void SetWindowSize(int w, int h) { (void)w; (void)h; }
void SetWindowOpacity(float o) { (void)o; }
void SetWindowFocused(void) {}
void *GetWindowHandle(void) { return NULL; }
int GetCurrentMonitor(void) { return 0; }
Vector2 GetMonitorPosition(int m) { (void)m; return (Vector2){0, 0}; }
int GetMonitorWidth(int m) { (void)m; return screen_width; }
int GetMonitorHeight(int m) { (void)m; return screen_height; }
int GetMonitorPhysicalWidth(int m) { (void)m; return 0; }
int GetMonitorPhysicalHeight(int m) { (void)m; return 0; }
int GetMonitorRefreshRate(int m) { (void)m; return 60; }
const char *GetMonitorName(int m) { (void)m; return "T-Deck emulator"; }
Vector2 GetWindowPosition(void) { return (Vector2){0, 0}; }
Vector2 GetWindowScaleDPI(void) { return (Vector2){1.0f, 1.0f}; }
void SetClipboardText(const char *t) { (void)t; }
const char *GetClipboardText(void) { return ""; }
Image GetClipboardImage(void) { return (Image){0}; }
// ---------------------------------------------------------------------------
// Cursor stubs
// ---------------------------------------------------------------------------
void ShowCursor(void) {}
void HideCursor(void) {}
void EnableCursor(void) {}
void DisableCursor(void) {}
// ---------------------------------------------------------------------------
// Input stubs (the sketch reads emu::keyboard directly instead)
// ---------------------------------------------------------------------------
int SetGamepadMappings(const char *m) { (void)m; return 0; }
void SetMousePosition(int x, int y) { (void)x; (void)y; }
void SetMouseCursor(int c) { (void)c; }
const char *GetKeyName(int key) { (void)key; return ""; }
void PollInputEvents(void) {}
// ---------------------------------------------------------------------------
// SwapScreenBuffer — hand the rendered frame to the SDL host
// ---------------------------------------------------------------------------
void SwapScreenBuffer(void)
{
int sw_w, sw_h;
uint16_t *rendered = (uint16_t *)swSwapColorBuffer(&sw_w, &sw_h);
if (!rendered || sw_w != screen_width || sw_h != screen_height) {
TRACELOG(LOG_ERROR, "PLATFORM: Framebuffer mismatch");
return;
}
emu_raylib_present(rendered, sw_w, sw_h);
}
// ---------------------------------------------------------------------------
// Timing
// ---------------------------------------------------------------------------
double GetTime(void)
{
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
return (double)ts.tv_sec + (double)ts.tv_nsec / 1000000000.0;
}
// ---------------------------------------------------------------------------
// Misc
// ---------------------------------------------------------------------------
void OpenURL(const char *url)
{
if (strchr(url, '\'') != NULL)
TRACELOG(LOG_WARNING, "SYSTEM: Provided URL contains suspicious character");
}
// ---------------------------------------------------------------------------
// Platform init / close
// ---------------------------------------------------------------------------
int InitPlatform(void);
bool InitGraphicsDevice(void);
bool CreateWindowFramebuffer(int width, int height)
{
screen_width = width;
screen_height = height;
TRACELOG(LOG_INFO, "PLATFORM: Framebuffer %dx%d (RGB565, software renderer)", width, height);
return true;
}
int InitPlatform(void)
{
if (screen_width == 0 || screen_height == 0) {
// Mirrors the ESP32 port: display size must be known before InitWindow().
TRACELOG(LOG_ERROR, "PLATFORM: Framebuffer size unknown — call "
"emu_raylib_set_framebuffer(w, h) before InitWindow()");
return -1;
}
CreateWindowFramebuffer(screen_width, screen_height);
TRACELOG(LOG_INFO, "PLATFORM: Emulator initialized (%dx%d)", screen_width, screen_height);
return 0;
}
void ClosePlatform(void)
{
TRACELOG(LOG_INFO, "PLATFORM: Emulator closed");
}