X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=cl_particles.c;h=0367e5fa69d1b03a117dddcf6cbf812f364cc042;hp=30a799c0dd53802a9e24b0d0588a9008b01f542e;hb=aa2be95cac4543cdd49fae01e9dc412f7e95b801;hpb=6fe636cfb9d5ee6320f4cd6db33c0a6f38d1ee2c

diff --git a/cl_particles.c b/cl_particles.c
index 30a799c0..0367e5fa 100644
--- a/cl_particles.c
+++ b/cl_particles.c
@@ -148,36 +148,58 @@ void VectorVectors(const vec3_t forward, vec3_t right, vec3_t up)
 	VectorNormalizeFast(right);
 	CrossProduct(right, forward, up);
 }
+#if QW
+#include "pmove.h"
+extern qboolean PM_RecursiveHullCheck (hull_t *hull, int num, float p1f, float p2f, vec3_t p1, vec3_t p2, pmtrace_t *trace);
+#endif
+float CL_TraceLine (vec3_t start, vec3_t end, vec3_t impact, vec3_t normal, int contents, int hitbmodels, void **hitent)
+{
+#if QW
+	pmtrace_t trace;
+#else
+	trace_t trace;
+#endif
+	memset (&trace, 0, sizeof(trace));
+	trace.fraction = 1;
+	VectorCopy (end, trace.endpos);
+#if QW
+	PM_RecursiveHullCheck (cl.model_precache[1]->hulls, 0, 0, 1, start, end, &trace);
+#else
+	RecursiveHullCheck (cl.worldmodel->hulls, 0, 0, 1, start, end, &trace);
+#endif
+	VectorCopy(trace.endpos, impact);
+	VectorCopy(trace.plane.normal, normal);
+	return trace.fraction;
+}
 #else
 #include "cl_collision.h"
 #endif
 
-#define MAX_PARTICLES			8192	// default max # of particles at one time
+#define MAX_PARTICLES			32768	// default max # of particles at one time
 #define ABSOLUTE_MIN_PARTICLES	512		// no fewer than this no matter what's on the command line
 
 typedef enum
 {
-	pt_static, pt_rain, pt_bubble, pt_blood
+	pt_static, pt_rain, pt_bubble, pt_blood, pt_grow, pt_decal
 }
 ptype_t;
 
 #define PARTICLE_INVALID 0
 #define PARTICLE_BILLBOARD 1
-#define PARTICLE_BEAM 2
+#define PARTICLE_SPARK 2
 #define PARTICLE_ORIENTED_DOUBLESIDED 3
+#define PARTICLE_BEAM 4
 
-#define P_TEXNUM_FIRSTBIT 0
-#define P_TEXNUM_BITS 6
-#define P_ORIENTATION_FIRSTBIT (P_TEXNUM_FIRSTBIT + P_TEXNUM_BITS)
-#define P_ORIENTATION_BITS 2
-#define P_FLAGS_FIRSTBIT (P_ORIENTATION_FIRSTBIT + P_ORIENTATION_BITS)
-//#define P_DYNLIGHT (1 << (P_FLAGS_FIRSTBIT + 0))
-#define P_ADDITIVE (1 << (P_FLAGS_FIRSTBIT + 1))
+#define PBLEND_ALPHA 0
+#define PBLEND_ADD 1
+#define PBLEND_MOD 2
 
 typedef struct particle_s
 {
 	ptype_t		type;
-	unsigned int	flags; // dynamically lit, orientation, additive blending, texnum
+	int			orientation;
+	int			texnum;
+	int			blendmode;
 	vec3_t		org;
 	vec3_t		vel;
 	float		die;
@@ -193,6 +215,12 @@ typedef struct particle_s
 	float		friction; // how much air friction affects this object (objects with a low mass/size ratio tend to get more air friction)
 	float		pressure; // if non-zero, apply pressure to other particles
 	qbyte		color[4];
+#ifndef WORKINGLQUAKE
+	entity_render_t	*owner; // decal stuck to this entity
+	model_t		*ownermodel; // model the decal is stuck to (used to make sure the entity is still alive)
+	vec3_t		relativeorigin; // decal at this location in entity's coordinate space
+	vec3_t		relativedirection; // decal oriented this way relative to entity's coordinate space
+#endif
 }
 particle_t;
 
@@ -234,12 +262,14 @@ static int particlepalette[256] =
 
 //static int explosparkramp[8] = {0x4b0700, 0x6f0f00, 0x931f07, 0xb7330f, 0xcf632b, 0xe3974f, 0xffe7b5, 0xffffff};
 
-// these must match r_part.c's textures
+// texture numbers in particle font
 static const int tex_smoke[8] = {0, 1, 2, 3, 4, 5, 6, 7};
 static const int tex_rainsplash[16] = {8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23};
 static const int tex_particle = 24;
-static const int tex_rain = 25;
+static const int tex_raindrop = 25;
 static const int tex_bubble = 26;
+static const int tex_beam = 27;
+static const int tex_blooddecal[8] = {32, 33, 34, 35, 36, 37, 38, 39};
 
 static int			cl_maxparticles;
 static int			cl_numparticles;
@@ -254,8 +284,14 @@ cvar_t cl_particles_blood_size = {CVAR_SAVE, "cl_particles_blood_size", "8"};
 cvar_t cl_particles_blood_alpha = {CVAR_SAVE, "cl_particles_blood_alpha", "0.5"};
 cvar_t cl_particles_bulletimpacts = {CVAR_SAVE, "cl_particles_bulletimpacts", "1"};
 cvar_t cl_particles_smoke = {CVAR_SAVE, "cl_particles_smoke", "1"};
+cvar_t cl_particles_smoke_size = {CVAR_SAVE, "cl_particles_smoke_size", "7"};
+cvar_t cl_particles_smoke_alpha = {CVAR_SAVE, "cl_particles_smoke_alpha", "0.5"};
+cvar_t cl_particles_smoke_alphafade = {CVAR_SAVE, "cl_particles_smoke_alphafade", "0.55"};
 cvar_t cl_particles_sparks = {CVAR_SAVE, "cl_particles_sparks", "1"};
 cvar_t cl_particles_bubbles = {CVAR_SAVE, "cl_particles_bubbles", "1"};
+cvar_t cl_decals = {CVAR_SAVE, "cl_decals", "0"};
+cvar_t cl_decals_time = {CVAR_SAVE, "cl_decals_time", "0"};
+cvar_t cl_decals_fadetime = {CVAR_SAVE, "cl_decals_fadetime", "20"};
 
 #ifndef WORKINGLQUAKE
 static mempool_t *cl_part_mempool;
@@ -297,8 +333,14 @@ void CL_Particles_Init (void)
 	Cvar_RegisterVariable (&cl_particles_blood_alpha);
 	Cvar_RegisterVariable (&cl_particles_bulletimpacts);
 	Cvar_RegisterVariable (&cl_particles_smoke);
+	Cvar_RegisterVariable (&cl_particles_smoke_size);
+	Cvar_RegisterVariable (&cl_particles_smoke_alpha);
+	Cvar_RegisterVariable (&cl_particles_smoke_alphafade);
 	Cvar_RegisterVariable (&cl_particles_sparks);
 	Cvar_RegisterVariable (&cl_particles_bubbles);
