void graphicst::prepare_graphics(string &src_dir) { if(!init.display.flag.has_flag(INIT_DISPLAY_FLAG_USE_GRAPHICS))return; texture.clean(); //GET READY TO LOAD svector<char *> processfilename; long f; textlinesst setuplines; char str[400]; //LOAD THE OBJECT FILES UP INTO MEMORY //MUST INSURE THAT THEY ARE LOADED IN THE PROPER ORDER, IN CASE THEY REFER TO EACH OTHER string chk=src_dir; chk+="graphics/graphics_*"; #ifdef WIN32 chk+=".*"; #endif find_files_by_pattern_with_exception(chk.c_str(),processfilename,"text"); string chktype="GRAPHICS"; for(f=0;f<processfilename.size();f++) { strcpy(str,src_dir.c_str()); strcat(str,"graphics/"); strcat(str,processfilename[f]); setuplines.load_raw_to_lines(str); errorlog_prefix="*** Error(s) found in the file \""; errorlog_prefix+=str; errorlog_prefix+='\"'; process_object_lines(setuplines,chktype,src_dir); errorlog_prefix.clear(); delete[] processfilename[f]; } processfilename.clear(); enabler.reset_textures(); }
void render_things() { //GRAB CURRENT SCREEN AT THE END OF THE LIST viewscreenst *currentscreen=&gview.view; while(currentscreen->child!=NULL)currentscreen=currentscreen->child; //NO INTERFACE LEFT, LEAVE if(currentscreen==&gview.view)return; if(currentscreen->breakdownlevel==INTERFACE_BREAKDOWN_NONE) { currentscreen->render(); } else gps.erasescreen(); // Render REC when recording macros. Definitely want this screen-specific. Or do we? const Time now = SDL_GetTicks(); if (enabler.is_recording() && now % 1000 > 500) { gps.locate(0, 20); gps.changecolor(4,1,1); gps.addst("REC"); } // Render PLAY when playing a macro if (enabler.is_macro_playing() && now % 1000 <= 500) { gps.locate(0,20); gps.changecolor(2,1,1); gps.addst("PLAY"); } // Render # <i> when building a repetition prefix if (enabler.prefix_building()) { gps.locate(0,20); gps.changecolor(3,1,1); gps.addst("#" + enabler.prefix()); } if (gps.display_frames) { ostringstream fps_stream; fps_stream << "FPS: " << setw(3) << enabler.calculate_fps() << " (" << enabler.calculate_gfps() << ")"; string fps = fps_stream.str(); gps.changecolor(7,3,1); static gps_locator fps_locator(0, 25); fps_locator(fps.size()); gps.addst(fps); } }
int main (int argc, char* argv[]) { #ifdef unix setlocale(LC_ALL, ""); #endif #if !defined(__APPLE__) && defined(unix) bool gtk_ok = false; if (getenv("DISPLAY")) gtk_ok = gtk_init_check(&argc, &argv); #endif // Initialise minimal SDL subsystems. int retval = SDL_Init(SDL_INIT_TIMER); // Report failure? if (retval != 0) { report_error("SDL initialization failure", SDL_GetError()); return false; } enabler.renderer_threadid = SDL_ThreadID(); // Spawn simulation thread SDL_CreateThread(call_loop, NULL); init.begin(); // Load init.txt settings #if !defined(__APPLE__) && defined(unix) if (!gtk_ok && !init.display.flag.has_flag(INIT_DISPLAY_FLAG_TEXT)) { puts("Display not found and PRINT_MODE not set to TEXT, aborting."); exit(EXIT_FAILURE); } if (init.display.flag.has_flag(INIT_DISPLAY_FLAG_TEXT) && init.display.flag.has_flag(INIT_DISPLAY_FLAG_USE_GRAPHICS)) { puts("Graphical tiles are not compatible with text output, sorry"); exit(EXIT_FAILURE); } #endif // Initialize video, if we /use/ video retval = SDL_InitSubSystem(init.display.flag.has_flag(INIT_DISPLAY_FLAG_TEXT) ? 0 : SDL_INIT_VIDEO); if (retval != 0) { report_error("SDL initialization failure", SDL_GetError()); return false; } #ifdef linux if (!init.media.flag.has_flag(INIT_MEDIA_FLAG_SOUND_OFF)) { // Initialize OpenAL if (!musicsound.initsound()) { puts("Initializing OpenAL failed, no sound will be played"); init.media.flag.add_flag(INIT_MEDIA_FLAG_SOUND_OFF); } } #endif #ifdef WIN32 // Attempt to get as good a timer as possible int ms = 1; while (timeBeginPeriod(ms) != TIMERR_NOERROR) ms++; #endif // Load keyboard map keybinding_init(); enabler.load_keybindings("data/init/interface.txt"); string cmdLine; for (int i = 1; i < argc; ++i) { char *option = argv[i]; string opt=option; if(opt.length()>=1) { //main removes quotes, unlike the winmain version, so it has to be rebuilt if(opt[0]=='-') { cmdLine += opt; cmdLine += " "; } else { cmdLine += "\""; cmdLine += opt; cmdLine += "\""; cmdLine += " "; } } } int result = enabler.loop(cmdLine); SDL_Quit(); #ifdef WIN32 timeEndPeriod(ms); #endif return result; }
int call_loop(void *dummy) { enabler.async_loop(); return 0; }
void enablerst::eventLoop_SDL() { SDL_Event event; const SDL_Surface *screen = SDL_GetVideoSurface(); Uint32 mouse_lastused = 0; SDL_ShowCursor(SDL_DISABLE); // Initialize the grid renderer->resize(screen->w, screen->h); while (loopvar) { Uint32 now = SDL_GetTicks(); bool paused_loop = false; // Check for zoom commands zoom_commands zoom; while (async_zoom.try_read(zoom)) { if (overridden_grid_sizes.size()) continue; // No zooming in movies if (!paused_loop) { pause_async_loop(); paused_loop = true; } if (zoom == zoom_fullscreen) renderer->set_fullscreen(); else renderer->zoom(zoom); } // Check for SDL events while (SDL_PollEvent(&event)) { // Make sure mainloop isn't running while we're processing input if (!paused_loop) { pause_async_loop(); paused_loop = true; } // Handle SDL events switch (event.type) { case SDL_KEYDOWN: // Disable mouse if it's been long enough if (mouse_lastused + 5000 < now) { if(init.input.flag.has_flag(INIT_INPUT_FLAG_MOUSE_PICTURE)) { // hide the mouse picture // enabler.set_tile(0, TEXTURE_MOUSE, enabler.mouse_x, enabler.mouse_y); } SDL_ShowCursor(SDL_DISABLE); } case SDL_KEYUP: case SDL_QUIT: enabler.add_input(event, now); break; case SDL_MOUSEBUTTONDOWN: case SDL_MOUSEBUTTONUP: if (!init.input.flag.has_flag(INIT_INPUT_FLAG_MOUSE_OFF)) { int isdown = (event.type == SDL_MOUSEBUTTONDOWN); if (event.button.button == SDL_BUTTON_LEFT) { enabler.mouse_lbut = isdown; enabler.mouse_lbut_down = isdown; if (!isdown) enabler.mouse_lbut_lift = 0; } else if (event.button.button == SDL_BUTTON_RIGHT) { enabler.mouse_rbut = isdown; enabler.mouse_rbut_down = isdown; if (!isdown) enabler.mouse_rbut_lift = 0; } else enabler.add_input(event, now); } break; case SDL_MOUSEMOTION: // Deal with the mouse hiding bit mouse_lastused = now; if(init.input.flag.has_flag(INIT_INPUT_FLAG_MOUSE_PICTURE)) { // turn on mouse picture // enabler.set_tile(gps.tex_pos[TEXTURE_MOUSE], TEXTURE_MOUSE,enabler.mouse_x, enabler.mouse_y); } else { SDL_ShowCursor(SDL_ENABLE); } break; case SDL_ACTIVEEVENT: enabler.clear_input(); if (event.active.state & SDL_APPACTIVE) { if (event.active.gain) { enabler.flag|=ENABLERFLAG_RENDER; gps.force_full_display_count++; } } break; case SDL_VIDEOEXPOSE: gps.force_full_display_count++; enabler.flag|=ENABLERFLAG_RENDER; break; case SDL_VIDEORESIZE: if (is_fullscreen()); //errorlog << "Caught resize event in fullscreen??\n"; else { //gamelog << "Resizing window to " << event.resize.w << "x" << event.resize.h << endl << flush; renderer->resize(event.resize.w, event.resize.h); } break; } // switch (event.type) } //while have event // Update mouse state if (!init.input.flag.has_flag(INIT_INPUT_FLAG_MOUSE_OFF)) { int mouse_x = -1, mouse_y = -1, mouse_state; // Check whether the renderer considers this valid input or not, and write it to gps if ((SDL_GetAppState() & SDL_APPMOUSEFOCUS) && renderer->get_mouse_coords(mouse_x, mouse_y)) { mouse_state = 1; } else { mouse_state = 0; } if (mouse_x != gps.mouse_x || mouse_y != gps.mouse_y || mouse_state != enabler.tracking_on) { // Pause rendering loop and update values if (!paused_loop) { pause_async_loop(); paused_loop = true; } enabler.tracking_on = mouse_state; gps.mouse_x = mouse_x; gps.mouse_y = mouse_y; } } if (paused_loop) unpause_async_loop(); do_frame(); /* #if !defined(NO_FMOD) // Call FMOD::System.update(). Manages a bunch of sound stuff. musicsound.update(); #endif */ } }
Either<texture_fullid,texture_ttfid> renderer::screen_to_texid(int x, int y) { const int tile = x * gps.dimy + y; const unsigned char *s = screen + tile*4; struct texture_fullid ret; int ch; int bold; int fg; int bg; // TTF text does not get the full treatment. if (s[3] == GRAPHICSTYPE_TTF) { texture_ttfid texpos = *((unsigned int *)s) & 0xffffff; return Either<texture_fullid,texture_ttfid>(texpos); } else if (s[3] == GRAPHICSTYPE_TTFCONT) { // TTFCONT means this is a tile that does not have TTF anchored on it, but is covered by TTF. // Since this may actually be stale information, we'll draw it as a blank space, ch = 32; fg = bg = bold = 0; } else { // Otherwise, it's a normal (graphical?) tile. ch = s[0]; bold = (s[3] != 0) * 8; fg = (s[1] + bold) % 16; bg = s[2] % 16; } static bool use_graphics = init.display.flag.has_flag(INIT_DISPLAY_FLAG_USE_GRAPHICS); if (use_graphics) { const long texpos = screentexpos[tile]; const char addcolor = screentexpos_addcolor[tile]; const unsigned char grayscale = screentexpos_grayscale[tile]; const unsigned char cf = screentexpos_cf[tile]; const unsigned char cbr = screentexpos_cbr[tile]; if (texpos) { ret.texpos = texpos; if (grayscale) { ret.r = enabler.ccolor[cf][0]; ret.g = enabler.ccolor[cf][1]; ret.b = enabler.ccolor[cf][2]; ret.br = enabler.ccolor[cbr][0]; ret.bg = enabler.ccolor[cbr][1]; ret.bb = enabler.ccolor[cbr][2]; } else if (addcolor) { goto use_ch; } else { ret.r = ret.g = ret.b = 1; ret.br = ret.bg = ret.bb = 0; } goto skip_ch; } } ret.texpos = enabler.is_fullscreen() ? init.font.large_font_texpos[ch] : init.font.small_font_texpos[ch]; use_ch: ret.r = enabler.ccolor[fg][0]; ret.g = enabler.ccolor[fg][1]; ret.b = enabler.ccolor[fg][2]; ret.br = enabler.ccolor[bg][0]; ret.bg = enabler.ccolor[bg][1]; ret.bb = enabler.ccolor[bg][2]; skip_ch: return Either<texture_fullid,texture_ttfid>(ret); }
Either<texture_fullid,texture_ttfid> renderer::screen_to_texid(int x, int y) { const int tile = x * gps.dimy + y; const unsigned char *s = screen + tile*4; // TTF text does not get the full treatment. if (s[3] == GRAPHICSTYPE_TTF) { texture_ttfid texpos = (s[0] << 16) | (s[1] << 8) | s[2]; return Either<texture_fullid,texture_ttfid>(texpos); } else if (s[3] == GRAPHICSTYPE_TTFCONT) return Either<texture_fullid,texture_ttfid>(0); // Otherwise, it's a normal (graphical?) tile. struct texture_fullid ret; const int ch = s[0]; const int bold = (s[3] != 0) * 8; const int fg = (s[1] + bold) % 16; const int bg = s[2] % 16; static bool use_graphics = init.display.flag.has_flag(INIT_DISPLAY_FLAG_USE_GRAPHICS); if (use_graphics) { const long texpos = screentexpos[tile]; const char addcolor = screentexpos_addcolor[tile]; const unsigned char grayscale = screentexpos_grayscale[tile]; const unsigned char cf = screentexpos_cf[tile]; const unsigned char cbr = screentexpos_cbr[tile]; if (texpos) { ret.texpos = texpos; if (grayscale) { ret.r = enabler.ccolor[cf][0]; ret.g = enabler.ccolor[cf][1]; ret.b = enabler.ccolor[cf][2]; ret.br = enabler.ccolor[cbr][0]; ret.bg = enabler.ccolor[cbr][1]; ret.bb = enabler.ccolor[cbr][2]; } else if (addcolor) { goto use_ch; } else { ret.r = ret.g = ret.b = 1; ret.br = ret.bg = ret.bb = 0; } goto skip_ch; } } ret.texpos = enabler.is_fullscreen() ? init.font.large_font_texpos[ch] : init.font.small_font_texpos[ch]; use_ch: ret.r = enabler.ccolor[fg][0]; ret.g = enabler.ccolor[fg][1]; ret.b = enabler.ccolor[fg][2]; ret.br = enabler.ccolor[bg][0]; ret.bg = enabler.ccolor[bg][1]; ret.bb = enabler.ccolor[bg][2]; skip_ch: return Either<texture_fullid,texture_ttfid>(ret); }