《Note --- Unreal 4 --- Sample analyze --- StrategyGame（continue...）》-白红宇

《Note --- Unreal 4 --- Sample analyze --- StrategyGame（continue...）》

阅读量：4310 次

发布时间：2019-06-06

本文共 43519 字，大约阅读时间需要 145 分钟。

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

整体模块module分析:

打开StrategyGame.uproject来看:

{    "FileVersion": 3,    "Version": 0,    "VersionName": "0.0",    "EngineVersion": "0.0.0-0",    "PackageFileUE4Version": 226,    "PackageFileLicenseeUE4Version": 0,    "EngineAssociation": "",    "FriendlyName": "",    "Description": "",    "Category": "",    "CreatedBy": "",    "CreatedByURL": "",    "Modules": [        {            "Name": "StrategyGame",            "Type": "Runtime",            "LoadingPhase": "Default"        },        {            "Name": "StrategyGameLoadingScreen", //这个是额外增加的module            "Type": "Runtime",            "LoadingPhase": "PreLoadingScreen" //从代码中找到解释, 这个module必须设置成这种类型, 否则不会 “hook in time”, 从字面意思来看,是预加载一直存在于内存中的;        }    ],    "EpicSampleNameHash": "0",    "TargetPlatforms": [        "Android",        "IOS",        "MacNoEditor",        "WindowsNoEditor"    ]}

可以看到这里面定义了两个模块, 名字,类型,还有一个”LoadingPhase”的属性;

这个文件里面的内容是自己定义的, 还是自动生成的 ?

CONTINUE ... ...

这个demo从整体模块来讲可以看成有两个, 一个模块这里指的是生成dll的个数, 除了主模块StrategyGame之外,还有一个StrategyGameLoadingScreen:

StrategyGameLoadingScreen: 作为子模块, 会生成一个dll, UE4Editor-StrategyGameLoadingScreen.dll(只是在editor里面编译运行过游戏); 具体实现的时候添加的内容有:

文件StrategyGameLoadingScreen.h/cpp

FStrategyGameLoadingScreenModule : IStrategyGameLoadingScreenModule : public IModuleInterface

利用这样的继承关系实现一个新的module;

其具有自己的build文件: StrategyGameLoadingScreen.Build.cs文件:

using UnrealBuildTool;// This module must be loaded "PreLoadingScreen" in the .uproject file, otherwise it will not hook in time!public class StrategyGameLoadingScreen : ModuleRules{    public StrategyGameLoadingScreen(TargetInfo Target)    {        PrivateIncludePaths.Add("../../StrategyGame/Source/StrategyGameLoadingScreen/Private");        PublicDependencyModuleNames.AddRange(            new string[] {                "Core",                "CoreUObject",                "Engine"            }        );        PrivateDependencyModuleNames.AddRange(            new string[] {                "MoviePlayer",                "Slate",                "SlateCore",                "InputCore"            }        );    }}

可以看到其内部定义了该模块的额外include path, 以及使用那些引擎的原生模块; 认为, 可能是: public为属性的模块可以和其他模块进行接口之间调用的交互,而private的只能是自己当前模块使用的(参考RulesCompiler.cs);

这个模块的主要功能是实现开始菜单的部分,并且一些UI元素如背景图等是代码写出来的(class SStrategyLoadingScreen 的Construct 函数 ), 在此发现SNew和SAssignNew是UI 进行new专用的;

但是对于这个demo的UI而言,这个module里面的内容还不够, 猜测主模块StrategyGame里面对于UI的处理是结合这个模块的;

主模块StrategyGame:

这个模块对应了一个UE4Editor-StrategyGame.dll; 其内部使用了上面那个StrategyGameLoadingScreen模块:

在StrategyGame.Build.cs文件里面除了增加其他module,还有:

PrivateDependencyModuleNames.AddRange(            new string[] {                "StrategyGameLoadingScreen"            }        );

主模块StrategyGame和StrategyGameLoadingScreen模块的交互:

这个demo中,主要是主模块调用子模块函数然后让其显示菜单背景图等, 需要包含子模块的头文件, 显式加载子模块, 调用子模块的具体实现:

void AStrategyMenuHUD::ShowLoadingScreen(){    IStrategyGameLoadingScreenModule* LoadingScreenModule = FModuleManager::LoadModulePtr
        
         ("StrategyGameLoadingScreen");    if( LoadingScreenModule != nullptr )    {        LoadingScreenModule->StartInGameLoadingScreen();    }}

这个StrategyGameLoadingScreen模块作为具有PreLoadingScreen属性的模块，在游戏启动时候会专门先加载（LaunchEngineLoop.cpp, EnginePreInit(…)）：

// Load up all modules that need to hook into the loading screen    if (!IProjectManager::Get().LoadModulesForProject(ELoadingPhase::PreLoadingScreen) || !IPluginManager::Get().LoadModulesForEnabledPlugins(ELoadingPhase::PreLoadingScreen))    {        return 1;}

关于模块加载函数LoadModulesForProject其参数是：

enum Type    {        /** Loaded before the engine is fully initialized, immediately after the config system has been initialized.  Necessary only for very low-level hooks */        PostConfigInit,        /** Loaded before the engine is fully initialized for modules that need to hook into the loading screen before it triggers */        PreLoadingScreen,        /** Right before the default phase */        PreDefault,        /** Loaded at the default loading point during startup (during engine init, after game modules are loaded.) */        Default,        /** Right after the default phase */        PostDefault,        /** After the engine has been initialized */        PostEngineInit,        /** Do not automatically load this module */        None,        // NOTE: If you add a new value, make sure to update the ToString() method below!        Max};

所以可以知道，不同的module属性会在加载的时候具有不同的时机；

看后面可以发现会逐一加载后面几个属性的module(LaunchEngineLoop.cpp)：

bool FEngineLoop::LoadStartupModules(){    FScopedSlowTask SlowTask(3);    SlowTask.EnterProgressFrame(1);    // Load any modules that want to be loaded before default modules are loaded up.    if (!IProjectManager::Get().LoadModulesForProject(ELoadingPhase::PreDefault) || !IPluginManager::Get().LoadModulesForEnabledPlugins(ELoadingPhase::PreDefault))    {        return false;    }    SlowTask.EnterProgressFrame(1);    // Load modules that are configured to load in the default phase    if (!IProjectManager::Get().LoadModulesForProject(ELoadingPhase::Default) || !IPluginManager::Get().LoadModulesForEnabledPlugins(ELoadingPhase::Default))    {        return false;    }    SlowTask.EnterProgressFrame(1);    // Load any modules that want to be loaded after default modules are loaded up.    if (!IProjectManager::Get().LoadModulesForProject(ELoadingPhase::PostDefault) || !IPluginManager::Get().LoadModulesForEnabledPlugins(ELoadingPhase::PostDefault))    {        return false;    }    return true;}

Blueprint和code布局总览:

比如,在game mode的代码和blueprint里面都定义当前的角色, 那么当前使用的角色到底是哪个?

想来，如果在代码的BeginPlay里面定义一些事情，再在blueprint里面的beginPlay节点后面连接定义一些事情，那么估计应该是先走代码里面的，再走blueprint里面的逻辑；

GameMode部分:

本demo中gamemode C++类没有创建对应的blueprint资源, 认为,对于一些不需要美术,或者不经常改动的变量,可以不暴露给editor,这样就不需要额外的blueprint, 纯C++类即可, 特别对于一些单件类可能更是如此;

GameMode主要是包含一些游戏性相关的接口,比如AllowCheats, InitGame, InitGameState, GetDefaultPawnClassForController, StartPlay, SetPause, ResetLevel, StartToLeaveMap, PreLogin,

CanSpectate(这个好像是是否freecamera)等, 在本demo中, 只是重新实现了InitGameState, RestartPlayer函数, 新增一些如ModifyDamage, ReturnToMenu, FinishGam, ExitGme这样的函数, 新增的函数如果允许blueprint来调用可以加上属性”BlueprintCallable”;

GameState部分:

GameStateBase is a class that manages the game's global state, and is spawned by GameModeBase.

这个demo里面这部分没有对这个类进行特定的blueprint资源;

有个类APlayerState:public AInfo 于文件PlayerState.h, 属于引擎原生文件, 如playername, playerID, starttime 等;

Demo中这个类添加了一些如敌人(这是个塔防游戏)个数(数组存储),OnCharPawn(供AI部分代码调用spawn出新的敌人); SetGamePaused供blueprint调用;

小地图指针也存储于此类: TWeakObjectPtr<AStrategyMiniMapCapture> MiniMapCamera;

MiniMap部分:

左下角的小地图有类: class AStrategyMiniMapCapture : public ASceneCapture2D[该父类自带一个DrawFrustum的component, 是个camera] 增加一些小地图宽高,AudioListener的FrontDir,RightDir[但在这里没用,应该只是存储,然后更新立体声时候从这里拿]等,以及辅助capture的变量; 在其BeginPlay函数里面存储this到GameState中; 根据tick函数来进行capture的更新; ASceneCapture2D自带GetCaptureComponent2D()->UpdateContent()[内部实现:{ CaptureSceneDeferred(); }];用于更新自身rendertarget的内容;

该类具有blueprint实例, 实例里面定义了当前使用哪个RenderTarget资源;

至于这个类里面的render target,在这个demo里面是自定义的成员变量:

在BeginPlay()里面将其给了父类中rendertarget:

MiniMapView = NewObject
        
         ();        MiniMapView->InitAutoFormat(MiniMapWidth,MiniMapHeight);        GetCaptureComponent2D()->TextureTarget = MiniMapView;

注意这里虽然是New出来的,但是没有显式析构; 其定义是 UPROPERTY() UTextureRenderTarget2D* MiniMapView; 应该是这样加上属性令UE4管理其析构的;

这里有点怀疑, 不使用额外的自定义的rendertarget应该也可以, 而在blueprint里面赋值的也只是这个TextureTarget, 而不是类中新增加的MiniMapView;

如此怀疑: blueprint与C++代码的交互是: 代码的BeginPlay()先走, 给TextureTarget赋值, 然后读取blueprint里面的值, 否则blueprint里面的值会被覆盖才对;

总感觉这个变量没什么用, 去掉应该也可以… … test … ….

该类内部专属editor代码，这部分代码关联着C++与blueprint之间交互的机制：

#if WITH_EDITORvoid AStrategyMiniMapCapture::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent){    Super::PostEditChangeProperty(PropertyChangedEvent);    UProperty* PropertyThatChanged = PropertyChangedEvent.Property;    FName PropertyName = PropertyThatChanged != nullptr ? PropertyThatChanged->GetFName() : NAME_None;    if (PropertyName==FName(TEXT("RelativeRotation")))    {        FRotator ChangedRotation = RootComponent->GetComponentRotation();        RootComponent->SetWorldRotation(FRotator(-90,0,ChangedRotation.Roll));    }}void AStrategyMiniMapCapture::EditorApplyRotation(const FRotator& DeltaRotation, bool bAltDown, bool bShiftDown, bool bCtrlDown){    FRotator FiltredRotation(0, DeltaRotation.Yaw, 0);    Super::EditorApplyRotation(FiltredRotation, bAltDown, bShiftDown, bCtrlDown);}#endif

该类内部的GroundLevel定义: capture的camera Z值减去该值即为 [大约]距离地面的高度;

在StrategyPlayerController.Cpp里面发现代码用于坐标转换, 射线与平面检测(比较有用):

const FPlane GroundPlane = FPlane(FVector(0,0,GroundLevel), FVector::UpVector);FViewport* const Viewport = GEngine->GameViewport->ViewportFrame->GetViewport();FVector2D const ScreenRes = Viewport->GetSizeXY();FVector RayOrigin, RayDirection;FVector2D const ScreenCenterPoint = ScreenRes * 0.5f;//获取屏幕中心点FStrategyHelpers::DeprojectScreenToWorld(ScreenCenterPoint, MyPlayer, RayOrigin, RayDirection);//屏幕中心点坐标转换到世界空间,传出世界空间中的射线始点与方向,其内部:        FSceneViewProjectionData ProjectionData;        if (Player->GetProjectionData(Player->ViewportClient->Viewport, eSSP_FULL, /*out*/ ProjectionData))        {            const FMatrix ViewMatrix = FTranslationMatrix(-ProjectionData.ViewOrigin) * ProjectionData.ViewRotationMatrix;            const FMatrix InvViewMatrix = ViewMatrix.InverseFast();            const FMatrix InvProjectionMatrix = ProjectionData.ProjectionMatrix.InverseFast();            FSceneView::DeprojectScreenToWorld(ScreenPosition, ProjectionData.GetConstrainedViewRect(), InvViewMatrix, InvProjectionMatrix, /*out*/ RayOrigin, /*out*/ RayDirection);            return true;        }FVector const WorldPoint = FStrategyHelpers::IntersectRayWithPlane(RayOrigin, RayDirection, GroundPlane);//在世界空间进行射线与平面检测

至于这个类及其render target与UI渲染的交互, 绘制到画面上: 是在class AStrategyHUD : public AHUD的函数DrawMiniMap()里面，该类重载了很多AHUD的函数，如DrawHUD；默认的HUD可以在gamemode里面进行定义；关于小地图位置的设定也是在绘制的时候写死的，绘制：

FCanvasTileItem MapTileItem( FVector2D( 0.0f, 0.0f), FVector2D( 0.0f, 0.0f ), FLinearColor::White );            MapTileItem.Texture = MiniMapTexture->Resource;            MapTileItem.Size = FVector2D( MapWidth, MapHeight );            MapTileItem.BlendMode = SE_BLEND_Opaque;            Canvas->DrawItem( MapTileItem, FVector2D( MiniMapMargin * UIScale, Canvas->ClipY - MapHeight - MiniMapMargin * UIScale ) )

HUD部分:

HUD和菜单本来算是同一种实现方式,但是在本demo中是不一样的;

像上段落提到的，class AStrategyHUD : public AHUD；作为本demo默认的HUD类；

如何使用UE4的UMG进行UI设计? 这种方法可以纯粹使用blueprint,而不必使用代码,只是在按钮按下之类的事件的响应函数中可以利用代码实现(为了能够在blueprint里面在响应时候被调用,这种专门后台处理UI的类应该暴露给blueprint,而这个类可以作为一个成员变量存储到主角类里面,这样blueprint里面通过主角来获得该类,进而调用函数);如果一个C++类具有两个blueprint实例,那么这两个实例之间应该是没关系的,所以对于这种专门后台处理UI相应事件的逻辑(供blueprint调用)的类, 不必具有blueprint实例; 主要使用的资源类型是”Widget Blueprint”, 在这种资源里面进行UI设计,添加相应事件,调用响应函数; 游戏整体与这个资源进行交互的机制是, 一般可以在level blueprint(比如menu是个专门的level, 就具有专门的level blueprint)里面使用”Create Wedget”节点,使用这个资源(比如做弹出菜单的时候可以常用这种):

然后将这个”PauseMenuReference”作为节点”Add to Viewport”的target, 将菜单添加到Viewport中;

关于UI相关的资源在UE4中有四种:

1. Font: 字体;

本demo中没有新建字体；

2. Slate Brush: An asset describing how a texture can exist in slate’s DPI-aware environment and how this texture responds resizing, eg. Scale9-stretching? Tiling?

在blueprint里面可以使用节点“MakeSlateBrush”来创建一个SlateBrush；

一个brush可以包一个UTexture或者UMaterialInstance，一个brush应该可以理解为，设定一个贴图怎样绘制（大小，边缘怎样处理，对其方式）；

在Widget Blueprint资源里面，如果拖进去一个image的控件，会发现属性里面有Brush一栏，里面的设定和一个Slate Brush的设定是一样的；

在本demo中，创建了一个Slate Brush资源，使用的方法是（看起来是作为备份的默认图片）：

const FSlateBrush*  SStrategyButtonWidget::GetButtonImage() const{    if (ButtonImage.IsValid())    {        return ButtonImage.Get();    }     else     {        return FStrategyStyle::Get().GetBrush("DefaultActionImageBrush");    }}

可以看到这种slate brush资源“DefaultActionImageBrush”是做后备万一的；

3. Slate Widget Style: Just a wrapper for the struct with real data in it;

4. Widget Blueprint: The widget blueprint enables extending UUserWidget the user extensible UWidget; 其实可以完全不使用代码，仅仅通过这种资源来进行所有UI的设定，然后在blueprint里面通过节点“”“Create Widget”引用这个资源，然后“Add to Viewport”即可；只是本demo全是C++代码写的，类似于早期的纯代码写windows app的UI，而不是利用MFC拖控件的方式；

自定义Widget：

Widget可以理解为在UE4中即指代UI控件，本demo没有使用Widget Blueprint资源来涉及UI，所有都是代码写的，创建了很多继承自ScompoundWidget的类，作为一种新的自定义的Widget来作为UI的最小单元控件（后被用于组合成一个style）；

如：class SStrategyButtonWidget : public SCompoundWidget : public SWidget

自定义Widget内部具体内容（如点击时的事件回调函数，button上的text等）需要以SLATE_BEGIN_ARGS(SStrategyButtonWidget)形式开始，以SLATE_END_ARGS()形式结束，内容例如：

SLATE_BEGIN_ARGS(SStrategyButtonWidget)    {}    /* Owning HUD for getting Game World */    SLATE_ARGUMENT(TWeakObjectPtr
        
         , OwnerHUD)    SLATE_DEFAULT_SLOT(FArguments, Content)    /** called when the button is clicked */    SLATE_EVENT(FOnClicked, OnClicked)//这个是自定义的新事件并自动被delegate，其实在SWidget里面有OnMouseButtonDown这样的虚函数已经托管好了，重载即可，这里拿来理解怎样新增自己事件以及绑定好回调函数    /** text on the button */    SLATE_ATTRIBUTE(FText, ButtonText)    SLATE_END_ARGS()

又如：class SStrategyMiniMapWidget : public SCompoundWidget : public SWidget

这个是自定义小地图使用的widget，这部分和小地图的那个rendertarget渲染部分和事件响应（鼠标在小地图上点击，移动）是有关系的，该类还重载了OnPaint（…）函数，这个函数内部只是绘制小地图上的白线的，通过FSlateDrawElement::MakeLines（…）函数；

至于小地图上的那个rendertarget的绘制，小地图部分已经提及；

一点比较有用的代码：

AStrategyPlayerController* const PC = Cast
        
         (GEngine->GetFirstLocalPlayerController(OwnerHUD.Get()->GetWorld()));        AStrategyGameState const* const MyGameState = PC && PC->GetWorld() ? PC->GetWorld()->GetGameState
         
          () : NULL;        AStrategyHUD* const HUD = PC ? Cast
          
           (PC->MyHUD) : NULL;

注意这里自定义的几种新的Widget，但是对于editor而言是没用的，也没有对应的资源之类的东西，只是逻辑代码上的东西；这些自定义的widget应该被用于后面实现class SStrategySlateHUDWidget : public SCompoundWidget；

自定义的widget在其构造函数中会初始化该widget的属性，如：（）

void SStrategyButtonWidget::Construct(const FArguments& InArgs){    OwnerHUD = InArgs._OwnerHUD;    ButtonText = InArgs._ButtonText;    CenterText = InArgs._CenterText;    CornerText = InArgs._CornerText;    OnClicked = InArgs._OnClicked;    OnClickedDisabled = InArgs._OnClickedDisabled;    CoinIconVisible = InArgs._CoinIconVisible;    TextHAlign = InArgs._TextHAlign;     TextVAlign = InArgs._TextVAlign;     TextMargin = InArgs._TextMargin;    TextFont = InArgs._TextFont;    Opacity = InArgs._Opacity;    bIsUserActionRequired = false;    bIsMouseButtonDown = false;    bIsActiveAction = false;    bIsActionAllowed = true;    OnMouseEnterDel = InArgs._OnMouseEnterDel;    OnMouseLeaveDel = InArgs._OnMouseLeaveDel;    OpacityCurve = WidgetAnimation.AddCurve(0.0f, 0.2f, ECurveEaseFunction::QuadInOut);    bMouseCursorVisible = true;    ChildSlot    .VAlign(VAlign_Fill)    .HAlign(HAlign_Fill)    [        SNew(SOverlay)        +SOverlay::Slot()        .HAlign(HAlign_Center)        .VAlign(VAlign_Center)        [            SNew(SImage)            .Image(this, &SStrategyButtonWidget::GetButtonImage)            .ColorAndOpacity(this,&SStrategyButtonWidget::GetImageColor)        ]        +SOverlay::Slot()        .HAlign(HAlign_Center)        .VAlign(VAlign_Center)        [            SNew(SImage)            .Image(this, &SStrategyButtonWidget::GetButtonImage)            .ColorAndOpacity(this,&SStrategyButtonWidget::GetTintColor)        ]        +SOverlay::Slot()        .HAlign(TextHAlign.Get().IsSet() ? TextHAlign.Get().GetValue() : EHorizontalAlignment::HAlign_Center)        .VAlign(TextVAlign.Get().IsSet() ? TextVAlign.Get().GetValue() : EVerticalAlignment::VAlign_Bottom)        .Padding(TAttribute
         
          (this, &SStrategyButtonWidget::GetTextMargin))        [            SNew(STextBlock)            .ShadowColorAndOpacity(this,&SStrategyButtonWidget::GetTextShadowColor)            .ColorAndOpacity(this,&SStrategyButtonWidget::GetTextColor)            .ShadowOffset(FIntPoint(-1,1))            .Font(this, &SStrategyButtonWidget::GetTextFont)            .Text(ButtonText)        ]        +SOverlay::Slot()        .HAlign(EHorizontalAlignment::HAlign_Center)        .VAlign(EVerticalAlignment::VAlign_Center)        [            SNew(STextBlock)            .ShadowColorAndOpacity(this,&SStrategyButtonWidget::GetTextShadowColor)            .ColorAndOpacity(this,&SStrategyButtonWidget::GetTextColor)            .ShadowOffset(FIntPoint(-1,1))            .Font(this, &SStrategyButtonWidget::GetTextFont)            .Text(CenterText)        ]        +SOverlay::Slot()        .HAlign(EHorizontalAlignment::HAlign_Right)        .VAlign(EVerticalAlignment::VAlign_Top)        [            SNew(STextBlock)            .ShadowColorAndOpacity(this,&SStrategyButtonWidget::GetTextShadowColor)            .ColorAndOpacity(this,&SStrategyButtonWidget::GetTextColor)            .ShadowOffset(FIntPoint(-1,1))            .Text(CornerText)        ]        +SOverlay::Slot()        [            InArgs._Content.Widget        ]            ];}

View Code

在本demo实现class SStrategySlateHUDWidget : public SCompoundWidget的时候，其内部构造函数就用到了之前实现的几个别的Widget，也就是说，像class SStrategyMiniMapWidget，class SStrategyButtonWidget这样的widget都是为class SStrategySlateHUDWidget服务的，虽然他们都是Widget，并且具有相同的父子继承关系；

所以在void SStrategySlateHUDWidget::Construct(const FArguments& InArgs)里面有：

SNew(SCanvas)SNew(SBorder)SAssignNew(ActionButtonsWidget,SStrategyActionGrid)SAssignNew(MiniMapWidget,SStrategyMiniMapWidget)SNew(SImage)SAssignNew(PauseMenuButtons[ButtonIndex++], SStrategyButtonWidget)

即是说，SStrategySlateHUDWidget 类把之前的小地图自定义widget，button自定义widget等widget组合了起来（指针成为其成员变量），它使用了它们；

另外在它重载的Tick函数里面有两行代码比较好用：

UConsole* ViewportConsole = (GEngine !=NULL && GEngine->GameViewport != NULL) ? GEngine->GameViewport->ViewportConsole : NULL;    if (ViewportConsole != NULL && (ViewportConsole->ConsoleState == "Typing" || ViewportConsole->ConsoleState == "Open"))    {        FSlateApplication::Get().SetAllUserFocusToGameViewport();        FSlateApplication::Get().SetKeyboardFocus(SharedThis(this));    }

然后组合了各种自定义的Widget的这个SStrategySlateHUDWidget又被class AStrategyHUD : public AHUD使用，在其BuildMenuWidgets（…）函数里面被SAssignNew出来：

void AStrategyHUD::BuildMenuWidgets(){    if (!GEngine || !GEngine->GameViewport)    {        return;    }    if (!MyHUDMenuWidget.IsValid())    {        const AStrategyPlayerController* PCOwner = Cast
         
          (PlayerOwner);        if (PCOwner)        {            SAssignNew(MyHUDMenuWidget, SStrategySlateHUDWidget)//AstrategyHUD具有成员变量TSharedPtr
          
            MyHUDMenuWidget;            .OwnerHUD(this);            if (MyHUDMenuWidget.IsValid())            {                GEngine->GameViewport->AddViewportWidgetContent(                    SNew(SWeakWidget)                    .PossiblyNullContent(MyHUDMenuWidget.ToSharedRef())                );                MyHUDMenuWidget->ActionButtonsWidget->SetVisibility(EVisibility::Visible);                MyHUDMenuWidget->ActionWidgetPosition.BindUObject(this,&AStrategyHUD::GetActionsWidgetPos);                if (ActionPauseTexture != NULL)                {                    MyHUDMenuWidget->PauseButton->SetImage(ActionPauseTexture);                    MyHUDMenuWidget->PauseButton->DeferredShow();                }                if (MenuButtonTexture != NULL)                {                    for (uint8 i = 0; i < MyHUDMenuWidget->PauseMenuButtons.Num(); i++)                    {                        MyHUDMenuWidget->PauseMenuButtons[i]->SetImage(MenuButtonTexture);                    }                }            }        }    }}

View Code

【这块HUD的分析思路有误，应该从默认HUD类class AStrategyHUD : public AHUD分析起，会发现其使用了自定义widget SStrategySlateHUDWidget，然后进入到SStrategySlateHUDWidget的构造函数里面会发现其又组合里其他自定义widget；这样自顶向下的分析会更有效率更清晰；以上的分析是自下至上的，容易糊涂；不过自顶而下的分析需要知道顶在哪里；】

自定义Style：

“Styles can be created and applied to the various parts of a widget. This makes it easy to iterate on the look of the components in the UI, as well as share and reuse styles.”；

本demo中，WidgetStyle类似是个容器类，它组合了之前的自定义widget，

这里style的基类：struct SLATECORE_API FSlateWidgetStyle，仅仅是个struct；

struct FStrategyHUDStyle : public FSlateWidgetStyle，该类作为容器内部包含了FSlateBrush（可看出带配置的texture），FSlateColor等，然后定义一个class UStrategyHUDWidgetStyle : public USlateWidgetStyleContainerBase，是正规的类，包含一个FStrategyHUDStyle类型，这样blueprint就可以对其赋值了；

然后editor中创建这个类对应的style资源，然后再在某个构造函数（void SStrategyMenuWidget::Construct(const FArguments& InArgs)）中查找使用它：

MenuStyle = &FStrategyStyle::Get().GetWidgetStyle
        
         ("DefaultStrategyMenuStyle");//注意这里是按照名字查找相关style的，也就是说，所有的widget style都应该放到一个map中，查找代码发现（SlateStyle.h，class SLATECORE_API FSlateStyleSet : public ISlateStyle）：    FString CoreContentRootDir; /** This dir is Engine/Slate folder to share the items **/    TMap< FName, TSharedRef< struct FSlateWidgetStyle > > WidgetStyleValues;会把所有的slate widget style收集起来；

#define IMAGE_BRUSH( RelativePath, ... ) FSlateImageBrush( FPaths::GameContentDir() / "Slate"/ RelativePath + TEXT(".png"), __VA_ARGS__ )#define BOX_BRUSH( RelativePath, ... ) FSlateBoxBrush( FPaths::GameContentDir() / "Slate"/ RelativePath + TEXT(".png"), __VA_ARGS__ )#define BORDER_BRUSH( RelativePath, ... ) FSlateBorderBrush( FPaths::GameContentDir() / "Slate"/ RelativePath + TEXT(".png"), __VA_ARGS__ )#define TTF_FONT( RelativePath, ... ) FSlateFontInfo( FPaths::GameContentDir() / "Slate"/ RelativePath + TEXT(".ttf"), __VA_ARGS__ )#define OTF_FONT( RelativePath, ... ) FSlateFontInfo( FPaths::GameContentDir() / "Slate"/ RelativePath + TEXT(".otf"), __VA_ARGS__ )

自定义Menu：

除了class AStrategyHUD : public AHUD还有一个hud：class AStrategyMenuHUD : public AHUD，按照之前的分析，前者主要是小地图，右上角的三个代表生命个数的木桶，后者主要是菜单hud；菜单HUD；editor中定义的是前者AStrategyHUD；

菜单除了具有单独的HUD，菜单还有单独的game mode和controller：

AStrategyMenuGameMode::AStrategyMenuGameMode(const FObjectInitializer& ObjectInitializer)    : Super(ObjectInitializer){    //setup our custom PC and HUD    PlayerControllerClass = AStrategyMenuPlayerController::StaticClass();    HUDClass = AStrategyMenuHUD::StaticClass();    SpectatorClass = AStrategySpectatorPawn::StaticClass();}

这个menu gamemode好像没有显式使用的地方，也没有对应的资源；这个Menu HUD的一个指针引用保存在了class SStrategyMenuWidget : public SCompoundWidget里面；

这个menu部分，好像一直是独立出来的一块似的；它的HUD，game mode，widget， PlayerController似乎都是自己和自己在用，没找到别的地方有使用它的；？？？？？这是个没有完成的demo？？？

这个demo中的两个地图，两个game mode，他们是怎样工作的？难道是一个地图就可以有一个game mode？

发现，当游戏启动时候，会两个game mode的构造函数都会逐一进入，先进入的是AStrategyGameMode然后是AStrategyMenuGameMode的；

在DefaultEngine.ini里面：

GameDefaultMap=/Game/Maps/StrategyMenuServerDefaultMap=/Game/Maps/StrategyMenuEditorStartupMap=/Game/Maps/TowerDefenseMapGlobalDefaultGameMode="/Script/StrategyGame.StrategyGameMode"

这样的设定应该决定了游戏刚起来的时候默认地图是StrategyMenu，所以在游戏开时候回有LoadMap（…）调用来加载地图StrategyMenu，然后在LoadMap函数内部调用SetGameMode（…）：

WorldContext.World()->SetGameMode(URL);//看来似乎一个地图一个world就有一个game mode设定bool UWorld::SetGameMode(const FURL& InURL){    if( IsServer() && !AuthorityGameMode )    {        AuthorityGameMode = GetGameInstance()->CreateGameModeForURL(InURL);//这个URL里面包含了地图名StrategyMenu，此时正在加载这个地图，按这个函数名来看，似乎会依赖loadmap的地图信息弄出来个game mode        if( AuthorityGameMode != NULL )        {            return true;        }        else        {            UE_LOG(LogWorld, Error, TEXT("Failed to spawn GameMode actor."));            return false;        }    }    return false;}

打开地图可以发现，对于主要的游戏地图TowerDefenseMap，它的World Setting里面使用的GameModeOverride是“StrategyGameMode”，而StrategyMenu地图里面的GameOverride是“StrategyMenuGameMenu”，所以知道了：整个游戏可以有自己的game mode，各个地图可以override自己的game mode，当然也就会有自己独特专属的Controller，HUD等等：

AStrategyMenuGameMode::AStrategyMenuGameMode(const FObjectInitializer& ObjectInitializer)    : Super(ObjectInitializer){    //setup our custom PC and HUD    PlayerControllerClass = AStrategyMenuPlayerController::StaticClass();    HUDClass = AStrategyMenuHUD::StaticClass();    SpectatorClass = AStrategySpectatorPawn::StaticClass();}

所以在地图StrategyMenu里面看到什么都没有，它的作用只是在它的world setting里面设定override的专属game mode，然后这个专属的game mode AStrategyMenuGameMode的构造函数里面会有设定专属的Controller和HUD以及SpectatorClass（这个就是主角类，玩家控制的），而这个StrategyMenu在project setting里面里面设定的是作为Startup map，所以游戏启动后，加载这个菜单地图，然后其构造函数指定这个菜单地图的HUD，controller，SpectatorClass；

对应菜单专属的controller AStrategyMenuPlayerController，没有做特殊时期，主要是SetupInputComponent（）函数的重载实现，并且没有特殊的实现，用的是PlayerController.CPP的；

Menu部分:

class SStrategyMenuWidget : public SCompoundWidget 这个是menu的widget，其构造函数中找到menu的style：MenuStyle = &FStrategyStyle::Get().GetWidgetStyle<FStrategyMenuStyle> ("DefaultStrategyMenuStyle"); 这style就有点像一个容器内部包含了很多菜单所需要的texture（类型FStrategyMenuStyle包含了SlateBrush，SlateSound等，然后editor中有这个类对应的blueprint资源，这个资源名字就是“DefaultStrategyMenuStyle”），然后在SStrategyMenuWidget的构造函数中通过MenuStyle找到这些texture，然后构建菜单按钮贴图等的布局；

在AStrategyMenuHUD的构造函数里面，直接通过代码方式增加子菜单的四个按钮“Easy”“Normal”“Hard”“Back”；在SStrategyMenuWidget有各个按钮的回调函数；这样菜单就启动起来了；

关于菜单间的切换进入游戏部分：

当点击easy等游戏难度选择按钮后，会调用到回调函数：

void AStrategyMenuHUD::LaunchGame(){    FString StartStr = FString::Printf(TEXT("/Game/Maps/TowerDefenseMap?%s=%d"), *AStrategyGameMode::DifficultyOptionName, (uint8) Difficulty);    GetWorld()->ServerTravel(StartStr);//这里准备加载游戏主地图    ShowLoadingScreen();//但是主地图不会马上加载并显示进来，所以需要一个loading页面，按照之前的分析，这个loading screen是在另外一个module里面，另外的module也不一定是同一个线程}

对于函数ShowLoadingScreen（）:

void AStrategyMenuHUD::ShowLoadingScreen(){    IStrategyGameLoadingScreenModule* LoadingScreenModule = FModuleManager::LoadModulePtr
        
         ("StrategyGameLoadingScreen");//这里就载入了新的module，进入加载游戏的那个页面    if( LoadingScreenModule != nullptr )    {        LoadingScreenModule->StartInGameLoadingScreen();    }}

这里看出，UE4在切换的时候，使用GetWorld()->ServerTravel(StartStr);这样的函数，使得游戏转入下一个地图即游戏主地图“TowerDefenseMap”，同理，在载入地图的时候会加载override的gamemode “AStrategyGameMode”，其内部构造函数设定使用的controller，state，HUD，controller，DefaultPawnClass，就把各个类结合了起来，随后比如定义在state（类AStrategyGameState）里面的诸如重载的InitGameState这样的函数就会开始走，初始化游戏状态相关内容；

点击建筑，建筑上会出现即时弹出菜单，都是定义在StrategyBuilding文件里，弹出菜单存储在ASrategyHUD里面，只是显示隐藏，控件点击的触发回调都是一样的；

AI部分:

NPC行走路线的定义:

NPC自动转身走动：

CONTINUE ... ...

/** * SensingComponent encapsulates sensory (ie sight and hearing) settings and functionality for an Actor, * allowing the actor to see/hear Pawns in the world. It does *not* enable hearing * and sight sensing by default. */UCLASS(config=Game)class UStrategyAISensingComponent : public UPawnSensingComponentStrategyAIController.h:DECLARE_DELEGATE_OneParam(FOnBumpEvent, FHitResult const&);DECLARE_DELEGATE(FOnMovementEvent);如此这样声明一个事件,然后比如” FOnMovementEvent”就成为一种类型,可以声明变量;    FOnMovementEvent MovementDelegate;    MovementDelegate.BindUObject(this, &UStrategyAIAction_MoveToBrewery::OnMoveCompleted);    MyAIController->RegisterMovementEventDelegate(MovementDelegate);

Gameplay部分:

在文件DefaultGame.ini里面：

[/Script/StrategyGame.StrategyGameMode]TimeBeforeReturnToMenu=3[/Script/StrategyGame.StrategyGameState]WarmupTime=3

然后找到其对应的代码变量（StrategyGameMode.h）：

/** Time before game returns to menu after finish. */    UPROPERTY(config)    int32 TimeBeforeReturnToMenu;    /** Warm up time before game starts */    UPROPERTY(config)    int32 WarmupTime;

可以知道如果想要读取这个ini里面的变量，只需要在声明变量的时候加上config关键字即可；

所以在游戏主界面的游戏启动前（点击了选择难度按钮后）的暖场时间，这个所谓的暖场时间只是主游戏界面左上角的倒计时，跟加载页面时间没关系，逻辑是（StrategyGameState.cpp）：

void AStrategyGameState::StartGameplayStateMachine(){    if (WarmupTime > 0.f)    {        SetGameplayState(EGameplayState::Waiting);        GetWorldTimerManager().SetTimer(TimerHandle_OnGameStart, this, &AStrategyGameState::OnGameStart, WarmupTime, false);    }    else    {        OnGameStart();    }}

关于这个启动游戏前的暖场时间和机制：

点击easy难度页面后调用：

void AStrategyMenuHUD::LaunchGame(){    FString StartStr = FString::Printf(TEXT("/Game/Maps/TowerDefenseMap?%s=%d"), *AStrategyGameMode::DifficultyOptionName, (uint8) Difficulty);    GetWorld()->ServerTravel(StartStr);//@Virtuos[wangsongwei]here we begin to load the main game map TowerDefenseMap    ShowLoadingScreen();//@Virtuos[wangsongwei]since the main game map will not load and appear quickly, we need one loading screen, and this screen is in another module, but this also is same one thread}ServerTravel函数加载主游戏地图，初始化state，在初始化state时候有调用：void AStrategyGameState::StartGameplayStateMachine(){    if (WarmupTime > 0.f)    {        SetGameplayState(EGameplayState::Waiting);        GetWorldTimerManager().SetTimer(TimerHandle_OnGameStart, this, &AStrategyGameState::OnGameStart, WarmupTime, false);//这里设定的不是loading页面的显示时间，只是游戏正式开始的倒计时，其实是一个等待时间，时间到了，就调用这里设定的回调函数开始游戏    }    else    {        OnGameStart();    }}

ShowLoadingScreen函数加载额外的那个screen loading的module，这个module不一定是有单独线程在走的，这个demo似乎是没有:

这个加载页面，它的具体实现是（StrategyGameLoadingScreen.cpp）：

virtual void CreateScreen()    {        FLoadingScreenAttributes LoadingScreen;        LoadingScreen.bAutoCompleteWhenLoadingCompletes = true;        LoadingScreen.MinimumLoadingScreenDisplayTime = 0.f;//这个值是可以改变等待时间的，单位是秒        LoadingScreen.WidgetLoadingScreen = SNew(SStrategyLoadingScreen);        GetMoviePlayer()->SetupLoadingScreen(LoadingScreen);    }

按照这里的设定，是加载完成就自动退出，怎样才算是加载完成呢？它能自动监视游戏的state吗？主要逻辑部分代码在DefaultGameMoviePlayer.cpp里面；

这里的主视角的camera是class UStrategyCameraComponent : public UCameraComponent作为成员变量存储在StrategySpectatorPawn里面的，AStrategySpectatorPawn重载了MoveForward之类的函数来控制camera动；引擎怎么知道这个camera是主视角的camera？

发现当我们触发一个debug camera自由移动场景时候（ToggleDebugCamera命令行输入），void ADebugCameraController::OnActivate( APlayerController* OriginalPC )会进入，会有：

float const OrigCamFOV = OriginalPC->PlayerCameraManager->GetFOVAngle();

可以看出，主视角camera是存储在playerController里面的PlayerCameraManager里面的：

/** Camera manager associated with this Player Controller. */    UPROPERTY(BlueprintReadOnly, Category=PlayerController)    class APlayerCameraManager* PlayerCameraManager;    /** PlayerCamera class should be set for each game, otherwise Engine.PlayerCameraManager is used */    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=PlayerController)    TSubclassOf
        
          PlayerCameraManagerClass;

对于菜单的那个player controller是这么对其赋值的：

AStrategyMenuPlayerController::AStrategyMenuPlayerController(const FObjectInitializer& ObjectInitializer)    : Super(ObjectInitializer){    // just use the normal camera...fine for now    PlayerCameraManagerClass = APlayerCameraManager::StaticClass();}

APlayerCameraManager 虽然不包括camera component，但是其具有camera的必要信息；

在加载进入主游戏地图时候，会先spawn player controller，在spawn player controller的过程中会进行SpawnPlayerCameraManager（）会有一些信息存储到APlayerCameraManager里面；

对于这个游戏demo而言，主视角只有平移操作，就是在平移ASpectatorPawn主角类对象，因为camera是它的子component，所以位置也变了，这样主视角变化；

而对于缩放整个level场景，实现方法的调用堆栈是：

void APlayerController::UpdateCameraManager(float DeltaSeconds)void APlayerCameraManager::UpdateCamera(float DeltaTime)void APlayerCameraManager::DoUpdateCamera(float DeltaTime)void APlayerCameraManager::UpdateViewTarget(FTViewTarget& OutVT, float DeltaTime)void APlayerCameraManager::UpdateViewTargetInternal(FTViewTarget& OutVT, float DeltaTime)void AActor::CalcCamera(float DeltaTime, FMinimalViewInfo& OutResult)void UStrategyCameraComponent::GetCameraView(float DeltaTime, FMinimalViewInfo& OutResult){        APlayerController* Controller = GetPlayerController();    if( Controller )     {        OutResult.FOV = 30.f;        const float CurrentOffset = MinCameraOffset + ZoomAlpha * (MaxCameraOffset - MinCameraOffset);//缩放整个场景主要改变ZoomAlpha这个值实现的        FVector Pos2 = Controller->GetFocalLocation();        OutResult.Location = Controller->GetFocalLocation() - FixedCameraAngle.Vector() * CurrentOffset;        OutResult.Rotation = FixedCameraAngle;    }}

在PlayerCameraManager.h里面：

/** A ViewTarget is the primary actor the camera is associated with. */USTRUCT()struct ENGINE_API FTViewTarget{ class AActor* Target; }

Camera的ViewTarget保存camera注视的是？像这里就是“StrategySpectatorPawn_0”

Input部分:

PlayerController.h:

/** Object that manages player input. */    UPROPERTY(transient)    class UPlayerInput* PlayerInput;

Sound部分:

类型可以是AmbientSound这种actor;

作弊cheat部分:

FReply SStrategySlateHUDWidget::OnCheatAddGold() const{    FReply Reply = FReply::Unhandled();    APlayerController* PlayerController = Cast
        
         (OwnerHUD->GetWorld()->GetFirstPlayerController());    if (PlayerController)    {        UStrategyCheatManager* CheatManager = Cast
         
          (PlayerController->CheatManager);        if (CheatManager != nullptr)        {            CheatManager->AddGold(10000);            Reply = FReply::Handled();        }    }    return Reply;}

其中class UStrategyCheatManager : public UCheatManager；

UFUNCTION(exec)// This function is executable from the command line.    void AddGold(uint32 NewGold);

关于UCheatManager类，有定义free camera的controller：

UCLASS(Blueprintable, Within=PlayerController)class ENGINE_API UCheatManager : public UObject{    GENERATED_UCLASS_BODY()    /** Debug camera - used to have independent camera without stopping gameplay */    UPROPERTY()    class ADebugCameraController* DebugCameraControllerRef;    /** Debug camera - used to have independent camera without stopping gameplay */    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category="Debug Camera")    TSubclassOf
         
            DebugCameraControllerClass;        … …}/*** Camera controller that allows you to fly around a level mostly unrestricted by normal movement rules.** To turn it on, please press Alt+C or both (left and right) analogs on XBox pad,* or use the "ToggleDebugCamera" console command. Check the debug camera bindings* in DefaultPawn.cpp for the camera controls.*/UCLASS(config=Game)class ENGINE_API ADebugCameraController    : public APlayerController{ … … }

View Code

UE4还提供了一个专门的类ADebugCameraHUD可供参考，在文件DebugCameraHUD.CPP里面；我们要实现的时候可以继承他；

PlayerController.h:

/** Object that manages "cheat" commands.  Not instantiated in shipping builds. */    UPROPERTY(transient, BlueprintReadOnly, Category="Cheat Manager")    class UCheatManager* CheatManager;    /**  Enables cheats within the game */    UFUNCTION(exec)    virtual void EnableCheats();

其他:

场景中的灯光都要被包含在一个LightmassImportanceVolume里面;

关于碰撞检测, 对于整个地面的那个static mesh actor:

而对于其他的actor, 则Collision Presets的设定是NoCollision, 比如墙,石头,木桶,都是可以穿过去的,为了防止此点, 场景中增加了大量的block volume; 利用block volume比物理actor之间检测碰撞应该更有效率;

武器attach到(NPC)角色身上的机制:

类class UStrategyAIDirector : public UActorComponent里面有暴露给blueprint的函数SetDefaultWeapon, 具体是在level blueprint里面进行设定的;void UStrategyAIDirector::SetDefaultWeapon(UBlueprint* InWeapon)//注意有这种UBlueprint类型{    DefaultWeapon = InWeapon ? *InWeapon->GeneratedClass : nullptr;//这种GeneratedClass的属性: /** Pointer to the 'most recent' fully generated class */UPROPERTY(nontransactional)TSubclassOf
        
             GeneratedClass;}void UStrategyAIDirector::SetDefaultWeaponClass(TSubclassOf
         
           InWeapon){    DefaultWeapon = InWeapon;}    创建了一个component, class UStrategyAttachment : public USkeletalMeshComponent, 然后创建它相关的blueprint资源, 然后这个资源被SetDefaultWeapon 设定上去; 随后被真正attach到NPC身上:                if (DefaultWeapon != nullptr)                {                    UStrategyGameBlueprintLibrary::GiveWeaponFromClass(MinionChar, DefaultWeapon);                }void UStrategyGameBlueprintLibrary::GiveWeaponFromClass(AStrategyChar* InChar, TSubclassOf
          
            ArmorClass){    if (InChar && *ArmorClass)    {        auto MyWeapon = NewObject
           
            (InChar, *ArmorClass);        InChar->SetWeaponAttachment(MyWeapon);    }}

这种设定,使得在level blueprint里面设定的一个weapons(暂时先存储到UStrategyAIDirector : public UActorComponent 类里面, 这种继承关系应该只是为了tick),然后就被应用到了所有的NPC, 其实并不很好,只是这里的demo适合;

namespace UF{    // valid keywords for the UFUNCTION and UDELEGATE macros    enum     {        /// This function is designed to be overridden by a blueprint.  Do not provide a body for this function;        /// the autogenerated code will include a thunk that calls ProcessEvent to execute the overridden body.        BlueprintImplementableEvent,        /// This function is designed to be overridden by a blueprint, but also has a native implementation.        /// Provide a body named [FunctionName]_Implementation instead of [FunctionName]; the autogenerated        /// code will include a thunk that calls the implementation method when necessary.        BlueprintNativeEvent,        /// This function is sealed and cannot be overridden in subclasses.        /// It is only a valid keyword for events; declare other methods as static or final to indicate that they are sealed.        SealedEvent,        /// This function is executable from the command line.        Exec,        /// This function is replicated, and executed on servers.  Provide a body named [FunctionName]_Implementation instead of [FunctionName];        /// the autogenerated code will include a thunk that calls the implementation method when necessary.        Server,        /// This function is replicated, and executed on clients.  Provide a body named [FunctionName]_Implementation instead of [FunctionName];        /// the autogenerated code will include a thunk that calls the implementation method when necessary.        Client,        /// This function is both executed locally on the server and replicated to all clients, regardless of the Actor's NetOwner        NetMulticast,        /// Replication of calls to this function should be done on a reliable channel.        /// Only valid when used in conjunction with Client or Server        Reliable,        /// Replication of calls to this function can be done on an unreliable channel.        /// Only valid when used in conjunction with Client or Server        Unreliable,        /// This function fulfills a contract of producing no side effects, and additionally implies BlueprintCallable.        BlueprintPure,        /// This function can be called from blueprint code and should be exposed to the user of blueprint editing tools.        BlueprintCallable,        /// This function will not execute from blueprint code if running on something without network authority        BlueprintAuthorityOnly,        /// This function is cosmetic and will not run on dedicated servers        BlueprintCosmetic,        /// The UnrealHeaderTool code generator will not produce a execFoo thunk for this function; it is up to the user to provide one.        CustomThunk,        /// Specifies the category of the function when displayed in blueprint editing tools.        /// Usage: Category=CategoryName or Category="MajorCategory,SubCategory"        Category,        /// This function must supply a _Validate implementation        WithValidation,        /// This function is RPC service request        ServiceRequest,        /// This function is RPC service response        ServiceResponse    };}

View Code

PlayerController.h:

/** SwitchLevel to the given MapURL. */    UFUNCTION(exec)    virtual void SwitchLevel(const FString& URL);    /** Positions the mouse cursor in screen space, in pixels. */    UFUNCTION( BlueprintCallable, Category="Game|Player", meta = (DisplayName = "SetMousePosition", Keywords = "mouse" ))    void SetMouseLocation( const int X, const int Y );    UFUNCTION(BlueprintCallable, Category="Game|Player", meta=(bTraceComplex=true))    bool GetHitResultUnderFingerForObjects(ETouchIndex::Type FingerIndex, const  TArray
         
          
            > & ObjectTypes, bool bTraceComplex, FHitResult& HitResult) const;    /** Convert current mouse 2D position to World Space 3D position and direction. Returns false if unable to determine value. **/    UFUNCTION(BlueprintCallable, Category = "Game|Player", meta = (DisplayName = "ConvertMouseLocationToWorldSpace", Keywords = "deproject"))    bool DeprojectMousePositionToWorld(FVector& WorldLocation, FVector& WorldDirection) const;    /** Convert current mouse 2D position to World Space 3D position and direction. Returns false if unable to determine value. **/    UFUNCTION(BlueprintCallable, Category = "Game|Player", meta = (DisplayName = "ConvertScreenLocationToWorldSpace", Keywords = "deproject"))    bool DeprojectScreenPositionToWorld(float ScreenX, float ScreenY, FVector& WorldLocation, FVector& WorldDirection) const;    /**     * Convert a World Space 3D position into a 2D Screen Space position.     * @return true if the world coordinate was successfully projected to the screen.     */    UFUNCTION(BlueprintCallable, Category = "Game|Player", meta = (DisplayName = "ConvertWorldLocationToScreenLocation", Keywords = "project"))    bool ProjectWorldLocationToScreen(FVector WorldLocation, FVector2D& ScreenLocation, bool bPlayerViewportRelative = false) const;    /**     * Convert a World Space 3D position into a 3D Screen Space position.     * @return true if the world coordinate was successfully projected to the screen.     */    bool ProjectWorldLocationToScreenWithDistance(FVector WorldLocation, FVector& ScreenLocation, bool bPlayerViewportRelative = false) const;

View Code