X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=cl_particles.c;h=30a799c0dd53802a9e24b0d0588a9008b01f542e;hp=2c9f2147ae54b0938dba14d9cb9d8cb67fcabddb;hb=6fe636cfb9d5ee6320f4cd6db33c0a6f38d1ee2c;hpb=cf93d91077855abf71419763e56bc774bc3b244f diff --git a/cl_particles.c b/cl_particles.c index 2c9f2147..30a799c0 100644 --- a/cl_particles.c +++ b/cl_particles.c @@ -19,9 +19,140 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "quakedef.h" + +#ifdef WORKINGLQUAKE +#define lhrandom(MIN,MAX) ((rand() & 32767) * (((MAX)-(MIN)) * (1.0f / 32767.0f)) + (MIN)) +#define NUMVERTEXNORMALS 162 +siextern float r_avertexnormals[NUMVERTEXNORMALS][3]; +#define m_bytenormals r_avertexnormals +#define VectorNormalizeFast VectorNormalize +#define Mod_PointContents(v,m) (Mod_PointInLeaf(v,m)->contents) +typedef unsigned char qbyte; +#define cl_stainmaps.integer 0 +void R_Stain (vec3_t origin, float radius, int cr1, int cg1, int cb1, int ca1, int cr2, int cg2, int cb2, int ca2) +{ +} +#define CL_EntityParticles R_EntityParticles +#define CL_ReadPointFile_f R_ReadPointFile_f +#define CL_ParseParticleEffect R_ParseParticleEffect +#define CL_ParticleExplosion R_ParticleExplosion +#define CL_ParticleExplosion2 R_ParticleExplosion2 +#define CL_BlobExplosion R_BlobExplosion +#define CL_RunParticleEffect R_RunParticleEffect +#define CL_LavaSplash R_LavaSplash +#define CL_RocketTrail2 R_RocketTrail2 +void R_CalcBeamVerts (float *vert, vec3_t org1, vec3_t org2, float width) +{ + vec3_t right1, right2, diff, normal; + + VectorSubtract (org2, org1, normal); + VectorNormalizeFast (normal); + + // calculate 'right' vector for start + VectorSubtract (r_origin, org1, diff); + VectorNormalizeFast (diff); + CrossProduct (normal, diff, right1); + + // calculate 'right' vector for end + VectorSubtract (r_origin, org2, diff); + VectorNormalizeFast (diff); + CrossProduct (normal, diff, right2); + + vert[ 0] = org1[0] + width * right1[0]; + vert[ 1] = org1[1] + width * right1[1]; + vert[ 2] = org1[2] + width * right1[2]; + vert[ 4] = org1[0] - width * right1[0]; + vert[ 5] = org1[1] - width * right1[1]; + vert[ 6] = org1[2] - width * right1[2]; + vert[ 8] = org2[0] - width * right2[0]; + vert[ 9] = org2[1] - width * right2[1]; + vert[10] = org2[2] - width * right2[2]; + vert[12] = org2[0] + width * right2[0]; + vert[13] = org2[1] + width * right2[1]; + vert[14] = org2[2] + width * right2[2]; +} +void fractalnoise(qbyte *noise, int size, int startgrid) +{ + int x, y, g, g2, amplitude, min, max, size1 = size - 1, sizepower, gridpower; + int *noisebuf; +#define n(x,y) noisebuf[((y)&size1)*size+((x)&size1)] + + for (sizepower = 0;(1 << sizepower) < size;sizepower++); + if (size != (1 << sizepower)) + Sys_Error("fractalnoise: size must be power of 2\n"); + + for (gridpower = 0;(1 << gridpower) < startgrid;gridpower++); + if (startgrid != (1 << gridpower)) + Sys_Error("fractalnoise: grid must be power of 2\n"); + + startgrid = bound(0, startgrid, size); + + amplitude = 0xFFFF; // this gets halved before use + noisebuf = malloc(size*size*sizeof(int)); + memset(noisebuf, 0, size*size*sizeof(int)); + + for (g2 = startgrid;g2;g2 >>= 1) + { + // brownian motion (at every smaller level there is random behavior) + amplitude >>= 1; + for (y = 0;y < size;y += g2) + for (x = 0;x < size;x += g2) + n(x,y) += (rand()&litude); + + g = g2 >> 1; + if (g) + { + // subdivide, diamond-square algorithm (really this has little to do with squares) + // diamond + for (y = 0;y < size;y += g2) + for (x = 0;x < size;x += g2) + n(x+g,y+g) = (n(x,y) + n(x+g2,y) + n(x,y+g2) + n(x+g2,y+g2)) >> 2; + // square + for (y = 0;y < size;y += g2) + for (x = 0;x < size;x += g2) + { + n(x+g,y) = (n(x,y) + n(x+g2,y) + n(x+g,y-g) + n(x+g,y+g)) >> 2; + n(x,y+g) = (n(x,y) + n(x,y+g2) + n(x-g,y+g) + n(x+g,y+g)) >> 2; + } + } + } + // find range of noise values + min = max = 0; + for (y = 0;y < size;y++) + for (x = 0;x < size;x++) + { + if (n(x,y) < min) min = n(x,y); + if (n(x,y) > max) max = n(x,y); + } + max -= min; + max++; + // normalize noise and copy to output + for (y = 0;y < size;y++) + for (x = 0;x < size;x++) + *noise++ = (qbyte) (((n(x,y) - min) * 256) / max); + free(noisebuf); +#undef n +} +void VectorVectors(const vec3_t forward, vec3_t right, vec3_t up) +{ + float d; + + right[0] = forward[2]; + right[1] = -forward[0]; + right[2] = forward[1]; + + d = DotProduct(forward, right); + right[0] -= d * forward[0]; + right[1] -= d * forward[1]; + right[2] -= d * forward[2]; + VectorNormalizeFast(right); + CrossProduct(right, forward, up); +} +#else #include "cl_collision.h" +#endif -#define MAX_PARTICLES 16384 // default max # of particles at one time +#define MAX_PARTICLES 8192 // default max # of particles at one time #define ABSOLUTE_MIN_PARTICLES 512 // no fewer than this no matter what's on the command line typedef enum @@ -30,12 +161,17 @@ typedef enum } ptype_t; +#define PARTICLE_INVALID 0 +#define PARTICLE_BILLBOARD 1 +#define PARTICLE_BEAM 2 +#define PARTICLE_ORIENTED_DOUBLESIDED 3 + #define P_TEXNUM_FIRSTBIT 0 #define P_TEXNUM_BITS 6 #define P_ORIENTATION_FIRSTBIT (P_TEXNUM_FIRSTBIT + P_TEXNUM_BITS) #define P_ORIENTATION_BITS 2 #define P_FLAGS_FIRSTBIT (P_ORIENTATION_FIRSTBIT + P_ORIENTATION_BITS) -#define P_DYNLIGHT (1 << (P_FLAGS_FIRSTBIT + 0)) +//#define P_DYNLIGHT (1 << (P_FLAGS_FIRSTBIT + 0)) #define P_ADDITIVE (1 << (P_FLAGS_FIRSTBIT + 1)) typedef struct particle_s @@ -121,7 +257,9 @@ cvar_t cl_particles_smoke = {CVAR_SAVE, "cl_particles_smoke", "1"}; cvar_t cl_particles_sparks = {CVAR_SAVE, "cl_particles_sparks", "1"}; cvar_t cl_particles_bubbles = {CVAR_SAVE, "cl_particles_bubbles", "1"}; +#ifndef WORKINGLQUAKE static mempool_t *cl_part_mempool; +#endif void CL_Particles_Clear(void) { @@ -162,9 +300,14 @@ void CL_Particles_Init (void) Cvar_RegisterVariable (&cl_particles_sparks); Cvar_RegisterVariable (&cl_particles_bubbles); +#ifdef WORKINGLQUAKE + particles = (particle_t *) Hunk_AllocName(cl_maxparticles * sizeof(particle_t), "particles"); + freeparticles = (void *) Hunk_AllocName(cl_maxparticles * sizeof(particle_t *), "particles"); +#else cl_part_mempool = Mem_AllocPool("CL_Part"); particles = (particle_t *) Mem_Alloc(cl_part_mempool, cl_maxparticles * sizeof(particle_t)); freeparticles = (void *) Mem_Alloc(cl_part_mempool, cl_maxparticles * sizeof(particle_t *)); +#endif cl_numparticles = 0; } @@ -179,8 +322,8 @@ void CL_Particles_Init (void) partflags = ((porientation) << P_ORIENTATION_FIRSTBIT) | ((ptex) << P_TEXNUM_FIRSTBIT);\ if (padditive)\ partflags |= P_ADDITIVE;\ - if (plight)\ - partflags |= P_DYNLIGHT;\ + /*if (plight)*/\ + /* partflags |= P_DYNLIGHT;*/\ tempcolor = (pcolor1);\ tempcolor2 = (pcolor2);\ cr2 = ((tempcolor2) >> 16) & 0xFF;\ @@ -261,7 +404,11 @@ void CL_EntityParticles (entity_t *ent) forward[1] = cp*sy; forward[2] = -sp; +#ifdef WORKINGLQUAKE + particle(pt_static, PARTICLE_BILLBOARD, particlepalette[0x6f], particlepalette[0x6f], tex_particle, false, false, 2, 2, 255, 0, 0, 0, 0, ent->origin[0] + m_bytenormals[i][0]*dist + forward[0]*beamlength, ent->origin[1] + m_bytenormals[i][1]*dist + forward[1]*beamlength, ent->origin[2] + m_bytenormals[i][2]*dist + forward[2]*beamlength, 0, 0, 0, 0, 0, 0, 0, 0, 0); +#else particle(pt_static, PARTICLE_BILLBOARD, particlepalette[0x6f], particlepalette[0x6f], tex_particle, false, false, 2, 2, 255, 0, 0, 0, 0, ent->render.origin[0] + m_bytenormals[i][0]*dist + forward[0]*beamlength, ent->render.origin[1] + m_bytenormals[i][1]*dist + forward[1]*beamlength, ent->render.origin[2] + m_bytenormals[i][2]*dist + forward[2]*beamlength, 0, 0, 0, 0, 0, 0, 0, 0, 0); +#endif } } @@ -270,16 +417,33 @@ void CL_ReadPointFile_f (void) { vec3_t org; int r, c; - char *pointfile, *pointfilepos, *t, tchar; - - pointfile = COM_LoadFile(va("maps/%s.pts", sv.name), true); + char *pointfile = NULL, *pointfilepos, *t, tchar; +#if WORKINGLQUAKE + char name[MAX_OSPATH]; + + sprintf (name,"maps/%s.pts", cl.worldmodel->name); + COM_FOpenFile (name, &f); + if (f) + { + int pointfilelength; + fseek(f, 0, SEEK_END); + pointfilelength = ftell(f); + fseek(f, 0, SEEK_SET); + pointfile = malloc(pointfilelength + 1); + fread(pointfile, 1, pointfilelength, f); + pointfile[pointfilelength] = 0; + fclose(f); + } +#else + pointfile = COM_LoadFile(va("maps/%s.pts", cl.worldmodel->name), true); +#endif if (!pointfile) { - Con_Printf ("couldn't open %s.pts\n", sv.name); + Con_Printf ("couldn't open %s.pts\n", cl.worldmodel->name); return; } - Con_Printf ("Reading %s.pts...\n", sv.name); + Con_Printf ("Reading %s.pts...\n", cl.worldmodel->name); c = 0; pointfilepos = pointfile; while (*pointfilepos) @@ -308,7 +472,11 @@ void CL_ReadPointFile_f (void) particle(pt_static, PARTICLE_BILLBOARD, particlepalette[(-c)&15], particlepalette[(-c)&15], tex_particle, false, false, 2, 2, 255, 0, 99999, 0, 0, org[0], org[1], org[2], 0, 0, 0, 0, 0, 0, 0, 0, 0); } +#ifdef WORKINGLQUAKE + free(pointfile); +#else Mem_Free(pointfile); +#endif Con_Printf ("%i points read\n", c); } @@ -321,8 +489,8 @@ Parse an effect out of the server message */ void CL_ParseParticleEffect (void) { - vec3_t org, dir; - int i, count, msgcount, color; + vec3_t org, dir; + int i, count, msgcount, color; for (i=0 ; i<3 ; i++) org[i] = MSG_ReadCoord (); @@ -345,13 +513,15 @@ CL_ParticleExplosion =============== */ -void CL_ParticleExplosion (vec3_t org, int smoke) +void CL_ParticleExplosion (vec3_t org) { - int i; + int i, k; + //vec3_t v; + //vec3_t v2; if (cl_stainmaps.integer) R_Stain(org, 96, 80, 80, 80, 64, 176, 176, 176, 64); - i = Mod_PointInLeaf(org, cl.worldmodel)->contents; + i = Mod_PointContents(org, cl.worldmodel); if ((i == CONTENTS_SLIME || i == CONTENTS_WATER) && cl_particles.integer && cl_particles_bubbles.integer) { for (i = 0;i < 128;i++) @@ -359,6 +529,46 @@ void CL_ParticleExplosion (vec3_t org, int smoke) particle(pt_bubble, PARTICLE_BILLBOARD, 0x404040, 0x808080, tex_bubble, false, true, 2, 2, lhrandom(128, 255), 256, 9999, -0.25, 1.5, org[0] + lhrandom(-16, 16), org[1] + lhrandom(-16, 16), org[2] + lhrandom(-16, 16), lhrandom(-96, 96), lhrandom(-96, 96), lhrandom(-96, 96), 0, 0, 0, 0, (1.0 / 16.0), 0); } } + else + { + /* + // LordHavoc: smoke effect similar to UT2003, chews fillrate too badly up close + // smoke puff + if (cl_particles_smoke.integer) + { + for (i = 0;i < 64;i++) + { +#ifdef WORKINGLQUAKE + v2[0] = lhrandom(-64, 64); + v2[1] = lhrandom(-64, 64); + v2[2] = lhrandom(-8, 24); +#else + for (k = 0;k < 16;k++) + { + v[0] = org[0] + lhrandom(-64, 64); + v[1] = org[1] + lhrandom(-64, 64); + v[2] = org[2] + lhrandom(-8, 24); + if (CL_TraceLine(org, v, v2, NULL, 0, true, NULL) >= 0.1) + break; + } + VectorSubtract(v2, org, v2); +#endif + VectorScale(v2, 2.0f, v2); + particle(pt_static, PARTICLE_BILLBOARD, 0x101010, 0x202020, tex_smoke[rand()&7], true, 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); + } + } + */ + + 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_explosions.integer) R_NewExplosion(org); @@ -409,7 +619,7 @@ void CL_RunParticleEffect (vec3_t org, vec3_t dir, int color, int count) if (count == 1024) { - CL_ParticleExplosion(org, false); + CL_ParticleExplosion(org); return; } if (!cl_particles.integer) return; @@ -432,13 +642,19 @@ void CL_SparkShower (vec3_t org, vec3_t dir, int count) if (!cl_particles.integer) return; if (cl_stainmaps.integer) - R_Stain(org, 32, 96, 96, 96, 2, 128, 128, 128, 2); + R_Stain(org, 32, 96, 96, 96, 24, 128, 128, 128, 24); if (cl_particles_bulletimpacts.integer) { // smoke puff if (cl_particles_smoke.integer) - particle(pt_static, PARTICLE_BILLBOARD, 0x606060, 0xA0A0A0, tex_smoke[rand()&7], true, true, 4, 4, 255, 1024, 9999, -0.2, 0, org[0], org[1], org[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(0, 16), 0, 0, 0, 0, 0, 0); + { + k = count / 4; + while(k--) + { + 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); + } + } if (cl_particles_sparks.integer) { @@ -446,7 +662,7 @@ void CL_SparkShower (vec3_t org, vec3_t dir, int count) while(count--) { k = particlepalette[0x68 + (rand() & 7)]; - particle(pt_static, PARTICLE_BILLBOARD, k, k, tex_particle, false, true, 1, 1, lhrandom(64, 255), 512, 9999, 1, 0, org[0], org[1], org[2], lhrandom(-64, 64) + dir[0], lhrandom(-64, 64) + dir[1], lhrandom(0, 128) + dir[2], 0, 0, 0, 0, 0, 0); + particle(pt_static, PARTICLE_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); } } } @@ -455,7 +671,7 @@ void CL_SparkShower (vec3_t org, vec3_t dir, int count) void CL_PlasmaBurn (vec3_t org) { if (cl_stainmaps.integer) - R_Stain(org, 48, 96, 96, 96, 3, 128, 128, 128, 3); + R_Stain(org, 48, 96, 96, 96, 32, 128, 128, 128, 32); } static float bloodcount = 0; @@ -565,7 +781,7 @@ void CL_ParticleRain (vec3_t mins, vec3_t maxs, vec3_t dir, int count, int color while(count--) { k = particlepalette[colorbase + (rand()&3)]; - particle(pt_rain, PARTICLE_UPRIGHT_FACING, k, k, tex_particle, true, true, 0.5, 8, lhrandom(8, 16), 0, t, 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz), dir[0], dir[1], dir[2], cl.time + 9999, dir[0], dir[1], dir[2], 0, 0); + particle(pt_rain, PARTICLE_BEAM, k, k, tex_particle, true, true, 0.5, 0.02, lhrandom(8, 16), 0, t, 0, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz), dir[0], dir[1], dir[2], cl.time + 9999, dir[0], dir[1], dir[2], 0, 0); } break; case 1: @@ -677,8 +893,8 @@ CL_TeleportSplash =============== */ -/* -void CL_TeleportSplash (vec3_t org) +#if WORKINGLQUAKE +void R_TeleportSplash (vec3_t org) { int i, j, k; if (!cl_particles.integer) return; @@ -688,9 +904,13 @@ void CL_TeleportSplash (vec3_t org) 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); } -*/ +#endif +#ifdef WORKINGLQUAKE +void R_RocketTrail (vec3_t start, vec3_t end, int type) +#else void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent) +#endif { vec3_t vec, dir, vel, pos; float len, dec, speed, r; @@ -700,24 +920,31 @@ void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent) VectorNormalize(dir); VectorSubtract (end, start, vec); +#ifdef WORKINGLQUAKE + len = VectorNormalize (vec); + dec = 0; + speed = 1.0f / cl.frametime; + VectorSubtract(end, start, vel); +#else len = VectorNormalizeLength (vec); dec = -ent->persistent.trail_time; ent->persistent.trail_time += len; if (ent->persistent.trail_time < 0.01f) return; + // if we skip out, leave it reset + ent->persistent.trail_time = 0.0f; + speed = 1.0f / (ent->state_current.time - ent->state_previous.time); VectorSubtract(ent->state_current.origin, ent->state_previous.origin, vel); +#endif VectorScale(vel, speed, vel); // advance into this frame to reach the first puff location VectorMA(start, dec, vec, pos); len -= dec; - // if we skip out, leave it reset - ent->persistent.trail_time = 0.0f; - - contents = Mod_PointInLeaf(pos, cl.worldmodel)->contents; + contents = Mod_PointContents(pos, cl.worldmodel); if (contents == CONTENTS_SKY || contents == CONTENTS_LAVA) return; @@ -799,7 +1026,9 @@ void CL_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent) len -= dec; VectorMA (pos, dec, vec, pos); } +#ifndef WORKINGLQUAKE ent->persistent.trail_time = len; +#endif } void CL_RocketTrail2 (vec3_t start, vec3_t end, int color, entity_t *ent) @@ -811,7 +1040,11 @@ void CL_RocketTrail2 (vec3_t start, vec3_t end, int color, entity_t *ent) VectorCopy(start, pos); VectorSubtract (end, start, vec); +#ifdef WORKINGLQUAKE + len = (int) (VectorNormalize (vec) * (1.0f / 3.0f)); +#else len = (int) (VectorNormalizeLength (vec) * (1.0f / 3.0f)); +#endif VectorScale(vec, 3, vec); color = particlepalette[color]; while (len--) @@ -837,7 +1070,11 @@ void CL_MoveParticles (void) if (!cl_numparticles) return; +#ifdef WORKINGLQUAKE + frametime = cl.frametime; +#else frametime = cl.time - cl.oldtime; +#endif gravity = frametime * sv_gravity.value; dvel = 1+4*frametime; bloodwaterfade = max(cl_particles_blood_alpha.value, 0.01f) * frametime * 128.0f; @@ -851,16 +1088,17 @@ void CL_MoveParticles (void) VectorCopy(p->org, p->oldorg); VectorMA(p->org, frametime, p->vel, p->org); VectorCopy(p->org, org); +#ifndef WORKINGLQUAKE if (p->bounce) { - if (CL_TraceLine(p->oldorg, p->org, v, normal, 0, true) < 1) + if (CL_TraceLine(p->oldorg, p->org, v, normal, 0, true, NULL) < 1) { VectorCopy(v, p->org); if (p->bounce < 0) { // assume it's blood (lame, but...) if (cl_stainmaps.integer) - R_Stain(v, 32, 32, 16, 16, p->alpha * p->scalex * (1.0f / 400.0f), 192, 48, 48, p->alpha * p->scalex * (1.0f / 400.0f)); + 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; @@ -874,13 +1112,14 @@ void CL_MoveParticles (void) } } } +#endif p->vel[2] -= p->gravity * gravity; p->alpha -= p->alphafade * frametime; if (p->friction) { f = p->friction * frametime; if (!content) - content = Mod_PointInLeaf(p->org, cl.worldmodel)->contents; + content = Mod_PointContents(p->org, cl.worldmodel); if (content != CONTENTS_EMPTY) f *= 4; f = 1.0f - f; @@ -893,7 +1132,7 @@ void CL_MoveParticles (void) { case pt_blood: if (!content) - content = Mod_PointInLeaf(p->org, cl.worldmodel)->contents; + content = Mod_PointContents(p->org, cl.worldmodel); a = content; if (a != CONTENTS_EMPTY) { @@ -911,7 +1150,7 @@ void CL_MoveParticles (void) break; case pt_bubble: if (!content) - content = Mod_PointInLeaf(p->org, cl.worldmodel)->contents; + content = Mod_PointContents(p->org, cl.worldmodel); if (content != CONTENTS_WATER && content != CONTENTS_SLIME) { p->die = -1; @@ -928,7 +1167,7 @@ void CL_MoveParticles (void) p->vel[2] = /*lhrandom(-32, 32) +*/ p->vel2[2]; } if (!content) - content = Mod_PointInLeaf(p->org, cl.worldmodel)->contents; + content = Mod_PointContents(p->org, cl.worldmodel); a = content; if (a != CONTENTS_EMPTY && a != CONTENTS_SKY) p->die = -1; @@ -999,18 +1238,20 @@ typedef struct } particletexture_t; +#if WORKINGLQUAKE +static int particlefonttexture; +#else static rtexturepool_t *particletexturepool; - static rtexture_t *particlefonttexture; +#endif static particletexture_t particletexture[MAX_PARTICLETEXTURES]; static cvar_t r_drawparticles = {0, "r_drawparticles", "1"}; -static cvar_t r_particles_lighting = {0, "r_particles_lighting", "0"}; static qbyte shadebubble(float dx, float dy, vec3_t light) { - float dz, f, dot; - vec3_t normal; + float dz, f, dot; + vec3_t normal; dz = 1 - (dx*dx+dy*dy); if (dz > 0) // it does hit the sphere { @@ -1055,11 +1296,11 @@ static void setuptex(int cltexnum, int rtexnum, qbyte *data, qbyte *particletext static void R_InitParticleTexture (void) { - int x,y,d,i,m; - float dx, dy, radius, f, f2; - qbyte data[32][32][4], noise1[64][64], noise2[64][64]; - vec3_t light; - qbyte particletexturedata[256*256*4]; + int x,y,d,i,m; + float dx, dy, radius, f, f2; + qbyte data[32][32][4], noise1[64][64], noise2[64][64]; + vec3_t light; + qbyte particletexturedata[256*256*4]; memset(particletexturedata, 255, sizeof(particletexturedata)); @@ -1156,7 +1397,13 @@ static void R_InitParticleTexture (void) } setuptex(26, 34, &data[0][0][0], particletexturedata); +#if WORKINGLQUAKE + glBindTexture(GL_TEXTURE_2D, (particlefonttexture = gl_extension_number++)); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); +#else particlefonttexture = R_LoadTexture (particletexturepool, "particlefont", 256, 256, particletexturedata, TEXTYPE_RGBA, TEXF_ALPHA | TEXF_PRECACHE); +#endif } static void r_part_start(void) @@ -1172,83 +1419,68 @@ static void r_part_shutdown(void) static void r_part_newmap(void) { + cl_numparticles = 0; } void R_Particles_Init (void) { Cvar_RegisterVariable(&r_drawparticles); - Cvar_RegisterVariable(&r_particles_lighting); +#ifdef WORKINGLQUAKE + r_part_start(); +#else R_RegisterModule("R_Particles", r_part_start, r_part_shutdown, r_part_newmap); +#endif } -int partindexarray[6] = {0, 1, 2, 0, 2, 3}; - -void R_DrawParticleCallback(void *calldata1, int calldata2) +#ifdef WORKINGLQUAKE +void R_InitParticles(void) { - int lighting, dynlight, additive, texnum, orientation; - float org[3], up2[3], right2[3], v[3], right[3], up[3], fog, ifog, fogvec[3], cr, cg, cb, ca; - particletexture_t *tex; - mleaf_t *leaf; - rmeshbufferinfo_t m; - particle_t *p; - - p = calldata1; + CL_Particles_Init(); + R_Particles_Init(); +} - // LordHavoc: check if it's in a visible leaf - leaf = Mod_PointInLeaf(p->org, cl.worldmodel); - if (leaf->visframe != r_framecount) - return; +float varray_vertex[16]; +#endif - lighting = r_dynamic.integer ? r_particles_lighting.integer : 0; +void R_DrawParticleCallback(const void *calldata1, int calldata2) +{ + int additive, texnum, orientation; + float org[3], up2[3], v[3], right[3], up[3], fog, ifog, fogvec[3], cr, cg, cb, ca; + particletexture_t *tex; +#ifndef WORKINGLQUAKE + rmeshstate_t m; +#endif + const particle_t *p = calldata1; VectorCopy(p->org, org); orientation = (p->flags >> P_ORIENTATION_FIRSTBIT) & ((1 << P_ORIENTATION_BITS) - 1); texnum = (p->flags >> P_TEXNUM_FIRSTBIT) & ((1 << P_TEXNUM_BITS) - 1); - dynlight = p->flags & P_DYNLIGHT; + //dynlight = p->flags & P_DYNLIGHT; additive = p->flags & P_ADDITIVE; - if (orientation == PARTICLE_BILLBOARD) - { - VectorScale(vright, p->scalex, right); - VectorScale(vup, p->scaley, up); - } - else if (orientation == PARTICLE_UPRIGHT_FACING) - { - v[0] = r_origin[0] - org[0]; - v[1] = r_origin[1] - org[1]; - v[2] = 0; - VectorNormalizeFast(v); - VectorVectors(v, right2, up2); - VectorScale(right2, p->scalex, right); - VectorScale(up2, p->scaley, up); - } - else if (orientation == PARTICLE_ORIENTED_DOUBLESIDED) - { - // double-sided - if (DotProduct(p->vel2, r_origin) > DotProduct(p->vel2, org)) - { - VectorNegate(p->vel2, v); - VectorVectors(v, right, up); - } - else - VectorVectors(p->vel2, right, up); - VectorScale(right, p->scalex, right); - VectorScale(up, p->scaley, up); - } + +#ifdef WORKINGLQUAKE + if (additive) + glBlendFunc(GL_SRC_ALPHA, GL_ONE); else - Host_Error("R_DrawParticles: unknown particle orientation %i\n", orientation); + 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]; cr = p->color[0] * (1.0f / 255.0f); cg = p->color[1] * (1.0f / 255.0f); cb = p->color[2] * (1.0f / 255.0f); ca = p->alpha * (1.0f / 255.0f); - if (lighting >= 1 && (dynlight || lighting >= 2)) - { - R_CompleteLightPoint(v, org, true, leaf); - cr *= v[0]; - cg *= v[1]; - cb *= v[2]; - } - +#ifndef WORKINGLQUAKE if (fogenabled) { VectorSubtract(org, r_origin, fogvec); @@ -1264,52 +1496,81 @@ void R_DrawParticleCallback(void *calldata1, int calldata2) cb += fogcolor[2] * fog; } } - - memset(&m, 0, sizeof(m)); - m.transparent = false; - m.blendfunc1 = GL_SRC_ALPHA; - if (additive) - m.blendfunc2 = GL_ONE; - else - m.blendfunc2 = GL_ONE_MINUS_SRC_ALPHA; - m.numtriangles = 2; - m.numverts = 4; - m.tex[0] = R_GetTexture(particlefonttexture); - if (R_Mesh_Draw_GetBuffer(&m, false)) + cr *= r_colorscale; + cg *= r_colorscale; + cb *= r_colorscale; + + varray_color[ 0] = varray_color[ 4] = varray_color[ 8] = varray_color[12] = cr; + varray_color[ 1] = varray_color[ 5] = varray_color[ 9] = varray_color[13] = cg; + varray_color[ 2] = varray_color[ 6] = varray_color[10] = varray_color[14] = cb; + varray_color[ 3] = varray_color[ 7] = varray_color[11] = varray_color[15] = ca; + 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) + { + VectorMA(p->org, -p->scaley, p->vel, v); + VectorMA(p->org, p->scaley, p->vel, up2); + R_CalcBeamVerts(varray_vertex, v, up2, p->scalex); + } + else if (orientation == PARTICLE_BILLBOARD) { - m.index[0] = 0; - m.index[1] = 1; - m.index[2] = 2; - m.index[3] = 0; - m.index[4] = 2; - m.index[5] = 3; - m.vertex[0] = org[0] - right[0] - up[0]; - m.vertex[1] = org[1] - right[1] - up[1]; - m.vertex[2] = org[2] - right[2] - up[2]; - m.vertex[4] = org[0] - right[0] + up[0]; - m.vertex[5] = org[1] - right[1] + up[1]; - m.vertex[6] = org[2] - right[2] + up[2]; - m.vertex[8] = org[0] + right[0] + up[0]; - m.vertex[9] = org[1] + right[1] + up[1]; - m.vertex[10] = org[2] + right[2] + up[2]; - m.vertex[12] = org[0] + right[0] - up[0]; - m.vertex[13] = org[1] + right[1] - up[1]; - m.vertex[14] = org[2] + right[2] - up[2]; - tex = &particletexture[texnum]; - m.texcoords[0][0] = tex->s1; - m.texcoords[0][1] = tex->t1; - m.texcoords[0][2] = tex->s1; - m.texcoords[0][3] = tex->t2; - m.texcoords[0][4] = tex->s2; - m.texcoords[0][5] = tex->t2; - m.texcoords[0][6] = tex->s2; - m.texcoords[0][7] = tex->t1; - m.color[0] = m.color[4] = m.color[8] = m.color[12] = cr * m.colorscale; - m.color[1] = m.color[5] = m.color[9] = m.color[13] = cg * m.colorscale; - m.color[2] = m.color[6] = m.color[10] = m.color[14] = cb * m.colorscale; - m.color[3] = m.color[7] = m.color[11] = m.color[15] = ca; - R_Mesh_Render(); + VectorScale(vright, p->scalex, right); + VectorScale(vup, p->scaley, up); + varray_vertex[ 0] = org[0] + right[0] - up[0]; + varray_vertex[ 1] = org[1] + right[1] - up[1]; + varray_vertex[ 2] = org[2] + right[2] - up[2]; + varray_vertex[ 4] = org[0] - right[0] - up[0]; + varray_vertex[ 5] = org[1] - right[1] - up[1]; + varray_vertex[ 6] = org[2] - right[2] - up[2]; + varray_vertex[ 8] = org[0] - right[0] + up[0]; + varray_vertex[ 9] = org[1] - right[1] + up[1]; + varray_vertex[10] = org[2] - right[2] + up[2]; + varray_vertex[12] = org[0] + right[0] + up[0]; + varray_vertex[13] = org[1] + right[1] + up[1]; + varray_vertex[14] = org[2] + right[2] + up[2]; + } + else if (orientation == PARTICLE_ORIENTED_DOUBLESIDED) + { + // double-sided + if (DotProduct(p->vel2, r_origin) > DotProduct(p->vel2, org)) + { + 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]; } + else + Host_Error("R_DrawParticles: unknown particle orientation %i\n", orientation); +#if WORKINGLQUAKE + glBegin(GL_QUADS); + glColor4f(cr, cg, cb, ca); + glTexCoord2f(tex->s2, tex->t1);glVertex3f(varray_vertex[ 0], varray_vertex[ 1], varray_vertex[ 2]); + glTexCoord2f(tex->s1, tex->t1);glVertex3f(varray_vertex[ 4], varray_vertex[ 5], varray_vertex[ 6]); + glTexCoord2f(tex->s1, tex->t2);glVertex3f(varray_vertex[ 8], varray_vertex[ 9], varray_vertex[10]); + glTexCoord2f(tex->s2, tex->t2);glVertex3f(varray_vertex[12], varray_vertex[13], varray_vertex[14]); + glEnd(); +#else + R_Mesh_Draw(4, 2, polygonelements); +#endif } void R_DrawParticles (void) @@ -1318,21 +1579,34 @@ void R_DrawParticles (void) float minparticledist; particle_t *p; +#ifdef WORKINGLQUAKE + CL_MoveParticles(); +#endif + // LordHavoc: early out conditions if ((!cl_numparticles) || (!r_drawparticles.integer)) return; - c_particles += cl_numparticles; - minparticledist = DotProduct(r_origin, vpn) + 16.0f; +#ifdef WORKINGLQUAKE + glBindTexture(GL_TEXTURE_2D, particlefonttexture); + glEnable(GL_BLEND); + glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + glDepthMask(0); + // LordHavoc: only render if not too close for (i = 0, p = particles;i < cl_numparticles;i++, p++) - { - // LordHavoc: only render if not too close - if (DotProduct(p->org, vpn) < minparticledist) - continue; - - R_MeshQueue_AddTransparent(p->org, R_DrawParticleCallback, p, 0); - } + if (DotProduct(p->org, vpn) >= minparticledist) + R_DrawParticleCallback(p, 0); + glDepthMask(1); + glDisable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); +#else + // LordHavoc: only render if not too close + c_particles += cl_numparticles; + for (i = 0, p = particles;i < cl_numparticles;i++, p++) + if (DotProduct(p->org, vpn) >= minparticledist) + R_MeshQueue_AddTransparent(p->org, R_DrawParticleCallback, p, 0); +#endif }