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

Functions
void	CSQCModel_Effects_Apply (entity this)
void	CSQCModel_Hook_PreDraw (entity this, bool isplayer)
void	CSQCModel_LOD_Apply (entity this, bool isplayer)

Variables
int	autocvar__cl_color
string	autocvar__cl_playermodel
int	autocvar__cl_playerskin
float	autocvar_cl_deathglow
float	autocvar_cl_deathglow_min = 0.5
int	autocvar_cl_forcemyplayercolors
string	autocvar_cl_forcemyplayermodel
int	autocvar_cl_forcemyplayerskin
bool	autocvar_cl_forceplayercolors
bool	autocvar_cl_forceplayermodels
bool	autocvar_cl_forceuniqueplayercolors
float	autocvar_cl_jetpack_attenuation = 2
float	autocvar_cl_loddistance1 = 768
float	autocvar_cl_loddistance2 = 2048
int	autocvar_cl_modeldetailreduction
int	autocvar_cl_playerdetailreduction
bool	autocvar_cl_respawn_ghosts_keepcolors
float	autocvar_r_hdr_glowintensity
int	csqcmodel_effects
bool	csqcmodel_isdead
int	csqcmodel_modelflags
int	csqcmodel_traileffect
float	death_time
const int	EF_BRIGHTFIELD = BIT(0)
const int	EF_BRIGHTLIGHT = BIT(2)
const int	EF_DIMLIGHT = BIT(3)
const int	EF_DOUBLESIDED = BIT(15)
const int	EF_DYNAMICMODELLIGHT = BIT(17)
const int	EF_NOSELFSHADOW = BIT(16)
const int	EF_RESTARTANIM_BIT = BIT(20)
const int	EF_TELEPORT_BIT = BIT(21)
int	isplayermodel
const int	MF_GIB = BIT(2)
const int	MF_GRENADE = BIT(1)
const int	MF_ROCKET = BIT(0)
const int	MF_ROTATE = BIT(3)
const int	MF_TRACER = BIT(4)
const int	MF_TRACER2 = BIT(6)
const int	MF_TRACER3 = BIT(7)
const int	MF_ZOMGIB = BIT(5)

Function Documentation

◆ CSQCModel_Effects_Apply()

void CSQCModel_Effects_Apply ( entity this )

Definition at line 546 of file csqcmodel_hooks.qc.