+	Cvar_RegisterVariable (&cl_decals);
+	Cvar_RegisterVariable (&cl_decals_time);
+	Cvar_RegisterVariable (&cl_decals_fadetime);
 
 #ifdef WORKINGLQUAKE
 	particles = (particle_t *) Hunk_AllocName(cl_maxparticles * sizeof(particle_t), "particles");
@@ -311,41 +353,37 @@ void CL_Particles_Init (void)
 	cl_numparticles = 0;
 }
 
-#define particle(ptype, porientation, pcolor1, pcolor2, ptex, plight, padditive, pscalex, pscaley, palpha, palphafade, ptime, pgravity, pbounce, px, py, pz, pvx, pvy, pvz, ptime2, pvx2, pvy2, pvz2, pfriction, ppressure)\
+#define particle(ptype, porientation, pcolor1, pcolor2, ptex, plight, pblendmode, pscalex, pscaley, palpha, palphafade, ptime, pgravity, pbounce, px, py, pz, pvx, pvy, pvz, ptime2, pvx2, pvy2, pvz2, pfriction, ppressure)\
 {\
-	if (cl_numparticles >= cl_maxparticles)\
-		return;\
+	if (cl_numparticles < cl_maxparticles)\
 	{\
 		particle_t	*part;\
-		int tempcolor, tempcolor2, cr1, cg1, cb1, cr2, cg2, cb2;\
-		unsigned int partflags;\
-		partflags = ((porientation) << P_ORIENTATION_FIRSTBIT) | ((ptex) << P_TEXNUM_FIRSTBIT);\
-		if (padditive)\
-			partflags |= P_ADDITIVE;\
-		/*if (plight)*/\
-		/*	partflags |= P_DYNLIGHT;*/\
-		tempcolor = (pcolor1);\
-		tempcolor2 = (pcolor2);\
-		cr2 = ((tempcolor2) >> 16) & 0xFF;\
-		cg2 = ((tempcolor2) >> 8) & 0xFF;\
-		cb2 = (tempcolor2) & 0xFF;\
-		if (tempcolor != tempcolor2)\
+		int ptempcolor, ptempcolor2, pcr1, pcg1, pcb1, pcr2, pcg2, pcb2;\
+		ptempcolor = (pcolor1);\
+		ptempcolor2 = (pcolor2);\
+		pcr2 = ((ptempcolor2) >> 16) & 0xFF;\
+		pcg2 = ((ptempcolor2) >> 8) & 0xFF;\
+		pcb2 = (ptempcolor2) & 0xFF;\
+		if (ptempcolor != ptempcolor2)\
 		{\
-			cr1 = ((tempcolor) >> 16) & 0xFF;\
-			cg1 = ((tempcolor) >> 8) & 0xFF;\
-			cb1 = (tempcolor) & 0xFF;\
-			tempcolor = rand() & 0xFF;\
-			cr2 = (((cr2 - cr1) * tempcolor) >> 8) + cr1;\
-			cg2 = (((cg2 - cg1) * tempcolor) >> 8) + cg1;\
-			cb2 = (((cb2 - cb1) * tempcolor) >> 8) + cb1;\
+			pcr1 = ((ptempcolor) >> 16) & 0xFF;\
+			pcg1 = ((ptempcolor) >> 8) & 0xFF;\
+			pcb1 = (ptempcolor) & 0xFF;\
+			ptempcolor = rand() & 0xFF;\
+			pcr2 = (((pcr2 - pcr1) * ptempcolor) >> 8) + pcr1;\
+			pcg2 = (((pcg2 - pcg1) * ptempcolor) >> 8) + pcg1;\
+			pcb2 = (((pcb2 - pcb1) * ptempcolor) >> 8) + pcb1;\
 		}\
 		part = &particles[cl_numparticles++];\
+		memset(part, 0, sizeof(*part));\
 		part->type = (ptype);\
-		part->color[0] = cr2;\
-		part->color[1] = cg2;\
-		part->color[2] = cb2;\
+		part->color[0] = pcr2;\
+		part->color[1] = pcg2;\
+		part->color[2] = pcb2;\
 		part->color[3] = 0xFF;\
-		part->flags = partflags;\
+		part->orientation = porientation;\
+		part->texnum = ptex;\
+		part->blendmode = pblendmode;\
 		part->scalex = (pscalex);\
 		part->scaley = (pscaley);\
 		part->alpha = (palpha);\
@@ -405,9 +443,9 @@ void CL_EntityParticles (entity_t *ent)
 		forward[2] = -sp;
 
 #ifdef WORKINGLQUAKE
-		particle(pt_static, PARTICLE_BILLBOARD, particlepalette[0x6f], particlepalette[0x6f], tex_particle, false, false, 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);
+		particle(pt_static, PARTICLE_BILLBOARD, particlepalette[0x6f], particlepalette[0x6f], tex_particle, false, PBLEND_ALPHA, 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);
 #else
-		particle(pt_static, PARTICLE_BILLBOARD, particlepalette[0x6f], particlepalette[0x6f], tex_particle, false, false, 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);
+		particle(pt_static, PARTICLE_BILLBOARD, particlepalette[0x6f], particlepalette[0x6f], tex_particle, false, PBLEND_ALPHA, 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);
 #endif
 	}
 }
@@ -469,7 +507,7 @@ void CL_ReadPointFile_f (void)
 			Con_Printf ("Not enough free particles\n");
 			break;
 		}
-		particle(pt_static, PARTICLE_BILLBOARD, particlepalette[(-c)&15], particlepalette[(-c)&15], tex_particle, false, false, 2, 2, 255, 0, 99999, 0, 0, org[0], org[1], org[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
+		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);
 	}
 
 #ifdef WORKINGLQUAKE
@@ -526,7 +564,7 @@ void CL_ParticleExplosion (vec3_t org)
 	{
 		for (i = 0;i < 128;i++)
 		{
-			particle(pt_bubble, PARTICLE_BILLBOARD, 0x404040, 0x808080, tex_bubble, false, true, 2, 2, lhrandom(128, 255), 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);
+			particle(pt_bubble, PARTICLE_BILLBOARD, 0x404040, 0x808080, tex_bubble, false, PBLEND_ADD, 2, 2, lhrandom(128, 255), 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);
 		}
 	}
 	else
@@ -554,7 +592,7 @@ void CL_ParticleExplosion (vec3_t org)
 				VectorSubtract(v2, org, v2);
 #endif
 				VectorScale(v2, 2.0f, v2);
-				particle(pt_static, PARTICLE_BILLBOARD, 0x101010, 0x202020, tex_smoke[rand()&7], true, true, 12, 12, 255, 512, 9999, 0, 0, org[0], org[1], org[2], v2[0], v2[1], v2[2], 0, 0, 0, 0, 0, 0);
+				particle(pt_static, PARTICLE_BILLBOARD, 0x101010, 0x202020, tex_smoke[rand()&7], true, PBLEND_ADD, 12, 12, 255, 512, 9999, 0, 0, org[0], org[1], org[2], v2[0], v2[1], v2[2], 0, 0, 0, 0, 0, 0);
 			}
 		}
 		*/
