UE4编程之C++建立一个FPS工程（二）角色网格、动画、HUD、子弹类

时间  2019-11-30
标签 ue4 编程 c++ 建立 一个 fps 工程 角色 网格 动画 hud 子弹 栏目 C&C++ 繁體版
原文   原文链接

转自：http://blog.csdn.net/u011707076/article/details/44243103数组

 

紧接上回，本篇文章将和你们一同整理总结UE4关于角色网格、动画、子弹类和HUD的简单实现。浏览器

（五）角色添加网格ssh

  Character类为咱们默认建立了一个SkeletaMeshComponent组件，因此咱们仅仅须要作的就是使用哪个静态网格模型。接下来咱们为咱们的FPSCharacter类建立一个蓝图，这样咱们能够简单的把资源指定给静态网格模型这里，而且方便之后操做添加的组件。做为开始，咱们首先要导入一个第三人称的静态网格模型，最后咱们设置成两个网格，一个是咱们本身看的，另一个是其余人看到的。编辑器

 1.添加一个完整的全身的网格，如今点击这里载入资源吧。我把咱们要用到的全部资源所有放进去了，GenericMale.fbx文件就是有全身网格的，HeroFPP.FBX是等下咱们要用到的本身看本身只有胳膊和武器的网格，Sphere.FBX是个球体网格模拟子弹，crosshair.TGA是瞄准的十字准心，FPP_Animations文件夹存放的是胳膊和武器的那个网格的用的的动画。这是个人目录结构，仅供参考。函数

  

   你们把他们都载入进来吧，注意一点就是，注意载入所有，好比载入网格，须要勾选载入材质，载入动做的时候，要选择网格，以下：oop

  

        好了，关于资源载入的问题，就一次性说清，之后就不说了。测试

      2.在蓝图文件夹内，新建蓝图动画

        

  

  这里注意！在下拉框中选择FPSCharacter，使其做为蓝图的父类，给蓝图命名为“BP_FPSCharacter”，打开它。this

  3.选中Mesh，指定网格，并把Mesh的z轴值改成-88spa

   

  完成之后就应该是这样了，为何是-88？由于是已经调整好的数值，当使用本身的网格模型时，须要本身调整，最终目标是 使得网格被外面的胶囊组件包裹，而且方向为箭头所指向的方向。这将会使得模型在世界中正确行走，方向正常。能够直接在视图中调整，也能够直接设置数值。

 4.编译保存蓝图，如今，咱们要告诉咱们的游戏模型使用最新咱们建立的蓝图类来做为游戏角色的pawn物体，而不是咱们以前建立的父类：FPSCharacter。返回VS,在模式的CPP文件构造函数中，删除

 

[cpp]  view plain copy print ?
 
  1. DefaultPawnClass = AFPSCharacter::StaticClass();  

  并添加以下代码：

 

 

[cpp]  view plain copy print ?
 
  1. AMyNewFPSGameMode::AMyNewFPSGameMode(const FObjectInitializer& ObjectInitializer)  
  2.     : Super(ObjectInitializer)  
  3. {  
  4.     //DefaultPawnClass = AMyNewFPSCharacter::StaticClass();  
  5.   
  6.     static ConstructorHelpers::FObjectFinder<UBlueprint> PlayerPawnObject(TEXT("Blueprint'/Game/Blueprints/BP_FPSCharacter.BP_FPSCharacter'"));  
  7.     if (PlayerPawnObject.Object != NULL)  
  8.     {  
  9.         DefaultPawnClass = (UClass*)PlayerPawnObject.Object->GeneratedClass;  
  10.     }  
  11. }  

  （这里提早说一下，你们无视个人类名，按照本身的来便可）
   这里有很是重要的一个知识点：在C++中引用蓝图（这样，就能够打通C++和蓝图了！），更准确的说应该是引用资源，这里的蓝图是以资源出现，等下咱们也会发如今引用十字瞄准点的时候，使  用的是一样的方法，那就是： 

 

 

[cpp]  view plain copy print ?
 
  1. static ConstructorHelpers::FObjectFinder<UBlueprint> PlayerPawnObject(TEXT("Blueprint'/Game/Blueprints/BP_FPSCharacter.BP_FPSCharacter'"));  

  TEXT里面的是资源的路径，获取资源路径有个小技巧，就是在内容浏览器中右键资源，选中复制引用命令，就会把具体的位置复制到剪贴板中了。

 

  5.回到编辑器，选择编译，等待编译成功进入游戏测试。若是你移动摄像机，你会发现角色的影子，按下F1+Shift键，来得到鼠标指针，点击上面的弹出，这  时候就能够在世界中随意的移动摄像机来看到角色的网格。