{
    float dt = bound(0, frametime, 0.1);
    int eff = this.csqcmodel_effects & ~CSQCMODEL_EF_RESPAWNGHOST;
    int tref = this.csqcmodel_traileffect;
 
    this.renderflags &= ~(RF_DEPTHHACK | RF_ADDITIVE | RF_FULLBRIGHT | EF_NOSHADOW | RF_USEAXIS);
    this.effects = 0;
    this.traileffect = 0;
 
    float pl_alpha = (!this.alpha ? 1 : this.alpha);
    if (eff & EF_BRIGHTFIELD)
        tref = EFFECT_TR_NEXUIZPLASMA.m_id;
    // ignoring EF_MUZZLEFLASH
    if ((eff & EF_NODRAW) || pl_alpha < 0)
        this.drawmask = 0;
    if (eff & EF_ADDITIVE)
        this.renderflags |= RF_ADDITIVE;
    // ignoring EF_NOGUNBOB
    if (eff & EF_FULLBRIGHT)
        this.renderflags |= RF_FULLBRIGHT;
 
    if (pl_alpha > 0)
    {
        if (eff & EF_BLUE)
            adddynamiclight(this.origin, 200 * pl_alpha, '0.15 0.15 1.5');
        if (eff & EF_RED)
            adddynamiclight(this.origin, 200 * pl_alpha, '1.5 0.15 0.15');
        if (eff & EF_BRIGHTLIGHT)
            adddynamiclight(this.origin, 400 * pl_alpha, '3 3 3');
        if (eff & EF_DIMLIGHT)
            adddynamiclight(this.origin, 200 * pl_alpha, '1.5 1.5 1.5');
        if (eff & EF_FLAME)
        {
            particles_alphamin = particles_alphamax = pl_alpha; // scale by player alpha
            // XONRELEASE TODO: xonotic-v0.9.0 after release remove the ef_shock_num check
            // NOTE here we check if EF_SHOCK exists because it was added together with the change to EF_FLAME
            int ef_shock_num = particleeffectnum(EFFECT_EF_SHOCK);
            if (ef_shock_num >= 0) // in the old version of EF_FLAME the light was spawned by boxparticles
                adddynamiclight2(this.origin + '0 0 10', 200 * particles_alphamin, '1 0.35 0', 6, "", PFLAGS_FULLDYNAMIC); // no PFLAGS_CORONA, it looks bad
            int ef_flame_num = particleeffectnum(EFFECT_EF_FLAME);
            boxparticles(ef_flame_num, this, this.absmin, this.absmax, this.velocity, this.velocity, dt, PARTICLES_USEALPHA);
            //pointparticles(EFFECT_EF_FLAME, this.origin, '0 0 0', dt);
        }
        if (eff & EF_SHOCK)
        {
            particles_alphamin = particles_alphamax = pl_alpha; // scale by player alpha
            // XONRELEASE TODO: xonotic-v0.9.0 after release remove the ef_shock_num check
            int ef_shock_num = particleeffectnum(EFFECT_EF_SHOCK);
            if (ef_shock_num >= 0) // in ARC_LIGHTNING the light is spawned by boxparticles
                adddynamiclight2(this.origin, 50 * particles_alphamin, '3.1 4.4 10', 10, "", PFLAGS_FULLDYNAMIC); // no PFLAGS_CORONA, it looks bad
            else
                ef_shock_num = particleeffectnum(EFFECT_ARC_LIGHTNING);
            boxparticles(ef_shock_num, this, this.absmin, this.absmax, '0 0 0', '0 0 0', dt, PARTICLES_USEALPHA);
            //pointparticles(EFFECT_ARC_LIGHTNING, this.origin, '0 0 0', dt);
        }
        if (eff & EF_SPEED)
        {
            float speed = vlen(this.velocity);
            if (speed > 0)
            {
                particles_alphamin = particles_alphamax = pl_alpha * min(speed / PHYS_MAXSPEED(this), 1); // scale by player alpha, and more transparent at lower speeds
                vector dir = this.velocity * 1 / speed;
                // XONRELEASE TODO: xonotic-v0.9.0 post-release remove the ef_speed_num check
                int ef_speed_num = particleeffectnum(EFFECT_EF_SPEED);
                int foot_L_idx = gettagindex(this, "foot_L"); // left & right feet on the playermodel,
                int foot_R_idx = gettagindex(this, "foot_R"); // roughly at the heel
                if (foot_L_idx && foot_R_idx)
                {
                    vector foot_L_org = gettaginfo(this, foot_L_idx);
                    vector foot_R_org = gettaginfo(this, foot_R_idx);
                    if (ef_speed_num >= 0)
                    {
                        // NOTE: to make this a proper trail the old foot_*_org will need to be stored, however it looks fine as-is
                        WarpZone_TrailParticles_WithMultiplier(this, ef_speed_num, foot_L_org - dir, foot_L_org + dir, dt, PARTICLES_USEALPHA);
                        WarpZone_TrailParticles_WithMultiplier(this, ef_speed_num, foot_R_org - dir, foot_R_org + dir, dt, PARTICLES_USEALPHA);
                    }
                    // No fallback since nothing looks similar, light will still draw though
                    adddynamiclight(foot_L_org, 45 * particles_alphamin, STATUSEFFECT_Speed.m_color);
                    adddynamiclight(foot_R_org, 45 * particles_alphamin, STATUSEFFECT_Speed.m_color);
                }
                else
                {
                    vector org = this.origin + 0.5 * (this.mins + this.maxs); // center
                    if (ef_speed_num >= 0)
                        WarpZone_TrailParticles_WithMultiplier(this, ef_speed_num, org - dir, org + dir, dt, PARTICLES_USEALPHA);
                        //pointparticles(EFFECT_EF_SPEED, org, '0 0 0', dt);
                    adddynamiclight(org, 45 * particles_alphamin, STATUSEFFECT_Speed.m_color);
                }
            }
        }
        if (eff & EF_STARDUST)
        {
            particles_alphamin = particles_alphamax = pl_alpha; // scale by player alpha
            boxparticles(particleeffectnum(EFFECT_EF_STARDUST), this, this.absmin, this.absmax, this.velocity, this.velocity, dt, PARTICLES_USEALPHA);
            //pointparticles(EFFECT_EF_STARDUST, this.origin, '0 0 0', dt);
        }
    }
 
    if (eff & EF_NOSHADOW)
        this.renderflags |= RF_NOSHADOW;
    if (eff & EF_NODEPTHTEST)
        this.renderflags |= RF_DEPTHHACK;
    // ignoring EF_SELECTABLE
    if (eff & EF_DOUBLESIDED)
        this.effects |= EF_DOUBLESIDED;
    if (eff & EF_NOSELFSHADOW)
        this.effects |= EF_NOSELFSHADOW;
    if (eff & EF_DYNAMICMODELLIGHT)
        this.renderflags |= RF_DYNAMICMODELLIGHT;
    // ignoring EF_UNUSED18, EF_UNUSED19, EF_RESTARTANIM_BIT, EF_TELEPORT_BIT, EF_LOWPRECISION
 
    if (false)
        ;
#define TRAIL_FROM_MODEL(modelflag, trailent) \
    else if (this.csqcmodel_modelflags & (modelflag)) \
        tref = EFFECT_##trailent.m_id
    TRAIL_FROM_MODEL(MF_TRACER3, TR_VORESPIKE);
    TRAIL_FROM_MODEL(MF_TRACER2, TR_KNIGHTSPIKE);
    TRAIL_FROM_MODEL(MF_ZOMGIB,  TR_SLIGHTBLOOD);
    TRAIL_FROM_MODEL(MF_TRACER,  TR_WIZSPIKE);
    TRAIL_FROM_MODEL(MF_GIB,     TR_BLOOD);
    TRAIL_FROM_MODEL(MF_GRENADE, TR_GRENADE);
    TRAIL_FROM_MODEL(MF_ROCKET,  TR_ROCKET);
#undef TRAIL_FROM_MODEL
    if (this.csqcmodel_modelflags & MF_ROTATE)
    {
        // This will be hard to replace with MAKE_VECTORS because it's called as part of the predraw function
        // as documented in csprogs.h in the engine. The globals can then be read in many places in the engine.
        // However MF_ROTATE is currently only used in one place - might be possible to get rid of it entirely.
        this.renderflags |= RF_USEAXIS;
        makevectors(this.angles + '0 100 0' * fmod(time, 3.6));
    }
 
    this.traileffect = tref;
 
    if (this.drawmask)
        Projectile_DrawTrail(this, this.origin);
    else
        Projectile_ResetTrail(this, this.origin);
 
    if (this.csqcmodel_effects & CSQCMODEL_EF_RESPAWNGHOST)
        this.renderflags |= RF_ADDITIVE;
        // also special in CSQCPlayer_GlowMod_Apply
 
    if (this.csqcmodel_modelflags & MF_ROCKET)
    {
        if (!this.snd_looping)
        {
            sound(this, CH_TRIGGER_SINGLE, SND_JETPACK_FLY, VOL_BASE, autocvar_cl_jetpack_attenuation);
            this.snd_looping = CH_TRIGGER_SINGLE;
        }
    }
    else
    {
        if (this.snd_looping)
        {
            sound(this, this.snd_looping, SND_Null, VOL_BASE, autocvar_cl_jetpack_attenuation);
            this.snd_looping = 0;
        }
    }
}

