X-Git-Url: https://de.git.xonotic.org/?a=blobdiff_plain;f=cl_particles.c;h=ae4f2e79729c204867c15e5597d085c744bd4d8f;hb=399fcc6085a339ac51cc46218a3ac9cbcc945749;hp=15f78ca5657ec58d1727932e94cd1b7894b7d9eb;hpb=933a1996b1c2661e86bf76936c8cda4f38281726;p=xonotic%2Fdarkplaces.git diff --git a/cl_particles.c b/cl_particles.c index 15f78ca5..ae4f2e79 100644 --- a/cl_particles.c +++ b/cl_particles.c @@ -19,29 +19,187 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "quakedef.h" + +#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 CL_PointContents(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_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_CalcBeam_Vertex3f (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[ 3] = org1[0] - width * right1[0]; + vert[ 4] = org1[1] - width * right1[1]; + vert[ 5] = org1[2] - width * right1[2]; + vert[ 6] = org2[0] - width * right2[0]; + vert[ 7] = org2[1] - width * right2[1]; + vert[ 8] = org2[2] - width * right2[2]; + vert[ 9] = org2[0] + width * right2[0]; + vert[10] = org2[1] + width * right2[1]; + vert[11] = 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); +} +#if QW +#include "pmove.h" +extern qboolean PM_RecursiveHullCheck (hull_t *hull, int num, float p1f, float p2f, vec3_t p1, vec3_t p2, pmtrace_t *trace); +#endif +float CL_TraceLine (vec3_t start, vec3_t end, vec3_t impact, vec3_t normal, int contents, int hitbmodels, void **hitent) +{ +#if QW + pmtrace_t trace; +#else + trace_t trace; +#endif + memset (&trace, 0, sizeof(trace)); + trace.fraction = 1; + VectorCopy (end, trace.endpos); +#if QW + PM_RecursiveHullCheck (cl.model_precache[1]->brushq1.hulls, 0, 0, 1, start, end, &trace); +#else + RecursiveHullCheck (cl.worldmodel->brushq1.hulls, 0, 0, 1, start, end, &trace); +#endif + VectorCopy(trace.endpos, impact); + VectorCopy(trace.plane.normal, normal); + return trace.fraction; +} +#else #include "cl_collision.h" +#endif -#define MAX_PARTICLES 16384 // default max # of particles at one time +#define MAX_PARTICLES 32768 // default max # of particles at one time #define ABSOLUTE_MIN_PARTICLES 512 // no fewer than this no matter what's on the command line typedef enum { - pt_static, pt_rain, pt_bubble, pt_blood + pt_static, pt_rain, pt_bubble, pt_blood, pt_grow, pt_decal } ptype_t; -#define P_TEXNUM_FIRSTBIT 0 -#define P_TEXNUM_BITS 6 -#define P_ORIENTATION_FIRSTBIT (P_TEXNUM_FIRSTBIT + P_TEXNUM_BITS) -#define P_ORIENTATION_BITS 2 -#define P_FLAGS_FIRSTBIT (P_ORIENTATION_FIRSTBIT + P_ORIENTATION_BITS) -#define P_DYNLIGHT (1 << (P_FLAGS_FIRSTBIT + 0)) -#define P_ADDITIVE (1 << (P_FLAGS_FIRSTBIT + 1)) +#define PARTICLE_INVALID 0 +#define PARTICLE_BILLBOARD 1 +#define PARTICLE_SPARK 2 +#define PARTICLE_ORIENTED_DOUBLESIDED 3 +#define PARTICLE_BEAM 4 + +#define PBLEND_ALPHA 0 +#define PBLEND_ADD 1 +#define PBLEND_MOD 2 typedef struct particle_s { ptype_t type; - unsigned int flags; // dynamically lit, orientation, additive blending, texnum + int orientation; + int texnum; + int blendmode; vec3_t org; vec3_t vel; float die; @@ -57,6 +215,12 @@ typedef struct particle_s float friction; // how much air friction affects this object (objects with a low mass/size ratio tend to get more air friction) float pressure; // if non-zero, apply pressure to other particles qbyte color[4]; +#ifndef WORKINGLQUAKE + entity_render_t *owner; // decal stuck to this entity + model_t *ownermodel; // model the decal is stuck to (used to make sure the entity is still alive) + vec3_t relativeorigin; // decal at this location in entity's coordinate space + vec3_t relativedirection; // decal oriented this way relative to entity's coordinate space +#endif } particle_t; @@ -98,12 +262,14 @@ static int particlepalette[256] = //static int explosparkramp[8] = {0x4b0700, 0x6f0f00, 0x931f07, 0xb7330f, 0xcf632b, 0xe3974f, 0xffe7b5, 0xffffff}; -// these must match r_part.c's textures +// texture numbers in particle font static const int tex_smoke[8] = {0, 1, 2, 3, 4, 5, 6, 7}; static const int tex_rainsplash[16] = {8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23}; static const int tex_particle = 24; -static const int tex_rain = 25; +static const int tex_raindrop = 25; static const int tex_bubble = 26; +static const int tex_beam = 27; +static const int tex_blooddecal[8] = {32, 33, 34, 35, 36, 37, 38, 39}; static int cl_maxparticles; static int cl_numparticles; @@ -118,10 +284,18 @@ cvar_t cl_particles_blood_size = {CVAR_SAVE, "cl_particles_blood_size", "8"}; cvar_t cl_particles_blood_alpha = {CVAR_SAVE, "cl_particles_blood_alpha", "0.5"}; cvar_t cl_particles_bulletimpacts = {CVAR_SAVE, "cl_particles_bulletimpacts", "1"}; cvar_t cl_particles_smoke = {CVAR_SAVE, "cl_particles_smoke", "1"}; +cvar_t cl_particles_smoke_size = {CVAR_SAVE, "cl_particles_smoke_size", "7"}; +cvar_t cl_particles_smoke_alpha = {CVAR_SAVE, "cl_particles_smoke_alpha", "0.5"}; +cvar_t cl_particles_smoke_alphafade = {CVAR_SAVE, "cl_particles_smoke_alphafade", "0.55"}; cvar_t cl_particles_sparks = {CVAR_SAVE, "cl_particles_sparks", "1"}; cvar_t cl_particles_bubbles = {CVAR_SAVE, "cl_particles_bubbles", "1"}; +cvar_t cl_decals = {CVAR_SAVE, "cl_decals", "0"}; +cvar_t cl_decals_time = {CVAR_SAVE, "cl_decals_time", "0"}; +cvar_t cl_decals_fadetime = {CVAR_SAVE, "cl_decals_fadetime", "20"}; +#ifndef WORKINGLQUAKE static mempool_t *cl_part_mempool; +#endif void CL_Particles_Clear(void) { @@ -159,50 +333,57 @@ void CL_Particles_Init (void) Cvar_RegisterVariable (&cl_particles_blood_alpha); Cvar_RegisterVariable (&cl_particles_bulletimpacts); Cvar_RegisterVariable (&cl_particles_smoke); + Cvar_RegisterVariable (&cl_particles_smoke_size); + Cvar_RegisterVariable (&cl_particles_smoke_alpha); + Cvar_RegisterVariable (&cl_particles_smoke_alphafade); Cvar_RegisterVariable (&cl_particles_sparks); Cvar_RegisterVariable (&cl_particles_bubbles); - + Cvar_RegisterVariable (&cl_decals); + Cvar_RegisterVariable (&cl_decals_time); + Cvar_RegisterVariable (&cl_decals_fadetime); + +#ifdef WORKINGLQUAKE + particles = (particle_t *) Hunk_AllocName(cl_maxparticles * sizeof(particle_t), "particles"); + 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; } -#define particle(ptype, porientation, pcolor1, pcolor2, ptex, plight, padditive, pscalex, pscaley, palpha, palphafade, ptime, pgravity, pbounce, px, py, pz, pvx, pvy, pvz, ptime2, pvx2, pvy2, pvz2, pfriction, ppressure)\ +#define particle(ptype, porientation, pcolor1, pcolor2, ptex, plight, pblendmode, pscalex, pscaley, palpha, palphafade, ptime, pgravity, pbounce, px, py, pz, pvx, pvy, pvz, ptime2, pvx2, pvy2, pvz2, pfriction, ppressure)\ {\ - if (cl_numparticles >= cl_maxparticles)\ - return;\ + if (cl_numparticles < cl_maxparticles)\ {\ particle_t *part;\ - int tempcolor, tempcolor2, cr1, cg1, cb1, cr2, cg2, cb2;\ - unsigned int partflags;\ - partflags = ((porientation) << P_ORIENTATION_FIRSTBIT) | ((ptex) << P_TEXNUM_FIRSTBIT);\ - if (padditive)\ - partflags |= P_ADDITIVE;\ - if (plight)\ - partflags |= P_DYNLIGHT;\ - tempcolor = (pcolor1);\ - tempcolor2 = (pcolor2);\ - cr2 = ((tempcolor2) >> 16) & 0xFF;\ - cg2 = ((tempcolor2) >> 8) & 0xFF;\ - cb2 = (tempcolor2) & 0xFF;\ - if (tempcolor != tempcolor2)\ + int ptempcolor, ptempcolor2, pcr1, pcg1, pcb1, pcr2, pcg2, pcb2;\ + ptempcolor = (pcolor1);\ + ptempcolor2 = (pcolor2);\ + pcr2 = ((ptempcolor2) >> 16) & 0xFF;\ + pcg2 = ((ptempcolor2) >> 8) & 0xFF;\ + pcb2 = (ptempcolor2) & 0xFF;\ + if (ptempcolor != ptempcolor2)\ {\ - cr1 = ((tempcolor) >> 16) & 0xFF;\ - cg1 = ((tempcolor) >> 8) & 0xFF;\ - cb1 = (tempcolor) & 0xFF;\ - tempcolor = rand() & 0xFF;\ - cr2 = (((cr2 - cr1) * tempcolor) >> 8) + cr1;\ - cg2 = (((cg2 - cg1) * tempcolor) >> 8) + cg1;\ - cb2 = (((cb2 - cb1) * tempcolor) >> 8) + cb1;\ + pcr1 = ((ptempcolor) >> 16) & 0xFF;\ + pcg1 = ((ptempcolor) >> 8) & 0xFF;\ + pcb1 = (ptempcolor) & 0xFF;\ + ptempcolor = rand() & 0xFF;\ + pcr2 = (((pcr2 - pcr1) * ptempcolor) >> 8) + pcr1;\ + pcg2 = (((pcg2 - pcg1) * ptempcolor) >> 8) + pcg1;\ + pcb2 = (((pcb2 - pcb1) * ptempcolor) >> 8) + pcb1;\ }\ part = &particles[cl_numparticles++];\ + memset(part, 0, sizeof(*part));\ part->type = (ptype);\ - part->color[0] = cr2;\ - part->color[1] = cg2;\ - part->color[2] = cb2;\ + part->color[0] = pcr2;\ + part->color[1] = pcg2;\ + part->color[2] = pcb2;\ part->color[3] = 0xFF;\ - part->flags = partflags;\ + part->orientation = porientation;\ + part->texnum = ptex;\ + part->blendmode = pblendmode;\ part->scalex = (pscalex);\ part->scaley = (pscaley);\ part->alpha = (palpha);\ @@ -261,26 +442,41 @@ void CL_EntityParticles (entity_t *ent) forward[1] = cp*sy; forward[2] = -sp; - 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); +#ifdef WORKINGLQUAKE + particle(pt_static, PARTICLE_BILLBOARD, particlepalette[0x6f], particlepalette[0x6f], tex_particle, false, PBLEND_ADD, 2, 2, 255, 0, 0, 0, 0, ent->origin[0] + m_bytenormals[i][0]*dist + forward[0]*beamlength, ent->origin[1] + m_bytenormals[i][1]*dist + forward[1]*beamlength, ent->origin[2] + m_bytenormals[i][2]*dist + forward[2]*beamlength, 0, 0, 0, 0, 0, 0, 0, 0, 0); +#else + particle(pt_static, PARTICLE_BILLBOARD, particlepalette[0x6f], particlepalette[0x6f], tex_particle, false, PBLEND_ADD, 2, 2, 255, 0, 0, 0, 0, ent->render.origin[0] + m_bytenormals[i][0]*dist + forward[0]*beamlength, ent->render.origin[1] + m_bytenormals[i][1]*dist + forward[1]*beamlength, ent->render.origin[2] + m_bytenormals[i][2]*dist + forward[2]*beamlength, 0, 0, 0, 0, 0, 0, 0, 0, 0); +#endif } } void CL_ReadPointFile_f (void) { - vec3_t org; - int r, c; - char *pointfile, *pointfilepos, *t, tchar; + vec3_t org, leakorg; + int r, c, s; + char *pointfile = NULL, *pointfilepos, *t, tchar; + char name[MAX_OSPATH]; + + if (!cl.worldmodel) + return; - pointfile = COM_LoadFile(va("maps/%s.pts", sv.name), true); + FS_StripExtension(cl.worldmodel->name, name); + strcat(name, ".pts"); +#if WORKINGLQUAKE + pointfile = COM_LoadTempFile (name); +#else + pointfile = FS_LoadFile(name, true); +#endif if (!pointfile) { - Con_Printf ("couldn't open %s.pts\n", sv.name); + Con_Printf ("Could not open %s\n", name); return; } - Con_Printf ("Reading %s.pts...\n", sv.name); + Con_Printf ("Reading %s...\n", name); c = 0; + s = 0; pointfilepos = pointfile; while (*pointfilepos) { @@ -298,18 +494,25 @@ void CL_ReadPointFile_f (void) pointfilepos = t; if (r != 3) break; + if (c == 0) + VectorCopy(org, leakorg); c++; - if (cl_numparticles >= cl_maxparticles) + if (cl_numparticles < cl_maxparticles - 3) { - Con_Printf ("Not enough free particles\n"); - break; + s++; + particle(pt_static, PARTICLE_BILLBOARD, particlepalette[(-c)&15], particlepalette[(-c)&15], tex_particle, false, PBLEND_ALPHA, 2, 2, 255, 0, 99999, 0, 0, org[0], org[1], org[2], 0, 0, 0, 0, 0, 0, 0, 0, 0); } - 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); } - +#ifndef WORKINGLQUAKE Mem_Free(pointfile); - Con_Printf ("%i points read\n", c); +#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]); + + 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); + particle(pt_static, PARTICLE_BEAM, 0x0000FF, 0x0000FF, tex_beam, false, PBLEND_ALPHA, 64, 64, 255, 0, 99999, 0, 0, org[0], org[1], org[2] - 4096, 0, 0, 0, 0, org[0], org[1], org[2] + 4096, 0, 0); } /* @@ -321,8 +524,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 (); @@ -345,18 +548,60 @@ CL_ParticleExplosion =============== */ -void CL_ParticleExplosion (vec3_t org, int smoke) +void CL_ParticleExplosion (vec3_t org) { - int i; + 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); - i = Mod_PointInLeaf(org, cl.worldmodel)->contents; + i = CL_PointContents(org); if ((i == CONTENTS_SLIME || i == CONTENTS_WATER) && cl_particles.integer && cl_particles_bubbles.integer) { for (i = 0;i < 128;i++) { - particle(pt_bubble, PARTICLE_BILLBOARD, 0x404040, 0x808080, tex_bubble, false, true, 2, 2, lhrandom(128, 255), 256, 9999, -0.25, 1.5, org[0] + lhrandom(-16, 16), org[1] + lhrandom(-16, 16), org[2] + lhrandom(-16, 16), lhrandom(-96, 96), lhrandom(-96, 96), lhrandom(-96, 96), 0, 0, 0, 0, (1.0 / 16.0), 0); + particle(pt_bubble, PARTICLE_BILLBOARD, 0x404040, 0x808080, tex_bubble, false, PBLEND_ADD, 2, 2, lhrandom(128, 255), 256, 9999, -0.25, 1.5, org[0] + lhrandom(-16, 16), org[1] + lhrandom(-16, 16), org[2] + lhrandom(-16, 16), lhrandom(-96, 96), lhrandom(-96, 96), lhrandom(-96, 96), 0, 0, 0, 0, (1.0 / 16.0), 0); + } + } + else + { + /* + // LordHavoc: smoke effect similar to UT2003, chews fillrate too badly up close + // smoke puff + if (cl_particles.integer && cl_particles_smoke.integer) + { + for (i = 0;i < 64;i++) + { +#ifdef WORKINGLQUAKE + v2[0] = lhrandom(-64, 64); + v2[1] = lhrandom(-64, 64); + v2[2] = lhrandom(-8, 24); +#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) + 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); + } + } + */ + + 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); + } } } @@ -378,7 +623,7 @@ void CL_ParticleExplosion2 (vec3_t org, int colorStart, int colorLength) for (i = 0;i < 512;i++) { k = particlepalette[colorStart + (i % colorLength)]; - particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, false, 1.5, 1.5, 255, 384, 0.3, 0, 0, org[0] + lhrandom(-8, 8), org[1] + lhrandom(-8, 8), org[2] + lhrandom(-8, 8), lhrandom(-192, 192), lhrandom(-192, 192), lhrandom(-192, 192), 0, 0, 0, 0, 1, 0); + particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ALPHA, 1.5, 1.5, 255, 384, 0.3, 0, 0, org[0] + lhrandom(-8, 8), org[1] + lhrandom(-8, 8), org[2] + lhrandom(-8, 8), lhrandom(-192, 192), lhrandom(-192, 192), lhrandom(-192, 192), 0, 0, 0, 0, 1, 0); } } @@ -409,14 +654,21 @@ void CL_RunParticleEffect (vec3_t org, vec3_t dir, int color, int count) 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_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); + 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); + } + 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); + } } } @@ -428,17 +680,29 @@ CL_SparkShower */ void CL_SparkShower (vec3_t org, vec3_t dir, int count) { + vec3_t org2, org3; int k; - if (!cl_particles.integer) return; if (cl_stainmaps.integer) - R_Stain(org, 32, 96, 96, 96, 2, 128, 128, 128, 2); + R_Stain(org, 32, 96, 96, 96, 24, 128, 128, 128, 24); + + if (!cl_particles.integer) return; if (cl_particles_bulletimpacts.integer) { // smoke puff if (cl_particles_smoke.integer) - particle(pt_static, PARTICLE_BILLBOARD, 0x606060, 0xA0A0A0, tex_smoke[rand()&7], true, true, 4, 4, 255, 1024, 9999, -0.2, 0, org[0], org[1], org[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(0, 16), 0, 0, 0, 0, 0, 0); + { + k = count / 4; + 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); + } + } if (cl_particles_sparks.integer) { @@ -446,7 +710,7 @@ void CL_SparkShower (vec3_t org, vec3_t dir, int count) while(count--) { k = particlepalette[0x68 + (rand() & 7)]; - particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, true, 1, 1, lhrandom(64, 255), 512, 9999, 1, 0, org[0], org[1], org[2], lhrandom(-64, 64) + dir[0], lhrandom(-64, 64) + dir[1], lhrandom(0, 128) + dir[2], 0, 0, 0, 0, 0, 0); + particle(pt_static, PARTICLE_SPARK, k, k, tex_particle, false, PBLEND_ADD, 0.4f, 0.015f, lhrandom(64, 255), 512, 9999, 1, 0, org[0], org[1], org[2], lhrandom(-64, 64) + dir[0], lhrandom(-64, 64) + dir[1], lhrandom(0, 128) + dir[2], 0, 0, 0, 0, 0, 0); } } } @@ -455,13 +719,14 @@ void CL_SparkShower (vec3_t org, vec3_t dir, int count) void CL_PlasmaBurn (vec3_t org) { if (cl_stainmaps.integer) - R_Stain(org, 48, 96, 96, 96, 3, 128, 128, 128, 3); + 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 s, r, a; + 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; @@ -475,7 +740,12 @@ void CL_BloodPuff (vec3_t org, vec3_t vel, int count) a = cl_particles_blood_alpha.value * 255; while(bloodcount > 0) { - particle(pt_blood, PARTICLE_BILLBOARD, 0x000000, 0x200000, tex_smoke[rand()&7], true, false, r, r, a, a * 0.5, 9999, 0, -1, org[0], org[1], org[2], vel[0] + lhrandom(-s, s), vel[1] + lhrandom(-s, s), vel[2] + lhrandom(-s, s), 0, 0, 0, 0, 1, 0); + 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; } } @@ -511,7 +781,8 @@ void CL_BloodShower (vec3_t mins, vec3_t maxs, float velspeed, int count) vel[1] = (org[1] - center[1]) * velscale[1]; vel[2] = (org[2] - center[2]) * velscale[2]; bloodcount -= r; - particle(pt_blood, PARTICLE_BILLBOARD, 0x000000, 0x200000, tex_smoke[rand()&7], true, false, r, r, a, a * 0.5, 9999, 0, -1, org[0], org[1], org[2], vel[0], vel[1], vel[2], 0, 0, 0, 0, 1, 0); + particle(pt_blood, PARTICLE_BILLBOARD, 0xFFFFFF, 0xFFFFFF, tex_blooddecal[rand()&7], true, PBLEND_MOD, r, r, a * 3, a * 1.5, 9999, 0, -1, org[0], org[1], org[2], vel[0], vel[1], vel[2], 0, 0, 0, 0, 1, 0); + //particle(pt_blood, PARTICLE_BILLBOARD, 0x000000, 0x200000, tex_smoke[rand()&7], true, PBLEND_ALPHA, r, r, a, a * 0.5, 9999, 0, -1, org[0], org[1], org[2], vel[0], vel[1], vel[2], 0, 0, 0, 0, 1, 0); } } @@ -527,7 +798,7 @@ void CL_ParticleCube (vec3_t mins, vec3_t maxs, vec3_t dir, int count, int color while (count--) { k = particlepalette[colorbase + (rand()&3)]; - particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, false, 2, 2, 255, 0, lhrandom(1, 2), gravity ? 1 : 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(mins[2], maxs[2]), dir[0] + lhrandom(-randomvel, randomvel), dir[1] + lhrandom(-randomvel, randomvel), dir[2] + lhrandom(-randomvel, randomvel), 0, 0, 0, 0, 0, 0); + particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ALPHA, 2, 2, 255, 0, lhrandom(1, 2), gravity ? 1 : 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(mins[2], maxs[2]), dir[0] + lhrandom(-randomvel, randomvel), dir[1] + lhrandom(-randomvel, randomvel), dir[2] + lhrandom(-randomvel, randomvel), 0, 0, 0, 0, 0, 0); } } @@ -565,14 +836,28 @@ void CL_ParticleRain (vec3_t mins, vec3_t maxs, vec3_t dir, int count, int color while(count--) { k = particlepalette[colorbase + (rand()&3)]; - particle(pt_rain, PARTICLE_UPRIGHT_FACING, k, k, tex_particle, true, true, 0.5, 8, 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); + 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); + } + 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); + } } break; case 1: while(count--) { k = particlepalette[colorbase + (rand()&3)]; - particle(pt_rain, PARTICLE_BILLBOARD, k, k, tex_particle, false, true, 1, 1, lhrandom(64, 128), 0, t, 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz), dir[0], dir[1], dir[2], 0, dir[0], dir[1], dir[2], 0, 0); + 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); + } + 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); + } } break; default: @@ -605,7 +890,7 @@ void CL_Stardust (vec3_t mins, vec3_t maxs, int count) VectorNormalizeFast(v); VectorScale(v, 100, v); v[2] += sv_gravity.value * 0.15f; - particle(pt_static, PARTICLE_BILLBOARD, 0x903010, 0xFFD030, tex_particle, false, true, 1.5, 1.5, lhrandom(64, 128), 128, 9999, 1, 0, o[0], o[1], o[2], v[0], v[1], v[2], 0, 0, 0, 0, 0, 0); + particle(pt_static, PARTICLE_BILLBOARD, 0x903010, 0xFFD030, tex_particle, false, PBLEND_ADD, 1.5, 1.5, lhrandom(64, 128), 128, 9999, 1, 0, o[0], o[1], o[2], v[0], v[1], v[2], 0, 0, 0, 0, 0, 0); } } @@ -621,9 +906,9 @@ void CL_FlameCube (vec3_t mins, vec3_t maxs, int count) while (count--) { k = particlepalette[224 + (rand()&15)]; - particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, true, 4, 4, lhrandom(64, 128), 384, 9999, -1, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(mins[2], maxs[2]), lhrandom(-32, 32), lhrandom(-32, 32), lhrandom(0, 64), 0, 0, 0, 0, 1, 0); + particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ADD, 4, 4, lhrandom(64, 128), 384, 9999, -1, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(mins[2], maxs[2]), lhrandom(-32, 32), lhrandom(-32, 32), lhrandom(0, 64), 0, 0, 0, 0, 1, 0); if (count & 1) - particle(pt_static, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], false, true, 6, 6, lhrandom(48, 96), 64, 9999, 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(mins[2], maxs[2]), lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(0, 32), 0, 0, 0, 0, 0, 0); + particle(pt_static, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], false, PBLEND_ADD, 6, 6, lhrandom(48, 96), 64, 9999, 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(mins[2], maxs[2]), lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(0, 32), 0, 0, 0, 0, 0, 0); } } @@ -635,7 +920,7 @@ void CL_Flames (vec3_t org, vec3_t vel, int count) while (count--) { k = particlepalette[224 + (rand()&15)]; - particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, true, 4, 4, lhrandom(64, 128), 384, 9999, -1, 1.1, org[0], org[1], org[2], vel[0] + lhrandom(-128, 128), vel[1] + lhrandom(-128, 128), vel[2] + lhrandom(-128, 128), 0, 0, 0, 0, 1, 0); + particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, PBLEND_ADD, 4, 4, lhrandom(64, 128), 384, 9999, -1, 1.1, org[0], org[1], org[2], vel[0] + lhrandom(-128, 128), vel[1] + lhrandom(-128, 128), vel[2] + lhrandom(-128, 128), 0, 0, 0, 0, 1, 0); } } @@ -649,14 +934,15 @@ CL_LavaSplash */ void CL_LavaSplash (vec3_t origin) { - int i, j, k; + int i, j, k, l, inc; float vel; vec3_t dir, org; if (!cl_particles.integer) return; - for (i=-128 ; i<128 ; i+=16) + inc = 32; + for (i = -128;i < 128;i += inc) { - for (j=-128 ; j<128 ; j+=16) + for (j = -128;j < 128;j += inc) { dir[0] = j + lhrandom(0, 8); dir[1] = i + lhrandom(0, 8); @@ -665,8 +951,17 @@ void CL_LavaSplash (vec3_t origin) org[1] = origin[1] + dir[1]; org[2] = origin[2] + lhrandom(0, 64); vel = lhrandom(50, 120) / VectorLength(dir); // normalize and scale - k = particlepalette[224 + (rand()&7)]; - particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, true, 7, 7, 255, 192, 9999, 0.05, 0, org[0], org[1], org[2], dir[0] * vel, dir[1] * vel, dir[2] * vel, 0, 0, 0, 0, 0, 0); + if (gamemode == GAME_GOODVSBAD2) + { + 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); + } + 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); + } } } } @@ -677,8 +972,8 @@ CL_TeleportSplash =============== */ -/* -void CL_TeleportSplash (vec3_t org) +#if WORKINGLQUAKE +void R_TeleportSplash (vec3_t org) { int i, j, k; if (!cl_particles.integer) return; @@ -686,38 +981,52 @@ void CL_TeleportSplash (vec3_t org) for (i=-16 ; i<16 ; i+=8) for (j=-16 ; j<16 ; j+=8) for (k=-24 ; k<32 ; k+=8) - particle(pt_static, PARTICLE_BILLBOARD, 0xA0A0A0, 0xFFFFFF, tex_particle, false, true, 10, 10, lhrandom(64, 128), 256, 9999, 0, 0, org[0] + i + lhrandom(0, 8), org[1] + j + lhrandom(0, 8), org[2] + k + lhrandom(0, 8), lhrandom(-64, 64), lhrandom(-64, 64), lhrandom(-256, 256), 0, 0, 0, 0, 1, 0); + particle(pt_static, PARTICLE_BILLBOARD, 0xA0A0A0, 0xFFFFFF, tex_particle, false, PBLEND_ADD, 10, 10, lhrandom(64, 128), 256, 9999, 0, 0, org[0] + i + lhrandom(0, 8), org[1] + j + lhrandom(0, 8), org[2] + k + lhrandom(0, 8), lhrandom(-64, 64), lhrandom(-64, 64), lhrandom(-256, 256), 0, 0, 0, 0, 1, 0); } -*/ +#endif +#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, r; int contents, smoke, blood, bubbles; + if (end[0] == start[0] && end[1] == start[1] && end[2] == start[2]) + return; + VectorSubtract(end, start, dir); VectorNormalize(dir); 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 = CL_PointContents(pos); if (contents == CONTENTS_SKY || contents == CONTENTS_LAVA) return; @@ -733,22 +1042,22 @@ void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent) dec = 3; if (smoke) { - particle(pt_static, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], false, true, dec, dec, 32, 64, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-5, 5), lhrandom(-5, 5), lhrandom(-5, 5), 0, 0, 0, 0, 0, 0); - particle(pt_static, PARTICLE_BILLBOARD, 0x801010, 0xFFA020, tex_smoke[rand()&7], false, true, dec, dec, 128, 768, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-20, 20), lhrandom(-20, 20), lhrandom(-20, 20), 0, 0, 0, 0, 0, 0); + particle(pt_grow, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], false, PBLEND_ADD, dec, dec, cl_particles_smoke_alpha.value*125, cl_particles_smoke_alphafade.value*125, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-5, 5), lhrandom(-5, 5), lhrandom(-5, 5), cl_particles_smoke_size.value, 0, 0, 0, 0, 0); + particle(pt_static, PARTICLE_BILLBOARD, 0x801010, 0xFFA020, tex_smoke[rand()&7], false, PBLEND_ADD, dec, dec, cl_particles_smoke_alpha.value*288, cl_particles_smoke_alphafade.value*1400, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-20, 20), lhrandom(-20, 20), lhrandom(-20, 20), 0, 0, 0, 0, 0, 0); } if (bubbles) { r = lhrandom(1, 2); - particle(pt_bubble, PARTICLE_BILLBOARD, 0x404040, 0x808080, tex_bubble, false, true, r, r, lhrandom(64, 255), 256, 9999, -0.25, 1.5, pos[0], pos[1], pos[2], lhrandom(-16, 16), lhrandom(-16, 16), lhrandom(-16, 16), 0, 0, 0, 0, (1.0 / 16.0), 0); + particle(pt_bubble, PARTICLE_BILLBOARD, 0x404040, 0x808080, tex_bubble, false, PBLEND_ADD, r, r, lhrandom(64, 255), 256, 9999, -0.25, 1.5, pos[0], pos[1], pos[2], lhrandom(-16, 16), lhrandom(-16, 16), lhrandom(-16, 16), 0, 0, 0, 0, (1.0 / 16.0), 0); } break; case 1: // grenade trail // FIXME: make it gradually stop smoking dec = 3; - if (cl_particles.integer && cl_particles_smoke.integer) + if (smoke) { - particle(pt_static, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], false, true, dec, dec, 32, 96, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-5, 5), lhrandom(-5, 5), lhrandom(-5, 5), 0, 0, 0, 0, 0, 0); + particle(pt_grow, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], false, PBLEND_ADD, dec, dec, cl_particles_smoke_alpha.value*100, cl_particles_smoke_alphafade.value*100, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-5, 5), lhrandom(-5, 5), lhrandom(-5, 5), cl_particles_smoke_size.value, 0, 0, 0, 0, 0); } break; @@ -758,7 +1067,8 @@ void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent) dec = cl_particles_blood_size.value; if (blood) { - particle(pt_blood, PARTICLE_BILLBOARD, 0x100000, 0x280000, tex_smoke[rand()&7], true, false, dec, dec, cl_particles_blood_alpha.value * 255.0f, cl_particles_blood_alpha.value * 255.0f * 0.5, 9999, 0, -1, pos[0], pos[1], pos[2], vel[0] * 0.5f + lhrandom(-64, 64), vel[1] * 0.5f + lhrandom(-64, 64), vel[2] * 0.5f + lhrandom(-64, 64), 0, 0, 0, 0, 1, 0); + particle(pt_blood, PARTICLE_BILLBOARD, 0xFFFFFF, 0xFFFFFF, tex_blooddecal[rand()&7], true, PBLEND_MOD, dec, dec, cl_particles_blood_alpha.value * 255.0f * 3.0f, cl_particles_blood_alpha.value * 255.0f * 0.5f * 1.5f, 9999, 0, -1, pos[0], pos[1], pos[2], vel[0] * 0.5f + lhrandom(-64, 64), vel[1] * 0.5f + lhrandom(-64, 64), vel[2] * 0.5f + lhrandom(-64, 64), 0, 0, 0, 0, 1, 0); + //particle(pt_blood, PARTICLE_BILLBOARD, 0x100000, 0x280000, tex_smoke[rand()&7], true, PBLEND_ALPHA, dec, dec, cl_particles_blood_alpha.value * 255.0f, cl_particles_blood_alpha.value * 255.0f * 0.5, 9999, 0, -1, pos[0], pos[1], pos[2], vel[0] * 0.5f + lhrandom(-64, 64), vel[1] * 0.5f + lhrandom(-64, 64), vel[2] * 0.5f + lhrandom(-64, 64), 0, 0, 0, 0, 1, 0); } break; @@ -766,7 +1076,14 @@ void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent) dec = 6; if (smoke) { - particle(pt_static, PARTICLE_BILLBOARD, 0x002000, 0x003000, tex_particle, false, true, dec, dec, 128, 384, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 0, 0, 0, 0, 0, 0); + 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); + } + 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); + } } break; @@ -774,7 +1091,7 @@ void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent) dec = 6; if (smoke) { - particle(pt_static, PARTICLE_BILLBOARD, 0x301000, 0x502000, tex_particle, false, true, dec, dec, 128, 384, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 0, 0, 0, 0, 0, 0); + particle(pt_static, PARTICLE_BILLBOARD, 0x301000, 0x502000, tex_particle, false, PBLEND_ADD, dec, dec, 128, 384, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 0, 0, 0, 0, 0, 0); } break; @@ -782,7 +1099,14 @@ void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent) dec = 6; if (smoke) { - particle(pt_static, PARTICLE_BILLBOARD, 0x502030, 0x502030, tex_particle, false, true, dec, dec, 128, 384, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(-8, 8), 0, 0, 0, 0, 0, 0); + 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); + } + 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); + } } break; @@ -790,16 +1114,25 @@ void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent) dec = 7; if (smoke) { - particle(pt_static, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], true, false, dec, dec, 64, 320, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-4, 4), lhrandom(-4, 4), lhrandom(0, 16), 0, 0, 0, 0, 0, 0); + particle(pt_static, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], true, PBLEND_ALPHA, dec, dec, 64, 320, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-4, 4), lhrandom(-4, 4), lhrandom(0, 16), 0, 0, 0, 0, 0, 0); } break; + case 8: // Nexuiz plasma trail + dec = 4; + if (smoke) + { + //particle(pt_static, PARTICLE_BILLBOARD, 0x2030FF, 0x80C0FF, tex_particle, false, PBLEND_ADD, 3.0f, 3.0f, lhrandom(64, 255), 512, 9999, 0, 0, pos[0], pos[1], pos[2], lhrandom(-32, 32) + dir[0] * -64.0f, lhrandom(-32, 32) + dir[1] * -64.0f, lhrandom(-32, 32) + dir[2] * -64.0f, 0, 0, 0, 0, 0, 0); + particle(pt_static, PARTICLE_BILLBOARD, 0x283880, 0x283880, tex_particle, false, PBLEND_ADD, dec, dec, 255, 1024, 9999, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, 0, 0); + } } // advance to next time and position 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) @@ -811,16 +1144,73 @@ void CL_RocketTrail2 (vec3_t start, vec3_t end, int color, entity_t *ent) 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, false, 5, 5, 128, 320, 9999, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, 0, 0); + particle(pt_static, PARTICLE_BILLBOARD, color, color, tex_particle, false, PBLEND_ALPHA, 5, 5, 128, 320, 9999, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0, 0, 0, 0); VectorAdd (pos, vec, pos); } } +void CL_BeamParticle (const vec3_t start, const vec3_t end, vec_t radius, float red, float green, float blue, float alpha, float lifetime) +{ + int tempcolor2, cr, cg, cb; + cr = red * 255; + cg = green * 255; + cb = blue * 255; + tempcolor2 = (bound(0, cr, 255) << 16) | (bound(0, cg, 255) << 8) | bound(0, cb, 255); + particle(pt_static, PARTICLE_BEAM, tempcolor2, tempcolor2, tex_beam, false, PBLEND_ADD, radius, radius, alpha * 255, alpha * 255 / lifetime, 9999, 0, 0, start[0], start[1], start[2], 0, 0, 0, 0, end[0], end[1], end[2], 0, 0); +} + +void CL_Tei_Smoke(const vec3_t org, const vec3_t dir, int count) +{ + int k; + if (!cl_particles.integer) return; + + // smoke puff + if (cl_particles_smoke.integer) + { + k = count / 4; + while(k--) + { + particle(pt_grow, PARTICLE_BILLBOARD, 0x202020, 0x404040, tex_smoke[rand()&7], true, PBLEND_ADD, 5, 5, 255, 512, 9999, 0, 0, org[0] + 0.125f * lhrandom(-count, count), org[1] + 0.125f * lhrandom (-count, count), org[2] + 0.125f * lhrandom(-count, count), dir[0] + lhrandom(-count, count) * 0.5f, dir[1] + lhrandom(-count, count) * 0.5f, dir[2] + lhrandom(-count, count) * 0.5f, 15, 0, 0, 0, 0, 0); + } + } +} + +void CL_Tei_PlasmaHit(const vec3_t org, const vec3_t dir, int count) +{ + int k; + if (!cl_particles.integer) return; + + if (cl_stainmaps.integer) + R_Stain(org, 40, 96, 96, 96, 40, 128, 128, 128, 40); + + // smoke puff + if (cl_particles_smoke.integer) + { + k = count / 4; + while(k--) + { + particle(pt_grow, PARTICLE_BILLBOARD, 0x202020, 0x404040, tex_smoke[rand()&7], true, PBLEND_ADD, 5, 5, 255, 512, 9999, 0, 0, org[0] + 0.125f * lhrandom(-count, count), org[1] + 0.125f * lhrandom (-count, count), org[2] + 0.125f * lhrandom(-count, count), dir[0] + lhrandom(-count, count), dir[1] + lhrandom(-count, count), dir[2] + lhrandom(-count, count), 15, 0, 0, 0, 0, 0); + } + } + + if (cl_particles_sparks.integer) + { + // sparks + while(count--) + { + particle(pt_static, PARTICLE_SPARK, 0x2030FF, 0x80C0FF, tex_particle, false, PBLEND_ADD, 2.0f, 0.1f, lhrandom(64, 255), 512, 9999, 0, 0, org[0], org[1], org[2], lhrandom(-count, count) * 3.0f + dir[0], lhrandom(-count, count) * 3.0f + dir[1], lhrandom(-count, count) * 3.0f + dir[2], 0, 0, 0, 0, 0, 0); + } + } +} /* =============== @@ -832,12 +1222,21 @@ void CL_MoveParticles (void) particle_t *p; int i, activeparticles, maxparticle, j, a, pressureused = false, content; float gravity, dvel, bloodwaterfade, frametime, f, dist, normal[3], v[3], org[3]; +#ifdef WORKINGLQUAKE + void *hitent; +#else + entity_render_t *hitent; +#endif // LordHavoc: early out condition if (!cl_numparticles) return; +#ifdef WORKINGLQUAKE + frametime = cl.frametime; +#else frametime = cl.time - cl.oldtime; +#endif gravity = frametime * sv_gravity.value; dvel = 1+4*frametime; bloodwaterfade = max(cl_particles_blood_alpha.value, 0.01f) * frametime * 128.0f; @@ -853,17 +1252,45 @@ void CL_MoveParticles (void) VectorCopy(p->org, org); if (p->bounce) { - if (CL_TraceLine(p->oldorg, p->org, v, normal, 0, true) < 1) + if (CL_TraceLine(p->oldorg, p->org, v, normal, 0, true, &hitent) < 1) { VectorCopy(v, p->org); if (p->bounce < 0) { // assume it's blood (lame, but...) +#ifndef WORKINGLQUAKE if (cl_stainmaps.integer) - R_Stain(v, 32, 32, 16, 16, p->alpha * p->scalex * (1.0f / 400.0f), 192, 48, 48, p->alpha * p->scalex * (1.0f / 400.0f)); - p->die = -1; - freeparticles[j++] = p; - continue; + 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 + { + p->die = -1; + freeparticles[j++] = p; + continue; + } } else { @@ -880,7 +1307,7 @@ void CL_MoveParticles (void) { f = p->friction * frametime; if (!content) - content = Mod_PointInLeaf(p->org, cl.worldmodel)->contents; + content = CL_PointContents(p->org); if (content != CONTENTS_EMPTY) f *= 4; f = 1.0f - f; @@ -893,7 +1320,7 @@ void CL_MoveParticles (void) { case pt_blood: if (!content) - content = Mod_PointInLeaf(p->org, cl.worldmodel)->contents; + content = CL_PointContents(p->org); a = content; if (a != CONTENTS_EMPTY) { @@ -911,7 +1338,7 @@ void CL_MoveParticles (void) break; case pt_bubble: if (!content) - content = Mod_PointInLeaf(p->org, cl.worldmodel)->contents; + content = CL_PointContents(p->org); if (content != CONTENTS_WATER && content != CONTENTS_SLIME) { p->die = -1; @@ -928,13 +1355,33 @@ void CL_MoveParticles (void) p->vel[2] = /*lhrandom(-32, 32) +*/ p->vel2[2]; } if (!content) - content = Mod_PointInLeaf(p->org, cl.worldmodel)->contents; + content = CL_PointContents(p->org); 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; + case pt_decal: +#ifndef WORKINGLQUAKE + if (p->owner->model == p->ownermodel) + { + Matrix4x4_Transform(&p->owner->matrix, p->relativeorigin, p->org); + Matrix4x4_Transform3x3(&p->owner->matrix, p->relativedirection, p->vel2); + } + else + p->die = -1; +#endif + if (cl.time > p->time2) + { + p->alphafade = p->alpha / (p->die - cl.time); + p->time2 += 10000; + } + break; default: - printf("unknown particle type %i\n", p->type); + Con_Printf("unknown particle type %i\n", p->type); p->die = -1; break; } @@ -995,22 +1442,25 @@ void CL_MoveParticles (void) // particletexture_t is a rectangle in the particlefonttexture typedef struct { + rtexture_t *texture; float s1, t1, s2, t2; } particletexture_t; +#if WORKINGLQUAKE +static int particlefonttexture; +#else static rtexturepool_t *particletexturepool; - static rtexture_t *particlefonttexture; +#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", "0"}; 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 { @@ -1040,30 +1490,29 @@ static qbyte shadebubble(float dx, float dy, vec3_t light) return 0; } -static void setuptex(int cltexnum, int rtexnum, qbyte *data, qbyte *particletexturedata) +static void setuptex(int texnum, qbyte *data, qbyte *particletexturedata) { int basex, basey, y; - basex = ((rtexnum >> 0) & 7) * 32; - basey = ((rtexnum >> 3) & 7) * 32; - particletexture[cltexnum].s1 = (basex + 1) / 256.0f; - particletexture[cltexnum].t1 = (basey + 1) / 256.0f; - particletexture[cltexnum].s2 = (basex + 31) / 256.0f; - particletexture[cltexnum].t2 = (basey + 31) / 256.0f; + basex = ((texnum >> 0) & 7) * 32; + basey = ((texnum >> 3) & 7) * 32; + particletexture[texnum].s1 = (basex + 1) / 256.0f; + particletexture[texnum].t1 = (basey + 1) / 256.0f; + particletexture[texnum].s2 = (basex + 31) / 256.0f; + particletexture[texnum].t2 = (basey + 31) / 256.0f; for (y = 0;y < 32;y++) memcpy(particletexturedata + ((basey + y) * 256 + basex) * 4, data + y * 32 * 4, 32 * 4); } static void R_InitParticleTexture (void) { - int x,y,d,i,m; - float dx, dy, radius, f, f2; - qbyte data[32][32][4], noise1[64][64], noise2[64][64]; - vec3_t light; - qbyte particletexturedata[256*256*4]; + int x, y, d, i, j, k, m; + float cx, cy, dx, dy, radius, f, f2; + qbyte data[32][32][4], noise1[64][64], noise2[64][64], data2[64][16][4]; + vec3_t light; + qbyte particletexturedata[256*256*4]; memset(particletexturedata, 255, sizeof(particletexturedata)); - // the particletexture[][] array numbers must match the cl_part.c textures // smoke/blood for (i = 0;i < 8;i++) { @@ -1092,7 +1541,7 @@ static void R_InitParticleTexture (void) } while (m < 224); - setuptex(i + 0, i + 0, &data[0][0][0], particletexturedata); + setuptex(tex_smoke[i], &data[0][0][0], particletexturedata); } // rain splash @@ -1112,7 +1561,7 @@ static void R_InitParticleTexture (void) data[y][x][3] = (int) f; } } - setuptex(i + 8, i + 16, &data[0][0][0], particletexturedata); + setuptex(tex_rainsplash[i], &data[0][0][0], particletexturedata); } // normal particle @@ -1128,7 +1577,7 @@ static void R_InitParticleTexture (void) data[y][x][3] = (qbyte) d; } } - setuptex(24, 32, &data[0][0][0], particletexturedata); + setuptex(tex_particle, &data[0][0][0], particletexturedata); // rain light[0] = 1;light[1] = 1;light[2] = 1; @@ -1141,7 +1590,7 @@ static void R_InitParticleTexture (void) data[y][x][3] = shadebubble((x - 16) * (1.0 / 8.0), y < 24 ? (y - 24) * (1.0 / 24.0) : (y - 24) * (1.0 / 8.0), light); } } - setuptex(25, 33, &data[0][0][0], particletexturedata); + setuptex(tex_raindrop, &data[0][0][0], particletexturedata); // bubble light[0] = 1;light[1] = 1;light[2] = 1; @@ -1154,9 +1603,80 @@ static void R_InitParticleTexture (void) data[y][x][3] = shadebubble((x - 16) * (1.0 / 16.0), (y - 16) * (1.0 / 16.0), light); } } - setuptex(26, 34, &data[0][0][0], particletexturedata); + setuptex(tex_bubble, &data[0][0][0], particletexturedata); + + // smoke/blood + for (i = 0;i < 8;i++) + { + memset(&data[0][0][0], 255, sizeof(data)); + for (j = 1;j < 8;j++) + { + for (k = 0;k < 3;k++) + { + cx = lhrandom(j + 1, 30 - j); + cy = lhrandom(j + 1, 30 - j); + for (y = 0;y < 32;y++) + { + for (x = 0;x < 32;x++) + { + dx = (x - cx); + dy = (y - cy); + f = 1.0f - sqrt(dx * dx + dy * dy) / j; + if (f > 0) + { + data[y][x][0] = data[y][x][0] + f * 0.5 * ( 160 - data[y][x][0]); + data[y][x][1] = data[y][x][1] + f * 0.5 * ( 32 - data[y][x][1]); + data[y][x][2] = data[y][x][2] + f * 0.5 * ( 32 - data[y][x][2]); + } + } + } + } + } + // use inverted colors so we can scale them later using glColor and use an inverse blend + for (y = 0;y < 32;y++) + { + for (x = 0;x < 32;x++) + { + data[y][x][0] = 255 - data[y][x][0]; + data[y][x][1] = 255 - data[y][x][1]; + data[y][x][2] = 255 - data[y][x][2]; + } + } + setuptex(tex_blooddecal[i], &data[0][0][0], particletexturedata); + } - particlefonttexture = R_LoadTexture (particletexturepool, "particlefont", 256, 256, particletexturedata, TEXTYPE_RGBA, TEXF_ALPHA | TEXF_PRECACHE); +#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); + for (i = 0;i < MAX_PARTICLETEXTURES;i++) + particletexture[i].texture = particlefonttexture; + + // beam + fractalnoise(&noise1[0][0], 64, 4); + m = 0; + for (y = 0;y < 64;y++) + { + for (x = 0;x < 16;x++) + { + if (x < 8) + d = x; + else + d = (15 - x); + d = d * d * noise1[y][x] / (7 * 7); + data2[y][x][0] = data2[y][x][1] = data2[y][x][2] = (qbyte) bound(0, d, 255); + data2[y][x][3] = 255; + } + } + + particletexture[tex_beam].texture = R_LoadTexture2D(particletexturepool, "beam", 16, 64, &data2[0][0][0], TEXTYPE_RGBA, TEXF_PRECACHE, NULL); + particletexture[tex_beam].s1 = 0; + particletexture[tex_beam].t1 = 0; + particletexture[tex_beam].s2 = 1; + particletexture[tex_beam].t2 = 1; +#endif } static void r_part_start(void) @@ -1172,70 +1692,101 @@ 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}; +#ifdef WORKINGLQUAKE +void R_InitParticles(void) +{ + CL_Particles_Init(); + R_Particles_Init(); +} +#endif -void R_DrawParticles (void) +float particle_vertex3f[12], particle_texcoord2f[8]; + +#ifdef WORKINGLQUAKE +void R_DrawParticle(particle_t *p) { - int i, lighting, dynlight, additive, texnum, orientation; - float minparticledist, org[3], uprightangles[3], up2[3], right2[3], v[3], right[3], up[3], fog, ifog, fogvec[3], cr, cg, cb, ca; - mleaf_t *leaf; +#else +void R_DrawParticleCallback(const void *calldata1, int calldata2) +{ + const particle_t *p = calldata1; + rmeshstate_t m; +#endif + float org[3], up2[3], v[3], right[3], up[3], fog, ifog, fogvec[3], cr, cg, cb, ca; particletexture_t *tex; - rmeshbufferinfo_t m; - particle_t *p; - - // LordHavoc: early out conditions - if ((!cl_numparticles) || (!r_drawparticles.integer)) - return; - lighting = r_particles_lighting.integer; - if (!r_dynamic.integer) - lighting = 0; + VectorCopy(p->org, org); - c_particles += cl_numparticles; + tex = &particletexture[p->texnum]; + cr = p->color[0] * (1.0f / 255.0f); + cg = p->color[1] * (1.0f / 255.0f); + cb = p->color[2] * (1.0f / 255.0f); + ca = p->alpha * (1.0f / 255.0f); + if (p->blendmode == PBLEND_MOD) + { + cr *= ca; + cg *= ca; + cb *= ca; + cr = min(cr, 1); + cg = min(cg, 1); + cb = min(cb, 1); + ca = 1; + } - uprightangles[0] = 0; - uprightangles[1] = r_refdef.viewangles[1]; - uprightangles[2] = 0; - AngleVectors (uprightangles, NULL, right2, up2); +#ifndef WORKINGLQUAKE + if (fogenabled && p->blendmode != PBLEND_MOD) + { + VectorSubtract(org, r_origin, fogvec); + fog = exp(fogdensity/DotProduct(fogvec,fogvec)); + ifog = 1 - fog; + cr = cr * ifog; + cg = cg * ifog; + cb = cb * ifog; + if (p->blendmode == 0) + { + cr += fogcolor[0] * fog; + cg += fogcolor[1] * fog; + cb += fogcolor[2] * fog; + } + } + cr *= r_colorscale; + cg *= r_colorscale; + cb *= r_colorscale; - minparticledist = DotProduct(r_origin, vpn) + 16.0f; + GL_Color(cr, cg, cb, ca); - for (i = 0, p = particles;i < cl_numparticles;i++, p++) - { - // LordHavoc: only render if not too close - if (DotProduct(p->org, vpn) < minparticledist) - continue; + R_Mesh_Matrix(&r_identitymatrix); - // LordHavoc: check if it's in a visible leaf - leaf = Mod_PointInLeaf(p->org, cl.worldmodel); - if (leaf->visframe != r_framecount) - continue; + memset(&m, 0, sizeof(m)); + m.tex[0] = R_GetTexture(tex->texture); + m.pointer_texcoord[0] = particle_texcoord2f; + R_Mesh_State_Texture(&m); - 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) - { - VectorScale(right2, p->scalex, right); - VectorScale(up2, p->scaley, up); - } - else if (orientation == PARTICLE_ORIENTED_DOUBLESIDED) + if (p->blendmode == 0) + GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + else if (p->blendmode == 1) + GL_BlendFunc(GL_SRC_ALPHA, GL_ONE); + else + 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)) @@ -1249,82 +1800,105 @@ void R_DrawParticles (void) VectorScale(up, p->scaley, up); } else - Host_Error("R_DrawParticles: unknown particle orientation %i\n", orientation); - - 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); - if (lighting >= 1 && (dynlight || lighting >= 2)) { - R_CompleteLightPoint(v, org, true, leaf); - cr *= v[0]; - cg *= v[1]; - cb *= v[2]; + VectorScale(vright, p->scalex, right); + VectorScale(vup, p->scaley, up); } + particle_vertex3f[ 0] = org[0] - right[0] - up[0]; + particle_vertex3f[ 1] = org[1] - right[1] - up[1]; + particle_vertex3f[ 2] = org[2] - right[2] - up[2]; + particle_vertex3f[ 3] = org[0] - right[0] + up[0]; + particle_vertex3f[ 4] = org[1] - right[1] + up[1]; + particle_vertex3f[ 5] = org[2] - right[2] + up[2]; + particle_vertex3f[ 6] = org[0] + right[0] + up[0]; + particle_vertex3f[ 7] = org[1] + right[1] + up[1]; + particle_vertex3f[ 8] = org[2] + right[2] + up[2]; + particle_vertex3f[ 9] = org[0] + right[0] - up[0]; + particle_vertex3f[10] = org[1] + right[1] - up[1]; + particle_vertex3f[11] = org[2] + right[2] - up[2]; + particle_texcoord2f[0] = tex->s1;particle_texcoord2f[1] = tex->t2; + particle_texcoord2f[2] = tex->s1;particle_texcoord2f[3] = tex->t1; + particle_texcoord2f[4] = tex->s2;particle_texcoord2f[5] = tex->t1; + particle_texcoord2f[6] = tex->s2;particle_texcoord2f[7] = tex->t2; + } + else if (p->orientation == PARTICLE_SPARK) + { + VectorMA(p->org, -p->scaley, p->vel, v); + VectorMA(p->org, p->scaley, p->vel, up2); + R_CalcBeam_Vertex3f(particle_vertex3f, v, up2, p->scalex); + particle_texcoord2f[0] = tex->s1;particle_texcoord2f[1] = tex->t2; + particle_texcoord2f[2] = tex->s1;particle_texcoord2f[3] = tex->t1; + particle_texcoord2f[4] = tex->s2;particle_texcoord2f[5] = tex->t1; + particle_texcoord2f[6] = tex->s2;particle_texcoord2f[7] = tex->t2; + } + else if (p->orientation == PARTICLE_BEAM) + { + R_CalcBeam_Vertex3f(particle_vertex3f, p->org, p->vel2, p->scalex); + VectorSubtract(p->vel2, p->org, up); + VectorNormalizeFast(up); + v[0] = DotProduct(p->org, up) * (1.0f / 64.0f) - cl.time * 0.25; + v[1] = DotProduct(p->vel2, up) * (1.0f / 64.0f) - cl.time * 0.25; + particle_texcoord2f[0] = 1;particle_texcoord2f[1] = v[0]; + particle_texcoord2f[2] = 0;particle_texcoord2f[3] = v[0]; + particle_texcoord2f[4] = 0;particle_texcoord2f[5] = v[1]; + particle_texcoord2f[6] = 1;particle_texcoord2f[7] = v[1]; + } + else + Host_Error("R_DrawParticles: unknown particle orientation %i\n", p->orientation); - if (fogenabled) - { - VectorSubtract(org, r_origin, fogvec); - fog = exp(fogdensity/DotProduct(fogvec,fogvec)); - ifog = 1 - fog; - cr = cr * ifog; - cg = cg * ifog; - cb = cb * ifog; - if (!additive) - { - cr += fogcolor[0] * fog; - cg += fogcolor[1] * fog; - cb += fogcolor[2] * fog; - } - } +#if WORKINGLQUAKE + if (p->blendmode == 0) + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + else if (p->blendmode == 1) + glBlendFunc(GL_SRC_ALPHA, GL_ONE); + else + glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR); + glColor4f(cr, cg, cb, ca); + glBegin(GL_QUADS); + glTexCoord2f(particle_texcoord2f[0], particle_texcoord2f[1]);glVertex3f(particle_vertex3f[ 0], particle_vertex3f[ 1], particle_vertex3f[ 2]); + glTexCoord2f(particle_texcoord2f[2], particle_texcoord2f[3]);glVertex3f(particle_vertex3f[ 3], particle_vertex3f[ 4], particle_vertex3f[ 5]); + glTexCoord2f(particle_texcoord2f[4], particle_texcoord2f[5]);glVertex3f(particle_vertex3f[ 6], particle_vertex3f[ 7], particle_vertex3f[ 8]); + glTexCoord2f(particle_texcoord2f[6], particle_texcoord2f[7]);glVertex3f(particle_vertex3f[ 9], particle_vertex3f[10], particle_vertex3f[11]); + glEnd(); +#else + R_Mesh_Draw(4, 2, polygonelements); +#endif +} - memset(&m, 0, sizeof(m)); - m.transparent = true; - m.blendfunc1 = GL_SRC_ALPHA; - if (additive) - m.blendfunc2 = GL_ONE; - else - m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA; - m.numtriangles = 2; - m.numverts = 4; - m.tex[0] = R_GetTexture(particlefonttexture); - if (R_Mesh_Draw_GetBuffer(&m, false)) - { - m.index[0] = 0; - m.index[1] = 1; - m.index[2] = 2; - m.index[3] = 0; - m.index[4] = 2; - m.index[5] = 3; - m.vertex[0] = org[0] - right[0] - up[0]; - m.vertex[1] = org[1] - right[1] - up[1]; - m.vertex[2] = org[2] - right[2] - up[2]; - m.vertex[4] = org[0] - right[0] + up[0]; - m.vertex[5] = org[1] - right[1] + up[1]; - m.vertex[6] = org[2] - right[2] + up[2]; - m.vertex[8] = org[0] + right[0] + up[0]; - m.vertex[9] = org[1] + right[1] + up[1]; - m.vertex[10] = org[2] + right[2] + up[2]; - m.vertex[12] = org[0] + right[0] - up[0]; - m.vertex[13] = org[1] + right[1] - up[1]; - m.vertex[14] = org[2] + right[2] - up[2]; - m.texcoords[0][0] = tex->s1; - m.texcoords[0][1] = tex->t1; - m.texcoords[0][2] = tex->s1; - m.texcoords[0][3] = tex->t2; - m.texcoords[0][4] = tex->s2; - m.texcoords[0][5] = tex->t2; - m.texcoords[0][6] = tex->s2; - m.texcoords[0][7] = tex->t1; - m.color[0] = m.color[4] = m.color[8] = m.color[12] = cr * m.colorscale; - m.color[1] = m.color[5] = m.color[9] = m.color[13] = cg * m.colorscale; - m.color[2] = m.color[6] = m.color[10] = m.color[14] = cb * m.colorscale; - m.color[3] = m.color[7] = m.color[11] = m.color[15] = ca; - R_Mesh_Render(); - } - } +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_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); +#endif }