（六）更改摄像机试图（添加摄像机组件）

     在上一节的结尾，默认的摄像机是在网格的脖子里，如今咱们来建立一个正确的摄像机，而且能够设置摄像机的一些属性好比位置和视图。咱们经过给咱们的FPSCharacter类添加一个摄像机组件来完成（CameraComponent ）。首先，咱们为FPSCharacter添加一个属性来引用摄像机组件。

   1.在角色.h文件里面添加下面的代码来添加一个公有变量FirstPersonCameraComponent。

 

[cpp]  view plain copy print ?
 
  1. /** First person camera 
  2.     * 为摄像机新建变量，引用摄像机。在构造函数中作初始化------C++中添加组件！，蓝图中赋值。 
  3.     */  
  4.     UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera)  
  5.         TSubobjectPtr<UCameraComponent> FirstPersonCameraComponent;  

  2.咱们在FPSCharacter的构造函数中建立真正的组件，在FPSCharacter的构造函数中添加以下代码，来建立一个摄像机组件而且把他依附到胶囊组件上。

 

 

[cpp]  view plain copy print ?
 
  1. AMyNewFPSCharacter::AMyNewFPSCharacter(const FObjectInitializer& ObjectInitializer)  
  2.     : Super(ObjectInitializer)  
  3. {  
  4.     /********************建立、初始化摄像机********************************/  
  5.     //建立摄像机组件  
  6.     FirstPersonCameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("FirstPersonCamera"));  
  7.     FirstPersonCameraComponent->AttachParent = CapsuleComponent;  
  8.   
  9.     // 摄像机的位置稍微比眼睛要高  
  10.     FirstPersonCameraComponent->RelativeLocation = FVector(0, 0, 50.0f + BaseEyeHeight);  
  11.     // 容许玩家控制旋转  
  12.     FirstPersonCameraComponent->bUsePawnControlRotation = true;  
  13. }  

 

  3.咱们来调整摄像机的位置到眼睛的位置,在蓝图中也能够做调整，这里只用调整他的位置信息，不用调整旋转，由于旋转会被鼠标改变。这部分代码就是上面的下两行。

  4.好了，进游戏测试吧，摄像机应该在角色的头上，因此当你向下看的时候，将会看到角色的头部！

（七）添加第一人称网格

   常规的FPS要准备和处理两套网格，一套是其余人看到的本身，可是对于本身来讲它是隐藏的，这个就是全身的网格；还有一种是只有武器和手臂的网格，他们要依附在摄像机上，当玩家是第一人称的时候才被看到。为了实现这个，咱们首先要保持现有的网格，给它命名为“Mesh”，而且为咱们的第一人称网格准备一个新的静态网格模型。

  1.角色的.h文件中新建变量来引用新的网格。

 

[cpp]  view plain copy print ?
 
  1. /** 
  2.     * 出生的时候的网格，只有手臂和武器。 也是添加一个变量引用新的网格 
  3.     */  
  4.     UPROPERTY(VisibleDefaultsOnly, Category = Mesh)  
  5.         TSubobjectPtr<USkeletalMeshComponent> FirstPersonMesh;  

 2.在构造函数中，添加以下代码来建立配置网格

 

 

[cpp]  view plain copy print ?
 
  1. ///********************建立、初始化只有手和武器的网格********************************/  
  2.     //// 建立一个网格组件，他只有手臂和武器  
  3.     FirstPersonMesh = CreateDefaultSubobject<USkeletalMeshComponent>(TEXT("FirstPersonMesh"));  
  4.     FirstPersonMesh->SetOnlyOwnerSee(true);// 仅仅只有这个Pawn才能够看到  
  5.     FirstPersonMesh->AttachParent = FirstPersonCameraComponent;  
  6.     FirstPersonMesh->bCastDynamicShadow = false;  
  7.     FirstPersonMesh->CastShadow = false;  
  8.   
  9.   
  10.     ///********************除了本身，其余人看到全身*******************************/  
  11.     //// 除了本身其余人都能看到  
  12.     Mesh->SetOwnerNoSee(true);  

  上面其一部分代码中，说明了仅仅只有这个Pawn才能够看到，依附到第一人称摄像机，取消阴影；后一部分代码实现的功能呢，看注释把。

 

 3.编译C++代码，打开BP_FPSCharacter 蓝图，选择FirstPersonMesh组件，右面Detail面板中指定。调整其位置属性为：{240,0,35}，旋转属性{-180, 50, -180}.最后应该获得这么一张图

  

  OK,进入游戏测试吧，

    

   F1+Shift 而且选择弹出鼠标,这是你就不会再占有角色了,这个时候,你能够随意走动,而且看到两我的称的网格.

   