References absmax, absmin, adddynamiclight, adddynamiclight2, alpha, angles, autocvar_cl_jetpack_attenuation, bound(), CH_TRIGGER_SINGLE, CSQCMODEL_EF_RESPAWNGHOST, csqcmodel_effects, csqcmodel_modelflags, csqcmodel_traileffect, dir, drawmask, EF_ADDITIVE, EF_BLUE, EF_BRIGHTFIELD, EF_BRIGHTLIGHT, EF_DIMLIGHT, EF_DOUBLESIDED, EF_DYNAMICMODELLIGHT, EF_FLAME, EF_FULLBRIGHT, EF_NODEPTHTEST, EF_NODRAW, EF_NOSELFSHADOW, EF_NOSHADOW, EF_RED, EF_SHOCK, EF_SPEED, EF_STARDUST, effects, entity(), fmod(), frametime, gettagindex, gettaginfo, makevectors, maxs, MF_GIB, MF_GRENADE, MF_ROCKET, MF_ROTATE, MF_TRACER, MF_TRACER2, MF_TRACER3, MF_ZOMGIB, min(), mins, org, origin, particleeffectnum, particles_alphamax, particles_alphamin, PARTICLES_USEALPHA, PFLAGS_FULLDYNAMIC, PHYS_MAXSPEED, Projectile_DrawTrail(), Projectile_ResetTrail(), renderflags, RF_ADDITIVE, RF_DEPTHHACK, RF_DYNAMICMODELLIGHT, RF_FULLBRIGHT, RF_NOSHADOW, RF_USEAXIS, snd_looping, sound, speed, time, TRAIL_FROM_MODEL, vector, velocity, vlen(), VOL_BASE, and WarpZone_TrailParticles_WithMultiplier().

Referenced by CSQCModel_Hook_PreDraw(), and viewmodel_draw().

