src/particle/particle.cpp

   1 /*
   2  * Copyright (C) Volition, Inc. 1999.  All rights reserved.
   3  *
   4  * All source code herein is the property of Volition, Inc. You may not sell
   5  * or otherwise commercially exploit the source or things you created based on
   6  * the source.
   7  */
   8
   9 /*
  10  * $Logfile: /Freespace2/code/Particle/Particle.cpp $
  11  * $Revision$
  12  * $Date$
  13  * $Author$
  14  *
  15  * Code for particle system
  16  *
  17  * $Log$
  18  * Revision 1.7  2004/09/20 01:31:44  theoddone33
  19  * GCC 3.4 fixes.
  20  *
  21  * Revision 1.6  2003/05/25 02:30:43  taylor
  22  * Freespace 1 support
  23  *
  24  * Revision 1.5  2002/06/17 06:33:10  relnev
  25  * ryan's struct patch for gcc 2.95
  26  *
  27  * Revision 1.4  2002/06/09 04:41:25  relnev
  28  * added copyright header
  29  *
  30  * Revision 1.3  2002/06/09 03:16:04  relnev
  31  * added _splitpath.
  32  *
  33  * removed unneeded asm, old sdl 2d setup.
  34  *
  35  * fixed crash caused by opengl_get_region.
  36  *
  37  * Revision 1.2  2002/05/07 03:16:48  theoddone33
  38  * The Great Newline Fix
  39  *
  40  * Revision 1.1.1.1  2002/05/03 03:28:10  root
  41  * Initial import.
  42  *
  43  *
  44  * 11    7/21/99 8:10p Dave
  45  * First run of supernova effect.
  46  *
  47  * 10    7/15/99 9:20a Andsager
  48  * FS2_DEMO initial checkin
  49  *
  50  * 9     7/07/99 3:11p Dave
  51  * Fix for uninitialized particle system data.
  52  *
  53  * 8     4/22/99 11:06p Dave
  54  * Final pass at beam weapons. Solidified a lot of stuff. All that remains
  55  * now is to tweak and fix bugs as they come up. No new beam weapon
  56  * features.
  57  *
  58  * 7     1/29/99 12:47a Dave
  59  * Put in sounds for beam weapon. A bunch of interface screens (tech
  60  * database stuff).
  61  *
  62  * 6     1/28/99 9:10a Andsager
  63  * Particles increased in width, life, number.  Max particles increased
  64  *
  65  * 5     1/27/99 9:56a Dave
  66  * Temporary checkin of beam weapons for Dan to make cool sounds.
  67  *
  68  * 4     1/24/99 11:37p Dave
  69  * First full rev of beam weapons. Very customizable. Removed some bogus
  70  * Int3()'s in low level net code.
  71  *
  72  * 3     1/21/99 2:06p Dave
  73  * Final checkin for multiplayer testing.
  74  *
  75  * 2     10/07/98 10:53a Dave
  76  * Initial checkin.
  77  *
  78  * 1     10/07/98 10:50a Dave
  79  *
  80  * 28    5/13/98 3:25p John
  81  * Added code to make explosion impacts not get removed by other
  82  * particles.
  83  *
  84  * 27    5/11/98 10:06a John
  85  * Added new particle for Adam
  86  *
  87  * 26    4/30/98 11:31a Andsager
  88  * Added particles to big ship explosions.  Modified particle_emit() to
  89  * take optional range to increase range at which pariticles are created.
  90  *
  91  * 25    4/17/98 1:42p Allender
  92  * fixed NDEBUG build problems
  93  *
  94  * 24    4/17/98 6:58a John
  95  * Made particles not reduce in low mem conditions.
  96  *
  97  * 23    4/15/98 4:21p John
  98  * Made particles drop off with distance smoothly.  Made old particles get
  99  * deleted by new ones.
 100  *
 101  * 22    4/15/98 11:15a Adam
 102  * upped MAX_PARTICLES to 1500 (from 800).  Primary weapon hit sparks were
 103  * not finding slots.
 104  *
 105  * 21    4/12/98 10:24a John
 106  * Made particle drop off distance larger for larger detail levels.
 107  *
 108  * 20    4/09/98 7:58p John
 109  * Cleaned up tmapper code a bit.   Put NDEBUG around some ndebug stuff.
 110  * Took out XPARENT flag settings in all the alpha-blended texture stuff.
 111  *
 112  * 19    4/02/98 11:40a Lawrance
 113  * check for #ifdef DEMO instead of #ifdef DEMO_RELEASE
 114  *
 115  * 18    4/01/98 9:21p John
 116  * Made NDEBUG, optimized build with no warnings or errors.
 117  *
 118  * 17    4/01/98 10:57a Mike
 119  * Reduce array sizes to save memory.
 120  *
 121  * 16    3/31/98 5:18p John
 122  * Removed demo/save/restore.  Made NDEBUG defined compile.  Removed a
 123  * bunch of debug stuff out of player file.  Made model code be able to
 124  * unload models and malloc out only however many models are needed.
 125  *
 126  *
 127  * 15    3/30/98 4:02p John
 128  * Made machines with < 32 MB of RAM use every other frame of certain
 129  * bitmaps.   Put in code to keep track of how much RAM we've malloc'd.
 130  *
 131  * 14    3/26/98 5:26p John
 132  * added new paging code. nonfunctional.
 133  *
 134  * 13    3/22/98 11:02a John
 135  * Made a bunch of the detail levels actually do something
 136  *
 137  * 12    2/13/98 5:01p John
 138  * Made particles behind you not render
 139  *
 140  * 11    2/06/98 7:28p John
 141  * Made debris and particles not get created if > 200 m from eye.   Added
 142  * max_velocity to asteroid's physics info for aiding in throwing out
 143  * collision pairs.
 144  *
 145  * 10    2/05/98 9:21p John
 146  * Some new Direct3D code.   Added code to monitor a ton of stuff in the
 147  * game.
 148  *
 149  * 9     1/29/98 11:48a John
 150  * Added new counter measure rendering as model code.   Made weapons be
 151  * able to have impact explosion.
 152  *
 153  * 8     1/26/98 5:10p John
 154  * Took particle use out of registry.
 155  *
 156  * 7     1/23/98 5:08p John
 157  * Took L out of vertex structure used B (blue) instead.   Took all small
 158  * fireballs out of fireball types and used particles instead.  Fixed some
 159  * debris explosion things.  Restructured fireball code.   Restructured
 160  * some lighting code.   Made dynamic lighting on by default. Made groups
 161  * of lasers only cast one light.  Made fireballs not cast light.
 162  *
 163  * 6     1/13/98 8:09p John
 164  * Removed the old collision system that checked all pairs.   Added code
 165  * to disable collisions and particles.
 166  *
 167  * 5     1/02/98 5:04p John
 168  * Several explosion related changes.  Made fireballs not be used as
 169  * ani's.  Made ship spark system expell particles.  Took away impact
 170  * explosion for weapon hitting ship... this needs to get added to weapon
 171  * info and makes shield hit more obvious.  Only make sparks when hit
 172  * hull, not shields.
 173  *
 174  * 4     12/30/97 6:44p John
 175  * Made g3_Draw_bitmap functions account for aspect of bitmap.
 176  *
 177  * 3     12/26/97 5:42p Adam
 178  *
 179  * 2     12/23/97 3:58p John
 180  * Second rev of particles
 181  *
 182  * 1     12/23/97 8:26a John
 183  *
 184  * $NoKeywords: $
 185  */
 186
 187 #include "pstypes.h"
 188 #include "freespace.h"
 189 #include "linklist.h"
 190 #include "3d.h"
 191 #include "bmpman.h"
 192 #include "particle.h"
 193 #include "osapi.h"
 194 #include "object.h"
 195 #include "timer.h"
 196
 197 typedef struct particle {
 198         // old style data
 199         vector  pos;                                    // position
 200         vector  velocity;                       // velocity
 201         float           age;                                    // How long it's been alive
 202         float           max_life;                       // How much life we had
 203         float           radius;                         // radius
 204         int             type;                                   // type                                                                         // -1 = None
 205         uint            optional_data;          // depends on type
 206         int             nframes;                                // If an ani, how many frames?
 207
 208         // new style data
 209         float           tracer_length;          // if this is set, draw as a rod to simulate a "tracer" effect
 210         short           attached_objnum;        // if this is set, pos is relative to the attached object. velocity is ignored
 211         int             attached_sig;           // to check for dead/nonexistent objects
 212         ubyte           reverse;                                // play any animations in reverse
 213 } particle;
 214
 215 #if defined(FS2_DEMO) || defined(FS1_DEMO)
 216         #define MAX_PARTICLES   500
 217 #else
 218         #define MAX_PARTICLES   2000    //      Reduced from 2000 to 800 by MK on 4/1/98.  Most I ever saw was 400 and the system recovers
 219                                                                                         //      gracefully from running out of slots.
 220                                                                                         // AP: Put it to 1500 on 4/15/98.  Primary hit sparks weren't finding open slots.
 221                                                                                         // Made todo item for John to force oldest smoke particles to give up their slots.
 222 #endif
 223
 224 int Num_particles = 0;
 225 particle Particles[MAX_PARTICLES];
 226 int Next_particle = 0;
 227
 228 int Anim_bitmap_id_fire = -1;
 229 int Anim_num_frames_fire = -1;
 230
 231 int Anim_bitmap_id_smoke = -1;
 232 int Anim_num_frames_smoke = -1;
 233
 234 int Anim_bitmap_id_smoke2 = -1;
 235 int Anim_num_frames_smoke2 = -1;
 236
 237 static int Particles_enabled = 1;
 238
 239 // Reset everything between levels
 240 void particle_init()
 241 {
 242         int i;
 243
 244 //      Particles_enabled = os_config_read_uint( NULL, "UseParticles", 0 );
 245
 246         Num_particles = 0;
 247         Next_particle = 0;
 248
 249         for (i=0; i<MAX_PARTICLES; i++ )        {
 250                 Particles[i].type = -1;
 251         }
 252
 253         if ( Anim_bitmap_id_fire == -1 )        {
 254                 int fps;
 255                 Anim_bitmap_id_fire = bm_load_animation( "particleexp01", &Anim_num_frames_fire, &fps, 1 );
 256         }
 257                 //Anim_bitmap_id = bm_load( "particleglow01" );
 258                 //Anim_num_frames = 1;
 259
 260         if ( Anim_bitmap_id_smoke == -1 )       {
 261                 int fps;
 262                 Anim_bitmap_id_smoke = bm_load_animation( "particlesmoke01", &Anim_num_frames_smoke, &fps, 1 );
 263         }
 264
 265         if ( Anim_bitmap_id_smoke2 == -1 )      {
 266                 int fps;
 267                 Anim_bitmap_id_smoke2 = bm_load_animation( "particlesmoke02", &Anim_num_frames_smoke2, &fps, 1 );
 268         }
 269
 270 }
 271
 272 void particle_page_in()
 273 {
 274         int i;
 275
 276         for (i=0; i<MAX_PARTICLES; i++ )        {
 277                 Particles[i].type = -1;
 278         }
 279
 280         for (i=0; i<Anim_num_frames_fire; i++ ) {
 281                 bm_page_in_texture( Anim_bitmap_id_fire + i );
 282         }
 283
 284         for (i=0; i<Anim_num_frames_smoke; i++ )        {
 285                 bm_page_in_texture( Anim_bitmap_id_smoke + i );
 286         }
 287
 288         for (i=0; i<Anim_num_frames_smoke2; i++ )       {
 289                 bm_page_in_texture( Anim_bitmap_id_smoke2 + i );
 290         }
 291 }
 292
 293 DCF(particles,"Turns particles on/off")
 294 {
 295         if ( Dc_command )       {
 296                 dc_get_arg(ARG_TRUE|ARG_FALSE|ARG_NONE);
 297                 if ( Dc_arg_type & ARG_TRUE )   Particles_enabled = 1;
 298                 else if ( Dc_arg_type & ARG_FALSE ) Particles_enabled = 0;
 299                 else if ( Dc_arg_type & ARG_NONE ) Particles_enabled ^= 1;
 300         }
 301         if ( Dc_help )  dc_printf( "Usage: particles [bool]\nTurns particle system on/off.  If nothing passed, then toggles it.\n" );
 302         if ( Dc_status )        dc_printf( "particles are %s\n", (Particles_enabled?"ON":"OFF") );
 303
 304 //      os_config_write_uint( NULL, "UseParticles", Particles_enabled );
 305 }
 306
 307
 308                 //mprintf(( "%s\n", text ));
 309
 310 int Num_particles_hwm = 0;
 311
 312 #ifndef NDEBUG
 313 int Total_requested = 0;
 314 int Total_killed = 0;
 315 int next_message = -1;
 316 #endif
 317
 318 // Creates a single particle. See the PARTICLE_?? defines for types.
 319 void particle_create( particle_info *pinfo )
 320 {
 321         particle *p;
 322
 323 #ifndef NDEBUG
 324         if ( next_message == -1 )       {
 325                 next_message = timestamp(10000);
 326         }
 327
 328         if ( timestamp_elapsed(next_message)) {
 329                 next_message = timestamp(10000);
 330                 if ( Total_requested > 1 )      {
 331                         nprintf(( "Particles", "Particles: Killed off %d%% of the particles\n", (Total_killed*100/Total_requested) ));
 332                 }
 333                 Total_requested = 0;
 334                 Total_killed = 0;
 335         }
 336 #endif
 337
 338         if ( !Particles_enabled ) return;
 339
 340         #ifndef NDEBUG
 341         Total_requested++;
 342         #endif
 343
 344         int RetryCount = 0;
 345         int FirstParticleFound = Next_particle;
 346 KillAnother:
 347         p = &Particles[Next_particle++];
 348         if ( Next_particle >= MAX_PARTICLES )   {
 349                 Next_particle = 0;
 350         }
 351
 352         if ( p->type > -1 )     {
 353                 // Only remove non-persistent ones
 354                 if ( p->type != PARTICLE_BITMAP_PERSISTENT )    {
 355                         p->type = -1;
 356                         Num_particles--;
 357                         #ifndef NDEBUG
 358                         Total_killed++;
 359                         #endif
 360                 } else {
 361                         RetryCount++;
 362                         // Keep trying to find a non-persistent one until we searched through 1/3 the slots.
 363                         if ( RetryCount < MAX_PARTICLES/3 )     {
 364                                 goto KillAnother;
 365                         }
 366                         // Couldn't find any non-persistent ones to remove, so just remove the
 367                         // first one we would have removed.
 368                         mprintf(( "DELETING A PERSISTENT PARTICLE!!! This is ok if this only happens rarely. Get John if not.\n" ));
 369                         Next_particle = FirstParticleFound;
 370                         p = &Particles[Next_particle++];
 371                         if ( Next_particle >= MAX_PARTICLES )   {
 372                                 Next_particle = 0;
 373                         }
 374                 }
 375         }
 376
 377         // increment counter
 378         Num_particles++;
 379         if (Num_particles > Num_particles_hwm) {
 380                 Num_particles_hwm = Num_particles;
 381
 382                 if ( Num_particles_hwm == MAX_PARTICLES )       {
 383                         mprintf(( "All particle slots filled!\n" ));
 384                 }
 385                 //mprintf(( "Num_particles high water mark = %i\n", Num_particles_hwm));
 386         }
 387
 388         // Init the particle data
 389         p->pos = pinfo->pos;
 390         p->velocity = pinfo->vel;
 391         p->age = 0.0f;
 392         p->max_life = pinfo->lifetime;
 393         p->radius = pinfo->rad;
 394         p->type = pinfo->type;
 395         p->optional_data = pinfo->optional_data;
 396         p->tracer_length = pinfo->tracer_length;
 397         p->attached_objnum = pinfo->attached_objnum;
 398         p->attached_sig = pinfo->attached_sig;
 399         p->reverse = pinfo->reverse;
 400
 401         if ( (p->type == PARTICLE_BITMAP) || (p->type == PARTICLE_BITMAP_PERSISTENT) )  {
 402                 int fps;
 403                 bm_get_info( p->optional_data,NULL, NULL, NULL, &p->nframes, &fps );
 404                 if ( p->nframes > 1 )   {
 405                         // Recalculate max life for ani's
 406                         p->max_life = i2fl(p->nframes) / i2fl(fps);
 407                 }
 408         } else {
 409                 p->nframes = 1;
 410         }
 411 }
 412
 413 void particle_create( vector *pos, vector *vel, float lifetime, float rad, int type, uint optional_data )
 414 {
 415         particle_info pinfo;
 416
 417         // setup old data
 418         pinfo.pos = *pos;
 419         pinfo.vel = *vel;
 420         pinfo.lifetime = lifetime;
 421         pinfo.rad = rad;
 422         pinfo.type = type;
 423         pinfo.optional_data = optional_data;
 424
 425         // setup new data
 426         pinfo.tracer_length = -1.0f;
 427         pinfo.attached_objnum = -1;
 428         pinfo.attached_sig = -1;
 429         pinfo.reverse = 0;
 430
 431         // lower level function
 432         particle_create(&pinfo);
 433 }
 434
 435 MONITOR( NumParticles );
 436
 437 void particle_move_all(float frametime)
 438 {
 439         particle *p;
 440
 441         MONITOR_INC( NumParticles, Num_particles );
 442
 443         if ( !Particles_enabled ) return;
 444
 445         p = Particles;
 446
 447         int i;
 448         for ( i=0; i<MAX_PARTICLES; i++, p++ )  {
 449
 450                 if ( p->type == -1 )    {
 451                         continue;
 452                 }
 453
 454                 // bogus attached objnum
 455                 if(p->attached_objnum >= MAX_OBJECTS){
 456                         p->type = -1;
 457
 458                         // decrement counter
 459                         Num_particles--;
 460
 461                         SDL_assert(Num_particles >= 0);
 462                         continue;
 463                 }
 464
 465                 // if the vector is attached to an object which has become invalid, kill if
 466                 if(p->attached_objnum >= 0){
 467                         // if the signature has changed, kill it
 468                         if(p->attached_sig != Objects[p->attached_objnum].signature){
 469                                 p->type = -1;
 470
 471                                 // decrement counter
 472                                 Num_particles--;
 473
 474                                 SDL_assert(Num_particles >= 0);
 475                                 continue;
 476                         }
 477                 }
 478                 // move as a regular particle
 479                 else {
 480                         // Move the particle
 481                         vm_vec_scale_add2( &p->pos, &p->velocity, frametime );
 482                 }
 483
 484                 p->age += frametime;
 485
 486                 if ( p->age > p->max_life )     {
 487
 488                         // If it's time expired, remove it from the used list and
 489                         // into the free list
 490                         p->type = -1;
 491
 492                         // decrement counter
 493                         Num_particles--;
 494
 495                         SDL_assert(Num_particles >= 0);
 496                 }
 497         }
 498 }
 499
 500 // kill all active particles
 501 void particle_kill_all()
 502 {
 503         int idx;
 504
 505         // kill all active particles
 506         Num_particles = 0;
 507         Next_particle = 0;
 508         Num_particles_hwm = 0;
 509         for(idx=0; idx<MAX_PARTICLES; idx++){
 510                 Particles[idx].type = -1;
 511         }
 512 }
 513
 514 MONITOR( NumParticlesRend );
 515
 516 void particle_render_all()
 517 {
 518         particle *p;
 519         ubyte flags;
 520         float pct_complete;
 521         float alpha;
 522         vertex pos;
 523         vector ts, te, temp;
 524         int rotate = 1;
 525
 526         if ( !Particles_enabled ) return;
 527
 528         MONITOR_INC( NumParticlesRend, Num_particles );
 529
 530         int n = 0;
 531         int nclipped = 0;
 532
 533         p = Particles;
 534
 535         int i;
 536         for ( i=0; i<MAX_PARTICLES; i++, p++ )  {
 537
 538                 if ( p->type == -1 )    {
 539                         continue;
 540                 }
 541
 542                 n++;
 543
 544                 // pct complete for the particle
 545                 pct_complete = p->age / p->max_life;
 546
 547                 // calculate the alpha to draw at
 548                 alpha = 1.0f;
 549
 550                 // if this is a tracer style particle, calculate tracer vectors
 551                 if(p->tracer_length > 0.0f){
 552                         ts = p->pos;
 553                         temp = p->velocity;
 554                         vm_vec_normalize_quick(&temp);
 555                         vm_vec_scale_add(&te, &ts, &temp, p->tracer_length);
 556
 557                         // don't bother rotating
 558                         rotate = 0;
 559                 }
 560                 // if this is an "attached" particle. move it
 561                 else if(p->attached_objnum >= 0){
 562                         // offset the vector, and transform to view coords
 563                         // vm_vec_add(&te, &Objects[p->attached_objnum].pos, &p->pos);
 564                         vm_vec_unrotate(&temp, &p->pos, &Objects[p->attached_objnum].orient);
 565                         vm_vec_add2(&temp, &Objects[p->attached_objnum].pos);
 566
 567                         flags = g3_rotate_vertex(&pos, &temp);
 568                         if(flags){
 569                                 nclipped++;
 570                                 continue;
 571                         }
 572
 573                         // don't bother rotating again
 574                         rotate = 0;
 575                 }
 576
 577                 // rotate the vertex
 578                 if(rotate){
 579                         flags = g3_rotate_vertex( &pos, &p->pos );
 580                         if ( flags )    {
 581                                 nclipped++;
 582                                 continue;
 583                         }
 584                 }
 585
 586                 switch( p->type )       {
 587
 588                         case PARTICLE_DEBUG:                            // A red sphere, no optional data required
 589                                 gr_set_color( 255, 0, 0 );
 590                                 g3_draw_sphere_ez( &p->pos, p->radius );
 591                                 break;
 592
 593                         case PARTICLE_BITMAP:
 594                         case PARTICLE_BITMAP_PERSISTENT:
 595                                 {       // A bitmap, optional data is the bitmap number
 596                                         int framenum = p->optional_data;
 597
 598                                         if ( p->nframes > 1 )   {
 599                                                 int f = fl2i(pct_complete * p->nframes + 0.5);
 600
 601                                                 if ( f < 0 ) f = 0;
 602                                                 else if ( f > p->nframes-1 ) f = p->nframes-1;
 603
 604                                                 framenum += f;
 605                                         }
 606
 607                                         // set the bitmap
 608                                         gr_set_bitmap( framenum, GR_ALPHABLEND_FILTER, GR_BITBLT_MODE_NORMAL, alpha, -1, -1);
 609
 610                                         // if this is a tracer style particle
 611                                         if(p->tracer_length > 0.0f){
 612                                                 g3_draw_laser(&ts, p->radius, &te, p->radius, TMAP_FLAG_TEXTURED|TMAP_FLAG_XPARENT, 25.0f);
 613                                         }
 614                                         // draw as a regular bitmap
 615                                         else {
 616                                                 g3_draw_bitmap(&pos, (p-Particles)%8, p->radius, TMAP_FLAG_TEXTURED );
 617                                         }
 618                                         break;
 619                                 }
 620
 621                         case PARTICLE_FIRE:     {
 622                                         int framenum = fl2i(pct_complete * Anim_num_frames_fire + 0.5);
 623
 624                                         if ( framenum < 0 ) framenum = 0;
 625                                         else if ( framenum > Anim_num_frames_fire-1 ) framenum = Anim_num_frames_fire-1;
 626
 627                                         /*
 628                                         vertex pos;
 629                                         flags = g3_rotate_vertex( &pos, &p->pos );
 630                                         if ( flags )    {
 631                                                 nclipped++;
 632                                                 break;
 633                                         }
 634                                         */
 635
 636                                         // set the bitmap
 637                                         gr_set_bitmap(p->reverse ? Anim_bitmap_id_fire+(Anim_num_frames_fire - framenum - 1) : Anim_bitmap_id_fire+framenum, GR_ALPHABLEND_FILTER, GR_BITBLT_MODE_NORMAL, alpha, -1, -1);
 638
 639                                         // if this is a tracer style particle
 640                                         if(p->tracer_length > 0.0f){
 641                                                 g3_draw_laser(&ts, p->radius, &te, p->radius, TMAP_FLAG_TEXTURED|TMAP_FLAG_XPARENT, 25.0f);
 642                                         }
 643                                         // draw as a regular bitmap
 644                                         else {
 645                                                 g3_draw_bitmap(&pos, (p-Particles)%8, p->radius, TMAP_FLAG_TEXTURED );
 646                                         }
 647                                         break;
 648                                 }
 649
 650                         case PARTICLE_SMOKE:    {
 651                                         int framenum = fl2i(pct_complete * Anim_num_frames_smoke + 0.5);
 652
 653                                         if ( framenum < 0 ) framenum = 0;
 654                                         else if ( framenum > Anim_num_frames_smoke-1 ) framenum = Anim_num_frames_smoke-1;
 655
 656                                         /*
 657                                         vertex pos;
 658                                         flags = g3_rotate_vertex( &pos, &p->pos );
 659                                         if ( flags )    {
 660                                                 nclipped++;
 661                                                 break;
 662                                         }
 663                                         */
 664
 665                                         // set the bitmap
 666                                         gr_set_bitmap(p->reverse ? Anim_bitmap_id_smoke+(Anim_num_frames_smoke - framenum - 1) : Anim_bitmap_id_smoke+framenum, GR_ALPHABLEND_FILTER, GR_BITBLT_MODE_NORMAL, alpha, -1, -1);
 667
 668                                         // if this is a tracer style particle
 669                                         if(p->tracer_length > 0.0f){
 670                                                 g3_draw_laser(&ts, p->radius, &te, p->radius, TMAP_FLAG_TEXTURED|TMAP_FLAG_XPARENT, 25.0f);
 671                                         }
 672                                         // draw as a regular bitmap
 673                                         else {
 674                                                 g3_draw_bitmap(&pos, (p-Particles)%8, p->radius, TMAP_FLAG_TEXTURED );
 675                                         }
 676                                         break;
 677                                 }
 678
 679                         case PARTICLE_SMOKE2:   {
 680                                         int framenum = fl2i(pct_complete * Anim_num_frames_smoke2 + 0.5);
 681
 682                                         if ( framenum < 0 ) framenum = 0;
 683                                         else if ( framenum > Anim_num_frames_smoke2-1 ) framenum = Anim_num_frames_smoke2-1;
 684
 685                                         /*
 686                                         vertex pos;
 687                                         flags = g3_rotate_vertex( &pos, &p->pos );
 688                                         if ( flags )    {
 689                                                 nclipped++;
 690                                                 break;
 691                                         }
 692                                         */
 693
 694                                         // set the bitmap
 695                                         gr_set_bitmap(p->reverse ? Anim_bitmap_id_smoke2+(Anim_num_frames_smoke2 - framenum - 1) : Anim_bitmap_id_smoke2+framenum, GR_ALPHABLEND_FILTER, GR_BITBLT_MODE_NORMAL, alpha, -1, -1);
 696
 697                                         // if this is a tracer style particle
 698                                         if(p->tracer_length > 0.0f){
 699                                                 g3_draw_laser(&ts, p->radius, &te, p->radius, TMAP_FLAG_TEXTURED|TMAP_FLAG_XPARENT, 25.0f);
 700                                         }
 701                                         // draw as a regular bitmap
 702                                         else {
 703                                                 g3_draw_bitmap(&pos, (p-Particles)%8, p->radius, TMAP_FLAG_TEXTURED );
 704                                         }
 705                                         break;
 706                                 }
 707                 }
 708         }
 709 //      mprintf(( "NP=%d, NCP=%d\n", n, nclipped ));
 710 }
 711
 712
 713
 714
 715 //============================================================================
 716 //============== HIGH-LEVEL PARTICLE SYSTEM CREATION CODE ====================
 717 //============================================================================
 718
 719 // Use a structure rather than pass a ton of parameters to particle_emit
 720 /*
 721 typedef struct particle_emitter {
 722         int             num_low;                                // Lowest number of particles to create
 723         int             num_high;                       // Highest number of particles to create
 724         vector  pos;                                    // Where the particles emit from
 725         vector  vel;                                    // Initial velocity of all the particles
 726         float           lifetime;                       // How long the particles live
 727         vector  normal;                         // What normal the particle emit arond
 728         float           normal_variance;        //      How close they stick to that normal 0=good, 1=360 degree
 729         float           min_vel;                                // How fast the slowest particle can move
 730         float           max_vel;                                // How fast the fastest particle can move
 731         float           min_rad;                                // Min radius
 732         float           max_rad;                                // Max radius
 733 } particle_emitter;
 734 */
 735
 736 #if MAX_DETAIL_LEVEL != 4
 737 #error Max details assumed to be 4 here
 738 #endif
 739 int detail_max_num[5] = { 0, 50, 75, 100, 125 };
 740
 741 // Creates a bunch of particles. You pass a structure
 742 // rather than a bunch of parameters.
 743 void particle_emit( particle_emitter *pe, int type, uint optional_data, float range )
 744 {
 745         int i, n;
 746
 747         if ( !Particles_enabled ) return;
 748
 749         int n1, n2;
 750
 751         // Account for detail
 752         #if MAX_DETAIL_LEVEL != 4
 753         #error Code in Particle.cpp assumes MAX_DETAIL_LEVEL == 4
 754         #endif
 755
 756         int percent = detail_max_num[Detail.num_particles];
 757
 758         //Particle rendering drops out too soon.  Seems to be around 150 m.  Is it detail level controllable?  I'd like it to be 500-1000
 759         float min_dist = 125.0f;
 760         float dist = vm_vec_dist_quick( &pe->pos, &Eye_position ) / range;
 761         if ( dist > min_dist )  {
 762                 percent = fl2i( i2fl(percent)*min_dist / dist );
 763                 if ( percent < 1 ) {
 764                         return;
 765                 }
 766         }
 767         //mprintf(( "Dist = %.1f, percent = %d%%\n", dist, percent ));
 768
 769         n1 = (pe->num_low*percent)/100;
 770         n2 = (pe->num_high*percent)/100;
 771
 772         // How many to emit?
 773         n = (myrand() % (n2-n1+1)) + n1;
 774
 775         if ( n < 1 ) return;
 776
 777
 778         for (i=0; i<n; i++ )    {
 779                 // Create a particle
 780                 vector tmp_vel;
 781                 vector normal;                          // What normal the particle emit arond
 782
 783                 float radius = (( pe->max_rad - pe->min_rad ) * frand()) + pe->min_rad;
 784
 785                 float speed = (( pe->max_vel - pe->min_vel ) * frand()) + pe->min_vel;
 786
 787                 float life = (( pe->max_life - pe->min_life ) * frand()) + pe->min_life;
 788
 789                 normal.xyz.x = pe->normal.xyz.x + (frand()*2.0f - 1.0f)*pe->normal_variance;
 790                 normal.xyz.y = pe->normal.xyz.y + (frand()*2.0f - 1.0f)*pe->normal_variance;
 791                 normal.xyz.z = pe->normal.xyz.z + (frand()*2.0f - 1.0f)*pe->normal_variance;
 792                 vm_vec_normalize_safe( &normal );
 793                 vm_vec_scale_add( &tmp_vel, &pe->vel, &normal, speed );
 794
 795                 particle_create( &pe->pos, &tmp_vel, life, radius, type, optional_data );
 796         }
 797 }