]> de.git.xonotic.org Git - xonotic/darkplaces.git/blobdiff - sys_linux.c
new cvar sys_useclockgettime (default 0) that makes DP use clock_gettime as time...
[xonotic/darkplaces.git] / sys_linux.c
index eb2993cb71e509acf62a7f2c3028a5ea01c8679f..0ddf3224d68d49f499d26588bea10cceed3e5412 100644 (file)
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdarg.h>
+#include "quakedef.h"
 
-#include <sys/types.h>
-#include <sys/stat.h>
+#ifdef WIN32
+#include <io.h>
+#include "conio.h"
+#else
 #include <unistd.h>
 #include <fcntl.h>
-
-#include <signal.h>
-#include <limits.h>
-#include <sys/ipc.h>
-#include <sys/shm.h>
 #include <sys/time.h>
-#include <sys/wait.h>
-#include <sys/mman.h>
-#include <string.h>
-#include <ctype.h>
-#include <errno.h>
 #include <time.h>
+#endif
+
+#include <signal.h>
 
-#include "quakedef.h"
 
-char *basedir = ".";
-#if CACHEENABLE
-char *cachedir = "/tmp";
+#ifdef WIN32
+cvar_t sys_usetimegettime = {CVAR_SAVE, "sys_usetimegettime", "1", "use windows timeGetTime function (which has issues on some motherboards) for timing rather than QueryPerformanceCounter timer (which has issues on multicore/multiprocessor machines and processors which are designed to conserve power)"};
+#else
+# ifndef MACOSX
+cvar_t sys_useclockgettime = {CVAR_SAVE, "sys_useclockgettime", "0", "use POSIX clock_gettime function (which has issues if the system clock speed is far off, as it can't get fixed by NTP) for timing rather than gettimeofday (which has issues if the system time is stepped by ntpdate, or apparently on some Xen installations)"};
+# endif
 #endif
 
+
+
 // =======================================================================
 // General routines
 // =======================================================================
-
-void Sys_DebugNumber(int y, int val)
+void Sys_Shutdown (void)
 {
-}
-
-void Sys_Quit (void)
-{
-       Host_Shutdown();
+#ifndef WIN32
        fcntl (0, F_SETFL, fcntl (0, F_GETFL, 0) & ~FNDELAY);
+#endif
        fflush(stdout);
-       exit(0);
 }
 
-void Sys_Error (char *error, ...)
+void Sys_Error (const char *error, ...)
 {
        va_list argptr;
-       char string[1024];
+       char string[MAX_INPUTLINE];
 
 // change stdin to non blocking
+#ifndef WIN32
        fcntl (0, F_SETFL, fcntl (0, F_GETFL, 0) & ~FNDELAY);
+#endif
 
        va_start (argptr,error);
-       vsprintf (string,error,argptr);
+       dpvsnprintf (string, sizeof (string), error, argptr);
        va_end (argptr);
-       fprintf(stderr, "Error: %s\n", string);
+
+       Con_Printf ("Quake Error: %s\n", string);
 
        Host_Shutdown ();
        exit (1);
-
 }
 
