retroflt.h

Go to the documentation of this file.

 
#ifndef RETROFLT_H
#define RETROFLT_H
 
#ifdef RETROFLAT_OPENGL
#  define RETROFLAT_BMP_TEX
#endif /* RETROFLAT_OPENGL */
 
typedef int16_t retroflat_tile_t;
 
/* === Generic Includes and Defines === */
 
#ifndef RETROFLAT_BITMAP_TRACE_LVL
#  define RETROFLAT_BITMAP_TRACE_LVL 0
#endif /* !RETROFLAT_BITMAP_TRACE_LVL */
 
#ifndef RETROINPUT_TRACE_LVL
#  define RETROINPUT_TRACE_LVL 0
#endif /* !RETROINPUT_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_LITERAL_PATH   0x02
 
#define RETROFLAT_FLAGS_BITMAP_SILENT   0x04
 
#define RETROFLAT_FLAGS_ALL_CAPS 0x02
 
#define RETROFLAT_FLAGS_SCREEN_BUFFER     0x80
 /* 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_WAIT_FOR_FPS   0x20
 
#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_api */
 
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     0x08
 
#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_DEFAULT_SCREEN_SCALE
#  define RETROFLAT_DEFAULT_SCREEN_SCALE 1
#endif /* !RETROFLAT_DEFAULT_SCREEN_SCALE */
 
#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 */
 
#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 */
 
#ifndef RETROFLAT_BMP_COLORS_SZ_MAX
#  define RETROFLAT_BMP_COLORS_SZ_MAX 256
#endif /* !RETROFLAT_BMP_COLORS_SZ_MAX */
 
#ifndef RETROFLAT_TIMER_CT_MAX
#  define RETROFLAT_TIMER_CT_MAX 10
#endif /* !RETROFLAT_TIMER_CT_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 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 */
 
typedef int8_t retroflat_dir4_t;
 
typedef int8_t retroflat_dir8_t;
 
#define RETROFLAT_DIR4_NONE  (-1)
#define RETROFLAT_DIR4_NORTH  0
#define RETROFLAT_DIR4_EAST   1
#define RETROFLAT_DIR4_SOUTH  2
#define RETROFLAT_DIR4_WEST   3
 
#define RETROFLAT_DIR8_NONE   (-1)
#define RETROFLAT_DIR8_NORTH  0
#define RETROFLAT_DIR8_EAST   2
#define RETROFLAT_DIR8_SOUTH  4
#define RETROFLAT_DIR8_WEST   6
 
#define retroflat_dir4_rotate_cw( dir ) \
   ((dir + 1) % 4)
 
#define retroflat_dir8_reverse( dir ) \
   ((dir + 4) % 8)
 
#define retroflat_dir8_bounce( dir ) \
   ((dir + 2) % 8)
 /* maug_retroflt_dir */
 
typedef int16_t retroflat_pxxy_t;
 
#define PXXY_FMT "%d"
 
#define PXXY_MAX INT16_MAX
 
struct RETROFLAT_ARGS;
 
#ifndef RETRO2D_TRACE_LVL
#  define RETRO2D_TRACE_LVL 0
#endif /* !RETRO2D_TRACE_LVL */
 
#ifndef RETRO2D_DRAW_TRACE_LVL
#  define RETRO2D_DRAW_TRACE_LVL 0
#endif /* !RETRO2D_DRAW_TRACE_LVL */
 
#ifndef RETRO2D_LOCK_TRACE_LVL
#  define RETRO2D_LOCK_TRACE_LVL 0
#endif /* !RETRO2D_LOCK_TRACE_LVL */
 
#ifndef RETROFLAT_NO_SOUND
 
#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 /* !RETROFLAT_NO_SOUND */
 
/* === Platform-specific APIs === */
 
/* The first call to these headers should just establish definitions (macros, defines, prototypes,
 * typedefs, etc). The later call below should then define function bodies.
 */
#ifndef RETROFLAT_NO_SOUND
#  include <retapis.h>
#endif /* !RETROFLAT_NO_SOUND */
#include <retapii.h>
 
/* === End platform-specific APIs === */
 
#  if defined( RETROFLAT_NO_KEYBOARD )
#     define retroflat_case_key( key, pad ) case pad:
#     define retroflat_or_key( input, key, pad ) ((input) == (pad))
#  elif defined( RETROFLAT_NO_PAD )
#     define retroflat_case_key( key, pad ) case key:
#     define retroflat_or_key( input, key, pad ) ((input) == (key))
#  else
#     define retroflat_case_key( key, pad ) case pad: case key:
#     define retroflat_or_key( input, key, pad ) \
         (((input) == (pad)) || ((input) == (key)))
#  endif
 /* maug_retroflt_input */
 
/* === 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 */
 
#if defined( RETROFLAT_BMP_TEX ) || defined( DOCUMENTATION )
 
