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;
}
}