/*

Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or

modify it under the terms of the GNU General Public License

as published by the Free Software Foundation; either version 2

of the License, or (at your option) any later version.

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.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program; if not, write to the Free Software

Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

*/

// r_part.c

#include "quakedef.h"

#define DEFAULT_NUM_PARTICLES 1024 // 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 ABSOLUTE_MAX_PARTICLES 8192

static int ramp1[8] = {0x6f, 0x6d, 0x6b, 0x69, 0x67, 0x65, 0x63, 0x61};

static int ramp2[8] = {0x6f, 0x6e, 0x6d, 0x6c, 0x6b, 0x6a, 0x68, 0x66};

static int ramp3[8] = {0x6d, 0x6b, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01};

particle_t *active_particles, *free_particles;

particle_t *particles;

int r_numparticles;

vec3_t r_pright, r_pup, r_ppn;

/*

===============

R_InitParticles

===============

*/

void R_InitParticles (void)

{

int i;

if ((i = COM_CheckParm ("-particles")) && i+1 < com_argc)

{

r_numparticles = (int)(atoi(com_argv[i+1]));

r_numparticles = bound(ABSOLUTE_MIN_PARTICLES, r_numparticles, ABSOLUTE_MAX_PARTICLES);

}

else

{

r_numparticles = DEFAULT_NUM_PARTICLES;

}

particles = (particle_t *)Hunk_AllocName (r_numparticles * sizeof(particle_t), "particles");

}

/*

===============

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 i, count;

particle_t *p;

float angle, dist, sp, sy, cp, cy, sr, cr;

vec3_t forward;

dist = 64;

count = 25; //50;

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][0];

sy = sinf(angle);

cy = cosf(angle);

angle = cl.time * avelocities[i][1];

sp = sinf(angle);

cp = cosf(angle);

angle = cl.time * avelocities[i][2];

sr = sinf(angle);

cr = cosf(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->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;

}

}

/*

===============

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)

{

int f;

vec3_t org;

int r, c;

particle_t *p;

char name[MAX_OSPATH];

snprintf(name, sizeof(name), "maps/%s.pts", sv.name);

COM_FOpenFile (name, &f);

if (f < 0)

{

Con_Printf ("couldn't open %s\n", name);

return;

}

Con_Printf ("Reading %s...\n", name);

c = 0;

for ( ;; )

{

// Read the line into a string.

char line[128];

int chars = 0;

do

{

if (chars >= (sizeof(line) - 2))

{

Sys_Error("Line buffer overflow when reading point file");

}

if (!Sys_FileRead(f, &line[chars++], 1) != 1)

{

break;

}

}

while (line[chars - 1] != '\n');

line[chars] = '\0';

r = sscanf (line, "%f %f %f\n", &org[0], &org[1], &org[2]);

if (r != 3)

break;

c++;

if (!free_particles)

{

Con_Printf ("Not enough free particles\n");

break;

}

p = free_particles;

free_particles = p->next;

p->next = active_particles;

active_particles = p;

p->die = 99999;

p->color = (-c)&15;

p->type = pt_static;

VectorCopy (vec3_origin, p->vel);

VectorCopy (org, p->org);

}

Sys_FileClose(f);

Con_Printf ("%i points read\n", c);

}

/*

===============

R_ParseParticleEffect

Parse an effect out of the server message

===============

*/

void R_ParseParticleEffect (void)

{

int i, count, color;

int msgcount;

vec3_t org, dir;

for (i=0 ; i<3 ; i++)

org[i] = MSG_ReadCoord ();

for (i=0 ; i<3 ; i++)

dir[i] = MSG_ReadChar () * (1.0/16);

msgcount = MSG_ReadByte ();

color = MSG_ReadByte ();

if (msgcount == 255) {

count = 1024;

} else {

count = msgcount;

}

R_RunParticleEffect (org, dir, color, count);

}

/*

===============

R_ParticleExplosion

===============

*/

void R_ParticleExplosion (vec3_t org)

{

int i, j;

particle_t *p;

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->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;

}

}

}

}

/*

===============

R_ParticleExplosion2

===============

*/

void R_ParticleExplosion2 (vec3_t org, int colorStart, int colorLength)

{

int i, j;

particle_t *p;

int colorMod = 0;

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->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;

}

}

}

/*

===============

R_BlobExplosion

===============

*/

void R_BlobExplosion (vec3_t org)

{

int i, j;

particle_t *p;

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->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;

}

}

}

}

/*

===============

R_RunParticleEffect

===============

*/

void R_RunParticleEffect (vec3_t org, vec3_t dir, int color, int count)

{

int i, j;

particle_t *p;

for (i=0 ; i<count ; i++)

{

if (!free_particles)

return;

p = free_particles;

free_particles = p->next;

p->next = active_particles;

active_particles = p;

if (count == 1024) {

// rocket explosion

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->die = cl.time + 0.1*(rand()%5);

p->color = (color&~7) + (rand()&7);

p->type = pt_slowgrav;

for (j=0 ; j<3 ; j++)

{

p->org[j] = org[j] + ((rand()&15)-8);

p->vel[j] = dir[j]*15;

}

}

}

}

/*

===============

R_LavaSplash

===============

*/

void R_LavaSplash (vec3_t org)

{

int i, j, k;

particle_t *p;

float vel;

vec3_t dir;

for (i=-16 ; i<16 ; i++)

{

for (j=-16 ; j<16 ; j++)

{

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->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);

}

}

}

}

/*

===============

R_TeleportSplash

===============

*/

void R_TeleportSplash (vec3_t org)

{

int i, j, k;

particle_t *p;

float vel;

vec3_t dir;

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->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);

}

}

}

}

/*

===============

R_RocketTrail

===============

*/

