MoOtA

粒子系统 (Particle System) 银牌收录

一、作品说明

基于 C++ 11EasyX 实现。

参考资料

主要功能

  • 能模拟一些简单的粒子行为,可以控制相关属性。
    • 发射器

      • ID
      • 名称
      • 说明
      • 发射数量
      • 发射时间
      • 发射速率
      • 发射角度(以 y 正半轴为 0° 计算)
      • 发射位置
      • 是否循环
    • 粒子

      • ID
      • 名称
      • 说明
      • 颜色
      • 初始位置(相对发射器的坐标)
      • 初始速率
      • 阻力
      • 半径
      • 生命周期
  • 除了内置特效(见菜单),可以自定义新的特效。

其他效果尚未实现或尚不可控。

二、运行截图

菜单中文翻译

状态

- 平均帧数
- 帧时间
- 粒子数 / 粒子总数
- 模拟总时间

鼠标

- 移动:搅动粒子
- 左击:聚集粒子
- 右击:吹散粒子
- 滚轮:缩放粒子

键盘

- Esc:退出系统
- Tab:隐藏菜单
- Space:暂停系统
- Enter:重新模拟

特效(开启或者关闭)

- A:显示鼠标落点
- B:反弹墙壁
- C:速度和大小关联
- D:吹散
- E:聚集
- F:搅动
- G:摩擦力
- H:漩涡
- I:随机移动
- J:缩放
- K:轨迹消失
- L:重力
- M:生命周期

三、项目源码

C++ 源码有两个文件,ParticleSystem.h 和 ParticleSystem.cpp

我先介绍如何使用,先看流程图

系统流程图

用代码描述就是 

Main.cpp

#include "ParticleSystem.h"

int main()
{
	constexpr float Width = 1024.0f;
	constexpr float Height = 576.0f;

	// step1:初始化【粒子系统】
	FParticleSystem& ParticleSystem = FParticleSystem::GetInstance()
									.SetName(_T("Particle System"))
									.SetVersion(2, 5, 1)
									.SetScreenSize({Width, Height})
									.InitInstance();

	// step2: 新建【粒子特效】或者跳过
	ParticleSystem.CreateParticleEffect(1)
				.SetFunction([](const float InDeltaTime, FParticleInstance& InParticleInstance)
				{
					// do everything you want
					InParticleInstance.Velocity = {2.0f, -2.0f};
				})
				.SetKeyboard('A')
				.SetHelpContent(_T("KeepHighSpeed"))
				.SetIsShowHelp(true)
				.Finish();

	// step3: 新建或复用【粒子模板】
	ParticleSystem.CreateParticleTemplate(1)
				.SetName(_T("样例粒子"))
				.SetDescription(_T("样例"))
				.SetColor({RGB(255, 123, 0), RGB(255, 255, 0), EGenerateType::RandColor})
				.SetStartLocation({0.0f, 0.0f})
				.SetStartSpeed({0.0f, 15.0f})
				.SetRadius({1.0f, 1.4f})
				.SetFriction({0.93f, 0.95f})
				.SetLifeTime({0.4f, 0.8f})
				.SetEffects(FVarNum(1), 1)
				.Finish();

	ParticleSystem.CreateParticleTemplate(2, 1)
				.SetColor({RGB(255, 0, 0), RGB(255, 255, 255), EGenerateType::RandColor});

	// step4: 新建或复用【发射器模板】
	ParticleSystem.CreateEmitterTemplate(1)
				.SetName(_T("样例发射器"))
				.SetDescription(_T("样例"))
				.SetSum(33333)
				.SetTime(0.0f)
				.SetLocation({Width * 0.5f, Height * 0.5f})
				.SetAngle({0.0f, 450.0f})
				.SetSpeed(10)
				.SetIsLoop(false)
				.Finish();

	// step5: 生成【带多个粒子实例的发射器实例】
	ParticleSystem.CreateEmitterInstance(1).CreateParticleInstance(FVarNum(2), 1, 2).Finish();

	// step6:【粒子系统】运行所有的【发射器实例】
	ParticleSystem.RunEmitterInstances();

	return 0;
}

可以看到,只需要设置好相关参数,就可以轻松使用粒子系统。

当然上面的例子只是演示,没有做什么效果,萌新初学乍到——_+,期待大佬们给出更好的样例。

而且呃,很多好玩且有用的参数和功能并未实现,不过之后会一直更新的√。

下面是源码!!!

ParticleSystem.h

/**
 * 粒子系统(Particle System)
 * @platform Windows10,Rider 2022 | Visual Studio 2022,EasyX for VisualStudio2022
 * @origin "https://codebus.cn/zhaoh/liquid-particles"
 * @author Moota <3334754085@qq.com>
 * @date 2022 - 08 - 06
 */

/**
 * 注意事项
 * @note 代码是在 Krissi 大神的基础上修改!!!
 *
 * 特效添加步骤
 * @step 添加特效函数,在:FParticleSystem。
 * 如: OnEffectGravity(float InDeltaTime, FParticle& InParticle)
 *
 * @step 添加控制信号,在:FParticleSystem。
 * 如: bool IsEffectGravity;
 *
 * @step 添加控制按键,在:FParticleSystem::HandleInput。
 * 如: case 'P': IsEffectGravity =! IsEffectGravity;
 *
 * @step 添加提示信息。在:FParticleSystem::ShowHelp。
 * 如: "[P]: Effect - Gravity ON";
 *
 * 其他
 * @note 虽然不能全屏,当你拖动窗口到略微超过屏幕,系统会自动帮你上下对齐窗口,就相当于全屏啦。
 * @note 为了简单起见,很多设计限于两个文件没有实现,不过还好啦。
 * @note 萌新初学,欢迎一起讨论和交流!!!
 */

/**
 * 不算 Bug 的 Bug:
 * @bug 鼠标以按下状态超过窗口范围,再以松开状态返回窗口时,鼠标原作用会保持,比如会一直集聚粒子。
 * @reason 原因是超过窗口范围的鼠标信息未被利用,再次点击就会恢复正常。
 * @note 不过这样也很好看,某种意义上还很方便呃。
 */

#pragma once
#include <map>
#include <set>
#include <ctime>
#include <vector>
#include <iostream>
#include <graphics.h>

/**
 * 二维数据
 */
struct FVector2D
{
	float X, Y;

	FVector2D(const float InX = 0.0f, const float InY = 0.0f): X(InX), Y(InY)
	{
	}

	FVector2D operator+(const FVector2D& Other) const
	{
		return {X + Other.X, Y + Other.Y};
	}

	FVector2D operator-(const FVector2D& Other) const
	{
		return {X - Other.X, Y - Other.Y};
	}

	FVector2D operator*(const float Other) const
	{
		return {X * Other, Y * Other};
	}

	FVector2D& operator+=(const FVector2D& Other)
	{
		*this = operator+(Other);
		return *this;
	}

	FVector2D& operator-=(const FVector2D& Other)
	{
		*this = operator-(Other);
		return *this;
	}

	FVector2D& operator*=(const float Other)
	{
		*this = operator*(Other);
		return *this;
	}
};

/**
 * 颜色信息
 */
struct FColor
{
	int R, G, B;

	COLORREF sRGB;

	FColor(const int InR = 255, const int InG = 255, const int InB = 255): R(InR), G(InG), B(InB), sRGB(RGB(InR, InG, InB))
	{
	}

	FColor(const COLORREF InColor): R(GetRValue(InColor)), G(GetGValue(InColor)), B(GetBValue(InColor)), sRGB(InColor)
	{
	}

	/**
	 * FColor 转 RGB
	 */
	static COLORREF FColorToRGB(const FColor& InColor)
	{
		return RGB(InColor.R, InColor.G, InColor.B);
	}

	/**
	 * RGB 转 FColor
	 */
	static FColor RGBToFColor(const COLORREF InColor)
	{
		return {GetRValue(InColor), GetGValue(InColor), GetBValue(InColor)};
	}
};

/**
 * 特效漩涡信息
 */
struct FVortex
{
	FVector2D Position;
	float Radius;
	float RotateSpeed;
};

/**
 * 可变参数数量
 */
struct FVarNum
{
public:
	explicit FVarNum(const size_t InValue): Value(InValue)
	{
	}

	FVarNum() = default;
public:
	size_t Value = 0;
};

/**
 * 通用工具
 */
class FTool
{
public:
	/**
	* 产生随机浮点数,范围在 [Min,Max],精度为 FractionalNum 位小数
	*/
	static float GenerateRandomNumber(const float Min, const float Max, const float FractionalNum)
	{
		const float PowerNumber = powf(10, FractionalNum);
		const int MinInt = static_cast<int>(Min * PowerNumber);
		const int MaxInt = static_cast<int>(Max * PowerNumber);
		return static_cast<float>(MinInt + GenerateRandomNumber() % (MaxInt - MinInt + 1)) / PowerNumber;
	}

	/**
	* 产生随机整数,范围在 [Min,Max]
	*/
	static int GenerateRandomNumber(const int Min, const int Max)
	{
		return Min + GenerateRandomNumber() % (Max - Min + 1);
	}

	/**
	* 产生随机从 0 开始的整数,范围在 [0,Max]
	*/
	static int GenerateRandomNumber(const int Max)
	{
		return GenerateRandomNumber() % (Max + 1);
	}

	/**
	* 产生随机从 0.0f 开始的浮点数,范围在 [0.0f,Max],精度为 FractionalNum 位小数
	*/
	static float GenerateRandomNumber(const float Max, const float FractionalNum)
	{
		const float PowerNumber = powf(10, FractionalNum);
		const int MaxInt = static_cast<int>(Max * PowerNumber);
		return static_cast<float>(GenerateRandomNumber() % (MaxInt + 1)) / PowerNumber;
	}

	/**
	* 标准随机数
	*/
	static int GenerateRandomNumber()
	{
		return rand();
	}

	/**
	 * 产生随机颜色
	 */
	static COLORREF GenerateRandomColor(const FColor& InMin, const FColor& InMax)
	{
		return RGB(GenerateRandomNumber(InMin.R, InMax.R),
					GenerateRandomNumber(InMin.G, InMax.G),
					GenerateRandomNumber(InMin.B, InMax.B));
	}

	/**
	* 产生随机符号,范围在 {-1,1}
	*/
	template <typename ElementType>
	static ElementType GenerateRandomSign()
	{
		return static_cast<ElementType>(pow(-1, GenerateRandomNumber() % 2));
	}

	/**
	* 将数据限制在 [Min,Max] 区间
	*/
	template <typename ElementType>
	static ElementType Clamp(ElementType Number, ElementType Min, ElementType Max)
	{
		return Number >= Min ? Number <= Max ? Number : Max : Min;
	}

	/**
	 * 选择数据,当 Condition 为真,选择 OptionTrue,否则选择 OptionFalse
	 */
	template <typename ElementType>
	static ElementType Select(const bool Condition, const ElementType& OptionTrue, const ElementType& OptionFalse)
	{
		return Condition == true ? OptionTrue : OptionFalse;
	}

	/**
	* 求单位向量
	*/
	static FVector2D Normalize(const FVector2D& Vector2D)
	{
		const float Length = CalculateLength(Vector2D);
		return {Vector2D.X / Length, Vector2D.Y / Length};
	}

	static FVector2D Normalize(FVector2D&& Vector2D)
	{
		const float Length = CalculateLength(Vector2D);
		return {Vector2D.X / Length, Vector2D.Y / Length};
	}

