siextern float r_avertexnormals[NUMVERTEXNORMALS][3];
#define m_bytenormals r_avertexnormals
#define VectorNormalizeFast VectorNormalize
-#define CL_PointContents(v) (Mod_PointInLeaf(v,cl.worldmodel)->contents)
+#define CL_PointQ1Contents(v) (Mod_PointInLeaf(v,cl.worldmodel)->contents)
typedef unsigned char qbyte;
#define cl_stainmaps.integer 0
void R_Stain (vec3_t origin, float radius, int cr1, int cg1, int cb1, int ca1, int cr2, int cg2, int cb2, int ca2)
#define CL_BlobExplosion R_BlobExplosion
#define CL_RunParticleEffect R_RunParticleEffect
#define CL_LavaSplash R_LavaSplash
-#define CL_RocketTrail2 R_RocketTrail2
void R_CalcBeam_Vertex3f (float *vert, vec3_t org1, vec3_t org2, float width)
{
vec3_t right1, right2, diff, normal;
VectorNormalizeFast (normal);
// calculate 'right' vector for start
- VectorSubtract (r_origin, org1, diff);
+ VectorSubtract (r_vieworigin, org1, diff);
VectorNormalizeFast (diff);
CrossProduct (normal, diff, right1);
// calculate 'right' vector for end
- VectorSubtract (r_origin, org2, diff);
+ VectorSubtract (r_vieworigin, org2, diff);
VectorNormalizeFast (diff);
CrossProduct (normal, diff, right2);
#include "pmove.h"
extern qboolean PM_RecursiveHullCheck (hull_t *hull, int num, float p1f, float p2f, vec3_t p1, vec3_t p2, pmtrace_t *trace);
#endif
-float CL_TraceLine (vec3_t start, vec3_t end, vec3_t impact, vec3_t normal, int contents, int hitbmodels, void **hitent)
+float CL_TraceLine (vec3_t start, vec3_t end, vec3_t impact, vec3_t normal, int hitbmodels, void **hitent, int hitsupercontentsmask)
{
#if QW
pmtrace_t trace;
trace.fraction = 1;
VectorCopy (end, trace.endpos);
#if QW
- PM_RecursiveHullCheck (cl.model_precache[1]->brushq1.hulls, 0, 0, 1, start, end, &trace);
+ PM_RecursiveHullCheck (cl.model_precache[1]->hulls, 0, 0, 1, start, end, &trace);
#else
- RecursiveHullCheck (cl.worldmodel->brushq1.hulls, 0, 0, 1, start, end, &trace);
+ RecursiveHullCheck (cl.worldmodel->hulls, 0, 0, 1, start, end, &trace);
#endif
VectorCopy(trace.endpos, impact);
VectorCopy(trace.plane.normal, normal);
}
#else
#include "cl_collision.h"
+#include "image.h"
#endif
#define MAX_PARTICLES 32768 // default max # of particles at one time
typedef enum
{
- pt_static, pt_rain, pt_bubble, pt_blood, pt_grow, pt_decal
+ pt_dead, pt_static, pt_rain, pt_bubble, pt_blood, pt_grow, pt_decal, pt_decalfade, pt_ember
}
ptype_t;
-#define PARTICLE_INVALID 0
-#define PARTICLE_BILLBOARD 1
-#define PARTICLE_SPARK 2
-#define PARTICLE_ORIENTED_DOUBLESIDED 3
-#define PARTICLE_BEAM 4
+typedef enum
+{
+ PARTICLE_BILLBOARD = 0,
+ PARTICLE_SPARK = 1,
+ PARTICLE_ORIENTED_DOUBLESIDED = 2,
+ PARTICLE_BEAM = 3
+}
+porientation_t;
-#define PBLEND_ALPHA 0
-#define PBLEND_ADD 1
-#define PBLEND_MOD 2
+typedef enum
+{
+ PBLEND_ALPHA = 0,
+ PBLEND_ADD = 1,
+ PBLEND_MOD = 2
+}
+pblend_t;
typedef struct particle_s
{
// texture numbers in particle font
static const int tex_smoke[8] = {0, 1, 2, 3, 4, 5, 6, 7};
-static const int tex_rainsplash[16] = {8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23};
-static const int tex_particle = 24;
-static const int tex_raindrop = 25;
-static const int tex_bubble = 26;
-static const int tex_beam = 27;
-static const int tex_blooddecal[8] = {32, 33, 34, 35, 36, 37, 38, 39};
+static const int tex_bulletdecal[8] = {8, 9, 10, 11, 12, 13, 14, 15};
+static const int tex_blooddecal[8] = {16, 17, 18, 19, 20, 21, 22, 23};
+static const int tex_bloodparticle[8] = {24, 25, 26, 27, 28, 29, 30, 31};
+static const int tex_rainsplash[16] = {32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47};
+static const int tex_particle = 63;
+static const int tex_bubble = 62;
+static const int tex_raindrop = 61;
+static const int tex_beam = 60;
static int cl_maxparticles;
static int cl_numparticles;
+static int cl_freeparticle;
static particle_t *particles;
-static particle_t **freeparticles; // list used only in compacting particles array
cvar_t cl_particles = {CVAR_SAVE, "cl_particles", "1"};
+cvar_t cl_particles_quality = {CVAR_SAVE, "cl_particles_quality", "1"};
cvar_t cl_particles_size = {CVAR_SAVE, "cl_particles_size", "1"};
cvar_t cl_particles_bloodshowers = {CVAR_SAVE, "cl_particles_bloodshowers", "1"};
cvar_t cl_particles_blood = {CVAR_SAVE, "cl_particles_blood", "1"};
-cvar_t cl_particles_blood_size = {CVAR_SAVE, "cl_particles_blood_size", "8"};
cvar_t cl_particles_blood_alpha = {CVAR_SAVE, "cl_particles_blood_alpha", "0.5"};
+cvar_t cl_particles_blood_bloodhack = {CVAR_SAVE, "cl_particles_blood_bloodhack", "1"};
cvar_t cl_particles_bulletimpacts = {CVAR_SAVE, "cl_particles_bulletimpacts", "1"};
+cvar_t cl_particles_explosions_bubbles = {CVAR_SAVE, "cl_particles_explosions_bubbles", "1"};
+cvar_t cl_particles_explosions_smoke = {CVAR_SAVE, "cl_particles_explosions_smokes", "0"};
+cvar_t cl_particles_explosions_sparks = {CVAR_SAVE, "cl_particles_explosions_sparks", "1"};
+cvar_t cl_particles_explosions_shell = {CVAR_SAVE, "cl_particles_explosions_shell", "0"};
cvar_t cl_particles_smoke = {CVAR_SAVE, "cl_particles_smoke", "1"};
-cvar_t cl_particles_smoke_size = {CVAR_SAVE, "cl_particles_smoke_size", "7"};
cvar_t cl_particles_smoke_alpha = {CVAR_SAVE, "cl_particles_smoke_alpha", "0.5"};
cvar_t cl_particles_smoke_alphafade = {CVAR_SAVE, "cl_particles_smoke_alphafade", "0.55"};
cvar_t cl_particles_sparks = {CVAR_SAVE, "cl_particles_sparks", "1"};
void CL_Particles_Clear(void)
{
cl_numparticles = 0;
+ cl_freeparticle = 0;
+ memset(particles, 0, sizeof(particle_t) * cl_maxparticles);
}
/*
{
int i;
+// COMMANDLINEOPTION: -particles <number> changes maximum number of particles at once, default 32768
i = COM_CheckParm ("-particles");
if (i && i < com_argc - 1)
Cmd_AddCommand ("pointfile", CL_ReadPointFile_f);
Cvar_RegisterVariable (&cl_particles);
+ Cvar_RegisterVariable (&cl_particles_quality);
Cvar_RegisterVariable (&cl_particles_size);
Cvar_RegisterVariable (&cl_particles_bloodshowers);
Cvar_RegisterVariable (&cl_particles_blood);
- Cvar_RegisterVariable (&cl_particles_blood_size);
Cvar_RegisterVariable (&cl_particles_blood_alpha);
+ Cvar_RegisterVariable (&cl_particles_blood_bloodhack);
+ Cvar_RegisterVariable (&cl_particles_explosions_bubbles);
+ Cvar_RegisterVariable (&cl_particles_explosions_smoke);
+ Cvar_RegisterVariable (&cl_particles_explosions_sparks);
+ Cvar_RegisterVariable (&cl_particles_explosions_shell);
Cvar_RegisterVariable (&cl_particles_bulletimpacts);
Cvar_RegisterVariable (&cl_particles_smoke);
- Cvar_RegisterVariable (&cl_particles_smoke_size);
Cvar_RegisterVariable (&cl_particles_smoke_alpha);
Cvar_RegisterVariable (&cl_particles_smoke_alphafade);
Cvar_RegisterVariable (&cl_particles_sparks);
#ifdef WORKINGLQUAKE
particles = (particle_t *) Hunk_AllocName(cl_maxparticles * sizeof(particle_t), "particles");
- freeparticles = (void *) Hunk_AllocName(cl_maxparticles * sizeof(particle_t *), "particles");
#else
- cl_part_mempool = Mem_AllocPool("CL_Part");
+ cl_part_mempool = Mem_AllocPool("CL_Part", 0, NULL);
particles = (particle_t *) Mem_Alloc(cl_part_mempool, cl_maxparticles * sizeof(particle_t));
- freeparticles = (void *) Mem_Alloc(cl_part_mempool, cl_maxparticles * sizeof(particle_t *));
#endif
- cl_numparticles = 0;
+ CL_Particles_Clear();
}
-#define particle(ptype, porientation, pcolor1, pcolor2, ptex, plight, pblendmode, pscalex, pscaley, palpha, palphafade, ptime, pgravity, pbounce, px, py, pz, pvx, pvy, pvz, ptime2, pvx2, pvy2, pvz2, pfriction, ppressure)\
-{\
- if (cl_numparticles < cl_maxparticles)\
- {\
- particle_t *part;\
- int ptempcolor, ptempcolor2, pcr1, pcg1, pcb1, pcr2, pcg2, pcb2;\
- ptempcolor = (pcolor1);\
- ptempcolor2 = (pcolor2);\
- pcr2 = ((ptempcolor2) >> 16) & 0xFF;\
- pcg2 = ((ptempcolor2) >> 8) & 0xFF;\
- pcb2 = (ptempcolor2) & 0xFF;\
- if (ptempcolor != ptempcolor2)\
- {\
- pcr1 = ((ptempcolor) >> 16) & 0xFF;\
- pcg1 = ((ptempcolor) >> 8) & 0xFF;\
- pcb1 = (ptempcolor) & 0xFF;\
- ptempcolor = rand() & 0xFF;\
- pcr2 = (((pcr2 - pcr1) * ptempcolor) >> 8) + pcr1;\
- pcg2 = (((pcg2 - pcg1) * ptempcolor) >> 8) + pcg1;\
- pcb2 = (((pcb2 - pcb1) * ptempcolor) >> 8) + pcb1;\
- }\
- part = &particles[cl_numparticles++];\
- memset(part, 0, sizeof(*part));\
- part->type = (ptype);\
- part->color[0] = pcr2;\
- part->color[1] = pcg2;\
- part->color[2] = pcb2;\
- part->color[3] = 0xFF;\
- part->orientation = porientation;\
- part->texnum = ptex;\
- part->blendmode = pblendmode;\
- part->scalex = (pscalex);\
- part->scaley = (pscaley);\
- part->alpha = (palpha);\
- part->alphafade = (palphafade);\
- part->die = cl.time + (ptime);\
- part->gravity = (pgravity);\
- part->bounce = (pbounce);\
- part->org[0] = (px);\
- part->org[1] = (py);\
- part->org[2] = (pz);\
- part->vel[0] = (pvx);\
- part->vel[1] = (pvy);\
- part->vel[2] = (pvz);\
- part->time2 = (ptime2);\
- part->vel2[0] = (pvx2);\
- part->vel2[1] = (pvy2);\
- part->vel2[2] = (pvz2);\
- part->friction = (pfriction);\
- part->pressure = (ppressure);\
- }\
+// 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
+// porientation - PARTICLE_ enum values (PARTICLE_BILLBOARD, PARTICLE_SPARK, etc)
+// 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
+// plight - no longer used (this used to turn on particle lighting)
+// pblendmode - PBLEND_ enum values (PBLEND_ALPHA, PBLEND_ADD, etc)
+// pscalex,pscaley - width and height of particle (according to orientation), these are normally the same except when making sparks and beams
+// 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)
+// pgravity - how much effect gravity has on the particle (0-1)
+// pbounce - how much bounce the particle has when it hits a surface (0-1), -1 makes a blood splat when it hits a surface, 0 does not even check for collisions
+// px,py,pz - starting origin of particle
+// pvx,pvy,pvz - starting velocity of particle
+// ptime2 - extra time parameter for certain particle types (pt_decal delayed fades and pt_rain snowflutter use this)
+// pvx2,pvy2,pvz2 - for PARTICLE_ORIENTED_DOUBLESIDED this is the surface normal of the orientation (forward vector), pt_rain uses this for snow fluttering
+// pfriction - how much the particle slows down per second (0-1 typically, can slowdown faster than 1)
+// ppressure - pushes other particles away if they are within 64 units distance, the force is based on scalex, this feature is supported but not currently used
+particle_t *particle(ptype_t ptype, porientation_t porientation, int pcolor1, int pcolor2, int ptex, int plight, pblend_t pblendmode, float pscalex, float pscaley, float palpha, float palphafade, float ptime, float pgravity, float pbounce, float px, float py, float pz, float pvx, float pvy, float pvz, float ptime2, float pvx2, float pvy2, float pvz2, float pfriction, float ppressure)
+{
+ particle_t *part;
+ int ptempcolor, ptempcolor2, pcr1, pcg1, pcb1, pcr2, pcg2, pcb2;
+ ptempcolor = (pcolor1);
+ ptempcolor2 = (pcolor2);
+ pcr2 = ((ptempcolor2) >> 16) & 0xFF;
+ pcg2 = ((ptempcolor2) >> 8) & 0xFF;
+ pcb2 = (ptempcolor2) & 0xFF;
+ if (ptempcolor != ptempcolor2)
+ {
+ pcr1 = ((ptempcolor) >> 16) & 0xFF;
+ pcg1 = ((ptempcolor) >> 8) & 0xFF;
+ pcb1 = (ptempcolor) & 0xFF;
+ ptempcolor = rand() & 0xFF;
+ pcr2 = (((pcr2 - pcr1) * ptempcolor) >> 8) + pcr1;
+ pcg2 = (((pcg2 - pcg1) * ptempcolor) >> 8) + pcg1;
+ pcb2 = (((pcb2 - pcb1) * ptempcolor) >> 8) + pcb1;
+ }
+ for (;cl_freeparticle < cl_maxparticles && particles[cl_freeparticle].type;cl_freeparticle++);
+ if (cl_freeparticle >= cl_maxparticles)
+ return NULL;
+ part = &particles[cl_freeparticle++];
+ if (cl_numparticles < cl_freeparticle)
+ cl_numparticles = cl_freeparticle;
+ memset(part, 0, sizeof(*part));
+ part->type = (ptype);
+ part->color[0] = pcr2;
+ part->color[1] = pcg2;
+ part->color[2] = pcb2;
+ part->color[3] = 0xFF;
+ part->orientation = porientation;
+ part->texnum = ptex;
+ part->blendmode = pblendmode;
+ part->scalex = (pscalex);
+ part->scaley = (pscaley);
+ part->alpha = (palpha);
+ part->alphafade = (palphafade);
+ part->die = cl.time + (ptime);
+ part->gravity = (pgravity);
+ part->bounce = (pbounce);
+ part->org[0] = (px);
+ part->org[1] = (py);
+ part->org[2] = (pz);
+ part->vel[0] = (pvx);
+ part->vel[1] = (pvy);
+ part->vel[2] = (pvz);
+ part->time2 = (ptime2);
+ part->vel2[0] = (pvx2);
+ part->vel2[1] = (pvy2);
+ part->vel2[2] = (pvz2);
+ part->friction = (pfriction);
+ part->pressure = (ppressure);
+ return part;
+}
+
+void CL_SpawnDecalParticleForSurface(void *hitent, const vec3_t org, const vec3_t normal, int color1, int color2, int texnum, float size, float alpha)
+{
+ particle_t *p;
+ if (!cl_decals.integer)
+ return;
+ p = particle(pt_decal, PARTICLE_ORIENTED_DOUBLESIDED, color1, color2, texnum, false, PBLEND_MOD, size, size, alpha, 0, cl_decals_time.value + cl_decals_fadetime.value, 0, 0, org[0] + normal[0], org[1] + normal[1], org[2] + normal[2], 0, 0, 0, cl.time + cl_decals_time.value, normal[0], normal[1], normal[2], 0, 0);
+#ifndef WORKINGLQUAKE
+ if (p)
+ {
+ p->owner = hitent;
+ p->ownermodel = p->owner->model;
+ Matrix4x4_Transform(&p->owner->inversematrix, org, p->relativeorigin);
+ Matrix4x4_Transform3x3(&p->owner->inversematrix, normal, p->relativedirection);
+ VectorAdd(p->relativeorigin, p->relativedirection, p->relativeorigin);
+ }
+#endif
+}
+
+void CL_SpawnDecalParticleForPoint(const vec3_t org, float maxdist, float size, float alpha, int texnum, int color1, int color2)
+{
+ int i;
+ float bestfrac, bestorg[3], bestnormal[3];
+ float frac, v[3], normal[3], org2[3];
+#ifdef WORKINGLQUAKE
+ void *besthitent = NULL, *hitent;
+#else
+ entity_render_t *besthitent = NULL, *hitent;
+#endif
+ bestfrac = 10;
+ for (i = 0;i < 32;i++)
+ {
+ VectorRandom(org2);
+ VectorMA(org, maxdist, org2, org2);
+ frac = CL_TraceLine(org, org2, v, normal, true, &hitent, SUPERCONTENTS_SOLID);
+ if (bestfrac > frac)
+ {
+ bestfrac = frac;
+ besthitent = hitent;
+ VectorCopy(v, bestorg);
+ VectorCopy(normal, bestnormal);
+ }
+ }
+ if (bestfrac < 1)
+ CL_SpawnDecalParticleForSurface(besthitent, bestorg, bestnormal, color1, color2, texnum, size, alpha);
}
/*
if (!cl.worldmodel)
return;
- FS_StripExtension(cl.worldmodel->name, name);
- strcat(name, ".pts");
+ FS_StripExtension (cl.worldmodel->name, name, sizeof (name));
+ strlcat (name, ".pts", sizeof (name));
#if WORKINGLQUAKE
pointfile = COM_LoadTempFile (name);
#else
- pointfile = FS_LoadFile(name, true);
+ pointfile = FS_LoadFile(name, tempmempool, true);
#endif
if (!pointfile)
{
- Con_Printf ("Could not open %s\n", name);
+ Con_Printf("Could not open %s\n", name);
return;
}
- Con_Printf ("Reading %s...\n", name);
+ Con_Printf("Reading %s...\n", name);
c = 0;
s = 0;
pointfilepos = pointfile;
Mem_Free(pointfile);
#endif
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]);
+ Con_Printf("%i points read (%i particles spawned)\nLeak at %f %f %f\n", c, s, org[0], org[1], org[2]);
particle(pt_static, PARTICLE_BEAM, 0xFF0000, 0xFF0000, tex_beam, false, PBLEND_ALPHA, 64, 64, 255, 0, 99999, 0, 0, org[0] - 4096, org[1], org[2], 0, 0, 0, 0, org[0] + 4096, org[1], org[2], 0, 0);
particle(pt_static, PARTICLE_BEAM, 0x00FF00, 0x00FF00, tex_beam, false, PBLEND_ALPHA, 64, 64, 255, 0, 99999, 0, 0, org[0], org[1] - 4096, org[2], 0, 0, 0, 0, org[0], org[1] + 4096, org[2], 0, 0);
vec3_t org, dir;
int i, count, msgcount, color;
- for (i=0 ; i<3 ; i++)
- org[i] = MSG_ReadCoord ();
+ MSG_ReadVector(org, cl.protocol);
for (i=0 ; i<3 ; i++)
dir[i] = MSG_ReadChar () * (1.0/16);
msgcount = MSG_ReadByte ();
else
count = msgcount;
+ if (cl_particles_blood_bloodhack.integer)
+ {
+ if (color == 73)
+ {
+ // regular blood
+ CL_BloodPuff(org, dir, count / 2);
+ return;
+ }
+ if (color == 225)
+ {
+ // lightning blood
+ CL_BloodPuff(org, dir, count / 2);
+ return;
+ }
+ }
CL_RunParticleEffect (org, dir, color, count);
}
*/
void CL_ParticleExplosion (vec3_t org)
{
- int i, k;
+ int i;
//vec3_t v;
//vec3_t v2;
if (cl_stainmaps.integer)
R_Stain(org, 96, 80, 80, 80, 64, 176, 176, 176, 64);
+ CL_SpawnDecalParticleForPoint(org, 40, 48, 255, tex_bulletdecal[rand()&7], 0xFFFFFF, 0xFFFFFF);
- i = CL_PointContents(org);
- if ((i == CONTENTS_SLIME || i == CONTENTS_WATER) && cl_particles.integer && cl_particles_bubbles.integer)
+ i = CL_PointQ1Contents(org);
+ if (i == CONTENTS_SLIME || i == CONTENTS_WATER)
{
- for (i = 0;i < 128;i++)
- {
- particle(pt_bubble, PARTICLE_BILLBOARD, 0x404040, 0x808080, tex_bubble, false, PBLEND_ADD, 2, 2, lhrandom(128, 255), 256, 9999, -0.25, 1.5, org[0] + lhrandom(-16, 16), org[1] + lhrandom(-16, 16), org[2] + lhrandom(-16, 16), lhrandom(-96, 96), lhrandom(-96, 96), lhrandom(-96, 96), 0, 0, 0, 0, (1.0 / 16.0), 0);
- }
+ if (cl_particles.integer && cl_particles_bubbles.integer && cl_particles_explosions_bubbles.integer)
+ for (i = 0;i < 128 * cl_particles_quality.value;i++)
+ particle(pt_bubble, PARTICLE_BILLBOARD, 0x404040, 0x808080, tex_bubble, false, PBLEND_ADD, 2, 2, (1.0f / cl_particles_quality.value) * lhrandom(128, 255), (1.0f / cl_particles_quality.value) * 256, 9999, -0.25, 1.5, org[0] + lhrandom(-16, 16), org[1] + lhrandom(-16, 16), org[2] + lhrandom(-16, 16), lhrandom(-96, 96), lhrandom(-96, 96), lhrandom(-96, 96), 0, 0, 0, 0, (1.0 / 16.0), 0);
}
else
{
- /*
// LordHavoc: smoke effect similar to UT2003, chews fillrate too badly up close
// smoke puff
- if (cl_particles.integer && cl_particles_smoke.integer)
+ if (cl_particles.integer && cl_particles_smoke.integer && cl_particles_explosions_smoke.integer)
{
- for (i = 0;i < 64;i++)
+ for (i = 0;i < 32;i++)
{
+ int k;
+ vec3_t v, v2;
#ifdef WORKINGLQUAKE
- v2[0] = lhrandom(-64, 64);
- v2[1] = lhrandom(-64, 64);
- v2[2] = lhrandom(-8, 24);
+ v2[0] = lhrandom(-48, 48);
+ v2[1] = lhrandom(-48, 48);
+ v2[2] = lhrandom(-48, 48);
#else
for (k = 0;k < 16;k++)
{
- v[0] = org[0] + lhrandom(-64, 64);
- v[1] = org[1] + lhrandom(-64, 64);
- v[2] = org[2] + lhrandom(-8, 24);
- if (CL_TraceLine(org, v, v2, NULL, 0, true, NULL) >= 0.1)
+ v[0] = org[0] + lhrandom(-48, 48);
+ v[1] = org[1] + lhrandom(-48, 48);
+ v[2] = org[2] + lhrandom(-48, 48);
+ if (CL_TraceLine(org, v, v2, NULL, true, NULL, SUPERCONTENTS_SOLID) >= 0.1)
break;
}
VectorSubtract(v2, org, v2);
#endif
VectorScale(v2, 2.0f, v2);
- particle(pt_static, PARTICLE_BILLBOARD, 0x101010, 0x202020, tex_smoke[rand()&7], true, PBLEND_ADD, 12, 12, 255, 512, 9999, 0, 0, org[0], org[1], org[2], v2[0], v2[1], v2[2], 0, 0, 0, 0, 0, 0);
+ particle(pt_static, PARTICLE_BILLBOARD, 0xFFFFFF, 0xFFFFFF, tex_smoke[rand()&7], true, PBLEND_ADD, 12, 12, 32, 64, 9999, 0, 0, org[0], org[1], org[2], v2[0], v2[1], v2[2], 0, 0, 0, 0, 0, 0);
}
}
- */
- if (cl_particles.integer && cl_particles_sparks.integer)
- {
- // sparks
- for (i = 0;i < 256;i++)
- {
- k = particlepalette[0x68 + (rand() & 7)];
- particle(pt_static, PARTICLE_SPARK, k, k, tex_particle, false, PBLEND_ADD, 1.5f, 0.05f, lhrandom(0, 255), 512, 9999, 1, 0, org[0], org[1], org[2], lhrandom(-192, 192), lhrandom(-192, 192), lhrandom(-192, 192) + 160, 0, 0, 0, 0, 0, 0);
- }
- }
+#if 1
+ if (cl_particles.integer && cl_particles_sparks.integer && cl_particles_explosions_sparks.integer)
+ for (i = 0;i < 128 * cl_particles_quality.value;i++)
+ particle(pt_static, PARTICLE_SPARK, 0x903010, 0xFFD030, tex_particle, false, PBLEND_ADD, 1.0f, 0.02f, (1.0f / cl_particles_quality.value) * lhrandom(0, 255), (1.0f / cl_particles_quality.value) * 512, 9999, 1, 0, org[0], org[1], org[2], lhrandom(-256, 256), lhrandom(-256, 256), lhrandom(-256, 256) + 80, 0, 0, 0, 0, 0.2, 0);
+#elif 1
+ if (cl_particles.integer && cl_particles_sparks.integer && cl_particles_explosions_sparks.integer)
+ for (i = 0;i < 64 * cl_particles_quality.value;i++)
+ particle(pt_ember, PARTICLE_SPARK, 0x903010, 0xFFD030, tex_particle, false, PBLEND_ADD, 1.0f, 0.01f, (1.0f / cl_particles_quality.value) * lhrandom(0, 255), (1.0f / cl_particles_quality.value) * 256, 9999, 0.7, 0, org[0], org[1], org[2], lhrandom(-256, 256), lhrandom(-256, 256), lhrandom(-256, 256) + 80, cl.time, 0, 0, 0, 0, 0);
+#else
+ if (cl_particles.integer && cl_particles_sparks.integer && cl_particles_explosions_sparks.integer)
+ for (i = 0;i < 256 * cl_particles_quality.value;i++)
+ particle(pt_static, PARTICLE_SPARK, 0x903010, 0xFFD030, tex_particle, false, PBLEND_ADD, 1.5f, 0.05f, (1.0f / cl_particles_quality.value) * lhrandom(0, 255), (1.0f / cl_particles_quality.value) * 512, 9999, 1, 0, org[0], org[1], org[2], lhrandom(-192, 192), lhrandom(-192, 192), lhrandom(-192, 192) + 160, 0, 0, 0, 0, 0.2, 0);
+#endif
}
- if (cl_explosions.integer)
+ if (cl_particles_explosions_shell.integer)
R_NewExplosion(org);
}
*/
void CL_ParticleExplosion2 (vec3_t org, int colorStart, int colorLength)
{
+ vec3_t vel;
+ vec3_t offset;
int i, k;
+ float pscale;
if (!cl_particles.integer) return;
- for (i = 0;i < 512;i++)
+ for (i = 0;i < 512 * cl_particles_quality.value;i++)
{
+ VectorRandom (offset);
+ VectorScale (offset, 192, vel);
+ VectorScale (offset, 8, offset);
k = particlepalette[colorStart + (i % colorLength)];
- particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ALPHA, 1.5, 1.5, 255, 384, 0.3, 0, 0, org[0] + lhrandom(-8, 8), org[1] + lhrandom(-8, 8), org[2] + lhrandom(-8, 8), lhrandom(-192, 192), lhrandom(-192, 192), lhrandom(-192, 192), 0, 0, 0, 0, 1, 0);
+ pscale = lhrandom(0.5, 1.5);
+ particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ADD, pscale, pscale, (1.0f / cl_particles_quality.value) * 255, (1.0f/cl_particles_quality.value)*512, 9999, 0, 0, org[0] + offset[0], org[1] + offset[1], org[2] + offset[2], vel[0], vel[1], vel[2], 0, 0, 0, 0, lhrandom(1.5, 3), 0);
}
}
*/
void CL_BlobExplosion (vec3_t org)
{
- if (cl_stainmaps.integer)
- R_Stain(org, 96, 80, 80, 80, 64, 176, 176, 176, 64);
-
- if (cl_explosions.integer)
- R_NewExplosion(org);
+ CL_ParticleExplosion(org);
}
/*
return;
}
if (!cl_particles.integer) return;
+ count *= cl_particles_quality.value;
while (count--)
{
k = particlepalette[color + (rand()&7)];
if (gamemode == GAME_GOODVSBAD2)
- {
- particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ALPHA, 5, 5, 255, 300, 9999, 0, 0, org[0] + lhrandom(-8, 8), org[1] + lhrandom(-8, 8), org[2] + lhrandom(-8, 8), lhrandom(-10, 10), lhrandom(-10, 10), lhrandom(-10, 10), 0, 0, 0, 0, 0, 0);
- }
+ particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ALPHA, 5, 5, (1.0f / cl_particles_quality.value) * 255, (1.0f / cl_particles_quality.value) * 300, 9999, 0, 0, org[0] + lhrandom(-8, 8), org[1] + lhrandom(-8, 8), org[2] + lhrandom(-8, 8), lhrandom(-10, 10), lhrandom(-10, 10), lhrandom(-10, 10), 0, 0, 0, 0, 0, 0);
else
- {
- particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ALPHA, 1, 1, 255, 512, 9999, 0, 0, org[0] + lhrandom(-8, 8), org[1] + lhrandom(-8, 8), org[2] + lhrandom(-8, 8), dir[0] + lhrandom(-15, 15), dir[1] + lhrandom(-15, 15), dir[2] + lhrandom(-15, 15), 0, 0, 0, 0, 0, 0);
- }
+ particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ALPHA, 1, 1, (1.0f / cl_particles_quality.value) * 255, (1.0f / cl_particles_quality.value) * 512, 9999, 0, 0, org[0] + lhrandom(-8, 8), org[1] + lhrandom(-8, 8), org[2] + lhrandom(-8, 8), dir[0] + lhrandom(-15, 15), dir[1] + lhrandom(-15, 15), dir[2] + lhrandom(-15, 15), 0, 0, 0, 0, 0, 0);
}
}
if (cl_stainmaps.integer)
R_Stain(org, 32, 96, 96, 96, 24, 128, 128, 128, 24);
+ CL_SpawnDecalParticleForPoint(org, 6, 3, 255, tex_bulletdecal[rand()&7], 0xFFFFFF, 0xFFFFFF);
if (!cl_particles.integer) return;
// smoke puff
if (cl_particles_smoke.integer)
{
- k = count / 4;
+ k = count * 0.25 * cl_particles_quality.value;
while(k--)
{
org2[0] = org[0] + 0.125f * lhrandom(-count, count);
org2[1] = org[1] + 0.125f * lhrandom(-count, count);
org2[2] = org[2] + 0.125f * lhrandom(-count, count);
- CL_TraceLine(org, org2, org3, NULL, 0, true, NULL);
- particle(pt_grow, PARTICLE_BILLBOARD, 0x101010, 0x202020, tex_smoke[rand()&7], true, PBLEND_ADD, 3, 3, 255, 1024, 9999, -0.2, 0, org3[0], org3[1], org3[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(0, 16), 15, 0, 0, 0, 0, 0);
+ CL_TraceLine(org, org2, org3, NULL, true, NULL, SUPERCONTENTS_SOLID);
+ particle(pt_grow, PARTICLE_BILLBOARD, 0x101010, 0x202020, tex_smoke[rand()&7], true, PBLEND_ADD, 3, 3, (1.0f / cl_particles_quality.value) * 255, (1.0f / cl_particles_quality.value) * 1024, 9999, -0.2, 0, org3[0], org3[1], org3[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(0, 16), 15, 0, 0, 0, 0.2, 0);
}
}
if (cl_particles_sparks.integer)
{
// sparks
+ count *= cl_particles_quality.value;
while(count--)
{
k = particlepalette[0x68 + (rand() & 7)];
- particle(pt_static, PARTICLE_SPARK, k, k, tex_particle, false, PBLEND_ADD, 0.4f, 0.015f, lhrandom(64, 255), 512, 9999, 1, 0, org[0], org[1], org[2], lhrandom(-64, 64) + dir[0], lhrandom(-64, 64) + dir[1], lhrandom(0, 128) + dir[2], 0, 0, 0, 0, 0, 0);
+ particle(pt_static, PARTICLE_SPARK, k, k, tex_particle, false, PBLEND_ADD, 0.4f, 0.015f, (1.0f / cl_particles_quality.value) * lhrandom(64, 255), (1.0f / cl_particles_quality.value) * 512, 9999, 1, 0, org[0], org[1], org[2], lhrandom(-64, 64) + dir[0], lhrandom(-64, 64) + dir[1], lhrandom(0, 128) + dir[2], 0, 0, 0, 0, 0.2, 0);
}
}
}
{
if (cl_stainmaps.integer)
R_Stain(org, 48, 96, 96, 96, 32, 128, 128, 128, 32);
+ CL_SpawnDecalParticleForPoint(org, 6, 6, 255, tex_bulletdecal[rand()&7], 0xFFFFFF, 0xFFFFFF);
}
static float bloodcount = 0;
void CL_BloodPuff (vec3_t org, vec3_t vel, int count)
{
- float s, r, a;
+ float s;
vec3_t org2, org3;
// bloodcount is used to accumulate counts too small to cause a blood particle
if (!cl_particles.integer) return;
if (!cl_particles_blood.integer) return;
- s = count + 32.0f;
+ s = count + 64.0f;
count *= 5.0f;
if (count > 1000)
count = 1000;
bloodcount += count;
- r = cl_particles_blood_size.value;
- a = cl_particles_blood_alpha.value * 255;
while(bloodcount > 0)
{
org2[0] = org[0] + 0.125f * lhrandom(-bloodcount, bloodcount);
org2[1] = org[1] + 0.125f * lhrandom(-bloodcount, bloodcount);
org2[2] = org[2] + 0.125f * lhrandom(-bloodcount, bloodcount);
- CL_TraceLine(org, org2, org3, NULL, 0, true, NULL);
- particle(pt_blood, PARTICLE_BILLBOARD, 0xFFFFFF, 0xFFFFFF, tex_blooddecal[rand()&7], true, PBLEND_MOD, r, r, a * 3, a * 1.5, 9999, 0, -1, org3[0], org3[1], org3[2], vel[0] + lhrandom(-s, s), vel[1] + lhrandom(-s, s), vel[2] + lhrandom(-s, s), 0, 0, 0, 0, 1, 0);
- //particle(pt_blood, PARTICLE_BILLBOARD, 0x000000, 0x200000, tex_smoke[rand()&7], true, PBLEND_ALPHA, r, r, a, a * 0.5, 9999, 0, -1, org3[0], org3[1], org3[2], vel[0] + lhrandom(-s, s), vel[1] + lhrandom(-s, s), vel[2] + lhrandom(-s, s), 0, 0, 0, 0, 1, 0);
- bloodcount -= r;
+ CL_TraceLine(org, org2, org3, NULL, true, NULL, SUPERCONTENTS_SOLID);
+ particle(pt_blood, PARTICLE_BILLBOARD, 0xFFFFFF, 0xFFFFFF, tex_bloodparticle[rand()&7], true, PBLEND_MOD, 8, 8, cl_particles_blood_alpha.value * 768 / cl_particles_quality.value, cl_particles_blood_alpha.value * 384 / cl_particles_quality.value, 9999, 0, -1, org3[0], org3[1], org3[2], vel[0] + lhrandom(-s, s), vel[1] + lhrandom(-s, s), vel[2] + lhrandom(-s, s), 0, 0, 0, 0, 1, 0);
+ bloodcount -= 16 / cl_particles_quality.value;
}
}
void CL_BloodShower (vec3_t mins, vec3_t maxs, float velspeed, int count)
{
- float r;
- float a;
- vec3_t diff, center, velscale;
+ vec3_t org, vel, diff, center, velscale;
if (!cl_particles.integer) return;
if (!cl_particles_bloodshowers.integer) return;
if (!cl_particles_blood.integer) return;
center[0] = (mins[0] + maxs[0]) * 0.5;
center[1] = (mins[1] + maxs[1]) * 0.5;
center[2] = (mins[2] + maxs[2]) * 0.5;
- // FIXME: change velspeed back to 2.0x after fixing mod
velscale[0] = velspeed * 2.0 / diff[0];
velscale[1] = velspeed * 2.0 / diff[1];
velscale[2] = velspeed * 2.0 / diff[2];
bloodcount += count * 5.0f;
- r = cl_particles_blood_size.value;
- a = cl_particles_blood_alpha.value * 255;
while (bloodcount > 0)
{
- vec3_t org, vel;
org[0] = lhrandom(mins[0], maxs[0]);
org[1] = lhrandom(mins[1], maxs[1]);
org[2] = lhrandom(mins[2], maxs[2]);
vel[0] = (org[0] - center[0]) * velscale[0];
vel[1] = (org[1] - center[1]) * velscale[1];
vel[2] = (org[2] - center[2]) * velscale[2];
- bloodcount -= r;
- particle(pt_blood, PARTICLE_BILLBOARD, 0xFFFFFF, 0xFFFFFF, tex_blooddecal[rand()&7], true, PBLEND_MOD, r, r, a * 3, a * 1.5, 9999, 0, -1, org[0], org[1], org[2], vel[0], vel[1], vel[2], 0, 0, 0, 0, 1, 0);
- //particle(pt_blood, PARTICLE_BILLBOARD, 0x000000, 0x200000, tex_smoke[rand()&7], true, PBLEND_ALPHA, r, r, a, a * 0.5, 9999, 0, -1, org[0], org[1], org[2], vel[0], vel[1], vel[2], 0, 0, 0, 0, 1, 0);
+ bloodcount -= 16 / cl_particles_quality.value;
+ particle(pt_blood, PARTICLE_BILLBOARD, 0xFFFFFF, 0xFFFFFF, tex_bloodparticle[rand()&7], true, PBLEND_MOD, 8, 8, cl_particles_blood_alpha.value * 768 / cl_particles_quality.value, cl_particles_blood_alpha.value * 384 / cl_particles_quality.value, 9999, 0, -1, org[0], org[1], org[2], vel[0], vel[1], vel[2], 0, 0, 0, 0, 1, 0);
}
}
if (maxs[1] <= mins[1]) {t = mins[1];mins[1] = maxs[1];maxs[1] = t;}
if (maxs[2] <= mins[2]) {t = mins[2];mins[2] = maxs[2];maxs[2] = t;}
+ count *= cl_particles_quality.value;
while (count--)
{
k = particlepalette[colorbase + (rand()&3)];
- particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ALPHA, 2, 2, 255, 0, lhrandom(1, 2), gravity ? 1 : 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(mins[2], maxs[2]), dir[0] + lhrandom(-randomvel, randomvel), dir[1] + lhrandom(-randomvel, randomvel), dir[2] + lhrandom(-randomvel, randomvel), 0, 0, 0, 0, 0, 0);
+ particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ALPHA, 2, 2, 255 / cl_particles_quality.value, 0, lhrandom(1, 2), gravity ? 1 : 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(mins[2], maxs[2]), dir[0] + lhrandom(-randomvel, randomvel), dir[1] + lhrandom(-randomvel, randomvel), dir[2] + lhrandom(-randomvel, randomvel), 0, 0, 0, 0, 0, 0);
}
}
minz = bound(mins[2], minz, maxs[2]);
maxz = bound(mins[2], maxz, maxs[2]);
+ count *= cl_particles_quality.value;
+
switch(type)
{
case 0:
k = particlepalette[colorbase + (rand()&3)];
if (gamemode == GAME_GOODVSBAD2)
{
- particle(pt_rain, PARTICLE_SPARK, k, k, tex_particle, true, PBLEND_ADD, 20, 20, lhrandom(8, 16), 0, t, 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz), dir[0], dir[1], dir[2], cl.time + 9999, dir[0], dir[1], dir[2], 0, 0);
+ particle(pt_rain, PARTICLE_SPARK, k, k, tex_particle, true, PBLEND_ADD, 20, 20, lhrandom(8, 16) / cl_particles_quality.value, 0, t, 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz), dir[0], dir[1], dir[2], cl.time + 9999, dir[0], dir[1], dir[2], 0, 0);
}
else
{
- particle(pt_rain, PARTICLE_SPARK, k, k, tex_particle, true, PBLEND_ADD, 0.5, 0.02, lhrandom(8, 16), 0, t, 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz), dir[0], dir[1], dir[2], cl.time + 9999, dir[0], dir[1], dir[2], 0, 0);
+ particle(pt_rain, PARTICLE_SPARK, k, k, tex_particle, true, PBLEND_ADD, 0.5, 0.02, lhrandom(8, 16) / cl_particles_quality.value, 0, t, 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz), dir[0], dir[1], dir[2], cl.time + 9999, dir[0], dir[1], dir[2], 0, 0);
}
}
break;
k = particlepalette[colorbase + (rand()&3)];
if (gamemode == GAME_GOODVSBAD2)
{
- particle(pt_rain, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ADD, 20, 20, lhrandom(64, 128), 0, t, 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz), dir[0], dir[1], dir[2], 0, dir[0], dir[1], dir[2], 0, 0);
+ particle(pt_rain, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ADD, 20, 20, lhrandom(64, 128) / cl_particles_quality.value, 0, t, 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz), dir[0], dir[1], dir[2], 0, dir[0], dir[1], dir[2], 0, 0);
}
else
{
- particle(pt_rain, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ADD, 1, 1, lhrandom(64, 128), 0, t, 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz), dir[0], dir[1], dir[2], 0, dir[0], dir[1], dir[2], 0, 0);
+ particle(pt_rain, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ADD, 1, 1, lhrandom(64, 128) / cl_particles_quality.value, 0, t, 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz), dir[0], dir[1], dir[2], 0, dir[0], dir[1], dir[2], 0, 0);
}
}
break;
center[1] = (mins[1] + maxs[1]) * 0.5f;
center[2] = (mins[2] + maxs[2]) * 0.5f;
+ count *= cl_particles_quality.value;
while (count--)
{
k = particlepalette[224 + (rand()&15)];
VectorNormalizeFast(v);
VectorScale(v, 100, v);
v[2] += sv_gravity.value * 0.15f;
- particle(pt_static, PARTICLE_BILLBOARD, 0x903010, 0xFFD030, tex_particle, false, PBLEND_ADD, 1.5, 1.5, lhrandom(64, 128), 128, 9999, 1, 0, o[0], o[1], o[2], v[0], v[1], v[2], 0, 0, 0, 0, 0, 0);
+ particle(pt_static, PARTICLE_BILLBOARD, 0x903010, 0xFFD030, tex_particle, false, PBLEND_ADD, 1.5, 1.5, lhrandom(64, 128) / cl_particles_quality.value, 128 / cl_particles_quality.value, 9999, 1, 0, o[0], o[1], o[2], v[0], v[1], v[2], 0, 0, 0, 0, 0.2, 0);
}
}
if (maxs[1] <= mins[1]) {t = mins[1];mins[1] = maxs[1];maxs[1] = t;}
if (maxs[2] <= mins[2]) {t = mins[2];mins[2] = maxs[2];maxs[2] = t;}
+ count *= cl_particles_quality.value;
while (count--)
{
k = particlepalette[224 + (rand()&15)];
- particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ADD, 4, 4, lhrandom(64, 128), 384, 9999, -1, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(mins[2], maxs[2]), lhrandom(-32, 32), lhrandom(-32, 32), lhrandom(0, 64), 0, 0, 0, 0, 1, 0);
+ particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ADD, 4, 4, lhrandom(64, 128) / cl_particles_quality.value, 384 / cl_particles_quality.value, 9999, -1, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(mins[2], maxs[2]), lhrandom(-32, 32), lhrandom(-32, 32), lhrandom(0, 64), 0, 0, 0, 0, 1, 0);
if (count & 1)
- particle(pt_static, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], false, PBLEND_ADD, 6, 6, lhrandom(48, 96), 64, 9999, 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(mins[2], maxs[2]), lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(0, 32), 0, 0, 0, 0, 0, 0);
+ particle(pt_static, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], false, PBLEND_ADD, 6, 6, lhrandom(48, 96) / cl_particles_quality.value, 64 / cl_particles_quality.value, 9999, 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(mins[2], maxs[2]), lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(0, 32), 0, 0, 0, 0, 0, 0);
}
}
int k;
if (!cl_particles.integer) return;
+ count *= cl_particles_quality.value;
while (count--)
{
k = particlepalette[224 + (rand()&15)];
- particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ADD, 4, 4, lhrandom(64, 128), 384, 9999, -1, 1.1, org[0], org[1], org[2], vel[0] + lhrandom(-128, 128), vel[1] + lhrandom(-128, 128), vel[2] + lhrandom(-128, 128), 0, 0, 0, 0, 1, 0);
+ particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ADD, 4, 4, lhrandom(64, 128) / cl_particles_quality.value, 384 / cl_particles_quality.value, 9999, -1, 1.1, org[0], org[1], org[2], vel[0] + lhrandom(-128, 128), vel[1] + lhrandom(-128, 128), vel[2] + lhrandom(-128, 128), 0, 0, 0, 0, 1, 0);
}
}
*/
void CL_LavaSplash (vec3_t origin)
{
- int i, j, k, l, inc;
- float vel;
+ float i, j, inc, vel;
+ int k, l;
vec3_t dir, org;
if (!cl_particles.integer) return;
- inc = 32;
+ inc = 32 / cl_particles_quality.value;
for (i = -128;i < 128;i += inc)
{
for (j = -128;j < 128;j += inc)
{
k = particlepalette[0 + (rand()&255)];
l = particlepalette[0 + (rand()&255)];
- particle(pt_static, PARTICLE_BILLBOARD, k, l, tex_particle, false, PBLEND_ADD, 12, 12, 255, 240, 9999, 0.05, 1, org[0], org[1], org[2], dir[0] * vel, dir[1] * vel, dir[2] * vel, 0, 0, 0, 0, 0, 0);
+ particle(pt_static, PARTICLE_BILLBOARD, k, l, tex_particle, false, PBLEND_ADD, 12, 12, inc * 8, inc * 8, 9999, 0.05, 1, org[0], org[1], org[2], dir[0] * vel, dir[1] * vel, dir[2] * vel, 0, 0, 0, 0, 0, 0);
}
else
{
k = l = particlepalette[224 + (rand()&7)];
- particle(pt_static, PARTICLE_BILLBOARD, k, l, tex_particle, false, PBLEND_ADD, 12, 12, 255, 240, 9999, 0.05, 0, org[0], org[1], org[2], dir[0] * vel, dir[1] * vel, dir[2] * vel, 0, 0, 0, 0, 0, 0);
+ particle(pt_static, PARTICLE_BILLBOARD, k, l, tex_particle, false, PBLEND_ADD, 12, 12, inc * 8, inc * 8, 9999, 0.05, 0, org[0], org[1], org[2], dir[0] * vel, dir[1] * vel, dir[2] * vel, 0, 0, 0, 0, 0, 0);
}
}
}
#if WORKINGLQUAKE
void R_TeleportSplash (vec3_t org)
{
- int i, j, k;
+ float i, j, k, inc;
if (!cl_particles.integer) return;
- for (i=-16 ; i<16 ; i+=8)
- for (j=-16 ; j<16 ; j+=8)
- for (k=-24 ; k<32 ; k+=8)
- particle(pt_static, PARTICLE_BILLBOARD, 0xA0A0A0, 0xFFFFFF, tex_particle, false, PBLEND_ADD, 10, 10, lhrandom(64, 128), 256, 9999, 0, 0, org[0] + i + lhrandom(0, 8), org[1] + j + lhrandom(0, 8), org[2] + k + lhrandom(0, 8), lhrandom(-64, 64), lhrandom(-64, 64), lhrandom(-256, 256), 0, 0, 0, 0, 1, 0);
+ inc = 8 / cl_particles_quality.value;
+ for (i = -16;i < 16;i += inc)
+ for (j = -16;j < 16;j += inc)
+ for (k = -24;k < 32;k += inc)
+ particle(pt_static, PARTICLE_BILLBOARD, 0xA0A0A0, 0xFFFFFF, tex_particle, false, PBLEND_ADD, 10, 10, inc * 32, inc * lhrandom(8, 16), inc * 32, 9999, 0, 0, org[0] + i + lhrandom(0, 8), org[1] + j + lhrandom(0, 8), org[2] + k + lhrandom(0, 8), lhrandom(-64, 64), lhrandom(-64, 64), lhrandom(-256, 256), 0, 0, 0, 0, 1, 0);
}
#endif
#ifdef WORKINGLQUAKE
void R_RocketTrail (vec3_t start, vec3_t end, int type)
#else
-void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent)
+void CL_RocketTrail (vec3_t start, vec3_t end, int type, int color, entity_t *ent)
#endif
{
vec3_t vec, dir, vel, pos;
- float len, dec, speed, r;
+ float len, dec, speed, qd;
int contents, smoke, blood, bubbles;
if (end[0] == start[0] && end[1] == start[1] && end[2] == start[2])
// if we skip out, leave it reset
ent->persistent.trail_time = 0.0f;
- speed = 1.0f / (ent->state_current.time - ent->state_previous.time);
+ speed = ent->state_current.time - ent->state_previous.time;
+ if (speed)
+ speed = 1.0f / speed;
VectorSubtract(ent->state_current.origin, ent->state_previous.origin, vel);
#endif
VectorScale(vel, speed, vel);
VectorMA(start, dec, vec, pos);
len -= dec;
- contents = CL_PointContents(pos);
+ contents = CL_PointQ1Contents(pos);
if (contents == CONTENTS_SKY || contents == CONTENTS_LAVA)
return;
smoke = cl_particles.integer && cl_particles_smoke.integer;
blood = cl_particles.integer && cl_particles_blood.integer;
bubbles = cl_particles.integer && cl_particles_bubbles.integer && (contents == CONTENTS_WATER || contents == CONTENTS_SLIME);
+ qd = 1.0f / cl_particles_quality.value;
while (len >= 0)
{
switch (type)
{
case 0: // rocket trail
- dec = 3;
+ dec = qd*3;
if (smoke)
{
- particle(pt_grow, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], false, PBLEND_ADD, dec, dec, cl_particles_smoke_alpha.value*125, cl_particles_smoke_alphafade.value*125, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-5, 5), lhrandom(-5, 5), lhrandom(-5, 5), cl_particles_smoke_size.value, 0, 0, 0, 0, 0);
- particle(pt_static, PARTICLE_BILLBOARD, 0x801010, 0xFFA020, tex_smoke[rand()&7], false, PBLEND_ADD, dec, dec, cl_particles_smoke_alpha.value*288, cl_particles_smoke_alphafade.value*1400, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-20, 20), lhrandom(-20, 20), lhrandom(-20, 20), 0, 0, 0, 0, 0, 0);
+ particle(pt_grow, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], false, PBLEND_ADD, 3, 3, qd*cl_particles_smoke_alpha.value*125, qd*cl_particles_smoke_alphafade.value*125, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-5, 5), lhrandom(-5, 5), lhrandom(-5, 5), 7, 0, 0, 0, 0, 0);
+ particle(pt_static, PARTICLE_BILLBOARD, 0x801010, 0xFFA020, tex_smoke[rand()&7], false, PBLEND_ADD, 3, 3, qd*cl_particles_smoke_alpha.value*288, qd*cl_particles_smoke_alphafade.value*1400, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-20, 20), lhrandom(-20, 20), lhrandom(-20, 20), 0, 0, 0, 0, 0, 0);
}
if (bubbles)
- {
- r = lhrandom(1, 2);
- particle(pt_bubble, PARTICLE_BILLBOARD, 0x404040, 0x808080, tex_bubble, false, PBLEND_ADD, r, r, lhrandom(64, 255), 256, 9999, -0.25, 1.5, pos[0], pos[1], pos[2], lhrandom(-16, 16), lhrandom(-16, 16), lhrandom(-16, 16), 0, 0, 0, 0, (1.0 / 16.0), 0);
- }
+ particle(pt_bubble, PARTICLE_BILLBOARD, 0x404040, 0x808080, tex_bubble, false, PBLEND_ADD, 2, 2, qd*lhrandom(64, 255), qd*256, 9999, -0.25, 1.5, pos[0], pos[1], pos[2], lhrandom(-16, 16), lhrandom(-16, 16), lhrandom(-16, 16), 0, 0, 0, 0, (1.0 / 16.0), 0);
break;
case 1: // grenade trail
// FIXME: make it gradually stop smoking
- dec = 3;
+ dec = qd*3;
if (smoke)
- {
- particle(pt_grow, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], false, PBLEND_ADD, dec, dec, cl_particles_smoke_alpha.value*100, cl_particles_smoke_alphafade.value*100, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-5, 5), lhrandom(-5, 5), lhrandom(-5, 5), cl_particles_smoke_size.value, 0, 0, 0, 0, 0);
- }
+ particle(pt_grow, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], false, PBLEND_ADD, 3, 3, qd*cl_particles_smoke_alpha.value*100, qd*cl_particles_smoke_alphafade.value*100, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-5, 5), lhrandom(-5, 5), lhrandom(-5, 5), 7, 0, 0, 0, 0, 0);
break;
case 2: // blood
case 4: // slight blood
- dec = cl_particles_blood_size.value;
+ dec = qd*16;
if (blood)
- {
- particle(pt_blood, PARTICLE_BILLBOARD, 0xFFFFFF, 0xFFFFFF, tex_blooddecal[rand()&7], true, PBLEND_MOD, dec, dec, cl_particles_blood_alpha.value * 255.0f * 3.0f, cl_particles_blood_alpha.value * 255.0f * 0.5f * 1.5f, 9999, 0, -1, pos[0], pos[1], pos[2], vel[0] * 0.5f + lhrandom(-64, 64), vel[1] * 0.5f + lhrandom(-64, 64), vel[2] * 0.5f + lhrandom(-64, 64), 0, 0, 0, 0, 1, 0);
- //particle(pt_blood, PARTICLE_BILLBOARD, 0x100000, 0x280000, tex_smoke[rand()&7], true, PBLEND_ALPHA, dec, dec, cl_particles_blood_alpha.value * 255.0f, cl_particles_blood_alpha.value * 255.0f * 0.5, 9999, 0, -1, pos[0], pos[1], pos[2], vel[0] * 0.5f + lhrandom(-64, 64), vel[1] * 0.5f + lhrandom(-64, 64), vel[2] * 0.5f + lhrandom(-64, 64), 0, 0, 0, 0, 1, 0);
- }
+ particle(pt_blood, PARTICLE_BILLBOARD, 0xFFFFFF, 0xFFFFFF, tex_bloodparticle[rand()&7], true, PBLEND_MOD, 8, 8, qd * cl_particles_blood_alpha.value * 768.0f, qd * cl_particles_blood_alpha.value * 384.0f, 9999, 0, -1, pos[0], pos[1], pos[2], vel[0] * 0.5f + lhrandom(-64, 64), vel[1] * 0.5f + lhrandom(-64, 64), vel[2] * 0.5f + lhrandom(-64, 64), 0, 0, 0, 0, 1, 0);
break;
case 3: // green tracer
- dec = 6;
+ dec = qd*6;
if (smoke)
{
if (gamemode == GAME_GOODVSBAD2)
- {
- particle(pt_static, PARTICLE_BILLBOARD, 0x00002E, 0x000030, tex_particle, false, PBLEND_ADD, dec, dec, 128, 384, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 0, 0, 0, 0, 0, 0);
- }
+ particle(pt_static, PARTICLE_BILLBOARD, 0x00002E, 0x000030, tex_particle, false, PBLEND_ADD, 6, 6, qd*128, qd*384, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 0, 0, 0, 0, 0, 0);
else
- {
- particle(pt_static, PARTICLE_BILLBOARD, 0x002000, 0x003000, tex_particle, false, PBLEND_ADD, dec, dec, 128, 384, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 0, 0, 0, 0, 0, 0);
- }
+ particle(pt_static, PARTICLE_BILLBOARD, 0x002000, 0x003000, tex_particle, false, PBLEND_ADD, 6, 6, qd*128, qd*384, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 0, 0, 0, 0, 0, 0);
}
break;
case 5: // flame tracer
- dec = 6;
+ dec = qd*6;
if (smoke)
- {
- particle(pt_static, PARTICLE_BILLBOARD, 0x301000, 0x502000, tex_particle, false, PBLEND_ADD, dec, dec, 128, 384, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 0, 0, 0, 0, 0, 0);
- }
+ particle(pt_static, PARTICLE_BILLBOARD, 0x301000, 0x502000, tex_particle, false, PBLEND_ADD, 6, 6, qd*128, qd*384, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 0, 0, 0, 0, 0, 0);
break;
case 6: // voor trail
- dec = 6;
+ dec = qd*6;
if (smoke)
{
if (gamemode == GAME_GOODVSBAD2)
- {
- particle(pt_static, PARTICLE_BILLBOARD, particlepalette[0 + (rand()&255)], particlepalette[0 + (rand()&255)], tex_particle, false, PBLEND_ALPHA, dec, dec, 255, 384, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 0, 0, 0, 0, 0, 0);
- }
+ particle(pt_static, PARTICLE_BILLBOARD, particlepalette[0 + (rand()&255)], particlepalette[0 + (rand()&255)], tex_particle, false, PBLEND_ALPHA, 6, 6, qd*255, qd*384, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 0, 0, 0, 0, 0, 0);
+ else if (gamemode == GAME_PRYDON)
+ particle(pt_static, PARTICLE_BILLBOARD, 0x103040, 0x204050, tex_particle, false, PBLEND_ADD, 6, 6, qd*128, qd*384, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 0, 0, 0, 0, 0, 0);
else
- {
- particle(pt_static, PARTICLE_BILLBOARD, 0x502030, 0x502030, tex_particle, false, PBLEND_ADD, dec, dec, 128, 384, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 0, 0, 0, 0, 0, 0);
- }
+ particle(pt_static, PARTICLE_BILLBOARD, 0x502030, 0x502030, tex_particle, false, PBLEND_ADD, 6, 6, qd*128, qd*384, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 0, 0, 0, 0, 0, 0);
}
break;
-
+#ifndef WORKINGLQUAKE
case 7: // Nehahra smoke tracer
- dec = 7;
+ dec = qd*7;
if (smoke)
- {
- particle(pt_static, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], true, PBLEND_ALPHA, dec, dec, 64, 320, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-4, 4), lhrandom(-4, 4), lhrandom(0, 16), 0, 0, 0, 0, 0, 0);
- }
+ particle(pt_static, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], true, PBLEND_ALPHA, 7, 7, qd*64, qd*320, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-4, 4), lhrandom(-4, 4), lhrandom(0, 16), 0, 0, 0, 0, 0, 0);
break;
case 8: // Nexuiz plasma trail
- dec = 4;
+ dec = qd*4;
if (smoke)
- {
- //particle(pt_static, PARTICLE_BILLBOARD, 0x2030FF, 0x80C0FF, tex_particle, false, PBLEND_ADD, 3.0f, 3.0f, lhrandom(64, 255), 512, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-32, 32) + dir[0] * -64.0f, lhrandom(-32, 32) + dir[1] * -64.0f, lhrandom(-32, 32) + dir[2] * -64.0f, 0, 0, 0, 0, 0, 0);
- particle(pt_static, PARTICLE_BILLBOARD, 0x283880, 0x283880, tex_particle, false, PBLEND_ADD, dec, dec, 255, 1024, 9999, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
- }
+ particle(pt_static, PARTICLE_BILLBOARD, 0x283880, 0x283880, tex_particle, false, PBLEND_ADD, 4, 4, qd*255, qd*1024, 9999, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
+ break;
+ case 9: // glow trail
+ dec = qd*3;
+ if (smoke)
+ particle(pt_static, PARTICLE_BILLBOARD, color, color, tex_particle, false, PBLEND_ALPHA, 5, 5, qd*128, qd*320, 9999, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
+ break;
+#endif
}
// advance to next time and position
#endif
}
-void CL_RocketTrail2 (vec3_t start, vec3_t end, int color, entity_t *ent)
-{
- vec3_t vec, pos;
- int len;
- if (!cl_particles.integer) return;
- if (!cl_particles_smoke.integer) return;
-
- VectorCopy(start, pos);
- VectorSubtract (end, start, vec);
-#ifdef WORKINGLQUAKE
- len = (int) (VectorNormalize (vec) * (1.0f / 3.0f));
-#else
- len = (int) (VectorNormalizeLength (vec) * (1.0f / 3.0f));
-#endif
- VectorScale(vec, 3, vec);
- color = particlepalette[color];
- while (len--)
- {
- particle(pt_static, PARTICLE_BILLBOARD, color, color, tex_particle, false, PBLEND_ALPHA, 5, 5, 128, 320, 9999, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
- VectorAdd (pos, vec, pos);
- }
-}
-
void CL_BeamParticle (const vec3_t start, const vec3_t end, vec_t radius, float red, float green, float blue, float alpha, float lifetime)
{
int tempcolor2, cr, cg, cb;
void CL_Tei_Smoke(const vec3_t org, const vec3_t dir, int count)
{
- int k;
+ float f;
if (!cl_particles.integer) return;
// smoke puff
if (cl_particles_smoke.integer)
- {
- k = count / 4;
- while(k--)
- {
- particle(pt_grow, PARTICLE_BILLBOARD, 0x202020, 0x404040, tex_smoke[rand()&7], true, PBLEND_ADD, 5, 5, 255, 512, 9999, 0, 0, org[0] + 0.125f * lhrandom(-count, count), org[1] + 0.125f * lhrandom (-count, count), org[2] + 0.125f * lhrandom(-count, count), dir[0] + lhrandom(-count, count) * 0.5f, dir[1] + lhrandom(-count, count) * 0.5f, dir[2] + lhrandom(-count, count) * 0.5f, 15, 0, 0, 0, 0, 0);
- }
- }
+ for (f = 0;f < count;f += 4.0f / cl_particles_quality.value)
+ particle(pt_grow, PARTICLE_BILLBOARD, 0x202020, 0x404040, tex_smoke[rand()&7], true, PBLEND_ADD, 5, 5, 255 / cl_particles_quality.value, 512 / cl_particles_quality.value, 9999, 0, 0, org[0] + 0.125f * lhrandom(-count, count), org[1] + 0.125f * lhrandom (-count, count), org[2] + 0.125f * lhrandom(-count, count), dir[0] + lhrandom(-count, count) * 0.5f, dir[1] + lhrandom(-count, count) * 0.5f, dir[2] + lhrandom(-count, count) * 0.5f, 15, 0, 0, 0, 0, 0);
}
void CL_Tei_PlasmaHit(const vec3_t org, const vec3_t dir, int count)
{
- int k;
+ float f;
if (!cl_particles.integer) return;
if (cl_stainmaps.integer)
R_Stain(org, 40, 96, 96, 96, 40, 128, 128, 128, 40);
+ CL_SpawnDecalParticleForPoint(org, 6, 8, 255, tex_bulletdecal[rand()&7], 0xFFFFFF, 0xFFFFFF);
// smoke puff
if (cl_particles_smoke.integer)
- {
- k = count / 4;
- while(k--)
- {
- particle(pt_grow, PARTICLE_BILLBOARD, 0x202020, 0x404040, tex_smoke[rand()&7], true, PBLEND_ADD, 5, 5, 255, 512, 9999, 0, 0, org[0] + 0.125f * lhrandom(-count, count), org[1] + 0.125f * lhrandom (-count, count), org[2] + 0.125f * lhrandom(-count, count), dir[0] + lhrandom(-count, count), dir[1] + lhrandom(-count, count), dir[2] + lhrandom(-count, count), 15, 0, 0, 0, 0, 0);
- }
- }
+ for (f = 0;f < count;f += 4.0f / cl_particles_quality.value)
+ particle(pt_grow, PARTICLE_BILLBOARD, 0x202020, 0x404040, tex_smoke[rand()&7], true, PBLEND_ADD, 5, 5, 255 / cl_particles_quality.value, 512 / cl_particles_quality.value, 9999, 0, 0, org[0] + 0.125f * lhrandom(-count, count), org[1] + 0.125f * lhrandom (-count, count), org[2] + 0.125f * lhrandom(-count, count), dir[0] + lhrandom(-count, count), dir[1] + lhrandom(-count, count), dir[2] + lhrandom(-count, count), 15, 0, 0, 0, 0, 0);
+ // sparks
if (cl_particles_sparks.integer)
- {
- // sparks
- while(count--)
- {
- particle(pt_static, PARTICLE_SPARK, 0x2030FF, 0x80C0FF, tex_particle, false, PBLEND_ADD, 2.0f, 0.1f, lhrandom(64, 255), 512, 9999, 0, 0, org[0], org[1], org[2], lhrandom(-count, count) * 3.0f + dir[0], lhrandom(-count, count) * 3.0f + dir[1], lhrandom(-count, count) * 3.0f + dir[2], 0, 0, 0, 0, 0, 0);
- }
- }
+ for (f = 0;f < count;f += 1.0f / cl_particles_quality.value)
+ particle(pt_static, PARTICLE_SPARK, 0x2030FF, 0x80C0FF, tex_particle, false, PBLEND_ADD, 2.0f, 0.1f, lhrandom(64, 255) / cl_particles_quality.value, 512 / cl_particles_quality.value, 9999, 0, 0, org[0], org[1], org[2], lhrandom(-count, count) * 3.0f + dir[0], lhrandom(-count, count) * 3.0f + dir[1], lhrandom(-count, count) * 3.0f + dir[2], 0, 0, 0, 0, 0, 0);
}
/*
void CL_MoveParticles (void)
{
particle_t *p;
- int i, activeparticles, maxparticle, j, a, pressureused = false, content;
+ int i, maxparticle, j, a, content;
float gravity, dvel, bloodwaterfade, frametime, f, dist, normal[3], v[3], org[3];
#ifdef WORKINGLQUAKE
void *hitent;
// LordHavoc: early out condition
if (!cl_numparticles)
+ {
+ cl_freeparticle = 0;
return;
+ }
#ifdef WORKINGLQUAKE
frametime = cl.frametime;
dvel = 1+4*frametime;
bloodwaterfade = max(cl_particles_blood_alpha.value, 0.01f) * frametime * 128.0f;
- activeparticles = 0;
maxparticle = -1;
j = 0;
for (i = 0, p = particles;i < cl_numparticles;i++, p++)
{
+ if (!p->type)
+ continue;
+ maxparticle = i;
content = 0;
VectorCopy(p->org, p->oldorg);
VectorMA(p->org, frametime, p->vel, p->org);
VectorCopy(p->org, org);
if (p->bounce)
{
- if (CL_TraceLine(p->oldorg, p->org, v, normal, 0, true, &hitent) < 1)
+ if (CL_TraceLine(p->oldorg, p->org, v, normal, true, &hitent, SUPERCONTENTS_SOLID) < 1)
{
VectorCopy(v, p->org);
if (p->bounce < 0)
if (cl_stainmaps.integer)
R_Stain(v, 32, 32, 16, 16, p->alpha * p->scalex * (1.0f / 40.0f), 192, 48, 48, p->alpha * p->scalex * (1.0f / 40.0f));
#endif
- if (cl_decals.integer)
- {
- p->type = pt_decal;
- p->orientation = PARTICLE_ORIENTED_DOUBLESIDED;
-#ifndef WORKINGLQUAKE
- p->owner = hitent;
- p->ownermodel = hitent->model;
- Matrix4x4_Transform(&hitent->inversematrix, v, p->relativeorigin);
- Matrix4x4_Transform3x3(&hitent->inversematrix, normal, p->relativedirection);
- VectorAdd(p->relativeorigin, p->relativedirection, p->relativeorigin);
-#endif
- p->time2 = cl.time + cl_decals_time.value;
- p->die = p->time2 + cl_decals_fadetime.value;
- p->alphafade = 0;
- VectorCopy(normal, p->vel2);
- VectorClear(p->vel);
- VectorAdd(p->org, normal, p->org);
- p->bounce = 0;
- p->friction = 0;
- p->gravity = 0;
- p->scalex *= 1.25f;
- p->scaley *= 1.25f;
- }
- else
+ if (!cl_decals.integer)
{
- p->die = -1;
- freeparticles[j++] = p;
+ p->type = pt_dead;
continue;
}
+
+ p->type = pt_decal;
+ p->orientation = PARTICLE_ORIENTED_DOUBLESIDED;
+ // convert from a blood particle to a blood decal
+ p->texnum = tex_blooddecal[rand()&7];
+#ifndef WORKINGLQUAKE
+ p->owner = hitent;
+ p->ownermodel = hitent->model;
+ Matrix4x4_Transform(&hitent->inversematrix, v, p->relativeorigin);
+ Matrix4x4_Transform3x3(&hitent->inversematrix, normal, p->relativedirection);
+ VectorAdd(p->relativeorigin, p->relativedirection, p->relativeorigin);
+#endif
+ p->time2 = cl.time + cl_decals_time.value;
+ p->die = p->time2 + cl_decals_fadetime.value;
+ p->alphafade = 0;
+ VectorCopy(normal, p->vel2);
+ VectorClear(p->vel);
+ VectorAdd(p->org, normal, p->org);
+ p->bounce = 0;
+ p->friction = 0;
+ p->gravity = 0;
+ p->scalex *= 2.0f;
+ p->scaley *= 2.0f;
}
else
{
}
}
}
+
p->vel[2] -= p->gravity * gravity;
+
p->alpha -= p->alphafade * frametime;
+
+ if (p->alpha <= 0 || cl.time > p->die)
+ {
+ p->type = pt_dead;
+ continue;
+ }
+
if (p->friction)
{
f = p->friction * frametime;
if (!content)
- content = CL_PointContents(p->org);
+ content = CL_PointQ1Contents(p->org);
if (content != CONTENTS_EMPTY)
f *= 4;
f = 1.0f - f;
{
case pt_blood:
if (!content)
- content = CL_PointContents(p->org);
+ content = CL_PointQ1Contents(p->org);
a = content;
if (a != CONTENTS_EMPTY)
{
if (a == CONTENTS_WATER || a == CONTENTS_SLIME)
{
- p->scalex += frametime * cl_particles_blood_size.value;
- p->scaley += frametime * cl_particles_blood_size.value;
+ p->scalex += frametime * 8;
+ p->scaley += frametime * 8;
//p->alpha -= bloodwaterfade;
}
else
- p->die = -1;
+ p->type = pt_dead;
}
else
p->vel[2] -= gravity;
break;
case pt_bubble:
if (!content)
- content = CL_PointContents(p->org);
+ content = CL_PointQ1Contents(p->org);
if (content != CONTENTS_WATER && content != CONTENTS_SLIME)
{
- p->die = -1;
+ p->type = pt_dead;
break;
}
break;
p->vel[2] = /*lhrandom(-32, 32) +*/ p->vel2[2];
}
if (!content)
- content = CL_PointContents(p->org);
+ content = CL_PointQ1Contents(p->org);
a = content;
if (a != CONTENTS_EMPTY && a != CONTENTS_SKY)
- p->die = -1;
+ p->type = pt_dead;
break;
case pt_grow:
p->scalex += frametime * p->time2;
{
Matrix4x4_Transform(&p->owner->matrix, p->relativeorigin, p->org);
Matrix4x4_Transform3x3(&p->owner->matrix, p->relativedirection, p->vel2);
+ if (cl.time > p->time2)
+ {
+ p->alphafade = p->alpha / (p->die - cl.time);
+ p->type = pt_decalfade;
+ }
}
else
- p->die = -1;
+ p->type = pt_dead;
#endif
- if (cl.time > p->time2)
+ break;
+ case pt_decalfade:
+#ifndef WORKINGLQUAKE
+ if (p->owner->model == p->ownermodel)
+ {
+ Matrix4x4_Transform(&p->owner->matrix, p->relativeorigin, p->org);
+ Matrix4x4_Transform3x3(&p->owner->matrix, p->relativedirection, p->vel2);
+ }
+ else
+ p->type = pt_dead;
+#endif
+ break;
+ case pt_ember:
+ while (cl.time > p->time2)
{
- p->alphafade = p->alpha / (p->die - cl.time);
- p->time2 += 10000;
+ p->time2 += 0.025;
+ particle(pt_static, PARTICLE_SPARK, 0x903010, 0xFFD030, tex_particle, false, PBLEND_ADD, p->scalex * 0.75, p->scaley * 0.75, p->alpha, p->alphafade, 9999, 0.5, 0, p->org[0], p->org[1], p->org[2], p->vel[0] * lhrandom(0.4, 0.6), p->vel[1] * lhrandom(0.4, 0.6), p->vel[2] * lhrandom(0.4, 0.6), 0, 0, 0, 0, 0, 0);
}
break;
default:
Con_Printf("unknown particle type %i\n", p->type);
- p->die = -1;
+ p->type = pt_dead;
break;
}
}
-
- // remove dead particles
- if (p->alpha < 1 || p->die < cl.time)
- freeparticles[j++] = p;
- else
- {
- maxparticle = i;
- activeparticles++;
- if (p->pressure)
- pressureused = true;
- }
- }
- // fill in gaps to compact the array
- i = 0;
- while (maxparticle >= activeparticles)
- {
- *freeparticles[i++] = particles[maxparticle--];
- while (maxparticle >= activeparticles && particles[maxparticle].die < cl.time)
- maxparticle--;
- }
- cl_numparticles = activeparticles;
-
- if (pressureused)
- {
- activeparticles = 0;
- for (i = 0, p = particles;i < cl_numparticles;i++, p++)
- if (p->pressure)
- freeparticles[activeparticles++] = p;
-
- if (activeparticles)
- {
- for (i = 0, p = particles;i < cl_numparticles;i++, p++)
- {
- for (j = 0;j < activeparticles;j++)
- {
- if (freeparticles[j] != p)
- {
- float dist, diff[3];
- VectorSubtract(p->org, freeparticles[j]->org, diff);
- dist = DotProduct(diff, diff);
- if (dist < 4096 && dist >= 1)
- {
- dist = freeparticles[j]->scalex * 4.0f * frametime / sqrt(dist);
- VectorMA(p->vel, dist, diff, p->vel);
- }
- }
- }
- }
- }
}
+ cl_numparticles = maxparticle + 1;
+ cl_freeparticle = 0;
}
#define MAX_PARTICLETEXTURES 64
static cvar_t r_drawparticles = {0, "r_drawparticles", "1"};
+#define PARTICLETEXTURESIZE 32
+#define PARTICLEFONTSIZE (PARTICLETEXTURESIZE*8)
+
static qbyte shadebubble(float dx, float dy, vec3_t light)
{
float dz, f, dot;
static void setuptex(int texnum, qbyte *data, qbyte *particletexturedata)
{
int basex, basey, y;
- basex = ((texnum >> 0) & 7) * 32;
- basey = ((texnum >> 3) & 7) * 32;
- particletexture[texnum].s1 = (basex + 1) / 256.0f;
- particletexture[texnum].t1 = (basey + 1) / 256.0f;
- particletexture[texnum].s2 = (basex + 31) / 256.0f;
- particletexture[texnum].t2 = (basey + 31) / 256.0f;
- for (y = 0;y < 32;y++)
- memcpy(particletexturedata + ((basey + y) * 256 + basex) * 4, data + y * 32 * 4, 32 * 4);
+ basex = ((texnum >> 0) & 7) * PARTICLETEXTURESIZE;
+ basey = ((texnum >> 3) & 7) * PARTICLETEXTURESIZE;
+ particletexture[texnum].s1 = (basex + 1) / (float)PARTICLEFONTSIZE;
+ particletexture[texnum].t1 = (basey + 1) / (float)PARTICLEFONTSIZE;
+ particletexture[texnum].s2 = (basex + PARTICLETEXTURESIZE - 1) / (float)PARTICLEFONTSIZE;
+ particletexture[texnum].t2 = (basey + PARTICLETEXTURESIZE - 1) / (float)PARTICLEFONTSIZE;
+ for (y = 0;y < PARTICLETEXTURESIZE;y++)
+ memcpy(particletexturedata + ((basey + y) * PARTICLEFONTSIZE + basex) * 4, data + y * PARTICLETEXTURESIZE * 4, PARTICLETEXTURESIZE * 4);
+}
+
+void particletextureblotch(qbyte *data, float radius, float red, float green, float blue, float alpha)
+{
+ int x, y;
+ float cx, cy, dx, dy, f, iradius;
+ qbyte *d;
+ cx = (lhrandom(radius + 1, PARTICLETEXTURESIZE - 2 - radius) + lhrandom(radius + 1, PARTICLETEXTURESIZE - 2 - radius)) * 0.5f;
+ cy = (lhrandom(radius + 1, PARTICLETEXTURESIZE - 2 - radius) + lhrandom(radius + 1, PARTICLETEXTURESIZE - 2 - radius)) * 0.5f;
+ iradius = 1.0f / radius;
+ alpha *= (1.0f / 255.0f);
+ for (y = 0;y < PARTICLETEXTURESIZE;y++)
+ {
+ for (x = 0;x < PARTICLETEXTURESIZE;x++)
+ {
+ dx = (x - cx);
+ dy = (y - cy);
+ f = (1.0f - sqrt(dx * dx + dy * dy) * iradius) * alpha;
+ if (f > 0)
+ {
+ d = data + (y * PARTICLETEXTURESIZE + x) * 4;
+ d[0] += f * (red - d[0]);
+ d[1] += f * (green - d[1]);
+ d[2] += f * (blue - d[2]);
+ }
+ }
+ }
+}
+
+void particletextureclamp(qbyte *data, int minr, int ming, int minb, int maxr, int maxg, int maxb)
+{
+ int i;
+ for (i = 0;i < PARTICLETEXTURESIZE*PARTICLETEXTURESIZE;i++, data += 4)
+ {
+ data[0] = bound(minr, data[0], maxr);
+ data[1] = bound(ming, data[1], maxg);
+ data[2] = bound(minb, data[2], maxb);
+ }
+}
+
+void particletextureinvert(qbyte *data)
+{
+ int i;
+ for (i = 0;i < PARTICLETEXTURESIZE*PARTICLETEXTURESIZE;i++, data += 4)
+ {
+ data[0] = 255 - data[0];
+ data[1] = 255 - data[1];
+ data[2] = 255 - data[2];
+ }
}
static void R_InitParticleTexture (void)
{
int x, y, d, i, j, k, m;
- float cx, cy, dx, dy, radius, f, f2;
- qbyte data[32][32][4], noise1[64][64], noise2[64][64], data2[64][16][4];
+ float dx, dy, radius, f, f2;
+ qbyte data[PARTICLETEXTURESIZE][PARTICLETEXTURESIZE][4], noise1[PARTICLETEXTURESIZE*2][PARTICLETEXTURESIZE*2], noise2[PARTICLETEXTURESIZE*2][PARTICLETEXTURESIZE*2], noise3[64][64], data2[64][16][4];
vec3_t light;
- qbyte particletexturedata[256*256*4];
+ qbyte *particletexturedata;
- memset(particletexturedata, 255, sizeof(particletexturedata));
+ // a note: decals need to modulate (multiply) the background color to
+ // properly darken it (stain), and they need to be able to alpha fade,
+ // this is a very difficult challenge because it means fading to white
+ // (no change to background) rather than black (darkening everything
+ // behind the whole decal polygon), and to accomplish this the texture is
+ // inverted (dark red blood on white background becomes brilliant cyan
+ // and white on black background) so we can alpha fade it to black, then
+ // we invert it again during the blendfunc to make it work...
- // smoke/blood
+ particletexturedata = Mem_Alloc(tempmempool, PARTICLEFONTSIZE*PARTICLEFONTSIZE*4);
+ memset(particletexturedata, 255, PARTICLEFONTSIZE*PARTICLEFONTSIZE*4);
+
+ // smoke
for (i = 0;i < 8;i++)
{
+ memset(&data[0][0][0], 255, sizeof(data));
do
{
- fractalnoise(&noise1[0][0], 64, 4);
- fractalnoise(&noise2[0][0], 64, 8);
+ fractalnoise(&noise1[0][0], PARTICLETEXTURESIZE*2, PARTICLETEXTURESIZE/8);
+ fractalnoise(&noise2[0][0], PARTICLETEXTURESIZE*2, PARTICLETEXTURESIZE/4);
m = 0;
- for (y = 0;y < 32;y++)
+ for (y = 0;y < PARTICLETEXTURESIZE;y++)
{
- dy = y - 16;
- for (x = 0;x < 32;x++)
+ dy = (y - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f+1);
+ for (x = 0;x < PARTICLETEXTURESIZE;x++)
{
- data[y][x][0] = data[y][x][1] = data[y][x][2] = 255;
- dx = x - 16;
+ dx = (x - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f+1);
d = (noise2[y][x] - 128) * 3 + 192;
if (d > 0)
- d = (d * (256 - (int) (dx*dx+dy*dy))) >> 8;
+ d = d * (1-(dx*dx+dy*dy));
d = (d * noise1[y][x]) >> 7;
d = bound(0, d, 255);
data[y][x][3] = (qbyte) d;
}
}
while (m < 224);
-
setuptex(tex_smoke[i], &data[0][0][0], particletexturedata);
}
// rain splash
for (i = 0;i < 16;i++)
{
- radius = i * 3.0f / 16.0f;
+ memset(&data[0][0][0], 255, sizeof(data));
+ radius = i * 3.0f / 4.0f / 16.0f;
f2 = 255.0f * ((15.0f - i) / 15.0f);
- for (y = 0;y < 32;y++)
+ for (y = 0;y < PARTICLETEXTURESIZE;y++)
{
- dy = (y - 16) * 0.25f;
- for (x = 0;x < 32;x++)
+ dy = (y - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f+1);
+ for (x = 0;x < PARTICLETEXTURESIZE;x++)
{
- dx = (x - 16) * 0.25f;
- data[y][x][0] = data[y][x][1] = data[y][x][2] = 255;
- f = (1.0 - fabs(radius - sqrt(dx*dx+dy*dy))) * f2;
- f = bound(0.0f, f, 255.0f);
- data[y][x][3] = (int) f;
+ dx = (x - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f+1);
+ f = f2 * (1.0 - 4.0f * fabs(radius - sqrt(dx*dx+dy*dy)));
+ data[y][x][3] = (int) (bound(0.0f, f, 255.0f));
}
}
setuptex(tex_rainsplash[i], &data[0][0][0], particletexturedata);
}
// normal particle
- for (y = 0;y < 32;y++)
+ memset(&data[0][0][0], 255, sizeof(data));
+ for (y = 0;y < PARTICLETEXTURESIZE;y++)
{
- dy = y - 16;
- for (x = 0;x < 32;x++)
+ dy = (y - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f+1);
+ for (x = 0;x < PARTICLETEXTURESIZE;x++)
{
- data[y][x][0] = data[y][x][1] = data[y][x][2] = 255;
- dx = x - 16;
- d = (256 - (dx*dx+dy*dy));
+ dx = (x - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f+1);
+ d = 256 * (1 - (dx*dx+dy*dy));
d = bound(0, d, 255);
data[y][x][3] = (qbyte) d;
}
setuptex(tex_particle, &data[0][0][0], particletexturedata);
// rain
+ memset(&data[0][0][0], 255, sizeof(data));
light[0] = 1;light[1] = 1;light[2] = 1;
VectorNormalize(light);
- for (y = 0;y < 32;y++)
+ for (y = 0;y < PARTICLETEXTURESIZE;y++)
{
- for (x = 0;x < 32;x++)
+ dy = (y - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f+1);
+ // stretch upper half of bubble by +50% and shrink lower half by -50%
+ // (this gives an elongated teardrop shape)
+ if (dy > 0.5f)
+ dy = (dy - 0.5f) * 2.0f;
+ else
+ dy = (dy - 0.5f) / 1.5f;
+ for (x = 0;x < PARTICLETEXTURESIZE;x++)
{
- data[y][x][0] = data[y][x][1] = data[y][x][2] = 255;
- data[y][x][3] = shadebubble((x - 16) * (1.0 / 8.0), y < 24 ? (y - 24) * (1.0 / 24.0) : (y - 24) * (1.0 / 8.0), light);
+ 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);
}
}
setuptex(tex_raindrop, &data[0][0][0], particletexturedata);
// bubble
+ memset(&data[0][0][0], 255, sizeof(data));
light[0] = 1;light[1] = 1;light[2] = 1;
VectorNormalize(light);
- for (y = 0;y < 32;y++)
+ for (y = 0;y < PARTICLETEXTURESIZE;y++)
{
- for (x = 0;x < 32;x++)
+ dy = (y - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f+1);
+ for (x = 0;x < PARTICLETEXTURESIZE;x++)
{
- data[y][x][0] = data[y][x][1] = data[y][x][2] = 255;
- data[y][x][3] = shadebubble((x - 16) * (1.0 / 16.0), (y - 16) * (1.0 / 16.0), light);
+ dx = (x - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f+1);
+ data[y][x][3] = shadebubble(dx, dy, light);
}
}
setuptex(tex_bubble, &data[0][0][0], particletexturedata);
- // smoke/blood
+ // blood particles
for (i = 0;i < 8;i++)
{
memset(&data[0][0][0], 255, sizeof(data));
- for (j = 1;j < 8;j++)
- {
- for (k = 0;k < 3;k++)
- {
- cx = lhrandom(j + 1, 30 - j);
- cy = lhrandom(j + 1, 30 - j);
- for (y = 0;y < 32;y++)
- {
- for (x = 0;x < 32;x++)
- {
- dx = (x - cx);
- dy = (y - cy);
- f = 1.0f - sqrt(dx * dx + dy * dy) / j;
- if (f > 0)
- {
- data[y][x][0] = data[y][x][0] + f * 0.5 * ( 160 - data[y][x][0]);
- data[y][x][1] = data[y][x][1] + f * 0.5 * ( 32 - data[y][x][1]);
- data[y][x][2] = data[y][x][2] + f * 0.5 * ( 32 - data[y][x][2]);
- }
- }
- }
- }
- }
- // use inverted colors so we can scale them later using glColor and use an inverse blend
- for (y = 0;y < 32;y++)
- {
- for (x = 0;x < 32;x++)
- {
- data[y][x][0] = 255 - data[y][x][0];
- data[y][x][1] = 255 - data[y][x][1];
- data[y][x][2] = 255 - data[y][x][2];
- }
- }
+ 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);
+ }
+
+ // blood decals
+ for (i = 0;i < 8;i++)
+ {
+ memset(&data[0][0][0], 255, sizeof(data));
+ 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, 192 - 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);
}
+ // bullet decals
+ for (i = 0;i < 8;i++)
+ {
+ memset(&data[0][0][0], 255, sizeof(data));
+ for (k = 0;k < 12;k++)
+ particletextureblotch(&data[0][0][0], 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);
+ }
+
#if WORKINGLQUAKE
glBindTexture(GL_TEXTURE_2D, (particlefonttexture = gl_extension_number++));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
#else
- particlefonttexture = R_LoadTexture2D(particletexturepool, "particlefont", 256, 256, particletexturedata, TEXTYPE_RGBA, TEXF_ALPHA | TEXF_PRECACHE, NULL);
+ particlefonttexture = loadtextureimage(particletexturepool, "particles/particlefont.tga", 0, 0, false, TEXF_ALPHA | TEXF_PRECACHE);
+ if (!particlefonttexture)
+ particlefonttexture = R_LoadTexture2D(particletexturepool, "particlefont", PARTICLEFONTSIZE, PARTICLEFONTSIZE, particletexturedata, TEXTYPE_RGBA, TEXF_ALPHA | TEXF_PRECACHE, NULL);
for (i = 0;i < MAX_PARTICLETEXTURES;i++)
particletexture[i].texture = particlefonttexture;
- // beam
- fractalnoise(&noise1[0][0], 64, 4);
+ // nexbeam
+ fractalnoise(&noise3[0][0], 64, 4);
m = 0;
for (y = 0;y < 64;y++)
{
+ dy = (y - 0.5f*64) / (64*0.5f+1);
for (x = 0;x < 16;x++)
{
- if (x < 8)
- d = x;
- else
- d = (15 - x);
- d = d * d * noise1[y][x] / (7 * 7);
+ dx = (x - 0.5f*16) / (16*0.5f+1);
+ d = (1 - (dx*dx)) * noise3[y][x];
data2[y][x][0] = data2[y][x][1] = data2[y][x][2] = (qbyte) bound(0, d, 255);
data2[y][x][3] = 255;
}
}
- particletexture[tex_beam].texture = R_LoadTexture2D(particletexturepool, "beam", 16, 64, &data2[0][0][0], TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
+ particletexture[tex_beam].texture = loadtextureimage(particletexturepool, "particles/nexbeam.tga", 0, 0, false, TEXF_ALPHA | TEXF_PRECACHE);
+ if (!particletexture[tex_beam].texture)
+ particletexture[tex_beam].texture = R_LoadTexture2D(particletexturepool, "nexbeam", 16, 64, &data2[0][0][0], TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
particletexture[tex_beam].s1 = 0;
particletexture[tex_beam].t1 = 0;
particletexture[tex_beam].s2 = 1;
particletexture[tex_beam].t2 = 1;
#endif
+ Mem_Free(particletexturedata);
}
static void r_part_start(void)
static void r_part_newmap(void)
{
cl_numparticles = 0;
+ cl_freeparticle = 0;
}
void R_Particles_Init (void)
#ifndef WORKINGLQUAKE
if (fogenabled && p->blendmode != PBLEND_MOD)
{
- VectorSubtract(org, r_origin, fogvec);
+ VectorSubtract(org, r_vieworigin, fogvec);
fog = exp(fogdensity/DotProduct(fogvec,fogvec));
ifog = 1 - fog;
cr = cr * ifog;
cb += fogcolor[2] * fog;
}
}
- cr *= r_colorscale;
- cg *= r_colorscale;
- cb *= r_colorscale;
-
- GL_Color(cr, cg, cb, ca);
R_Mesh_Matrix(&r_identitymatrix);
memset(&m, 0, sizeof(m));
m.tex[0] = R_GetTexture(tex->texture);
m.pointer_texcoord[0] = particle_texcoord2f;
- R_Mesh_State_Texture(&m);
+ m.pointer_vertex = particle_vertex3f;
+ R_Mesh_State(&m);
+
+ GL_Color(cr, cg, cb, ca);
if (p->blendmode == 0)
GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
GL_BlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
GL_DepthMask(false);
GL_DepthTest(true);
- GL_VertexPointer(particle_vertex3f);
#endif
if (p->orientation == PARTICLE_BILLBOARD || p->orientation == PARTICLE_ORIENTED_DOUBLESIDED)
{
if (p->orientation == PARTICLE_ORIENTED_DOUBLESIDED)
{
// double-sided
- if (DotProduct(p->vel2, r_origin) > DotProduct(p->vel2, org))
+ if (DotProduct(p->vel2, r_vieworigin) > DotProduct(p->vel2, org))
{
VectorNegate(p->vel2, v);
VectorVectors(v, right, up);
}
else
{
- VectorScale(vright, p->scalex, right);
- VectorScale(vup, p->scaley, up);
+ VectorScale(r_viewleft, -p->scalex, right);
+ VectorScale(r_viewup, p->scaley, up);
}
particle_vertex3f[ 0] = org[0] - right[0] - up[0];
particle_vertex3f[ 1] = org[1] - right[1] - up[1];
if ((!cl_numparticles) || (!r_drawparticles.integer))
return;
- minparticledist = DotProduct(r_origin, vpn) + 16.0f;
+ minparticledist = DotProduct(r_vieworigin, r_viewforward) + 4.0f;
#ifdef WORKINGLQUAKE
glBindTexture(GL_TEXTURE_2D, particlefonttexture);
glDepthMask(0);
// LordHavoc: only render if not too close
for (i = 0, p = particles;i < cl_numparticles;i++, p++)
- if (DotProduct(p->org, vpn) >= minparticledist)
+ if (p->type && DotProduct(p->org, r_viewforward) >= minparticledist)
R_DrawParticle(p);
glDepthMask(1);
glDisable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
#else
// LordHavoc: only render if not too close
- c_particles += cl_numparticles;
for (i = 0, p = particles;i < cl_numparticles;i++, p++)
- if (DotProduct(p->org, vpn) >= minparticledist || p->orientation == PARTICLE_BEAM)
- R_MeshQueue_AddTransparent(p->org, R_DrawParticleCallback, p, 0);
+ {
+ if (p->type)
+ {
+ c_particles++;
+ if (DotProduct(p->org, r_viewforward) >= minparticledist || p->orientation == PARTICLE_BEAM)
+ R_MeshQueue_AddTransparent(p->org, R_DrawParticleCallback, p, 0);
+ }
+ }
#endif
}
projects / xonotic / darkplaces.git / blobdiff