struct RETROFLAT_3DTEX {
   uint8_t flags;
   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_BMP_TEX */
 
/* TODO: Migrate all platform-specific parts below to retapid.h. */
#include <retapid.h>
 
#ifndef retroflat_system_task
#  define retroflat_system_task()
#endif /* !retroflat_system_task */
 
typedef maug_ms_t retroflat_ms_t;
 
typedef void (*retroflat_timer_cb_t)( retroflat_ms_t time, void* data );
 
#include "retrom2d.h"
 
/* === Structures === */
 
/* TODO: Break the args into API-specific headers. */
 
struct RETROFLAT_ARGS {
   uint8_t flags;
   char* title;
   char* assets_path;
   char* config_path;
   int screen_w;
   int screen_h;
   int screen_x;
   int screen_y;
   int screen_scale;
   int screen_colors;
   int joystick_id;
   struct RETROFLAT_PLATFORM_ARGS platform;
#  ifndef RETROFLAT_NO_SOUND
   struct RETROFLAT_SOUND_ARGS sound;
#  endif /* !RETROFLAT_NO_SOUND */
};
 
struct RETROFLAT_VIEWPORT {
   retroflat_pxxy_t screen_x;
   retroflat_pxxy_t screen_y;
   retroflat_pxxy_t world_x;
   retroflat_pxxy_t world_y;
   retroflat_pxxy_t world_w;
   retroflat_pxxy_t world_h;
   retroflat_pxxy_t screen_w;
   retroflat_pxxy_t screen_h;
   retroflat_pxxy_t screen_w_remainder;
   retroflat_pxxy_t screen_h_remainder;
   int16_t screen_tile_w;
   int16_t screen_tile_h;
   int16_t world_tile_x;
   int16_t world_tile_y;
#ifndef RETROFLAT_NO_VIEWPORT_REFRESH
   MAUG_MHANDLE refresh_grid_h;
   retroflat_tile_t* refresh_grid;
#endif /* !RETROFLAT_NO_VIEWPORT_REFRESH */
};
 
#  define retroflat_screen_colors() (g_retroflat_state->screen_colors)
 
#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_tile_x_generic() \
   (g_retroflat_state->viewport.world_tile_x)
 
#  define retroflat_viewport_world_tile_y_generic() \
   (g_retroflat_state->viewport.world_tile_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_screen_w_generic() \
   (g_retroflat_state->viewport.screen_w)
 
#  define retroflat_viewport_screen_h_generic() \
   (g_retroflat_state->viewport.screen_h)
 
#  define retroflat_viewport_screen_w_remainder_generic() \
   (g_retroflat_state->viewport.screen_w_remainder)
 
#  define retroflat_viewport_screen_h_remainder_generic() \
   (g_retroflat_state->viewport.screen_h_remainder)
 
#  define retroflat_viewport_set_world_generic( w, h ) \
   debug_printf( 1, "setting viewport size to %d x %d...", \
      (int16_t)(w), (int16_t)(h) ); \
   (g_retroflat_state->viewport.world_w) = w; \
   (g_retroflat_state->viewport.world_h) = h;
 
#  define retroflat_viewport_set_world_pos_generic( x, y ) \
   debug_printf( 1, "setting viewport world pos to %d, %d...", x, y ); \
   (g_retroflat_state->viewport.world_x) = x; \
   (g_retroflat_state->viewport.world_y) = y; \
   (g_retroflat_state->viewport.world_tile_x) = (x) >> RETROFLAT_TILE_W_BITS; \
   (g_retroflat_state->viewport.world_tile_y) = (y) >> RETROFLAT_TILE_H_BITS;
 
#  define retroflat_viewport_set_pos_size_generic( x_px, y_px, w_px, h_px ) \
   g_retroflat_state->viewport.screen_x = (x_px); \
   g_retroflat_state->viewport.screen_y = (y_px); \
   g_retroflat_state->viewport.screen_tile_w = \
      ((w_px) / RETROFLAT_TILE_W); \
   g_retroflat_state->viewport.screen_tile_h = \
      ((h_px) / RETROFLAT_TILE_H); \
   /* We're not adding the extra room here since this won't be used for
   * indexing or allocation but rather pixel detection.
   */ \
   g_retroflat_state->viewport.screen_w = \
      ((w_px) / RETROFLAT_TILE_W) * RETROFLAT_TILE_W; \
   g_retroflat_state->viewport.screen_h = \
      ((h_px) / RETROFLAT_TILE_H) * RETROFLAT_TILE_H; \
   g_retroflat_state->viewport.screen_w_remainder = \
      (x_px) + (w_px) - g_retroflat_state->viewport.screen_w; \
   g_retroflat_state->viewport.screen_h_remainder = \
      (y_px) + (h_px) - g_retroflat_state->viewport.screen_h;
 
#ifndef RETROFLAT_NO_VIEWPORT_REFRESH
 
#  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 ) + 1) * \
            (g_retroflat_state->viewport.screen_tile_w + 2)) + \
               (_retroflat_viewport_refresh_tile_x( x_px ) + 1)] = 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 ) + 1) * \
            (g_retroflat_state->viewport.screen_tile_w + 2)) + \
               (_retroflat_viewport_refresh_tile_x( x_px ) + 1)])
 
#endif /* !RETROFLAT_NO_VIEWPORT_REFRESH */
 
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(
   retroflat_pxxy_t x1, retroflat_pxxy_t y1,
   retroflat_pxxy_t range, retroflat_pxxy_t speed );
 
#  define retroflat_viewport_screen_x_generic( world_x ) \
   (g_retroflat_state->viewport.screen_x + \
      ((world_x) - retroflat_viewport_world_x()))
 
#  define retroflat_viewport_screen_y_generic( world_y ) \
   (g_retroflat_state->viewport.screen_y + \
      ((world_y) - retroflat_viewport_world_y()))
 
#  define retroflat_viewport_screen_get_x_generic() \
   (g_retroflat_state->viewport.screen_x)
 
#  define retroflat_viewport_screen_get_y_generic() \
   (g_retroflat_state->viewport.screen_y)
 
#endif /* !DOCUMENTATION */
 
#if defined( RETROFLAT_SOFT_VIEWPORT ) || defined( DOCUMENTATION )
 
#  ifndef RETROFLAT_NO_VIEWPORT_REFRESH
      /* These clamp world coordinates to tile borders to allow refresh grid to
       * function properly (smooth-scrolling tiles will always be in motion).
       */
 
#     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_NO_VIEWPORT_REFRESH */
 
#     define retroflat_viewport_world_tile_x() \
         retroflat_viewport_world_tile_x_generic()
#     define retroflat_viewport_world_tile_y() \
         retroflat_viewport_world_tile_y_generic()
 
#  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_screen_w() \
   retroflat_viewport_screen_w_generic()
 
#  define retroflat_viewport_screen_h() \
   retroflat_viewport_screen_h_generic()
 
#  define retroflat_viewport_screen_w_remainder() \
   retroflat_viewport_screen_w_remainder_generic()
 
#  define retroflat_viewport_screen_h_remainder() \
   retroflat_viewport_screen_h_remainder_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_set_pos_size( x_px, y_px, w_px, h_px ) \
   retroflat_viewport_set_pos_size_generic( x_px, y_px, w_px, h_px )
 
