int main (int argc, char **argv) { static quakeparms_t parms; float time, oldtime, newtime; parms.memsize = 16*1024*1024; parms.membase = malloc (parms.memsize); parms.basedir = "."; parms.cachedir = NULL; COM_InitArgv (argc, argv); parms.argc = com_argc; parms.argv = com_argv; printf ("Host_Init\n"); Host_Init (&parms); Sys_Init(); // unroll the simulation loop to give the video side a chance to see _vid_default_mode Host_Frame( 0.1 ); VID_SetDefaultMode(); oldtime = Sys_FloatTime(); while (1) { newtime = Sys_FloatTime(); Host_Frame (newtime - oldtime); oldtime = newtime; } return 0; }
int Sys_InitGame() { //Four args, three unused, and one I don't care to use. //char * gamedir[0x100]; //gmodinfo might need zeroing out on server restarts and whatnot, but for the //first server, there ought to be no troubles. //Tracing sucks. SeedRandomNumberGenerator(); Sys_InitMemory(); if(Host_Init(&host_parms) == 0) { //failed. return(0); } Sys_Init(); //be after host_init, as cvars need memory. //COM_GetGameDirSize(gamedir, sizeof(gamedir)); //Sys_InitAuthentication Host_InitializeGameDLL(); Banlist_Init(); NET_Config(1); return(1); }
/* ================== main ================== */ int main (int argc, char **argv) { double newtime, time, oldtime; int sleep_msec; Host_Init (argc, argv, 16*1024*1024); // // main loop // oldtime = Sys_DoubleTime () - 0.1; while (1) { sleep_msec = sys_sleep.value; if (sleep_msec > 0) { if (sleep_msec > 13) sleep_msec = 13; Sleep (sleep_msec); } NET_Sleep (1); // find time passed since last cycle newtime = Sys_DoubleTime (); time = newtime - oldtime; oldtime = newtime; Host_Frame (time); } return true; }
void main (int argc, char **argv) { static quakeparms_t parms; parms.memsize = MEMSZ; parms.membase = mem; parms.basedir = "/amnt1"; if(0 == parms.membase) { printf("out of mem\n"); exit(1); } COM_InitArgv (argc, argv); parms.argc = com_argc; parms.argv = com_argv; printf ("Host_Init\n"); Host_Init (&parms); while (1) { Host_Frame (0.1); } }
int main (int c, char **v) { quakeparms_t parms; enableCrunLoop = c > 0; // signal(SIGFPE, floating_point_exception_handler); signal(SIGFPE, SIG_IGN); parms.memsize = 16*1024*1024; parms.membase = malloc (parms.memsize); parms.basedir = basedir; parms.cachedir = cachedir; 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; if(enableCrunLoop) { while(true) { engineTick(); } } else { AS3_GoAsync(); } }
int main() { int32_t rc; uint32_t numBlks, blkSize; uint8_t inquiryResult[INQUIRY_LENGTH]; /* SystemClockUpdate() updates the SystemFrequency variable */ SystemClockUpdate(); UART_Init(57600); /* Initialize the serial port to view the log messages */ Host_Init(); /* Initialize the lpc17xx host controller */ rc = Host_EnumDev(); /* Enumerate the device connected */ if (rc == OK) { /* Initialize the mass storage and scsi interfaces */ rc = MS_Init( &blkSize, &numBlks, inquiryResult ); if (rc == OK) { rc = FAT_Init(); /* Initialize the FAT16 file system */ if (rc == OK) { Main_Copy(); /* Call the application */ } else { return (0); } } else { return (0); } } else { return (0); } while(1); }
/******************************************************************************* * Function Name : main * Description : Main program * Input : None * Output : None * Return : None * Attention : None *******************************************************************************/ int main (void) { uint32_t n; uint32_t ret; SysTick_Config(SystemCoreClock / 1000); #ifdef CFG_SDCARD /* Setup SD Card/FATFS */ SDInit(); #endif debug_frmwrk_init(); printf("\r\n hello"); //for (n = 0; n < MSC_ImageSize; n++) { /* Copy Initial Disk Image */ // Memory[n] = DiskImage[n]; /* from Flash to RAM */ //} if(!KEY1_PIN) { UsbMode = 0; while(!KEY1_PIN); delay(100000); while(!KEY1_PIN); } if(UsbMode == 0){ USB_Init(); /* USB Initialization */ USB_Connect(TRUE); /* USB Connect */ } else{ Host_Init(); // Initialize the lpc17xx host controller if( Host_EnumDev() == 0 ) /* Enumerate the device connected */ { printf("-- USB device detected OK \r\n"); } else { printf("-- Please connect a USB device \r\n"); while( Host_EnumDev() == 0 ); printf("-- USB device connection detected \r\n"); Delay(0x00ffff); } } while (1){ if(!KEY1_PIN) { ret = Host_CtrlSend(0x40, 0x50, 0, 0, 0, NULL); printf("\r\n sent switch cmd,ret= %x ",ret); delay(100); NVIC_SystemReset(); } } }
int main (int argc, char **argv) { MSG msg; quakeparms_t parms; double time, oldtime; static char cwd[1024]; memset (&parms, 0, sizeof(parms)); parms.memsize = 16384*1024; parms.membase = malloc (parms.memsize); _getcwd (cwd, sizeof(cwd)); if (cwd[Q_strlen(cwd)-1] == '\\') cwd[Q_strlen(cwd)-1] = 0; parms.basedir = cwd; //"f:/quake"; // parms.basedir = "f:\\quake"; COM_InitArgv (argc, argv); // dedicated server ONLY! if (!COM_CheckParm ("-dedicated")) { memcpy (newargv, argv, argc*4); newargv[argc] = "-dedicated"; argc++; argv = newargv; COM_InitArgv (argc, argv); } parms.argc = argc; parms.argv = argv; printf ("Host_Init\n"); Host_Init (&parms); oldtime = Sys_FloatTime (); /* main window message loop */ while (1) { time = Sys_FloatTime(); if (time - oldtime < sys_ticrate.value ) { Sleep(1); continue; } Host_Frame ( time - oldtime ); oldtime = time; } /* return success of application */ return TRUE; }
int main (int c, char **v) { double time, oldtime, newtime; quakeparms_t parms; int j; // static char cwd[1024]; // signal(SIGFPE, floating_point_exception_handler); signal(SIGFPE, SIG_IGN); memset(&parms, 0, sizeof(parms)); COM_InitArgv(c, v); parms.argc = com_argc; parms.argv = com_argv; parms.memsize = 16*1024*1024; j = COM_CheckParm("-mem"); if (j) parms.memsize = (int) (Q_atof(com_argv[j+1]) * 1024 * 1024); parms.membase = malloc (parms.memsize); parms.basedir = basedir; // caching is disabled by default, use -cachedir to enable // parms.cachedir = cachedir; noconinput = COM_CheckParm("-noconinput"); if (!noconinput) fcntl(0, F_SETFL, fcntl (0, F_GETFL, 0) | FNDELAY); if (COM_CheckParm("-nostdout")) nostdout = 1; Sys_Init(); Host_Init(&parms); oldtime = Sys_DoubleTime (); while (1) { // find time spent rendering last frame newtime = Sys_DoubleTime (); time = newtime - oldtime; Host_Frame(time); oldtime = newtime; } }
int main(int ac, char *av[]) { double newtime, time, oldtime; int sleep_msec; ParseCommandLine (ac, av); COM_InitArgv (argc, argv); GetConsoleTitle(title, sizeof(title)); Host_Init(argc, argv, DEFAULT_MEM_SIZE); // run one frame immediately for first heartbeat SV_Frame (0.1); // // main loop // oldtime = Sys_DoubleTime () - 0.1; while (1) { sleep_msec = (int)sys_sleep.value; if (sleep_msec > 0) { if (sleep_msec > 13) sleep_msec = 13; Sleep (sleep_msec); } // select on the net socket and stdin // the only reason we have a timeout at all is so that if the last // connected client times out, the message would not otherwise // be printed until the next event. if (!sys_simulation.value) { NET_Sleep((int)sys_select_timeout.value / 1000, false); } // find time passed since last cycle newtime = Sys_DoubleTime (); time = newtime - oldtime; oldtime = newtime; curtime = newtime; SV_Frame (time); } return true; }
/*********************************************************************//** * @brief This function is the main function where the execution begins * @param[in] None * @return None **********************************************************************/ int main() { int32_t rc; uint32_t numBlks, blkSize; uint8_t buffer[30]; UINT nun; uint8_t inquiryResult[INQUIRY_LENGTH]; FATFS fs; FIL fsrc, fdst; const TCHAR a=1; SystemInit(); debug_frmwrk_init(); print_menu(); Host_Init(); /* Initialize the lpc17xx host controller */ PRINT_Log("Host Initialized\r\n"); PRINT_Log("Connect a Mass Storage device\r\n"); rc = Host_EnumDev(); /* Enumerate the device connected */ PRINT_Log("Á¬½ÓÉ豸\r\n"); if ((rc == USB_HOST_FUNC_OK) && (Host_GetDeviceType() == MASS_STORAGE_DEVICE)) { PRINT_Log("Mass Storage device connected\r\n"); rc = f_mount(&fs,"0:",1); if(rc==0) { rc = f_open(&fdst, "0:read.txt", FA_READ); if(rc==0) { PRINT_Log("open ok\r\n"); f_read (&fdst, buffer, 30, &nun ); PRINT_Log(buffer); f_close(&fdst); } } } else { PRINT_Log("Not a Mass Storage device\n"); return (0); } return 0; }
int main (int argc, char **argv) { double time, oldtime, newtime; #ifdef PARANOID signal(SIGFPE, floating_point_exception_handler); #else signal(SIGFPE, SIG_IGN); #endif #ifdef hpux // makes it possible to access unaligned pointers (e.g. inside structures) // must be linked with libhpp.a to work (add -lhppa to LDFLAGS) allow_unaligned_data_access(); #endif // we need to check for -noconinput and -nostdout // before Host_Init is called COM_InitArgv (argc, argv); noconinput = COM_CheckParm("-noconinput"); if (!noconinput) fcntl(0, F_SETFL, fcntl (0, F_GETFL, 0) | O_NDELAY); if (COM_CheckParm("-nostdout")) nostdout = 1; #if id386 Sys_SetFPCW(); #endif Host_Init (argc, argv, 32*1024*1024); oldtime = Sys_DoubleTime (); while (1) { if (dedicated) NET_Sleep (10); // find time spent rendering last frame newtime = Sys_DoubleTime (); time = newtime - oldtime; Host_Frame(time); oldtime = newtime; } return 0; }
static int main_real() { printf("Mounting drive\n"); { FATFS fso; FIL myfile; int r; memset(&fso, 0, sizeof(fso)); memset(&myfile, 0, sizeof(myfile)); r = f_mount(0, &fso); if (r == 0) printf("Succeeded\n"); else printf("Failed\n"); } { double mytime, oldtime, newtime; char *myargv[] = { "fodquake", 0 }; printf("Calling Host_Init()\n"); #if 0 cl.frames = malloc(sizeof(*cl.frames)*UPDATE_BACKUP); memset(cl.frames, 0, sizeof(*cl.frames)*UPDATE_BACKUP); #endif Host_Init(1, myargv, 10*1024*1024); oldtime = Sys_DoubleTime(); while(1) { newtime = Sys_DoubleTime(); mytime = newtime - oldtime; oldtime = newtime; Host_Frame(mytime); } Sys_Error("End of app"); return 0; } }
void AndroidInit(int width, int height) { quakeparms_t parms; int j; int c = 0; char* v[] = {"quake", (char*) 0}; scr_width = width; scr_height = height; // static char cwd[1024]; // signal(SIGFPE, floating_point_exception_handler); // signal(SIGFPE, SIG_IGN); memset(&parms, 0, sizeof(parms)); COM_InitArgv(c, v); parms.argc = com_argc; parms.argv = com_argv; parms.memsize = 16*1024*1024; j = COM_CheckParm("-mem"); if (j) parms.memsize = (int) (Q_atof(com_argv[j+1]) * 1024 * 1024); parms.membase = malloc (parms.memsize); parms.basedir = basedir; // caching is disabled by default, use -cachedir to enable // parms.cachedir = cachedir; #if 0 // FNDELAY not implemented noconinput = COM_CheckParm("-noconinput"); if (!noconinput) fcntl(0, F_SETFL, fcntl (0, F_GETFL, 0) | FNDELAY); #endif if (COM_CheckParm("-nostdout")) nostdout = 1; Sys_Init(); Host_Init(&parms); g_oldtime = Sys_DoubleTime (); }
int main (int argc, char **argv) { static quakeparms_t parms; float time, oldtime, newtime; signal(SIGFPE, SIG_IGN); SifInitRpc(0); LoadModules(); /* if(mcInit(MC_TYPE_MC) < 0) { printf("Failed to initialise memcard\n"); SleepThread(); } */ inithandle(); parms.memsize = 24*1024*1024; parms.membase = malloc (parms.memsize); parms.basedir = "."; COM_InitArgv (argc, argv); parms.argc = com_argc; parms.argv = com_argv; printf ("Host_Init\n"); Host_Init (&parms); start_ps2_timer(); oldtime = Sys_FloatTime () - 0.1; while (1) { // find time spent rendering last frame newtime = Sys_FloatTime (); time = newtime - oldtime; oldtime = newtime; Host_Frame (time); } stop_ps2_timer(); return 0; }
/* main */ int SDL_main (int c, char **v) { double time, oldtime, newtime; int j; #ifndef WIN32 signal (SIGFPE, SIG_IGN); #endif memset (&host_parms, 0, sizeof (host_parms)); COM_InitArgv (c, v); host_parms.argc = com_argc; host_parms.argv = com_argv; host_parms.memsize = 16 * 1024 * 1024; // 16MB default heap j = COM_CheckParm ("-mem"); if (j) host_parms.memsize = (int) (atof (com_argv[j + 1]) * 1024 * 1024); host_parms.membase = malloc (host_parms.memsize); if (!host_parms.membase) { printf ("Can't allocate memory for zone.\n"); return 1; } #ifndef WIN32 noconinput = COM_CheckParm ("-noconinput"); if (!noconinput) fcntl (0, F_SETFL, fcntl (0, F_GETFL, 0) | O_NONBLOCK); #endif Host_Init (); oldtime = Sys_DoubleTime (); while (1) { // find time spent rendering last frame newtime = Sys_DoubleTime (); time = newtime - oldtime; Host_Frame (time); oldtime = newtime; } }
int main (int argc, char **argv) { #ifdef hpux // makes it possible to access unaligned pointers (e.g. inside structures) // must be linked with libhpp.a to work (add -lhppa to LDFLAGS) allow_unaligned_data_access(); #endif printf ("Host_Init\n"); Host_Init (argc, argv, 5861376); while (1) { Host_Frame (0.1); } return 0; }
void SchlierenRenderer::init() { _initialized=true; // create pbo // createPBO(&pbo_dest,_params.width, _params.height); // // // create texture for blitting onto the screen // createTexture(&tex_screen, _params.width, _params.height); // // // create a depth buffer for offscreen rendering // createDepthBuffer(&depth_buffer, _params.width, _params.height); // // // create a framebuffer for offscreen rendering // createFramebuffer(&framebuffer, tex_screen, depth_buffer); Host_Init(&_params); }
DSTATUS disk_initialize(BYTE drv /* Physical drive nmuber (0..) */ ) { DSTATUS stat; int result; (void) result; switch (drv) { case ATA: // result = ATA_disk_initialize(); stat = STA_NOINIT; // translate the result code here return stat; case MMC: stat = MMC_disk_initialize(); return stat; case USB: #if WITH_USB_MS /* USB host init and enumeration */ if ( usb_status & STA_NOINIT ) { Host_Init(); if ( Host_EnumDev() == OK ) { /* mass-storage init */ if ( MS_Init(&blkSize, &numBlks, inquiryResult) == OK ) { usb_status &= ~STA_NOINIT; } else { /* MS init fail */ } } else { /* host init and/or enum fail */ } } return usb_status; #else stat = STA_NOINIT; return stat; #endif } return STA_NOINIT; }
int main (int argc, char **argv) { float time, oldtime; APT_CheckNew3DS(&isN3DS); if(isN3DS) osSetSpeedupEnable(true); gfxInit(GSP_RGB565_OES,GSP_RGB565_OES,false); gfxSetDoubleBuffering(GFX_TOP, false); gfxSetDoubleBuffering(GFX_BOTTOM, false); gfxSet3D(true); consoleInit(GFX_BOTTOM, NULL); #ifdef _3DS_CIA if(chdir("sdmc:/3ds/ctrQuake") != 0) Sys_Error("Could not find folder: sdmc:/3ds/ctrQuake"); #endif static quakeparms_t parms; parms.memsize = 24*1024*1024; parms.membase = malloc (parms.memsize); parms.basedir = "."; COM_InitArgv (argc, argv); parms.argc = com_argc; parms.argv = com_argv; Host_Init (&parms); Sys_Init(); oldtime = Sys_FloatTime() -0.1; while (aptMainLoop()) { time = Sys_FloatTime(); separation_distance = osGet3DSliderState(); Host_Frame (time - oldtime); oldtime = time; } gfxExit(); return 0; }
void main (int argc, char **argv) { static quakeparms_t parms; parms.memsize = 8*1024*1024; parms.membase = malloc (parms.memsize); parms.basedir = "."; COM_InitArgv (argc, argv); parms.argc = com_argc; parms.argv = com_argv; printf ("Host_Init\n"); Host_Init (&parms); while (1) { Host_Frame (0.1); } }
/* ============= main ============= */ int main (int argc, char *argv[]) { double time1, oldtime, newtime; // Without signal(SIGPIPE, SIG_IGN); MVDSV crashes on *nix when qtvproxy will be disconnect. signal(SIGPIPE, SIG_IGN); COM_InitArgv (argc, argv); SV_System_Init(); // daemonize and so... Host_Init(argc, argv, DEFAULT_MEM_SIZE); // run one frame immediately for first heartbeat SV_Frame (0.1); // main loop oldtime = Sys_DoubleTime () - 0.1; while (1) { // select on the net socket and stdin // the only reason we have a timeout at all is so that if the last // connected client times out, the message would not otherwise // be printed until the next event. stdin_ready = NET_Sleep ((int)sys_select_timeout.value / 1000, do_stdin); // find time passed since last cycle newtime = Sys_DoubleTime (); time1 = newtime - oldtime; oldtime = newtime; curtime = newtime; SV_Frame (time1); // extrasleep is just a way to generate a f****d up connection on purpose if ((int)sys_extrasleep.value) usleep ((unsigned long)sys_extrasleep.value); } return 0; }
int main() { USB_INT32S rc; USB_INT32U numBlks, blkSize; USB_INT08U inquiryResult[INQUIRY_LENGTH]; // Code Red - if CMSIS 1.3 setup is being used, then SystemInit() routine // will be called by startup code rather than in application's main() #ifndef __USE_CMSIS SystemInit(); /* initialize clocks */ #endif UART_Init(115200); /* Initialize the serial port to view the log messages */ Host_Init(); /* Initialize the lpc17xx host controller */ rc = Host_EnumDev(); /* Enumerate the device connected */ if (rc == OK) { /* Initialize the mass storage and scsi interfaces */ rc = MS_Init( &blkSize, &numBlks, inquiryResult ); if (rc == OK) { rc = FAT_Init(); /* Initialize the FAT16 file system */ if (rc == OK) { Main_Copy(); /* Call the application */ } else { while ( 1 ); return (0); } } else { while ( 1 ); return (0); } } else { while ( 1 ); return (0); } while(1); }
void Host_Main(void) { double time1 = 0; double time2 = 0; double time3 = 0; double cl_timer = 0, sv_timer = 0; double clframetime, deltacleantime, olddirtytime, dirtytime; double wait; int pass1, pass2, pass3, i; char vabuf[1024]; qboolean playing; Host_Init(); realtime = 0; host_dirtytime = Sys_DirtyTime(); for (;;) { if (setjmp(host_abortframe)) { SCR_ClearLoadingScreen(false); continue; // something bad happened, or the server disconnected } olddirtytime = host_dirtytime; dirtytime = Sys_DirtyTime(); deltacleantime = dirtytime - olddirtytime; if (deltacleantime < 0) { // warn if it's significant if (deltacleantime < -0.01) Con_Printf("Host_Mingled: time stepped backwards (went from %f to %f, difference %f)\n", olddirtytime, dirtytime, deltacleantime); deltacleantime = 0; } else if (deltacleantime >= 1800) { Con_Printf("Host_Mingled: time stepped forward (went from %f to %f, difference %f)\n", olddirtytime, dirtytime, deltacleantime); deltacleantime = 0; } realtime += deltacleantime; host_dirtytime = dirtytime; cl_timer += deltacleantime; sv_timer += deltacleantime; if (!svs.threaded) { svs.perf_acc_realtime += deltacleantime; // Look for clients who have spawned playing = false; for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++) if(host_client->begun) if(host_client->netconnection) playing = true; if(sv.time < 10) { // don't accumulate time for the first 10 seconds of a match // so things can settle svs.perf_acc_realtime = svs.perf_acc_sleeptime = svs.perf_acc_lost = svs.perf_acc_offset = svs.perf_acc_offset_squared = svs.perf_acc_offset_max = svs.perf_acc_offset_samples = 0; } else if(svs.perf_acc_realtime > 5) { svs.perf_cpuload = 1 - svs.perf_acc_sleeptime / svs.perf_acc_realtime; svs.perf_lost = svs.perf_acc_lost / svs.perf_acc_realtime; if(svs.perf_acc_offset_samples > 0) { svs.perf_offset_max = svs.perf_acc_offset_max; svs.perf_offset_avg = svs.perf_acc_offset / svs.perf_acc_offset_samples; svs.perf_offset_sdev = sqrt(svs.perf_acc_offset_squared / svs.perf_acc_offset_samples - svs.perf_offset_avg * svs.perf_offset_avg); } if(svs.perf_lost > 0 && developer_extra.integer) if(playing) // only complain if anyone is looking Con_DPrintf("Server can't keep up: %s\n", Host_TimingReport(vabuf, sizeof(vabuf))); svs.perf_acc_realtime = svs.perf_acc_sleeptime = svs.perf_acc_lost = svs.perf_acc_offset = svs.perf_acc_offset_squared = svs.perf_acc_offset_max = svs.perf_acc_offset_samples = 0; } } if (slowmo.value < 0.00001 && slowmo.value != 0) Cvar_SetValue("slowmo", 0); if (host_framerate.value < 0.00001 && host_framerate.value != 0) Cvar_SetValue("host_framerate", 0); // keep the random time dependent, but not when playing demos/benchmarking if(!*sv_random_seed.string && !cls.demoplayback) rand(); // get new key events Key_EventQueue_Unblock(); SndSys_SendKeyEvents(); Sys_SendKeyEvents(); NetConn_UpdateSockets(); Log_DestBuffer_Flush(); // receive packets on each main loop iteration, as the main loop may // be undersleeping due to select() detecting a new packet if (sv.active && !svs.threaded) NetConn_ServerFrame(); Curl_Run(); // check for commands typed to the host Host_GetConsoleCommands(); // when a server is running we only execute console commands on server frames // (this mainly allows frikbot .way config files to work properly by staying in sync with the server qc) // otherwise we execute them on client frames if (sv.active ? sv_timer > 0 : cl_timer > 0) { // process console commands // R_TimeReport("preconsole"); CL_VM_PreventInformationLeaks(); Cbuf_Frame(); // R_TimeReport("console"); } //Con_Printf("%6.0f %6.0f\n", cl_timer * 1000000.0, sv_timer * 1000000.0); // if the accumulators haven't become positive yet, wait a while if (cls.state == ca_dedicated) wait = sv_timer * -1000000.0; else if (!sv.active || svs.threaded) wait = cl_timer * -1000000.0; else wait = max(cl_timer, sv_timer) * -1000000.0; if (!cls.timedemo && wait >= 1) { double time0, delta; if(host_maxwait.value <= 0) wait = min(wait, 1000000.0); else wait = min(wait, host_maxwait.value * 1000.0); if(wait < 1) wait = 1; // because we cast to int time0 = Sys_DirtyTime(); if (sv_checkforpacketsduringsleep.integer && !sys_usenoclockbutbenchmark.integer && !svs.threaded) { NetConn_SleepMicroseconds((int)wait); if (cls.state != ca_dedicated) NetConn_ClientFrame(); // helps server browser get good ping values // TODO can we do the same for ServerFrame? Probably not. } else Sys_Sleep((int)wait); delta = Sys_DirtyTime() - time0; if (delta < 0 || delta >= 1800) delta = 0; if (!svs.threaded) svs.perf_acc_sleeptime += delta; // R_TimeReport("sleep"); continue; } // limit the frametime steps to no more than 100ms each if (cl_timer > 0.1) cl_timer = 0.1; if (sv_timer > 0.1) { if (!svs.threaded) svs.perf_acc_lost += (sv_timer - 0.1); sv_timer = 0.1; } R_TimeReport("---"); //------------------- // // server operations // //------------------- // limit the frametime steps to no more than 100ms each if (sv.active && sv_timer > 0 && !svs.threaded) { // execute one or more server frames, with an upper limit on how much // execution time to spend on server frames to avoid freezing the game if // the server is overloaded, this execution time limit means the game will // slow down if the server is taking too long. int framecount, framelimit = 1; double advancetime, aborttime = 0; float offset; prvm_prog_t *prog = SVVM_prog; // run the world state // don't allow simulation to run too fast or too slow or logic glitches can occur // stop running server frames if the wall time reaches this value if (sys_ticrate.value <= 0) advancetime = sv_timer; else if (cl.islocalgame && !sv_fixedframeratesingleplayer.integer) { // synchronize to the client frametime, but no less than 10ms and no more than 100ms advancetime = bound(0.01, cl_timer, 0.1); } else { advancetime = sys_ticrate.value; // listen servers can run multiple server frames per client frame framelimit = cl_maxphysicsframesperserverframe.integer; aborttime = Sys_DirtyTime() + 0.1; } if(slowmo.value > 0 && slowmo.value < 1) advancetime = min(advancetime, 0.1 / slowmo.value); else advancetime = min(advancetime, 0.1); if(advancetime > 0) { offset = Sys_DirtyTime() - dirtytime;if (offset < 0 || offset >= 1800) offset = 0; offset += sv_timer; ++svs.perf_acc_offset_samples; svs.perf_acc_offset += offset; svs.perf_acc_offset_squared += offset * offset; if(svs.perf_acc_offset_max < offset) svs.perf_acc_offset_max = offset; } // only advance time if not paused // the game also pauses in singleplayer when menu or console is used sv.frametime = advancetime * slowmo.value; if (host_framerate.value) sv.frametime = host_framerate.value; if (sv.paused || (cl.islocalgame && (key_dest != key_game || key_consoleactive || cl.csqc_paused))) sv.frametime = 0; for (framecount = 0;framecount < framelimit && sv_timer > 0;framecount++) { sv_timer -= advancetime; // move things around and think unless paused if (sv.frametime) SV_Physics(); // if this server frame took too long, break out of the loop if (framelimit > 1 && Sys_DirtyTime() >= aborttime) break; } R_TimeReport("serverphysics"); // send all messages to the clients SV_SendClientMessages(); if (sv.paused == 1 && realtime > sv.pausedstart && sv.pausedstart > 0) { prog->globals.fp[OFS_PARM0] = realtime - sv.pausedstart; PRVM_serverglobalfloat(time) = sv.time; prog->ExecuteProgram(prog, PRVM_serverfunction(SV_PausedTic), "QC function SV_PausedTic is missing"); } // send an heartbeat if enough time has passed since the last one NetConn_Heartbeat(0); R_TimeReport("servernetwork"); } else if (!svs.threaded) { // don't let r_speeds display jump around R_TimeReport("serverphysics"); R_TimeReport("servernetwork"); } //------------------- // // client operations // //------------------- if (cls.state != ca_dedicated && (cl_timer > 0 || cls.timedemo || ((vid_activewindow ? cl_maxfps : cl_maxidlefps).value < 1))) { R_TimeReport("---"); Collision_Cache_NewFrame(); R_TimeReport("photoncache"); // decide the simulation time if (cls.capturevideo.active) { //*** if (cls.capturevideo.realtime) clframetime = cl.realframetime = max(cl_timer, 1.0 / cls.capturevideo.framerate); else { clframetime = 1.0 / cls.capturevideo.framerate; cl.realframetime = max(cl_timer, clframetime); } } else if (vid_activewindow && cl_maxfps.value >= 1 && !cls.timedemo) { clframetime = cl.realframetime = max(cl_timer, 1.0 / cl_maxfps.value); // when running slow, we need to sleep to keep input responsive wait = bound(0, cl_maxfps_alwayssleep.value * 1000, 100000); if (wait > 0) Sys_Sleep((int)wait); } else if (!vid_activewindow && cl_maxidlefps.value >= 1 && !cls.timedemo) clframetime = cl.realframetime = max(cl_timer, 1.0 / cl_maxidlefps.value); else clframetime = cl.realframetime = cl_timer; // apply slowmo scaling clframetime *= cl.movevars_timescale; // scale playback speed of demos by slowmo cvar if (cls.demoplayback) { clframetime *= slowmo.value; // if demo playback is paused, don't advance time at all if (cls.demopaused) clframetime = 0; } else { // host_framerate overrides all else if (host_framerate.value) clframetime = host_framerate.value; if (cl.paused || (cl.islocalgame && (key_dest != key_game || key_consoleactive || cl.csqc_paused))) clframetime = 0; } if (cls.timedemo) clframetime = cl.realframetime = cl_timer; // deduct the frame time from the accumulator cl_timer -= cl.realframetime; cl.oldtime = cl.time; cl.time += clframetime; // update video if (host_speeds.integer) time1 = Sys_DirtyTime(); R_TimeReport("pre-input"); // Collect input into cmd CL_Input(); R_TimeReport("input"); // check for new packets NetConn_ClientFrame(); // read a new frame from a demo if needed CL_ReadDemoMessage(); R_TimeReport("clientnetwork"); // now that packets have been read, send input to server CL_SendMove(); R_TimeReport("sendmove"); // update client world (interpolate entities, create trails, etc) CL_UpdateWorld(); R_TimeReport("lerpworld"); CL_Video_Frame(); R_TimeReport("client"); CL_UpdateScreen(); CL_MeshEntities_Reset(); R_TimeReport("render"); if (host_speeds.integer) time2 = Sys_DirtyTime(); // update audio if(cl.csqc_usecsqclistener) { S_Update(&cl.csqc_listenermatrix); cl.csqc_usecsqclistener = false; } else S_Update(&r_refdef.view.matrix); CDAudio_Update(); R_TimeReport("audio"); // reset gathering of mouse input in_mouse_x = in_mouse_y = 0; if (host_speeds.integer) { pass1 = (int)((time1 - time3)*1000000); time3 = Sys_DirtyTime(); pass2 = (int)((time2 - time1)*1000000); pass3 = (int)((time3 - time2)*1000000); Con_Printf("%6ius total %6ius server %6ius gfx %6ius snd\n", pass1+pass2+pass3, pass1, pass2, pass3); } } #if MEMPARANOIA Mem_CheckSentinelsGlobal(); #else if (developer_memorydebug.integer) Mem_CheckSentinelsGlobal(); #endif // if there is some time remaining from this frame, reset the timers if (cl_timer >= 0) cl_timer = 0; if (sv_timer >= 0) { if (!svs.threaded) svs.perf_acc_lost += sv_timer; sv_timer = 0; } host_framecount++; } }
portTASK_FUNCTION(shell, pvParameters ) { int c; xTaskHandle xHandle; printf("\n%s v%s\r\n", NAMA_BOARD, VERSI_KOMON); printf("Daun Biru Engineering, Des 2008\r\n"); printf("=========================================\r\n"); printf("ARM-GCC %s : %s : %s\r\n", __VERSION__, __DATE__, __TIME__); printf("CPU = LPC 2387, %d MHz,", configCPU_CLOCK_HZ/1000000); printf(" FreeRTOS 5.1.1\r\n"); if (configUSE_PREEMPTION == 0) printf("NON Preemptive kernel digunakan !\r\n"); else printf("Preemptive kernel digunakan !\r\n"); #ifdef USB_TEST Host_Init(); /* Initialize the lpc2468 host controller */ //c = Host_EnumDev(); /* Enumerate the device connected */ // if (c == 0) printf("Ketemu !\r\n"); #if 1 if (OHCIInit() == 0) { printf("------------ Init error \r\n"); } //install_usb_interrupt(); #endif #endif /* * add command */ //tinysh_add_command(&myfoocmd); tinysh_add_command(&printenv_cmd); tinysh_add_command(&setenv_cmd); // tinysh_add_command(&save_env_cmd); tinysh_add_command(&reset_cmd); tinysh_add_command(&cek_stack_cmd); tinysh_add_command(&uptime_cmd); tinysh_add_command(&version_cmd); #ifdef BOARD_KOMON_KONTER tinysh_add_command(&cek_rpm_cmd); tinysh_add_command(&set_kanal_cmd); #endif //#ifdef BOARD_TAMPILAN #ifdef CARI_SUMBER tinysh_add_command(&cek_sumber_cmd); tinysh_add_command(&set_sumber_cmd); //tinysh_add_command(&cek_mesin_cmd); //tinysh_add_command(&set_mesin_cmd); //tinysh_add_command(&cek_titik_cmd); //tinysh_add_command(&set_titik_cmd); tinysh_add_command(&save_sumber_cmd); //tinysh_add_command(&save_mesin_cmd); //tinysh_add_command(&save_titik_cmd); #endif #ifdef BOARD_KOMON_A_RTD tinysh_add_command(&cek_adc_cmd); tinysh_add_command(&set_kanal_cmd); #endif #ifdef BOARD_KOMON_420_SAJA #ifdef PAKAI_ADC tinysh_add_command(&cek_adc_cmd); tinysh_add_command(&lihat_data_cmd); #endif tinysh_add_command(&set_kanal_cmd); #endif #ifdef BOARD_KOMON_420_SABANG #ifdef PAKAI_ADC tinysh_add_command(&cek_adc_cmd); //tinysh_add_command(&lihat_data_cmd); tinysh_add_command(&set_kanal_cmd); #endif #endif #ifdef BOARD_KOMON_B_THERMO tinysh_add_command(&cek_adc_cmd); tinysh_add_command(&set_kanal_cmd); #endif #ifdef PAKE_TELNETD tinysh_add_command(&matikan_telnet_cmd); #endif #ifdef PAKAI_PM // tinysh_add_command(&cek_pm_cmd); // tinysh_add_command(&set_pm_cmd); // tinysh_add_command(&cek_konfig_pmnya_cmd); #endif #ifdef PAKAI_GSM_FTP tinysh_add_command(&set_modem_ftp_cmd); tinysh_add_command(&cek_modem_cmd); tinysh_add_command(&set_modem_gsm_cmd); tinysh_add_command(&gsm_ftp_cmd); tinysh_add_command(&cek_ftp_cmd); #endif #ifdef PAKAI_SMS tinysh_add_command(&cek_pulsa_cmd); tinysh_add_command(&kirim_sms_cmd); tinysh_add_command(&hapus_sms_cmd); tinysh_add_command(&baca_sms_cmd); tinysh_add_command(&baca_sms_semua_cmd); tinysh_add_command(&sms_monita_cmd); #endif #ifdef PAKAI_CRON tinysh_add_command(&set_cron_cmd); tinysh_add_command(&cek_cron_cmd); #endif //#ifdef CARI_SUMBERNYA #ifdef BOARD_TAMPILAN tinysh_add_command(&cek_group_cmd); tinysh_add_command(&set_group_cmd); //tinysh_add_command(&cek_sumber_cmd); //tinysh_add_command(&set_sumber_cmd); // data //tinysh_add_command(&set_data_cmd); //tinysh_add_command(&cek_data_cmd); //printf("board_tampilan\r\n"); #endif vTaskDelay(100); #ifdef BANYAK_SUMBER tinysh_add_command(&cek_sumber_cmd); tinysh_add_command(&set_sumber_cmd); tinysh_add_command(&set_data_cmd); tinysh_add_command(&cek_data_cmd); //printf("banyak sumber\r\n"); #endif vTaskDelay(100); #if (VERSI_KONFIGx == 2) tinysh_add_command(&cek_group_cmd); tinysh_add_command(&set_group_cmd); tinysh_add_command(&cek_sumber_cmd); tinysh_add_command(&set_sumber_cmd); // data tinysh_add_command(&set_data_cmd); tinysh_add_command(&cek_data_cmd); #endif // simpan file #ifdef PAKAI_FILE_SIMPAN tinysh_add_command(&cek_file_cmd); tinysh_add_command(&set_file_cmd); tinysh_add_command(&del_direktori_cmd); tinysh_add_command(&cari_doku_cmd); tinysh_add_command(&hapus_filenya_cmd); #endif #ifdef CENDOL tinysh_add_command(&cek_konfig_cmd); tinysh_add_command(&set_konfig_cmd); #endif #ifdef PAKAI_MULTI_SERIAL #if defined(PAKAI_SERIAL_1) || defined(PAKAI_SERIAL_2) || defined(PAKAI_SERIAL_3) tinysh_add_command(&kirim_serial_cmd); #endif #endif /* add sub commands */ //tinysh_add_command(&ctxcmd); //tinysh_add_command(&item1); //tinysh_add_command(&item2); /* use a command from the stack * !!! this is only possible because the shell will have exited * before the stack of function main !!! */ /* { tinysh_cmd_t quitcmd={0,"quit","exit shell",0,reset_to_0, (void *)&again,0,0}; tinysh_add_command(&quitcmd); }*/ /* add atoxi support test command */ //tinysh_add_command(&atoxi_cmd); /* add a background command */ //tinysh_add_command(&bgcmd); //xTaskCreate( bg_cmd_thread, "bg_cmd", 1000, NULL, 2, &xHandle); #ifdef PAKAI_MMC vTaskDelay(340); #else vTaskDelay(450); #endif #ifdef PAKAI_SELENOID static tinysh_cmd_t set_relay_cmd={0,"set_relay","setting relay", "help default ",set_relay,0,0,0}; tinysh_add_command(&set_relay_cmd); #endif //#ifdef BOARD_TAMPILAN #ifdef CARI_SUMBERx // cek ukuran struk printf("size struct Mesin = %d\r\n", sizeof (struct t_mesin) * JML_MESIN); printf("size struct Sumber = %d\r\n", sizeof (struct t_sumber) * JML_SUMBER); printf("size struct Titik = %d\r\n", sizeof (struct t_titik) * JML_MESIN * TIAP_MESIN); //printf("size struct sambungan = %d\r\n", sizeof (samb)); #endif #ifdef BOARD_KOMON_420_SAJA kalibrasi_adc1(); vTaskDelay(100); start_adc_1(); #endif #ifdef BOARD_KOMON_420_SABANG #ifdef PAKAI_ADC kalibrasi_adc1(); vTaskDelay(100); start_adc_1(); #endif vTaskDelay(100); #endif #ifdef BOARD_KOMON_A_RTD kalibrasi_adc1(); vTaskDelay(100); start_adc_1(); #endif #ifdef BOARD_KOMON_B_THERMO kalibrasi_adc1(); vTaskDelay(100); start_adc_1(); #endif #ifdef BOARD_KOMON_KONTER #ifdef PAKAI_RTC rtc_init(); vTaskDelay(100); //baca_rtc_mem(); #endif #endif #ifdef PAKAI_MMC tinysh_add_command(&util_ls_cmd); tinysh_add_command(&util_mkdir_cmd); tinysh_add_command(&util_cd_cmd); tinysh_add_command(&util_pwd_cmd); tinysh_add_command(&util_view_cmd); init_gpio_mmc(); uncs_mmc(); vTaskDelay(5); set_fs_mount(); vTaskDelay(5); status_MMC = cek_fs_free(); struct t_simpan_file *ts; ts = (char *) ALMT_SFILE; vTaskDelay(5); if (status_MMC) { printf("_____MMC ERROR !!!!_____ %d\r\n", status_MMC); if (status_MMC==13) printf("_____MMC FR_NO_FILESYSTEM, kudu diformat FAT32 !!!\r\n"); if (ts->set==1) { set_file_mati(); printf("simpan data ke file dimatikan !!\r\n"); } } else { status_MMC = 1; printf("MMC aktif. Siap simpan data: %d\r\n", status_MMC); } /* FR_NOT_READY, 3 FR_NO_FILE, 4 FR_NO_PATH, 5 FR_INVALID_NAME, 6 FR_DENIED, 7 FR_EXIST, 8 FR_INVALID_OBJECT, 9 FR_WRITE_PROTECTED, 10 FR_INVALID_DRIVE, 11 FR_NOT_ENABLED, 12 FR_NO_FILESYSTEM, 13 FR_MKFS_ABORTED, 14 FR_TIMEOUT 15 //*/ sprintf(abs_path, "%s", ""); #endif #ifdef PAKAI_RTC tinysh_add_command(&set_date_cmd); #endif struct t_env *envx; envx = (char *) ALMT_ENV; sprintf(str,"%s%d$ ", PROMPT, (envx->IP3)); tinysh_set_prompt(str); //tinysh_set_prompt( PROMPT ); /* force untuk tampil prompt */ tinysh_char_in('\r'); int perdetiknya=0; /* printf("nChr: %d, nInt: %d, nLInt: %d, nFloat: %d, nDouble: %d\r\n", \ sizeof(char), sizeof(int), sizeof(long int), sizeof(float), sizeof(double)); printf("nChr: %d, nInt: %d, nLInt: %d, nFloat: %d, nDouble: %d\r\n", \ 255, 20000000, 20000000, 20000000, 20000000); //*/ /* * main loop shell */ int lop = 0; while(1) { vTaskDelay(1); lop++; if (xSerialGetChar(1, &c, 100 ) == pdTRUE) { lop = 0; tinysh_char_in((unsigned char)c); } /* dilindungi password setiap menit tidak ada aktifitas*/ if (lop > 6000) { lop = 0; printf("\r\nPasswd lock!\r\n"); while(1) { if (xSerialGetChar(1, &c, 100) == pdTRUE) { if (proses_passwd( &c ) == 1) break; } #ifdef PAKAI_MMC #ifdef PAKAI_FILE_SIMPAN perdetiknya++; if (perdetiknya==10 && status_MMC==1) { proses_simpan_file(); perdetiknya=0; } #endif #endif #ifdef PAKAI_ADC #ifdef BOARD_KOMON_A_RTD proses_data_adc(); #endif #ifdef BOARD_KOMON_B_THERMO proses_data_adc(); #endif #ifdef BOARD_KOMON_420_SABANG proses_data_adc(); #endif #ifdef BOARD_KOMON_420_SAJA proses_data_adc(); hitung_datanya(); #endif simpan_ke_data_f(); #endif #ifdef BOARD_KOMON_KONTER data_frek_rpm(); #endif } } // pembacaaan ADC dipindah dari task eth ke shell 1 Okt 2010. #ifdef PAKAI_ADC #ifdef BOARD_KOMON_A_RTD proses_data_adc(); #endif #ifdef BOARD_KOMON_B_THERMO proses_data_adc(); #endif #ifdef BOARD_KOMON_420_SAJA proses_data_adc(); hitung_datanya(); #endif #ifdef BOARD_KOMON_420_SABANG proses_data_adc(); #endif simpan_ke_data_f(); #endif #ifdef BOARD_KOMON_KONTER data_frek_rpm(); #endif #ifdef PAKAI_MMC #ifdef PAKAI_FILE_SIMPAN perdetiknya++; if (perdetiknya==10 && status_MMC==1) { proses_simpan_file(); perdetiknya=0; } #endif #endif #ifdef USB_TEST c = HC_INT_STAT ; { printf("%4d: usb stat 0x%X\r\n", lop, c); HC_INT_STAT |= c; usb_terup = 0; } #endif } return; }
/* ================ main ================ */ int main (int c, char **v) { double time, oldtime, newtime; extern void (*dos_error_func)(char *, ...); static char cwd[1024]; printf ("Quake v%4.2f\n", VERSION); // make sure there's an FPU signal(SIGNOFP, Sys_NoFPUExceptionHandler); signal(SIGABRT, Sys_DefaultExceptionHandler); signal(SIGALRM, Sys_DefaultExceptionHandler); signal(SIGKILL, Sys_DefaultExceptionHandler); signal(SIGQUIT, Sys_DefaultExceptionHandler); signal(SIGINT, Sys_DefaultExceptionHandler); if (fptest_temp >= 0.0) fptest_temp += 0.1; COM_InitArgv (c, v); quakeparms.argc = com_argc; quakeparms.argv = com_argv; dos_error_func = Sys_Error; Sys_DetectWin95 (); Sys_PageInProgram (); Sys_GetMemory (); atexit (Sys_AtExit); // in case we crash getwd (cwd); if (cwd[Q_strlen(cwd)-1] == '/') cwd[Q_strlen(cwd)-1] = 0; quakeparms.basedir = cwd; //"f:/quake"; isDedicated = (COM_CheckParm ("-dedicated") != 0); Sys_Init (); if (!isDedicated) dos_registerintr(9, TrapKey); //Sys_InitStackCheck (); Host_Init(&quakeparms); //Sys_StackCheck (); //Con_Printf ("Top of stack: 0x%x\n", &time); oldtime = Sys_FloatTime (); while (1) { newtime = Sys_FloatTime (); time = newtime - oldtime; if (cls.state == ca_dedicated && (time<sys_ticrate.value)) continue; Host_Frame (time); //Sys_StackCheck (); oldtime = newtime; } }
int main (int c, char **v) { double time, oldtime, newtime; quakeparms_t parms; extern int vcrFile; extern int recording; int j; // static char cwd[1024]; // signal(SIGFPE, floating_point_exception_handler); signal(SIGFPE, SIG_IGN); memset(&parms, 0, sizeof(parms)); COM_InitArgv(c, v); parms.argc = com_argc; parms.argv = com_argv; #ifdef GLQUAKE parms.memsize = 16*1024*1024; #else parms.memsize = 8*1024*1024; #endif j = COM_CheckParm("-mem"); if (j) parms.memsize = (int) (Q_atof(com_argv[j+1]) * 1024 * 1024); parms.membase = malloc (parms.memsize); parms.basedir = basedir; // caching is disabled by default, use -cachedir to enable // parms.cachedir = cachedir; fcntl(0, F_SETFL, fcntl (0, F_GETFL, 0) | FNDELAY); Host_Init(&parms); Sys_Init(); if (COM_CheckParm("-nostdout")) nostdout = 1; else { fcntl(0, F_SETFL, fcntl (0, F_GETFL, 0) | FNDELAY); printf ("Linux Quake -- Version %0.3f\n", LINUX_VERSION); } 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) ) { usleep(1); 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; Host_Frame (time); // graphic debugging aids if (sys_linerefresh.value) Sys_LineRefresh (); } }
static void* main_thread_function(void*) { u32 level, real_heap_size; // hope the parms are all set by now COM_InitArgv(parms_number, parms_array); _CPU_ISR_Disable(level); heap = (char *)align32(SYS_GetArena2Lo()); real_heap_size = heap_size - ((u32)heap - (u32)SYS_GetArena2Lo()); if ((u32)heap + real_heap_size > (u32)SYS_GetArena2Hi()) { _CPU_ISR_Restore(level); Sys_Error("heap + real_heap_size > (u32)SYS_GetArena2Hi()"); } else { SYS_SetArena2Lo(heap + real_heap_size); _CPU_ISR_Restore(level); } VIDEO_SetBlack(TRUE); // Initialise the Host module. quakeparms_t parms; memset(&parms, 0, sizeof(parms)); parms.argc = com_argc; parms.argv = com_argv; parms.basedir = QUAKE_WII_BASEDIR; parms.memsize = real_heap_size; parms.membase = heap; if (parms.membase == 0) { Sys_Error("Heap allocation failed"); } memset(parms.membase, 0, parms.memsize); Host_Init(&parms); #if TIME_DEMO Cbuf_AddText("map start\n"); Cbuf_AddText("wait\n"); Cbuf_AddText("timedemo demo1\n"); #endif #if TEST_CONNECTION Cbuf_AddText("connect 192.168.0.2"); #endif SYS_SetResetCallback(reset_system); SYS_SetPowerCallback(shutdown_system); VIDEO_SetBlack(FALSE); // Run the main loop. u64 last_time = gettime(); for (;;) { if (want_to_reset) Sys_Reset(); if (want_to_shutdown) Sys_Shutdown(); // Get the frame time in ticks. const u64 current_time = gettime(); const u64 time_delta = current_time - last_time; const double seconds = time_delta * (0.001f / TB_TIMER_CLOCK); last_time = current_time; // Run the frame. Host_Frame(seconds); }; // Quit (this code is never reached). Sys_Quit(); return 0; }
void AndroidInit2(int width, int height) { PMPLOG(("AndroidInit2 %d,%d", width, height)); gInitialized = true; PMPBEGIN(("AndroidInit2")); quakeparms_t parms; int j; int c = 0; const char* v[] = {"quake", (char*) 0}; scr_width = width; scr_height = height; // static char cwd[1024]; // signal(SIGFPE, floating_point_exception_handler); // signal(SIGFPE, SIG_IGN); memset(&parms, 0, sizeof(parms)); if (gArgc) { COM_InitArgv(gArgc, (const char**) gArgv); } else { COM_InitArgv(c, (const char**) v); } parms.argc = com_argc; parms.argv = com_argv; parms.memsize = 16*1024*1024; j = COM_CheckParm("-mem"); if (j) parms.memsize = (int) (Q_atof(com_argv[j+1]) * 1024 * 1024); parms.membase = malloc (parms.memsize); const char* basedir = basedir2; if(direxists(basedir1)) { basedir = basedir1; } else if(direxists(basedir2)) { basedir = basedir2; } else { Sys_Error("Could not find data directories %s or %s", basedir1, basedir2); } parms.basedir = basedir; CheckGLCacheVersion(basedir); // caching is disabled by default, use -cachedir to enable // parms.cachedir = cachedir; #if 0 // FNDELAY not implemented noconinput = COM_CheckParm("-noconinput"); if (!noconinput) fcntl(0, F_SETFL, fcntl (0, F_GETFL, 0) | FNDELAY); #endif if (COM_CheckParm("-nostdout")) nostdout = 1; Sys_Init(); Host_Init(&parms); g_oldtime = Sys_FloatTime (); PMPEND(("AndroidInit2")); }
int main (int argc, char **argv) { double time, oldtime, newtime; PrintVersion(); // make sure there's an FPU signal(SIGNOFP, Sys_NoFPUExceptionHandler); signal(SIGABRT, Sys_DefaultExceptionHandler); signal(SIGALRM, Sys_DefaultExceptionHandler); signal(SIGKILL, Sys_DefaultExceptionHandler); signal(SIGQUIT, Sys_DefaultExceptionHandler); signal(SIGINT, Sys_DefaultExceptionHandler); if (fptest_temp >= 0.0) fptest_temp += 0.1; dos_error_func = Sys_Error; memset (cwd, 0, sizeof(cwd)); if (Sys_GetBasedir(argv[0], cwd, sizeof(cwd)) != 0) Sys_Error ("Couldn't determine current directory"); /* initialize the host params */ memset (&quakeparms, 0, sizeof(quakeparms)); quakeparms.basedir = cwd; quakeparms.userdir = cwd; quakeparms.argc = argc; quakeparms.argv = argv; host_parms = &quakeparms; LOG_Init (&quakeparms); COM_ValidateByteorder (); Sys_DetectWin95 (); Sys_PageInProgram (); Sys_GetMemory (); atexit (Sys_AtExit); // in case we crash isDedicated = (COM_CheckParm ("-dedicated") != 0); Sys_Init (); if (!isDedicated) dos_registerintr(9, TrapKey); // Sys_InitStackCheck (); Host_Init(); // Sys_StackCheck (); // Con_Printf ("Top of stack: 0x%x\n", &time); oldtime = Sys_DoubleTime (); while (1) { newtime = Sys_DoubleTime (); time = newtime - oldtime; if (isDedicated && (time < sys_ticrate.value)) continue; Host_Frame (time); // Sys_StackCheck (); oldtime = newtime; } }