X-Git-Url: http://git.xonotic.org/?a=blobdiff_plain;ds=sidebyside;f=cl_particles.c;h=1409edcdc0a8451dcfa17e4ef00858a17f5dd76d;hb=00ca5f39cd5c7640de9c915c1f6792f2bd4108d9;hp=09d12c7c5b8267822c1c68da4ae78aaf937e6319;hpb=17c635ed3aab74ad2931d6267253ad79df98bbdd;p=xonotic%2Fdarkplaces.git diff --git a/cl_particles.c b/cl_particles.c index 09d12c7c..1409edcd 100644 --- a/cl_particles.c +++ b/cl_particles.c @@ -20,21 +20,158 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. #include "quakedef.h" -#define MAX_PARTICLES 16384 // default max # of particles at one time +#ifdef WORKINGLQUAKE +#define lhrandom(MIN,MAX) ((rand() & 32767) * (((MAX)-(MIN)) * (1.0f / 32767.0f)) + (MIN)) +#define NUMVERTEXNORMALS 162 +siextern float r_avertexnormals[NUMVERTEXNORMALS][3]; +#define m_bytenormals r_avertexnormals +#define VectorNormalizeFast VectorNormalize +#define Mod_PointContents(v,m) (Mod_PointInLeaf(v,m)->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_EntityParticles R_EntityParticles +#define CL_ReadPointFile_f R_ReadPointFile_f +#define CL_ParseParticleEffect R_ParseParticleEffect +#define CL_ParticleExplosion R_ParticleExplosion +#define CL_ParticleExplosion2 R_ParticleExplosion2 +#define CL_BlobExplosion R_BlobExplosion +#define CL_RunParticleEffect R_RunParticleEffect +#define CL_LavaSplash R_LavaSplash +#define CL_RocketTrail2 R_RocketTrail2 +void R_CalcBeamVerts (float *vert, vec3_t org1, vec3_t org2, float width) +{ + vec3_t right1, right2, diff, normal; + + VectorSubtract (org2, org1, normal); + VectorNormalizeFast (normal); + + // calculate 'right' vector for start + VectorSubtract (r_origin, org1, diff); + VectorNormalizeFast (diff); + CrossProduct (normal, diff, right1); + + // calculate 'right' vector for end + VectorSubtract (r_origin, org2, diff); + VectorNormalizeFast (diff); + CrossProduct (normal, diff, right2); + + vert[ 0] = org1[0] + width * right1[0]; + vert[ 1] = org1[1] + width * right1[1]; + vert[ 2] = org1[2] + width * right1[2]; + vert[ 4] = org1[0] - width * right1[0]; + vert[ 5] = org1[1] - width * right1[1]; + vert[ 6] = org1[2] - width * right1[2]; + vert[ 8] = org2[0] - width * right2[0]; + vert[ 9] = org2[1] - width * right2[1]; + vert[10] = org2[2] - width * right2[2]; + vert[12] = org2[0] + width * right2[0]; + vert[13] = org2[1] + width * right2[1]; + vert[14] = org2[2] + width * right2[2]; +} +void fractalnoise(qbyte *noise, int size, int startgrid) +{ + int x, y, g, g2, amplitude, min, max, size1 = size - 1, sizepower, gridpower; + int *noisebuf; +#define n(x,y) noisebuf[((y)&size1)*size+((x)&size1)] + + for (sizepower = 0;(1 << sizepower) < size;sizepower++); + if (size != (1 << sizepower)) + Sys_Error("fractalnoise: size must be power of 2\n"); + + for (gridpower = 0;(1 << gridpower) < startgrid;gridpower++); + if (startgrid != (1 << gridpower)) + Sys_Error("fractalnoise: grid must be power of 2\n"); + + startgrid = bound(0, startgrid, size); + + amplitude = 0xFFFF; // this gets halved before use + noisebuf = malloc(size*size*sizeof(int)); + memset(noisebuf, 0, size*size*sizeof(int)); + + for (g2 = startgrid;g2;g2 >>= 1) + { + // brownian motion (at every smaller level there is random behavior) + amplitude >>= 1; + for (y = 0;y < size;y += g2) + for (x = 0;x < size;x += g2) + n(x,y) += (rand()&litude); + + g = g2 >> 1; + if (g) + { + // subdivide, diamond-square algorithm (really this has little to do with squares) + // diamond + for (y = 0;y < size;y += g2) + for (x = 0;x < size;x += g2) + n(x+g,y+g) = (n(x,y) + n(x+g2,y) + n(x,y+g2) + n(x+g2,y+g2)) >> 2; + // square + for (y = 0;y < size;y += g2) + for (x = 0;x < size;x += g2) + { + n(x+g,y) = (n(x,y) + n(x+g2,y) + n(x+g,y-g) + n(x+g,y+g)) >> 2; + n(x,y+g) = (n(x,y) + n(x,y+g2) + n(x-g,y+g) + n(x+g,y+g)) >> 2; + } + } + } + // find range of noise values + min = max = 0; + for (y = 0;y < size;y++) + for (x = 0;x < size;x++) + { + if (n(x,y) < min) min = n(x,y); + if (n(x,y) > max) max = n(x,y); + } + max -= min; + max++; + // normalize noise and copy to output + for (y = 0;y < size;y++) + for (x = 0;x < size;x++) + *noise++ = (qbyte) (((n(x,y) - min) * 256) / max); + free(noisebuf); +#undef n +} +void VectorVectors(const vec3_t forward, vec3_t right, vec3_t up) +{ + float d; + + right[0] = forward[2]; + right[1] = -forward[0]; + right[2] = forward[1]; + + d = DotProduct(forward, right); + right[0] -= d * forward[0]; + right[1] -= d * forward[1]; + right[2] -= d * forward[2]; + VectorNormalizeFast(right); + CrossProduct(right, forward, up); +} +#else +#include "cl_collision.h" +#endif + +#define MAX_PARTICLES 8192 // default max # of particles at one time #define ABSOLUTE_MIN_PARTICLES 512 // no fewer than this no matter what's on the command line typedef enum { - pt_static, pt_grav, pt_blob, pt_blob2, pt_bulletsmoke, pt_smoke, pt_snow, pt_rain, pt_spark, pt_bubble, pt_fade, pt_steam, pt_splash, pt_splashpuff, pt_flame, pt_blood, pt_oneframe, pt_lavasplash, pt_raindropsplash, pt_underwaterspark, pt_explosionsplash, pt_stardust + pt_static, pt_rain, pt_bubble, pt_blood, pt_grow } ptype_t; +#define PARTICLE_INVALID 0 +#define PARTICLE_BILLBOARD 1 +#define PARTICLE_BEAM 2 +#define PARTICLE_ORIENTED_DOUBLESIDED 3 + #define P_TEXNUM_FIRSTBIT 0 #define P_TEXNUM_BITS 6 #define P_ORIENTATION_FIRSTBIT (P_TEXNUM_FIRSTBIT + P_TEXNUM_BITS) #define P_ORIENTATION_BITS 2 #define P_FLAGS_FIRSTBIT (P_ORIENTATION_FIRSTBIT + P_ORIENTATION_BITS) -#define P_DYNLIGHT (1 << (P_FLAGS_FIRSTBIT + 0)) +//#define P_DYNLIGHT (1 << (P_FLAGS_FIRSTBIT + 0)) #define P_ADDITIVE (1 << (P_FLAGS_FIRSTBIT + 1)) typedef struct particle_s @@ -47,8 +184,10 @@ typedef struct particle_s float scalex; float scaley; float alpha; // 0-255 + float alphafade; // how much alpha reduces per second float time2; // used for various things (snow fluttering, for example) float bounce; // how much bounce-back from a surface the particle hits (0 = no physics, 1 = stop and slide, 2 = keep bouncing forever, 1.5 is typical) + float gravity; // how much gravity affects this particle (1.0 = normal gravity, 0.0 = none) vec3_t oldorg; vec3_t vel2; // used for snow fluttering (base velocity, wind for instance) float friction; // how much air friction affects this object (objects with a low mass/size ratio tend to get more air friction) @@ -93,36 +232,34 @@ static int particlepalette[256] = 0x8b0000,0xb30000,0xd70000,0xff0000,0xfff393,0xfff7c7,0xffffff,0x9f5b53 }; -static int explosparkramp[8] = {0x4b0700, 0x6f0f00, 0x931f07, 0xb7330f, 0xcf632b, 0xe3974f, 0xffe7b5, 0xffffff}; -//static int explounderwatersparkramp[8] = {0x00074b, 0x000f6f, 0x071f93, 0x0f33b7, 0x2b63cf, 0x4f97e3, 0xb5e7ff, 0xffffff}; +//static int explosparkramp[8] = {0x4b0700, 0x6f0f00, 0x931f07, 0xb7330f, 0xcf632b, 0xe3974f, 0xffe7b5, 0xffffff}; // these must match r_part.c's textures 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_rainsplash[16] = {8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23}; static const int tex_particle = 24; -static const int tex_rain = 25; +//static const int tex_rain = 25; static const int tex_bubble = 26; -//static const int tex_rocketglow = 27; static int cl_maxparticles; static int cl_numparticles; static particle_t *particles; static particle_t **freeparticles; // list used only in compacting particles array -//static renderparticle_t *cl_renderparticles; - -static cvar_t cl_particles = {CVAR_SAVE, "cl_particles", "1"}; -static cvar_t cl_particles_size = {CVAR_SAVE, "cl_particles_size", "1"}; -static cvar_t cl_particles_bloodshowers = {CVAR_SAVE, "cl_particles_bloodshowers", "1"}; -static cvar_t cl_particles_blood = {CVAR_SAVE, "cl_particles_blood", "1"}; -static cvar_t cl_particles_blood_size_min = {CVAR_SAVE, "cl_particles_blood_size_min", "5"}; -static cvar_t cl_particles_blood_size_max = {CVAR_SAVE, "cl_particles_blood_size_max", "10"}; -static cvar_t cl_particles_blood_alpha = {CVAR_SAVE, "cl_particles_blood_alpha", "0.5"}; -static cvar_t cl_particles_smoke = {CVAR_SAVE, "cl_particles_smoke", "1"}; -static cvar_t cl_particles_sparks = {CVAR_SAVE, "cl_particles_sparks", "1"}; -static cvar_t cl_particles_bubbles = {CVAR_SAVE, "cl_particles_bubbles", "1"}; -static cvar_t cl_particles_explosions = {CVAR_SAVE, "cl_particles_explosions", "0"}; +cvar_t cl_particles = {CVAR_SAVE, "cl_particles", "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_bulletimpacts = {CVAR_SAVE, "cl_particles_bulletimpacts", "1"}; +cvar_t cl_particles_smoke = {CVAR_SAVE, "cl_particles_smoke", "1"}; +cvar_t cl_particles_sparks = {CVAR_SAVE, "cl_particles_sparks", "1"}; +cvar_t cl_particles_bubbles = {CVAR_SAVE, "cl_particles_bubbles", "1"}; + +#ifndef WORKINGLQUAKE static mempool_t *cl_part_mempool; +#endif void CL_Particles_Clear(void) { @@ -141,7 +278,7 @@ void CL_Particles_Init (void) i = COM_CheckParm ("-particles"); - if (i) + if (i && i < com_argc - 1) { cl_maxparticles = (int)(atoi(com_argv[i+1])); if (cl_maxparticles < ABSOLUTE_MIN_PARTICLES) @@ -156,24 +293,25 @@ void CL_Particles_Init (void) Cvar_RegisterVariable (&cl_particles_size); Cvar_RegisterVariable (&cl_particles_bloodshowers); Cvar_RegisterVariable (&cl_particles_blood); - Cvar_RegisterVariable (&cl_particles_blood_size_min); - Cvar_RegisterVariable (&cl_particles_blood_size_max); + Cvar_RegisterVariable (&cl_particles_blood_size); Cvar_RegisterVariable (&cl_particles_blood_alpha); + Cvar_RegisterVariable (&cl_particles_bulletimpacts); Cvar_RegisterVariable (&cl_particles_smoke); Cvar_RegisterVariable (&cl_particles_sparks); Cvar_RegisterVariable (&cl_particles_bubbles); - Cvar_RegisterVariable (&cl_particles_explosions); +#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"); 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; - - // FIXME: r_refdef stuff should be allocated somewhere else? - //r_refdef.particles = cl_renderparticles = Mem_Alloc(cl_refdef_mempool, cl_maxparticles * sizeof(renderparticle_t)); } -#define particle(ptype, porientation, pcolor1, pcolor2, ptex, plight, padditive, pscalex, pscaley, palpha, ptime, pbounce, px, py, pz, pvx, pvy, pvz, ptime2, pvx2, pvy2, pvz2, pfriction, ppressure)\ +#define particle(ptype, porientation, pcolor1, pcolor2, ptex, plight, padditive, pscalex, pscaley, palpha, palphafade, ptime, pgravity, pbounce, px, py, pz, pvx, pvy, pvz, ptime2, pvx2, pvy2, pvz2, pfriction, ppressure)\ {\ if (cl_numparticles >= cl_maxparticles)\ return;\ @@ -184,8 +322,8 @@ void CL_Particles_Init (void) partflags = ((porientation) << P_ORIENTATION_FIRSTBIT) | ((ptex) << P_TEXNUM_FIRSTBIT);\ if (padditive)\ partflags |= P_ADDITIVE;\ - if (plight)\ - partflags |= P_DYNLIGHT;\ + /*if (plight)*/\ + /* partflags |= P_DYNLIGHT;*/\ tempcolor = (pcolor1);\ tempcolor2 = (pcolor2);\ cr2 = ((tempcolor2) >> 16) & 0xFF;\ @@ -208,14 +346,12 @@ void CL_Particles_Init (void) part->color[2] = cb2;\ part->color[3] = 0xFF;\ part->flags = partflags;\ - /*part->tex = (ptex);*/\ - /*part->orientation = (porientation);*/\ - /*part->dynlight = (plight);*/\ - /*part->additive = (padditive);*/\ 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);\ @@ -268,7 +404,11 @@ void CL_EntityParticles (entity_t *ent) forward[1] = cp*sy; forward[2] = -sp; - particle(pt_oneframe, PARTICLE_BILLBOARD, particlepalette[0x6f], particlepalette[0x6f], tex_particle, false, false, 2, 2, 255, 9999, 0, ent->render.origin[0] + m_bytenormals[i][0]*dist + forward[0]*beamlength, ent->render.origin[1] + m_bytenormals[i][1]*dist + forward[1]*beamlength, ent->render.origin[2] + m_bytenormals[i][2]*dist + forward[2]*beamlength, 0, 0, 0, 0, 0, 0, 0, 0, 0); +#ifdef WORKINGLQUAKE + particle(pt_static, PARTICLE_BILLBOARD, particlepalette[0x6f], particlepalette[0x6f], tex_particle, false, false, 2, 2, 255, 0, 0, 0, 0, ent->origin[0] + m_bytenormals[i][0]*dist + forward[0]*beamlength, ent->origin[1] + m_bytenormals[i][1]*dist + forward[1]*beamlength, ent->origin[2] + m_bytenormals[i][2]*dist + forward[2]*beamlength, 0, 0, 0, 0, 0, 0, 0, 0, 0); +#else + particle(pt_static, PARTICLE_BILLBOARD, particlepalette[0x6f], particlepalette[0x6f], tex_particle, false, false, 2, 2, 255, 0, 0, 0, 0, ent->render.origin[0] + m_bytenormals[i][0]*dist + forward[0]*beamlength, ent->render.origin[1] + m_bytenormals[i][1]*dist + forward[1]*beamlength, ent->render.origin[2] + m_bytenormals[i][2]*dist + forward[2]*beamlength, 0, 0, 0, 0, 0, 0, 0, 0, 0); +#endif } } @@ -277,16 +417,33 @@ void CL_ReadPointFile_f (void) { vec3_t org; int r, c; - char *pointfile, *pointfilepos, *t, tchar; - - pointfile = COM_LoadFile(va("maps/%s.pts", sv.name), true); + char *pointfile = NULL, *pointfilepos, *t, tchar; +#if WORKINGLQUAKE + char name[MAX_OSPATH]; + + sprintf (name,"maps/%s.pts", cl.worldmodel->name); + COM_FOpenFile (name, &f); + if (f) + { + int pointfilelength; + fseek(f, 0, SEEK_END); + pointfilelength = ftell(f); + fseek(f, 0, SEEK_SET); + pointfile = malloc(pointfilelength + 1); + fread(pointfile, 1, pointfilelength, f); + pointfile[pointfilelength] = 0; + fclose(f); + } +#else + pointfile = COM_LoadFile(va("maps/%s.pts", cl.worldmodel->name), true); +#endif if (!pointfile) { - Con_Printf ("couldn't open %s.pts\n", sv.name); + Con_Printf ("couldn't open %s.pts\n", cl.worldmodel->name); return; } - Con_Printf ("Reading %s.pts...\n", sv.name); + Con_Printf ("Reading %s.pts...\n", cl.worldmodel->name); c = 0; pointfilepos = pointfile; while (*pointfilepos) @@ -312,10 +469,14 @@ void CL_ReadPointFile_f (void) Con_Printf ("Not enough free particles\n"); break; } - particle(pt_static, PARTICLE_BILLBOARD, particlepalette[(-c)&15], particlepalette[(-c)&15], tex_particle, false, false, 2, 2, 255, 99999, 0, org[0], org[1], org[2], 0, 0, 0, 0, 0, 0, 0, 0, 0); + particle(pt_static, PARTICLE_BILLBOARD, particlepalette[(-c)&15], particlepalette[(-c)&15], tex_particle, false, false, 2, 2, 255, 0, 99999, 0, 0, org[0], org[1], org[2], 0, 0, 0, 0, 0, 0, 0, 0, 0); } +#ifdef WORKINGLQUAKE + free(pointfile); +#else Mem_Free(pointfile); +#endif Con_Printf ("%i points read\n", c); } @@ -328,8 +489,8 @@ Parse an effect out of the server message */ void CL_ParseParticleEffect (void) { - vec3_t org, dir; - int i, count, msgcount, color; + vec3_t org, dir; + int i, count, msgcount, color; for (i=0 ; i<3 ; i++) org[i] = MSG_ReadCoord (); @@ -352,101 +513,65 @@ CL_ParticleExplosion =============== */ -void CL_ParticleExplosion (vec3_t org, int smoke) +void CL_ParticleExplosion (vec3_t org) { - int i; - R_Stain(org, 96, 80, 80, 80, 128, 176, 176, 176, 128); - - i = Mod_PointInLeaf(org, cl.worldmodel)->contents; - if (i == CONTENTS_SLIME || i == CONTENTS_WATER) - for (i = 0;i < 128;i++) - particle(pt_bubble, PARTICLE_BILLBOARD, 0x808080, 0xFFFFFF, tex_bubble, false, true, 2, 2, 255, 9999, 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, 0, 0); + int i, k; + //vec3_t v; + //vec3_t v2; + if (cl_stainmaps.integer) + R_Stain(org, 96, 80, 80, 80, 64, 176, 176, 176, 64); - if (cl_particles.integer && cl_particles_explosions.integer) + i = Mod_PointContents(org, cl.worldmodel); + if ((i == CONTENTS_SLIME || i == CONTENTS_WATER) && cl_particles.integer && cl_particles_bubbles.integer) { - int j, k; - float f; - vec3_t v, end, ang; - qbyte noise1[32*32], noise2[32*32]; - - VectorClear(end); // hush MSVC - i = Mod_PointInLeaf(org, cl.worldmodel)->contents; - if (i == CONTENTS_SLIME || i == CONTENTS_WATER) + for (i = 0;i < 128;i++) { - //for (i = 0;i < 128;i++) - // particle(pt_bubble, PARTICLE_BILLBOARD, 0x808080, 0xFFFFFF, tex_bubble, false, true, 2, 2, 255, 9999, 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, 0, 0); - - ang[2] = lhrandom(0, 360); - fractalnoisequick(noise1, 32, 4); - fractalnoisequick(noise2, 32, 8); - for (i = 0;i < 32;i++) - { - for (j = 0;j < 32;j++) - { - VectorRandom(v); - VectorMA(org, 16, v, v); - TraceLine(org, v, end, NULL, 0, true); - ang[0] = (j + 0.5f) * (360.0f / 32.0f); - ang[1] = (i + 0.5f) * (360.0f / 32.0f); - AngleVectors(ang, v, NULL, NULL); - f = noise1[j*32+i] * 1.5f; - VectorScale(v, f, v); - k = noise2[j*32+i] * 0x010101; - particle(pt_underwaterspark, PARTICLE_BILLBOARD, k, k, tex_smoke[rand()&7], false, true, 10, 10, lhrandom(128, 255), 9999, 1.5, end[0], end[1], end[2], v[0], v[1], v[2], 512.0f, 0, 0, 0, 2, 0); - VectorScale(v, 0.75, v); - k = explosparkramp[(noise2[j*32+i] >> 5)]; - particle(pt_underwaterspark, PARTICLE_BILLBOARD, k, k, tex_particle, false, true, 10, 10, lhrandom(128, 255), 9999, 1.5, end[0], end[1], end[2], v[0], v[1], v[2], 512.0f, 0, 0, 0, 2, 0); - } - } + particle(pt_bubble, PARTICLE_BILLBOARD, 0x404040, 0x808080, tex_bubble, false, true, 2, 2, lhrandom(128, 255), 256, 9999, -0.25, 1.5, org[0] + lhrandom(-16, 16), org[1] + lhrandom(-16, 16), org[2] + lhrandom(-16, 16), lhrandom(-96, 96), lhrandom(-96, 96), lhrandom(-96, 96), 0, 0, 0, 0, (1.0 / 16.0), 0); } - else + } + else + { + /* + // LordHavoc: smoke effect similar to UT2003, chews fillrate too badly up close + // smoke puff + if (cl_particles_smoke.integer) { - ang[2] = lhrandom(0, 360); - fractalnoisequick(noise1, 32, 4); - fractalnoisequick(noise2, 32, 8); - for (i = 0;i < 32;i++) + for (i = 0;i < 64;i++) { - for (j = 0;j < 32;j++) +#ifdef WORKINGLQUAKE + v2[0] = lhrandom(-64, 64); + v2[1] = lhrandom(-64, 64); + v2[2] = lhrandom(-8, 24); +#else + for (k = 0;k < 16;k++) { - VectorRandom(v); - VectorMA(org, 16, v, v); - TraceLine(org, v, end, NULL, 0, true); - ang[0] = (j + 0.5f) * (360.0f / 32.0f); - ang[1] = (i + 0.5f) * (360.0f / 32.0f); - AngleVectors(ang, v, NULL, NULL); - f = noise1[j*32+i] * 1.5f; - VectorScale(v, f, v); - k = noise2[j*32+i] * 0x010101; - particle(pt_spark, PARTICLE_BILLBOARD, k, k, tex_smoke[rand()&7], false, true, 10, 10, lhrandom(128, 255), 9999, 1.5, end[0], end[1], end[2], v[0], v[1], v[2] + 160.0f, 512.0f, 0, 0, 0, 2, 0); - VectorScale(v, 0.75, v); - k = explosparkramp[(noise2[j*32+i] >> 5)]; - particle(pt_spark, PARTICLE_BILLBOARD, k, k, tex_particle, false, true, 10, 10, lhrandom(128, 255), 9999, 1.5, end[0], end[1], end[2], v[0], v[1], v[2] + 160.0f, 512.0f, 0, 0, 0, 2, 0); - // VectorRandom(v); - // VectorScale(v, 384, v); - // particle(pt_spark, PARTICLE_BILLBOARD, explosparkramp[rand()&7], tex_particle, false, true, 2, 2, lhrandom(16, 255), 9999, 1.5, end[0], end[1], end[2], v[0], v[1], v[2] + 160.0f, 512.0f, 0, 0, 0, 2, 0); + 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) + break; } + VectorSubtract(v2, org, v2); +#endif + VectorScale(v2, 2.0f, v2); + particle(pt_static, PARTICLE_BILLBOARD, 0x101010, 0x202020, tex_smoke[rand()&7], true, true, 12, 12, 255, 512, 9999, 0, 0, org[0], org[1], org[2], v2[0], v2[1], v2[2], 0, 0, 0, 0, 0, 0); } } - } - else - { - /* - int i; - vec3_t v; - for (i = 0;i < 256;i++) + */ + + if (cl_particles_sparks.integer) { - do + // sparks + for (i = 0;i < 256;i++) { - VectorRandom(v); + k = particlepalette[0x68 + (rand() & 7)]; + particle(pt_static, PARTICLE_BEAM, k, k, tex_particle, false, true, 1.5f, 0.05f, lhrandom(0, 255), 512, 9999, 1, 0, org[0], org[1], org[2], lhrandom(-192, 192), lhrandom(-192, 192), lhrandom(-192, 192) + 160, 0, 0, 0, 0, 0, 0); } - while(DotProduct(v,v) < 0.75); - VectorScale(v, 512, v); - k = explosparkramp[rand()&7]; - particle(pt_spark, PARTICLE_BILLBOARD, k, k, tex_particle, false, true, 4, 4, 255, 9999, 1.5, org[0], org[1], org[2], v[0], v[1], v[2] + 160.0f, 512.0f, 0, 0, 0, 2, 0); } - */ - R_NewExplosion(org); } + + if (cl_explosions.integer) + R_NewExplosion(org); } /* @@ -463,7 +588,7 @@ void CL_ParticleExplosion2 (vec3_t org, int colorStart, int colorLength) for (i = 0;i < 512;i++) { k = particlepalette[colorStart + (i % colorLength)]; - particle(pt_fade, PARTICLE_BILLBOARD, k, k, tex_particle, false, false, 1.5, 1.5, 255, 0.3, 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), 384, 0, 0, 0, 1, 0); + particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, false, 1.5, 1.5, 255, 384, 0.3, 0, 0, org[0] + lhrandom(-8, 8), org[1] + lhrandom(-8, 8), org[2] + lhrandom(-8, 8), lhrandom(-192, 192), lhrandom(-192, 192), lhrandom(-192, 192), 0, 0, 0, 0, 1, 0); } } @@ -475,18 +600,11 @@ CL_BlobExplosion */ void CL_BlobExplosion (vec3_t org) { - //int i; - if (!cl_particles.integer) return; + if (cl_stainmaps.integer) + R_Stain(org, 96, 80, 80, 80, 64, 176, 176, 176, 64); - R_Stain(org, 96, 80, 80, 80, 128, 176, 176, 176, 128); - //R_Stain(org, 96, 96, 64, 96, 128, 160, 128, 160, 128); - - R_NewExplosion(org); - - //for (i = 0;i < 256;i++) - // particle(pt_blob , PARTICLE_BILLBOARD, particlepalette[ 66+(rand()%6)], tex_particle, false, true, 4, 4, 255, 9999, 0, org[0] + lhrandom(-16, 16), org[1] + lhrandom(-16, 16), org[2] + lhrandom(-16, 16), lhrandom(-4, 4), lhrandom(-4, 4), lhrandom(-128, 128), 0, 0, 0, 0, 0, 0); - //for (i = 0;i < 256;i++) - // particle(pt_blob2, PARTICLE_BILLBOARD, particlepalette[150+(rand()%6)], tex_particle, false, true, 4, 4, 255, 9999, 0, org[0] + lhrandom(-16, 16), org[1] + lhrandom(-16, 16), org[2] + lhrandom(-16, 16), lhrandom(-4, 4), lhrandom(-4, 4), lhrandom(-128, 128), 0, 0, 0, 0, 0, 0); + if (cl_explosions.integer) + R_NewExplosion(org); } /* @@ -498,17 +616,17 @@ CL_RunParticleEffect void CL_RunParticleEffect (vec3_t org, vec3_t dir, int color, int count) { int k; - if (!cl_particles.integer) return; if (count == 1024) { - CL_ParticleExplosion(org, false); + CL_ParticleExplosion(org); return; } + if (!cl_particles.integer) return; while (count--) { k = particlepalette[color + (rand()&7)]; - particle(pt_fade, PARTICLE_BILLBOARD, k, k, tex_particle, false, false, 1, 1, 128, 9999, 0, org[0] + lhrandom(-8, 8), org[1] + lhrandom(-8, 8), org[2] + lhrandom(-8, 8), lhrandom(-15, 15), lhrandom(-15, 15), lhrandom(-15, 15), 384, 0, 0, 0, 0, 0); + particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, false, 1, 1, 255, 512, 9999, 0, 0, org[0] + lhrandom(-8, 8), org[1] + lhrandom(-8, 8), org[2] + lhrandom(-8, 8), lhrandom(-15, 15), lhrandom(-15, 15), lhrandom(-15, 15), 0, 0, 0, 0, 0, 0); } } @@ -523,35 +641,44 @@ void CL_SparkShower (vec3_t org, vec3_t dir, int count) int k; if (!cl_particles.integer) return; - R_Stain(org, 32, 96, 96, 96, 32, 128, 128, 128, 32); - - // smoke puff - if (cl_particles_smoke.integer) - particle(pt_bulletsmoke, PARTICLE_BILLBOARD, 0xA0A0A0, 0xFFFFFF, tex_smoke[rand()&7], true, true, 2, 2, 255, 9999, 0, org[0], org[1], org[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(0, 16), 0, 0, 0, 0, 0, 0); + if (cl_stainmaps.integer) + R_Stain(org, 32, 96, 96, 96, 24, 128, 128, 128, 24); - if (cl_particles_sparks.integer) + if (cl_particles_bulletimpacts.integer) { - // sparks - while(count--) + // smoke puff + if (cl_particles_smoke.integer) + { + k = count / 4; + while(k--) + { + particle(pt_grow, PARTICLE_BILLBOARD, 0x101010, 0x202020, tex_smoke[rand()&7], true, true, 3, 3, 255, 1024, 9999, -0.2, 0, org[0] + 0.125f * lhrandom(-count, count), org[1] + 0.125f * lhrandom (-count, count), org[2] + 0.125f * lhrandom(-count, count), lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(0, 16), 15, 0, 0, 0, 0, 0); + } + } + + if (cl_particles_sparks.integer) { - k = particlepalette[0x68 + (rand() & 7)]; - particle(pt_spark, PARTICLE_BILLBOARD, k, k, tex_particle, false, true, 1, 1, lhrandom(64, 128), 9999, 0, org[0], org[1], org[2], lhrandom(-64, 64) + dir[0], lhrandom(-64, 64) + dir[1], lhrandom(0, 128) + dir[2], 480, 0, 0, 0, 1, 0); + // sparks + while(count--) + { + k = particlepalette[0x68 + (rand() & 7)]; + particle(pt_static, PARTICLE_BEAM, k, k, tex_particle, false, true, 0.4f, 0.015f, lhrandom(64, 255), 512, 9999, 1, 0, org[0], org[1], org[2], lhrandom(-64, 64) + dir[0], lhrandom(-64, 64) + dir[1], lhrandom(0, 128) + dir[2], 0, 0, 0, 0, 0, 0); + } } } } void CL_PlasmaBurn (vec3_t org) { - if (!cl_particles.integer) return; - - R_Stain(org, 48, 96, 96, 96, 48, 128, 128, 128, 48); + if (cl_stainmaps.integer) + R_Stain(org, 48, 96, 96, 96, 32, 128, 128, 128, 32); } +static float bloodcount = 0; void CL_BloodPuff (vec3_t org, vec3_t vel, int count) { - float r, s; + float s, r, a; // bloodcount is used to accumulate counts too small to cause a blood particle - static int bloodcount = 0; if (!cl_particles.integer) return; if (!cl_particles_blood.integer) return; @@ -560,18 +687,19 @@ void CL_BloodPuff (vec3_t org, vec3_t vel, int count) if (count > 1000) count = 1000; bloodcount += count; + r = cl_particles_blood_size.value; + a = cl_particles_blood_alpha.value * 255; while(bloodcount > 0) { - r = lhrandom(cl_particles_blood_size_min.value, cl_particles_blood_size_max.value); - particle(pt_blood, PARTICLE_BILLBOARD, 0x000000, 0x200000, tex_smoke[rand()&7], true, false, r, r, cl_particles_blood_alpha.value * 255, 9999, -1, org[0], org[1], org[2], vel[0] + lhrandom(-s, s), vel[1] + lhrandom(-s, s), vel[2] + lhrandom(-s, s), 0, 0, 0, 0, 1, 0); + particle(pt_blood, PARTICLE_BILLBOARD, 0x000000, 0x200000, tex_smoke[rand()&7], true, false, r, r, a, a * 0.5, 9999, 0, -1, org[0], org[1], org[2], vel[0] + lhrandom(-s, s), vel[1] + lhrandom(-s, s), vel[2] + lhrandom(-s, s), 0, 0, 0, 0, 1, 0); bloodcount -= r; } } void CL_BloodShower (vec3_t mins, vec3_t maxs, float velspeed, int count) { - float c; float r; + float a; vec3_t diff, center, velscale; if (!cl_particles.integer) return; if (!cl_particles_bloodshowers.integer) return; @@ -586,8 +714,10 @@ void CL_BloodShower (vec3_t mins, vec3_t maxs, float velspeed, int count) velscale[1] = velspeed * 2.0 / diff[1]; velscale[2] = velspeed * 2.0 / diff[2]; - c = count * 5; - while (c > 0) + 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]); @@ -596,9 +726,8 @@ void CL_BloodShower (vec3_t mins, vec3_t maxs, float velspeed, int count) vel[0] = (org[0] - center[0]) * velscale[0]; vel[1] = (org[1] - center[1]) * velscale[1]; vel[2] = (org[2] - center[2]) * velscale[2]; - r = lhrandom(cl_particles_blood_size_min.value, cl_particles_blood_size_max.value); - c -= r; - particle(pt_blood, PARTICLE_BILLBOARD, 0x000000, 0x200000, tex_smoke[rand()&7], true, false, r, r, cl_particles_blood_alpha.value * 255, 9999, -1, org[0], org[1], org[2], vel[0], vel[1], vel[2], 0, 0, 0, 0, 1, 0); + bloodcount -= r; + particle(pt_blood, PARTICLE_BILLBOARD, 0x000000, 0x200000, tex_smoke[rand()&7], true, false, r, r, a, a * 0.5, 9999, 0, -1, org[0], org[1], org[2], vel[0], vel[1], vel[2], 0, 0, 0, 0, 1, 0); } } @@ -614,15 +743,14 @@ void CL_ParticleCube (vec3_t mins, vec3_t maxs, vec3_t dir, int count, int color while (count--) { k = particlepalette[colorbase + (rand()&3)]; - particle(gravity ? pt_grav : pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, false, 2, 2, 255, lhrandom(1, 2), 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, false, 2, 2, 255, 0, lhrandom(1, 2), gravity ? 1 : 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(mins[2], maxs[2]), dir[0] + lhrandom(-randomvel, randomvel), dir[1] + lhrandom(-randomvel, randomvel), dir[2] + lhrandom(-randomvel, randomvel), 0, 0, 0, 0, 0, 0); } } void CL_ParticleRain (vec3_t mins, vec3_t maxs, vec3_t dir, int count, int colorbase, int type) { int k; - vec3_t vel; - float t, z; + float t, z, minz, maxz; if (!cl_particles.integer) return; if (maxs[0] <= mins[0]) {t = mins[0];mins[0] = maxs[0];maxs[0] = t;} if (maxs[1] <= mins[1]) {t = mins[1];mins[1] = maxs[1];maxs[1] = t;} @@ -640,6 +768,11 @@ void CL_ParticleRain (vec3_t mins, vec3_t maxs, vec3_t dir, int count, int color if (t < 0 || t > 2) // sanity check t = 2; + minz = z - fabs(dir[2]) * 0.1; + maxz = z + fabs(dir[2]) * 0.1; + minz = bound(mins[2], minz, maxs[2]); + maxz = bound(mins[2], maxz, maxs[2]); + switch(type) { case 0: @@ -647,21 +780,15 @@ void CL_ParticleRain (vec3_t mins, vec3_t maxs, vec3_t dir, int count, int color while(count--) { - vel[0] = dir[0] + lhrandom(-16, 16); - vel[1] = dir[1] + lhrandom(-16, 16); - vel[2] = dir[2] + lhrandom(-32, 32); k = particlepalette[colorbase + (rand()&3)]; - particle(pt_rain, PARTICLE_UPRIGHT_FACING, k, k, tex_particle, true, true, 1, 64, 64, t, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), z, vel[0], vel[1], vel[2], 0, vel[0], vel[1], vel[2], 0, 0); + particle(pt_rain, PARTICLE_BEAM, k, k, tex_particle, true, true, 0.5, 0.02, lhrandom(8, 16), 0, t, 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz), dir[0], dir[1], dir[2], cl.time + 9999, dir[0], dir[1], dir[2], 0, 0); } break; case 1: while(count--) { - vel[0] = dir[0] + lhrandom(-16, 16); - vel[1] = dir[1] + lhrandom(-16, 16); - vel[2] = dir[2] + lhrandom(-32, 32); k = particlepalette[colorbase + (rand()&3)]; - particle(pt_snow, PARTICLE_BILLBOARD, k, k, tex_particle, false, true, 2, 2, 255, t, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), z, vel[0], vel[1], vel[2], 0, vel[0], vel[1], vel[2], 0, 0); + particle(pt_rain, PARTICLE_BILLBOARD, k, k, tex_particle, false, true, 1, 1, lhrandom(64, 128), 0, t, 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz), dir[0], dir[1], dir[2], 0, dir[0], dir[1], dir[2], 0, 0); } break; default: @@ -674,7 +801,6 @@ void CL_Stardust (vec3_t mins, vec3_t maxs, int count) int k; float t; vec3_t o, v, center; - //Con_Printf("CL_Stardust ('%f %f %f', '%f %f %f', %d);\n", mins[0], mins[1], mins[2], maxs[0], maxs[1], maxs[2], count); if (!cl_particles.integer) return; if (maxs[0] <= mins[0]) {t = mins[0];mins[0] = maxs[0];maxs[0] = t;} @@ -695,7 +821,7 @@ void CL_Stardust (vec3_t mins, vec3_t maxs, int count) VectorNormalizeFast(v); VectorScale(v, 100, v); v[2] += sv_gravity.value * 0.15f; - particle(pt_stardust, PARTICLE_BILLBOARD, 0x903010, 0xFFD030, tex_particle, false, true, 1.5, 1.5, lhrandom(64, 128), 9999, 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, true, 1.5, 1.5, lhrandom(64, 128), 128, 9999, 1, 0, o[0], o[1], o[2], v[0], v[1], v[2], 0, 0, 0, 0, 0, 0); } } @@ -711,7 +837,9 @@ void CL_FlameCube (vec3_t mins, vec3_t maxs, int count) while (count--) { k = particlepalette[224 + (rand()&15)]; - particle(pt_flame, PARTICLE_BILLBOARD, k, k, tex_particle, false, true, 4, 4, lhrandom(64, 128), 9999, 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, true, 4, 4, lhrandom(64, 128), 384, 9999, -1, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(mins[2], maxs[2]), lhrandom(-32, 32), lhrandom(-32, 32), lhrandom(0, 64), 0, 0, 0, 0, 1, 0); + if (count & 1) + particle(pt_static, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], false, true, 6, 6, lhrandom(48, 96), 64, 9999, 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(mins[2], maxs[2]), lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(0, 32), 0, 0, 0, 0, 0, 0); } } @@ -723,7 +851,7 @@ void CL_Flames (vec3_t org, vec3_t vel, int count) while (count--) { k = particlepalette[224 + (rand()&15)]; - particle(pt_flame, PARTICLE_BILLBOARD, k, k, tex_particle, false, true, 4, 4, lhrandom(64, 128), 9999, 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, true, 4, 4, lhrandom(64, 128), 384, 9999, -1, 1.1, org[0], org[1], org[2], vel[0] + lhrandom(-128, 128), vel[1] + lhrandom(-128, 128), vel[2] + lhrandom(-128, 128), 0, 0, 0, 0, 1, 0); } } @@ -754,7 +882,7 @@ void CL_LavaSplash (vec3_t origin) org[2] = origin[2] + lhrandom(0, 64); vel = lhrandom(50, 120) / VectorLength(dir); // normalize and scale k = particlepalette[224 + (rand()&7)]; - particle(pt_lavasplash, PARTICLE_BILLBOARD, k, k, tex_particle, false, true, 7, 7, 255, 9999, 0, org[0], org[1], org[2], dir[0] * vel, dir[1] * vel, dir[2] * vel, 0, 0, 0, 0, 0, 0); + particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, true, 7, 7, 255, 192, 9999, 0.05, 0, org[0], org[1], org[2], dir[0] * vel, dir[1] * vel, dir[2] * vel, 0, 0, 0, 0, 0, 0); } } } @@ -765,143 +893,132 @@ CL_TeleportSplash =============== */ -void CL_TeleportSplash (vec3_t org) +#if WORKINGLQUAKE +void R_TeleportSplash (vec3_t org) { - int i, j, k; + int i, j, k; 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_fade, PARTICLE_BILLBOARD, 0xA0A0A0, 0xFFFFFF, tex_particle, false, true, 1.5, 1.5, lhrandom(64, 128), 9999, 0, org[0] + i + lhrandom(0, 8), org[1] + j + lhrandom(0, 8), org[2] + k + lhrandom(0, 8), i*2 + lhrandom(-12.5, 12.5), j*2 + lhrandom(-12.5, 12.5), k*2 + lhrandom(27.5, 52.5), 384.0f, 0, 0, 0, 1, 0); - particle(pt_fade, PARTICLE_BILLBOARD, 0xA0A0A0, 0xFFFFFF, tex_particle, false, true, 10, 10, lhrandom(64, 128), 9999, 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), 256.0f, 0, 0, 0, 1, 0); + particle(pt_static, PARTICLE_BILLBOARD, 0xA0A0A0, 0xFFFFFF, tex_particle, false, true, 10, 10, lhrandom(64, 128), 256, 9999, 0, 0, org[0] + i + lhrandom(0, 8), org[1] + j + lhrandom(0, 8), org[2] + k + lhrandom(0, 8), lhrandom(-64, 64), lhrandom(-64, 64), lhrandom(-256, 256), 0, 0, 0, 0, 1, 0); } +#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) +#endif { - vec3_t vec, dir, vel, pos; - float len, dec, speed; - int contents, bubbles; - if (!cl_particles.integer) return; + vec3_t vec, dir, vel, pos; + float len, dec, speed, r; + int contents, smoke, blood, bubbles; VectorSubtract(end, start, dir); VectorNormalize(dir); - //if (type == 0 && host_frametime != 0) // rocket glow - // particle(pt_oneframe, PARTICLE_BILLBOARD, 0xFFFFFF, 0xFFFFFF, tex_rocketglow, false, true, 24, 24, 255, 9999, 0, end[0] - 12 * dir[0], end[1] - 12 * dir[1], end[2] - 12 * dir[2], 0, 0, 0, 0, 0, 0, 0, 0, 0); - VectorSubtract (end, start, vec); +#ifdef WORKINGLQUAKE + len = VectorNormalize (vec); + dec = 0; + speed = 1.0f / cl.frametime; + VectorSubtract(end, start, vel); +#else len = VectorNormalizeLength (vec); dec = -ent->persistent.trail_time; ent->persistent.trail_time += len; if (ent->persistent.trail_time < 0.01f) return; + // if we skip out, leave it reset + ent->persistent.trail_time = 0.0f; + speed = 1.0f / (ent->state_current.time - ent->state_previous.time); VectorSubtract(ent->state_current.origin, ent->state_previous.origin, vel); +#endif VectorScale(vel, speed, vel); // advance into this frame to reach the first puff location VectorMA(start, dec, vec, pos); len -= dec; - // if we skip out, leave it reset - ent->persistent.trail_time = 0.0f; - - contents = Mod_PointInLeaf(pos, cl.worldmodel)->contents; + contents = Mod_PointContents(pos, cl.worldmodel); if (contents == CONTENTS_SKY || contents == CONTENTS_LAVA) return; - bubbles = (contents == CONTENTS_WATER || contents == CONTENTS_SLIME); + 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); while (len >= 0) { switch (type) { case 0: // rocket trail - if (!cl_particles_smoke.integer) - return; - //dec = 5; - //particle(pt_fade, PARTICLE_BILLBOARD, 0x202020, 0x404040, tex_particle, true, false, dec, dec, 128, 9999, 0, pos[0], pos[1], pos[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 256.0f, 0, 0, 0, 0, 0); - dec = 6; - particle(pt_fade, PARTICLE_BILLBOARD, 0x202020, 0x404040, tex_smoke[rand()&7], true, true, dec, dec, 128, 9999, 0, pos[0], pos[1], pos[2], lhrandom(-5, 5), lhrandom(-5, 5), lhrandom(-5, 5), 256.0f, 0, 0, 0, 0, 0); - //particle(pt_fade, PARTICLE_BILLBOARD, 0x202020, 0x404040, tex_smoke[rand()&7], false, true, dec, dec, 128, 9999, 0, pos[0], pos[1], pos[2], lhrandom(-10, 10), lhrandom(-10, 10), lhrandom(-10, 10), 128.0f, 0, 0, 0, 0, 0); - //dec = 10; - //particle(pt_smoke, PARTICLE_BILLBOARD, 0x202020, 0x404040, tex_smoke[rand()&7], false, true, 2, 2, 160, 9999, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, 0, 0); - if (bubbles && cl_particles_bubbles.integer) + dec = 3; + if (smoke) { - particle(pt_bubble, PARTICLE_BILLBOARD, 0x404040, 0x808080, tex_bubble, false, true, 2, 2, 255, 9999, 1.5, pos[0], pos[1], pos[2], lhrandom(-16, 16), lhrandom(-16, 16), lhrandom(-16, 16), 0, 0, 0, 0, 0, 0); - //particle(pt_bubble, PARTICLE_BILLBOARD, 0x404040, 0x808080, tex_bubble, false, true, 2, 2, 255, 9999, 1.5, pos[0], pos[1], pos[2], lhrandom(-16, 16), lhrandom(-16, 16), lhrandom(-16, 16), 0, 0, 0, 0, 0, 0); + particle(pt_grow, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], false, true, dec, dec, 32, 64, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-5, 5), lhrandom(-5, 5), lhrandom(-5, 5), 6, 0, 0, 0, 0, 0); + particle(pt_static, PARTICLE_BILLBOARD, 0x801010, 0xFFA020, tex_smoke[rand()&7], false, true, dec, dec, 128, 768, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-20, 20), lhrandom(-20, 20), lhrandom(-20, 20), 0, 0, 0, 0, 0, 0); } - else + if (bubbles) { - //particle(pt_spark, PARTICLE_BILLBOARD, particlepalette[0x68 + (rand() & 7)], tex_particle, false, true, 2, 2, lhrandom(128, 255), 9999, 1.5, pos[0], pos[1], pos[2], lhrandom(-64, 64), lhrandom(-64, 64), lhrandom(-64, 64), 512.0f, 0, 0, 0, 1, 0); - //particle(pt_spark, PARTICLE_BILLBOARD, particlepalette[0x68 + (rand() & 7)], tex_particle, false, true, 2, 2, lhrandom(128, 255), 9999, 1.5, pos[0], pos[1], pos[2], lhrandom(-64, 64), lhrandom(-64, 64), lhrandom(-64, 64), 512.0f, 0, 0, 0, 1, 0); - //particle(pt_spark, PARTICLE_BILLBOARD, particlepalette[0x68 + (rand() & 7)], tex_particle, false, true, 1, 1, lhrandom(128, 255), 9999, 1.5, pos[0], pos[1], pos[2], lhrandom(-64, 64) - vel[0] * 0.0625, lhrandom(-64, 64) - vel[1] * 0.0625, lhrandom(-64, 64) - vel[2] * 0.0625, 512.0f, 0, 0, 0, 1, 0); - //particle(pt_spark, PARTICLE_BILLBOARD, particlepalette[0x68 + (rand() & 7)], tex_particle, false, true, 1, 1, lhrandom(128, 255), 9999, 1.5, pos[0], pos[1], pos[2], lhrandom(-64, 64) - vel[0] * 0.0625, lhrandom(-64, 64) - vel[1] * 0.0625, lhrandom(-64, 64) - vel[2] * 0.0625, 512.0f, 0, 0, 0, 1, 0); - //particle(pt_spark, PARTICLE_BILLBOARD, particlepalette[0x68 + (rand() & 7)], tex_particle, false, true, 1, 1, lhrandom(128, 255), 9999, 1.5, pos[0], pos[1], pos[2], lhrandom(-64, 64) - vel[0] * 0.0625, lhrandom(-64, 64) - vel[1] * 0.0625, lhrandom(-64, 64) - vel[2] * 0.0625, 512.0f, 0, 0, 0, 1, 0); - //particle(pt_spark, PARTICLE_BILLBOARD, particlepalette[0x68 + (rand() & 7)], tex_particle, false, true, 1, 1, lhrandom(128, 255), 9999, 1.5, pos[0], pos[1], pos[2], lhrandom(-64, 64) - vel[0] * 0.0625, lhrandom(-64, 64) - vel[1] * 0.0625, lhrandom(-64, 64) - vel[2] * 0.0625, 512.0f, 0, 0, 0, 1, 0); + r = lhrandom(1, 2); + particle(pt_bubble, PARTICLE_BILLBOARD, 0x404040, 0x808080, tex_bubble, false, true, r, r, lhrandom(64, 255), 256, 9999, -0.25, 1.5, pos[0], pos[1], pos[2], lhrandom(-16, 16), lhrandom(-16, 16), lhrandom(-16, 16), 0, 0, 0, 0, (1.0 / 16.0), 0); } break; case 1: // grenade trail // FIXME: make it gradually stop smoking - if (!cl_particles_smoke.integer) - return; - //dec = 5; - //particle(pt_fade, PARTICLE_BILLBOARD, 0x202020, 0x404040, tex_particle, true, false, dec, dec, 128, 9999, 0, pos[0], pos[1], pos[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 256.0f, 0, 0, 0, 0, 0); - dec = 6; - particle(pt_fade, PARTICLE_BILLBOARD, 0x202020, 0x404040, tex_smoke[rand()&7], true, true, dec, dec, 128, 9999, 0, pos[0], pos[1], pos[2], lhrandom(-5, 5), lhrandom(-5, 5), lhrandom(-5, 5), 256.0f, 0, 0, 0, 0, 0); - //particle(pt_smoke, PARTICLE_BILLBOARD, 0x202020, 0x404040, tex_smoke[rand()&7], false, true, 2, 2, 160, 9999, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, 0, 0); - if (bubbles && cl_particles_bubbles.integer) + dec = 3; + if (cl_particles.integer && cl_particles_smoke.integer) { - particle(pt_bubble, PARTICLE_BILLBOARD, 0x404040, 0x808080, tex_bubble, false, true, 2, 2, 255, 9999, 1.5, pos[0], pos[1], pos[2], lhrandom(-16, 16), lhrandom(-16, 16), lhrandom(-16, 16), 0, 0, 0, 0, 0, 0); - //particle(pt_bubble, PARTICLE_BILLBOARD, c * 2, tex_bubble, false, true, 2, 2, 255, 9999, 1.5, pos[0], pos[1], pos[2], lhrandom(-16, 16), lhrandom(-16, 16), lhrandom(-16, 16), 0, 0, 0, 0, 0, 0); + particle(pt_static, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], false, true, dec, dec, 32, 96, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-5, 5), lhrandom(-5, 5), lhrandom(-5, 5), 0, 0, 0, 0, 0, 0); } break; case 2: // blood - if (!cl_particles_blood.integer) - return; - dec = lhrandom(cl_particles_blood_size_min.value, cl_particles_blood_size_max.value); - particle(pt_blood, PARTICLE_BILLBOARD, 0x000000, 0x200000, tex_smoke[rand()&7], true, false, dec, dec, cl_particles_blood_alpha.value * 255.0f, 9999, -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, 0x000000, 0x200000, tex_smoke[rand()&7], true, false, dec, dec, cl_particles_blood_alpha.value * 255.0f, 9999, -1, pos[0], pos[1], pos[2], lhrandom(-64, 64), lhrandom(-64, 64), lhrandom(-64, 64), 0, 0, 0, 0, 1, 0); - //particle(pt_blood, PARTICLE_BILLBOARD, 0x000000, 0x200000, tex_particle, true, false, dec, dec, cl_particles_blood_alpha.value * 255.0f, 9999, -1, pos[0], pos[1], pos[2], lhrandom(-64, 64), lhrandom(-64, 64), lhrandom(-64, 64), 0, 0, 0, 0, 1, 0); - break; - case 4: // slight blood - if (!cl_particles_blood.integer) - return; - dec = lhrandom(cl_particles_blood_size_min.value, cl_particles_blood_size_max.value); - particle(pt_blood, PARTICLE_BILLBOARD, 0x000000, 0x200000, tex_smoke[rand()&7], true, false, dec, dec, cl_particles_blood_alpha.value * 255.0f, 9999, -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, 0x000000, 0x200000, tex_smoke[rand()&7], true, false, dec, dec, cl_particles_blood_alpha.value * 128.0f, 9999, -1, pos[0], pos[1], pos[2], lhrandom(-64, 64), lhrandom(-64, 64), lhrandom(-64, 64), 0, 0, 0, 0, 1, 0); - //particle(pt_blood, PARTICLE_BILLBOARD, 0x000000, 0x200000, tex_particle, true, false, dec, dec, cl_particles_blood_alpha.value * 128.0f, 9999, -1, pos[0], pos[1], pos[2], lhrandom(-64, 64), lhrandom(-64, 64), lhrandom(-64, 64), 0, 0, 0, 0, 1, 0); + dec = cl_particles_blood_size.value; + if (blood) + { + particle(pt_blood, PARTICLE_BILLBOARD, 0x100000, 0x280000, tex_smoke[rand()&7], true, false, dec, dec, cl_particles_blood_alpha.value * 255.0f, cl_particles_blood_alpha.value * 255.0f * 0.5, 9999, 0, -1, pos[0], pos[1], pos[2], vel[0] * 0.5f + lhrandom(-64, 64), vel[1] * 0.5f + lhrandom(-64, 64), vel[2] * 0.5f + lhrandom(-64, 64), 0, 0, 0, 0, 1, 0); + } break; case 3: // green tracer dec = 6; - //particle(pt_fade, PARTICLE_BILLBOARD, 0x373707, 0x373707, tex_particle, false, true, dec, dec, 128, 9999, 0, pos[0], pos[1], pos[2], 0, 0, 0, 384.0f, 0, 0, 0, 0, 0); - particle(pt_fade, PARTICLE_BILLBOARD, 0x373707, 0x373707, tex_particle, false, true, dec, dec, 128, 9999, 0, pos[0], pos[1], pos[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 384.0f, 0, 0, 0, 0, 0); + if (smoke) + { + particle(pt_static, PARTICLE_BILLBOARD, 0x002000, 0x003000, tex_particle, false, true, dec, dec, 128, 384, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 0, 0, 0, 0, 0, 0); + } break; case 5: // flame tracer dec = 6; - //particle(pt_fade, PARTICLE_BILLBOARD, 0xCF632B, 0xCF632B, tex_particle, false, true, dec, dec, 128, 9999, 0, pos[0], pos[1], pos[2], 0, 0, 0, 384.0f, 0, 0, 0, 0, 0); - particle(pt_fade, PARTICLE_BILLBOARD, 0xCF632B, 0xCF632B, tex_particle, false, true, dec, dec, 128, 9999, 0, pos[0], pos[1], pos[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 384.0f, 0, 0, 0, 0, 0); + if (smoke) + { + particle(pt_static, PARTICLE_BILLBOARD, 0x301000, 0x502000, tex_particle, false, true, dec, dec, 128, 384, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 0, 0, 0, 0, 0, 0); + } break; case 6: // voor trail dec = 6; - //particle(pt_fade, PARTICLE_BILLBOARD, 0x47232B, 0x47232B, tex_particle, false, true, dec, dec, 128, 9999, 0, pos[0], pos[1], pos[2], 0, 0, 0, 384.0f, 0, 0, 0, 0, 0); - particle(pt_fade, PARTICLE_BILLBOARD, 0x47232B, 0x47232B, tex_particle, false, true, dec, dec, 128, 9999, 0, pos[0], pos[1], pos[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 384.0f, 0, 0, 0, 0, 0); + if (smoke) + { + particle(pt_static, PARTICLE_BILLBOARD, 0x502030, 0x502030, tex_particle, false, true, dec, dec, 128, 384, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 0, 0, 0, 0, 0, 0); + } break; case 7: // Nehahra smoke tracer - if (!cl_particles_smoke.integer) - return; - dec = 10; - particle(pt_smoke, PARTICLE_BILLBOARD, 0x202020, 0x404040, tex_smoke[rand()&7], true, false, dec, dec, 64, 9999, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, 0, 0); + dec = 7; + if (smoke) + { + particle(pt_static, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], true, false, dec, dec, 64, 320, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-4, 4), lhrandom(-4, 4), lhrandom(0, 16), 0, 0, 0, 0, 0, 0); + } break; } @@ -909,24 +1026,30 @@ void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent) len -= dec; VectorMA (pos, dec, vec, pos); } +#ifndef WORKINGLQUAKE ent->persistent.trail_time = len; +#endif } void CL_RocketTrail2 (vec3_t start, vec3_t end, int color, entity_t *ent) { - vec3_t vec, pos; - int len; + 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_smoke, PARTICLE_BILLBOARD, color, color, tex_particle, false, false, 5, 5, 128, 9999, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, 0, 0); + particle(pt_static, PARTICLE_BILLBOARD, color, color, tex_particle, false, false, 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); } } @@ -940,47 +1063,42 @@ CL_MoveParticles void CL_MoveParticles (void) { particle_t *p; - //renderparticle_t *r, *rend; int i, activeparticles, maxparticle, j, a, pressureused = false, content; - float gravity, dvel, frametime, f, dist, normal[3], v[3], org[3]; + float gravity, dvel, bloodwaterfade, frametime, f, dist, normal[3], v[3], org[3]; // LordHavoc: early out condition if (!cl_numparticles) - { - //r_refdef.numparticles = 0; return; - } +#ifdef WORKINGLQUAKE + frametime = cl.frametime; +#else frametime = cl.time - cl.oldtime; - if (!frametime) - return; // if absolutely still, don't update particles +#endif gravity = frametime * sv_gravity.value; 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/*, r = r_refdef.particles, rend = r + cl_maxparticles*/;i < cl_numparticles;i++, p++) + for (i = 0, p = particles;i < cl_numparticles;i++, p++) { - if (p->die < cl.time) - { - freeparticles[j++] = p; - continue; - } - content = 0; VectorCopy(p->org, p->oldorg); VectorMA(p->org, frametime, p->vel, p->org); VectorCopy(p->org, org); +#ifndef WORKINGLQUAKE if (p->bounce) { - if (TraceLine(p->oldorg, p->org, v, normal, 0, true) < 1) + if (CL_TraceLine(p->oldorg, p->org, v, normal, 0, true, NULL) < 1) { VectorCopy(v, p->org); if (p->bounce < 0) { // assume it's blood (lame, but...) - R_Stain(v, 64, 32, 16, 16, p->alpha * p->scalex * (1.0f / 100.0f), 192, 48, 48, p->alpha * p->scalex * (1.0f / 100.0f)); + if (cl_stainmaps.integer) + R_Stain(v, 32, 32, 16, 16, p->alpha * p->scalex * (1.0f / 40.0f), 192, 48, 48, p->alpha * p->scalex * (1.0f / 40.0f)); p->die = -1; freeparticles[j++] = p; continue; @@ -994,297 +1112,79 @@ void CL_MoveParticles (void) } } } +#endif + p->vel[2] -= p->gravity * gravity; + p->alpha -= p->alphafade * frametime; if (p->friction) { f = p->friction * frametime; if (!content) - content = Mod_PointInLeaf(p->org, cl.worldmodel)->contents; + content = Mod_PointContents(p->org, cl.worldmodel); if (content != CONTENTS_EMPTY) f *= 4; f = 1.0f - f; VectorScale(p->vel, f, p->vel); } - switch (p->type) + if (p->type != pt_static) { - case pt_static: - break; - - // LordHavoc: drop-through because of shared code - case pt_blob: - p->vel[2] *= dvel; - case pt_blob2: - p->vel[0] *= dvel; - p->vel[1] *= dvel; - p->alpha -= frametime * 256; - if (p->alpha < 1) - p->die = -1; - break; - - case pt_grav: - p->vel[2] -= gravity; - break; - case pt_lavasplash: - p->vel[2] -= gravity * 0.05; - p->alpha -= frametime * 192; - if (p->alpha < 1) - p->die = -1; - break; - case pt_snow: - if (cl.time > p->time2) - { - p->time2 = cl.time + (rand() & 3) * 0.1; - p->vel[0] = (rand()&63)-32 + p->vel2[0]; - p->vel[1] = (rand()&63)-32 + p->vel2[1]; - p->vel[2] = (rand()&63)-32 + p->vel2[2]; - } - if (!content) - content = Mod_PointInLeaf(p->org, cl.worldmodel)->contents; - a = content; - if (a != CONTENTS_EMPTY && a != CONTENTS_SKY) - { - p->die = -1; - /* - if (a == CONTENTS_SOLID && Mod_PointInLeaf(p->oldorg, cl.worldmodel)->contents == CONTENTS_SOLID) - break; // still in solid - p->die = cl.time + 1000; - p->vel[0] = p->vel[1] = p->vel[2] = 0; - switch (a) - { - case CONTENTS_LAVA: - case CONTENTS_SLIME: - p->tex = tex_smoke[rand()&7]; - p->orientation = PARTICLE_BILLBOARD; - p->type = pt_steam; - p->alpha = 96; - p->scalex = 5; - p->scaley = 5; - p->vel[2] = 96; - break; - case CONTENTS_WATER: - p->tex = tex_smoke[rand()&7]; - p->orientation = PARTICLE_BILLBOARD; - p->type = pt_splash; - p->alpha = 96; - p->scalex = 5; - p->scaley = 5; - p->vel[2] = 96; - break; - default: // CONTENTS_SOLID and any others - TraceLine(p->oldorg, p->org, v, normal, 0, true); - VectorCopy(v, p->org); - p->tex = tex_smoke[rand()&7]; - p->orientation = PARTICLE_BILLBOARD; - p->type = pt_fade; - p->time2 = 384.0f; - p->scalex = 5; - p->scaley = 5; - VectorClear(p->vel); - break; - } - */ - } - break; - case pt_blood: - p->friction = 1; - if (!content) - content = Mod_PointInLeaf(p->org, cl.worldmodel)->contents; - a = content; - if (a != CONTENTS_EMPTY) + switch (p->type) { - if (a == CONTENTS_WATER || a == CONTENTS_SLIME) + case pt_blood: + if (!content) + content = Mod_PointContents(p->org, cl.worldmodel); + a = content; + if (a != CONTENTS_EMPTY) { - //p->friction = 5; - p->scalex += frametime * (cl_particles_blood_size_min.value + cl_particles_blood_size_max.value); - p->scaley += frametime * (cl_particles_blood_size_min.value + cl_particles_blood_size_max.value); - p->alpha -= frametime * max(cl_particles_blood_alpha.value, 0.01f) * 128.0f; - //p->vel[2] += gravity * 0.25f; - if (p->alpha < 1) + if (a == CONTENTS_WATER || a == CONTENTS_SLIME) + { + p->scalex += frametime * cl_particles_blood_size.value; + p->scaley += frametime * cl_particles_blood_size.value; + //p->alpha -= bloodwaterfade; + } + else p->die = -1; } else - p->die = -1; - } - else - p->vel[2] -= gravity; - break; - case pt_spark: - p->alpha -= frametime * p->time2; - p->vel[2] -= gravity; - if (p->alpha < 1) - p->die = -1; - else - { - if (!content) - content = Mod_PointInLeaf(p->org, cl.worldmodel)->contents; - if (content != CONTENTS_EMPTY) - p->die = -1; - } - break; - case pt_explosionsplash: - if (Mod_PointInLeaf(p->org, cl.worldmodel)->contents == CONTENTS_EMPTY) - p->vel[2] -= gravity; - else - p->alpha = 0; - p->scalex += frametime * 64.0f; - p->scaley += frametime * 64.0f; - p->alpha -= frametime * 1024.0f; - if (p->alpha < 1) - p->die = -1; - break; - case pt_fade: - p->alpha -= frametime * p->time2; - if (p->alpha < 1) - p->die = -1; - break; - case pt_bubble: - if (!content) - content = Mod_PointInLeaf(p->org, cl.worldmodel)->contents; - if (content != CONTENTS_WATER && content != CONTENTS_SLIME) - { - p->die = -1; - break; - /* - p->tex = tex_smoke[rand()&7]; - p->orientation = PARTICLE_BILLBOARD; - p->type = pt_splashpuff; - p->scalex = 4; - p->scaley = 4; - p->vel[0] = p->vel[1] = p->vel[2] = 0; + p->vel[2] -= gravity; break; - */ - } - p->vel[0] *= (1 - (frametime * 0.0625)); - p->vel[1] *= (1 - (frametime * 0.0625)); - p->vel[2] = (p->vel[2] + gravity * 0.25) * (1 - (frametime * 0.0625)); - if (cl.time > p->time2) - { - p->time2 = cl.time + lhrandom(0, 0.5); - p->vel[0] += lhrandom(-32,32); - p->vel[1] += lhrandom(-32,32); - p->vel[2] += lhrandom(-32,32); - } - p->alpha -= frametime * 256; - if (p->alpha < 1) - p->die = -1; - break; - case pt_bulletsmoke: - p->scalex += frametime * 16; - p->scaley += frametime * 16; - p->alpha -= frametime * 1024; - p->vel[2] += gravity * 0.2; - if (p->alpha < 1) - p->die = -1; - break; - case pt_smoke: - p->scalex += frametime * 16; - p->scaley += frametime * 16; - p->alpha -= frametime * 320; - //p->vel[2] += gravity * 0.2; - if (p->alpha < 1) - p->die = -1; - break; - case pt_steam: - p->scalex += frametime * 48; - p->scaley += frametime * 48; - p->alpha -= frametime * 512; - p->vel[2] += gravity * 0.05; - if (p->alpha < 1) - p->die = -1; - break; - case pt_splashpuff: - p->alpha -= frametime * 1024; - if (p->alpha < 1) - p->die = -1; - break; - case pt_rain: - if (!content) - content = Mod_PointInLeaf(p->org, cl.worldmodel)->contents; - a = content; - if (a != CONTENTS_EMPTY && a != CONTENTS_SKY) - p->die = -1; - /* - f = 0; - b = Mod_PointInLeaf(p->oldorg, cl.worldmodel)->contents; - VectorCopy(p->oldorg, o); - while (f < 1) - { - a = b; - f = TraceLine(o, p->org, v, normal, a, true); - b = traceline_endcontents; - if (f < 1 && b != CONTENTS_EMPTY && b != CONTENTS_SKY) + case pt_bubble: + if (!content) + content = Mod_PointContents(p->org, cl.worldmodel); + if (content != CONTENTS_WATER && content != CONTENTS_SLIME) { - #if 1 p->die = -1; - #else - p->die = cl.time + 1000; - p->vel[0] = p->vel[1] = p->vel[2] = 0; - VectorCopy(v, p->org); - switch (b) - { - case CONTENTS_LAVA: - case CONTENTS_SLIME: - p->tex = tex_smoke[rand()&7]; - p->orientation = PARTICLE_BILLBOARD; - p->type = pt_steam; - p->scalex = 3; - p->scaley = 3; - p->vel[2] = 96; - break; - default: // water, solid, and anything else - p->tex = tex_rainsplash[0]; - p->orientation = PARTICLE_ORIENTED_DOUBLESIDED; - p->time2 = 0; - VectorCopy(normal, p->vel2); - // VectorAdd(p->org, normal, p->org); - p->type = pt_raindropsplash; - p->scalex = 8; - p->scaley = 8; - break; - } - #endif break; } - } - */ - break; - /* - case pt_raindropsplash: - p->time2 += frametime * 64.0f; - if (p->time2 >= 16.0f) - { + break; + case pt_rain: + if (cl.time > p->time2) + { + // snow flutter + p->time2 = cl.time + (rand() & 3) * 0.1; + p->vel[0] = lhrandom(-32, 32) + p->vel2[0]; + p->vel[1] = lhrandom(-32, 32) + p->vel2[1]; + p->vel[2] = /*lhrandom(-32, 32) +*/ p->vel2[2]; + } + if (!content) + content = Mod_PointContents(p->org, cl.worldmodel); + a = content; + if (a != CONTENTS_EMPTY && a != CONTENTS_SKY) + p->die = -1; + break; + case pt_grow: + p->scalex += frametime * p->time2; + p->scaley += frametime * p->time2; + break; + default: + printf("unknown particle type %i\n", p->type); p->die = -1; break; } - p->tex = tex_rainsplash[(int) p->time2]; - p->orientation = PARTICLE_ORIENTED_DOUBLESIDED; - break; - */ - case pt_flame: - p->alpha -= frametime * 384; - p->vel[2] += gravity; - if (p->alpha < 16) - p->die = -1; - break; - case pt_oneframe: - if (p->time2) - p->die = -1; - p->time2 = 1; - break; - case pt_stardust: - p->alpha -= frametime * 128; - p->vel[2] -= gravity; - if (p->alpha < 16) - p->die = -1; - break; - default: - printf("unknown particle type %i\n", p->type); - p->die = -1; - break; } - // LordHavoc: immediate removal of unnecessary particles (must be done to ensure compactor below operates properly in all cases) - if (p->die < cl.time) + // remove dead particles + if (p->alpha < 1 || p->die < cl.time) freeparticles[j++] = p; else { @@ -1292,30 +1192,8 @@ void CL_MoveParticles (void) activeparticles++; if (p->pressure) pressureused = true; - - /* - // build renderparticle for renderer to use - r->orientation = p->orientation; - r->additive = p->additive; - r->dir[0] = p->vel2[0]; - r->dir[1] = p->vel2[1]; - r->dir[2] = p->vel2[2]; - r->org[0] = p->org[0]; - r->org[1] = p->org[1]; - r->org[2] = p->org[2]; - r->tex = p->tex; - r->scalex = p->scalex * cl_particles_size.value; - r->scaley = p->scaley * cl_particles_size.value; - r->dynlight = p->dynlight; - r->color[0] = p->color[0] * (1.0f / 255.0f); - r->color[1] = p->color[1] * (1.0f / 255.0f); - r->color[2] = p->color[2] * (1.0f / 255.0f); - r->color[3] = p->alpha * (1.0f / 255.0f); - r++; - */ } } - //r_refdef.numparticles = r - r_refdef.particles; // fill in gaps to compact the array i = 0; while (maxparticle >= activeparticles) @@ -1348,8 +1226,6 @@ void CL_MoveParticles (void) { dist = freeparticles[j]->scalex * 4.0f * frametime / sqrt(dist); VectorMA(p->vel, dist, diff, p->vel); - //dist = freeparticles[j]->scalex * 4.0f * frametime / dist; - //VectorMA(p->vel, dist, freeparticles[j]->vel, p->vel); } } } @@ -1358,19 +1234,28 @@ void CL_MoveParticles (void) } } -static rtexturepool_t *particletexturepool; +#define MAX_PARTICLETEXTURES 64 +// particletexture_t is a rectangle in the particlefonttexture +typedef struct +{ + float s1, t1, s2, t2; +} +particletexture_t; +#if WORKINGLQUAKE +static int particlefonttexture; +#else +static rtexturepool_t *particletexturepool; static rtexture_t *particlefonttexture; -// [0] is normal, [1] is fog, they may be the same -static particletexture_t particletexture[MAX_PARTICLETEXTURES][2]; +#endif +static particletexture_t particletexture[MAX_PARTICLETEXTURES]; static cvar_t r_drawparticles = {0, "r_drawparticles", "1"}; -static cvar_t r_particles_lighting = {0, "r_particles_lighting", "1"}; static qbyte shadebubble(float dx, float dy, vec3_t light) { - float dz, f, dot; - vec3_t normal; + float dz, f, dot; + vec3_t normal; dz = 1 - (dx*dx+dy*dy); if (dz > 0) // it does hit the sphere { @@ -1400,26 +1285,26 @@ static qbyte shadebubble(float dx, float dy, vec3_t light) return 0; } -static void setuptex(int cltexnum, int fog, int rtexnum, qbyte *data, qbyte *particletexturedata) +static void setuptex(int cltexnum, int rtexnum, qbyte *data, qbyte *particletexturedata) { int basex, basey, y; basex = ((rtexnum >> 0) & 7) * 32; basey = ((rtexnum >> 3) & 7) * 32; - particletexture[cltexnum][fog].s1 = (basex + 1) / 256.0f; - particletexture[cltexnum][fog].t1 = (basey + 1) / 256.0f; - particletexture[cltexnum][fog].s2 = (basex + 31) / 256.0f; - particletexture[cltexnum][fog].t2 = (basey + 31) / 256.0f; + particletexture[cltexnum].s1 = (basex + 1) / 256.0f; + particletexture[cltexnum].t1 = (basey + 1) / 256.0f; + particletexture[cltexnum].s2 = (basex + 31) / 256.0f; + particletexture[cltexnum].t2 = (basey + 31) / 256.0f; for (y = 0;y < 32;y++) memcpy(particletexturedata + ((basey + y) * 256 + basex) * 4, data + y * 32 * 4, 32 * 4); } static void R_InitParticleTexture (void) { - int x,y,d,i,m; - float dx, dy, radius, f, f2; - qbyte data[32][32][4], noise1[64][64], noise2[64][64]; - vec3_t light; - qbyte particletexturedata[256*256*4]; + int x,y,d,i,m; + float dx, dy, radius, f, f2; + qbyte data[32][32][4], noise1[64][64], noise2[64][64]; + vec3_t light; + qbyte particletexturedata[256*256*4]; memset(particletexturedata, 255, sizeof(particletexturedata)); @@ -1452,45 +1337,8 @@ static void R_InitParticleTexture (void) } while (m < 224); - setuptex(i + 0, 0, i + 0, &data[0][0][0], particletexturedata); - setuptex(i + 0, 1, i + 0, &data[0][0][0], particletexturedata); - } - /* - for (i = 0;i < 8;i++) - { - do - { - fractalnoise(&noise1[0][0], 64, 4); - fractalnoise(&noise2[0][0], 64, 8); - m = 0; - for (y = 0;y < 32;y++) - { - dy = y - 16; - for (x = 0;x < 32;x++) - { - d = (noise1[y][x] - 128) * 2 + 128; - d = bound(0, d, 255); - data[y][x][0] = data[y][x][1] = data[y][x][2] = d; - dx = x - 16; - d = (noise2[y][x] - 128) * 3 + 192; - if (d > 0) - d = (d * (256 - (int) (dx*dx+dy*dy))) >> 8; - d = bound(0, d, 255); - data[y][x][3] = (qbyte) d; - if (m < d) - m = d; - } - } - } - while (m < 224); - - setuptex(i + 0, 0, i + 0, &data[0][0][0], particletexturedata); - for (y = 0;y < 32;y++) - for (x = 0;x < 32;x++) - data[y][x][0] = data[y][x][1] = data[y][x][2] = 255; - setuptex(i + 0, 1, i + 8, &data[0][0][0], particletexturedata); + setuptex(i + 0, i + 0, &data[0][0][0], particletexturedata); } - */ // rain splash for (i = 0;i < 16;i++) @@ -1509,8 +1357,7 @@ static void R_InitParticleTexture (void) data[y][x][3] = (int) f; } } - setuptex(i + 8, 0, i + 16, &data[0][0][0], particletexturedata); - setuptex(i + 8, 1, i + 16, &data[0][0][0], particletexturedata); + setuptex(i + 8, i + 16, &data[0][0][0], particletexturedata); } // normal particle @@ -1526,8 +1373,7 @@ static void R_InitParticleTexture (void) data[y][x][3] = (qbyte) d; } } - setuptex(24, 0, 32, &data[0][0][0], particletexturedata); - setuptex(24, 1, 32, &data[0][0][0], particletexturedata); + setuptex(24, 32, &data[0][0][0], particletexturedata); // rain light[0] = 1;light[1] = 1;light[2] = 1; @@ -1540,8 +1386,7 @@ static void R_InitParticleTexture (void) data[y][x][3] = shadebubble((x - 16) * (1.0 / 8.0), y < 24 ? (y - 24) * (1.0 / 24.0) : (y - 24) * (1.0 / 8.0), light); } } - setuptex(25, 0, 33, &data[0][0][0], particletexturedata); - setuptex(25, 1, 33, &data[0][0][0], particletexturedata); + setuptex(25, 33, &data[0][0][0], particletexturedata); // bubble light[0] = 1;light[1] = 1;light[2] = 1; @@ -1554,32 +1399,15 @@ static void R_InitParticleTexture (void) data[y][x][3] = shadebubble((x - 16) * (1.0 / 16.0), (y - 16) * (1.0 / 16.0), light); } } - setuptex(26, 0, 34, &data[0][0][0], particletexturedata); - setuptex(26, 1, 34, &data[0][0][0], particletexturedata); - - // rocket flare - /* - for (y = 0;y < 32;y++) - { - dy = y - 16; - for (x = 0;x < 32;x++) - { - dx = x - 16; - d = (2048.0f / (dx*dx+dy*dy+1)) - 8.0f; - data[y][x][0] = bound(0, d * 1.0f, 255); - data[y][x][1] = bound(0, d * 0.8f, 255); - data[y][x][2] = bound(0, d * 0.5f, 255); - data[y][x][3] = bound(0, d * 1.0f, 255); - } - } - setuptex(27, 0, 35, &data[0][0][0], particletexturedata); - for (y = 0;y < 32;y++) - for (x = 0;x < 32;x++) - data[y][x][0] = data[y][x][1] = data[y][x][2] = 255; - setuptex(28, 1, 36, &data[0][0][0], particletexturedata); - */ - - particlefonttexture = R_LoadTexture (particletexturepool, "particlefont", 256, 256, particletexturedata, TEXTYPE_RGBA, TEXF_ALPHA | TEXF_PRECACHE); + setuptex(26, 34, &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); +#endif } static void r_part_start(void) @@ -1595,231 +1423,191 @@ static void r_part_shutdown(void) static void r_part_newmap(void) { + cl_numparticles = 0; } void R_Particles_Init (void) { Cvar_RegisterVariable(&r_drawparticles); - Cvar_RegisterVariable(&r_particles_lighting); +#ifdef WORKINGLQUAKE + r_part_start(); +#else R_RegisterModule("R_Particles", r_part_start, r_part_shutdown, r_part_newmap); +#endif } -int partindexarray[6] = {0, 1, 2, 0, 2, 3}; - -void R_DrawParticles (void) +#ifdef WORKINGLQUAKE +void R_InitParticles(void) { - //renderparticle_t *r; - int i, lighting, dynlight, additive, texnum, orientation; - float minparticledist, org[3], uprightangles[3], up2[3], right2[3], v[3], right[3], up[3], tvxyz[4][4], tvst[4][2], fog, ifog, fogvec[3]; - mleaf_t *leaf; - particletexture_t *tex, *texfog; - rmeshinfo_t m; - particle_t *p; - - // LordHavoc: early out conditions - //if ((!r_refdef.numparticles) || (!r_drawparticles.integer)) - if ((!cl_numparticles) || (!r_drawparticles.integer)) - return; - - lighting = r_particles_lighting.integer; - if (!r_dynamic.integer) - lighting = 0; - - c_particles += cl_numparticles; //r_refdef.numparticles; - - uprightangles[0] = 0; - uprightangles[1] = r_refdef.viewangles[1]; - uprightangles[2] = 0; - AngleVectors (uprightangles, NULL, right2, up2); + CL_Particles_Init(); + R_Particles_Init(); +} - minparticledist = DotProduct(r_origin, vpn) + 16.0f; +float varray_vertex[16]; +#endif - // LordHavoc: this meshinfo must match up with R_Mesh_DrawDecal - // LordHavoc: the commented out lines are hardwired behavior in R_Mesh_DrawDecal +void R_DrawParticleCallback(const void *calldata1, int calldata2) +{ + int additive, texnum, orientation; + float org[3], up2[3], v[3], right[3], up[3], fog, ifog, fogvec[3], cr, cg, cb, ca; + particletexture_t *tex; +#ifndef WORKINGLQUAKE + rmeshstate_t m; +#endif + const particle_t *p = calldata1; + + VectorCopy(p->org, org); + orientation = (p->flags >> P_ORIENTATION_FIRSTBIT) & ((1 << P_ORIENTATION_BITS) - 1); + texnum = (p->flags >> P_TEXNUM_FIRSTBIT) & ((1 << P_TEXNUM_BITS) - 1); + //dynlight = p->flags & P_DYNLIGHT; + additive = p->flags & P_ADDITIVE; + +#ifdef WORKINGLQUAKE + if (additive) + glBlendFunc(GL_SRC_ALPHA, GL_ONE); + else + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); +#else memset(&m, 0, sizeof(m)); - m.transparent = true; m.blendfunc1 = GL_SRC_ALPHA; - m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA; - m.numtriangles = 2; - m.index = partindexarray; - m.numverts = 4; - m.vertex = &tvxyz[0][0]; - m.vertexstep = sizeof(float[4]); + if (additive) + m.blendfunc2 = GL_ONE; + else + m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA; m.tex[0] = R_GetTexture(particlefonttexture); - m.texcoords[0] = &tvst[0][0]; - m.texcoordstep[0] = sizeof(float[2]); - - for (i = 0/*, r = r_refdef.particles*/, p = particles;i < /*r_refdef.numparticles*/cl_numparticles;i++, p++) + R_Mesh_Matrix(&r_identitymatrix); + R_Mesh_State(&m); +#endif + + tex = &particletexture[texnum]; + cr = p->color[0] * (1.0f / 255.0f); + cg = p->color[1] * (1.0f / 255.0f); + cb = p->color[2] * (1.0f / 255.0f); + ca = p->alpha * (1.0f / 255.0f); +#ifndef WORKINGLQUAKE + if (fogenabled) { - // LordHavoc: only render if not too close - if (DotProduct(p->org, vpn) < minparticledist) - continue; - - // LordHavoc: check if it's in a visible leaf - leaf = Mod_PointInLeaf(p->org, cl.worldmodel); - if (leaf->visframe != r_framecount) - continue; - - VectorCopy(p->org, org); - orientation = (p->flags >> P_ORIENTATION_FIRSTBIT) & ((1 << P_ORIENTATION_BITS) - 1); - texnum = (p->flags >> P_TEXNUM_FIRSTBIT) & ((1 << P_TEXNUM_BITS) - 1); - dynlight = p->flags & P_DYNLIGHT; - additive = p->flags & P_ADDITIVE; - if (orientation == PARTICLE_BILLBOARD) - { - VectorScale(vright, p->scalex, right); - VectorScale(vup, p->scaley, up); - } - else if (orientation == PARTICLE_UPRIGHT_FACING) + VectorSubtract(org, r_origin, fogvec); + fog = exp(fogdensity/DotProduct(fogvec,fogvec)); + ifog = 1 - fog; + cr = cr * ifog; + cg = cg * ifog; + cb = cb * ifog; + if (!additive) { - VectorScale(right2, p->scalex, right); - VectorScale(up2, p->scaley, up); + cr += fogcolor[0] * fog; + cg += fogcolor[1] * fog; + cb += fogcolor[2] * fog; } - else if (orientation == PARTICLE_ORIENTED_DOUBLESIDED) - { - // double-sided - if (DotProduct(p->vel2, r_origin) > DotProduct(p->vel2, org)) - { - VectorNegate(p->vel2, v); - VectorVectors(v, right, up); - } - else - VectorVectors(p->vel2, right, up); - VectorScale(right, p->scalex, right); - VectorScale(up, p->scaley, up); - } - else - Host_Error("R_DrawParticles: unknown particle orientation %i\n", orientation); + } + cr *= r_colorscale; + cg *= r_colorscale; + cb *= r_colorscale; - m.cr = p->color[0] * (1.0f / 255.0f); - m.cg = p->color[1] * (1.0f / 255.0f); - m.cb = p->color[2] * (1.0f / 255.0f); - m.ca = p->alpha * (1.0f / 255.0f); - if (lighting >= 1 && (dynlight || lighting >= 2)) - { - R_CompleteLightPoint(v, org, true, leaf); - m.cr *= v[0]; - m.cg *= v[1]; - m.cb *= v[2]; - } + varray_texcoord[0][0] = tex->s2;varray_texcoord[0][1] = tex->t1; + varray_texcoord[0][4] = tex->s1;varray_texcoord[0][5] = tex->t1; + varray_texcoord[0][8] = tex->s1;varray_texcoord[0][9] = tex->t2; + varray_texcoord[0][12] = tex->s2;varray_texcoord[0][13] = tex->t2; +#endif - tex = &particletexture[texnum][0]; - - tvxyz[0][0] = org[0] - right[0] - up[0]; - tvxyz[0][1] = org[1] - right[1] - up[1]; - tvxyz[0][2] = org[2] - right[2] - up[2]; - tvxyz[1][0] = org[0] - right[0] + up[0]; - tvxyz[1][1] = org[1] - right[1] + up[1]; - tvxyz[1][2] = org[2] - right[2] + up[2]; - tvxyz[2][0] = org[0] + right[0] + up[0]; - tvxyz[2][1] = org[1] + right[1] + up[1]; - tvxyz[2][2] = org[2] + right[2] + up[2]; - tvxyz[3][0] = org[0] + right[0] - up[0]; - tvxyz[3][1] = org[1] + right[1] - up[1]; - tvxyz[3][2] = org[2] + right[2] - up[2]; - tvst[0][0] = tex->s1; - tvst[0][1] = tex->t1; - tvst[1][0] = tex->s1; - tvst[1][1] = tex->t2; - tvst[2][0] = tex->s2; - tvst[2][1] = tex->t2; - tvst[3][0] = tex->s2; - tvst[3][1] = tex->t1; - - if (additive) + if (orientation == PARTICLE_BEAM) + { + VectorMA(p->org, -p->scaley, p->vel, v); + VectorMA(p->org, p->scaley, p->vel, up2); + R_CalcBeamVerts(varray_vertex, v, up2, p->scalex); + } + else if (orientation == PARTICLE_BILLBOARD) + { + VectorScale(vright, p->scalex, right); + VectorScale(vup, p->scaley, up); + varray_vertex[ 0] = org[0] + right[0] - up[0]; + varray_vertex[ 1] = org[1] + right[1] - up[1]; + varray_vertex[ 2] = org[2] + right[2] - up[2]; + varray_vertex[ 4] = org[0] - right[0] - up[0]; + varray_vertex[ 5] = org[1] - right[1] - up[1]; + varray_vertex[ 6] = org[2] - right[2] - up[2]; + varray_vertex[ 8] = org[0] - right[0] + up[0]; + varray_vertex[ 9] = org[1] - right[1] + up[1]; + varray_vertex[10] = org[2] - right[2] + up[2]; + varray_vertex[12] = org[0] + right[0] + up[0]; + varray_vertex[13] = org[1] + right[1] + up[1]; + varray_vertex[14] = org[2] + right[2] + up[2]; + } + else if (orientation == PARTICLE_ORIENTED_DOUBLESIDED) + { + // double-sided + if (DotProduct(p->vel2, r_origin) > DotProduct(p->vel2, org)) { - m.blendfunc2 = GL_ONE; - fog = 0; - if (fogenabled) - { - texfog = &particletexture[texnum][1]; - VectorSubtract(org, r_origin, fogvec); - ifog = 1 - exp(fogdensity/DotProduct(fogvec,fogvec)); - if (ifog < (1.0f - (1.0f / 64.0f))) - { - if (ifog >= (1.0f / 64.0f)) - { - // partially fogged, darken it - m.cr *= ifog; - m.cg *= ifog; - m.cb *= ifog; - R_Mesh_Draw(&m); - } - } - else - R_Mesh_Draw(&m); - } - else - R_Mesh_Draw(&m); + VectorNegate(p->vel2, v); + VectorVectors(v, right, up); } else - { - m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA; - fog = 0; - if (fogenabled) - { - texfog = &particletexture[texnum][1]; - VectorSubtract(org, r_origin, fogvec); - fog = exp(fogdensity/DotProduct(fogvec,fogvec)); - if (fog >= (1.0f / 64.0f)) - { - if (fog >= (1.0f - (1.0f / 64.0f))) - { - // fully fogged, just use the fog texture and render as alpha - m.cr = fogcolor[0]; - m.cg = fogcolor[1]; - m.cb = fogcolor[2]; - tvst[0][0] = texfog->s1; - tvst[0][1] = texfog->t1; - tvst[1][0] = texfog->s1; - tvst[1][1] = texfog->t2; - tvst[2][0] = texfog->s2; - tvst[2][1] = texfog->t2; - tvst[3][0] = texfog->s2; - tvst[3][1] = texfog->t1; - R_Mesh_Draw(&m); - } - else - { - // partially fogged, darken the first pass - ifog = 1 - fog; - m.cr *= ifog; - m.cg *= ifog; - m.cb *= ifog; - if (tex->s1 == texfog->s1 && tex->t1 == texfog->t1) - { - // fog texture is the same as the base, just change the color - m.cr += fogcolor[0] * fog; - m.cg += fogcolor[1] * fog; - m.cb += fogcolor[2] * fog; - R_Mesh_Draw(&m); - } - else - { - // render the first pass (alpha), then do additive fog - R_Mesh_Draw(&m); - - m.blendfunc2 = GL_ONE; - m.cr = fogcolor[0] * fog; - m.cg = fogcolor[1] * fog; - m.cb = fogcolor[2] * fog; - tvst[0][0] = texfog->s1; - tvst[0][1] = texfog->t1; - tvst[1][0] = texfog->s1; - tvst[1][1] = texfog->t2; - tvst[2][0] = texfog->s2; - tvst[2][1] = texfog->t2; - tvst[3][0] = texfog->s2; - tvst[3][1] = texfog->t1; - R_Mesh_Draw(&m); - } - } - } - else - R_Mesh_Draw(&m); - } - else - R_Mesh_Draw(&m); - } + VectorVectors(p->vel2, right, up); + VectorScale(right, p->scalex, right); + VectorScale(up, p->scaley, up); + varray_vertex[ 0] = org[0] + right[0] - up[0]; + varray_vertex[ 1] = org[1] + right[1] - up[1]; + varray_vertex[ 2] = org[2] + right[2] - up[2]; + varray_vertex[ 4] = org[0] - right[0] - up[0]; + varray_vertex[ 5] = org[1] - right[1] - up[1]; + varray_vertex[ 6] = org[2] - right[2] - up[2]; + varray_vertex[ 8] = org[0] - right[0] + up[0]; + varray_vertex[ 9] = org[1] - right[1] + up[1]; + varray_vertex[10] = org[2] - right[2] + up[2]; + varray_vertex[12] = org[0] + right[0] + up[0]; + varray_vertex[13] = org[1] + right[1] + up[1]; + varray_vertex[14] = org[2] + right[2] + up[2]; } + else + Host_Error("R_DrawParticles: unknown particle orientation %i\n", orientation); +#if WORKINGLQUAKE + glBegin(GL_QUADS); + glColor4f(cr, cg, cb, ca); + glTexCoord2f(tex->s2, tex->t1);glVertex3f(varray_vertex[ 0], varray_vertex[ 1], varray_vertex[ 2]); + glTexCoord2f(tex->s1, tex->t1);glVertex3f(varray_vertex[ 4], varray_vertex[ 5], varray_vertex[ 6]); + glTexCoord2f(tex->s1, tex->t2);glVertex3f(varray_vertex[ 8], varray_vertex[ 9], varray_vertex[10]); + glTexCoord2f(tex->s2, tex->t2);glVertex3f(varray_vertex[12], varray_vertex[13], varray_vertex[14]); + glEnd(); +#else + GL_Color(cr, cg, cb, ca); + R_Mesh_Draw(4, 2, polygonelements); +#endif } + +void R_DrawParticles (void) +{ + int i; + float minparticledist; + particle_t *p; + +#ifdef WORKINGLQUAKE + CL_MoveParticles(); +#endif + + // LordHavoc: early out conditions + if ((!cl_numparticles) || (!r_drawparticles.integer)) + return; + + minparticledist = DotProduct(r_origin, vpn) + 16.0f; + +#ifdef WORKINGLQUAKE + glBindTexture(GL_TEXTURE_2D, particlefonttexture); + glEnable(GL_BLEND); + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + 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) + R_DrawParticleCallback(p, 0); + 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) + R_MeshQueue_AddTransparent(p->org, R_DrawParticleCallback, p, 0); +#endif +} +