#ifndef RETROFLAT_NO_VIEWPORT_REFRESH
 
#  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 )
 
#endif /* !RETROFLAT_NO_VIEWPORT_REFRESH */
 
#  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 )
 
#  define retroflat_viewport_screen_get_x() \
   retroflat_viewport_screen_get_x_generic()
 
#  define retroflat_viewport_screen_get_y() \
   retroflat_viewport_screen_get_y_generic()
 
#  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 */
 
#define retroflat_heartbeat_set( len, max ) \
   g_retroflat_state->heartbeat_max = max; \
   g_retroflat_state->heartbeat_len = len;
 
#define retroflat_heartbeat() (g_retroflat_state->heartbeat_frame)
 
#define retroflat_heartbeat_update() \
   /* Update the heartbeat animation frame. */ \
   if( g_retroflat_state->heartbeat_next <= retroflat_get_ms() ) { \
      g_retroflat_state->heartbeat_frame++; \
      if( \
         g_retroflat_state->heartbeat_frame >= \
            g_retroflat_state->heartbeat_max \
      ) { \
         g_retroflat_state->heartbeat_frame = 0; \
      } \
      g_retroflat_state->heartbeat_next = \
         retroflat_get_ms() + g_retroflat_state->heartbeat_len; \
   }
 
struct RETROFLAT_STATE {
   /* TODO: Set this up in the initialization function! */
   /* TODO: We probably need more of these. */
   size_t                  sz;
   size_t                  offset_pal;
   size_t                  offset_tex_pal;
 
   void*                   loop_data;
   MERROR_RETVAL           retval;
   uint8_t                 retroflat_flags;
   maug_path               config_path;
   maug_path               assets_path;
   maug_path               saves_path;
 
   /* struct RETROFLAT_BITMAP buffer; */
   int screen_scale;
 
#  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;
   size_t               screen_colors;
 
   /* 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_ms_t heartbeat_next;
   uint16_t heartbeat_len;
   uint8_t heartbeat_frame;
   uint8_t heartbeat_max;
 
   retroflat_proc_resize_t on_resize;
   void* on_resize_data;
 
#ifndef RETROFLAT_BMP_TEX
   RETROFLAT_COLOR_DEF     palette[RETROFLAT_COLORS_SZ];
#endif /* !RETROFLAT_BMP_TEX */
 
   retroflat_loop_iter  loop_iter;
   retroflat_loop_iter  frame_iter;
 
   struct RETROFLAT_PLATFORM platform;
 
#  if defined( RETROFLAT_BMP_TEX )
   /* This allows native colors to be used for things like glColor3fv while
    * these colors are used to manipulate textures passed through
    * retroflat_bitmap_*().
    */
   RETROFLAT_TEX_COLOR_DEF tex_palette[RETROFLAT_COLORS_SZ];
#  endif /* RETROFLAT_BMP_TEX */
 
   struct RETROFLAT_INPUT_STATE input;
 
   retroflat_timer_cb_t timers_cb[RETROFLAT_TIMER_CT_MAX];
   retroflat_ms_t timers_at[RETROFLAT_TIMER_CT_MAX];
   void* timers_data[RETROFLAT_TIMER_CT_MAX];
   size_t timers_ct;
 
#  ifndef RETROFLAT_NO_SOUND
   struct RETROFLAT_SOUND_STATE sound;
#  endif /* !RETROFLAT_NO_SOUND */
};
 
/* === 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 */
 
#define retroflat_get_assets_path() (g_retroflat_state->assets_path)
 
MERROR_RETVAL retroflat_build_filename_path(
   const maug_path filename_in, const char* filename_ext,
   char* buffer_out, size_t buffer_out_sz, uint8_t flags );
 
void retroflat_message(
   uint8_t flags, const char* title, const char* format, ... );
 /* maug_retroflt_msg_api */
 
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 */
 
RETROFLAT_IN_KEY retroflat_repeat_input(
   RETROFLAT_IN_KEY key_out, struct RETROFLAT_INPUT* input,
   RETROFLAT_IN_KEY* prev_input, int* prev_delay );
 
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(
   retroflat_pxxy_t w, retroflat_pxxy_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,
   retroflat_pxxy_t s_x, retroflat_pxxy_t s_y,
   retroflat_pxxy_t d_x, retroflat_pxxy_t d_y,
   retroflat_pxxy_t w, retroflat_pxxy_t h,
   int16_t instance );
 
#ifdef RETROFLAT_TRACE_CONSTRAIN
#  define retroflat_constrain_px( x, y, bmp, retact ) \
      if( \
         x >= retroflat_bitmap_w( bmp ) || y >= retroflat_bitmap_h( bmp ) || \
         0 > x || 0 > y \
      ) { \
         error_printf( "attempted draw at %d, %d, out of bounds %d x %d", \
            x, y, retroflat_bitmap_w( bmp ), retroflat_bitmap_h( bmp ) ); \
         retact; \
      }
#else
#  define retroflat_constrain_px( x, y, bmp, retact ) \
      if( \
         x >= retroflat_bitmap_w( bmp ) || y >= retroflat_bitmap_h( bmp ) || \
         0 > x || 0 > y \
      ) { \
         retact; \
      }
#endif /* RETROFLAT_TRACE_CONSTRAIN */
 
MERROR_RETVAL retroflat_trim_px(
   struct RETROFLAT_BITMAP* bitmap,
   int16_t instance,
   retroflat_pxxy_t* s_x, retroflat_pxxy_t* s_y,
   retroflat_pxxy_t* d_x, retroflat_pxxy_t* d_y,
   retroflat_pxxy_t* w, retroflat_pxxy_t* h );
 /* 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,
   retroflat_pxxy_t x, retroflat_pxxy_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_3D */
#else
 
void retroflat_rect(
   struct RETROFLAT_BITMAP* target, const RETROFLAT_COLOR color,
   retroflat_pxxy_t x, retroflat_pxxy_t y,
   retroflat_pxxy_t w, retroflat_pxxy_t h, uint8_t flags );
 