◆ CSQCModel_Hook_PreDraw()

void CSQCModel_Hook_PreDraw	(	entity	this,
		bool	isplayer )

Definition at line 720 of file csqcmodel_hooks.qc.

{
    if(this.csqcmodel_predraw_run == framecount)
        return;
    this.csqcmodel_predraw_run = framecount;
 
    if(!this.modelindex || this.model == "null")
    {
        this.drawmask = 0;
        if(this.snd_looping > 0)
        {
            sound(this, this.snd_looping, SND_Null, VOL_BASE, autocvar_cl_jetpack_attenuation);
            this.snd_looping = 0;
        }
        return;
    }
    else
        this.drawmask = MASK_NORMAL;
 
    if((this.isplayermodel & ISPLAYER_MODEL) && this.drawmask) // this checks if it's a player MODEL!
    {
        CSQCPlayer_ModelAppearance_Apply(this, (this.isplayermodel & ISPLAYER_LOCAL));
        CSQCModel_LOD_Apply(this, true);
 
        if(!isplayer)
        {
            skeleton_loadinfo(this);
            bool doblend = (this.bone_upperbody >= 0);
            CSQCPlayer_FallbackFrame_Apply(this);
            if(doblend)
            {
                skeleton_from_frames(this, this.csqcmodel_isdead);
            }
            else
            {
                free_skeleton_from_frames(this);
                // just in case, clear these (we're animating in frame and frame3)
                this.lerpfrac = 0;
                this.lerpfrac4 = 0;
            }
        }
        else
        {
            // we know that frame3 and frame4 fields, used by InterpolateAnimation, are left alone - but that is all we know!
            skeleton_loadinfo(this);
            bool doblend = (this.bone_upperbody >= 0);
            bool onground = 0;
            if(this == csqcplayer)
            {
                if(IS_ONGROUND(this))
                    onground = 1;
                this.anim_prev_pmove_flags = this.flags;
                if(this.flags & FL_DUCKED)
                    animdecide_setstate(this, this.anim_state | ANIMSTATE_DUCK, false);
                else if(this.anim_state & ANIMSTATE_DUCK)
                    animdecide_setstate(this, this.anim_state - ANIMSTATE_DUCK, false);
            }
            else
            {
                tracebox(this.origin + '0 0 1', this.mins, this.maxs, this.origin - '0 0 4', MOVE_NORMAL, this);
                if(trace_startsolid || trace_fraction < 1)
                    onground = 1;
                // predicted clients handle smoothing in the prediction code
                this.origin = CSQCModel_ApplyStairSmoothing(this, onground, this.origin);
            }
            animdecide_load_if_needed(this);
            animdecide_setimplicitstate(this, onground);
            animdecide_setframes(this, doblend, anim_frame, anim_frame1time, anim_frame2, anim_frame2time);
            int sf = 0;
            if(this.anim_saveframe != this.anim_frame || this.anim_saveframe1time != this.anim_frame1time)
                sf |= CSQCMODEL_PROPERTY_FRAME;
            if(this.anim_saveframe2 != this.anim_frame2 || this.anim_saveframe2time != this.anim_frame2time)
                sf |= CSQCMODEL_PROPERTY_FRAME2;
            this.anim_saveframe = this.anim_frame;
            this.anim_saveframe1time = this.anim_frame1time;
            this.anim_saveframe2 = this.anim_frame2;
            this.anim_saveframe2time = this.anim_frame2time;
            // Note: we always consider lerpfrac "changed", as it uses fixed values every time anyway.
            // This ensures that .frame etc. are always written.
            CSQCModel_InterpolateAnimation_2To4_PreNote(this, sf | CSQCMODEL_PROPERTY_LERPFRAC);
            this.lerpfrac = (doblend ? 0.5 : 0);
            this.frame = this.anim_frame;
            this.frame1time = this.anim_frame1time;
            this.frame2 = this.anim_frame2;
            this.frame2time = this.anim_frame2time;
            CSQCModel_InterpolateAnimation_2To4_Note(this, sf | CSQCMODEL_PROPERTY_LERPFRAC, false);
            CSQCModel_InterpolateAnimation_2To4_Do(this);
            if(doblend)
            {
                skeleton_from_frames(this, this.csqcmodel_isdead);
            }
            else
            {
                free_skeleton_from_frames(this);
                // just in case, clear these (we're animating in frame and frame3)
                this.lerpfrac = 0;
                this.lerpfrac4 = 0;
            }
        }
    }
    else
        CSQCModel_LOD_Apply(this, false);
 
    CSQCModel_AutoTagIndex_Apply(this);
 
    CSQCModel_Effects_Apply(this);
}

