particle.c

   1 #include "particle.h"
   2 #include "shaders/trail.h"
   3
   4 static void particle_spawn( particle_system *sys,
   5                             v3f co, v3f v, f32 lifetime, u32 colour ){
   6    if( sys->alive == sys->max ) return;
   7
   8    particle *p = &sys->array[ sys->alive ++ ];
   9    v3_copy( co, p->co );
  10    v3_copy( v, p->v );
  11    p->life = lifetime;
  12    p->colour = colour;
  13 }
  14
  15 static void particle_spawn_cone( particle_system *sys,
  16                                  v3f co, v3f dir, f32 angle, f32 speed,
  17                                  f32 lifetime, u32 colour ){
  18    if( sys->alive == sys->max ) return;
  19
  20    particle *p = &sys->array[ sys->alive ++ ];
  21
  22    v3f tx, ty;
  23    v3_tangent_basis( dir, tx, ty );
  24
  25    v3f rand;
  26    vg_rand_cone( &vg.rand, rand, angle );
  27    v3_muls(          tx,  rand[0]*speed, p->v );
  28    v3_muladds( p->v, ty,  rand[1]*speed, p->v );
  29    v3_muladds( p->v, dir, rand[2]*speed, p->v );
  30
  31    p->life = lifetime;
  32    p->colour = colour;
  33    v3_copy( co, p->co );
  34 }
  35
  36 static void particle_system_update( particle_system *sys, f32 dt ){
  37    u32 i = 0;
  38 iter: if( i == sys->alive ) return;
  39
  40    particle *p = &sys->array[i];
  41    p->life -= dt;
  42
  43    if( p->life < 0.0f ){
  44       *p = sys->array[ -- sys->alive ];
  45       goto iter;
  46    }
  47
  48    v3_muladds( p->co, p->v, dt, p->co );
  49    p->v[1] += -9.8f * dt;
  50
  51    i ++;
  52    goto iter;
  53 }
  54
  55 static void particle_system_debug( particle_system *sys ){
  56    for( u32 i=0; i<sys->alive; i ++ ){
  57       particle *p = &sys->array[i];
  58       v3f p1;
  59       v3_muladds( p->co, p->v, 0.2f, p1 );
  60       vg_line( p->co, p1, p->colour );
  61    }
  62 }
  63
  64 struct particle_init_args {
  65    particle_system *sys;
  66    u16 indices[];
  67 };
  68
  69 static void async_particle_init( void *payload, u32 size ){
  70    struct particle_init_args *args = payload;
  71    particle_system *sys = args->sys;
  72
  73    glGenVertexArrays( 1, &sys->vao );
  74    glGenBuffers( 1, &sys->vbo );
  75    glGenBuffers( 1, &sys->ebo );
  76    glBindVertexArray( sys->vao );
  77
  78    size_t stride = sizeof(particle_vert);
  79
  80    glBindBuffer( GL_ARRAY_BUFFER, sys->vbo );
  81    glBufferData( GL_ARRAY_BUFFER, sys->max*stride*4, NULL, GL_DYNAMIC_DRAW );
  82    glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, sys->ebo );
  83    glBufferData( GL_ELEMENT_ARRAY_BUFFER,
  84                   sys->max*sizeof(u16)*6, args->indices, GL_STATIC_DRAW );
  85
  86    /* 0: coordinates */
  87    glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, stride, (void*)0 );
  88    glEnableVertexAttribArray( 0 );
  89
  90    /* 3: colour */
  91    glVertexAttribPointer( 1, 4, GL_UNSIGNED_BYTE, GL_TRUE,
  92          stride, (void *)offsetof(particle_vert, colour) );
  93    glEnableVertexAttribArray( 1 );
  94
  95    VG_CHECK_GL_ERR();
  96 }
  97
  98 static void particle_init(void){
  99    shader_particle_register();
 100 }
 101
 102 static void particle_alloc( particle_system *sys, u32 max ){
 103    size_t stride = sizeof(particle_vert);
 104
 105    sys->max = max;
 106    sys->array = vg_linear_alloc( vg_mem.rtmemory, max*sizeof(particle) );
 107    sys->vertices = vg_linear_alloc( vg_mem.rtmemory, max*stride*4 );
 108
 109    vg_async_item *call =
 110       vg_async_alloc( sizeof(particle_system *) + max*sizeof(u16)*6 );
 111    struct particle_init_args *init = call->payload;
 112    init->sys = sys;
 113
 114    for( u32 i=0; i<max; i ++ ){
 115       init->indices[i*6+0] = i*4;
 116       init->indices[i*6+1] = i*4+1;
 117       init->indices[i*6+2] = i*4+2;
 118       init->indices[i*6+3] = i*4;
 119       init->indices[i*6+4] = i*4+2;
 120       init->indices[i*6+5] = i*4+3;
 121    }
 122
 123    vg_async_dispatch( call, async_particle_init );
 124 }
 125
 126 static void particle_system_prerender( particle_system *sys ){
 127    for( u32 i=0; i<sys->alive; i ++ ){
 128       particle *p = &sys->array[i];
 129       particle_vert *vs = &sys->vertices[i*4];
 130
 131       v3f v, right;
 132       v3_copy( p->v, v );
 133
 134       f32 vm = v3_length( p->v );
 135       v3_muls( v, 1.0f/vm, v );
 136       v3_cross( v, (v3f){0,1,0}, right );
 137
 138       f32 l = (sys->scale+sys->velocity_scale*vm),
 139           w = sys->width;
 140
 141       v3f p0, p1;
 142       v3_muladds( p->co, p->v,  l, p0 );
 143       v3_muladds( p->co, p->v, -l, p1 );
 144
 145       v3_muladds( p0, right,  w, vs[0].co );
 146       v3_muladds( p1, right,  w, vs[1].co );
 147       v3_muladds( p1, right, -w, vs[2].co );
 148       v3_muladds( p0, right, -w, vs[3].co );
 149
 150       vs[0].colour = p->colour;
 151       vs[1].colour = p->colour;
 152       vs[2].colour = p->colour;
 153       vs[3].colour = p->colour;
 154    }
 155
 156    glBindVertexArray( sys->vao );
 157
 158    size_t stride = sizeof(particle_vert);
 159    glBindBuffer( GL_ARRAY_BUFFER, sys->vbo );
 160    glBufferSubData( GL_ARRAY_BUFFER, 0, sys->alive*stride*4, sys->vertices );
 161 }
 162
 163 static void particle_system_render( particle_system *sys, camera *cam ){
 164    glDisable( GL_CULL_FACE );
 165    glEnable( GL_DEPTH_TEST );
 166
 167    shader_particle_use();
 168    shader_particle_uPv( cam->mtx.pv );
 169    shader_particle_uPvPrev( cam->mtx_prev.pv );
 170
 171         glBindVertexArray( sys->vao );
 172         glDrawElements( GL_TRIANGLES, sys->alive*6, GL_UNSIGNED_SHORT, NULL );
 173 }