cl_particles.h File Reference

#include "qtypes.h"

Include dependency graph for cl_particles.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	particle_t
struct	particletype_t

Enumerations
enum	effectnameindex_t {   EFFECT_NONE , EFFECT_TE_GUNSHOT , EFFECT_TE_GUNSHOTQUAD , EFFECT_TE_SPIKE ,   EFFECT_TE_SPIKEQUAD , EFFECT_TE_SUPERSPIKE , EFFECT_TE_SUPERSPIKEQUAD , EFFECT_TE_WIZSPIKE ,   EFFECT_TE_KNIGHTSPIKE , EFFECT_TE_EXPLOSION , EFFECT_TE_EXPLOSIONQUAD , EFFECT_TE_TAREXPLOSION ,   EFFECT_TE_TELEPORT , EFFECT_TE_LAVASPLASH , EFFECT_TE_SMALLFLASH , EFFECT_TE_FLAMEJET ,   EFFECT_EF_FLAME , EFFECT_TE_BLOOD , EFFECT_TE_SPARK , EFFECT_TE_PLASMABURN ,   EFFECT_TE_TEI_G3 , EFFECT_TE_TEI_SMOKE , EFFECT_TE_TEI_BIGEXPLOSION , EFFECT_TE_TEI_PLASMAHIT ,   EFFECT_EF_STARDUST , EFFECT_TR_ROCKET , EFFECT_TR_GRENADE , EFFECT_TR_BLOOD ,   EFFECT_TR_WIZSPIKE , EFFECT_TR_SLIGHTBLOOD , EFFECT_TR_KNIGHTSPIKE , EFFECT_TR_VORESPIKE ,   EFFECT_TR_NEHAHRASMOKE , EFFECT_TR_NEXUIZPLASMA , EFFECT_TR_GLOWTRAIL , EFFECT_SVC_PARTICLE ,   EFFECT_TOTAL }
enum	pblend_t { PBLEND_ALPHA = 0 , PBLEND_ADD = 1 , PBLEND_INVMOD = 2 , PBLEND_INVALID = -1 }
enum	porientation_t {   PARTICLE_BILLBOARD = 0 , PARTICLE_SPARK = 1 , PARTICLE_ORIENTED_DOUBLESIDED = 2 , PARTICLE_VBEAM = 3 ,   PARTICLE_HBEAM = 4 , PARTICLE_INVALID = -1 }
enum	ptype_t {   pt_dead , pt_alphastatic , pt_static , pt_spark ,   pt_beam , pt_rain , pt_raindecal , pt_snow ,   pt_bubble , pt_blood , pt_smoke , pt_decal ,   pt_entityparticle , pt_explode , pt_explode2 , pt_total }

Functions
void	CL_EntityParticles (const struct entity_s *ent)
particle_t *	CL_NewParticle (const vec3_t sortorigin, unsigned short ptypeindex, int pcolor1, int pcolor2, int ptex, float psize, float psizeincrease, float palpha, float palphafade, float pgravity, float pbounce, float px, float py, float pz, float pvx, float pvy, float pvz, float pairfriction, float pliquidfriction, float originjitter, float velocityjitter, qbool pqualityreduction, float lifetime, float stretch, pblend_t blendmode, porientation_t orientation, int staincolor1, int staincolor2, int staintex, float stainalpha, float stainsize, float angle, float spin, float tint[4])
	Creates a new particle and returns a pointer to it.
particle_t *	CL_NewQuakeParticle (const vec3_t origin, const unsigned short ptypeindex, const int color_1, const int color_2, const float gravity, const float offset_x, const float offset_y, const float offset_z, const float velocity_offset_x, const float velocity_offset_y, const float velocity_offset_z, const float air_friction, const float liquid_friction, const float origin_jitter, const float velocity_jitter, const float lifetime)
	Creates a simple particle, a square like Quake, or a disc like GLQuake.
void	CL_ParseParticleEffect (void)
void	CL_ParticleBox (int effectindex, float pcount, const vec3_t originmins, const vec3_t originmaxs, const vec3_t velocitymins, const vec3_t velocitymaxs, struct entity_s *ent, int palettecolor, qbool spawndlight, qbool spawnparticles, float tintmins[4], float tintmaxs[4], float fade)
void	CL_ParticleCube (const vec3_t mins, const vec3_t maxs, const vec3_t dir, int count, int colorbase, vec_t gravity, vec_t randomvel)
void	CL_ParticleEffect (int effectindex, float pcount, const vec3_t originmins, const vec3_t originmaxs, const vec3_t velocitymins, const vec3_t velocitymaxs, struct entity_s *ent, int palettecolor)
int	CL_ParticleEffectIndexForName (const char *name)
const char *	CL_ParticleEffectNameForIndex (int i)
void	CL_ParticleExplosion (const vec3_t org)
void	CL_ParticleExplosion2 (const vec3_t org, int colorStart, int colorLength)
void	CL_ParticleRain (const vec3_t mins, const vec3_t maxs, const vec3_t dir, int count, int colorbase, int type)
void	CL_Particles_Clear (void)
void	CL_Particles_Init (void)
void	CL_Particles_Shutdown (void)
void	CL_ParticleTrail (int effectindex, float pcount, const vec3_t originmins, const vec3_t originmaxs, const vec3_t velocitymins, const vec3_t velocitymaxs, struct entity_s *ent, int palettecolor, qbool spawndlight, qbool spawnparticles, float tintmins[4], float tintmaxs[4], float fade)

Variables
struct cvar_s	cl_decals
struct cvar_s	cl_decals_fadetime
struct cvar_s	cl_decals_time
struct cvar_s	cl_particles
struct cvar_s	cl_particles_blood
struct cvar_s	cl_particles_blood_alpha
struct cvar_s	cl_particles_blood_bloodhack
struct cvar_s	cl_particles_blood_decal_alpha
struct cvar_s	cl_particles_blood_decal_scalemax
struct cvar_s	cl_particles_blood_decal_scalemin
struct cvar_s	cl_particles_bubbles
struct cvar_s	cl_particles_bulletimpacts
struct cvar_s	cl_particles_explosions_shell
struct cvar_s	cl_particles_explosions_sparks
struct cvar_s	cl_particles_quake
struct cvar_s	cl_particles_quality
struct cvar_s	cl_particles_rain
struct cvar_s	cl_particles_size
struct cvar_s	cl_particles_smoke
struct cvar_s	cl_particles_smoke_alpha
struct cvar_s	cl_particles_smoke_alphafade
struct cvar_s	cl_particles_snow
struct cvar_s	cl_particles_sparks

Enumeration Type Documentation

effectnameindex_t

enum effectnameindex_t