void retroflat_ellipse(
   struct RETROFLAT_BITMAP* target, const RETROFLAT_COLOR color,
   retroflat_pxxy_t x, retroflat_pxxy_t y,
   retroflat_pxxy_t w, retroflat_pxxy_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,
   retroflat_pxxy_t x1, retroflat_pxxy_t y1,
   retroflat_pxxy_t x2, retroflat_pxxy_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,
   retroflat_pxxy_t* w_out, retroflat_pxxy_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,
   retroflat_pxxy_t x_orig, retroflat_pxxy_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();
 
ssize_t retroflat_timer_add(
   retroflat_ms_t time, retroflat_timer_cb_t cb, void* data );
 
void retroflat_timer_handle();
 
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 };
 
#     ifdef RETROFLAT_STATE_ON_STACK
struct RETROFLAT_STATE SEG_MGLOBAL g_retroflat_state_stack;
#     else
MAUG_MHANDLE SEG_MGLOBAL g_retroflat_state_h = (MAUG_MHANDLE)NULL;
#     endif /* RETROFLAT_STATE_ON_STACK */
struct RETROFLAT_STATE* SEG_MGLOBAL g_retroflat_state = NULL;
 
#  define RETROFLAT_COLOR_TABLE_CONSTS( idx, name_l, name_u, r, g, b, cgac, cgad ) \
      MAUG_CONST RETROFLAT_COLOR SEG_MCONST 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 maug_path filename_in, const char* filename_ext,
   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. */
   maug_mzero( buffer_out, 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 if( NULL != filename_ext ) {
      /* 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, filename_ext );
   } else {
      maug_snprintf( buffer_out, buffer_out_sz - 1, "%s%c%s",
         g_retroflat_state->assets_path, RETROFLAT_PATH_SEP,
         filename_in );
   }
 
   return retval;
}
 
/* === */
 
#  if (defined( RETROFLAT_SOFT_SHAPES ) || defined( RETROFLAT_SOFT_LINES ) || \
   defined( RETROFLAT_3D ))
/* RETROSOFT_PRESENT is different from RETROFLAT_SOFT_SHAPES in that it only
 * indicates that the retrosoft library is loaded, not that it is the default
 * for drawing primatives!
 */
#     define RETROSOFT_PRESENT
#  endif
 
#  if defined( RETROFLAT_3D )
#     if !defined( MAUG_NO_AUTO_C )
#        define RETRO3D_C
#        define RETRO3DP_C
#        define RETROFP_C
#     endif /* MAUG_NO_AUTO_C */
#     include <retro3dp.h>
#     include <retro3d.h>
#     include <retro3du.h>
#     include <retapi3.h>
#  endif /* RETROFLAT_3D */
 
#  ifdef RETROSOFT_PRESENT
#     if !defined( MAUG_NO_AUTO_C )
#        define RETROSFT_C
#     endif /* !MAUG_NO_AUTO_C */
#     define RETROSOFT_PRESENT
#     include <retrosft.h>
#  endif /* RETROFLAT_SOFT_SHAPES */
 
#  ifndef RETROFLAT_NO_SOUND
#  include <retapis.h>
#  endif /* !RETROFLAT_NO_SOUND */
 
#  include <retapii.h>
 
#  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 {
      retroflat_system_task();
 
      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;
      }
 
      retroflat_heartbeat_update();
 
      retroflat_timer_handle();
 
      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( RETROINPUT_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
 
#  if !defined( RETROFLAT_NO_SOUND ) && defined( RETROSND_ARGS )
 
static MERROR_RETVAL retrosnd_cli_rsl(
   const char* arg, ssize_t arg_c, struct RETROFLAT_ARGS* args
) {
   if(
      0 <= arg_c &&
      0 == maug_strncmp( MAUG_CLI_SIGIL "rsl", arg, MAUG_CLI_SIGIL_SZ + 4 )
   ) {
      args->sound.flags |= RETROSND_ARGS_FLAG_LIST_DEVS;
   }
   return MERROR_OK;
}
 
# endif /* !RETROFLAT_NO_SOUND && RETROSND_ARGS */
 
#  if !defined( RETROFLAT_API_PC_BIOS ) && !defined( RETROFLAT_NO_CLI_SZ )
 
static MERROR_RETVAL retroflat_cli_rfs(
   const char* arg, ssize_t arg_c, struct RETROFLAT_ARGS* args
) {
   if( 1 < arg_c ) {
      args->screen_scale = atoi( arg );
      debug_printf( 3, "screen scale arg set to: %d", args->screen_scale );
   }
   return MERROR_OK;
}
 
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 == maug_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 == maug_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;
         debug_printf( 1, "setting arg screen_w to default %d:",
            args->screen_w );
      }
   } else if(
      0 == maug_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 );
      debug_printf( 1, "setting arg screen_w to: %d",
         args->screen_w );
   }
   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;
         debug_printf( 1, "setting arg screen_h to default: %d",
            args->screen_h );
      }
   } else if(
      0 == maug_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 );
      debug_printf( 1, "setting arg screen_h to: %d",
         args->screen_h );
   }
   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 == maug_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 == maug_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;
}
 
#  ifndef RETROFLAT_NO_PAD
 
static MERROR_RETVAL retroflat_cli_rfj(
   const char* arg, ssize_t arg_c, struct RETROFLAT_ARGS* args
) {
   if( 0 > arg_c ) {
      args->joystick_id = -1;
      debug_printf( 1, "setting arg joystick_id to default: %d",
         args->joystick_id );
   } else if(
      0 == maug_strncmp( MAUG_CLI_SIGIL "rfj", arg, MAUG_CLI_SIGIL_SZ + 4 )
   ) {
      /* The next arg must be the new var. */
   } else {
      args->joystick_id = atoi( arg );
      debug_printf( 1, "setting arg joystick_id to: %d",
         args->joystick_id );
   }
   return MERROR_OK;
}
 
#  endif /* !RETROFLAT_NO_PAD */
 
