retroflt.h

Go to the documentation of this file.

 
#ifndef RETROFLT_H
#define RETROFLT_H
 
/* === Generic Includes and Defines === */
 
#ifndef RETROFLAT_BITMAP_TRACE_LVL
#  define RETROFLAT_BITMAP_TRACE_LVL 0
#endif /* !RETROFLAT_BITMAP_TRACE_LVL */
 
#ifndef RETROFLAT_KB_TRACE_LVL
#  define RETROFLAT_KB_TRACE_LVL    0
#endif /* !RETROFLAT_KB_TRACE_LVL */
 
#include <stdarg.h>
 
#include <marge.h>
 
#define RETROFLAT_COLOR_TABLE( f ) \
   f( 0, black,     BLACK,     0,   0,   0,   BLACK,   BLACK   ) \
   f( 1, darkblue,  DARKBLUE,  0,   0,   170, CYAN,    BLACK   ) \
   f( 2, darkgreen, DARKGREEN, 0,   170, 0,   CYAN,    BLACK   ) \
   f( 3, teal,      TEAL,      0,   170, 170, CYAN,    CYAN    ) \
   f( 4, darkred,   DARKRED,   170, 0,   0,   MAGENTA, BLACK   ) \
   f( 5, violet,    VIOLET,    170, 0,   170, MAGENTA, BLACK   ) \
   f( 6, brown,     BROWN,     170, 85,  0,   CYAN,    MAGENTA ) \
   f( 7, gray,      GRAY,      170, 170, 170, WHITE,   BLACK   ) \
   f( 8, darkgray,  DARKGRAY,  85,  85,  85,  WHITE,   BLACK   ) \
   f( 9, blue,      BLUE,      85,  85,  255, CYAN,    WHITE   ) \
   f( 10, green,    GREEN,     85,  255, 85,  CYAN,    CYAN    ) \
   f( 11, cyan,     CYAN,      85,  255, 255, CYAN,    CYAN    ) \
   f( 12, red,      RED,       255, 85,  85,  MAGENTA, WHITE   ) \
   f( 13, magenta,  MAGENTA,   255, 85,  255, MAGENTA, MAGENTA ) \
   f( 14, yellow,   YELLOW,    255, 255, 85,  CYAN,    MAGENTA ) \
   f( 15, white,    WHITE,     255, 255, 255, WHITE,   WHITE   )
 
typedef int8_t RETROFLAT_COLOR;
 
#  define RETROFLAT_COLOR_NULL (-1)
 
#  define RETROFLAT_COLORS_SZ 16
 
/* TODO: Mouse is broken under DOS/Allegro. */
#if defined( RETROFLAT_OS_UNIX ) || defined( RETROFLAT_OS_WIN )
#define RETROFLAT_MOUSE
#endif /* RETROFLAT_OS_WIN || RETROFLAT_OS_WIN */
 
#define RETROFLAT_OK             0x00
#define RETROFLAT_ERROR_ENGINE   0x01
#define RETROFLAT_ERROR_GRAPHICS 0x02
#define RETROFLAT_ERROR_MOUSE    0x04
 
#define RETROFLAT_ERROR_BITMAP   0x08
#define RETROFLAT_ERROR_TIMER    0x0f
 
 /* maug_retroflt_retval */
 
#define RETROFLAT_FLAGS_FILL     0x01
 
#define RETROFLAT_FLAGS_OPAQUE   0x01
 
#define RETROFLAT_FLAGS_ALL_CAPS 0x02
 
#define RETROFLAT_FLAGS_LITERAL_PATH   0x02
 
#ifndef RETROFLAT_NO_STRING
#define RETROFLAT_FLAGS_OUTLINE  0x04
#endif /* !RETROFLAT_NO_STRING */
 
#define RETROFLAT_FLAGS_SCREEN_BUFFER     0x80
 
#define RETROFLAT_FLAGS_VIEWPORT_REFRESH  0x20
 
 /* maug_retroflt_drawing */
 
#define RETROFLAT_FLAGS_RUNNING  0x01
 
#define RETROFLAT_FLAGS_UNLOCK_FPS 0x02
 
#define RETROFLAT_FLAGS_KEY_REPEAT 0x04
 
#define RETROFLAT_FLAGS_SCREENSAVER 0x08
 
#define RETROFLAT_FLAGS_SCALE2X 0x10
 
#define RETROFLAT_FLAGS_WAIT_FOR_FPS   0x20
 
 /* maug_retroflt_flags */
 
#define RETROFLAT_MSG_FLAG_TYPE_MASK 0x07
 
#define RETROFLAT_MSG_FLAG_ERROR 0x01
 
#define RETROFLAT_MSG_FLAG_INFO 0x02
 
#define RETROFLAT_MSG_FLAG_WARNING 0x04
 
 /* maug_retroflt_msg_flags */
 
struct RETROFLAT_STATE;
 
#define RETROFLAT_VDP_FLAG_PXLOCK 0x01
 
typedef MERROR_RETVAL (*retroflat_vdp_proc_t)( struct RETROFLAT_STATE* );
 
 /* maug_retroflt_vdp */
 
typedef MERROR_RETVAL (*retroflat_proc_resize_t)(
   uint16_t new_w, uint16_t new_h, void* data );
 
#define RETROSND_ARGS_FLAG_LIST_DEVS 0x01
 
#define RETROFLAT_FLAGS_LOCK     0x01
 
#define RETROFLAT_FLAGS_SCREEN_LOCK     0x02
 
#define RETROFLAT_FLAGS_BITMAP_RO   0x04
 
#define RETROFLAT_INSTANCE_NULL (0)
 
#define retroflat_instance_tile( instance ) \
  (instance * -1)
 
#ifndef RETROFLAT_BITMAP_EXT
#  define RETROFLAT_BITMAP_EXT "bmp"
#endif /* !RETROFLAT_BITMAP_EXT */
 
#ifndef RETROFLAT_OPENGL_BPP
#  define RETROFLAT_OPENGL_BPP 32
#endif /* !RETROFLAT_OPENGL_BPP */
 
#ifndef RETROFLAT_TILE_W
#  define RETROFLAT_TILE_W 16
#endif /* !RETROFLAT_TILE_W */
 
#ifndef RETROFLAT_TILE_W_BITS
#  define RETROFLAT_TILE_W_BITS 4
#endif /* !RETROFLAT_TILE_W_BITS */
 
#ifndef RETROFLAT_TILE_H
#  define RETROFLAT_TILE_H 16
#endif /* !RETROFLAT_TILE_H */
 
#ifndef RETROFLAT_TILE_H_BITS
#  define RETROFLAT_TILE_H_BITS 4
#endif /* !RETROFLAT_TILE_H_BITS */
 
/* Transparency background color: black by default, to match Allegro. */
#ifndef RETROFLAT_TXP_R
#  define RETROFLAT_TXP_R 0x00
#endif /* !RETROFLAT_TXP_R */
 
#ifndef RETROFLAT_TXP_G
#  define RETROFLAT_TXP_G 0x00
#endif /* !RETROFLAT_TXP_G */
 
#ifndef RETROFLAT_TXP_B
#  define RETROFLAT_TXP_B 0x00
#endif /* !RETROFLAT_TXP_B */
 
#ifndef RETROFLAT_TXP_PAL_IDX
#  define RETROFLAT_TXP_PAL_IDX 0
#endif /* !RETROFLAT_TXP_PAL_IDX */
 
 /* maug_retroflt_bitmap */
 
#ifndef RETROFLAT_DEFAULT_SCREEN_W
#  define RETROFLAT_DEFAULT_SCREEN_W 320
#endif /* RETROFLAT_DEFAULT_SCREEN_W */
 
#ifndef RETROFLAT_DEFAULT_SCREEN_H
#  define RETROFLAT_DEFAULT_SCREEN_H 200
#endif /* RETROFLAT_DEFAULT_SCREEN_H */
 
#ifndef RETROFLAT_GL_Z
#  define RETROFLAT_GL_Z -0.001
#endif /* !RETROFLAT_GL_Z */
 
#define retroflat_on_resize( w, h ) \
   g_retroflat_state->screen_w = w; \
   g_retroflat_state->screen_h = h;
 
#ifndef RETROFLAT_LINE_THICKNESS
#  define RETROFLAT_LINE_THICKNESS 1
#endif /* !RETROFLAT_LINE_THICKNESS */
 
#define RETROFLAT_PI 3.14159
 
 /* maug_retroflt_drawing */
 
#ifndef RETROFLAT_FPS
#  define RETROFLAT_FPS 30
#endif /* !RETROFLAT_FPS */
 
#define retroflat_fps_next() (1000 / RETROFLAT_FPS)
 
#ifndef RETROFLAT_WINDOW_CLASS
#  define RETROFLAT_WINDOW_CLASS "RetroFlatWindowClass"
#endif /* !RETROFLAT_WINDOW_CLASS */
 
#ifndef RETROFLAT_WIN_FRAME_TIMER_ID
#  define RETROFLAT_WIN_FRAME_TIMER_ID 6001
#endif /* !RETROFLAT_WIN_FRAME_TIMER_ID */
 
#ifndef RETROFLAT_WIN_LOOP_TIMER_ID
#  define RETROFLAT_WIN_LOOP_TIMER_ID 6002
#endif /* !RETROFLAT_WIN_LOOP_TIMER_ID */
 
#ifndef RETROFLAT_MSG_MAX
#  define RETROFLAT_MSG_MAX 4096
#endif /* !RETROFLAT_MSG_MAX */
 
#define RETROFLAT_PATH_MAX MAUG_PATH_MAX
 
#ifndef RETROFLAT_TITLE_MAX
#  define RETROFLAT_TITLE_MAX 255
#endif /* !RETROFLAT_TITLE_MAX */
 
#ifndef RETROFLAT_VDP_ARGS_SZ_MAX
#  define RETROFLAT_VDP_ARGS_SZ_MAX 255
#endif /* !RETROFLAT_VDP_ARGS_SZ_MAX */
 
#if defined( RETROFLAT_API_SDL2 )
#  if !defined( NO_RETROFLAT_RESIZABLE )
#     define RETROFLAT_WIN_FLAGS SDL_WINDOW_RESIZABLE
#  else
#     define RETROFLAT_WIN_FLAGS 0
#  endif /* !NO_RETROFLAT_RESIZABLE */
#endif /* RETROFLAT_API_SDL2 */
 
#if defined( RETROFLAT_API_SDL1 )
#  define RETROFLAT_SDL_CC_FLAGS (SDL_RLEACCEL | SDL_SRCCOLORKEY)
#elif defined( RETROFLAT_API_SDL2 )
#  define RETROFLAT_SDL_CC_FLAGS (SDL_TRUE)
#endif /* RETROFLAT_API_SDL1 || RETROFLAT_API_SDL2 */
 
