void FGridWidget::AddReferencedObjects( FReferenceCollector& Collector )
{
	Collector.AddReferencedObject( LevelGridMaterial );
	Collector.AddReferencedObject( LevelGridMaterialInst );
	Collector.AddReferencedObject( LevelGridMaterial2 );
	Collector.AddReferencedObject( LevelGridMaterialInst2 );
}
/** FGCObject interface */
void FEdModeHaste::AddReferencedObjects(FReferenceCollector& Collector)
{
	// Call parent implementation
	FEdMode::AddReferencedObjects(Collector);

	Collector.AddReferencedObject(BrushMeshComponent);
	Collector.AddReferencedObject(UISettings);
}
void FTransaction::FObjectRecord::AddReferencedObjects( FReferenceCollector& Collector )
{
	Collector.AddReferencedObject( Object );
	for( int32 ObjIndex = 0; ObjIndex < ReferencedObjects.Num(); ObjIndex++ )
	{
		Collector.AddReferencedObject( ReferencedObjects[ ObjIndex ] );
	}
}
//------------------------------------------------------------------------------
void FBlueprintNodeTemplateCache::AddReferencedObjects(FReferenceCollector& Collector)
{
	for (auto& TemplateEntry : NodeTemplateCache)
	{
		Collector.AddReferencedObject(TemplateEntry.Value);
	}
	Collector.AddReferencedObjects(TemplateOuters);
}
void FScriptObjectReferencer::AddReferencedObjects(FReferenceCollector& Collector)
{
	Collector.AllowEliminatingReferences(false);
	for (auto Object : ScriptCreatedObjects)
	{
		Collector.AddReferencedObject(Object);
	}
	Collector.AllowEliminatingReferences(true);
}
Beispiel #6
0
void FPreviewScene::AddReferencedObjects( FReferenceCollector& Collector )
{
	for( int32 Index = 0; Index < Components.Num(); Index++ )
	{
		Collector.AddReferencedObject( Components[ Index ] );
	}
	Collector.AddReferencedObject( DirectionalLight );
	Collector.AddReferencedObject( PreviewWorld );
}
void FSignificanceManagerModule::AddReferencedObjects( FReferenceCollector& Collector )
{
	for (TPair<const UWorld*, USignificanceManager*>& WorldSignificanceManagerPair : WorldSignificanceManagers)
	{
		Collector.AddReferencedObject(WorldSignificanceManagerPair.Value, WorldSignificanceManagerPair.Key);
	}
	UClass* SignificanceManagerClassPtr = *SignificanceManagerClass;
	Collector.AddReferencedObject(SignificanceManagerClassPtr);
	SignificanceManagerClass = SignificanceManagerClassPtr; // Since pointer can be modified by AddReferencedObject
}
Beispiel #8
0
void UFactory::AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector)
{	
	UFactory* This = CastChecked<UFactory>(InThis);
	UClass* SupportedClass = *This->SupportedClass;
	UClass* ContextClass = *This->ContextClass;
	Collector.AddReferencedObject( SupportedClass, This );
	Collector.AddReferencedObject( ContextClass, This );

	Super::AddReferencedObjects( This, Collector );
}
// FGCObject interface
void FDeferRegisterStaticComponents::AddReferencedObjects(FReferenceCollector& Collector)
{
	for (TMap<AActor*, TArray<FDeferredComponentInfo> >::TIterator It(ComponentsToRegister); It; ++It)
	{
		Collector.AddReferencedObject(It.Key());
		TArray<FDeferredComponentInfo>& Components = It.Value();
		for (int32 ComponentIndex = 0; ComponentIndex < Components.Num(); ++ComponentIndex)
		{
			Collector.AddReferencedObject(Components[ComponentIndex].Component);
		}
	}
}
void FDestructibleMeshEditorViewportClient::AddReferencedObjects( FReferenceCollector& Collector )
{
	for (int32 i=0; i < SelectedChunks.Num(); ++i)
	{
		Collector.AddReferencedObject(SelectedChunks[i]);
	}

	for (int32 i=0; i < UnusedProxies.Num(); ++i)
	{
		Collector.AddReferencedObject(UnusedProxies[i]);
	}
}
void FObjectReferencer::AddReferencedObjects(FReferenceCollector& Collector)
{
	// don't want the collector to NULL pointers to UObject(s) marked for destruction
	Collector.AllowEliminatingReferences(false);
	for (auto& Iterator : ObjectRefs.GetAnnotationMap())
	{
		// annotations with a ref count of zero shouldn't be in the map
		check(Iterator.Value.Count > 0);
		UObjectBase* Object = const_cast<UObjectBase*>(Iterator.Key);
		Collector.AddReferencedObject(Object);
	}
	Collector.AllowEliminatingReferences(true);
}
void FLegacySlateFontInfoCache::AddReferencedObjects(FReferenceCollector& Collector)
{
	for(auto& FallbackFontEntry : FallbackFonts)
	{
		const UFontBulkData* TmpPtr = FallbackFontEntry.Value->BulkDataPtr;
		Collector.AddReferencedObject(TmpPtr);
	}

	if(LastResortFont.IsValid())
	{
		const UFontBulkData* TmpPtr = LastResortFont->BulkDataPtr;
		Collector.AddReferencedObject(TmpPtr);
	}
}
void FLegacySlateFontInfoCache::AddReferencedObjects(FReferenceCollector& Collector)
{
	if(FallbackFontData.IsValid())
	{
		const UFontBulkData* TmpPtr = FallbackFontData->BulkDataPtr;
		Collector.AddReferencedObject(TmpPtr);
	}

	if(LastResortFontData.IsValid())
	{
		const UFontBulkData* TmpPtr = LastResortFontData->BulkDataPtr;
		Collector.AddReferencedObject(TmpPtr);
	}
}
Beispiel #14
0
void UPolys::AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector)
{
    UPolys* This = CastChecked<UPolys>(InThis);
    // Let GC know that we're referencing some Actor and Property objects
    for( TTransArray<FPoly>::TConstIterator ElementIt(This->Element); ElementIt; ++ElementIt )
    {
        FPoly PolyElement = *ElementIt;
        Collector.AddReferencedObject( PolyElement.Actor, This );
        Collector.AddReferencedObject( PolyElement.Material, This );
    }
    UObject* ElementOwner = This->Element.GetOwner();
    Collector.AddReferencedObject( ElementOwner, This );
    Super::AddReferencedObjects(This, Collector);
}
void FStandaloneCompositeFont::AddReferencedObjects(FReferenceCollector& Collector)
{
	for(FTypefaceEntry& TypefaceEntry : DefaultTypeface.Fonts)
	{
		Collector.AddReferencedObject(TypefaceEntry.Font.BulkDataPtr);
	}

	for(FCompositeSubFont& SubFont : SubTypefaces)
	{
		for(FTypefaceEntry& TypefaceEntry : SubFont.Typeface.Fonts)
		{
			Collector.AddReferencedObject(TypefaceEntry.Font.BulkDataPtr);
		}
	}
}
void UJavascriptContext::AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector)
{
	UJavascriptContext* This = CastChecked<UJavascriptContext>(InThis);

	if (This->JavascriptContext.IsValid())
	{
		Collector.AllowEliminatingReferences(false);

		This->JavascriptContext->AddReferencedObjects(This, Collector);

		Collector.AllowEliminatingReferences(true);
	}

	Super::AddReferencedObjects(This, Collector);
}
void FEdGraphSchemaAction_EventFromFunction::AddReferencedObjects(FReferenceCollector& Collector)
{
	FEdGraphSchemaAction::AddReferencedObjects(Collector);

	// These don't get saved to disk, but we want to make sure the objects don't get GC'd while the action array is around
	Collector.AddReferencedObject(SignatureFunction);
}
Beispiel #18
0
void FEdModeLevel::AddReferencedObjects( FReferenceCollector& Collector )
{
	// Call parent implementation
	FEdMode::AddReferencedObjects( Collector );

	Collector.AddReferencedObject(BoxMaterial);
}
//------------------------------------------------------------------------------
void FBlueprintActionDatabase::AddReferencedObjects(FReferenceCollector& Collector)
{
	for (auto& ActionListIt : ActionRegistry)
	{
		Collector.AddReferencedObjects(ActionListIt.Value);
	}
}
Beispiel #20
0
void FNotifyBufferFinishedHooks::AddReferencedObjects( FReferenceCollector& Collector )
{
	for (FNotifyBufferDetails& NotifyDetails : Notifies)
	{
		Collector.AddReferencedObject( NotifyDetails.NotifyNode );
	}
}
Beispiel #21
0
void FEdGraphSchemaAction_NewNode::AddReferencedObjects( FReferenceCollector& Collector )
{
	FEdGraphSchemaAction::AddReferencedObjects( Collector );

	// These don't get saved to disk, but we want to make sure the objects don't get GC'd while the action array is around
	Collector.AddReferencedObject( NodeTemplate );
}
Beispiel #22
0
void FAnimMontageInstance::AddReferencedObjects( FReferenceCollector& Collector )
{
	if (Montage && Montage->GetOuter() == GetTransientPackage())
	{
		Collector.AddReferencedObject(Montage);
	}
}
	virtual void AddReferencedObjects(FReferenceCollector& Collector)
	{
		if( ResourceObject )
		{
			Collector.AddReferencedObject(ResourceObject);
		}
	}