（八）添加弹药，实现射击

   既然已经建立了角色，那咱们给角色实现一个简单的武器，一枚简单的长得很像手榴弹的子弹将会从屏幕中心射出，直到他碰到世界里面的物体，才会停下来。接下来咱们便添加输入的事件，事件映射，而且为子弹建立一个新的类。

  1.处理输入，这里就不赘述，简述以下：添加事件映射，Fire，鼠标左键。

  2.添加子弹类，使用UE4的C++类向导，一样简述：父类为Actor，命名FPSProjectile。

     3.首先，咱们应该肯定一个简化表示用于碰撞模拟的物理对象。在这里，咱们添加一个球体组件USphereComponent，在.h文件里面定义变量：

 

[cpp]  view plain copy print ?
 
  1. /** 胶囊碰撞组件 */  
  2.     UPROPERTY(VisibleDefaultsOnly, Category = Projectile)  
  3.         TSubobjectPtr<USphereComponent> CollisionComp;      

  4.在CPP的构造函数里面添加组件，咱们将把他做为根组件，由于咱们要模拟它，而且在蓝图里面稍后为他添加可视化组件。

 

 

[cpp]  view plain copy print ?
 
  1. AFPSProjectile::AFPSProjectile(const FObjectInitializer& ObjectInitializer)  
  2.     : Super(ObjectInitializer)  
  3. {  
  4.     // 使用球体表明子弹  
  5.     CollisionComp = CreateDefaultSubobject<USphereComponent>(TEXT("SphereComp"));  
  6.     CollisionComp->InitSphereRadius(15.0f);  
  7.     RootComponent = CollisionComp;    
  8. }  

 这里是第二次在C++里面直接添加组件了，总结一下过程就是：声明变量--添加组件！

 

 5.UE4里面有一个自带的组件叫作子弹移动组件ProjectileMovementComponent ，他能够用于简单的弹道式的移动，咱们把它添加到子弹类里面。

  （1）在.h里面添加变量

 

[cpp]  view plain copy print ?
 
  1. /**子弹移动组件 */  
  2.     UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Movement)  
  3.         TSubobjectPtr<class UProjectileMovementComponent> ProjectileMovement;  

  （2）.cpp构造函数里面添加

 

 

[cpp]  view plain copy print ?
 
  1. // 使用子弹移动组件ProjectileMovementComponent控制子弹  
  2.     ProjectileMovement = CreateDefaultSubobject<UProjectileMovementComponent>(TEXT("ProjectileComp"));  
  3.     ProjectileMovement->UpdatedComponent = CollisionComp;  
  4.     ProjectileMovement->InitialSpeed = 3000.f;  
  5.     ProjectileMovement->MaxSpeed = 3000.f;  
  6.     ProjectileMovement->bRotationFollowsVelocity = true;  
  7.     ProjectileMovement->bShouldBounce = true;  
  8.     ProjectileMovement->Bounciness = 0.3f;  

 6.日后想想，咱们还须要一个功能经过初速度设置来“启动”咱们的弹丸。咱们自定义一个函数来处理他。首先.h里面声明一个公有函数：

 

 

[cpp]  view plain copy print ?
 
  1. /** 子弹初速度*/  
  2.     void InitVelocity(const FVector& ShootDirection);  

  cpp里面添加实现函数

 

 

[cpp]  view plain copy print ?
 
  1. void AFPSProjectile::InitVelocity(const FVector& ShootDirection)  
  2. {  
  3.     if (ProjectileMovement)  
  4.     {  
  5.         // set the projectile's velocity to the desired direction 在所需方向上设置子弹的速度  
  6.         ProjectileMovement->Velocity = ShootDirection * ProjectileMovement->InitialSpeed;  
  7.     }  
  8. }  

 7.既然速度已经制定了，接下来咱们只须要设置一个启动的方向，首先在角色类中添加函数处理输入：

 

  .h：

 