#ifdef RETROFLAT_OS_DOS
#  define RETROFLAT_PATH_SEP '\\'
#else
#  define RETROFLAT_PATH_SEP '/'
#endif /* RETROFLAT_OS_DOS */
 
#define RETROFLAT_ASSETS_PATH_MAX (RETROFLAT_PATH_MAX >> 1)
 
#ifndef RETROFLAT_BMP_COLORS_SZ_MAX
#  define RETROFLAT_BMP_COLORS_SZ_MAX 256
#endif /* !RETROFLAT_BMP_COLORS_SZ_MAX */
 
 /* maug_retroflt_compiling */
 
#define retroflat_wait_for_frame() \
   (g_retroflat_state->retroflat_flags |= RETROFLAT_FLAGS_WAIT_FOR_FPS)
 
#define retroflat_is_waiting_for_frame() \
   (RETROFLAT_FLAGS_WAIT_FOR_FPS == \
      (g_retroflat_state->retroflat_flags & RETROFLAT_FLAGS_WAIT_FOR_FPS))
 
typedef char retroflat_asset_path[RETROFLAT_PATH_MAX];
 
#define retroflat_cmp_asset_path( a, b ) strncmp( a, b, RETROFLAT_PATH_MAX )
 
 /* maug_retroflt_assets */
 
typedef void (*retroflat_loop_iter)(void* data);
 
#define retroflat_buffer_bksp( buffer, buffer_cur, buffer_sz ) \
   if( 0 < buffer_cur ) { \
      if( buffer_cur < buffer_sz ) { \
         memmove( \
            &(buffer[(buffer_cur) - 1]), \
            &(buffer[buffer_cur]), \
            (buffer_sz) - (buffer_cur) ); \
      } \
      buffer_cur--; \
      buffer_sz--; \
      buffer[buffer_sz] = '\0'; \
   }
 
#define retroflat_buffer_insert( c, buffer, buffer_cur, buffer_sz, buffer_mx ) \
   if( buffer_sz + 1 < buffer_mx ) { \
      if( buffer_cur < buffer_sz ) { \
         memmove( \
            &(buffer[(buffer_cur) + 1]), \
            &(buffer[buffer_cur]), \
            (buffer_sz) - (buffer_cur) ); \
      } \
      buffer[buffer_cur] = c; \
      buffer_cur++; \
      buffer_sz++; \
      buffer[buffer_sz] = '\0'; \
   }
 
#define RETROFLAT_INPUT_MOD_SHIFT   0x01
 
#define RETROFLAT_INPUT_MOD_ALT     0x02
 
#define RETROFLAT_INPUT_MOD_CTRL    0x04
 
#define RETROFLAT_INPUT_FORCE_UPPER    0x08
 
struct RETROFLAT_INPUT {
   int mouse_x;
   int mouse_y;
   uint8_t key_flags;
};
 
 /* maug_retroflt_input */
 
#define RETROFLAT_DIR4_NORTH  0
#define RETROFLAT_DIR4_EAST   1
#define RETROFLAT_DIR4_SOUTH  2
#define RETROFLAT_DIR4_WEST   3
 
#define RETROFLAT_DIR8_NORTH  0
#define RETROFLAT_DIR8_EAST   2
#define RETROFLAT_DIR8_SOUTH  4
#define RETROFLAT_DIR8_WEST   6
 
#define retroflat_dir8_reverse( dir ) \
   ((dir + 4) % 8)
 
#define retroflat_dir8_bounce( dir ) \
   ((dir + 2) % 8)
 
 /* maug_retroflt_dir */
 
#ifdef RETROFLAT_OPENGL
struct RETROFLAT_GLTEX {
   MAUG_MHANDLE bytes_h;
   uint8_t* bytes;
   uint32_t bpp;
   uint32_t sz;
   uint8_t* px;
   uint32_t id;
   size_t w;
   size_t h;
};
#endif /* RETROFLAT_OPENGL */
 
struct RETROFLAT_ARGS;
 
#ifndef NO_RETROSND
 
#ifndef RETROSND_TRACE_LVL
#  define RETROSND_TRACE_LVL 0
#endif /* !RETROSND_TRACE_LVL */
 
#ifndef RETROSND_REG_TRACE_LVL
#  define RETROSND_REG_TRACE_LVL 0
#endif /* !RETROSND_REG_TRACE_LVL */
 
#define RETROSND_FLAG_INIT 0x01
 
 /* maug_retrosnd_flags */
 
#define RETROSND_VOICE_BREATH       122
 
#define RETROSND_VOICE_SEASHORE     123
 
#define RETROSND_VOICE_BIRD_TWEET   124
 
#define RETROSND_VOICE_PHONE_RING   125
 
#define RETROSND_VOICE_HELICOPTER   126
 
#define RETROSND_VOICE_APPLAUSE     127
 
#define RETROSND_VOICE_GUNSHOT      128
 
#define RETROSND_CHANNEL_CT         8
 
MERROR_RETVAL retrosnd_init( struct RETROFLAT_ARGS* args );
 
void retrosnd_set_sf_bank( const char* filename_in );
 
void retrosnd_midi_set_voice( uint8_t channel, uint8_t voice );
 
void retrosnd_midi_set_control( uint8_t channel, uint8_t key, uint8_t val );
 
void retrosnd_midi_note_on( uint8_t channel, uint8_t pitch, uint8_t vel );
 
void retrosnd_midi_note_off( uint8_t channel, uint8_t pitch, uint8_t vel );
 
MERROR_RETVAL retrosnd_midi_play_smf( const char* filename );
 
uint8_t retrosnd_midi_is_playing_smf();
 
void retrosnd_shutdown();
 
 /* maug_retrosnd */
 
#endif /* !NO_RETROSND */
 
/* === OS-Specific Includes and Defines === */
 
#if defined( RETROFLAT_OS_WIN ) && !defined( MAUG_WINDOWS_H )
#  include <windows.h>
#  define MAUG_WINDOWS_H
#endif /* !MAUG_WINDOWS_H */
 
/* TODO: Migrate all platform-specific parts below to retapid.h. */
#include <retapid.h>
 
typedef maug_ms_t retroflat_ms_t;
 
/* === Structures === */
 
struct RETROFLAT_ARGS {
   char* title;
   char* assets_path;
   uint8_t flags;
   char* config_path;
#  ifdef RETROFLAT_API_PC_BIOS
   uint8_t screen_mode;
#  elif !defined( RETROFLAT_NO_CLI_SZ )
   int screen_w;
   int screen_h;
   int screen_x;
   int screen_y;
#  endif /* RETROFLAT_API_PC_BIOS */
   uint8_t snd_flags;
#  if defined( RETROSND_API_SDL1 ) || defined( RETROSND_API_SDL2 )
#  elif defined( RETROSND_API_WINMM )
   UINT snd_dev_id;
#  elif defined( RETROSND_API_PC_BIOS )
   uint16_t snd_io_base;
   uint8_t snd_driver;
#  elif defined( RETROSND_API_ALSA )
   uint8_t snd_client;
   uint8_t snd_port;
#  else
#     pragma message( "warning: sound args not specified" )
#  endif /* RETROSND_API_WINMM */
};
 
typedef int16_t retroflat_tile_t;
 
struct RETROFLAT_VIEWPORT {
   int16_t screen_x;
   int16_t screen_y;
   int16_t world_x;
   int16_t world_y;
   int16_t world_w;
   int16_t world_h;
   int16_t screen_tile_w;
   int16_t screen_tile_h;
   MAUG_MHANDLE refresh_grid_h;
   retroflat_tile_t* refresh_grid;
};
 
#ifndef DOCUMENTATION
 
#  define retroflat_viewport_world_x_generic() \
   (g_retroflat_state->viewport.world_x)
 
#  define retroflat_viewport_world_y_generic() \
   (g_retroflat_state->viewport.world_y)
 
#  define retroflat_viewport_world_w_generic() \
   (g_retroflat_state->viewport.world_w)
 
#  define retroflat_viewport_world_h_generic() \
   (g_retroflat_state->viewport.world_h)
 
#  define retroflat_viewport_screen_tile_w_generic() \
   (g_retroflat_state->viewport.screen_tile_w)
 
#  define retroflat_viewport_screen_tile_h_generic() \
   (g_retroflat_state->viewport.screen_tile_h)
 
#  define retroflat_viewport_set_world_generic( w, h ) \
   (g_retroflat_state->viewport.world_w) = w; \
   (g_retroflat_state->viewport.world_h) = h;
 
#  define retroflat_viewport_set_world_pos_generic( x, y ) \
   (g_retroflat_state->viewport.world_x) = x; \
   (g_retroflat_state->viewport.world_y) = y;
 
#  define retroflat_viewport_lock_refresh_generic() \
   if( NULL == g_retroflat_state->viewport.refresh_grid ) { \
      maug_mlock( \
         g_retroflat_state->viewport.refresh_grid_h, \
         g_retroflat_state->viewport.refresh_grid ); \
      maug_cleanup_if_null_lock( retroflat_tile_t*, \
         g_retroflat_state->viewport.refresh_grid ); \
   }
 
#  define retroflat_viewport_unlock_refresh_generic() \
   if( NULL != g_retroflat_state->viewport.refresh_grid ) { \
      maug_munlock( \
         g_retroflat_state->viewport.refresh_grid_h, \
         g_retroflat_state->viewport.refresh_grid ); \
   }
 
#  define _retroflat_viewport_refresh_tile_x( x_px ) \
   (((x_px) + RETROFLAT_TILE_W) >> RETROFLAT_TILE_W_BITS)
 
#  define _retroflat_viewport_refresh_tile_y( y_px ) \
   (((y_px) + RETROFLAT_TILE_H) >> RETROFLAT_TILE_H_BITS)
 
#  define retroflat_viewport_set_refresh_generic( x_px, y_px, tid ) \
   assert( NULL != g_retroflat_state->viewport.refresh_grid ); \
   if( \
      /* Expand the range by -1 to account for just off-screen tile. */ \
      -(RETROFLAT_TILE_W) <= x_px && -(RETROFLAT_TILE_H) <= y_px && \
      retroflat_screen_w() > x_px && \
      retroflat_screen_h() > y_px \
   ) { \
      assert( 0 < g_retroflat_state->viewport.screen_tile_w ); \
      assert( 0 <= (((y_px) + RETROFLAT_TILE_H) >> RETROFLAT_TILE_H_BITS) ); \
      assert( 0 <= (((x_px) + RETROFLAT_TILE_W) >> RETROFLAT_TILE_W_BITS) ); \
      g_retroflat_state->viewport.refresh_grid[ \
         /* Add +1 tile to make off-screen "-1" tile positive. */ \
         (_retroflat_viewport_refresh_tile_y( y_px ) * \
            g_retroflat_state->viewport.screen_tile_w) + \
               _retroflat_viewport_refresh_tile_x( x_px )] = tid; \
   }
 
