OpenGL实现的烟花粒子系统

最近在学习OpenGL，看到一个网友写的烟花系统，非常漂亮，自己也实现一下，作为学习的练习。代码分别在VC和Android上实现，稍后我传上去，大家可以下载交流。



基本原理：

物理上，粒子首先向上做匀减速直线运动，s = v * t，v = a * t；x、z方向速度是0。到最高点之后，360度均匀炸开成24束小粒子，x、z方向做匀速直线运动，vx = r * sin(radian)，vz = r * cos(radian)；y方向做匀加速直线运动。拖尾的实现原理是每个粒子后面跟一串粒子，就像一只鸡妈妈后面领了大小一队鸡娃娃，粒子娃娃的位置依次是粒子妈妈最近N次运动经过的位置（N表示后面跟的粒子娃娃个数），粒子娃娃的大小分别为：size_baby
= size_mother * (1 - (float)n/N)；类似地，粒子娃娃的透明效果：alpha_baby = alpha_mother * (1 - (float)n/N)，很简单，但是实现的尾迹效果不错呢，如果追求更好的效果，可以试试一些递减的非线性函数，比如1 - sin(3.141593f/2*n/N)。



数据结构：

const int MAX_FIRE = 5;       // 最多5个烟花
const int MAX_PARTICLES = 24; // 每个烟花升空散开的小烟花个数
const int MAX_TAIL = 30;      // 烟花尾迹数

typedef struct {
   float r, g, b;      /* color */
   float x, y, z;      /* position  */
   float xs, ys, zs;   /* speed  */
   float xg, yg, zg;   /* gravity  */
   boolean up;         /* up or down */
} Particle;

typedef struct {
   Particle particle[MAX_PARTICLES][MAX_TAIL]; // 烟花系统数组
   float life, fade, rad; // 生命，衰减速度，x-z平面上的运动速度
} Fire;

Fire fire[MAX_FIRE];

初始化：

for(int loop = 0; loop < MAX_FIRE; loop++) {
   resetFire(loop);
}//for loop end
   
void resetFire(int loop) {
   // init position
   float xtemp = rand()%30 - 15.f;
   float ytemp = -1*rand()%5 - 15.f;//8.f;
   float ztemp = -1*rand()%5 - 15.f;//100.f;
   float speed = rand()%5 + 15.f;

   fire[loop].life = 1.5f;//1.0f;
   fire[loop].fade = (float) ((rand()%100)/20000 + 0.002);
   fire[loop].rad  = rand()%3 + 4.0f;

   for (int loop1 = 0; loop1 < MAX_PARTICLES; loop1++) {
      Particle* pat = &fire[loop].particle[loop1][0];
      //初始颜色
      pat->r = 1.0f; pat->g = 1.0f; pat->b = 1.0f;
      //初始位置
      pat->x = xtemp; pat->y = ytemp; pat->z = ztemp;
      //初始速度
      pat->xs = 0.0f; pat->ys = speed; pat->zs = 0.0f;
      //初始加速度
      pat->xg = 0.0f; pat->yg = -5.f; pat->zg = 0.0f;
      pat->up = true;

      //尾部初始化
      for(int loop2 = 1; loop2 < MAX_TAIL; loop2++) {
         pat = &fire[loop].particle[loop1][loop2];
         pat->x = fire[loop].particle[loop1][0].x;
         pat->y = fire[loop].particle[loop1][0].y;
         pat->z = fire[loop].particle[loop1][0].z;
      } //for loop2 end
   }//for loop1 end
}

粒子运动和渲染主逻辑：