Enumerator
EFFECT_NONE
EFFECT_TE_GUNSHOT
EFFECT_TE_GUNSHOTQUAD
EFFECT_TE_SPIKE
EFFECT_TE_SPIKEQUAD
EFFECT_TE_SUPERSPIKE
EFFECT_TE_SUPERSPIKEQUAD
EFFECT_TE_WIZSPIKE
EFFECT_TE_KNIGHTSPIKE
EFFECT_TE_EXPLOSION
EFFECT_TE_EXPLOSIONQUAD
EFFECT_TE_TAREXPLOSION
EFFECT_TE_TELEPORT
EFFECT_TE_LAVASPLASH
EFFECT_TE_SMALLFLASH
EFFECT_TE_FLAMEJET
EFFECT_EF_FLAME
EFFECT_TE_BLOOD
EFFECT_TE_SPARK
EFFECT_TE_PLASMABURN
EFFECT_TE_TEI_G3
EFFECT_TE_TEI_SMOKE
EFFECT_TE_TEI_BIGEXPLOSION
EFFECT_TE_TEI_PLASMAHIT
EFFECT_EF_STARDUST
EFFECT_TR_ROCKET
EFFECT_TR_GRENADE
EFFECT_TR_BLOOD
EFFECT_TR_WIZSPIKE
EFFECT_TR_SLIGHTBLOOD
EFFECT_TR_KNIGHTSPIKE
EFFECT_TR_VORESPIKE
EFFECT_TR_NEHAHRASMOKE
EFFECT_TR_NEXUIZPLASMA
EFFECT_TR_GLOWTRAIL
EFFECT_SVC_PARTICLE
EFFECT_TOTAL

Definition at line 128 of file cl_particles.h.

{
    EFFECT_NONE,
    EFFECT_TE_GUNSHOT,
    EFFECT_TE_GUNSHOTQUAD,
    EFFECT_TE_SPIKE,
    EFFECT_TE_SPIKEQUAD,
    EFFECT_TE_SUPERSPIKE,
    EFFECT_TE_SUPERSPIKEQUAD,
    EFFECT_TE_WIZSPIKE,
    EFFECT_TE_KNIGHTSPIKE,
    EFFECT_TE_EXPLOSION,
    EFFECT_TE_EXPLOSIONQUAD,
    EFFECT_TE_TAREXPLOSION,
    EFFECT_TE_TELEPORT,
    EFFECT_TE_LAVASPLASH,
    EFFECT_TE_SMALLFLASH,
    EFFECT_TE_FLAMEJET,
    EFFECT_EF_FLAME,
    EFFECT_TE_BLOOD,
    EFFECT_TE_SPARK,
    EFFECT_TE_PLASMABURN,
    EFFECT_TE_TEI_G3,
    EFFECT_TE_TEI_SMOKE,
    EFFECT_TE_TEI_BIGEXPLOSION,
    EFFECT_TE_TEI_PLASMAHIT,
    EFFECT_EF_STARDUST,
    EFFECT_TR_ROCKET,
    EFFECT_TR_GRENADE,
    EFFECT_TR_BLOOD,
    EFFECT_TR_WIZSPIKE,
    EFFECT_TR_SLIGHTBLOOD,
    EFFECT_TR_KNIGHTSPIKE,
    EFFECT_TR_VORESPIKE,
    EFFECT_TR_NEHAHRASMOKE,
    EFFECT_TR_NEXUIZPLASMA,
    EFFECT_TR_GLOWTRAIL,
    EFFECT_SVC_PARTICLE,
    EFFECT_TOTAL
}

pblend_t

enum pblend_t

Enumerator
PBLEND_ALPHA
PBLEND_ADD
PBLEND_INVMOD
PBLEND_INVALID

Definition at line 42 of file cl_particles.h.

{
    PBLEND_ALPHA = 0,
    PBLEND_ADD = 1,
    PBLEND_INVMOD = 2,
    PBLEND_INVALID = -1
}

porientation_t

enum porientation_t

Enumerator
PARTICLE_BILLBOARD
PARTICLE_SPARK
PARTICLE_ORIENTED_DOUBLESIDED
PARTICLE_VBEAM
PARTICLE_HBEAM
PARTICLE_INVALID

Definition at line 31 of file cl_particles.h.

{
    PARTICLE_BILLBOARD = 0,
    PARTICLE_SPARK = 1,
    PARTICLE_ORIENTED_DOUBLESIDED = 2,
    PARTICLE_VBEAM = 3,
    PARTICLE_HBEAM = 4,
    PARTICLE_INVALID = -1
}

ptype_t

enum ptype_t

Enumerator
pt_dead
pt_alphastatic
pt_static
pt_spark
pt_beam
pt_rain
pt_raindecal
pt_snow
pt_bubble
pt_blood
pt_smoke
pt_decal
pt_entityparticle
pt_explode
pt_explode2
pt_total

Definition at line 59 of file cl_particles.h.

{
    pt_dead,
    pt_alphastatic,
    pt_static,
    pt_spark,
    pt_beam,
    pt_rain,
    pt_raindecal,
    pt_snow,
    pt_bubble,
    pt_blood,
    pt_smoke,
    pt_decal,
    pt_entityparticle,
    pt_explode,   // used for Quake-style explosion particle colour ramping
    pt_explode2,  // used for Quake-style explosion particle colour ramping
    pt_total
}

Function Documentation

CL_EntityParticles()

void CL_EntityParticles

(

const struct entity_s *

ent

)

CL_NewParticle()

particle_t * CL_NewParticle	(	const vec3_t	sortorigin,
		unsigned short	ptypeindex,
		int	pcolor1,
		int	pcolor2,
		int	ptex,
		float	psize,
		float	psizeincrease,
		float	palpha,
		float	palphafade,
		float	pgravity,
		float	pbounce,
		float	px,
		float	py,
		float	pz,
		float	pvx,
		float	pvy,
		float	pvz,
		float	pairfriction,
		float	pliquidfriction,
		float	originjitter,
		float	velocityjitter,
		qbool	pqualityreduction,
		float	lifetime,
		float	stretch,
		pblend_t	blendmode,
		porientation_t	orientation,
		int	staincolor1,
		int	staincolor2,
		int	staintex,
		float	stainalpha,
		float	stainsize,
		float	angle,
		float	spin,
		float	tint[4] )

Creates a new particle and returns a pointer to it.

Parameters

[in]	sortorigin	?
[in]	ptypeindex	Any of the pt_ enum values (pt_static, pt_blood, etc), see ptype_t near the top of this file
[in]	pcolor1,pcolor2	Minimum and maximum range of color, randomly interpolated with pcolor2 to decide particle color
[in]	ptex	Any of the tex_ values such as tex_smoke[rand()&7] or tex_particle
[in]	psize	Size of particle (or thickness for PARTICLE_SPARK and PARTICLE_*BEAM)
[in]	psizeincrease	?
[in]	palpha	Opacity of particle as 0-255 (can be more than 255)
[in]	palphafade	Rate of fade per second (so 256 would mean a 256 alpha particle would fade to nothing in 1 second)
[in]	pgravity	How much effect gravity has on the particle (0-1)
[in]	pbounce	How much bounce the particle has when it hits a surface (0-1), -1 makes a blood splat when it hits a surface, 0 does not even check for collisions
[in]	px,py,pz	Starting origin of particle
[in]	pvx,pvy,pvz	Starting velocity of particle
[in]	pairfriction	How much the particle slows down, in air, per second (0-1 typically, can slowdown faster than 1)
[in]	pliquidfriction	How much the particle slows down, in liquids, per second (0-1 typically, can slowdown faster than 1)
[in]	originjitter	?
[in]	velocityjitter	?
[in]	pqualityreduction	?
[in]	lifetime	How long the particle can live (note it is also removed if alpha drops to nothing)
[in]	stretch	?
[in]	blendmode	One of the PBLEND_ values
[in]	orientation	One of the PARTICLE_ values
[in]	staincolor1	Minimum and maximum ranges of stain color, randomly interpolated to decide stain color (-1 to use none)
[in]	staincolor2	Minimum and maximum ranges of stain color, randomly interpolated to decide stain color (-1 to use none)
[in]	staintex	Any of the tex_ values such as tex_smoke[rand()&7] or tex_particle
[in]	angle	Base rotation of the particle geometry around its center normal
[in]	spin	Rotation speed of the particle geometry around its center normal
[in]	tint	The tint