[cpp]  view plain copy print ?
 
  1. void OnFire();  

  .cpp文件中添加实现函数，在实现这个函数的时候，有两点须要考虑：

 

   （1）在哪里产生子弹

   （2）产生什么样的子弹（即传入子弹的类）。

  第一个问题，为了制定产生的位置，咱们须要一个摄像机空间的偏移量做为能够编辑的参数，所以咱们能够在角色蓝图BP_FPSCharacter 里面设置它，而后就能够根据这个数据来计算子弹的初始化速度。主要是第二个，这里也是一个重点，简单来讲，它的实质是两个C++的类是什么样的关系，如何通讯！咱们解决的办法是，在C++里面定义一个共有变量，而后等下再蓝图里面指定它。因此在.h里面添加这个共有变量把~

  角色.h  

 

[cpp]  view plain copy print ?
 
  1. /***************************这两项要在蓝图里指定******************************************/  
  2.     /** 须要实例化的子弹类 */  
  3.     UPROPERTY(EditDefaultsOnly, Category = Projectile)  
  4.         TSubclassOf<class AFPSProjectile> ProjectileClass;  
  5.   
  6.     /** Gun muzzle's offset from the camera location 
  7.     枪口到摄像机的位置偏移量*/  
  8.     UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Gameplay)  
  9.         FVector MuzzleOffset;  

  解释一下变量前面的两个宏，里咱们使用只能在蓝图设置默认EditDefaultsOnly 的说明符,这就意味着你只能在蓝图类里面设置子弹类为默认,而在不是蓝图的每个实例中. 

 

  OnFire将会包含如下几步:

 

  • 由于咱们的子弹产生位置是由相机空间决定,因此在咱们真正计算子弹位置以前须要查询摄像机的位置信息.
  • 尝试实例化子弹.
  • 使用咱们定义的函数给子弹一个初始化的速度.

 

  OK，最后就是这个函数的实现了！

 

[cpp]  view plain copy print ?
 
  1. void AMyNewFPSCharacter::OnFire()  
  2. {  
  3.     // try and fire a projectile  
  4.     if(ProjectileClass !=NULL)  
  5.     {  
  6.         // Get the camera transform  
  7.     FVector CameraLoc;  
  8.     FRotator CameraRot;  
  9.     GetActorEyesViewPoint(CameraLoc, CameraRot);  
  10.       
  11.     // MuzzleOffset is in camera space, so transform it to world space before offsetting from the camera to find the final muzzle position  
  12.     FVector const MuzzleLocation = CameraLoc + FTransform(CameraRot).TransformVector(MuzzleOffset);  
  13.     FRotator MuzzleRotation = CameraRot;  
  14.     MuzzleRotation.Pitch += 10.0f;// skew the aim upwards a bit  
  15.   
  16.     UWorld*const World = GetWorld();   
  17.     if (World)  
  18.     {  
  19.         FActorSpawnParameters SpawnParams;  
  20.         SpawnParams.Owner = this;  
  21.         SpawnParams.Instigator = Instigator;// spawn the projectile at the muzzle  
  22.         AFPSProjectile*const Projectile = World->SpawnActor<AFPSProjectile>(ProjectileClass, MuzzleLocation, MuzzleRotation, SpawnParams);  
  23.   
  24.         if (Projectile)  
  25.         {  
  26.             // find launch direction  
  27.             FVector const LaunchDir = MuzzleRotation.Vector();  
  28.             Projectile->InitVelocity(LaunchDir);  
  29.         }  
  30.     }  
  31. }  
  32. }  

  这个函数有点复杂，得须要好好理解一下。最后注意在角色cpp里面添加头文件

 

 

[cpp]  view plain copy print ?
 
  1. #include "FPSProjectile.h"  

  8.编译代码，回到编辑器，最后一步为子弹建立蓝图添加网格，建立新的蓝图，父类FPSProjectile，蓝图命名BP_FPSProjectile，在蓝图里面手动添加静态网格组件，命名ProjectileMesh，在右面的Detail面板中指定Mesh值，并调整其大小为：0.09（x、y、z都是）。另外把子弹网格组件ProjectileMesh的碰撞关闭，由于咱们使用球形碰撞体来检测碰撞而不是网格物体。

 

  

  9.接下来，咱们就要为刚刚C++里面添加的两个共有变量赋值了！打开角色蓝图，点击头上的ClassDefault，而后在右面，你就能够看到这两个变量了。

  分别按照上面赋值！以后，进入游戏测试吧！应该但是打出子弹了！

