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);
}
