单一职责模式：包括装饰器模式和桥模式

装饰器模式

过度的使用继承会导致类膨胀，而使用组合则可以避免类膨胀，但是组合的缺点在于无法复用父类的方法，而装饰器模式可以实现复用父类的方法，同时也可以扩展功能。

设计模式的原则

面向对象：

1. 封装：隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别
2. 继承：子类继承父类的属性和行为，使得子类对象（实例）具有父类的属性和方法，还可以定义自己的属性和方法，其目的为复用
3. 多态：方法只有在运行时在确定其具体属性和实现

面向对象的设计原则：

1. 依赖倒置原则：针对接口编程，不要针对实现编程
2. 开放-封闭原则：对扩展开放，对修改封闭->类模块应该是可以扩展的（增加新的内容），但是不可修改（修改原有内容）
3. 单一职责原则：类模块应该只有一个引起它变化的原因 不应有过多的方法
4. 里氏替换原则：在父类出现的地方，其子类都可以替代父类使用 Is-a关系
5. 接口隔离原则：接口应小而完备，不提供过多的对外接口
6. 优先使用对象组合，而不是类继承：继承在某种程度上破坏了封装性，会增加耦合度；而组合只要求被组合对象有良好的接口
7. 封装变化点：将变化与稳定代码分离

虚幻多线程简介

虚幻引擎为了多平台的特性，对线程实现进行封装，抽象为FRunnable类，使用时需要继承FRunnable类，并重写Init、Run、Exit函数。
Init中执行所有内容的初始化，如果初始化失败将自行退出线程并返回错误代码，否则将会执行Run函数，Run函数中逻辑执行完毕后将调用Exit函数退出线程。

虚幻多线程的使用

创建线程

我们创建一个类并继承FRunnable，重写Init、Run、Exit函数。

1
2
3
4
5
6
7
8
9
10
11
12

class UMyThread : public FRunnable
{
public:
    UMyThread();
    virtual ~UMyThread();
    virtual bool Init() override;
    virtual uint32 Run() override;
    virtual void Exit() override;

private::
    class AMyActor* TestActor;
};

堆

堆的概念和性质

堆（Heap）：堆是一棵完全二叉树，且满足以下性质：

1. 堆的堆顶元素是最大（或最小）的。
2. 堆中每个节点的值都大于（或小于）其左右孩子节点的值。

堆的实现

以小顶堆为例，因为堆是一棵完全二叉树，所以可以使用数组来模拟堆。

假设我们现在有一数组，可以将该数组调整为堆，调整时，需要从最后一个非叶子节点开始调整，因为叶子节点没有孩子节点，所以调整时，只需要调整非叶子节点即可，它的整体调整过程是自下而上然后自上而下的。

调整过程：比较节点与它的左右孩子。将最小的节点放在父节点。

假设有一数组需要调整为堆，数组下标从0开始，从n/2-2位置开始调整，一直到0的位置。
假如要调整为大顶堆，代码如下：
本段代码将数组调整为一个大顶堆，若要调整为小顶堆，只需要改变比较条件即可（将大于号改为小于号）——将最大值置于父节点。

启用Niagara

在新版虚幻引擎中，Niagara已经集成到引擎中，无需额外安装。

在Edit-Plugins-FX中可以找到Niagara，勾选后重启编辑器即可。

安装完成后在内容浏览器中右键可以在FX中找到包含Niagara的内容。

这里只是在C++和蓝团中如何使用Niagara，并不自己创建Niagara，关于如何创建可以参考官方文档。

使用Niagara

在C++中使用Niagara

要使用Niagara，首先要将Niagara的模块添加进入工程中：
打开工程，在build.cs中添加：”Niagara”，使该模块添加如工程中。

需要在C++中创建一个NiagaraSystem,并添加到需要使用的物体上。

1
2
3
4
5
6
7
8
9
10
11
12

//添加头文件
//如果报错就添加完整路径或包含上一级文件

#include "NiagaraFunctionLibrary.h"
#include "NiagaraSystem.h"
#include "NiagaraComponent.h"

UPROPERTY(EditDefaultsOnly, Category = "Niagara")
class UNiagaraSystem* NiagaraSystem;

//在类中添加使用函数
void FireNiagara();

对使用函数作出实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

void ProjectName::FireNiagara()
{   
    if(NiagaraSystem){     
        NiagaraComponet=UNiagaraFunctionLibrary::SpawnSystemAttached(FireNiagara,RootComponent,NAME_None,FVector::ZeroVector,FRotator::ZeroRotator,FVector::OneVector,EAttachLocation::Type::KeepRelativeOffset,true,ENCPoolMethod::None);
    }
    /*
    函数声明：参数名称为其含义，可以看到函数返回一个NiagaraComponent，所以可以在头文件中声明一个NiagaraComponent变量，在使用使直接将函数返回值赋值给该变量。（感觉不用也可以，还没试过doge）
    UNiagaraComponent* UNiagaraFunctionLibrary::SpawnSystemAttached(UNiagaraSystem* SystemTemplate,USceneComponent* AttachToComponent,
    FName AttachPointName,FVector Location,FRotator Rotation,FVector Scale,EAttachLocation::Type LocationType,bool bAutoDestroy,
    ENCPoolMethod PoolingMethod,bool bAutoActivate,bool bPreCullCheck)
    */
}

