Объяснение эффекта частиц openGL

Question

Итак, у меня есть этот код, который создает фейерверки с использованием эффекта частиц, но я не понимаю, что происходит в коде. Может ли кто-нибудь объяснить мне это, в частности, функцию инициализации и функцию взрыва. Если бы вы могли аннотировать это примечаниями, это было бы супер.

/* fireworks.c - simulate fireworks with particle systems */

#include <GL/glut.h>
#include <math.h>
#include <stdlib.h>
#include <stdio.h>

#ifdef WIN32
//to correct ASCI deviations in Microsoft VC++ 6.0

#define M_PI (3.1415926535897932384626433832795)

double drand48()
{   return (rand()%10000)/10000.0; }

//end of corrections
#endif


#define MAX_POINTS 5000
int numPoints;
GLfloat curx, cury;
GLfloat x[MAX_POINTS], y[MAX_POINTS];
GLfloat xacc[MAX_POINTS], yacc[MAX_POINTS];
GLfloat red, green, blue;
int step; int length;

void initialize()
{ int j; double temp, temp2;

numPoints = drand48()*(MAX_POINTS-1);
curx = -0.5 + drand48();
cury = 0.0 + drand48();

red = 0.5 + 0.5*drand48();
green = 0.5 + 0.5*drand48();
blue = 0.5 + 0.5*drand48();
glPointSize(1.5); 
step = 0;
length = 700 + 300*drand48();


/* initialize the blast */
for (j=0 ; j<numPoints ; j++ ) {
x[j] = curx;
y[j] = cury;
temp = drand48();
temp2 = drand48()*2.0*M_PI;
xacc[j] = (cos(temp2) * temp)/length;
yacc[j] = (sin(temp2) * temp)/length;
}

}

void draw_blast(void)
{ int i;
double glow = (length - step) / (double)length;
glColor3f(red*glow, green*glow, blue*glow);
glBegin(GL_POINTS);
for (i=0;i<numPoints;i++) {
x[i] += xacc[i];
y[i] += yacc[i];
glVertex2f(x[i], y[i]);
}
glEnd();
glFlush();
glutSwapBuffers();
}

void display(void)
{ int i;
glClear(GL_COLOR_BUFFER_BIT);
if (step < 0.9*length) {
for (i=0; i<numPoints; i++)
yacc[i] -= 0.02 / length; // gravity
draw_blast();
}
step ++;
if (step > length) initialize();
}

void idle(void)
{
glutPostRedisplay();
}

void keyboard(unsigned char key, int x, int y)
{
switch (key) { 
case 27: exit(0); break;
}
}

void reshape (int w, int h)
{
glViewport(0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode(GL_PROJECTION); 
glLoadIdentity();
if (w <= h)
glOrtho(-1.0, 1.0,
-1.0*(GLfloat)h/(GLfloat)w, 1.0*(GLfloat)h/(GLfloat)w,
-1.0, 1.0);
else
glOrtho(-1.0*(GLfloat)w/(GLfloat)h, 1.0*(GLfloat)w/(GLfloat)h,
-1.0, 1.0,
-1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
}

int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize (800, 800);
glutInitWindowPosition(0, 0);
glutCreateWindow ("Fireworks");

glClearColor (0.0, 0.0, 0.0, 0.0);
initialize();

glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutIdleFunc(idle);
glutKeyboardFunc(keyboard);
glutMainLoop();

return 0; 
}

Answer 1

Да, это система частиц. Однако - не особенно эффективный.

Давайте пройдемся по шагам:

GLfloat x[MAX_POINTS], y[MAX_POINTS];
GLfloat xacc[MAX_POINTS], yacc[MAX_POINTS];

x а также y держать позиции частиц. xacc а также yacc держать их скорости.

В initialize:

numPoints = drand48()*(MAX_POINTS-1);

Это устанавливает случайное количество частиц...

curx = -0.5 + drand48();
cury = 0.0 + drand48();
red = 0.5 + 0.5*drand48();
green = 0.5 + 0.5*drand48();
blue = 0.5 + 0.5*drand48();
glPointSize(1.5); 
step = 0;
length = 700 + 300*drand48();

... со случайной центральной точкой, цветом и радиусом (length).

for (j=0 ; j<numPoints ; j++ ) {

Это начинает инициализацию для каждой частицы.

x[j] = curx;
y[j] = cury;

Устанавливает положение частицы в центральное положение.

temp = drand48();
temp2 = drand48()*2.0*M_PI;
xacc[j] = (cos(temp2) * temp)/length;
yacc[j] = (sin(temp2) * temp)/length;

Устанавливает случайное направление частицы (temp2) и случайная скорость на основе радиуса системы (temp / length).

В drawBlast():

double glow = (length - step) / (double)length;
glColor3f(red*glow, green*glow, blue*glow);

Медленно затухает цвет частиц до черного.

x[i] += xacc[i];
y[i] += yacc[i];

Продвигайте частицу по их скорости. Это предполагает постоянную частоту кадров.

glVertex2f(x[i], y[i]);

Нарисуйте частицу как точку.

В display():

yacc[i] -= 0.02 / length; // gravity

Ускорьте каждую частицу вниз. Т.е. симулировать, что частицы падают.