#  define retroflat_viewport_tile_is_stale( x_px, y_px, tile_id ) \
      ((tile_id) != \
      g_retroflat_state->viewport.refresh_grid[ \
         (_retroflat_viewport_refresh_tile_y( y_px ) * \
            g_retroflat_state->viewport.screen_tile_w) + \
               _retroflat_viewport_refresh_tile_x( x_px )])
 
uint8_t retroflat_viewport_move_x_generic( int16_t x );
 
uint8_t retroflat_viewport_move_y_generic( int16_t y );
 
uint8_t retroflat_viewport_focus_generic(
   size_t x1, size_t y1, size_t range, size_t speed );
 
#  define retroflat_viewport_screen_x_generic( world_x ) \
   ((world_x) - retroflat_viewport_world_x())
 
#  define retroflat_viewport_screen_y_generic( world_y ) \
   ((world_y) - retroflat_viewport_world_y())
 
#endif /* !DOCUMENTATION */
 
#if defined( RETROFLAT_SOFT_VIEWPORT ) || defined( DOCUMENTATION )
 
#  ifdef RETROFLAT_VIEWPORT_ADAPT
      /* Clamp world coordinates to tile borders to allow refresh grid to
       * function properly.
       */
#     define retroflat_viewport_world_x() \
         ((retroflat_viewport_world_x_generic() \
            >> RETROFLAT_TILE_W_BITS) << RETROFLAT_TILE_W_BITS)
#     define retroflat_viewport_world_y() \
         ((retroflat_viewport_world_y_generic() \
            >> RETROFLAT_TILE_H_BITS) << RETROFLAT_TILE_H_BITS)
#  else
#     define retroflat_viewport_world_x() retroflat_viewport_world_x_generic()
 
#     define retroflat_viewport_world_y() retroflat_viewport_world_y_generic()
#endif /* RETROFLAT_VIEWPORT_ADAPT */
 
#  define retroflat_viewport_world_w() \
   retroflat_viewport_world_w_generic()
 
#  define retroflat_viewport_world_h() \
   retroflat_viewport_world_h_generic()
 
#  define retroflat_viewport_screen_tile_w() \
   retroflat_viewport_screen_tile_w_generic()
 
#  define retroflat_viewport_screen_tile_h() \
   retroflat_viewport_screen_tile_h_generic()
 
#  define retroflat_viewport_set_world( w, h ) \
   retroflat_viewport_set_world_generic( w, h )
 
#  define retroflat_viewport_set_world_pos( x, y ) \
   retroflat_viewport_set_world_pos_generic( x, y )
 
#  define retroflat_viewport_lock_refresh() \
   retroflat_viewport_lock_refresh_generic()
 
#  define retroflat_viewport_unlock_refresh() \
   retroflat_viewport_unlock_refresh_generic()
 
#  define retroflat_viewport_set_refresh( x, y, tid ) \
   retroflat_viewport_set_refresh_generic( x, y, tid )
 
#  define retroflat_viewport_focus( x1, y1, range, speed ) \
   retroflat_viewport_focus_generic( x1, y1, range, speed )
 
#  define retroflat_viewport_screen_x( world_x ) \
   retroflat_viewport_screen_x_generic( world_x )
 
#  define retroflat_viewport_screen_y( world_y ) \
   retroflat_viewport_screen_y_generic( world_y )
 
#  ifndef RETROFLAT_VIEWPORT_OVERRIDE_MOVE
#     define retroflat_viewport_move_x( x ) \
         retroflat_viewport_move_x_generic( x )
 
#     define retroflat_viewport_move_y( y ) \
         retroflat_viewport_move_y_generic( y )
#  endif /* !RETROFLAT_VIEWPORT_OVERRIDE_MOVE */
 
#endif /* RETROFLAT_SOFT_VIEWPORT || DOCUMENTATION */
 
struct RETROFLAT_STATE {
   void*                   loop_data;
   MERROR_RETVAL           retval;
   uint8_t                 retroflat_flags;
   char                    config_path[RETROFLAT_PATH_MAX + 1];
   char                    assets_path[RETROFLAT_ASSETS_PATH_MAX + 1];
   /* TODO: Make indirect palette optional per-platform. */
   RETROFLAT_COLOR_DEF     palette[RETROFLAT_COLORS_SZ];
   struct RETROFLAT_BITMAP buffer;
 
#  if defined( RETROFLAT_VDP ) || defined( DOCUMENTATION ) || \
defined( RETROVDP_C )
   struct RETROFLAT_BITMAP* vdp_buffer;
#     ifdef RETROFLAT_OS_WIN
   HMODULE vdp_exe;
#     else
   void* vdp_exe;
#     endif /* RETROFLAT_OS_WIN */
   void* vdp_data;
   char vdp_args[RETROFLAT_VDP_ARGS_SZ_MAX];
   uint8_t vdp_flags;
#  endif /* RETROFLAT_VDP || DOCUMENTATION || RETROVDP_C */
 
   /* These are used by VDP so should be standardized/not put in plat-spec! */
 
   struct RETROFLAT_VIEWPORT viewport;
 
   size_t               screen_v_w;
   size_t               screen_v_h;
   size_t               screen_w;
   size_t               screen_h;
 
   /* WARNING: The VDP requires the state specifier to be the same size
    *          as the one it was compiled for! Do not modify above here!
    */
 
   /* TODO: Put these in a platform-specific struct of some kind to maintain
    *       consistent state struct size for VDP?
    */
 
   retroflat_loop_iter  loop_iter;
   retroflat_loop_iter  frame_iter;
 
   retroflat_proc_resize_t on_resize;
   void* on_resize_data;
 
#  if defined( RETROFLAT_OPENGL )
   uint8_t tex_palette[RETROFLAT_COLORS_SZ][3];
#  endif /* RETROFLAT_OPENGL */
 
   struct RETROFLAT_PLATFORM platform;
 
#ifndef NO_RETROSND
   struct RETROFLAT_SOUND sound;
#endif /* !NO_RETROSND */
};
 
/* === Translation Module === */
 
/* Declare the prototypes so that internal functions can call each other. */
 
#  ifdef retroflat_loop
MERROR_RETVAL retroflat_loop_generic(
   retroflat_loop_iter frame_iter, retroflat_loop_iter loop_iter, void* data );
#  else
MERROR_RETVAL retroflat_loop(
   retroflat_loop_iter frame_iter, retroflat_loop_iter loop_iter, void* data );
#  endif /* retroflat_loop */
 
void retroflat_message(
   uint8_t flags, const char* title, const char* format, ... );
 
MERROR_RETVAL retroflat_init( int argc, char* argv[], struct RETROFLAT_ARGS* args );
 
void retroflat_shutdown( int retval );
 
#  if defined( RETROFLAT_VDP ) || defined( DOCUMENTATION )
MERROR_RETVAL retroflat_vdp_call( const char* proc_name );
 
 /* maug_retroflt_vdp */
#  endif /* RETROFLAT_VDP || DOCUMENTATION */
 
void retroflat_set_title( const char* format, ... );
 
retroflat_ms_t retroflat_get_ms();
 
uint32_t retroflat_get_rand();
 
#  if !defined( RETROFLAT_NO_KEYBOARD )
char retroflat_vk_to_ascii( RETROFLAT_IN_KEY k, uint8_t flags );
#  endif /* !RETROFLAT_NO_KEYBOARD */
 
MERROR_RETVAL retroflat_load_bitmap(
   const char* filename, struct RETROFLAT_BITMAP* bmp_out, uint8_t flags );
 
MERROR_RETVAL retroflat_create_bitmap(
   size_t w, size_t h, struct RETROFLAT_BITMAP* bmp_out, uint8_t flags );
 
void retroflat_destroy_bitmap( struct RETROFLAT_BITMAP* bitmap );
 
MERROR_RETVAL retroflat_blit_bitmap(
   struct RETROFLAT_BITMAP* target, struct RETROFLAT_BITMAP* src,
   size_t s_x, size_t s_y, int16_t d_x, int16_t d_y, size_t w, size_t h,
   int16_t instance );
 
#define retroflat_constrain_px( x, y, bmp, retact ) \
   if( \
      x >= retroflat_bitmap_w( bmp ) || y >= retroflat_bitmap_h( bmp ) \
   ) { retact; }
 
 /* maug_retroflt_bitmap */
 
MERROR_RETVAL retroflat_draw_lock( struct RETROFLAT_BITMAP* bmp );
 
MERROR_RETVAL retroflat_draw_release( struct RETROFLAT_BITMAP* bmp );
 
void retroflat_px(
   struct RETROFLAT_BITMAP* target, const RETROFLAT_COLOR color,
   size_t x, size_t y, uint8_t flags );
 
#ifdef RETROFLAT_SOFT_SHAPES
#  ifdef RETROFLAT_OPENGL
/* Make sure we're not passing NULL to openGL texture drawers... they can't
 * handle that!
 */
#     define retroflat_rect( t, c, x, y, w, h, f ) \
      assert( NULL != t ); \
      retrosoft_rect( t, c, x, y, w, h, f );
#     define retroflat_ellipse( t, c, x, y, w, h, f ) \
      assert( NULL != t ); \
      retrosoft_ellipse( t, c, x, y, w, h, f )
#  else
#     define retroflat_rect( t, c, x, y, w, h, f ) \
      retrosoft_rect( t, c, x, y, w, h, f )
#     define retroflat_ellipse( t, c, x, y, w, h, f ) \
      retrosoft_ellipse( t, c, x, y, w, h, f )
#  endif /* RETROFLAT_OPENGL */
#else
 
void retroflat_rect(
   struct RETROFLAT_BITMAP* target, const RETROFLAT_COLOR color,
   int16_t x, int16_t y, int16_t w, int16_t h, uint8_t flags );
 
void retroflat_ellipse(
   struct RETROFLAT_BITMAP* target, const RETROFLAT_COLOR color,
   int16_t x, int16_t y, int16_t w, int16_t h, uint8_t flags );
 
#endif /* RETROFLAT_SOFT_SHAPES */
 
#ifdef RETROFLAT_SOFT_LINES
#  define retroflat_line( t, c, x1, y1, x2, y2, f ) \
   retrosoft_line( t, c, x1, y1, x2, y2, f )
#else
 
void retroflat_line(
   struct RETROFLAT_BITMAP* target, const RETROFLAT_COLOR color,
   int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint8_t flags );
 
#endif /* RETROFLAT_SOFT_LINES */
 
void retroflat_cursor( struct RETROFLAT_BITMAP* target, uint8_t flags );
 
