80486DX2-66/taisei
1
0
Fork 1
Code Issues Activity

Refactored config into a macro hell

Browse source
This commit is contained in:
Andrei "Akari" Alexeyev 2017-02-17 18:03:49 +02:00
parent de6deaca64
commit 32f7edd24e
24 changed files with 453 additions and 455 deletions
Download patch file Download diff file Expand all files Collapse all files

329
src/config.c
View file

@ -7,181 +7,136 @@
*/
#include <string.h>
#include <assert.h>
#include "config.h"
#include "global.h"
#include "paths/native.h"
#include "taisei_err.h"
ConfigEntry configdefs[] = {
{CFGT_KEYBINDING, KEY_UP, "key_up"},
{CFGT_KEYBINDING, KEY_DOWN, "key_down"},
{CFGT_KEYBINDING, KEY_LEFT, "key_left"},
{CFGT_KEYBINDING, KEY_RIGHT, "key_right"},
static bool config_initialized = false;
{CFGT_KEYBINDING, KEY_FOCUS, "key_focus"},
{CFGT_KEYBINDING, KEY_SHOT, "key_shot"},
{CFGT_KEYBINDING, KEY_BOMB, "key_bomb"},
CONFIGDEFS_EXPORT ConfigEntry configdefs[] = {
#define CONFIGDEF(type,entryname,default,ufield) {type, entryname, {.ufield = default}},
#define CONFIGDEF_KEYBINDING(id,entryname,default) CONFIGDEF(CONFIG_TYPE_KEYBINDING, entryname, default, i)
#define CONFIGDEF_GPKEYBINDING(id,entryname,default) CONFIGDEF(CONFIG_TYPE_INT, entryname, default, i)
#define CONFIGDEF_INT(id,entryname,default) CONFIGDEF(CONFIG_TYPE_INT, entryname, default, i)
#define CONFIGDEF_FLOAT(id,entryname,default) CONFIGDEF(CONFIG_TYPE_FLOAT, entryname, default, f)
#define CONFIGDEF_STRING(id,entryname,default) CONFIGDEF(CONFIG_TYPE_STRING, entryname, NULL, s)
{CFGT_KEYBINDING, KEY_FULLSCREEN, "key_fullscreen"},
{CFGT_KEYBINDING, KEY_SCREENSHOT, "key_screenshot"},
{CFGT_KEYBINDING, KEY_SKIP, "key_skip"},
CONFIGDEFS
{0}
{CFGT_KEYBINDING, KEY_IDDQD, "key_iddqd"},
{CFGT_KEYBINDING, KEY_HAHAIWIN, "key_skipstage"},
{CFGT_INT, FULLSCREEN, "fullscreen"},
{CFGT_INT, NO_SHADER, "disable_shader"},
{CFGT_INT, NO_AUDIO, "disable_audio"},
{CFGT_INT, NO_MUSIC, "disable_bgm"},
{CFGT_FLOAT, SFX_VOLUME, "sfx_volume"},
{CFGT_FLOAT, BGM_VOLUME, "bgm_volume"},
{CFGT_INT, NO_STAGEBG, "disable_stagebg"},
{CFGT_INT, NO_STAGEBG_FPSLIMIT, "disable_stagebg_auto_fpslimit"},
{CFGT_INT, SAVE_RPY, "save_rpy"},
{CFGT_INT, VID_WIDTH, "vid_width"},
{CFGT_INT, VID_HEIGHT, "vid_height"},
{CFGT_STRING, PLAYERNAME, "playername"},
{CFGT_INT, GAMEPAD_ENABLED, "gamepad_enabled"},
{CFGT_INT, GAMEPAD_DEVICE, "gamepad_device"},
{CFGT_INT, GAMEPAD_AXIS_UD, "gamepad_axis_ud"},
{CFGT_INT, GAMEPAD_AXIS_LR, "gamepad_axis_lr"},
{CFGT_FLOAT, GAMEPAD_AXIS_DEADZONE, "gamepad_axis_deadzone"},
{CFGT_INT, GAMEPAD_AXIS_FREE, "gamepad_axis_free"},
{CFGT_FLOAT, GAMEPAD_AXIS_UD_SENS, "gamepad_axis_ud_free_sensitivity"},
{CFGT_FLOAT, GAMEPAD_AXIS_LR_SENS, "gamepad_axis_lr_free_sensitivity"},
// gamepad controls
{CFGT_INT, GP_UP, "gamepad_key_up"},
{CFGT_INT, GP_DOWN, "gamepad_key_down"},
{CFGT_INT, GP_LEFT, "gamepad_key_left"},
{CFGT_INT, GP_RIGHT, "gamepad_key_right"},
{CFGT_INT, GP_FOCUS, "gamepad_key_focus"},
{CFGT_INT, GP_SHOT, "gamepad_key_shot"},
{CFGT_INT, GP_BOMB, "gamepad_key_bomb"},
{CFGT_INT, GP_SKIP, "gamepad_key_skip"},
{CFGT_INT, GP_PAUSE, "gamepad_key_pause"},
{CFGT_INT, VSYNC, "vsync"},
{0, 0, 0}
#undef CONFIGDEF
#undef CONFIGDEF_KEYBINDING
#undef CONFIGDEF_GPKEYBINDING
#undef CONFIGDEF_INT
#undef CONFIGDEF_FLOAT
#undef CONFIGDEF_STRING
};
ConfigEntry* config_findentry(char *name) {
void config_init(void) {
if(config_initialized) {
return;
}
#define CONFIGDEF_KEYBINDING(id,entryname,default)
#define CONFIGDEF_GPKEYBINDING(id,entryname,default)
#define CONFIGDEF_INT(id,entryname,default)
#define CONFIGDEF_FLOAT(id,entryname,default)
#define CONFIGDEF_STRING(id,entryname,default) stralloc(&configdefs[CONFIG_##id].val.s, default);
CONFIGDEFS
#undef CONFIGDEF_KEYBINDING
#undef CONFIGDEF_GPKEYBINDING
#undef CONFIGDEF_INT
#undef CONFIGDEF_FLOAT
#undef CONFIGDEF_STRING
config_initialized = true;
}
void config_uninit(void) {
for(ConfigEntry *e = configdefs; e->name; ++e) {
if(e->type == CONFIG_TYPE_STRING && e->val.s) {
free(e->val.s);
e->val.s = NULL;
}
}
}
void config_reset(void) {
#define CONFIGDEF(id,default,ufield) configdefs[CONFIG_##id].val.ufield = default;
#define CONFIGDEF_KEYBINDING(id,entryname,default) CONFIGDEF(id, default, i)
#define CONFIGDEF_GPKEYBINDING(id,entryname,default) CONFIGDEF(id, default, i)
#define CONFIGDEF_INT(id,entryname,default) CONFIGDEF(id, default, i)
#define CONFIGDEF_FLOAT(id,entryname,default) CONFIGDEF(id, default, f)
#define CONFIGDEF_STRING(id,entryname,default) stralloc(&configdefs[CONFIG_##id].val.s, default);
CONFIGDEFS
#undef CONFIGDEF
#undef CONFIGDEF_KEYBINDING
#undef CONFIGDEF_GPKEYBINDING
#undef CONFIGDEF_INT
#undef CONFIGDEF_FLOAT
#undef CONFIGDEF_STRING
}
#ifndef CONFIG_RAWACCESS
ConfigEntry* config_get(ConfigIndex idx) {
assert(idx >= 0 && idx < CONFIGIDX_NUM);
return configdefs + idx;
}
#endif
ConfigEntry* config_find_entry(char *name) {
ConfigEntry *e = configdefs;
do if(!strcmp(e->name, name)) return e; while((++e)->name);
return NULL;
}
ConfigEntry* config_findentry_byid(int id) {
ConfigEntry *e = configdefs;
do if(id == e->key) return e; while((++e)->name);
return NULL;
}
void config_preset(void) {
memset(tconfig.strval, 0, sizeof(tconfig.strval));
memset(tconfig.intval, 0, sizeof(tconfig.intval));
memset(tconfig.fltval, 0, sizeof(tconfig.fltval));
tconfig.intval[KEY_UP] = SDL_SCANCODE_UP;
tconfig.intval[KEY_DOWN] = SDL_SCANCODE_DOWN;
tconfig.intval[KEY_LEFT] = SDL_SCANCODE_LEFT;
tconfig.intval[KEY_RIGHT] = SDL_SCANCODE_RIGHT;
tconfig.intval[KEY_FOCUS] = SDL_SCANCODE_LSHIFT;
tconfig.intval[KEY_SHOT] = SDL_SCANCODE_Z;
tconfig.intval[KEY_BOMB] = SDL_SCANCODE_X;
tconfig.intval[KEY_FULLSCREEN] = SDL_SCANCODE_F11;
tconfig.intval[KEY_SCREENSHOT] = SDL_SCANCODE_P;
tconfig.intval[KEY_SKIP] = SDL_SCANCODE_LCTRL;
tconfig.intval[KEY_IDDQD] = SDL_SCANCODE_Q;
tconfig.intval[KEY_HAHAIWIN] = SDL_SCANCODE_E;
tconfig.intval[FULLSCREEN] = 0;
tconfig.intval[NO_SHADER] = 0;
tconfig.intval[NO_AUDIO] = 0;
tconfig.intval[NO_MUSIC] = 0;
tconfig.fltval[SFX_VOLUME] = 1.0;
tconfig.fltval[BGM_VOLUME] = 1.0;
tconfig.intval[NO_STAGEBG] = 0;
tconfig.intval[NO_STAGEBG_FPSLIMIT] = 40;
tconfig.intval[SAVE_RPY] = 2;
tconfig.intval[VID_WIDTH] = RESX;
tconfig.intval[VID_HEIGHT] = RESY;
char *name = "Player";
tconfig.strval[PLAYERNAME] = malloc(strlen(name)+1);
strcpy(tconfig.strval[PLAYERNAME], name);
for(int o = CONFIG_GPKEY_FIRST; o <= CONFIG_GPKEY_LAST; ++o)
tconfig.intval[o] = -1;
tconfig.intval[GAMEPAD_AXIS_LR] = 0;
tconfig.intval[GAMEPAD_AXIS_UD] = 1;
tconfig.fltval[GAMEPAD_AXIS_UD_SENS] = 1.0;
tconfig.fltval[GAMEPAD_AXIS_LR_SENS] = 1.0;
tconfig.intval[GP_FOCUS] = 0;
tconfig.intval[GP_SHOT] = 1;
tconfig.intval[GP_BOMB] = 2;
tconfig.intval[GP_SKIP] = 3;
tconfig.intval[GP_PAUSE] = 4;
tconfig.intval[VSYNC] = 1;
}
int config_scan2key(int scan) {
int i;
for(i = CONFIG_KEY_FIRST; i <= CONFIG_KEY_LAST; ++i)
if(scan == tconfig.intval[i])
return i;
return -1;
}
int config_button2gpkey(int btn) {
int i;
for(i = CONFIG_GPKEY_FIRST; i <= CONFIG_GPKEY_LAST; ++i)
if(btn == tconfig.intval[i])
return i;
return -1;
}
/*
* The following function is no less ugly than it's name...
* The reason for this crap: config_button2gpkey maps the button ID to the first gamepad control option that's bound to the value of the button, similar to config_sym2key.
* However, we need that in the KEY_* format to use in stuff like player and replay events.
* So we have to transform them, somehow.
* Since I don't think relying on the enum's layout is a better idea, here comes a dumb switch.
*/
int config_gpkey2key(int gpkey) {
switch(gpkey) {
case GP_UP : return KEY_UP ;break;
case GP_DOWN : return KEY_DOWN ;break;
case GP_LEFT : return KEY_LEFT ;break;
case GP_RIGHT : return KEY_RIGHT ;break;
case GP_SHOT : return KEY_SHOT ;break;
case GP_FOCUS : return KEY_FOCUS ;break;
case GP_BOMB : return KEY_BOMB ;break;
case GP_SKIP : return KEY_SKIP ;break;
KeyIndex config_key_from_scancode(int scan) {
for(int i = CONFIG_KEY_FIRST; i <= CONFIG_KEY_LAST; ++i) {
if(configdefs[i].val.i == scan) {
return CFGIDX_TO_KEYIDX(i);
}
}
return -1;
}
int config_button2key(int btn) {
return config_gpkey2key(config_button2gpkey(btn));
GamepadKeyIndex config_gamepad_key_from_gamepad_button(int btn) {
for(int i = CONFIG_GAMEPAD_KEY_FIRST; i <= CONFIG_GAMEPAD_KEY_LAST; ++i) {
if(configdefs[i].val.i == btn) {
return CFGIDX_TO_GPKEYIDX(i);
}
}
return -1;
}
KeyIndex config_key_from_gamepad_key(GamepadKeyIndex gpkey) {
#define CONFIGDEF_GPKEYBINDING(id,entryname,default) case GAMEPAD_##id: return id;
switch(gpkey) {
GPKEYDEFS
default: return -1;
}
#undef CONFIGDEF_GPKEYBINDING
}
GamepadKeyIndex config_gamepad_key_from_key(KeyIndex key) {
#define CONFIGDEF_GPKEYBINDING(id,entryname,default) case id: return GAMEPAD_##id;
switch(key) {
GPKEYDEFS
default: return -1;
}
#undef CONFIGDEF_GPKEYBINDING
}
KeyIndex config_key_from_gamepad_button(int btn) {
return config_key_from_gamepad_key(config_gamepad_key_from_gamepad_button(btn));
}
FILE* config_open(char *filename, char *mode) {
@ -204,30 +159,6 @@ FILE* config_open(char *filename, char *mode) {
return out;
}
int config_intval_p(ConfigEntry *e) {
return tconfig.intval[e->key];
}
char* config_strval_p(ConfigEntry *e) {
return tconfig.strval[e->key];
}
float config_fltval_p(ConfigEntry *e) {
return tconfig.fltval[e->key];
}
int config_intval(char *key) {
return config_intval_p(config_findentry(key));
}
char* config_strval(char *key) {
return config_strval_p(config_findentry(key));
}
float config_fltval(char *key) {
return config_fltval_p(config_findentry(key));
}
void config_save(char *filename) {
FILE *out = config_open(filename, "w");
ConfigEntry *e = configdefs;
@ -238,20 +169,21 @@ void config_save(char *filename) {
fputs("# Generated by taisei\n", out);
do switch(e->type) {
case CFGT_INT:
fprintf(out, "%s = %i\n", e->name, config_intval_p(e));
case CONFIG_TYPE_INT:
fprintf(out, "%s = %i\n", e->name, e->val.i);
break;
case CFGT_KEYBINDING:
fprintf(out, "%s = %s\n", e->name, SDL_GetScancodeName(config_intval_p(e)));
case CONFIG_TYPE_KEYBINDING:
fprintf(out, "%s = %s\n", e->name, SDL_GetScancodeName(e->val.i));
break;
case CFGT_STRING:
fprintf(out, "%s = %s\n", e->name, config_strval_p(e));
case CONFIG_TYPE_STRING:
fprintf(out, "%s = %s\n", e->name, e->val.s);
break;
case CFGT_FLOAT:
fprintf(out, "%s = %f\n", e->name, config_fltval_p(e));
case CONFIG_TYPE_FLOAT:
fprintf(out, "%s = %f\n", e->name, e->val.f);
break;
} while((++e)->name);
fclose(out);
@ -264,7 +196,7 @@ void config_save(char *filename) {
#define FLOATOF(s) ((float)strtod(s, NULL))
void config_set(char *key, char *val) {
ConfigEntry *e = config_findentry(key);
ConfigEntry *e = config_find_entry(key);
if(!e) {
warnx("config_set(): unknown setting '%s'", key);
@ -272,29 +204,28 @@ void config_set(char *key, char *val) {
}
switch(e->type) {
case CFGT_INT:
tconfig.intval[e->key] = INTOF(val);
case CONFIG_TYPE_INT:
e->val.i = INTOF(val);
break;
case CFGT_KEYBINDING: {
case CONFIG_TYPE_KEYBINDING: {
SDL_Scancode scan = SDL_GetScancodeFromName(val);
if(scan == SDL_SCANCODE_UNKNOWN) {
warnx("config_set(): unknown key '%s'", val);
} else {
tconfig.intval[e->key] = scan;
e->val.i = scan;
}
break;
}
case CFGT_STRING:
stralloc(&(tconfig.strval[e->key]), val);
case CONFIG_TYPE_STRING:
stralloc(&e->val.s, val);
break;
case CFGT_FLOAT:
tconfig.fltval[e->key] = FLOATOF(val);
case CONFIG_TYPE_FLOAT:
e->val.f = FLOATOF(val);
break;
}
}
@ -309,9 +240,11 @@ void config_load(char *filename) {
char key[CONFIG_LOAD_BUFSIZE];
char val[CONFIG_LOAD_BUFSIZE];
config_preset();
if(!in)
config_init();
if(!in) {
return;
}
while((c = fgetc(in)) != EOF) {
if(c == '#' && !i) {

238
src/config.h
View file

@ -11,118 +11,186 @@
#include <SDL_keycode.h>
typedef struct Config {
int intval[64];
char* strval[64];
float fltval[64];
} Config;
/*
Define these macros, then use CONFIGDEFS to expand them all for all config entries, or KEYDEFS for just keybindings.
Don't forget to undef them afterwards.
Remember that the id won't have the CONFIG_ prefix, prepend it yourself if you want a ConfigIndex constant.
*/
extern Config tconfig;
// #define CONFIGDEF_KEYBINDING(id,entryname,default)
// #define CONFIGDEF_GPKEYBINDING(id,entryname,default)
// #define CONFIGDEF_INT(id,entryname,default)
// #define CONFIGDEF_FLOAT(id,entryname,default)
// #define CONFIGDEF_STRING(id,entryname,default)
/*
* <Akari> IMPORTANT: When adding new controls, ALWAYS add them RIGHT AFTER the last KEY_* constant.
* Not doing so will likely break replays! And don't forget to update CONFIG_KEY_LAST below.
* Same goes for GP_*.
* DO NOT REORDER KEYBINDINGS.
*
* The KEY_* constants are used by replays. These are formed from KEYDEFS.
* Always add new keys at the end of KEYDEFS, never put them directly into CONFIGDEFS.
*
* KEYDEFS can be safely moved around within CONFIGDEFS, however.
* Stuff in GPKEYDEFS is safe to reorder.
*/
typedef enum ConfigKey {
KEY_UP = 0,
KEY_DOWN,
KEY_LEFT,
KEY_RIGHT,
KEY_FOCUS,
KEY_SHOT,
KEY_BOMB,
#define KEYDEFS \
CONFIGDEF_KEYBINDING(KEY_UP, "key_up", SDL_SCANCODE_UP) \
CONFIGDEF_KEYBINDING(KEY_DOWN, "key_down", SDL_SCANCODE_DOWN) \
CONFIGDEF_KEYBINDING(KEY_LEFT, "key_left", SDL_SCANCODE_LEFT) \
CONFIGDEF_KEYBINDING(KEY_RIGHT, "key_right", SDL_SCANCODE_RIGHT) \
CONFIGDEF_KEYBINDING(KEY_FOCUS, "key_focus", SDL_SCANCODE_LSHIFT) \
CONFIGDEF_KEYBINDING(KEY_SHOT, "key_shot", SDL_SCANCODE_Z) \
CONFIGDEF_KEYBINDING(KEY_BOMB, "key_bomb", SDL_SCANCODE_X) \
CONFIGDEF_KEYBINDING(KEY_FULLSCREEN, "key_fullscreen", SDL_SCANCODE_F11) \
CONFIGDEF_KEYBINDING(KEY_SCREENSHOT, "key_screenshot", SDL_SCANCODE_P) \
CONFIGDEF_KEYBINDING(KEY_SKIP, "key_skip", SDL_SCANCODE_LCTRL) \
CONFIGDEF_KEYBINDING(KEY_IDDQD, "key_iddqd", SDL_SCANCODE_Q) \
CONFIGDEF_KEYBINDING(KEY_HAHAIWIN, "key_skipstage", SDL_SCANCODE_E) \
CONFIGDEF_KEYBINDING(KEY_PAUSE, "key_pause", SDL_SCANCODE_PAUSE) \
KEY_FULLSCREEN,
KEY_SCREENSHOT,
KEY_SKIP,
KEY_IDDQD, // must be present even without DEBUG!
KEY_HAHAIWIN,
#define GPKEYDEFS \
CONFIGDEF_GPKEYBINDING(KEY_UP, "gamepad_key_up", -1) \
CONFIGDEF_GPKEYBINDING(KEY_DOWN, "gamepad_key_down", -1) \
CONFIGDEF_GPKEYBINDING(KEY_LEFT, "gamepad_key_left", -1) \
CONFIGDEF_GPKEYBINDING(KEY_RIGHT, "gamepad_key_right", -1) \
CONFIGDEF_GPKEYBINDING(KEY_FOCUS, "gamepad_key_focus", 0) \
CONFIGDEF_GPKEYBINDING(KEY_SHOT, "gamepad_key_shot", 1) \
CONFIGDEF_GPKEYBINDING(KEY_BOMB, "gamepad_key_bomb", 2) \
CONFIGDEF_GPKEYBINDING(KEY_SKIP, "gamepad_key_skip", 3) \
CONFIGDEF_GPKEYBINDING(KEY_PAUSE, "gamepad_key_pause", 4) \
FULLSCREEN,
NO_SHADER,
NO_AUDIO,
NO_MUSIC,
SFX_VOLUME,
BGM_VOLUME,
#define CONFIGDEFS \
CONFIGDEF_STRING (PLAYERNAME, "playername", "Player") \
CONFIGDEF_INT (FULLSCREEN, "fullscreen", 0) \
CONFIGDEF_INT (VID_WIDTH, "vid_width", RESX) \
CONFIGDEF_INT (VID_HEIGHT, "vid_height", RESY) \
CONFIGDEF_INT (VSYNC, "vsync", 1) \
CONFIGDEF_INT (NO_SHADER, "disable_shader", 0) \
CONFIGDEF_INT (NO_AUDIO, "disable_audio", 0) \
CONFIGDEF_INT (NO_MUSIC, "disable_bgm", 0) \
CONFIGDEF_FLOAT (SFX_VOLUME, "sfx_volume", 1.0) \
CONFIGDEF_FLOAT (BGM_VOLUME, "bgm_volume", 1.0) \
CONFIGDEF_INT (NO_STAGEBG, "disable_stagebg", 0) \
CONFIGDEF_INT (NO_STAGEBG_FPSLIMIT, "disable_stagebg_auto_fpslimit", 40) \
CONFIGDEF_INT (SAVE_RPY, "save_rpy", 2) \
KEYDEFS \
CONFIGDEF_INT (GAMEPAD_ENABLED, "gamepad_enabled", 0) \
CONFIGDEF_INT (GAMEPAD_DEVICE, "gamepad_device", 0) \
CONFIGDEF_INT (GAMEPAD_AXIS_UD, "gamepad_axis_ud", 1) \
CONFIGDEF_INT (GAMEPAD_AXIS_LR, "gamepad_axis_lr", 0) \
CONFIGDEF_INT (GAMEPAD_AXIS_FREE, "gamepad_axis_free", 1) \
CONFIGDEF_FLOAT (GAMEPAD_AXIS_UD_SENS, "gamepad_axis_ud_free_sensitivity", 1.0) \
CONFIGDEF_FLOAT (GAMEPAD_AXIS_LR_SENS, "gamepad_axis_lr_free_sensitivity", 1.0) \
CONFIGDEF_FLOAT (GAMEPAD_AXIS_DEADZONE, "gamepad_axis_deadzone", 0.0) \
GPKEYDEFS \
NO_STAGEBG,
NO_STAGEBG_FPSLIMIT,
SAVE_RPY,
typedef enum ConfigIndex {
#define CONFIGDEF(id) CONFIG_##id,
#define CONFIGDEF_KEYBINDING(id,entryname,default) CONFIGDEF(id)
#define CONFIGDEF_GPKEYBINDING(id,entryname,default) CONFIGDEF(GAMEPAD_##id)
#define CONFIGDEF_INT(id,entryname,default) CONFIGDEF(id)
#define CONFIGDEF_FLOAT(id,entryname,default) CONFIGDEF(id)
#define CONFIGDEF_STRING(id,entryname,default) CONFIGDEF(id)
VID_WIDTH,
VID_HEIGHT,
CONFIGDEFS
CONFIGIDX_NUM
PLAYERNAME,
#undef CONFIGDEF
#undef CONFIGDEF_KEYBINDING
#undef CONFIGDEF_GPKEYBINDING
#undef CONFIGDEF_INT
#undef CONFIGDEF_FLOAT
#undef CONFIGDEF_STRING
} ConfigIndex;
GAMEPAD_ENABLED,
GAMEPAD_DEVICE,
GAMEPAD_AXIS_UD,
GAMEPAD_AXIS_LR,
GAMEPAD_AXIS_UD_SENS,
GAMEPAD_AXIS_LR_SENS,
GAMEPAD_AXIS_DEADZONE,
GAMEPAD_AXIS_FREE,
#define CONFIGIDX_FIRST 0
#define CONFIGIDX_LAST (CONFIGIDX_NUM - 1)
// gamepad controls
// The UDLR ones should work without adjusting - but you can assign custom buttons to them if you really need to
GP_UP,
GP_DOWN,
GP_LEFT,
GP_RIGHT,
GP_FOCUS,
GP_SHOT,
GP_BOMB,
GP_SKIP,
GP_PAUSE,
typedef enum KeyIndex {
#define CONFIGDEF_KEYBINDING(id,entryname,default) id,
VSYNC,
} ConfigKey;
KEYDEFS
KEYIDX_NUM
typedef enum ConfigKeyType {
CFGT_INT,
CFGT_STRING,
CFGT_KEYBINDING,
CFGT_FLOAT
} ConfigKeyType;
#undef CONFIGDEF_KEYBINDING
} KeyIndex;
#define KEYIDX_FIRST 0
#define KEYIDX_LAST (KEYIDX_NUM - 1)
#define CFGIDX_TO_KEYIDX(idx) (idx - CONFIG_KEY_FIRST + KEYIDX_FIRST)
#define KEYIDX_TO_CFGIDX(idx) (idx + CONFIG_KEY_FIRST - KEYIDX_FIRST)
#define CONFIG_KEY_FIRST CONFIG_KEY_UP
#define CONFIG_KEY_LAST (CONFIG_KEY_FIRST + KEYIDX_LAST - KEYIDX_FIRST)
typedef enum GamepadKeyIndex {
#define CONFIGDEF_GPKEYBINDING(id,entryname,default) GAMEPAD_##id,
GPKEYDEFS
GAMEPAD_KEYIDX_NUM
#undef CONFIGDEF_GPKEYBINDING
} GamepadKeyIndex;
#define GAMEPAD_KEYIDX_FIRST 0
#define GAMEPAD_KEYIDX_LAST (GAMEPAD_KEYIDX_NUM - 1)
#define CFGIDX_TO_GPKEYIDX(idx) (idx - CONFIG_GAMEPAD_KEY_FIRST + GAMEPAD_KEYIDX_FIRST)
#define GPKEYIDX_TO_CFGIDX(idx) (idx + CONFIG_GAMEPAD_KEY_FIRST - GAMEPAD_KEYIDX_FIRST)
#define CONFIG_GAMEPAD_KEY_FIRST CONFIG_GAMEPAD_KEY_UP
#define CONFIG_GAMEPAD_KEY_LAST (CONFIG_GAMEPAD_KEY_FIRST + GAMEPAD_KEYIDX_LAST - GAMEPAD_KEYIDX_FIRST)
typedef enum ConfigEntryType {
CONFIG_TYPE_INT,
CONFIG_TYPE_STRING,
CONFIG_TYPE_KEYBINDING,
CONFIG_TYPE_FLOAT
} ConfigEntryType;
typedef struct ConfigEntry {
ConfigKeyType type;
ConfigKey key;
ConfigEntryType type;
char *name;
union {
int i;
double f;
char *s;
} val;
} ConfigEntry;
extern ConfigEntry configdefs[];
Config tconfig;
#define CONFIG_KEY_FIRST KEY_UP
#define CONFIG_KEY_LAST KEY_HAHAIWIN
#define CONFIG_GPKEY_FIRST GP_UP
#define CONFIG_GPKEY_LAST GP_PAUSE
#define CONFIG_LOAD_BUFSIZE 256
int config_scan2key(int scan);
int config_button2gpkey(int btn);
int config_gpkey2key(int btn);
int config_button2key(int btn);
KeyIndex config_key_from_scancode(int scan);
GamepadKeyIndex config_gamepad_key_from_gamepad_button(int btn);
KeyIndex config_key_from_gamepad_key(GamepadKeyIndex gpkey);
GamepadKeyIndex config_gamepad_key_from_key(KeyIndex key);
KeyIndex config_key_from_gamepad_button(int btn);
void config_preset(void);
void config_reset(void);
void config_init(void);
void config_uninit(void);
void config_load(char *filename);
void config_save(char *filename);
ConfigEntry* config_findentry(char *name);
ConfigEntry* config_findentry_byid(int id);
int config_intval(char*);
int config_intval_p(ConfigEntry*);
char* config_strval(char*);
char* config_strval_p(ConfigEntry*);
float config_fltval(char*);
float config_fltval_p(ConfigEntry*);
#ifndef DEBUG
#define CONFIG_RAWACCESS
#endif
#ifdef CONFIG_RAWACCESS
#define CONFIGDEFS_EXPORT
extern ConfigEntry configdefs[];
#define config_get(idx) (configdefs + (idx))
#else
#define CONFIGDEFS_EXPORT static
ConfigEntry* config_get(ConfigIndex idx);
#endif
#define config_get_int(idx) (config_get(idx)->val.i)
#define config_get_float(idx) (config_get(idx)->val.f)
#define config_get_str(idx) (config_get(idx)->val.s)
#define config_set_int(idx,val) (config_get_int(idx) = val)
#define config_set_float(idx,val) (config_get_float(idx) = val)
#define config_set_str(idx,val) stralloc(&config_get_str(idx), val)
#endif

2
src/credits.c
View file

@ -96,7 +96,7 @@ void credits_towerwall_draw(Vector pos) {
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, get_tex("stage6/towerwall")->gltex);
if(!tconfig.intval[NO_SHADER]) {
if(!config_get_int(CONFIG_NO_SHADER)) {
Shader *s = get_shader("tower_wall");
glUseProgram(s->prog);
glUniform1i(uniloc(s, "lendiv"), 2800.0 + 300.0 * sin(global.frames / 77.7));

22
src/events.c
View file

@ -46,12 +46,12 @@ void handle_events(EventHandler handler, EventFlags flags, void *arg) {
else if(scan == SDL_SCANCODE_BACKSPACE)
handler(E_CharErased, 0, arg);
} else {
if(scan == tconfig.intval[KEY_SCREENSHOT]) {
if(scan == config_get_int(CONFIG_KEY_SCREENSHOT)) {
take_screenshot();
break;
}
if((scan == SDL_SCANCODE_RETURN && (mod & KMOD_ALT)) || scan == tconfig.intval[KEY_FULLSCREEN]) {
if((scan == SDL_SCANCODE_RETURN && (mod & KMOD_ALT)) || scan == config_get_int(CONFIG_KEY_FULLSCREEN)) {
video_toggle_fullscreen();
break;
}
@ -62,26 +62,26 @@ void handle_events(EventHandler handler, EventFlags flags, void *arg) {
}
if(menu) {
if(scan == tconfig.intval[KEY_DOWN] || scan == SDL_SCANCODE_DOWN) {
if(scan == config_get_int(CONFIG_KEY_DOWN) || scan == SDL_SCANCODE_DOWN) {
handler(E_CursorDown, 0, arg);
} else if(scan == tconfig.intval[KEY_UP] || scan == SDL_SCANCODE_UP) {
} else if(scan == config_get_int(CONFIG_KEY_UP) || scan == SDL_SCANCODE_UP) {
handler(E_CursorUp, 0, arg);
} else if(scan == tconfig.intval[KEY_RIGHT] || scan == SDL_SCANCODE_RIGHT) {
} else if(scan == config_get_int(CONFIG_KEY_RIGHT) || scan == SDL_SCANCODE_RIGHT) {
handler(E_CursorRight, 0, arg);
} else if(scan == tconfig.intval[KEY_LEFT] || scan == SDL_SCANCODE_LEFT) {
} else if(scan == config_get_int(CONFIG_KEY_LEFT) || scan == SDL_SCANCODE_LEFT) {
handler(E_CursorLeft, 0, arg);
} else if(scan == tconfig.intval[KEY_SHOT] || scan == SDL_SCANCODE_RETURN) {
} else if(scan == config_get_int(CONFIG_KEY_SHOT) || scan == SDL_SCANCODE_RETURN) {
handler(E_MenuAccept, 0, arg);
} else if(scan == SDL_SCANCODE_ESCAPE || scan == tconfig.intval[KEY_BOMB]) {
} else if(scan == config_get_int(CONFIG_KEY_BOMB) || scan == SDL_SCANCODE_ESCAPE) {
handler(E_MenuAbort, 0, arg);
}
}
if(game && !event.key.repeat) {
if(scan == SDL_SCANCODE_ESCAPE) {
if(scan == config_get_int(CONFIG_KEY_PAUSE) || scan == SDL_SCANCODE_ESCAPE) {
handler(E_Pause, 0, arg);
} else {
int key = config_scan2key(scan);
int key = config_key_from_scancode(scan);
if(key >= 0)
handler(E_PlrKeyDown, key, arg);
}
@ -95,7 +95,7 @@ void handle_events(EventHandler handler, EventFlags flags, void *arg) {
}
if(game && !event.key.repeat) {
int key = config_scan2key(scan);
int key = config_key_from_scancode(scan);
if(key >= 0)
handler(E_PlrKeyUp, key, arg);
}

53
src/gamepad.c
View file

@ -21,7 +21,7 @@ static struct {
void gamepad_init(void) {
memset(&gamepad, 0, sizeof(gamepad));
if(!config_intval("gamepad_enabled"))
if(!config_get_int(CONFIG_GAMEPAD_ENABLED))
return;
if(gamepad.initialized)
@ -37,7 +37,7 @@ void gamepad_init(void) {
for(i = 0; i < cnt; ++i)
printf("%i: %s\n", i, SDL_JoystickNameForIndex(i));
int dev = config_intval("gamepad_device");
int dev = config_get_int(CONFIG_GAMEPAD_DEVICE);
if(dev < 0 || dev >= cnt) {
warnx("gamepad_init(): device %i is not available\n", dev);
gamepad_shutdown();
@ -83,11 +83,11 @@ int gamepad_axis2gamekey(int id, int val) {
return -1;
}
if(id == tconfig.intval[GAMEPAD_AXIS_LR]) {
if(id == config_get_int(CONFIG_GAMEPAD_AXIS_LR)) {
return val == AXISVAL_LEFT ? KEY_LEFT : KEY_RIGHT;
}
if(id == tconfig.intval[GAMEPAD_AXIS_UD]) {
if(id == config_get_int(CONFIG_GAMEPAD_AXIS_UD)) {
return val == AXISVAL_UP ? KEY_UP : KEY_DOWN;
}
@ -95,31 +95,31 @@ int gamepad_axis2gamekey(int id, int val) {
}
int gamepad_axis2menuevt(int id, int val) {
if(id == tconfig.intval[GAMEPAD_AXIS_LR])
if(id == config_get_int(CONFIG_GAMEPAD_AXIS_LR))
return val == AXISVAL_LEFT ? E_CursorLeft : E_CursorRight;
if(id == tconfig.intval[GAMEPAD_AXIS_UD])
if(id == config_get_int(CONFIG_GAMEPAD_AXIS_UD))
return val == AXISVAL_UP ? E_CursorUp : E_CursorDown;
return -1;
}
int gamepad_axis2gameevt(int id) {
if(id == tconfig.intval[GAMEPAD_AXIS_LR])
if(id == config_get_int(CONFIG_GAMEPAD_AXIS_LR))
return E_PlrAxisLR;
if(id == tconfig.intval[GAMEPAD_AXIS_UD])
if(id == config_get_int(CONFIG_GAMEPAD_AXIS_UD))
return E_PlrAxisUD;
return -1;
}
float gamepad_axis_sens(int id) {
if(id == tconfig.intval[GAMEPAD_AXIS_LR])
return tconfig.fltval[GAMEPAD_AXIS_LR_SENS];
if(id == config_get_int(CONFIG_GAMEPAD_AXIS_LR))
return config_get_float(CONFIG_GAMEPAD_AXIS_LR_SENS);
if(id == tconfig.intval[GAMEPAD_AXIS_UD])
return tconfig.fltval[GAMEPAD_AXIS_UD_SENS];
if(id == config_get_int(CONFIG_GAMEPAD_AXIS_UD))
return config_get_float(CONFIG_GAMEPAD_AXIS_UD_SENS);
return 1.0;
}
@ -127,7 +127,7 @@ float gamepad_axis_sens(int id) {
void gamepad_axis(int id, int raw, EventHandler handler, EventFlags flags, void *arg) {
int *a = gamepad.axis;
int val = AXISVAL(raw);
int free = tconfig.intval[GAMEPAD_AXIS_FREE];
int free = config_get_int(CONFIG_GAMEPAD_AXIS_FREE);
int menu = flags & EF_Menu;
int game = flags & EF_Game;
@ -186,8 +186,8 @@ void gamepad_button(int button, int state, EventHandler handler, EventFlags flag
int game = flags & EF_Game;
int gpad = flags & EF_Gamepad;
int gpkey = config_button2gpkey(button);
int key = config_gpkey2key(gpkey);
int gpkey = config_gamepad_key_from_gamepad_button(button);
int key = config_key_from_gamepad_key(gpkey);
//printf("button: %i %i\n", button, state);
//printf("gpkey: %i\n", gpkey);
@ -195,11 +195,11 @@ void gamepad_button(int button, int state, EventHandler handler, EventFlags flag
if(state == SDL_PRESSED) {
if(game) {
if(gpkey == GP_PAUSE) {
printf("should pause\n");
if(gpkey == GAMEPAD_KEY_PAUSE) {
handler(E_Pause, 0, arg);
} else if(key >= 0)
} else if(key >= 0) {
handler(E_PlrKeyDown, key, arg);
}
}
if(menu) switch(key) {
@ -227,7 +227,7 @@ void gamepad_event(SDL_Event *event, EventHandler handler, EventFlags flags, voi
return;
int val;
int sens = clamp(tconfig.fltval[GAMEPAD_AXIS_DEADZONE], 0, 1) * GAMEPAD_AXIS_RANGE;
int sens = clamp(config_get_float(CONFIG_GAMEPAD_AXIS_DEADZONE), 0, 1) * GAMEPAD_AXIS_RANGE;
switch(event->type) {
case SDL_JOYAXISMOTION:
@ -250,20 +250,19 @@ char* gamepad_devicename(int id) {
return (char*)SDL_JoystickNameForIndex(id);
}
int gamepad_buttonpressed(int btn) {
bool gamepad_buttonpressed(int btn) {
return SDL_JoystickGetButton(gamepad.device, btn);
}
int gamepad_gamekeypressed(int key) {
bool gamepad_gamekeypressed(KeyIndex key) {
if(!gamepad.initialized)
return 0;
return false;
// this sucks
int i; for(i = CONFIG_GPKEY_FIRST; i <= CONFIG_GPKEY_LAST; ++i)
if(key == config_gpkey2key(i) && gamepad_buttonpressed(tconfig.intval[i]))
return 1;
int gpkey = config_gamepad_key_from_key(key);
int cfgidx = GPKEYIDX_TO_CFGIDX(gpkey);
int button = config_get_int(cfgidx);
return 0;
return gamepad_buttonpressed(button);
}
void gamepad_init_bare(void) {

6
src/gamepad.h
View file

@ -10,7 +10,9 @@
#define GAMEPAD_H
#include <SDL.h>
#include <stdbool.h>
#include "events.h"
#include "config.h"
void gamepad_init(void);
void gamepad_shutdown(void);
@ -20,8 +22,8 @@ float gamepad_axis_sens(int);
char* gamepad_devicename(int);
void gamepad_event(SDL_Event*, EventHandler, EventFlags, void*);
int gamepad_buttonpressed(int btn);
int gamepad_gamekeypressed(int key);
bool gamepad_buttonpressed(int btn);
bool gamepad_gamekeypressed(KeyIndex key);
// shitty workaround for the options menu. Used to list devices while the gamepad subsystem is off.
// only initializes the SDL subsystem so you can use gamepad_devicecount/gamepad_devicename.

4
src/global.c
View file

@ -265,6 +265,6 @@ void stralloc(char **dest, char *src) {
// Inputdevice-agnostic method of checking whether a game control is pressed.
// ALWAYS use this instead of SDL_GetKeyState if you need it.
bool gamekeypressed(int key) {
return SDL_GetKeyboardState(NULL)[tconfig.intval[key]] || gamepad_gamekeypressed(key);
bool gamekeypressed(KeyIndex key) {
return SDL_GetKeyboardState(NULL)[config_get_int(KEYIDX_TO_CFGIDX(key))] || gamepad_gamekeypressed(key);
}

2
src/global.h
View file

@ -151,7 +151,7 @@ double psin(double);
bool strendswith(char *s, char *e);
char* difficulty_name(Difficulty diff);
void stralloc(char **dest, char *src);
bool gamekeypressed(int key);
bool gamekeypressed(KeyIndex key);
int getenvint(const char *v);
#define SIGN(x) ((x > 0) - (x < 0))

2
src/laser.c
View file

@ -143,7 +143,7 @@ void draw_lasers(void) {
Laser *laser;
for(laser = global.lasers; laser; laser = laser->next) {
if(laser->shader && !tconfig.intval[NO_SHADER] && tgl_ext[TGLEXT_draw_instanced])
if(laser->shader && !config_get_int(CONFIG_NO_SHADER) && tgl_ext[TGLEXT_draw_instanced])
draw_laser_curve_instanced(laser);
else
draw_laser_curve(laser);

10
src/main.c
View file

@ -38,11 +38,13 @@ void taisei_shutdown(void) {
config_save(CONFIG_FILE);
printf("\nshutdown:\n");
if (!tconfig.intval[NO_AUDIO]) shutdown_sfx();
if (!tconfig.intval[NO_MUSIC]) shutdown_bgm();
if(!config_get_int(CONFIG_NO_AUDIO)) shutdown_sfx();
if(!config_get_int(CONFIG_NO_MUSIC)) shutdown_bgm();
free_resources();
video_shutdown();
gamepad_shutdown();
config_uninit();
SDL_Quit();
printf("-- Good Bye.\n");
@ -161,8 +163,8 @@ int main(int argc, char** argv) {
MenuData menu;
create_main_menu(&menu);
printf("-- menu\n");
set_sfx_volume(tconfig.fltval[SFX_VOLUME]);
set_bgm_volume(tconfig.fltval[BGM_VOLUME]);
set_sfx_volume(config_get_float(CONFIG_SFX_VOLUME));
set_bgm_volume(config_get_float(CONFIG_BGM_VOLUME));
start_bgm("bgm_menu");
main_menu_loop(&menu);

2
src/menu/common.c
View file

@ -54,7 +54,7 @@ troll2:
}
if(global.replay_stage) {
switch(tconfig.intval[SAVE_RPY]) {
switch(config_get_int(CONFIG_SAVE_RPY)) {
case 0: break;
case 1: {

2
src/menu/ingamemenu.c
View file

@ -34,7 +34,7 @@ void create_ingame_menu(MenuData *m) {
void draw_ingame_menu_bg(float f) {
float rad = f*IMENU_BLUR;
if(!tconfig.intval[NO_SHADER]) {
if(!config_get_int(CONFIG_NO_SHADER)) {
glBindFramebuffer(GL_FRAMEBUFFER, 0);
Shader *shader = get_shader("ingame_menu");
glUseProgram(shader->prog);

155
src/menu/options.c
View file

@ -78,7 +78,7 @@ OptionBinding* bind_gpbinding(int cfgentry) {
}
// BT_StrValue: with a half-assed "textbox"
OptionBinding* bind_stroption(int cfgentry) {
OptionBinding* bind_stroption(ConfigIndex cfgentry) {
OptionBinding *bind = bind_new();
bind->type = BT_StrValue;
bind->configentry = cfgentry;
@ -86,7 +86,7 @@ OptionBinding* bind_stroption(int cfgentry) {
bind->valcount = 1;
bind->values = malloc(sizeof(char*));
*bind->values = malloc(OPTIONS_TEXT_INPUT_BUFSIZE);
strlcpy(*bind->values, tconfig.strval[cfgentry], OPTIONS_TEXT_INPUT_BUFSIZE);
strlcpy(*bind->values, config_get_str(cfgentry), OPTIONS_TEXT_INPUT_BUFSIZE);
return bind;
}
@ -210,19 +210,19 @@ bool bind_isactive(OptionBinding *b) {
// --- Shared binding callbacks --- //
int bind_common_onoffget(void *b) {
return !tconfig.intval[((OptionBinding*)b)->configentry];
return !config_get_int(((OptionBinding*)b)->configentry);
}
int bind_common_onoffset(void *b, int v) {
return !(tconfig.intval[((OptionBinding*)b)->configentry] = !v);
return !config_set_int(((OptionBinding*)b)->configentry, !v);
}
int bind_common_onoffget_inverted(void *b) {
return tconfig.intval[((OptionBinding*)b)->configentry];
return config_get_int(((OptionBinding*)b)->configentry);
}
int bind_common_onoffset_inverted(void *b, int v) {
return tconfig.intval[((OptionBinding*)b)->configentry] = v;
return config_set_int(((OptionBinding*)b)->configentry, v);
}
#define bind_common_intget bind_common_onoffget_inverted
@ -247,7 +247,7 @@ int bind_noaudio_set(void *b, int v) {
if(!init_sfx(NULL, NULL)) return 1;
load_resources();
set_sfx_volume(tconfig.fltval[SFX_VOLUME]);
set_sfx_volume(config_get_float(CONFIG_SFX_VOLUME));
}
return i;
@ -265,7 +265,7 @@ int bind_nomusic_set(void *b, int v) {
if(!init_bgm(NULL, NULL)) return 1;
load_resources();
set_bgm_volume(tconfig.fltval[BGM_VOLUME]);
set_bgm_volume(config_get_float(CONFIG_BGM_VOLUME));
start_bgm("bgm_menu");
}
@ -288,11 +288,11 @@ int bind_vsync_set(void *b, int v) {
}
bool bind_stagebg_fpslimit_dependence(void) {
return tconfig.intval[NO_STAGEBG] == 2;
return config_get_int(CONFIG_NO_STAGEBG) == 2;
}
int bind_saverpy_get(void *b) {
int v = tconfig.intval[((OptionBinding*)b)->configentry];
int v = config_get_int(((OptionBinding*)b)->configentry);
if(v > 1)
return v;
@ -301,8 +301,8 @@ int bind_saverpy_get(void *b) {
int bind_saverpy_set(void *b, int v) {
if(v > 1)
return tconfig.intval[((OptionBinding*)b)->configentry] = v;
return !(tconfig.intval[((OptionBinding*)b)->configentry] = !v);
return config_set_int(((OptionBinding*)b)->configentry, v);
return !config_set_int(((OptionBinding*)b)->configentry, !v);
}
// --- Creating, destroying, filling the menu --- //
@ -320,10 +320,10 @@ void destroy_options_menu(MenuData *m) {
if(bind->selected != -1) {
VideoMode *m = video.modes + bind->selected;
video_setmode(m->width, m->height, tconfig.intval[FULLSCREEN]);
video_setmode(m->width, m->height, config_get_int(CONFIG_FULLSCREEN));
tconfig.intval[VID_WIDTH] = video.intended.width;
tconfig.intval[VID_HEIGHT] = video.intended.height;
config_set_int(CONFIG_VID_WIDTH, video.intended.width);
config_set_int(CONFIG_VID_HEIGHT, video.intended.height);
}
break;
}
@ -358,30 +358,27 @@ void options_sub_video(MenuData *parent, void *arg) {
);
add_menu_entry(m, "Fullscreen", do_nothing,
b = bind_option(FULLSCREEN, bind_common_onoffget, bind_fullscreen_set)
b = bind_option(CONFIG_FULLSCREEN, bind_common_onoffget, bind_fullscreen_set)
); bind_onoff(b);
add_menu_entry(m, "Vertical synchronization", do_nothing,
b = bind_option(VSYNC, bind_common_onoffget, bind_vsync_set)
b = bind_option(CONFIG_VSYNC, bind_common_onoffget, bind_vsync_set)
); bind_onoff(b);
add_menu_separator(m);
add_menu_entry(m, "Shaders", do_nothing,
b = bind_option(NO_SHADER, bind_common_onoffget_inverted,
bind_noshader_set)
b = bind_option(CONFIG_NO_SHADER, bind_common_onoffget_inverted, bind_noshader_set)
); bind_onoff(b);
add_menu_entry(m, "Stage background", do_nothing,
b = bind_option(NO_STAGEBG, bind_common_intget,
bind_common_intset)
b = bind_option(CONFIG_NO_STAGEBG, bind_common_intget, bind_common_intset)
); bind_addvalue(b, "on");
bind_addvalue(b, "off");
bind_addvalue(b, "auto");
add_menu_entry(m, "Minimum FPS", do_nothing,
b = bind_option(NO_STAGEBG_FPSLIMIT, bind_common_intget,
bind_common_intset)
b = bind_option(CONFIG_NO_STAGEBG_FPSLIMIT, bind_common_intget, bind_common_intset)
); bind_setvaluerange(b, 20, 60);
bind_setdependence(b, bind_stagebg_fpslimit_dependence);
@ -401,7 +398,7 @@ void bind_setvaluerange_fancy(OptionBinding *b, int ma) {
}
bool gamepad_sens_depencence(void) {
return tconfig.intval[GAMEPAD_AXIS_FREE];
return config_get_int(CONFIG_GAMEPAD_AXIS_FREE);
}
void options_sub_gamepad_controls(MenuData *parent, void *arg) {
@ -411,43 +408,43 @@ void options_sub_gamepad_controls(MenuData *parent, void *arg) {
create_options_sub(m, "Gamepad Controls");
add_menu_entry(m, "Fire / Accept", do_nothing,
bind_gpbinding(GP_SHOT)
bind_gpbinding(CONFIG_GAMEPAD_KEY_SHOT)
);
add_menu_entry(m, "Focus / Abort", do_nothing,
bind_gpbinding(GP_FOCUS)
bind_gpbinding(CONFIG_GAMEPAD_KEY_FOCUS)
);
add_menu_entry(m, "Bomb", do_nothing,
bind_gpbinding(GP_BOMB)
bind_gpbinding(CONFIG_GAMEPAD_KEY_BOMB)
);
add_menu_separator(m);
add_menu_entry(m, "Pause", do_nothing,
bind_gpbinding(GP_PAUSE)
bind_gpbinding(CONFIG_GAMEPAD_KEY_PAUSE)
);
add_menu_entry(m, "Skip dialog", do_nothing,
bind_gpbinding(GP_SKIP)
bind_gpbinding(CONFIG_GAMEPAD_KEY_SKIP)
);
add_menu_separator(m);
add_menu_entry(m, "Move up", do_nothing,
bind_gpbinding(GP_UP)
bind_gpbinding(CONFIG_GAMEPAD_KEY_UP)
);
add_menu_entry(m, "Move down", do_nothing,
bind_gpbinding(GP_DOWN)
bind_gpbinding(CONFIG_GAMEPAD_KEY_DOWN)
);
add_menu_entry(m, "Move left", do_nothing,
bind_gpbinding(GP_LEFT)
bind_gpbinding(CONFIG_GAMEPAD_KEY_LEFT)
);
add_menu_entry(m, "Move right", do_nothing,
bind_gpbinding(GP_RIGHT)
bind_gpbinding(CONFIG_GAMEPAD_KEY_RIGHT)
);
add_menu_separator(m);
@ -466,11 +463,11 @@ void options_sub_gamepad(MenuData *parent, void *arg) {
create_options_sub(m, "Gamepad Options");
add_menu_entry(m, "Enable Gamepad/Joystick support", do_nothing,
b = bind_option(GAMEPAD_ENABLED, bind_common_onoffget, bind_common_onoffset)
b = bind_option(CONFIG_GAMEPAD_ENABLED, bind_common_onoffget, bind_common_onoffset)
); bind_onoff(b);
add_menu_entry(m, "Device", do_nothing,
b = bind_option(GAMEPAD_DEVICE, bind_common_intget, bind_common_intset)
b = bind_option(CONFIG_GAMEPAD_DEVICE, bind_common_intget, bind_common_intset)
); b->displaysingle = true;
add_menu_separator(m);
@ -493,28 +490,28 @@ void options_sub_gamepad(MenuData *parent, void *arg) {
add_menu_separator(m);
add_menu_entry(m, "The UD axis (Vertical)", do_nothing,
b = bind_option(GAMEPAD_AXIS_UD, bind_common_intget, bind_common_intset)
b = bind_option(CONFIG_GAMEPAD_AXIS_UD, bind_common_intget, bind_common_intset)
); bind_setvaluerange_fancy(b, GAMEPAD_AXES-1);
add_menu_entry(m, "The LR axis (Horizontal)", do_nothing,
b = bind_option(GAMEPAD_AXIS_LR, bind_common_intget, bind_common_intset)
b = bind_option(CONFIG_GAMEPAD_AXIS_LR, bind_common_intget, bind_common_intset)
); bind_setvaluerange_fancy(b, GAMEPAD_AXES-1);
add_menu_entry(m, "Axis mode", do_nothing,
b = bind_option(GAMEPAD_AXIS_FREE, bind_common_onoffget, bind_common_onoffset)
b = bind_option(CONFIG_GAMEPAD_AXIS_FREE, bind_common_onoffget, bind_common_onoffset)
); bind_addvalue(b, "free");
bind_addvalue(b, "restricted");
add_menu_entry(m, "UD axis sensitivity", do_nothing,
b = bind_scale(GAMEPAD_AXIS_UD_SENS, -2, 2, 0.05)
b = bind_scale(CONFIG_GAMEPAD_AXIS_UD_SENS, -2, 2, 0.05)
); bind_setdependence(b, gamepad_sens_depencence);
add_menu_entry(m, "LR axis sensitivity", do_nothing,
b = bind_scale(GAMEPAD_AXIS_LR_SENS, -2, 2, 0.05)
b = bind_scale(CONFIG_GAMEPAD_AXIS_LR_SENS, -2, 2, 0.05)
); bind_setdependence(b, gamepad_sens_depencence);
add_menu_entry(m, "Dead zone", do_nothing,
b = bind_scale(GAMEPAD_AXIS_DEADZONE, 0, 1, 0.01)
b = bind_scale(CONFIG_GAMEPAD_AXIS_DEADZONE, 0, 1, 0.01)
);
add_menu_separator(m);
@ -532,58 +529,58 @@ void options_sub_controls(MenuData *parent, void *arg) {
create_options_sub(m, "Controls");
add_menu_entry(m, "Move up", do_nothing,
bind_keybinding(KEY_UP)
bind_keybinding(CONFIG_KEY_UP)
);
add_menu_entry(m, "Move down", do_nothing,
bind_keybinding(KEY_DOWN)
bind_keybinding(CONFIG_KEY_DOWN)
);
add_menu_entry(m, "Move left", do_nothing,
bind_keybinding(KEY_LEFT)
bind_keybinding(CONFIG_KEY_LEFT)
);
add_menu_entry(m, "Move right", do_nothing,
bind_keybinding(KEY_RIGHT)
bind_keybinding(CONFIG_KEY_RIGHT)
);
add_menu_separator(m);
add_menu_entry(m, "Fire", do_nothing,
bind_keybinding(KEY_SHOT)
bind_keybinding(CONFIG_KEY_SHOT)
);
add_menu_entry(m, "Focus", do_nothing,
bind_keybinding(KEY_FOCUS)
bind_keybinding(CONFIG_KEY_FOCUS)
);
add_menu_entry(m, "Bomb", do_nothing,
bind_keybinding(KEY_BOMB)
bind_keybinding(CONFIG_KEY_BOMB)
);
add_menu_separator(m);
add_menu_entry(m, "Toggle fullscreen", do_nothing,
bind_keybinding(KEY_FULLSCREEN)
bind_keybinding(CONFIG_KEY_FULLSCREEN)
);
add_menu_entry(m, "Take a screenshot", do_nothing,
bind_keybinding(KEY_SCREENSHOT)
bind_keybinding(CONFIG_KEY_SCREENSHOT)
);
add_menu_entry(m, "Skip dialog", do_nothing,
bind_keybinding(KEY_SKIP)
bind_keybinding(CONFIG_KEY_SKIP)
);
#ifdef DEBUG
add_menu_separator(m);
add_menu_entry(m, "Toggle God mode", do_nothing,
bind_keybinding(KEY_IDDQD)
bind_keybinding(CONFIG_KEY_IDDQD)
);
add_menu_entry(m, "Skip stage", do_nothing,
bind_keybinding(KEY_HAHAIWIN)
bind_keybinding(CONFIG_KEY_HAHAIWIN)
);
#endif
@ -602,13 +599,13 @@ void create_options_menu(MenuData *m) {
m->context = "Options";
add_menu_entry(m, "Player name", do_nothing,
b = bind_stroption(PLAYERNAME)
b = bind_stroption(CONFIG_PLAYERNAME)
);
add_menu_separator(m);
add_menu_entry(m, "Save replays", do_nothing,
b = bind_option(SAVE_RPY, bind_saverpy_get,
b = bind_option(CONFIG_SAVE_RPY, bind_saverpy_get,
bind_saverpy_set)
); bind_addvalue(b, "on");
bind_addvalue(b, "off");
@ -617,21 +614,21 @@ void create_options_menu(MenuData *m) {
add_menu_separator(m);
add_menu_entry(m, "Sound effects", do_nothing,
b = bind_option(NO_AUDIO, bind_common_onoffget_inverted,
b = bind_option(CONFIG_NO_AUDIO, bind_common_onoffget_inverted,
bind_noaudio_set)
); bind_onoff(b);
add_menu_entry(m, "SFX volume level", do_nothing,
bind_scale_call(SFX_VOLUME, 0, 1, 0.1, set_sfx_volume)
bind_scale_call(CONFIG_SFX_VOLUME, 0, 1, 0.1, set_sfx_volume)
);
add_menu_entry(m, "Background music", do_nothing,
b = bind_option(NO_MUSIC, bind_common_onoffget_inverted,
b = bind_option(CONFIG_NO_MUSIC, bind_common_onoffget_inverted,
bind_nomusic_set)
); bind_onoff(b);
add_menu_entry(m, "Music volume level", do_nothing,
bind_scale_call(BGM_VOLUME, 0, 1, 0.1, set_bgm_volume)
bind_scale_call(CONFIG_BGM_VOLUME, 0, 1, 0.1, set_bgm_volume)
);
add_menu_separator(m);
@ -724,7 +721,7 @@ void draw_options_menu(MenuData *menu) {
glColor4f(0.5, 1, 0.5, 1);
draw_text(AL_Right, origin, 20*i, "Press a key to assign, ESC to cancel", _fonts.standard);
} else {
const char *txt = SDL_GetScancodeName(tconfig.intval[bind->configentry]);
const char *txt = SDL_GetScancodeName(config_get_int(bind->configentry));
if(!txt || !*txt) {
txt = "Unknown";
@ -745,9 +742,9 @@ void draw_options_menu(MenuData *menu) {
if(bind->blockinput) {
glColor4f(0.5, 1, 0.5, 1);
draw_text(AL_Right, origin, 20*i, "Press a button to assign, ESC to cancel", _fonts.standard);
} else if(tconfig.intval[bind->configentry] >= 0) {
} else if(config_get_int(bind->configentry) >= 0) {
char tmp[32];
snprintf(tmp, 32, "Button %i", tconfig.intval[bind->configentry] + 1);
snprintf(tmp, 32, "Button %i", config_get_int(bind->configentry) + 1);
draw_text(AL_Right, origin, 20*i, tmp, _fonts.standard);
} else {
draw_text(AL_Right, origin, 20*i, "Unbound", _fonts.standard);
@ -761,7 +758,7 @@ void draw_options_menu(MenuData *menu) {
if(strlen(*bind->values))
draw_text(AL_Right, origin, 20*i, *bind->values, _fonts.standard);
} else
draw_text(AL_Right, origin, 20*i, tconfig.strval[bind->configentry], _fonts.standard);
draw_text(AL_Right, origin, 20*i, config_get_str(bind->configentry), _fonts.standard);
break;
}
@ -789,7 +786,7 @@ void draw_options_menu(MenuData *menu) {
int h = 5;
int cw = 5;
float val = tconfig.fltval[bind->configentry];
float val = config_get_float(bind->configentry);
float ma = bind->scale_max;
float mi = bind->scale_min;
@ -843,12 +840,12 @@ void bind_input_event(EventType type, int state, void *arg) {
if(!esc) {
for(int i = CONFIG_KEY_FIRST; i <= CONFIG_KEY_LAST; ++i) {
if(tconfig.intval[i] == scan) {
tconfig.intval[i] = tconfig.intval[b->configentry];
if(config_get_int(i) == scan) {
config_set_int(i, config_get_int(b->configentry));
}
}
tconfig.intval[b->configentry] = scan;
config_set_int(b->configentry, scan);
}
b->blockinput = false;
@ -856,13 +853,13 @@ void bind_input_event(EventType type, int state, void *arg) {
}
case E_GamepadKeyDown: {
for(int i = CONFIG_GPKEY_FIRST; i <= CONFIG_GPKEY_LAST; ++i) {
if(tconfig.intval[i] == scan) {
tconfig.intval[i] = tconfig.intval[b->configentry];
for(int i = CONFIG_GAMEPAD_KEY_FIRST; i <= CONFIG_GAMEPAD_KEY_LAST; ++i) {
if(config_get_int(i) == scan) {
config_set_int(i, config_get_int(b->configentry));
}
}
tconfig.intval[b->configentry] = scan;
config_set_int(b->configentry, scan);
b->blockinput = false;
break;
}
@ -883,15 +880,15 @@ void bind_input_event(EventType type, int state, void *arg) {
case E_SubmitText: {
if(dest != NULL && strlen(dest))
stralloc(&(tconfig.strval[b->configentry]), dest);
config_set_str(b->configentry, dest);
else
strlcpy(dest, tconfig.strval[b->configentry], OPTIONS_TEXT_INPUT_BUFSIZE);
strlcpy(dest, config_get_str(b->configentry), OPTIONS_TEXT_INPUT_BUFSIZE);
b->blockinput = false;
break;
}
case E_CancelText: {
strlcpy(dest, tconfig.strval[b->configentry], OPTIONS_TEXT_INPUT_BUFSIZE);
strlcpy(dest, config_get_str(b->configentry), OPTIONS_TEXT_INPUT_BUFSIZE);
b->blockinput = false;
break;
}
@ -934,9 +931,9 @@ static void options_input_event(EventType type, int state, void *arg) {
if(bind->type == BT_IntValue || bind->type == BT_Resolution)
bind_setprev(bind);
else if((bind->type == BT_Scale) || (bind->type == BT_ScaleCallback)) {
tconfig.fltval[bind->configentry] = clamp(tconfig.fltval[bind->configentry] - bind->scale_step, bind->scale_min, bind->scale_max);
config_set_float(bind->configentry, clamp(config_get_float(bind->configentry) - bind->scale_step, bind->scale_min, bind->scale_max));
if (bind->type == BT_ScaleCallback)
bind->callback(tconfig.fltval[bind->configentry]);
bind->callback(config_get_float(bind->configentry));
}
}
break;
@ -947,9 +944,9 @@ static void options_input_event(EventType type, int state, void *arg) {
if(bind->type == BT_IntValue || bind->type == BT_Resolution)
bind_setnext(bind);
else if((bind->type == BT_Scale) || (bind->type == BT_ScaleCallback)) {
tconfig.fltval[bind->configentry] = clamp(tconfig.fltval[bind->configentry] + bind->scale_step, bind->scale_min, bind->scale_max);
config_set_float(bind->configentry, clamp(config_get_float(bind->configentry) + bind->scale_step, bind->scale_min, bind->scale_max));
if (bind->type == BT_ScaleCallback)
bind->callback(tconfig.fltval[bind->configentry]);
bind->callback(config_get_float(bind->configentry));
}
}
break;
@ -964,7 +961,7 @@ static void options_input_event(EventType type, int state, void *arg) {
break;
case BT_StrValue:
bind->selected = strlen(tconfig.strval[bind->configentry]);
bind->selected = strlen(config_get_str(bind->configentry));
bind->blockinput = true;
break;

8
src/projectile.c
View file

@ -204,22 +204,22 @@ int asymptotic(Projectile *p, int t) { // v = a[0]*(a[1] + 1); a[1] -> 0
}
void _ProjDraw(Projectile *proj, int t) {
if(proj->clr != NULL && !tconfig.intval[NO_SHADER]) {
if(proj->clr != NULL && !config_get_int(CONFIG_NO_SHADER)) {
Shader *shader = get_shader("bullet_color");
glUseProgram(shader->prog);
glUniform4fv(uniloc(shader, "color"), 1, (GLfloat *)proj->clr);
}
if(proj->clr != NULL && tconfig.intval[NO_SHADER])
if(proj->clr != NULL && config_get_int(CONFIG_NO_SHADER))
glColor3f(0,0,0);
draw_texture_p(0,0, proj->tex);
if(proj->clr != NULL && tconfig.intval[NO_SHADER])
if(proj->clr != NULL && config_get_int(CONFIG_NO_SHADER))
glColor3f(1,1,1);
if(!tconfig.intval[NO_SHADER])
if(!config_get_int(CONFIG_NO_SHADER))
glUseProgram(0);
}

5
src/replay.c
View file

@ -22,10 +22,7 @@ static uint8_t replay_magic_header[] = REPLAY_MAGIC_HEADER;
void replay_init(Replay *rpy) {
memset(rpy, 0, sizeof(Replay));
rpy->playername = malloc(strlen(tconfig.strval[PLAYERNAME]) + 1);
strcpy(rpy->playername, tconfig.strval[PLAYERNAME]);
stralloc(&rpy->playername, config_get_str(CONFIG_PLAYERNAME));
printf("replay_init(): replay initialized for writting\n");
}

18
src/resource/audio.c
View file

@ -27,7 +27,7 @@ int warn_alut_error(const char *when) {
void unload_alut_if_needed() {
// ALUT will be unloaded only if there are no audio AND no music enabled
if(!tconfig.intval[NO_AUDIO] || !tconfig.intval[NO_MUSIC] || !alut_loaded) return;
if(!config_get_int(CONFIG_NO_AUDIO) || !config_get_int(CONFIG_NO_MUSIC) || !alut_loaded) return;
warn_alut_error("preparing to shutdown");
alutExit();
@ -38,15 +38,15 @@ void unload_alut_if_needed() {
int init_alut_if_needed(int *argc, char *argv[]) {
// ALUT will not be loaded if there are no audio AND no music enabled
if((tconfig.intval[NO_AUDIO] && tconfig.intval[NO_MUSIC]) || alut_loaded) return 1;
if((config_get_int(CONFIG_NO_AUDIO) && config_get_int(CONFIG_NO_MUSIC)) || alut_loaded) return 1;
if(!alutInit(argc, argv))
{
warn_alut_error("initializing");
alutExit(); // Try to shutdown ALUT if it was partly initialized
warn_alut_error("shutting down");
tconfig.intval[NO_AUDIO] = 1;
tconfig.intval[NO_MUSIC] = 1;
config_set_int(CONFIG_NO_AUDIO, 1);
config_set_int(CONFIG_NO_MUSIC, 1);
return 0;
}
@ -58,13 +58,13 @@ int init_alut_if_needed(int *argc, char *argv[]) {
int init_sfx(int *argc, char *argv[])
{
if (tconfig.intval[NO_AUDIO]) return 1;
if (config_get_int(CONFIG_NO_AUDIO)) return 1;
if (!init_alut_if_needed(argc, argv)) return 0;
alGenSources(SNDSRC_COUNT, resources.sndsrc);
if(warn_alut_error("creating sfx sources"))
{
tconfig.intval[NO_AUDIO] = 1;
config_set_int(CONFIG_NO_AUDIO, 1);
unload_alut_if_needed();
return 0;
}
@ -81,7 +81,7 @@ void shutdown_sfx(void)
delete_sounds();
resources.state &= ~RS_SfxLoaded;
}
tconfig.intval[NO_AUDIO] = 1;
config_set_int(CONFIG_NO_AUDIO, 1);
unload_alut_if_needed();
}
@ -159,7 +159,7 @@ Sound *get_snd(Sound *source, char *name) {
void play_sound_p(char *name, int unconditional)
{
if(tconfig.intval[NO_AUDIO] || global.frameskip) return;
if(config_get_int(CONFIG_NO_AUDIO) || global.frameskip) return;
Sound *snd = get_snd(resources.sounds, name);
if (snd == NULL) return;
@ -193,7 +193,7 @@ void play_sound_p(char *name, int unconditional)
void set_sfx_volume(float gain)
{
if(tconfig.intval[NO_AUDIO]) return;
if(config_get_int(CONFIG_NO_AUDIO)) return;
printf("SFX volume: %f\n", gain);
int i;
for(i = 0; i < SNDSRC_COUNT; i++) {

12
src/resource/bgm.c
View file

@ -23,13 +23,13 @@ char *saved_bgm;
int init_bgm(int *argc, char *argv[])
{
if (tconfig.intval[NO_MUSIC]) return 1;
if (config_get_int(CONFIG_NO_MUSIC)) return 1;
if (!init_alut_if_needed(argc, argv)) return 0;
alGenSources(1, &resources.bgmsrc);
if(warn_alut_error("creating music sources"))
{
tconfig.intval[NO_MUSIC] = 1;
config_set_int(CONFIG_NO_MUSIC, 1);
unload_alut_if_needed();
return 0;
}
@ -47,7 +47,7 @@ void shutdown_bgm(void)
delete_music();
resources.state &= ~RS_BgmLoaded;
}
tconfig.intval[NO_MUSIC] = 1;
config_set_int(CONFIG_NO_MUSIC, 1);
unload_alut_if_needed();
}
@ -115,7 +115,7 @@ Sound *load_bgm(char *filename, const char *type) {
}
void start_bgm(char *name) {
if(tconfig.intval[NO_MUSIC]) return;
if(config_get_int(CONFIG_NO_MUSIC)) return;
if(!name || strcmp(name, "") == 0)
{
@ -179,7 +179,7 @@ void continue_bgm(void)
}
void stop_bgm(void) {
if (tconfig.intval[NO_MUSIC] || !current_bgm.name) return;
if (config_get_int(CONFIG_NO_MUSIC) || !current_bgm.name) return;
ALint play;
alGetSourcei(resources.bgmsrc,AL_SOURCE_STATE,&play);
@ -211,7 +211,7 @@ void restore_bgm(void)
void set_bgm_volume(float gain)
{
if(tconfig.intval[NO_MUSIC]) return;
if(config_get_int(CONFIG_NO_MUSIC)) return;
printf("BGM volume: %f\n", gain);
alSourcef(resources.bgmsrc,AL_GAIN, gain);
warn_alut_error("changing gain of music source");

6
src/resource/resource.c
View file

@ -77,7 +77,7 @@ void load_resources(void) {
resources.state |= RS_GfxLoaded;
}
if(!tconfig.intval[NO_AUDIO] && !(resources.state & RS_SfxLoaded)) {
if(!config_get_int(CONFIG_NO_AUDIO) && !(resources.state & RS_SfxLoaded)) {
printf("- sounds:\n");
strcpy(path, get_prefix());
strcat(path, "sfx");
@ -86,7 +86,7 @@ void load_resources(void) {
resources.state |= RS_SfxLoaded;
}
if(!tconfig.intval[NO_MUSIC] && !(resources.state & RS_BgmLoaded)) {
if(!config_get_int(CONFIG_NO_MUSIC) && !(resources.state & RS_BgmLoaded)) {
printf("- music:\n");
strcpy(path, get_prefix());
strcat(path, "bgm");
@ -96,7 +96,7 @@ void load_resources(void) {
resources.state |= RS_BgmLoaded;
}
if(!tconfig.intval[NO_SHADER] && !(resources.state & RS_ShaderLoaded)) {
if(!config_get_int(CONFIG_NO_SHADER) && !(resources.state & RS_ShaderLoaded)) {
printf("- shader:\n");
strcpy(path, get_prefix());
strcat(path, "shader");

2
src/resource/shader.c
View file

@ -274,7 +274,7 @@ int uniloc(Shader *sha, char *name) {
Shader *get_shader(const char *name) {
Shader *s, *res = NULL;
if(tconfig.intval[NO_SHADER])
if(config_get_int(CONFIG_NO_SHADER))
return NULL;
for(s = resources.shaders; s; s = s->next) {

14
src/stage.c
View file

@ -241,7 +241,7 @@ void draw_hud(void) {
void stage_draw(StageInfo *info, StageRule bgdraw, ShaderRule *shaderrules, int time) {
if(!tconfig.intval[NO_SHADER]) {
if(!config_get_int(CONFIG_NO_SHADER)) {
glBindFramebuffer(GL_FRAMEBUFFER, resources.fbg[0].fbo);
glViewport(0,0,SCREEN_W,SCREEN_H);
}
@ -250,14 +250,14 @@ void stage_draw(StageInfo *info, StageRule bgdraw, ShaderRule *shaderrules, int
glTranslatef(-(VIEWPORT_X+VIEWPORT_W/2.0), -(VIEWPORT_Y+VIEWPORT_H/2.0),0);
glEnable(GL_DEPTH_TEST);
if(tconfig.intval[NO_STAGEBG] == 2 && global.fps.stagebg_fps < tconfig.intval[NO_STAGEBG_FPSLIMIT]
if(config_get_int(CONFIG_NO_STAGEBG) == 2 && global.fps.stagebg_fps < config_get_int(CONFIG_NO_STAGEBG_FPSLIMIT)
&& !global.nostagebg) {
printf("stage_draw(): !- Stage background has been switched off due to low frame rate. You can change that in the options.\n");
global.nostagebg = true;
}
if(tconfig.intval[NO_STAGEBG] == 1)
if(config_get_int(CONFIG_NO_STAGEBG) == 1)
global.nostagebg = true;
if(!global.nostagebg)
@ -271,7 +271,7 @@ void stage_draw(StageInfo *info, StageRule bgdraw, ShaderRule *shaderrules, int
glPushMatrix();
glTranslatef(VIEWPORT_X,VIEWPORT_Y,0);
if(!tconfig.intval[NO_SHADER])
if(!config_get_int(CONFIG_NO_SHADER))
apply_bg_shaders(shaderrules);
if(global.boss) {
@ -312,7 +312,7 @@ void stage_draw(StageInfo *info, StageRule bgdraw, ShaderRule *shaderrules, int
draw_stage_title(info);
if(!tconfig.intval[NO_SHADER]) {
if(!config_get_int(CONFIG_NO_SHADER)) {
glBindFramebuffer(GL_FRAMEBUFFER, 0);
video_set_viewport();
glPushMatrix();
@ -489,7 +489,7 @@ void stage_loop(StageInfo* info, StageRule start, StageRule end, StageRule draw,
stage_start();
if(global.replaymode == REPLAY_RECORD) {
if(tconfig.intval[SAVE_RPY]) {
if(config_get_int(CONFIG_SAVE_RPY)) {
global.replay_stage = replay_create_stage(&global.replay, info, seed, global.diff, global.plr.points, &global.plr);
// make sure our player state is consistent with what goes into the replay
@ -584,7 +584,7 @@ void draw_title(int t, StageInfo *info, Alignment al, int x, int y, const char *
f = 1/35.0*i;
}
if(!tconfig.intval[NO_SHADER]) {
if(!config_get_int(CONFIG_NO_SHADER)) {
Shader *sha = get_shader("stagetitle");
glUseProgram(sha->prog);
glUniform1i(uniloc(sha, "trans"), 1);

4
src/stages/stage2.c
View file

@ -15,7 +15,7 @@ static Stage3D bgcontext;
void stage2_bg_leaves_draw(Vector pos) {
glEnable(GL_TEXTURE_2D);
if(!tconfig.intval[NO_SHADER])
if(!config_get_int(CONFIG_NO_SHADER))
glUseProgram(get_shader("alpha_depth")->prog);
glMatrixMode(GL_TEXTURE);
@ -37,7 +37,7 @@ void stage2_bg_leaves_draw(Vector pos) {
glPopMatrix();
if(!tconfig.intval[NO_SHADER])
if(!config_get_int(CONFIG_NO_SHADER))
glUseProgram(0);
glDisable(GL_TEXTURE_2D);

2
src/stages/stage5.c
View file

@ -38,7 +38,7 @@ void stage5_stairs_draw(Vector pos) {
glTranslatef(pos[0], pos[1], pos[2]);
glScalef(300,300,300);
if(!tconfig.intval[NO_SHADER]) {
if(!config_get_int(CONFIG_NO_SHADER)) {
Shader *sha = get_shader("tower_light");
glUseProgram(sha->prog);
glUniform3f(uniloc(sha, "lightvec"), 0, 0, 0);

4
src/stages/stage6.c
View file

@ -37,7 +37,7 @@ void stage6_towerwall_draw(Vector pos) {
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, get_tex("stage6/towerwall")->gltex);
if(!tconfig.intval[NO_SHADER]) {
if(!config_get_int(CONFIG_NO_SHADER)) {
Shader *s = get_shader("tower_wall");
glUseProgram(s->prog);
glUniform1i(uniloc(s, "lendiv"), 3000.0);
@ -166,7 +166,7 @@ void stage6_start(void) {
// bgcontext.cx[2] = 295;
// bgcontext.crot[0] = 90;
// bgcontext.crot[2] = 381.415100;
//
//
}

6
src/video.c
View file

@ -61,7 +61,7 @@ void video_set_viewport(void) {
}
void video_update_vsync(void) {
if(global.frameskip || !tconfig.intval[VSYNC]) {
if(global.frameskip || !config_get_int(CONFIG_VSYNC)) {
SDL_GL_SetSwapInterval(0);
} else {
if(SDL_GL_SetSwapInterval(-1) < 0) {
@ -166,7 +166,7 @@ void video_init(void) {
if(!fullscreen_available) {
warnx("video_init(): no available fullscreen modes");
tconfig.intval[FULLSCREEN] = false;
config_set_int(CONFIG_FULLSCREEN, false);
}
// Then, add some common 4:3 modes for the windowed mode if they are not there yet.
@ -177,7 +177,7 @@ void video_init(void) {
// sort it, mainly for the options menu
qsort(video.modes, video.mcount, sizeof(VideoMode), video_compare_modes);
video_setmode(tconfig.intval[VID_WIDTH], tconfig.intval[VID_HEIGHT], tconfig.intval[FULLSCREEN]);
video_setmode(config_get_int(CONFIG_VID_WIDTH), config_get_int(CONFIG_VID_HEIGHT), config_get_int(CONFIG_FULLSCREEN));
}
void video_shutdown(void) {