References anim_frame, anim_frame1time, anim_frame2, anim_frame2time, anim_prev_pmove_flags, anim_saveframe, anim_saveframe1time, anim_saveframe2, anim_saveframe2time, anim_state, animdecide_load_if_needed(), animdecide_setframes(), animdecide_setimplicitstate(), animdecide_setstate(), ANIMSTATE_DUCK, autocvar_cl_jetpack_attenuation, CSQCModel_ApplyStairSmoothing(), CSQCModel_AutoTagIndex_Apply(), CSQCModel_Effects_Apply(), CSQCModel_InterpolateAnimation_2To4_Do(), CSQCModel_InterpolateAnimation_2To4_Note(), CSQCModel_InterpolateAnimation_2To4_PreNote(), csqcmodel_isdead, CSQCModel_LOD_Apply(), csqcmodel_predraw_run, CSQCMODEL_PROPERTY_FRAME, CSQCMODEL_PROPERTY_FRAME2, CSQCMODEL_PROPERTY_LERPFRAC, csqcplayer, CSQCPlayer_FallbackFrame_Apply(), CSQCPlayer_ModelAppearance_Apply(), drawmask, entity(), FL_DUCKED, flags, frame, frame1time, frame2, frame2time, framecount, free_skeleton_from_frames(), IS_ONGROUND, ISPLAYER_LOCAL, ISPLAYER_MODEL, isplayermodel, lerpfrac, lerpfrac4, MASK_NORMAL, maxs, mins, model, modelindex, MOVE_NORMAL, origin, skeleton_from_frames(), skeleton_loadinfo(), snd_looping, sound, trace_fraction, trace_startsolid, and VOL_BASE.

Referenced by CSQCModel_AutoTagIndex_Apply(), and CSQCModel_Draw().

◆ CSQCModel_LOD_Apply()

void CSQCModel_LOD_Apply	(	entity	this,
		bool	isplayer )

Definition at line 28 of file csqcmodel_hooks.qc.

{
    int detailreduction = ((isplayer) ? autocvar_cl_playerdetailreduction : autocvar_cl_modeldetailreduction);
 
    // LOD model loading
    if(this.lodmodelindex0 != this.modelindex && this.lodmodelindex1 != this.modelindex && this.lodmodelindex2 != this.modelindex)
    {
        string modelname = this.model;
        string s;
 
        vector mi = this.mins;
        vector ma = this.maxs;
 
        // set modelindex
        this.lodmodelindex0 = this.modelindex;
        this.lodmodelindex1 = this.modelindex;
        this.lodmodelindex2 = this.modelindex;
 
        // FIXME: this only supports 3-letter extensions
        s = strcat(substring(modelname, 0, strlen(modelname)-4), "_lod1", substring(modelname, -4, 4));
        if(fexists(s))
        {
            precache_model(s);
            _setmodel(this, s);
            if(this.modelindex)
                this.lodmodelindex2 = this.lodmodelindex1 = this.modelindex;
        }
 
        s = strcat(substring(modelname, 0, strlen(modelname)-4), "_lod2", substring(modelname, -4, 4));
        if(fexists(s))
        {
            precache_model(s);
            _setmodel(this, s);
            if(this.modelindex)
                this.lodmodelindex2 = this.modelindex;
        }
 
        _setmodel(this, modelname); // make everything normal again
        setsize(this, mi, ma);
    }
 
    // apply LOD
    if(detailreduction <= 0)
    {
        if(detailreduction <= -2)
            this.modelindex = this.lodmodelindex2;
        else if(detailreduction <= -1)
            this.modelindex = this.lodmodelindex1;
        else
            this.modelindex = this.lodmodelindex0;
    }
    else
    {
        float distance = vlen(((isplayer) ? this.origin : NearestPointOnBox(this, view_origin)) - view_origin); // TODO: perhaps it should just use NearestPointOnBox all the time, player hitbox can potentially be huge
        float dist1 = (this.loddistance1 > 0) ? this.loddistance1 : autocvar_cl_loddistance1;
        float dist2 = (this.loddistance2 > 0) ? this.loddistance2 : autocvar_cl_loddistance2;
        float f = (distance * current_viewzoom + 100.0) * detailreduction;
        f *= 1.0 / bound(0.01, view_quality, 1);
        if(f > dist2)
            this.modelindex = this.lodmodelindex2;
        else if(f > dist1)
            this.modelindex = this.lodmodelindex1;
        else
            this.modelindex = this.lodmodelindex0;
    }
}