void retroflat_string_sz(
   struct RETROFLAT_BITMAP* target, const char* str, size_t str_sz,
   const char* font_str, size_t* w_out, size_t* h_out, uint8_t flags );
 
void retroflat_string(
   struct RETROFLAT_BITMAP* target, const RETROFLAT_COLOR color,
   const char* str, int str_sz, const char* font_str, int16_t x_orig, int16_t y_orig,
   uint8_t flags );
 
/* TODO: Documentation! */
void retroflat_get_palette( uint8_t idx, uint32_t* rgb );
 
MERROR_RETVAL retroflat_set_palette( uint8_t idx, uint32_t rgb );
 
 /* maug_retroflt_bitmap */
 
void retroflat_set_proc_resize(
   retroflat_proc_resize_t on_resize_in, void* data_in );
 
void retroflat_resize_v();
 
RETROFLAT_IN_KEY retroflat_poll_input( struct RETROFLAT_INPUT* input );
 
 /* maug_retroflt_input */
 
#ifdef RETROFLT_C
 
MAUG_CONST int16_t SEG_MCONST gc_retroflat_offsets8_x[8] =
   {  0,  1, 1, 1, 0, -1, -1, -1 };
MAUG_CONST int16_t SEG_MCONST gc_retroflat_offsets8_y[8] =
   { -1, -1, 0, 1, 1,  1,  0, -1 };
 
MAUG_CONST int16_t SEG_MCONST gc_retroflat_offsets4_x[4] =
   {  0, 1, 0, -1 };
MAUG_CONST int16_t SEG_MCONST gc_retroflat_offsets4_y[4] =
   { -1, 0, 1,  0 };
 
MAUG_MHANDLE g_retroflat_state_h = (MAUG_MHANDLE)NULL;
struct RETROFLAT_STATE* g_retroflat_state = NULL;
 
#  define RETROFLAT_COLOR_TABLE_CONSTS( idx, name_l, name_u, r, g, b, cgac, cgad ) \
      MAUG_CONST RETROFLAT_COLOR RETROFLAT_COLOR_ ## name_u = idx;
 
RETROFLAT_COLOR_TABLE( RETROFLAT_COLOR_TABLE_CONSTS )
 
#  define RETROFLAT_COLOR_TABLE_NAMES( idx, name_l, name_u, r, g, b, cgac, cgad ) \
      #name_u,
 
MAUG_CONST char* SEG_MCONST gc_retroflat_color_names[] = {
   RETROFLAT_COLOR_TABLE( RETROFLAT_COLOR_TABLE_NAMES )
};
 
/* Callback table is down below, after the statically-defined callbacks. */
 
/* === Function Definitions === */
 
MERROR_RETVAL retroflat_build_filename_path(
   const char* filename_in,
   char* buffer_out, size_t buffer_out_sz, uint8_t flags
) {
   MERROR_RETVAL retval = MERROR_OK;
 
   assert( 1 < buffer_out_sz );
 
   /* Build the path to the bitmap. */
   memset( buffer_out, '\0', buffer_out_sz );
   if(
      RETROFLAT_FLAGS_LITERAL_PATH ==
      (RETROFLAT_FLAGS_LITERAL_PATH & flags)
   ) {
      /* TODO: Error checking. */
      maug_snprintf( buffer_out, buffer_out_sz - 1, "%s", filename_in );
   } else {
      /* TODO: Error checking. */
      maug_snprintf( buffer_out, buffer_out_sz - 1, "%s%c%s.%s",
         g_retroflat_state->assets_path, RETROFLAT_PATH_SEP,
         filename_in, RETROFLAT_BITMAP_EXT );
   }
 
   return retval;
}
 
/* === */
 
#  if (defined( RETROFLAT_SOFT_SHAPES ) || defined( RETROFLAT_SOFT_LINES )) \
   && !defined( MAUG_NO_AUTO_C )
#     define RETROFP_C
#     include <retrofp.h>
#     define RETROSFT_C
#     include <retrosft.h>
#  endif /* RETROFLAT_SOFT_SHAPES */
 
#  if defined( RETROFLAT_OPENGL ) && !defined( MAUG_NO_AUTO_C )
#     define RETROGLU_C
#     include <retroglu.h>
#     define RETROFP_C
#     include <retrofp.h>
#     define RETROSFT_C
#     include <retrosft.h>
#  endif /* RETROFLAT_OPENGL */
 
#  if defined( RETROFLAT_VDP ) && defined( RETROFLAT_OS_UNIX )
#     include <dlfcn.h>
#  endif
 
/* Still inside RETROFLT_C! */
 
/* === */
 
#ifndef RETROFLAT_NO_GENERIC_LOOP
 
MERROR_RETVAL retroflat_loop_generic(
   retroflat_loop_iter frame_iter, retroflat_loop_iter loop_iter, void* data
) {
   MERROR_RETVAL retval = MERROR_OK;
   retroflat_ms_t next = 0,
      now = 0;
 
   g_retroflat_state->loop_iter = (retroflat_loop_iter)loop_iter;
   g_retroflat_state->loop_data = (void*)data;
   g_retroflat_state->frame_iter = (retroflat_loop_iter)frame_iter;
 
   if(
      RETROFLAT_FLAGS_RUNNING ==
      (g_retroflat_state->retroflat_flags & RETROFLAT_FLAGS_RUNNING)
   ) {
      /* Main loop is already running, so we're just changing the iter call
       * and leaving!
       */
      debug_printf( 1, "main loop already running!" );
      goto cleanup;
   }
 
   g_retroflat_state->retroflat_flags |= RETROFLAT_FLAGS_RUNNING;
   do {
      if(
         /* Not waiting for the next frame? */
         RETROFLAT_FLAGS_WAIT_FOR_FPS !=
         (RETROFLAT_FLAGS_WAIT_FOR_FPS & g_retroflat_state->retroflat_flags) &&
         /* Inter-frame loop present? */
         NULL != g_retroflat_state->loop_iter
      ) {
         /* Run the loop iter as many times as possible. */
         g_retroflat_state->loop_iter( g_retroflat_state->loop_data );
      }
      if(
         RETROFLAT_FLAGS_UNLOCK_FPS !=
         (RETROFLAT_FLAGS_UNLOCK_FPS & g_retroflat_state->retroflat_flags) &&
         retroflat_get_ms() < next
      ) {
         /* Sleep/low power for a bit. */
         continue;
      }
      if( NULL != g_retroflat_state->frame_iter ) {
         /* Run the frame iterator once per FPS tick. */
         g_retroflat_state->frame_iter( g_retroflat_state->loop_data );
      }
      /* Reset wait-for-frame flag AFTER frame callback. */
      g_retroflat_state->retroflat_flags &= ~RETROFLAT_FLAGS_WAIT_FOR_FPS;
      now = retroflat_get_ms();
      if( now + retroflat_fps_next() > now ) {
         next = now + retroflat_fps_next();
      } else {
         /* Rollover protection. */
         /* TODO: Add difference from now/next to 0 here. */
         next = 0;
      }
   } while(
      RETROFLAT_FLAGS_RUNNING == 
         (RETROFLAT_FLAGS_RUNNING & g_retroflat_state->retroflat_flags)
   );
   retval = g_retroflat_state->retval;
 
cleanup:
 
   /* This should be set by retroflat_quit(). */
   return retval;
}
 
#endif /* !RETROFLAT_NO_GENERIC_LOOP */
 
/* === */
 
#  if !defined( RETROFLAT_NO_KEYBOARD )
 
char retroflat_vk_to_ascii( RETROFLAT_IN_KEY k, uint8_t flags ) {
   char c = 0;
   char offset_lower = 0;
 
   if( RETROFLAT_INPUT_MOD_SHIFT != (RETROFLAT_INPUT_MOD_SHIFT & flags) ) {
      /* Shift is *not* being held down. */
 
      if( RETROFLAT_KEY_A <= k && RETROFLAT_KEY_Z >= k ) {
         if( 
            RETROFLAT_INPUT_FORCE_UPPER !=
               (RETROFLAT_INPUT_FORCE_UPPER & flags)
         ) {
            /* Key is alphabetical and we're not forcing uppercase. */
            offset_lower = 0x20;
         }
      } else {
         offset_lower = 1;
      }
   }
   
   switch( k ) {
   case RETROFLAT_KEY_A: c = 0x41 + offset_lower; break;
   case RETROFLAT_KEY_B: c = 0x42 + offset_lower; break;
   case RETROFLAT_KEY_C: c = 0x43 + offset_lower; break;
   case RETROFLAT_KEY_D: c = 0x44 + offset_lower; break;
   case RETROFLAT_KEY_E: c = 0x45 + offset_lower; break;
   case RETROFLAT_KEY_F: c = 0x46 + offset_lower; break;
   case RETROFLAT_KEY_G: c = 0x47 + offset_lower; break;
   case RETROFLAT_KEY_H: c = 0x48 + offset_lower; break;
   case RETROFLAT_KEY_I: c = 0x49 + offset_lower; break;
   case RETROFLAT_KEY_J: c = 0x4a + offset_lower; break;
   case RETROFLAT_KEY_K: c = 0x4b + offset_lower; break;
   case RETROFLAT_KEY_L: c = 0x4c + offset_lower; break;
   case RETROFLAT_KEY_M: c = 0x4d + offset_lower; break;
   case RETROFLAT_KEY_N: c = 0x4e + offset_lower; break;
   case RETROFLAT_KEY_O: c = 0x4f + offset_lower; break;
   case RETROFLAT_KEY_P: c = 0x50 + offset_lower; break;
   case RETROFLAT_KEY_Q: c = 0x51 + offset_lower; break;
   case RETROFLAT_KEY_R: c = 0x52 + offset_lower; break;
   case RETROFLAT_KEY_S: c = 0x53 + offset_lower; break;
   case RETROFLAT_KEY_T: c = 0x54 + offset_lower; break;
   case RETROFLAT_KEY_U: c = 0x55 + offset_lower; break;
   case RETROFLAT_KEY_V: c = 0x56 + offset_lower; break;
   case RETROFLAT_KEY_W: c = 0x57 + offset_lower; break;
   case RETROFLAT_KEY_X: c = 0x58 + offset_lower; break;
   case RETROFLAT_KEY_Y: c = 0x59 + offset_lower; break;
   case RETROFLAT_KEY_Z: c = 0x60 + offset_lower; break;
   case RETROFLAT_KEY_0: c = offset_lower ? 0x30 : ')'; break;
   case RETROFLAT_KEY_1: c = offset_lower ? 0x31 : '!'; break;
   case RETROFLAT_KEY_2: c = offset_lower ? 0x32 : '@'; break;
   case RETROFLAT_KEY_3: c = offset_lower ? 0x33 : '#'; break;
   case RETROFLAT_KEY_4: c = offset_lower ? 0x34 : '$'; break;
   case RETROFLAT_KEY_5: c = offset_lower ? 0x35 : '%'; break;
   case RETROFLAT_KEY_6: c = offset_lower ? 0x36 : '^'; break;
   case RETROFLAT_KEY_7: c = offset_lower ? 0x37 : '&'; break;
   case RETROFLAT_KEY_8: c = offset_lower ? 0x38 : '*'; break;
   case RETROFLAT_KEY_9: c = offset_lower ? 0x39 : '('; break;
   case RETROFLAT_KEY_SPACE: c = ' '; break;
   case RETROFLAT_KEY_BKSP: c = 0x08; break;
   case RETROFLAT_KEY_ENTER: c = '\n'; break;
   case RETROFLAT_KEY_SEMICOLON: c = offset_lower ? ';' : ':'; break;
   case RETROFLAT_KEY_DASH: c = offset_lower ? '-' : '_'; break;
   case RETROFLAT_KEY_SLASH: c = offset_lower ? '/' : '?'; break;
   case RETROFLAT_KEY_PERIOD: c = offset_lower ? '.' : '>'; break;
   case RETROFLAT_KEY_COMMA: c = offset_lower ? ',' : '<'; break;
   case RETROFLAT_KEY_QUOTE: c = offset_lower ? '\'' : '"'; break;
   case RETROFLAT_KEY_EQUALS: c = offset_lower ? '=' : '+'; break;
   case RETROFLAT_KEY_BACKSLASH: c = offset_lower ? '\\' : '|'; break;
   case RETROFLAT_KEY_BRACKETL: c = offset_lower ? '[' : '{'; break;
   case RETROFLAT_KEY_BRACKETR: c = offset_lower ? ']' : '}'; break;
#ifndef RETROFLAT_API_PC_BIOS
   /* TODO: FIXME in DOS! */
   case RETROFLAT_KEY_GRAVE: c = offset_lower ? '`' : '~'; break;
#endif /* !RETROFLAT_API_PC_BIOS */
   }
 
   debug_printf( RETROFLAT_KB_TRACE_LVL, "0x%02x", c );
 
   return c;
}
 
