do not generate vertexposition/vertexmesh arrays in
[divverent/darkplaces.git] / cl_particles.c
index 74925fe..1557fc3 100644 (file)
@@ -24,24 +24,21 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include "image.h"
 #include "r_shadow.h"
 
-#define ABSOLUTE_MAX_PARTICLES 1<<24 // upper limit on cl.max_particles
-#define ABSOLUTE_MAX_DECALS 1<<24 // upper limit on cl.max_decals
-
 // must match ptype_t values
 particletype_t particletype[pt_total] =
 {
-       {0, 0, false}, // pt_dead
+       {PBLEND_INVALID, PARTICLE_INVALID, false}, //pt_dead (should never happen)
        {PBLEND_ALPHA, PARTICLE_BILLBOARD, false}, //pt_alphastatic
        {PBLEND_ADD, PARTICLE_BILLBOARD, false}, //pt_static
        {PBLEND_ADD, PARTICLE_SPARK, false}, //pt_spark
-       {PBLEND_ADD, PARTICLE_BEAM, false}, //pt_beam
+       {PBLEND_ADD, PARTICLE_HBEAM, false}, //pt_beam
        {PBLEND_ADD, PARTICLE_SPARK, false}, //pt_rain
        {PBLEND_ADD, PARTICLE_ORIENTED_DOUBLESIDED, false}, //pt_raindecal
        {PBLEND_ADD, PARTICLE_BILLBOARD, false}, //pt_snow
        {PBLEND_ADD, PARTICLE_BILLBOARD, false}, //pt_bubble
-       {PBLEND_MOD, PARTICLE_BILLBOARD, false}, //pt_blood
+       {PBLEND_INVMOD, PARTICLE_BILLBOARD, false}, //pt_blood
        {PBLEND_ADD, PARTICLE_BILLBOARD, false}, //pt_smoke
-       {PBLEND_MOD, PARTICLE_ORIENTED_DOUBLESIDED, false}, //pt_decal
+       {PBLEND_INVMOD, PARTICLE_ORIENTED_DOUBLESIDED, false}, //pt_decal
        {PBLEND_ALPHA, PARTICLE_BILLBOARD, false}, //pt_entityparticle
 };
 
@@ -69,6 +66,10 @@ typedef struct particleeffectinfo_s
        float trailspacing;
        // type of particle to spawn (defines some aspects of behavior)
        ptype_t particletype;
+       // blending mode used on this particle type
+       pblend_t blendmode;
+       // orientation of this particle type (BILLBOARD, SPARK, BEAM, etc)
+       porientation_t orientation;
        // range of colors to choose from in hex RRGGBB (like HTML color tags),
        // randomly interpolated at spawn
        unsigned int color[2];
@@ -97,6 +98,8 @@ typedef struct particleeffectinfo_s
        // these offsets are added to the values given to particleeffect(), and
        // then an ellipsoid-shaped jitter is added as defined by these
        // (they are the 3 radii)
+       float stretchfactor;
+       // stretch velocity factor (used for sparks)
        float originoffset[3];
        float velocityoffset[3];
        float originjitter[3];
@@ -109,18 +112,22 @@ typedef struct particleeffectinfo_s
        float lightcolor[3];
        qboolean lightshadow;
        int lightcubemapnum;
+       unsigned int staincolor[2]; // note: 0x808080 = neutral (particle's own color), these are modding factors for the particle's original color!
+       int staintex[2];
+       float stainalpha[2];
+       float stainsize[2];
+       // other parameters
+       float rotate[4]; // min/max base angle, min/max rotation over time
 }
 particleeffectinfo_t;
 
-#define MAX_PARTICLEEFFECTNAME 256
 char particleeffectname[MAX_PARTICLEEFFECTNAME][64];
 
-#define MAX_PARTICLEEFFECTINFO 4096
-
+int numparticleeffectinfo;
 particleeffectinfo_t particleeffectinfo[MAX_PARTICLEEFFECTINFO];
 
