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

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 FLayers::UpdateActorViewVisibility( FLevelEditorViewportClient* ViewportClient, const TWeakObjectPtr< AActor >& Actor, bool bReregisterIfDirty )
{
	// get the viewport client
	const int32 ViewIndex = ViewportClient->ViewIndex;

	int32 NumHiddenLayers = 0;
	// look for which of the actor layers are hidden
	for (int32 LayerIndex = 0; LayerIndex < Actor->Layers.Num(); LayerIndex++)
	{
		// if its in the view hidden list, this layer is hidden for this actor
		if (ViewportClient->ViewHiddenLayers.Find( Actor->Layers[ LayerIndex ] ) != -1)
		{
			NumHiddenLayers++;
			// right now, if one is hidden, the actor is hidden
			break;
		}
	}

	uint64 OriginalHiddenViews = Actor->HiddenEditorViews;

	// right now, if one is hidden, the actor is hidden
	if (NumHiddenLayers)
	{
		Actor->HiddenEditorViews |= ((uint64)1 << ViewIndex);
	}
	else
	{
		Actor->HiddenEditorViews &= ~((uint64)1 << ViewIndex);
	}

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

		// make sure we redraw the viewport
		ViewportClient->Invalidate();
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Operations on actor viewport visibility regarding layers
//
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void FLayers::UpdatePerViewVisibility( FLevelEditorViewportClient* ViewportClient, const FName& LayerThatChanged )
{
	const int32 ViewIndex = ViewportClient->ViewIndex;
	// get the viewport client
	// Iterate over all actors, looking for actors in the specified layers.
	if( ViewportClient->GetWorld() == NULL )
	{
		return;
	}
	for( FActorIterator It(ViewportClient->GetWorld()) ; It ; ++It )
	{
		const TWeakObjectPtr< AActor > Actor = *It;
		if( !IsActorValidForLayer( Actor ) )
		{
			continue;
		}

		// if the view has nothing hidden, just quickly mark the actor as visible in this view 
		if ( ViewportClient->ViewHiddenLayers.Num() == 0)
		{
			// if the actor had this view hidden, then unhide it
			if ( Actor->HiddenEditorViews & ( (uint64)1 << ViewIndex ) )
			{
				// make sure this actor doesn't have the view set
				Actor->HiddenEditorViews &= ~( (uint64)1 << ViewIndex );
				Actor->MarkComponentsRenderStateDirty();
			}
		}
		// else if we were given a name that was changed, only update actors with that name in their layers,
		// otherwise update all actors
		else if ( LayerThatChanged == NAME_Skip || Actor->Layers.Contains( LayerThatChanged ) )
		{
			UpdateActorViewVisibility(ViewportClient, Actor);
		}
	}

	// make sure we redraw the viewport
	ViewportClient->Invalidate();
}

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