	/**
	* 求向量长度
	*/
	static float CalculateLength(const FVector2D& Vector2D)
	{
		return sqrt(Vector2D.X * Vector2D.X + Vector2D.Y * Vector2D.Y);
	}

	static float CalculateLength(FVector2D&& Vector2D)
	{
		return sqrt(Vector2D.X * Vector2D.X + Vector2D.Y * Vector2D.Y);
	}

	/**
	 * 角度转弧度
	 */
	static float DegreeToRadian(const float Degree)
	{
		static constexpr float Piece = (3.1415926f * 2) / 360.0f;
		return Degree * Piece;
	}

	/**
	 * 弧度转角度
	 */
	static float RadianToDegree(const float Radian)
	{
		static constexpr float Piece = 360.0f / (3.1415926f * 2);
		return Radian * Piece;
	}
};

/**
 * 唯一标识符生成器 暂时不全局
 */
struct FGuid
{
public:
	unsigned int NewGuid(unsigned int InNumber)
	{
		if (GuidMaps.find(InNumber) != GuidMaps.end())
		{
			throw std::logic_error("the number has been registered");
		}
		unsigned int Guid = 0;
		const size_t Size = Guids.size();
		while (Guids.size() == Size)
		{
			Guid = FTool::GenerateRandomNumber(RAND_MAX);
			Guids.insert(Guid);
		}
		GuidMaps[InNumber] = Guid;
		return Guid;
	}

	unsigned int GetGuid(unsigned int InNumber)
	{
		if (GuidMaps.find(InNumber) == GuidMaps.end())
		{
			throw std::logic_error("the number is not registered");
		}
		return GuidMaps[InNumber];
	}

public:
	std::set<unsigned int> Guids;
	std::map<unsigned int, unsigned int> GuidMaps;
};

/**
 * 数值的生成类型
 */
enum class EGenerateType: unsigned
{
	None = 0,
	Normal = 1,		// 直接使用 Default 值作为 GetValue()返回值
	Rand = 2,		// 从 [Min, Max] 随机生成 Default 值作为 GetValue()返回值
	RandColor = 3,	// 注意!!!是对 RGB 值分别随机
};

/**
 * 数值的使用类型
 */
enum class EUsedType: unsigned
{
	None = 0,
	Float = 1,								// 浮点
	PositiveFloat = 2,						// 非负浮点
	NegativeFloat = 3,						// 非正浮点
	PositivePercent = 4,					// 正百分比 (1.0%, 100.0%)
	PositivePercentZeroToOne = 5,			// 正百分比/100 (0.0, 1.0)
	Degree = 6,								// 角度 (-360, 360)
	Radian = 7,								// 弧度 (-2pi, 2pi)
	Color = 8,								// 颜色 (0-0-0, 255-255-255)
};

/**
 * 数值生成器
 */
struct FYielder
{
public:
	// 参见 EUsedType
	static const float PositiveFloatMin;					// 非负浮点最小值
	static const float PositiveFloatMax;					// 非负浮点最大值

	static const float PositivePercentMin;					// 非负百分比最小值
	static const float PositivePercentMax;					// 非负百分比最大值
	static const float PositivePercentZeroToOneMin;			// 非负百分比/100 最小值
	static const float PositivePercentZeroToOneMax;			// 非负百分比/100 最大值

	static const float PositiveDegreeMin;					// 非负角度最小值
	static const float PositiveDegreeMax;					// 非负角度最大值
	static const float PositiveRadianMin;					// 非负弧度最小值
	static const float PositiveRadianMax;					// 非负弧度最大值

	static const COLORREF ColorMin;							// 颜色最小值
	static const COLORREF ColorMax;							// 颜色最大值

	static int AvoidWarning;								// 无用之有用

public:
	FYielder(const float InMin, const float InMax, const EGenerateType InGenerateType = EGenerateType::Rand,
			const float InDefault = PositiveFloatMin): GenerateType(InGenerateType),
														Min(InMin),
														Max(InMax),
														Default(InDefault),
														Value(InDefault)
	{
		IsGenerated = false;
		CheckYielder(*this);
	}

	/**
	 * 约束数值
	 */
	static void AdjustValue(FYielder& InYielder)
	{
		InYielder.Value = InYielder.Value >= InYielder.Min ? InYielder.Value <= InYielder.Max ? InYielder.Value : InYielder.Max : InYielder.Min;
	}

	static void CheckRange(const float InValue, const float InMin, const float InMax)
	{
		if (InValue < (InMin - 0.01f) || (InMax + 0.01f) < InValue) // 误差 0.01f
		{
			throw std::logic_error("out of specify range");
		}
	}

	/**
	 * 检查合法性
	 */
	static void CheckYielder(const FYielder& InYielder, EUsedType InUsedType = EUsedType::Float)
	{
		if (InYielder.Min > InYielder.Max)
		{
			throw std::logic_error("your range is wrong");
		}
		switch (InUsedType)
		{
			case EUsedType::Float:
			{
				CheckRange(InYielder.Min, -PositiveFloatMax, PositiveFloatMax);
				CheckRange(InYielder.Max, -PositiveFloatMax, PositiveFloatMax);
				break;
			}
			case EUsedType::PositiveFloat:
			{
				CheckRange(InYielder.Min, PositiveFloatMin, PositiveFloatMax);
				CheckRange(InYielder.Max, PositiveFloatMin, PositiveFloatMax);
				break;
			}
			case EUsedType::NegativeFloat:
			{
				CheckRange(InYielder.Min, -PositiveFloatMax, PositiveFloatMin);
				CheckRange(InYielder.Max, -PositiveFloatMax, PositiveFloatMin);
				break;
			}
			case EUsedType::PositivePercent:
			{
				CheckRange(InYielder.Min, PositivePercentMin, PositivePercentMax);
				CheckRange(InYielder.Max, PositivePercentMin, PositivePercentMax);
				break;
			}
			case EUsedType::PositivePercentZeroToOne:
			{
				CheckRange(InYielder.Min, PositivePercentZeroToOneMin, PositivePercentZeroToOneMax);
				CheckRange(InYielder.Max, PositivePercentZeroToOneMin, PositivePercentZeroToOneMax);
				break;
			}
			case EUsedType::Degree:
			{
				CheckRange(InYielder.Min, -PositiveDegreeMax, PositiveDegreeMax);
				CheckRange(InYielder.Max, -PositiveDegreeMax, PositiveDegreeMax);
				break;
			}
			case EUsedType::Radian:
			{
				CheckRange(InYielder.Min, -PositiveRadianMax, PositiveRadianMax);
				CheckRange(InYielder.Max, -PositiveRadianMax, PositiveRadianMax);
				break;
			}
			case EUsedType::Color:
			{
				CheckRange(InYielder.Min, static_cast<float>(ColorMin), static_cast<float>(ColorMax));
				CheckRange(InYielder.Max, static_cast<float>(ColorMin), static_cast<float>(ColorMax));
				break;
			}
			case EUsedType::None:
			{
				throw std::logic_error("please specify used type");
			}
		}
	}

	/**
	 * 生成 Value
	 */
	static float GenerateValue(const FYielder& InYielder, const float FractionalNum = 1.0f)
	{
		float Result = 0.0f;
		switch (InYielder.GenerateType)
		{
			case EGenerateType::Normal:
			{
				Result = InYielder.Default;
				break;
			}
			case EGenerateType::Rand:
			{
				Result = FTool::GenerateRandomNumber(InYielder.Min, InYielder.Max, FractionalNum);
				break;
			}
			case EGenerateType::RandColor:
			{
				static FColor ColorMin;
				static FColor ColorMax;
				ColorMin = static_cast<COLORREF>(InYielder.Min);
				ColorMax = static_cast<COLORREF>(InYielder.Max);
				Result = static_cast<float>(FTool::GenerateRandomColor(ColorMin, ColorMax));
				break;
			}
			case EGenerateType::None:
			{
				throw std::logic_error("please specify generate type");
			}
		}
		return Result;
	}

	/**
	 * 获得 Value
	 */
	float GetValue(const bool IsRestartGenerate, const float InFractionalNum = 1.0f)
	{
		if (IsRestartGenerate || IsGenerated == false)
		{
			IsGenerated = true;
			Value = GenerateValue(*this, InFractionalNum);
		}
		return Value;
	}

public:
	EGenerateType GenerateType;			// 生成方式
	float Min;							// 最小值
	float Max;							// 最大值
	float Default;						// 默认值
private:
	float Value;						// 数值
	bool IsGenerated = false;			// 是否已经生成
};

/**
 * 窗口管理器
 */
class FWindowManager
{
public:
	static FWindowManager& GetInstance()
	{
		static FWindowManager WindowManager;
		return WindowManager;
	}

private:
	FWindowManager(const FWindowManager&) = default;
	FWindowManager(FWindowManager&&) = default;
	FWindowManager() = default;
	FWindowManager& operator=(const FWindowManager&) = default;
	FWindowManager& operator=(FWindowManager&&) = default;

public:
	void Initialize(float InWidth, float InHeight, const wchar_t* Title)
	{
		IsRunning = true;

		// 创建绘图窗口
		initgraph(static_cast<int>(InWidth), static_cast<int>(InHeight));

		// 修改窗口名称
		SetWindowText(GetHWnd(), Title);

		// 启用批绘图模式
		BeginBatchDraw();
	}

	~FWindowManager()
	{
		IsRunning = false;

		// 关闭绘图窗口
		closegraph();
	}

	void Flush() const
	{
		// 显示缓存的绘制内容
		FlushBatchDraw();
	}

private:
	bool IsRunning = false; // 是否在运行
};

/**
 * 形状类型
 */
enum class EShapeType: unsigned
{
	None = 0,
	Line = 1,
	SolidCircle = 2,
	SolidRectangle = 3,
};

struct FParticleEffect;
/**
 * 粒子信息
 */
struct FParticleInstance
{
public:
	EShapeType Type;			// 形状
	FColor Color;				// 颜色
	FVector2D Location;			// 坐标
	FVector2D Velocity;			// 速度
	float Friction;				// 摩擦力
	float Radius;				// 半径
	float LifeTime;				// 生命周期
	std::vector<FParticleEffect*> Effects;	// 粒子特效
public:
	FVector2D NextLocation;		// 下一次坐标
	bool IsPendingKilled;		// 是否进入死亡
	bool IsRendering;			// 是否正在渲染
public:
	FParticleInstance(EShapeType InType = EShapeType::SolidCircle,
					FColor InColor = {255, 255, 255},
					FVector2D InLocation = {0.0f, 0.0f},
					FVector2D InVelocity = {0.0f, 0.0f},
					float InFriction = 0.04f, float InRadius = 0.4f,
					float InLifeTime = 0.0f, std::vector<FParticleEffect*> InEffects = {}): Type(InType)
																							, Color(InColor)
																							, Location(InLocation)
																							, Velocity(InVelocity)
																							, Friction(InFriction)
																							, Radius(InRadius)
																							, LifeTime(InLifeTime)
																							, Effects(std::move(InEffects))
	{
		NextLocation = {0.0f, 0.0f};
		IsPendingKilled = false;
		IsRendering = false;
	}
};

/**
 * 特效信息
 */
struct FParticleEffect
{
public:
	typedef void (*FunctionPointer)(const float InDeltaTime, FParticleInstance& InParticleInstance);
public:
	unsigned int Id;																	// 标识
	BYTE Keyboard;																		// 控制按键
	FunctionPointer Function;															// 功能函数
	wchar_t HelpContent[255];															// 帮助文本
	bool IsShowHelp;																	// 是否显示帮助
};

