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; }
/** * 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; }
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; }
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 ); } }
//------------------------------------------------------------------------------ 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); }
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; }
// 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(); } } } }
void SMaterialPalette::RefreshAssetInRegistry(const FAssetData& InAddedAssetData) { // Grab the asset class, it will be checked for being a material function. UClass* Asset = FindObject<UClass>(ANY_PACKAGE, *InAddedAssetData.AssetClass.ToString()); if (Asset->IsChildOf(UMaterialFunction::StaticClass())) { RefreshActionsList(true); } }
void UK2Node_AddComponent::ValidateNodeDuringCompilation(FCompilerResultsLog& MessageLog) const { Super::ValidateNodeDuringCompilation(MessageLog); UActorComponent* Template = GetTemplateFromNode(); if (Template) { UClass* TemplateClass = Template->GetClass(); if (!TemplateClass->IsChildOf(UActorComponent::StaticClass()) || TemplateClass->HasAnyClassFlags(CLASS_Abstract) || !TemplateClass->HasMetaData(FBlueprintMetadata::MD_BlueprintSpawnableComponent) ) { FFormatNamedArguments Args; Args.Add(TEXT("TemplateClass"), FText::FromString(TemplateClass->GetName())); Args.Add(TEXT("NodeTitle"), GetNodeTitle(ENodeTitleType::FullTitle)); MessageLog.Error(*FText::Format(NSLOCTEXT("KismetCompiler", "InvalidComponentTemplate_Error", "Invalid class '{TemplateClass}' used as template by '{NodeTitle}' for @@"), Args).ToString(), this); } if (UChildActorComponent const* ChildActorComponent = Cast<UChildActorComponent const>(Template)) { UBlueprint const* Blueprint = GetBlueprint(); UClass const* ChildActorClass = ChildActorComponent->GetChildActorClass(); if (ChildActorClass == Blueprint->GeneratedClass) { UEdGraph const* ParentGraph = GetGraph(); UEdGraphSchema_K2 const* K2Schema = GetDefault<UEdGraphSchema_K2>(); if (K2Schema->IsConstructionScript(ParentGraph)) { FFormatNamedArguments Args; Args.Add(TEXT("ChildActorClass"), FText::FromString(ChildActorClass->GetName())); MessageLog.Error(*FText::Format(NSLOCTEXT("KismetCompiler", "AddSelfComponent_Error", "@@ cannot add a '{ChildActorClass}' component in the construction script (could cause infinite recursion)."), Args).ToString(), this); } } else if (ChildActorClass != nullptr) { AActor const* ChildActor = Cast<AActor>(ChildActorClass->ClassDefaultObject); check(ChildActor != nullptr); USceneComponent* RootComponent = ChildActor->GetRootComponent(); if ((RootComponent != nullptr) && (RootComponent->Mobility == EComponentMobility::Static) && (ChildActorComponent->Mobility != EComponentMobility::Static)) { FFormatNamedArguments Args; Args.Add(TEXT("ChildActorClass"), FText::FromString(ChildActorClass->GetName())); MessageLog.Error(*FText::Format(NSLOCTEXT("KismetCompiler", "AddStaticChildActorComponent_Error", "@@ cannot add a '{ChildActorClass}' component as it has static mobility, and the ChildActorComponent does not."), Args).ToString(), this); } } } } else { FFormatNamedArguments Args; Args.Add(TEXT("NodeTitle"), GetNodeTitle(ENodeTitleType::FullTitle)); MessageLog.Error(*FText::Format(NSLOCTEXT("KismetCompiler", "MissingComponentTemplate_Error", "Unknown template referenced by '{NodeTitle}' for @@"), Args).ToString(), this); } }
FThumbnailRenderingInfo* UThumbnailManager::GetRenderingInfo(UObject* Object) { // If something may have been GCed, empty the map so we don't crash if (bMapNeedsUpdate == true) { RenderInfoMap.Empty(); bMapNeedsUpdate = false; } check(Object); TArray<FThumbnailRenderingInfo>& ThumbnailTypes = RenderableThumbnailTypes; // Get the class to check against. UClass *ClassToCheck = ClassToCheck = Object->GetClass(); // Search for the cached entry and do the slower if not found FThumbnailRenderingInfo* RenderInfo = RenderInfoMap.FindRef(ClassToCheck); if (RenderInfo == nullptr) { // Loop through searching for the right thumbnail entry for (int32 Index = ThumbnailTypes.Num() - 1; (Index >= 0) && (RenderInfo == nullptr); Index--) { RenderInfo = &ThumbnailTypes[Index]; // See if this thumbnail renderer will work for the specified class or // if there is some data reason not to render the thumbnail if ((ClassToCheck->IsChildOf(RenderInfo->ClassNeedingThumbnail) == false) || (RenderInfo->Renderer == nullptr)) { RenderInfo = nullptr; } } // Make sure to add it to the cache if it is missing RenderInfoMap.Add(ClassToCheck, (RenderInfo != nullptr) ? RenderInfo : &NotSupported); } if ( RenderInfo && RenderInfo->Renderer ) { if ( !RenderInfo->Renderer->CanVisualizeAsset(Object) ) { // This is an asset with a thumbnail renderer, but it can't visualized (i.e it is something like a blueprint that doesn't contain any visible primitive components) RenderInfo = nullptr; } } // Check to see if this object is the "not supported" type or not if (RenderInfo == &NotSupported) { RenderInfo = nullptr; } return RenderInfo; }
bool SPropertyEditorAsset::ShouldDisplayThumbnail( const FArguments& InArgs ) { // Decide whether we should display the thumbnail or not bool bDisplayThumbnailByDefault = false; if(PropertyEditor.IsValid()) { UProperty* NodeProperty = PropertyEditor->GetPropertyNode()->GetProperty(); UClass* Class = GetObjectPropertyClass(NodeProperty); bDisplayThumbnailByDefault |= Class->IsChildOf(UMaterialInterface::StaticClass()) || Class->IsChildOf(UTexture::StaticClass()) || Class->IsChildOf(UStaticMesh::StaticClass()) || Class->IsChildOf(UStaticMeshComponent::StaticClass()) || Class->IsChildOf(USkeletalMesh::StaticClass()) || Class->IsChildOf(USkeletalMeshComponent::StaticClass()) || Class->IsChildOf(UParticleSystem::StaticClass()); } bool bDisplayThumbnail = ( bDisplayThumbnailByDefault || InArgs._DisplayThumbnail ) && InArgs._ThumbnailPool.IsValid(); if(PropertyEditor.IsValid()) { // also check metadata for thumbnail & text display if(InArgs._ThumbnailPool.IsValid()) { const UProperty* ArrayParent = PropertyEditorHelpers::GetArrayParent( *PropertyEditor->GetPropertyNode() ); const UProperty* SetParent = PropertyEditorHelpers::GetSetParent( *PropertyEditor->GetPropertyNode() ); const UProperty* MapParent = PropertyEditorHelpers::GetMapParent( *PropertyEditor->GetPropertyNode() ); const UProperty* PropertyToCheck = PropertyEditor->GetProperty(); if( ArrayParent != NULL ) { // If the property is a child of an array property, the parent will have the display thumbnail metadata PropertyToCheck = ArrayParent; } else if ( SetParent != NULL ) { PropertyToCheck = SetParent; } else if ( MapParent != NULL ) { PropertyToCheck = MapParent; } FString DisplayThumbnailString = PropertyToCheck->GetMetaData(TEXT("DisplayThumbnail")); if(DisplayThumbnailString.Len() > 0) { bDisplayThumbnail = DisplayThumbnailString == TEXT("true"); } } } return bDisplayThumbnail; }
void FGameplayCueTranslationManager::RefreshNameSwaps() { AllNameSwaps.Reset(); TArray<UGameplayCueTranslator*> CDOList; // Gather CDOs for( TObjectIterator<UClass> It ; It ; ++It ) { UClass* Class = *It; if( !Class->HasAnyClassFlags(CLASS_Abstract | CLASS_Deprecated) ) { if( Class->IsChildOf(UGameplayCueTranslator::StaticClass()) ) { UGameplayCueTranslator* CDO = Class->GetDefaultObject<UGameplayCueTranslator>(); if (CDO->IsEnabled()) { CDOList.Add(CDO); } } } } // Sort and get translated names CDOList.Sort([](const UGameplayCueTranslator& A, const UGameplayCueTranslator& B) { return (A.GetPriority() > B.GetPriority()); }); for (UGameplayCueTranslator* CDO : CDOList) { FNameSwapData& Data = AllNameSwaps[AllNameSwaps.AddDefaulted()]; CDO->GetTranslationNameSpawns(Data.NameSwaps); if (Data.NameSwaps.Num() > 0) { Data.ClassCDO = CDO; } else { AllNameSwaps.Pop(false); } } #if WITH_EDITOR // Give UniqueID to each rule int32 ID=1; for (FNameSwapData& GroupData : AllNameSwaps) { for (FGameplayCueTranslationNameSwap& SwapData : GroupData.NameSwaps) { SwapData.EditorData.UniqueID = ID++; } } #endif }
/** * Function to handle the projectile hitting something */ void AHealthPowerUp::OnHit(AActor* OtherActor, UPrimitiveComponent* OtherComp, FVector NormalImpulse, const FHitResult& Hit) { // Only add impulse and destroy projectile if we hit a physics if ((OtherActor != NULL) && (OtherActor != this) && (OtherComp != NULL)) { UClass* otherClass = OtherActor->GetClass(); if (otherClass->IsChildOf(AShip::StaticClass())){ AShip* otherShip = Cast<AShip>(OtherActor); otherShip->SetHealth(otherShip->GetMaxHealth()); Destroy(); } } }
/** * Function to handle the projectile hitting something */ void ABaseProjectile::OnHit(AActor* OtherActor, UPrimitiveComponent* OtherComp, FVector NormalImpulse, const FHitResult& Hit) { // Only add impulse and destroy projectile if we hit a physics if ((OtherActor != NULL) && (OtherActor != this) && (OtherComp != NULL)) { UClass* otherClass = OtherActor->GetClass(); /*if (OtherComp->IsSimulatingPhysics()) { OtherComp->AddImpulseAtLocation(GetVelocity() * 20.0f, GetActorLocation()); }*/ if (otherClass->IsChildOf(AShip::StaticClass())){ AShip* otherShip = Cast<AShip>(OtherActor); otherShip->HitByProjectile(this); Destroy(); } else if (!otherClass->IsChildOf(ABaseProjectile::StaticClass()) && !otherClass->IsChildOf(USphereComponent::StaticClass()) && !otherClass->IsChildOf(UStaticMeshComponent::StaticClass())){ Destroy(); } } }
FText FSimpleAssetEditor::GetToolkitToolTipText() 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 ]; return FAssetEditorToolkit::GetToolTipTextForObject(EditingObject); } else { UClass* SharedBaseClass = NULL; 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(); } } check(SharedBaseClass); Args.Add( TEXT("NumberOfObjects"), EditingObjs.Num() ); Args.Add( TEXT("ClassName"), FText::FromString( SharedBaseClass->GetName() ) ); return FText::Format( LOCTEXT("ToolkitTitle_EditingMultipleToolTip", "{NumberOfObjects} {ClassName} - {ToolkitName}"), Args ); } }
TOptional<ECurrentState> FAutoReimportManager::ProcessAdditions(const FTimeLimit& TimeLimit) { // Override the global feedback context while we do this to avoid popping up dialogs TGuardValue<FFeedbackContext*> ScopedContextOverride(GWarn, FeedbackContextOverride.Get()); TGuardValue<bool> ScopedAssetChangesGuard(bGuardAssetChanges, true); FeedbackContextOverride->GetContent()->SetMainText(GetProgressText()); TMap<FString, TArray<UFactory*>> Factories; TArray<FString> FactoryExtensions; FactoryExtensions.Reserve(16); // Get the list of valid factories for (TObjectIterator<UClass> It ; It ; ++It) { UClass* CurrentClass = (*It); if (CurrentClass->IsChildOf(UFactory::StaticClass()) && !(CurrentClass->HasAnyClassFlags(CLASS_Abstract))) { UFactory* Factory = Cast<UFactory>(CurrentClass->GetDefaultObject()); if (Factory->bEditorImport && Factory->ImportPriority >= 0) { FactoryExtensions.Reset(); Factory->GetSupportedFileExtensions(FactoryExtensions); for (const auto& Ext : FactoryExtensions) { auto& Array = Factories.FindOrAdd(Ext); Array.Add(Factory); } } } } for (auto& Pair : Factories) { Pair.Value.Sort([](const UFactory& A, const UFactory& B) { return A.ImportPriority > B.ImportPriority; }); } const IAssetRegistry& Registry = FModuleManager::LoadModuleChecked<FAssetRegistryModule>("AssetRegistry").Get(); for (auto& Monitor : DirectoryMonitors) { Monitor.ProcessAdditions(Registry, TimeLimit, PackagesToSave, Factories, *FeedbackContextOverride); yield TOptional<ECurrentState>(); } return ECurrentState::ProcessModifications; }
//------------------------------------------------------------------------------ static UClass* BlueprintActionMenuUtilsImpl::FindCommonBaseClass(TArray<UObject*> const& ObjectSet) { UClass* CommonClass = UObject::StaticClass(); if (ObjectSet.Num() > 0) { CommonClass = ObjectSet[0]->GetClass(); for (UObject const* Object : ObjectSet) { UClass* Class = Object->GetClass(); while (!Class->IsChildOf(CommonClass)) { CommonClass = CommonClass->GetSuperClass(); } } } return CommonClass; }
/** Callback for creating a new level sequence asset in the level. */ static void OnCreateActorInLevel() { // Create a new level sequence IAssetTools& AssetTools = FModuleManager::GetModuleChecked<FAssetToolsModule>("AssetTools").Get(); UObject* NewAsset = nullptr; // Attempt to create a new asset for (TObjectIterator<UClass> It ; It ; ++It) { UClass* CurrentClass = *It; if (CurrentClass->IsChildOf(UFactory::StaticClass()) && !(CurrentClass->HasAnyClassFlags(CLASS_Abstract))) { UFactory* Factory = Cast<UFactory>(CurrentClass->GetDefaultObject()); if (Factory->CanCreateNew() && Factory->ImportPriority >= 0 && Factory->SupportedClass == ULevelSequence::StaticClass()) { NewAsset = AssetTools.CreateAsset(ULevelSequence::StaticClass(), Factory); break; } } } if (!NewAsset) { return; } // Spawn an actor at the origin, and either move infront of the camera or focus camera on it (depending on the viewport) and open for edit UActorFactory* ActorFactory = GEditor->FindActorFactoryForActorClass(ALevelSequenceActor::StaticClass()); if (!ensure(ActorFactory)) { return; } ALevelSequenceActor* NewActor = CastChecked<ALevelSequenceActor>(GEditor->UseActorFactory(ActorFactory, FAssetData(NewAsset), &FTransform::Identity)); if (GCurrentLevelEditingViewportClient != nullptr && GCurrentLevelEditingViewportClient->IsPerspective()) { GEditor->MoveActorInFrontOfCamera(*NewActor, GCurrentLevelEditingViewportClient->GetViewLocation(), GCurrentLevelEditingViewportClient->GetViewRotation().Vector()); } else { GEditor->MoveViewportCamerasToActor(*NewActor, false); } FAssetEditorManager::Get().OpenEditorForAsset(NewAsset); }
const TCHAR* UClassProperty::ImportText_Internal( const TCHAR* Buffer, void* Data, int32 PortFlags, UObject* Parent, FOutputDevice* ErrorText ) const { const TCHAR* Result = UObjectProperty::ImportText_Internal( Buffer, Data, PortFlags, Parent, ErrorText ); if( Result ) { // Validate metaclass. UClass* C = (UClass*)GetObjectPropertyValue(Data); if (C && (!dynamic_cast<UClass*>(C) || !C->IsChildOf(MetaClass))) { // the object we imported doesn't implement our interface class ErrorText->Logf(TEXT("Invalid object '%s' specified for property '%s'"), *C->GetFullName(), *GetName()); SetObjectPropertyValue(Data, NULL); Result = NULL; } } return Result; }
void FClassBrowseHelper::BuildClassGraph() { UClass* RootNodeClass = UBTNode::StaticClass(); TArray<TSharedPtr<FClassDataNode> > NodeList; RootNode.Reset(); // gather all native classes for (TObjectIterator<UClass> It; It; ++It) { UClass* TestClass = *It; if (TestClass->HasAnyClassFlags(CLASS_Native) && TestClass->IsChildOf(RootNodeClass)) { TSharedPtr<FClassDataNode> NewNode = MakeShareable(new FClassDataNode); NewNode->ParentClassName = TestClass->GetSuperClass()->GetName(); FClassData NewData(TestClass); NewNode->Data = NewData; if (TestClass == RootNodeClass) { RootNode = NewNode; } NodeList.Add(NewNode); } } // gather all blueprints FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry")); TArray<FAssetData> BlueprintList; FARFilter Filter; Filter.ClassNames.Add(UBlueprint::StaticClass()->GetFName()); AssetRegistryModule.Get().GetAssets(Filter, BlueprintList); for (int32 i = 0; i < BlueprintList.Num(); i++) { TSharedPtr<FClassDataNode> NewNode = CreateClassDataNode(BlueprintList[i]); NodeList.Add(NewNode); } // build class tree AddClassGraphChildren(RootNode, NodeList); }
void UObjectPropertyBase::CheckValidObject(void* Value) const { UObject *Object = GetObjectPropertyValue(Value); if (Object) { // // here we want to make sure the the object value still matches the // object type expected by the property... UClass* ObjectClass = Object->GetClass(); // we could be in the middle of replacing references to the // PropertyClass itself (in the middle of an FArchiveReplaceObjectRef // pass)... if this is the case, then we might have already replaced // the object's class, but not the PropertyClass yet (or vise-versa)... // so we use this to ensure, in that situation, that we don't clear the // object value (if CLASS_NewerVersionExists is set, then we are likely // in the middle of an FArchiveReplaceObjectRef pass) bool bIsReplacingClassRefs = PropertyClass && PropertyClass->HasAnyClassFlags(CLASS_NewerVersionExists) != ObjectClass->HasAnyClassFlags(CLASS_NewerVersionExists); #if USE_CIRCULAR_DEPENDENCY_LOAD_DEFERRING FLinkerLoad* PropertyLinker = GetLinker(); bool const bIsDeferringValueLoad = ((PropertyLinker == nullptr) || (PropertyLinker->LoadFlags & LOAD_DeferDependencyLoads)) && (Object->IsA<ULinkerPlaceholderExportObject>() || Object->IsA<ULinkerPlaceholderClass>()); #if USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS check( bIsDeferringValueLoad || (!Object->IsA<ULinkerPlaceholderExportObject>() && !Object->IsA<ULinkerPlaceholderClass>()) ); #endif // USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS #else // USE_CIRCULAR_DEPENDENCY_LOAD_DEFERRING bool const bIsDeferringValueLoad = false; #endif // USE_CIRCULAR_DEPENDENCY_LOAD_DEFERRING if ((PropertyClass != nullptr) && !ObjectClass->IsChildOf(PropertyClass) && !bIsReplacingClassRefs && !bIsDeferringValueLoad) { UE_LOG(LogProperty, Warning, TEXT("Serialized %s for a property of %s. Reference will be NULLed.\n Property = %s\n Item = %s"), *Object->GetClass()->GetFullName(), *PropertyClass->GetFullName(), *GetFullName(), *Object->GetFullName() ); SetObjectPropertyValue(Value, NULL); } } }
//------------------------------------------------------------------------------ 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(); UClass* DelegateOwner = Delegate->GetOwnerClass()->GetAuthoritativeClass(); UClass* BindingClass = FBlueprintNodeSpawnerUtils::GetBindingClass(BindingCandidate)->GetAuthoritativeClass(); return bMatchesNodeType && BindingClass->IsChildOf(DelegateOwner) && !FObjectEditorUtils::IsVariableCategoryHiddenFromClass(Delegate, BindingClass); }
void UEdGraphSchema::GetGraphContextActions(FGraphContextMenuBuilder& ContextMenuBuilder) const { #if WITH_EDITOR // Run thru all nodes and add any menu items they want to add for (TObjectIterator<UClass> ClassIt; ClassIt; ++ClassIt) { UClass* Class = *ClassIt; if (Class->IsChildOf(UEdGraphNode::StaticClass()) && !Class->HasAnyClassFlags(CLASS_Abstract | CLASS_Deprecated)) { const UEdGraphNode* ClassCDO = Class->GetDefaultObject<UEdGraphNode>(); if (ClassCDO->CanCreateUnderSpecifiedSchema(this)) { ClassCDO->GetMenuEntries(ContextMenuBuilder); } } } #endif }
bool SPropertyEditorAsset::CanSetBasedOnCustomClasses( const FAssetData& InAssetData ) const { bool bAllowedToSetBasedOnFilter = true; if( InAssetData.IsValid() && CustomClassFilters.Num() > 0 ) { bAllowedToSetBasedOnFilter = false; UClass* AssetClass = InAssetData.GetClass(); for( const UClass* AllowedClass : CustomClassFilters ) { if( AssetClass->IsChildOf( AllowedClass ) ) { bAllowedToSetBasedOnFilter = true; break; } } } return bAllowedToSetBasedOnFilter; }
void SGAAttributeWidget::Construct(const FArguments& InArgs) { AttributesList.Empty(); AttributesNodes.Empty(); OnAttributeSelected = InArgs._OnAttributeSelectedIn; for (TObjectIterator<UClass> ClassIt; ClassIt; ++ClassIt) { UClass* Class = *ClassIt; if (Class->IsChildOf(UGAAttributesBase::StaticClass()) && !FKismetEditorUtilities::IsClassABlueprintSkeleton(Class)) { FString className = Class->GetName(); if (!className.Contains(TEXT("REINST_"))) { TSharedPtr<FGAAttributeNode> attributeNode = MakeShareable(new FGAAttributeNode()); attributeNode->Attribute = className; for (TFieldIterator<UProperty> PropertyIt(Class, EFieldIteratorFlags::ExcludeSuper); PropertyIt; ++PropertyIt) { UProperty* Prop = *PropertyIt; //I need array within array, one for list of attributes, and one for class names. // TSharedPtr<FString> attribute = MakeShareable(new FString(Prop->GetName())); attributeNode->AttributeNames.Add(Prop->GetName()); //AttributesList.Add(attribute); } AttributesNodes.Add(attributeNode); } } } ChildSlot [ SAssignNew(AttributeTreeWidget, STreeView<TSharedPtr<FGAAttributeNode>>) .OnSelectionChanged(this, &SGAAttributeWidget::OnItemSelected) .TreeItemsSource(&AttributesNodes) .OnGenerateRow(this, &SGAAttributeWidget::OnGenerateRow) .OnGetChildren(this, &SGAAttributeWidget::OnGetChildren) .OnExpansionChanged(this, &SGAAttributeWidget::OnExpansionChanged) .SelectionMode(ESelectionMode::Single) ]; }
bool SPropertyEditorAsset::CanSetBasedOnCustomClasses( const FAssetData& InAssetData ) const { bool bAllowedToSetBasedOnFilter = true; if( InAssetData.IsValid() && CustomClassFilters.Num() > 0 ) { bAllowedToSetBasedOnFilter = false; UClass* AssetClass = InAssetData.GetClass(); for( const UClass* AllowedClass : CustomClassFilters ) { const bool bAllowedClassIsInterface = AllowedClass->HasAnyClassFlags(CLASS_Interface); if( AssetClass->IsChildOf( AllowedClass ) || (bAllowedClassIsInterface && AssetClass->ImplementsInterface(AllowedClass)) ) { bAllowedToSetBasedOnFilter = true; break; } } } return bAllowedToSetBasedOnFilter; }
void FAssetTypeActions_EditorUtilityBlueprint::ExecuteGlobalBlutility(TWeakObjectPtr<UEditorUtilityBlueprint> InObject) { if (auto Object = InObject.Get()) { // The menu option should ONLY be available if there is only one blueprint selected, validated by the menu creation code UBlueprint* TargetBP = Object; UClass* TargetClass = TargetBP->GeneratedClass; if (!TargetClass->IsChildOf(UGlobalEditorUtilityBase::StaticClass())) { FMessageDialog::Open(EAppMsgType::Ok, LOCTEXT("GlobalBlUtilitiesOnly", "Can only invoke global blutilities.")); return; } // Launch the blutility TArray<UObject*> ObjList; ObjList.Add(Object); OpenAssetEditor(ObjList, NULL); } }
//------------------------------------------------------------------------------ bool FLinkerPlaceholderBase::AddReferencingPropertyValue(const UObjectProperty* ReferencingProperty, void* DataPtr) { TArray<UObject*>& PossibleReferencers = FPlaceholderContainerTracker::Get().PerspectiveReferencerStack; UObject* FoundReferencer = nullptr; // iterate backwards because this is meant to act as a stack, where the last // entry is most likely the one we're looking for for (int32 CandidateIndex = PossibleReferencers.Num() - 1; CandidateIndex >= 0; --CandidateIndex) { UObject* ReferencerCandidate = PossibleReferencers[CandidateIndex]; UClass* CandidateClass = ReferencerCandidate->GetClass(); UClass* PropOwnerClass = ReferencingProperty->GetOwnerClass(); if (CandidateClass->IsChildOf(PropOwnerClass)) { FoundReferencer = ReferencerCandidate; break; } } #if USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS check(ReferencingProperty->GetObjectPropertyValue(DataPtr) == GetPlaceholderAsUObject()); check(FoundReferencer != nullptr); #endif // USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS if (FoundReferencer != nullptr) { #if USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS // @TODO: verify that DataPtr belongs to FoundReferencer // uint8* ContainerStart = (uint8*)FoundReferencer; // uint8* ContainerEnd = ContainerStart + FoundReferencer->GetClass()->GetStructureSize(); // // check that we picked the right container object, and that DataPtr exists within it // check(DataPtr >= ContainerStart && DataPtr <= ContainerEnd); #endif // USE_DEFERRED_DEPENDENCY_CHECK_VERIFICATION_TESTS ReferencingContainers.FindOrAdd(FoundReferencer).Add(ReferencingProperty); } return (FoundReferencer != nullptr); }
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); } } }
void URuntimeMovieScenePlayer::SpawnActorsForMovie( TSharedRef<FMovieSceneInstance> MovieSceneInstance ) { UWorld* WorldPtr = World.Get(); if( WorldPtr != NULL && MovieSceneBindings != NULL ) { UMovieScene* MovieScene = MovieSceneInstance->GetMovieScene(); if( MovieScene != NULL ) { TArray<FSpawnedActorInfo>* FoundSpawnedActors = InstanceToSpawnedActorMap.Find( MovieSceneInstance ); if( FoundSpawnedActors ) { // 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 != NULL ) { const bool bIsActorBlueprint = GeneratedClass->IsChildOf( AActor::StaticClass() ); if ( bIsActorBlueprint ) { 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 ); } } } } } } }