Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

297 lines
7.9 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#ifndef SPRITE_H
#define SPRITE_H
#ifdef _WIN32
#pragma once
#endif
#include "predictable_entity.h"
#include "baseentity_shared.h"
#define SF_SPRITE_STARTON 0x0001
#define SF_SPRITE_ONCE 0x0002
#define SF_SPRITE_TEMPORARY 0x8000
class CBasePlayer;
#if defined( CLIENT_DLL )
#define CSprite C_Sprite
#define CSpriteOriented C_SpriteOriented
#include "c_pixel_visibility.h"
class CEngineSprite;
class C_SpriteRenderer
{
public:
//-----------------------------------------------------------------------------
// Purpose: Sprite orientations
// WARNING! Change these in common/MaterialSystem/Sprite.cpp if you change them here!
//-----------------------------------------------------------------------------
typedef enum
{
SPR_VP_PARALLEL_UPRIGHT = 0,
SPR_FACING_UPRIGHT = 1,
SPR_VP_PARALLEL = 2,
SPR_ORIENTED = 3,
SPR_VP_PARALLEL_ORIENTED = 4
} SPRITETYPE;
// Determine sprite orientation
static void GetSpriteAxes( SPRITETYPE type,
const Vector& origin,
const QAngle& angles,
Vector& forward,
Vector& right,
Vector& up );
// Sprites can alter blending amount
virtual float GlowBlend( CEngineSprite *psprite, const Vector& entorigin, int rendermode, int renderfx, int alpha, float *scale );
// Draws tempent as a sprite
int DrawSprite(
IClientEntity *entity,
const model_t *model,
const Vector& origin,
const QAngle& angles,
float frame,
IClientEntity *attachedto,
int attachmentindex,
int rendermode,
int renderfx,
int alpha,
int r,
int g,
int b,
float scale,
float flHDRColorScale = 1.0f
);
protected:
pixelvis_handle_t m_queryHandle;
float m_flGlowProxySize;
float m_flHDRColorScale;
};
#endif
class CSprite : public CBaseEntity
#if defined( CLIENT_DLL )
, public C_SpriteRenderer
#endif
{
DECLARE_CLASS( CSprite, CBaseEntity );
public:
DECLARE_PREDICTABLE();
DECLARE_NETWORKCLASS();
CSprite();
virtual void SetModel( const char *szModelName );
void Spawn( void );
void Precache( void );
virtual void ComputeWorldSpaceSurroundingBox( Vector *pVecWorldMins, Vector *pVecWorldMaxs );
void SetGlowProxySize( float flSize ) { m_flGlowProxySize = flSize; }
#if !defined( CLIENT_DLL )
virtual int ShouldTransmit( const CCheckTransmitInfo *pInfo );
virtual int UpdateTransmitState( void );
void SetAsTemporary( void ) { AddSpawnFlags( SF_SPRITE_TEMPORARY ); }
bool IsTemporary( void ) { return ( HasSpawnFlags( SF_SPRITE_TEMPORARY ) ); }
int ObjectCaps( void )
{
int flags = 0;
if ( IsTemporary() )
{
flags = FCAP_DONT_SAVE;
}
return (BaseClass::ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | flags;
}
void OnRestore();
#endif
void AnimateThink( void );
void ExpandThink( void );
void Animate( float frames );
void Expand( float scaleSpeed, float fadeSpeed );
void SpriteInit( const char *pSpriteName, const Vector &origin );
#if !defined( CLIENT_DLL )
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
// Input handlers
void InputHideSprite( inputdata_t &inputdata );
void InputShowSprite( inputdata_t &inputdata );
void InputToggleSprite( inputdata_t &inputdata );
void InputColorRedValue( inputdata_t &inputdata );
void InputColorBlueValue( inputdata_t &inputdata );
void InputColorGreenValue( inputdata_t &inputdata );
#endif
inline void SetAttachment( CBaseEntity *pEntity, int attachment )
{
if ( pEntity )
{
m_hAttachedToEntity = pEntity;
m_nAttachment = attachment;
FollowEntity( pEntity );
}
}
void TurnOff( void );
void TurnOn( void );
bool IsOn() { return !IsEffectActive( EF_NODRAW ); }
inline float Frames( void ) { return m_flMaxFrame; }
inline void SetTransparency( int rendermode, int r, int g, int b, int a, int fx )
{
SetRenderMode( (RenderMode_t)rendermode );
SetColor( r, g, b );
SetBrightness( a );
m_nRenderFX = fx;
}
inline void SetTexture( int spriteIndex ) { SetModelIndex( spriteIndex ); }
inline void SetColor( int r, int g, int b ) { SetRenderColor( r, g, b, GetRenderColor().a ); }
void SetBrightness( int brightness, float duration = 0.0f );
void SetScale( float scale, float duration = 0.0f );
void SetSpriteScale( float scale );
void EnableWorldSpaceScale( bool bEnable );
float GetScale( void ) { return m_flSpriteScale; }
int GetBrightness( void ) { return m_nBrightness; }
float GetHDRColorScale( void ) { return m_flHDRColorScale; }
inline void FadeAndDie( float duration )
{
SetBrightness( 0, duration );
SetThink(&CSprite::AnimateUntilDead);
m_flDieTime = gpGlobals->curtime + duration;
SetNextThink( gpGlobals->curtime );
}
inline void AnimateAndDie( float framerate )
{
SetThink(&CSprite::AnimateUntilDead);
m_flSpriteFramerate = framerate;
m_flDieTime = gpGlobals->curtime + (m_flMaxFrame / m_flSpriteFramerate);
SetNextThink( gpGlobals->curtime );
}
inline void AnimateForTime( float framerate, float time )
{
SetThink(&CSprite::AnimateUntilDead);
m_flSpriteFramerate = framerate;
m_flDieTime = gpGlobals->curtime + time;
SetNextThink( gpGlobals->curtime );
}
// FIXME: This completely blows.
// Surely there's gotta be a better way.
void FadeOutFromSpawn( )
{
SetThink(&CSprite::BeginFadeOutThink);
SetNextThink( gpGlobals->curtime + 0.01f );
}
void BeginFadeOutThink( )
{
FadeAndDie( 0.25f );
}
void AnimateUntilDead( void );
#if !defined( CLIENT_DLL )
DECLARE_DATADESC();
static CSprite *SpriteCreate( const char *pSpriteName, const Vector &origin, bool animate );
#endif
static CSprite *SpriteCreatePredictable( const char *module, int line, const char *pSpriteName, const Vector &origin, bool animate );
#if defined( CLIENT_DLL )
virtual float GetRenderScale( void );
virtual int GetRenderBrightness( void );
virtual int DrawModel( int flags );
virtual const Vector& GetRenderOrigin();
virtual void GetRenderBounds( Vector &vecMins, Vector &vecMaxs );
virtual float GlowBlend( CEngineSprite *psprite, const Vector& entorigin, int rendermode, int renderfx, int alpha, float *scale );
virtual void GetToolRecordingState( KeyValues *msg );
// Only supported in TF2 right now
#if defined( INVASION_CLIENT_DLL )
virtual bool ShouldPredict( void )
{
return true;
}
#endif
virtual void ClientThink( void );
virtual void OnDataChanged( DataUpdateType_t updateType );
#endif
public:
CNetworkHandle( CBaseEntity, m_hAttachedToEntity );
CNetworkVar( int, m_nAttachment );
CNetworkVar( float, m_flSpriteFramerate );
CNetworkVar( float, m_flFrame );
#ifdef PORTAL
CNetworkVar( bool, m_bDrawInMainRender );
CNetworkVar( bool, m_bDrawInPortalRender );
#endif
float m_flDieTime;
private:
CNetworkVar( int, m_nBrightness );
CNetworkVar( float, m_flBrightnessTime );
CNetworkVar( float, m_flSpriteScale );
CNetworkVar( float, m_flScaleTime );
CNetworkVar( bool, m_bWorldSpaceScale );
CNetworkVar( float, m_flGlowProxySize );
CNetworkVar( float, m_flHDRColorScale );
float m_flLastTime;
float m_flMaxFrame;
float m_flStartScale;
float m_flDestScale; //Destination scale
float m_flScaleTimeStart; //Real time for start of scale
int m_nStartBrightness;
int m_nDestBrightness; //Destination brightness
float m_flBrightnessTimeStart;//Real time for brightness
};
class CSpriteOriented : public CSprite
{
public:
DECLARE_CLASS( CSpriteOriented, CSprite );
#if !defined( CLIENT_DLL )
DECLARE_SERVERCLASS();
void Spawn( void );
#else
DECLARE_CLIENTCLASS();
virtual bool IsTransparent( void );
#endif
};
// Macro to wrap creation
#define SPRITE_CREATE_PREDICTABLE( name, origin, animate ) \
CSprite::SpriteCreatePredictable( __FILE__, __LINE__, name, origin, animate )
#endif // SPRITE_H