alice.mosphere.at / TIC-80
this repo has no description
0
fork

Configure Feed

Select the types of activity you want to include in your feed.

Gamepad mapping added to the RAM #1663 #1748

nesbox 3e7f3f55 0607ff0e

+171 -148
+10 -4
src/core/io.c
··· 132 132 : (tic_point){memory->ram.input.mouse.x - TIC80_OFFSET_LEFT, memory->ram.input.mouse.y - TIC80_OFFSET_TOP}; 133 133 } 134 134 135 - void tic_core_tick_io(tic_mem* memory) 135 + void tic_core_tick_io(tic_mem* tic) 136 136 { 137 - tic_core* core = (tic_core*)memory; 137 + tic_core* core = (tic_core*)tic; 138 + 139 + // process gamepads mapping 140 + u8* keycodes = tic->ram.mapping.data; 141 + for(s32 i = 0; i < sizeof(tic_mapping); ++i) 142 + if(keycodes[i] && tic_api_key(tic, keycodes[i])) 143 + tic->ram.input.gamepads.data |= 1 << i; 138 144 139 145 // process gamepad 140 146 for (s32 i = 0; i < COUNT_OF(core->state.gamepads.holds); i++) 141 147 { 142 148 u32 mask = 1 << i; 143 149 u32 prevDown = core->state.gamepads.previous.data & mask; 144 - u32 down = memory->ram.input.gamepads.data & mask; 150 + u32 down = tic->ram.input.gamepads.data & mask; 145 151 146 152 u32* hold = &core->state.gamepads.holds[i]; 147 153 if (prevDown && prevDown == down) (*hold)++; ··· 152 158 for (s32 i = 0; i < tic_keys_count; i++) 153 159 { 154 160 bool prevDown = isKeyPressed(&core->state.keyboard.previous, i); 155 - bool down = isKeyPressed(&memory->ram.input.keyboard, i); 161 + bool down = isKeyPressed(&tic->ram.input.keyboard, i); 156 162 157 163 u32* hold = &core->state.keyboard.holds[i]; 158 164
+37 -31
src/studio/config.c
··· 230 230 config->data = (StudioConfig) 231 231 { 232 232 .cart = config->cart, 233 - .menu = 233 + .options = 234 234 { 235 - .volume = MAX_VOLUME, 236 - .vsync = true, 237 - .fullscreen = false, 238 235 #if defined(CRT_SHADER_SUPPORT) 239 236 .crt = false, 240 237 #endif 238 + .volume = MAX_VOLUME, 239 + .vsync = true, 240 + .fullscreen = false, 241 + .mapping = (tic_mapping) 242 + { 243 + tic_key_up, 244 + tic_key_down, 245 + tic_key_left, 246 + tic_key_right, 247 + 248 + tic_key_z, // a 249 + tic_key_x, // b 250 + tic_key_a, // x 251 + tic_key_s, // y 252 + }, 241 253 }, 242 254 }; 243 255 ··· 278 290 279 291 static void save(Config* config) 280 292 { 281 - memcpy(config->cart, &config->tic->cart, sizeof(tic_cartridge)); 293 + *config->cart = config->tic->cart; 282 294 readConfig(config); 283 295 saveConfig(config, true); 284 296 285 297 studioConfigChanged(); 286 298 } 287 299 288 - static const char MenuDatPath[] = TIC_LOCAL_VERSION "menu.dat"; 300 + static const char OptionsDatPath[] = TIC_LOCAL_VERSION "options.dat"; 301 + 302 + static void loadConfigData(tic_fs* fs, const char* path, void* dst, s32 size) 303 + { 304 + s32 dataSize = 0; 305 + u8* data = (u8*)tic_fs_loadroot(fs, path, &dataSize); 306 + 307 + if(data) SCOPE(free(data)) 308 + if(dataSize == size) 309 + memcpy(dst, data, size); 310 + } 289 311 290 312 void initConfig(Config* config, tic_mem* tic, tic_fs* fs) 291 313 { 314 + *config = (Config) 292 315 { 293 - config->tic = tic; 294 - config->cart = malloc(sizeof(tic_cartridge)); 295 - config->save = save; 296 - config->reset = reset; 297 - config->fs = fs; 298 - } 316 + .tic = tic, 317 + .cart = realloc(config->cart, sizeof(tic_cartridge)), 318 + .save = save, 319 + .reset = reset, 320 + .fs = fs, 321 + }; 299 322 300 323 setDefault(config); 301 324 ··· 313 336 else saveConfig(config, false); 314 337 } 315 338 316 - // read menu.dat 317 - { 318 - s32 size = 0; 319 - u8* data = (u8*)tic_fs_loadroot(fs, MenuDatPath, &size); 320 - 321 - if(data) 322 - { 323 - enum{Size = sizeof config->data.menu}; 324 - if(size == Size) 325 - memcpy(&config->data.menu, data, Size); 326 - 327 - free(data); 328 - } 329 - } 339 + loadConfigData(fs, OptionsDatPath, &config->data.options, sizeof config->data.options); 330 340 331 341 tic_api_reset(tic); 332 342 } 333 343 334 344 void freeConfig(Config* config) 335 345 { 336 - // save menu.dat 337 - { 338 - enum{Size = sizeof config->data.menu}; 339 - tic_fs_saveroot(config->fs, MenuDatPath, &config->data.menu, Size, true); 340 - } 346 + tic_fs_saveroot(config->fs, OptionsDatPath, &config->data.options, sizeof config->data.options, true); 341 347 342 348 free(config->cart); 343 349
+1
src/studio/screens/console.c
··· 2731 2731 {offsetof(tic_ram, font.regular.params), "FONT PARAMS"}, 2732 2732 {offsetof(tic_ram, font.alt), "ALT FONT"}, 2733 2733 {offsetof(tic_ram, font.alt.params), "ALT FONT PARAMS"}, 2734 + {offsetof(tic_ram, mapping), "BUTTONS MAPPING"}, 2734 2735 {offsetof(tic_ram, free), "... (free)"}, 2735 2736 {TIC_RAM_SIZE, ""}, 2736 2737 };
+13 -6
src/studio/screens/menu.c
··· 237 237 238 238 if(animIdle(menu)) 239 239 { 240 - if(tic_api_btnp(menu->tic, Up, Hold, Period)) 240 + if(tic_api_btnp(menu->tic, Up, Hold, Period) 241 + || tic_api_keyp(tic, tic_key_up, Hold, Period)) 241 242 { 242 243 playSystemSfx(2); 243 244 resetMovie(menu, &menu->anim.up); 244 245 } 245 246 246 - if(tic_api_btnp(menu->tic, Down, Hold, Period)) 247 + if(tic_api_btnp(menu->tic, Down, Hold, Period) 248 + || tic_api_keyp(tic, tic_key_down, Hold, Period)) 247 249 { 248 250 playSystemSfx(2); 249 251 resetMovie(menu, &menu->anim.down); ··· 252 254 MenuOption* option = menu->items[menu->pos].option; 253 255 if(option) 254 256 { 255 - if(tic_api_btnp(menu->tic, Left, Hold, Period)) 257 + if(tic_api_btnp(menu->tic, Left, Hold, Period) 258 + || tic_api_keyp(tic, tic_key_left, Hold, Period)) 256 259 { 257 260 playSystemSfx(2); 258 261 updateOption(option, -1); 259 262 } 260 263 261 - if(tic_api_btnp(menu->tic, Right, Hold, Period)) 264 + if(tic_api_btnp(menu->tic, Right, Hold, Period) 265 + || tic_api_keyp(tic, tic_key_right, Hold, Period)) 262 266 { 263 267 playSystemSfx(2); 264 268 updateOption(option, +1); 265 269 } 266 270 } 267 271 268 - if(tic_api_btnp(menu->tic, A, -1, -1) || tic_api_keyp(tic, tic_key_return, -1, -1)) 272 + if(tic_api_btnp(menu->tic, A, -1, -1) 273 + || tic_api_keyp(tic, tic_key_return, Hold, Period)) 269 274 { 270 275 if(option) 271 276 { ··· 279 284 } 280 285 } 281 286 282 - if(tic_api_btnp(menu->tic, B, -1, -1) && menu->back) 287 + if((tic_api_btnp(menu->tic, B, -1, -1) 288 + || tic_api_keyp(tic, tic_key_backspace, Hold, Period)) 289 + && menu->back) 283 290 { 284 291 playSystemSfx(2); 285 292 resetMovie(menu, &menu->anim.back);
+10 -7
src/studio/screens/surf.c
··· 779 779 Up, Down, Left, Right, A, B, X, Y 780 780 }; 781 781 782 - if(tic_api_btnp(tic, Up, Hold, Period)) 782 + if(tic_api_btnp(tic, Up, Hold, Period) 783 + || tic_api_keyp(tic, tic_key_up, Hold, Period)) 783 784 { 784 785 surf->menu.anim = 1; 785 786 surf->menu.anim_target = -1; 786 787 787 788 playSystemSfx(2); 788 789 } 789 - else if(tic_api_btnp(tic, Down, Hold, Period)) 790 + else if(tic_api_btnp(tic, Down, Hold, Period) 791 + || tic_api_keyp(tic, tic_key_down, Hold, Period)) 790 792 { 791 793 surf->menu.anim = 1; 792 794 surf->menu.anim_target = 1; 793 795 794 796 playSystemSfx(2); 795 797 } 796 - else if( 797 - tic_api_btnp(tic, Left, Hold, Period) 798 + else if(tic_api_btnp(tic, Left, Hold, Period) 799 + || tic_api_keyp(tic, tic_key_left, Hold, Period) 798 800 || tic_api_keyp(tic, tic_key_pageup, Hold, Period)) 799 801 { 800 802 surf->menu.anim = 1; 801 803 surf->menu.anim_target = -5; 802 804 } 803 - else if( 804 - tic_api_btnp(tic, Right, Hold, Period) 805 + else if(tic_api_btnp(tic, Right, Hold, Period) 806 + || tic_api_keyp(tic, tic_key_right, Hold, Period) 805 807 || tic_api_keyp(tic, tic_key_pagedown, Hold, Period)) 806 808 { 807 809 surf->menu.anim = 1; ··· 817 819 : loadCart(surf); 818 820 } 819 821 820 - if(tic_api_btnp(tic, B, -1, -1)) 822 + if(tic_api_btnp(tic, B, -1, -1) 823 + || tic_api_keyp(tic, tic_key_backspace, -1, -1)) 821 824 { 822 825 goBackDir(surf); 823 826 }
+87 -87
src/studio/studio.c
··· 121 121 MouseState state[3]; 122 122 } mouse; 123 123 124 - tic_key keycodes[KEYMAP_COUNT]; 125 - 126 124 #if defined(BUILD_EDITORS) 127 125 EditorMode menuMode; 128 126 ··· 208 206 .mode = TIC_START_MODE, 209 207 .prevMode = TIC_CODE_MODE, 210 208 211 - .keycodes = 212 - { 213 - tic_key_up, 214 - tic_key_down, 215 - tic_key_left, 216 - tic_key_right, 217 - 218 - tic_key_z, // a 219 - tic_key_x, // b 220 - tic_key_a, // x 221 - tic_key_s, // y 222 - }, 223 209 #if defined(BUILD_EDITORS) 224 210 .cart = 225 211 { ··· 1148 1134 1149 1135 static void optionFullscreenSet(s32 pos) 1150 1136 { 1151 - tic_sys_fullscreen_set(impl.config->data.menu.fullscreen = (pos == 1)); 1137 + tic_sys_fullscreen_set(impl.config->data.options.fullscreen = (pos == 1)); 1152 1138 } 1153 1139 1154 1140 static const char OffValue[] = "<OFF> "; ··· 1164 1150 #if defined(CRT_SHADER_SUPPORT) 1165 1151 static s32 optionCrtMonitorGet() 1166 1152 { 1167 - return impl.config->data.menu.crt ? 1 : 0; 1153 + return impl.config->data.options.crt ? 1 : 0; 1168 1154 } 1169 1155 1170 1156 static void optionCrtMonitorSet(s32 pos) 1171 1157 { 1172 - impl.config->data.menu.crt = pos == 1; 1158 + impl.config->data.options.crt = pos == 1; 1173 1159 } 1174 1160 1175 1161 static MenuOption CrtMonitorOption = ··· 1183 1169 1184 1170 static s32 optionVSyncGet() 1185 1171 { 1186 - return getConfig()->menu.vsync ? 1 : 0; 1172 + return getConfig()->options.vsync ? 1 : 0; 1187 1173 } 1188 1174 1189 1175 static void optionVSyncSet(s32 pos) 1190 1176 { 1191 - impl.config->data.menu.vsync = pos == 1; 1177 + impl.config->data.options.vsync = pos == 1; 1192 1178 } 1193 1179 1194 1180 static MenuOption VSyncOption = ··· 1200 1186 1201 1187 static s32 optionVolumeGet() 1202 1188 { 1203 - return impl.config->data.menu.volume; 1189 + return impl.config->data.options.volume; 1204 1190 } 1205 1191 1206 1192 static void optionVolumeSet(s32 pos) 1207 1193 { 1208 - impl.config->data.menu.volume = pos; 1194 + impl.config->data.options.volume = pos; 1209 1195 } 1210 1196 1211 1197 static MenuOption VolumeOption = 1212 1198 { 1213 1199 OPTION_VALUES( 1214 1200 { 1215 - "<00> ", 1216 - "<01> ", 1217 - "<02> ", 1218 - "<03> ", 1219 - "<04> ", 1220 - "<05> ", 1221 - "<06> ", 1222 - "<07> ", 1223 - "<08> ", 1224 - "<09> ", 1225 - "<10> ", 1226 - "<11> ", 1227 - "<12> ", 1228 - "<13> ", 1229 - "<14> ", 1230 - "<15> ", 1201 + "<00> ", "<01> ", "<02> ", "<03> ", 1202 + "<04> ", "<05> ", "<06> ", "<07> ", 1203 + "<08> ", "<09> ", "<10> ", "<11> ", 1204 + "<12> ", "<13> ", "<14> ", "<15> ", 1231 1205 }), 1232 1206 optionVolumeGet, 1233 1207 optionVolumeSet, ··· 1311 1285 Count, Count - 5, COUNT_OF(GameMenu) - 3, showGameMenu, NULL); 1312 1286 } 1313 1287 1288 + static const char* KeysList[] = 1289 + { 1290 + "<A> ", "<B> ", "<C> ", "<D> ", "<E> ", "<F> ", "<G> ", "<H> ", 1291 + "<I> ", "<J> ", "<K> ", "<L> ", "<M> ", "<N> ", "<O> ", "<P> ", 1292 + "<Q> ", "<R> ", "<S> ", "<T> ", "<U> ", "<V> ", "<W> ", "<X> ", 1293 + "<Y> ", "<Z> ", "<0> ", "<1> ", "<2> ", "<3> ", "<4> ", "<5> ", 1294 + "<6> ", "<7> ", "<8> ", "<9> ", "<-> ", "<=> ", "<[> ", "<]> ", 1295 + "<\\> ","<;> ", "<'> ", "<`> ", "<,> ", "<.> ", "</> ", "< > ", 1296 + "<TAB> ", "<RET> ", "<BACKS>", "<DEL> ", "<INS> ", "<PGUP> ", "<PGDN> ", "<HOME> ", 1297 + "<END> ", "<UP> ", "<DOWN> ", "<LEFT> ", "<RIGHT>", "<CAPS> ", "<CTRL> ", "<SHIFT>", 1298 + "<ALT> ", "<ESC> ", "<F1> ", "<F2> ", "<F3> ", "<F4> ", "<F5> ", "<F6> ", 1299 + "<F7> ", "<F8> ", "<F9> ", "<F10> ", "<F11> ", "<F12> ", 1300 + }; 1301 + 1302 + static tic_mapping GamepadMapping; 1303 + 1304 + #define OPTION_KEY(KEY) \ 1305 + \ 1306 + enum{KEY ## KeyIndex = __COUNTER__}; \ 1307 + \ 1308 + static s32 option ## KEY ## KeyGet() \ 1309 + { \ 1310 + return GamepadMapping.data[KEY ## KeyIndex] - 1; \ 1311 + } \ 1312 + \ 1313 + static void option ## KEY ## KeySet(s32 pos) \ 1314 + { \ 1315 + GamepadMapping.data[KEY ## KeyIndex] = pos + 1; \ 1316 + } \ 1317 + \ 1318 + static MenuOption KEY ## KeyOption = \ 1319 + { \ 1320 + .values = KeysList, \ 1321 + .count = COUNT_OF(KeysList), \ 1322 + option ## KEY ## KeyGet, \ 1323 + option ## KEY ## KeySet, \ 1324 + }; 1325 + 1326 + OPTION_KEY(Up) 1327 + OPTION_KEY(Down) 1328 + OPTION_KEY(Left) 1329 + OPTION_KEY(Right) 1330 + OPTION_KEY(A) 1331 + OPTION_KEY(B) 1332 + OPTION_KEY(X) 1333 + OPTION_KEY(Y) 1334 + 1335 + static void backGamepadMenu() 1336 + { 1337 + impl.config->data.options.mapping = GamepadMapping; 1338 + showOptionsMenu(); 1339 + } 1340 + 1314 1341 static void showGamepadMenu() 1315 1342 { 1316 1343 static const MenuItem GamepadMenu[] = 1317 1344 { 1318 - {"UP <...>", NULL}, 1319 - {"DOWN <...>", NULL}, 1320 - {"LEFT <...>", NULL}, 1321 - {"RIGHT <...>", NULL}, 1322 - {"A <...>", NULL}, 1323 - {"B <...>", NULL}, 1324 - {"X <...>", NULL}, 1325 - {"Y <...>", NULL}, 1345 + {"UP ", NULL, &UpKeyOption}, 1346 + {"DOWN ", NULL, &DownKeyOption}, 1347 + {"LEFT ", NULL, &LeftKeyOption}, 1348 + {"RIGHT ", NULL, &RightKeyOption}, 1349 + {"A ", NULL, &AKeyOption}, 1350 + {"B ", NULL, &BKeyOption}, 1351 + {"X ", NULL, &XKeyOption}, 1352 + {"Y ", NULL, &YKeyOption}, 1326 1353 1327 1354 {"", NULL}, 1328 - {"BACK", showOptionsMenu}, 1355 + {"BACK", backGamepadMenu}, 1329 1356 }; 1330 1357 1358 + GamepadMapping = impl.studio.tic->ram.mapping; 1359 + 1331 1360 studio_menu_init(impl.menu, GamepadMenu, COUNT_OF(GamepadMenu), 1332 - 0, COUNT_OF(OptionMenu) - 3, showOptionsMenu, NULL); 1361 + 0, COUNT_OF(OptionMenu) - 3, backGamepadMenu, NULL); 1333 1362 } 1334 1363 1335 1364 static inline bool pointInRect(const tic_point* pt, const tic_rect* rect) ··· 1536 1565 } 1537 1566 #endif 1538 1567 1539 - tic_key* getKeymap() 1540 - { 1541 - return impl.keycodes; 1542 - } 1543 - 1544 - static void processGamepadMapping() 1545 - { 1546 - tic_mem* tic = impl.studio.tic; 1547 - 1548 - for(s32 i = 0; i < KEYMAP_COUNT; i++) 1549 - if(impl.keycodes[i] && tic_api_key(tic, impl.keycodes[i])) 1550 - tic->ram.input.gamepads.data |= 1 << i; 1551 - } 1552 - 1553 1568 static inline bool isGameMenu() 1554 1569 { 1555 1570 return (impl.mode == TIC_RUN_MODE || impl.mode == TIC_MENU_MODE) ··· 1714 1729 #if defined(CRT_SHADER_SUPPORT) 1715 1730 static void switchCrtMonitor() 1716 1731 { 1717 - impl.config->data.menu.crt = !impl.config->data.menu.crt; 1732 + impl.config->data.options.crt = !impl.config->data.options.crt; 1718 1733 } 1719 1734 #endif 1720 1735 ··· 1969 1984 sfx2ram(&tic->ram, sfx); 1970 1985 music2ram(&tic->ram, music); 1971 1986 1987 + // restore mapping in all the modes except Run mode 1988 + if(impl.mode != TIC_RUN_MODE) 1989 + impl.studio.tic->ram.mapping = getConfig()->options.mapping; 1990 + 1972 1991 tic_core_tick_start(tic); 1973 1992 } 1974 1993 ··· 1980 1999 VBANK(tic, 1) 1981 2000 { 1982 2001 tic_api_cls(tic, 0); 1983 - } 2002 + } 1984 2003 } 1985 2004 1986 2005 switch(impl.mode) ··· 2084 2103 tic_sys_update_config(); 2085 2104 } 2086 2105 2087 - static void initKeymap() 2088 - { 2089 - tic_fs* fs = impl.fs; 2090 - 2091 - s32 size = 0; 2092 - u8* data = (u8*)tic_fs_load(fs, KEYMAP_DAT_PATH, &size); 2093 - 2094 - if(data) 2095 - { 2096 - if(size == KEYMAP_SIZE) 2097 - memcpy(getKeymap(), data, KEYMAP_SIZE); 2098 - 2099 - free(data); 2100 - } 2101 - } 2102 - 2103 2106 static void processMouseStates() 2104 2107 { 2105 2108 for(s32 i = 0; i < COUNT_OF(impl.mouse.state); i++) ··· 2184 2187 } 2185 2188 2186 2189 processMouseStates(); 2187 - processGamepadMapping(); 2188 - 2189 2190 renderStudio(); 2190 2191 2191 2192 { ··· 2236 2237 tic_mem* tic = impl.studio.tic; 2237 2238 tic_core_synth_sound(tic); 2238 2239 2239 - s32 volume = getConfig()->menu.volume; 2240 + s32 volume = getConfig()->options.volume; 2240 2241 2241 2242 if(volume != MAX_VOLUME) 2242 2243 { ··· 2388 2389 tic_fs_makedir(impl.fs, TIC_LOCAL_VERSION); 2389 2390 2390 2391 initConfig(impl.config, impl.studio.tic, impl.fs); 2391 - initKeymap(); 2392 2392 initStart(impl.start, impl.studio.tic, args.cart); 2393 2393 initRunMode(); 2394 2394 ··· 2402 2402 impl.config->data.uiScale = args.scale; 2403 2403 2404 2404 if(args.volume >= 0) 2405 - impl.config->data.menu.volume = args.volume & 0x0f; 2405 + impl.config->data.options.volume = args.volume & 0x0f; 2406 2406 2407 2407 #if defined(CRT_SHADER_SUPPORT) 2408 - impl.config->data.menu.crt |= args.crt; 2408 + impl.config->data.options.crt |= args.crt; 2409 2409 #endif 2410 2410 2411 - impl.config->data.menu.fullscreen |= args.fullscreen; 2412 - impl.config->data.menu.vsync |= args.vsync; 2411 + impl.config->data.options.fullscreen |= args.fullscreen; 2412 + impl.config->data.options.vsync |= args.vsync; 2413 2413 impl.config->data.soft |= args.soft; 2414 2414 impl.config->data.cli |= args.cli; 2415 2415
-7
src/studio/studio.h
··· 54 54 #define CONFIG_TIC "config.tic" 55 55 #define CONFIG_TIC_PATH TIC_LOCAL_VERSION CONFIG_TIC 56 56 57 - #define KEYMAP_COUNT (sizeof(tic80_gamepads) * BITS_IN_BYTE) 58 - #define KEYMAP_SIZE (KEYMAP_COUNT) 59 - #define KEYMAP_DAT "keymap.dat" 60 - #define KEYMAP_DAT_PATH TIC_LOCAL_VERSION KEYMAP_DAT 61 - 62 57 #define CART_EXT ".tic" 63 58 #define PNG_EXT ".png" 64 59 ··· 220 215 221 216 void setStudioEvent(StudioEvent event); 222 217 void showTooltip(const char* text); 223 - 224 - tic_key* getKeymap(); 225 218 226 219 void setSpritePixel(tic_tile* tiles, s32 x, s32 y, u8 color); 227 220 u8 getSpritePixel(tic_tile* tiles, s32 x, s32 y);
+3 -2
src/studio/system.h
··· 123 123 124 124 bool fullscreen; 125 125 bool vsync; 126 - s32 volume; 127 - } menu; 126 + s32 volume; 127 + tic_mapping mapping; 128 + } options; 128 129 129 130 const tic_cartridge* cart; 130 131
+4 -4
src/system/sdl/main.c
··· 495 495 496 496 static void initGPU() 497 497 { 498 - bool vsync = platform.studio->config()->menu.vsync; 498 + bool vsync = platform.studio->config()->options.vsync; 499 499 bool soft = platform.studio->config()->soft; 500 500 501 501 #if defined(CRT_SHADER_SUPPORT) ··· 1498 1498 1499 1499 #if defined(CRT_SHADER_SUPPORT) 1500 1500 1501 - if(!platform.studio->config()->soft && platform.studio->config()->menu.crt) 1501 + if(!platform.studio->config()->soft && platform.studio->config()->options.crt) 1502 1502 { 1503 1503 if(platform.screen.shader == 0) 1504 1504 loadCrtShader(); ··· 1612 1612 setWindowIcon(); 1613 1613 initGPU(); 1614 1614 1615 - if(platform.studio->config()->menu.fullscreen) 1615 + if(platform.studio->config()->options.fullscreen) 1616 1616 tic_sys_fullscreen_set(true); 1617 1617 } 1618 1618 1619 1619 SDL_PauseAudioDevice(platform.audio.device, 0); 1620 1620 1621 1621 #if defined(__EMSCRIPTEN__) 1622 - emscripten_set_main_loop(emsGpuTick, platform.studio->config()->menu.vsync ? 0 : TIC80_FRAMERATE, 1); 1622 + emscripten_set_main_loop(emsGpuTick, platform.studio->config()->options.vsync ? 0 : TIC80_FRAMERATE, 1); 1623 1623 #else 1624 1624 { 1625 1625 const u64 Delta = SDL_GetPerformanceFrequency() / TIC80_FRAMERATE;
+6
src/tic.h
··· 507 507 u32 data[TIC_PERSISTENT_SIZE]; 508 508 } tic_persistent; 509 509 510 + typedef struct 511 + { 512 + u8 data[sizeof(tic80_gamepads) * BITS_IN_BYTE]; 513 + } tic_mapping; 514 + 510 515 typedef union 511 516 { 512 517 struct ··· 525 530 tic_persistent persistent; 526 531 tic_flags flags; 527 532 tic_font font; 533 + tic_mapping mapping; 528 534 529 535 u8 free; 530 536 };