Virtual function with default implementation?

[stevefan1999-personal]

I used the --vtable-generation feature but I see that some of the virtual functions are not generated:

	// initialization functions
	virtual void	Spawn( void ) { return; }
	virtual void	Precache( void ) { return; }
	virtual void	KeyValue( KeyValueData* pkvd) { pkvd->fHandled = FALSE; }
	virtual int		Save( CSave &save );
	virtual int		Restore( CRestore &restore );
	virtual int		ObjectCaps( void ) { return FCAP_ACROSS_TRANSITION; }
	virtual void	Activate( void ) {}

Spawn, Precache , KeyValue, ObjectCaps and Activate are not generated, but Save and Restore are. Is this an intended behavior?

The C++ Header:

//
// Base Entity.  All entity types derive from this
//
class CBaseEntity 
{
public:
	// Constructor.  Set engine to use C/C++ callback functions
	// pointers to engine data
	entvars_t *pev;		// Don't need to save/restore this pointer, the engine resets it

	// path corners
	CBaseEntity			*m_pGoalEnt;// path corner we are heading towards
	CBaseEntity			*m_pLink;// used for temporary link-list operations. 

	// initialization functions
	virtual void	Spawn( void ) { return; }
	virtual void	Precache( void ) { return; }
	virtual void	KeyValue( KeyValueData* pkvd) { pkvd->fHandled = FALSE; }
	virtual int		Save( CSave &save );
	virtual int		Restore( CRestore &restore );
	virtual int		ObjectCaps( void ) { return FCAP_ACROSS_TRANSITION; }
	virtual void	Activate( void ) {}
	
	// Setup the object->object collision box (pev->mins / pev->maxs is the object->world collision box)
	virtual void	SetObjectCollisionBox( void );

// Classify - returns the type of group (i.e, "houndeye", or "human military" so that monsters with different classnames
// still realize that they are teammates. (overridden for monsters that form groups)
	virtual int Classify ( void ) { return CLASS_NONE; };
	virtual void DeathNotice ( entvars_t *pevChild ) {}// monster maker children use this to tell the monster maker that they have died.


	static	TYPEDESCRIPTION m_SaveData[];

	virtual void	TraceAttack( entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);
	virtual int		TakeDamage( entvars_t* pevInflictor, entvars_t* pevAttacker, float flDamage, int bitsDamageType );
	virtual int		TakeHealth( float flHealth, int bitsDamageType );
	virtual void	Killed( entvars_t *pevAttacker, int iGib );
	virtual int		BloodColor( void ) { return DONT_BLEED; }
	virtual void	TraceBleed( float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType );
	virtual BOOL    IsTriggered( CBaseEntity *pActivator ) {return TRUE;}
	virtual CBaseMonster *MyMonsterPointer( void ) { return NULL;}
	virtual CSquadMonster *MySquadMonsterPointer( void ) { return NULL;}
	virtual	int		GetToggleState( void ) { return TS_AT_TOP; }
	virtual void	AddPoints( int score, BOOL bAllowNegativeScore ) {}
	virtual void	AddPointsToTeam( int score, BOOL bAllowNegativeScore ) {}
	virtual BOOL	AddPlayerItem( CBasePlayerItem *pItem ) { return 0; }
	virtual BOOL	RemovePlayerItem( CBasePlayerItem *pItem ) { return 0; }
	virtual int 	GiveAmmo( int iAmount, char *szName, int iMax ) { return -1; };
	virtual float	GetDelay( void ) { return 0; }
	virtual int		IsMoving( void ) { return pev->velocity != g_vecZero; }
	virtual void	OverrideReset( void ) {}
	virtual int		DamageDecal( int bitsDamageType );
	// This is ONLY used by the node graph to test movement through a door
	virtual void	SetToggleState( int state ) {}
	virtual void    StartSneaking( void ) {}
	virtual void    StopSneaking( void ) {}
	virtual BOOL	OnControls( entvars_t *pev ) { return FALSE; }
	virtual BOOL    IsSneaking( void ) { return FALSE; }
	virtual BOOL	IsAlive( void ) { return (pev->deadflag == DEAD_NO) && pev->health > 0; }
	virtual BOOL	IsBSPModel( void ) { return pev->solid == SOLID_BSP || pev->movetype == MOVETYPE_PUSHSTEP; }
	virtual BOOL	ReflectGauss( void ) { return ( IsBSPModel() && !pev->takedamage ); }
	virtual BOOL	HasTarget( string_t targetname ) { return FStrEq(STRING(targetname), STRING(pev->targetname) ); }
	virtual BOOL    IsInWorld( void );
	virtual	BOOL	IsPlayer( void ) { return FALSE; }
	virtual BOOL	IsNetClient( void ) { return FALSE; }
	virtual const char *TeamID( void ) { return ""; }


//	virtual void	SetActivator( CBaseEntity *pActivator ) {}
	virtual CBaseEntity *GetNextTarget( void );
	
