cl_particles.c

   1 /*
   2 Copyright (C) 1996-1997 Id Software, Inc.
   3
   4 This program is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU General Public License
   6 as published by the Free Software Foundation; either version 2
   7 of the License, or (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12
  13 See the GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18
  19 */
  20
  21 #include "quakedef.h"
  22
  23 #define MAX_PARTICLES                   16384   // default max # of particles at one time
  24 #define ABSOLUTE_MIN_PARTICLES  512             // no fewer than this no matter what's on the command line
  25
  26 typedef enum
  27 {
  28         pt_static, pt_grav, pt_blob, pt_blob2, pt_bulletsmoke, pt_smoke, pt_snow, pt_rain, pt_spark, pt_bubble, pt_fade, pt_steam, pt_splash, pt_splashpuff, pt_flame, pt_blood, pt_oneframe, pt_lavasplash, pt_raindropsplash, pt_underwaterspark, pt_explosionsplash
  29 }
  30 ptype_t;
  31
  32 typedef struct particle_s
  33 {
  34         ptype_t         type;
  35         int                     orientation; // typically PARTICLE_BILLBOARD
  36         vec3_t          org;
  37         vec3_t          vel;
  38         int                     tex;
  39         float           die;
  40         float           scalex;
  41         float           scaley;
  42         float           alpha; // 0-255
  43         float           time2; // used for various things (snow fluttering, for example)
  44         float           bounce; // how much bounce-back from a surface the particle hits (0 = no physics, 1 = stop and slide, 2 = keep bouncing forever, 1.5 is typical)
  45         vec3_t          oldorg;
  46         vec3_t          vel2; // used for snow fluttering (base velocity, wind for instance)
  47         float           friction; // how much air friction affects this object (objects with a low mass/size ratio tend to get more air friction)
  48         float           pressure; // if non-zero, apply pressure to other particles
  49         int                     dynlight; // if set the particle will be dynamically lit (if cl_dynamicparticles is on), used for smoke and blood
  50         byte            color[4];
  51 }
  52 particle_t;
  53
  54 static int particlepalette[256] =
  55 {
  56         0x000000,0x0f0f0f,0x1f1f1f,0x2f2f2f,0x3f3f3f,0x4b4b4b,0x5b5b5b,0x6b6b6b,
  57         0x7b7b7b,0x8b8b8b,0x9b9b9b,0xababab,0xbbbbbb,0xcbcbcb,0xdbdbdb,0xebebeb,
  58         0x0f0b07,0x170f0b,0x1f170b,0x271b0f,0x2f2313,0x372b17,0x3f2f17,0x4b371b,
  59         0x533b1b,0x5b431f,0x634b1f,0x6b531f,0x73571f,0x7b5f23,0x836723,0x8f6f23,
  60         0x0b0b0f,0x13131b,0x1b1b27,0x272733,0x2f2f3f,0x37374b,0x3f3f57,0x474767,
  61         0x4f4f73,0x5b5b7f,0x63638b,0x6b6b97,0x7373a3,0x7b7baf,0x8383bb,0x8b8bcb,
  62         0x000000,0x070700,0x0b0b00,0x131300,0x1b1b00,0x232300,0x2b2b07,0x2f2f07,
  63         0x373707,0x3f3f07,0x474707,0x4b4b0b,0x53530b,0x5b5b0b,0x63630b,0x6b6b0f,
  64         0x070000,0x0f0000,0x170000,0x1f0000,0x270000,0x2f0000,0x370000,0x3f0000,
  65         0x470000,0x4f0000,0x570000,0x5f0000,0x670000,0x6f0000,0x770000,0x7f0000,
  66         0x131300,0x1b1b00,0x232300,0x2f2b00,0x372f00,0x433700,0x4b3b07,0x574307,
  67         0x5f4707,0x6b4b0b,0x77530f,0x835713,0x8b5b13,0x975f1b,0xa3631f,0xaf6723,
  68         0x231307,0x2f170b,0x3b1f0f,0x4b2313,0x572b17,0x632f1f,0x733723,0x7f3b2b,
  69         0x8f4333,0x9f4f33,0xaf632f,0xbf772f,0xcf8f2b,0xdfab27,0xefcb1f,0xfff31b,
  70         0x0b0700,0x1b1300,0x2b230f,0x372b13,0x47331b,0x533723,0x633f2b,0x6f4733,
  71         0x7f533f,0x8b5f47,0x9b6b53,0xa77b5f,0xb7876b,0xc3937b,0xd3a38b,0xe3b397,
  72         0xab8ba3,0x9f7f97,0x937387,0x8b677b,0x7f5b6f,0x775363,0x6b4b57,0x5f3f4b,
  73         0x573743,0x4b2f37,0x43272f,0x371f23,0x2b171b,0x231313,0x170b0b,0x0f0707,
  74         0xbb739f,0xaf6b8f,0xa35f83,0x975777,0x8b4f6b,0x7f4b5f,0x734353,0x6b3b4b,
  75         0x5f333f,0x532b37,0x47232b,0x3b1f23,0x2f171b,0x231313,0x170b0b,0x0f0707,
  76         0xdbc3bb,0xcbb3a7,0xbfa39b,0xaf978b,0xa3877b,0x977b6f,0x876f5f,0x7b6353,
  77         0x6b5747,0x5f4b3b,0x533f33,0x433327,0x372b1f,0x271f17,0x1b130f,0x0f0b07,
  78         0x6f837b,0x677b6f,0x5f7367,0x576b5f,0x4f6357,0x475b4f,0x3f5347,0x374b3f,
  79         0x2f4337,0x2b3b2f,0x233327,0x1f2b1f,0x172317,0x0f1b13,0x0b130b,0x070b07,
  80         0xfff31b,0xefdf17,0xdbcb13,0xcbb70f,0xbba70f,0xab970b,0x9b8307,0x8b7307,
  81         0x7b6307,0x6b5300,0x5b4700,0x4b3700,0x3b2b00,0x2b1f00,0x1b0f00,0x0b0700,
  82         0x0000ff,0x0b0bef,0x1313df,0x1b1bcf,0x2323bf,0x2b2baf,0x2f2f9f,0x2f2f8f,
  83         0x2f2f7f,0x2f2f6f,0x2f2f5f,0x2b2b4f,0x23233f,0x1b1b2f,0x13131f,0x0b0b0f,
  84         0x2b0000,0x3b0000,0x4b0700,0x5f0700,0x6f0f00,0x7f1707,0x931f07,0xa3270b,
  85         0xb7330f,0xc34b1b,0xcf632b,0xdb7f3b,0xe3974f,0xe7ab5f,0xefbf77,0xf7d38b,
  86         0xa77b3b,0xb79b37,0xc7c337,0xe7e357,0x7fbfff,0xabe7ff,0xd7ffff,0x670000,
  87         0x8b0000,0xb30000,0xd70000,0xff0000,0xfff393,0xfff7c7,0xffffff,0x9f5b53
  88 };
  89
  90 static int explosparkramp[8] = {0x4b0700, 0x6f0f00, 0x931f07, 0xb7330f, 0xcf632b, 0xe3974f, 0xffe7b5, 0xffffff};
  91 //static int explounderwatersparkramp[8] = {0x00074b, 0x000f6f, 0x071f93, 0x0f33b7, 0x2b63cf, 0x4f97e3, 0xb5e7ff, 0xffffff};
  92
  93 // these must match r_part.c's textures
  94 static const int tex_smoke[8] = {0, 1, 2, 3, 4, 5, 6, 7};
  95 static const int tex_bullethole[8] = {8, 9, 10, 11, 12, 13, 14, 15};
  96 static const int tex_rainsplash[16] = {16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31};
  97 static const int tex_particle = 32;
  98 static const int tex_rain = 33;
  99 static const int tex_bubble = 34;
 100 static const int tex_rocketglow = 35;
 101
 102 static int                      cl_maxparticles;
 103 static int                      cl_numparticles;
 104 static particle_t       *particles;
 105 static particle_t       **freeparticles; // list used only in compacting particles array
 106 static renderparticle_t *cl_renderparticles;
 107
 108 static cvar_t cl_particles = {CVAR_SAVE, "cl_particles", "1"};
 109 static cvar_t cl_particles_size = {CVAR_SAVE, "cl_particles_size", "1"};
 110 static cvar_t cl_particles_bloodshowers = {CVAR_SAVE, "cl_particles_bloodshowers", "1"};
 111 static cvar_t cl_particles_blood = {CVAR_SAVE, "cl_particles_blood", "1"};
 112 static cvar_t cl_particles_smoke = {CVAR_SAVE, "cl_particles_smoke", "1"};
 113 static cvar_t cl_particles_sparks = {CVAR_SAVE, "cl_particles_sparks", "1"};
 114 static cvar_t cl_particles_bubbles = {CVAR_SAVE, "cl_particles_bubbles", "1"};
 115 static cvar_t cl_particles_explosions = {CVAR_SAVE, "cl_particles_explosions", "0"};
 116
 117 static mempool_t *cl_part_mempool;
 118
 119 void CL_Particles_Clear(void)
 120 {
 121         cl_numparticles = 0;
 122 }
 123
 124 /*
 125 ===============
 126 CL_InitParticles
 127 ===============
 128 */
 129 void CL_ReadPointFile_f (void);
 130 void CL_Particles_Init (void)
 131 {
 132         int             i;
 133
 134         i = COM_CheckParm ("-particles");
 135
 136         if (i)
 137         {
 138                 cl_maxparticles = (int)(atoi(com_argv[i+1]));
 139                 if (cl_maxparticles < ABSOLUTE_MIN_PARTICLES)
 140                         cl_maxparticles = ABSOLUTE_MIN_PARTICLES;
 141         }
 142         else
 143                 cl_maxparticles = MAX_PARTICLES;
 144
 145         Cmd_AddCommand ("pointfile", CL_ReadPointFile_f);
 146
 147         Cvar_RegisterVariable (&cl_particles);
 148         Cvar_RegisterVariable (&cl_particles_size);
 149         Cvar_RegisterVariable (&cl_particles_bloodshowers);
 150         Cvar_RegisterVariable (&cl_particles_blood);
 151         Cvar_RegisterVariable (&cl_particles_smoke);
 152         Cvar_RegisterVariable (&cl_particles_sparks);
 153         Cvar_RegisterVariable (&cl_particles_bubbles);
 154         Cvar_RegisterVariable (&cl_particles_explosions);
 155
 156         cl_part_mempool = Mem_AllocPool("CL_Part");
 157         particles = (particle_t *) Mem_Alloc(cl_part_mempool, cl_maxparticles * sizeof(particle_t));
 158         freeparticles = (void *) Mem_Alloc(cl_part_mempool, cl_maxparticles * sizeof(particle_t *));
 159         cl_numparticles = 0;
 160
 161         // FIXME: r_refdef stuff should be allocated somewhere else?
 162         r_refdef.particles = cl_renderparticles = Mem_Alloc(cl_refdef_mempool, cl_maxparticles * sizeof(renderparticle_t));
 163 }
 164
 165 #define particle(ptype, porientation, pcolor, ptex, plight, pscalex, pscaley, palpha, ptime, pbounce, px, py, pz, pvx, pvy, pvz, ptime2, pvx2, pvy2, pvz2, pfriction, ppressure)\
 166 {\
 167         particle_t      *part;\
 168         int tempcolor;\
 169         if (cl_numparticles >= cl_maxparticles)\
 170                 return;\
 171         part = &particles[cl_numparticles++];\
 172         part->type = (ptype);\
 173         tempcolor = (pcolor);\
 174         part->color[0] = ((tempcolor) >> 16) & 0xFF;\
 175         part->color[1] = ((tempcolor) >> 8) & 0xFF;\
 176         part->color[2] = (tempcolor) & 0xFF;\
 177         part->color[3] = 0xFF;\
 178         part->tex = (ptex);\
 179         part->orientation = (porientation);\
 180         part->dynlight = (plight);\
 181         part->scalex = (pscalex);\
 182         part->scaley = (pscaley);\
 183         part->alpha = (palpha);\
 184         part->die = cl.time + (ptime);\
 185         part->bounce = (pbounce);\
 186         part->org[0] = (px);\
 187         part->org[1] = (py);\
 188         part->org[2] = (pz);\
 189         part->vel[0] = (pvx);\
 190         part->vel[1] = (pvy);\
 191         part->vel[2] = (pvz);\
 192         part->time2 = (ptime2);\
 193         part->vel2[0] = (pvx2);\
 194         part->vel2[1] = (pvy2);\
 195         part->vel2[2] = (pvz2);\
 196         part->friction = (pfriction);\
 197         part->pressure = (ppressure);\
 198 }
 199
 200 /*
 201 ===============
 202 CL_EntityParticles
 203 ===============
 204 */
 205 void CL_EntityParticles (entity_t *ent)
 206 {
 207         int                     i;
 208         float           angle;
 209         float           sp, sy, cp, cy;
 210         vec3_t          forward;
 211         float           dist;
 212         float           beamlength;
 213         static vec3_t avelocities[NUMVERTEXNORMALS];
 214         if (!cl_particles.integer) return;
 215
 216         dist = 64;
 217         beamlength = 16;
 218
 219         if (!avelocities[0][0])
 220                 for (i=0 ; i<NUMVERTEXNORMALS*3 ; i++)
 221                         avelocities[0][i] = (rand()&255) * 0.01;
 222
 223         for (i=0 ; i<NUMVERTEXNORMALS ; i++)
 224         {
 225                 angle = cl.time * avelocities[i][0];
 226                 sy = sin(angle);
 227                 cy = cos(angle);
 228                 angle = cl.time * avelocities[i][1];
 229                 sp = sin(angle);
 230                 cp = cos(angle);
 231
 232                 forward[0] = cp*cy;
 233                 forward[1] = cp*sy;
 234                 forward[2] = -sp;
 235
 236                 particle(pt_oneframe, PARTICLE_BILLBOARD, particlepalette[0x6f], tex_particle, false, 2, 2, 255, 9999, 0, ent->render.origin[0] + m_bytenormals[i][0]*dist + forward[0]*beamlength, ent->render.origin[1] + m_bytenormals[i][1]*dist + forward[1]*beamlength, ent->render.origin[2] + m_bytenormals[i][2]*dist + forward[2]*beamlength, 0, 0, 0, 0, 0, 0, 0, 0, 0);
 237         }
 238 }
 239
 240
 241 void CL_ReadPointFile_f (void)
 242 {
 243         vec3_t  org;
 244         int             r, c;
 245         char    *pointfile, *pointfilepos, *t, tchar;
 246
 247         pointfile = COM_LoadFile(va("maps/%s.pts", sv.name), true);
 248         if (!pointfile)
 249         {
 250                 Con_Printf ("couldn't open %s.pts\n", sv.name);
 251                 return;
 252         }
 253
 254         Con_Printf ("Reading %s.pts...\n", sv.name);
 255         c = 0;
 256         pointfilepos = pointfile;
 257         while (*pointfilepos)
 258         {
 259                 while (*pointfilepos == '\n' || *pointfilepos == '\r')
 260                         pointfilepos++;
 261                 if (!*pointfilepos)
 262                         break;
 263                 t = pointfilepos;
 264                 while (*t && *t != '\n' && *t != '\r')
 265                         t++;
 266                 tchar = *t;
 267                 *t = 0;
 268                 r = sscanf (pointfilepos,"%f %f %f", &org[0], &org[1], &org[2]);
 269                 *t = tchar;
 270                 pointfilepos = t;
 271                 if (r != 3)
 272                         break;
 273                 c++;
 274
 275                 if (cl_numparticles >= cl_maxparticles)
 276                 {
 277                         Con_Printf ("Not enough free particles\n");
 278                         break;
 279                 }
 280                 particle(pt_static, PARTICLE_BILLBOARD, particlepalette[(-c)&15], tex_particle, false, 2, 2, 255, 99999, 0, org[0], org[1], org[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
 281         }
 282
 283         Mem_Free(pointfile);
 284         Con_Printf ("%i points read\n", c);
 285 }
 286
 287 /*
 288 ===============
 289 CL_ParseParticleEffect
 290
 291 Parse an effect out of the server message
 292 ===============
 293 */
 294 void CL_ParseParticleEffect (void)
 295 {
 296         vec3_t          org, dir;
 297         int                     i, count, msgcount, color;
 298
 299         for (i=0 ; i<3 ; i++)
 300                 org[i] = MSG_ReadCoord ();
 301         for (i=0 ; i<3 ; i++)
 302                 dir[i] = MSG_ReadChar () * (1.0/16);
 303         msgcount = MSG_ReadByte ();
 304         color = MSG_ReadByte ();
 305
 306         if (msgcount == 255)
 307                 count = 1024;
 308         else
 309                 count = msgcount;
 310
 311         CL_RunParticleEffect (org, dir, color, count);
 312 }
 313
 314 /*
 315 ===============
 316 CL_ParticleExplosion
 317
 318 ===============
 319 */
 320 void CL_ParticleExplosion (vec3_t org, int smoke)
 321 {
 322         int i, j;
 323         float f;
 324         vec3_t v, end, ang;
 325         byte noise1[32*32], noise2[32*32];
 326
 327         VectorClear(end); // hush MSVC
 328         if (cl_particles.integer && cl_particles_explosions.integer)
 329         {
 330                 i = Mod_PointInLeaf(org, cl.worldmodel)->contents;
 331                 if (i == CONTENTS_SLIME || i == CONTENTS_WATER)
 332                 {
 333                         for (i = 0;i < 128;i++)
 334                                 particle(pt_bubble, PARTICLE_BILLBOARD, 0xFFFFFF, tex_bubble, false, 2, 2, 255, 9999, 1.5, org[0] + lhrandom(-16, 16), org[1] + lhrandom(-16, 16), org[2] + lhrandom(-16, 16), lhrandom(-96, 96), lhrandom(-96, 96), lhrandom(-96, 96), 0, 0, 0, 0, 0, 0);
 335
 336                         ang[2] = lhrandom(0, 360);
 337                         fractalnoise(noise1, 32, 4);
 338                         fractalnoise(noise2, 32, 8);
 339                         for (i = 0;i < 32;i++)
 340                         {
 341                                 for (j = 0;j < 32;j++)
 342                                 {
 343                                         VectorRandom(v);
 344                                         VectorMA(org, 16, v, v);
 345                                         TraceLine(org, v, end, NULL, 0);
 346                                         ang[0] = (j + 0.5f) * (360.0f / 32.0f);
 347                                         ang[1] = (i + 0.5f) * (360.0f / 32.0f);
 348                                         AngleVectors(ang, v, NULL, NULL);
 349                                         f = noise1[j*32+i] * 1.5f;
 350                                         VectorScale(v, f, v);
 351                                         particle(pt_underwaterspark, PARTICLE_BILLBOARD, noise2[j*32+i] * 0x010101, tex_smoke[rand()&7], false, 10, 10, lhrandom(128, 255), 9999, 1.5, end[0], end[1], end[2], v[0], v[1], v[2], 512.0f, 0, 0, 0, 2, 0);
 352                                         VectorScale(v, 0.75, v);
 353                                         particle(pt_underwaterspark, PARTICLE_BILLBOARD, explosparkramp[(noise2[j*32+i] >> 5)], tex_particle, false, 10, 10, lhrandom(128, 255), 9999, 1.5, end[0], end[1], end[2], v[0], v[1], v[2], 512.0f, 0, 0, 0, 2, 0);
 354                                 }
 355                         }
 356                 }
 357                 else
 358                 {
 359                         ang[2] = lhrandom(0, 360);
 360                         fractalnoise(noise1, 32, 4);
 361                         fractalnoise(noise2, 32, 8);
 362                         for (i = 0;i < 32;i++)
 363                         {
 364                                 for (j = 0;j < 32;j++)
 365                                 {
 366                                         VectorRandom(v);
 367                                         VectorMA(org, 16, v, v);
 368                                         TraceLine(org, v, end, NULL, 0);
 369                                         ang[0] = (j + 0.5f) * (360.0f / 32.0f);
 370                                         ang[1] = (i + 0.5f) * (360.0f / 32.0f);
 371                                         AngleVectors(ang, v, NULL, NULL);
 372                                         f = noise1[j*32+i] * 1.5f;
 373                                         VectorScale(v, f, v);
 374                                         particle(pt_spark, PARTICLE_BILLBOARD, noise2[j*32+i] * 0x010101, tex_smoke[rand()&7], false, 10, 10, lhrandom(128, 255), 9999, 1.5, end[0], end[1], end[2], v[0], v[1], v[2] + 160.0f, 512.0f, 0, 0, 0, 2, 0);
 375                                         VectorScale(v, 0.75, v);
 376                                         particle(pt_spark, PARTICLE_BILLBOARD, explosparkramp[(noise2[j*32+i] >> 5)], tex_particle, false, 10, 10, lhrandom(128, 255), 9999, 1.5, end[0], end[1], end[2], v[0], v[1], v[2] + 160.0f, 512.0f, 0, 0, 0, 2, 0);
 377                                 //      VectorRandom(v);
 378                                 //      VectorScale(v, 384, v);
 379                                 //      particle(pt_spark, PARTICLE_BILLBOARD, explosparkramp[rand()&7], tex_particle, false, 2, 2, lhrandom(16, 255), 9999, 1.5, end[0], end[1], end[2], v[0], v[1], v[2] + 160.0f, 512.0f, 0, 0, 0, 2, 0);
 380                                 }
 381                         }
 382                 }
 383         }
 384         else
 385                 R_NewExplosion(org);
 386 }
 387
 388 /*
 389 ===============
 390 CL_ParticleExplosion2
 391
 392 ===============
 393 */
 394 void CL_ParticleExplosion2 (vec3_t org, int colorStart, int colorLength)
 395 {
 396         int                     i;
 397         if (!cl_particles.integer) return;
 398
 399         for (i = 0;i < 512;i++)
 400                 particle(pt_fade, PARTICLE_BILLBOARD, particlepalette[colorStart + (i % colorLength)], tex_particle, false, 1.5, 1.5, 255, 0.3, 0, org[0] + lhrandom(-8, 8), org[1] + lhrandom(-8, 8), org[2] + lhrandom(-8, 8), lhrandom(-192, 192), lhrandom(-192, 192), lhrandom(-192, 192), 0, 0, 0, 0, 0.1f, 0);
 401 }
 402
 403 /*
 404 ===============
 405 CL_BlobExplosion
 406
 407 ===============
 408 */
 409 void CL_BlobExplosion (vec3_t org)
 410 {
 411         int                     i;
 412         if (!cl_particles.integer) return;
 413
 414         for (i = 0;i < 256;i++)
 415                 particle(pt_blob , PARTICLE_BILLBOARD, particlepalette[ 66+(rand()%6)], tex_particle, false, 4, 4, 255, 9999, 0, org[0] + lhrandom(-16, 16), org[1] + lhrandom(-16, 16), org[2] + lhrandom(-16, 16), lhrandom(-4, 4), lhrandom(-4, 4), lhrandom(-128, 128), 0, 0, 0, 0, 0, 0);
 416         for (i = 0;i < 256;i++)
 417                 particle(pt_blob2, PARTICLE_BILLBOARD, particlepalette[150+(rand()%6)], tex_particle, false, 4, 4, 255, 9999, 0, org[0] + lhrandom(-16, 16), org[1] + lhrandom(-16, 16), org[2] + lhrandom(-16, 16), lhrandom(-4, 4), lhrandom(-4, 4), lhrandom(-128, 128), 0, 0, 0, 0, 0, 0);
 418 }
 419
 420 /*
 421 ===============
 422 CL_RunParticleEffect
 423
 424 ===============
 425 */
 426 void CL_RunParticleEffect (vec3_t org, vec3_t dir, int color, int count)
 427 {
 428         if (!cl_particles.integer) return;
 429
 430         if (count == 1024)
 431         {
 432                 CL_ParticleExplosion(org, false);
 433                 return;
 434         }
 435         while (count--)
 436                 particle(pt_fade, PARTICLE_BILLBOARD, particlepalette[color + (rand()&7)], tex_particle, false, 1, 1, 128, 9999, 0, org[0] + lhrandom(-8, 8), org[1] + lhrandom(-8, 8), org[2] + lhrandom(-8, 8), lhrandom(-15, 15), lhrandom(-15, 15), lhrandom(-15, 15), 0, 0, 0, 0, 0, 0);
 437 }
 438
 439 // LordHavoc: added this for spawning sparks/dust (which have strong gravity)
 440 /*
 441 ===============
 442 CL_SparkShower
 443 ===============
 444 */
 445 void CL_SparkShower (vec3_t org, vec3_t dir, int count)
 446 {
 447         if (!cl_particles.integer) return;
 448
 449         CL_Decal(org, tex_bullethole[rand()&7], 16 * cl_particles_size.value, 0, 0, 0, 1);
 450
 451         // smoke puff
 452         if (cl_particles_smoke.integer)
 453                 particle(pt_bulletsmoke, PARTICLE_BILLBOARD, 0xA0A0A0, tex_smoke[rand()&7], true, 5, 5, 255, 9999, 0, org[0], org[1], org[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(0, 16), 0, 0, 0, 0, 0, 0);
 454
 455         if (cl_particles_sparks.integer)
 456         {
 457                 // sparks
 458                 while(count--)
 459                         particle(pt_spark, PARTICLE_BILLBOARD, particlepalette[0x68 + (rand() & 7)], tex_particle, false, 1, 1, lhrandom(0, 255), 9999, 1.5, org[0], org[1], org[2], lhrandom(-64, 64), lhrandom(-64, 64), lhrandom(0, 128), 512.0f, 0, 0, 0, 0.2f, 0);
 460         }
 461 }
 462
 463 void CL_BloodPuff (vec3_t org, vec3_t vel, int count)
 464 {
 465         // bloodcount is used to accumulate counts too small to cause a blood particle
 466         static int bloodcount = 0;
 467         if (!cl_particles.integer) return;
 468         if (!cl_particles_blood.integer) return;
 469
 470         if (count > 100)
 471                 count = 100;
 472         bloodcount += count;
 473         while(bloodcount >= 10)
 474         {
 475                 particle(pt_blood, PARTICLE_BILLBOARD, 0x300000, tex_smoke[rand()&7], true, 24, 24, 255, 9999, -1, org[0], org[1], org[2], vel[0] + lhrandom(-64, 64), vel[1] + lhrandom(-64, 64), vel[2] + lhrandom(-64, 64), 0, 0, 0, 0, 1.0f, 0);
 476                 bloodcount -= 10;
 477         }
 478 }
 479
 480 void CL_BloodShower (vec3_t mins, vec3_t maxs, float velspeed, int count)
 481 {
 482         vec3_t diff, center, velscale;
 483         if (!cl_particles.integer) return;
 484         if (!cl_particles_bloodshowers.integer) return;
 485         if (!cl_particles_blood.integer) return;
 486
 487         VectorSubtract(maxs, mins, diff);
 488         center[0] = (mins[0] + maxs[0]) * 0.5;
 489         center[1] = (mins[1] + maxs[1]) * 0.5;
 490         center[2] = (mins[2] + maxs[2]) * 0.5;
 491         // FIXME: change velspeed back to 2.0x after fixing mod
 492         velscale[0] = velspeed * 2.0 / diff[0];
 493         velscale[1] = velspeed * 2.0 / diff[1];
 494         velscale[2] = velspeed * 2.0 / diff[2];
 495
 496         while (count--)
 497         {
 498                 vec3_t org, vel;
 499                 org[0] = lhrandom(mins[0], maxs[0]);
 500                 org[1] = lhrandom(mins[1], maxs[1]);
 501                 org[2] = lhrandom(mins[2], maxs[2]);
 502                 vel[0] = (org[0] - center[0]) * velscale[0];
 503                 vel[1] = (org[1] - center[1]) * velscale[1];
 504                 vel[2] = (org[2] - center[2]) * velscale[2];
 505                 particle(pt_blood, PARTICLE_BILLBOARD, 0x300000, tex_smoke[rand()&7], true, 24, 24, 255, 9999, -1, org[0], org[1], org[2], vel[0], vel[1], vel[2], 0, 0, 0, 0, 1.0f, 0);
 506         }
 507 }
 508
 509 void CL_ParticleCube (vec3_t mins, vec3_t maxs, vec3_t dir, int count, int colorbase, int gravity, int randomvel)
 510 {
 511         float           t;
 512         if (!cl_particles.integer) return;
 513         if (maxs[0] <= mins[0]) {t = mins[0];mins[0] = maxs[0];maxs[0] = t;}
 514         if (maxs[1] <= mins[1]) {t = mins[1];mins[1] = maxs[1];maxs[1] = t;}
 515         if (maxs[2] <= mins[2]) {t = mins[2];mins[2] = maxs[2];maxs[2] = t;}
 516
 517         while (count--)
 518                 particle(gravity ? pt_grav : pt_static, PARTICLE_BILLBOARD, particlepalette[colorbase + (rand()&3)], tex_particle, false, 2, 2, 255, lhrandom(1, 2), 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(mins[2], maxs[2]), dir[0] + lhrandom(-randomvel, randomvel), dir[1] + lhrandom(-randomvel, randomvel), dir[2] + lhrandom(-randomvel, randomvel), 0, 0, 0, 0, 0, 0);
 519 }
 520
 521 void CL_ParticleRain (vec3_t mins, vec3_t maxs, vec3_t dir, int count, int colorbase, int type)
 522 {
 523         vec3_t          vel;
 524         float           t, z;
 525         if (!cl_particles.integer) return;
 526         if (maxs[0] <= mins[0]) {t = mins[0];mins[0] = maxs[0];maxs[0] = t;}
 527         if (maxs[1] <= mins[1]) {t = mins[1];mins[1] = maxs[1];maxs[1] = t;}
 528         if (maxs[2] <= mins[2]) {t = mins[2];mins[2] = maxs[2];maxs[2] = t;}
 529         if (dir[2] < 0) // falling
 530         {
 531                 t = (maxs[2] - mins[2]) / -dir[2];
 532                 z = maxs[2];
 533         }
 534         else // rising??
 535         {
 536                 t = (maxs[2] - mins[2]) / dir[2];
 537                 z = mins[2];
 538         }
 539         if (t < 0 || t > 2) // sanity check
 540                 t = 2;
 541
 542         switch(type)
 543         {
 544         case 0:
 545                 count *= 4; // ick, this should be in the mod or maps?
 546
 547                 while(count--)
 548                 {
 549                         vel[0] = dir[0] + lhrandom(-16, 16);
 550                         vel[1] = dir[1] + lhrandom(-16, 16);
 551                         vel[2] = dir[2] + lhrandom(-32, 32);
 552                         particle(pt_rain, PARTICLE_UPRIGHT_FACING, particlepalette[colorbase + (rand()&3)], tex_particle, true, 1, 64, 64, t, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), z, vel[0], vel[1], vel[2], 0, vel[0], vel[1], vel[2], 0, 0);
 553                 }
 554                 break;
 555         case 1:
 556                 while(count--)
 557                 {
 558                         vel[0] = dir[0] + lhrandom(-16, 16);
 559                         vel[1] = dir[1] + lhrandom(-16, 16);
 560                         vel[2] = dir[2] + lhrandom(-32, 32);
 561                         particle(pt_snow, PARTICLE_BILLBOARD, particlepalette[colorbase + (rand()&3)], tex_particle, false, 2, 2, 255, t, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), z, vel[0], vel[1], vel[2], 0, vel[0], vel[1], vel[2], 0, 0);
 562                 }
 563                 break;
 564         default:
 565                 Host_Error("CL_ParticleRain: unknown type %i (0 = rain, 1 = snow)\n", type);
 566         }
 567 }
 568
 569 void CL_FlameCube (vec3_t mins, vec3_t maxs, int count)
 570 {
 571         float           t;
 572         if (!cl_particles.integer) return;
 573         if (maxs[0] <= mins[0]) {t = mins[0];mins[0] = maxs[0];maxs[0] = t;}
 574         if (maxs[1] <= mins[1]) {t = mins[1];mins[1] = maxs[1];maxs[1] = t;}
 575         if (maxs[2] <= mins[2]) {t = mins[2];mins[2] = maxs[2];maxs[2] = t;}
 576
 577         while (count--)
 578                 particle(pt_flame, PARTICLE_BILLBOARD, particlepalette[224 + (rand()&15)], tex_particle, false, 8, 8, 255, 9999, 1.1, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(mins[2], maxs[2]), lhrandom(-32, 32), lhrandom(-32, 32), lhrandom(-32, 64), 0, 0, 0, 0, 0.1f, 0);
 579 }
 580
 581 void CL_Flames (vec3_t org, vec3_t vel, int count)
 582 {
 583         if (!cl_particles.integer) return;
 584
 585         while (count--)
 586                 particle(pt_flame, PARTICLE_BILLBOARD, particlepalette[224 + (rand()&15)], tex_particle, false, 8, 8, 255, 9999, 1.1, org[0], org[1], org[2], vel[0] + lhrandom(-128, 128), vel[1] + lhrandom(-128, 128), vel[2] + lhrandom(-128, 128), 0, 0, 0, 0, 0.1f, 0);
 587 }
 588
 589
 590
 591 /*
 592 ===============
 593 CL_LavaSplash
 594
 595 ===============
 596 */
 597 void CL_LavaSplash (vec3_t origin)
 598 {
 599         int                     i, j;
 600         float           vel;
 601         vec3_t          dir, org;
 602         if (!cl_particles.integer) return;
 603
 604         for (i=-128 ; i<128 ; i+=16)
 605         {
 606                 for (j=-128 ; j<128 ; j+=16)
 607                 {
 608                         dir[0] = j + lhrandom(0, 8);
 609                         dir[1] = i + lhrandom(0, 8);
 610                         dir[2] = 256;
 611                         org[0] = origin[0] + dir[0];
 612                         org[1] = origin[1] + dir[1];
 613                         org[2] = origin[2] + lhrandom(0, 64);
 614                         vel = lhrandom(50, 120) / VectorLength(dir); // normalize and scale
 615                         particle(pt_lavasplash, PARTICLE_BILLBOARD, particlepalette[224 + (rand()&7)], tex_particle, false, 7, 7, 255, 9999, 0, org[0], org[1], org[2], dir[0] * vel, dir[1] * vel, dir[2] * vel, 0, 0, 0, 0, 0, 0);
 616                 }
 617         }
 618 }
 619
 620 /*
 621 ===============
 622 CL_TeleportSplash
 623
 624 ===============
 625 */
 626 void CL_TeleportSplash (vec3_t org)
 627 {
 628         int                     i, j, k;
 629         if (!cl_particles.integer) return;
 630
 631         for (i=-16 ; i<16 ; i+=8)
 632                 for (j=-16 ; j<16 ; j+=8)
 633                         for (k=-24 ; k<32 ; k+=8)
 634                                 particle(pt_fade, PARTICLE_BILLBOARD, 0xFFFFFF, tex_particle, false, 1, 1, lhrandom(64, 128), 9999, 0, org[0] + i + lhrandom(0, 8), org[1] + j + lhrandom(0, 8), org[2] + k + lhrandom(0, 8), i*2 + lhrandom(-12.5, 12.5), j*2 + lhrandom(-12.5, 12.5), k*2 + lhrandom(27.5, 52.5), 0, 0, 0, 0, 0.1f, -512.0f);
 635 }
 636
 637 void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent)
 638 {
 639         vec3_t          vec, dir, vel;
 640         float           len, dec = 0, speed;
 641         int                     contents, bubbles;
 642         double          t;
 643         if (!cl_particles.integer) return;
 644
 645         VectorSubtract(end, start, dir);
 646         VectorNormalize(dir);
 647
 648         if (type == 0 && host_frametime != 0) // rocket glow
 649                 particle(pt_oneframe, PARTICLE_BILLBOARD, 0xFFFFFF, tex_rocketglow, false, 24, 24, 255, 9999, 0, end[0] - 12 * dir[0], end[1] - 12 * dir[1], end[2] - 12 * dir[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
 650
 651         t = ent->persistent.trail_time;
 652         if (t >= cl.time)
 653                 return; // no particles to spawn this frame (sparse trail)
 654
 655         if (t < cl.oldtime)
 656                 t = cl.oldtime;
 657
 658         VectorSubtract (end, start, vec);
 659         len = VectorNormalizeLength (vec);
 660         if (len <= 0.01f)
 661         {
 662                 // advance the trail time
 663                 ent->persistent.trail_time = cl.time;
 664                 return;
 665         }
 666         speed = len / (cl.time - cl.oldtime);
 667         VectorScale(vec, speed, vel);
 668
 669         // advance into this frame to reach the first puff location
 670         dec = t - cl.oldtime;
 671         dec *= speed;
 672         VectorMA(start, dec, vec, start);
 673
 674         contents = Mod_PointInLeaf(start, cl.worldmodel)->contents;
 675         if (contents == CONTENTS_SKY || contents == CONTENTS_LAVA)
 676         {
 677                 // advance the trail time
 678                 ent->persistent.trail_time = cl.time;
 679                 return;
 680         }
 681
 682         bubbles = (contents == CONTENTS_WATER || contents == CONTENTS_SLIME);
 683
 684         while (t < cl.time)
 685         {
 686                 switch (type)
 687                 {
 688                         case 0: // rocket trail
 689                                 if (!cl_particles_smoke.integer)
 690                                         dec = cl.time - t;
 691                                 else if (bubbles && cl_particles_bubbles.integer)
 692                                 {
 693                                         dec = 0.005f;
 694                                         particle(pt_bubble, PARTICLE_BILLBOARD, 0xFFFFFF, tex_bubble, false, 2, 2, 255, 9999, 1.5, start[0], start[1], start[2], lhrandom(-16, 16), lhrandom(-16, 16), lhrandom(-16, 16), 0, 0, 0, 0, 0, 0);
 695                                         particle(pt_bubble, PARTICLE_BILLBOARD, 0xFFFFFF, tex_bubble, false, 2, 2, 255, 9999, 1.5, start[0], start[1], start[2], lhrandom(-16, 16), lhrandom(-16, 16), lhrandom(-16, 16), 0, 0, 0, 0, 0, 0);
 696                                         particle(pt_smoke, PARTICLE_BILLBOARD, 0xFFFFFF, tex_smoke[rand()&7], false, 2, 2, 160, 9999, 0, start[0], start[1], start[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
 697                                 }
 698                                 else
 699                                 {
 700                                         dec = 0.005f;
 701                                         particle(pt_smoke, PARTICLE_BILLBOARD, 0xC0C0C0, tex_smoke[rand()&7], true, 2, 2, 160, 9999, 0, start[0], start[1], start[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
 702                                         //particle(pt_spark, PARTICLE_BILLBOARD, particlepalette[0x68 + (rand() & 7)], tex_particle, false, 1, 1, lhrandom(128, 255), 9999, 1.5, start[0], start[1], start[2], lhrandom(-64, 64) - vel[0] * 0.0625, lhrandom(-64, 64) - vel[1] * 0.0625, lhrandom(-64, 64) - vel[2] * 0.0625, 512.0f, 0, 0, 0, 0.1f, 0);
 703                                         //particle(pt_spark, PARTICLE_BILLBOARD, particlepalette[0x68 + (rand() & 7)], tex_particle, false, 1, 1, lhrandom(128, 255), 9999, 1.5, start[0], start[1], start[2], lhrandom(-64, 64) - vel[0] * 0.0625, lhrandom(-64, 64) - vel[1] * 0.0625, lhrandom(-64, 64) - vel[2] * 0.0625, 512.0f, 0, 0, 0, 0.1f, 0);
 704                                         //particle(pt_spark, PARTICLE_BILLBOARD, particlepalette[0x68 + (rand() & 7)], tex_particle, false, 1, 1, lhrandom(128, 255), 9999, 1.5, start[0], start[1], start[2], lhrandom(-64, 64) - vel[0] * 0.0625, lhrandom(-64, 64) - vel[1] * 0.0625, lhrandom(-64, 64) - vel[2] * 0.0625, 512.0f, 0, 0, 0, 0.1f, 0);
 705                                         //particle(pt_spark, PARTICLE_BILLBOARD, particlepalette[0x68 + (rand() & 7)], tex_particle, false, 1, 1, lhrandom(128, 255), 9999, 1.5, start[0], start[1], start[2], lhrandom(-64, 64) - vel[0] * 0.0625, lhrandom(-64, 64) - vel[1] * 0.0625, lhrandom(-64, 64) - vel[2] * 0.0625, 512.0f, 0, 0, 0, 0.1f, 0);
 706                                 }
 707                                 break;
 708
 709                         case 1: // grenade trail
 710                                 // FIXME: make it gradually stop smoking
 711                                 if (!cl_particles_smoke.integer)
 712                                         dec = cl.time - t;
 713                                 else if (bubbles && cl_particles_bubbles.integer)
 714                                 {
 715                                         dec = 0.02f;
 716                                         particle(pt_bubble, PARTICLE_BILLBOARD, 0xFFFFFF, tex_bubble, false, 2, 2, 255, 9999, 1.5, start[0], start[1], start[2], lhrandom(-16, 16), lhrandom(-16, 16), lhrandom(-16, 16), 0, 0, 0, 0, 0, 0);
 717                                         particle(pt_bubble, PARTICLE_BILLBOARD, 0xFFFFFF, tex_bubble, false, 2, 2, 255, 9999, 1.5, start[0], start[1], start[2], lhrandom(-16, 16), lhrandom(-16, 16), lhrandom(-16, 16), 0, 0, 0, 0, 0, 0);
 718                                         particle(pt_smoke, PARTICLE_BILLBOARD, 0xFFFFFF, tex_smoke[rand()&7], false, 2, 2, 160, 9999, 0, start[0], start[1], start[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
 719                                 }
 720                                 else
 721                                 {
 722                                         dec = 0.02f;
 723                                         particle(pt_smoke, PARTICLE_BILLBOARD, 0x808080, tex_smoke[rand()&7], true, 2, 2, 160, 9999, 0, start[0], start[1], start[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
 724                                 }
 725                                 break;
 726
 727
 728                         case 2: // blood
 729                                 if (!cl_particles_blood.integer)
 730                                         dec = cl.time - t;
 731                                 else
 732                                 {
 733                                         dec = 0.1f;
 734                                         particle(pt_blood, PARTICLE_BILLBOARD, 0x300000, tex_smoke[rand()&7], true, 24, 24, 255, 9999, -1, start[0], start[1], start[2], vel[0] + lhrandom(-64, 64), vel[1] + lhrandom(-64, 64), vel[2] + lhrandom(-64, 64), 0, 0, 0, 0, 1.0f, 0);
 735                                 }
 736                                 break;
 737
 738                         case 4: // slight blood
 739                                 if (!cl_particles_blood.integer)
 740                                         dec = cl.time - t;
 741                                 else
 742                                 {
 743                                         dec = 0.15f;
 744                                         particle(pt_blood, PARTICLE_BILLBOARD, 0x300000, tex_smoke[rand()&7], true, 24, 24, 255, 9999, -1, start[0], start[1], start[2], vel[0] + lhrandom(-64, 64), vel[1] + lhrandom(-64, 64), vel[2] + lhrandom(-64, 64), 0, 0, 0, 0, 1.0f, 0);
 745                                 }
 746                                 break;
 747
 748                         case 3: // green tracer
 749                                 dec = 0.02f;
 750                                 particle(pt_fade, PARTICLE_BILLBOARD, 0x373707, tex_smoke[rand()&7], false, 4, 4, 255, 9999, 0, start[0], start[1], start[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
 751                                 break;
 752
 753                         case 5: // flame tracer
 754                                 dec = 0.02f;
 755                                 particle(pt_fade, PARTICLE_BILLBOARD, 0xCF632B, tex_smoke[rand()&7], false, 4, 4, 255, 9999, 0, start[0], start[1], start[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
 756                                 break;
 757
 758                         case 6: // voor trail
 759                                 dec = 0.05f; // sparse trail
 760                                 particle(pt_fade, PARTICLE_BILLBOARD, 0x47232B, tex_smoke[rand()&7], false, 4, 4, 255, 9999, 0, start[0], start[1], start[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
 761                                 break;
 762
 763                         case 7: // Nehahra smoke tracer
 764                                 if (!cl_particles_smoke.integer)
 765                                         dec = cl.time - t;
 766                                 else
 767                                 {
 768                                         dec = 0.14f;
 769                                         particle(pt_smoke, PARTICLE_BILLBOARD, 0xC0C0C0, tex_smoke[rand()&7], true, 10, 10, 64, 9999, 0, start[0], start[1], start[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
 770                                 }
 771                                 break;
 772                 }
 773
 774                 // advance to next time and position
 775                 t += dec;
 776                 dec *= speed;
 777                 VectorMA (start, dec, vec, start);
 778         }
 779         ent->persistent.trail_time = t;
 780 }
 781
 782 void CL_RocketTrail2 (vec3_t start, vec3_t end, int color, entity_t *ent)
 783 {
 784         vec3_t          vec;
 785         int                     len;
 786         if (!cl_particles.integer) return;
 787         if (!cl_particles_smoke.integer) return;
 788
 789         VectorSubtract (end, start, vec);
 790         len = (int) (VectorNormalizeLength (vec) * (1.0f / 3.0f));
 791         VectorScale(vec, 3, vec);
 792         color = particlepalette[color];
 793         while (len--)
 794         {
 795                 particle(pt_smoke, PARTICLE_BILLBOARD, color, tex_particle, false, 8, 8, 192, 9999, 0, start[0], start[1], start[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
 796                 VectorAdd (start, vec, start);
 797         }
 798 }
 799
 800
 801 /*
 802 ===============
 803 CL_MoveParticles
 804 ===============
 805 */
 806 void CL_MoveParticles (void)
 807 {
 808         particle_t *p;
 809         renderparticle_t *r;
 810         int i, activeparticles, maxparticle, j, a, b, pressureused = false;
 811         float gravity, dvel, frametime, f, dist, normal[3], v[3], org[3], o[3];
 812
 813         // LordHavoc: early out condition
 814         if (!cl_numparticles)
 815         {
 816                 r_refdef.numparticles = 0;
 817                 return;
 818         }
 819
 820         frametime = cl.time - cl.oldtime;
 821         if (!frametime)
 822                 return; // if absolutely still, don't update particles
 823         gravity = frametime * sv_gravity.value;
 824         dvel = 1+4*frametime;
 825
 826         activeparticles = 0;
 827         maxparticle = -1;
 828         j = 0;
 829         for (i = 0, p = particles, r = r_refdef.particles;i < cl_numparticles;i++, p++)
 830         {
 831                 if (p->die < cl.time)
 832                 {
 833                         freeparticles[j++] = p;
 834                         continue;
 835                 }
 836
 837                 VectorCopy(p->org, p->oldorg);
 838                 VectorMA(p->org, frametime, p->vel, p->org);
 839                 if (p->friction)
 840                 {
 841                         f = 1.0f - (p->friction * frametime);
 842                         VectorScale(p->vel, f, p->vel);
 843                 }
 844                 VectorCopy(p->org, org);
 845                 if (p->bounce)
 846                 {
 847                         if (TraceLine(p->oldorg, p->org, v, normal, 0) < 1)
 848                         {
 849                                 VectorCopy(v, p->org);
 850                                 if (p->bounce < 0)
 851                                 {
 852                                         CL_Decal(v, p->tex, p->scalex * cl_particles_size.value, p->color[0] * (1.0f / 255.0f), p->color[1] * (1.0f / 255.0f), p->color[2] * (1.0f / 255.0f), p->alpha * (1.0f / 255.0f));
 853                                         p->die = -1;
 854                                         freeparticles[j++] = p;
 855                                         continue;
 856                                 }
 857                                 else
 858                                 {
 859                                         dist = DotProduct(p->vel, normal) * -p->bounce;
 860                                         VectorMA(p->vel, dist, normal, p->vel);
 861                                         if (DotProduct(p->vel, p->vel) < 0.03)
 862                                                 VectorClear(p->vel);
 863                                 }
 864                         }
 865                 }
 866
 867                 switch (p->type)
 868                 {
 869                 case pt_static:
 870                         break;
 871
 872                         // LordHavoc: drop-through because of shared code
 873                 case pt_blob:
 874                         p->vel[2] *= dvel;
 875                 case pt_blob2:
 876                         p->vel[0] *= dvel;
 877                         p->vel[1] *= dvel;
 878                         p->alpha -= frametime * 256;
 879                         if (p->alpha < 1)
 880                                 p->die = -1;
 881                         break;
 882
 883                 case pt_grav:
 884                         p->vel[2] -= gravity;
 885                         break;
 886                 case pt_lavasplash:
 887                         p->vel[2] -= gravity * 0.05;
 888                         p->alpha -= frametime * 192;
 889                         if (p->alpha < 1)
 890                                 p->die = -1;
 891                         break;
 892                 case pt_snow:
 893                         if (cl.time > p->time2)
 894                         {
 895                                 p->time2 = cl.time + (rand() & 3) * 0.1;
 896                                 p->vel[0] = (rand()&63)-32 + p->vel2[0];
 897                                 p->vel[1] = (rand()&63)-32 + p->vel2[1];
 898                                 p->vel[2] = (rand()&63)-32 + p->vel2[2];
 899                         }
 900                         a = Mod_PointInLeaf(p->org, cl.worldmodel)->contents;
 901                         if (a != CONTENTS_EMPTY && a != CONTENTS_SKY)
 902                         {
 903                                 p->die = -1;
 904                                 /*
 905                                 if (a == CONTENTS_SOLID && Mod_PointInLeaf(p->oldorg, cl.worldmodel)->contents == CONTENTS_SOLID)
 906                                         break; // still in solid
 907                                 p->die = cl.time + 1000;
 908                                 p->vel[0] = p->vel[1] = p->vel[2] = 0;
 909                                 switch (a)
 910                                 {
 911                                 case CONTENTS_LAVA:
 912                                 case CONTENTS_SLIME:
 913                                         p->tex = tex_smoke[rand()&7];
 914                                         p->orientation = PARTICLE_BILLBOARD;
 915                                         p->type = pt_steam;
 916                                         p->alpha = 96;
 917                                         p->scalex = 5;
 918                                         p->scaley = 5;
 919                                         p->vel[2] = 96;
 920                                         break;
 921                                 case CONTENTS_WATER:
 922                                         p->tex = tex_smoke[rand()&7];
 923                                         p->orientation = PARTICLE_BILLBOARD;
 924                                         p->type = pt_splash;
 925                                         p->alpha = 96;
 926                                         p->scalex = 5;
 927                                         p->scaley = 5;
 928                                         p->vel[2] = 96;
 929                                         break;
 930                                 default: // CONTENTS_SOLID and any others
 931                                         TraceLine(p->oldorg, p->org, v, normal, 0);
 932                                         VectorCopy(v, p->org);
 933                                         p->tex = tex_smoke[rand()&7];
 934                                         p->orientation = PARTICLE_BILLBOARD;
 935                                         p->type = pt_fade;
 936                                         p->scalex = 5;
 937                                         p->scaley = 5;
 938                                         VectorClear(p->vel);
 939                                         break;
 940                                 }
 941                                 */
 942                         }
 943                         break;
 944                 case pt_blood:
 945                         p->friction = 1;
 946                         a = Mod_PointInLeaf(p->org, cl.worldmodel)->contents;
 947                         if (a != CONTENTS_EMPTY)
 948                         {
 949                                 if (a == CONTENTS_WATER || a == CONTENTS_SLIME)
 950                                 {
 951                                         p->friction = 5;
 952                                         p->scalex += frametime * 32.0f;
 953                                         p->scaley += frametime * 32.0f;
 954                                         p->alpha -= frametime * 128.0f;
 955                                         p->vel[2] += gravity * 0.125f;
 956                                         if (p->alpha < 1)
 957                                                 p->die = -1;
 958                                         break;
 959                                 }
 960                                 else
 961                                 {
 962                                         p->die = -1;
 963                                         break;
 964                                 }
 965                         }
 966                         p->vel[2] -= gravity * 0.5;
 967                         break;
 968                 case pt_spark:
 969                         p->alpha -= frametime * p->time2;
 970                         p->vel[2] -= gravity;
 971                         if (p->alpha < 1)
 972                                 p->die = -1;
 973                         else if (Mod_PointInLeaf(p->org, cl.worldmodel)->contents != CONTENTS_EMPTY)
 974                                 p->type = pt_underwaterspark;
 975                         break;
 976                 case pt_underwaterspark:
 977                         if (Mod_PointInLeaf(p->org, cl.worldmodel)->contents == CONTENTS_EMPTY)
 978                         {
 979                                 p->tex = tex_smoke[rand()&7];
 980                                 p->orientation = PARTICLE_BILLBOARD;
 981                                 p->color[0] = p->color[1] = p->color[2] = 255;
 982                                 p->scalex = 8;
 983                                 p->scaley = 8;
 984                                 p->type = pt_explosionsplash;
 985                         }
 986                         else
 987                                 p->vel[2] += gravity * 0.5f;
 988                         p->alpha -= frametime * p->time2;
 989                         if (p->alpha < 1)
 990                                 p->die = -1;
 991                         break;
 992                 case pt_explosionsplash:
 993                         if (Mod_PointInLeaf(p->org, cl.worldmodel)->contents == CONTENTS_EMPTY)
 994                                 p->vel[2] -= gravity;
 995                         else
 996                                 p->alpha = 0;
 997                         p->scalex += frametime * 64.0f;
 998                         p->scaley += frametime * 64.0f;
 999                         p->alpha -= frametime * 1024.0f;
1000                         if (p->alpha < 1)
1001                                 p->die = -1;
1002                         break;
1003                 case pt_fade:
1004                         p->alpha -= frametime * 512;
1005                         if (p->alpha < 1)
1006                                 p->die = -1;
1007                         break;
1008                 case pt_bubble:
1009                         a = Mod_PointInLeaf(p->org, cl.worldmodel)->contents;
1010                         if (a != CONTENTS_WATER && a != CONTENTS_SLIME)
1011                         {
1012                                 p->tex = tex_smoke[rand()&7];
1013                                 p->orientation = PARTICLE_BILLBOARD;
1014                                 p->type = pt_splashpuff;
1015                                 p->scalex = 4;
1016                                 p->scaley = 4;
1017                                 p->vel[0] = p->vel[1] = p->vel[2] = 0;
1018                                 break;
1019                         }
1020                         p->vel[2] += gravity * 0.25;
1021                         p->vel[0] *= (1 - (frametime * 0.0625));
1022                         p->vel[1] *= (1 - (frametime * 0.0625));
1023                         p->vel[2] *= (1 - (frametime * 0.0625));
1024                         if (cl.time > p->time2)
1025                         {
1026                                 p->time2 = cl.time + lhrandom(0, 0.5);
1027                                 p->vel[0] += lhrandom(-32,32);
1028                                 p->vel[1] += lhrandom(-32,32);
1029                                 p->vel[2] += lhrandom(-32,32);
1030                         }
1031                         p->alpha -= frametime * 256;
1032                         if (p->alpha < 1)
1033                                 p->die = -1;
1034                         break;
1035                 case pt_bulletsmoke:
1036                         p->scalex += frametime * 16;
1037                         p->scaley += frametime * 16;
1038                         p->alpha -= frametime * 1024;
1039                         p->vel[2] += gravity * 0.1;
1040                         if (p->alpha < 1)
1041                                 p->die = -1;
1042                         break;
1043                 case pt_smoke:
1044                         p->scalex += frametime * 24;
1045                         p->scaley += frametime * 24;
1046                         p->alpha -= frametime * 256;
1047                         p->vel[2] += gravity * 0.1;
1048                         if (p->alpha < 1)
1049                                 p->die = -1;
1050                         break;
1051                 case pt_steam:
1052                         p->scalex += frametime * 48;
1053                         p->scaley += frametime * 48;
1054                         p->alpha -= frametime * 512;
1055                         p->vel[2] += gravity * 0.05;
1056                         if (p->alpha < 1)
1057                                 p->die = -1;
1058                         break;
1059                 case pt_splashpuff:
1060                         p->alpha -= frametime * 1024;
1061                         if (p->alpha < 1)
1062                                 p->die = -1;
1063                         break;
1064                 case pt_rain:
1065                         f = 0;
1066                         b = Mod_PointInLeaf(p->oldorg, cl.worldmodel)->contents;
1067                         VectorCopy(p->oldorg, o);
1068                         while (f < 1)
1069                         {
1070                                 a = b;
1071                                 f = TraceLine(o, p->org, v, normal, a);
1072                                 b = traceline_endcontents;
1073                                 if (f < 1 && b != CONTENTS_EMPTY && b != CONTENTS_SKY)
1074                                 {
1075                                         p->die = -1;
1076                                         /*
1077                                         p->die = cl.time + 1000;
1078                                         p->vel[0] = p->vel[1] = p->vel[2] = 0;
1079                                         VectorCopy(v, p->org);
1080                                         switch (b)
1081                                         {
1082                                         case CONTENTS_LAVA:
1083                                         case CONTENTS_SLIME:
1084                                                 p->tex = tex_smoke[rand()&7];
1085                                                 p->orientation = PARTICLE_BILLBOARD;
1086                                                 p->type = pt_steam;
1087                                                 p->scalex = 3;
1088                                                 p->scaley = 3;
1089                                                 p->vel[2] = 96;
1090                                                 break;
1091                                         default: // water, solid, and anything else
1092                                                 p->tex = tex_rainsplash[0];
1093                                                 p->orientation = PARTICLE_ORIENTED_DOUBLESIDED;
1094                                                 p->time2 = 0;
1095                                                 VectorCopy(normal, p->vel2);
1096                                         //      VectorAdd(p->org, normal, p->org);
1097                                                 p->type = pt_raindropsplash;
1098                                                 p->scalex = 8;
1099                                                 p->scaley = 8;
1100                                                 break;
1101                                         }
1102                                         */
1103                                 }
1104                         }
1105                         break;
1106                         /*
1107                 case pt_raindropsplash:
1108                         p->time2 += frametime * 64.0f;
1109                         if (p->time2 >= 16.0f)
1110                         {
1111                                 p->die = -1;
1112                                 break;
1113                         }
1114                         p->tex = tex_rainsplash[(int) p->time2];
1115                         p->orientation = PARTICLE_ORIENTED_DOUBLESIDED;
1116                         break;
1117                         */
1118                 case pt_flame:
1119                         p->alpha -= frametime * 512;
1120                         p->vel[2] += gravity;
1121                         if (p->alpha < 16)
1122                                 p->die = -1;
1123                         break;
1124                 case pt_oneframe:
1125                         if (p->time2)
1126                                 p->die = -1;
1127                         p->time2 = 1;
1128                         break;
1129                 default:
1130                         printf("unknown particle type %i\n", p->type);
1131                         p->die = -1;
1132                         break;
1133                 }
1134
1135                 // LordHavoc: immediate removal of unnecessary particles (must be done to ensure compactor below operates properly in all cases)
1136                 if (p->die < cl.time)
1137                         freeparticles[j++] = p;
1138                 else
1139                 {
1140                         maxparticle = i;
1141                         activeparticles++;
1142                         if (p->pressure)
1143                                 pressureused = true;
1144
1145                         // build renderparticle for renderer to use
1146                         r->orientation = p->orientation;
1147                         r->dir[0] = p->vel2[0];
1148                         r->dir[1] = p->vel2[1];
1149                         r->dir[2] = p->vel2[2];
1150                         r->org[0] = p->org[0];
1151                         r->org[1] = p->org[1];
1152                         r->org[2] = p->org[2];
1153                         r->tex = p->tex;
1154                         r->scalex = p->scalex * 0.5f * cl_particles_size.value;
1155                         r->scaley = p->scaley * 0.5f * cl_particles_size.value;
1156                         r->dynlight = p->dynlight;
1157                         r->color[0] = p->color[0] * (1.0f / 255.0f);
1158                         r->color[1] = p->color[1] * (1.0f / 255.0f);
1159                         r->color[2] = p->color[2] * (1.0f / 255.0f);
1160                         r->color[3] = p->alpha * (1.0f / 255.0f);
1161                         r++;
1162                 }
1163         }
1164         r_refdef.numparticles = r - r_refdef.particles;
1165         // fill in gaps to compact the array
1166         i = 0;
1167         while (maxparticle >= activeparticles)
1168         {
1169                 *freeparticles[i++] = particles[maxparticle--];
1170                 while (maxparticle >= activeparticles && particles[maxparticle].die < cl.time)
1171                         maxparticle--;
1172         }
1173         cl_numparticles = activeparticles;
1174
1175         if (pressureused)
1176         {
1177                 activeparticles = 0;
1178                 for (i = 0, p = particles;i < cl_numparticles;i++, p++)
1179                         if (p->pressure)
1180                                 freeparticles[activeparticles++] = p;
1181
1182                 if (activeparticles)
1183                 {
1184                         for (i = 0, p = particles;i < cl_numparticles;i++, p++)
1185                         {
1186                                 for (j = 0;j < activeparticles;j++)
1187                                 {
1188                                         if (freeparticles[j] != p)
1189                                         {
1190                                                 float dist, diff[3];
1191                                                 VectorSubtract(p->org, freeparticles[j]->org, diff);
1192                                                 dist = DotProduct(diff, diff);
1193                                                 if (dist < 4096 && dist >= 1)
1194                                                 {
1195                                                         dist = freeparticles[j]->scalex * 4.0f * frametime / sqrt(dist);
1196                                                         VectorMA(p->vel, dist, diff, p->vel);
1197                                                         //dist = freeparticles[j]->scalex * 4.0f * frametime / dist;
1198                                                         //VectorMA(p->vel, dist, freeparticles[j]->vel, p->vel);
1199                                                 }
1200                                         }
1201                                 }
1202                         }
1203                 }
1204         }
1205 }