Returns

Pointer to the new particle

Definition at line 668 of file cl_particles.c.

{
    int l1, l2, r, g, b;
    particle_t *part;
    vec3_t v;
    if (!cl_particles.integer)
        return NULL;
    for (;cl.free_particle < cl.max_particles && cl.particles[cl.free_particle].typeindex;cl.free_particle++);
    if (cl.free_particle >= cl.max_particles)
        return NULL;
    if (!lifetime)
        lifetime = palpha / min(1, palphafade);
    part = &cl.particles[cl.free_particle++];
    if (cl.num_particles < cl.free_particle)
        cl.num_particles = cl.free_particle;
    memset(part, 0, sizeof(*part));
    VectorCopy(sortorigin, part->sortorigin);
    part->typeindex = ptypeindex;
    part->blendmode = blendmode;
    if(orientation == PARTICLE_HBEAM || orientation == PARTICLE_VBEAM)
    {
        particletexture_t *tex = &particletexture[ptex];
        if(tex->t1 == 0 && tex->t2 == 1) // full height of texture?
            part->orientation = PARTICLE_VBEAM;
        else
            part->orientation = PARTICLE_HBEAM;
    }
    else
        part->orientation = orientation;
    l2 = (int)lhrandom(0.5, 256.5);
    l1 = 256 - l2;
    part->color[0] = ((((pcolor1 >> 16) & 0xFF) * l1 + ((pcolor2 >> 16) & 0xFF) * l2) >> 8) & 0xFF;
    part->color[1] = ((((pcolor1 >>  8) & 0xFF) * l1 + ((pcolor2 >>  8) & 0xFF) * l2) >> 8) & 0xFF;
    part->color[2] = ((((pcolor1 >>  0) & 0xFF) * l1 + ((pcolor2 >>  0) & 0xFF) * l2) >> 8) & 0xFF;
    if (vid.sRGB3D)
    {
        part->color[0] = (unsigned char)floor(Image_LinearFloatFromsRGB(part->color[0]) * 255.0f + 0.5f);
        part->color[1] = (unsigned char)floor(Image_LinearFloatFromsRGB(part->color[1]) * 255.0f + 0.5f);
        part->color[2] = (unsigned char)floor(Image_LinearFloatFromsRGB(part->color[2]) * 255.0f + 0.5f);
    }
    part->alpha = palpha;
    part->alphafade = palphafade;
    part->staintexnum = staintex;
    if(staincolor1 >= 0 && staincolor2 >= 0)
    {
        l2 = (int)lhrandom(0.5, 256.5);
        l1 = 256 - l2;
        if(blendmode == PBLEND_INVMOD)
        {
            r = ((((staincolor1 >> 16) & 0xFF) * l1 + ((staincolor2 >> 16) & 0xFF) * l2) * (255 - part->color[0])) / 0x8000; // staincolor 0x808080 keeps color invariant
            g = ((((staincolor1 >>  8) & 0xFF) * l1 + ((staincolor2 >>  8) & 0xFF) * l2) * (255 - part->color[1])) / 0x8000;
            b = ((((staincolor1 >>  0) & 0xFF) * l1 + ((staincolor2 >>  0) & 0xFF) * l2) * (255 - part->color[2])) / 0x8000;
        }
        else
        {
            r = ((((staincolor1 >> 16) & 0xFF) * l1 + ((staincolor2 >> 16) & 0xFF) * l2) * part->color[0]) / 0x8000; // staincolor 0x808080 keeps color invariant
            g = ((((staincolor1 >>  8) & 0xFF) * l1 + ((staincolor2 >>  8) & 0xFF) * l2) * part->color[1]) / 0x8000;
            b = ((((staincolor1 >>  0) & 0xFF) * l1 + ((staincolor2 >>  0) & 0xFF) * l2) * part->color[2]) / 0x8000;
        }
        if(r > 0xFF) r = 0xFF;
        if(g > 0xFF) g = 0xFF;
        if(b > 0xFF) b = 0xFF;
    }
    else
    {
        r = part->color[0]; // -1 is shorthand for stain = particle color
        g = part->color[1];
        b = part->color[2];
    }
    part->staincolor[0] = r;
    part->staincolor[1] = g;
    part->staincolor[2] = b;
    part->stainalpha = palpha * stainalpha;
    part->stainsize = psize * stainsize;
    if(tint)
    {
        if(blendmode != PBLEND_INVMOD) // invmod is immune to tinting
        {
            part->color[0] *= tint[0];
            part->color[1] *= tint[1];
            part->color[2] *= tint[2];
        }
        part->alpha *= tint[3];
        part->alphafade *= tint[3];
        part->stainalpha *= tint[3];
    }
    part->texnum = ptex;
    part->size = psize;
    part->sizeincrease = psizeincrease;
    part->gravity = pgravity;
    part->bounce = pbounce;
    part->stretch = stretch;
    VectorRandom(v);
    part->org[0] = px + originjitter * v[0];
    part->org[1] = py + originjitter * v[1];
    part->org[2] = pz + originjitter * v[2];
    part->vel[0] = pvx + velocityjitter * v[0];
    part->vel[1] = pvy + velocityjitter * v[1];
    part->vel[2] = pvz + velocityjitter * v[2];
    part->airfriction = pairfriction;
    part->liquidfriction = pliquidfriction;
    part->die = cl.time + lifetime;
    part->delayedspawn = cl.time;
//  part->delayedcollisions = 0;
    part->qualityreduction = pqualityreduction;
    part->angle = angle;
    part->spin = spin;
    // if it is rain or snow, trace ahead and shut off collisions until an actual collision event needs to occur to improve performance
    if (part->typeindex == pt_rain)
    {
        int i;
        particle_t *part2;
        vec3_t endvec;
        trace_t trace;
        // turn raindrop into simple spark and create delayedspawn splash effect
        part->typeindex = pt_spark;
        part->bounce = 0;
        VectorMA(part->org, lifetime, part->vel, endvec);
        trace = CL_TraceLine(part->org, endvec, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_LIQUIDSMASK, 0, 0, collision_extendmovelength.value, true, false, NULL, false, false);
        part->die = cl.time + lifetime * trace.fraction;
        part2 = CL_NewParticle(endvec, pt_raindecal, pcolor1, pcolor2, tex_rainsplash, part->size, part->size * 20, part->alpha, part->alpha / 0.4, 0, 0, trace.endpos[0] + trace.plane.normal[0], trace.endpos[1] + trace.plane.normal[1], trace.endpos[2] + trace.plane.normal[2], trace.plane.normal[0], trace.plane.normal[1], trace.plane.normal[2], 0, 0, 0, 0, pqualityreduction, 0, 1, PBLEND_ADD, PARTICLE_ORIENTED_DOUBLESIDED, -1, -1, -1, 1, 1, 0, 0, NULL);
        if (part2)
        {
            part2->delayedspawn = part->die;
            part2->die += part->die - cl.time;
            for (i = rand() & 7;i < 10;i++)
            {
                part2 = CL_NewParticle(endvec, pt_spark, pcolor1, pcolor2, tex_particle, 0.25f, 0, part->alpha * 2, part->alpha * 4, 1, 0.1, trace.endpos[0] + trace.plane.normal[0], trace.endpos[1] + trace.plane.normal[1], trace.endpos[2] + trace.plane.normal[2], trace.plane.normal[0] * 16, trace.plane.normal[1] * 16, trace.plane.normal[2] * 16 + cl.movevars_gravity * 0.04, 0, 0, 0, 32, pqualityreduction, 0, 1, PBLEND_ADD, PARTICLE_SPARK, -1, -1, -1, 1, 1, 0, 0, NULL);
                if (part2)
                {
                    part2->delayedspawn = part->die;
                    part2->die += part->die - cl.time;
                }
            }
        }
    }
    else if (part->typeindex == pt_explode || part->typeindex == pt_explode2)
        part->time2 = rand()&3; // time2 is used to progress the colour ramp index
 
#if 0
    else if (part->bounce != 0 && part->gravity == 0 && part->typeindex != pt_snow)
    {
        float lifetime = part->alpha / (part->alphafade ? part->alphafade : 1);
        vec3_t endvec;
        trace_t trace;
        VectorMA(part->org, lifetime, part->vel, endvec);
        trace = CL_TraceLine(part->org, endvec, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY, true, false, NULL, false);
        part->delayedcollisions = cl.time + lifetime * trace.fraction - 0.1;
    }
#endif
 
    return part;
}

