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 glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) { next_glClearBufferfv(buffer, drawbuffer, value); printGLError(); if(buffer== GL_COLOR) gr_clear(GL_COLOR_BUFFER_BIT); if(buffer== GL_DEPTH) gr_clear(GL_DEPTH_BUFFER_BIT); debugPrint("glClearBufferfv(buffer= %s, drawbuffer= %i, value= %x)\n", getEnumString(buffer), drawbuffer, value); }
void debug_draw() { int i; gr_clear(); gr_set_font(FONT1); gr_set_color_fast( &Color_bright ); gr_string( 0x8000, 3, "Debug Console" ); gr_set_color_fast( &Color_normal ); for (i=0; i<DROWS; i++ ) { gr_string( 0, i*16+16, debug_text[i] ); } int t = timer_get_fixed_seconds() / (F1_0/3); if ( t & 1 ) { int w,h; char c; c = debug_text[debug_y][command_line_pos+1]; debug_text[debug_y][command_line_pos+1] = 0; gr_get_string_size( &w, &h, debug_text[debug_y] ); //gr_string( w, debug_y*16, "_" ); gr_rect(w+1,debug_y*16+1+16,2,14); debug_text[debug_y][command_line_pos+1] = c; } gr_flip(); }
int main() { // Create the main window // Start the game loop arc_add_dat("th105a.dat"); arc_add_dat("th105b.dat"); arc_add_dat("th105c.dat"); arc_add_dat("th123a.dat"); arc_add_dat("th123b.dat"); arc_add_dat("th123c.dat"); gr_init(640,480,"OpenSoku"); sfx_init(); scene_load_sounds(); char_c *marisa = new char_marisa(inp_createinput(INP_TYPE_KB)); char_c *alice = new char_alice(inp_createinput(INP_TYPE_NONE),1); // uint32_t i = 0; // inp_kb kb; marisa->set_seq(0); alice->set_seq(0); background *bkg = new background_11; c_scene *scn = new c_scene(bkg,marisa,alice); while(!kb.rawPressed(kC_Escape)) { kb.update(); gr_clear(); scn->players_input(); //scn.players_collisions(); scn->update(); scn->draw_scene(); scn->update_char_anims(); gr_flip(); } return EXIT_SUCCESS; }
// Clear the screen and draw the currently selected background icon (if any). // Should only be called with updateMutex locked. void ScreenRecoveryUI::draw_background_locked() { pagesIdentical = false; gr_color(0, 0, 0, 255); gr_clear(); if (currentIcon != NONE) { if (max_stage != -1) { int stage_height = gr_get_height(stageMarkerEmpty); int stage_width = gr_get_width(stageMarkerEmpty); int x = (gr_fb_width() - max_stage * gr_get_width(stageMarkerEmpty)) / 2; int y = gr_fb_height() - stage_height; for (int i = 0; i < max_stage; ++i) { GRSurface* stage_surface = (i < stage) ? stageMarkerFill : stageMarkerEmpty; gr_blit(stage_surface, 0, 0, stage_width, stage_height, x, y); x += stage_width; } } GRSurface* text_surface = GetCurrentText(); int text_x = (gr_fb_width() - gr_get_width(text_surface)) / 2; int text_y = GetTextBaseline(); gr_color(255, 255, 255, 255); gr_texticon(text_x, text_y, text_surface); } }
// Redraw everything on the screen. Does not flip pages. // Should only be called with updateMutex locked. void ScreenRecoveryUI::draw_screen_locked() { if (!show_text) { draw_background_locked(currentIcon); draw_progress_locked(); } else { gr_color(0, 0, 0, 255); gr_clear(); int y = 0; if (show_menu) { char recovery_fingerprint[PROPERTY_VALUE_MAX]; property_get("ro.bootimage.build.fingerprint", recovery_fingerprint, ""); SetColor(INFO); DrawTextLine(&y, "Android Recovery", true); for (auto& chunk : android::base::Split(recovery_fingerprint, ":")) { DrawTextLine(&y, chunk.c_str(), false); } DrawTextLines(&y, HasThreeButtons() ? REGULAR_HELP : LONG_PRESS_HELP); SetColor(HEADER); DrawTextLines(&y, menu_headers_); SetColor(MENU); DrawHorizontalRule(&y); y += 4; for (int i = 0; i < menu_items; ++i) { if (i == menu_sel) { // Draw the highlight bar. SetColor(IsLongPress() ? MENU_SEL_BG_ACTIVE : MENU_SEL_BG); gr_fill(0, y - 2, gr_fb_width(), y + char_height + 2); // Bold white text for the selected item. SetColor(MENU_SEL_FG); gr_text(4, y, menu_[i], true); SetColor(MENU); } else { gr_text(4, y, menu_[i], false); } y += char_height + 4; } DrawHorizontalRule(&y); } // display from the bottom up, until we hit the top of the // screen, the bottom of the menu, or we've displayed the // entire text buffer. SetColor(LOG); int row = (text_top_ + text_rows_ - 1) % text_rows_; size_t count = 0; for (int ty = gr_fb_height() - char_height; ty >= y && count < text_rows_; ty -= char_height, ++count) { gr_text(0, ty, text_[row], false); --row; if (row < 0) row = text_rows_ - 1; } } }
// Redraw everything on the screen. Does not flip pages. // Should only be called with updateMutex locked. void ScreenRecoveryUI::draw_screen_locked() { if (!show_text) { draw_background_locked(currentIcon); draw_progress_locked(); // MStar Android Patch Begin draw_top_title_locked(); draw_tip_title_locked(currentTip); draw_exit_recovery_tip_title_locked(currentExitRecoveryTip); // MStar Android Patch End } else { gr_color(0, 0, 0, 255); gr_clear(); int y = 0; int i = 0; if (show_menu) { SetColor(HEADER); for (; i < menu_top + menu_items; ++i) { if (i == menu_top) SetColor(MENU); if (i == menu_top + menu_sel) { // draw the highlight bar SetColor(MENU_SEL_BG); gr_fill(0, y-2, gr_fb_width(), y+char_height+2); // white text of selected item SetColor(MENU_SEL_FG); if (menu[i][0]) gr_text(4, y, menu[i], 1); SetColor(MENU); } else { if (menu[i][0]) gr_text(4, y, menu[i], i < menu_top); } y += char_height+4; } SetColor(MENU); y += 4; gr_fill(0, y, gr_fb_width(), y+2); y += 4; ++i; } SetColor(LOG); // display from the bottom up, until we hit the top of the // screen, the bottom of the menu, or we've displayed the // entire text buffer. int ty; int row = (text_top+text_rows-1) % text_rows; for (int ty = gr_fb_height() - char_height, count = 0; ty > y+2 && count < text_rows; ty -= char_height, ++count) { gr_text(4, ty, text[row], 0); --row; if (row < 0) row = text_rows-1; } } }
void glClear(GLbitfield mask) { next_glClear(mask); printGLError(); gr_clear(mask); debugPrint("glClear(mask= %x)\n", mask); }
// debug pause do frame void pause_debug_do() { int key; key = Pause_win.process(); if (Pause_single_step.changed()) { game_single_step = Pause_single_step.checked(); } if (Pause_physics.changed()) { physics_paused = Pause_physics.checked(); } if (Pause_ai.changed()) { ai_paused = Pause_ai.checked(); if (ai_paused) { obj_init_all_ships_physics(); } } if (Pause_ai_render.changed()) { Ai_render_debug_flag = Pause_ai_render.checked(); } if (Pause_firing.changed()) { Ai_firing_enabled = Pause_firing.checked(); } if (Pause_external_view_mode_check.changed()) { Pause_external_view_mode = Pause_external_view_mode_check.checked(); if (Pause_external_view_mode) { HUD_sourced_printf(HUD_SOURCE_HIDDEN, XSTR("External view of player ship.", 182)); } else { HUD_sourced_printf(HUD_SOURCE_HIDDEN, XSTR("View from inside player ship.", 183)); } } if (Pause_continue.pressed() || (key == KEY_PAUSE)) { // Changed, MK, 11/9/97, only Pause break pause. gameseq_post_event(GS_EVENT_PREVIOUS_STATE); } gr_clear(); Pause_win.draw(); gr_flip(); }
/* clear the gr, then free its allocated ptrs array, and then free gr itself */ int gr_destroy(gr_t gr) { int ret_val; if (!gr) return 0; ret_val = gr_clear(gr); free(gr->ptrs); free(gr); return ret_val; }
bool screen_gameplay::draw() { gr_clear(126,206,244); if (true)//HACK DON'T NEED FRAME SKIP? { scene->func14(); return true; } return false; }
void dc_draw(bool show_prompt = FALSE) { gr_clear(); gr_set_font(dc_font); gr_set_color_fast( &Color_bright ); gr_string( 0x8000, 3, dc_title.c_str(), GR_RESIZE_NONE ); gr_set_color_fast( &Color_normal ); dc_draw_window(show_prompt); gr_flip(); }
/** * Renders everything for a head animation * Also checks for when new head ani's need to start playing */ void HudGaugeTalkingHead::render(float frametime) { if ( Head_frame.first_frame == -1 ) { return; } if(msg_id != -1 && head_anim != NULL) { if(!head_anim->done_playing) { // draw frame // hud_set_default_color(); setGaugeColor(); // clear setClip(position[0] + Anim_offsets[0], position[1] + Anim_offsets[1], Anim_size[0], Anim_size[1]); gr_clear(); resetClip(); renderBitmap(Head_frame.first_frame, position[0], position[1]); // head ani border float scale_x = i2fl(Anim_size[0]) / i2fl(head_anim->width); float scale_y = i2fl(Anim_size[1]) / i2fl(head_anim->height); gr_set_screen_scale(fl2ir(base_w / scale_x), fl2ir(base_h / scale_y)); setGaugeColor(); generic_anim_render(head_anim,frametime, fl2ir((position[0] + Anim_offsets[0] + HUD_offset_x) / scale_x), fl2ir((position[1] + Anim_offsets[1] + HUD_offset_y) / scale_y)); // draw title gr_set_screen_scale(base_w, base_h); renderString(position[0] + Header_offsets[0], position[1] + Header_offsets[1], XSTR("message", 217)); } else { for (int j = 0; j < Num_messages_playing; ++j) { if (Playing_messages[j].id == msg_id) { Playing_messages[j].play_anim = false; break; // only one head ani plays at a time } } msg_id = -1; // allow repeated messages to display a new head ani head_anim = NULL; // Nothing to see here anymore, move along } } // check playing messages to see if we have any messages with talking animations that need to be created. for (int i = 0; i < Num_messages_playing; i++ ) { if(Playing_messages[i].play_anim && Playing_messages[i].id != msg_id ) { msg_id = Playing_messages[i].id; if (Playing_messages[i].anim_data) head_anim = Playing_messages[i].anim_data; else head_anim = NULL; return; } } }
// Clear the screen and draw the currently selected background icon (if any). // Should only be called with updateMutex locked. void ScreenRecoveryUI::draw_background_locked(Icon icon) { pagesIdentical = false; gr_color(0, 0, 0, 255); gr_clear(); if (icon) { gr_surface surface = backgroundIcon[icon]; if (icon == INSTALLING_UPDATE || icon == ERASING) { surface = installation[installingFrame]; } gr_surface text_surface = backgroundText[icon]; int iconWidth = gr_get_width(surface); int iconHeight = gr_get_height(surface); int textWidth = gr_get_width(text_surface); int textHeight = gr_get_height(text_surface); int stageHeight = gr_get_height(stageMarkerEmpty); int sh = (max_stage >= 0) ? stageHeight : 0; iconX = (gr_fb_width() - iconWidth) / 2; iconY = (gr_fb_height() - (iconHeight+textHeight+40+sh)) / 2; // MStar Android Patch Begin // Add textHeight + 40 + sh may cause iconY value be negative number if (iconY < 0) { iconY = 0; } // MStar Android Patch End int textX = (gr_fb_width() - textWidth) / 2; int textY = ((gr_fb_height() - (iconHeight+textHeight+40+sh)) / 2) + iconHeight + 40; gr_blit(surface, 0, 0, iconWidth, iconHeight, iconX, iconY); if (stageHeight > 0) { int sw = gr_get_width(stageMarkerEmpty); int x = (gr_fb_width() - max_stage * gr_get_width(stageMarkerEmpty)) / 2; int y = iconY + iconHeight + 20; for (int i = 0; i < max_stage; ++i) { gr_blit((i < stage) ? stageMarkerFill : stageMarkerEmpty, 0, 0, sw, stageHeight, x, y); x += sw; } } gr_color(255, 255, 255, 255); gr_texticon(textX, textY, text_surface); } }
void dc_draw(bool show_prompt = FALSE) { gr_clear(); font::set_font(dc_font); gr_set_color_fast( &Color_bright ); int w; gr_get_string_size(&w, nullptr, dc_title.c_str()); gr_string((gr_screen.clip_width - w) / 2, 3, dc_title.c_str(), GR_RESIZE_NONE ); gr_set_color_fast( &Color_normal ); dc_draw_window(show_prompt); gr_flip(); }
// Clear the screen and draw the currently selected background icon (if any). // Should only be called with updateMutex locked. void ScreenRecoveryUI::draw_background_locked(Icon icon) { pagesIdentical = false; SetColor(TEXT_FILL); gr_clear(); if (icon) { gr_surface surface = backgroundIcon[icon]; if (icon == INSTALLING_UPDATE || icon == ERASING) { surface = installation[installingFrame]; } gr_surface text_surface = backgroundText[icon]; int iconWidth = gr_get_width(surface); int iconHeight = gr_get_height(surface); int textWidth = gr_get_width(text_surface); int textHeight = gr_get_height(text_surface); int stageHeight = gr_get_height(stageMarkerEmpty); int availableHeight = icon == INSTALLING_UPDATE && !DialogShowing() && show_text ? 3 * gr_fb_height() / 4 : gr_fb_height(); int sh = (max_stage >= 0) ? stageHeight : 0; iconX = (gr_fb_width() - iconWidth) / 2; iconY = (availableHeight - (iconHeight+textHeight+40+sh)) / 2; int textX = (gr_fb_width() - textWidth) / 2; int textY = ((availableHeight - (iconHeight+textHeight+40+sh)) / 2) + iconHeight + 40; gr_blit(surface, 0, 0, iconWidth, iconHeight, iconX, iconY); if (stageHeight > 0) { int sw = gr_get_width(stageMarkerEmpty); int x = (gr_fb_width() - max_stage * gr_get_width(stageMarkerEmpty)) / 2; int y = iconY + iconHeight + 20; for (int i = 0; i < max_stage; ++i) { gr_blit((i < stage) ? stageMarkerFill : stageMarkerEmpty, 0, 0, sw, stageHeight, x, y); x += sw; } } LOGV("textX=%d textY=%d iconX=%d iconY=%d", textX, textY, iconX, iconY); SetColor(MENU); gr_texticon(textX, textY, text_surface); } }
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 }
// Exercises many of the gr_*() functions; useful for testing. static void gr_test() { GRSurface** images; int frames; int result = res_create_multi_surface("icon_installing", &frames, &images); if (result < 0) { printf("create surface %d\n", result); gr_exit(); return; } time_t start = time(NULL); int x; for (x = 0; x <= 1200; ++x) { if (x < 400) { gr_color(0, 0, 0, 255); } else { gr_color(0, (x-400)%128, 0, 255); } gr_clear(); gr_color(255, 0, 0, 255); gr_surface frame = images[x%frames]; gr_blit(frame, 0, 0, frame->width, frame->height, x, 0); gr_color(255, 0, 0, 128); gr_fill(400, 150, 600, 350); gr_color(255, 255, 255, 255); gr_text(500, 225, "hello, world!", 0); gr_color(255, 255, 0, 128); gr_text(300+x, 275, "pack my box with five dozen liquor jugs", 1); gr_color(0, 0, 255, 128); gr_fill(gr_draw->width - 200 - x, 300, gr_draw->width - x, 500); gr_draw = gr_backend->flip(gr_backend); } printf("getting end time\n"); time_t end = time(NULL); printf("got end time\n"); printf("start %ld end %ld\n", (long)start, (long)end); if (end > start) { printf("%.2f fps\n", ((double)x) / (end-start)); } }
/* frees all pointers in gr: if chain is present, destroy it. then loop through ptrs, calling the user supplied cleanup function on all pointers. If none was supplied (ie ff == NULL), then call free. */ int gr_clear(gr_t gr) { int i; int ret_val = 0; /* > 0 means there was a problem freeing some resources */ assert(gr); assert(gr->ptrs); if (gr->chain) { if (dbg) fprintf(stderr, "gr_clear: clearing chain\n"); if (destroy_chains_on_clear) { ret_val += gr_destroy(gr->chain); gr->chain = NULL; } else { ret_val += gr_clear(gr->chain); } } /* if ff (free_func) is NULL, assume that we should just free the data */ for (i = 0; i < gr->num; i++) { if (gr->ptrs[i].data) { if (gr->ptrs[i].ff) ret_val += (*gr->ptrs[i].ff)(gr->ptrs[i].data); else free(gr->ptrs[i].data); gr->ptrs[i].data = NULL; } } if (dbg) fprintf(stderr, "gr_clear: cleared %d\n", i); gr->num = 0; return ret_val; }
// call before beginning all rendering void neb2_render_setup(camid cid) { // standalone servers can bail here if (Game_mode & GM_STANDALONE_SERVER) { return; } // if the mission is not a fullneb mission, skip if ( !(The_mission.flags[Mission::Mission_Flags::Fullneb]) ) { return; } if (Neb2_render_mode == NEB2_RENDER_HTL) { // RT The background needs to be the same colour as the fog and this seems // to be the ideal place to do it ubyte tr = gr_screen.current_clear_color.red; ubyte tg = gr_screen.current_clear_color.green; ubyte tb = gr_screen.current_clear_color.blue; neb2_get_fog_color( &gr_screen.current_clear_color.red, &gr_screen.current_clear_color.green, &gr_screen.current_clear_color.blue); gr_clear(); gr_screen.current_clear_color.red = tr; gr_screen.current_clear_color.green = tg; gr_screen.current_clear_color.blue = tb; return; } // pre-render the real background nebula neb2_pre_render(cid); }
static void clear() { gr_color(0, 0, 0, 0); gr_clear(); gr_flip(); }
// 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 gr_clear_as( GRAPH * dest, int color ) { uint32_t y; if ( !color ) { gr_clear( dest ); return; } switch ( dest->format->depth ) { case 8: { memset( dest->data, color, dest->pitch * dest->height ) ; break; } case 16: { uint8_t * data = dest->data ; int16_t * ptr ; int n ; y = dest->height; while ( y-- ) { ptr = ( int16_t * ) data; n = dest->width; while ( n-- ) * ptr++ = color ; data += dest->pitch ; } break; } case 32: { uint8_t * data = dest->data ; uint32_t * ptr ; int n ; y = dest->height; while ( y-- ) { ptr = ( uint32_t * ) data; n = dest->width; while ( n-- ) * ptr++ = color ; data += dest->pitch ; } break; } case 1: { int c = color ? 0xFF : 0 ; memset( dest->data, c, dest->pitch * dest->height ) ; break; } } dest->modified = 1 ; /* Don't needs analysis */ if ( dest->format->depth != 32 || ( color & 0xff000000 ) == 0xff000000 ) dest->info_flags |= GI_NOCOLORKEY; else dest->info_flags &= ~GI_NOCOLORKEY; dest->info_flags &= ~GI_CLEAN; }
// --------------------------------------------------------------------- // mission_hotkey_do_frame() // // Called once per frame to process user input for the Hotkey Assignment Screen // void mission_hotkey_do_frame(float frametime) { char buf[256]; int i, k, w, h, y, z, line, hotkeys; int font_height = gr_get_font_height(); int select_tease_line = -1; // line mouse is down on, but won't be selected until button released color circle_color; if ( help_overlay_active(Hotkey_overlay_id) ) { Buttons[gr_screen.res][HELP_BUTTON].button.reset_status(); Ui_window.set_ignore_gadgets(1); } k = Ui_window.process() & ~KEY_DEBUGGED; if ( (k > 0) || B1_JUST_RELEASED ) { if ( help_overlay_active(Hotkey_overlay_id) ) { help_overlay_set_state(Hotkey_overlay_id, gr_screen.res, 0); Ui_window.set_ignore_gadgets(0); k = 0; } } if ( !help_overlay_active(Hotkey_overlay_id) ) { Ui_window.set_ignore_gadgets(0); } switch (k) { case KEY_DOWN: // scroll list down hotkey_scroll_line_down(); break; case KEY_UP: // scroll list up hotkey_scroll_line_up(); break; case KEY_PAGEDOWN: // scroll list down hotkey_scroll_screen_down(); break; case KEY_PAGEUP: // scroll list up hotkey_scroll_screen_up(); break; case KEY_CTRLED | KEY_ENTER: save_hotkeys(); // fall through to next state -- allender changed this behavior since ESC should always cancel, no? case KEY_ESC: mission_hotkey_exit(); break; case KEY_TAB: case KEY_ENTER: case KEY_PADENTER: expand_wing(); break; case KEY_EQUAL: case KEY_PADPLUS: add_hotkey(Cur_hotkey); break; case KEY_MINUS: case KEY_PADMINUS: remove_hotkey(); break; case KEY_F2: gameseq_post_event(GS_EVENT_OPTIONS_MENU); break; case KEY_CTRLED | KEY_R: reset_hotkeys(); break; case KEY_CTRLED | KEY_C: clear_hotkeys(); break; } // end switch // ? for (i=0; i<MAX_KEYED_TARGETS; i++) { if (k == Key_sets[i]) Cur_hotkey = i; if (k == (Key_sets[i] | KEY_SHIFTED)) add_hotkey(i); } // handle pressed buttons for (i=0; i<NUM_BUTTONS; i++) { if (Buttons[gr_screen.res][i].button.pressed()) { hotkey_button_pressed(i); break; // only need to handle 1 button @ a time } } for (i=0; i<LIST_BUTTONS_MAX; i++) { // check for tease line if (List_buttons[i].button_down()) { select_tease_line = i + Scroll_offset; } // check for selected list item if (List_buttons[i].pressed()) { Selected_line = i + Scroll_offset; List_buttons[i].get_mouse_pos(&z, NULL); z += Hotkey_list_coords[gr_screen.res][0]; // adjust to full screen space if ((z >= Hotkey_wing_icon_x[gr_screen.res]) && (z < (Hotkey_wing_icon_x[gr_screen.res]) + Hotkey_function_field_width[gr_screen.res])) { expand_wing(); } } if (List_buttons[i].double_clicked()) { Selected_line = i + Scroll_offset; hotkeys = -1; switch (Hotkey_lines[Selected_line].type) { case HOTKEY_LINE_WING: hotkeys = get_wing_hotkeys(Hotkey_lines[Selected_line].index); break; case HOTKEY_LINE_SHIP: case HOTKEY_LINE_SUBSHIP: hotkeys = Hotkey_bits[Hotkey_lines[Selected_line].index]; break; } if (hotkeys != -1) { if (hotkeys & (1 << Cur_hotkey)) remove_hotkey(); else add_hotkey(Cur_hotkey); } } } GR_MAYBE_CLEAR_RES(Background_bitmap); if (Background_bitmap >= 0) { gr_set_bitmap(Background_bitmap); gr_bitmap(0, 0, GR_RESIZE_MENU); } else gr_clear(); Ui_window.draw(); gr_init_color(&circle_color, 160, 160, 0); // draw the big "F10" in the little box font::set_font(font::FONT2); gr_set_color_fast(&Color_text_normal); strcpy_s(buf, Scan_code_text[Key_sets[Cur_hotkey]]); gr_get_string_size(&w, &h, buf); gr_printf_menu(Hotkey_function_name_coords[gr_screen.res][0] + (Hotkey_function_name_coords[gr_screen.res][2] - w) / 2, Hotkey_function_name_coords[gr_screen.res][1], buf); font::set_font(font::FONT1); line = Scroll_offset; while (hotkey_line_query_visible(line)) { z = Hotkey_lines[line].index; y = Hotkey_list_coords[gr_screen.res][1] + Hotkey_lines[line].y - Hotkey_lines[Scroll_offset].y; hotkeys = 0; switch (Hotkey_lines[line].type) { case HOTKEY_LINE_HEADING: gr_set_color_fast(&Color_text_heading); gr_get_string_size(&w, &h, Hotkey_lines[line].label); i = y + h / 2 - 1; gr_line(Hotkey_list_coords[gr_screen.res][0], i, Hotkey_ship_x[gr_screen.res] - 2, i, GR_RESIZE_MENU); gr_line(Hotkey_ship_x[gr_screen.res] + w + 1, i, Hotkey_list_coords[gr_screen.res][0] + Hotkey_list_coords[gr_screen.res][2], i, GR_RESIZE_MENU); break; case HOTKEY_LINE_WING: gr_set_bitmap(Wing_bmp); bm_get_info(Wing_bmp, NULL, &h, NULL); i = y + font_height / 2 - h / 2 - 1; gr_bitmap(Hotkey_wing_icon_x[gr_screen.res], i, GR_RESIZE_MENU); // i = y + font_height / 2 - 1; // gr_set_color_fast(&circle_color); // gr_circle(ICON_LIST_X + 4, i, 5, GR_RESIZE_MENU); // gr_set_color_fast(&Color_bright); // gr_line(ICON_LIST_X, i, ICON_LIST_X + 2, i, GR_RESIZE_MENU); // gr_line(ICON_LIST_X + 4, i - 4, ICON_LIST_X + 4, i - 2, GR_RESIZE_MENU); // gr_line(ICON_LIST_X + 6, i, ICON_LIST_X + 8, i, GR_RESIZE_MENU); // gr_line(ICON_LIST_X + 4, i + 2, ICON_LIST_X + 4, i + 4, GR_RESIZE_MENU); hotkeys = get_wing_hotkeys(Hotkey_lines[line].index); break; case HOTKEY_LINE_SHIP: case HOTKEY_LINE_SUBSHIP: hotkeys = Hotkey_bits[Hotkey_lines[line].index]; break; default: Int3(); } if (Hotkey_lines[line].type != HOTKEY_LINE_HEADING) { Assert( (line - Scroll_offset) < LIST_BUTTONS_MAX ); List_buttons[line - Scroll_offset].update_dimensions(Hotkey_list_coords[gr_screen.res][0], y, Hotkey_list_coords[gr_screen.res][0] + Hotkey_list_coords[gr_screen.res][2] - Hotkey_list_coords[gr_screen.res][0], font_height); List_buttons[line - Scroll_offset].enable(); if (hotkeys & (1 << Cur_hotkey)) { gr_set_color_fast(&Color_text_active); } else { if (line == Selected_line) gr_set_color_fast(&Color_text_selected); else if (line == select_tease_line) gr_set_color_fast(&Color_text_subselected); else gr_set_color_fast(&Color_text_normal); } } else { Assert( (line - Scroll_offset) < LIST_BUTTONS_MAX ); List_buttons[line - Scroll_offset].disable(); } // print active hotkeys associated for this line if (hotkeys) { for (i=0; i<MAX_KEYED_TARGETS; i++) { if (hotkeys & (1 << i)) { gr_printf_menu(Hotkey_list_coords[gr_screen.res][0] + Hotkey_function_field_width[gr_screen.res]*i, y, Scan_code_text[Key_sets[i]]); } } /* *buf = 0; for (i=0; i<MAX_KEYED_TARGETS; i++) { if (hotkeys & (1 << i)) { strcat_s(buf, Scan_code_text[Key_sets[i]]); strcat_s(buf, ", "); } } Assert(strlen(buf) > 1); buf[strlen(buf) - 2] = 0; // lose the ", " on the end font::force_fit_string(buf, 255, GROUP_LIST_W); gr_printf_menu(GROUP_LIST_X, y, buf);*/ } // draw ship/wing name strcpy_s(buf, Hotkey_lines[line].label); end_string_at_first_hash_symbol(buf); if (Hotkey_lines[line].type == HOTKEY_LINE_SUBSHIP) { // indent font::force_fit_string(buf, 255, Hotkey_list_coords[gr_screen.res][0] + Hotkey_list_coords[gr_screen.res][2] - (Hotkey_ship_x[gr_screen.res]+20)); gr_printf_menu(Hotkey_ship_x[gr_screen.res]+20, y, buf); } else { font::force_fit_string(buf, 255, Hotkey_list_coords[gr_screen.res][0] + Hotkey_list_coords[gr_screen.res][2] - Hotkey_ship_x[gr_screen.res]); gr_printf_menu(Hotkey_ship_x[gr_screen.res], y, buf); } line++; } i = line - Scroll_offset; while (i < LIST_BUTTONS_MAX) List_buttons[i++].disable(); // blit help overlay if active help_overlay_maybe_blit(Hotkey_overlay_id, gr_screen.res); gr_flip(); }
void gr_draw_screen( GRAPH * dest, int restore_type, int dump_type ) { int a ; GRAPH * orig_scrbitmap = scrbitmap; scrbitmap = dest ; if ( background && background->modified ) { restore_type = 1; dump_type = 1; } /* Update the object list */ gr_update_objects_mark_rects( restore_type, dump_type ); /* Restore the background */ if ( !dump_type || !restore_type ) { updaterects_count = gr_mark_rects( updaterects ); } else { updaterects_count = 1; updaterects[ 0 ].x = 0; updaterects[ 0 ].y = 0; updaterects[ 0 ].x2 = scr_width - 1; updaterects[ 0 ].y2 = scr_height - 1; } if ( !restore_type ) { /* PARTIAL_RESTORE */ if ( background->info_flags & GI_CLEAN ) { for ( a = 0; a < updaterects_count; a++ ) gr_clear_region( scrbitmap, &updaterects[ a ] ); } else { for ( a = 0; a < updaterects_count; a++ ) gr_blit( scrbitmap, &updaterects[ a ], 0, 0, B_NOCOLORKEY, background ); } } else if ( restore_type == 1 ) { /* COMPLETE_RESTORE */ if ( background->info_flags & GI_CLEAN ) gr_clear( scrbitmap ) ; else gr_blit( scrbitmap, NULL, 0, 0, B_NOCOLORKEY, background ); updaterects_count = 1; updaterects[ 0 ].x = 0; updaterects[ 0 ].y = 0; updaterects[ 0 ].x2 = scr_width - 1; updaterects[ 0 ].y2 = scr_height - 1; } /* Dump the objects */ if ( dump_type == 0 ) { /* Dump only changed & enabled objects */ gr_draw_objects( updaterects, updaterects_count ); } else { /* Dump everything */ gr_draw_objects_complete(); } /* Reset the zone-to-update array for the next frame */ gr_rects_clear(); if ( background && background->modified ) background->modified = 0; if ( scrbitmap && scrbitmap->modified ) scrbitmap->modified = 0; scrbitmap = orig_scrbitmap; }
GRAPH * gr_text_bitmap( int fontid, const char * text, int alignment ) { GRAPH * gr ; int x, y ; FONT * f ; // Splinter if ( !text || !*text ) return NULL; if ( fontid < 0 || fontid >= MAX_FONTS || !fonts[fontid] ) return NULL; // Incorrect font type f = fonts[fontid] ; /* Un refresco de paleta en mitad de gr_text_put puede provocar efectos * desagradables al modificar el tipo de letra del sistema */ if ( palette_changed ) gr_refresh_palette() ; gr = bitmap_new_syslib( gr_text_width( fontid, ( const unsigned char * ) text ), gr_text_height( fontid, ( const unsigned char * ) text ), sys_pixel_format->depth ) ; if ( !gr ) return NULL; gr_clear( gr ) ; if ( !gr_text_put( gr, 0, fontid, 0, -gr_text_margintop( fontid, ( const unsigned char * ) text ), ( const unsigned char * ) text ) ) { bitmap_destroy( gr ); return NULL; } switch ( alignment ) { case ALIGN_TOP_LEFT: // 0 case ALIGN_TOP: // 1 case ALIGN_TOP_RIGHT: // 2 y = 0 ; break ; case ALIGN_CENTER_LEFT: // 3 case ALIGN_CENTER: // 4 case ALIGN_CENTER_RIGHT:// 5 y = gr->height / 2 ; break ; default: y = gr->height - 1 ; break ; } switch ( alignment ) { case ALIGN_TOP_LEFT: // 0 case ALIGN_CENTER_LEFT: // 3 case ALIGN_BOTTOM_LEFT: // 6 x = 0 ; break ; case ALIGN_TOP: // 1 case ALIGN_CENTER: // 4 case ALIGN_BOTTOM: // 7 x = gr->width / 2 ; break ; default: x = gr->width - 1 ; break ; } bitmap_add_cpoint( gr, x, y ) ; return gr ; }
void freespace_menu_background() { gr_reset_clip(); gr_clear(); }
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; }