-void Sys_Warn (char *warning, ...)
+void Sys_PrintToTerminal(const char *text)
 {
-       va_list argptr;
-       char string[1024];
-
-       va_start (argptr,warning);
-       vsprintf (string,warning,argptr);
-       va_end (argptr);
-       fprintf(stderr, "Warning: %s", string);
-}
-
-/*
-============
-Sys_FileTime
-
-returns -1 if not present
-============
-*/
-int Sys_FileTime (char *path)
-{
-       struct stat buf;
-
-       if (stat (path,&buf) == -1)
-               return -1;
-
-       return buf.st_mtime;
-}
-
-
-void Sys_mkdir (char *path)
-{
-       mkdir (path, 0777);
-}
-
-int Sys_FileOpenRead (char *path, int *handle)
-{
-       int h;
-       struct stat fileinfo;
-
-       h = open (path, O_RDONLY, 0666);
-       *handle = h;
-       if (h == -1)
-               return -1;
-
-       if (fstat (h,&fileinfo) == -1)
-               Sys_Error ("Error fstating %s", path);
-
-       return fileinfo.st_size;
-}
-
-int Sys_FileOpenWrite (char *path)
-{
-       int handle;
-
-       umask (0);
-
-       handle = open(path,O_RDWR | O_CREAT | O_TRUNC, 0666);
-
-       if (handle == -1)
+#ifndef WIN32
+       // BUG: for some reason, NDELAY also affects stdout (1) when used on stdin (0).
+       int origflags = fcntl (1, F_GETFL, 0);
+       fcntl (1, F_SETFL, origflags & ~FNDELAY);
+#endif
+       while(*text)
        {
-               Con_Printf("Sys_FileOpenWrite: Error opening %s: %s", path, strerror(errno));
-               return 0;
+               int written = (int)write(1, text, (int)strlen(text));
+               if(written <= 0)
+                       break; // sorry, I cannot do anything about this error - without an output
+               text += written;
        }
-
-       return handle;
-}
-
-int Sys_FileWrite (int handle, void *src, int count)
-{
-       return write (handle, src, count);
-}
-
-void Sys_FileClose (int handle)
-{
-       close (handle);
-}
-
-void Sys_FileSeek (int handle, int position)
-{
-       lseek (handle, position, SEEK_SET);
-}
-
-int Sys_FileRead (int handle, void *dest, int count)
-{
-       return read (handle, dest, count);
-}
-
-void Sys_DebugLog(char *file, char *fmt, ...)
-{
-       va_list argptr;
-       static char data[1024];
-       int fd;
-
-       va_start(argptr, fmt);
-       vsprintf(data, fmt, argptr);
-       va_end(argptr);
-       fd = open(file, O_WRONLY | O_CREAT | O_APPEND, 0666);
-       write(fd, data, strlen(data));
-       close(fd);
+#ifndef WIN32
+       fcntl (1, F_SETFL, origflags);
+#endif
+       //fprintf(stdout, "%s", text);
 }
 
 double Sys_DoubleTime (void)
@@ -166,11 +79,80 @@ double Sys_DoubleTime (void)
        static int first = true;
        static double oldtime = 0.0, curtime = 0.0;
        double newtime;
-       struct timeval tp;
-
-       gettimeofday(&tp, NULL);
-
-       newtime = (double) tp.tv_sec + tp.tv_usec / 1000000.0;
+#ifdef WIN32
+#include <mmsystem.h>
+       // LordHavoc: note to people modifying this code, DWORD is specifically defined as an unsigned 32bit number, therefore the 65536.0 * 65536.0 is fine.
+       if (sys_usetimegettime.integer)
+       {
+               static int firsttimegettime = true;
+               // timeGetTime
+               // platform:
+               // Windows 95/98/ME/NT/2000/XP
+               // features:
+               // reasonable accuracy (millisecond)
+               // issues:
+               // wraps around every 47 days or so (but this is non-fatal to us, odd times are rejected, only causes a one frame stutter)
+
+               // make sure the timer is high precision, otherwise different versions of windows have varying accuracy
+               if (firsttimegettime)
+               {
+                       timeBeginPeriod (1);
+                       firsttimegettime = false;
+               }
+
+               newtime = (double) timeGetTime () / 1000.0;
+       }
+       else
+       {
+               // QueryPerformanceCounter
+               // platform:
+               // Windows 95/98/ME/NT/2000/XP
+               // features:
+               // very accurate (CPU cycles)
+               // known issues:
+               // does not necessarily match realtime too well (tends to get faster and faster in win98)
+               // wraps around occasionally on some platforms (depends on CPU speed and probably other unknown factors)
+               double timescale;
+               LARGE_INTEGER PerformanceFreq;
+               LARGE_INTEGER PerformanceCount;
+
+               if (!QueryPerformanceFrequency (&PerformanceFreq))
+               {
+                       Con_Printf ("No hardware timer available\n");
+                       // fall back to timeGetTime
+                       Cvar_SetValueQuick(&sys_usetimegettime, true);
+                       return Sys_DoubleTime();
+               }
+               QueryPerformanceCounter (&PerformanceCount);
+
+               #ifdef __BORLANDC__
+               timescale = 1.0 / ((double) PerformanceFreq.u.LowPart + (double) PerformanceFreq.u.HighPart * 65536.0 * 65536.0);
+               newtime = ((double) PerformanceCount.u.LowPart + (double) PerformanceCount.u.HighPart * 65536.0 * 65536.0) * timescale;
+               #else
+               timescale = 1.0 / ((double) PerformanceFreq.LowPart + (double) PerformanceFreq.HighPart * 65536.0 * 65536.0);
+               newtime = ((double) PerformanceCount.LowPart + (double) PerformanceCount.HighPart * 65536.0 * 65536.0) * timescale;
+               #endif
+       }
+#else
+# ifndef MACOSX
+       if (sys_useclockgettime.integer)
+       {
+               struct timespec ts;
+#  ifdef SUNOS
+               clock_gettime(CLOCK_HIGHRES, &ts);
+#  else
+               clock_gettime(CLOCK_MONOTONIC, &ts);
+#  endif
+               newtime = (double) ts.tv_sec + ts.tv_nsec / 1000000000.0;
+       }
+       else
+# endif
+       {
+               struct timeval tp;
+               gettimeofday(&tp, NULL);
+               newtime = (double) tp.tv_sec + tp.tv_usec / 1000000.0;
+       }
+#endif
 
        if (first)
        {
@@ -191,84 +173,107 @@ double Sys_DoubleTime (void)
        return curtime;
 }
 