#endif /* !RETROFLAT_NO_CLI */
 
/* === */
 
/* Still inside RETROFLT_C! */
 
MERROR_RETVAL retroflat_init(
   int argc, char* argv[], struct RETROFLAT_ARGS* args
) {
 
   /* = Declare Init Vars = */
 
   MERROR_RETVAL 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( 2 <= sizeof( MERROR_RETVAL ) );
   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, "initializing drawing routines..." );
 
   /* Initialize 2D callbacks depending on if we're in 2D or 3D mode.
    * Please see retrom2d.h for more information.
    */
#     if defined( RETROFLAT_BMP_TEX )
   retroflat_2d_px = (retroflat_px_cb)retro3d_texture_px;
   retroflat_2d_line = (retroflat_line_cb)retrosoft_line;
   retroflat_2d_rect = (retroflat_rect_cb)retrosoft_rect;
   retroflat_2d_ellipse = (retroflat_ellipse_cb)retrosoft_ellipse;
   retroflat_2d_blit_bitmap = (retroflat_blit_bitmap_cb)retro3d_texture_blit;
   retroflat_2d_load_bitmap =
      (retroflat_load_bitmap_cb)retro3d_texture_load_bitmap;
   retroflat_2d_create_bitmap =
      (retroflat_create_bitmap_cb)retro3d_texture_create;
#     else
   retroflat_2d_px = (retroflat_px_cb)retroflat_px;
#        ifdef RETROFLAT_SOFT_SHAPES
   /* TODO: Work retrosoft routines to use retroflat_blit_t */
   retroflat_2d_line = (retroflat_line_cb)retrosoft_line;
   retroflat_2d_rect = (retroflat_rect_cb)retrosoft_rect;
   retroflat_2d_ellipse = (retroflat_ellipse_cb)retrosoft_ellipse;
#        else
   retroflat_2d_line = (retroflat_line_cb)retroflat_line;
   retroflat_2d_rect = (retroflat_rect_cb)retroflat_rect;
   retroflat_2d_ellipse = (retroflat_ellipse_cb)retroflat_ellipse;
#        endif /* RETROFLAT_SOFT_SHAPES */
   retroflat_2d_blit_bitmap = (retroflat_blit_bitmap_cb)retroflat_blit_bitmap;
   retroflat_2d_load_bitmap = (retroflat_load_bitmap_cb)retroflat_load_bitmap;
   retroflat_2d_create_bitmap =
      (retroflat_create_bitmap_cb)retroflat_create_bitmap;
#     endif /* RETROFLAT_BMP_TEX */
 
   debug_printf( 1, "retroflat: MFIX_PRECISION: %f", MFIX_PRECISION );
 
   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 ) );
 
   debug_printf( 1, "initializing global state..." );
 
#     ifdef RETROFLAT_STATE_ON_STACK
   g_retroflat_state = &g_retroflat_state_stack;
#     else
   maug_malloc_test( g_retroflat_state_h, 1, sizeof( struct RETROFLAT_STATE ) );
 
   maug_mlock( g_retroflat_state_h, g_retroflat_state );
   if( NULL == g_retroflat_state ) {
      retroflat_message( RETROFLAT_MSG_FLAG_ERROR,
         "Error", "Could not lock global state!" );
      retval = MERROR_ALLOC;
      goto cleanup;
   }
#     endif /* RETROFLAT_STATE_ON_STACK */
 
   maug_mzero( g_retroflat_state, sizeof( struct RETROFLAT_STATE ) );
 
   retroflat_heartbeat_set( 1000, 2 );
 
   debug_printf( 1, "initializing platform filesystem..." );
   retval = mfile_plt_init();
   maug_cleanup_if_not_ok();
 
#  ifndef RETROFLAT_NO_CLI
 
   debug_printf( 1, "retroflat: parsing args..." );
 
   /* All platforms: add command-line args based on compile definitons. */
 
   retval = maug_add_arg(
      MAUG_CLI_SIGIL "h", MAUG_CLI_SIGIL_SZ + 2, "Display command-line help",
      26, maug_cli_h, NULL );
 
#  if !defined( RETROFLAT_NO_SOUND ) && defined( 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 /* !RETROFLAT_NO_SOUND && 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 "rfs", MAUG_CLI_SIGIL_SZ + 4,
      "Set screen scale factor.", 0,
      (maug_cli_cb)retroflat_cli_rfs, args );
   maug_cleanup_if_not_ok();
   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();
 
#     ifndef RETROFLAT_NO_PAD
   retval = maug_add_arg( MAUG_CLI_SIGIL "rfj", MAUG_CLI_SIGIL_SZ + 4,
      "Specify joystick ID to use.", 0,
      (maug_cli_cb)retroflat_cli_rfj, args );
   maug_cleanup_if_not_ok();
#     endif /* !RETROFLAT_NO_PAD */
 
   /* Parse command line args. */
   retval = maug_parse_args( argc, argv );
   maug_cleanup_if_not_ok();
 
#  endif /* !RETROFLAT_NO_CLI */
 
   if( 0 == args->screen_w ) {
      args->screen_w = RETROFLAT_DEFAULT_SCREEN_W;
      debug_printf( 1, "setting arg screen_w to default: %d",
         args->screen_w );
   }
   if( 0 == args->screen_h ) {
      args->screen_h = RETROFLAT_DEFAULT_SCREEN_H;
      debug_printf( 1, "setting arg screen_h to default: %d",
         args->screen_h );
   }
   if( 0 == args->screen_scale ) {
      args->screen_scale = RETROFLAT_DEFAULT_SCREEN_SCALE;
      debug_printf( 1, "setting arg screen_scale to default: %d",
         args->screen_scale );
   }
   if( 0 == args->screen_colors ) {
      args->screen_colors = 16;
      debug_printf( 1, "setting arg screen_colors to default: %d",
         args->screen_colors );
   }
   args->joystick_id = -1;
 
   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. */
   if( NULL != args->assets_path ) {
      maug_mzero( g_retroflat_state->assets_path, MAUG_PATH_SZ_MAX );
      maug_strncpy( g_retroflat_state->assets_path,
         args->assets_path, MAUG_PATH_SZ_MAX - 1 );
   }
 