（九）设置子弹的碰撞和生命周期

 

  如今，咱们须要考虑两件事情

  • 咱们打出的子弹如今是不会消失的， Scene Outliner面板告诉了咱们
  • 弹不会产生碰撞。
  第一件事，幸运的是，UE4全部的Actors都有一个生命的限制，被一个默认生命期限限制，因此在子弹的构造函数中添加以下代码控制生命，也能够在蓝图的default中手动添加。  
[cpp]  view plain copy print ?
 
  1. // 子弹生命周期（全部的Actor都有的参数）  
  2.     InitialLifeSpan = 3.0f;  

     接下来，就要解决子弹的碰撞问题了。这部分问题，我看到的材料有点复杂，理解的不是很透彻，得多操做几遍才能熟悉，我会把英文原文附上，因此熟能生巧...

   1.UE4有几个有用的碰撞渠道，并且还提供了一些咱们能够定制的碰撞渠道，如今咱们来自定义为弹丸碰撞渠道，这样场景中的一切均可以选择如何在咱们的游戏中和一个子弹的相互做用。

   在引擎配置.ini（ DefaultEngine.ini，位于FPSProject > Config）的下方添加下面的代码：

 

[cpp]  view plain copy print ?
 
  1. [/Script/Engine.CollisionProfile]  
  2.   +DefaultChannelResponses=(Channel=ECC_GameTraceChannel1, Name=Projectile)  

  这其实是重命名了通用的渠道为“Projectile”，咱们要在本地代码中重命名它，来保证事情的持续性和可读性。这其实是重命名了通用的渠道为“Projectile”，咱们要在本地代码中重命名它，来保证事情的持续性和可读性。

 

  2.UE4也有一个功能叫作碰撞分布，实质上是引擎总体使用的预先捆绑的碰撞的设置。日后想一下，或许咱们能够在咱们的游戏有不少类型的弹丸，若是保持一致的碰撞设置其中多是容易出错的，因此咱们定义为弹一个新的文件。

      继续在DefaultEngine.ini,添加代码：

 

[cpp]  view plain copy print ?
 
  1. +Profiles=(Name="Projectile", CollisionEnabled=QueryOnly,ObjectTypeName=Projectile, CustomResponses=( \  
  2.  (Channel=Static,            Response=ECR_Block), \  
  3.  (Channel=PawnMovement,      Response=ECR_Block), \  
  4.  (Channel=Dynamic,           Response=ECR_Block), \  
  5.  (Channel=PhysicsBody,       Response=ECR_Block), \  
  6.  (Channel=VehicleMovement,   Response=ECR_Block), \  
  7.  (Channel=Destructible,      Response=ECR_Block) \  
  8.  ))  

  This profile means that the projectile will be blocked by Static Actors, Pawns, Dynamic Actors, Actors simulating Physics, Vehicles, and Destructible Actors. 这个分布意味着，子弹能够被静态物体，Pawns, Dynamic Actors, Actors simulating Physics, Vehicles, and Destructible Actors等等这些物体阻挡。

 

 3.如今咱们来设置咱们的子弹使用这个分布，在子弹构造函数中，添加下面代码：

 

[cpp]  view plain copy print ?
 
  1. //使用自定义的碰撞分布  
  2. CollisionComp->BodyInstance.SetCollisionProfileName("Projectile");  

  ok，编译一下代码吧。

 

（十）子弹和世界的物体交互

 既然咱们已经能够发现咱们子弹的碰撞相互做用，咱们能够决定怎么对她作出反应，在咱们的子弹碰撞设置中，咱们已经设置了对块的相互碰撞，接下来咱们要为子弹类添加一个叫作OnHit的函数来处理这些事件。

  1.自定义一个函数OnHit。在子弹的.h文件下添加声明

 

[cpp]  view plain copy print ?
 
  1. /** 当子弹碰到其余物体时被调用*/  
  2.     UFUNCTION()  //这个必须有  
  3.     void OnHit(class AActor* OtherActor, class UPrimitiveComponent* OtherComp, FVector NormalImpulse, const FHitResult& Hit);  

  2.cpp里面实现它

 

 