@@ -565,7 +603,7 @@ void CL_ParticleExplosion (vec3_t org)
 			for (i = 0;i < 256;i++)
 			{
 				k = particlepalette[0x68 + (rand() & 7)];
-				particle(pt_static, PARTICLE_BEAM, k, k, tex_particle, false, true, 1.5f, 0.05f, lhrandom(0, 255), 512, 9999, 1, 0, org[0], org[1], org[2], lhrandom(-192, 192), lhrandom(-192, 192), lhrandom(-192, 192) + 160, 0, 0, 0, 0, 0, 0);
+				particle(pt_static, PARTICLE_SPARK, k, k, tex_particle, false, PBLEND_ADD, 1.5f, 0.05f, lhrandom(0, 255), 512, 9999, 1, 0, org[0], org[1], org[2], lhrandom(-192, 192), lhrandom(-192, 192), lhrandom(-192, 192) + 160, 0, 0, 0, 0, 0, 0);
 			}
 		}
 	}
@@ -588,7 +626,7 @@ void CL_ParticleExplosion2 (vec3_t org, int colorStart, int colorLength)
 	for (i = 0;i < 512;i++)
 	{
 		k = particlepalette[colorStart + (i % colorLength)];
-		particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, false, 1.5, 1.5, 255, 384, 0.3, 0, 0, org[0] + lhrandom(-8, 8), org[1] + lhrandom(-8, 8), org[2] + lhrandom(-8, 8), lhrandom(-192, 192), lhrandom(-192, 192), lhrandom(-192, 192), 0, 0, 0, 0, 1, 0);
+		particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ALPHA, 1.5, 1.5, 255, 384, 0.3, 0, 0, org[0] + lhrandom(-8, 8), org[1] + lhrandom(-8, 8), org[2] + lhrandom(-8, 8), lhrandom(-192, 192), lhrandom(-192, 192), lhrandom(-192, 192), 0, 0, 0, 0, 1, 0);
 	}
 }
 
@@ -626,7 +664,7 @@ void CL_RunParticleEffect (vec3_t org, vec3_t dir, int color, int count)
 	while (count--)
 	{
 		k = particlepalette[color + (rand()&7)];
-		particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, false, 1, 1, 255, 512, 9999, 0, 0, org[0] + lhrandom(-8, 8), org[1] + lhrandom(-8, 8), org[2] + lhrandom(-8, 8), lhrandom(-15, 15), lhrandom(-15, 15), lhrandom(-15, 15), 0, 0, 0, 0, 0, 0);
+		particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ALPHA, 1, 1, 255, 512, 9999, 0, 0, org[0] + lhrandom(-8, 8), org[1] + lhrandom(-8, 8), org[2] + lhrandom(-8, 8), lhrandom(-15, 15), lhrandom(-15, 15), lhrandom(-15, 15), 0, 0, 0, 0, 0, 0);
 	}
 }
 
@@ -652,7 +690,7 @@ void CL_SparkShower (vec3_t org, vec3_t dir, int count)
 			k = count / 4;
 			while(k--)
 			{
-				particle(pt_static, PARTICLE_BILLBOARD, 0x101010, 0x202020, tex_smoke[rand()&7], true, true, 4, 4, 255, 1024, 9999, -0.2, 0, org[0] + 0.125f * lhrandom(-count, count), org[1] + 0.125f * lhrandom (-count, count), org[2] + 0.125f * lhrandom(-count, count), lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(0, 16), 0, 0, 0, 0, 0, 0);
+				particle(pt_grow, PARTICLE_BILLBOARD, 0x101010, 0x202020, tex_smoke[rand()&7], true, PBLEND_ADD, 3, 3, 255, 1024, 9999, -0.2, 0, org[0] + 0.125f * lhrandom(-count, count), org[1] + 0.125f * lhrandom (-count, count), org[2] + 0.125f * lhrandom(-count, count), lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(0, 16), 15, 0, 0, 0, 0, 0);
 			}
 		}
 
@@ -662,7 +700,7 @@ void CL_SparkShower (vec3_t org, vec3_t dir, int count)
 			while(count--)
 			{
 				k = particlepalette[0x68 + (rand() & 7)];
-				particle(pt_static, PARTICLE_BEAM, k, k, tex_particle, false, true, 0.4f, 0.015f, lhrandom(64, 255), 512, 9999, 1, 0, org[0], org[1], org[2], lhrandom(-64, 64) + dir[0], lhrandom(-64, 64) + dir[1], lhrandom(0, 128) + dir[2], 0, 0, 0, 0, 0, 0);
+				particle(pt_static, PARTICLE_SPARK, k, k, tex_particle, false, PBLEND_ADD, 0.4f, 0.015f, lhrandom(64, 255), 512, 9999, 1, 0, org[0], org[1], org[2], lhrandom(-64, 64) + dir[0], lhrandom(-64, 64) + dir[1], lhrandom(0, 128) + dir[2], 0, 0, 0, 0, 0, 0);
 			}
 		}
 	}
@@ -691,7 +729,8 @@ void CL_BloodPuff (vec3_t org, vec3_t vel, int count)
 	a = cl_particles_blood_alpha.value * 255;
 	while(bloodcount > 0)
 	{
-		particle(pt_blood, PARTICLE_BILLBOARD, 0x000000, 0x200000, tex_smoke[rand()&7], true, false, r, r, a, a * 0.5, 9999, 0, -1, org[0], org[1], org[2], vel[0] + lhrandom(-s, s), vel[1] + lhrandom(-s, s), vel[2] + lhrandom(-s, s), 0, 0, 0, 0, 1, 0);
+		particle(pt_blood, PARTICLE_BILLBOARD, 0xFFFFFF, 0xFFFFFF, tex_blooddecal[rand()&7], true, PBLEND_MOD, r, r, a * 3, a * 1.5, 9999, 0, -1, org[0], org[1], org[2], vel[0] + lhrandom(-s, s), vel[1] + lhrandom(-s, s), vel[2] + lhrandom(-s, s), 0, 0, 0, 0, 1, 0);
+		//particle(pt_blood, PARTICLE_BILLBOARD, 0x000000, 0x200000, tex_smoke[rand()&7], true, PBLEND_ALPHA, r, r, a, a * 0.5, 9999, 0, -1, org[0], org[1], org[2], vel[0] + lhrandom(-s, s), vel[1] + lhrandom(-s, s), vel[2] + lhrandom(-s, s), 0, 0, 0, 0, 1, 0);
 		bloodcount -= r;
 	}
 }
@@ -727,7 +766,8 @@ void CL_BloodShower (vec3_t mins, vec3_t maxs, float velspeed, int count)
 		vel[1] = (org[1] - center[1]) * velscale[1];
 		vel[2] = (org[2] - center[2]) * velscale[2];
 		bloodcount -= r;
