This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
#include "quakedef.h"
-#define MAX_PARTICLES 2048 // default max # of particles at one
- // time
-#define ABSOLUTE_MIN_PARTICLES 512 // no fewer than this no matter what's
- // on the command line
+#define MAX_PARTICLES 16384 // default max # of particles at one time
+#define ABSOLUTE_MIN_PARTICLES 512 // no fewer than this no matter what's on the command line
-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};
-
-int particletexture;
-int smokeparticletexture;
-int flareparticletexture;
-int rainparticletexture;
-int bloodcloudparticletexture;
-int bubbleparticletexture;
-
-particle_t *active_particles, *free_particles;
-
-particle_t *particles;
-int r_numparticles;
-
-vec3_t r_pright, r_pup, r_ppn;
+typedef enum
+{
+ pt_static, pt_grav, pt_blob, pt_blob2, pt_bulletsmoke, pt_smoke, pt_snow, pt_rain, pt_spark, pt_bubble, pt_fade, pt_steam, pt_splash, pt_splashpuff, pt_flame, pt_blood, pt_oneframe, pt_lavasplash, pt_raindropsplash, pt_underwaterspark, pt_explosionsplash
+}
+ptype_t;
-//extern cvar_t r_particles/*, r_smoke*/, r_smokealpha;
-//cvar_t r_smokecolor = {"r_smokecolor", "0"};
+typedef struct
+{
+ float s1, t1, s2, t2;
+}
+particletexture_t;
-void fractalnoise(char *noise, int size);
-void fractalnoise_zeroedge(char *noise, int size);
+typedef struct particle_s
+{
+ ptype_t type;
+ vec3_t org;
+ vec3_t vel;
+ particletexture_t *tex;
+ float die;
+ float scale;
+ float alpha; // 0-255
+ float time2; // used for various things (snow fluttering, for example)
+ float bounce; // how much bounce-back from a surface the particle hits (0 = no physics, 1 = stop and slide, 2 = keep bouncing forever, 1.5 is typical)
+ 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
+ int dynlight; // if set the particle will be dynamically lit (if r_dynamicparticles is on), used for smoke and blood
+ int rendermode; // a TPOLYTYPE_ value
+ byte color[4];
+}
+particle_t;
-void R_InitParticleTexture (void)
+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
+};
+
+static int explosparkramp[8] = {0x4b0700, 0x6f0f00, 0x931f07, 0xb7330f, 0xcf632b, 0xe3974f, 0xffe7b5, 0xffffff};
+//static int explounderwatersparkramp[8] = {0x00074b, 0x000f6f, 0x071f93, 0x0f33b7, 0x2b63cf, 0x4f97e3, 0xb5e7ff, 0xffffff};
+
+static rtexture_t *particlefonttexture;
+
+static particletexture_t particletexture;
+static particletexture_t smokeparticletexture[8];
+static particletexture_t rainparticletexture;
+static particletexture_t bubbleparticletexture;
+static particletexture_t bulletholetexture[8];
+static particletexture_t rocketglowparticletexture;
+static particletexture_t raindropsplashparticletexture[16];
+
+static particle_t *particles;
+static int r_numparticles;
+
+static int numparticles;
+static particle_t **freeparticles; // list used only in compacting particles array
+
+static cvar_t r_particles = {CVAR_SAVE, "r_particles", "1"};
+static cvar_t r_drawparticles = {0, "r_drawparticles", "1"};
+static cvar_t r_particles_lighting = {CVAR_SAVE, "r_particles_lighting", "1"};
+static cvar_t r_particles_bloodshowers = {CVAR_SAVE, "r_particles_bloodshowers", "1"};
+static cvar_t r_particles_blood = {CVAR_SAVE, "r_particles_blood", "1"};
+static cvar_t r_particles_smoke = {CVAR_SAVE, "r_particles_smoke", "1"};
+static cvar_t r_particles_sparks = {CVAR_SAVE, "r_particles_sparks", "1"};
+static cvar_t r_particles_bubbles = {CVAR_SAVE, "r_particles_bubbles", "1"};
+static cvar_t r_particles_explosions = {CVAR_SAVE, "r_particles_explosions", "0"};
+
+static byte shadebubble(float dx, float dy, vec3_t light)
{
- int x,y,d;
- float dx, dy, dz, f, dot;
- byte data[64][64][4], noise1[64][64], noise2[64][64];
- vec3_t normal, light;
+ float dz, f, dot;
+ vec3_t normal;
+ dz = 1 - (dx*dx+dy*dy);
+ if (dz > 0) // it does hit the sphere
+ {
+ f = 0;
+ // back side
+ normal[0] = dx;normal[1] = dy;normal[2] = dz;
+ VectorNormalize(normal);
+ dot = DotProduct(normal, light);
+ if (dot > 0.5) // interior reflection
+ f += ((dot * 2) - 1);
+ else if (dot < -0.5) // exterior reflection
+ f += ((dot * -2) - 1);
+ // front side
+ normal[0] = dx;normal[1] = dy;normal[2] = -dz;
+ VectorNormalize(normal);
+ dot = DotProduct(normal, light);
+ if (dot > 0.5) // interior reflection
+ f += ((dot * 2) - 1);
+ else if (dot < -0.5) // exterior reflection
+ f += ((dot * -2) - 1);
+ f *= 128;
+ f += 16; // just to give it a haze so you can see the outline
+ f = bound(0, f, 255);
+ return (byte) f;
+ }
+ else
+ return 0;
+}
- particletexture = texture_extension_number++;
- glBindTexture(GL_TEXTURE_2D, particletexture);
+static void R_InitParticleTexture (void)
+{
+ int x,y,d,i,m, texnum;
+ float dx, dy, radius, f, f2;
+ byte data[32][32][4], noise1[64][64], noise2[64][64];
+ vec3_t light;
+ byte particletexturedata[256][256][4];
+
+ memset(&particletexturedata[0][0][0], 255, sizeof(particletexturedata));
+ texnum = 0;
+ #define SETUPTEX(var)\
+ {\
+ int basex, basey, y;\
+ if (texnum >= 64)\
+ {\
+ Sys_Error("R_InitParticleTexture: ran out of textures (64)\n");\
+ return; /* only to hush compiler */ \
+ }\
+ basex = (texnum & 7) * 32;\
+ basey = ((texnum >> 3) & 7) * 32;\
+ var.s1 = (basex + 1) / 256.0f;\
+ var.t1 = (basey + 1) / 256.0f;\
+ var.s2 = (basex + 31) / 256.0f;\
+ var.t2 = (basey + 31) / 256.0f;\
+ for (y = 0;y < 32;y++)\
+ memcpy(&particletexturedata[basey + y][basex][0], &data[y][0][0], 32*4);\
+ texnum++;\
+ }
- for (x=0 ; x<64 ; x++)
+ for (y = 0;y < 32;y++)
{
- for (y=0 ; y<64 ; y++)
+ dy = y - 16;
+ for (x = 0;x < 32;x++)
{
data[y][x][0] = data[y][x][1] = data[y][x][2] = 255;
dx = x - 16;
- dy = y - 16;
- d = (255 - (dx*dx+dy*dy));
- if (d < 0) d = 0;
+ d = (256 - (dx*dx+dy*dy));
+ d = bound(0, d, 255);
data[y][x][3] = (byte) d;
}
}
- glTexImage2D (GL_TEXTURE_2D, 0, 4, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
-
- glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+ SETUPTEX(particletexture)
+// particletexture = R_LoadTexture ("particletexture", 32, 32, &data[0][0][0], TEXF_MIPMAP | TEXF_ALPHA | TEXF_RGBA | TEXF_PRECACHE);
- glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
- glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-
-
- fractalnoise(&noise1[0][0], 64);
- fractalnoise(&noise2[0][0], 64);
- for (y = 0;y < 64;y++)
- for (x = 0;x < 64;x++)
+ for (i = 0;i < 8;i++)
+ {
+ do
{
- data[y][x][0] = data[y][x][1] = data[y][x][2] = (noise1[y][x] >> 1) + 128;
- dx = x - 16;
- dy = y - 16;
- d = (noise2[y][x] * (255 - (dx*dx+dy*dy))) * (1.0f / 255.0f);
- if (d < 0) d = 0;
- if (d > 255) d = 255;
- data[y][x][3] = (byte) d;
+ fractalnoise(&noise1[0][0], 64, 4);
+ fractalnoise(&noise2[0][0], 64, 8);
+ m = 0;
+ for (y = 0;y < 32;y++)
+ {
+ dy = y - 16;
+ for (x = 0;x < 32;x++)
+ {
+ d = (noise1[y][x] - 128) * 2 + 64; // was + 128
+ d = bound(0, d, 255);
+ data[y][x][0] = data[y][x][1] = data[y][x][2] = d;
+ dx = x - 16;
+ d = (noise2[y][x] - 128) * 3 + 192;
+ if (d > 0)
+ d = (d * (256 - (int) (dx*dx+dy*dy))) >> 8;
+ d = bound(0, d, 255);
+ data[y][x][3] = (byte) d;
+ if (m < d)
+ m = d;
+ }
+ }
}
+ while (m < 224);
- /*
- for (x=0 ; x<34 ; x+=2)
- for (y=0 ; y<34 ; y+=2)
- data[y][x][0] = data[y][x][1] = data[y][x][2] = (rand()%64)+192;
- for (x=0 ; x<32 ; x+=2)
- for (y=0 ; y<32 ; y+=2)
- {
- data[y ][x+1][0] = data[y ][x+1][1] = data[y ][x+1][2] = (int) (data[y ][x ][0] + data[y ][x+2][0]) >> 1;
- data[y+1][x ][0] = data[y+1][x ][1] = data[y+1][x ][2] = (int) (data[y ][x ][0] + data[y+2][x ][0]) >> 1;
- data[y+1][x+1][0] = data[y+1][x+1][1] = data[y+1][x+1][2] = (int) (data[y ][x ][0] + data[y ][x+2][0] + data[y+2][x ][0] + data[y+2][x+2][0]) >> 2;
- }
- for (x=0 ; x<64 ; x++)
+ SETUPTEX(smokeparticletexture[i])
+// smokeparticletexture[i] = R_LoadTexture (va("smokeparticletexture%02d", i), 32, 32, &data[0][0][0], TEXF_MIPMAP | TEXF_ALPHA | TEXF_RGBA | TEXF_PRECACHE);
+ }
+
+ light[0] = 1;light[1] = 1;light[2] = 1;
+ VectorNormalize(light);
+ for (y = 0;y < 32;y++)
{
- for (y=0 ; y<64 ; y++)
+ for (x = 0;x < 32;x++)
{
- //data[y][x][0] = data[y][x][1] = data[y][x][2] = (rand()%192)+64;
- dx = x - 16;
- dy = y - 16;
- d = (255 - (dx*dx+dy*dy));
- if (d < 0) d = 0;
- data[y][x][3] = (byte) d;
+ 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);
}
}
- */
- smokeparticletexture = texture_extension_number++;
- glBindTexture(GL_TEXTURE_2D, smokeparticletexture);
- glTexImage2D (GL_TEXTURE_2D, 0, 4, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
- glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
- glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
- glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-
- fractalnoise(&noise1[0][0], 64);
- fractalnoise(&noise2[0][0], 64);
- for (y = 0;y < 64;y++)
- for (x = 0;x < 64;x++)
- {
- data[y][x][0] = data[y][x][1] = data[y][x][2] = (noise1[y][x] >> 1) + 128;
- dx = x - 16;
- dy = y - 16;
- d = (noise2[y][x] * (255 - (dx*dx+dy*dy))) * (1.0f / 255.0f);
- if (d < 0) d = 0;
- if (d > 255) d = 255;
- data[y][x][3] = (byte) d;
- }
-
- bloodcloudparticletexture = texture_extension_number++;
- glBindTexture(GL_TEXTURE_2D, bloodcloudparticletexture);
- glTexImage2D (GL_TEXTURE_2D, 0, 4, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
- glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
- glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
- glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+ SETUPTEX(rainparticletexture)
+// rainparticletexture = R_LoadTexture ("rainparticletexture", 32, 32, &data[0][0][0], TEXF_MIPMAP | TEXF_ALPHA | TEXF_RGBA | TEXF_PRECACHE);
- flareparticletexture = texture_extension_number++;
- glBindTexture(GL_TEXTURE_2D, flareparticletexture);
-
- for (x=0 ; x<64 ; x++)
+ light[0] = 1;light[1] = 1;light[2] = 1;
+ VectorNormalize(light);
+ for (y = 0;y < 32;y++)
{
- for (y=0 ; y<64 ; y++)
+ for (x = 0;x < 32;x++)
{
data[y][x][0] = data[y][x][1] = data[y][x][2] = 255;
- dx = x - 16;
- dy = y - 16;
- d = 2048 / (dx*dx+dy*dy+1) - 32;
- d = bound(0, d, 255);
- data[y][x][3] = (byte) d;
+ data[y][x][3] = shadebubble((x - 16) * (1.0 / 16.0), (y - 16) * (1.0 / 16.0), light);
}
}
- glTexImage2D (GL_TEXTURE_2D, 0, 4, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
-
- glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-
- glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
- glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+ SETUPTEX(bubbleparticletexture)
+// bubbleparticletexture = R_LoadTexture ("bubbleparticletexture", 32, 32, &data[0][0][0], TEXF_MIPMAP | TEXF_ALPHA | TEXF_RGBA | TEXF_PRECACHE);
- rainparticletexture = texture_extension_number++;
- glBindTexture(GL_TEXTURE_2D, rainparticletexture);
-
- for (x=0 ; x<64 ; x++)
+ for (i = 0;i < 8;i++)
{
- for (y=0 ; y<64 ; y++)
+ float p[32][32];
+ fractalnoise(&noise1[0][0], 64, 8);
+ for (y = 0;y < 32;y++)
+ for (x = 0;x < 32;x++)
+ p[y][x] = (noise1[y][x] / 8.0f) - 64.0f;
+ for (m = 0;m < 32;m++)
{
- data[y][x][0] = data[y][x][1] = data[y][x][2] = 255;
- if (y < 24) // stretch the upper half to make a raindrop
+ int j;
+ float fx, fy, f;
+ fx = lhrandom(14, 18);
+ fy = lhrandom(14, 18);
+ do
{
- dx = (x - 16)*2;
- dy = (y - 24)*2/3;
- d = (255 - (dx*dx+dy*dy))/2;
+ dx = lhrandom(-1, 1);
+ dy = lhrandom(-1, 1);
+ f = (dx * dx + dy * dy);
}
- else
+ while(f < 0.125f || f > 1.0f);
+ f = (m + 1) / 40.0f; //lhrandom(0.0f, 1.0);
+ dx *= 1.0f / 32.0f;
+ dy *= 1.0f / 32.0f;
+ for (j = 0;f > 0 && j < (32 * 14);j++)
{
- dx = (x - 16)*2;
- dy = (y - 24)*2;
- d = (255 - (dx*dx+dy*dy))/2;
+ y = fy;
+ x = fx;
+ fx += dx;
+ fy += dy;
+ p[y - 1][x - 1] += f * 0.125f;
+ p[y - 1][x ] += f * 0.25f;
+ p[y - 1][x + 1] += f * 0.125f;
+ p[y ][x - 1] += f * 0.25f;
+ p[y ][x ] += f;
+ p[y ][x + 1] += f * 0.25f;
+ p[y + 1][x - 1] += f * 0.125f;
+ p[y + 1][x ] += f * 0.25f;
+ p[y + 1][x + 1] += f * 0.125f;
+// f -= (0.5f / (32 * 16));
+ }
+ }
+ for (y = 0;y < 32;y++)
+ {
+ for (x = 0;x < 32;x++)
+ {
+ m = p[y][x];
+ data[y][x][0] = data[y][x][1] = data[y][x][2] = 255;
+ data[y][x][3] = (byte) bound(0, m, 255);
}
- if (d < 0) d = 0;
- data[y][x][3] = (byte) d;
}
- }
- glTexImage2D (GL_TEXTURE_2D, 0, 4, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
-
- glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
- glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
- glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+ SETUPTEX(bulletholetexture[i])
+// bulletholetexture[i] = R_LoadTexture (va("bulletholetexture%02d", i), 32, 32, &data[0][0][0], TEXF_MIPMAP | TEXF_ALPHA | TEXF_RGBA | TEXF_PRECACHE);
+ }
- bubbleparticletexture = texture_extension_number++;
- glBindTexture(GL_TEXTURE_2D, bubbleparticletexture);
+ for (y = 0;y < 32;y++)
+ {
+ dy = y - 16;
+ for (x = 0;x < 32;x++)
+ {
+ dx = x - 16;
+ d = (2048.0f / (dx*dx+dy*dy+1)) - 8.0f;
+ data[y][x][0] = bound(0, d * 1.0f, 255);
+ data[y][x][1] = bound(0, d * 0.8f, 255);
+ data[y][x][2] = bound(0, d * 0.5f, 255);
+ data[y][x][3] = bound(0, d * 1.0f, 255);
+ }
+ }
+ SETUPTEX(rocketglowparticletexture)
+// rocketglowparticletexture = R_LoadTexture ("glowparticletexture", 32, 32, &data[0][0][0], TEXF_MIPMAP | TEXF_ALPHA | TEXF_RGBA | TEXF_PRECACHE);
- light[0] = 1;light[1] = 1;light[2] = 1;
- VectorNormalize(light);
- for (x=0 ; x<64 ; x++)
+ for (i = 0;i < 16;i++)
{
- for (y=0 ; y<64 ; y++)
+ radius = i * 3.0f / 16.0f;
+ f2 = 255.0f * ((15.0f - i) / 15.0f);
+ for (y = 0;y < 32;y++)
{
- data[y][x][0] = data[y][x][1] = data[y][x][2] = 255;
- dx = x * (1.0 / 16.0) - 1.0;
- dy = y * (1.0 / 16.0) - 1.0;
- if (dx*dx+dy*dy < 1) // it does hit the sphere
+ dy = (y - 16) * 0.25f;
+ for (x = 0;x < 32;x++)
{
- dz = 1 - (dx*dx+dy*dy);
- f = 0;
- // back side
- normal[0] = dx;normal[1] = dy;normal[2] = dz;
- VectorNormalize(normal);
- dot = DotProduct(normal, light);
- if (dot > 0.5) // interior reflection
- f += ((dot * 2) - 1);
- else if (dot < -0.5) // exterior reflection
- f += ((dot * -2) - 1);
- // front side
- normal[0] = dx;normal[1] = dy;normal[2] = -dz;
- VectorNormalize(normal);
- dot = DotProduct(normal, light);
- if (dot > 0.5) // interior reflection
- f += ((dot * 2) - 1);
- else if (dot < -0.5) // exterior reflection
- f += ((dot * -2) - 1);
- f *= 255;
- f = bound(0, f, 255);
- data[y][x][3] = (byte) d;
+ 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;
}
- else
- data[y][x][3] = 0;
}
+ SETUPTEX(raindropsplashparticletexture[i])
+// raindropsplashparticletexture[i] = R_LoadTexture (va("raindropslashparticletexture%02d", i), 32, 32, &data[0][0][0], TEXF_MIPMAP | TEXF_ALPHA | TEXF_RGBA | TEXF_PRECACHE);
}
- glTexImage2D (GL_TEXTURE_2D, 0, 4, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
- glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+ particlefonttexture = R_LoadTexture ("particlefont", 256, 256, &particletexturedata[0][0][0], TEXF_ALPHA | TEXF_RGBA | TEXF_PRECACHE);
+}
+
+static void r_part_start(void)
+{
+ particles = (particle_t *) qmalloc(r_numparticles * sizeof(particle_t));
+ freeparticles = (void *) qmalloc(r_numparticles * sizeof(particle_t *));
+ numparticles = 0;
+ R_InitParticleTexture ();
+}
+
+static void r_part_shutdown(void)
+{
+ numparticles = 0;
+ qfree(particles);
+ qfree(freeparticles);
+}
- glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
- glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+static void r_part_newmap(void)
+{
+ numparticles = 0;
}
/*
R_InitParticles
===============
*/
-void R_InitParticles (void)
+void R_ReadPointFile_f (void);
+void R_Particles_Init (void)
{
int i;
r_numparticles = MAX_PARTICLES;
}
- particles = (particle_t *) Hunk_AllocName (r_numparticles * sizeof(particle_t), "particles");
+ Cmd_AddCommand ("pointfile", R_ReadPointFile_f);
-// Cvar_RegisterVariable (&r_smokecolor);
- R_InitParticleTexture ();
+ Cvar_RegisterVariable (&r_particles);
+ Cvar_RegisterVariable (&r_drawparticles);
+ Cvar_RegisterVariable (&r_particles_lighting);
+ Cvar_RegisterVariable (&r_particles_bloodshowers);
+ Cvar_RegisterVariable (&r_particles_blood);
+ Cvar_RegisterVariable (&r_particles_smoke);
+ Cvar_RegisterVariable (&r_particles_sparks);
+ Cvar_RegisterVariable (&r_particles_bubbles);
+ Cvar_RegisterVariable (&r_particles_explosions);
+
+ R_RegisterModule("R_Particles", r_part_start, r_part_shutdown, r_part_newmap);
+}
+
+//void particle(int ptype, int pcolor, int ptex, int prendermode, int plight, float pscale, float palpha, float ptime, float pbounce, float px, float py, float pz, float pvx, float pvy, float pvz)
+#define particle(ptype, pcolor, ptex, prendermode, plight, pscale, palpha, ptime, pbounce, px, py, pz, pvx, pvy, pvz, ptime2, pvx2, pvy2, pvz2, pfriction, ppressure)\
+{\
+ particle_t *part;\
+ int tempcolor;\
+ if (numparticles >= r_numparticles)\
+ return;\
+ part = &particles[numparticles++];\
+ part->type = (ptype);\
+ tempcolor = (pcolor);\
+ part->color[0] = ((tempcolor) >> 16) & 0xFF;\
+ part->color[1] = ((tempcolor) >> 8) & 0xFF;\
+ part->color[2] = (tempcolor) & 0xFF;\
+ part->color[3] = 0xFF;\
+ part->tex = (&ptex);\
+ part->dynlight = (plight);\
+ part->rendermode = (prendermode);\
+ part->scale = (pscale);\
+ part->alpha = (palpha);\
+ part->die = cl.time + (ptime);\
+ 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);\
}
/*
R_EntityParticles
===============
*/
-
-#define NUMVERTEXNORMALS 162
-extern float r_avertexnormals[NUMVERTEXNORMALS][3];
-vec3_t avelocities[NUMVERTEXNORMALS];
-float beamlength = 16;
-vec3_t avelocity = {23, 7, 3};
-float partstep = 0.01;
-float timescale = 0.01;
-
void R_EntityParticles (entity_t *ent)
{
- int count;
int i;
- particle_t *p;
float angle;
- float sr, sp, sy, cr, cp, cy;
+ float sp, sy, cp, cy;
vec3_t forward;
float dist;
-// if (!r_particles.value) return; // LordHavoc: particles are optional
-
- dist = 64;
- count = 50;
+ float beamlength;
+ static vec3_t avelocities[NUMVERTEXNORMALS];
+ if (!r_particles.value) return; // LordHavoc: particles are optional
-if (!avelocities[0][0])
-{
-for (i=0 ; i<NUMVERTEXNORMALS*3 ; i++)
-avelocities[0][i] = (rand()&255) * 0.01;
-}
+ dist = 64;
+ beamlength = 16;
+ if (!avelocities[0][0])
+ for (i=0 ; i<NUMVERTEXNORMALS*3 ; i++)
+ avelocities[0][i] = (rand()&255) * 0.01;
for (i=0 ; i<NUMVERTEXNORMALS ; i++)
{
angle = cl.time * avelocities[i][1];
sp = sin(angle);
cp = cos(angle);
- angle = cl.time * avelocities[i][2];
- sr = sin(angle);
- cr = cos(angle);
-
+
forward[0] = cp*cy;
forward[1] = cp*sy;
forward[2] = -sp;
- if (!free_particles)
- return;
- p = free_particles;
- free_particles = p->next;
- p->next = active_particles;
- active_particles = p;
-
- p->texnum = flareparticletexture;
- p->scale = 2;
- p->alpha = 255;
- p->die = cl.time + 0.01;
- p->color = 0x6f;
- p->type = pt_explode;
-
- p->org[0] = ent->origin[0] + r_avertexnormals[i][0]*dist + forward[0]*beamlength;
- p->org[1] = ent->origin[1] + r_avertexnormals[i][1]*dist + forward[1]*beamlength;
- p->org[2] = ent->origin[2] + r_avertexnormals[i][2]*dist + forward[2]*beamlength;
+ particle(pt_oneframe, particlepalette[0x6f], particletexture, TPOLYTYPE_ALPHA, false, 2, 255, 9999, 0, ent->render.origin[0] + m_bytenormals[i][0]*dist + forward[0]*beamlength, ent->render.origin[1] + m_bytenormals[i][1]*dist + forward[1]*beamlength, ent->render.origin[2] + m_bytenormals[i][2]*dist + forward[2]*beamlength, 0, 0, 0, 0, 0, 0, 0, 0, 0);
}
}
-/*
-===============
-R_ClearParticles
-===============
-*/
-void R_ClearParticles (void)
-{
- int i;
-
- free_particles = &particles[0];
- active_particles = NULL;
-
- for (i=0 ;i<r_numparticles ; i++)
- particles[i].next = &particles[i+1];
- particles[r_numparticles-1].next = NULL;
-}
-
-
void R_ReadPointFile_f (void)
{
- FILE *f;
+ QFile *f;
vec3_t org;
int r;
int c;
- particle_t *p;
char name[MAX_OSPATH];
-
+
sprintf (name,"maps/%s.pts", sv.name);
- COM_FOpenFile (name, &f, false);
+ COM_FOpenFile (name, &f, false, true);
if (!f)
{
Con_Printf ("couldn't open %s\n", name);
return;
}
-
+
Con_Printf ("Reading %s...\n", name);
c = 0;
- for ( ;; )
+ for (;;)
{
- r = fscanf (f,"%f %f %f\n", &org[0], &org[1], &org[2]);
+ char *str = Qgetline (f);
+ r = sscanf (str,"%f %f %f\n", &org[0], &org[1], &org[2]);
if (r != 3)
break;
c++;
-
- if (!free_particles)
+
+ if (numparticles >= r_numparticles)
{
Con_Printf ("Not enough free particles\n");
break;
}
- p = free_particles;
- free_particles = p->next;
- p->next = active_particles;
- active_particles = p;
-
- p->texnum = particletexture;
- p->scale = 2;
- p->alpha = 255;
- p->die = 99999;
- p->color = (-c)&15;
- p->type = pt_static;
- VectorCopy (vec3_origin, p->vel);
- VectorCopy (org, p->org);
+ particle(pt_static, particlepalette[(-c)&15], particletexture, TPOLYTYPE_ALPHA, false, 2, 255, 99999, 0, org[0], org[1], org[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
}
- fclose (f);
+ Qclose (f);
Con_Printf ("%i points read\n", c);
}
{
vec3_t org, dir;
int i, count, msgcount, color;
-
+
for (i=0 ; i<3 ; i++)
org[i] = MSG_ReadCoord ();
for (i=0 ; i<3 ; i++)
msgcount = MSG_ReadByte ();
color = MSG_ReadByte ();
-if (msgcount == 255)
- count = 1024;
-else
- count = msgcount;
-
+ if (msgcount == 255)
+ count = 1024;
+ else
+ count = msgcount;
+
R_RunParticleEffect (org, dir, color, count);
}
-
+
/*
===============
R_ParticleExplosion
*/
void R_ParticleExplosion (vec3_t org, int smoke)
{
- int i, j;
- particle_t *p;
-// if (!r_particles.value) return; // LordHavoc: particles are optional
-
- for (i=0 ; i<1024 ; i++)
+ int i, j;
+ float f;
+ vec3_t v, end, ang;
+ byte noise1[32*32], noise2[32*32];
+
+ if (r_particles.value && r_particles_explosions.value)
{
- if (!free_particles)
- return;
- p = free_particles;
- free_particles = p->next;
- p->next = active_particles;
- active_particles = p;
-
- p->texnum = flareparticletexture;
- p->scale = 4+(rand()&7);
- p->alpha = rand()&255;
- p->die = cl.time + 5;
- p->color = ramp1[0];
- p->ramp = rand()&3;
- /*
- if (i & 1)
- p->type = pt_explode;
- else
- p->type = pt_explode2;
- */
- p->color = ramp1[rand()&7];
- p->type = pt_fallfadespark;
- for (j=0 ; j<3 ; j++)
+ i = Mod_PointInLeaf(org, cl.worldmodel)->contents;
+ if (i == CONTENTS_SLIME || i == CONTENTS_WATER)
{
- p->org[j] = org[j] + ((rand()&63)-32);
- p->vel[j] = (rand()&511)-256;
- }
- p->vel[j] += 200;
- }
+ for (i = 0;i < 128;i++)
+ particle(pt_bubble, 0xFFFFFF, bubbleparticletexture, TPOLYTYPE_ALPHA, false, lhrandom(1, 2), 255, 9999, 1.5, org[0] + lhrandom(-16, 16), org[1] + lhrandom(-16, 16), org[2] + lhrandom(-16, 16), lhrandom(-96, 96), lhrandom(-96, 96), lhrandom(-96, 96), 0, 0, 0, 0, 0, 0);
- if (smoke)
- {
- for (i=0 ; i<32 ; i++)
+ ang[2] = lhrandom(0, 360);
+ fractalnoise(noise1, 32, 4);
+ fractalnoise(noise2, 32, 8);
+ for (i = 0;i < 32;i++)
+ {
+ for (j = 0;j < 32;j++)
+ {
+ VectorRandom(v);
+ VectorMA(org, 16, v, v);
+ TraceLine(org, v, end, NULL, 0);
+ ang[0] = (j + 0.5f) * (360.0f / 32.0f);
+ ang[1] = (i + 0.5f) * (360.0f / 32.0f);
+ AngleVectors(ang, v, NULL, NULL);
+ f = noise1[j*32+i] * 1.5f;
+ VectorScale(v, f, v);
+ particle(pt_underwaterspark, noise2[j*32+i] * 0x010101, smokeparticletexture[rand()&7], TPOLYTYPE_ALPHA, false, 10, lhrandom(128, 255), 9999, 1.5, end[0], end[1], end[2], v[0], v[1], v[2], 512.0f, 0, 0, 0, 2, 0);
+ VectorScale(v, 0.75, v);
+ particle(pt_underwaterspark, explosparkramp[(noise2[j*32+i] >> 5)], particletexture, TPOLYTYPE_ALPHA, false, 10, lhrandom(128, 255), 9999, 1.5, end[0], end[1], end[2], v[0], v[1], v[2], 512.0f, 0, 0, 0, 2, 0);
+ }
+ }
+ }
+ else
{
- if (!free_particles)
- return;
- p = free_particles;
- free_particles = p->next;
- p->next = active_particles;
- active_particles = p;
-
- p->texnum = smokeparticletexture;
- p->scale = 24;
- p->alpha = 80;
- p->die = cl.time + 2;
- p->type = pt_smoke;
- p->color = (rand()&7) + 8;
- for (j=0 ; j<3 ; j++)
+ ang[2] = lhrandom(0, 360);
+ fractalnoise(noise1, 32, 4);
+ fractalnoise(noise2, 32, 8);
+ for (i = 0;i < 32;i++)
{
- p->org[j] = org[j] + ((rand()%96)-48);
- p->vel[j] = (rand()&63)-32;
+ for (j = 0;j < 32;j++)
+ {
+ VectorRandom(v);
+ VectorMA(org, 16, v, v);
+ TraceLine(org, v, end, NULL, 0);
+ ang[0] = (j + 0.5f) * (360.0f / 32.0f);
+ ang[1] = (i + 0.5f) * (360.0f / 32.0f);
+ AngleVectors(ang, v, NULL, NULL);
+ f = noise1[j*32+i] * 1.5f;
+ VectorScale(v, f, v);
+ particle(pt_spark, noise2[j*32+i] * 0x010101, smokeparticletexture[rand()&7], TPOLYTYPE_ALPHA, false, 10, lhrandom(128, 255), 9999, 1.5, end[0], end[1], end[2], v[0], v[1], v[2] + 160.0f, 512.0f, 0, 0, 0, 2, 0);
+ VectorScale(v, 0.75, v);
+ particle(pt_spark, explosparkramp[(noise2[j*32+i] >> 5)], particletexture, TPOLYTYPE_ALPHA, false, 10, lhrandom(128, 255), 9999, 1.5, end[0], end[1], end[2], v[0], v[1], v[2] + 160.0f, 512.0f, 0, 0, 0, 2, 0);
+ // VectorRandom(v);
+ // VectorScale(v, 384, v);
+ // particle(pt_spark, explosparkramp[rand()&7], particletexture, TPOLYTYPE_ALPHA, false, 2, lhrandom(16, 255), 9999, 1.5, end[0], end[1], end[2], v[0], v[1], v[2] + 160.0f, 512.0f, 0, 0, 0, 2, 0);
+ }
}
}
}
+ else
+ R_NewExplosion(org);
}
/*
*/
void R_ParticleExplosion2 (vec3_t org, int colorStart, int colorLength)
{
- int i, j;
- particle_t *p;
- int colorMod = 0;
-// if (!r_particles.value) return; // LordHavoc: particles are optional
+ int i;
+ if (!r_particles.value) return; // LordHavoc: particles are optional
- for (i=0; i<512; i++)
- {
- if (!free_particles)
- return;
- p = free_particles;
- free_particles = p->next;
- p->next = active_particles;
- active_particles = p;
-
- p->texnum = flareparticletexture;
- p->scale = 8;
- p->alpha = 255;
- p->die = cl.time + 0.3;
- p->color = colorStart + (colorMod % colorLength);
- colorMod++;
-
- p->type = pt_blob;
- for (j=0 ; j<3 ; j++)
- {
- p->org[j] = org[j] + ((rand()%32)-16);
- p->vel[j] = (rand()%512)-256;
- }
- }
+ for (i = 0;i < 512;i++)
+ particle(pt_fade, particlepalette[colorStart + (i % colorLength)], particletexture, TPOLYTYPE_ALPHA, false, 1.5, 255, 0.3, 0, org[0] + lhrandom(-8, 8), org[1] + lhrandom(-8, 8), org[2] + lhrandom(-8, 8), lhrandom(-192, 192), lhrandom(-192, 192), lhrandom(-192, 192), 0, 0, 0, 0, 0.1f, 0);
}
/*
*/
void R_BlobExplosion (vec3_t org)
{
- int i, j;
- particle_t *p;
-// if (!r_particles.value) return; // LordHavoc: particles are optional
-
- for (i=0 ; i<1024 ; i++)
- {
- if (!free_particles)
- return;
- p = free_particles;
- free_particles = p->next;
- p->next = active_particles;
- active_particles = p;
-
- p->texnum = flareparticletexture;
- p->scale = 8;
- p->alpha = 255;
- p->die = cl.time + 1 + (rand()&8)*0.05;
-
- if (i & 1)
- {
- p->type = pt_blob;
- p->color = 66 + rand()%6;
- for (j=0 ; j<3 ; j++)
- {
- p->org[j] = org[j] + ((rand()%32)-16);
- p->vel[j] = (rand()%512)-256;
- }
- }
- else
- {
- p->type = pt_blob2;
- p->color = 150 + rand()%6;
- for (j=0 ; j<3 ; j++)
- {
- p->org[j] = org[j] + ((rand()%32)-16);
- p->vel[j] = (rand()%512)-256;
- }
- }
- }
+ int i;
+ if (!r_particles.value) return; // LordHavoc: particles are optional
+
+ for (i = 0;i < 256;i++)
+ particle(pt_blob , particlepalette[ 66+(rand()%6)], particletexture, TPOLYTYPE_ALPHA, false, 4, 255, 9999, 0, org[0] + lhrandom(-16, 16), org[1] + lhrandom(-16, 16), org[2] + lhrandom(-16, 16), lhrandom(-4, 4), lhrandom(-4, 4), lhrandom(-128, 128), 0, 0, 0, 0, 0, 0);
+ for (i = 0;i < 256;i++)
+ particle(pt_blob2, particlepalette[150+(rand()%6)], particletexture, TPOLYTYPE_ALPHA, false, 4, 255, 9999, 0, org[0] + lhrandom(-16, 16), org[1] + lhrandom(-16, 16), org[2] + lhrandom(-16, 16), lhrandom(-4, 4), lhrandom(-4, 4), lhrandom(-128, 128), 0, 0, 0, 0, 0, 0);
}
/*
*/
void R_RunParticleEffect (vec3_t org, vec3_t dir, int color, int count)
{
- int i, j;
- particle_t *p;
-// if (!r_particles.value) return; // LordHavoc: particles are optional
-
- for (i=0 ; i<count ; i++)
+ if (!r_particles.value) return; // LordHavoc: particles are optional
+
+ if (count == 1024)
{
- if (!free_particles)
- return;
- p = free_particles;
- free_particles = p->next;
- p->next = active_particles;
- active_particles = p;
-
- if (count == 1024)
- { // rocket explosion
- p->texnum = flareparticletexture;
- p->scale = 8;
- p->alpha = 255;
- p->die = cl.time + 5;
- p->color = ramp1[0];
- p->ramp = rand()&3;
- if (i & 1)
- {
- p->type = pt_explode;
- for (j=0 ; j<3 ; j++)
- {
- p->org[j] = org[j] + ((rand()%32)-16);
- p->vel[j] = (rand()%512)-256;
- }
- }
- else
- {
- p->type = pt_explode2;
- for (j=0 ; j<3 ; j++)
- {
- p->org[j] = org[j] + ((rand()%32)-16);
- p->vel[j] = (rand()%512)-256;
- }
- }
- }
- else
- {
- p->texnum = flareparticletexture;
- p->scale = 8;
- p->alpha = 255;
- p->die = cl.time + 0.1*(rand()%5);
- p->color = (color&~7) + (rand()&7);
- p->type = pt_static; //slowgrav;
- for (j=0 ; j<3 ; j++)
- {
- p->org[j] = org[j] + ((rand()&15)-8);
- p->vel[j] = dir[j]*15;// + (rand()%300)-150;
- }
- }
+ R_ParticleExplosion(org, false);
+ return;
}
+ while (count--)
+ particle(pt_fade, particlepalette[color + (rand()&7)], particletexture, TPOLYTYPE_ALPHA, false, 1, 128, 9999, 0, org[0] + lhrandom(-8, 8), org[1] + lhrandom(-8, 8), org[2] + lhrandom(-8, 8), lhrandom(-15, 15), lhrandom(-15, 15), lhrandom(-15, 15), 0, 0, 0, 0, 0, 0);
}
// LordHavoc: added this for spawning sparks/dust (which have strong gravity)
/*
===============
R_SparkShower
-
===============
*/
-void R_SparkShower (vec3_t org, vec3_t dir, int count, int type)
+void R_SparkShower (vec3_t org, vec3_t dir, int count)
{
- int i, j;
- particle_t *p;
-// if (!r_particles.value) return; // LordHavoc: particles are optional
+ particletexture_t *tex;
+ if (!r_particles.value) return; // LordHavoc: particles are optional
- if (!free_particles)
- return;
- p = free_particles;
- free_particles = p->next;
- p->next = active_particles;
- active_particles = p;
- if (type == 0) // sparks
+ tex = &bulletholetexture[rand()&7];
+ R_Decal(org, particlefonttexture, tex->s1, tex->t1, tex->s2, tex->t2, 16, 0, 0, 0, 255);
+
+ // smoke puff
+ if (r_particles_smoke.value)
+ particle(pt_bulletsmoke, 0xA0A0A0, smokeparticletexture[rand()&7], TPOLYTYPE_ALPHA, true, 5, 255, 9999, 0, org[0], org[1], org[2], lhrandom(-8, 8), lhrandom(-8, 8), lhrandom(0, 16), 0, 0, 0, 0, 0, 0);
+
+ if (r_particles_sparks.value)
{
- p->texnum = smokeparticletexture;
- p->scale = 20;
- p->alpha = 64;
- p->color = (rand()&3)+12;
- p->type = pt_bulletpuff;
- p->die = cl.time + 1;
- VectorCopy(org, p->org);
- p->vel[0] = p->vel[1] = p->vel[2] = 0;
+ // sparks
+ while(count--)
+ particle(pt_spark, particlepalette[0x68 + (rand() & 7)], particletexture, TPOLYTYPE_ALPHA, false, 1, lhrandom(0, 255), 9999, 1.5, org[0], org[1], org[2], lhrandom(-64, 64), lhrandom(-64, 64), lhrandom(0, 128), 512.0f, 0, 0, 0, 0.2f, 0);
}
- else // blood
- {
- p->texnum = bloodcloudparticletexture;
- p->scale = 24;
- p->alpha = 128;
- p->color = (rand()&3)+68;
- p->type = pt_bloodcloud;
- p->die = cl.time + 0.5;
- VectorCopy(org, p->org);
- p->vel[0] = p->vel[1] = p->vel[2] = 0;
- return;
- }
- for (i=0 ; i<count ; i++)
+}
+
+void R_BloodPuff (vec3_t org, vec3_t vel, int count)
+{
+ // bloodcount is used to accumulate counts too small to cause a blood particle
+ static int bloodcount = 0;
+ if (!r_particles.value) return; // LordHavoc: particles are optional
+ if (!r_particles_blood.value) return;
+
+ if (count > 100)
+ count = 100;
+ bloodcount += count;
+ while(bloodcount >= 10)
{
- if (!free_particles)
- return;
- p = free_particles;
- free_particles = p->next;
- p->next = active_particles;
- active_particles = p;
-
- p->texnum = flareparticletexture;
- p->scale = 5;
- p->alpha = 255;
- p->die = cl.time + 0.0625 * (rand()&15);
- /*
- if (type == 0) // sparks
- {
- */
- p->type = pt_dust;
- p->ramp = (rand()&3);
- p->color = ramp1[(int)p->ramp];
- for (j=0 ; j<3 ; j++)
- {
- p->org[j] = org[j] + ((rand()&7)-4);
- p->vel[j] = dir[j] + (rand()%192)-96;
- }
- /*
- }
- else // blood
- {
- p->type = pt_fadespark2;
- p->color = 67 + (rand()&3);
- for (j=0 ; j<3 ; j++)
- {
- p->org[j] = org[j] + (rand()&7)-4;
- p->vel[j] = dir[j] + (rand()&63)-32;
- }
- }
- */
+ particle(pt_blood, 0x300000, smokeparticletexture[rand()&7], TPOLYTYPE_ALPHA, true, 24, 255, 9999, -1, org[0], org[1], org[2], vel[0] + lhrandom(-64, 64), vel[1] + lhrandom(-64, 64), vel[2] + lhrandom(-64, 64), 0, 0, 0, 0, 1.0f, 0);
+ bloodcount -= 10;
}
}
void R_BloodShower (vec3_t mins, vec3_t maxs, float velspeed, int count)
{
- int i, j;
- particle_t *p;
vec3_t diff;
vec3_t center;
vec3_t velscale;
-// if (!r_particles.value) return; // LordHavoc: particles are optional
+ if (!r_particles.value) return; // LordHavoc: particles are optional
+ if (!r_particles_bloodshowers.value) return;
+ if (!r_particles_blood.value) return;
VectorSubtract(maxs, mins, diff);
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];
-
- for (i=0 ; i<count ; i++)
+
+ while (count--)
{
- if (!free_particles)
- return;
- p = free_particles;
- free_particles = p->next;
- p->next = active_particles;
- active_particles = p;
-
- p->texnum = bloodcloudparticletexture;
- p->scale = 24;
- p->alpha = 96 + (rand()&63);
- p->die = cl.time + 2; //0.015625 * (rand()%128);
- p->type = pt_fadespark;
- p->color = (rand()&3)+68;
-// p->color = 67 + (rand()&3);
- for (j=0 ; j<3 ; j++)
- {
- p->org[j] = diff[j] * (float) (rand()%1024) * (1.0 / 1024.0) + mins[j];
- p->vel[j] = (p->org[j] - center[j]) * velscale[j];
- }
+ 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];
+ particle(pt_blood, 0x300000, smokeparticletexture[rand()&7], TPOLYTYPE_ALPHA, true, 24, 255, 9999, -1, org[0], org[1], org[2], vel[0], vel[1], vel[2], 0, 0, 0, 0, 1.0f, 0);
}
}
void R_ParticleCube (vec3_t mins, vec3_t maxs, vec3_t dir, int count, int colorbase, int gravity, int randomvel)
{
- int i, j;
- particle_t *p;
- vec3_t diff;
float t;
-// if (!r_particles.value) return; // LordHavoc: particles are optional
+ if (!r_particles.value) return; // LordHavoc: particles are optional
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;}
- VectorSubtract(maxs, mins, diff);
-
- for (i=0 ; i<count ; i++)
- {
- if (!free_particles)
- return;
- p = free_particles;
- free_particles = p->next;
- p->next = active_particles;
- active_particles = p;
-
- p->texnum = flareparticletexture;
- p->scale = 12;
- p->alpha = 255;
- p->die = cl.time + 1 + (rand()&15)*0.0625;
- if (gravity)
- p->type = pt_grav;
- else
- p->type = pt_static;
- p->color = colorbase + (rand()&3);
- for (j=0 ; j<3 ; j++)
- {
- p->org[j] = diff[j] * (float) (rand()&1023) * (1.0 / 1024.0) + mins[j];
- if (randomvel)
- p->vel[j] = dir[j] + (rand()%randomvel)-(randomvel*0.5);
- else
- p->vel[j] = 0;
- }
- }
+ while (count--)
+ particle(gravity ? pt_grav : pt_static, particlepalette[colorbase + (rand()&3)], particletexture, TPOLYTYPE_ALPHA, false, 2, 255, lhrandom(1, 2), 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(mins[2], maxs[2]), dir[0] + lhrandom(-randomvel, randomvel), dir[1] + lhrandom(-randomvel, randomvel), dir[2] + lhrandom(-randomvel, randomvel), 0, 0, 0, 0, 0, 0);
}
void R_ParticleRain (vec3_t mins, vec3_t maxs, vec3_t dir, int count, int colorbase, int type)
{
- int i;
- particle_t *p;
- vec3_t diff;
- vec3_t org;
vec3_t vel;
float t, z;
-// if (!r_particles.value) return; // LordHavoc: particles are optional
+ if (!r_particles.value) return; // LordHavoc: particles are optional
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 (t < 0 || t > 2) // sanity check
t = 2;
- t += cl.time;
- VectorSubtract(maxs, mins, diff);
-
- for (i=0 ; i<count ; i++)
+ switch(type)
{
- if (!free_particles)
- return;
- p = free_particles;
- free_particles = p->next;
- p->next = active_particles;
- active_particles = p;
-
- vel[0] = dir[0] + (rand()&31) - 16;
- vel[1] = dir[1] + (rand()&31) - 16;
- vel[2] = dir[2] + (rand()&63) - 32;
- org[0] = diff[0] * (float) (rand()&1023) * (1.0 / 1024.0) + mins[0];
- org[1] = diff[1] * (float) (rand()&1023) * (1.0 / 1024.0) + mins[1];
- org[2] = z;
-
- p->scale = 6;
- p->alpha = 255;
- p->die = t;
- if (type == 1)
+ case 0:
+ while(count--)
{
- p->texnum = particletexture;
- p->type = pt_snow;
+ vel[0] = dir[0] + lhrandom(-16, 16);
+ vel[1] = dir[1] + lhrandom(-16, 16);
+ vel[2] = dir[2] + lhrandom(-32, 32);
+ particle(pt_rain, particlepalette[colorbase + (rand()&3)], rainparticletexture, TPOLYTYPE_ALPHA, true, 3, 255, t, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), z, vel[0], vel[1], vel[2], 0, vel[0], vel[1], vel[2], 0, 0);
}
- else // 0
+ break;
+ case 1:
+ while(count--)
{
- p->texnum = rainparticletexture;
- p->type = pt_static;
+ vel[0] = dir[0] + lhrandom(-16, 16);
+ vel[1] = dir[1] + lhrandom(-16, 16);
+ vel[2] = dir[2] + lhrandom(-32, 32);
+ particle(pt_snow, particlepalette[colorbase + (rand()&3)], particletexture, TPOLYTYPE_ALPHA, false, 2, 255, t, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), z, vel[0], vel[1], vel[2], 0, vel[0], vel[1], vel[2], 0, 0);
}
- p->color = colorbase + (rand()&3);
- VectorCopy(org, p->org);
- VectorCopy(vel, p->vel);
+ break;
+ default:
+ Host_Error("R_ParticleRain: unknown type %i (0 = rain, 1 = snow)\n", type);
}
}
+void R_FlameCube (vec3_t mins, vec3_t maxs, int count)
+{
+ float t;
+ if (!r_particles.value) return; // LordHavoc: particles are optional
+ 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;}
+
+ while (count--)
+ particle(pt_flame, particlepalette[224 + (rand()&15)], smokeparticletexture[rand()&7], TPOLYTYPE_ALPHA, false, 8, 255, 9999, 1.1, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(mins[2], maxs[2]), lhrandom(-32, 32), lhrandom(-32, 32), lhrandom(-32, 64), 0, 0, 0, 0, 0.1f, 0);
+}
+
+void R_Flames (vec3_t org, vec3_t vel, int count)
+{
+ if (!r_particles.value) return; // LordHavoc: particles are optional
+
+ while (count--)
+ particle(pt_flame, particlepalette[224 + (rand()&15)], smokeparticletexture[rand()&7], TPOLYTYPE_ALPHA, false, 8, 255, 9999, 1.1, org[0], org[1], org[2], vel[0] + lhrandom(-128, 128), vel[1] + lhrandom(-128, 128), vel[2] + lhrandom(-128, 128), 0, 0, 0, 0, 0.1f, 0);
+}
+
+
/*
===============
===============
*/
-void R_LavaSplash (vec3_t org)
+void R_LavaSplash (vec3_t origin)
{
- int i, j, k;
- particle_t *p;
+ int i, j;
float vel;
- vec3_t dir;
-// if (!r_particles.value) return; // LordHavoc: particles are optional
+ vec3_t dir, org;
+ if (!r_particles.value) return; // LordHavoc: particles are optional
- for (i=-16 ; i<16 ; i+=2)
- for (j=-16 ; j<16 ; j+=2)
- for (k=0 ; k<1 ; k++)
- {
- if (!free_particles)
- return;
- p = free_particles;
- free_particles = p->next;
- p->next = active_particles;
- active_particles = p;
-
- p->texnum = flareparticletexture;
- p->scale = 24;
- p->alpha = 255;
- p->die = cl.time + 2 + (rand()&31) * 0.02;
- p->color = 224 + (rand()&7);
- p->type = pt_slowgrav;
-
- dir[0] = j*8 + (rand()&7);
- dir[1] = i*8 + (rand()&7);
- dir[2] = 256;
-
- p->org[0] = org[0] + dir[0];
- p->org[1] = org[1] + dir[1];
- p->org[2] = org[2] + (rand()&63);
-
- VectorNormalize (dir);
- vel = 50 + (rand()&63);
- VectorScale (dir, vel, p->vel);
- }
+ for (i=-128 ; i<128 ; i+=16)
+ {
+ for (j=-128 ; j<128 ; j+=16)
+ {
+ 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
+ particle(pt_lavasplash, particlepalette[224 + (rand()&7)], particletexture, TPOLYTYPE_ALPHA, false, 7, 255, 9999, 0, org[0], org[1], org[2], dir[0] * vel, dir[1] * vel, dir[2] * vel, 0, 0, 0, 0, 0, 0);
+ }
+ }
}
/*
void R_TeleportSplash (vec3_t org)
{
int i, j, k;
- particle_t *p;
-// vec3_t dir;
-// if (!r_particles.value) return; // LordHavoc: particles are optional
-
- /*
- for (i=-16 ; i<16 ; i+=4)
- for (j=-16 ; j<16 ; j+=4)
- for (k=-24 ; k<32 ; k+=4)
- {
- if (!free_particles)
- return;
- p = free_particles;
- free_particles = p->next;
- p->next = active_particles;
- active_particles = p;
-
- p->texnum = particletexture;
- p->scale = 2;
- p->alpha = 255;
- p->die = cl.time + 0.2 + (rand()&7) * 0.02;
- p->color = 7 + (rand()&7);
- p->type = pt_slowgrav;
-
- dir[0] = j*8;
- dir[1] = i*8;
- dir[2] = k*8;
-
- p->org[0] = org[0] + i + (rand()&3);
- p->org[1] = org[1] + j + (rand()&3);
- p->org[2] = org[2] + k + (rand()&3);
-
- VectorNormalize (dir);
- vel = 50 + (rand()&63);
- VectorScale (dir, vel, p->vel);
- }
- */
+ if (!r_particles.value) return; // LordHavoc: particles are optional
- for (i=-24 ; i<24 ; i+=8)
- for (j=-24 ; j<24 ; j+=8)
+ for (i=-16 ; i<16 ; i+=8)
+ for (j=-16 ; j<16 ; j+=8)
for (k=-24 ; k<32 ; k+=8)
- {
- if (!free_particles)
- return;
- p = free_particles;
- free_particles = p->next;
- p->next = active_particles;
- active_particles = p;
-
- p->texnum = flareparticletexture;
- p->scale = 8;
- p->alpha = (1 + rand()&7) * 32;
- p->die = cl.time + 5;
- p->color = 254; //8 + (rand()&7);
- p->type = pt_fadespark;
-
- p->org[0] = org[0] + i + (rand()&7);
- p->org[1] = org[1] + j + (rand()&7);
- p->org[2] = org[2] + k + (rand()&7);
-
- p->vel[0] = i*2 + (rand()%25) - 12;
- p->vel[1] = j*2 + (rand()%25) - 12;
- p->vel[2] = k*2 + (rand()%25) - 12 + 40;
- }
+ particle(pt_fade, 0xFFFFFF, particletexture, TPOLYTYPE_ALPHA, false, 1, lhrandom(64, 128), 9999, 0, org[0] + i + lhrandom(0, 8), org[1] + j + lhrandom(0, 8), org[2] + k + lhrandom(0, 8), i*2 + lhrandom(-12.5, 12.5), j*2 + lhrandom(-12.5, 12.5), k*2 + lhrandom(27.5, 52.5), 0, 0, 0, 0, 0.1f, -512.0f);
}
void R_RocketTrail (vec3_t start, vec3_t end, int type, entity_t *ent)
{
- vec3_t vec;
- float len, dec, t, nt, speed;
- int j, contents, bubbles;
- particle_t *p;
- static int tracercount;
-// if (!r_particles.value) return; // LordHavoc: particles are optional
-
- t = cl.oldtime;
- nt = cl.time;
- if (ent->trail_leftover < 0)
- ent->trail_leftover = 0;
- t += ent->trail_leftover;
- ent->trail_leftover -= (cl.time - cl.oldtime);
+ vec3_t vec, dir, vel;
+ float len, dec = 0, speed;
+ int contents, bubbles, polytype;
+ double t;
+ if (!r_particles.value) return; // LordHavoc: particles are optional
+
+ VectorSubtract(end, start, dir);
+ VectorNormalize(dir);
+
+ if (type == 0 && host_frametime != 0) // rocket glow
+ particle(pt_oneframe, 0xFFFFFF, rocketglowparticletexture, TPOLYTYPE_ALPHA, false, 24, 255, 9999, 0, end[0] - 12 * dir[0], end[1] - 12 * dir[1], end[2] - 12 * dir[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
+
+ t = ent->persistent.trail_time;
if (t >= cl.time)
- return;
+ return; // no particles to spawn this frame (sparse trail)
- contents = Mod_PointInLeaf(start, cl.worldmodel)->contents;
- if (contents == CONTENTS_SKY || contents == CONTENTS_LAVA)
- return;
+ if (t < cl.oldtime)
+ t = cl.oldtime;
VectorSubtract (end, start, vec);
len = VectorNormalizeLength (vec);
if (len <= 0.01f)
+ {
+ // advance the trail time
+ ent->persistent.trail_time = cl.time;
return;
- speed = len / (nt - t);
+ }
+ speed = len / (cl.time - cl.oldtime);
+ VectorScale(vec, speed, vel);
- bubbles = (contents == CONTENTS_WATER || contents == CONTENTS_SLIME);
+ // advance into this frame to reach the first puff location
+ dec = t - cl.oldtime;
+ dec *= speed;
+ VectorMA(start, dec, vec, start);
- while (t < nt)
+ contents = Mod_PointInLeaf(start, cl.worldmodel)->contents;
+ if (contents == CONTENTS_SKY || contents == CONTENTS_LAVA)
{
- if (!free_particles)
- return;
- p = free_particles;
- free_particles = p->next;
- p->next = active_particles;
- active_particles = p;
-
- p->vel[0] = p->vel[1] = p->vel[2] = 0;
- p->die = cl.time + 2;
+ // advance the trail time
+ ent->persistent.trail_time = cl.time;
+ return;
+ }
+
+ bubbles = (contents == CONTENTS_WATER || contents == CONTENTS_SLIME);
+
+ polytype = TPOLYTYPE_ALPHA;
+ if (ent->render.effects & EF_ADDITIVE)
+ polytype = TPOLYTYPE_ADD;
+ while (t < cl.time)
+ {
switch (type)
{
case 0: // rocket trail
- case 1: // grenade trail
- if (bubbles)
+ if (!r_particles_smoke.value)
+ dec = cl.time - t;
+ else if (bubbles && r_particles_bubbles.value)
{
- dec = 0.01f;
- p->texnum = bubbleparticletexture;
- p->scale = 6+(rand()&3);
- p->alpha = 255;
-// if (r_smokecolor.value)
-// p->color = r_smokecolor.value;
-// else
- p->color = (rand()&3)+12;
- p->type = pt_bubble;
- p->die = cl.time + 2;
- for (j=0 ; j<3 ; j++)
- {
- p->vel[j] = (rand()&31)-16;
- p->org[j] = start[j] + ((rand()&3)-2);
- }
+ dec = 0.005f;
+ particle(pt_bubble, 0xFFFFFF, bubbleparticletexture, polytype, false, lhrandom(1, 2), 255, 9999, 1.5, start[0], start[1], start[2], lhrandom(-16, 16), lhrandom(-16, 16), lhrandom(-16, 16), 0, 0, 0, 0, 0, 0);
+ particle(pt_bubble, 0xFFFFFF, bubbleparticletexture, polytype, false, lhrandom(1, 2), 255, 9999, 1.5, start[0], start[1], start[2], lhrandom(-16, 16), lhrandom(-16, 16), lhrandom(-16, 16), 0, 0, 0, 0, 0, 0);
+ particle(pt_smoke, 0xFFFFFF, smokeparticletexture[rand()&7], polytype, false, 2, 160, 9999, 0, start[0], start[1], start[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
}
else
{
- dec = 0.03f;
- p->texnum = smokeparticletexture;
- p->scale = 12+(rand()&7);
- p->alpha = 64 + (rand()&31);
-// if (r_smokecolor.value)
-// p->color = r_smokecolor.value;
-// else
- p->color = (rand()&3)+12;
- p->type = pt_smoke;
- p->die = cl.time + 2;
- VectorCopy(start, p->org);
+ dec = 0.005f;
+ particle(pt_smoke, 0xC0C0C0, smokeparticletexture[rand()&7], polytype, true, 2, 160, 9999, 0, start[0], start[1], start[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
+ //particle(pt_spark, particlepalette[0x68 + (rand() & 7)], particletexture, TPOLYTYPE_ALPHA, false, 1, lhrandom(128, 255), 9999, 1.5, start[0], start[1], start[2], lhrandom(-64, 64) - vel[0] * 0.0625, lhrandom(-64, 64) - vel[1] * 0.0625, lhrandom(-64, 64) - vel[2] * 0.0625, 512.0f, 0, 0, 0, 0.1f, 0);
+ //particle(pt_spark, particlepalette[0x68 + (rand() & 7)], particletexture, TPOLYTYPE_ALPHA, false, 1, lhrandom(128, 255), 9999, 1.5, start[0], start[1], start[2], lhrandom(-64, 64) - vel[0] * 0.0625, lhrandom(-64, 64) - vel[1] * 0.0625, lhrandom(-64, 64) - vel[2] * 0.0625, 512.0f, 0, 0, 0, 0.1f, 0);
+ //particle(pt_spark, particlepalette[0x68 + (rand() & 7)], particletexture, TPOLYTYPE_ALPHA, false, 1, lhrandom(128, 255), 9999, 1.5, start[0], start[1], start[2], lhrandom(-64, 64) - vel[0] * 0.0625, lhrandom(-64, 64) - vel[1] * 0.0625, lhrandom(-64, 64) - vel[2] * 0.0625, 512.0f, 0, 0, 0, 0.1f, 0);
+ //particle(pt_spark, particlepalette[0x68 + (rand() & 7)], particletexture, TPOLYTYPE_ALPHA, false, 1, lhrandom(128, 255), 9999, 1.5, start[0], start[1], start[2], lhrandom(-64, 64) - vel[0] * 0.0625, lhrandom(-64, 64) - vel[1] * 0.0625, lhrandom(-64, 64) - vel[2] * 0.0625, 512.0f, 0, 0, 0, 0.1f, 0);
}
break;
- /*
- case 1: // smoke smoke
- dec = 0.016f;
- p->texnum = smokeparticletexture;
- p->scale = 12+rand()&7;
- p->alpha = 64;
- if (r_smokecolor.value)
- p->color = r_smokecolor.value;
+ case 1: // grenade trail
+ // FIXME: make it gradually stop smoking
+ if (!r_particles_smoke.value)
+ dec = cl.time - t;
+ else if (bubbles && r_particles_bubbles.value)
+ {
+ dec = 0.02f;
+ particle(pt_bubble, 0xFFFFFF, bubbleparticletexture, polytype, false, lhrandom(1, 2), 255, 9999, 1.5, start[0], start[1], start[2], lhrandom(-16, 16), lhrandom(-16, 16), lhrandom(-16, 16), 0, 0, 0, 0, 0, 0);
+ particle(pt_bubble, 0xFFFFFF, bubbleparticletexture, polytype, false, lhrandom(1, 2), 255, 9999, 1.5, start[0], start[1], start[2], lhrandom(-16, 16), lhrandom(-16, 16), lhrandom(-16, 16), 0, 0, 0, 0, 0, 0);
+ particle(pt_smoke, 0xFFFFFF, smokeparticletexture[rand()&7], polytype, false, 2, 160, 9999, 0, start[0], start[1], start[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
+ }
else
- p->color = (rand()&3)+12;
- p->type = pt_smoke;
- p->die = cl.time + 1;
- VectorCopy(start, p->org);
- break;
- */
-
- case 2: // blood
- dec = 0.03f;
- p->texnum = bloodcloudparticletexture;
- p->scale = 20+(rand()&7);
- p->alpha = 255;
- p->color = (rand()&3)+68;
- p->type = pt_bloodcloud;
- p->die = cl.time + 2;
- for (j=0 ; j<3 ; j++)
{
- p->vel[j] = (rand()&15)-8;
- p->org[j] = start[j] + ((rand()&3)-2);
+ dec = 0.02f;
+ particle(pt_smoke, 0x808080, smokeparticletexture[rand()&7], polytype, true, 2, 160, 9999, 0, start[0], start[1], start[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
}
break;
- case 3:
- case 5: // tracer
- dec = 0.01f;
- p->texnum = flareparticletexture;
- p->scale = 4;
- p->alpha = 255;
- p->die = cl.time + 0.2; //5;
- p->type = pt_static;
- if (type == 3)
- p->color = 52 + ((tracercount&4)<<1);
- else
- p->color = 230 + ((tracercount&4)<<1);
-
- tracercount++;
- VectorCopy (start, p->org);
- if (tracercount & 1)
- {
- p->vel[0] = 30*vec[1];
- p->vel[1] = 30*-vec[0];
- }
+ case 2: // blood
+ if (!r_particles_blood.value)
+ dec = cl.time - t;
else
{
- p->vel[0] = 30*-vec[1];
- p->vel[1] = 30*vec[0];
+ dec = 0.1f;
+ particle(pt_blood, 0x300000, smokeparticletexture[rand()&7], polytype, true, 24, 255, 9999, -1, start[0], start[1], start[2], vel[0] + lhrandom(-64, 64), vel[1] + lhrandom(-64, 64), vel[2] + lhrandom(-64, 64), 0, 0, 0, 0, 1.0f, 0);
}
break;
case 4: // slight blood
- dec = 0.03f; // sparse trail
- p->texnum = bloodcloudparticletexture;
- p->scale = 20+(rand()&7);
- p->alpha = 255;
- p->color = (rand()&3)+68;
- p->type = pt_fadespark2;
- p->die = cl.time + 2;
- for (j=0 ; j<3 ; j++)
+ if (!r_particles_blood.value)
+ dec = cl.time - t;
+ else
{
- p->vel[j] = (rand()&15)-8;
- p->org[j] = start[j] + ((rand()&3)-2);
+ dec = 0.15f;
+ particle(pt_blood, 0x300000, smokeparticletexture[rand()&7], polytype, true, 24, 255, 9999, -1, start[0], start[1], start[2], vel[0] + lhrandom(-64, 64), vel[1] + lhrandom(-64, 64), vel[2] + lhrandom(-64, 64), 0, 0, 0, 0, 1.0f, 0);
}
break;
+ case 3: // green tracer
+ dec = 0.02f;
+ particle(pt_fade, 0x373707, smokeparticletexture[rand()&7], polytype, false, 4, 255, 9999, 0, start[0], start[1], start[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
+ break;
+
+ case 5: // flame tracer
+ dec = 0.02f;
+ particle(pt_fade, 0xCF632B, smokeparticletexture[rand()&7], polytype, false, 4, 255, 9999, 0, start[0], start[1], start[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
+ break;
+
case 6: // voor trail
dec = 0.05f; // sparse trail
- p->texnum = flareparticletexture;
- p->scale = 20+(rand()&7);
- p->alpha = 255;
- p->color = 9*16 + 8 + (rand()&3);
- p->type = pt_fadespark2;
- p->die = cl.time + 2;
- for (j=0 ; j<3 ; j++)
- {
- p->vel[j] = (rand()&15)-8;
- p->org[j] = start[j] + ((rand()&3)-2);
- }
+ particle(pt_fade, 0x47232B, smokeparticletexture[rand()&7], polytype, false, 4, 255, 9999, 0, start[0], start[1], start[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
break;
case 7: // Nehahra smoke tracer
- dec = 0.14f;
- p->texnum = smokeparticletexture;
- p->scale = 12+(rand()&7);
- p->alpha = 64;
- p->color = (rand()&3)+12;
- p->type = pt_smoke;
- p->die = cl.time + 1;
- for (j=0 ; j<3 ; j++)
- p->org[j] = start[j] + ((rand()&3)-2);
+ if (!r_particles_smoke.value)
+ dec = cl.time - t;
+ else
+ {
+ dec = 0.14f;
+ particle(pt_smoke, 0xC0C0C0, smokeparticletexture[rand()&7], polytype, true, 10, 64, 9999, 0, start[0], start[1], start[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
+ }
break;
}
-
+
+ // advance to next time and position
t += dec;
dec *= speed;
VectorMA (start, dec, vec, start);
}
- ent->trail_leftover = t - cl.time;
+ ent->persistent.trail_time = t;
}
void R_RocketTrail2 (vec3_t start, vec3_t end, int color, entity_t *ent)
{
vec3_t vec;
- float len;
- particle_t *p;
- static int tracercount;
-// if (!r_particles.value) return; // LordHavoc: particles are optional
+ int len;
+ if (!r_particles.value) return; // LordHavoc: particles are optional
+ if (!r_particles_smoke.value) return;
VectorSubtract (end, start, vec);
- len = VectorNormalizeLength (vec);
- while (len > 0)
+ len = (int) (VectorNormalizeLength (vec) * (1.0f / 3.0f));
+ VectorScale(vec, 3, vec);
+ color = particlepalette[color];
+ while (len--)
{
- len -= 3;
-
- if (!free_particles)
- return;
- p = free_particles;
- free_particles = p->next;
- p->next = active_particles;
- active_particles = p;
-
- VectorCopy (vec3_origin, p->vel);
-
- p->texnum = flareparticletexture;
- p->scale = 16;
- p->alpha = 192;
- p->color = color;
- p->type = pt_smoke;
- p->die = cl.time + 1;
- VectorCopy(start, p->org);
-// for (j=0 ; j<3 ; j++)
-// p->org[j] = start[j] + ((rand()&15)-8);
-
+ particle(pt_smoke, color, particletexture, TPOLYTYPE_ALPHA, false, 8, 192, 9999, 0, start[0], start[1], start[2], 0, 0, 0, 0, 0, 0, 0, 0, 0);
VectorAdd (start, vec, start);
}
}
-//extern qboolean isG200, isATI, isRagePro;
-extern qboolean lighthalf;
-
/*
===============
R_DrawParticles
===============
*/
-extern cvar_t sv_gravity;
-
-void R_DrawParticles (void)
+void R_MoveParticles (void)
{
- particle_t *p, *kill;
- int i, /*texnum, */r,g,b,a;
- float grav, grav1, time1, time2, time3, dvel, frametime, scale, scale2;
- byte *color24;
- vec3_t up, right, uprightangles, forward2, up2, right2, v;
+ particle_t *p;
+ int i, activeparticles, maxparticle, j, a, b, pressureused = false;
+ vec3_t v, org, o, normal;
+ float gravity, dvel, frametime, f;
// LordHavoc: early out condition
- if (!active_particles)
+ if (!numparticles)
return;
- /*
- texnum = particletexture;
- glBindTexture(GL_TEXTURE_2D, texnum);
- glEnable (GL_BLEND);
- // LordHavoc: Matrox G200 cards can't handle per pixel alpha at all...
- // and ATI Rage Pro can't modulate a per pixel alpha texture
- if (isG200 || isRagePro)
- glEnable(GL_ALPHA_TEST);
- else
- glDisable(GL_ALPHA_TEST);
- glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
- glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
- glDepthMask(0); // disable zbuffer updates
- glShadeModel(GL_FLAT);
- glBegin (GL_TRIANGLES);
- */
-
- VectorScale (vup, 1.5, up);
- VectorScale (vright, 1.5, right);
-
- uprightangles[0] = 0;
- uprightangles[1] = r_refdef.viewangles[1];
- uprightangles[2] = 0;
- AngleVectors (uprightangles, forward2, right2, up2);
-
frametime = cl.time - cl.oldtime;
- time3 = frametime * 15;
- time2 = frametime * 10; // 15;
- time1 = frametime * 5;
- grav = (grav1 = frametime * sv_gravity.value) * 0.05;
+ if (!frametime)
+ return; // if absolutely still, don't update particles
+ gravity = frametime * sv_gravity.value;
dvel = 1+4*frametime;
- for ( ;; )
+ activeparticles = 0;
+ maxparticle = -1;
+ j = 0;
+ for (i = 0, p = particles;i < numparticles;i++, p++)
{
- kill = active_particles;
- if (kill && kill->die < cl.time)
+ if (p->die < cl.time)
{
- active_particles = kill->next;
- kill->next = free_particles;
- free_particles = kill;
+ freeparticles[j++] = p;
continue;
}
- break;
- }
- for (p=active_particles ; p ; p=p->next)
- {
- for ( ;; )
+ VectorCopy(p->org, p->oldorg);
+ VectorMA(p->org, frametime, p->vel, p->org);
+ if (p->friction)
{
- kill = p->next;
- if (kill && kill->die < cl.time)
- {
- p->next = kill->next;
- kill->next = free_particles;
- free_particles = kill;
- continue;
- }
- break;
+ f = 1.0f - (p->friction * frametime);
+ VectorScale(p->vel, f, p->vel);
}
- // LordHavoc: 'removed last in list' condition
- if (!p)
- break;
-
- VectorSubtract(p->org, r_refdef.vieworg, v);
- if (DotProduct(v, v) >= 256.0f)
+ VectorCopy(p->org, org);
+ if (p->bounce)
{
- scale = p->scale * -0.25;scale2 = p->scale * 0.75;
- /*
- if (p->texnum != texnum)
- {
- texnum = p->texnum;
- glEnd();
- glBindTexture(GL_TEXTURE_2D, texnum);
- glBegin(GL_TRIANGLES);
- }
- if (lighthalf)
- {
- color24 = (byte *)&d_8to24table[(int)p->color];
- if (p->texnum == smokeparticletexture)
- glColor4ub((byte) (color24[0] >> 1), (byte) (color24[1] >> 1), (byte) (color24[2] >> 1), (byte) (p->alpha*r_smokealpha.value));
- else
- glColor4ub((byte) (color24[0] >> 1), (byte) (color24[1] >> 1), (byte) (color24[2] >> 1), (byte) p->alpha);
- }
- else
+ vec3_t normal;
+ float dist;
+ if (TraceLine(p->oldorg, p->org, v, normal, 0) < 1)
{
- color24 = (byte *) &d_8to24table[(int)p->color];
- if (p->texnum == smokeparticletexture)
- glColor4ub(color24[0], color24[1], color24[2], (byte) (p->alpha*r_smokealpha.value));
+ VectorCopy(v, p->org);
+ if (p->bounce < 0)
+ {
+ R_Decal(v, particlefonttexture, p->tex->s1, p->tex->t1, p->tex->s2, p->tex->t2, p->scale, p->color[0], p->color[1], p->color[2], p->alpha);
+ p->die = -1;
+ freeparticles[j++] = p;
+ continue;
+ }
else
- glColor4ub(color24[0], color24[1], color24[2], (byte) p->alpha);
- }
- if (p->texnum == rainparticletexture) // rain streak
- {
- glTexCoord2f (0,0);
- glVertex3f (p->org[0] + right2[0]*scale , p->org[1] + right2[1]*scale , p->org[2] + right2[2]*scale );
- glTexCoord2f (1,0);
- glVertex3f (p->org[0] + right2[0]*scale , p->org[1] + right2[1]*scale , p->org[2] + right2[2]*scale );
- glTexCoord2f (0,1);
- glVertex3f (p->org[0] + right2[0]*scale2, p->org[1] + right2[1]*scale2, p->org[2] + right2[2]*scale2);
- }
- else
- {
- glTexCoord2f (0,0);
- // LordHavoc: centered particle sprites
- glVertex3f (p->org[0] + up[0]*scale + right[0]*scale , p->org[1] + up[1]*scale + right[1]*scale , p->org[2] + up[2]*scale + right[2]*scale );
- glTexCoord2f (1,0);
- glVertex3f (p->org[0] + up[0]*scale2 + right[0]*scale , p->org[1] + up[1]*scale2 + right[1]*scale , p->org[2] + up[2]*scale2 + right[2]*scale );
- glTexCoord2f (0,1);
- glVertex3f (p->org[0] + up[0]*scale + right[0]*scale2, p->org[1] + up[1]*scale + right[1]*scale2, p->org[2] + up[2]*scale + right[2]*scale2);
- }
- */
- color24 = (byte *) &d_8to24table[(int)p->color];
- r = color24[0];
- g = color24[1];
- b = color24[2];
- a = p->alpha;
- if (lighthalf)
- {
- r >>= 1;
- g >>= 1;
- b >>= 1;
- }
- transpolybegin(p->texnum, 0, p->texnum, TPOLYTYPE_ALPHA);
- if (p->texnum == rainparticletexture) // rain streak
- {
- transpolyvert(p->org[0] + right2[0]*scale , p->org[1] + right2[1]*scale , p->org[2] + right2[2]*scale , 0,0,r,g,b,a);
- transpolyvert(p->org[0] + right2[0]*scale , p->org[1] + right2[1]*scale , p->org[2] + right2[2]*scale , 1,0,r,g,b,a);
- transpolyvert(p->org[0] + right2[0]*scale2, p->org[1] + right2[1]*scale2, p->org[2] + right2[2]*scale2, 0,1,r,g,b,a);
- }
- else
- {
- transpolyvert(p->org[0] + up[0]*scale + right[0]*scale , p->org[1] + up[1]*scale + right[1]*scale , p->org[2] + up[2]*scale + right[2]*scale , 0,0,r,g,b,a);
- transpolyvert(p->org[0] + up[0]*scale2 + right[0]*scale , p->org[1] + up[1]*scale2 + right[1]*scale , p->org[2] + up[2]*scale2 + right[2]*scale , 1,0,r,g,b,a);
- transpolyvert(p->org[0] + up[0]*scale + right[0]*scale2, p->org[1] + up[1]*scale + right[1]*scale2, p->org[2] + up[2]*scale + right[2]*scale2, 0,1,r,g,b,a);
+ {
+ 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);
+ }
}
- transpolyend();
}
- p->org[0] += p->vel[0]*frametime;
- p->org[1] += p->vel[1]*frametime;
- p->org[2] += p->vel[2]*frametime;
-
switch (p->type)
{
case pt_static:
break;
- case pt_fire:
- p->ramp += time1;
- if (p->ramp >= 6)
- p->die = -1;
- else
- p->color = ramp3[(int)p->ramp];
- p->vel[2] += grav;
- break;
-
- case pt_explode:
- p->ramp += time2;
- if (p->ramp >=8)
- p->die = -1;
- else
- p->color = ramp1[(int)p->ramp];
-// p->vel[2] -= grav1; // LordHavoc: apply full gravity to explosion sparks
- for (i=0 ; i<3 ; i++)
- p->vel[i] *= dvel;
-// p->vel[2] -= grav;
- break;
-
- case pt_explode2:
- p->ramp += time3;
- if (p->ramp >=8)
- p->die = -1;
- else
- p->color = ramp2[(int)p->ramp];
-// p->vel[2] -= grav1; // LordHavoc: apply full gravity to explosion sparks
- for (i=0 ; i<3 ; i++)
- p->vel[i] -= p->vel[i]*frametime;
-// p->vel[2] -= grav;
- break;
+ // LordHavoc: drop-through because of shared code
case pt_blob:
- for (i=0 ; i<3 ; i++)
- p->vel[i] += p->vel[i]*dvel;
- p->vel[2] -= grav;
- break;
-
+ p->vel[2] *= dvel;
case pt_blob2:
- for (i=0 ; i<2 ; i++)
- p->vel[i] -= p->vel[i]*dvel;
- p->vel[2] -= grav;
+ p->vel[0] *= dvel;
+ p->vel[1] *= dvel;
+ p->alpha -= frametime * 256;
+ if (p->alpha < 1)
+ p->die = -1;
break;
case pt_grav:
- p->vel[2] -= grav1;
- break;
- case pt_slowgrav:
- p->vel[2] -= grav;
+ p->vel[2] -= gravity;
break;
-// LordHavoc: gunshot spark showers
- case pt_dust:
- p->ramp += time1;
- p->scale -= frametime * 4;
- if (p->ramp >= 8 || p->scale <= 0)
- p->die = -1;
- else
- p->color = ramp3[(int)p->ramp];
- p->vel[2] -= grav1;
- break;
-// LordHavoc: for smoke trails
- case pt_smoke:
- p->scale += frametime * 16;
- p->alpha -= frametime * 64;
- p->vel[2] += grav;
+ case pt_lavasplash:
+ p->vel[2] -= gravity * 0.05;
+ p->alpha -= frametime * 192;
if (p->alpha < 1)
p->die = -1;
break;
case pt_snow:
if (cl.time > p->time2)
{
- p->time2 = cl.time + 0.4;
- p->vel[0] = (rand()&63)-32;
- p->vel[1] = (rand()&63)-32;
+ p->time2 = cl.time + (rand() & 3) * 0.1;
+ p->vel[0] = (rand()&63)-32 + p->vel2[0];
+ p->vel[1] = (rand()&63)-32 + p->vel2[1];
+ p->vel[2] = (rand()&63)-32 + p->vel2[2];
+ }
+ a = Mod_PointInLeaf(p->org, cl.worldmodel)->contents;
+ if (a != CONTENTS_EMPTY && a != CONTENTS_SKY)
+ {
+ vec3_t normal;
+ if (a == CONTENTS_SOLID && Mod_PointInLeaf(p->oldorg, cl.worldmodel)->contents == CONTENTS_SOLID)
+ break; // still in solid
+ p->die = cl.time + 1000;
+ p->vel[0] = p->vel[1] = p->vel[2] = 0;
+ switch (a)
+ {
+ case CONTENTS_LAVA:
+ case CONTENTS_SLIME:
+ p->tex = &smokeparticletexture[rand()&7];
+ p->type = pt_steam;
+ p->alpha = 96;
+ p->scale = 5;
+ p->vel[2] = 96;
+ break;
+ case CONTENTS_WATER:
+ p->tex = &smokeparticletexture[rand()&7];
+ p->type = pt_splash;
+ p->alpha = 96;
+ p->scale = 5;
+ p->vel[2] = 96;
+ break;
+ default: // CONTENTS_SOLID and any others
+ TraceLine(p->oldorg, p->org, v, normal, 0);
+ VectorCopy(v, p->org);
+ p->tex = &smokeparticletexture[rand()&7];
+ p->type = pt_fade;
+ VectorClear(p->vel);
+ break;
+ }
}
break;
- case pt_bulletpuff:
- p->scale -= frametime * 64;
- p->alpha -= frametime * 1024;
- p->vel[2] -= grav;
- if (p->alpha < 1 || p->scale < 1)
+ case pt_blood:
+ p->friction = 1;
+ a = Mod_PointInLeaf(p->org, cl.worldmodel)->contents;
+ if (a != CONTENTS_EMPTY)
+ {
+ if (a == CONTENTS_WATER || a == CONTENTS_SLIME)
+ {
+ p->friction = 5;
+ p->scale += frametime * 32.0f;
+ p->alpha -= frametime * 128.0f;
+ p->vel[2] += gravity * 0.125f;
+ if (p->alpha < 1)
+ p->die = -1;
+ break;
+ }
+ else
+ {
+ p->die = -1;
+ break;
+ }
+ }
+ p->vel[2] -= gravity * 0.5;
+ break;
+ case pt_spark:
+ p->alpha -= frametime * p->time2;
+ p->vel[2] -= gravity;
+ if (p->alpha < 1)
p->die = -1;
+ else if (Mod_PointInLeaf(p->org, cl.worldmodel)->contents != CONTENTS_EMPTY)
+ p->type = pt_underwaterspark;
break;
- case pt_bloodcloud:
- p->scale -= frametime * 24;
- p->alpha -= frametime * 128;
- p->vel[2] -= grav;
- if (p->alpha < 1 || p->scale < 1)
+ case pt_underwaterspark:
+ if (Mod_PointInLeaf(p->org, cl.worldmodel)->contents == CONTENTS_EMPTY)
+ {
+ p->tex = &smokeparticletexture[rand()&7];
+ p->color[0] = p->color[1] = p->color[2] = 255;
+ p->scale = 16;
+ p->type = pt_explosionsplash;
+ }
+ else
+ p->vel[2] += gravity * 0.5f;
+ p->alpha -= frametime * p->time2;
+ if (p->alpha < 1)
p->die = -1;
break;
- case pt_fadespark:
- p->alpha -= frametime * 256;
- p->vel[2] -= grav;
+ case pt_explosionsplash:
+ if (Mod_PointInLeaf(p->org, cl.worldmodel)->contents == CONTENTS_EMPTY)
+ p->vel[2] -= gravity;
+ else
+ p->alpha = 0;
+ p->scale += frametime * 64.0f;
+ p->alpha -= frametime * 1024.0f;
if (p->alpha < 1)
p->die = -1;
break;
- case pt_fadespark2:
+ case pt_fade:
p->alpha -= frametime * 512;
- p->vel[2] -= grav;
if (p->alpha < 1)
p->die = -1;
break;
- case pt_fallfadespark:
+ case pt_bubble:
+ a = Mod_PointInLeaf(p->org, cl.worldmodel)->contents;
+ if (a != CONTENTS_WATER && a != CONTENTS_SLIME)
+ {
+ p->tex = &smokeparticletexture[rand()&7];
+ p->type = pt_splashpuff;
+ p->scale = 4;
+ p->vel[0] = p->vel[1] = p->vel[2] = 0;
+ break;
+ }
+ p->vel[2] += gravity * 0.25;
+ p->vel[0] *= (1 - (frametime * 0.0625));
+ p->vel[1] *= (1 - (frametime * 0.0625));
+ p->vel[2] *= (1 - (frametime * 0.0625));
+ if (cl.time > p->time2)
+ {
+ p->time2 = cl.time + lhrandom(0, 0.5);
+ p->vel[0] += lhrandom(-32,32);
+ p->vel[1] += lhrandom(-32,32);
+ p->vel[2] += lhrandom(-32,32);
+ }
+ p->alpha -= frametime * 256;
+ if (p->alpha < 1)
+ p->die = -1;
+ break;
+ case pt_bulletsmoke:
+ p->scale += frametime * 16;
+ p->alpha -= frametime * 1024;
+ p->vel[2] += gravity * 0.1;
+ if (p->alpha < 1)
+ p->die = -1;
+ break;
+ case pt_smoke:
+ p->scale += frametime * 24;
p->alpha -= frametime * 256;
- p->vel[2] -= grav1;
+ p->vel[2] += gravity * 0.1;
if (p->alpha < 1)
p->die = -1;
break;
- case pt_fallfadespark2:
+ case pt_steam:
+ p->scale += frametime * 48;
p->alpha -= frametime * 512;
- p->vel[2] -= grav1;
+ p->vel[2] += gravity * 0.05;
if (p->alpha < 1)
p->die = -1;
break;
- case pt_bubble:
- p->vel[2] += grav1;
- if (p->vel[2] >= 100)
- p->vel[2] = 68+rand()&31;
- if (cl.time > p->time2)
+ case pt_splashpuff:
+ p->alpha -= frametime * 1024;
+ if (p->alpha < 1)
+ p->die = -1;
+ break;
+ case pt_rain:
+ f = 0;
+ b = Mod_PointInLeaf(p->oldorg, cl.worldmodel)->contents;
+ VectorCopy(p->oldorg, o);
+ while (f < 1)
{
- p->time2 = cl.time + (rand()&7)*0.0625;
- p->vel[0] = (rand()&63)-32;
- p->vel[1] = (rand()&63)-32;
+ a = b;
+ f = TraceLine(o, p->org, v, normal, a);
+ b = traceline_endcontents;
+ if (f < 1 && b != CONTENTS_EMPTY && b != CONTENTS_SKY)
+ {
+ p->die = cl.time + 1000;
+ p->vel[0] = p->vel[1] = p->vel[2] = 0;
+ VectorCopy(v, p->org);
+ switch (b)
+ {
+ case CONTENTS_LAVA:
+ case CONTENTS_SLIME:
+ p->tex = &smokeparticletexture[rand()&7];
+ p->type = pt_steam;
+ p->scale = 3;
+ p->vel[2] = 96;
+ break;
+ default: // water, solid, and anything else
+ p->tex = &raindropsplashparticletexture[0];
+ p->time2 = 0;
+ VectorCopy(normal, p->vel2);
+ // VectorAdd(p->org, normal, p->org);
+ p->type = pt_raindropsplash;
+ p->scale = 8;
+ break;
+ }
+ }
}
- p->alpha -= frametime * 32;
- if (p->alpha < 1)
+ break;
+ case pt_raindropsplash:
+ p->time2 += frametime * 64.0f;
+ if (p->time2 >= 16.0f)
+ {
p->die = -1;
+ break;
+ }
+ p->tex = &raindropsplashparticletexture[(int) p->time2];
+ break;
+ case pt_flame:
+ p->alpha -= frametime * 512;
+ p->vel[2] += gravity;
+ if (p->alpha < 16)
+ p->die = -1;
+ break;
+ case pt_oneframe:
+ if (p->time2)
+ p->die = -1;
+ p->time2 = 1;
+ break;
+ default:
+ printf("unknown particle type %i\n", p->type);
+ p->die = -1;
break;
}
+
+ // LordHavoc: immediate removal of unnecessary particles (must be done to ensure compactor below operates properly in all cases)
+ if (p->die < cl.time)
+ 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--;
}
+ numparticles = activeparticles;
- /*
- glEnd ();
- glShadeModel(GL_SMOOTH);
- glDepthMask(1); // enable zbuffer updates
- glDisable (GL_BLEND);
- */
+ if (pressureused)
+ {
+ activeparticles = 0;
+ for (i = 0, p = particles;i < numparticles;i++, p++)
+ if (p->pressure)
+ freeparticles[activeparticles++] = p;
+
+ if (activeparticles)
+ {
+ for (i = 0, p = particles;i < numparticles;i++, p++)
+ {
+ for (j = 0;j < activeparticles;j++)
+ {
+ if (freeparticles[j] != p)
+ {
+ float dist, diff[3];
+ VectorSubtract(p->org, freeparticles[j]->org, diff);
+ dist = DotProduct(diff, diff);
+ if (dist < 4096 && dist >= 1)
+ {
+ dist = freeparticles[j]->scale * 4.0f * frametime / sqrt(dist);
+ VectorMA(p->vel, dist, diff, p->vel);
+ //dist = freeparticles[j]->scale * 4.0f * frametime / dist;
+ //VectorMA(p->vel, dist, freeparticles[j]->vel, p->vel);
+ }
+ }
+ }
+ }
+ }
+ }
}
+void R_DrawParticles (void)
+{
+ particle_t *p;
+ int i, dynamiclight, staticlight, r, g, b, texnum;
+ float minparticledist;
+ vec3_t uprightangles, up2, right2, v, right, up;
+ mleaf_t *leaf;
+
+ // LordHavoc: early out condition
+ if ((!numparticles) || (!r_drawparticles.value))
+ return;
+
+ staticlight = dynamiclight = r_particles_lighting.value;
+ if (!r_dynamic.value)
+ dynamiclight = 0;
+ c_particles += numparticles;
+
+ uprightangles[0] = 0;
+ uprightangles[1] = r_refdef.viewangles[1];
+ uprightangles[2] = 0;
+ AngleVectors (uprightangles, NULL, right2, up2);
+
+ minparticledist = DotProduct(r_origin, vpn) + 16.0f;
+
+ texnum = R_GetTexture(particlefonttexture);
+ for (i = 0, p = particles;i < numparticles;i++, p++)
+ {
+ if (p->tex == NULL || p->alpha < 1 || p->scale < 0.1f)
+ continue;
+
+ // LordHavoc: only render if not too close
+ if (DotProduct(p->org, vpn) < minparticledist)
+ continue;
+
+ // LordHavoc: check if it's in a visible leaf
+ leaf = Mod_PointInLeaf(p->org, cl.worldmodel);
+ if (leaf->visframe != r_framecount)
+ continue;
+
+ r = p->color[0];
+ g = p->color[1];
+ b = p->color[2];
+ if (staticlight && (p->dynlight || staticlight >= 2)) // LordHavoc: only light blood and smoke
+ {
+ R_CompleteLightPoint(v, p->org, dynamiclight, leaf);
+#if SLOWMATH
+ r = (r * (int) v[0]) >> 7;
+ g = (g * (int) v[1]) >> 7;
+ b = (b * (int) v[2]) >> 7;
+#else
+ v[0] += 8388608.0f;
+ v[1] += 8388608.0f;
+ v[2] += 8388608.0f;
+ r = (r * (*((long *) &v[0]) & 0x7FFFFF)) >> 7;
+ g = (g * (*((long *) &v[1]) & 0x7FFFFF)) >> 7;
+ b = (b * (*((long *) &v[2]) & 0x7FFFFF)) >> 7;
+#endif
+ }
+ if (p->type == pt_raindropsplash)
+ {
+ // treat as double-sided
+ if (DotProduct(p->vel2, r_origin) > DotProduct(p->vel2, p->org))
+ {
+ VectorNegate(p->vel2, v);
+ VectorVectors(v, right, up);
+ }
+ else
+ VectorVectors(p->vel2, right, up);
+ transpolyparticle(p->org, right, up, p->scale, texnum, p->rendermode, r, g, b, p->alpha, p->tex->s1, p->tex->t1, p->tex->s2, p->tex->t2);
+ }
+ else if (p->tex == &rainparticletexture) // rain streak
+ transpolyparticle(p->org, right2, up2, p->scale, texnum, p->rendermode, r, g, b, p->alpha, p->tex->s1, p->tex->t1, p->tex->s2, p->tex->t2);
+ else
+ transpolyparticle(p->org, vright, vup, p->scale, texnum, p->rendermode, r, g, b, p->alpha, p->tex->s1, p->tex->t1, p->tex->s2, p->tex->t2);
+ }
+}