bool UGameEngine::HandleExitCommand( const TCHAR* Cmd, FOutputDevice& Ar )
{
Ar.Log( TEXT("Closing by request") );
FGameDelegates::Get().GetExitCommandDelegate().Broadcast();
FPlatformMisc::RequestExit( 0 );
return true;
}
bool UGameEngine::HandleMinimizeCommand( const TCHAR *Cmd, FOutputDevice &Ar )
{
Ar.Log( TEXT("Minimize by request") );
FPlatformMisc::RequestMinimize();
return true;
}
virtual bool Exec( class UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar )
{
if (FParse::Command(&Cmd, TEXT("TOGGLESTATECACHE")))
{
GD3D11SkipStateCaching = !GD3D11SkipStateCaching;
Ar.Log(FString::Printf(TEXT("D3D11 State Caching: %s"), GD3D11SkipStateCaching ? TEXT("OFF") : TEXT("ON")));
return true;
}
return false;
}
bool VZipFileReader::Close()
{
guard(VZipFileReader::Close);
if (rest_read_uncompressed == 0)
{
if (Crc32 != Info.crc)
{
bError = true;
Error->Log("Bad CRC");
}
}
if (stream_initialised)
{
inflateEnd(&stream);
}
stream_initialised = false;
return !bError;
unguard;
}
/** After the stack tracker reports a given stack trace, it calls this function
* which appends data particular to line checks
*/
static void LineCheckReportFn(const FStackTracker::FCallStack& CallStack, uint64 TotalStackCount, FOutputDevice& Ar)
{
//Output to a csv file any relevant data
LineCheckTracker::FLineCheckData* const LCData = static_cast<LineCheckTracker::FLineCheckData*>(CallStack.UserData);
if (LCData)
{
FString UserOutput = LINE_TERMINATOR TEXT(",,,");
UserOutput += (LCData->IsNonZeroExtent ? TEXT( "NonZeroExtent") : TEXT("ZeroExtent"));
for (TMap<const FName, LineCheckTracker::FLineCheckData::LineCheckObj>::TConstIterator It(LCData->LineCheckObjsMap); It; ++It)
{
UserOutput += LINE_TERMINATOR TEXT(",,,");
const LineCheckTracker::FLineCheckData::LineCheckObj &CurObj = It.Value();
UserOutput += FString::Printf(TEXT("%s (%d) : %s"), *CurObj.ObjectName.ToString(), CurObj.Count, *CurObj.DetailedInfo);
}
UserOutput += LINE_TERMINATOR TEXT(",,,");
Ar.Log(*UserOutput);
}
}
bool UGameEngine::HandleExitCommand( const TCHAR* Cmd, FOutputDevice& Ar )
{
for (int32 WorldIndex = 0; WorldIndex < WorldList.Num(); ++WorldIndex)
{
UWorld* const World = WorldList[WorldIndex].World();
AGameMode* const GameMode = World->GetAuthGameMode();
if (GameMode)
{
GameMode->GameEnding();
}
// Cancel any pending connection to a server
CancelPending(WorldList[WorldIndex]);
// Shut down any existing game connections
ShutdownWorldNetDriver(World);
}
Ar.Log( TEXT("Closing by request") );
FPlatformMisc::RequestExit( 0 );
return true;
}
//
// Command line.
//
UBOOL UXViewport::Exec( const TCHAR* Cmd, FOutputDevice& Ar )
{
guard(UXViewport::Exec);
if( UViewport::Exec( Cmd, Ar ) )
{
return 1;
}
else if( ParseCommand(&Cmd,TEXT("EndFullscreen")) )
{
EndFullscreen();
return 1;
}
else if( ParseCommand(&Cmd,TEXT("ToggleFullscreen")) )
{
ToggleFullscreen();
return 1;
}
else if( ParseCommand(&Cmd,TEXT("Iconify")) )
{
Iconify();
return 1;
}
else if( ParseCommand(&Cmd,TEXT("GetCurrentRes")) )
{
Ar.Logf( TEXT("%ix%i"), SizeX, SizeY, (ColorBytes?ColorBytes:2)*8 );
return 1;
}
else if( ParseCommand(&Cmd,TEXT("GetCurrentColorDepth")) )
{
Ar.Logf( TEXT("%i"), (ColorBytes?ColorBytes:2)*8 );
return 1;
}
else if( ParseCommand(&Cmd,TEXT("GetColorDepths")) )
{
Ar.Log( TEXT("16 32") );
return 1;
}
else if( ParseCommand(&Cmd,TEXT("GetCurrentRenderDevice")) )
{
Ar.Log( RenDev->GetClass()->GetPathName() );
return 1;
}
else if( ParseCommand(&Cmd,TEXT("SetRenderDevice")) )
{
FString Saved = RenDev->GetClass()->GetPathName();
INT SavedSizeX=SizeX, SavedSizeY=SizeY, SavedColorBytes=ColorBytes, SavedFullscreen=((BlitFlags & BLIT_Fullscreen)!=0);
TryRenderDevice( Cmd, SizeX, SizeY, ColorBytes, SavedFullscreen );
if( !RenDev )
{
TryRenderDevice( *Saved, SavedSizeX, SavedSizeY, SavedColorBytes, SavedFullscreen );
check(RenDev);
Ar.Log(TEXT("0"));
}
else Ar.Log(TEXT("1"));
return 1;
}
else if( ParseCommand(&Cmd,TEXT("GetRes")) )
{
return 1;
}
else if( ParseCommand(&Cmd,TEXT("SetRes")) )
{
INT X=appAtoi(Cmd);
TCHAR* CmdTemp = (TCHAR*) (appStrchr(Cmd,'x') ? appStrchr(Cmd,'x')+1 : appStrchr(Cmd,'X') ? appStrchr(Cmd,'X')+1 : TEXT(""));
INT Y=appAtoi(CmdTemp);
Cmd = CmdTemp;
CmdTemp = (TCHAR*) (appStrchr(Cmd,'x') ? appStrchr(Cmd,'x')+1 : appStrchr(Cmd,'X') ? appStrchr(Cmd,'X')+1 : TEXT(""));
INT C=appAtoi(CmdTemp);
INT NewColorBytes = C ? C/8 : ColorBytes;
if( X && Y )
{
HoldCount++;
UBOOL Result = RenDev->SetRes( X, Y, NewColorBytes, IsFullscreen() );
HoldCount--;
if( !Result )
EndFullscreen();
}
return 1;
}
else if( ParseCommand(&Cmd,TEXT("Preferences")) )
{
// No preferences window.
return 1;
}
else return 0;
unguard;
}
FProcHandle FDesktopPlatformBase::InvokeUnrealBuildToolAsync(const FString& InCmdLineParams, FOutputDevice &Ar, void*& OutReadPipe, void*& OutWritePipe, bool bSkipBuildUBT)
{
FString CmdLineParams = InCmdLineParams;
#if PLATFORM_WINDOWS
#if _MSC_VER >= 1900
CmdLineParams += TEXT(" -2015");
#elif _MSC_VER >= 1800
CmdLineParams += TEXT(" -2013");
#else
CmdLineParams += TEXT(" -2012");
#endif
#endif // PLATFORM_WINDOWS
// UnrealBuildTool is currently always located in the Binaries/DotNET folder
FString ExecutableFileName = GetUnrealBuildToolExecutableFilename(FPaths::RootDir());
// Rocket never builds UBT, UnrealBuildTool should already exist
bool bSkipBuild = FApp::IsEngineInstalled() || bSkipBuildUBT;
if (!bSkipBuild)
{
// When not using rocket, we should attempt to build UBT to make sure it is up to date
// Only do this if we have not already successfully done it once during this session.
static bool bSuccessfullyBuiltUBTOnce = false;
if (!bSuccessfullyBuiltUBTOnce)
{
Ar.Log(TEXT("Building UnrealBuildTool..."));
if (BuildUnrealBuildTool(FPaths::RootDir(), Ar))
{
bSuccessfullyBuiltUBTOnce = true;
}
else
{
// Failed to build UBT
Ar.Log(TEXT("Failed to build UnrealBuildTool."));
return FProcHandle();
}
}
}
#if PLATFORM_LINUX
CmdLineParams += (" -progress");
#endif // PLATFORM_LINUX
Ar.Logf(TEXT("Launching UnrealBuildTool... [%s %s]"), *ExecutableFileName, *CmdLineParams);
#if PLATFORM_MAC
// On Mac we launch UBT with Mono
FString ScriptPath = FPaths::ConvertRelativePathToFull(FPaths::EngineDir() / TEXT("Build/BatchFiles/Mac/RunMono.sh"));
CmdLineParams = FString::Printf(TEXT("\"%s\" \"%s\" %s"), *ScriptPath, *ExecutableFileName, *CmdLineParams);
ExecutableFileName = TEXT("/bin/sh");
#elif PLATFORM_LINUX
// Real men run Linux (with Mono??)
FString ScriptPath = FPaths::ConvertRelativePathToFull(FPaths::EngineDir() / TEXT("Build/BatchFiles/Linux/RunMono.sh"));
CmdLineParams = FString::Printf(TEXT("\"%s\" \"%s\" %s"), *ScriptPath, *ExecutableFileName, *CmdLineParams);
ExecutableFileName = TEXT("/bin/bash");
#endif
// Run UnrealBuildTool
const bool bLaunchDetached = false;
const bool bLaunchHidden = true;
const bool bLaunchReallyHidden = bLaunchHidden;
FProcHandle ProcHandle = FPlatformProcess::CreateProc(*ExecutableFileName, *CmdLineParams, bLaunchDetached, bLaunchHidden, bLaunchReallyHidden, NULL, 0, NULL, OutWritePipe);
if (!ProcHandle.IsValid())
{
Ar.Logf(TEXT("Failed to launch Unreal Build Tool. (%s)"), *ExecutableFileName);
}
return ProcHandle;
}
bool FDesktopPlatformBase::BuildUnrealBuildTool(const FString& RootDir, FOutputDevice& Ar)
{
Ar.Logf(TEXT("Building UnrealBuildTool in %s..."), *RootDir);
// Check the project file exists
FString CsProjLocation = GetUnrealBuildToolProjectFileName(RootDir);
if(!FPaths::FileExists(CsProjLocation))
{
Ar.Logf(TEXT("Project file not found at %s"), *CsProjLocation);
return false;
}
FString CompilerExecutableFilename;
FString CmdLineParams;
if (PLATFORM_WINDOWS)
{
// To build UBT for windows, we must assemble a batch file that first registers the environment variable necessary to run msbuild then run it
// This can not be done in a single invocation of CMD.exe because the environment variables do not transfer between subsequent commands when using the "&" syntax
// devenv.exe can be used to build as well but it takes several seconds to start up so it is not desirable
// First determine the appropriate vcvars batch file to launch
FString VCVarsBat;
#if PLATFORM_WINDOWS
#if _MSC_VER >= 1900
FPlatformMisc::GetVSComnTools(14, VCVarsBat);
#elif _MSC_VER >= 1800
FPlatformMisc::GetVSComnTools(12, VCVarsBat);
#else
FPlatformMisc::GetVSComnTools(11, VCVarsBat);
#endif
#endif // PLATFORM_WINDOWS
VCVarsBat = FPaths::Combine(*VCVarsBat, L"../../VC/bin/x86_amd64/vcvarsx86_amd64.bat");
// Check to make sure we found one.
if (VCVarsBat.IsEmpty() || !FPaths::FileExists(VCVarsBat))
{
Ar.Logf(TEXT("Couldn't find %s; skipping."), *VCVarsBat);
return false;
}
// Now make a batch file in the intermediate directory to invoke the vcvars batch then msbuild
FString BuildBatchFile = RootDir / TEXT("Engine/Intermediate/Build/UnrealBuildTool/BuildUBT.bat");
BuildBatchFile.ReplaceInline(TEXT("/"), TEXT("\\"));
FString BatchFileContents;
BatchFileContents = FString::Printf(TEXT("call \"%s\"") LINE_TERMINATOR, *VCVarsBat);
BatchFileContents += FString::Printf(TEXT("msbuild /nologo /verbosity:quiet \"%s\" /property:Configuration=Development /property:Platform=AnyCPU"), *CsProjLocation);
FFileHelper::SaveStringToFile(BatchFileContents, *BuildBatchFile);
TCHAR CmdExePath[MAX_PATH];
FPlatformMisc::GetEnvironmentVariable(TEXT("ComSpec"), CmdExePath, ARRAY_COUNT(CmdExePath));
CompilerExecutableFilename = CmdExePath;
CmdLineParams = FString::Printf(TEXT("/c \"%s\""), *BuildBatchFile);
}
else if (PLATFORM_MAC)
{
FString ScriptPath = FPaths::ConvertRelativePathToFull(RootDir / TEXT("Engine/Build/BatchFiles/Mac/RunXBuild.sh"));
CompilerExecutableFilename = TEXT("/bin/sh");
CmdLineParams = FString::Printf(TEXT("\"%s\" /property:Configuration=Development %s"), *ScriptPath, *CsProjLocation);
}
else if (PLATFORM_LINUX)
{
FString ScriptPath = FPaths::ConvertRelativePathToFull(RootDir / TEXT("Engine/Build/BatchFiles/Linux/RunXBuild.sh"));
CompilerExecutableFilename = TEXT("/bin/bash");
CmdLineParams = FString::Printf(TEXT("\"%s\" /property:Configuration=Development /property:TargetFrameworkVersion=v4.0 %s"), *ScriptPath, *CsProjLocation);
}
else
{
Ar.Log(TEXT("Unknown platform, unable to build UnrealBuildTool."));
return false;
}
// Spawn the compiler
Ar.Logf(TEXT("Running: %s %s"), *CompilerExecutableFilename, *CmdLineParams);
const bool bLaunchDetached = false;
const bool bLaunchHidden = true;
const bool bLaunchReallyHidden = bLaunchHidden;
FProcHandle ProcHandle = FPlatformProcess::CreateProc(*CompilerExecutableFilename, *CmdLineParams, bLaunchDetached, bLaunchHidden, bLaunchReallyHidden, NULL, 0, NULL, NULL);
if (!ProcHandle.IsValid())
{
Ar.Log(TEXT("Failed to start process."));
return false;
}
FPlatformProcess::WaitForProc(ProcHandle);
FPlatformProcess::CloseProc(ProcHandle);
// If the executable appeared where we expect it, then we were successful
FString UnrealBuildToolExePath = GetUnrealBuildToolExecutableFilename(RootDir);
if(!FPaths::FileExists(UnrealBuildToolExePath))
{
Ar.Logf(TEXT("Missing %s after build"), *UnrealBuildToolExePath);
return false;
}
return true;
}
bool UGameEngine::Exec( UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar )
{
if( FParse::Command( &Cmd,TEXT("REATTACHCOMPONENTS")) || FParse::Command( &Cmd,TEXT("REREGISTERCOMPONENTS")))
{
UE_LOG(LogConsoleResponse, Warning, TEXT("Deprectated command! Please use 'Reattach.Components' instead."));
return true;
}
else if( FParse::Command( &Cmd,TEXT("EXIT")) || FParse::Command(&Cmd,TEXT("QUIT")))
{
FString CmdName = FParse::Token(Cmd, 0);
bool Background = false;
if (!CmdName.IsEmpty() && !FCString::Stricmp(*CmdName, TEXT("background")))
{
Background = true;
}
if ( Background && FPlatformProperties::SupportsMinimize() )
{
return HandleMinimizeCommand( Cmd, Ar );
}
else if ( FPlatformProperties::SupportsQuit() )
{
return HandleExitCommand( Cmd, Ar );
}
else
{
// ignore command on xbox one and ps4 as it will cause a crash
// ttp:321126
return true;
}
}
else if( FParse::Command( &Cmd, TEXT("GETMAXTICKRATE") ) )
{
return HandleGetMaxTickRateCommand( Cmd, Ar );
}
else if( FParse::Command( &Cmd, TEXT("CANCEL") ) )
{
return HandleCancelCommand( Cmd, Ar, InWorld );
}
else if ( FParse::Command( &Cmd, TEXT("TOGGLECVAR") ) )
{
FString CVarName;
FParse::Token(Cmd, CVarName, false);
bool bEnoughParamsSupplied = false;
IConsoleVariable * CVar = nullptr;
if (CVarName.Len() > 0)
{
CVar = IConsoleManager::Get().FindConsoleVariable(*CVarName);
}
if (CVar)
{
// values to toggle between
FString StringVal1, StringVal2;
if (FParse::Token(Cmd, StringVal1, false))
{
if (FParse::Token(Cmd, StringVal2, false))
{
bEnoughParamsSupplied = true;
FString CurrentValue = CVar->GetString();
FString Command(FString::Printf(TEXT("%s %s"), *CVarName, (CurrentValue == StringVal1) ? *StringVal2 : *StringVal1));
GEngine->Exec(InWorld, *Command);
}
}
}
else
{
Ar.Log(*FString::Printf(TEXT("TOGGLECVAR: cvar '%s' was not found"), *CVarName));
bEnoughParamsSupplied = true; // cannot say anything about the rest of parameters
}
if (!bEnoughParamsSupplied)
{
Ar.Log(TEXT("Usage: TOGGLECVAR CVarName Value1 Value2"));
}
return true;
}
#if !UE_BUILD_SHIPPING
else if( FParse::Command( &Cmd, TEXT("ApplyUserSettings") ) )
{
return HandleApplyUserSettingsCommand( Cmd, Ar );
}
#endif // !UE_BUILD_SHIPPING
else if( InWorld && InWorld->Exec( InWorld, Cmd, Ar ) )
{
return true;
}
else if( InWorld && InWorld->GetAuthGameMode() && InWorld->GetAuthGameMode()->ProcessConsoleExec(Cmd,Ar,NULL) )
{
return true;
}
else
{
#if UE_BUILD_SHIPPING
// disallow set of actor properties if network game
if ((FParse::Command( &Cmd, TEXT("SET")) || FParse::Command( &Cmd, TEXT("SETNOPEC"))))
{
FWorldContext &Context = GetWorldContextFromWorldChecked(InWorld);
if( Context.PendingNetGame != NULL || InWorld->GetNetMode() != NM_Standalone)
{
return true;
}
// the effects of this cannot be easily reversed, so prevent the user from playing network games without restarting to avoid potential exploits
GDisallowNetworkTravel = true;
}
#endif // UE_BUILD_SHIPPING
if (UEngine::Exec(InWorld, Cmd, Ar))
{
return true;
}
else if (UPlatformInterfaceBase::StaticExec(Cmd, Ar))
{
return true;
}
return false;
}
}
void VZipFileReader::Serialise(void* V, int Length)
{
guard(VZipFileReader::Serialise);
if (bError)
{
// Don't read anything from already broken stream.
return;
}
if (FileStream->IsError())
{
return;
}
if (Length == 0)
return;
stream.next_out = (Bytef*)V;
stream.avail_out = Length;
if ((vuint32)Length > rest_read_uncompressed)
stream.avail_out = rest_read_uncompressed;
int iRead = 0;
while (stream.avail_out > 0)
{
if (stream.avail_in == 0 && rest_read_compressed > 0)
{
vuint32 uReadThis = UNZ_BUFSIZE;
if (rest_read_compressed < uReadThis)
uReadThis = rest_read_compressed;
FileStream->Seek(pos_in_zipfile);
FileStream->Serialise(ReadBuffer, uReadThis);
if (FileStream->IsError())
{
Error->Log("Failed to read from zip file");
return;
}
pos_in_zipfile += uReadThis;
rest_read_compressed -= uReadThis;
stream.next_in = ReadBuffer;
stream.avail_in = uReadThis;
}
if (Info.compression_method == 0)
{
if (stream.avail_in == 0 && rest_read_compressed == 0)
break;
int uDoCopy;
if (stream.avail_out < stream.avail_in)
uDoCopy = stream.avail_out;
else
uDoCopy = stream.avail_in;
for (int i = 0; i < uDoCopy; i++)
*(stream.next_out + i) = *(stream.next_in + i);
Crc32 = crc32(Crc32, stream.next_out, uDoCopy);
rest_read_uncompressed -= uDoCopy;
stream.avail_in -= uDoCopy;
stream.avail_out -= uDoCopy;
stream.next_out += uDoCopy;
stream.next_in += uDoCopy;
stream.total_out += uDoCopy;
iRead += uDoCopy;
}
else
{
int flush = Z_SYNC_FLUSH;
uLong uTotalOutBefore = stream.total_out;
const Bytef* bufBefore = stream.next_out;
int err = inflate(&stream, flush);
if (err >= 0 && stream.msg != NULL)
{
bError = true;
Error->Logf("Decompression failed: %s", stream.msg);
return;
}
uLong uTotalOutAfter = stream.total_out;
vuint32 uOutThis = uTotalOutAfter - uTotalOutBefore;
Crc32 = crc32(Crc32, bufBefore, (uInt)uOutThis);
rest_read_uncompressed -= uOutThis;
iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
if (err != Z_OK)
break;
}
}
if (iRead != Length)
{
bError = true;
Error->Logf("Only read %d of %d bytes", iRead, Length);
}
unguard;
}
bool VZipFileReader::CheckCurrentFileCoherencyHeader(vuint32* piSizeVar,
vuint32 byte_before_the_zipfile)
{
guard(VZipFileReader::CheckCurrentFileCoherencyHeader);
vuint32 Magic, DateTime, Crc, ComprSize, UncomprSize;
vuint16 Version, Flags, ComprMethod, FileNameSize, ExtraFieldSize;
*piSizeVar = 0;
FileStream->Seek(Info.offset_curfile + byte_before_the_zipfile);
*FileStream
<< Magic
<< Version
<< Flags
<< ComprMethod
<< DateTime
<< Crc
<< ComprSize
<< UncomprSize
<< FileNameSize
<< ExtraFieldSize;
if (Magic != 0x04034b50)
{
Error->Log("Bad file magic");
return false;
}
if (ComprMethod != Info.compression_method)
{
Error->Log("Compression method doesn\'t match");
return false;
}
if ((Crc != Info.crc) && ((Flags & 8) == 0))
{
Error->Log("CRC doesn\'t match");
return false;
}
if ((ComprSize != Info.compressed_size) && ((Flags & 8) == 0))
{
Error->Log("Compressed size doesn\'t match");
return false;
}
if ((UncomprSize != Info.uncompressed_size) && ((Flags & 8) == 0))
{
Error->Log("Uncompressed size doesn\'t match");
return false;
}
if ((FileNameSize != Info.size_filename))
{
Error->Log("File name length doesn\'t match");
return false;
}
*piSizeVar += FileNameSize + ExtraFieldSize;
return true;
unguard;
}