#  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. */
   g_retroflat_state->screen_scale = args->screen_scale;
   g_retroflat_state->screen_v_w = args->screen_w;
   g_retroflat_state->screen_v_h = args->screen_h;
   g_retroflat_state->screen_w = args->screen_w *
      g_retroflat_state->screen_scale;
   g_retroflat_state->screen_h = args->screen_h *
      g_retroflat_state->screen_scale;
   g_retroflat_state->screen_colors = args->screen_colors;
 
   debug_printf( 3, "attempting to initialize platform with: " 
      SIZE_T_FMT "x" SIZE_T_FMT " pixels (scaled to " SIZE_T_FMT "x" SIZE_T_FMT 
      ") and " SIZE_T_FMT " colors",
      g_retroflat_state->screen_v_w, g_retroflat_state->screen_v_h,
      g_retroflat_state->screen_w, g_retroflat_state->screen_h,
      g_retroflat_state->screen_colors );
#  endif /* !RETROFLAT_NO_CLI_SZ */
 
   /* == Platform-Specific Init == */
 
   retval = retroflat_init_platform( argc, argv, args );
   maug_cleanup_if_not_ok();
 
#  if defined( RETROFLAT_NO_CLI_SZ )
   g_retroflat_state->screen_scale = args->screen_scale;
   g_retroflat_state->screen_v_w = args->screen_w;
   g_retroflat_state->screen_v_h = args->screen_h;
   g_retroflat_state->screen_w = args->screen_w *
      g_retroflat_state->screen_scale;
   g_retroflat_state->screen_h = args->screen_h *
      g_retroflat_state->screen_scale;
   g_retroflat_state->screen_colors = args->screen_colors;
 
   debug_printf( 3, "initialized platform with: " 
      SIZE_T_FMT "x" SIZE_T_FMT " pixels (scaled to " SIZE_T_FMT "x" SIZE_T_FMT 
      ") and " SIZE_T_FMT " colors",
      g_retroflat_state->screen_v_w, g_retroflat_state->screen_v_h,
      g_retroflat_state->screen_w, g_retroflat_state->screen_h,
      g_retroflat_state->screen_colors );
#  endif /* RETROFLAT_NO_CLI_SZ */
 
   retval = retroflat_init_input( args );
   maug_cleanup_if_not_ok();
 
   debug_printf( 3, "screen initialized with: " SIZE_T_FMT "x" SIZE_T_FMT
      " pixels (scaled to " SIZE_T_FMT "x" SIZE_T_FMT 
      ") with " SIZE_T_FMT " colors",
      g_retroflat_state->screen_v_w, g_retroflat_state->screen_v_h,
      g_retroflat_state->screen_w, g_retroflat_state->screen_h,
      retroflat_screen_colors() );
 
   /* Setup the refresh grid, if requested, only after screen space has been
    * determined by the platform!
    */
   maug_cleanup_if_eq(
      (size_t)0, retroflat_screen_w(), SIZE_T_FMT, MERROR_GUI );
   maug_cleanup_if_eq(
      (size_t)0, retroflat_screen_h(), SIZE_T_FMT, MERROR_GUI );
   maug_cleanup_if_eq(
      (size_t)0, retroflat_screen_colors(), SIZE_T_FMT, MERROR_GUI );
 
   /* This is intended as a default and can be modified by calling this macro
    * again later.
    */
   retroflat_viewport_set_pos_size(
      0, 0, retroflat_screen_w(), retroflat_screen_h() );
 
#ifndef RETROFLAT_NO_VIEWPORT_REFRESH
   debug_printf( 1, "allocating refresh grid (%d tiles...)",
      g_retroflat_state->viewport.screen_tile_w *
      g_retroflat_state->viewport.screen_tile_h );
   maug_malloc_test(
      g_retroflat_state->viewport.refresh_grid_h,
      (g_retroflat_state->viewport.screen_tile_w + 2) *
      (g_retroflat_state->viewport.screen_tile_h + 2),
      sizeof( retroflat_tile_t ) );
#endif /* !RETROFLAT_NO_VIEWPORT_REFRESH */
 
#  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 */
 
#  ifdef RETROFLAT_3D
   retro3d_platform_init();
#  endif /* RETROFLAT_3D */
 
#  if !defined( RETROFLAT_NO_BLANK_INIT ) && !defined( RETROFLAT_3D )
   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..." );
 
#ifndef RETROFLAT_NO_VIEWPORT_REFRESH
   if(
      NULL != g_retroflat_state &&
      (MAUG_MHANDLE)NULL != g_retroflat_state->viewport.refresh_grid_h
   ) {
      maug_mfree( g_retroflat_state->viewport.refresh_grid_h );
   }
#endif /* !RETROFLAT_NO_VIEWPORT_REFRESH */
 
#  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 */
 
   /* === Platform-Specific Shutdown === */
 
#ifdef RETROFLAT_3D
   retro3d_platform_shutdown();
#endif /* RETROFLAT_3D */
 
   retroflat_shutdown_platform( retval );
 
#ifndef RETROFLAT_STATE_ON_STACK
   maug_munlock( g_retroflat_state_h, g_retroflat_state );
   maug_mfree( g_retroflat_state_h );
#endif /* !RETROFLAT_STATE_ON_STACK */
 
}
 
/* === */
 