	// fundamental callbacks
	void (CBaseEntity ::*m_pfnThink)(void);
	void (CBaseEntity ::*m_pfnTouch)( CBaseEntity *pOther );
	void (CBaseEntity ::*m_pfnUse)( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
	void (CBaseEntity ::*m_pfnBlocked)( CBaseEntity *pOther );

	virtual void Think( void ) { if (m_pfnThink) (this->*m_pfnThink)(); };
	virtual void Touch( CBaseEntity *pOther ) { if (m_pfnTouch) (this->*m_pfnTouch)( pOther ); };
	virtual void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value ) 
	{ 
		if (m_pfnUse) 
			(this->*m_pfnUse)( pActivator, pCaller, useType, value );
	}
	virtual void Blocked( CBaseEntity *pOther ) { if (m_pfnBlocked) (this->*m_pfnBlocked)( pOther ); };

	// allow engine to allocate instance data
    void *operator new( size_t stAllocateBlock, entvars_t *pev )
	{
		return (void *)ALLOC_PRIVATE(ENT(pev), stAllocateBlock);
	};

	// don't use this.
#if _MSC_VER >= 1200 // only build this code if MSVC++ 6.0 or higher
	void operator delete(void *pMem, entvars_t *pev)
	{
		pev->flags |= FL_KILLME;
	};
#endif

	void UpdateOnRemove( void );

	// common member functions
	void EXPORT SUB_Remove( void );
	void EXPORT SUB_DoNothing( void );
	void EXPORT SUB_StartFadeOut ( void );
	void EXPORT SUB_FadeOut ( void );
	void EXPORT SUB_CallUseToggle( void ) { this->Use( this, this, USE_TOGGLE, 0 ); }
	int			ShouldToggle( USE_TYPE useType, BOOL currentState );
	void		FireBullets( ULONG	cShots, Vector  vecSrc, Vector	vecDirShooting,	Vector	vecSpread, float flDistance, int iBulletType, int iTracerFreq = 4, int iDamage = 0, entvars_t *pevAttacker = NULL  );
	Vector		FireBulletsPlayer( ULONG	cShots, Vector  vecSrc, Vector	vecDirShooting,	Vector	vecSpread, float flDistance, int iBulletType, int iTracerFreq = 4, int iDamage = 0, entvars_t *pevAttacker = NULL, int shared_rand = 0 );

	virtual CBaseEntity *Respawn( void ) { return NULL; }

	void SUB_UseTargets( CBaseEntity *pActivator, USE_TYPE useType, float value );
	// Do the bounding boxes of these two intersect?
	int		Intersects( CBaseEntity *pOther );
	void	MakeDormant( void );
	int		IsDormant( void );
	BOOL    IsLockedByMaster( void ) { return FALSE; }

	static CBaseEntity *Instance( edict_t *pent )
	{ 
		if ( !pent )
			pent = ENT(0);
		CBaseEntity *pEnt = (CBaseEntity *)GET_PRIVATE(pent); 
		return pEnt; 
	}

	static CBaseEntity *Instance( entvars_t *pev ) { return Instance( ENT( pev ) ); }
	static CBaseEntity *Instance( int eoffset) { return Instance( ENT( eoffset) ); }

