another int cast for that patch
[divverent/darkplaces.git] / sys_linux.c
1
2 #ifdef WIN32
3 #include <io.h>
4 #include "conio.h"
5 #else
6 #include <unistd.h>
7 #include <fcntl.h>
8 #include <sys/time.h>
9 #endif
10
11 #include <signal.h>
12
13 #include "quakedef.h"
14
15
16 #ifdef WIN32
17 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)"};
18 #endif
19
20
21
22 // =======================================================================
23 // General routines
24 // =======================================================================
25 void Sys_Shutdown (void)
26 {
27 #ifndef WIN32
28         fcntl (0, F_SETFL, fcntl (0, F_GETFL, 0) & ~FNDELAY);
29 #endif
30         fflush(stdout);
31 }
32
33 void Sys_Error (const char *error, ...)
34 {
35         va_list argptr;
36         char string[MAX_INPUTLINE];
37
38 // change stdin to non blocking
39 #ifndef WIN32
40         fcntl (0, F_SETFL, fcntl (0, F_GETFL, 0) & ~FNDELAY);
41 #endif
42
43         va_start (argptr,error);
44         dpvsnprintf (string, sizeof (string), error, argptr);
45         va_end (argptr);
46
47         Con_Printf ("Quake Error: %s\n", string);
48
49         Host_Shutdown ();
50         exit (1);
51 }
52
53 void Sys_PrintToTerminal(const char *text)
54 {
55 #ifndef WIN32
56         // BUG: for some reason, NDELAY also affects stdout (1) when used on stdin (0).
57         int origflags = fcntl (1, F_GETFL, 0);
58         fcntl (1, F_SETFL, origflags & ~FNDELAY);
59 #endif
60         while(*text)
61         {
62                 int written = (int)write(1, text, (int)strlen(text));
63                 if(written <= 0)
64                         break; // sorry, I cannot do anything about this error - without an output
65                 text += written;
66         }
67 #ifndef WIN32
68         fcntl (1, F_SETFL, origflags);
69 #endif
70         //fprintf(stdout, "%s", text);
71 }
72
73 double Sys_DoubleTime (void)
74 {
75         static int first = true;
76         static double oldtime = 0.0, curtime = 0.0;
77         double newtime;
78 #ifdef WIN32
79         // LordHavoc: note to people modifying this code, DWORD is specifically defined as an unsigned 32bit number, therefore the 65536.0 * 65536.0 is fine.
80         if (sys_usetimegettime.integer)
81         {
82                 static int firsttimegettime = true;
83                 // timeGetTime
84                 // platform:
85                 // Windows 95/98/ME/NT/2000/XP
86                 // features:
87                 // reasonable accuracy (millisecond)
88                 // issues:
89                 // wraps around every 47 days or so (but this is non-fatal to us, odd times are rejected, only causes a one frame stutter)
90
91                 // make sure the timer is high precision, otherwise different versions of windows have varying accuracy
92                 if (firsttimegettime)
93                 {
94                         timeBeginPeriod (1);
95                         firsttimegettime = false;
96                 }
97
98                 newtime = (double) timeGetTime () / 1000.0;
99         }
100         else
101         {
102                 // QueryPerformanceCounter
103                 // platform:
104                 // Windows 95/98/ME/NT/2000/XP
105                 // features:
106                 // very accurate (CPU cycles)
107                 // known issues:
108                 // does not necessarily match realtime too well (tends to get faster and faster in win98)
109                 // wraps around occasionally on some platforms (depends on CPU speed and probably other unknown factors)
110                 double timescale;
111                 LARGE_INTEGER PerformanceFreq;
112                 LARGE_INTEGER PerformanceCount;
113
114                 if (!QueryPerformanceFrequency (&PerformanceFreq))
115                 {
116                         Con_Printf ("No hardware timer available\n");
117                         // fall back to timeGetTime
118                         Cvar_SetValueQuick(&sys_usetimegettime, true);
119                         return Sys_DoubleTime();
120                 }
121                 QueryPerformanceCounter (&PerformanceCount);
122
123                 #ifdef __BORLANDC__
124                 timescale = 1.0 / ((double) PerformanceFreq.u.LowPart + (double) PerformanceFreq.u.HighPart * 65536.0 * 65536.0);
125                 newtime = ((double) PerformanceCount.u.LowPart + (double) PerformanceCount.u.HighPart * 65536.0 * 65536.0) * timescale;
126                 #else
127                 timescale = 1.0 / ((double) PerformanceFreq.LowPart + (double) PerformanceFreq.HighPart * 65536.0 * 65536.0);
128                 newtime = ((double) PerformanceCount.LowPart + (double) PerformanceCount.HighPart * 65536.0 * 65536.0) * timescale;
129                 #endif
130         }
131 #else
132         struct timeval tp;
133         gettimeofday(&tp, NULL);
134         newtime = (double) tp.tv_sec + tp.tv_usec / 1000000.0;
135 #endif
136
137         if (first)
138         {
139                 first = false;
140                 oldtime = newtime;
141         }
142
143         if (newtime < oldtime)
144         {
145                 // warn if it's significant
146                 if (newtime - oldtime < -0.01)
147                         Con_Printf("Sys_DoubleTime: time stepped backwards (went from %f to %f, difference %f)\n", oldtime, newtime, newtime - oldtime);
148         }
149         else
150                 curtime += newtime - oldtime;
151         oldtime = newtime;
152
153         return curtime;
154 }
155
156 char *Sys_ConsoleInput(void)
157 {
158         if (cls.state == ca_dedicated)
159         {
160                 static char text[MAX_INPUTLINE];
161                 static unsigned int len = 0;
162 #ifdef WIN32
163                 int c;
164
165                 // read a line out
166                 while (_kbhit ())
167                 {
168                         c = _getch ();
169                         if (c == '\r')
170                         {
171                                 text[len] = '\0';
172                                 putch ('\n');
173                                 len = 0;
174                                 return text;
175                         }
176                         if (c == '\b')
177                         {
178                                 if (len)
179                                 {
180                                         putch (c);
181                                         putch (' ');
182                                         putch (c);
183                                         len--;
184                                 }
185                                 continue;
186                         }
187                         if (len < sizeof (text) - 1)
188                         {
189                                 putch (c);
190                                 text[len] = c;
191                                 len++;
192                         }
193                 }
194 #else
195                 fd_set fdset;
196                 struct timeval timeout;
197                 FD_ZERO(&fdset);
198                 FD_SET(0, &fdset); // stdin
199                 timeout.tv_sec = 0;
200                 timeout.tv_usec = 0;
201                 if (select (1, &fdset, NULL, NULL, &timeout) != -1 && FD_ISSET(0, &fdset))
202                 {
203                         len = read (0, text, sizeof(text));
204                         if (len >= 1)
205                         {
206                                 // rip off the \n and terminate
207                                 text[len-1] = 0;
208                                 return text;
209                         }
210                 }
211 #endif
212         }
213         return NULL;
214 }
215
216 void Sys_Sleep(int milliseconds)
217 {
218         if (milliseconds < 1)
219                 milliseconds = 1;
220 #ifdef WIN32
221         Sleep(milliseconds);
222 #else
223         usleep(milliseconds * 1000);
224 #endif
225 }
226
227 char *Sys_GetClipboardData (void)
228 {
229         return NULL;
230 }
231
232 void Sys_InitConsole (void)
233 {
234 }
235
236 void Sys_Init_Commands (void)
237 {
238 }
239
240 int main (int argc, char **argv)
241 {
242         double frameoldtime, framenewtime;
243
244         signal(SIGFPE, SIG_IGN);
245
246         com_argc = argc;
247         com_argv = (const char **)argv;
248
249 #ifndef WIN32
250         fcntl(0, F_SETFL, fcntl (0, F_GETFL, 0) | FNDELAY);
251 #endif
252
253         Host_Init();
254
255         frameoldtime = Sys_DoubleTime () - 0.1;
256         while (1)
257         {
258                 // find time spent rendering last frame
259                 framenewtime = Sys_DoubleTime ();
260
261                 Host_Frame (framenewtime - frameoldtime);
262
263                 frameoldtime = framenewtime;
264         }
265         return 0;
266 }