-		particle(pt_blood, PARTICLE_BILLBOARD, 0x000000, 0x200000, tex_smoke[rand()&7], true, false, r, r, a, a * 0.5, 9999, 0, -1, org[0], org[1], org[2], vel[0], vel[1], vel[2], 0, 0, 0, 0, 1, 0);
+		particle(pt_blood, PARTICLE_BILLBOARD, 0xFFFFFF, 0xFFFFFF, tex_blooddecal[rand()&7], true, PBLEND_MOD, r, r, a * 3, a * 1.5, 9999, 0, -1, org[0], org[1], org[2], vel[0], vel[1], vel[2], 0, 0, 0, 0, 1, 0);
+		//particle(pt_blood, PARTICLE_BILLBOARD, 0x000000, 0x200000, tex_smoke[rand()&7], true, PBLEND_ALPHA, r, r, a, a * 0.5, 9999, 0, -1, org[0], org[1], org[2], vel[0], vel[1], vel[2], 0, 0, 0, 0, 1, 0);
 	}
 }
 
@@ -743,7 +783,7 @@ void CL_ParticleCube (vec3_t mins, vec3_t maxs, vec3_t dir, int count, int color
 	while (count--)
 	{
 		k = particlepalette[colorbase + (rand()&3)];
-		particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, false, 2, 2, 255, 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);
+		particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ALPHA, 2, 2, 255, 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);
 	}
 }
 
@@ -781,14 +821,14 @@ void CL_ParticleRain (vec3_t mins, vec3_t maxs, vec3_t dir, int count, int color
 		while(count--)
 		{
 			k = particlepalette[colorbase + (rand()&3)];
-			particle(pt_rain, PARTICLE_BEAM, k, k, tex_particle, true, true, 0.5, 0.02, lhrandom(8, 16), 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);
+			particle(pt_rain, PARTICLE_SPARK, k, k, tex_particle, true, PBLEND_ADD, 0.5, 0.02, lhrandom(8, 16), 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);
 		}
 		break;
 	case 1:
 		while(count--)
 		{
 			k = particlepalette[colorbase + (rand()&3)];
-			particle(pt_rain, PARTICLE_BILLBOARD, k, k, tex_particle, false, true, 1, 1, lhrandom(64, 128), 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);
+			particle(pt_rain, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ADD, 1, 1, lhrandom(64, 128), 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);
 		}
 		break;
 	default:
@@ -821,7 +861,7 @@ void CL_Stardust (vec3_t mins, vec3_t maxs, int count)
 		VectorNormalizeFast(v);
 		VectorScale(v, 100, v);
 		v[2] += sv_gravity.value * 0.15f;
-		particle(pt_static, PARTICLE_BILLBOARD, 0x903010, 0xFFD030, tex_particle, false, true, 1.5, 1.5, lhrandom(64, 128), 128, 9999, 1, 0, o[0], o[1], o[2], v[0], v[1], v[2], 0, 0, 0, 0, 0, 0);
+		particle(pt_static, PARTICLE_BILLBOARD, 0x903010, 0xFFD030, tex_particle, false, PBLEND_ADD, 1.5, 1.5, lhrandom(64, 128), 128, 9999, 1, 0, o[0], o[1], o[2], v[0], v[1], v[2], 0, 0, 0, 0, 0, 0);
 	}
 }
 
@@ -837,9 +877,9 @@ void CL_FlameCube (vec3_t mins, vec3_t maxs, int count)
 	while (count--)
 	{
 		k = particlepalette[224 + (rand()&15)];
-		particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, true, 4, 4, lhrandom(64, 128), 384, 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);
+		particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ADD, 4, 4, lhrandom(64, 128), 384, 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);
 		if (count & 1)
-			particle(pt_static, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], false, true, 6, 6, lhrandom(48, 96), 64, 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);
+			particle(pt_static, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], false, PBLEND_ADD, 6, 6, lhrandom(48, 96), 64, 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);
 	}
 }
 
@@ -851,7 +891,7 @@ void CL_Flames (vec3_t org, vec3_t vel, int count)
 	while (count--)
 	{
 		k = particlepalette[224 + (rand()&15)];
-		particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, true, 4, 4, lhrandom(64, 128), 384, 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);
+		particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ADD, 4, 4, lhrandom(64, 128), 384, 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);
 	}
 }
 
@@ -882,7 +922,7 @@ void CL_LavaSplash (vec3_t origin)
 			org[2] = origin[2] + lhrandom(0, 64);
 			vel = lhrandom(50, 120) / VectorLength(dir); // normalize and scale
 			k = particlepalette[224 + (rand()&7)];
-			particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, true, 7, 7, 255, 192, 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);
+			particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ADD, 7, 7, 255, 192, 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);
 		}
 	}
 }
@@ -902,7 +942,7 @@ void R_TeleportSplash (vec3_t org)
 	for (i=-16 ; i<16 ; i+=8)
 		for (j=-16 ; j<16 ; j+=8)
 			for (k=-24 ; k<32 ; k+=8)
-				particle(pt_static, PARTICLE_BILLBOARD, 0xA0A0A0, 0xFFFFFF, tex_particle, false, true, 10, 10, lhrandom(64, 128), 256, 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);
+				particle(pt_static, PARTICLE_BILLBOARD, 0xA0A0A0, 0xFFFFFF, tex_particle, false, PBLEND_ADD, 10, 10, lhrandom(64, 128), 256, 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);
 }
 #endif
 
@@ -916,6 +956,9 @@ void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent)
 	float len, dec, speed, r;
 	int contents, smoke, blood, bubbles;
 
+	if (end[0] == start[0] && end[1] == start[1] && end[2] == start[2])
+		return;
+
 	VectorSubtract(end, start, dir);
 	VectorNormalize(dir);
 
@@ -960,13 +1003,13 @@ void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent)
 				dec = 3;
 				if (smoke)
 				{
-					particle(pt_static, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], false, true, dec, dec, 32, 64, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-5, 5), lhrandom(-5, 5), lhrandom(-5, 5), 0, 0, 0, 0, 0, 0);
-					particle(pt_static, PARTICLE_BILLBOARD, 0x801010, 0xFFA020, tex_smoke[rand()&7], false, true, dec, dec, 128, 768, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-20, 20), lhrandom(-20, 20), lhrandom(-20, 20), 0, 0, 0, 0, 0, 0);
+					particle(pt_grow,   PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], false, PBLEND_ADD, dec, dec, cl_particles_smoke_alpha.value*125, cl_particles_smoke_alphafade.value*125, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-5, 5), lhrandom(-5, 5), lhrandom(-5, 5), cl_particles_smoke_size.value, 0, 0, 0, 0, 0);
+					particle(pt_static, PARTICLE_BILLBOARD, 0x801010, 0xFFA020, tex_smoke[rand()&7], false, PBLEND_ADD, dec, dec, cl_particles_smoke_alpha.value*288, 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);
 				}
 				if (bubbles)
 				{
 					r = lhrandom(1, 2);
-					particle(pt_bubble, PARTICLE_BILLBOARD, 0x404040, 0x808080, tex_bubble, false, true, r, r, lhrandom(64, 255), 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);
+					particle(pt_bubble, PARTICLE_BILLBOARD, 0x404040, 0x808080, tex_bubble, false, PBLEND_ADD, r, r, lhrandom(64, 255), 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);
 				}
 				break;
 
