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