La forma más rápida de crear un efecto de partícula simple

Estoy buscando la forma más rápida de crear un efecto de partículas realmente simple que se enviará como spam en el juego ...

Básicamente, mi juego se ve como un juego vectrex, hecho principalmente de líneas ... Quiero hacer algunas pequeñas explosiones que serán realmente comunes.

¿Hay algo más rápido que simplemente moverse por algunos puntos y renderizar con GL_Point?

Realmente no hay necesidad de almacenar memoria para cada partícula y animar cada partícula por separado. Puede hacerlo procedimentalmente al reconstruir la posición de la partícula durante el dibujo utilizando la ecuación de física clásica. s = ut + 1 / 2.at ^ 2

Un ejemplo simple (sin aceleración constante de partículas):

void drawExplosion(ExplosionParameters& s)
{
  Random rng;
  rng.seed(s.startSeed);
  glBegin(GL_POINTS);
  for (int i = 0; i < s.numParticles; i++)
  {
    vec3 vel = rng.getRandomVector(-1.0f, 1.0f) * s.explosionSpeed;
    float timeBias = rng.getRandom(0, s.particleTimeBias);
    vec3 pos = s.explosionCentre + (vel * (s.timeElapsed + timeBias));
    glPoint3fv(&pos);
  }
  glEnd();
}

Luego, simplemente aumenta s.timeElapsed en cada iteración de su ciclo de actualización.

También es completamente susceptible de implementarse en la GPU, liberando así a su CPU de tener que hacer cualquier trabajo. Una implementación de gpu podría verse así:

void drawExplosion(ExplosionParameters& s)
{
    //bind Vertex Shader If Not Already Bound();
    ...
    // bindVertexBuffer of Zeroes If Not AlreadyBound();
    glVertexPointer(...)
    //uploadShaderUniformsForExplosion(s);
    glUniform3f(...)
    ...
    glDrawArrays(GL_POINTS, 0, s.numParticles);
} 

El sombreador de vértices de la GPU luego reconstruiría la posición de la partícula a través de la ecuación física y los uniformes / constantes pasaron a ella, tal como lo hizo la versión de la CPU.

Para agregar alguna variación, puede usar más explosiones simultáneas con parámetros ligeramente diferentes, animando colores / alfa, eligiendo diferentes posiciones de inicio. etc.

Hice varias pruebas, y la forma MÁS RÁPIDA (no la más rápida de codificar) fue partículas hechas de GL_LINE que conocían su posición y velocidad, y las usé como puntos al renderizar (por lo tanto, cuanto más rápido va la partícula, más "línea" se vuelve, más lento, se convierte en un punto).

El efecto es REALMENTE genial (mira cualquier video de geometry wars para verlo), y REALMENTE rápido también. Expulsar a los quads (especialmente porque los quads me harían necesitar calcular la cantidad doble de vértices)

Además, es mejor que usar un sistema de partículas ya hecho, porque quería un efecto específico y RÁPIDO, los sistemas de partículas generalmente admiten muchas características, con una cantidad proporcional de sobrecarga.

Normalmente creo que harías partículas como quads mapeados con textura. Trátelos básicamente como sprites 2D y desvanezca con el tiempo, destruyéndolos cuando sean invisibles. Mejor aún, reutilice los viejos cuando haga otros nuevos para no estar agotando la memoria de estas cosas.

Si usa alfa premultiplicado en el arte, puede soportar fácilmente luces, fuego, humo y más, además de todo con un solo tipo de operación de mezcla.

Con OpenGL ES 2.0, ES 1.X con una extensión y OpenGL => 2.1, puede usar GL_POINT_SPRITES. GL_POINT_SPRITES son como un quad siempre delante de la cámara.

En fragment shaders, puedes:

• definir tamaños de sprite con gl_PointSize en vertex shader
• use gl_PointCoord (coordenadas uv) en fragment shader

Puedes usar textura con alfa para dibujar sprites de bola ...

Un tutorial para Point Sprites

La mayoría de los sistemas de efectos de partículas que he visto, en lugar de dibujar una gran cantidad de puntos, dibujan una cantidad relativamente menor de texturas de vallas publicitarias donde cada textura se parece un poco a una explosión. A menos que su estilo artístico realmente lo impida, es probable que sea más feliz siguiendo ese camino. Minimizará la cantidad de partículas que necesita para animar y renderizar individualmente, a la vez que le dará un gran efecto visual.

Para una pequeña forma ordenada de manejar el desove / eliminación / actualización de partículas, suponiendo que tenga una matriz simple de partículas - Partículas [MAX_PARTICLES]:

Mantenga un registro de las partículas activas (comenzando con NumActiveParticles = 0)

Siempre se agregan nuevas partículas al final de la matriz:

pNewParticle = &Particles[NumActiveParticles++];

El bit inteligente: al eliminar una partícula 'muerta', cámbiela por la última partícula activa y disminuya NumActiveParticles:

if ( DeadParticle < NumActiveParticles-1 )
{
  Particles[ DeadParticle ] = Particles[ NumActiveParticles-1 ];
}
NumActiveParticles--;

Esto evita cualquier búsqueda de 'partículas no utilizadas' durante el desove, y evita cualquier exploración a través de una matriz de MAX_PARTICLES si no hay ninguna en uso.

Tenga en cuenta que esto solo funciona si el orden de actualización / renderización no es importante (como es el caso de muchos efectos de partículas, que usan una combinación de aditivos), ya que este método de eliminar una partícula reordena la matriz

Supongo que la forma más rápida es encontrar un motor de partículas y usarlo para sus efectos. Aquí hay algunos:

• Tricelpa
• CHISPA - CHISPEAR
• Cenagal