void FSlateRHIResourceManager::CreateTextures( const TArray< const FSlateBrush* >& Resources ) { DECLARE_SCOPE_CYCLE_COUNTER(TEXT("Loading Slate Textures"), STAT_Slate, STATGROUP_LoadTime); TMap<FName,FNewTextureInfo> TextureInfoMap; const uint32 Stride = GPixelFormats[PF_R8G8B8A8].BlockBytes; for( int32 ResourceIndex = 0; ResourceIndex < Resources.Num(); ++ResourceIndex ) { const FSlateBrush& Brush = *Resources[ResourceIndex]; const FName TextureName = Brush.GetResourceName(); if( TextureName != NAME_None && !Brush.HasUObject() && !Brush.IsDynamicallyLoaded() && !ResourceMap.Contains(TextureName) ) { // Find the texture or add it if it doesnt exist (only load the texture once) FNewTextureInfo& Info = TextureInfoMap.FindOrAdd( TextureName ); Info.bSrgb = (Brush.ImageType != ESlateBrushImageType::Linear); // Only atlas the texture if none of the brushes that use it tile it and the image is srgb Info.bShouldAtlas &= ( Brush.Tiling == ESlateBrushTileType::NoTile && Info.bSrgb && AtlasSize > 0 ); // Texture has been loaded if the texture data is valid if( !Info.TextureData.IsValid() ) { uint32 Width = 0; uint32 Height = 0; TArray<uint8> RawData; bool bSucceeded = LoadTexture( Brush, Width, Height, RawData ); Info.TextureData = MakeShareable( new FSlateTextureData( Width, Height, Stride, RawData ) ); const bool bTooLargeForAtlas = (Width >= 256 || Height >= 256 || Width >= AtlasSize || Height >= AtlasSize ); Info.bShouldAtlas &= !bTooLargeForAtlas; if( !bSucceeded || !ensureMsgf( Info.TextureData->GetRawBytes().Num() > 0, TEXT("Slate resource: (%s) contains no data"), *TextureName.ToString() ) ) { TextureInfoMap.Remove( TextureName ); } } } } // Sort textures by size. The largest textures are atlased first which creates a more compact atlas TextureInfoMap.ValueSort( FCompareFNewTextureInfoByTextureSize() ); for( TMap<FName,FNewTextureInfo>::TConstIterator It(TextureInfoMap); It; ++It ) { const FNewTextureInfo& Info = It.Value(); FName TextureName = It.Key(); FString NameStr = TextureName.ToString(); checkSlow( TextureName != NAME_None ); FSlateShaderResourceProxy* NewTexture = GenerateTextureResource( Info ); ResourceMap.Add( TextureName, NewTexture ); } }
void UGameplayCueManager::UpdatePreallocation(UWorld* World) { FPreallocationInfo& Info = GetPreallocationInfo(World); if (Info.ClassesNeedingPreallocation.Num() > 0) { AGameplayCueNotify_Actor* CDO = Info.ClassesNeedingPreallocation.Last(); TArray<AGameplayCueNotify_Actor*>& PreallocatedList = Info.PreallocatedInstances.FindOrAdd(CDO->GetClass()); AGameplayCueNotify_Actor* PrespawnedInstance = Cast<AGameplayCueNotify_Actor>(World->SpawnActor(CDO->GetClass())); ensureMsgf(PrespawnedInstance, TEXT("Failed to prespawn GC notify for: %s"), *GetNameSafe(CDO)); ensureMsgf(PrespawnedInstance->IsPendingKill() == false, TEXT("Newly spawned GC is PendingKILL: %s"), *GetNameSafe(CDO)); if (PrespawnedInstance) { if (LogGameplayCueActorSpawning) { ABILITY_LOG(Warning, TEXT("Prespawning GC %s"), *GetNameSafe(CDO)); } PrespawnedInstance->bInRecycleQueue = true; PreallocatedList.Push(PrespawnedInstance); PrespawnedInstance->SetActorHiddenInGame(true); if (PreallocatedList.Num() >= CDO->NumPreallocatedInstances) { Info.ClassesNeedingPreallocation.Pop(false); } } } }
void UEdGraphPin::MakeLinkTo(UEdGraphPin* ToPin) { Modify(); if (ToPin != NULL) { ToPin->Modify(); // Make sure we don't already link to it if (!LinkedTo.Contains(ToPin)) { UEdGraphNode* MyNode = GetOwningNode(); // Check that the other pin does not link to us ensureMsgf(!ToPin->LinkedTo.Contains(this), *GetLinkInfoString( LOCTEXT("MakeLinkTo", "MakeLinkTo").ToString(), LOCTEXT("IsLinked", "is linked with pin").ToString(), ToPin)); ensureMsgf(MyNode->GetOuter() == ToPin->GetOwningNode()->GetOuter(), *GetLinkInfoString( LOCTEXT("MakeLinkTo", "MakeLinkTo").ToString(), LOCTEXT("OuterMismatch", "has a different outer than pin").ToString(), ToPin)); // Ensure both pins belong to the same graph // Add to both lists LinkedTo.Add(ToPin); ToPin->LinkedTo.Add(this); GraphPinHelpers::EnableAllConnectedNodes(MyNode); GraphPinHelpers::EnableAllConnectedNodes(ToPin->GetOwningNode()); } } }
void FComponentSpacePoseLink::EvaluateComponentSpace(FComponentSpacePoseContext& Output) { #if DO_CHECK checkf( !bProcessed, TEXT( "EvaluateComponentSpace already in progress, circular link for AnimInstance [%s] Blueprint [%s]" ), \ *Output.AnimInstanceProxy->GetAnimInstanceName(), *GetFullNameSafe(IAnimClassInterface::GetActualAnimClass(Output.AnimInstanceProxy->GetAnimClassInterface()))); TGuardValue<bool> CircularGuard(bProcessed, true); #endif #if ENABLE_ANIMGRAPH_TRAVERSAL_DEBUG checkf(InitializationCounter.IsSynchronizedWith(Output.AnimInstanceProxy->GetInitializationCounter()), TEXT("Calling EvaluateComponentSpace without initialization!")); checkf(CachedBonesCounter.IsSynchronizedWith(Output.AnimInstanceProxy->GetCachedBonesCounter()), TEXT("Calling EvaluateComponentSpace without CachedBones!")); checkf(UpdateCounter.IsSynchronizedWith(Output.AnimInstanceProxy->GetUpdateCounter()), TEXT("Calling EvaluateComponentSpace without Update for this node!")); EvaluationCounter.SynchronizeWith(Output.AnimInstanceProxy->GetEvaluationCounter()); #endif if (LinkedNode != NULL) { LinkedNode->EvaluateComponentSpace(Output); #if WITH_EDITOR Output.AnimInstanceProxy->RegisterWatchedPose(Output.Pose, LinkID); #endif } else { //@TODO: Warning here? Output.ResetToRefPose(); } // Detect non valid output #if !(UE_BUILD_SHIPPING || UE_BUILD_TEST) if (Output.ContainsNaN()) { // Show bone transform with some useful debug info for (const FTransform& Bone : Output.Pose.GetPose().GetBones()) { if (Bone.ContainsNaN()) { ensureMsgf(!Bone.ContainsNaN(), TEXT("Bone transform contains NaN from AnimInstance:[%s] Node:[%s] Value:[%s]") , *Output.AnimInstanceProxy->GetAnimInstanceName(), LinkedNode ? *LinkedNode->StaticStruct()->GetName() : TEXT("NULL"), *Bone.ToString()); } } } if (!Output.IsNormalized()) { // Show bone transform with some useful debug info for (const FTransform& Bone : Output.Pose.GetPose().GetBones()) { if (!Bone.IsRotationNormalized()) { ensureMsgf(Bone.IsRotationNormalized(), TEXT("Bone Rotation not normalized from AnimInstance:[%s] Node:[%s] Value:[%s]") , *Output.AnimInstanceProxy->GetAnimInstanceName(), LinkedNode ? *LinkedNode->StaticStruct()->GetName() : TEXT("NULL"), *Bone.ToString()); } } } #endif }
void FPrimitiveSceneInfo::GatherLightingAttachmentGroupPrimitives(TArray<FPrimitiveSceneInfo*, SceneRenderingAllocator>& OutChildSceneInfos) { #if ENABLE_NAN_DIAGNOSTIC // local function that returns full name of object auto GetObjectName = [](const UPrimitiveComponent* InPrimitive)->FString { return (InPrimitive) ? InPrimitive->GetFullName() : FString(TEXT("Unknown Object")); }; // verify that the current object has a valid bbox before adding it const float& BoundsRadius = this->Proxy->GetBounds().SphereRadius; if (ensureMsgf(!FMath::IsNaN(BoundsRadius) && FMath::IsFinite(BoundsRadius), TEXT("%s had an ill-formed bbox and was skipped during shadow setup, contact DavidH."), *GetObjectName(this->ComponentForDebuggingOnly))) { OutChildSceneInfos.Add(this); } else { // return, leaving the TArray empty return; } #else // add self at the head of this queue OutChildSceneInfos.Add(this); #endif if (!LightingAttachmentRoot.IsValid() && Proxy->LightAttachmentsAsGroup()) { const FAttachmentGroupSceneInfo* AttachmentGroup = Scene->AttachmentGroups.Find(PrimitiveComponentId); if (AttachmentGroup) { for (int32 ChildIndex = 0, ChildIndexMax = AttachmentGroup->Primitives.Num(); ChildIndex < ChildIndexMax; ChildIndex++) { FPrimitiveSceneInfo* ShadowChild = AttachmentGroup->Primitives[ChildIndex]; #if ENABLE_NAN_DIAGNOSTIC // Only enqueue objects with valid bounds using the normality of the SphereRaduis as criteria. const float& ShadowChildBoundsRadius = ShadowChild->Proxy->GetBounds().SphereRadius; if (ensureMsgf(!FMath::IsNaN(ShadowChildBoundsRadius) && FMath::IsFinite(ShadowChildBoundsRadius), TEXT("%s had an ill-formed bbox and was skipped during shadow setup, contact DavidH."), *GetObjectName(ShadowChild->ComponentForDebuggingOnly))) { checkSlow(!OutChildSceneInfos.Contains(ShadowChild)) OutChildSceneInfos.Add(ShadowChild); } #else // enqueue all objects. checkSlow(!OutChildSceneInfos.Contains(ShadowChild)) OutChildSceneInfos.Add(ShadowChild); #endif } } } }
void UActorComponent::PostInitProperties() { Super::PostInitProperties(); AActor* Owner = GetOwner(); ensureMsgf(Owner == NULL || Owner == GetOuter(), TEXT("Component %s is owned by %s by has an Outer of %s."), *GetName(), *Owner->GetName(), *GetOuter()->GetName()); }
//------------------------------------------------------------------------------ bool UBlueprintBoundEventNodeSpawner::IsBindingCompatible(UObject const* BindingCandidate) const { bool bMatchesNodeType = false; if (NodeClass->IsChildOf<UK2Node_ComponentBoundEvent>()) { UObjectProperty const* BindingProperty = Cast<UObjectProperty>(BindingCandidate); bMatchesNodeType = (BindingProperty != nullptr); } else if (NodeClass->IsChildOf<UK2Node_ActorBoundEvent>()) { bMatchesNodeType = BindingCandidate->IsA<AActor>(); } const UMulticastDelegateProperty* Delegate = GetEventDelegate(); if ( !ensureMsgf(!FBlueprintNodeSpawnerUtils::IsStaleFieldAction(this), TEXT("Invalid BlueprintBoundEventNodeSpawner (for %s). Was the action database properly updated when this class was compiled?"), *Delegate->GetOwnerClass()->GetName())) { return false; } UClass* DelegateOwner = Delegate->GetOwnerClass()->GetAuthoritativeClass(); UClass* BindingClass = FBlueprintNodeSpawnerUtils::GetBindingClass(BindingCandidate)->GetAuthoritativeClass(); return bMatchesNodeType && BindingClass->IsChildOf(DelegateOwner) && !FObjectEditorUtils::IsVariableCategoryHiddenFromClass(Delegate, BindingClass); }
void UAnimSequenceBase::RefreshCacheData() { #if WITH_EDITOR SortNotifies(); for (int32 TrackIndex=0; TrackIndex<AnimNotifyTracks.Num(); ++TrackIndex) { AnimNotifyTracks[TrackIndex].Notifies.Empty(); } for (int32 NotifyIndex = 0; NotifyIndex<Notifies.Num(); ++NotifyIndex) { int32 TrackIndex = Notifies[NotifyIndex].TrackIndex; if (AnimNotifyTracks.IsValidIndex(TrackIndex)) { AnimNotifyTracks[TrackIndex].Notifies.Add(&Notifies[NotifyIndex]); } else { // this notifyindex isn't valid, delete // this should not happen, but if it doesn, find best place to add ensureMsgf(0, TEXT("AnimNotifyTrack: Wrong indices found")); AnimNotifyTracks[0].Notifies.Add(&Notifies[NotifyIndex]); } } // notification broadcast OnNotifyChanged.Broadcast(); #endif //WITH_EDITOR }
FPinConnectionResponse UEdGraphSchema::MovePinLinks(UEdGraphPin& MoveFromPin, UEdGraphPin& MoveToPin, bool bIsIntermediateMove) const { #if WITH_EDITOR ensureMsgf(bIsIntermediateMove || !MoveToPin.GetOwningNode()->GetGraph()->HasAnyFlags(RF_Transient), TEXT("When moving to an Intermediate pin, use FKismetCompilerContext::MovePinLinksToIntermediate() instead of UEdGraphSchema::MovePinLinks()")); #endif // #if WITH_EDITOR FPinConnectionResponse FinalResponse = FPinConnectionResponse(CONNECT_RESPONSE_MAKE, TEXT("")); // First copy the current set of links TArray<UEdGraphPin*> CurrentLinks = MoveFromPin.LinkedTo; // Then break all links at pin we are moving from MoveFromPin.BreakAllPinLinks(); // Try and make each new connection for (int32 i=0; i<CurrentLinks.Num(); i++) { UEdGraphPin* NewLink = CurrentLinks[i]; FPinConnectionResponse Response = CanCreateConnection(&MoveToPin, NewLink); if(Response.CanSafeConnect()) { MoveToPin.MakeLinkTo(NewLink); } else { FinalResponse = Response; } } // Move over the default values MoveToPin.DefaultValue = MoveFromPin.DefaultValue; MoveToPin.DefaultObject = MoveFromPin.DefaultObject; MoveToPin.DefaultTextValue = MoveFromPin.DefaultTextValue; return FinalResponse; }
bool UObjectBaseUtility::IsA( const UClass* SomeBase ) const { UE_CLOG(!SomeBase, LogObj, Fatal, TEXT("IsA(NULL) cannot yield meaningful results")); #if UCLASS_FAST_ISA_IMPL & 1 bool bOldResult = false; for ( UClass* TempClass=GetClass(); TempClass; TempClass=TempClass->GetSuperClass() ) { if ( TempClass == SomeBase ) { bOldResult = true; break; } } #endif #if UCLASS_FAST_ISA_IMPL & 2 bool bNewResult = GetClass()->IsAUsingFastTree(*SomeBase); #endif #if (UCLASS_FAST_ISA_IMPL & 1) && (UCLASS_FAST_ISA_IMPL & 2) ensureMsgf(bOldResult == bNewResult, TEXT("New cast code failed")); #endif #if UCLASS_FAST_ISA_IMPL & 1 return bOldResult; #else return bNewResult; #endif }
const TCHAR* ELoadingPhase::ToString( const ELoadingPhase::Type Value ) { switch( Value ) { case Default: return TEXT( "Default" ); case PostDefault: return TEXT( "PostDefault" ); case PreDefault: return TEXT( "PreDefault" ); case PostConfigInit: return TEXT( "PostConfigInit" ); case PreLoadingScreen: return TEXT( "PreLoadingScreen" ); case PostEngineInit: return TEXT( "PostEngineInit" ); default: ensureMsgf( false, TEXT( "Unrecognized ELoadingPhase value: %i" ), Value ); return NULL; } }
int32 TLinkerImportPlaceholder<UFunction>::ResolvePropertyReferences(UFunction* ReplacementFunc) { int32 ReplacementCount = 0; UFunction* PlaceholderFunc = CastChecked<UFunction>(GetPlaceholderAsUObject()); for (UProperty* Property : ReferencingProperties) { if (UDelegateProperty* DelegateProperty = Cast<UDelegateProperty>(Property)) { if (DelegateProperty->SignatureFunction == PlaceholderFunc) { DelegateProperty->SignatureFunction = ReplacementFunc; ++ReplacementCount; } } else if (UMulticastDelegateProperty* MulticastDelegateProperty = Cast<UMulticastDelegateProperty>(Property)) { if (MulticastDelegateProperty->SignatureFunction == PlaceholderFunc) { MulticastDelegateProperty->SignatureFunction = ReplacementFunc; ++ReplacementCount; } } else { ensureMsgf(false, TEXT("Unhandled property type: %s"), *Property->GetClass()->GetName()); } } ReferencingProperties.Empty(); return ReplacementCount; }
void FBlueprintNativeCodeGenModule::GenerateStubs() { TSet<TAssetPtr<UBlueprint>> AlreadyGenerated; while (AlreadyGenerated.Num() < StubsRequiredByGeneratedCode.Num()) { const int32 OldGeneratedNum = AlreadyGenerated.Num(); for (TAssetPtr<UBlueprint>& BPPtr : StubsRequiredByGeneratedCode) { bool bAlreadyGenerated = false; AlreadyGenerated.Add(BPPtr, &bAlreadyGenerated); if (bAlreadyGenerated) { continue; } ensureMsgf(AllPotentialStubs.Contains(BPPtr), TEXT("A required blueprint doesn't generate stub: %s"), *BPPtr.ToString()); for (auto& PlatformName : TargetPlatformNames) { GenerateSingleStub(BPPtr.LoadSynchronous(), *PlatformName); } } if (!ensure(OldGeneratedNum != AlreadyGenerated.Num())) { break; } } UE_LOG(LogBlueprintCodeGen, Log, TEXT("GenerateStubs - all unconverted bp: %d, generated wrapers: %d"), AllPotentialStubs.Num(), StubsRequiredByGeneratedCode.Num()); }
void FLevelSequenceObjectReferenceMap::CreateBinding(const FGuid& ObjectId, const FLevelSequenceObjectReference& ObjectReference) { if (ensureMsgf(ObjectReference.IsValid(), TEXT("Invalid object reference specifed for binding"))) { Map.FindOrAdd(ObjectId) = ObjectReference; } }
FPinConnectionResponse UEdGraphSchema::CopyPinLinks(UEdGraphPin& CopyFromPin, UEdGraphPin& CopyToPin, bool bIsIntermediateCopy) const { #if WITH_EDITOR ensureMsgf(bIsIntermediateCopy || !CopyToPin.GetOwningNode()->GetGraph()->HasAnyFlags(RF_Transient), TEXT("When copying to an Intermediate pin, use FKismetCompilerContext::CopyPinLinksToIntermediate() instead of UEdGraphSchema::CopyPinLinks()")); #endif // #if WITH_EDITOR FPinConnectionResponse FinalResponse = FPinConnectionResponse(CONNECT_RESPONSE_MAKE, TEXT("")); for (int32 i=0; i<CopyFromPin.LinkedTo.Num(); i++) { UEdGraphPin* NewLink = CopyFromPin.LinkedTo[i]; FPinConnectionResponse Response = CanCreateConnection(&CopyToPin, NewLink); if (Response.CanSafeConnect()) { CopyToPin.MakeLinkTo(NewLink); } else { FinalResponse = Response; } } CopyToPin.DefaultValue = CopyFromPin.DefaultValue; CopyToPin.DefaultObject = CopyFromPin.DefaultObject; CopyToPin.DefaultTextValue = CopyFromPin.DefaultTextValue; return FinalResponse; }
FMovieSceneSequenceInstance::~FMovieSceneSequenceInstance() { for (auto& Pair : SpawnedObjects) { ensureMsgf(!Pair.Value.Get(), TEXT("Sequence instance is being destroyed but still has spawned objects")); } }
const TCHAR* EHostType::ToString( const EHostType::Type Value ) { switch( Value ) { case Runtime: return TEXT( "Runtime" ); case RuntimeNoCommandlet: return TEXT( "RuntimeNoCommandlet" ); case Developer: return TEXT( "Developer" ); case Editor: return TEXT( "Editor" ); case EditorNoCommandlet: return TEXT( "EditorNoCommandlet" ); case Program: return TEXT("Program"); default: ensureMsgf( false, TEXT( "Unrecognized EModuleType value: %i" ), Value ); return NULL; } }
static FVector2D GetMenuOffsetForPlacement(const FGeometry& AllottedGeometry, EMenuPlacement PlacementMode, FVector2D PopupSizeLocalSpace) { switch (PlacementMode) { case MenuPlacement_BelowAnchor: return FVector2D(0.0f, AllottedGeometry.GetLocalSize().Y); break; case MenuPlacement_CenteredBelowAnchor: return FVector2D(-((PopupSizeLocalSpace.X / 2) - (AllottedGeometry.GetLocalSize().X / 2)), AllottedGeometry.GetLocalSize().Y); break; case MenuPlacement_ComboBox: return FVector2D(0.0f, AllottedGeometry.GetLocalSize().Y); break; case MenuPlacement_ComboBoxRight: return FVector2D(AllottedGeometry.GetLocalSize().X - PopupSizeLocalSpace.X, AllottedGeometry.GetLocalSize().Y); break; case MenuPlacement_MenuRight: return FVector2D(AllottedGeometry.GetLocalSize().X, 0.0f); break; case MenuPlacement_AboveAnchor: return FVector2D(0.0f, -PopupSizeLocalSpace.Y); break; case MenuPlacement_CenteredAboveAnchor: return FVector2D(-((PopupSizeLocalSpace.X / 2) - (AllottedGeometry.GetLocalSize().X / 2)), -PopupSizeLocalSpace.Y); break; case MenuPlacement_MenuLeft: return FVector2D(-AllottedGeometry.GetLocalSize().X - PopupSizeLocalSpace.X, 0.0f); break; default: ensureMsgf( false, TEXT("Unhandled placement mode: %d"), PlacementMode ); return FVector2D::ZeroVector; } }
/** * Returns whether a package name is favorited or not * * @param Item Package name of the item to check * * @return true if the provided item is in the favorite's list; false if it is not */ bool FMainMRUFavoritesList::ContainsFavoritesItem( const FString& Item ) { if (ensureMsgf(FPackageName::IsValidLongPackageName(Item), TEXT("Item is not a valid long package name: '%s'"), *Item)) { return FavoriteItems.Contains( Item ); } return false; }
void UActorComponent::RegisterComponentWithWorld(UWorld* InWorld) { checkf(!HasAnyFlags(RF_Unreachable), TEXT("%s"), *GetFullName()); if(IsPendingKill()) { UE_LOG(LogActorComponent, Log, TEXT("RegisterComponentWithWorld: (%s) Trying to register component with IsPendingKill() == true. Aborting."), *GetPathName()); return; } // If the component was already registered, do nothing if(IsRegistered()) { UE_LOG(LogActorComponent, Log, TEXT("RegisterComponentWithWorld: (%s) Already registered. Aborting."), *GetPathName()); return; } if(InWorld == NULL) { //UE_LOG(LogActorComponent, Log, TEXT("RegisterComponentWithWorld: (%s) NULL InWorld specified. Aborting."), *GetPathName()); return; } // If not registered, should not have a scene checkf(World == NULL, TEXT("%s"), *GetFullName()); // Follow outer chain to see if we can find an Actor AActor* Owner = GetOwner(); ensureMsgf(Owner == NULL || Owner == GetOuter(), TEXT("Component %s is owned by %s by has an Outer of %s."), *GetName(), *Owner->GetName(), *GetOuter()->GetName()); if ((Owner != NULL) && Owner->GetClass()->HasAnyClassFlags(CLASS_NewerVersionExists)) { UE_LOG(LogActorComponent, Log, TEXT("RegisterComponentWithWorld: Owner belongs to a DEADCLASS")); return; } #if !(UE_BUILD_SHIPPING || UE_BUILD_TEST) // Can only register with an Actor if we are created within one if(Owner != NULL) { checkf(!Owner->HasAnyFlags(RF_Unreachable), TEXT("%s"), *GetFullName()); // can happen with undo because the owner will be restored "next" //checkf(!Owner->IsPendingKill(), TEXT("%s"), *GetFullName()); if(InWorld != GetOwner()->GetWorld()) { // The only time you should specify a scene that is not GetOwner()->GetWorld() is when you don't have an Actor UE_LOG(LogActorComponent, Log, TEXT("RegisterComponentWithWorld: (%s) Specifying a world, but an Owner Actor found, and InWorld is not GetOwner()->GetWorld()"), *GetPathName()); } } #endif // !(UE_BUILD_SHIPPING || UE_BUILD_TEST) World = InWorld; ExecuteRegisterEvents(); RegisterAllComponentTickFunctions(true); }
void UGame::Init() { ensureMsgf( !bIsInitialized, TEXT("Trying to initialize an already initialized game.") ); bIsInitialized = true; OnInit(); BPF_OnInit(); }
class UEdGraph* UEdGraphNode::GetGraph() const { UEdGraph* Graph = Cast<UEdGraph>(GetOuter()); if (Graph == NULL) { ensureMsgf(false, TEXT("EdGraphNode::GetGraph : '%s' does not have a UEdGraph as an Outer."), *GetPathName()); } return Graph; }
void FLevelSequenceObjectReferenceMap::CreateBinding(const FGuid& ObjectId, UObject* InObject, UObject* InContext) { FLevelSequenceObjectReference NewReference(InObject, InContext); if (ensureMsgf(NewReference.IsValid(), TEXT("Unable to generate a reference for the specified object and context"))) { Map.FindOrAdd(ObjectId) = NewReference; } }
void FD3D11DynamicRHI::CheckIfSRVIsResolved(ID3D11ShaderResourceView* SRV) { #if CHECK_SRV_TRANSITIONS if (GRHIThread || !SRV) { return; } static const auto CheckSRVCVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.CheckSRVTransitions")); if (!CheckSRVCVar->GetValueOnRenderThread()) { return; } ID3D11Resource* SRVResource = nullptr; SRV->GetResource(&SRVResource); int32 MipLevel; int32 NumMips; int32 ArraySlice; int32 NumSlices; GetMipAndSliceInfoFromSRV(SRV, MipLevel, NumMips, ArraySlice, NumSlices); //d3d uses -1 to mean 'all mips' int32 LastMip = MipLevel + NumMips - 1; int32 LastSlice = ArraySlice + NumSlices - 1; TArray<FUnresolvedRTInfo> RTInfoArray; UnresolvedTargets.MultiFind(SRVResource, RTInfoArray); for (int32 InfoIndex = 0; InfoIndex < RTInfoArray.Num(); ++InfoIndex) { const FUnresolvedRTInfo& RTInfo = RTInfoArray[InfoIndex]; int32 RTLastMip = RTInfo.MipLevel + RTInfo.NumMips - 1; ensureMsgf((MipLevel == -1 || NumMips == -1) || (LastMip < RTInfo.MipLevel || MipLevel > RTLastMip), TEXT("SRV is set to read mips in range %i to %i. Target %s is unresolved for mip %i"), MipLevel, LastMip, *RTInfo.ResourceName.ToString(), RTInfo.MipLevel); ensureMsgf(NumMips != -1, TEXT("SRV is set to read all mips. Target %s is unresolved for mip %i"), *RTInfo.ResourceName.ToString(), RTInfo.MipLevel); int32 RTLastSlice = RTInfo.ArraySlice + RTInfo.ArraySize - 1; ensureMsgf((ArraySlice == -1 || LastSlice == -1) || (LastSlice < RTInfo.ArraySlice || ArraySlice > RTLastSlice), TEXT("SRV is set to read slices in range %i to %i. Target %s is unresolved for mip %i"), ArraySlice, LastSlice, *RTInfo.ResourceName.ToString(), RTInfo.ArraySlice); ensureMsgf(ArraySlice == -1 || NumSlices != -1, TEXT("SRV is set to read all slices. Target %s is unresolved for slice %i")); } SRVResource->Release(); #endif }
void USceneManager::SetCurrentScene(UGameScene* pCurrentScene){ ensureMsgf(pCurrentScene, TEXT("oops! SceneManager::SetCurrentScene()")); if (CurrentScene && CurrentScene->IsValidLowLevelFast()){ CurrentScene->OnExit(); } CurrentScene = pCurrentScene; if (!SceneStack.Contains(pCurrentScene)){ SceneStack.Emplace(CurrentScene); } }
/** * Moves the specified favorites item to the head of the list * * @param Item Package name of the item to move */ void FMainMRUFavoritesList::MoveFavoritesItemToHead(const FString& Item) { if (ensureMsgf(FPackageName::IsValidLongPackageName(Item), TEXT("Item is not a valid long package name: '%s'"), *Item)) { if ( FavoriteItems.RemoveSingle(Item) == 1 ) { FavoriteItems.Insert( Item, 0 ); WriteToINI(); } } }
void FCompositionLighting::PrepareAsyncSSAO(FRHICommandListImmediate& RHICmdList, TArray<FViewInfo>& Views) { //clear out last frame's fence. ensureMsgf(AsyncSSAOFence == nullptr, TEXT("Old AsyncCompute SSAO fence has not been cleared.")); static FName AsyncSSAOFenceName(TEXT("AsyncSSAOFence")); AsyncSSAOFence = RHICmdList.CreateComputeFence(AsyncSSAOFenceName); //Grab the async compute commandlist. FRHIAsyncComputeCommandListImmediate& RHICmdListComputeImmediate = FRHICommandListExecutor::GetImmediateAsyncComputeCommandList(); RHICmdListComputeImmediate.SetAsyncComputeBudget(FSSAOHelper::GetAmbientOcclusionAsyncComputeBudget()); }
/** * Add a new item to the favorites list * * @param Item Package name of the item to add to the favorites list */ void FMainMRUFavoritesList::AddFavoritesItem( const FString& Item ) { if (ensureMsgf(FPackageName::IsValidLongPackageName(Item), TEXT("Item is not a valid long package name: '%s'"), *Item)) { // Only add the item if it isn't already a favorite! if ( !FavoriteItems.Contains( Item ) ) { FavoriteItems.Insert( Item, 0 ); WriteToINI(); } } }
void USlateVectorArtData::InitFromStaticMesh(const UStaticMesh& InSourceMesh) { if (SourceMaterial != InSourceMesh.GetMaterial(0)) { SourceMaterial = InSourceMesh.GetMaterial(0); Material = SourceMaterial; } ensureMsgf(Material != nullptr, TEXT("USlateVectorArtData::InitFromStaticMesh() expected %s to have a material assigned."), *InSourceMesh.GetFullName()); StaticMeshToSlateRenderData(InSourceMesh, VertexData, IndexData, ExtentMin, ExtentMax); }
/** * Remove an item from the favorites list * * @param Item Package name of the item to remove from the favorites list */ void FMainMRUFavoritesList::RemoveFavoritesItem( const FString& Item ) { if (ensureMsgf(FPackageName::IsValidLongPackageName(Item), TEXT("Item is not a valid long package name: '%s'"), *Item)) { const int32 ItemIndex = FavoriteItems.Find( Item ); if ( ItemIndex != INDEX_NONE ) { FavoriteItems.RemoveAt( ItemIndex ); WriteToINI(); } } }