Cleaned up alot more memory leaks. (still get 720 leaks just running demo1.dem)
[xonotic/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 void R_CalcBeam_Vertex3f (float *vert, vec3_t org1, vec3_t org2, float width)
44 {
45         vec3_t right1, right2, diff, normal;
46
47         VectorSubtract (org2, org1, normal);
48         VectorNormalizeFast (normal);
49
50         // calculate 'right' vector for start
51         VectorSubtract (r_vieworigin, org1, diff);
52         VectorNormalizeFast (diff);
53         CrossProduct (normal, diff, right1);
54
55         // calculate 'right' vector for end
56         VectorSubtract (r_vieworigin, org2, diff);
57         VectorNormalizeFast (diff);
58         CrossProduct (normal, diff, right2);
59
60         vert[ 0] = org1[0] + width * right1[0];
61         vert[ 1] = org1[1] + width * right1[1];
62         vert[ 2] = org1[2] + width * right1[2];
63         vert[ 3] = org1[0] - width * right1[0];
64         vert[ 4] = org1[1] - width * right1[1];
65         vert[ 5] = org1[2] - width * right1[2];
66         vert[ 6] = org2[0] - width * right2[0];
67         vert[ 7] = org2[1] - width * right2[1];
68         vert[ 8] = org2[2] - width * right2[2];
69         vert[ 9] = org2[0] + width * right2[0];
70         vert[10] = org2[1] + width * right2[1];
71         vert[11] = org2[2] + width * right2[2];
72 }
73 void fractalnoise(qbyte *noise, int size, int startgrid)
74 {
75         int x, y, g, g2, amplitude, min, max, size1 = size - 1, sizepower, gridpower;
76         int *noisebuf;
77 #define n(x,y) noisebuf[((y)&size1)*size+((x)&size1)]
78
79         for (sizepower = 0;(1 << sizepower) < size;sizepower++);
80         if (size != (1 << sizepower))
81                 Sys_Error("fractalnoise: size must be power of 2\n");
82
83         for (gridpower = 0;(1 << gridpower) < startgrid;gridpower++);
84         if (startgrid != (1 << gridpower))
85                 Sys_Error("fractalnoise: grid must be power of 2\n");
86
87         startgrid = bound(0, startgrid, size);
88
89         amplitude = 0xFFFF; // this gets halved before use
90         noisebuf = malloc(size*size*sizeof(int));
91         memset(noisebuf, 0, size*size*sizeof(int));
92
93         for (g2 = startgrid;g2;g2 >>= 1)
94         {
95                 // brownian motion (at every smaller level there is random behavior)
96                 amplitude >>= 1;
97                 for (y = 0;y < size;y += g2)
98                         for (x = 0;x < size;x += g2)
99                                 n(x,y) += (rand()&amplitude);
100
101                 g = g2 >> 1;
102                 if (g)
103                 {
104                         // subdivide, diamond-square algorithm (really this has little to do with squares)
105                         // diamond
106                         for (y = 0;y < size;y += g2)
107                                 for (x = 0;x < size;x += g2)
108                                         n(x+g,y+g) = (n(x,y) + n(x+g2,y) + n(x,y+g2) + n(x+g2,y+g2)) >> 2;
109                         // square
110                         for (y = 0;y < size;y += g2)
111                                 for (x = 0;x < size;x += g2)
112                                 {
113                                         n(x+g,y) = (n(x,y) + n(x+g2,y) + n(x+g,y-g) + n(x+g,y+g)) >> 2;
114                                         n(x,y+g) = (n(x,y) + n(x,y+g2) + n(x-g,y+g) + n(x+g,y+g)) >> 2;
115                                 }
116                 }
117         }
118         // find range of noise values
119         min = max = 0;
120         for (y = 0;y < size;y++)
121                 for (x = 0;x < size;x++)
122                 {
123                         if (n(x,y) < min) min = n(x,y);
124                         if (n(x,y) > max) max = n(x,y);
125                 }
126         max -= min;
127         max++;
128         // normalize noise and copy to output
129         for (y = 0;y < size;y++)
130                 for (x = 0;x < size;x++)
131                         *noise++ = (qbyte) (((n(x,y) - min) * 256) / max);
132         free(noisebuf);
133 #undef n
134 }
135 void VectorVectors(const vec3_t forward, vec3_t right, vec3_t up)
136 {
137         float d;
138
139         right[0] = forward[2];
140         right[1] = -forward[0];
141         right[2] = forward[1];
142
143         d = DotProduct(forward, right);
144         right[0] -= d * forward[0];
145         right[1] -= d * forward[1];
146         right[2] -= d * forward[2];
147         VectorNormalizeFast(right);
148         CrossProduct(right, forward, up);
149 }
150 #if QW
151 #include "pmove.h"
152 extern qboolean PM_RecursiveHullCheck (hull_t *hull, int num, float p1f, float p2f, vec3_t p1, vec3_t p2, pmtrace_t *trace);
153 #endif
154 float CL_TraceLine (vec3_t start, vec3_t end, vec3_t impact, vec3_t normal, int hitbmodels, void **hitent, int hitsupercontentsmask)
155 {
156 #if QW
157         pmtrace_t trace;
158 #else
159         trace_t trace;
160 #endif
161         memset (&trace, 0, sizeof(trace));
162         trace.fraction = 1;
163         VectorCopy (end, trace.endpos);
164 #if QW
165         PM_RecursiveHullCheck (cl.model_precache[1]->hulls, 0, 0, 1, start, end, &trace);
166 #else
167         RecursiveHullCheck (cl.worldmodel->hulls, 0, 0, 1, start, end, &trace);
168 #endif
169         VectorCopy(trace.endpos, impact);
170         VectorCopy(trace.plane.normal, normal);
171         return trace.fraction;
172 }
173 #else
174 #include "cl_collision.h"
175 #include "image.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_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_explosions_bubbles = {CVAR_SAVE, "cl_particles_explosions_bubbles", "1"};
297 cvar_t cl_particles_explosions_smoke = {CVAR_SAVE, "cl_particles_explosions_smokes", "0"};
298 cvar_t cl_particles_explosions_sparks = {CVAR_SAVE, "cl_particles_explosions_sparks", "1"};
299 cvar_t cl_particles_explosions_shell = {CVAR_SAVE, "cl_particles_explosions_shell", "0"};
300 cvar_t cl_particles_smoke = {CVAR_SAVE, "cl_particles_smoke", "1"};
301 cvar_t cl_particles_smoke_alpha = {CVAR_SAVE, "cl_particles_smoke_alpha", "0.5"};
302 cvar_t cl_particles_smoke_alphafade = {CVAR_SAVE, "cl_particles_smoke_alphafade", "0.55"};
303 cvar_t cl_particles_sparks = {CVAR_SAVE, "cl_particles_sparks", "1"};
304 cvar_t cl_particles_bubbles = {CVAR_SAVE, "cl_particles_bubbles", "1"};
305 cvar_t cl_decals = {CVAR_SAVE, "cl_decals", "0"};
306 cvar_t cl_decals_time = {CVAR_SAVE, "cl_decals_time", "0"};
307 cvar_t cl_decals_fadetime = {CVAR_SAVE, "cl_decals_fadetime", "20"};
308
309 #ifndef WORKINGLQUAKE
310 static mempool_t *cl_part_mempool;
311 #endif
312
313 void CL_Particles_Clear(void)
314 {
315         cl_numparticles = 0;
316         cl_freeparticle = 0;
317         memset(particles, 0, sizeof(particle_t) * cl_maxparticles);
318 }
319
320 /*
321 ===============
322 CL_InitParticles
323 ===============
324 */
325 void CL_ReadPointFile_f (void);
326 void CL_Particles_Init (void)
327 {
328         int             i;
329
330 // COMMANDLINEOPTION: Client: -particles <number> changes maximum number of particles at once, default 32768
331         i = COM_CheckParm ("-particles");
332
333         if (i && i < com_argc - 1)
334         {
335                 cl_maxparticles = (int)(atoi(com_argv[i+1]));
336                 if (cl_maxparticles < ABSOLUTE_MIN_PARTICLES)
337                         cl_maxparticles = ABSOLUTE_MIN_PARTICLES;
338         }
339         else
340                 cl_maxparticles = MAX_PARTICLES;
341
342         Cmd_AddCommand ("pointfile", CL_ReadPointFile_f);
343
344         Cvar_RegisterVariable (&cl_particles);
345         Cvar_RegisterVariable (&cl_particles_quality);
346         Cvar_RegisterVariable (&cl_particles_size);
347         Cvar_RegisterVariable (&cl_particles_bloodshowers);
348         Cvar_RegisterVariable (&cl_particles_blood);
349         Cvar_RegisterVariable (&cl_particles_blood_alpha);
350         Cvar_RegisterVariable (&cl_particles_blood_bloodhack);
351         Cvar_RegisterVariable (&cl_particles_explosions_bubbles);
352         Cvar_RegisterVariable (&cl_particles_explosions_smoke);
353         Cvar_RegisterVariable (&cl_particles_explosions_sparks);
354         Cvar_RegisterVariable (&cl_particles_explosions_shell);
355         Cvar_RegisterVariable (&cl_particles_bulletimpacts);
356         Cvar_RegisterVariable (&cl_particles_smoke);
357         Cvar_RegisterVariable (&cl_particles_smoke_alpha);
358         Cvar_RegisterVariable (&cl_particles_smoke_alphafade);
359         Cvar_RegisterVariable (&cl_particles_sparks);
360         Cvar_RegisterVariable (&cl_particles_bubbles);
361         Cvar_RegisterVariable (&cl_decals);
362         Cvar_RegisterVariable (&cl_decals_time);
363         Cvar_RegisterVariable (&cl_decals_fadetime);
364
365 #ifdef WORKINGLQUAKE
366         particles = (particle_t *) Hunk_AllocName(cl_maxparticles * sizeof(particle_t), "particles");
367 #else
368         cl_part_mempool = Mem_AllocPool("CL_Part", 0, NULL);
369         particles = (particle_t *) Mem_Alloc(cl_part_mempool, cl_maxparticles * sizeof(particle_t));
370 #endif
371         CL_Particles_Clear();
372 }
373
374 void CL_Particles_Shutdown (void)
375 {
376 #ifdef WORKINGLQUAKE
377         // No clue what to do here...
378 #else
379         Mem_FreePool (&cl_part_mempool);
380 #endif
381 }
382
383 // list of all 26 parameters:
384 // ptype - any of the pt_ enum values (pt_static, pt_blood, etc), see ptype_t near the top of this file
385 // porientation - PARTICLE_ enum values (PARTICLE_BILLBOARD, PARTICLE_SPARK, etc)
386 // pcolor1,pcolor2 - minimum and maximum ranges of color, randomly interpolated to decide particle color
387 // ptex - any of the tex_ values such as tex_smoke[rand()&7] or tex_particle
388 // plight - no longer used (this used to turn on particle lighting)
389 // pblendmode - PBLEND_ enum values (PBLEND_ALPHA, PBLEND_ADD, etc)
390 // pscalex,pscaley - width and height of particle (according to orientation), these are normally the same except when making sparks and beams
391 // palpha - opacity of particle as 0-255 (can be more than 255)
392 // palphafade - rate of fade per second (so 256 would mean a 256 alpha particle would fade to nothing in 1 second)
393 // ptime - how long the particle can live (note it is also removed if alpha drops to nothing)
394 // pgravity - how much effect gravity has on the particle (0-1)
395 // 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
396 // px,py,pz - starting origin of particle
397 // pvx,pvy,pvz - starting velocity of particle
398 // ptime2 - extra time parameter for certain particle types (pt_decal delayed fades and pt_rain snowflutter use this)
399 // pvx2,pvy2,pvz2 - for PARTICLE_ORIENTED_DOUBLESIDED this is the surface normal of the orientation (forward vector), pt_rain uses this for snow fluttering
400 // pfriction - how much the particle slows down per second (0-1 typically, can slowdown faster than 1)
401 // 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
402 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)
403 {
404         particle_t *part;
405         int ptempcolor, ptempcolor2, pcr1, pcg1, pcb1, pcr2, pcg2, pcb2;
406         ptempcolor = (pcolor1);
407         ptempcolor2 = (pcolor2);
408         pcr2 = ((ptempcolor2) >> 16) & 0xFF;
409         pcg2 = ((ptempcolor2) >> 8) & 0xFF;
410         pcb2 = (ptempcolor2) & 0xFF;
411         if (ptempcolor != ptempcolor2)
412         {
413                 pcr1 = ((ptempcolor) >> 16) & 0xFF;
414                 pcg1 = ((ptempcolor) >> 8) & 0xFF;
415                 pcb1 = (ptempcolor) & 0xFF;
416                 ptempcolor = rand() & 0xFF;
417                 pcr2 = (((pcr2 - pcr1) * ptempcolor) >> 8) + pcr1;
418                 pcg2 = (((pcg2 - pcg1) * ptempcolor) >> 8) + pcg1;
419                 pcb2 = (((pcb2 - pcb1) * ptempcolor) >> 8) + pcb1;
420         }
421         for (;cl_freeparticle < cl_maxparticles && particles[cl_freeparticle].type;cl_freeparticle++);
422         if (cl_freeparticle >= cl_maxparticles)
423                 return NULL;
424         part = &particles[cl_freeparticle++];
425         if (cl_numparticles < cl_freeparticle)
426                 cl_numparticles = cl_freeparticle;
427         memset(part, 0, sizeof(*part));
428         part->type = (ptype);
429         part->color[0] = pcr2;
430         part->color[1] = pcg2;
431         part->color[2] = pcb2;
432         part->color[3] = 0xFF;
433         part->orientation = porientation;
434         part->texnum = ptex;
435         part->blendmode = pblendmode;
436         part->scalex = (pscalex);
437         part->scaley = (pscaley);
438         part->alpha = (palpha);
439         part->alphafade = (palphafade);
440         part->die = cl.time + (ptime);
441         part->gravity = (pgravity);
442         part->bounce = (pbounce);
443         part->org[0] = (px);
444         part->org[1] = (py);
445         part->org[2] = (pz);
446         part->vel[0] = (pvx);
447         part->vel[1] = (pvy);
448         part->vel[2] = (pvz);
449         part->time2 = (ptime2);
450         part->vel2[0] = (pvx2);
451         part->vel2[1] = (pvy2);
452         part->vel2[2] = (pvz2);
453         part->friction = (pfriction);
454         part->pressure = (ppressure);
455         return part;
456 }
457
458 void CL_SpawnDecalParticleForSurface(void *hitent, const vec3_t org, const vec3_t normal, int color1, int color2, int texnum, float size, float alpha)
459 {
460         particle_t *p;
461         if (!cl_decals.integer)
462                 return;
463         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);
464 #ifndef WORKINGLQUAKE
465         if (p)
466         {
467                 p->owner = hitent;
468                 p->ownermodel = p->owner->model;
469                 Matrix4x4_Transform(&p->owner->inversematrix, org, p->relativeorigin);
470                 Matrix4x4_Transform3x3(&p->owner->inversematrix, normal, p->relativedirection);
471                 VectorAdd(p->relativeorigin, p->relativedirection, p->relativeorigin);
472         }
473 #endif
474 }
475
476 void CL_SpawnDecalParticleForPoint(const vec3_t org, float maxdist, float size, float alpha, int texnum, int color1, int color2)
477 {
478         int i;
479         float bestfrac, bestorg[3], bestnormal[3];
480         float frac, v[3], normal[3], org2[3];
481 #ifdef WORKINGLQUAKE
482         void *besthitent = NULL, *hitent;
483 #else
484         entity_render_t *besthitent = NULL, *hitent;
485 #endif
486         bestfrac = 10;
487         for (i = 0;i < 32;i++)
488         {
489                 VectorRandom(org2);
490                 VectorMA(org, maxdist, org2, org2);
491                 frac = CL_TraceLine(org, org2, v, normal, true, &hitent, SUPERCONTENTS_SOLID);
492                 if (bestfrac > frac)
493                 {
494                         bestfrac = frac;
495                         besthitent = hitent;
496                         VectorCopy(v, bestorg);
497                         VectorCopy(normal, bestnormal);
498                 }
499         }
500         if (bestfrac < 1)
501                 CL_SpawnDecalParticleForSurface(besthitent, bestorg, bestnormal, color1, color2, texnum, size, alpha);
502 }
503
504 /*
505 ===============
506 CL_EntityParticles
507 ===============
508 */
509 void CL_EntityParticles (entity_t *ent)
510 {
511         int                     i;
512         float           angle;
513         float           sp, sy, cp, cy;
514         vec3_t          forward;
515         float           dist;
516         float           beamlength;
517         static vec3_t avelocities[NUMVERTEXNORMALS];
518         if (!cl_particles.integer) return;
519
520         dist = 64;
521         beamlength = 16;
522
523         if (!avelocities[0][0])
524                 for (i=0 ; i<NUMVERTEXNORMALS*3 ; i++)
525                         avelocities[0][i] = (rand()&255) * 0.01;
526
527         for (i=0 ; i<NUMVERTEXNORMALS ; i++)
528         {
529                 angle = cl.time * avelocities[i][0];
530                 sy = sin(angle);
531                 cy = cos(angle);
532                 angle = cl.time * avelocities[i][1];
533                 sp = sin(angle);
534                 cp = cos(angle);
535
536                 forward[0] = cp*cy;
537                 forward[1] = cp*sy;
538                 forward[2] = -sp;
539
540 #ifdef WORKINGLQUAKE
541                 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);
542 #else
543                 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);
544 #endif
545         }
546 }
547
548
549 void CL_ReadPointFile_f (void)
550 {
551         vec3_t org, leakorg;
552         int r, c, s;
553         char *pointfile = NULL, *pointfilepos, *t, tchar;
554         char name[MAX_OSPATH];
555
556         if (!cl.worldmodel)
557                 return;
558
559         FS_StripExtension (cl.worldmodel->name, name, sizeof (name));
560         strlcat (name, ".pts", sizeof (name));
561 #if WORKINGLQUAKE
562         pointfile = COM_LoadTempFile (name);
563 #else
564         pointfile = FS_LoadFile(name, tempmempool, true);
565 #endif
566         if (!pointfile)
567         {
568                 Con_Printf("Could not open %s\n", name);
569                 return;
570         }
571
572         Con_Printf("Reading %s...\n", name);
573         c = 0;
574         s = 0;
575         pointfilepos = pointfile;
576         while (*pointfilepos)
577         {
578                 while (*pointfilepos == '\n' || *pointfilepos == '\r')
579                         pointfilepos++;
580                 if (!*pointfilepos)
581                         break;
582                 t = pointfilepos;
583                 while (*t && *t != '\n' && *t != '\r')
584                         t++;
585                 tchar = *t;
586                 *t = 0;
587                 r = sscanf (pointfilepos,"%f %f %f", &org[0], &org[1], &org[2]);
588                 *t = tchar;
589                 pointfilepos = t;
590                 if (r != 3)
591                         break;
592                 if (c == 0)
593                         VectorCopy(org, leakorg);
594                 c++;
595
596                 if (cl_numparticles < cl_maxparticles - 3)
597                 {
598                         s++;
599                         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);
600                 }
601         }
602 #ifndef WORKINGLQUAKE
603         Mem_Free(pointfile);
604 #endif
605         VectorCopy(leakorg, org);
606         Con_Printf("%i points read (%i particles spawned)\nLeak at %f %f %f\n", c, s, org[0], org[1], org[2]);
607
608         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);
609         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);
610         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);
611 }
612
613 /*
614 ===============
615 CL_ParseParticleEffect
616
617 Parse an effect out of the server message
618 ===============
619 */
620 void CL_ParseParticleEffect (void)
621 {
622         vec3_t org, dir;
623         int i, count, msgcount, color;
624
625         MSG_ReadVector(org, cl.protocol);
626         for (i=0 ; i<3 ; i++)
627                 dir[i] = MSG_ReadChar () * (1.0/16);
628         msgcount = MSG_ReadByte ();
629         color = MSG_ReadByte ();
630
631         if (msgcount == 255)
632                 count = 1024;
633         else
634                 count = msgcount;
635
636         if (cl_particles_blood_bloodhack.integer)
637         {
638                 if (color == 73)
639                 {
640                         // regular blood
641                         CL_BloodPuff(org, dir, count / 2);
642                         return;
643                 }
644                 if (color == 225)
645                 {
646                         // lightning blood
647                         CL_BloodPuff(org, dir, count / 2);
648                         return;
649                 }
650         }
651         CL_RunParticleEffect (org, dir, color, count);
652 }
653
654 /*
655 ===============
656 CL_ParticleExplosion
657
658 ===============
659 */
660 void CL_ParticleExplosion (vec3_t org)
661 {
662         int i;
663         //vec3_t v;
664         //vec3_t v2;
665         if (cl_stainmaps.integer)
666                 R_Stain(org, 96, 80, 80, 80, 64, 176, 176, 176, 64);
667         CL_SpawnDecalParticleForPoint(org, 40, 48, 255, tex_bulletdecal[rand()&7], 0xFFFFFF, 0xFFFFFF);
668
669         i = CL_PointQ1Contents(org);
670         if (i == CONTENTS_SLIME || i == CONTENTS_WATER)
671         {
672                 if (cl_particles.integer && cl_particles_bubbles.integer && cl_particles_explosions_bubbles.integer)
673                         for (i = 0;i < 128 * cl_particles_quality.value;i++)
674                                 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);
675         }
676         else
677         {
678                 // LordHavoc: smoke effect similar to UT2003, chews fillrate too badly up close
679                 // smoke puff
680                 if (cl_particles.integer && cl_particles_smoke.integer && cl_particles_explosions_smoke.integer)
681                 {
682                         for (i = 0;i < 32;i++)
683                         {
684                                 int k;
685                                 vec3_t v, v2;
686 #ifdef WORKINGLQUAKE
687                                 v2[0] = lhrandom(-48, 48);
688                                 v2[1] = lhrandom(-48, 48);
689                                 v2[2] = lhrandom(-48, 48);
690 #else
691                                 for (k = 0;k < 16;k++)
692                                 {
693                                         v[0] = org[0] + lhrandom(-48, 48);
694                                         v[1] = org[1] + lhrandom(-48, 48);
695                                         v[2] = org[2] + lhrandom(-48, 48);
696                                         if (CL_TraceLine(org, v, v2, NULL, true, NULL, SUPERCONTENTS_SOLID) >= 0.1)
697                                                 break;
698                                 }
699                                 VectorSubtract(v2, org, v2);
700 #endif
701                                 VectorScale(v2, 2.0f, v2);
702                                 particle(pt_static, PARTICLE_BILLBOARD, 0xFFFFFF, 0xFFFFFF, tex_smoke[rand()&7], true, PBLEND_ADD, 12, 12, 32, 64, 9999, 0, 0, org[0], org[1], org[2], v2[0], v2[1], v2[2], 0, 0, 0, 0, 0, 0);
703                         }
704                 }
705
706 #if 1
707                 if (cl_particles.integer && cl_particles_sparks.integer && cl_particles_explosions_sparks.integer)
708                         for (i = 0;i < 128 * cl_particles_quality.value;i++)
709                                 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);
710 #elif 1
711                 if (cl_particles.integer && cl_particles_sparks.integer && cl_particles_explosions_sparks.integer)
712                         for (i = 0;i < 64 * cl_particles_quality.value;i++)
713                                 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);
714 #else
715                 if (cl_particles.integer && cl_particles_sparks.integer && cl_particles_explosions_sparks.integer)
716                         for (i = 0;i < 256 * cl_particles_quality.value;i++)
717                                 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);
718 #endif
719         }
720
721         if (cl_particles_explosions_shell.integer)
722                 R_NewExplosion(org);
723 }
724
725 /*
726 ===============
727 CL_ParticleExplosion2
728
729 ===============
730 */
731 void CL_ParticleExplosion2 (vec3_t org, int colorStart, int colorLength)
732 {
733         vec3_t vel;
734         vec3_t offset;
735         int i, k;
736         float pscale;
737         if (!cl_particles.integer) return;
738
739         for (i = 0;i < 512 * cl_particles_quality.value;i++)
740         {
741                 VectorRandom (offset);
742                 VectorScale (offset, 192, vel);
743                 VectorScale (offset, 8, offset);
744                 k = particlepalette[colorStart + (i % colorLength)];
745                 pscale = lhrandom(0.5, 1.5);
746                 particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ADD, pscale, pscale, (1.0f / cl_particles_quality.value) * 255, (1.0f/cl_particles_quality.value)*512, 9999, 0, 0, org[0] + offset[0], org[1] + offset[1], org[2] + offset[2], vel[0], vel[1], vel[2], 0, 0, 0, 0, lhrandom(1.5, 3), 0);
747         }
748 }
749
750 /*
751 ===============
752 CL_BlobExplosion
753
754 ===============
755 */
756 void CL_BlobExplosion (vec3_t org)
757 {
758         CL_ParticleExplosion(org);
759 }
760
761 /*
762 ===============
763 CL_RunParticleEffect
764
765 ===============
766 */
767 void CL_RunParticleEffect (vec3_t org, vec3_t dir, int color, int count)
768 {
769         int k;
770
771         if (count == 1024)
772         {
773                 CL_ParticleExplosion(org);
774                 return;
775         }
776         if (!cl_particles.integer) return;
777         count *= cl_particles_quality.value;
778         while (count--)
779         {
780                 k = particlepalette[color + (rand()&7)];
781                 if (gamemode == GAME_GOODVSBAD2)
782                         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);
783                 else
784                         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);
785         }
786 }
787
788 // LordHavoc: added this for spawning sparks/dust (which have strong gravity)
789 /*
790 ===============
791 CL_SparkShower
792 ===============
793 */
794 void CL_SparkShower (vec3_t org, vec3_t dir, int count, vec_t gravityscale)
795 {
796         int k;
797
798         if (!cl_particles.integer) return;
799
800         if (cl_particles_sparks.integer)
801         {
802                 // sparks
803                 count *= cl_particles_quality.value;
804                 while(count--)
805                 {
806                         k = particlepalette[0x68 + (rand() & 7)];
807                         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, gravityscale, 0, org[0], org[1], org[2], lhrandom(-64, 64) + dir[0], lhrandom(-64, 64) + dir[1], lhrandom(0, 128) + dir[2], 0, 0, 0, 0, 0, 0);
808                 }
809         }
810 }
811
812 void CL_Smoke (vec3_t org, vec3_t dir, int count)
813 {
814         vec3_t org2, org3;
815         int k;
816
817         if (!cl_particles.integer) return;
818
819         // smoke puff
820         if (cl_particles_smoke.integer)
821         {
822                 k = count * 0.25 * cl_particles_quality.value;
823                 while(k--)
824                 {
825                         org2[0] = org[0] + 0.125f * lhrandom(-count, count);
826                         org2[1] = org[1] + 0.125f * lhrandom(-count, count);
827                         org2[2] = org[2] + 0.125f * lhrandom(-count, count);
828                         CL_TraceLine(org, org2, org3, NULL, true, NULL, SUPERCONTENTS_SOLID);
829                         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, 0, org3[0], org3[1], org3[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 15, 0, 0, 0, 0, 0);
830                 }
831         }
832 }
833
834 void CL_BulletMark (vec3_t org)
835 {
836         if (cl_stainmaps.integer)
837                 R_Stain(org, 32, 96, 96, 96, 24, 128, 128, 128, 24);
838         CL_SpawnDecalParticleForPoint(org, 6, 3, 255, tex_bulletdecal[rand()&7], 0xFFFFFF, 0xFFFFFF);
839 }
840
841 void CL_PlasmaBurn (vec3_t org)
842 {
843         if (cl_stainmaps.integer)
844                 R_Stain(org, 48, 96, 96, 96, 32, 128, 128, 128, 32);
845         CL_SpawnDecalParticleForPoint(org, 6, 6, 255, tex_bulletdecal[rand()&7], 0xFFFFFF, 0xFFFFFF);
846 }
847
848 static float bloodcount = 0;
849 void CL_BloodPuff (vec3_t org, vec3_t vel, int count)
850 {
851         float s;
852         vec3_t org2, org3;
853         // bloodcount is used to accumulate counts too small to cause a blood particle
854         if (!cl_particles.integer) return;
855         if (!cl_particles_blood.integer) return;
856
857         s = count + 64.0f;
858         count *= 5.0f;
859         if (count > 1000)
860                 count = 1000;
861         bloodcount += count;
862         while(bloodcount > 0)
863         {
864                 org2[0] = org[0] + 0.125f * lhrandom(-bloodcount, bloodcount);
865                 org2[1] = org[1] + 0.125f * lhrandom(-bloodcount, bloodcount);
866                 org2[2] = org[2] + 0.125f * lhrandom(-bloodcount, bloodcount);
867                 CL_TraceLine(org, org2, org3, NULL, true, NULL, SUPERCONTENTS_SOLID);
868                 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);
869                 bloodcount -= 16 / cl_particles_quality.value;
870         }
871 }
872
873 void CL_BloodShower (vec3_t mins, vec3_t maxs, float velspeed, int count)
874 {
875         vec3_t org, vel, diff, center, velscale;
876         if (!cl_particles.integer) return;
877         if (!cl_particles_bloodshowers.integer) return;
878         if (!cl_particles_blood.integer) return;
879
880         VectorSubtract(maxs, mins, diff);
881         center[0] = (mins[0] + maxs[0]) * 0.5;
882         center[1] = (mins[1] + maxs[1]) * 0.5;
883         center[2] = (mins[2] + maxs[2]) * 0.5;
884         velscale[0] = velspeed * 2.0 / diff[0];
885         velscale[1] = velspeed * 2.0 / diff[1];
886         velscale[2] = velspeed * 2.0 / diff[2];
887
888         bloodcount += count * 5.0f;
889         while (bloodcount > 0)
890         {
891                 org[0] = lhrandom(mins[0], maxs[0]);
892                 org[1] = lhrandom(mins[1], maxs[1]);
893                 org[2] = lhrandom(mins[2], maxs[2]);
894                 vel[0] = (org[0] - center[0]) * velscale[0];
895                 vel[1] = (org[1] - center[1]) * velscale[1];
896                 vel[2] = (org[2] - center[2]) * velscale[2];
897                 bloodcount -= 16 / cl_particles_quality.value;
898                 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);
899         }
900 }
901
902 void CL_ParticleCube (vec3_t mins, vec3_t maxs, vec3_t dir, int count, int colorbase, int gravity, int randomvel)
903 {
904         int k;
905         float t;
906         if (!cl_particles.integer) return;
907         if (maxs[0] <= mins[0]) {t = mins[0];mins[0] = maxs[0];maxs[0] = t;}
908         if (maxs[1] <= mins[1]) {t = mins[1];mins[1] = maxs[1];maxs[1] = t;}
909         if (maxs[2] <= mins[2]) {t = mins[2];mins[2] = maxs[2];maxs[2] = t;}
910
911         count *= cl_particles_quality.value;
912         while (count--)
913         {
914                 k = particlepalette[colorbase + (rand()&3)];
915                 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);
916         }
917 }
918
919 void CL_ParticleRain (vec3_t mins, vec3_t maxs, vec3_t dir, int count, int colorbase, int type)
920 {
921         int k;
922         float t, z, minz, maxz;
923         if (!cl_particles.integer) return;
924         if (maxs[0] <= mins[0]) {t = mins[0];mins[0] = maxs[0];maxs[0] = t;}
925         if (maxs[1] <= mins[1]) {t = mins[1];mins[1] = maxs[1];maxs[1] = t;}
926         if (maxs[2] <= mins[2]) {t = mins[2];mins[2] = maxs[2];maxs[2] = t;}
927         if (dir[2] < 0) // falling
928         {
929                 t = (maxs[2] - mins[2]) / -dir[2];
930                 z = maxs[2];
931         }
932         else // rising??
933         {
934                 t = (maxs[2] - mins[2]) / dir[2];
935                 z = mins[2];
936         }
937         if (t < 0 || t > 2) // sanity check
938                 t = 2;
939
940         minz = z - fabs(dir[2]) * 0.1;
941         maxz = z + fabs(dir[2]) * 0.1;
942         minz = bound(mins[2], minz, maxs[2]);
943         maxz = bound(mins[2], maxz, maxs[2]);
944
945         count *= cl_particles_quality.value;
946
947         switch(type)
948         {
949         case 0:
950                 count *= 4; // ick, this should be in the mod or maps?
951
952                 while(count--)
953                 {
954                         k = particlepalette[colorbase + (rand()&3)];
955                         if (gamemode == GAME_GOODVSBAD2)
956                         {
957                                 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);
958                         }
959                         else
960                         {
961                                 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);
962                         }
963                 }
964                 break;
965         case 1:
966                 while(count--)
967                 {
968                         k = particlepalette[colorbase + (rand()&3)];
969                         if (gamemode == GAME_GOODVSBAD2)
970                         {
971                                 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);
972                         }
973                         else
974                         {
975                                 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);
976                         }
977                 }
978                 break;
979         default:
980                 Host_Error("CL_ParticleRain: unknown type %i (0 = rain, 1 = snow)\n", type);
981         }
982 }
983
984 void CL_Stardust (vec3_t mins, vec3_t maxs, int count)
985 {
986         int k;
987         float t;
988         vec3_t o, v, center;
989         if (!cl_particles.integer) return;
990
991         if (maxs[0] <= mins[0]) {t = mins[0];mins[0] = maxs[0];maxs[0] = t;}
992         if (maxs[1] <= mins[1]) {t = mins[1];mins[1] = maxs[1];maxs[1] = t;}
993         if (maxs[2] <= mins[2]) {t = mins[2];mins[2] = maxs[2];maxs[2] = t;}
994
995         center[0] = (mins[0] + maxs[0]) * 0.5f;
996         center[1] = (mins[1] + maxs[1]) * 0.5f;
997         center[2] = (mins[2] + maxs[2]) * 0.5f;
998
999         count *= cl_particles_quality.value;
1000         while (count--)
1001         {
1002                 k = particlepalette[224 + (rand()&15)];
1003                 o[0] = lhrandom(mins[0], maxs[0]);
1004                 o[1] = lhrandom(mins[1], maxs[1]);
1005                 o[2] = lhrandom(mins[2], maxs[2]);
1006                 VectorSubtract(o, center, v);
1007                 VectorNormalizeFast(v);
1008                 VectorScale(v, 100, v);
1009                 v[2] += sv_gravity.value * 0.15f;
1010                 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);
1011         }
1012 }
1013
1014 void CL_FlameCube (vec3_t mins, vec3_t maxs, int count)
1015 {
1016         int k;
1017         float t;
1018         if (!cl_particles.integer) return;
1019         if (maxs[0] <= mins[0]) {t = mins[0];mins[0] = maxs[0];maxs[0] = t;}
1020         if (maxs[1] <= mins[1]) {t = mins[1];mins[1] = maxs[1];maxs[1] = t;}
1021         if (maxs[2] <= mins[2]) {t = mins[2];mins[2] = maxs[2];maxs[2] = t;}
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, 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);
1028                 if (count & 1)
1029                         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);
1030         }
1031 }
1032
1033 void CL_Flames (vec3_t org, vec3_t vel, int count)
1034 {
1035         int k;
1036         if (!cl_particles.integer) return;
1037
1038         count *= cl_particles_quality.value;
1039         while (count--)
1040         {
1041                 k = particlepalette[224 + (rand()&15)];
1042                 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);
1043         }
1044 }
1045
1046
1047
1048 /*
1049 ===============
1050 CL_LavaSplash
1051
1052 ===============
1053 */
1054 void CL_LavaSplash (vec3_t origin)
1055 {
1056         float i, j, inc, vel;
1057         int k, l;
1058         vec3_t          dir, org;
1059         if (!cl_particles.integer) return;
1060
1061         inc = 32 / cl_particles_quality.value;
1062         for (i = -128;i < 128;i += inc)
1063         {
1064                 for (j = -128;j < 128;j += inc)
1065                 {
1066                         dir[0] = j + lhrandom(0, 8);
1067                         dir[1] = i + lhrandom(0, 8);
1068                         dir[2] = 256;
1069                         org[0] = origin[0] + dir[0];
1070                         org[1] = origin[1] + dir[1];
1071                         org[2] = origin[2] + lhrandom(0, 64);
1072                         vel = lhrandom(50, 120) / VectorLength(dir); // normalize and scale
1073                         if (gamemode == GAME_GOODVSBAD2)
1074                         {
1075                                 k = particlepalette[0 + (rand()&255)];
1076                                 l = particlepalette[0 + (rand()&255)];
1077                                 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);
1078                         }
1079                         else
1080                         {
1081                                 k = l = particlepalette[224 + (rand()&7)];
1082                                 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);
1083                         }
1084                 }
1085         }
1086 }
1087
1088 /*
1089 ===============
1090 CL_TeleportSplash
1091
1092 ===============
1093 */
1094 #if WORKINGLQUAKE
1095 void R_TeleportSplash (vec3_t org)
1096 {
1097         float i, j, k, inc;
1098         if (!cl_particles.integer) return;
1099
1100         inc = 8 / cl_particles_quality.value;
1101         for (i = -16;i < 16;i += inc)
1102                 for (j = -16;j < 16;j += inc)
1103                         for (k = -24;k < 32;k += inc)
1104                                 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);
1105 }
1106 #endif
1107
1108 #ifdef WORKINGLQUAKE
1109 void R_RocketTrail (vec3_t start, vec3_t end, int type)
1110 #else
1111 void CL_RocketTrail (vec3_t start, vec3_t end, int type, int color, entity_t *ent)
1112 #endif
1113 {
1114         vec3_t vec, dir, vel, pos;
1115         float len, dec, speed, qd;
1116         int contents, smoke, blood, bubbles;
1117
1118         if (end[0] == start[0] && end[1] == start[1] && end[2] == start[2])
1119                 return;
1120
1121         VectorSubtract(end, start, dir);
1122         VectorNormalize(dir);
1123
1124         VectorSubtract (end, start, vec);
1125 #ifdef WORKINGLQUAKE
1126         len = VectorNormalize (vec);
1127         dec = 0;
1128         speed = 1.0f / cl.frametime;
1129         VectorSubtract(end, start, vel);
1130 #else
1131         len = VectorNormalizeLength (vec);
1132         dec = -ent->persistent.trail_time;
1133         ent->persistent.trail_time += len;
1134         if (ent->persistent.trail_time < 0.01f)
1135                 return;
1136
1137         // if we skip out, leave it reset
1138         ent->persistent.trail_time = 0.0f;
1139
1140         speed = ent->state_current.time - ent->state_previous.time;
1141         if (speed)
1142                 speed = 1.0f / speed;
1143         VectorSubtract(ent->state_current.origin, ent->state_previous.origin, vel);
1144         color = particlepalette[color];
1145 #endif
1146         VectorScale(vel, speed, vel);
1147
1148         // advance into this frame to reach the first puff location
1149         VectorMA(start, dec, vec, pos);
1150         len -= dec;
1151
1152         contents = CL_PointQ1Contents(pos);
1153         if (contents == CONTENTS_SKY || contents == CONTENTS_LAVA)
1154                 return;
1155
1156         smoke = cl_particles.integer && cl_particles_smoke.integer;
1157         blood = cl_particles.integer && cl_particles_blood.integer;
1158         bubbles = cl_particles.integer && cl_particles_bubbles.integer && (contents == CONTENTS_WATER || contents == CONTENTS_SLIME);
1159         qd = 1.0f / cl_particles_quality.value;
1160
1161         while (len >= 0)
1162         {
1163                 switch (type)
1164                 {
1165                         case 0: // rocket trail
1166                                 dec = qd*3;
1167                                 if (smoke)
1168                                 {
1169                                         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);
1170                                         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);
1171                                 }
1172                                 if (bubbles)
1173                                         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);
1174                                 break;
1175
1176                         case 1: // grenade trail
1177                                 // FIXME: make it gradually stop smoking
1178                                 dec = qd*3;
1179                                 if (smoke)
1180                                         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);
1181                                 break;
1182
1183
1184                         case 2: // blood
1185                         case 4: // slight blood
1186                                 dec = qd*16;
1187                                 if (blood)
1188                                         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);
1189                                 break;
1190
1191                         case 3: // green tracer
1192                                 dec = qd*6;
1193                                 if (smoke)
1194                                 {
1195                                         if (gamemode == GAME_GOODVSBAD2)
1196                                                 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);
1197                                         else
1198                                                 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);
1199                                 }
1200                                 break;
1201
1202                         case 5: // flame tracer
1203                                 dec = qd*6;
1204                                 if (smoke)
1205                                         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);
1206                                 break;
1207
1208                         case 6: // voor trail
1209                                 dec = qd*6;
1210                                 if (smoke)
1211                                 {
1212                                         if (gamemode == GAME_GOODVSBAD2)
1213                                                 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);
1214                                         else if (gamemode == GAME_PRYDON)
1215                                                 particle(pt_static, PARTICLE_BILLBOARD, 0x103040, 0x204050, 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);
1216                                         else
1217                                                 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);
1218                                 }
1219                                 break;
1220 #ifndef WORKINGLQUAKE
1221                         case 7: // Nehahra smoke tracer
1222                                 dec = qd*7;
1223                                 if (smoke)
1224                                         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);
1225                                 break;
1226                         case 8: // Nexuiz plasma trail
1227                                 dec = qd*4;
1228                                 if (smoke)
1229                                         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);
1230                                 break;
1231                         case 9: // glow trail
1232                                 dec = qd*3;
1233                                 if (smoke)
1234                                         particle(pt_static, PARTICLE_BILLBOARD, color, color, tex_particle, false, PBLEND_ALPHA, 5, 5, qd*128, qd*320, 9999, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
1235                                 break;
1236 #endif
1237                 }
1238
1239                 // advance to next time and position
1240                 len -= dec;
1241                 VectorMA (pos, dec, vec, pos);
1242         }
1243 #ifndef WORKINGLQUAKE
1244         ent->persistent.trail_time = len;
1245 #endif
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;
1362                                         p->die = p->time2 + cl_decals_time.value + 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 *= 2.0f;
1371                                         p->scaley *= 2.0f;
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                                 p->alphafade = cl.time > (p->time2 + cl_decals_time.value) ? (p->alpha / cl_decals_fadetime.value) : 0;
1456 #ifndef WORKINGLQUAKE
1457                                 if (p->owner->model == p->ownermodel)
1458                                 {
1459                                         Matrix4x4_Transform(&p->owner->matrix, p->relativeorigin, p->org);
1460                                         Matrix4x4_Transform3x3(&p->owner->matrix, p->relativedirection, p->vel2);
1461                                 }
1462                                 else
1463                                         p->type = pt_dead;
1464 #endif
1465                                 break;
1466                         case pt_ember:
1467                                 while (cl.time > p->time2)
1468                                 {
1469                                         p->time2 += 0.025;
1470                                         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);
1471                                 }
1472                                 break;
1473                         default:
1474                                 Con_Printf("unknown particle type %i\n", p->type);
1475                                 p->type = pt_dead;
1476                                 break;
1477                         }
1478                 }
1479         }
1480         cl_numparticles = maxparticle + 1;
1481         cl_freeparticle = 0;
1482 }
1483
1484 #define MAX_PARTICLETEXTURES 64
1485 // particletexture_t is a rectangle in the particlefonttexture
1486 typedef struct
1487 {
1488         rtexture_t *texture;
1489         float s1, t1, s2, t2;
1490 }
1491 particletexture_t;
1492
1493 #if WORKINGLQUAKE
1494 static int particlefonttexture;
1495 #else
1496 static rtexturepool_t *particletexturepool;
1497 static rtexture_t *particlefonttexture;
1498 #endif
1499 static particletexture_t particletexture[MAX_PARTICLETEXTURES];
1500
1501 static cvar_t r_drawparticles = {0, "r_drawparticles", "1"};
1502
1503 #define PARTICLETEXTURESIZE 64
1504 #define PARTICLEFONTSIZE (PARTICLETEXTURESIZE*8)
1505
1506 static qbyte shadebubble(float dx, float dy, vec3_t light)
1507 {
1508         float dz, f, dot;
1509         vec3_t normal;
1510         dz = 1 - (dx*dx+dy*dy);
1511         if (dz > 0) // it does hit the sphere
1512         {
1513                 f = 0;
1514                 // back side
1515                 normal[0] = dx;normal[1] = dy;normal[2] = dz;
1516                 VectorNormalize(normal);
1517                 dot = DotProduct(normal, light);
1518                 if (dot > 0.5) // interior reflection
1519                         f += ((dot *  2) - 1);
1520                 else if (dot < -0.5) // exterior reflection
1521                         f += ((dot * -2) - 1);
1522                 // front side
1523                 normal[0] = dx;normal[1] = dy;normal[2] = -dz;
1524                 VectorNormalize(normal);
1525                 dot = DotProduct(normal, light);
1526                 if (dot > 0.5) // interior reflection
1527                         f += ((dot *  2) - 1);
1528                 else if (dot < -0.5) // exterior reflection
1529                         f += ((dot * -2) - 1);
1530                 f *= 128;
1531                 f += 16; // just to give it a haze so you can see the outline
1532                 f = bound(0, f, 255);
1533                 return (qbyte) f;
1534         }
1535         else
1536                 return 0;
1537 }
1538
1539 static void setuptex(int texnum, qbyte *data, qbyte *particletexturedata)
1540 {
1541         int basex, basey, y;
1542         basex = ((texnum >> 0) & 7) * PARTICLETEXTURESIZE;
1543         basey = ((texnum >> 3) & 7) * PARTICLETEXTURESIZE;
1544         particletexture[texnum].s1 = (basex + 1) / (float)PARTICLEFONTSIZE;
1545         particletexture[texnum].t1 = (basey + 1) / (float)PARTICLEFONTSIZE;
1546         particletexture[texnum].s2 = (basex + PARTICLETEXTURESIZE - 1) / (float)PARTICLEFONTSIZE;
1547         particletexture[texnum].t2 = (basey + PARTICLETEXTURESIZE - 1) / (float)PARTICLEFONTSIZE;
1548         for (y = 0;y < PARTICLETEXTURESIZE;y++)
1549                 memcpy(particletexturedata + ((basey + y) * PARTICLEFONTSIZE + basex) * 4, data + y * PARTICLETEXTURESIZE * 4, PARTICLETEXTURESIZE * 4);
1550 }
1551
1552 void particletextureblotch(qbyte *data, float radius, float red, float green, float blue, float alpha)
1553 {
1554         int x, y;
1555         float cx, cy, dx, dy, f, iradius;
1556         qbyte *d;
1557         cx = (lhrandom(radius + 1, PARTICLETEXTURESIZE - 2 - radius) + lhrandom(radius + 1, PARTICLETEXTURESIZE - 2 - radius)) * 0.5f;
1558         cy = (lhrandom(radius + 1, PARTICLETEXTURESIZE - 2 - radius) + lhrandom(radius + 1, PARTICLETEXTURESIZE - 2 - radius)) * 0.5f;
1559         iradius = 1.0f / radius;
1560         alpha *= (1.0f / 255.0f);
1561         for (y = 0;y < PARTICLETEXTURESIZE;y++)
1562         {
1563                 for (x = 0;x < PARTICLETEXTURESIZE;x++)
1564                 {
1565                         dx = (x - cx);
1566                         dy = (y - cy);
1567                         f = (1.0f - sqrt(dx * dx + dy * dy) * iradius) * alpha;
1568                         if (f > 0)
1569                         {
1570                                 d = data + (y * PARTICLETEXTURESIZE + x) * 4;
1571                                 d[0] += f * (red   - d[0]);
1572                                 d[1] += f * (green - d[1]);
1573                                 d[2] += f * (blue  - d[2]);
1574                         }
1575                 }
1576         }
1577 }
1578
1579 void particletextureclamp(qbyte *data, int minr, int ming, int minb, int maxr, int maxg, int maxb)
1580 {
1581         int i;
1582         for (i = 0;i < PARTICLETEXTURESIZE*PARTICLETEXTURESIZE;i++, data += 4)
1583         {
1584                 data[0] = bound(minr, data[0], maxr);
1585                 data[1] = bound(ming, data[1], maxg);
1586                 data[2] = bound(minb, data[2], maxb);
1587         }
1588 }
1589
1590 void particletextureinvert(qbyte *data)
1591 {
1592         int i;
1593         for (i = 0;i < PARTICLETEXTURESIZE*PARTICLETEXTURESIZE;i++, data += 4)
1594         {
1595                 data[0] = 255 - data[0];
1596                 data[1] = 255 - data[1];
1597                 data[2] = 255 - data[2];
1598         }
1599 }
1600
1601 static void R_InitParticleTexture (void)
1602 {
1603         int x, y, d, i, j, k, m;
1604         float dx, dy, radius, f, f2;
1605         qbyte data[PARTICLETEXTURESIZE][PARTICLETEXTURESIZE][4], noise1[PARTICLETEXTURESIZE*2][PARTICLETEXTURESIZE*2], noise2[PARTICLETEXTURESIZE*2][PARTICLETEXTURESIZE*2], noise3[64][64], data2[64][16][4];
1606         vec3_t light;
1607         qbyte *particletexturedata;
1608
1609         // a note: decals need to modulate (multiply) the background color to
1610         // properly darken it (stain), and they need to be able to alpha fade,
1611         // this is a very difficult challenge because it means fading to white
1612         // (no change to background) rather than black (darkening everything
1613         // behind the whole decal polygon), and to accomplish this the texture is
1614         // inverted (dark red blood on white background becomes brilliant cyan
1615         // and white on black background) so we can alpha fade it to black, then
1616         // we invert it again during the blendfunc to make it work...
1617
1618         particletexturedata = Mem_Alloc(tempmempool, PARTICLEFONTSIZE*PARTICLEFONTSIZE*4);
1619         memset(particletexturedata, 255, PARTICLEFONTSIZE*PARTICLEFONTSIZE*4);
1620
1621         // smoke
1622         for (i = 0;i < 8;i++)
1623         {
1624                 memset(&data[0][0][0], 255, sizeof(data));
1625                 do
1626                 {
1627                         fractalnoise(&noise1[0][0], PARTICLETEXTURESIZE*2, PARTICLETEXTURESIZE/8);
1628                         fractalnoise(&noise2[0][0], PARTICLETEXTURESIZE*2, PARTICLETEXTURESIZE/4);
1629                         m = 0;
1630                         for (y = 0;y < PARTICLETEXTURESIZE;y++)
1631                         {
1632                                 dy = (y - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f+1);
1633                                 for (x = 0;x < PARTICLETEXTURESIZE;x++)
1634                                 {
1635                                         dx = (x - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f+1);
1636                                         d = (noise2[y][x] - 128) * 3 + 192;
1637                                         if (d > 0)
1638                                                 d = d * (1-(dx*dx+dy*dy));
1639                                         d = (d * noise1[y][x]) >> 7;
1640                                         d = bound(0, d, 255);
1641                                         data[y][x][3] = (qbyte) d;
1642                                         if (m < d)
1643                                                 m = d;
1644                                 }
1645                         }
1646                 }
1647                 while (m < 224);
1648                 setuptex(tex_smoke[i], &data[0][0][0], particletexturedata);
1649         }
1650
1651         // rain splash
1652         for (i = 0;i < 16;i++)
1653         {
1654                 memset(&data[0][0][0], 255, sizeof(data));
1655                 radius = i * 3.0f / 4.0f / 16.0f;
1656                 f2 = 255.0f * ((15.0f - i) / 15.0f);
1657                 for (y = 0;y < PARTICLETEXTURESIZE;y++)
1658                 {
1659                         dy = (y - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f+1);
1660                         for (x = 0;x < PARTICLETEXTURESIZE;x++)
1661                         {
1662                                 dx = (x - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f+1);
1663                                 f = f2 * (1.0 - 4.0f * fabs(radius - sqrt(dx*dx+dy*dy)));
1664                                 data[y][x][3] = (int) (bound(0.0f, f, 255.0f));
1665                         }
1666                 }
1667                 setuptex(tex_rainsplash[i], &data[0][0][0], particletexturedata);
1668         }
1669
1670         // normal particle
1671         memset(&data[0][0][0], 255, sizeof(data));
1672         for (y = 0;y < PARTICLETEXTURESIZE;y++)
1673         {
1674                 dy = (y - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f+1);
1675                 for (x = 0;x < PARTICLETEXTURESIZE;x++)
1676                 {
1677                         dx = (x - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f+1);
1678                         d = 256 * (1 - (dx*dx+dy*dy));
1679                         d = bound(0, d, 255);
1680                         data[y][x][3] = (qbyte) d;
1681                 }
1682         }
1683         setuptex(tex_particle, &data[0][0][0], particletexturedata);
1684
1685         // rain
1686         memset(&data[0][0][0], 255, sizeof(data));
1687         light[0] = 1;light[1] = 1;light[2] = 1;
1688         VectorNormalize(light);
1689         for (y = 0;y < PARTICLETEXTURESIZE;y++)
1690         {
1691                 dy = (y - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f+1);
1692                 // stretch upper half of bubble by +50% and shrink lower half by -50%
1693                 // (this gives an elongated teardrop shape)
1694                 if (dy > 0.5f)
1695                         dy = (dy - 0.5f) * 2.0f;
1696                 else
1697                         dy = (dy - 0.5f) / 1.5f;
1698                 for (x = 0;x < PARTICLETEXTURESIZE;x++)
1699                 {
1700                         dx = (x - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f+1);
1701                         // shrink bubble width to half
1702                         dx *= 2.0f;
1703                         data[y][x][3] = shadebubble(dx, dy, light);
1704                 }
1705         }
1706         setuptex(tex_raindrop, &data[0][0][0], particletexturedata);
1707
1708         // bubble
1709         memset(&data[0][0][0], 255, sizeof(data));
1710         light[0] = 1;light[1] = 1;light[2] = 1;
1711         VectorNormalize(light);
1712         for (y = 0;y < PARTICLETEXTURESIZE;y++)
1713         {
1714                 dy = (y - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f+1);
1715                 for (x = 0;x < PARTICLETEXTURESIZE;x++)
1716                 {
1717                         dx = (x - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f+1);
1718                         data[y][x][3] = shadebubble(dx, dy, light);
1719                 }
1720         }
1721         setuptex(tex_bubble, &data[0][0][0], particletexturedata);
1722
1723         // blood particles
1724         for (i = 0;i < 8;i++)
1725         {
1726                 memset(&data[0][0][0], 255, sizeof(data));
1727                 for (k = 0;k < 24;k++)
1728                         particletextureblotch(&data[0][0][0], PARTICLETEXTURESIZE/16, 96, 0, 0, 160);
1729                 //particletextureclamp(&data[0][0][0], 32, 32, 32, 255, 255, 255);
1730                 particletextureinvert(&data[0][0][0]);
1731                 setuptex(tex_bloodparticle[i], &data[0][0][0], particletexturedata);
1732         }
1733
1734         // blood decals
1735         for (i = 0;i < 8;i++)
1736         {
1737                 memset(&data[0][0][0], 255, sizeof(data));
1738                 m = 8;
1739                 for (j = 1;j < 10;j++)
1740                         for (k = min(j, m - 1);k < m;k++)
1741                                 particletextureblotch(&data[0][0][0], (float)j*PARTICLETEXTURESIZE/64.0f, 96, 0, 0, 192 - j * 8);
1742                 //particletextureclamp(&data[0][0][0], 32, 32, 32, 255, 255, 255);
1743                 particletextureinvert(&data[0][0][0]);
1744                 setuptex(tex_blooddecal[i], &data[0][0][0], particletexturedata);
1745         }
1746
1747         // bullet decals
1748         for (i = 0;i < 8;i++)
1749         {
1750                 memset(&data[0][0][0], 255, sizeof(data));
1751                 for (k = 0;k < 12;k++)
1752                         particletextureblotch(&data[0][0][0], PARTICLETEXTURESIZE/16, 0, 0, 0, 128);
1753                 for (k = 0;k < 3;k++)
1754                         particletextureblotch(&data[0][0][0], PARTICLETEXTURESIZE/2, 0, 0, 0, 160);
1755                 //particletextureclamp(&data[0][0][0], 64, 64, 64, 255, 255, 255);
1756                 particletextureinvert(&data[0][0][0]);
1757                 setuptex(tex_bulletdecal[i], &data[0][0][0], particletexturedata);
1758         }
1759
1760 #if WORKINGLQUAKE
1761         glBindTexture(GL_TEXTURE_2D, (particlefonttexture = gl_extension_number++));
1762         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1763         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
1764 #else
1765
1766 #if 0
1767         Image_WriteTGARGBA ("particles/particlefont.tga", PARTICLEFONTSIZE, PARTICLEFONTSIZE, particletexturedata);
1768 #endif
1769
1770         particlefonttexture = loadtextureimage(particletexturepool, "particles/particlefont.tga", 0, 0, false, TEXF_ALPHA | TEXF_PRECACHE);
1771         if (!particlefonttexture)
1772                 particlefonttexture = R_LoadTexture2D(particletexturepool, "particlefont", PARTICLEFONTSIZE, PARTICLEFONTSIZE, particletexturedata, TEXTYPE_RGBA, TEXF_ALPHA | TEXF_PRECACHE, NULL);
1773         for (i = 0;i < MAX_PARTICLETEXTURES;i++)
1774                 particletexture[i].texture = particlefonttexture;
1775
1776         // nexbeam
1777         fractalnoise(&noise3[0][0], 64, 4);
1778         m = 0;
1779         for (y = 0;y < 64;y++)
1780         {
1781                 dy = (y - 0.5f*64) / (64*0.5f+1);
1782                 for (x = 0;x < 16;x++)
1783                 {
1784                         dx = (x - 0.5f*16) / (16*0.5f+1);
1785                         d = (1 - (dx*dx)) * noise3[y][x];
1786                         data2[y][x][0] = data2[y][x][1] = data2[y][x][2] = (qbyte) bound(0, d, 255);
1787                         data2[y][x][3] = 255;
1788                 }
1789         }
1790
1791         particletexture[tex_beam].texture = loadtextureimage(particletexturepool, "particles/nexbeam.tga", 0, 0, false, TEXF_ALPHA | TEXF_PRECACHE);
1792         if (!particletexture[tex_beam].texture)
1793                 particletexture[tex_beam].texture = R_LoadTexture2D(particletexturepool, "nexbeam", 16, 64, &data2[0][0][0], TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
1794         particletexture[tex_beam].s1 = 0;
1795         particletexture[tex_beam].t1 = 0;
1796         particletexture[tex_beam].s2 = 1;
1797         particletexture[tex_beam].t2 = 1;
1798 #endif
1799         Mem_Free(particletexturedata);
1800 }
1801
1802 static void r_part_start(void)
1803 {
1804         particletexturepool = R_AllocTexturePool();
1805         R_InitParticleTexture ();
1806 }
1807
1808 static void r_part_shutdown(void)
1809 {
1810         R_FreeTexturePool(&particletexturepool);
1811 }
1812
1813 static void r_part_newmap(void)
1814 {
1815         cl_numparticles = 0;
1816         cl_freeparticle = 0;
1817 }
1818
1819 void R_Particles_Init (void)
1820 {
1821         Cvar_RegisterVariable(&r_drawparticles);
1822 #ifdef WORKINGLQUAKE
1823         r_part_start();
1824 #else
1825         R_RegisterModule("R_Particles", r_part_start, r_part_shutdown, r_part_newmap);
1826 #endif
1827 }
1828
1829 #ifdef WORKINGLQUAKE
1830 void R_InitParticles(void)
1831 {
1832         CL_Particles_Init();
1833         R_Particles_Init();
1834 }
1835 #endif
1836
1837 float particle_vertex3f[12], particle_texcoord2f[8];
1838
1839 #ifdef WORKINGLQUAKE
1840 void R_DrawParticle(particle_t *p)
1841 {
1842 #else
1843 void R_DrawParticleCallback(const void *calldata1, int calldata2)
1844 {
1845         const particle_t *p = calldata1;
1846         rmeshstate_t m;
1847 #endif
1848         float org[3], up2[3], v[3], right[3], up[3], fog, ifog, fogvec[3], cr, cg, cb, ca;
1849         particletexture_t *tex;
1850
1851         VectorCopy(p->org, org);
1852
1853         tex = &particletexture[p->texnum];
1854         cr = p->color[0] * (1.0f / 255.0f);
1855         cg = p->color[1] * (1.0f / 255.0f);
1856         cb = p->color[2] * (1.0f / 255.0f);
1857         ca = p->alpha * (1.0f / 255.0f);
1858         if (p->blendmode == PBLEND_MOD)
1859         {
1860                 cr *= ca;
1861                 cg *= ca;
1862                 cb *= ca;
1863                 cr = min(cr, 1);
1864                 cg = min(cg, 1);
1865                 cb = min(cb, 1);
1866                 ca = 1;
1867         }
1868
1869 #ifndef WORKINGLQUAKE
1870         if (fogenabled && p->blendmode != PBLEND_MOD)
1871         {
1872                 VectorSubtract(org, r_vieworigin, fogvec);
1873                 fog = exp(fogdensity/DotProduct(fogvec,fogvec));
1874                 ifog = 1 - fog;
1875                 cr = cr * ifog;
1876                 cg = cg * ifog;
1877                 cb = cb * ifog;
1878                 if (p->blendmode == 0)
1879                 {
1880                         cr += fogcolor[0] * fog;
1881                         cg += fogcolor[1] * fog;
1882                         cb += fogcolor[2] * fog;
1883                 }
1884         }
1885
1886         R_Mesh_Matrix(&r_identitymatrix);
1887
1888         memset(&m, 0, sizeof(m));
1889         m.tex[0] = R_GetTexture(tex->texture);
1890         m.pointer_texcoord[0] = particle_texcoord2f;
1891         m.pointer_vertex = particle_vertex3f;
1892         R_Mesh_State(&m);
1893
1894         GL_Color(cr, cg, cb, ca);
1895
1896         if (p->blendmode == 0)
1897                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1898         else if (p->blendmode == 1)
1899                 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
1900         else
1901                 GL_BlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
1902         GL_DepthMask(false);
1903         GL_DepthTest(true);
1904 #endif
1905         if (p->orientation == PARTICLE_BILLBOARD || p->orientation == PARTICLE_ORIENTED_DOUBLESIDED)
1906         {
1907                 if (p->orientation == PARTICLE_ORIENTED_DOUBLESIDED)
1908                 {
1909                         // double-sided
1910                         if (DotProduct(p->vel2, r_vieworigin) > DotProduct(p->vel2, org))
1911                         {
1912                                 VectorNegate(p->vel2, v);
1913                                 VectorVectors(v, right, up);
1914                         }
1915                         else
1916                                 VectorVectors(p->vel2, right, up);
1917                         VectorScale(right, p->scalex, right);
1918                         VectorScale(up, p->scaley, up);
1919                 }
1920                 else
1921                 {
1922                         VectorScale(r_viewleft, -p->scalex, right);
1923                         VectorScale(r_viewup, p->scaley, up);
1924                 }
1925                 particle_vertex3f[ 0] = org[0] - right[0] - up[0];
1926                 particle_vertex3f[ 1] = org[1] - right[1] - up[1];
1927                 particle_vertex3f[ 2] = org[2] - right[2] - up[2];
1928                 particle_vertex3f[ 3] = org[0] - right[0] + up[0];
1929                 particle_vertex3f[ 4] = org[1] - right[1] + up[1];
1930                 particle_vertex3f[ 5] = org[2] - right[2] + up[2];
1931                 particle_vertex3f[ 6] = org[0] + right[0] + up[0];
1932                 particle_vertex3f[ 7] = org[1] + right[1] + up[1];
1933                 particle_vertex3f[ 8] = org[2] + right[2] + up[2];
1934                 particle_vertex3f[ 9] = org[0] + right[0] - up[0];
1935                 particle_vertex3f[10] = org[1] + right[1] - up[1];
1936                 particle_vertex3f[11] = org[2] + right[2] - up[2];
1937                 particle_texcoord2f[0] = tex->s1;particle_texcoord2f[1] = tex->t2;
1938                 particle_texcoord2f[2] = tex->s1;particle_texcoord2f[3] = tex->t1;
1939                 particle_texcoord2f[4] = tex->s2;particle_texcoord2f[5] = tex->t1;
1940                 particle_texcoord2f[6] = tex->s2;particle_texcoord2f[7] = tex->t2;
1941         }
1942         else if (p->orientation == PARTICLE_SPARK)
1943         {
1944                 VectorMA(p->org, -p->scaley, p->vel, v);
1945                 VectorMA(p->org, p->scaley, p->vel, up2);
1946                 R_CalcBeam_Vertex3f(particle_vertex3f, v, up2, p->scalex);
1947                 particle_texcoord2f[0] = tex->s1;particle_texcoord2f[1] = tex->t2;
1948                 particle_texcoord2f[2] = tex->s1;particle_texcoord2f[3] = tex->t1;
1949                 particle_texcoord2f[4] = tex->s2;particle_texcoord2f[5] = tex->t1;
1950                 particle_texcoord2f[6] = tex->s2;particle_texcoord2f[7] = tex->t2;
1951         }
1952         else if (p->orientation == PARTICLE_BEAM)
1953         {
1954                 R_CalcBeam_Vertex3f(particle_vertex3f, p->org, p->vel2, p->scalex);
1955                 VectorSubtract(p->vel2, p->org, up);
1956                 VectorNormalizeFast(up);
1957                 v[0] = DotProduct(p->org, up) * (1.0f / 64.0f) - cl.time * 0.25;
1958                 v[1] = DotProduct(p->vel2, up) * (1.0f / 64.0f) - cl.time * 0.25;
1959                 particle_texcoord2f[0] = 1;particle_texcoord2f[1] = v[0];
1960                 particle_texcoord2f[2] = 0;particle_texcoord2f[3] = v[0];
1961                 particle_texcoord2f[4] = 0;particle_texcoord2f[5] = v[1];
1962                 particle_texcoord2f[6] = 1;particle_texcoord2f[7] = v[1];
1963         }
1964         else
1965                 Host_Error("R_DrawParticles: unknown particle orientation %i\n", p->orientation);
1966
1967 #if WORKINGLQUAKE
1968         if (p->blendmode == 0)
1969                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1970         else if (p->blendmode == 1)
1971                 glBlendFunc(GL_SRC_ALPHA, GL_ONE);
1972         else
1973                 glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
1974         glColor4f(cr, cg, cb, ca);
1975         glBegin(GL_QUADS);
1976         glTexCoord2f(particle_texcoord2f[0], particle_texcoord2f[1]);glVertex3f(particle_vertex3f[ 0], particle_vertex3f[ 1], particle_vertex3f[ 2]);
1977         glTexCoord2f(particle_texcoord2f[2], particle_texcoord2f[3]);glVertex3f(particle_vertex3f[ 3], particle_vertex3f[ 4], particle_vertex3f[ 5]);
1978         glTexCoord2f(particle_texcoord2f[4], particle_texcoord2f[5]);glVertex3f(particle_vertex3f[ 6], particle_vertex3f[ 7], particle_vertex3f[ 8]);
1979         glTexCoord2f(particle_texcoord2f[6], particle_texcoord2f[7]);glVertex3f(particle_vertex3f[ 9], particle_vertex3f[10], particle_vertex3f[11]);
1980         glEnd();
1981 #else
1982         R_Mesh_Draw(4, 2, polygonelements);
1983 #endif
1984 }
1985
1986 void R_DrawParticles (void)
1987 {
1988         int i;
1989         float minparticledist;
1990         particle_t *p;
1991
1992 #ifdef WORKINGLQUAKE
1993         CL_MoveParticles();
1994 #endif
1995
1996         // LordHavoc: early out conditions
1997         if ((!cl_numparticles) || (!r_drawparticles.integer))
1998                 return;
1999
2000         minparticledist = DotProduct(r_vieworigin, r_viewforward) + 4.0f;
2001
2002 #ifdef WORKINGLQUAKE
2003         glBindTexture(GL_TEXTURE_2D, particlefonttexture);
2004         glEnable(GL_BLEND);
2005         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
2006         glDepthMask(0);
2007         // LordHavoc: only render if not too close
2008         for (i = 0, p = particles;i < cl_numparticles;i++, p++)
2009                 if (p->type && DotProduct(p->org, r_viewforward) >= minparticledist)
2010                         R_DrawParticle(p);
2011         glDepthMask(1);
2012         glDisable(GL_BLEND);
2013         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2014 #else
2015         // LordHavoc: only render if not too close
2016         for (i = 0, p = particles;i < cl_numparticles;i++, p++)
2017         {
2018                 if (p->type)
2019                 {
2020                         c_particles++;
2021                         if (DotProduct(p->org, r_viewforward) >= minparticledist || p->orientation == PARTICLE_BEAM)
2022                         {
2023                                 if (p->type == pt_decal)
2024                                         R_DrawParticleCallback(p, 0);
2025                                 else
2026                                         R_MeshQueue_AddTransparent(p->org, R_DrawParticleCallback, p, 0);
2027                         }
2028                 }
2029         }
2030 #endif
2031 }
2032