-static int particlepalette[256] =
-{
+static int particlepalette[256];
+/*
        0x000000,0x0f0f0f,0x1f1f1f,0x2f2f2f,0x3f3f3f,0x4b4b4b,0x5b5b5b,0x6b6b6b, // 0-7
        0x7b7b7b,0x8b8b8b,0x9b9b9b,0xababab,0xbbbbbb,0xcbcbcb,0xdbdbdb,0xebebeb, // 8-15
        0x0f0b07,0x170f0b,0x1f170b,0x271b0f,0x2f2313,0x372b17,0x3f2f17,0x4b371b, // 16-23
@@ -153,7 +160,7 @@ static int particlepalette[256] =
        0xb7330f,0xc34b1b,0xcf632b,0xdb7f3b,0xe3974f,0xe7ab5f,0xefbf77,0xf7d38b, // 232-239
        0xa77b3b,0xb79b37,0xc7c337,0xe7e357,0x7fbfff,0xabe7ff,0xd7ffff,0x670000, // 240-247
        0x8b0000,0xb30000,0xd70000,0xff0000,0xfff393,0xfff7c7,0xffffff,0x9f5b53  // 248-255
-};
+*/
 
 int            ramp1[8] = {0x6f, 0x6d, 0x6b, 0x69, 0x67, 0x65, 0x63, 0x61};
 int            ramp2[8] = {0x6f, 0x6e, 0x6d, 0x6c, 0x6b, 0x6a, 0x68, 0x66};
@@ -161,6 +168,19 @@ int                ramp3[8] = {0x6d, 0x6b, 6, 5, 4, 3};
 
 //static int explosparkramp[8] = {0x4b0700, 0x6f0f00, 0x931f07, 0xb7330f, 0xcf632b, 0xe3974f, 0xffe7b5, 0xffffff};
 
+// particletexture_t is a rectangle in the particlefonttexture
+typedef struct particletexture_s
+{
+       rtexture_t *texture;
+       float s1, t1, s2, t2;
+}
+particletexture_t;
+
+static rtexturepool_t *particletexturepool;
+static rtexture_t *particlefonttexture;
+static particletexture_t particletexture[MAX_PARTICLETEXTURES];
+skinframe_t *decalskinframe;
+
 // texture numbers in particle font
 static const int tex_smoke[8] = {0, 1, 2, 3, 4, 5, 6, 7};
 static const int tex_bulletdecal[8] = {8, 9, 10, 11, 12, 13, 14, 15};
@@ -178,7 +198,10 @@ cvar_t cl_particles_alpha = {CVAR_SAVE, "cl_particles_alpha", "1", "multiplies o
 cvar_t cl_particles_size = {CVAR_SAVE, "cl_particles_size", "1", "multiplies particle size"};
 cvar_t cl_particles_quake = {CVAR_SAVE, "cl_particles_quake", "0", "makes particle effects look mostly like the ones in Quake"};
 cvar_t cl_particles_blood = {CVAR_SAVE, "cl_particles_blood", "1", "enables blood effects"};
-cvar_t cl_particles_blood_alpha = {CVAR_SAVE, "cl_particles_blood_alpha", "1", "opacity of blood"};
+cvar_t cl_particles_blood_alpha = {CVAR_SAVE, "cl_particles_blood_alpha", "1", "opacity of blood, does not affect decals"};
+cvar_t cl_particles_blood_decal_alpha = {CVAR_SAVE, "cl_particles_blood_decal_alpha", "1", "opacity of blood decal"};
+cvar_t cl_particles_blood_decal_scalemin = {CVAR_SAVE, "cl_particles_blood_decal_scalemin", "1.5", "minimal random scale of decal"};
+cvar_t cl_particles_blood_decal_scalemax = {CVAR_SAVE, "cl_particles_blood_decal_scalemax", "2", "maximal random scale of decal"};
 cvar_t cl_particles_blood_bloodhack = {CVAR_SAVE, "cl_particles_blood_bloodhack", "1", "make certain quake particle() calls create blood effects instead"};
 cvar_t cl_particles_bulletimpacts = {CVAR_SAVE, "cl_particles_bulletimpacts", "1", "enables bulletimpact effects"};
 cvar_t cl_particles_explosions_sparks = {CVAR_SAVE, "cl_particles_explosions_sparks", "1", "enables sparks from explosions"};
@@ -190,21 +213,28 @@ 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", "brightness fade per second"};
 cvar_t cl_particles_sparks = {CVAR_SAVE, "cl_particles_sparks", "1", "enables sparks (used by multiple effects)"};
 cvar_t cl_particles_bubbles = {CVAR_SAVE, "cl_particles_bubbles", "1", "enables bubbles (used by multiple effects)"};
+cvar_t cl_particles_visculling = {CVAR_SAVE, "cl_particles_visculling", "0", "perform a costly check if each particle is visible before drawing"};
+cvar_t cl_particles_collisions = {CVAR_SAVE, "cl_particles_collisions", "1", "allow costly collision detection on particles (sparks that bounce, particles not going through walls, blood hitting surfaces, etc)"};
 cvar_t cl_decals = {CVAR_SAVE, "cl_decals", "1", "enables decals (bullet holes, blood, etc)"};
+cvar_t cl_decals_visculling = {CVAR_SAVE, "cl_decals_visculling", "1", "perform a very cheap check if each decal is visible before drawing"};
 cvar_t cl_decals_time = {CVAR_SAVE, "cl_decals_time", "20", "how long before decals start to fade away"};
 cvar_t cl_decals_fadetime = {CVAR_SAVE, "cl_decals_fadetime", "1", "how long decals take to fade away"};
+cvar_t cl_decals_newsystem = {CVAR_SAVE, "cl_decals_newsystem", "0", "enables new advanced decal system"};
+cvar_t cl_decals_newsystem_intensitymultiplier = {CVAR_SAVE, "cl_decals_newsystem_intensitymultiplier", "2", "boosts intensity of decals (because the distance fade can make them hard to see otherwise)"};
+cvar_t cl_decals_newsystem_immediatebloodstain = {CVAR_SAVE, "cl_decals_newsystem_immediatebloodstain", "2", "0: no on-spawn blood stains; 1: on-spawn blood stains for pt_blood; 2: always use on-spawn blood stains"};
+cvar_t cl_decals_models = {CVAR_SAVE, "cl_decals_models", "0", "enables decals on animated models (if newsystem is also 1)"};
+cvar_t cl_decals_bias = {CVAR_SAVE, "cl_decals_bias", "0.125", "distance to bias decals from surface to prevent depth fighting"};
+cvar_t cl_decals_max = {CVAR_SAVE, "cl_decals_max", "4096", "maximum number of decals allowed to exist in the world at once"};
 
 
-void CL_Particles_ParseEffectInfo(const char *textstart, const char *textend)
+void CL_Particles_ParseEffectInfo(const char *textstart, const char *textend, const char *filename)
 {
        int arrayindex;
        int argc;
-       int effectinfoindex;
        int linenumber;
        particleeffectinfo_t *info = NULL;
        const char *text = textstart;
        char argv[16][1024];
-       effectinfoindex = -1;
        for (linenumber = 1;;linenumber++)
        {
                argc = 0;
@@ -224,19 +254,19 @@ void CL_Particles_ParseEffectInfo(const char *textstart, const char *textend)
                }
                if (argc < 1)
                        continue;
-#define checkparms(n) if (argc != (n)) {Con_Printf("effectinfo.txt:%i: error while parsing: %s given %i parameters, should be %i parameters\n", linenumber, argv[0], argc, (n));break;}
+#define checkparms(n) if (argc != (n)) {Con_Printf("%s:%i: error while parsing: %s given %i parameters, should be %i parameters\n", filename, linenumber, argv[0], argc, (n));break;}
 #define readints(array, n) checkparms(n+1);for (arrayindex = 0;arrayindex < argc - 1;arrayindex++) array[arrayindex] = strtol(argv[1+arrayindex], NULL, 0)
 #define readfloats(array, n) checkparms(n+1);for (arrayindex = 0;arrayindex < argc - 1;arrayindex++) array[arrayindex] = atof(argv[1+arrayindex])
 #define readint(var) checkparms(2);var = strtol(argv[1], NULL, 0)
 #define readfloat(var) checkparms(2);var = atof(argv[1])
+#define readbool(var) checkparms(2);var = strtol(argv[1], NULL, 0) != 0
                if (!strcmp(argv[0], "effect"))
                {
                        int effectnameindex;
                        checkparms(2);
-                       effectinfoindex++;
-                       if (effectinfoindex >= MAX_PARTICLEEFFECTINFO)
+                       if (numparticleeffectinfo >= MAX_PARTICLEEFFECTINFO)
                        {
-                               Con_Printf("effectinfo.txt:%i: too many effects!\n", linenumber);
+                               Con_Printf("%s:%i: too many effects!\n", filename, linenumber);
                                break;
                        }
                        for (effectnameindex = 1;effectnameindex < MAX_PARTICLEEFFECTNAME;effectnameindex++)
@@ -255,12 +285,14 @@ void CL_Particles_ParseEffectInfo(const char *textstart, const char *textend)
                        // if we run out of names, abort
                        if (effectnameindex == MAX_PARTICLEEFFECTNAME)
                        {
-                               Con_Printf("effectinfo.txt:%i: too many effects!\n", linenumber);
+                               Con_Printf("%s:%i: too many effects!\n", filename, linenumber);
                                break;
                        }
-                       info = particleeffectinfo + effectinfoindex;
+                       info = particleeffectinfo + numparticleeffectinfo++;
                        info->effectnameindex = effectnameindex;
                        info->particletype = pt_alphastatic;
+                       info->blendmode = particletype[info->particletype].blendmode;
+                       info->orientation = particletype[info->particletype].orientation;
                        info->tex[0] = tex_particle;
                        info->tex[1] = tex_particle;
                        info->color[0] = 0xFFFFFF;
@@ -275,10 +307,23 @@ void CL_Particles_ParseEffectInfo(const char *textstart, const char *textend)
                        VectorSet(info->lightcolor, 1, 1, 1);
                        info->lightshadow = true;
                        info->lighttime = 9999;
+                       info->stretchfactor = 1;
+                       info->staincolor[0] = (unsigned int)-1;
+                       info->staincolor[1] = (unsigned int)-1;
+                       info->staintex[0] = -1;
+                       info->staintex[1] = -1;
+                       info->stainalpha[0] = 1;
+                       info->stainalpha[1] = 1;
+                       info->stainsize[0] = 2;
+                       info->stainsize[1] = 2;
+                       info->rotate[0] = 0;
+                       info->rotate[1] = 360;
+                       info->rotate[2] = 0;
+                       info->rotate[3] = 0;
                }
                else if (info == NULL)
                {
-                       Con_Printf("effectinfo.txt:%i: command %s encountered before effect\n", linenumber, argv[0]);
+                       Con_Printf("%s:%i: command %s encountered before effect\n", filename, linenumber, argv[0]);
                        break;
                }
                else if (!strcmp(argv[0], "countabsolute")) {readfloat(info->countabsolute);}
@@ -294,18 +339,37 @@ void CL_Particles_ParseEffectInfo(const char *textstart, const char *textend)
                        else if (!strcmp(argv[1], "raindecal")) info->particletype = pt_raindecal;
                        else if (!strcmp(argv[1], "snow")) info->particletype = pt_snow;
                        else if (!strcmp(argv[1], "bubble")) info->particletype = pt_bubble;
-                       else if (!strcmp(argv[1], "blood")) info->particletype = pt_blood;
+                       else if (!strcmp(argv[1], "blood")) {info->particletype = pt_blood;info->gravity = 1;}
                        else if (!strcmp(argv[1], "smoke")) info->particletype = pt_smoke;
                        else if (!strcmp(argv[1], "decal")) info->particletype = pt_decal;
                        else if (!strcmp(argv[1], "entityparticle")) info->particletype = pt_entityparticle;
-                       else Con_Printf("effectinfo.txt:%i: unrecognized particle type %s\n", linenumber, argv[1]);
+                       else Con_Printf("%s:%i: unrecognized particle type %s\n", filename, linenumber, argv[1]);
+                       info->blendmode = particletype[info->particletype].blendmode;
+                       info->orientation = particletype[info->particletype].orientation;
+               }
+               else if (!strcmp(argv[0], "blend"))
+               {
+                       checkparms(2);
+                       if (!strcmp(argv[1], "alpha")) info->blendmode = PBLEND_ALPHA;
+                       else if (!strcmp(argv[1], "add")) info->blendmode = PBLEND_ADD;
+                       else if (!strcmp(argv[1], "invmod")) info->blendmode = PBLEND_INVMOD;
+                       else Con_Printf("%s:%i: unrecognized blendmode %s\n", filename, linenumber, argv[1]);
+               }
+               else if (!strcmp(argv[0], "orientation"))
+               {
+                       checkparms(2);
+                       if (!strcmp(argv[1], "billboard")) info->orientation = PARTICLE_BILLBOARD;
+                       else if (!strcmp(argv[1], "spark")) info->orientation = PARTICLE_SPARK;
+                       else if (!strcmp(argv[1], "oriented")) info->orientation = PARTICLE_ORIENTED_DOUBLESIDED;
+                       else if (!strcmp(argv[1], "beam")) info->orientation = PARTICLE_HBEAM;
+                       else Con_Printf("%s:%i: unrecognized orientation %s\n", filename, linenumber, argv[1]);
                }
                else if (!strcmp(argv[0], "color")) {readints(info->color, 2);}
                else if (!strcmp(argv[0], "tex")) {readints(info->tex, 2);}
                else if (!strcmp(argv[0], "size")) {readfloats(info->size, 2);}
                else if (!strcmp(argv[0], "sizeincrease")) {readfloat(info->size[2]);}
                else if (!strcmp(argv[0], "alpha")) {readfloats(info->alpha, 3);}
-               else if (!strcmp(argv[0], "time")) {readints(info->time, 2);}
+               else if (!strcmp(argv[0], "time")) {readfloats(info->time, 2);}
                else if (!strcmp(argv[0], "gravity")) {readfloat(info->gravity);}
                else if (!strcmp(argv[0], "bounce")) {readfloat(info->bounce);}
                else if (!strcmp(argv[0], "airfriction")) {readfloat(info->airfriction);}
@@ -319,13 +383,20 @@ void CL_Particles_ParseEffectInfo(const char *textstart, const char *textend)
                else if (!strcmp(argv[0], "lightradiusfade")) {readfloat(info->lightradiusfade);}
                else if (!strcmp(argv[0], "lighttime")) {readfloat(info->lighttime);}
                else if (!strcmp(argv[0], "lightcolor")) {readfloats(info->lightcolor, 3);}
-               else if (!strcmp(argv[0], "lightshadow")) {readint(info->lightshadow);}
+               else if (!strcmp(argv[0], "lightshadow")) {readbool(info->lightshadow);}
                else if (!strcmp(argv[0], "lightcubemapnum")) {readint(info->lightcubemapnum);}
                else if (!strcmp(argv[0], "underwater")) {checkparms(1);info->flags |= PARTICLEEFFECT_UNDERWATER;}
                else if (!strcmp(argv[0], "notunderwater")) {checkparms(1);info->flags |= PARTICLEEFFECT_NOTUNDERWATER;}
                else if (!strcmp(argv[0], "trailspacing")) {readfloat(info->trailspacing);if (info->trailspacing > 0) info->countmultiplier = 1.0f / info->trailspacing;}
+               else if (!strcmp(argv[0], "stretchfactor")) {readfloat(info->stretchfactor);}
+               else if (!strcmp(argv[0], "staincolor")) {readints(info->staincolor, 2);}
+               else if (!strcmp(argv[0], "stainalpha")) {readfloats(info->stainalpha, 2);}
+               else if (!strcmp(argv[0], "stainsize")) {readfloats(info->stainsize, 2);}
+               else if (!strcmp(argv[0], "staintex")) {readints(info->staintex, 2);}
+               else if (!strcmp(argv[0], "stainless")) {info->staintex[0] = -2; info->staincolor[0] = (unsigned int)-1; info->staincolor[1] = (unsigned int)-1; info->stainalpha[0] = 1; info->stainalpha[1] = 1; info->stainsize[0] = 2; info->stainsize[1] = 2; }
+               else if (!strcmp(argv[0], "rotate")) {readfloats(info->rotate, 4);}
                else
-                       Con_Printf("effectinfo.txt:%i: skipping unknown command %s\n", linenumber, argv[0]);
+                       Con_Printf("%s:%i: skipping unknown command %s\n", filename, linenumber, argv[0]);
 #undef checkparms
 #undef readints
 #undef readfloats
@@ -394,19 +465,34 @@ static const char *standardeffectnames[EFFECT_TOTAL] =
 void CL_Particles_LoadEffectInfo(void)
 {
        int i;
+       int filepass;
        unsigned char *filedata;
        fs_offset_t filesize;
+       char filename[MAX_QPATH];
+       numparticleeffectinfo = 0;
        memset(particleeffectinfo, 0, sizeof(particleeffectinfo));
        memset(particleeffectname, 0, sizeof(particleeffectname));
        for (i = 0;i < EFFECT_TOTAL;i++)
                strlcpy(particleeffectname[i], standardeffectnames[i], sizeof(particleeffectname[i]));
-       filedata = FS_LoadFile("effectinfo.txt", tempmempool, true, &filesize);
-       if (filedata)
+       for (filepass = 0;;filepass++)
        {
-               CL_Particles_ParseEffectInfo((const char *)filedata, (const char *)filedata + filesize);
+               if (filepass == 0)
+                       dpsnprintf(filename, sizeof(filename), "effectinfo.txt");
+               else if (filepass == 1)
+               {
+                       if (!cl.worldbasename[0])
+                               continue;
+                       dpsnprintf(filename, sizeof(filename), "%s_effectinfo.txt", cl.worldnamenoextension);
+               }
+               else
+                       break;
+               filedata = FS_LoadFile(filename, tempmempool, true, &filesize);
+               if (!filedata)
+                       continue;
+               CL_Particles_ParseEffectInfo((const char *)filedata, (const char *)filedata + filesize, filename);
                Mem_Free(filedata);
        }
-};
+}
 
 /*
 ===============
@@ -417,7 +503,7 @@ void CL_ReadPointFile_f (void);
 void CL_Particles_Init (void)
 {
        Cmd_AddCommand ("pointfile", CL_ReadPointFile_f, "display point file produced by qbsp when a leak was detected in the map (a line leading through the leak hole, to an entity inside the level)");
-       Cmd_AddCommand ("cl_particles_reloadeffects", CL_Particles_LoadEffectInfo, "reloads effectinfo.txt");
+       Cmd_AddCommand ("cl_particles_reloadeffects", CL_Particles_LoadEffectInfo, "reloads effectinfo.txt and maps/levelname_effectinfo.txt (where levelname is the current map)");
 
        Cvar_RegisterVariable (&cl_particles);
        Cvar_RegisterVariable (&cl_particles_quality);
@@ -426,6 +512,9 @@ void CL_Particles_Init (void)
        Cvar_RegisterVariable (&cl_particles_quake);
        Cvar_RegisterVariable (&cl_particles_blood);
        Cvar_RegisterVariable (&cl_particles_blood_alpha);
+       Cvar_RegisterVariable (&cl_particles_blood_decal_alpha);
+       Cvar_RegisterVariable (&cl_particles_blood_decal_scalemin);
+       Cvar_RegisterVariable (&cl_particles_blood_decal_scalemax);
        Cvar_RegisterVariable (&cl_particles_blood_bloodhack);
        Cvar_RegisterVariable (&cl_particles_explosions_sparks);
        Cvar_RegisterVariable (&cl_particles_explosions_shell);
@@ -437,20 +526,32 @@ void CL_Particles_Init (void)
        Cvar_RegisterVariable (&cl_particles_smoke_alphafade);
        Cvar_RegisterVariable (&cl_particles_sparks);
        Cvar_RegisterVariable (&cl_particles_bubbles);
+       Cvar_RegisterVariable (&cl_particles_visculling);
+       Cvar_RegisterVariable (&cl_particles_collisions);
        Cvar_RegisterVariable (&cl_decals);
+       Cvar_RegisterVariable (&cl_decals_visculling);
        Cvar_RegisterVariable (&cl_decals_time);
        Cvar_RegisterVariable (&cl_decals_fadetime);
+       Cvar_RegisterVariable (&cl_decals_newsystem);
+       Cvar_RegisterVariable (&cl_decals_newsystem_intensitymultiplier);
+       Cvar_RegisterVariable (&cl_decals_newsystem_immediatebloodstain);
+       Cvar_RegisterVariable (&cl_decals_models);
+       Cvar_RegisterVariable (&cl_decals_bias);
+       Cvar_RegisterVariable (&cl_decals_max);
 }
 
 void CL_Particles_Shutdown (void)
 {
 }
 
+void CL_SpawnDecalParticleForSurface(int hitent, const vec3_t org, const vec3_t normal, int color1, int color2, int texnum, float size, float alpha);
+void CL_SpawnDecalParticleForPoint(const vec3_t org, float maxdist, float size, float alpha, int texnum, int color1, int color2);
+
 // list of all 26 parameters:
 // ptype - any of the pt_ enum values (pt_static, pt_blood, etc), see ptype_t near the top of this file
 // pcolor1,pcolor2 - minimum and maximum ranges of color, randomly interpolated to decide particle color
 // ptex - any of the tex_ values such as tex_smoke[rand()&7] or tex_particle
-// psize - size of particle (or thickness for PARTICLE_SPARK and PARTICLE_BEAM)
+// psize - size of particle (or thickness for PARTICLE_SPARK and PARTICLE_*BEAM)
 // palpha - opacity of particle as 0-255 (can be more than 255)
 // palphafade - rate of fade per second (so 256 would mean a 256 alpha particle would fade to nothing in 1 second)
 // ptime - how long the particle can live (note it is also removed if alpha drops to nothing)
@@ -459,9 +560,17 @@ void CL_Particles_Shutdown (void)
 // px,py,pz - starting origin of particle
 // pvx,pvy,pvz - starting velocity of particle
 // pfriction - how much the particle slows down per second (0-1 typically, can slowdown faster than 1)
-static particle_t *CL_NewParticle(unsigned short ptypeindex, int pcolor1, int pcolor2, int ptex, float psize, float psizeincrease, float palpha, float palphafade, float pgravity, float pbounce, float px, float py, float pz, float pvx, float pvy, float pvz, float pairfriction, float pliquidfriction, float originjitter, float velocityjitter, qboolean pqualityreduction, float lifetime)
+// blendmode - one of the PBLEND_ values
+// orientation - one of the PARTICLE_ values
+// staincolor1, staincolor2: minimum and maximum ranges of stain color, randomly interpolated to decide stain color (-1 to use none)
+// staintex: any of the tex_ values such as tex_smoke[rand()&7] or tex_particle (-1 to use none)
+// stainalpha: opacity of the stain as factor for alpha
+// stainsize: size of the stain as factor for palpha
+// angle: base rotation of the particle geometry around its center normal
+// spin: rotation speed of the particle geometry around its center normal
+particle_t *CL_NewParticle(const vec3_t sortorigin, unsigned short ptypeindex, int pcolor1, int pcolor2, int ptex, float psize, float psizeincrease, float palpha, float palphafade, float pgravity, float pbounce, float px, float py, float pz, float pvx, float pvy, float pvz, float pairfriction, float pliquidfriction, float originjitter, float velocityjitter, qboolean pqualityreduction, float lifetime, float stretch, pblend_t blendmode, porientation_t orientation, int staincolor1, int staincolor2, int staintex, float stainalpha, float stainsize, float angle, float spin, float tint[4])
 {
-       int l1, l2;
+       int l1, l2, r, g, b;
        particle_t *part;
        vec3_t v;
        if (!cl_particles.integer)
@@ -475,19 +584,76 @@ static particle_t *CL_NewParticle(unsigned short ptypeindex, int pcolor1, int pc
        if (cl.num_particles < cl.free_particle)
                cl.num_particles = cl.free_particle;
        memset(part, 0, sizeof(*part));
+       VectorCopy(sortorigin, part->sortorigin);
        part->typeindex = ptypeindex;
+       part->blendmode = blendmode;
+       if(orientation == PARTICLE_HBEAM || orientation == PARTICLE_VBEAM)
+       {
+               particletexture_t *tex = &particletexture[ptex];
+               if(tex->t1 == 0 && tex->t2 == 1) // full height of texture?
+                       part->orientation = PARTICLE_VBEAM;
+               else
+                       part->orientation = PARTICLE_HBEAM;
+       }
+       else
+               part->orientation = orientation;
        l2 = (int)lhrandom(0.5, 256.5);
        l1 = 256 - l2;
        part->color[0] = ((((pcolor1 >> 16) & 0xFF) * l1 + ((pcolor2 >> 16) & 0xFF) * l2) >> 8) & 0xFF;
        part->color[1] = ((((pcolor1 >>  8) & 0xFF) * l1 + ((pcolor2 >>  8) & 0xFF) * l2) >> 8) & 0xFF;
        part->color[2] = ((((pcolor1 >>  0) & 0xFF) * l1 + ((pcolor2 >>  0) & 0xFF) * l2) >> 8) & 0xFF;
+       part->alpha = palpha;
+       part->alphafade = palphafade;
+       part->staintexnum = staintex;
+       if(staincolor1 >= 0 && staincolor2 >= 0)
+       {
+               l2 = (int)lhrandom(0.5, 256.5);
+               l1 = 256 - l2;
+               if(blendmode == PBLEND_INVMOD)
+               {
+                       r = ((((staincolor1 >> 16) & 0xFF) * l1 + ((staincolor2 >> 16) & 0xFF) * l2) * (255 - part->color[0])) / 0x8000; // staincolor 0x808080 keeps color invariant
+                       g = ((((staincolor1 >>  8) & 0xFF) * l1 + ((staincolor2 >>  8) & 0xFF) * l2) * (255 - part->color[1])) / 0x8000;
+                       b = ((((staincolor1 >>  0) & 0xFF) * l1 + ((staincolor2 >>  0) & 0xFF) * l2) * (255 - part->color[2])) / 0x8000;
+               }
+               else
+               {
+                       r = ((((staincolor1 >> 16) & 0xFF) * l1 + ((staincolor2 >> 16) & 0xFF) * l2) * part->color[0]) / 0x8000; // staincolor 0x808080 keeps color invariant
+                       g = ((((staincolor1 >>  8) & 0xFF) * l1 + ((staincolor2 >>  8) & 0xFF) * l2) * part->color[1]) / 0x8000;
+                       b = ((((staincolor1 >>  0) & 0xFF) * l1 + ((staincolor2 >>  0) & 0xFF) * l2) * part->color[2]) / 0x8000;
+               }
+               if(r > 0xFF) r = 0xFF;
+               if(g > 0xFF) g = 0xFF;
+               if(b > 0xFF) b = 0xFF;
+       }
+       else
+       {
+               r = part->color[0]; // -1 is shorthand for stain = particle color
+               g = part->color[1];
+               b = part->color[2];
+       }
+       part->staincolor[0] = r;
+       part->staincolor[1] = g;
+       part->staincolor[2] = b;
+       part->stainalpha = palpha * stainalpha;
+       part->stainsize = psize * stainsize;
+       if(tint)
+       {
+               if(blendmode != PBLEND_INVMOD) // invmod is immune to tinting
+               {
+                       part->color[0] *= tint[0];
+                       part->color[1] *= tint[1];
+                       part->color[2] *= tint[2];
+               }
+               part->alpha *= tint[3];
+               part->alphafade *= tint[3];
+               part->stainalpha *= tint[3];
+       }
        part->texnum = ptex;
        part->size = psize;
        part->sizeincrease = psizeincrease;
-       part->alpha = palpha;
-       part->alphafade = palphafade;
        part->gravity = pgravity;
        part->bounce = pbounce;
+       part->stretch = stretch;
        VectorRandom(v);
        part->org[0] = px + originjitter * v[0];
        part->org[1] = py + originjitter * v[1];
@@ -499,10 +665,11 @@ static particle_t *CL_NewParticle(unsigned short ptypeindex, int pcolor1, int pc
        part->airfriction = pairfriction;
        part->liquidfriction = pliquidfriction;
        part->die = cl.time + lifetime;
-       part->delayedcollisions = 0;
+       part->delayedspawn = cl.time;
+//     part->delayedcollisions = 0;
        part->qualityreduction = pqualityreduction;
-       if (part->typeindex == pt_blood)
-               part->gravity += 1; // FIXME: this is a legacy hack, effectinfo.txt doesn't have gravity on blood (nor do the particle calls in the engine)
+       part->angle = angle;
+       part->spin = spin;
        // if it is rain or snow, trace ahead and shut off collisions until an actual collision event needs to occur to improve performance
        if (part->typeindex == pt_rain)
        {
@@ -515,16 +682,16 @@ static particle_t *CL_NewParticle(unsigned short ptypeindex, int pcolor1, int pc
                part->typeindex = pt_spark;
                part->bounce = 0;
                VectorMA(part->org, lifetime, part->vel, endvec);
-               trace = CL_Move(part->org, vec3_origin, vec3_origin, endvec, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_LIQUIDSMASK, true, false, NULL, false);
+               trace = CL_TraceLine(part->org, endvec, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_LIQUIDSMASK, true, false, NULL, false);
                part->die = cl.time + lifetime * trace.fraction;
-               part2 = CL_NewParticle(pt_raindecal, pcolor1, pcolor2, tex_rainsplash, part->size, part->size * 20, part->alpha, part->alpha / 0.4, 0, 0, trace.endpos[0] + trace.plane.normal[0], trace.endpos[1] + trace.plane.normal[1], trace.endpos[2] + trace.plane.normal[2], trace.plane.normal[0], trace.plane.normal[1], trace.plane.normal[2], 0, 0, 0, 0, pqualityreduction, 0);
+               part2 = CL_NewParticle(endvec, pt_raindecal, pcolor1, pcolor2, tex_rainsplash, part->size, part->size * 20, part->alpha, part->alpha / 0.4, 0, 0, trace.endpos[0] + trace.plane.normal[0], trace.endpos[1] + trace.plane.normal[1], trace.endpos[2] + trace.plane.normal[2], trace.plane.normal[0], trace.plane.normal[1], trace.plane.normal[2], 0, 0, 0, 0, pqualityreduction, 0, 1, PBLEND_ADD, PARTICLE_ORIENTED_DOUBLESIDED, -1, -1, -1, 1, 1, 0, 0, NULL);
                if (part2)
                {
                        part2->delayedspawn = part->die;
                        part2->die += part->die - cl.time;
                        for (i = rand() & 7;i < 10;i++)
                        {
-                               part2 = CL_NewParticle(pt_spark, pcolor1, pcolor2, tex_particle, 0.25f, 0, part->alpha * 2, part->alpha * 4, 1, 0, trace.endpos[0] + trace.plane.normal[0], trace.endpos[1] + trace.plane.normal[1], trace.endpos[2] + trace.plane.normal[2], trace.plane.normal[0] * 16, trace.plane.normal[1] * 16, trace.plane.normal[2] * 16 + cl.movevars_gravity * 0.04, 0, 0, 0, 32, pqualityreduction, 0);
+                               part2 = CL_NewParticle(endvec, pt_spark, pcolor1, pcolor2, tex_particle, 0.25f, 0, part->alpha * 2, part->alpha * 4, 1, 0, trace.endpos[0] + trace.plane.normal[0], trace.endpos[1] + trace.plane.normal[1], trace.endpos[2] + trace.plane.normal[2], trace.plane.normal[0] * 16, trace.plane.normal[1] * 16, trace.plane.normal[2] * 16 + cl.movevars_gravity * 0.04, 0, 0, 0, 32, pqualityreduction, 0, 1, PBLEND_ADD, PARTICLE_SPARK, -1, -1, -1, 1, 1, 0, 0, NULL);
                                if (part2)
                                {
                                        part2->delayedspawn = part->die;
@@ -533,24 +700,68 @@ static particle_t *CL_NewParticle(unsigned short ptypeindex, int pcolor1, int pc
                        }
                }
        }
+#if 0
        else if (part->bounce != 0 && part->gravity == 0 && part->typeindex != pt_snow)
        {
                float lifetime = part->alpha / (part->alphafade ? part->alphafade : 1);
                vec3_t endvec;
                trace_t trace;
                VectorMA(part->org, lifetime, part->vel, endvec);
-               trace = CL_Move(part->org, vec3_origin, vec3_origin, endvec, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY, true, false, NULL, false);
+               trace = CL_TraceLine(part->org, endvec, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY, true, false, NULL, false);
                part->delayedcollisions = cl.time + lifetime * trace.fraction - 0.1;
        }
+#endif
+
        return part;
 }
 
+static void CL_ImmediateBloodStain(particle_t *part)
+{
+       vec3_t v;
+       int staintex;
+
+       // blood creates a splash at spawn, not just at impact, this makes monsters bloody where they are shot
+       if (part->staintexnum >= 0 && cl_decals_newsystem.integer && cl_decals.integer)
+       {
+               VectorCopy(part->vel, v);
+               VectorNormalize(v);
+               staintex = part->staintexnum;
+               R_DecalSystem_SplatEntities(part->org, v, 1-part->staincolor[0]*(1.0f/255.0f), 1-part->staincolor[1]*(1.0f/255.0f), 1-part->staincolor[2]*(1.0f/255.0f), part->stainalpha*(1.0f/255.0f), particletexture[staintex].s1, particletexture[staintex].t1, particletexture[staintex].s2, particletexture[staintex].t2, part->stainsize);
+       }
+
+       // blood creates a splash at spawn, not just at impact, this makes monsters bloody where they are shot
+       if (part->typeindex == pt_blood && cl_decals_newsystem.integer && cl_decals.integer)
+       {
+               VectorCopy(part->vel, v);
+               VectorNormalize(v);
+               staintex = tex_blooddecal[rand()&7];
+               R_DecalSystem_SplatEntities(part->org, v, part->color[0]*(1.0f/255.0f), part->color[1]*(1.0f/255.0f), part->color[2]*(1.0f/255.0f), part->alpha*(1.0f/255.0f), particletexture[staintex].s1, particletexture[staintex].t1, particletexture[staintex].s2, particletexture[staintex].t2, part->size * 2);
+       }
+}
+
 void CL_SpawnDecalParticleForSurface(int hitent, const vec3_t org, const vec3_t normal, int color1, int color2, int texnum, float size, float alpha)
 {
        int l1, l2;
        decal_t *decal;
+       entity_render_t *ent = &cl.entities[hitent].render;
+       unsigned char color[3];
        if (!cl_decals.integer)
                return;
+       if (!ent->allowdecals)
+               return;
+
+       l2 = (int)lhrandom(0.5, 256.5);
+       l1 = 256 - l2;
+       color[0] = ((((color1 >> 16) & 0xFF) * l1 + ((color2 >> 16) & 0xFF) * l2) >> 8) & 0xFF;
+       color[1] = ((((color1 >>  8) & 0xFF) * l1 + ((color2 >>  8) & 0xFF) * l2) >> 8) & 0xFF;
+       color[2] = ((((color1 >>  0) & 0xFF) * l1 + ((color2 >>  0) & 0xFF) * l2) >> 8) & 0xFF;
+
+       if (cl_decals_newsystem.integer)
+       {
+               R_DecalSystem_SplatEntities(org, normal, color[0]*(1.0f/255.0f), color[1]*(1.0f/255.0f), color[2]*(1.0f/255.0f), alpha*(1.0f/255.0f), particletexture[texnum].s1, particletexture[texnum].t1, particletexture[texnum].s2, particletexture[texnum].t2, size);
+               return;
+       }
+
        for (;cl.free_decal < cl.max_decals && cl.decals[cl.free_decal].typeindex;cl.free_decal++);
        if (cl.free_decal >= cl.max_decals)
                return;
@@ -558,19 +769,19 @@ void CL_SpawnDecalParticleForSurface(int hitent, const vec3_t org, const vec3_t
        if (cl.num_decals < cl.free_decal)
                cl.num_decals = cl.free_decal;
        memset(decal, 0, sizeof(*decal));
+       decal->decalsequence = cl.decalsequence++;
        decal->typeindex = pt_decal;
        decal->texnum = texnum;
-       VectorAdd(org, normal, decal->org);
+       VectorMA(org, cl_decals_bias.value, normal, decal->org);
        VectorCopy(normal, decal->normal);
        decal->size = size;
        decal->alpha = alpha;
        decal->time2 = cl.time;
-       l2 = (int)lhrandom(0.5, 256.5);
-       l1 = 256 - l2;
-       decal->color[0] = ((((color1 >> 16) & 0xFF) * l1 + ((color2 >> 16) & 0xFF) * l2) >> 8) & 0xFF;
-       decal->color[1] = ((((color1 >>  8) & 0xFF) * l1 + ((color2 >>  8) & 0xFF) * l2) >> 8) & 0xFF;
-       decal->color[2] = ((((color1 >>  0) & 0xFF) * l1 + ((color2 >>  0) & 0xFF) * l2) >> 8) & 0xFF;
+       decal->color[0] = color[0];
+       decal->color[1] = color[1];
+       decal->color[2] = color[2];
        decal->owner = hitent;
+       decal->clusterindex = -1000; // no vis culling unless we're sure
        if (hitent)
        {
                // these relative things are only used to regenerate p->org and p->vel if decal->owner is not world (0)
@@ -578,6 +789,15 @@ void CL_SpawnDecalParticleForSurface(int hitent, const vec3_t org, const vec3_t
                Matrix4x4_Transform(&cl.entities[decal->owner].render.inversematrix, org, decal->relativeorigin);
                Matrix4x4_Transform3x3(&cl.entities[decal->owner].render.inversematrix, normal, decal->relativenormal);
        }
+       else
+       {
+               if(r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.PointInLeaf)
+               {
+                       mleaf_t *leaf = r_refdef.scene.worldmodel->brush.PointInLeaf(r_refdef.scene.worldmodel, decal->org);
+                       if(leaf)
+                               decal->clusterindex = leaf->clusterindex;
+               }
+       }
 }
 
 void CL_SpawnDecalParticleForPoint(const vec3_t org, float maxdist, float size, float alpha, int texnum, int color1, int color2)
@@ -592,7 +812,7 @@ void CL_SpawnDecalParticleForPoint(const vec3_t org, float maxdist, float size,
        {
                VectorRandom(org2);
                VectorMA(org, maxdist, org2, org2);
-               trace = CL_Move(org, vec3_origin, vec3_origin, org2, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY, true, false, &hitent, false);
+               trace = CL_TraceLine(org, org2, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY, true, false, &hitent, false);
                // take the closest trace result that doesn't end up hitting a NOMARKS
                // surface (sky for example)
                if (bestfrac > trace.fraction && !(trace.hitq3surfaceflags & Q3SURFACEFLAG_NOMARKS))
@@ -613,6 +833,7 @@ void CL_ParticleEffect_Fallback(int effectnameindex, float count, const vec3_t o
 {
        vec3_t center;
        matrix4x4_t tempmatrix;
+       particle_t *part;
        VectorLerp(originmins, 0.5, originmaxs, center);
        Matrix4x4_CreateTranslate(&tempmatrix, center[0], center[1], center[2]);
        if (effectnameindex == EFFECT_SVC_PARTICLE)
@@ -621,21 +842,16 @@ void CL_ParticleEffect_Fallback(int effectnameindex, float count, const vec3_t o
                {
                        // bloodhack checks if this effect's color matches regular or lightning blood and if so spawns a blood effect instead
                        if (count == 1024)
-                               CL_ParticleExplosion(center);
+                               CL_ParticleEffect(EFFECT_TE_EXPLOSION, 1, originmins, originmaxs, velocitymins, velocitymaxs, NULL, 0);
                        else if (cl_particles_blood_bloodhack.integer && !cl_particles_quake.integer && (palettecolor == 73 || palettecolor == 225))
-                               CL_ParticleEffect(EFFECT_TE_BLOOD, count / 6.0f, originmins, originmaxs, velocitymins, velocitymaxs, NULL, 0);
+                               CL_ParticleEffect(EFFECT_TE_BLOOD, count / 2.0f, originmins, originmaxs, velocitymins, velocitymaxs, NULL, 0);
                        else
                        {
                                count *= cl_particles_quality.value;
                                for (;count > 0;count--)
                                {
-                                       int k = particlepalette[palettecolor + (rand()&7)];
-                                       if (cl_particles_quake.integer)
-                                               CL_NewParticle(pt_alphastatic, k, k, tex_particle, 1.5, 0, lhrandom(51, 255), 512, 0.05, 0, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), lhrandom(velocitymins[0], velocitymaxs[0]), lhrandom(velocitymins[1], velocitymaxs[1]), lhrandom(velocitymins[2], velocitymaxs[2]), 0, 0, 8, 0, true, 0);
-                                       else if (gamemode == GAME_GOODVSBAD2)
-                                               CL_NewParticle(pt_alphastatic, k, k, tex_particle, 5, 0, 255, 300, 0, 0, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), lhrandom(velocitymins[0], velocitymaxs[0]), lhrandom(velocitymins[1], velocitymaxs[1]), lhrandom(velocitymins[2], velocitymaxs[2]), 0, 0, 8, 10, true, 0);
-                                       else
-                                               CL_NewParticle(pt_alphastatic, k, k, tex_particle, 1.5, 0, 255, 512, 0, 0, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), lhrandom(velocitymins[0], velocitymaxs[0]), lhrandom(velocitymins[1], velocitymaxs[1]), lhrandom(velocitymins[2], velocitymaxs[2]), 0, 0, 8, 15, true, 0);
+                                       int k = particlepalette[(palettecolor & ~7) + (rand()&7)];
+                                       CL_NewParticle(center, pt_alphastatic, k, k, tex_particle, 1.5, 0, 255, 0, 0.05, 0, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), lhrandom(velocitymins[0], velocitymaxs[0]), lhrandom(velocitymins[1], velocitymaxs[1]), lhrandom(velocitymins[2], velocitymaxs[2]), 0, 0, 8, 0, true, lhrandom(0.1, 0.5), 1, PBLEND_ALPHA, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                                }
                        }
                }
@@ -657,10 +873,11 @@ void CL_ParticleEffect_Fallback(int effectnameindex, float count, const vec3_t o
                        {
                                CL_Smoke(originmins, originmaxs, velocitymins, velocitymaxs, 4*count);
                                CL_Sparks(originmins, originmaxs, velocitymins, velocitymaxs, 15*count);
+                               CL_NewParticle(center, pt_static, 0x808080,0x808080, tex_particle, 3, 0, 256, 512, 0, 0, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), 0, 0, 0, 0, 0, 0, 0, true, 0, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                        }
                }
                // bullet hole
-               if (cl_stainmaps.integer) R_Stain(center, 32, 96, 96, 96, 24, 128, 128, 128, 24);
+               R_Stain(center, 16, 40, 40, 40, 64, 88, 88, 88, 64);
                CL_SpawnDecalParticleForPoint(center, 6, 3, 255, tex_bulletdecal[rand()&7], 0xFFFFFF, 0xFFFFFF);
        }
        else if (effectnameindex == EFFECT_TE_SPIKEQUAD)
@@ -676,10 +893,11 @@ void CL_ParticleEffect_Fallback(int effectnameindex, float count, const vec3_t o
                        {
                                CL_Smoke(originmins, originmaxs, velocitymins, velocitymaxs, 4*count);
                                CL_Sparks(originmins, originmaxs, velocitymins, velocitymaxs, 15*count);
+                               CL_NewParticle(center, pt_static, 0x808080,0x808080, tex_particle, 3, 0, 256, 512, 0, 0, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), 0, 0, 0, 0, 0, 0, 0, true, 0, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                        }
                }
                // bullet hole
-               if (cl_stainmaps.integer) R_Stain(center, 32, 96, 96, 96, 24, 128, 128, 128, 24);
+               R_Stain(center, 16, 40, 40, 40, 64, 88, 88, 88, 64);
                CL_SpawnDecalParticleForPoint(center, 6, 3, 255, tex_bulletdecal[rand()&7], 0xFFFFFF, 0xFFFFFF);
                CL_AllocLightFlash(NULL, &tempmatrix, 100, 0.15f, 0.15f, 1.5f, 500, 0.2, 0, -1, true, 1, 0.25, 1, 0, 0, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
        }
@@ -696,10 +914,11 @@ void CL_ParticleEffect_Fallback(int effectnameindex, float count, const vec3_t o
                        {
                                CL_Smoke(originmins, originmaxs, velocitymins, velocitymaxs, 8*count);
                                CL_Sparks(originmins, originmaxs, velocitymins, velocitymaxs, 30*count);
+                               CL_NewParticle(center, pt_static, 0x808080,0x808080, tex_particle, 3, 0, 256, 512, 0, 0, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), 0, 0, 0, 0, 0, 0, 0, true, 0, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                        }
                }
                // bullet hole
-               if (cl_stainmaps.integer) R_Stain(center, 32, 96, 96, 96, 24, 128, 128, 128, 24);
+               R_Stain(center, 16, 40, 40, 40, 64, 88, 88, 88, 64);
                CL_SpawnDecalParticleForPoint(center, 6, 3, 255, tex_bulletdecal[rand()&7], 0xFFFFFF, 0xFFFFFF);
        }
        else if (effectnameindex == EFFECT_TE_SUPERSPIKEQUAD)
@@ -715,10 +934,11 @@ void CL_ParticleEffect_Fallback(int effectnameindex, float count, const vec3_t o
                        {
                                CL_Smoke(originmins, originmaxs, velocitymins, velocitymaxs, 8*count);
                                CL_Sparks(originmins, originmaxs, velocitymins, velocitymaxs, 30*count);
+                               CL_NewParticle(center, pt_static, 0x808080,0x808080, tex_particle, 3, 0, 256, 512, 0, 0, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), 0, 0, 0, 0, 0, 0, 0, true, 0, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                        }
                }
                // bullet hole
-               if (cl_stainmaps.integer) R_Stain(center, 32, 96, 96, 96, 24, 128, 128, 128, 24);
+               R_Stain(center, 16, 40, 40, 40, 64, 88, 88, 88, 64);
                CL_SpawnDecalParticleForPoint(center, 6, 3, 255, tex_bulletdecal[rand()&7], 0xFFFFFF, 0xFFFFFF);
                CL_AllocLightFlash(NULL, &tempmatrix, 100, 0.15f, 0.15f, 1.5f, 500, 0.2, 0, -1, true, 1, 0.25, 1, 0, 0, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
        }
@@ -727,13 +947,22 @@ void CL_ParticleEffect_Fallback(int effectnameindex, float count, const vec3_t o
                if (!cl_particles_blood.integer)
                        return;
                if (cl_particles_quake.integer)
-                       CL_ParticleEffect(EFFECT_SVC_PARTICLE, 20*count, originmins, originmaxs, velocitymins, velocitymaxs, NULL, 73);
+                       CL_ParticleEffect(EFFECT_SVC_PARTICLE, 2*count, originmins, originmaxs, velocitymins, velocitymaxs, NULL, 73);
                else
                {
                        static double bloodaccumulator = 0;
+                       qboolean immediatebloodstain = (cl_decals_newsystem_immediatebloodstain.integer >= 1);
+                       //CL_NewParticle(center, pt_alphastatic, 0x4f0000,0x7f0000, tex_particle, 2.5, 0, 256, 256, 0, 0, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), 0, 0, 0, 1, 4, 0, 0, true, 0, 1, PBLEND_ALPHA, PARTICLE_BILLBOARD, NULL);
                        bloodaccumulator += count * 0.333 * cl_particles_quality.value;
                        for (;bloodaccumulator > 0;bloodaccumulator--)
-                               CL_NewParticle(pt_blood, 0xFFFFFF, 0xFFFFFF, tex_bloodparticle[rand()&7], 8, 0, cl_particles_blood_alpha.value * 768, cl_particles_blood_alpha.value * 384, 0, -1, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), lhrandom(velocitymins[0], velocitymaxs[0]), lhrandom(velocitymins[1], velocitymaxs[1]), lhrandom(velocitymins[2], velocitymaxs[2]), 1, 4, 0, 64, true, 0);
+                       {
+                               part = CL_NewParticle(center, pt_blood, 0xFFFFFF, 0xFFFFFF, tex_bloodparticle[rand()&7], 8, 0, cl_particles_blood_alpha.value * 768, cl_particles_blood_alpha.value * 384, 1, -1, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), lhrandom(velocitymins[0], velocitymaxs[0]), lhrandom(velocitymins[1], velocitymaxs[1]), lhrandom(velocitymins[2], velocitymaxs[2]), 1, 4, 0, 64, true, 0, 1, PBLEND_INVMOD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
+                               if (immediatebloodstain && part)
+                               {
+                                       immediatebloodstain = false;
+                                       CL_ImmediateBloodStain(part);
+                               }
+                       }
                }
        }
        else if (effectnameindex == EFFECT_TE_SPARK)
@@ -741,7 +970,7 @@ void CL_ParticleEffect_Fallback(int effectnameindex, float count, const vec3_t o
        else if (effectnameindex == EFFECT_TE_PLASMABURN)
        {
                // plasma scorch mark
-               if (cl_stainmaps.integer) R_Stain(center, 48, 96, 96, 96, 32, 128, 128, 128, 32);
+               R_Stain(center, 40, 40, 40, 40, 64, 88, 88, 88, 64);
                CL_SpawnDecalParticleForPoint(center, 6, 6, 255, tex_bulletdecal[rand()&7], 0xFFFFFF, 0xFFFFFF);
                CL_AllocLightFlash(NULL, &tempmatrix, 200, 1, 1, 1, 1000, 0.2, 0, -1, true, 1, 0.25, 1, 0, 0, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
        }
@@ -755,10 +984,11 @@ void CL_ParticleEffect_Fallback(int effectnameindex, float count, const vec3_t o
                        {
                                CL_Smoke(originmins, originmaxs, velocitymins, velocitymaxs, 4*count);
                                CL_Sparks(originmins, originmaxs, velocitymins, velocitymaxs, 20*count);
+                               CL_NewParticle(center, pt_static, 0x808080,0x808080, tex_particle, 3, 0, 256, 512, 0, 0, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), 0, 0, 0, 0, 0, 0, 0, true, 0, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                        }
                }
                // bullet hole
-               if (cl_stainmaps.integer) R_Stain(center, 32, 96, 96, 96, 24, 128, 128, 128, 24);
+               R_Stain(center, 16, 40, 40, 40, 64, 88, 88, 88, 64);
                CL_SpawnDecalParticleForPoint(center, 6, 3, 255, tex_bulletdecal[rand()&7], 0xFFFFFF, 0xFFFFFF);
        }
        else if (effectnameindex == EFFECT_TE_GUNSHOTQUAD)
@@ -771,10 +1001,11 @@ void CL_ParticleEffect_Fallback(int effectnameindex, float count, const vec3_t o
                        {
                                CL_Smoke(originmins, originmaxs, velocitymins, velocitymaxs, 4*count);
                                CL_Sparks(originmins, originmaxs, velocitymins, velocitymaxs, 20*count);
+                               CL_NewParticle(center, pt_static, 0x808080,0x808080, tex_particle, 3, 0, 256, 512, 0, 0, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), 0, 0, 0, 0, 0, 0, 0, true, 0, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                        }
                }
                // bullet hole
-               if (cl_stainmaps.integer) R_Stain(center, 32, 96, 96, 96, 24, 128, 128, 128, 24);
+               R_Stain(center, 16, 40, 40, 40, 64, 88, 88, 88, 64);
                CL_SpawnDecalParticleForPoint(center, 6, 3, 255, tex_bulletdecal[rand()&7], 0xFFFFFF, 0xFFFFFF);
                CL_AllocLightFlash(NULL, &tempmatrix, 100, 0.15f, 0.15f, 1.5f, 500, 0.2, 0, -1, true, 1, 0.25, 1, 0, 0, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
        }
@@ -796,9 +1027,9 @@ void CL_ParticleEffect_Fallback(int effectnameindex, float count, const vec3_t o
                        for (i = 0;i < 1024 * cl_particles_quality.value;i++)
                        {
                                if (i & 1)
-                                       CL_NewParticle(pt_static, particlepalette[66], particlepalette[71], tex_particle, 1.5f, 0, lhrandom(182, 255), 182, 0, 0, center[0], center[1], center[2], 0, 0, 0, -4, -4, 16, 256, true, 0);
+                                       CL_NewParticle(center, pt_alphastatic, particlepalette[66], particlepalette[71], tex_particle, 1.5f, 0, 255, 0, 0, 0, center[0], center[1], center[2], 0, 0, 0, -4, -4, 16, 256, true, (rand() & 1) ? 1.4 : 1.0, 1, PBLEND_ALPHA, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                                else
-                                       CL_NewParticle(pt_static, particlepalette[150], particlepalette[155], tex_particle, 1.5f, 0, lhrandom(182, 255), 182, 0, 0, center[0], center[1], center[2], 0, 0, lhrandom(-256, 256), 0, 0, 16, 0, true, 0);
+                                       CL_NewParticle(center, pt_alphastatic, particlepalette[150], particlepalette[155], tex_particle, 1.5f, 0, 255, 0, 0, 0, center[0], center[1], center[2], 0, 0, lhrandom(-256, 256), 0, 0, 16, 0, true, (rand() & 1) ? 1.4 : 1.0, 1, PBLEND_ALPHA, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                        }
                }
                else
@@ -811,7 +1042,7 @@ void CL_ParticleEffect_Fallback(int effectnameindex, float count, const vec3_t o
        {
                count *= cl_particles_quality.value;
                while (count-- > 0)
-                       CL_NewParticle(pt_smoke, 0x6f0f00, 0xe3974f, tex_particle, 4, 0, lhrandom(64, 128), 384, -1, 1.1, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), lhrandom(velocitymins[0], velocitymaxs[0]), lhrandom(velocitymins[1], velocitymaxs[1]), lhrandom(velocitymins[2], velocitymaxs[2]), 1, 4, 0, 128, true, 0);
+                       CL_NewParticle(center, pt_smoke, 0x6f0f00, 0xe3974f, tex_particle, 4, 0, lhrandom(64, 128), 384, -1, 1.1, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), lhrandom(velocitymins[0], velocitymaxs[0]), lhrandom(velocitymins[1], velocitymaxs[1]), lhrandom(velocitymins[2], velocitymaxs[2]), 1, 4, 0, 128, true, 0, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
        }
        else if (effectnameindex == EFFECT_TE_LAVASPLASH)
        {
@@ -830,7 +1061,7 @@ void CL_ParticleEffect_Fallback(int effectnameindex, float count, const vec3_t o
                                org[1] = center[1] + dir[1];
                                org[2] = center[2] + lhrandom(0, 64);
                                vel = lhrandom(50, 120) / VectorLength(dir); // normalize and scale
-                               CL_NewParticle(pt_alphastatic, particlepalette[224], particlepalette[231], tex_particle, 1.5f, 0, inc * lhrandom(24, 32), inc * 12, 0.05, 0, org[0], org[1], org[2], dir[0] * vel, dir[1] * vel, dir[2] * vel, 0, 0, 0, 0, true, 0);
+                               CL_NewParticle(center, pt_alphastatic, particlepalette[224], particlepalette[231], tex_particle, 1.5f, 0, 255, 0, 0.05, 0, org[0], org[1], org[2], dir[0] * vel, dir[1] * vel, dir[2] * vel, 0, 0, 0, 0, true, lhrandom(2, 2.62), 1, PBLEND_ALPHA, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                        }
                }
        }
@@ -839,7 +1070,10 @@ void CL_ParticleEffect_Fallback(int effectnameindex, float count, const vec3_t o
                float i, j, k, inc, vel;
                vec3_t dir;
 
-               inc = 8 / cl_particles_quality.value;
+               if (cl_particles_quake.integer)
+                       inc = 4 / cl_particles_quality.value;
+               else
+                       inc = 8 / cl_particles_quality.value;
                for (i = -16;i < 16;i += inc)
                {
                        for (j = -16;j < 16;j += inc)
@@ -849,22 +1083,26 @@ void CL_ParticleEffect_Fallback(int effectnameindex, float count, const vec3_t o
                                        VectorSet(dir, i*8, j*8, k*8);
                                        VectorNormalize(dir);
                                        vel = lhrandom(50, 113);
-                                       CL_NewParticle(pt_alphastatic, particlepalette[7], particlepalette[14], tex_particle, 1.5f, 0, inc * lhrandom(37, 63), inc * 187, 0, 0, center[0] + i + lhrandom(0, inc), center[1] + j + lhrandom(0, inc), center[2] + k + lhrandom(0, inc), dir[0] * vel, dir[1] * vel, dir[2] * vel, 0, 0, 0, 0, true, 0);
+                                       if (cl_particles_quake.integer)
+                                               CL_NewParticle(center, pt_alphastatic, particlepalette[7], particlepalette[14], tex_particle, 1.5f, 0, 255, 0, 0, 0, center[0] + i + lhrandom(0, inc), center[1] + j + lhrandom(0, inc), center[2] + k + lhrandom(0, inc), dir[0] * vel, dir[1] * vel, dir[2] * vel, 0, 0, 0, 0, true, lhrandom(0.2, 0.34), 1, PBLEND_ALPHA, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
+                                       else
+                                               CL_NewParticle(center, pt_alphastatic, particlepalette[7], particlepalette[14], tex_particle, 1.5f, 0, inc * lhrandom(37, 63), inc * 187, 0, 0, center[0] + i + lhrandom(0, inc), center[1] + j + lhrandom(0, inc), center[2] + k + lhrandom(0, inc), dir[0] * vel, dir[1] * vel, dir[2] * vel, 0, 0, 0, 0, true, 0, 1, PBLEND_ALPHA, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                                }
                        }
                }
-               CL_NewParticle(pt_static, particlepalette[14], particlepalette[14], tex_particle, 30, 0, 256, 512, 0, 0, center[0], center[1], center[2], 0, 0, 0, 0, 0, 0, 0, false, 0);
+               if (!cl_particles_quake.integer)
+                       CL_NewParticle(center, pt_static, 0xffffff, 0xffffff, tex_particle, 30, 0, 256, 512, 0, 0, center[0], center[1], center[2], 0, 0, 0, 0, 0, 0, 0, false, 0, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                CL_AllocLightFlash(NULL, &tempmatrix, 200, 2.0f, 2.0f, 2.0f, 400, 99.0f, 0, -1, true, 1, 0.25, 1, 0, 0, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
        }
        else if (effectnameindex == EFFECT_TE_TEI_G3)
-               CL_NewParticle(pt_beam, 0xFFFFFF, 0xFFFFFF, tex_beam, 8, 0, 256, 256, 0, 0, originmins[0], originmins[1], originmins[2], originmaxs[0], originmaxs[1], originmaxs[2], 0, 0, 0, 0, false, 0);
+               CL_NewParticle(center, pt_beam, 0xFFFFFF, 0xFFFFFF, tex_beam, 8, 0, 256, 256, 0, 0, originmins[0], originmins[1], originmins[2], originmaxs[0], originmaxs[1], originmaxs[2], 0, 0, 0, 0, false, 0, 1, PBLEND_ADD, PARTICLE_HBEAM, -1, -1, -1, 1, 1, 0, 0, NULL);
        else if (effectnameindex == EFFECT_TE_TEI_SMOKE)
        {
                if (cl_particles_smoke.integer)
                {
                        count *= 0.25f * cl_particles_quality.value;
                        while (count-- > 0)
-                               CL_NewParticle(pt_smoke, 0x202020, 0x404040, tex_smoke[rand()&7], 5, 0, 255, 512, 0, 0, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), lhrandom(velocitymins[0], velocitymaxs[0]), lhrandom(velocitymins[1], velocitymaxs[1]), lhrandom(velocitymins[2], velocitymaxs[2]), 0, 0, 1.5f, 6.0f, true, 0);
+                               CL_NewParticle(center, pt_smoke, 0x202020, 0x404040, tex_smoke[rand()&7], 5, 0, 255, 512, 0, 0, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), lhrandom(velocitymins[0], velocitymaxs[0]), lhrandom(velocitymins[1], velocitymaxs[1]), lhrandom(velocitymins[2], velocitymaxs[2]), 0, 0, 1.5f, 6.0f, true, 0, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                }
        }
        else if (effectnameindex == EFFECT_TE_TEI_BIGEXPLOSION)
@@ -875,29 +1113,28 @@ void CL_ParticleEffect_Fallback(int effectnameindex, float count, const vec3_t o
        else if (effectnameindex == EFFECT_TE_TEI_PLASMAHIT)
        {
                float f;
-               if (cl_stainmaps.integer)
-                       R_Stain(center, 40, 96, 96, 96, 40, 128, 128, 128, 40);
+               R_Stain(center, 40, 40, 40, 40, 64, 88, 88, 88, 64);
                CL_SpawnDecalParticleForPoint(center, 6, 8, 255, tex_bulletdecal[rand()&7], 0xFFFFFF, 0xFFFFFF);
                if (cl_particles_smoke.integer)
                        for (f = 0;f < count;f += 4.0f / cl_particles_quality.value)
-                               CL_NewParticle(pt_smoke, 0x202020, 0x404040, tex_smoke[rand()&7], 5, 0, 255, 512, 0, 0, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), lhrandom(velocitymins[0], velocitymaxs[0]), lhrandom(velocitymins[1], velocitymaxs[1]), lhrandom(velocitymins[2], velocitymaxs[2]), 0, 0, 20, 155, true, 0);
+                               CL_NewParticle(center, pt_smoke, 0x202020, 0x404040, tex_smoke[rand()&7], 5, 0, 255, 512, 0, 0, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), lhrandom(velocitymins[0], velocitymaxs[0]), lhrandom(velocitymins[1], velocitymaxs[1]), lhrandom(velocitymins[2], velocitymaxs[2]), 0, 0, 20, 155, true, 0, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                if (cl_particles_sparks.integer)
                        for (f = 0;f < count;f += 1.0f / cl_particles_quality.value)
-                               CL_NewParticle(pt_spark, 0x2030FF, 0x80C0FF, tex_particle, 2.0f, 0, lhrandom(64, 255), 512, 0, 0, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), lhrandom(velocitymins[0], velocitymaxs[0]), lhrandom(velocitymins[1], velocitymaxs[1]), lhrandom(velocitymins[2], velocitymaxs[2]), 0, 0, 0, 465, true, 0);
+                               CL_NewParticle(center, pt_spark, 0x2030FF, 0x80C0FF, tex_particle, 2.0f, 0, lhrandom(64, 255), 512, 0, 0, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), lhrandom(velocitymins[0], velocitymaxs[0]), lhrandom(velocitymins[1], velocitymaxs[1]), lhrandom(velocitymins[2], velocitymaxs[2]), 0, 0, 0, 465, true, 0, 1, PBLEND_ADD, PARTICLE_SPARK, -1, -1, -1, 1, 1, 0, 0, NULL);
                CL_AllocLightFlash(NULL, &tempmatrix, 500, 0.6f, 1.2f, 2.0f, 2000, 9999, 0, -1, true, 1, 0.25, 0.25, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
        }
        else if (effectnameindex == EFFECT_EF_FLAME)
        {
                count *= 300 * cl_particles_quality.value;
                while (count-- > 0)
-                       CL_NewParticle(pt_smoke, 0x6f0f00, 0xe3974f, tex_particle, 4, 0, lhrandom(64, 128), 384, -1, 0, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), lhrandom(velocitymins[0], velocitymaxs[0]), lhrandom(velocitymins[1], velocitymaxs[1]), lhrandom(velocitymins[2], velocitymaxs[2]), 1, 4, 16, 128, true, 0);
+                       CL_NewParticle(center, pt_smoke, 0x6f0f00, 0xe3974f, tex_particle, 4, 0, lhrandom(64, 128), 384, -1, 0, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), lhrandom(velocitymins[0], velocitymaxs[0]), lhrandom(velocitymins[1], velocitymaxs[1]), lhrandom(velocitymins[2], velocitymaxs[2]), 1, 4, 16, 128, true, 0, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                CL_AllocLightFlash(NULL, &tempmatrix, 200, 2.0f, 1.5f, 0.5f, 0, 0, 0, -1, true, 1, 0.25, 0.25, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
        }
        else if (effectnameindex == EFFECT_EF_STARDUST)
        {
                count *= 200 * cl_particles_quality.value;
                while (count-- > 0)
-                       CL_NewParticle(pt_static, 0x903010, 0xFFD030, tex_particle, 4, 0, lhrandom(64, 128), 128, 1, 0, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), lhrandom(velocitymins[0], velocitymaxs[0]), lhrandom(velocitymins[1], velocitymaxs[1]), lhrandom(velocitymins[2], velocitymaxs[2]), 0.2, 0.8, 16, 128, true, 0);
+                       CL_NewParticle(center, pt_static, 0x903010, 0xFFD030, tex_particle, 4, 0, lhrandom(64, 128), 128, 1, 0, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), lhrandom(velocitymins[0], velocitymaxs[0]), lhrandom(velocitymins[1], velocitymaxs[1]), lhrandom(velocitymins[2], velocitymaxs[2]), 0.2, 0.8, 16, 128, true, 0, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                CL_AllocLightFlash(NULL, &tempmatrix, 200, 1.0f, 0.7f, 0.3f, 0, 0, 0, -1, true, 1, 0.25, 0.25, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
        }
        else if (!strncmp(particleeffectname[effectnameindex], "TR_", 3))
@@ -927,7 +1164,8 @@ void CL_ParticleEffect_Fallback(int effectnameindex, float count, const vec3_t o
                        {
                                matrix4x4_t tempmatrix;
                                Matrix4x4_CreateFromQuakeEntity(&tempmatrix, originmaxs[0], originmaxs[1], originmaxs[2], 0, 0, 0, light[3]);
-                               R_RTLight_Update(&r_refdef.scene.lights[r_refdef.scene.numlights++], false, &tempmatrix, light, -1, NULL, true, 1, 0.25, 0, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
+                               R_RTLight_Update(&r_refdef.scene.templights[r_refdef.scene.numlights], false, &tempmatrix, light, -1, NULL, true, 1, 0.25, 0, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
+                               r_refdef.scene.lights[r_refdef.scene.numlights] = &r_refdef.scene.templights[r_refdef.scene.numlights];r_refdef.scene.numlights++;
                        }
                }
 
@@ -971,12 +1209,12 @@ void CL_ParticleEffect_Fallback(int effectnameindex, float count, const vec3_t o
                                        if (cl_particles_quake.integer)
                                        {
                                                color = particlepalette[67 + (rand()&3)];
-                                               CL_NewParticle(pt_alphastatic, color, color, tex_particle, 1.5f, 0, 255, 128, 0, -0.05, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 3, 0, true, 0);
+                                               CL_NewParticle(center, pt_alphastatic, color, color, tex_particle, 1.5f, 0, 255, 0, 0.05, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 3, 0, true, 2, 1, PBLEND_ALPHA, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                                        }
                                        else
                                        {
                                                dec = 16;
-                                               CL_NewParticle(pt_blood, 0xFFFFFF, 0xFFFFFF, tex_bloodparticle[rand()&7], 8, 0, qd * cl_particles_blood_alpha.value * 768.0f, qd * cl_particles_blood_alpha.value * 384.0f, 0, -1, pos[0], pos[1], pos[2], lhrandom(velocitymins[0], velocitymaxs[0]), lhrandom(velocitymins[1], velocitymaxs[1]), lhrandom(velocitymins[2], velocitymaxs[2]), 1, 4, 0, 64, true, 0);
+                                               CL_NewParticle(center, pt_blood, 0xFFFFFF, 0xFFFFFF, tex_bloodparticle[rand()&7], 8, 0, qd * cl_particles_blood_alpha.value * 768.0f, qd * cl_particles_blood_alpha.value * 384.0f, 1, -1, pos[0], pos[1], pos[2], lhrandom(velocitymins[0], velocitymaxs[0]), lhrandom(velocitymins[1], velocitymaxs[1]), lhrandom(velocitymins[2], velocitymaxs[2]), 1, 4, 0, 64, true, 0, 1, PBLEND_INVMOD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                                        }
                                }
                                else if (effectnameindex == EFFECT_TR_SLIGHTBLOOD)
@@ -985,12 +1223,12 @@ void CL_ParticleEffect_Fallback(int effectnameindex, float count, const vec3_t o
                                        {
                                                dec = 6;
                                                color = particlepalette[67 + (rand()&3)];
-                                               CL_NewParticle(pt_alphastatic, color, color, tex_particle, 1.5f, 0, 255, 128, 0, -0.05, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 3, 0, true, 0);
+                                               CL_NewParticle(center, pt_alphastatic, color, color, tex_particle, 1.5f, 0, 255, 0, 0.05, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 3, 0, true, 2, 1, PBLEND_ALPHA, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                                        }
                                        else
                                        {
                                                dec = 32;
-                                               CL_NewParticle(pt_blood, 0xFFFFFF, 0xFFFFFF, tex_bloodparticle[rand()&7], 8, 0, qd * cl_particles_blood_alpha.value * 768.0f, qd * cl_particles_blood_alpha.value * 384.0f, 0, -1, pos[0], pos[1], pos[2], lhrandom(velocitymins[0], velocitymaxs[0]), lhrandom(velocitymins[1], velocitymaxs[1]), lhrandom(velocitymins[2], velocitymaxs[2]), 1, 4, 0, 64, true, 0);
+                                               CL_NewParticle(center, pt_blood, 0xFFFFFF, 0xFFFFFF, tex_bloodparticle[rand()&7], 8, 0, qd * cl_particles_blood_alpha.value * 768.0f, qd * cl_particles_blood_alpha.value * 384.0f, 1, -1, pos[0], pos[1], pos[2], lhrandom(velocitymins[0], velocitymaxs[0]), lhrandom(velocitymins[1], velocitymaxs[1]), lhrandom(velocitymins[2], velocitymaxs[2]), 1, 4, 0, 64, true, 0, 1, PBLEND_INVMOD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                                        }
                                }
                        }
@@ -1002,12 +1240,12 @@ void CL_ParticleEffect_Fallback(int effectnameindex, float count, const vec3_t o
                                        {
                                                r = rand()&3;
                                                color = particlepalette[ramp3[r]];
-                                               CL_NewParticle(pt_alphastatic, color, color, tex_particle, 1.5f, 0, 42*(6-r), 306, 0, -0.05, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 3, 0, true, 0);
+                                               CL_NewParticle(center, pt_alphastatic, color, color, tex_particle, 1.5f, 0, 255, 0, -0.05, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 3, 0, true, 0.1372549*(6-r), 1, PBLEND_ALPHA, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                                        }
                                        else
                                        {
-                                               CL_NewParticle(pt_smoke, 0x303030, 0x606060, tex_smoke[rand()&7], 3, 0, cl_particles_smoke_alpha.value*62, cl_particles_smoke_alphafade.value*62, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, true, 0);
-                                               CL_NewParticle(pt_static, 0x801010, 0xFFA020, tex_smoke[rand()&7], 3, 0, cl_particles_smoke_alpha.value*288, cl_particles_smoke_alphafade.value*1400, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 20, true, 0);
+                                               CL_NewParticle(center, pt_smoke, 0x303030, 0x606060, tex_smoke[rand()&7], 3, 0, cl_particles_smoke_alpha.value*62, cl_particles_smoke_alphafade.value*62, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, true, 0, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
+                                               CL_NewParticle(center, pt_static, 0x801010, 0xFFA020, tex_smoke[rand()&7], 3, 0, cl_particles_smoke_alpha.value*288, cl_particles_smoke_alphafade.value*1400, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 20, true, 0, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                                        }
                                }
                                else if (effectnameindex == EFFECT_TR_GRENADE)
@@ -1016,11 +1254,11 @@ void CL_ParticleEffect_Fallback(int effectnameindex, float count, const vec3_t o
                                        {
                                                r = 2 + (rand()%5);
                                                color = particlepalette[ramp3[r]];
-                                               CL_NewParticle(pt_alphastatic, color, color, tex_particle, 1.5f, 0, 42*(6-r), 306, 0, -0.05, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 3, 0, true, 0);
+                                               CL_NewParticle(center, pt_alphastatic, color, color, tex_particle, 1.5f, 0, 255, 0, -0.05, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 3, 0, true, 0.1372549*(6-r), 1, PBLEND_ALPHA, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                                        }
                                        else
                                        {
-                                               CL_NewParticle(pt_smoke, 0x303030, 0x606060, tex_smoke[rand()&7], 3, 0, cl_particles_smoke_alpha.value*50, cl_particles_smoke_alphafade.value*75, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, true, 0);
+                                               CL_NewParticle(center, pt_smoke, 0x303030, 0x606060, tex_smoke[rand()&7], 3, 0, cl_particles_smoke_alpha.value*50, cl_particles_smoke_alphafade.value*75, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, true, 0, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                                        }
                                }
                                else if (effectnameindex == EFFECT_TR_WIZSPIKE)
@@ -1029,18 +1267,18 @@ void CL_ParticleEffect_Fallback(int effectnameindex, float count, const vec3_t o
                                        {
                                                dec = 6;
                                                color = particlepalette[52 + (rand()&7)];
-                                               CL_NewParticle(pt_alphastatic, color, color, tex_particle, 1.5f, 0, 255, 512, 0, 0, pos[0], pos[1], pos[2], 30*dir[1], 30*-dir[0], 0, 0, 0, 0, 0, true, 0);
-                                               CL_NewParticle(pt_alphastatic, color, color, tex_particle, 1.5f, 0, 255, 512, 0, 0, pos[0], pos[1], pos[2], 30*-dir[1], 30*dir[0], 0, 0, 0, 0, 0, true, 0);
+                                               CL_NewParticle(center, pt_alphastatic, color, color, tex_particle, 1.5f, 0, 255, 0, 0, 0, pos[0], pos[1], pos[2], 30*dir[1], 30*-dir[0], 0, 0, 0, 0, 0, true, 0.5, 1, PBLEND_ALPHA, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
+                                               CL_NewParticle(center, pt_alphastatic, color, color, tex_particle, 1.5f, 0, 255, 0, 0, 0, pos[0], pos[1], pos[2], 30*-dir[1], 30*dir[0], 0, 0, 0, 0, 0, true, 0.5, 1, PBLEND_ALPHA, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                                        }
                                        else if (gamemode == GAME_GOODVSBAD2)
                                        {
                                                dec = 6;
-                                               CL_NewParticle(pt_static, 0x00002E, 0x000030, tex_particle, 6, 0, 128, 384, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, true, 0);
+                                               CL_NewParticle(center, pt_static, 0x00002E, 0x000030, tex_particle, 6, 0, 128, 384, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, true, 0, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                                        }
                                        else
                                        {
                                                color = particlepalette[20 + (rand()&7)];
-                                               CL_NewParticle(pt_static, color, color, tex_particle, 2, 0, 64, 192, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, true, 0);
+                                               CL_NewParticle(center, pt_static, color, color, tex_particle, 2, 0, 64, 192, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, true, 0, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                                        }
                                }
                                else if (effectnameindex == EFFECT_TR_KNIGHTSPIKE)
@@ -1049,13 +1287,13 @@ void CL_ParticleEffect_Fallback(int effectnameindex, float count, const vec3_t o
                                        {
                                                dec = 6;
                                                color = particlepalette[230 + (rand()&7)];
-                                               CL_NewParticle(pt_alphastatic, color, color, tex_particle, 1.5f, 0, 255, 512, 0, 0, pos[0], pos[1], pos[2], 30*dir[1], 30*-dir[0], 0, 0, 0, 0, 0, true, 0);
-                                               CL_NewParticle(pt_alphastatic, color, color, tex_particle, 1.5f, 0, 255, 512, 0, 0, pos[0], pos[1], pos[2], 30*-dir[1], 30*dir[0], 0, 0, 0, 0, 0, true, 0);
+                                               CL_NewParticle(center, pt_alphastatic, color, color, tex_particle, 1.5f, 0, 255, 0, 0, 0, pos[0], pos[1], pos[2], 30*dir[1], 30*-dir[0], 0, 0, 0, 0, 0, true, 0.5, 1, PBLEND_ALPHA, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
+                                               CL_NewParticle(center, pt_alphastatic, color, color, tex_particle, 1.5f, 0, 255, 0, 0, 0, pos[0], pos[1], pos[2], 30*-dir[1], 30*dir[0], 0, 0, 0, 0, 0, true, 0.5, 1, PBLEND_ALPHA, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                                        }
                                        else
                                        {
                                                color = particlepalette[226 + (rand()&7)];
-                                               CL_NewParticle(pt_static, color, color, tex_particle, 2, 0, 64, 192, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, true, 0);
+                                               CL_NewParticle(center, pt_static, color, color, tex_particle, 2, 0, 64, 192, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, true, 0, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                                        }
                                }
                                else if (effectnameindex == EFFECT_TR_VORESPIKE)
@@ -1063,40 +1301,40 @@ void CL_ParticleEffect_Fallback(int effectnameindex, float count, const vec3_t o
                                        if (cl_particles_quake.integer)
                                        {
                                                color = particlepalette[152 + (rand()&3)];
-                                               CL_NewParticle(pt_alphastatic, color, color, tex_particle, 1.5f, 0, 255, 850, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 8, 0, true, 0);
+                                               CL_NewParticle(center, pt_alphastatic, color, color, tex_particle, 1.5f, 0, 255, 0, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 8, 0, true, 0.3, 1, PBLEND_ALPHA, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                                        }
                                        else if (gamemode == GAME_GOODVSBAD2)
                                        {
                                                dec = 6;
-                                               CL_NewParticle(pt_alphastatic, particlepalette[0 + (rand()&255)], particlepalette[0 + (rand()&255)], tex_particle, 6, 0, 255, 384, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, true, 0);
+                                               CL_NewParticle(center, pt_alphastatic, particlepalette[0 + (rand()&255)], particlepalette[0 + (rand()&255)], tex_particle, 6, 0, 255, 384, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, true, 0, 1, PBLEND_ALPHA, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                                        }
                                        else if (gamemode == GAME_PRYDON)
                                        {
                                                dec = 6;
-                                               CL_NewParticle(pt_static, 0x103040, 0x204050, tex_particle, 6, 0, 64, 192, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, true, 0);
+                                               CL_NewParticle(center, pt_static, 0x103040, 0x204050, tex_particle, 6, 0, 64, 192, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, true, 0, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                                        }
                                        else
-                                               CL_NewParticle(pt_static, 0x502030, 0x502030, tex_particle, 3, 0, 64, 192, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, true, 0);
+                                               CL_NewParticle(center, pt_static, 0x502030, 0x502030, tex_particle, 3, 0, 64, 192, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, true, 0, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                                }
                                else if (effectnameindex == EFFECT_TR_NEHAHRASMOKE)
                                {
                                        dec = 7;
-                                       CL_NewParticle(pt_alphastatic, 0x303030, 0x606060, tex_smoke[rand()&7], 7, 0, 64, 320, 0, 0, pos[0], pos[1], pos[2], 0, 0, lhrandom(4, 12), 0, 0, 0, 4, false, 0);
+                                       CL_NewParticle(center, pt_alphastatic, 0x303030, 0x606060, tex_smoke[rand()&7], 7, 0, 64, 320, 0, 0, pos[0], pos[1], pos[2], 0, 0, lhrandom(4, 12), 0, 0, 0, 4, false, 0, 1, PBLEND_ALPHA, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                                }
                                else if (effectnameindex == EFFECT_TR_NEXUIZPLASMA)
                                {
                                        dec = 4;
-                                       CL_NewParticle(pt_static, 0x283880, 0x283880, tex_particle, 4, 0, 255, 1024, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 16, true, 0);
+                                       CL_NewParticle(center, pt_static, 0x283880, 0x283880, tex_particle, 4, 0, 255, 1024, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 16, true, 0, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                                }
                                else if (effectnameindex == EFFECT_TR_GLOWTRAIL)
-                                       CL_NewParticle(pt_alphastatic, particlepalette[palettecolor], particlepalette[palettecolor], tex_particle, 5, 0, 128, 320, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, true, 0);
+                                       CL_NewParticle(center, pt_alphastatic, particlepalette[palettecolor], particlepalette[palettecolor], tex_particle, 5, 0, 128, 320, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, true, 0, 1, PBLEND_ALPHA, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                        }
                        if (bubbles)
                        {
                                if (effectnameindex == EFFECT_TR_ROCKET)
-                                       CL_NewParticle(pt_bubble, 0x404040, 0x808080, tex_bubble, 2, 0, lhrandom(64, 255), 256, -0.25, 1.5, pos[0], pos[1], pos[2], 0, 0, 0, 0.0625, 0.25, 0, 16, true, 0);
+                                       CL_NewParticle(center, pt_bubble, 0x404040, 0x808080, tex_bubble, 2, 0, lhrandom(128, 512), 512, -0.25, 1.5, pos[0], pos[1], pos[2], 0, 0, 0, 0.0625, 0.25, 0, 16, true, 0, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                                else if (effectnameindex == EFFECT_TR_GRENADE)
-                                       CL_NewParticle(pt_bubble, 0x404040, 0x808080, tex_bubble, 2, 0, lhrandom(64, 255), 256, -0.25, 1.5, pos[0], pos[1], pos[2], 0, 0, 0, 0.0625, 0.25, 0, 16, true, 0);
+                                       CL_NewParticle(center, pt_bubble, 0x404040, 0x808080, tex_bubble, 2, 0, lhrandom(128, 512), 512, -0.25, 1.5, pos[0], pos[1], pos[2], 0, 0, 0, 0.0625, 0.25, 0, 16, true, 0, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                        }
                        // advance to next time and position
                        dec *= qd;
@@ -1106,45 +1344,53 @@ void CL_ParticleEffect_Fallback(int effectnameindex, float count, const vec3_t o
                if (ent)
                        ent->persistent.trail_time = len;
        }
-       else if (developer.integer >= 1)
-               Con_Printf("CL_ParticleEffect_Fallback: no fallback found for effect %s\n", particleeffectname[effectnameindex]);
+       else
+               Con_DPrintf("CL_ParticleEffect_Fallback: no fallback found for effect %s\n", particleeffectname[effectnameindex]);
 }
 
 // this is also called on point effects with spawndlight = true and
 // spawnparticles = true
 // it is called CL_ParticleTrail because most code does not want to supply
 // these parameters, only trail handling does
-void CL_ParticleTrail(int effectnameindex, float pcount, const vec3_t originmins, const vec3_t originmaxs, const vec3_t velocitymins, const vec3_t velocitymaxs, entity_t *ent, int palettecolor, qboolean spawndlight, qboolean spawnparticles)
+void CL_ParticleTrail(int effectnameindex, float pcount, const vec3_t originmins, const vec3_t originmaxs, const vec3_t velocitymins, const vec3_t velocitymaxs, entity_t *ent, int palettecolor, qboolean spawndlight, qboolean spawnparticles, float tintmins[4], float tintmaxs[4])
 {
-       vec3_t center;
        qboolean found = false;
-       if (effectnameindex < 1 || effectnameindex >= MAX_PARTICLEEFFECTNAME)
-               return; // invalid effect index
-       if (!particleeffectname[effectnameindex][0])
+       if (effectnameindex < 1 || effectnameindex >= MAX_PARTICLEEFFECTNAME || !particleeffectname[effectnameindex][0])
+       {
+               Con_DPrintf("Unknown effect number %i received from server\n", effectnameindex);
                return; // no such effect
-       VectorLerp(originmins, 0.5, originmaxs, center);
+       }
        if (!cl_particles_quake.integer && particleeffectinfo[0].effectnameindex)
        {
                int effectinfoindex;
                int supercontents;
-               int tex;
+               int tex, staintex;
                particleeffectinfo_t *info;
                vec3_t center;
-               vec3_t centervelocity;
                vec3_t traildir;
                vec3_t trailpos;
                vec3_t rvec;
                vec_t traillen;
                vec_t trailstep;
                qboolean underwater;
+               qboolean immediatebloodstain;
+               particle_t *part;
+               float avgtint[4], tint[4], tintlerp;
                // note this runs multiple effects with the same name, each one spawns only one kind of particle, so some effects need more than one
                VectorLerp(originmins, 0.5, originmaxs, center);
-               VectorLerp(velocitymins, 0.5, velocitymaxs, centervelocity);
                supercontents = CL_PointSuperContents(center);
                underwater = (supercontents & (SUPERCONTENTS_WATER | SUPERCONTENTS_SLIME)) != 0;
                VectorSubtract(originmaxs, originmins, traildir);
                traillen = VectorLength(traildir);
                VectorNormalize(traildir);
+               if(tintmins)
+               {
+                       Vector4Lerp(tintmins, 0.5, tintmaxs, avgtint);
+               }
+               else
+               {
+                       Vector4Set(avgtint, 1, 1, 1, 1);
+               }
                for (effectinfoindex = 0, info = particleeffectinfo;effectinfoindex < MAX_PARTICLEEFFECTINFO && info->effectnameindex;effectinfoindex++, info++)
                {
                        if (info->effectnameindex == effectnameindex)
@@ -1167,14 +1413,18 @@ void CL_ParticleTrail(int effectnameindex, float pcount, const vec3_t originmins
                                        {
                                                // light flash (explosion, etc)
                                                // called when effect starts
-                                               CL_AllocLightFlash(NULL, &tempmatrix, info->lightradiusstart, info->lightcolor[0], info->lightcolor[1], info->lightcolor[2], info->lightradiusfade, info->lighttime, info->lightcubemapnum, -1, info->lightshadow, 1, 0.25, 0, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
+                                               CL_AllocLightFlash(NULL, &tempmatrix, info->lightradiusstart, info->lightcolor[0]*avgtint[0]*avgtint[3], info->lightcolor[1]*avgtint[1]*avgtint[3], info->lightcolor[2]*avgtint[2]*avgtint[3], info->lightradiusfade, info->lighttime, info->lightcubemapnum, -1, info->lightshadow, 1, 0.25, 0, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
                                        }
-                                       else
+                                       else if (r_refdef.scene.numlights < MAX_DLIGHTS)
                                        {
                                                // glowing entity
                                                // called by CL_LinkNetworkEntity
                                                Matrix4x4_Scale(&tempmatrix, info->lightradiusstart, 1);
-                                               R_RTLight_Update(&r_refdef.scene.lights[r_refdef.scene.numlights++], false, &tempmatrix, info->lightcolor, -1, info->lightcubemapnum > 0 ? va("cubemaps/%i", info->lightcubemapnum) : NULL, info->lightshadow, 1, 0.25, 0, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
+                                               rvec[0] = info->lightcolor[0]*avgtint[0]*avgtint[3];
+                                               rvec[1] = info->lightcolor[1]*avgtint[1]*avgtint[3];
+                                               rvec[2] = info->lightcolor[2]*avgtint[2]*avgtint[3];
+                                               R_RTLight_Update(&r_refdef.scene.templights[r_refdef.scene.numlights], false, &tempmatrix, rvec, -1, info->lightcubemapnum > 0 ? va("cubemaps/%i", info->lightcubemapnum) : NULL, info->lightshadow, 1, 0.25, 0, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
+                                               r_refdef.scene.lights[r_refdef.scene.numlights] = &r_refdef.scene.templights[r_refdef.scene.numlights];r_refdef.scene.numlights++;
                                        }
                                }
 
@@ -1188,10 +1438,17 @@ void CL_ParticleTrail(int effectnameindex, float pcount, const vec3_t originmins
                                        tex = (int)lhrandom(info->tex[0], info->tex[1]);
                                        tex = min(tex, info->tex[1] - 1);
                                }
+                               if(info->staintex[0] < 0)
+                                       staintex = info->staintex[0];
+                               else
+                               {
+                                       staintex = (int)lhrandom(info->staintex[0], info->staintex[1]);
+                                       staintex = min(staintex, info->staintex[1] - 1);
+                               }
                                if (info->particletype == pt_decal)
-                                       CL_SpawnDecalParticleForPoint(center, info->originjitter[0], lhrandom(info->size[0], info->size[1]), lhrandom(info->alpha[0], info->alpha[1]), tex, info->color[0], info->color[1]);
-                               else if (info->particletype == pt_beam)
-                                       CL_NewParticle(info->particletype, info->color[0], info->color[1], tex, lhrandom(info->size[0], info->size[1]), info->size[2], lhrandom(info->alpha[0], info->alpha[1]), info->alpha[2], 0, 0, originmins[0], originmins[1], originmins[2], originmaxs[0], originmaxs[1], originmaxs[2], 0, 0, 0, 0, false, 0);
+                                       CL_SpawnDecalParticleForPoint(center, info->originjitter[0], lhrandom(info->size[0], info->size[1]), lhrandom(info->alpha[0], info->alpha[1])*avgtint[3], tex, info->color[0], info->color[1]);
+                               else if (info->orientation == PARTICLE_HBEAM)
+                                       CL_NewParticle(center, info->particletype, info->color[0], info->color[1], tex, lhrandom(info->size[0], info->size[1]), info->size[2], lhrandom(info->alpha[0], info->alpha[1]), info->alpha[2], 0, 0, originmins[0], originmins[1], originmins[2], originmaxs[0], originmaxs[1], originmaxs[2], 0, 0, 0, 0, false, lhrandom(info->time[0], info->time[1]), info->stretchfactor, info->blendmode, info->orientation, info->staincolor[0], info->staincolor[1], staintex, lhrandom(info->stainalpha[0], info->stainalpha[1]), lhrandom(info->stainsize[0], info->stainsize[1]), 0, 0, tintmins ? avgtint : NULL);
                                else
                                {
                                        if (!cl_particles.integer)
@@ -1209,13 +1466,18 @@ void CL_ParticleTrail(int effectnameindex, float pcount, const vec3_t originmins
                                        VectorCopy(originmins, trailpos);
                                        if (info->trailspacing > 0)
                                        {
-                                               info->particleaccumulator += traillen / info->trailspacing * cl_particles_quality.value;
-                                               trailstep = info->trailspacing / cl_particles_quality.value;
+                                               info->particleaccumulator += traillen / info->trailspacing * cl_particles_quality.value * pcount;
+                                               trailstep = info->trailspacing / cl_particles_quality.value / max(0.001, pcount);
+                                               immediatebloodstain = false;
                                        }
                                        else
                                        {
                                                info->particleaccumulator += info->countabsolute + pcount * info->countmultiplier * cl_particles_quality.value;
                                                trailstep = 0;
+                                               immediatebloodstain =
+                                                       ((cl_decals_newsystem_immediatebloodstain.integer >= 1) && (info->particletype == pt_blood))
+                                                       ||
+                                                       ((cl_decals_newsystem_immediatebloodstain.integer >= 2) && staintex);
                                        }
                                        info->particleaccumulator = bound(0, info->particleaccumulator, 16384);
                                        for (;info->particleaccumulator >= 1;info->particleaccumulator--)
@@ -1231,8 +1493,18 @@ void CL_ParticleTrail(int effectnameindex, float pcount, const vec3_t originmins
                                                        trailpos[1] = lhrandom(originmins[1], originmaxs[1]);
                                                        trailpos[2] = lhrandom(originmins[2], originmaxs[2]);
                                                }
+                                               if(tintmins)
+                                               {
+                                                       tintlerp = lhrandom(0, 1);
+                                                       Vector4Lerp(tintmins, tintlerp, tintmaxs, tint);
+                                               }
                                                VectorRandom(rvec);
-                                               CL_NewParticle(info->particletype, info->color[0], info->color[1], tex, lhrandom(info->size[0], info->size[1]), info->size[2], lhrandom(info->alpha[0], info->alpha[1]), info->alpha[2], info->gravity, info->bounce, trailpos[0] + info->originoffset[0] + info->originjitter[0] * rvec[0], trailpos[1] + info->originoffset[1] + info->originjitter[1] * rvec[1], trailpos[2] + info->originoffset[2] + info->originjitter[2] * rvec[2], lhrandom(velocitymins[0], velocitymaxs[0]) * info->velocitymultiplier + info->velocityoffset[0] + info->velocityjitter[0] * rvec[0], lhrandom(velocitymins[1], velocitymaxs[1]) * info->velocitymultiplier + info->velocityoffset[1] + info->velocityjitter[1] * rvec[1], lhrandom(velocitymins[2], velocitymaxs[2]) * info->velocitymultiplier + info->velocityoffset[2] + info->velocityjitter[2] * rvec[2], info->airfriction, info->liquidfriction, 0, 0, info->countabsolute <= 0, 0);
+                                               part = CL_NewParticle(center, info->particletype, info->color[0], info->color[1], tex, lhrandom(info->size[0], info->size[1]), info->size[2], lhrandom(info->alpha[0], info->alpha[1]), info->alpha[2], info->gravity, info->bounce, trailpos[0] + info->originoffset[0] + info->originjitter[0] * rvec[0], trailpos[1] + info->originoffset[1] + info->originjitter[1] * rvec[1], trailpos[2] + info->originoffset[2] + info->originjitter[2] * rvec[2], lhrandom(velocitymins[0], velocitymaxs[0]) * info->velocitymultiplier + info->velocityoffset[0] + info->velocityjitter[0] * rvec[0], lhrandom(velocitymins[1], velocitymaxs[1]) * info->velocitymultiplier + info->velocityoffset[1] + info->velocityjitter[1] * rvec[1], lhrandom(velocitymins[2], velocitymaxs[2]) * info->velocitymultiplier + info->velocityoffset[2] + info->velocityjitter[2] * rvec[2], info->airfriction, info->liquidfriction, 0, 0, info->countabsolute <= 0, lhrandom(info->time[0], info->time[1]), info->stretchfactor, info->blendmode, info->orientation, info->staincolor[0], info->staincolor[1], staintex, lhrandom(info->stainalpha[0], info->stainalpha[1]), lhrandom(info->stainsize[0], info->stainsize[1]), lhrandom(info->rotate[0], info->rotate[1]), lhrandom(info->rotate[2], info->rotate[3]), tintmins ? tint : NULL);
+                                               if (immediatebloodstain && part)
+                                               {
+                                                       immediatebloodstain = false;
+                                                       CL_ImmediateBloodStain(part);
+                                               }
                                                if (trailstep)
                                                        VectorMA(trailpos, trailstep, traildir, trailpos);
                                        }
@@ -1246,7 +1518,7 @@ void CL_ParticleTrail(int effectnameindex, float pcount, const vec3_t originmins
 
 void CL_ParticleEffect(int effectnameindex, float pcount, const vec3_t originmins, const vec3_t originmaxs, const vec3_t velocitymins, const vec3_t velocitymaxs, entity_t *ent, int palettecolor)
 {
-       CL_ParticleTrail(effectnameindex, pcount, originmins, originmaxs, velocitymins, velocitymaxs, ent, palettecolor, true, true);
+       CL_ParticleTrail(effectnameindex, pcount, originmins, originmaxs, velocitymins, velocitymaxs, ent, palettecolor, true, true, NULL, NULL);
 }
 
 /*
@@ -1275,7 +1547,7 @@ void CL_EntityParticles (const entity_t *ent)
                v[0] = org[0] + m_bytenormals[i][0] * dist + (cos(pitch)*cos(yaw)) * beamlength;
                v[1] = org[1] + m_bytenormals[i][1] * dist + (cos(pitch)*sin(yaw)) * beamlength;
                v[2] = org[2] + m_bytenormals[i][2] * dist + (-sin(pitch)) * beamlength;
-               CL_NewParticle(pt_entityparticle, particlepalette[0x6f], particlepalette[0x6f], tex_particle, 1, 0, 255, 0, 0, 0, v[0], v[1], v[2], 0, 0, 0, 0, 0, 0, 0, true, 0);
+               CL_NewParticle(org, pt_entityparticle, particlepalette[0x6f], particlepalette[0x6f], tex_particle, 1, 0, 255, 0, 0, 0, v[0], v[1], v[2], 0, 0, 0, 0, 0, 0, 0, true, 0, 1, PBLEND_ALPHA, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
        }
 }
 
@@ -1285,13 +1557,12 @@ void CL_ReadPointFile_f (void)
        vec3_t org, leakorg;
        int r, c, s;
        char *pointfile = NULL, *pointfilepos, *t, tchar;
-       char name[MAX_OSPATH];
+       char name[MAX_QPATH];
 
        if (!cl.worldmodel)
                return;
 
-       FS_StripExtension (cl.worldmodel->name, name, sizeof (name));
-       strlcat (name, ".pts", sizeof (name));
+       dpsnprintf(name, sizeof(name), "%s.pts", cl.worldnamenoextension);
        pointfile = (char *)FS_LoadFile(name, tempmempool, true, NULL);
        if (!pointfile)
        {
@@ -1315,6 +1586,9 @@ void CL_ReadPointFile_f (void)
                        t++;
                tchar = *t;
                *t = 0;
+#if _MSC_VER >= 1400
+#define sscanf sscanf_s
+#endif
                r = sscanf (pointfilepos,"%f %f %f", &org[0], &org[1], &org[2]);
                *t = tchar;
                pointfilepos = t;
@@ -1327,16 +1601,16 @@ void CL_ReadPointFile_f (void)
                if (cl.num_particles < cl.max_particles - 3)
                {
                        s++;
-                       CL_NewParticle(pt_static, particlepalette[(-c)&15], particlepalette[(-c)&15], tex_particle, 2, 0, 255, 0, 0, 0, org[0], org[1], org[2], 0, 0, 0, 0, 0, 0, 0, true, 1<<30);
+                       CL_NewParticle(org, pt_alphastatic, particlepalette[(-c)&15], particlepalette[(-c)&15], tex_particle, 2, 0, 255, 0, 0, 0, org[0], org[1], org[2], 0, 0, 0, 0, 0, 0, 0, true, 1<<30, 1, PBLEND_ALPHA, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                }
        }
        Mem_Free(pointfile);
        VectorCopy(leakorg, org);
        Con_Printf("%i points read (%i particles spawned)\nLeak at %f %f %f\n", c, s, org[0], org[1], org[2]);
 
-       CL_NewParticle(pt_beam, 0xFF0000, 0xFF0000, tex_beam, 64, 0, 255, 0, 0, 0, org[0] - 4096, org[1], org[2], org[0] + 4096, org[1], org[2], 0, 0, 0, 0, false, 1<<30);
-       CL_NewParticle(pt_beam, 0x00FF00, 0x00FF00, tex_beam, 64, 0, 255, 0, 0, 0, org[0], org[1] - 4096, org[2], org[0], org[1] + 4096, org[2], 0, 0, 0, 0, false, 1<<30);
-       CL_NewParticle(pt_beam, 0x0000FF, 0x0000FF, tex_beam, 64, 0, 255, 0, 0, 0, org[0], org[1], org[2] - 4096, org[0], org[1], org[2] + 4096, 0, 0, 0, 0, false, 1<<30);
+       CL_NewParticle(org, pt_beam, 0xFF0000, 0xFF0000, tex_beam, 64, 0, 255, 0, 0, 0, org[0] - 4096, org[1], org[2], org[0] + 4096, org[1], org[2], 0, 0, 0, 0, false, 1<<30, 1, PBLEND_ADD, PARTICLE_HBEAM, -1, -1, -1, 1, 1, 0, 0, NULL);
+       CL_NewParticle(org, pt_beam, 0x00FF00, 0x00FF00, tex_beam, 64, 0, 255, 0, 0, 0, org[0], org[1] - 4096, org[2], org[0], org[1] + 4096, org[2], 0, 0, 0, 0, false, 1<<30, 1, PBLEND_ADD, PARTICLE_HBEAM, -1, -1, -1, 1, 1, 0, 0, NULL);
+       CL_NewParticle(org, pt_beam, 0x0000FF, 0x0000FF, tex_beam, 64, 0, 255, 0, 0, 0, org[0], org[1], org[2] - 4096, org[0], org[1], org[2] + 4096, 0, 0, 0, 0, false, 1<<30, 1, PBLEND_ADD, PARTICLE_HBEAM, -1, -1, -1, 1, 1, 0, 0, NULL);
 }
 
 /*
@@ -1353,7 +1627,7 @@ void CL_ParseParticleEffect (void)
 
        MSG_ReadVector(org, cls.protocol);
        for (i=0 ; i<3 ; i++)
-               dir[i] = MSG_ReadChar ();
+               dir[i] = MSG_ReadChar () * (1.0 / 16.0);
        msgcount = MSG_ReadByte ();
        color = MSG_ReadByte ();
 
@@ -1377,8 +1651,7 @@ void CL_ParticleExplosion (const vec3_t org)
        trace_t trace;
        //vec3_t v;
        //vec3_t v2;
-       if (cl_stainmaps.integer)
-               R_Stain(org, 96, 80, 80, 80, 64, 176, 176, 176, 64);
+       R_Stain(org, 96, 40, 40, 40, 64, 88, 88, 88, 64);
        CL_SpawnDecalParticleForPoint(org, 40, 48, 255, tex_bulletdecal[rand()&7], 0xFFFFFF, 0xFFFFFF);
 
        if (cl_particles_quake.integer)
@@ -1390,12 +1663,12 @@ void CL_ParticleExplosion (const vec3_t org)
                        if (i & 1)
                        {
                                color = particlepalette[ramp1[r]];
-                               CL_NewParticle(pt_alphastatic, color, color, tex_particle, 1.5f, 0, 32 * (8 - r), 318, 0, 0, org[0], org[1], org[2], 0, 0, 0, -4, -4, 16, 256, true, 0);
+                               CL_NewParticle(org, pt_alphastatic, color, color, tex_particle, 1.5f, 0, 255, 0, 0, 0, org[0], org[1], org[2], 0, 0, 0, -4, -4, 16, 256, true, 0.1006 * (8 - r), 1, PBLEND_ALPHA, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                        }
                        else
                        {
                                color = particlepalette[ramp2[r]];
-                               CL_NewParticle(pt_alphastatic, color, color, tex_particle, 1.5f, 0, 32 * (8 - r), 478, 0, 0, org[0], org[1], org[2], 0, 0, 0, 1, 1, 16, 256, true, 0);
+                               CL_NewParticle(org, pt_alphastatic, color, color, tex_particle, 1.5f, 0, 255, 0, 0, 0, org[0], org[1], org[2], 0, 0, 0, 1, 1, 16, 256, true, 0.0669 * (8 - r), 1, PBLEND_ALPHA, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                        }
                }
        }
@@ -1406,7 +1679,7 @@ void CL_ParticleExplosion (const vec3_t org)
                {
                        if (cl_particles.integer && cl_particles_bubbles.integer)
                                for (i = 0;i < 128 * cl_particles_quality.value;i++)
-                                       CL_NewParticle(pt_bubble, 0x404040, 0x808080, tex_bubble, 2, 0, lhrandom(128, 255), 128, -0.125, 1.5, org[0], org[1], org[2], 0, 0, 0, 0.0625, 0.25, 16, 96, true, 0);
+                                       CL_NewParticle(org, pt_bubble, 0x404040, 0x808080, tex_bubble, 2, 0, lhrandom(128, 255), 128, -0.125, 1.5, org[0], org[1], org[2], 0, 0, 0, 0.0625, 0.25, 16, 96, true, 0, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                }
                else
                {
@@ -1414,19 +1687,18 @@ void CL_ParticleExplosion (const vec3_t org)
                        {
                                for (i = 0;i < 512 * cl_particles_quality.value;i++)
                                {
-                                       int k;
+                                       int k = 0;
                                        vec3_t v, v2;
-                                       for (k = 0;k < 16;k++)
+                                       do
                                        {
                                                VectorRandom(v2);
                                                VectorMA(org, 128, v2, v);
-                                               trace = CL_Move(org, vec3_origin, vec3_origin, v, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false);
-                                               if (trace.fraction >= 0.1)
-                                                       break;
+                                               trace = CL_TraceLine(org, v, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, true, false, NULL, false);
                                        }
+                                       while (k < 16 && trace.fraction < 0.1f);
                                        VectorSubtract(trace.endpos, org, v2);
                                        VectorScale(v2, 2.0f, v2);
-                                       CL_NewParticle(pt_spark, 0x903010, 0xFFD030, tex_particle, 1.0f, 0, lhrandom(0, 255), 512, 0, 0, org[0], org[1], org[2], v2[0], v2[1], v2[2], 0, 0, 0, 0, true, 0);
+                                       CL_NewParticle(org, pt_spark, 0x903010, 0xFFD030, tex_particle, 1.0f, 0, lhrandom(0, 255), 512, 0, 0, org[0], org[1], org[2], v2[0], v2[1], v2[2], 0, 0, 0, 0, true, 0, 1, PBLEND_ADD, PARTICLE_SPARK, -1, -1, -1, 1, 1, 0, 0, NULL);
                                }
                        }
                }
@@ -1451,42 +1723,48 @@ void CL_ParticleExplosion2 (const vec3_t org, int colorStart, int colorLength)
        {
                k = particlepalette[colorStart + (i % colorLength)];
                if (cl_particles_quake.integer)
-                       CL_NewParticle(pt_static, k, k, tex_particle, 1, 0, 255, 850, 0, 0, org[0], org[1], org[2], 0, 0, 0, -4, -4, 8, 256, true, 0);
+                       CL_NewParticle(org, pt_alphastatic, k, k, tex_particle, 1, 0, 255, 0, 0, 0, org[0], org[1], org[2], 0, 0, 0, -4, -4, 16, 256, true, 0.3, 1, PBLEND_ALPHA, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                else
-                       CL_NewParticle(pt_static, k, k, tex_particle, lhrandom(0.5, 1.5), 0, 255, 512, 0, 0, org[0], org[1], org[2], 0, 0, 0, lhrandom(1.5, 3), lhrandom(1.5, 3), 8, 192, true, 0);
+                       CL_NewParticle(org, pt_alphastatic, k, k, tex_particle, lhrandom(0.5, 1.5), 0, 255, 512, 0, 0, org[0], org[1], org[2], 0, 0, 0, lhrandom(1.5, 3), lhrandom(1.5, 3), 8, 192, true, 0, 1, PBLEND_ALPHA, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
        }
 }
 
 static void CL_Sparks(const vec3_t originmins, const vec3_t originmaxs, const vec3_t velocitymins, const vec3_t velocitymaxs, float sparkcount)
 {
+       vec3_t center;
+       VectorMAM(0.5f, originmins, 0.5f, originmaxs, center);
        if (cl_particles_sparks.integer)
        {
                sparkcount *= cl_particles_quality.value;
                while(sparkcount-- > 0)
-                       CL_NewParticle(pt_spark, particlepalette[0x68], particlepalette[0x6f], tex_particle, 0.5f, 0, lhrandom(64, 255), 512, 1, 0, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), lhrandom(velocitymins[0], velocitymaxs[0]), lhrandom(velocitymins[1], velocitymaxs[1]), lhrandom(velocitymins[2], velocitymaxs[2]) + cl.movevars_gravity * 0.1f, 0, 0, 0, 64, true, 0);
+                       CL_NewParticle(center, pt_spark, particlepalette[0x68], particlepalette[0x6f], tex_particle, 0.5f, 0, lhrandom(64, 255), 512, 1, 0, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), lhrandom(velocitymins[0], velocitymaxs[0]), lhrandom(velocitymins[1], velocitymaxs[1]), lhrandom(velocitymins[2], velocitymaxs[2]) + cl.movevars_gravity * 0.1f, 0, 0, 0, 64, true, 0, 1, PBLEND_ADD, PARTICLE_SPARK, -1, -1, -1, 1, 1, 0, 0, NULL);
        }
 }
 
 static void CL_Smoke(const vec3_t originmins, const vec3_t originmaxs, const vec3_t velocitymins, const vec3_t velocitymaxs, float smokecount)
 {
+       vec3_t center;
+       VectorMAM(0.5f, originmins, 0.5f, originmaxs, center);
        if (cl_particles_smoke.integer)
        {
                smokecount *= cl_particles_quality.value;
                while(smokecount-- > 0)
-                       CL_NewParticle(pt_smoke, 0x101010, 0x101010, tex_smoke[rand()&7], 2, 2, 255, 256, 0, 0, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), lhrandom(velocitymins[0], velocitymaxs[0]), lhrandom(velocitymins[1], velocitymaxs[1]), lhrandom(velocitymins[2], velocitymaxs[2]), 0, 0, 0, smokecount > 0 ? 16 : 0, true, 0);
+                       CL_NewParticle(center, pt_smoke, 0x101010, 0x101010, tex_smoke[rand()&7], 2, 2, 255, 256, 0, 0, lhrandom(originmins[0], originmaxs[0]), lhrandom(originmins[1], originmaxs[1]), lhrandom(originmins[2], originmaxs[2]), lhrandom(velocitymins[0], velocitymaxs[0]), lhrandom(velocitymins[1], velocitymaxs[1]), lhrandom(velocitymins[2], velocitymaxs[2]), 0, 0, 0, smokecount > 0 ? 16 : 0, true, 0, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
        }
 }
 
 void CL_ParticleCube (const vec3_t mins, const vec3_t maxs, const vec3_t dir, int count, int colorbase, vec_t gravity, vec_t randomvel)
 {
+       vec3_t center;
        int k;
        if (!cl_particles.integer) return;
+       VectorMAM(0.5f, mins, 0.5f, maxs, center);
 
        count = (int)(count * cl_particles_quality.value);
        while (count--)
        {
                k = particlepalette[colorbase + (rand()&3)];
-               CL_NewParticle(pt_alphastatic, k, k, tex_particle, 2, 0, 255, 128, gravity, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(mins[2], maxs[2]), dir[0], dir[1], dir[2], 0, 0, 0, randomvel, true, 0);
+               CL_NewParticle(center, pt_alphastatic, k, k, tex_particle, 2, 0, 255, 128, gravity, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(mins[2], maxs[2]), dir[0], dir[1], dir[2], 0, 0, 0, randomvel, true, 0, 1, PBLEND_ALPHA, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
        }
 }
 
@@ -1494,6 +1772,7 @@ void CL_ParticleRain (const vec3_t mins, const vec3_t maxs, const vec3_t dir, in
 {
        int k;
        float minz, maxz, lifetime = 30;
+       vec3_t org;
        if (!cl_particles.integer) return;
        if (dir[2] < 0) // falling
        {
@@ -1521,10 +1800,11 @@ void CL_ParticleRain (const vec3_t mins, const vec3_t maxs, const vec3_t dir, in
                while(count--)
                {
                        k = particlepalette[colorbase + (rand()&3)];
+                       VectorSet(org, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz));
                        if (gamemode == GAME_GOODVSBAD2)
-                               CL_NewParticle(pt_rain, k, k, tex_particle, 20, 0, lhrandom(32, 64), 0, 0, -1, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz), dir[0], dir[1], dir[2], 0, 0, 0, 0, true, lifetime);
+                               CL_NewParticle(org, pt_rain, k, k, tex_particle, 20, 0, lhrandom(32, 64), 0, 0, -1, org[0], org[1], org[2], dir[0], dir[1], dir[2], 0, 0, 0, 0, true, lifetime, 1, PBLEND_ADD, PARTICLE_SPARK, -1, -1, -1, 1, 1, 0, 0, NULL);
                        else
-                               CL_NewParticle(pt_rain, k, k, tex_particle, 0.5, 0, lhrandom(32, 64), 0, 0, -1, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz), dir[0], dir[1], dir[2], 0, 0, 0, 0, true, lifetime);
+                               CL_NewParticle(org, pt_rain, k, k, tex_particle, 0.5, 0, lhrandom(32, 64), 0, 0, -1, org[0], org[1], org[2], dir[0], dir[1], dir[2], 0, 0, 0, 0, true, lifetime, 1, PBLEND_ADD, PARTICLE_SPARK, -1, -1, -1, 1, 1, 0, 0, NULL);
                }
                break;
        case 1:
@@ -1532,10 +1812,11 @@ void CL_ParticleRain (const vec3_t mins, const vec3_t maxs, const vec3_t dir, in
                while(count--)
                {
                        k = particlepalette[colorbase + (rand()&3)];
+                       VectorSet(org, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz));
                        if (gamemode == GAME_GOODVSBAD2)
-                               CL_NewParticle(pt_snow, k, k, tex_particle, 20, 0, lhrandom(64, 128), 0, 0, -1, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz), dir[0], dir[1], dir[2], 0, 0, 0, 0, true, lifetime);
+                               CL_NewParticle(org, pt_snow, k, k, tex_particle, 20, 0, lhrandom(64, 128), 0, 0, -1, org[0], org[1], org[2], dir[0], dir[1], dir[2], 0, 0, 0, 0, true, lifetime, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                        else
-                               CL_NewParticle(pt_snow, k, k, tex_particle, 1, 0, lhrandom(64, 128), 0, 0, -1, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz), dir[0], dir[1], dir[2], 0, 0, 0, 0, true, lifetime);
+                               CL_NewParticle(org, pt_snow, k, k, tex_particle, 1, 0, lhrandom(64, 128), 0, 0, -1, org[0], org[1], org[2], dir[0], dir[1], dir[2], 0, 0, 0, 0, true, lifetime, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
                }
                break;
        default:
@@ -1543,21 +1824,10 @@ void CL_ParticleRain (const vec3_t mins, const vec3_t maxs, const vec3_t dir, in
        }
 }
 
-#define MAX_PARTICLETEXTURES 64
-// particletexture_t is a rectangle in the particlefonttexture
-typedef struct particletexture_s
-{
-       rtexture_t *texture;
-       float s1, t1, s2, t2;
-}
-particletexture_t;
-
-static rtexturepool_t *particletexturepool;
-static rtexture_t *particlefonttexture;
-static particletexture_t particletexture[MAX_PARTICLETEXTURES];
-
 static cvar_t r_drawparticles = {0, "r_drawparticles", "1", "enables drawing of particles"};
 static cvar_t r_drawparticles_drawdistance = {CVAR_SAVE, "r_drawparticles_drawdistance", "2000", "particles further than drawdistance*size will not be drawn"};
+static cvar_t r_drawparticles_nearclip_min = {CVAR_SAVE, "r_drawparticles_nearclip_min", "4", "particles closer than drawnearclip_min will not be drawn"};
+static cvar_t r_drawparticles_nearclip_max = {CVAR_SAVE, "r_drawparticles_nearclip_max", "4", "particles closer than drawnearclip_min will be faded"};
 static cvar_t r_drawdecals = {0, "r_drawdecals", "1", "enables drawing of decals"};
 static cvar_t r_drawdecals_drawdistance = {CVAR_SAVE, "r_drawdecals_drawdistance", "500", "decals further than drawdistance*size will not be drawn"};
 
@@ -1597,11 +1867,21 @@ static unsigned char shadebubble(float dx, float dy, vec3_t light)
                return 0;
 }
 
+int particlefontwidth, particlefontheight, particlefontcellwidth, particlefontcellheight, particlefontrows, particlefontcols;
+void CL_Particle_PixelCoordsForTexnum(int texnum, int *basex, int *basey, int *width, int *height)
+{
+       *basex = (texnum % particlefontcols) * particlefontcellwidth;
+       *basey = ((texnum / particlefontcols) % particlefontrows) * particlefontcellheight;
+       *width = particlefontcellwidth;
+       *height = particlefontcellheight;
+}
+
 static void setuptex(int texnum, unsigned char *data, unsigned char *particletexturedata)
 {
-       int basex, basey, y;
-       basex = ((texnum >> 0) & 7) * PARTICLETEXTURESIZE;
-       basey = ((texnum >> 3) & 7) * PARTICLETEXTURESIZE;
+       int basex, basey, w, h, y;
+       CL_Particle_PixelCoordsForTexnum(texnum, &basex, &basey, &w, &h);
+       if(w != PARTICLETEXTURESIZE || h != PARTICLETEXTURESIZE)
+               Sys_Error("invalid particle texture size for autogenerating");
        for (y = 0;y < PARTICLETEXTURESIZE;y++)
                memcpy(particletexturedata + ((basey + y) * PARTICLEFONTSIZE + basex) * 4, data + y * PARTICLETEXTURESIZE * 4, PARTICLETEXTURESIZE * 4);
 }
@@ -1661,32 +1941,34 @@ void particletextureinvert(unsigned char *data)
 static void R_InitBloodTextures (unsigned char *particletexturedata)
 {
        int i, j, k, m;
-       unsigned char data[PARTICLETEXTURESIZE][PARTICLETEXTURESIZE][4];
+       size_t datasize = PARTICLETEXTURESIZE*PARTICLETEXTURESIZE*4;
+       unsigned char *data = (unsigned char *)Mem_Alloc(tempmempool, datasize);
 
        // blood particles
        for (i = 0;i < 8;i++)
        {
-               memset(&data[0][0][0], 255, sizeof(data));
+               memset(data, 255, datasize);
                for (k = 0;k < 24;k++)
-                       particletextureblotch(&data[0][0][0], PARTICLETEXTURESIZE/16, 96, 0, 0, 160);
-               //particletextureclamp(&data[0][0][0], 32, 32, 32, 255, 255, 255);
-               particletextureinvert(&data[0][0][0]);
-               setuptex(tex_bloodparticle[i], &data[0][0][0], particletexturedata);
+                       particletextureblotch(data, PARTICLETEXTURESIZE/16, 96, 0, 0, 160);
+               //particletextureclamp(data, 32, 32, 32, 255, 255, 255);
+               particletextureinvert(data);
+               setuptex(tex_bloodparticle[i], data, particletexturedata);
        }
 
        // blood decals
        for (i = 0;i < 8;i++)
        {
-               memset(&data[0][0][0], 255, sizeof(data));
+               memset(data, 255, datasize);
                m = 8;
                for (j = 1;j < 10;j++)
                        for (k = min(j, m - 1);k < m;k++)
-                               particletextureblotch(&data[0][0][0], (float)j*PARTICLETEXTURESIZE/64.0f, 96, 0, 0, 320 - j * 8);
-               //particletextureclamp(&data[0][0][0], 32, 32, 32, 255, 255, 255);
-               particletextureinvert(&data[0][0][0]);
-               setuptex(tex_blooddecal[i], &data[0][0][0], particletexturedata);
+                               particletextureblotch(data, (float)j*PARTICLETEXTURESIZE/64.0f, 96, 0, 0, 320 - j * 8);
+               //particletextureclamp(data, 32, 32, 32, 255, 255, 255);
+               particletextureinvert(data);
+               setuptex(tex_blooddecal[i], data, particletexturedata);
        }
 
+       Mem_Free(data);
 }
 
 //uncomment this to make engine save out particle font to a tga file when run
@@ -1695,8 +1977,12 @@ static void R_InitBloodTextures (unsigned char *particletexturedata)
 static void R_InitParticleTexture (void)
 {
        int x, y, d, i, k, m;
-       float dx, dy, f;
+       int basex, basey, w, h;
+       float dx, dy, f, s1, t1, s2, t2;
        vec3_t light;
+       char *buf;
+       fs_offset_t filesize;
+       char texturename[MAX_QPATH];
 
        // a note: decals need to modulate (multiply) the background color to
        // properly darken it (stain), and they need to be able to alpha fade,
@@ -1708,24 +1994,42 @@ static void R_InitParticleTexture (void)
        // we invert it again during the blendfunc to make it work...
 
 #ifndef DUMPPARTICLEFONT
-       particlefonttexture = loadtextureimage(particletexturepool, "particles/particlefont.tga", false, TEXF_ALPHA | TEXF_PRECACHE, true);
-       if (!particlefonttexture)
+       decalskinframe = R_SkinFrame_LoadExternal("particles/particlefont.tga", TEXF_ALPHA | TEXF_FORCELINEAR, false);
+       if (decalskinframe)
+       {
+               particlefonttexture = decalskinframe->base;
+               // TODO maybe allow custom grid size?
+               particlefontwidth = image_width;
+               particlefontheight = image_height;
+               particlefontcellwidth = image_width / 8;
+               particlefontcellheight = image_height / 8;
+               particlefontcols = 8;
+               particlefontrows = 8;
+       }
+       else
 #endif
        {
                unsigned char *particletexturedata = (unsigned char *)Mem_Alloc(tempmempool, PARTICLEFONTSIZE*PARTICLEFONTSIZE*4);
-               unsigned char data[PARTICLETEXTURESIZE][PARTICLETEXTURESIZE][4];
+               size_t datasize = PARTICLETEXTURESIZE*PARTICLETEXTURESIZE*4;
+               unsigned char *data = (unsigned char *)Mem_Alloc(tempmempool, datasize);
+               unsigned char *noise1 = (unsigned char *)Mem_Alloc(tempmempool, PARTICLETEXTURESIZE*2*PARTICLETEXTURESIZE*2);
+               unsigned char *noise2 = (unsigned char *)Mem_Alloc(tempmempool, PARTICLETEXTURESIZE*2*PARTICLETEXTURESIZE*2);
+
+               particlefontwidth = particlefontheight = PARTICLEFONTSIZE;
+               particlefontcellwidth = particlefontcellheight = PARTICLETEXTURESIZE;
+               particlefontcols = 8;
+               particlefontrows = 8;
+
                memset(particletexturedata, 255, PARTICLEFONTSIZE*PARTICLEFONTSIZE*4);
 
                // smoke
                for (i = 0;i < 8;i++)
                {
-                       memset(&data[0][0][0], 255, sizeof(data));
+                       memset(data, 255, datasize);
                        do
                        {
-                               unsigned char noise1[PARTICLETEXTURESIZE*2][PARTICLETEXTURESIZE*2], noise2[PARTICLETEXTURESIZE*2][PARTICLETEXTURESIZE*2];
-
-                               fractalnoise(&noise1[0][0], PARTICLETEXTURESIZE*2, PARTICLETEXTURESIZE/8);
-                               fractalnoise(&noise2[0][0], PARTICLETEXTURESIZE*2, PARTICLETEXTURESIZE/4);
+                               fractalnoise(noise1, PARTICLETEXTURESIZE*2, PARTICLETEXTURESIZE/8);
+                               fractalnoise(noise2, PARTICLETEXTURESIZE*2, PARTICLETEXTURESIZE/4);
                                m = 0;
                                for (y = 0;y < PARTICLETEXTURESIZE;y++)
                                {
@@ -1733,23 +2037,23 @@ static void R_InitParticleTexture (void)
                                        for (x = 0;x < PARTICLETEXTURESIZE;x++)
                                        {
                                                dx = (x - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f-1);
-                                               d = (noise2[y][x] - 128) * 3 + 192;
+                                               d = (noise2[y*PARTICLETEXTURESIZE*2+x] - 128) * 3 + 192;
                                                if (d > 0)
                                                        d = (int)(d * (1-(dx*dx+dy*dy)));
-                                               d = (d * noise1[y][x]) >> 7;
+                                               d = (d * noise1[y*PARTICLETEXTURESIZE*2+x]) >> 7;
                                                d = bound(0, d, 255);
-                                               data[y][x][3] = (unsigned char) d;
+                                               data[(y*PARTICLETEXTURESIZE+x)*4+3] = (unsigned char) d;
                                                if (m < d)
                                                        m = d;
                                        }
                                }
                        }
                        while (m < 224);
-                       setuptex(tex_smoke[i], &data[0][0][0], particletexturedata);
+                       setuptex(tex_smoke[i], data, particletexturedata);
                }
 
                // rain splash
-               memset(&data[0][0][0], 255, sizeof(data));
+               memset(data, 255, datasize);
                for (y = 0;y < PARTICLETEXTURESIZE;y++)
                {
                        dy = (y - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f-1);
@@ -1757,13 +2061,13 @@ static void R_InitParticleTexture (void)
                        {
                                dx = (x - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f-1);
                                f = 255.0f * (1.0 - 4.0f * fabs(10.0f - sqrt(dx*dx+dy*dy)));
-                               data[y][x][3] = (int) (bound(0.0f, f, 255.0f));
+                               data[(y*PARTICLETEXTURESIZE+x)*4+3] = (int) (bound(0.0f, f, 255.0f));
                        }
                }
-               setuptex(tex_rainsplash, &data[0][0][0], particletexturedata);
+               setuptex(tex_rainsplash, data, particletexturedata);
 
                // normal particle
-               memset(&data[0][0][0], 255, sizeof(data));
+               memset(data, 255, datasize);
                for (y = 0;y < PARTICLETEXTURESIZE;y++)
                {
                        dy = (y - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f-1);
@@ -1772,13 +2076,13 @@ static void R_InitParticleTexture (void)
                                dx = (x - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f-1);
                                d = (int)(256 * (1 - (dx*dx+dy*dy)));
                                d = bound(0, d, 255);
-                               data[y][x][3] = (unsigned char) d;
+                               data[(y*PARTICLETEXTURESIZE+x)*4+3] = (unsigned char) d;
                        }
                }
-               setuptex(tex_particle, &data[0][0][0], particletexturedata);
+               setuptex(tex_particle, data, particletexturedata);
 
                // rain
-               memset(&data[0][0][0], 255, sizeof(data));
+               memset(data, 255, datasize);
                light[0] = 1;light[1] = 1;light[2] = 1;
                VectorNormalize(light);
                for (y = 0;y < PARTICLETEXTURESIZE;y++)
@@ -1795,13 +2099,13 @@ static void R_InitParticleTexture (void)
                                dx = (x - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f-1);
                                // shrink bubble width to half
                                dx *= 2.0f;
-                               data[y][x][3] = shadebubble(dx, dy, light);
+                               data[(y*PARTICLETEXTURESIZE+x)*4+3] = shadebubble(dx, dy, light);
                        }
                }
-               setuptex(tex_raindrop, &data[0][0][0], particletexturedata);
+               setuptex(tex_raindrop, data, particletexturedata);
 
                // bubble
-               memset(&data[0][0][0], 255, sizeof(data));
+               memset(data, 255, datasize);
                light[0] = 1;light[1] = 1;light[2] = 1;
                VectorNormalize(light);
                for (y = 0;y < PARTICLETEXTURESIZE;y++)
@@ -1810,10 +2114,10 @@ static void R_InitParticleTexture (void)
                        for (x = 0;x < PARTICLETEXTURESIZE;x++)
                        {
                                dx = (x - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f-1);
-                               data[y][x][3] = shadebubble(dx, dy, light);
+                               data[(y*PARTICLETEXTURESIZE+x)*4+3] = shadebubble(dx, dy, light);
                        }
                }
-               setuptex(tex_bubble, &data[0][0][0], particletexturedata);
+               setuptex(tex_bubble, data, particletexturedata);
 
                // Blood particles and blood decals
                R_InitBloodTextures (particletexturedata);
@@ -1821,37 +2125,40 @@ static void R_InitParticleTexture (void)
                // bullet decals
                for (i = 0;i < 8;i++)
                {
-                       memset(&data[0][0][0], 255, sizeof(data));
+                       memset(data, 255, datasize);
                        for (k = 0;k < 12;k++)
-                               particletextureblotch(&data[0][0][0], PARTICLETEXTURESIZE/16, 0, 0, 0, 128);
+                               particletextureblotch(data, PARTICLETEXTURESIZE/16, 0, 0, 0, 128);
                        for (k = 0;k < 3;k++)
-                               particletextureblotch(&data[0][0][0], PARTICLETEXTURESIZE/2, 0, 0, 0, 160);
-                       //particletextureclamp(&data[0][0][0], 64, 64, 64, 255, 255, 255);
-                       particletextureinvert(&data[0][0][0]);
-                       setuptex(tex_bulletdecal[i], &data[0][0][0], particletexturedata);
+                               particletextureblotch(data, PARTICLETEXTURESIZE/2, 0, 0, 0, 160);
+                       //particletextureclamp(data, 64, 64, 64, 255, 255, 255);
+                       particletextureinvert(data);
+                       setuptex(tex_bulletdecal[i], data, particletexturedata);
                }
 
 #ifdef DUMPPARTICLEFONT
                Image_WriteTGABGRA ("particles/particlefont.tga", PARTICLEFONTSIZE, PARTICLEFONTSIZE, particletexturedata);
 #endif
 
-               particlefonttexture = R_LoadTexture2D(particletexturepool, "particlefont", PARTICLEFONTSIZE, PARTICLEFONTSIZE, particletexturedata, TEXTYPE_BGRA, TEXF_ALPHA | TEXF_PRECACHE, NULL);
+               decalskinframe = R_SkinFrame_LoadInternalBGRA("particlefont", TEXF_ALPHA | TEXF_FORCELINEAR, particletexturedata, PARTICLEFONTSIZE, PARTICLEFONTSIZE);
+               particlefonttexture = decalskinframe->base;
 
                Mem_Free(particletexturedata);
+               Mem_Free(data);
+               Mem_Free(noise1);
+               Mem_Free(noise2);
        }
        for (i = 0;i < MAX_PARTICLETEXTURES;i++)
        {
-               int basex = ((i >> 0) & 7) * PARTICLETEXTURESIZE;
-               int basey = ((i >> 3) & 7) * PARTICLETEXTURESIZE;
+               CL_Particle_PixelCoordsForTexnum(i, &basex, &basey, &w, &h);
                particletexture[i].texture = particlefonttexture;
-               particletexture[i].s1 = (basex + 1) / (float)PARTICLEFONTSIZE;
-               particletexture[i].t1 = (basey + 1) / (float)PARTICLEFONTSIZE;
-               particletexture[i].s2 = (basex + PARTICLETEXTURESIZE - 1) / (float)PARTICLEFONTSIZE;
-               particletexture[i].t2 = (basey + PARTICLETEXTURESIZE - 1) / (float)PARTICLEFONTSIZE;
+               particletexture[i].s1 = (basex + 1) / (float)particlefontwidth;
+               particletexture[i].t1 = (basey + 1) / (float)particlefontheight;
+               particletexture[i].s2 = (basex + w - 1) / (float)particlefontwidth;
+               particletexture[i].t2 = (basey + h - 1) / (float)particlefontheight;
        }
 
 #ifndef DUMPPARTICLEFONT
-       particletexture[tex_beam].texture = loadtextureimage(particletexturepool, "particles/nexbeam.tga", false, TEXF_ALPHA | TEXF_PRECACHE, true);
+       particletexture[tex_beam].texture = loadtextureimage(particletexturepool, "particles/nexbeam.tga", false, TEXF_ALPHA | TEXF_FORCELINEAR, true, r_texture_convertsRGB_particles.integer != 0);
        if (!particletexture[tex_beam].texture)
 #endif
        {
@@ -1874,16 +2181,82 @@ static void R_InitParticleTexture (void)
 #ifdef DUMPPARTICLEFONT
                Image_WriteTGABGRA ("particles/nexbeam.tga", 64, 64, &data2[0][0][0]);
 #endif
-               particletexture[tex_beam].texture = R_LoadTexture2D(particletexturepool, "nexbeam", 16, 64, &data2[0][0][0], TEXTYPE_BGRA, TEXF_PRECACHE, NULL);
+               particletexture[tex_beam].texture = R_LoadTexture2D(particletexturepool, "nexbeam", 16, 64, &data2[0][0][0], TEXTYPE_BGRA, TEXF_ALPHA | TEXF_FORCELINEAR, -1, NULL);
        }
        particletexture[tex_beam].s1 = 0;
        particletexture[tex_beam].t1 = 0;
        particletexture[tex_beam].s2 = 1;
        particletexture[tex_beam].t2 = 1;
+
+       // now load an texcoord/texture override file
+       buf = (char *) FS_LoadFile("particles/particlefont.txt", tempmempool, false, &filesize);
+       if(buf)
+       {
+               const char *bufptr;
+               bufptr = buf;
+               for(;;)
+               {
+                       if(!COM_ParseToken_Simple(&bufptr, true, false))
+                               break;
+                       if(!strcmp(com_token, "\n"))
+                               continue; // empty line
+                       i = atoi(com_token);
+
+                       texturename[0] = 0;
+                       s1 = 0;
+                       t1 = 0;
+                       s2 = 1;
+                       t2 = 1;
+
+                       if (COM_ParseToken_Simple(&bufptr, true, false) && strcmp(com_token, "\n"))
+                       {
+                               strlcpy(texturename, com_token, sizeof(texturename));
+                               s1 = atof(com_token);
+                               if (COM_ParseToken_Simple(&bufptr, true, false) && strcmp(com_token, "\n"))
+                               {
+                                       texturename[0] = 0;
+                                       t1 = atof(com_token);
+                                       if (COM_ParseToken_Simple(&bufptr, true, false) && strcmp(com_token, "\n"))
+                                       {
+                                               s2 = atof(com_token);
+                                               if (COM_ParseToken_Simple(&bufptr, true, false) && strcmp(com_token, "\n"))
+                                               {
+                                                       t2 = atof(com_token);
+                                                       strlcpy(texturename, "particles/particlefont.tga", sizeof(texturename));
+                                                       if (COM_ParseToken_Simple(&bufptr, true, false) && strcmp(com_token, "\n"))
+                                                               strlcpy(texturename, com_token, sizeof(texturename));
+                                               }
+                                       }
+                               }
+                               else
+                                       s1 = 0;
+                       }
+                       if (!texturename[0])
+                       {
+                               Con_Printf("particles/particlefont.txt: syntax should be texnum x1 y1 x2 y2 texturename or texnum x1 y1 x2 y2 or texnum texturename\n");
+                               continue;
+                       }
+                       if (i < 0 || i >= MAX_PARTICLETEXTURES)
+                       {
+                               Con_Printf("particles/particlefont.txt: texnum %i outside valid range (0 to %i)\n", i, MAX_PARTICLETEXTURES);
+                               continue;
+                       }
+                       particletexture[i].texture = R_SkinFrame_LoadExternal(texturename, TEXF_ALPHA | TEXF_FORCELINEAR, false)->base;
+                       particletexture[i].s1 = s1;
+                       particletexture[i].t1 = t1;
+                       particletexture[i].s2 = s2;
+                       particletexture[i].t2 = t2;
+               }
+               Mem_Free(buf);
+       }
 }
 
 static void r_part_start(void)
 {
+       int i;
+       // generate particlepalette for convenience from the main one
+       for (i = 0;i < 256;i++)
+               particlepalette[i] = palette_rgb[i][0] * 65536 + palette_rgb[i][1] * 256 + palette_rgb[i][2];
        particletexturepool = R_AllocTexturePool();
        R_InitParticleTexture ();
        CL_Particles_LoadEffectInfo();
@@ -1896,29 +2269,35 @@ static void r_part_shutdown(void)
 
 static void r_part_newmap(void)
 {
+       if (decalskinframe)
+               R_SkinFrame_MarkUsed(decalskinframe);
+       CL_Particles_LoadEffectInfo();
 }
 
 #define BATCHSIZE 256
-int particle_element3i[BATCHSIZE*6];
+unsigned short particle_elements[BATCHSIZE*6];
+float particle_vertex3f[BATCHSIZE*12], particle_texcoord2f[BATCHSIZE*8], particle_color4f[BATCHSIZE*16];
 
 void R_Particles_Init (void)
 {
        int i;
        for (i = 0;i < BATCHSIZE;i++)
        {
-               particle_element3i[i*6+0] = i*4+0;
-               particle_element3i[i*6+1] = i*4+1;
-               particle_element3i[i*6+2] = i*4+2;
-               particle_element3i[i*6+3] = i*4+0;
-               particle_element3i[i*6+4] = i*4+2;
-               particle_element3i[i*6+5] = i*4+3;
+               particle_elements[i*6+0] = i*4+0;
+               particle_elements[i*6+1] = i*4+1;
+               particle_elements[i*6+2] = i*4+2;
+               particle_elements[i*6+3] = i*4+0;
+               particle_elements[i*6+4] = i*4+2;
+               particle_elements[i*6+5] = i*4+3;
        }
 
        Cvar_RegisterVariable(&r_drawparticles);
        Cvar_RegisterVariable(&r_drawparticles_drawdistance);
+       Cvar_RegisterVariable(&r_drawparticles_nearclip_min);
+       Cvar_RegisterVariable(&r_drawparticles_nearclip_max);
        Cvar_RegisterVariable(&r_drawdecals);
        Cvar_RegisterVariable(&r_drawdecals_drawdistance);
-       R_RegisterModule("R_Particles", r_part_start, r_part_shutdown, r_part_newmap);
+       R_RegisterModule("R_Particles", r_part_start, r_part_shutdown, r_part_newmap, NULL, NULL);
 }
 
 void R_DrawDecal_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
@@ -1928,15 +2307,12 @@ void R_DrawDecal_TransparentCallback(const entity_render_t *ent, const rtlight_t
        float *v3f, *t2f, *c4f;
        particletexture_t *tex;
        float right[3], up[3], size, ca;
-       float alphascale = (1.0f / 65536.0f) * cl_particles_alpha.value * r_refdef.view.colorscale;
-       float particle_vertex3f[BATCHSIZE*12], particle_texcoord2f[BATCHSIZE*8], particle_color4f[BATCHSIZE*16];
-
-       r_refdef.stats.decals += numsurfaces;
-       R_Mesh_Matrix(&identitymatrix);
-       R_Mesh_ResetTextureState();
-       R_Mesh_VertexPointer(particle_vertex3f, 0, 0);
-       R_Mesh_TexCoordPointer(0, 2, particle_texcoord2f, 0, 0);
-       R_Mesh_ColorPointer(particle_color4f, 0, 0);
+       float alphascale = (1.0f / 65536.0f) * cl_particles_alpha.value;
+
+       RSurf_ActiveWorldEntity();
+
+       r_refdef.stats.drawndecals += numsurfaces;
+//     R_Mesh_ResetTextureState();
        GL_DepthMask(false);
        GL_DepthRange(0, 1);
        GL_PolygonOffset(0, 0);
@@ -1951,8 +2327,11 @@ void R_DrawDecal_TransparentCallback(const entity_render_t *ent, const rtlight_t
                // calculate color
                c4f = particle_color4f + 16*surfacelistindex;
                ca = d->alpha * alphascale;
+               // ensure alpha multiplier saturates properly
+               if (ca > 1.0f / 256.0f)
+                       ca = 1.0f / 256.0f;     
                if (r_refdef.fogenabled)
-                       ca *= FogPoint_World(d->org);
+                       ca *= RSurf_FogVertex(d->org);
                Vector4Set(c4f, d->color[0] * ca, d->color[1] * ca, d->color[2] * ca, 1);
                Vector4Copy(c4f, c4f + 4);
                Vector4Copy(c4f, c4f + 8);
@@ -1989,37 +2368,40 @@ void R_DrawDecal_TransparentCallback(const entity_render_t *ent, const rtlight_t
        // now render the decals all at once
        // (this assumes they all use one particle font texture!)
        GL_BlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
-       R_Mesh_TexBind(0, R_GetTexture(particletexture[63].texture));
-       GL_LockArrays(0, numsurfaces*4);
-       R_Mesh_Draw(0, numsurfaces * 4, numsurfaces * 2, particle_element3i, 0, 0);
-       GL_LockArrays(0, 0);
+       R_SetupShader_Generic(particletexture[63].texture, NULL, GL_MODULATE, 1);
+       R_Mesh_PrepareVertices_Generic_Arrays(numsurfaces * 4, particle_vertex3f, particle_color4f, particle_texcoord2f);
+       R_Mesh_Draw(0, numsurfaces * 4, 0, numsurfaces * 2, NULL, NULL, 0, particle_elements, NULL, 0);
 }
 
 void R_DrawDecals (void)
 {
        int i;
+       int drawdecals = r_drawdecals.integer;
        decal_t *decal;
        float frametime;
        float decalfade;
-       // used as if (i & qualitymask) to skip some less important particles
-       // according to cl_minfps
-       int qualitymask = (1 << r_refdef.view.qualityreduction) - 1;
-       float drawdist2 = r_drawdecals_drawdistance.value * r_drawdecals_drawdistance.value;
+       float drawdist2;
+       int killsequence = cl.decalsequence - max(0, cl_decals_max.integer);
 
        frametime = bound(0, cl.time - cl.decals_updatetime, 1);
-       cl.decals_updatetime += frametime;
+       cl.decals_updatetime = bound(cl.time - 1, cl.decals_updatetime + frametime, cl.time + 1);
 
        // LordHavoc: early out conditions
-       if ((!cl.num_decals) || (!r_drawdecals.integer))
+       if (!cl.num_decals)
                return;
 
        decalfade = frametime * 256 / cl_decals_fadetime.value;
+       drawdist2 = r_drawdecals_drawdistance.value * r_refdef.view.quality;
+       drawdist2 = drawdist2*drawdist2;
 
        for (i = 0, decal = cl.decals;i < cl.num_decals;i++, decal++)
        {
                if (!decal->typeindex)
                        continue;
 
+               if (killsequence - decal->decalsequence > 0)
+                       goto killdecal;
+
                if (cl.time > decal->time2 + cl_decals_time.value)
                {
                        decal->alpha -= decalfade;
@@ -2038,8 +2420,10 @@ void R_DrawDecals (void)
                                goto killdecal;
                }
 
-               // skip some of the less important decals according to cl_minfps
-               if (i & qualitymask)
+               if(cl_decals_visculling.integer && decal->clusterindex > -1000 && !CHECKPVSBIT(r_refdef.viewcache.world_pvsbits, decal->clusterindex))
+                       continue;
+
+               if (!drawdecals)
                        continue;
 
                if (DotProduct(r_refdef.view.origin, decal->normal) > DotProduct(decal->org, decal->normal) && VectorDistance2(decal->org, r_refdef.view.origin) < drawdist2 * (decal->size * decal->size))
@@ -2055,14 +2439,16 @@ killdecal:
        while (cl.num_decals > 0 && cl.decals[cl.num_decals - 1].typeindex == 0)
                cl.num_decals--;
 
-       if (cl.num_decals == cl.max_decals && cl.max_decals < ABSOLUTE_MAX_DECALS)
+       if (cl.num_decals == cl.max_decals && cl.max_decals < MAX_DECALS)
        {
                decal_t *olddecals = cl.decals;
-               cl.max_decals = min(cl.max_decals * 2, ABSOLUTE_MAX_DECALS);
+               cl.max_decals = min(cl.max_decals * 2, MAX_DECALS);
                cl.decals = (decal_t *) Mem_Alloc(cls.levelmempool, cl.max_decals * sizeof(decal_t));
                memcpy(cl.decals, olddecals, cl.num_decals * sizeof(decal_t));
                Mem_Free(olddecals);
        }
+
+       r_refdef.stats.totaldecals = cl.num_decals;
 }
 
 void R_DrawParticle_TransparentCallback(const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
@@ -2074,54 +2460,83 @@ void R_DrawParticle_TransparentCallback(const entity_render_t *ent, const rtligh
        rtexture_t *texture;
        float *v3f, *t2f, *c4f;
        particletexture_t *tex;
-       float up2[3], v[3], right[3], up[3], fog, ifog, size;
+       float up2[3], v[3], right[3], up[3], fog, ifog, size, len, lenfactor, alpha;
        float ambient[3], diffuse[3], diffusenormal[3];
+       float palpha, spintime, spinrad, spincos, spinsin, spinm1, spinm2, spinm3, spinm4, baseright[3], baseup[3];
        vec4_t colormultiplier;
-       float particle_vertex3f[BATCHSIZE*12], particle_texcoord2f[BATCHSIZE*8], particle_color4f[BATCHSIZE*16];
+       float minparticledist_start, minparticledist_end;
+       qboolean dofade;
+
+       RSurf_ActiveWorldEntity();
 
        Vector4Set(colormultiplier, r_refdef.view.colorscale * (1.0 / 256.0f), r_refdef.view.colorscale * (1.0 / 256.0f), r_refdef.view.colorscale * (1.0 / 256.0f), cl_particles_alpha.value * (1.0 / 256.0f));
 
        r_refdef.stats.particles += numsurfaces;
-       R_Mesh_Matrix(&identitymatrix);
-       R_Mesh_ResetTextureState();
-       R_Mesh_VertexPointer(particle_vertex3f, 0, 0);
-       R_Mesh_TexCoordPointer(0, 2, particle_texcoord2f, 0, 0);
-       R_Mesh_ColorPointer(particle_color4f, 0, 0);
+//     R_Mesh_ResetTextureState();
        GL_DepthMask(false);
        GL_DepthRange(0, 1);
        GL_PolygonOffset(0, 0);
        GL_DepthTest(true);
+       GL_AlphaTest(false);
        GL_CullFace(GL_NONE);
 
+       spintime = r_refdef.scene.time;
+
+       minparticledist_start = DotProduct(r_refdef.view.origin, r_refdef.view.forward) + r_drawparticles_nearclip_min.value;
+       minparticledist_end = DotProduct(r_refdef.view.origin, r_refdef.view.forward) + r_drawparticles_nearclip_max.value;
+       dofade = (minparticledist_start < minparticledist_end);
+
        // first generate all the vertices at once
        for (surfacelistindex = 0, v3f = particle_vertex3f, t2f = particle_texcoord2f, c4f = particle_color4f;surfacelistindex < numsurfaces;surfacelistindex++, v3f += 3*4, t2f += 2*4, c4f += 4*4)
        {
                p = cl.particles + surfacelist[surfacelistindex];
 
-               blendmode = particletype[p->typeindex].blendmode;
+               blendmode = (pblend_t)p->blendmode;
+               palpha = p->alpha;
+               if(dofade && p->orientation != PARTICLE_VBEAM && p->orientation != PARTICLE_HBEAM)
+                       palpha *= min(1, (DotProduct(p->org, r_refdef.view.forward)  - minparticledist_start) / (minparticledist_end - minparticledist_start));
 
-               c4f[0] = p->color[0] * colormultiplier[0];
-               c4f[1] = p->color[1] * colormultiplier[1];
-               c4f[2] = p->color[2] * colormultiplier[2];
-               c4f[3] = p->alpha * colormultiplier[3];
                switch (blendmode)
                {
-               case PBLEND_MOD:
+               case PBLEND_INVALID:
+               case PBLEND_INVMOD:
+                       alpha = palpha * colormultiplier[3];
+                       // ensure alpha multiplier saturates properly
+                       if (alpha > 1.0f)
+                               alpha = 1.0f;
+                       // additive and modulate can just fade out in fog (this is correct)
+                       if (r_refdef.fogenabled)
+                               alpha *= RSurf_FogVertex(p->org);
+                       // collapse alpha into color for these blends (so that the particlefont does not need alpha on most textures)
+                       alpha *= 1.0f / 256.0f;
+                       c4f[0] = p->color[0] * alpha;
+                       c4f[1] = p->color[1] * alpha;
+                       c4f[2] = p->color[2] * alpha;
+                       c4f[3] = 1;
+                       break;
                case PBLEND_ADD:
+                       alpha = palpha * colormultiplier[3];
+                       // ensure alpha multiplier saturates properly
+                       if (alpha > 1.0f)
+                               alpha = 1.0f;
                        // additive and modulate can just fade out in fog (this is correct)
                        if (r_refdef.fogenabled)
-                               c4f[3] *= FogPoint_World(p->org);
+                               alpha *= RSurf_FogVertex(p->org);
                        // collapse alpha into color for these blends (so that the particlefont does not need alpha on most textures)
-                       c4f[0] *= c4f[3];
-                       c4f[1] *= c4f[3];
-                       c4f[2] *= c4f[3];
+                       c4f[0] = p->color[0] * colormultiplier[0] * alpha;
+                       c4f[1] = p->color[1] * colormultiplier[1] * alpha;
+                       c4f[2] = p->color[2] * colormultiplier[2] * alpha;
                        c4f[3] = 1;
                        break;
                case PBLEND_ALPHA:
+                       c4f[0] = p->color[0] * colormultiplier[0];
+                       c4f[1] = p->color[1] * colormultiplier[1];
+                       c4f[2] = p->color[2] * colormultiplier[2];
+                       c4f[3] = palpha * colormultiplier[3];
                        // note: lighting is not cheap!
                        if (particletype[p->typeindex].lighting)
                        {
-                               R_CompleteLightPoint(ambient, diffuse, diffusenormal, p->org, true);
+                               R_CompleteLightPoint(ambient, diffuse, diffusenormal, p->org, true, false);
                                c4f[0] *= (ambient[0] + 0.5 * diffuse[0]);
                                c4f[1] *= (ambient[1] + 0.5 * diffuse[1]);
                                c4f[2] *= (ambient[2] + 0.5 * diffuse[2]);
@@ -2129,7 +2544,7 @@ void R_DrawParticle_TransparentCallback(const entity_render_t *ent, const rtligh
                        // mix in the fog color
                        if (r_refdef.fogenabled)
                        {
-                               fog = FogPoint_World(p->org);
+                               fog = RSurf_FogVertex(p->org);
                                ifog = 1 - fog;
                                c4f[0] = c4f[0] * fog + r_refdef.fogcolor[0] * ifog;
                                c4f[1] = c4f[1] * fog + r_refdef.fogcolor[1] * ifog;
@@ -2144,11 +2559,28 @@ void R_DrawParticle_TransparentCallback(const entity_render_t *ent, const rtligh
 
                size = p->size * cl_particles_size.value;
                tex = &particletexture[p->texnum];
-               switch(particletype[p->typeindex].orientation)
+               switch(p->orientation)
                {
+//             case PARTICLE_INVALID:
                case PARTICLE_BILLBOARD:
-                       VectorScale(r_refdef.view.left, -size, right);
-                       VectorScale(r_refdef.view.up, size, up);
+                       if (p->angle + p->spin)
+                       {
+                               spinrad = (p->angle + p->spin * (spintime - p->delayedspawn)) * (float)(M_PI / 180.0f);
+                               spinsin = sin(spinrad) * size;
+                               spincos = cos(spinrad) * size;
+                               spinm1 = -p->stretch * spincos;
+                               spinm2 = -spinsin;
+                               spinm3 = spinsin;
+                               spinm4 = -p->stretch * spincos;
+                               VectorMAM(spinm1, r_refdef.view.left, spinm2, r_refdef.view.up, right);
+                               VectorMAM(spinm3, r_refdef.view.left, spinm4, r_refdef.view.up, up);
+                       }
+                       else
+                       {
+                               VectorScale(r_refdef.view.left, -size * p->stretch, right);
+                               VectorScale(r_refdef.view.up, size, up);
+                       }
+
                        v3f[ 0] = p->org[0] - right[0] - up[0];
                        v3f[ 1] = p->org[1] - right[1] - up[1];
                        v3f[ 2] = p->org[2] - right[2] - up[2];
@@ -2167,9 +2599,24 @@ void R_DrawParticle_TransparentCallback(const entity_render_t *ent, const rtligh
                        t2f[6] = tex->s2;t2f[7] = tex->t2;
                        break;
                case PARTICLE_ORIENTED_DOUBLESIDED:
-                       VectorVectors(p->vel, right, up);
-                       VectorScale(right, size, right);
-                       VectorScale(up, size, up);
+                       VectorVectors(p->vel, baseright, baseup);
+                       if (p->angle + p->spin)
+                       {
+                               spinrad = (p->angle + p->spin * (spintime - p->delayedspawn)) * (float)(M_PI / 180.0f);
+                               spinsin = sin(spinrad) * size;
+                               spincos = cos(spinrad) * size;
+                               spinm1 = p->stretch * spincos;
+                               spinm2 = -spinsin;
+                               spinm3 = spinsin;
+                               spinm4 = p->stretch * spincos;
+                               VectorMAM(spinm1, baseright, spinm2, baseup, right);
+                               VectorMAM(spinm3, baseright, spinm4, baseup, up);
+                       }
+                       else
+                       {
+                               VectorScale(baseright, size * p->stretch, right);
+                               VectorScale(baseup, size, up);
+                       }
                        v3f[ 0] = p->org[0] - right[0] - up[0];
                        v3f[ 1] = p->org[1] - right[1] - up[1];
                        v3f[ 2] = p->org[2] - right[2] - up[2];
@@ -2188,50 +2635,67 @@ void R_DrawParticle_TransparentCallback(const entity_render_t *ent, const rtligh
                        t2f[6] = tex->s2;t2f[7] = tex->t2;
                        break;
                case PARTICLE_SPARK:
-                       VectorMA(p->org, -0.04, p->vel, v);
-                       VectorMA(p->org, 0.04, p->vel, up2);
+                       len = VectorLength(p->vel);
+                       VectorNormalize2(p->vel, up);
+                       lenfactor = p->stretch * 0.04 * len;
+                       if(lenfactor < size * 0.5)
+                               lenfactor = size * 0.5;
+                       VectorMA(p->org, -lenfactor, up, v);
+                       VectorMA(p->org,  lenfactor, up, up2);
                        R_CalcBeam_Vertex3f(v3f, v, up2, size);
                        t2f[0] = tex->s1;t2f[1] = tex->t2;
                        t2f[2] = tex->s1;t2f[3] = tex->t1;
                        t2f[4] = tex->s2;t2f[5] = tex->t1;
                        t2f[6] = tex->s2;t2f[7] = tex->t2;
                        break;
-               case PARTICLE_BEAM:
+               case PARTICLE_VBEAM:
                        R_CalcBeam_Vertex3f(v3f, p->org, p->vel, size);
                        VectorSubtract(p->vel, p->org, up);
                        VectorNormalize(up);
-                       v[0] = DotProduct(p->org, up) * (1.0f / 64.0f);
-                       v[1] = DotProduct(p->vel, up) * (1.0f / 64.0f);
-                       t2f[0] = 1;t2f[1] = v[0];
-                       t2f[2] = 0;t2f[3] = v[0];
-                       t2f[4] = 0;t2f[5] = v[1];
-                       t2f[6] = 1;t2f[7] = v[1];
+                       v[0] = DotProduct(p->org, up) * (1.0f / 64.0f) * p->stretch;
+                       v[1] = DotProduct(p->vel, up) * (1.0f / 64.0f) * p->stretch;
+                       t2f[0] = tex->s2;t2f[1] = v[0];
+                       t2f[2] = tex->s1;t2f[3] = v[0];
+                       t2f[4] = tex->s1;t2f[5] = v[1];
+                       t2f[6] = tex->s2;t2f[7] = v[1];
+                       break;
+               case PARTICLE_HBEAM:
+                       R_CalcBeam_Vertex3f(v3f, p->org, p->vel, size);
+                       VectorSubtract(p->vel, p->org, up);
+                       VectorNormalize(up);
+                       v[0] = DotProduct(p->org, up) * (1.0f / 64.0f) * p->stretch;
+                       v[1] = DotProduct(p->vel, up) * (1.0f / 64.0f) * p->stretch;
+                       t2f[0] = v[0];t2f[1] = tex->t1;
+                       t2f[2] = v[0];t2f[3] = tex->t2;
+                       t2f[4] = v[1];t2f[5] = tex->t2;
+                       t2f[6] = v[1];t2f[7] = tex->t1;
                        break;
                }
        }
 
        // now render batches of particles based on blendmode and texture
-       blendmode = -1;
+       blendmode = PBLEND_INVALID;
        texture = NULL;
-       GL_LockArrays(0, numsurfaces*4);
        batchstart = 0;
        batchcount = 0;
+       R_Mesh_PrepareVertices_Generic_Arrays(numsurfaces * 4, particle_vertex3f, particle_color4f, particle_texcoord2f);
        for (surfacelistindex = 0;surfacelistindex < numsurfaces;)
        {
                p = cl.particles + surfacelist[surfacelistindex];
 
-               if (blendmode != particletype[p->typeindex].blendmode)
+               if (blendmode != p->blendmode)
                {
-                       blendmode = particletype[p->typeindex].blendmode;
+                       blendmode = (pblend_t)p->blendmode;
                        switch(blendmode)
                        {
                        case PBLEND_ALPHA:
                                GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                                break;
+                       case PBLEND_INVALID:
                        case PBLEND_ADD:
                                GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
                                break;
-                       case PBLEND_MOD:
+                       case PBLEND_INVMOD:
                                GL_BlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
                                break;
                        }
@@ -2239,7 +2703,7 @@ void R_DrawParticle_TransparentCallback(const entity_render_t *ent, const rtligh
                if (texture != particletexture[p->texnum].texture)
                {
                        texture = particletexture[p->texnum].texture;
-                       R_Mesh_TexBind(0, R_GetTexture(texture));
+                       R_SetupShader_Generic(texture, NULL, GL_MODULATE, 1);
                }
 
                // iterate until we find a change in settings
@@ -2247,42 +2711,39 @@ void R_DrawParticle_TransparentCallback(const entity_render_t *ent, const rtligh
                for (;surfacelistindex < numsurfaces;surfacelistindex++)
                {
                        p = cl.particles + surfacelist[surfacelistindex];
-                       if (blendmode != particletype[p->typeindex].blendmode || texture != particletexture[p->texnum].texture)
+                       if (blendmode != p->blendmode || texture != particletexture[p->texnum].texture)
                                break;
                }
 
                batchcount = surfacelistindex - batchstart;
-               R_Mesh_Draw(batchstart * 4, batchcount * 4, batchcount * 2, particle_element3i + batchstart * 6, 0, 0);
+               R_Mesh_Draw(batchstart * 4, batchcount * 4, batchstart * 2, batchcount * 2, NULL, NULL, 0, particle_elements, NULL, 0);
        }
-       GL_LockArrays(0, 0);
 }
 
 void R_DrawParticles (void)
 {
-       int i, a, content;
-       float minparticledist;
+       int i, a;
+       int drawparticles = r_drawparticles.integer;
+       float minparticledist_start;
        particle_t *p;
-       float gravity, dvel, decalfade, frametime, f, dist, oldorg[3];
-       float drawdist2 = r_drawparticles_drawdistance.value * r_drawparticles_drawdistance.value;
+       float gravity, frametime, f, dist, oldorg[3];
+       float drawdist2;
        int hitent;
        trace_t trace;
        qboolean update;
-       // used as if (i & qualitymask) to skip some less important particles
-       // according to cl_minfps
-       int qualitymask = (1 << r_refdef.view.qualityreduction) - 1;
 
        frametime = bound(0, cl.time - cl.particles_updatetime, 1);
-       cl.particles_updatetime += frametime;
+       cl.particles_updatetime = bound(cl.time - 1, cl.particles_updatetime + frametime, cl.time + 1);
 
        // LordHavoc: early out conditions
-       if ((!cl.num_particles) || (!r_drawparticles.integer))
+       if (!cl.num_particles)
                return;
 
-       minparticledist = DotProduct(r_refdef.view.origin, r_refdef.view.forward) + 4.0f;
+       minparticledist_start = DotProduct(r_refdef.view.origin, r_refdef.view.forward) + r_drawparticles_nearclip_min.value;
        gravity = frametime * cl.movevars_gravity;
-       dvel = 1+4*frametime;
-       decalfade = frametime * 255 / cl_decals_fadetime.value;
        update = frametime > 0;
+       drawdist2 = r_drawparticles_drawdistance.value * r_refdef.view.quality;
+       drawdist2 = drawdist2*drawdist2;
 
        for (i = 0, p = cl.particles;i < cl.num_particles;i++, p++)
        {
@@ -2297,9 +2758,6 @@ void R_DrawParticles (void)
                {
                        if (p->delayedspawn > cl.time)
                                continue;
-                       p->delayedspawn = 0;
-
-                       content = 0;
 
                        p->size += p->sizeincrease * frametime;
                        p->alpha -= p->alphafade * frametime;
@@ -2307,9 +2765,9 @@ void R_DrawParticles (void)
                        if (p->alpha <= 0 || p->die <= cl.time)
                                goto killparticle;
 
-                       if (particletype[p->typeindex].orientation != PARTICLE_BEAM && frametime > 0)
+                       if (p->orientation != PARTICLE_VBEAM && p->orientation != PARTICLE_HBEAM && frametime > 0)
                        {
-                               if (p->liquidfriction && (CL_PointSuperContents(p->org) & SUPERCONTENTS_LIQUIDSMASK))
+                               if (p->liquidfriction && cl_particles_collisions.integer && (CL_PointSuperContents(p->org) & SUPERCONTENTS_LIQUIDSMASK))
                                {
                                        if (p->typeindex == pt_blood)
                                                p->size += frametime * 8;
@@ -2330,9 +2788,10 @@ void R_DrawParticles (void)
 
                                VectorCopy(p->org, oldorg);
                                VectorMA(p->org, frametime, p->vel, p->org);
-                               if (p->bounce && cl.time >= p->delayedcollisions)
+//                             if (p->bounce && cl.time >= p->delayedcollisions)
+                               if (p->bounce && cl_particles_collisions.integer && VectorLength(p->vel))
                                {
-                                       trace = CL_Move(oldorg, vec3_origin, vec3_origin, p->org, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | ((p->typeindex == pt_rain || p->typeindex == pt_snow) ? SUPERCONTENTS_LIQUIDSMASK : 0), true, false, &hitent, false);
+                                       trace = CL_TraceLine(oldorg, p->org, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | ((p->typeindex == pt_rain || p->typeindex == pt_snow) ? SUPERCONTENTS_LIQUIDSMASK : 0), true, false, &hitent, false);
                                        // if the trace started in or hit something of SUPERCONTENTS_NODROP
                                        // or if the trace hit something flagged as NOIMPACT
                                        // then remove the particle
@@ -2343,17 +2802,37 @@ void R_DrawParticles (void)
                                        if (trace.fraction < 1)
                                        {
                                                VectorCopy(trace.endpos, p->org);
+
+                                               if (p->staintexnum >= 0)
+                                               {
+                                                       // blood - splash on solid
+                                                       if (!(trace.hitq3surfaceflags & Q3SURFACEFLAG_NOMARKS))
+                                                       {
+                                                               R_Stain(p->org, 16,
+                                                                       p->staincolor[0], p->staincolor[1], p->staincolor[2], (int)(p->stainalpha * p->stainsize * (1.0f / 160.0f)),
+                                                                       p->staincolor[0], p->staincolor[1], p->staincolor[2], (int)(p->stainalpha * p->stainsize * (1.0f / 160.0f)));
+                                                               if (cl_decals.integer)
+                                                               {
+                                                                       // create a decal for the blood splat
+                                                                       a = 0xFFFFFF ^ (p->staincolor[0]*65536+p->staincolor[1]*256+p->staincolor[2]);
+                                                                       CL_SpawnDecalParticleForSurface(hitent, p->org, trace.plane.normal, a, a, p->staintexnum, p->stainsize, p->stainalpha); // staincolor needs to be inverted for decals!
+                                                               }
+                                                       }
+                                               }
+
                                                if (p->typeindex == pt_blood)
                                                {
                                                        // blood - splash on solid
                                                        if (trace.hitq3surfaceflags & Q3SURFACEFLAG_NOMARKS)
                                                                goto killparticle;
-                                                       if (cl_stainmaps.integer)
-                                                               R_Stain(p->org, 32, 32, 16, 16, (int)(p->alpha * p->size * (1.0f / 40.0f)), 192, 48, 48, (int)(p->alpha * p->size * (1.0f / 40.0f)));
-                                                       if (cl_decals.integer)
+                                                       if(p->staintexnum == -1) // staintex < -1 means no stains at all
                                                        {
-                                                               // create a decal for the blood splat
-                                                               CL_SpawnDecalParticleForSurface(hitent, p->org, trace.plane.normal, p->color[0] * 65536 + p->color[1] * 256 + p->color[2], p->color[0] * 65536 + p->color[1] * 256 + p->color[2], tex_blooddecal[rand()&7], p->size * 2, p->alpha);
+                                                               R_Stain(p->org, 16, 64, 16, 16, (int)(p->alpha * p->size * (1.0f / 80.0f)), 64, 32, 32, (int)(p->alpha * p->size * (1.0f / 80.0f)));
+                                                               if (cl_decals.integer)
+                                                               {
+                                                                       // create a decal for the blood splat
+                                                                       CL_SpawnDecalParticleForSurface(hitent, p->org, trace.plane.normal, p->color[0] * 65536 + p->color[1] * 256 + p->color[2], p->color[0] * 65536 + p->color[1] * 256 + p->color[2], tex_blooddecal[rand()&7], p->size * lhrandom(cl_particles_blood_decal_scalemin.value, cl_particles_blood_decal_scalemax.value), cl_particles_blood_decal_alpha.value * 768);
+                                                               }
                                                        }
                                                        goto killparticle;
                                                }
@@ -2367,11 +2846,16 @@ void R_DrawParticles (void)
                                                        // anything else - bounce off solid
                                                        dist = DotProduct(p->vel, trace.plane.normal) * -p->bounce;
                                                        VectorMA(p->vel, dist, trace.plane.normal, p->vel);
-                                                       if (DotProduct(p->vel, p->vel) < 0.03)
-                                                               VectorClear(p->vel);
                                                }
                                        }
                                }
+
+                               if (VectorLength2(p->vel) < 0.03)
+                               {
+                                       if(p->orientation == PARTICLE_SPARK) // sparks are virtually invisible if very slow, so rather let them go off
+                                               goto killparticle;
+                                       VectorClear(p->vel);
+                               }
                        }
 
                        if (p->typeindex != pt_static)
@@ -2417,13 +2901,10 @@ void R_DrawParticles (void)
                                }
                        }
                }
-               else if (p->delayedspawn)
+               else if (p->delayedspawn > cl.time)
                        continue;
-
-               // skip some of the less important particles according to cl_minfps
-               if ((i & qualitymask) && p->qualityreduction)
+               if (!drawparticles)
                        continue;
-
                // don't render particles too close to the view (they chew fillrate)
                // also don't render particles behind the view (useless)
                // further checks to cull to the frustum would be too slow here
@@ -2431,12 +2912,21 @@ void R_DrawParticles (void)
                {
                case pt_beam:
                        // beams have no culling
-                       R_MeshQueue_AddTransparent(p->org, R_DrawParticle_TransparentCallback, NULL, i, NULL);
+                       R_MeshQueue_AddTransparent(p->sortorigin, R_DrawParticle_TransparentCallback, NULL, i, NULL);
                        break;
                default:
+                       if(cl_particles_visculling.integer)
+                               if (!r_refdef.viewcache.world_novis)
+                                       if(r_refdef.scene.worldmodel && r_refdef.scene.worldmodel->brush.PointInLeaf)
+                                       {
+                                               mleaf_t *leaf = r_refdef.scene.worldmodel->brush.PointInLeaf(r_refdef.scene.worldmodel, p->org);
+                                               if(leaf)
+                                                       if(!CHECKPVSBIT(r_refdef.viewcache.world_pvsbits, leaf->clusterindex))
+                                                               continue;
+                                       }
                        // anything else just has to be in front of the viewer and visible at this distance
-                       if (DotProduct(p->org, r_refdef.view.forward) >= minparticledist && VectorDistance2(p->org, r_refdef.view.origin) < drawdist2 * (p->size * p->size))
-                               R_MeshQueue_AddTransparent(p->org, R_DrawParticle_TransparentCallback, NULL, i, NULL);
+                       if (DotProduct(p->org, r_refdef.view.forward) >= minparticledist_start && VectorDistance2(p->org, r_refdef.view.origin) < drawdist2 * (p->size * p->size))
+                               R_MeshQueue_AddTransparent(p->sortorigin, R_DrawParticle_TransparentCallback, NULL, i, NULL);
                        break;
                }
 
@@ -2451,10 +2941,10 @@ killparticle:
        while (cl.num_particles > 0 && cl.particles[cl.num_particles - 1].typeindex == 0)
                cl.num_particles--;
 
-       if (cl.num_particles == cl.max_particles && cl.max_particles < ABSOLUTE_MAX_PARTICLES)
+       if (cl.num_particles == cl.max_particles && cl.max_particles < MAX_PARTICLES)
        {
                particle_t *oldparticles = cl.particles;
-               cl.max_particles = min(cl.max_particles * 2, ABSOLUTE_MAX_PARTICLES);
+               cl.max_particles = min(cl.max_particles * 2, MAX_PARTICLES);
                cl.particles = (particle_t *) Mem_Alloc(cls.levelmempool, cl.max_particles * sizeof(particle_t));
                memcpy(cl.particles, oldparticles, cl.num_particles * sizeof(particle_t));
                Mem_Free(oldparticles);