@@ -975,7 +1018,7 @@ void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent)
 				dec = 3;
 				if (cl_particles.integer && cl_particles_smoke.integer)
 				{
-					particle(pt_static, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], false, true, dec, dec, 32, 96, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-5, 5), lhrandom(-5, 5), lhrandom(-5, 5), 0, 0, 0, 0, 0, 0);
+					particle(pt_grow, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], false, PBLEND_ADD, dec, dec, cl_particles_smoke_alpha.value*100, cl_particles_smoke_alphafade.value*100, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-5, 5), lhrandom(-5, 5), lhrandom(-5, 5), cl_particles_smoke_size.value, 0, 0, 0, 0, 0);
 				}
 				break;
 
@@ -985,7 +1028,8 @@ void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent)
 				dec = cl_particles_blood_size.value;
 				if (blood)
 				{
-					particle(pt_blood, PARTICLE_BILLBOARD, 0x100000, 0x280000, tex_smoke[rand()&7], true, false, dec, dec, cl_particles_blood_alpha.value * 255.0f, cl_particles_blood_alpha.value * 255.0f * 0.5, 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);
+					particle(pt_blood, PARTICLE_BILLBOARD, 0xFFFFFF, 0xFFFFFF, tex_blooddecal[rand()&7], true, PBLEND_MOD, dec, dec, cl_particles_blood_alpha.value * 255.0f * 3.0f, cl_particles_blood_alpha.value * 255.0f * 0.5f * 1.5f, 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);
+					//particle(pt_blood, PARTICLE_BILLBOARD, 0x100000, 0x280000, tex_smoke[rand()&7], true, PBLEND_ALPHA, dec, dec, cl_particles_blood_alpha.value * 255.0f, cl_particles_blood_alpha.value * 255.0f * 0.5, 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);
 				}
 				break;
 
@@ -993,7 +1037,7 @@ void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent)
 				dec = 6;
 				if (smoke)
 				{
-					particle(pt_static, PARTICLE_BILLBOARD, 0x002000, 0x003000, tex_particle, false, true, dec, dec, 128, 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);
+					particle(pt_static, PARTICLE_BILLBOARD, 0x002000, 0x003000, tex_particle, false, PBLEND_ADD, dec, dec, 128, 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);
 				}
 				break;
 
@@ -1001,7 +1045,7 @@ void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent)
 				dec = 6;
 				if (smoke)
 				{
-					particle(pt_static, PARTICLE_BILLBOARD, 0x301000, 0x502000, tex_particle, false, true, dec, dec, 128, 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);
+					particle(pt_static, PARTICLE_BILLBOARD, 0x301000, 0x502000, tex_particle, false, PBLEND_ADD, dec, dec, 128, 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);
 				}
 				break;
 
@@ -1009,7 +1053,7 @@ void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent)
 				dec = 6;
 				if (smoke)
 				{
-					particle(pt_static, PARTICLE_BILLBOARD, 0x502030, 0x502030, tex_particle, false, true, dec, dec, 128, 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);
+					particle(pt_static, PARTICLE_BILLBOARD, 0x502030, 0x502030, tex_particle, false, PBLEND_ADD, dec, dec, 128, 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);
 				}
 				break;
 
@@ -1017,9 +1061,16 @@ void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent)
 				dec = 7;
 				if (smoke)
 				{
-					particle(pt_static, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], true, false, dec, dec, 64, 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);
+					particle(pt_static, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], true, PBLEND_ALPHA, dec, dec, 64, 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);
 				}
 				break;
+			case 8: // Nexiuz plasma trail
+				dec = 4;
+				if (smoke)
+				{
+					//particle(pt_static, PARTICLE_BILLBOARD, 0x2030FF, 0x80C0FF, tex_particle, false, PBLEND_ADD, 3.0f, 3.0f, lhrandom(64, 255), 512, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-32, 32) + dir[0] * -64.0f, lhrandom(-32, 32) + dir[1] * -64.0f, lhrandom(-32, 32) + dir[2] * -64.0f, 0, 0, 0, 0, 0, 0);
+					particle(pt_static, PARTICLE_BILLBOARD, 0x283880, 0x283880, tex_particle, false, PBLEND_ADD, dec, dec, 255, 1024, 9999, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
+				}
 		}
 
 		// advance to next time and position
