+
+
+
+
+
+
+
+
+
+
+
+
254#ifdef RETROFLAT_API_WINCE
+
+
256# define RETROFLAT_API_WIN32
+
+
+
264#define RETROFLAT_COLOR_TABLE( f ) \
+
265 f( 0, black, BLACK, 0, 0, 0 ) \
+
266 f( 1, darkblue, DARKBLUE, 0, 0, 170 ) \
+
267 f( 2, darkgreen, DARKGREEN, 0, 170, 0 ) \
+
268 f( 3, teal, TEAL, 0, 170, 170 ) \
+
269 f( 4, darkred, DARKRED, 170, 0, 0 ) \
+
270 f( 5, violet, VIOLET, 170, 0, 170 ) \
+
271 f( 6, brown, BROWN, 170, 85, 0 ) \
+
272 f( 7, gray, GRAY, 170, 170, 170 ) \
+
273 f( 8, darkgray, DARKGRAY, 85, 85, 85 ) \
+
274 f( 9, blue, BLUE, 85, 85, 255 ) \
+
275 f( 10, green, GREEN, 85, 255, 85 ) \
+
276 f( 11, cyan, CYAN, 85, 255, 255 ) \
+
277 f( 12, red, RED, 255, 85, 85 ) \
+
278 f( 13, magenta, MAGENTA, 255, 85, 255 ) \
+
279 f( 14, yellow, YELLOW, 255, 255, 85 ) \
+
280 f( 15, white, WHITE, 255, 255, 255 )
+
+
282typedef int8_t RETROFLAT_COLOR;
+
+
284# define RETROFLAT_COLOR_NULL (-1)
+
+
286#ifndef RETROFLAT_COLORS_SZ
+
287# define RETROFLAT_COLORS_SZ 16
+
+
+
+
293#if defined( RETROFLAT_OS_UNIX ) || defined( RETROFLAT_OS_WIN )
+
294#define RETROFLAT_MOUSE
+
+
+
304#define RETROFLAT_OK 0x00
+
305#define RETROFLAT_ERROR_ENGINE 0x01
+
306#define RETROFLAT_ERROR_GRAPHICS 0x02
+
307#define RETROFLAT_ERROR_MOUSE 0x04
+
+
313#define RETROFLAT_ERROR_BITMAP 0x08
+
314#define RETROFLAT_ERROR_TIMER 0x0f
+
+
+
318#define bmp_read_uint32( b ) (*((uint32_t*)(b)))
+
+
334#define RETROFLAT_FLAGS_FILL 0x01
+
+
340#define RETROFLAT_FLAGS_OPAQUE 0x01
+
+
348#define RETROFLAT_FLAGS_SCREEN_BUFFER 0x80
+
+
+
363#define RETROFLAT_FLAGS_RUNNING 0x01
+
+
369#define RETROFLAT_FLAGS_UNLOCK_FPS 0x02
+
+
375#define RETROFLAT_FLAGS_KEY_REPEAT 0x04
+
+
381#define RETROFLAT_FLAGS_SCREENSAVER 0x08
+
+
+
395#define RETROFLAT_BUFFER_INT 0x00
+
+
397#define RETROFLAT_BUFFER_STRING 0x01
+
+
399#define RETROFLAT_BUFFER_FLOAT 0x02
+
+
401#define RETROFLAT_BUFFER_BOOL 0x04
+
+
+
419#define RETROFLAT_CONFIG_FLAG_W 0x01
+
+
424#define RETROFLAT_CONFIG_FLAG_BIN 0x02
+
+
+
+
435#define RETROFLAT_MSG_FLAG_TYPE_MASK 0x07
+
+
437#define RETROFLAT_MSG_FLAG_ERROR 0x01
+
+
439#define RETROFLAT_MSG_FLAG_INFO 0x02
+
+
441#define RETROFLAT_MSG_FLAG_WARNING 0x04
+
+
+
+
+
466#define RETROFLAT_VDP_FLAG_PXLOCK 0x01
+
+
+
+
+
512#define RETROFLAT_FLAGS_LOCK 0x01
+
+
514#define RETROFLAT_FLAGS_SCREEN_LOCK 0x02
+
+
520#ifndef RETROFLAT_BITMAP_EXT
+
521# define RETROFLAT_BITMAP_EXT "bmp"
+
+
+
524#ifndef RETROFLAT_OPENGL_BPP
+
525# define RETROFLAT_OPENGL_BPP 32
+
+
+
+
529#ifndef RETROFLAT_TXP_R
+
535# define RETROFLAT_TXP_R 0x00
+
+
+
538#ifndef RETROFLAT_TXP_G
+
544# define RETROFLAT_TXP_G 0x00
+
+
+
547#ifndef RETROFLAT_TXP_B
+
553# define RETROFLAT_TXP_B 0x00
+
+
+
+
558#ifndef RETROFLAT_GL_Z
+
559# define RETROFLAT_GL_Z -0.001
+
+
+
562#define retroflat_on_resize( w, h ) \
+
563 g_retroflat_state->screen_w = w; \
+
564 g_retroflat_state->screen_h = h;
+
+
571#ifndef RETROFLAT_LINE_THICKNESS
+
576# define RETROFLAT_LINE_THICKNESS 1
+
+
+
579#define RETROFLAT_PI 3.14159
+
+
+
+
593# define RETROFLAT_FPS 30
+
+
+
596#define retroflat_fps_next() (1000 / RETROFLAT_FPS)
+
+
598#ifndef RETROFLAT_WINDOW_CLASS
+
603# define RETROFLAT_WINDOW_CLASS "RetroFlatWindowClass"
+
+
+
606#ifndef RETROFLAT_WIN_GFX_TIMER_ID
+
611# define RETROFLAT_WIN_GFX_TIMER_ID 6001
+
+
+
614#ifndef RETROFLAT_MSG_MAX
+
619# define RETROFLAT_MSG_MAX 4096
+
+
+
622#ifndef RETROFLAT_PATH_MAX
+
624# define RETROFLAT_PATH_MAX 256
+
+
+
627#ifndef RETROFLAT_TITLE_MAX
+
628# define RETROFLAT_TITLE_MAX 255
+
+
+
631#ifndef RETROFLAT_VDP_ARGS_SZ_MAX
+
635# define RETROFLAT_VDP_ARGS_SZ_MAX 255
+
+
+
638#if defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
639# if !defined( RETROFLAT_WIN_STYLE )
+
640# if defined( RETROFLAT_API_WINCE )
+
641# define RETROFLAT_WIN_STYLE (WS_VISIBLE)
+
+
643# define RETROFLAT_WIN_STYLE (WS_OVERLAPPEDWINDOW & ~WS_MAXIMIZEBOX & ~WS_THICKFRAME)
+
+
+
+
+
648#if defined( RETROFLAT_API_SDL2 )
+
649# if defined( RETROFLAT_RESIZABLE )
+
650# define RETROFLAT_WIN_FLAGS SDL_WINDOW_RESIZABLE
+
+
652# define RETROFLAT_WIN_FLAGS 0
+
+
+
+
656#if defined( RETROFLAT_API_SDL1 )
+
657# define RETROFLAT_SDL_CC_FLAGS (SDL_RLEACCEL | SDL_SRCCOLORKEY)
+
658#elif defined( RETROFLAT_API_SDL2 )
+
659# define RETROFLAT_SDL_CC_FLAGS (SDL_TRUE)
+
+
+
662#ifdef RETROFLAT_OS_DOS
+
663# define RETROFLAT_PATH_SEP '\\'
+
+
666# define RETROFLAT_PATH_SEP '/'
+
+
+
670#define RETROFLAT_ASSETS_PATH_MAX (RETROFLAT_PATH_MAX / 2)
+
+
672#ifndef NDS_OAM_ACTIVE
+
674# define NDS_OAM_ACTIVE &oamMain
+
+
+
677#ifndef NDS_SPRITES_ACTIVE
+
679# define NDS_SPRITES_ACTIVE 24
+
+
+
682#ifndef RETROFLAT_CONFIG_LN_SZ_MAX
+
683# define RETROFLAT_CONFIG_LN_SZ_MAX 255
+
+
+
686#ifndef RETROFLAT_CONFIG_EXT
+
687# define RETROFLAT_CONFIG_EXT ".ini"
+
+
+
690#ifndef RETROFLAT_BMP_COLORS_SZ_MAX
+
691# define RETROFLAT_BMP_COLORS_SZ_MAX 256
+
+
+
+
+
+
710#define retroflat_buffer_bksp( buffer, buffer_cur, buffer_sz ) \
+
711 if( 0 < buffer_cur ) { \
+
712 if( buffer_cur < buffer_sz ) { \
+
+
714 &(buffer[(buffer_cur) - 1]), \
+
715 &(buffer[buffer_cur]), \
+
716 (buffer_sz) - (buffer_cur) ); \
+
+
+
+
720 buffer[buffer_sz] = '\0'; \
+
+
+
726#define retroflat_buffer_insert( c, buffer, buffer_cur, buffer_sz, buffer_mx ) \
+
727 if( buffer_sz + 1 < buffer_mx ) { \
+
728 if( buffer_cur < buffer_sz ) { \
+
+
730 &(buffer[(buffer_cur) + 1]), \
+
731 &(buffer[buffer_cur]), \
+
732 (buffer_sz) - (buffer_cur) ); \
+
+
734 buffer[buffer_cur] = c; \
+
+
+
737 buffer[buffer_sz] = '\0'; \
+
+
+
740#define RETROFLAT_INPUT_MOD_SHIFT 0x01
+
+
742#define RETROFLAT_INPUT_MOD_ALT 0x02
+
+
744#define RETROFLAT_INPUT_MOD_CTRL 0x04
+
+
746#define RETROFLAT_INPUT_FORCE_UPPER 0x08
+
+
+
+
+
+
+
+
+
765#ifdef RETROFLAT_OPENGL
+
766struct RETROFLAT_GLTEX {
+
767 MAUG_MHANDLE bytes_h;
+
+
+
+
+
+
+
+
+
+
+
+
+
780#if defined( RETROFLAT_API_ALLEGRO )
+
+
782# ifdef RETROFLAT_OPENGL
+
783# error "opengl support not implemented for allegro"
+
+
+
+
+
+
+
790# ifdef RETROFLAT_OS_DOS
+
+
+
+
+
+
+
797# ifndef RETROFLAT_CONFIG_USE_FILE
+
798# define RETROFLAT_CONFIG_USE_FILE
+
+
+
+
+
+
+
+
+
+
+
809typedef int RETROFLAT_COLOR_DEF;
+
+
811# define retroflat_bitmap_ok( bitmap ) (NULL != (bitmap)->b)
+
812# define retroflat_bitmap_locked( bmp ) (0)
+
813# ifdef RETROFLAT_OPENGL
+
814# define retroflat_bitmap_w( bmp ) ((bmp)->tex.w)
+
815# define retroflat_bitmap_h( bmp ) ((bmp)->tex.h)
+
+
817# define retroflat_bitmap_w( bmp ) ((bmp)->w)
+
818# define retroflat_bitmap_h( bmp ) ((bmp)->h)
+
+
820# define retroflat_screen_w() SCREEN_W
+
821# define retroflat_screen_h() SCREEN_H
+
822# define retroflat_screen_buffer() (&(g_retroflat_state->buffer))
+
823# define retroflat_px_lock( bmp )
+
824# define retroflat_px_release( bmp )
+
+
826# define retroflat_quit( retval_in ) \
+
827 g_retroflat_state->retroflat_flags &= ~RETROFLAT_FLAGS_RUNNING; \
+
828 g_retroflat_state->retval = retval_in;
+
+
830# define RETROFLAT_MOUSE_B_LEFT -1
+
831# define RETROFLAT_MOUSE_B_RIGHT -2
+
+
833# define RETROFLAT_KEY_UP KEY_UP
+
834# define RETROFLAT_KEY_DOWN KEY_DOWN
+
835# define RETROFLAT_KEY_RIGHT KEY_RIGHT
+
836# define RETROFLAT_KEY_LEFT KEY_LEFT
+
837# define RETROFLAT_KEY_A KEY_A
+
838# define RETROFLAT_KEY_B KEY_B
+
839# define RETROFLAT_KEY_C KEY_C
+
840# define RETROFLAT_KEY_D KEY_D
+
841# define RETROFLAT_KEY_E KEY_E
+
842# define RETROFLAT_KEY_F KEY_F
+
843# define RETROFLAT_KEY_G KEY_G
+
844# define RETROFLAT_KEY_H KEY_H
+
845# define RETROFLAT_KEY_I KEY_I
+
846# define RETROFLAT_KEY_J KEY_J
+
847# define RETROFLAT_KEY_K KEY_K
+
848# define RETROFLAT_KEY_L KEY_L
+
849# define RETROFLAT_KEY_M KEY_M
+
850# define RETROFLAT_KEY_N KEY_N
+
851# define RETROFLAT_KEY_O KEY_O
+
852# define RETROFLAT_KEY_P KEY_P
+
853# define RETROFLAT_KEY_Q KEY_Q
+
854# define RETROFLAT_KEY_R KEY_R
+
855# define RETROFLAT_KEY_S KEY_S
+
856# define RETROFLAT_KEY_T KEY_T
+
857# define RETROFLAT_KEY_U KEY_U
+
858# define RETROFLAT_KEY_V KEY_V
+
859# define RETROFLAT_KEY_W KEY_W
+
860# define RETROFLAT_KEY_X KEY_X
+
861# define RETROFLAT_KEY_Y KEY_Y
+
862# define RETROFLAT_KEY_Z KEY_Z
+
863# define RETROFLAT_KEY_0 KEY_0
+
864# define RETROFLAT_KEY_1 KEY_1
+
865# define RETROFLAT_KEY_2 KEY_2
+
866# define RETROFLAT_KEY_3 KEY_3
+
867# define RETROFLAT_KEY_4 KEY_4
+
868# define RETROFLAT_KEY_5 KEY_5
+
869# define RETROFLAT_KEY_6 KEY_6
+
870# define RETROFLAT_KEY_7 KEY_7
+
871# define RETROFLAT_KEY_8 KEY_8
+
872# define RETROFLAT_KEY_9 KEY_9
+
873# define RETROFLAT_KEY_TAB KEY_TAB
+
874# define RETROFLAT_KEY_SPACE KEY_SPACE
+
875# define RETROFLAT_KEY_ESC KEY_ESC
+
876# define RETROFLAT_KEY_ENTER KEY_ENTER
+
877# define RETROFLAT_KEY_HOME KEY_HOME
+
878# define RETROFLAT_KEY_END KEY_END
+
879# define RETROFLAT_KEY_DELETE KEY_DEL
+
880# define RETROFLAT_KEY_PGUP KEY_PGUP
+
881# define RETROFLAT_KEY_PGDN KEY_PGDN
+
882# define RETROFLAT_KEY_GRAVE KEY_BACKQUOTE
+
883# define RETROFLAT_KEY_BKSP KEY_BACKSPACE
+
884# define RETROFLAT_KEY_SLASH KEY_SLASH
+
885# define RETROFLAT_KEY_SEMICOLON KEY_SEMICOLON
+
886# define RETROFLAT_KEY_PERIOD KEY_STOP
+
887# define RETROFLAT_KEY_COMMA KEY_COMMA
+
888# define RETROFLAT_KEY_EQUALS KEY_EQUALS
+
889# define RETROFLAT_KEY_DASH KEY_MINUS
+
+
891#elif defined( RETROFLAT_API_SDL1 ) || defined( RETROFLAT_API_SDL2 )
+
+
893# if defined( RETROFLAT_API_SDL2 ) && defined( RETROFLAT_OPENGL )
+
894# error "opengl support not implemented for SDL 2"
+
+
+
+
+
899# if defined( RETROFLAT_OS_WASM )
+
900# include <emscripten.h>
+
+
+
903# ifndef RETROFLAT_CONFIG_USE_FILE
+
904# define RETROFLAT_CONFIG_USE_FILE
+
+
+
+
+
909# if !defined( RETROFLAT_SOFT_SHAPES ) && !defined( RETROFLAT_OPENGL )
+
910# define RETROFLAT_SOFT_SHAPES
+
+
+
+
+
+
+
+
918 SDL_Surface* surface;
+
919# ifdef RETROFLAT_API_SDL1
+
+
921 ssize_t autolock_refs;
+
+
+
924 SDL_Texture* texture;
+
925 SDL_Renderer* renderer;
+
+
927# ifdef RETROFLAT_OPENGL
+
928 struct RETROFLAT_GLTEX tex;
+
+
+
+
932# define RETROFLAT_KEY_UP SDLK_UP
+
933# define RETROFLAT_KEY_DOWN SDLK_DOWN
+
934# define RETROFLAT_KEY_RIGHT SDLK_RIGHT
+
935# define RETROFLAT_KEY_LEFT SDLK_LEFT
+
936# define RETROFLAT_KEY_A SDLK_a
+
937# define RETROFLAT_KEY_B SDLK_b
+
938# define RETROFLAT_KEY_C SDLK_c
+
939# define RETROFLAT_KEY_D SDLK_d
+
940# define RETROFLAT_KEY_E SDLK_e
+
941# define RETROFLAT_KEY_F SDLK_f
+
942# define RETROFLAT_KEY_G SDLK_g
+
943# define RETROFLAT_KEY_H SDLK_h
+
944# define RETROFLAT_KEY_I SDLK_i
+
945# define RETROFLAT_KEY_J SDLK_j
+
946# define RETROFLAT_KEY_K SDLK_k
+
947# define RETROFLAT_KEY_L SDLK_l
+
948# define RETROFLAT_KEY_M SDLK_m
+
949# define RETROFLAT_KEY_N SDLK_n
+
950# define RETROFLAT_KEY_O SDLK_o
+
951# define RETROFLAT_KEY_P SDLK_p
+
952# define RETROFLAT_KEY_Q SDLK_q
+
953# define RETROFLAT_KEY_R SDLK_r
+
954# define RETROFLAT_KEY_S SDLK_s
+
955# define RETROFLAT_KEY_T SDLK_t
+
956# define RETROFLAT_KEY_U SDLK_u
+
957# define RETROFLAT_KEY_V SDLK_v
+
958# define RETROFLAT_KEY_W SDLK_w
+
959# define RETROFLAT_KEY_X SDLK_x
+
960# define RETROFLAT_KEY_Y SDLK_y
+
961# define RETROFLAT_KEY_Z SDLK_z
+
962# define RETROFLAT_KEY_0 SDLK_0
+
963# define RETROFLAT_KEY_1 SDLK_1
+
964# define RETROFLAT_KEY_2 SDLK_2
+
965# define RETROFLAT_KEY_3 SDLK_3
+
966# define RETROFLAT_KEY_4 SDLK_4
+
967# define RETROFLAT_KEY_5 SDLK_5
+
968# define RETROFLAT_KEY_6 SDLK_6
+
969# define RETROFLAT_KEY_7 SDLK_7
+
970# define RETROFLAT_KEY_8 SDLK_8
+
971# define RETROFLAT_KEY_9 SDLK_9
+
972# define RETROFLAT_KEY_TAB SDLK_TAB
+
973# define RETROFLAT_KEY_SPACE SDLK_SPACE
+
974# define RETROFLAT_KEY_ESC SDLK_ESCAPE
+
975# define RETROFLAT_KEY_ENTER SDLK_RETURN
+
976# define RETROFLAT_KEY_HOME SDLK_HOME
+
977# define RETROFLAT_KEY_END SDLK_END
+
978# define RETROFLAT_KEY_DELETE SDLK_DELETE
+
979# define RETROFLAT_KEY_PGUP SDLK_PAGEUP
+
980# define RETROFLAT_KEY_PGDN SDLK_PAGEDOWN
+
981# define RETROFLAT_KEY_GRAVE SDLK_BACKQUOTE
+
982# define RETROFLAT_KEY_SLASH SDLK_SLASH
+
983# define RETROFLAT_KEY_BKSP SDLK_BACKSPACE
+
984# define RETROFLAT_KEY_SEMICOLON SDLK_SEMICOLON
+
985# define RETROFLAT_KEY_PERIOD SDLK_PERIOD
+
986# define RETROFLAT_KEY_COMMA SDLK_COMMA
+
987# define RETROFLAT_KEY_EQUALS SDLK_EQUALS
+
988# define RETROFLAT_KEY_DASH SDLK_MINUS
+
+
990# define RETROFLAT_MOUSE_B_LEFT -1
+
991# define RETROFLAT_MOUSE_B_RIGHT -2
+
+
993# define retroflat_bitmap_ok( bitmap ) (NULL != (bitmap)->surface)
+
994# ifdef RETROFLAT_OPENGL
+
995# define retroflat_bitmap_w( bmp ) ((bmp)->tex.w)
+
996# define retroflat_bitmap_h( bmp ) ((bmp)->tex.h)
+
+
998# define retroflat_bitmap_w( bmp ) ((bmp)->surface->w)
+
999# define retroflat_bitmap_h( bmp ) ((bmp)->surface->h)
+
+
1001# ifdef RETROFLAT_API_SDL1
+
1002# define retroflat_bitmap_locked( bmp ) \
+
1003 (RETROFLAT_FLAGS_LOCK == (RETROFLAT_FLAGS_LOCK & (bmp)->flags))
+
+
1005# define retroflat_bitmap_locked( bmp ) (NULL != (bmp)->renderer)
+
+
1007# define retroflat_screen_w() (g_retroflat_state->screen_v_w)
+
1008# define retroflat_screen_h() (g_retroflat_state->screen_v_h)
+
1009# define retroflat_screen_buffer() \
+
1010 (NULL == g_retroflat_state->vdp_buffer ? \
+
1011 &(g_retroflat_state->buffer) : g_retroflat_state->vdp_buffer)
+
+
1013# if defined( RETROFLAT_API_SDL1 ) && !defined( RETROFLAT_OPENGL )
+
+
1015# define retroflat_px_lock( bmp ) \
+
1016 assert( NULL != bmp ); \
+
1017 (bmp)->autolock_refs++; \
+
1018 SDL_LockSurface( (bmp)->surface );
+
1019# define retroflat_px_release( bmp ) \
+
1020 assert( NULL != bmp ); \
+
1021 assert( 0 < (bmp)->autolock_refs ); \
+
1022 (bmp)->autolock_refs--; \
+
1023 SDL_UnlockSurface( (bmp)->surface );
+
+
+
1026# define retroflat_px_lock( bmp )
+
1027# define retroflat_px_release( bmp )
+
+
+
1030# define retroflat_quit( retval_in ) \
+
1031 g_retroflat_state->retroflat_flags &= ~RETROFLAT_FLAGS_RUNNING; \
+
1032 g_retroflat_state->retval = retval_in;
+
+
1034# define END_OF_MAIN()
+
+
+
1037# if defined( RETROFLT_C ) && defined( RETROFLAT_SDL_ICO )
+
1038# include <sdl_ico.h>
+
+
+
+
1042# ifdef RETROFLAT_OPENGL
+
1043typedef float MAUG_CONST* RETROFLAT_COLOR_DEF;
+
+
1045typedef SDL_Color RETROFLAT_COLOR_DEF;
+
+
+
1048#elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
+
+
+
1052# if defined( RETROFLAT_API_WIN16 ) && defined( RETROFLAT_OPENGL )
+
1053# error "opengl support not implemented for win16"
+
+
+
1056#ifndef MAUG_WINDOWS_H
+
1057# include <windows.h>
+
1058# define MAUG_WINDOWS_H
+
+
+
1061# include <mmsystem.h>
+
+
1063# ifndef RETROFLAT_API_WINCE
+
+
+
+
1067# ifdef RETROFLAT_WING
+
+
1069# if defined( RETROFLAT_API_WIN32 )
+
1070# define WINGAPI WINAPI
+
+
1072# define WINGAPI WINAPI _loadds
+
+
+
1075# define RETROFLAT_WING_LLTABLE( f ) \
+
1076 f( HDC, WinGCreateDC, 1001 ) \
+
1077 f( BOOL, WinGRecommendDIBFormat, 1002 ) \
+
1078 f( HBITMAP, WinGCreateBitmap, 1003 ) \
+
1079 f( BOOL, WinGStretchBlt, 1009 )
+
+
1081typedef HDC (WINGAPI *WinGCreateDC_t)();
+
1082typedef BOOL (WINGAPI *WinGRecommendDIBFormat_t)( BITMAPINFO FAR* );
+
1083typedef HBITMAP (WINGAPI *WinGCreateBitmap_t)(
+
1084 HDC, BITMAPINFO
const FAR*,
void FAR* FAR* );
+
1085typedef BOOL (WINGAPI *WinGStretchBlt_t)(
+
1086 HDC, int, int, int, int, HDC, int, int, int, int );
+
+
1088# define RETROFLAT_WING_LLTABLE_STRUCT_MEMBERS( retval, proc, ord ) \
+
+
+
1091struct RETROFLAT_WING_MODULE {
+
+
+
1094 RETROFLAT_WING_LLTABLE( RETROFLAT_WING_LLTABLE_STRUCT_MEMBERS )
+
+
+
+
1098struct RETROFLAT_BMI {
+
1099 BITMAPINFOHEADER header;
+
1100 RGBQUAD colors[RETROFLAT_BMP_COLORS_SZ_MAX];
+
+
+
1103# ifdef RETROFLAT_API_WIN32
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1117 HBITMAP old_hbm_mask;
+
1118# ifdef RETROFLAT_API_WIN16
+
+
+
+
+
1123 ssize_t autolock_refs;
+
1124# ifdef RETROFLAT_OPENGL
+
1125 struct RETROFLAT_GLTEX tex;
+
+
1127 struct RETROFLAT_BMI bmi;
+
+
+
+
1131# if defined( RETROFLAT_C ) && defined( RETROFLAT_API_WINCE )
+
1132void* calloc(
size_t n,
size_t s ) {
+
+
+
1135 out = malloc( n * s );
+
1136 memset( out,
'\0', n * s );
+
+
+
+
+
+
1142# ifdef RETROFLAT_OPENGL
+
+
1144typedef float MAUG_CONST* RETROFLAT_COLOR_DEF;
+
+
+
+
+
+
1150typedef COLORREF RETROFLAT_COLOR_DEF;
+
+
+
+
+
1155# define RETROFLAT_COLOR_TABLE_WIN_BRUSH( idx, name_l, name_u, r, g, b ) \
+
+
+
1158# define RETROFLAT_COLOR_TABLE_WIN_BRSET( idx, name_l, name_u, r, g, b ) \
+
1159 gc_retroflat_win_brushes[idx] = CreateSolidBrush( RGB( r, g, b ) );
+
+
1161# define RETROFLAT_COLOR_TABLE_WIN_BRRM( idx, name_l, name_u, r, g, b ) \
+
1162 if( (HBRUSH)NULL != gc_retroflat_win_brushes[idx] ) { \
+
1163 DeleteObject( gc_retroflat_win_brushes[idx] ); \
+
1164 gc_retroflat_win_brushes[idx] = (HBRUSH)NULL; \
+
+
+
+
+
+
+
1171# define RETROFLAT_COLOR_TABLE_WIN_PENS( idx, name_l, name_u, r, g, b ) \
+
+
+
1174# define RETROFLAT_COLOR_TABLE_WIN_PNSET( idx, name_l, name_u, r, g, b ) \
+
1175 gc_retroflat_win_pens[idx] = CreatePen( \
+
1176 PS_SOLID, RETROFLAT_LINE_THICKNESS, RGB( r, g, b ) );
+
+
1178# define RETROFLAT_COLOR_TABLE_WIN_PENRM( idx, name_l, name_u, r, g, b ) \
+
1179 if( (HPEN)NULL != gc_retroflat_win_pens[idx] ) { \
+
1180 DeleteObject( gc_retroflat_win_pens[idx] ); \
+
1181 gc_retroflat_win_pens[idx] = (HPEN)NULL; \
+
+
+
+
+
+
+
1188HBRUSH gc_retroflat_win_brushes[] = {
+
1189 RETROFLAT_COLOR_TABLE( RETROFLAT_COLOR_TABLE_WIN_BRUSH )
+
+
+
1192static HPEN gc_retroflat_win_pens[] = {
+
1193 RETROFLAT_COLOR_TABLE( RETROFLAT_COLOR_TABLE_WIN_PENS )
+
+
+
+
+
1198extern HBRUSH gc_retroflat_win_brushes[];
+
+
+
+
+
1203# define retroflat_win_setup_brush( old_brush, target, color, flags ) \
+
1204 if( RETROFLAT_FLAGS_FILL != (RETROFLAT_FLAGS_FILL & flags) ) { \
+
+
1206 SelectObject( target->hdc_b, GetStockObject( NULL_BRUSH ) ); \
+
+
1208 old_brush = SelectObject( \
+
1209 target->hdc_b, gc_retroflat_win_brushes[color] ); \
+
+
+
+
1213# define retroflat_win_setup_pen( old_pen, target, color, flags ) \
+
+
1215 SelectObject( target->hdc_b, gc_retroflat_win_pens[color] );
+
+
1217# define retroflat_win_cleanup_brush( old_brush, target ) \
+
1218 if( (HBRUSH)NULL != old_brush ) { \
+
1219 SelectObject( target->hdc_b, old_brush ); \
+
+
+
1222# define retroflat_win_cleanup_pen( old_pen, target ) \
+
1223 if( (HPEN)NULL != old_pen ) { \
+
1224 SelectObject( target->hdc_b, old_pen ); \
+
+
+
+
+
+
+
1231# ifdef RETROFLAT_OPENGL
+
1232# define retroflat_bitmap_w( bmp ) ((bmp)->tex.w)
+
1233# define retroflat_bitmap_h( bmp ) ((bmp)->tex.h)
+
1234# define retroflat_bitmap_locked( bmp ) (NULL != (bmp)->tex.bytes)
+
+
1236# define retroflat_bitmap_w( bmp ) ((bmp)->bmi.header.biWidth)
+
1237# define retroflat_bitmap_h( bmp ) ((bmp)->bmi.header.biHeight)
+
1238# define retroflat_bitmap_locked( bmp ) ((HDC)NULL != (bmp)->hdc_b)
+
+
+
1241# define retroflat_bitmap_ok( bitmap ) ((HBITMAP)NULL != (bitmap)->b)
+
+
1243# ifdef RETROFLAT_VDP
+
+
+
1246# define retroflat_px_lock( bmp ) \
+
1247 assert( NULL != (bmp)->hdc_b ); \
+
+
1249 (bmp)->autolock_refs++; \
+
+
1251 1 == (bmp)->autolock_refs && \
+
1252 RETROFLAT_FLAGS_SCREEN_BUFFER != \
+
1253 (RETROFLAT_FLAGS_SCREEN_BUFFER & (bmp)->flags) \
+
+
+
+
1257 assert( NULL == (bmp)->bits ); \
+
1258 assert( (bmp)->bmi.header.biBitCount == 32 ); \
+
1259 assert( (bmp)->bmi.header.biWidth > 0 ); \
+
1260 assert( (bmp)->bmi.header.biHeight > 0 ); \
+
1261 assert( (bmp)->bmi.header.biSizeImage == \
+
1262 (bmp)->bmi.header.biWidth * (bmp)->bmi.header.biHeight * 4 ); \
+
1263 (bmp)->bits = VirtualAlloc( \
+
1264 0, (bmp)->bmi.header.biSizeImage, \
+
1265 MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE ); \
+
1266 assert( NULL != (bmp)->bits ); \
+
1267 GetDIBits( (bmp)->hdc_b, (bmp)->b, 0, (bmp)->bmi.header.biHeight, \
+
1268 (bmp)->bits, (BITMAPINFO*)&((bmp)->bmi), DIB_RGB_COLORS ); \
+
+
+
1271# define retroflat_px_release( bmp ) \
+
1272 assert( 0 < (bmp)->autolock_refs ); \
+
1273 (bmp)->autolock_refs--; \
+
+
1275 0 == (bmp)->autolock_refs && \
+
1276 RETROFLAT_FLAGS_SCREEN_BUFFER != \
+
1277 (RETROFLAT_FLAGS_SCREEN_BUFFER & (bmp)->flags) \
+
+
+
+
1281 SetDIBits( g_retroflat_state->hdc_win, (bmp)->b, 0, \
+
1282 (bmp)->bmi.header.biHeight, (bmp)->bits, \
+
1283 (BITMAPINFO*)&((bmp)->bmi), DIB_RGB_COLORS ) < \
+
1284 (bmp)->bmi.header.biHeight \
+
+
1286 error_printf( "SetDIBits failed!" ); \
+
+
1288 VirtualFree( (bmp)->bits, 0, MEM_RELEASE ); \
+
1289 (bmp)->bits = NULL; \
+
+
+
+
+
1294# define retroflat_px_lock( bmp )
+
1295# define retroflat_px_release( bmp )
+
+
+
+
1299# define retroflat_screen_w() (g_retroflat_state->screen_v_w)
+
1300# define retroflat_screen_h() (g_retroflat_state->screen_v_h)
+
1301# define retroflat_screen_buffer() \
+
1302 (NULL == g_retroflat_state->vdp_buffer ? \
+
1303 &(g_retroflat_state->buffer) : g_retroflat_state->vdp_buffer)
+
1304# define retroflat_quit( retval_in ) PostQuitMessage( retval_in );
+
+
1306# define retroflat_bmp_int( type, buf, offset ) *((type*)&(buf[offset]))
+
+
+
1309# define VK_OEM_2 0xbf
+
+
+
+
1313# define VK_OEM_3 0xc0
+
+
+
1316# define RETROFLAT_KEY_GRAVE VK_OEM_3
+
1317# define RETROFLAT_KEY_SLASH VK_OEM_2
+
1318# define RETROFLAT_KEY_UP VK_UP
+
1319# define RETROFLAT_KEY_DOWN VK_DOWN
+
1320# define RETROFLAT_KEY_RIGHT VK_RIGHT
+
1321# define RETROFLAT_KEY_LEFT VK_LEFT
+
1322# define RETROFLAT_KEY_BKSP VK_BACK
+
1323# define RETROFLAT_KEY_A 0x41
+
1324# define RETROFLAT_KEY_B 0x42
+
1325# define RETROFLAT_KEY_C 0x43
+
1326# define RETROFLAT_KEY_D 0x44
+
1327# define RETROFLAT_KEY_E 0x45
+
1328# define RETROFLAT_KEY_F 0x46
+
1329# define RETROFLAT_KEY_G 0x47
+
1330# define RETROFLAT_KEY_H 0x48
+
1331# define RETROFLAT_KEY_I 0x49
+
1332# define RETROFLAT_KEY_J 0x4a
+
1333# define RETROFLAT_KEY_K 0x4b
+
1334# define RETROFLAT_KEY_L 0x4c
+
1335# define RETROFLAT_KEY_M 0x4d
+
1336# define RETROFLAT_KEY_N 0x4e
+
1337# define RETROFLAT_KEY_O 0x4f
+
1338# define RETROFLAT_KEY_P 0x50
+
1339# define RETROFLAT_KEY_Q 0x51
+
1340# define RETROFLAT_KEY_R 0x52
+
1341# define RETROFLAT_KEY_S 0x53
+
1342# define RETROFLAT_KEY_T 0x54
+
1343# define RETROFLAT_KEY_U 0x55
+
1344# define RETROFLAT_KEY_V 0x56
+
1345# define RETROFLAT_KEY_W 0x57
+
1346# define RETROFLAT_KEY_X 0x58
+
1347# define RETROFLAT_KEY_Y 0x59
+
1348# define RETROFLAT_KEY_Z 0x60
+
1349# define RETROFLAT_KEY_0 0x30
+
1350# define RETROFLAT_KEY_1 0x31
+
1351# define RETROFLAT_KEY_2 0x32
+
1352# define RETROFLAT_KEY_3 0x33
+
1353# define RETROFLAT_KEY_4 0x34
+
1354# define RETROFLAT_KEY_5 0x35
+
1355# define RETROFLAT_KEY_6 0x36
+
1356# define RETROFLAT_KEY_7 0x37
+
1357# define RETROFLAT_KEY_8 0x38
+
1358# define RETROFLAT_KEY_9 0x39
+
1359# define RETROFLAT_KEY_TAB VK_TAB
+
1360# define RETROFLAT_KEY_SPACE VK_SPACE
+
1361# define RETROFLAT_KEY_ESC VK_ESCAPE
+
1362# define RETROFLAT_KEY_ENTER VK_RETURN
+
1363# define RETROFLAT_KEY_HOME VK_HOME
+
1364# define RETROFLAT_KEY_END VK_END
+
1365# define RETROFLAT_KEY_DELETE VK_DELETE
+
1366# define RETROFLAT_KEY_PGUP VK_PRIOR
+
1367# define RETROFLAT_KEY_PGDN VK_NEXT
+
1368# define RETROFLAT_KEY_SEMICOLON ';'
+
1369# define RETROFLAT_KEY_PERIOD '.'
+
1370# define RETROFLAT_KEY_COMMA ','
+
1371# define RETROFLAT_KEY_EQUALS '='
+
1372# define RETROFLAT_KEY_DASH '-'
+
+
1374# define RETROFLAT_MOUSE_B_LEFT VK_LBUTTON
+
1375# define RETROFLAT_MOUSE_B_RIGHT VK_RBUTTON
+
+
+
1378# if defined( RETROFLAT_API_WIN16 )
+
1379# define WINXAPI PASCAL
+
1380# elif defined( RETROFLAT_API_WIN32 )
+
1381# define WINXAPI WINAPI
+
+
+
+
1385#define GET_X_LPARAM(lp) ((int)(short)LOWORD(lp))
+
1386#define GET_Y_LPARAM(lp) ((int)(short)HIWORD(lp))
+
+
1388#define main( argc, argv ) retroflat_main( argc, argv )
+
+
+
1391#define END_OF_MAIN() \
+
1392 int WINXAPI WinMain( \
+
1393 HINSTANCE hInstance, HINSTANCE hPrevInstance, \
+
1394 LPSTR lpCmdLine, int nCmdShow \
+
+
1396 LPSTR* rf_argv = NULL; \
+
+
+
1399 g_retroflat_instance = hInstance; \
+
1400 g_retroflat_cmd_show = nCmdShow; \
+
1401 rf_argv = retroflat_win_cli( lpCmdLine, &rf_argc ); \
+
1402 retval = retroflat_main( rf_argc, rf_argv ); \
+
+
+
+
+
+
+
1409#define retroflat_internal_autolock_bitmap( bmp, lock_auto ) \
+
1410 if( !retroflat_bitmap_locked( bmp ) ) { \
+
1411 retval = retroflat_draw_lock( bmp ); \
+
1412 maug_cleanup_if_not_ok(); \
+
+
+
+
1416#elif defined( RETROFLAT_API_LIBNDS )
+
+
+
+
+
+
+
1423# ifndef RETROFLAT_SOFT_SHAPES
+
1424# define RETROFLAT_SOFT_SHAPES
+
+
+
1427# define BG_TILE_W_PX 8
+
1428# define BG_TILE_H_PX 8
+
1429# define BG_W_TILES 32
+
+
+
+
+
+
+
+
1437# ifdef RETROFLAT_OPENGL
+
1438 struct RETROFLAT_GLTEX tex;
+
+
+
+
+
+
1444typedef int RETROFLAT_COLOR_DEF;
+
+
1446# ifdef RETROFLAT_NDS_WASD
+
1447# define RETROFLAT_KEY_A KEY_LEFT
+
1448# define RETROFLAT_KEY_D KEY_RIGHT
+
1449# define RETROFLAT_KEY_W KEY_UP
+
1450# define RETROFLAT_KEY_S KEY_DOWN
+
+
1452# define RETROFLAT_KEY_LEFT KEY_LEFT
+
1453# define RETROFLAT_KEY_RIGHT KEY_RIGHT
+
1454# define RETROFLAT_KEY_UP KEY_UP
+
1455# define RETROFLAT_KEY_DOWN KEY_DOWN
+
+
1457# define RETROFLAT_KEY_ENTER KEY_START
+
1458# define RETROFLAT_KEY_SPACE KEY_A
+
1459# define RETROFLAT_KEY_ESC KEY_B
+
1460# define RETROFLAT_MOUSE_B_LEFT (-1)
+
1461# define RETROFLAT_MOUSE_B_RIGHT (-2)
+
+
+
1464# define retroflat_bitmap_locked( bmp ) (0)
+
1465# define retroflat_px_lock( bmp )
+
1466# define retroflat_px_release( bmp )
+
+
1468# define retroflat_screen_w() (256)
+
1469# define retroflat_screen_h() (192)
+
1470# define retroflat_screen_buffer() (&(g_retroflat_state->buffer))
+
+
1472# define END_OF_MAIN()
+
+
+
1475# define retroflat_quit( retval_in )
+
1476# define retroflat_bitmap_w( bmp ) (0)
+
1477# define retroflat_bitmap_h( bmp ) (0)
+
1478# define retroflat_bitmap_ok( bitmap ) (0)
+
+
1480#elif defined( RETROFLAT_API_GLUT )
+
+
1482#ifndef RETROFLAT_OPENGL
+
1483# error "RETROFLAT_API_GLUT specified without RETROFLAT_OPENGL!"
+
1484# define RETROFLAT_OPENGL
+
+
+
+
+
1489# ifndef RETROFLAT_CONFIG_USE_FILE
+
1490# define RETROFLAT_CONFIG_USE_FILE
+
+
+
+
+
1495typedef float MAUG_CONST* RETROFLAT_COLOR_DEF;
+
+
+
+
+
1500 struct RETROFLAT_GLTEX tex;
+
+
+
+
+
1505# define retroflat_bitmap_ok( bitmap ) (NULL != (bitmap)->b)
+
1506# define retroflat_bitmap_locked( bmp ) 0
+
+
1508# define retroflat_bitmap_w( bmp ) (0)
+
1509# define retroflat_bitmap_h( bmp ) (0)
+
+
1512# define retroflat_px_lock( bmp )
+
1513# define retroflat_px_release( bmp )
+
1514# define retroflat_screen_w() (g_retroflat_state->screen_v_w)
+
1515# define retroflat_screen_h() (g_retroflat_state->screen_v_h)
+
1516# define retroflat_screen_buffer() (&(g_retroflat_state->buffer))
+
1517# define retroflat_quit( retval_in ) glutDestroyWindow( glutGetWindow() )
+
1518# define END_OF_MAIN()
+
+
1520# define GLUT_SPECIAL_KEY_OFFSET 0x80
+
+
1522# define RETROFLAT_KEY_UP (GLUT_SPECIAL_KEY_OFFSET + GLUT_KEY_UP)
+
1523# define RETROFLAT_KEY_DOWN (GLUT_SPECIAL_KEY_OFFSET + GLUT_KEY_DOWN)
+
1524# define RETROFLAT_KEY_RIGHT (GLUT_SPECIAL_KEY_OFFSET + GLUT_KEY_RIGHT)
+
1525# define RETROFLAT_KEY_LEFT (GLUT_SPECIAL_KEY_OFFSET + GLUT_KEY_LEFT)
+
1526# define RETROFLAT_KEY_HOME (GLUT_SPECIAL_KEY_OFFSET + GLUT_KEY_HOME)
+
1527# define RETROFLAT_KEY_END (GLUT_SPECIAL_KEY_OFFSET + GLUT_KEY_END)
+
1528# define RETROFLAT_KEY_PGUP (GLUT_SPECIAL_KEY_OFFSET + GLUT_KEY_PAGE_UP)
+
1529# define RETROFLAT_KEY_PGDN \
+
1530 (GLUT_SPECIAL_KEY_OFFSET + GLUT_KEY_PAGE_DOWN)
+
1531# define RETROFLAT_KEY_DELETE 0x7f
+
1532# define RETROFLAT_KEY_ESC 0x1b
+
1533# define RETROFLAT_KEY_ENTER 0x0d
+
1534# define RETROFLAT_KEY_TAB '\t'
+
1535# define RETROFLAT_KEY_SPACE ' '
+
1536# define RETROFLAT_KEY_GRAVE '`'
+
1537# define RETROFLAT_KEY_SLASH '/'
+
1538# define RETROFLAT_KEY_BKSP 0x08
+
1539# define RETROFLAT_KEY_SEMICOLON ';'
+
1540# define RETROFLAT_KEY_PERIOD '.'
+
1541# define RETROFLAT_KEY_COMMA ','
+
1542# define RETROFLAT_KEY_EQUALS '='
+
1543# define RETROFLAT_KEY_DASH '-'
+
1544# define RETROFLAT_KEY_A 'a'
+
1545# define RETROFLAT_KEY_B 'b'
+
1546# define RETROFLAT_KEY_C 'c'
+
1547# define RETROFLAT_KEY_D 'd'
+
1548# define RETROFLAT_KEY_E 'e'
+
1549# define RETROFLAT_KEY_F 'f'
+
1550# define RETROFLAT_KEY_G 'g'
+
1551# define RETROFLAT_KEY_H 'h'
+
1552# define RETROFLAT_KEY_I 'i'
+
1553# define RETROFLAT_KEY_J 'j'
+
1554# define RETROFLAT_KEY_K 'k'
+
1555# define RETROFLAT_KEY_L 'l'
+
1556# define RETROFLAT_KEY_M 'm'
+
1557# define RETROFLAT_KEY_N 'n'
+
1558# define RETROFLAT_KEY_O 'o'
+
1559# define RETROFLAT_KEY_P 'p'
+
1560# define RETROFLAT_KEY_Q 'q'
+
1561# define RETROFLAT_KEY_R 'r'
+
1562# define RETROFLAT_KEY_S 's'
+
1563# define RETROFLAT_KEY_T 't'
+
1564# define RETROFLAT_KEY_U 'u'
+
1565# define RETROFLAT_KEY_V 'v'
+
1566# define RETROFLAT_KEY_W 'w'
+
1567# define RETROFLAT_KEY_X 'x'
+
1568# define RETROFLAT_KEY_Y 'y'
+
1569# define RETROFLAT_KEY_Z 'z'
+
1570# define RETROFLAT_KEY_0 '0'
+
1571# define RETROFLAT_KEY_1 '1'
+
1572# define RETROFLAT_KEY_2 '2'
+
1573# define RETROFLAT_KEY_3 '3'
+
1574# define RETROFLAT_KEY_4 '4'
+
1575# define RETROFLAT_KEY_5 '5'
+
1576# define RETROFLAT_KEY_6 '6'
+
1577# define RETROFLAT_KEY_7 '7'
+
1578# define RETROFLAT_KEY_8 '8'
+
1579# define RETROFLAT_KEY_9 '9'
+
+
+
1582# warning "not implemented"
+
+
+
+
+
+
+
+
1615 struct RETROFLAT_GLTEX tex;
+
+
+
1619# define retroflat_bitmap_ok( bitmap ) (NULL != (bitmap)->b)
+
+
+
1624# define retroflat_screen_w()
+
+
1627# define retroflat_screen_h()
+
+
1630# define retroflat_screen_buffer() (&(g_retroflat_state->buffer))
+
+
1636# define retroflat_quit( retval_in )
+
+
1651typedef int RETROFLAT_COLOR_DEF;
+
+
1653# define RETROFLAT_COLOR_BLACK 0
+
1654# define RETROFLAT_COLOR_DARKBLUE 1
+
1655# define RETROFLAT_COLOR_DARKGREEN 2
+
1656# define RETROFLAT_COLOR_TEAL 3
+
1657# define RETROFLAT_COLOR_DARKRED 4
+
1658# define RETROFLAT_COLOR_VIOLET 5
+
1659# define RETROFLAT_COLOR_BROWN 6
+
1660# define RETROFLAT_COLOR_GRAY 7
+
1661# define RETROFLAT_COLOR_DARKGRAY 8
+
1662# define RETROFLAT_COLOR_BLUE 9
+
1663# define RETROFLAT_COLOR_GREEN 10
+
1664# define RETROFLAT_COLOR_CYAN 11
+
1665# define RETROFLAT_COLOR_RED 12
+
1666# define RETROFLAT_COLOR_MAGENTA 13
+
1667# define RETROFLAT_COLOR_YELLOW 14
+
1668# define RETROFLAT_COLOR_WHITE 15
+
+
+
+
1687# define RETROFLAT_KEY_UP 0
+
1688# define RETROFLAT_KEY_DOWN 0
+
1689# define RETROFLAT_KEY_RIGHT 0
+
1690# define RETROFLAT_KEY_LEFT 0
+
1691# define RETROFLAT_KEY_A 0x41
+
1692# define RETROFLAT_KEY_B 0x42
+
1693# define RETROFLAT_KEY_C 0x43
+
1694# define RETROFLAT_KEY_D 0x44
+
1695# define RETROFLAT_KEY_E 0x45
+
1696# define RETROFLAT_KEY_F 0x46
+
1697# define RETROFLAT_KEY_G 0x47
+
1698# define RETROFLAT_KEY_H 0x48
+
1699# define RETROFLAT_KEY_I 0x49
+
1700# define RETROFLAT_KEY_J 0x4a
+
1701# define RETROFLAT_KEY_K 0x4b
+
1702# define RETROFLAT_KEY_L 0x4c
+
1703# define RETROFLAT_KEY_M 0x4d
+
1704# define RETROFLAT_KEY_N 0x4e
+
1705# define RETROFLAT_KEY_O 0x4f
+
1706# define RETROFLAT_KEY_P 0x50
+
1707# define RETROFLAT_KEY_Q 0x51
+
1708# define RETROFLAT_KEY_R 0x52
+
1709# define RETROFLAT_KEY_S 0x53
+
1710# define RETROFLAT_KEY_T 0x54
+
1711# define RETROFLAT_KEY_U 0x55
+
1712# define RETROFLAT_KEY_V 0x56
+
1713# define RETROFLAT_KEY_W 0x57
+
1714# define RETROFLAT_KEY_X 0x58
+
1715# define RETROFLAT_KEY_Y 0x59
+
1716# define RETROFLAT_KEY_Z 0x60
+
1717# define RETROFLAT_KEY_0 0x30
+
1718# define RETROFLAT_KEY_1 0x31
+
1719# define RETROFLAT_KEY_2 0x32
+
1720# define RETROFLAT_KEY_3 0x33
+
1721# define RETROFLAT_KEY_4 0x34
+
1722# define RETROFLAT_KEY_5 0x35
+
1723# define RETROFLAT_KEY_6 0x36
+
1724# define RETROFLAT_KEY_7 0x37
+
1725# define RETROFLAT_KEY_8 0x38
+
1726# define RETROFLAT_KEY_9 0x39
+
1727# define RETROFLAT_KEY_TAB 0
+
1728# define RETROFLAT_KEY_SPACE 0
+
1729# define RETROFLAT_KEY_ESC 0
+
1730# define RETROFLAT_KEY_ENTER 0
+
1731# define RETROFLAT_KEY_HOME 0
+
1732# define RETROFLAT_KEY_END 0
+
+
1734# define RETROFLAT_MOUSE_B_LEFT 0
+
1735# define RETROFLAT_MOUSE_B_RIGHT 0
+
+
+
+
+
+
+
1744# if defined( RETROFLAT_OPENGL ) && !defined( RETROFLAT_API_LIBNDS )
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1787#ifdef RETROFLAT_OS_WIN
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1810#if defined( RETROFLAT_OPENGL )
+
1811 uint8_t tex_palette[RETROFLAT_COLORS_SZ][3];
+
+
+
1814#if defined( RETROFLAT_API_ALLEGRO )
+
+
1816# ifdef RETROFLAT_OS_DOS
+
1817 unsigned int last_mouse;
+
1818 unsigned int last_mouse_x;
+
1819 unsigned int last_mouse_y;
+
+
1821 unsigned int close_button;
+
+
+
1824#elif defined( RETROFLAT_API_SDL1 ) || defined( RETROFLAT_API_SDL2 )
+
+
1826# ifndef RETROFLAT_API_SDL1
+
+
+
+
+
1831#elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
+
+
+
1835# ifdef RETROFLAT_SCREENSAVER
+
+
+
+
+
1840# ifdef RETROFLAT_OPENGL
+
+
+
+
+
+
1846 unsigned int last_mouse;
+
1847 unsigned int last_mouse_x;
+
1848 unsigned int last_mouse_y;
+
+
+
1851#elif defined( RETROFLAT_API_LIBNDS )
+
+
+
+
1855 uint8_t bg_bmp_changed;
+
1856 uint8_t window_bmp_changed;
+
+
+
1859 uint16_t bg_tiles[1024];
+
1860 uint16_t window_tiles[1024];
+
+
1862# elif defined( RETROFLAT_API_GLUT )
+
+
1864 size_t retroflat_next;
+
+
1866 int16_t retroflat_last_key;
+
+
+
+
+
+
+
+
+
+
+
+
+
1890 uint8_t
flags,
const char* title,
const char* format, ... );
+
+
+
+
+
+
1909# ifdef RETROFLAT_VDP
+
+
+
+
1913void retroflat_set_title(
const char* format, ... );
+
+
1915uint32_t retroflat_get_ms();
+
+
1917uint32_t retroflat_get_rand();
+
+
1919#define retroflat_opengl_push( x, y, x_f, y_f, aspect_f ) \
+
+
1921 glMatrixMode( GL_PROJECTION ); \
+
+
+
1924 glDisable( GL_LIGHTING ); \
+
+
+
1927 aspect_f = (float)retroflat_screen_w() / (float)retroflat_screen_h(); \
+
1928 glOrtho( -1.0f * aspect_f, aspect_f, -1.0f, 1.0f, 0, 10.0f ); \
+
+
+
+
1932 x_f = ((x) * aspect_f / retroflat_screen_w()) - (aspect_f / 2); \
+
+
1934 y_f = 1.0f - ((y) * 2.0f / retroflat_screen_h()); \
+
+
1936#define retroflat_opengl_whf( w, h, w_f, h_f, aspect_f ) \
+
1937 w_f = ((w) * aspect_f / retroflat_screen_w()); \
+
1938 h_f = ((h) * 2.0f / retroflat_screen_h());
+
+
1940#define retroflat_opengl_pop() \
+
+
+
1943 glMatrixMode( GL_MODELVIEW );
+
+
+
+
+
+
+
+
1966#if defined( RETROFLAT_XPM ) || defined( DOCUMENTATION )
+
+
+
+
+
+
+
+
+
+
+
2000 int s_x,
int s_y,
int d_x,
int d_y,
int w,
int h );
+
+
+
+
+
+
+
+
+
2024 int x,
int y, uint8_t
flags );
+
+
+
+
2038 int x,
int y,
int w,
int h, uint8_t
flags );
+
+
+
+
2052 int x,
int y,
int w,
int h, uint8_t
flags );
+
+
+
+
2067 int x1,
int y1,
int x2,
int y2, uint8_t
flags );
+
+
+
+
+
+
2085 const char* font_str,
size_t* w_out,
size_t* h_out, uint8_t
flags );
+
+
+
+
2106 const char* str,
int str_sz,
const char* font_str,
int x_orig,
int y_orig,
+
+
+
+
+
+
+
+
+
+
+
+
+
2148 const char* sect_name,
const char* key_name, uint8_t buffer_type,
+
2149 void* buffer,
size_t buffer_sz_max );
+
+
+
+
2160 const char* sect_name,
const char* key_name, uint8_t buffer_type,
+
2161 void* buffer_out,
size_t buffer_out_sz_max,
+
2162 const void* default_out,
size_t default_out_sz );
+
+
+
+
+
2168MAUG_MHANDLE g_retroflat_state_h = (MAUG_MHANDLE)NULL;
+
+
+
2171#define RETROFLAT_COLOR_TABLE_CONSTS( idx, name_l, name_u, r, g, b ) \
+
2172 MAUG_CONST RETROFLAT_COLOR RETROFLAT_COLOR_ ## name_u = idx;
+
+
2174RETROFLAT_COLOR_TABLE( RETROFLAT_COLOR_TABLE_CONSTS )
+
+
2176#define RETROFLAT_COLOR_TABLE_NAMES( idx, name_l, name_u, r, g, b ) \
+
+
+
2179MAUG_CONST
char* gc_retroflat_color_names[] = {
+
2180 RETROFLAT_COLOR_TABLE( RETROFLAT_COLOR_TABLE_NAMES )
+
+
+
2183# if defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
+
+
+
2187HINSTANCE g_retroflat_instance;
+
2188int g_retroflat_cmd_show;
+
+
2190# ifdef RETROFLAT_WING
+
2191struct RETROFLAT_WING_MODULE g_w;
+
+
+
+
+
+
+
+
+
+
+
+
2203# if defined( RETROFLAT_SOFT_SHAPES ) && !defined( MAUG_NO_AUTO_C )
+
+
+
+
2207# include <retrosft.h>
+
+
+
2210# if defined( RETROFLAT_OPENGL ) && !defined( MAUG_NO_AUTO_C )
+
+
+
+
+
+
2216# include <retrosft.h>
+
+
+
2219# if defined( RETROFLAT_VDP ) && defined( RETROFLAT_OS_UNIX )
+
+
+
+
2223# if defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
+
2225static LRESULT CALLBACK WndProc(
+
2226 HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam
+
+
+
2229# ifndef RETROFLAT_OPENGL
+
2230 HDC hdc_paint = (HDC)NULL;
+
+
2232# if defined( RETROFLAT_OPENGL )
+
2233 int pixel_fmt_int = 0;
+
2234 static PIXELFORMATDESCRIPTOR pixel_fmt = {
+
2235 sizeof( PIXELFORMATDESCRIPTOR ),
+
+
2237 PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
+
+
2239 RETROFLAT_OPENGL_BPP,
+
2240 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+
2242 0, 0, PFD_MAIN_PLANE, 0, 0, 0, 0
+
+
+
+
+
+
+
2249 g_retroflat_state->hdc_win = GetDC( hWnd );
+
+
2251# if defined( RETROFLAT_OPENGL )
+
+
+
2254 ChoosePixelFormat( g_retroflat_state->hdc_win, &pixel_fmt );
+
+
2256 g_retroflat_state->hdc_win, pixel_fmt_int, &pixel_fmt );
+
+
2258 debug_printf( 1,
"setting up OpenGL context..." );
+
+
2260 g_retroflat_state->hrc_win =
+
2261 wglCreateContext( g_retroflat_state->hdc_win );
+
+
2263 FALSE == wglMakeCurrent( g_retroflat_state->hdc_win,
+
2264 g_retroflat_state->hrc_win )
+
+
+
2267 "Error",
"Error creating OpenGL context: %d",
+
+
+
+
+
+
+
+
2275 debug_printf( 1,
"retroflat: creating window buffer (%d x %d)...",
+
2276 g_retroflat_state->screen_w, g_retroflat_state->screen_h );
+
+
+
+
2280 retroflat_create_bitmap(
+
2281 g_retroflat_state->screen_w,
+
2282 g_retroflat_state->screen_h,
+
2283 &(g_retroflat_state->
buffer),
+
+
2285 if( (HDC)NULL == g_retroflat_state->
buffer.hdc_b ) {
+
+
2287 "Error",
"Could not determine buffer device context!" );
+
2288 g_retroflat_state->retval = RETROFLAT_ERROR_GRAPHICS;
+
+
+
+
+
+
+
+
2296 "Error",
"Could not create screen buffer!" );
+
2297 g_retroflat_state->retval = RETROFLAT_ERROR_GRAPHICS;
+
+
+
+
+
+
+
+
+
2306# if defined( RETROFLAT_OPENGL )
+
2307 wglMakeCurrent( g_retroflat_state->hdc_win, NULL );
+
2308 wglDeleteContext( g_retroflat_state->hrc_win );
+
+
+
+
+
+
+
2315# if !defined( RETROFLAT_OPENGL )
+
+
+
+
2319 error_printf(
"screen buffer not ready!" );
+
+
+
+
+
+
2325 hdc_paint = BeginPaint( hWnd, &ps );
+
2326 if( (HDC)NULL == hdc_paint ) {
+
+
2328 "Error",
"Could not determine window device context!" );
+
2329 g_retroflat_state->retval = RETROFLAT_ERROR_GRAPHICS;
+
+
+
+
+
2334# if defined( RETROFLAT_VDP )
+
2335 retroflat_vdp_call(
"retroflat_vdp_flip" );
+
+
+
2338# ifdef RETROFLAT_WING
+
2339 if( (WinGStretchBlt_t)NULL != g_w.WinGStretchBlt ) {
+
+
+
+
2343 g_retroflat_state->screen_w, g_retroflat_state->screen_h,
+
2344 g_retroflat_state->
buffer.hdc_b,
+
+
2346 g_retroflat_state->screen_w,
+
2347 g_retroflat_state->screen_h
+
+
2349# ifdef RETROFLAT_API_WIN32
+
+
+
+
+
+
+
+
2357 g_retroflat_state->screen_w, g_retroflat_state->screen_h,
+
2358 g_retroflat_state->
buffer.hdc_b,
+
+
2360 g_retroflat_state->screen_w,
+
2361 g_retroflat_state->screen_h,
+
+
+
2364# ifdef RETROFLAT_WING
+
+
+
+
2368 DeleteDC( hdc_paint );
+
2369 EndPaint( hWnd, &ps );
+
+
+
+
+
+
+
+
+
+
+
2380 g_retroflat_state->vk_mods |= RETROFLAT_INPUT_MOD_SHIFT;
+
+
+
+
2384 g_retroflat_state->vk_mods |= RETROFLAT_INPUT_MOD_CTRL;
+
+
+
+
+
+
2390 g_retroflat_state->last_key = wParam;
+
+
+
+
+
+
+
+
2398 g_retroflat_state->vk_mods &= ~RETROFLAT_INPUT_MOD_SHIFT;
+
+
+
+
2402 g_retroflat_state->vk_mods |= RETROFLAT_INPUT_MOD_CTRL;
+
+
+
+
+
+
+
+
2410 case WM_LBUTTONDOWN:
+
2411 case WM_RBUTTONDOWN:
+
2412 g_retroflat_state->last_mouse = wParam;
+
2413 g_retroflat_state->last_mouse_x = GET_X_LPARAM( lParam );
+
2414 g_retroflat_state->last_mouse_y = GET_Y_LPARAM( lParam );
+
+
+
+
+
2419 DeleteObject( g_retroflat_state->
buffer.b );
+
+
2421 PostQuitMessage( 0 );
+
+
+
+
2425 retroflat_on_resize( LOWORD( lParam ), HIWORD( lParam ) );
+
+
+
+
+
2430# ifdef RETROFLAT_OPENGL
+
2431 (HGLRC)NULL == g_retroflat_state->hrc_win ||
+
+
+
+
2435 hWnd != g_retroflat_state->window ||
+
2436 NULL == g_retroflat_state->loop_iter
+
+
+
+
+
+
2442 g_retroflat_state->loop_iter( g_retroflat_state->loop_data );
+
+
+
+
2446 g_retroflat_state->last_idc = LOWORD( wParam );
+
+
+
+
2450 return DefWindowProc( hWnd, message, wParam, lParam );
+
+
+
+
+
+
2456LPSTR* retroflat_win_cli( LPSTR cmd_line,
int* argc_out ) {
+
2457 LPSTR* argv_out = NULL;
+
+
+
+
+
+
+
+
+
+
+
2468 debug_printf( 1,
"retroflat: win cli: %s", cmd_line );
+
+
+
+
2472 for( i = 0 ;
'\0' != cmd_line[i - 1] ; i++ ) {
+
2473 if(
' ' != cmd_line[i] &&
'\0' != cmd_line[i] ) {
+
+
2475 }
else if( 0 < i ) {
+
+
2477 if( arg_iter > arg_longest ) {
+
+
2479 arg_longest = arg_iter;
+
+
+
+
+
+
2485 argv_out = calloc( *argc_out,
sizeof(
char* ) );
+
2486 maug_cleanup_if_null_alloc(
char**, argv_out );
+
+
+
2489 argv_out[0] = calloc( 1,
sizeof(
char ) );
+
2490 maug_cleanup_if_null_alloc(
char*, argv_out[0] );
+
+
+
+
2494 for( i = 0 ;
'\0' != cmd_line[i - 1] ; i++ ) {
+
2495 if(
' ' != cmd_line[i] &&
'\0' != cmd_line[i] ) {
+
+
2497 if( 0 < i &&
' ' == cmd_line[i - 1] ) {
+
+
+
+
+
+
+
+
+
2506 if( 0 < i &&
' ' != cmd_line[i - 1] ) {
+
+
2508 assert( NULL == argv_out[arg_idx] );
+
2509 argv_out[arg_idx] = calloc( arg_iter + 1,
sizeof(
char ) );
+
2510 maug_cleanup_if_null_alloc(
char*, argv_out[arg_idx] );
+
2511 strncpy( argv_out[arg_idx], &(cmd_line[arg_start]), arg_iter );
+
+
+
+
+
+
+
+
+
2520 if( MERROR_OK != retval && NULL != argv_out ) {
+
2521 for( i = 0 ; *argc_out > i ; i++ ) {
+
2522 free( argv_out[i] );
+
+
+
+
+
+
+
+
+
+
2532# elif defined( RETROFLAT_API_GLUT )
+
+
2534#ifdef RETROFLAT_OS_OS2
+
+
+
+
+
2539retroflat_glut_display(
void ) {
+
2540 if( NULL != g_retroflat_state->loop_iter ) {
+
2541 g_retroflat_state->loop_iter( g_retroflat_state->loop_data );
+
+
+
+
2545#ifdef RETROFLAT_OS_OS2
+
+
+
+
+
2550retroflat_glut_idle(
void ) {
+
+
+
2553 now = retroflat_get_ms();
+
+
+
+
2557 now < g_retroflat_state->retroflat_next
+
+
+
+
+
2562 glutPostRedisplay();
+
+
2564 if( now + retroflat_fps_next() > now ) {
+
2565 g_retroflat_state->retroflat_next = now + retroflat_fps_next();
+
+
+
2568 g_retroflat_state->retroflat_next = 0;
+
+
+
+
2572#ifdef RETROFLAT_OS_OS2
+
+
+
+
+
2577retroflat_glut_key(
unsigned char key,
int x,
int y ) {
+
2578 g_retroflat_state->retroflat_last_key = key;
+
+
+
+
+
+
+
+
+
+
+
2589# if defined( RETROFLAT_OS_WASM )
+
+
2591 emscripten_cancel_main_loop();
+
2592 emscripten_set_main_loop_arg( loop_iter, data, 0, 0 );
+
+
2594# elif defined( RETROFLAT_API_ALLEGRO ) || \
+
2595 defined( RETROFLAT_API_SDL1 ) || \
+
2596 defined( RETROFLAT_API_SDL2 ) || \
+
2597 defined( RETROFLAT_API_LIBNDS )
+
+
+
+
+
+
+
+
+
+
2607 retroflat_get_ms() < next
+
+
+
2610# ifdef RETROFLAT_API_LIBNDS
+
+
+
+
+
+
2616 now = retroflat_get_ms();
+
2617 if( now + retroflat_fps_next() > now ) {
+
2618 next = now + retroflat_fps_next();
+
+
+
+
+
+
+
+
+
2627# elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
+
+
+
2631 g_retroflat_state->loop_data = (
void*)data;
+
+
+
+
2635 g_retroflat_state->msg_retval =
+
2636 GetMessage( &(g_retroflat_state->msg), 0, 0, 0 );
+
2637 TranslateMessage( &(g_retroflat_state->msg) );
+
2638 DispatchMessage( &(g_retroflat_state->msg) );
+
2639 }
while( 0 < g_retroflat_state->msg_retval );
+
+
2641# elif defined( RETROFLAT_API_GLUT )
+
+
+
2644 g_retroflat_state->loop_data = (
void*)data;
+
+
+
+
2648# warning "loop not implemented"
+
+
+
+
2652 return g_retroflat_state->retval;
+
+
+
+
+
2657char retroflat_vk_to_ascii(
int k, uint8_t flags ) {
+
+
2659 char offset_lower = 0;
+
+
2661 if( RETROFLAT_INPUT_MOD_SHIFT != (RETROFLAT_INPUT_MOD_SHIFT & flags) ) {
+
+
+
2664 if( RETROFLAT_KEY_A <= k && RETROFLAT_KEY_Z >= k ) {
+
+
2666 RETROFLAT_INPUT_FORCE_UPPER !=
+
2667 (RETROFLAT_INPUT_FORCE_UPPER & flags)
+
+
+
2670 offset_lower = 0x20;
+
+
+
+
+
+
+
+
2678 case RETROFLAT_KEY_A: c = 0x41 + offset_lower;
break;
+
2679 case RETROFLAT_KEY_B: c = 0x42 + offset_lower;
break;
+
2680 case RETROFLAT_KEY_C: c = 0x43 + offset_lower;
break;
+
2681 case RETROFLAT_KEY_D: c = 0x44 + offset_lower;
break;
+
2682 case RETROFLAT_KEY_E: c = 0x45 + offset_lower;
break;
+
2683 case RETROFLAT_KEY_F: c = 0x46 + offset_lower;
break;
+
2684 case RETROFLAT_KEY_G: c = 0x47 + offset_lower;
break;
+
2685 case RETROFLAT_KEY_H: c = 0x48 + offset_lower;
break;
+
2686 case RETROFLAT_KEY_I: c = 0x49 + offset_lower;
break;
+
2687 case RETROFLAT_KEY_J: c = 0x4a + offset_lower;
break;
+
2688 case RETROFLAT_KEY_K: c = 0x4b + offset_lower;
break;
+
2689 case RETROFLAT_KEY_L: c = 0x4c + offset_lower;
break;
+
2690 case RETROFLAT_KEY_M: c = 0x4d + offset_lower;
break;
+
2691 case RETROFLAT_KEY_N: c = 0x4e + offset_lower;
break;
+
2692 case RETROFLAT_KEY_O: c = 0x4f + offset_lower;
break;
+
2693 case RETROFLAT_KEY_P: c = 0x50 + offset_lower;
break;
+
2694 case RETROFLAT_KEY_Q: c = 0x51 + offset_lower;
break;
+
2695 case RETROFLAT_KEY_R: c = 0x52 + offset_lower;
break;
+
2696 case RETROFLAT_KEY_S: c = 0x53 + offset_lower;
break;
+
2697 case RETROFLAT_KEY_T: c = 0x54 + offset_lower;
break;
+
2698 case RETROFLAT_KEY_U: c = 0x55 + offset_lower;
break;
+
2699 case RETROFLAT_KEY_V: c = 0x56 + offset_lower;
break;
+
2700 case RETROFLAT_KEY_W: c = 0x57 + offset_lower;
break;
+
2701 case RETROFLAT_KEY_X: c = 0x58 + offset_lower;
break;
+
2702 case RETROFLAT_KEY_Y: c = 0x59 + offset_lower;
break;
+
2703 case RETROFLAT_KEY_Z: c = 0x60 + offset_lower;
break;
+
2704 case RETROFLAT_KEY_0: c = 0x30 + offset_lower;
break;
+
2705 case RETROFLAT_KEY_1: c = offset_lower ? 0x31 :
'!';
break;
+
2706 case RETROFLAT_KEY_2: c = 0x32;
break;
+
2707 case RETROFLAT_KEY_3: c = 0x33;
break;
+
2708 case RETROFLAT_KEY_4: c = 0x34;
break;
+
2709 case RETROFLAT_KEY_5: c = 0x35;
break;
+
2710 case RETROFLAT_KEY_6: c = 0x36;
break;
+
2711 case RETROFLAT_KEY_7: c = 0x37;
break;
+
2712 case RETROFLAT_KEY_8: c = 0x38;
break;
+
2713 case RETROFLAT_KEY_9: c = 0x39;
break;
+
2714 case RETROFLAT_KEY_SPACE: c =
' ';
break;
+
2715 case RETROFLAT_KEY_BKSP: c = 0x08;
break;
+
2716 case RETROFLAT_KEY_ENTER: c =
'\n';
break;
+
2717 case RETROFLAT_KEY_SEMICOLON: c = offset_lower ?
';' :
':';
break;
+
2718 case RETROFLAT_KEY_DASH: c = offset_lower ?
'-' :
'_';
break;
+
2719 case RETROFLAT_KEY_SLASH: c = offset_lower ?
'/' :
'?';
break;
+
2720 case RETROFLAT_KEY_PERIOD: c = offset_lower ?
'.' :
'>';
break;
+
2721 case RETROFLAT_KEY_COMMA: c = offset_lower ?
',' :
'<';
break;
+
+
+
+
+
+
+
+
+
2730 uint8_t flags,
const char* title,
const char* format, ...
+
+
+
+
2734# ifdef RETROFLAT_API_SDL2
+
2735 uint32_t sdl_msg_flags = 0;
+
2736# elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
2737 uint32_t win_msg_flags = 0;
+
+
+
+
2741 va_start( vargs, format );
+
+
+
2744# if defined( RETROFLAT_API_ALLEGRO )
+
2745 allegro_message(
"%s", msg_out );
+
2746# elif defined( RETROFLAT_API_SDL1 )
+
+
2748 error_printf(
"%s", msg_out );
+
2749# elif defined( RETROFLAT_API_SDL2 )
+
2750 switch( (flags & RETROFLAT_MSG_FLAG_TYPE_MASK) ) {
+
2751 case RETROFLAT_MSG_FLAG_ERROR:
+
2752 sdl_msg_flags = SDL_MESSAGEBOX_ERROR;
+
+
+
2755 case RETROFLAT_MSG_FLAG_INFO:
+
2756 sdl_msg_flags = SDL_MESSAGEBOX_INFORMATION;
+
+
+
2759 case RETROFLAT_MSG_FLAG_WARNING:
+
2760 sdl_msg_flags = SDL_MESSAGEBOX_WARNING;
+
+
+
+
2764 SDL_ShowSimpleMessageBox(
+
2765 sdl_msg_flags, title, msg_out, g_retroflat_state->window );
+
2766# elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
2767 switch( (flags & RETROFLAT_MSG_FLAG_TYPE_MASK) ) {
+
2768 case RETROFLAT_MSG_FLAG_ERROR:
+
2769 win_msg_flags |= MB_ICONSTOP;
+
+
+
2772 case RETROFLAT_MSG_FLAG_INFO:
+
2773 win_msg_flags |= MB_ICONINFORMATION;
+
+
+
2776 case RETROFLAT_MSG_FLAG_WARNING:
+
2777 win_msg_flags |= MB_ICONEXCLAMATION;
+
+
+
+
2781 MessageBox( g_retroflat_state->window, msg_out, title, win_msg_flags );
+
2782# elif defined( RETROFLAT_API_GLUT )
+
+
2784 error_printf(
"%s", msg_out );
+
+
2786# warning "not implemented"
+
+
+
+
+
+
2792# ifdef RETROFLAT_SCREENSAVER
+
+
+
+
2796static int retroflat_cli_p(
const char* arg,
struct RETROFLAT_ARGS* args ) {
+
2797 if( 0 == strncmp(
MAUG_CLI_SIGIL "p", arg, MAUG_CLI_SIGIL_SZ + 2 ) ) {
+
+
+
2800 g_retroflat_state->parent = (HWND)atoi( arg );
+
+
+
+
+
2805static int retroflat_cli_s(
const char* arg,
struct RETROFLAT_ARGS* args ) {
+
2806 debug_printf( 3,
"using screensaver mode..." );
+
+
+
+
+
+
+
2813# ifndef RETROFLAT_NO_CLI_SZ
+
+
2815static int retroflat_cli_rfw(
const char* arg,
struct RETROFLAT_ARGS* args ) {
+
2816 if( 0 == strncmp(
MAUG_CLI_SIGIL "rfx", arg, MAUG_CLI_SIGIL_SZ + 4 ) ) {
+
+
+
+
+
+
+
+
2824static int retroflat_cli_rfw_def(
const char* arg,
struct RETROFLAT_ARGS* args ) {
+
+
+
+
+
+
+
2831static int retroflat_cli_rfh(
const char* arg,
struct RETROFLAT_ARGS* args ) {
+
2832 if( 0 == strncmp(
MAUG_CLI_SIGIL "rfy", arg, MAUG_CLI_SIGIL_SZ + 4 ) ) {
+
+
+
+
+
+
+
+
2840static int retroflat_cli_rfh_def(
const char* arg,
struct RETROFLAT_ARGS* args ) {
+
+
+
+
+
+
+
+
+
2849# ifndef MAUG_NO_CONFIG
+
+
2851static int retroflat_cli_c(
const char* arg,
struct RETROFLAT_ARGS* args ) {
+
2852 if( 0 == strncmp(
MAUG_CLI_SIGIL "rfc", arg, MAUG_CLI_SIGIL_SZ + 4 ) ) {
+
+
+
2855 debug_printf( 1,
"setting config path to: %s", arg );
+
+
+
+
+
+
2861static int retroflat_cli_c_def(
const char* arg,
struct RETROFLAT_ARGS* args ) {
+
+
+
+
2865 debug_printf( 1,
"setting config path to: %s", args->
config_path );
+
+
2867 g_retroflat_state->config_path,
+
+
+
2870 debug_printf( 1,
"setting config path to: %s%s",
+
2871 args->
title, RETROFLAT_CONFIG_EXT );
+
+
+
+
2875 g_retroflat_state->config_path,
+
+
+
+
+
+
+
+
+
2884# ifdef RETROFLAT_VDP
+
2885static int retroflat_cli_vdp(
const char* arg,
struct RETROFLAT_ARGS* args ) {
+
2886 if( 0 == strncmp(
MAUG_CLI_SIGIL "vdp", arg, MAUG_CLI_SIGIL_SZ + 4 ) ) {
+
+
+
+
2890 debug_printf( 1,
"VDP args: %s", g_retroflat_state->
vdp_args );
+
+
+
+
+
+
2896static int retroflat_cli_u(
const char* arg,
struct RETROFLAT_ARGS* args ) {
+
2897 if( 0 == strncmp(
MAUG_CLI_SIGIL "rfu", arg, MAUG_CLI_SIGIL_SZ + 4 ) ) {
+
2898 debug_printf( 1,
"unlocking FPS..." );
+
+
+
+
+
+
2904static int retroflat_cli_u_def(
const char* arg,
struct RETROFLAT_ARGS* args ) {
+
2905 args->flags &= ~RETROFLAT_FLAGS_UNLOCK_FPS;
+
+
+
+
+
+
2911# ifdef RETROFLAT_API_ALLEGRO
+
+
+
+
2915void retroflat_on_ms_tick() {
+
2916 if( NULL == g_retroflat_state ) {
+
2917 debug_printf( 1,
"no state!" );
+
+
2919 g_retroflat_state->ms++;
+
+
+
+
2923void retroflat_on_close_button() {
+
2924 g_retroflat_state->close_button = 1;
+
+
2926END_OF_FUNCTION( retroflat_on_close_button )
+
+
+
+
+
+
+
+
+
+
+
+
+
2939# if defined( RETROFLAT_API_ALLEGRO ) && defined( RETROFLAT_OS_DOS )
+
+
+
+
+
2944# elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
2945 WNDCLASS wc = { 0 };
+
2946 RECT wr = { 0, 0, 0, 0 };
+
2947 DWORD window_style = RETROFLAT_WIN_STYLE;
+
2948 DWORD window_style_ex = 0;
+
2949 int wx = CW_USEDEFAULT,
+
+
2951# elif defined( RETROFLAT_API_SDL1 )
+
2952 const SDL_VideoInfo* info = NULL;
+
2953# if defined( RETROFLAT_OPENGL )
+
+
+
+
2957# elif defined( RETROFLAT_API_LIBNDS )
+
+
2959# elif defined( RETROFLAT_API_GLUT )
+
2960 unsigned int glut_init_flags = 0;
+
+
+
2963# if defined( RETROFLAT_API_SDL1 ) || defined( RETROFLAT_API_SDL2 )
+
2964# if defined( RETROFLAT_SDL_ICO )
+
2965 SDL_Surface* icon = NULL;
+
+
+
+
2969 debug_printf( 1,
"retroflat: initializing..." );
+
+
+
2972 assert( 4 ==
sizeof( uint32_t ) );
+
2973 assert( 4 ==
sizeof( int32_t ) );
+
2974 assert( 2 ==
sizeof( uint16_t ) );
+
2975 assert( 2 ==
sizeof( int16_t ) );
+
2976 assert( 1 ==
sizeof( uint8_t ) );
+
2977 assert( 1 ==
sizeof( int8_t ) );
+
2978 assert( NULL != args );
+
+
2980 debug_printf( 1,
"retroflat: allocating state (" SIZE_T_FMT
" bytes",
+
+
+
2983 g_retroflat_state_h = maug_malloc( 1,
sizeof(
struct RETROFLAT_STATE ) );
+
2984 if( (MAUG_MHANDLE)NULL == g_retroflat_state_h ) {
+
+
2986 "Error",
"Could not allocate global state!" );
+
2987 retval = MERROR_ALLOC;
+
+
+
+
2991 maug_mlock( g_retroflat_state_h, g_retroflat_state );
+
2992 if( (MAUG_MHANDLE)NULL == g_retroflat_state ) {
+
+
2994 "Error",
"Could not lock global state!" );
+
2995 retval = MERROR_ALLOC;
+
+
+
+
+
3000 debug_printf( 1,
"retroflat: parsing args..." );
+
+
+
+
3004# ifdef RETROFLAT_SCREENSAVER
+
+
3006 "Preview screensaver", 0, (maug_cli_cb)retroflat_cli_p, NULL, args );
+
+
3008 "Launch screensaver", 0, (maug_cli_cb)retroflat_cli_s, NULL, args );
+
+
+
3011# ifndef RETROFLAT_NO_CLI_SZ
+
+
3013 "Set the screen width.", 0,
+
3014 (maug_cli_cb)retroflat_cli_rfw,
+
3015 (maug_cli_cb)retroflat_cli_rfw_def, args );
+
+
3017 "Set the screen height.", 0,
+
3018 (maug_cli_cb)retroflat_cli_rfh,
+
3019 (maug_cli_cb)retroflat_cli_rfh_def, args );
+
+
+
3022# ifdef RETROFLAT_VDP
+
+
3024 "Pass a string of args to the VDP.", 0,
+
3025 (maug_cli_cb)retroflat_cli_vdp, NULL, args );
+
+
+
3028# ifndef MAUG_NO_CONFIG
+
+
3030 "Set the config path.", 0,
+
3031 (maug_cli_cb)retroflat_cli_c, (maug_cli_cb)retroflat_cli_c_def, args );
+
+
+
+
+
3036 (maug_cli_cb)retroflat_cli_u, (maug_cli_cb)retroflat_cli_u_def, args );
+
+
+
3039 retval = maug_parse_args( argc, argv );
+
+
+
+
+
+
+
+
+
+
+
3050 debug_printf( 1,
"retroflat: setting config..." );
+
+
+
+
+
3055 strncpy( g_retroflat_state->assets_path,
+
+
+
+
3059# if defined( RETROFLAT_SCREENSAVER )
+
+
+
+
+
+
+
+
+
+
+
+
+
3072 g_retroflat_state->screen_v_w = args->
screen_w;
+
3073 g_retroflat_state->screen_v_h = args->
screen_h;
+
3074 g_retroflat_state->screen_w = args->
screen_w;
+
3075 g_retroflat_state->screen_h = args->
screen_h;
+
+
3077# ifdef RETROFLAT_OPENGL
+
3078 debug_printf( 1,
"setting up texture palette..." );
+
3079# define RETROFLAT_COLOR_TABLE_TEX( idx, name_l, name_u, r, g, b ) \
+
3080 g_retroflat_state->tex_palette[idx][0] = r; \
+
3081 g_retroflat_state->tex_palette[idx][1] = g; \
+
3082 g_retroflat_state->tex_palette[idx][2] = b;
+
3083 RETROFLAT_COLOR_TABLE( RETROFLAT_COLOR_TABLE_TEX )
+
+
+
3086# ifdef RETROFLAT_API_ALLEGRO
+
+
+
+
3090 srand( time( NULL ) );
+
+
3092 if( allegro_init() ) {
+
3093 allegro_message(
"could not setup allegro!" );
+
3094 retval = RETROFLAT_ERROR_ENGINE;
+
+
+
+
+
3099# if !defined( RETROFLAT_OS_DOS )
+
+
+
3102 install_int( retroflat_on_ms_tick, 1 );
+
+
+
3105# ifdef RETROFLAT_OS_DOS
+
+
+
+
+
+
+
+
+
+
+
+
3117 allegro_message(
"could not setup graphics!" );
+
3118 retval = RETROFLAT_ERROR_GRAPHICS;
+
+
+
+
3122# define RETROFLAT_COLOR_TABLE_ALLEGRO_INIT( i, name_l, name_u, r, g, b ) \
+
3123 g_retroflat_state->palette[i] = makecol( r, g, b );
+
+
3125 RETROFLAT_COLOR_TABLE( RETROFLAT_COLOR_TABLE_ALLEGRO_INIT )
+
+
3127 LOCK_FUNCTION( retroflat_on_close_button );
+
3128 set_close_button_callback( retroflat_on_close_button );
+
+
3130# ifndef RETROFLAT_OS_DOS
+
3131 if( NULL != args->
title ) {
+
3132 retroflat_set_title( args->
title );
+
+
+
+
3136 if( 0 > install_mouse() ) {
+
3137 allegro_message(
"could not setup mouse!" );
+
3138 retval = RETROFLAT_ERROR_MOUSE;
+
+
+
+
+
3143# ifdef RETROFLAT_OS_DOS
+
+
+
+
+
3148 regs.x.edx = FP_OFF( g_retroflat_state->mouse_cursor );
+
3149 sregs.es = FP_SEG( g_retroflat_state->mouse_cursor );
+
3150 int386x( 0x33, ®s, ®s, &sregs );
+
+
+
+
3154 g_retroflat_state->
buffer.b =
+
+
3156 maug_cleanup_if_null(
+
3157 BITMAP*, g_retroflat_state->
buffer.b, RETROFLAT_ERROR_GRAPHICS );
+
+
3159# elif defined( RETROFLAT_API_SDL1 )
+
+
+
+
3163 srand( time( NULL ) );
+
+
3165 if( SDL_Init( SDL_INIT_VIDEO ) ) {
+
+
3167 "Error",
"Error initializing SDL: %s", SDL_GetError() );
+
3168 retval = RETROFLAT_ERROR_ENGINE;
+
+
+
+
3172 info = SDL_GetVideoInfo();
+
3173 maug_cleanup_if_null_alloc( SDL_VideoInfo*, info );
+
+
+
3176# ifdef RETROFLAT_OPENGL
+
3177# define RETROFLAT_COLOR_TABLE_SDL( idx, name_l, name_u, r, g, b ) \
+
3178 g_retroflat_state->palette[idx] = RETROGLU_COLOR_ ## name_u;
+
+
3180# define RETROFLAT_COLOR_TABLE_SDL( idx, name_l, name_u, rd, gd, bd ) \
+
3181 g_retroflat_state->palette[idx].r = rd; \
+
3182 g_retroflat_state->palette[idx].g = gd; \
+
3183 g_retroflat_state->palette[idx].b = bd;
+
+
3185 RETROFLAT_COLOR_TABLE( RETROFLAT_COLOR_TABLE_SDL )
+
+
3187# ifdef RETROFLAT_OPENGL
+
+
+
+
3191 SDL_GL_SetAttribute( SDL_GL_SWAP_CONTROL, 0 );
+
+
3193 SDL_GL_SetAttribute( SDL_GL_RED_SIZE, 5 );
+
3194 SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, 5 );
+
3195 SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, 5 );
+
+
+
3198 gl_retval = SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, gl_depth );
+
+
3200 error_printf(
"unable to set depth buffer to %d!", gl_depth );
+
+
+
3203 }
while( gl_retval );
+
3204 SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
+
+
+
3207 if( NULL != args->
title ) {
+
3208 retroflat_set_title( args->
title );
+
+
+
3211# ifdef RETROFLAT_SDL_ICO
+
3212 debug_printf( 1,
"setting SDL window icon..." );
+
3213 icon = SDL_LoadBMP_RW(
+
3214 SDL_RWFromConstMem( obj_ico_sdl_ico_bmp,
+
3215 obj_ico_sdl_ico_bmp_len ), 1 );
+
+
3217 SDL_WM_SetIcon( icon, 0 );
+
+
+
3220 g_retroflat_state->
buffer.surface = SDL_SetVideoMode(
+
+
3222 SDL_DOUBLEBUF | SDL_HWSURFACE | SDL_ANYFORMAT
+
3223# ifdef RETROFLAT_OPENGL
+
+
+
+
3227 maug_cleanup_if_null(
+
3228 SDL_Surface*, g_retroflat_state->
buffer.surface,
+
3229 RETROFLAT_ERROR_GRAPHICS );
+
+
+
+
+
+
3235 if( 0 != SDL_EnableKeyRepeat(
+
3236 1, SDL_DEFAULT_REPEAT_INTERVAL
+
+
3238 error_printf(
"could not enable key repeat!" );
+
+
3240 debug_printf( 3,
"key repeat enabled" );
+
+
+
+
3244# elif defined( RETROFLAT_API_SDL2 )
+
+
+
+
3248 srand( time( NULL ) );
+
+
3250 if( SDL_Init( SDL_INIT_VIDEO ) ) {
+
+
3252 "Error",
"Error initializing SDL: %s", SDL_GetError() );
+
3253 retval = RETROFLAT_ERROR_ENGINE;
+
+
+
+
+
3258# ifdef RETROFLAT_OPENGL
+
3259# define RETROFLAT_COLOR_TABLE_SDL( idx, name_l, name_u, r, g, b ) \
+
3260 g_retroflat_state->palette[idx] = RETROGLU_COLOR_ ## name_u;
+
+
3262# define RETROFLAT_COLOR_TABLE_SDL( idx, name_l, name_u, rd, gd, bd ) \
+
3263 g_retroflat_state->palette[idx].r = rd; \
+
3264 g_retroflat_state->palette[idx].g = gd; \
+
3265 g_retroflat_state->palette[idx].b = bd;
+
+
3267 RETROFLAT_COLOR_TABLE( RETROFLAT_COLOR_TABLE_SDL )
+
+
+
3270 g_retroflat_state->window = SDL_CreateWindow( args->
title,
+
3271 SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
+
+
3273 maug_cleanup_if_null( SDL_Window*, g_retroflat_state->window, RETROFLAT_ERROR_GRAPHICS );
+
+
+
3276 g_retroflat_state->
buffer.renderer = SDL_CreateRenderer(
+
3277 g_retroflat_state->window, -1,
+
3278 SDL_RENDERER_ACCELERATED | SDL_RENDERER_TARGETTEXTURE );
+
3279 maug_cleanup_if_null(
+
3280 SDL_Renderer*, g_retroflat_state->
buffer.renderer,
+
3281 RETROFLAT_ERROR_GRAPHICS );
+
+
+
3284 g_retroflat_state->
buffer.texture =
+
3285 SDL_CreateTexture( g_retroflat_state->
buffer.renderer,
+
3286 SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET,
+
3287 g_retroflat_state->screen_w, g_retroflat_state->screen_h );
+
+
3289# ifdef RETROFLAT_SDL_ICO
+
3290 debug_printf( 1,
"setting SDL window icon..." );
+
3291 icon = SDL_LoadBMP_RW(
+
3292 SDL_RWFromConstMem( obj_ico_sdl_ico_bmp,
+
3293 obj_ico_sdl_ico_bmp_len ), 1 );
+
+
3295 SDL_SetWindowIcon( g_retroflat_state->window, icon );
+
+
+
3298# elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
+
+
+
3302# ifdef RETROFLAT_API_WINCE
+
3303 srand( GetTickCount() );
+
+
3305 srand( time( NULL ) );
+
+
+
+
+
3310# ifdef RETROFLAT_OPENGL
+
3311# define RETROFLAT_COLOR_TABLE_WIN( idx, name_l, name_u, r, g, b ) \
+
3312 g_retroflat_state->palette[idx] = RETROGLU_COLOR_ ## name_u;
+
+
3314# define RETROFLAT_COLOR_TABLE_WIN( idx, name_l, name_u, r, g, b ) \
+
3315 g_retroflat_state->palette[idx] = RGB( r, g, b );
+
+
+
3318 RETROFLAT_COLOR_TABLE( RETROFLAT_COLOR_TABLE_WIN )
+
+
3320# ifdef RETROFLAT_WING
+
3321 debug_printf( 3,
"attempting to link WinG..." );
+
+
3323# ifdef RETROFLAT_API_WIN32
+
3324 g_w.module = LoadLibrary(
"wing32.dll" );
+
3325 if( (HMODULE)NULL == g_w.module ) {
+
3326# elif defined( RETROFLAT_API_WIN16 )
+
3327 g_w.module = LoadLibrary(
"wing.dll" );
+
3328 if( HINSTANCE_ERROR == g_w.module ) {
+
+
+
+
+
+
3334# ifdef RETROFLAT_API_WIN32
+
3335# define RETROFLAT_WING_LLTABLE_LOAD_PROC( retval, proc, ord ) \
+
3336 g_w.proc = (proc ## _t)GetProcAddress( g_w.module, #proc ); \
+
3337 if( (proc ## _t)NULL == g_w.proc ) { \
+
+
+
3340# elif defined( RETROFLAT_API_WIN16 )
+
3341# define RETROFLAT_WING_LLTABLE_LOAD_PROC( retval, proc, ord ) \
+
3342 g_w.proc = (proc ## _t)GetProcAddress( \
+
3343 g_w.module, MAKEINTRESOURCE( ord ) ); \
+
3344 if( (proc ## _t)NULL == g_w.proc ) { \
+
3345 retroflat_message( \
+
3346 RETROFLAT_MSG_FLAG_ERROR, "Error", \
+
3347 "Unable to link WinG proc: %s", #proc ); \
+
+
+
+
+
3352 RETROFLAT_WING_LLTABLE( RETROFLAT_WING_LLTABLE_LOAD_PROC )
+
+
+
+
3356 if( !g_w.success ) {
+
+
3358 "Error",
"Unable to link WinG!" );
+
+
+
+
3362 debug_printf( 1,
"retroflat: creating window class..." );
+
+
+
3365 wr.right = g_retroflat_state->screen_v_w;
+
3366 wr.bottom = g_retroflat_state->screen_v_h;
+
3367# ifndef RETROFLAT_API_WINCE
+
3368 AdjustWindowRect( &wr, RETROFLAT_WIN_STYLE, FALSE );
+
+
+
+
+
3373 memset( &wc,
'\0',
sizeof( WNDCLASS ) );
+
+
3375 wc.lpfnWndProc = (WNDPROC)&WndProc;
+
3376 wc.hInstance = g_retroflat_instance;
+
3377# ifdef RETROFLAT_ICO_RES_ID
+
3378 wc.hIcon = LoadIcon(
+
3379 g_retroflat_instance, MAKEINTRESOURCE( RETROFLAT_ICO_RES_ID ) );
+
+
3381 wc.hCursor = LoadCursor( 0, IDC_ARROW );
+
3382 wc.hbrBackground = (HBRUSH)( COLOR_BTNFACE + 1 );
+
+
+
+
3386 if( !RegisterClass( &wc ) ) {
+
+
3388 "Error",
"Could not register window class!" );
+
+
+
+
3392 debug_printf( 1,
"retroflat: creating window..." );
+
+
3394# ifdef RETROFLAT_SCREENSAVER
+
3395 if( (HWND)0 != g_retroflat_state->parent ) {
+
+
3397 debug_printf( 1,
"retroflat: using window parent: " UPRINTF_U32,
+
3398 g_retroflat_state->parent );
+
3399 window_style = WS_CHILD;
+
3400 GetClientRect( g_retroflat_state->parent, &wr );
+
+
+
+
+
+
3406 window_style_ex = WS_EX_TOPMOST;
+
3407 window_style = WS_POPUP | WS_VISIBLE;
+
+
+
+
+
3412 wr.right = GetSystemMetrics( SM_CXSCREEN );
+
3413 wr.bottom = GetSystemMetrics( SM_CYSCREEN );
+
+
+
+
3417 g_retroflat_state->window = CreateWindowEx(
+
+
+
3420# ifdef RETROFLAT_API_WINCE
+
3421 0, 0, CW_USEDEFAULT, CW_USEDEFAULT,
+
+
+
3424 wr.right - wr.left, wr.bottom - wr.top,
+
+
3426# ifdef RETROFLAT_SCREENSAVER
+
3427 g_retroflat_state->parent
+
+
+
+
3431 , 0, g_retroflat_instance, 0
+
+
+
3434# ifdef RETROFLAT_API_WINCE
+
+
3436 GetClientRect( g_retroflat_state->window, &wr );
+
3437 g_retroflat_state->screen_v_w = wr.right - wr.left;
+
3438 g_retroflat_state->screen_v_h = wr.bottom - wr.top;
+
+
+
3441 if( !g_retroflat_state->window ) {
+
+
3443 "Error",
"Could not create window!" );
+
3444 retval = RETROFLAT_ERROR_GRAPHICS;
+
+
+
+
3448 maug_cleanup_if_null_alloc( HWND, g_retroflat_state->window );
+
+
3450 debug_printf( 1,
"setting up graphics timer every %d ms...",
+
+
+
+
+
+
3456 "Error",
"Could not create graphics timer!" );
+
3457 retval = RETROFLAT_ERROR_TIMER;
+
+
+
+
3461#ifndef RETROFLAT_OPENGL
+
3462 RETROFLAT_COLOR_TABLE( RETROFLAT_COLOR_TABLE_WIN_BRSET )
+
3463 RETROFLAT_COLOR_TABLE( RETROFLAT_COLOR_TABLE_WIN_PNSET )
+
+
+
3466 ShowWindow( g_retroflat_state->window, g_retroflat_cmd_show );
+
+
3468# elif defined( RETROFLAT_API_LIBNDS )
+
+
+
+
+
3473# define RETROFLAT_COLOR_TABLE_NDS_RGBS_INIT( idx, name_l, name_u, r, g, b ) \
+
3474 g_retroflat_state->palette[idx] = ARGB16( 1, r, g, b );
+
3475 RETROFLAT_COLOR_TABLE( RETROFLAT_COLOR_TABLE_NDS_RGBS_INIT )
+
+
+
+
+
+
3481 powerOn( POWER_ALL );
+
+
3483# ifdef RETROFLAT_OPENGL
+
+
3485 debug_printf( 3,
"setting up GL subsystem..." );
+
+
3487 videoSetMode( MODE_0_3D );
+
+
3489 vramSetBankA( VRAM_A_TEXTURE );
+
+
+
+
+
+
+
3496 videoSetMode( MODE_5_2D );
+
3497 videoSetModeSub( MODE_0_2D );
+
+
+
3500 vramSetBankA( VRAM_A_MAIN_BG );
+
3501 vramSetBankB( VRAM_B_MAIN_SPRITE );
+
+
+
3504 vramSetBankC( VRAM_C_MAIN_BG );
+
3505 vramSetBankD( VRAM_D_SUB_SPRITE );
+
+
3507 bgExtPaletteEnable();
+
+
+
+
+
3512 g_retroflat_state->bg_id = bgInit( 0, BgType_Text8bpp, BgSize_T_256x256, 2, 7 );
+
3513 dmaFillWords( 0, g_retroflat_state->bg_tiles,
sizeof( g_retroflat_state->bg_tiles ) );
+
3514 bgSetPriority( g_retroflat_state->bg_id, 2 );
+
+
+
3517 g_retroflat_state->window_id = bgInit( 1, BgType_Text8bpp, BgSize_T_256x256, 3, 0 );
+
3518 dmaFillWords( 0, g_retroflat_state->window_tiles,
sizeof( g_retroflat_state->window_tiles ) );
+
3519 bgSetPriority( g_retroflat_state->window_id, 1 );
+
+
+
3522 g_retroflat_state->px_id = bgInit( 2, BgType_Bmp16, BgSize_B16_256x256, 1, 0 );
+
3523 bgSetPriority( g_retroflat_state->px_id, 0 );
+
+
+
+
+
+
+
3530 g_retroflat_state->sprite_frames[i] = oamAllocateGfx(
+
+
+
+
+
+
+
3537 TIMER0_CR = TIMER_ENABLE | TIMER_DIV_1024;
+
3538 TIMER1_CR = TIMER_ENABLE | TIMER_CASCADE;
+
+
3540# elif defined( RETROFLAT_API_GLUT )
+
+
+
+
3544# define RETROFLAT_COLOR_TABLE_GLUT( idx, name_l, name_u, rd, gd, bd ) \
+
3545 g_retroflat_state->palette[idx] = RETROGLU_COLOR_ ## name_u;
+
+
3547 RETROFLAT_COLOR_TABLE( RETROFLAT_COLOR_TABLE_GLUT )
+
+
3549 glutInit( &argc, argv );
+
3550 glut_init_flags = GLUT_DEPTH | GLUT_RGBA;
+
+
+
+
3554 glut_init_flags |= GLUT_DOUBLE;
+
+
3556 glutInitDisplayMode( glut_init_flags );
+
+
3558 g_retroflat_state->screen_v_w, g_retroflat_state->screen_v_h );
+
3559 glutCreateWindow( args->
title );
+
3560 glutIdleFunc( retroflat_glut_idle );
+
3561 glutDisplayFunc( retroflat_glut_display );
+
3562 glutKeyboardFunc( retroflat_glut_key );
+
+
+
3565# warning "init not implemented"
+
+
+
3568# if defined( RETROFLAT_SOFT_SHAPES )
+
3569 retval = retrosoft_init();
+
3570 maug_cleanup_if_not_ok();
+
+
+
3573# if defined( RETROFLAT_OPENGL )
+
3574 retval = retrosoft_init();
+
3575 maug_cleanup_if_not_ok();
+
3576 retval = retroglu_init_glyph_tex();
+
3577 maug_cleanup_if_not_ok();
+
+
+
3580# ifdef RETROFLAT_VDP
+
3581# if defined( RETROFLAT_OS_UNIX )
+
3582 g_retroflat_state->
vdp_exe = dlopen(
+
3583# ifdef RETROFLAT_API_SDL1
+
+
3585# elif defined( RETROFLAT_API_SDL2 )
+
+
+
3588# error
"rvdp .so undefined!"
+
+
+
3591# elif defined( RETROFLAT_OS_WIN )
+
3592 g_retroflat_state->
vdp_exe = LoadLibrary(
+
3593# ifdef RETROFLAT_API_SDL1
+
+
3595# elif defined( RETROFLAT_API_SDL2 )
+
+
3597# elif defined( RETROFLAT_API_WIN32 )
+
+
+
3600# error
"rvdp .so undefined!"
+
+
+
+
3604# error "dlopen undefined!"
+
+
+
3607 if( !(g_retroflat_state->
vdp_exe) ) {
+
3608 error_printf(
"not loading VDP" );
+
+
+
+
+
+
3614 debug_printf( 1,
"creating VDP buffer, %d x %d",
+
3615 g_retroflat_state->screen_v_w, g_retroflat_state->screen_v_h );
+
+
+
3618 maug_cleanup_if_null_alloc(
+
+
3620 retval = retroflat_create_bitmap(
+
3621 g_retroflat_state->screen_v_w, g_retroflat_state->screen_v_h,
+
+
3623 maug_cleanup_if_not_ok();
+
+
3625 debug_printf( 1,
"initializing VDP..." );
+
3626 retval = retroflat_vdp_call(
"retroflat_vdp_init" );
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
3641# if defined( RETROFLAT_VDP )
+
3642 if( NULL != g_retroflat_state->
vdp_exe ) {
+
3643 retroflat_vdp_call(
"retroflat_vdp_shutdown" );
+
3644# ifdef RETROFLAT_OS_UNIX
+
3645 dlclose( g_retroflat_state->
vdp_exe );
+
3646# elif defined( RETROFLAT_OS_WIN )
+
3647 FreeLibrary( g_retroflat_state->
vdp_exe );
+
+
3649# error "dlclose undefined!"
+
+
+
+
3653 if( NULL != g_retroflat_state->
vdp_buffer ) {
+
+
+
+
+
+
3659# if defined( RETROFLAT_SOFT_SHAPES )
+
3660 retrosoft_shutdown();
+
+
+
3663# if defined( RETROFLAT_OS_WASM )
+
+
+
3666# elif defined( RETROFLAT_API_ALLEGRO )
+
+
3668# ifdef RETROFLAT_VDP
+
+
+
+
+
+
3674 if( RETROFLAT_ERROR_ENGINE != retval ) {
+
+
+
+
+
+
3680# elif defined( RETROFLAT_API_SDL1 ) || defined( RETROFLAT_API_SDL2 )
+
+
+
+
3684# ifndef RETROFLAT_API_SDL1
+
3685 SDL_DestroyWindow( g_retroflat_state->window );
+
+
+
+
+
3690# elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
+
+
+
3694 if( (HDC)NULL != g_retroflat_state->
buffer.hdc_b ) {
+
+
+
3697 g_retroflat_state->
buffer.hdc_b,
+
3698 g_retroflat_state->
buffer.old_hbm_b );
+
3699 DeleteDC( g_retroflat_state->
buffer.hdc_b );
+
3700 g_retroflat_state->
buffer.hdc_b = (HDC)NULL;
+
+
+
+
+
+
3706# ifndef RETROFLAT_OPENGL
+
3707 RETROFLAT_COLOR_TABLE( RETROFLAT_COLOR_TABLE_WIN_BRRM )
+
3708 RETROFLAT_COLOR_TABLE( RETROFLAT_COLOR_TABLE_WIN_PENRM )
+
+
+
3711# ifdef RETROFLAT_WING
+
3712 if( (HMODULE)NULL != g_w.module ) {
+
3713 FreeLibrary( g_w.module );
+
+
+
+
3717 if( (HDC)NULL != g_retroflat_state->hdc_win ) {
+
3718 ReleaseDC( g_retroflat_state->window, g_retroflat_state->hdc_win );
+
+
+
3721# elif defined( RETROFLAT_API_GLUT )
+
+
+
+
+
3726# warning "shutdown not implemented"
+
+
+
3729 maug_munlock( g_retroflat_state_h, g_retroflat_state );
+
3730 maug_mfree( g_retroflat_state );
+
+
+
+
+
+
3736# ifdef RETROFLAT_VDP
+
+
+
+
+
3741# ifdef RETROFLAT_OS_WIN
+
3742 char proc_name_ex[256];
+
+
+
3745 if( NULL == g_retroflat_state->
vdp_exe ) {
+
+
+
+
3749# ifdef RETROFLAT_OS_UNIX
+
3750 vdp_proc = dlsym( g_retroflat_state->
vdp_exe, proc_name );
+
3751# elif defined( RETROFLAT_OS_WIN )
+
+
3753 maug_snprintf( proc_name_ex, 255,
"%s_", proc_name );
+
+
3755 g_retroflat_state->
vdp_exe, proc_name_ex );
+
+
3757# error "dlsym undefined!"
+
+
+
+
+
+
3763# ifdef RETROFLAT_OS_WIN
+
+
+
+
+
+
3769 0 == strcmp(
"retroflat_vdp_flip", proc_name ) &&
+
+
+
+
3773 retroflat_px_lock( &(g_retroflat_state->
buffer) );
+
3774 retroflat_px_lock( g_retroflat_state->
vdp_buffer );
+
+
+
3777 retval = vdp_proc( g_retroflat_state );
+
+
+
3780 0 == strcmp(
"retroflat_vdp_flip", proc_name ) &&
+
+
+
+
3784 retroflat_px_release( &(g_retroflat_state->
buffer) );
+
3785 retroflat_px_release( g_retroflat_state->
vdp_buffer );
+
+
+
3788# ifdef RETROFLAT_OS_WIN
+
3789 retroflat_draw_release( g_retroflat_state->
vdp_buffer );
+
+
+
+
+
+
+
+
+
+
+
3800void retroflat_set_title(
const char* format, ... ) {
+
3801 char title[RETROFLAT_TITLE_MAX + 1];
+
+
+
+
3805 va_start( vargs, format );
+
3806 memset( title,
'\0', RETROFLAT_TITLE_MAX + 1 );
+
3807 maug_vsnprintf( title, RETROFLAT_TITLE_MAX, format, vargs );
+
+
3809#if defined( RETROFLAT_API_ALLEGRO )
+
3810 set_window_title( title );
+
3811#elif defined( RETROFLAT_API_SDL1 )
+
3812 SDL_WM_SetCaption( title, NULL );
+
3813#elif defined( RETROFLAT_API_SDL2 )
+
3814 SDL_SetWindowTitle( g_retroflat_state->window, title );
+
3815#elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
3816 SetWindowText( g_retroflat_state->window, title );
+
3817#elif defined( RETROFLAT_API_LIBNDS )
+
+
3819#elif defined( RETROFLAT_API_GLUT )
+
3820 glutSetWindowTitle( title );
+
+
3822# warning "set title implemented"
+
+
+
+
+
+
+
+
3830uint32_t retroflat_get_ms() {
+
3831# if defined( RETROFLAT_API_ALLEGRO )
+
+
+
+
3835 return g_retroflat_state->ms;
+
+
3837# elif defined( RETROFLAT_API_SDL1 ) || defined( RETROFLAT_API_SDL2 )
+
+
+
+
3841 return SDL_GetTicks();
+
+
3843# elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
+
3845 return timeGetTime();
+
+
3847# elif defined( RETROFLAT_API_LIBNDS )
+
+
+
+
3851 return ((TIMER1_DATA * (1 << 16)) + TIMER0_DATA) / 32;
+
+
3853# elif defined( RETROFLAT_API_GLUT )
+
+
+
+
3857 return glutGet( GLUT_ELAPSED_TIME );
+
+
+
3860# warning "get_ms not implemented"
+
+
+
+
+
+
3866uint32_t retroflat_get_rand() {
+
+
+
+
+
+
+
+
+
3875# if defined( RETROFLAT_OPENGL )
+
+
+
+
3879 &(g_retroflat_state->
buffer) != bmp &&
+
3880 (MAUG_MHANDLE)NULL != bmp->tex.bytes_h
+
+
3882 bmp->
flags |= RETROFLAT_FLAGS_LOCK;
+
3883 maug_mlock( bmp->tex.bytes_h, bmp->tex.bytes );
+
+
+
3886# elif defined( RETROFLAT_API_ALLEGRO )
+
+
+
+
+
+
+
+
+
+
+
3897# ifdef RETROFLAT_MOUSE
+
+
+
+
+
+
+
+
3905# elif defined( RETROFLAT_API_SDL1 )
+
+
+
+
+
+
+
+
3913 if( NULL == bmp || &(g_retroflat_state->
buffer) == bmp ) {
+
+
3915 bmp = &(g_retroflat_state->
buffer);
+
+
+
3918 RETROFLAT_FLAGS_SCREEN_LOCK !=
+
3919 (RETROFLAT_FLAGS_SCREEN_LOCK & bmp->
flags)
+
+
+
+
+
3924 bmp->
flags |= RETROFLAT_FLAGS_SCREEN_LOCK;
+
+
+
+
3928 assert( 0 == (RETROFLAT_FLAGS_LOCK & bmp->
flags) );
+
3929 bmp->
flags |= RETROFLAT_FLAGS_LOCK;
+
+
+
+
+
3934 assert( 0 == (RETROFLAT_FLAGS_LOCK & bmp->
flags) );
+
3935 bmp->
flags |= RETROFLAT_FLAGS_LOCK;
+
+
+
3938# elif defined( RETROFLAT_API_SDL2 )
+
+
+
+
+
+
3944# ifdef RETROFLAT_VDP
+
+
+
+
+
+
3950 SDL_SetRenderTarget(
+
3951 g_retroflat_state->
buffer.renderer,
+
3952 g_retroflat_state->
buffer.texture );
+
+
+
+
3956# ifdef RETROFLAT_VDP
+
3957 }
else if( NULL == bmp && NULL != g_retroflat_state->
vdp_buffer ) {
+
+
+
+
+
+
3963 assert( NULL == bmp->renderer );
+
3964 assert( NULL != bmp->surface );
+
3965 bmp->renderer = SDL_CreateSoftwareRenderer( bmp->surface );
+
+
+
+
3969# elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
+
+
+
+
3974# ifdef RETROFLAT_VDP
+
3975 if( NULL != g_retroflat_state->
vdp_buffer ) {
+
+
+
+
+
+
+
3982 assert( (HDC)NULL != g_retroflat_state->
buffer.hdc_b );
+
+
+
3985# ifdef RETROFLAT_VDP
+
+
+
+
+
+
3991 assert( (HBITMAP)NULL != bmp->b );
+
3992 assert( (HDC)NULL == bmp->hdc_b );
+
+
+
3995 bmp->hdc_b = CreateCompatibleDC( (HDC)NULL );
+
+
+
3998 if( (HBITMAP)NULL != bmp->mask ) {
+
+
4000 bmp->hdc_mask = CreateCompatibleDC( (HDC)NULL );
+
+
+
+
+
4005 bmp->old_hbm_b = SelectObject( bmp->hdc_b, bmp->b );
+
4006 if( (HBITMAP)NULL != bmp->mask ) {
+
4007 bmp->old_hbm_mask = SelectObject( bmp->hdc_mask, bmp->mask );
+
+
+
+
+
+
4013# warning "draw lock not implemented"
+
+
+
+
+
+
+
+
+
+
+
4024# ifdef RETROFLAT_OPENGL
+
4025 if( NULL == bmp || &(g_retroflat_state->
buffer) == bmp ) {
+
+
+
+
4029# if defined( RETROFLAT_API_SDL1 ) || defined( RETROFLAT_API_SDL2 )
+
4030 SDL_GL_SwapBuffers();
+
4031# elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
4032 SwapBuffers( g_retroflat_state->hdc_win );
+
4033# elif defined( RETROFLAT_API_GLUT )
+
+
+
4036 }
else if( retroflat_bitmap_locked( bmp ) ) {
+
4037 bmp->
flags &= ~RETROFLAT_FLAGS_LOCK;
+
4038#ifndef RETROGLU_NO_TEXTURES
+
4039 assert( 0 < bmp->tex.id );
+
4040 assert( NULL != bmp->tex.bytes );
+
+
+
4043 glBindTexture( GL_TEXTURE_2D, bmp->tex.id );
+
4044 glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, bmp->tex.w, bmp->tex.h, 0,
+
4045 GL_RGBA, GL_UNSIGNED_BYTE, bmp->tex.bytes );
+
+
+
+
4049 maug_munlock( bmp->tex.bytes_h, bmp->tex.bytes );
+
+
+
4052# elif defined( RETROFLAT_API_ALLEGRO )
+
+
+
+
+
+
+
+
+
+
4062 blit( g_retroflat_state->
buffer.b, screen, 0, 0, 0, 0, SCREEN_W, SCREEN_H );
+
+
+
+
4066# ifdef RETROFLAT_MOUSE
+
+
4068 show_mouse( screen );
+
+
+
+
+
4073# elif defined( RETROFLAT_API_SDL1 )
+
+
+
+
4077 if( NULL == bmp || &(g_retroflat_state->
buffer) == bmp ) {
+
+
4079 bmp = &(g_retroflat_state->
buffer);
+
+
+
4082 RETROFLAT_FLAGS_LOCK == (RETROFLAT_FLAGS_LOCK & bmp->
flags)
+
+
+
4085 bmp->
flags &= ~RETROFLAT_FLAGS_LOCK;
+
4086 SDL_UnlockSurface( bmp->surface );
+
+
+
+
4090 RETROFLAT_FLAGS_SCREEN_LOCK ==
+
4091 (RETROFLAT_FLAGS_SCREEN_LOCK & bmp->
flags) );
+
4092 bmp->
flags &= ~RETROFLAT_FLAGS_SCREEN_LOCK;
+
+
4094# if defined( RETROFLAT_VDP )
+
4095 retroflat_vdp_call(
"retroflat_vdp_flip" );
+
+
+
4098 SDL_Flip( bmp->surface );
+
+
+
+
+
4103 assert( RETROFLAT_FLAGS_LOCK == (RETROFLAT_FLAGS_LOCK & bmp->
flags) );
+
4104 bmp->
flags &= ~RETROFLAT_FLAGS_LOCK;
+
4105 SDL_UnlockSurface( bmp->surface );
+
+
+
4108# elif defined( RETROFLAT_API_SDL2 )
+
+
+
+
+
+
4114# ifdef RETROFLAT_VDP
+
+
+
+
+
4119 SDL_SetRenderTarget( g_retroflat_state->
buffer.renderer, NULL );
+
+
4121 g_retroflat_state->
buffer.renderer,
+
4122 g_retroflat_state->
buffer.texture, NULL, NULL, 0, NULL, 0 );
+
4123 SDL_RenderPresent( g_retroflat_state->
buffer.renderer );
+
+
+
+
4127# ifdef RETROFLAT_VDP
+
4128 }
else if( NULL == bmp && NULL != g_retroflat_state->
vdp_buffer ) {
+
+
+
+
+
+
+
+
4136 SDL_RenderPresent( bmp->renderer );
+
4137 SDL_DestroyRenderer( bmp->renderer );
+
4138 bmp->renderer = NULL;
+
+
+
+
+
+
4144 assert( NULL != bmp->texture );
+
4145 SDL_DestroyTexture( bmp->texture );
+
4146 bmp->texture = SDL_CreateTextureFromSurface(
+
4147 g_retroflat_state->
buffer.renderer, bmp->surface );
+
4148 maug_cleanup_if_null(
+
+
+
+
4152# elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
+
+
+
+
+
4158 if( (HWND)NULL != g_retroflat_state->window ) {
+
4159 InvalidateRect( g_retroflat_state->window, 0, TRUE );
+
+
+
4162# ifdef RETROFLAT_VDP
+
4163 if( NULL != g_retroflat_state->
vdp_buffer ) {
+
+
+
+
+
+
+
+
4171# ifdef RETROFLAT_VDP
+
+
+
+
+
+
4177 if( (HDC)NULL != bmp->hdc_b ) {
+
4178 SelectObject( bmp->hdc_b, bmp->old_hbm_b );
+
4179 DeleteDC( bmp->hdc_b );
+
4180 bmp->hdc_b = (HDC)NULL;
+
4181 bmp->old_hbm_b = (HBITMAP)NULL;
+
+
+
+
4185 if( (HDC)NULL != bmp->hdc_mask ) {
+
4186 SelectObject( bmp->hdc_mask, bmp->old_hbm_mask );
+
4187 DeleteDC( bmp->hdc_mask );
+
4188 bmp->hdc_mask = (HDC)NULL;
+
4189 bmp->old_hbm_mask = (HBITMAP)NULL;
+
+
+
+
+
+
4195# warning "draw release not implemented"
+
+
+
+
+
+
+
+
4203#if defined( RETROFLAT_API_WIN16 ) || defined (RETROFLAT_API_WIN32 )
+
+
4205static int retroflat_bitmap_win_transparency(
+
+
+
+
4209 unsigned long txp_color = 0;
+
+
+
4212 bmp_out->mask = CreateBitmap( w, h, 1, 1, NULL );
+
+
+
+
4216 maug_cleanup_if_not_ok();
+
+
+
+
+
+
+
+
4224 SetBkColor( bmp_out->hdc_b, txp_color );
+
+
+
+
4228 bmp_out->hdc_mask, 0, 0, w, h, bmp_out->hdc_b, 0, 0, SRCCOPY );
+
+
4230 bmp_out->hdc_b, 0, 0, w, h, bmp_out->hdc_mask, 0, 0, SRCINVERT );
+
+
+
+
+
4235 retroflat_draw_release( bmp_out );
+
+
+
+
+
+
+
+
+
+
+
+
4247 int retval = MERROR_OK;
+
4248# if defined( RETROFLAT_OPENGL )
+
4249 FILE* bmp_file = NULL;
+
4250 uint8_t* bmp_buffer = NULL;
+
4251 size_t bmp_buffer_sz = 0,
+
4252 bmp_buffer_read = 0;
+
4253 MAUG_MHANDLE bmp_buffer_h = (MAUG_MHANDLE)NULL;
+
4254 uint32_t bmp_offset = 0;
+
+
4256# elif defined( RETROFLAT_API_SDL1 )
+
4257 SDL_Surface* tmp_surface = NULL;
+
4258# elif defined( RETROFLAT_API_WIN16 ) || defined (RETROFLAT_API_WIN32 )
+
4259# if defined( RETROFLAT_API_WIN16 )
+
+
4261 FILE* bmp_file = NULL;
+
4262 long int i, x, y, w, h, colors, offset, sz, read;
+
4263# elif defined( RETROFLAT_API_WIN32 )
+
+
+
+
+
4268 assert( NULL != bmp_out );
+
+
+
+
+
+
+
+
+
+
4278 debug_printf( 1,
"retroflat: loading bitmap: %s", filename_path );
+
+
4280# ifdef RETROFLAT_OPENGL
+
+
+
+
4284 bmp_file = fopen( filename_path,
"rb" );
+
4285 maug_cleanup_if_null_alloc( FILE*, bmp_file );
+
+
4287 fseek( bmp_file, 0, SEEK_END );
+
4288 bmp_buffer_sz = ftell( bmp_file );
+
4289 fseek( bmp_file, 0, SEEK_SET );
+
+
4291 bmp_buffer_h = maug_malloc( bmp_buffer_sz, 1 );
+
4292 maug_cleanup_if_null_alloc( MAUG_MHANDLE, bmp_buffer_h );
+
+
4294 maug_mlock( bmp_buffer_h, bmp_buffer );
+
4295 maug_cleanup_if_null_alloc( uint8_t*, bmp_buffer );
+
+
4297 bmp_buffer_read = fread( bmp_buffer, 1, bmp_buffer_sz, bmp_file );
+
4298 if( bmp_buffer_read < bmp_buffer_sz ) {
+
+
4300 "Error",
"Could not read bitmap file!" );
+
4301 retval = MERROR_FILE;
+
+
+
+
+
+
+
4308 if( 40 != bmp_read_uint32( &(bmp_buffer[0x0e]) ) ) {
+
+
4310 "Unable to determine texture bitmap format: %d", bmp_buffer[0x0e] );
+
+
+
+
+
+
4316 bmp_offset = bmp_read_uint32( &(bmp_buffer[0x0a]) );
+
4317 bmp_out->tex.sz = bmp_buffer_sz - bmp_offset;
+
4318 bmp_out->tex.w = bmp_read_uint32( &(bmp_buffer[0x12]) );
+
4319 bmp_out->tex.h = bmp_read_uint32( &(bmp_buffer[0x16]) );
+
4320 bmp_out->tex.bpp = bmp_read_uint32( &(bmp_buffer[0x1c]) );
+
4321 if( 24 != bmp_out->tex.bpp ) {
+
+
4323 "Error",
"Invalid texture bitmap depth: %d",
+
+
+
+
+
+
+
4330 debug_printf( 0,
"creating bitmap: " SIZE_T_FMT
" x " SIZE_T_FMT,
+
4331 bmp_out->tex.w, bmp_out->tex.h );
+
4332 bmp_out->tex.bytes_h = maug_malloc( bmp_out->tex.w * bmp_out->tex.h, 4 );
+
4333 maug_cleanup_if_null_alloc( MAUG_MHANDLE, bmp_out->tex.bytes_h );
+
+
4335 maug_mlock( bmp_out->tex.bytes_h, bmp_out->tex.bytes );
+
4336 maug_cleanup_if_null_alloc( uint8_t*, bmp_out->tex.bytes );
+
+
+
4339 for( i = 0 ; bmp_out->tex.sz / 3 > i ; i++ ) {
+
4340 bmp_out->tex.bytes[i * 4] = bmp_buffer[bmp_offset + (i * 3) + 2];
+
4341 bmp_out->tex.bytes[(i * 4) + 1] = bmp_buffer[bmp_offset + (i * 3) + 1];
+
4342 bmp_out->tex.bytes[(i * 4) + 2] = bmp_buffer[bmp_offset + (i * 3)];
+
+
+
+
+
+
+
4349 bmp_out->tex.bytes[(i * 4) + 3] = 0x00;
+
+
4351 bmp_out->tex.bytes[(i * 4) + 3] = 0xff;
+
+
+
+
4355#ifndef RETROGLU_NO_TEXTURES
+
4356 glGenTextures( 1, (GLuint*)&(bmp_out->tex.id) );
+
4357 glBindTexture( GL_TEXTURE_2D, bmp_out->tex.id );
+
4358 glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, bmp_out->tex.w, bmp_out->tex.h, 0,
+
4359 GL_RGBA, GL_UNSIGNED_BYTE, bmp_out->tex.bytes );
+
+
+
+
+
4364 if( NULL != bmp_out->tex.bytes ) {
+
4365 maug_munlock( bmp_out->tex.bytes_h, bmp_out->tex.bytes );
+
+
+
4368 if( NULL != bmp_buffer ) {
+
4369 maug_munlock( bmp_buffer_h, bmp_buffer );
+
+
+
4372 if( (MAUG_MHANDLE)NULL != bmp_buffer_h ) {
+
4373 maug_mfree( bmp_buffer_h );
+
+
+
4376 if( NULL != bmp_file ) {
+
+
+
+
4380# elif defined( RETROFLAT_API_ALLEGRO )
+
+
+
+
4384 bmp_out->b = load_bitmap( filename_path, NULL );
+
+
+
4387 if( NULL == bmp_out->b ) {
+
4388 allegro_message(
"unable to load %s", filename_path );
+
+
+
+
4392# elif defined( RETROFLAT_API_SDL1 )
+
+
+
+
4396 tmp_surface = SDL_LoadBMP( filename_path );
+
+
4398 if( NULL == tmp_surface ) {
+
+
4400 "Error",
"SDL unable to load bitmap: %s", SDL_GetError() );
+
+
+
+
+
4405 debug_printf( 1,
"loaded bitmap: %d x %d", tmp_surface->w, tmp_surface->h );
+
+
4407 bmp_out->surface = SDL_DisplayFormat( tmp_surface );
+
4408 if( NULL == bmp_out->surface ) {
+
+
4410 "Error",
"SDL unable to load bitmap: %s", SDL_GetError() );
+
+
+
+
+
4415 debug_printf( 1,
"converted bitmap: %d x %d",
+
4416 bmp_out->surface->w, bmp_out->surface->h );
+
+
4418 SDL_SetColorKey( bmp_out->surface, RETROFLAT_SDL_CC_FLAGS,
+
4419 SDL_MapRGB( bmp_out->surface->format,
+
+
+
+
+
4424 if( NULL != tmp_surface ) {
+
4425 SDL_FreeSurface( tmp_surface );
+
+
+
4428# elif defined( RETROFLAT_API_SDL2 )
+
+
+
+
4432 bmp_out->renderer = NULL;
+
+
4434 bmp_out->surface = SDL_LoadBMP( filename_path );
+
+
+
4437 if( NULL == bmp_out->surface ) {
+
+
4439 "Error",
"SDL unable to load bitmap: %s", SDL_GetError() );
+
+
+
+
+
4444 SDL_SetColorKey( bmp_out->surface, RETROFLAT_SDL_CC_FLAGS,
+
4445 SDL_MapRGB( bmp_out->surface->format,
+
+
+
4448 bmp_out->texture = SDL_CreateTextureFromSurface(
+
4449 g_retroflat_state->
buffer.renderer, bmp_out->surface );
+
+
4451 if( NULL == bmp_out->texture ) {
+
+
4453 "Error",
"SDL unable to create texture: %s", SDL_GetError() );
+
+
4455 if( NULL != bmp_out->surface ) {
+
4456 SDL_FreeSurface( bmp_out->surface );
+
4457 bmp_out->surface = NULL;
+
+
+
+
+
+
+
4464# elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
+
4466# if defined( RETROFLAT_API_WIN16 )
+
+
+
+
+
+
+
+
+
4475 bmp_file = fopen( filename_path,
"rb" );
+
4476 maug_cleanup_if_null_file( bmp_file );
+
4477 fseek( bmp_file, 0, SEEK_END );
+
4478 sz = ftell( bmp_file );
+
4479 fseek( bmp_file, 0, SEEK_SET );
+
+
4481 buf = calloc( sz, 1 );
+
4482 maug_cleanup_if_null_alloc(
char*, buf );
+
+
4484 read = fread( buf, 1, sz, bmp_file );
+
4485 assert( read == sz );
+
+
4487 offset = retroflat_bmp_int(
unsigned long, buf, 10 );
+
4488 colors = retroflat_bmp_int(
int, buf, 46 );
+
+
+
+
4492 sizeof( BITMAPFILEHEADER ) +
+
4493 sizeof( BITMAPINFOHEADER ) +
+
4494 (colors *
sizeof( RGBQUAD )) > sz
+
+
+
+
4498 "Attempted to load bitmap with too many colors!" );
+
4499 retval = MERROR_FILE;
+
+
+
+
4503 memcpy( &(bmp_out->bmi),
+
4504 &(buf[
sizeof( BITMAPFILEHEADER )]),
+
+
4506 sizeof( BITMAPINFOHEADER ) + (colors *
sizeof( RGBQUAD )) );
+
+
+
4509 debug_printf( 1,
"bitmap w: %08x, h: %08x, colors: %d",
+
4510 bmp_out->bmi.header.biWidth, bmp_out->bmi.header.biHeight, colors );
+
+
4512 assert( 0 < bmp_out->bmi.header.biWidth );
+
4513 assert( 0 < bmp_out->bmi.header.biHeight );
+
4514 assert( 0 == bmp_out->bmi.header.biWidth % 8 );
+
4515 assert( 0 == bmp_out->bmi.header.biHeight % 8 );
+
+
4517 bmp_out->b = CreateCompatibleBitmap( g_retroflat_state->hdc_win,
+
4518 bmp_out->bmi.header.biWidth, bmp_out->bmi.header.biHeight );
+
+
+
+
4522 SetDIBits( g_retroflat_state->hdc_win, bmp_out->b, 0,
+
4523 bmp_out->bmi.header.biHeight, &(buf[offset]),
+
4524 (BITMAPINFO*)&(bmp_out->bmi),
+
+
+
4527 retval = retroflat_bitmap_win_transparency( bmp_out,
+
4528 bmp_out->bmi.header.biWidth, bmp_out->bmi.header.biHeight );
+
+
+
+
+
+
+
+
4536# ifdef RETROFLAT_API_WINCE
+
4537 bmp_out->b = SHLoadDIBitmap( filename_path );
+
+
4539 bmp_out->b = LoadImage(
+
4540 NULL, filename_path, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE );
+
+
4542 maug_cleanup_if_null_msg(
+
4543 HBITMAP, bmp_out->b, MERROR_FILE,
"failed to open FILE!" )
+
+
4545 GetObject( bmp_out->b, sizeof( BITMAP ), &bm );
+
+
4547 bmp_out->bmi.header.biSize = sizeof( BITMAPINFOHEADER );
+
4548 bmp_out->bmi.header.biCompression = BI_RGB;
+
4549 bmp_out->bmi.header.biWidth = bm.bmWidth;
+
4550 bmp_out->bmi.header.biHeight = bm.bmHeight;
+
4551 bmp_out->bmi.header.biPlanes = bm.bmPlanes;
+
4552 bmp_out->bmi.header.biBitCount = bm.bmBitsPixel;
+
4553 bmp_out->bmi.header.biSizeImage =
+
4554 bmp_out->bmi.header.biWidth *
+
4555 bmp_out->bmi.header.biHeight *
+
4556 (bm.bmBitsPixel / sizeof( uint8_t ));
+
+
+
+
+
+
+
+
+
+
+
4567 retval = retroflat_bitmap_win_transparency(
+
4568 bmp_out, bm.bmWidth, bm.bmHeight );
+
+
+
+
+
+
+
+
4576# ifdef RETROFLAT_API_WIN16
+
+
+
+
+
4581 if( NULL != bmp_file ) {
+
+
+
+
+
+
+
4588# warning "load bitmap not implemented"
+
+
+
+
+
+
+
+
+
+
+
+
4600# if defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
+
4602 PALETTEENTRY palette[RETROFLAT_BMP_COLORS_SZ_MAX];
+
+
+
+
+
+
+
4609# if defined( RETROFLAT_OPENGL )
+
+
+
+
+
4614 debug_printf( 0,
"creating bitmap: " SIZE_T_FMT
" x " SIZE_T_FMT,
+
4615 bmp_out->tex.w, bmp_out->tex.h );
+
4616 bmp_out->tex.bytes_h = maug_malloc( bmp_out->tex.w * bmp_out->tex.h, 4 );
+
4617 maug_cleanup_if_null_alloc( MAUG_MHANDLE, bmp_out->tex.bytes_h );
+
+
4619 maug_mlock( bmp_out->tex.bytes_h, bmp_out->tex.bytes );
+
4620 maug_cleanup_if_null_alloc( uint8_t*, bmp_out->tex.bytes );
+
+
+
+
+
4625 bmp_out->tex.w * bmp_out->tex.h *
sizeof( uint32_t ) );
+
+
4627# ifndef RETROGLU_NO_TEXTURES
+
4628 glGenTextures( 1, (GLuint*)&(bmp_out->tex.id) );
+
+
+
+
4632 if( NULL != bmp_out->tex.bytes ) {
+
4633 maug_munlock( bmp_out->tex.bytes_h, bmp_out->tex.bytes );
+
+
4635# elif defined( RETROFLAT_API_ALLEGRO )
+
+
+
+
4639 bmp_out->b = create_bitmap( w, h );
+
+
4641 clear_bitmap( bmp_out->b );
+
+
+
4644# elif defined( RETROFLAT_API_SDL1 )
+
+
+
+
4648 bmp_out->surface = SDL_CreateRGBSurface( 0, w, h,
+
+
4650 maug_cleanup_if_null(
+
+
+
4653 SDL_SetColorKey( bmp_out->surface, RETROFLAT_SDL_CC_FLAGS,
+
4654 SDL_MapRGB( bmp_out->surface->format,
+
+
+
+
+
4659# elif defined( RETROFLAT_API_SDL2 )
+
+
+
+
+
+
+
4666 bmp_out->surface = SDL_CreateRGBSurface( 0, w, h,
+
+
+
4669 maug_cleanup_if_null(
+
+
4671 SDL_SetColorKey( bmp_out->surface, RETROFLAT_SDL_CC_FLAGS,
+
4672 SDL_MapRGB( bmp_out->surface->format,
+
+
+
+
4676 bmp_out->texture = SDL_CreateTextureFromSurface(
+
4677 g_retroflat_state->
buffer.renderer, bmp_out->surface );
+
4678 maug_cleanup_if_null(
+
+
+
+
4682# elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
+
+
+
+
4687 bmp_out->mask = (HBITMAP)NULL;
+
+
4689# ifdef RETROFLAT_WING
+
+
+
+
+
4694 (WinGCreateDC_t)NULL != g_w.WinGCreateDC &&
+
4695 (WinGRecommendDIBFormat_t)NULL != g_w.WinGRecommendDIBFormat
+
+
4697 bmp_out->hdc_b = g_w.WinGCreateDC();
+
+
4699 if( !g_w.WinGRecommendDIBFormat( (BITMAPINFO far*)&(bmp_out->bmi) ) ) {
+
+
4701 "Error",
"Could not determine recommended format!" );
+
4702 retval = RETROFLAT_ERROR_GRAPHICS;
+
+
+
+
+
+
4708 debug_printf( 0,
"creating bitmap..." );
+
+
4710 bmp_out->bmi.header.biSize =
sizeof( BITMAPINFOHEADER );
+
4711 bmp_out->bmi.header.biPlanes = 1;
+
4712 bmp_out->bmi.header.biCompression = BI_RGB;
+
4713 bmp_out->bmi.header.biWidth = w;
+
4714# ifdef RETROFLAT_WING
+
4715 bmp_out->bmi.header.biHeight *= h;
+
+
4717 bmp_out->bmi.header.biHeight = h;
+
+
4719 bmp_out->bmi.header.biBitCount = 32;
+
4720 bmp_out->bmi.header.biSizeImage = w * h * 4;
+
+
4722 GetSystemPaletteEntries(
+
4723 g_retroflat_state->hdc_win, 0, RETROFLAT_BMP_COLORS_SZ_MAX, palette );
+
4724 for( i = 0 ; RETROFLAT_BMP_COLORS_SZ_MAX > i ; i++ ) {
+
4725 bmp_out->bmi.colors[i].rgbRed = palette[i].peRed;
+
4726 bmp_out->bmi.colors[i].rgbGreen = palette[i].peGreen;
+
4727 bmp_out->bmi.colors[i].rgbBlue = palette[i].peBlue;
+
4728 bmp_out->bmi.colors[i].rgbReserved = 0;
+
+
+
4731# ifdef RETROFLAT_WING
+
+
+
+
+
4736 (WinGCreateBitmap_t)NULL != g_w.WinGCreateBitmap
+
+
+
4739 debug_printf( 1,
"creating WinG-backed bitmap..." );
+
+
+
4742 bmp_out->b = g_w.WinGCreateBitmap(
+
+
4744 (BITMAPINFO far*)(&bmp_out->bmi),
+
4745 (
void far*)&(bmp_out->bits) );
+
+
4747 debug_printf( 1,
"WinG bitmap bits: %p", bmp_out->bits );
+
+
+
+
+
4752 bmp_out->b = CreateCompatibleBitmap( g_retroflat_state->hdc_win, w, h );
+
+
+
+
+
+
4758 debug_printf( 1,
"creating screen device context..." );
+
4759 bmp_out->hdc_b = CreateCompatibleDC( g_retroflat_state->hdc_win );
+
4760 bmp_out->old_hbm_b = SelectObject( bmp_out->hdc_b, bmp_out->b );
+
+
+
4763# ifdef RETROFLAT_WING
+
+
+
+
+
+
+
4770# warning "create bitmap not implemented"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
4784 RETROFLAT_COLOR color;
+
+
+
+
+
+
+
+
+
+
4794 while(
'\0' != gc_xpm_filenames[xpm_idx][0] ) {
+
4795 if( 0 == strcmp( filename, gc_xpm_filenames[xpm_idx] ) ) {
+
+
+
+
+
+
+
+
+
+
+
4806 debug_printf( 2,
"found xpm: %s", gc_xpm_filenames[xpm_idx] );
+
+
+
+
4810 sscanf( gc_xpm_data[xpm_idx][0],
"%d %d %d %d",
+
4811 &bmp_w, &bmp_h, &bmp_colors, &bmp_bypp );
+
+
4813 assert( 16 == bmp_colors );
+
4814 assert( 1 == bmp_bypp );
+
+
4816 retval = retroflat_create_bitmap( bmp_w, bmp_h, bmp_out, 0 );
+
4817 if( MERROR_OK != retval ) {
+
+
+
+
4821 debug_printf( 1,
"created empty canvas: %dx%d", bmp_w, bmp_h );
+
+
+
+
+
+
+
+
4829 retroflat_px_lock( bmp_out );
+
+
4831 for( y = 0 ; bmp_h > y ; y++ ) {
+
4832 for( x = 0 ; bmp_w > x ; x++ ) {
+
4833 switch( gc_xpm_data[xpm_idx][17 + y][x] ) {
+
+
+
+
+
4838 color = RETROFLAT_COLOR_DARKBLUE;
+
+
+
4841 color = RETROFLAT_COLOR_DARKGREEN;
+
+
+
4844 color = RETROFLAT_COLOR_TEAL;
+
+
+
4847 color = RETROFLAT_COLOR_DARKRED;
+
+
+
4850 color = RETROFLAT_COLOR_VIOLET;
+
+
+
4853 color = RETROFLAT_COLOR_BROWN;
+
+
+
4856 color = RETROFLAT_COLOR_GRAY;
+
+
+
4859 color = RETROFLAT_COLOR_DARKGRAY;
+
+
+
4862 color = RETROFLAT_COLOR_BLUE;
+
+
+
4865 color = RETROFLAT_COLOR_GREEN;
+
+
+
4868 color = RETROFLAT_COLOR_CYAN;
+
+
+
4871 color = RETROFLAT_COLOR_RED;
+
+
+
4874 color = RETROFLAT_COLOR_MAGENTA;
+
+
+
4877 color = RETROFLAT_COLOR_YELLOW;
+
+
+
4880 color = RETROFLAT_COLOR_WHITE;
+
+
+
+
4884 retroflat_px( bmp_out, color, x, y, 0 );
+
+
+
+
4888 retroflat_px_release( bmp_out );
+
4889 retroflat_draw_release( bmp_out );
+
+
+
+
+
+
+
+
+
+
+
+
4901# if defined( RETROFLAT_OPENGL )
+
+
4903 if( NULL != bmp->tex.bytes_h ) {
+
4904 if( NULL != bmp->tex.bytes ) {
+
4905 maug_munlock( bmp->tex.bytes_h, bmp->tex.bytes );
+
+
+
4908 maug_mfree( bmp->tex.bytes_h );
+
+
+
4911# elif defined( RETROFLAT_API_ALLEGRO )
+
+
+
+
4915 if( NULL == bmp->b ) {
+
+
+
+
4919 destroy_bitmap( bmp->b );
+
+
+
4922# elif defined( RETROFLAT_API_SDL1 ) || defined( RETROFLAT_API_SDL2 )
+
+
4924 assert( NULL != bmp );
+
4925 assert( NULL != bmp->surface );
+
+
4927# ifndef RETROFLAT_API_SDL1
+
4928 assert( NULL != bmp->texture );
+
+
4930 SDL_DestroyTexture( bmp->texture );
+
4931 bmp->texture = NULL;
+
+
+
4934 SDL_FreeSurface( bmp->surface );
+
4935 bmp->surface = NULL;
+
+
4937# elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
+
+
+
4941 if( NULL != bmp->old_hbm_b ) {
+
4942 SelectObject( bmp->hdc_b, bmp->old_hbm_b );
+
4943 bmp->old_hbm_b = NULL;
+
4944 bmp->old_hbm_b = (HBITMAP)NULL;
+
+
+
4947 if( (HBITMAP)NULL != bmp->b ) {
+
4948 DeleteObject( bmp->b );
+
4949 bmp->b = (HBITMAP)NULL;
+
+
+
4952 if( (HBITMAP)NULL != bmp->mask ) {
+
4953 DeleteObject( bmp->mask );
+
4954 bmp->mask = (HBITMAP)NULL;
+
+
+
+
4958# warning "destroy bitmap not implemented"
+
+
+
+
+
+
+
+
4966 int s_x,
int s_y,
int d_x,
int d_y,
int w,
int h
+
+
4968# if defined( RETROFLAT_OPENGL )
+
+
4970# elif defined( RETROFLAT_API_SDL1 ) && !defined( RETROFLAT_OPENGL )
+
+
+
+
4974# elif defined( RETROFLAT_API_SDL2 )
+
+
4976 SDL_Rect src_rect = { s_x, s_y, w, h };
+
4977 SDL_Rect dest_rect = { d_x, d_y, w, h };
+
4978# elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
+
4980 int locked_src_internal = 0;
+
4981 int locked_target_internal = 0;
+
+
+
4984# ifndef RETROFLAT_OPENGL
+
4985 if( NULL == target ) {
+
+
+
+
+
4990 assert( NULL != src );
+
+
4992# if defined( RETROFLAT_OPENGL )
+
+
+
+
+
+
+
+
5000 assert( NULL != target->tex.bytes );
+
+
+
5003 assert( !retroflat_bitmap_locked( src ) );
+
5004 maug_mlock( src->tex.bytes_h, src->tex.bytes );
+
5005 for( y_iter = 0 ; h > y_iter ; y_iter++ ) {
+
+
+
5008 &(target->tex.bytes[(((y_iter * target->tex.w) + d_x) * 4)]),
+
5009 &(src->tex.bytes[(((y_iter * src->tex.w) + s_x) * 4)]),
+
+
+
5012 maug_munlock( src->tex.bytes_h, src->tex.bytes );
+
+
+
+
5016# elif defined( RETROFLAT_API_ALLEGRO )
+
+
+
+
5020 assert( NULL != target->b );
+
5021 assert( NULL != src->b );
+
+
+
5024 0 == s_x && 0 == s_y &&
+
5025 ((-1 == w && -1 == h ) || (src->b->w == w && src->b->h == h))
+
+
5027 draw_sprite( target->b, src->b, d_x, d_y );
+
+
+
5030 blit( src->b, target->b, s_x, s_y, d_x, d_y, w, h );
+
+
+
5033# elif defined( RETROFLAT_API_SDL1 ) || defined( RETROFLAT_API_SDL2 )
+
+
+
+
+
+
+
+
+
+
+
+
+
5046# ifdef RETROFLAT_API_SDL1
+
5047 assert( 0 == src->autolock_refs );
+
5048 assert( 0 == target->autolock_refs );
+
+
5050 SDL_BlitSurface( src->surface, &src_rect, target->surface, &dest_rect );
+
+
5052 error_printf(
"could not blit surface: %s", SDL_GetError() );
+
+
+
+
5056 assert( retroflat_bitmap_locked( target ) );
+
5057 retval = SDL_RenderCopy(
+
5058 target->renderer, src->texture, &src_rect, &dest_rect );
+
+
5060 error_printf(
"could not blit surface: %s", SDL_GetError() );
+
+
+
+
+
5065# elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
+
+
+
5069 assert( (HBITMAP)NULL != target->b );
+
5070 assert( (HBITMAP)NULL != src->b );
+
+
5072 retroflat_internal_autolock_bitmap( src, locked_src_internal );
+
5073 assert( retroflat_bitmap_locked( target ) );
+
+
5075 if( (HBITMAP)NULL != src->mask ) {
+
+
+
5078 target->hdc_b, d_x, d_y, w, h, src->hdc_mask, s_x, s_y, SRCAND );
+
+
+
+
+
5083 target->hdc_b, d_x, d_y, w, h, src->hdc_b, s_x, s_y, SRCPAINT );
+
+
+
+
5087 if( locked_src_internal ) {
+
5088 retroflat_draw_release( src );
+
+
+
+
5092# warning "blit bitmap not implemented"
+
+
+
+
+
+
+
+
+
5101 int x,
int y, uint8_t
flags
+
+
5103# if defined( RETROFLAT_OPENGL )
+
5104# elif defined( RETROFLAT_API_SDL1 )
+
+
5106 uint8_t* px_1 = NULL;
+
5107 uint16_t* px_2 = NULL;
+
5108 uint32_t* px_4 = NULL;
+
5109 RETROFLAT_COLOR_DEF* color = &(g_retroflat_state->
palette[color_idx]);
+
5110# elif defined( RETROFLAT_API_SDL2 )
+
5111 RETROFLAT_COLOR_DEF* color = &(g_retroflat_state->
palette[color_idx]);
+
+
+
5114 if( RETROFLAT_COLOR_NULL == color_idx ) {
+
+
+
+
5118 if( NULL == target ) {
+
+
+
+
+
+
+
+
+
+
+
5129# if defined( RETROFLAT_OPENGL )
+
+
5131 assert( NULL != target->tex.bytes );
+
5132 assert( retroflat_bitmap_locked( target ) );
+
+
5134 target->tex.bytes[(((y * target->tex.w) + x) * 4) + 0] =
+
5135 g_retroflat_state->tex_palette[color_idx][0];
+
5136 target->tex.bytes[(((y * target->tex.w) + x) * 4) + 1] =
+
5137 g_retroflat_state->tex_palette[color_idx][1];
+
5138 target->tex.bytes[(((y * target->tex.w) + x) * 4) + 2] =
+
5139 g_retroflat_state->tex_palette[color_idx][2];
+
5140 target->tex.bytes[(((y * target->tex.w) + x) * 4) + 3] = 0xff;
+
+
5142# elif defined( RETROFLAT_API_ALLEGRO )
+
+
+
+
5146 putpixel( target->b, x, y, g_retroflat_state->
palette[color_idx] );
+
+
5148# elif defined( RETROFLAT_API_SDL1 )
+
+
+
+
5152 retroflat_px_lock( target );
+
+
5154 assert( 0 < target->autolock_refs );
+
+
5156 offset = (y * target->surface->pitch) +
+
5157 (x * target->surface->format->BytesPerPixel);
+
+
5159 switch( target->surface->format->BytesPerPixel ) {
+
+
5161 px_4 = (uint32_t*)&(((uint8_t*)(target->surface->pixels))[offset]);
+
+
5163 SDL_MapRGB( target->surface->format, color->r, color->g, color->b );
+
+
+
+
5167 px_2 = (uint16_t*)&(((uint8_t*)(target->surface->pixels))[offset]);
+
+
5169 SDL_MapRGB( target->surface->format, color->r, color->g, color->b );
+
+
+
+
5173 px_1 = (uint8_t*)&(((uint8_t*)(target->surface->pixels))[offset]);
+
+
5175 SDL_MapRGB( target->surface->format, color->r, color->g, color->b );
+
+
+
+
5179 retroflat_px_release( target );
+
+
5181# elif defined( RETROFLAT_API_SDL2 )
+
+
+
+
5185 assert( retroflat_bitmap_locked( target ) );
+
+
5187 SDL_SetRenderDrawColor(
+
5188 target->renderer, color->r, color->g, color->b, 255 );
+
5189 SDL_RenderDrawPoint( target->renderer, x, y );
+
+
5191# elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
+
+
+
5195 assert( retroflat_bitmap_locked( target ) );
+
+
5197# ifdef RETROFLAT_WING
+
5198 if( NULL != target->bits ) {
+
+
+
5201 if( 0 > target->h ) {
+
5202 target->bits[((target->h - 1 - y) * target->tex.w) + x] =
+
+
+
5205 target->bits[(y * target->tex.w) + x] =
+
+
+
+
+
5210 SetPixel( target->hdc_b, x, y,
+
5211 g_retroflat_state->
palette[color_idx] );
+
+
+
5214 SetPixel( target->hdc_b, x, y,
+
5215 g_retroflat_state->
palette[color_idx] );
+
+
+
5218# elif defined( RETROFLAT_API_LIBNDS )
+
+
+
+
5222 uint16_t* px_ptr = NULL;
+
+
5224 px_ptr = bgGetGfxPtr( g_retroflat_state->px_id );
+
5225 px_ptr[(y * 256) + x] = g_retroflat_state->
palette[color_idx];
+
+
+
5228# warning "px not implemented"
+
+
+
+
+
+
+
+
+
5237 int x,
int y,
int w,
int h, uint8_t
flags
+
+
5239#if defined( RETROFLAT_OPENGL )
+
5240 float aspect_ratio = 0,
+
+
+
+
+
5245#elif defined( RETROFLAT_API_SDL2 )
+
5246#elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
+
5248 HBRUSH old_brush = (HBRUSH)NULL;
+
5249 int locked_target_internal = 0;
+
5250 HPEN old_pen = (HPEN)NULL;
+
+
+
5253 if( RETROFLAT_COLOR_NULL == color_idx ) {
+
+
+
+
5257# ifndef RETROFLAT_OPENGL
+
5258 if( NULL == target ) {
+
+
+
+
+
5263# if defined( RETROFLAT_OPENGL )
+
+
+
+
+
5268 retroflat_opengl_push( x, y, screen_x, screen_y, aspect_ratio );
+
5269 retroflat_opengl_whf( w, h, screen_w, screen_h, aspect_ratio );
+
+
5271 glBegin( GL_TRIANGLES );
+
5272 glColor3fv( g_retroflat_state->
palette[color_idx] );
+
5273 glVertex3f( screen_x, screen_y, RETROFLAT_GL_Z );
+
5274 glVertex3f( screen_x, screen_y - screen_h, RETROFLAT_GL_Z );
+
5275 glVertex3f( screen_x + screen_w, screen_y - screen_h, RETROFLAT_GL_Z );
+
+
5277 glVertex3f( screen_x + screen_w, screen_y - screen_h, RETROFLAT_GL_Z );
+
5278 glVertex3f( screen_x + screen_w, screen_y, RETROFLAT_GL_Z );
+
5279 glVertex3f( screen_x, screen_y, RETROFLAT_GL_Z );
+
+
+
5282 retroflat_opengl_pop();
+
+
5284 retrosoft_rect( target, color_idx, x, y, w, h,
flags );
+
+
+
5287# elif defined( RETROFLAT_SOFT_SHAPES )
+
+
5289 retrosoft_rect( target, color_idx, x, y, w, h,
flags );
+
+
5291# elif defined( RETROFLAT_API_ALLEGRO )
+
+
+
+
5295 assert( NULL != target->b );
+
+
5297 rectfill( target->b, x, y, x + w, y + h,
+
5298 g_retroflat_state->
palette[color_idx] );
+
+
5300 rect( target->b, x, y, x + w, y + h,
+
5301 g_retroflat_state->
palette[color_idx] );
+
+
+
5304# elif defined( RETROFLAT_API_SDL2 )
+
+
5306 assert( retroflat_bitmap_locked( target ) );
+
+
+
+
+
+
+
5313 SDL_SetRenderDrawColor(
+
5314 target->renderer, color->r, color->g, color->b, 255 );
+
+
+
5317 SDL_RenderFillRect( target->renderer, &area );
+
+
5319 SDL_RenderDrawRect( target->renderer, &area );
+
+
+
5322# elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
+
+
+
5326 assert( (HBITMAP)NULL != target->b );
+
+
5328 assert( retroflat_bitmap_locked( target ) );
+
+
5330 retroflat_win_setup_brush( old_brush, target, color_idx,
flags );
+
5331 retroflat_win_setup_pen( old_pen, target, color_idx,
flags );
+
+
5333 Rectangle( target->hdc_b, x, y, x + w, y + h );
+
+
+
+
5337 retroflat_win_cleanup_brush( old_brush, target )
+
5338 retroflat_win_cleanup_pen( old_pen, target )
+
+
+
5341# warning "rect not implemented"
+
+
+
+
+
+
+
+
5349 int x1,
int y1,
int x2,
int y2, uint8_t
flags
+
+
5351# if defined( RETROFLAT_OPENGL )
+
5352# elif defined( RETROFLAT_SOFT_SHAPES )
+
5353# elif defined( RETROFLAT_API_SDL2 )
+
+
5355 int locked_target_internal = 0;
+
5356 RETROFLAT_COLOR_DEF color = g_retroflat_state->
palette[color_idx];
+
5357# elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
5358 HPEN pen = (HPEN)NULL;
+
5359 HPEN old_pen = (HPEN)NULL;
+
+
+
5362 int locked_target_internal = 0;
+
+
+
5365 if( RETROFLAT_COLOR_NULL == color_idx ) {
+
+
+
+
5369# ifndef RETROFLAT_OPENGL
+
5370 if( NULL == target ) {
+
+
+
+
+
5375# if defined( RETROFLAT_OPENGL )
+
+
+
+
+
5380 retrosoft_line( target, color_idx, x1, y1, x2, y2,
flags );
+
+
+
5383# elif defined( RETROFLAT_SOFT_SHAPES )
+
+
5385 retrosoft_line( target, color_idx, x1, y1, x2, y2,
flags );
+
+
5387# elif defined( RETROFLAT_API_ALLEGRO )
+
+
+
+
5391 assert( NULL != target->b );
+
5392 line( target->b, x1, y1, x2, y2, color_idx );
+
+
5394# elif defined( RETROFLAT_API_SDL2 )
+
+
+
+
5398 assert( retroflat_bitmap_locked( target );
+
+
5400 SDL_SetRenderDrawColor(
+
5401 target->renderer, color->r, color->g, color->b, 255 );
+
5402 SDL_RenderDrawLine( target->renderer, x1, y1, x2, y2 );
+
+
5404# elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
+
+
+
5408 assert( NULL != target->b );
+
+
5410 assert( retroflat_bitmap_locked( target ) );
+
+
5412 retroflat_win_setup_pen( old_pen, target, color_idx,
flags );
+
+
+
+
+
+
+
+
5420 Polyline( target->hdc_b, points, 2 );
+
+
+
+
5424 if( (HPEN)NULL != pen ) {
+
5425 SelectObject( target->hdc_b, old_pen );
+
5426 DeleteObject( pen );
+
+
+
+
5430# warning "line not implemented"
+
+
+
+
+
+
+
+
5438 int x,
int y,
int w,
int h, uint8_t
flags
+
+
5440# if defined( RETROFLAT_OPENGL )
+
5441# elif defined( RETROFLAT_SOFT_SHAPES )
+
5442# elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
5443 HPEN old_pen = (HPEN)NULL;
+
5444 HBRUSH old_brush = (HBRUSH)NULL;
+
+
5446 int locked_target_internal = 0;
+
+
+
5449 if( RETROFLAT_COLOR_NULL == color ) {
+
+
+
+
5453# ifndef RETROFLAT_OPENGL
+
5454 if( NULL == target ) {
+
+
+
+
+
5459# if defined( RETROFLAT_OPENGL )
+
+
+
+
+
5464 retrosoft_ellipse( target, color, x, y, w, h,
flags );
+
+
+
5467# elif defined( RETROFLAT_SOFT_SHAPES )
+
+
5469 retrosoft_ellipse( target, color, x, y, w, h,
flags );
+
+
5471# elif defined( RETROFLAT_API_ALLEGRO )
+
+
+
+
5475 assert( NULL != target->b );
+
+
+
5478 ellipsefill( target->b, x + (w / 2), y + (h / 2), w / 2, h / 2, color );
+
+
5480 ellipse( target->b, x + (w / 2), y + (h / 2), w / 2, h / 2, color );
+
+
+
5483# elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
+
+
+
5487 assert( NULL != target->b );
+
5488 assert( retroflat_bitmap_locked( target ) );
+
+
5490 retroflat_win_setup_brush( old_brush, target, color,
flags );
+
5491 retroflat_win_setup_pen( old_pen, target, color,
flags );
+
+
5493 Ellipse( target->hdc_b, x, y, x + w, y + h );
+
+
+
+
5497 retroflat_win_cleanup_brush( old_brush, target )
+
5498 retroflat_win_cleanup_pen( old_pen, target )
+
+
+
5501# warning "ellipse not implemented"
+
+
+
+
+
+
+
+
5509 char mouse_str[11] =
"";
+
+
+
5512 mouse_str, 10,
"%02d, %02d", g_retroflat_state->last_mouse_x, g_retroflat_state->last_mouse_y );
+
+
+
5515 target, RETROFLAT_COLOR_BLACK,
+
5516 mouse_str, 10, NULL, 0, 0, 0 );
+
+
5518 target, RETROFLAT_COLOR_BLACK,
+
5519 g_retroflat_state->last_mouse_x - 5, g_retroflat_state->last_mouse_y - 5, 10, 10, 0 );
+
+
+
+
+
+
5525# if defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
+
5527# define retroflat_win_create_font( flags, font_str ) \
+
5528 CreateFont( 10, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, \
+
5529 DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, \
+
5530 DEFAULT_QUALITY, DEFAULT_PITCH, \
+
5531 (NULL == font_str || '\0' == font_str[0] ? "Arial" : font_str) );
+
+
+
+
+
+
5537 const char* font_str,
size_t* w_out,
size_t* h_out, uint8_t
flags
+
+
5539# if defined( RETROFLAT_OPENGL )
+
5540# elif defined( RETROFLAT_SOFT_SHAPES )
+
5541# elif defined( RETROFLAT_API_ALLEGRO )
+
5542 FONT* font_data = NULL;
+
5543 int font_loaded = 0;
+
5544# elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
+
5546 int locked_target_internal = 0;
+
+
+
+
+
+
5552 if( NULL == target ) {
+
+
+
+
5556# if defined( RETROFLAT_OPENGL )
+
+
5558 retrosoft_string_sz( target, str, str_sz, font_str, w_out, h_out,
flags );
+
+
5560# elif defined( RETROFLAT_SOFT_SHAPES )
+
+
5562 retrosoft_string_sz( target, str, str_sz, font_str, w_out, h_out,
flags );
+
+
5564# elif defined( RETROFLAT_API_ALLEGRO )
+
+
+
+
5568 if( NULL == font_str ||
'\0' == font_str[0] ) {
+
+
+
+
5572 font_data = load_font( font_str, NULL, NULL );
+
+
5574 if( NULL == font_data ) {
+
+
5576 "Error",
"Unable to load font: %s", font_str );
+
+
+
+
5580 *w_out = text_length( font_data, str );
+
5581 *h_out = text_height( font_data );
+
+
+
+
5585 if( font_loaded && NULL != font_data ) {
+
5586 destroy_font( font_data );
+
+
+
5589# elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
+
+
+
5593 assert( NULL != target->b );
+
5594 assert( retroflat_bitmap_locked( target ) );
+
+
5596 font = retroflat_win_create_font(
flags, font_str );
+
5597 old_font = SelectObject( target->hdc_b, font );
+
+
5599 GetTextExtentPoint( target->hdc_b, str, str_sz, &
sz );
+
+
+
+
+
+
5605 SelectObject( target->hdc_b, old_font );
+
+
+
5608# warning "string sz not implemented"
+
+
+
+
+
+
+
+
5616 const char* str,
int str_sz,
const char* font_str,
int x_orig,
int y_orig,
+
+
+
5619# if defined( RETROFLAT_OPENGL )
+
5620 float aspect_ratio = 0,
+
+
+
5623# elif defined( RETROFLAT_SOFT_SHAPES )
+
5624# elif defined( RETROFLAT_API_ALLEGRO )
+
5625 FONT* font_data = NULL;
+
5626 int font_loaded = 0;
+
5627# elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
+
5629 int locked_target_internal = 0;
+
+
+
+
+
+
+
5636 if( RETROFLAT_COLOR_NULL == color ) {
+
+
+
+
5640# if !defined( RETROFLAT_OPENGL )
+
5641 if( NULL == target ) {
+
+
+
+
+
+
5647 str_sz = strlen( str );
+
+
+
5650# if defined( RETROFLAT_OPENGL )
+
+
+
5653 retroflat_opengl_push( x_orig, y_orig, screen_x, screen_y, aspect_ratio );
+
+
+
5656 screen_x, screen_y, 0,
+
5657 g_retroflat_state->
palette[color], str, str_sz, font_str,
flags );
+
+
5659 retroflat_opengl_pop();
+
+
+
5662 target, color, str, str_sz, font_str, x_orig, y_orig,
flags );
+
+
+
5665# elif defined( RETROFLAT_SOFT_SHAPES )
+
+
+
5668 target, color, str, str_sz, font_str, x_orig, y_orig,
flags );
+
+
5670# elif defined( RETROFLAT_API_ALLEGRO )
+
+
+
+
5674 if( NULL == font_str ||
'\0' == font_str[0] ) {
+
+
+
+
5678 font_data = load_font( font_str, NULL, NULL );
+
+
5680 if( NULL == font_data ) {
+
+
5682 "Error",
"Unable to load font: %s", font_str );
+
+
+
+
5686 textout_ex( target->b, font_data, str, x_orig, y_orig, color, -1 );
+
+
+
5689 if( font_loaded && NULL != font_data ) {
+
5690 destroy_font( font_data );
+
+
+
5693# elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
+
+
+
5697 assert( NULL != target->b );
+
+
5699 assert( retroflat_bitmap_locked( target ) );
+
+
+
5702 str_sz = strlen( str );
+
+
5704 memset( &
sz,
'\0',
sizeof( SIZE ) );
+
+
5706 font = retroflat_win_create_font(
flags, font_str );
+
5707 old_font = SelectObject( target->hdc_b, font );
+
+
5709 GetTextExtentPoint( target->hdc_b, str, str_sz, &
sz );
+
+
+
5712 rect.right = (x_orig +
sz.cx);
+
5713 rect.bottom = (y_orig +
sz.cy);
+
+
5715 SetTextColor( target->hdc_b, g_retroflat_state->
palette[color] );
+
5716 SetBkMode( target->hdc_b, TRANSPARENT );
+
+
5718 DrawText( target->hdc_b, str, str_sz, &rect, 0 );
+
+
+
+
5722 SelectObject( target->hdc_b, old_font );
+
+
5724 SetBkMode( target->hdc_b, OPAQUE );
+
5725 SetTextColor( target->hdc_b,
+
5726 g_retroflat_state->
palette[RETROFLAT_COLOR_BLACK] );
+
+
+
5729# warning "string not implemented"
+
+
+
+
+
+
+
5736# if defined( RETROFLAT_API_ALLEGRO ) && defined( RETROFLAT_OS_DOS )
+
+
+
5739# elif defined( RETROFLAT_API_SDL1 ) || defined( RETROFLAT_API_SDL2 )
+
+
+
+
+
+
5745 assert( NULL != input );
+
+
5747 input->key_flags = 0;
+
+
5749# ifdef RETROFLAT_API_ALLEGRO
+
+
+
+
5753 if( g_retroflat_state->close_button ) {
+
+
+
+
+
5758# ifdef RETROFLAT_OS_DOS
+
+
+
+
5762 int386( 0x33, &inregs, &outregs );
+
+
+
5765 1 == outregs.x.ebx &&
+
5766 outregs.w.cx != g_retroflat_state->last_mouse_x &&
+
5767 outregs.w.dx != g_retroflat_state->last_mouse_y
+
+
5769 input->
mouse_x = outregs.w.cx;
+
5770 input->
mouse_y = outregs.w.dx;
+
+
+
5773 g_retroflat_state->last_mouse_x = input->
mouse_x;
+
5774 g_retroflat_state->last_mouse_y = input->
mouse_y;
+
+
5776 return RETROFLAT_MOUSE_B_LEFT;
+
+
5778 g_retroflat_state->last_mouse_x = outregs.w.cx;
+
5779 g_retroflat_state->last_mouse_y = outregs.w.dx;
+
+
+
+
+
+
5785 if( mouse_b & 0x01 ) {
+
+
+
5788 return RETROFLAT_MOUSE_B_LEFT;
+
5789 }
else if( mouse_b & 0x02 ) {
+
+
+
5792 return RETROFLAT_MOUSE_B_RIGHT;
+
+
+
+
+
5797 if( keypressed() ) {
+
+
5799 if( KB_SHIFT_FLAG == (KB_SHIFT_FLAG & key_shifts) ) {
+
5800 input->key_flags |= RETROFLAT_INPUT_MOD_SHIFT;
+
+
+
5803 if( KB_CTRL_FLAG == (KB_CTRL_FLAG & key_shifts) ) {
+
5804 input->key_flags |= RETROFLAT_INPUT_MOD_CTRL;
+
+
+
5807 if( KB_ALT_FLAG == (KB_ALT_FLAG & key_shifts) ) {
+
5808 input->key_flags |= RETROFLAT_INPUT_MOD_ALT;
+
+
+
5811 return (readkey() >> 8);
+
+
+
5814# elif defined( RETROFLAT_API_SDL1 ) || defined( RETROFLAT_API_SDL2 )
+
+
+
+
5818 SDL_PollEvent( &event );
+
+
5820 if( SDL_QUIT == event.type ) {
+
+
+
+
5824 }
else if( SDL_KEYDOWN == event.type ) {
+
5825 key_out =
event.key.keysym.sym;
+
+
+
5828 KMOD_RSHIFT == (KMOD_RSHIFT & event.key.keysym.mod) ||
+
5829 KMOD_LSHIFT == (KMOD_LSHIFT & event.key.keysym.mod)
+
+
5831 input->key_flags |= RETROFLAT_INPUT_MOD_SHIFT;
+
+
+
5834 if( KMOD_CTRL == (KMOD_CTRL & event.key.keysym.mod) ) {
+
5835 input->key_flags |= RETROFLAT_INPUT_MOD_CTRL;
+
+
+
5838 if( KMOD_ALT == (KMOD_ALT & event.key.keysym.mod) ) {
+
5839 input->key_flags |= RETROFLAT_INPUT_MOD_ALT;
+
+
+
+
+
+
+
+
5847 while( (eres = SDL_PollEvent( &event )) );
+
+
+
5850 }
else if( SDL_MOUSEBUTTONUP == event.type ) {
+
+
5852 g_retroflat_state->mouse_state = 0;
+
+
5854 }
else if( 0 != g_retroflat_state->mouse_state ) {
+
+
+
+
+
5859 key_out = g_retroflat_state->mouse_state;
+
+
5861 }
else if( SDL_MOUSEBUTTONDOWN == event.type ) {
+
+
+
+
5865 input->
mouse_x =
event.button.x;
+
5866 input->
mouse_y =
event.button.y;
+
+
+
5869 if( SDL_BUTTON_LEFT == event.button.button ) {
+
5870 key_out = RETROFLAT_MOUSE_B_LEFT;
+
5871 g_retroflat_state->mouse_state = RETROFLAT_MOUSE_B_LEFT;
+
5872 }
else if( SDL_BUTTON_RIGHT == event.button.button ) {
+
5873 key_out = RETROFLAT_MOUSE_B_RIGHT;
+
5874 g_retroflat_state->mouse_state = RETROFLAT_MOUSE_B_RIGHT;
+
+
+
+
+
+
5880# if !defined( RETROFLAT_API_SDL1 )
+
5881 }
else if( SDL_WINDOWEVENT == event.type ) {
+
5882 switch( event.window.event ) {
+
5883 case SDL_WINDOWEVENT_RESIZED:
+
5884 retroflat_on_resize( event.window.data1, event.window.data2 );
+
+
+
+
+
5889# elif defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
+
+
+
5893 if( g_retroflat_state->last_key ) {
+
+
+
+
5897 key_out = g_retroflat_state->last_key;
+
5898 input->key_flags = g_retroflat_state->vk_mods;
+
+
+
5901 g_retroflat_state->last_key = 0;
+
+
5903 }
else if( g_retroflat_state->last_mouse ) {
+
5904 if( MK_LBUTTON == (MK_LBUTTON & g_retroflat_state->last_mouse) ) {
+
5905 input->
mouse_x = g_retroflat_state->last_mouse_x;
+
5906 input->
mouse_y = g_retroflat_state->last_mouse_y;
+
5907 key_out = RETROFLAT_MOUSE_B_LEFT;
+
5908 }
else if( MK_RBUTTON == (MK_RBUTTON & g_retroflat_state->last_mouse) ) {
+
5909 input->
mouse_x = g_retroflat_state->last_mouse_x;
+
5910 input->
mouse_y = g_retroflat_state->last_mouse_y;
+
5911 key_out = RETROFLAT_MOUSE_B_RIGHT;
+
+
5913 g_retroflat_state->last_mouse = 0;
+
5914 g_retroflat_state->last_mouse_x = 0;
+
5915 g_retroflat_state->last_mouse_y = 0;
+
+
+
5918# ifdef RETROFLAT_SCREENSAVER
+
+
+
+
+
+
+
+
+
+
5928# elif defined( RETROFLAT_API_GLUT )
+
+
5930 key_out = g_retroflat_state->retroflat_last_key;
+
5931 g_retroflat_state->retroflat_last_key = 0;
+
+
+
5934# warning "poll input not implemented"
+
+
+
+
+
+
+
+
+
+
+
5945# if defined( RETROFLAT_CONFIG_USE_FILE )
+
5946 char flag_buffer[3] = {
'\0',
'\0',
'\0' };
+
+
+
5949 flag_buffer[0] =
'w';
+
+
5951 flag_buffer[0] =
'r';
+
+
+
+
5955 flag_buffer[1] =
'b';
+
+
+
5958 debug_printf( 1,
"opening config file %s with mode [%s]...",
+
5959 g_retroflat_state->config_path, flag_buffer );
+
+
5961 *config = fopen( g_retroflat_state->config_path, flag_buffer );
+
+
+
+
5965# elif defined( RETROFLAT_API_WIN16 )
+
+
+
+
+
+
5971# elif defined( RETROFLAT_API_WIN32 )
+
+
+
+
+
+
+
+
+
+
5981 if( ERROR_SUCCESS != RegOpenKey(
+
+
+
+
+
5986 retval = MERROR_FILE;
+
+
+
+
5990# warning "config close not implemented"
+
+
+
+
+
+
+
+
+
+
6000# if defined( RETROFLAT_CONFIG_USE_FILE )
+
+
6002 debug_printf( 1,
"closing config file..." );
+
+
+
+
6006# elif defined( RETROFLAT_API_WIN16 )
+
+
+
+
6010# elif defined( RETROFLAT_API_WIN32 )
+
+
+
+
+
+
+
6017# warning "config close not implemented"
+
+
+
+
+
+
+
6024#ifdef RETROFLAT_CONFIG_USE_FILE
+
+
6031static char* retroflat_config_tok_sect(
+
6032 char* line,
size_t line_sz,
const char* sect_name,
size_t* sect_match
+
+
+
+
6036 if(
'[' == line[0] ) {
+
6037 *sect_match = strncmp( sect_name, &(line[1]), line_sz - 2 );
+
6038 if( 0 == *sect_match ) {
+
+
6040 line[line_sz - 1] =
'\0';
+
6041 debug_printf( 1,
"found section: %s", &(line[1]) );
+
+
+
+
+
+
+
+
+
+
+
+
+
+
6055 const char* sect_name,
const char* key_name, uint8_t buffer_type,
+
6056 void* buffer,
size_t buffer_sz_max
+
+
+
+
+
+
+
+
+
+
+
+
6068 const char* sect_name,
const char* key_name, uint8_t buffer_type,
+
6069 void* buffer_out,
size_t buffer_out_sz_max,
+
6070 const void* default_out,
size_t default_out_sz
+
+
+
6073# if defined( RETROFLAT_CONFIG_USE_FILE )
+
6074 char line[RETROFLAT_CONFIG_LN_SZ_MAX + 1];
+
6075 char* line_val = NULL;
+
+
6077 size_t sect_match = 1;
+
+
+
6080# if defined( RETROFLAT_CONFIG_USE_FILE )
+
+
+
+
6084 while( fgets( line, RETROFLAT_CONFIG_LN_SZ_MAX, *config ) ) {
+
+
6086 line_sz = strlen( line );
+
6087 if( 1 >= line_sz || RETROFLAT_CONFIG_LN_SZ_MAX <= line_sz ) {
+
6088 error_printf(
"invalid line sz: " SIZE_T_FMT, line_sz );
+
+
+
+
+
6093 if(
'\n' == line[line_sz - 1] ||
'\r' == line[line_sz - 1] ) {
+
6094 debug_printf( 1,
"stripping newline!" );
+
+
6096 line[line_sz] =
'\0';
+
+
+
+
+
6101 retroflat_config_tok_sect( line, line_sz, sect_name, §_match )
+
+
+
+
+
+
6107 line_val = strchr( line,
'=' );
+
6108 if( NULL == line_val || line_val == line ) {
+
6109 error_printf(
"invalid line: %s", line );
+
+
+
+
+
+
+
+
6117 if( 0 == sect_match && 0 == strcmp( key_name, line ) ) {
+
6118 debug_printf( 1,
"found %s: %s", line, line_val );
+
+
6120 switch( buffer_type ) {
+
6121 case RETROFLAT_BUFFER_INT:
+
6122 *((
int*)buffer_out) = atoi( line_val );
+
+
+
6125 case RETROFLAT_BUFFER_FLOAT:
+
6126 *((
float*)buffer_out) = atof( line_val );
+
+
+
6129 case RETROFLAT_BUFFER_STRING:
+
6130 strncpy( (
char*)buffer_out, line_val, buffer_out_sz_max );
+
+
+
6133 case RETROFLAT_BUFFER_BOOL:
+
+
+
+
+
+
+
+
+
6142 fseek( *config, 0, SEEK_SET );
+
+
6144# elif defined( RETROFLAT_API_WIN16 )
+
+
+
+
+
+
+
+
+
6153# elif defined( RETROFLAT_API_WIN32 )
+
+
+
+
+
+
+
6160# warning "config read not implemented"
+
+
+
+
+
+
6166#elif !defined( RETROVDP_C )
+
+
6168#define RETROFLAT_COLOR_TABLE_CONSTS( idx, name_l, name_u, r, g, b ) \
+
6169 extern MAUG_CONST RETROFLAT_COLOR RETROFLAT_COLOR_ ## name_u;
+
+
6171RETROFLAT_COLOR_TABLE( RETROFLAT_COLOR_TABLE_CONSTS )
+
+
6173extern MAUG_CONST
char* gc_retroflat_color_names[];
+
+
+
6176# if defined( RETROFLAT_API_WIN16 ) || defined( RETROFLAT_API_WIN32 )
+
6177 extern HINSTANCE g_retroflat_instance;
+
6178 extern int g_retroflat_cmd_show;
+
+
+
+
+
6183# if defined( RETROFLAT_SOFT_SHAPES ) && !defined( MAUG_NO_AUTO_C )
+
+
6185# include <retrosft.h>
+
+
+
6188# if defined( RETROFLAT_OPENGL ) && !defined( MAUG_NO_AUTO_C )
+
+
+
6191# include <retrosft.h>
+
+
+
+
+
+
+
+
+
+
+
+
+
+
MERROR_RETVAL maug_add_arg(const char *arg, int arg_sz, const char *help, int help_sz, maug_cli_cb arg_cb, maug_cli_cb def_cb, void *data)
Add a command-line argument to the built-in parser.
+
#define MAUG_CLI_SIGIL
Default flag to prepend to CLI arguments. Is "/" on Windows/DOS and "-" on other platforms....
Definition marge.h:34
+
int MERROR_RETVAL
Return type indicating function returns a value from this list.
Definition merror.h:19
+
#define RETROFLAT_BITMAP_EXT
The filename suffix to be appended with a "." to filenames passed to retroflat_load_bitmap()....
Definition retroflt.h:521
+
#define RETROFLAT_TXP_G
Compiler-define-overridable constant indicating the Green value of the transparency color on platform...
Definition retroflt.h:544
+
void retroflat_blit_bitmap(struct RETROFLAT_BITMAP *target, struct RETROFLAT_BITMAP *src, int s_x, int s_y, int d_x, int d_y, int w, int h)
Blit the contents of a RETROFLAT_BITMAP onto another RETROFLAT_BITMAP.
+
MERROR_RETVAL retroflat_load_bitmap(const char *filename, struct RETROFLAT_BITMAP *bmp_out)
Load a bitmap into the given RETROFLAT_BITMAP structure if it is available. Bitmaps are subject to th...
+
MERROR_RETVAL retroflat_load_xpm(const char *filename, struct RETROFLAT_BITMAP *bmp_out)
Load a compiled-in XPM image into an API-specific bitmap context. \warn The XPM must have been genera...
+
void retroflat_destroy_bitmap(struct RETROFLAT_BITMAP *bitmap)
Unload a bitmap from a RETROFLAT_BITMAP struct. The struct, itself, is not freed (in case it is on th...
+
#define RETROFLAT_TXP_B
Compiler-define-overridable constant indicating the Blue value of the transparency color on platforms...
Definition retroflt.h:553
+
#define retroflat_bitmap_ok(bitmap)
Check to see if a bitmap is loaded.
Definition retroflt.h:1619
+
#define RETROFLAT_TXP_R
Compiler-define-overridable constant indicating the Red value of the transparency color on platforms ...
Definition retroflt.h:535
+
#define RETROFLAT_WIN_GFX_TIMER_ID
Unique ID for the timer that execute graphics ticks in Win16/Win32. Is a RetroFlat Compiler Definitio...
Definition retroflt.h:611
+
#define NDS_SPRITES_ACTIVE
Maximum number of sprites active on-screen on Nintendo DS.
Definition retroflt.h:679
+
#define RETROFLAT_VDP_ARGS_SZ_MAX
Definition retroflt.h:635
+
#define RETROFLAT_MSG_MAX
Maximum number of characters possible in a message using retroflat_message(). Is a RetroFlat Compiler...
Definition retroflt.h:619
+
#define RETROFLAT_WINDOW_CLASS
Unique window class to use on some platforms (e.g. Win32). Is a RetroFlat Compiler Definitions.
Definition retroflt.h:603
+
#define RETROFLAT_FPS
Target Frames Per Second.
Definition retroflt.h:593
+
#define RETROFLAT_ASSETS_PATH_MAX
Maximum size of the assets path, to allow room for appending.
Definition retroflt.h:670
+
#define NDS_OAM_ACTIVE
Active sprite engine screen on Nintendo DS.
Definition retroflt.h:674
+
#define RETROFLAT_PATH_MAX
Maximum size allocated for asset paths.
Definition retroflt.h:624
+
#define RETROFLAT_PATH_SEP
The valid path separator on the target platform.
Definition retroflt.h:666
+
#define RETROFLAT_CONFIG_FLAG_W
Flag indicating config object should be opened for WRITING only.
Definition retroflt.h:419
+
#define RETROFLAT_CONFIG_FLAG_BIN
Flag indicating config object holds BINARY data.
Definition retroflt.h:424
+
FILE * RETROFLAT_CONFIG
A configuration object to use with the RetroFlat Config API.
Definition retroflt.h:1595
+
size_t retroflat_config_write(RETROFLAT_CONFIG *config, const char *sect_name, const char *key_name, uint8_t buffer_type, void *buffer, size_t buffer_sz_max)
Write the contents of a buffer to a config object.
+
size_t retroflat_config_read(RETROFLAT_CONFIG *config, const char *sect_name, const char *key_name, uint8_t buffer_type, void *buffer_out, size_t buffer_out_sz_max, const void *default_out, size_t default_out_sz)
Write the contents of a buffer to a config object.
+
MERROR_RETVAL retroflat_config_open(RETROFLAT_CONFIG *config, uint8_t flags)
Open a configuration file/registry/SRAM/etc handle.
+
#define RETROFLAT_FLAGS_OPAQUE
Flag for retroflat_create_bitmap() to create a bitmap without transparency.
Definition retroflt.h:340
+
void retroflat_string(struct RETROFLAT_BITMAP *target, const RETROFLAT_COLOR color, const char *str, int str_sz, const char *font_str, int x_orig, int y_orig, uint8_t flags)
Draw a text string at the specified location in the specified font and color on the target RETROFLAT_...
+
void retroflat_ellipse(struct RETROFLAT_BITMAP *target, const RETROFLAT_COLOR color, int x, int y, int w, int h, uint8_t flags)
Draw an ellipse onto the target RETROFLAT_BITMAP.
+
MERROR_RETVAL retroflat_draw_lock(struct RETROFLAT_BITMAP *bmp)
Lock a bitmap for drawing. This will be done automatically if necessary and not called explicitly,...
+
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)
Get the size in pixels of a text string when drawn with a given font by retroflat_string().
+
void retroflat_line(struct RETROFLAT_BITMAP *target, const RETROFLAT_COLOR color, int x1, int y1, int x2, int y2, uint8_t flags)
Draw a straight line onto the target RETROFLAT_BITMAP.
+
void retroflat_rect(struct RETROFLAT_BITMAP *target, const RETROFLAT_COLOR color, int x, int y, int w, int h, uint8_t flags)
Draw a rectangle onto the target RETROFLAT_BITMAP.
+
#define RETROFLAT_FLAGS_FILL
Flag for retroflat_rect() or retroflat_ellipse(), indicating drawn shape should be filled.
Definition retroflt.h:334
+
#define RETROFLAT_FLAGS_SCREEN_BUFFER
Flag for retroflat_create_bitmap() to create a WinG-backed bitmap.
Definition retroflt.h:348
+
#define RETROFLAT_FLAGS_SCREENSAVER
Flag indicating the current application is running as a screensaver.
Definition retroflt.h:381
+
#define RETROFLAT_FLAGS_UNLOCK_FPS
Flag indicating FPS should not be capped.
Definition retroflt.h:369
+
#define RETROFLAT_FLAGS_RUNNING
Flag indicating that retroflat_loop() should continue executing.
Definition retroflt.h:363
+
#define RETROFLAT_FLAGS_KEY_REPEAT
Flag indicating keyboard repeat is enabled.
Definition retroflt.h:375
+
+
#define RETROFLAT_OK
Certain functions return this when there was no problem.
Definition retroflt.h:304
+
#define RETROFLAT_ERROR_BITMAP
Returned if there is a problem loading or locking a RETROFLAT_BITMAP struct.
Definition retroflt.h:313
+
MERROR_RETVAL(* retroflat_vdp_proc_t)(struct RETROFLAT_STATE *)
VDP function called from the VDP library.
Definition retroflt.h:479
+
#define RETROFLAT_VDP_FLAG_PXLOCK
Flag for RETROFLAT_STATE::vdp_flags indicating the VDP requires RetroFlat to pixel-lock the frame bef...
Definition retroflt.h:466
+
void retroflat_shutdown(int retval)
Deinitialize RetroFlat and its underlying layers. This should be called once at the end of the progra...
+
#define retroflat_screen_h()
Get the current screen height in pixels.
Definition retroflt.h:1627
+
#define retroflat_quit(retval_in)
This should be called in order to quit a program using RetroFlat.
Definition retroflt.h:1636
+
#define retroflat_screen_buffer()
Get the direct screen buffer or the VDP buffer if a VDP is loaded.
Definition retroflt.h:1630
+
void(* retroflat_loop_iter)(void *data)
Prototype for the main loop function passed to retroflat_loop().
Definition retroflt.h:699
+
MERROR_RETVAL retroflat_loop(retroflat_loop_iter iter, void *data)
This should be called once in the main body of the program in order to enter the main loop....
+
void retroflat_message(uint8_t flags, const char *title, const char *format,...)
Display a message in a dialog box and/or on stderr.
+
#define retroflat_screen_w()
Get the current screen width in pixels.
Definition retroflt.h:1624
+
MERROR_RETVAL retroflat_init(int argc, char *argv[], struct RETROFLAT_ARGS *args)
Initialize RetroFlat and its underlying layers. This should be called once at the beginning of the pr...
+
Contains functions and macros for working with fixed-point numbers.
+
Library of tools for working with RetroFlat and OpenGL.
+
Struct containing configuration values for a RetroFlat program.
Definition retroflt.h:1752
+
char * config_path
Relative path of local config file (if not using registry).
Definition retroflt.h:1766
+
char * assets_path
Relative path under which bitmap assets are stored.
Definition retroflt.h:1763
+
int screen_w
Desired screen or window width in pixels.
Definition retroflt.h:1759
+
int screen_h
Desired screen or window height in pixels.
Definition retroflt.h:1761
+
char * title
Title to set for the main program Window if applicable on the target platform.
Definition retroflt.h:1757
+
Platform-specific bitmap structure. retroflat_bitmap_ok() can be used on a pointer to it to determine...
Definition retroflt.h:1610
+
size_t sz
Size of the bitmap structure, used to check VDP compatibility.
Definition retroflt.h:1612
+
uint8_t flags
Platform-specific bitmap flags.
Definition retroflt.h:1614
+
+
+
+
Global singleton containing state for the current platform.
Definition retroflt.h:1770
+
char vdp_args[RETROFLAT_VDP_ARGS_SZ_MAX]
CLI args passed with -vdp to the RetroFlat VDP API.
Definition retroflt.h:1796
+
uint8_t vdp_flags
Flags set by the RetroFlat VDP API.
Definition retroflt.h:1798
+
uint8_t retroflat_flags
Global Flags indicating current system status.
Definition retroflt.h:1774
+
struct RETROFLAT_BITMAP * vdp_buffer
A buffer assembled and passed to the VDP for its use, or NULL if no VDP is loaded.
Definition retroflt.h:1786
+
struct RETROFLAT_BITMAP buffer
Off-screen buffer bitmap.
Definition retroflt.h:1780
+
void * vdp_exe
A handle for the loaded VDP module.
Definition retroflt.h:1791
+
RETROFLAT_COLOR_DEF palette[RETROFLAT_COLORS_SZ]
Index of available colors, initialized on platform init.
Definition retroflt.h:1778
+
void * vdp_data
Pointer to data defined by the VDP for its use.
Definition retroflt.h:1794
+
+