int DrawGLScene(GLvoid)	{ // Here's Where We Do All The Drawing
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);		// Clear Screen And Depth Buffer
   glLoadIdentity();		// Reset The ModelView Matrix

   // 背景颜色随最亮的烟花颜色变化
   float rgb_max_value = 0.0f;
   for(int loop = 0; loop < MAX_FIRE; loop++) {
      float rgb_value = fire[loop].particle[0][0].r + fire[loop].particle[0][0].g + fire[loop].particle[0][0].b;
      if (rgb_value > rgb_max_value) {
         rgb_max_value = rgb_value;
         glColor4f(fire[loop].particle[0][0].r, fire[loop].particle[0][0].g, fire[loop].particle[0][0].b, 1.0f);
      }
   }

   // 画背景图
   glBindTexture(GL_TEXTURE_2D, texture[1]);
   glBegin(GL_TRIANGLE_STRIP);  // Build Quad From A Triangle Strip
   float w = 0.05522847498307933984022516322796f, h = 0.04142135623730950488016887242097f;
   // h = tan(45.f/2) * 0.1f; w = 640.f/480.f*h;
   glTexCoord2d(1,1); glVertex3f(w, h, -0.1f); // Top Right
   glTexCoord2d(0,1); glVertex3f(-w, h, -0.1f); // Top Left
   glTexCoord2d(1,0); glVertex3f(w, -h, -0.1f); // Bottom Right
   glTexCoord2d(0,0); glVertex3f(-w, -h, -0.1f); // Bottom Left
   glEnd(); // Done Building Triangle Strip

   // 画粒子，更新粒子位置和生命
   glBindTexture(GL_TEXTURE_2D, texture[0]);
   for(int loop = 0; loop < MAX_FIRE; loop++) {
      int color = rand()%12;
      for (int loop1 = 0; loop1 < MAX_PARTICLES; loop1++) {
         for(int loop2 = 0; loop2 < MAX_TAIL; loop2++) {
            float x = fire[loop].particle[loop1][loop2].x;
            float y = fire[loop].particle[loop1][loop2].y;
            float z = fire[loop].particle[loop1][loop2].z + zoom;
            float dt = 1 - (float)loop2/MAX_TAIL;
            glColor4f(fire[loop].particle[loop1][0].r, 
               fire[loop].particle[loop1][0].g, 
               fire[loop].particle[loop1][0].b, 
               fire[loop].life * dt);

            float size = 0.5f * dt;
            glBegin(GL_TRIANGLE_STRIP);   // Build Quad From A Triangle Strip
            glTexCoord2d(1,1); glVertex3f(x+size,y+size,z); // Top Right
            glTexCoord2d(0,1); glVertex3f(x-size,y+size,z); // Top Left
            glTexCoord2d(1,0); glVertex3f(x+size,y-size,z); // Bottom Right
            glTexCoord2d(0,0); glVertex3f(x-size,y-size,z); // Bottom Left
            glEnd(); // Done Building Triangle Strip
         }

         // update position
         for(int loop2 = MAX_TAIL-1; loop2 > 0; loop2--) {
            fire[loop].particle[loop1][loop2].x = fire[loop].particle[loop1][loop2-1].x;
            fire[loop].particle[loop1][loop2].y = fire[loop].particle[loop1][loop2-1].y;
            fire[loop].particle[loop1][loop2].z = fire[loop].particle[loop1][loop2-1].z;
         } //for loop2 end

         fire[loop].particle[loop1][0].x += fire[loop].particle[loop1][0].xs / (slowdown * 1000);
         fire[loop].particle[loop1][0].y += fire[loop].particle[loop1][0].ys / (slowdown * 1000);
         fire[loop].particle[loop1][0].z += fire[loop].particle[loop1][0].zs / (slowdown * 1000);

         // update y speed
         float yd = fire[loop].particle[loop1][0].yg / (slowdown * 1000);
         fire[loop].particle[loop1][0].ys += yd;
         if (fire[loop].particle[loop1][0].up && fire[loop].particle[loop1][0].ys < -yd) {
            fire[loop].particle[loop1][0].up = false;
            //int color = rand()%12;
            fire[loop].particle[loop1][0].r = colors[color][0];
            fire[loop].particle[loop1][0].g = colors[color][1];
            fire[loop].particle[loop1][0].b = colors[color][2];

            // x-z speed
            double radian = 3.14159*loop1*15.0/180.0;
            fire[loop].particle[loop1][0].xs = (float)(fire[loop].rad*sin(radian));
            fire[loop].particle[loop1][0].zs = (float)(fire[loop].rad*cos(radian));
         }

         if (keys[VK_UP] && fire[loop].particle[loop1][0].yg < 1.5f) {
            fire[loop].particle[loop1][0].yg += 0.01f;
         }

         if (keys[VK_DOWN] && fire[loop].particle[loop1][0].yg > -1.5f) {
            fire[loop].particle[loop1][0].yg -= 0.01f;
         }

         if (keys[VK_LEFT] && fire[loop].particle[loop1][0].xg < 1.5f) {
            fire[loop].particle[loop1][0].yg += 0.01f;
         }

         if (keys[VK_RIGHT] && fire[loop].particle[loop1][0].xg > -1.5f) {
            fire[loop].particle[loop1][0].yg -= 0.01f;
         }
      }

      fire[loop].life -= fire[loop].fade;
      if (fire[loop].life < 0) {
         resetFire(loop);
      }
   }
   
   if (keys[VK_TAB])	{ // Tab Key Causes A Burst
      for (int loop = 0; loop < MAX_FIRE; loop++) {
         resetFire(loop);
      }
   }
   return TRUE;
}

