UEC++个人速查
个人速查这里是鄙人在学习U++时候整理的部分笔记，后面也会把自己用到的补充上来。这个笔记存在的唯一原因只是UE的API太过简陋，所以自己找教程看，把基础内容写过来用于copy。接下来自己的学习安排是，打算做一个相对复杂点的蓝图项目熟悉下游戏架构，再将一些蓝图替换成C++，简单的C++游戏已经抄了俩了。后面再看怎么做小型的网络游戏(排队游戏的某个关卡
之类的)。
创建Actor和组件挂载
组件头文件
[*]Components/SceneComponent.h(挂载点，任何组件都必须挂载在挂载点上)
[*]Components/StaticMeshComponent.h(网格体组件)
[*]Components/BoxComponent.h(碰撞组件)
[*]Particles/ParticleSystemComponent.h(粒子系统组件)
[*]Components/AudioComponent.h(声音组件)
只有Actor能挂组件哦。
声明
UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class USceneComponent* MyScene;
UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class UStaticMeshComponent* MyMesh;
UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class UParticleSystemComponent* MyParticle;
UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class UBoxComponent* MyBox;
UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class UAudioComponent* MyAudio;挂载和定义
一般常在构造函数中声明并挂载
定义
MyScene = CreateDefaultSubobject<USceneComponent>(TEXT("CustomSceneName"));
MyMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("CustomStaticMeshName"));
MyParticle = CreateDefaultSubobject<UParticleSystemcComponent>(TEXT("MyCustomParticleSystemName"));
MyBox = CreateDefaultSubobject<UBoxComponent>(TEXT("MyCustomBox"));
MyAudio = CreateDefaultSubobject<UAudioComponent>(TEXT("MyCustomAudio"));挂载
因为只能挂载到DefaultSubobject,所以最好让RootComponent为DefaultSubobject这样就能挂更多组件。一般常在构造方法挂载。
RootComponent = MyScene;
MyMesh->SetupAttachment(MyScene);
MyParticle->SetupAttachment(MyScene);
MyBox->SetupAttachment(MyScene);
MyAudio->SetupAttachment(MyBox);静态加载
静态加载资源
资源文件写死，在确定组件的层级结构后，传入资源并指定到组件对象的某个属性上。声明定义挂载后的下一个选择环节。
FObjectFinder中的参数可以去蓝图中看，蓝图中这些组件的detail中引入用的啥参数就用啥参数。静态加载的时候定义必须写在构造方法中。
//.hUPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class USceneComponent* MyScene;
UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class UStaticMeshComponent* MyMesh;
UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class UParticleSystemComponent* MyParticle;
UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class UBoxComponent* MyBox;
UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class UAudioComponent* MyAudio;//.cppstatic ConstructorHelpers::FObjectFinderTempStaticMesh(TEXT(“网格体模型资产的引用”));MyMesh->SetStaticMesh(TempStaticMesh.Object);static ConstructorHelpers::FObjectFinderTempParticleSystem(TEXT("粒子特效的资产引用"));MyParticle->SetTemplate(TemParticleSystem.Object); static ConstructorHelpers::FObjectFinderTempSound(TEXT("音效资产引用"));MyAudio->SetSound(TempSound.Object);静态加载资源类
不再通过class 加组件的形式前向声明了，而是通过TSubclassOf来实现声明。静态加载的时候定义必须写在构造方法中。同样是将一个资源用一个指针储存，但是涉及到蓝图的类型，所以试用TSubclassOf用一个对象存储任何AActor的子类，
//。h
UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MyClass")
TSubclassOf MyActor;
//.cpp
static ConstructorHelpers::FClassFinder TempMyActor(TEXT("蓝图类资源引用_C"));
MyActor = TempMyActor.class;动态加载
动态加载资源
动态加载放在构造方法外的其他位置，比如BeginPlay中。相对于静态加载资源没啥变化
UStaticMesh* MyTempStaticMesh = LoadObject<UStaticMesh>(nullptr,TEXT("资源引用"));
if(MyTempStaticMesh)MyMesh->SetStaticMesh(MyTempStaticMesh);动态加载类资源
UClass* MyTempClass = LoadClass(this,TEXT("蓝图类资源引用_C"));
if(MyTempClass)AActor* SpawnActor = GetWorld()->SpawnActor(MyTempClass,FVector::ZeroVector,FRotator::ZeroRotator);相机和相机臂
类型选择
[*]必然Pawn或者character这样的panw子类了。
头文件
[*]GameFramework/SpringArmComponent.h(相机臂)
[*]Camera/CameraComponent.h(相机组件)
声明
UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
USceneComponent* MyRoot;
UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
USpringArmComponent* MySprintArm;
UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
UCameraComponent* MyCamera;挂载和定义
定义
在构造方法中实现初始化定义。
MyRoot = CreateDefaultSubobject<USceneComponent>(TEXT("MyRootComponent"));
MySpringArm = CreateDefaultSubobject<USpringArmComponent>(TEXT("MySpringArmComponent"));
MyCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("MyCameraComponent"));挂载
这里挂载也放在构造函数
RootComponent = MyRoot;
MySpringArm->SetupAttachment(MyRoot);
MyCamera->SetupAttachment(MySpringArm);其他配置
MySpringArm->bDoCollisionTest = false;//取消摄像机的碰撞按键映射和鼠标滑轮
类型选择
一般常用PlayerController。因为它提供了很多接口，重载就行，无需造轮子。
似乎PlayerController本身就自带了一个InputComponent,换句话说，如果自己不使用playercontroller只用pawn就得将InputComponent给导入并在构造函数创建即可(不需要挂载)，在beginplay启动输入并调用手动实现的setupinputcomponent。其他相同。
头文件导入
PlayerController控制的那个Pawn的头文件，想要控制Pawn上的摄像机臂或者pawn的位置，必须有其引用。
声明
重载接口函数
virtual void SetupInputComponent();声明映射函数
void WheelUpFunction();
void WheelDownFUnction();
//我是一个辅助函数
void Zoom(bool Direction,ZoomSpeed);定义
在SetupInputComponent()函数中将按键设置和触发类型以及回调函数绑定到inputComponent上来。
Super::SetuupInputComponent();
InputComponent->BindAction(“按键配置名”,IE_Pressed,this,&AmyPlayerController::WheelUpFunction);
InputComponent->BindAction(“按键配置名”,IE_Pressed,this,&AmyPlayerController::WheelDownFunction);在映射函数中WheelUpFunction();通过PlayerController的GetPawn获取受控的引用经过类型判断后进行摄像机臂处理。
if(GetPawn())
{
AMyPawn* MyCameraPawn = Cast(GetPawn());
if(MyCameraPawn)
{
MyCameraPawn->Zoom(1,10);
}
}在Zoom(Direction,ZoomSpeed)函数;根据传入方向和速度进行弹簧臂的拉近和延伸。
if(Direction)
{
if(MySpringArm->TargetArmLength >=300 && MySpringArm->TargetArmLength<5000)
MySpringArm->TargetArmLength+=(ZoomSpeed*2);
}
else
{
if(MySpringArm->TargetArmLength>300 && MySpringArm->TargetArmLength<=5000)
MySpringArm->TargetArmLength0-(ZoomSpeed*2);
}Actor的位置偏移
类型选择
[*]Actor及其子类因为相关的Actor类都实现了。
使用
相对于根节点移动
控制整个Actor的移动，相对于根节点的移动(根节点不动)
[*]需要一个MyOffset表示某个对象移动的方向和距离。
[*]是否忽略碰撞
[*]需要一个HitResult的引用存储是否发生了碰撞作
FVector MyOffset = FVector(1,0,0);
FHitResult HitResult;
AddActorLocalOffset(MyOffset,false,&HitResult);相对于世界的移动
参数同上
AddActorWorldOffset(MyOffset,false,&HitResult);Actor的碰撞-Overlap
头文件
[*]Components/BoxComponent.h(碰撞组件)
声明
MyBox = CreateDefaultSubobject<UBoxComponent>(TEXT("MyCustomBox"));定义与挂载
定义
MyBox = CreateDefaultSubobject<UBoxComponent>(TEXT("MyCustomBox"));挂载
MyBox->SetupAttachment(MyScene);使用
绑定
MyBox->OnComponentBeginOverlap.AddDynamic(this,&AMyActor::BeginOverlapFunction);
MyBox->OnComponentBeginOverlap.AddDynamic(this,&AMyActor::EndOverlapFunction);其他配置--待绑定函数的声明
[*]当前actor的碰撞盒组件
[*]另一个碰撞actor
[*]另一个碰撞actor的碰撞组件
[*]对方组件的body索引(无视)
[*]一个物体是否是主动带着速度撞过来的
[*]主动撞过来时的命中等信息
UFUNCTION()
void BeginOverlapFunction(
UPrimitiveComponent* OverlappedComponent,
AActor* OtherActor,
UPrimitiveComponent* OtherComp,
int32 OtherBodyIndex,
bool bFromSweep,
const FHitResult& SweepResult);
UFUNCTION()
void EndOverlapFunction(
UPrimitiveComponent* OverlappedComponent,
AActor* OtherActor,
UPrimitiveComponent* OtherComp,
int32 OtherBodyIndex);其他配置--待绑定函数的实现
void AMyActor::BeinOverlapFunction(UPrimitiveComponent* OverlappedComponent,
AActor* OtherActor,
UPrimitiveComponent* OtherComp,
int32 OtherBodyIndex,
bool bFromSweep,
const FHitResult& SweepResult)
{
UELOG(......)
}Actor的碰撞Hit
hit不同于beginoverlap的第一次碰撞才触发，hit只要有接触就会触发。
头文件
[*]Components/BoxComponent.h(碰撞组件)
声明
MyBox = CreateDefaultSubobject<UBoxComponent>(TEXT("MyCustomBox"));定义与挂载
定义
MyBox = CreateDefaultSubobject<UBoxComponent>(TEXT("MyCustomBox"));挂载
MyBox->SetupAttachment(MyScene);使用
绑定
MyBox->OnComponentHit.AddDynamic(this,&AMyActor::HitFunction)其他配置--带绑定函数的声明
UFUNCTION()
void HitFunction(
UPrimitiveComponent* HitComponent,
AActor* OtherActor,
UPrimitiveComponent* OtherComp,
FVector NormalImpulse,
const FHitResult& Hit);Actor的碰撞设置
头文件
[*]Components/BoxComponent.h(碰撞组件)
声明
MyBox = CreateDefaultSubobject<UBoxComponent>(TEXT("MyCustomBox"));定义与挂载
定义
MyBox = CreateDefaultSubobject<UBoxComponent>(TEXT("MyCustomBox"));挂载
MyBox->SetupAttachment(MyScene);使用
碰撞设置
MyBox->SetCollisionEnabled(ECollisionEnabled::NoCollision);
MyBox->SetCollisionEnabled(ECollisionEnabled::QueryOnly);
MyBox->SetCollisionEnabled(ECollisionEnabled::PhysicsOnly);
MyBox->SetCollisionEnabled(ECollisionEnabled::QueryAndPhysics);
MyBox->SetCollisionEnabled(ECollisionEnabled::ProbeOnly);
MyBox->SetCollisionEnabled(ECollisionEnabled::QueryAndProbe);碰撞类型
MyBox->SetCollisionObjectType(ECC_WorldStatic);
MyBox->SetCollisionObjectType(ECC_WorldDynamic);
MyBox->SetCollisionObjectType(ECC_Pawn);
MyBox->SetCollisionObjectType(ECC_PhysicsBody);
MyBox->SetCollisionObjectType(ECC_Vehicle);
MyBox->SetCollisionObjectType(ECC_Destructible);碰撞响应
多个通道
MyBox->SetCollisionResponseToALllChannels(ECR_Block); //设置所有通道响应为block
MyBox->SetCollisionResponseToAllChannels(ECR_Overlap);//设所有通道响应为重叠
MyBox->SetCollisionResponseToAllChannels(ECR_Ignore);//设所有通道响应为忽略单个通道
MyBox->SetCollisionResponseToChannel(ECR_Pawn,ECR_Overlap);//对pawn设置为重叠
MyBox->SetCollisionResponseToChannel(ECC_WorldStatic,ECR_Block);//对世界静态设置为阻挡
MyBox->SetCollisionResponseToChannel(ECC_WorldDynamic,ECR_Block);//对世界动态设置为忽略Actor的粒子特效的激活和失效
头文件
[*]Particles/ParticleSystemComponent.h(粒子系统组件)
声明
UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class USceneComponent* MyScene;
UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class UStaticMeshComponent* MyMesh;
UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class UParticleSystemComponent* MyParticle;
UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class UBoxComponent* MyBox;
UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category = "MySceneComponent")
class UAudioComponent* MyAudio;挂载和定义
一般常在构造函数中声明并挂载
定义
MyScene = CreateDefaultSubobject<USceneComponent>(TEXT("CustomSceneName"));
MyParticle = CreateDefaultSubobject<UParticleSystemcComponent>(TEXT("MyCustomParticleSystemName"));挂载
因为只能挂载到DefaultSubobject,所以最好让RootComponent为DefaultSubobject这样就能挂更多组件。一般常在构造方法挂载。
RootComponent = MyScene;
MyParticle->SetupAttachment(MyScene);使用-激活和失效
MyParticle->Activate();
MyParticle->Deactivate();用户控件--按钮
类型选择
[*]选择C++的Widget的UserWidget类进行派生
[*]选则一个PlayerController处理控件的显示。
头文件
[*]控件父类：
[*]Components/Button.h
[*]PlayerController类
[*]Blueprint/UserWidget.h
声明
[*]使用meta的bindwidget相当于将控件名为ButtonStart和ButtonQuit的两个控件的操作句柄暴露给C++方法了。
UPROPERTY(meta=(BindWidget))
UButton* ButtonStart;
UPROPERTY(meta=(BindWidget))
UButton* ButtonQuit;
virtual bool Initialize() override;定义
bool UMyUserWidget::Initialize()
{
if(!Super::Initialize())
{
return false;
}
ButtonStart->OnClicked.AddDynaic(this,&UMyUserWidget::Start());
ButtonQuit->OnClicked.AddDynaic(this,&UMyUserWidget::Quit());
return ture;
}其他配置--待绑定方法声明和定义
//声明：
UFUNCTION()
void Start();
UFUNCTION()
void Quit();
//定义
void UMyUserWidget::Start(){
GEngine->AddOnScreenDebugMessage(-1,5.0f,FColor::Red,TEXT("Start"));
}
void UMyUserWidget::Quit(){
GEngine->AddOnScreenDebugMessage(-1,5.0f,FColor::Red,TEXT("Quit"));
}使用--这里用了动态加载。
[*]进入一个PlayerController类，其实选其他类也是可以的，但是Pawn可能会死，可能会换，World需要手动管理声明周期，而playercontroller几乎贯穿玩家和游戏交互的全流程，因此选择PlayerController。
[*]先将蓝图子类加载到内存，在用UUserWidget这个控件父类指针去指向基于蓝图子类创建出来的Widget。所以LoadClass真的只是读取一个类而不是一个对象,通过指针将控件添加到视口。类似于TSubClassOf，指针存储底稿，运行时根据底稿来创建副本并进行修改。
void AMyPlayerController::BeinPlay()
{
Super::BeginPlay();
UClass* widgetClass = LoadClass<UUserWidget>(NULL,TEXT("控件的蓝图子类的资源引用_C"));
UUserWidget* MyWidgetClass = nullptr;
MyWidgetClass = CreateWidget<UUserWidget>(GetWorld(),widgetClass);
MyWidgetClass->AddToViewPort();
}用户控件--进度条
类型选择
[*]选择C++的Widget的UserWidget类进行派生
[*]选则一个PlayerController处理控件的显示。
头文件
[*]控件父类：
[*]Components/ProgressBar.h
[*]PlayerController类
[*]Blueprint/UserWidget.h
声明
UPROPERTY(meta=(BindWidget))
UProgressBar* ProgressBarHealth;
UPROPERTY(EditAnywhere,BlueprintReadWrite,Category = "MyHealth")
float CurrentHealth = 100.0f;
UPROPERTY(EditAnywhere,BlueprintReadWrite,Category = "MyHealth")
float MaxHealth = 100.0f;
void UpdateHealth(); 定义
void UMyUserWidget::UpdateHealth()
{
float Percent = FMath::Clamp(CurrentHealth/MaxHealth,0.f,1.f);
if(ProgressBarHealth)ProgressBarHealth->SetPercent(Percent);
if (CurrentHealth <= 0)
GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, TEXT("Death"));
else
GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Green, TEXT("-10"));
}其他配置
找一个函数负责调用UpdateHealth().
void UMyUserWidget::Start()
{
UpdateHealth();
}代理--单播
类型选择
选了Actor来派生
代理的声明
[*]代理的声明依靠一个宏，这个宏会在预编译阶段被替换成对一个类的声明，也就是会根据代理名替换城几个类NoParamDelegate,OneParamDelegate,TwoParamDelegate,ThreeParamDelegate,RevalDelegate这些类。
DECLARE_DELEGATE(NoParamDelegate);
DECLARE_DELEGATE_OneParam(OneParamDelegate,FString);
DECLARE_DELEGATE_TwoParams(TwoParamDelegate,FString,int32);
DECLARE_DELEGATE_ThreeParams(ThreeParamsDelegate,FString,int32,float);
DECLARE_DELEGATE_RetVal(FString,RevalDelegate);
[*]通过宏声明了代理后(创建了代理类后)就需要实例化这个所谓的代理(感觉所谓的代理就是一个容器，负责在调用的时候将绑定上去的函数一起执行掉)
NoParamDelegate NoParamDelegate;
OneParamDelegate OneParamDelegate;
TwoParamDelegate TwoParamDelegate;
ThreeParamsDelegate ThreeParamDelegate;
RevalDelegate RevalDelegate;
[*]我觉得是函数容器也并非空穴来风，因为真的很像，这里就是在声明函数了。
void NoParamFunction();
void OneParamFunction(FString str);
void TwoParamFunction(FString str,int32 value);
void ThreeParamFunction(FString str,int32 value,float value1);
FString RevalParamFunction();定义
void AMyDelegateActor::NoParamFunction()
{
GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Blue, TEXT("NoParamDelegate"));
}
void AMyDelegateActor::OneParamFunction(FString str)
{
GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Blue, FString::Printf(TEXT("%s"), *str));
}
void AMyDelegateActor::TwoParamFunction(FString str, int32 value)
{
GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Blue, FString::Printf(TEXT("%s %d"), *str,value));
}
void AMyDelegateActor::ThreeParamFunction(FString str, int32 value, float value1)
{
GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Blue, FString::Printf(TEXT("%s %d %f"), *str, value,value1));
}
FString AMyDelegateActor::RevalParamFunction()
{
FString str = FString::Printf(TEXT("RevalParamDelegate"));
return str;
}使用
[*]绑定方法到代理----在构造方法中将函数绑定到容器中。
NoParamDelegate.BindUObject(this, &AMyDelegateActor::NoParamFunction);
OneParamDelegate.BindUObject(this, &AMyDelegateActor::OneParamFunction);
TwoParamDelegate.BindUObject(this, &AMyDelegateActor::TwoParamFunction);
ThreeParamDelegate.BindUObject(this, &AMyDelegateActor::ThreeParamFunction);
RevalDelegate.BindUObject(this, &AMyDelegateActor::RevalParamFunction);
[*]执行代理---此处在beginplay执行
void AMyDelegateActor::BeingPlay()
{
SUper::BeginPlay();
NoParamDelegate.ExecuteIfBound();
OneParamDelegate.ExecuteIfBound("OneParamDelegate");
TwoParamDelegate.ExecuteIfBound("TwoParamDelegate",10);
ThreeParamDelegate.ExecuteIfBound("ThreeParamDelegate",10,5.0);
FString strValue = RevalDelegate.Execute();
}代理--多播
类型选择
同上单播
代理的声明
我说实话，多播感觉就更像一个容器了。
[*]代理声明
DECLARE_MULTICAST_DELEGATE_OneParam(OneParamMultiDelegate,FString)
[*]代理实例化
OneParamMultiDelegate OneParamMultiDelegate;
[*]绑定函数的声明
UFUNCTION()
void MultiDelegateFunction1(FString str);
UFUNCTION()
void MultiDelegateFunction2(FString str);
UFUNCTION()
void MultiDelegateFUnction3(FString str);定义
定义函数
void AMyDelegateActor::MultiDelegateFunction1(FString str)
{
FString TempStr = str.Append("1");
GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, FString::Printf(TEXT("%s"), *TempStr));
}
void AMyDelegateActor::MultiDelegateFunction2(FString str)
{
FString TempStr = str.Append("2");
GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, FString::Printf(TEXT("%s"), *TempStr));
}
void AMyDelegateActor::MultiDelegateFUnction3(FString str)
{
FString TempStr = str.Append("3");
GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, FString::Printf(TEXT("%s"), *TempStr));
}使用
[*]绑定代理，感觉多播更像容器了---这里在构造方法绑定的
OneParamMultiDelegate.AddUObject(this, &AMyDelegateActor::MultiDelegateFunction1);
OneParamMultiDelegate.AddUObject(this, &AMyDelegateActor::MultiDelegateFunction2);
OneParamMultiDelegate.AddUObject(this, &AMyDelegateActor::MultiDelegateFUnction3);
[*]执行代理---这里再Beginplay执行的
OneParamMultiDelegate.Broadcast("OneParamMultiDelegate");代理--动态多播
类型选择
同上单播,动态多播好像是可以给蓝图用。
代理的声明
[*]声明代理，动态多播必须用F开头作为标识
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FDynamicMultiDelegate, FString, param);
[*]实例化
UPROPERTY(BlueprintAssignable)
FDynamicMultiDelegate DynamicMultiDelegate;使用
因为动态多播可以给蓝图用，所以不需要实现函数并绑定(当然也可以),那就只剩执行了---这里放在Beginplay中了
DynamicMultiDelegate.Broadcast("DynamicMultiDelegate");发射物类
基类选择
Actor
头文件
[*]Components/StaticMeshComponent.h(子弹怎么能没有网格体呢？)
[*]Components/CapsuleComponent.h(子弹必须有碰撞网格，最好是胶囊体)
[*]GameFramework/ProjectileMovementComponent.h(发射物运动组件，发射物必备)
声明
public:
UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category="MyComponent")
UStaticMeshComponent* MyBullet;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "MyComponent")
UCapsuleComponent* MyCapsule;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "MyComponent")
UProjectileMovementComponent* MyProjectile;定义
在构造方法进行初始化
[*]创建组件并完成挂载
[*]静态加载网格体模型
[*]设置Bullet相对于的根节点大小
[*]UMovementComponent提供了一批移动转向相关的函数，其子类负责实现在tick中调用这些函数实现运动逻辑
[*]SetupDatedComponent后面跟的就是打算将移动委托给移动组件处理的一个组件
[*]InitialSpeed发射瞬间速度，MaxSpeed飞行速度上限，bRotationFollowsVelocity弹头是否使用面朝飞行方向，bIsHomingProjectile是否启用追踪效果，ProjectileGravityScale重力倍率
MyBullet = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("MyBulletComponent"));
MyCapsule = CreateDefaultSubobject<UCapsuleComponent>(TEXT("MyCapsuleComponent"));
MyProjectile = CreateDefaultSubobject<UProjectileMovementComponent>(TEXT("MyProjectileComponent"));
static ConstructorHelpers::FObjectFinder<UStaticMesh> TmpStaticMesh(TEXT("网格体引用"));
MyBullet->SetStaticMesh(TmpStaticMesh.Object);
MyBullet->SetRelativeScale3D(FVector(0.4, 0.4, 0.4));
RootComponent = MyBullet;
MyCapsule->SetupAttachment(MyBullet);
MyProjectile->SetUpdatedComponent(MyBullet);
MyProjectile->InitialSpeed = 1200.0f;
MyProjectile->MaxSpeed = 2400.f;
MyProjectile->bRotationFollowsVelocity = true;
MyProjectile->bIsHomingProjectile = true;
MyProjectile->ProjectileGravityScale = 1.5f;Character和增强输入
派生方式
派生自一个Character类
Build配置
添加"EnhancedInput"于Build.cs
头文件
[*]InputActionValue.h
[*]EnhancedInputComponent.h
[*]EnhancedInputSubsystems.h
[*]GameFramework/Controller.h
[*]GameFramework/SpringArmComponent.h
[*]Camera/CameraComponent.h
[*]GameFramework/CharacterMovementComponent.h
声明
[*]两个摄像机相关组件
[*]一个映射上下文组件(个人理解：老输入映射方式是在项目配置里写，实际上是更类似于宏一样的方式，很死板，增强输入引入一个资产用于保存输入输出映射，这个资产就是UInputMappingContext。而UInputAction就是UInputMappingContext的字段，只不过得写在同级的属性中。)
public:
UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category="MySceneComponent")
USpringArmComponent* MySpringArm;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "MySceneComponent")
UCameraComponent* MyCamera;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
class UInputMappingContext* DefaultMappingContext;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
class UInputAction* MoveAction;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
class UInputAction* LookAction;
void Move(const FInputActionValue& Value);
void Look(const FInputActionValue& Value);定义
[*]初始化
[*]创建组件并命名
[*]进行配置
[*]配置相机臂长度
[*]将角色的yaw,poll,pitch,的旋转和摄像机隔离开，方便摄像机环顾而角色朝向独立(ARPG)
[*]将角色朝向锁定到移动的方向
[*]BeginPlay
[*]在当前character为玩家控制时，获取输入系统并利用这个子系统将输入方案挂载到玩家上。(个人理解，子系统就是个翻译，它会查UInputMappingContext表并返回输入映射数据)
[*]指定要查的表UInputMappingContext.
[*]SetupPlayerInputComponent
[*]绑定函数到表中的两个字段
[*]Move
[*]Value是在组件内就绑定在委托上的输入了。
[*]获取相机朝向并抽取XOY平面上的朝向
[*]将朝向这个向量拆分成两个X轴和Y轴的分向量，并将移动信息替换到位置信息。
AMyCharacter::AMyCharacter()
{
// Set this character to call Tick() every frame.You can turn this off to improve performance if you don't need it.
PrimaryActorTick.bCanEverTick = true;
//创建组件并命名挂载
MySpringArm = CreateDefaultSubobject<USpringArmComponent>(TEXT("MySpringArmComponent"));
MyCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("MyCameraComponent"));
MyCamera->SetupAttachment(MySpringArm);
MySpringArm->SetupAttachment(RootComponent);
/*1. 配置相机臂长度
1. 将角色的yaw,poll,pitch,的旋转和摄像机隔离开，方便摄像机环顾而角色朝向独立(ARPG)*/
MySpringArm->TargetArmLength = 400.0f;
bUseControllerRotationPitch = false;
bUseControllerRotationYaw = false;
bUseControllerRotationRoll = false;
//将角色朝向锁定到移动的方向
GetCharacterMovement()->bOrientRotationToMovement = true;
//
MySpringArm->bUsePawnControlRotation = true;
}
void AMyCharacter::BeginPlay()
{
Super::BeginPlay();
if (APlayerController* PlayerController = Cast(Controller))
{
if (UEnhancedInputLocalPlayerSubsystem* Subsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(PlayerController->GetLocalPlayer()))
{
Subsystem->AddMappingContext(DefaultMappingContext,0);
}
}
}
void AMyCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
Super::SetupPlayerInputComponent(PlayerInputComponent);
if (UEnhancedInputComponent* EnhancedInputComponent = CastChecked<UEnhancedInputComponent>(PlayerInputComponent))
{
EnhancedInputComponent->BindAction(MoveAction, ETriggerEvent::Triggered, this, &AMyCharacter::Move);
EnhancedInputComponent->BindAction(LookAction, ETriggerEvent::Triggered, this, &AMyCharacter::Look);
}
}
void AMyCharacter::Move(const FInputActionValue& Value)
{
FVector2D MovementVector = Value.Get<FVector2D>();
if (Controller!=nullptr)
{
const FRotator Rotation = Controller->GetControlRotation();
const FRotator YawRotation(0, Rotation.Yaw, 0);
const FVector ForwardDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
const FVector RightDirection = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);
AddMovementInput(ForwardDirection, MovementVector.Y);
AddMovementInput(RightDirection, MovementVector.X);
}
}
void AMyCharacter::Look(const FInputActionValue& Value)
{
FVector2D LookAxisVector = Value.Get<FVector2D>();
if (Controller != nullptr)
{
AddControllerYawInput(LookAxisVector.X);
AddControllerPitchInput(LookAxisVector.Y);
}
}接口
选择类型
[*]Interface进行派生
[*]MyCharacter类
头文件
[*]MyCharacter:Myinterface.h
声明
接口是一个给别的类继承的抽象类,所以只有什么没有定义，定义在其他类
public:
virtual void Attack() {};
virtual void CalculateHealth() {};重载声明
class XXXXXXX_API AMyCharacter : public ACharacter,public IMyInterface
{
public:
virtual void Attack() override;
virtual void CalculateHealth() override;
}定义
void AMyCharacter::Attack()
{
IMyInterface::Attack();
GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, TEXT("Attack"));
}
void AMyCharacter::CalculateHealth()
{
IMyInterface::CalculateHealth();
GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, TEXT("CalculateHealth"));
}使用
尝试载beginplay中调用。
TimeHndle定时器
派生方式
派生自Scharacter,还是之前的MyCharacter类。
头文件
[*]TimeManager.h
声明
[*]声明一个操纵定时器的句柄
FTimerHandle Time;其他配置--回调函数
//声明
void PrintF();
//定义
void AMyCharacter::PrintF()
{
GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, TEXT("Time"));
}使用
[*]设置定时器--常在Beginplay里
[*]参数：定时器句柄，this，回调函数，定时器时间长度s,是否循环定时。
[*]UWorld中管理着所有定时器，gettimermanager可以返回一个单例，这个单例有存放句柄的素组，这个单例提供了设置定时器句柄数组的方式入SetTimer和ClearTimer.
void AMyCharacter::BeginPlay()
{
GetWorld()->GetTimerManager().SetTimer(Time, this, &AMyCharacter::PrintF, 1.0, true);
if(Time.IsValid())
{
GetWorld()->GetTimerManager().ClearTimer(Time);
}
}3DWidget
派生方式
[*]使用UserWidget进行派生->MyHealthWidget
[*]做出来的控件给MyCharacter类调用
头文件
[*]MyCharacter类
[*]Components/WidgetComponent.h(用父类指针指向蓝图子类对象)
[*]MyHealthWidget
[*]无（因为这里没有使用控件组件,按钮之类的，所有视觉元素都在蓝图中构建的。)
声明
[*]MyHealthWidget类
public:
UPROPERTY(EditAnywhere,BlueprintReadWrite,Category="MyWidget")
float CurrentHealth=100.0f;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="MyWidget")
float MaxHealth = 100.0f;
[*]MyCharacter类
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "MySceneComponent")
UWidgetComponent* MyWidgetHealth;定义
[*]MyHealthWidget类：没有源文件定义，定义(如UI,函数等)写在对应控件蓝图子类中。
[*]MyCharacter类
[*]创建一个控件组件并命名且挂载
[*]静态读取资源类引用
[*]配置一个空间蓝图的蓝图类资源句柄到控件组件上，并配置组件的位置，再让UI贴在屏幕上，和缩放。
AMyCharacter::AMyCharacter()
{
MyWidgetHealth = CreateDefaultSubobject<UWidgetComponent>(TEXT("MyWidgetComponent"));
MyWidgetHealth->SetupAttachment(RootComponent);
static ConstructorHelpers::FClassFinder<UUserWidget>WidgetClass(TEXT("蓝图资源引用_C"));
MyWidgetHealth->SetWidgetClass(WidgetClass.Class);
MyWidgetHealth->SetRelativeLocation(FVector(0, 0, 100));
MyWidgetHealth->SetWidgetSpace(EWidgetSpace::Screen);
MyWidgetHealth->SetDrawSize(FVector2D(400,20));
}Damage相关
派生方式
MyActor
头文件
[*]Kismet/GameplayStatic.h
[*]MyCharacter.h
声明
[*]AMyCharacter--重载并声明TakeDamage方法
virtual float TakeDamage(float DamageAmount,struct FDamageEvent const & DamageEvnt,class AController* EventInstigator,AActor* DamageCause) override;定义
[*]AMyCharacter
float AMyCharacter::TakeDamage(float DamageAmount, struct FDamageEvent const& DamageEvnt,
class AController* EventInstigator, AActor* DamageCause)
{
UMyHealthWidget* MyWidget = Cast<UMyHealthWidget>(MyWidgetHealth->GetUserWidgetObject());
if (MyWidget)
{
if (MyWidget->CurrentHealth <=0)
{
return 0.0f;
}
MyWidget->CurrentHealth -= 5.0;
}
return 0.0f;
}使用
[*]AMyActor，施加伤害---常用在碰撞事件中.
[*]这是一个用于绑定到6参数委托上的函数
[*]将另外一个Actor尝试转换，如果另一个Actor是MyCharacter那就调用施加伤害的函数
[*]参数：待受伤Actor，伤害数值，伤害施加者的控制器(为空可能来源于陷阱)，伤害世家这，上海类型
void AMyActor::BeingOverlapFunction(UPrimitiveComponent* OverlappedComponent,
AActor* OtherActor,
UPrimitiveComponent* OtherComp,
int32 OtherBodyIndex,
bool bFromSweep,
const FHitResult& SweepResult)
{
AMyCharacter* MyCharacter = Cast(OtherActor);
if(MyCharacter)
{
UGameplayStatics::ApplyDamage(MyCharacter,5.0f,nullptr,this,UDamageType::StaticClass());
}
}Timeline开关门
派生方式
Actor
头文件
[*]Components/BoxComponent.h
[*]Components/TimelineComponent.h
[*]MyCharacter.h(涉及类型转换,特定类型去触发)
声明
[*]
FOnTimelineFloat TimelineDelegate;
FOnTimelineEvent TimelineFinishedDelegate;
UFUNCTION()
void TimelineStart(float value);
UFUNCTION()
void TimelineFinished(float value);
UPROPERTY(EditAnywhere,BlueprintReadWrite,Category = "MySceneComponent")
USceneComponent* MyScene;
UPROPERTY(EditAnywhere,BlueprintReadWrite,Category = "MySceneComponent")
UStaticMeshComponent* MyStaticMesh;
UPROPERTY(EditAnywhere,BlueprintReadWrite,Category ="MySceneComponent")
UBoxComponent* MyBox;
UPROPERTY(EditAnywhere,BlueprintReadWrite,Category = "MyCurve")
UCurveFloat* MyCurveFloat;
UPROPERTY(EditAnywhere,BlueprintReadWrite,Category = "MySceneComponet")
UTimelineComponent* MyTimeline;
UFUNCTION()
void BeginOverlapFunction(
UPrimitiveComponent* OverlappedComponent,
AActor* OtherActor,
UPrimitiveComponent* OtherComp,
int32 OtherBodyIndex,
bool bFromSweep,
const FHitResult& SweepResult);
UFUNCTION()
void EndOverlapFunction(
UPrimitiveComponent* OverlappedComponent,
AActor* OtherActor,
UPrimitiveComponent* OtherComp,
int32 OtherBodyIndex);定义
[*]构造函数初始化
[*]创建并声明组件MyTimelineComponent,MySene,StaticMesh,Box
[*]静态加载网格体
[*]构建挂载层级
[*]配置碰撞盒的大小,位置
[*]BeginPlay进行配置
[*]将帧更新的回调绑定到TimelineStart函数
[*]将播放完成的回调绑定到TimelineFinished函数
[*]使用曲线去驱动浮点量
[*]播放完就停,设置为不循环
[*]设置未从0秒开始播放
[*]设置立即开始播放
[*]把播放结束回调给timeline
[*]绑定两个回调函数到碰撞盒
AMyTimelineActor::AMyTimelineActor()
{
// Set this actor to call Tick() every frame.You can turn this off to improve performance if you don't need it.
PrimaryActorTick.bCanEverTick = true;
MyTimeline = CreateDefaultSubobject<UTimelineComponent>(TEXT("MyTimelineComponent"));
MyScene = CreateDefaultSubobject<USceneComponent>(TEXT("MySceneComponent"));
MyStaticMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("MyStaticMeshComponent"));
MyBox = CreateDefaultSubobject<UBoxComponent>(TEXT("MyBoxComponent"));
static ConstructorHelpers::FObjectFinder<UStaticMesh>TmpStaticMesh(TEXT("资源引用"));
if (TmpStaticMesh.Succeeded())
{
MyStaticMesh->SetStaticMesh(TmpStaticMesh.Object);
}
RootComponent = MyScene;
MyStaticMesh->SetupAttachment(MyScene);
MyBox->SetupAttachment(MyScene);
MyBox->SetBoxExtent(FVector(200, 100, 100));
MyBox->SetRelativeLocation(FVector(200, 0, 0));
}
void AMyTimelineActor::BeginPlay()
{
Super::BeginPlay();
TimelineDelegate.BindUFunction(this, TEXT("TimelineStart"));
TimelineFinishedDelegate.BindUFunction(this, TEXT("TimelineFinished"));
MyTimeline->AddInterpFloat(MyCurveFloat, TimelineDelegate);
MyTimeline->SetLooping(false);
MyTimeline->PlayFromStart();
MyTimeline->Play();
MyTimeline->SetTimelineFinishedFunc(TimelineFinishedDelegate);
MyBox->OnComponentBeginOverlap.AddDynamic(this, &AMyTimelineActor::BeginOverlapFunction);
MyBox->OnComponentEndOverlap.AddDynamic(this, &AMyTimelineActor::EndOverlapFunction);
}其他配置--待绑定函数的定义
void AMyTimelineActor::TimelineStart(float value)
{
GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, TEXT("Timelineplay"));
float YawRotation = FMath::Lerp(0, 90, value);
MyStaticMesh->SetRelativeRotation(FRotator(0, YawRotation, 0));
}
void AMyTimelineActor::TimelineFinished(float value)
{
GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, TEXT("TimelineFinished"));
}
void AMyTimelineActor::BeginOverlapFunction(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor,
UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult)
{
AMyCharacter* TmpCharacter = Cast(OtherActor);
if (TmpCharacter)
{
MyTimeline->PlayFromStart();
}
}
void AMyTimelineActor::EndOverlapFunction(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor,
UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)
{
AMyCharacter* TmpCharacter = Cast(OtherActor);
if (TmpCharacter)
{
MyTimeline->ReverseFromEnd();
}
}射线检测
派生方式
Actor
声明
FVector StartLocation;
FVector ForwardVector;
FVector EndLocation;
FHitResult HitResult;使用
[*]通道检测
[*]需要起始点位置和起始点朝向，终点位置
[*]进行Visibility通道的射线检测，命中单位写入HitResult中
[*]如果命中了，就获取命中结果中的Actor，并抽取命中的表面点(ImpactPoint)
void AMyCharacter::Tick(float DeltaTime)
{
Super::Tick(DeltaTime);
StartLocation = MyCamera->GetComponentLocation();
ForwardVector = MyCamera->GetForwardVector();
EndLocation = StartLocation + ForwardVector * 9999;
bool bHit = GetWorld()->LineTraceSingleByChannel(HitResult, StartLocation, EndLocation, ECC_Visibility);
if (bHit)
{
AActor* HitActor = HitResult.GetActor();
FVector ImpactPoint = HitResult.ImpactPoint;
FVector HitLocation = HitResult.Location;
GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, FString::Printf(TEXT("%s"), *HitActor->GetName()));
}
}
[*]对象检测
[*]构建射线的发出点和方向，和重点位置
[*]构建对象类型查询列表FCollisionObjectQueryParams实例
[*]想列表添加类型
void AMyCharacter::Tick(float DeltaTime)
{
Super::Tick(DeltaTime);
StartLocation = MyCamera->GetComponentLocation();
ForwardVector = MyCamera->GetForwardVector();
EndLocation = StartLocation + ForwardVector * 9999;
FCollisionObjectQueryParams objectType;
objectType.AddObjectTypesToQuery(ECC_WorldDynamic);
bool bHit2 = GetWorld()->LineTraceSingleByObjectType(HitResult, StartLocation, EndLocation, objectType);
if (bHit2)
{
AActor* HitActor2 = HitResult.GetActor();
FVector ImpactPoint2 = HitResult.ImpactPoint;
FVector HitLocation2 = HitResult.Location;
GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, FString::Printf(TEXT("%s"), *HitActor2->GetName()));
}
}多射线通道检测和对象检测
派生方式
Actor
声明
//射线检测
FVector StartLocation;
FVector ForwardVector;
FVector EndLocation;
//多通道射线检测
TArray<FHitResult> HitResults;使用
[*]多通道检测和单通道检测的区别在于多通道有穿透。
void AMyCharacter::Tick(float DeltaTime)
{
Super::Tick(DeltaTime);
StartLocation = MyCamera->GetComponentLocation();
ForwardVector = MyCamera->GetForwardVector();
EndLocation = StartLocation + ForwardVector * 9999;
bool HitMulti = GetWorld()->LineTraceMultiByChannel(HitResults, StartLocation, EndLocation, ECC_Visibility);
if (HitMulti)
{
for (int32 i = 0;i<HitResults.Num();i++)
{
AActor* HitMultiActor = HitResults.GetActor();
FVector HitLocation = HitResults.Location;
FVector HitImpactPoint = HitResults.ImpactPoint;
GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, FString::Printf(TEXT("%s"), *HitMultiActor->GetName()));
}
}
}
[*]多对象检测
void AMyCharacter::Tick(float DeltaTime)
{
Super::Tick(DeltaTime);
StartLocation = MyCamera->GetComponentLocation();
ForwardVector = MyCamera->GetForwardVector();
EndLocation = StartLocation + ForwardVector * 9999;
FCollisionObjectQueryParams objectType;
objectType.AddObjectTypesToQuery(ECC_WorldStatic);
bool HitMulti = GetWorld()->LineTraceMultiByObjectType(HitResults, StartLocation, EndLocation, ECC_Visibility);
if (HitMulti)
{
for (int32 i =0;i<HitResults.Num();i++)
{
AActor* HitMultiActor = HitResults.GetActor();
FVector HitLocation = HitResults.Location;
FVector HitImpactPoint = HitResults.ImpactPoint;
GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, FString::Printf(TEXT("%s"), *HitMultiActor->GetName()));
}
}
}软引用和同异步资源加载
概念
UE提供了两种引用软引用和应引用
[*]硬引用，拥有资源对象的属性,硬引用被加载在内存中，则被引用的资源也会被载入到内存，如直接的指针，或者TSubclassOf引用，或者组件子对象
[*]软引用，仅存储资源路径，只有在需要时才会被加载到内存中。
派生方式
Actor->派生一个MySoftActor
头文件
[*]Engine/AssetManager.h
声明
UPROPERTY(EditAnywhere,BlueprintReadWrite,Category = "Path")
FSoftObjectPath AssetObjectPath;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Path")
FSoftClassPath AssetClassPath;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Path")
TSoftObjectPtr AssetObjectPtr;
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Path")
TSoftClassPtr AssetClassPtr;使用
异步加载资源
[*]初始化资源加载的路径
[*]用指针存储待会要异步加载的资源的句柄但是暂时还不加载
[*]通过句柄进行异步加载，仅在GetLoadedAsset()的时候才加载资源
void AMySoftActor::BeginPlay()
{
Super::BeginPlay();
FSoftObjectPath Path1 = TEXT("/Script/Engine.StaticMesh'/Game/StarterContent/Props/SM_Chair.SM_Chair'");
TSharedPtr<FStreamableHandle>SyncStreamHandle = UAssetManager::GetStreamableManager().RequestAsyncLoad(Path1);
if (SyncStreamHandle)
{
UTexture2D* Image1 = Cast<UTexture2D>(SyncStreamHandle->GetLoadedAsset());
if (Image1)
{
GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, FString::Printf(TEXT("%s"), *Image1->GetName(())));
}
}
}同步加载
void AMySoftActor::BeginPlay()
{
Super::BeginPlay();
FSoftObjectPath Path2 = TEXT("/Script/Engine.StaticMesh'/Game/StarterContent/Props/SM_Chair.SM_Chair'");
TSharedPtr<FStreamableHandle> SyncStreamHandle = UAssetManager::GetStreamableManager().RequestSyncLoad(Path2);
if (SyncStreamHandle)
{
UTexture2D* Image2 = Cast<UTexture2D>(SyncStreamHandle->GetLoadedAsset());
if (Image2)
{
GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, FString::Printf(TEXT("%s"), *Image2->GetName()));
}
}
}UE共享指针和引用以及弱指针
派生方式
Actor->派生MySmartPtrActor
辅助工具
class TestA
{
public:
int a = 0;
float b = 0;
TestA()
{
a = 0;
b = 0;
};
TestA(int a, float b)
{
this->a = a;
this->b = b;
}
~TestA()
{
UE_LOG(LogTemp, Warning, TEXT("xigou"));
};
};使用
共享指针
[*]共享指针时可以初始化为空的并用MakeSharedable进行重新赋值。
[*]ESPMode::ThreadSafe可以用于创造线程安全的共享指针，本质上是让操作原子化,保证读取只能读取写入完的数据或者未写入的数据，不存在写了几个字节没写完的数据。
%% 原始的指针需要手动delete %%
TestA* ptr1 = new TestA(1,2.0f);
%% 用裸指针左值赋值共享指针，可能会导致裸指针释放后共享指针再次释放 %%
TSharedPtr<TestA> Sharedptr2(ptr1);
ptr1 = nullptr;
%% 共享指针右值初始化,资源在创建的时候理解被共享指针接管，无所有权歧义 %%
TSharedPtr<TestA>Sharedptr3(new TestA(3, 4.0f));
%% 拷贝构造函数初始化，同类数据左值传入 %%
TSharedPtr<TestA>Sharedptr4(Sharedptr3);
%% UE的方式初始化共享指针，共享指针时可以初始化未空的，通过MakeShareable再赋值 %%
TSharedPtr<TestA>Sharedptr5 = nullptr;
Sharedptr5 = MakeShareable(new TestA(5, 6.0f));
%% 线程安全的共享指针 %%
TSharedPtr<TestA, ESPMode::ThreadSafe>Sharedptr6(new TestA(7, 8.0f));
[*]SharedRef创建一个共享引用。
[*]SharedPtr类的ToSharedRef方法可以创建指向数据的一个引用并返回
[*]SharedPtr类的GetSharedReferenceCount可以获取引用数
[*]IsUnique判断是否引用计数为1
[*]Get方法获取裸指针
[*]Reset()将指针充值为nullptr，并将引用计数减一。本质上来说是让此共享指针放弃所有权。
if (Sharedptr5.IsValid())
{
TSharedRef<TestA>SharedRef1(new TestA(9, 10.0));
SharedRef1 = Sharedptr5.ToSharedRef();
int32 Count1 = Sharedptr5.GetSharedReferenceCount();//获取引用计数
UE_LOG(LogTemp, Warning, TEXT("Count1 is %d"), Count1);
if (!Sharedptr5.IsUnique())
{
UE_LOG(LogTemp, Warning, TEXT("sharedptr is not unique"));
}
Sharedptr5.Get()->a;//Get方法解引用。
UE_LOG(LogTemp, Warning, TEXT("sharedptr is %d"), Sharedptr5.Get()->a);
Sharedptr5.Reset();//把共享指针包裹的裸指针置为null。
int32 Count2 = Sharedptr5.GetSharedReferenceCount();
UE_LOG(LogTemp, Warning, TEXT("Count2 is %d"), Count2);
}共享引用
[*]类似于引用，是不存在空这种状态的。
[*]底层实现和共享指针完全一样，所以还是用->解引用
[*]共享引用转共享指针无开销
%% 共享引用初始化时必须指向一个有效的对象 %%
TSharedRef<TestA> SharedRef2(new TestA(7, 8.0f));
if (SharedRef2.IsUnique())
{
%% 共享引用也用指针访问 %%
SharedRef2->a;
UE_LOG(LogTemp, Warning, TEXT("Sharedref2a is %"), SharedRef2->a);
%% 共享引用->共享指针 %%
TSharedPtr<TestA> SharedPtr6;
SharedPtr6 = SharedRef2;
SharedPtr6.Get()->b;
UE_LOG(LogTemp, Warning, TEXT("Sharedptr6 b is %f"), SharedPtr6.Get()->b);
}弱指针
[*]弱指针用于循环引用，可以不占用引用计数
[*]不能组织对象被销毁
[*]在堆上创建一个数据并用共享指针指向。
[*]创建一个引用，应用着堆上一个对象
[*]声明弱指针，指向两个指针的数据，不拥有，只查看
[*]判断对象是否存活，强引用计数大于0才存活
[*]Pin用于提升弱指针到强指针，只要pin时对象存在就会将引用计数加一并返回共享指针。
%% 弱指针解决了循环引用，只对弱指针保留引用权，不增加引用计数 %%
%% 不能阻止对象被销毁。 %%
TSharedPtr<TestA>Sharedptr7 = MakeShareable(new TestA(10, 11.0f));
TSharedRef<TestA>SharedRef3(new TestA(12, 13.0f));
//声明弱指针
TWeakPtr<TestA>WeakPtr1(Sharedptr7);
TWeakPtr<TestA>WeakPtr2(SharedRef3);
if (WeakPtr1.IsValid())
{
TSharedPtr<TestA>Sharedptr8(WeakPtr1.Pin());
if (Sharedptr8.IsValid())
{
Sharedptr8.Get()->a;
UE_LOG(LogTemp, Warning, TEXT("Sharedptr8a is %d"), Sharedptr8.Get()->a);
}
}常用函数
派生方式
这里用的Actor，但是并不重要，这里是函数的列表查看吧。
头文件
[*]Kismet/GameplayStatics.h
声明
public:
UFUNCTION(BlueprintCallable,Category="MyTestFunction")
void MyOpenlevel();
UFUNCTION(BlueprintCallable, Category = "MyTestFunction")
void MyCurrentLevelName();
UFUNCTION(BlueprintCallable, Category = "MyTestFunction")
void MyQuitGame();定义
[*]BeginPlay
[*]GetAllActorOfClass()：查找关卡世界中所有StaticClass类的对象并塞入OutActors容器。
[*]遍历并输出容器中actor的名称
[*]MyOpenLevel
[*]打开名称指定的地图
[*]MyCurrentLevelName
[*]获取当前关卡的名称并输出
[*]MyQuitGame
[*]调用退出游戏命令。
void AMyFunctionLibraryActor::BeginPlay()
{
Super::BeginPlay();
TArrayOutActors;
UGameplayStatics::GetAllActorsOfClass(GetWorld(), AActor::StaticClass(), OutActors);
for (int32 i =0;i<OutActors.Num();i++)
{
UE_LOG(LogTemp, Warning, TEXT("Actor is %s"), *OutActors->GetName());
}
}
void AMyFunctionLibraryActor::MyOpenLevel()
{
UGameplayStatics::OpenLevel(GetWorld(), TEXT("关卡名称"));
}
void AMyFunctionLibraryActor::MyCurrentLevelName()
{
FString MyCurrentLevelName = UGameplayStatics::GetCurrentLevelName(GetWorld());
GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, FString::Printf(TEXT("MyCurrentLevelName is %s"), *MyCurrentLevelName));
}
void AMyFunctionLibraryActor::MyQuitGame()
{
UGameplayStatics::GetPlayerController(GetWorld(), 0)->ConsoleCommand("quit");
}字符串操作
派生方式
Actor->派生MyStringActor
头文件
[*]Kismet/KismetStringLibrary.h
使用
[*]查看是否存在指定字符
%% 查找字符串是否包含指定字符。 %%
bool isFind1 = MyString.Contains("b", ESearchCase::IgnoreCase, ESearchDir::FromStart);
bool isFind2 = UKismetStringLibrary::Contains(MyString, "b", ESearchCase::CaseSensitive, ESearchDir::FromStart);
[*]判断两子妇产是否相等
bool isFind3 = MyString.Equals("123");
[*]拼接字符串
FString MyString2 = MyString.Append("OBJ");
[*]字符串长度
int32 Num = MyString.Len();
int32 Num2 = UKismetStringLibrary::Len(MyString);
[*]字符串是否为空
bool isEmpty = MyString.IsEmpty();
[*]从指定位置开始的字符串返回一个子字符串
FString MyChildString = UKismetStringLibrary::GetSubstring(MyString,0,3);
[*]查看字符串中的子字符串的起始索引
int32 Index1 = UKismetStringLibrary::FindSubstring(MyString,"123",false,false,0);
[*]返回第几个字符的ascaii吗
int32 Index2 = UKismetStringLibrary::GetCharacterAsNumber(MyString,0);
[*]返回一个数组
TArray<FString>MyArrayString;
MyArrayString = UKismetStringLibrary::GetCharacterArrayFromString(MyString);
[*]大写化
FString MyUpperString = MyString.ToUpper();
[*]小写化
FString MyLowerString = MyString.ToLower();
[*]在字符串左右侧填充指定数量字符
FString MyLeftpadString = MyString.LeftPad(3);
FString MyRightpadString = MyString.RightPad(3);
[*]检查字符串中是否包含数字字符
bool IsNumber = MyString.IsNumeric();
[*]测试字符串是否以给定的字符串为开头或者结尾
bool isStart = MyString.StartsWith("abcd",ESearchCase::IgnoreCase);
bool isEnd = MyString.EndsWith("1234",ESearchCase::IgnoreCase);
[*]字符串替换,将a换成$
UKismetStringLibrary::Replace(MyString,"a","$",ESearchCase::IgnoreCase);
[*]返回最左边或最右边给定的字符数
UKismetStringLibrary::Left(MyString,2);
UKismetStringLibrary::Right(MyString,2);
[*]返回最左边或者最右边给定的字符数，从末尾切掉给定数量的字符
UKismetStringLibrary::LeftChop(MyString,1);
UKismetStringLibrary::RightChop(MyString,2);
[*]从起始位置返回count个字符的子字符串
UKismetStringLibrary::Mid(MyString,2,3);
[*]分割出左右俩字符串
FString Left;
FString Right;
MyString.Split("_",&Left,&Right,ESearchCase::IgnoreCase,ESearchDir::FromStart);
[*]从分割符划分的元字符中获取字符串数组，并可选择剔除空字符
TArray<FString> MyStringArrayParse;
MyString.ParseIntoArray(MyStringArrayParse,TEXt("_"),true);
for(auto TestArray:MyStringArrayParse){
GEngine->AddOnScreenDebugMessage(-1,5.0f,FColor::Red,FString::Printf(TEXT("%s"),*TestArray));
}动态材质实例
派生方式
Actor->MyMaterialActor
头文件
[*]"Components/StaticMeshComponent.h"
[*]"UObject/ConstructorHelpers.h"
声明
UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category="MySceneComponent")
class USceneComponent* MyScene;
UPROPERTY(VisibleAnywhere,BlueprintReadOnly,Category="MySceneComponent")
class UStaticMeshComponent* MyMesh;
UMaterialInstanceDynamic* DynamicMaterial;定义
[*]AMyMaterialActor
[*]创建组件USceneComponent,和StaticMeshComponent并命名和挂载
[*]通过FObjectfinder同步加载网格资源到网格体组件上
[*]BeginPlay()
[*]beginplay是运行时了，这里是运行时加载一个资产并生成材质
[*]为网格体贴上材质并生成一个材质句柄返回
[*]调整材质的两个参数
AMyMaterialActor::AMyMaterialActor()
{
// Set this actor to call Tick() every frame.You can turn this off to improve performance if you don't need it.
PrimaryActorTick.bCanEverTick = true;
MyScene = CreateDefaultSubobject<USceneComponent>(TEXT("MyCustomScene"));
MyMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("MyCustomStaticMesh"));
RootComponent = MyScene;
MyMesh->SetupAttachment(MyScene);
static ConstructorHelpers::FObjectFinder<UStaticMesh>TempStaticMesh(TEXT("/Script/Engine.StaticMesh'/Game/StarterContent/Shapes/Shape_TriPyramid.Shape_TriPyramid'"));
MyMesh->SetStaticMesh(TempStaticMesh.Object);
}
// Called when the game starts or when spawned
void AMyMaterialActor::BeginPlay()
{
Super::BeginPlay();
UMaterialInterface* Material = LoadObject<UMaterialInterface>(nullptr, TEXT("/Script/Engine.Material'/Game/M_testMaterial.M_testMaterial'"));
DynamicMaterial = MyMesh->CreateDynamicMaterialInstance(0, Material);
DynamicMaterial->SetVectorParameterValue("BaseColor", FLinearColor::Red);
DynamicMaterial->SetScalarParameterValue("BaseMetallic", 1);
}文件操作
派生方式
BlueprintFunctionLibrary->派生
头文件
[*]"Engine/Engine.h"
[*]"Misc/FileHelper.h"
[*]Runtime/Core/Public/HAL/FileManagerGeneric.h（处理文件夹)
声明
public:
UFUNCTION(BlueprintCallable, Category="File")
static bool LoadStringFromFIle(FString FilePath, FString& ResultString);
UFUNCTION(BlueprintCallable, Category="File")
static bool WriteStringToFile(TArray<FString>SaveFile, FString FIlePath);
UFUNCTION(BlueprintCallable,Category="File")
static FString GetFilePath(FString Path);
UFUNCTION(BlueprintCallable,Category = "File")
static FString GetFileName(FString InPath,bool bRemoveForwardPath);
UFUNCTION(BlueprintCallable,Category="File")
static FString GetFileExtension(FString InPath, bool bIncludeDot);
UFUNCTION(BlueprintCallable,Category="File")
static void CreateFolder(FString FolderName);
UFUNCTION(BlueprintCallable, Category="FIle")
static void RemoveFolder(FString FolderName);
UFUNCTION(BlueprintCallable,Category="FIle")
static bool MoveFileTo(FString To, FString From);
UFUNCTION(BlueprintCallable,Category="File")
static TArray<FString> FindFileFolder(FString Path,FString FileType,bool Files,bool Folders);定义
bool UMyBlueprintFunctionLibrary::LoadStringFromFIle(FString FilePath, FString& ResultString)
{
if (!FilePath.IsEmpty())
{
if (FFileHelper::LoadFileToString(ResultString,*FilePath))
{
return true;
}
else
{
GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, TEXT("error"));
}
}
return false;
}
bool UMyBlueprintFunctionLibrary::WriteStringToFile(TArray<FString>SaveFile, FString FIlePath)
{
if (!FIlePath.IsEmpty())
{
if (FFileHelper::SaveStringArrayToFile(SaveFile,*FIlePath))
{
return true;
}
else
{
GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, TEXT("error"));
}
}
return false;
}
FString UMyBlueprintFunctionLibrary::GetFilePath(FString Path)
{
FString result;
result = FPaths::GetPath(*Path);
return result;
}
FString UMyBlueprintFunctionLibrary::GetFileName(FString InPath, bool bRemoveForwardPath)
{
return FPaths::GetBaseFilename(*InPath, bRemoveForwardPath);
}
FString UMyBlueprintFunctionLibrary::GetFileExtension(FString InPath, bool bIncludeDot)
{
return FPaths::GetExtension(*InPath, bIncludeDot);
}
void UMyBlueprintFunctionLibrary::CreateFolder(FString FolderName)
{
FString Path = FPaths::ProjectContentDir() / *FolderName;
FPlatformFileManager::Get().GetPlatformFile().CreateDirectoryTree(*Path);
}
void UMyBlueprintFunctionLibrary::RemoveFolder(FString FolderName)
{
FString Path1 = FPaths::ProjectContentDir() / *FolderName;
FPlatformFileManager::Get().GetPlatformFile().DeleteDirectoryRecursively(*Path1);
}
bool UMyBlueprintFunctionLibrary::MoveFileTo(FString To, FString From)
{
return IFileManager::Get().Move(*To, *From);
}
TArray<FString> UMyBlueprintFunctionLibrary::FindFileFolder(FString Path, FString FileType, bool Files, bool Folders)
{
TArray<FString> OutPathList;
OutPathList.Empty();
FFileManagerGeneric::Get().FindFilesRecursive(OutPathList, *Path, *FileType, Files, Folders);
return OutPathList;
}Delay实现函数
派生方式
Actor->MyMaterialActor
头文件
[*]Kismet/KismetSystemLibrary.h
声明
public:
UFUNCTION()
void DelayFunctionFinish();使用
[*]UE通过this指针和DelayFunctionFinish这个字符串反射找到UFunction中AMyMaterialActor::DelayFunctionFinish方法，再在Delay中延时回调。
[*]我只能说UE为了兼容蓝图整的操作真心有点看不懂。
void AMyMaterialActor::BeginPlay()
{
Super::BeginPlay();
const FLatentActionInfo LatentInfo(0, FMath::Rand(), TEXT("DelayFunctionFinish"), this);
UKismetSystemLibrary::Delay(this,1.0f ,LatentInfo);
}其他配置--待回调函数
void AMyMaterialActor::DelayFunctionFinish()
{
GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, TEXT("Delay Finished"));
}Destory
派生方式
Actor-->MyActor
头文件
无
使用
[*]放在碰撞函数中，调用就销毁Actor。
void AMyActor::BeingOverlapFunction(
UPrimitiveComponent* OverlappedComponent,
AActor* OtherActor,
UPrimitiveComponent* OtherComp,
int32 OtherBodyIndex,
bool bFromSweep,
const FHitResult& SweepResult)
{
Destory();
}
[*]调用就销毁指定Component
void AMyActor::BeingOverlapFunction(
UPrimitiveComponent* OverlappedComponent,
AActor* OtherActor,
UPrimitiveComponent* OtherComp,
int32 OtherBodyIndex,
bool bFromSweep,
const FHitResult& SweepResult)
{
MyParticle->DestroyComponent();
}JSON文件解析
引入模块
PrivateDependencyModuleNames.AddRange(new string[]{"Json","JsonUtilities"});派生方式
BlueprintFunctionLibrary-->MyBlueprintFunctionLibrary
声明
UFUNCTION(BlueprintCallable,Category="Json")
static void ReadJson(FString JsonValueString);
UFUNCTION(BlueprintCallable,Category = "JsonToMap")
static TMap<FString, FString> JsonToMap(FString JsonValueString);
UFUNCTION(BlueprintCallable,Category = "MapToJson")
static FString MapToJson(TMap<FString, FString> InMap);定义
读取Json
[*]JSonReaderFactory::Create是一个工厂函数，返回一个FString的Json读取器
[*]创建一个根对象，并对读取器进行反序列化到根对象上。
[*]利用根对象获取其中的数据。
void UMyBlueprintFunctionLibrary::ReadJson(FString JsonValueString)
{
TSharedRef<TJsonReader<TCHAR>> JsonReader = TJsonReaderFactory<TCHAR>::Create(JsonValueString);//通过jsonreader工厂创建一个解析器
TSharedPtr<FJsonObject> JsonObject;
bool isOk = FJsonSerializer::Deserialize(JsonReader, JsonObject);
if (isOk)
{
int32code = JsonObject->GetIntegerField("code");
FString msg = JsonObject->GetStringField("msg");
TSharedPtr<FJsonObject> DataObject = JsonObject->GetObjectField("data");
FString MyUserName = DataObject->GetStringField("username");
FString MyUserID = DataObject->GetStringField("userid");
FString MyToken = DataObject->GetStringField("token");
GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, FString::Printf(TEXT("%d"), code));
GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, FString::Printf(TEXT("%s"), *msg));
GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, FString::Printf(TEXT("%s"), *MyUserName));
}
}JsonToMap
[*]使用json工厂函数创建json读取器，并序列化创建根对象。
[*]创建一个数据结构，将对象的key作为key，用指针直接指向对象中的数据。
[*]遍历数据结构，并通过指向对象中数据的指针取数据，并添加到结果中。
TMap<FString, FString> UMyBlueprintFunctionLibrary::JsonToMap(FString JsonValueString)
{
TMap<FString, FString> result;
TSharedRef<TJsonReader<TCHAR>> JsonReader = TJsonReaderFactory<TCHAR>::Create(JsonValueString);
TSharedPtr<FJsonObject> JsonObject;
bool isOk = FJsonSerializer::Deserialize(JsonReader, JsonObject);
if (isOk)
{
TMap<FString, TSharedPtr<FJsonValue>> keys = JsonObject->Values;
for (auto currJson = keys.CreateIterator();currJson;++currJson)
{
FString key = (*currJson).Key;
FString value = JsonObject->GetStringField(key);
result.Add(key, value);
}
}
return result;
}MapToJson
[*]用一个工厂函数创建一个写入器并指定写入的目标。
[*]创建一个数组存放keys，通过遍历数组，获取key对应的value，并将key和value写入字符串中。
[*]TCondensedJsonPrintPolicy是压缩策略(不缩进，不换行，体积最小，最不可读)，TPrettyJsonPrintPolicy会带缩进。
FString UMyBlueprintFunctionLibrary::MapToJson(TMap<FString, FString> InMap)
{
FString JsonStr;
TSharedRef<TJsonWriter<TCHAR, TCondensedJsonPrintPolicy<TCHAR>>>JsonWriter = TJsonWriterFactory<TCHAR, TCondensedJsonPrintPolicy<TCHAR>> ::Create(&JsonStr);
JsonWriter->WriteObjectStart();
TArray<FString> keys;
InMap.GetKeys(keys);
for (size_t i=0;i<keys.Num();i++)
{
FString* value = InMap.Find(keys);
JsonWriter->WriteValue(keys, *value);
}
JsonWriter->WriteObjectEnd();
JsonWriter->Close();
return JsonStr;
}其他配置
实例json
{
"code":200,
"msg":"成功",
"data":{
"username":"zhangsan",
"userid":'123456',
"token":"adadadsdawdsadw47dad2sd5a4d"
}
}GameInstanceSubsystem
派生方式
GameInstanceSubsystem--->MyGameInstanceSubsystem(本质上就是一个全局的单例)
头文件
无
声明
public:
virtual bool ShouldCreateSubsystem(UObject* Outer) const override;
virtual void Initialize(FSubsystemCollectionBase& Collection) override;
virtual void Deinitialize() override;
static UMyGameInstanceSubsystem* MyInstanceSubsystem;
UFUNCTION(BlueprintCallable, Category= "MyTestSubsystem")
static UMyGameInstanceSubsystem* Get();
UFUNCTION(BlueprintCallable,Category = "MyTestSubsystem")
voidStartThread();
UFUNCTION(BlueprintCallable, Category = "MyTestSubsystem")
void StopThread();定义
[*]Subsystem用单例实现，单例不需要构造方法，它需要一个指向自己的指针MyInstanceSubsystem并设置为nullptr。
[*]shouldCreateSubsystem，Initialize,Deinitialize方法。并在初始化中将本实例赋值给指向自己的指针。这三个函数由UE引擎负责调用(因为gamemode和level是关卡级的，而gameinstance和subsystem是游戏级的)，游戏开始根据前者决定是否init，游戏结束调用deinit。
UMyGameInstanceSubsystem* UMyGameInstanceSubsystem::MyInstanceSubsystem = nullptr;
bool UMyGameInstanceSubsystem::ShouldCreateSubsystem(UObject* Outer) const
{
return true;
}
void UMyGameInstanceSubsystem::Initialize(FSubsystemCollectionBase& Collection)
{
Super::Initialize(Collection);
MyInstanceSubsystem = this;
UE_LOG(LogTemp, Warning, TEXT("Initialize MyGameInstance MySubsystem"));
}
void UMyGameInstanceSubsystem::Deinitialize()
{
Super::Deinitialize();
UE_LOG(LogTemp,Warning,TEXT("Deinitialize MyGameInstance MySubsystem"))
}
UMyGameInstanceSubsystem* UMyGameInstanceSubsystem::Get()
{
return MyInstanceSubsystem;
}
void UMyGameInstanceSubsystem::StartThread()
{
UE_LOG(LogTemp, Warning, TEXT("StartThread MyGameInstanceSubsystems"));
}
void UMyGameInstanceSubsystem::StopThread()
{
UE_LOG(LogTemp, Warning, TEXT("StopThread MyGameInstanceSubsystems"));
}多线程--FRunnable和FRunnableThread
派生方式
None-->MyRunnable,并将方法和类前加上F前缀。并让类继承自FRunnable
class COOPGAME_API FMyRunnable:public FRunnable
{
public:
FMyRunnable();
~FMyRunnable();
};GameInstance
头文件
[*]MyRunnable
[*]HAL/Runnable.h
[*]HAL/ThreadSafeBool.h
[*]MyGameInstanceSubsystem.h(Subsystem是进程级的，常用在多线程中)
[*]MyGameInstanceSubsystem
[*]MyRunnable.h
声明
MyRunnable
将一个FRunnable类派生的线程对象传入FRunnableThread::Create(),这个对象会自动调用其Init的函数，再根据init函数结果的真假决定调用Run函数与否(所以需要重载)
public:
FMyRunnable();
FMyRunnable(FString InThreadName);
~FMyRunnable();
virtual bool Init() override;
virtual uint32 Run() override;
virtual void Stop() override;
virtual void Exit() override;
FString ThreadName;
bool IsRunning;MyGameInstanceSubsystem
protected:
TSharedPtr<FMyRunnable> MyRunnable;
FRunnableThread* MyRunnableThread;定义
MyRunnable
MyRunnable这个类，负责多线程需要执行的一个函数，类似于单独存在的线程(消息队列).
[*]Run方法
[*]调整InRunning并进入循环，每三秒获取一次单例对象Instance。
FMyRunnable::FMyRunnable()
{
UE_LOG(LogTemp,Warning,TEXT("Constructor Function0"))
}
FMyRunnable::FMyRunnable(FString InThreadName):ThreadName(InThreadName)
{
UE_LOG(LogTemp, Warning, TEXT("Constructor Function1"))
}
FMyRunnable::~FMyRunnable()
{
UE_LOG(LogTemp, Warning, TEXT("DeConstructor Function0"))
}
bool FMyRunnable::Init()
{
UE_LOG(LogTemp, Warning, TEXT("Init Runnable "));
return true;
}
uint32 FMyRunnable::Run()
{
IsRunning = true;
while (IsRunning)
{
FPlatformProcess::Sleep(3.0);
UMyGameInstanceSubsystem* Instance = UMyGameInstanceSubsystem::Get();
if (Instance)
{
UE_LOG(LogTemp, Warning, TEXT("Run Thread"));
}
}
return uint32();
}
void FMyRunnable::Stop()
{
IsRunning = false;
UE_LOG(LogTemp, Warning, TEXT("Stop Thread"));
}
void FMyRunnable::Exit()
{
UE_LOG(LogTemp,Warning,TEXT("Exit Thread"))
}MyGameInstanceSubsystem
MyGameInstanceSubsystem负责线程的创建，以及线程中运行的功能。
[*]StartThread
[*]通过FMyRunnable的构造方法创建一个对象
[*]使用FRunnableThread::Create(线程体，线程名),将一个FRunnable类派生的线程对象传入FRunnableThread::Create(),这个对象会自动调用其Init的函数，再根据init函数结果的真假决定调用Run函数与否(所以需要重载)
[*]StopThread()
[*]在线程对象合法时停止线程
[*]在线程池合法时等待线程结束并删除线程，并将线程置为null.
void UMyGameInstanceSubsystem::StartThread()
{
//创建对象
MyRunnable = MakeShared<FMyRunnable>(TEXT("MyRunnable"));
//创建线程
MyRunnableThread = FRunnableThread::Create(MyRunnable.Get(),*(MyRunnable->ThreadName));
UE_LOG(LogTemp, Warning, TEXT("StartThread MyGameInstanceSubsystems"));
}
void UMyGameInstanceSubsystem::StopThread()
{
if (MyRunnable.IsValid())
{
MyRunnable->Stop();
}
if (MyRunnableThread)
{
MyRunnableThread->WaitForCompletion();
delete MyRunnableThread;
MyRunnableThread = nullptr;
}
UE_LOG(LogTemp, Warning, TEXT("StopThread MyGameInstanceSubsystems"));
}多线程--AsyncTask
派生方式
None-->FMyAsyncTask
Actor-->MyAsyncTestActor(测试用)
头文件
FMyAsyncTask
[*]Async/AsyncWork.h
MyAsyncTestActor
[*]FMyAsyncTask.h
声明
[*]FNonAbandonableTask告诉线程池，此任务不可以被取消，必须dowork完才嗯释放
[*]通过友元声明将此类列入到线程管家(估计也是某个类)的友元中，让它可以访问此类的私有和受保护方法。
[*]FORCENOINLINE用于强制要求编译器不可以使用内联策略(如某个函数只有一行代码运算，编译器通过内联策略，将这个函数取消替换成一行别的代码,提升了性能，但也无法从堆栈分析调试了)
[*]RETURN_QUICK_DECLARE_CYCLE_STAT本质上就是返回此函数的一个生成的id(程序运行前就创建了)用于计时此线程的耗时。（两个参数分别是任务名称和任务ID）
class COOPGAME_API FMyAsyncTask : public FNonAbandonableTask
{
friend class FAutoDeleteAsyncTask<FMyAsyncTask>;
public:
FMyAsyncTask();
~FMyAsyncTask();
public:
void DoWork();
FORCENOINLINE TStatId GetStatId() const
{
RETURN_QUICK_DECLARE_CYCLE_STAT(FMyAsyncTask,STATGROUP_ThreadPoolAsyncTasks);
}
FORCENOINLINE static const TCHAR* GetTaskName()
{
return TEXT("FMyAsyncTask");
}
};定义
FMyAsyncTask::~FMyAsyncTask()
{
UE_LOG(LogTemp, Warning, TEXT("AsyncTask End>>>>>>>>>>>>>>"));
}
void FMyAsyncTask::DoWork()
{
UE_LOG(LogTemp,Warning,TEXT("AsyncTask Start>>>>>>>>"));
for (int32 i=0;i<1000;i++)
{
UE_LOG(LogTemp, Warning, TEXT("i=%d"),i);
}
}多线程--Async
派生方式
Actor-->MyAsyncTaskActor
头文件
Async/Async.h
使用
void AMyAsyncTaskActor::BeginPlay()
{
Super::BeginPlay();
FAutoDeleteAsyncTask<FMyAsyncTask>* MyTask = new FAutoDeleteAsyncTask<FMyAsyncTask>();
MyTask->StartBackgroundTask();//异步线程
// MyTask->StartSynchronousTask();//当前线程
}多线程--综述
[*]AsyncTask:是一个模板类，创建按在后台线程运行的任务，它可以在任务完成后自动删除自己，很适合用于创建按一次性的异步任务。例如用于加载资源，或者进行一次复杂的计算，或者http请求后端资源。
[*]Async:是一个函数，用于后台线程运行一个Lambda表达式，很适合创建简单的异步任务，如加载资源和一次复杂的计算。
[*]FRunnable:是一个接口，用于创建一个在单独线程上运行的任务，它需要手动管理生命周期，适合复杂任务。例如WebSocket做与后端的长连接，长时间任务。
编码处理--Base64
我现在感觉之前网上到处找第三方实现的我像个傻叉，不过我感觉也不怪我，U++相关的api介绍真的挺少，官方的API介绍太简洁且API又太多，谁会乐意每次差一个api等半天浏览器响应呢？
声明
void AMyAsyncTaskActor::BeginPlay()
{
Super::BeginPlay();
Async(EAsyncExecution::ThreadPool, []
{
for (int32 i = 0; i < 1000; ++i)
{
UE_LOG(LogTemp, Warning, TEXT("i=%d"), i);
}
});
}定义
//字符串到base64
UFUNCTION(BlueprintPure, Category = "CommonLibrary")
static FString StringToBase64Encode(const FString& Source);
//字节到base64
UFUNCTION(BlueprintPure, Category = "CommonLibrary")
static FString BytesToBase64Encode(const TArray<uint8>& Source);
//Bas64到字符串
UFUNCTION(BlueprintPure, Category = "CommonLibrary")
static bool Base64DecodeFString(const FString& Source,FString& Dest);
//Bas64到字节
UFUNCTION(BlueprintPure, Category = "CommonLibrary")
static bool Base64DecodeBytes(const FString& Source,TArray<uint8>& Dest);编码处理--URL
头文件
GenericPlatform/GenericPlatfoormHttp.h
模块引入
http
声明
FString UFileSystemBPLibrary::StringToBase64Encode(const FString& Source)
{
return FBase64::Encode(Source);
}
FString UFileSystemBPLibrary::BytesToBase64Encode(const TArray<uint8>& Source)
{
return FBase64::Encode(Source);
}
bool UFileSystemBPLibrary::Base64DecodeFString(const FString& Source, FString& Dest)
{
return FBase64::Decode(Source, Dest);
}
bool UFileSystemBPLibrary::Base64DecodeBytes(const FString& Source, TArray<uint8>& Dest)
{
return FBase64::Decode(Source, Dest);
}定义
UFUNCTION(BlueprintPure,Category = "CommonLibrary")
static FString URLEncode(const FString& Source);
UFUNCTION(BlueprintPure,Category = "CommonLibrary")
static FString URLDecode(const FString& Source);编码处理--MD5
声明
FString UFileSystemBPLibrary::URLEncode(const FString& Source)
{
return FGenericPlatformHttp::UrlEncode(Source);
}
FString UFileSystemBPLibrary::URLDecode(const FString& Source)
{
return FGenericPlatformHttp::UrlDecode(Source);
}定义
UFUNCTION(BlueprintPure,Category = "CommonFunctionLibrary")
static FString MD5Encode(const FString& Source);时间戳
声明
FString UFileSystemBPLibrary::MD5Encode(const FString& Source)
{
return FMD5::HashAnsiString(*Source);
}定义
//获得UTC时间戳
UFUNCTION(BlueprintPure,Category = "CommonLibrary")
static FString GetUTCTimestamp();
//UTC毫秒级13位时间戳
UFUNCTION(BlueprintPure,Category = "CommonLibrary")
static FString GetMillUTCTimestamp();
//RFC1123时间和时区表示
UFUNCTION(BlueprintPure,Category = "CommonFunctionLibrary")
static FString GetUTCRFC1123();单例设计
概念
让一个类有且仅有一个实例，提供一个访问该实例的节点，仅在首次请求单例对象时进行初始化。
方案
将默认构造函数设为私有，放置其他对象使用单例类的new运算符。新建一个静态构造方法作为构造函数。
派生方式
UObject---->SingletonObject
声明
[*]在类中定义一个指向本类的指针用private藏好，并初始化为nullptr。
[*]定义获取instance方法，进行首次的初始化。
[*]用static进行修饰让USingletonObject指针存放的值在此类中唯一化,即此类只能存在一个这个值，怎么new都只有一个。如果不适用static修饰需要参考原始的C++方式(手动删除构造方法，拷贝构造方法，赋值构造方法)
FString UFileSystemBPLibrary::GetUTCTimestamp()
{
FString TImestamp;
FDateTime Time = FDateTime::UtcNow();
int64 unixTimestamp = Time.ToUnixTimestamp();
TImestamp = FString::Printf(TEXT("%lld"), unixTimestamp);
return TImestamp;
}
FString UFileSystemBPLibrary::GetMillUTCTimestamp()
{
FDateTime CurrentTime = FDateTime::UtcNow();
int64 TimestampMillSeconds = CurrentTime.ToUnixTimestamp() * 1000 + CurrentTime.GetMillisecond();
FStringMillTimestamp;
MillTimestamp = FString::Printf(TEXT("%lld"), TimestampMillSeconds);
return MillTimestamp;
}
FString UFileSystemBPLibrary::GetUTCRFC1123()
{
return FDateTime::UtcNow().ToHttpDate();
}定义
public:
UFUNCTION(BlueprintCallable)
static USingletonObject* GetSingletonObjectInstance();
UFUNCTION(BlueprintCallable)
void SetValue(int32 NewValue);
UFUNCTION(BlueprintCallable)
int32 GetValue();
private:
static USingletonObject* SingletonObject;
int32 value;简单工厂设计
概念
向一个工厂类传入参数就能创建来源于Prototype抽象类的其他类。
方案
[*]创建抽象Prototype类
[*]基于Prototype派生具体类
[*]创建工厂类，通过静态方法根据传入不通的参数从而创建不通的派生类实例。
派生方式
[*]UObject---->ProtoTypeObject
[*]ProtoTypeObject--->MyProductA
[*]ProtoTypeObject--->MyProductB
[*]UObject---->FactoryObject
[*]Actor---->FactorActor(测试与使用)
头文件
FactoryObject
[*]ProtoTypeObject.h
FactorActor
[*]ProtoTypeObject.h
[*]FactoryObject.h
[*]MyProductA.h
[*]MyProductB.h
声明与定义
ProtoTypeObject
[*]需指定UCLASS为Abstract，抽象类，
[*]通过virtual创建接口。
USingletonObject* USingletonObject::SingletonObject = nullptr;
USingletonObject* USingletonObject::GetSingletonObjectInstance()
{
if (SingletonObject == nullptr)
{
SingletonObject = NewObject<USingletonObject>();
}
return SingletonObject;
}
void USingletonObject::SetValue(int32 NewValue)
{
value = NewValue;
}
int32 USingletonObject::GetValue()
{
returnvalue;
}ProductA和B
[*]重写ProtoType提供的接口
UCLASS(Abstract)
class COOPGAME_API UProtoTypeObject : public UObject
{
GENERATED_BODY()
public:
virtual void ShowInfo() { UE_LOG(LogTemp, Warning, TEXT("ProtoTypeObject")) };
};FactoryObject
[*]传入一个兼容的类对象的指针用于存放产品对象
[*]传入要生产的产品类
//ProductA
public:
virtual void ShowInfo() override{UE_LOG(LogTemp,Warning,TEXT("This is ProductA"))};
//ProductB
public:
virtual void ShowInfo() override{UE_LOG(LogTemp,Warning,TEXT("This is ProductB"))};使用
public:
static UProtoTypeObject* CreateNewProduct(UObject* Outer, TSubclassOf<UProtoTypeObject> ProductClass)
{
return NewObject<UProtoTypeObject>(Outer, ProductClass);
};
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！
页:
[1]