-// =======================================================================
-// Sleeps for microseconds
-// =======================================================================
-
-static volatile int oktogo;
-
-void alarm_handler(int x)
-{
-       oktogo=1;
-}
-
-void floating_point_exception_handler(int whatever)
-{
-       signal(SIGFPE, floating_point_exception_handler);
-}
-
 char *Sys_ConsoleInput(void)
 {
-       static char text[256];
-       int len;
-       fd_set fdset;
-       struct timeval timeout;
-
        if (cls.state == ca_dedicated)
        {
+               static char text[MAX_INPUTLINE];
+               static unsigned int len = 0;
+#ifdef WIN32
+               int c;
+
+               // read a line out
+               while (_kbhit ())
+               {
+                       c = _getch ();
+                       if (c == '\r')
+                       {
+                               text[len] = '\0';
+                               putch ('\n');
+                               len = 0;
+                               return text;
+                       }
+                       if (c == '\b')
+                       {
+                               if (len)
+                               {
+                                       putch (c);
+                                       putch (' ');
+                                       putch (c);
+                                       len--;
+                               }
+                               continue;
+                       }
+                       if (len < sizeof (text) - 1)
+                       {
+                               putch (c);
+                               text[len] = c;
+                               len++;
+                       }
+               }
+#else
+               fd_set fdset;
+               struct timeval timeout;
                FD_ZERO(&fdset);
                FD_SET(0, &fdset); // stdin
                timeout.tv_sec = 0;
                timeout.tv_usec = 0;
-               if (select (1, &fdset, NULL, NULL, &timeout) == -1 || !FD_ISSET(0, &fdset))
-                       return NULL;
-
-               len = read (0, text, sizeof(text));
-               if (len < 1)
-                       return NULL;
-               text[len-1] = 0;    // rip off the /n and terminate
-
-               return text;
+               if (select (1, &fdset, NULL, NULL, &timeout) != -1 && FD_ISSET(0, &fdset))
+               {
+                       len = read (0, text, sizeof(text));
+                       if (len >= 1)
+                       {
+                               // rip off the \n and terminate
+                               text[len-1] = 0;
+                               return text;
+                       }
+               }
+#endif
        }
        return NULL;
 }
 
-void Sys_Sleep(void)
+void Sys_Sleep(int microseconds)
 {
-       usleep(1);
+#ifdef WIN32
+       Sleep(microseconds / 1000);
+#else
+       usleep(microseconds);
+#endif
 }
 
-int main (int c, char **v)
+char *Sys_GetClipboardData (void)
 {
-       double frameoldtime, framenewtime;
+       return NULL;
+}
 
-       signal(SIGFPE, SIG_IGN);
+void Sys_InitConsole (void)
+{
+}
 
-       memset(&host_parms, 0, sizeof(host_parms));
+void Sys_Init_Commands (void)
+{
+#ifdef WIN32
+       Cvar_RegisterVariable(&sys_usetimegettime);
+#else
+# ifndef MACOSX
+       Cvar_RegisterVariable(&sys_useclockgettime);
+# endif
+#endif
+}
 
-       COM_InitArgv(c, v);
-       host_parms.argc = com_argc;
-       host_parms.argv = com_argv;
+int main (int argc, char **argv)
+{
+       signal(SIGFPE, SIG_IGN);
 
-       host_parms.basedir = basedir;
+       com_argc = argc;
+       com_argv = (const char **)argv;
 
+#ifndef WIN32
        fcntl(0, F_SETFL, fcntl (0, F_GETFL, 0) | FNDELAY);
+#endif
 
-       Sys_Shared_EarlyInit();
-
-       Host_Init();
-
-       Sys_Shared_LateInit();
-
-       frameoldtime = Sys_DoubleTime () - 0.1;
-       while (1)
-       {
-               // find time spent rendering last frame
-               framenewtime = Sys_DoubleTime ();
-
-               Host_Frame (framenewtime - frameoldtime);
+       Host_Main();
 
-               frameoldtime = framenewtime;
-       }
        return 0;
 }