X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=cl_particles.c;h=d49affc92c4c3464896070d9973ee8001206a9bb;hb=e537c2269e790f67f68556ded6b7cf62c55874dd;hp=9995ccd8cecdb27994b769327c550b28485247f7;hpb=d88ce08f9848343ae8a8302286b8307c3ec5c4aa;p=xonotic%2Fdarkplaces.git diff --git a/cl_particles.c b/cl_particles.c index 9995ccd8..d49affc9 100644 --- a/cl_particles.c +++ b/cl_particles.c @@ -25,9 +25,8 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. #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_PointQ1Contents(v) (Mod_PointInLeaf(v,cl.worldmodel)->contents) +typedef unsigned char unsigned char; #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) { @@ -37,41 +36,41 @@ void R_Stain (vec3_t origin, float radius, int cr1, int cg1, int cb1, int ca1, i #define CL_ParseParticleEffect R_ParseParticleEffect #define CL_ParticleExplosion R_ParticleExplosion #define CL_ParticleExplosion2 R_ParticleExplosion2 +#define CL_TeleportSplash R_TeleportSplash #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) +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); + VectorNormalize (normal); // calculate 'right' vector for start - VectorSubtract (r_origin, org1, diff); - VectorNormalizeFast (diff); + VectorSubtract (r_vieworigin, org1, diff); + VectorNormalize (diff); CrossProduct (normal, diff, right1); // calculate 'right' vector for end - VectorSubtract (r_origin, org2, diff); - VectorNormalizeFast (diff); + VectorSubtract (r_vieworigin, org2, diff); + VectorNormalize (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]; + 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) +void fractalnoise(unsigned char *noise, int size, int startgrid) { int x, y, g, g2, amplitude, min, max, size1 = size - 1, sizepower, gridpower; int *noisebuf; @@ -79,11 +78,17 @@ void fractalnoise(qbyte *noise, int size, int startgrid) for (sizepower = 0;(1 << sizepower) < size;sizepower++); if (size != (1 << sizepower)) - Sys_Error("fractalnoise: size must be power of 2\n"); + { + Con_Printf("fractalnoise: size must be power of 2\n"); + return; + } for (gridpower = 0;(1 << gridpower) < startgrid;gridpower++); if (startgrid != (1 << gridpower)) - Sys_Error("fractalnoise: grid must be power of 2\n"); + { + Con_Printf("fractalnoise: grid must be power of 2\n"); + return; + } startgrid = bound(0, startgrid, size); @@ -129,7 +134,7 @@ void fractalnoise(qbyte *noise, int size, int startgrid) // 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); + *noise++ = (unsigned char) (((n(x,y) - min) * 256) / max); free(noisebuf); #undef n } @@ -145,125 +150,192 @@ void VectorVectors(const vec3_t forward, vec3_t right, vec3_t up) right[0] -= d * forward[0]; right[1] -= d * forward[1]; right[2] -= d * forward[2]; - VectorNormalizeFast(right); + VectorNormalize(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 +trace_t CL_TraceBox (vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end, int hitbmodels, int *hitent, int hitsupercontentsmask, qboolean hitplayers) +{ +#if QW + pmtrace_t trace; +#else + trace_t trace; +#endif + memset (&trace, 0, sizeof(trace)); + trace.fraction = 1; + VectorCopy (end, trace.endpos); +#if QW + PM_RecursiveHullCheck (cl.model_precache[1]->hulls, 0, 0, 1, start, end, &trace); +#else + RecursiveHullCheck (cl.worldmodel->hulls, 0, 0, 1, start, end, &trace); +#endif + return trace; +} #else #include "cl_collision.h" +#include "image.h" #endif -#define MAX_PARTICLES 8192 // default max # of particles at one time +#define MAX_PARTICLES 32768 // default max # of particles at one time #define ABSOLUTE_MIN_PARTICLES 512 // no fewer than this no matter what's on the command line typedef enum { - pt_static, pt_rain, pt_bubble, pt_blood + PARTICLE_BILLBOARD = 0, + PARTICLE_SPARK = 1, + PARTICLE_ORIENTED_DOUBLESIDED = 2, + PARTICLE_BEAM = 3 } -ptype_t; +porientation_t; -#define PARTICLE_INVALID 0 -#define PARTICLE_BILLBOARD 1 -#define PARTICLE_BEAM 2 -#define PARTICLE_ORIENTED_DOUBLESIDED 3 +typedef enum +{ + PBLEND_ALPHA = 0, + PBLEND_ADD = 1, + PBLEND_MOD = 2 +} +pblend_t; + +typedef struct particletype_s +{ + pblend_t blendmode; + porientation_t orientation; + qboolean lighting; +} +particletype_t; + +typedef enum +{ + pt_alphastatic, pt_static, pt_spark, pt_beam, pt_rain, pt_raindecal, pt_snow, pt_bubble, pt_blood, pt_smoke, pt_decal, pt_entityparticle, pt_total +} +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)) +// must match ptype_t values +particletype_t particletype[pt_total] = +{ + {PBLEND_ALPHA, PARTICLE_BILLBOARD, false}, //pt_alphastatic + {PBLEND_ADD, PARTICLE_BILLBOARD, false}, //pt_static + {PBLEND_ADD, PARTICLE_SPARK, false}, //pt_spark + {PBLEND_ADD, PARTICLE_BEAM, false}, //pt_beam + {PBLEND_ADD, PARTICLE_SPARK, false}, //pt_rain + {PBLEND_ADD, PARTICLE_ORIENTED_DOUBLESIDED, false}, //pt_raindecal + {PBLEND_ADD, PARTICLE_BILLBOARD, false}, //pt_snow + {PBLEND_ADD, PARTICLE_BILLBOARD, false}, //pt_bubble + {PBLEND_MOD, PARTICLE_BILLBOARD, false}, //pt_blood + {PBLEND_ADD, PARTICLE_BILLBOARD, false}, //pt_smoke + {PBLEND_MOD, PARTICLE_ORIENTED_DOUBLESIDED, false}, //pt_decal + {PBLEND_ALPHA, PARTICLE_BILLBOARD, false}, //pt_entityparticle +}; typedef struct particle_s { - ptype_t type; - unsigned int flags; // dynamically lit, orientation, additive blending, texnum + particletype_t *type; + int texnum; vec3_t org; - vec3_t vel; - float die; - float scalex; - float scaley; + vec3_t vel; // velocity of particle, or orientation of decal, or end point of beam + float size; float alpha; // 0-255 float alphafade; // how much alpha reduces per second - float time2; // used for various things (snow fluttering, for example) + float time2; // used for snow fluttering and decal fade 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) - float pressure; // if non-zero, apply pressure to other particles - qbyte color[4]; + unsigned char color[4]; + unsigned short 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 } particle_t; static int particlepalette[256] = { - 0x000000,0x0f0f0f,0x1f1f1f,0x2f2f2f,0x3f3f3f,0x4b4b4b,0x5b5b5b,0x6b6b6b, - 0x7b7b7b,0x8b8b8b,0x9b9b9b,0xababab,0xbbbbbb,0xcbcbcb,0xdbdbdb,0xebebeb, - 0x0f0b07,0x170f0b,0x1f170b,0x271b0f,0x2f2313,0x372b17,0x3f2f17,0x4b371b, - 0x533b1b,0x5b431f,0x634b1f,0x6b531f,0x73571f,0x7b5f23,0x836723,0x8f6f23, - 0x0b0b0f,0x13131b,0x1b1b27,0x272733,0x2f2f3f,0x37374b,0x3f3f57,0x474767, - 0x4f4f73,0x5b5b7f,0x63638b,0x6b6b97,0x7373a3,0x7b7baf,0x8383bb,0x8b8bcb, - 0x000000,0x070700,0x0b0b00,0x131300,0x1b1b00,0x232300,0x2b2b07,0x2f2f07, - 0x373707,0x3f3f07,0x474707,0x4b4b0b,0x53530b,0x5b5b0b,0x63630b,0x6b6b0f, - 0x070000,0x0f0000,0x170000,0x1f0000,0x270000,0x2f0000,0x370000,0x3f0000, - 0x470000,0x4f0000,0x570000,0x5f0000,0x670000,0x6f0000,0x770000,0x7f0000, - 0x131300,0x1b1b00,0x232300,0x2f2b00,0x372f00,0x433700,0x4b3b07,0x574307, - 0x5f4707,0x6b4b0b,0x77530f,0x835713,0x8b5b13,0x975f1b,0xa3631f,0xaf6723, - 0x231307,0x2f170b,0x3b1f0f,0x4b2313,0x572b17,0x632f1f,0x733723,0x7f3b2b, - 0x8f4333,0x9f4f33,0xaf632f,0xbf772f,0xcf8f2b,0xdfab27,0xefcb1f,0xfff31b, - 0x0b0700,0x1b1300,0x2b230f,0x372b13,0x47331b,0x533723,0x633f2b,0x6f4733, - 0x7f533f,0x8b5f47,0x9b6b53,0xa77b5f,0xb7876b,0xc3937b,0xd3a38b,0xe3b397, - 0xab8ba3,0x9f7f97,0x937387,0x8b677b,0x7f5b6f,0x775363,0x6b4b57,0x5f3f4b, - 0x573743,0x4b2f37,0x43272f,0x371f23,0x2b171b,0x231313,0x170b0b,0x0f0707, - 0xbb739f,0xaf6b8f,0xa35f83,0x975777,0x8b4f6b,0x7f4b5f,0x734353,0x6b3b4b, - 0x5f333f,0x532b37,0x47232b,0x3b1f23,0x2f171b,0x231313,0x170b0b,0x0f0707, - 0xdbc3bb,0xcbb3a7,0xbfa39b,0xaf978b,0xa3877b,0x977b6f,0x876f5f,0x7b6353, - 0x6b5747,0x5f4b3b,0x533f33,0x433327,0x372b1f,0x271f17,0x1b130f,0x0f0b07, - 0x6f837b,0x677b6f,0x5f7367,0x576b5f,0x4f6357,0x475b4f,0x3f5347,0x374b3f, - 0x2f4337,0x2b3b2f,0x233327,0x1f2b1f,0x172317,0x0f1b13,0x0b130b,0x070b07, - 0xfff31b,0xefdf17,0xdbcb13,0xcbb70f,0xbba70f,0xab970b,0x9b8307,0x8b7307, - 0x7b6307,0x6b5300,0x5b4700,0x4b3700,0x3b2b00,0x2b1f00,0x1b0f00,0x0b0700, - 0x0000ff,0x0b0bef,0x1313df,0x1b1bcf,0x2323bf,0x2b2baf,0x2f2f9f,0x2f2f8f, - 0x2f2f7f,0x2f2f6f,0x2f2f5f,0x2b2b4f,0x23233f,0x1b1b2f,0x13131f,0x0b0b0f, - 0x2b0000,0x3b0000,0x4b0700,0x5f0700,0x6f0f00,0x7f1707,0x931f07,0xa3270b, - 0xb7330f,0xc34b1b,0xcf632b,0xdb7f3b,0xe3974f,0xe7ab5f,0xefbf77,0xf7d38b, - 0xa77b3b,0xb79b37,0xc7c337,0xe7e357,0x7fbfff,0xabe7ff,0xd7ffff,0x670000, - 0x8b0000,0xb30000,0xd70000,0xff0000,0xfff393,0xfff7c7,0xffffff,0x9f5b53 + 0x000000,0x0f0f0f,0x1f1f1f,0x2f2f2f,0x3f3f3f,0x4b4b4b,0x5b5b5b,0x6b6b6b, // 0-7 + 0x7b7b7b,0x8b8b8b,0x9b9b9b,0xababab,0xbbbbbb,0xcbcbcb,0xdbdbdb,0xebebeb, // 8-15 + 0x0f0b07,0x170f0b,0x1f170b,0x271b0f,0x2f2313,0x372b17,0x3f2f17,0x4b371b, // 16-23 + 0x533b1b,0x5b431f,0x634b1f,0x6b531f,0x73571f,0x7b5f23,0x836723,0x8f6f23, // 24-31 + 0x0b0b0f,0x13131b,0x1b1b27,0x272733,0x2f2f3f,0x37374b,0x3f3f57,0x474767, // 32-39 + 0x4f4f73,0x5b5b7f,0x63638b,0x6b6b97,0x7373a3,0x7b7baf,0x8383bb,0x8b8bcb, // 40-47 + 0x000000,0x070700,0x0b0b00,0x131300,0x1b1b00,0x232300,0x2b2b07,0x2f2f07, // 48-55 + 0x373707,0x3f3f07,0x474707,0x4b4b0b,0x53530b,0x5b5b0b,0x63630b,0x6b6b0f, // 56-63 + 0x070000,0x0f0000,0x170000,0x1f0000,0x270000,0x2f0000,0x370000,0x3f0000, // 64-71 + 0x470000,0x4f0000,0x570000,0x5f0000,0x670000,0x6f0000,0x770000,0x7f0000, // 72-79 + 0x131300,0x1b1b00,0x232300,0x2f2b00,0x372f00,0x433700,0x4b3b07,0x574307, // 80-87 + 0x5f4707,0x6b4b0b,0x77530f,0x835713,0x8b5b13,0x975f1b,0xa3631f,0xaf6723, // 88-95 + 0x231307,0x2f170b,0x3b1f0f,0x4b2313,0x572b17,0x632f1f,0x733723,0x7f3b2b, // 96-103 + 0x8f4333,0x9f4f33,0xaf632f,0xbf772f,0xcf8f2b,0xdfab27,0xefcb1f,0xfff31b, // 104-111 + 0x0b0700,0x1b1300,0x2b230f,0x372b13,0x47331b,0x533723,0x633f2b,0x6f4733, // 112-119 + 0x7f533f,0x8b5f47,0x9b6b53,0xa77b5f,0xb7876b,0xc3937b,0xd3a38b,0xe3b397, // 120-127 + 0xab8ba3,0x9f7f97,0x937387,0x8b677b,0x7f5b6f,0x775363,0x6b4b57,0x5f3f4b, // 128-135 + 0x573743,0x4b2f37,0x43272f,0x371f23,0x2b171b,0x231313,0x170b0b,0x0f0707, // 136-143 + 0xbb739f,0xaf6b8f,0xa35f83,0x975777,0x8b4f6b,0x7f4b5f,0x734353,0x6b3b4b, // 144-151 + 0x5f333f,0x532b37,0x47232b,0x3b1f23,0x2f171b,0x231313,0x170b0b,0x0f0707, // 152-159 + 0xdbc3bb,0xcbb3a7,0xbfa39b,0xaf978b,0xa3877b,0x977b6f,0x876f5f,0x7b6353, // 160-167 + 0x6b5747,0x5f4b3b,0x533f33,0x433327,0x372b1f,0x271f17,0x1b130f,0x0f0b07, // 168-175 + 0x6f837b,0x677b6f,0x5f7367,0x576b5f,0x4f6357,0x475b4f,0x3f5347,0x374b3f, // 176-183 + 0x2f4337,0x2b3b2f,0x233327,0x1f2b1f,0x172317,0x0f1b13,0x0b130b,0x070b07, // 184-191 + 0xfff31b,0xefdf17,0xdbcb13,0xcbb70f,0xbba70f,0xab970b,0x9b8307,0x8b7307, // 192-199 + 0x7b6307,0x6b5300,0x5b4700,0x4b3700,0x3b2b00,0x2b1f00,0x1b0f00,0x0b0700, // 200-207 + 0x0000ff,0x0b0bef,0x1313df,0x1b1bcf,0x2323bf,0x2b2baf,0x2f2f9f,0x2f2f8f, // 208-215 + 0x2f2f7f,0x2f2f6f,0x2f2f5f,0x2b2b4f,0x23233f,0x1b1b2f,0x13131f,0x0b0b0f, // 216-223 + 0x2b0000,0x3b0000,0x4b0700,0x5f0700,0x6f0f00,0x7f1707,0x931f07,0xa3270b, // 224-231 + 0xb7330f,0xc34b1b,0xcf632b,0xdb7f3b,0xe3974f,0xe7ab5f,0xefbf77,0xf7d38b, // 232-239 + 0xa77b3b,0xb79b37,0xc7c337,0xe7e357,0x7fbfff,0xabe7ff,0xd7ffff,0x670000, // 240-247 + 0x8b0000,0xb30000,0xd70000,0xff0000,0xfff393,0xfff7c7,0xffffff,0x9f5b53 // 248-255 }; +int ramp1[8] = {0x6f, 0x6d, 0x6b, 0x69, 0x67, 0x65, 0x63, 0x61}; +int ramp2[8] = {0x6f, 0x6e, 0x6d, 0x6c, 0x6b, 0x6a, 0x68, 0x66}; +int ramp3[8] = {0x6d, 0x6b, 6, 5, 4, 3}; + //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_bubble = 26; +static const int tex_bulletdecal[8] = {8, 9, 10, 11, 12, 13, 14, 15}; +static const int tex_blooddecal[8] = {16, 17, 18, 19, 20, 21, 22, 23}; +static const int tex_bloodparticle[8] = {24, 25, 26, 27, 28, 29, 30, 31}; +static const int tex_rainsplash[16] = {32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47}; +static const int tex_particle = 63; +static const int tex_bubble = 62; +static const int tex_raindrop = 61; +static const int tex_beam = 60; static int cl_maxparticles; static int cl_numparticles; +static int cl_freeparticle; static particle_t *particles; -static particle_t **freeparticles; // list used only in compacting particles array cvar_t cl_particles = {CVAR_SAVE, "cl_particles", "1"}; +cvar_t cl_particles_quality = {CVAR_SAVE, "cl_particles_quality", "1"}; cvar_t cl_particles_size = {CVAR_SAVE, "cl_particles_size", "1"}; +cvar_t cl_particles_quake = {CVAR_SAVE, "cl_particles_quake", "0"}; cvar_t cl_particles_bloodshowers = {CVAR_SAVE, "cl_particles_bloodshowers", "1"}; cvar_t cl_particles_blood = {CVAR_SAVE, "cl_particles_blood", "1"}; -cvar_t cl_particles_blood_size = {CVAR_SAVE, "cl_particles_blood_size", "8"}; cvar_t cl_particles_blood_alpha = {CVAR_SAVE, "cl_particles_blood_alpha", "0.5"}; +cvar_t cl_particles_blood_bloodhack = {CVAR_SAVE, "cl_particles_blood_bloodhack", "1"}; cvar_t cl_particles_bulletimpacts = {CVAR_SAVE, "cl_particles_bulletimpacts", "1"}; +cvar_t cl_particles_explosions_bubbles = {CVAR_SAVE, "cl_particles_explosions_bubbles", "1"}; +cvar_t cl_particles_explosions_smoke = {CVAR_SAVE, "cl_particles_explosions_smokes", "0"}; +cvar_t cl_particles_explosions_sparks = {CVAR_SAVE, "cl_particles_explosions_sparks", "1"}; +cvar_t cl_particles_explosions_shell = {CVAR_SAVE, "cl_particles_explosions_shell", "0"}; cvar_t cl_particles_smoke = {CVAR_SAVE, "cl_particles_smoke", "1"}; +cvar_t cl_particles_smoke_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"}; - -#ifndef WORKINGLQUAKE -static mempool_t *cl_part_mempool; -#endif +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"}; void CL_Particles_Clear(void) { cl_numparticles = 0; + cl_freeparticle = 0; + memset(particles, 0, sizeof(particle_t) * cl_maxparticles); } /* @@ -276,6 +348,7 @@ void CL_Particles_Init (void) { int i; +// COMMANDLINEOPTION: Client: -particles changes maximum number of particles at once, default 32768 i = COM_CheckParm ("-particles"); if (i && i < com_argc - 1) @@ -290,82 +363,134 @@ void CL_Particles_Init (void) Cmd_AddCommand ("pointfile", CL_ReadPointFile_f); Cvar_RegisterVariable (&cl_particles); + Cvar_RegisterVariable (&cl_particles_quality); Cvar_RegisterVariable (&cl_particles_size); + Cvar_RegisterVariable (&cl_particles_quake); Cvar_RegisterVariable (&cl_particles_bloodshowers); Cvar_RegisterVariable (&cl_particles_blood); - Cvar_RegisterVariable (&cl_particles_blood_size); Cvar_RegisterVariable (&cl_particles_blood_alpha); + Cvar_RegisterVariable (&cl_particles_blood_bloodhack); + Cvar_RegisterVariable (&cl_particles_explosions_bubbles); + Cvar_RegisterVariable (&cl_particles_explosions_smoke); + Cvar_RegisterVariable (&cl_particles_explosions_sparks); + Cvar_RegisterVariable (&cl_particles_explosions_shell); Cvar_RegisterVariable (&cl_particles_bulletimpacts); Cvar_RegisterVariable (&cl_particles_smoke); + Cvar_RegisterVariable (&cl_particles_smoke_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 *)); + particles = (particle_t *) Mem_Alloc(cl_mempool, cl_maxparticles * sizeof(particle_t)); #endif - cl_numparticles = 0; + CL_Particles_Clear(); } -#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;\ - {\ - 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)\ - {\ - 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;\ - }\ - part = &particles[cl_numparticles++];\ - part->type = (ptype);\ - part->color[0] = cr2;\ - part->color[1] = cg2;\ - part->color[2] = cb2;\ - part->color[3] = 0xFF;\ - part->flags = partflags;\ - part->scalex = (pscalex);\ - part->scaley = (pscaley);\ - part->alpha = (palpha);\ - part->alphafade = (palphafade);\ - part->die = cl.time + (ptime);\ - part->gravity = (pgravity);\ - part->bounce = (pbounce);\ - part->org[0] = (px);\ - part->org[1] = (py);\ - part->org[2] = (pz);\ - part->vel[0] = (pvx);\ - part->vel[1] = (pvy);\ - part->vel[2] = (pvz);\ - part->time2 = (ptime2);\ - part->vel2[0] = (pvx2);\ - part->vel2[1] = (pvy2);\ - part->vel2[2] = (pvz2);\ - part->friction = (pfriction);\ - part->pressure = (ppressure);\ - }\ +void CL_Particles_Shutdown (void) +{ +#ifdef WORKINGLQUAKE + // No clue what to do here... +#endif +} + +// list of all 26 parameters: +// ptype - any of the pt_ enum values (pt_static, pt_blood, etc), see ptype_t near the top of this file +// pcolor1,pcolor2 - minimum and maximum ranges of color, randomly interpolated to decide particle color +// ptex - any of the tex_ values such as tex_smoke[rand()&7] or tex_particle +// psize - size of particle (or thickness for PARTICLE_SPARK and PARTICLE_BEAM) +// palpha - opacity of particle as 0-255 (can be more than 255) +// palphafade - rate of fade per second (so 256 would mean a 256 alpha particle would fade to nothing in 1 second) +// ptime - how long the particle can live (note it is also removed if alpha drops to nothing) +// pgravity - how much effect gravity has on the particle (0-1) +// pbounce - how much bounce the particle has when it hits a surface (0-1), -1 makes a blood splat when it hits a surface, 0 does not even check for collisions +// px,py,pz - starting origin of particle +// pvx,pvy,pvz - starting velocity of particle +// pfriction - how much the particle slows down per second (0-1 typically, can slowdown faster than 1) +particle_t *particle(particletype_t *ptype, int pcolor1, int pcolor2, int ptex, float psize, float palpha, float palphafade, float pgravity, float pbounce, float px, float py, float pz, float pvx, float pvy, float pvz, float pfriction, float originjitter, float velocityjitter) +{ + int l1, l2; + particle_t *part; + vec3_t v; + for (;cl_freeparticle < cl_maxparticles && particles[cl_freeparticle].type;cl_freeparticle++); + if (cl_freeparticle >= cl_maxparticles) + return NULL; + part = &particles[cl_freeparticle++]; + if (cl_numparticles < cl_freeparticle) + cl_numparticles = cl_freeparticle; + memset(part, 0, sizeof(*part)); + part->type = ptype; + l2 = (int)lhrandom(0.5, 256.5); + l1 = 256 - l2; + part->color[0] = ((((pcolor1 >> 16) & 0xFF) * l1 + ((pcolor2 >> 16) & 0xFF) * l2) >> 8) & 0xFF; + part->color[1] = ((((pcolor1 >> 8) & 0xFF) * l1 + ((pcolor2 >> 8) & 0xFF) * l2) >> 8) & 0xFF; + part->color[2] = ((((pcolor1 >> 0) & 0xFF) * l1 + ((pcolor2 >> 0) & 0xFF) * l2) >> 8) & 0xFF; + part->color[3] = 0xFF; + part->texnum = ptex; + part->size = psize; + part->alpha = palpha; + part->alphafade = palphafade; + part->gravity = pgravity; + part->bounce = pbounce; + VectorRandom(v); + part->org[0] = px + originjitter * v[0]; + part->org[1] = py + originjitter * v[1]; + part->org[2] = pz + originjitter * v[2]; + part->vel[0] = pvx + velocityjitter * v[0]; + part->vel[1] = pvy + velocityjitter * v[1]; + part->vel[2] = pvz + velocityjitter * v[2]; + part->time2 = 0; + part->friction = pfriction; + return part; +} + +void CL_SpawnDecalParticleForSurface(int hitent, const vec3_t org, const vec3_t normal, int color1, int color2, int texnum, float size, float alpha) +{ + particle_t *p; + if (!cl_decals.integer) + return; + p = particle(particletype + pt_decal, color1, color2, texnum, size, alpha, 0, 0, 0, org[0] + normal[0], org[1] + normal[1], org[2] + normal[2], normal[0], normal[1], normal[2], 0, 0, 0); + if (p) + { + p->time2 = cl.time; +#ifndef WORKINGLQUAKE + p->owner = hitent; + p->ownermodel = cl_entities[p->owner].render.model; + Matrix4x4_Transform(&cl_entities[p->owner].render.inversematrix, org, p->relativeorigin); + Matrix4x4_Transform3x3(&cl_entities[p->owner].render.inversematrix, normal, p->relativedirection); + VectorAdd(p->relativeorigin, p->relativedirection, p->relativeorigin); +#endif + } +} + +void CL_SpawnDecalParticleForPoint(const vec3_t org, float maxdist, float size, float alpha, int texnum, int color1, int color2) +{ + int i; + float bestfrac, bestorg[3], bestnormal[3]; + float org2[3]; + int besthitent = 0, hitent; + trace_t trace; + bestfrac = 10; + for (i = 0;i < 32;i++) + { + VectorRandom(org2); + VectorMA(org, maxdist, org2, org2); + trace = CL_TraceBox(org, vec3_origin, vec3_origin, org2, true, &hitent, SUPERCONTENTS_SOLID, false); + if (bestfrac > trace.fraction) + { + bestfrac = trace.fraction; + besthitent = hitent; + VectorCopy(trace.endpos, bestorg); + VectorCopy(trace.plane.normal, bestnormal); + } + } + if (bestfrac < 1) + CL_SpawnDecalParticleForSurface(besthitent, bestorg, bestnormal, color1, color2, texnum, size, alpha); } /* @@ -375,76 +500,60 @@ CL_EntityParticles */ void CL_EntityParticles (entity_t *ent) { - int i; - float angle; - float sp, sy, cp, cy; - vec3_t forward; - float dist; - float beamlength; + int i; + float pitch, yaw, dist = 64, beamlength = 16, org[3], v[3]; static vec3_t avelocities[NUMVERTEXNORMALS]; if (!cl_particles.integer) return; - dist = 64; - beamlength = 16; +#ifdef WORKINGLQUAKE + VectorCopy(ent->origin, org); +#else + Matrix4x4_OriginFromMatrix(&ent->render.matrix, org); +#endif if (!avelocities[0][0]) - for (i=0 ; iorigin[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 + yaw = cl.time * avelocities[i][0]; + pitch = cl.time * avelocities[i][1]; + v[0] = org[0] + m_bytenormals[i][0] * dist + (cos(pitch)*cos(yaw)) * beamlength; + v[1] = org[1] + m_bytenormals[i][1] * dist + (cos(pitch)*sin(yaw)) * beamlength; + v[2] = org[2] + m_bytenormals[i][2] * dist + (-sin(pitch)) * beamlength; + particle(particletype + pt_entityparticle, particlepalette[0x6f], particlepalette[0x6f], tex_particle, 1, 255, 0, 0, 0, v[0], v[1], v[2], 0, 0, 0, 0, 0, 0); } } void CL_ReadPointFile_f (void) { - vec3_t org; - int r, c; - char *pointfile = NULL, *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; + + FS_StripExtension (cl.worldmodel->name, name, sizeof (name)); + strlcat (name, ".pts", sizeof (name)); #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); - } + pointfile = COM_LoadTempFile (name); #else - pointfile = COM_LoadFile(va("maps/%s.pts", cl.worldmodel->name), true); + pointfile = (char *)FS_LoadFile(name, tempmempool, true, NULL); #endif if (!pointfile) { - Con_Printf ("couldn't open %s.pts\n", cl.worldmodel->name); + Con_Printf("Could not open %s\n", name); return; } - Con_Printf ("Reading %s.pts...\n", cl.worldmodel->name); + Con_Printf("Reading %s...\n", name); + VectorClear(leakorg); c = 0; + s = 0; pointfilepos = pointfile; while (*pointfilepos) { @@ -462,22 +571,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(particletype + pt_static, particlepalette[(-c)&15], particlepalette[(-c)&15], tex_particle, 2, 255, 0, 0, 0, org[0], org[1], org[2], 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 +#ifndef WORKINGLQUAKE Mem_Free(pointfile); #endif - Con_Printf ("%i points read\n", c); + 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(particletype + pt_beam, 0xFF0000, 0xFF0000, tex_beam, 64, 255, 0, 0, 0, org[0] - 4096, org[1], org[2], org[0] + 4096, org[1], org[2], 0, 0, 0); + particle(particletype + pt_beam, 0x00FF00, 0x00FF00, tex_beam, 64, 255, 0, 0, 0, org[0], org[1] - 4096, org[2], org[0], org[1] + 4096, org[2], 0, 0, 0); + particle(particletype + pt_beam, 0x0000FF, 0x0000FF, tex_beam, 64, 255, 0, 0, 0, org[0], org[1], org[2] - 4096, org[0], org[1], org[2] + 4096, 0, 0, 0); } /* @@ -492,10 +604,9 @@ void CL_ParseParticleEffect (void) vec3_t org, dir; int i, count, msgcount, color; + MSG_ReadVector(org, cl.protocol); for (i=0 ; i<3 ; i++) - org[i] = MSG_ReadCoord (); - for (i=0 ; i<3 ; i++) - dir[i] = MSG_ReadChar () * (1.0/16); + dir[i] = MSG_ReadChar (); msgcount = MSG_ReadByte (); color = MSG_ReadByte (); @@ -504,6 +615,21 @@ void CL_ParseParticleEffect (void) else count = msgcount; + if (cl_particles_blood_bloodhack.integer && !cl_particles_quake.integer) + { + if (color == 73) + { + // regular blood + CL_BloodPuff(org, dir, count / 2); + return; + } + if (color == 225) + { + // lightning blood + CL_BloodPuff(org, dir, count / 2); + return; + } + } CL_RunParticleEffect (org, dir, color, count); } @@ -515,62 +641,79 @@ CL_ParticleExplosion */ void CL_ParticleExplosion (vec3_t org) { - int i, k; + int i; + trace_t trace; //vec3_t v; //vec3_t v2; if (cl_stainmaps.integer) R_Stain(org, 96, 80, 80, 80, 64, 176, 176, 176, 64); + CL_SpawnDecalParticleForPoint(org, 40, 48, 255, tex_bulletdecal[rand()&7], 0xFFFFFF, 0xFFFFFF); - i = Mod_PointContents(org, cl.worldmodel); - if ((i == CONTENTS_SLIME || i == CONTENTS_WATER) && cl_particles.integer && cl_particles_bubbles.integer) + if (cl_particles_quake.integer) { - for (i = 0;i < 128;i++) + for (i = 0;i < 1024;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); + int r, color; + r = rand()&3; + if (i & 1) + { + color = particlepalette[ramp1[r]]; + particle(particletype + pt_alphastatic, color, color, tex_particle, 1, (1.0f / cl_particles_quality.value) * 32 * (8 - r), (1.0f / cl_particles_quality.value) * 318, 0, 0, org[0], org[1], org[2], 0, 0, 0, -4, 16, 256); + } + else + { + color = particlepalette[ramp2[r]]; + particle(particletype + pt_alphastatic, color, color, tex_particle, 1, (1.0f / cl_particles_quality.value) * 32 * (8 - r), (1.0f / cl_particles_quality.value) * 478, 0, 0, org[0], org[1], org[2], 0, 0, 0, 1, 16, 256); + } } } else { - /* - // LordHavoc: smoke effect similar to UT2003, chews fillrate too badly up close - // smoke puff - if (cl_particles_smoke.integer) + i = CL_PointSuperContents(org); + if (i & (SUPERCONTENTS_SLIME | SUPERCONTENTS_WATER)) + { + if (cl_particles.integer && cl_particles_bubbles.integer && cl_particles_explosions_bubbles.integer) + for (i = 0;i < 128 * cl_particles_quality.value;i++) + particle(particletype + pt_bubble, 0x404040, 0x808080, tex_bubble, 2, (1.0f / cl_particles_quality.value) * lhrandom(128, 255), (1.0f / cl_particles_quality.value) * 128, -0.125, 1.5, org[0], org[1], org[2], 0, 0, 0, (1.0 / 16.0), 16, 96); + } + else { - for (i = 0;i < 64;i++) + // LordHavoc: smoke effect similar to UT2003, chews fillrate too badly up close + // smoke puff + if (cl_particles.integer && cl_particles_smoke.integer && cl_particles_explosions_smoke.integer) { + for (i = 0;i < 32;i++) + { + int k; + vec3_t v, v2; #ifdef WORKINGLQUAKE - v2[0] = lhrandom(-64, 64); - v2[1] = lhrandom(-64, 64); - v2[2] = lhrandom(-8, 24); + v2[0] = lhrandom(-48, 48); + v2[1] = lhrandom(-48, 48); + v2[2] = lhrandom(-48, 48); #else - for (k = 0;k < 16;k++) - { - v[0] = org[0] + lhrandom(-64, 64); - v[1] = org[1] + lhrandom(-64, 64); - v[2] = org[2] + lhrandom(-8, 24); - if (CL_TraceLine(org, v, v2, NULL, 0, true, NULL) >= 0.1) - break; - } - VectorSubtract(v2, org, v2); + for (k = 0;k < 16;k++) + { + v[0] = org[0] + lhrandom(-48, 48); + v[1] = org[1] + lhrandom(-48, 48); + v[2] = org[2] + lhrandom(-48, 48); + trace = CL_TraceBox(org, vec3_origin, vec3_origin, v, true, NULL, SUPERCONTENTS_SOLID, false); + if (trace.fraction >= 0.1) + break; + } + VectorSubtract(trace.endpos, 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); + VectorScale(v2, 2.0f, v2); + particle(particletype + pt_smoke, 0x202020, 0x404040, tex_smoke[rand()&7], 12, 32, 64, 0, 0, org[0], org[1], org[2], v2[0], v2[1], v2[2], 0, 0, 0); + } } - } - */ - if (cl_particles_sparks.integer) - { - // sparks - for (i = 0;i < 256;i++) - { - k = particlepalette[0x68 + (rand() & 7)]; - particle(pt_static, PARTICLE_BEAM, k, k, tex_particle, false, true, 1.5f, 0.05f, lhrandom(0, 255), 512, 9999, 1, 0, org[0], org[1], org[2], lhrandom(-192, 192), lhrandom(-192, 192), lhrandom(-192, 192) + 160, 0, 0, 0, 0, 0, 0); - } + if (cl_particles.integer && cl_particles_sparks.integer && cl_particles_explosions_sparks.integer) + for (i = 0;i < 128 * cl_particles_quality.value;i++) + particle(particletype + pt_spark, 0x903010, 0xFFD030, tex_particle, 1.0f, (1.0f / cl_particles_quality.value) * lhrandom(0, 255), (1.0f / cl_particles_quality.value) * 512, 1, 0, org[0], org[1], org[2], 0, 0, 80, 0.2, 0, 256); } } - if (cl_explosions.integer) + if (cl_particles_explosions_shell.integer) R_NewExplosion(org); } @@ -585,10 +728,13 @@ void CL_ParticleExplosion2 (vec3_t org, int colorStart, int colorLength) int i, k; if (!cl_particles.integer) return; - for (i = 0;i < 512;i++) + for (i = 0;i < 512 * cl_particles_quality.value;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); + if (cl_particles_quake.integer) + particle(particletype + pt_static, k, k, tex_particle, 1, (1.0f / cl_particles_quality.value) * 255, (1.0f/cl_particles_quality.value)*850, 0, 0, org[0], org[1], org[2], 0, 0, 0, -4, 8, 256); + else + particle(particletype + pt_static, k, k, tex_particle, lhrandom(0.5, 1.5), (1.0f / cl_particles_quality.value) * 255, (1.0f/cl_particles_quality.value)*512, 0, 0, org[0], org[1], org[2], 0, 0, 0, lhrandom(1.5, 3), 8, 192); } } @@ -600,11 +746,28 @@ CL_BlobExplosion */ void CL_BlobExplosion (vec3_t org) { - if (cl_stainmaps.integer) - R_Stain(org, 96, 80, 80, 80, 64, 176, 176, 176, 64); + int i, k; + if (!cl_particles.integer) return; - if (cl_explosions.integer) - R_NewExplosion(org); + if (!cl_particles_quake.integer) + { + CL_ParticleExplosion(org); + return; + } + + for (i = 0;i < 1024 * cl_particles_quality.value;i++) + { + if (i & 1) + { + k = particlepalette[66 + rand()%6]; + particle(particletype + pt_static, k, k, tex_particle, 1, (1.0f / cl_particles_quality.value) * lhrandom(182, 255), (1.0f/cl_particles_quality.value)*182, 0, 0, org[0], org[1], org[2], 0, 0, 0, -4, 16, 256); + } + else + { + k = particlepalette[150 + rand()%6]; + particle(particletype + pt_static, k, k, tex_particle, 1, (1.0f / cl_particles_quality.value) * lhrandom(182, 255), (1.0f/cl_particles_quality.value)*182, 0, 0, org[0], org[1], org[2], 0, 0, lhrandom(-256, 256), 0, 16, 0); + } + } } /* @@ -623,10 +786,26 @@ void CL_RunParticleEffect (vec3_t org, vec3_t dir, int color, int count) return; } if (!cl_particles.integer) return; - while (count--) + if (cl_particles_quake.integer) { - 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); + count *= cl_particles_quality.value; + while (count--) + { + k = particlepalette[color + (rand()&7)]; + particle(particletype + pt_alphastatic, k, k, tex_particle, 1, (1.0f / cl_particles_quality.value) * lhrandom(51, 255), (1.0f / cl_particles_quality.value) * 512, 0, 0.05, org[0], org[1], org[2], dir[0], dir[1], dir[2], 0, 8, 0); + } + } + else + { + count *= cl_particles_quality.value; + while (count--) + { + k = particlepalette[color + (rand()&7)]; + if (gamemode == GAME_GOODVSBAD2) + particle(particletype + pt_alphastatic, k, k, tex_particle, 5, (1.0f / cl_particles_quality.value) * 255, (1.0f / cl_particles_quality.value) * 300, 0, 0, org[0], org[1], org[2], 0, 0, 0, 0, 8, 10); + else + particle(particletype + pt_alphastatic, k, k, tex_particle, 1, (1.0f / cl_particles_quality.value) * 255, (1.0f / cl_particles_quality.value) * 512, 0, 0, org[0], org[1], org[2], dir[0], dir[1], dir[2], 0, 8, 15); + } } } @@ -636,71 +815,95 @@ void CL_RunParticleEffect (vec3_t org, vec3_t dir, int color, int count) CL_SparkShower =============== */ -void CL_SparkShower (vec3_t org, vec3_t dir, int count) +void CL_SparkShower (vec3_t org, vec3_t dir, int count, vec_t gravityscale) { int k; - if (!cl_particles.integer) return; - if (cl_stainmaps.integer) - R_Stain(org, 32, 96, 96, 96, 24, 128, 128, 128, 24); + if (!cl_particles.integer) return; - if (cl_particles_bulletimpacts.integer) + if (cl_particles_sparks.integer) { - // smoke puff - if (cl_particles_smoke.integer) + // sparks + count *= cl_particles_quality.value; + while(count--) { - k = count / 4; - while(k--) - { - particle(pt_static, PARTICLE_BILLBOARD, 0x101010, 0x202020, tex_smoke[rand()&7], true, true, 4, 4, 255, 1024, 9999, -0.2, 0, org[0] + 0.125f * lhrandom(-count, count), org[1] + 0.125f * lhrandom (-count, count), org[2] + 0.125f * lhrandom(-count, count), lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(0, 16), 0, 0, 0, 0, 0, 0); - } + k = particlepalette[0x68 + (rand() & 7)]; + particle(particletype + pt_spark, k, k, tex_particle, 0.4f, (1.0f / cl_particles_quality.value) * lhrandom(64, 255), (1.0f / cl_particles_quality.value) * 512, gravityscale, 0, org[0], org[1], org[2], dir[0], dir[1], dir[2] + sv_gravity.value * 0.1, 0, 0, 64); } + } +} + +void CL_Smoke (vec3_t org, vec3_t dir, int count) +{ + vec3_t org2; + int k; + trace_t trace; + + if (!cl_particles.integer) return; - if (cl_particles_sparks.integer) + // smoke puff + if (cl_particles_smoke.integer) + { + k = count * 0.25 * cl_particles_quality.value; + while(k--) { - // 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); - } + 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); + trace = CL_TraceBox(org, vec3_origin, vec3_origin, org2, true, NULL, SUPERCONTENTS_SOLID, false); + particle(particletype + pt_smoke, 0x101010, 0x202020, tex_smoke[rand()&7], 3, (1.0f / cl_particles_quality.value) * 255, (1.0f / cl_particles_quality.value) * 1024, 0, 0, trace.endpos[0], trace.endpos[1], trace.endpos[2], 0, 0, 0, 0, 0, 8); } } } +void CL_BulletMark (vec3_t org) +{ + if (cl_stainmaps.integer) + R_Stain(org, 32, 96, 96, 96, 24, 128, 128, 128, 24); + CL_SpawnDecalParticleForPoint(org, 6, 3, 255, tex_bulletdecal[rand()&7], 0xFFFFFF, 0xFFFFFF); +} + void CL_PlasmaBurn (vec3_t org) { if (cl_stainmaps.integer) R_Stain(org, 48, 96, 96, 96, 32, 128, 128, 128, 32); + CL_SpawnDecalParticleForPoint(org, 6, 6, 255, tex_bulletdecal[rand()&7], 0xFFFFFF, 0xFFFFFF); } static float bloodcount = 0; void CL_BloodPuff (vec3_t org, vec3_t vel, int count) { - float s, r, a; + float s; + vec3_t org2; + trace_t trace; // bloodcount is used to accumulate counts too small to cause a blood particle if (!cl_particles.integer) return; + if (cl_particles_quake.integer) + { + CL_RunParticleEffect(org, vel, 73, count * 2); + return; + } if (!cl_particles_blood.integer) return; - s = count + 32.0f; + s = count + 64.0f; count *= 5.0f; if (count > 1000) count = 1000; bloodcount += count; - r = cl_particles_blood_size.value; - a = cl_particles_blood_alpha.value * 255; while(bloodcount > 0) { - 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; + 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); + trace = CL_TraceBox(org, vec3_origin, vec3_origin, org2, true, NULL, SUPERCONTENTS_SOLID, false); + particle(particletype + pt_blood, 0xFFFFFF, 0xFFFFFF, tex_bloodparticle[rand()&7], 8, cl_particles_blood_alpha.value * 768 / cl_particles_quality.value, cl_particles_blood_alpha.value * 384 / cl_particles_quality.value, 0, -1, trace.endpos[0], trace.endpos[1], trace.endpos[2], vel[0], vel[1], vel[2], 1, 0, s); + bloodcount -= 16 / cl_particles_quality.value; } } void CL_BloodShower (vec3_t mins, vec3_t maxs, float velspeed, int count) { - float r; - float a; - vec3_t diff, center, velscale; + vec3_t org, vel, diff, center, velscale; if (!cl_particles.integer) return; if (!cl_particles_bloodshowers.integer) return; if (!cl_particles_blood.integer) return; @@ -709,25 +912,21 @@ void CL_BloodShower (vec3_t mins, vec3_t maxs, float velspeed, int count) center[0] = (mins[0] + maxs[0]) * 0.5; center[1] = (mins[1] + maxs[1]) * 0.5; center[2] = (mins[2] + maxs[2]) * 0.5; - // FIXME: change velspeed back to 2.0x after fixing mod velscale[0] = velspeed * 2.0 / diff[0]; velscale[1] = velspeed * 2.0 / diff[1]; velscale[2] = velspeed * 2.0 / diff[2]; bloodcount += count * 5.0f; - r = cl_particles_blood_size.value; - a = cl_particles_blood_alpha.value * 255; while (bloodcount > 0) { - vec3_t org, vel; org[0] = lhrandom(mins[0], maxs[0]); org[1] = lhrandom(mins[1], maxs[1]); org[2] = lhrandom(mins[2], maxs[2]); vel[0] = (org[0] - center[0]) * velscale[0]; vel[1] = (org[1] - center[1]) * velscale[1]; vel[2] = (org[2] - center[2]) * velscale[2]; - bloodcount -= r; - particle(pt_blood, PARTICLE_BILLBOARD, 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); + bloodcount -= 16 / cl_particles_quality.value; + particle(particletype + pt_blood, 0xFFFFFF, 0xFFFFFF, tex_bloodparticle[rand()&7], 8, cl_particles_blood_alpha.value * 768 / cl_particles_quality.value, cl_particles_blood_alpha.value * 384 / cl_particles_quality.value, 0, -1, org[0], org[1], org[2], vel[0], vel[1], vel[2], 1, 0, 0); } } @@ -740,10 +939,11 @@ void CL_ParticleCube (vec3_t mins, vec3_t maxs, vec3_t dir, int count, int color if (maxs[1] <= mins[1]) {t = mins[1];mins[1] = maxs[1];maxs[1] = t;} if (maxs[2] <= mins[2]) {t = mins[2];mins[2] = maxs[2];maxs[2] = t;} + count *= cl_particles_quality.value; while (count--) { k = particlepalette[colorbase + (rand()&3)]; - particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, 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(particletype + pt_alphastatic, k, k, tex_particle, 2, 255 / cl_particles_quality.value, (255 / cl_particles_quality.value) / 2, gravity ? 1 : 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(mins[2], maxs[2]), dir[0], dir[1], dir[2], 0, 0, randomvel); } } @@ -751,28 +951,23 @@ void CL_ParticleRain (vec3_t mins, vec3_t maxs, vec3_t dir, int count, int color { int k; float t, z, minz, maxz; + particle_t *p; 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;} if (maxs[2] <= mins[2]) {t = mins[2];mins[2] = maxs[2];maxs[2] = t;} if (dir[2] < 0) // falling - { - t = (maxs[2] - mins[2]) / -dir[2]; z = maxs[2]; - } else // rising?? - { - t = (maxs[2] - mins[2]) / dir[2]; z = mins[2]; - } - 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]); + count *= cl_particles_quality.value; + switch(type) { case 0: @@ -781,18 +976,26 @@ void CL_ParticleRain (vec3_t mins, vec3_t maxs, vec3_t dir, int count, int color while(count--) { k = particlepalette[colorbase + (rand()&3)]; - particle(pt_rain, PARTICLE_BEAM, k, k, tex_particle, true, true, 0.5, 0.02, lhrandom(8, 16), 0, t, 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz), dir[0], dir[1], dir[2], cl.time + 9999, dir[0], dir[1], dir[2], 0, 0); + if (gamemode == GAME_GOODVSBAD2) + particle(particletype + pt_rain, k, k, tex_particle, 20, lhrandom(8, 16) / cl_particles_quality.value, 0, 0, -1, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz), dir[0], dir[1], dir[2], 0, 0, 0); + else + particle(particletype + pt_rain, k, k, tex_particle, 0.5, lhrandom(8, 16) / cl_particles_quality.value, 0, 0, -1, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz), dir[0], dir[1], dir[2], 0, 0, 0); } 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) + p = particle(particletype + pt_snow, k, k, tex_particle, 20, lhrandom(64, 128) / cl_particles_quality.value, 0, 0, -1, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz), dir[0], dir[1], dir[2], 0, 0, 0); + else + p = particle(particletype + pt_snow, k, k, tex_particle, 1, lhrandom(64, 128) / cl_particles_quality.value, 0, 0, -1, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz), dir[0], dir[1], dir[2], 0, 0, 0); + if (p) + VectorCopy(p->vel, p->relativedirection); } break; default: - Host_Error("CL_ParticleRain: unknown type %i (0 = rain, 1 = snow)\n", type); + Con_Printf ("CL_ParticleRain: unknown type %i (0 = rain, 1 = snow)\n", type); } } @@ -811,6 +1014,7 @@ void CL_Stardust (vec3_t mins, vec3_t maxs, int count) center[1] = (mins[1] + maxs[1]) * 0.5f; center[2] = (mins[2] + maxs[2]) * 0.5f; + count *= cl_particles_quality.value; while (count--) { k = particlepalette[224 + (rand()&15)]; @@ -818,10 +1022,10 @@ void CL_Stardust (vec3_t mins, vec3_t maxs, int count) o[1] = lhrandom(mins[1], maxs[1]); o[2] = lhrandom(mins[2], maxs[2]); VectorSubtract(o, center, v); - VectorNormalizeFast(v); + VectorNormalize(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(particletype + pt_static, 0x903010, 0xFFD030, tex_particle, 1.5, lhrandom(64, 128) / cl_particles_quality.value, 128 / cl_particles_quality.value, 1, 0, o[0], o[1], o[2], v[0], v[1], v[2], 0.2, 0, 0); } } @@ -834,12 +1038,13 @@ void CL_FlameCube (vec3_t mins, vec3_t maxs, int count) if (maxs[1] <= mins[1]) {t = mins[1];mins[1] = maxs[1];maxs[1] = t;} if (maxs[2] <= mins[2]) {t = mins[2];mins[2] = maxs[2];maxs[2] = t;} + count *= cl_particles_quality.value; while (count--) { k = particlepalette[224 + (rand()&15)]; - particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, 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(particletype + pt_static, k, k, tex_particle, 4, lhrandom(64, 128) / cl_particles_quality.value, 384 / cl_particles_quality.value, -1, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(mins[2], maxs[2]), 0, 0, 32, 1, 0, 32); 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(particletype + pt_static, 0x303030, 0x606060, tex_smoke[rand()&7], 6, lhrandom(48, 96) / cl_particles_quality.value, 64 / cl_particles_quality.value, 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(mins[2], maxs[2]), 0, 0, 24, 0, 0, 8); } } @@ -848,10 +1053,11 @@ void CL_Flames (vec3_t org, vec3_t vel, int count) int k; if (!cl_particles.integer) return; + count *= cl_particles_quality.value; while (count--) { k = particlepalette[224 + (rand()&15)]; - particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, 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(particletype + pt_static, k, k, tex_particle, 4, lhrandom(64, 128) / cl_particles_quality.value, 384 / cl_particles_quality.value, -1, 1.1, org[0], org[1], org[2], vel[0], vel[1], vel[2], 1, 0, 128); } } @@ -865,24 +1071,56 @@ CL_LavaSplash */ void CL_LavaSplash (vec3_t origin) { - int i, j, k; - float vel; + float i, j, inc, vel; + int k, l; vec3_t dir, org; if (!cl_particles.integer) return; - for (i=-128 ; i<128 ; i+=16) + if (cl_particles_quake.integer) { - for (j=-128 ; j<128 ; j+=16) + inc = 8 / cl_particles_quality.value; + for (i = -128;i < 128;i += inc) { - dir[0] = j + lhrandom(0, 8); - dir[1] = i + lhrandom(0, 8); - dir[2] = 256; - org[0] = origin[0] + dir[0]; - 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); + for (j = -128;j < 128;j += inc) + { + dir[0] = j + lhrandom(0, inc); + dir[1] = i + lhrandom(0, inc); + dir[2] = 256; + org[0] = origin[0] + dir[0]; + org[1] = origin[1] + dir[1]; + org[2] = origin[2] + lhrandom(0, 64); + vel = lhrandom(50, 120) / VectorLength(dir); // normalize and scale + k = l = particlepalette[224 + (rand()&7)]; + particle(particletype + pt_alphastatic, k, l, tex_particle, 1, inc * lhrandom(24, 32), inc * 12, 0.05, 0, org[0], org[1], org[2], dir[0] * vel, dir[1] * vel, dir[2] * vel, 0, 0, 0); + } + } + } + else + { + inc = 32 / cl_particles_quality.value; + for (i = -128;i < 128;i += inc) + { + for (j = -128;j < 128;j += inc) + { + dir[0] = j + lhrandom(0, inc); + dir[1] = i + lhrandom(0, inc); + dir[2] = 256; + org[0] = origin[0] + dir[0]; + org[1] = origin[1] + dir[1]; + org[2] = origin[2] + lhrandom(0, 64); + vel = lhrandom(50, 120) / VectorLength(dir); // normalize and scale + if (gamemode == GAME_GOODVSBAD2) + { + k = particlepalette[0 + (rand()&255)]; + l = particlepalette[0 + (rand()&255)]; + particle(particletype + pt_static, k, l, tex_particle, 12, inc * 8, inc * 8, 0.05, 1, org[0], org[1], org[2], dir[0] * vel, dir[1] * vel, dir[2] * vel, 0, 0, 0); + } + else + { + k = l = particlepalette[224 + (rand()&7)]; + particle(particletype + pt_static, k, l, tex_particle, 12, inc * 8, inc * 8, 0.05, 0, org[0], org[1], org[2], dir[0] * vel, dir[1] * vel, dir[2] * vel, 0, 0, 0); + } + } } } } @@ -893,28 +1131,55 @@ CL_TeleportSplash =============== */ -#if WORKINGLQUAKE -void R_TeleportSplash (vec3_t org) +void CL_TeleportSplash (vec3_t org) { - int i, j, k; + float i, j, k, inc; if (!cl_particles.integer) return; - for (i=-16 ; i<16 ; i+=8) - for (j=-16 ; j<16 ; j+=8) - for (k=-24 ; k<32 ; k+=8) - particle(pt_static, PARTICLE_BILLBOARD, 0xA0A0A0, 0xFFFFFF, tex_particle, false, 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); + if (cl_particles_quake.integer) + { + inc = 4 / cl_particles_quality.value; + for (i = -16;i < 16;i += inc) + { + for (j = -16;j < 16;j += inc) + { + for (k = -24;k < 32;k += inc) + { + vec3_t dir; + float vel; + VectorSet(dir, i*8, j*8, k*8); + VectorNormalize(dir); + vel = lhrandom(50, 113); + particle(particletype + pt_alphastatic, particlepalette[7], particlepalette[14], tex_particle, 1, inc * lhrandom(37, 63), inc * 187, 0, 0, org[0] + i + lhrandom(0, inc), org[1] + j + lhrandom(0, inc), org[2] + k + lhrandom(0, inc), dir[0] * vel, dir[1] * vel, dir[2] * vel, 0, 0, 0); + } + } + } + } + else + { + inc = 8 / cl_particles_quality.value; + for (i = -16;i < 16;i += inc) + for (j = -16;j < 16;j += inc) + for (k = -24;k < 32;k += inc) + particle(particletype + pt_static, 0xA0A0A0, 0xFFFFFF, tex_particle, 10, inc * lhrandom(8, 16), inc * 32, 0, 0, org[0] + i + lhrandom(0, inc), org[1] + j + lhrandom(0, inc), org[2] + k + lhrandom(0, inc), 0, 0, lhrandom(-256, 256), 1, 0, 0); + } } -#endif #ifdef WORKINGLQUAKE void R_RocketTrail (vec3_t start, vec3_t end, int type) #else -void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent) +void CL_RocketTrail (vec3_t start, vec3_t end, int type, int color, entity_t *ent) #endif { vec3_t vec, dir, vel, pos; - float len, dec, speed, r; - int contents, smoke, blood, bubbles; + float len, dec, speed, qd; + int smoke, blood, bubbles, r; +#ifdef WORKINGLQUAKE + int contents; +#endif + + if (end[0] == start[0] && end[1] == start[1] && end[2] == start[2]) + return; VectorSubtract(end, start, dir); VectorNormalize(dir); @@ -935,8 +1200,11 @@ void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent) // if we skip out, leave it reset ent->persistent.trail_time = 0.0f; - speed = 1.0f / (ent->state_current.time - ent->state_previous.time); + speed = ent->state_current.time - ent->state_previous.time; + if (speed) + speed = 1.0f / speed; VectorSubtract(ent->state_current.origin, ent->state_previous.origin, vel); + color = particlepalette[color]; #endif VectorScale(vel, speed, vel); @@ -944,82 +1212,179 @@ void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent) VectorMA(start, dec, vec, pos); len -= dec; - contents = Mod_PointContents(pos, cl.worldmodel); - if (contents == CONTENTS_SKY || contents == CONTENTS_LAVA) - return; - smoke = cl_particles.integer && cl_particles_smoke.integer; blood = cl_particles.integer && cl_particles_blood.integer; +#ifdef WORKINGLQUAKE + contents = CL_PointQ1Contents(pos); bubbles = cl_particles.integer && cl_particles_bubbles.integer && (contents == CONTENTS_WATER || contents == CONTENTS_SLIME); +#else + bubbles = cl_particles.integer && cl_particles_bubbles.integer && (CL_PointSuperContents(pos) & (SUPERCONTENTS_WATER | SUPERCONTENTS_SLIME)); +#endif + qd = 1.0f / cl_particles_quality.value; while (len >= 0) { switch (type) { case 0: // rocket trail - dec = 3; - if (smoke) + if (cl_particles_quake.integer) { - 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); + dec = qd*3; + r = rand()&3; + color = particlepalette[ramp3[r]]; + particle(particletype + pt_alphastatic, color, color, tex_particle, 1, qd*42*(6-r), qd*306, 0, -0.05, pos[0], pos[1], pos[2], 0, 0, 0, 0, 3, 0); } - if (bubbles) + else { - 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); + dec = qd*3; + if (smoke) + { + particle(particletype + pt_smoke, 0x303030, 0x606060, tex_smoke[rand()&7], 3, qd*cl_particles_smoke_alpha.value*62, qd*cl_particles_smoke_alphafade.value*62, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0); + particle(particletype + pt_static, 0x801010, 0xFFA020, tex_smoke[rand()&7], 3, qd*cl_particles_smoke_alpha.value*288, qd*cl_particles_smoke_alphafade.value*1400, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 20); + } + if (bubbles) + particle(particletype + pt_bubble, 0x404040, 0x808080, tex_bubble, 2, qd*lhrandom(64, 255), qd*256, -0.25, 1.5, pos[0], pos[1], pos[2], 0, 0, 0, (1.0 / 16.0), 0, 16); } break; case 1: // grenade trail - // FIXME: make it gradually stop smoking - dec = 3; - if (cl_particles.integer && cl_particles_smoke.integer) + if (cl_particles_quake.integer) + { + dec = qd*3; + r = 2 + (rand()%5); + color = particlepalette[ramp3[r]]; + particle(particletype + pt_alphastatic, color, color, tex_particle, 1, qd*42*(6-r), qd*306, 0, -0.05, pos[0], pos[1], pos[2], 0, 0, 0, 0, 3, 0); + } + else { - 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); + dec = qd*3; + if (smoke) + particle(particletype + pt_smoke, 0x303030, 0x606060, tex_smoke[rand()&7], 3, qd*cl_particles_smoke_alpha.value*50, qd*cl_particles_smoke_alphafade.value*50, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0); } break; case 2: // blood case 4: // slight blood - dec = cl_particles_blood_size.value; - if (blood) + if (cl_particles_quake.integer) { - 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); + if (type == 2) + { + dec = qd*3; + color = particlepalette[67 + (rand()&3)]; + particle(particletype + pt_alphastatic, color, color, tex_particle, 1, qd*255, qd*128, 0, -0.05, pos[0], pos[1], pos[2], 0, 0, 0, 0, 3, 0); + } + else + { + dec = qd*6; + color = particlepalette[67 + (rand()&3)]; + particle(particletype + pt_alphastatic, color, color, tex_particle, 1, qd*255, qd*128, 0, -0.05, pos[0], pos[1], pos[2], 0, 0, 0, 0, 3, 0); + } + } + else + { + dec = qd*16; + if (blood) + particle(particletype + pt_blood, 0xFFFFFF, 0xFFFFFF, tex_bloodparticle[rand()&7], 8, qd * cl_particles_blood_alpha.value * 768.0f, qd * cl_particles_blood_alpha.value * 384.0f, 0, -1, pos[0], pos[1], pos[2], vel[0] * 0.5f, vel[1] * 0.5f, vel[2] * 0.5f, 1, 0, 64); } break; case 3: // green tracer - dec = 6; - if (smoke) + if (cl_particles_quake.integer) { - 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); + dec = qd*6; + color = particlepalette[52 + (rand()&7)]; + particle(particletype + pt_alphastatic, color, color, tex_particle, 1, qd*255, qd*512, 0, 0, pos[0], pos[1], pos[2], 30*vec[1], 30*-vec[0], 0, 0, 0, 0); + particle(particletype + pt_alphastatic, color, color, tex_particle, 1, qd*255, qd*512, 0, 0, pos[0], pos[1], pos[2], 30*-vec[1], 30*vec[0], 0, 0, 0, 0); + } + else + { + dec = qd*16; + if (smoke) + { + if (gamemode == GAME_GOODVSBAD2) + { + dec = qd*6; + particle(particletype + pt_static, 0x00002E, 0x000030, tex_particle, 6, qd*128, qd*384, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0); + } + else + { + dec = qd*3; + color = particlepalette[20 + (rand()&7)]; + particle(particletype + pt_static, color, color, tex_particle, 2, qd*64, qd*192, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0); + } + } } break; case 5: // flame tracer - dec = 6; - if (smoke) + if (cl_particles_quake.integer) + { + dec = qd*6; + color = particlepalette[230 + (rand()&7)]; + particle(particletype + pt_alphastatic, color, color, tex_particle, 1, qd*255, qd*512, 0, 0, pos[0], pos[1], pos[2], 30*vec[1], 30*-vec[0], 0, 0, 0, 0); + particle(particletype + pt_alphastatic, color, color, tex_particle, 1, qd*255, qd*512, 0, 0, pos[0], pos[1], pos[2], 30*-vec[1], 30*vec[0], 0, 0, 0, 0); + } + else { - 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); + dec = qd*3; + if (smoke) + { + color = particlepalette[226 + (rand()&7)]; + particle(particletype + pt_static, color, color, tex_particle, 2, qd*64, qd*192, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0); + } } break; case 6: // voor trail - dec = 6; - if (smoke) + if (cl_particles_quake.integer) + { + dec = qd*3; + color = particlepalette[152 + (rand()&3)]; + particle(particletype + pt_alphastatic, color, color, tex_particle, 1, qd*255, qd*850, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 8, 0); + } + else { - 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); + dec = qd*16; + if (smoke) + { + if (gamemode == GAME_GOODVSBAD2) + { + dec = qd*6; + particle(particletype + pt_alphastatic, particlepalette[0 + (rand()&255)], particlepalette[0 + (rand()&255)], tex_particle, 6, qd*255, qd*384, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0); + } + else if (gamemode == GAME_PRYDON) + { + dec = qd*6; + particle(particletype + pt_static, 0x103040, 0x204050, tex_particle, 6, qd*64, qd*192, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0); + } + else + { + dec = qd*3; + particle(particletype + pt_static, 0x502030, 0x502030, tex_particle, 3, qd*64, qd*192, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0); + } + } } break; - +#ifndef WORKINGLQUAKE case 7: // Nehahra smoke tracer - dec = 7; + dec = qd*7; if (smoke) - { - particle(pt_static, PARTICLE_BILLBOARD, 0x303030, 0x606060, tex_smoke[rand()&7], true, 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(particletype + pt_alphastatic, 0x303030, 0x606060, tex_smoke[rand()&7], 7, qd*64, qd*320, 0, 0, pos[0], pos[1], pos[2], 0, 0, lhrandom(4, 12), 0, 0, 4); break; + case 8: // Nexuiz plasma trail + dec = qd*4; + if (smoke) + particle(particletype + pt_static, 0x283880, 0x283880, tex_particle, 4, qd*255, qd*1024, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 16); + break; + case 9: // glow trail + dec = qd*3; + if (smoke) + particle(particletype + pt_alphastatic, color, color, tex_particle, 5, qd*128, qd*320, 0, 0, pos[0], pos[1], pos[2], 0, 0, 0, 0, 0, 0); + break; +#endif + default: + Sys_Error("CL_RocketTrail: unknown trail type %i", type); } // advance to next time and position @@ -1031,29 +1396,46 @@ void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent) #endif } -void CL_RocketTrail2 (vec3_t start, vec3_t end, int color, entity_t *ent) +void CL_BeamParticle (const vec3_t start, const vec3_t end, vec_t radius, float red, float green, float blue, float alpha, float lifetime) { - vec3_t vec, pos; - int len; + 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(particletype + pt_beam, tempcolor2, tempcolor2, tex_beam, radius, alpha * 255, alpha * 255 / lifetime, 0, 0, start[0], start[1], start[2], end[0], end[1], end[2], 0, 0, 0); +} + +void CL_Tei_Smoke(const vec3_t org, const vec3_t dir, int count) +{ + float f; if (!cl_particles.integer) return; - if (!cl_particles_smoke.integer) return; - VectorCopy(start, pos); - VectorSubtract (end, start, vec); -#ifdef WORKINGLQUAKE - len = (int) (VectorNormalize (vec) * (1.0f / 3.0f)); -#else - len = (int) (VectorNormalizeLength (vec) * (1.0f / 3.0f)); -#endif - VectorScale(vec, 3, vec); - color = particlepalette[color]; - while (len--) - { - particle(pt_static, PARTICLE_BILLBOARD, color, color, tex_particle, false, 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); - } + // smoke puff + if (cl_particles_smoke.integer) + for (f = 0;f < count;f += 4.0f / cl_particles_quality.value) + particle(particletype + pt_smoke, 0x202020, 0x404040, tex_smoke[rand()&7], 5, 255 / cl_particles_quality.value, 512 / cl_particles_quality.value, 0, 0, org[0], org[1], org[2], dir[0], dir[1], dir[2], 0, count * 0.125f, count * 0.5f); } +void CL_Tei_PlasmaHit(const vec3_t org, const vec3_t dir, int count) +{ + float f; + if (!cl_particles.integer) return; + + if (cl_stainmaps.integer) + R_Stain(org, 40, 96, 96, 96, 40, 128, 128, 128, 40); + CL_SpawnDecalParticleForPoint(org, 6, 8, 255, tex_bulletdecal[rand()&7], 0xFFFFFF, 0xFFFFFF); + + // smoke puff + if (cl_particles_smoke.integer) + for (f = 0;f < count;f += 4.0f / cl_particles_quality.value) + particle(particletype + pt_smoke, 0x202020, 0x404040, tex_smoke[rand()&7], 5, 255 / cl_particles_quality.value, 512 / cl_particles_quality.value, 0, 0, org[0], org[1], org[2], dir[0], dir[1], dir[2], 0, count * 0.125f, count); + + // sparks + if (cl_particles_sparks.integer) + for (f = 0;f < count;f += 1.0f / cl_particles_quality.value) + particle(particletype + pt_spark, 0x2030FF, 0x80C0FF, tex_particle, 2.0f, lhrandom(64, 255) / cl_particles_quality.value, 512 / cl_particles_quality.value, 0, 0, org[0], org[1], org[2], dir[0], dir[1], dir[2], 0, 0, count * 3.0f); +} /* =============== @@ -1063,12 +1445,17 @@ CL_MoveParticles 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]; + int i, maxparticle, j, a, content; + float gravity, dvel, bloodwaterfade, frametime, f, dist, org[3], oldorg[3]; + int hitent; + trace_t trace; // LordHavoc: early out condition if (!cl_numparticles) + { + cl_freeparticle = 0; return; + } #ifdef WORKINGLQUAKE frametime = cl.frametime; @@ -1079,161 +1466,233 @@ void CL_MoveParticles (void) dvel = 1+4*frametime; bloodwaterfade = max(cl_particles_blood_alpha.value, 0.01f) * frametime * 128.0f; - activeparticles = 0; maxparticle = -1; j = 0; for (i = 0, p = particles;i < cl_numparticles;i++, p++) { + if (!p->type) + continue; + maxparticle = i; content = 0; - VectorCopy(p->org, p->oldorg); - VectorMA(p->org, frametime, p->vel, p->org); - VectorCopy(p->org, org); -#ifndef WORKINGLQUAKE - if (p->bounce) + + p->alpha -= p->alphafade * frametime; + + if (p->alpha <= 0) { - if (CL_TraceLine(p->oldorg, p->org, v, normal, 0, true, NULL) < 1) + p->type = NULL; + continue; + } + + if (p->type->orientation != PARTICLE_BEAM) + { + VectorCopy(p->org, oldorg); + VectorMA(p->org, frametime, p->vel, p->org); + VectorCopy(p->org, org); + if (p->bounce) { - VectorCopy(v, p->org); - if (p->bounce < 0) + if (p->type == particletype + pt_rain) { - // assume it's blood (lame, but...) - 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; + // raindrop - splash on solid/water/slime/lava + trace = CL_TraceBox(oldorg, vec3_origin, vec3_origin, p->org, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_LIQUIDSMASK, false); + if (trace.fraction < 1) + { + // convert from a raindrop particle to a rainsplash decal + VectorCopy(trace.endpos, p->org); + VectorCopy(trace.plane.normal, p->vel); + VectorAdd(p->org, p->vel, p->org); + p->type = particletype + pt_raindecal; + p->texnum = tex_rainsplash[0]; + p->time2 = cl.time; + p->alphafade = p->alpha / 0.4; + p->bounce = 0; + p->friction = 0; + p->gravity = 0; + p->size = 8.0; + } + } + else if (p->type == particletype + pt_blood) + { + // blood - splash on solid + trace = CL_TraceBox(oldorg, vec3_origin, vec3_origin, p->org, true, &hitent, SUPERCONTENTS_SOLID, false); + if (trace.fraction < 1) + { + // convert from a blood particle to a blood decal + VectorCopy(trace.endpos, p->org); + VectorCopy(trace.plane.normal, p->vel); + VectorAdd(p->org, p->vel, p->org); +#ifndef WORKINGLQUAKE + if (cl_stainmaps.integer) + R_Stain(p->org, 32, 32, 16, 16, p->alpha * p->size * (1.0f / 40.0f), 192, 48, 48, p->alpha * p->size * (1.0f / 40.0f)); +#endif + if (!cl_decals.integer) + { + p->type = NULL; + continue; + } + + p->type = particletype + pt_decal; + p->texnum = tex_blooddecal[rand()&7]; +#ifndef WORKINGLQUAKE + p->owner = hitent; + p->ownermodel = cl_entities[hitent].render.model; + Matrix4x4_Transform(&cl_entities[hitent].render.inversematrix, p->org, p->relativeorigin); + Matrix4x4_Transform3x3(&cl_entities[hitent].render.inversematrix, p->vel, p->relativedirection); +#endif + p->time2 = cl.time; + p->alphafade = 0; + p->bounce = 0; + p->friction = 0; + p->gravity = 0; + p->size *= 2.0f; + } } else { - dist = DotProduct(p->vel, normal) * -p->bounce; - VectorMA(p->vel, dist, normal, p->vel); - if (DotProduct(p->vel, p->vel) < 0.03) - VectorClear(p->vel); + trace = CL_TraceBox(oldorg, vec3_origin, vec3_origin, p->org, true, NULL, SUPERCONTENTS_SOLID, false); + if (trace.fraction < 1) + { + VectorCopy(trace.endpos, p->org); + if (p->bounce < 0) + { + p->type = NULL; + continue; + } + else + { + dist = DotProduct(p->vel, trace.plane.normal) * -p->bounce; + VectorMA(p->vel, dist, trace.plane.normal, p->vel); + if (DotProduct(p->vel, p->vel) < 0.03) + VectorClear(p->vel); + } + } } } - } + p->vel[2] -= p->gravity * gravity; + + if (p->friction) + { + f = p->friction * frametime; +#ifdef WORKINGLQUAKE + if (CL_PointQ1Contents(p->org) != CONTENTS_EMPTY) +#else + if (CL_PointSuperContents(p->org) & SUPERCONTENTS_LIQUIDSMASK) #endif - p->vel[2] -= p->gravity * gravity; - p->alpha -= p->alphafade * frametime; - if (p->friction) - { - f = p->friction * frametime; - if (!content) - content = Mod_PointContents(p->org, cl.worldmodel); - if (content != CONTENTS_EMPTY) - f *= 4; - f = 1.0f - f; - VectorScale(p->vel, f, p->vel); + f *= 4; + f = 1.0f - f; + VectorScale(p->vel, f, p->vel); + } } - if (p->type != pt_static) + if (p->type != particletype + pt_static) { - switch (p->type) + switch (p->type - particletype) { + case pt_entityparticle: + // particle that removes itself after one rendered frame + if (p->time2) + p->type = NULL; + else + p->time2 = 1; + break; case pt_blood: - if (!content) - content = Mod_PointContents(p->org, cl.worldmodel); - a = content; - if (a != CONTENTS_EMPTY) +#ifdef WORKINGLQUAKE + a = CL_PointQ1Contents(p->org); + if (a <= CONTENTS_WATER) +#else + a = CL_PointSuperContents(p->org); + if (a & (SUPERCONTENTS_WATER | SUPERCONTENTS_SLIME)) +#endif { - 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; + p->size += frametime * 8; + //p->alpha -= bloodwaterfade; } else p->vel[2] -= gravity; +#ifdef WORKINGLQUAKE + if (a == CONTENTS_SOLID || a == CONTENTS_LAVA) +#else + if (a & (SUPERCONTENTS_SOLID | SUPERCONTENTS_LAVA | SUPERCONTENTS_NODROP)) +#endif + p->type = NULL; break; case pt_bubble: - if (!content) - content = Mod_PointContents(p->org, cl.worldmodel); - if (content != CONTENTS_WATER && content != CONTENTS_SLIME) +#ifdef WORKINGLQUAKE + a = CL_PointQ1Contents(p->org); + if (a != CONTENTS_WATER && a != CONTENTS_SLIME) +#else + a = CL_PointSuperContents(p->org); + if (!(a & (SUPERCONTENTS_WATER | SUPERCONTENTS_SLIME))) +#endif { - p->die = -1; + p->type = NULL; break; } break; case pt_rain: +#ifdef WORKINGLQUAKE + a = CL_PointQ1Contents(p->org); + if (a != CONTENTS_EMPTY && a != CONTENTS_SKY) +#else + a = CL_PointSuperContents(p->org); + if (a & (SUPERCONTENTS_SOLID | SUPERCONTENTS_LIQUIDSMASK)) +#endif + p->type = NULL; + break; + case pt_snow: 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]; + p->vel[0] = p->relativedirection[0] + lhrandom(-32, 32); + p->vel[1] = p->relativedirection[1] + lhrandom(-32, 32); + //p->vel[2] = p->relativedirection[2] + lhrandom(-32, 32); } - if (!content) - content = Mod_PointContents(p->org, cl.worldmodel); - a = content; +#ifdef WORKINGLQUAKE + a = CL_PointQ1Contents(p->org); if (a != CONTENTS_EMPTY && a != CONTENTS_SKY) - p->die = -1; +#else + a = CL_PointSuperContents(p->org); + if (a & (SUPERCONTENTS_SOLID | SUPERCONTENTS_LIQUIDSMASK)) +#endif + p->type = NULL; break; - default: - printf("unknown particle type %i\n", p->type); - p->die = -1; + case pt_smoke: + //p->size += frametime * 15; break; - } - } - - // remove dead particles - if (p->alpha < 1 || p->die < cl.time) - freeparticles[j++] = p; - else - { - maxparticle = i; - activeparticles++; - if (p->pressure) - pressureused = true; - } - } - // fill in gaps to compact the array - i = 0; - while (maxparticle >= activeparticles) - { - *freeparticles[i++] = particles[maxparticle--]; - while (maxparticle >= activeparticles && particles[maxparticle].die < cl.time) - maxparticle--; - } - cl_numparticles = activeparticles; - - if (pressureused) - { - activeparticles = 0; - for (i = 0, p = particles;i < cl_numparticles;i++, p++) - if (p->pressure) - freeparticles[activeparticles++] = p; - - if (activeparticles) - { - for (i = 0, p = particles;i < cl_numparticles;i++, p++) - { - for (j = 0;j < activeparticles;j++) + case pt_decal: + // FIXME: this has fairly wacky handling of alpha + p->alphafade = cl.time > (p->time2 + cl_decals_time.value) ? (255 / cl_decals_fadetime.value) : 0; +#ifndef WORKINGLQUAKE + if (cl_entities[p->owner].render.model == p->ownermodel) { - if (freeparticles[j] != p) - { - float dist, diff[3]; - VectorSubtract(p->org, freeparticles[j]->org, diff); - dist = DotProduct(diff, diff); - if (dist < 4096 && dist >= 1) - { - dist = freeparticles[j]->scalex * 4.0f * frametime / sqrt(dist); - VectorMA(p->vel, dist, diff, p->vel); - } - } + Matrix4x4_Transform(&cl_entities[p->owner].render.matrix, p->relativeorigin, p->org); + Matrix4x4_Transform3x3(&cl_entities[p->owner].render.matrix, p->relativedirection, p->vel); } + else + p->type = NULL; +#endif + break; + case pt_raindecal: + a = max(0, (cl.time - p->time2) * 40); + if (a < 16) + p->texnum = tex_rainsplash[a]; + else + p->type = NULL; + break; + default: + break; } } } + cl_numparticles = maxparticle + 1; + cl_freeparticle = 0; } #define MAX_PARTICLETEXTURES 64 // particletexture_t is a rectangle in the particlefonttexture -typedef struct +typedef struct particletexture_s { + rtexture_t *texture; float s1, t1, s2, t2; } particletexture_t; @@ -1248,7 +1707,10 @@ static particletexture_t particletexture[MAX_PARTICLETEXTURES]; static cvar_t r_drawparticles = {0, "r_drawparticles", "1"}; -static qbyte shadebubble(float dx, float dy, vec3_t light) +#define PARTICLETEXTURESIZE 64 +#define PARTICLEFONTSIZE (PARTICLETEXTURESIZE*8) + +static unsigned char shadebubble(float dx, float dy, vec3_t light) { float dz, f, dot; vec3_t normal; @@ -1275,135 +1737,290 @@ static qbyte shadebubble(float dx, float dy, vec3_t light) f *= 128; f += 16; // just to give it a haze so you can see the outline f = bound(0, f, 255); - return (qbyte) f; + return (unsigned char) f; } else return 0; } -static void setuptex(int cltexnum, int rtexnum, qbyte *data, qbyte *particletexturedata) +static void setuptex(int texnum, unsigned char *data, unsigned char *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; - for (y = 0;y < 32;y++) - memcpy(particletexturedata + ((basey + y) * 256 + basex) * 4, data + y * 32 * 4, 32 * 4); + basex = ((texnum >> 0) & 7) * PARTICLETEXTURESIZE; + basey = ((texnum >> 3) & 7) * PARTICLETEXTURESIZE; + particletexture[texnum].s1 = (basex + 1) / (float)PARTICLEFONTSIZE; + particletexture[texnum].t1 = (basey + 1) / (float)PARTICLEFONTSIZE; + particletexture[texnum].s2 = (basex + PARTICLETEXTURESIZE - 1) / (float)PARTICLEFONTSIZE; + particletexture[texnum].t2 = (basey + PARTICLETEXTURESIZE - 1) / (float)PARTICLEFONTSIZE; + for (y = 0;y < PARTICLETEXTURESIZE;y++) + memcpy(particletexturedata + ((basey + y) * PARTICLEFONTSIZE + basex) * 4, data + y * PARTICLETEXTURESIZE * 4, PARTICLETEXTURESIZE * 4); +} + +void particletextureblotch(unsigned char *data, float radius, float red, float green, float blue, float alpha) +{ + int x, y; + float cx, cy, dx, dy, f, iradius; + unsigned char *d; + cx = (lhrandom(radius + 1, PARTICLETEXTURESIZE - 2 - radius) + lhrandom(radius + 1, PARTICLETEXTURESIZE - 2 - radius)) * 0.5f; + cy = (lhrandom(radius + 1, PARTICLETEXTURESIZE - 2 - radius) + lhrandom(radius + 1, PARTICLETEXTURESIZE - 2 - radius)) * 0.5f; + iradius = 1.0f / radius; + alpha *= (1.0f / 255.0f); + for (y = 0;y < PARTICLETEXTURESIZE;y++) + { + for (x = 0;x < PARTICLETEXTURESIZE;x++) + { + dx = (x - cx); + dy = (y - cy); + f = (1.0f - sqrt(dx * dx + dy * dy) * iradius) * alpha; + if (f > 0) + { + d = data + (y * PARTICLETEXTURESIZE + x) * 4; + d[0] += f * (red - d[0]); + d[1] += f * (green - d[1]); + d[2] += f * (blue - d[2]); + } + } + } +} + +void particletextureclamp(unsigned char *data, int minr, int ming, int minb, int maxr, int maxg, int maxb) +{ + int i; + for (i = 0;i < PARTICLETEXTURESIZE*PARTICLETEXTURESIZE;i++, data += 4) + { + data[0] = bound(minr, data[0], maxr); + data[1] = bound(ming, data[1], maxg); + data[2] = bound(minb, data[2], maxb); + } +} + +void particletextureinvert(unsigned char *data) +{ + int i; + for (i = 0;i < PARTICLETEXTURESIZE*PARTICLETEXTURESIZE;i++, data += 4) + { + data[0] = 255 - data[0]; + data[1] = 255 - data[1]; + data[2] = 255 - data[2]; + } +} + +// Those loops are in a separate function to work around an optimization bug in Mac OS X's GCC +static void R_InitBloodTextures (unsigned char *particletexturedata) +{ + int i, j, k, m; + unsigned char data[PARTICLETEXTURESIZE][PARTICLETEXTURESIZE][4]; + + // blood particles + for (i = 0;i < 8;i++) + { + memset(&data[0][0][0], 255, sizeof(data)); + for (k = 0;k < 24;k++) + particletextureblotch(&data[0][0][0], PARTICLETEXTURESIZE/16, 96, 0, 0, 160); + //particletextureclamp(&data[0][0][0], 32, 32, 32, 255, 255, 255); + particletextureinvert(&data[0][0][0]); + setuptex(tex_bloodparticle[i], &data[0][0][0], particletexturedata); + } + + // blood decals + for (i = 0;i < 8;i++) + { + memset(&data[0][0][0], 255, sizeof(data)); + m = 8; + for (j = 1;j < 10;j++) + for (k = min(j, m - 1);k < m;k++) + particletextureblotch(&data[0][0][0], (float)j*PARTICLETEXTURESIZE/64.0f, 96, 0, 0, 192 - j * 8); + //particletextureclamp(&data[0][0][0], 32, 32, 32, 255, 255, 255); + particletextureinvert(&data[0][0][0]); + setuptex(tex_blooddecal[i], &data[0][0][0], particletexturedata); + } + } static void R_InitParticleTexture (void) { - int x,y,d,i,m; + int x, y, d, i, k, m; float dx, dy, radius, f, f2; - qbyte data[32][32][4], noise1[64][64], noise2[64][64]; + unsigned char data[PARTICLETEXTURESIZE][PARTICLETEXTURESIZE][4], noise3[64][64], data2[64][16][4]; vec3_t light; - qbyte particletexturedata[256*256*4]; + unsigned char *particletexturedata; - memset(particletexturedata, 255, sizeof(particletexturedata)); + // a note: decals need to modulate (multiply) the background color to + // properly darken it (stain), and they need to be able to alpha fade, + // this is a very difficult challenge because it means fading to white + // (no change to background) rather than black (darkening everything + // behind the whole decal polygon), and to accomplish this the texture is + // inverted (dark red blood on white background becomes brilliant cyan + // and white on black background) so we can alpha fade it to black, then + // we invert it again during the blendfunc to make it work... - // the particletexture[][] array numbers must match the cl_part.c textures - // smoke/blood + particletexturedata = (unsigned char *)Mem_Alloc(tempmempool, PARTICLEFONTSIZE*PARTICLEFONTSIZE*4); + memset(particletexturedata, 255, PARTICLEFONTSIZE*PARTICLEFONTSIZE*4); + + // smoke for (i = 0;i < 8;i++) { + memset(&data[0][0][0], 255, sizeof(data)); do { - fractalnoise(&noise1[0][0], 64, 4); - fractalnoise(&noise2[0][0], 64, 8); + unsigned char noise1[PARTICLETEXTURESIZE*2][PARTICLETEXTURESIZE*2], noise2[PARTICLETEXTURESIZE*2][PARTICLETEXTURESIZE*2]; + + fractalnoise(&noise1[0][0], PARTICLETEXTURESIZE*2, PARTICLETEXTURESIZE/8); + fractalnoise(&noise2[0][0], PARTICLETEXTURESIZE*2, PARTICLETEXTURESIZE/4); m = 0; - for (y = 0;y < 32;y++) + for (y = 0;y < PARTICLETEXTURESIZE;y++) { - dy = y - 16; - for (x = 0;x < 32;x++) + dy = (y - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f-1); + for (x = 0;x < PARTICLETEXTURESIZE;x++) { - data[y][x][0] = data[y][x][1] = data[y][x][2] = 255; - dx = x - 16; + dx = (x - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f-1); d = (noise2[y][x] - 128) * 3 + 192; if (d > 0) - d = (d * (256 - (int) (dx*dx+dy*dy))) >> 8; + d = d * (1-(dx*dx+dy*dy)); d = (d * noise1[y][x]) >> 7; d = bound(0, d, 255); - data[y][x][3] = (qbyte) d; + data[y][x][3] = (unsigned char) d; if (m < d) m = d; } } } while (m < 224); - - setuptex(i + 0, i + 0, &data[0][0][0], particletexturedata); + setuptex(tex_smoke[i], &data[0][0][0], particletexturedata); } // rain splash for (i = 0;i < 16;i++) { - radius = i * 3.0f / 16.0f; + memset(&data[0][0][0], 255, sizeof(data)); + radius = i * 3.0f / 4.0f / 16.0f; f2 = 255.0f * ((15.0f - i) / 15.0f); - for (y = 0;y < 32;y++) + for (y = 0;y < PARTICLETEXTURESIZE;y++) { - dy = (y - 16) * 0.25f; - for (x = 0;x < 32;x++) + dy = (y - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f-1); + for (x = 0;x < PARTICLETEXTURESIZE;x++) { - dx = (x - 16) * 0.25f; - data[y][x][0] = data[y][x][1] = data[y][x][2] = 255; - f = (1.0 - fabs(radius - sqrt(dx*dx+dy*dy))) * f2; - f = bound(0.0f, f, 255.0f); - data[y][x][3] = (int) f; + dx = (x - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f-1); + f = f2 * (1.0 - 4.0f * fabs(radius - sqrt(dx*dx+dy*dy))); + data[y][x][3] = (int) (bound(0.0f, f, 255.0f)); } } - setuptex(i + 8, i + 16, &data[0][0][0], particletexturedata); + setuptex(tex_rainsplash[i], &data[0][0][0], particletexturedata); } // normal particle - for (y = 0;y < 32;y++) + memset(&data[0][0][0], 255, sizeof(data)); + for (y = 0;y < PARTICLETEXTURESIZE;y++) { - dy = y - 16; - for (x = 0;x < 32;x++) + dy = (y - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f-1); + for (x = 0;x < PARTICLETEXTURESIZE;x++) { - data[y][x][0] = data[y][x][1] = data[y][x][2] = 255; - dx = x - 16; - d = (256 - (dx*dx+dy*dy)); + dx = (x - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f-1); + d = 256 * (1 - (dx*dx+dy*dy)); d = bound(0, d, 255); - data[y][x][3] = (qbyte) d; + data[y][x][3] = (unsigned char) d; } } - setuptex(24, 32, &data[0][0][0], particletexturedata); + setuptex(tex_particle, &data[0][0][0], particletexturedata); // rain + memset(&data[0][0][0], 255, sizeof(data)); light[0] = 1;light[1] = 1;light[2] = 1; VectorNormalize(light); - for (y = 0;y < 32;y++) + for (y = 0;y < PARTICLETEXTURESIZE;y++) { - for (x = 0;x < 32;x++) + dy = (y - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f-1); + // stretch upper half of bubble by +50% and shrink lower half by -50% + // (this gives an elongated teardrop shape) + if (dy > 0.5f) + dy = (dy - 0.5f) * 2.0f; + else + dy = (dy - 0.5f) / 1.5f; + for (x = 0;x < PARTICLETEXTURESIZE;x++) { - data[y][x][0] = data[y][x][1] = data[y][x][2] = 255; - data[y][x][3] = shadebubble((x - 16) * (1.0 / 8.0), y < 24 ? (y - 24) * (1.0 / 24.0) : (y - 24) * (1.0 / 8.0), light); + dx = (x - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f-1); + // shrink bubble width to half + dx *= 2.0f; + data[y][x][3] = shadebubble(dx, dy, light); } } - setuptex(25, 33, &data[0][0][0], particletexturedata); + setuptex(tex_raindrop, &data[0][0][0], particletexturedata); // bubble + memset(&data[0][0][0], 255, sizeof(data)); light[0] = 1;light[1] = 1;light[2] = 1; VectorNormalize(light); - for (y = 0;y < 32;y++) + for (y = 0;y < PARTICLETEXTURESIZE;y++) { - for (x = 0;x < 32;x++) + dy = (y - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f-1); + for (x = 0;x < PARTICLETEXTURESIZE;x++) { - data[y][x][0] = data[y][x][1] = data[y][x][2] = 255; - data[y][x][3] = shadebubble((x - 16) * (1.0 / 16.0), (y - 16) * (1.0 / 16.0), light); + dx = (x - 0.5f*PARTICLETEXTURESIZE) / (PARTICLETEXTURESIZE*0.5f-1); + data[y][x][3] = shadebubble(dx, dy, light); } } - setuptex(26, 34, &data[0][0][0], particletexturedata); + setuptex(tex_bubble, &data[0][0][0], particletexturedata); + + // Blood particles and blood decals + R_InitBloodTextures (particletexturedata); + + // bullet decals + for (i = 0;i < 8;i++) + { + memset(&data[0][0][0], 255, sizeof(data)); + for (k = 0;k < 12;k++) + particletextureblotch(&data[0][0][0], PARTICLETEXTURESIZE/16, 0, 0, 0, 128); + for (k = 0;k < 3;k++) + particletextureblotch(&data[0][0][0], PARTICLETEXTURESIZE/2, 0, 0, 0, 160); + //particletextureclamp(&data[0][0][0], 64, 64, 64, 255, 255, 255); + particletextureinvert(&data[0][0][0]); + setuptex(tex_bulletdecal[i], &data[0][0][0], particletexturedata); + } #if WORKINGLQUAKE glBindTexture(GL_TEXTURE_2D, (particlefonttexture = gl_extension_number++)); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); #else - particlefonttexture = R_LoadTexture (particletexturepool, "particlefont", 256, 256, particletexturedata, TEXTYPE_RGBA, TEXF_ALPHA | TEXF_PRECACHE); + +#if 0 + Image_WriteTGARGBA ("particles/particlefont.tga", PARTICLEFONTSIZE, PARTICLEFONTSIZE, particletexturedata); +#endif + + particlefonttexture = loadtextureimage(particletexturepool, "particles/particlefont.tga", 0, 0, false, TEXF_ALPHA | TEXF_PRECACHE); + if (!particlefonttexture) + particlefonttexture = R_LoadTexture2D(particletexturepool, "particlefont", PARTICLEFONTSIZE, PARTICLEFONTSIZE, particletexturedata, TEXTYPE_RGBA, TEXF_ALPHA | TEXF_PRECACHE, NULL); + for (i = 0;i < MAX_PARTICLETEXTURES;i++) + particletexture[i].texture = particlefonttexture; + + // nexbeam + fractalnoise(&noise3[0][0], 64, 4); + m = 0; + for (y = 0;y < 64;y++) + { + dy = (y - 0.5f*64) / (64*0.5f-1); + for (x = 0;x < 16;x++) + { + dx = (x - 0.5f*16) / (16*0.5f-2); + d = (1 - sqrt(fabs(dx))) * noise3[y][x]; + data2[y][x][0] = data2[y][x][1] = data2[y][x][2] = (unsigned char) bound(0, d, 255); + data2[y][x][3] = 255; + } + } + +#if 0 + Image_WriteTGARGBA ("particles/nexbeam.tga", 64, 64, &data2[0][0][0]); #endif + + particletexture[tex_beam].texture = loadtextureimage(particletexturepool, "particles/nexbeam.tga", 0, 0, false, TEXF_ALPHA | TEXF_PRECACHE); + if (!particletexture[tex_beam].texture) + particletexture[tex_beam].texture = R_LoadTexture2D(particletexturepool, "nexbeam", 16, 64, &data2[0][0][0], TEXTYPE_RGBA, TEXF_PRECACHE, NULL); + particletexture[tex_beam].s1 = 0; + particletexture[tex_beam].t1 = 0; + particletexture[tex_beam].s2 = 1; + particletexture[tex_beam].t2 = 1; +#endif + Mem_Free(particletexturedata); } static void r_part_start(void) @@ -1420,6 +2037,7 @@ static void r_part_shutdown(void) static void r_part_newmap(void) { cl_numparticles = 0; + cl_freeparticle = 0; } void R_Particles_Init (void) @@ -1438,135 +2056,166 @@ void R_InitParticles(void) CL_Particles_Init(); R_Particles_Init(); } - -float varray_vertex[16]; #endif -void R_DrawParticleCallback(const void *calldata1, int calldata2) +float particle_vertex3f[12], particle_texcoord2f[8]; + +#ifdef WORKINGLQUAKE +void R_DrawParticle(particle_t *p) { - 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 +#else +void R_DrawParticle_TransparentCallback(const entity_render_t *ent, int surfacenumber, const rtlight_t *rtlight) +{ + const particle_t *p = particles + surfacenumber; rmeshstate_t m; #endif - const particle_t *p = calldata1; + pblend_t blendmode; + float org[3], up2[3], v[3], right[3], up[3], fog, ifog, cr, cg, cb, ca, size; + particletexture_t *tex; VectorCopy(p->org, org); - orientation = (p->flags >> P_ORIENTATION_FIRSTBIT) & ((1 << P_ORIENTATION_BITS) - 1); - texnum = (p->flags >> P_TEXNUM_FIRSTBIT) & ((1 << P_TEXNUM_BITS) - 1); - //dynlight = p->flags & P_DYNLIGHT; - additive = p->flags & P_ADDITIVE; -#ifdef WORKINGLQUAKE - if (additive) - glBlendFunc(GL_SRC_ALPHA, GL_ONE); - else - glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); -#else - memset(&m, 0, sizeof(m)); - m.blendfunc1 = GL_SRC_ALPHA; - if (additive) - m.blendfunc2 = GL_ONE; - else - m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA; - m.tex[0] = R_GetTexture(particlefonttexture); - R_Mesh_Matrix(&r_identitymatrix); - R_Mesh_State(&m); -#endif - - tex = &particletexture[texnum]; + blendmode = p->type->blendmode; + 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 (blendmode == PBLEND_MOD) + { + cr *= ca; + cg *= ca; + cb *= ca; + cr = min(cr, 1); + cg = min(cg, 1); + cb = min(cb, 1); + ca = 1; + } #ifndef WORKINGLQUAKE + if (p->type->lighting) + { + float ambient[3], diffuse[3], diffusenormal[3]; + R_CompleteLightPoint(ambient, diffuse, diffusenormal, org, true); + cr *= (ambient[0] + 0.5 * diffuse[0]); + cg *= (ambient[1] + 0.5 * diffuse[1]); + cb *= (ambient[2] + 0.5 * diffuse[2]); + } if (fogenabled) { - VectorSubtract(org, r_origin, fogvec); - fog = exp(fogdensity/DotProduct(fogvec,fogvec)); + fog = VERTEXFOGTABLE(VectorDistance(org, r_vieworigin)); ifog = 1 - fog; cr = cr * ifog; cg = cg * ifog; cb = cb * ifog; - if (!additive) + if (blendmode == PBLEND_ALPHA) { cr += fogcolor[0] * fog; cg += fogcolor[1] * fog; cb += fogcolor[2] * fog; } } - cr *= r_colorscale; - cg *= r_colorscale; - cb *= r_colorscale; - - varray_texcoord[0][0] = tex->s2;varray_texcoord[0][1] = tex->t1; - varray_texcoord[0][2] = tex->s1;varray_texcoord[0][3] = tex->t1; - varray_texcoord[0][4] = tex->s1;varray_texcoord[0][5] = tex->t2; - varray_texcoord[0][6] = tex->s2;varray_texcoord[0][7] = tex->t2; -#endif - if (orientation == PARTICLE_BEAM) + R_Mesh_Matrix(&r_identitymatrix); + + memset(&m, 0, sizeof(m)); + m.tex[0] = R_GetTexture(tex->texture); + m.pointer_texcoord[0] = particle_texcoord2f; + m.pointer_vertex = particle_vertex3f; + R_Mesh_State(&m); + + GL_Color(cr, cg, cb, ca); + + if (blendmode == PBLEND_ALPHA) + GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + else if (blendmode == PBLEND_ADD) + GL_BlendFunc(GL_SRC_ALPHA, GL_ONE); + else //if (blendmode == PBLEND_MOD) + GL_BlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR); + GL_DepthMask(false); + GL_DepthTest(true); +#endif + size = p->size * cl_particles_size.value; + if (p->type->orientation == PARTICLE_BILLBOARD || p->type->orientation == PARTICLE_ORIENTED_DOUBLESIDED) { - VectorMA(p->org, -p->scaley, p->vel, v); - VectorMA(p->org, p->scaley, p->vel, up2); - R_CalcBeamVerts(varray_vertex, v, up2, p->scalex); + if (p->type->orientation == PARTICLE_ORIENTED_DOUBLESIDED) + { + // double-sided + if (DotProduct(p->vel, r_vieworigin) > DotProduct(p->vel, org)) + { + VectorNegate(p->vel, v); + VectorVectors(v, right, up); + } + else + VectorVectors(p->vel, right, up); + VectorScale(right, size, right); + VectorScale(up, size, up); + } + else + { + VectorScale(r_viewleft, -size, right); + VectorScale(r_viewup, size, 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 (orientation == PARTICLE_BILLBOARD) + else if (p->type->orientation == PARTICLE_SPARK) { - 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]; + VectorMA(p->org, -0.02, p->vel, v); + VectorMA(p->org, 0.02, p->vel, up2); + R_CalcBeam_Vertex3f(particle_vertex3f, v, up2, size); + 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 (orientation == PARTICLE_ORIENTED_DOUBLESIDED) + else if (p->type->orientation == PARTICLE_BEAM) { - // 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); - 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]; + R_CalcBeam_Vertex3f(particle_vertex3f, p->org, p->vel, size); + VectorSubtract(p->vel, p->org, up); + VectorNormalize(up); + v[0] = DotProduct(p->org, up) * (1.0f / 64.0f); + v[1] = DotProduct(p->vel, up) * (1.0f / 64.0f); + 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", orientation); + { + Con_Printf("R_DrawParticles: unknown particle orientation %i\n", p->type->orientation); + return; + } + #if WORKINGLQUAKE - glBegin(GL_QUADS); + if (blendmode == PBLEND_ALPHA) + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + else if (blendmode == PBLEND_ADD) + glBlendFunc(GL_SRC_ALPHA, GL_ONE); + else //if (blendmode == PBLEND_MOD) + glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR); 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]); + 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 - GL_Color(cr, cg, cb, ca); - R_Mesh_Draw(4, 2, polygonelements); + R_Mesh_Draw(0, 4, 2, polygonelements); #endif } @@ -1584,7 +2233,7 @@ void R_DrawParticles (void) if ((!cl_numparticles) || (!r_drawparticles.integer)) return; - minparticledist = DotProduct(r_origin, vpn) + 16.0f; + minparticledist = DotProduct(r_vieworigin, r_viewforward) + 4.0f; #ifdef WORKINGLQUAKE glBindTexture(GL_TEXTURE_2D, particlefonttexture); @@ -1593,17 +2242,27 @@ void R_DrawParticles (void) 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); + if (p->type && DotProduct(p->org, r_viewforward) >= minparticledist) + R_DrawParticle(p); glDepthMask(1); glDisable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); #else // LordHavoc: only render if not too close - c_particles += cl_numparticles; for (i = 0, p = particles;i < cl_numparticles;i++, p++) - if (DotProduct(p->org, vpn) >= minparticledist) - R_MeshQueue_AddTransparent(p->org, R_DrawParticleCallback, p, 0); + { + if (p->type) + { + renderstats.particles++; + if (DotProduct(p->org, r_viewforward) >= minparticledist || p->type->orientation == PARTICLE_BEAM) + { + if (p->type == particletype + pt_decal) + R_DrawParticle_TransparentCallback(0, i, 0); + else + R_MeshQueue_AddTransparent(p->org, R_DrawParticle_TransparentCallback, NULL, i, NULL); + } + } + } #endif }