home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 113 / EnigmaAmiga113CD.iso / software / sviluppo / quakeworld_src / client / sys_amiga.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-06-17  |  12.4 KB  |  605 lines
  1. /* 
  2. Copyright (C) 1996-1997 Id Software, Inc. 
  3.  
  4. This program is free software; you can redistribute it and/or 
  5. modify it under the terms of the GNU General Public License 
  6. as published by the Free Software Foundation; either version 2 
  7. of the License, or (at your option) any later version. 
  8.  
  9. This program is distributed in the hope that it will be useful, 
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of 
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.   
  12.  
  13. See the GNU General Public License for more details. 
  14.  
  15. You should have received a copy of the GNU General Public License 
  16. along with this program; if not, write to the Free Software 
  17. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. 
  18.  
  19. */ 
  20.  
  21. /*
  22. ** sys_amiga.c
  23. **
  24. ** QuakeWorld Server for Amiga M68k and Amiga PowerPC
  25. **
  26. */
  27.  
  28. #pragma amiga-align
  29. #include <exec/types.h>
  30. #include <exec/memory.h>
  31. #include <exec/execbase.h>
  32. #include <dos/dos.h>
  33. #include <utility/tagitem.h>
  34. #include <graphics/gfxbase.h>
  35. #include <devices/timer.h>
  36. #include <clib/alib_protos.h>
  37. #include <proto/exec.h>
  38. #include <proto/dos.h>
  39. #include <proto/timer.h>
  40. #ifdef __PPC__
  41. #ifdef WOS
  42. #include <clib/powerpc_protos.h>
  43. #else
  44. #include <powerup/ppclib/time.h>
  45. #include <powerup/gcclib/powerup_protos.h>
  46. #endif
  47. #endif
  48. #pragma default-align
  49.  
  50. /* Quake includes */
  51. #include "quakedef.h"
  52. #if defined(__PPC__) && !defined(WOS)
  53. #include "sys_timer.h"  /* GetSysTimePPC() emulation for PowerUp */
  54. #endif
  55.  
  56. #define CLOCK_PAL       3546895
  57. #define CLOCK_NTSC      3579545
  58. #define MAX_HANDLES     10
  59.  
  60.  
  61. #ifdef __STORM__
  62. extern struct Library *TimerBase;
  63. extern struct Library *UtilityBase;
  64. #else
  65. struct Library *TimerBase = NULL;
  66. struct Library *UtilityBase = NULL;
  67. #endif
  68. struct Library *LowLevelBase = NULL;
  69. #ifdef __PPC__
  70. #ifdef __STORM__
  71. extern struct Library *MathIeeeDoubBasBase = NULL;
  72. #else
  73. struct Library *MathIeeeDoubBasBase;
  74. #endif
  75.  
  76. qboolean no68kFPU = false; /* for LC040/LC060 systems */
  77. #endif
  78.  
  79. /* these are for snd_amiga.c */
  80. long sysclock = CLOCK_PAL;
  81. int FirstTime = 0;
  82. int FirstTime2 = 0;
  83.  
  84. static quakeparms_t parms;
  85. static struct timerequest *timerio;
  86. static int membase_offs;
  87. static int nostdout=0,coninput=0;
  88. static BPTR amiga_stdin,amiga_stdout;
  89. static BPTR sys_handles[MAX_HANDLES];
  90.  
  91. cvar_t  sys_linerefresh = {"sys_linerefresh","0"};// set for entity display
  92.  
  93.  
  94. #ifndef __PPC__
  95. extern void MMUHackOn(void);
  96. extern void MMUHackOff(void);
  97. #endif
  98.  
  99.  
  100.  
  101. // =======================================================================
  102. // General routines
  103. // =======================================================================
  104.  
  105. /*
  106. ================
  107. usleep
  108. ================
  109. */
  110. void usleep(unsigned long timeout)
  111. {
  112.   timerio->tr_node.io_Command = TR_ADDREQUEST;
  113.   timerio->tr_time.tv_secs = timeout / 1000000;
  114.   timerio->tr_time.tv_micro = timeout % 1000000;
  115.   SendIO((struct IORequest *)timerio);
  116.   WaitIO((struct IORequest *)timerio);
  117. }
  118.  
  119. /*
  120. ================
  121. strcasecmp
  122. ================
  123. */
  124. int strcasecmp(const char *str1, const char *str2)
  125. {
  126.   while(tolower((unsigned char)*str1) == tolower((unsigned char)*str2)) {
  127.     if(!*str1) return(0);
  128.     str1++;str2++;
  129.   }
  130.   return(tolower(*(unsigned char *)str1)-tolower(*(unsigned char *)str2));
  131. }
  132.  
  133. /*
  134. ================
  135. strncasecmp
  136. ================
  137. */
  138. int strncasecmp(const char *str1, const char *str2, size_t n)
  139. {
  140.   if (n==0) return 0;
  141.   while (--n && tolower((unsigned char)*str1)==tolower((unsigned char)*str2)){
  142.     if (!*str1) return(0);
  143.     str1++; str2++;
  144.   }
  145.   return(tolower(*(unsigned char *)str1)-tolower(*(unsigned char *)str2));
  146. }
  147.  
  148. /*
  149. ================
  150. bzero
  151. ================
  152. */
  153. void bzero(void *p,size_t n)
  154. {
  155.   memset(p,0,n);
  156. }
  157.  
  158.  
  159. static void cleanup(int rc)
  160. {
  161.   int i;
  162.  
  163.   Host_Shutdown();
  164.  
  165.   if (coninput)
  166.     SetMode(amiga_stdin,0);  /* put console back into normal CON mode */
  167.  
  168.   if (parms.membase)
  169.     FreeMem((char *)parms.membase-membase_offs,parms.memsize+3*32);
  170.  
  171. #ifndef __PPC__
  172.   if (COM_CheckParm("-hack"))
  173.     MMUHackOff();
  174. #endif
  175.  
  176.   if (TimerBase) {
  177.     if (!CheckIO((struct IORequest *)timerio)) {
  178.       AbortIO((struct IORequest *)timerio);
  179.       WaitIO((struct IORequest *)timerio);
  180.     }
  181.     CloseDevice((struct IORequest *)timerio);
  182.     DeletePort(timerio->tr_node.io_Message.mn_ReplyPort);
  183.     DeleteStdIO((struct IOStdReq *)timerio);
  184.   }
  185.  
  186. #ifdef __PPC__
  187.   if (no68kFPU) {
  188.     if (MathIeeeDoubBasBase)
  189.       CloseLibrary(MathIeeeDoubBasBase);
  190.   }
  191. #endif
  192.  
  193.   if (LowLevelBase)
  194.     CloseLibrary(LowLevelBase);
  195.   if (UtilityBase)
  196.     CloseLibrary(UtilityBase);
  197.  
  198.   for (i=1; i<MAX_HANDLES; i++) {
  199.     if (sys_handles[i])
  200.       Close(sys_handles[i]);
  201.   }
  202.   exit(rc);
  203. }
  204.  
  205. void Sys_DebugNumber(int y, int val)
  206. {
  207. }
  208.  
  209. void Sys_Printf (char *fmt, ...)
  210. {
  211.   va_list argptr;
  212.   static char text[2048];
  213.   unsigned char *p;
  214.  
  215.   va_start(argptr,fmt);
  216.   vsprintf(text,fmt,argptr);
  217.   va_end(argptr);
  218.  
  219.   if (strlen(text) > sizeof(text))
  220.     Sys_Error("memory overwrite in Sys_Printf");
  221.  
  222.   if (nostdout)
  223.     return;
  224.  
  225.   for (p = (unsigned char *)text; *p; p++) {
  226.     *p &= 0x7f;
  227.     if ((*p > 128 || *p < 32) && *p != 10 && *p != 13 && *p != 9)
  228.       printf("[%02x]", *p);
  229.     else
  230.       putc(*p, stdout);
  231.   }
  232.   fflush(stdout);
  233. }
  234.  
  235. void Sys_Quit (void)
  236. {
  237.   cleanup(0);
  238. }
  239.  
  240. void Sys_Init(void)
  241. {
  242. }
  243.  
  244. void Sys_Error (char *error, ...)
  245. {
  246.   va_list argptr;
  247.   
  248.   printf("Error: ");
  249.   va_start(argptr,error);
  250.   vprintf(error,argptr);
  251.   va_end(argptr);
  252.   printf("\n");
  253.   cleanup(1);
  254. }
  255.  
  256. void Sys_Warn (char *warning, ...)
  257. { 
  258.   va_list argptr;
  259.     
  260.   printf("Warning: ");
  261.   va_start(argptr,warning);
  262.   vprintf(warning,argptr);
  263.   va_end(argptr);
  264.   printf("\n");
  265. } 
  266.  
  267. /*
  268. ============
  269. Sys_FileTime
  270.  
  271. returns -1 if not present
  272. ============
  273. */
  274. int Sys_FileTime (char *path)
  275. {
  276.   BPTR lck;
  277.   int  t = -1;
  278.  
  279.   if (lck = Lock(path,ACCESS_READ)) {
  280.     t = 1;
  281.     UnLock(lck);
  282.   }
  283.  
  284.   return t;
  285. }
  286.  
  287.  
  288. void Sys_mkdir (char *path)
  289. {
  290.   BPTR lck;
  291.  
  292.   if (lck = CreateDir(path))
  293.     UnLock(lck);
  294. }
  295.  
  296. static int findhandle (void)
  297. {
  298.   int i;
  299.   
  300.   for (i=1 ; i<MAX_HANDLES ; i++)
  301.     if (!sys_handles[i])
  302.       return i;
  303.   Sys_Error ("out of handles");
  304.   return -1;
  305. }
  306.  
  307. int Sys_FileOpenRead (char *path, int *handle)
  308. {
  309.   BPTR fh;
  310.   struct FileInfoBlock *fib;
  311.   int     i = -1;
  312.   int flen = -1;
  313.   
  314.   *handle = -1;
  315.   if (fib = AllocDosObjectTags(DOS_FIB,TAG_DONE)) {
  316.     if (fh = Open(path,MODE_OLDFILE)) {
  317.       if (ExamineFH(fh,fib)) {
  318.         if ((i = findhandle()) > 0) {
  319.           sys_handles[i] = fh;
  320.           *handle = i;
  321.           flen = (int)fib->fib_Size;
  322.         }
  323.         else
  324.           Close(fh);
  325.       }
  326.       else
  327.         Close(fh);
  328.     }
  329.     FreeDosObject(DOS_FIB,fib);
  330.   }
  331.   return flen;
  332. }
  333.  
  334. int Sys_FileOpenWrite (char *path)
  335. {
  336.   BPTR fh;
  337.   int  i;
  338.   
  339.   if ((i = findhandle ()) > 0) {
  340.     if (fh = Open(path,MODE_NEWFILE)) {
  341.       sys_handles[i] = fh;
  342.     }
  343.     else {
  344.       char ebuf[80];
  345.       Fault(IoErr(),"",ebuf,80);
  346.       Sys_Error ("Error opening %s: %s", path, ebuf);
  347.       i = -1;
  348.     }
  349.   }
  350.   return i;
  351. }
  352.  
  353. int Sys_FileWrite (int handle, void *src, int count)
  354. {
  355.   return (int)Write(sys_handles[handle],src,(LONG)count);
  356. }
  357.  
  358. void Sys_FileClose (int handle)
  359. {
  360.   if (sys_handles[handle]) {
  361.     Close(sys_handles[handle]);
  362.     sys_handles[handle] = 0;
  363.   }
  364. }
  365.  
  366. void Sys_FileSeek (int handle, int position)
  367. {
  368.   Seek(sys_handles[handle],position,OFFSET_BEGINNING);
  369. }
  370.  
  371. int Sys_FileRead (int handle, void *dest, int count)
  372. {
  373.    return (int)Read(sys_handles[handle],dest,(LONG)count);
  374. }
  375.  
  376. void Sys_DebugLog(char *file, char *fmt, ...)
  377. {
  378.   va_list argptr; 
  379.   static char data[1024];
  380.   BPTR fh;
  381.  
  382.   va_start(argptr, fmt);
  383.   vsprintf(data, fmt, argptr);
  384.   va_end(argptr);
  385.   if (fh = Open(file,MODE_READWRITE)) {
  386.     Seek(fh,0,OFFSET_END);
  387.     Write(fh,data,(LONG)strlen(data));
  388.     Close(fh);
  389.   }
  390. }
  391.  
  392. void Sys_EditFile(char *filename)
  393. {
  394.   char cmd[256];
  395.   char *editor;
  396.  
  397.   editor = getenv("VISUAL");
  398.   if (!editor)
  399.     editor = getenv("EDITOR");
  400.   if (!editor)
  401.     editor = getenv("EDIT");
  402.   if (!editor)
  403.     editor = "ed";
  404.   sprintf(cmd, "%s %s", editor, filename);
  405.   system(cmd);
  406. }
  407.  
  408. double Sys_DoubleTime (void)
  409. {
  410.   struct timeval tv;
  411.  
  412. #ifdef __PPC__
  413.   GetSysTimePPC(&tv);
  414. #else
  415.   GetSysTime(&tv);
  416. #endif
  417.   return ((double)(tv.tv_secs-FirstTime) + (((double)tv.tv_micro) / 1000000.0));
  418. }
  419.  
  420. void Sys_LineRefresh(void)
  421. {
  422. }
  423.  
  424. char *Sys_ConsoleInput(void)
  425. {
  426.   if (coninput) {
  427.     static const char *backspace = "\b \b";
  428.     static char text[256];
  429.     static int len = 0;
  430.     char ch;
  431.  
  432.     while (WaitForChar(amiga_stdin,10) == DOSTRUE) {
  433.       Read(amiga_stdin,&ch,1);  /* note: console is in RAW mode! */
  434.       if (ch == '\r') {
  435.         ch = '\n';
  436.         Write(amiga_stdout,&ch,1);
  437.         text[len] = 0;
  438.         len = 0;
  439.         return text;
  440.       }
  441.       else if (ch == '\b') {
  442.         if (len > 0) {
  443.           len--;
  444.           Write(amiga_stdout,(char *)backspace,3);
  445.         }
  446.       }
  447.       else {
  448.         if (len < sizeof(text)-1) {
  449.           Write(amiga_stdout,&ch,1);
  450.           text[len++] = ch;
  451.         }
  452.       }
  453.     }
  454.   }
  455.   return NULL;
  456. }
  457.  
  458.  
  459. main(int argc, char *argv[])
  460. {
  461.   char cwd[128];
  462.   struct MsgPort *timerport;
  463.   int i;
  464.   double time, oldtime, newtime;
  465.   struct timeval tv;
  466.   struct GfxBase *GfxBase;
  467.  
  468.   memset(&parms,0,sizeof(parms));
  469.   parms.memsize = 16*1024*1024;  /* 16MB is default */
  470.  
  471.   COM_InitArgv (argc, argv);  
  472.   parms.argc = com_argc;
  473.   parms.argv = com_argv;
  474.  
  475.   /* Amiga Init */
  476.   if ((UtilityBase = OpenLibrary("utility.library",36)) == NULL ||
  477.       (LowLevelBase = OpenLibrary("lowlevel.library",36)) == NULL)
  478.     Sys_Error("OS2.0 required!");
  479. #ifdef __PPC__
  480.   no68kFPU = COM_CheckParm("-no68kfpu") != 0;
  481.   if (no68kFPU) {
  482.      if (!(MathIeeeDoubBasBase = OpenLibrary("mathieeedoubbas.library",36)))
  483.        Sys_Error("mathieeedoubbas.library is missing");
  484.   }
  485. #endif
  486.  
  487.   amiga_stdin = Input();
  488.   amiga_stdout = Output();
  489.  
  490.   coninput = COM_CheckParm("-console");
  491.   if (coninput)
  492.     SetMode(amiga_stdin,1);  /* put console into RAW mode */
  493.  
  494.   /* open timer.device */
  495. #ifdef __STORM__
  496.   if (timerport = CreateMsgPort()) {
  497.     if (timerio = CreateIORequest(timerport,sizeof(struct timerequest))) {
  498.       if (OpenDevice(TIMERNAME,UNIT_MICROHZ,
  499.                      (struct IORequest *)timerio,0) == 0) {
  500.         TimerBase = (struct Library *)timerio->tr_node.io_Device;
  501.       }
  502.       else {
  503.         DeleteIORequest(timerio);
  504.         DeleteMsgPort(timerport);
  505.       }
  506.     }
  507.     else
  508.       DeleteMsgPort(timerport);
  509.   }
  510. #else
  511.   if (timerport = CreatePort(NULL,0)) {
  512.     if (timerio = (struct timerequest *)
  513.                    CreateExtIO(timerport,sizeof(struct timerequest))) {
  514.       if (OpenDevice(TIMERNAME,UNIT_MICROHZ,
  515.                      (struct IORequest *)timerio,0) == 0) {
  516.         TimerBase = (struct Library *)timerio->tr_node.io_Device;
  517.       }
  518.       else {
  519.         DeleteStdIO((struct IOStdReq *)timerio);
  520.         DeletePort(timerport);
  521.       }
  522.     }
  523.     else
  524.       DeletePort(timerport);
  525.   }
  526. #endif
  527.  
  528.   if (!TimerBase)
  529.     Sys_Error("Can't open timer.device");
  530.   usleep(1);  /* don't delete, otherwise we can't do timer.device cleanup */
  531.  
  532. #if defined(__PPC__) && !defined(WOS)
  533.   /* init GetSysTimePPC() emulation for PowerUp */
  534.   InitSysTimePPC();
  535. #endif
  536.  
  537. #ifdef __PPC__
  538.   GetSysTimePPC(&tv);
  539.   FirstTime = tv.tv_secs;
  540.   GetSysTime(&tv);
  541.   FirstTime2 = tv.tv_secs;
  542. #else
  543.   GetSysTime(&tv);
  544.   FirstTime2 = FirstTime = tv.tv_secs;
  545. #endif
  546.  
  547.   /* check arguments */
  548.   nostdout = (COM_CheckParm("-nostdout"));
  549. #ifndef __PPC__
  550.   if (COM_CheckParm("-hack"))
  551.     MMUHackOn();
  552. #endif
  553.  
  554.   if (i = COM_CheckParm("-mem"))
  555.     parms.memsize = (int)(Q_atof(com_argv[i+1]) * 1024 * 1024);
  556.  
  557.   /* alloc 16-byte aligned quake memory */
  558.   parms.memsize = (parms.memsize+15)&~15;
  559.   if ((parms.membase = AllocMem((ULONG)parms.memsize,MEMF_FAST)) == NULL)
  560.     Sys_Error("Can't allocate %ld bytes\n", parms.memsize);
  561.   if ((ULONG)parms.membase & 8)
  562.     membase_offs = 40;  /* guarantee 16-byte aligment */
  563.   else
  564.     membase_offs = 32;
  565.   parms.membase = (char *)parms.membase + membase_offs;
  566.   parms.memsize -= 3*32;
  567.  
  568.   /* get name of current directory */
  569.   GetCurrentDirName(cwd,128);
  570.   parms.basedir = cwd;
  571.  
  572.   /* set the clock constant */
  573.   if (GfxBase = (struct GfxBase *)OpenLibrary("graphics.library",36)) {
  574.     if (GfxBase->DisplayFlags & PAL)
  575.       sysclock = CLOCK_PAL;
  576.     else
  577.       sysclock = CLOCK_NTSC;
  578.     CloseLibrary((struct Library *)GfxBase);
  579.   }
  580.  
  581.   Sys_Init();
  582.  
  583.   Host_Init(&parms);
  584.  
  585.   oldtime = Sys_DoubleTime ();
  586.   while (1) {
  587.     /* find time spent rendering last frame */
  588.     newtime = Sys_DoubleTime ();
  589.     time = newtime - oldtime;
  590.  
  591.     Host_Frame(time);
  592.     oldtime = newtime;
  593.   }
  594. }
  595.  
  596.  
  597. /*
  598. ================
  599. Sys_MakeCodeWriteable
  600. ================
  601. */
  602. void Sys_MakeCodeWriteable (unsigned long startaddr, unsigned long length)
  603. {
  604. }
  605.