/**
 * 粒子模板信息
 */
struct FParticleTemplate
{
public:
	FParticleTemplate(const unsigned int InId): Id(InId)
	{
	}

	FParticleTemplate() = default;
public:
	unsigned int Id = 0;										// 标识
	wchar_t Name[255]{_T("默认粒子")};							// 名称
	wchar_t Description[255]{_T("默认描述")};					// 描述
public:
	FYielder Color{RGB(0, 0, 0), RGB(255, 255, 255)};			// 颜色(默认随机)
	FVector2D StartLocation{0.0f, 0.0f};						// 起始坐标
	FYielder StartSpeed{10.0f, 20.0f};							// 起始速率
	FYielder LimitedSpeed{100.0f, 200.0f};						// 限制速率
	FYielder Friction{0.93f, 0.97f};							// 摩擦力
	FYielder Radius{1.0f, 1.5f};								// 半径
	FYielder LifeTime{1.0f, 5.0f};								// 生命周期
	std::vector<FParticleEffect*> Effects;						// 粒子特效
};

/**
 * 特效管理器
 */
class FParticleEffectManager
{
private:
	FParticleEffectManager() = default;
	~FParticleEffectManager() = default;
	FParticleEffectManager(const FParticleEffectManager&) = default;
	FParticleEffectManager(FParticleEffectManager&&) = default;
	FParticleEffectManager& operator=(const FParticleEffectManager&) = default;
	FParticleEffectManager& operator=(FParticleEffectManager&&) = default;

public:
	void Finish() const
	{
		ParticleEffect->Id = ParticleEffect->Id + 0;
	}

	static FParticleEffectManager& GetInstance()
	{
		static FParticleEffectManager ParticleEffectManager;
		return ParticleEffectManager;
	}

	FParticleEffectManager& BindParticleEffect(FParticleEffect& InParticleEffect)
	{
		ParticleEffect = &InParticleEffect;
		return GetInstance();
	}

	FParticleEffectManager& CreateParticleEffect(const unsigned int InId)
	{
		const unsigned int Guid = ParticleEffectGuid.NewGuid(InId);
		ParticleEffects[Guid] = {};
		return GetInstance()
				.BindParticleEffect(ParticleEffects[Guid])
				.SetId(InId);
	}

	FParticleEffect& GetParticleEffect(const unsigned int InId)
	{
		const unsigned int Guid = ParticleEffectGuid.GetGuid(InId);
		return ParticleEffects[Guid];
	}

public:
	FParticleEffectManager& SetFunction(const FParticleEffect::FunctionPointer InFunction) const
	{
		ParticleEffect->Function = InFunction;
		return GetInstance();
	}

	FParticleEffect::FunctionPointer GetFunction() const
	{
		return ParticleEffect->Function;
	}

	FParticleEffectManager& SetHelpContent(const wchar_t* InHelpContent) const
	{
		FYielder::AvoidWarning = swprintf_s(ParticleEffect->HelpContent, _T("%s"), InHelpContent);
		return GetInstance();
	}

	const wchar_t* GetHelpContent() const
	{
		return ParticleEffect->HelpContent;
	}

	FParticleEffectManager& SetIsShowHelp(const bool InIsShowHelp) const
	{
		ParticleEffect->IsShowHelp = InIsShowHelp;
		return GetInstance();
	}

	bool GetIsShowHelp() const
	{
		return ParticleEffect->IsShowHelp;
	}

	FParticleEffectManager& SetId(const unsigned int InId) const
	{
		ParticleEffect->Id = InId;
		return GetInstance();
	}

	unsigned int GetId() const
	{
		return ParticleEffect->Id;
	}

	FParticleEffectManager& SetKeyboard(const BYTE InKeyboard) const
	{
		ParticleEffect->Keyboard = InKeyboard;
		return GetInstance();
	}

	BYTE GetKeyboard() const
	{
		return ParticleEffect->Keyboard;
	}

private:
	FParticleEffect* ParticleEffect = nullptr;
	std::map<unsigned int, FParticleEffect> ParticleEffects;
	FGuid ParticleEffectGuid;
};

/**
 * 粒子实例管理器
 */
class FParticleInstanceManager
{
private:
	FParticleInstanceManager() = default;
	~FParticleInstanceManager() = default;
	FParticleInstanceManager(const FParticleInstanceManager&) = default;
	FParticleInstanceManager(FParticleInstanceManager&&) = default;
	FParticleInstanceManager& operator=(const FParticleInstanceManager&) = default;
	FParticleInstanceManager& operator=(FParticleInstanceManager&&) = default;

public:
	void Finish() const
	{
		ParticleInstance->LifeTime = ParticleInstance->LifeTime + 0;
	}

	static FParticleInstanceManager& GetInstance()
	{
		static FParticleInstanceManager ParticleInstanceManager;
		return ParticleInstanceManager;
	}

private:
	FParticleInstance* ParticleInstance = nullptr;
};

/**
 * 粒子模板管理器
 */
class FParticleTemplateManager
{
private:
	FParticleTemplateManager(): ParticleEffectManager(FParticleEffectManager::GetInstance())
	{
	}

	~FParticleTemplateManager() = default;
	FParticleTemplateManager(const FParticleTemplateManager&) = default;
	FParticleTemplateManager(FParticleTemplateManager&&) = default;
public:
	FParticleTemplateManager& operator=(const FParticleTemplateManager&) = delete;
	FParticleTemplateManager& operator=(FParticleTemplateManager&&) = delete;

public:
	void Finish() const
	{
		ParticleTemplate->Id = ParticleTemplate->Id + 0;
	}

	static FParticleTemplateManager& GetInstance()
	{
		static FParticleTemplateManager ParticleManager;
		return ParticleManager;
	}

	FParticleTemplateManager& BindParticleTemplate(FParticleTemplate& InParticleTemplate)
	{
		ParticleTemplate = &InParticleTemplate;
		return GetInstance();
	}


public:
	FParticleTemplateManager& SetEffects(const FVarNum Count, ...) const
	{
		ParticleTemplate->Effects = {};
		va_list List;
		va_start(List, Count);
		for (size_t i = 0; i < Count.Value; ++i)
		{
			ParticleTemplate->Effects.push_back(&ParticleEffectManager.GetParticleEffect(va_arg(List, unsigned int)));
		}
		return GetInstance();
	}

	std::vector<FParticleEffect*>& GetEffects() const
	{
		return ParticleTemplate->Effects;
	}

	FParticleTemplateManager& SetLimitedSpeed(const FYielder& InLimitedSpeed) const
	{
		FYielder::CheckYielder(InLimitedSpeed, EUsedType::PositiveFloat);
		ParticleTemplate->LimitedSpeed = InLimitedSpeed;
		return GetInstance();
	}

	FYielder GetLimitedSpeed() const
	{
		return ParticleTemplate->LimitedSpeed;
	}


	FParticleTemplateManager& SetFriction(const FYielder& InFriction) const
	{
		FYielder::CheckYielder(InFriction, EUsedType::PositivePercentZeroToOne);
		ParticleTemplate->Friction = InFriction;
		return GetInstance();
	}

	FYielder GetFriction() const
	{
		return ParticleTemplate->Friction;
	}


	FParticleTemplateManager& SetRadius(const FYielder& InRadius) const
	{
		FYielder::CheckYielder(InRadius, EUsedType::PositiveFloat);
		ParticleTemplate->Radius = InRadius;
		return GetInstance();
	}

	FYielder GetRadius() const
	{
		return ParticleTemplate->Radius;
	}


	FParticleTemplateManager& SetLifeTime(const FYielder& InLifeTime) const
	{
		FYielder::CheckYielder(InLifeTime, EUsedType::PositiveFloat);
		ParticleTemplate->LifeTime = InLifeTime;
		return GetInstance();
	}

	FYielder GetLifeTime() const
	{
		return ParticleTemplate->LifeTime;
	}

	FParticleTemplateManager& SetColor(const FYielder& InColor) const
	{
		FYielder::CheckYielder(InColor, EUsedType::Color);
		ParticleTemplate->Color = InColor;
		return GetInstance();
	}

	FYielder GetColor() const
	{
		return ParticleTemplate->Color;
	}

	FParticleTemplateManager& SetStartLocation(const FVector2D& InStartLocation) const
	{
		ParticleTemplate->StartLocation = InStartLocation;
		return GetInstance();
	}

	FVector2D GetStartLocation() const
	{
		return ParticleTemplate->StartLocation;
	}

	FParticleTemplateManager& SetStartSpeed(const FYielder& InStartSpeed) const
	{
		FYielder::CheckYielder(InStartSpeed, EUsedType::PositiveFloat);
		ParticleTemplate->StartSpeed = InStartSpeed;
		return GetInstance();
	}

	FYielder GetStartSpeed() const
	{
		return ParticleTemplate->StartSpeed;
	}

public:
	FParticleTemplateManager& SetId(const unsigned int InId) const
	{
		ParticleTemplate->Id = InId;
		return GetInstance();
	}

	unsigned int GetId() const
	{
		return ParticleTemplate->Id;
	}

	FParticleTemplateManager& SetName(const wchar_t* InName) const
	{
		FYielder::AvoidWarning = swprintf_s(ParticleTemplate->Name, _T("%s"), InName);
		return GetInstance();
	}

	const wchar_t* GetName() const
	{
		return ParticleTemplate->Name;
	}

	FParticleTemplateManager& SetDescription(const wchar_t* InDescription) const
	{
		FYielder::AvoidWarning = swprintf_s(ParticleTemplate->Description, _T("%s"), InDescription);
		return GetInstance();
	}

	const wchar_t* GetDescription() const
	{
		return ParticleTemplate->Description;
	}

private:
	FParticleTemplate* ParticleTemplate = nullptr;
	FParticleEffectManager& ParticleEffectManager;
};

/**
 * 发射器实例信息
 */
struct FEmitterInstance
{
public:
	float Time = 0.0f;								// 发射时间
	size_t Speed = 111;								// 发射速率
	FYielder Angle{0.0f, 360.0f};					// 发射方向
	FVector2D Location = {10.0f, 10.0f};			// 发射位置
	size_t Sum = 666;								// 发射总数
	bool IsLoop = false;							// 是否循环发射
public:
	std::vector<FParticleInstance> ParticleInstances;		// 粒子数组
	std::vector<FParticleTemplate> ParticleTemplates;		// 粒子模板数组
	bool IsRender = false;									// 是否已经加入渲染
	size_t RenderedNum = 0;									// 已经被渲染的粒子数
	size_t RenderingNum = 0;								// 正在渲染的粒子数
	size_t DeadNum = 0;										// 已经消逝的粒子数
};

/**
 * 发射器模板信息
 */
struct FEmitterTemplate
{
public:
	float Time = 0.0f;										// 发射时间
	size_t Speed = 111;										// 发射速率
	FYielder Angle{0.0f, 360.0f};							// 发射方向
	FVector2D Location = {10.0f, 10.0f};					// 发射位置
	size_t Sum = 666;										// 发射总数
	bool IsLoop = false;									// 是否循环发射
public:
	unsigned int Id = 0;									// 标识
	wchar_t Name[255]{_T("默认粒子")};						// 名称
	wchar_t Description[255]{_T("默认描述")};				// 描述
public:
	std::vector<FParticleTemplate> ParticleTemplates;		// 粒子模板数组
};

/**
 * 发射器实例管理器
 */