RETROFLAT_IN_KEY retroflat_repeat_input(
   RETROFLAT_IN_KEY key_out, struct RETROFLAT_INPUT* input,
   RETROFLAT_IN_KEY* prev_input, int* prev_delay
) {
 
   /* Add a slight debounce for gamepad button repeat. */
   if( 0 < (*prev_delay) ) {
      debug_printf(
         RETROINPUT_TRACE_LVL,
         "repeat delay: %d", (*prev_delay) );
      (*prev_delay)--;
   }
 
   /* If nothing else happened and repeat is enabled and a joypad button is
    * down, then emulate repeat for it.
    */
   if(
      0 == key_out &&
      RETROFLAT_FLAGS_KEY_REPEAT ==
      (RETROFLAT_FLAGS_KEY_REPEAT & g_retroflat_state->retroflat_flags) &&
      /* There is an input to repeat. */
      0 != *prev_input &&
      /* Delay countdown reached. */
      0 == *prev_delay
   ) {
      key_out = *prev_input;
      *prev_delay = 1;
      debug_printf( RETROINPUT_TRACE_LVL, "repeat: %d", key_out );
   }
 
   return key_out;
}
 
/* === */
 
ssize_t retroflat_timer_add(
   retroflat_ms_t at_time, retroflat_timer_cb_t cb, void* data
) {
   if( retroflat_get_ms() > at_time ) {
      error_printf( "timer time is in the past!" );
      return merror_retval_to_sz( MERROR_EXEC );
   }
 
   if( g_retroflat_state->timers_ct + 1 < RETROFLAT_TIMER_CT_MAX ) {
      g_retroflat_state->timers_cb[g_retroflat_state->timers_ct] = cb;
      g_retroflat_state->timers_at[g_retroflat_state->timers_ct] = at_time;
      g_retroflat_state->timers_ct++;
      return g_retroflat_state->timers_ct - 1;
   }
 
   error_printf( "too many timers!" );
   return merror_retval_to_sz( MERROR_OVERFLOW );
}
 
/* === */
 
void retroflat_timer_handle() {
   size_t i = 0;
   retroflat_ms_t time_now = 0;
 
   time_now = retroflat_get_ms();
 
   for( i = 0 ; g_retroflat_state->timers_ct > i ; i++ ) {
      if( g_retroflat_state->timers_at[i] <= time_now ) {
         g_retroflat_state->timers_cb[i](
            time_now, g_retroflat_state->timers_data[i] );
         memmove(
            &(g_retroflat_state->timers_cb[i]),
            &(g_retroflat_state->timers_cb[i + 1]),
            sizeof( retroflat_timer_cb_t ) *
               ((g_retroflat_state->timers_ct - i) - 1)
         );
         memmove(
            &(g_retroflat_state->timers_at[i]),
            &(g_retroflat_state->timers_at[i + 1]),
            sizeof( retroflat_ms_t ) * ((g_retroflat_state->timers_ct - i) - 1)
         );
         memmove(
            &(g_retroflat_state->timers_data[i]),
            &(g_retroflat_state->timers_data[i + 1]),
            sizeof( void* ) * ((g_retroflat_state->timers_ct - i) - 1)
         );
         g_retroflat_state->timers_ct--;
         i--;
      }
   }
}
 
/* === */
 
MERROR_RETVAL retroflat_trim_px(
   struct RETROFLAT_BITMAP* bitmap,
   int16_t instance,
   retroflat_pxxy_t* s_x, retroflat_pxxy_t* s_y,
   retroflat_pxxy_t* d_x, retroflat_pxxy_t* d_y,
   retroflat_pxxy_t* w, retroflat_pxxy_t* h
) {
   retroflat_pxxy_t trim_bottom = *d_y + *h;
   retroflat_pxxy_t trim_right = *d_x + *w;
   retroflat_pxxy_t viewport_bottom = 0;
   retroflat_pxxy_t viewport_right = 0;
   retroflat_pxxy_t viewport_left = 0;
   retroflat_pxxy_t viewport_top = 0;
 
   if( 
      /* On the screen, constrain to the edges of the viewport. */
      retroflat_screen_buffer() == bitmap &&
      /* Probably blitting a window or other element that can go anywhere. */
      RETROFLAT_INSTANCE_NULL != instance
   ) {
      viewport_left = retroflat_viewport_screen_get_x();
      viewport_top = retroflat_viewport_screen_get_y();
      viewport_bottom =
         (retroflat_viewport_screen_get_y() + retroflat_viewport_screen_h());
      viewport_right =
         (retroflat_viewport_screen_get_x() + retroflat_viewport_screen_w());
 
   } else {
      /* Constrain to the edges of the arbitrary bitmap. */
      viewport_bottom = retroflat_bitmap_h( bitmap );
      viewport_right = retroflat_bitmap_w( bitmap );
   }
 
   if( viewport_bottom < *d_y || trim_bottom < viewport_top ) {
#ifdef RETROFLAT_TRACE_CONSTRAIN
      error_printf( "attempted to blit bitmap way out of bounds at %d, %d!",
         *d_x, *d_y );
#endif /* RETROFLAT_TRACE_CONSTRAIN */
      return MERROR_GUI;
 
   } else if( viewport_bottom <= trim_bottom ) {
#ifdef RETROFLAT_TRACE_CONSTRAIN
      error_printf(
         "trimming " SIZE_T_FMT " pixels to get " SIZE_T_FMT " under "
            SIZE_T_FMT,
         trim_bottom - viewport_bottom, trim_bottom, viewport_bottom );
#endif /* RETROFLAT_TRACE_CONSTRAIN */
      *h -= (trim_bottom - viewport_bottom);
 
   } else if( viewport_top > *d_y ) {
#ifdef RETROFLAT_TRACE_CONSTRAIN
      error_printf(
         "trimming " SIZE_T_FMT " pixels to get " SIZE_T_FMT " under "
            SIZE_T_FMT,
         trim_bottom - viewport_bottom, trim_bottom, viewport_bottom );
#endif /* RETROFLAT_TRACE_CONSTRAIN */
      *h -= (viewport_top - *d_y);
      if( NULL != s_y ) {
         *s_y += (viewport_top - *d_y);
      }
      *d_y += (viewport_top - *d_y);
      assert( viewport_top == *d_y );
   }
 
   if( viewport_right < *d_x || trim_right < viewport_left ) {
#ifdef RETROFLAT_TRACE_CONSTRAIN
      error_printf( "attempted to blit bitmap way out of bounds at %d, %d!",
         *d_x, *d_y );
#endif /* RETROFLAT_TRACE_CONSTRAIN */
      return MERROR_GUI;
 
   } else if( viewport_right <= trim_right ) {
#ifdef RETROFLAT_TRACE_CONSTRAIN
      error_printf(
         "trimming " SIZE_T_FMT " pixels to get " SIZE_T_FMT " under "
            SIZE_T_FMT,
         trim_right - viewport_right, trim_right, viewport_right );
#endif /* RETROFLAT_TRACE_CONSTRAIN */
      *w -= (trim_right - viewport_right);
 
   } else if( viewport_left > *d_x ) {
#ifdef RETROFLAT_TRACE_CONSTRAIN
      error_printf(
         "trimming " SIZE_T_FMT " pixels to get " SIZE_T_FMT " under "
            SIZE_T_FMT,
         trim_bottom - viewport_bottom, trim_bottom, viewport_bottom );
#endif /* RETROFLAT_TRACE_CONSTRAIN */
      *w -= (viewport_left - *d_x);
      if( NULL != s_x ) {
         *s_x += (viewport_left - *d_x);
      }
      *d_x += (viewport_left - *d_x);
      assert( viewport_left == *d_x );
   }
 
   if( 0 == w && 0 == h ) {
      return MERROR_GUI;
   }
 
   return MERROR_OK;
}
 