粒子的生命(life)减少到0时，粒子死亡，用alpha值来表示。

效果图：









推荐学习：

1，《OpenGL编程指南》，此书被广大OpenGL学习者称为红宝书，是Khronos小组编写的官方指南，质量和权威性毋庸置疑，但是比较枯燥，大家可以配合NEHE教程学习；

2，NEHE的OpenGL网络教程（http://nehe.gamedev.net/），这个教程由48个例子组成，作者从建立一个开发框架开始，用例子详细讲解OpenGL，非常值得看。

代码下载：

VC平台：http://download.csdn.net/detail/ynnmnm/3894301

Android平台：http://download.csdn.net/detail/ynnmnm/3724974（android平台的代码是在模拟器上调的，由于模拟器很慢，帧数很低，运行的时候要按向上键减小slowdown，以加快速度，如果拿到手机上运行，可以参考一下vc实现设置的初始y方向速度和加速度，修改一下即可。）

update 1——2014.09.10

程序写完之后，很久没有再回来看了。今天看了我传到csdn下载的资源评价，发现有同学反应几个问题：

VC平台：1. 编译不过；2. 运行报错；3. 运行没有爆炸效果。

我仔细检查了一下，发现主要是64位系统支持的问题，已经修复了。这里说一下修复方法：

1. 编译报错，原因可能是在64位系统，有些静态库默认链接64位的。修改库的路径，强制链接32位库就可以了。比如，在我现在的机器配置下，win8.1 64位+vs2013，因为win8.1 sdk自带了32位和64位的glu32.lib，默认加载64位，所以编译会报错error LNK2019: 无法解析的外部符号 _gluPerspective@32。我把这行代码#pragma
comment(lib, "glu32.lib")改为#pragma comment(lib, "C:/Program Files (x86)/Windows Kits/8.1/Lib/winv6.3/um/x86/glu32.lib")就可以了。

2. 运行报错，这个很可能是因为缺少dll库；库文件需要根据32位或64位分别放到相应目录。

我在csdn下载频道放了所有依赖库，但是不是最新的，11年写这篇文章的时候放上去的，但是可以使用。下载链接：http://download.csdn.net/detail/ynnmnm/3759504

lib库推荐放到

..\vs安装目录\VC\lib，比如我的机器上是：D:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\lib 或者

..\Windows Kits\Lib\um\x86 or x64，比如我的机器上是：C:\Program Files (x86)\Windows Kits\8.1\Lib\winv6.3\um\x86

dll

对于32位机器，一律放到C:\Windows\System32目录下

对于64位机器，32位库放到C:\Windows\SysWOW64目录下，比如

glut.dll --> C:\Windows\System32

glu32.dll/glut32.dll/glew32.dll/glew32mx.dll --> C:\Windows\SysWOW64

3. 运行没有爆炸效果。我仔细检查了代码，发现是因为粒子生命是逐帧减少的，有的机器性能比较好，fps很高，以至于粒子还没开始散落，生命就终结了。定帧或者让生命减少跟时间相关就可以了，比如，可以在fireworks::Initialize()方法中加上FPS::Instance()->fixFps(60);，或者在粒子生命减少的地方乘以当帧经过的时间。亲测ok。

现在，我家里和单位机器都是win8.1 64位+vs2013，按照以上方法修改之后，可以编译通过，完美运行，效果跟上文截图一样。

Android平台：主要反映1. 运行不了；2. 运行没效果。

这个很抱歉，11年写这篇文章的时候我还没android手机，当时在模拟器上运行的，效果跟win32平台的效果一模一样。看看project.properties中的target=3就知道很古老了。只能等以后有空了再修改了。