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 #ifdef WORKINGLQUAKE
  24 #define lhrandom(MIN,MAX) ((rand() & 32767) * (((MAX)-(MIN)) * (1.0f / 32767.0f)) + (MIN))
  25 #define NUMVERTEXNORMALS        162
  26 siextern float r_avertexnormals[NUMVERTEXNORMALS][3];
  27 #define m_bytenormals r_avertexnormals
  28 #define VectorNormalizeFast VectorNormalize
  29 #define CL_PointQ1Contents(v) (Mod_PointInLeaf(v,cl.worldmodel)->contents)
  30 typedef unsigned char qbyte;
  31 #define cl_stainmaps.integer 0
  32 void R_Stain (vec3_t origin, float radius, int cr1, int cg1, int cb1, int ca1, int cr2, int cg2, int cb2, int ca2)
  33 {
  34 }
  35 #define CL_EntityParticles R_EntityParticles
  36 #define CL_ReadPointFile_f R_ReadPointFile_f
  37 #define CL_ParseParticleEffect R_ParseParticleEffect
  38 #define CL_ParticleExplosion R_ParticleExplosion
  39 #define CL_ParticleExplosion2 R_ParticleExplosion2
  40 #define CL_BlobExplosion R_BlobExplosion
  41 #define CL_RunParticleEffect R_RunParticleEffect
  42 #define CL_LavaSplash R_LavaSplash
  43 #define CL_RocketTrail2 R_RocketTrail2
  44 void R_CalcBeam_Vertex3f (float *vert, vec3_t org1, vec3_t org2, float width)
  45 {
  46         vec3_t right1, right2, diff, normal;
  47
  48         VectorSubtract (org2, org1, normal);
  49         VectorNormalizeFast (normal);
  50
  51         // calculate 'right' vector for start
  52         VectorSubtract (r_origin, org1, diff);
  53         VectorNormalizeFast (diff);
  54         CrossProduct (normal, diff, right1);
  55
  56         // calculate 'right' vector for end
  57         VectorSubtract (r_origin, org2, diff);
  58         VectorNormalizeFast (diff);
  59         CrossProduct (normal, diff, right2);
  60
  61         vert[ 0] = org1[0] + width * right1[0];
  62         vert[ 1] = org1[1] + width * right1[1];
  63         vert[ 2] = org1[2] + width * right1[2];
  64         vert[ 3] = org1[0] - width * right1[0];
  65         vert[ 4] = org1[1] - width * right1[1];
  66         vert[ 5] = org1[2] - width * right1[2];
  67         vert[ 6] = org2[0] - width * right2[0];
  68         vert[ 7] = org2[1] - width * right2[1];
  69         vert[ 8] = org2[2] - width * right2[2];
  70         vert[ 9] = org2[0] + width * right2[0];
  71         vert[10] = org2[1] + width * right2[1];
  72         vert[11] = org2[2] + width * right2[2];
  73 }
  74 void fractalnoise(qbyte *noise, int size, int startgrid)
  75 {
  76         int x, y, g, g2, amplitude, min, max, size1 = size - 1, sizepower, gridpower;
  77         int *noisebuf;
  78 #define n(x,y) noisebuf[((y)&size1)*size+((x)&size1)]
  79
  80         for (sizepower = 0;(1 << sizepower) < size;sizepower++);
  81         if (size != (1 << sizepower))
  82                 Sys_Error("fractalnoise: size must be power of 2\n");
  83
  84         for (gridpower = 0;(1 << gridpower) < startgrid;gridpower++);
  85         if (startgrid != (1 << gridpower))
  86                 Sys_Error("fractalnoise: grid must be power of 2\n");
  87
  88         startgrid = bound(0, startgrid, size);
  89
  90         amplitude = 0xFFFF; // this gets halved before use
  91         noisebuf = malloc(size*size*sizeof(int));
  92         memset(noisebuf, 0, size*size*sizeof(int));
  93
  94         for (g2 = startgrid;g2;g2 >>= 1)
  95         {
  96                 // brownian motion (at every smaller level there is random behavior)
  97                 amplitude >>= 1;
  98                 for (y = 0;y < size;y += g2)
  99                         for (x = 0;x < size;x += g2)
 100                                 n(x,y) += (rand()&amplitude);
 101
 102                 g = g2 >> 1;
 103                 if (g)
 104                 {
 105                         // subdivide, diamond-square algorithm (really this has little to do with squares)
 106                         // diamond
 107                         for (y = 0;y < size;y += g2)
 108                                 for (x = 0;x < size;x += g2)
 109                                         n(x+g,y+g) = (n(x,y) + n(x+g2,y) + n(x,y+g2) + n(x+g2,y+g2)) >> 2;
 110                         // square
 111                         for (y = 0;y < size;y += g2)
 112                                 for (x = 0;x < size;x += g2)
 113                                 {
 114                                         n(x+g,y) = (n(x,y) + n(x+g2,y) + n(x+g,y-g) + n(x+g,y+g)) >> 2;
 115                                         n(x,y+g) = (n(x,y) + n(x,y+g2) + n(x-g,y+g) + n(x+g,y+g)) >> 2;
 116                                 }
 117                 }
 118         }
 119         // find range of noise values
 120         min = max = 0;
 121         for (y = 0;y < size;y++)
 122                 for (x = 0;x < size;x++)
 123                 {
 124                         if (n(x,y) < min) min = n(x,y);
 125                         if (n(x,y) > max) max = n(x,y);
 126                 }
 127         max -= min;
 128         max++;
 129         // normalize noise and copy to output
 130         for (y = 0;y < size;y++)
 131                 for (x = 0;x < size;x++)
 132                         *noise++ = (qbyte) (((n(x,y) - min) * 256) / max);
 133         free(noisebuf);
 134 #undef n
 135 }
 136 void VectorVectors(const vec3_t forward, vec3_t right, vec3_t up)
 137 {
 138         float d;
 139
 140         right[0] = forward[2];
 141         right[1] = -forward[0];
 142         right[2] = forward[1];
 143
 144         d = DotProduct(forward, right);
 145         right[0] -= d * forward[0];
 146         right[1] -= d * forward[1];
 147         right[2] -= d * forward[2];
 148         VectorNormalizeFast(right);
 149         CrossProduct(right, forward, up);
 150 }
 151 #if QW
 152 #include "pmove.h"
 153 extern qboolean PM_RecursiveHullCheck (hull_t *hull, int num, float p1f, float p2f, vec3_t p1, vec3_t p2, pmtrace_t *trace);
 154 #endif
 155 float CL_TraceLine (vec3_t start, vec3_t end, vec3_t impact, vec3_t normal, int hitbmodels, void **hitent, int hitsupercontentsmask)
 156 {
 157 #if QW
 158         pmtrace_t trace;
 159 #else
 160         trace_t trace;
 161 #endif
 162         memset (&trace, 0, sizeof(trace));
 163         trace.fraction = 1;
 164         VectorCopy (end, trace.endpos);
 165 #if QW
 166         PM_RecursiveHullCheck (cl.model_precache[1]->hulls, 0, 0, 1, start, end, &trace);
 167 #else
 168         RecursiveHullCheck (cl.worldmodel->hulls, 0, 0, 1, start, end, &trace);
 169 #endif
 170         VectorCopy(trace.endpos, impact);
 171         VectorCopy(trace.plane.normal, normal);
 172         return trace.fraction;
 173 }
 174 #else
 175 #include "cl_collision.h"
 176 #endif
 177
 178 #define MAX_PARTICLES                   32768   // default max # of particles at one time
 179 #define ABSOLUTE_MIN_PARTICLES  512             // no fewer than this no matter what's on the command line
 180
 181 typedef enum
 182 {
 183         pt_static, pt_rain, pt_bubble, pt_blood, pt_grow, pt_decal, pt_decalfade
 184 }
 185 ptype_t;
 186
 187 #define PARTICLE_INVALID 0
 188 #define PARTICLE_BILLBOARD 1
 189 #define PARTICLE_SPARK 2
 190 #define PARTICLE_ORIENTED_DOUBLESIDED 3
 191 #define PARTICLE_BEAM 4
 192
 193 #define PBLEND_ALPHA 0
 194 #define PBLEND_ADD 1
 195 #define PBLEND_MOD 2
 196
 197 typedef struct particle_s
 198 {
 199         ptype_t         type;
 200         int                     orientation;
 201         int                     texnum;
 202         int                     blendmode;
 203         vec3_t          org;
 204         vec3_t          vel;
 205         float           die;
 206         float           scalex;
 207         float           scaley;
 208         float           alpha; // 0-255
 209         float           alphafade; // how much alpha reduces per second
 210         float           time2; // used for various things (snow fluttering, for example)
 211         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)
 212         float           gravity; // how much gravity affects this particle (1.0 = normal gravity, 0.0 = none)
 213         vec3_t          oldorg;
 214         vec3_t          vel2; // used for snow fluttering (base velocity, wind for instance)
 215         float           friction; // how much air friction affects this object (objects with a low mass/size ratio tend to get more air friction)
 216         float           pressure; // if non-zero, apply pressure to other particles
 217         qbyte           color[4];
 218 #ifndef WORKINGLQUAKE
 219         entity_render_t *owner; // decal stuck to this entity
 220         model_t         *ownermodel; // model the decal is stuck to (used to make sure the entity is still alive)
 221         vec3_t          relativeorigin; // decal at this location in entity's coordinate space
 222         vec3_t          relativedirection; // decal oriented this way relative to entity's coordinate space
 223 #endif
 224 }
 225 particle_t;
 226
 227 static int particlepalette[256] =
 228 {
 229         0x000000,0x0f0f0f,0x1f1f1f,0x2f2f2f,0x3f3f3f,0x4b4b4b,0x5b5b5b,0x6b6b6b,
 230         0x7b7b7b,0x8b8b8b,0x9b9b9b,0xababab,0xbbbbbb,0xcbcbcb,0xdbdbdb,0xebebeb,
 231         0x0f0b07,0x170f0b,0x1f170b,0x271b0f,0x2f2313,0x372b17,0x3f2f17,0x4b371b,
 232         0x533b1b,0x5b431f,0x634b1f,0x6b531f,0x73571f,0x7b5f23,0x836723,0x8f6f23,
 233         0x0b0b0f,0x13131b,0x1b1b27,0x272733,0x2f2f3f,0x37374b,0x3f3f57,0x474767,
 234         0x4f4f73,0x5b5b7f,0x63638b,0x6b6b97,0x7373a3,0x7b7baf,0x8383bb,0x8b8bcb,
 235         0x000000,0x070700,0x0b0b00,0x131300,0x1b1b00,0x232300,0x2b2b07,0x2f2f07,
 236         0x373707,0x3f3f07,0x474707,0x4b4b0b,0x53530b,0x5b5b0b,0x63630b,0x6b6b0f,
 237         0x070000,0x0f0000,0x170000,0x1f0000,0x270000,0x2f0000,0x370000,0x3f0000,
 238         0x470000,0x4f0000,0x570000,0x5f0000,0x670000,0x6f0000,0x770000,0x7f0000,
 239         0x131300,0x1b1b00,0x232300,0x2f2b00,0x372f00,0x433700,0x4b3b07,0x574307,
 240         0x5f4707,0x6b4b0b,0x77530f,0x835713,0x8b5b13,0x975f1b,0xa3631f,0xaf6723,
 241         0x231307,0x2f170b,0x3b1f0f,0x4b2313,0x572b17,0x632f1f,0x733723,0x7f3b2b,
 242         0x8f4333,0x9f4f33,0xaf632f,0xbf772f,0xcf8f2b,0xdfab27,0xefcb1f,0xfff31b,
 243         0x0b0700,0x1b1300,0x2b230f,0x372b13,0x47331b,0x533723,0x633f2b,0x6f4733,
 244         0x7f533f,0x8b5f47,0x9b6b53,0xa77b5f,0xb7876b,0xc3937b,0xd3a38b,0xe3b397,
 245         0xab8ba3,0x9f7f97,0x937387,0x8b677b,0x7f5b6f,0x775363,0x6b4b57,0x5f3f4b,
 246         0x573743,0x4b2f37,0x43272f,0x371f23,0x2b171b,0x231313,0x170b0b,0x0f0707,
 247         0xbb739f,0xaf6b8f,0xa35f83,0x975777,0x8b4f6b,0x7f4b5f,0x734353,0x6b3b4b,
 248         0x5f333f,0x532b37,0x47232b,0x3b1f23,0x2f171b,0x231313,0x170b0b,0x0f0707,
 249         0xdbc3bb,0xcbb3a7,0xbfa39b,0xaf978b,0xa3877b,0x977b6f,0x876f5f,0x7b6353,
 250         0x6b5747,0x5f4b3b,0x533f33,0x433327,0x372b1f,0x271f17,0x1b130f,0x0f0b07,
 251         0x6f837b,0x677b6f,0x5f7367,0x576b5f,0x4f6357,0x475b4f,0x3f5347,0x374b3f,
 252         0x2f4337,0x2b3b2f,0x233327,0x1f2b1f,0x172317,0x0f1b13,0x0b130b,0x070b07,
 253         0xfff31b,0xefdf17,0xdbcb13,0xcbb70f,0xbba70f,0xab970b,0x9b8307,0x8b7307,
 254         0x7b6307,0x6b5300,0x5b4700,0x4b3700,0x3b2b00,0x2b1f00,0x1b0f00,0x0b0700,
 255         0x0000ff,0x0b0bef,0x1313df,0x1b1bcf,0x2323bf,0x2b2baf,0x2f2f9f,0x2f2f8f,
 256         0x2f2f7f,0x2f2f6f,0x2f2f5f,0x2b2b4f,0x23233f,0x1b1b2f,0x13131f,0x0b0b0f,
 257         0x2b0000,0x3b0000,0x4b0700,0x5f0700,0x6f0f00,0x7f1707,0x931f07,0xa3270b,
 258         0xb7330f,0xc34b1b,0xcf632b,0xdb7f3b,0xe3974f,0xe7ab5f,0xefbf77,0xf7d38b,
 259         0xa77b3b,0xb79b37,0xc7c337,0xe7e357,0x7fbfff,0xabe7ff,0xd7ffff,0x670000,
 260         0x8b0000,0xb30000,0xd70000,0xff0000,0xfff393,0xfff7c7,0xffffff,0x9f5b53
 261 };
 262
 263 //static int explosparkramp[8] = {0x4b0700, 0x6f0f00, 0x931f07, 0xb7330f, 0xcf632b, 0xe3974f, 0xffe7b5, 0xffffff};
 264
 265 // texture numbers in particle font
 266 static const int tex_smoke[8] = {0, 1, 2, 3, 4, 5, 6, 7};
 267 static const int tex_bulletdecal[8] = {8, 9, 10, 11, 12, 13, 14, 15};
 268 static const int tex_blooddecal[8] = {16, 17, 18, 19, 20, 21, 22, 23};
 269 static const int tex_bloodparticle[8] = {24, 25, 26, 27, 28, 29, 30, 31};
 270 static const int tex_rainsplash[16] = {32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47};
 271 static const int tex_particle = 63;
 272 static const int tex_bubble = 62;
 273 static const int tex_raindrop = 61;
 274 static const int tex_beam = 60;
 275
 276 static int                      cl_maxparticles;
 277 static int                      cl_numparticles;
 278 static particle_t       *particles;
 279 static particle_t       **freeparticles; // list used only in compacting particles array
 280
 281 cvar_t cl_particles = {CVAR_SAVE, "cl_particles", "1"};
 282 cvar_t cl_particles_quality = {CVAR_SAVE, "cl_particles_quality", "1"};
 283 cvar_t cl_particles_size = {CVAR_SAVE, "cl_particles_size", "1"};
 284 cvar_t cl_particles_bloodshowers = {CVAR_SAVE, "cl_particles_bloodshowers", "1"};
 285 cvar_t cl_particles_blood = {CVAR_SAVE, "cl_particles_blood", "1"};
 286 cvar_t cl_particles_blood_alpha = {CVAR_SAVE, "cl_particles_blood_alpha", "0.5"};
 287 cvar_t cl_particles_bulletimpacts = {CVAR_SAVE, "cl_particles_bulletimpacts", "1"};
 288 cvar_t cl_particles_smoke = {CVAR_SAVE, "cl_particles_smoke", "1"};
 289 cvar_t cl_particles_smoke_alpha = {CVAR_SAVE, "cl_particles_smoke_alpha", "0.5"};
 290 cvar_t cl_particles_smoke_alphafade = {CVAR_SAVE, "cl_particles_smoke_alphafade", "0.55"};
 291 cvar_t cl_particles_sparks = {CVAR_SAVE, "cl_particles_sparks", "1"};
 292 cvar_t cl_particles_bubbles = {CVAR_SAVE, "cl_particles_bubbles", "1"};
 293 cvar_t cl_decals = {CVAR_SAVE, "cl_decals", "0"};
 294 cvar_t cl_decals_time = {CVAR_SAVE, "cl_decals_time", "0"};
 295 cvar_t cl_decals_fadetime = {CVAR_SAVE, "cl_decals_fadetime", "20"};
 296
 297 #ifndef WORKINGLQUAKE
 298 static mempool_t *cl_part_mempool;
 299 #endif
 300
 301 void CL_Particles_Clear(void)
 302 {
 303         cl_numparticles = 0;
 304 }
 305
 306 /*
 307 ===============
 308 CL_InitParticles
 309 ===============
 310 */
 311 void CL_ReadPointFile_f (void);
 312 void CL_Particles_Init (void)
 313 {
 314         int             i;
 315
 316         i = COM_CheckParm ("-particles");
 317
 318         if (i && i < com_argc - 1)
 319         {
 320                 cl_maxparticles = (int)(atoi(com_argv[i+1]));
 321                 if (cl_maxparticles < ABSOLUTE_MIN_PARTICLES)
 322                         cl_maxparticles = ABSOLUTE_MIN_PARTICLES;
 323         }
 324         else
 325                 cl_maxparticles = MAX_PARTICLES;
 326
 327         Cmd_AddCommand ("pointfile", CL_ReadPointFile_f);
 328
 329         Cvar_RegisterVariable (&cl_particles);
 330         Cvar_RegisterVariable (&cl_particles_quality);
 331         Cvar_RegisterVariable (&cl_particles_size);
 332         Cvar_RegisterVariable (&cl_particles_bloodshowers);
 333         Cvar_RegisterVariable (&cl_particles_blood);
 334         Cvar_RegisterVariable (&cl_particles_blood_alpha);
 335         Cvar_RegisterVariable (&cl_particles_bulletimpacts);
 336         Cvar_RegisterVariable (&cl_particles_smoke);
 337         Cvar_RegisterVariable (&cl_particles_smoke_alpha);
 338         Cvar_RegisterVariable (&cl_particles_smoke_alphafade);
 339         Cvar_RegisterVariable (&cl_particles_sparks);
 340         Cvar_RegisterVariable (&cl_particles_bubbles);
 341         Cvar_RegisterVariable (&cl_decals);
 342         Cvar_RegisterVariable (&cl_decals_time);
 343         Cvar_RegisterVariable (&cl_decals_fadetime);
 344
 345 #ifdef WORKINGLQUAKE
 346         particles = (particle_t *) Hunk_AllocName(cl_maxparticles * sizeof(particle_t), "particles");
 347         freeparticles = (void *) Hunk_AllocName(cl_maxparticles * sizeof(particle_t *), "particles");
 348 #else
 349         cl_part_mempool = Mem_AllocPool("CL_Part");
 350         particles = (particle_t *) Mem_Alloc(cl_part_mempool, cl_maxparticles * sizeof(particle_t));
 351         freeparticles = (void *) Mem_Alloc(cl_part_mempool, cl_maxparticles * sizeof(particle_t *));
 352 #endif
 353         cl_numparticles = 0;
 354 }
 355
 356 particle_t *particle(int ptype, int porientation, int pcolor1, int pcolor2, int ptex, int plight, int pblendmode, float pscalex, float pscaley, float palpha, float palphafade, float ptime, float pgravity, float pbounce, float px, float py, float pz, float pvx, float pvy, float pvz, float ptime2, float pvx2, float pvy2, float pvz2, float pfriction, float ppressure)
 357 {
 358         if (cl_numparticles < cl_maxparticles)
 359         {
 360                 particle_t *part;
 361                 int ptempcolor, ptempcolor2, pcr1, pcg1, pcb1, pcr2, pcg2, pcb2;
 362                 ptempcolor = (pcolor1);
 363                 ptempcolor2 = (pcolor2);
 364                 pcr2 = ((ptempcolor2) >> 16) & 0xFF;
 365                 pcg2 = ((ptempcolor2) >> 8) & 0xFF;
 366                 pcb2 = (ptempcolor2) & 0xFF;
 367                 if (ptempcolor != ptempcolor2)
 368                 {
 369                         pcr1 = ((ptempcolor) >> 16) & 0xFF;
 370                         pcg1 = ((ptempcolor) >> 8) & 0xFF;
 371                         pcb1 = (ptempcolor) & 0xFF;
 372                         ptempcolor = rand() & 0xFF;
 373                         pcr2 = (((pcr2 - pcr1) * ptempcolor) >> 8) + pcr1;
 374                         pcg2 = (((pcg2 - pcg1) * ptempcolor) >> 8) + pcg1;
 375                         pcb2 = (((pcb2 - pcb1) * ptempcolor) >> 8) + pcb1;
 376                 }
 377                 part = &particles[cl_numparticles++];
 378                 memset(part, 0, sizeof(*part));
 379                 part->type = (ptype);
 380                 part->color[0] = pcr2;
 381                 part->color[1] = pcg2;
 382                 part->color[2] = pcb2;
 383                 part->color[3] = 0xFF;
 384                 part->orientation = porientation;
 385                 part->texnum = ptex;
 386                 part->blendmode = pblendmode;
 387                 part->scalex = (pscalex);
 388                 part->scaley = (pscaley);
 389                 part->alpha = (palpha);
 390                 part->alphafade = (palphafade);
 391                 part->die = cl.time + (ptime);
 392                 part->gravity = (pgravity);
 393                 part->bounce = (pbounce);
 394                 part->org[0] = (px);
 395                 part->org[1] = (py);
 396                 part->org[2] = (pz);
 397                 part->vel[0] = (pvx);
 398                 part->vel[1] = (pvy);
 399                 part->vel[2] = (pvz);
 400                 part->time2 = (ptime2);
 401                 part->vel2[0] = (pvx2);
 402                 part->vel2[1] = (pvy2);
 403                 part->vel2[2] = (pvz2);
 404                 part->friction = (pfriction);
 405                 part->pressure = (ppressure);
 406                 return part;
 407         }
 408         return NULL;
 409 }
 410
 411 void CL_SpawnDecalParticleForSurface(void *hitent, const vec3_t org, const vec3_t normal, int color1, int color2, int texnum, float size, float alpha)
 412 {
 413         particle_t *p;
 414         if (!cl_decals.integer)
 415                 return;
 416         p = particle(pt_decal, PARTICLE_ORIENTED_DOUBLESIDED, color1, color2, texnum, false, PBLEND_MOD, size, size, alpha, 0, cl_decals_time.value + cl_decals_fadetime.value, 0, 0, org[0] + normal[0], org[1] + normal[1], org[2] + normal[2], 0, 0, 0, cl.time + cl_decals_time.value, normal[0], normal[1], normal[2], 0, 0);
 417 #ifndef WORKINGLQUAKE
 418         if (p)
 419         {
 420                 p->owner = hitent;
 421                 p->ownermodel = p->owner->model;
 422                 Matrix4x4_Transform(&p->owner->inversematrix, org, p->relativeorigin);
 423                 Matrix4x4_Transform3x3(&p->owner->inversematrix, normal, p->relativedirection);
 424                 VectorAdd(p->relativeorigin, p->relativedirection, p->relativeorigin);
 425         }
 426 #endif
 427 }
 428
 429 void CL_SpawnDecalParticleForPoint(const vec3_t org, float maxdist, float size, float alpha, int texnum, int color1, int color2)
 430 {
 431         int i;
 432         float bestfrac, bestorg[3], bestnormal[3];
 433         float frac, v[3], normal[3], org2[3];
 434 #ifdef WORKINGLQUAKE
 435         void *besthitent = NULL, *hitent;
 436 #else
 437         entity_render_t *besthitent = NULL, *hitent;
 438 #endif
 439         bestfrac = 10;
 440         for (i = 0;i < 32;i++)
 441         {
 442                 VectorRandom(org2);
 443                 VectorMA(org, maxdist, org2, org2);
 444                 frac = CL_TraceLine(org, org2, v, normal, true, &hitent, SUPERCONTENTS_SOLID);
 445                 if (bestfrac > frac)
 446                 {
 447                         bestfrac = frac;
 448                         besthitent = hitent;
 449                         VectorCopy(v, bestorg);
 450                         VectorCopy(normal, bestnormal);
 451                 }
 452         }
 453         if (bestfrac < 1)
 454                 CL_SpawnDecalParticleForSurface(besthitent, bestorg, bestnormal, color1, color2, texnum, size, alpha);
 455 }
 456
 457 /*
 458 ===============
 459 CL_EntityParticles
 460 ===============
 461 */
 462 void CL_EntityParticles (entity_t *ent)
 463 {
 464         int                     i;
 465         float           angle;
 466         float           sp, sy, cp, cy;
 467         vec3_t          forward;
 468         float           dist;
 469         float           beamlength;
 470         static vec3_t avelocities[NUMVERTEXNORMALS];
 471         if (!cl_particles.integer) return;
 472
 473         dist = 64;
 474         beamlength = 16;
 475
 476         if (!avelocities[0][0])
 477                 for (i=0 ; i<NUMVERTEXNORMALS*3 ; i++)
 478                         avelocities[0][i] = (rand()&255) * 0.01;
 479
 480         for (i=0 ; i<NUMVERTEXNORMALS ; i++)
 481         {
 482                 angle = cl.time * avelocities[i][0];
 483                 sy = sin(angle);
 484                 cy = cos(angle);
 485                 angle = cl.time * avelocities[i][1];
 486                 sp = sin(angle);
 487                 cp = cos(angle);
 488
 489                 forward[0] = cp*cy;
 490                 forward[1] = cp*sy;
 491                 forward[2] = -sp;
 492
 493 #ifdef WORKINGLQUAKE
 494                 particle(pt_static, PARTICLE_BILLBOARD, particlepalette[0x6f], particlepalette[0x6f], tex_particle, false, PBLEND_ADD, 2, 2, 255, 0, 0, 0, 0, ent->origin[0] + m_bytenormals[i][0]*dist + forward[0]*beamlength, ent->origin[1] + m_bytenormals[i][1]*dist + forward[1]*beamlength, ent->origin[2] + m_bytenormals[i][2]*dist + forward[2]*beamlength, 0, 0, 0, 0, 0, 0, 0, 0, 0);
 495 #else
 496                 particle(pt_static, PARTICLE_BILLBOARD, particlepalette[0x6f], particlepalette[0x6f], tex_particle, false, PBLEND_ADD, 2, 2, 255, 0, 0, 0, 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);
 497 #endif
 498         }
 499 }
 500
 501
 502 void CL_ReadPointFile_f (void)
 503 {
 504         vec3_t org, leakorg;
 505         int r, c, s;
 506         char *pointfile = NULL, *pointfilepos, *t, tchar;
 507         char name[MAX_OSPATH];
 508
 509         if (!cl.worldmodel)
 510                 return;
 511
 512         FS_StripExtension(cl.worldmodel->name, name);
 513         strcat(name, ".pts");
 514 #if WORKINGLQUAKE
 515         pointfile = COM_LoadTempFile (name);
 516 #else
 517         pointfile = FS_LoadFile(name, true);
 518 #endif
 519         if (!pointfile)
 520         {
 521                 Con_Printf ("Could not open %s\n", name);
 522                 return;
 523         }
 524
 525         Con_Printf ("Reading %s...\n", name);
 526         c = 0;
 527         s = 0;
 528         pointfilepos = pointfile;
 529         while (*pointfilepos)
 530         {
 531                 while (*pointfilepos == '\n' || *pointfilepos == '\r')
 532                         pointfilepos++;
 533                 if (!*pointfilepos)
 534                         break;
 535                 t = pointfilepos;
 536                 while (*t && *t != '\n' && *t != '\r')
 537                         t++;
 538                 tchar = *t;
 539                 *t = 0;
 540                 r = sscanf (pointfilepos,"%f %f %f", &org[0], &org[1], &org[2]);
 541                 *t = tchar;
 542                 pointfilepos = t;
 543                 if (r != 3)
 544                         break;
 545                 if (c == 0)
 546                         VectorCopy(org, leakorg);
 547                 c++;
 548
 549                 if (cl_numparticles < cl_maxparticles - 3)
 550                 {
 551                         s++;
 552                         particle(pt_static, PARTICLE_BILLBOARD, particlepalette[(-c)&15], particlepalette[(-c)&15], tex_particle, false, PBLEND_ALPHA, 2, 2, 255, 0, 99999, 0, 0, org[0], org[1], org[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
 553                 }
 554         }
 555 #ifndef WORKINGLQUAKE
 556         Mem_Free(pointfile);
 557 #endif
 558         VectorCopy(leakorg, org);
 559         Con_Printf ("%i points read (%i particles spawned)\nLeak at %f %f %f\n", c, s, org[0], org[1], org[2]);
 560
 561         particle(pt_static, PARTICLE_BEAM, 0xFF0000, 0xFF0000, tex_beam, false, PBLEND_ALPHA, 64, 64, 255, 0, 99999, 0, 0, org[0] - 4096, org[1], org[2], 0, 0, 0, 0, org[0] + 4096, org[1], org[2], 0, 0);
 562         particle(pt_static, PARTICLE_BEAM, 0x00FF00, 0x00FF00, tex_beam, false, PBLEND_ALPHA, 64, 64, 255, 0, 99999, 0, 0, org[0], org[1] - 4096, org[2], 0, 0, 0, 0, org[0], org[1] + 4096, org[2], 0, 0);
 563         particle(pt_static, PARTICLE_BEAM, 0x0000FF, 0x0000FF, tex_beam, false, PBLEND_ALPHA, 64, 64, 255, 0, 99999, 0, 0, org[0], org[1], org[2] - 4096, 0, 0, 0, 0, org[0], org[1], org[2] + 4096, 0, 0);
 564 }
 565
 566 /*
 567 ===============
 568 CL_ParseParticleEffect
 569
 570 Parse an effect out of the server message
 571 ===============
 572 */
 573 void CL_ParseParticleEffect (void)
 574 {
 575         vec3_t org, dir;
 576         int i, count, msgcount, color;
 577
 578         for (i=0 ; i<3 ; i++)
 579                 org[i] = MSG_ReadCoord ();
 580         for (i=0 ; i<3 ; i++)
 581                 dir[i] = MSG_ReadChar () * (1.0/16);
 582         msgcount = MSG_ReadByte ();
 583         color = MSG_ReadByte ();
 584
 585         if (msgcount == 255)
 586                 count = 1024;
 587         else
 588                 count = msgcount;
 589
 590         CL_RunParticleEffect (org, dir, color, count);
 591 }
 592
 593 /*
 594 ===============
 595 CL_ParticleExplosion
 596
 597 ===============
 598 */
 599 void CL_ParticleExplosion (vec3_t org)
 600 {
 601         int i, k;
 602         //vec3_t v;
 603         //vec3_t v2;
 604         if (cl_stainmaps.integer)
 605                 R_Stain(org, 96, 80, 80, 80, 64, 176, 176, 176, 64);
 606         CL_SpawnDecalParticleForPoint(org, 40, 48, 255, tex_bulletdecal[rand()&7], 0xFFFFFF, 0xFFFFFF);
 607
 608         i = CL_PointQ1Contents(org);
 609         if ((i == CONTENTS_SLIME || i == CONTENTS_WATER) && cl_particles.integer && cl_particles_bubbles.integer)
 610         {
 611                 for (i = 0;i < 128 * cl_particles_quality.value;i++)
 612                         particle(pt_bubble, PARTICLE_BILLBOARD, 0x404040, 0x808080, tex_bubble, false, PBLEND_ADD, 2, 2, (1.0f / cl_particles_quality.value) * lhrandom(128, 255), (1.0f / cl_particles_quality.value) * 256, 9999, -0.25, 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, (1.0 / 16.0), 0);
 613         }
 614         else
 615         {
 616                 /*
 617                 // LordHavoc: smoke effect similar to UT2003, chews fillrate too badly up close
 618                 // smoke puff
 619                 if (cl_particles.integer && cl_particles_smoke.integer)
 620                 {
 621                         for (i = 0;i < 64;i++)
 622                         {
 623 #ifdef WORKINGLQUAKE
 624                                 v2[0] = lhrandom(-64, 64);
 625                                 v2[1] = lhrandom(-64, 64);
 626                                 v2[2] = lhrandom(-8, 24);
 627 #else
 628                                 for (k = 0;k < 16;k++)
 629                                 {
 630                                         v[0] = org[0] + lhrandom(-64, 64);
 631                                         v[1] = org[1] + lhrandom(-64, 64);
 632                                         v[2] = org[2] + lhrandom(-8, 24);
 633                                         if (CL_TraceLine(org, v, v2, NULL, true, NULL, SUPERCONTENTS_SOLID) >= 0.1)
 634                                                 break;
 635                                 }
 636                                 VectorSubtract(v2, org, v2);
 637 #endif
 638                                 VectorScale(v2, 2.0f, v2);
 639                                 particle(pt_static, PARTICLE_BILLBOARD, 0x101010, 0x202020, tex_smoke[rand()&7], true, PBLEND_ADD, 12, 12, 255, 512, 9999, 0, 0, org[0], org[1], org[2], v2[0], v2[1], v2[2], 0, 0, 0, 0, 0, 0);
 640                         }
 641                 }
 642                 */
 643
 644                 if (cl_particles.integer && cl_particles_sparks.integer)
 645                 {
 646                         // sparks
 647                         for (i = 0;i < 256 * cl_particles_quality.value;i++)
 648                         {
 649                                 k = particlepalette[0x68 + (rand() & 7)];
 650                                 particle(pt_static, PARTICLE_SPARK, k, k, tex_particle, false, PBLEND_ADD, 1.5f, 0.05f, (1.0f / cl_particles_quality.value) * lhrandom(0, 255), (1.0f / cl_particles_quality.value) * 512, 9999, 1, 0, org[0], org[1], org[2], lhrandom(-192, 192), lhrandom(-192, 192), lhrandom(-192, 192) + 160, 0, 0, 0, 0, 0, 0);
 651                         }
 652                 }
 653         }
 654
 655         if (cl_explosions.integer)
 656                 R_NewExplosion(org);
 657 }
 658
 659 /*
 660 ===============
 661 CL_ParticleExplosion2
 662
 663 ===============
 664 */
 665 void CL_ParticleExplosion2 (vec3_t org, int colorStart, int colorLength)
 666 {
 667         int i, k;
 668         if (!cl_particles.integer) return;
 669
 670         for (i = 0;i < 512 * cl_particles_quality.value;i++)
 671         {
 672                 k = particlepalette[colorStart + (i % colorLength)];
 673                 particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ALPHA, 1.5, 1.5, (1.0f / cl_particles_quality.value) * 255, (1.0f / cl_particles_quality.value) * 384, 0.3, 0, 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, 1, 0);
 674         }
 675 }
 676
 677 /*
 678 ===============
 679 CL_BlobExplosion
 680
 681 ===============
 682 */
 683 void CL_BlobExplosion (vec3_t org)
 684 {
 685         if (cl_stainmaps.integer)
 686                 R_Stain(org, 96, 80, 80, 80, 64, 176, 176, 176, 64);
 687         CL_SpawnDecalParticleForPoint(org, 40, 48, 255, tex_bulletdecal[rand()&7], 0xFFFFFF, 0xFFFFFF);
 688
 689         if (cl_explosions.integer)
 690                 R_NewExplosion(org);
 691 }
 692
 693 /*
 694 ===============
 695 CL_RunParticleEffect
 696
 697 ===============
 698 */
 699 void CL_RunParticleEffect (vec3_t org, vec3_t dir, int color, int count)
 700 {
 701         int k;
 702
 703         if (count == 1024)
 704         {
 705                 CL_ParticleExplosion(org);
 706                 return;
 707         }
 708         if (!cl_particles.integer) return;
 709         count *= cl_particles_quality.value;
 710         while (count--)
 711         {
 712                 k = particlepalette[color + (rand()&7)];
 713                 if (gamemode == GAME_GOODVSBAD2)
 714                         particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ALPHA, 5, 5, (1.0f / cl_particles_quality.value) * 255, (1.0f / cl_particles_quality.value) * 300, 9999, 0, 0, org[0] + lhrandom(-8, 8), org[1] + lhrandom(-8, 8), org[2] + lhrandom(-8, 8), lhrandom(-10, 10), lhrandom(-10, 10), lhrandom(-10, 10), 0, 0, 0, 0, 0, 0);
 715                 else
 716                         particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ALPHA, 1, 1, (1.0f / cl_particles_quality.value) * 255, (1.0f / cl_particles_quality.value) * 512, 9999, 0, 0, org[0] + lhrandom(-8, 8), org[1] + lhrandom(-8, 8), org[2] + lhrandom(-8, 8), dir[0] + lhrandom(-15, 15), dir[1] + lhrandom(-15, 15), dir[2] + lhrandom(-15, 15), 0, 0, 0, 0, 0, 0);
 717         }
 718 }
 719
 720 // LordHavoc: added this for spawning sparks/dust (which have strong gravity)
 721 /*
 722 ===============
 723 CL_SparkShower
 724 ===============
 725 */
 726 void CL_SparkShower (vec3_t org, vec3_t dir, int count)
 727 {
 728         vec3_t org2, org3;
 729         int k;
 730
 731         if (cl_stainmaps.integer)
 732                 R_Stain(org, 32, 96, 96, 96, 24, 128, 128, 128, 24);
 733         CL_SpawnDecalParticleForPoint(org, 6, 3, 255, tex_bulletdecal[rand()&7], 0xFFFFFF, 0xFFFFFF);
 734
 735         if (!cl_particles.integer) return;
 736
 737         if (cl_particles_bulletimpacts.integer)
 738         {
 739                 // smoke puff
 740                 if (cl_particles_smoke.integer)
 741                 {
 742                         k = count * 0.25 * cl_particles_quality.value;
 743                         while(k--)
 744                         {
 745                                 org2[0] = org[0] + 0.125f * lhrandom(-count, count);
 746                                 org2[1] = org[1] + 0.125f * lhrandom(-count, count);
 747                                 org2[2] = org[2] + 0.125f * lhrandom(-count, count);
 748                                 CL_TraceLine(org, org2, org3, NULL, true, NULL, SUPERCONTENTS_SOLID);
 749                                 particle(pt_grow, PARTICLE_BILLBOARD, 0x101010, 0x202020, tex_smoke[rand()&7], true, PBLEND_ADD, 3, 3, (1.0f / cl_particles_quality.value) * 255, (1.0f / cl_particles_quality.value) * 1024, 9999, -0.2, 0, org3[0], org3[1], org3[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(0, 16), 15, 0, 0, 0, 0, 0);
 750                         }
 751                 }
 752
 753                 if (cl_particles_sparks.integer)
 754                 {
 755                         // sparks
 756                         count *= cl_particles_quality.value;
 757                         while(count--)
 758                         {
 759                                 k = particlepalette[0x68 + (rand() & 7)];
 760                                 particle(pt_static, PARTICLE_SPARK, k, k, tex_particle, false, PBLEND_ADD, 0.4f, 0.015f, (1.0f / cl_particles_quality.value) * lhrandom(64, 255), (1.0f / cl_particles_quality.value) * 512, 9999, 1, 0, org[0], org[1], org[2], lhrandom(-64, 64) + dir[0], lhrandom(-64, 64) + dir[1], lhrandom(0, 128) + dir[2], 0, 0, 0, 0, 0, 0);
 761                         }
 762                 }
 763         }
 764 }
 765
 766 void CL_PlasmaBurn (vec3_t org)
 767 {
 768         if (cl_stainmaps.integer)
 769                 R_Stain(org, 48, 96, 96, 96, 32, 128, 128, 128, 32);
 770         CL_SpawnDecalParticleForPoint(org, 6, 6, 255, tex_bulletdecal[rand()&7], 0xFFFFFF, 0xFFFFFF);
 771 }
 772
 773 static float bloodcount = 0;
 774 void CL_BloodPuff (vec3_t org, vec3_t vel, int count)
 775 {
 776         float s;
 777         vec3_t org2, org3;
 778         // bloodcount is used to accumulate counts too small to cause a blood particle
 779         if (!cl_particles.integer) return;
 780         if (!cl_particles_blood.integer) return;
 781
 782         s = count + 32.0f;
 783         count *= 5.0f;
 784         if (count > 1000)
 785                 count = 1000;
 786         bloodcount += count;
 787         while(bloodcount > 0)
 788         {
 789                 org2[0] = org[0] + 0.125f * lhrandom(-bloodcount, bloodcount);
 790                 org2[1] = org[1] + 0.125f * lhrandom(-bloodcount, bloodcount);
 791                 org2[2] = org[2] + 0.125f * lhrandom(-bloodcount, bloodcount);
 792                 CL_TraceLine(org, org2, org3, NULL, true, NULL, SUPERCONTENTS_SOLID);
 793                 particle(pt_blood, PARTICLE_BILLBOARD, 0xFFFFFF, 0xFFFFFF, tex_bloodparticle[rand()&7], true, PBLEND_MOD, 8, 8, cl_particles_blood_alpha.value * 768 / cl_particles_quality.value, cl_particles_blood_alpha.value * 384 / cl_particles_quality.value, 9999, 0, -1, org3[0], org3[1], org3[2], vel[0] + lhrandom(-s, s), vel[1] + lhrandom(-s, s), vel[2] + lhrandom(-s, s), 0, 0, 0, 0, 1, 0);
 794                 bloodcount -= 16 / cl_particles_quality.value;
 795         }
 796 }
 797
 798 void CL_BloodShower (vec3_t mins, vec3_t maxs, float velspeed, int count)
 799 {
 800         vec3_t org, vel, diff, center, velscale;
 801         if (!cl_particles.integer) return;
 802         if (!cl_particles_bloodshowers.integer) return;
 803         if (!cl_particles_blood.integer) return;
 804
 805         VectorSubtract(maxs, mins, diff);
 806         center[0] = (mins[0] + maxs[0]) * 0.5;
 807         center[1] = (mins[1] + maxs[1]) * 0.5;
 808         center[2] = (mins[2] + maxs[2]) * 0.5;
 809         velscale[0] = velspeed * 2.0 / diff[0];
 810         velscale[1] = velspeed * 2.0 / diff[1];
 811         velscale[2] = velspeed * 2.0 / diff[2];
 812
 813         bloodcount += count * 5.0f;
 814         while (bloodcount > 0)
 815         {
 816                 org[0] = lhrandom(mins[0], maxs[0]);
 817                 org[1] = lhrandom(mins[1], maxs[1]);
 818                 org[2] = lhrandom(mins[2], maxs[2]);
 819                 vel[0] = (org[0] - center[0]) * velscale[0];
 820                 vel[1] = (org[1] - center[1]) * velscale[1];
 821                 vel[2] = (org[2] - center[2]) * velscale[2];
 822                 bloodcount -= 16 / cl_particles_quality.value;
 823                 particle(pt_blood, PARTICLE_BILLBOARD, 0xFFFFFF, 0xFFFFFF, tex_bloodparticle[rand()&7], true, PBLEND_MOD, 8, 8, cl_particles_blood_alpha.value * 768 / cl_particles_quality.value, cl_particles_blood_alpha.value * 384 / cl_particles_quality.value, 9999, 0, -1, org[0], org[1], org[2], vel[0], vel[1], vel[2], 0, 0, 0, 0, 1, 0);
 824         }
 825 }
 826
 827 void CL_ParticleCube (vec3_t mins, vec3_t maxs, vec3_t dir, int count, int colorbase, int gravity, int randomvel)
 828 {
 829         int k;
 830         float t;
 831         if (!cl_particles.integer) return;
 832         if (maxs[0] <= mins[0]) {t = mins[0];mins[0] = maxs[0];maxs[0] = t;}
 833         if (maxs[1] <= mins[1]) {t = mins[1];mins[1] = maxs[1];maxs[1] = t;}
 834         if (maxs[2] <= mins[2]) {t = mins[2];mins[2] = maxs[2];maxs[2] = t;}
 835
 836         count *= cl_particles_quality.value;
 837         while (count--)
 838         {
 839                 k = particlepalette[colorbase + (rand()&3)];
 840                 particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ALPHA, 2, 2, 255 / cl_particles_quality.value, 0, lhrandom(1, 2), gravity ? 1 : 0, 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);
 841         }
 842 }
 843
 844 void CL_ParticleRain (vec3_t mins, vec3_t maxs, vec3_t dir, int count, int colorbase, int type)
 845 {
 846         int k;
 847         float t, z, minz, maxz;
 848         if (!cl_particles.integer) return;
 849         if (maxs[0] <= mins[0]) {t = mins[0];mins[0] = maxs[0];maxs[0] = t;}
 850         if (maxs[1] <= mins[1]) {t = mins[1];mins[1] = maxs[1];maxs[1] = t;}
 851         if (maxs[2] <= mins[2]) {t = mins[2];mins[2] = maxs[2];maxs[2] = t;}
 852         if (dir[2] < 0) // falling
 853         {
 854                 t = (maxs[2] - mins[2]) / -dir[2];
 855                 z = maxs[2];
 856         }
 857         else // rising??
 858         {
 859                 t = (maxs[2] - mins[2]) / dir[2];
 860                 z = mins[2];
 861         }
 862         if (t < 0 || t > 2) // sanity check
 863                 t = 2;
 864
 865         minz = z - fabs(dir[2]) * 0.1;
 866         maxz = z + fabs(dir[2]) * 0.1;
 867         minz = bound(mins[2], minz, maxs[2]);
 868         maxz = bound(mins[2], maxz, maxs[2]);
 869
 870         count *= cl_particles_quality.value;
 871
 872         switch(type)
 873         {
 874         case 0:
 875                 count *= 4; // ick, this should be in the mod or maps?
 876
 877                 while(count--)
 878                 {
 879                         k = particlepalette[colorbase + (rand()&3)];
 880                         if (gamemode == GAME_GOODVSBAD2)
 881                         {
 882                                 particle(pt_rain, PARTICLE_SPARK, k, k, tex_particle, true, PBLEND_ADD, 20, 20, lhrandom(8, 16) / cl_particles_quality.value, 0, t, 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz), dir[0], dir[1], dir[2], cl.time + 9999, dir[0], dir[1], dir[2], 0, 0);
 883                         }
 884                         else
 885                         {
 886                                 particle(pt_rain, PARTICLE_SPARK, k, k, tex_particle, true, PBLEND_ADD, 0.5, 0.02, lhrandom(8, 16) / cl_particles_quality.value, 0, t, 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz), dir[0], dir[1], dir[2], cl.time + 9999, dir[0], dir[1], dir[2], 0, 0);
 887                         }
 888                 }
 889                 break;
 890         case 1:
 891                 while(count--)
 892                 {
 893                         k = particlepalette[colorbase + (rand()&3)];
 894                         if (gamemode == GAME_GOODVSBAD2)
 895                         {
 896                                 particle(pt_rain, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ADD, 20, 20, lhrandom(64, 128) / cl_particles_quality.value, 0, t, 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz), dir[0], dir[1], dir[2], 0, dir[0], dir[1], dir[2], 0, 0);
 897                         }
 898                         else
 899                         {
 900                                 particle(pt_rain, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ADD, 1, 1, lhrandom(64, 128) / cl_particles_quality.value, 0, t, 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz), dir[0], dir[1], dir[2], 0, dir[0], dir[1], dir[2], 0, 0);
 901                         }
 902                 }
 903                 break;
 904         default:
 905                 Host_Error("CL_ParticleRain: unknown type %i (0 = rain, 1 = snow)\n", type);
 906         }
 907 }
 908
 909 void CL_Stardust (vec3_t mins, vec3_t maxs, int count)
 910 {
 911         int k;
 912         float t;
 913         vec3_t o, v, center;
 914         if (!cl_particles.integer) return;
 915
 916         if (maxs[0] <= mins[0]) {t = mins[0];mins[0] = maxs[0];maxs[0] = t;}
 917         if (maxs[1] <= mins[1]) {t = mins[1];mins[1] = maxs[1];maxs[1] = t;}
 918         if (maxs[2] <= mins[2]) {t = mins[2];mins[2] = maxs[2];maxs[2] = t;}
 919
 920         center[0] = (mins[0] + maxs[0]) * 0.5f;
 921         center[1] = (mins[1] + maxs[1]) * 0.5f;
 922         center[2] = (mins[2] + maxs[2]) * 0.5f;
 923
 924         count *= cl_particles_quality.value;
 925         while (count--)
 926         {
 927                 k = particlepalette[224 + (rand()&15)];
 928                 o[0] = lhrandom(mins[0], maxs[0]);
 929                 o[1] = lhrandom(mins[1], maxs[1]);
 930                 o[2] = lhrandom(mins[2], maxs[2]);
 931                 VectorSubtract(o, center, v);
 932                 VectorNormalizeFast(v);
 933                 VectorScale(v, 100, v);
 934                 v[2] += sv_gravity.value * 0.15f;
 935                 particle(pt_static, PARTICLE_BILLBOARD, 0x903010, 0xFFD030, tex_particle, false, PBLEND_ADD, 1.5, 1.5, lhrandom(64, 128) / cl_particles_quality.value, 128 / cl_particles_quality.value, 9999, 1, 0, o[0], o[1], o[2], v[0], v[1], v[2], 0, 0, 0, 0, 0, 0);
 936         }
 937 }
 938
 939 void CL_FlameCube (vec3_t mins, vec3_t maxs, int count)
 940 {
 941         int k;
 942         float t;
 943         if (!cl_particles.integer) return;
 944         if (maxs[0] <= mins[0]) {t = mins[0];mins[0] = maxs[0];maxs[0] = t;}
 945         if (maxs[1] <= mins[1]) {t = mins[1];mins[1] = maxs[1];maxs[1] = t;}
 946         if (maxs[2] <= mins[2]) {t = mins[2];mins[2] = maxs[2];maxs[2] = t;}
 947
 948         count *= cl_particles_quality.value;
 949         while (count--)
 950         {
 951                 k = particlepalette[224 + (rand()&15)];
 952                 particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ADD, 4, 4, lhrandom(64, 128) / cl_particles_quality.value, 384 / cl_particles_quality.value, 9999, -1, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(mins[2], maxs[2]), lhrandom(-32, 32), lhrandom(-32, 32), lhrandom(0, 64), 0, 0, 0, 0, 1, 0);
 953                 if (count & 1)
 954                         particle(pt_static, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], false, PBLEND_ADD, 6, 6, lhrandom(48, 96) / cl_particles_quality.value, 64 / cl_particles_quality.value, 9999, 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(mins[2], maxs[2]), lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(0, 32), 0, 0, 0, 0, 0, 0);
 955         }
 956 }
 957
 958 void CL_Flames (vec3_t org, vec3_t vel, int count)
 959 {
 960         int k;
 961         if (!cl_particles.integer) return;
 962
 963         count *= cl_particles_quality.value;
 964         while (count--)
 965         {
 966                 k = particlepalette[224 + (rand()&15)];
 967                 particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ADD, 4, 4, lhrandom(64, 128) / cl_particles_quality.value, 384 / cl_particles_quality.value, 9999, -1, 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, 1, 0);
 968         }
 969 }
 970
 971
 972
 973 /*
 974 ===============
 975 CL_LavaSplash
 976
 977 ===============
 978 */
 979 void CL_LavaSplash (vec3_t origin)
 980 {
 981         float i, j, inc, vel;
 982         int k, l;
 983         vec3_t          dir, org;
 984         if (!cl_particles.integer) return;
 985
 986         inc = 32 / cl_particles_quality.value;
 987         for (i = -128;i < 128;i += inc)
 988         {
 989                 for (j = -128;j < 128;j += inc)
 990                 {
 991                         dir[0] = j + lhrandom(0, 8);
 992                         dir[1] = i + lhrandom(0, 8);
 993                         dir[2] = 256;
 994                         org[0] = origin[0] + dir[0];
 995                         org[1] = origin[1] + dir[1];
 996                         org[2] = origin[2] + lhrandom(0, 64);
 997                         vel = lhrandom(50, 120) / VectorLength(dir); // normalize and scale
 998                         if (gamemode == GAME_GOODVSBAD2)
 999                         {
1000                                 k = particlepalette[0 + (rand()&255)];
1001                                 l = particlepalette[0 + (rand()&255)];
1002                                 particle(pt_static, PARTICLE_BILLBOARD, k, l, tex_particle, false, PBLEND_ADD, 12, 12, inc * 8, inc * 8, 9999, 0.05, 1, org[0], org[1], org[2], dir[0] * vel, dir[1] * vel, dir[2] * vel, 0, 0, 0, 0, 0, 0);
1003                         }
1004                         else
1005                         {
1006                                 k = l = particlepalette[224 + (rand()&7)];
1007                                 particle(pt_static, PARTICLE_BILLBOARD, k, l, tex_particle, false, PBLEND_ADD, 12, 12, inc * 8, inc * 8, 9999, 0.05, 0, org[0], org[1], org[2], dir[0] * vel, dir[1] * vel, dir[2] * vel, 0, 0, 0, 0, 0, 0);
1008                         }
1009                 }
1010         }
1011 }
1012
1013 /*
1014 ===============
1015 CL_TeleportSplash
1016
1017 ===============
1018 */
1019 #if WORKINGLQUAKE
1020 void R_TeleportSplash (vec3_t org)
1021 {
1022         float i, j, k, inc;
1023         if (!cl_particles.integer) return;
1024
1025         inc = 8 / cl_particles_quality.value;
1026         for (i = -16;i < 16;i += inc)
1027                 for (j = -16;j < 16;j += inc)
1028                         for (k = -24;k < 32;k += inc)
1029                                 particle(pt_static, PARTICLE_BILLBOARD, 0xA0A0A0, 0xFFFFFF, tex_particle, false, PBLEND_ADD, 10, 10, inc * 32, inc * lhrandom(8, 16), inc * 32, 9999, 0, 0, org[0] + i + lhrandom(0, 8), org[1] + j + lhrandom(0, 8), org[2] + k + lhrandom(0, 8), lhrandom(-64, 64), lhrandom(-64, 64), lhrandom(-256, 256), 0, 0, 0, 0, 1, 0);
1030 }
1031 #endif
1032
1033 #ifdef WORKINGLQUAKE
1034 void R_RocketTrail (vec3_t start, vec3_t end, int type)
1035 #else
1036 void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent)
1037 #endif
1038 {
1039         vec3_t vec, dir, vel, pos;
1040         float len, dec, speed, qd;
1041         int contents, smoke, blood, bubbles;
1042
1043         if (end[0] == start[0] && end[1] == start[1] && end[2] == start[2])
1044                 return;
1045
1046         VectorSubtract(end, start, dir);
1047         VectorNormalize(dir);
1048
1049         VectorSubtract (end, start, vec);
1050 #ifdef WORKINGLQUAKE
1051         len = VectorNormalize (vec);
1052         dec = 0;
1053         speed = 1.0f / cl.frametime;
1054         VectorSubtract(end, start, vel);
1055 #else
1056         len = VectorNormalizeLength (vec);
1057         dec = -ent->persistent.trail_time;
1058         ent->persistent.trail_time += len;
1059         if (ent->persistent.trail_time < 0.01f)
1060                 return;
1061
1062         // if we skip out, leave it reset
1063         ent->persistent.trail_time = 0.0f;
1064
1065         speed = 1.0f / (ent->state_current.time - ent->state_previous.time);
1066         VectorSubtract(ent->state_current.origin, ent->state_previous.origin, vel);
1067 #endif
1068         VectorScale(vel, speed, vel);
1069
1070         // advance into this frame to reach the first puff location
1071         VectorMA(start, dec, vec, pos);
1072         len -= dec;
1073
1074         contents = CL_PointQ1Contents(pos);
1075         if (contents == CONTENTS_SKY || contents == CONTENTS_LAVA)
1076                 return;
1077
1078         smoke = cl_particles.integer && cl_particles_smoke.integer;
1079         blood = cl_particles.integer && cl_particles_blood.integer;
1080         bubbles = cl_particles.integer && cl_particles_bubbles.integer && (contents == CONTENTS_WATER || contents == CONTENTS_SLIME);
1081         qd = 1.0f / cl_particles_quality.value;
1082
1083         while (len >= 0)
1084         {
1085                 switch (type)
1086                 {
1087                         case 0: // rocket trail
1088                                 dec = qd*3;
1089                                 if (smoke)
1090                                 {
1091                                         particle(pt_grow,   PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], false, PBLEND_ADD, 3, 3, qd*cl_particles_smoke_alpha.value*125, qd*cl_particles_smoke_alphafade.value*125, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-5, 5), lhrandom(-5, 5), lhrandom(-5, 5), 7, 0, 0, 0, 0, 0);
1092                                         particle(pt_static, PARTICLE_BILLBOARD, 0x801010, 0xFFA020, tex_smoke[rand()&7], false, PBLEND_ADD, 3, 3, qd*cl_particles_smoke_alpha.value*288, qd*cl_particles_smoke_alphafade.value*1400, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-20, 20), lhrandom(-20, 20), lhrandom(-20, 20), 0, 0, 0, 0, 0, 0);
1093                                 }
1094                                 if (bubbles)
1095                                         particle(pt_bubble, PARTICLE_BILLBOARD, 0x404040, 0x808080, tex_bubble, false, PBLEND_ADD, 2, 2, qd*lhrandom(64, 255), qd*256, 9999, -0.25, 1.5, pos[0], pos[1], pos[2], lhrandom(-16, 16), lhrandom(-16, 16), lhrandom(-16, 16), 0, 0, 0, 0, (1.0 / 16.0), 0);
1096                                 break;
1097
1098                         case 1: // grenade trail
1099                                 // FIXME: make it gradually stop smoking
1100                                 dec = qd*3;
1101                                 if (smoke)
1102                                         particle(pt_grow, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], false, PBLEND_ADD, 3, 3, qd*cl_particles_smoke_alpha.value*100, qd*cl_particles_smoke_alphafade.value*100, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-5, 5), lhrandom(-5, 5), lhrandom(-5, 5), 7, 0, 0, 0, 0, 0);
1103                                 break;
1104
1105
1106                         case 2: // blood
1107                         case 4: // slight blood
1108                                 dec = qd*16;
1109                                 if (blood)
1110                                         particle(pt_blood, PARTICLE_BILLBOARD, 0xFFFFFF, 0xFFFFFF, tex_bloodparticle[rand()&7], true, PBLEND_MOD, 8, 8, qd * cl_particles_blood_alpha.value * 768.0f, qd * cl_particles_blood_alpha.value * 384.0f, 9999, 0, -1, pos[0], pos[1], pos[2], vel[0] * 0.5f + lhrandom(-64, 64), vel[1] * 0.5f + lhrandom(-64, 64), vel[2] * 0.5f + lhrandom(-64, 64), 0, 0, 0, 0, 1, 0);
1111                                 break;
1112
1113                         case 3: // green tracer
1114                                 dec = qd*6;
1115                                 if (smoke)
1116                                 {
1117                                         if (gamemode == GAME_GOODVSBAD2)
1118                                                 particle(pt_static, PARTICLE_BILLBOARD, 0x00002E, 0x000030, tex_particle, false, PBLEND_ADD, 6, 6, qd*128, qd*384, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 0, 0, 0, 0, 0, 0);
1119                                         else
1120                                                 particle(pt_static, PARTICLE_BILLBOARD, 0x002000, 0x003000, tex_particle, false, PBLEND_ADD, 6, 6, qd*128, qd*384, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 0, 0, 0, 0, 0, 0);
1121                                 }
1122                                 break;
1123
1124                         case 5: // flame tracer
1125                                 dec = qd*6;
1126                                 if (smoke)
1127                                         particle(pt_static, PARTICLE_BILLBOARD, 0x301000, 0x502000, tex_particle, false, PBLEND_ADD, 6, 6, qd*128, qd*384, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 0, 0, 0, 0, 0, 0);
1128                                 break;
1129
1130                         case 6: // voor trail
1131                                 dec = qd*6;
1132                                 if (smoke)
1133                                 {
1134                                         if (gamemode == GAME_GOODVSBAD2)
1135                                                 particle(pt_static, PARTICLE_BILLBOARD, particlepalette[0 + (rand()&255)], particlepalette[0 + (rand()&255)], tex_particle, false, PBLEND_ALPHA, 6, 6, qd*255, qd*384, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 0, 0, 0, 0, 0, 0);
1136                                         else
1137                                                 particle(pt_static, PARTICLE_BILLBOARD, 0x502030, 0x502030, tex_particle, false, PBLEND_ADD, 6, 6, qd*128, qd*384, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 0, 0, 0, 0, 0, 0);
1138                                 }
1139                                 break;
1140
1141                         case 7: // Nehahra smoke tracer
1142                                 dec = qd*7;
1143                                 if (smoke)
1144                                         particle(pt_static, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], true, PBLEND_ALPHA, 7, 7, qd*64, qd*320, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-4, 4), lhrandom(-4, 4), lhrandom(0, 16), 0, 0, 0, 0, 0, 0);
1145                                 break;
1146                         case 8: // Nexuiz plasma trail
1147                                 dec = qd*4;
1148                                 if (smoke)
1149                                         particle(pt_static, PARTICLE_BILLBOARD, 0x283880, 0x283880, tex_particle, false, PBLEND_ADD, 4, 4, qd*255, qd*1024, 9999, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
1150                                 break;
1151                 }
1152
1153                 // advance to next time and position
1154                 len -= dec;
1155                 VectorMA (pos, dec, vec, pos);
1156         }
1157 #ifndef WORKINGLQUAKE
1158         ent->persistent.trail_time = len;
1159 #endif
1160 }
1161
1162 void CL_RocketTrail2 (vec3_t start, vec3_t end, int color, entity_t *ent)
1163 {
1164         float dec, len;
1165         vec3_t vec, pos;
1166         if (!cl_particles.integer) return;
1167         if (!cl_particles_smoke.integer) return;
1168
1169         VectorCopy(start, pos);
1170         VectorSubtract(end, start, vec);
1171 #ifdef WORKINGLQUAKE
1172         len = VectorNormalize(vec);
1173 #else
1174         len = VectorNormalizeLength(vec);
1175 #endif
1176         color = particlepalette[color];
1177         dec = 3.0f / cl_particles_quality.value;
1178         while (len > 0)
1179         {
1180                 particle(pt_static, PARTICLE_BILLBOARD, color, color, tex_particle, false, PBLEND_ALPHA, 5, 5, 128 / cl_particles_quality.value, 320 / cl_particles_quality.value, 9999, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
1181                 len -= dec;
1182                 VectorMA(pos, dec, vec, pos);
1183         }
1184 }
1185
1186 void CL_BeamParticle (const vec3_t start, const vec3_t end, vec_t radius, float red, float green, float blue, float alpha, float lifetime)
1187 {
1188         int tempcolor2, cr, cg, cb;
1189         cr = red * 255;
1190         cg = green * 255;
1191         cb = blue * 255;
1192         tempcolor2 = (bound(0, cr, 255) << 16) | (bound(0, cg, 255) << 8) | bound(0, cb, 255);
1193         particle(pt_static, PARTICLE_BEAM, tempcolor2, tempcolor2, tex_beam, false, PBLEND_ADD, radius, radius, alpha * 255, alpha * 255 / lifetime, 9999, 0, 0, start[0], start[1], start[2], 0, 0, 0, 0, end[0], end[1], end[2], 0, 0);
1194 }
1195
1196 void CL_Tei_Smoke(const vec3_t org, const vec3_t dir, int count)
1197 {
1198         float f;
1199         if (!cl_particles.integer) return;
1200
1201         // smoke puff
1202         if (cl_particles_smoke.integer)
1203                 for (f = 0;f < count;f += 4.0f / cl_particles_quality.value)
1204                         particle(pt_grow, PARTICLE_BILLBOARD, 0x202020, 0x404040, tex_smoke[rand()&7], true, PBLEND_ADD, 5, 5, 255 / cl_particles_quality.value, 512 / cl_particles_quality.value, 9999, 0, 0, org[0] + 0.125f * lhrandom(-count, count), org[1] + 0.125f * lhrandom (-count, count), org[2] + 0.125f * lhrandom(-count, count), dir[0] + lhrandom(-count, count) * 0.5f, dir[1] + lhrandom(-count, count) * 0.5f, dir[2] + lhrandom(-count, count) * 0.5f, 15, 0, 0, 0, 0, 0);
1205 }
1206
1207 void CL_Tei_PlasmaHit(const vec3_t org, const vec3_t dir, int count)
1208 {
1209         float f;
1210         if (!cl_particles.integer) return;
1211
1212         if (cl_stainmaps.integer)
1213                 R_Stain(org, 40, 96, 96, 96, 40, 128, 128, 128, 40);
1214         CL_SpawnDecalParticleForPoint(org, 6, 8, 255, tex_bulletdecal[rand()&7], 0xFFFFFF, 0xFFFFFF);
1215
1216         // smoke puff
1217         if (cl_particles_smoke.integer)
1218                 for (f = 0;f < count;f += 4.0f / cl_particles_quality.value)
1219                         particle(pt_grow, PARTICLE_BILLBOARD, 0x202020, 0x404040, tex_smoke[rand()&7], true, PBLEND_ADD, 5, 5, 255 / cl_particles_quality.value, 512 / cl_particles_quality.value, 9999, 0, 0, org[0] + 0.125f * lhrandom(-count, count), org[1] + 0.125f * lhrandom (-count, count), org[2] + 0.125f * lhrandom(-count, count), dir[0] + lhrandom(-count, count), dir[1] + lhrandom(-count, count), dir[2] + lhrandom(-count, count), 15, 0, 0, 0, 0, 0);
1220
1221         // sparks
1222         if (cl_particles_sparks.integer)
1223                 for (f = 0;f < count;f += 1.0f / cl_particles_quality.value)
1224                         particle(pt_static, PARTICLE_SPARK, 0x2030FF, 0x80C0FF, tex_particle, false, PBLEND_ADD, 2.0f, 0.1f, lhrandom(64, 255) / cl_particles_quality.value, 512 / cl_particles_quality.value, 9999, 0, 0, org[0], org[1], org[2], lhrandom(-count, count) * 3.0f + dir[0], lhrandom(-count, count) * 3.0f + dir[1], lhrandom(-count, count) * 3.0f + dir[2], 0, 0, 0, 0, 0, 0);
1225 }
1226
1227 /*
1228 ===============
1229 CL_MoveParticles
1230 ===============
1231 */
1232 void CL_MoveParticles (void)
1233 {
1234         particle_t *p;
1235         int i, activeparticles, maxparticle, j, a, pressureused = false, content;
1236         float gravity, dvel, bloodwaterfade, frametime, f, dist, normal[3], v[3], org[3];
1237 #ifdef WORKINGLQUAKE
1238         void *hitent;
1239 #else
1240         entity_render_t *hitent;
1241 #endif
1242
1243         // LordHavoc: early out condition
1244         if (!cl_numparticles)
1245                 return;
1246
1247 #ifdef WORKINGLQUAKE
1248         frametime = cl.frametime;
1249 #else
1250         frametime = cl.time - cl.oldtime;
1251 #endif
1252         gravity = frametime * sv_gravity.value;
1253         dvel = 1+4*frametime;
1254         bloodwaterfade = max(cl_particles_blood_alpha.value, 0.01f) * frametime * 128.0f;
1255
1256         activeparticles = 0;
1257         maxparticle = -1;
1258         j = 0;
1259         for (i = 0, p = particles;i < cl_numparticles;i++, p++)
1260         {
1261                 content = 0;
1262                 VectorCopy(p->org, p->oldorg);
1263                 VectorMA(p->org, frametime, p->vel, p->org);
1264                 VectorCopy(p->org, org);
1265                 if (p->bounce)
1266                 {
1267                         if (CL_TraceLine(p->oldorg, p->org, v, normal, true, &hitent, SUPERCONTENTS_SOLID) < 1)
1268                         {
1269                                 VectorCopy(v, p->org);
1270                                 if (p->bounce < 0)
1271                                 {
1272                                         // assume it's blood (lame, but...)
1273 #ifndef WORKINGLQUAKE
1274                                         if (cl_stainmaps.integer)
1275                                                 R_Stain(v, 32, 32, 16, 16, p->alpha * p->scalex * (1.0f / 40.0f), 192, 48, 48, p->alpha * p->scalex * (1.0f / 40.0f));
1276 #endif
1277                                         if (cl_decals.integer)
1278                                         {
1279                                                 p->type = pt_decal;
1280                                                 p->orientation = PARTICLE_ORIENTED_DOUBLESIDED;
1281                                                 // convert from a blood particle to a blood decal
1282                                                 p->texnum = tex_blooddecal[rand()&7];
1283 #ifndef WORKINGLQUAKE
1284                                                 p->owner = hitent;
1285                                                 p->ownermodel = hitent->model;
1286                                                 Matrix4x4_Transform(&hitent->inversematrix, v, p->relativeorigin);
1287                                                 Matrix4x4_Transform3x3(&hitent->inversematrix, normal, p->relativedirection);
1288                                                 VectorAdd(p->relativeorigin, p->relativedirection, p->relativeorigin);
1289 #endif
1290                                                 p->time2 = cl.time + cl_decals_time.value;
1291                                                 p->die = p->time2 + cl_decals_fadetime.value;
1292                                                 p->alphafade = 0;
1293                                                 VectorCopy(normal, p->vel2);
1294                                                 VectorClear(p->vel);
1295                                                 VectorAdd(p->org, normal, p->org);
1296                                                 p->bounce = 0;
1297                                                 p->friction = 0;
1298                                                 p->gravity = 0;
1299                                                 p->scalex *= 1.25f;
1300                                                 p->scaley *= 1.25f;
1301                                         }
1302                                         else
1303                                         {
1304                                                 p->die = -1;
1305                                                 freeparticles[j++] = p;
1306                                                 continue;
1307                                         }
1308                                 }
1309                                 else
1310                                 {
1311                                         dist = DotProduct(p->vel, normal) * -p->bounce;
1312                                         VectorMA(p->vel, dist, normal, p->vel);
1313                                         if (DotProduct(p->vel, p->vel) < 0.03)
1314                                                 VectorClear(p->vel);
1315                                 }
1316                         }
1317                 }
1318                 p->vel[2] -= p->gravity * gravity;
1319                 p->alpha -= p->alphafade * frametime;
1320                 if (p->friction)
1321                 {
1322                         f = p->friction * frametime;
1323                         if (!content)
1324                                 content = CL_PointQ1Contents(p->org);
1325                         if (content != CONTENTS_EMPTY)
1326                                 f *= 4;
1327                         f = 1.0f - f;
1328                         VectorScale(p->vel, f, p->vel);
1329                 }
1330
1331                 if (p->type != pt_static)
1332                 {
1333                         switch (p->type)
1334                         {
1335                         case pt_blood:
1336                                 if (!content)
1337                                         content = CL_PointQ1Contents(p->org);
1338                                 a = content;
1339                                 if (a != CONTENTS_EMPTY)
1340                                 {
1341                                         if (a == CONTENTS_WATER || a == CONTENTS_SLIME)
1342                                         {
1343                                                 p->scalex += frametime * 8;
1344                                                 p->scaley += frametime * 8;
1345                                                 //p->alpha -= bloodwaterfade;
1346                                         }
1347                                         else
1348                                                 p->die = -1;
1349                                 }
1350                                 else
1351                                         p->vel[2] -= gravity;
1352                                 break;
1353                         case pt_bubble:
1354                                 if (!content)
1355                                         content = CL_PointQ1Contents(p->org);
1356                                 if (content != CONTENTS_WATER && content != CONTENTS_SLIME)
1357                                 {
1358                                         p->die = -1;
1359                                         break;
1360                                 }
1361                                 break;
1362                         case pt_rain:
1363                                 if (cl.time > p->time2)
1364                                 {
1365                                         // snow flutter
1366                                         p->time2 = cl.time + (rand() & 3) * 0.1;
1367                                         p->vel[0] = lhrandom(-32, 32) + p->vel2[0];
1368                                         p->vel[1] = lhrandom(-32, 32) + p->vel2[1];
1369                                         p->vel[2] = /*lhrandom(-32, 32) +*/ p->vel2[2];
1370                                 }
1371                                 if (!content)
1372                                         content = CL_PointQ1Contents(p->org);
1373                                 a = content;
1374                                 if (a != CONTENTS_EMPTY && a != CONTENTS_SKY)
1375                                         p->die = -1;
1376                                 break;
1377                         case pt_grow:
1378                                 p->scalex += frametime * p->time2;
1379                                 p->scaley += frametime * p->time2;
1380                                 break;
1381                         case pt_decal:
1382 #ifndef WORKINGLQUAKE
1383                                 if (p->owner->model == p->ownermodel)
1384                                 {
1385                                         Matrix4x4_Transform(&p->owner->matrix, p->relativeorigin, p->org);
1386                                         Matrix4x4_Transform3x3(&p->owner->matrix, p->relativedirection, p->vel2);
1387                                 }
1388                                 else
1389                                         p->die = -1;
1390 #endif
1391                                 if (cl.time > p->time2)
1392                                 {
1393                                         p->alphafade = p->alpha / (p->die - cl.time);
1394                                         p->type = pt_decalfade;
1395                                 }
1396                                 break;
1397                         case pt_decalfade:
1398 #ifndef WORKINGLQUAKE
1399                                 if (p->owner->model == p->ownermodel)
1400                                 {
1401                                         Matrix4x4_Transform(&p->owner->matrix, p->relativeorigin, p->org);
1402                                         Matrix4x4_Transform3x3(&p->owner->matrix, p->relativedirection, p->vel2);
1403                                 }
1404                                 else
1405                                         p->die = -1;
1406 #endif
1407                                 break;
1408                         default:
1409                                 Con_Printf("unknown particle type %i\n", p->type);
1410                                 p->die = -1;
1411                                 break;
1412                         }
1413                 }
1414
1415                 // remove dead particles
1416                 if (p->alpha < 1 || p->die < cl.time)
1417                         freeparticles[j++] = p;
1418                 else
1419                 {
1420                         maxparticle = i;
1421                         activeparticles++;
1422                         if (p->pressure)
1423                                 pressureused = true;
1424                 }
1425         }
1426         // fill in gaps to compact the array
1427         i = 0;
1428         while (maxparticle >= activeparticles)
1429         {
1430                 *freeparticles[i++] = particles[maxparticle--];
1431                 while (maxparticle >= activeparticles && particles[maxparticle].die < cl.time)
1432                         maxparticle--;
1433         }
1434         cl_numparticles = activeparticles;
1435
1436         if (pressureused)
1437         {
1438                 activeparticles = 0;
1439                 for (i = 0, p = particles;i < cl_numparticles;i++, p++)
1440                         if (p->pressure)
1441                                 freeparticles[activeparticles++] = p;
1442
1443                 if (activeparticles)
1444                 {
1445                         for (i = 0, p = particles;i < cl_numparticles;i++, p++)
1446                         {
1447                                 for (j = 0;j < activeparticles;j++)
1448                                 {
1449                                         if (freeparticles[j] != p)
1450                                         {
1451                                                 float dist, diff[3];
1452                                                 VectorSubtract(p->org, freeparticles[j]->org, diff);
1453                                                 dist = DotProduct(diff, diff);
1454                                                 if (dist < 4096 && dist >= 1)
1455                                                 {
1456                                                         dist = freeparticles[j]->scalex * 4.0f * frametime / sqrt(dist);
1457                                                         VectorMA(p->vel, dist, diff, p->vel);
1458                                                 }
1459                                         }
1460                                 }
1461                         }
1462                 }
1463         }
1464 }
1465
1466 #define MAX_PARTICLETEXTURES 64
1467 // particletexture_t is a rectangle in the particlefonttexture
1468 typedef struct
1469 {
1470         rtexture_t *texture;
1471         float s1, t1, s2, t2;
1472 }
1473 particletexture_t;
1474
1475 #if WORKINGLQUAKE
1476 static int particlefonttexture;
1477 #else
1478 static rtexturepool_t *particletexturepool;
1479 static rtexture_t *particlefonttexture;
1480 #endif
1481 static particletexture_t particletexture[MAX_PARTICLETEXTURES];
1482
1483 static cvar_t r_drawparticles = {0, "r_drawparticles", "1"};
1484
1485 static qbyte shadebubble(float dx, float dy, vec3_t light)
1486 {
1487         float dz, f, dot;
1488         vec3_t normal;
1489         dz = 1 - (dx*dx+dy*dy);
1490         if (dz > 0) // it does hit the sphere
1491         {
1492                 f = 0;
1493                 // back side
1494                 normal[0] = dx;normal[1] = dy;normal[2] = dz;
1495                 VectorNormalize(normal);
1496                 dot = DotProduct(normal, light);
1497                 if (dot > 0.5) // interior reflection
1498                         f += ((dot *  2) - 1);
1499                 else if (dot < -0.5) // exterior reflection
1500                         f += ((dot * -2) - 1);
1501                 // front side
1502                 normal[0] = dx;normal[1] = dy;normal[2] = -dz;
1503                 VectorNormalize(normal);
1504                 dot = DotProduct(normal, light);
1505                 if (dot > 0.5) // interior reflection
1506                         f += ((dot *  2) - 1);
1507                 else if (dot < -0.5) // exterior reflection
1508                         f += ((dot * -2) - 1);
1509                 f *= 128;
1510                 f += 16; // just to give it a haze so you can see the outline
1511                 f = bound(0, f, 255);
1512                 return (qbyte) f;
1513         }
1514         else
1515                 return 0;
1516 }
1517
1518 static void setuptex(int texnum, qbyte *data, qbyte *particletexturedata)
1519 {
1520         int basex, basey, y;
1521         basex = ((texnum >> 0) & 7) * 32;
1522         basey = ((texnum >> 3) & 7) * 32;
1523         particletexture[texnum].s1 = (basex + 1) / 256.0f;
1524         particletexture[texnum].t1 = (basey + 1) / 256.0f;
1525         particletexture[texnum].s2 = (basex + 31) / 256.0f;
1526         particletexture[texnum].t2 = (basey + 31) / 256.0f;
1527         for (y = 0;y < 32;y++)
1528                 memcpy(particletexturedata + ((basey + y) * 256 + basex) * 4, data + y * 32 * 4, 32 * 4);
1529 }
1530
1531 void particletextureblotch(qbyte *data, float radius, float red, float green, float blue, float alpha)
1532 {
1533         int x, y;
1534         float cx, cy, dx, dy, f, iradius;
1535         qbyte *d;
1536         cx = lhrandom(radius + 1, 30 - radius);
1537         cy = lhrandom(radius + 1, 30 - radius);
1538         iradius = 1.0f / radius;
1539         alpha *= (1.0f / 255.0f);
1540         for (y = 0;y < 32;y++)
1541         {
1542                 for (x = 0;x < 32;x++)
1543                 {
1544                         dx = (x - cx);
1545                         dy = (y - cy);
1546                         f = (1.0f - sqrt(dx * dx + dy * dy) * iradius) * alpha;
1547                         if (f > 0)
1548                         {
1549                                 d = data + (y * 32 + x) * 4;
1550                                 d[0] += f * (red   - d[0]);
1551                                 d[1] += f * (green - d[1]);
1552                                 d[2] += f * (blue  - d[2]);
1553                         }
1554                 }
1555         }
1556 }
1557
1558 void particletextureclamp(qbyte *data, int minr, int ming, int minb, int maxr, int maxg, int maxb)
1559 {
1560         int i;
1561         for (i = 0;i < 32*32;i++, data += 4)
1562         {
1563                 data[0] = bound(minr, data[0], maxr);
1564                 data[1] = bound(ming, data[1], maxg);
1565                 data[2] = bound(minb, data[2], maxb);
1566         }
1567 }
1568
1569 void particletextureinvert(qbyte *data)
1570 {
1571         int i;
1572         for (i = 0;i < 32*32;i++, data += 4)
1573         {
1574                 data[0] = 255 - data[0];
1575                 data[1] = 255 - data[1];
1576                 data[2] = 255 - data[2];
1577         }
1578 }
1579
1580 static void R_InitParticleTexture (void)
1581 {
1582         int x, y, d, i, j, k, m;
1583         float dx, dy, radius, f, f2;
1584         qbyte data[32][32][4], noise1[64][64], noise2[64][64], data2[64][16][4];
1585         vec3_t light;
1586         qbyte particletexturedata[256*256*4];
1587
1588         // a note: decals need to modulate (multiply) the background color to
1589         // properly darken it (stain), and they need to be able to alpha fade,
1590         // this is a very difficult challenge because it means fading to white
1591         // (no change to background) rather than black (darkening everything
1592         // behind the whole decal polygon), and to accomplish this the texture is
1593         // inverted (dark red blood on white background becomes brilliant cyan
1594         // and white on black background) so we can alpha fade it to black, then
1595         // we invert it again during the blendfunc to make it work...
1596
1597         memset(particletexturedata, 255, sizeof(particletexturedata));
1598
1599         // smoke
1600         for (i = 0;i < 8;i++)
1601         {
1602                 memset(&data[0][0][0], 255, sizeof(data));
1603                 do
1604                 {
1605                         fractalnoise(&noise1[0][0], 64, 4);
1606                         fractalnoise(&noise2[0][0], 64, 8);
1607                         m = 0;
1608                         for (y = 0;y < 32;y++)
1609                         {
1610                                 dy = y - 16;
1611                                 for (x = 0;x < 32;x++)
1612                                 {
1613                                         dx = x - 16;
1614                                         d = (noise2[y][x] - 128) * 3 + 192;
1615                                         if (d > 0)
1616                                                 d = d * (256 - (int) (dx*dx+dy*dy)) / 256;
1617                                         d = (d * noise1[y][x]) >> 7;
1618                                         d = bound(0, d, 255);
1619                                         data[y][x][3] = (qbyte) d;
1620                                         if (m < d)
1621                                                 m = d;
1622                                 }
1623                         }
1624                 }
1625                 while (m < 224);
1626                 setuptex(tex_smoke[i], &data[0][0][0], particletexturedata);
1627         }
1628
1629         // rain splash
1630         for (i = 0;i < 16;i++)
1631         {
1632                 memset(&data[0][0][0], 255, sizeof(data));
1633                 radius = i * 3.0f / 16.0f;
1634                 f2 = 255.0f * ((15.0f - i) / 15.0f);
1635                 for (y = 0;y < 32;y++)
1636                 {
1637                         dy = (y - 16) * 0.25f;
1638                         for (x = 0;x < 32;x++)
1639                         {
1640                                 dx = (x - 16) * 0.25f;
1641                                 f = (1.0 - fabs(radius - sqrt(dx*dx+dy*dy))) * f2;
1642                                 data[y][x][3] = (int) (bound(0.0f, f, 255.0f));
1643                         }
1644                 }
1645                 setuptex(tex_rainsplash[i], &data[0][0][0], particletexturedata);
1646         }
1647
1648         // normal particle
1649         memset(&data[0][0][0], 255, sizeof(data));
1650         for (y = 0;y < 32;y++)
1651         {
1652                 dy = y - 16;
1653                 for (x = 0;x < 32;x++)
1654                 {
1655                         dx = x - 16;
1656                         d = (256 - (dx*dx+dy*dy));
1657                         d = bound(0, d, 255);
1658                         data[y][x][3] = (qbyte) d;
1659                 }
1660         }
1661         setuptex(tex_particle, &data[0][0][0], particletexturedata);
1662
1663         // rain
1664         memset(&data[0][0][0], 255, sizeof(data));
1665         light[0] = 1;light[1] = 1;light[2] = 1;
1666         VectorNormalize(light);
1667         for (y = 0;y < 32;y++)
1668                 for (x = 0;x < 32;x++)
1669                         data[y][x][3] = shadebubble((x - 16) * (1.0 / 8.0), y < 24 ? (y - 24) * (1.0 / 24.0) : (y - 24) * (1.0 / 8.0), light);
1670         setuptex(tex_raindrop, &data[0][0][0], particletexturedata);
1671
1672         // bubble
1673         memset(&data[0][0][0], 255, sizeof(data));
1674         light[0] = 1;light[1] = 1;light[2] = 1;
1675         VectorNormalize(light);
1676         for (y = 0;y < 32;y++)
1677                 for (x = 0;x < 32;x++)
1678                         data[y][x][3] = shadebubble((x - 16) * (1.0 / 16.0), (y - 16) * (1.0 / 16.0), light);
1679         setuptex(tex_bubble, &data[0][0][0], particletexturedata);
1680
1681         // blood particles
1682         for (i = 0;i < 8;i++)
1683         {
1684                 memset(&data[0][0][0], 255, sizeof(data));
1685                 for (k = 0;k < 24;k++)
1686                         particletextureblotch(&data[0][0][0], 2, 96, 0, 0, 160);
1687                 //particletextureclamp(&data[0][0][0], 32, 32, 32, 255, 255, 255);
1688                 particletextureinvert(&data[0][0][0]);
1689                 setuptex(tex_bloodparticle[i], &data[0][0][0], particletexturedata);
1690         }
1691
1692         // blood decals
1693         for (i = 0;i < 8;i++)
1694         {
1695                 memset(&data[0][0][0], 255, sizeof(data));
1696                 for (k = 0;k < 24;k++)
1697                         particletextureblotch(&data[0][0][0], 2, 96, 0, 0, 96);
1698                 for (j = 3;j < 7;j++)
1699                         for (k = 0, m = rand() % 12;k < m;k++)
1700                                 particletextureblotch(&data[0][0][0], j, 96, 0, 0, 192);
1701                 //particletextureclamp(&data[0][0][0], 32, 32, 32, 255, 255, 255);
1702                 particletextureinvert(&data[0][0][0]);
1703                 setuptex(tex_blooddecal[i], &data[0][0][0], particletexturedata);
1704         }
1705
1706         // bullet decals
1707         for (i = 0;i < 8;i++)
1708         {
1709                 memset(&data[0][0][0], 255, sizeof(data));
1710                 for (k = 0;k < 12;k++)
1711                         particletextureblotch(&data[0][0][0], 2, 0, 0, 0, 128);
1712                 for (k = 0;k < 3;k++)
1713                         particletextureblotch(&data[0][0][0], 14, 0, 0, 0, 160);
1714                 //particletextureclamp(&data[0][0][0], 64, 64, 64, 255, 255, 255);
1715                 particletextureinvert(&data[0][0][0]);
1716                 setuptex(tex_bulletdecal[i], &data[0][0][0], particletexturedata);
1717         }
1718
1719 #if WORKINGLQUAKE
1720         glBindTexture(GL_TEXTURE_2D, (particlefonttexture = gl_extension_number++));
1721         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1722         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
1723 #else
1724         particlefonttexture = R_LoadTexture2D(particletexturepool, "particlefont", 256, 256, particletexturedata, TEXTYPE_RGBA, TEXF_ALPHA | TEXF_PRECACHE, NULL);
1725         for (i = 0;i < MAX_PARTICLETEXTURES;i++)
1726                 particletexture[i].texture = particlefonttexture;
1727
1728         // beam
1729         fractalnoise(&noise1[0][0], 64, 4);
1730         m = 0;
1731         for (y = 0;y < 64;y++)
1732         {
1733                 for (x = 0;x < 16;x++)
1734                 {
1735                         if (x < 8)
1736                                 d = x;
1737                         else
1738                                 d = (15 - x);
1739                         d = d * d * noise1[y][x] / (7 * 7);
1740                         data2[y][x][0] = data2[y][x][1] = data2[y][x][2] = (qbyte) bound(0, d, 255);
1741                         data2[y][x][3] = 255;
1742                 }
1743         }
1744
1745         particletexture[tex_beam].texture = R_LoadTexture2D(particletexturepool, "beam", 16, 64, &data2[0][0][0], TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
1746         particletexture[tex_beam].s1 = 0;
1747         particletexture[tex_beam].t1 = 0;
1748         particletexture[tex_beam].s2 = 1;
1749         particletexture[tex_beam].t2 = 1;
1750 #endif
1751 }
1752
1753 static void r_part_start(void)
1754 {
1755         particletexturepool = R_AllocTexturePool();
1756         R_InitParticleTexture ();
1757 }
1758
1759 static void r_part_shutdown(void)
1760 {
1761         R_FreeTexturePool(&particletexturepool);
1762 }
1763
1764 static void r_part_newmap(void)
1765 {
1766         cl_numparticles = 0;
1767 }
1768
1769 void R_Particles_Init (void)
1770 {
1771         Cvar_RegisterVariable(&r_drawparticles);
1772 #ifdef WORKINGLQUAKE
1773         r_part_start();
1774 #else
1775         R_RegisterModule("R_Particles", r_part_start, r_part_shutdown, r_part_newmap);
1776 #endif
1777 }
1778
1779 #ifdef WORKINGLQUAKE
1780 void R_InitParticles(void)
1781 {
1782         CL_Particles_Init();
1783         R_Particles_Init();
1784 }
1785 #endif
1786
1787 float particle_vertex3f[12], particle_texcoord2f[8];
1788
1789 #ifdef WORKINGLQUAKE
1790 void R_DrawParticle(particle_t *p)
1791 {
1792 #else
1793 void R_DrawParticleCallback(const void *calldata1, int calldata2)
1794 {
1795         const particle_t *p = calldata1;
1796         rmeshstate_t m;
1797 #endif
1798         float org[3], up2[3], v[3], right[3], up[3], fog, ifog, fogvec[3], cr, cg, cb, ca;
1799         particletexture_t *tex;
1800
1801         VectorCopy(p->org, org);
1802
1803         tex = &particletexture[p->texnum];
1804         cr = p->color[0] * (1.0f / 255.0f);
1805         cg = p->color[1] * (1.0f / 255.0f);
1806         cb = p->color[2] * (1.0f / 255.0f);
1807         ca = p->alpha * (1.0f / 255.0f);
1808         if (p->blendmode == PBLEND_MOD)
1809         {
1810                 cr *= ca;
1811                 cg *= ca;
1812                 cb *= ca;
1813                 cr = min(cr, 1);
1814                 cg = min(cg, 1);
1815                 cb = min(cb, 1);
1816                 ca = 1;
1817         }
1818
1819 #ifndef WORKINGLQUAKE
1820         if (fogenabled && p->blendmode != PBLEND_MOD)
1821         {
1822                 VectorSubtract(org, r_origin, fogvec);
1823                 fog = exp(fogdensity/DotProduct(fogvec,fogvec));
1824                 ifog = 1 - fog;
1825                 cr = cr * ifog;
1826                 cg = cg * ifog;
1827                 cb = cb * ifog;
1828                 if (p->blendmode == 0)
1829                 {
1830                         cr += fogcolor[0] * fog;
1831                         cg += fogcolor[1] * fog;
1832                         cb += fogcolor[2] * fog;
1833                 }
1834         }
1835         cr *= r_colorscale;
1836         cg *= r_colorscale;
1837         cb *= r_colorscale;
1838
1839         GL_Color(cr, cg, cb, ca);
1840
1841         R_Mesh_Matrix(&r_identitymatrix);
1842
1843         memset(&m, 0, sizeof(m));
1844         m.tex[0] = R_GetTexture(tex->texture);
1845         m.pointer_texcoord[0] = particle_texcoord2f;
1846         R_Mesh_State_Texture(&m);
1847
1848         if (p->blendmode == 0)
1849                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1850         else if (p->blendmode == 1)
1851                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
1852         else
1853                 GL_BlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
1854         GL_DepthMask(false);
1855         GL_DepthTest(true);
1856         GL_VertexPointer(particle_vertex3f);
1857 #endif
1858         if (p->orientation == PARTICLE_BILLBOARD || p->orientation == PARTICLE_ORIENTED_DOUBLESIDED)
1859         {
1860                 if (p->orientation == PARTICLE_ORIENTED_DOUBLESIDED)
1861                 {
1862                         // double-sided
1863                         if (DotProduct(p->vel2, r_origin) > DotProduct(p->vel2, org))
1864                         {
1865                                 VectorNegate(p->vel2, v);
1866                                 VectorVectors(v, right, up);
1867                         }
1868                         else
1869                                 VectorVectors(p->vel2, right, up);
1870                         VectorScale(right, p->scalex, right);
1871                         VectorScale(up, p->scaley, up);
1872                 }
1873                 else
1874                 {
1875                         VectorScale(vright, p->scalex, right);
1876                         VectorScale(vup, p->scaley, up);
1877                 }
1878                 particle_vertex3f[ 0] = org[0] - right[0] - up[0];
1879                 particle_vertex3f[ 1] = org[1] - right[1] - up[1];
1880                 particle_vertex3f[ 2] = org[2] - right[2] - up[2];
1881                 particle_vertex3f[ 3] = org[0] - right[0] + up[0];
1882                 particle_vertex3f[ 4] = org[1] - right[1] + up[1];
1883                 particle_vertex3f[ 5] = org[2] - right[2] + up[2];
1884                 particle_vertex3f[ 6] = org[0] + right[0] + up[0];
1885                 particle_vertex3f[ 7] = org[1] + right[1] + up[1];
1886                 particle_vertex3f[ 8] = org[2] + right[2] + up[2];
1887                 particle_vertex3f[ 9] = org[0] + right[0] - up[0];
1888                 particle_vertex3f[10] = org[1] + right[1] - up[1];
1889                 particle_vertex3f[11] = org[2] + right[2] - up[2];
1890                 particle_texcoord2f[0] = tex->s1;particle_texcoord2f[1] = tex->t2;
1891                 particle_texcoord2f[2] = tex->s1;particle_texcoord2f[3] = tex->t1;
1892                 particle_texcoord2f[4] = tex->s2;particle_texcoord2f[5] = tex->t1;
1893                 particle_texcoord2f[6] = tex->s2;particle_texcoord2f[7] = tex->t2;
1894         }
1895         else if (p->orientation == PARTICLE_SPARK)
1896         {
1897                 VectorMA(p->org, -p->scaley, p->vel, v);
1898                 VectorMA(p->org, p->scaley, p->vel, up2);
1899                 R_CalcBeam_Vertex3f(particle_vertex3f, v, up2, p->scalex);
1900                 particle_texcoord2f[0] = tex->s1;particle_texcoord2f[1] = tex->t2;
1901                 particle_texcoord2f[2] = tex->s1;particle_texcoord2f[3] = tex->t1;
1902                 particle_texcoord2f[4] = tex->s2;particle_texcoord2f[5] = tex->t1;
1903                 particle_texcoord2f[6] = tex->s2;particle_texcoord2f[7] = tex->t2;
1904         }
1905         else if (p->orientation == PARTICLE_BEAM)
1906         {
1907                 R_CalcBeam_Vertex3f(particle_vertex3f, p->org, p->vel2, p->scalex);
1908                 VectorSubtract(p->vel2, p->org, up);
1909                 VectorNormalizeFast(up);
1910                 v[0] = DotProduct(p->org, up) * (1.0f / 64.0f) - cl.time * 0.25;
1911                 v[1] = DotProduct(p->vel2, up) * (1.0f / 64.0f) - cl.time * 0.25;
1912                 particle_texcoord2f[0] = 1;particle_texcoord2f[1] = v[0];
1913                 particle_texcoord2f[2] = 0;particle_texcoord2f[3] = v[0];
1914                 particle_texcoord2f[4] = 0;particle_texcoord2f[5] = v[1];
1915                 particle_texcoord2f[6] = 1;particle_texcoord2f[7] = v[1];
1916         }
1917         else
1918                 Host_Error("R_DrawParticles: unknown particle orientation %i\n", p->orientation);
1919
1920 #if WORKINGLQUAKE
1921         if (p->blendmode == 0)
1922                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1923         else if (p->blendmode == 1)
1924                 glBlendFunc(GL_SRC_ALPHA, GL_ONE);
1925         else
1926                 glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
1927         glColor4f(cr, cg, cb, ca);
1928         glBegin(GL_QUADS);
1929         glTexCoord2f(particle_texcoord2f[0], particle_texcoord2f[1]);glVertex3f(particle_vertex3f[ 0], particle_vertex3f[ 1], particle_vertex3f[ 2]);
1930         glTexCoord2f(particle_texcoord2f[2], particle_texcoord2f[3]);glVertex3f(particle_vertex3f[ 3], particle_vertex3f[ 4], particle_vertex3f[ 5]);
1931         glTexCoord2f(particle_texcoord2f[4], particle_texcoord2f[5]);glVertex3f(particle_vertex3f[ 6], particle_vertex3f[ 7], particle_vertex3f[ 8]);
1932         glTexCoord2f(particle_texcoord2f[6], particle_texcoord2f[7]);glVertex3f(particle_vertex3f[ 9], particle_vertex3f[10], particle_vertex3f[11]);
1933         glEnd();
1934 #else
1935         R_Mesh_Draw(4, 2, polygonelements);
1936 #endif
1937 }
1938
1939 void R_DrawParticles (void)
1940 {
1941         int i;
1942         float minparticledist;
1943         particle_t *p;
1944
1945 #ifdef WORKINGLQUAKE
1946         CL_MoveParticles();
1947 #endif
1948
1949         // LordHavoc: early out conditions
1950         if ((!cl_numparticles) || (!r_drawparticles.integer))
1951                 return;
1952
1953         minparticledist = DotProduct(r_origin, vpn) + 4.0f;
1954
1955 #ifdef WORKINGLQUAKE
1956         glBindTexture(GL_TEXTURE_2D, particlefonttexture);
1957         glEnable(GL_BLEND);
1958         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
1959         glDepthMask(0);
1960         // LordHavoc: only render if not too close
1961         for (i = 0, p = particles;i < cl_numparticles;i++, p++)
1962                 if (DotProduct(p->org, vpn) >= minparticledist)
1963                         R_DrawParticle(p);
1964         glDepthMask(1);
1965         glDisable(GL_BLEND);
1966         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1967 #else
1968         // LordHavoc: only render if not too close
1969         c_particles += cl_numparticles;
1970         for (i = 0, p = particles;i < cl_numparticles;i++, p++)
1971                 if (DotProduct(p->org, vpn) >= minparticledist || p->orientation == PARTICLE_BEAM)
1972                         R_MeshQueue_AddTransparent(p->org, R_DrawParticleCallback, p, 0);
1973 #endif
1974 }
1975