[cpp]  view plain copy print ?
 
  1. void AFPSProjectile::OnHit(AActor* OtherActor, UPrimitiveComponent* OtherComp, FVector NormalImpulse, const FHitResult& Hit)  
  2. {  
  3.     if (OtherActor && (OtherActor != this) && OtherComp)  
  4.     {  
  5.         OtherComp->AddImpulseAtLocation(ProjectileMovement->Velocity * 100.0f, Hit.ImpactPoint);  
  6.     }  
  7. }  

 3.委托，如今咱们须要把这个函数交给子弹的球形组件的OnComponentBeginOverlap 事件委托，因此在子弹的构造函数中继续添加下面代码：

 

 

[cpp]  view plain copy print ?
 
  1. CollisionComp->OnComponentHit.AddDynamic(this, &AFPSProjectile::OnHit);  

 最后，你的子弹构造函数应该是这个样子：

 

 

[cpp]  view plain copy print ?
 
  1. AFPSProjectile::AFPSProjectile(const FObjectInitializer& ObjectInitializer)  
  2.     : Super(ObjectInitializer)  
  3. {  
  4.     // 使用球体表明子弹  
  5.     CollisionComp = CreateDefaultSubobject<USphereComponent>(TEXT("SphereComp"));  
  6.     CollisionComp->InitSphereRadius(15.0f);  
  7.     RootComponent = CollisionComp;  
  8.     //使用自定义的碰撞分布  
  9.     CollisionComp->BodyInstance.SetCollisionProfileName("Projectile");  
  10.     //碰撞事件委托  
  11.     CollisionComp->OnComponentHit.AddDynamic(this, &AFPSProjectile::OnHit);  
  12.   
  13.     // 使用子弹移动组件ProjectileMovementComponent控制子弹  
  14.     ProjectileMovement = CreateDefaultSubobject<UProjectileMovementComponent>(TEXT("ProjectileComp"));  
  15.     ProjectileMovement->UpdatedComponent = CollisionComp;  
  16.     ProjectileMovement->InitialSpeed = 3000.f;  
  17.     ProjectileMovement->MaxSpeed = 3000.f;  
  18.     ProjectileMovement->bRotationFollowsVelocity = true;  
  19.     ProjectileMovement->bShouldBounce = true;  
  20.     ProjectileMovement->Bounciness = 0.3f;  
  21.   
  22.     // 子弹生命周期（全部的Actor都有的参数）  
  23.     InitialLifeSpan = 3.0f;  
  24. }  

    好咧，编译代码！

 

    4.回到编辑器，为了有一个对比的东西，咱们选择地面物体SM_Template_Map_Floor这个网格，而后复制一份，改变他的大小为{0.2, 0.2, 3.0}，位置为：{-230, 0, 160}.接下来，在Detail面板中，找到Physical选项，勾选计算物理Simulate Physics.而后就开始测试吧！

 5.咱们测试的时候回遇到不少问题，退出游戏，提示

  

  不要惧怕，咱们更具这里的信息记录更改就行，通常就是说，某一个网格没有勾选物理选项。这里好像有个问题，就是最后提示地面要模拟物理个警告咱们不用管它。不然，地面就直接掉下去了。测试到最后的结果是，咱们能够用子弹把这个正方体打下去！

 

（十一）增添十字锚点

    UE4有一个基类HUD咱们能够扩展。

  1.新建一个类，父类HUD，命名FPSHUD

  2.咱们想要在屏幕的中央画一个十字的瞄准图片，首先咱们添加对贴图资源的引用，其实引用方法和蓝图同样！

   （1）新建一个变量来引用它，在HUD的.h文件里面添加变量私有的就行：

 

[cpp]  view plain copy print ?
 
  1. private:  
  2.     /**瞄准十字贴图 */  
  3.     UTexture2D* CrosshairTex;  

   （2）咱们在构造函数中引用资源，提醒一下,能够在内容浏览器中经过右键复制引用的方式找到资源的位置.

[cpp]  view plain copy print ?
 
  1. AFPSHUD::AFPSHUD(const FObjectInitializer& ObjectInitializer)  
  2.     : Super(ObjectInitializer)  
  3. {  
  4.     // 引用赋值  
  5.     static ConstructorHelpers::FObjectFinder<UTexture2D> CrosshairTexObj(TEXT("Texture2D'/Game/Texture/crosshair.crosshair'"));  
  6.     CrosshairTex = CrosshairTexObj.Object;  
  7. }  

 

