/**
* Perform an editor build with behavior dependent upon the specified id
*
* @param Id Action Id specifying what kind of build is requested
*
* @return true if the build completed successfully; false if it did not (or was manually canceled)
*/
bool FEditorBuildUtils::EditorBuild( UWorld* InWorld, EBuildOptions::Type Id, const bool bAllowLightingDialog )
{
FMessageLog("MapCheck").NewPage(LOCTEXT("MapCheckNewPage", "Map Check"));
// Make sure to set this flag to false before ALL builds.
GEditor->SetMapBuildCancelled( false );
// Will be set to false if, for some reason, the build does not happen.
bool bDoBuild = true;
// Indicates whether the persistent level should be dirtied at the end of a build.
bool bDirtyPersistentLevel = true;
// Stop rendering thread so we're not wasting CPU cycles.
StopRenderingThread();
// Hack: These don't initialize properly and if you pick BuildAll right off the
// bat when opening a map you will get incorrect values in them.
GSwarmDebugOptions.Touch();
// Show option dialog first, before showing the DlgBuildProgress window.
FLightingBuildOptions LightingBuildOptions;
if ( Id == EBuildOptions::BuildLighting )
{
// Retrieve settings from ini.
GConfig->GetBool( TEXT("LightingBuildOptions"), TEXT("OnlyBuildSelected"), LightingBuildOptions.bOnlyBuildSelected, GEditorPerProjectIni );
GConfig->GetBool( TEXT("LightingBuildOptions"), TEXT("OnlyBuildCurrentLevel"), LightingBuildOptions.bOnlyBuildCurrentLevel, GEditorPerProjectIni );
GConfig->GetBool( TEXT("LightingBuildOptions"), TEXT("OnlyBuildSelectedLevels"),LightingBuildOptions.bOnlyBuildSelectedLevels, GEditorPerProjectIni );
GConfig->GetBool( TEXT("LightingBuildOptions"), TEXT("OnlyBuildVisibility"), LightingBuildOptions.bOnlyBuildVisibility, GEditorPerProjectIni );
GConfig->GetBool( TEXT("LightingBuildOptions"), TEXT("UseErrorColoring"), LightingBuildOptions.bUseErrorColoring, GEditorPerProjectIni );
GConfig->GetBool( TEXT("LightingBuildOptions"), TEXT("ShowLightingBuildInfo"), LightingBuildOptions.bShowLightingBuildInfo, GEditorPerProjectIni );
int32 QualityLevel;
GConfig->GetInt( TEXT("LightingBuildOptions"), TEXT("QualityLevel"), QualityLevel, GEditorPerProjectIni );
QualityLevel = FMath::Clamp<int32>(QualityLevel, Quality_Preview, Quality_Production);
LightingBuildOptions.QualityLevel = (ELightingBuildQuality)QualityLevel;
}
// Show the build progress dialog.
SBuildProgressWidget::EBuildType BuildType = SBuildProgressWidget::BUILDTYPE_Geometry;
switch (Id)
{
case EBuildOptions::BuildGeometry:
case EBuildOptions::BuildVisibleGeometry:
case EBuildOptions::BuildAll:
case EBuildOptions::BuildAllOnlySelectedPaths:
BuildType = SBuildProgressWidget::BUILDTYPE_Geometry;
break;
case EBuildOptions::BuildLighting:
BuildType = SBuildProgressWidget::BUILDTYPE_Lighting;
break;
case EBuildOptions::BuildAIPaths:
case EBuildOptions::BuildSelectedAIPaths:
BuildType = SBuildProgressWidget::BUILDTYPE_Paths;
break;
case EBuildOptions::BuildHierarchicalLOD:
case EBuildOptions::PreviewHierarchicalLOD:
BuildType = SBuildProgressWidget::BUILDTYPE_LODs;
break;
default:
BuildType = SBuildProgressWidget::BUILDTYPE_Unknown;
break;
}
TWeakPtr<class SBuildProgressWidget> BuildProgressWidget = GWarn->ShowBuildProgressWindow();
BuildProgressWidget.Pin()->SetBuildType(BuildType);
bool bShouldMapCheck = true;
switch( Id )
{
case EBuildOptions::BuildGeometry:
{
// We can't set the busy cursor for all windows, because lighting
// needs a cursor for the lighting options dialog.
const FScopedBusyCursor BusyCursor;
GUnrealEd->Exec( InWorld, TEXT("MAP REBUILD") );
if (GetDefault<ULevelEditorMiscSettings>()->bNavigationAutoUpdate)
{
TriggerNavigationBuilder(InWorld, Id);
}
// No need to dirty the persient level if we're building BSP for a sub-level.
bDirtyPersistentLevel = false;
break;
}
case EBuildOptions::BuildVisibleGeometry:
{
// If any levels are hidden, prompt the user about how to proceed
bDoBuild = GEditor->WarnAboutHiddenLevels( InWorld, true );
if ( bDoBuild )
{
// We can't set the busy cursor for all windows, because lighting
// needs a cursor for the lighting options dialog.
const FScopedBusyCursor BusyCursor;
GUnrealEd->Exec( InWorld, TEXT("MAP REBUILD ALLVISIBLE") );
if (GetDefault<ULevelEditorMiscSettings>()->bNavigationAutoUpdate)
{
TriggerNavigationBuilder(InWorld, Id);
}
}
break;
}
case EBuildOptions::BuildLighting:
{
if( bDoBuild )
{
// We can't set the busy cursor for all windows, because lighting
// needs a cursor for the lighting options dialog.
const FScopedBusyCursor BusyCursor;
// BSP export to lightmass relies on current BSP state
GUnrealEd->Exec( InWorld, TEXT("MAP REBUILD ALLVISIBLE") );
GUnrealEd->BuildLighting( LightingBuildOptions );
bShouldMapCheck = false;
}
break;
}
case EBuildOptions::BuildAIPaths:
{
bDoBuild = GEditor->WarnAboutHiddenLevels( InWorld, false );
if ( bDoBuild )
{
GEditor->ResetTransaction( NSLOCTEXT("UnrealEd", "RebuildNavigation", "Rebuilding Navigation") );
// We can't set the busy cursor for all windows, because lighting
// needs a cursor for the lighting options dialog.
const FScopedBusyCursor BusyCursor;
TriggerNavigationBuilder(InWorld, Id);
}
break;
}
case EBuildOptions::BuildHierarchicalLOD:
{
bDoBuild = GEditor->WarnAboutHiddenLevels( InWorld, false );
if ( bDoBuild )
{
GEditor->ResetTransaction( NSLOCTEXT("UnrealEd", "RebuildLOD", "Rebuilding HierarchicalLOD") );
// We can't set the busy cursor for all windows, because lighting
// needs a cursor for the lighting options dialog.
const FScopedBusyCursor BusyCursor;
TriggerHierarchicalLODBuilder(InWorld, Id);
}
break;
}
case EBuildOptions::PreviewHierarchicalLOD:
{
bDoBuild = GEditor->WarnAboutHiddenLevels(InWorld, false);
if (bDoBuild)
{
GEditor->ResetTransaction(NSLOCTEXT("UnrealEd", "RebuildLOD", "Rebuilding HierarchicalLOD"));
// We can't set the busy cursor for all windows, because lighting
// needs a cursor for the lighting options dialog.
const FScopedBusyCursor BusyCursor;
TriggerHierarchicalLODBuilder(InWorld, Id);
}
break;
}
case EBuildOptions::BuildAll:
case EBuildOptions::BuildAllSubmit:
{
bDoBuild = GEditor->WarnAboutHiddenLevels( InWorld, true );
bool bLightingAlreadyRunning = GUnrealEd->WarnIfLightingBuildIsCurrentlyRunning();
if ( bDoBuild && !bLightingAlreadyRunning )
{
// We can't set the busy cursor for all windows, because lighting
// needs a cursor for the lighting options dialog.
const FScopedBusyCursor BusyCursor;
GUnrealEd->Exec( InWorld, TEXT("MAP REBUILD ALLVISIBLE") );
{
BuildProgressWidget.Pin()->SetBuildType(SBuildProgressWidget::BUILDTYPE_LODs);
TriggerHierarchicalLODBuilder(InWorld, Id);
}
{
BuildProgressWidget.Pin()->SetBuildType(SBuildProgressWidget::BUILDTYPE_Paths);
TriggerNavigationBuilder(InWorld, Id);
}
//Do a canceled check before moving on to the next step of the build.
if( GEditor->GetMapBuildCancelled() )
{
break;
}
else
{
BuildProgressWidget.Pin()->SetBuildType(SBuildProgressWidget::BUILDTYPE_Lighting);
FLightingBuildOptions LightingOptions;
int32 QualityLevel;
// Force automated builds to always use production lighting
if ( Id == EBuildOptions::BuildAllSubmit )
{
QualityLevel = Quality_Production;
}
else
{
GConfig->GetInt( TEXT("LightingBuildOptions"), TEXT("QualityLevel"), QualityLevel, GEditorPerProjectIni);
QualityLevel = FMath::Clamp<int32>(QualityLevel, Quality_Preview, Quality_Production);
}
LightingOptions.QualityLevel = (ELightingBuildQuality)QualityLevel;
GUnrealEd->BuildLighting(LightingOptions);
bShouldMapCheck = false;
}
}
break;
}
default:
UE_LOG(LogEditorBuildUtils, Warning, TEXT("Invalid build Id"));
break;
}
// Check map for errors (only if build operation happened)
if ( bShouldMapCheck && bDoBuild && !GEditor->GetMapBuildCancelled() )
{
GUnrealEd->Exec( InWorld, TEXT("MAP CHECK DONTDISPLAYDIALOG") );
}
// Re-start the rendering thread after build operations completed.
if (GUseThreadedRendering)
{
StartRenderingThread();
}
if ( bDoBuild )
{
// Display elapsed build time.
UE_LOG(LogEditorBuildUtils, Log, TEXT("Build time %s"), *BuildProgressWidget.Pin()->BuildElapsedTimeText().ToString() );
}
// Build completed, hide the build progress dialog.
// NOTE: It's important to turn off modalness before hiding the window, otherwise a background
// application may unexpectedly be promoted to the foreground, obscuring the editor.
GWarn->CloseBuildProgressWindow();
GUnrealEd->RedrawLevelEditingViewports();
if ( bDoBuild )
{
if ( bDirtyPersistentLevel )
{
InWorld->MarkPackageDirty();
}
ULevel::LevelDirtiedEvent.Broadcast();
}
// Don't show map check if we cancelled build because it may have some bogus data
const bool bBuildCompleted = bDoBuild && !GEditor->GetMapBuildCancelled();
if( bBuildCompleted )
{
if (bShouldMapCheck)
{
FMessageLog("MapCheck").Open( EMessageSeverity::Warning );
}
FMessageLog("LightingResults").Notify(LOCTEXT("LightingErrorsNotification", "There were lighting errors."), EMessageSeverity::Error);
}
return bBuildCompleted;
}
TShaderMap<FGlobalShaderType>* GetGlobalShaderMap(EShaderPlatform Platform, bool bRefreshShaderMap)
{
DECLARE_SCOPE_CYCLE_COUNTER(TEXT("GetGlobalShaderMap"), STAT_GetGlobalShaderMap, STATGROUP_LoadTime);
// No global shaders needed on dedicated server
if (FPlatformProperties::IsServerOnly())
{
if (!GGlobalShaderMap[Platform])
{
GGlobalShaderMap[Platform] = new TShaderMap<FGlobalShaderType>();
return GGlobalShaderMap[Platform];
}
return NULL;
}
if (bRefreshShaderMap)
{
// delete the current global shader map
delete GGlobalShaderMap[Platform];
GGlobalShaderMap[Platform] = NULL;
// make sure we look for updated shader source files
FlushShaderFileCache();
}
// If the global shader map hasn't been created yet, create it.
if(!GGlobalShaderMap[Platform])
{
// GetGlobalShaderMap is called the first time during startup in the main thread.
check(IsInGameThread());
FScopedSlowTask SlowTask(70);
// verify that all shader source files are intact
SlowTask.EnterProgressFrame(20);
VerifyShaderSourceFiles();
GGlobalShaderMap[Platform] = new TShaderMap<FGlobalShaderType>();
bool bLoadedFromCacheFile = false;
// Try to load the global shaders from a local cache file if it exists
// This method is used exclusively with cooked content, since the DDC is not present
if (FPlatformProperties::RequiresCookedData())
{
SlowTask.EnterProgressFrame(50);
TArray<uint8> GlobalShaderData;
FString GlobalShaderCacheFilename = FPaths::GetRelativePathToRoot() / GetGlobalShaderCacheFilename(Platform);
FPaths::MakeStandardFilename(GlobalShaderCacheFilename);
bLoadedFromCacheFile = FFileHelper::LoadFileToArray(GlobalShaderData, *GlobalShaderCacheFilename, FILEREAD_Silent);
if (!bLoadedFromCacheFile)
{
// Handle this gracefully and exit.
FString SandboxPath = IFileManager::Get().ConvertToAbsolutePathForExternalAppForWrite(*GlobalShaderCacheFilename);
// This can be too early to localize in some situations.
const FText Message = FText::Format( NSLOCTEXT("Engine", "GlobalShaderCacheFileMissing", "The global shader cache file '{0}' is missing.\n\nYou're running a version of the application built to load COOKED content only, however no COOKED content was found. Consider cooking content for this build, or build and run the UNCOOKED version of the application instead."), FText::FromString( SandboxPath ) );
if (FPlatformProperties::SupportsWindowedMode())
{
UE_LOG(LogMaterial, Error, TEXT("%s"), *Message.ToString());
FMessageDialog::Open(EAppMsgType::Ok, Message);
FPlatformMisc::RequestExit(false);
return NULL;
}
else
{
UE_LOG(LogMaterial, Fatal, TEXT("%s"), *Message.ToString());
}
}
FMemoryReader MemoryReader(GlobalShaderData);
SerializeGlobalShaders(MemoryReader, GGlobalShaderMap[Platform]);
}
// Uncooked platform
else
{
FGlobalShaderMapId ShaderMapId(Platform);
TArray<uint8> CachedData;
SlowTask.EnterProgressFrame(40);
const FString DataKey = GetGlobalShaderMapKeyString(ShaderMapId, Platform);
// Find the shader map in the derived data cache
SlowTask.EnterProgressFrame(10);
if (GetDerivedDataCacheRef().GetSynchronous(*DataKey, CachedData))
{
FMemoryReader Ar(CachedData, true);
// Deserialize from the cached data
SerializeGlobalShaders(Ar, GGlobalShaderMap[Platform]);
}
}
// If any shaders weren't loaded, compile them now.
VerifyGlobalShaders(Platform, bLoadedFromCacheFile);
extern int32 GCreateShadersOnLoad;
if (GCreateShadersOnLoad && Platform == GMaxRHIShaderPlatform)
{
for (TMap<FShaderType*, TRefCountPtr<FShader> >::TConstIterator ShaderIt(GGlobalShaderMap[Platform]->GetShaders()); ShaderIt; ++ShaderIt)
{
FShader* Shader = ShaderIt.Value();
if (Shader)
{
Shader->BeginInitializeResources();
}
}
}
}
return GGlobalShaderMap[Platform];
}
void RecompileShadersForRemote(
const FString& PlatformName,
EShaderPlatform ShaderPlatformToCompile,
const FString& OutputDirectory,
const TArray<FString>& MaterialsToLoad,
const TArray<uint8>& SerializedShaderResources,
TArray<uint8>* MeshMaterialMaps,
TArray<FString>* ModifiedFiles,
bool bCompileChangedShaders )
{
// figure out what shader platforms to recompile
ITargetPlatformManagerModule* TPM = GetTargetPlatformManager();
ITargetPlatform* TargetPlatform = TPM->FindTargetPlatform(PlatformName);
if (TargetPlatform == NULL)
{
UE_LOG(LogShaders, Display, TEXT("Failed to find target platform module for %s"), *PlatformName);
return;
}
TArray<FName> DesiredShaderFormats;
TargetPlatform->GetAllTargetedShaderFormats(DesiredShaderFormats);
UE_LOG(LogShaders, Display, TEXT("Loading %d materials..."), MaterialsToLoad.Num());
// make sure all materials the client has loaded will be processed
TArray<UMaterialInterface*> MaterialsToCompile;
for (int32 Index = 0; Index < MaterialsToLoad.Num(); Index++)
{
UE_LOG(LogShaders, Display, TEXT(" --> %s"), *MaterialsToLoad[Index]);
MaterialsToCompile.Add(LoadObject<UMaterialInterface>(NULL, *MaterialsToLoad[Index]));
}
UE_LOG(LogShaders, Display, TEXT(" Done!"))
// figure out which shaders are out of date
TArray<FShaderType*> OutdatedShaderTypes;
TArray<const FVertexFactoryType*> OutdatedFactoryTypes;
// Pick up new changes to shader files
FlushShaderFileCache();
if( bCompileChangedShaders )
{
FShaderType::GetOutdatedTypes( OutdatedShaderTypes, OutdatedFactoryTypes );
UE_LOG( LogShaders, Display, TEXT( "We found %d out of date shader types, and %d out of date VF types!" ), OutdatedShaderTypes.Num(), OutdatedFactoryTypes.Num() );
}
{
for (int32 FormatIndex = 0; FormatIndex < DesiredShaderFormats.Num(); FormatIndex++)
{
// get the shader platform enum
const EShaderPlatform ShaderPlatform = ShaderFormatToLegacyShaderPlatform(DesiredShaderFormats[FormatIndex]);
// Only compile for the desired platform if requested
if (ShaderPlatform == ShaderPlatformToCompile || ShaderPlatformToCompile == SP_NumPlatforms)
{
if( bCompileChangedShaders )
{
// Kick off global shader recompiles
BeginRecompileGlobalShaders( OutdatedShaderTypes, ShaderPlatform );
// Block on global shaders
FinishRecompileGlobalShaders();
}
// we only want to actually compile mesh shaders if a client directly requested it, and there's actually some work to do
if (MeshMaterialMaps != NULL && (OutdatedShaderTypes.Num() || OutdatedFactoryTypes.Num() || bCompileChangedShaders == false))
{
TMap<FString, TArray<TRefCountPtr<FMaterialShaderMap> > > CompiledShaderMaps;
UMaterial::CompileMaterialsForRemoteRecompile(MaterialsToCompile, ShaderPlatform, CompiledShaderMaps);
// write the shader compilation info to memory, converting fnames to strings
FMemoryWriter MemWriter(*MeshMaterialMaps, true);
FNameAsStringProxyArchive Ar(MemWriter);
// pull the serialized resource ids into an array of resources
TArray<FShaderResourceId> ClientResourceIds;
FMemoryReader MemReader(SerializedShaderResources, true);
MemReader << ClientResourceIds;
// save out the shader map to the byte array
FMaterialShaderMap::SaveForRemoteRecompile(Ar, CompiledShaderMaps, ClientResourceIds);
}
// save it out so the client can get it (and it's up to date next time)
FString GlobalShaderFilename = SaveGlobalShaderFile(ShaderPlatform, OutputDirectory);
// add this to the list of files to tell the other end about
if (ModifiedFiles)
{
// need to put it in non-sandbox terms
FString SandboxPath(GlobalShaderFilename);
check(SandboxPath.StartsWith(OutputDirectory));
SandboxPath.ReplaceInline(*OutputDirectory, TEXT("../../../"));
FPaths::NormalizeFilename(SandboxPath);
ModifiedFiles->Add(SandboxPath);
}
}
}
}
}
void FPerforceConnection::EstablishConnection(const FPerforceConnectionInfo& InConnectionInfo)
{
#if USE_P4_API
// Verify Input. ServerName and UserName are required
if ( InConnectionInfo.Port.IsEmpty() || InConnectionInfo.UserName.IsEmpty() )
{
return;
}
//Connection assumed successful
bEstablishedConnection = true;
UE_LOG(LogSourceControl, Verbose, TEXT("Attempting P4 connection: %s/%s"), *InConnectionInfo.Port, *InConnectionInfo.UserName);
P4Client.SetProtocol("tag", "");
P4Client.SetProtocol("enableStreams", "");
//Set configuration based params
P4Client.SetPort(TCHAR_TO_ANSI(*InConnectionInfo.Port));
Error P4Error;
if(InConnectionInfo.Password.Len() > 0)
{
UE_LOG(LogSourceControl, Verbose, TEXT(" ... applying password" ));
P4Client.DefinePassword(TCHAR_TO_ANSI(*InConnectionInfo.Password), &P4Error);
if(P4Error.Test())
{
StrBuf ErrorMessage;
P4Error.Fmt(&ErrorMessage);
UE_LOG(LogSourceControl, Error, TEXT("P4ERROR: Could not set password."));
UE_LOG(LogSourceControl, Error, TEXT("%s"), ANSI_TO_TCHAR(ErrorMessage.Text()));
}
}
if(InConnectionInfo.HostOverride.Len() > 0)
{
UE_LOG(LogSourceControl, Verbose, TEXT(" ... overriding host" ));
P4Client.SetHost(TCHAR_TO_ANSI(*InConnectionInfo.HostOverride));
}
UE_LOG(LogSourceControl, Verbose, TEXT(" ... connecting" ));
//execute the connection to perforce using the above settings
P4Client.Init(&P4Error);
//ensure the connection is valid
UE_LOG(LogSourceControl, Verbose, TEXT(" ... validating connection" ));
if (P4Error.Test())
{
bEstablishedConnection = false;
StrBuf ErrorMessage;
P4Error.Fmt(&ErrorMessage);
UE_LOG(LogSourceControl, Error, TEXT("P4ERROR: Invalid connection to server."));
UE_LOG(LogSourceControl, Error, TEXT("%s"), ANSI_TO_TCHAR(ErrorMessage.Text()));
}
else
{
TArray<FString> Params;
TArray<FText> ErrorMessages;
FP4RecordSet Records;
bool bConnectionDropped = false;
const bool bStandardDebugOutput = false;
const bool bAllowRetry = true;
UE_LOG(LogSourceControl, Verbose, TEXT(" ... checking unicode status" ));
if (RunCommand(TEXT("info"), Params, Records, ErrorMessages, FOnIsCancelled(), bConnectionDropped, bStandardDebugOutput, bAllowRetry))
{
// Get character encoding
bIsUnicode = Records[0].Find(TEXT("unicode")) != NULL;
if(bIsUnicode)
{
P4Client.SetTrans(CharSetApi::UTF_8);
UE_LOG(LogSourceControl, Verbose, TEXT(" server is unicode" ));
}
// Now we know our unicode status we can gather the client root
P4Client.SetUser(FROM_TCHAR(*InConnectionInfo.UserName, bIsUnicode));
if(InConnectionInfo.Password.Len() > 0)
{
Login(InConnectionInfo);
}
if (InConnectionInfo.Ticket.Len())
{
P4Client.SetPassword(FROM_TCHAR(*InConnectionInfo.Ticket, bIsUnicode));
}
if (InConnectionInfo.Workspace.Len())
{
P4Client.SetClient(FROM_TCHAR(*InConnectionInfo.Workspace, bIsUnicode));
}
P4Client.SetCwd(FROM_TCHAR(*FPaths::RootDir(), bIsUnicode));
// Gather the client root
UE_LOG(LogSourceControl, Verbose, TEXT(" ... getting info" ));
bConnectionDropped = false;
if (RunCommand(TEXT("info"), Params, Records, ErrorMessages, FOnIsCancelled(), bConnectionDropped, bStandardDebugOutput, bAllowRetry))
{
UE_LOG(LogSourceControl, Verbose, TEXT(" ... getting clientroot" ));
ClientRoot = Records[0](TEXT("clientRoot"));
//make sure all slashes point the same way
ClientRoot = ClientRoot.Replace(TEXT("\\"), TEXT("/"));
}
}
}
#endif
}
/**
* Makes sure all global shaders are loaded and/or compiled for the passed in platform.
* Note: if compilation is needed, this only kicks off the compile.
*
* @param Platform Platform to verify global shaders for
*/
void VerifyGlobalShaders(EShaderPlatform Platform, bool bLoadedFromCacheFile)
{
check(IsInGameThread());
check(!FPlatformProperties::IsServerOnly());
check(GGlobalShaderMap[Platform]);
UE_LOG(LogShaders, Log, TEXT("Verifying Global Shaders for %s"), *LegacyShaderPlatformToShaderFormat(Platform).ToString());
// Ensure that the global shader map contains all global shader types.
TShaderMap<FGlobalShaderType>* GlobalShaderMap = GetGlobalShaderMap(Platform);
const bool bEmptyMap = GlobalShaderMap->IsEmpty();
if (bEmptyMap)
{
UE_LOG(LogShaders, Warning, TEXT(" Empty global shader map, recompiling all global shaders"));
}
TArray<FShaderCompileJob*> GlobalShaderJobs;
for(TLinkedList<FShaderType*>::TIterator ShaderTypeIt(FShaderType::GetTypeList());ShaderTypeIt;ShaderTypeIt.Next())
{
FGlobalShaderType* GlobalShaderType = ShaderTypeIt->GetGlobalShaderType();
if(GlobalShaderType && GlobalShaderType->ShouldCache(Platform))
{
if(!GlobalShaderMap->HasShader(GlobalShaderType))
{
bool bErrorOnMissing = bLoadedFromCacheFile;
if (FPlatformProperties::RequiresCookedData())
{
// We require all shaders to exist on cooked platforms because we can't compile them.
bErrorOnMissing = true;
}
if (bErrorOnMissing)
{
UE_LOG(LogShaders, Fatal,TEXT("Missing global shader %s, Please make sure cooking was successful."), GlobalShaderType->GetName());
}
if (!bEmptyMap)
{
UE_LOG(LogShaders, Warning, TEXT(" %s"), GlobalShaderType->GetName());
}
// Compile this global shader type.
GlobalShaderType->BeginCompileShader(Platform, GlobalShaderJobs);
}
}
}
if (GlobalShaderJobs.Num() > 0)
{
GShaderCompilingManager->AddJobs(GlobalShaderJobs, true, true);
const bool bAllowAsynchronousGlobalShaderCompiling =
// OpenGL requires that global shader maps are compiled before attaching
// primitives to the scene as it must be able to find FNULLPS.
// TODO_OPENGL: Allow shaders to be compiled asynchronously.
!IsOpenGLPlatform(GMaxRHIShaderPlatform) &&
GShaderCompilingManager->AllowAsynchronousShaderCompiling();
if (!bAllowAsynchronousGlobalShaderCompiling)
{
TArray<int32> ShaderMapIds;
ShaderMapIds.Add(GlobalShaderMapId);
GShaderCompilingManager->FinishCompilation(TEXT("Global"), ShaderMapIds);
}
}
}
bool FPerforceConnection::GetWorkspaceList(const FPerforceConnectionInfo& InConnectionInfo, FOnIsCancelled InOnIsCanceled, TArray<FString>& OutWorkspaceList, TArray<FText>& OutErrorMessages)
{
if(bEstablishedConnection)
{
TArray<FString> Params;
bool bAllowWildHosts = !GIsBuildMachine;
Params.Add(TEXT("-u"));
Params.Add(InConnectionInfo.UserName);
FP4RecordSet Records;
bool bConnectionDropped = false;
bool bCommandOK = RunCommand(TEXT("clients"), Params, Records, OutErrorMessages, InOnIsCanceled, bConnectionDropped);
if (bCommandOK)
{
FString ApplicationPath = IFileManager::Get().ConvertToAbsolutePathForExternalAppForRead(*FPaths::GameDir()).ToLower();
FString LocalHostName = InConnectionInfo.HostOverride;
if(LocalHostName.Len() == 0)
{
// No host override, check environment variable
TCHAR P4HostEnv[256];
FPlatformMisc::GetEnvironmentVariable(TEXT("P4HOST"), P4HostEnv, ARRAY_COUNT(P4HostEnv));
LocalHostName = P4HostEnv;
}
if (LocalHostName.Len() == 0)
{
// no host name, use local machine name
LocalHostName = FString(FPlatformProcess::ComputerName()).ToLower();
}
else
{
LocalHostName = LocalHostName.ToLower();
}
for (int32 Index = 0; Index < Records.Num(); ++Index)
{
const FP4Record& ClientRecord = Records[Index];
FString ClientName = ClientRecord("client");
FString HostName = ClientRecord("Host");
FString ClientRootPath = ClientRecord("Root").ToLower();
//this clientspec has to be meant for this machine ( "" hostnames mean any host can use ths clientspec in p4 land)
bool bHostNameMatches = (LocalHostName == HostName.ToLower());
bool bHostNameWild = (HostName.Len() == 0);
if( bHostNameMatches || (bHostNameWild && bAllowWildHosts) )
{
// A workspace root could be "null" which allows the user to map depot locations to different drives.
// Allow these workspaces since we already allow workspaces mapped to drive letters.
const bool bIsNullClientRootPath = (ClientRootPath == TEXT("null"));
//make sure all slashes point the same way
ClientRootPath = ClientRootPath.Replace(TEXT("\\"), TEXT("/"));
ApplicationPath = ApplicationPath.Replace(TEXT("\\"), TEXT("/"));
if (!ClientRootPath.EndsWith(TEXT("/")))
{
ClientRootPath += TEXT("/");
}
// Only allow paths that are ACTUALLY legit for this application
if (bIsNullClientRootPath || ApplicationPath.Contains(ClientRootPath) )
{
OutWorkspaceList.Add(ClientName);
}
else
{
UE_LOG(LogSourceControl, Error, TEXT(" %s client specs rejected due to root directory mismatch (%s)"), *ClientName, *ClientRootPath);
}
//Other useful fields: Description, Owner, Host
}
else
{
UE_LOG(LogSourceControl, Error, TEXT(" %s client specs rejected due to host name mismatch (%s)"), *ClientName, *HostName);
}
}
}
return bCommandOK;
}
return false;
}
bool FPerforceConnection::RunCommand(const FString& InCommand, const TArray<FString>& InParameters, FP4RecordSet& OutRecordSet, TArray<FText>& OutErrorMessage, FOnIsCancelled InIsCancelled, bool& OutConnectionDropped, const bool bInStandardDebugOutput, const bool bInAllowRetry)
{
#if USE_P4_API
if (!bEstablishedConnection)
{
return false;
}
FString FullCommand = InCommand;
// Prepare arguments
int32 ArgC = InParameters.Num();
UTF8CHAR** ArgV = new UTF8CHAR*[ArgC];
for (int32 Index = 0; Index < ArgC; Index++)
{
if(bIsUnicode)
{
FTCHARToUTF8 UTF8String(*InParameters[Index]);
ArgV[Index] = new UTF8CHAR[UTF8String.Length() + 1];
FMemory::Memcpy(ArgV[Index], UTF8String.Get(), UTF8String.Length() + 1);
}
else
{
ArgV[Index] = new UTF8CHAR[InParameters[Index].Len() + 1];
FMemory::Memcpy(ArgV[Index], TCHAR_TO_ANSI(*InParameters[Index]), InParameters[Index].Len() + 1);
}
if (bInStandardDebugOutput)
{
FullCommand += TEXT(" ");
FullCommand += InParameters[Index];
}
}
if (bInStandardDebugOutput)
{
UE_LOG( LogSourceControl, Log, TEXT("Attempting 'p4 %s'"), *FullCommand );
}
double SCCStartTime = FPlatformTime::Seconds();
P4Client.SetArgv(ArgC, (char**)ArgV);
FP4KeepAlive KeepAlive(InIsCancelled);
P4Client.SetBreak(&KeepAlive);
OutRecordSet.Reset();
FP4ClientUser User(OutRecordSet, bIsUnicode, OutErrorMessage);
P4Client.Run(FROM_TCHAR(*InCommand, bIsUnicode), &User);
if ( P4Client.Dropped() )
{
OutConnectionDropped = true;
}
P4Client.SetBreak(NULL);
// Free arguments
for (int32 Index = 0; Index < ArgC; Index++)
{
delete [] ArgV[Index];
}
delete [] ArgV;
if (bInStandardDebugOutput)
{
UE_LOG( LogSourceControl, VeryVerbose, TEXT("P4 execution time: %0.4f seconds. Command: %s"), FPlatformTime::Seconds() - SCCStartTime, *FullCommand );
}
#endif
return OutRecordSet.Num() > 0;
}
void AOnlineBeaconHost::NotifyControlMessage(UNetConnection* Connection, uint8 MessageType, class FInBunch& Bunch)
{
if(NetDriver->ServerConnection == nullptr)
{
bool bCloseConnection = false;
// We are the server.
#if !(UE_BUILD_SHIPPING && WITH_EDITOR)
UE_LOG(LogBeacon, Verbose, TEXT("%s[%s] Host received: %s"), *GetName(), Connection ? *Connection->GetName() : TEXT("Invalid"), FNetControlMessageInfo::GetName(MessageType));
#endif
switch (MessageType)
{
case NMT_Hello:
{
UE_LOG(LogBeacon, Log, TEXT("Beacon Hello"));
uint8 IsLittleEndian;
uint32 RemoteNetworkVersion = 0;
uint32 LocalNetworkVersion = FNetworkVersion::GetLocalNetworkVersion();
FNetControlMessage<NMT_Hello>::Receive(Bunch, IsLittleEndian, RemoteNetworkVersion);
if (!FNetworkVersion::IsNetworkCompatible(LocalNetworkVersion, RemoteNetworkVersion))
{
UE_LOG(LogBeacon, Log, TEXT("Client not network compatible %s"), *Connection->GetName());
FNetControlMessage<NMT_Upgrade>::Send(Connection, LocalNetworkVersion);
bCloseConnection = true;
}
else
{
Connection->Challenge = FString::Printf(TEXT("%08X"), FPlatformTime::Cycles());
FNetControlMessage<NMT_BeaconWelcome>::Send(Connection);
Connection->FlushNet();
}
break;
}
case NMT_Netspeed:
{
int32 Rate;
FNetControlMessage<NMT_Netspeed>::Receive(Bunch, Rate);
Connection->CurrentNetSpeed = FMath::Clamp(Rate, 1800, NetDriver->MaxClientRate);
UE_LOG(LogBeacon, Log, TEXT("Client netspeed is %i"), Connection->CurrentNetSpeed);
break;
}
case NMT_BeaconJoin:
{
FString ErrorMsg;
FString BeaconType;
FUniqueNetIdRepl UniqueId;
FNetControlMessage<NMT_BeaconJoin>::Receive(Bunch, BeaconType, UniqueId);
UE_LOG(LogBeacon, Log, TEXT("Beacon Join %s %s"), *BeaconType, *UniqueId.ToDebugString());
if (Connection->ClientWorldPackageName == NAME_None)
{
AOnlineBeaconClient* ClientActor = GetClientActor(Connection);
if (ClientActor == nullptr)
{
UWorld* World = GetWorld();
Connection->ClientWorldPackageName = World->GetOutermost()->GetFName();
AOnlineBeaconClient* NewClientActor = nullptr;
FOnBeaconSpawned* OnBeaconSpawnedDelegate = OnBeaconSpawnedMapping.Find(BeaconType);
if (OnBeaconSpawnedDelegate && OnBeaconSpawnedDelegate->IsBound())
{
NewClientActor = OnBeaconSpawnedDelegate->Execute(Connection);
}
if (NewClientActor && BeaconType == NewClientActor->GetBeaconType())
{
NewClientActor->SetConnectionState(EBeaconConnectionState::Pending);
FNetworkGUID NetGUID = Connection->Driver->GuidCache->AssignNewNetGUID_Server(NewClientActor);
NewClientActor->SetNetConnection(Connection);
Connection->PlayerId = UniqueId;
Connection->OwningActor = NewClientActor;
NewClientActor->Role = ROLE_Authority;
NewClientActor->SetReplicates(false);
check(NetDriverName == NetDriver->NetDriverName);
NewClientActor->SetNetDriverName(NetDriverName);
ClientActors.Add(NewClientActor);
FNetControlMessage<NMT_BeaconAssignGUID>::Send(Connection, NetGUID);
}
else
{
ErrorMsg = NSLOCTEXT("NetworkErrors", "BeaconSpawnFailureError", "Join failure, Couldn't spawn beacon.").ToString();
}
}
else
{
ErrorMsg = NSLOCTEXT("NetworkErrors", "BeaconSpawnExistingActorError", "Join failure, existing beacon actor.").ToString();
}
}
else
{
ErrorMsg = NSLOCTEXT("NetworkErrors", "BeaconSpawnClientWorldPackageNameError", "Join failure, existing ClientWorldPackageName.").ToString();
}
if (!ErrorMsg.IsEmpty())
{
UE_LOG(LogBeacon, Log, TEXT("%s: %s"), *Connection->GetName(), *ErrorMsg);
FNetControlMessage<NMT_Failure>::Send(Connection, ErrorMsg);
bCloseConnection = true;
}
break;
}
case NMT_BeaconNetGUIDAck:
{
FString ErrorMsg;
FString BeaconType;
FNetControlMessage<NMT_BeaconNetGUIDAck>::Receive(Bunch, BeaconType);
AOnlineBeaconClient* ClientActor = GetClientActor(Connection);
if (ClientActor && BeaconType == ClientActor->GetBeaconType())
{
FOnBeaconConnected* OnBeaconConnectedDelegate = OnBeaconConnectedMapping.Find(BeaconType);
if (OnBeaconConnectedDelegate)
{
ClientActor->SetReplicates(true);
ClientActor->SetAutonomousProxy(true);
ClientActor->SetConnectionState(EBeaconConnectionState::Open);
// Send an RPC to the client to open the actor channel and guarantee RPCs will work
ClientActor->ClientOnConnected();
UE_LOG(LogBeacon, Log, TEXT("Handshake complete for %s!"), *ClientActor->GetName());
OnBeaconConnectedDelegate->ExecuteIfBound(ClientActor, Connection);
}
else
{
// Failed to connect.
ErrorMsg = NSLOCTEXT("NetworkErrors", "BeaconSpawnNetGUIDAckError1", "Join failure, no host object at NetGUIDAck.").ToString();
}
}
else
{
// Failed to connect.
ErrorMsg = NSLOCTEXT("NetworkErrors", "BeaconSpawnNetGUIDAckError2", "Join failure, no actor at NetGUIDAck.").ToString();
}
if (!ErrorMsg.IsEmpty())
{
UE_LOG(LogBeacon, Log, TEXT("%s: %s"), *Connection->GetName(), *ErrorMsg);
FNetControlMessage<NMT_Failure>::Send(Connection, ErrorMsg);
bCloseConnection = true;
}
break;
}
case NMT_BeaconWelcome:
case NMT_BeaconAssignGUID:
default:
{
FString ErrorMsg = NSLOCTEXT("NetworkErrors", "BeaconSpawnUnexpectedError", "Join failure, unexpected control message.").ToString();
UE_LOG(LogBeacon, Log, TEXT("%s: %s"), *Connection->GetName(), *ErrorMsg);
FNetControlMessage<NMT_Failure>::Send(Connection, ErrorMsg);
bCloseConnection = true;
}
break;
}
if (bCloseConnection)
{
UE_LOG(LogBeacon, Verbose, TEXT("Closing connection %s: %s"), *Connection->GetName(), *Connection->PlayerId.ToDebugString());
AOnlineBeaconClient* ClientActor = GetClientActor(Connection);
if (ClientActor)
{
UE_LOG(LogBeacon, Verbose, TEXT("- BeaconActor: %s %s"), *ClientActor->GetName(), *ClientActor->GetBeaconType());
AOnlineBeaconHostObject* BeaconHostObject = GetHost(ClientActor->GetBeaconType());
if (BeaconHostObject)
{
UE_LOG(LogBeacon, Verbose, TEXT("- HostObject: %s"), *BeaconHostObject->GetName());
BeaconHostObject->NotifyClientDisconnected(ClientActor);
}
RemoveClientActor(ClientActor);
}
Connection->FlushNet(true);
Connection->Close();
UE_LOG(LogBeacon, Verbose, TEXT("--------------------------------"));
}
}
}
void ATankPlayerController::BeginPlay()
{
Super::BeginPlay();
UE_LOG(LogTemp, Warning, TEXT("PlayerController BeginPlay()"));
}
void AOnlineBeaconHost::OnNetCleanup(UNetConnection* Connection)
{
UE_LOG(LogBeacon, Error, TEXT("Cleaning up a beacon host!"));
ensure(0);
}
UMyCharDataComp::~UMyCharDataComp()
{
UE_LOG(CompLogger, Warning, TEXT("--- UMyCharDataComp::~UMyCharDataComp"));
}
void FConsoleEventLogger::Log( EEventLog::Type Event, const FString& AdditionalContent, TSharedPtr<SWidget> Widget )
{
UE_LOG(LogSlate, Log, TEXT("%s"), *PrettyPrint(Event, AdditionalContent, Widget));
}
/**
* Private helper method to log an error both to GWarn and to the build's list of accumulated errors
*
* @param InErrorMessage Message to log to GWarn/add to list of errors
* @param OutAccumulatedErrors List of errors accumulated during a build process so far
*/
void FEditorBuildUtils::LogErrorMessage( const FText& InErrorMessage, FText& OutAccumulatedErrors )
{
OutAccumulatedErrors = FText::Format( LOCTEXT("AccumulateErrors", "{0}\n{1}"), OutAccumulatedErrors, InErrorMessage );
UE_LOG(LogEditorBuildUtils, Warning, TEXT("%s"), *InErrorMessage.ToString() );
}
void AOnlineBeaconClient::NotifyControlMessage(UNetConnection* Connection, uint8 MessageType, class FInBunch& Bunch)
{
if(NetDriver->ServerConnection)
{
check(Connection == NetDriver->ServerConnection);
// We are the client
#if !(UE_BUILD_SHIPPING && WITH_EDITOR)
UE_LOG(LogNet, Log, TEXT("Beacon: Client received: %s"), FNetControlMessageInfo::GetName(MessageType));
#endif
switch (MessageType)
{
case NMT_BeaconWelcome:
{
Connection->ClientResponse = TEXT("0");
FNetControlMessage<NMT_Netspeed>::Send(Connection, Connection->CurrentNetSpeed);
FString BeaconType = GetBeaconType();
if (!BeaconType.IsEmpty())
{
FNetControlMessage<NMT_BeaconJoin>::Send(Connection, BeaconType);
NetDriver->ServerConnection->FlushNet();
}
else
{
// Force close the session
UE_LOG(LogNet, Log, TEXT("Beacon close from invalid beacon type"));
OnFailure();
}
break;
}
case NMT_BeaconAssignGUID:
{
FNetworkGUID NetGUID;
FNetControlMessage<NMT_BeaconAssignGUID>::Receive(Bunch, NetGUID);
if (NetGUID.IsValid())
{
Connection->Driver->GuidCache->RegisterNetGUID_Client( NetGUID, this );
FString BeaconType = GetBeaconType();
FNetControlMessage<NMT_BeaconNetGUIDAck>::Send(Connection, BeaconType);
// Server will send ClientOnConnected() when it gets this control message
// Fail safe for connection to server but no client connection RPC
FTimerDelegate TimerDelegate = FTimerDelegate::CreateUObject(this, &AOnlineBeaconClient::OnFailure);
GetWorldTimerManager().SetTimer(TimerHandle_OnFailure, TimerDelegate, BEACON_RPC_TIMEOUT, false);
}
else
{
// Force close the session
UE_LOG(LogNet, Log, TEXT("Beacon close from invalid NetGUID"));
OnFailure();
}
break;
}
case NMT_Upgrade:
{
// Report mismatch.
uint32 RemoteNetworkVersion;
FNetControlMessage<NMT_Upgrade>::Receive(Bunch, RemoteNetworkVersion);
// Upgrade
const FString ConnectionError = NSLOCTEXT("Engine", "ClientOutdated", "The match you are trying to join is running an incompatible version of the game. Please try upgrading your game version.").ToString();
GEngine->BroadcastNetworkFailure(GetWorld(), NetDriver, ENetworkFailure::OutdatedClient, ConnectionError);
break;
}
case NMT_Failure:
{
FString ErrorMsg;
FNetControlMessage<NMT_Failure>::Receive(Bunch, ErrorMsg);
if (ErrorMsg.IsEmpty())
{
ErrorMsg = NSLOCTEXT("NetworkErrors", "GenericBeaconConnectionFailed", "Beacon Connection Failed.").ToString();
}
// Force close the session
UE_LOG(LogNet, Log, TEXT("Beacon close from NMT_Failure %s"), *ErrorMsg);
OnFailure();
break;
}
case NMT_BeaconJoin:
case NMT_BeaconNetGUIDAck:
default:
{
// Force close the session
UE_LOG(LogNet, Log, TEXT("Beacon close from unexpected control message"));
OnFailure();
break;
}
}
}
}
void FBlueprintStatsModule::DumpBlueprintStats()
{
TArray<FBlueprintStatRecord> Records;
for (TObjectIterator<UBlueprint> BlueprintIt; BlueprintIt; ++BlueprintIt)
{
UBlueprint* Blueprint = *BlueprintIt;
new (Records) FBlueprintStatRecord(Blueprint);
}
// Now merge them
FBlueprintStatRecord Aggregate(NULL);
for (const FBlueprintStatRecord& SourceRecord : Records)
{
Aggregate.MergeAnotherRecordIn(SourceRecord);
}
// Sort the lists
Aggregate.NodeCount.ValueSort(TGreater<int32>());
Aggregate.FunctionCount.ValueSort(TGreater<int32>());
Aggregate.FunctionOwnerCount.ValueSort(TGreater<int32>());
Aggregate.RemoteMacroCount.ValueSort(TGreater<int32>());
// Print out the merged record
UE_LOG(LogBlueprintStats, Log, TEXT("Blueprint stats for %d blueprints in %s"), Records.Num(), GGameName);
UE_LOG(LogBlueprintStats, Log, TEXT("%s"), *Aggregate.ToString(true));
UE_LOG(LogBlueprintStats, Log, TEXT("%s"), *Aggregate.ToString(false));
UE_LOG(LogBlueprintStats, Log, TEXT("\n"));
// Print out the node list
UE_LOG(LogBlueprintStats, Log, TEXT("NodeClass,NumInstances"));
for (const auto& NodePair : Aggregate.NodeCount)
{
UE_LOG(LogBlueprintStats, Log, TEXT("%s,%d"), *(NodePair.Key->GetName()), NodePair.Value);
}
UE_LOG(LogBlueprintStats, Log, TEXT("\n"));
// Print out the function list
UE_LOG(LogBlueprintStats, Log, TEXT("FunctionPath,ClassName,FunctionName,NumInstances"));
for (const auto& FunctionPair : Aggregate.FunctionCount)
{
UFunction* Function = FunctionPair.Key;
UE_LOG(LogBlueprintStats, Log, TEXT("%s,%s,%s,%d"), *(Function->GetPathName()), *(Function->GetOuterUClass()->GetName()), *(Function->GetName()), FunctionPair.Value);
}
UE_LOG(LogBlueprintStats, Log, TEXT("\n"));
// Print out the macro list
UE_LOG(LogBlueprintStats, Log, TEXT("MacroPath,MacroName,NumInstances"));
for (const auto& MacroPair : Aggregate.RemoteMacroCount)
{
UEdGraph* MacroGraph = MacroPair.Key;
UE_LOG(LogBlueprintStats, Log, TEXT("%s,%s,%d"), *(MacroGraph->GetPathName()), *(MacroGraph->GetName()), MacroPair.Value);
}
UE_LOG(LogBlueprintStats, Log, TEXT("\n"));
}
bool UWorld::ComponentSweepMulti(TArray<struct FHitResult>& OutHits, class UPrimitiveComponent* PrimComp, const FVector& Start, const FVector& End, const FRotator& Rot, const struct FComponentQueryParams& Params) const
{
if(GetPhysicsScene() == NULL)
{
return false;
}
if(PrimComp == NULL)
{
UE_LOG(LogCollision, Log, TEXT("ComponentSweepMulti : No PrimComp"));
return false;
}
// if target is skeletalmeshcomponent and do not support singlebody physics
if ( !PrimComp->ShouldTrackOverlaps() )
{
UE_LOG(LogCollision, Log, TEXT("ComponentSweepMulti : (%s) Does not support skeletalmesh with Physics Asset and destructibles."), *PrimComp->GetPathName());
return false;
}
ECollisionChannel TraceChannel = PrimComp->GetCollisionObjectType();
#if WITH_PHYSX
// if extent is 0, do line trace
if (PrimComp->IsZeroExtent())
{
return RaycastMulti(this, OutHits, Start, End, TraceChannel, Params, FCollisionResponseParams(PrimComp->GetCollisionResponseToChannels()));
}
PxRigidActor* PRigidActor = PrimComp->BodyInstance.GetPxRigidActor();
if(PRigidActor == NULL)
{
UE_LOG(LogCollision, Log, TEXT("ComponentSweepMulti : (%s) No physics data"), *PrimComp->GetPathName());
return false;
}
PxScene * const PScene = PRigidActor->getScene();
OutHits.Empty();
// Get all the shapes from the actor
TArray<PxShape*, TInlineAllocator<8>> PShapes;
{
SCOPED_SCENE_READ_LOCK(PScene);
PShapes.AddZeroed(PRigidActor->getNbShapes());
PRigidActor->getShapes(PShapes.GetData(), PShapes.Num());
}
// calculate the test global pose of the actor
PxTransform PGlobalStartPose = U2PTransform(FTransform(Start));
PxTransform PGlobalEndPose = U2PTransform(FTransform(End));
bool bHaveBlockingHit = false;
PxQuat PGeomRot = U2PQuat(Rot.Quaternion());
// Iterate over each shape
SCENE_LOCK_READ(PScene);
for(int32 ShapeIdx=0; ShapeIdx<PShapes.Num(); ShapeIdx++)
{
PxShape* PShape = PShapes[ShapeIdx];
check(PShape);
TArray<struct FHitResult> Hits;
// Calc shape global pose
PxTransform PLocalShape = PShape->getLocalPose();
PxTransform PShapeGlobalStartPose = PGlobalStartPose.transform(PLocalShape);
PxTransform PShapeGlobalEndPose = PGlobalEndPose.transform(PLocalShape);
// consider localshape rotation for shape rotation
PxQuat PShapeRot = PGeomRot * PLocalShape.q;
GET_GEOMETRY_FROM_SHAPE(PGeom, PShape);
if(PGeom != NULL)
{
SCENE_UNLOCK_READ(PScene);
if (GeomSweepMulti(this, *PGeom, PShapeRot, Hits, P2UVector(PShapeGlobalStartPose.p), P2UVector(PShapeGlobalEndPose.p), TraceChannel, Params, FCollisionResponseParams(PrimComp->GetCollisionResponseToChannels())))
{
bHaveBlockingHit = true;
}
OutHits.Append(Hits);
SCENE_LOCK_READ(PScene);
}
}
SCENE_UNLOCK_READ(PScene);
return bHaveBlockingHit;
#endif //WITH_PHYSX
return false;
}
void USimpleConstructionScript::PostLoad()
{
Super::PostLoad();
int32 NodeIndex;
TArray<USCS_Node*> Nodes = GetAllNodes();
#if WITH_EDITOR
// Get the Blueprint that owns the SCS
UBlueprint* Blueprint = GetBlueprint();
if (!Blueprint)
{
// sometimes the PostLoad can be called, after the object was trashed, we dont want this
UE_LOG(LogBlueprint, Warning, TEXT("USimpleConstructionScript::PostLoad() '%s' cannot find its owner blueprint"), *GetPathName());
return;
}
for (NodeIndex=0; NodeIndex < Nodes.Num(); ++NodeIndex)
{
USCS_Node* Node = Nodes[NodeIndex];
// Fix up any uninitialized category names
if(Node->CategoryName == NAME_None)
{
Node->CategoryName = TEXT("Default");
}
// Fix up components that may have switched from scene to non-scene type and vice-versa
if(Node->ComponentTemplate != nullptr)
{
// Check to see if switched from scene to a non-scene component type
if (!Node->ComponentTemplate->IsA<USceneComponent>())
{
// Otherwise, check to see if switched from scene to non-scene component type
int32 RootNodeIndex = INDEX_NONE;
if(!RootNodes.Find(Node, RootNodeIndex))
{
// Move the node into the root set if it's currently in the scene hierarchy
USCS_Node* ParentNode = FindParentNode(Node);
if(ParentNode != nullptr)
{
ParentNode->ChildNodes.Remove(Node);
}
RootNodes.Add(Node);
}
else
{
// Otherwise, if it's a root node, promote one of its children (if any) to take its place
int32 PromoteIndex = FindPromotableChildNodeIndex(Node);
if(PromoteIndex != INDEX_NONE)
{
// Remove it as a child node
USCS_Node* ChildToPromote = Node->ChildNodes[PromoteIndex];
Node->ChildNodes.RemoveAt(PromoteIndex);
// Insert it as a root node just before its prior parent node; this way if it switches back to a scene type it won't supplant the new root we've just created
RootNodes.Insert(ChildToPromote, RootNodeIndex);
// Append previous root node's children to the new root
ChildToPromote->ChildNodes.Append(Node->ChildNodes);
// Clear all child nodes from the old root (because it's now a non-scene type and no longer supports attached components)
Node->ChildNodes.Empty();
// Copy any previous external attachment info from the previous root node
ChildToPromote->bIsParentComponentNative = Node->bIsParentComponentNative;
ChildToPromote->ParentComponentOrVariableName = Node->ParentComponentOrVariableName;
ChildToPromote->ParentComponentOwnerClassName = Node->ParentComponentOwnerClassName;
}
// Clear info for any previous external attachment if set
if(Node->ParentComponentOrVariableName != NAME_None)
{
Node->bIsParentComponentNative = false;
Node->ParentComponentOrVariableName = NAME_None;
Node->ParentComponentOwnerClassName = NAME_None;
}
}
}
}
}
#endif // WITH_EDITOR
// Fix up native/inherited parent attachments, in case anything has changed
FixupRootNodeParentReferences();
// Ensure that we have a valid scene root
ValidateSceneRootNodes();
// Reset non-native "root" scene component scale values, prior to the change in which
// we began applying custom scale values to root components at construction time. This
// way older, existing Blueprint actor instances won't start unexpectedly getting scaled.
if(GetLinkerUE4Version() < VER_UE4_BLUEPRINT_USE_SCS_ROOTCOMPONENT_SCALE)
{
// Get the BlueprintGeneratedClass that owns the SCS
UClass* BPGeneratedClass = GetOwnerClass();
if(BPGeneratedClass != nullptr)
{
// Get the Blueprint class default object
AActor* CDO = Cast<AActor>(BPGeneratedClass->GetDefaultObject(false));
if(CDO != NULL)
{
// Check for a native root component
USceneComponent* NativeRootComponent = CDO->GetRootComponent();
if(NativeRootComponent == nullptr)
{
// If no native root component exists, find the first non-native, non-parented SCS node with a
// scene component template. This will be designated as the root component at construction time.
for(NodeIndex = 0; NodeIndex < RootNodes.Num(); ++NodeIndex)
{
USCS_Node* Node = RootNodes[NodeIndex];
if(Node->ParentComponentOrVariableName == NAME_None)
{
// Note that we have to check for nullptr here, because it may be an ActorComponent type
USceneComponent* SceneComponentTemplate = Cast<USceneComponent>(Node->ComponentTemplate);
if(SceneComponentTemplate != nullptr
&& SceneComponentTemplate->RelativeScale3D != FVector(1.0f, 1.0f, 1.0f))
{
UE_LOG(LogBlueprint, Warning, TEXT("%s: Found non-native root component custom scale for %s (%s) saved prior to being usable; reverting to default scale."), *BPGeneratedClass->GetName(), *Node->GetVariableName().ToString(), *SceneComponentTemplate->RelativeScale3D.ToString());
SceneComponentTemplate->RelativeScale3D = FVector(1.0f, 1.0f, 1.0f);
}
// Done - no need to fix up any other nodes.
break;
}
}
}
}
}
}
}
bool UWorld::ComponentOverlapTest(class UPrimitiveComponent* PrimComp, const FVector& Pos, const FRotator& Rot, const struct FComponentQueryParams& Params) const
{
if(GetPhysicsScene() == NULL)
{
return false;
}
if(PrimComp == NULL)
{
UE_LOG(LogCollision, Log, TEXT("ComponentOverlapMulti : No PrimComp"));
return false;
}
// if target is skeletalmeshcomponent and do not support singlebody physics, we don't support this yet
// talk to @JG, SP, LH
if ( !PrimComp->ShouldTrackOverlaps() )
{
UE_LOG(LogCollision, Log, TEXT("ComponentOverlapMulti : (%s) Does not support skeletalmesh with Physics Asset and destructibles."), *PrimComp->GetPathName());
return false;
}
#if WITH_PHYSX
ECollisionChannel TraceChannel = PrimComp->GetCollisionObjectType();
PxRigidActor* PRigidActor = PrimComp->BodyInstance.GetPxRigidActor();
if(PRigidActor == NULL)
{
UE_LOG(LogCollision, Log, TEXT("ComponentOverlapMulti : (%s) No physics data"), *PrimComp->GetPathName());
return false;
}
// calculate the test global pose of the actor
PxTransform PTestGlobalPose = U2PTransform(FTransform(Rot, Pos));
// Get all the shapes from the actor
TArray<PxShape*, TInlineAllocator<8>> PShapes;
PShapes.AddZeroed(PRigidActor->getNbShapes());
int32 NumShapes = PRigidActor->getShapes(PShapes.GetData(), PShapes.Num());
// Iterate over each shape
for(int32 ShapeIdx=0; ShapeIdx<PShapes.Num(); ShapeIdx++)
{
PxShape* PShape = PShapes[ShapeIdx];
check(PShape);
// Calc shape global pose
PxTransform PLocalPose = PShape->getLocalPose();
PxTransform PShapeGlobalPose = PTestGlobalPose.transform(PLocalPose);
GET_GEOMETRY_FROM_SHAPE(PGeom, PShape);
if(PGeom != NULL)
{
if( GeomOverlapTest(this, *PGeom, PShapeGlobalPose, TraceChannel, Params, FCollisionResponseParams(PrimComp->GetCollisionResponseToChannels())))
{
// in this test, it only matters true or false.
// if we found first true, we don't care next test anymore.
return true;
}
}
}
#endif //WITH_PHYSX
return false;
}
bool UWorld::ComponentSweepSingle(struct FHitResult& OutHit,class UPrimitiveComponent* PrimComp, const FVector& Start, const FVector& End, const FRotator& Rot, const struct FComponentQueryParams& Params) const
{
OutHit.TraceStart = Start;
OutHit.TraceEnd = End;
if(GetPhysicsScene() == NULL)
{
return false;
}
if(PrimComp == NULL)
{
UE_LOG(LogCollision, Log, TEXT("ComponentSweepSingle : No PrimComp"));
return false;
}
// if target is skeletalmeshcomponent and do not support singlebody physics
if ( !PrimComp->ShouldTrackOverlaps() )
{
UE_LOG(LogCollision, Log, TEXT("ComponentSweepSingle : (%s) Does not support skeletalmesh with Physics Asset and destructibles."), *PrimComp->GetPathName());
return false;
}
ECollisionChannel TraceChannel = PrimComp->GetCollisionObjectType();
#if WITH_PHYSX
// if extent is 0, do line trace
if (PrimComp->IsZeroExtent())
{
return RaycastSingle(this, OutHit, Start, End, TraceChannel, Params, FCollisionResponseParams(PrimComp->GetCollisionResponseToChannels()));
}
PxRigidActor* PRigidActor = PrimComp->BodyInstance.GetPxRigidActor();
if(PRigidActor == NULL)
{
UE_LOG(LogCollision, Log, TEXT("ComponentSweepMulti : (%s) No physics data"), *PrimComp->GetPathName());
return false;
}
// Get all the shapes from the actor
TArray<PxShape*, TInlineAllocator<8>> PShapes;
PShapes.AddZeroed(PRigidActor->getNbShapes());
int32 NumShapes = PRigidActor->getShapes(PShapes.GetData(), PShapes.Num());
// calculate the test global pose of the actor
PxTransform PGlobalStartPose = U2PTransform(FTransform(Start));
PxTransform PGlobalEndPose = U2PTransform(FTransform(End));
bool bHaveBlockingHit = false;
PxQuat PGeomRot = U2PQuat(Rot.Quaternion());
// Iterate over each shape
for(int32 ShapeIdx=0; ShapeIdx<PShapes.Num(); ShapeIdx++)
{
PxShape* PShape = PShapes[ShapeIdx];
check(PShape);
// Calc shape global pose
PxTransform PLocalShape = PShape->getLocalPose();
PxTransform PShapeGlobalStartPose = PGlobalStartPose.transform(PLocalShape);
PxTransform PShapeGlobalEndPose = PGlobalEndPose.transform(PLocalShape);
// consider localshape rotation for shape rotation
PxQuat PShapeRot = PGeomRot * PLocalShape.q;
GET_GEOMETRY_FROM_SHAPE(PGeom, PShape);
if(PGeom != NULL)
{
// @todo UE4, this might not be the best behavior. If we're looking for the most closest, this have to change to save the result, and find the closest one or
// any other options, right now if anything hits first, it will return
if (GeomSweepSingle(this, *PGeom, PShapeRot, OutHit, P2UVector(PShapeGlobalStartPose.p), P2UVector(PShapeGlobalEndPose.p), TraceChannel, Params, FCollisionResponseParams(PrimComp->GetCollisionResponseToChannels())))
{
bHaveBlockingHit = true;
break;
}
}
}
return bHaveBlockingHit;
#endif //WITH_PHYSX
return false;
}
FArchive* CreateOutputArchive()
{
FArchive* OutputFilePtr = nullptr;
if (CommunicationMode == ThroughFile)
{
const double StartTime = FPlatformTime::Seconds();
bool bResult = false;
// It seems XGE does not support deleting files.
// Don't delete the input file if we are running under Incredibuild.
// Instead, we signal completion by creating a zero byte "Success" file after the output file has been fully written.
if (!GShaderCompileUseXGE)
{
do
{
// Remove the input file so that it won't get processed more than once
bResult = IFileManager::Get().Delete(*InputFilePath);
}
while (!bResult && (FPlatformTime::Seconds() - StartTime < 2));
if (!bResult)
{
UE_LOG(LogShaders, Fatal,TEXT("Couldn't delete input file %s, is it readonly?"), *InputFilePath);
}
}
#if PLATFORM_MAC || PLATFORM_LINUX
// To make sure that the process waiting for results won't read unfinished output file,
// we use a temp file name during compilation.
do
{
FGuid Guid;
FPlatformMisc::CreateGuid(Guid);
TempFilePath = WorkingDirectory + Guid.ToString();
} while (IFileManager::Get().FileSize(*TempFilePath) != INDEX_NONE);
// Create the output file.
OutputFilePtr = IFileManager::Get().CreateFileWriter(*TempFilePath,FILEWRITE_EvenIfReadOnly | FILEWRITE_NoFail);
#else
const double StartTime2 = FPlatformTime::Seconds();
do
{
// Create the output file.
OutputFilePtr = IFileManager::Get().CreateFileWriter(*OutputFilePath,FILEWRITE_EvenIfReadOnly);
}
while (!OutputFilePtr && (FPlatformTime::Seconds() - StartTime2 < 2));
if (!OutputFilePtr)
{
UE_LOG(LogShaders, Fatal,TEXT("Couldn't save output file %s"), *OutputFilePath);
}
#endif
}
else
{
#if PLATFORM_SUPPORTS_NAMED_PIPES
check(IsUsingNamedPipes());
// Output Transfer Buffer...
TransferBufferOut.Empty(0);
OutputFilePtr = new FMemoryWriter(TransferBufferOut);
#endif
}
return OutputFilePtr;
}
/** Called in the idle loop, checks for conditions under which the helper should exit */
void CheckExitConditions()
{
#if PLATFORM_SUPPORTS_NAMED_PIPES
if (CommunicationMode == ThroughNamedPipeOnce)
{
UE_LOG(LogShaders, Log, TEXT("PipeOnce: exiting after one job."));
FPlatformMisc::RequestExit(false);
}
else if (CommunicationMode == ThroughFile)
#endif
{
if (!InputFilename.Contains(TEXT("Only")))
{
UE_LOG(LogShaders, Log, TEXT("InputFilename did not contain 'Only', exiting after one job."));
FPlatformMisc::RequestExit(false);
}
}
#if PLATFORM_MAC || PLATFORM_LINUX
if (!FPlatformMisc::IsDebuggerPresent() && ParentProcessId > 0)
{
// If the parent process is no longer running, exit
if (!FPlatformProcess::IsApplicationRunning(ParentProcessId))
{
FString InputFilePath = FString(WorkingDirectory) + InputFilename;
checkf(IFileManager::Get().FileSize(*InputFilePath) == INDEX_NONE, TEXT("Exiting due to the parent process no longer running and the input file is present!"));
UE_LOG(LogShaders, Log, TEXT("Parent process no longer running, exiting"));
FPlatformMisc::RequestExit(false);
}
}
const double CurrentTime = FPlatformTime::Seconds();
// If we have been idle for 20 seconds then exit
if (CurrentTime - LastCompileTime > 20.0)
{
UE_LOG(LogShaders, Log, TEXT("No jobs found for 20 seconds, exiting"));
FPlatformMisc::RequestExit(false);
}
#else
// Don't do these if the debugger is present
//@todo - don't do these if Unreal is being debugged either
if (!IsDebuggerPresent())
{
if (ParentProcessId > 0)
{
FString InputFilePath = FString(WorkingDirectory) + InputFilename;
bool bParentStillRunning = true;
HANDLE ParentProcessHandle = OpenProcess(SYNCHRONIZE, false, ParentProcessId);
// If we couldn't open the process then it is no longer running, exit
if (ParentProcessHandle == nullptr)
{
if (!IsUsingNamedPipes())
{
checkf(IFileManager::Get().FileSize(*InputFilePath) == INDEX_NONE, TEXT("Exiting due to OpenProcess(ParentProcessId) failing and the input file is present!"));
}
UE_LOG(LogShaders, Log, TEXT("Couldn't OpenProcess, Parent process no longer running, exiting"));
FPlatformMisc::RequestExit(false);
}
else
{
// If we did open the process, that doesn't mean it is still running
// The process object stays alive as long as there are handles to it
// We need to check if the process has signaled, which indicates that it has exited
uint32 WaitResult = WaitForSingleObject(ParentProcessHandle, 0);
if (WaitResult != WAIT_TIMEOUT)
{
if (!IsUsingNamedPipes())
{
checkf(IFileManager::Get().FileSize(*InputFilePath) == INDEX_NONE, TEXT("Exiting due to WaitForSingleObject(ParentProcessHandle) signaling and the input file is present!"));
}
UE_LOG(LogShaders, Log, TEXT("WaitForSingleObject signaled, Parent process no longer running, exiting"));
FPlatformMisc::RequestExit(false);
}
CloseHandle(ParentProcessHandle);
}
}
const double CurrentTime = FPlatformTime::Seconds();
// If we have been idle for 20 seconds then exit
if (CurrentTime - LastCompileTime > 20.0)
{
UE_LOG(LogShaders, Log, TEXT("No jobs found for 20 seconds, exiting"));
FPlatformMisc::RequestExit(false);
}
}
#endif
}
void ALobbyBeaconState::DumpState() const
{
UE_LOG(LogBeacon, Display, TEXT("Players:"));
Players.DumpState();
}
void Loop()
{
UE_LOG(LogShaders, Log, TEXT("Entering job loop"));
while(true)
{
TArray<FJobResult> JobResults;
// Read & Process Input
{
FArchive* InputFilePtr = OpenInputFile();
if(!InputFilePtr)
{
break;
}
UE_LOG(LogShaders, Log, TEXT("Processing shader"));
LastCompileTime = FPlatformTime::Seconds();
ProcessInputFromArchive(InputFilePtr, JobResults);
// Close the input file.
delete InputFilePtr;
}
// Prepare for output
FArchive* OutputFilePtr = CreateOutputArchive();
check(OutputFilePtr);
WriteToOutputArchive(OutputFilePtr, JobResults);
// Close the output file.
delete OutputFilePtr;
#if PLATFORM_MAC || PLATFORM_LINUX
// Change the output file name to requested one
IFileManager::Get().Move(*OutputFilePath, *TempFilePath);
#endif
#if PLATFORM_SUPPORTS_NAMED_PIPES
if (CommunicationMode == ThroughNamedPipeOnce || CommunicationMode == ThroughNamedPipe)
{
VerifyResult(Pipe.WriteInt32(TransferBufferOut.Num()), TEXT("Writing Transfer Size"));
VerifyResult(Pipe.WriteBytes(TransferBufferOut.Num(), TransferBufferOut.GetData()), TEXT("Writing Transfer Buffer"));
//FPlatformMisc::LowLevelOutputDebugStringf(TEXT("*** Closing pipe...\n"));
Pipe.Destroy();
if (CommunicationMode == ThroughNamedPipeOnce)
{
// Give up CPU time while we are waiting
FPlatformProcess::Sleep(0.02f);
break;
}
LastConnectionTime = FPlatformTime::Seconds();
}
#endif // PLATFORM_SUPPORTS_NAMED_PIPES
if (GShaderCompileUseXGE)
{
// To signal compilation completion, create a zero length file in the working directory.
WriteXGESuccessFile(*WorkingDirectory);
// We only do one pass per process when using XGE.
break;
}
}
UE_LOG(LogShaders, Log, TEXT("Exiting job loop"));
}
void UGameEngine::Init(IEngineLoop* InEngineLoop)
{
DECLARE_SCOPE_CYCLE_COUNTER(TEXT("UGameEngine Init"), STAT_GameEngineStartup, STATGROUP_LoadTime);
// Call base.
UEngine::Init(InEngineLoop);
#if USE_NETWORK_PROFILER
FString NetworkProfilerTag;
if( FParse::Value(FCommandLine::Get(), TEXT("NETWORKPROFILER="), NetworkProfilerTag ) )
{
GNetworkProfiler.EnableTracking(true);
}
#endif
// Load and apply user game settings
GetGameUserSettings()->LoadSettings();
GetGameUserSettings()->ApplySettings();
// Creates the initial world context. For GameEngine, this should be the only WorldContext that ever gets created.
FWorldContext &InitialWorldContext = CreateNewWorldContext(EWorldType::Game);
// Initialize the viewport client.
UGameViewportClient* ViewportClient = NULL;
if(GIsClient)
{
ViewportClient = ConstructObject<UGameViewportClient>(GameViewportClientClass,this);
ViewportClient->SetReferenceToWorldContext(InitialWorldContext);
GameViewport = ViewportClient;
InitialWorldContext.GameViewport = ViewportClient;
}
bCheckForMovieCapture = true;
// Attach the viewport client to a new viewport.
if(ViewportClient)
{
// This must be created before any gameplay code adds widgets
bool bWindowAlreadyExists = GameViewportWindow.IsValid();
if (!bWindowAlreadyExists)
{
GameViewportWindow = CreateGameWindow();
}
CreateGameViewport( ViewportClient );
if( !bWindowAlreadyExists )
{
SwitchGameWindowToUseGameViewport();
}
FString Error;
if(!ViewportClient->Init(Error))
{
UE_LOG(LogEngine, Fatal,TEXT("%s"),*Error);
}
}
// Create default URL.
// @note: if we change how we determine the valid start up map update LaunchEngineLoop's GetStartupMap()
FURL DefaultURL;
DefaultURL.LoadURLConfig( TEXT("DefaultPlayer"), GGameIni );
// Enter initial world.
EBrowseReturnVal::Type BrowseRet = EBrowseReturnVal::Failure;
FString Error;
TCHAR Parm[4096]=TEXT("");
const TCHAR* Tmp = FCommandLine::Get();
#if UE_BUILD_SHIPPING
// In shipping don't allow an override
Tmp = TEXT("");
#endif // UE_BUILD_SHIPPING
const UGameMapsSettings* GameMapsSettings = GetDefault<UGameMapsSettings>();
const FString& DefaultMap = GameMapsSettings->GetGameDefaultMap();
if (!FParse::Token(Tmp, Parm, ARRAY_COUNT(Parm), 0) || Parm[0] == '-')
{
FCString::Strcpy(Parm, *(DefaultMap + GameMapsSettings->LocalMapOptions));
}
FURL URL( &DefaultURL, Parm, TRAVEL_Partial );
if( URL.Valid )
{
BrowseRet = Browse(InitialWorldContext, URL, Error );
}
// If waiting for a network connection, go into the starting level.
if (BrowseRet != EBrowseReturnVal::Success && FCString::Stricmp(Parm, *DefaultMap) != 0)
{
const FText Message = FText::Format( NSLOCTEXT("Engine", "MapNotFound", "The map specified on the commandline '{0}' could not be found. Would you like to load the default map instead?"), FText::FromString( URL.Map ) );
// the map specified on the command-line couldn't be loaded. ask the user if we should load the default map instead
if ( FCString::Stricmp(*URL.Map, *DefaultMap) != 0 &&
FMessageDialog::Open( EAppMsgType::OkCancel, Message ) != EAppReturnType::Ok)
{
// user canceled (maybe a typo while attempting to run a commandlet)
FPlatformMisc::RequestExit( false );
return;
}
else
{
BrowseRet = Browse(InitialWorldContext, FURL(&DefaultURL, *(DefaultMap + GameMapsSettings->LocalMapOptions), TRAVEL_Partial), Error);
}
}
// Handle failure.
if( BrowseRet != EBrowseReturnVal::Success )
{
UE_LOG(LogLoad, Fatal, TEXT("%s"), *FString::Printf( TEXT("Failed to enter %s: %s. Please check the log for errors."), Parm, *Error) );
}
UE_LOG(LogInit, Display, TEXT("Game Engine Initialized.") );
// for IsInitialized()
bIsInitialized = true;
}
void UGameEngine::Tick( float DeltaSeconds, bool bIdleMode )
{
SCOPE_CYCLE_COUNTER(STAT_GameEngineTick);
NETWORK_PROFILER(GNetworkProfiler.TrackFrameBegin());
int32 LocalTickCycles=0;
CLOCK_CYCLES(LocalTickCycles);
// -----------------------------------------------------
// Non-World related stuff
// -----------------------------------------------------
if( DeltaSeconds < 0.0f )
{
#if (UE_BUILD_SHIPPING && WITH_EDITOR)
// End users don't have access to the secure parts of UDN. Regardless, they won't
// need the warning because the game ships with AMD drivers that address the issue.
UE_LOG(LogEngine, Fatal,TEXT("Negative delta time!"));
#else
// Send developers to the support list thread.
UE_LOG(LogEngine, Fatal,TEXT("Negative delta time! Please see https://udn.epicgames.com/lists/showpost.php?list=ue3bugs&id=4364"));
#endif
}
// Tick allocator
if( GMalloc != NULL )
{
GMalloc->Tick( DeltaSeconds );
}
// Tick the module manager
FModuleManager::Get().Tick();
if (!IsRunningDedicatedServer() && !IsRunningCommandlet())
{
// Clean up the game viewports that have been closed.
CleanupGameViewport();
}
// If all viewports closed, time to exit.
if(GIsClient && GameViewport == NULL )
{
UE_LOG(LogEngine, Log, TEXT("All Windows Closed") );
FPlatformMisc::RequestExit( 0 );
return;
}
if ( GameViewport != NULL )
{
// Decide whether to drop high detail because of frame rate.
GameViewport->SetDropDetail(DeltaSeconds);
}
// Update subsystems.
{
// This assumes that UObject::StaticTick only calls ProcessAsyncLoading.
StaticTick( DeltaSeconds );
}
// -----------------------------------------------------
// Begin ticking worlds
// -----------------------------------------------------
int32 OriginalGWorldContext = INDEX_NONE;
for (int32 i=0; i < WorldList.Num(); ++i)
{
if (WorldList[i].World() == GWorld)
{
OriginalGWorldContext = WorldList[i].ContextHandle;
break;
}
}
bool WorldWasPaused = false;
for (int32 WorldIdx = 0; WorldIdx < WorldList.Num(); ++WorldIdx)
{
FWorldContext &Context = WorldList[WorldIdx];
if (Context.World() == NULL)
{
continue;
}
WorldWasPaused |= Context.World()->IsPaused();
GWorld = Context.World();
// Tick all travel and Pending NetGames (Seamless, server, client)
TickWorldTravel(Context, DeltaSeconds);
if (!IsRunningDedicatedServer() && !IsRunningCommandlet())
{
// Only update reflection captures in game once all 'always loaded' levels have been loaded
// This won't work with actual level streaming though
if (Context.World()->AreAlwaysLoadedLevelsLoaded())
{
// Update sky light first because it's considered direct lighting, sky diffuse will be visible in reflection capture indirect specular
USkyLightComponent::UpdateSkyCaptureContents(Context.World());
UReflectionCaptureComponent::UpdateReflectionCaptureContents(Context.World());
}
}
if (!bIdleMode)
{
// Tick the world.
GameCycles=0;
CLOCK_CYCLES(GameCycles);
Context.World()->Tick( LEVELTICK_All, DeltaSeconds );
UNCLOCK_CYCLES(GameCycles);
}
// Issue cause event after first tick to provide a chance for the game to spawn the player and such.
if( Context.World()->bWorldWasLoadedThisTick )
{
Context.World()->bWorldWasLoadedThisTick = false;
const TCHAR* InitialExec = Context.LastURL.GetOption(TEXT("causeevent="),NULL);
ULocalPlayer* GamePlayer = Context.GamePlayers.Num() > 0 ? Context.GamePlayers[0] : NULL;
if( InitialExec && GamePlayer )
{
UE_LOG(LogEngine, Log, TEXT("Issuing initial cause event passed from URL: %s"), InitialExec);
GamePlayer->Exec( GamePlayer->GetWorld(), *(FString("CAUSEEVENT ") + InitialExec), *GLog );
}
Context.World()->bTriggerPostLoadMap = true;
}
// Tick the viewports.
if ( GameViewport != NULL && !bIdleMode )
{
SCOPE_CYCLE_COUNTER(STAT_GameViewportTick);
GameViewport->Tick(DeltaSeconds);
}
UpdateTransitionType(Context.World());
// fixme: this will only happen once due to the static bool, but still need to figure out how to handle this for multiple worlds
if (FPlatformProperties::SupportsWindowedMode())
{
// Hide the splashscreen and show the game window
static bool bFirstTime = true;
if ( bFirstTime )
{
bFirstTime = false;
FPlatformSplash::Hide();
if ( GameViewportWindow.IsValid() )
{
GameViewportWindow.Pin()->ShowWindow();
FSlateApplication::Get().RegisterGameViewport( GameViewportWidget.ToSharedRef() );
}
}
}
if (!bIdleMode && !IsRunningDedicatedServer() && !IsRunningCommandlet())
{
// Render everything.
RedrawViewports();
}
// Block on async loading if requested.
if( Context.World()->bRequestedBlockOnAsyncLoading )
{
// Only perform work if there is anything to do. This ensures we are not syncronizing with the GPU
// and suspending the device needlessly.
bool bWorkToDo = IsAsyncLoading();
if (!bWorkToDo)
{
Context.World()->UpdateLevelStreaming();
bWorkToDo = Context.World()->IsVisibilityRequestPending();
}
if (bWorkToDo)
{
// tell clients to do the same so they don't fall behind
for( FConstPlayerControllerIterator Iterator = Context.World()->GetPlayerControllerIterator(); Iterator; ++Iterator )
{
APlayerController* PlayerController = *Iterator;
UNetConnection* Conn = Cast<UNetConnection>(PlayerController->Player);
if (Conn != NULL && Conn->GetUChildConnection() == NULL)
{
// call the event to replicate the call
PlayerController->ClientSetBlockOnAsyncLoading();
// flush the connection to make sure it gets sent immediately
Conn->FlushNet(true);
}
}
FStreamingPause::GameThreadWantsToSuspendRendering( GameViewport ? GameViewport->Viewport : NULL );
// Flushes level streaming requests, blocking till completion.
Context.World()->FlushLevelStreaming();
FStreamingPause::GameThreadWantsToResumeRendering();
}
Context.World()->bRequestedBlockOnAsyncLoading = false;
}
// streamingServer
if( GIsServer == true )
{
SCOPE_CYCLE_COUNTER(STAT_UpdateLevelStreaming);
Context.World()->UpdateLevelStreaming();
}
// Update Audio. This needs to occur after rendering as the rendering code updates the listener position.
if( GetAudioDevice() )
{
GetAudioDevice()->Update( !Context.World()->IsPaused() );
}
if( GIsClient )
{
// GStreamingManager is updated outside of a world context. For now, assuming it needs to tick here, before possibly calling PostLoadMap.
// Will need to take another look when trying to support multiple worlds.
// Update resource streaming after viewports have had a chance to update view information. Normal update.
GStreamingManager->Tick( DeltaSeconds );
if ( Context.World()->bTriggerPostLoadMap )
{
Context.World()->bTriggerPostLoadMap = false;
// Turns off the loading movie (if it was turned on by LoadMap) and other post-load cleanup.
PostLoadMap();
}
}
UNCLOCK_CYCLES(LocalTickCycles);
TickCycles=LocalTickCycles;
// See whether any map changes are pending and we requested them to be committed.
ConditionalCommitMapChange(Context);
}
// ----------------------------
// End per-world ticking
// ----------------------------
// Restore original GWorld*. This will go away one day.
if (OriginalGWorldContext != INDEX_NONE)
{
GWorld = WorldContextFromHandle(OriginalGWorldContext).World();
}
// tell renderer about GWorld->IsPaused(), before rendering
{
ENQUEUE_UNIQUE_RENDER_COMMAND_ONEPARAMETER(
SetPaused,
bool, bGamePaused, WorldWasPaused,
{
GRenderingRealtimeClock.SetGamePaused(bGamePaused);
});
}
/**
* Dump helpers
*/
void FSystemSettingsData::DumpTextureLODGroup(TextureGroup TextureGroupID, const TCHAR* GroupName)
{
const FString Entry = GetLODGroupString( TextureGroupID, GroupName );
UE_LOG(LogSystemSettings, Log, TEXT("\t%s: %s"), GroupName, *Entry );
}
bool FLinuxPlatformProcess::ExecProcess( const TCHAR* URL, const TCHAR* Params, int32* OutReturnCode, FString* OutStdOut, FString* OutStdErr )
{
TArray<FString> ArgsArray;
FString(Params).ParseIntoArray(&ArgsArray, TEXT(" "), true);
char *args[ArgsArray.Num()];
for(int i = 0; i < ArgsArray.Num(); i++)
{
args[i] = TCHAR_TO_ANSI(*ArgsArray[i]);
}
pid_t pid;
int status;
int fd_stdout[2], fd_stderr[2];
if (pipe(fd_stdout) == -1)
{
int ErrNo = errno;
UE_LOG(LogHAL, Fatal, TEXT("Creating fd_stdout pipe failed with errno = %d (%s)"), ErrNo,
StringCast< TCHAR >(strerror(ErrNo)).Get());
return false;
}
if (pipe(fd_stderr) == -1)
{
int ErrNo = errno;
UE_LOG(LogHAL, Fatal, TEXT("Creating fd_stderr pipe failed with errno = %d (%s)"), ErrNo,
StringCast< TCHAR >(strerror(ErrNo)).Get());
return false;
}
pid = fork();
if(pid < 0)
{
int ErrNo = errno;
UE_LOG(LogHAL, Fatal, TEXT("fork() failed with errno = %d (%s)"), ErrNo,
StringCast< TCHAR >(strerror(ErrNo)).Get());
return false;
}
if(pid == 0)
{
close(fd_stdout[0]);
close(fd_stderr[0]);
dup2(fd_stdout[1], 1);
dup2(fd_stderr[1], 2);
close(fd_stdout[1]);
close(fd_stderr[1]);
// TODO Not sure if we need to look up URL in PATH
exit(execv(TCHAR_TO_ANSI(URL), args));
}
else
{
// TODO This might deadlock, should use select. Rewrite me. Also doesn't handle all errors correctly.
close(fd_stdout[1]);
close(fd_stderr[1]);
do
{
pid_t wpid = waitpid(pid, &status, 0);
if (wpid == -1)
{
int ErrNo = errno;
UE_LOG(LogHAL, Fatal, TEXT("waitpid() failed with errno = %d (%s)"), ErrNo,
StringCast< TCHAR >(strerror(ErrNo)).Get());
return false;
}
if (WIFEXITED(status))
{
*OutReturnCode = WEXITSTATUS(status);
}
else if (WIFSIGNALED(status))
{
*OutReturnCode = WTERMSIG(status);
}
} while (!WIFEXITED(status) && !WIFSIGNALED(status));
while(1)
{
char buf[100];
int size = read(fd_stdout[0], buf, 100);
if(size)
{
if(OutStdErr)
{
*OutStdErr += FString(buf);
}
}
else
{
break;
}
}
while(1)
{
char buf[100];
int size = read(fd_stderr[0], buf, 100);
if(size)
{
if(OutStdOut)
{
*OutStdOut += FString(buf);
}
}
else
{
break;
}
}
return true;
}
}
FProcHandle FLinuxPlatformProcess::CreateProc(const TCHAR* URL, const TCHAR* Parms, bool bLaunchDetached, bool bLaunchHidden, bool bLaunchReallyHidden, uint32* OutProcessID, int32 PriorityModifier, const TCHAR* OptionalWorkingDirectory, void* PipeWrite)
{
// @TODO bLaunchHidden bLaunchReallyHidden are not handled
// We need an absolute path to executable
FString ProcessPath = URL;
if (*URL != '/')
{
ProcessPath = FPaths::ConvertRelativePathToFull(ProcessPath);
}
if (!FPaths::FileExists(ProcessPath))
{
return FProcHandle();
}
FString Commandline = ProcessPath;
Commandline += TEXT(" ");
Commandline += Parms;
UE_LOG(LogHAL, Verbose, TEXT("FLinuxPlatformProcess::CreateProc: '%s'"), *Commandline);
TArray<FString> ArgvArray;
int Argc = Commandline.ParseIntoArray(&ArgvArray, TEXT(" "), true);
char* Argv[PlatformProcessLimits::MaxArgvParameters + 1] = { NULL }; // last argument is NULL, hence +1
struct CleanupArgvOnExit
{
int Argc;
char** Argv; // relying on it being long enough to hold Argc elements
CleanupArgvOnExit( int InArgc, char *InArgv[] )
: Argc(InArgc)
, Argv(InArgv)
{}
~CleanupArgvOnExit()
{
for (int Idx = 0; Idx < Argc; ++Idx)
{
FMemory::Free(Argv[Idx]);
}
}
} CleanupGuard(Argc, Argv);
// make sure we do not lose arguments with spaces in them due to Commandline.ParseIntoArray breaking them apart above
// @todo this code might need to be optimized somehow and integrated with main argument parser below it
TArray<FString> NewArgvArray;
if (Argc > 0)
{
if (Argc > PlatformProcessLimits::MaxArgvParameters)
{
UE_LOG(LogHAL, Warning, TEXT("FLinuxPlatformProcess::CreateProc: too many (%d) commandline arguments passed, will only pass %d"),
Argc, PlatformProcessLimits::MaxArgvParameters);
Argc = PlatformProcessLimits::MaxArgvParameters;
}
FString MultiPartArg;
for (int32 Index = 0; Index < Argc; Index++)
{
if (MultiPartArg.IsEmpty())
{
if ((ArgvArray[Index].StartsWith(TEXT("\"")) && !ArgvArray[Index].EndsWith(TEXT("\""))) // check for a starting quote but no ending quote, excludes quoted single arguments
|| (ArgvArray[Index].Contains(TEXT("=\"")) && !ArgvArray[Index].EndsWith(TEXT("\""))) // check for quote after =, but no ending quote, this gets arguments of the type -blah="string string string"
|| ArgvArray[Index].EndsWith(TEXT("=\""))) // check for ending quote after =, this gets arguments of the type -blah=" string string string "
{
MultiPartArg = ArgvArray[Index];
}
else
{
if (ArgvArray[Index].Contains(TEXT("=\"")))
{
FString SingleArg = ArgvArray[Index];
SingleArg = SingleArg.Replace(TEXT("=\""), TEXT("="));
NewArgvArray.Add(SingleArg.TrimQuotes(NULL));
}
else
{
NewArgvArray.Add(ArgvArray[Index].TrimQuotes(NULL));
}
}
}
else
{
MultiPartArg += TEXT(" ");
MultiPartArg += ArgvArray[Index];
if (ArgvArray[Index].EndsWith(TEXT("\"")))
{
if (MultiPartArg.StartsWith(TEXT("\"")))
{
NewArgvArray.Add(MultiPartArg.TrimQuotes(NULL));
}
else
{
NewArgvArray.Add(MultiPartArg);
}
MultiPartArg.Empty();
}
}
}
}
// update Argc with the new argument count
Argc = NewArgvArray.Num();
if (Argc > 0) // almost always, unless there's no program name
{
if (Argc > PlatformProcessLimits::MaxArgvParameters)
{
UE_LOG(LogHAL, Warning, TEXT("FLinuxPlatformProcess::CreateProc: too many (%d) commandline arguments passed, will only pass %d"),
Argc, PlatformProcessLimits::MaxArgvParameters);
Argc = PlatformProcessLimits::MaxArgvParameters;
}
for (int Idx = 0; Idx < Argc; ++Idx)
{
auto AnsiBuffer = StringCast<ANSICHAR>(*NewArgvArray[Idx]);
const char* Ansi = AnsiBuffer.Get();
size_t AnsiSize = FCStringAnsi::Strlen(Ansi) + 1;
check(AnsiSize);
Argv[Idx] = reinterpret_cast< char* >( FMemory::Malloc(AnsiSize) );
check(Argv[Idx]);
FCStringAnsi::Strncpy(Argv[Idx], Ansi, AnsiSize);
}
// last Argv should be NULL
check(Argc <= PlatformProcessLimits::MaxArgvParameters + 1);
Argv[Argc] = NULL;
}
extern char ** environ; // provided by libc
pid_t ChildPid = -1;
posix_spawn_file_actions_t FileActions;
posix_spawn_file_actions_init(&FileActions);
if (PipeWrite)
{
const FPipeHandle* PipeWriteHandle = reinterpret_cast< const FPipeHandle* >(PipeWrite);
posix_spawn_file_actions_adddup2(&FileActions, PipeWriteHandle->GetHandle(), STDOUT_FILENO);
}
int ErrNo = posix_spawn(&ChildPid, TCHAR_TO_ANSI(*ProcessPath), &FileActions, NULL, Argv, environ);
posix_spawn_file_actions_destroy(&FileActions);
if (ErrNo != 0)
{
UE_LOG(LogHAL, Fatal, TEXT("FLinuxPlatformProcess::CreateProc: posix_spawn() failed (%d, %s)"), ErrNo, ANSI_TO_TCHAR(strerror(ErrNo)));
return FProcHandle(); // produce knowingly invalid handle if for some reason Fatal log (above) returns
}
else
{
UE_LOG(LogHAL, Log, TEXT("FLinuxPlatformProcess::CreateProc: spawned child %d"), ChildPid);
}
if (OutProcessID)
{
*OutProcessID = ChildPid;
}
return FProcHandle( ChildPid );
}
void AOnlineBeaconClient::OnFailure()
{
UE_LOG(LogBeacon, Verbose, TEXT("Client beacon (%s) connection failure, handling connection timeout."), *GetName());
HostConnectionFailure.ExecuteIfBound();
Super::OnFailure();
}
void USimpleConstructionScript::FixupRootNodeParentReferences()
{
// Get the BlueprintGeneratedClass that owns the SCS
UClass* BPGeneratedClass = GetOwnerClass();
if(BPGeneratedClass == NULL)
{
UE_LOG(LogBlueprint, Warning, TEXT("USimpleConstructionScript::FixupRootNodeParentReferences() - owner class is NULL; skipping."));
// cannot do the rest of fixup without a BPGC
return;
}
for (int32 NodeIndex=0; NodeIndex < RootNodes.Num(); ++NodeIndex)
{
// If this root node is parented to a native/inherited component template
USCS_Node* RootNode = RootNodes[NodeIndex];
if(RootNode->ParentComponentOrVariableName != NAME_None)
{
bool bWasFound = false;
// If the node is parented to a native component
if(RootNode->bIsParentComponentNative)
{
// Get the Blueprint class default object
AActor* CDO = Cast<AActor>(BPGeneratedClass->GetDefaultObject(false));
if(CDO != NULL)
{
// Look for the parent component in the CDO's components array
TInlineComponentArray<UActorComponent*> Components;
CDO->GetComponents(Components);
for (auto CompIter = Components.CreateConstIterator(); CompIter && !bWasFound; ++CompIter)
{
UActorComponent* ComponentTemplate = *CompIter;
bWasFound = ComponentTemplate->GetFName() == RootNode->ParentComponentOrVariableName;
}
}
else
{
// SCS and BGClass depends on each other (while their construction).
// Class is not ready, so one have to break the dependency circle.
continue;
}
}
// Otherwise the node is parented to an inherited SCS node from a parent Blueprint
else
{
// Get the Blueprint hierarchy
TArray<const UBlueprintGeneratedClass*> ParentBPClassStack;
const bool bErrorFree = UBlueprintGeneratedClass::GetGeneratedClassesHierarchy(BPGeneratedClass, ParentBPClassStack);
// Find the parent Blueprint in the hierarchy
for(int32 StackIndex = ParentBPClassStack.Num() - 1; StackIndex > 0; --StackIndex)
{
auto ParentClass = ParentBPClassStack[StackIndex];
if( ParentClass != NULL
&& ParentClass->SimpleConstructionScript != NULL
&& ParentClass->GetFName() == RootNode->ParentComponentOwnerClassName)
{
// Attempt to locate a match by searching all the nodes that belong to the parent Blueprint's SCS
TArray<USCS_Node*> ParentNodes = ParentClass->SimpleConstructionScript->GetAllNodes();
for (int32 ParentNodeIndex=0; ParentNodeIndex < ParentNodes.Num() && !bWasFound; ++ParentNodeIndex)
{
USCS_Node* ParentNode = ParentNodes[ParentNodeIndex];
bWasFound = ParentNode != NULL && ParentNode->VariableName == RootNode->ParentComponentOrVariableName;
}
// We found a match; no need to continue searching the hierarchy
break;
}
}
}
// Clear parent info if we couldn't find the parent component instance
if(!bWasFound)
{
UE_LOG(LogBlueprint, Warning, TEXT("USimpleConstructionScript::FixupRootNodeParentReferences() - Couldn't find %s parent component '%s' for '%s' in BlueprintGeneratedClass '%s' (it may have been removed)"), RootNode->bIsParentComponentNative ? TEXT("native") : TEXT("inherited"), *RootNode->ParentComponentOrVariableName.ToString(), *RootNode->GetVariableName().ToString(), *BPGeneratedClass->GetName());
RootNode->bIsParentComponentNative = false;
RootNode->ParentComponentOrVariableName = NAME_None;
RootNode->ParentComponentOwnerClassName = NAME_None;
}
}
}
// call this after we do the above ParentComponentOrVariableName fixup,
// because this operates differently for root nodes that have their
// ParentComponentOrVariableName field cleared
//
// repairs invalid scene hierarchies (like when this Blueprint has been
// reparented and there is no longer an inherited scene root... meaning one
// of the scene component nodes here needs to be promoted)
FixupSceneNodeHierarchy();
}