#endif /* !RETROFLAT_NO_KEYBOARD */
 
/* === */
 
/* TODO: Migrate all platform-specific parts below to retapif.h. */
#include <retapif.h>
 
/* === */
 
#  ifndef RETROFLAT_NO_CLI
 
#  ifdef RETROSND_ARGS
 
static MERROR_RETVAL retrosnd_cli_rsl(
   const char* arg, ssize_t arg_c, struct RETROFLAT_ARGS* args
) {
   if(
      0 <= arg_c &&
      0 == strncmp( MAUG_CLI_SIGIL "rsl", arg, MAUG_CLI_SIGIL_SZ + 4 )
   ) {
      args->snd_flags |= RETROSND_ARGS_FLAG_LIST_DEVS;
   }
   return MERROR_OK;
}
 
static MERROR_RETVAL retrosnd_cli_rsd(
   const char* arg, ssize_t arg_c, struct RETROFLAT_ARGS* args
) {
   MERROR_RETVAL retval = MERROR_OK;
#     if defined( RETROSND_API_PC_BIOS ) || defined( RETROSND_API_ALSA )
   char* env_var = NULL;
   size_t i = 0;
#     elif defined( RETROSND_API_ALSA )
   char* env_var = NULL;
#     elif defined( RETROSND_API_WINMM )
   char* env_var = NULL;
#     endif /* RETROSND_API_PC_BIOS || RETROSND_API_ALSA */
 
   if( 0 > arg_c ) {
#     ifdef RETROSND_API_PC_BIOS
   if( NULL != env_var ) {
      env_var = getenv( "MAUG_MIDI_DOS" );
 
      /* Return MERROR_OK since this isn't fatal and will just cause sound
         * init to fail later.
         */
      maug_cleanup_if_null_msg(
         char*, env_var, MERROR_OK, "MAUG_MIDI_DOS variable not found!" );
 
      debug_printf( 2, "env: MAUG_MIDI_DOS: %s", env_var );
 
      /* Turn comma separator into NULL split. */
      for( i = 0 ; maug_strlen( env_var ) > i ; i++ ) {
         if( ',' == env_var[i] ) {
            /* Split into two null-terminated strings. */
            env_var[i] = '\0';
         }
      }
 
      if( 0 == strcmp( env_var, "mpu" ) ) {
         debug_printf( 3, "selecting MIDI driver: mpu" );
         args->snd_driver = 2;
      } else if( 0 == strcmp( env_var, "gus" ) ) {
         debug_printf( 3, "selecting MIDI driver: gus" );
         args->snd_driver = 4;
      } else if( 0 == strcmp( env_var, "adlib" ) ) {
         debug_printf( 3, "selecting MIDI driver: adlib" );
         args->snd_driver = 8;
      }
      /* TODO: Maug replacement for C99 crutch. */
      args->snd_io_base = strtoul( &(env_var[i]), NULL, 16 );
      debug_printf( 3, "setting MIDI I/O base: %u", args->snd_io_base );
   } else {
      /* default */
      debug_printf( 3, "default MIDI driver: adlib" );
      args->snd_driver = 8;
      args->snd_io_base = 0x388;
   }
 
#     elif defined( RETROSND_API_ALSA )
   if( 0 == args->snd_client ) {
      env_var = getenv( "MAUG_MIDI_ALSA" );
 
      /* Return MERROR_OK since this isn't fatal and will just cause sound
         * init to fail later.
         */
      maug_cleanup_if_null_msg(
         char*, env_var, MERROR_OK, "MAUG_MIDI_ALSA variable not found!" );
 
      debug_printf( 2, "env: MAUG_MIDI_ALSA: %s", env_var );
 
      for( i = 0 ; maug_strlen( env_var ) > i ; i++ ) {
         if( ':' == env_var[i] ) {
            /* Split into two null-terminated strings. */
            env_var[i] = '\0';
         }
      }
 
      args->snd_client = atoi( env_var );
      args->snd_port = atoi( &(env_var[i]) );
      debug_printf( 3, "setting MIDI device to: %u:%u",
         args->snd_client, args->snd_port );
   }
 
#     elif defined( RETROSND_API_WINMM )
   env_var = getenv( "MAUG_MIDI_WIN" );
 
   /* Return MERROR_OK since this isn't fatal and will just cause sound
      * init to fail later.
      */
   maug_cleanup_if_null_msg(
      char*, env_var, MERROR_OK, "MAUG_MIDI_WIN variable not found!" );
 
   debug_printf( 2, "env: MAUG_MIDI_WIN: %s", env_var );
 
   if( NULL != env_var ) {
      args->snd_dev_id = atoi( env_var );
   } else {
      args->snd_dev_id = 0;
   }
   debug_printf( 3, "setting MIDI device to: %u", args->snd_dev_id );
 
#     endif /* RETROSND_API_PC_BIOS || RETROSND_API_ALSA || RETROSND_API_WINMM */
   } else if(
      0 == strncmp( MAUG_CLI_SIGIL "rsd", arg, MAUG_CLI_SIGIL_SZ + 4 )
   ) {
      /* The next arg must be the new var. */
   } else {
#     ifdef RETROSND_API_PC_BIOS
      /* TODO: Parse device. */
#     elif defined( RETROSND_API_ALSA )
      /* TODO: Parse device. */
#     elif defined( RETROSND_API_WINMM )
      debug_printf( 3, "setting MIDI device to rsd arg: %s", arg );
      args->snd_dev_id = atoi( arg );
#     endif /* RETROSND_API_PC_BIOS || RETROSND_API_ALSA || RETROSND_API_WINMM */
   }
 
#     if defined( RETROSND_API_PC_BIOS ) || defined( RETROSND_API_ALSA )
cleanup:
#     elif defined( RETROSND_API_ALSA )
cleanup:
#     elif defined( RETROSND_API_WINMM )
cleanup:
#     endif /* RETROSND_API_PC_BIOS || RETROSND_API_ALSA */
 
   return retval;
}
 
# endif /* RETROSND_ARGS */
 
#  if !defined( RETROFLAT_API_PC_BIOS ) && !defined( RETROFLAT_NO_CLI_SZ )
 
static MERROR_RETVAL retroflat_cli_rfx(
   const char* arg, ssize_t arg_c, struct RETROFLAT_ARGS* args
) {
   if( 0 > arg_c ) {
      if( 0 == args->screen_w ) {
         args->screen_x = 0;
      }
   } else if(
      0 == strncmp( MAUG_CLI_SIGIL "rfx", arg, MAUG_CLI_SIGIL_SZ + 4 )
   ) {
      /* The next arg must be the new var. */
   } else {
      args->screen_x = atoi( arg );
   }
   return MERROR_OK;
}
 
static MERROR_RETVAL retroflat_cli_rfy(
   const char* arg, ssize_t arg_c, struct RETROFLAT_ARGS* args
) {
   if( 0 > arg_c ) {
      if( 0 == args->screen_h ) {
         args->screen_y = 0;
      }
   } else if(
      0 == strncmp( MAUG_CLI_SIGIL "rfy", arg, MAUG_CLI_SIGIL_SZ + 4 )
   ) {
      /* The next arg must be the new var. */
   } else {
      args->screen_y = atoi( arg );
   }
   return MERROR_OK;
}
 
static MERROR_RETVAL retroflat_cli_rfw(
   const char* arg, ssize_t arg_c, struct RETROFLAT_ARGS* args
) {
   if( 0 > arg_c ) {
      if( 0 == args->screen_w ) {
         args->screen_w = RETROFLAT_DEFAULT_SCREEN_W;
      }
   } else if(
      0 == strncmp( MAUG_CLI_SIGIL "rfw", arg, MAUG_CLI_SIGIL_SZ + 4 )
   ) {
      /* The next arg must be the new var. */
   } else {
      args->screen_w = atoi( arg );
   }
   return MERROR_OK;
}
 
static MERROR_RETVAL retroflat_cli_rfh(
   const char* arg, ssize_t arg_c, struct RETROFLAT_ARGS* args
) {
   if( 0 > arg_c ) {
      if( 0 == args->screen_h ) {
         args->screen_h = RETROFLAT_DEFAULT_SCREEN_H;
      }
   } else if(
      0 == strncmp( MAUG_CLI_SIGIL "rfh", arg, MAUG_CLI_SIGIL_SZ + 4 )
   ) {
      /* The next arg must be the new var. */
   } else {
      args->screen_h = atoi( arg );
   }
   return MERROR_OK;
}
 
#  endif /* !RETROFLAT_API_PC_BIOS && !RETROFLAT_NO_CLI_SZ */
 
