kolibrios-fun/contrib/other/sdlquake-1.0.9/sys_sdl.c
turbocat 9aefaa6765 sdlquake:
- Better fix for finding resource folders.

git-svn-id: svn://kolibrios.org@8663 a494cfbc-eb01-0410-851d-a64ba20cac60
2021-04-02 21:11:15 +00:00

482 lines
7.8 KiB
C

#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
#include <limits.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <kos32sys.h>
#if !defined(__WIN32__) && !defined(_KOLIBRI)
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/mman.h>
#endif
#include "quakedef.h"
qboolean isDedicated;
int noconinput = 0;
char *basedir = ".";
cvar_t sys_linerefresh = {"sys_linerefresh","0"};// set for entity display
cvar_t sys_nostdout = {"sys_nostdout","0"};
// =======================================================================
// General routines
// =======================================================================
void Sys_DebugNumber(int y, int val)
{
}
void Sys_Printf (char *fmt, ...)
{
va_list argptr;
char text[1024];
va_start (argptr,fmt);
vsprintf (text,fmt,argptr);
va_end (argptr);
fprintf(stderr, "%s", text);
//Con_Print (text);
}
void Sys_Quit (void)
{
Host_Shutdown();
exit(0);
}
void Sys_Init(void)
{
#if id386
Sys_SetFPCW();
#endif
}
#if !id386
/*
================
Sys_LowFPPrecision
================
*/
void Sys_LowFPPrecision (void)
{
// causes weird problems on Nextstep
}
/*
================
Sys_HighFPPrecision
================
*/
void Sys_HighFPPrecision (void)
{
// causes weird problems on Nextstep
}
#endif // !id386
void Sys_Error (char *error, ...)
{
va_list argptr;
char string[1024];
va_start (argptr,error);
vsprintf (string,error,argptr);
va_end (argptr);
fprintf(stderr, "Error: %s\n", string);
Host_Shutdown ();
exit (1);
}
void Sys_Warn (char *warning, ...)
{
va_list argptr;
char string[1024];
va_start (argptr,warning);
vsprintf (string,warning,argptr);
va_end (argptr);
fprintf(stderr, "Warning: %s", string);
}
/*
===============================================================================
FILE IO
===============================================================================
*/
#define MAX_HANDLES 10
FILE *sys_handles[MAX_HANDLES];
int findhandle (void)
{
int i;
for (i=1 ; i<MAX_HANDLES ; i++)
if (!sys_handles[i])
return i;
Sys_Error ("out of handles");
return -1;
}
/*
================
Qfilelength
================
*/
static int Qfilelength (FILE *f)
{
int pos;
int end;
pos = ftell (f);
fseek (f, 0, SEEK_END);
end = ftell (f);
fseek (f, pos, SEEK_SET);
return end;
}
int Sys_FileOpenRead (char *path, int *hndl)
{
FILE *f;
int i;
i = findhandle ();
f = fopen(path, "rb");
if (!f)
{
*hndl = -1;
return -1;
}
sys_handles[i] = f;
*hndl = i;
return Qfilelength(f);
}
int Sys_FileOpenWrite (char *path)
{
FILE *f;
int i;
i = findhandle ();
f = fopen(path, "wb");
if (!f)
Sys_Error ("Error opening %s: %s", path,strerror(errno));
sys_handles[i] = f;
return i;
}
void Sys_FileClose (int handle)
{
if ( handle >= 0 ) {
fclose (sys_handles[handle]);
sys_handles[handle] = NULL;
}
}
void Sys_FileSeek (int handle, int position)
{
if ( handle >= 0 ) {
fseek (sys_handles[handle], position, SEEK_SET);
}
}
int Sys_FileRead (int handle, void *dst, int count)
{
char *data;
int size, done;
size = 0;
if ( handle >= 0 ) {
data = dst;
while ( count > 0 ) {
done = fread (data, 1, count, sys_handles[handle]);
if ( done == 0 ) {
break;
}
data += done;
count -= done;
size += done;
}
}
return size;
}
int Sys_FileWrite (int handle, void *src, int count)
{
char *data;
int size, done;
size = 0;
if ( handle >= 0 ) {
data = src;
while ( count > 0 ) {
done = fread (data, 1, count, sys_handles[handle]);
if ( done == 0 ) {
break;
}
data += done;
count -= done;
size += done;
}
}
return size;
}
int Sys_FileTime (char *path)
{
FILE *f;
f = fopen(path, "rb");
if (f)
{
fclose(f);
return 1;
}
return -1;
}
void Sys_mkdir (char *path)
{
#ifdef __WIN32__
mkdir (path);
#else
//mkdir (path, 0777);
#endif
}
void Sys_DebugLog(char *file, char *fmt, ...)
{
va_list argptr;
static char data[1024];
FILE *fp;
va_start(argptr, fmt);
vsprintf(data, fmt, argptr);
va_end(argptr);
fp = fopen(file, "a");
fwrite(data, strlen(data), 1, fp);
fclose(fp);
}
double Sys_FloatTime (void)
{
#if defined(_KOLIBRI)
static int starttime = 0;
if ( ! starttime )
__asm__ __volatile__("int $0x40" : "=a"(starttime) : "a"(26), "b"(9));
int curtime;
__asm__ __volatile__("int $0x40" : "=a"(curtime) : "a"(26), "b"(9));
return (curtime-starttime)*0.01;
#elif defined(__WIN32__)
static int starttime = 0;
if ( ! starttime )
starttime = clock();
return (clock()-starttime)*1.0/1024;
#else
struct timeval tp;
struct timezone tzp;
static int secbase;
gettimeofday(&tp, &tzp);
if (!secbase)
{
secbase = tp.tv_sec;
return tp.tv_usec/1000000.0;
}
return (tp.tv_sec - secbase) + tp.tv_usec/1000000.0;
#endif
}
// =======================================================================
// Sleeps for microseconds
// =======================================================================
static volatile int oktogo;
void alarm_handler(int x)
{
oktogo=1;
}
byte *Sys_ZoneBase (int *size)
{
char *QUAKEOPT = getenv("QUAKEOPT");
*size = 0xc00000;
if (QUAKEOPT)
{
while (*QUAKEOPT)
if (tolower(*QUAKEOPT++) == 'm')
{
*size = atof(QUAKEOPT) * 1024*1024;
break;
}
}
return malloc (*size);
}
void Sys_LineRefresh(void)
{
}
void Sys_Sleep(void)
{
#ifdef _KOLIBRI
delay(1);
#else
SDL_Delay(1);
#endif
}
#ifndef _KOLIBRI
void floating_point_exception_handler(int whatever)
{
// Sys_Warn("floating point exception\n");
signal(SIGFPE, floating_point_exception_handler);
}
#endif
void moncontrol(int x)
{
}
int main (int c, char **v)
{
#ifdef _KOLIBRI
#include "kolibri.h"
_ksys_setcwd(dirname(v[0]));
#endif
double time, oldtime, newtime;
quakeparms_t parms;
extern int vcrFile;
extern qboolean recording;
static int frame;
moncontrol(0);
#ifndef _KOLIBRI
// signal(SIGFPE, floating_point_exception_handler);
signal(SIGFPE, SIG_IGN);
#endif
parms.memsize = 8*1024*1024;
parms.membase = malloc (parms.memsize);
parms.basedir = basedir;
parms.cachedir = NULL;
COM_InitArgv(c, v);
parms.argc = com_argc;
parms.argv = com_argv;
Sys_Init();
Host_Init(&parms);
Cvar_RegisterVariable (&sys_nostdout);
oldtime = Sys_FloatTime () - 0.1;
while (1)
{
// find time spent rendering last frame
newtime = Sys_FloatTime ();
time = newtime - oldtime;
if (cls.state == ca_dedicated)
{ // play vcrfiles at max speed
if (time < sys_ticrate.value && (vcrFile == -1 || recording) )
{
#ifdef _KOLIBRI
delay(1);
#else
SDL_Delay (1);
#endif
continue; // not time to run a server only tic yet
}
time = sys_ticrate.value;
}
if (time > sys_ticrate.value*2)
oldtime = newtime;
else
oldtime += time;
if (++frame > 10)
moncontrol(1); // profile only while we do each Quake frame
Host_Frame (time);
moncontrol(0);
// graphic debugging aids
if (sys_linerefresh.value)
Sys_LineRefresh ();
}
}
/*
================
Sys_MakeCodeWriteable
================
*/
void Sys_MakeCodeWriteable (unsigned long startaddr, unsigned long length)
{
#ifndef _KOLIBRI
int r;
unsigned long addr;
int psize = getpagesize();
fprintf(stderr, "writable code %lx-%lx\n", startaddr, startaddr+length);
addr = startaddr & ~(psize-1);
r = mprotect((char*)addr, length + startaddr - addr, 7);
if (r < 0)
Sys_Error("Protection change failed\n");
#endif
}