bool UClassThumbnailRenderer::CanVisualizeAsset(UObject* Object) { if (ThumbnailScene == nullptr) { ThumbnailScene = new FClassThumbnailScene(); } UClass* Class = Cast<UClass>(Object); // Only visualize actor based classes if (Class && Class->IsChildOf(AActor::StaticClass())) { // Try to find any visible primitive components in the class' CDO AActor* CDO = Class->GetDefaultObject<AActor>(); TInlineComponentArray<UActorComponent*> Components; CDO->GetComponents(Components); for (auto CompIt = Components.CreateConstIterator(); CompIt; ++CompIt) { if (ThumbnailScene->IsValidComponentForVisualization(*CompIt)) { return true; } } } return false; }
UActorFactory* FPlacementMode::FindLastUsedFactoryForAssetType( UObject* Asset ) const { if ( Asset == NULL ) { return NULL; } UActorFactory* LastUsedFactory = NULL; UClass* CurrentClass = Cast<UClass>( Asset ); if ( CurrentClass == NULL ) { CurrentClass = Asset->GetClass(); } while ( LastUsedFactory == NULL && CurrentClass != NULL && CurrentClass != UClass::StaticClass() ) { const TWeakObjectPtr< UActorFactory >* FoundFactory = AssetTypeToFactory.Find( *CurrentClass->GetPathName() ); if ( FoundFactory != NULL && FoundFactory->IsValid() ) { LastUsedFactory = FoundFactory->Get(); } else { CurrentClass = CurrentClass->GetSuperClass(); } } return LastUsedFactory; }
// Disassemble all functions in any classes that have matching names. void FKismetBytecodeDisassembler::DisassembleAllFunctionsInClasses(FOutputDevice& Ar, const FString& ClassnameSubstring) { FKismetBytecodeDisassembler Disasm(Ar); for (TObjectIterator<UClass> ClassIter; ClassIter; ++ClassIter) { UClass* Class = *ClassIter; FString ClassName = Class->GetName(); if (FCString::Strfind(*ClassName, *ClassnameSubstring)) { Ar.Logf(TEXT("Processing class %s"), *ClassName); for (TFieldIterator<UFunction> FunctionIter(Class, EFieldIteratorFlags::ExcludeSuper); FunctionIter; ++FunctionIter) { UFunction* Function = *FunctionIter; FString FunctionName = Function->GetName(); Ar.Logf(TEXT(" Processing function %s (%d bytes)"), *FunctionName, Function->Script.Num()); Disasm.DisassembleStructure(Function); Ar.Logf(TEXT("")); } Ar.Logf(TEXT("")); Ar.Logf(TEXT("-----------")); Ar.Logf(TEXT("")); } } }
int32 UFixupNeedsLoadForEditorGameCommandlet::InitializeResaveParameters(const TArray<FString>& Tokens, TArray<FString>& MapPathNames) { int32 Result = Super::InitializeResaveParameters(Tokens, MapPathNames); // We need ResaveClasses to be specified, otherwise we won't know what to update if (Result == 0 && !ResaveClasses.Num()) { UE_LOG(LogContentCommandlet, Error, TEXT("FixupNeedsLoadForEditorGame commandlet requires at least one resave class name. Use -RESAVECLASS=ClassA,ClassB,ClassC to specify resave classes.")); Result = 1; } else { for (FName& ClassName : ResaveClasses) { if (!ResaveClassNeedsLoadForEditorGameValues.Contains(ClassName)) { UClass* ResaveClass = FindObject<UClass>(ANY_PACKAGE, *ClassName.ToString()); if (ResaveClass) { UObject* DefaultObject = ResaveClass->GetDefaultObject(); ResaveClassNeedsLoadForEditorGameValues.Add(ClassName, DefaultObject->NeedsLoadForEditorGame()); } } else if (Verbosity != UResavePackagesCommandlet::ONLY_ERRORS) { UE_LOG(LogContentCommandlet, Warning, TEXT("Resave Class \"%s\" could not be found. Make sure the class name is valid and that it's a native class."), *ClassName.ToString()); } } if (ResaveClassNeedsLoadForEditorGameValues.Num() == 0) { UE_LOG(LogContentCommandlet, Error, TEXT("Got %d classes to resave but none of the exist."), ResaveClasses.Num()); Result = 1; } } return Result; }
/** * Trys to load the UClass for the commandlet that was requested * * @param CommandletName the name of the commandlet to load */ static UClass* LoadCommandlet(const TCHAR* CommandletName) { // Try to find the UClass for the commandlet (works for all but script classes) UClass* Class = FindObject<UClass>(ANY_PACKAGE,CommandletName,FALSE); // Don't accept classes that are not commandlets... if (!Class->IsChildOf(UCommandlet::StaticClass())) { Class = NULL; } // Name mangle by appending Commandlet FString AppendedName(CommandletName); AppendedName += TEXT("Commandlet"); if (Class == NULL) { Class = FindObject<UClass>(ANY_PACKAGE,*AppendedName,FALSE); // Don't accept classes that are not commandlets... if (!Class->IsChildOf(UCommandlet::StaticClass())) { Class = NULL; } } // Let the user know that the commandlet wasn't found if (Class == NULL) { warnf(TEXT("Failed to load commandlet %s"),CommandletName); } return Class; }
// Looks at the Objects array and returns the best base class. Called by // Finalize(); that is, when the list of selected objects is being finalized. void FObjectPropertyNode::SetBestBaseClass() { BaseClass = NULL; for( int32 x = 0 ; x < Objects.Num() ; ++x ) { UObject* Obj = Objects[x].Get(); if( Obj ) { UClass* ObjClass = Cast<UClass>(Obj); if (ObjClass == NULL) { ObjClass = Obj->GetClass(); } check( ObjClass ); // Initialize with the class of the first object we encounter. if( BaseClass == NULL ) { BaseClass = ObjClass; } // If we've encountered an object that's not a subclass of the current best baseclass, // climb up a step in the class hierarchy. while( !ObjClass->IsChildOf( BaseClass.Get() ) ) { BaseClass = BaseClass->GetSuperClass(); } } } }
//------------------------------------------------------------------------------ bool UBlueprintBoundEventNodeSpawner::IsBindingCompatible(UObject const* BindingCandidate) const { bool bMatchesNodeType = false; if (NodeClass->IsChildOf<UK2Node_ComponentBoundEvent>()) { UObjectProperty const* BindingProperty = Cast<UObjectProperty>(BindingCandidate); bMatchesNodeType = (BindingProperty != nullptr); } else if (NodeClass->IsChildOf<UK2Node_ActorBoundEvent>()) { bMatchesNodeType = BindingCandidate->IsA<AActor>(); } const UMulticastDelegateProperty* Delegate = GetEventDelegate(); if ( !ensureMsgf(!FBlueprintNodeSpawnerUtils::IsStaleFieldAction(this), TEXT("Invalid BlueprintBoundEventNodeSpawner (for %s). Was the action database properly updated when this class was compiled?"), *Delegate->GetOwnerClass()->GetName())) { return false; } UClass* DelegateOwner = Delegate->GetOwnerClass()->GetAuthoritativeClass(); UClass* BindingClass = FBlueprintNodeSpawnerUtils::GetBindingClass(BindingCandidate)->GetAuthoritativeClass(); return bMatchesNodeType && BindingClass->IsChildOf(DelegateOwner) && !FObjectEditorUtils::IsVariableCategoryHiddenFromClass(Delegate, BindingClass); }
bool UOnlineHotfixManager::HotfixPakIniFile(const FString& FileName) { FConfigFile* ConfigFile = GetConfigFile(FileName); ConfigFile->Combine(FileName); UE_LOG(LogHotfixManager, Log, TEXT("Hotfix merged INI (%s) found in a PAK file"), *FileName); FName IniFileName(*FileName, FNAME_Find); int32 NumObjectsReloaded = 0; const double StartTime = FPlatformTime::Seconds(); // Now that we have a list of classes to update, we can iterate objects and // reload if they match the INI file that was changed for (FObjectIterator It; It; ++It) { UClass* Class = It->GetClass(); if (Class->HasAnyClassFlags(CLASS_Config) && Class->ClassConfigName == IniFileName) { // Force a reload of the config vars It->ReloadConfig(); NumObjectsReloaded++; } } UE_LOG(LogHotfixManager, Log, TEXT("Updating config from %s took %f seconds reloading %d objects"), *FileName, FPlatformTime::Seconds() - StartTime, NumObjectsReloaded); return true; }
void AActor::ResetPropertiesForConstruction() { // Get class CDO AActor* Default = GetClass()->GetDefaultObject<AActor>(); // RandomStream struct name to compare against const FName RandomStreamName(TEXT("RandomStream")); // We don't want to reset references to world object const bool bIsLevelScriptActor = IsA(ALevelScriptActor::StaticClass()); // Iterate over properties for( TFieldIterator<UProperty> It(GetClass()) ; It ; ++It ) { UProperty* Prop = *It; UStructProperty* StructProp = Cast<UStructProperty>(Prop); UClass* PropClass = CastChecked<UClass>(Prop->GetOuter()); // get the class that added this property // First see if it is a random stream, if so reset before running construction script if( (StructProp != NULL) && (StructProp->Struct != NULL) && (StructProp->Struct->GetFName() == RandomStreamName) ) { FRandomStream* StreamPtr = StructProp->ContainerPtrToValuePtr<FRandomStream>(this); StreamPtr->Reset(); } // If it is a blueprint added variable that is not editable per-instance, reset to default before running construction script else if( !bIsLevelScriptActor && Prop->HasAnyPropertyFlags(CPF_DisableEditOnInstance) && PropClass->HasAnyClassFlags(CLASS_CompiledFromBlueprint) && !Prop->IsA(UDelegateProperty::StaticClass()) && !Prop->IsA(UMulticastDelegateProperty::StaticClass()) ) { Prop->CopyCompleteValue_InContainer(this, Default); } } }
TSharedRef<SWidget> SContentReference::MakeAssetPickerMenu() { FContentBrowserModule& ContentBrowserModule = FModuleManager::Get().LoadModuleChecked<FContentBrowserModule>(TEXT("ContentBrowser")); FAssetPickerConfig AssetPickerConfig; UClass* FilterClass = AllowedClass.Get(); if (FilterClass != NULL) { AssetPickerConfig.Filter.ClassNames.Add(FilterClass->GetFName()); AssetPickerConfig.Filter.bRecursiveClasses = true; } AssetPickerConfig.OnAssetSelected = FOnAssetSelected::CreateSP(this, &SContentReference::OnAssetSelectedFromPicker); AssetPickerConfig.OnShouldFilterAsset = OnShouldFilterAsset; AssetPickerConfig.bAllowNullSelection = true; AssetPickerConfig.ThumbnailLabel = EThumbnailLabel::ClassName; AssetPickerConfig.InitialAssetViewType = InitialAssetViewType; return SNew(SBox) .WidthOverride(AssetPickerSizeOverride.Get().X) .HeightOverride(AssetPickerSizeOverride.Get().Y) [ ContentBrowserModule.Get().CreateAssetPicker(AssetPickerConfig) ]; }
UFunction* UK2Node_MakeArray::GetArrayAddFunction() const { UClass* ArrayLibClass = UKismetArrayLibrary::StaticClass(); UFunction* ReturnFunction = ArrayLibClass->FindFunctionByName(FName(TEXT("Array_Add"))); check(ReturnFunction); return ReturnFunction; }
FName FClassIconFinder::FindIconNameForClass(UClass* InClass, const FName& InDefaultName ) { FName BrushName = InDefaultName; const FSlateBrush* Brush = NULL; if ( InClass != NULL ) { // walk up class hierarchy until we find an icon UClass* ActorClass = InClass; while( (Brush == NULL || Brush == FEditorStyle::GetDefaultBrush()) && ActorClass && (ActorClass != AActor::StaticClass()) ) { BrushName = *FString::Printf( TEXT( "ClassIcon.%s" ), *ActorClass->GetName() ); Brush = FEditorStyle::GetBrush( BrushName ); ActorClass = ActorClass->GetSuperClass(); } } if( Brush == NULL || Brush == FEditorStyle::GetDefaultBrush() ) { // If we didn't supply an override name for the default icon use default class icon. if( InDefaultName == "" ) { BrushName = TEXT( "ClassIcon.Default" ); } else { BrushName = InDefaultName; } } return BrushName; }
void FBlueprintCompileReinstancer::UpdateBytecodeReferences() { BP_SCOPED_COMPILER_EVENT_STAT(EKismetReinstancerStats_UpdateBytecodeReferences); if(ClassToReinstance != NULL) { TMap<UObject*, UObject*> FieldMappings; GenerateFieldMappings(FieldMappings); for( auto DependentBP = Dependencies.CreateIterator(); DependentBP; ++DependentBP ) { UClass* BPClass = (*DependentBP)->GeneratedClass; // Skip cases where the class is junk, or haven't finished serializing in yet if( (BPClass == ClassToReinstance) || (BPClass->GetOutermost() == GetTransientPackage()) || BPClass->HasAnyClassFlags(CLASS_NewerVersionExists) || (BPClass->ClassGeneratedBy && BPClass->ClassGeneratedBy->HasAnyFlags(RF_NeedLoad|RF_BeingRegenerated)) ) { continue; } // For each function defined in this blueprint, run through the bytecode, and update any refs from the old properties to the new for( TFieldIterator<UFunction> FuncIter(BPClass, EFieldIteratorFlags::ExcludeSuper); FuncIter; ++FuncIter ) { UFunction* CurrentFunction = *FuncIter; if( CurrentFunction->Script.Num() > 0 ) { FArchiveReplaceObjectRef<UObject> ReplaceAr(CurrentFunction, FieldMappings, /*bNullPrivateRefs=*/ false, /*bIgnoreOuterRef=*/ true, /*bIgnoreArchetypeRef=*/ true); } } } } }
FPrimaryAssetId AAFCueActor::GetPrimaryAssetId() const { FName dupa1 = FPackageName::GetShortFName(GetOutermost()->GetFName()); const AAFCueActor* A = this; return FPrimaryAssetId(FPrimaryAssetType("ActorCue"), dupa1); //if (HasAnyFlags(RF_ClassDefaultObject)) { UClass* SearchNativeClass = GetClass(); while (SearchNativeClass && !SearchNativeClass->HasAnyClassFlags(CLASS_Native | CLASS_Intrinsic)) { SearchNativeClass = SearchNativeClass->GetSuperClass(); } if (SearchNativeClass && SearchNativeClass != GetClass()) { // If blueprint, return native class and asset name } // Native CDO, return nothing return FPrimaryAssetId(); } // Data assets use Class and ShortName by default, there's no inheritance so class works fine //return FPrimaryAssetId(GetClass()->GetFName(), GetFName()); }
TSharedRef<SWidget> SGraphPinObject::GenerateAssetPicker() { // This class and its children are the classes that we can show objects for UClass* AllowedClass = Cast<UClass>(GraphPinObj->PinType.PinSubCategoryObject.Get()); if (AllowedClass == NULL) { AllowedClass = UObject::StaticClass(); } FContentBrowserModule& ContentBrowserModule = FModuleManager::Get().LoadModuleChecked<FContentBrowserModule>(TEXT("ContentBrowser")); FAssetPickerConfig AssetPickerConfig; AssetPickerConfig.Filter.ClassNames.Add(AllowedClass->GetFName()); AssetPickerConfig.bAllowNullSelection = true; AssetPickerConfig.Filter.bRecursiveClasses = true; AssetPickerConfig.OnAssetSelected = FOnAssetSelected::CreateSP(this, &SGraphPinObject::OnAssetSelectedFromPicker); AssetPickerConfig.ThumbnailScale = 0; AssetPickerConfig.InitialAssetViewType = EAssetViewType::List; return SNew(SBox) .HeightOverride(300) .WidthOverride(300) [ SNew(SBorder) .BorderImage( FEditorStyle::GetBrush("Menu.Background") ) [ ContentBrowserModule.Get().CreateAssetPicker(AssetPickerConfig) ] ]; }
void FBlueprintNativeCodeGenModule::GenerateSingleStub(UBlueprint* BP, const TCHAR* PlatformName) { if (!ensure(BP)) { return; } UClass* Class = BP->GeneratedClass; if (!ensure(Class)) { return; } // no PCHFilename should be necessary const IAssetRegistry& Registry = FModuleManager::LoadModuleChecked<FAssetRegistryModule>("AssetRegistry").Get(); FAssetData AssetInfo = Registry.GetAssetByObjectPath(*Class->GetPathName()); FString FileContents; TUniquePtr<IBlueprintCompilerCppBackend> Backend_CPP(IBlueprintCompilerCppBackendModuleInterface::Get().Create()); // Apparently we can only generate wrappers for classes, so any logic that results in non classes requesting // wrappers will fail here: FileContents = Backend_CPP->GenerateWrapperForClass(Class); if (!FileContents.IsEmpty()) { FFileHelper::SaveStringToFile(FileContents , *(GetManifest(PlatformName).CreateUnconvertedDependencyRecord(AssetInfo.PackageName, AssetInfo).GeneratedWrapperPath) , ForcedEncoding()); } // The stub we generate still may have dependencies on other modules, so make sure the module dependencies are // still recorded so that the .build.cs is generated correctly. Without this you'll get include related errors // (or possibly linker errors) in stub headers: GetManifest(PlatformName).GatherModuleDependencies(BP->GetOutermost()); }
FString UMaterialGraphNode::GetDocumentationExcerptName() const { // Default the node to searching for an excerpt named for the C++ node class name, including the U prefix. // This is done so that the excerpt name in the doc file can be found by find-in-files when searching for the full class name. UClass* MyClass = (MaterialExpression != NULL) ? MaterialExpression->GetClass() : this->GetClass(); return FString::Printf(TEXT("%s%s"), MyClass->GetPrefixCPP(), *MyClass->GetName()); }
void AActor::PreEditUndo() { // Check if this Actor needs to be re-instanced UClass* OldClass = GetClass(); UClass* NewClass = OldClass->GetAuthoritativeClass(); if (NewClass != OldClass) { // Empty the OwnedComponents array, it's filled with invalid information OwnedComponents.Empty(); } // Since child actor components will rebuild themselves get rid of the Actor before we make changes TInlineComponentArray<UChildActorComponent*> ChildActorComponents; GetComponents(ChildActorComponents); for (UChildActorComponent* ChildActorComponent : ChildActorComponents) { if (ChildActorComponent->IsCreatedByConstructionScript()) { ChildActorComponent->DestroyChildActor(); } } // let navigation system know to not care about this actor anymore UNavigationSystem::ClearNavOctreeAll(this); Super::PreEditUndo(); }
UFunction* FindNetServiceFunctionById(int16 RPCId) { UFunction** Function = RPCFunctionMap.Find(RPCId); if (!Function) { for (TObjectIterator<UClass> ClassIt; ClassIt; ++ClassIt) { UClass* Class = *ClassIt; if (Class->IsChildOf(AActor::StaticClass()) && !(Class->HasAnyClassFlags(CLASS_Abstract | CLASS_Deprecated))) { for (TFieldIterator<UFunction> FuncIt(Class); FuncIt; ++FuncIt) { UFunction* CurFunc = *FuncIt; if (CurFunc->RPCId > 0) { RPCFunctionMap.Add(CurFunc->RPCId, CurFunc); } } } } Function = RPCFunctionMap.Find(RPCId); } return *Function; }
FString FComponentEditorUtils::GenerateValidVariableNameFromAsset(UObject* Asset, AActor* ComponentOwner) { int32 Counter = 1; FString AssetName = Asset->GetName(); UClass* Class = Cast<UClass>(Asset); if (Class) { if (!Class->HasAnyClassFlags(CLASS_CompiledFromBlueprint)) { AssetName.RemoveFromEnd(TEXT("Component")); } else { AssetName.RemoveFromEnd("_C"); } } // Try to create a name without any numerical suffix first FString ComponentInstanceName = AssetName; if (ComponentOwner) { while (!IsComponentNameAvailable(ComponentInstanceName, ComponentOwner)) { // Assign the lowest possible numerical suffix ComponentInstanceName = FString::Printf(TEXT("%s%d"), *AssetName, Counter++); } } return ComponentInstanceName; }
FText FSimpleAssetEditor::GetToolkitName() const { const TArray<UObject*>& EditingObjs = GetEditingObjects(); check( EditingObjs.Num() > 0 ); FFormatNamedArguments Args; Args.Add( TEXT("ToolkitName"), GetBaseToolkitName() ); if( EditingObjs.Num() == 1 ) { const UObject* EditingObject = EditingObjs[ 0 ]; const bool bDirtyState = EditingObject->GetOutermost()->IsDirty(); Args.Add( TEXT("ObjectName"), FText::FromString( EditingObject->GetName() ) ); Args.Add( TEXT("DirtyState"), bDirtyState ? FText::FromString( TEXT( "*" ) ) : FText::GetEmpty() ); return FText::Format( LOCTEXT("ToolkitTitle", "{ObjectName}{DirtyState} - {ToolkitName}"), Args ); } else { bool bDirtyState = false; UClass* SharedBaseClass = nullptr; for( int32 x = 0; x < EditingObjs.Num(); ++x ) { UObject* Obj = EditingObjs[ x ]; check( Obj ); UClass* ObjClass = Cast<UClass>(Obj); if (ObjClass == nullptr) { ObjClass = Obj->GetClass(); } check( ObjClass ); // Initialize with the class of the first object we encounter. if( SharedBaseClass == nullptr ) { SharedBaseClass = ObjClass; } // If we've encountered an object that's not a subclass of the current best baseclass, // climb up a step in the class hierarchy. while( !ObjClass->IsChildOf( SharedBaseClass ) ) { SharedBaseClass = SharedBaseClass->GetSuperClass(); } // If any of the objects are dirty, flag the label bDirtyState |= Obj->GetOutermost()->IsDirty(); } check(SharedBaseClass); Args.Add( TEXT("NumberOfObjects"), EditingObjs.Num() ); Args.Add( TEXT("ClassName"), FText::FromString( SharedBaseClass->GetName() ) ); Args.Add( TEXT("DirtyState"), bDirtyState ? FText::FromString( TEXT( "*" ) ) : FText::GetEmpty() ); return FText::Format( LOCTEXT("ToolkitTitle_EditingMultiple", "{NumberOfObjects} {ClassName}{DirtyState} - {ToolkitName}"), Args ); } }
FString UK2Node_BaseMCDelegate::GetDocumentationLink() const { UClass* ParentClass = NULL; if (DelegateReference.IsSelfContext()) { if (HasValidBlueprint()) { UField* Delegate = FindField<UField>(GetBlueprint()->GeneratedClass, DelegateReference.GetMemberName()); if (Delegate != NULL) { ParentClass = Delegate->GetOwnerClass(); } } } else { ParentClass = DelegateReference.GetMemberParentClass(this); } if ( ParentClass != NULL ) { return FString( TEXT("Shared/") ) + ParentClass->GetName(); } return TEXT(""); }
const FSlateBrush* FClassIconFinder::FindIconForActors(const TArray< TWeakObjectPtr<AActor> >& InActors, UClass*& CommonBaseClass) { // Get the common base class of the selected actors const FSlateBrush* CommonIcon = nullptr; for( int32 ActorIdx = 0; ActorIdx < InActors.Num(); ++ActorIdx ) { TWeakObjectPtr<AActor> Actor = InActors[ActorIdx]; UClass* ObjClass = Actor->GetClass(); if (!CommonBaseClass) { CommonBaseClass = ObjClass; } while (!ObjClass->IsChildOf(CommonBaseClass)) { CommonBaseClass = CommonBaseClass->GetSuperClass(); } const FSlateBrush* ActorIcon = FindIconForActor(Actor); if (!CommonIcon) { CommonIcon = ActorIcon; } if (CommonIcon != ActorIcon) { CommonIcon = FindIconForClass(CommonBaseClass); } } return CommonIcon; }
/** * Generates a list of assets from the ENGINE and the GAME by a specific type. * This is to be used by the GetTest() function. */ void FEditorAutomationTestUtilities::CollectTestsByClass(UClass * Class, TArray<FString>& OutBeautifiedNames, TArray <FString>& OutTestCommands) { FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry")); TArray<FAssetData> ObjectList; AssetRegistryModule.Get().GetAssetsByClass(Class->GetFName(), ObjectList); for (TObjectIterator<UClass> AllClassesIt; AllClassesIt; ++AllClassesIt) { UClass* ClassList = *AllClassesIt; FName ClassName = ClassList->GetFName(); } for (auto ObjIter = ObjectList.CreateConstIterator(); ObjIter; ++ObjIter) { const FAssetData& Asset = *ObjIter; FString Filename = Asset.ObjectPath.ToString(); //convert to full paths Filename = FPackageName::LongPackageNameToFilename(Filename); if (FAutomationTestFramework::GetInstance().ShouldTestContent(Filename)) { FString BeautifiedFilename = Asset.AssetName.ToString(); OutBeautifiedNames.Add(BeautifiedFilename); OutTestCommands.Add(Asset.ObjectPath.ToString()); } } }
void UClassProperty::Serialize( FArchive& Ar ) { Super::Serialize( Ar ); Ar << MetaClass; #if USE_CIRCULAR_DEPENDENCY_LOAD_DEFERRING if (Ar.IsLoading() || Ar.IsObjectReferenceCollector()) { if (ULinkerPlaceholderClass* PlaceholderClass = Cast<ULinkerPlaceholderClass>(MetaClass)) { PlaceholderClass->AddReferencingProperty(this); } } #endif // USE_CIRCULAR_DEPENDENCY_LOAD_DEFERRING if( !(MetaClass||HasAnyFlags(RF_ClassDefaultObject)) ) { // If we failed to load the MetaClass and we're not a CDO, that means we relied on a class that has been removed or doesn't exist. // The most likely cause for this is either an incomplete recompile, or if content was migrated between games that had native class dependencies // that do not exist in this game. We allow blueprint classes to continue, because compile on load will error out, and stub the class that was using it UClass* TestClass = dynamic_cast<UClass*>(GetOwnerStruct()); if( TestClass && TestClass->HasAllClassFlags(CLASS_Native) && !TestClass->HasAllClassFlags(CLASS_NewerVersionExists) && (TestClass->GetOutermost() != GetTransientPackage()) ) { checkf(false, TEXT("Class property tried to serialize a missing class. Did you remove a native class and not fully recompile?")); } } }
FText SPropertyEditorAsset::OnGetAssetClassName() const { UClass* Class = GetDisplayedClass(); if(Class) { return FText::FromString(Class->GetName()); } return FText::GetEmpty(); }
void UK2Node_SpawnActor::GetNodeAttributes( TArray<TKeyValuePair<FString, FString>>& OutNodeAttributes ) const { UClass* ClassToSpawn = GetClassToSpawn(); const FString ClassToSpawnStr = ClassToSpawn ? ClassToSpawn->GetName() : TEXT( "InvalidClass" ); OutNodeAttributes.Add( TKeyValuePair<FString, FString>( TEXT( "Type" ), TEXT( "SpawnActor" ) )); OutNodeAttributes.Add( TKeyValuePair<FString, FString>( TEXT( "Class" ), GetClass()->GetName() )); OutNodeAttributes.Add( TKeyValuePair<FString, FString>( TEXT( "Name" ), GetName() )); OutNodeAttributes.Add( TKeyValuePair<FString, FString>( TEXT( "ActorClass" ), ClassToSpawnStr )); }
UField* FMemberReference::FindRemappedField(UClass* InitialScope, FName InitialName, bool bInitialScopeMustBeOwnerOfField) { FFieldRemapInfo NewFieldInfo; bool bFoundReplacement = false; // Step up the class chain to check if us or any of our parents specify a redirect UClass* TestRemapClass = InitialScope; while( TestRemapClass != NULL ) { if( FindReplacementFieldName(TestRemapClass, InitialName, NewFieldInfo) ) { // Found it, stop our search bFoundReplacement = true; break; } TestRemapClass = TestRemapClass->GetSuperClass(); } // In the case of a bifurcation of a variable (e.g. moved from a parent into certain children), verify that we don't also define the variable in the current scope first if( bFoundReplacement && (FindField<UField>(InitialScope, InitialName) != nullptr)) { bFoundReplacement = false; } if( bFoundReplacement ) { const FName NewFieldName = NewFieldInfo.FieldName; UClass* SearchClass = (NewFieldInfo.FieldClass != NAME_None) ? (UClass*)StaticFindObject(UClass::StaticClass(), ANY_PACKAGE, *NewFieldInfo.FieldClass.ToString()) : (UClass*)TestRemapClass; // Find the actual field specified by the redirector, so we can return it and update the node that uses it UField* NewField = FindField<UField>(SearchClass, NewFieldInfo.FieldName); if( NewField != NULL ) { if (bInitialScopeMustBeOwnerOfField && !InitialScope->IsChildOf(SearchClass)) { UE_LOG(LogBlueprint, Log, TEXT("UK2Node: Unable to update field. Remapped field '%s' in not owned by given scope. Scope: '%s', Owner: '%s'."), *InitialName.ToString(), *InitialScope->GetName(), *NewFieldInfo.FieldClass.ToString()); } else { UE_LOG(LogBlueprint, Log, TEXT("UK2Node: Fixed up old field '%s' to new name '%s' on class '%s'."), *InitialName.ToString(), *NewFieldInfo.FieldName.ToString(), *SearchClass->GetName()); return NewField; } } else if (SearchClass != NULL) { UE_LOG(LogBlueprint, Log, TEXT("UK2Node: Unable to find updated field name for '%s' on class '%s'."), *InitialName.ToString(), *SearchClass->GetName()); } else { UE_LOG(LogBlueprint, Log, TEXT("UK2Node: Unable to find updated field name for '%s' on unknown class '%s'."), *InitialName.ToString(), *NewFieldInfo.FieldClass.ToString()); } } return NULL; }
FString SPropertyEditorAsset::OnGetAssetClassName() const { UClass* Class = GetDisplayedClass(); if(Class) { return Class->GetName(); } return FString(); }
void UActorAnimationPlayer::SpawnActorsForMovie(TSharedRef<FMovieSceneSequenceInstance> MovieSceneInstance) { UWorld* WorldPtr = World.Get(); if (WorldPtr == nullptr) { return; } UMovieScene* MovieScene = MovieSceneInstance->GetSequence()->GetMovieScene(); if (MovieScene == nullptr) { return; } TArray<FSpawnedActorInfo>* FoundSpawnedActors = InstanceToSpawnedActorMap.Find(MovieSceneInstance); if (FoundSpawnedActors != nullptr) { // Remove existing spawned actors for this movie DestroyActorsForMovie( MovieSceneInstance ); } TArray<FSpawnedActorInfo>& SpawnedActorList = InstanceToSpawnedActorMap.Add(MovieSceneInstance, TArray<FSpawnedActorInfo>()); for (auto SpawnableIndex = 0; SpawnableIndex < MovieScene->GetSpawnableCount(); ++SpawnableIndex) { auto& Spawnable = MovieScene->GetSpawnable(SpawnableIndex); UClass* GeneratedClass = Spawnable.GetClass(); if ((GeneratedClass == nullptr) || !GeneratedClass->IsChildOf(AActor::StaticClass())) { continue; } AActor* ActorCDO = CastChecked<AActor>(GeneratedClass->ClassDefaultObject); const FVector SpawnLocation = ActorCDO->GetRootComponent()->RelativeLocation; const FRotator SpawnRotation = ActorCDO->GetRootComponent()->RelativeRotation; FActorSpawnParameters SpawnInfo; { SpawnInfo.ObjectFlags = RF_NoFlags; } AActor* NewActor = WorldPtr->SpawnActor(GeneratedClass, &SpawnLocation, &SpawnRotation, SpawnInfo); if (NewActor) { // Actor was spawned OK! FSpawnedActorInfo NewInfo; { NewInfo.RuntimeGuid = Spawnable.GetGuid(); NewInfo.SpawnedActor = NewActor; } SpawnedActorList.Add(NewInfo); } } }