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