405 lines
12 KiB
C++
405 lines
12 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#ifndef BEAM_H
|
|
#define BEAM_H
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "baseentity_shared.h"
|
|
#include "baseplayer_shared.h"
|
|
#if !defined(CLIENT_DLL)
|
|
#include "entityoutput.h"
|
|
#endif
|
|
|
|
#include "beam_flags.h"
|
|
|
|
#define MAX_BEAM_WIDTH 102.3f
|
|
#define MAX_BEAM_SCROLLSPEED 100.0f
|
|
#define MAX_BEAM_NOISEAMPLITUDE 64
|
|
|
|
#define SF_BEAM_STARTON 0x0001
|
|
#define SF_BEAM_TOGGLE 0x0002
|
|
#define SF_BEAM_RANDOM 0x0004
|
|
#define SF_BEAM_RING 0x0008
|
|
#define SF_BEAM_SPARKSTART 0x0010
|
|
#define SF_BEAM_SPARKEND 0x0020
|
|
#define SF_BEAM_DECALS 0x0040
|
|
#define SF_BEAM_SHADEIN 0x0080
|
|
#define SF_BEAM_SHADEOUT 0x0100
|
|
#define SF_BEAM_TAPEROUT 0x0200 // Tapers to zero
|
|
#define SF_BEAM_TEMPORARY 0x8000
|
|
|
|
#define ATTACHMENT_INDEX_BITS 5
|
|
#define ATTACHMENT_INDEX_MASK ((1 << ATTACHMENT_INDEX_BITS) - 1)
|
|
|
|
#if defined(CLIENT_DLL)
|
|
#define CBeam C_Beam
|
|
#include "c_pixel_visibility.h"
|
|
#endif
|
|
|
|
class CBeam : public CBaseEntity {
|
|
DECLARE_CLASS(CBeam, CBaseEntity);
|
|
|
|
public:
|
|
DECLARE_NETWORKCLASS();
|
|
DECLARE_PREDICTABLE();
|
|
#if !defined(CLIENT_DLL)
|
|
DECLARE_DATADESC();
|
|
#endif
|
|
|
|
CBeam();
|
|
|
|
virtual void SetModel(const char *szModelName);
|
|
|
|
void Spawn(void);
|
|
void Precache(void);
|
|
#if !defined(CLIENT_DLL)
|
|
int ObjectCaps(void);
|
|
void SetTransmit(CCheckTransmitInfo *pInfo, bool bAlways);
|
|
int UpdateTransmitState(void);
|
|
int ShouldTransmit(const CCheckTransmitInfo *pInfo);
|
|
#endif
|
|
|
|
virtual int DrawDebugTextOverlays(void);
|
|
|
|
// These functions are here to show the way beams are encoded as entities.
|
|
// Encoding beams as entities simplifies their management in the
|
|
// client/server architecture
|
|
void SetType(int type);
|
|
void SetBeamFlags(int flags);
|
|
void SetBeamFlag(int flag);
|
|
|
|
// NOTE: Start + End Pos are specified in *relative* coordinates
|
|
void SetStartPos(const Vector &pos);
|
|
void SetEndPos(const Vector &pos);
|
|
|
|
// This will change things so the abs position matches the requested spot
|
|
void SetAbsStartPos(const Vector &pos);
|
|
void SetAbsEndPos(const Vector &pos);
|
|
|
|
const Vector &GetAbsStartPos(void) const;
|
|
const Vector &GetAbsEndPos(void) const;
|
|
|
|
void SetStartEntity(CBaseEntity *pEntity);
|
|
void SetEndEntity(CBaseEntity *pEntity);
|
|
|
|
void SetStartAttachment(int attachment);
|
|
void SetEndAttachment(int attachment);
|
|
|
|
void SetTexture(int spriteIndex);
|
|
void SetHaloTexture(int spriteIndex);
|
|
void SetHaloScale(float haloScale);
|
|
void SetWidth(float width);
|
|
void SetEndWidth(float endWidth);
|
|
void SetFadeLength(float fadeLength);
|
|
void SetNoise(float amplitude);
|
|
void SetColor(int r, int g, int b);
|
|
void SetBrightness(int brightness);
|
|
void SetFrame(float frame);
|
|
void SetScrollRate(int speed);
|
|
void SetFireTime(float flFireTime);
|
|
void SetFrameRate(float flFrameRate) { m_flFrameRate = flFrameRate; }
|
|
|
|
void SetMinDXLevel(int nMinDXLevel) { m_nMinDXLevel = nMinDXLevel; }
|
|
|
|
void TurnOn(void);
|
|
void TurnOff(void);
|
|
|
|
int GetType(void) const;
|
|
int GetBeamFlags(void) const;
|
|
CBaseEntity *GetStartEntityPtr(void) const;
|
|
int GetStartEntity(void) const;
|
|
CBaseEntity *GetEndEntityPtr(void) const;
|
|
int GetEndEntity(void) const;
|
|
int GetStartAttachment() const;
|
|
int GetEndAttachment() const;
|
|
|
|
virtual const Vector &WorldSpaceCenter(void) const;
|
|
|
|
int GetTexture(void);
|
|
float GetWidth(void) const;
|
|
float GetEndWidth(void) const;
|
|
float GetFadeLength(void) const;
|
|
float GetNoise(void) const;
|
|
int GetBrightness(void) const;
|
|
float GetFrame(void) const;
|
|
float GetScrollRate(void) const;
|
|
float GetHDRColorScale(void) const;
|
|
void SetHDRColorScale(float flScale) { m_flHDRColorScale = flScale; }
|
|
|
|
// Call after you change start/end positions
|
|
void RelinkBeam(void);
|
|
|
|
void DoSparks(const Vector &start, const Vector &end);
|
|
CBaseEntity *RandomTargetname(const char *szName);
|
|
void BeamDamage(trace_t *ptr);
|
|
// Init after BeamCreate()
|
|
void BeamInit(const char *pSpriteName, float width);
|
|
void PointsInit(const Vector &start, const Vector &end);
|
|
void PointEntInit(const Vector &start, CBaseEntity *pEndEntity);
|
|
void EntsInit(CBaseEntity *pStartEntity, CBaseEntity *pEndEntity);
|
|
void LaserInit(CBaseEntity *pStartEntity, CBaseEntity *pEndEntity);
|
|
void HoseInit(const Vector &start, const Vector &direction);
|
|
void SplineInit(int nNumEnts, CBaseEntity **pEntList, int *attachment);
|
|
|
|
// Input handlers
|
|
|
|
static CBeam *BeamCreate(const char *pSpriteName, float width);
|
|
static CBeam *BeamCreatePredictable(const char *module, int line,
|
|
bool persist, const char *pSpriteName,
|
|
float width, CBasePlayer *pOwner);
|
|
|
|
void LiveForTime(float time);
|
|
void BeamDamageInstant(trace_t *ptr, float damage);
|
|
|
|
// Only supported in TF2 right now
|
|
#if defined(INVASION_CLIENT_DLL)
|
|
virtual bool ShouldPredict(void) { return true; }
|
|
#endif
|
|
|
|
virtual const char *GetDecalName(void) { return "BigShot"; }
|
|
|
|
#if defined(CLIENT_DLL)
|
|
// IClientEntity overrides.
|
|
public:
|
|
virtual int DrawModel(int flags);
|
|
virtual bool IsTransparent(void);
|
|
virtual bool ShouldDraw();
|
|
virtual bool IgnoresZBuffer(void) const { return true; }
|
|
virtual void OnDataChanged(DataUpdateType_t updateType);
|
|
|
|
virtual bool OnPredictedEntityRemove(bool isbeingremoved,
|
|
C_BaseEntity *predicted);
|
|
|
|
// Add beam to visible entities list?
|
|
virtual void AddEntity(void);
|
|
virtual bool ShouldReceiveProjectedTextures(int flags) { return false; }
|
|
|
|
// Beam Data Elements
|
|
private:
|
|
// Computes the bounding box of a beam local to the origin of the beam
|
|
void ComputeBounds(Vector &mins, Vector &maxs);
|
|
|
|
friend void RecvProxy_Beam_ScrollSpeed(const CRecvProxyData *pData,
|
|
void *pStruct, void *pOut);
|
|
friend class CViewRenderBeams;
|
|
|
|
#endif
|
|
|
|
protected:
|
|
CNetworkVar(float, m_flFrameRate);
|
|
CNetworkVar(float, m_flHDRColorScale);
|
|
float m_flFireTime;
|
|
float m_flDamage; // Damage per second to touchers.
|
|
CNetworkVar(int, m_nNumBeamEnts);
|
|
#if defined(CLIENT_DLL)
|
|
pixelvis_handle_t m_queryHandleHalo;
|
|
#endif
|
|
|
|
private:
|
|
#if !defined(CLIENT_DLL)
|
|
void InputNoise(inputdata_t &inputdata);
|
|
void InputWidth(inputdata_t &inputdata);
|
|
void InputColorRedValue(inputdata_t &inputdata);
|
|
void InputColorBlueValue(inputdata_t &inputdata);
|
|
void InputColorGreenValue(inputdata_t &inputdata);
|
|
#endif
|
|
|
|
// Beam Data Elements
|
|
CNetworkVar(int, m_nHaloIndex);
|
|
CNetworkVar(int, m_nBeamType);
|
|
CNetworkVar(int, m_nBeamFlags);
|
|
CNetworkArray(EHANDLE, m_hAttachEntity, MAX_BEAM_ENTS);
|
|
CNetworkArray(int, m_nAttachIndex, MAX_BEAM_ENTS);
|
|
CNetworkVar(float, m_fWidth);
|
|
CNetworkVar(float, m_fEndWidth);
|
|
CNetworkVar(float, m_fFadeLength);
|
|
CNetworkVar(float, m_fHaloScale);
|
|
CNetworkVar(float, m_fAmplitude);
|
|
CNetworkVar(float, m_fStartFrame);
|
|
CNetworkVar(float, m_fSpeed);
|
|
CNetworkVar(int, m_nMinDXLevel);
|
|
CNetworkVar(float, m_flFrame);
|
|
|
|
CNetworkVector(m_vecEndPos);
|
|
|
|
EHANDLE m_hEndEntity;
|
|
|
|
#if !defined(CLIENT_DLL)
|
|
int m_nDissolveType;
|
|
#endif
|
|
|
|
public:
|
|
#ifdef PORTAL
|
|
CNetworkVar(bool, m_bDrawInMainRender);
|
|
CNetworkVar(bool, m_bDrawInPortalRender);
|
|
#endif //#ifdef PORTAL
|
|
};
|
|
|
|
#if !defined(CLIENT_DLL)
|
|
//-----------------------------------------------------------------------------
|
|
// Inline methods
|
|
//-----------------------------------------------------------------------------
|
|
inline int CBeam::ObjectCaps(void) {
|
|
int flags = 0;
|
|
if (HasSpawnFlags(SF_BEAM_TEMPORARY)) flags = FCAP_DONT_SAVE;
|
|
return (BaseClass::ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | flags;
|
|
}
|
|
#endif
|
|
|
|
inline void CBeam::SetFireTime(float flFireTime) { m_flFireTime = flFireTime; }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// NOTE: Start + End Pos are specified in *relative* coordinates
|
|
//-----------------------------------------------------------------------------
|
|
inline void CBeam::SetStartPos(const Vector &pos) {
|
|
#if defined(CLIENT_DLL)
|
|
SetNetworkOrigin(pos);
|
|
#endif
|
|
SetLocalOrigin(pos);
|
|
}
|
|
|
|
inline void CBeam::SetEndPos(const Vector &pos) { m_vecEndPos = pos; }
|
|
|
|
// center point of beam
|
|
inline const Vector &CBeam::WorldSpaceCenter(void) const {
|
|
Vector &vecResult = AllocTempVector();
|
|
VectorAdd(GetAbsStartPos(), GetAbsEndPos(), vecResult);
|
|
vecResult *= 0.5f;
|
|
return vecResult;
|
|
}
|
|
|
|
inline void CBeam::SetStartAttachment(int attachment) {
|
|
Assert((attachment & ~ATTACHMENT_INDEX_MASK) == 0);
|
|
m_nAttachIndex.Set(0, attachment);
|
|
}
|
|
|
|
inline void CBeam::SetEndAttachment(int attachment) {
|
|
Assert((attachment & ~ATTACHMENT_INDEX_MASK) == 0);
|
|
m_nAttachIndex.Set(m_nNumBeamEnts - 1, attachment);
|
|
}
|
|
|
|
inline void CBeam::SetTexture(int spriteIndex) { SetModelIndex(spriteIndex); }
|
|
|
|
inline void CBeam::SetHaloTexture(int spriteIndex) {
|
|
m_nHaloIndex = spriteIndex;
|
|
}
|
|
|
|
inline void CBeam::SetHaloScale(float haloScale) { m_fHaloScale = haloScale; }
|
|
|
|
inline void CBeam::SetWidth(float width) {
|
|
Assert(width <= MAX_BEAM_WIDTH);
|
|
m_fWidth = MIN(MAX_BEAM_WIDTH, width);
|
|
}
|
|
|
|
inline void CBeam::SetEndWidth(float endWidth) {
|
|
Assert(endWidth <= MAX_BEAM_WIDTH);
|
|
m_fEndWidth = MIN(MAX_BEAM_WIDTH, endWidth);
|
|
}
|
|
|
|
inline void CBeam::SetFadeLength(float fadeLength) {
|
|
m_fFadeLength = fadeLength;
|
|
}
|
|
|
|
inline void CBeam::SetNoise(float amplitude) { m_fAmplitude = amplitude; }
|
|
|
|
inline void CBeam::SetColor(int r, int g, int b) {
|
|
SetRenderColor(r, g, b, GetRenderColor().a);
|
|
}
|
|
|
|
inline void CBeam::SetBrightness(int brightness) {
|
|
SetRenderColorA(brightness);
|
|
}
|
|
|
|
inline void CBeam::SetFrame(float frame) { m_fStartFrame = frame; }
|
|
|
|
inline void CBeam::SetScrollRate(int speed) { m_fSpeed = speed; }
|
|
|
|
inline CBaseEntity *CBeam::GetStartEntityPtr(void) const {
|
|
return m_hAttachEntity[0].Get();
|
|
}
|
|
|
|
inline int CBeam::GetStartEntity(void) const {
|
|
CBaseEntity *pEntity = m_hAttachEntity[0].Get();
|
|
return pEntity ? pEntity->entindex() : 0;
|
|
}
|
|
|
|
inline CBaseEntity *CBeam::GetEndEntityPtr(void) const {
|
|
return m_hAttachEntity[1].Get();
|
|
}
|
|
|
|
inline int CBeam::GetEndEntity(void) const {
|
|
CBaseEntity *pEntity = m_hAttachEntity[m_nNumBeamEnts - 1].Get();
|
|
return pEntity ? pEntity->entindex() : 0;
|
|
}
|
|
|
|
inline int CBeam::GetStartAttachment() const {
|
|
return m_nAttachIndex[0] & ATTACHMENT_INDEX_MASK;
|
|
}
|
|
|
|
inline int CBeam::GetEndAttachment() const {
|
|
return m_nAttachIndex[m_nNumBeamEnts - 1] & ATTACHMENT_INDEX_MASK;
|
|
}
|
|
|
|
inline int CBeam::GetTexture(void) { return GetModelIndex(); }
|
|
|
|
inline float CBeam::GetWidth(void) const { return m_fWidth; }
|
|
|
|
inline float CBeam::GetEndWidth(void) const { return m_fEndWidth; }
|
|
|
|
inline float CBeam::GetFadeLength(void) const { return m_fFadeLength; }
|
|
|
|
inline float CBeam::GetNoise(void) const { return m_fAmplitude; }
|
|
|
|
inline int CBeam::GetBrightness(void) const { return GetRenderColor().a; }
|
|
|
|
inline float CBeam::GetFrame(void) const { return m_fStartFrame; }
|
|
|
|
inline float CBeam::GetScrollRate(void) const { return m_fSpeed; }
|
|
|
|
inline float CBeam::GetHDRColorScale(void) const { return m_flHDRColorScale; }
|
|
|
|
inline void CBeam::LiveForTime(float time) {
|
|
SetThink(&CBeam::SUB_Remove);
|
|
SetNextThink(gpGlobals->curtime + time);
|
|
}
|
|
|
|
inline void CBeam::BeamDamageInstant(trace_t *ptr, float damage) {
|
|
m_flDamage = damage;
|
|
m_flFireTime = gpGlobals->curtime - 1;
|
|
BeamDamage(ptr);
|
|
}
|
|
|
|
bool IsStaticPointEntity(CBaseEntity *pEnt);
|
|
|
|
// Macro to wrap creation
|
|
#define BEAM_CREATE_PREDICTABLE(name, width, player) \
|
|
CBeam::BeamCreatePredictable(__FILE__, __LINE__, false, name, width, player)
|
|
|
|
#define BEAM_CREATE_PREDICTABLE_PERSIST(name, width, player) \
|
|
CBeam::BeamCreatePredictable(__FILE__, __LINE__, true, name, width, player)
|
|
|
|
// Start/End Entity is encoded as 12 bits of entity index, and 4 bits of
|
|
// attachment (4:12)
|
|
#define BEAMENT_ENTITY(x) ((x)&0xFFF)
|
|
#define BEAMENT_ATTACHMENT(x) (((x) >> 12) & 0xF)
|
|
|
|
// Beam types, encoded as a byte
|
|
enum {
|
|
BEAM_POINTS = 0,
|
|
BEAM_ENTPOINT,
|
|
BEAM_ENTS,
|
|
BEAM_HOSE,
|
|
BEAM_SPLINE,
|
|
BEAM_LASER,
|
|
NUM_BEAM_TYPES
|
|
};
|
|
|
|
#endif // BEAM_H
|