class FEmitterInstanceManager
{
private:
	FEmitterInstanceManager() = default;
	~FEmitterInstanceManager() = default;
	FEmitterInstanceManager(const FEmitterInstanceManager&) = default;
	FEmitterInstanceManager(FEmitterInstanceManager&&) = default;
	FEmitterInstanceManager& operator=(const FEmitterInstanceManager&) = default;
	FEmitterInstanceManager& operator=(FEmitterInstanceManager&&) = default;

public:
	void Finish() const
	{
		EmitterInstance->Time = EmitterInstance->Time + 0;
	}

	static FEmitterInstanceManager& GetInstance()
	{
		static FEmitterInstanceManager EmitterInstanceManager;
		return EmitterInstanceManager;
	}

	FEmitterInstanceManager& BindEmitterInstance(FEmitterInstance& InEmitterInstance)
	{
		EmitterInstance = &InEmitterInstance;
		return GetInstance();
	}

	/**
	 * 生成粒子实例
	 */
	FEmitterInstanceManager& CreateParticleInstance(FParticleTemplate InParticleTemplate) const
	{
		EmitterInstance->ParticleTemplates.push_back(InParticleTemplate);
		auto& ParticleInstances = EmitterInstance->ParticleInstances;
		ParticleInstances.reserve(ParticleInstances.size() + EmitterInstance->Sum);
		for (size_t i = 0; i < EmitterInstance->Sum; ++i)
		{
			const float StartAngleRand = EmitterInstance->Angle.GetValue(true, 2.0f);
			const float StartSpeedRand = InParticleTemplate.StartSpeed.GetValue(true, 2.0f);
			ParticleInstances.emplace_back(
				EShapeType::SolidCircle,
				static_cast<COLORREF>(InParticleTemplate.Color.GetValue(true, 0.0f)),
				InParticleTemplate.StartLocation + EmitterInstance->Location,
				FVector2D
				{
					cos(StartAngleRand) * StartSpeedRand,
					sin(StartAngleRand) * StartSpeedRand
				},
				InParticleTemplate.Friction.GetValue(true, 2.0f),
				InParticleTemplate.Radius.GetValue(true, 2.0f),
				InParticleTemplate.LifeTime.GetValue(true, 2.0f),
				InParticleTemplate.Effects
			);
		}
		return GetInstance();
	}

	/**
	 * 重新生成粒子实例
	 */
	FEmitterInstanceManager& RegenerateParticleInstance() const
	{
		SetIsRender(false)
			.SetRenderingNum(0)
			.SetRenderedNum(0)
			.SetDeadNum(0)
			.Finish();
		EmitterInstance->ParticleInstances = {};
		const auto ParticleTemplates = EmitterInstance->ParticleTemplates;
		EmitterInstance->ParticleTemplates = {};
		for (const auto& ParticleTemplate : ParticleTemplates)
		{
			CreateParticleInstance(ParticleTemplate).Finish();
		}
		return GetInstance();
	}

	/**
	 * 获得粒子实例
	 */
	std::vector<FParticleInstance>& GetParticleInstances() const
	{
		return EmitterInstance->ParticleInstances;
	}

public:
	FEmitterInstanceManager& SetParticleTemplates(const std::vector<FParticleTemplate>& InParticleTemplates) const
	{
		EmitterInstance->ParticleTemplates = InParticleTemplates;
		return GetInstance();
	}

	std::vector<FParticleTemplate>& GetParticleTemplates() const
	{
		return EmitterInstance->ParticleTemplates;
	}

	size_t GetTotalNum() const
	{
		return EmitterInstance->Sum * EmitterInstance->ParticleTemplates.size();
	}

	FEmitterInstanceManager& SetDeadNum(const size_t InDeadNum) const
	{
		EmitterInstance->DeadNum = InDeadNum;
		return GetInstance();
	}

	size_t GetDeadNum() const
	{
		return EmitterInstance->DeadNum;
	}

	FEmitterInstanceManager& SetRenderedNum(const size_t InRenderedNum) const
	{
		EmitterInstance->RenderedNum = InRenderedNum;
		return GetInstance();
	}

	size_t GetRenderedNum() const
	{
		return EmitterInstance->RenderedNum;
	}

	FEmitterInstanceManager& SetRenderingNum(const size_t InRenderingNum) const
	{
		EmitterInstance->RenderingNum = InRenderingNum;
		return GetInstance();
	}

	size_t GetRenderingNum() const
	{
		return EmitterInstance->RenderingNum;
	}

	FEmitterInstanceManager& SetIsLoop(const bool InIsLoop) const
	{
		EmitterInstance->IsLoop = InIsLoop;
		return GetInstance();
	}

	bool GetIsLoop() const
	{
		return EmitterInstance->IsLoop;
	}

	FEmitterInstanceManager& SetIsRender(const bool InIsRender) const
	{
		EmitterInstance->IsRender = InIsRender;
		return GetInstance();
	}

	bool GetIsRender() const
	{
		return EmitterInstance->IsRender;
	}

	FEmitterInstanceManager& SetTime(const float InTime) const
	{
		EmitterInstance->Time = InTime;
		return GetInstance();
	}

	float GetTime() const
	{
		return EmitterInstance->Time;
	}

	FEmitterInstanceManager& SetSpeed(const size_t InSpeed) const
	{
		EmitterInstance->Speed = InSpeed;
		return GetInstance();
	}

	size_t GetSpeed() const
	{
		return EmitterInstance->Speed;
	}

	FEmitterInstanceManager& SetSum(const unsigned int InSum) const
	{
		EmitterInstance->Sum = InSum;
		return GetInstance();
	}

	size_t GetSum() const
	{
		return EmitterInstance->Sum;
	}

	FEmitterInstanceManager& SetAngle(const FYielder& InAngle) const
	{
		EmitterInstance->Angle = InAngle;
		EmitterInstance->Angle.Min = FTool::DegreeToRadian(InAngle.Min);
		EmitterInstance->Angle.Max = FTool::DegreeToRadian(InAngle.Max);
		FYielder::CheckYielder(EmitterInstance->Angle, EUsedType::Radian);
		return GetInstance();
	}

	FYielder GetAngle() const
	{
		return EmitterInstance->Angle;
	}

	FEmitterInstanceManager& SetLocation(const FVector2D& InLocation) const
	{
		EmitterInstance->Location = InLocation;
		return GetInstance();
	}

	FVector2D GetLocation() const
	{
		return EmitterInstance->Location;
	}

private:
	FEmitterInstance* EmitterInstance = nullptr;
};

/**
 * 发射器模板管理器
 */
class FEmitterTemplateManager
{
private:
	FEmitterTemplateManager() = default;
	~FEmitterTemplateManager() = default;
	FEmitterTemplateManager(const FEmitterTemplateManager&) = default;
	FEmitterTemplateManager(FEmitterTemplateManager&&) = default;
	FEmitterTemplateManager& operator=(const FEmitterTemplateManager&) = default;
	FEmitterTemplateManager& operator=(FEmitterTemplateManager&&) = default;

public:
	void Finish() const
	{
		EmitterTemplate->Time = EmitterTemplate->Time + 0;
	}

	static FEmitterTemplateManager& GetInstance()
	{
		static FEmitterTemplateManager ParticleManager;
		return ParticleManager;
	}

	FEmitterTemplateManager& BindEmitterTemplate(FEmitterTemplate& InEmitterTemplate)
	{
		EmitterTemplate = &InEmitterTemplate;
		return GetInstance();
	}

	FEmitterInstance CreateEmitterInstance(const FEmitterTemplate& InEmitterTemplate) const
	{
		FEmitterInstance EmitterInstance;
		EmitterInstance.Sum = InEmitterTemplate.Sum;
		EmitterInstance.Speed = InEmitterTemplate.Speed;
		EmitterInstance.Angle = InEmitterTemplate.Angle;
		EmitterInstance.Location = InEmitterTemplate.Location;
		EmitterInstance.Time = InEmitterTemplate.Time;
		EmitterInstance.IsLoop = InEmitterTemplate.IsLoop;
		EmitterInstance.ParticleTemplates = InEmitterTemplate.ParticleTemplates;
		Finish();
		return EmitterInstance;
	}

public:
	FEmitterTemplateManager& SetParticleTemplates(const std::vector<FParticleTemplate>& InParticleTemplates) const
	{
		EmitterTemplate->ParticleTemplates = InParticleTemplates;
		return GetInstance();
	}

	std::vector<FParticleTemplate>& GetParticleTemplates() const
	{
		return EmitterTemplate->ParticleTemplates;
	}

	FEmitterTemplateManager& SetIsLoop(const bool InIsLoop) const
	{
		EmitterTemplate->IsLoop = InIsLoop;
		return GetInstance();
	}

	bool GetIsLoop() const
	{
		return EmitterTemplate->IsLoop;
	}

	FEmitterTemplateManager& SetTime(const float InTime) const
	{
		EmitterTemplate->Time = InTime;
		return GetInstance();
	}

	float GetTime() const
	{
		return EmitterTemplate->Time;
	}

	FEmitterTemplateManager& SetSpeed(const size_t InSpeed) const
	{
		EmitterTemplate->Speed = InSpeed;
		return GetInstance();
	}

	size_t GetSpeed() const
	{
		return EmitterTemplate->Speed;
	}

	FEmitterTemplateManager& SetSum(const unsigned int InSum) const
	{
		EmitterTemplate->Sum = InSum;
		return GetInstance();
	}

	size_t GetSum() const
	{
		return EmitterTemplate->Sum;
	}

	FEmitterTemplateManager& SetAngle(const FYielder& InAngle) const
	{
		FYielder::CheckYielder(EmitterTemplate->Angle, EUsedType::Degree);
		EmitterTemplate->Angle = InAngle;
		EmitterTemplate->Angle.Min = FTool::DegreeToRadian(InAngle.Min - 90.0f);
		EmitterTemplate->Angle.Max = FTool::DegreeToRadian(InAngle.Max - 90.0f);
		return GetInstance();
	}

	FYielder GetAngle() const
	{
		return EmitterTemplate->Angle;
	}

	FEmitterTemplateManager& SetLocation(const FVector2D& InLocation) const
	{
		EmitterTemplate->Location = InLocation;
		return GetInstance();
	}

	FVector2D GetLocation() const
	{
		return EmitterTemplate->Location;
	}

public:
	FEmitterTemplateManager& SetId(const unsigned int InId) const
	{
		EmitterTemplate->Id = InId;
		return GetInstance();
	}

	unsigned int GetId() const
	{
		return EmitterTemplate->Id;
	}

	FEmitterTemplateManager& SetName(const wchar_t* InName) const
	{
		FYielder::AvoidWarning = swprintf_s(EmitterTemplate->Name, _T("%s"), InName);
		return GetInstance();
	}

	const wchar_t* GetName() const
	{
		return EmitterTemplate->Name;
	}

	FEmitterTemplateManager& SetDescription(const wchar_t* InDescription) const
	{
		FYielder::AvoidWarning = swprintf_s(EmitterTemplate->Description, _T("%s"), InDescription);
		return GetInstance();
	}

	const wchar_t* GetDescription() const
	{
		return EmitterTemplate->Description;
	}

private:
	FEmitterTemplate* EmitterTemplate = nullptr;
};

/**
 * 粒子系统
 */
