HGE系列之八管中窥豹(粒子系统)
HGE系列之八管中窥豹(粒子系统)
HGE系列之八管中窥豹(粒子系统)
这次的HGE系列让我们一起来学习一下HGE引擎的粒子系统部分，对于粒子系统不甚了解的朋友可以从这里开始了解。
首先还是让我们从头文件开始：
类名 ：hgeParticle
功能 ：单个粒子的属性结构
头文件 ：hge/hge181/include/hgeParticle.h
实现文件 ： 无
struct hgeParticle
{
// 粒子所在的位置
hgeVector vecLocation;
// 粒子的速度(Velocity)
hgeVector vecVelocity;
// 粒子的重力
float fGravity;
// 粒子的线加速度
float fRadialAccel;
// 粒子的角加速度
float fTangentialAccel;
// 粒子的旋转角度
float fSpin;
// 粒子旋转角度偏移量
float fSpinDelta;
// 粒子的大小
float fSize;
// 粒子的大小偏移量
float fSizeDelta;
// 粒子的颜色（带alpha值）
hgeColor colColor; // + alpha
// 粒子的颜色偏移量
hgeColor colColorDelta;
// 粒子的生存时间
float fAge;
// 粒子的死亡时间
float fTerminalAge;
};
仅一个简单的数据集合而已，各中变量相信大家一目了然 ：）
类名 ：hgeParticleSystemInfo
功能 ：粒子系统的相关信息结构
头文件 ：hge/hge181/include/hgeParticle.h
实现文件 ： 无
struct hgeParticleSystemInfo
{
// 粒子贴图
hgeSprite* sprite; // texture + blend mode
// 每秒的粒子数
int nEmission; // particles per sec
// 生命周期
float fLifetime;
// 最小生命周期
float fParticleLifeMin;
// 最大生命周期
float fParticleLifeMax;
// 方向
float fDirection;
// 偏移角度
float fSpread;
// 绝对值还是相对值，用以计算生成粒子的初始速度
bool bRelative;
// 最低速度
float fSpeedMin;
// 最高速度
float fSpeedMax;
// 最小重力
float fGravityMin;
// 最大重力
float fGravityMax;
// 最低线加速度
float fRadialAccelMin;
// 最高线加速度
float fRadialAccelMax;
// 最低角加速度
float fTangentialAccelMin;
// 最高角加速度
float fTangentialAccelMax;
// 起始大小
float fSizeStart;
// 最终大小
float fSizeEnd;
// 大小变化值
float fSizeVar;
// 起始旋转角度
float fSpinStart;
// 最终旋转角度
float fSpinEnd;
// 角度变化值
float fSpinVar;
// 起始颜色
hgeColor colColorStart; // + alpha
// 最终颜色
hgeColor colColorEnd;
// 颜色变化值
float fColorVar;
// alpha变化值
float fAlphaVar;
};
仍然是一个数据集合而已：）
接着让我们看一看hgeParticleSystem这个类型：
类名 ：hgeParticleSystem
功能 ：粒子系统
头文件 ：hge/hge181/include/hgeParticle.h
实现文件 ： hge/hge181/src/helpers/hgeparticle.cpp
class hgeParticleSystem
{
public:
// 用于存储粒子系统的相关信息（详见hgeParticleSystemInfo的定义）
hgeParticleSystemInfo info;
// 构造函数&析构函数
hgeParticleSystem(const char *filename, hgeSprite *sprite);
hgeParticleSystem(hgeParticleSystemInfo *psi);
hgeParticleSystem(const hgeParticleSystem &ps);
~hgeParticleSystem() { hge->Release(); }
// 重载赋值运算符
hgeParticleSystem& operator= (const hgeParticleSystem &ps);
// 渲染粒子系统
void Render();
// 在指定位置启动粒子系统
void FireAt(float x, float y);
// 启动粒子系统
void Fire();
// 停止粒子系统
void Stop(bool bKillParticles=false);
// 更新粒子系统
void Update(float fDeltaTime);
// 移动粒子系统的位置
void MoveTo(float x, float y, bool bMoveParticles=false);
// 设定粒子系统的位置偏移量
void Transpose(float x, float y) { fTx=x; fTy=y; }
// 设置粒子系统的缩放比例
void SetScale(float scale) { fScale = scale; }
// 设置是否跟踪粒子系统的边界盒
void TrackBoundingBox(bool bTrack) { bUpdateBoundingBox=bTrack; }
// 获取当前粒子系统中活动的粒子个数
int GetParticlesAlive() const { return nParticlesAlive; }
// 获得粒子系统的生命值
float GetAge() const { return fAge; }
// 获取粒子系统位置
void GetPosition(float *x, float *y) const { *x=vecLocation.x; *y=vecLocation.y; }
// 获取位置偏移量
void GetTransposition(float *x, float *y) const { *x=fTx; *y=fTy; }
// 获取缩放比例
float GetScale() { return fScale; }
// 获取边界盒
hgeRect* GetBoundingBox(hgeRect *rect) const;
private:
// 私有化默认构造函数，达到屏蔽默认构造的作用
hgeParticleSystem();
// HGE静态指针
static HGE *hge;
// 生命值
float fAge;
// 剩余未有发射（生成）的粒子数量
float fEmissionResidue;
// 前一个位置
hgeVector vecPrevLocation;
// 当前位置
hgeVector vecLocation;
// 偏移量
float fTx, fTy;
// 缩放因子
float fScale;
// 活动的粒子个数
int nParticlesAlive;
// 粒子系统的边界盒
hgeRect rectBoundingBox;
// 是否更新边界盒
bool bUpdateBoundingBox;
// hgeParticle数组，用以存储所有的粒子
hgeParticle particles[MAX_PARTICLES];
};
总的来说，hgeParticleSystem封装了一个相对简洁的粒子系统的各项功能，其头文件声明的数据及函数成员并未有十分费解的地方，下面就让我们看一看其的实现源码：
首先自然是他的构造函数：
hgeParticleSystem::hgeParticleSystem(const char *filename, hgeSprite *sprite)
{
void *psi;
// 创建HGE，以获得其提供的底层接口
hge=hgeCreate(HGE_VERSION);
// 使用Resource_Load加载文件
psi=hge->Resource_Load(filename);
if(!psi) return;
// 将文件中的内容拷贝至info（hgeParticleSystemInfo）中
memcpy(&info, psi, sizeof(hgeParticleSystemInfo));
// 释放资源
hge->Resource_Free(psi);
// 设置粒子精灵类
info.sprite=sprite;
// 初始化粒子系统的位置
vecLocation.x=vecPrevLocation.x=0.0f;
vecLocation.y=vecPrevLocation.y=0.0f;
// 初始化粒子系统的偏移位置
fTx=fTy=0;
// 初始化缩放因子，1.0f代表不做缩放
fScale = 1.0f;
// 初始化未发射（生成）粒子数量
fEmissionResidue=0.0f;
// 初始化活动粒子数
nParticlesAlive=0;
// 初始化粒子生命值
fAge=-2.0;
// 初始化边界盒
rectBoundingBox.Clear();
// 默认不更新边界盒
bUpdateBoundingBox=false;
}
各项操作还是相当易解的，剩下的两个构造函数如出一辙，在此不再赘述，只是就其中的复制构造函数，在这里我想说上一说：
源代码中，关于复制构造函数的实现很简单：
hgeParticleSystem::hgeParticleSystem(const hgeParticleSystem &ps)
{
memcpy(this, &ps, sizeof(hgeParticleSystem));
hge=hgeCreate(HGE_VERSION);
}
由于hgeParticleSystem并不涉及资源的管理（关于HGE的资源管理，可以看看这篇），所以结构内容基本可以按照POD数据的方式进行复制，这也是该函数中大胆使用memcpy的一个原因，但是令我比较意外的是，虽然hgeParticleSystem的头文件中声明了重载赋值运算符函数：
/ / 重载赋值运算符
hgeParticleSystem& operator= (const hgeParticleSystem &ps);
但是却没有加以实现，所以当使用时必然引起链接错误，如果这是作者的初衷的话，我想将其变为私有（private）将更为妥当，而且按照C++中公认的编程规范，一旦你定义了复制构造函数，那么你也应该定义赋值构造函数。对于这个类别，我想比较妥当的定义方法也许可以是这个样子：
hgeParticleSystem::hgeParticleSystem(const hgeParticleSystem &ps)
{
memcpy(this, &ps, sizeof(hgeParticleSystem));
hge=hgeCreate(HGE_VERSION);
}
hgeParticleSystem& hgeParticleSystem::operator= (const hgeParticleSystem &ps)
{
if( this == &ps )
return;
memcpy(this, &ps, sizeof(hgeParticleSystem));
}
另外一提的便是fAge这个成员变量，在构造函数中他被设置成了-2.0：
// 初始化粒子生命值
fAge=-2.0;
相信不少朋友对于这个-2.0的由来应该比较奇怪，其实他是一个“魔数”，代表着粒子系统尚未启动（使用FireAt或者Fire来启动粒子系统），不过这种编程技巧我个人是比较不赞同的，我的建议是至少使用枚举之类明显的变量值进行代替，最低限度也可以使用粗糙的宏定义来简单的包装一下，譬如：
#define PARTICLE_SYSTEM_NOT_START (-2.0)
好了，闲话少叙，接着让我们来看看其他的成员函数：
// 移动粒子系统的位置
void hgeParticleSystem::MoveTo(float x, float y, bool bMoveParticles)
{
int i;
float dx,dy;
// 如果移动所有活动粒子的话
if(bMoveParticles)
{
// 计算目标坐标与当前坐标的偏移量
dx=x-vecLocation.x;
dy=y-vecLocation.y;
// 重新设置所有活动粒子的位置
for(i=0;i<nParticlesAlive;i++)
{
particles[i].vecLocation.x += dx;
particles[i].vecLocation.y += dy;
}
// 重新计算先前所在坐标的位置
vecPrevLocation.x=vecPrevLocation.x + dx;
vecPrevLocation.y=vecPrevLocation.y + dy;
}
// 否则仅移动即将发射的粒子
else
{
// 如果粒子系统尚未启动
if(fAge==-2.0) { vecPrevLocation.x=x; vecPrevLocation.y=y; }
else { vecPrevLocation.x=vecLocation.x; vecPrevLocation.y=vecLocation.y; }
}
// 设置当前位置坐标
vecLocation.x=x;
vecLocation.y=y;
}
可以看到，相关的代码并不复杂，值得注意一下的是代码中对于vecPrevLocation的设置 ：）
接着是FireAt、Fire以及对应的Stop：
// 在指定位置启动粒子系统
void hgeParticleSystem::FireAt(float x, float y)
{
// 简单三部曲：首先停止，接着移动，最后启动
Stop();
MoveTo(x,y);
Fire();
}
// 启动粒子系统
void hgeParticleSystem::Fire()
{
// 注意fAge的设置
if(info.fLifetime==-1.0f) fAge=-1.0f;
else fAge=0.0f;
}
// 停止粒子系统
void hgeParticleSystem::Stop(bool bKillParticles)
{
// 注意fAge的设置
fAge=-2.0f;
// 如果需要清除粒子的话
if(bKillParticles)
{
// 重新设置活动粒子数量为0
nParticlesAlive=0;
// 重置粒子系统的边界盒
rectBoundingBox.Clear();
}
}
再者让我们看看如何渲染粒子系统：
// 渲染粒子系统
void hgeParticleSystem::Render()
{
int i;
DWORD col;
hgeParticle *par=particles;
// 获取粒子精灵的颜色
col=info.sprite->GetColor();
// 对于每一个活动的粒子
for(i=0; i<nParticlesAlive; i++)
{
// 设置粒子精灵的颜色
if(info.colColorStart.r < 0)
info.sprite->SetColor(SETA(info.sprite->GetColor(),par->colColor.a*255));
else
info.sprite->SetColor(par->colColor.GetHWColor());
// 渲染粒子精灵，注意各个参数的设置
info.sprite->RenderEx(par->vecLocation.x*fScale+fTx, par->vecLocation.y*fScale+fTy, par->fSpin*par->fAge, par->fSize*fScale);
// 移动到下一活动粒子
par++;
}
// 还原先前的粒子精灵颜色
info.sprite->SetColor(col);
}
边界盒的获取也并不复杂：
hgeRect *hgeParticleSystem::GetBoundingBox(hgeRect *rect) const
{
*rect = rectBoundingBox;
// 根据缩放因子缩放坐标
rect->x1 *= fScale;
rect->y1 *= fScale;
rect->x2 *= fScale;
rect->y2 *= fScale;
return rect;
}
最后，让我们来看一看稍有些复杂的Update函数：
void hgeParticleSystem::Update(float fDeltaTime)
{
int i;
float ang;
hgeParticle *par;
hgeVector vecAccel, vecAccel2;
// 如果粒子系统生命值大于0
if(fAge >= 0)
{
// 累计生命值
fAge += fDeltaTime;
// 如果超过系统生命周期时间，则重新设置为未启动
if(fAge >= info.fLifetime) fAge = -2.0f;
}
// 更新所有活动粒子
// 更新粒子系统边界盒
if(bUpdateBoundingBox) rectBoundingBox.Clear();
par=particles;
// 对于每一个活动粒子
for(i=0; i<nParticlesAlive; i++)
{
// 更新生命值
par->fAge += fDeltaTime;
// 如果达到死亡时间
if(par->fAge >= par->fTerminalAge)
{
// 递减活动粒子数目
nParticlesAlive--;
// 将最后一个活动粒子拷贝至此处
memcpy(par, &particles[nParticlesAlive], sizeof(hgeParticle));
// 递减计数值，以达到下次继续处理该位置粒子的目的
i--;
continue;
}
// 计算粒子的线加速度
vecAccel = par->vecLocation-vecLocation;
vecAccel.Normalize();
vecAccel2 = vecAccel;
vecAccel *= par->fRadialAccel;
// vecAccel2.Rotate(M_PI_2);
// the following is faster
// 计算线加速度方向的切线方向
ang = vecAccel2.x;
vecAccel2.x = -vecAccel2.y;
vecAccel2.y = ang;
// 计算角角速度
vecAccel2 *= par->fTangentialAccel;
// 计算粒子的实际速度
par->vecVelocity += (vecAccel+vecAccel2)*fDeltaTime;
// 考虑到重力的影响
par->vecVelocity.y += par->fGravity*fDeltaTime;
// 计算粒子的位置
par->vecLocation += par->vecVelocity*fDeltaTime;
// 计算粒子的旋转角度
par->fSpin += par->fSpinDelta*fDeltaTime;
// 计算粒子的大小
par->fSize += par->fSizeDelta*fDeltaTime;
// 计算粒子的颜色
par->colColor += par->colColorDelta*fDeltaTime;
// 更新粒子边界盒
if(bUpdateBoundingBox) rectBoundingBox.Encapsulate(par->vecLocation.x, par->vecLocation.y);
// 移动到下一个粒子
par++;
}
// 生成新的粒子
// 如果粒子系统已经启动的话
if(fAge != -2.0f)
{
// 计算需要生成的粒子数
float fParticlesNeeded = info.nEmission*fDeltaTime + fEmissionResidue;
// 强制装换为无符号整数
int nParticlesCreated = (unsigned int)fParticlesNeeded;
// 计算遗留下来未有生成的粒子，等待下一次更新生成
fEmissionResidue=fParticlesNeeded-nParticlesCreated;
par=&particles[nParticlesAlive];
// 对于每一个需要生成的粒子
for(i=0; i<nParticlesCreated; i++)
{
// 如果活动粒子已经超过上界，则不在生成
if(nParticlesAlive>=MAX_PARTICLES) break;
// 设置粒子的各项属性
// 生命值
par->fAge = 0.0f;
par->fTerminalAge = hge->Random_Float(info.fParticleLifeMin, info.fParticleLifeMax);
// 设置粒子的位置
par->vecLocation = vecPrevLocation+(vecLocation-vecPrevLocation)*hge->Random_Float(0.0f, 1.0f);
par->vecLocation.x += hge->Random_Float(-2.0f, 2.0f);
par->vecLocation.y += hge->Random_Float(-2.0f, 2.0f);
// 设置粒子的速度值，注意角度的计算 ang=info.fDirection-M_PI_2+hge->Random_Float(0,info.fSpread)-info.fSpread/2.0f;
if(info.bRelative) ang += (vecPrevLocation-vecLocation).Angle()+M_PI_2;
par->vecVelocity.x = cosf(ang);
par->vecVelocity.y = sinf(ang);
par->vecVelocity *= hge->Random_Float(info.fSpeedMin, info.fSpeedMax);
// 设置粒子的重力、线角速度以及角加速度
par->fGravity = hge->Random_Float(info.fGravityMin, info.fGravityMax);
par->fRadialAccel = hge->Random_Float(info.fRadialAccelMin, info.fRadialAccelMax);
par->fTangentialAccel = hge->Random_Float(info.fTangentialAccelMin, info.fTangentialAccelMax);
// 设置粒子的大小及偏移量
par->fSize = hge->Random_Float(info.fSizeStart, info.fSizeStart+(info.fSizeEnd-info.fSizeStart)*info.fSizeVar);
par->fSizeDelta = (info.fSizeEnd-par->fSize) / par->fTerminalAge;
// 设置粒子的旋转角度及偏移量
par->fSpin = hge->Random_Float(info.fSpinStart, info.fSpinStart+(info.fSpinEnd-info.fSpinStart)*info.fSpinVar);
par->fSpinDelta = (info.fSpinEnd-par->fSpin) / par->fTerminalAge;
// 设置粒子颜色
par->colColor.r = hge->Random_Float(info.colColorStart.r, info.colColorStart.r+(info.colColorEnd.r-info.colColorStart.r)*info.fColorVar);
par->colColor.g = hge->Random_Float(info.colColorStart.g, info.colColorStart.g+(info.colColorEnd.g-info.colColorStart.g)*info.fColorVar);
par->colColor.b = hge->Random_Float(info.colColorStart.b, info.colColorStart.b+(info.colColorEnd.b-info.colColorStart.b)*info.fColorVar);
par->colColor.a = hge->Random_Float(info.colColorStart.a, info.colColorStart.a+(info.colColorEnd.a-info.colColorStart.a)*info.fAlphaVar);
// 设置粒子颜色偏移量
par->colColorDelta.r = (info.colColorEnd.r-par->colColor.r) / par->fTerminalAge;
par->colColorDelta.g = (info.colColorEnd.g-par->colColor.g) / par->fTerminalAge;
par->colColorDelta.b = (info.colColorEnd.b-par->colColor.b) / par->fTerminalAge;
par->colColorDelta.a = (info.colColorEnd.a-par->colColor.a) / par->fTerminalAge;
// 更新粒子系统边界盒
if(bUpdateBoundingBox) rectBoundingBox.Encapsulate(par->vecLocation.x, par->vecLocation.y);
// 递增活动粒子数目
nParticlesAlive++;
// 移动到下一个待生成粒子
par++;
}
}
// 设置先前粒子系统位置
vecPrevLocation=vecLocation;
}
好了，至此，我们完全可以使用hgeParticleSystem来生成不错的粒子特效了，不过在这之前，让我们继续来看一下HGE对于hgeParticleSystem的更进一步封装：hgeParticleManager
类名 ：hgeParticleManager
功能 ：粒子系统管理类
头文件 ：hge/hge181/include/hgeParticle.h
实现文件 ： hge/hge181/src/helpers/hgepmanager.cpp
头文件如下：
class hgeParticleManager
{
public:
// 构造函数&析构函数
hgeParticleManager();
~hgeParticleManager();
// 更新函数
void Update(float dt);
// 渲染函数
void Render();
// 生成粒子系统
hgeParticleSystem* SpawnPS(hgeParticleSystemInfo *psi, float x, float y);
// 粒子系统是否活动
bool IsPSAlive(hgeParticleSystem *ps) const;
// 设置粒子系统偏移
void Transpose(float x, float y);
// 获取粒子系统位移
void GetTransposition(float *dx, float *dy) const {*dx=tX; *dy=tY;}
// 销毁指定的粒子系统
void KillPS(hgeParticleSystem *ps);
// 销毁所有粒子系统
void KillAll();
private:
// 私有化复制构造函数及赋值操作符函数，已达到屏蔽作用
hgeParticleManager(const hgeParticleManager &);
hgeParticleManager& operator= (const hgeParticleManager &);
// 粒子系统数量
int nPS;
// 偏移位置坐标
float tX;
float tY;
// 粒子系统指针数组
hgeParticleSystem* psList[MAX_PSYSTEMS];
};
hgeParticleManager看来还是相对简单的 ：）
首先自然是构造函数和析构函数：
hgeParticleManager::hgeParticleManager()
{
// 设定初始值，使用成员列表更好一些
nPS=0;
tX=tY=0.0f;
}
hgeParticleManager::~hgeParticleManager()
{
// 遍历指针数组依次删除
int i;
for(i=0;i<nPS;i++) delete psList[i];
}
没有什么奇特的地方，那么接着让我们来看一看SpawnPS：
hgeParticleSystem* hgeParticleManager::SpawnPS(hgeParticleSystemInfo *psi, float x, float y)
{
// 如果粒子系统超过上界，则返回
if(nPS==MAX_PSYSTEMS) return 0;
// 生成粒子系统
psList[nPS]=new hgeParticleSystem(psi);
// 启动
psList[nPS]->FireAt(x,y);
// 设置偏移
psList[nPS]->Transpose(tX,tY);
// 递增粒子系统数目
nPS++;
return psList[nPS-1];
}
函数很简单，生成粒子系统而已 ：）
接下来的几个成员函数也并不困难：
bool hgeParticleManager::IsPSAlive(hgeParticleSystem *ps) const
{
// 依次遍历数组查找指定的粒子系统
int i;
for(i=0;i<nPS;i++) if(psList[i]==ps) return true;
return false;
}
void hgeParticleManager::Transpose(float x, float y)
{
// 依次遍历并设置粒子系统偏移
int i;
for(i=0;i<nPS;i++) psList[i]->Transpose(x,y);
// 更新tX和tY
tX=x; tY=y;
}
void hgeParticleManager::KillPS(hgeParticleSystem *ps)
{
int i;
// 依次遍历指针数组
for(i=0;i<nPS;i++)
{
// 如果找到
if(psList[i]==ps)
{
// 删除这个粒子系统
delete psList[i];
// 并将其指向最后一个活动的粒子系统
psList[i]=psList[nPS-1];
// 递减粒子系统数目
nPS--;
return;
}
}
}
void hgeParticleManager::KillAll()
{
// 遍历并删除所有粒子系统
int i;
for(i=0;i<nPS;i++) delete psList[i];
nPS=0;
}
最后，让我们来看一看Update和Render：
void hgeParticleManager::Render()
{
// 依次遍历并渲染每个粒子系统
int i;
for(i=0;i<nPS;i++) psList[i]->Render();
}
Render相当简单，那么Update如何呢：
void hgeParticleManager::Update(float dt)
{
int i;
// 对于每个存在的粒子系统
for(i=0;i<nPS;i++)
{
// 更新该粒子系统
psList[i]->Update(dt);
// 如果该粒子系统尚未启动并且活动粒子数目为0
if(psList[i]->GetAge()==-2.0f && psList[i]->GetParticlesAlive()==0)
{
// 删除这个粒子系统
delete psList[i];
// 将其指向最后一个活动粒子系统
psList[i]=psList[nPS-1];
// 更新粒子系统数目
nPS--;
// 递减计数值，已达到下次循环继续处理该位置粒子系统的目的
i--;
}
}
}
呼，至此，HGE的粒子系统终算泛泛的讲解完毕了，虽然篇幅不短，但也还算简单，平心而论，HGE的粒子系统虽说并不十分复杂，但也提供了非常不错的显示效果和可扩展性，对于我们关于粒子系统的学习还是很有助益的，有兴趣的朋友远可以进一步使用或者扩展，说不定可以搞出令人惊奇的东西（到时务必告知一下，以便观摩学习）！好了好了，我想我废话也够多了，是时候说ByeBye了，那么，下次再见吧 ：）