Line data    Source code

       1              : /* control.cpp: misc engine utilities for program control
       2              :  *
       3              :  * control.cpp defines a handful of useful utilities for creating a useful program
       4              :  * using the library, including logging (to file), program crash handling, engine
       5              :  * timestate information, and engine version information
       6              :  */
       7              : #include "../libprimis-headers/cube.h"
       8              : #include "../../shared/stream.h"
       9              : 
      10              : #include "console.h"
      11              : #include "control.h"
      12              : #include "menus.h"
      13              : 
      14              : #include "render/renderwindow.h"
      15              : 
      16              : namespace
      17              : {
      18              :     // logging
      19              :     constexpr int logstrlen = 512;
      20              : 
      21          698 :     void writelog(FILE *file, const char *buf)
      22              :     {
      23              :         static uchar ubuf[logstrlen];
      24          698 :         size_t len = std::strlen(buf),
      25          698 :                carry = 0;
      26         1395 :         while(carry < len)
      27              :         {
      28          697 :             size_t numu = encodeutf8(ubuf, sizeof(ubuf)-1, &(reinterpret_cast<const uchar*>(buf))[carry], len - carry, &carry);
      29          697 :             if(carry >= len)
      30              :             {
      31          697 :                 ubuf[numu++] = '\n';
      32              :             }
      33          697 :             fwrite(ubuf, 1, numu, file);
      34              :         }
      35          698 :     }
      36              : 
      37          698 :     void writelogv(FILE *file, const char *fmt, va_list args)
      38              :     {
      39              :         static char buf[logstrlen];
      40          698 :         vformatstring(buf, fmt, args, sizeof(buf));
      41          698 :         writelog(file, buf);
      42          698 :     }
      43              : 
      44              :     int clockrealbase = 0,
      45              :         clockvirtbase = 0;
      46              : 
      47            0 :     void clockreset()
      48              :     {
      49            0 :         clockrealbase = SDL_GetTicks();
      50            0 :         clockvirtbase = totalmillis;
      51            0 :     }
      52              : }
      53              : 
      54              : 
      55              : bool inbetweenframes = false,
      56              :      renderedframe = true;
      57              : 
      58              : FILE *logfile = nullptr; //used in iengine.h
      59              : 
      60          698 : FILE *getlogfile()
      61              : {
      62              : #ifdef WIN32
      63              :     return logfile;
      64              : #else
      65          698 :     return logfile ? logfile : stdout;
      66              : #endif
      67              : }
      68              : 
      69              : /* initsdl
      70              :  * calls the SDL 2 init procedure
      71              :  * returns false on failure, true on success
      72              :  */
      73            0 : bool initsdl()
      74              : {
      75            0 :     return (SDL_Init(SDL_INIT_TIMER|SDL_INIT_VIDEO|SDL_INIT_AUDIO|SDL_INIT_GAMECONTROLLER) < 0 ? false : true);
      76              : }
      77              : 
      78          698 : void logoutfv(const char *fmt, va_list args, FILE *f)
      79              : {
      80          698 :     if(f)
      81              :     {
      82          698 :         writelogv(f, fmt, args);
      83              :     }
      84          698 : }
      85              : 
      86          698 : void logoutf(const char *fmt, ...)
      87              : {
      88              :     va_list args;
      89          698 :     va_start(args, fmt);
      90          698 :     logoutfv(fmt, args);
      91          698 :     va_end(args);
      92          698 : }
      93              : 
      94              : //error handling
      95              : 
      96            0 : void fatal(const char *s, ...)    // failure exit
      97              : {
      98              :     static int errors = 0;
      99            0 :     errors++;
     100              : 
     101            0 :     if(errors <= 2) // print up to one extra recursive error
     102              :     {
     103            0 :         DEFV_FORMAT_STRING(msg,s,s);
     104            0 :         logoutf("%s", msg);
     105              : 
     106            0 :         if(errors <= 1) // avoid recursion
     107              :         {
     108            0 :             if(SDL_WasInit(SDL_INIT_VIDEO))
     109              :             {
     110            0 :                 SDL_ShowCursor(SDL_TRUE);
     111            0 :                 SDL_SetRelativeMouseMode(SDL_FALSE);
     112            0 :                 if(screen)
     113              :                 {
     114            0 :                     SDL_SetWindowGrab(screen, SDL_FALSE);
     115              :                 }
     116            0 :                 cleargamma();
     117              :             }
     118            0 :             SDL_Quit();
     119            0 :             SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "Libprimis engine fatal error", msg, nullptr);
     120              :         }
     121              :     }
     122              : 
     123            0 :     exit(EXIT_FAILURE);
     124              : }
     125              : 
     126              : int curtime = 0,
     127              :     lastmillis = 1,
     128              :     elapsedtime = 0,
     129              :     totalmillis = 1;
     130              : 
     131              : dynent *player = nullptr;
     132              : 
     133              : int initing = Init_Not;
     134              : 
     135            1 : bool initwarning(const char *desc, int level, int type)
     136              : {
     137            1 :     if(initing < level)
     138              :     {
     139            1 :         addchange(desc, type);
     140            1 :         return true;
     141              :     }
     142            0 :     return false;
     143              : }
     144              : 
     145            0 : VARFP(clockerror, 990000, 1000000, 1010000, clockreset());
     146            0 : VARFP(clockfix, 0, 0, 1, clockreset());
     147              : 
     148            0 : int getclockmillis()
     149              : {
     150            0 :     int millis = SDL_GetTicks() - clockrealbase;
     151            0 :     if(clockfix)
     152              :     {
     153            0 :         millis = static_cast<int>(millis*(static_cast<double>(clockerror)/1000000));
     154              :     }
     155            0 :     millis += clockvirtbase;
     156            0 :     return std::max(millis, totalmillis);
     157              : }
     158              : 
     159              : //identification info about engine
     160            0 : std::string enginestr()
     161              : {
     162            0 :     return "Libprimis v0.50a";
     163              : }
     164              : 
     165            0 : std::string enginebuilddate()
     166              : {
     167            0 :     return __DATE__;
     168              : }