class FParticleSystem
{
public:
	static FParticleSystem& GetInstance()
	{
		static FParticleSystem ParticleSystem;
		return ParticleSystem;
	}

private:
	FParticleSystem(): WindowManager(FWindowManager::GetInstance()),
						ParticleEffectManager(FParticleEffectManager::GetInstance()),
						ParticleTemplateManager(FParticleTemplateManager::GetInstance()),
						ParticleInstanceManager(FParticleInstanceManager::GetInstance()),
						EmitterTemplateManager(FEmitterTemplateManager::GetInstance()),
						EmitterInstanceManager(FEmitterInstanceManager::GetInstance())
	{
	}

	~FParticleSystem() = default;
public:
	FParticleSystem(const FParticleSystem&) = delete;
	FParticleSystem(FParticleSystem&&) = delete;
	FParticleSystem& operator=(const FParticleSystem&) = delete;
	FParticleSystem& operator=(FParticleSystem&&) = delete;

public:
	void Finish()
	{
		SimulateTotalTime = SimulateTotalTime + 0.0f;
	}

	/**
	 * 初始化粒子系统
	 */
	FParticleSystem& InitInstance();

	/**
	 * 创造粒子特效
	 */
	FParticleEffectManager& CreateParticleEffect(const unsigned int InId) const
	{
		return ParticleEffectManager.CreateParticleEffect(InId);
	}

	/**
	 * 创造粒子模板
	 */
	FParticleTemplateManager& CreateParticleTemplate(const unsigned int InId)
	{
		const unsigned int Guid = ParticleTemplateGuid.NewGuid(InId);
		ParticleTemplates[Guid] = {};
		return ParticleTemplateManager
				.BindParticleTemplate(ParticleTemplates[Guid])
				.SetId(InId);
	}

	/**
	 * 参考已有粒子模板创造粒子模板
	 */
	FParticleTemplateManager& CreateParticleTemplate(const unsigned int InId, const unsigned int InCopyId)
	{
		const unsigned int Guid = ParticleTemplateGuid.NewGuid(InId);
		const unsigned int ReferGuid = ParticleTemplateGuid.GetGuid(InCopyId);

		ParticleTemplates[Guid] = ParticleTemplates[ReferGuid];
		return ParticleTemplateManager
				.BindParticleTemplate(ParticleTemplates[Guid])
				.SetId(InId);
	}

	/**
	 * 生成粒子实例
	 */
	FParticleSystem& CreateParticleInstance(const FVarNum Count, ...)
	{
		va_list List;
		va_start(List, Count);
		for (size_t i = 0; i < Count.Value; ++i)
		{
			EmitterInstanceManager.CreateParticleInstance(ParticleTemplates[ParticleTemplateGuid.GetGuid(va_arg(List, unsigned int))]);
			ParticleTotalNum += EmitterInstanceManager.GetSum();
		}
		va_end(List);
		return GetInstance();
	}

	/**
	 * 创造发射器模板
	 */
	FEmitterTemplateManager& CreateEmitterTemplate(const unsigned int InId)
	{
		const unsigned int Guid = EmitterTemplateGuid.NewGuid(InId);
		EmitterTemplates[Guid] = {};
		return EmitterTemplateManager
				.BindEmitterTemplate(EmitterTemplates[Guid])
				.SetId(InId);
	}

	/**
	 * 生成发射器实例
	 */
	FParticleSystem& CreateEmitterInstance(const unsigned int InId)
	{
		const FEmitterInstance EmitterInstance = EmitterTemplateManager.CreateEmitterInstance(EmitterTemplates[EmitterTemplateGuid.GetGuid(InId)]);
		EmitterInstances.push_back(EmitterInstance);
		EmitterInstanceManager.BindEmitterInstance(EmitterInstances[EmitterInstances.size() - 1]);
		return GetInstance();
	}

	/**
	 * 生成发射器实例
	 */
	FEmitterTemplateManager& CreateEmitterTemplate(const unsigned int InId, const unsigned int InCopyId)
	{
		const unsigned int Guid = EmitterTemplateGuid.NewGuid(InId);
		const unsigned int ReferGuid = EmitterTemplateGuid.GetGuid(InCopyId);

		EmitterTemplates[Guid] = EmitterTemplates[ReferGuid];
		return EmitterTemplateManager
				.BindEmitterTemplate(EmitterTemplates[Guid])
				.SetId(InId);
	}

	/**
	 * 启动所有发射器实例
	 */
	void RunEmitterInstances();

public:
	/**
	 * 设置增量时间
	 */
	void SetDeltaTime(const float InDeltaTime)
	{
		CustomDeltaTime = InDeltaTime;
	}

	/**
	 * 获得增量时间 (s)
	 */
	float GetDeltaTime() const
	{
		return CustomDeltaTime / 1000.0f;
	}

	/**
	 * 设置版本信息
	 * @param InX 系统重大重构时 + 1
	 * @param InY 系统出现新的功能时 + 1
	 * @param InZ 系统零碎修改时 + 1
	 */
	FParticleSystem& SetVersion(const unsigned InX, const unsigned InY, const unsigned InZ)
	{
		FYielder::AvoidWarning = swprintf_s(Version, _T("%u.%u.%u"), InX, InY, InZ);
		return GetInstance();
	}

	/**
	 * 获得版本信息 X.Y.Z
	 */
	const wchar_t* GetVersion()
	{
		return Version;
	}

	FParticleSystem& SetName(const wchar_t* InName)
	{
		FYielder::AvoidWarning = swprintf_s(Name, _T("%s"), InName);
		return GetInstance();
	}

	const wchar_t* GetName()
	{
		return Name;
	}

	FParticleSystem& SetScreenSize(const FVector2D& InScreenSize)
	{
		ScreenSize = InScreenSize;
		return GetInstance();
	}

	FVector2D GetScreenSize() const
	{
		return ScreenSize;
	}

private:
	/**
	 * 处理输入
	 */
	void HandleInput();

	/**
	 * 显示帮助信息
	 */
	void ShowHelp() const;

	/**
	 * 绘制动画(一帧)
	 */
	void Render(const float InDeltaTime);

	/**
	 * 计算 FPS
	 */
	float CalculateFps(const float InElapsedTime);

	/**
	 * 计算增量时间
	 */
	float CalculateDeltaTime(const clock_t InCurTime);

	/**
	 * 绝对延时
	 */
	static void Delay(const clock_t Ms);

	/**
	 * 帧率限制
	 */
	float LimitFps(const float InElapsedTime) const;

private:
	/**
	 * 鼠标范围特效:点击会出现小圆表示落点
	 */
	void OnEffectMouseField(const float InDeltaTime) const;

	/**
	 * 粒子轨迹消失特效:开启将不会记录粒子移动轨迹
	 */
	void OnEffectDisappearTrack(const float InDeltaTime) const;

	/**
	 * 粒子边界特效:碰到边界反弹
	 */
	void OnEffectReboundWall(const float InDeltaTime, FParticleInstance& InParticleInstance) const;

	/**
	 * 粒子大小特效:速度越大,粒子半径越大
	 */
	void OnEffectRadiusAboutSpeed(const float InDeltaTime, FParticleInstance& InParticleInstance) const;

	/**
	 * 粒子吹散特效:鼠标右击时,以落点吹散粒子
	 */
	void OnEffectBlow(const float InDeltaTime, FParticleInstance& InParticleInstance) const;

	/**
	 * 粒子聚集特效:鼠标左击时,以落点聚集粒子
	 */
	void OnEffectGather(const float InDeltaTime, FParticleInstance& InParticleInstance) const;

	/**
	 * 粒子搅动特效:鼠标移动时,以落点搅动粒子
	 */
	void OnEffectStir(const float InDeltaTime, FParticleInstance& InParticleInstance) const;

	/**
	 * 粒子摩擦力特效:粒子移动受摩擦力
	 */
	void OnEffectFriction(const float InDeltaTime, FParticleInstance& InParticleInstance) const;

	/**
	 * 粒子漩涡特效:空间存在漩涡,作用于粒子
	 */
	void OnEffectVortex(const float InDeltaTime, FParticleInstance& InParticleInstance) const;

	/**
	 * 粒子随机微动特效:不受作用的情况下,粒子会随机移动
	 */
	void OnEffectRandomMove(const float InDeltaTime, FParticleInstance& InParticleInstance) const;

	/**
	 * 粒子随滚轮缩放特效:鼠标滚轮移动控制粒子显示大小
	 */
	void OnEffectScaleWithWheel(const float InDeltaTime, FParticleInstance& InParticleInstance) const;

	/**
	 * 粒子重力特效:粒子受重力影响
	 */
	void OnEffectGravity(const float InDeltaTime, FParticleInstance& InParticleInstance) const;

	/**
	 * 粒子死亡特效:粒子也会消逝啊
	 */
	void OnEffectDeath(const float InDeltaTime, FParticleInstance& InParticleInstance) const;

private:
	FVector2D ScreenSize{1540.0f, 840.0f};			// 屏幕尺寸
	size_t ParticleTotalNum = 0;					// 粒子总数
	size_t ParticleCurNum = 0;						// 粒子当前数
	FVector2D CurMouseLocation;						// 当前鼠标坐标
	FVector2D PrevMouseLocation;					// 上次鼠标坐标
	FVector2D MouseVelocity;						// 鼠标速度
	bool IsLeftMouseDown = false;					// 是否按下鼠标左键
	bool IsRightMouseDown = false;					// 是否按下鼠标右键
	DWORD* GBuffer = nullptr;						// 显示缓冲区指针
	float CustomHighFps = 90.0f;					// 限制高帧率
	float CustomLowFps = 10.0f;						// 限制低帧率
	float CustomDeltaTime = 1000.0f / 90.0f;		// 增量时间(ms)
	float GraphicsFps = 90.0f;						// 当前帧数
	float GraphicsTime = 1000.0f / 90.0f;			// 当前帧时间
	float SimulateTotalTime = 0.0f;					// 模拟总时间
public:
	FWindowManager& WindowManager;									// 窗口管理器
	FParticleEffectManager& ParticleEffectManager;					// 粒子特效管理器
	FParticleTemplateManager& ParticleTemplateManager;				// 粒子模板管理器
	FParticleInstanceManager& ParticleInstanceManager;				// 粒子实例管理器
	FEmitterTemplateManager& EmitterTemplateManager;				// 发射器模板管理器
	FEmitterInstanceManager& EmitterInstanceManager;				// 发射器实例管理器
private:
	std::map<unsigned int, FParticleTemplate> ParticleTemplates;		// 粒子模板数组
	std::map<unsigned int, FEmitterTemplate> EmitterTemplates;			// 发射器模板数组
	std::vector<FEmitterInstance> EmitterInstances;						// 发射器实例数组
	FGuid ParticleTemplateGuid;											// 粒子唯一标识
	FGuid EmitterTemplateGuid;											// 发射器唯一标识
private:
	float RandomDis = 0.0f;		// 进入随机距离
	float BlowDis = 0.0f;		// 进入扩散距离
	float GatherDis = 0.0f;		// 进入聚集距离
	float StirDis = 0.0f;		// 进入搅动距离
private:
	float RandomSpeed = 20.0f;	// 随机速度
	float BlowSpeed = 5.0f;		// 扩散速度
	float GatherSpeed = 26.0f;	// 聚集速度
	float StirSpeed = 35.0f;	// 搅动速度
private:
	bool IsShowHelp = true;			// 是否显示帮助
	bool IsContinueGraphics = true;	// 是否继续系统
	bool IsContinueSimulate = true;	// 是否继续模拟
	bool IsRestartSimulate = false;	// 是否重新模拟
	mutable float ScaleSize = 1.0f;	// 滚轮缩放大小
private:
	// 特效控制,顾名思义
	bool IsEffectMouseField = false;
	bool IsEffectReboundWall = true;
	bool IsEffectRadiusAboutSpeed = false;
	bool IsEffectBlow = true;
	bool IsEffectGather = true;
	bool IsEffectStir = true;
	bool IsEffectFriction = true;
	bool IsEffectVortex = false;
	bool IsEffectRandomMove = false;
	bool IsEffectScaleWithWheel = true;
	bool IsEffectDisappearTrack = true;
	bool IsEffectGravity = false;
	bool IsEffectDeath = true;
private:
	wchar_t Name[255] = _T("Particle System");	// 粒子系统名称
	wchar_t Version[255] = _T("0.0.0");			// 粒子系统版本
};

