Example #1
0
void FLayers::UpdateActorAllViewsVisibility( const TWeakObjectPtr< AActor >& Actor )
{
	uint64 OriginalHiddenViews = Actor->HiddenEditorViews;

	for ( int32 ViewIndex = 0; ViewIndex < Editor->LevelViewportClients.Num(); ++ViewIndex )
	{
		// don't have this reattach, as we can do it once for all views
		UpdateActorViewVisibility(Editor->LevelViewportClients[ViewIndex], Actor, false);
	}

	// reregister if we changed the visibility bits, as the rendering thread needs them
	if (OriginalHiddenViews != Actor->HiddenEditorViews)
	{
		return;
	}

	Actor->MarkComponentsRenderStateDirty();

	// redraw all viewports if the actor
	for (int32 ViewIndex = 0; ViewIndex < Editor->LevelViewportClients.Num(); ViewIndex++)
	{
		// make sure we redraw all viewports
		Editor->LevelViewportClients[ViewIndex]->Invalidate();
	}
}
void FLightingBuildInfoStatsPage::Generate( TArray< TWeakObjectPtr<UObject> >& OutObjects ) const
{
	if(Entries.Num())
	{		
		for( auto It = Entries.CreateConstIterator(); It; ++It )
		{
			TWeakObjectPtr<ULightingBuildInfo> Entry = *It;
			if(Entry.IsValid())
			{
				ULightingBuildInfo* NewObject = DuplicateObject<ULightingBuildInfo>(Entry.Get(), Entry->GetOuter());
				NewObject->AddToRoot();
				OutObjects.Add( NewObject );
			}
		}
	}
}
Example #3
0
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Operations on selected actors.
//
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
TArray< TWeakObjectPtr< AActor > > FLayers::GetSelectedActors() const
{
	// Unfortunately, the batch selection operation is not entirely effective
	// and the result can be that the iterator becomes invalid when adding an actor to a layer
	// due to unintended selection change notifications being fired.
	TArray< TWeakObjectPtr< AActor > > CurrentlySelectedActors;
	for( FSelectionIterator It( Editor->GetSelectedActorIterator() ); It; ++It )
	{
		const TWeakObjectPtr< AActor > Actor = static_cast< AActor* >( *It );
		checkSlow( Actor->IsA(AActor::StaticClass()) );

		CurrentlySelectedActors.Add( Actor );
	}

	return CurrentlySelectedActors;
}
FName FClassIconFinder::FindIconNameForActor( const TWeakObjectPtr<AActor>& InActor )
{
	// Actor specific overrides to normal per-class icons
	AActor* Actor = InActor.Get();
	FName BrushName = NAME_None;

	if ( Actor )
	{
		ABrush* Brush = Cast< ABrush >( Actor );
		if ( Brush )
		{
			if (Brush_Add == Brush->BrushType)
			{
				BrushName = TEXT( "ClassIcon.BrushAdditive" );
			}
			else if (Brush_Subtract == Brush->BrushType)
			{
				BrushName = TEXT( "ClassIcon.BrushSubtractive" );
			}
		}

		// Actor didn't specify an icon - fallback on the class icon
		if ( BrushName.IsNone() )
		{
			BrushName = FindIconNameForClass( Actor->GetClass() );
		}
	}
	else
	{
		// If the actor reference is NULL it must have been deleted
		BrushName = TEXT( "ClassIcon.Deleted" );
	}

	return BrushName;
}
Example #5
0
	/** Called to get the name of a curve back from the animation skeleton */
	virtual FText GetCurveName(USkeleton::AnimCurveUID Uid) const
	{
		if(BaseSequence.IsValid())
		{
			FSmartNameMapping* NameMapping = BaseSequence.Get()->GetSkeleton()->SmartNames.GetContainer(USkeleton::AnimCurveMappingName);
			if(NameMapping)
			{
				FName CurveName;
				if(NameMapping->GetName(Uid, CurveName))
				{
					return FText::FromName(CurveName);
				}
			}
		}
		return FText::GetEmpty();
	}
