本文整理汇总了C++中UClass::GetDefaultObject方法的典型用法代码示例。如果您正苦于以下问题:C++ UClass::GetDefaultObject方法的具体用法?C++ UClass::GetDefaultObject怎么用?C++ UClass::GetDefaultObject使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类UClass
的用法示例。
在下文中一共展示了UClass::GetDefaultObject方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: GetAssetRegistryTags
void UBlueprint::GetAssetRegistryTags(TArray<FAssetRegistryTag>& OutTags) const
{
UClass* GenClass = Cast<UClass>(GeneratedClass);
if ( GenClass && GenClass->GetDefaultObject() )
{
GenClass->GetDefaultObject()->GetAssetRegistryTags(OutTags);
}
Super::GetAssetRegistryTags(OutTags);
FString ParentClassPackageName;
if ( ParentClass )
{
ParentClassPackageName = ParentClass->GetOutermost()->GetName();
}
else
{
ParentClassPackageName = TEXT("None");
}
//NumReplicatedProperties
int32 NumReplicatedProperties = 0;
UBlueprintGeneratedClass* BlueprintClass = Cast<UBlueprintGeneratedClass>(GenClass);
if (BlueprintClass)
{
NumReplicatedProperties = BlueprintClass->NumReplicatedProperties;
}
OutTags.Add(FAssetRegistryTag("NumReplicatedProperties", FString::FromInt(NumReplicatedProperties), FAssetRegistryTag::TT_Numerical));
OutTags.Add(FAssetRegistryTag("ParentClassPackage", ParentClassPackageName, FAssetRegistryTag::TT_Hidden));
OutTags.Add(FAssetRegistryTag(GET_MEMBER_NAME_CHECKED(UBlueprint, BlueprintDescription), BlueprintDescription, FAssetRegistryTag::TT_Hidden));
uint32 ClassFlagsTagged = 0;
if (BlueprintClass)
{
ClassFlagsTagged = BlueprintClass->GetClassFlags();
}
else
{
ClassFlagsTagged = GetClass()->GetClassFlags();
}
OutTags.Add( FAssetRegistryTag("ClassFlags", FString::FromInt(ClassFlagsTagged), FAssetRegistryTag::TT_Hidden) );
FKismetEditorUtilities::GetAssetRegistryTagsForBlueprint(this, OutTags);
OutTags.Add( FAssetRegistryTag( "IsDataOnly",
FBlueprintEditorUtils::IsDataOnlyBlueprint(this) ? TEXT("True") : TEXT("False"),
FAssetRegistryTag::TT_Alphabetical ) );
}
示例2: InitializeResaveParameters
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;
}
示例3: GetValueBaseAddress
/**
* Calculates the memory address for the data associated with this item's property. This is typically the value of a UProperty or a UObject address.
*
* @param StartAddress the location to use as the starting point for the calculation; typically the address of the object that contains this property.
*
* @return a pointer to a UProperty value or UObject. (For dynamic arrays, you'd cast this value to an FArray*)
*/
uint8* FObjectPropertyNode::GetValueBaseAddress( uint8* StartAddress )
{
uint8* Result = StartAddress;
UClass* ClassObject;
if ( (ClassObject=Cast<UClass>((UObject*)Result)) != NULL )
{
Result = (uint8*)ClassObject->GetDefaultObject();
}
return Result;
}
示例4: OnCreateActorInLevel
/** 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);
}
示例5: ScopedContextOverride
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;
}
示例6: CanEditNativeComponent
bool FComponentEditorUtils::CanEditNativeComponent(const UActorComponent* NativeComponent)
{
// A native component can be edited if it is bound to a member variable and that variable is marked as visible in the editor
// Note: We aren't concerned with whether the component is marked editable - the component itself is responsible for determining which of its properties are editable
bool bCanEdit = false;
UClass* OwnerClass = (NativeComponent && NativeComponent->GetOwner()) ? NativeComponent->GetOwner()->GetClass() : nullptr;
if (OwnerClass != nullptr)
{
// If the owner is a blueprint generated class, use the BP parent class
UBlueprint* Blueprint = UBlueprint::GetBlueprintFromClass(OwnerClass);
if (Blueprint != nullptr && Blueprint->ParentClass != nullptr)
{
OwnerClass = Blueprint->ParentClass;
}
for (TFieldIterator<UProperty> It(OwnerClass); It; ++It)
{
UProperty* Property = *It;
if (UObjectProperty* ObjectProp = Cast<UObjectProperty>(Property))
{
// Must be visible - note CPF_Edit is set for all properties that should be visible, not just those that are editable
if (( Property->PropertyFlags & ( CPF_Edit ) ) == 0)
{
continue;
}
UObject* ParentCDO = OwnerClass->GetDefaultObject();
if (!NativeComponent->GetClass()->IsChildOf(ObjectProp->PropertyClass))
{
continue;
}
UObject* Object = ObjectProp->GetObjectPropertyValue(ObjectProp->ContainerPtrToValuePtr<void>(ParentCDO));
bCanEdit = Object != nullptr && Object->GetFName() == NativeComponent->GetFName();
if (bCanEdit)
{
break;
}
}
}
}
return bCanEdit;
}
示例7: GenerateListOfExistingNames
void USimpleConstructionScript::GenerateListOfExistingNames(TArray<FName>& CurrentNames) const
{
TArray<const USCS_Node*> ChildrenNodes = GetAllNodesConst();
const UBlueprintGeneratedClass* OwnerClass = Cast<const UBlueprintGeneratedClass>(GetOuter());
const UBlueprint* Blueprint = Cast<const UBlueprint>(OwnerClass ? OwnerClass->ClassGeneratedBy : NULL);
// >>> Backwards Compatibility: VER_UE4_EDITORONLY_BLUEPRINTS
if (!Blueprint)
{
Blueprint = Cast<UBlueprint>(GetOuter());
}
// <<< End Backwards Compatibility
check(Blueprint);
TArray<UObject*> NativeCDOChildren;
UClass* FirstNativeClass = FBlueprintEditorUtils::FindFirstNativeClass(Blueprint->ParentClass);
GetObjectsWithOuter(FirstNativeClass->GetDefaultObject(), NativeCDOChildren, false);
for (UObject* NativeCDOChild : NativeCDOChildren)
{
CurrentNames.Add(NativeCDOChild->GetFName());
}
if (Blueprint->SkeletonGeneratedClass)
{
// First add the class variables.
FBlueprintEditorUtils::GetClassVariableList(Blueprint, CurrentNames, true);
// Then the function names.
FBlueprintEditorUtils::GetFunctionNameList(Blueprint, CurrentNames);
}
// And add their names
for (int32 NodeIndex = 0; NodeIndex < ChildrenNodes.Num(); ++NodeIndex)
{
const USCS_Node* ChildNode = ChildrenNodes[NodeIndex];
if (ChildNode)
{
if (ChildNode->VariableName != NAME_None)
{
CurrentNames.Add(ChildNode->VariableName);
}
}
}
if (GetDefaultSceneRootNode())
{
CurrentNames.AddUnique(GetDefaultSceneRootNode()->GetVariableName());
}
}
示例8: ReconstructClassDefaultObject
void FHotReloadClassReinstancer::ReconstructClassDefaultObject(UClass* InClass, UObject* InOuter, FName InName, EObjectFlags InFlags)
{
// Get the parent CDO
UClass* ParentClass = InClass->GetSuperClass();
UObject* ParentDefaultObject = NULL;
if (ParentClass != NULL)
{
ParentDefaultObject = ParentClass->GetDefaultObject(); // Force the default object to be constructed if it isn't already
}
// Re-create
InClass->ClassDefaultObject = StaticAllocateObject(InClass, InOuter, InName, InFlags, false);
check(InClass->ClassDefaultObject);
const bool bShouldInitilizeProperties = false;
const bool bCopyTransientsFromClassDefaults = false;
(*InClass->ClassConstructor)(FObjectInitializer(InClass->ClassDefaultObject, ParentDefaultObject, bCopyTransientsFromClassDefaults, bShouldInitilizeProperties));
}
示例9: FindVariableNameGivenComponentInstance
FName FComponentEditorUtils::FindVariableNameGivenComponentInstance(UActorComponent* ComponentInstance)
{
check(ComponentInstance != nullptr);
// First see if the name just works
if (AActor* OwnerActor = ComponentInstance->GetOwner())
{
UClass* OwnerActorClass = OwnerActor->GetClass();
if (UObjectProperty* TestProperty = FindField<UObjectProperty>(OwnerActorClass, ComponentInstance->GetFName()))
{
if (ComponentInstance->GetClass()->IsChildOf(TestProperty->PropertyClass))
{
return TestProperty->GetFName();
}
}
}
// Name mismatch, try finding a differently named variable pointing to the the component (the mismatch should only be possible for native components)
if (UActorComponent* Archetype = Cast<UActorComponent>(ComponentInstance->GetArchetype()))
{
if (AActor* OwnerActor = Archetype->GetOwner())
{
UClass* OwnerClass = OwnerActor->GetClass();
AActor* OwnerCDO = CastChecked<AActor>(OwnerClass->GetDefaultObject());
check(OwnerCDO->HasAnyFlags(RF_ClassDefaultObject));
for (TFieldIterator<UObjectProperty> PropIt(OwnerClass, EFieldIteratorFlags::IncludeSuper); PropIt; ++PropIt)
{
UObjectProperty* TestProperty = *PropIt;
if (Archetype->GetClass()->IsChildOf(TestProperty->PropertyClass))
{
void* TestPropertyInstanceAddress = TestProperty->ContainerPtrToValuePtr<void>(OwnerCDO);
UObject* ObjectPointedToByProperty = TestProperty->GetObjectPropertyValue(TestPropertyInstanceAddress);
if (ObjectPointedToByProperty == Archetype)
{
// This property points to the component archetype, so it's an anchor even if it was named wrong
return TestProperty->GetFName();
}
}
}
}
}
return NAME_None;
}
示例10:
FFindHeadersToInclude(FGatherConvertedClassDependencies& InDependencies)
: FGatherConvertedClassDependenciesHelperBase(InDependencies)
{
FindReferences(Dependencies.GetActualStruct());
// special case - literal enum
UBlueprintGeneratedClass* BPGC = Cast<UBlueprintGeneratedClass>(Dependencies.GetActualStruct());
UBlueprint* BP = BPGC ? Cast<UBlueprint>(BPGC->ClassGeneratedBy) : nullptr;
if (BP)
{
TArray<UEdGraph*> Graphs;
BP->GetAllGraphs(Graphs);
for (UEdGraph* Graph : Graphs)
{
if (Graph)
{
TArray<UK2Node_EnumLiteral*> LiteralEnumNodes;
Graph->GetNodesOfClass<UK2Node_EnumLiteral>(LiteralEnumNodes);
for (UK2Node_EnumLiteral* LiteralEnumNode : LiteralEnumNodes)
{
UEnum* Enum = LiteralEnumNode ? LiteralEnumNode->Enum : nullptr;
IncludeTheHeaderInBody(Enum);
}
}
}
}
// Include classes of native subobjects
if (BPGC)
{
UClass* NativeSuperClass = BPGC->GetSuperClass();
for (; NativeSuperClass && !NativeSuperClass->HasAnyClassFlags(CLASS_Native); NativeSuperClass = NativeSuperClass->GetSuperClass())
{}
UObject* NativeCDO = NativeSuperClass ? NativeSuperClass->GetDefaultObject(false) : nullptr;
if (NativeCDO)
{
TArray<UObject*> DefaultSubobjects;
NativeCDO->GetDefaultSubobjects(DefaultSubobjects);
for (UObject* DefaultSubobject : DefaultSubobjects)
{
IncludeTheHeaderInBody(DefaultSubobject ? DefaultSubobject->GetClass() : nullptr);
}
}
}
}
开发者ID:zhaoyizheng0930,项目名称:UnrealEngine,代码行数:45,代码来源:BlueprintCompilerCppBackendGatherDependencies.cpp
示例11: EventTickName
bool UK2Node_Event::IsCosmeticTickEvent() const
{
// Special case for EventTick/ReceiveTick that is conditionally executed by a separate bool rather than function flag.
static const FName EventTickName(TEXT("ReceiveTick"));
if (EventSignatureName == EventTickName)
{
const UBlueprint* Blueprint = GetBlueprint();
if (Blueprint)
{
UClass* BPClass = Blueprint->GeneratedClass;
const AActor* DefaultActor = BPClass ? Cast<const AActor>(BPClass->GetDefaultObject()) : NULL;
if (DefaultActor && !DefaultActor->AllowReceiveTickEventOnDedicatedServer())
{
return true;
}
}
}
return false;
}
示例12: PropagatePuppetActorChanges
void FSequencerActorBindingManager::PropagatePuppetActorChanges( const TSharedRef< FPuppetActorInfo > PuppetActorInfo )
{
AActor* PuppetActor = PuppetActorInfo->PuppetActor.Get();
AActor* TargetActor = NULL;
{
// Find the spawnable for this puppet actor
FMovieSceneSpawnable* FoundSpawnable = NULL;
TArray< UMovieScene* > MovieScenesBeingEdited = Sequencer.Pin()->GetMovieScenesBeingEdited();
for( auto CurMovieSceneIt( MovieScenesBeingEdited.CreateIterator() ); CurMovieSceneIt; ++CurMovieSceneIt )
{
auto CurMovieScene = *CurMovieSceneIt;
FoundSpawnable = CurMovieScene->FindSpawnable( PuppetActorInfo->SpawnableGuid );
if( FoundSpawnable != NULL )
{
break;
}
}
if (ensure( FoundSpawnable != NULL && PuppetActor != NULL ))
{
UClass* ActorClass = FoundSpawnable->GetClass();
// The puppet actor's class should always be the blueprint that it was spawned from!
UClass* SpawnedActorClass = PuppetActor->GetClass();
check( ActorClass == SpawnedActorClass );
// We'll be copying properties into the class default object of the Blueprint's generated class
TargetActor = CastChecked<AActor>( ActorClass->GetDefaultObject() );
}
}
if( PuppetActor != NULL && TargetActor != NULL )
{
Sequencer.Pin()->CopyActorProperties( PuppetActor, TargetActor );
}
}
示例13: IsSteamNetDriverAvailable
bool NUTNet::IsSteamNetDriverAvailable()
{
bool bReturnVal = false;
UGameEngine* GameEngine = Cast<UGameEngine>(GEngine);
if (GameEngine != NULL)
{
bool bFoundSteamDriver = false;
const TCHAR* SteamDriverClassName = TEXT("OnlineSubsystemSteam.SteamNetDriver");
for (int i=0; i<GameEngine->NetDriverDefinitions.Num(); i++)
{
if (GameEngine->NetDriverDefinitions[i].DefName == NAME_GameNetDriver)
{
if (GameEngine->NetDriverDefinitions[i].DriverClassName == SteamDriverClassName)
{
bFoundSteamDriver = true;
}
break;
}
}
if (bFoundSteamDriver)
{
UClass* SteamNetDriverClass = StaticLoadClass(UNetDriver::StaticClass(), NULL, SteamDriverClassName, NULL, LOAD_Quiet);
if (SteamDriverClassName != NULL)
{
UNetDriver* SteamNetDriverDef = Cast<UNetDriver>(SteamNetDriverClass->GetDefaultObject());
bReturnVal = SteamNetDriverDef != NULL && SteamNetDriverDef->IsAvailable();
}
}
}
return bReturnVal;
}
示例14: GetAllFactoryExtensions
FString FAutoReimportManager::GetAllFactoryExtensions()
{
FString AllExtensions;
// Use a scratch buffer to avoid unnecessary re-allocation
FString Scratch;
Scratch.Reserve(32);
for (TObjectIterator<UClass> ClassIt; ClassIt; ++ClassIt)
{
UClass* Class = *ClassIt;
if (Class->IsChildOf(UFactory::StaticClass()) && !Class->HasAnyClassFlags(CLASS_Abstract))
{
UFactory* Factory = Cast<UFactory>(Class->GetDefaultObject());
if (Factory->bEditorImport)
{
for (const FString& Format : Factory->Formats)
{
int32 Index = INDEX_NONE;
if (Format.FindChar(';', Index) && Index > 0)
{
Scratch.GetCharArray().Reset();
// Include the ;
Scratch.AppendChars(*Format, Index + 1);
if (AllExtensions.Find(Scratch) == INDEX_NONE)
{
AllExtensions += Scratch;
}
}
}
}
}
}
return AllExtensions;
}
示例15: CreatePin
void UK2Node_Switch::CreateFunctionPin()
{
// Set properties on the function pin
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
UEdGraphPin* FunctionPin = CreatePin(EGPD_Input, K2Schema->PC_Object, TEXT(""), FunctionClass, false, false, FunctionName.ToString());
FunctionPin->bDefaultValueIsReadOnly = true;
FunctionPin->bNotConnectable = true;
FunctionPin->bHidden = true;
UFunction* Function = FindField<UFunction>(FunctionClass, FunctionName);
const bool bIsStaticFunc = Function->HasAllFunctionFlags(FUNC_Static);
if (bIsStaticFunc)
{
// Wire up the self to the CDO of the class if it's not us
if (UBlueprint* BP = GetBlueprint())
{
UClass* FunctionOwnerClass = Function->GetOuterUClass();
if (!BP->SkeletonGeneratedClass->IsChildOf(FunctionOwnerClass))
{
FunctionPin->DefaultObject = FunctionOwnerClass->GetDefaultObject();
}
}
}
}