3.HUD基类有一个咱们能够重写的虚函数叫作DrawHUD，来增长咱们自定义的须要往屏幕上添加的内容，咱们如今来重写它！

 HUD.H里面添加

 

[cpp]  view plain copy print ?
 
  1. virtual void DrawHUD() OVERRIDE;  

 cpp里面实现

 

 

[cpp]  view plain copy print ?
 
  1. void AFPSHUD::DrawHUD()  
  2. {  
  3.     Super::DrawHUD();  
  4.       
  5.     // Draw very simple crosshair  
  6.       
  7.     // 找到屏幕可绘区域的中心  
  8.     FVector2D Center(Canvas->ClipX *0.5f, Canvas->ClipY *0.5f);  
  9.       
  10.     //计算一下偏移  
  11.     FVector2D CrosshairDrawPosition((Center.X-(CrosshairTex->GetSurfaceWidth()*0.5)),(Center.Y - (CrosshairTex->GetSurfaceHeight()*0.5f)));  
  12.       
  13.     // 画出来  
  14.     FCanvasTileItem TileItem(CrosshairDrawPosition, CrosshairTex->Resource, FLinearColor::White);  
  15.     TileItem.BlendMode = SE_BLEND_Translucent;  
  16.     Canvas->DrawItem(TileItem);  
  17. }  

 

 3.在游戏模式的构造函数里面添加

 

[cpp]  view plain copy print ?
 
  1. HUDClass = AFPSHUD::StaticClass();  
[cpp]  view plain copy print ?
 
  1. AMyNewFPSGameMode::AMyNewFPSGameMode(const FObjectInitializer& ObjectInitializer)  
  2.     : Super(ObjectInitializer)  
  3. {  
  4.     //DefaultPawnClass = AMyNewFPSCharacter::StaticClass();  
  5.   
  6.     static ConstructorHelpers::FObjectFinder<UBlueprint> PlayerPawnObject(TEXT("Blueprint'/Game/Blueprints/BP_FPSCharacter.BP_FPSCharacter'"));  
  7.     if (PlayerPawnObject.Object != NULL)  
  8.     {  
  9.         DefaultPawnClass = (UClass*)PlayerPawnObject.Object->GeneratedClass;  
  10.     }  
  11.   
  12.     HUDClass = AFPSHUD::StaticClass();  
  13. }  

  注意要写上头文件。

 

  好了，到了这一步，就能够测试了！应该没问题！

