C++ TWeakObjectPtr::Modify方法代码示例

bool FLayers::AddActorsToLayers( const TArray< TWeakObjectPtr< AActor > >& Actors, const TArray< FName >& LayerNames )
{
	bool bChangesOccurred = false;

	if ( LayerNames.Num() > 0 ) 
	{
		Editor->GetSelectedActors()->BeginBatchSelectOperation();

		for( auto ActorIt = Actors.CreateConstIterator(); ActorIt; ++ActorIt )
		{
			const TWeakObjectPtr< AActor > Actor = *ActorIt;

			if ( !IsActorValidForLayer( Actor ) )
			{
				continue;
			}

			bool bActorWasModified = false;
			for( auto LayerNameIt = LayerNames.CreateConstIterator(); LayerNameIt; ++LayerNameIt )
			{
				const FName& LayerName = *LayerNameIt;

				if( !Actor->Layers.Contains( LayerName ) )
				{
					if( !bActorWasModified )
					{
						Actor->Modify();
						bActorWasModified = true;
					}

					TWeakObjectPtr< ULayer > Layer = EnsureLayerExists( LayerName );
					Actor->Layers.Add( LayerName );

					Layer->Modify();
					AddActorToStats( Layer, Actor);
				}
			} //END Iteration over Layers

			if( bActorWasModified )
			{
				// update per-view visibility info
				UpdateActorAllViewsVisibility(Actor);

				// update general actor visibility
				bool bActorModified = false;
				bool bActorSelectionChanged = false;
				const bool bActorNotifySelectionChange = true;
				const bool bActorRedrawViewports = false;
				UpdateActorVisibility( Actor, bActorSelectionChanged, bActorModified, bActorNotifySelectionChange, bActorRedrawViewports );

				bChangesOccurred = true;
			}
		} //END Iteration over Actors

		Editor->GetSelectedActors()->EndBatchSelectOperation();
	}

	return bChangesOccurred;
}

bool FLayers::RemoveActorsFromLayers( const TArray< TWeakObjectPtr< AActor > >& Actors, const TArray< FName >& LayerNames, const bool bUpdateStats )
{
	Editor->GetSelectedActors()->BeginBatchSelectOperation();

	bool bChangesOccurred = false;
	for( auto ActorIt = Actors.CreateConstIterator(); ActorIt; ++ActorIt )
	{
		const TWeakObjectPtr< AActor > Actor = *ActorIt;

		if ( !IsActorValidForLayer( Actor ) )
		{
			continue;
		}

		bool ActorWasModified = false;
		for( auto LayerNameIt = LayerNames.CreateConstIterator(); LayerNameIt; ++LayerNameIt )
		{
			const FName& LayerName = *LayerNameIt;
			if( Actor->Layers.Contains( LayerName ) )
			{
				if( !ActorWasModified )
				{
					Actor->Modify();
					ActorWasModified = true;
				}

				Actor->Layers.Remove( LayerName );

				TWeakObjectPtr< ULayer > Layer;
				if( bUpdateStats && TryGetLayer( LayerName, Layer ))
				{
					Layer->Modify();
					RemoveActorFromStats( Layer, Actor);
				}
			}
		} //END Iteration over Layers

		if( ActorWasModified )
		{
			// update per-view visibility info
			UpdateActorAllViewsVisibility(Actor);

			// update general actor visibility
			bool bActorModified = false;
			bool bActorSelectionChanged = false;
			const bool bActorNotifySelectionChange = true;
			const bool bActorRedrawViewports = false;
			UpdateActorVisibility( Actor, bActorSelectionChanged, bActorModified, bActorNotifySelectionChange, bActorRedrawViewports );

			bChangesOccurred = true;
		}
	} //END Iteration over Actors

	Editor->GetSelectedActors()->EndBatchSelectOperation();

	return bChangesOccurred;
}

void FLayers::SetLayersVisibility( const TArray< FName >& LayerNames, bool bIsVisible )
{
	if( LayerNames.Num() == 0 )
	{
		return;
	}

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

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

	if( bChangeOccurred )
	{
		UpdateAllActorsVisibility( true, true );
	}
}

void FLayers::ToggleLayerVisibility( const FName& LayerName )
{
	const TWeakObjectPtr< ULayer > Layer = EnsureLayerExists( LayerName );
	check( Layer != NULL );

	Layer->Modify();
	Layer->bIsVisible = !Layer->bIsVisible;

	LayersChanged.Broadcast( ELayersAction::Modify, Layer, "bIsVisible" );
	UpdateAllActorsVisibility( true, true );
}

