1

utils/hlmv/studiomodel.h

@@ -0,0 +1,483 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+
+#ifndef INCLUDED_STUDIOMODEL
+#define INCLUDED_STUDIOMODEL
+
+#include "mathlib/mathlib.h"
+#include "studio.h"
+#include "mouthinfo.h"
+#include "UtlLinkedList.h"
+#include "utlsymbol.h"
+#include "bone_setup.h"
+#include "datacache/imdlcache.h"
+#include "viewersettings.h"
+#include "tier1/utlstring.h"
+
+#define DEFAULT_BLEND_TIME 0.2
+
+//-----------------------------------------------------------------------------
+// Forward declarations
+//-----------------------------------------------------------------------------
+typedef struct IFACE_TAG IFACE;
+typedef struct IMESH_TAG IMESH;
+typedef struct ResolutionUpdateTag ResolutionUpdate;
+typedef struct FaceUpdateTag FaceUpdate;
+class IMaterial;
+class IDataCache;
+class IStudioPhysics;
+class IMaterialSystem;
+class IMDLCache;
+class CPhysmesh;
+struct hlmvsolid_t;
+struct constraint_ragdollparams_t;
+class IStudioRender;
+class IPhysicsSurfaceProps;
+class IPhysicsCollision;
+class IStudioDataCache;
+class IDataCache;
+class IFileSystem;
+class IMaterialSystemHardwareConfig;
+class CJiggleBones;
+
+//-----------------------------------------------------------------------------
+// Singleton interfaces
+//-----------------------------------------------------------------------------
+extern IStudioRender *g_pStudioRender;
+extern IMDLCache *g_pMDLCache;
+extern IPhysicsSurfaceProps *physprop;
+extern IPhysicsCollision *physcollision;
+extern IStudioDataCache *g_pStudioDataCache;
+extern IDataCache *g_pDataCache;
+extern IFileSystem *g_pFileSystem;
+extern IMaterialSystem *g_pMaterialSystem;
+extern IMaterialSystemHardwareConfig *g_pMaterialSystemHardwareConfig;
+
+
+class AnimationLayer
+{
+public:
+	float					m_cycle;			// 0 to 1 animation playback index
+	int						m_sequence;			// sequence index
+	float					m_weight;
+	float					m_playbackrate;
+	int						m_priority;			// lower priorities get layered first
+};
+
+struct StudioLookTarget
+{
+	float					m_flWeight;
+	Vector					m_vecPosition;
+	bool					m_bSelf;
+};
+
+struct HitboxInfo_t
+{
+	CUtlString m_Name;
+	mstudiobbox_t m_BBox;
+};
+
+// I'm saving this as internal data because we may add or remove hitboxes
+// I'm using a utllinkedlist so hitbox IDs remain constant on add + remove
+typedef CUtlLinkedList< HitboxInfo_t, unsigned short > HitboxList_t;
+
+
+struct HitboxSet_t
+{
+	CUtlString m_Name;
+	HitboxList_t m_Hitboxes;
+};
+
+
+class StudioModel
+{
+public:
+	StudioModel();
+
+	// memory handling, uses calloc so members are zero'd out on instantiation
+	static void *operator new( size_t nSize );
+	static void* operator new( size_t size, int nBlockUse, const char *pFileName, int nLine );
+
+	static void operator delete( void *pData );
+	static void operator delete( void* p, int nBlockUse, const char *pFileName, int nLine );
+
+
+	static void				Init( void );
+	static void				Shutdown( void ); // garymcthack - need to call this.
+	static void				UpdateViewState( const Vector& viewOrigin,
+											 const Vector& viewRight,
+											 const Vector& viewUp,
+											 const Vector& viewPlaneNormal );
+
+	static void						ReleaseStudioModel( void );
+	static void						RestoreStudioModel( void );
+
+	static void						UnloadGroupFiles();
+
+	char const						*GetFileName( void );
+
+	IStudioRender				    *GetStudioRender();
+
+	static void UpdateStudioRenderConfig( bool bWireframe, bool bZBufferWireframe, bool bNormals, bool bTangentFrame );
+	studiohdr_t						*getAnimHeader (int i) const;
+
+	virtual void					ModelInit( void ) { }
+
+	bool							IsModelLoaded() const;
+
+	void							FreeModel( bool bReleasing );
+	bool							LoadModel( const char *modelname );
+	virtual bool					PostLoadModel ( const char *modelname );
+	bool							HasModel();
+
+	virtual int						DrawModel( bool mergeBones = false );
+
+	virtual void					AdvanceFrame( float dt );
+	float							GetInterval( void );
+	float							GetCycle( void );
+	float							GetFrame( void );
+	int								GetMaxFrame( void );
+	int								SetFrame( int frame );
+	float							GetCycle( int iLayer );
+	float							GetFrame( int iLayer );
+	int								GetMaxFrame( int iLayer );
+	int								SetFrame( int iLayer, int frame );
+
+	void							ExtractBbox( Vector &mins, Vector &maxs );
+
+	void							SetBlendTime( float blendtime );
+	int								LookupSequence( const char *szSequence );
+	int								LookupActivity( const char *szActivity );
+	int								SetSequence( int iSequence );
+	int								SetSequence( const char *szSequence );
+	const char*						GetSequenceName( int iSequence );
+	void							ClearOverlaysSequences( void );
+	void							ClearAnimationLayers( void );
+	int								GetNewAnimationLayer( int iPriority = 0 );
+
+	int								SetOverlaySequence( int iLayer, int iSequence, float flWeight );
+	float							SetOverlayRate( int iLayer, float flCycle, float flFrameRate );
+	int								GetOverlaySequence( int iLayer );
+	float							GetOverlaySequenceWeight( int iLayer );
+	void							StartBlending( void );
+
+	float							GetTransitionAmount( void );
+	int								GetSequence( void );
+	void							GetSequenceInfo( int iSequence, float *pflFrameRate, float *pflGroundSpeed );
+	void							GetSequenceInfo( float *pflFrameRate, float *pflGroundSpeed );
+	float							GetFPS( int iSequence );
+	float							GetFPS( );
+	float							GetDuration( int iSequence );
+	float							GetDuration( );
+	int								GetNumFrames( int iSequence );
+	bool							GetSequenceLoops( int iSequence );
+	void							GetMovement( float prevCycle[5], Vector &vecPos, QAngle &vecAngles );
+	void							GetMovement( int iSequence, float prevCycle, float currCycle, Vector &vecPos, QAngle &vecAngles );
+	void							GetSeqAnims( int iSequence, mstudioanimdesc_t *panim[4], float *pweights );
+	void							GetSeqAnims( mstudioanimdesc_t *panim[4], float *pweights );
+	float							GetGroundSpeed( int iSequence );
+	float							GetGroundSpeed( void );
+	float							GetCurrentVelocity( void );
+	bool							IsHidden( int iSequence );
+
+	float							SetController( int iController, float flValue );
+
+	int								LookupPoseParameter( char const *szName );
+	float							SetPoseParameter( int iParameter, float flValue );
+	float							SetPoseParameter( char const *szName, float flValue );
+	float							GetPoseParameter( char const *szName );
+	float							GetPoseParameter( int iParameter );
+	bool 							GetPoseParameterRange( int iParameter, float *pflMin, float *pflMax );
+	float*							GetPoseParameters();
+
+	int								LookupAttachment( char const *szName );
+
+	int								SetBodygroup( int iGroup, int iValue = -1 );
+	int								SetSkin( int iValue );
+	int								FindBone( const char *pName );
+
+	LocalFlexController_t			LookupFlexController( char *szName );
+	void							SetFlexController( char *szName, float flValue );
+	void							SetFlexController( LocalFlexController_t iFlex, float flValue );
+	float							GetFlexController( char *szName );
+	float							GetFlexController( LocalFlexController_t iFlex );
+	void							SetFlexControllerRaw( LocalFlexController_t iFlex, float flValue );
+	float							GetFlexControllerRaw( LocalFlexController_t iFlex );
+
+	// void							CalcBoneTransform( int iBone, Vector pos[], Quaternion q[], matrix3x4_t& bonematrix );
+
+	void							UpdateBoneChain( Vector pos[], Quaternion q[], int iBone, matrix3x4_t *pBoneToWorld );
+	void							SetViewTarget( void ); // ???
+	void							GetBodyPoseParametersFromFlex( void );
+	void							CalcHeadRotation( Vector pos[], Quaternion q[] );
+	float							SetHeadPosition( matrix3x4_t& attToWorld, Vector const &vTargetPos, float dt );
+
+	int								GetNumLODs() const;
+	float							GetLODSwitchValue( int lod ) const;
+	void							SetLODSwitchValue( int lod, float switchValue );
+	
+	void							scaleMeshes( float scale );
+	void							scaleBones( float scale );
+
+	// Physics
+	void							OverrideBones( bool *override );
+	int								Physics_GetBoneCount( void );
+	const char *					Physics_GetBoneName( int index );
+	int								Physics_GetBoneIndex( const char *pName );
+	void							Physics_GetData( int boneIndex, hlmvsolid_t *psolid, constraint_ragdollparams_t *pConstraint ) const;
+	void							Physics_SetData( int boneIndex, const hlmvsolid_t *psolid, constraint_ragdollparams_t const *pConstraint );
+	void							Physics_SetPreview( int previewBone, int axis, float t );
+	float							Physics_GetMass( void );
+	void							Physics_SetMass( float mass );
+	char							*Physics_DumpQC( void );
+
+	float							GetSequenceTime() const { return m_sequencetime; }
+	float							GetTimeDelta() const { return m_dt; }
+
+	CStudioHdr						*m_pStudioHdr;
+	CStudioHdr						*GetStudioHdr() const;
+	studiohdr_t						*GetStudioRenderHdr() const;
+	studiohwdata_t					*GetHardwareData( void ) const;
+
+	// Get and set the model transform (i.e. what m_origin and m_angles are used to generate).
+	void GetModelTransform( matrix3x4_t &mat );
+	void SetModelTransform( const matrix3x4_t &mat );
+
+public:
+	// entity settings
+	QAngle							m_angles;	// rot
+	Vector							m_origin;	// trans
+
+protected:
+	int								m_bodynum;			// bodypart selection	
+	int								m_skinnum;			// skin group selection
+	float							m_controller[4];	// bone controllers
+
+public:
+	CMouthInfo						m_mouth;
+
+protected:
+	char							*m_pModelName;		// model file name
+
+	// bool							m_owntexmodel;		// do we have a modelT.mdl ?
+
+	// Previouse sequence data
+	float							m_blendtime;
+	float							m_sequencetime;
+	int								m_prevsequence;
+	float							m_prevcycle;
+
+	float							m_dt;
+
+	// Blending info
+
+	// Gesture,Sequence layering state
+#define MAXSTUDIOANIMLAYERS			8
+	AnimationLayer					m_Layer[MAXSTUDIOANIMLAYERS];
+	int								m_iActiveLayers;
+
+public:
+	float							m_cycle;			// 0 to 1 animation playback index
+protected:
+	int								m_sequence;			// sequence index
+	float							m_poseparameter[MAXSTUDIOPOSEPARAM];		// intra-sequence blending
+	float							m_weight;
+
+	// internal data
+	MDLHandle_t						m_MDLHandle;
+	mstudiomodel_t					*m_pmodel;
+
+public:
+	CUtlVector< HitboxSet_t >		m_HitboxSets;
+	CUtlVector< CUtlSymbol >		m_SurfaceProps;
+
+protected:
+	// class data
+	static Vector					*m_AmbientLightColors;
+
+	// Added data
+	// IMESH						*m_pimesh;
+	// VertexUpdate					*m_pvertupdate;
+	// FaceUpdate					*m_pfaceupdate;
+	IFACE							*m_pface;
+
+	// studiohdr_t					*m_ptexturehdr;
+
+	Vector4D						m_adj;				// FIX: non persistant, make static
+
+public:
+	IStudioPhysics					*m_pPhysics;
+private:
+	int								m_physPreviewBone;
+	int								m_physPreviewAxis;
+	float							m_physPreviewParam;
+	float							m_physMass;
+
+public:
+	mstudioseqdesc_t				&GetSeqDesc( int seq );
+	const matrix3x4_t*				BoneToWorld( int nBoneIndex ) const;
+
+private:
+	mstudioanimdesc_t				&GetAnimDesc( int anim );
+	mstudioanim_t					*GetAnim( int anim );
+
+	void							DrawPhysmesh( CPhysmesh *pMesh, int boneIndex, IMaterial *pMaterial, float *color );
+	void							DrawPhysConvex( CPhysmesh *pMesh, IMaterial *pMaterial );
+
+	void							SetupLighting( void );
+
+	virtual void					SetupModel( int bodypart );
+
+private:
+	float							m_flexweight[MAXSTUDIOFLEXCTRL];
+	matrix3x4_t						m_pBoneToWorld[MAXSTUDIOBONES];
+
+public:
+	virtual void					RunFlexRules( void );
+	virtual int						BoneMask( void );
+	virtual void					SetUpBones( bool mergeBones );
+
+	int								GetLodUsed( void );
+	float							GetLodMetric( void );
+
+	const char						*GetKeyValueText( int iSequence );
+
+private:
+	// Drawing helper methods
+	void DrawBones( );
+	void DrawAttachments( );
+	void DrawEditAttachment();
+	void DrawHitboxes();
+	void DrawPhysicsModel( );
+	void DrawIllumPosition( );
+	void DrawOriginAxis( );
+
+public:
+	// generic interface to rendering?
+	void drawBox (Vector const *v, float const * color );
+	void drawWireframeBox (Vector const *v, float const* color );
+	void drawTransform( matrix3x4_t& m, float flLength = 4 );
+	void drawLine( Vector const &p1, Vector const &p2, int r = 0, int g = 0, int b = 255 );
+	void drawTransparentBox( Vector const &bbmin, Vector const &bbmax, const matrix3x4_t& m, float const *color, float const *wirecolor );
+
+private:
+	int						m_LodUsed;
+	float					m_LodMetric;
+
+public:
+
+	void					SetSolveHeadTurn( int solve );
+	int						GetSolveHeadTurn() const;
+
+	void					ClearLookTargets( void );
+	void					AddLookTarget( const Vector& vecPosition, float flWeight );
+	void					AddLookTargetSelf( float flWeight );
+
+	void					SetModelYaw( float yaw );
+	float					GetModelYaw( void ) const;
+	void					SetBodyYaw( float yaw );
+	float					GetBodyYaw( void ) const;
+	void					SetSpineYaw( float yaw );
+	float					GetSpineYaw( void ) const;
+
+private:
+
+	// 0 == no, 1 == based on dt, 2 == completely.
+	int						m_nSolveHeadTurn; 
+	CUtlVector < StudioLookTarget >	m_vecHeadTargets;
+
+	float					m_flModelYaw;
+	float					m_flBodyYaw;
+	float					m_flSpineYaw;
+
+public:
+	bool					m_bIsTransparent;
+	bool					m_bHasProxy;
+
+	// necessary for accessing correct vertexes
+	void					SetCurrentModel();
+
+public:
+	CIKContext				m_ik;
+	float					m_prevGroundCycles[5];
+	float					m_prevIKCycles[5];
+
+public:
+	void					IncrementFramecounter( void ) { m_iFramecounter++; };
+private:
+	int						m_iFramecounter;
+
+private:
+	CJiggleBones			*m_pJiggleBones;
+};
+
+
+//-----------------------------------------------------------------------------
+// Inline methods 
+//-----------------------------------------------------------------------------
+inline CStudioHdr *StudioModel::GetStudioHdr( void ) const 
+{ 
+	if (!m_pStudioHdr || m_pStudioHdr->IsReadyForAccess())
+		return m_pStudioHdr;
+
+	studiohdr_t *hdr = g_pMDLCache->GetStudioHdr( m_MDLHandle );
+
+	m_pStudioHdr->Init( hdr );
+
+	if (m_pStudioHdr->IsReadyForAccess())
+		return m_pStudioHdr;
+
+	return NULL;
+}
+
+inline studiohdr_t *StudioModel::GetStudioRenderHdr( void ) const 
+{
+	return g_pMDLCache->GetStudioHdr( m_MDLHandle );
+}
+
+inline studiohwdata_t *StudioModel::GetHardwareData( void ) const 
+{ 
+	return g_pMDLCache->GetHardwareData( m_MDLHandle );
+}
+
+inline studiohdr_t *StudioModel::getAnimHeader( int i ) const 
+{ 
+//	return g_pMDLCache->GetStudioHdr( m_AnimHandle[i] );
+//	return m_panimhdr[i]; 
+}
+
+inline char const *StudioModel::GetFileName( void ) 
+{ 
+	return m_pModelName; 
+}
+
+inline IStudioRender *StudioModel::GetStudioRender() 
+{ 
+	return g_pStudioRender; 
+}
+
+inline bool StudioModel::IsModelLoaded() const 
+{ 
+	return m_MDLHandle != MDLHANDLE_INVALID; 
+}
+
+inline const matrix3x4_t* StudioModel::BoneToWorld( int nBoneIndex ) const
+{
+	return &m_pBoneToWorld[nBoneIndex];
+}
+
+
+//-----------------------------------------------------------------------------
+// Globals
+//-----------------------------------------------------------------------------
+extern Vector g_vright;		// needs to be set to viewer's right in order for chrome to work
+extern StudioModel *g_pStudioModel;
+extern StudioModel *g_pStudioExtraModel[HLMV_MAX_MERGED_MODELS];
+
+
+#endif // INCLUDED_STUDIOMODEL