#  ifdef RETROFLAT_VDP
static MERROR_RETVAL retroflat_cli_vdp(
   const char* arg, ssize_t arg_c, struct RETROFLAT_ARGS* args
) {
   if( 0 == strncmp( MAUG_CLI_SIGIL "vdp", arg, MAUG_CLI_SIGIL_SZ + 4 ) ) {
      /* Next arg is VDP args str. */
   } else {
      maug_strncpy( g_retroflat_state->vdp_args, arg, RETROFLAT_VDP_ARGS_SZ_MAX );
      debug_printf( 1, "VDP args: %s", g_retroflat_state->vdp_args );
   }
   return MERROR_OK;
}
#  endif /* RETROFLAT_VDP */
 
static MERROR_RETVAL retroflat_cli_u(
   const char* arg, ssize_t arg_c, struct RETROFLAT_ARGS* args
) {
   if( 0 > arg_c ) {
      args->flags &= ~RETROFLAT_FLAGS_UNLOCK_FPS;
   } else if(
      0 == strncmp( MAUG_CLI_SIGIL "rfu", arg, MAUG_CLI_SIGIL_SZ + 4 )
   ) {
      debug_printf( 1, "unlocking FPS..." );
      args->flags |= RETROFLAT_FLAGS_UNLOCK_FPS;
   }
   return MERROR_OK;
}
 
#endif /* !RETROFLAT_NO_CLI */
 
/* === */
 
/* Still inside RETROFLT_C! */
 
int retroflat_init( int argc, char* argv[], struct RETROFLAT_ARGS* args ) {
 
   /* = Declare Init Vars = */
 
   int retval = 0;
 
   /* = Begin Init Procedure = */
 
#  ifdef RETROFLAT_COMMIT_HASH
   debug_printf( 1, "retroflat commit: " RETROFLAT_COMMIT_HASH  );
#  endif /* RETROFLAT_COMMIT_HASH */
 
   debug_printf( 1, "retroflat: initializing..." );
 
   /* System sanity checks. */
   assert( 4 == sizeof( uint32_t ) );
   assert( 4 == sizeof( int32_t ) );
   assert( 2 == sizeof( uint16_t ) );
   assert( 2 == sizeof( int16_t ) );
   assert( 1 == sizeof( uint8_t ) );
   assert( 1 == sizeof( int8_t ) );
   assert( NULL != args );
   assert( 1 << RETROFLAT_TILE_W_BITS == RETROFLAT_TILE_W );
   assert( 1 << RETROFLAT_TILE_H_BITS == RETROFLAT_TILE_H );
 
   debug_printf( 1, "retroflat: allocating state (" SIZE_T_FMT " bytes)...",
      sizeof( struct RETROFLAT_STATE ) );
 
   debug_printf( 1, "retroflat: size_t is (" SIZE_T_FMT " bytes)...",
      sizeof( size_t ) );
 
   debug_printf( 1, "retroflat: ssize_t is (" SIZE_T_FMT " bytes)...",
      sizeof( ssize_t ) );
 
   debug_printf( 1, "retroflat: off_t is (" SIZE_T_FMT " bytes)...",
      sizeof( off_t ) );
 
   g_retroflat_state_h = maug_malloc( 1, sizeof( struct RETROFLAT_STATE ) );
   if( (MAUG_MHANDLE)NULL == g_retroflat_state_h ) {
      retroflat_message( RETROFLAT_MSG_FLAG_ERROR,
         "Error", "Could not allocate global state!" );
      retval = MERROR_ALLOC;
      goto cleanup;
   }
 
   maug_mlock( g_retroflat_state_h, g_retroflat_state );
   if( (MAUG_MHANDLE)NULL == g_retroflat_state ) {
      retroflat_message( RETROFLAT_MSG_FLAG_ERROR,
         "Error", "Could not lock global state!" );
      retval = MERROR_ALLOC;
      goto cleanup;
   }
   maug_mzero( g_retroflat_state, sizeof( struct RETROFLAT_STATE ) );
 
#  ifndef RETROFLAT_NO_CLI
 
   debug_printf( 1, "retroflat: parsing args..." );
 
   /* All platforms: add command-line args based on compile definitons. */
 
#     ifdef RETROSND_ARGS
   retval = maug_add_arg( MAUG_CLI_SIGIL "rsd", MAUG_CLI_SIGIL_SZ + 4,
      "Select MIDI device", 0, (maug_cli_cb)retrosnd_cli_rsd, args );
   maug_cleanup_if_not_ok();
   retval = maug_add_arg( MAUG_CLI_SIGIL "rsl", MAUG_CLI_SIGIL_SZ + 4,
      "List MIDI devices", 0, (maug_cli_cb)retrosnd_cli_rsl, args );
   maug_cleanup_if_not_ok();
#     endif /* RETROSND_ARGS */
 
#     ifdef RETROFLAT_SCREENSAVER
   retval = maug_add_arg( MAUG_CLI_SIGIL "p", MAUG_CLI_SIGIL_SZ + 2,
      "Preview screensaver", 0, (maug_cli_cb)retroflat_cli_p, args );
   maug_cleanup_if_not_ok();
   retval = maug_add_arg( MAUG_CLI_SIGIL "s", MAUG_CLI_SIGIL_SZ + 2,
      "Launch screensaver", 0, (maug_cli_cb)retroflat_cli_s, args );
   maug_cleanup_if_not_ok();
#     endif /* RETROFLAT_SCREENSAVER */
 
#     ifdef RETROFLAT_API_PC_BIOS
   retval = maug_add_arg( MAUG_CLI_SIGIL "rfm", MAUG_CLI_SIGIL_SZ + 4,
      "Set the screen mode.", 0,
      (maug_cli_cb)retroflat_cli_rfm, args );
   maug_cleanup_if_not_ok();
#     elif !defined( RETROFLAT_NO_CLI_SZ )
   retval = maug_add_arg( MAUG_CLI_SIGIL "rfx", MAUG_CLI_SIGIL_SZ + 4,
      "Set the screen X position.", 0,
      (maug_cli_cb)retroflat_cli_rfx, args );
   maug_cleanup_if_not_ok();
   retval = maug_add_arg( MAUG_CLI_SIGIL "rfy", MAUG_CLI_SIGIL_SZ + 4,
      "Set the screen Y position.", 0,
      (maug_cli_cb)retroflat_cli_rfy, args );
   maug_cleanup_if_not_ok();
   retval = maug_add_arg( MAUG_CLI_SIGIL "rfw", MAUG_CLI_SIGIL_SZ + 4,
      "Set the screen width.", 0,
      (maug_cli_cb)retroflat_cli_rfw, args );
   maug_cleanup_if_not_ok();
   retval = maug_add_arg( MAUG_CLI_SIGIL "rfh", MAUG_CLI_SIGIL_SZ + 4,
      "Set the screen height.", 0,
      (maug_cli_cb)retroflat_cli_rfh, args );
   maug_cleanup_if_not_ok();
#     endif /* !RETROFLAT_NO_CLI_SZ */
 
#     ifdef RETROFLAT_VDP
   retval = maug_add_arg( MAUG_CLI_SIGIL "vdp", MAUG_CLI_SIGIL_SZ + 4,
      "Pass a string of args to the VDP.", 0,
      (maug_cli_cb)retroflat_cli_vdp, args );
   maug_cleanup_if_not_ok();
#     endif /* RETROFLAT_VDP */
 
   retval = maug_add_arg( MAUG_CLI_SIGIL "rfu", MAUG_CLI_SIGIL_SZ + 4,
      "Unlock FPS.", 0,
      (maug_cli_cb)retroflat_cli_u, args );
   maug_cleanup_if_not_ok();
 
   /* Parse command line args. */
   retval = maug_parse_args( argc, argv );
   maug_cleanup_if_not_ok();
 
#  else
 
   args->screen_w = RETROFLAT_DEFAULT_SCREEN_W;
   args->screen_h = RETROFLAT_DEFAULT_SCREEN_H;
 
#  endif /* !RETROFLAT_NO_CLI */
 
   if(
      RETROFLAT_FLAGS_UNLOCK_FPS == (RETROFLAT_FLAGS_UNLOCK_FPS & args->flags)
   ) {
      g_retroflat_state->retroflat_flags |= RETROFLAT_FLAGS_UNLOCK_FPS;
   }
 
   debug_printf( 1, "retroflat: setting config..." );
 
   /* Set the assets path. */
   memset( g_retroflat_state->assets_path, '\0', RETROFLAT_ASSETS_PATH_MAX );
   if( NULL != args->assets_path ) {
      maug_strncpy( g_retroflat_state->assets_path,
         args->assets_path, RETROFLAT_ASSETS_PATH_MAX );
   }
 
#  if defined( RETROFLAT_SCREENSAVER )
   if(
      RETROFLAT_FLAGS_SCREENSAVER ==
      (RETROFLAT_FLAGS_SCREENSAVER & args->flags)
   ) {
      g_retroflat_state->retroflat_flags |= RETROFLAT_FLAGS_SCREENSAVER;
   }
#  endif /* RETROFLAT_SCREENSAVER */
 
#  if !defined( RETROFLAT_NO_CLI_SZ )
   /* Setup intended screen size. */
   /* TODO: Handle window resizing someday! */
   g_retroflat_state->screen_v_w = args->screen_w;
   g_retroflat_state->screen_v_h = args->screen_h;
   if(
      RETROFLAT_FLAGS_SCALE2X == (RETROFLAT_FLAGS_SCALE2X & args->flags)
   ) {
      debug_printf( 1, "setting window scale to 2x..." );
      g_retroflat_state->screen_w = args->screen_w * 2;
      g_retroflat_state->screen_h = args->screen_h * 2;
   } else {
      g_retroflat_state->screen_w = args->screen_w;
      g_retroflat_state->screen_h = args->screen_h;
   }
#  endif /* RETROFLAT_NO_CLI_SZ */
 
#  ifdef RETROFLAT_OPENGL
   debug_printf( 1, "setting up texture palette..." );
#     define RETROFLAT_COLOR_TABLE_TEX( idx, name_l, name_u, r, g, b, cgac, cgad ) \
         g_retroflat_state->tex_palette[idx][0] = r; \
         g_retroflat_state->tex_palette[idx][1] = g; \
         g_retroflat_state->tex_palette[idx][2] = b;
   RETROFLAT_COLOR_TABLE( RETROFLAT_COLOR_TABLE_TEX )
#  endif /* RETROFLAT_OPENGL */
 
   /* == Platform-Specific Init == */
 
   retval = retroflat_init_platform( argc, argv, args );
   maug_cleanup_if_not_ok();
 
   /* Setup the refresh grid, if requested, only after screen space has been
    * determined by the platform!
    */
   assert( 0 < retroflat_screen_w() );
   assert( 0 < retroflat_screen_h() );
   if(
      RETROFLAT_FLAGS_VIEWPORT_REFRESH ==
      (RETROFLAT_FLAGS_VIEWPORT_REFRESH & args->flags)
   ) {
      g_retroflat_state->retroflat_flags |= RETROFLAT_FLAGS_VIEWPORT_REFRESH;
 
      g_retroflat_state->viewport.screen_tile_w = 
         /* Allocate 1 extra tile on each side for smooth scrolling. */
         ((retroflat_screen_w() / RETROFLAT_TILE_W) + 2);
      g_retroflat_state->viewport.screen_tile_h = 
         ((retroflat_screen_h() / RETROFLAT_TILE_H) + 2);
 
      debug_printf( 1, "allocating refresh grid (%d tiles...)",
         g_retroflat_state->viewport.screen_tile_w *
         g_retroflat_state->viewport.screen_tile_h );
      g_retroflat_state->viewport.refresh_grid_h = maug_malloc(
         g_retroflat_state->viewport.screen_tile_w *
         g_retroflat_state->viewport.screen_tile_h,
         sizeof( retroflat_tile_t ) );
      maug_cleanup_if_null_alloc( MAUG_MHANDLE,
         g_retroflat_state->viewport.refresh_grid_h );
   }
 
#  if defined( RETROFLAT_SOFT_SHAPES ) || defined( RETROFLAT_SOFT_LINES )
   retval = retrosoft_init();
   maug_cleanup_if_not_ok();
#  endif /* RETROFLAT_SOFT_SHAPES || RETROFLAT_SOFT_LINES */
 
#  if defined( RETROFLAT_OPENGL )
   retval = retrosoft_init();
   maug_cleanup_if_not_ok();
#     ifndef RETROFLAT_NO_STRING
   retval = retroglu_init_glyph_tex();
   maug_cleanup_if_not_ok();
#     endif /* !RETROFLAT_NO_STRING */
#  endif /* RETROFLAT_OPENGL */
 
#  ifdef RETROFLAT_VDP
#     if defined( RETROFLAT_OS_UNIX )
   g_retroflat_state->vdp_exe = dlopen(
      "./" RETROFLAT_VDP_LIB_NAME ".so", RTLD_LAZY );
#     elif defined( RETROFLAT_OS_WIN )
   g_retroflat_state->vdp_exe = LoadLibrary(
      "./" RETROFLAT_VDP_LIB_NAME ".dll" );
#     else
#        error "dlopen undefined!"
#     endif /* RETROFLAT_OS_UNIX */
 
   if( !(g_retroflat_state->vdp_exe) ) {
      error_printf( "not loading VDP" );
      /* Skip creating the buffer or trying to run the init proc. */
      goto skip_vdp;
   }
 
   /* Create intermediary screen buffer. */
   debug_printf( 1, "creating VDP buffer, " SIZE_T_FMT " x " SIZE_T_FMT,
      g_retroflat_state->screen_v_w, g_retroflat_state->screen_v_h );
   g_retroflat_state->vdp_buffer =
      calloc( 1, sizeof( struct RETROFLAT_BITMAP ) );
   maug_cleanup_if_null_alloc(
      struct RETROFLAT_BITMAP*, g_retroflat_state->vdp_buffer );
   retval = retroflat_create_bitmap(
      g_retroflat_state->screen_v_w, g_retroflat_state->screen_v_h,
      g_retroflat_state->vdp_buffer, RETROFLAT_FLAGS_OPAQUE );
   maug_cleanup_if_not_ok();
 
   debug_printf( 1, "initializing VDP..." );
   retval = retroflat_vdp_call( "retroflat_vdp_init" );
 
skip_vdp:
 
#  endif /* RETROFLAT_VDP */
 
#  if !defined( RETROFLAT_NO_BLANK_INIT ) && !defined( RETROFLAT_OPENGL )
   retroflat_draw_lock( NULL );
   retroflat_rect(
      NULL, RETROFLAT_COLOR_BLACK, 0, 0,
      retroflat_screen_w(), retroflat_screen_h(),
      RETROFLAT_FLAGS_FILL );
   retroflat_draw_release( NULL );
#  endif /* !RETROFLAT_NO_BLANK_INIT */
 
cleanup:
 
   return retval;
}
 