@@ -1049,11 +1100,64 @@ void CL_RocketTrail2 (vec3_t start, vec3_t end, int color, entity_t *ent)
 	color = particlepalette[color];
 	while (len--)
 	{
-		particle(pt_static, PARTICLE_BILLBOARD, color, color, tex_particle, false, false, 5, 5, 128, 320, 9999, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
+		particle(pt_static, PARTICLE_BILLBOARD, color, color, tex_particle, false, PBLEND_ALPHA, 5, 5, 128, 320, 9999, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
 		VectorAdd (pos, vec, pos);
 	}
 }
 
+void CL_BeamParticle (const vec3_t start, const vec3_t end, vec_t radius, float red, float green, float blue, float alpha, float lifetime)
+{
+	int tempcolor2, cr, cg, cb;
+	cr = red * 255;
+	cg = green * 255;
+	cb = blue * 255;
+	tempcolor2 = (bound(0, cr, 255) << 16) | (bound(0, cg, 255) << 8) | bound(0, cb, 255);
+	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);
+}
+
+void CL_Tei_Smoke(const vec3_t org, const vec3_t dir, int count)
+{
+	int k;
+	if (!cl_particles.integer) return;
+
+	// smoke puff
+	if (cl_particles_smoke.integer)
+	{
+		k = count / 4;
+		while(k--)
+		{
+			particle(pt_grow, PARTICLE_BILLBOARD, 0x202020, 0x404040, tex_smoke[rand()&7], true, PBLEND_ADD, 5, 5, 255, 512, 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);
+		}
+	}
+}
+
+void CL_Tei_PlasmaHit(const vec3_t org, const vec3_t dir, int count)
+{
+	int k;
+	if (!cl_particles.integer) return;
+
+	if (cl_stainmaps.integer)
+		R_Stain(org, 40, 96, 96, 96, 40, 128, 128, 128, 40);
+
+	// smoke puff
+	if (cl_particles_smoke.integer)
+	{
+		k = count / 4;
+		while(k--)
+		{
+			particle(pt_grow, PARTICLE_BILLBOARD, 0x202020, 0x404040, tex_smoke[rand()&7], true, PBLEND_ADD, 5, 5, 255, 512, 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);
+		}
+	}
+
+	if (cl_particles_sparks.integer)
+	{
+		// sparks
+		while(count--)
+		{
+			particle(pt_static, PARTICLE_SPARK, 0x2030FF, 0x80C0FF, tex_particle, false, PBLEND_ADD, 2.0f, 0.1f, lhrandom(64, 255), 512, 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);
+		}
+	}
+}
 
 /*
 ===============
@@ -1065,6 +1169,11 @@ void CL_MoveParticles (void)
 	particle_t *p;
 	int i, activeparticles, maxparticle, j, a, pressureused = false, content;
 	float gravity, dvel, bloodwaterfade, frametime, f, dist, normal[3], v[3], org[3];
+#ifdef WORKINGLQUAKE
+	void *hitent;
+#else
+	entity_render_t *hitent;
+#endif
 
 	// LordHavoc: early out condition
 	if (!cl_numparticles)
@@ -1088,20 +1197,47 @@ void CL_MoveParticles (void)
 		VectorCopy(p->org, p->oldorg);
 		VectorMA(p->org, frametime, p->vel, p->org);
 		VectorCopy(p->org, org);
-#ifndef WORKINGLQUAKE
 		if (p->bounce)
 		{
-			if (CL_TraceLine(p->oldorg, p->org, v, normal, 0, true, NULL) < 1)
+			if (CL_TraceLine(p->oldorg, p->org, v, normal, 0, true, &hitent) < 1)
 			{
 				VectorCopy(v, p->org);
 				if (p->bounce < 0)
 				{
 					// assume it's blood (lame, but...)
+#ifndef WORKINGLQUAKE
 					if (cl_stainmaps.integer)
 						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));
-					p->die = -1;
-					freeparticles[j++] = p;
-					continue;
+#endif
+					if (cl_decals.integer)
+					{
+						p->type = pt_decal;
+						p->orientation = PARTICLE_ORIENTED_DOUBLESIDED;
+#ifndef WORKINGLQUAKE
+						p->owner = hitent;
+						p->ownermodel = hitent->model;
+						Matrix4x4_Transform(&hitent->inversematrix, v, p->relativeorigin);
+						Matrix4x4_Transform3x3(&hitent->inversematrix, normal, p->relativedirection);
+						VectorAdd(p->relativeorigin, p->relativedirection, p->relativeorigin);
+#endif
+						p->time2 = cl.time + cl_decals_time.value;
+						p->die = p->time2 + cl_decals_fadetime.value;
+						p->alphafade = 0;
+						VectorCopy(normal, p->vel2);
+						VectorClear(p->vel);
+						VectorAdd(p->org, normal, p->org);
+						p->bounce = 0;
+						p->friction = 0;
+						p->gravity = 0;
+						p->scalex *= 1.25f;
+						p->scaley *= 1.25f;
+					}
+					else
+					{
+						p->die = -1;
+						freeparticles[j++] = p;
+						continue;
+					}
 				}
 				else
 				{
@@ -1112,7 +1248,6 @@ void CL_MoveParticles (void)
 				}
 			}
 		}
-#endif
 		p->vel[2] -= p->gravity * gravity;
 		p->alpha -= p->alphafade * frametime;
 		if (p->friction)
@@ -1172,6 +1307,26 @@ void CL_MoveParticles (void)
 				if (a != CONTENTS_EMPTY && a != CONTENTS_SKY)
 					p->die = -1;
 				break;
+			case pt_grow:
+				p->scalex += frametime * p->time2;
+				p->scaley += frametime * p->time2;
+				break;
+			case pt_decal:
+#ifndef WORKINGLQUAKE
+				if (p->owner->model == p->ownermodel)
+				{
+					Matrix4x4_Transform(&p->owner->matrix, p->relativeorigin, p->org);
+					Matrix4x4_Transform3x3(&p->owner->matrix, p->relativedirection, p->vel2);
+				}
+				else
+					p->die = -1;
+#endif
+				if (cl.time > p->time2)
+				{
+					p->alphafade = p->alpha / (p->die - cl.time);
+					p->time2 += 10000;
+				}
+				break;
 			default:
 				printf("unknown particle type %i\n", p->type);
 				p->die = -1;
@@ -1234,6 +1389,7 @@ void CL_MoveParticles (void)
 // particletexture_t is a rectangle in the particlefonttexture
 typedef struct
 {
+	rtexture_t *texture;
 	float s1, t1, s2, t2;
 }
 particletexture_t;
@@ -1281,30 +1437,29 @@ static qbyte shadebubble(float dx, float dy, vec3_t light)
 		return 0;
 }
 
-static void setuptex(int cltexnum, int rtexnum, qbyte *data, qbyte *particletexturedata)
+static void setuptex(int texnum, qbyte *data, qbyte *particletexturedata)
 {
 	int basex, basey, y;
-	basex = ((rtexnum >> 0) & 7) * 32;
-	basey = ((rtexnum >> 3) & 7) * 32;
-	particletexture[cltexnum].s1 = (basex + 1) / 256.0f;
-	particletexture[cltexnum].t1 = (basey + 1) / 256.0f;
-	particletexture[cltexnum].s2 = (basex + 31) / 256.0f;
-	particletexture[cltexnum].t2 = (basey + 31) / 256.0f;
+	basex = ((texnum >> 0) & 7) * 32;
+	basey = ((texnum >> 3) & 7) * 32;
+	particletexture[texnum].s1 = (basex + 1) / 256.0f;
+	particletexture[texnum].t1 = (basey + 1) / 256.0f;
+	particletexture[texnum].s2 = (basex + 31) / 256.0f;
+	particletexture[texnum].t2 = (basey + 31) / 256.0f;
 	for (y = 0;y < 32;y++)
 		memcpy(particletexturedata + ((basey + y) * 256 + basex) * 4, data + y * 32 * 4, 32 * 4);
 }
 
 static void R_InitParticleTexture (void)
 {
-	int x,y,d,i,m;
-	float dx, dy, radius, f, f2;
-	qbyte data[32][32][4], noise1[64][64], noise2[64][64];
+	int x, y, d, i, j, k, m;
+	float cx, cy, dx, dy, radius, f, f2;
+	qbyte data[32][32][4], noise1[64][64], noise2[64][64], data2[64][16][4];
 	vec3_t light;
 	qbyte particletexturedata[256*256*4];
 
 	memset(particletexturedata, 255, sizeof(particletexturedata));
 
-	// the particletexture[][] array numbers must match the cl_part.c textures
 	// smoke/blood
 	for (i = 0;i < 8;i++)
 	{
@@ -1333,7 +1488,7 @@ static void R_InitParticleTexture (void)
 		}
 		while (m < 224);
 
-		setuptex(i + 0, i + 0, &data[0][0][0], particletexturedata);
+		setuptex(tex_smoke[i], &data[0][0][0], particletexturedata);
 	}
 
 	// rain splash
@@ -1353,7 +1508,7 @@ static void R_InitParticleTexture (void)
 				data[y][x][3] = (int) f;
 			}
 		}
-		setuptex(i + 8, i + 16, &data[0][0][0], particletexturedata);
+		setuptex(tex_rainsplash[i], &data[0][0][0], particletexturedata);
 	}
 
 	// normal particle
@@ -1369,7 +1524,7 @@ static void R_InitParticleTexture (void)
 			data[y][x][3] = (qbyte) d;
 		}
 	}
-	setuptex(24, 32, &data[0][0][0], particletexturedata);
+	setuptex(tex_particle, &data[0][0][0], particletexturedata);
 
 	// rain
 	light[0] = 1;light[1] = 1;light[2] = 1;
@@ -1382,7 +1537,7 @@ static void R_InitParticleTexture (void)
 			data[y][x][3] = shadebubble((x - 16) * (1.0 / 8.0), y < 24 ? (y - 24) * (1.0 / 24.0) : (y - 24) * (1.0 / 8.0), light);
 		}
 	}
-	setuptex(25, 33, &data[0][0][0], particletexturedata);
+	setuptex(tex_raindrop, &data[0][0][0], particletexturedata);
 
 	// bubble
 	light[0] = 1;light[1] = 1;light[2] = 1;
@@ -1395,14 +1550,79 @@ static void R_InitParticleTexture (void)
 			data[y][x][3] = shadebubble((x - 16) * (1.0 / 16.0), (y - 16) * (1.0 / 16.0), light);
 		}
 	}
-	setuptex(26, 34, &data[0][0][0], particletexturedata);
+	setuptex(tex_bubble, &data[0][0][0], particletexturedata);
+
+	// smoke/blood
+	for (i = 0;i < 8;i++)
+	{
+		memset(&data[0][0][0], 255, sizeof(data));
+		for (j = 1;j < 8;j++)
+		{
+			for (k = 0;k < 3;k++)
+			{
+				cx = lhrandom(j + 1, 30 - j);
+				cy = lhrandom(j + 1, 30 - j);
+				for (y = 0;y < 32;y++)
+				{
+					for (x = 0;x < 32;x++)
+					{
+						dx = (x - cx);
+						dy = (y - cy);
+						f = 1.0f - sqrt(dx * dx + dy * dy) / j;
+						if (f > 0)
+						{
+							data[y][x][0] = data[y][x][0] + f * 0.5 * ( 160 - data[y][x][0]);
+							data[y][x][1] = data[y][x][1] + f * 0.5 * ( 32 - data[y][x][1]);
+							data[y][x][2] = data[y][x][2] + f * 0.5 * ( 32 - data[y][x][2]);
+						}
+					}
+				}
+			}
+		}
+		// use inverted colors so we can scale them later using glColor and use an inverse blend
+		for (y = 0;y < 32;y++)
+		{
+			for (x = 0;x < 32;x++)
+			{
+				data[y][x][0] = 255 - data[y][x][0];
+				data[y][x][1] = 255 - data[y][x][1];
+				data[y][x][2] = 255 - data[y][x][2];
+			}
+		}
+		setuptex(tex_blooddecal[i], &data[0][0][0], particletexturedata);
+	}
 
 #if WORKINGLQUAKE
 	glBindTexture(GL_TEXTURE_2D, (particlefonttexture = gl_extension_number++));
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 #else
-	particlefonttexture = R_LoadTexture (particletexturepool, "particlefont", 256, 256, particletexturedata, TEXTYPE_RGBA, TEXF_ALPHA | TEXF_PRECACHE);
+	particlefonttexture = R_LoadTexture2D(particletexturepool, "particlefont", 256, 256, particletexturedata, TEXTYPE_RGBA, TEXF_ALPHA | TEXF_PRECACHE, NULL);
+	for (i = 0;i < MAX_PARTICLETEXTURES;i++)
+		particletexture[i].texture = particlefonttexture;
+
+	// beam
+	fractalnoise(&noise1[0][0], 64, 4);
+	m = 0;
+	for (y = 0;y < 64;y++)
+	{
+		for (x = 0;x < 16;x++)
+		{
+			if (x < 8)
+				d = x;
+			else
+				d = (15 - x);
+			d = d * d * noise1[y][x] / (7 * 7);
+			data2[y][x][0] = data2[y][x][1] = data2[y][x][2] = (qbyte) bound(0, d, 255);
+			data2[y][x][3] = 255;
+		}
+	}
+
+	particletexture[tex_beam].texture = R_LoadTexture2D(particletexturepool, "beam", 16, 64, &data2[0][0][0], TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
+	particletexture[tex_beam].s1 = 0;
+	particletexture[tex_beam].t1 = 0;
+	particletexture[tex_beam].s2 = 1;
+	particletexture[tex_beam].t2 = 1;
 #endif
 }
 
@@ -1442,81 +1662,21 @@ void R_InitParticles(void)
 float varray_vertex[16];
 #endif
 
+#ifdef WORKINGLQUAKE
+void R_DrawParticle(particle_t *p)
+{
+#else
 void R_DrawParticleCallback(const void *calldata1, int calldata2)
 {
-	int additive, texnum, orientation;
-	float org[3], up2[3], v[3], right[3], up[3], fog, ifog, fogvec[3], cr, cg, cb, ca;
-	particletexture_t *tex;
-#ifndef WORKINGLQUAKE
+	const particle_t *p = calldata1;
 	rmeshstate_t m;
 #endif
-	const particle_t *p = calldata1;
+	float org[3], up2[3], v[3], right[3], up[3], fog, ifog, fogvec[3], cr, cg, cb, ca;
+	particletexture_t *tex;
 
 	VectorCopy(p->org, org);
-	orientation = (p->flags >> P_ORIENTATION_FIRSTBIT) & ((1 << P_ORIENTATION_BITS) - 1);
-	texnum = (p->flags >> P_TEXNUM_FIRSTBIT) & ((1 << P_TEXNUM_BITS) - 1);
-	//dynlight = p->flags & P_DYNLIGHT;
-	additive = p->flags & P_ADDITIVE;
-
-#ifdef WORKINGLQUAKE
-	if (additive)
-		glBlendFunc(GL_SRC_ALPHA, GL_ONE);
-	else
-		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-#else
-	memset(&m, 0, sizeof(m));
-	m.blendfunc1 = GL_SRC_ALPHA;
-	if (additive)
-		m.blendfunc2 = GL_ONE;
-	else
-		m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
-	m.tex[0] = R_GetTexture(particlefonttexture);
-	R_Mesh_Matrix(&r_identitymatrix);
-	R_Mesh_State(&m);
-#endif
 
-	tex = &particletexture[texnum];
-	cr = p->color[0] * (1.0f / 255.0f);
-	cg = p->color[1] * (1.0f / 255.0f);
-	cb = p->color[2] * (1.0f / 255.0f);
-	ca = p->alpha * (1.0f / 255.0f);
-#ifndef WORKINGLQUAKE
-	if (fogenabled)
-	{
-		VectorSubtract(org, r_origin, fogvec);
-		fog = exp(fogdensity/DotProduct(fogvec,fogvec));
-		ifog = 1 - fog;
-		cr = cr * ifog;
-		cg = cg * ifog;
-		cb = cb * ifog;
-		if (!additive)
-		{
-			cr += fogcolor[0] * fog;
-			cg += fogcolor[1] * fog;
-			cb += fogcolor[2] * fog;
-		}
-	}
-	cr *= r_colorscale;
-	cg *= r_colorscale;
-	cb *= r_colorscale;
-
-	varray_color[ 0] = varray_color[ 4] = varray_color[ 8] = varray_color[12] = cr;
-	varray_color[ 1] = varray_color[ 5] = varray_color[ 9] = varray_color[13] = cg;
-	varray_color[ 2] = varray_color[ 6] = varray_color[10] = varray_color[14] = cb;
-	varray_color[ 3] = varray_color[ 7] = varray_color[11] = varray_color[15] = ca;
-	varray_texcoord[0][0] = tex->s2;varray_texcoord[0][1] = tex->t1;
-	varray_texcoord[0][2] = tex->s1;varray_texcoord[0][3] = tex->t1;
-	varray_texcoord[0][4] = tex->s1;varray_texcoord[0][5] = tex->t2;
-	varray_texcoord[0][6] = tex->s2;varray_texcoord[0][7] = tex->t2;
-#endif
-
-	if (orientation == PARTICLE_BEAM)
-	{
-		VectorMA(p->org, -p->scaley, p->vel, v);
-		VectorMA(p->org, p->scaley, p->vel, up2);
-		R_CalcBeamVerts(varray_vertex, v, up2, p->scalex);
-	}
-	else if (orientation == PARTICLE_BILLBOARD)
+	if (p->orientation == PARTICLE_BILLBOARD)
 	{
 		VectorScale(vright, p->scalex, right);
 		VectorScale(vup, p->scaley, up);
@@ -1533,7 +1693,15 @@ void R_DrawParticleCallback(const void *calldata1, int calldata2)
 		varray_vertex[13] = org[1] + right[1] + up[1];
 		varray_vertex[14] = org[2] + right[2] + up[2];
 	}
-	else if (orientation == PARTICLE_ORIENTED_DOUBLESIDED)
+	else if (p->orientation == PARTICLE_SPARK)
+	{
+		VectorMA(p->org, -p->scaley, p->vel, v);
+		VectorMA(p->org, p->scaley, p->vel, up2);
+		R_CalcBeamVerts(varray_vertex, v, up2, p->scalex);
+	}
+	else if (p->orientation == PARTICLE_BEAM)
+		R_CalcBeamVerts(varray_vertex, p->org, p->vel2, p->scalex);
+	else if (p->orientation == PARTICLE_ORIENTED_DOUBLESIDED)
 	{
 		// double-sided
 		if (DotProduct(p->vel2, r_origin) > DotProduct(p->vel2, org))
@@ -1559,8 +1727,31 @@ void R_DrawParticleCallback(const void *calldata1, int calldata2)
 		varray_vertex[14] = org[2] + right[2] + up[2];
 	}
 	else
-		Host_Error("R_DrawParticles: unknown particle orientation %i\n", orientation);
+		Host_Error("R_DrawParticles: unknown particle orientation %i\n", p->orientation);
+
+	tex = &particletexture[p->texnum];
+	cr = p->color[0] * (1.0f / 255.0f);
+	cg = p->color[1] * (1.0f / 255.0f);
+	cb = p->color[2] * (1.0f / 255.0f);
+	ca = p->alpha * (1.0f / 255.0f);
+	if (p->blendmode == PBLEND_MOD)
+	{
+		cr *= ca;
+		cg *= ca;
+		cb *= ca;
+		cr = min(cr, 1);
+		cg = min(cg, 1);
+		cb = min(cb, 1);
+		ca = 1;
+	}
+
 #if WORKINGLQUAKE
+	if (p->blendmode == 0)
+		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	else if (p->blendmode == 1)
+		glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+	else
+		glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
 	glBegin(GL_QUADS);
 	glColor4f(cr, cg, cb, ca);
 	glTexCoord2f(tex->s2, tex->t1);glVertex3f(varray_vertex[ 0], varray_vertex[ 1], varray_vertex[ 2]);
@@ -1569,6 +1760,65 @@ void R_DrawParticleCallback(const void *calldata1, int calldata2)
 	glTexCoord2f(tex->s2, tex->t2);glVertex3f(varray_vertex[12], varray_vertex[13], varray_vertex[14]);
 	glEnd();
 #else
+	memset(&m, 0, sizeof(m));
+	if (p->blendmode == 0)
+	{
+		m.blendfunc1 = GL_SRC_ALPHA;
+		m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA;
+	}
+	else if (p->blendmode == 1)
+	{
+		m.blendfunc1 = GL_SRC_ALPHA;
+		m.blendfunc2 = GL_ONE;
+	}
+	else
+	{
+		m.blendfunc1 = GL_ZERO;
+		m.blendfunc2 = GL_ONE_MINUS_SRC_COLOR;
+	}
+	m.tex[0] = R_GetTexture(tex->texture);
+	R_Mesh_Matrix(&r_identitymatrix);
+	R_Mesh_State(&m);
+
+	if (fogenabled && p->blendmode != PBLEND_MOD)
+	{
+		VectorSubtract(org, r_origin, fogvec);
+		fog = exp(fogdensity/DotProduct(fogvec,fogvec));
+		ifog = 1 - fog;
+		cr = cr * ifog;
+		cg = cg * ifog;
+		cb = cb * ifog;
+		if (p->blendmode == 0)
+		{
+			cr += fogcolor[0] * fog;
+			cg += fogcolor[1] * fog;
+			cb += fogcolor[2] * fog;
+		}
+	}
+	cr *= r_colorscale;
+	cg *= r_colorscale;
+	cb *= r_colorscale;
+
+	if (p->orientation == PARTICLE_BEAM)
+	{
+		VectorSubtract(p->vel2, p->org, up);
+		VectorNormalizeFast(up);
+		v[0] = DotProduct(p->org, up) * (1.0f / 64.0f) - cl.time * 0.25;
+		v[1] = DotProduct(p->vel2, up) * (1.0f / 64.0f) - cl.time * 0.25;
+		varray_texcoord[0][0] = 1;varray_texcoord[0][1] = v[0];
+		varray_texcoord[0][4] = 0;varray_texcoord[0][5] = v[0];
+		varray_texcoord[0][8] = 0;varray_texcoord[0][9] = v[1];
+		varray_texcoord[0][12] = 1;varray_texcoord[0][13] = v[1];
+	}
+	else
+	{
+		varray_texcoord[0][0] = tex->s2;varray_texcoord[0][1] = tex->t1;
+		varray_texcoord[0][4] = tex->s1;varray_texcoord[0][5] = tex->t1;
+		varray_texcoord[0][8] = tex->s1;varray_texcoord[0][9] = tex->t2;
+		varray_texcoord[0][12] = tex->s2;varray_texcoord[0][13] = tex->t2;
+	}
+
+	GL_Color(cr, cg, cb, ca);
 	R_Mesh_Draw(4, 2, polygonelements);
 #endif
 }
@@ -1597,7 +1847,7 @@ void R_DrawParticles (void)
 	// LordHavoc: only render if not too close
 	for (i = 0, p = particles;i < cl_numparticles;i++, p++)
 		if (DotProduct(p->org, vpn) >= minparticledist)
-			R_DrawParticleCallback(p, 0);
+			R_DrawParticle(p);
 	glDepthMask(1);
 	glDisable(GL_BLEND);
 	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
@@ -1605,7 +1855,7 @@ void R_DrawParticles (void)
 	// LordHavoc: only render if not too close
 	c_particles += cl_numparticles;
 	for (i = 0, p = particles;i < cl_numparticles;i++, p++)
-		if (DotProduct(p->org, vpn) >= minparticledist)
+		if (DotProduct(p->org, vpn) >= minparticledist || p->orientation == PARTICLE_BEAM)
 			R_MeshQueue_AddTransparent(p->org, R_DrawParticleCallback, p, 0);
 #endif
 }