ParticleSystem.cpp

#include "ParticleSystem.h"

const float FYielder::PositiveFloatMin = 0.0f;
const float FYielder::PositiveFloatMax = 100000000.0f;

const float FYielder::PositivePercentMin = 0.0f;
const float FYielder::PositivePercentMax = 100.0f;
const float FYielder::PositivePercentZeroToOneMin = 0.0f;
const float FYielder::PositivePercentZeroToOneMax = 1.0f;

const float FYielder::PositiveDegreeMin = 0.0f;
const float FYielder::PositiveDegreeMax = 360.0f;
const float FYielder::PositiveRadianMin = 0.0f;
const float FYielder::PositiveRadianMax = 3.1415926f * 2.0f;

const COLORREF FYielder::ColorMin = RGB(0, 0, 0);
const COLORREF FYielder::ColorMax = RGB(255, 255, 255);

int FYielder::AvoidWarning = 0;

FParticleSystem& FParticleSystem::InitInstance()
{
	// 初始化窗口管理器
	wchar_t Message[510];
	FYielder::AvoidWarning = swprintf_s(Message, _T("%s %s"), Name, GetVersion());
	WindowManager.Initialize(ScreenSize.X, ScreenSize.Y, Message);

	// 设置随机种子
	srand(static_cast<unsigned>(time(nullptr) + 5201314));

	// 获取显示缓冲区指针
	GBuffer = GetImageBuffer(nullptr);

	// 初始化鼠标变量
	CurMouseLocation = PrevMouseLocation = {ScreenSize.X / 2, ScreenSize.Y / 2};

	// 特效参数
	RandomDis = ScreenSize.X;
	BlowDis = ScreenSize.X * 0.5f;
	GatherDis = ScreenSize.X * 0.86f;
	StirDis = ScreenSize.X * 0.125f;

	// 其他
	CustomDeltaTime = 1000.0f / CustomHighFps;

	return GetInstance();
}

void FParticleSystem::RunEmitterInstances()
{
	static clock_t OldTime;
	static clock_t NewTime;
	while (IsContinueGraphics)
	{
		OldTime = clock();

		// 计算增量时间
		CalculateDeltaTime(clock());

		// 处理输入消息
		HandleInput();

		// 绘制所需图形
		Render(GetDeltaTime());

		// 显示缓存绘制
		WindowManager.Flush();

		NewTime = clock();

		// 限制并计算帧数
		CalculateFps(LimitFps(static_cast<float>(NewTime - OldTime)));

		// 计算总时间
		SimulateTotalTime += (IsContinueSimulate == true ? static_cast<float>(clock() - OldTime) / 1000.0f : 0.0f);
	}
}

void FParticleSystem::HandleInput()
{
	ExMessage Input{};
	while (peekmessage(&Input, EM_MOUSE | EM_KEY))
	{
		switch (Input.message)
		{
			case WM_MOUSEMOVE:
			{
				CurMouseLocation = {static_cast<float>(Input.x), static_cast<float>(Input.y)};
				break;
			}
			case WM_MOUSEWHEEL:
			{
				ScaleSize = min(max(ScaleSize + Input.wheel / 500.0f, 0.5f), 5.0f);
				break;
			}
			case WM_LBUTTONDOWN:
			{
				IsLeftMouseDown = true;
				break;
			}
			case WM_LBUTTONUP:
			{
				IsLeftMouseDown = false;
				break;
			}
			case WM_RBUTTONDOWN:
			{
				IsRightMouseDown = true;
				break;
			}
			case WM_RBUTTONUP:
			{
				IsRightMouseDown = false;
				break;
			}
			case WM_KEYDOWN:
			{
				switch (Input.vkcode)
				{
					case VK_RETURN: IsRestartSimulate = true;
						break;
					case VK_ESCAPE: IsContinueGraphics = false;
						break;
					case VK_SPACE: IsContinueSimulate = !IsContinueSimulate;
						break;
					case VK_TAB: IsShowHelp = !IsShowHelp;
						break;
					case 'A':
					case 'a': IsEffectMouseField = !IsEffectMouseField;
						break;
					case 'B':
					case 'b': IsEffectReboundWall = !IsEffectReboundWall;
						break;
					case 'C':
					case 'c': IsEffectRadiusAboutSpeed = !IsEffectRadiusAboutSpeed;
						break;
					case 'D':
					case 'd': IsEffectBlow = !IsEffectBlow;
						break;
					case 'E':
					case 'e': IsEffectGather = !IsEffectGather;
						break;
					case 'F':
					case 'f': IsEffectStir = !IsEffectStir;
						break;
					case 'G':
					case 'g': IsEffectFriction = !IsEffectFriction;
						break;
					case 'H':
					case 'h': IsEffectVortex = !IsEffectVortex;
						break;
					case 'I':
					case 'i': IsEffectRandomMove = !IsEffectRandomMove;
						break;
					case 'J':
					case 'j': IsEffectScaleWithWheel = !IsEffectScaleWithWheel;
						break;
					case 'K':
					case 'k': IsEffectDisappearTrack = !IsEffectDisappearTrack;
						break;
					case 'L':
					case 'l': IsEffectGravity = !IsEffectGravity;
						break;
					case 'M':
					case 'm': IsEffectDeath = !IsEffectDeath;
						break;
					default: break;
				}
				break;
			}
			default: break;
		}
	}
}

void FParticleSystem::ShowHelp() const
{
	if (IsShowHelp)
	{
		static wchar_t Message[255];
		static constexpr int TextHeight = 16;
		int Lines = -1;

		FYielder::AvoidWarning = swprintf_s(Message, _T("\t\tfps: %.1f"), static_cast<double>(GraphicsFps));
		outtextxy(0, TextHeight * (++Lines), Message);

		FYielder::AvoidWarning = swprintf_s(Message, _T("\t\ttime: %.1fms"), static_cast<double>(GraphicsTime));
		outtextxy(0, TextHeight * (++Lines), Message);

		FYielder::AvoidWarning = swprintf_s(Message,
											_T("\t\tparticles: %u / %u"),
											static_cast<unsigned int>(ParticleCurNum),
											static_cast<unsigned int>(ParticleTotalNum));
		outtextxy(0, TextHeight * (++Lines), Message);

		FYielder::AvoidWarning = swprintf_s(Message,
											_T("\t\ttotal: %.2fs"),
											static_cast<double>(SimulateTotalTime));
		outtextxy(0, TextHeight * (++Lines), Message);

		++Lines;
		outtextxy(0, TextHeight * (++Lines), _T("\t\tMouse"));
		outtextxy(0, TextHeight * (++Lines), _T("\t\tMove: Stir"));
		outtextxy(0, TextHeight * (++Lines), _T("\t\tLeft: Gather"));
		outtextxy(0, TextHeight * (++Lines), _T("\t\tRight: Blow"));
		outtextxy(0, TextHeight * (++Lines), _T("\t\tWheel: Scale"));

		++Lines;
		outtextxy(0, TextHeight * (++Lines), _T("\t\tKeyboard"));

		outtextxy(0, TextHeight * (++Lines), _T("\t\t[Esc]: Exit System"));
		outtextxy(0, TextHeight * (++Lines), _T("\t\t[Tab]: Hide Menu"));
		outtextxy(0, TextHeight * (++Lines), _T("\t\t[Space]: Pause System"));
		outtextxy(0, TextHeight * (++Lines), _T("\t\t[Enter]: Restart Simulate"));

		++Lines;
		outtextxy(0, TextHeight * (++Lines), _T("\t\tSpecial"));

		FYielder::AvoidWarning = swprintf_s(Message, _T("\t\t[A]: Effect - MouseField %s"),
											IsEffectMouseField == true ? _T("ON") : _T("OFF"));
		outtextxy(0, TextHeight * (++Lines), Message);

		FYielder::AvoidWarning = swprintf_s(Message, _T("\t\t[B]: Effect - ReboundWall %s"),
											IsEffectReboundWall == true ? _T("ON") : _T("OFF"));
		outtextxy(0, TextHeight * (++Lines), Message);

		FYielder::AvoidWarning = swprintf_s(Message, _T("\t\t[C]: Effect - RadiusAboutSpeed %s"),
											IsEffectRadiusAboutSpeed == true ? _T("ON") : _T("OFF"));
		outtextxy(0, TextHeight * (++Lines), Message);

		FYielder::AvoidWarning = swprintf_s(Message, _T("\t\t[D]: Effect - Blow %s"),
											IsEffectBlow == true ? _T("ON") : _T("OFF"));
		outtextxy(0, TextHeight * (++Lines), Message);

		FYielder::AvoidWarning = swprintf_s(Message, _T("\t\t[E]: Effect - Gather %s"),
											IsEffectGather == true ? _T("ON") : _T("OFF"));
		outtextxy(0, TextHeight * (++Lines), Message);

		FYielder::AvoidWarning = swprintf_s(Message, _T("\t\t[F]: Effect - Stir %s"),
											IsEffectStir == true ? _T("ON") : _T("OFF"));
		outtextxy(0, TextHeight * (++Lines), Message);

		FYielder::AvoidWarning = swprintf_s(Message, _T("\t\t[G]: Effect - Friction %s"),
											IsEffectFriction == true ? _T("ON") : _T("OFF"));
		outtextxy(0, TextHeight * (++Lines), Message);

		FYielder::AvoidWarning = swprintf_s(Message, _T("\t\t[H]: Effect - Vortex %s"),
											IsEffectVortex == true ? _T("ON") : _T("OFF"));
		outtextxy(0, TextHeight * (++Lines), Message);

		FYielder::AvoidWarning = swprintf_s(Message, _T("\t\t[I]: Effect - RandomMove %s"),
											IsEffectRandomMove == true ? _T("ON") : _T("OFF"));
		outtextxy(0, TextHeight * (++Lines), Message);

		FYielder::AvoidWarning = swprintf_s(Message, _T("\t\t[J]: Effect - Scale %s"),
											IsEffectScaleWithWheel == true ? _T("ON") : _T("OFF"));
		outtextxy(0, TextHeight * (++Lines), Message);

		FYielder::AvoidWarning = swprintf_s(Message, _T("\t\t[K]: Effect - DisappearTrack %s"),
											IsEffectDisappearTrack == true ? _T("ON") : _T("OFF"));
		outtextxy(0, TextHeight * (++Lines), Message);

		FYielder::AvoidWarning = swprintf_s(Message, _T("\t\t[L]: Effect - Gravity %s"),
											IsEffectGravity == true ? _T("ON") : _T("OFF"));
		outtextxy(0, TextHeight * (++Lines), Message);

		FYielder::AvoidWarning = swprintf_s(Message, _T("\t\t[M]: Effect - Death %s"),
											IsEffectDeath == true ? _T("ON") : _T("OFF"));
		outtextxy(0, TextHeight * (++Lines), Message);
	}
}