/* === */
 
void retroflat_shutdown( int retval ) {
 
   debug_printf( 1, "retroflat shutdown called..." );
 
   if( (MAUG_MHANDLE)NULL != g_retroflat_state->viewport.refresh_grid_h ) {
      maug_mfree( g_retroflat_state->viewport.refresh_grid_h );
   }
 
#  if defined( RETROFLAT_VDP )
   if( NULL != g_retroflat_state->vdp_exe ) {
      retroflat_vdp_call( "retroflat_vdp_shutdown" );
#     ifdef RETROFLAT_OS_UNIX
      dlclose( g_retroflat_state->vdp_exe );
#     elif defined( RETROFLAT_OS_WIN )
      FreeLibrary( g_retroflat_state->vdp_exe );
#     else
#        error "dlclose undefined!"
#     endif /* RETROFLAT_OS_UNIX || RETROFLAT_OS_WIN */
   }
 
   if( NULL != g_retroflat_state->vdp_buffer ) {
      debug_printf( 1, "destroying VPD buffer..." );
      retroflat_destroy_bitmap( g_retroflat_state->vdp_buffer );
      free( g_retroflat_state->vdp_buffer );
   }
#  endif /* RETROFLAT_VDP */
 
#  if defined( RETROFLAT_SOFT_SHAPES ) || defined( RETROFLAT_SOFT_LINES ) || \
defined( RETROFLAT_OPENGL )
   debug_printf( 1, "calling retrosoft shutdown..." );
   retrosoft_shutdown();
#  endif /* RETROFLAT_SOFT_SHAPES */
 
#  if defined( RETROFLAT_OPENGL ) && !defined( RETROFLAT_NO_STRING )
   debug_printf( 1, "destroying GL glyphs..." );
   retroglu_destroy_glyph_tex();
#  endif /* RETROFLAT_OPENGL */
 
   /* === Platform-Specific Shutdown === */
 
   retroflat_shutdown_platform( retval );
 
   maug_munlock( g_retroflat_state_h, g_retroflat_state );
   maug_mfree( g_retroflat_state );
 
}
 
/* === */
 
#  ifdef RETROFLAT_VDP
 
MERROR_RETVAL retroflat_vdp_call( const char* proc_name ) {
   MERROR_RETVAL retval = MERROR_OK;
   retroflat_vdp_proc_t vdp_proc = (retroflat_vdp_proc_t)NULL;
#     ifdef RETROFLAT_OS_WIN
   char proc_name_ex[256];
#     endif /* RETROFLAT_OS_WIN */
 
   if( NULL == g_retroflat_state->vdp_exe ) {
      goto cleanup;
   }
 
#     ifdef RETROFLAT_OS_UNIX
   vdp_proc = dlsym( g_retroflat_state->vdp_exe, proc_name );
#     elif defined( RETROFLAT_OS_WIN )
   /* Append a _ to the proc_name because Watcom? Windows? */
   maug_snprintf( proc_name_ex, 255, "%s_", proc_name );
   vdp_proc = (retroflat_vdp_proc_t)GetProcAddress(
      g_retroflat_state->vdp_exe, proc_name_ex );
#     else
#        error "dlsym undefined!"
#     endif
   if( (retroflat_vdp_proc_t)NULL == vdp_proc ) {
      goto cleanup;
   }
 
#     ifdef RETROFLAT_OS_WIN
   retroflat_draw_lock( g_retroflat_state->vdp_buffer );
#     endif /* RETROFLAT_OS_WIN */
 
   if(
      /* Don't pxlock before init can set the flag! */
      0 == strcmp( "retroflat_vdp_flip", proc_name ) &&
      RETROFLAT_VDP_FLAG_PXLOCK ==
         (RETROFLAT_VDP_FLAG_PXLOCK & g_retroflat_state->vdp_flags)
   ) {
      retroflat_vdp_lock( &(g_retroflat_state->buffer) );
      retroflat_vdp_lock( g_retroflat_state->vdp_buffer );
   }
 
   retval = vdp_proc( g_retroflat_state );
 
   if(
      0 == strcmp( "retroflat_vdp_flip", proc_name ) &&
      RETROFLAT_VDP_FLAG_PXLOCK ==
         (RETROFLAT_VDP_FLAG_PXLOCK & g_retroflat_state->vdp_flags)
   ) {
      retroflat_vdp_release( &(g_retroflat_state->buffer) );
      retroflat_vdp_release( g_retroflat_state->vdp_buffer );
   }
 
#     ifdef RETROFLAT_OS_WIN
   retroflat_draw_release( g_retroflat_state->vdp_buffer );
#     endif /* RETROFLAT_OS_WIN */
 
cleanup:
   return retval;
}
 
#  endif /* RETROFLAT_VDP */
 
/* === */
 
#if 0
 
void retroflat_cursor( struct RETROFLAT_BITMAP* target, uint8_t flags ) {
#if 0
   char mouse_str[11] = "";
 
   maug_snprintf(
      mouse_str, 10, "%02d, %02d", g_retroflat_state->last_mouse_x, g_retroflat_state->last_mouse_y );
 
   retroflat_string(
      target, RETROFLAT_COLOR_BLACK,
      mouse_str, 10, NULL, 0, 0, 0 );
   retroflat_rect(
      target, RETROFLAT_COLOR_BLACK,
      g_retroflat_state->last_mouse_x - 5, g_retroflat_state->last_mouse_y - 5, 10, 10, 0 );
#endif
}
 
#endif
 
/* === */
 
#ifndef RETROFLAT_NO_STRING
 
#  if defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
 
#     define retroflat_win_create_font( flags, font_str ) \
         CreateFont( 10, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, \
            DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, \
            DEFAULT_QUALITY, DEFAULT_PITCH, \
            (NULL == font_str || '\0' == font_str[0] ? "Arial" : font_str) );
 
#  endif /* RETROFLAT_API_WIN16 || RETROFLAT_API_WIN32 */
 