//------------------------------------------------------------------------------
int32 FLinkerPlaceholderBase::ResolvePlaceholderPropertyValues(UObject* NewObjectValue)
{
	int32 ResolvedTotal = 0;

	UObject* ThisAsUObject = GetPlaceholderAsUObject();
	for (auto& ReferencingPair : ReferencingContainers)
	{
		TWeakObjectPtr<UObject> ContainerPtr = ReferencingPair.Key;
		if (!ContainerPtr.IsValid())
		{
			continue;
		}
		UObject* Container = ContainerPtr.Get();

		for (const UObjectProperty* Property : ReferencingPair.Value)
		{
#if USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS
			check(Property->GetOwnerClass() == Container->GetClass());
#endif // USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS

			TArray<const UProperty*> PropertyChain;
			LinkerPlaceholderObjectImpl::BuildPropertyChain(Property, PropertyChain);
			const UProperty* OutermostProperty = PropertyChain.Last();

			uint8* OutermostAddress = OutermostProperty->ContainerPtrToValuePtr<uint8>((uint8*)Container, /*ArrayIndex =*/0);
			int32 ResolvedCount = LinkerPlaceholderObjectImpl::ResolvePlaceholderValues(PropertyChain, PropertyChain.Num() - 1, OutermostAddress, ThisAsUObject, NewObjectValue);
			ResolvedTotal += ResolvedCount;

#if USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS
			// we expect that (because we have had ReferencingProperties added) 
			// there should be at least one reference that is resolved... if 
			// there were none, then a property could have changed its value 
			// after it was set to this
			// 
			// NOTE: this may seem it can be resolved by properties removing 
			//       themselves from ReferencingProperties, but certain 
			//       properties may be the inner of a UArrayProperty (meaning 
			//       there could be multiple references per property)... we'd 
			//       have to inc/decrement a property ref-count to resolve that 
			//       scenario
			check(ResolvedCount > 0);
#endif // USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS
		}
	}

	return ResolvedTotal;
}
Example #7
0
// Purges any objects marked pending kill from the object list
void FObjectPropertyNode::PurgeKilledObjects()
{
	// Purge any objects that are marked pending kill from the object list
	for (int32 Index = 0; Index < Objects.Num(); )
	{
		TWeakObjectPtr<UObject> Object = Objects[Index];

		if ( !Object.IsValid() || Object->HasAnyFlags(RF_PendingKill) )
		{
			Objects.RemoveAt(Index, 1);
		}
		else
		{
			++Index;
		}
	}
}
	FAnimCurveBaseInterface(UAnimSequenceBase * BaseSeq, FAnimCurveBase*	InData)
		: BaseSequence(BaseSeq)
		, CurveData(InData)
	{
		// they should be valid
		check (BaseSequence.IsValid());
		check (CurveData);
	}
Example #9
0
//------------------------------------------------------------------------------
bool FDeferredScriptLoader::Resolve(FArchive& Ar)
{
	if (UStruct* Target = TargetScriptContainerPtr.Get())
	{
		return LoadStructWithScript(Target, Ar);
	}
	return false;
}
void UAblAbilityTaskDependencyValidator::Validate(const TWeakObjectPtr<UAblAbilityTaskValidatorContext>& Context, const TWeakObjectPtr<const UAblAbilityTask>& Task) const
{
	const TArray<UAblAbilityTask*>& AllTasks = Context->GetAbility()->GetTasks();
	for (const UAblAbilityTask* CurrentTask : AllTasks)
	{
		HasCircularDependency(Context, CurrentTask, CurrentTask);
	}
}
Example #11
0
void UK2Node_MacroInstance::FindInContentBrowser(TWeakObjectPtr<UK2Node_MacroInstance> MacroInstance)
{
	if ( MacroInstance.IsValid() )
	{
		UEdGraph* InstanceMacroGraph = MacroInstance.Get()->MacroGraphReference.GetGraph();
		if ( InstanceMacroGraph )
		{
			UBlueprint* BlueprintToSync = FBlueprintEditorUtils::FindBlueprintForGraph(InstanceMacroGraph);
			if ( BlueprintToSync )
			{
				TArray<UObject*> ObjectsToSync;
				ObjectsToSync.Add( BlueprintToSync );
				GEditor->SyncBrowserToObjects(ObjectsToSync);
			}
		}
	}
}
Example #12
0
	void DoTask(ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent)
	{
		SCOPE_CYCLE_COUNTER(STAT_AnimGameThreadTime);
		if (USkeletalMeshComponent* Comp = SkeletalMeshComponent.Get())
		{
			Comp->CompleteParallelBlendPhysics();
		}
	}
