/**
* Crash test
*/
int32 CrashTest(const TCHAR* CommandLine)
{
FPlatformMisc::SetCrashHandler(NULL);
FPlatformMisc::SetGracefulTerminationHandler();
GEngineLoop.PreInit(CommandLine);
UE_LOG(LogTestPAL, Display, TEXT("Running crash test (this should not exit)."));
// try ensures first (each ensure fires just once)
{
for (int IdxEnsure = 0; IdxEnsure < 5; ++IdxEnsure)
{
FScopeLogTime EnsureLogTime(*FString::Printf(TEXT("Handled FIRST ensure() #%d times"), IdxEnsure), nullptr, FScopeLogTime::ScopeLog_Seconds);
ensure(false);
}
}
{
for (int IdxEnsure = 0; IdxEnsure < 5; ++IdxEnsure)
{
FScopeLogTime EnsureLogTime(*FString::Printf(TEXT("Handled SECOND ensure() #%d times"), IdxEnsure), nullptr, FScopeLogTime::ScopeLog_Seconds);
ensure(false);
}
}
if (FParse::Param(CommandLine, TEXT("logfatal")))
{
UE_LOG(LogTestPAL, Fatal, TEXT(" LogFatal!"));
}
else if (FParse::Param(CommandLine, TEXT("check")))
{
checkf(false, TEXT(" checkf!"));
}
else
{
*(int *)0x10 = 0x11;
}
FEngineLoop::AppPreExit();
FEngineLoop::AppExit();
return 0;
}
/**
* Links a vertex shader and pixel shader into a program for use in rendering
*
* @param VertexShader The vertex shader to link
* @param PixelShader The pixel shader to link
*/
void FSlateOpenGLShaderProgram::LinkShaders( const FSlateOpenGLVS& VertexShader, const FSlateOpenGLPS& PixelShader )
{
// Should not link twice
check( ProgramID == 0 );
GLuint VertexShaderID = VertexShader.GetShaderID();
GLuint PixelShaderID = PixelShader.GetShaderID();
// Make sure the shaders have been created
check( VertexShaderID && PixelShaderID );
// Create a new program id and attach the shaders
ProgramID = glCreateProgram();
glAttachShader( ProgramID, VertexShaderID );
glAttachShader( ProgramID, PixelShaderID );
CHECK_GL_ERRORS;
// Set up attribute locations for per vertex data
glBindAttribLocation(ProgramID, 0, "InTexCoords");
glBindAttribLocation(ProgramID, 1, "InPosition");
glBindAttribLocation(ProgramID, 2, "InClipOrigin");
glBindAttribLocation(ProgramID, 3, "InClipExtents");
glBindAttribLocation(ProgramID, 4, "InColor");
// Link the shaders
glLinkProgram( ProgramID );
CHECK_GL_ERRORS;
// Check to see if linking succeeded
GLint LinkStatus;
glGetProgramiv( ProgramID, GL_LINK_STATUS, &LinkStatus );
if( LinkStatus == GL_FALSE )
{
// Linking failed, display why.
FString Log = GetGLSLProgramLog( ProgramID );
checkf(false, TEXT("Failed to link GLSL program: %s"), *Log );
}
CHECK_GL_ERRORS;
}
void ProcessInputFromArchive(FArchive* InputFilePtr, TArray<FJobResult>& OutJobResults)
{
int32 NumBatches = 0;
FArchive& InputFile = *InputFilePtr;
int32 InputVersion;
InputFile << InputVersion;
checkf(ShaderCompileWorkerInputVersion == InputVersion, TEXT("Exiting due to ShaderCompilerWorker expecting input version %d, got %d instead! Did you forget to build ShaderCompilerWorker?"), ShaderCompileWorkerInputVersion, InputVersion);
TMap<FString, uint16> ReceivedFormatVersionMap;
InputFile << ReceivedFormatVersionMap;
VerifyFormatVersions(ReceivedFormatVersionMap);
InputFile << NumBatches;
// Flush cache, to make sure we load the latest version of the input file.
// (Otherwise quick changes to a shader file can result in the wrong output.)
FlushShaderFileCache();
for (int32 BatchIndex = 0; BatchIndex < NumBatches; BatchIndex++)
{
// Deserialize the job's inputs.
FShaderCompilerInput CompilerInput;
InputFile << CompilerInput;
if (IsValidRef(CompilerInput.SharedEnvironment))
{
// Merge the shared environment into the per-shader environment before calling into the compile function
CompilerInput.Environment.Merge(*CompilerInput.SharedEnvironment);
}
// Process the job.
FShaderCompilerOutput CompilerOutput;
ProcessCompilationJob(CompilerInput,CompilerOutput,WorkingDirectory);
// Serialize the job's output.
FJobResult& JobResult = *new(OutJobResults) FJobResult;
JobResult.CompilerOutput = CompilerOutput;
}
}
/** Serializes the global shader map to an archive. */
void SerializeGlobalShaders(FArchive& Ar, TShaderMap<FGlobalShaderType>* GlobalShaderMap)
{
check(IsInGameThread());
// Serialize the global shader map binary file tag.
static const uint32 ReferenceTag = 0x47534D42;
if (Ar.IsLoading())
{
// Initialize Tag to 0 as it won't be written to if the serialize fails (ie the global shader cache file is empty)
uint32 Tag = 0;
Ar << Tag;
checkf(Tag == ReferenceTag, TEXT("Global shader map binary file is missing GSMB tag."));
}
else
{
uint32 Tag = ReferenceTag;
Ar << Tag;
}
// Serialize the global shaders.
GlobalShaderMap->SerializeInline(Ar, true, false);
}
void FLinuxWindow::ReshapeWindow( int32 NewX, int32 NewY, int32 NewWidth, int32 NewHeight )
{
switch( WindowMode )
{
// Fullscreen and WindowedFullscreen both use SDL_WINDOW_FULLSCREEN_DESKTOP now
// and code elsewhere handles the backbufer blit properly. This solves several
// problems that actual mode switches cause, and a GPU scales better than your
// cheap LCD display anyhow.
case EWindowMode::Fullscreen:
case EWindowMode::WindowedFullscreen:
{
SDL_SetWindowFullscreen( HWnd, 0 );
SDL_SetWindowSize( HWnd, NewWidth, NewHeight );
SDL_SetWindowFullscreen( HWnd, SDL_WINDOW_FULLSCREEN_DESKTOP );
bWasFullscreen = true;
} break;
case EWindowMode::Windowed:
{
if (Definition->HasOSWindowBorder)
{
// we are passed coordinates of a client area, so account for decorations
checkf(bValidNativePropertiesCache, TEXT("Attempted to use border sizes too early, native properties aren't yet cached. Review the flow"));
NewX -= LeftBorderWidth;
NewY -= TopBorderHeight;
}
SDL_SetWindowPosition( HWnd, NewX, NewY );
SDL_SetWindowSize( HWnd, NewWidth, NewHeight );
bWasFullscreen = false;
} break;
}
RegionWidth = NewWidth;
RegionHeight = NewHeight;
VirtualWidth = NewWidth;
VirtualHeight = NewHeight;
}
UPackage* FHierarchicalLODUtilities::CreateOrRetrieveLevelHLODPackage(ULevel* InLevel)
{
checkf(InLevel != nullptr, TEXT("Invalid Level supplied"));
UPackage* HLODPackage = nullptr;
UPackage* LevelOuterMost = InLevel->GetOutermost();
const FString PathName = FPackageName::GetLongPackagePath(LevelOuterMost->GetPathName());
const FString BaseName = FPackageName::GetShortName(LevelOuterMost->GetPathName());
const FString HLODLevelPackageName = FString::Printf(TEXT("%s/HLOD/%s_HLOD"), *PathName, *BaseName);
HLODPackage = CreatePackage(NULL, *HLODLevelPackageName);
HLODPackage->FullyLoad();
HLODPackage->Modify();
// Target level filename
const FString HLODLevelFileName = FPackageName::LongPackageNameToFilename(HLODLevelPackageName);
// This is a hack to avoid save file dialog when we will be saving HLOD map package
HLODPackage->FileName = FName(*HLODLevelFileName);
return HLODPackage;
}
void FMovieSceneColorTrackInstance::SaveState(const TArray<TWeakObjectPtr<UObject>>& RuntimeObjects, IMovieScenePlayer& Player, FMovieSceneSequenceInstance& SequenceInstance)
{
for (auto ObjectPtr : RuntimeObjects)
{
UObject* Object = ObjectPtr.Get();
if( ColorType == EColorType::Slate )
{
if (InitSlateColorMap.Find(Object) == nullptr)
{
FSlateColor ColorValue = PropertyBindings->GetCurrentValue<FSlateColor>(Object);
InitSlateColorMap.Add(Object, ColorValue);
}
}
else if( ColorType == EColorType::Linear )
{
if (InitLinearColorMap.Find(Object) == nullptr)
{
UProperty* Property = PropertyBindings->GetProperty(Object);
FLinearColor ColorValue = PropertyBindings->GetCurrentValue<FLinearColor>(Object);
InitLinearColorMap.Add(Object, ColorValue);
}
}
else if( ColorType == EColorType::Color )
{
if (InitLinearColorMap.Find(Object) == nullptr)
{
UProperty* Property = PropertyBindings->GetProperty(Object);
FColor ColorValue = PropertyBindings->GetCurrentValue<FColor>(Object);
FLinearColor LinearColorValue = ColorValue;
InitLinearColorMap.Add(Object, ColorValue);
}
}
else
{
checkf(0, TEXT("Invalid Color Type"));
}
}
}
/**
* Retrieves AnimNotifies given a StartTime and a DeltaTime.
* Time will be advanced and support looping if bAllowLooping is true.
* Supports playing backwards (DeltaTime<0).
* Returns notifies between StartTime (exclusive) and StartTime+DeltaTime (inclusive)
*/
void UAnimSequenceBase::GetAnimNotifies(const float& StartTime, const float& DeltaTime, const bool bAllowLooping, TArray<const FAnimNotifyEvent *> & OutActiveNotifies) const
{
// Early out if we have no notifies
if( (Notifies.Num() == 0) || (DeltaTime == 0.f) )
{
return;
}
bool const bPlayingBackwards = (DeltaTime < 0.f);
float PreviousPosition = StartTime;
float CurrentPosition = StartTime;
float DesiredDeltaMove = DeltaTime;
do
{
// Disable looping here. Advance to desired position, or beginning / end of animation
const ETypeAdvanceAnim AdvanceType = FAnimationRuntime::AdvanceTime(false, DesiredDeltaMove, CurrentPosition, SequenceLength);
// Verify position assumptions
checkf(bPlayingBackwards ? (CurrentPosition <= PreviousPosition) : (CurrentPosition >= PreviousPosition), TEXT("in Animsequence %s"), *GetName());
GetAnimNotifiesFromDeltaPositions(PreviousPosition, CurrentPosition, OutActiveNotifies);
// If we've hit the end of the animation, and we're allowed to loop, keep going.
if( (AdvanceType == ETAA_Finished) && bAllowLooping )
{
const float ActualDeltaMove = (CurrentPosition - PreviousPosition);
DesiredDeltaMove -= ActualDeltaMove;
PreviousPosition = bPlayingBackwards ? SequenceLength : 0.f;
CurrentPosition = PreviousPosition;
}
else
{
break;
}
}
while( true );
}
void FPoseLinkBase::Initialize(const FAnimationInitializeContext& Context)
{
#if DO_CHECK
checkf(!bProcessed, TEXT("Initialize already in progress, circular link for AnimInstance [%s] Blueprint [%s]"), \
*Context.AnimInstanceProxy->GetAnimInstanceName(), *GetFullNameSafe(IAnimClassInterface::GetActualAnimClass(Context.AnimInstanceProxy->GetAnimClassInterface())));
TGuardValue<bool> CircularGuard(bProcessed, true);
#endif
AttemptRelink(Context);
#if ENABLE_ANIMGRAPH_TRAVERSAL_DEBUG
InitializationCounter.SynchronizeWith(Context.AnimInstanceProxy->GetInitializationCounter());
// Initialization will require update to be called before an evaluate.
UpdateCounter.Reset();
#endif
// Do standard initialization
if (LinkedNode != NULL)
{
LinkedNode->Initialize(Context);
}
}
void setup_sht() {
int nmaps = sht_nmaps;
FILE *fd;
printf(" Initializing (incl. FFTW plans)\n");
/* Import FFTW plan if it exists */
fd = fopen("fftw.wisdom", "r");
if (fd != NULL) {
fftw_import_wisdom_from_file(fd);
fclose(fd);
}
sht_plan = wavemoth_plan_to_healpix(Nside, lmax, lmax, nmaps, N_threads, sht_input,
sht_output, WAVEMOTH_MMAJOR, sht_flags,
sht_resourcefile);
checkf(sht_plan, "plan not created, nthreads=%d", N_threads);
/* Export FFTW wisdom generated during planning */
fd = fopen("fftw.wisdom", "w");
if (fd != NULL) {
fftw_export_wisdom_to_file(fd);
fclose(fd);
}
}
const bool FHierarchicalLODUtilities::RemoveActorFromCluster(AActor* InActor)
{
checkf(InActor != nullptr, TEXT("Invalid InActor"));
bool bSucces = false;
ALODActor* ParentActor = FHierarchicalLODUtilities::GetParentLODActor(InActor);
if (ParentActor != nullptr)
{
const FScopedTransaction Transaction(LOCTEXT("UndoAction_RemoveActorFromCluster", "Remove Actor From Cluster"));
ParentActor->Modify();
InActor->Modify();
bSucces = ParentActor->RemoveSubActor(InActor);
if (!ParentActor->HasValidSubActors())
{
DestroyCluster(ParentActor);
}
}
return bSucces;
}
FText FText::Format(const FText& Pattern, const FFormatOrderedArguments& Arguments)
{
checkf(FInternationalization::Get().IsInitialized() == true, TEXT("FInternationalization is not initialized. An FText formatting method was likely used in static object initialization - this is not supported."));
//SCOPE_CYCLE_COUNTER( STAT_TextFormat );
struct FArgumentGetter
{
const FFormatOrderedArguments& Arguments;
FArgumentGetter(const FFormatOrderedArguments& InArguments) : Arguments(InArguments) {}
const FFormatArgumentValue* GetArgumentValue( const FString ArgumentName )
{
int32 ArgumentIndex = INDEX_NONE;
if( ArgumentName.IsNumeric() )
{
ArgumentIndex = FCString::Atoi(*ArgumentName);
}
return ArgumentIndex != INDEX_NONE && ArgumentIndex < Arguments.Num() ? &(Arguments[ArgumentIndex]) : NULL;
}
};
FArgumentGetter ArgumentGetter(Arguments);
return FLegacyTextHelper::Format(Pattern, FGetArgumentValue::CreateRaw(&ArgumentGetter, &FArgumentGetter::GetArgumentValue));
}
int FVorbisAudioInfo::Seek( uint32 offset, int whence )
{
switch( whence )
{
case SEEK_SET:
BufferOffset = offset;
break;
case SEEK_CUR:
BufferOffset += offset;
break;
case SEEK_END:
BufferOffset = SrcBufferDataSize - offset;
break;
default:
checkf(false, TEXT("Uknown seek type"));
break;
}
return( BufferOffset );
}
FShaderType::FShaderType(
const TCHAR* InName,
const TCHAR* InSourceFilename,
const TCHAR* InFunctionName,
uint32 InFrequency,
ConstructSerializedType InConstructSerializedRef,
GetStreamOutElementsType InGetStreamOutElementsRef
):
Name(InName),
TypeName(InName),
SourceFilename(InSourceFilename),
FunctionName(InFunctionName),
Frequency(InFrequency),
ConstructSerializedRef(InConstructSerializedRef),
GetStreamOutElementsRef(InGetStreamOutElementsRef),
GlobalListLink(this)
{
for (int32 Platform = 0; Platform < SP_NumPlatforms; Platform++)
{
bCachedUniformBufferStructDeclarations[Platform] = false;
}
// This will trigger if an IMPLEMENT_SHADER_TYPE was in a module not loaded before InitializeShaderTypes
// Shader types need to be implemented in modules that are loaded before that
checkf(!bInitializedSerializationHistory, TEXT("Shader type was loaded after engine init, use ELoadingPhase::PostConfigInit on your module to cause it to load earlier."));
//make sure the name is shorter than the maximum serializable length
check(FCString::Strlen(InName) < NAME_SIZE);
// register this shader type
GlobalListLink.LinkHead(GetTypeList());
GetNameToTypeMap().Add(TypeName, this);
// Assign the shader type the next unassigned hash index.
static uint32 NextHashIndex = 0;
HashIndex = NextHashIndex++;
}
void FPhysXVehicleManager::RemoveVehicle( TWeakObjectPtr<UWheeledVehicleMovementComponent> Vehicle )
{
check(Vehicle != NULL);
check(Vehicle->PVehicle);
PxVehicleWheels* PVehicle = Vehicle->PVehicle;
int32 RemovedIndex = Vehicles.Find(Vehicle);
Vehicles.Remove( Vehicle );
PVehicles.Remove( PVehicle );
delete[] PVehiclesWheelsStates[RemovedIndex].wheelQueryResults;
PVehiclesWheelsStates.RemoveAt(RemovedIndex); // LOC_MOD double check this
//PVehiclesWheelsStates.Remove(PVehiclesWheelsStates[RemovedIndex]);
if ( PVehicle == TelemetryVehicle )
{
TelemetryVehicle = NULL;
}
switch( PVehicle->getVehicleType() )
{
case PxVehicleTypes::eDRIVE4W:
((PxVehicleDrive4W*)PVehicle)->free();
break;
case PxVehicleTypes::eDRIVETANK:
((PxVehicleDriveTank*)PVehicle)->free();
break;
case PxVehicleTypes::eNODRIVE:
((PxVehicleNoDrive*)PVehicle)->free();
break;
default:
checkf( 0, TEXT("Unsupported vehicle type"));
break;
}
}
FSlateMaterialShaderPS* FSlateRHIRenderingPolicy::GetMaterialPixelShader( const FMaterial* Material, ESlateShader::Type ShaderType, ESlateDrawEffect::Type DrawEffects )
{
const FMaterialShaderMap* MaterialShaderMap = Material->GetRenderingThreadShaderMap();
const bool bDrawDisabled = (DrawEffects & ESlateDrawEffect::DisabledEffect) != 0;
const bool bUseTextureAlpha = (DrawEffects & ESlateDrawEffect::IgnoreTextureAlpha) == 0;
FShader* FoundShader = nullptr;
switch (ShaderType)
{
case ESlateShader::Default:
if (bDrawDisabled)
{
FoundShader = MaterialShaderMap->GetShader(&TSlateMaterialShaderPS<0, true>::StaticType);
}
else
{
FoundShader = MaterialShaderMap->GetShader(&TSlateMaterialShaderPS<0, false>::StaticType);
}
break;
case ESlateShader::Border:
if (bDrawDisabled)
{
FoundShader = MaterialShaderMap->GetShader(&TSlateMaterialShaderPS<1, true>::StaticType);
}
else
{
FoundShader = MaterialShaderMap->GetShader(&TSlateMaterialShaderPS<1, false>::StaticType);
}
break;
default:
checkf(false, TEXT("Unsupported Slate shader type for use with materials"));
break;
}
return FoundShader ? (FSlateMaterialShaderPS*)FoundShader->GetShaderChecked() : nullptr;
}
void UActorComponent::OnRegister()
{
checkf(!HasAnyFlags(RF_Unreachable), TEXT("%s"), *GetDetailedInfo());
checkf(!GetOuter()->IsTemplate(), TEXT("'%s' (%s)"), *GetOuter()->GetFullName(), *GetDetailedInfo());
checkf(!IsTemplate(), TEXT("'%s' (%s)"), *GetOuter()->GetFullName(), *GetDetailedInfo() );
checkf(World, TEXT("OnRegister: %s to %s"), *GetDetailedInfo(), GetOwner() ? *GetOwner()->GetFullName() : TEXT("*** No Owner ***") );
checkf(!bRegistered, TEXT("OnRegister: %s to %s"), *GetDetailedInfo(), GetOwner() ? *GetOwner()->GetFullName() : TEXT("*** No Owner ***") );
checkf(!IsPendingKill(), TEXT("OnRegister: %s to %s"), *GetDetailedInfo(), GetOwner() ? *GetOwner()->GetFullName() : TEXT("*** No Owner ***") );
bRegistered = true;
UpdateComponentToWorld();
if (bAutoActivate)
{
Activate(true);
}
}
/**
* Set up this buffer to contain and play XWMA data
*/
void FXAudio2SoundBuffer::InitXWMA( USoundWave* Wave, FXMAInfo* XMAInfo )
{
#if XAUDIO_SUPPORTS_XMA2WAVEFORMATEX
SoundFormat = SoundFormat_XWMA;
FMemory::Memcpy( &XWMA.XWMAFormat, XMAInfo->EncodedBufferFormat, XMAInfo->EncodedBufferFormatSize );
NumChannels = XWMA.XWMAFormat.Format.nChannels;
// Allocate the audio data in physical memory
XWMA.XWMADataSize = XMAInfo->EncodedBufferSize;
// Allocate via normal allocator.
XWMA.XWMAData = ( uint8* )FMemory::Malloc( XWMA.XWMADataSize );
FMemory::Memcpy( ( void* )XWMA.XWMAData, XMAInfo->EncodedBuffer, XMAInfo->EncodedBufferSize );
XWMA.XWMASeekDataSize = XMAInfo->SeekTableSize;
XWMA.XWMASeekData = ( UINT32* )FMemory::Malloc( XWMA.XWMASeekDataSize );
FMemory::Memcpy( ( void* )XWMA.XWMASeekData, XMAInfo->SeekTable, XMAInfo->SeekTableSize );
#else //XAUDIO_SUPPORTS_XMA2WAVEFORMATEX
checkf(0, TEXT("XMA2WAVEFORMATEX not supported!"));
#endif //XAUDIO_SUPPORTS_XMA2WAVEFORMATEX
}
FText FText::AsMemory(SIZE_T NumBytes, const FNumberFormattingOptions* const Options, const TSharedPtr<FCulture>& TargetCulture)
{
checkf(FInternationalization::IsInitialized() == true, TEXT("FInternationalization is not initialized. An FText formatting method was likely used in static object initialization - this is not supported."));
FFormatNamedArguments Args;
if (NumBytes < 1024)
{
Args.Add( TEXT("Number"), FText::AsNumber( (uint64)NumBytes, Options, TargetCulture) );
Args.Add( TEXT("Unit"), FText::FromString( FString( TEXT("B") ) ) );
return FText::Format( NSLOCTEXT("Internationalization", "ComputerMemoryFormatting", "{Number} {Unit}"), Args );
}
static const TCHAR* Prefixes = TEXT("kMGTPEZY");
int32 Prefix = 0;
for (; NumBytes > 1024 * 1024; NumBytes >>= 10)
{
++Prefix;
}
Args.Add( TEXT("Number"), FText::AsNumber( (uint64)(NumBytes / 1024) , Options, TargetCulture) );
Args.Add( TEXT("Unit"), FText::FromString( FString( 1, &Prefixes[Prefix] ) + TEXT("B") ) );
return FText::Format( NSLOCTEXT("Internationalization", "ComputerMemoryFormatting", "{Number} {Unit}"), Args);
}
void UActorComponent::UnregisterComponent()
{
// Do nothing if not registered
if(!IsRegistered())
{
UE_LOG(LogActorComponent, Log, TEXT("UnregisterComponent: (%s) Not registered. Aborting."), *GetPathName());
return;
}
// If registered, should have a world
checkf(World != NULL, TEXT("%s"), *GetFullName());
// Notify the texture streaming system
const UPrimitiveComponent* Primitive = Cast<const UPrimitiveComponent>(this);
if ( Primitive )
{
IStreamingManager::Get().NotifyPrimitiveDetached( Primitive );
}
RegisterAllComponentTickFunctions(false);
ExecuteUnregisterEvents();
World = NULL;
}
void FMovieSceneColorTrackInstance::RestoreState(const TArray<TWeakObjectPtr<UObject>>& RuntimeObjects, IMovieScenePlayer& Player, FMovieSceneSequenceInstance& SequenceInstance)
{
for (auto ObjectPtr : RuntimeObjects )
{
UObject* Object = ObjectPtr.Get();
if (!IsValid(Object))
{
continue;
}
if( ColorType == EColorType::Slate )
{
FSlateColor* ColorValue = InitSlateColorMap.Find(Object);
if (ColorValue != nullptr)
{
PropertyBindings->CallFunction<FSlateColor>(Object, ColorValue);
}
}
else if( ColorType == EColorType::Linear || ColorType == EColorType::Color )
{
//todo
FLinearColor* ColorValue = InitLinearColorMap.Find(Object);
if (ColorValue != nullptr)
{
PropertyBindings->CallFunction<FLinearColor>(Object, ColorValue);
}
}
else
{
checkf(0, TEXT("Invalid Color Type"));
}
}
PropertyBindings->UpdateBindings( RuntimeObjects );
}
void FActorReferenceKeyArea::EvaluateAndAddKey(float Time, float TimeToCopyFrom, FKeyHandle& CurrentKey)
{
UMovieSceneActorReferenceSection* ActorReferenceSection = Cast<UMovieSceneActorReferenceSection>(OwningSection);
checkf(ActorReferenceSection, TEXT("Incompatible section in FActorReferenceKeyArea"));
// Add the keys to the section here instead of the curve because the actor reference section doesn't
// store the guids directly in the curve.
// TODO: Fix up this code once there is an FGuid curve.
if (ActorReferenceSection != nullptr)
{
FGuid Value;
if (ExternalValue.IsSet() && ExternalValue.Get().IsSet() && TimeToCopyFrom == FLT_MAX)
{
Value = ExternalValue.Get().GetValue();
}
else
{
float EvalTime = TimeToCopyFrom != FLT_MAX ? Time : TimeToCopyFrom;
Value = ActorReferenceSection->Eval(EvalTime);
}
ActorReferenceSection->AddKey(Time, Value);
}
}
FText FText::Format(const FText& Pattern, const TArray< FFormatArgumentData > InArguments)
{
checkf(FInternationalization::Get().IsInitialized() == true, TEXT("FInternationalization is not initialized. An FText formatting method was likely used in static object initialization - this is not supported."));
//SCOPE_CYCLE_COUNTER( STAT_TextFormat );
struct FArgumentGetter
{
const FFormatNamedArguments& Arguments;
FArgumentGetter(const FFormatNamedArguments& InArguments) : Arguments(InArguments) {}
const FFormatArgumentValue* GetArgumentValue( const FString ArgumentName )
{
return Arguments.Find(ArgumentName);
}
};
FFormatNamedArguments FormatNamedArguments;
for(auto It = InArguments.CreateConstIterator(); It; ++It)
{
FormatNamedArguments.Add(It->ArgumentName.ToString(), FFormatArgumentValue(It->ArgumentValue));
}
FArgumentGetter ArgumentGetter(FormatNamedArguments);
return FLegacyTextHelper::Format(Pattern, FGetArgumentValue::CreateRaw(&ArgumentGetter, &FArgumentGetter::GetArgumentValue));
}
ALODActor* FHierarchicalLODUtilities::CreateNewClusterFromActors(UWorld* InWorld, AWorldSettings* WorldSettings, const TArray<AActor*>& InActors, const int32 InLODLevel /*= 0*/)
{
checkf(InWorld != nullptr, TEXT("Invalid world"));
checkf(InActors.Num() > 0, TEXT("Zero number of sub actors"));
checkf(WorldSettings != nullptr, TEXT("Invalid world settings"));
checkf(WorldSettings->bEnableHierarchicalLODSystem, TEXT("Hierarchical LOD system is disabled"));
const FScopedTransaction Transaction(LOCTEXT("UndoAction_CreateNewCluster", "Create new Cluster"));
InWorld->Modify();
// Create the cluster
ALODActor* NewCluster = FHierarchicalLODUtilities::CreateNewClusterActor(InWorld, InLODLevel, WorldSettings);
checkf(NewCluster != nullptr, TEXT("Failed to create a new cluster"));
// Add InActors to new cluster
for (AActor* Actor : InActors)
{
checkf(Actor != nullptr, TEXT("Invalid actor in InActors"));
// Check if Actor is currently part of a different cluster
ALODActor* ParentActor = FHierarchicalLODUtilities::GetParentLODActor(Actor);
if (ParentActor != nullptr)
{
// If so remove it first
ParentActor->Modify();
ParentActor->RemoveSubActor(Actor);
// If the parent cluster is now empty (invalid) destroy it
if (!ParentActor->HasValidSubActors())
{
FHierarchicalLODUtilities::DestroyCluster(ParentActor);
}
}
// Add actor to new cluster
NewCluster->AddSubActor(Actor);
}
// Update sub actor LOD parents to populate
NewCluster->UpdateSubActorLODParents();
return NewCluster;
}
void FEditorModeTools::SetToolkitHost(TSharedRef<class IToolkitHost> InHost)
{
checkf(!ToolkitHost.IsValid(), TEXT("SetToolkitHost can only be called once"));
ToolkitHost = InHost;
}
/** Called in the idle loop, checks for conditions under which the helper should exit */
void CheckExitConditions()
{
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 FilePath = FString(WorkingDirectory) + InputFilename;
checkf(IFileManager::Get().FileSize(*FilePath) == 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 FilePath = 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)
{
checkf(IFileManager::Get().FileSize(*FilePath) == 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)
{
checkf(IFileManager::Get().FileSize(*FilePath) == 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
}
static bool IsInvalidFaceIndex(PxU32 faceIndex)
{
checkf(InvalidQueryHit.faceIndex == 0xFFFFffff, TEXT("Engine code needs fixing: PhysX invalid face index sentinel has changed or is not part of default PxQueryHit!"));
return (faceIndex == InvalidQueryHit.faceIndex);
}
int
main(int argc, char **argv)
{
FILE * volatile f;
char *s;
volatile int left;
volatile off_t initline;
volatile int prnames = 0;
volatile int initopt = 0;
volatile int srchopt = 0;
int clearit = 0;
int ch;
char initbuf[80];
if (pledge("stdio rpath tty", NULL) == -1) {
perror("pledge");
exit(1);
}
setlocale(LC_ALL, "");
/* all signals just use a stub handler and interrupt syscalls */
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sa.sa_handler = onsignal;
nfiles = argc;
fnames = argv;
initterm();
nscroll = Lpp/2 - 1;
if (nscroll <= 0)
nscroll = 1;
if ((s = getenv("MORE")) != NULL && *s != '\0')
argscan(s);
while (--nfiles > 0) {
if ((ch = (*++fnames)[0]) == '-')
argscan(*fnames + 1);
else if (ch == '+') {
s = *fnames;
if (*++s == '/') {
srchopt++;
(void)strlcpy(initbuf, ++s, sizeof(initbuf));
} else {
initopt++;
for (initline = 0; *s != '\0'; s++) {
if (isdigit((unsigned char)*s))
initline =
initline * 10 + *s - '0';
}
--initline;
}
} else
break;
}
/*
* Allow clreol only if Home and eraseln and EodClr strings are
* defined, and in that case, make sure we are in noscroll mode.
*/
if (clreol) {
if (Home == NULL || *Home == '\0' || eraseln == NULL ||
*eraseln == '\0' || EodClr == NULL || *EodClr == '\0')
clreol = 0;
else
noscroll = 1;
}
if (dlines == 0)
dlines = Lpp - 1;
left = dlines;
if (nfiles > 1)
prnames++;
if (!no_intty && nfiles == 0)
usage();
else
f = stdin;
if (!no_tty) {
struct sigaction osa;
(void)sigaction(SIGQUIT, &sa, NULL);
(void)sigaction(SIGINT, &sa, NULL);
(void)sigaction(SIGWINCH, &sa, NULL);
if (sigaction(SIGTSTP, &osa, NULL) == 0 &&
osa.sa_handler == SIG_DFL) {
(void)sigaction(SIGTSTP, &sa, NULL);
(void)sigaction(SIGTTIN, &sa, NULL);
(void)sigaction(SIGTTOU, &sa, NULL);
catch_susp++;
}
set_tty();
}
if (no_intty) {
if (no_tty)
copy_file(stdin);
else {
if ((ch = Getc(f)) == '\f')
doclear();
else {
Ungetc(ch, f);
if (noscroll && ch != EOF) {
if (clreol)
home();
else
doclear();
}
}
if (srchopt) {
if (search(initbuf, stdin, 1) == 0 && noscroll)
left--;
} else if (initopt)
skiplns(initline, stdin);
screen(stdin, left);
}
no_intty = 0;
dup2(STDERR_FILENO, STDIN_FILENO); /* stderr is a tty */
prnames++;
firstf = 0;
}
while (fnum < nfiles) {
if ((f = checkf(fnames[fnum], &clearit)) != NULL) {
context.line = context.chrctr = 0;
Currline = 0;
restart:
if (firstf) {
firstf = 0;
if (srchopt) {
if (search(initbuf, f, 1) < 0)
goto restart;
if (noscroll)
left--;
} else if (initopt)
skiplns(initline, f);
} else if (fnum < nfiles && !no_tty)
left = command(fnames[fnum], f);
if (left != 0) {
if ((noscroll || clearit) &&
(file_size != LONG_MAX)) {
if (clreol)
home();
else
doclear();
}
if (prnames) {
if (bad_so)
erasep(0);
if (clreol)
cleareol();
fputs("::::::::::::::", stdout);
if (promptlen > 14)
erasep(14);
putchar('\n');
if (clreol)
cleareol();
printf("%s\n", fnames[fnum]);
if (clreol)
cleareol();
fputs("::::::::::::::\n", stdout);
if (left > Lpp - 4)
left = Lpp - 4;
}
if (no_tty)
copy_file(f);
else {
within++;
screen(f, left);
within = 0;
}
}
fflush(stdout);
fclose(f);
screen_start.line = screen_start.chrctr = 0L;
context.line = context.chrctr = 0L;
}
fnum++;
firstf = 0;
}
reset_tty();
exit(0);
}
ULocalPlayer* UGameInstance::CreateLocalPlayer(int32 ControllerId, FString& OutError, bool bSpawnActor)
{
checkf(GetEngine()->LocalPlayerClass != NULL);
ULocalPlayer* NewPlayer = NULL;
int32 InsertIndex = INDEX_NONE;
const int32 MaxSplitscreenPlayers = (GetGameViewportClient() != NULL) ? GetGameViewportClient()->MaxSplitscreenPlayers : 1;
if (FindLocalPlayerFromControllerId( ControllerId ) != NULL)
{
OutError = FString::Printf(TEXT("A local player already exists for controller ID %d,"), ControllerId);
}
else if (LocalPlayers.Num() < MaxSplitscreenPlayers)
{
// If the controller ID is not specified then find the first available
if (ControllerId < 0)
{
for (ControllerId = 0; ControllerId < MaxSplitscreenPlayers; ++ControllerId)
{
if (FindLocalPlayerFromControllerId( ControllerId ) == NULL)
{
break;
}
}
check(ControllerId < MaxSplitscreenPlayers);
}
else if (ControllerId >= MaxSplitscreenPlayers)
{
UE_LOG(LogPlayerManagement, Warning, TEXT("Controller ID (%d) is unlikely to map to any physical device, so this player will not receive input"), ControllerId);
}
NewPlayer = NewObject<ULocalPlayer>(GetEngine(), GetEngine()->LocalPlayerClass);
InsertIndex = AddLocalPlayer(NewPlayer, ControllerId);
if (bSpawnActor && InsertIndex != INDEX_NONE && GetWorld() != NULL)
{
if (GetWorld()->GetNetMode() != NM_Client)
{
// server; spawn a new PlayerController immediately
if (!NewPlayer->SpawnPlayActor("", OutError, GetWorld()))
{
RemoveLocalPlayer(NewPlayer);
NewPlayer = NULL;
}
}
else
{
// client; ask the server to let the new player join
NewPlayer->SendSplitJoin();
}
}
}
else
{
OutError = FString::Printf(TEXT( "Maximum number of players (%d) already created. Unable to create more."), MaxSplitscreenPlayers);
}
if (OutError != TEXT(""))
{
UE_LOG(LogPlayerManagement, Log, TEXT("UPlayer* creation failed with error: %s"), *OutError);
}
return NewPlayer;
}
FText FText::AsDateTime( const FDateTime& DateTime, const EDateTimeStyle::Type DateStyle, const EDateTimeStyle::Type TimeStyle, const FString& TimeZone, const FCulturePtr& TargetCulture )
{
checkf(FInternationalization::Get().IsInitialized() == true, TEXT("FInternationalization is not initialized. An FText formatting method was likely used in static object initialization - this is not supported."));
return FText::FromString(DateTime.ToString(TEXT("%Y.%m.%d-%H.%M.%S")));
}