void FMainMenu::FillEditMenu( FMenuBuilder& MenuBuilder, const TSharedRef< FExtender > Extender, const TSharedPtr<FTabManager> TabManager ) { MenuBuilder.BeginSection("EditHistory", LOCTEXT("HistoryHeading", "History")); { struct Local { /** @return Returns a dynamic text string for Undo that contains the name of the action */ static FText GetUndoLabelText() { return FText::Format(LOCTEXT("DynamicUndoLabel", "Undo {0}"), GUnrealEd->Trans->GetUndoContext().Title); } /** @return Returns a dynamic text string for Redo that contains the name of the action */ static FText GetRedoLabelText() { return FText::Format(LOCTEXT("DynamicRedoLabel", "Redo {0}"), GUnrealEd->Trans->GetRedoContext().Title); } }; // Undo TAttribute<FText> DynamicUndoLabel; DynamicUndoLabel.BindStatic(&Local::GetUndoLabelText); MenuBuilder.AddMenuEntry( FGenericCommands::Get().Undo, "Undo", DynamicUndoLabel); // TAttribute< FString >::Create( &Local::GetUndoLabelText ) ); // Redo TAttribute< FText > DynamicRedoLabel; DynamicRedoLabel.BindStatic( &Local::GetRedoLabelText ); MenuBuilder.AddMenuEntry(FGenericCommands::Get().Redo, "Redo", DynamicRedoLabel); // TAttribute< FString >::Create( &Local::GetRedoLabelText ) ); // Show undo history MenuBuilder.AddMenuEntry( LOCTEXT("UndoHistoryTabTitle", "Undo History"), LOCTEXT("UndoHistoryTooltipText", "View the entire undo history."), FSlateIcon(FEditorStyle::GetStyleSetName(), "UndoHistory.TabIcon"), FUIAction(FExecuteAction::CreateStatic(&FUndoHistoryModule::ExecuteOpenUndoHistory)) ); } MenuBuilder.EndSection(); MenuBuilder.BeginSection("EditLocalTabSpawners", LOCTEXT("ConfigurationHeading", "Configuration")); { if (GetDefault<UEditorExperimentalSettings>()->bToolbarCustomization) { FUIAction ToggleMultiBoxEditMode( FExecuteAction::CreateStatic(&FMultiBoxSettings::ToggleToolbarEditing), FCanExecuteAction(), FIsActionChecked::CreateStatic(&FMultiBoxSettings::IsInToolbarEditMode) ); MenuBuilder.AddMenuEntry( LOCTEXT("EditToolbarsLabel", "Edit Toolbars"), LOCTEXT("EditToolbarsToolTip", "Allows customization of each toolbar"), FSlateIcon(), ToggleMultiBoxEditMode, NAME_None, EUserInterfaceActionType::ToggleButton ); // Automatically populate tab spawners from TabManager if (TabManager.IsValid()) { const IWorkspaceMenuStructure& MenuStructure = WorkspaceMenu::GetMenuStructure(); TabManager->PopulateTabSpawnerMenu(MenuBuilder, MenuStructure.GetEditOptions()); } } if (GetDefault<UEditorStyleSettings>()->bExpandConfigurationMenus) { MenuBuilder.AddSubMenu( LOCTEXT("EditorPreferencesSubMenuLabel", "Editor Preferences"), LOCTEXT("EditorPreferencesSubMenuToolTip", "Configure the behavior and features of this Editor"), FNewMenuDelegate::CreateStatic(&FSettingsMenu::MakeMenu, FName("Editor")), false, FSlateIcon(FEditorStyle::GetStyleSetName(), "EditorPreferences.TabIcon") ); MenuBuilder.AddSubMenu( LOCTEXT("ProjectSettingsSubMenuLabel", "Project Settings"), LOCTEXT("ProjectSettingsSubMenuToolTip", "Change the settings of the currently loaded project"), FNewMenuDelegate::CreateStatic(&FSettingsMenu::MakeMenu, FName("Project")), false, FSlateIcon(FEditorStyle::GetStyleSetName(), "ProjectSettings.TabIcon") ); } else { #if !PLATFORM_MAC // Handled by app's menu in menu bar MenuBuilder.AddMenuEntry( LOCTEXT("EditorPreferencesMenuLabel", "Editor Preferences..."), LOCTEXT("EditorPreferencesMenuToolTip", "Configure the behavior and features of the Unreal Editor."), FSlateIcon(FEditorStyle::GetStyleSetName(), "EditorPreferences.TabIcon"), FUIAction(FExecuteAction::CreateStatic(&FSettingsMenu::OpenSettings, FName("Editor"), FName("General"), FName("Appearance"))) ); #endif MenuBuilder.AddMenuEntry( LOCTEXT("ProjectSettingsMenuLabel", "Project Settings..."), LOCTEXT("ProjectSettingsMenuToolTip", "Change the settings of the currently loaded project."), FSlateIcon(FEditorStyle::GetStyleSetName(), "ProjectSettings.TabIcon"), FUIAction(FExecuteAction::CreateStatic(&FSettingsMenu::OpenSettings, FName("Project"), FName("Project"), FName("General"))) ); //@todo The tab system needs to be able to be extendable by plugins [9/3/2013 Justin.Sargent] if (IModularFeatures::Get().IsModularFeatureAvailable(EditorFeatures::PluginsEditor)) { FGlobalTabmanager::Get()->PopulateTabSpawnerMenu(MenuBuilder, "PluginsEditor"); } } } MenuBuilder.EndSection(); }
UPackage* Z_Construct_UPackage_TheBeginning() { static UPackage* ReturnPackage = NULL; if (!ReturnPackage) { ReturnPackage = CastChecked<UPackage>(StaticFindObjectFast(UPackage::StaticClass(), NULL, FName(TEXT("/Script/TheBeginning")), false, false)); ReturnPackage->PackageFlags |= PKG_CompiledIn | 0x00000000; FGuid Guid; Guid.A = 0xAF7F2495; Guid.B = 0x2BE2AF11; Guid.C = 0x00000000; Guid.D = 0x00000000; ReturnPackage->SetGuid(Guid); } return ReturnPackage; }
// Copyright 1998-2014 Epic Games, Inc. All Rights Reserved. /*============================================================================= Interaction.cpp: See .UC for for info =============================================================================*/ #include "EnginePrivate.h" #include "Engine/Console.h" #include "Engine/LevelScriptActor.h" #include "Slate.h" #include "DefaultValueHelper.h" static const uint32 MAX_AUTOCOMPLETION_LINES = 20; static FName NAME_Typing = FName(TEXT("Typing")); static FName NAME_Open = FName(TEXT("Open")); class FConsoleVariableAutoCompleteVisitor { public: // @param Name must not be 0 // @param CVar must not be 0 static void OnConsoleVariable(const TCHAR *Name, IConsoleObject* CVar,TArray<struct FAutoCompleteCommand>& Sink) { #if (UE_BUILD_SHIPPING || UE_BUILD_TEST) if(CVar->TestFlags(ECVF_Cheat)) { return; } #endif // (UE_BUILD_SHIPPING || UE_BUILD_TEST) if(CVar->TestFlags(ECVF_Unregistered))
#include "GraphEditor.h" #include "TileMapEditorViewportClient.h" #include "TileMapEditorCommands.h" #include "SEditorViewport.h" #include "WorkspaceMenuStructureModule.h" #include "Paper2DEditorModule.h" #include "STileMapEditorViewportToolbar.h" #include "SDockTab.h" #include "EdModeTileMap.h" #define LOCTEXT_NAMESPACE "TileMapEditor" ////////////////////////////////////////////////////////////////////////// const FName TileMapEditorAppName = FName(TEXT("TileMapEditorApp")); ////////////////////////////////////////////////////////////////////////// struct FTileMapEditorTabs { // Tab identifiers static const FName DetailsID; static const FName ViewportID; static const FName ToolboxHostID; }; ////////////////////////////////////////////////////////////////////////// const FName FTileMapEditorTabs::DetailsID(TEXT("Details")); const FName FTileMapEditorTabs::ViewportID(TEXT("Viewport"));
TSharedRef<SWidget> FDetailWidgetExtensionHandler::GenerateExtensionWidget(const UClass* InObjectClass, TSharedPtr<IPropertyHandle> InPropertyHandle) { UProperty* Property = InPropertyHandle->GetProperty(); FString DelegateName = Property->GetName() + "Delegate"; UDelegateProperty* DelegateProperty = FindFieldChecked<UDelegateProperty>(CastChecked<UClass>(Property->GetOuter()), FName(*DelegateName)); const bool bIsEditable = Property->HasAnyPropertyFlags(CPF_Edit | CPF_EditConst); const bool bDoSignaturesMatch = DelegateProperty->SignatureFunction->GetReturnProperty()->SameType(Property); if ( !ensure(bIsEditable && bDoSignaturesMatch) ) { return SNullWidget::NullWidget; } return SNew(SPropertyBinding, BlueprintEditor.Pin().ToSharedRef(), DelegateProperty, InPropertyHandle.ToSharedRef()) .GeneratePureBindings(true); }
FName FMediaPlaylistEditorToolkit::GetToolkitFName() const { return FName("MediaPlaylistEditor"); }
AOnlineBeaconHost::AOnlineBeaconHost(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer) { NetDriverName = FName(TEXT("BeaconDriverHost")); }
TArray<FRichCurveEditInfo> UCurveFloat::GetCurves() { TArray<FRichCurveEditInfo> Curves; Curves.Add(FRichCurveEditInfo(&FloatCurve, FName(*GetName()))); return Curves; }
FName UBTComposite_SimpleParallel::GetNodeIconName() const { return FName("BTEditor.Graph.BTNode.Composite.SimpleParallel.Icon"); }
bool FModuleDescriptor::Read(const FJsonObject& Object, FText& OutFailReason) { // Read the module name TSharedPtr<FJsonValue> NameValue = Object.TryGetField(TEXT("Name")); if(!NameValue.IsValid() || NameValue->Type != EJson::String) { OutFailReason = LOCTEXT("ModuleWithoutAName", "Found a 'Module' entry with a missing 'Name' field"); return false; } Name = FName(*NameValue->AsString()); // Read the module type TSharedPtr<FJsonValue> TypeValue = Object.TryGetField(TEXT("Type")); if(!TypeValue.IsValid() || TypeValue->Type != EJson::String) { OutFailReason = FText::Format( LOCTEXT( "ModuleWithoutAType", "Found Module entry '{0}' with a missing 'Type' field" ), FText::FromName(Name) ); return false; } Type = EHostType::FromString(*TypeValue->AsString()); if(Type == EHostType::Max) { OutFailReason = FText::Format( LOCTEXT( "ModuleWithInvalidType", "Module entry '{0}' specified an unrecognized module Type '{1}'" ), FText::FromName(Name), FText::FromString(TypeValue->AsString()) ); return false; } // Read the loading phase TSharedPtr<FJsonValue> LoadingPhaseValue = Object.TryGetField(TEXT("LoadingPhase")); if(LoadingPhaseValue.IsValid() && LoadingPhaseValue->Type == EJson::String) { LoadingPhase = ELoadingPhase::FromString(*LoadingPhaseValue->AsString()); if(LoadingPhase == ELoadingPhase::Max) { OutFailReason = FText::Format( LOCTEXT( "ModuleWithInvalidLoadingPhase", "Module entry '{0}' specified an unrecognized module LoadingPhase '{1}'" ), FText::FromName(Name), FText::FromString(LoadingPhaseValue->AsString()) ); return false; } } // Read the whitelisted platforms TSharedPtr<FJsonValue> WhitelistPlatformsValue = Object.TryGetField(TEXT("WhitelistPlatforms")); if(WhitelistPlatformsValue.IsValid() && WhitelistPlatformsValue->Type == EJson::Array) { const TArray< TSharedPtr< FJsonValue > >& PlatformsArray = WhitelistPlatformsValue->AsArray(); for(int Idx = 0; Idx < PlatformsArray.Num(); Idx++) { WhitelistPlatforms.Add(PlatformsArray[Idx]->AsString()); } } // Read the blacklisted platforms TSharedPtr<FJsonValue> BlacklistPlatformsValue = Object.TryGetField(TEXT("BlacklistPlatforms")); if(BlacklistPlatformsValue.IsValid() && BlacklistPlatformsValue->Type == EJson::Array) { const TArray< TSharedPtr< FJsonValue > >& PlatformsArray = BlacklistPlatformsValue->AsArray(); for(int Idx = 0; Idx < PlatformsArray.Num(); Idx++) { BlacklistPlatforms.Add(PlatformsArray[Idx]->AsString()); } } return true; }
FNullDynamicRHI::FNullDynamicRHI() { GMaxRHIShaderPlatform = ShaderFormatToLegacyShaderPlatform(FName(FPlatformMisc::GetNullRHIShaderFormat())); }
void CreatureEditor::StartupModule() { FPropertyEditorModule& PropertyModule = FModuleManager::LoadModuleChecked<FPropertyEditorModule>("PropertyEditor"); //Custom detail views PropertyModule.RegisterCustomClassLayout("CreatureAnimStateMachine", FOnGetDetailCustomizationInstance::CreateStatic(&FCreatureAnimStateMachineDetails::MakeInstance)); PropertyModule.RegisterCustomClassLayout("CreatureMeshComponent", FOnGetDetailCustomizationInstance::CreateStatic(&FCreatureToolsDetails::MakeInstance)); IAssetTools& AssetTools = FModuleManager::LoadModuleChecked<FAssetToolsModule>("AssetTools").Get(); EAssetTypeCategories::Type CreatureAssetCategoryBit = AssetTools.RegisterAdvancedAssetCategory(FName(TEXT("CreatureAssetCategory")), LOCTEXT("CreatureAssetCategory", "Creature")); AssetTools.RegisterAssetTypeActions(MakeShareable(new FCreatureAnimStateMachineAssetTypeActions(CreatureAssetCategoryBit))); AssetTools.RegisterAssetTypeActions(MakeShareable(new FCreatureAnimStoreAssetTypeActions(CreatureAssetCategoryBit))); AssetTools.RegisterAssetTypeActions(MakeShareable(new FCreatureAnimationAssetTypeActions(CreatureAssetCategoryBit))); AssetTools.RegisterAssetTypeActions(MakeShareable(new FCreatureMetaAssetTypeActions(CreatureAssetCategoryBit))); AssetTools.RegisterAssetTypeActions(MakeShareable(new FCreatureParticlesAssetTypeActions(CreatureAssetCategoryBit))); }
void ANextLevelTrigger::BeginOverlap(AActor *Other, class UPrimitiveComponent *OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult &SweepResult) { UGameplayStatics::OpenLevel(GetWorld(), FName(*("/Game/Maps/" + NextLevel.ToString()))); }
/** * Should the shader for this material with the given platform, shader type and vertex * factory type combination be compiled * * @param Platform The platform currently being compiled for * @param ShaderType Which shader is being compiled * @param VertexFactory Which vertex factory is being compiled (can be NULL) * * @return true if the shader should be compiled */ virtual bool ShouldCache(EShaderPlatform Platform, const FShaderType* ShaderType, const FVertexFactoryType* VertexFactoryType) const { // only generate the needed shaders (which should be very restrictive for fast recompiling during editing) // @todo: Add a FindShaderType by fname or something bool bEditorStatsMaterial = Material->bIsMaterialEditorStatsMaterial; // Always allow HitProxy shaders. if (FCString::Stristr(ShaderType->GetName(), TEXT("HitProxy"))) { return true; } // we only need local vertex factory for the preview static mesh if (VertexFactoryType != FindVertexFactoryType(FName(TEXT("FLocalVertexFactory"), FNAME_Find))) { //cache for gpu skinned vertex factory if the material allows it //this way we can have a preview skeletal mesh if (bEditorStatsMaterial || !IsUsedWithSkeletalMesh() || (VertexFactoryType != FindVertexFactoryType(FName(TEXT("TGPUSkinVertexFactoryfalse"), FNAME_Find)) && VertexFactoryType != FindVertexFactoryType(FName(TEXT("TGPUSkinVertexFactorytrue"), FNAME_Find)))) { return false; } } if (bEditorStatsMaterial) { TArray<FString> ShaderTypeNames; TArray<FString> ShaderTypeDescriptions; GetRepresentativeShaderTypesAndDescriptions(ShaderTypeNames, ShaderTypeDescriptions); //Only allow shaders that are used in the stats. return ShaderTypeNames.Find(ShaderType->GetName()) != INDEX_NONE; } // look for any of the needed type bool bShaderTypeMatches = false; // For FMaterialResource::GetRepresentativeInstructionCounts if (FCString::Stristr(ShaderType->GetName(), TEXT("BasePassPSTDistanceFieldShadowsAndLightMapPolicyHQ"))) { bShaderTypeMatches = true; } else if (FCString::Stristr(ShaderType->GetName(), TEXT("BasePassPSFNoLightMapPolicy"))) { bShaderTypeMatches = true; } else if (FCString::Stristr(ShaderType->GetName(), TEXT("CachedPointIndirectLightingPolicy"))) { bShaderTypeMatches = true; } else if (FCString::Stristr(ShaderType->GetName(), TEXT("BasePassPSFSelfShadowedTranslucencyPolicy"))) { bShaderTypeMatches = true; } // Pick tessellation shader based on material settings else if(FCString::Stristr(ShaderType->GetName(), TEXT("BasePassVSFNoLightMapPolicy")) || FCString::Stristr(ShaderType->GetName(), TEXT("BasePassHSFNoLightMapPolicy")) || FCString::Stristr(ShaderType->GetName(), TEXT("BasePassDSFNoLightMapPolicy"))) { bShaderTypeMatches = true; } else if (FCString::Stristr(ShaderType->GetName(), TEXT("DepthOnly"))) { bShaderTypeMatches = true; } else if (FCString::Stristr(ShaderType->GetName(), TEXT("ShadowDepth"))) { bShaderTypeMatches = true; } else if (FCString::Stristr(ShaderType->GetName(), TEXT("TDistortion"))) { bShaderTypeMatches = true; } else if (FCString::Stristr(ShaderType->GetName(), TEXT("TBasePassForForwardShading"))) { bShaderTypeMatches = true; } return bShaderTypeMatches; }
FName UBTDecorator_TimeLimit::GetNodeIconName() const { return FName("BTEditor.Graph.BTNode.Decorator.TimeLimit.Icon"); }
struct FASTCHeader { uint32 Magic; uint8 BlockSizeX; uint8 BlockSizeY; uint8 BlockSizeZ; uint8 TexelCountX[3]; uint8 TexelCountY[3]; uint8 TexelCountZ[3]; }; #if PLATFORM_SUPPORTS_PRAGMA_PACK #pragma pack(pop) #endif IImageWrapperModule& ImageWrapperModule = FModuleManager::LoadModuleChecked<IImageWrapperModule>(FName("ImageWrapper")); static int32 GetDefaultCompressionBySizeValue() { // start at default quality, then lookup in .ini file int32 CompressionModeValue = 0; GConfig->GetInt(TEXT("/Script/UnrealEd.CookerSettings"), TEXT("DefaultASTCQualityBySize"), CompressionModeValue, GEngineIni); FParse::Value(FCommandLine::Get(), TEXT("-astcqualitybysize="), CompressionModeValue); CompressionModeValue = FMath::Min<uint32>(CompressionModeValue, MAX_QUALITY_BY_SIZE); return CompressionModeValue; } static int32 GetDefaultCompressionBySpeedValue()
void UBrainLevelSelectionMenuWidget::LoadLevel(FString name) { UWorld* world = GetWorld(); if (world) UGameplayStatics::OpenLevel(world,FName(*name)); }
void ARayCastCharacter::ThrowRay() { //GEngine->AddOnScreenDebugMessage(-1, 1.0f, FColor::Green, "Throw Ray Cast"); // Âû÷èñëÿåì êîíåö íàøåãî ëó÷à FVector TraceEnd = GetActorLocation() + GetActorForwardVector()*RayDistance; // Èíèöàëèçèðóåì ñòðóêòóðó, êîòîðàÿ ïîñëå ñòîëêíîâåíèÿ áóäåò õðàíèòü äàííûå î ñòîëêíîâåíèè FHitResult TraceHit; // Ïàðàìåòðû äëÿ ðýé êàñòèíãà FCollisionQueryParams TraceParams(FName("Ray Cast"), true, this); // Îáû÷íûé ðýé êàñò ïî òðåéñ êàíàëó, êîòîðûé îñòàíîâèòñÿ, êîãäà âñòðåòèò õîòÿ á îäíî ïðåïÿòñòâèå GetWorld()->LineTraceSingleByChannel( TraceHit, GetActorLocation(), TraceEnd, COLLISION_TEST_TRACE, TraceParams); // Èíèöèàëèçàöèÿ òèïîâ îáúåêòîâ, ñ êîòîðûìè ðåéêàñò áóäåò âçàèìîäåéñòâîâàòü /*TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes; ObjectTypes.Add(EObjectTypeQuery(ECC_Pawn)); ObjectTypes.Add(EObjectTypeQuery(ECC_WorldStatic)); ObjectTypes.Add(EObjectTypeQuery(ECC_WorldDynamic)); FCollisionObjectQueryParams ObjectParams(ObjectTypes); GetWorld()->LineTraceSingleByObjectType( TraceHit, GetActorLocation(), TraceEnd, ObjectParams, TraceParams);*/ /*GetWorld()->SweepSingleByChannel( // Ðåéêàñò ïðè ïîìîùè ôèçè÷åñêèõ ïðèìèòèâîâ TraceHit, GetActorLocation(), TraceEnd, FQuat::Identity, // äëÿ Ñâèïà íåîáõîäèì Rotation, âûðàæåííûé ÷åðåç FQuat. FQuat::Identity ñàì îïðåäåëÿåò ïîâîðîò íà îñíîâå äâóõ äàííûé òî÷åê. Íî âû òàêæå ìîæåòå óêàçàòü åãî âðó÷íóþ COLLISION_TEST_TRACE, FCollisionShape::MakeBox(FVector(0, 100, 100)), // Äåëàåò ôîðìó, ïî êîòîðîé áóäåò äåëàòü ñâèï.  ýòîé ñòðîêå ýòî - êîðîáêà FCollisionShape::MakeSphere(25.0f), // Çäåñü - ñôåðà FCollisionShape::MakeCapsule(50.f, 100.f), // À òóò - êàïñóëà. Äëÿ Âûçîâà ðåéêàñòà ðàñêîìåíòü òîëüêî îäíó èç ýòèõ òðåõ ñòðî÷åê TraceParams);*/ //TArray<FHitResult> TraceHits; // Íèæå ïðèâåäåí ðåéêàñò äëÿ ìíîæåñòâåííûõ îáúåêòîâ. Ðàçíèöà â òîì, ÷òî âìåñòî îäíîãî FHitResult, íåîáõîäèìî ïîäàâàòü ìàññèâ èç íèõ //GetWorld()->LineTraceMultiByChannel( // TraceHits, // GetActorLocation(), // TraceEnd, // COLLISION_TEST_TRACE, // TraceParams); // Îòðèñîâêà íàøåãî ëó÷à DrawDebugLine( GetWorld(), GetActorLocation(), TraceEnd, FColor::Cyan, false, // áóäåò ëè íàø ëó÷ îòðèñîâûâàòüñÿ ïîñòîÿííî 3.0f, // ñêîëüêî âðåìåíè îí áóäåò îòðèñîâûâàòüñÿ 0, 5.0f); // Òîëùèíà ëó÷à. Äîñòóïíà íå äëÿ âñåõ ôóíêöèé if (TraceHit.GetActor()) // Ïðîâåðêà, óäàðèëè ëè ìû êàêîãî-ëèáî àêòåðà { GEngine->AddOnScreenDebugMessage(-1, 1.0f, FColor::Yellow, "YAY!!!"); /*ARayCastCharacter* Ray = Cast<ARayCastCharacter>(TraceHit.GetActor()); if (Ray) { GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Cyan, "It's Ray!!!"); }*/ if (TraceHit.GetActor()->GetClass()->ImplementsInterface(ULessonOct28Interface::StaticClass())) // Ïðîâåðêà íà òî, ðåàëèçóåò ëè êëàññ äàííîãî îáúåêòà óêàçàííûé èíòåðôåéñ. // Íåîáõîäèìî åå äåëàòü îáÿçàòåëüíî, áåç íåå êîìïèëÿöèÿ ïðîéäåò, à âîò ïðèëîæåíèå êðàøíåòñÿ. { ILessonOct28Interface::Execute_Test(TraceHit.GetActor()); //Ïîñëàíèå ñîîáùåíèÿ íà âûïîëíåíèå ôóíêöèè // Åñëè ó ìåòîäà âàøåãî åñòü ïàðàìåòðû, â Execute_MethodName íóæíî èõ ïîäàâàòü ñðàçó ïîñëå óêàçàíèÿ àêòåðà äëÿ èñïîëíåíèÿ // Íàïðèìåð: ITestInterface::Execute_TestMethod(TestActor, Param1, Param2); Êîëè÷åñòâî ïàðàìåòðîâ çíà÷åíèÿ íå èìååò. } } else { GEngine->AddOnScreenDebugMessage(-1, 1.0f, FColor::Red, "No hit..."); } }
void FParticleTrackEditor::AddKeyInternal( float KeyTime, const TArray<UObject*> Objects, bool bTrigger) { for( int32 ObjectIndex = 0; ObjectIndex < Objects.Num(); ++ObjectIndex ) { UObject* Object = Objects[ObjectIndex]; FGuid ObjectHandle = FindOrCreateHandleToObject( Object ); if (ObjectHandle.IsValid()) { UMovieSceneTrack* Track = GetTrackForObject( ObjectHandle, UMovieSceneParticleTrack::StaticClass(), FName("ParticleSystem")); if (ensure(Track)) { Cast<UMovieSceneParticleTrack>(Track)->AddNewParticleSystem( KeyTime, bTrigger ); } } } }
void DestroySocketSubsystem( FSocketSubsystemModule& SocketSubsystemModule ) { SocketSubsystemModule.UnregisterSocketSubsystem(FName(TEXT("LINUX"))); FSocketSubsystemLinux::Destroy(); }
FName UMovieSceneAnimationTrack::GetTrackName() const { return FName("Animation"); }
FName FTextAssetEditorToolkit::GetToolkitFName() const { return FName("TextAssetEditor"); }
bool FDetailWidgetExtensionHandler::IsPropertyExtendable(const UClass* InObjectClass, const IPropertyHandle& InPropertyHandle) const { // TODO UMG make this work for multiple widgets. if ( InPropertyHandle.GetNumOuterObjects() == 1 ) { TArray<UObject*> Objects; InPropertyHandle.GetOuterObjects(Objects); // We don't allow bindings on the CDO. if ( Objects[0]->HasAnyFlags(RF_ClassDefaultObject) ) { return false; } UProperty* Property = InPropertyHandle.GetProperty(); FString DelegateName = Property->GetName() + "Delegate"; if ( UClass* ContainerClass = Cast<UClass>(Property->GetOuter()) ) { UDelegateProperty* DelegateProperty = FindField<UDelegateProperty>(ContainerClass, FName(*DelegateName)); if ( DelegateProperty ) { return true; } } } return false; }
static void ReplaceStructWithTempDuplicate( UBlueprintGeneratedStruct* StructureToReinstance, TSet<UBlueprint*>& BlueprintsToRecompile, TArray<UBlueprintGeneratedStruct*>& ChangedStructs) { if (StructureToReinstance) { UBlueprintGeneratedStruct* DuplicatedStruct = NULL; { const FString ReinstancedName = FString::Printf(TEXT("STRUCT_REINST_%s"), *StructureToReinstance->GetName()); const FName UniqueName = MakeUniqueObjectName(GetTransientPackage(), UBlueprintGeneratedStruct::StaticClass(), FName(*ReinstancedName)); const bool OldIsDuplicatingClassForReinstancing = GIsDuplicatingClassForReinstancing; GIsDuplicatingClassForReinstancing = true; DuplicatedStruct = (UBlueprintGeneratedStruct*)StaticDuplicateObject(StructureToReinstance, GetTransientPackage(), *UniqueName.ToString(), ~RF_Transactional); GIsDuplicatingClassForReinstancing = OldIsDuplicatingClassForReinstancing; } DuplicatedStruct->Status = EBlueprintStructureStatus::BSS_Duplicate; DuplicatedStruct->SetFlags(RF_Transient); DuplicatedStruct->AddToRoot(); for (TObjectIterator<UStructProperty> PropertyIter(RF_ClassDefaultObject|RF_PendingKill); PropertyIter; ++PropertyIter) { UStructProperty* StructProperty = *PropertyIter; if (StructProperty && (StructureToReinstance == StructProperty->Struct)) { UBlueprint* FoundBlueprint = NULL; if (auto OwnerClass = Cast<UBlueprintGeneratedClass>(StructProperty->GetOwnerClass())) { FoundBlueprint = Cast<UBlueprint>(OwnerClass->ClassGeneratedBy); } else if (auto OwnerStruct = Cast<UBlueprintGeneratedStruct>(StructProperty->GetOwnerStruct())) { check(OwnerStruct != DuplicatedStruct); const bool bValidStruct = (OwnerStruct->GetOutermost() != GetTransientPackage()) && !OwnerStruct->HasAnyFlags(RF_PendingKill) && (EBlueprintStructureStatus::BSS_Duplicate != OwnerStruct->Status.GetValue()); if (bValidStruct) { FoundBlueprint = OwnerStruct->StructGeneratedBy; ChangedStructs.AddUnique(OwnerStruct); } } else { UE_LOG(LogK2Compiler, Warning, TEXT("ReplaceStructWithTempDuplicate unknown owner")); } if (NULL != FoundBlueprint) { StructProperty->Struct = DuplicatedStruct; BlueprintsToRecompile.Add(FoundBlueprint); } } } DuplicatedStruct->RemoveFromRoot(); } }
Parms.OtherComp=OtherComp; Parms.OtherBodyIndex=OtherBodyIndex; Parms.bFromSweep=bFromSweep ? true : false; Parms.SweepResult=SweepResult; ProcessEvent(FindFunctionChecked(THEBEGINNING_Prox),&Parms); } void APickUpItem::StaticRegisterNativesAPickUpItem() { FNativeFunctionRegistrar::RegisterFunction(APickUpItem::StaticClass(),"Prox",(Native)&APickUpItem::execProx); } IMPLEMENT_CLASS(APickUpItem, 1911399684); void ATheBeginningGameMode::StaticRegisterNativesATheBeginningGameMode() { } IMPLEMENT_CLASS(ATheBeginningGameMode, 3523517141); FName THEBEGINNING_Prox = FName(TEXT("Prox")); #if USE_COMPILED_IN_NATIVES // Cross Module References ENGINE_API class UClass* Z_Construct_UClass_ACharacter(); ENGINE_API class UClass* Z_Construct_UClass_USoundBase_NoRegister(); COREUOBJECT_API class UScriptStruct* Z_Construct_UScriptStruct_FVector(); ENGINE_API class UScriptStruct* Z_Construct_UScriptStruct_FHitResult(); ENGINE_API class UClass* Z_Construct_UClass_UPrimitiveComponent_NoRegister(); ENGINE_API class UClass* Z_Construct_UClass_AActor_NoRegister(); ENGINE_API class UClass* Z_Construct_UClass_AActor(); ENGINE_API class UClass* Z_Construct_UClass_UProjectileMovementComponent_NoRegister(); ENGINE_API class UClass* Z_Construct_UClass_USphereComponent_NoRegister(); ENGINE_API class UClass* Z_Construct_UClass_UStaticMeshComponent_NoRegister(); ENGINE_API class UClass* Z_Construct_UClass_UBoxComponent_NoRegister(); COREUOBJECT_API class UClass* Z_Construct_UClass_UObject_NoRegister(); ENGINE_API class UClass* Z_Construct_UClass_AHUD();
static void CleanAndSanitizeStruct(UBlueprintGeneratedStruct* StructToClean) { check(StructToClean); const FString TransientString = FString::Printf(TEXT("TRASHSTRUCT_%s"), *StructToClean->GetName()); const FName TransientName = MakeUniqueObjectName(GetTransientPackage(), UBlueprintGeneratedStruct::StaticClass(), FName(*TransientString)); UBlueprintGeneratedStruct* TransientStruct = NewNamedObject<UBlueprintGeneratedStruct>(GetTransientPackage(), TransientName, RF_Public|RF_Transient); const bool bRecompilingOnLoad = StructToClean->StructGeneratedBy ? StructToClean->StructGeneratedBy->bIsRegeneratingOnLoad : false; const ERenameFlags RenFlags = REN_DontCreateRedirectors | (bRecompilingOnLoad ? REN_ForceNoResetLoaders : 0); TArray<UObject*> SubObjects; GetObjectsWithOuter(StructToClean, SubObjects, true); for( auto SubObjIt = SubObjects.CreateIterator(); SubObjIt; ++SubObjIt ) { UObject* CurrSubObj = *SubObjIt; CurrSubObj->Rename(NULL, TransientStruct, RenFlags); if( UProperty* Prop = Cast<UProperty>(CurrSubObj) ) { FKismetCompilerUtilities::InvalidatePropertyExport(Prop); } else { ULinkerLoad::InvalidateExport(CurrSubObj); } } if(!bRecompilingOnLoad) { StructToClean->RemoveMetaData(TEXT("BlueprintType")); } StructToClean->SetSuperStruct(NULL); StructToClean->Children = NULL; StructToClean->Script.Empty(); StructToClean->MinAlignment = 0; StructToClean->RefLink = NULL; StructToClean->PropertyLink = NULL; StructToClean->DestructorLink = NULL; StructToClean->ScriptObjectReferences.Empty(); StructToClean->PropertyLink = NULL; }
void FFoliageInstanceBaseCache::CompactInstanceBaseCache(AInstancedFoliageActor* IFA) { UWorld* World = IFA->GetWorld(); if (!World || World->IsGameWorld()) { return; } FFoliageInstanceBaseCache& Cache = IFA->InstanceBaseCache; TSet<FFoliageInstanceBaseId> BasesInUse; for (auto& Pair : IFA->FoliageMeshes) { for (const auto& Pair : Pair.Value->ComponentHash) { if (Pair.Key != FFoliageInstanceBaseCache::InvalidBaseId) { BasesInUse.Add(Pair.Key); } } } // Look for any removed maps TSet<FFoliageInstanceBasePtr> InvalidBasePtrs; for (auto& Pair : Cache.InstanceBaseLevelMap) { const auto& WorldAsset = Pair.Key; bool bExists = (WorldAsset == World); // Check sub-levels if (!bExists) { const FName PackageName = FName(*FPackageName::ObjectPathToPackageName(WorldAsset.ToStringReference().ToString())); if (World->WorldComposition) { bExists = World->WorldComposition->DoesTileExists(PackageName); } else { bExists = (World->GetLevelStreamingForPackageName(PackageName) != nullptr); } } if (!bExists) { InvalidBasePtrs.Append(Pair.Value); Cache.InstanceBaseLevelMap.Remove(Pair.Key); } else { // Remove dead links for (int32 i = Pair.Value.Num()-1; i >= 0; --i) { // Base needs to be removed if it's not in use by existing instances or component was removed if (Pair.Value[i].IsNull() || !BasesInUse.Contains(Cache.GetInstanceBaseId(Pair.Value[i]))) { InvalidBasePtrs.Add(Pair.Value[i]); Pair.Value.RemoveAt(i); } } if (Pair.Value.Num() == 0) { Cache.InstanceBaseLevelMap.Remove(Pair.Key); } } } TSet<FFoliageInstanceBaseId> InvalidBaseIds; Cache.InstanceBaseInvMap.Empty(); // Look for any removed base components for (const auto& Pair : Cache.InstanceBaseMap) { const FFoliageInstanceBaseInfo& BaseInfo = Pair.Value; if (InvalidBasePtrs.Contains(BaseInfo.BasePtr)) { InvalidBaseIds.Add(Pair.Key); Cache.InstanceBaseMap.Remove(Pair.Key); } else { // Regenerate inverse map check(!Cache.InstanceBaseInvMap.Contains(BaseInfo.BasePtr)); Cache.InstanceBaseInvMap.Add(BaseInfo.BasePtr, Pair.Key); } } if (InvalidBaseIds.Num()) { for (auto& Pair : IFA->FoliageMeshes) { auto& MeshInfo = Pair.Value; MeshInfo->ComponentHash.Empty(); int32 InstanceIdx = 0; for (FFoliageInstance& Instance : MeshInfo->Instances) { if (InvalidBaseIds.Contains(Instance.BaseId)) { Instance.BaseId = FFoliageInstanceBaseCache::InvalidBaseId; } MeshInfo->ComponentHash.FindOrAdd(Instance.BaseId).Add(InstanceIdx); InstanceIdx++; } } Cache.InstanceBaseMap.Compact(); Cache.InstanceBaseLevelMap.Compact(); } }
void SGameplayTagGraphPin::ParseDefaultValueData() { FString TagString = GraphPinObj->GetDefaultAsString(); UK2Node_CallFunction* CallFuncNode = Cast<UK2Node_CallFunction>(GraphPinObj->GetOuter()); FilterString.Empty(); if (CallFuncNode) { UFunction* ThisFunction = CallFuncNode->GetTargetFunction(); if (ThisFunction) { if (ThisFunction->HasMetaData(TEXT("GameplayTagFilter"))) { FilterString = ThisFunction->GetMetaData(TEXT("GameplayTagFilter")); } } } if (TagString.StartsWith(TEXT("(")) && TagString.EndsWith(TEXT(")"))) { TagString = TagString.LeftChop(1); TagString = TagString.RightChop(1); TagString.Split("=", NULL, &TagString); if (TagString.StartsWith(TEXT("\"")) && TagString.EndsWith(TEXT("\""))) { TagString = TagString.LeftChop(1); TagString = TagString.RightChop(1); } } if (!TagString.IsEmpty()) { FGameplayTag Tag = IGameplayTagsModule::Get().GetGameplayTagsManager().RequestGameplayTag(FName(*TagString)); TagContainer->AddTag(Tag); } }
// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved. #include "MatineeModule.h" #include "ModuleManager.h" #include "Matinee.h" #include "Matinee/MatineeActor.h" const FName MatineeAppIdentifier = FName(TEXT("MatineeApp")); /*----------------------------------------------------------------------------- FMatineeModule -----------------------------------------------------------------------------*/ class FMatineeModule : public IMatineeModule { public: /** Constructor, set up console commands and variables **/ FMatineeModule() { } /** Called right after the module DLL has been loaded and the module object has been created */ virtual void StartupModule() override { MenuExtensibilityManager = MakeShareable(new FExtensibilityManager); ToolBarExtensibilityManager = MakeShareable(new FExtensibilityManager); } /** Called before the module is unloaded, right before the module object is destroyed. */
TSharedRef<SWidget> FMainMenu::MakeMainMenu(const TSharedPtr<FTabManager>& TabManager, const TSharedRef< FExtender > Extender) { #define LOCTEXT_NAMESPACE "MainMenu" // Put the toolbox into our menus { const IWorkspaceMenuStructure& MenuStructure = WorkspaceMenu::GetMenuStructure(); IToolboxModule& ToolboxModule = FModuleManager::LoadModuleChecked<IToolboxModule>("Toolbox"); ToolboxModule.RegisterSpawners(MenuStructure.GetDeveloperToolsDebugCategory(), MenuStructure.GetDeveloperToolsMiscCategory()); } // Cache all project names once FMainFrameActionCallbacks::CacheProjectNames(); FMenuBarBuilder MenuBuilder(FMainFrameCommands::ActionList, Extender); { // File MenuBuilder.AddPullDownMenu( LOCTEXT("FileMenu", "File"), LOCTEXT("FileMenu_ToolTip", "Open the file menu"), FNewMenuDelegate::CreateStatic(&FMainMenu::FillFileMenu, Extender), "File", FName(TEXT("FileMenu")) ); // Edit MenuBuilder.AddPullDownMenu( LOCTEXT("EditMenu", "Edit"), LOCTEXT("EditMenu_ToolTip", "Open the edit menu"), FNewMenuDelegate::CreateStatic(&FMainMenu::FillEditMenu, Extender, TabManager), "Edit" , FName(TEXT("EditMenu")) ); // Window MenuBuilder.AddPullDownMenu( LOCTEXT("WindowMenu", "Window"), LOCTEXT("WindowMenu_ToolTip", "Open new windows or tabs."), FNewMenuDelegate::CreateStatic(&FMainMenu::FillWindowMenu, Extender, TabManager), "Window" ); // Help MenuBuilder.AddPullDownMenu( LOCTEXT("HelpMenu", "Help"), LOCTEXT("HelpMenu_ToolTip", "Open the help menu"), FNewMenuDelegate::CreateStatic(&FMainMenu::FillHelpMenu, Extender), "Help" ); } // Create the menu bar! TSharedRef<SWidget> MenuBarWidget = MenuBuilder.MakeWidget(); // Tell tab-manager about the multi-box for platforms with a global menu bar TabManager->SetMenuMultiBox(MenuBuilder.GetMultiBox()); return MenuBarWidget; }