static int fill_row(int id, SDL_Rect **modes, int i, int n)
{
int complete;
if (n == 0)
return 1;
if (modes[i])
{
char label[20];
int btn;
sprintf(label, "%d x %d", modes[i]->w, modes[i]->h);
complete = fill_row(id, modes, i + 1, n - 1);
btn = gui_state(id, label, GUI_SML, RESOL_SELECT, i);
gui_set_hilite(btn, (config_get_d(CONFIG_WIDTH) == modes[i]->w &&
config_get_d(CONFIG_HEIGHT) == modes[i]->h));
}
else
{
for (; n; gui_space(id), n--);
complete = 0;
}
return complete;
}
static void view_init(void)
{
view_a = 0.f;
view_ry = 0.f;
view_fov = (float) config_get_d(CONFIG_VIEW_FOV);
view_dp = (float) config_get_d(CONFIG_VIEW_DP) / 100.0f;
view_dc = (float) config_get_d(CONFIG_VIEW_DC) / 100.0f;
view_dz = (float) config_get_d(CONFIG_VIEW_DZ) / 100.0f;
view_k = 1.0f;
view_c[0] = 0.f;
view_c[1] = view_dc;
view_c[2] = 0.f;
view_p[0] = 0.f;
view_p[1] = view_dp;
view_p[2] = view_dz;
view_e[0][0] = 1.f;
view_e[0][1] = 0.f;
view_e[0][2] = 0.f;
view_e[1][0] = 0.f;
view_e[1][1] = 1.f;
view_e[1][2] = 0.f;
view_e[2][0] = 0.f;
view_e[2][1] = 0.f;
view_e[2][2] = 1.f;
}
static int camera_gui(void)
{
int id, jd;
if ((id = gui_vstack(0)))
{
conf_header(id, _("Camera"), GUI_BACK);
int rot_speed = ROT_SPEED_RANGE_MAP(config_get_d(CONFIG_ROTATE_FAST));
int normal_rot_accel = config_get_d(CONFIG_ROTATE_ACCEL_NORMAL);
int finesse_rot_accel = config_get_d(CONFIG_ROTATE_ACCEL_FINESSE);
conf_slider(id, _("Max rotation speed"), CAMERA_ROT_SPEED, rot_speed,
rot_speed_id, ARRAYSIZE(rot_speed_id));
conf_slider(id, _("Normal rotation accel."), CAMERA_NORMAL_ROT_ACCEL, normal_rot_accel,
normal_rot_accel_id, ARRAYSIZE(normal_rot_accel_id));
conf_slider(id, _("Finesse-mode rotation accel."), CAMERA_FINESSE_ROT_ACCEL, finesse_rot_accel,
finesse_rot_accel_id, ARRAYSIZE(finesse_rot_accel_id));
gui_space(id);
conf_toggle(id, _("Reversed camera rotation"), CAMERA_REVERSED_CAMERA_ROTATION,
config_get_d(CONFIG_REVERSED_CAMERA_ROTATION), _("On"), 1, _("Off"), 0);
conf_toggle(id, _("Draw floor tilt"), CAMERA_SCREEN_TILT_ENABLED,
config_get_d(CONFIG_SCREEN_TILT_ENABLED), _("On"), 1, _("Off"), 0);
gui_layout(id, 0, 0);
}
return id;
}
int video_init(const char *title, const char *icon)
{
SDL_QuitSubSystem(SDL_INIT_VIDEO);
if (SDL_InitSubSystem(SDL_INIT_VIDEO) == -1)
{
fprintf(stderr, "%s\n", SDL_GetError());
return 0;
}
/* This has to happen before mode setting... */
set_SDL_icon(icon);
/* Initialize the video. */
if (!video_mode(config_get_d(CONFIG_FULLSCREEN),
config_get_d(CONFIG_WIDTH),
config_get_d(CONFIG_HEIGHT)))
{
fprintf(stderr, "%s\n", SDL_GetError());
return 0;
}
/* ...and this has to happen after it. */
set_EWMH_icon(icon);
SDL_WM_SetCaption(title, title);
return 1;
}
static int display_action(int tok, int val)
{
int r = 1;
audio_play(AUD_MENU, 1.0f);
switch (tok)
{
case GUI_BACK:
goto_state(display_back);
display_back = NULL;
break;
case DISPLAY_SELECT:
if (val != config_get_d(CONFIG_DISPLAY))
{
goto_state(&st_null);
config_set_d(CONFIG_DISPLAY, val);
r = video_mode(config_get_d(CONFIG_FULLSCREEN),
config_get_d(CONFIG_WIDTH),
config_get_d(CONFIG_HEIGHT));
goto_state(&st_display);
}
break;
}
return r;
}
static int handle_key_up(SDL_Event *e)
{
int d = 1;
int c = e->key.keysym.sym;
switch (c)
{
case SDLK_RETURN:
d = st_buttn(config_get_d(CONFIG_JOYSTICK_BUTTON_A), 0);
break;
case KEY_EXIT:
d = st_keybd(KEY_EXIT, 0);
break;
default:
if (config_tst_d(CONFIG_KEY_FORWARD, c))
st_stick(config_get_d(CONFIG_JOYSTICK_AXIS_Y0), 0);
else if (config_tst_d(CONFIG_KEY_BACKWARD, c))
st_stick(config_get_d(CONFIG_JOYSTICK_AXIS_Y0), 0);
else if (config_tst_d(CONFIG_KEY_LEFT, c))
st_stick(config_get_d(CONFIG_JOYSTICK_AXIS_X0), 0);
else if (config_tst_d(CONFIG_KEY_RIGHT, c))
st_stick(config_get_d(CONFIG_JOYSTICK_AXIS_X0), 0);
else
d = st_keybd(e->key.keysym.sym, 0);
}
return d;
}
static void play_loop_timer(int id, float dt)
{
float k = (fast_rotate ?
(float) config_get_d(CONFIG_ROTATE_FAST) / 100.0f :
(float) config_get_d(CONFIG_ROTATE_SLOW) / 100.0f);
float r = 0.0f;
gui_timer(id, dt);
hud_timer(dt);
switch (rot_get(&r))
{
case ROT_HOLD:
/*
* Cam 3 could be anything. But let's assume it's a manual cam
* and holding down both rotation buttons freezes the camera
* rotation.
*/
game_set_rot(0.0f);
game_set_cam(CAM_3);
break;
case ROT_ROTATE:
case ROT_NONE:
game_set_rot(r * k);
game_set_cam(config_get_d(CONFIG_CAMERA));
break;
}
game_step_fade(dt);
game_server_step(dt);
game_client_sync(demo_fp);
game_client_blend(game_server_blend());
switch (curr_status())
{
case GAME_GOAL:
progress_stat(GAME_GOAL);
goto_state(&st_goal);
break;
case GAME_FALL:
progress_stat(GAME_FALL);
goto_state(&st_fail);
break;
case GAME_TIME:
progress_stat(GAME_TIME);
goto_state(&st_fail);
break;
default:
progress_step();
break;
}
}
void game_set_pos(int x, int y)
{
const float range = ANGLE_BOUND * 2;
input_set_x(input_get_x() + range * y / config_get_d(CONFIG_MOUSE_SENSE));
input_set_z(input_get_z() + range * x / config_get_d(CONFIG_MOUSE_SENSE));
input_set_s(config_get_d(CONFIG_MOUSE_RESPONSE) * 0.001f);
}
static int handle_key_dn(SDL_Event *e)
{
int d = 1;
int c = e->key.keysym.sym;
/* SDL made me do it. */
#ifdef __APPLE__
if (c == SDLK_q && e->key.keysym.mod & KMOD_GUI)
return 0;
#endif
#ifdef _WIN32
if (c == SDLK_F4 && e->key.keysym.mod & KMOD_ALT)
return 0;
#endif
switch (c)
{
case KEY_SCREENSHOT:
shot();
break;
case KEY_FPS:
config_tgl_d(CONFIG_FPS);
break;
case KEY_WIREFRAME:
if (config_cheat())
toggle_wire();
break;
case KEY_RESOURCES:
if (config_cheat())
{
light_load();
mtrl_reload();
}
break;
case SDLK_RETURN:
d = st_buttn(config_get_d(CONFIG_JOYSTICK_BUTTON_A), 1);
break;
case KEY_EXIT:
d = st_keybd(KEY_EXIT, 1);
break;
default:
if (config_tst_d(CONFIG_KEY_FORWARD, c))
st_stick(config_get_d(CONFIG_JOYSTICK_AXIS_Y0), -1.0f);
else if (config_tst_d(CONFIG_KEY_BACKWARD, c))
st_stick(config_get_d(CONFIG_JOYSTICK_AXIS_Y0), +1.0f);
else if (config_tst_d(CONFIG_KEY_LEFT, c))
st_stick(config_get_d(CONFIG_JOYSTICK_AXIS_X0), -1.0f);
else if (config_tst_d(CONFIG_KEY_RIGHT, c))
st_stick(config_get_d(CONFIG_JOYSTICK_AXIS_X0), +1.0f);
else
d = st_keybd(e->key.keysym.sym, 1);
}
return d;
}
static int conf_action(int tok, int val)
{
int sound = config_get_d(CONFIG_SOUND_VOLUME);
int music = config_get_d(CONFIG_MUSIC_VOLUME);
int mouse = MOUSE_RANGE_MAP(config_get_d(CONFIG_MOUSE_SENSE));
int r = 1;
audio_play(AUD_MENU, 1.0f);
switch (tok)
{
case GUI_BACK:
goto_state(&st_title);
break;
case CONF_VIDEO:
goto_state(&st_conf_video);
break;
case CONF_PLAYER:
goto_name(&st_conf, &st_conf, 1);
break;
case CONF_BALL:
goto_state(&st_ball);
break;
case CONF_MOUSE_SENSE:
config_set_d(CONFIG_MOUSE_SENSE, MOUSE_RANGE_UNMAP(val));
gui_toggle(mouse_id[val]);
gui_toggle(mouse_id[mouse]);
break;
case CONF_SOUND_VOLUME:
config_set_d(CONFIG_SOUND_VOLUME, val);
audio_volume(val, music);
audio_play(AUD_BUMPM, 1.f);
gui_toggle(sound_id[val]);
gui_toggle(sound_id[sound]);
break;
case CONF_MUSIC_VOLUME:
config_set_d(CONFIG_MUSIC_VOLUME, val);
audio_volume(sound, val);
audio_play(AUD_BUMPM, 1.f);
gui_toggle(music_id[val]);
gui_toggle(music_id[music]);
break;
}
return r;
}
void game_init(const char *s)
{
jump_e = 1;
jump_b = 0;
view_init();
sol_load_gl(&file, s,
config_get_d(CONFIG_TEXTURES),
config_get_d(CONFIG_SHADOW));
}
static int start_click(int b, int d)
{
if (gui_click(b, d))
{
return start_buttn(config_get_d(CONFIG_JOYSTICK_BUTTON_A), 1);
}
else if (gui_click_right(b, d))
{
return start_buttn(config_get_d(CONFIG_JOYSTICK_BUTTON_B), 1);
}
return 1;
}
int tilt_get_button(int *b, int *s)
{
int ch = BUTTON_NC;
if (mutex)
{
SDL_mutexP(mutex);
{
if ((ch = get_button(&state.A)))
{
*b = config_get_d(CONFIG_JOYSTICK_BUTTON_A);
*s = (ch == BUTTON_DN);
}
else if ((ch = get_button(&state.B)))
{
*b = config_get_d(CONFIG_JOYSTICK_BUTTON_B);
*s = (ch == BUTTON_DN);
}
else if ((ch = get_button(&state.plus)))
{
*b = config_get_d(CONFIG_JOYSTICK_BUTTON_R1);
*s = (ch == BUTTON_DN);
}
else if ((ch = get_button(&state.minus)))
{
*b = config_get_d(CONFIG_JOYSTICK_BUTTON_L1);
*s = (ch == BUTTON_DN);
}
else if ((ch = get_button(&state.home)))
{
*b = config_get_d(CONFIG_JOYSTICK_BUTTON_START);
*s = (ch == BUTTON_DN);
}
else if ((ch = get_button(&state.L)))
{
*b = config_get_d(CONFIG_JOYSTICK_DPAD_L);
*s = (ch == BUTTON_DN);
}
else if ((ch = get_button(&state.R)))
{
*b = config_get_d(CONFIG_JOYSTICK_DPAD_R);
*s = (ch == BUTTON_DN);
}
else if ((ch = get_button(&state.U)))
{
*b = config_get_d(CONFIG_JOYSTICK_DPAD_U);
*s = (ch == BUTTON_DN);
}
else if ((ch = get_button(&state.D)))
{
*b = config_get_d(CONFIG_JOYSTICK_DPAD_D);
*s = (ch == BUTTON_DN);
}
}
SDL_mutexV(mutex);
}
return ch;
}
int video_init(void)
{
if (!video_mode(config_get_d(CONFIG_FULLSCREEN),
config_get_d(CONFIG_WIDTH),
config_get_d(CONFIG_HEIGHT)))
{
log_printf("Failure to create window (%s)\n", SDL_GetError());
return 0;
}
return 1;
}
void video_push_ortho(void)
{
GLdouble w = (GLdouble) config_get_d(CONFIG_WIDTH);
GLdouble h = (GLdouble) config_get_d(CONFIG_HEIGHT);
glMatrixMode(GL_PROJECTION);
{
glPushMatrix();
glLoadIdentity();
glOrtho(0.0, w, 0.0, h, -1.0, +1.0);
}
glMatrixMode(GL_MODELVIEW);
}
static int camera_action(int tok, int val)
{
int r = 1;
int rot_speed = ROT_SPEED_RANGE_MAP(config_get_d(CONFIG_ROTATE_FAST));
int normal_rot_accel = config_get_d(CONFIG_ROTATE_ACCEL_NORMAL);
int finesse_rot_accel = config_get_d(CONFIG_ROTATE_ACCEL_FINESSE);
audio_play(AUD_MENU, 1.0f);
switch (tok) {
case GUI_BACK:
goto_state(camera_back);
camera_back = NULL;
break;
case CAMERA_ROT_SPEED:
config_set_d(CONFIG_ROTATE_FAST, ROT_SPEED_RANGE_UNMAP(val));
gui_toggle(rot_speed_id[val]);
gui_toggle(rot_speed_id[rot_speed]);
break;
case CAMERA_NORMAL_ROT_ACCEL:
config_set_d(CONFIG_ROTATE_ACCEL_NORMAL, val);
gui_toggle(normal_rot_accel_id[val]);
gui_toggle(normal_rot_accel_id[normal_rot_accel]);
break;
case CAMERA_FINESSE_ROT_ACCEL:
config_set_d(CONFIG_ROTATE_ACCEL_FINESSE, val);
gui_toggle(finesse_rot_accel_id[val]);
gui_toggle(finesse_rot_accel_id[finesse_rot_accel]);
break;
case CAMERA_SCREEN_TILT_ENABLED:
goto_state(&st_null);
config_set_d(CONFIG_SCREEN_TILT_ENABLED, val);
goto_state(&st_camera);
break;
case CAMERA_REVERSED_CAMERA_ROTATION:
goto_state(&st_null);
config_set_d(CONFIG_REVERSED_CAMERA_ROTATION, val);
goto_state(&st_camera);
break;
default:
break;
}
return r;
}
static int conf_action(int i)
{
int s = config_get_d(CONFIG_SOUND_VOLUME);
int m = config_get_d(CONFIG_MUSIC_VOLUME);
int r = 1;
audio_play(AUD_MENU, 1.0f);
switch (i)
{
case CONF_BACK:
goto_state(&st_title);
break;
case CONF_VIDEO:
goto_state(&st_video);
break;
case CONF_LANG:
goto_state(&st_lang);
break;
default:
if (100 <= i && i <= 110)
{
int n = i - 100;
config_set_d(CONFIG_SOUND_VOLUME, n);
audio_volume(n, m);
audio_play(AUD_BUMP, 1.f);
gui_toggle(sound_id[n]);
gui_toggle(sound_id[s]);
}
if (200 <= i && i <= 210)
{
int n = i - 200;
config_set_d(CONFIG_MUSIC_VOLUME, n);
audio_volume(s, n);
audio_play(AUD_BUMP, 1.f);
gui_toggle(music_id[n]);
gui_toggle(music_id[m]);
}
}
return r;
}
void hmd_common_swap(float center,
float scale,
const float *barrel_correction,
const float *chroma_correction)
{
int w = config_get_d(CONFIG_WIDTH);
int h = config_get_d(CONFIG_HEIGHT);
float a = (float) w / (float) h / 2;
/* Prepare to draw a screen-filling pair of rectangles. */
glBindFramebuffer_(GL_FRAMEBUFFER, 0);
glViewport(0, 0, w, h);
glDisable(GL_BLEND);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glUseProgram_(distortion.program);
{
/* Set distortion parameters for both eyes. */
glsl_uniform2f(&distortion, "ScaleOut", 0.5f / scale, 0.5f * a / scale);
glsl_uniform2f(&distortion, "ScaleIn", 2.0f, 2.0f / a);
glsl_uniform4f(&distortion, "DistortionK", barrel_correction[0],
barrel_correction[1],
barrel_correction[2],
barrel_correction[3]);
glsl_uniform4f(&distortion, "ChromAbParam", chroma_correction[0],
chroma_correction[1],
chroma_correction[2],
chroma_correction[3]);
/* Draw the left eye. */
glsl_uniform2f(&distortion, "LensCenter", 0.5f + 0.5f * center, 0.5f);
hmd_common_draw(L_fbo.color_texture, L_vbo);
/* Draw the right eye.*/
glsl_uniform2f(&distortion, "LensCenter", 0.5f - 0.5f * center, 0.5f);
hmd_common_draw(R_fbo.color_texture, R_vbo);
}
glUseProgram_(0);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
glEnable(GL_BLEND);
}
static int set_enter(void)
{
int w = config_get_d(CONFIG_WIDTH);
int h = config_get_d(CONFIG_HEIGHT);
int id, jd, kd;
int i;
if (do_init)
{
total = set_init();
first = MIN(first, (total - 1) - ((total - 1) % SET_STEP));
audio_music_fade_to(0.5f, "bgm/inter.ogg");
audio_play(AUD_START, 1.f);
}
else do_init = 1;
if ((id = gui_vstack(0)))
{
if ((jd = gui_hstack(id)))
{
gui_label(jd, _("Level Set"), GUI_SML, GUI_ALL, gui_yel, gui_red);
gui_filler(jd);
gui_navig(jd, first > 0, first + SET_STEP < total);
}
gui_space(id);
if ((jd = gui_harray(id)))
{
shot_id = gui_image(jd, set_shot(first), 7 * w / 16, 7 * h / 16);
if ((kd = gui_varray(jd)))
{
for (i = first; i < first + SET_STEP; i++)
gui_set(kd, i);
}
}
gui_space(id);
desc_id = gui_multi(id, " \\ \\ \\ \\ \\", GUI_SML, GUI_ALL,
gui_yel, gui_wht);
gui_layout(id, 0, 0);
}
return id;
}
static int conf_gui(void)
{
int id;
/* Initialize the configuration GUI. */
if ((id = gui_vstack(0)))
{
int sound = config_get_d(CONFIG_SOUND_VOLUME);
int music = config_get_d(CONFIG_MUSIC_VOLUME);
int mouse = MOUSE_RANGE_MAP(config_get_d(CONFIG_MOUSE_SENSE));
const char *player = config_get_s(CONFIG_PLAYER);
const char *ball = config_get_s(CONFIG_BALL_FILE);
int name_id = 0, ball_id = 0;
conf_header(id, _("Options"), GUI_BACK);
conf_state(id, _("Graphics"), _("Configure"), CONF_VIDEO);
gui_space(id);
conf_slider(id, _("Mouse Sensitivity"), CONF_MOUSE_SENSE, mouse,
mouse_id, ARRAYSIZE(mouse_id));
gui_space(id);
conf_slider(id, _("Sound Volume"), CONF_SOUND_VOLUME, sound,
sound_id, ARRAYSIZE(sound_id));
conf_slider(id, _("Music Volume"), CONF_MUSIC_VOLUME, music,
music_id, ARRAYSIZE(music_id));
gui_space(id);
name_id = conf_state(id, _("Player Name"), " ", CONF_PLAYER);
ball_id = conf_state(id, _("Ball Model"), " ", CONF_BALL);
gui_layout(id, 0, 0);
gui_set_trunc(name_id, TRUNC_TAIL);
gui_set_trunc(ball_id, TRUNC_TAIL);
gui_set_label(name_id, player);
gui_set_label(ball_id, base_name(ball));
}
return id;
}
void game_set_pos(int x, int y)
{
// float bound = 20.f;
float bound = BOUND; //20.f;
// game_ix += 40.f * y / config_get_d(CONFIG_MOUSE_SENSE);
game_ix += (2.0f*BOUND) * y / config_get_d(CONFIG_MOUSE_SENSE);
// game_iz += 40.f * x / config_get_d(CONFIG_MOUSE_SENSE);
game_iz += (2.0f*BOUND) * x / config_get_d(CONFIG_MOUSE_SENSE);
if (game_ix > +bound) game_ix = +bound;
if (game_ix < -bound) game_ix = -bound;
if (game_iz > +bound) game_iz = +bound;
if (game_iz < -bound) game_iz = -bound;
}
void hud_paint(void)
{
static int fps = 0;
static int then = 0;
static int count = 0;
int now = SDL_GetTicks();
if (now - then > 250)
{
fps = count * 1000 / (now - then);
then = now;
count = 0;
gui_set_count(fps_id, fps);
}
else count++;
if (config_get_d(CONFIG_FPS))
gui_paint(fps_id);
gui_paint(Rhud_id);
gui_paint(Lhud_id);
#ifdef __MOBILE__
gui_paint(Shud_id);
#endif
}
int game_init(const char *s)
{
int i;
jump_e = 1;
jump_b = 0;
idle_t = 1.0f;
view_init();
if (!(state = sol_load_full(&file, s, config_get_d(CONFIG_SHADOW))))
return 0;
sol_init_sim(&file.vary);
for (i = 0; i < file.base.dc; i++)
{
const char *k = file.base.av + file.base.dv[i].ai;
const char *v = file.base.av + file.base.dv[i].aj;
if (strcmp(k, "idle") == 0)
{
sscanf(v, "%f", &idle_t);
if (idle_t < 1.0f)
idle_t = 1.0f;
}
}
return 1;
}
void game_set_mag(int d)
{
view_m -= (float) (1.f * d) / config_get_d(CONFIG_MOUSE_SENSE);
if (view_m < 0.25f)
view_m = 0.25f;
}
int progress_play(struct level *l)
{
if (l && (level_opened(l) || config_cheat()))
{
level = l;
next = NULL;
status = GAME_NONE;
coins = 0;
timer = 0;
goal = goal_i = level_goal(level);
if (same_goal_e)
same_goal_e = 0;
else
goal_e = (mode != MODE_CHALLENGE && level_completed(level) &&
config_get_d(CONFIG_LOCK_GOALS) == 0) || goal == 0;
prev = curr;
time_rank = RANK_LAST;
goal_rank = RANK_LAST;
coin_rank = RANK_LAST;
return init_level();
}
return 0;
}
static void game_draw_back(int pose, int d, const float p[3])
{
float c[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
float t = SDL_GetTicks() / 1000.f + 120.0f;
glPushMatrix();
{
if (d < 0)
{
glRotatef(game_rz * 2, view_e[2][0], view_e[2][1], view_e[2][2]);
glRotatef(game_rx * 2, view_e[0][0], view_e[0][1], view_e[0][2]);
}
glTranslatef(p[0], p[1], p[2]);
glColor4fv(c);
if (config_get_d(CONFIG_BACKGROUND))
{
/* Draw all background layers back to front. */
sol_back(&back, BACK_DIST, FAR_DIST, t);
back_draw(0);
sol_back(&back, 0, BACK_DIST, t);
/* Draw all foreground geometry in the background file. */
sol_draw(&back);
}
else back_draw(0);
}
glPopMatrix();
}
void st_paint(float t)
{
int stereo = config_get_d(CONFIG_STEREO);
state_drawn = 1;
if (state && state->paint)
{
if (stereo)
{
glDrawBuffer(GL_BACK_LEFT);
video_clear();
state->paint(state->gui_id, t);
glDrawBuffer(GL_BACK_RIGHT);
video_clear();
state->paint(state->gui_id, t);
}
else
{
video_clear();
state->paint(state->gui_id, t);
}
}
}
void st_stick(int a, float v)
{
static struct
{
const int *num;
const int *inv;
} axes[] = {
{ &CONFIG_JOYSTICK_AXIS_X0, &CONFIG_JOYSTICK_AXIS_X0_INVERT },
{ &CONFIG_JOYSTICK_AXIS_Y0, &CONFIG_JOYSTICK_AXIS_Y0_INVERT },
{ &CONFIG_JOYSTICK_AXIS_X1, &CONFIG_JOYSTICK_AXIS_X1_INVERT },
{ &CONFIG_JOYSTICK_AXIS_Y1, &CONFIG_JOYSTICK_AXIS_Y1_INVERT }
};
int i;
for (i = 0; i < ARRAYSIZE(axes); i++)
if (config_tst_d(*axes[i].num, a) && config_get_d(*axes[i].inv))
{
v = -v;
break;
}
if (state && state->stick)
{
cache_stick(a, v, state_time + STICK_HOLD_TIME);
state->stick(state->gui_id, a, v, bump_stick(a));
}
}
static void game_shadow_conf(int pose, int enable)
{
if (enable && config_get_d(CONFIG_SHADOW))
{
switch (pose)
{
case POSE_LEVEL:
/* No shadow. */
tex_env_active(&tex_env_default);
break;
case POSE_BALL:
/* Shadow only. */
tex_env_select(&tex_env_pose,
&tex_env_default,
NULL);
break;
default:
/* Regular shadow. */
tex_env_select(&tex_env_shadow_clip,
&tex_env_shadow,
&tex_env_default,
NULL);
break;
}
}
else
{
tex_env_active(&tex_env_default);
}
}
static void game_draw_back(struct s_rend *rend,
const struct game_draw *gd,
int pose, int d, float t)
{
if (pose == POSE_BALL)
return;
glPushMatrix();
{
const struct game_view *view = &gd->view;
if (d < 0)
{
const struct game_tilt *tilt = &gd->tilt;
glRotatef(tilt->rz * 2, tilt->z[0], tilt->z[1], tilt->z[2]);
glRotatef(tilt->rx * 2, tilt->x[0], tilt->x[1], tilt->x[2]);
}
glTranslatef(view->p[0], view->p[1] * d, view->p[2]);
if (config_get_d(CONFIG_BACKGROUND))
{
back_draw(rend);
sol_back(&gd->back.draw, rend, 0, FAR_DIST, t);
}
else back_draw(rend);
}
glPopMatrix();
}