References particle_t::airfriction, particle_t::alpha, particle_t::alphafade, particle_t::angle, b, particle_t::blendmode, particle_t::bounce, cl, CL_NewParticle(), cl_particles, CL_TraceLine(), collision_extendmovelength, particle_t::color, particle_t::delayedspawn, particle_t::die, trace_t::endpos, floor(), trace_t::fraction, client_state_t::free_particle, g, particle_t::gravity, i, Image_LinearFloatFromsRGB, int(), cvar_t::integer, lhrandom, particle_t::liquidfriction, client_state_t::max_particles, min, MOVE_NOMONSTERS, client_state_t::movevars_gravity, plane_t::normal, NULL, client_state_t::num_particles, particle_t::org, particle_t::orientation, PARTICLE_HBEAM, PARTICLE_ORIENTED_DOUBLESIDED, PARTICLE_SPARK, PARTICLE_VBEAM, client_state_t::particles, particletexture, PBLEND_ADD, PBLEND_INVMOD, trace_t::plane, pt_explode, pt_explode2, pt_rain, pt_raindecal, pt_snow, pt_spark, px, particle_t::qualityreduction, r, particle_t::size, particle_t::sizeincrease, particle_t::sortorigin, particle_t::spin, viddef_t::sRGB3D, particle_t::stainalpha, particle_t::staincolor, particle_t::stainsize, particle_t::staintexnum, particle_t::stretch, SUPERCONTENTS_BODY, SUPERCONTENTS_LIQUIDSMASK, SUPERCONTENTS_SOLID, particletexture_t::t1, particletexture_t::t2, tex_particle, tex_rainsplash, particle_t::texnum, client_state_t::time, particle_t::time2, particle_t::typeindex, v, cvar_t::value, VectorCopy, VectorMA, VectorRandom, particle_t::vel, and vid.

Referenced by CL_EntityParticles(), CL_NewParticle(), CL_NewParticlesFromEffectinfo(), CL_NewQuakeParticle(), CL_ParticleCube(), CL_ParticleEffect_Fallback(), CL_ParticleExplosion(), CL_ParticleExplosion2(), CL_ParticleRain(), CL_ReadPointFile_f(), CL_Smoke(), CL_Sparks(), VM_CL_SpawnParticle(), and VM_CL_SpawnParticleDelayed().

CL_NewQuakeParticle()

particle_t * CL_NewQuakeParticle	(	const vec3_t	origin,
		const unsigned short	ptypeindex,
		const int	color_1,
		const int	color_2,
		const float	gravity,
		const float	offset_x,
		const float	offset_y,
		const float	offset_z,
		const float	velocity_offset_x,
		const float	velocity_offset_y,
		const float	velocity_offset_z,
		const float	air_friction,
		const float	liquid_friction,
		const float	origin_jitter,
		const float	velocity_jitter,
		const float	lifetime )

Creates a simple particle, a square like Quake, or a disc like GLQuake.

Parameters

[in]	origin	?
[in]	color_1,color_2	Minimum and maximum range of color, randomly interpolated with pcolor2 to decide particle color
[in]	gravity	How much effect gravity has on the particle (0-1)
[in]	offset_x,offset_y,offset_z	Starting origin of particle
[in]	velocity_offset_x,velocity_offset_y,velocity_offset_z	Starting velocity of particle
[in]	air_friction	How much the particle slows down, in air, per second (0-1 typically, can slowdown faster than 1)
[in]	liquid_friction	How much the particle slows down, in liquids, per second (0-1 typically, can slowdown faster than 1)
[in]	origin_jitter	?
[in]	velocity_jitter	?
[in]	lifetime	How long the particle can live (note it is also removed if alpha drops to nothing)

Returns

Pointer to the new particle

Definition at line 869 of file cl_particles.c.

{
    int texture;
 
    // Set the particle texture based on the value of cl_particles_quake; defaulting to the GLQuake disc
    if (cl_particles_quake.integer == 2)
        texture = tex_square;
    else
        texture = tex_particle;
 
    return CL_NewParticle(
        origin,
        ptypeindex,          // type
        color_1,
        color_2,
        texture,
        0.8f,                // size
        0,                   // size increase
        255,                 // alpha
        0,                   // alpha fade
        gravity,
        0,                   // bounce
        offset_x,
        offset_y,
        offset_z,
        velocity_offset_x,
        velocity_offset_y,
        velocity_offset_z,
        air_friction,
        liquid_friction,
        origin_jitter,
        velocity_jitter,
        true,                // quality reduction
        lifetime,
        1,                   // stretch
        PBLEND_ALPHA,        // blend mode
        PARTICLE_BILLBOARD,  // orientation
        -1,                  // stain color 1
        -1,                  // stain color 2
        -1,                  // stain texture
        1,                   // stain alpha
        1,                   // stain size
        0,                   // angle
        0,                   // spin
        NULL                 // tint
    );
}