Example #13
0
			// Called by the EditableText widget to get the current comment for the node
			static FString GetNodeComment(TWeakObjectPtr<UEdGraphNode> NodeWeakPtr)
			{
				if (UEdGraphNode* SelectedNode = NodeWeakPtr.Get())
				{
					return SelectedNode->NodeComment;
				}
				return FString();
			}
void FAssetTypeActions_Texture::ExecuteFindMaterials(TWeakObjectPtr<UTexture> Object)
{
	auto Texture = Object.Get();
	if ( Texture )
	{
		// @todo AssetTypeActions Implement FindMaterials using the asset registry.
	}
}
void FMovieSceneActorReferenceTrackInstance::Update(EMovieSceneUpdateData& UpdateData, const TArray<TWeakObjectPtr<UObject>>& RuntimeObjects, class IMovieScenePlayer& Player, FMovieSceneSequenceInstance& SequenceInstance ) 
{
	// TODO: Support default values.
	FGuid ActorReferenceGuid;
	if( ActorReferenceTrack->Eval( UpdateData.Position, UpdateData.LastPosition, ActorReferenceGuid ) )
	{
		AActor* CurrentActor = nullptr;
		if (GuidToActorCache.Contains(ActorReferenceGuid))
		{
			TWeakObjectPtr<AActor> CachedActor = *GuidToActorCache.Find(ActorReferenceGuid);
			if (CachedActor.IsValid())
			{
				CurrentActor = CachedActor.Get();
			}
		}

		if (CurrentActor == nullptr)
		{
			TArray<TWeakObjectPtr<UObject>> RuntimeObjectsForGuid;
			Player.GetRuntimeObjects(SequenceInstance.AsShared(), ActorReferenceGuid, RuntimeObjectsForGuid);
	
			if (RuntimeObjectsForGuid.Num() == 1)
			{
				AActor* ActorForGuid = Cast<AActor>(RuntimeObjectsForGuid[0].Get());

				if (ActorForGuid != nullptr)
				{
					CurrentActor = ActorForGuid;
					if (CurrentActor != nullptr)
					{
						GuidToActorCache.Add(ActorReferenceGuid, CurrentActor);
					}
				}
			}
		}

		if (CurrentActor != nullptr)
		{
			for (auto ObjectPtr : RuntimeObjects)
			{
				UObject* Object = ObjectPtr.Get();
				PropertyBindings->CallFunction<AActor*>(Object, &CurrentActor);
			}
		}
	}
}
Example #16
0
float UPhysicalMaterial::GetTireFrictionScale( TWeakObjectPtr<UTireType> TireType )
{
	float Scale = (TireType != NULL) ? TireType->GetFrictionScale() : 1.0f;

	Scale *= TireFrictionScale;

	for ( int32 i = TireFrictionScales.Num() - 1; i >= 0; --i )
	{
		if ( TireFrictionScales[i].TireType == TireType.Get() )
		{
			Scale *= TireFrictionScales[i].FrictionScale;
			break;
		}
	}

	return Scale;
}
FString SObjectNameEditableTextBox::GetObjectDisplayName(TWeakObjectPtr<UObject> Object)
{
	FString Result;
	if(Object.IsValid())
	{
		UObject* ObjectPtr = Object.Get();
		if (ObjectPtr->IsA(AActor::StaticClass()))
		{
			Result =  ((AActor*)ObjectPtr)->GetActorLabel();
		}
		else
		{
			Result = ObjectPtr->GetName();
		}
	}
	return Result;
}
Example #18
0
	virtual bool IsValidCurve( FRichCurveEditInfo CurveInfo ) override
	{
		// Get the curve with the ID directly from the sequence and compare it since undo/redo can cause previously
		// used curves to become invalid.
		FAnimCurveBase* CurrentCurveData = BaseSequence.Get()->RawCurveData.GetCurveData( CurveUID );
		return CurrentCurveData != nullptr &&
			CurveInfo.CurveToEdit == &((FFloatCurve*)CurrentCurveData)->FloatCurve;
	}
