void GfglFeatures::dumpHardwareInfo() const
{
GfLogInfo("Video hardware info :\n");
GfLogInfo(" Vendor : %s\n", glGetString(GL_VENDOR));
GfLogInfo(" Renderer : %s\n", glGetString(GL_RENDERER));
GfLogInfo(" Version : %s\n", glGetString(GL_VERSION));
}
static void
RmReadyToRace(void * /* dummy */)
{
if (GfuiRemoveKey(rmScreenHandle,GFUIK_RETURN,"Ready"))
{
GfLogInfo("<Enter> key for Ready' removed \n");
}
else
{
GfLogInfo("FAILED to remove <Enter> to Start key \n");
}
// The menu changed.
rmbMenuChanged = true;
rmPreRacePause = false;
// Enable the sound
if (LegacyMenu::self().soundEngine())
{
LegacyMenu::self().soundEngine()->mute(false);
}
LmRaceEngine().stopPreracePause();
}
// Implementation of IRaceEngine.
void StandardGame::reset(void)
{
GfLogInfo("Resetting StandardGame race engine.\n");
// Cleanup everything in case no yet done.
cleanup();
// Internal init.
::ReReset();
// Load and initialize the track loader module.
const char* pszModName =
GfParmGetStr(ReSituation::self().data()->_reParam, "Modules", "track", "track");
GfLogInfo("Loading '%s' track loader ...\n", pszModName);
GfModule* pmodTrkLoader = GfModule::load("modules/track", pszModName);
// Check that it implements ITrackLoader.
if (pmodTrkLoader)
_piTrkLoader = pmodTrkLoader->getInterface<ITrackLoader>();
if (pmodTrkLoader && !_piTrkLoader)
{
GfModule::unload(pmodTrkLoader);
return;
}
// Initialize GfTracks' track module interface (needed for some track infos).
GfTracks::self()->setTrackLoader(_piTrkLoader);
}
static void onHostPlayerReady(tCheckBoxInfo* pInfo)
{
tRmInfo* reInfo = LmRaceEngine().inData();
char dname[256];
int nCars = GfParmGetEltNb(reInfo->params, RM_SECT_DRIVERS);
NetServerMutexData *pSData = NetGetServer()->LockServerData();
for (int i=1; i <= nCars; i++) {
sprintf(dname, "%s/%d", RM_SECT_DRIVERS, i);
GfLogInfo("Setting driver %d to %d\n", i, pInfo->bChecked);
if(strcmp(NETWORKROBOT, GfParmGetStr(reInfo->params, dname, RM_ATTR_MODULE, "")) == 0) {
// Human drive, check if local
int index = GfParmGetNum(reInfo->params, dname, RM_ATTR_IDX, NULL, 1.0) - 1;
GfLogInfo("Index %d\n", index);
if (pSData->m_vecNetworkPlayers[index].client == false)
NetGetServer()->OverrideDriverReady(i, pInfo->bChecked);
} else {
// Robot driver, all are local
NetGetServer()->OverrideDriverReady(i, pInfo->bChecked);
}
bRobotsReady = pInfo->bChecked;
}
NetGetServer()->UnlockServerData();
EnableMenuHostButtons(pInfo->bChecked);
GfLogInfo("menu ready\n");
}
bool LegacyMenu::onRaceFinished(bool bEndOfSession)
{
tRmInfo* pReInfo = _piRaceEngine->inData();
// Display the results of the session for all the competitors
// only if this is the end of a session (for all competitors),
// and if specified by the race mode or if the display mode is "normal".
if (bEndOfSession
&& (!strcmp(GfParmGetStr(pReInfo->params, pReInfo->_reRaceName, RM_ATTR_DISPRES, RM_VAL_YES), RM_VAL_YES)
|| pReInfo->_displayMode == RM_DISP_MODE_NORMAL))
{
// Create the "Race Engine update state" hook if not already done.
if (!_hscrReUpdateStateHook)
_hscrReUpdateStateHook = ::RmInitReUpdateStateHook();
// This is now the "game" screen.
_hscrGame = _hscrReUpdateStateHook;
// Display the results menu (will activate the game screen on exit).
::RmShowResults(_hscrGame, _piRaceEngine->inData());
// Tell the race engine state automaton to stop looping (enter the menu).
return false;
}
GfLogInfo("Not starting Results menu (not end of session, or specified not to, or blind mode).\n");
return true;
}
int
RePostRace(void)
{
int curRaceIdx;
void *results = ReInfo->results;
void *params = ReInfo->params;
// Prepare for next session if any left in the event.
curRaceIdx = (int)GfParmGetNum(results, RE_SECT_CURRENT, RE_ATTR_CUR_RACE, NULL, 1);
if (curRaceIdx < GfParmGetEltNb(params, RM_SECT_RACES)) {
// Next session.
curRaceIdx++;
GfLogInfo("Next session will be #%d\n", curRaceIdx);
GfParmSetNum(results, RE_SECT_CURRENT, RE_ATTR_CUR_RACE, NULL, (tdble)curRaceIdx);
// Update standings in the results file.
ReUpdateStandings();
return RM_SYNC | RM_NEXT_RACE;
}
// No more session in the event : update standings in the results file.
ReUpdateStandings();
// Next event if any will start with its first session.
GfParmSetNum(results, RE_SECT_CURRENT, RE_ATTR_CUR_RACE, NULL, 1);
return RM_SYNC | RM_NEXT_STEP;
}
void NetServer::SendStartTimePacket(int &startTime)
{
//Wait RACESTARTDELEAY seconds to start race
m_racestarttime = GfTimeClock()+RACESTARTDELEAY;
PackedBuffer msg;
try
{
msg.pack_ubyte(RACESTARTTIME_PACKET);
msg.pack_double(m_racestarttime);
}
catch (PackedBufferException &e)
{
GfLogFatal("SendStartTimePacket: packed buffer error\n");
}
GfLogTrace("SendStartTimePacket: packed data length=%d\n",
msg.length());
ENetPacket * pPacket = enet_packet_create (msg.buffer(),
msg.length(),
ENET_PACKET_FLAG_RELIABLE);
BroadcastPacket(pPacket,RELIABLECHANNEL);
GfLogInfo("Server Start time is %lf\n",m_racestarttime);
}
void NetServer::SendFinishTimePacket()
{
GfLogTrace("Sending finish Time Packet\n");
NetMutexData *pNData = LockNetworkData();
double time = pNData->m_finishTime;
UnlockNetworkData();
GfLogInfo("Server finish time is %lf\n",time);
PackedBuffer msg;
try
{
msg.pack_ubyte(FINISHTIME_PACKET);
msg.pack_double(time);
}
catch (PackedBufferException &e)
{
GfLogFatal("SendFinishTimePacket: packed buffer error\n");
}
GfLogTrace("SendFinishTimePacket: packed data length=%d\n",
msg.length());
ENetPacket * pPacket = enet_packet_create (msg.buffer(),
msg.length(),
ENET_PACKET_FLAG_RELIABLE);
BroadcastPacket(pPacket,RELIABLECHANNEL);
}
static void
rmCarSettingsMenu(void *pMenu)
{
int nDriverIdx = NetGetNetwork()->GetDriverIdx();
if (nDriverIdx > -1) {
NetDriver driver;
// char newName[64]; Never used
char dname[256];
// check for car change
GfLogInfo("Car %d changed \n", nDriverIdx);
tRmInfo* reInfo = LmRaceEngine().inData();
reInfo->params = GfParmReadFileLocal("config/raceman/networkrace.xml",GFPARM_RMODE_REREAD);
reInfo->_reName = GfParmGetStr(reInfo->params, RM_SECT_HEADER, RM_ATTR_NAME, "");
sprintf(dname, "%s/%d", RM_SECT_DRIVERS, nDriverIdx);
int idx = GfParmGetNum(reInfo->params, dname, RM_ATTR_IDX, "",0);
// Garage menu to change clients car
GfDriver* PCurrentDriver = GfDrivers::self()->getDriver(NETWORKROBOT, idx);
GarageMenu.setPreviousMenuHandle(racemanMenuHdle);
GarageMenu.runMenu(LmRaceEngine().race(), PCurrentDriver);
bGarage = true;
}
}
static void
rmScreenActivate(void * /* dummy */)
{
// Configure the FPS limiter if active.
#ifdef UseFPSLimiter
// Get the max. refresh rate from the screen config params file.
std::ostringstream ossConfFile;
ossConfFile << GfLocalDir() << GFSCR_CONF_FILE;
void* hparmScrConf = GfParmReadFile(ossConfFile.str().c_str(), GFPARM_RMODE_STD);
FPSLimLastTime = 0.0;
FPSLimMaxRate =
GfParmGetNum(hparmScrConf, GFSCR_SECT_VALIDPROPS, GFSCR_ATT_MAXREFRESH, NULL, 0.0);
if (FPSLimMaxRate)
GfLogInfo("FPS limiter is on (%.1f Hz).\n", FPSLimMaxRate);
else
GfLogInfo("FPS limiter is off.\n");
GfParmReleaseHandle(hparmScrConf);
#endif
// Configure the event loop.
GfuiApp().eventLoop().setRecomputeCB(rmUpdateRaceEngine);
GfuiApp().eventLoop().setRedisplayCB(rmRedisplay);
// If not paused ...
#ifdef STARTPAUSED
if ((!rmRacePaused)&&(!rmPreRacePause))
#else
if (!rmRacePaused)
#endif
{
// Reset normal sound volume.
if (LegacyMenu::self().soundEngine())
LegacyMenu::self().soundEngine()->mute(false);
// Resynchronize the race engine.
LmRaceEngine().start();
}
// Request a redisplay for the next event loop.
GfuiApp().eventLoop().postRedisplay();
// The menu changed.
rmbMenuChanged = true;
}
const char* GfSetDataDir(const char *pszPath)
{
if (gfDataDir)
free(gfDataDir);
gfDataDir = makeRunTimeDirPath(pszPath);
GfLogInfo("Data in %s (from %s)\n", gfDataDir, pszPath);
return gfDataDir;
}
void LegacyMenu::onLapCompleted(int nLapIndex)
{
if (nLapIndex <= 0)
return;
GfLogInfo("Lap #%d completed.\n", nLapIndex);
}
const char* GfSetBinDir(const char *pszPath)
{
if (gfBinDir)
free(gfBinDir);
gfBinDir = makeRunTimeDirPath(pszPath);
GfLogInfo("Executables in %s (from %s)\n", gfBinDir, pszPath);
return gfBinDir;
}
void StandardGame::shutdown(void)
{
GfLogInfo("Shutting down StandardGame race engine.\n");
cleanup();
delete _pRace;
}
const char* GfSetLibDir(const char *pszPath)
{
if (gfLibDir)
free(gfLibDir);
gfLibDir = makeRunTimeDirPath(pszPath);
GfLogInfo("Libraries in %s (from %s)\n", gfLibDir, pszPath);
return gfLibDir;
}
const char* GfSetLocalDir(const char *pszPath)
{
if (gfLocalDir)
free(gfLocalDir);
gfLocalDir = makeRunTimeDirPath(pszPath);
GfLogInfo("User settings in %s (from %s)\n", gfLocalDir, pszPath);
return gfLocalDir;
}
static void
rmNetworkServerDisconnect(void * /* dummy */)
{
GfLogInfo("Disconnecting all clients\n");
if (NetGetServer())
NetGetServer()->Disconnect();
GfuiScreenActivate(RmRaceSelectMenuHandle);
}
bool
linuxSetThreadAffinity(int nCPUId)
{
// MacOS X, FreeBSD, OpenBSD, NetBSD, etc ...
#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)
GfLogWarning("Thread affinity not yet implemented on Mac OS X or BSD.\n");
// TODO.
// Linux, Solaris, AIX ... with NPTL (Native POSIX Threads Library)
#elif defined(linux) || defined(__linux__)
// Get the handle for the current thread.
pthread_t hCurrThread = pthread_self();
// Determine the affinity mask to set for the current thread.
cpu_set_t nThreadAffinityMask;
CPU_ZERO(&nThreadAffinityMask);
if (nCPUId == GfAffinityAnyCPU)
{
// No special affinity on any CPU => set "system" affinity mask
// (1 bit for each installed CPU).
for (int nCPUIndex = 0; (unsigned)nCPUIndex < linuxGetNumberOfCPUs(); nCPUIndex++)
{
CPU_SET(nCPUIndex, &nThreadAffinityMask);
}
}
else
{
// Affinity on a specified CPU => compute its mask.
CPU_SET(nCPUId, &nThreadAffinityMask);
}
// Set the affinity mask for the current thread ("stick" it to the target core).
if (pthread_setaffinity_np(hCurrThread, sizeof(nThreadAffinityMask), &nThreadAffinityMask))
{
GfLogError("Failed to set current pthread (handle=0x%X) affinity on CPU(s) %s (%s)\n",
hCurrThread, cpuSet2String(&nThreadAffinityMask).c_str(), strerror(errno));
return false;
}
else
GfLogInfo("Affinity set on CPU(s) %s for current pthread (handle=0x%X)\n",
cpuSet2String(&nThreadAffinityMask).c_str(), hCurrThread);
return true;
// Anything else ... not supported.
#else
#warning "linuxspec.cpp::linuxSetThreadAffinity : Unsupported Linux OS"
GfLogWarning("Thread affinity not yet implemented on this unknown Unix.\n");
#endif
return false;
}
/* Compute Pit stop time */
void
ReCarsUpdateCarPitTime(tCarElt *car)
{
tSituation *s = ReInfo->s;
tReCarInfo *info = &(ReInfo->_reCarInfo[car->index]);
tCarPenalty *penalty;
int i;
// GfLogDebug("ReCarsUpdateCarPitTime(%s) : typ=%d, fuel=%f, rep=%d\n",
// car->_name, car->_pitStopType, car->_pitFuel, car->_pitRepair);
switch (car->_pitStopType) {
case RM_PIT_REPAIR:
info->totalPitTime = 2.0f + fabs((double)(car->_pitFuel)) / 8.0f + (tdble)(fabs((double)(car->_pitRepair))) * 0.007f;
car->_scheduledEventTime = s->currentTime + info->totalPitTime;
RePhysicsEngine().reconfigureCar(car);
for (i=0; i<4; i++) {
car->_tyreCondition(i) = 1.01f;
car->_tyreT_in(i) = 50.0f;
car->_tyreT_mid(i) = 50.0f;
car->_tyreT_out(i) = 50.0f;
}
GfLogInfo("%s in repair pit stop for %.1f s (refueling by %.1f l, repairing by %d).\n",
car->_name, info->totalPitTime, car->_pitFuel, car->_pitRepair);
break;
case RM_PIT_STOPANDGO:
penalty = GF_TAILQ_FIRST(&(car->_penaltyList));
if (penalty && penalty->penalty == RM_PENALTY_10SEC_STOPANDGO)
info->totalPitTime = 10.0;
else
info->totalPitTime = 0.0;
car->_scheduledEventTime = s->currentTime + info->totalPitTime;
// Prevent car->_state & RM_CAR_STATE_PIT from being true for a too short delay,
// in order for the penalty management to detect it.
if (car->_scheduledEventTime < s->currentTime + RCM_MAX_DT_SIMU)
car->_scheduledEventTime += RCM_MAX_DT_SIMU;
GfLogInfo("%s in Stop-and-Go pit stop for %.1f s.\n", car->_name, info->totalPitTime);
break;
}
}
/*
* Function
* linuxModLoad
*
* Description
* Load the module of given shared library file
* (Load the shared library, then retrieve info about the module (tModInfo struct) ;
* the library is NOT unloaded).
*
* Parameters
* sopath (in) path of the shared library file to load
* modlist (in/out) list of module interfaces description structure (may begin empty)
*
* Return
* 0 Ok
* -1 error
*
* Remarks
* * Nothing done if a module with equal shared library file path-name
* already exists in modlist (WARNING: if same shared library file, but with different
* path-names, like with an absolute and a relative one, the module is loaded again !)
* * The loaded module info structure is added at the HEAD of the list (**modlist)
* (not added, but only moved to HEAD, if a module with equal shared library file path-name
* already exists in modlist).
*
*/
static int
linuxModLoad(unsigned int /* gfid */, const char *sopath, tModList **modlist)
{
tSOHandle handle;
tModList* curMod;
/* Try and avoid loading the same module twice (WARNING: Only checks sopath equality !) */
if ((curMod = GfModIsInList(sopath, *modlist)) != 0)
{
GfLogInfo("Module %s already loaded\n", sopath);
GfModMoveToListHead(curMod, modlist); // Force module to be the first in the list.
return 0;
}
GfLogInfo("Loading module %s\n", sopath);
/* Load the shared library */
handle = dlopen(sopath, RTLD_LAZY);
if (handle)
{
/* Initialize the module */
if (GfModInitialize(handle, sopath, GfIdAny, &curMod) == 0)
{
if (curMod) /* Retained against GfIdAny */
// Add the loaded module at the head of the list (no sort by priority).
GfModAddInList(curMod, modlist, /* priosort */ 0);
}
else
{
dlclose(handle);
GfLogError("linuxModLoad: Module init function failed %s\n", sopath);
return -1;
}
}
else
{
GfLogError("linuxModLoad: ... %s\n", dlerror());
return -1;
}
return 0;
}
double NetServer::WaitForRaceStart()
{
int startTime;
SendStartTimePacket(startTime);
GfLogInfo("Server waiting to start the race\n");
double time = GfTimeClock()-m_racestarttime;
return time;
}
int
ReRaceEventInit(void)
{
void *mainParams = ReInfo->mainParams;
void *params = ReInfo->params;
const bool careerMode = strcmp(GfParmGetStr(ReInfo->mainParams, RM_SECT_SUBFILES, RM_ATTR_HASSUBFILES, RM_VAL_NO), RM_VAL_YES) == 0;
/* Career mode : Look if it is necessary to open another file */
if (strcmp(GfParmGetStr(mainParams, RM_SECT_SUBFILES, RM_ATTR_HASSUBFILES, RM_VAL_NO), RM_VAL_YES) == 0)
{
/* Close previous params */
if (params != mainParams)
GfParmReleaseHandle(params);
/* Read the new params */
ReInfo->params = GfParmReadFile( GfParmGetStr( ReInfo->mainResults, RE_SECT_CURRENT, RE_ATTR_CUR_FILE, "" ), GFPARM_RMODE_STD );
GfLogTrace("Career : New params file is %s (from main results file)\n",
GfParmGetStr( ReInfo->mainResults, RE_SECT_CURRENT, RE_ATTR_CUR_FILE, ""));
if (!ReInfo->params)
GfLogWarning( "Career : MainResults params weren't read correctly\n" );
/* Close previous results */
if (ReInfo->results != ReInfo->mainResults)
{
GfParmWriteFile(NULL, ReInfo->results, NULL);
GfParmReleaseHandle(ReInfo->results);
}
/* Read the new results */
ReInfo->results = GfParmReadFile( GfParmGetStr( ReInfo->params, RM_SECT_SUBFILES, RM_ATTR_RESULTSUBFILE, ""), GFPARM_RMODE_STD );
if (!ReInfo->results)
GfLogWarning( "Career : New results weren't read correctly\n" );
}
// Initialize the race session name.
ReInfo->_reRaceName = ReGetCurrentRaceName();
GfLogInfo("Starting new event (%s session)\n", ReInfo->_reRaceName);
ReUI().onRaceEventInitializing();
ReInfo->s->_features = RmGetFeaturesList(ReInfo->params);
ReTrackInit();
ReEventInitResults();
NoCleanupNeeded = false;
const bool bGoOnLooping = ReUI().onRaceEventStarting(careerMode && !ReHumanInGroup());
return (bGoOnLooping ? RM_SYNC : RM_ASYNC) | RM_NEXT_STEP;
}
int
ReNetworkWaitReady()
{
// No wait if not an online race.
if (!NetGetNetwork())
return RM_SYNC | RM_NEXT_STEP;
// If network race, wait for other players and start when the server tells to
bool bWaitFinished = false;
if (NetGetClient())
{
NetGetClient()->SendReadyToStartPacket();
ReInfo->s->currentTime = NetGetClient()->WaitForRaceStart();
GfLogInfo("Client beginning race in %lf seconds!\n", - ReInfo->s->currentTime);
bWaitFinished = true;
}
else if (NetGetServer())
{
if (NetGetServer()->ClientsReadyToRace())
{
ReInfo->s->currentTime = NetGetServer()->WaitForRaceStart();
GfLogInfo("Server beginning race in %lf seconds!\n", - ReInfo->s->currentTime);
bWaitFinished = true;
}
}
if (bWaitFinished)
{
ReSituation::self().setRaceMessage("", -1/*always*/, /*big=*/true);
return RM_SYNC | RM_NEXT_STEP;
}
else
{
ReSituation::self().setRaceMessage("Waiting for online players",
-1/*always*/, /*big=*/true);
return RM_ASYNC;
}
}
bool LegacyMenu::onRaceEventStarting(bool careerNonHumanGroup)
{
tRmInfo* pReInfo = _piRaceEngine->inData();
if (GfParmGetEltNb(pReInfo->params, RM_SECT_TRACKS) > 1)
{
if (!careerNonHumanGroup)
{
::RmNextEventMenu();
return false; // Tell the race engine state automaton to stop looping (enter the menu).
}
else
{
GfLogInfo("Not starting Next Event menu, because there is no human in the race");
return true;
}
}
GfLogInfo("Not starting Next Event menu, as only one track to race on.\n");
return true; // Tell the race engine state automaton to go on looping.
}
static void
rmToggleMovieCapture(void * /* dummy */)
{
if (!rmMovieCapture.enabled)
{
GfLogWarning("Movie capture is not enabled : command ignored\n");
return;
}
if (!(LmRaceEngine().outData()->_displayMode & RM_DISP_MODE_NORMAL))
{
GfLogWarning("Movie capture is available only in normal display mode : command ignored\n");
return;
}
rmMovieCapture.active = !rmMovieCapture.active;
if (rmMovieCapture.active)
{
// Try and change the race engine scheduling scheme for movie capture.
if (LmRaceEngine().setSchedulingSpecs(rmMovieCapture.simuRate, rmMovieCapture.frameRate))
{
rmMovieCapture.currentFrame = 0;
rmMovieCapture.currentCapture++;
GfLogInfo("Starting movie capture\n");
}
else
{
// Not supported (multi-threaded mode).
rmMovieCapture.active = false;
GfLogWarning("Movie capture not supported in multi-threaded mode : command ignored\n");
}
}
else
{
GfLogInfo("Stopping movie capture\n");
LmRaceEngine().setSchedulingSpecs(1.0 / RCM_MAX_DT_SIMU);
LmRaceEngine().start(); // Resynchronize the race engine.
}
}
/*
* Function
* linuxGetNumberOfCPUs
*
* Description
* Retrieve the actual number of CPUs in the system
* Note that a core is considered here as a "CPU", and an Intel hyper-threaded processor
* will report twice as many "CPUs" as actual cores ...
*
* Parameters
* None
*
* Return
* The number of CPUs in the system
*
* Remarks
* WARNING: Not tested under platforms other than Linux : Mac OS X, BSD, Solaris, AIX.
*
*/
unsigned linuxGetNumberOfCPUs()
{
static unsigned nCPUs = 0;
if (nCPUs == 0)
{
// MacOS X, FreeBSD, OpenBSD, NetBSD, etc ...
#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)
nt mib[4];
size_t len;
// Set the mib for hw.ncpu
// Get the number of CPUs from the system
// 1) Try HW_AVAILCPU first.
mib[0] = CTL_HW;
mib[1] = HW_AVAILCPU; // alternatively, try HW_NCPU;
sysctl(mib, 2, &nCPUs, &len, NULL, 0);
if (nCPUs < 1)
{
// 2) Try alternatively HW_NCPU.
mib[1] = HW_NCPU;
sysctl(mib, 2, &nCPUs, &len, NULL, 0);
}
// Linux, Solaris, AIX
#elif defined(linux) || defined(__linux__)
nCPUs = (unsigned)sysconf(_SC_NPROCESSORS_ONLN);
// Anything else ... not supported.
#else
#warning "Unsupported Linux OS"
#endif
if (nCPUs < 1)
{
GfLogWarning("Could not get the number of CPUs here ; assuming only 1\n");
nCPUs = 1;
}
else
GfLogInfo("Detected %d CPUs\n", nCPUs);
}
return nCPUs;
}
static void
rmInitMovieCapture()
{
// Don't do it twice.
if (rmMovieCapture.outputBase)
return;
// But do it the first time.
char buf[256];
snprintf(buf, sizeof(buf), "%s%s", GfLocalDir(), RACE_ENG_CFG);
void* hparmRaceEng = GfParmReadFile(buf, GFPARM_RMODE_REREAD | GFPARM_RMODE_CREAT);
rmMovieCapture.enabled =
strcmp(GfParmGetStr(hparmRaceEng, RM_SECT_MOVIE_CAPTURE, RM_ATT_CAPTURE_ENABLE,
RM_VAL_NO),
RM_VAL_NO) ? true : false;
rmMovieCapture.active = false;
if (!rmMovieCapture.enabled)
{
rmMovieCapture.outputBase = 0;
GfLogInfo("Movie capture disabled (see raceengine.xml)\n");
}
else
{
rmMovieCapture.frameRate =
GfParmGetNum(hparmRaceEng, RM_SECT_MOVIE_CAPTURE, RM_ATT_CAPTURE_FPS, NULL, 25.0);
rmMovieCapture.simuRate = 1.0 / RCM_MAX_DT_SIMU;
char pszDefOutputBase[256];
snprintf(pszDefOutputBase, sizeof(pszDefOutputBase), "%s%s",
GfLocalDir(), GfParmGetStr(hparmRaceEng, RM_SECT_MOVIE_CAPTURE,
RM_ATT_CAPTURE_OUT_DIR, "captures"));
rmMovieCapture.outputBase = strdup(pszDefOutputBase);
GfDirCreate(pszDefOutputBase); // In case not already done.
GfLogInfo("Movie capture enabled (%.0f FPS, PNG frames in %s)\n",
rmMovieCapture.frameRate, rmMovieCapture.outputBase);
}
}
void ReSituationUpdater::stop()
{
GfLogInfo("Stopping race engine.\n");
// Lock the race engine data.
ReSituation::self().lock("ReSituationUpdater::stop");
// Reset the running flags.
ReSituation::self().data()->_reRunning = 0;
ReSituation::self().data()->s->_raceState |= RM_RACE_PAUSED;
// Unlock the race engine data.
ReSituation::self().unlock("ReSituationUpdater::stop");
}
/* Prepare to open the pit menu when back in the main updater (thread) */
static void
reCarsSchedulePitMenu(tCarElt *car)
{
// Do nothing if one car is already scheduled for the pit menu
// (this one will have to wait for the current one exiting from the menu)
if (ReInfo->_rePitRequester)
{
GfLogInfo("%s would like to pit, but the pit menu is already in use.\n", car->_name);
return;
}
// Otherwise, "post" a pit menu request for this car.
ReInfo->_rePitRequester = car;
}
void SDScreens::changeScreen(long p)
{
switch (p)
{
case SD_NEXT_SCREEN:
m_CurrentScreenIndex = (m_CurrentScreenIndex + 1) % m_NbActiveScreens;
break;
case SD_PREV_SCREEN:
m_CurrentScreenIndex = (m_CurrentScreenIndex - 1 + m_NbActiveScreens) % m_NbActiveScreens;
break;
}
GfLogInfo("Changing current screen to #%d (out of %d)\n", m_CurrentScreenIndex, m_NbActiveScreens);
}
