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 545 of file csqcmodel_hooks.qc.

{
    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;
 
    if(eff & EF_BRIGHTFIELD)
        tref = EFFECT_TR_NEXUIZPLASMA.m_id;
    // ignoring EF_MUZZLEFLASH
    if(eff & EF_BRIGHTLIGHT)
        adddynamiclight(this.origin, 400, '3 3 3');
    if(eff & EF_DIMLIGHT)
        adddynamiclight(this.origin, 200, '1.5 1.5 1.5');
    if((eff & EF_NODRAW) || (this.alpha < 0))
        this.drawmask = 0;
    if(eff & EF_ADDITIVE)
        this.renderflags |= RF_ADDITIVE;
        if(eff & EF_BLUE)
            adddynamiclight(this.origin, 200, '0.15 0.15 1.5');
        if(eff & EF_RED)
            adddynamiclight(this.origin, 200, '1.5 0.15 0.15');
    // ignoring EF_NOGUNBOB
    if(eff & EF_FULLBRIGHT)
        this.renderflags |= RF_FULLBRIGHT;
    if(eff & EF_FLAME)
    {
        // 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, '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, bound(0, frametime, 0.1), 0);
        //pointparticles(EFFECT_EF_FLAME, this.origin, '0 0 0', bound(0, frametime, 0.1));
    }
    if(eff & EF_SHOCK)
    {
        // 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, '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', bound(0, frametime, 0.1), 0);
        //pointparticles(EFFECT_ARC_LIGHTNING, this.origin, '0 0 0', bound(0, frametime, 0.1));
    }
    if(eff & EF_STARDUST)
    {
        boxparticles(particleeffectnum(EFFECT_EF_STARDUST), this, this.absmin, this.absmax, this.velocity, this.velocity, bound(0, frametime, 0.1), 0);
        //pointparticles(EFFECT_EF_STARDUST, this.origin, '0 0 0', bound(0, frametime, 0.1));
    }
    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(this.csqcmodel_modelflags & MF_ROCKET)
        tref = EFFECT_TR_ROCKET.m_id;
    if(this.csqcmodel_modelflags & MF_GRENADE)
        tref = EFFECT_TR_GRENADE.m_id;
    if(this.csqcmodel_modelflags & MF_GIB)
        tref = EFFECT_TR_BLOOD.m_id;
    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));
    }
    if(this.csqcmodel_modelflags & MF_TRACER)
        tref = EFFECT_TR_WIZSPIKE.m_id;
    if(this.csqcmodel_modelflags & MF_ZOMGIB)
        tref = EFFECT_TR_SLIGHTBLOOD.m_id;
    if(this.csqcmodel_modelflags & MF_TRACER2)
        tref = EFFECT_TR_KNIGHTSPIKE.m_id;
    if(this.csqcmodel_modelflags & MF_TRACER3)
        tref = EFFECT_TR_VORESPIKE.m_id;
 
    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, 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_STARDUST, effects, entity(), fmod(), frametime, makevectors, MF_GIB, MF_GRENADE, MF_ROCKET, MF_ROTATE, MF_TRACER, MF_TRACER2, MF_TRACER3, MF_ZOMGIB, origin, particleeffectnum, PFLAGS_FULLDYNAMIC, Projectile_DrawTrail(), Projectile_ResetTrail(), renderflags, RF_ADDITIVE, RF_DEPTHHACK, RF_DYNAMICMODELLIGHT, RF_FULLBRIGHT, RF_NOSHADOW, RF_USEAXIS, snd_looping, sound, time, velocity, and VOL_BASE.

Referenced by CSQCModel_Hook_PreDraw(), and viewmodel_draw().

◆ CSQCModel_Hook_PreDraw()

void CSQCModel_Hook_PreDraw	(	entity	this,
		bool	isplayer )

Definition at line 674 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 27 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;
    }
}