UExporter::UExporter(const class FPostConstructInitializeProperties& PCIP)
	: Super(PCIP)
{
	if ( HasAnyFlags(RF_ClassDefaultObject) )
	{
		TWeakObjectPtr<UExporter> DefaultExporterObj(this);
		TWeakObjectPtr<UExporter>* PreviousObj = RegisteredExporters.Find(DefaultExporterObj);
		if(!PreviousObj)
		{
			RegisteredExporters.Add(DefaultExporterObj);
		}
		else if(!PreviousObj->IsValid())
		{
			RegisteredExporters.Remove(*PreviousObj);
			RegisteredExporters.Add(DefaultExporterObj);
		}
	}
}
Example #20
0
bool FLayers::InitializeNewActorLayers( const TWeakObjectPtr< AActor >& Actor )
{
	if(	!IsActorValidForLayer( Actor ) )
	{
		return false;
	}

	for( auto LayerNameIt = Actor->Layers.CreateConstIterator(); LayerNameIt; ++LayerNameIt )
	{
		const FName LayerName = *LayerNameIt;
		TWeakObjectPtr< ULayer > Layer = EnsureLayerExists( LayerName );

		Layer->Modify();
		AddActorToStats( Layer, Actor);
	}

	return Actor->Layers.Num() > 0;
}
Example #21
0
UExporter::UExporter(const FObjectInitializer& ObjectInitializer)
    : Super(ObjectInitializer)
{
    if ( HasAnyFlags(RF_ClassDefaultObject) )
    {
        TWeakObjectPtr<UExporter> DefaultExporterObj(this);
        TWeakObjectPtr<UExporter>* PreviousObj = RegisteredExporters.Find(DefaultExporterObj);
        if(!PreviousObj)
        {
            RegisteredExporters.Add(DefaultExporterObj);
        }
        else if(!PreviousObj->IsValid())
        {
            RegisteredExporters.Remove(*PreviousObj);
            RegisteredExporters.Add(DefaultExporterObj);
        }
    }
}
Example #22
0
void FLayers::MakeAllLayersVisible()
{
	TArray< FName > AllLayerNames;
	FLayers::AddAllLayerNamesTo( AllLayerNames );
	for( auto LayerIt = GetWorld()->Layers.CreateIterator(); LayerIt; ++LayerIt )
	{
		TWeakObjectPtr< ULayer > Layer = *LayerIt;

		if( !Layer->bIsVisible )
		{
			Layer->Modify();
			Layer->bIsVisible = true;
			LayersChanged.Broadcast( ELayersAction::Modify, Layer, "bIsVisible" );
		}
	}

	UpdateAllActorsVisibility( true, true );
}
	FAnimTrackCurveBaseInterface(UAnimSequence * BaseSeq, USkeleton::AnimCurveUID InCurveUID, ETransformCurve::Type InCurveType)
		: BaseSequence(BaseSeq)
		, CurveUID(InCurveUID)
		, CurveType(InCurveType)
	{
		CurveData = GetCurveDataFromSequence();
		// they should be valid
		check (BaseSequence.IsValid());
		check (CurveData);
	}
Example #24
0
void FLayers::ToggleLayersVisibility( const TArray< FName >& LayerNames )
{
	if( LayerNames.Num() == 0 )
	{
		return;
	}

	for( auto LayerNameIt = LayerNames.CreateConstIterator(); LayerNameIt; ++LayerNameIt )
	{
		const TWeakObjectPtr< ULayer > Layer = EnsureLayerExists( *LayerNameIt );
		check( Layer != NULL );

		Layer->Modify();
		Layer->bIsVisible = !Layer->bIsVisible;
		LayersChanged.Broadcast( ELayersAction::Modify, Layer, "bIsVisible" );
	}

	UpdateAllActorsVisibility( true, true );
}
	/** Called to get the name of a curve back from the animation skeleton */
	virtual FText GetCurveName(USkeleton::AnimCurveUID Uid) const
	{
		if(BaseSequence.IsValid())
		{
			FSmartNameMapping* NameMapping = BaseSequence.Get()->GetSkeleton()->SmartNames.GetContainer(USkeleton::AnimTrackCurveMappingName);
			if(NameMapping)
			{
				FName CurveName;
				if(NameMapping->GetName(Uid, CurveName))
				{
					FName DisplayName = CurveName;

					return FText::FromString(FString::Printf(TEXT("%s(%c)"), *DisplayName.ToString(), GetCurveTypeCharacter()));
				}
			}
		}

		return FText::GetEmpty();
	}
 virtual void DrawCanvas(FViewport& InViewport, FSceneView& View, FCanvas& Canvas) override
 {
     FEditorViewportClient::DrawCanvas(InViewport, View, Canvas);
     
     if (Widget.IsValid() && Widget->OnDrawCanvas.IsBound())
     {
         if(CanvasOwner.Canvas == nullptr){
             CanvasOwner.Canvas = NewObject<UCanvas>(Widget.Get());
         }
         
         CanvasOwner.Canvas->Canvas = &Canvas;
         CanvasOwner.Canvas->Init(View.UnscaledViewRect.Width(), View.UnscaledViewRect.Height(), const_cast<FSceneView*>(&View));
         CanvasOwner.Canvas->ApplySafeZoneTransform();
         
         Widget->OnDrawCanvas.Execute(CanvasOwner.Canvas, Widget.Get());
         
         CanvasOwner.Canvas->PopSafeZoneTransform();
     }
 }