bool FLayers::RenameLayer( const FName OriginalLayerName, const FName& NewLayerName )
{
	// We specifically don't pass the original LayerName by reference to avoid it changing
	// it's original value, in case, it would be the reference of the Layer's actually FName
	if ( OriginalLayerName == NewLayerName )
	{
		return false;
	}

	TWeakObjectPtr< ULayer > Layer;
	if( !TryGetLayer( OriginalLayerName, Layer ) )
	{
		return false;
	}

	Layer->Modify();
	Layer->LayerName = NewLayerName;
	Layer->ActorStats.Empty();
	// Iterate over all actors, swapping layers.
	for( FActorIterator It(GetWorld()) ; It ; ++It )
	{
		const TWeakObjectPtr< AActor > Actor = *It;
		if( !IsActorValidForLayer( Actor ) )
		{
			continue;
		}

		if ( FLayers::RemoveActorFromLayer( Actor, OriginalLayerName ) )
		{
			// No need to mark the actor as modified these functions take care of that
			AddActorToLayer( Actor, NewLayerName );
		}
	}

	// update all views's hidden layers if they had this one
	for ( int32 ViewIndex = 0; ViewIndex < Editor->LevelViewportClients.Num(); ViewIndex++ )
	{
		FLevelEditorViewportClient* ViewportClient = Editor->LevelViewportClients[ ViewIndex ];
		if ( ViewportClient->ViewHiddenLayers.Remove( OriginalLayerName ) > 0 )
		{
			ViewportClient->ViewHiddenLayers.AddUnique( NewLayerName );
			ViewportClient->Invalidate();
		}
	}

	LayersChanged.Broadcast( ELayersAction::Rename, Layer, "LayerName" );

	return true;
} 

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 );
}

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;
}

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 );
}

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;
}

bool FLayers::UpdateActorVisibility( const TWeakObjectPtr< AActor >& Actor, bool& bOutSelectionChanged, bool& bOutActorModified, bool bNotifySelectionChange, bool bRedrawViewports )
{
	bOutActorModified = false;
	bOutSelectionChanged = false;

	if(	!IsActorValidForLayer( Actor ) )
	{
		return false;
	}

	// If the actor doesn't belong to any layers
	if( Actor->Layers.Num() == 0)
	{
		// If the actor is also hidden
		if( Actor->bHiddenEdLayer )
		{
			Actor->Modify();

			// Actors that don't belong to any layer shouldn't be hidden
			Actor->bHiddenEdLayer = false;
			Actor->MarkComponentsRenderStateDirty();
			bOutActorModified = true;
		}

		return bOutActorModified;
	}

	bool bActorBelongsToVisibleLayer = false;
	for( int32 LayerIndex = 0 ; LayerIndex < GetWorld()->Layers.Num() ; ++LayerIndex )
	{
		const TWeakObjectPtr< ULayer > Layer =  GetWorld()->Layers[ LayerIndex ];

		if( !Layer->bIsVisible )
		{
			continue;
		}

		if( Actor->Layers.Contains( Layer->LayerName ) )
		{
			if ( Actor->bHiddenEdLayer )
			{
				Actor->Modify();
				Actor->bHiddenEdLayer = false;
				Actor->MarkComponentsRenderStateDirty();
				bOutActorModified = true;
			}

			// Stop, because we found at least one visible layer the actor belongs to
			bActorBelongsToVisibleLayer = true;
			break;
		}
	}

	// If the actor isn't part of a visible layer, hide and de-select it.
	if( !bActorBelongsToVisibleLayer )
	{
		if ( !Actor->bHiddenEdLayer )
		{
			Actor->Modify();
			Actor->bHiddenEdLayer = true;
			Actor->MarkComponentsRenderStateDirty();
			bOutActorModified = true;
		}

		//if the actor was selected, mark it as unselected
		if ( Actor->IsSelected() )
		{
			bool bSelect = false;
			bool bNotify = false;
			bool bIncludeHidden = true;
			Editor->SelectActor( Actor.Get(), bSelect, bNotify, bIncludeHidden );

			bOutSelectionChanged = true;
			bOutActorModified = true;
		}
	}

	if ( bNotifySelectionChange && bOutSelectionChanged )
	{
		Editor->NoteSelectionChange();
	}

	if( bRedrawViewports )
	{
		Editor->RedrawLevelEditingViewports();
	}

	return bOutActorModified || bOutSelectionChanged;
}