int main(int argc, char **argv) { char *fn; int begin=0; int end=255; int size=10; int cpl=0; int cell=0; char autohinter=0; char seq=0; char alpha=0; char pack=0; FT_Library freetype; FT_Face face; int err; int i; char *out_fn="font.png"; char *def_fn=NULL; Font font; if(argc<2) { usage(); return 1; } while((i=getopt(argc, argv, "r:s:l:c:o:atvh?ed:p"))!=-1) { char *ptr; int temp; switch(i) { case 'r': if(!strcmp(optarg, "all")) { begin=0; end=0x110000; } else { if(!isdigit(optarg[0])) temp=-1; else { temp=strtol(optarg, &ptr, 0); if(ptr[0]!=',' || !isdigit(ptr[1])) temp=-1; } if(temp<0) { printf("Not a valid range: %s\n", optarg); exit(1); } else { begin=temp; end=strtol(ptr+1, NULL, 0); } } break; case 's': size=strtol(optarg, NULL, 0); break; case 'l': cpl=strtol(optarg, NULL, 0); break; case 'c': cell=strtol(optarg, NULL, 0); break; case 'o': out_fn=optarg; break; case 'a': autohinter=1; break; case 't': alpha=1; break; case 'v': ++verbose; break; case 'h': case '?': usage(); return 0; case 'e': seq=1; break; case 'd': def_fn=optarg; break; case 'p': pack=1; break; } } if(!strcmp(out_fn, "-")) verbose=0; if(optind!=argc-1) { usage(); return 1; } fn=argv[optind]; err=FT_Init_FreeType(&freetype); if(err) { fprintf(stderr, "Couldn't initialize FreeType library\n"); return 1; } err=FT_New_Face(freetype, fn, 0, &face); if(err) { fprintf(stderr, "Couldn't load font file\n"); if(err==FT_Err_Unknown_File_Format) fprintf(stderr, "Unknown file format\n"); return 1; } if(verbose) { const char *name=FT_Get_Postscript_Name(face); printf("Font name: %s\n", name); printf("Glyphs: %ld\n", face->num_glyphs); } err=FT_Set_Pixel_Sizes(face, 0, size); if(err) { fprintf(stderr, "Couldn't set size\n"); return 1; } font.size=size; init_font(&font, face, begin, end, autohinter); if(pack) render_packed(&font); else render_grid(&font, cell, cpl, seq); save_png(out_fn, &font.image, alpha); if(def_fn) save_defs(def_fn, &font); for(i=0; i<font.n_glyphs; ++i) free(font.glyphs[i].image.data); free(font.glyphs); free(font.image.data); FT_Done_Face(face); FT_Done_FreeType(freetype); return 0; }
int main(int argc, char *argv[]){ if(!glfwInit()){ throw std::runtime_error("glfwInit failed"); } glfwOpenWindowHint(GLFW_FSAA_SAMPLES, 4); glfwOpenWindowHint(0, GLFW_OPENGL_CORE_PROFILE); glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3); glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 1); glfwOpenWindowHint(GLFW_WINDOW_NO_RESIZE, GL_TRUE); if(!glfwOpenWindow(800, 600, 0, 0, 0, 0, 32, 0, GLFW_WINDOW)){ throw std::runtime_error("glfwOpenWindow failed. does this hardware work with 3.1"); } glewExperimental = GL_TRUE; if(glewInit() != GLEW_OK){ throw std::runtime_error("glewInit failed"); } if(!GLEW_VERSION_3_1){ throw std::runtime_error("OpenGL 3.1 API is not available"); } LoadGeometry(); LoadTexture(); PrepVertexUniforms(); init_font(); printf("All data prepped\n"); camera.setPosition(glm::vec3(0,0,8)); camera.setViewportAspectRatio(screenwidth/screenheight); light.position = camera.position(); light.intensities = glm::vec3(1,1,1); glfwDisable(GLFW_MOUSE_CURSOR); glfwSetMousePos(0, 0); glfwSetMouseWheel(0); printf("camera prepped\n"); //turn on depth test so things dont look stupid glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glEnable(GL_CULL_FACE); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); printf("starting main loop\n"); while(glfwGetWindowParam(GLFW_OPENED)){ update(); display(); //check for errors GLenum error = glGetError(); if(error != GL_NO_ERROR){ glPrintError(); } //esc == close if(glfwGetKey(GLFW_KEY_ESC)){ glfwCloseWindow(); } } glfwTerminate(); return 0; }
int real_main() { srand48(time(NULL)); if (!al_init()) { puts("Could not initialise allegro"); return 1; } if (!al_install_keyboard()) { puts("Could not initialise allegro keyboard subsystem"); return 1; } keys = malloc(sizeof(ALLEGRO_KEYBOARD_STATE)); if (!init_font()) { puts("Could not initialise allegro font subsystem"); return 1; } al_set_new_display_flags(ALLEGRO_FULLSCREEN_WINDOW); ALLEGRO_DISPLAY* display = al_create_display(1, 1); if (!display) { puts("Could not initialise allegro display"); return 1; } Vector size = new_vector(); size.x = al_get_display_width(display); size.y = al_get_display_height(display); Game* game = new_game(size); int i; for (i = 0; i < ASTEROIDN; i++) spawn_asteroid(game); ALLEGRO_TIMER* timer = al_create_timer(1.0/FPS); ALLEGRO_EVENT_QUEUE *timereq = al_create_event_queue(); ALLEGRO_EVENT_QUEUE *genericeq = al_create_event_queue(); if (!timereq || !genericeq) { puts("Could not create allegro event queue"); return 1; } al_register_event_source(timereq, al_get_timer_event_source(timer)); al_register_event_source(genericeq, al_get_keyboard_event_source()); al_register_event_source(genericeq, al_get_display_event_source(display)); al_start_timer(timer); // Start generating timer events ALLEGRO_EVENT *timerevent = malloc(sizeof(ALLEGRO_EVENT)); ALLEGRO_EVENT *genericevent = malloc(sizeof(ALLEGRO_EVENT)); float last_drawn, now; last_drawn = now = al_get_time(); while (game->status != Quit) { al_get_keyboard_state(keys); al_wait_for_event(timereq, NULL); al_get_next_event(timereq, timerevent); // No need to fill up the queue if we are late drawing frames al_flush_event_queue(timereq); handle_key_status(game, keys); while(al_get_next_event(genericeq, genericevent)) switch(genericevent->type) { case ALLEGRO_EVENT_KEY_DOWN: handle_key_event(game, genericevent->keyboard.keycode); break; case ALLEGRO_EVENT_DISPLAY_RESIZE: game->size.x = genericevent->display.x; game->size.y = genericevent->display.y; al_acknowledge_resize(display); break; case ALLEGRO_EVENT_DISPLAY_CLOSE: game->status = Quit; break; } now = al_get_time(); update_game(game, now - last_drawn); last_drawn = now; draw_game(game, game->status == Playing ? 1 : 0.2); switch(game->status) { case Playing: break; case Paused: draw_paused(game); break; case Won: draw_won(game); break; case Lost: draw_lost(game); break; default: break; } al_flip_display(); } free(timerevent); free(genericevent); delete_game(game); return 0; }
static void ft2_source_update(void *data, obs_data_t settings) { struct ft2_source *srcdata = data; obs_data_t font_obj = obs_data_get_obj(settings, "font"); bool vbuf_needs_update = false; bool word_wrap = false; uint32_t color[2]; uint32_t custom_width = 0; const char *font_name = obs_data_get_string(font_obj, "face"); const char *font_style = obs_data_get_string(font_obj, "style"); uint16_t font_size = (uint16_t)obs_data_get_int(font_obj, "size"); uint32_t font_flags = (uint32_t)obs_data_get_int(font_obj, "flags"); if (!font_obj) return; srcdata->drop_shadow = obs_data_get_bool(settings, "drop_shadow"); srcdata->outline_text = obs_data_get_bool(settings, "outline"); word_wrap = obs_data_get_bool(settings, "word_wrap"); color[0] = (uint32_t)obs_data_get_int(settings, "color1"); color[1] = (uint32_t)obs_data_get_int(settings, "color2"); custom_width = (uint32_t)obs_data_get_int(settings, "custom_width"); if (custom_width >= 100) { if (custom_width != srcdata->custom_width) { srcdata->custom_width = custom_width; vbuf_needs_update = true; } } else { if (srcdata->custom_width >= 100) vbuf_needs_update = true; srcdata->custom_width = 0; } if (word_wrap != srcdata->word_wrap) { srcdata->word_wrap = word_wrap; vbuf_needs_update = true; } if (color[0] != srcdata->color[0] || color[1] != srcdata->color[1]) { srcdata->color[0] = color[0]; srcdata->color[1] = color[1]; vbuf_needs_update = true; } bool from_file = obs_data_get_bool(settings, "from_file"); bool chat_log_mode = obs_data_get_bool(settings, "log_mode"); srcdata->log_mode = chat_log_mode; if (ft2_lib == NULL) goto error; if (srcdata->draw_effect == NULL) { char *effect_file = NULL; char *error_string = NULL; effect_file = obs_module_file("text_default.effect"); if (effect_file) { obs_enter_graphics(); srcdata->draw_effect = gs_effect_create_from_file( effect_file, &error_string); obs_leave_graphics(); bfree(effect_file); if (error_string != NULL) bfree(error_string); } } if (srcdata->font_size != font_size || srcdata->from_file != from_file) vbuf_needs_update = true; srcdata->file_load_failed = false; srcdata->from_file = from_file; if (srcdata->font_name != NULL) { if (strcmp(font_name, srcdata->font_name) == 0 && strcmp(font_style, srcdata->font_style) == 0 && font_flags == srcdata->font_flags && font_size == srcdata->font_size) goto skip_font_load; bfree(srcdata->font_name); bfree(srcdata->font_style); srcdata->font_name = NULL; srcdata->font_style = NULL; srcdata->max_h = 0; } srcdata->font_name = bstrdup(font_name); srcdata->font_style = bstrdup(font_style); srcdata->font_size = font_size; srcdata->font_flags = font_flags; if (!init_font(srcdata) || srcdata->font_face == NULL) { blog(LOG_WARNING, "FT2-text: Failed to load font %s", srcdata->font_name); goto error; } else { FT_Set_Pixel_Sizes(srcdata->font_face, 0, srcdata->font_size); FT_Select_Charmap(srcdata->font_face, FT_ENCODING_UNICODE); } if (srcdata->texbuf != NULL) { bfree(srcdata->texbuf); srcdata->texbuf = NULL; } srcdata->texbuf = bzalloc(texbuf_w * texbuf_h * 4); if (srcdata->font_face) cache_standard_glyphs(srcdata); skip_font_load:; if (from_file) { const char *tmp = obs_data_get_string(settings, "text_file"); if (!tmp || !*tmp) { blog(LOG_WARNING, "FT2-text: Failed to open %s for reading", tmp); goto error; } if (srcdata->text_file != NULL && strcmp(srcdata->text_file, tmp) == 0 && !vbuf_needs_update) goto error; bfree(srcdata->text_file); srcdata->text_file = bstrdup(tmp); if (chat_log_mode) read_from_end(srcdata, tmp); else load_text_from_file(srcdata, tmp); srcdata->last_checked = os_gettime_ns(); } else { const char *tmp = obs_data_get_string(settings, "text"); if (!tmp || !*tmp) goto error; if (srcdata->text != NULL) { bfree(srcdata->text); srcdata->text = NULL; } os_utf8_to_wcs_ptr(tmp, strlen(tmp), &srcdata->text); } if (srcdata->font_face) { cache_glyphs(srcdata, srcdata->text); set_up_vertex_buffer(srcdata); } error: obs_data_release(font_obj); }
/* Initialise Video, PAD, DVD, Font */ void Initialise (void) { VIDEO_Init (); PAD_Init (); DVD_Init(); *(volatile unsigned long*)0xcc00643c = 0x00000000; //allow 32mhz exi bus // Disable IPL modchips to allow access to IPL ROM fonts ipl_set_config(6); usleep(1000); //wait for modchip to disable (overkill) __SYS_ReadROM(IPLInfo,256,0); // Read IPL tag // By default, let libOGC figure out the video mode GXRModeObj *vmode = VIDEO_GetPreferredMode(NULL); //Last mode used if(is_gamecube()) { // Gamecube, determine based on IPL int retPAD = 0, retCnt = 10000; while(retPAD <= 0 && retCnt >= 0) { retPAD = PAD_ScanPads(); usleep(100); retCnt--; } // L Trigger held down ignores the fact that there's a component cable plugged in. if(VIDEO_HaveComponentCable() && !(PAD_ButtonsDown(0) & PAD_TRIGGER_L)) { if(strstr(IPLInfo,"MPAL")!=NULL) { swissSettings.sramVideo = 2; vmode = &TVMpal480Prog; //Progressive 480p } else if((strstr(IPLInfo,"PAL")!=NULL)) { swissSettings.sramVideo = 1; vmode = &TVPal576ProgScale; //Progressive 576p } else { swissSettings.sramVideo = 0; vmode = &TVNtsc480Prog; //Progressive 480p } } else { //try to use the IPL region if(strstr(IPLInfo,"MPAL")!=NULL) { swissSettings.sramVideo = 2; vmode = &TVMpal480IntDf; //PAL-M } else if(strstr(IPLInfo,"PAL")!=NULL) { swissSettings.sramVideo = 1; vmode = &TVPal576IntDfScale; //PAL } else { swissSettings.sramVideo = 0; vmode = &TVNtsc480IntDf; //NTSC } } } setVideoMode(vmode); init_font(); DrawInit(); drive_version(&driveVersion[0]); swissSettings.hasDVDDrive = *(u32*)&driveVersion[0] ? 1 : 0; if(!driveVersion[0]) { // Reset DVD if there was a IPL replacement that hasn't done that for us yet uiDrawObj_t *progBox = DrawPublish(DrawProgressBar(true, 0, "Initialise DVD .. (HOLD B if NO DVD Drive)")); dvd_reset(); // low-level, basic dvd_read_id(); if(!(PAD_ButtonsHeld(0) & PAD_BUTTON_B)) { dvd_set_streaming(*(char*)0x80000008); } drive_version(&driveVersion[0]); swissSettings.hasDVDDrive = *(u32*)&driveVersion[0] ? 2 : 0; if(!swissSettings.hasDVDDrive) { DrawDispose(progBox); progBox = DrawPublish(DrawMessageBox(D_INFO, "No DVD Drive Detected !!")); sleep(2); } DrawDispose(progBox); } }
static void mySDL_init(int w, int h) { if (!SDL_WasInit(SDL_INIT_VIDEO)) { int status=SDL_Init(SDL_INIT_VIDEO); if (status<0) fnError2("sdl-init-video failed.", SDL_GetError()); } // init ttf if (!TTF_WasInit()) { int status=TTF_Init(); if (status<0) fnError2("TTF_Init failed.", SDL_GetError()); } // FIXME the two following modern fonts do not work properly. //gFont=TTF_OpenFont("fonts/DroidSansMono.ttf", 12); //gFont=TTF_OpenFont("fonts/DejaVuSansMono.ttf", 12); gFont=TTF_OpenFont("fonts/fixedsys.fon", 12); adjust_cell_size_from_font(gFont); gFont_zh=TTF_OpenFont("fonts/wqy-zenhei.ttc", 14); // adjust wide font size according to cell size does not work well, for now. /* adjust_wide_font_from_cell_size("fonts/wqy-zenhei.ttc", gDisplay_cell_w, gDisplay_cell_h); */ if (gFont==NULL || gFont_zh==NULL) fnError2("fail open font cour.ttf/msyh.ttf", SDL_GetError()); int i; for (i=0; i<4; i++) { TTF_Font* gFont_tmp= TTF_OpenFont("fonts/fixedsys.fon", 10); if (gFont_tmp==NULL) fnError2("error load font ", SDL_GetError()); gDisplayFontNormal[i]=gFont_tmp; TTF_SetFontStyle(gFont_tmp, i); gDisplayFontWide[i]=gFont_zh; } gDisplayFontCur=gDisplayFontNormal[0]; myInfo_init(500,500); send_setcellsize_to_adapter(gDisplay_cell_w, gDisplay_cell_h); myDisplay_init(DISPLAY_W ,DISPLAY_H); mySDLrunning=1; /* info_push_messagef("cell_pix_w=%d, h=%d", gDisplay_cell_w, gDisplay_cell_h); */ SDL_Color color={0xff,0xff, 0xff,0xff}; init_font(&myInfoFont, gInfoRenderer, gFont, &color_black); //init_font(&myDisplayFont, gDisplayRenderer, gFont, &color_black); SDL_Color textColor={255, 255, 0, 0xff}; static char buf[300]="hello##"; int ii; for (ii=0; ii<256; ii++) buf[ii]=ii+1; buf[256]=0; SDL_Surface *textSurface=TTF_RenderText_Blended(gFont, buf, textColor); if (textSurface==NULL) fnWarn("textSurface==NULL"); text_hello=SDL_CreateTextureFromSurface(gInfoRenderer, textSurface); if (text_hello==NULL) fnWarn("text_hello==NULL"); SDL_FreeSurface(textSurface); }
/* main() * Program entry point. Initializes everything and runs the main loop. * Times are calculated and the frame rate is controlled here. */ int main( int argc, char* argv[] ) { program_state_t* PS = &program_state; game_state_t* GS = &game_state; sounds_t* snd = &(GS->sounds); PS->program_start_us = get_time(); init_sdl( PS, GS ); // Create window, load sounds init_sound( PS, GS ); // Load music, sounds, set volume init_font( PS ); // Load font init_opengl( PS ); // Load textures play_music( snd->music ); load_highscore( GS ); PS->current_time_us = PS->frame_start_us = get_time(); // Make the following look nice in debug info PS->game_start_us = PS->pause_since_us = PS->program_start_us - 1; PS->tick_fraction_s = -1; PS->highest_frame_time = 0; PS->lowest_frame_time = 99999999; PS->run_mode = RM_INTRO; while (PS->run_mode != RM_EXIT) { PS->current_time_us = get_time(); // Calculate how much time we need to waste for target FPS PS->delay_until_us = PS->current_time_us + (1000000 / TARGET_FPS) ; // Keep track of game time (handling pause) if ( !(PS->run_mode & (RM_PAUSE | RM_MAIN_MENU)) ) { PS->game_time_us = PS->current_time_us - PS->game_start_us ; } // Show intro after main menu idles for a while if (PS->run_mode == RM_MAIN_MENU) { if (PS->main_menu_since_us + MAIN_MENU_INTRO_SWITCH_TIME < get_time()) { PS->run_mode = RM_INTRO; } } // Handle user input process_event_queue( PS, GS ); // Let the universe live for a short moment if (PS->run_mode & (RM_RUNNING | RM_AFTER_LIFE)) { advance_simulation( PS, GS ); } // Display the current world status as game scene draw_frame( PS, GS ); #if LIMIT_FPS // Waste time until the next frame needs to be drawn while (get_time() < PS->delay_until_us) { #if LIMIT_FPS_USING_SDL_DELAY SDL_Delay( 1 ); #endif } #endif // Keep track of how many FPS we actually achieved PS->frame_time_us = get_time() - PS->frame_start_us; PS->highest_frame_time = max( PS->highest_frame_time, PS->frame_time_us ); PS->lowest_frame_time = min( PS->lowest_frame_time, PS->frame_time_us ); PS->frame_start_us = get_time(); PS->tick_fraction_s = (real_t)PS->frame_time_us / 1000000.0; save_frame_time( PS ); // For average FPS PS->average_frame_time = average_frame_time( PS ); } save_highscore( PS, GS ); glDeleteTextures( 1, &(PS->textures.background) ); glDeleteTextures( 1, &(PS->textures.digits) ); Mix_FreeChunk( snd->laser ); Mix_FreeChunk( snd->hit ); Mix_FreeChunk( snd->punch ); Mix_FreeChunk( snd->blast ); Mix_FreeChunk( snd->denied ); Mix_FreeChunk( snd->alarm ); Mix_FreeChunk( snd->blub ); Mix_FreeChunk( snd->computer_autofire ); Mix_FreeChunk( snd->computer_doubleshot ); Mix_FreeChunk( snd->computer_roundshot ); Mix_FreeChunk( snd->computer_danger ); Mix_FreeChunk( snd->computer_weaponlost ); Mix_FreeMusic( snd->music ); SDL_Quit(); // Will (allegedly) also free screen . return 0; }
void game :: init(){ pause_drawing=false; glines = VertexArray(Lines); conf.init("conf.cfg"); cfg=&conf; fps_coeff = 1.f/cfg->getfloat("timestep"); //srand((unsigned)time(0)); window.setKeyRepeatEnabled(false); wincenter.x=window.getSize().x/2; wincenter.y=window.getSize().y/2; winsize.x=window.getSize().x; winsize.y=window.getSize().y; window.setFramerateLimit(fps_coeff); if(cfg->getint("stick_left")) { Vec2i screen_resolution; cfg->SET(screen_resolution); #ifdef __APPLE__ screen_resolution=Vec2i(1280,800); #endif Vec2i windowpos(screen_resolution.x - winsize.x-10,25); cout << strfy(screen_resolution) << endl; cout << strfy(windowpos) << endl; window.setPosition(windowpos); } else window.setPosition(Vec2i(5,25)); { Vec2 cons_view_size; cfg->SET(cons_view_size); console_view.setSize(Vec2(cons_view_size.x*wsize.x,cons_view_size.y*wsize.y)); fixedview = window.getDefaultView(); mainview=fixedview; } wsize = winsize; wcenter = wincenter; float window_coeff = conf.getfloat("window_coeff"); if(window_coeff!=1.0) { Vec2u resized(winsize.x*window_coeff,winsize.y*window_coeff); window.setSize(resized); } bg = cfg->getcolor("background"); string path="yes/"; #ifdef __APPLE__ path = resourcePath()+path; #endif if(!cursor_tx.loadFromFile(path+"cursor4.png")) cout << "did not load cursor" << endl; cursor.setTexture(cursor_tx); cursor.setOrigin(3,3); window.setMouseCursorVisible(false); confpoint(c1,3,Color::Green); confpoint(c2,3,Color::Red); // fonts and f*****g globals init_font(); font1 = &ft; font2 = &ft2; charsize=chsz; charsize2=chsz2; // console console = new sfconsole; console->numlines=conf.getint("numlines"); console->init(); cons=console; draw_console = true; labs=new labels; labs->pos=Vec2(15,winsize.y-30); lbs=&(labs->strings); win=&window; add_symbol_to_lambdas(); if(cfg->getint("use_menu")) { menu_loop(); } else { init_gameobj(); loop(); } }
void options(char ip[]) { int quit = 0; int menu_choice = 0; //fps struct timer_t2 fps; init_options(); init_font(); //wait for user to continue or exit while( quit != 1 ) { //Start the frame timer timer_start(&fps); //While there are events to handle while( SDL_PollEvent( &event ) ) { if( event.type == SDL_QUIT ) { //exit clean_up(); exit(0); } if( event.type == SDL_KEYDOWN ) { switch(event.key.keysym.sym) { case SDLK_ESCAPE: quit = 1; break; } } mouse_over_options(event.button.x, event.button.y); if( event.type == SDL_MOUSEBUTTONDOWN) { switch(event.button.button) { case SDL_BUTTON_LEFT: press_options(event.button.x, event.button.y); break; } } if( event.type == SDL_MOUSEBUTTONUP) { switch(event.button.button) { case SDL_BUTTON_LEFT: menu_choice = press_options(event.button.x, event.button.y); break; } } switch(menu_choice) { case 1: handle_input(event,ip); printf("String in graphics.c (%s)\n",ip); break; case 2: quit = 1; printf("Försöker bryta ut ur options\n"); break; default: break; } } apply_letter(ip); apply_texture(); startDraw(); //draw menu drawOptions(SCREEN_WIDTH, SCREEN_HEIGHT); drawBack(); endDraw(); if( timer_get_ticks(&fps) < 1000 / FRAMES_PER_SECOND ) { //delay the as much time as we need to get desired frames per second SDL_Delay( ( 1000 / FRAMES_PER_SECOND ) - timer_get_ticks(&fps) ); } } }