void retroflat_string_sz(
   struct RETROFLAT_BITMAP* target, const char* str, size_t str_sz,
   const char* font_str, size_t* w_out, size_t* h_out, uint8_t flags
) {
#  if defined( RETROFLAT_OPENGL )
#  elif defined( RETROFLAT_SOFT_SHAPES )
#  elif defined( RETROFLAT_API_ALLEGRO )
   FONT* font_data = NULL;
   int font_loaded = 0;
#  elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
   SIZE sz;
   HFONT font;
   HFONT old_font;
#  endif /* RETROFLAT_API_ALLEGRO || RETROFLAT_API_SDL2 || RETROFLAT_API_WIN16 || RETROFLAT_API_WIN32 */
 
   if( NULL == target ) {
      target = retroflat_screen_buffer();
   }
 
#  if defined( RETROFLAT_OPENGL )
 
   retrosoft_string_sz( target, str, str_sz, font_str, w_out, h_out, flags );
 
#  elif defined( RETROFLAT_SOFT_SHAPES )
 
   retrosoft_string_sz( target, str, str_sz, font_str, w_out, h_out, flags );
 
#  elif defined( RETROFLAT_API_ALLEGRO )
 
   /* == Allegro == */
 
   if( NULL == font_str || '\0' == font_str[0] ) {
      font_data = font;
   } else {
      /* TODO: Cache loaded fonts for later use. */
      font_data = load_font( font_str, NULL, NULL );
   }
   if( NULL == font_data ) {
      retroflat_message( RETROFLAT_MSG_FLAG_ERROR,
         "Error", "Unable to load font: %s", font_str );
      goto cleanup;
   }
 
   *w_out = text_length( font_data, str );
   *h_out = text_height( font_data );
   
cleanup:
 
   if( font_loaded && NULL != font_data ) {
      destroy_font( font_data );
   }
 
#  elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
 
   /* == Win16/Win32 == */
 
   assert( (HBITMAP)NULL != target->b );
   assert( retroflat_bitmap_locked( target ) );
 
   font = retroflat_win_create_font( flags, font_str );
   old_font = SelectObject( target->hdc_b, font );
 
   GetTextExtentPoint( target->hdc_b, str, str_sz, &sz );
   *w_out = sz.cx;
   *h_out = sz.cy;
 
/* cleanup: */
 
   SelectObject( target->hdc_b, old_font );
 
#  else
#     pragma message( "warning: string sz not implemented" )
#  endif /* RETROFLAT_API_ALLEGRO || RETROFLAT_API_SDL2 || RETROFLAT_API_WIN16 || RETROFLAT_API_WIN32 */
}
 
/* === */
 
void retroflat_string(
   struct RETROFLAT_BITMAP* target, const RETROFLAT_COLOR color,
   const char* str, int str_sz, const char* font_str, int16_t x_orig, int16_t y_orig,
   uint8_t flags
) {
#  if defined( RETROFLAT_OPENGL )
   float aspect_ratio = 0,
      screen_x = 0,
      screen_y = 0;
#  elif defined( RETROFLAT_SOFT_SHAPES )
#  elif defined( RETROFLAT_API_ALLEGRO )
   FONT* font_data = NULL;
   int font_loaded = 0;
#  elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
   RECT rect;
   SIZE sz;
   HFONT font;
   HFONT old_font;
#  endif /* RETROFLAT_API_ALLEGRO || RETROFLAT_API_SDL2 || RETROFLAT_API_WIN16 || RETROFLAT_API_WIN32 */
 
   if( RETROFLAT_COLOR_NULL == color ) {
      return;
   }
 
#  if !defined( RETROFLAT_OPENGL )
   if( NULL == target ) {
      target = retroflat_screen_buffer();
   }
#  endif /* !RETROFLAT_OPENGL */
 
   if( 0 == str_sz ) {
      str_sz = maug_strlen( str );
   }
 
#  if defined( RETROFLAT_OPENGL )
 
   if( NULL == target || retroflat_screen_buffer() == target ) {
      /* Push new overlay projection parms before we create a new overlay. */
      retroglu_push_overlay( x_orig, y_orig, screen_x, screen_y, aspect_ratio );
 
      retroglu_string(
         screen_x, screen_y, 0, 
         g_retroflat_state->palette[color], str, str_sz, font_str, flags );
 
      retroglu_pop_overlay();
   } else {
      /* Assume drawing surface is already configured inside a push_overlay()
       * call and draw to its texture. */
      retrosoft_string(
         target, color, str, str_sz, font_str, x_orig, y_orig, flags );
   }
 
#  elif defined( RETROFLAT_SOFT_SHAPES )
 
   retrosoft_string(
      target, color, str, str_sz, font_str, x_orig, y_orig, flags );
 
#  elif defined( RETROFLAT_API_ALLEGRO )
 
   /* == Allegro == */
 
   if( NULL == font_str || '\0' == font_str[0] ) {
      font_data = font;
   } else {
      /* TODO: Cache loaded fonts for later use. */
      font_data = load_font( font_str, NULL, NULL );
   }
   if( NULL == font_data ) {
      retroflat_message( RETROFLAT_MSG_FLAG_ERROR,
         "Error", "Unable to load font: %s", font_str );
      goto cleanup;
   }
 
   textout_ex( target->b, font_data, str, x_orig, y_orig, color, -1 );
 
cleanup:
   if( font_loaded && NULL != font_data ) {
      destroy_font( font_data );
   }
 
#  elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
 
   /* == Win16/Win32 == */
 
   assert( (HBITMAP)NULL != target->b );
 
   assert( retroflat_bitmap_locked( target ) );
 
   /* DrawText will draw gibberish even if the string is null-terminated! */
   str_sz = maug_strlen( str );
 
   memset( &sz, '\0', sizeof( SIZE ) );
 
   font = retroflat_win_create_font( flags, font_str );
   old_font = SelectObject( target->hdc_b, font );
 
   GetTextExtentPoint( target->hdc_b, str, str_sz, &sz );
   rect.left = x_orig;
   rect.top = y_orig;
   rect.right = (x_orig + sz.cx);
   rect.bottom = (y_orig + sz.cy);
 
   SetTextColor( target->hdc_b, g_retroflat_state->palette[color] );
   SetBkMode( target->hdc_b, TRANSPARENT );
 
   DrawText( target->hdc_b, str, str_sz, &rect, 0 );
 
/* cleanup: */
 
   SelectObject( target->hdc_b, old_font );
 
   SetBkMode( target->hdc_b, OPAQUE );
   SetTextColor( target->hdc_b,
      g_retroflat_state->palette[RETROFLAT_COLOR_BLACK] );
 
#  else
#     pragma message( "warning: string not implemented" )
#  endif /* RETROFLAT_API_ALLEGRO || RETROFLAT_API_SDL2 || RETROFLAT_API_WIN16 || RETROFLAT_API_WIN32 */
}
 
#endif /* !RETROFLAT_NO_STRING */
 
/* === */
 
void retroflat_set_proc_resize(
   retroflat_proc_resize_t on_resize_in, void* data_in
) {
   g_retroflat_state->on_resize = on_resize_in;
   g_retroflat_state->on_resize_data = data_in;
}
 
/* === */
 
uint8_t retroflat_viewport_move_x_generic( int16_t x ) {
   int16_t new_world_x = g_retroflat_state->viewport.world_x + x;
 
   g_retroflat_state->viewport.screen_x += x;
 
   /* Keep the viewport in the world arena. */
   if(
      0 < new_world_x &&
      g_retroflat_state->viewport.world_w > new_world_x + retroflat_screen_w()
   ) {
      g_retroflat_state->viewport.world_x += x;
      return 1;
   }
 
   return 0;
}
 
/* === */
 
uint8_t retroflat_viewport_move_y_generic( int16_t y ) {
   int16_t new_world_y = g_retroflat_state->viewport.world_y + y;
 
   g_retroflat_state->viewport.screen_y += y;
 
   /* Keep the viewport in the world arena. */
   if(
      0 < new_world_y &&
      g_retroflat_state->viewport.world_h > new_world_y + retroflat_screen_h()
   ) {
      g_retroflat_state->viewport.world_y += y;
      return 1;
   }
 
   return 0;
}
 
/* === */
 
uint8_t retroflat_viewport_focus_generic(
   size_t x1, size_t y1, size_t range, size_t speed
) {
   uint8_t moved = 0,
      new_moved = 0;
   int16_t new_pt = 0;
 
#  define _retroflat_viewport_focus_dir( n, xy, wh, gl, pm, dir, range, speed ) \
      new_pt = n - retroflat_viewport_world_ ## xy(); \
      if( new_pt gl (retroflat_screen_ ## wh() >> 1) pm range ) { \
         new_moved = retroflat_viewport_move_ ## xy( \
            gc_retroflat_offsets8_ ## xy[RETROFLAT_DIR8_ ## dir] * speed ); \
         if( !moved && new_moved ) { \
            moved = new_moved; \
         } \
      }
 
   _retroflat_viewport_focus_dir( x1, x, w, <, -, WEST, range, speed );
   _retroflat_viewport_focus_dir( x1, x, w, >, +, EAST, range, speed );
   _retroflat_viewport_focus_dir( y1, y, h, <, -, NORTH, range, speed );
   _retroflat_viewport_focus_dir( y1, y, h, >, +, SOUTH, range, speed );
 
   return moved;
}
 
/* === */
 
#elif !defined( RETROVDP_C ) /* End of RETROFLT_C */
 
extern MAUG_CONST int16_t SEG_MCONST gc_retroflat_offsets8_x[8];
extern MAUG_CONST int16_t SEG_MCONST gc_retroflat_offsets8_y[8];
extern MAUG_CONST int16_t SEG_MCONST gc_retroflat_offsets4_x[4];
extern MAUG_CONST int16_t SEG_MCONST gc_retroflat_offsets4_y[4];
 
#define RETROFLAT_COLOR_TABLE_CONSTS( idx, name_l, name_u, r, g, b, cgac, cgad ) \
   extern MAUG_CONST RETROFLAT_COLOR RETROFLAT_COLOR_ ## name_u;
 
RETROFLAT_COLOR_TABLE( RETROFLAT_COLOR_TABLE_CONSTS )
 
extern MAUG_CONST char* SEG_MCONST gc_retroflat_color_names[];
 
   extern struct RETROFLAT_STATE* g_retroflat_state;
#     if defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
   extern HINSTANCE            g_retroflat_instance;
   extern int                  g_retroflat_cmd_show;
#     endif /* RETROFLAT_API_WIN16 || RETROFLAT_API_WIN32 */
 
#  include <uprintf.h>
 
#  if (defined( RETROFLAT_SOFT_SHAPES ) || defined( RETROFLAT_SOFT_LINES)) \
   && !defined( MAUG_NO_AUTO_C )
#     include <retrofp.h>
#     include <retrosft.h>
#  endif /* RETROFLAT_SOFT_SHAPES || RETROFLAT_SOFT_LINES */
 
#  if defined( RETROFLAT_OPENGL ) && !defined( MAUG_NO_AUTO_C )
#     include <retroglu.h>
#     include <retrofp.h>
#     include <retrosft.h>
#  endif /* RETROFLAT_OPENGL */
 
#endif /* RETROFLT_C */
 
#ifdef RETROFLAT_XPM
#include <retroxpm.h>
#endif /* RETROFLAT_XPM */
 
#ifdef RETROVDP_C
 
/* Declarations for VDP sources. */
 
#endif /* RETROVDP_C */
 
 /* maug_retroflt */
 
#endif /* RETROFLT_H */