void FParticleSystem::Render(const float InDeltaTime)
{
	if (IsContinueSimulate)
	{
		if (IsRestartSimulate)
		{
			IsRestartSimulate = false;
			SimulateTotalTime = 0.0f;
			ParticleCurNum = 0;
			ParticleTotalNum = 0;
			for (auto& EmitterInstance : EmitterInstances)
			{
				EmitterInstanceManager.BindEmitterInstance(EmitterInstance)
									.SetIsRender(false)
									.SetRenderingNum(0)
									.SetRenderedNum(0)
									.SetDeadNum(0)
									.RegenerateParticleInstance()
									.Finish();
				ParticleTotalNum += EmitterInstanceManager.GetTotalNum();
			}
		}
		else
		{
			ShowHelp();
			OnEffectMouseField(InDeltaTime);
			OnEffectDisappearTrack(InDeltaTime);

			MouseVelocity = CurMouseLocation - PrevMouseLocation;

			PrevMouseLocation = CurMouseLocation;

			ParticleCurNum = 0;
			for (auto& EmitterInstance : EmitterInstances)
			{
				std::vector<FParticleInstance>& Particles = EmitterInstanceManager
															.BindEmitterInstance(EmitterInstance)
															.GetParticleInstances();

				if (EmitterInstanceManager.GetTime() <= SimulateTotalTime)
				{
					EmitterInstanceManager.SetIsRender(true).Finish();

					static size_t NewRenderNum;
					static size_t RenderingNum;
					static size_t RenderedNum;
					static size_t DeadNum;
					static size_t RemainNum;

					NewRenderNum = 0;
					RenderingNum = EmitterInstanceManager.GetRenderingNum();
					RenderedNum = EmitterInstanceManager.GetRenderedNum();
					DeadNum = EmitterInstanceManager.GetDeadNum();
					RemainNum = EmitterInstanceManager.GetTotalNum() - EmitterInstanceManager.GetRenderedNum();

					if (RemainNum > 0)
					{
						NewRenderNum = FTool::Clamp(EmitterInstanceManager.GetSpeed(), static_cast<size_t>(0), RemainNum);
						EmitterInstanceManager.SetRenderedNum(RenderedNum + NewRenderNum).Finish();
						EmitterInstanceManager.SetRenderingNum(RenderingNum + NewRenderNum).Finish();
					}

					for (size_t i = 0; i < EmitterInstanceManager.GetRenderingNum(); ++i)
					{
						// 画粒子
						Particles[i].IsRendering = true;
						setfillcolor(Particles[i].Color.sRGB);
						solidcircle(static_cast<int>(Particles[i].Location.X),
									static_cast<int>(Particles[i].Location.Y),
									static_cast<int>(floorf(Particles[i].Radius * ScaleSize)));

						// 计算下一帧数据
						if (Particles[i].IsPendingKilled == true)
						{
							std::swap(Particles[i], Particles[Particles.size() - 1]);
							Particles.pop_back();
							EmitterInstanceManager.SetRenderingNum(EmitterInstanceManager.GetRenderingNum() - 1).Finish();
							EmitterInstanceManager.SetDeadNum(EmitterInstanceManager.GetDeadNum() + 1).Finish();
						}
						else
						{
							FParticleInstance Temp = Particles[i];

							for (const auto& Effect: Temp.Effects)
							{
								Effect->Function(InDeltaTime, Temp);
							}
							OnEffectDeath(InDeltaTime, Temp);
							OnEffectRandomMove(InDeltaTime, Temp);
							OnEffectBlow(InDeltaTime, Temp);
							OnEffectGather(InDeltaTime, Temp);
							OnEffectStir(InDeltaTime, Temp);
							OnEffectFriction(InDeltaTime, Temp);
							OnEffectRadiusAboutSpeed(InDeltaTime, Temp);
							OnEffectVortex(InDeltaTime, Temp);
							OnEffectGravity(InDeltaTime, Temp);
							OnEffectScaleWithWheel(InDeltaTime, Temp);

							Temp.NextLocation = Temp.Location + Temp.Velocity;

							OnEffectReboundWall(InDeltaTime, Temp);

							Temp.Location = Temp.NextLocation;

							Particles[i] = Temp;
						}
					}
					ParticleCurNum += EmitterInstanceManager.GetRenderingNum();

					if (RemainNum <= 0)
					{
						if (EmitterInstanceManager.GetIsLoop())
						{
							EmitterInstanceManager.BindEmitterInstance(EmitterInstance)
												.RegenerateParticleInstance()
												.Finish();
						}
					}
				}
			}
		}
	}
}

float FParticleSystem::CalculateFps(const float InElapsedTime)
{
	static constexpr int FpsCount = 8; // 每 8 次计算一次帧数
	static int Count = 0;
	static float TotalElapsedTime = 0;

	++Count;
	GraphicsTime = InElapsedTime;
	TotalElapsedTime += InElapsedTime;
	if (Count >= FpsCount)
	{
		GraphicsFps = static_cast<float>(Count) / (TotalElapsedTime / 1000.0f);
		Count = 0;
		TotalElapsedTime = 0;
	}

	return GraphicsFps;
}

float FParticleSystem::CalculateDeltaTime(const clock_t InCurTime)
{
	static clock_t LastTime = clock();
	static const float LowLimit = 1000.0f / CustomLowFps;
	static const float HighLimit = 1000.0f / CustomHighFps;

	auto CurDeltaTime = static_cast<float>(InCurTime - LastTime);

	if (CurDeltaTime > LowLimit)
	{
		CurDeltaTime = LowLimit;
	}
	if (CurDeltaTime < HighLimit)
	{
		CurDeltaTime = HighLimit;
	}

	SetDeltaTime(CurDeltaTime);
	LastTime = InCurTime;

	return CurDeltaTime;
}

void FParticleSystem::Delay(const clock_t Ms)
{
	static clock_t OldTime = clock();
	OldTime = clock();
	while ((clock() - OldTime) < Ms)
	{
		Sleep(1);
	}
}

float FParticleSystem::LimitFps(const float InElapsedTime) const
{
	float OffsetTime = (1000.0f / CustomHighFps) - InElapsedTime;
	if (OffsetTime >= 0.01f)
	{
		Delay(static_cast<clock_t>(OffsetTime + 1));
	}
	else
	{
		OffsetTime = 0.0f;
	}
	return InElapsedTime + OffsetTime;
}

void FParticleSystem::OnEffectMouseField(const float InDeltaTime) const
{
	if (IsEffectMouseField)
	{
		static float Radius = 2.0f;
		static float Times = 1.5f;
		static float MouseFieldSpeed = 0.5f;
		static COLORREF Color = RGB(187, 34, 128);

		if (IsLeftMouseDown)
		{
			if (Times == 0.0f)
			{
				Times = 1.5f;
			}
			else
			{
				Times += 1.5f;
			}
			Times -= MouseFieldSpeed * InDeltaTime;
			Radius += MouseFieldSpeed * InDeltaTime;
			setfillcolor(Color);
			setlinecolor(Color);
			fillcircle(static_cast<int>(CurMouseLocation.X + 0.01f * MouseVelocity.X),
						static_cast<int>(CurMouseLocation.Y + 0.01f * MouseVelocity.Y),
						static_cast<int>(max(Radius, 5.0f)));
		}
		else
		{
			if (Times > 0.0f)
			{
				Times -= MouseFieldSpeed * InDeltaTime;
				Radius -= MouseFieldSpeed * InDeltaTime;
				setfillcolor(Color);
				setlinecolor(Color);
				fillcircle(static_cast<int>(CurMouseLocation.X),
							static_cast<int>(CurMouseLocation.Y),
							static_cast<int>(max(Radius, 2.0f)));
			}
			else
			{
				Times = 0.0f;
				Color = RGB(FTool::GenerateRandomNumber(255), FTool::GenerateRandomNumber(255),
							FTool::GenerateRandomNumber(255));
			}
		}
	}
}

void FParticleSystem::OnEffectDisappearTrack(const float InDeltaTime) const
{
	if (IsEffectDisappearTrack)
	{
		for (int i = static_cast<int>(ScreenSize.X * ScreenSize.Y) - 1; i >= 0; --i)
		{
			if (GBuffer[i] != 0)
			{
				GBuffer[i] = RGB(GetRValue(GBuffer[i]) >> 1, GetGValue(GBuffer[i]) >> 1, GetBValue(GBuffer[i]) >> 1);
			}
		}
	}
}

void FParticleSystem::OnEffectReboundWall(const float InDeltaTime, FParticleInstance& InParticleInstance) const
{
	if (IsEffectReboundWall && InParticleInstance.IsRendering)
	{
		static float ReboundLoss = 0.85f;
		if (InParticleInstance.NextLocation.X > ScreenSize.X)
		{
			InParticleInstance.NextLocation.X = ScreenSize.X;
			InParticleInstance.Velocity.X *= -1 * ReboundLoss;
		}
		else if (InParticleInstance.NextLocation.X < 0)
		{
			InParticleInstance.NextLocation.X = 0;
			InParticleInstance.Velocity.X *= -1 * ReboundLoss;
		}
		if (InParticleInstance.NextLocation.Y > ScreenSize.Y)
		{
			InParticleInstance.NextLocation.Y = ScreenSize.Y;
			InParticleInstance.Velocity.Y *= -1 * ReboundLoss;
		}
		else if (InParticleInstance.NextLocation.Y < 0)
		{
			InParticleInstance.NextLocation.Y = 0;
			InParticleInstance.Velocity.Y *= -1 * ReboundLoss;
		}
	}
}

void FParticleSystem::OnEffectRadiusAboutSpeed(const float InDeltaTime, FParticleInstance& InParticleInstance) const
{
	if (IsEffectRadiusAboutSpeed && InParticleInstance.IsRendering)
	{
		const float AvgVx = fabs(InParticleInstance.Velocity.X);
		const float AvgVy = fabs(InParticleInstance.Velocity.Y);
		const float AvgV = (AvgVx + AvgVy) * 0.5f;

		InParticleInstance.Radius = AvgV * 0.45f + 0.5f;
		InParticleInstance.Radius = FTool::Clamp(InParticleInstance.Radius, 0.4f, 1.66f);
	}
}

void FParticleSystem::OnEffectBlow(const float InDeltaTime, FParticleInstance& InParticleInstance) const
{
	if (IsEffectBlow && InParticleInstance.IsRendering)
	{
		float DisX = InParticleInstance.Location.X - CurMouseLocation.X;
		float DisY = InParticleInstance.Location.Y - CurMouseLocation.Y;
		const float Radius = sqrt(DisX * DisX + DisY * DisY);
		DisX = Radius > 0.01f ? DisX / Radius : 0;
		DisY = Radius > 0.01f ? DisY / Radius : 0;

		if (IsRightMouseDown && Radius < BlowDis)
		{
			const float BlowAcc = (1 - (Radius / BlowDis)) * 14;
			InParticleInstance.Velocity.X += DisX * BlowAcc * BlowSpeed * InDeltaTime + 0.5f - static_cast<float>(
				FTool::GenerateRandomNumber()) / RAND_MAX;
			InParticleInstance.Velocity.Y += DisY * BlowAcc * BlowSpeed * InDeltaTime + 0.5f - static_cast<float>(
				FTool::GenerateRandomNumber()) / RAND_MAX;
		}
	}
}