void R_RocketTrail (vec3_t start, vec3_t end, int type)

{

vec3_t vec;

float len;

int j, dec;

particle_t *p;

static int tracercount;

VectorSubtract (end, start, vec);

len = VectorNormalize (vec);

if (type < 128) {

dec = 3;

} else {

dec = 1;

type -= 128;

}

while (len > 0)

{

len -= dec;

if (!free_particles)

return;

p = free_particles;

free_particles = p->next;

p->next = active_particles;

active_particles = p;

VectorCopy (vec3_origin, p->vel);

p->die = cl.time + 2;

switch (type)

{

case GRENADE_TRAIL: // 1 = smoke smoke

p->ramp = (rand()&3) + 2;

p->color = ramp3[(int)p->ramp];

p->type = pt_fire;

for (j=0 ; j<3 ; j++)

p->org[j] = start[j] + ((rand()%6)-3);

break;

case BLOOD_TRAIL: // 2 = blood

p->type = pt_grav;

p->color = 67 + (rand()&3);

for (j=0 ; j<3 ; j++)

p->org[j] = start[j] + ((rand()%6)-3);

break;

case SLIGHT_BLOOD_TRAIL: // 4 = slight blood

p->type = pt_grav;

p->color = 67 + (rand()&3);

for (j=0 ; j<3 ; j++)

p->org[j] = start[j] + ((rand()%6)-3);

len -= 3;

break;

case TRACER1_TRAIL: // 3

case TRACER2_TRAIL: // 5

p->die = cl.time + 0.5;

p->type = pt_static;

p->color = (type == TRACER1_TRAIL) ? 52 + ((tracercount & 4) << 1) : 230 + ((tracercount&4)<<1);

tracercount++;

VectorCopy (start, p->org);

if (tracercount & 1)

{

p->vel[0] = 30*vec[1];

p->vel[1] = 30*-vec[0];

}

else

{

p->vel[0] = 30*-vec[1];

p->vel[1] = 30*vec[0];

}

break;

case VOOR_TRAIL: // 6 voor trail

p->color = 9*16 + 8 + (rand()&3);

p->type = pt_static;

p->die = cl.time + 0.3;

for (j=0 ; j<3 ; j++)

p->org[j] = start[j] + ((rand()&15)-8);

break;

case ROCKET_TRAIL: // 0 = rocket trail

p->ramp = (rand()&3);

p->color = ramp3[(int)p->ramp];

p->type = pt_fire;

for (j=0 ; j<3 ; j++)

p->org[j] = start[j] + ((rand()%6)-3);

break;

}

VectorAdd (start, vec, start);

}

}

/*

===============

R_DrawParticles

===============

*/

extern cvar_t sv_gravity;

#define PART_BUFFER_SIZE 1024

void R_DrawParticles (void)

{

int i;

float grav, time1, time2, time3, dvel, frametime;

particle_t *p, *kill;

float scale;

vec3_t up, right;

#ifdef PSP_HARDWARE_VIDEO

int part_buffer_size = PART_BUFFER_SIZE;

psp_particle* part_buffer = NULL;

part_buffer = D_CreateBuffer(part_buffer_size);

VectorScale (vup, 1.25, up);

VectorScale (vright, 1.25, right);

#endif

D_StartParticles ();

#ifdef PSP_HARDWARE_VIDEO

//VectorScale (vright, xscaleshrink, r_pright);

//VectorScale (vup, yscaleshrink, r_pup);

//VectorCopy (vright, r_pright);

//VectorCopy (vup, r_pup);

#else

VectorScale (vright, xscaleshrink, r_pright);

VectorScale (vup, yscaleshrink, r_pup);

#endif

VectorCopy (vpn, r_ppn);

frametime = cl.time - cl.oldtime;

time3 = frametime * 15;

time2 = frametime * 10; // 15;

time1 = frametime * 5;

grav = frametime * sv_gravity.value * 0.05;

dvel = 4*frametime;

for ( ;; )

{

kill = active_particles;

if (kill && kill->die < cl.time)

{

active_particles = kill->next;

kill->next = free_particles;

free_particles = kill;

continue;

}

break;

}

for (p=active_particles ; p ; p=p->next)

{

for ( ;; )

{

kill = p->next;

if (kill && kill->die < cl.time)

{

p->next = kill->next;

kill->next = free_particles;

free_particles = kill;

continue;

}

break;

}

#ifdef PSP_HARDWARE_VIDEO

// hack a scale up to keep particles from disapearing

scale = (p->org[0] - r_origin[0])*vpn[0] + (p->org[1] - r_origin[1])*vpn[1] + (p->org[2] - r_origin[2])*vpn[2];

if (scale < 20)

scale = 1;

else

scale = 1 + scale * 0.004;

// D_DrawParticle (p, up, right, scale);

int rv = D_DrawParticleBuffered(part_buffer,p, up, right, scale);

if (rv == -1)

part_buffer = D_CreateBuffer(part_buffer_size);

#else

D_DrawParticle (p);

#endif

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];

for (i=0 ; i<3 ; i++)

p->vel[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];

for (i=0 ; i<3 ; i++)

p->vel[i] -= p->vel[i]*frametime;

p->vel[2] -= grav;

break;

case pt_blob:

for (i=0 ; i<3 ; i++)

p->vel[i] += p->vel[i]*dvel;

p->vel[2] -= grav;

break;

case pt_blob2:

for (i=0 ; i<2 ; i++)

p->vel[i] -= p->vel[i]*dvel;

p->vel[2] -= grav;

break;

case pt_grav:

case pt_slowgrav:

p->vel[2] -= grav;

break;

}

}

#ifdef PSP_HARDWARE_VIDEO

D_DeleteBuffer(part_buffer);

#endif

D_EndParticles ();

}