rq3/reaction
0
0
Fork 0
mirror of https://github.com/ReactionQuake3/reaction.git synced 2024-11-25 21:51:30 +00:00
Code Issues Projects Releases Packages Wiki Activity
reaction/code/cgame/cg_marks.c
Richard Allen b6ae8af89f Moving everything up one folder.
2013-01-04 13:27:22 +00:00

2578 lines
54 KiB
C
Raw Blame History

//-----------------------------------------------------------------------------
//
// $Id$
//
//-----------------------------------------------------------------------------
//
// $Log$
// Revision 1.21 2006/04/14 18:16:31 makro
// no message
//
// Revision 1.20 2004/01/26 21:26:08 makro
// no message
//
// Revision 1.19 2003/07/30 16:05:46 makro
// no message
//
// Revision 1.18 2003/03/29 18:53:41 jbravo
// Fixed ammo bug when dropping bandolier. Added color to more errormessages
//
// Revision 1.17 2002/12/02 19:52:05 niceass
// water pressure & shell ejection stuff
//
// Revision 1.16 2002/08/25 23:20:18 niceass
// steam looks/acts better
//
// Revision 1.15 2002/08/22 07:06:37 niceass
// small change to particle reflection
//
// Revision 1.14 2002/08/21 03:53:09 niceass
// enhanced particle system that allows particle reflection
//
// Revision 1.13 2002/08/21 03:45:36 niceass
// enhanced particle system that supports bouncing
//
// Revision 1.12 2002/06/16 20:06:13 jbravo
// Reindented all the source files with "indent -kr -ut -i8 -l120 -lc120 -sob -bad -bap"
//
// Revision 1.11 2002/06/09 05:15:12 niceass
// pressure change
//
// Revision 1.10 2002/06/06 01:53:26 niceass
// pressure change
//
// Revision 1.9 2002/05/26 05:14:05 niceass
// pressure stuff
//
// Revision 1.8 2002/04/29 06:13:31 niceass
// small particle stuff
//
// Revision 1.7 2002/04/23 06:06:19 niceass
// pressure particles
//
// Revision 1.6 2002/01/11 19:48:29 jbravo
// Formatted the source in non DOS format.
//
// Revision 1.5 2001/12/31 16:28:41 jbravo
// I made a Booboo with the Log tag.
//
//
//-----------------------------------------------------------------------------
// Copyright (C) 1999-2000 Id Software, Inc.
//
// cg_marks.c -- wall marks
#include "cg_local.h"
/*
===================================================================
MARK POLYS
===================================================================
*/
markPoly_t cg_activeMarkPolys; // double linked list
markPoly_t *cg_freeMarkPolys; // single linked list
markPoly_t cg_markPolys[MAX_MARK_POLYS];
static int markTotal;
/*
===================
CG_InitMarkPolys
This is called at startup and for tournement restarts
===================
*/
void CG_InitMarkPolys(void)
{
int i;
memset(cg_markPolys, 0, sizeof(cg_markPolys));
cg_activeMarkPolys.nextMark = &cg_activeMarkPolys;
cg_activeMarkPolys.prevMark = &cg_activeMarkPolys;
cg_freeMarkPolys = cg_markPolys;
for (i = 0; i < MAX_MARK_POLYS - 1; i++) {
cg_markPolys[i].nextMark = &cg_markPolys[i + 1];
}
}
/*
==================
CG_FreeMarkPoly
==================
*/
void CG_FreeMarkPoly(markPoly_t * le)
{
if (!le->prevMark) {
CG_Error("CG_FreeLocalEntity: not active");
}
// remove from the doubly linked active list
le->prevMark->nextMark = le->nextMark;
le->nextMark->prevMark = le->prevMark;
// the free list is only singly linked
le->nextMark = cg_freeMarkPolys;
cg_freeMarkPolys = le;
}
/*
===================
CG_AllocMark
Will allways succeed, even if it requires freeing an old active mark
===================
*/
markPoly_t *CG_AllocMark(void)
{
markPoly_t *le;
int time;
if (!cg_freeMarkPolys) {
// no free entities, so free the one at the end of the chain
// remove the oldest active entity
time = cg_activeMarkPolys.prevMark->time;
while (cg_activeMarkPolys.prevMark && time == cg_activeMarkPolys.prevMark->time) {
CG_FreeMarkPoly(cg_activeMarkPolys.prevMark);
}
}
le = cg_freeMarkPolys;
cg_freeMarkPolys = cg_freeMarkPolys->nextMark;
memset(le, 0, sizeof(*le));
// link into the active list
le->nextMark = cg_activeMarkPolys.nextMark;
le->prevMark = &cg_activeMarkPolys;
cg_activeMarkPolys.nextMark->prevMark = le;
cg_activeMarkPolys.nextMark = le;
return le;
}
/*
=================
CG_ImpactMark
origin should be a point within a unit of the plane
dir should be the plane normal
temporary marks will not be stored or randomly oriented, but immediately
passed to the renderer.
=================
*/
#define MAX_MARK_FRAGMENTS 128
#define MAX_MARK_POINTS 384
void CG_ImpactMark(qhandle_t markShader, const vec3_t origin, const vec3_t dir,
float orientation, float red, float green, float blue, float alpha,
qboolean alphaFade, float radius, qboolean temporary)
{
vec3_t axis[3];
float texCoordScale;
vec3_t originalPoints[4];
byte colors[4];
int i, j;
int numFragments;
markFragment_t markFragments[MAX_MARK_FRAGMENTS], *mf;
vec3_t markPoints[MAX_MARK_POINTS];
vec3_t projection;
if (!cg_addMarks.integer) {
return;
}
if (radius <= 0) {
CG_Error("CG_ImpactMark called with <= 0 radius");
}
//if ( markTotal >= MAX_MARK_POLYS ) {
// return;
//}
// create the texture axis
VectorNormalize2(dir, axis[0]);
PerpendicularVector(axis[1], axis[0]);
RotatePointAroundVector(axis[2], axis[0], axis[1], orientation);
CrossProduct(axis[0], axis[2], axis[1]);
texCoordScale = 0.5 * 1.0 / radius;
// create the full polygon
for (i = 0; i < 3; i++) {
originalPoints[0][i] = origin[i] - radius * axis[1][i] - radius * axis[2][i];
originalPoints[1][i] = origin[i] + radius * axis[1][i] - radius * axis[2][i];
originalPoints[2][i] = origin[i] + radius * axis[1][i] + radius * axis[2][i];
originalPoints[3][i] = origin[i] - radius * axis[1][i] + radius * axis[2][i];
}
// get the fragments
VectorScale(dir, -20, projection);
numFragments = trap_CM_MarkFragments(4, (void *) originalPoints,
projection, MAX_MARK_POINTS, markPoints[0],
MAX_MARK_FRAGMENTS, markFragments);
colors[0] = red * 255;
colors[1] = green * 255;
colors[2] = blue * 255;
colors[3] = alpha * 255;
for (i = 0, mf = markFragments; i < numFragments; i++, mf++) {
polyVert_t *v;
polyVert_t verts[MAX_VERTS_ON_POLY];
markPoly_t *mark;
// we have an upper limit on the complexity of polygons
// that we store persistantly
if (mf->numPoints > MAX_VERTS_ON_POLY) {
mf->numPoints = MAX_VERTS_ON_POLY;
}
for (j = 0, v = verts; j < mf->numPoints; j++, v++) {
vec3_t delta;
VectorCopy(markPoints[mf->firstPoint + j], v->xyz);
VectorSubtract(v->xyz, origin, delta);
v->st[0] = 0.5 + DotProduct(delta, axis[1]) * texCoordScale;
v->st[1] = 0.5 + DotProduct(delta, axis[2]) * texCoordScale;
*(int *) v->modulate = *(int *) colors;
}
// if it is a temporary (shadow) mark, add it immediately and forget about it
if (temporary) {
trap_R_AddPolyToScene(markShader, mf->numPoints, verts);
continue;
}
// otherwise save it persistantly
mark = CG_AllocMark();
mark->time = cg.time;
mark->alphaFade = alphaFade;
mark->markShader = markShader;
mark->poly.numVerts = mf->numPoints;
mark->color[0] = red;
mark->color[1] = green;
mark->color[2] = blue;
mark->color[3] = alpha;
memcpy(mark->verts, verts, mf->numPoints * sizeof(verts[0]));
markTotal++;
}
}
/*
===============
CG_AddMarks
===============
*/
#define MARK_TOTAL_TIME 10000
#define MARK_FADE_TIME 1000
void CG_AddMarks(void)
{
int j;
markPoly_t *mp, *next;
int t;
int fade;
if (!cg_addMarks.integer) {
return;
}
mp = cg_activeMarkPolys.nextMark;
for (; mp != &cg_activeMarkPolys; mp = next) {
// grab next now, so if the local entity is freed we
// still have it
next = mp->nextMark;
// see if it is time to completely remove it
if (cg.time > mp->time + MARK_TOTAL_TIME) {
CG_FreeMarkPoly(mp);
continue;
}
// fade out the energy bursts
if (mp->markShader == cgs.media.energyMarkShader) {
fade = 450 - 450 * ((cg.time - mp->time) / 3000.0);
if (fade < 255) {
if (fade < 0) {
fade = 0;
}
if (mp->verts[0].modulate[0] != 0) {
for (j = 0; j < mp->poly.numVerts; j++) {
mp->verts[j].modulate[0] = mp->color[0] * fade;
mp->verts[j].modulate[1] = mp->color[1] * fade;
mp->verts[j].modulate[2] = mp->color[2] * fade;
}
}
}
}
// fade all marks out with time
t = mp->time + MARK_TOTAL_TIME - cg.time;
if (t < MARK_FADE_TIME) {
fade = 255 * t / MARK_FADE_TIME;
if (mp->alphaFade) {
for (j = 0; j < mp->poly.numVerts; j++) {
mp->verts[j].modulate[3] = fade;
}
} else {
for (j = 0; j < mp->poly.numVerts; j++) {
mp->verts[j].modulate[0] = mp->color[0] * fade;
mp->verts[j].modulate[1] = mp->color[1] * fade;
mp->verts[j].modulate[2] = mp->color[2] * fade;
}
}
}
trap_R_AddPolyToScene(mp->markShader, mp->poly.numVerts, mp->verts);
}
}
// cg_particles.c
#define BLOODRED 2
#define EMISIVEFADE 3
#define GREY75 4
#define LIGHT_BLUE_WATER 5
#define DARK_BLUE_WATER 6
//Makro - added
#define GRASS 7
typedef struct particle_s {
struct particle_s *next;
float time;
float endtime;
vec3_t org;
vec3_t vel;
vec3_t accel;
int color;
float colorvel;
float alpha;
float alphavel;
int type;
qhandle_t pshader;
float height;
float width;
float endheight;
float endwidth;
float start;
float end;
float startfade;
qboolean rotate;
int snum;
qboolean link;
// Ridah
int shaderAnim;
int roll;
int accumroll;
// reflection stuff
float reflectdistance;
vec3_t reflectnormal;
float mtime;
float epsilon;
} cparticle_t;
typedef enum {
P_NONE,
P_WEATHER,
P_FLAT,
P_SMOKE,
P_ROTATE,
P_WEATHER_TURBULENT,
P_ANIM, // Ridah
P_BAT,
P_BLEED,
P_FLAT_SCALEUP,
P_FLAT_SCALEUP_FADE,
P_WEATHER_FLURRY,
P_SMOKE_IMPACT,
P_BUBBLE,
P_BUBBLE_TURBULENT,
P_SPRITE
} particle_type_t;
#define MAX_SHADER_ANIMS 32
#define MAX_SHADER_ANIM_FRAMES 64
static char *shaderAnimNames[MAX_SHADER_ANIMS] = {
"explode1",
NULL
};
static qhandle_t shaderAnims[MAX_SHADER_ANIMS][MAX_SHADER_ANIM_FRAMES];
static int shaderAnimCounts[MAX_SHADER_ANIMS] = {
23
};
static float shaderAnimSTRatio[MAX_SHADER_ANIMS] = {
1.0f
};
static int numShaderAnims;
// done.
#define PARTICLE_GRAVITY 40
#define MAX_PARTICLES 1536 // NiceAss: 1024 upped to 1536
cparticle_t *active_particles, *free_particles;
cparticle_t particles[MAX_PARTICLES];
int cl_numparticles = MAX_PARTICLES;
qboolean initparticles = qfalse;
vec3_t pvforward, pvright, pvup;
vec3_t rforward, rright, rup;
float oldtime;
/*
===============
CL_ClearParticles
===============
*/
void CG_ClearParticles(void)
{
int i;
memset(particles, 0, sizeof(particles));
free_particles = &particles[0];
active_particles = NULL;
for (i = 0; i < cl_numparticles; i++) {
particles[i].next = &particles[i + 1];
particles[i].type = 0;
}
particles[cl_numparticles - 1].next = NULL;
oldtime = cg.time;
// Ridah, init the shaderAnims
for (i = 0; shaderAnimNames[i]; i++) {
int j;
for (j = 0; j < shaderAnimCounts[i]; j++) {
shaderAnims[i][j] = trap_R_RegisterShader(va("%s%i", shaderAnimNames[i], j + 1));
}
}
numShaderAnims = i;
// done.
initparticles = qtrue;
}
/*
=====================
CG_AddParticleToScene
=====================
*/
void CG_AddParticleToScene(cparticle_t * p, vec3_t org, float alpha)
{
vec3_t point;
polyVert_t verts[4];
float width;
float height;
float time, time2;
float ratio;
float invratio;
vec3_t color;
polyVert_t TRIverts[3];
vec3_t rright2, rup2;
if (p->type == P_WEATHER || p->type == P_WEATHER_TURBULENT || p->type == P_WEATHER_FLURRY || p->type == P_BUBBLE || p->type == P_BUBBLE_TURBULENT) { // create a front facing polygon
if (p->type != P_WEATHER_FLURRY) {
if (p->type == P_BUBBLE || p->type == P_BUBBLE_TURBULENT) {
if (org[2] > p->end) {
p->time = cg.time;
VectorCopy(org, p->org); // Ridah, fixes rare snow flakes that flicker on the ground
p->org[2] = (p->start + crandom() * 4);
if (p->type == P_BUBBLE_TURBULENT) {
p->vel[0] = crandom() * 4;
p->vel[1] = crandom() * 4;
}
}
} else {
if (org[2] < p->end) {
p->time = cg.time;
VectorCopy(org, p->org); // Ridah, fixes rare snow flakes that flicker on the ground
while (p->org[2] < p->end) {
p->org[2] += (p->start - p->end);
}
if (p->type == P_WEATHER_TURBULENT) {
p->vel[0] = crandom() * 16;
p->vel[1] = crandom() * 16;
}
}
}
// Rafael snow pvs check
if (!p->link)
return;
p->alpha = 1;
}
// Ridah, had to do this or MAX_POLYS is being exceeded in village1.bsp
if (Distance(cg.snap->ps.origin, org) > 1024) {
return;
}
// done.
if (p->type == P_BUBBLE || p->type == P_BUBBLE_TURBULENT) {
VectorMA(org, -p->height, pvup, point);
VectorMA(point, -p->width, pvright, point);
VectorCopy(point, verts[0].xyz);
verts[0].st[0] = 0;
verts[0].st[1] = 0;
verts[0].modulate[0] = 255;
verts[0].modulate[1] = 255;
verts[0].modulate[2] = 255;
verts[0].modulate[3] = 255 * p->alpha;
VectorMA(org, -p->height, pvup, point);
VectorMA(point, p->width, pvright, point);
VectorCopy(point, verts[1].xyz);
verts[1].st[0] = 0;
verts[1].st[1] = 1;
verts[1].modulate[0] = 255;
verts[1].modulate[1] = 255;
verts[1].modulate[2] = 255;
verts[1].modulate[3] = 255 * p->alpha;
VectorMA(org, p->height, pvup, point);
VectorMA(point, p->width, pvright, point);
VectorCopy(point, verts[2].xyz);
verts[2].st[0] = 1;
verts[2].st[1] = 1;
verts[2].modulate[0] = 255;
verts[2].modulate[1] = 255;
verts[2].modulate[2] = 255;
verts[2].modulate[3] = 255 * p->alpha;
VectorMA(org, p->height, pvup, point);
VectorMA(point, -p->width, pvright, point);
VectorCopy(point, verts[3].xyz);
verts[3].st[0] = 1;
verts[3].st[1] = 0;
verts[3].modulate[0] = 255;
verts[3].modulate[1] = 255;
verts[3].modulate[2] = 255;
verts[3].modulate[3] = 255 * p->alpha;
} else {
VectorMA(org, -p->height, pvup, point);
VectorMA(point, -p->width, pvright, point);
VectorCopy(point, TRIverts[0].xyz);
TRIverts[0].st[0] = 1;
TRIverts[0].st[1] = 0;
TRIverts[0].modulate[0] = 255;
TRIverts[0].modulate[1] = 255;
TRIverts[0].modulate[2] = 255;
TRIverts[0].modulate[3] = 255 * p->alpha;
VectorMA(org, p->height, pvup, point);
VectorMA(point, -p->width, pvright, point);
VectorCopy(point, TRIverts[1].xyz);
TRIverts[1].st[0] = 0;
TRIverts[1].st[1] = 0;
TRIverts[1].modulate[0] = 255;
TRIverts[1].modulate[1] = 255;
TRIverts[1].modulate[2] = 255;
TRIverts[1].modulate[3] = 255 * p->alpha;
VectorMA(org, p->height, pvup, point);
VectorMA(point, p->width, pvright, point);
VectorCopy(point, TRIverts[2].xyz);
TRIverts[2].st[0] = 0;
TRIverts[2].st[1] = 1;
TRIverts[2].modulate[0] = 255;
TRIverts[2].modulate[1] = 255;
TRIverts[2].modulate[2] = 255;
TRIverts[2].modulate[3] = 255 * p->alpha;
}
} else if (p->type == P_SPRITE) {
vec3_t rr, ru;
vec3_t rotate_ang;
VectorSet(color, 1.0, 1.0, 0.5);
time = cg.time - p->time;
time2 = p->endtime - p->time;
ratio = time / time2;
width = p->width + (ratio * (p->endwidth - p->width));
height = p->height + (ratio * (p->endheight - p->height));
if (p->roll) {
vectoangles(cg.refdef.viewaxis[0], rotate_ang);
rotate_ang[ROLL] += p->roll;
AngleVectors(rotate_ang, NULL, rr, ru);
}
if (p->roll) {
VectorMA(org, -height, ru, point);
VectorMA(point, -width, rr, point);
} else {
VectorMA(org, -height, pvup, point);
VectorMA(point, -width, pvright, point);
}
VectorCopy(point, verts[0].xyz);
verts[0].st[0] = 0;
verts[0].st[1] = 0;
verts[0].modulate[0] = 255;
verts[0].modulate[1] = 255;
verts[0].modulate[2] = 255;
verts[0].modulate[3] = 255;
if (p->roll) {
VectorMA(point, 2 * height, ru, point);
} else {
VectorMA(point, 2 * height, pvup, point);
}
VectorCopy(point, verts[1].xyz);
verts[1].st[0] = 0;
verts[1].st[1] = 1;
verts[1].modulate[0] = 255;
verts[1].modulate[1] = 255;
verts[1].modulate[2] = 255;
verts[1].modulate[3] = 255;
if (p->roll) {
VectorMA(point, 2 * width, rr, point);
} else {
VectorMA(point, 2 * width, pvright, point);
}
VectorCopy(point, verts[2].xyz);
verts[2].st[0] = 1;
verts[2].st[1] = 1;
verts[2].modulate[0] = 255;
verts[2].modulate[1] = 255;
verts[2].modulate[2] = 255;
verts[2].modulate[3] = 255;
if (p->roll) {
VectorMA(point, -2 * height, ru, point);
} else {
VectorMA(point, -2 * height, pvup, point);
}
VectorCopy(point, verts[3].xyz);
verts[3].st[0] = 1;
verts[3].st[1] = 0;
verts[3].modulate[0] = 255;
verts[3].modulate[1] = 255;
verts[3].modulate[2] = 255;
verts[3].modulate[3] = 255;
} else if (p->type == P_SMOKE || p->type == P_SMOKE_IMPACT) { // create a front rotating facing polygon
if (p->type == P_SMOKE_IMPACT && Distance(cg.snap->ps.origin, org) > 1024) {
return;
}
if (p->color == BLOODRED)
VectorSet(color, 0.22f, 0.0f, 0.0f);
else if (p->color == LIGHT_BLUE_WATER)
VectorSet(color, 0.8f, 0.8f, 1.0f);
else if (p->color == DARK_BLUE_WATER)
VectorSet(color, 0.6f, 0.8f, 1.0f);
//Makro - added
else if (p->color == GRASS)
VectorSet(color, 0.4f, 0.5f, 0.4f);
else if (p->color == GREY75) {
float len;
float greyit;
float val;
len = Distance(cg.snap->ps.origin, org);
if (!len)
len = 1;
val = 4096 / len;
greyit = 0.25 * val;
if (greyit > 0.5)
greyit = 0.5;
VectorSet(color, greyit, greyit, greyit);
} else
VectorSet(color, 1.0, 1.0, 1.0);
time = cg.time - p->time;
time2 = p->endtime - p->time;
ratio = time / time2;
if (cg.time > p->startfade) {
invratio = 1 - ((cg.time - p->startfade) / (p->endtime - p->startfade));
if (p->color == EMISIVEFADE) {
float fval;
fval = (invratio * invratio);
if (fval < 0)
fval = 0;
VectorSet(color, fval, fval, fval);
}
invratio *= p->alpha;
} else
invratio = 1 * p->alpha;
if (cgs.glconfig.hardwareType == GLHW_RAGEPRO)
invratio = 1;
if (invratio > 1)
invratio = 1;
width = p->width + (ratio * (p->endwidth - p->width));
height = p->height + (ratio * (p->endheight - p->height));
if (p->type != P_SMOKE_IMPACT) {
vec3_t temp;
vectoangles(rforward, temp);
p->accumroll += p->roll;
temp[ROLL] += p->accumroll * 0.1;
AngleVectors(temp, NULL, rright2, rup2);
} else {
VectorCopy(rright, rright2);
VectorCopy(rup, rup2);
}
if (p->rotate) {
VectorMA(org, -height, rup2, point);
VectorMA(point, -width, rright2, point);
} else {
VectorMA(org, -p->height, pvup, point);
VectorMA(point, -p->width, pvright, point);
}
VectorCopy(point, verts[0].xyz);
verts[0].st[0] = 0;
verts[0].st[1] = 0;
verts[0].modulate[0] = 255 * color[0];
verts[0].modulate[1] = 255 * color[1];
verts[0].modulate[2] = 255 * color[2];
verts[0].modulate[3] = 255 * invratio;
if (p->rotate) {
VectorMA(org, -height, rup2, point);
VectorMA(point, width, rright2, point);
} else {
VectorMA(org, -p->height, pvup, point);
VectorMA(point, p->width, pvright, point);
}
VectorCopy(point, verts[1].xyz);
verts[1].st[0] = 0;
verts[1].st[1] = 1;
verts[1].modulate[0] = 255 * color[0];
verts[1].modulate[1] = 255 * color[1];
verts[1].modulate[2] = 255 * color[2];
verts[1].modulate[3] = 255 * invratio;
if (p->rotate) {
VectorMA(org, height, rup2, point);
VectorMA(point, width, rright2, point);
} else {
VectorMA(org, p->height, pvup, point);
VectorMA(point, p->width, pvright, point);
}
VectorCopy(point, verts[2].xyz);
verts[2].st[0] = 1;
verts[2].st[1] = 1;
verts[2].modulate[0] = 255 * color[0];
verts[2].modulate[1] = 255 * color[1];
verts[2].modulate[2] = 255 * color[2];
verts[2].modulate[3] = 255 * invratio;
if (p->rotate) {
VectorMA(org, height, rup2, point);
VectorMA(point, -width, rright2, point);
} else {
VectorMA(org, p->height, pvup, point);
VectorMA(point, -p->width, pvright, point);
}
VectorCopy(point, verts[3].xyz);
verts[3].st[0] = 1;
verts[3].st[1] = 0;
verts[3].modulate[0] = 255 * color[0];
verts[3].modulate[1] = 255 * color[1];
verts[3].modulate[2] = 255 * color[2];
verts[3].modulate[3] = 255 * invratio;
} else if (p->type == P_BLEED) {
vec3_t rr, ru;
vec3_t rotate_ang;
float alpha;
alpha = p->alpha;
if (cgs.glconfig.hardwareType == GLHW_RAGEPRO)
alpha = 1;
if (p->roll) {
vectoangles(cg.refdef.viewaxis[0], rotate_ang);
rotate_ang[ROLL] += p->roll;
AngleVectors(rotate_ang, NULL, rr, ru);
} else {
VectorCopy(pvup, ru);
VectorCopy(pvright, rr);
}
VectorMA(org, -p->height, ru, point);
VectorMA(point, -p->width, rr, point);
VectorCopy(point, verts[0].xyz);
verts[0].st[0] = 0;
verts[0].st[1] = 0;
verts[0].modulate[0] = 111;
verts[0].modulate[1] = 19;
verts[0].modulate[2] = 9;
verts[0].modulate[3] = 255 * alpha;
VectorMA(org, -p->height, ru, point);
VectorMA(point, p->width, rr, point);
VectorCopy(point, verts[1].xyz);
verts[1].st[0] = 0;
verts[1].st[1] = 1;
verts[1].modulate[0] = 111;
verts[1].modulate[1] = 19;
verts[1].modulate[2] = 9;
verts[1].modulate[3] = 255 * alpha;
VectorMA(org, p->height, ru, point);
VectorMA(point, p->width, rr, point);
VectorCopy(point, verts[2].xyz);
verts[2].st[0] = 1;
verts[2].st[1] = 1;
verts[2].modulate[0] = 111;
verts[2].modulate[1] = 19;
verts[2].modulate[2] = 9;
verts[2].modulate[3] = 255 * alpha;
VectorMA(org, p->height, ru, point);
VectorMA(point, -p->width, rr, point);
VectorCopy(point, verts[3].xyz);
verts[3].st[0] = 1;
verts[3].st[1] = 0;
verts[3].modulate[0] = 111;
verts[3].modulate[1] = 19;
verts[3].modulate[2] = 9;
verts[3].modulate[3] = 255 * alpha;
} else if (p->type == P_FLAT_SCALEUP) {
float width, height;
float sinR, cosR;
if (p->color == BLOODRED)
VectorSet(color, 1, 1, 1);
else if (p->color == LIGHT_BLUE_WATER)
VectorSet(color, 0.8f, 0.8f, 1.0f);
else if (p->color == DARK_BLUE_WATER)
VectorSet(color, 0.6f, 0.8f, 1.0f);
else
VectorSet(color, 0.5, 0.5, 0.5);
time = cg.time - p->time;
time2 = p->endtime - p->time;
ratio = time / time2;
width = p->width + (ratio * (p->endwidth - p->width));
height = p->height + (ratio * (p->endheight - p->height));
if (width > p->endwidth)
width = p->endwidth;
if (height > p->endheight)
height = p->endheight;
sinR = height * sin(DEG2RAD(p->roll)) * sqrt(2);
cosR = width * cos(DEG2RAD(p->roll)) * sqrt(2);
VectorCopy(org, verts[0].xyz);
verts[0].xyz[0] -= sinR;
verts[0].xyz[1] -= cosR;
verts[0].st[0] = 0;
verts[0].st[1] = 0;
verts[0].modulate[0] = 255 * color[0];
verts[0].modulate[1] = 255 * color[1];
verts[0].modulate[2] = 255 * color[2];
verts[0].modulate[3] = 255;
VectorCopy(org, verts[1].xyz);
verts[1].xyz[0] -= cosR;
verts[1].xyz[1] += sinR;
verts[1].st[0] = 0;
verts[1].st[1] = 1;
verts[1].modulate[0] = 255 * color[0];
verts[1].modulate[1] = 255 * color[1];
verts[1].modulate[2] = 255 * color[2];
verts[1].modulate[3] = 255;
VectorCopy(org, verts[2].xyz);
verts[2].xyz[0] += sinR;
verts[2].xyz[1] += cosR;
verts[2].st[0] = 1;
verts[2].st[1] = 1;
verts[2].modulate[0] = 255 * color[0];
verts[2].modulate[1] = 255 * color[1];
verts[2].modulate[2] = 255 * color[2];
verts[2].modulate[3] = 255;
VectorCopy(org, verts[3].xyz);
verts[3].xyz[0] += cosR;
verts[3].xyz[1] -= sinR;
verts[3].st[0] = 1;
verts[3].st[1] = 0;
verts[3].modulate[0] = 255 * color[0];
verts[3].modulate[1] = 255 * color[1];
verts[3].modulate[2] = 255 * color[2];
verts[3].modulate[3] = 255;
} else if (p->type == P_FLAT) {
VectorCopy(org, verts[0].xyz);
verts[0].xyz[0] -= p->height;
verts[0].xyz[1] -= p->width;
verts[0].st[0] = 0;
verts[0].st[1] = 0;
verts[0].modulate[0] = 255;
verts[0].modulate[1] = 255;
verts[0].modulate[2] = 255;
verts[0].modulate[3] = 255;
VectorCopy(org, verts[1].xyz);
verts[1].xyz[0] -= p->height;
verts[1].xyz[1] += p->width;
verts[1].st[0] = 0;
verts[1].st[1] = 1;
verts[1].modulate[0] = 255;
verts[1].modulate[1] = 255;
verts[1].modulate[2] = 255;
verts[1].modulate[3] = 255;
VectorCopy(org, verts[2].xyz);
verts[2].xyz[0] += p->height;
verts[2].xyz[1] += p->width;
verts[2].st[0] = 1;
verts[2].st[1] = 1;
verts[2].modulate[0] = 255;
verts[2].modulate[1] = 255;
verts[2].modulate[2] = 255;
verts[2].modulate[3] = 255;
VectorCopy(org, verts[3].xyz);
verts[3].xyz[0] += p->height;
verts[3].xyz[1] -= p->width;
verts[3].st[0] = 1;
verts[3].st[1] = 0;
verts[3].modulate[0] = 255;
verts[3].modulate[1] = 255;
verts[3].modulate[2] = 255;
verts[3].modulate[3] = 255;
}
// Ridah
else if (p->type == P_ANIM) {
vec3_t rr, ru;
vec3_t rotate_ang;
int i, j;
time = cg.time - p->time;
time2 = p->endtime - p->time;
ratio = time / time2;
if (ratio >= 1.0f) {
ratio = 0.9999f;
}
width = p->width + (ratio * (p->endwidth - p->width));
height = p->height + (ratio * (p->endheight - p->height));
// if we are "inside" this sprite, don't draw
if (Distance(cg.snap->ps.origin, org) < width / 1.5) {
return;
}
i = p->shaderAnim;
j = (int) floor(ratio * shaderAnimCounts[p->shaderAnim]);
p->pshader = shaderAnims[i][j];
if (p->roll) {
vectoangles(cg.refdef.viewaxis[0], rotate_ang);
rotate_ang[ROLL] += p->roll;
AngleVectors(rotate_ang, NULL, rr, ru);
}
if (p->roll) {
VectorMA(org, -height, ru, point);
VectorMA(point, -width, rr, point);
} else {
VectorMA(org, -height, pvup, point);
VectorMA(point, -width, pvright, point);
}
VectorCopy(point, verts[0].xyz);
verts[0].st[0] = 0;
verts[0].st[1] = 0;
verts[0].modulate[0] = 255;
verts[0].modulate[1] = 255;
verts[0].modulate[2] = 255;
verts[0].modulate[3] = 255;
if (p->roll) {
VectorMA(point, 2 * height, ru, point);
} else {
VectorMA(point, 2 * height, pvup, point);
}
VectorCopy(point, verts[1].xyz);
verts[1].st[0] = 0;
verts[1].st[1] = 1;
verts[1].modulate[0] = 255;
verts[1].modulate[1] = 255;
verts[1].modulate[2] = 255;
verts[1].modulate[3] = 255;
if (p->roll) {
VectorMA(point, 2 * width, rr, point);
} else {
VectorMA(point, 2 * width, pvright, point);
}
VectorCopy(point, verts[2].xyz);
verts[2].st[0] = 1;
verts[2].st[1] = 1;
verts[2].modulate[0] = 255;
verts[2].modulate[1] = 255;
verts[2].modulate[2] = 255;
verts[2].modulate[3] = 255;
if (p->roll) {
VectorMA(point, -2 * height, ru, point);
} else {
VectorMA(point, -2 * height, pvup, point);
}
VectorCopy(point, verts[3].xyz);
verts[3].st[0] = 1;
verts[3].st[1] = 0;
verts[3].modulate[0] = 255;
verts[3].modulate[1] = 255;
verts[3].modulate[2] = 255;
verts[3].modulate[3] = 255;
}
// done.
if (!p->pshader) {
// (SA) temp commented out for DM
// CG_Printf ("CG_AddParticleToScene type %d p->pshader == ZERO\n", p->type);
return;
}
if (p->type == P_WEATHER || p->type == P_WEATHER_TURBULENT || p->type == P_WEATHER_FLURRY)
trap_R_AddPolyToScene(p->pshader, 3, TRIverts);
else
trap_R_AddPolyToScene(p->pshader, 4, verts);
}
// Ridah, made this static so it doesn't interfere with other files
static float roll = 0.0;
/*
===============
CG_AddParticles
===============
*/
void CG_AddParticles(void)
{
cparticle_t *p, *next;
float alpha;
float time, time2, mtime, mtime2;
vec3_t org;
// int color;
cparticle_t *active, *tail;
// int type;
vec3_t rotate_ang;
trace_t tr;
vec3_t dist, end;
if (!initparticles)
CG_ClearParticles();
VectorCopy(cg.refdef.viewaxis[0], pvforward);
VectorCopy(cg.refdef.viewaxis[1], pvright);
VectorCopy(cg.refdef.viewaxis[2], pvup);
vectoangles(cg.refdef.viewaxis[0], rotate_ang);
roll += ((cg.time - oldtime) * 0.1);
rotate_ang[ROLL] += (roll * 0.9);
AngleVectors(rotate_ang, rforward, rright, rup);
oldtime = cg.time;
active = NULL;
tail = NULL;
for (p = active_particles; p; p = next) {
next = p->next;
time = (cg.time - p->time) * 0.001;
mtime = (cg.time - p->mtime) * 0.001;
alpha = p->alpha + time * p->alphavel;
if (alpha <= 0) { // faded out
p->next = free_particles;
free_particles = p;
p->type = 0;
p->color = 0;
p->alpha = 0;
continue;
}
if (p->type == P_SMOKE || p->type == P_ANIM || p->type == P_BLEED || p->type == P_SMOKE_IMPACT) {
if (cg.time > p->endtime) {
p->next = free_particles;
free_particles = p;
p->type = 0;
p->color = 0;
p->alpha = 0;
continue;
}
}
if (p->type == P_WEATHER_FLURRY) {
if (cg.time > p->endtime) {
p->next = free_particles;
free_particles = p;
p->type = 0;
p->color = 0;
p->alpha = 0;
continue;
}
}
if (p->type == P_FLAT_SCALEUP_FADE) {
if (cg.time > p->endtime) {
p->next = free_particles;
free_particles = p;
p->type = 0;
p->color = 0;
p->alpha = 0;
continue;
}
}
if ((p->type == P_BAT || p->type == P_SPRITE) && p->endtime < 0) {
// temporary sprite
CG_AddParticleToScene(p, p->org, alpha);
p->next = free_particles;
free_particles = p;
p->type = 0;
p->color = 0;
p->alpha = 0;
continue;
}
p->next = NULL;
if (!tail)
active = tail = p;
else {
tail->next = p;
tail = p;
}
if (alpha > 1.0)
alpha = 1;
// color = p->color;
time2 = time * time;
mtime2 = mtime * mtime;
if (p->mtime) {
org[0] = p->org[0] + p->vel[0] * mtime + p->accel[0] * mtime2;
org[1] = p->org[1] + p->vel[1] * mtime + p->accel[1] * mtime2;
org[2] = p->org[2] + p->vel[2] * mtime + p->accel[2] * mtime2;
}
else {
org[0] = p->org[0] + p->vel[0] * time + p->accel[0] * time2;
org[1] = p->org[1] + p->vel[1] * time + p->accel[1] * time2;
org[2] = p->org[2] + p->vel[2] * time + p->accel[2] * time2;
}
// type = p->type;
CG_AddParticleToScene(p, org, alpha);
VectorSubtract(org, p->org, dist);
// reflection stuff
if ( VectorLength( dist ) > p->reflectdistance - 5 && p->reflectdistance ) {
float length;
length = VectorLength(p->vel) * 0.75f;
// reflection stuff
p->vel[0] += (rand() % 200) - 100;
p->vel[1] += (rand() % 200) - 100;
p->vel[2] += (rand() % 200) - 100;
VectorNormalize(p->vel);
VectorScale(p->vel, length, p->vel);
PM_ClipVelocity(p->vel, p->reflectnormal, p->vel, p->epsilon);
VectorCopy(org, p->org);
VectorMA(org, 300, p->vel, end);
CG_Trace(&tr, org, NULL, NULL, end, 0, MASK_SOLID);
VectorSubtract(org, tr.endpos, dist);
p->reflectdistance = VectorLength(dist);
VectorCopy(tr.plane.normal, p->reflectnormal);
p->mtime = cg.time;
}
}
active_particles = active;
}
/*
======================
CG_AddParticles
======================
*/
void CG_ParticleSnowFlurry(qhandle_t pshader, centity_t * cent)
{
cparticle_t *p;
qboolean turb = qtrue;
if (!pshader)
CG_Printf("^1CG_ParticleSnowFlurry pshader == ZERO!\n");
if (!free_particles)
return;
p = free_particles;
free_particles = p->next;
p->next = active_particles;
active_particles = p;
p->time = cg.time;
p->color = 0;
p->alpha = 0.90f;
p->alphavel = 0;
p->start = cent->currentState.origin2[0];
p->end = cent->currentState.origin2[1];
p->endtime = cg.time + cent->currentState.time;
p->startfade = cg.time + cent->currentState.time2;
p->pshader = pshader;
if (rand() % 100 > 90) {
p->height = 32;
p->width = 32;
p->alpha = 0.10f;
} else {
p->height = 1;
p->width = 1;
}
p->vel[2] = -20;
p->type = P_WEATHER_FLURRY;
if (turb)
p->vel[2] = -10;
VectorCopy(cent->currentState.origin, p->org);
p->org[0] = p->org[0];
p->org[1] = p->org[1];
p->org[2] = p->org[2];
p->vel[0] = p->vel[1] = 0;
p->accel[0] = p->accel[1] = p->accel[2] = 0;
p->vel[0] += cent->currentState.angles[0] * 32 + (crandom() * 16);
p->vel[1] += cent->currentState.angles[1] * 32 + (crandom() * 16);
p->vel[2] += cent->currentState.angles[2];
if (turb) {
p->accel[0] = crandom() * 16;
p->accel[1] = crandom() * 16;
}
}
void CG_ParticleSnow(qhandle_t pshader, vec3_t origin, vec3_t origin2, int turb, float range, int snum)
{
cparticle_t *p;
if (!pshader)
CG_Printf("^1CG_ParticleSnow pshader == ZERO!\n");
if (!free_particles)
return;
p = free_particles;
free_particles = p->next;
p->next = active_particles;
active_particles = p;
p->time = cg.time;
p->color = 0;
p->alpha = 0.40f;
p->alphavel = 0;
p->start = origin[2];
p->end = origin2[2];
p->pshader = pshader;
p->height = 1;
p->width = 1;
p->vel[2] = -50;
if (turb) {
p->type = P_WEATHER_TURBULENT;
p->vel[2] = -50 * 1.3;
} else {
p->type = P_WEATHER;
}
VectorCopy(origin, p->org);
p->org[0] = p->org[0] + (crandom() * range);
p->org[1] = p->org[1] + (crandom() * range);
p->org[2] = p->org[2] + (crandom() * (p->start - p->end));
p->vel[0] = p->vel[1] = 0;
p->accel[0] = p->accel[1] = p->accel[2] = 0;
if (turb) {
p->vel[0] = crandom() * 16;
p->vel[1] = crandom() * 16;
}
// Rafael snow pvs check
p->snum = snum;
p->link = qtrue;
}
void CG_ParticleBubble(qhandle_t pshader, vec3_t origin, vec3_t origin2, int turb, float range, int snum)
{
cparticle_t *p;
float randsize;
if (!pshader)
CG_Printf("^1CG_ParticleSnow pshader == ZERO!\n");
if (!free_particles)
return;
p = free_particles;
free_particles = p->next;
p->next = active_particles;
active_particles = p;
p->time = cg.time;
p->color = 0;
p->alpha = 0.40f;
p->alphavel = 0;
p->start = origin[2];
p->end = origin2[2];
p->pshader = pshader;
randsize = 1 + (crandom() * 0.5);
p->height = randsize;
p->width = randsize;
p->vel[2] = 50 + (crandom() * 10);
if (turb) {
p->type = P_BUBBLE_TURBULENT;
p->vel[2] = 50 * 1.3;
} else {
p->type = P_BUBBLE;
}
VectorCopy(origin, p->org);
p->org[0] = p->org[0] + (crandom() * range);
p->org[1] = p->org[1] + (crandom() * range);
p->org[2] = p->org[2] + (crandom() * (p->start - p->end));
p->vel[0] = p->vel[1] = 0;
p->accel[0] = p->accel[1] = p->accel[2] = 0;
if (turb) {
p->vel[0] = crandom() * 4;
p->vel[1] = crandom() * 4;
}
// Rafael snow pvs check
p->snum = snum;
p->link = qtrue;
}
void CG_ParticleSmoke(qhandle_t pshader, centity_t * cent)
{
// using cent->density = enttime
// cent->frame = startfade
cparticle_t *p;
if (!pshader)
CG_Printf("^1CG_ParticleSmoke == ZERO!\n");
if (!free_particles)
return;
p = free_particles;
free_particles = p->next;
p->next = active_particles;
active_particles = p;
p->time = cg.time;
p->endtime = cg.time + cent->currentState.time;
p->startfade = cg.time + cent->currentState.time2;
p->color = 0;
p->alpha = 1.0;
p->alphavel = 0;
p->start = cent->currentState.origin[2];
p->end = cent->currentState.origin2[2];
p->pshader = pshader;
p->rotate = qfalse;
p->height = 8;
p->width = 8;
p->endheight = 32;
p->endwidth = 32;
p->type = P_SMOKE;
VectorCopy(cent->currentState.origin, p->org);
p->vel[0] = p->vel[1] = 0;
p->accel[0] = p->accel[1] = p->accel[2] = 0;
p->vel[2] = 5;
if (cent->currentState.frame == 1) // reverse gravity
p->vel[2] *= -1;
p->roll = 8 + (crandom() * 4);
}
void CG_ParticleBulletDebris(vec3_t org, vec3_t vel, int duration)
{
cparticle_t *p;
if (!free_particles)
return;
p = free_particles;
free_particles = p->next;
p->next = active_particles;
active_particles = p;
p->time = cg.time;
p->endtime = cg.time + duration;
p->startfade = cg.time + duration / 2;
p->color = EMISIVEFADE;
p->alpha = 1.0;
p->alphavel = 0;
/*
p->height = 0.5;
p->width = 0.5;
p->endheight = 0.5;
p->endwidth = 0.5;
*/
p->pshader = cgs.media.tracerShader;
p->type = P_SMOKE;
VectorCopy(org, p->org);
p->vel[0] = vel[0];
p->vel[1] = vel[1];
p->vel[2] = vel[2];
p->accel[0] = p->accel[1] = p->accel[2] = 0;
p->accel[2] = -60;
p->vel[2] += -20;
}
/*
======================
CG_ParticleExplosion
======================
*/
void CG_ParticleExplosion(char *animStr, vec3_t origin, vec3_t vel, int duration, int sizeStart, int sizeEnd)
{
cparticle_t *p;
int anim;
if (animStr < (char *) 10)
CG_Error("CG_ParticleExplosion: animStr is probably an index rather than a string");
// find the animation string
for (anim = 0; shaderAnimNames[anim]; anim++) {
if (!Q_stricmp(animStr, shaderAnimNames[anim]))
break;
}
if (!shaderAnimNames[anim]) {
CG_Error("CG_ParticleExplosion: unknown animation string: %s\n", animStr);
return;
}
if (!free_particles)
return;
p = free_particles;
free_particles = p->next;
p->next = active_particles;
active_particles = p;
p->time = cg.time;
p->alpha = 0.5;
p->alphavel = 0;
if (duration < 0) {
duration *= -1;
p->roll = 0;
} else {
p->roll = crandom() * 179;
}
p->shaderAnim = anim;
p->width = sizeStart;
p->height = sizeStart * shaderAnimSTRatio[anim]; // for sprites that are stretch in either direction
p->endheight = sizeEnd;
p->endwidth = sizeEnd * shaderAnimSTRatio[anim];
p->endtime = cg.time + duration;
p->type = P_ANIM;
VectorCopy(origin, p->org);
VectorCopy(vel, p->vel);
VectorClear(p->accel);
}
// Rafael Shrapnel
void CG_AddParticleShrapnel(localEntity_t * le)
{
return;
}
// done.
int CG_NewParticleArea(int num)
{
// const char *str;
char *str;
char *token;
int type;
vec3_t origin, origin2;
int i;
float range = 0;
int turb;
int numparticles;
int snum;
str = (char *) CG_ConfigString(num);
if (!str[0])
return (0);
// returns type 128 64 or 32
token = COM_Parse(&str);
type = atoi(token);
if (type == 1)
range = 128;
else if (type == 2)
range = 64;
else if (type == 3)
range = 32;
else if (type == 0)
range = 256;
else if (type == 4)
range = 8;
else if (type == 5)
range = 16;
else if (type == 6)
range = 32;
else if (type == 7)
range = 64;
for (i = 0; i < 3; i++) {
token = COM_Parse(&str);
origin[i] = atof(token);
}
for (i = 0; i < 3; i++) {
token = COM_Parse(&str);
origin2[i] = atof(token);
}
token = COM_Parse(&str);
numparticles = atoi(token);
token = COM_Parse(&str);
turb = atoi(token);
token = COM_Parse(&str);
snum = atoi(token);
for (i = 0; i < numparticles; i++) {
if (type >= 4)
CG_ParticleBubble(cgs.media.waterBubbleShader, origin, origin2, turb, range, snum);
else
CG_ParticleSnow(cgs.media.waterBubbleShader, origin, origin2, turb, range, snum);
}
return (1);
}
void CG_SnowLink(centity_t * cent, qboolean particleOn)
{
cparticle_t *p, *next;
int id;
id = cent->currentState.frame;
for (p = active_particles; p; p = next) {
next = p->next;
if (p->type == P_WEATHER || p->type == P_WEATHER_TURBULENT) {
if (p->snum == id) {
if (particleOn)
p->link = qtrue;
else
p->link = qfalse;
}
}
}
}
void CG_ParticleImpactSmokePuff(qhandle_t pshader, vec3_t origin)
{
cparticle_t *p;
if (!pshader)
CG_Printf("^1CG_ParticleImpactSmokePuff pshader == ZERO!\n");
if (!free_particles)
return;
p = free_particles;
free_particles = p->next;
p->next = active_particles;
active_particles = p;
p->time = cg.time;
p->alpha = 0.25;
p->alphavel = 0;
p->roll = crandom() * 179;
p->pshader = pshader;
p->endtime = cg.time + 1000;
p->startfade = cg.time + 100;
p->width = rand() % 4 + 8;
p->height = rand() % 4 + 8;
p->endheight = p->height * 2;
p->endwidth = p->width * 2;
p->endtime = cg.time + 500;
p->type = P_SMOKE_IMPACT;
VectorCopy(origin, p->org);
VectorSet(p->vel, 0, 0, 20);
VectorSet(p->accel, 0, 0, 20);
p->rotate = qtrue;
}
void CG_Particle_Bleed(qhandle_t pshader, vec3_t start, vec3_t dir, int fleshEntityNum, int duration)
{
cparticle_t *p;
if (!pshader)
CG_Printf("^1CG_Particle_Bleed pshader == ZERO!\n");
if (!free_particles)
return;
p = free_particles;
free_particles = p->next;
p->next = active_particles;
active_particles = p;
p->time = cg.time;
p->alpha = 1.0;
p->alphavel = 0;
p->roll = 0;
p->pshader = pshader;
p->endtime = cg.time + duration;
if (fleshEntityNum)
p->startfade = cg.time;
else
p->startfade = cg.time + 100;
p->width = 4;
p->height = 4;
p->endheight = 4 + rand() % 3;
p->endwidth = p->endheight;
p->type = P_SMOKE;
VectorCopy(start, p->org);
p->vel[0] = 0;
p->vel[1] = 0;
p->vel[2] = -20;
VectorClear(p->accel);
p->rotate = qfalse;
p->roll = rand() % 179;
p->color = BLOODRED;
p->alpha = 0.75;
}
void CG_Particle_OilParticle(qhandle_t pshader, centity_t * cent)
{
cparticle_t *p;
int time;
int time2;
float ratio;
float duration = 1500;
time = cg.time;
time2 = cg.time + cent->currentState.time;
ratio = (float) 1 - ((float) time / (float) time2);
if (!pshader)
CG_Printf("^1CG_Particle_OilParticle == ZERO!\n");
if (!free_particles)
return;
p = free_particles;
free_particles = p->next;
p->next = active_particles;
active_particles = p;
p->time = cg.time;
p->alpha = 1.0;
p->alphavel = 0;
p->roll = 0;
p->pshader = pshader;
p->endtime = cg.time + duration;
p->startfade = p->endtime;
p->width = 1;
p->height = 3;
p->endheight = 3;
p->endwidth = 1;
p->type = P_SMOKE;
VectorCopy(cent->currentState.origin, p->org);
p->vel[0] = (cent->currentState.origin2[0] * (16 * ratio));
p->vel[1] = (cent->currentState.origin2[1] * (16 * ratio));
p->vel[2] = (cent->currentState.origin2[2]);
p->snum = 1.0f;
VectorClear(p->accel);
p->accel[2] = -20;
p->rotate = qfalse;
p->roll = rand() % 179;
p->alpha = 0.75;
}
void CG_Particle_OilSlick(qhandle_t pshader, centity_t * cent)
{
cparticle_t *p;
if (!pshader)
CG_Printf("^1CG_Particle_OilSlick == ZERO!\n");
if (!free_particles)
return;
p = free_particles;
free_particles = p->next;
p->next = active_particles;
active_particles = p;
p->time = cg.time;
if (cent->currentState.angles2[2])
p->endtime = cg.time + cent->currentState.angles2[2];
else
p->endtime = cg.time + 60000;
p->startfade = p->endtime;
p->alpha = 1.0;
p->alphavel = 0;
p->roll = 0;
p->pshader = pshader;
if (cent->currentState.angles2[0] || cent->currentState.angles2[1]) {
p->width = cent->currentState.angles2[0];
p->height = cent->currentState.angles2[0];
p->endheight = cent->currentState.angles2[1];
p->endwidth = cent->currentState.angles2[1];
} else {
p->width = 8;
p->height = 8;
p->endheight = 16;
p->endwidth = 16;
}
p->type = P_FLAT_SCALEUP;
p->snum = 1.0;
VectorCopy(cent->currentState.origin, p->org);
p->org[2] += 0.55 + (crandom() * 0.5);
p->vel[0] = 0;
p->vel[1] = 0;
p->vel[2] = 0;
VectorClear(p->accel);
p->rotate = qfalse;
p->roll = rand() % 179;
p->alpha = 0.75;
}
void CG_OilSlickRemove(centity_t * cent)
{
cparticle_t *p, *next;
int id;
id = 1.0f;
if (!id)
CG_Printf("^1CG_OilSlickRevove NULL id\n");
for (p = active_particles; p; p = next) {
next = p->next;
if (p->type == P_FLAT_SCALEUP) {
if (p->snum == id) {
p->endtime = cg.time + 100;
p->startfade = p->endtime;
p->type = P_FLAT_SCALEUP_FADE;
}
}
}
}
qboolean ValidBloodPool(vec3_t start)
{
#define EXTRUDE_DIST 0.5
vec3_t angles;
vec3_t right, up;
vec3_t this_pos, x_pos, center_pos, end_pos;
float x, y;
float fwidth, fheight;
trace_t trace;
vec3_t normal;
fwidth = 16;
fheight = 16;
VectorSet(normal, 0, 0, 1);
vectoangles(normal, angles);
AngleVectors(angles, NULL, right, up);
VectorMA(start, EXTRUDE_DIST, normal, center_pos);
for (x = -fwidth / 2; x < fwidth; x += fwidth) {
VectorMA(center_pos, x, right, x_pos);
for (y = -fheight / 2; y < fheight; y += fheight) {
VectorMA(x_pos, y, up, this_pos);
VectorMA(this_pos, -EXTRUDE_DIST * 2, normal, end_pos);
CG_Trace(&trace, this_pos, NULL, NULL, end_pos, -1, CONTENTS_SOLID);
if (trace.entityNum < (MAX_GENTITIES - 1)) // may only land on world
return qfalse;
if (!(!trace.startsolid && trace.fraction < 1))
return qfalse;
}
}
return qtrue;
}
void CG_BloodPool(localEntity_t * le, qhandle_t pshader, trace_t * tr)
{
cparticle_t *p;
qboolean legit;
vec3_t start;
float rndSize;
if (!pshader)
CG_Printf("^1CG_BloodPool pshader == ZERO!\n");
if (!free_particles)
return;
VectorCopy(tr->endpos, start);
legit = ValidBloodPool(start);
if (!legit)
return;
p = free_particles;
free_particles = p->next;
p->next = active_particles;
active_particles = p;
p->time = cg.time;
p->endtime = cg.time + 3000;
p->startfade = p->endtime;
p->alpha = 1.0;
p->alphavel = 0;
p->roll = 0;
p->pshader = pshader;
rndSize = 0.4 + random() * 0.6;
p->width = 8 * rndSize;
p->height = 8 * rndSize;
p->endheight = 16 * rndSize;
p->endwidth = 16 * rndSize;
p->type = P_FLAT_SCALEUP;
VectorCopy(start, p->org);
p->vel[0] = 0;
p->vel[1] = 0;
p->vel[2] = 0;
VectorClear(p->accel);
p->rotate = qfalse;
p->roll = rand() % 179;
p->alpha = 0.75;
p->color = BLOODRED;
}
#define NORMALSIZE 16
#define LARGESIZE 32
void CG_ParticleBloodCloud(centity_t * cent, vec3_t origin, vec3_t dir)
{
float length;
float dist;
float crittersize;
vec3_t angles, forward;
vec3_t point;
cparticle_t *p;
int i;
dist = 0;
length = VectorLength(dir);
vectoangles(dir, angles);
AngleVectors(angles, forward, NULL, NULL);
crittersize = LARGESIZE;
if (length)
dist = length / crittersize;
if (dist < 1)
dist = 1;
VectorCopy(origin, point);
for (i = 0; i < dist; i++) {
VectorMA(point, crittersize, forward, point);
if (!free_particles)
return;
p = free_particles;
free_particles = p->next;
p->next = active_particles;
active_particles = p;
p->time = cg.time;
p->alpha = 1.0;
p->alphavel = 0;
p->roll = 0;
p->pshader = cgs.media.smokePuffShader;
p->endtime = cg.time + 350 + (crandom() * 100);
p->startfade = cg.time;
p->width = LARGESIZE;
p->height = LARGESIZE;
p->endheight = LARGESIZE;
p->endwidth = LARGESIZE;
p->type = P_SMOKE;
VectorCopy(origin, p->org);
p->vel[0] = 0;
p->vel[1] = 0;
p->vel[2] = -1;
VectorClear(p->accel);
p->rotate = qfalse;
p->roll = rand() % 179;
p->color = BLOODRED;
p->alpha = 0.75;
}
}
// Elder: modified to suit our impact marks
void CG_ParticleSparks(vec3_t org, vec3_t vel, int duration, float x, float y, float speed, float scale)
{
cparticle_t *p;
if (!free_particles)
{
CG_Printf(S_COLOR_RED "No particles left for sparks!!!\n");
return;
}
p = free_particles;
free_particles = p->next;
p->next = active_particles;
active_particles = p;
p->time = cg.time;
p->endtime = cg.time + duration;
p->startfade = cg.time + duration / 2;
p->color = EMISIVEFADE;
p->alpha = 0.4f;
p->alphavel = 0;
/*
// Elder: old settings
p->height = 0.5;
p->width = 0.5;
p->endheight = 0.5;
p->endwidth = 0.5;
*/
p->height = 1.5 * scale;
p->width = 1.5 * scale;
p->endheight = 0.75 * scale;
p->endwidth = 0.75 * scale;
p->pshader = cgs.media.tracerShader;
p->type = P_SMOKE;
VectorCopy(org, p->org);
p->org[0] += (crandom() * x);
p->org[1] += (crandom() * y);
p->vel[0] = vel[0];
p->vel[1] = vel[1];
p->vel[2] = vel[2];
// Elder: old settings
//p->accel[0] = p->accel[1] = p->accel[2] = 0;
p->accel[0] = p->accel[1] = 0;
p->accel[2] = -PARTICLE_GRAVITY * 4;
p->vel[0] += (crandom() * 4);
p->vel[1] += (crandom() * 4);
p->vel[2] += (20 + (crandom() * 10)) * speed;
p->accel[0] = crandom() * 4;
p->accel[1] = crandom() * 4;
}
//Makro - snow
void CG_ParticleHitSnow(vec3_t org, vec3_t vel, int duration, float x, float y, float speed, float scale)
{
cparticle_t *p;
if (!free_particles)
{
CG_Printf(S_COLOR_RED "No particles left for sparks!!!\n");
return;
}
p = free_particles;
free_particles = p->next;
p->next = active_particles;
active_particles = p;
p->time = cg.time;
p->endtime = cg.time + duration;
p->startfade = cg.time + duration * 0.75;
//p->color = GREY75;
p->color = 0;
p->alpha = 0.8f;
p->alphavel = p->alpha / ((p->endtime - p->startfade) * .001f);
p->height = 4;
p->width = 4;
p->endheight = 16;
p->endwidth = 16;
p->pshader = cgs.media.snowImpactShader;
p->type = P_SMOKE;
VectorCopy(org, p->org);
p->org[0] += (crandom() * x);
p->org[1] += (crandom() * y);
p->vel[0] = vel[0];
p->vel[1] = vel[1];
p->vel[2] = vel[2];
p->accel[0] = crandom() * 4;
p->accel[1] = crandom() * 4;
p->accel[2] = -PARTICLE_GRAVITY * 4;
p->vel[0] += (crandom() * 8);
p->vel[1] += (crandom() * 8);
//p->vel[2] += (20 + (crandom() * 10)) * speed;
}
//Makro - grass
void CG_ParticleHitGrass(vec3_t org, vec3_t vel, int duration, float x, float y, float speed, float scale)
{
cparticle_t *p;
if (!free_particles)
return;
p = free_particles;
free_particles = p->next;
p->next = active_particles;
active_particles = p;
p->time = cg.time;
p->endtime = cg.time + duration;
p->startfade = cg.time + duration * 0.75;
p->color = GRASS;
p->alpha = 0.5f;
p->alphavel = 0;
p->height = 4;
p->width = 4;
p->endheight = 8;
p->endwidth = 8;
p->pshader = cgs.media.smokePuffShader;
p->type = P_SMOKE;
VectorCopy(org, p->org);
p->org[0] += (crandom() * x);
p->org[1] += (crandom() * y);
p->vel[0] = vel[0];
p->vel[1] = vel[1];
p->vel[2] = vel[2];
p->accel[0] = crandom() * 6;
p->accel[1] = crandom() * 6;
p->accel[2] = -PARTICLE_GRAVITY * 4;
p->vel[0] += (crandom() * 12);
p->vel[1] += (crandom() * 12);
//p->vel[2] += (20 + (crandom() * 10)) * speed;
}
//Makro - wall
void CG_ParticleHitWall(vec3_t org, vec3_t vel, int duration, float x, float y, float speed, float scale)
{
cparticle_t *p;
if (!free_particles)
return;
p = free_particles;
free_particles = p->next;
p->next = active_particles;
active_particles = p;
p->time = cg.time;
p->endtime = cg.time + duration;
p->startfade = cg.time + duration * 0.85;
p->color = 0;
p->alpha = 1.0f;
p->alphavel = 0;
p->roll = rand() % 179;
p->height = 3;
p->width = 3;
p->endheight = 2;
p->endwidth = 2;
p->pshader = cgs.media.particleImpactShader;
p->type = P_SMOKE;
VectorCopy(org, p->org);
p->org[0] += (crandom() * x);
p->org[1] += (crandom() * y);
p->vel[0] = vel[0];
p->vel[1] = vel[1];
p->vel[2] = vel[2];
p->accel[0] = crandom() * 6;
p->accel[1] = crandom() * 6;
p->accel[2] = -PARTICLE_GRAVITY * 4;
p->vel[0] += (crandom() * 24);
p->vel[1] += (crandom() * 24);
p->vel[2] += (crandom() * 24);
}
void CG_ParticleDust(centity_t * cent, vec3_t origin, vec3_t dir)
{
float length;
float dist;
float crittersize;
vec3_t angles, forward;
vec3_t point;
cparticle_t *p;
int i;
dist = 0;
VectorNegate(dir, dir);
length = VectorLength(dir);
vectoangles(dir, angles);
AngleVectors(angles, forward, NULL, NULL);
crittersize = LARGESIZE;
if (length)
dist = length / crittersize;
if (dist < 1)
dist = 1;
VectorCopy(origin, point);
for (i = 0; i < dist; i++) {
VectorMA(point, crittersize, forward, point);
if (!free_particles)
return;
p = free_particles;
free_particles = p->next;
p->next = active_particles;
active_particles = p;
p->time = cg.time;
p->alpha = 5.0;
p->alphavel = 0;
p->roll = 0;
p->pshader = cgs.media.smokePuffShader;
// RF, stay around for long enough to expand and dissipate naturally
if (length)
p->endtime = cg.time + 4500 + (crandom() * 3500);
else
p->endtime = cg.time + 750 + (crandom() * 500);
p->startfade = cg.time;
p->width = LARGESIZE;
p->height = LARGESIZE;
// RF, expand while falling
p->endheight = LARGESIZE * 3.0;
p->endwidth = LARGESIZE * 3.0;
if (!length) {
p->width *= 0.2f;
p->height *= 0.2f;
p->endheight = NORMALSIZE;
p->endwidth = NORMALSIZE;
}
p->type = P_SMOKE;
VectorCopy(point, p->org);
p->vel[0] = crandom() * 6;
p->vel[1] = crandom() * 6;
p->vel[2] = random() * 20;
// RF, add some gravity/randomness
p->accel[0] = crandom() * 3;
p->accel[1] = crandom() * 3;
p->accel[2] = -PARTICLE_GRAVITY * 0.4;
VectorClear(p->accel);
p->rotate = qfalse;
p->roll = rand() % 179;
p->alpha = 0.75;
}
}
void CG_ParticleMisc(qhandle_t pshader, vec3_t origin, int size, int duration, float alpha)
{
cparticle_t *p;
if (!pshader)
CG_Printf("^1CG_ParticleImpactSmokePuff pshader == ZERO!\n");
if (!free_particles)
return;
p = free_particles;
free_particles = p->next;
p->next = active_particles;
active_particles = p;
p->time = cg.time;
p->alpha = 1.0;
p->alphavel = 0;
p->roll = rand() % 179;
p->pshader = pshader;
if (duration > 0)
p->endtime = cg.time + duration;
else
p->endtime = duration;
p->startfade = cg.time;
p->width = size;
p->height = size;
p->endheight = size;
p->endwidth = size;
p->type = P_SPRITE;
VectorCopy(origin, p->org);
p->rotate = qfalse;
}
void CG_ParticleAir(vec3_t org, vec3_t vel, int duration, float alpha, float speed, float scale)
{
cparticle_t *p;
if (!free_particles)
return;
p = free_particles;
free_particles = p->next;
p->next = active_particles;
active_particles = p;
p->time = cg.time;
p->mtime = cg.time;
p->endtime = cg.time + duration;
p->startfade = cg.time + duration / 1.5;
if (rand() % 2)
p->color = DARK_BLUE_WATER;
else
p->color = LIGHT_BLUE_WATER;
p->alpha = alpha;
p->alphavel = p->alpha / ((p->endtime - p->startfade) * .0001f);
p->height = 1.0 * scale;
p->width = 1.0 * scale;
p->endheight = 1.0 * scale;
p->endwidth = 1.0 * scale;
p->pshader = cgs.media.waterBubbleShader;
p->type = P_SMOKE;
VectorCopy(org, p->org);
p->vel[0] = vel[0] * speed;
p->vel[1] = vel[1] * speed;
p->vel[2] = vel[2] * speed;
p->accel[0] = p->accel[1] = 0;
p->accel[2] = PARTICLE_GRAVITY * 8;
p->vel[0] += (crandom() * 40);
p->vel[1] += (crandom() * 40);
p->vel[2] += (20 + (crandom() * 40)) * speed;
}
void CG_ParticleSteam(vec3_t org, vec3_t vel, int duration, float alpha, float speed, float scale, int Shader)
{
trace_t tr;
vec3_t end, dist;
cparticle_t *p;
if (!free_particles)
return;
p = free_particles;
free_particles = p->next;
p->next = active_particles;
active_particles = p;
p->time = cg.time;
p->mtime = cg.time;
p->epsilon = 1.1f;
p->endtime = cg.time + duration;
p->startfade = cg.time;
p->alpha = alpha * 0.5f;
p->alphavel = p->alpha / ((p->endtime - p->startfade) * .0001f);
p->width = LARGESIZE * 0.06f;
p->height = LARGESIZE * 0.06f;
p->endheight = LARGESIZE * 0.70f;
p->endwidth = LARGESIZE * 0.70f;
p->rotate = qtrue;
p->roll = crandom() * 20;
p->pshader = Shader;
p->type = P_SMOKE;
VectorCopy(org, p->org);
p->vel[0] = vel[0] * speed;
p->vel[1] = vel[1] * speed;
p->vel[2] = vel[2] * speed;
p->vel[0] += (crandom() * 12);
p->vel[1] += (crandom() * 12);
p->vel[2] += (crandom() * 12);
// reflection stuff
VectorMA(org, 300, p->vel, end);
CG_Trace(&tr, org, NULL, NULL, end, 0, MASK_SOLID);
VectorSubtract(org, tr.endpos, dist);
p->reflectdistance = VectorLength(dist);
VectorCopy(tr.plane.normal, p->reflectnormal);
}
void CG_ParticleWater(vec3_t org, vec3_t vel, int duration, float alpha, float speed, float scale)
{
cparticle_t *p;
if (!free_particles)
return;
p = free_particles;
free_particles = p->next;
p->next = active_particles;
active_particles = p;
p->time = cg.time;
p->mtime = cg.time;
p->endtime = cg.time + duration;
p->startfade = cg.time + duration / 1.5;
if (rand() % 2)
p->color = DARK_BLUE_WATER;
else
p->color = LIGHT_BLUE_WATER;
p->alpha = alpha;
p->alphavel = p->alpha / ((p->endtime - p->startfade) * .0001f);
p->height = scale;
p->width = scale;
p->endheight = scale;
p->endwidth = scale;
p->pshader = cgs.media.smokePuffShader;
p->type = P_SMOKE;
VectorCopy(org, p->org);
p->vel[0] = vel[0] * speed;
p->vel[1] = vel[1] * speed;
p->vel[2] = vel[2] * speed;
p->accel[0] = p->accel[1] = 0;
p->accel[2] = -PARTICLE_GRAVITY * 8;
p->vel[0] += (crandom() * 40);
p->vel[1] += (crandom() * 40);
p->vel[2] += (20 + (crandom() * 40)) * speed;
}
Reference in a new issue View git blame Copy permalink