void gr_opengl_flip()
{
if ( !GL_initted )
return;
TRACE_SCOPE(tracing::PageFlip);
gr_reset_clip();
mouse_reset_deltas();
if (Cmdline_gl_finish)
glFinish();
current_viewport->swapBuffers();
opengl_tcache_frame();
#ifndef NDEBUG
int ic = opengl_check_for_errors();
if (ic) {
mprintf(("!!DEBUG!! OpenGL Errors this frame: %i\n", ic));
}
#endif
}
void gr_opengl_cleanup(bool closing, int minimize)
{
if ( !GL_initted ) {
return;
}
if ( !closing && !Fred_running ) {
gr_reset_clip();
gr_clear();
gr_flip();
gr_clear();
gr_flip();
gr_clear();
}
GL_initted = false;
opengl_tcache_flush();
opengl_minimize();
gr_opengl_shutdown();
current_viewport = nullptr;
graphic_operations.reset();
}
void UI_SCROLLBAR::draw()
{
UI_GADGET::draw();
if (uses_bmaps) {
gr_reset_clip();
if (disabled_flag) {
if ( bmap_ids[SB_DISABLED] != -1 ) {
gr_set_bitmap(bmap_ids[SB_DISABLED]);
gr_bitmap(x,y,GR_RESIZE_MENU);
}
} else {
if ( bmap_ids[SB_NORMAL] != -1 ) {
gr_set_bitmap(bmap_ids[SB_NORMAL]);
gr_bitmap(x,y,GR_RESIZE_MENU);
}
}
gr_set_clip( x, y, w, h, GR_RESIZE_MENU );
ui_draw_box_out( 0, bar_position, w - 1, bar_position + bar_size - 1 );
} else {
font::set_font(my_wnd->f_id);
gr_set_clip( x, y, w, h, GR_RESIZE_MENU );
if (my_wnd->selected_gadget == this)
gr_set_color_fast(&CBRIGHT_GREEN);
else
gr_set_color_fast(&CGRAY);
ui_rect( 0, 0, w-1, h-1 );
ui_draw_box_out( 0, bar_position, w - 1, bar_position + bar_size - 1 );
}
}
void UI_ICON::draw()
{
if (uses_bmaps) {
gr_reset_clip();
if (disabled_flag) {
if (bmap_ids[ICON_DISABLED] != -1) {
gr_set_bitmap(bmap_ids[ICON_DISABLED]);
gr_bitmap(x,y);
}
} else if (this->is_mouse_on()) {
if (B1_PRESSED) {
if (bmap_ids[ICON_SELECTED] != -1) {
gr_set_bitmap(bmap_ids[ICON_SELECTED]);
gr_bitmap(x, y);
}
} else {
if (bmap_ids[ICON_HIGHLIGHT] != -1) {
gr_set_bitmap(bmap_ids[ICON_HIGHLIGHT]);
gr_bitmap(x, y);
}
}
} else {
if (bmap_ids[ICON_NORMAL] != -1) {
gr_set_bitmap(bmap_ids[ICON_NORMAL]);
gr_bitmap(x, y);
}
}
} else {
gr_set_font(my_wnd->f_id);
gr_set_clip(x, y, w, h);
ui_draw_box_out(0, 0, w-1, h-1);
if (disabled_flag)
gr_set_color_fast(&CDARK_GRAY);
else
gr_set_color_fast(&CBLACK);
if (text)
ui_string_centered(Middle(w), Middle(h), text);
gr_reset_clip();
}
}
// run the popup in a tight loop (no states)
void multi_pinfo_popup_do()
{
int k;
// if there was an error in initialization, return immediately
if (Multi_pinfo_popup_error)
{
return;
}
// tight loop
while (!Multi_pinfo_popup_done)
{
multi_pinfo_maybe_reload_pic(&Mp_pilot);
multi_pinfo_maybe_reload_pic(&Mp_squad);
// process the window
k = Multi_pinfo_window.process();
switch (k)
{
case KEY_ESC :
Multi_pinfo_popup_done = 1;
break;
}
// check button presses
multi_pinfo_popup_check_buttons();
// set frametime and run background stuff
game_set_frametime(-1);
game_do_state_common(gameseq_get_state());
// draw the background bitmap and the ui window over it
Assert(Multi_pinfo_screen_save != -1);
gr_reset_clip();
gr_restore_screen(Multi_pinfo_screen_save);
// grey the screen
gr_set_shader(&Grey_shader);
gr_shade(0, 0, gr_screen.clip_width, gr_screen.clip_height, false);
// draw the background bitmap
gr_set_bitmap(Multi_pinfo_bitmap);
gr_bitmap(0, 0);
// blit the selected pilot image
multi_pinfo_blit_pilot_image();
// blit the squadron logo
multi_pinfo_blit_squadron_logo();
// blit the player statistics
multi_pinfo_blit_player_stats();
// draw the ui window and flip
Multi_pinfo_window.draw();
gr_flip();
}
}
void UI_WINDOW::draw()
{
UI_GADGET *tmp;
gr_reset_clip();
font::set_font(f_id);
if (foreground_bmap_id >= 0) {
gr_set_bitmap(foreground_bmap_id);
gr_bitmap(x, y, GR_RESIZE_MENU);
}
if (flags & WIN_FILLED) {
ui_draw_box_out(x, y, x+w-1, y+h-1);
}
if (flags & WIN_BORDER) {
ui_draw_frame(x-BORDER_WIDTH, y-BORDER_WIDTH, x+w+BORDER_WIDTH-1, y+h+BORDER_WIDTH-1);
}
if (first_gadget) {
tmp = first_gadget;
do {
if (!tmp->hidden)
tmp->draw();
tmp = tmp->next;
} while (tmp != first_gadget);
}
if (first_gadget) {
tmp = first_gadget;
do {
if (!tmp->hidden && (tmp->kind == UI_KIND_BUTTON) && ((UI_BUTTON *) tmp)->button_down()){
tmp->draw();
}
tmp = tmp->next;
} while (tmp != first_gadget);
}
// draw all xstrs
draw_xstrs();
// draw tooltips
draw_tooltip();
// convenient debug code for showing mouse coords
if(Cmdline_mouse_coords){
int mx, my;
mouse_get_pos(&mx, &my);
// mprintf(("MOUSE (%d, %d)\n", mx, my));
gr_set_color_fast(&Color_normal);
gr_printf_no_resize(mx, my - 12, "%d %d", mx, my);
}
}
void RocketRenderingInterface::EnableScissorRegion(bool enable)
{
GR_DEBUG_SCOPE("libRocket::EnableScissorRegion");
if (!enable) {
// Disable clipping if requested
gr_reset_clip();
}
// If clipping is active then SetScissorRegion will be called next
clipping_active = enable;
}
void training_menu_do_frame(float frametime)
{
int training_menu_choice;
if (!training_menu_inited)
{
training_menu_init();
training_menu_inited = 1;
}
gr_reset_clip();
gr_set_color(0, 0, 0);
GR_MAYBE_CLEAR_RES(trainingMenuBitmap);
// set the background
if (trainingMenuBitmap != -1)
{
gr_set_bitmap(trainingMenuBitmap);
gr_bitmap(0, 0);
}
int snazzy_action = -1;
training_menu_choice = snazzy_menu_do(mask_data, Training_mask_w, Training_mask_h, num_training,
region, &snazzy_action);
if (snazzy_action != SNAZZY_CLICKED)
{
training_menu_choice = -1;
}
switch (training_menu_choice)
{
case TRAINING_MENU_TRAINING_MISSIONS_MASK:
break;
case TRAINING_MENU_REPLAY_MISSIONS_MASK:
// TODO: load the mission and start the briefing
break;
case TRAINING_MENU_RETURN_MASK:
case ESC_PRESSED:
gameseq_post_event(GS_EVENT_MAIN_MENU);
break;
case -1:
// nothing selected
break;
default:
Error(LOCATION, "Unknown option %d in training menu screen", training_menu_choice);
break;
} // end switch
gr_flip();
}
void gr_opengl_restore_screen(int bmp_id)
{
gr_reset_clip();
if ( !GL_saved_screen ) {
gr_clear();
return;
}
Assert( (bmp_id < 0) || (bmp_id == GL_saved_screen_id) );
if (GL_saved_screen_id < 0)
return;
gr_set_bitmap(GL_saved_screen_id);
gr_bitmap(0, 0, GR_RESIZE_NONE); // don't scale here since we already have real screen size
}
void UI_SLIDER2::draw() {
Assert((currentPosition >= 0) && (currentPosition <= numberPositions));
if (uses_bmaps && !disabled_flag) {
gr_reset_clip();
switch (slider_mode) {
case S2M_ON_ME:
gr_set_bitmap(bmap_ids[S2_HIGHLIGHT]); // draw slider level
break;
case S2M_MOVING:
gr_set_bitmap(bmap_ids[S2_PRESSED]);
break;
case S2M_DEFAULT:
default:
gr_set_bitmap(bmap_ids[S2_NORMAL]); // draw slider level
break;
}
gr_bitmap(x, y+currentPosition, GR_RESIZE_MENU);
}
}
void UI_INPUTBOX::draw()
{
int invis, w1, h1, tw, th;
int text_x, text_y;
if (hidden){
return;
}
w1 = w;
h1 = h;
invis = flags & UI_INPUTBOX_FLAG_INVIS;
gr_set_font(my_wnd->f_id);
gr_reset_clip();
if (!invis && !(flags & UI_INPUTBOX_FLAG_NO_BACK)) {
// draw the entire text box region
ui_draw_sunken_border( x-2, y-2, x+w+1, y+h+1 );
gr_set_color_fast( &CBLACK );
gr_rect( 0, 0, w, h );
w1 -= 4;
h1 -= 4;
gr_set_clip( x + 1, y + 1, w1 + 1, h1 + 1 );
} else {
gr_set_clip( x - 1, y - 1, w1 + 1, h1 + 1 );
}
if (flags & UI_INPUTBOX_FLAG_PASSWD){
gr_get_string_size(&tw, &th, passwd_text);
} else {
gr_get_string_size(&tw, &th, text);
}
// If first_time is set, that means this input box got
// focus, but nothing is typed yet, so all the text is
// selected, if you type a character it will replace the
// text, if you type an arrow it will unselect it.
// So it needs to be colored differently to show this.
if (!disabled_flag && !(flags & UI_INPUTBOX_FLAG_NO_BACK)) {
// if ( (my_wnd->selected_gadget == this) && first_time ) {
// gr_set_color_fast( text_color );
// } else {
gr_set_color_fast( &CBLACK );
// }
// color the background behind the text
gr_rect( 0, 0, tw + 1, th );
}
if ( (my_wnd->selected_gadget == this) || disabled_flag ) {
gr_set_color_fast(text_color);
} else {
gr_set_color_fast(&CWHITE);
}
// coords of where to draw the text
text_x = 1;
text_y = 1;
if(flags & UI_INPUTBOX_FLAG_TEXT_CEN){
// if we fit within the text area, draw it centered
if(tw <= w1 - 5){
text_x += (w1 - tw)/2;
}
}
// draw the text
if (flags & UI_INPUTBOX_FLAG_PASSWD){
gr_string(text_x, text_y, passwd_text);
} else {
gr_string(text_x, text_y, text);
}
// draw the "cursor"
if (!disabled_flag) {
if (my_wnd->selected_gadget == this) {
if (cursor_first_frame == -1) {
gr_set_color_fast(text_color);
ui_vline(1, h1, text_x + tw + 4);
ui_vline(1, h1, text_x + tw + 5);
} else {
// draw animating cursor
int time_delta = timer_get_milliseconds() - cursor_elapsed_time;
if ( (time_delta / 1000.0f) > (1.0f / cursor_fps) ) {
// advance frame
cursor_elapsed_time += time_delta;
cursor_current_frame++;
if (cursor_current_frame >= cursor_nframes) {
cursor_current_frame = 0;
}
}
// draw current frame
gr_set_bitmap(cursor_first_frame + cursor_current_frame);
gr_bitmap(text_x + tw + 4, 1);
}
}
}
gr_reset_clip();
}
void UI_INPUTBOX::draw()
{
int invis, w1, h1, tw, th;
int text_x, text_y;
if (hidden){
return;
}
w1 = w;
h1 = h;
invis = flags & UI_INPUTBOX_FLAG_INVIS;
gr_set_font(my_wnd->f_id);
gr_reset_clip();
if (!invis && !(flags & UI_INPUTBOX_FLAG_NO_BACK)) {
// draw the entire text box region
ui_draw_sunken_border( x-2, y-2, x+w+1, y+h+1 );
gr_set_color_fast( &CBLACK );
gr_rect( 0, 0, w, h, GR_RESIZE_MENU );
w1 -= 4;
h1 -= 4;
gr_set_clip( x + 1, y + 1, w1 + 1, h1 + 1, GR_RESIZE_MENU );
} else {
gr_set_clip( x - 1, y - 1, w1 + 1, h1 + 1, GR_RESIZE_MENU );
}
if (flags & UI_INPUTBOX_FLAG_PASSWD){
gr_get_string_size(&tw, &th, passwd_text);
} else {
gr_get_string_size(&tw, &th, text);
}
if (!disabled_flag && !(flags & UI_INPUTBOX_FLAG_NO_BACK)) {
gr_set_color_fast( &CBLACK );
// color the background behind the text
gr_rect( 0, 0, tw + 1, th, GR_RESIZE_MENU_NO_OFFSET );
}
if ( (my_wnd->selected_gadget == this) || disabled_flag ) {
gr_set_color_fast(text_color);
} else {
gr_set_color_fast(&CWHITE);
}
// coords of where to draw the text
text_x = 1;
text_y = 1;
if(flags & UI_INPUTBOX_FLAG_TEXT_CEN){
// if we fit within the text area, draw it centered
if(tw <= w1 - 5){
text_x += (w1 - tw)/2;
}
}
// draw the text
if (flags & UI_INPUTBOX_FLAG_PASSWD){
gr_string(text_x, text_y, passwd_text, GR_RESIZE_MENU);
} else {
gr_string(text_x, text_y, text, GR_RESIZE_MENU);
}
// draw the "cursor"
if (!disabled_flag) {
if (my_wnd->selected_gadget == this) {
if (cursor_first_frame == -1) {
gr_set_color_fast(text_color);
ui_vline(1, h1, text_x + tw + 4);
ui_vline(1, h1, text_x + tw + 5);
} else {
// draw animating cursor
int time_delta = timer_get_milliseconds() - cursor_elapsed_time;
if ( (time_delta / 1000.0f) > (1.0f / cursor_fps) ) {
// advance frame
cursor_elapsed_time += time_delta;
cursor_current_frame++;
if (cursor_current_frame >= cursor_nframes) {
cursor_current_frame = 0;
}
}
// draw current frame
gr_set_bitmap(cursor_first_frame + cursor_current_frame);
gr_bitmap(text_x + tw + 4, 1, GR_RESIZE_MENU_NO_OFFSET);
}
}
}
gr_reset_clip();
}
void UI_INPUTBOX::draw()
{
int invis, w1, h1, tw, th;
int text_x, text_y;
if (hidden){
return;
}
w1 = w;
h1 = h;
invis = flags & UI_INPUTBOX_FLAG_INVIS;
font::set_font(my_wnd->f_id);
gr_reset_clip();
if (!invis && !(flags & UI_INPUTBOX_FLAG_NO_BACK)) {
// draw the entire text box region
ui_draw_sunken_border( x-2, y-2, x+w+1, y+h+1 );
gr_set_color_fast( &CBLACK );
gr_rect( 0, 0, w, h, GR_RESIZE_MENU );
w1 -= 4;
h1 -= 4;
gr_set_clip( x + 1, y + 1, w1 + 1, h1 + 1, GR_RESIZE_MENU );
} else {
gr_set_clip( x - 1, y - 1, w1 + 1, h1 + 1, GR_RESIZE_MENU );
}
if (flags & UI_INPUTBOX_FLAG_PASSWD){
gr_get_string_size(&tw, &th, passwd_text);
} else {
gr_get_string_size(&tw, &th, text);
}
if (!disabled_flag && !(flags & UI_INPUTBOX_FLAG_NO_BACK)) {
gr_set_color_fast( &CBLACK );
// color the background behind the text
gr_rect( 0, 0, tw + 1, th, GR_RESIZE_MENU_NO_OFFSET );
}
if ( (my_wnd->selected_gadget == this) || disabled_flag ) {
gr_set_color_fast(text_color);
} else {
gr_set_color_fast(&CWHITE);
}
// coords of where to draw the text
text_x = 1;
text_y = 1;
if(flags & UI_INPUTBOX_FLAG_TEXT_CEN){
// if we fit within the text area, draw it centered
if(tw <= w1 - 5){
text_x += (w1 - tw)/2;
}
}
// draw the text
if (flags & UI_INPUTBOX_FLAG_PASSWD){
gr_string(text_x, text_y, passwd_text, GR_RESIZE_MENU);
} else {
gr_string(text_x, text_y, text, GR_RESIZE_MENU);
}
// draw the "cursor"
if (!disabled_flag) {
if (my_wnd->selected_gadget == this) {
if (cursor_first_frame == -1) {
gr_set_color_fast(text_color);
ui_vline(1, h1, text_x + tw + 4);
ui_vline(1, h1, text_x + tw + 5);
} else {
// draw animating cursor
// new method is simpler and should give the same results unless the target device is super slow
// i.e. can't render an interface frame in less than the anim frame delays (retail 15 fps == 66.67 msec)
cursor_current_frame = bm_get_anim_frame(cursor_first_frame, i2fl(timer_get_milliseconds()) / 1000.0f, 0.0f, true);
// draw current frame
gr_set_bitmap(cursor_first_frame + cursor_current_frame);
gr_bitmap(text_x + tw + 4, 1, GR_RESIZE_MENU_NO_OFFSET);
}
}
}
gr_reset_clip();
}
void UI_CHECKBOX::draw()
{
int offset;
if ( uses_bmaps ) {
if ( disabled_flag ) {
if ( flag ) {
if ( bmap_ids[CBOX_DISABLED_MARKED] != -1 ) {
gr_set_bitmap(bmap_ids[CBOX_DISABLED_MARKED]);
gr_bitmap(x,y,GR_RESIZE_MENU);
}
}
else {
if ( bmap_ids[CBOX_DISABLED_CLEAR] != -1 ) {
gr_set_bitmap(bmap_ids[CBOX_DISABLED_CLEAR]);
gr_bitmap(x,y,GR_RESIZE_MENU);
}
}
}
else { // not disabled
if ( position == 0 ) { // up
if ( flag ) { // marked
if ( bmap_ids[CBOX_UP_MARKED] != -1 ) {
gr_set_bitmap(bmap_ids[CBOX_UP_MARKED]);
gr_bitmap(x,y,GR_RESIZE_MENU);
}
}
else { // not marked
if ( bmap_ids[CBOX_UP_CLEAR] != -1 ) {
gr_set_bitmap(bmap_ids[CBOX_UP_CLEAR]);
gr_bitmap(x,y,GR_RESIZE_MENU);
}
}
}
else { // down
if ( flag ) { // marked
if ( bmap_ids[CBOX_DOWN_MARKED] != -1 ) {
gr_set_bitmap(bmap_ids[CBOX_DOWN_MARKED]);
gr_bitmap(x,y,GR_RESIZE_MENU);
}
}
else { // not marked
if ( bmap_ids[CBOX_DOWN_CLEAR] != -1 ) {
gr_set_bitmap(bmap_ids[CBOX_DOWN_CLEAR]);
gr_bitmap(x,y,GR_RESIZE_MENU);
}
}
}
}
} else {
font::set_font(my_wnd->f_id);
gr_set_clip( x, y, w, h, GR_RESIZE_MENU );
if (position == 0 ) {
ui_draw_box_out( 0, 0, w-1, h-1 );
offset = 0;
} else {
ui_draw_box_in( 0, 0, w-1, h-1 );
offset = 1;
}
if (disabled_flag)
gr_set_color_fast( &CGRAY );
else if (my_wnd->selected_gadget == this)
gr_set_color_fast( &CBRIGHT_GREEN );
else
gr_set_color_fast( &CGREEN );
if (flag)
ui_string_centered( Middle(w) + offset, Middle(h) + offset, "X" );
else
ui_string_centered( Middle(w) + offset, Middle(h) + offset, " " );
if (text) {
gr_reset_clip();
gr_string( x+w+4, y+2, text, GR_RESIZE_MENU );
}
}
}
void credits_do_frame(float frametime)
{
int i, k, next, percent, bm1, bm2;
int bx1, by1, bw1, bh1;
int bx2, by2, bw2, bh2;
// Use this id to trigger the start of music playing on the credits screen
if ( timestamp_elapsed(Credits_music_begin_timestamp) ) {
Credits_music_begin_timestamp = 0;
credits_start_music();
}
k = Ui_window.process();
switch (k) {
case KEY_ESC:
gameseq_post_event(GS_EVENT_MAIN_MENU);
key_flush();
break;
case KEY_CTRLED | KEY_UP:
case KEY_SHIFTED | KEY_TAB:
if ( !(Player->flags & PLAYER_FLAGS_IS_MULTI) ) {
credits_screen_button_pressed(CUTSCENES_BUTTON);
break;
}
// else, react like tab key.
case KEY_CTRLED | KEY_DOWN:
case KEY_TAB:
credits_screen_button_pressed(TECH_DATABASE_BUTTON);
break;
default:
break;
} // end switch
for (i=0; i<NUM_BUTTONS; i++){
if (Buttons[i][gr_screen.res].button.pressed()){
if (credits_screen_button_pressed(i)){
return;
}
}
}
gr_reset_clip();
GR_MAYBE_CLEAR_RES(Background_bitmap);
if (Background_bitmap >= 0) {
gr_set_bitmap(Background_bitmap);
gr_bitmap(0, 0);
}
percent = (int) (100.0f - (CREDITS_ARTWORK_DISPLAY_TIME - Credits_counter) * 100.0f / CREDITS_ARTWORK_FADE_TIME);
if (percent < 0){
percent = 0;
}
next = Credits_artwork_index + 1;
if (next >= NUM_IMAGES){
next = 0;
}
if (Credits_bmps[Credits_artwork_index] < 0) {
char buf[40];
if (gr_screen.res == GR_1024) {
sprintf(buf, NOX("2_CrIm%.2d"), Credits_artwork_index);
} else {
sprintf(buf, NOX("CrIm%.2d"), Credits_artwork_index);
}
Credits_bmps[Credits_artwork_index] = bm_load(buf);
}
if (Credits_bmps[next] < 0) {
char buf[40];
if (gr_screen.res == GR_1024) {
sprintf(buf, NOX("2_CrIm%.2d"), Credits_artwork_index);
} else {
sprintf(buf, NOX("CrIm%.2d"), next);
}
Credits_bmps[next] = bm_load(buf);
}
bm1 = Credits_bmps[Credits_artwork_index];
bm2 = Credits_bmps[next];
if((bm1 != -1) && (bm2 != -1)){
Assert(percent >= 0 && percent <= 100);
// get width and height
bm_get_info(bm1, &bw1, &bh1, NULL, NULL, NULL);
bm_get_info(bm2, &bw2, &bh2, NULL, NULL, NULL);
// determine where to draw the coords
bx1 = Credits_image_coords[gr_screen.res][CREDITS_X_COORD] + ((Credits_image_coords[gr_screen.res][CREDITS_W_COORD] - bw1)/2);
by1 = Credits_image_coords[gr_screen.res][CREDITS_Y_COORD] + ((Credits_image_coords[gr_screen.res][CREDITS_H_COORD] - bh1)/2);
bx2 = Credits_image_coords[gr_screen.res][CREDITS_X_COORD] + ((Credits_image_coords[gr_screen.res][CREDITS_W_COORD] - bw2)/2);
by2 = Credits_image_coords[gr_screen.res][CREDITS_Y_COORD] + ((Credits_image_coords[gr_screen.res][CREDITS_H_COORD] - bh2)/2);
gr_cross_fade(bm1, bm2, bx1, by1, bx2, by2, (float)percent / 100.0f);
}
/*
if (CreditsWin01 != -1) {
gr_set_bitmap(CreditsWin01);
gr_bitmap(233, 5);
}
if (CreditsWin02 != -1) {
gr_set_bitmap(CreditsWin02);
gr_bitmap(616, 8);
}
if (CreditsWin03 != -1) {
gr_set_bitmap(CreditsWin03);
gr_bitmap(233, 299);
}
if (CreditsWin04 != -1) {
gr_set_bitmap(CreditsWin04);
gr_bitmap(215, 8);
}
*/
Ui_window.draw();
for (i=TECH_DATABASE_BUTTON; i<=CREDITS_BUTTON; i++){
if (Buttons[i][gr_screen.res].button.button_down()){
break;
}
}
if (i > CREDITS_BUTTON){
Buttons[CREDITS_BUTTON][gr_screen.res].button.draw_forced(2);
}
gr_set_clip(Credits_text_coords[gr_screen.res][CREDITS_X_COORD], Credits_text_coords[gr_screen.res][CREDITS_Y_COORD], Credits_text_coords[gr_screen.res][CREDITS_W_COORD], Credits_text_coords[gr_screen.res][CREDITS_H_COORD]);
gr_set_font(FONT1);
gr_set_color_fast(&Color_normal);
int sy;
if ( Credit_position > 0 ) {
sy = fl2i(Credit_position+0.5f);
} else {
sy = fl2i(Credit_position-0.5f);
}
gr_string(0x8000, sy, Credit_text);
int temp_time;
temp_time = timer_get_milliseconds();
Credits_frametime = temp_time - Credits_last_time;
Credits_last_time = temp_time;
timestamp_inc(Credits_frametime / 1000.0f);
float fl_frametime = i2fl(Credits_frametime) / 1000.f;
if (keyd_pressed[KEY_LSHIFT]) {
Credit_position -= fl_frametime * CREDITS_SCROLL_RATE * 4.0f;
} else {
Credit_position -= fl_frametime * CREDITS_SCROLL_RATE;
}
if (Credit_position < Credit_stop_pos){
Credit_position = Credit_start_pos;
}
Credits_counter += fl_frametime;
while (Credits_counter >= CREDITS_ARTWORK_DISPLAY_TIME) {
Credits_counter -= CREDITS_ARTWORK_DISPLAY_TIME;
Credits_artwork_index = next;
}
gr_flip();
}
/**
* @brief This function is called to blit the next frame of an anim instance to the screen.
* This is normally called by the anim_render_all() function.
*
* @param instance Pointer to animation instance
* @param frametime Time elapsed since last call, in seconds
*/
int anim_show_next_frame(anim_instance *instance, float frametime)
{
int bitmap_id, bitmap_flags=0, new_frame_num, frame_diff=0, i, n_frames=0,frame_save;
float percent_through, time;
vertex image_vertex;
int aabitmap = 0;
int bpp = 16;
Assert( instance != NULL );
instance->time_elapsed += frametime;
// Advance to the next frame, if we determine enough time has elapsed.
if(instance->direction == ANIM_DIRECT_FORWARD)
n_frames = instance->stop_at - instance->start_at + 1;
else if(instance->direction == ANIM_DIRECT_REVERSE)
n_frames = instance->start_at - instance->stop_at + 1;
time = n_frames / i2fl(instance->parent->fps);
percent_through = instance->time_elapsed / time;
if(instance->direction == ANIM_DIRECT_FORWARD)
new_frame_num = instance->start_at - 1 + fl2i(percent_through * n_frames + 0.5f);
else
new_frame_num = instance->start_at - 1 - fl2i(percent_through * n_frames + 0.5f);
frame_save = instance->frame_num;
// If framerate independent, use the new_frame_num... unless instance->skip_frames is
// FALSE, then only advance a maximum of one frame (this is needed since some big animations
// should just play slower rather than taking the hit of decompressing multiple frames and
// creating an even greater slowdown
if (instance->framerate_independent) {
if(instance->direction == ANIM_DIRECT_FORWARD){
if ( new_frame_num > instance->last_frame_num) {
if ( instance->skip_frames )
instance->frame_num = new_frame_num;
else
instance->frame_num++;
}
} else if(instance->direction == ANIM_DIRECT_REVERSE){
if( new_frame_num < instance->last_frame_num) {
if ( instance->skip_frames )
instance->frame_num = new_frame_num;
else
instance->frame_num--;
}
}
}
else {
if(instance->direction == ANIM_DIRECT_FORWARD){
if ( new_frame_num > instance->last_frame_num) {
instance->frame_num++;
}
} else if(instance->direction == ANIM_DIRECT_REVERSE){
if ( new_frame_num < instance->last_frame_num) {
instance->frame_num--;
}
}
}
if(instance->direction == ANIM_DIRECT_FORWARD){
if ( instance->frame_num < instance->start_at ) {
instance->frame_num = instance->start_at;
}
} else if(instance->direction == ANIM_DIRECT_REVERSE){
if ( instance->frame_num > instance->start_at ) {
instance->frame_num = instance->start_at;
}
}
if ( instance->stop_now == TRUE ) {
return -1;
}
// If past the last frame, clamp to the last frame and then set the stop_now flag in the
// anim instance. The next iteration, the animation will stop.
if(instance->direction == ANIM_DIRECT_FORWARD){
if (instance->frame_num >= instance->stop_at ) {
if (instance->looped) { // looped animations
instance->frame_num = instance->stop_at;
instance->time_elapsed = 0.0f;
} else if(instance->ping_pong) { // pingponged animations
instance->frame_num = instance->stop_at;
anim_reverse_direction(instance);
} else { // one-shot animations
instance->frame_num = instance->stop_at;
instance->last_frame_num = instance->frame_num;
instance->stop_now = TRUE;
}
}
} else if(instance->direction == ANIM_DIRECT_REVERSE){
if (instance->frame_num <= instance->stop_at ) {
if (instance->looped) { // looped animations
instance->frame_num = instance->stop_at;
instance->time_elapsed = 0.0f;
} else if(instance->ping_pong) { // pingponged animations
instance->frame_num = instance->stop_at;
anim_reverse_direction(instance);
} else { // one-shot animations
instance->frame_num = instance->stop_at+1;
instance->last_frame_num = instance->frame_num;
instance->stop_now = TRUE;
}
}
}
if(instance->direction == ANIM_DIRECT_FORWARD){
if( instance->last_frame_num >= instance->start_at ) {
frame_diff = instance->frame_num - instance->last_frame_num;
} else {
frame_diff = 1;
}
} else if(instance->direction == ANIM_DIRECT_REVERSE){
if( instance->last_frame_num <= instance->start_at ) {
frame_diff = instance->last_frame_num - instance->frame_num;
} else {
frame_diff = 1;
}
}
Assert(frame_diff >= 0);
Assert( instance->frame_num >= 0 && instance->frame_num < instance->parent->total_frames );
// if the anim is paused, ignore all the above changes and still display this frame
if(instance->paused || Anim_paused){
instance->frame_num = frame_save;
instance->time_elapsed -= frametime;
frame_diff = 0;
}
if (instance->parent->flags & ANF_XPARENT){
bitmap_flags = 0;
}
bpp = 16;
if(instance->aa_color != NULL){
bitmap_flags |= BMP_AABITMAP;
aabitmap = 1;
bpp = 8;
}
if ( frame_diff > 0 ) {
instance->last_frame_num = instance->frame_num;
t1 = timer_get_fixed_seconds();
for ( i = 0; i < frame_diff; i++ ) {
anim_check_for_palette_change(instance);
// if we're playing backwards, every frame must be a keyframe and we set the data ptr here
if(instance->direction == ANIM_DIRECT_REVERSE){
if ( anim_instance_is_streamed(instance) ) {
instance->file_offset = instance->parent->file_offset + instance->parent->keys[instance->frame_num-1].offset;
} else {
instance->data = instance->parent->data + instance->parent->keys[instance->frame_num-1].offset;
}
}
ubyte *temp = NULL;
int temp_file_offset = -1;
// if we're using bitmap polys
BM_SELECT_TEX_FORMAT();
if ( anim_instance_is_streamed(instance) ) {
if ( instance->xlate_pal ){
temp_file_offset = unpack_frame_from_file(instance, instance->frame, instance->parent->width*instance->parent->height, instance->parent->palette_translation, aabitmap, bpp);
} else {
temp_file_offset = unpack_frame_from_file(instance, instance->frame, instance->parent->width*instance->parent->height, NULL, aabitmap, bpp);
}
} else {
if ( instance->xlate_pal ){
temp = unpack_frame(instance, instance->data, instance->frame, instance->parent->width*instance->parent->height, instance->parent->palette_translation, aabitmap, bpp);
} else {
temp = unpack_frame(instance, instance->data, instance->frame, instance->parent->width*instance->parent->height, NULL, aabitmap, bpp);
}
}
// always go back to screen format
BM_SELECT_SCREEN_FORMAT();
// see if we had an error during decode (corrupted anim stream)
if ( (temp == NULL) && (temp_file_offset < 0) ) {
mprintf(("ANI: Fatal ERROR at frame %i!! Aborting playback of \"%s\"...\n", instance->frame_num, instance->parent->name));
// return -1 to end all playing of this anim instanc
return -1;
}
if(instance->direction == ANIM_DIRECT_FORWARD){
if ( anim_instance_is_streamed(instance) ) {
instance->file_offset = temp_file_offset;
} else {
instance->data = temp;
}
}
}
t2 = timer_get_fixed_seconds();
}
else {
t2=t1=0;
}
// this only happens when the anim is being looped, we need to reset the last_frame_num
if ( (instance->time_elapsed == 0) && (instance->looped) ) {
instance->last_frame_num = -1;
instance->frame_num = -1;
instance->data = instance->parent->data;
instance->file_offset = instance->parent->file_offset;
instance->loop_count++;
}
t1 = timer_get_fixed_seconds();
if ( frame_diff == 0 && instance->last_bitmap != -1 ) {
bitmap_id = instance->last_bitmap;
}
else {
if ( instance->last_bitmap != -1 ){
bm_release(instance->last_bitmap);
}
bitmap_id = bm_create(bpp, instance->parent->width, instance->parent->height, instance->frame, bitmap_flags);
}
if ( bitmap_id == -1 ) {
// anim has finsished playing, free the instance frame data
anim_release_render_instance(instance);
return -1;
// NOTE: there is no need to free the instance, since it was pre-allocated as
// part of the anim_free_list
}
else {
gr_set_bitmap(bitmap_id);
// determine x,y to display the bitmap at
if ( instance->world_pos == NULL ) {
int old_max_w_unscaled = gr_screen.max_w_unscaled;
int old_max_h_unscaled = gr_screen.max_h_unscaled;
int old_max_w_unscaled_zoomed = gr_screen.max_w_unscaled_zoomed;
int old_max_h_unscaled_zoomed = gr_screen.max_h_unscaled_zoomed;
gr_set_screen_scale(instance->base_w, instance->base_h);
gr_set_clip(0, 0, instance->base_w, instance->base_h, GR_RESIZE_MENU);
if ( instance->aa_color == NULL ) {
gr_bitmap(instance->x, instance->y, GR_RESIZE_MENU_NO_OFFSET);
}
else {
gr_set_color_fast( (color*)instance->aa_color );
gr_aabitmap(instance->x, instance->y, GR_RESIZE_MENU_NO_OFFSET);
}
gr_set_screen_scale(old_max_w_unscaled, old_max_h_unscaled, old_max_w_unscaled_zoomed, old_max_h_unscaled_zoomed);
gr_reset_clip();
}
else {
g3_rotate_vertex(&image_vertex,instance->world_pos);
Assert(instance->radius != 0.0f);
//g3_draw_bitmap(&image_vertex, 0, instance->radius*1.5f, TMAP_FLAG_TEXTURED | TMAP_HTL_2D);
material mat_params;
material_set_unlit(&mat_params, bitmap_id, 1.0f, false, false);
g3_render_rect_screen_aligned_2d(&mat_params, &image_vertex, 0, instance->radius*1.5f);
}
instance->last_bitmap = bitmap_id;
}
t2 = timer_get_fixed_seconds();
return 0;
}
void cmd_brief_init(int team)
{
common_music_init(SCORE_BRIEFING);
int i;
ui_button_info *b;
Cmd_brief_inited = 0;
Cur_cmd_brief = &Cmd_briefs[team];
// Goober5000 - replace any variables (probably persistent variables) with their values
for (i = 0; i < Cur_cmd_brief->num_stages; i++)
sexp_replace_variable_names_with_values(Cur_cmd_brief->stage[i].text);
if (Cur_cmd_brief->num_stages <= 0)
return;
gr_reset_clip();
gr_clear();
Mouse_hidden++;
gr_flip();
Mouse_hidden--;
// first determine which layout to use
Uses_scroll_buttons = 1; // assume true
Cmd_brief_background_bitmap = bm_load(Cmd_brief_fname[Uses_scroll_buttons][gr_screen.res]); // try to load extra one first
if (Cmd_brief_background_bitmap < 0) // failed to load
{
Uses_scroll_buttons = 0; // nope, sorry
Cmd_brief_background_bitmap = bm_load(Cmd_brief_fname[Uses_scroll_buttons][gr_screen.res]);
}
Ui_window.create(0, 0, gr_screen.max_w_unscaled, gr_screen.max_h_unscaled, 0);
Ui_window.set_mask_bmap(Cmd_brief_mask[Uses_scroll_buttons][gr_screen.res]);
for (i=0; i<NUM_CMD_BRIEF_BUTTONS; i++) {
b = &Cmd_brief_buttons[gr_screen.res][i];
b->button.create(&Ui_window, "", b->x, b->y, 60, 30, 0, 1);
// set up callback for when a mouse first goes over a button
b->button.set_highlight_action(common_play_highlight_sound);
b->button.set_bmaps(b->filename);
b->button.link_hotspot(b->hotspot);
}
// add text
for(i=0; i<CMD_BRIEF_NUM_TEXT; i++){
Ui_window.add_XSTR(&Cmd_brief_text[gr_screen.res][i]);
}
// set up readyrooms for buttons so we draw the correct animation frame when a key is pressed
Cmd_brief_buttons[gr_screen.res][CMD_BRIEF_BUTTON_FIRST_STAGE].button.set_hotkey(KEY_SHIFTED | KEY_LEFT);
Cmd_brief_buttons[gr_screen.res][CMD_BRIEF_BUTTON_LAST_STAGE].button.set_hotkey(KEY_SHIFTED | KEY_RIGHT);
Cmd_brief_buttons[gr_screen.res][CMD_BRIEF_BUTTON_PREV_STAGE].button.set_hotkey(KEY_LEFT);
Cmd_brief_buttons[gr_screen.res][CMD_BRIEF_BUTTON_NEXT_STAGE].button.set_hotkey(KEY_RIGHT);
Cmd_brief_buttons[gr_screen.res][CMD_BRIEF_BUTTON_ACCEPT].button.set_hotkey(KEY_CTRLED | KEY_ENTER);
Cmd_brief_buttons[gr_screen.res][CMD_BRIEF_BUTTON_HELP].button.set_hotkey(KEY_F1);
Cmd_brief_buttons[gr_screen.res][CMD_BRIEF_BUTTON_OPTIONS].button.set_hotkey(KEY_F2);
// extra - Goober5000
if (Uses_scroll_buttons)
{
Cmd_brief_buttons[gr_screen.res][CMD_BRIEF_BUTTON_SCROLL_UP].button.set_hotkey(KEY_UP);
Cmd_brief_buttons[gr_screen.res][CMD_BRIEF_BUTTON_SCROLL_DOWN].button.set_hotkey(KEY_DOWN);
}
// load in help overlay bitmap
help_overlay_load(CMD_BRIEF_OVERLAY);
help_overlay_set_state(CMD_BRIEF_OVERLAY,0);
for (i=0; i<Cur_cmd_brief->num_stages; i++)
cmd_brief_ani_wave_init(i);
cmd_brief_init_voice();
cmd_brief_new_stage(0);
Cmd_brief_paused = 0;
Cmd_brief_inited = 1;
}
// Play one movie
bool movie_play(char *name)
{
// mark the movie as viewable to the player when in a campaign
// do this before anything else so that we're sure the movie is available
// to the player even if it's not going to play right now
if (Game_mode & GM_CAMPAIGN_MODE) {
cutscene_mark_viewable(name);
}
extern int Mouse_hidden;
extern int Is_standalone;
if (Cmdline_nomovies || Is_standalone)
return false;
char full_name[MAX_PATH];
int rc = 0;
memset(full_name, 0, sizeof(full_name));
rc = movie_find(name, full_name);
if (rc == MOVIE_NONE) {
strcpy_s(full_name, name);
char *p = strrchr(full_name, '.');
if ( p ) *p = 0;
mprintf(("Movie Error: Unable to open '%s' movie in any supported format.\n", full_name));
return false;
}
// clear the screen and hide the mouse cursor
Mouse_hidden++;
gr_reset_clip();
gr_set_color(255, 255, 255);
gr_set_clear_color(0, 0, 0);
gr_zbuffer_clear(0);
// clear first buffer
gr_clear();
gr_flip();
// clear second buffer (may not be one, but that's ok)
gr_clear();
gr_flip();
// clear third buffer (may not be one, but that's ok)
gr_clear();
if (rc == MOVIE_OGG) {
THEORAFILE *movie_ogg = theora_open(name);
if (movie_ogg) {
// start playing ...
theora_play(movie_ogg);
// ... done playing, close the movie
theora_close(movie_ogg);
} else {
// uh-oh, movie is invalid... Abory, Retry, Fail?
mprintf(("MOVIE ERROR: Found invalid movie! (%s)\n", name));
Mouse_hidden--; // show the mouse cursor!
return false;
}
} else if (rc == MOVIE_MVE) {
MVESTREAM *movie_mve = mve_open(name);
if (movie_mve) {
// start playing ...
mve_init(movie_mve);
mve_play(movie_mve);
// ... done playing, close the movie
mve_shutdown();
mve_close(movie_mve);
} else {
// uh-oh, movie is invalid... Abory, Retry, Fail?
mprintf(("MOVIE ERROR: Found invalid movie! (%s)\n", name));
Mouse_hidden--; // show the mouse cursor!
return false;
}
}
// show the mouse cursor again
Mouse_hidden--;
return true;
}
// -----------------------------------------------------------------------------
void barracks_do_frame(float frametime)
{
int k = Ui_window.process();
if ( k > 0 ) {
if ( help_overlay_active(Barracks_overlay_id) ) {
help_overlay_set_state(Barracks_overlay_id,gr_screen.res,0);
k = 0;
}
}
// pilot that mouse is over
int prospective_pilot = -1;
int i;
// Entering pilot callsign
if (Barracks_callsign_enter_mode) {
// set focus to inputbox
Inputbox.set_focus();
switch (k) {
case KEY_ESC:
// cancel create pilot
Num_pilots--;
for (i=0; i<Num_pilots; i++) {
strcpy(Pilots[i], Pilots[i + 1]);
Pilot_ranks[i] = Pilot_ranks[i + 1];
}
barracks_set_callsign_enter_mode(false);
break;
case KEY_ENTER:
barracks_accept_new_pilot_callsign();
break;
}
} else {
// not entering pilot callsign
switch (k) {
case KEY_ENTER:
if (barracks_new_pilot_selected()) {
gamesnd_play_iface(SND_GENERAL_FAIL);
} else {
gamesnd_play_iface(SND_USER_SELECT);
}
break;
case KEY_ESC: // cancel
if (!help_overlay_active(Barracks_overlay_id)) {
if (Num_pilots && !barracks_pilot_accepted()) {
gameseq_post_event(GS_EVENT_MAIN_MENU);
} else {
gamesnd_play_iface(SND_GENERAL_FAIL);
}
} else {
// kill the overlay
help_overlay_set_state(Barracks_overlay_id,gr_screen.res,0);
}
break;
case KEY_TAB: // switch mode (simgle/multi)
if ( Networking_disabled ) {
game_feature_disabled_popup();
break;
}
if (Player_sel_mode == PLAYER_SELECT_MODE_SINGLE) {
Cur_pilot->flags |= PLAYER_FLAGS_IS_MULTI;
Pilot.save_player(Cur_pilot);
barracks_init_player_stuff(PLAYER_SELECT_MODE_MULTI);
} else {
// make sure we don't carry over the multi flag
Cur_pilot->flags &= ~PLAYER_FLAGS_IS_MULTI;
Pilot.save_player(Cur_pilot);
barracks_init_player_stuff(PLAYER_SELECT_MODE_SINGLE);
}
gamesnd_play_iface(SND_USER_SELECT);
break;
case KEY_F1: // show help overlay
gamesnd_play_iface(SND_HELP_PRESSED);
break;
case KEY_F2: // goto options screen
gamesnd_play_iface(SND_SWITCH_SCREENS);
gameseq_post_event(GS_EVENT_OPTIONS_MENU);
break;
} // end switch
// process buttons
for (i=0; i<BARRACKS_NUM_BUTTONS; i++) {
if (Buttons[gr_screen.res][i].button.pressed()) {
barracks_button_pressed(i);
}
}
// if mouse is over a pilot, find index into Pilots array
if (List_region.is_mouse_on()) {
int y;
List_region.get_mouse_pos(NULL, &y);
int pilot_index = List_scroll_offset + (y / gr_get_font_height());
if ((pilot_index >= 0) && (pilot_index < Num_pilots)) {
prospective_pilot = pilot_index;
}
}
// if mouse clicked in list region, find index into Pilots array
if (List_region.pressed()) {
if (prospective_pilot != -1) {
Selected_line = prospective_pilot;
gamesnd_play_iface(SND_USER_SELECT);
}
}
}
// check mouse over help
if (mouse_down(MOUSE_LEFT_BUTTON)) {
help_overlay_set_state(Barracks_overlay_id, gr_screen.res, 0);
}
// do pilot pic stuff
if ((Pic_number >= 0) && (Pic_number < Num_pilot_images)) {
if (Pilot_images[Pic_number] == BARRACKS_IMAGE_NOT_LOADED) { // haven't tried loading it yet
Pilot_images[Pic_number] = bm_load(Pilot_image_names[Pic_number]);
if (Pilot_images[Pic_number] >= 0) {
int w, h;
bm_get_info(Pilot_images[Pic_number], &w, &h, NULL);
// check for invalid pilot pic file
if ((w != PLAYER_PILOT_PIC_W) || (h != PLAYER_PILOT_PIC_H)) {
bm_release(Pilot_images[Pic_number]);
Pilot_images[Pic_number] = -1;
}
}
}
} else {
Pic_number = -1;
}
// do squad pic stuff
if ((Pic_squad_number >= 0) && (Pic_squad_number < Num_pilot_squad_images)) {
if (Pilot_squad_images[Pic_squad_number] == BARRACKS_IMAGE_NOT_LOADED) { // haven't tried loading it yet
Pilot_squad_images[Pic_squad_number] = bm_load_duplicate(Pilot_squad_image_names[Pic_squad_number]);
if (Pilot_squad_images[Pic_squad_number] >= 0) {
int w, h;
bm_get_info(Pilot_squad_images[Pic_squad_number], &w, &h, NULL);
// check for invalid pilot pic file
if ((w != PLAYER_SQUAD_PIC_W) || (h != PLAYER_SQUAD_PIC_H)) {
bm_release(Pilot_squad_images[Pic_squad_number]);
Pilot_squad_images[Pic_squad_number] = -1;
}
}
}
} else {
Pic_squad_number = -1;
}
// draw the background, etc
gr_reset_clip();
GR_MAYBE_CLEAR_RES(Background_bitmap);
if (Background_bitmap >= 0) {
gr_set_bitmap(Background_bitmap);
gr_bitmap(0, 0, GR_RESIZE_MENU);
}
// draw pilot image and clean up afterwards
barracks_draw_pilot_pic();
barracks_draw_squad_pic();
// draw the window
Ui_window.draw();
// light up the correct mode button (single or multi)
if (Player_sel_mode == PLAYER_SELECT_MODE_SINGLE) {
Buttons[gr_screen.res][B_PILOT_SINGLE_MODE_BUTTON].button.draw_forced(2);
} else {
Buttons[gr_screen.res][B_PILOT_MULTI_MODE_BUTTON].button.draw_forced(2);
}
// write out pilot call signs
barracks_display_pilot_callsigns(prospective_pilot);
// write out current pilot stats
barracks_display_pilot_stats();
// blit help overlay if active
help_overlay_maybe_blit(Barracks_overlay_id, gr_screen.res);
// flip the page
gr_flip();
}
void techroom_ships_render(float frametime)
{
// render all the common stuff
tech_common_render();
if(Cur_entry_index == -1)
return;
// now render the trackball ship, which is unique to the ships tab
float rev_rate = REVOLUTION_RATE;
angles rot_angles, view_angles;
int z, i, j;
ship_info *sip = &Ship_info[Cur_entry_index];
model_render_params render_info;
if (sip->uses_team_colors) {
render_info.set_team_color(sip->default_team_name, "none", 0, 0);
}
// get correct revolution rate
z = sip->flags;
if (z & SIF_BIG_SHIP) {
rev_rate *= 1.7f;
}
if (z & SIF_HUGE_SHIP) {
rev_rate *= 3.0f;
}
// rotate the ship as much as required for this frame
Techroom_ship_rot += PI2 * frametime / rev_rate;
while (Techroom_ship_rot > PI2){
Techroom_ship_rot -= PI2;
}
// reorient ship
if (Trackball_active) {
int dx, dy;
matrix mat1, mat2;
if (Trackball_active) {
mouse_get_delta(&dx, &dy);
if (dx || dy) {
vm_trackball(-dx, -dy, &mat1);
vm_matrix_x_matrix(&mat2, &mat1, &Techroom_ship_orient);
Techroom_ship_orient = mat2;
}
}
} else {
// setup stuff needed to render the ship
view_angles.p = -0.6f;
view_angles.b = 0.0f;
view_angles.h = 0.0f;
vm_angles_2_matrix(&Techroom_ship_orient, &view_angles);
rot_angles.p = 0.0f;
rot_angles.b = 0.0f;
rot_angles.h = Techroom_ship_rot;
vm_rotate_matrix_by_angles(&Techroom_ship_orient, &rot_angles);
}
gr_set_clip(Tech_ship_display_coords[gr_screen.res][SHIP_X_COORD], Tech_ship_display_coords[gr_screen.res][SHIP_Y_COORD], Tech_ship_display_coords[gr_screen.res][SHIP_W_COORD], Tech_ship_display_coords[gr_screen.res][SHIP_H_COORD], GR_RESIZE_MENU);
// render the ship
g3_start_frame(1);
g3_set_view_matrix(&sip->closeup_pos, &vmd_identity_matrix, sip->closeup_zoom * 1.3f);
// lighting for techroom
light_reset();
vec3d light_dir = vmd_zero_vector;
light_dir.xyz.y = 1.0f;
light_dir.xyz.x = 0.0000001f;
light_add_directional(&light_dir, 0.85f, 1.0f, 1.0f, 1.0f);
light_rotate_all();
// lighting for techroom
Glowpoint_use_depth_buffer = false;
model_clear_instance(Techroom_ship_modelnum);
render_info.set_detail_level_lock(0);
polymodel *pm = model_get(Techroom_ship_modelnum);
for (i = 0; i < sip->n_subsystems; i++) {
model_subsystem *msp = &sip->subsystems[i];
if (msp->type == SUBSYSTEM_TURRET) {
float p = 0.0f;
float h = 0.0f;
for (j = 0; j < msp->n_triggers; j++) {
// special case for turrets
p = msp->triggers[j].angle.xyz.x;
h = msp->triggers[j].angle.xyz.y;
}
if ( msp->subobj_num >= 0 ) {
model_set_instance_techroom(Techroom_ship_modelnum, msp->subobj_num, 0.0f, h );
}
if ( (msp->subobj_num != msp->turret_gun_sobj) && (msp->turret_gun_sobj >= 0) ) {
model_set_instance_techroom(Techroom_ship_modelnum, msp->turret_gun_sobj, p, 0.0f );
}
}
}
if(Cmdline_shadow_quality)
{
gr_reset_clip();
shadows_start_render(&Eye_matrix, &Eye_position, Proj_fov, gr_screen.clip_aspect, -sip->closeup_pos.xyz.z + pm->rad, -sip->closeup_pos.xyz.z + pm->rad + 200.0f, -sip->closeup_pos.xyz.z + pm->rad + 2000.0f, -sip->closeup_pos.xyz.z + pm->rad + 10000.0f);
render_info.set_flags(MR_NO_TEXTURING | MR_NO_LIGHTING | MR_AUTOCENTER);
model_render_immediate(&render_info, Techroom_ship_modelnum, &Techroom_ship_orient, &vmd_zero_vector);
shadows_end_render();
gr_set_clip(Tech_ship_display_coords[gr_screen.res][SHIP_X_COORD], Tech_ship_display_coords[gr_screen.res][SHIP_Y_COORD], Tech_ship_display_coords[gr_screen.res][SHIP_W_COORD], Tech_ship_display_coords[gr_screen.res][SHIP_H_COORD], GR_RESIZE_MENU);
}
if (!Cmdline_nohtl) {
gr_set_proj_matrix(Proj_fov, gr_screen.clip_aspect, Min_draw_distance, Max_draw_distance);
gr_set_view_matrix(&Eye_position, &Eye_matrix);
}
uint render_flags = MR_AUTOCENTER;
if(sip->flags2 & SIF2_NO_LIGHTING)
render_flags |= MR_NO_LIGHTING;
render_info.set_flags(render_flags);
model_render_immediate(&render_info, Techroom_ship_modelnum, &Techroom_ship_orient, &vmd_zero_vector);
Glowpoint_use_depth_buffer = true;
batch_render_all();
if (!Cmdline_nohtl)
{
gr_end_view_matrix();
gr_end_proj_matrix();
}
g3_end_frame();
gr_reset_clip();
}
void pilot_manage_do(void)
{
int k = Ui_window.process();
int i;
if ( k > 0 ) {
// put back in when overlay stuff is fixed
// if ( help_overlay_active(PILOT_MANAGE_OVERLAY) ) {
// help_overlay_set_state(PILOT_MANAGE_OVERLAY,0);
// k = 0;
// }
}
switch (k)
{
case KEY_ESC: // cancel only if not trying to enter a pilot name
if (!pilot_manage_callsign_enter_mode)
gameseq_post_event(GS_EVENT_BARRACKS_MENU);//GS_EVENT_PREVIOUS_STATE
break;
} // end switch
int prospective_pilot = -1;
// Entering pilot callsign
if (pilot_manage_callsign_enter_mode) {
// set focus to inputbox
Inputbox.set_focus();
switch (k) {
case KEY_ESC:
// cancel create pilot
Num_pilots--;
for (i=0; i<Num_pilots; i++) {
strcpy(Pilots[i], Pilots[i + 1]);
Pilot_ranks[i] = Pilot_ranks[i + 1];
}
pilot_manage_set_callsign_enter_mode(false);
break;
case KEY_ENTER:
pilot_manage_accept_new_pilot_callsign();
break;
}
}
// process buttons
for (i=0; i<PM_NUM_BUTTONS; i++) {
if (Buttons[gr_screen.res][i].button.pressed()) {
pilot_manage_button_pressed(i);
}
}
// pilot that mouse is over
// if mouse is over a pilot, find index into Pilots array
if (List_region.is_mouse_on()) {
int y;
List_region.get_mouse_pos(NULL, &y);
int pilot_index = List_scroll_offset + (y / gr_get_font_height());
if ((pilot_index >= 0) && (pilot_index < Num_pilots)) {
prospective_pilot = pilot_index;
}
}
// if mouse clicked in list region, find index into Pilots array
if (List_region.pressed()) {
if (prospective_pilot != -1) {
Selected_line = prospective_pilot;
gamesnd_play_iface(SND_USER_SELECT);
}
}
gr_reset_clip();
GR_MAYBE_CLEAR_RES(Background_bitmap);
if (Background_bitmap >= 0) {
gr_set_bitmap(Background_bitmap);
gr_bitmap(0, 0);
}
Ui_window.draw();
//light up the correct mode button (single or multi)
if (Player_sel_mode == PLAYER_SELECT_MODE_SINGLE) {
Buttons[gr_screen.res][PM_SINGLE_MODE_BUTTON].button.draw_forced(2);
} else {
Buttons[gr_screen.res][PM_MULTI_MODE_BUTTON].button.draw_forced(2);
}
pilot_manage_display_pilot_callsigns(prospective_pilot);
pilot_manage_force_button_frame();
pilot_manage_maybe_show_button_text();
// needs to be fixed help_overlay_maybe_blit(PILOT_MANAGE_OVERLAY);
gr_flip();
}
void freespace_menu_background()
{
gr_reset_clip();
gr_clear();
}
void credits_do_frame(float frametime)
{
GR_DEBUG_SCOPE("Credits do frame");
int i, k, next, percent, bm1, bm2;
int bx1, by1, bw1, bh1;
int bx2, by2, bw2, bh2;
// Use this id to trigger the start of music playing on the credits screen
if ( timestamp_elapsed(Credits_music_begin_timestamp) ) {
Credits_music_begin_timestamp = 0;
credits_start_music();
}
k = Ui_window.process();
switch (k) {
case KEY_ESC:
gameseq_post_event(GS_EVENT_MAIN_MENU);
key_flush();
break;
case KEY_CTRLED | KEY_UP:
case KEY_SHIFTED | KEY_TAB:
if ( !(Player->flags & PLAYER_FLAGS_IS_MULTI) ) {
credits_screen_button_pressed(CUTSCENES_BUTTON);
break;
}
// else, react like tab key.
case KEY_CTRLED | KEY_DOWN:
case KEY_TAB:
credits_screen_button_pressed(TECH_DATABASE_BUTTON);
break;
default:
break;
} // end switch
for (i=0; i<NUM_BUTTONS; i++){
if (Buttons[i][gr_screen.res].button.pressed()){
if (credits_screen_button_pressed(i)){
return;
}
}
}
gr_reset_clip();
GR_MAYBE_CLEAR_RES(Background_bitmap);
if (Background_bitmap >= 0) {
gr_set_bitmap(Background_bitmap);
gr_bitmap(0, 0, GR_RESIZE_MENU);
}
percent = (int) (100.0f - (Credits_artwork_display_time - Credits_counter) * 100.0f / Credits_artwork_fade_time);
if (percent < 0){
percent = 0;
}
next = Credits_artwork_index + 1;
if (next >= Credits_num_images){
next = 0;
}
if (Credits_bmps[Credits_artwork_index] < 0) {
char buf[40];
if (gr_screen.res == GR_1024) {
sprintf(buf, NOX("2_CrIm%.2d"), Credits_artwork_index);
} else {
sprintf(buf, NOX("CrIm%.2d"), Credits_artwork_index);
}
Credits_bmps[Credits_artwork_index] = bm_load(buf);
}
if (Credits_bmps[next] < 0) {
char buf[40];
if (gr_screen.res == GR_1024) {
sprintf(buf, NOX("2_CrIm%.2d"), next);
} else {
sprintf(buf, NOX("CrIm%.2d"), next);
}
Credits_bmps[next] = bm_load(buf);
}
bm1 = Credits_bmps[Credits_artwork_index];
bm2 = Credits_bmps[next];
if((bm1 != -1) && (bm2 != -1)){
GR_DEBUG_SCOPE("Render credits bitmap");
Assert(percent >= 0 && percent <= 100);
// get width and height
bm_get_info(bm1, &bw1, &bh1, NULL, NULL, NULL);
bm_get_info(bm2, &bw2, &bh2, NULL, NULL, NULL);
// determine where to draw the coords
bx1 = Credits_image_coords[gr_screen.res][CREDITS_X_COORD] + ((Credits_image_coords[gr_screen.res][CREDITS_W_COORD] - bw1)/2);
by1 = Credits_image_coords[gr_screen.res][CREDITS_Y_COORD] + ((Credits_image_coords[gr_screen.res][CREDITS_H_COORD] - bh1)/2);
bx2 = Credits_image_coords[gr_screen.res][CREDITS_X_COORD] + ((Credits_image_coords[gr_screen.res][CREDITS_W_COORD] - bw2)/2);
by2 = Credits_image_coords[gr_screen.res][CREDITS_Y_COORD] + ((Credits_image_coords[gr_screen.res][CREDITS_H_COORD] - bh2)/2);
auto alpha = (float)percent / 100.0f;
gr_set_bitmap(bm1, GR_ALPHABLEND_FILTER, GR_BITBLT_MODE_NORMAL, 1.0f - alpha);
gr_bitmap(bx1, by1, GR_RESIZE_MENU);
gr_set_bitmap(bm2, GR_ALPHABLEND_FILTER, GR_BITBLT_MODE_NORMAL, alpha);
gr_bitmap(bx2, by2, GR_RESIZE_MENU);
}
Ui_window.draw();
for (i=TECH_DATABASE_BUTTON; i<=CREDITS_BUTTON; i++){
if (Buttons[i][gr_screen.res].button.button_down()){
break;
}
}
if (i > CREDITS_BUTTON){
Buttons[CREDITS_BUTTON][gr_screen.res].button.draw_forced(2);
}
gr_set_clip(Credits_text_coords[gr_screen.res][CREDITS_X_COORD], Credits_text_coords[gr_screen.res][CREDITS_Y_COORD], Credits_text_coords[gr_screen.res][CREDITS_W_COORD], Credits_text_coords[gr_screen.res][CREDITS_H_COORD], GR_RESIZE_MENU);
font::set_font(font::FONT1);
gr_set_color_fast(&Color_normal);
int y_offset = 0;
for (SCP_vector<SCP_string>::iterator iter = Credit_text_parts.begin(); iter != Credit_text_parts.end(); ++iter)
{
size_t currentPos = 0;
size_t lineEnd;
do
{
int height;
int width;
lineEnd = iter->find('\n', currentPos);
auto length = lineEnd - currentPos;
if (lineEnd == SCP_string::npos)
{
length = std::numeric_limits<size_t>::max();
}
gr_get_string_size(&width, &height, iter->c_str() + currentPos, static_cast<int>(length));
// Check if the text part is actually visible
if (Credit_position + y_offset + height > 0.0f)
{
float x = static_cast<float>((gr_screen.clip_width_unscaled - width) / 2);
gr_string(x, Credit_position + y_offset, iter->c_str() + currentPos, GR_RESIZE_MENU, static_cast<int>(length));
}
y_offset += height;
currentPos = lineEnd + 1;
} while (lineEnd < iter->length() && lineEnd != SCP_string::npos);
}
int temp_time;
temp_time = timer_get_milliseconds();
Credits_frametime = temp_time - Credits_last_time;
Credits_last_time = temp_time;
timestamp_inc(i2f(Credits_frametime) / TIMESTAMP_FREQUENCY);
float fl_frametime = i2fl(Credits_frametime) / 1000.f;
if (keyd_pressed[KEY_LSHIFT]) {
Credit_position -= fl_frametime * Credits_scroll_rate * 4.0f;
} else {
Credit_position -= fl_frametime * Credits_scroll_rate;
}
if (Credit_position < Credit_stop_pos){
Credit_position = Credit_start_pos;
}
Credits_counter += fl_frametime;
while (Credits_counter >= Credits_artwork_display_time) {
Credits_counter -= Credits_artwork_display_time;
Credits_artwork_index = next;
}
gr_flip();
}
void UI_LISTBOX::draw()
{
int i, x1, y1, stop;
int w1, h1;
UI_GADGET::draw();
gr_set_font(my_wnd->f_id);
if (uses_bmaps) {
if (disabled_flag) {
if ( bmap_ids[LBOX_DISABLED] >= 0 ) {
gr_set_bitmap(bmap_ids[LBOX_DISABLED]);
gr_bitmap(x, y);
}
} else {
if ( bmap_ids[LBOX_NORMAL] >= 0 ) {
gr_set_bitmap(bmap_ids[LBOX_NORMAL]);
gr_bitmap(x, y);
}
}
} else {
gr_set_color_fast(&CBLACK);
gr_set_clip( x, y, w, h );
ui_rect( 0, 0, w-1, h-1 );
gr_reset_clip();
if (has_scrollbar) {
ui_draw_sunken_border( x-2, y-2, x+w+scrollbar.w+4, y+h+1 );
} else {
ui_draw_sunken_border( x-2, y-2, x+w+4, y+h+1 );
}
}
stop = first_item+num_items_displayed;
if (stop>num_items) stop = num_items;
x1 = y1 = 0;
gr_set_clip( x, y, w, h );
for ( i=first_item; i<stop; i++ ) {
gr_get_string_size( &w1, &h1,list[i] );
if (check_list)
w1 += 18;
if (i !=current_item) {
/*
if ((current_item == -1) && (my_wnd->selected_gadget == this ) && (i == first_item) ) {
if ( !uses_bmaps ) {
gr_set_color_fast( &CBLACK );
gr_rect( x1, y1, w1+2, h1 );
}
current_item = first_item;
gr_set_color_fast( &CBRIGHT_GREEN );
} else {
if ( !uses_bmaps ) {
gr_set_color_fast( &CBLACK );
gr_rect( x1, y1, w1+2, h1 );
}
gr_set_color_fast( &CWHITE );
}
*/
if (!uses_bmaps) {
gr_set_color_fast( &CBLACK );
gr_rect( x1, y1, w1+2, h1 );
}
gr_set_color_fast(&CWHITE);
} else {
if (my_wnd->selected_gadget == this) {
gr_set_color_fast( &CGRAY );
gr_rect( x1, y1, w1+2, h1 );
gr_set_color_fast( &CBRIGHT_GREEN );
} else {
gr_set_color_fast( &CGRAY );
gr_rect( x1, y1, w1+2, h1 );
gr_set_color_fast( &CBLACK );
}
}
if ( check_list ) {
if ( check_list[i] ) {
gr_string( x1+2, y1, "X" );
}
gr_string( x1+16, y1, list[i] );
} else
gr_string( x1+2, y1, list[i] );
if (i==current_item)
gr_set_color_fast( &CGRAY );
else
gr_set_color_fast( &CBLACK );
if ( !uses_bmaps ) {
ui_rect( x1+w1+2, y1, w-1, y1+h1-1 );
ui_rect( x1, y1, x1+1, y1+h1-1 );
}
y1 += h1;
}
if (stop < num_items_displayed-1 && !uses_bmaps) {
gr_set_color_fast(&CBLACK);
ui_rect( x1, y1, w-1, h-1 );
}
}
// Render button. How it draws exactly depends on it's current state.
void UI_BUTTON::draw()
{
int offset, frame_num = -1;
if (uses_bmaps) {
gr_reset_clip();
// if button is down, draw it that way
if (button_down()) {
if (bmap_ids[B_PRESSED] >= 0){
frame_num = B_PRESSED;
}
// otherwise if button is disabled, draw it that way
} else if (disabled_flag) {
if (bmap_ids[B_DISABLED] >= 0){
frame_num = B_DISABLED;
}
// otherwise, if button is highlighted (mouse is over it, but mouse buttons not down) draw it that way
} else if (m_flags & BF_HIGHLIGHTED) {
if (bmap_ids[B_HIGHLIGHT] >= 0){
frame_num = B_HIGHLIGHT;
}
// otherwise, just draw it normally
} else {
if (bmap_ids[B_NORMAL] >= 0){
frame_num = B_NORMAL;
}
}
if (frame_num >= 0) {
gr_set_bitmap(bmap_ids[frame_num]);
gr_bitmap(x, y);
}
} else {
gr_set_font(my_wnd->f_id);
gr_set_clip( x, y, w, h );
// draw the button's box
if (button_down()) {
ui_draw_box_in( 0, 0, w-1, h-1 );
offset = 1;
} else {
ui_draw_box_out( 0, 0, w-1, h-1 );
offset = 0;
}
// now draw the button's text
if (disabled_flag){
gr_set_color_fast(&CDARK_GRAY);
} else if (my_wnd->selected_gadget == this){
gr_set_color_fast(&CBRIGHT_GREEN);
} else {
gr_set_color_fast(&CBLACK);
}
if (text){
ui_string_centered( Middle(w) + offset, Middle(h) + offset, text );
}
gr_reset_clip();
}
}
void mht_do()
{
int k = Mht_window.process();
// need to ensure ambient is playing, since it may be stopped by a playing movie
main_hall_start_ambient();
// process any keypresses
switch(k){
case KEY_ESC :
mht_exit_game();
break;
case KEY_B:
gameseq_post_event( GS_EVENT_BARRACKS_MENU );
break;
case KEY_G:
if(Player->flags & PLAYER_FLAGS_IS_MULTI){
break;
}
if (Num_recent_missions > 0) {
strcpy_s( Game_current_mission_filename, Recent_missions[0] );
} else {
mission_load_up_campaign();
strcpy_s( Game_current_mission_filename, Campaign.missions[0].name );
}
Campaign.current_mission = -1;
gameseq_post_event(GS_EVENT_START_GAME_QUICK);
break;
case KEY_L:
gameseq_post_event( GS_EVENT_LOAD_MISSION_MENU );
break;
case KEY_F2:
gameseq_post_event(GS_EVENT_OPTIONS_MENU);
break;
case KEY_M:
if (Player->flags & PLAYER_FLAGS_IS_MULTI){
main_hall_do_multi_ready();
}
break;
}
// process button presses
mht_check_buttons();
// draw the background, etc
gr_reset_clip();
GR_MAYBE_CLEAR_RES(Mht_bitmap);
if(Mht_bitmap != -1){
gr_set_bitmap(Mht_bitmap);
gr_bitmap(0,0,GR_RESIZE_MENU);
}
Mht_window.draw();
// flip the buffer
gr_flip();
}
int snazzy_menu_do(ubyte *data, int mask_w, int mask_h, int num_regions, MENU_REGION *regions, int *action, int poll_key, int *key)
{
int i, k, x, y, offset;
int choice = -1, mouse_on_choice = -1;
ubyte pixel_value = 0;
Assert(data != NULL);
Assert(num_regions > 0);
Assert(regions != NULL);
gr_reset_clip(); // don't remove
mouse_get_pos_unscaled( &x, &y );
// boundary conditions
if((y > mask_h - 1) || (x > mask_w - 1)){
pixel_value = 0;
} else {
// check the pixel value under the mouse
offset = y * mask_w + x;
pixel_value = *(data + (offset));
}
*action = -1;
k = 0;
if ( poll_key ) {
k = game_check_key();
if (key)
*key = k; // pass keypress back to caller
}
// if (mouse_down_count(MOUSE_LEFT_BUTTON) ) {
if ( !mouse_down(MOUSE_LEFT_BUTTON) && Snazzy_mouse_left_was_down ) {
//nprintf(("Alan", "pixel val: %d\n", pixel_value));
for (i=0; i < num_regions; i++) {
if (pixel_value == regions[i].mask) {
choice = regions[i].mask;
if ( regions[i].click_sound != -1 ) {
snd_play( &Snds_iface[regions[i].click_sound], 0.0f );
}
}
} // end for
}
switch ( k ) {
case KEY_ESC:
choice = ESC_PRESSED;
break;
default:
if ( k )
for (i=0; i<num_regions; i++) {
if ( !regions[i].key )
continue;
if (ascii_table[k] == regions[i].key || shifted_ascii_table[k] == regions[i].key) {
choice = regions[i].mask;
if ( regions[i].click_sound != -1 ) {
snd_play( &Snds_iface[regions[i].click_sound], 0.0f );
}
}
} // end for
break;
} // end switch
for (i=0; i<num_regions; i++) {
if (pixel_value == regions[i].mask) {
mouse_on_choice = regions[i].mask;
break;
}
} // end for
gr_set_color_fast(&Color_white);
gr_set_font( FONT1 );
if ((mouse_on_choice >= 0) && (mouse_on_choice <= (num_regions)) && (i >=0)) {
gr_printf( 0x8000, 450, regions[i].text );
}
if ( mouse_down(MOUSE_LEFT_BUTTON) ){
Snazzy_mouse_left_was_down = 1;
} else {
Snazzy_mouse_left_was_down = 0;
}
if ( choice > -1 || choice == ESC_PRESSED ) {
*action = SNAZZY_CLICKED;
return choice;
}
if ( mouse_on_choice > -1 ) {
*action = SNAZZY_OVER;
return mouse_on_choice;
}
return -1;
}
void UI_RADIO::draw()
{
int offset;
if ( uses_bmaps ) {
if ( disabled_flag ) {
if ( flag ) {
if ( bmap_ids[RADIO_DISABLED_MARKED] != -1 ) {
gr_set_bitmap(bmap_ids[RADIO_DISABLED_MARKED], GR_ALPHABLEND_NONE, GR_BITBLT_MODE_NORMAL, 1.0f, -1, -1);
gr_bitmap(x,y);
}
}
else {
if ( bmap_ids[RADIO_DISABLED_CLEAR] != -1 ) {
gr_set_bitmap(bmap_ids[RADIO_DISABLED_CLEAR], GR_ALPHABLEND_NONE, GR_BITBLT_MODE_NORMAL, 1.0f, -1, -1);
gr_bitmap(x,y);
}
}
}
else { // not disabled
if ( position == 0 ) { // up
if ( flag ) { // marked
if ( bmap_ids[RADIO_UP_MARKED] != -1 ) {
gr_set_bitmap(bmap_ids[RADIO_UP_MARKED], GR_ALPHABLEND_NONE, GR_BITBLT_MODE_NORMAL, 1.0f, -1, -1);
gr_bitmap(x,y);
}
}
else { // not marked
if ( bmap_ids[RADIO_UP_CLEAR] != -1 ) {
gr_set_bitmap(bmap_ids[RADIO_UP_CLEAR], GR_ALPHABLEND_NONE, GR_BITBLT_MODE_NORMAL, 1.0f, -1, -1);
gr_bitmap(x,y);
}
}
}
else { // down
if ( flag ) { // marked
if ( bmap_ids[RADIO_DOWN_MARKED] != -1 ) {
gr_set_bitmap(bmap_ids[RADIO_DOWN_MARKED], GR_ALPHABLEND_NONE, GR_BITBLT_MODE_NORMAL, 1.0f, -1, -1);
gr_bitmap(x,y);
}
}
else { // not marked
if ( bmap_ids[RADIO_DOWN_CLEAR] != -1 ) {
gr_set_bitmap(bmap_ids[RADIO_DOWN_CLEAR], GR_ALPHABLEND_NONE, GR_BITBLT_MODE_NORMAL, 1.0f, -1, -1);
gr_bitmap(x,y);
}
}
}
}
}
else {
gr_set_font(my_wnd->f_id);
gr_set_clip( x, y, w, h );
if (position == 0 ) {
ui_draw_box_out( 0, 0, w-1, h-1 );
offset = 0;
} else {
ui_draw_box_in( 0, 0, w-1, h-1 );
offset = 1;
}
if (disabled_flag)
gr_set_color_fast(&CDARK_GRAY);
else if (my_wnd->selected_gadget == this)
gr_set_color_fast(&CBRIGHT_GREEN);
else
gr_set_color_fast(&CGREEN);
// if (flag)
// ui_string_centered( Middle(w)+offset, Middle(h)+offset, "*" );
// else
// ui_string_centered( Middle(w)+offset, Middle(h)+offset, "o" );
if (flag) {
gr_circle( Middle(w)+offset, Middle(h)+offset, 8 );
} else {
gr_circle( Middle(w)+offset, Middle(h)+offset, 8 );
gr_set_color_fast( &CWHITE );
gr_circle( Middle(w)+offset, Middle(h)+offset, 4 );
}
if (disabled_flag)
gr_set_color_fast(&CDARK_GRAY);
else if (my_wnd->selected_gadget == this)
gr_set_color_fast(&CBRIGHT_GREEN);
else
gr_set_color_fast(&CGREEN);
if ( text ) {
gr_reset_clip();
gr_string( x+w+4, y+2, text );
}
}
}
