Counter Strike : Global Offensive Source Code
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.
 
 
 
 
 
 

335 lines
13 KiB

//===== Copyright © 1996-2005, Valve Corporation, All rights reserved. ======//
//
// Purpose:
//
// $NoKeywords: $
//===========================================================================//
#ifndef ICLIENTRENDERABLE_H
#define ICLIENTRENDERABLE_H
#ifdef _WIN32
#pragma once
#endif
#include "mathlib/mathlib.h"
#include "interface.h"
#include "iclientunknown.h"
#include "client_render_handle.h"
#include "engine/ivmodelrender.h"
struct model_t;
struct matrix3x4_t;
extern void DefaultRenderBoundsWorldspace( IClientRenderable *pRenderable, Vector &absMins, Vector &absMaxs );
//-----------------------------------------------------------------------------
// Handles to a client shadow
//-----------------------------------------------------------------------------
typedef unsigned short ClientShadowHandle_t;
enum
{
CLIENTSHADOW_INVALID_HANDLE = (ClientShadowHandle_t)~0
};
//-----------------------------------------------------------------------------
// What kind of shadows to render?
//-----------------------------------------------------------------------------
enum ShadowType_t
{
SHADOWS_NONE = 0,
SHADOWS_SIMPLE,
SHADOWS_RENDER_TO_TEXTURE,
SHADOWS_RENDER_TO_TEXTURE_DYNAMIC, // the shadow is always changing state
SHADOWS_RENDER_TO_DEPTH_TEXTURE,
SHADOWS_RENDER_TO_TEXTURE_DYNAMIC_CUSTOM, // changing, and entity uses custom rendering code for shadow
};
// This provides a way for entities to know when they've entered or left the PVS.
// Normally, server entities can use NotifyShouldTransmit to get this info, but client-only
// entities can use this. Store a CPVSNotifyInfo in your
//
// When bInPVS=true, it's being called DURING rendering. It might be after rendering any
// number of views.
//
// If no views had the entity, then it is called with bInPVS=false after rendering.
abstract_class IPVSNotify
{
public:
virtual void OnPVSStatusChanged( bool bInPVS ) = 0;
};
//-----------------------------------------------------------------------------
// Information needed to draw a model
//-----------------------------------------------------------------------------
struct RenderableInstance_t
{
uint8 m_nAlpha;
};
// client renderable frame buffer usage flags
#define ERENDERFLAGS_NEEDS_POWER_OF_TWO_FB 1 // needs refract texture
#define ERENDERFLAGS_NEEDS_FULL_FB 2 // needs full framebuffer texture
#define ERENDERFLAGS_REFRACT_ONLY_ONCE_PER_FRAME 4 // even if it needs a the refract texture, don't update it >once/ frame
//-----------------------------------------------------------------------------
// Purpose: All client entities must implement this interface.
//-----------------------------------------------------------------------------
abstract_class IClientRenderable
{
public:
// Gets at the containing class...
virtual IClientUnknown* GetIClientUnknown() = 0;
// Data accessors
virtual Vector const& GetRenderOrigin( void ) = 0;
virtual QAngle const& GetRenderAngles( void ) = 0;
virtual bool ShouldDraw( void ) = 0;
virtual int GetRenderFlags( void ) = 0; // ERENDERFLAGS_xxx
virtual void Unused( void ) const {}
virtual ClientShadowHandle_t GetShadowHandle() const = 0;
// Used by the leaf system to store its render handle.
virtual ClientRenderHandle_t& RenderHandle() = 0;
// Render baby!
virtual const model_t* GetModel( ) const = 0;
virtual int DrawModel( int flags, const RenderableInstance_t &instance ) = 0;
// Get the body parameter
virtual int GetBody() = 0;
// Determine the color modulation amount
virtual void GetColorModulation( float* color ) = 0;
// Returns false if the entity shouldn't be drawn due to LOD.
// (NOTE: This is no longer used/supported, but kept in the vtable for backwards compat)
virtual bool LODTest() = 0;
// Call this to get the current bone transforms for the model.
// currentTime parameter will affect interpolation
// nMaxBones specifies how many matrices pBoneToWorldOut can hold. (Should be greater than or
// equal to studiohdr_t::numbones. Use MAXSTUDIOBONES to be safe.)
virtual bool SetupBones( matrix3x4a_t *pBoneToWorldOut, int nMaxBones, int boneMask, float currentTime ) = 0;
virtual void SetupWeights( const matrix3x4_t *pBoneToWorld, int nFlexWeightCount, float *pFlexWeights, float *pFlexDelayedWeights ) = 0;
virtual void DoAnimationEvents( void ) = 0;
// Return this if you want PVS notifications. See IPVSNotify for more info.
// Note: you must always return the same value from this function. If you don't,
// undefined things will occur, and they won't be good.
virtual IPVSNotify* GetPVSNotifyInterface() = 0;
// Returns the bounds relative to the origin (render bounds)
virtual void GetRenderBounds( Vector& mins, Vector& maxs ) = 0;
// returns the bounds as an AABB in worldspace
virtual void GetRenderBoundsWorldspace( Vector& mins, Vector& maxs ) = 0;
// These normally call through to GetRenderAngles/GetRenderBounds, but some entities custom implement them.
virtual void GetShadowRenderBounds( Vector &mins, Vector &maxs, ShadowType_t shadowType ) = 0;
// Should this object be able to have shadows cast onto it?
virtual bool ShouldReceiveProjectedTextures( int flags ) = 0;
// These methods return true if we want a per-renderable shadow cast direction + distance
virtual bool GetShadowCastDistance( float *pDist, ShadowType_t shadowType ) const = 0;
virtual bool GetShadowCastDirection( Vector *pDirection, ShadowType_t shadowType ) const = 0;
// Other methods related to shadow rendering
virtual bool IsShadowDirty( ) = 0;
virtual void MarkShadowDirty( bool bDirty ) = 0;
// Iteration over shadow hierarchy
virtual IClientRenderable *GetShadowParent() = 0;
virtual IClientRenderable *FirstShadowChild() = 0;
virtual IClientRenderable *NextShadowPeer() = 0;
// Returns the shadow cast type
virtual ShadowType_t ShadowCastType() = 0;
virtual void Unused2() {}
// Create/get/destroy model instance
virtual void CreateModelInstance() = 0;
virtual ModelInstanceHandle_t GetModelInstance() = 0;
// Returns the transform from RenderOrigin/RenderAngles to world
virtual const matrix3x4_t &RenderableToWorldTransform() = 0;
// Attachments
virtual int LookupAttachment( const char *pAttachmentName ) = 0;
virtual bool GetAttachment( int number, Vector &origin, QAngle &angles ) = 0;
virtual bool GetAttachment( int number, matrix3x4_t &matrix ) = 0;
virtual bool ComputeLightingOrigin( int nAttachmentIndex, Vector modelLightingCenter, const matrix3x4_t &matrix, Vector &transformedLightingCenter ) = 0;
// Rendering clip plane, should be 4 floats, return value of NULL indicates a disabled render clip plane
virtual float *GetRenderClipPlane( void ) = 0;
// Get the skin parameter
virtual int GetSkin() = 0;
virtual void OnThreadedDrawSetup() = 0;
virtual bool UsesFlexDelayedWeights() = 0;
virtual void RecordToolMessage() = 0;
virtual bool ShouldDrawForSplitScreenUser( int nSlot ) = 0;
// NOTE: This is used by renderables to override the default alpha modulation,
// not including fades, for a renderable. The alpha passed to the function
// is the alpha computed based on the current renderfx.
virtual uint8 OverrideAlphaModulation( uint8 nAlpha ) = 0;
// NOTE: This is used by renderables to override the default alpha modulation,
// not including fades, for a renderable's shadow. The alpha passed to the function
// is the alpha computed based on the current renderfx + any override
// computed in OverrideAlphaModulation
virtual uint8 OverrideShadowAlphaModulation( uint8 nAlpha ) = 0;
virtual IClientModelRenderable* GetClientModelRenderable() = 0;
};
//-----------------------------------------------------------------------------
// Purpose: All client renderables supporting the fast-path mdl
// rendering algorithm must inherit from this interface
//-----------------------------------------------------------------------------
enum RenderableLightingModel_t
{
LIGHTING_MODEL_NONE = -1,
LIGHTING_MODEL_STANDARD = 0,
LIGHTING_MODEL_STATIC_PROP,
LIGHTING_MODEL_PHYSICS_PROP,
LIGHTING_MODEL_COUNT,
};
enum ModelDataCategory_t
{
MODEL_DATA_LIGHTING_MODEL, // data type returned is a RenderableLightingModel_t
MODEL_DATA_STENCIL, // data type returned is a ShaderStencilState_t
MODEL_DATA_CATEGORY_COUNT,
};
abstract_class IClientModelRenderable
{
public:
virtual bool GetRenderData( void *pData, ModelDataCategory_t nCategory ) = 0;
};
// This class can be used to implement default versions of some of the
// functions of IClientRenderable.
abstract_class CDefaultClientRenderable : public IClientUnknown, public IClientRenderable
{
public:
CDefaultClientRenderable()
{
m_hRenderHandle = INVALID_CLIENT_RENDER_HANDLE;
}
virtual const Vector & GetRenderOrigin( void ) = 0;
virtual const QAngle & GetRenderAngles( void ) = 0;
virtual const matrix3x4_t & RenderableToWorldTransform() = 0;
virtual bool ShouldDraw( void ) = 0;
virtual void OnThreadedDrawSetup() {}
virtual int GetRenderFlags( void ) { return 0; }
virtual ClientShadowHandle_t GetShadowHandle() const
{
return CLIENTSHADOW_INVALID_HANDLE;
}
virtual ClientRenderHandle_t& RenderHandle()
{
return m_hRenderHandle;
}
virtual int GetBody() { return 0; }
virtual int GetSkin() { return 0; }
virtual bool UsesFlexDelayedWeights() { return false; }
virtual const model_t* GetModel( ) const { return NULL; }
virtual int DrawModel( int flags, const RenderableInstance_t &instance ) { return 0; }
virtual bool LODTest() { return true; }
virtual bool SetupBones( matrix3x4a_t *pBoneToWorldOut, int nMaxBones, int boneMask, float currentTime ) { return true; }
virtual void SetupWeights( const matrix3x4_t *pBoneToWorld, int nFlexWeightCount, float *pFlexWeights, float *pFlexDelayedWeights ) {}
virtual void DoAnimationEvents( void ) {}
virtual IPVSNotify* GetPVSNotifyInterface() { return NULL; }
virtual void GetRenderBoundsWorldspace( Vector& absMins, Vector& absMaxs ) { DefaultRenderBoundsWorldspace( this, absMins, absMaxs ); }
// Determine the color modulation amount
virtual void GetColorModulation( float* color )
{
Assert(color);
color[0] = color[1] = color[2] = 1.0f;
}
// Should this object be able to have shadows cast onto it?
virtual bool ShouldReceiveProjectedTextures( int flags )
{
return false;
}
// These methods return true if we want a per-renderable shadow cast direction + distance
virtual bool GetShadowCastDistance( float *pDist, ShadowType_t shadowType ) const { return false; }
virtual bool GetShadowCastDirection( Vector *pDirection, ShadowType_t shadowType ) const { return false; }
virtual void GetShadowRenderBounds( Vector &mins, Vector &maxs, ShadowType_t shadowType )
{
GetRenderBounds( mins, maxs );
}
virtual bool IsShadowDirty( ) { return false; }
virtual void MarkShadowDirty( bool bDirty ) {}
virtual IClientRenderable *GetShadowParent() { return NULL; }
virtual IClientRenderable *FirstShadowChild(){ return NULL; }
virtual IClientRenderable *NextShadowPeer() { return NULL; }
virtual ShadowType_t ShadowCastType() { return SHADOWS_NONE; }
virtual void CreateModelInstance() {}
virtual ModelInstanceHandle_t GetModelInstance() { return MODEL_INSTANCE_INVALID; }
// Attachments
virtual int LookupAttachment( const char *pAttachmentName ) { return -1; }
virtual bool GetAttachment( int number, Vector &origin, QAngle &angles ) { return false; }
virtual bool GetAttachment( int number, matrix3x4_t &matrix ) { return false; }
virtual bool ComputeLightingOrigin( int nAttachmentIndex, Vector modelLightingCenter, const matrix3x4_t &matrix, Vector &transformedLightingCenter ) { return false; }
// Rendering clip plane, should be 4 floats, return value of NULL indicates a disabled render clip plane
virtual float *GetRenderClipPlane() { return NULL; }
virtual void RecordToolMessage() {}
virtual bool ShouldDrawForSplitScreenUser( int nSlot ) { return true; }
virtual uint8 OverrideAlphaModulation( uint8 nAlpha ) { return nAlpha; }
virtual uint8 OverrideShadowAlphaModulation( uint8 nAlpha ) { return nAlpha; }
virtual IClientModelRenderable* GetClientModelRenderable() { return 0; }
// IClientUnknown implementation.
public:
virtual void SetRefEHandle( const CBaseHandle &handle ) { Assert( false ); }
virtual const CBaseHandle& GetRefEHandle() const { Assert( false ); return *((CBaseHandle*)0); }
virtual IClientUnknown* GetIClientUnknown() { return this; }
virtual ICollideable* GetCollideable() { return 0; }
virtual IClientRenderable* GetClientRenderable() { return this; }
virtual IClientNetworkable* GetClientNetworkable() { return 0; }
virtual IClientEntity* GetIClientEntity() { return 0; }
virtual C_BaseEntity* GetBaseEntity() { return 0; }
virtual IClientThinkable* GetClientThinkable() { return 0; }
virtual IClientAlphaProperty* GetClientAlphaProperty() { return 0; }
public:
ClientRenderHandle_t m_hRenderHandle;
};
#endif // ICLIENTRENDERABLE_H