void ARadiantWebViewActor::BindDynamicMaterial() { if ((GetNetMode() != NM_DedicatedServer) && MeshComponent && (WebViewRenderComponent->WebView->WebViewCanvas)) { if (OldMeshMaterial) { MeshComponent->SetMaterial(OldMaterialIndex, OldMeshMaterial); } OldMeshMaterial = MeshComponent->GetMaterial(MaterialIndex); if (WebViewMID) { WebViewMID->MarkPendingKill(); } if (ReplaceMaterial) { WebViewMID = UMaterialInstanceDynamic::Create(ReplaceMaterial, GetTransientPackage()); } else if (OldMeshMaterial) { WebViewMID = UMaterialInstanceDynamic::Create(OldMeshMaterial, GetTransientPackage()); } if (WebViewMID) { WebViewMID->SetTextureParameterValue(TEXT("WebViewTexture"), WebViewRenderComponent->WebView->WebViewCanvas->RenderTargetTexture); } } }
FPreviewScene::FPreviewScene(FPreviewScene::ConstructionValues CVS) : PreviewWorld(NULL) , bForceAllUsedMipsResident(CVS.bForceMipsResident) { PreviewWorld = NewObject<UWorld>(); PreviewWorld->WorldType = EWorldType::Preview; if (CVS.bTransactional) { PreviewWorld->SetFlags(RF_Transactional); } FWorldContext& WorldContext = GEngine->CreateNewWorldContext(EWorldType::Preview); WorldContext.SetCurrentWorld(PreviewWorld); PreviewWorld->InitializeNewWorld(UWorld::InitializationValues() .AllowAudioPlayback(CVS.bAllowAudioPlayback) .CreatePhysicsScene(CVS.bCreatePhysicsScene) .RequiresHitProxies(false) .CreateNavigation(false) .CreateAISystem(false) .ShouldSimulatePhysics(CVS.bShouldSimulatePhysics) .SetTransactional(CVS.bTransactional)); PreviewWorld->InitializeActorsForPlay(FURL()); GetScene()->UpdateDynamicSkyLight(FLinearColor::White * CVS.SkyBrightness, FLinearColor::Black); DirectionalLight = NewObject<UDirectionalLightComponent>(GetTransientPackage()); DirectionalLight->Intensity = CVS.LightBrightness; DirectionalLight->LightColor = FColor::White; AddComponent(DirectionalLight, FTransform(CVS.LightRotation)); LineBatcher = NewObject<ULineBatchComponent>(GetTransientPackage()); AddComponent(LineBatcher, FTransform::Identity); }
/** * Marks/Unmarks the package's bDirty flag */ void UPackage::SetDirtyFlag( bool bIsDirty ) { if ( GetOutermost() != GetTransientPackage() ) { if ( GUndo != NULL // PIE world objects should never end up in the transaction buffer as we cannot undo during gameplay. && !(GetOutermost()->PackageFlags & (PKG_PlayInEditor|PKG_ContainsScript)) ) { // make sure we're marked as transactional SetFlags(RF_Transactional); // don't call Modify() since it calls SetDirtyFlag() GUndo->SaveObject( this ); } // Update dirty bit bDirty = bIsDirty; if( GIsEditor // Only fire the callback in editor mode && !(PackageFlags & PKG_ContainsScript) // Skip script packages && !(PackageFlags & PKG_PlayInEditor) // Skip packages for PIE && GetTransientPackage() != this ) // Skip the transient package { // Package is changing dirty state, let the editor know so we may prompt for source control checkout PackageDirtyStateChangedEvent.Broadcast(this); } } }
UMaterialShaderQualitySettings* UMaterialShaderQualitySettings::Get() { if( RenderQualitySingleton == nullptr ) { static const TCHAR* SettingsContainerName = TEXT("MaterialShaderQualitySettingsContainer"); RenderQualitySingleton = FindObject<UMaterialShaderQualitySettings>(GetTransientPackage(), SettingsContainerName); if (RenderQualitySingleton == nullptr) { RenderQualitySingleton = NewObject<UMaterialShaderQualitySettings>(GetTransientPackage(), UMaterialShaderQualitySettings::StaticClass(), SettingsContainerName); RenderQualitySingleton->AddToRoot(); } RenderQualitySingleton->CurrentPlatformSettings = RenderQualitySingleton->GetShaderPlatformQualitySettings(FPlatformProperties::PlatformName()); // LegacyShaderPlatformToShaderFormat(EShaderPlatform) // GShaderPlatformForFeatureLevel // GMaxRHIFeatureLevel // populate shader platforms RenderQualitySingleton->CurrentPlatformSettings = RenderQualitySingleton->GetShaderPlatformQualitySettings(FPlatformProperties::PlatformName()); } return RenderQualitySingleton; }
static void ReplaceStructWithTempDuplicate( UUserDefinedStruct* StructureToReinstance, TSet<UBlueprint*>& BlueprintsToRecompile, TArray<UUserDefinedStruct*>& ChangedStructs) { if (StructureToReinstance) { UUserDefinedStruct* DuplicatedStruct = NULL; { const FString ReinstancedName = FString::Printf(TEXT("STRUCT_REINST_%s"), *StructureToReinstance->GetName()); const FName UniqueName = MakeUniqueObjectName(GetTransientPackage(), UUserDefinedStruct::StaticClass(), FName(*ReinstancedName)); TGuardValue<bool> IsDuplicatingClassForReinstancing(GIsDuplicatingClassForReinstancing, true); DuplicatedStruct = (UUserDefinedStruct*)StaticDuplicateObject(StructureToReinstance, GetTransientPackage(), *UniqueName.ToString(), ~RF_Transactional); } DuplicatedStruct->Guid = StructureToReinstance->Guid; DuplicatedStruct->Bind(); DuplicatedStruct->StaticLink(true); DuplicatedStruct->PrimaryStruct = StructureToReinstance; DuplicatedStruct->Status = EUserDefinedStructureStatus::UDSS_Duplicate; DuplicatedStruct->SetFlags(RF_Transient); DuplicatedStruct->AddToRoot(); CastChecked<UUserDefinedStructEditorData>(DuplicatedStruct->EditorData)->RecreateDefaultInstance(); for (auto StructProperty : TObjectRange<UStructProperty>(RF_ClassDefaultObject | RF_PendingKill)) { if (StructProperty && (StructureToReinstance == StructProperty->Struct)) { if (auto OwnerClass = Cast<UBlueprintGeneratedClass>(StructProperty->GetOwnerClass())) { if (UBlueprint* FoundBlueprint = Cast<UBlueprint>(OwnerClass->ClassGeneratedBy)) { BlueprintsToRecompile.Add(FoundBlueprint); StructProperty->Struct = DuplicatedStruct; } } else if (auto OwnerStruct = Cast<UUserDefinedStruct>(StructProperty->GetOwnerStruct())) { check(OwnerStruct != DuplicatedStruct); const bool bValidStruct = (OwnerStruct->GetOutermost() != GetTransientPackage()) && !OwnerStruct->HasAnyFlags(RF_PendingKill) && (EUserDefinedStructureStatus::UDSS_Duplicate != OwnerStruct->Status.GetValue()); if (bValidStruct) { ChangedStructs.AddUnique(OwnerStruct); StructProperty->Struct = DuplicatedStruct; } } else { UE_LOG(LogK2Compiler, Error, TEXT("ReplaceStructWithTempDuplicate unknown owner")); } } } DuplicatedStruct->RemoveFromRoot(); } }
void FTexAlignTools::Init() { // Create the list of aligners. Aligners.Empty(); Aligners.Add(NewObject<UTexAlignerDefault>(GetTransientPackage(), NAME_None, RF_Public | RF_RootSet | RF_Standalone)); Aligners.Add(NewObject<UTexAlignerPlanar>(GetTransientPackage(), NAME_None, RF_Public | RF_RootSet | RF_Standalone)); Aligners.Add(NewObject<UTexAlignerBox>(GetTransientPackage(), NAME_None, RF_Public | RF_RootSet | RF_Standalone)); Aligners.Add(NewObject<UTexAlignerFit>(GetTransientPackage(), NAME_None, RF_Public | RF_RootSet | RF_Standalone)); FEditorDelegates::FitTextureToSurface.AddRaw(this, &FTexAlignTools::OnEditorFitTextureToSurface); }
UObject* FEditorObjectTracker::GetEditorObjectForClass( UClass* EdClass ) { UObject *Obj = (EditorObjMap.Contains(EdClass) ? *EditorObjMap.Find(EdClass) : NULL); if(Obj == NULL) { FString ObjName = MakeUniqueObjectName(GetTransientPackage(), EdClass).ToString(); ObjName += "_EdObj"; Obj = StaticConstructObject(EdClass, GetTransientPackage(), FName(*ObjName), RF_Public|RF_Standalone|RF_Transient); EditorObjMap.Add(EdClass,Obj); } return Obj; }
void UChildActorComponent::PostEditChangeChainProperty(FPropertyChangedChainEvent& PropertyChangedEvent) { if (PropertyChangedEvent.Property && PropertyChangedEvent.Property->GetFName() == GET_MEMBER_NAME_CHECKED(UChildActorComponent, ChildActorClass)) { if (IsTemplate()) { if (ChildActorClass) { if (ChildActorTemplate == nullptr || (ChildActorTemplate->GetClass() != ChildActorClass)) { Modify(); AActor* NewChildActorTemplate = NewObject<AActor>(GetTransientPackage(), ChildActorClass, NAME_None, RF_ArchetypeObject | RF_Transactional | RF_Public); if (ChildActorTemplate) { UEngine::CopyPropertiesForUnrelatedObjects(ChildActorTemplate, NewChildActorTemplate); ChildActorTemplate->Rename(nullptr, GetTransientPackage(), REN_DontCreateRedirectors); } ChildActorTemplate = NewChildActorTemplate; // Record initial object state in case we're in a transaction context. ChildActorTemplate->Modify(); // Now set the actual name and outer to the BPGC. const FString TemplateName = FString::Printf(TEXT("%s_%s_CAT"), *GetName(), *ChildActorClass->GetName()); ChildActorTemplate->Rename(*TemplateName, this, REN_DoNotDirty | REN_DontCreateRedirectors | REN_ForceNoResetLoaders); } } else if (ChildActorTemplate) { Modify(); ChildActorTemplate->Rename(nullptr, GetTransientPackage(), REN_DontCreateRedirectors); ChildActorTemplate = nullptr; } } else { ChildActorTemplate = CastChecked<UChildActorComponent>(GetArchetype())->ChildActorTemplate; } } Super::PostEditChangeChainProperty(PropertyChangedEvent); }
void UK2Node::ReconstructSinglePin(UEdGraphPin* NewPin, UEdGraphPin* OldPin, ERedirectType RedirectType) { UBlueprint* Blueprint = GetBlueprint(); check(NewPin && OldPin); // Copy over modified persistent data NewPin->CopyPersistentDataFromOldPin(*OldPin); if (NewPin->DefaultValue != NewPin->AutogeneratedDefaultValue) { if (RedirectType == ERedirectType_Value) { TArray<FString> OldPinNames; GetRedirectPinNames(*OldPin, OldPinNames); // convert TArray<FString> to TArray<FName>, faster to search TArray<FName> OldPinFNames; for (auto NameIter=OldPinNames.CreateConstIterator(); NameIter; ++NameIter) { const FString& Name = *NameIter; OldPinFNames.AddUnique(*Name); } // go through for the NewPinNode for(TMultiMap<UClass*, FParamRemapInfo>::TConstKeyIterator ParamIter(FMemberReference::GetParamRedirectMap(), Cast<UK2Node>(NewPin->GetOwningNode())->GetClass()); ParamIter; ++ParamIter) { const FParamRemapInfo& ParamRemap = ParamIter.Value(); // once we find it, see about remapping the value if (OldPinFNames.Contains(ParamRemap.OldParam)) { const FString* NewValue = ParamRemap.ParamValueMap.Find(NewPin->DefaultValue); if (NewValue) { NewPin->DefaultValue = *NewValue; } break; } } } else if (RedirectType == ERedirectType_Custom) { CustomMapParamValue(*NewPin); } } // Update the blueprints watched pins as the old pin will be going the way of the dodo for (int32 WatchIndex = 0; WatchIndex < Blueprint->PinWatches.Num(); ++WatchIndex) { UEdGraphPin*& WatchedPin = Blueprint->PinWatches[WatchIndex]; if( WatchedPin == OldPin ) { WatchedPin = NewPin; break; } } OldPin->Rename(NULL, GetTransientPackage(), (REN_DontCreateRedirectors|(Blueprint->bIsRegeneratingOnLoad ? REN_ForceNoResetLoaders : REN_None))); }
bool UDeckListModel::LoadDecks(UCardListModel* CardListModel, UHeroListModel* HeroListModel) { TArray<UCardDeckModel*> Result; UParagonSaveGame* LoadedSaveGame = Cast<UParagonSaveGame>(UGameplayStatics::CreateSaveGameObject(UParagonSaveGame::StaticClass())); LoadedSaveGame = Cast<UParagonSaveGame>(UGameplayStatics::LoadGameFromSlot(TEXT("DefaultSaveGameSlot"), 0)); if (!LoadedSaveGame) { return false; } auto Importer = NewObject<UCardDeckImporterJSON>(GetTransientPackage(), NAME_None); for (auto& DeckAsJSON : LoadedSaveGame->DecksAsJSON) { if (DeckAsJSON.IsEmpty()) { Result.Add(nullptr); } else { TArray<FString> ImportErrors; UCardDeckModel* CardDeckModel = Importer->ImportDeckModel(DeckAsJSON, CardListModel, HeroListModel, ImportErrors); if (!CardDeckModel) { return false; } Result.Add(CardDeckModel); } } DeckSlots = Result; return true; }
FAISenseID UAISense_Blueprint::UpdateSenseID() { #if WITH_EDITOR // ignore skeleton and "old version"-classes if (FKismetEditorUtilities::IsClassABlueprintSkeleton(GetClass()) || GetClass()->HasAnyClassFlags(CLASS_NewerVersionExists) || (GetOutermost() == GetTransientPackage())) { return FAISenseID::InvalidID(); } #endif if (GetClass()->HasAnyClassFlags(CLASS_Abstract) == false) { const NAME_INDEX NameIndex = GetClass()->GetFName().GetDisplayIndex(); const FAISenseID* StoredID = BPSenseToSenseID.Find(NameIndex); if (StoredID != nullptr) { ForceSenseID(*StoredID); } else { const FAISenseID NewSenseID = FAISenseID(GetFName()); ForceSenseID(NewSenseID); BPSenseToSenseID.Add(NameIndex, GetSenseID()); } } return GetSenseID(); }
//------------------------------------------------------------------------------ UBlueprintComponentNodeSpawner* UBlueprintComponentNodeSpawner::Create(TSubclassOf<UActorComponent> const ComponentClass, UObject* Outer/* = nullptr*/) { check(ComponentClass != nullptr); if (Outer == nullptr) { Outer = GetTransientPackage(); } UBlueprintComponentNodeSpawner* NodeSpawner = NewObject<UBlueprintComponentNodeSpawner>(Outer); NodeSpawner->ComponentClass = ComponentClass; NodeSpawner->NodeClass = UK2Node_AddComponent::StaticClass(); FBlueprintActionUiSpec& MenuSignature = NodeSpawner->DefaultMenuSignature; FText const ComponentTypeName = FText::FromName(ComponentClass->GetFName()); MenuSignature.MenuName = FText::Format(LOCTEXT("AddComponentMenuName", "Add {0}"), ComponentTypeName); MenuSignature.Category = BlueprintComponentNodeSpawnerImpl::GetDefaultMenuCategory(ComponentClass); MenuSignature.Tooltip = FText::Format(LOCTEXT("AddComponentTooltip", "Spawn a {0}"), ComponentTypeName); MenuSignature.Keywords = ComponentClass->GetMetaData(FBlueprintMetadata::MD_FunctionKeywords); // add at least one character, so that PrimeDefaultMenuSignature() doesn't // attempt to query the template node MenuSignature.Keywords.AppendChar(TEXT(' ')); MenuSignature.IconName = FClassIconFinder::FindIconNameForClass(ComponentClass); return NodeSpawner; }
//------------------------------------------------------------------------------ UBlueprintEventNodeSpawner* UBlueprintEventNodeSpawner::Create(TSubclassOf<UK2Node_Event> NodeClass, FName CustomEventName, UObject* Outer/* = nullptr*/) { if (Outer == nullptr) { Outer = GetTransientPackage(); } UBlueprintEventNodeSpawner* NodeSpawner = NewObject<UBlueprintEventNodeSpawner>(Outer); NodeSpawner->NodeClass = NodeClass; NodeSpawner->CustomEventName = CustomEventName; FBlueprintActionUiSpec& MenuSignature = NodeSpawner->DefaultMenuSignature; if (CustomEventName.IsNone()) { MenuSignature.MenuName = LOCTEXT("AddCustomEvent", "Add Custom Event..."); MenuSignature.IconName = TEXT("GraphEditor.CustomEvent_16x"); } else { FText const EventName = FText::FromName(CustomEventName); MenuSignature.MenuName = FText::Format(LOCTEXT("EventWithSignatureName", "Event {0}"), EventName); MenuSignature.IconName = TEXT("GraphEditor.Event_16x"); } //MenuSignature.Category, will be pulled from the node template //MenuSignature.Tooltip, will be pulled from the node template //MenuSignature.Keywords, will be pulled from the node template return NodeSpawner; }
void FAnimMontageInstance::AddReferencedObjects( FReferenceCollector& Collector ) { if (Montage && Montage->GetOuter() == GetTransientPackage()) { Collector.AddReferencedObject(Montage); } }
virtual void StartupModule() override { // this is an example of a hotfix, declared here for no particular reason. Once we have other examples, it can be deleted. #if 0 FCoreDelegates::GetHotfixDelegate(EHotfixDelegates::Test).BindRaw(this, &FWindowsTargetPlatformModule::HotfixTest); #endif TargetSettings = NewObject<UWindowsTargetSettings>(GetTransientPackage(), "WindowsTargetSettings", RF_Standalone); // We need to manually load the config properties here, as this module is loaded before the UObject system is setup to do this GConfig->GetArray(TEXT("/Script/WindowsTargetPlatform.WindowsTargetSettings"), TEXT("TargetedRHIs"), TargetSettings->TargetedRHIs, GEngineIni); // When this is initialized the UEnum for EMinimumSupportedOS hasn't been registered. FString MinOSString; if (GConfig->GetString(TEXT("/Script/WindowsTargetPlatform.WindowsTargetSettings"), TEXT("MinimumOSVersion"), MinOSString, GEngineIni)) { // We need to parse the string and compare manually. TargetSettings->MinimumOSVersion = MinOSString == TEXT("MSOS_XP") ? EMinimumSupportedOS::MSOS_XP : EMinimumSupportedOS::MSOS_Vista; } TargetSettings->AddToRoot(); ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings"); if (SettingsModule != nullptr) { SettingsModule->RegisterSettings("Project", "Platforms", "Windows", LOCTEXT("TargetSettingsName", "Windows"), LOCTEXT("TargetSettingsDescription", "Settings for Windows target platform"), TargetSettings ); } }
// Called when the game starts void UTestLoadCSVComponent::BeginPlay() { Super::BeginPlay(); // ... // 加载csv,并且显示第一行数据 UDataTable* csv = LoadObject<UDataTable>(NULL, TEXT("DataTable'/Game/csv/test1.test1'")); if (csv != NULL && csv->GetRowNames().Num() > 0) { // 获取id=1的那行的数据 FTestDataRow* row = csv->FindRow<FTestDataRow>(TEXT("1"), TEXT("")); if (row != NULL) { Debug(FString::Printf(TEXT("csv, row time="), row->time)); } } // 动态读取csv文件,不过,这个只能在Editor模式运行,如果需要在发布版中运行,那么自己新建一个类 FString FilePath = FPaths::ConvertRelativePathToFull(FPaths::GameDir()) + FString::Printf(TEXT("csv/test1.csv")); FString Data; if (FFileHelper::LoadFileToString(Data, *FilePath)) { UDataTable* DataTable = NewObject<UDataTable>(GetTransientPackage(), FName(TEXT("CSV_Test"))); DataTable->RowStruct = FTestDataRow::StaticStruct(); DataTable->CreateTableFromCSVString(Data); Debug(FString::Printf(TEXT("%d"), DataTable->GetRowNames().Num())); } }
// Clones (deep copies) a UEdGraph, including all of it's nodes and pins and their links, // maintaining a mapping from the clone to the source nodes (even across multiple clonings) UEdGraph* FEdGraphUtilities::CloneGraph(UEdGraph* InSource, UObject* NewOuter, FCompilerResultsLog* MessageLog, bool bCloningForCompile) { // Duplicate the graph, keeping track of what was duplicated TMap<UObject*, UObject*> DuplicatedObjectList; UObject* UseOuter = (NewOuter != NULL) ? NewOuter : GetTransientPackage(); FObjectDuplicationParameters Parameters(InSource, UseOuter); Parameters.CreatedObjects = &DuplicatedObjectList; if (bCloningForCompile || (NewOuter == NULL)) { Parameters.ApplyFlags |= RF_Transient; } UEdGraph* ClonedGraph = CastChecked<UEdGraph>(StaticDuplicateObjectEx(Parameters)); // Store backtrack links from each duplicated object to the original source object if (MessageLog != NULL) { for (TMap<UObject*, UObject*>::TIterator It(DuplicatedObjectList); It; ++It) { UObject* const Source = It.Key(); UObject* const Dest = It.Value(); MessageLog->NotifyIntermediateObjectCreation(Dest, Source); } } return ClonedGraph; }
void SStaticMeshEditorViewport::Construct(const FArguments& InArgs) { StaticMeshEditorPtr = InArgs._StaticMeshEditor; StaticMesh = InArgs._ObjectToEdit; CurrentViewMode = VMI_Lit; SEditorViewport::Construct( SEditorViewport::FArguments() ); PreviewMeshComponent = ConstructObject<UStaticMeshComponent>( UStaticMeshComponent::StaticClass(), GetTransientPackage(), NAME_None, RF_Transient ); SetPreviewMesh(StaticMesh); ViewportOverlay->AddSlot() .VAlign(VAlign_Top) .HAlign(HAlign_Left) .Padding(10) [ SAssignNew(OverlayTextVerticalBox, SVerticalBox) ]; FCoreUObjectDelegates::OnObjectPropertyChanged.AddRaw(this, &SStaticMeshEditorViewport::OnObjectPropertyChanged); }
//------------------------------------------------------------------------------ UBlueprintEventNodeSpawner* UBlueprintEventNodeSpawner::Create(UFunction const* const EventFunc, UObject* Outer/* = nullptr*/) { check(EventFunc != nullptr); if (Outer == nullptr) { Outer = GetTransientPackage(); } UBlueprintEventNodeSpawner* NodeSpawner = NewObject<UBlueprintEventNodeSpawner>(Outer); NodeSpawner->EventFunc = EventFunc; NodeSpawner->NodeClass = UK2Node_Event::StaticClass(); FBlueprintActionUiSpec& MenuSignature = NodeSpawner->DefaultMenuSignature; FText const FuncName = UEdGraphSchema_K2::GetFriendlySignatureName(EventFunc); MenuSignature.MenuName = FText::Format(LOCTEXT("EventWithSignatureName", "Event {0}"), FuncName); MenuSignature.Category = UK2Node_CallFunction::GetDefaultCategoryForFunction(EventFunc, LOCTEXT("AddEventCategory", "Add Event")); //MenuSignature.Tooltip, will be pulled from the node template MenuSignature.Keywords = UK2Node_CallFunction::GetKeywordsForFunction(EventFunc); if (MenuSignature.Keywords.IsEmpty()) { MenuSignature.Keywords = FText::FromString(TEXT(" ")); } MenuSignature.IconName = TEXT("GraphEditor.Event_16x"); return NodeSpawner; }
void FAssetTypeActions_EditorUtilityBlueprint::OpenAssetEditor(const TArray<UObject*>& InObjects, TSharedPtr<class IToolkitHost> EditWithinLevelEditor) { EToolkitMode::Type Mode = EditWithinLevelEditor.IsValid() ? EToolkitMode::WorldCentric : EToolkitMode::Standalone; for (auto ObjIt = InObjects.CreateConstIterator(); ObjIt; ++ObjIt) { if (UEditorUtilityBlueprint* Blueprint = Cast<UEditorUtilityBlueprint>(*ObjIt)) { if (Blueprint->GeneratedClass->IsChildOf(UGlobalEditorUtilityBase::StaticClass())) { const UGlobalEditorUtilityBase* CDO = Blueprint->GeneratedClass->GetDefaultObject<UGlobalEditorUtilityBase>(); if (CDO->bAutoRunDefaultAction) { // This is an instant-run blueprint, just execute it UGlobalEditorUtilityBase* Instance = NewObject<UGlobalEditorUtilityBase>(GetTransientPackage(), Blueprint->GeneratedClass); Instance->ExecuteDefaultAction(); } else { // This one needs settings or has multiple actions to execute, so invoke the blutility dialog TSharedRef<FGlobalBlutilityDialog> NewBlutilityDialog(new FGlobalBlutilityDialog()); NewBlutilityDialog->InitBlutilityDialog(Mode, EditWithinLevelEditor, Blueprint); } } else { // Edit actor blutilities FBlueprintEditorModule& BlueprintEditorModule = FModuleManager::LoadModuleChecked<FBlueprintEditorModule>( "Kismet" ); TSharedRef<IBlueprintEditor> NewBlueprintEditor = BlueprintEditorModule.CreateBlueprintEditor(Mode, EditWithinLevelEditor, Blueprint, false); } } } }
bool UDeckListModel::SaveDecks() { auto Exporter = NewObject<UCardDeckExporterJSON>(GetTransientPackage(), NAME_None); TArray<FString> DecksAsJSON; for (auto CardDeckModel : DeckSlots) { if (CardDeckModel) { FString JSONData; if (!Exporter->ExportDeckModel(CardDeckModel, JSONData)) { return false; } DecksAsJSON.Add(JSONData); UE_LOG(Deck, Verbose, TEXT("SAVE: \n%s"), *JSONData); } else { DecksAsJSON.Add(FString()); } } UParagonSaveGame* SaveGame = Cast<UParagonSaveGame>(UGameplayStatics::CreateSaveGameObject(UParagonSaveGame::StaticClass())); SaveGame->DecksAsJSON = DecksAsJSON; return UGameplayStatics::SaveGameToSlot(SaveGame, TEXT("DefaultSaveGameSlot"), 0); }
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); } } } } }
bool FLiveEditorManager::Activate( const FString &Name ) { RealWorld = GWorld; check( LiveEditorWorld != NULL ); GWorld = LiveEditorWorld; bool bSuccess = false; UBlueprint *Blueprint = LoadObject<UBlueprint>( NULL, *Name, NULL, 0, NULL ); if( Blueprint != NULL && Blueprint->GeneratedClass != NULL && Blueprint->GeneratedClass->IsChildOf( ULiveEditorBlueprint::StaticClass() ) ) { FActiveBlueprintRecord Record; Record.Name = Name; auto Instance = NewObject<ULiveEditorBlueprint>(GetTransientPackage(), Blueprint->GeneratedClass, NAME_None, RF_Transient | RF_Public | RF_RootSet | RF_Standalone); Instance->DoInit(); Record.Blueprint = Instance; ActiveBlueprints.Add( Record ); bSuccess = true; } GWorld = RealWorld; RealWorld = NULL; return bSuccess; }
UThumbnailManager& UThumbnailManager::Get() { // Create it if we need to if (ThumbnailManagerSingleton == nullptr) { FString ClassName = GetDefault<UThumbnailManager>()->ThumbnailManagerClassName; if (!ClassName.IsEmpty()) { // Try to load the specified class UClass* Class = LoadObject<UClass>(nullptr, *ClassName, nullptr, LOAD_None, nullptr); if (Class != nullptr) { // Create an instance of this class ThumbnailManagerSingleton = NewObject<UThumbnailManager>(GetTransientPackage(), Class); } } // If the class couldn't be loaded or is the wrong type, fallback to the default if (ThumbnailManagerSingleton == nullptr) { ThumbnailManagerSingleton = NewObject<UThumbnailManager>(); } // Keep the singleton alive ThumbnailManagerSingleton->AddToRoot(); // Tell it to load all of its classes ThumbnailManagerSingleton->Initialize(); } return *ThumbnailManagerSingleton; }
void UThumbnailManager::InitializeRenderTypeArray(TArray<FThumbnailRenderingInfo>& ThumbnailRendererTypes) { // Loop through setting up each thumbnail entry for (int32 Index = 0; Index < ThumbnailRendererTypes.Num(); Index++) { FThumbnailRenderingInfo& RenderInfo = ThumbnailRendererTypes[Index]; // Load the class that this is for if (RenderInfo.ClassNeedingThumbnailName.Len() > 0) { // Try to load the specified class RenderInfo.ClassNeedingThumbnail = LoadObject<UClass>(nullptr, *RenderInfo.ClassNeedingThumbnailName, nullptr, LOAD_None, nullptr); } if (RenderInfo.RendererClassName.Len() > 0) { // Try to create the renderer object by loading its class and // constructing one UClass* RenderClass = LoadObject<UClass>(nullptr, *RenderInfo.RendererClassName, nullptr, LOAD_None, nullptr); if (RenderClass != nullptr) { RenderInfo.Renderer = NewObject<UThumbnailRenderer>(GetTransientPackage(), RenderClass); } } // Add this to the map if it created the renderer component if (RenderInfo.Renderer != nullptr) { RenderInfoMap.Add(RenderInfo.ClassNeedingThumbnail, &RenderInfo); } } }
void UThumbnailManager::RegisterCustomRenderer(UClass* Class, TSubclassOf<UThumbnailRenderer> RendererClass) { check(Class != nullptr); check(*RendererClass != nullptr); const FString NewClassPathName = Class->GetPathName(); // Verify that this class isn't already registered for (int32 Index = 0; Index < RenderableThumbnailTypes.Num(); ++Index) { if (ensure(RenderableThumbnailTypes[Index].ClassNeedingThumbnailName != NewClassPathName)) { } else { return; } } // Register the new class FThumbnailRenderingInfo& Info = *(new (RenderableThumbnailTypes) FThumbnailRenderingInfo()); Info.ClassNeedingThumbnailName = NewClassPathName; Info.ClassNeedingThumbnail = Class; Info.Renderer = NewObject<UThumbnailRenderer>(GetTransientPackage(), RendererClass); Info.RendererClassName = RendererClass->GetPathName(); bMapNeedsUpdate = true; }
/** * Constructor. Builds the list of items to ignore */ FFindReferencedAssets::FFindReferencedAssets(void) { OnEditorMapChangeDelegateHandle = FEditorDelegates::MapChange.AddRaw(this, &FFindReferencedAssets::OnEditorMapChange); // Set up our ignore lists IgnoreClasses.Add(ULevel::StaticClass()); IgnoreClasses.Add(UWorld::StaticClass()); // Load the asset registry module FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry")); TArray<FAssetData> AssetData; FARFilter Filter; Filter.PackagePaths.Add(FName(TEXT("/Engine/EngineResources"))); Filter.PackagePaths.Add(FName(TEXT("/Engine/EngineFonts"))); Filter.PackagePaths.Add(FName(TEXT("/Engine/EngineMaterials"))); Filter.PackagePaths.Add(FName(TEXT("/Engine/EditorResources"))); Filter.PackagePaths.Add(FName(TEXT("/Engine/EditorMaterials"))); AssetRegistryModule.Get().GetAssets(Filter, AssetData); for (int32 AssetIdx = 0; AssetIdx < AssetData.Num(); ++AssetIdx) { UPackage* Package = FindObject<UPackage>(NULL, *AssetData[AssetIdx].PackageName.ToString(), true); if( Package != NULL ) { IgnorePackages.Add(Package); } } IgnorePackages.Add(GetTransientPackage()); }
UBluJsonObj* UBluBlueprintFunctionLibrary::NewBluJSONObj(UObject* WorldContextObject) { UBluJsonObj* tempObj = NewObject<UBluJsonObj>(GetTransientPackage(), UBluJsonObj::StaticClass()); tempObj->init("{}"); return tempObj; }
UBluJsonObj* UBluBlueprintFunctionLibrary::ParseJSON(const FString& JSONString) { UBluJsonObj* tempObj = NewObject<UBluJsonObj>(GetTransientPackage(), UBluJsonObj::StaticClass()); tempObj->init(JSONString); return tempObj; }
UMaterialInstanceDynamic* UMaterialInstanceDynamic::Create(UMaterialInterface* ParentMaterial, UObject* InOuter) { UObject* Outer = InOuter ? InOuter : GetTransientPackage(); UMaterialInstanceDynamic* MID = NewObject<UMaterialInstanceDynamic>(Outer); MID->SetParentInternal(ParentMaterial, false); return MID; }