References CL_NewParticle(), cl_particles_quake, cvar_t::integer, NULL, origin, PARTICLE_BILLBOARD, PBLEND_ALPHA, tex_particle, tex_square, and texture.

Referenced by CL_ParticleEffect_Fallback(), CL_ParticleExplosion(), and CL_ParticleExplosion2().

CL_ParseParticleEffect()

void CL_ParseParticleEffect

(

void

)

Definition at line 1914 of file cl_particles.c.

{
    vec3_t org, dir;
    int i, count, msgcount, color;
 
    MSG_ReadVector(&cl_message, org, cls.protocol);
    for (i=0 ; i<3 ; i++)
        dir[i] = MSG_ReadChar(&cl_message) * (1.0 / 16.0);
    msgcount = MSG_ReadByte(&cl_message);
    color = MSG_ReadByte(&cl_message);
 
    if (msgcount == 255)
        count = 1024;
    else
        count = msgcount;
 
    CL_ParticleEffect(EFFECT_SVC_PARTICLE, count, org, org, dir, dir, NULL, color);
}

References cl_message, CL_ParticleEffect(), cls, color, count, dir, EFFECT_SVC_PARTICLE, i, MSG_ReadByte, MSG_ReadChar, MSG_ReadVector(), NULL, and client_static_t::protocol.

Referenced by CL_ParseServerMessage().

CL_ParticleBox()

void CL_ParticleBox	(	int	effectindex,
		float	pcount,
		const vec3_t	originmins,
		const vec3_t	originmaxs,
		const vec3_t	velocitymins,
		const vec3_t	velocitymaxs,
		struct entity_s *	ent,
		int	palettecolor,
		qbool	spawndlight,
		qbool	spawnparticles,
		float	tintmins[4],
		float	tintmaxs[4],
		float	fade )

CL_ParticleCube()

void CL_ParticleCube	(	const vec3_t	mins,
		const vec3_t	maxs,
		const vec3_t	dir,
		int	count,
		int	colorbase,
		vec_t	gravity,
		vec_t	randomvel )

Definition at line 2073 of file cl_particles.c.