/* === */
 
#  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->platform.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->platform.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
 
/* === */
 
void maug_critical_error( const char* msg ) {
   retroflat_message( RETROFLAT_MSG_FLAG_ERROR, "Error", msg );
}
 
/* === */
 
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;
 
   /* Keep the viewport in the world arena. */
   if(
      0 <= new_world_x &&
      g_retroflat_state->viewport.world_w >= new_world_x +
         g_retroflat_state->viewport.screen_w
   ) {
      g_retroflat_state->viewport.world_x += x;
      g_retroflat_state->viewport.world_tile_x += x >> RETROFLAT_TILE_W_BITS;
      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;
 
   /* Keep the viewport in the world arena. */
   if(
      0 <= new_world_y &&
      g_retroflat_state->viewport.world_h >= new_world_y +
         g_retroflat_state->viewport.screen_h
   ) {
      g_retroflat_state->viewport.world_y += y;
      g_retroflat_state->viewport.world_tile_y += y >> RETROFLAT_TILE_H_BITS;
      return 1;
   }
 
   return 0;
}
 
/* === */
 
uint8_t retroflat_viewport_focus_generic(
   retroflat_pxxy_t x1, retroflat_pxxy_t y1,
   retroflat_pxxy_t range, retroflat_pxxy_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;
}
 
/* === */
 
#ifdef RETROFLAT_LOAD_BITMAP_GENERIC
 
/* This is a generic function that uses the callback
 * retroflat_load_bitmap_px_cb(), which should be defined by the
 * platform-specific API to draw the loaded bitmap onto a native canvas.
 */
 
MERROR_RETVAL retroflat_load_bitmap(
   const char* filename, struct RETROFLAT_BITMAP* bmp_out, uint8_t flags
) {
   maug_path filename_path;
   MERROR_RETVAL retval = MERROR_OK;
   mfile_t bmp_file;
   struct MFMT_STRUCT_BMPFILE header_bmp;
   uint8_t bmp_flags = 0;
 
   assert( NULL != bmp_out );
   maug_mzero( bmp_out, sizeof( struct RETROFLAT_BITMAP ) );
   retval = retroflat_build_filename_path(
      filename, RETROFLAT_BITMAP_EXT, filename_path,
      MAUG_PATH_SZ_MAX, flags );
   maug_cleanup_if_not_ok();
   debug_printf( 1, "retroflat: loading bitmap: %s", filename_path );
 
   bmp_out->flags = flags;
 
   /* Open the bitmap file. */
   retval = mfile_open_read( filename_path, &bmp_file );
   maug_cleanup_if_not_ok();
 
   /* mfmt file detection system. */
   maug_mzero( &header_bmp, sizeof( struct MFMT_STRUCT_BMPFILE ) );
   header_bmp.magic[0] = 'B';
   header_bmp.magic[1] = 'M';
   header_bmp.info.sz = 40;
 
   retval = mfmt_read_bmp_header(
      (struct MFMT_STRUCT*)&header_bmp,
      &bmp_file, 0, mfile_get_sz( &bmp_file ), &bmp_flags );
   maug_cleanup_if_not_ok();
 
   retval = retroflat_create_bitmap(
      header_bmp.info.width, header_bmp.info.height, bmp_out, flags );
   maug_cleanup_if_not_ok();
 
   retroflat_draw_lock( bmp_out );
 
   retval = mfmt_read_bmp_px_cb(
      (struct MFMT_STRUCT*)&header_bmp,
      &bmp_file,
      header_bmp.px_offset,
      mfile_get_sz( &bmp_file ) - header_bmp.px_offset,
      bmp_flags,
      retroflat_load_bitmap_px_cb,
      bmp_out );
   maug_cleanup_if_not_ok();
 
   retroflat_draw_release( bmp_out );
 
cleanup:
 
   mfile_close( &bmp_file );
 
   return retval;
}
 
#endif /* RETROFLAT_LOAD_BITMAP_GENERIC */
 
#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 SEG_MCONST 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* SEG_MGLOBAL g_retroflat_state;
 
#  if (defined( RETROFLAT_SOFT_SHAPES ) || defined( RETROFLAT_SOFT_LINES ) || \
   defined( RETROFLAT_3D ))
#     define RETROSOFT_PRESENT
#  endif
 
#  ifdef RETROFLAT_3D
#     include <retro3dp.h>
#     include <retro3d.h>
#     include <retro3du.h>
#  endif /* RETROFLAT_3D */
 
#  ifdef RETROSOFT_PRESENT
#     include <retrosft.h>
#  endif /* RETROFLAT_SOFT_SHAPES */
 
/* Second retapis.h include for function bodies not needed. */
 
/* Second retapii.h include for function bodies not needed. */
 
#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 */