	CBaseMonster *GetMonsterPointer( entvars_t *pevMonster ) 
	{ 
		CBaseEntity *pEntity = Instance( pevMonster );
		if ( pEntity )
			return pEntity->MyMonsterPointer();
		return NULL;
	}
	CBaseMonster *GetMonsterPointer( edict_t *pentMonster ) 
	{ 
		CBaseEntity *pEntity = Instance( pentMonster );
		if ( pEntity )
			return pEntity->MyMonsterPointer();
		return NULL;
	}


	// Ugly code to lookup all functions to make sure they are exported when set.
#ifdef _DEBUG
	void FunctionCheck( void *pFunction, char *name ) 
	{ 
		if (pFunction && !NAME_FOR_FUNCTION((uint32)pFunction) )
			ALERT( at_error, "No EXPORT: %s:%s (%08lx)\n", STRING(pev->classname), name, (uint32)pFunction );
	}

	BASEPTR	ThinkSet( BASEPTR func, char *name ) 
	{ 
		m_pfnThink = func; 
		FunctionCheck( (void *)*((int *)((char *)this + ( offsetof(CBaseEntity,m_pfnThink)))), name ); 
		return func;
	}
	ENTITYFUNCPTR TouchSet( ENTITYFUNCPTR func, char *name ) 
	{ 
		m_pfnTouch = func; 
		FunctionCheck( (void *)*((int *)((char *)this + ( offsetof(CBaseEntity,m_pfnTouch)))), name ); 
		return func;
	}
	USEPTR	UseSet( USEPTR func, char *name ) 
	{ 
		m_pfnUse = func; 
		FunctionCheck( (void *)*((int *)((char *)this + ( offsetof(CBaseEntity,m_pfnUse)))), name ); 
		return func;
	}
	ENTITYFUNCPTR	BlockedSet( ENTITYFUNCPTR func, char *name ) 
	{ 
		m_pfnBlocked = func; 
		FunctionCheck( (void *)*((int *)((char *)this + ( offsetof(CBaseEntity,m_pfnBlocked)))), name ); 
		return func;
	}

#endif


	// virtual functions used by a few classes
	
	// used by monsters that are created by the MonsterMaker
	virtual	void UpdateOwner( void ) { return; };


	//
	static CBaseEntity *Create( char *szName, const Vector &vecOrigin, const Vector &vecAngles, edict_t *pentOwner = NULL );

	virtual BOOL FBecomeProne( void ) {return FALSE;};
	edict_t *edict() { return ENT( pev ); };
	EOFFSET eoffset( ) { return OFFSET( pev ); };
	int	  entindex( ) { return ENTINDEX( edict() ); };

	virtual Vector Center( ) { return (pev->absmax + pev->absmin) * 0.5; }; // center point of entity
	virtual Vector EyePosition( ) { return pev->origin + pev->view_ofs; };			// position of eyes
	virtual Vector EarPosition( ) { return pev->origin + pev->view_ofs; };			// position of ears
	virtual Vector BodyTarget( const Vector &posSrc ) { return Center( ); };		// position to shoot at

	virtual int Illumination( ) { return GETENTITYILLUM( ENT( pev ) ); };

	virtual	BOOL FVisible ( CBaseEntity *pEntity );
	virtual	BOOL FVisible ( const Vector &vecOrigin );

	//We use this variables to store each ammo count.
	int ammo_9mm;
	int ammo_357;
	int ammo_bolts;
	int ammo_buckshot;
	int ammo_rockets;
	int ammo_uranium;
	int ammo_hornets;
	int ammo_argrens;
	//Special stuff for grenades and satchels.
	float m_flStartThrow;
	float m_flReleaseThrow;
	int m_chargeReady;
	int m_fInAttack;

	enum EGON_FIRESTATE { FIRE_OFF, FIRE_CHARGE };
	int m_fireState;
};

Generated structure:

#[repr(C)]
pub struct CBaseEntity__bindgen_vtable {
    pub CBaseEntity_Save:
        unsafe extern "C" fn(this: *mut CBaseEntity, save: *mut CSave) -> ::std::os::raw::c_int,
    pub CBaseEntity_Restore: unsafe extern "C" fn(
        this: *mut CBaseEntity,
        restore: *mut CRestore,
    ) -> ::std::os::raw::c_int,
    pub CBaseEntity_SetObjectCollisionBox: unsafe extern "C" fn(this: *mut CBaseEntity),
    pub CBaseEntity_TraceAttack: unsafe extern "C" fn(
        this: *mut CBaseEntity,
        pevAttacker: *mut entvars_t,
        flDamage: f32,
        vecDir: Vector,
        ptr: *mut TraceResult,
        bitsDamageType: ::std::os::raw::c_int,
    ),
    pub CBaseEntity_TakeDamage: unsafe extern "C" fn(
        this: *mut CBaseEntity,
        pevInflictor: *mut entvars_t,
        pevAttacker: *mut entvars_t,
        flDamage: f32,
        bitsDamageType: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int,
    pub CBaseEntity_TakeHealth: unsafe extern "C" fn(
        this: *mut CBaseEntity,
        flHealth: f32,
        bitsDamageType: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int,
    pub CBaseEntity_Killed: unsafe extern "C" fn(
        this: *mut CBaseEntity,
        pevAttacker: *mut entvars_t,
        iGib: ::std::os::raw::c_int,
    ),
    pub CBaseEntity_TraceBleed: unsafe extern "C" fn(
        this: *mut CBaseEntity,
        flDamage: f32,
        vecDir: Vector,
        ptr: *mut TraceResult,
        bitsDamageType: ::std::os::raw::c_int,
    ),
    pub CBaseEntity_DamageDecal: unsafe extern "C" fn(
        this: *mut CBaseEntity,
        bitsDamageType: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int,
    pub CBaseEntity_IsInWorld: unsafe extern "C" fn(this: *mut CBaseEntity) -> BOOL,
    pub CBaseEntity_GetNextTarget: unsafe extern "C" fn(this: *mut CBaseEntity) -> *mut CBaseEntity,
    pub CBaseEntity_FVisible:
        unsafe extern "C" fn(this: *mut CBaseEntity, pEntity: *mut CBaseEntity) -> BOOL,
    pub CBaseEntity_FVisible1:
        unsafe extern "C" fn(this: *mut CBaseEntity, vecOrigin: *const Vector) -> BOOL,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CBaseEntity {
    pub vtable_: *const CBaseEntity__bindgen_vtable,
    pub pev: *mut entvars_t,
    pub m_pGoalEnt: *mut CBaseEntity,
    pub m_pLink: *mut CBaseEntity,
    pub m_pfnThink: ::std::option::Option<unsafe extern "C" fn()>,
    pub m_pfnTouch: ::std::option::Option<unsafe extern "C" fn(pOther: *mut CBaseEntity)>,
    pub m_pfnUse: ::std::option::Option<
        unsafe extern "C" fn(
            pActivator: *mut CBaseEntity,
            pCaller: *mut CBaseEntity,
            useType: USE_TYPE,
            value: f32,
        ),
    >,
    pub m_pfnBlocked: ::std::option::Option<unsafe extern "C" fn(pOther: *mut CBaseEntity)>,
    pub ammo_9mm: ::std::os::raw::c_int,
    pub ammo_357: ::std::os::raw::c_int,
    pub ammo_bolts: ::std::os::raw::c_int,
    pub ammo_buckshot: ::std::os::raw::c_int,
    pub ammo_rockets: ::std::os::raw::c_int,
    pub ammo_uranium: ::std::os::raw::c_int,
    pub ammo_hornets: ::std::os::raw::c_int,
    pub ammo_argrens: ::std::os::raw::c_int,
    pub m_flStartThrow: f32,
    pub m_flReleaseThrow: f32,
    pub m_chargeReady: ::std::os::raw::c_int,
    pub m_fInAttack: ::std::os::raw::c_int,
    pub m_fireState: ::std::os::raw::c_int,
}
pub const CBaseEntity_EGON_FIRESTATE_FIRE_OFF: CBaseEntity_EGON_FIRESTATE = 0;
pub const CBaseEntity_EGON_FIRESTATE_FIRE_CHARGE: CBaseEntity_EGON_FIRESTATE = 1;
pub type CBaseEntity_EGON_FIRESTATE = ::std::os::raw::c_int;
extern "C" {
    #[link_name = "\u{1}?m_SaveData@CBaseEntity@@2PAUTYPEDESCRIPTION@@A"]
    pub static mut CBaseEntity_m_SaveData: [TYPEDESCRIPTION; 0usize];
}
#[test]
fn bindgen_test_layout_CBaseEntity() {
    const UNINIT: ::std::mem::MaybeUninit<CBaseEntity> = ::std::mem::MaybeUninit::uninit();
    let ptr = UNINIT.as_ptr();
    assert_eq!(
        ::std::mem::size_of::<CBaseEntity>(),
        120usize,
        concat!("Size of: ", stringify!(CBaseEntity))
    );
    assert_eq!(
        ::std::mem::align_of::<CBaseEntity>(),
        8usize,
        concat!("Alignment of ", stringify!(CBaseEntity))
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).pev) as usize - ptr as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(CBaseEntity),
            "::",
            stringify!(pev)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).m_pGoalEnt) as usize - ptr as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(CBaseEntity),
            "::",
            stringify!(m_pGoalEnt)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).m_pLink) as usize - ptr as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(CBaseEntity),
            "::",
            stringify!(m_pLink)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).m_pfnThink) as usize - ptr as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(CBaseEntity),
            "::",
            stringify!(m_pfnThink)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).m_pfnTouch) as usize - ptr as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(CBaseEntity),
            "::",
            stringify!(m_pfnTouch)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).m_pfnUse) as usize - ptr as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(CBaseEntity),
            "::",
            stringify!(m_pfnUse)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).m_pfnBlocked) as usize - ptr as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(CBaseEntity),
            "::",
            stringify!(m_pfnBlocked)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ammo_9mm) as usize - ptr as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(CBaseEntity),
            "::",
            stringify!(ammo_9mm)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ammo_357) as usize - ptr as usize },
        68usize,
        concat!(
            "Offset of field: ",
            stringify!(CBaseEntity),
            "::",
            stringify!(ammo_357)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ammo_bolts) as usize - ptr as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(CBaseEntity),
            "::",
            stringify!(ammo_bolts)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ammo_buckshot) as usize - ptr as usize },
        76usize,
        concat!(
            "Offset of field: ",
            stringify!(CBaseEntity),
            "::",
            stringify!(ammo_buckshot)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ammo_rockets) as usize - ptr as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(CBaseEntity),
            "::",
            stringify!(ammo_rockets)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ammo_uranium) as usize - ptr as usize },
        84usize,
        concat!(
            "Offset of field: ",
            stringify!(CBaseEntity),
            "::",
            stringify!(ammo_uranium)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ammo_hornets) as usize - ptr as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(CBaseEntity),
            "::",
            stringify!(ammo_hornets)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).ammo_argrens) as usize - ptr as usize },
        92usize,
        concat!(
            "Offset of field: ",
            stringify!(CBaseEntity),
            "::",
            stringify!(ammo_argrens)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).m_flStartThrow) as usize - ptr as usize },
        96usize,
        concat!(
            "Offset of field: ",
            stringify!(CBaseEntity),
            "::",
            stringify!(m_flStartThrow)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).m_flReleaseThrow) as usize - ptr as usize },
        100usize,
        concat!(
            "Offset of field: ",
            stringify!(CBaseEntity),
            "::",
            stringify!(m_flReleaseThrow)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).m_chargeReady) as usize - ptr as usize },
        104usize,
        concat!(
            "Offset of field: ",
            stringify!(CBaseEntity),
            "::",
            stringify!(m_chargeReady)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).m_fInAttack) as usize - ptr as usize },
        108usize,
        concat!(
            "Offset of field: ",
            stringify!(CBaseEntity),
            "::",
            stringify!(m_fInAttack)
        )
    );
    assert_eq!(
        unsafe { ::std::ptr::addr_of!((*ptr).m_fireState) as usize - ptr as usize },
        112usize,
        concat!(
            "Offset of field: ",
            stringify!(CBaseEntity),
            "::",
            stringify!(m_fireState)
        )
    );
}
extern "C" {
    #[link_name = "\u{1}?UpdateOnRemove@CBaseEntity@@QEAAXXZ"]
    pub fn CBaseEntity_UpdateOnRemove(this: *mut CBaseEntity);
}
extern "C" {
    #[link_name = "\u{1}?SUB_Remove@CBaseEntity@@QEAAXXZ"]
    pub fn CBaseEntity_SUB_Remove(this: *mut CBaseEntity);
}
extern "C" {
    #[link_name = "\u{1}?SUB_DoNothing@CBaseEntity@@QEAAXXZ"]
    pub fn CBaseEntity_SUB_DoNothing(this: *mut CBaseEntity);
}
extern "C" {
    #[link_name = "\u{1}?SUB_StartFadeOut@CBaseEntity@@QEAAXXZ"]
    pub fn CBaseEntity_SUB_StartFadeOut(this: *mut CBaseEntity);
}
extern "C" {
    #[link_name = "\u{1}?SUB_FadeOut@CBaseEntity@@QEAAXXZ"]
    pub fn CBaseEntity_SUB_FadeOut(this: *mut CBaseEntity);
}
extern "C" {
    #[link_name = "\u{1}?ShouldToggle@CBaseEntity@@QEAAHW4USE_TYPE@@H@Z"]
    pub fn CBaseEntity_ShouldToggle(
        this: *mut CBaseEntity,
        useType: USE_TYPE,
        currentState: BOOL,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}?FireBullets@CBaseEntity@@QEAAXKVVector@@00MHHHPEAUentvars_s@@@Z"]
    pub fn CBaseEntity_FireBullets(
        this: *mut CBaseEntity,
        cShots: ULONG,
        vecSrc: Vector,
        vecDirShooting: Vector,
        vecSpread: Vector,
        flDistance: f32,
        iBulletType: ::std::os::raw::c_int,
        iTracerFreq: ::std::os::raw::c_int,
        iDamage: ::std::os::raw::c_int,
        pevAttacker: *mut entvars_t,
    );
}
extern "C" {
    #[link_name = "\u{1}?FireBulletsPlayer@CBaseEntity@@QEAA?AVVector@@KV2@00MHHHPEAUentvars_s@@H@Z"]
    pub fn CBaseEntity_FireBulletsPlayer(
        this: *mut CBaseEntity,
        cShots: ULONG,
        vecSrc: Vector,
        vecDirShooting: Vector,
        vecSpread: Vector,
        flDistance: f32,
        iBulletType: ::std::os::raw::c_int,
        iTracerFreq: ::std::os::raw::c_int,
        iDamage: ::std::os::raw::c_int,
        pevAttacker: *mut entvars_t,
        shared_rand: ::std::os::raw::c_int,
    ) -> Vector;
}
extern "C" {
    #[link_name = "\u{1}?SUB_UseTargets@CBaseEntity@@QEAAXPEAV1@W4USE_TYPE@@M@Z"]
    pub fn CBaseEntity_SUB_UseTargets(
        this: *mut CBaseEntity,
        pActivator: *mut CBaseEntity,
        useType: USE_TYPE,
        value: f32,
    );
}
extern "C" {
    #[link_name = "\u{1}?Intersects@CBaseEntity@@QEAAHPEAV1@@Z"]
    pub fn CBaseEntity_Intersects(
        this: *mut CBaseEntity,
        pOther: *mut CBaseEntity,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}?MakeDormant@CBaseEntity@@QEAAXXZ"]
    pub fn CBaseEntity_MakeDormant(this: *mut CBaseEntity);
}
extern "C" {
    #[link_name = "\u{1}?IsDormant@CBaseEntity@@QEAAHXZ"]
    pub fn CBaseEntity_IsDormant(this: *mut CBaseEntity) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}?Create@CBaseEntity@@SAPEAV1@PEADAEBVVector@@1PEAUedict_s@@@Z"]
    pub fn CBaseEntity_Create(
        szName: *mut ::std::os::raw::c_char,
        vecOrigin: *const Vector,
        vecAngles: *const Vector,
        pentOwner: *mut edict_t,
    ) -> *mut CBaseEntity;
}
impl CBaseEntity {
    #[inline]
    pub unsafe fn UpdateOnRemove(&mut self) {
        CBaseEntity_UpdateOnRemove(self)
    }
    #[inline]
    pub unsafe fn SUB_Remove(&mut self) {
        CBaseEntity_SUB_Remove(self)
    }
    #[inline]
    pub unsafe fn SUB_DoNothing(&mut self) {
        CBaseEntity_SUB_DoNothing(self)
    }
    #[inline]
    pub unsafe fn SUB_StartFadeOut(&mut self) {
        CBaseEntity_SUB_StartFadeOut(self)
    }
    #[inline]
    pub unsafe fn SUB_FadeOut(&mut self) {
        CBaseEntity_SUB_FadeOut(self)
    }
    #[inline]
    pub unsafe fn ShouldToggle(
        &mut self,
        useType: USE_TYPE,
        currentState: BOOL,
    ) -> ::std::os::raw::c_int {
        CBaseEntity_ShouldToggle(self, useType, currentState)
    }
    #[inline]
    pub unsafe fn FireBullets(
        &mut self,
        cShots: ULONG,
        vecSrc: Vector,
        vecDirShooting: Vector,
        vecSpread: Vector,
        flDistance: f32,
        iBulletType: ::std::os::raw::c_int,
        iTracerFreq: ::std::os::raw::c_int,
        iDamage: ::std::os::raw::c_int,
        pevAttacker: *mut entvars_t,
    ) {
        CBaseEntity_FireBullets(
            self,
            cShots,
            vecSrc,
            vecDirShooting,
            vecSpread,
            flDistance,
            iBulletType,
            iTracerFreq,
            iDamage,
            pevAttacker,
        )
    }
    #[inline]
    pub unsafe fn FireBulletsPlayer(
        &mut self,
        cShots: ULONG,
        vecSrc: Vector,
        vecDirShooting: Vector,
        vecSpread: Vector,
        flDistance: f32,
        iBulletType: ::std::os::raw::c_int,
        iTracerFreq: ::std::os::raw::c_int,
        iDamage: ::std::os::raw::c_int,
        pevAttacker: *mut entvars_t,
        shared_rand: ::std::os::raw::c_int,
    ) -> Vector {
        CBaseEntity_FireBulletsPlayer(
            self,
            cShots,
            vecSrc,
            vecDirShooting,
            vecSpread,
            flDistance,
            iBulletType,
            iTracerFreq,
            iDamage,
            pevAttacker,
            shared_rand,
        )
    }
    #[inline]
    pub unsafe fn SUB_UseTargets(
        &mut self,
        pActivator: *mut CBaseEntity,
        useType: USE_TYPE,
        value: f32,
    ) {
        CBaseEntity_SUB_UseTargets(self, pActivator, useType, value)
    }
    #[inline]
    pub unsafe fn Intersects(&mut self, pOther: *mut CBaseEntity) -> ::std::os::raw::c_int {
        CBaseEntity_Intersects(self, pOther)
    }
    #[inline]
    pub unsafe fn MakeDormant(&mut self) {
        CBaseEntity_MakeDormant(self)
    }
    #[inline]
    pub unsafe fn IsDormant(&mut self) -> ::std::os::raw::c_int {
        CBaseEntity_IsDormant(self)
    }
    #[inline]
    pub unsafe fn Create(
        szName: *mut ::std::os::raw::c_char,
        vecOrigin: *const Vector,
        vecAngles: *const Vector,
        pentOwner: *mut edict_t,
    ) -> *mut CBaseEntity {
        CBaseEntity_Create(szName, vecOrigin, vecAngles, pentOwner)
    }
}
extern "C" {
    #[link_name = "\u{1}?Save@CBaseEntity@@UEAAHAEAVCSave@@@Z"]
    pub fn CBaseEntity_Save(
        this: *mut ::std::os::raw::c_void,
        save: *mut CSave,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}?Restore@CBaseEntity@@UEAAHAEAVCRestore@@@Z"]
    pub fn CBaseEntity_Restore(
        this: *mut ::std::os::raw::c_void,
        restore: *mut CRestore,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}?SetObjectCollisionBox@CBaseEntity@@UEAAXXZ"]
    pub fn CBaseEntity_SetObjectCollisionBox(this: *mut ::std::os::raw::c_void);
}
extern "C" {
    #[link_name = "\u{1}?TraceAttack@CBaseEntity@@UEAAXPEAUentvars_s@@MVVector@@PEAUTraceResult@@H@Z"]
    pub fn CBaseEntity_TraceAttack(
        this: *mut ::std::os::raw::c_void,
        pevAttacker: *mut entvars_t,
        flDamage: f32,
        vecDir: Vector,
        ptr: *mut TraceResult,
        bitsDamageType: ::std::os::raw::c_int,
    );
}
extern "C" {
    #[link_name = "\u{1}?TakeDamage@CBaseEntity@@UEAAHPEAUentvars_s@@0MH@Z"]
    pub fn CBaseEntity_TakeDamage(
        this: *mut ::std::os::raw::c_void,
        pevInflictor: *mut entvars_t,
        pevAttacker: *mut entvars_t,
        flDamage: f32,
        bitsDamageType: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}?TakeHealth@CBaseEntity@@UEAAHMH@Z"]
    pub fn CBaseEntity_TakeHealth(
        this: *mut ::std::os::raw::c_void,
        flHealth: f32,
        bitsDamageType: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}?Killed@CBaseEntity@@UEAAXPEAUentvars_s@@H@Z"]
    pub fn CBaseEntity_Killed(
        this: *mut ::std::os::raw::c_void,
        pevAttacker: *mut entvars_t,
        iGib: ::std::os::raw::c_int,
    );
}
extern "C" {
    #[link_name = "\u{1}?TraceBleed@CBaseEntity@@UEAAXMVVector@@PEAUTraceResult@@H@Z"]
    pub fn CBaseEntity_TraceBleed(
        this: *mut ::std::os::raw::c_void,
        flDamage: f32,
        vecDir: Vector,
        ptr: *mut TraceResult,
        bitsDamageType: ::std::os::raw::c_int,
    );
}
extern "C" {
    #[link_name = "\u{1}?DamageDecal@CBaseEntity@@UEAAHH@Z"]
    pub fn CBaseEntity_DamageDecal(
        this: *mut ::std::os::raw::c_void,
        bitsDamageType: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[link_name = "\u{1}?IsInWorld@CBaseEntity@@UEAAHXZ"]
    pub fn CBaseEntity_IsInWorld(this: *mut ::std::os::raw::c_void) -> BOOL;
}
extern "C" {
    #[link_name = "\u{1}?GetNextTarget@CBaseEntity@@UEAAPEAV1@XZ"]
    pub fn CBaseEntity_GetNextTarget(this: *mut ::std::os::raw::c_void) -> *mut CBaseEntity;
}
extern "C" {
    #[link_name = "\u{1}?FVisible@CBaseEntity@@UEAAHPEAV1@@Z"]
    pub fn CBaseEntity_FVisible(
        this: *mut ::std::os::raw::c_void,
        pEntity: *mut CBaseEntity,
    ) -> BOOL;
}
extern "C" {
    #[link_name = "\u{1}?FVisible@CBaseEntity@@UEAAHAEBVVector@@@Z"]
    pub fn CBaseEntity_FVisible1(
        this: *mut ::std::os::raw::c_void,
        vecOrigin: *const Vector,
    ) -> BOOL;
}

[stevefan1999-personal]

Related: #2593