{
    vec3_t center;
    int k;
    if (!cl_particles.integer) return;
    VectorMAM(0.5f, mins, 0.5f, maxs, center);
 
    count = (int)(count * cl_particles_quality.value);
    while (count--)
    {
        k = particlepalette[colorbase + (rand()&3)];
        CL_NewParticle(center, pt_alphastatic, k, k, tex_particle, 2, 0, 255, 128, gravity, 0, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(mins[2], maxs[2]), dir[0], dir[1], dir[2], 0, 0, 0, randomvel, true, 0, 1, PBLEND_ALPHA, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
    }
}

References CL_NewParticle(), cl_particles, cl_particles_quality, count, dir, int(), cvar_t::integer, lhrandom, maxs, mins, NULL, PARTICLE_BILLBOARD, particlepalette, PBLEND_ALPHA, pt_alphastatic, tex_particle, cvar_t::value, and VectorMAM.

Referenced by CL_ParseTempEntity(), and VM_CL_te_particlecube().

CL_ParticleEffect()

void CL_ParticleEffect	(	int	effectindex,
		float	pcount,
		const vec3_t	originmins,
		const vec3_t	originmaxs,
		const vec3_t	velocitymins,
		const vec3_t	velocitymaxs,
		struct entity_s *	ent,
		int	palettecolor )

CL_ParticleEffectIndexForName()

int CL_ParticleEffectIndexForName

(

const char *

name

)

Definition at line 481 of file cl_particles.c.

{
    int i;
    for (i = 1;i < MAX_PARTICLEEFFECTNAME && particleeffectname[i][0];i++)
        if (!strcmp(particleeffectname[i], name))
            return i;
    return 0;
}

References i, MAX_PARTICLEEFFECTNAME, name, and particleeffectname.

Referenced by VM_CL_particleeffectnum().

CL_ParticleEffectNameForIndex()

const char * CL_ParticleEffectNameForIndex

(

int

i

)

Definition at line 490 of file cl_particles.c.

{
    if (i < 1 || i >= MAX_PARTICLEEFFECTNAME)
        return NULL;
    return particleeffectname[i];
}

References i, MAX_PARTICLEEFFECTNAME, NULL, and particleeffectname.

CL_ParticleExplosion()

void CL_ParticleExplosion

(

const vec3_t

org

)

Definition at line 1939 of file cl_particles.c.

{
    int i;
    trace_t trace;
 
    R_Stain(org, 96, 40, 40, 40, 64, 88, 88, 88, 64);
    CL_SpawnDecalParticleForPoint(org, 40, 48, 255, tex_bulletdecal[rand()&7], 0xFFFFFF, 0xFFFFFF);
 
    if (cl_particles_quake.integer)
    {
        for (i = 0; i < 1024; i++)
        {
            int color;
            int r = rand()&3;
 
            if (i & 1)
            {
                color = particlepalette[ramp1[r]];
 
                CL_NewQuakeParticle(
                    org,
                    pt_explode,
                    color, color,
                    0.05,                        // gravity
                    org[0], org[1], org[2],      // offset
                    0, 0, 0,                     // velocity
                    2,                           // air friction
                    0,                           // liquid friction
                    16,                          // origin jitter
                    256,                         // velocity jitter
                    5                            // lifetime
                );
            }
            else
            {
                color = particlepalette[ramp2[r]];
 
                CL_NewQuakeParticle(
                    org,
                    pt_explode2,
                    color, color,
                    0.05,                        // gravity
                    org[0], org[1], org[2],      // offset
                    0, 0, 0,                     // velocity
                    0,                           // air friction
                    0,                           // liquid friction
                    16,                          // origin jitter
                    256,                         // velocity jitter
                    5                            // lifetime
                );
            }
        }
    }
    else
    {
        i = CL_PointSuperContents(org);
        if (i & (SUPERCONTENTS_SLIME | SUPERCONTENTS_WATER))
        {
            if (cl_particles.integer && cl_particles_bubbles.integer)
                for (i = 0;i < 128 * cl_particles_quality.value;i++)
                    CL_NewParticle(org, pt_bubble, 0x404040, 0x808080, tex_bubble, 2, 0, lhrandom(128, 255), 128, -0.125, 1.5, org[0], org[1], org[2], 0, 0, 0, 0.0625, 0.25, 16, 96, true, 0, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
        }
        else
        {
            if (cl_particles.integer && cl_particles_sparks.integer && cl_particles_explosions_sparks.integer)
            {
                for (i = 0;i < 512 * cl_particles_quality.value;i++)
                {
                    int k = 0;
                    vec3_t v, v2;
                    do
                    {
                        VectorRandom(v2);
                        VectorMA(org, 128, v2, v);
                        trace = CL_TraceLine(org, v, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID, 0, 0, collision_extendmovelength.value, true, false, NULL, false, false);
                    }
                    while (k++ < 16 && trace.fraction < 0.1f);
                    VectorSubtract(trace.endpos, org, v2);
                    VectorScale(v2, 2.0f, v2);
                    CL_NewParticle(org, pt_spark, 0x903010, 0xFFD030, tex_particle, 1.0f, 0, lhrandom(0, 255), 512, 0, 0, org[0], org[1], org[2], v2[0], v2[1], v2[2], 0, 0, 0, 0, true, 0, 1, PBLEND_ADD, PARTICLE_SPARK, -1, -1, -1, 1, 1, 0, 0, NULL);
                }
            }
        }
    }
 
    if (cl_particles_explosions_shell.integer)
        R_NewExplosion(org);
}

References CL_NewParticle(), CL_NewQuakeParticle(), cl_particles, cl_particles_bubbles, cl_particles_explosions_shell, cl_particles_explosions_sparks, cl_particles_quake, cl_particles_quality, cl_particles_sparks, CL_PointSuperContents, CL_SpawnDecalParticleForPoint(), CL_TraceLine(), collision_extendmovelength, color, trace_t::endpos, trace_t::fraction, i, cvar_t::integer, lhrandom, MOVE_NOMONSTERS, NULL, PARTICLE_BILLBOARD, PARTICLE_SPARK, particlepalette, PBLEND_ADD, pt_bubble, pt_explode, pt_explode2, pt_spark, r, R_NewExplosion(), R_Stain(), ramp1, ramp2, SUPERCONTENTS_SLIME, SUPERCONTENTS_SOLID, SUPERCONTENTS_WATER, tex_bubble, tex_bulletdecal, tex_particle, v, v2, cvar_t::value, VectorMA, VectorRandom, VectorScale, and VectorSubtract.

Referenced by CL_ParseTempEntity(), CL_ParticleEffect_Fallback(), and VM_CL_te_explosionrgb().

CL_ParticleExplosion2()

void CL_ParticleExplosion2	(	const vec3_t	org,
		int	colorStart,
		int	colorLength )

Definition at line 2034 of file cl_particles.c.

{
    int i, k;
    if (!cl_particles.integer) return;
 
    for (i = 0;i < 512 * cl_particles_quality.value;i++)
    {
        k = particlepalette[colorStart + (i % colorLength)];
        if (cl_particles_quake.integer)
            CL_NewQuakeParticle(org, pt_alphastatic, k, k, 0, org[0], org[1], org[2], 0, 0, 0, -4, -4, 16, 256, 0.3);
        else
            CL_NewParticle(org, pt_alphastatic, k, k, tex_particle, lhrandom(0.5, 1.5), 0, 255, 512, 0, 0, org[0], org[1], org[2], 0, 0, 0, lhrandom(1.5, 3), lhrandom(1.5, 3), 8, 192, true, 0, 1, PBLEND_ALPHA, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
    }
}

References CL_NewParticle(), CL_NewQuakeParticle(), cl_particles, cl_particles_quake, cl_particles_quality, i, cvar_t::integer, lhrandom, NULL, PARTICLE_BILLBOARD, particlepalette, PBLEND_ALPHA, pt_alphastatic, tex_particle, and cvar_t::value.

Referenced by CL_ParseTempEntity(), and VM_CL_te_explosion2().

CL_ParticleRain()

void CL_ParticleRain	(	const vec3_t	mins,
		const vec3_t	maxs,
		const vec3_t	dir,
		int	count,
		int	colorbase,
		int	type )

Definition at line 2088 of file cl_particles.c.

{
    int k;
    float minz, maxz, lifetime = 30;
    float particle_size;
    vec3_t org;
 
    if (!cl_particles.integer) return;
    if (dir[2] < 0) // falling
    {
        minz = maxs[2] + dir[2] * 0.1;
        maxz = maxs[2];
        if (cl.worldmodel)
            lifetime = (maxz - cl.worldmodel->normalmins[2]) / max(1, -dir[2]);
    }
    else // rising??
    {
        minz = mins[2];
        maxz = maxs[2] + dir[2] * 0.1;
        if (cl.worldmodel)
            lifetime = (cl.worldmodel->normalmaxs[2] - minz) / max(1, dir[2]);
    }
 
    count = (int)(count * cl_particles_quality.value);
 
    switch(type)
    {
    case 0:
        if (!cl_particles_rain.integer) break;
 
        count *= 4; // ick, this should be in the mod or maps?
        particle_size = (gamemode == GAME_GOODVSBAD2) ? 20 : 0.5;
 
        while(count--)
        {
            k = particlepalette[colorbase + (rand()&3)];
            VectorSet(org, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz));
            CL_NewParticle(org, pt_rain, k, k, tex_particle, particle_size, 0, lhrandom(32, 64), 0, 0, -1, org[0], org[1], org[2], dir[0], dir[1], dir[2], 0, 0, 0, 0, true, lifetime, 1, PBLEND_ADD, PARTICLE_SPARK, -1, -1, -1, 1, 1, 0, 0, NULL);
        }
        break;
    case 1:
        if (!cl_particles_snow.integer) break;
 
        particle_size = (gamemode == GAME_GOODVSBAD2) ? 20 : 1.0;
 
        while(count--)
        {
            k = particlepalette[colorbase + (rand()&3)];
            VectorSet(org, lhrandom(mins[0], maxs[0]), lhrandom(mins[1], maxs[1]), lhrandom(minz, maxz));
            CL_NewParticle(org, pt_snow, k, k, tex_particle, 1, 0, lhrandom(64, 128), 0, 0, -1, org[0], org[1], org[2], dir[0], dir[1], dir[2], 0, 0, 0, 0, true, lifetime, 1, PBLEND_ADD, PARTICLE_BILLBOARD, -1, -1, -1, 1, 1, 0, 0, NULL);
        }
        break;
    default:
        Con_Printf ("CL_ParticleRain: unknown type %i (0 = rain, 1 = snow)\n", type);
    }
}

References cl, CL_NewParticle(), cl_particles, cl_particles_quality, cl_particles_rain, cl_particles_snow, Con_Printf(), count, dir, GAME_GOODVSBAD2, gamemode, int(), cvar_t::integer, lhrandom, max, maxs, mins, NULL, PARTICLE_BILLBOARD, particle_size, PARTICLE_SPARK, particlepalette, PBLEND_ADD, pt_rain, pt_snow, tex_particle, type, cvar_t::value, VectorSet, and client_state_t::worldmodel.

Referenced by CL_ParseTempEntity(), VM_CL_te_particlerain(), and VM_CL_te_particlesnow().

CL_Particles_Clear()

void CL_Particles_Clear

(

void

)

CL_Particles_Init()

void CL_Particles_Init

(

void

)

Definition at line 586 of file cl_particles.c.

{
    Cmd_AddCommand(CF_CLIENT, "pointfile", CL_ReadPointFile_f, "display point file produced by qbsp when a leak was detected in the map (a line leading through the leak hole, to an entity inside the level)");
    Cmd_AddCommand(CF_CLIENT, "cl_particles_reloadeffects", CL_Particles_LoadEffectInfo_f, "reloads effectinfo.txt and maps/levelname_effectinfo.txt (where levelname is the current map) if parameter is given, loads from custom file (no levelname_effectinfo are loaded in this case)");
 
    Cvar_RegisterVariable (&cl_particles);
    Cvar_RegisterVariable (&cl_particles_quality);
    Cvar_RegisterVariable (&cl_particles_alpha);
    Cvar_RegisterVariable (&cl_particles_size);
    Cvar_RegisterVariable (&cl_particles_quake);
    Cvar_RegisterVariable (&cl_particles_blood);
    Cvar_RegisterVariable (&cl_particles_blood_alpha);
    Cvar_RegisterVariable (&cl_particles_blood_decal_alpha);
    Cvar_RegisterVariable (&cl_particles_blood_decal_scalemin);
    Cvar_RegisterVariable (&cl_particles_blood_decal_scalemax);
    Cvar_RegisterVariable (&cl_particles_blood_bloodhack);
    Cvar_RegisterVariable (&cl_particles_explosions_sparks);
    Cvar_RegisterVariable (&cl_particles_explosions_shell);
    Cvar_RegisterVariable (&cl_particles_bulletimpacts);
    Cvar_RegisterVariable (&cl_particles_rain);
    Cvar_RegisterVariable (&cl_particles_snow);
    Cvar_RegisterVariable (&cl_particles_smoke);
    Cvar_RegisterVariable (&cl_particles_smoke_alpha);
    Cvar_RegisterVariable (&cl_particles_smoke_alphafade);
    Cvar_RegisterVariable (&cl_particles_sparks);
    Cvar_RegisterVariable (&cl_particles_bubbles);
    Cvar_RegisterVariable (&cl_particles_visculling);
    Cvar_RegisterVariable (&cl_particles_collisions);
    Cvar_RegisterVariable (&cl_particles_forcetraileffects);
    Cvar_RegisterVariable (&cl_decals);
    Cvar_RegisterVariable (&cl_decals_time);
    Cvar_RegisterVariable (&cl_decals_fadetime);
    Cvar_RegisterVariable (&cl_decals_newsystem_intensitymultiplier);
    Cvar_RegisterVariable (&cl_decals_newsystem_immediatebloodstain);
    Cvar_RegisterVariable (&cl_decals_newsystem_bloodsmears);
    Cvar_RegisterVariable (&cl_decals_models);
    Cvar_RegisterVariable (&cl_decals_bias);
    Cvar_RegisterVariable (&cl_decals_max);
}

References CF_CLIENT, cl_decals, cl_decals_bias, cl_decals_fadetime, cl_decals_max, cl_decals_models, cl_decals_newsystem_bloodsmears, cl_decals_newsystem_immediatebloodstain, cl_decals_newsystem_intensitymultiplier, cl_decals_time, cl_particles, cl_particles_alpha, cl_particles_blood, cl_particles_blood_alpha, cl_particles_blood_bloodhack, cl_particles_blood_decal_alpha, cl_particles_blood_decal_scalemax, cl_particles_blood_decal_scalemin, cl_particles_bubbles, cl_particles_bulletimpacts, cl_particles_collisions, cl_particles_explosions_shell, cl_particles_explosions_sparks, cl_particles_forcetraileffects, CL_Particles_LoadEffectInfo_f(), cl_particles_quake, cl_particles_quality, cl_particles_rain, cl_particles_size, cl_particles_smoke, cl_particles_smoke_alpha, cl_particles_smoke_alphafade, cl_particles_snow, cl_particles_sparks, cl_particles_visculling, CL_ReadPointFile_f(), Cmd_AddCommand(), and Cvar_RegisterVariable().

Referenced by CL_Init().

CL_Particles_Shutdown()

void CL_Particles_Shutdown

(

void

)

Definition at line 626 of file cl_particles.c.

{
}

Referenced by CL_Shutdown().

CL_ParticleTrail()

void CL_ParticleTrail	(	int	effectindex,
		float	pcount,
		const vec3_t	originmins,
		const vec3_t	originmaxs,
		const vec3_t	velocitymins,
		const vec3_t	velocitymaxs,
		struct entity_s *	ent,
		int	palettecolor,
		qbool	spawndlight,
		qbool	spawnparticles,
		float	tintmins[4],
		float	tintmaxs[4],
		float	fade )

Variable Documentation

cl_decals

struct cvar_s cl_decals

extern

Definition at line 303 of file cl_particles.c.

{CF_CLIENT | CF_ARCHIVE, "cl_decals", "1", "enables decals (bullet holes, blood, etc)"};

Referenced by CL_ImmediateBloodStain(), CL_Particles_Init(), CL_SpawnDecalParticleForSurface(), M_Menu_Options_Effects_AdjustSliders(), M_Options_Effects_Draw(), and R_DrawParticles().

cl_decals_fadetime

struct cvar_s cl_decals_fadetime

extern

Definition at line 305 of file cl_particles.c.

{CF_CLIENT | CF_ARCHIVE, "cl_decals_fadetime", "1", "how long decals take to fade away"};

Referenced by CL_Particles_Init(), R_DrawModelDecals_Entity(), and R_DrawModelDecals_FadeEntity().

cl_decals_time

struct cvar_s cl_decals_time

extern

Definition at line 304 of file cl_particles.c.

{CF_CLIENT | CF_ARCHIVE, "cl_decals_time", "20", "how long before decals start to fade away"};

Referenced by CL_Particles_Init(), R_DrawModelDecals_Entity(), and R_DrawModelDecals_FadeEntity().

cl_particles

struct cvar_s cl_particles

extern

Definition at line 279 of file cl_particles.c.

{CF_CLIENT | CF_ARCHIVE, "cl_particles", "1", "enables particle effects"};

Referenced by CL_EntityParticles(), CL_NewParticle(), CL_NewParticlesFromEffectinfo(), CL_ParticleCube(), CL_ParticleEffect_Fallback(), CL_ParticleExplosion(), CL_ParticleExplosion2(), CL_ParticleRain(), CL_Particles_Init(), M_Menu_Options_Effects_AdjustSliders(), and M_Options_Effects_Draw().

cl_particles_blood

struct cvar_s cl_particles_blood

extern

Definition at line 284 of file cl_particles.c.

{CF_CLIENT | CF_ARCHIVE, "cl_particles_blood", "1", "enables blood effects"};

Referenced by CL_NewParticlesFromEffectinfo(), CL_ParticleEffect_Fallback(), CL_Particles_Init(), M_Menu_Options_Effects_AdjustSliders(), and M_Options_Effects_Draw().

cl_particles_blood_alpha

struct cvar_s cl_particles_blood_alpha

extern

Definition at line 285 of file cl_particles.c.

{CF_CLIENT | CF_ARCHIVE, "cl_particles_blood_alpha", "1", "opacity of blood, does not affect decals"};

Referenced by CL_ParticleEffect_Fallback(), CL_Particles_Init(), M_Menu_Options_Effects_AdjustSliders(), and M_Options_Effects_Draw().

cl_particles_blood_bloodhack

struct cvar_s cl_particles_blood_bloodhack

extern

Definition at line 289 of file cl_particles.c.

{CF_CLIENT | CF_ARCHIVE, "cl_particles_blood_bloodhack", "1", "make certain quake particle() calls create blood effects instead"};

Referenced by CL_ParticleEffect_Fallback(), CL_Particles_Init(), M_Menu_Options_Effects_AdjustSliders(), and M_Options_Effects_Draw().

cl_particles_blood_decal_alpha

struct cvar_s cl_particles_blood_decal_alpha

extern

Definition at line 286 of file cl_particles.c.

{CF_CLIENT | CF_ARCHIVE, "cl_particles_blood_decal_alpha", "1", "opacity of blood decal"};

Referenced by CL_Particles_Init(), and R_DrawParticles().

cl_particles_blood_decal_scalemax

struct cvar_s cl_particles_blood_decal_scalemax

extern

Definition at line 288 of file cl_particles.c.

{CF_CLIENT | CF_ARCHIVE, "cl_particles_blood_decal_scalemax", "2", "maximal random scale of decal"};

Referenced by CL_Particles_Init(), and R_DrawParticles().

cl_particles_blood_decal_scalemin

struct cvar_s cl_particles_blood_decal_scalemin

extern

Definition at line 287 of file cl_particles.c.

{CF_CLIENT | CF_ARCHIVE, "cl_particles_blood_decal_scalemin", "1.5", "minimal random scale of decal"};

Referenced by CL_Particles_Init(), and R_DrawParticles().

cl_particles_bubbles

struct cvar_s cl_particles_bubbles

extern

Definition at line 299 of file cl_particles.c.

{CF_CLIENT | CF_ARCHIVE, "cl_particles_bubbles", "1", "enables bubbles (used by multiple effects)"};

Referenced by CL_NewParticlesFromEffectinfo(), CL_ParticleEffect_Fallback(), CL_ParticleExplosion(), CL_Particles_Init(), M_Menu_Options_Effects_AdjustSliders(), and M_Options_Effects_Draw().

cl_particles_bulletimpacts

struct cvar_s cl_particles_bulletimpacts

extern

Definition at line 290 of file cl_particles.c.

{CF_CLIENT | CF_ARCHIVE, "cl_particles_bulletimpacts", "1", "enables bulletimpact effects"};

Referenced by CL_ParticleEffect_Fallback(), CL_Particles_Init(), M_Menu_Options_Effects_AdjustSliders(), and M_Options_Effects_Draw().

cl_particles_explosions_shell

struct cvar_s cl_particles_explosions_shell

extern

Definition at line 292 of file cl_particles.c.

{CF_CLIENT | CF_ARCHIVE, "cl_particles_explosions_shell", "0", "enables polygonal shell from explosions"};

Referenced by CL_ParticleExplosion(), CL_Particles_Init(), M_Menu_Options_Effects_AdjustSliders(), and M_Options_Effects_Draw().

cl_particles_explosions_sparks

struct cvar_s cl_particles_explosions_sparks

extern

Definition at line 291 of file cl_particles.c.

{CF_CLIENT | CF_ARCHIVE, "cl_particles_explosions_sparks", "1", "enables sparks from explosions"};

Referenced by CL_ParticleExplosion(), and CL_Particles_Init().

cl_particles_quake

struct cvar_s cl_particles_quake

extern

Definition at line 283 of file cl_particles.c.

{CF_CLIENT | CF_ARCHIVE, "cl_particles_quake", "0", "0: Fancy particles; 1: Disc particles like GLQuake; 2: Square particles like software-rendered Quake"};

Referenced by CL_NewParticlesFromEffectinfo(), CL_NewQuakeParticle(), CL_ParticleEffect_Fallback(), CL_ParticleExplosion(), CL_ParticleExplosion2(), CL_Particles_Init(), M_Menu_Options_Effects_AdjustSliders(), and M_Options_Effects_Draw().

cl_particles_quality

struct cvar_s cl_particles_quality

extern

Definition at line 280 of file cl_particles.c.

{CF_CLIENT | CF_ARCHIVE, "cl_particles_quality", "1", "multiplies number of particles"};

Referenced by CL_NewParticlesFromEffectinfo(), CL_ParticleCube(), CL_ParticleEffect_Fallback(), CL_ParticleExplosion(), CL_ParticleExplosion2(), CL_ParticleRain(), CL_Particles_Init(), CL_Smoke(), CL_Sparks(), M_Menu_Options_Effects_AdjustSliders(), and M_Options_Effects_Draw().

cl_particles_rain

struct cvar_s cl_particles_rain

extern

Definition at line 293 of file cl_particles.c.

{CF_CLIENT | CF_ARCHIVE, "cl_particles_rain", "1", "enables rain effects"};

Referenced by CL_NewParticlesFromEffectinfo(), CL_ParticleRain(), and CL_Particles_Init().

cl_particles_size

struct cvar_s cl_particles_size

extern

Definition at line 282 of file cl_particles.c.

{CF_CLIENT | CF_ARCHIVE, "cl_particles_size", "1", "multiplies particle size"};

Referenced by CL_Particles_Init(), and R_DrawParticle_TransparentCallback().

cl_particles_smoke

struct cvar_s cl_particles_smoke

extern

Definition at line 295 of file cl_particles.c.

{CF_CLIENT | CF_ARCHIVE, "cl_particles_smoke", "1", "enables smoke (used by multiple effects)"};

Referenced by CL_NewParticlesFromEffectinfo(), CL_ParticleEffect_Fallback(), CL_Particles_Init(), CL_Smoke(), M_Menu_Options_Effects_AdjustSliders(), and M_Options_Effects_Draw().

cl_particles_smoke_alpha

struct cvar_s cl_particles_smoke_alpha

extern

Definition at line 296 of file cl_particles.c.

{CF_CLIENT | CF_ARCHIVE, "cl_particles_smoke_alpha", "0.5", "smoke brightness"};

Referenced by CL_ParticleEffect_Fallback(), and CL_Particles_Init().

cl_particles_smoke_alphafade

struct cvar_s cl_particles_smoke_alphafade

extern

Definition at line 297 of file cl_particles.c.

{CF_CLIENT | CF_ARCHIVE, "cl_particles_smoke_alphafade", "0.55", "brightness fade per second"};

Referenced by CL_ParticleEffect_Fallback(), and CL_Particles_Init().

cl_particles_snow

struct cvar_s cl_particles_snow

extern

Definition at line 294 of file cl_particles.c.

{CF_CLIENT | CF_ARCHIVE, "cl_particles_snow", "1", "enables snow effects"};

Referenced by CL_NewParticlesFromEffectinfo(), CL_ParticleRain(), and CL_Particles_Init().

cl_particles_sparks

struct cvar_s cl_particles_sparks

extern

Definition at line 298 of file cl_particles.c.

{CF_CLIENT | CF_ARCHIVE, "cl_particles_sparks", "1", "enables sparks (used by multiple effects)"};

Referenced by CL_NewParticlesFromEffectinfo(), CL_ParticleEffect_Fallback(), CL_ParticleExplosion(), CL_Particles_Init(), CL_Sparks(), M_Menu_Options_Effects_AdjustSliders(), and M_Options_Effects_Draw().