uint16_t InitEnvironment(const std::vector<std::string> &defines)
{
void EnvLoadFile(const std::string &envfile);
void EnvLoadArray(const std::vector<std::string> &data);
std::string m(RootDir());
if (!m.empty())
{
std::string mm = ToolBox::UnixToMac(m);
if (mm.back() != ':') mm.push_back(':');
Environment.emplace(std::string("MPW"), mm);
}
if (defines.size())
EnvLoadArray(defines);
if (!m.empty())
{
std::string path(RootDirPathForFile("Environment.text"));
EnvLoadFile(path);
}
return 0;
}
std::string RootDirPathForFile(const std::string &file)
{
std::string dir(RootDir());
if (dir.length() && dir.back() != '/') dir.push_back('/');
dir.append(file);
return dir;
}
optional<unique_ref<fspp::Node>> CopyDevice::Load(const bf::path &path) {
auto real_path = RootDir() / path;
if(bf::is_symlink(real_path)) { //We have to check for symlink first, because bf::is_directory/bf::is_regular_file return true if the symlink is pointing to a respective entry
return optional<unique_ref<fspp::Node>>(make_unique_ref<CopySymlink>(this, path));
}else if(bf::is_directory(real_path)) {
return optional<unique_ref<fspp::Node>>(make_unique_ref<CopyDir>(this, path));
} else if(bf::is_regular_file(real_path)) {
return optional<unique_ref<fspp::Node>>(make_unique_ref<CopyFile>(this, path));
}
throw fspp::fuse::FuseErrnoException(ENOENT);
}
void FLinuxMisc::NormalizePath(FString& InPath)
{
// only lowercase part of the path that is under root (if we know it)
if (GHaveRootDir)
{
static FString Root = RootDir();
// if absolute path begins at root
if (InPath.Find(Root, ESearchCase::IgnoreCase) == 0)
{
InPath = FPaths::Combine(*Root, *InPath.RightChop(Root.Len()).ToLower());
}
}
if (InPath.Contains(TEXT("~"), ESearchCase::CaseSensitive)) // case sensitive is quicker, and our substring doesn't care
{
static bool bHaveHome = false;
static TCHAR CachedResult[ PlatformMiscLimits::MaxUserHomeDirLength ] = TEXT("~"); // init with a default value that changes nothing
if (!bHaveHome)
{
// get user $HOME var first
const char * VarValue = __secure_getenv("HOME");
if (NULL != VarValue)
{
FCString::Strcpy(CachedResult, ARRAY_COUNT(CachedResult) - 1, ANSI_TO_TCHAR(VarValue));
bHaveHome = true;
}
// if var failed
if (!bHaveHome)
{
struct passwd * UserInfo = getpwuid(getuid());
if (NULL != UserInfo && NULL != UserInfo->pw_dir)
{
FCString::Strcpy(CachedResult, ARRAY_COUNT(CachedResult) - 1, ANSI_TO_TCHAR(UserInfo->pw_dir));
bHaveHome = true;
}
else
{
// fail for realz
UE_LOG(LogInit, Fatal, TEXT("Could not get determine user home directory."));
}
}
}
InPath = InPath.Replace(TEXT("~"), CachedResult, ESearchCase::CaseSensitive);
}
}
void FFileManagerGeneric::FindFiles(TArray<FString>& FoundFiles, const TCHAR* Directory, const TCHAR* FileExtension)
{
if (!Directory)
{
return;
}
FString RootDir(Directory);
FString ExtStr = (FileExtension != nullptr) ? FString(FileExtension) : "";
// No Directory?
if (RootDir.Len() < 1)
{
return;
}
FPaths::NormalizeDirectoryName(RootDir);
// Don't modify the ExtStr if the user supplied the form "*.EXT" or "*" or "*.*" or "Name.*"
if (!ExtStr.Contains(TEXT("*")))
{
if (ExtStr == "")
{
ExtStr = "*.*";
}
else
{
//Complete the supplied extension with * or *. to yield "*.EXT"
ExtStr = (ExtStr.Left(1) == ".") ? "*" + ExtStr : "*." + ExtStr;
}
}
// Create the full filter, which is "Directory/*.EXT".
FString FinalPath = RootDir + "/" + ExtStr;
FindFiles(FoundFiles, *FinalPath, true, false);
}
//------------------------------------------------------------------------------
// reset() --
//------------------------------------------------------------------------------
void JSBSimModel::reset()
{
BaseClass::reset();
pitchTrimPos = (LCreal)0.0;
pitchTrimRate = (LCreal)0.1;
pitchTrimSw = (LCreal)0.0;
rollTrimPos = (LCreal)0.0;
rollTrimRate = (LCreal)0.1;
rollTrimSw = (LCreal)0.0;
// Get our Player (must have one!)
Simulation::Player* p = static_cast<Simulation::Player*>( findContainerByType(typeid(Simulation::Player)) );
if (p == 0) return;
// must have strings set
if (rootDir == 0 || model == 0) return;
// Must also have the JSBSim object
if (fdmex == 0) {
// must have a JSBSim property manager
if (propMgr == 0) {
propMgr = new JSBSim::FGPropertyManager();
}
fdmex = new JSBSim::FGFDMExec(propMgr);
std::string RootDir(rootDir->getString());
fdmex->SetAircraftPath(RootDir + "aircraft");
fdmex->SetEnginePath(RootDir + "engine");
fdmex->SetSystemsPath(RootDir + "systems"); // JSBSim-1.0 or after only
fdmex->LoadModel(model->getString());
JSBSim::FGPropertyManager* propMgr = fdmex->GetPropertyManager();
if (propMgr != 0) {
hasHeadingHold = propMgr->HasNode("ap/heading_hold") && propMgr->HasNode("ap/heading_setpoint");
hasVelocityHold = propMgr->HasNode("ap/airspeed_hold") && propMgr->HasNode("ap/airspeed_setpoint");
hasAltitudeHold = propMgr->HasNode("ap/altitude_hold") && propMgr->HasNode("ap/altitude_setpoint");
#if 0
// CGB this isn't working for some reason. I set the values directly in "dynamics" for now.
if (hasHeadingHold) {
propMgr->Tie("ap/heading_hold", this, &JSBSimModel::isHeadingHoldOn);
propMgr->Tie("ap/heading_setpoint", this, &JSBSimModel::getCommandedHeadingD);
}
if (hasVelocityHold) {
propMgr->Tie("ap/airspeed_hold", this, &JSBSimModel::isVelocityHoldOn);
propMgr->Tie("ap/airspeed_setpoint", this, &JSBSimModel::getCommandedVelocityKts);
}
if (hasAltitudeHold) {
propMgr->Tie("ap/altitude_hold", this, &JSBSimModel::isAltitudeHoldOn);
propMgr->Tie("ap/altitude_setpoint", this, &JSBSimModel::getCommandedAltitude * Basic::Distance::M2FT);
}
#endif
}
}
#if 0
// CGB TBD
reset = 0;
freeze = 0;
#endif
JSBSim::FGInitialCondition* fgic = fdmex->GetIC();
if (fgic == 0) return;
fgic->SetAltitudeASLFtIC(Basic::Distance::M2FT * p->getAltitude());
#if 0
fgic->SetTrueHeadingDegIC(Basic::Angle::R2DCC * p->getHeading());
fgic->SetRollAngleDegIC(Basic::Angle::R2DCC * p->getRoll());
fgic->SetPitchAngleDegIC(Basic::Angle::R2DCC * p->getPitch());
#else
fgic->SetPsiDegIC(Basic::Angle::R2DCC * p->getHeading());
fgic->SetPhiDegIC(Basic::Angle::R2DCC * p->getRoll());
fgic->SetThetaDegIC(Basic::Angle::R2DCC * p->getPitch());
#endif
fgic->SetVtrueKtsIC(Basic::Distance::M2NM * p->getTotalVelocity() * 3600.0f);
fgic->SetLatitudeDegIC(p->getInitLatitude());
fgic->SetLongitudeDegIC(p->getInitLongitude());
JSBSim::FGPropulsion* Propulsion = fdmex->GetPropulsion();
JSBSim::FGFCS* FCS = fdmex->GetFCS();
if (Propulsion != 0 && FCS != 0) {
Propulsion->SetMagnetos(3);
for (unsigned int i=0; i < Propulsion->GetNumEngines(); i++) {
FCS->SetMixtureCmd(i, 1.0);
FCS->SetThrottleCmd(i, 1.0);
FCS->SetPropAdvanceCmd(i, 1.0);
FCS->SetMixturePos(i, 1.0);
FCS->SetThrottlePos(i, 1.0);
FCS->SetPropAdvance(i, 1.0);
JSBSim::FGEngine* eng = Propulsion->GetEngine(i);
eng->SetRunning(true);
JSBSim::FGThruster* thruster = eng->GetThruster();
thruster->SetRPM(1000.0);
}
Propulsion->SetFuelFreeze(p->isFuelFrozen());
Propulsion->InitRunning(-1); // -1 refers to "All Engines"
Propulsion->GetSteadyState();
}
fdmex->RunIC();
}
void CopyDevice::statfs(const bf::path &path, struct statvfs *fsstat) {
auto real_path = RootDir() / path;
int retval = ::statvfs(real_path.c_str(), fsstat);
CHECK_RETVAL(retval);
}