Example #27
0
bool FLayers::DisassociateActorFromLayers( const TWeakObjectPtr< AActor >& Actor )
{
	if(	!IsActorValidForLayer( Actor ) )
	{
		return false;
	}

	bool bChangeOccurred = false;
	for( auto LayerNameIt = Actor->Layers.CreateConstIterator(); LayerNameIt; ++LayerNameIt )
	{
		const FName LayerName = *LayerNameIt;
		TWeakObjectPtr< ULayer > Layer = EnsureLayerExists( LayerName );

		Layer->Modify();
		RemoveActorFromStats( Layer, Actor);
		bChangeOccurred = true;
	}

	return bChangeOccurred;
}
void UAblAbilityTaskOrderValidator::Validate(const TWeakObjectPtr<UAblAbilityTaskValidatorContext>& Context, const TWeakObjectPtr<const UAblAbilityTask>& Task) const
{
	const float AbilityLength = Context->GetAbility()->GetLength();
	const TArray<UAblAbilityTask*>& AllTasks = Context->GetAbility()->GetTasks();
	int j = 0;
	float TimeDifference = 0.0f;
	for (int i = 0; i < AllTasks.Num() - 1; ++i)
	{
		for (j = i + 1; j < AllTasks.Num(); ++j)
		{
			TimeDifference = AllTasks[j]->GetStartTime() - AllTasks[i]->GetStartTime();
			// The 0.0 check is just there to catch any constants people may be using.
			if (TimeDifference != 0.0f && TimeDifference < KINDA_SMALL_NUMBER)
			{
				Context->AddError(LOCTEXT("AbilityValidatorTasksOutOfOrder", "Tasks aren't in sequential order. Please resave the ability."));
				return; // We can early out.
			}
		}
	}
}
void FPropertyTable::PurgeInvalidObjectNodes()
{
	TArray< TSharedRef< FObjectPropertyNode > > ValidNodes;
	for( auto NodeIter = SourceObjectPropertyNodes.CreateIterator(); NodeIter; ++NodeIter )
	{
		const TWeakObjectPtr< UObject > Object = NodeIter.Key();

		if ( !Object.IsValid() )
		{
			ValidNodes.Add( NodeIter.Value() );
		}
	}

	SourceObjectPropertyNodes.Empty();
	for( auto NodeIter = ValidNodes.CreateIterator(); NodeIter; ++NodeIter )
	{
		const TSharedRef< FObjectPropertyNode >& CurrentNode = *NodeIter;
		SourceObjectPropertyNodes.Add( CurrentNode->GetUObject( 0 ), CurrentNode );
	}
}
void FBPProfilerBranchStat::CreateChildrenForPins()
{
	TWeakObjectPtr<const UObject> ObjectPtr = ObjectContext.GetObjectPtr();
	bAreExecutionPathsSequential = IsBranchSequential();
	if (const UEdGraphNode* GraphNode = Cast<const UEdGraphNode>(ObjectPtr.Get()))
	{
		for (auto Pin : GraphNode->Pins)
		{
			if (Pin->Direction == EGPD_Output && Pin->PinType.PinCategory == UEdGraphSchema_K2::PC_Exec)
			{
				FBPProfilerStatPtr& Result = CachedChildren.FindOrAdd(Pin);
				if (!Result.IsValid())
				{
					FScriptExecEvent NewExitPin(Pin, ObjectContext);
					Result = MakeShareable(new FBPProfilerStat(AsShared(), NewExitPin));
				}
			}
		}
	}
}