void USoundNodeModPlayer::AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector)
{
	USoundNodeModPlayer* This = CastChecked<USoundNodeModPlayer>(InThis);
	Super::AddReferencedObjects(This, Collector);

	Collector.AddReferencedObject(This->SoundMod);
}
void FEdGraphSchemaAction_K2AddComponent::AddReferencedObjects( FReferenceCollector& Collector )
{
	FEdGraphSchemaAction_K2NewNode::AddReferencedObjects( Collector );

	// These don't get saved to disk, but we want to make sure the objects don't get GC'd while the action array is around
	Collector.AddReferencedObject( ComponentAsset );
}
void UDataTable::AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector)
{
    UDataTable* This = CastChecked<UDataTable>(InThis);

    // Need to emit references for referenced rows
    if(This->RowStruct != NULL)
    {
        // Now iterate over rows in the map
        for ( auto RowIt = This->RowMap.CreateIterator(); RowIt; ++RowIt )
        {
            uint8* RowData = RowIt.Value();

            if (RowData)
            {
                // Serialize all of the properties to make sure they get in the collector
                FSimpleObjectReferenceCollectorArchive ObjectReferenceCollector( This, Collector );
                This->RowStruct->SerializeBin(ObjectReferenceCollector, RowData);
            }
        }
    }

#if WITH_EDITOR
    Collector.AddReferencedObjects(This->TemporarilyReferencedObjects);
#endif //WITH_EDITOR

    Super::AddReferencedObjects( This, Collector );
}
Beispiel #27
0
void FAutoReimportManager::AddReferencedObjects(FReferenceCollector& Collector)
{
	for (auto* Package : PackagesToSave)
	{
		Collector.AddReferencedObject(Package);
	}
}
void FWidgetBlueprintEditor::AddReferencedObjects( FReferenceCollector& Collector )
{
	FBlueprintEditor::AddReferencedObjects( Collector );

	UUserWidget* Preview = GetPreview();
	Collector.AddReferencedObject( Preview );
}
Beispiel #29
0
void STutorialRoot::AddReferencedObjects( FReferenceCollector& Collector )
{
	if(CurrentTutorial != nullptr)
	{
		Collector.AddReferencedObject(CurrentTutorial);
	}
}
void FQosInterface::AddReferencedObjects(FReferenceCollector& Collector)
{
	if (RegionManager)
	{
		Collector.AddReferencedObject(RegionManager);
	}
}