//或者另一种实现
void ProjectName::FireNiagara()
{
    if(NiagaraSystem){
        NiagaraComponet=UNiagaraFunctionLibrary::SpawnSystemAtLocation(Getworld(),FireNiagara,GetActorLocation());
    }
    /*
    函数声明：含义与上面得方法类似
    UNiagaraComponent* SpawnSystemAtLocation(const UObject* WorldContextObject, UNiagaraSystem* SystemTemplate, FVector SpawnLocation, 
    FRotator SpawnRotation, FVector Scale, bool bAutoDestroy, bool bAutoActivate, ENCPoolMethod PoolingMethod, bool bPreCullCheck)
    */
}

在蓝图中使用Niagara

在蓝图中使用就很简单了，直接搜索Spawn System Attach 或者 Spawn System at Location,参数于C++中相同，直接按照需求填入即可。

总结

只是使用现成的System并没有什么难度，但自己实现一个Niagara比普通粒子效果要复杂得多。

更多细节以及API可以查看官方文档：
https://docs.unrealengine.com/4.27/zh-CN/RenderingAndGraphics/Niagara/
https://docs.unrealengine.com/4.27/en-US/API/Plugins/Niagara/UNiagaraFunctionLibrary/
https://docs.unrealengine.com/4.27/en-US/API/Plugins/Niagara/UNiagaraComponent/

虚幻的反射

反射是虚幻引擎中的基础技术，虚幻中的细节面板、序列化、垃圾回收、蓝图与C++交互等功能都依赖于反射。但原生C++并不支持反射，因此虚幻拥有一套自己的反射系统。

本文将对虚幻的反射机制进行浅析，更多信息可以查看工程文件中的generated和Marcos源码文件，里面有对反射更详细的解释。

反射的简要机制

Unreal Build Tool(UBT)和Unreal Header Tool(UHT)两个协同工作来生成运行时反射需要的数据。UBT通过扫描头文件，记录任何至少有一个反射类型的头文件的模块。如果其中任意一个头文件从上一次编译起发生了变化，那么UHT就会被调用来利用和更新反射数据。UHT分析头文件，创建一系列反射数据，并且生成包含反射数据的C++代码,放到每一个模块的generated文件中，使用标记宏标记的数据编译后可以在generated文件中看到，使用了一些宏对数据进行包装。

用生成的C++代码来存储反射数据的一个最大好处就是，它可以保证跟二进制做到同步,不会加载陈旧或者过时的反射数据，因为它是跟引擎的其它代码同时编译的，并且它会在程序启动的时候使用C++表达式来计算成员偏移等，而不是通过针对特定平台/编译器/优化的组合中进行逆向工程。

反射的概念

允许程序运行时获取类内部信息，并且能操作对象的内部属性和方法。

但C++本身并没有反射的概念，需要通过第三方库来实现。

反射的目标：

1. 类对象反射。
2. 类成员数据反射。
3. 类成员函数反射。

注册时成员为public作用域
通过注册宏实现反射功能

归并排序

算法思想：先将需要排序的元素分开，在合并的过程中将元素进行排序，最终得到一个有序数组。
分开方法：逻辑二分。

模拟：将数组拆分为单个元素

选择排序

每次从乱序区中选择一个最小的排序
分为简单选择排序和堆排序

简单选择排序

每次遍历都找到一个最小的元素，放在乱序区的第一个位置。

1
2
3
4
5
6
7
8
9
10
11
12

void SelectSort(int arr[], int n)
{
    for(int i=0;i<n;i++){
        int Min=i;
        for(int j=i+1;j<n;j++){
            if(arr[j]<arr[Min]){
                Min=j;
            }
        }
        swap(arr[i],arr[Min]);
    }
}

交换排序

基于比较的排序算法，通过不断交换元素的位置，使得排序的元素达到有序。
主要有冒泡排序和快速排序。

冒泡排序

冒泡排序思路与实现都很简单，通过不断比较两个相邻的元素，如果第一个元素比第二个元素大，则交换两个元素的位置，这样循环一轮下来，最大的元素就浮到了最右边。

同样将数组分为待排区和有序区，实现如下：

1
2
3
4
5
6
7
8
9
10

void BubbleSort(int* arr, int n) 
{
    for(int i=0;i<n-1;i++){
        for(int j=0;j<n-i-1;j++){
            if(arr[j]>arr[j+1]){
                swap(arr[j],arr[j+1]);
            }
        }
    }
}