（十二） 给角色添加动画

   1.建立动画蓝图，命名Arms_AnimBP ，选择父类:AniInstance  目标骨架为HeroFPP_Skeleton 

   

  2.咱们须要建立一个状态机来设置这些动画的状态和转化，可是要想清楚怎么样来驱动这个状态机。这里咱们须要处理两个事情：1.人物是否是在走路，人物是否是在空中。咱们给动画蓝图添加两个变量来存储这些信息。更多其余建立的方法，能够参考蓝图文档。

   接下来添加两个布尔变量：bIsRunning，bIsFalling   

 3.接下来，咱们看动画蓝图里面的第一张图表：事件图表

  （1）图表中添加第一个事件节点： Event Blueprint Update Animation 

     这个节点容许咱们当动画更新是，更新咱们设置的变量，他们是和整个游戏状态是同步的。

     
  （2）咱们能够经过询问角色的CharacterMovementComponent角色移动组件来为咱们的变量赋正确的数值。为了实现这一点，咱们须要添加一个动画控制角色的引用。添加节点：Try Get Pawn Owner，连线：Cast to Character  （中文为：类型转换为Character）

    

 （3）以下图，在拖出一个节点：中文叫作得到CharacterMovement，继续添加节点Get Movement Mode.   

       （４）如今咱们能够查询CharacterMovementComponent's 组件的MovementMode 来设置bIsFalling 变量是否是真，当咱们在降落的状态的时候。连出新节点: Equal (Enum).(中文：等于枚举值)，设置其属性为Falling，得到变量bIsFalling，最后链接，以下图   

 （5）接着，为了决定咱们是在行走或是在站立，咱们须要得到角色的速度而且设置bIsRunning 为真，固然是在值大于零的时候。反之，先得到速度，若是角色不是站立，那么速度数组的长度会大于零。因此以下图，继续添加节点Vector Length

    最后的最后，蓝图张这个样子：

    4.接下来，来看动画蓝图的第二个图表：动画图表

  （1）右键，新建状态机，重命名为Arms State Machine.如上图连线。

    

   （2）双击ArmStateMachine状态机节点来编辑它的图表。

      

    在这个图表中咱们须要五个状态，接下来处理第一个状态

      （1）图表右键,添加状态,命名为Idle,双击进入状态的图表.

      （2）图表中右键，查找Idle，添加Play FPP_Idle节点，以下图链接：

     

  （3）OK，第一个状态添加成功，接下来，按照一样的方法添加另外的四个状态    

 

  • Run
  • JumpStart
  • JumpEnd
  • JumpLoop
  最后效果：

 

   （4）接下来，咱们来添加状态之间的转换，其实这部分，说白了，就是连线，加转换条件。

      <1>Entry->Idle

      <2>Idle->Run,双击这个线，在里面添加转换的条件

        

        双击连线，进入转换规则的图表，从变量栏中拉出bIsRunning，并得到，而后按照下图连接

        

      <3>Run->Idle

        转换条件：

       

     <4>Idle->JumpStart

      

    <5>Run->JumpStart

      

   <6>JumpStart->JumpLoop

     

     这里有一点要注意：从JumpStart到JumpLoop发生在JumpStart立刻就要完成的时候，因此在转换的规则中，咱们添加一个节点：FPP_JumpStart的剩余时间<=0.1的节点，而后如上图链接。

   <7>JumpLoop->JumpEnd

     

  <8>JumpEnd->Idle

    

  (5)最终的动画图表以下：    

 5.联系动画蓝图和角色蓝图。（两个蓝图的链接！）

  （1）编译、保存动画蓝图

  （2）打开角色蓝图BP_FPSCharacter 

  （3）看下图：

 

 最后最后最后啦！！！！测试你的游戏吧！没问题！

  好了，到目前为止，咱们的这个第一人称射击类游戏就算完成了！

（十三） 总结一下今天

    今天作了以下一些事情：

    1.给角色添加网格，添加自定义摄像机，调整视角，添加第二套网格

  2.添加弹药，实现射击
   （1）添加弹药类，实例化弹药
   （2） 子弹碰撞和生命周期
 3.添加HUD 十字瞄准点
 4.给角色添加动画。
 
  作了不少事，其实最重要的是，应该解决了一些童鞋心中的疑惑，好比：
（一）C++和蓝图应该怎么互相有联系呢？
  答案：能够用蓝图来继承C++的类，这只是他们联系的一张方式，之后，咱们甚至能够本身添加节点，完善蓝图。
（二）C++如何访问蓝图
  答案：经过引用资源这种方式
（三）C++也能够直接添加组件，方式是：
    1.添加变量
    2.构造函数中建立组件
 
第二部分：全篇总结
 
（一）整个流程：
 
第一步:建立工程,并自定义GameMode
    1.建立空白工程
    2.设置启动关卡.
    3.自定义GameMode
    4.修改启动游戏模式为GameMode
 
1.建立关卡
2.建立游戏模式
3.制做一个角色
4.控制输入：映射轴（键盘WASD--前进，鼠标X,Y--向上看，向右看），映射事件（Space--Jump）

仍是那一套，进入游戏测试。

这里总结一下：前面这么多处理输入控制的函数，其实每一类控制要想完成都须要三部：

1.处理映射：在项目设置中处理映射，包括轴映射（键盘鼠标均可以），事件映射。

1.添加函数：这里要在角色的.h和.cpp文件里都要添加，一个是声明一个是实现

2.函数和输入绑定！这一步，在角色重写的那个设置玩家输入组件的函数里面实现。

 

5.给角色添加网格，添加自定义摄像机，调整视角，添加第二套网格

6.添加弹药，实现射击
  （1）添加弹药类，实例化弹药
  （2） 子弹碰撞和生命周期
7.添加HUD 十字瞄准点
8.给角色添加动画。
 
 
（二）我已近把涉及到的这几个类传上去了，仅供参考：
    1.http://pan.baidu.com/s/1dDpOhsH
    2.你们也能够直接新建一个C++的第一人称模板类的项目，啥也别作，打开看看，其实内容是差很少的。
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程