void FParticleSystem::OnEffectGather(const float InDeltaTime, FParticleInstance& InParticleInstance) const
{
	if (IsEffectGather && InParticleInstance.IsRendering)
	{
		float DisX = InParticleInstance.Location.X - CurMouseLocation.X;
		float DisY = InParticleInstance.Location.Y - CurMouseLocation.Y;
		const float Radius = FTool::CalculateLength({DisX, DisY});

		DisX = Radius > 0.01f ? DisX / Radius : 0;
		DisY = Radius > 0.01f ? DisY / Radius : 0;

		if (IsLeftMouseDown && Radius < GatherDis)
		{
			const float GatherAcc = (1 - (Radius / GatherDis)) * ScreenSize.X * 0.0014f;
			InParticleInstance.Velocity.X -= DisX * GatherAcc * GatherSpeed * InDeltaTime;
			InParticleInstance.Velocity.Y -= DisY * GatherAcc * GatherSpeed * InDeltaTime;
		}
	}
}

void FParticleSystem::OnEffectStir(const float InDeltaTime, FParticleInstance& InParticleInstance) const
{
	if (IsEffectStir && InParticleInstance.IsRendering)
	{
		const float DisX = InParticleInstance.Location.X - CurMouseLocation.X;
		const float DisY = InParticleInstance.Location.Y - CurMouseLocation.Y;
		const float Radius = FTool::CalculateLength({DisX, DisY});

		if (!IsLeftMouseDown && !IsRightMouseDown && Radius < StirDis)
		{
			const float StirAcc = (1 - (Radius / StirDis)) * ScreenSize.X * 0.00026f;
			InParticleInstance.Velocity +=
			{
				MouseVelocity.X * StirAcc * StirSpeed * InDeltaTime,
				MouseVelocity.Y * StirAcc * StirSpeed * InDeltaTime
			};
		}
	}
}

void FParticleSystem::OnEffectFriction(const float InDeltaTime, FParticleInstance& InParticleInstance) const
{
	if (IsEffectFriction && InParticleInstance.IsRendering)
	{
		InParticleInstance.Velocity *= InParticleInstance.Friction;
	}
}

void FParticleSystem::OnEffectVortex(const float InDeltaTime, FParticleInstance& InParticleInstance) const
{
	if (IsEffectVortex && InParticleInstance.IsRendering)
	{
		static std::vector<FVortex> Vortexes;
		static constexpr int VortexesNum = 3;
		if (Vortexes.empty())
		{
			for (int i = 0; i < VortexesNum; ++i)
			{
				float PosX = 10.0f + FTool::GenerateRandomNumber(ScreenSize.X - 1, 1.0f);
				float PosY = 10.0f + FTool::GenerateRandomNumber(ScreenSize.Y - 1, 1.0f);
				float Radius = max(30.0f, 30.0f + FTool::GenerateRandomNumber(29.0f, 1.0f));
				const float Speed = 20.0f + FTool::GenerateRandomNumber(50.0f, 1.0f);
				if ((ScreenSize.X - PosX) <= 10)
				{
					PosX = ScreenSize.X - 20;
					Radius = 15.0f;
				}
				if ((ScreenSize.Y - PosY) <= 10)
				{
					PosY = ScreenSize.Y - 20;
					Radius = 15.0f;
				}
				Vortexes.push_back({{PosX, PosY}, Radius, Speed});
			}
		}
		else
		{
			for (int i = 0; i < VortexesNum; ++i)
			{
				const float Vx = InParticleInstance.Location.X - Vortexes[i].Position.X - 1;
				const float Vy = InParticleInstance.Location.Y - Vortexes[i].Position.Y - 1;
				const float Distance = FTool::CalculateLength({Vx, Vy});

				static float RotationSpeed = 35.0f + FTool::GenerateRandomNumber(10.0f, 1.0f);
				if (Distance <= Vortexes[i].Radius)
				{
					InParticleInstance.Location =
					{
						Vortexes[i].Position.X + Vx * cos(RotationSpeed * InDeltaTime) + Vy * sin(
							Vortexes[i].RotateSpeed * InDeltaTime),
						Vortexes[i].Position.Y + Vy * cos(RotationSpeed * InDeltaTime) - Vx * sin(
							Vortexes[i].RotateSpeed * InDeltaTime)
					};
					if (FTool::GenerateRandomNumber(10) > 7)
					{
						InParticleInstance.Location +=
						{
							FTool::GenerateRandomSign<float>() * FTool::GenerateRandomNumber(
								5.0f, 1.0f),
							FTool::GenerateRandomSign<float>() * FTool::GenerateRandomNumber(
								5.0f, 1.0f)
						};
					}
				}
			}
		}
	}
}

void FParticleSystem::OnEffectRandomMove(const float InDeltaTime, FParticleInstance& InParticleInstance) const
{
	if (IsEffectRandomMove && InParticleInstance.IsRendering)
	{
		float DisX = InParticleInstance.Location.X - CurMouseLocation.X;
		float DisY = InParticleInstance.Location.Y - CurMouseLocation.Y;
		const float Radius = FTool::CalculateLength({DisX, DisY});

		DisX = Radius > 0.01f ? DisX / Radius : 0;
		DisY = Radius > 0.01f ? DisY / Radius : 0;

		const float RandomAcc = FTool::GenerateRandomSign<float>() * Radius / RandomDis * 0.5f;
		InParticleInstance.Velocity +=
		{
			DisX * RandomAcc * RandomSpeed * InDeltaTime + 0.5f - static_cast<float>(
				FTool::GenerateRandomNumber()) / RAND_MAX,
			DisY * RandomAcc * RandomSpeed * InDeltaTime + 0.5f - static_cast<float>(
				FTool::GenerateRandomNumber()) / RAND_MAX
		};

		const float AvgVx = fabs(InParticleInstance.Velocity.X);
		const float AvgVy = fabs(InParticleInstance.Velocity.Y);
		if (AvgVx < 0.1f) InParticleInstance.Velocity.X *= static_cast<float>(FTool::GenerateRandomNumber()) / RAND_MAX * 2;
		if (AvgVy < 0.1f) InParticleInstance.Velocity.Y *= static_cast<float>(FTool::GenerateRandomNumber()) / RAND_MAX * 2;
	}
}

void FParticleSystem::OnEffectScaleWithWheel(const float InDeltaTime, FParticleInstance& InParticleInstance) const
{
	if (IsEffectScaleWithWheel && InParticleInstance.IsRendering)
	{
		// nothing to do
	}
	else
	{
		ScaleSize = 1.0f;
	}
}

void FParticleSystem::OnEffectGravity(const float InDeltaTime, FParticleInstance& InParticleInstance) const
{
	if (IsEffectGravity && InParticleInstance.IsRendering)
	{
		if ((ScreenSize.Y - InParticleInstance.Location.Y) >= 5)
		{
			static float GravitySpeed = 1.0f;
			static float Gravity = 10.0f;
			InParticleInstance.Velocity.Y += Gravity * GravitySpeed * InDeltaTime;
		}
	}
}

void FParticleSystem::OnEffectDeath(const float InDeltaTime, FParticleInstance& InParticleInstance) const
{
	if (IsEffectDeath && InParticleInstance.IsRendering)
	{
		static float DeathSpeed = 1.0f;
		InParticleInstance.LifeTime -= DeathSpeed * InDeltaTime;
		if (InParticleInstance.LifeTime <= 0)
		{
			InParticleInstance.LifeTime = 0;
			InParticleInstance.IsPendingKilled = true;
		}
	}
}

虽然代码有注释,但是如果存在不明白或错误之处,欢迎留言。

四、项目记录

## 一、概念介绍

粒子系统的一个普遍公认的定义是:粒子系统由具有相同属性规则的微小个体组成,
大量微小个体可以随机显示不同特征的粒子的集合体。

## 二、编码规范

命名法

- PascalCase

前缀

- F 默认
- E 枚举
- Is 表询问的布尔值
- In 形参

其他

- 函数声明提供:文档注释
- 变量声明提供:行注释
- 不同作用的成员隔开:类权限修饰符
- 尽量加 const 修饰符
- 尽量传 const& 参数
- 使用:Setter / Getter 提供访问控制
- 使用 Tab 对齐注释
- 能使用 static 函数不使用 non - static
- 能在 编译期 报错就绝不在 运行期 报错
- 能使用 变量 就绝不写 固定数值
- 不要忽视任何一个 warning

## 三、可控属性

发射器

- 标识符:unsigned int >0 无重复,用于寻找
- 名称:wchar_t 0 - 255 个字符
- 说明:wchar_t 0 - 255 个字符
- 发射数量:unsigned int > 0 总共发射多少粒子
- 发射时间:float > 0 粒子系统运行多久后发射
- 发射速率:size_t > 0 每帧发射多少粒子
- 发射角度:float 以 y 轴正半轴顺时针转 0 - 360
- 发射位置:FVector2D
- 是否循环:bool

粒子

- 标识符:unsigned int > 0 无重复,用于寻找
- 名称:wchar_t 0 - 255 个字符
- 说明:wchar_t 0 - 255 个字符
- 颜色:COLORREF RGB() 随机请使用 EGenerateType::RandColor
- 初始位置:FVector2D 相对发射器的坐标
- 初始速率:float > 0
- 阻力:float 0.0 - 1.0
- 半径:float > 0
- 生命周期:float > 0

## 四、Bug

- DeltaTime 未完全利用
- IsRender 属性应该归粒子所有,这样才好计算生命周期 (已解决)
- 粒子渲染错误,奇怪的数组越界(已解决)
- 阻力公式错误

## 五、更新日志

采用 x.y.z 模式

- x 系统重大重构时 + 1
- y 系统出现新的功能时 + 1
- z 系统零碎修改时 + 1

2020 - 08 - 01 版本 1.0.0

- x 研究 Krissi 大佬的粒子系统代码
- x 研究 EasyX 平台其他作品的代码

2020 - 08 - 02 版本 1.6.0

- y 提供 ParticlesSystem 类,Particle 类
- y 添加基础属性/特效函数
- y 添加更多按键
- y 添加提示信息
- y 计算 fps,deltaTime,particles 等数据

2020 - 08 - 03 版本 1.11.3

- y 提供 Emitter 类,EmitterManager 类,Utlis 类
- z 解决 fps 计算和限制问题
- z 解决部分 deltaTime 计算和使用错误问题
- y 规范语法,大幅度减少编译器警告
- y 现在可以使用链式调用设置 Emitter 类
- y 新增开始时间属性
- y 新增位置属性
- z 完善单例模式

2020 - 08 - 04 版本 1.15.6

- y 提供 FParticleManager 类
- z 实装 FVector2D 类
- y 提供 Float 类,作用是数值
- z 实装 Float 类
- z Float 类改名为 FYielder 类,作用是生成数值
- y 数值异常处理
- y 提供总时间提示

2020 - 08 - 05 版本 2.0.0

- y 新增发射时间和生命周期关联
- y 新增发射速率
- z 继续规范命名
- y 现在可以设置系统的名称和版本
- x 重新设计粒子系统的执行流程,大幅度修改代码

2020 - 08 - 06 版本 2.4.1

- z 优化命名
- y 提供 FGuid 类,提供唯一标识符
- y 实装 FGuid 类
- y 提供参考已有模板创建新模板的功能
- y 提供可变参数创建发射器实例

2020 - 08 - 07 版本 2.5.1

- y 分离特效控制,提供自定义特效接口

感谢看完!!!

评论 (2) -

添加评论