Backups/csgo-2018-source
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
main
csgo-2018-source/public/studio_PS3.h
KittenPopo c2130ba4e9 uid issue
2021-07-24 21:11:47 -07:00

3734 lines
132 KiB
C++
Raw Permalink Blame History

//===== Copyright (c) 1996-2008, Valve Corporation, All rights reserved. ======//
//
// Purpose:
//
// $NoKeywords: $
//
//=============================================================================//
#ifndef STUDIO_PS3_H
#define STUDIO_PS3_H
#include "basetypes.h"
//#include "mathlib/vector2d.h"
#include "mathlib/vector.h"
#include "mathlib/vector4d.h"
#include "mathlib/compressed_vector.h"
// #include "tier0/dbg.h"
// #include "tier0/threadtools.h"
#include "mathlib/mathlib.h"
//#include "utlvector.h"
// #include "utlhash.h"
// #include "datamap.h"
// #include "generichash.h"
// #include "localflexcontroller.h"
// #include "utlsymbol.h"
// #include "convar.h"
// duplicated defined from studio.h for spu
#if defined(__SPU__)
#define STUDIO_LOCAL 0x0200 // sequence has a local context sequence
#define STUDIO_LOOPING 0x0001 // ending frame should be the same as the starting frame
#define BONE_FIXED_ALIGNMENT 0x00100000 // bone can't spin 360 degrees, all interpolation is normalized around a fixed orientation
#define BONE_HAS_SAVEFRAME_POS 0x00200000 // Vector48
#define BONE_HAS_SAVEFRAME_ROT64 0x00400000 // Quaternion64
#define BONE_HAS_SAVEFRAME_ROT32 0x00800000 // Quaternion32
#define STUDIO_FRAME_CONST_POS 0x01 // Vector48 in constants
#define STUDIO_FRAME_CONST_ROT 0x02 // Quaternion48 in constants
#define STUDIO_FRAME_ANIM_POS 0x04 // Vector48 in framedata
#define STUDIO_FRAME_ANIM_ROT 0x08 // Quaternion48 in framedata
#define STUDIO_FRAME_ANIM_POS2 0x10 // Vector in framedata
#define STUDIO_FRAME_CONST_POS2 0x20 // Vector in constants
#define STUDIO_FRAME_CONST_ROT2 0x40 // Quaternion48S in constants
#define STUDIO_FRAME_ANIM_ROT2 0x80 // Quaternion48S in framedata
#define STUDIO_DELTA 0x0004 // this sequence "adds" to the base sequences, not slerp blends
#define STUDIO_FRAMEANIM 0x0040 // animation is encoded as by frame x bone instead of RLE bone x frame
#define STUDIO_POST 0x0010 //
#define STUDIO_WORLD 0x4000 // sequence blends in worldspace
#endif
// #define STUDIO_ENABLE_PERF_COUNTERS
// #define STUDIO_SEQUENCE_ACTIVITY_LOOKUPS_ARE_SLOW 0
//-----------------------------------------------------------------------------
// forward declarations
//-----------------------------------------------------------------------------
// class IMaterial;
// class IMesh;
// class IMorph;
// struct virtualmodel_t;
// struct vertexFileHeader_t;
// struct thinModelVertices_t;
//
// namespace OptimizedModel
// {
// struct StripHeader_t;
// }
class CThreadFastMutex_PS3 // here for size only
{
uint32 m_ownerID;
int m_depth;
};
/*
==============================================================================
STUDIO MODELS
Studio models are position independent, so the cache manager can move them.
==============================================================================
*/
// #define STUDIO_VERSION 49
struct studiohdr_t_PS3;
// #ifdef _GAMECONSOLE
// #define MAXSTUDIOTRIANGLES 65536 //
// #define MAXSTUDIOVERTS 32768 // These numbers save memory in CCachedRenderData, but restrict usable model sizes on 360
// #define MAXSTUDIOFLEXVERTS 4096 //
// #else
// #define MAXSTUDIOTRIANGLES 65536 // TODO: tune this
// #define MAXSTUDIOVERTS 65536 // TODO: tune this
// #define MAXSTUDIOFLEXVERTS 10000 // max number of verts that can be flexed per mesh. TODO: tune this
// #endif
// #define MAXSTUDIOSKINS 32 // total textures
#define MAXSTUDIOBONES_PS3 128 // 256 // total bones actually used
// #define MAXSTUDIOFLEXDESC 1024 // maximum number of low level flexes (actual morph targets)
// #define MAXSTUDIOFLEXCTRL 96 // maximum number of flexcontrollers (input sliders)
#define MAXSTUDIOPOSEPARAM_PS3 24
// #define MAXSTUDIOBONECTRLS 4
// #define MAXSTUDIOANIMBLOCKS 256
#define MAXSTUDIOBONEBITS_PS3 7 //8 // NOTE: MUST MATCH MAXSTUDIOBONES
// NOTE!!! : Changing this number also changes the vtx file format!!!!!
// #define MAX_NUM_BONES_PER_VERT 3
//Adrian - Remove this when we completely phase out the old event system.
// #define NEW_EVENT_STYLE ( 1 << 10 )
// struct mstudiodata_t
// {
// int count;
// int offset;
// };
// #define STUDIO_PROC_AXISINTERP 1
// #define STUDIO_PROC_QUATINTERP 2
// #define STUDIO_PROC_AIMATBONE 3
// #define STUDIO_PROC_AIMATATTACH 4
// #define STUDIO_PROC_JIGGLE 5
// #define STUDIO_PROC_TWIST_MASTER 6
// #define STUDIO_PROC_TWIST_SLAVE 7 // Multiple twist bones are computed at once for the same parent/child combo so TWIST_NULL do nothing
// #define STUDIO_PROC_POINT_CONSTRAINT 8
// #define STUDIO_PROC_ORIENT_CONSTRAINT 9
// #define STUDIO_PROC_AIM_CONSTRAINT 10
// #define STUDIO_PROC_IK_CONSTRAINT 11
// #define STUDIO_PROC_PARENT_CONSTRAINT 12
// struct mstudioaxisinterpbone_t
// {
// DECLARE_BYTESWAP_DATADESC();
// int control;// local transformation of this bone used to calc 3 point blend
// int axis; // axis to check
// Vector pos[6]; // X+, X-, Y+, Y-, Z+, Z-
// Quaternion quat[6];// X+, X-, Y+, Y-, Z+, Z-
//
// mstudioaxisinterpbone_t(){}
// private:
// // No copy constructors allowed
// mstudioaxisinterpbone_t(const mstudioaxisinterpbone_t& vOther);
// };
// struct mstudioquatinterpinfo_t
// {
// DECLARE_BYTESWAP_DATADESC();
// float inv_tolerance; // 1 / radian angle of trigger influence
// Quaternion trigger; // angle to match
// Vector pos; // new position
// Quaternion quat; // new angle
//
// mstudioquatinterpinfo_t(){}
// private:
// // No copy constructors allowed
// mstudioquatinterpinfo_t(const mstudioquatinterpinfo_t& vOther);
// };
// struct mstudioquatinterpbone_t
// {
// DECLARE_BYTESWAP_DATADESC();
// int control;// local transformation to check
// int numtriggers;
// int triggerindex;
// inline mstudioquatinterpinfo_t *pTrigger( int i ) const { return (mstudioquatinterpinfo_t *)(((byte *)this) + triggerindex) + i; };
//
// mstudioquatinterpbone_t(){}
// private:
// // No copy constructors allowed
// mstudioquatinterpbone_t(const mstudioquatinterpbone_t& vOther);
// };
// #define JIGGLE_IS_FLEXIBLE 0x01
// #define JIGGLE_IS_RIGID 0x02
// #define JIGGLE_HAS_YAW_CONSTRAINT 0x04
// #define JIGGLE_HAS_PITCH_CONSTRAINT 0x08
// #define JIGGLE_HAS_ANGLE_CONSTRAINT 0x10
// #define JIGGLE_HAS_LENGTH_CONSTRAINT 0x20
// #define JIGGLE_HAS_BASE_SPRING 0x40
//
// struct mstudiojigglebone_t
// {
// DECLARE_BYTESWAP_DATADESC();
//
// int flags;
//
// // general params
// float length; // how from from bone base, along bone, is tip
// float tipMass;
//
// // flexible params
// float yawStiffness;
// float yawDamping;
// float pitchStiffness;
// float pitchDamping;
// float alongStiffness;
// float alongDamping;
//
// // angle constraint
// float angleLimit; // maximum deflection of tip in radians
//
// // yaw constraint
// float minYaw; // in radians
// float maxYaw; // in radians
// float yawFriction;
// float yawBounce;
//
// // pitch constraint
// float minPitch; // in radians
// float maxPitch; // in radians
// float pitchFriction;
// float pitchBounce;
//
// // base spring
// float baseMass;
// float baseStiffness;
// float baseDamping;
// float baseMinLeft;
// float baseMaxLeft;
// float baseLeftFriction;
// float baseMinUp;
// float baseMaxUp;
// float baseUpFriction;
// float baseMinForward;
// float baseMaxForward;
// float baseForwardFriction;
//
// private:
// // No copy constructors allowed
// //mstudiojigglebone_t(const mstudiojigglebone_t& vOther);
// };
// struct mstudioaimatbone_t
// {
// DECLARE_BYTESWAP_DATADESC();
//
// int parent;
// int aim; // Might be bone or attach
// Vector aimvector;
// Vector upvector;
// Vector basepos;
//
// mstudioaimatbone_t() {}
// private:
// // No copy constructors allowed
// mstudioaimatbone_t(const mstudioaimatbone_t& vOther);
// };
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
// struct mstudiotwistbonetarget_t
// {
// DECLARE_BYTESWAP_DATADESC();
//
// int m_nBone;
// float m_flWeight;
// Vector m_vBaseTranslate;
// Quaternion m_qBaseRotation;
//
// mstudiotwistbonetarget_t() {}
// private:
// // No copy constructors allowed
// mstudiotwistbonetarget_t( const mstudiotwistbonetarget_t &vOther );
// };
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
// struct mstudiotwistbone_t
// {
// DECLARE_BYTESWAP_DATADESC();
//
// bool m_bInverse; // False: Apply child rotation to twist targets True: Apply parent rotation to twist targets
// Vector m_vUpVector; // In parent space, projected into plane defined by vector between parent & child
// int m_nParentBone;
// Quaternion m_qBaseInv; // The base rotation of the parent, used if m_bInverse is true
// int m_nChildBone;
//
// int m_nTargetCount;
// int m_nTargetIndex;
// inline mstudiotwistbonetarget_t *pTarget( int i ) const { return ( mstudiotwistbonetarget_t * )( ( ( byte * )this) + m_nTargetIndex ) + i; }
//
// mstudiotwistbone_t() {}
// private:
// // No copy constructors allowed
// mstudiotwistbone_t( const mstudiotwistbone_t &vOther );
// };
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
// struct mstudioconstraintslave_t
// {
// DECLARE_BYTESWAP_DATADESC();
//
// int m_nBone;
// Vector m_vBasePosition;
// Quaternion m_qBaseOrientation;
//
// mstudioconstraintslave_t() {}
// private:
// // No copy constructors allowed
// mstudioconstraintslave_t( const mstudioconstraintslave_t &vOther );
// };
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
// struct mstudioconstrainttarget_t
// {
// DECLARE_BYTESWAP_DATADESC();
//
// int m_nBone;
// float m_flWeight;
// Vector m_vOffset;
// Quaternion m_qOffset;
//
// mstudioconstrainttarget_t() {}
// private:
// // No copy constructors allowed
// mstudioconstrainttarget_t( const mstudioconstrainttarget_t &vOther );
// };
//-----------------------------------------------------------------------------
// Point constraint, slave position matches target position
//-----------------------------------------------------------------------------
// struct mstudiopointconstraint_t
// {
// DECLARE_BYTESWAP_DATADESC();
//
// mstudioconstraintslave_t m_slave; // DEFINE_EMBEDDED
//
// int m_nTargetCount;
// int m_nTargetIndex;
// inline mstudioconstrainttarget_t *pTarget( int i ) const { return ( mstudioconstrainttarget_t * )( ( ( byte * )this) + m_nTargetIndex ) + i; }
//
// mstudiopointconstraint_t() {}
// private:
// // No copy constructors allowed
// mstudiopointconstraint_t( const mstudiopointconstraint_t &vOther );
// };
//-----------------------------------------------------------------------------
// Orient constraint, slave orientation matches target orientation
//-----------------------------------------------------------------------------
// struct mstudioorientconstraint_t
// {
// DECLARE_BYTESWAP_DATADESC();
//
// mstudioconstraintslave_t m_slave; // DEFINE_EMBEDDED
//
// int m_nTargetCount;
// int m_nTargetIndex;
// inline mstudioconstrainttarget_t *pTarget( int i ) const { return ( mstudioconstrainttarget_t * )( ( ( byte * )this) + m_nTargetIndex ) + i; }
//
// mstudioorientconstraint_t() {}
// private:
// // No copy constructors allowed
// mstudioorientconstraint_t( const mstudioorientconstraint_t &vOther );
// };
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
// struct mstudioaimconstraint_t
// {
// DECLARE_BYTESWAP_DATADESC();
//
// mstudioconstraintslave_t m_slave; // DEFINE_EMBEDDED
//
// int m_nTargetCount;
// int m_nTargetIndex;
// inline mstudioconstrainttarget_t *pTarget( int i ) const { return ( mstudioconstrainttarget_t * )( ( ( byte * )this) + m_nTargetIndex ) + i; }
//
// Quaternion m_qAimOffset;
// Vector m_vUp;
// int m_nUpSpaceTarget;
//
// mstudioaimconstraint_t() {}
// private:
// // No copy constructors allowed
// mstudioaimconstraint_t( const mstudioaimconstraint_t &vOther );
// };
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
// struct mstudioikconstraint_t
// {
// DECLARE_BYTESWAP_DATADESC();
//
// mstudioikconstraint_t() {}
// private:
// // No copy constructors allowed
// mstudioikconstraint_t( const mstudioaimconstraint_t &vOther );
// };
//-----------------------------------------------------------------------------
// Parent constraint, slave position and orientation are updated to behave as children of the target
//-----------------------------------------------------------------------------
// struct mstudioparentconstraint_t
// {
// DECLARE_BYTESWAP_DATADESC();
//
// mstudioconstraintslave_t m_slave; // DEFINE_EMBEDDED
//
// int m_nTargetCount;
// int m_nTargetIndex;
// inline mstudioconstrainttarget_t *pTarget( int i ) const { return ( mstudioconstrainttarget_t * )( ( ( byte * )this) + m_nTargetIndex ) + i; }
//
// mstudioparentconstraint_t() {}
// private:
// // No copy constructors allowed
// mstudioparentconstraint_t( const mstudioparentconstraint_t &vOther );
// };
// bones
struct mstudiobone_t_PS3
{
// DECLARE_BYTESWAP_DATADESC();
int sznameindex;
// inline char * const pszName( void ) const { return ((char *)this) + sznameindex; }
int parent; // parent bone
int bonecontroller[6]; // bone controller index, -1 == none
// default values
Vector pos;
Quaternion quat;
RadianEuler rot;
// compression scale
Vector posscale;
Vector rotscale;
matrix3x4_t poseToBone;
Quaternion qAlignment;
int flags;
int proctype;
int procindex; // procedural rule
mutable int physicsbone; // index into physically simulated bone
// inline void *pProcedure( ) const { if (procindex == 0) return NULL; else return (void *)(((byte *)this) + procindex); };
int surfacepropidx; // index into string tablefor property name
// inline char * const pszSurfaceProp( void ) const { return ((char *)this) + surfacepropidx; }
// inline int GetSurfaceProp( void ) const { return surfacepropLookup; }
int contents; // See BSPFlags.h for the contents flags
int surfacepropLookup; // this index must be cached by the loader, not saved in the file
int unused[7]; // remove as appropriate
mstudiobone_t_PS3(){}
private:
// No copy constructors allowed
mstudiobone_t_PS3(const mstudiobone_t_PS3& vOther);
};
// middle chunk from mstudiobone_t_PS3
struct mstudiobone_t_PS3_postoqalignment
{
Vector pos;
Quaternion quat;
RadianEuler rot;
Vector posscale;
Vector rotscale;
matrix3x4_t poseToBone;
Quaternion qAlignment;
int flags;
};
struct mstudiolinearbone_t_PS3
{
// DECLARE_BYTESWAP_DATADESC();
int numbones;
int flagsindex;
// inline int flags( int i ) const { Assert( i >= 0 && i < numbones); return *((int *)(((byte *)this) + flagsindex) + i); };
// inline int *pflags( int i ) { Assert( i >= 0 && i < numbones); return ((int *)(((byte *)this) + flagsindex) + i); };
int parentindex;
// inline int parent( int i ) const { Assert( i >= 0 && i < numbones); return *((int *)(((byte *)this) + parentindex) + i); };
int posindex;
// inline const Vector &pos( byte *pEA_this, int i ) const { Assert( i >= 0 && i < numbones); return (Vector *)((pEA_this) + posindex) + i; };
int quatindex;
// inline const Quaternion &quat( int i ) const { Assert( i >= 0 && i < numbones); return *((Quaternion *)((pEA_this) + quatindex) + i); };
int rotindex;
// inline const RadianEuler &rot( int i ) const { Assert( i >= 0 && i < numbones); return *((RadianEuler *)(((byte *)this) + rotindex) + i); };
int posetoboneindex;
// inline const matrix3x4_t &poseToBone( int i ) const { Assert( i >= 0 && i < numbones); return *((matrix3x4_t *)(((byte *)this) + posetoboneindex) + i); };
int posscaleindex;
// inline const Vector &posscale( int i ) const { Assert( i >= 0 && i < numbones); return *((Vector *)(((byte *)this) + posscaleindex) + i); };
int rotscaleindex;
// inline const Vector &rotscale( int i ) const { Assert( i >= 0 && i < numbones); return *((Vector *)(((byte *)this) + rotscaleindex) + i); };
int qalignmentindex;
// inline const Quaternion &qalignment( int i ) const { Assert( i >= 0 && i < numbones); return *((Quaternion *)(((byte *)this) + qalignmentindex) + i); };
int unused[6];
mstudiolinearbone_t_PS3(){}
private:
// No copy constructors allowed
mstudiolinearbone_t_PS3(const mstudiolinearbone_t_PS3& vOther);
};
//-----------------------------------------------------------------------------
// The component of the bone used by mstudioboneflexdriver_t
//-----------------------------------------------------------------------------
// enum StudioBoneFlexComponent_t
// {
// STUDIO_BONE_FLEX_INVALID = -1, // Invalid
// STUDIO_BONE_FLEX_TX = 0, // Translate X
// STUDIO_BONE_FLEX_TY = 1, // Translate Y
// STUDIO_BONE_FLEX_TZ = 2 // Translate Z
// };
//-----------------------------------------------------------------------------
// Component is one of Translate X, Y or Z [0,2] (StudioBoneFlexComponent_t)
//-----------------------------------------------------------------------------
// struct mstudioboneflexdrivercontrol_t
// {
// DECLARE_BYTESWAP_DATADESC();
//
// int m_nBoneComponent; // Bone component that drives flex, StudioBoneFlexComponent_t
// int m_nFlexControllerIndex; // Flex controller to drive
// float m_flMin; // Min value of bone component mapped to 0 on flex controller
// float m_flMax; // Max value of bone component mapped to 1 on flex controller
//
// mstudioboneflexdrivercontrol_t(){}
// private:
// // No copy constructors allowed
// mstudioboneflexdrivercontrol_t( const mstudioboneflexdrivercontrol_t &vOther );
// };
//-----------------------------------------------------------------------------
// Drive flex controllers from bone components
//-----------------------------------------------------------------------------
// struct mstudioboneflexdriver_t
// {
// DECLARE_BYTESWAP_DATADESC();
//
// int m_nBoneIndex; // Bone to drive flex controller
// int m_nControlCount; // Number of flex controllers being driven
// int m_nControlIndex; // Index into data where controllers are (relative to this)
//
// inline mstudioboneflexdrivercontrol_t *pBoneFlexDriverControl( int i ) const
// {
// Assert( i >= 0 && i < m_nControlCount );
// return (mstudioboneflexdrivercontrol_t *)(((byte *)this) + m_nControlIndex) + i;
// }
//
// int unused[3];
//
// mstudioboneflexdriver_t(){}
// private:
// // No copy constructors allowed
// mstudioboneflexdriver_t( const mstudioboneflexdriver_t &vOther );
// };
// #define BONE_CALCULATE_MASK 0x1F
// #define BONE_PHYSICALLY_SIMULATED 0x01 // bone is physically simulated when physics are active
// #define BONE_PHYSICS_PROCEDURAL 0x02 // procedural when physics is active
// #define BONE_ALWAYS_PROCEDURAL 0x04 // bone is always procedurally animated
// #define BONE_SCREEN_ALIGN_SPHERE 0x08 // bone aligns to the screen, not constrained in motion.
// #define BONE_SCREEN_ALIGN_CYLINDER 0x10 // bone aligns to the screen, constrained by it's own axis.
//
// #define BONE_USED_MASK 0x0007FF00
// #define BONE_USED_BY_ANYTHING 0x0007FF00
// #define BONE_USED_BY_HITBOX 0x00000100 // bone (or child) is used by a hit box
// #define BONE_USED_BY_ATTACHMENT 0x00000200 // bone (or child) is used by an attachment point
// #define BONE_USED_BY_VERTEX_MASK 0x0003FC00
// #define BONE_USED_BY_VERTEX_LOD0 0x00000400 // bone (or child) is used by the toplevel model via skinned vertex
// #define BONE_USED_BY_VERTEX_LOD1 0x00000800
// #define BONE_USED_BY_VERTEX_LOD2 0x00001000
// #define BONE_USED_BY_VERTEX_LOD3 0x00002000
// #define BONE_USED_BY_VERTEX_LOD4 0x00004000
// #define BONE_USED_BY_VERTEX_LOD5 0x00008000
// #define BONE_USED_BY_VERTEX_LOD6 0x00010000
// #define BONE_USED_BY_VERTEX_LOD7 0x00020000
// #define BONE_USED_BY_BONE_MERGE 0x00040000 // bone is available for bone merge to occur against it
//
// #define BONE_USED_BY_VERTEX_AT_LOD(lod) ( BONE_USED_BY_VERTEX_LOD0 << (lod) )
// #define BONE_USED_BY_ANYTHING_AT_LOD(lod) ( ( BONE_USED_BY_ANYTHING & ~BONE_USED_BY_VERTEX_MASK ) | BONE_USED_BY_VERTEX_AT_LOD(lod) )
//
// #define MAX_NUM_LODS 8
//
// #define BONE_TYPE_MASK 0x00F00000
// #define BONE_FIXED_ALIGNMENT 0x00100000 // bone can't spin 360 degrees, all interpolation is normalized around a fixed orientation
//
// #define BONE_HAS_SAVEFRAME_POS 0x00200000 // Vector48
// #define BONE_HAS_SAVEFRAME_ROT64 0x00400000 // Quaternion64
// #define BONE_HAS_SAVEFRAME_ROT32 0x00800000 // Quaternion32
// bone controllers
struct mstudiobonecontroller_t_PS3
{
// DECLARE_BYTESWAP_DATADESC();
int bone; // -1 == 0
int type; // X, Y, Z, XR, YR, ZR, M
float start;
float end;
int rest; // byte index value at rest
int inputfield; // 0-3 user set controller, 4 mouth
int unused[8];
};
// intersection boxes
struct mstudiobbox_t_PS3
{
// DECLARE_BYTESWAP_DATADESC();
int bone;
int group; // intersection group
Vector bbmin; // bounding box
Vector bbmax;
int szhitboxnameindex; // offset to the name of the hitbox.
int unused[8];
// const char* pszHitboxName() const
// {
// if( szhitboxnameindex == 0 )
// return "";
//
// return ((const char*)this) + szhitboxnameindex;
// }
mstudiobbox_t_PS3() {}
private:
// No copy constructors allowed
mstudiobbox_t_PS3(const mstudiobbox_t_PS3& vOther);
};
// demand loaded sequence groups
// struct mstudiomodelgroup_t_PS3
// {
// DECLARE_BYTESWAP_DATADESC();
// int szlabelindex; // textual name
// inline char * const pszLabel( void ) const { return ((char *)this) + szlabelindex; }
// int sznameindex; // file name
// inline char * const pszName( void ) const { return ((char *)this) + sznameindex; }
// };
// struct mstudiomodelgrouplookup_t
// {
// int modelgroup;
// int indexwithingroup;
// };
// events
// NOTE: If you modify this struct you MUST also modify mstudioevent_for_client_server_t in npcevent.h!!!
// struct mstudioevent_t
// {
// DECLARE_BYTESWAP_DATADESC();
// float cycle;
// int event;
// int type;
// inline const char * pszOptions( void ) const { return options; }
// char options[64];
//
// int szeventindex;
// inline char * const pszEventName( void ) const { return ((char *)this) + szeventindex; }
// };
//#define ATTACHMENT_FLAG_WORLD_ALIGN 0x10000
// attachment
struct mstudioattachment_t_PS3
{
// DECLARE_BYTESWAP_DATADESC();
int sznameindex;
// inline char * const pszName( void ) const { return ((char *)this) + sznameindex; }
unsigned int flags;
int localbone;
matrix3x4_t local; // attachment point
int unused[8];
};
#if defined(__SPU__)
#define IK_SELF 1
#define IK_WORLD 2
#define IK_GROUND 3
#define IK_RELEASE 4
#define IK_ATTACHMENT 5
#define IK_UNLATCH 6
#endif
struct mstudioikerror_t_PS3
{
// DECLARE_BYTESWAP_DATADESC();
Vector pos;
Quaternion q;
mstudioikerror_t_PS3() {}
private:
// No copy constructors allowed
mstudioikerror_t_PS3(const mstudioikerror_t_PS3& vOther);
};
union mstudioanimvalue_t_PS3;
struct mstudiocompressedikerror_t_PS3
{
// DECLARE_BYTESWAP_DATADESC();
float scale[6];
short offset[6];
inline mstudioanimvalue_t_PS3 *pAnimvalue( void *pEA_this, int i ) const { if (offset[i] > 0) return (mstudioanimvalue_t_PS3 *)(((byte *)pEA_this) + offset[i]); else return NULL; };
mstudiocompressedikerror_t_PS3(){}
private:
// No copy constructors allowed
mstudiocompressedikerror_t_PS3(const mstudiocompressedikerror_t_PS3& vOther);
};
struct mstudioikrule_t_PS3
{
// DECLARE_BYTESWAP_DATADESC();
int index;
int type;
int chain;
int bone;
int slot; // iktarget slot. Usually same as chain.
float height;
float radius;
float floor;
Vector pos;
Quaternion q;
int compressedikerrorindex;
// inline mstudiocompressedikerror_t *pCompressedError() const { return (mstudiocompressedikerror_t *)(((byte *)this) + compressedikerrorindex); };
inline mstudiocompressedikerror_t_PS3 *pCompressedError( void *pEA_this ) const { return (mstudiocompressedikerror_t_PS3 *)(((byte *)pEA_this) + compressedikerrorindex); };
int unused2;
int iStart;
int ikerrorindex;
// inline mstudioikerror_t *pError( int i ) const { return (ikerrorindex) ? (mstudioikerror_t *)(((byte *)this) + ikerrorindex) + (i - iStart) : NULL; };
inline mstudioikerror_t_PS3 *pError( void *pEA_this, int i ) const { return (ikerrorindex) ? (mstudioikerror_t_PS3 *)(((byte *)pEA_this) + ikerrorindex) + (i - iStart) : NULL; };
float start; // beginning of influence
float peak; // start of full influence
float tail; // end of full influence
float end; // end of all influence
float unused3; //
float contact; // frame footstep makes ground concact
float drop; // how far down the foot should drop when reaching for IK
float top; // top of the foot box
int unused6;
int unused7;
int unused8;
int szattachmentindex; // name of world attachment
// inline char * const pszAttachment( void ) const { return ((char *)this) + szattachmentindex; }
int unused[7];
// int unused[6];
// void* pEA_this;
mstudioikrule_t_PS3() {}
private:
// No copy constructors allowed
mstudioikrule_t_PS3(const mstudioikrule_t_PS3& vOther);
};
struct mstudioikrulezeroframe_t_PS3
{
short chain;
short slot;
float16 start; // beginning of influence
float16 peak; // start of full influence
float16 tail; // end of full influence
float16 end; // end of all influence
};
struct mstudioiklock_t_PS3
{
// DECLARE_BYTESWAP_DATADESC();
int chain;
float flPosWeight;
float flLocalQWeight;
int flags;
int unused[4];
};
// struct mstudiolocalhierarchy_t
// {
// DECLARE_BYTESWAP_DATADESC();
// int iBone; // bone being adjusted
// int iNewParent; // the bones new parent
//
// float start; // beginning of influence
// float peak; // start of full influence
// float tail; // end of full influence
// float end; // end of all influence
//
// int iStart; // first frame
//
// int localanimindex;
// inline mstudiocompressedikerror_t *pLocalAnim() const { return (mstudiocompressedikerror_t *)(((byte *)this) + localanimindex); };
//
// int unused[4];
// };
// animation frames
union mstudioanimvalue_t_PS3
{
struct
{
byte valid;
byte total;
} num;
short value;
};
struct mstudioanim_valueptr_t_PS3
{
// DECLARE_BYTESWAP_DATADESC();
short offset[3];
inline mstudioanimvalue_t_PS3 *pAnimvalue( void *pEA_this, int i ) const { if (offset[i] > 0) return (mstudioanimvalue_t_PS3 *)(((byte *)pEA_this) + offset[i]); else return NULL; };
};
#if defined(__SPU__)
#define STUDIO_ANIM_RAWPOS 0x01 // Vector48
#define STUDIO_ANIM_RAWROT 0x02 // Quaternion48
#define STUDIO_ANIM_ANIMPOS 0x04 // mstudioanim_valueptr_t
#define STUDIO_ANIM_ANIMROT 0x08 // mstudioanim_valueptr_t
#define STUDIO_ANIM_DELTA 0x10
#define STUDIO_ANIM_RAWROT2 0x20 // Quaternion64
#endif
// per bone per animation DOF and weight pointers, RLE encoded
struct mstudio_rle_anim_t_PS3
{
// DECLARE_BYTESWAP_DATADESC();
byte bone;
byte flags; // weighing options
// valid for animating data only
inline byte *pData( void *pEA_this ) const { return (((byte *)pEA_this) + sizeof( struct mstudio_rle_anim_t_PS3 )); };
inline mstudioanim_valueptr_t_PS3 *pRotV( void *pEA_this ) const { return (mstudioanim_valueptr_t_PS3 *)(pData( pEA_this )); };
inline mstudioanim_valueptr_t_PS3 *pPosV( void *pEA_this ) const { return (mstudioanim_valueptr_t_PS3 *)(pData( pEA_this )) + ((flags & STUDIO_ANIM_ANIMROT) != 0); };
// valid if animation unvaring over timeline
inline Quaternion48 *pQuat48( void *pEA_this ) const { return (Quaternion48 *)(pData( pEA_this )); };
inline Quaternion64 *pQuat64( void *pEA_this ) const { return (Quaternion64 *)(pData( pEA_this )); };
inline Vector48 *pPos( void *pEA_this ) const { return (Vector48 *)(pData( pEA_this ) + ((flags & STUDIO_ANIM_RAWROT) != 0) * sizeof( *pQuat48( pEA_this ) ) + ((flags & STUDIO_ANIM_RAWROT2) != 0) * sizeof( *pQuat64( pEA_this ) ) ); };
// inline Vector48 *pPos( void *pEA_this ) const { return (Vector48 *)(pData( pEA_this ) + ((flags & STUDIO_ANIM_RAWROT) != 0) * sizeof( Quaternion48 ) + ((flags & STUDIO_ANIM_RAWROT2) != 0) * sizeof( Quaternion64 ) ); };
// points to next bone in the list
short nextoffset;
inline mstudio_rle_anim_t_PS3 *pNext( void *pEA_this ) const { if (nextoffset != 0) return (mstudio_rle_anim_t_PS3 *)(((byte *)pEA_this) + nextoffset); else return NULL; };
};
// #define STUDIO_FRAME_CONST_POS 0x01 // Vector48 in constants
// #define STUDIO_FRAME_CONST_ROT 0x02 // Quaternion48 in constants
// #define STUDIO_FRAME_ANIM_POS 0x04 // Vector48 in framedata
// #define STUDIO_FRAME_ANIM_ROT 0x08 // Quaternion48 in framedata
// #define STUDIO_FRAME_ANIM_POS2 0x10 // Vector in framedata
// #define STUDIO_FRAME_CONST_POS2 0x20 // Vector in constants
// #define STUDIO_FRAME_CONST_ROT2 0x40 // Quaternion48S in constants
// #define STUDIO_FRAME_ANIM_ROT2 0x80 // Quaternion48S in framedata
struct mstudio_frame_anim_t_PS3
{
// DECLARE_BYTESWAP_DATADESC();
inline byte *pBoneFlags( void *pEA_this ) const { return (((byte *)pEA_this) + sizeof( struct mstudio_frame_anim_t_PS3 )); };
int constantsoffset;
inline byte *pConstantData( void *pEA_this ) const { return (((byte *)pEA_this) + constantsoffset); };
int frameoffset;
int framelength;
inline byte *pFrameData( void *pEA_this, int iFrame ) const { return (((byte *)pEA_this) + frameoffset + iFrame * framelength); };
int unused[3];
};
// struct mstudiomovement_t_PS3
// {
// // DECLARE_BYTESWAP_DATADESC();
// int endframe;
// int motionflags;
// float v0; // velocity at start of block
// float v1; // velocity at end of block
// float angle; // YAW rotation at end of this blocks movement
// Vector vector; // movement vector relative to this blocks initial angle
// Vector position; // relative to start of animation???
//
// mstudiomovement_t_PS3(){}
// private:
// // No copy constructors allowed
// mstudiomovement_t_PS3(const mstudiomovement_t_PS3& vOther);
// };
// used for piecewise loading of animation data
struct mstudioanimblock_t_PS3
{
// DECLARE_BYTESWAP_DATADESC();
int datastart;
int dataend;
};
struct mstudioanimsections_t_PS3
{
// DECLARE_BYTESWAP_DATADESC();
int animblock;
int animindex;
};
struct mstudioanimdesc_t_PS3
{
// DECLARE_BYTESWAP_DATADESC();
int baseptr;
// inline studiohdr_t *pStudiohdr( void ) const { return (studiohdr_t *)(((byte *)this) + baseptr); }
// inline studiohdr_t *pStudiohdr( void *pEA_this ) const { return (studiohdr_t *)(((byte *)pEA_this) + baseptr); }
int sznameindex;
// inline char * const pszName( void ) const { return ((char *)this) + sznameindex; }
inline char * const pszName( void *pEA_this ) const { return ((char *)pEA_this) + sznameindex; }
float fps; // frames per second
int flags; // looping/non-looping flags
int numframes;
// piecewise movement
int nummovements;
int movementindex;
// inline mstudiomovement_t * const pMovement( int i ) const { return (mstudiomovement_t *)(((byte *)this) + movementindex) + i; };
// inline mstudiomovement_t * const pMovement( void *pEA_this, int i ) const { return (mstudiomovement_t *)(((byte *)pEA_this) + movementindex) + i; };
int ikrulezeroframeindex;
// mstudioikrulezeroframe_t *pIKRuleZeroFrame( int i ) const { if (ikrulezeroframeindex) return (mstudioikrulezeroframe_t *)(((byte *)this) + ikrulezeroframeindex) + i; else return NULL; };
// mstudioikrulezeroframe_t *pIKRuleZeroFrame( void *pEA_this, int i ) const { if (ikrulezeroframeindex) return (mstudioikrulezeroframe_t *)(((byte *)pEA_this) + ikrulezeroframeindex) + i; else return NULL; };
int unused1[5]; // remove as appropriate (and zero if loading older versions)
int animblock;
int animindex; // non-zero when anim data isn't in sections
// byte *pAnimBlock( int block, int index, bool preloadIfMissing = true) const; // returns pointer to a specific anim block (local or external)
// bool hasAnimBlockBeenPreloaded( int block ) const;
// byte *pAnim( int *piFrame, float &flStall ) const; // returns pointer to data and new frame index
// byte *pAnim( int *piFrame ) const; // returns pointer to data and new frame index
int numikrules;
int ikruleindex; // non-zero when IK rule is stored in the mdl
int animblockikruleindex; // non-zero when IK data is stored in animblock file
// mstudioikrule_t *pIKRule( int i ) const;
int numlocalhierarchy;
int localhierarchyindex;
// mstudiolocalhierarchy_t *pHierarchy( int i ) const;
int sectionindex;
int sectionframes; // number of frames used in each fast lookup section, zero if not used
// inline mstudioanimsections_t * const pSection( int i ) const { return (mstudioanimsections_t *)(((byte *)this) + sectionindex) + i; }
// inline mstudioanimsections_t * const pSection( void *pEA_this, int i ) const { return (mstudioanimsections_t *)(((byte *)pEA_this) + sectionindex) + i; }
short zeroframespan; // frames per span
short zeroframecount; // number of spans
int zeroframeindex;
// byte *pZeroFrameData( ) const { if (zeroframeindex) return (((byte *)this) + zeroframeindex); else return NULL; };
byte *pZeroFrameData( void *pEA_this ) const { if (zeroframeindex) return (((byte *)pEA_this) + zeroframeindex); else return NULL; };
mutable float zeroframestalltime; // saved during read stalls
mstudioanimdesc_t_PS3(){}
private:
// No copy constructors allowed
mstudioanimdesc_t_PS3(const mstudioanimdesc_t_PS3& vOther);
};
struct mstudioikrule_t_PS3;
struct mstudioautolayer_t_PS3
{
// DECLARE_BYTESWAP_DATADESC();
//private:
short iSequence;
short iPose;
//public:
int flags;
float start; // beginning of influence
float peak; // start of full influence
float tail; // end of full influence
float end; // end of all influence
};
// struct mstudioactivitymodifier_t
// {
// DECLARE_BYTESWAP_DATADESC();
//
// int sznameindex;
// inline char *pszName() { return (sznameindex) ? (char *)(((byte *)this) + sznameindex ) : NULL; }
// };
// sequence descriptions
struct mstudioseqdesc_t_PS3
{
// DECLARE_BYTESWAP_DATADESC();
int baseptr;
// inline studiohdr_t *pStudiohdr( void *pEA_this ) const { return (studiohdr_t *)(((byte *)pEA_this) + baseptr); }
int szlabelindex;
// inline char * const pszLabel( void *pEA_this ) const { return ((char *)pEA_this) + szlabelindex; }
int szactivitynameindex;
// inline char * const pszActivityName( void ) const { return ((char *)this) + szactivitynameindex; }
// inline char * const pszActivityName( void ) const { return pEA_this + szactivitynameindex; }
int flags; // looping/non-looping flags
int activity; // initialized at loadtime to game DLL values
int actweight;
int numevents;
int eventindex;
// inline mstudioevent_t *pEvent( int i ) const { Assert( i >= 0 && i < numevents); return (mstudioevent_t *)(((byte *)this) + eventindex) + i; };
// inline mstudioevent_t *pEvent( int i ) const { Assert( i >= 0 && i < numevents); return (mstudioevent_t *)(pEA_this + eventindex) + i; };
Vector bbmin; // per sequence bounding box
Vector bbmax;
int numblends;
// Index into array of shorts which is groupsize[0] x groupsize[1] in length
int animindexindex;
inline int anim( void *pEA_this, int x, int y ) const
{
if ( x >= groupsize[0] )
{
x = groupsize[0] - 1;
}
if ( y >= groupsize[1] )
{
y = groupsize[ 1 ] - 1;
}
int offset = y * groupsize[0] + x;
short *blends = (short *)(((byte *)pEA_this) + animindexindex);
int value = (int)blends[ offset ];
return value;
}
int movementindex; // [blend] float array for blended movement
int groupsize[2];
int paramindex[2]; // X, Y, Z, XR, YR, ZR
float paramstart[2]; // local (0..1) starting value
float paramend[2]; // local (0..1) ending value
int paramparent;
float fadeintime; // ideal cross fate in time (0.2 default)
float fadeouttime; // ideal cross fade out time (0.2 default)
int localentrynode; // transition node at entry
int localexitnode; // transition node at exit
int nodeflags; // transition rules
float entryphase; // used to match entry gait
float exitphase; // used to match exit gait
float lastframe; // frame that should generation EndOfSequence
int nextseq; // auto advancing sequences
int pose; // index of delta animation between end and nextseq
int numikrules;
int numautolayers; //
int autolayerindex;
// inline mstudioautolayer_t *pAutolayer( int i ) const { Assert( i >= 0 && i < numautolayers); return (mstudioautolayer_t *)(((byte *)this) + autolayerindex) + i; };
// inline mstudioautolayer_t *pAutolayer( int i ) const { Assert( i >= 0 && i < numautolayers); return (mstudioautolayer_t *)(pEA_this + autolayerindex) + i; };
int weightlistindex;
inline float *pBoneweight( void *pEA_this, int i ) const { return ((float *)(((byte *)pEA_this) + weightlistindex) + i); };
inline float weight( void *pEA_this, int i ) const { return *(pBoneweight( pEA_this, i )); };
// FIXME: make this 2D instead of 2x1D arrays
int posekeyindex;
// float *pPoseKey( int iParam, int iAnim ) const { return (float *)(((byte *)this) + posekeyindex) + iParam * groupsize[0] + iAnim; }
// float poseKey( int iParam, int iAnim ) const { return *(pPoseKey( iParam, iAnim )); }
int numiklocks;
int iklockindex;
inline mstudioiklock_t_PS3 *pIKLock( void *pEA_this, int i ) const { Assert( i >= 0 && i < numiklocks); return (mstudioiklock_t_PS3 *)(((byte *)pEA_this) + iklockindex) + i; };
// Key values
int keyvalueindex;
int keyvaluesize;
// inline const char * KeyValueText( void ) const { return keyvaluesize != 0 ? ((char *)this) + keyvalueindex : NULL; }
int cycleposeindex; // index of pose parameter to use as cycle index
int activitymodifierindex;
int numactivitymodifiers;
// inline mstudioactivitymodifier_t *pActivityModifier( int i ) const { Assert( i >= 0 && i < numactivitymodifiers); return activitymodifierindex != 0 ? (mstudioactivitymodifier_t *)(((byte *)this) + activitymodifierindex) + i : NULL; };
int unused[5]; // remove/add as appropriate (grow back to 8 ints on version change!)
mstudioseqdesc_t_PS3(){}
private:
// No copy constructors allowed
mstudioseqdesc_t_PS3(const mstudioseqdesc_t_PS3& vOther);
};
struct mstudioposeparamdesc_t_PS3
{
// DECLARE_BYTESWAP_DATADESC();
int sznameindex;
// inline char * const pszName( void ) const { return ((char *)this) + sznameindex; }
int flags; // ????
float start; // starting value
float end; // ending value
float loop; // looping range, 0 for no looping, 360 for rotations, etc.
};
// struct mstudioflexdesc_t
// {
// DECLARE_BYTESWAP_DATADESC();
// int szFACSindex;
// inline char * const pszFACS( void ) const { return ((char *)this) + szFACSindex; }
// };
// struct mstudioflexcontroller_t
// {
// DECLARE_BYTESWAP_DATADESC();
// int sztypeindex;
// inline char * const pszType( void ) const { return ((char *)this) + sztypeindex; }
// int sznameindex;
// inline char * const pszName( void ) const { return ((char *)this) + sznameindex; }
// mutable int localToGlobal; // remapped at load time to master list
// float min;
// float max;
// };
// enum FlexControllerRemapType_t
// {
// FLEXCONTROLLER_REMAP_PASSTHRU = 0,
// FLEXCONTROLLER_REMAP_2WAY, // Control 0 -> ramps from 1-0 from 0->0.5. Control 1 -> ramps from 0-1 from 0.5->1
// FLEXCONTROLLER_REMAP_NWAY, // StepSize = 1 / (control count-1) Control n -> ramps from 0-1-0 from (n-1)*StepSize to n*StepSize to (n+1)*StepSize. A second control is needed to specify amount to use
// FLEXCONTROLLER_REMAP_EYELID
// };
//class CStudioHdr_PS3;
// struct mstudioflexcontrollerui_t
// {
// DECLARE_BYTESWAP_DATADESC();
// int sznameindex;
// inline char * const pszName( void ) const { return ((char *)this) + sznameindex; }
//
// // These are used like a union to save space
// // Here are the possible configurations for a UI controller
// //
// // SIMPLE NON-STEREO: 0: control 1: unused 2: unused
// // STEREO: 0: left 1: right 2: unused
// // NWAY NON-STEREO: 0: control 1: unused 2: value
// // NWAY STEREO: 0: left 1: right 2: value
//
// int szindex0;
// int szindex1;
// int szindex2;
//
// inline const mstudioflexcontroller_t *pController( void ) const
// {
// return !stereo ? (mstudioflexcontroller_t *)( (char *)this + szindex0 ) : NULL;
// }
// inline char * const pszControllerName( void ) const { return !stereo ? pController()->pszName() : NULL; }
// inline int controllerIndex( const CStudioHdr &cStudioHdr ) const;
//
// inline const mstudioflexcontroller_t *pLeftController( void ) const
// {
// return stereo ? (mstudioflexcontroller_t *)( (char *)this + szindex0 ) : NULL;
// }
// inline char * const pszLeftName( void ) const { return stereo ? pLeftController()->pszName() : NULL; }
// inline int leftIndex( const CStudioHdr &cStudioHdr ) const;
//
// inline const mstudioflexcontroller_t *pRightController( void ) const
// {
// return stereo ? (mstudioflexcontroller_t *)( (char *)this + szindex1 ): NULL;
// }
// inline char * const pszRightName( void ) const { return stereo ? pRightController()->pszName() : NULL; }
// inline int rightIndex( const CStudioHdr &cStudioHdr ) const;
//
// inline const mstudioflexcontroller_t *pNWayValueController( void ) const
// {
// return remaptype == FLEXCONTROLLER_REMAP_NWAY ? (mstudioflexcontroller_t *)( (char *)this + szindex2 ) : NULL;
// }
// inline char * const pszNWayValueName( void ) const { return remaptype == FLEXCONTROLLER_REMAP_NWAY ? pNWayValueController()->pszName() : NULL; }
// inline int nWayValueIndex( const CStudioHdr &cStudioHdr ) const;
//
// // Number of controllers this ui description contains, 1, 2 or 3
// inline int Count() const { return ( stereo ? 2 : 1 ) + ( remaptype == FLEXCONTROLLER_REMAP_NWAY ? 1 : 0 ); }
// inline const mstudioflexcontroller_t *pController( int index ) const;
//
// unsigned char remaptype; // See the FlexControllerRemapType_t enum
// bool stereo; // Is this a stereo control?
// byte unused[2];
// };
// this is the memory image of vertex anims (16-bit fixed point)
// struct mstudiovertanim_t
// {
// DECLARE_BYTESWAP_DATADESC();
// unsigned short index;
// byte speed; // 255/max_length_in_flex
// byte side; // 255/left_right
//
// protected:
// union
// {
// short delta[3];
// float16 flDelta[3];
// };
//
// union
// {
// short ndelta[3];
// float16 flNDelta[3];
// };
//
// public:
// inline void ConvertToFixed( float flVertAnimFixedPointScale )
// {
// delta[0] = ( short )( flDelta[0].GetFloat() / flVertAnimFixedPointScale );
// delta[1] = ( short )( flDelta[1].GetFloat() / flVertAnimFixedPointScale );
// delta[2] = ( short )( flDelta[2].GetFloat() / flVertAnimFixedPointScale );
// ndelta[0] = ( short )( flNDelta[0].GetFloat() / flVertAnimFixedPointScale );
// ndelta[1] = ( short )( flNDelta[1].GetFloat() / flVertAnimFixedPointScale );
// ndelta[2] = ( short )( flNDelta[2].GetFloat() / flVertAnimFixedPointScale );
// }
//
// inline Vector GetDeltaFixed( float flVertAnimFixedPointScale )
// {
// return Vector( delta[0] * flVertAnimFixedPointScale, delta[1] * flVertAnimFixedPointScale, delta[2] * flVertAnimFixedPointScale );
// }
// inline Vector GetNDeltaFixed( float flVertAnimFixedPointScale )
// {
// return Vector( ndelta[0] * flVertAnimFixedPointScale, ndelta[1] * flVertAnimFixedPointScale, ndelta[2] * flVertAnimFixedPointScale );
// }
// inline void GetDeltaFixed4DAligned( Vector4DAligned *vFillIn, float flVertAnimFixedPointScale )
// {
// vFillIn->Set( delta[0] * flVertAnimFixedPointScale, delta[1] * flVertAnimFixedPointScale, delta[2] * flVertAnimFixedPointScale, 0.0f );
// }
// inline void GetNDeltaFixed4DAligned( Vector4DAligned *vFillIn, float flVertAnimFixedPointScale )
// {
// vFillIn->Set( ndelta[0] * flVertAnimFixedPointScale, ndelta[1] * flVertAnimFixedPointScale, ndelta[2] * flVertAnimFixedPointScale, 0.0f );
// }
// inline Vector GetDeltaFloat()
// {
// return Vector (flDelta[0].GetFloat(), flDelta[1].GetFloat(), flDelta[2].GetFloat());
// }
// inline Vector GetNDeltaFloat()
// {
// return Vector (flNDelta[0].GetFloat(), flNDelta[1].GetFloat(), flNDelta[2].GetFloat());
// }
// inline void SetDeltaFixed( const Vector& vInput, float flVertAnimFixedPointScale )
// {
// delta[0] = ( short )( vInput.x / flVertAnimFixedPointScale );
// delta[1] = ( short )( vInput.y / flVertAnimFixedPointScale );
// delta[2] = ( short )( vInput.z / flVertAnimFixedPointScale );
// }
// inline void SetNDeltaFixed( const Vector& vInputNormal, float flVertAnimFixedPointScale )
// {
// ndelta[0] = ( short )( vInputNormal.x / flVertAnimFixedPointScale );
// ndelta[1] = ( short )( vInputNormal.y / flVertAnimFixedPointScale );
// ndelta[2] = ( short )( vInputNormal.z / flVertAnimFixedPointScale );
// }
//
// // Ick...can also force fp16 data into this structure for writing to file in legacy format...
// inline void SetDeltaFloat( const Vector& vInput )
// {
// flDelta[0].SetFloat( vInput.x );
// flDelta[1].SetFloat( vInput.y );
// flDelta[2].SetFloat( vInput.z );
// }
// inline void SetNDeltaFloat( const Vector& vInputNormal )
// {
// flNDelta[0].SetFloat( vInputNormal.x );
// flNDelta[1].SetFloat( vInputNormal.y );
// flNDelta[2].SetFloat( vInputNormal.z );
// }
//
// class CSortByIndex
// {
// public:
// bool operator()(const mstudiovertanim_t &left, const mstudiovertanim_t & right)const
// {
// return left.index < right.index;
// }
// };
// friend class CSortByIndex;
//
// mstudiovertanim_t(){}
// //private:
// // No copy constructors allowed, but it's needed for std::sort()
// // mstudiovertanim_t(const mstudiovertanim_t& vOther);
// };
// this is the memory image of vertex anims (16-bit fixed point)
// struct mstudiovertanim_wrinkle_t : public mstudiovertanim_t
// {
// DECLARE_BYTESWAP_DATADESC();
//
// short wrinkledelta;
//
// inline void SetWrinkleFixed( float flWrinkle, float flVertAnimFixedPointScale )
// {
// int nWrinkleDeltaInt = ( int )( flWrinkle / flVertAnimFixedPointScale );
// wrinkledelta = clamp( nWrinkleDeltaInt, -32767, 32767 );
// }
//
// inline Vector4D GetDeltaFixed( float flVertAnimFixedPointScale )
// {
// return Vector4D( delta[0] * flVertAnimFixedPointScale, delta[1] * flVertAnimFixedPointScale, delta[2] * flVertAnimFixedPointScale, wrinkledelta * flVertAnimFixedPointScale );
// }
//
// inline void GetDeltaFixed4DAligned( Vector4DAligned *vFillIn, float flVertAnimFixedPointScale )
// {
// vFillIn->Set( delta[0] * flVertAnimFixedPointScale, delta[1] * flVertAnimFixedPointScale, delta[2] * flVertAnimFixedPointScale, wrinkledelta * flVertAnimFixedPointScale );
// }
//
// inline float GetWrinkleDeltaFixed( float flVertAnimFixedPointScale )
// {
// return wrinkledelta * flVertAnimFixedPointScale;
// }
// };
// enum StudioVertAnimType_t
// {
// STUDIO_VERT_ANIM_NORMAL = 0,
// STUDIO_VERT_ANIM_WRINKLE,
// };
// struct mstudioflex_t
// {
// DECLARE_BYTESWAP_DATADESC();
// int flexdesc; // input value
//
// float target0; // zero
// float target1; // one
// float target2; // one
// float target3; // zero
//
// int numverts;
// int vertindex;
//
// inline mstudiovertanim_t *pVertanim( int i ) const { Assert( vertanimtype == STUDIO_VERT_ANIM_NORMAL ); return (mstudiovertanim_t *)(((byte *)this) + vertindex) + i; };
// inline mstudiovertanim_wrinkle_t *pVertanimWrinkle( int i ) const { Assert( vertanimtype == STUDIO_VERT_ANIM_WRINKLE ); return (mstudiovertanim_wrinkle_t *)(((byte *)this) + vertindex) + i; };
//
// inline byte *pBaseVertanim( ) const { return ((byte *)this) + vertindex; };
// inline int VertAnimSizeBytes() const { return ( vertanimtype == STUDIO_VERT_ANIM_NORMAL ) ? sizeof(mstudiovertanim_t) : sizeof(mstudiovertanim_wrinkle_t); }
//
// int flexpair; // second flex desc
// unsigned char vertanimtype; // See StudioVertAnimType_t
// unsigned char unusedchar[3];
// int unused[6];
//
// };
// struct mstudioflexop_t
// {
// DECLARE_BYTESWAP_DATADESC();
// int op;
// union
// {
// int index;
// float value;
// } d;
// };
// struct mstudioflexrule_t
// {
// DECLARE_BYTESWAP_DATADESC();
// int flex;
// int numops;
// int opindex;
// inline mstudioflexop_t *iFlexOp( int i ) const { return (mstudioflexop_t *)(((byte *)this) + opindex) + i; };
// };
// 16 bytes
// struct mstudioboneweight_t
// {
// DECLARE_BYTESWAP_DATADESC();
// float weight[MAX_NUM_BONES_PER_VERT];
// byte bone[MAX_NUM_BONES_PER_VERT];
// byte numbones;
//
// // byte material;
// // short firstref;
// // short lastref;
// };
// NOTE: This is exactly 48 bytes
// struct mstudiovertex_t
// {
// DECLARE_BYTESWAP_DATADESC();
// mstudioboneweight_t m_BoneWeights;
// Vector m_vecPosition;
// Vector m_vecNormal;
// Vector2D m_vecTexCoord;
//
// mstudiovertex_t() {}
//
// private:
// // No copy constructors allowed
// mstudiovertex_t(const mstudiovertex_t& vOther);
// };
// skin info
// struct mstudiotexture_t
// {
// DECLARE_BYTESWAP_DATADESC();
// int sznameindex;
// inline char * const pszName( void ) const { return ((char *)this) + sznameindex; }
// int flags;
// int used;
// int unused1;
// mutable IMaterial *material; // fixme: this needs to go away . .isn't used by the engine, but is used by studiomdl
// mutable void *clientmaterial; // gary, replace with client material pointer if used
//
// int unused[10];
// };
// eyeball
// struct mstudioeyeball_t
// {
// DECLARE_BYTESWAP_DATADESC();
// int sznameindex;
// inline char * const pszName( void ) const { return ((char *)this) + sznameindex; }
// int bone;
// Vector org;
// float zoffset;
// float radius;
// Vector up;
// Vector forward;
// int texture;
//
// int unused1;
// float iris_scale;
// int unused2;
//
// int upperflexdesc[3]; // index of raiser, neutral, and lowerer flexdesc that is set by flex controllers
// int lowerflexdesc[3];
// float uppertarget[3]; // angle (radians) of raised, neutral, and lowered lid positions
// float lowertarget[3];
//
// int upperlidflexdesc; // index of flex desc that actual lid flexes look to
// int lowerlidflexdesc;
// int unused[4]; // These were used before, so not guaranteed to be 0
// bool m_bNonFACS; // Never used before version 44
// char unused3[3];
// int unused4[7];
//
// mstudioeyeball_t(){}
// private:
// // No copy constructors allowed
// mstudioeyeball_t(const mstudioeyeball_t& vOther);
// };
// ikinfo
struct mstudioiklink_t_PS3
{
// DECLARE_BYTESWAP_DATADESC();
int bone;
Vector kneeDir; // ideal bending direction (per link, if applicable)
Vector unused0; // unused
mstudioiklink_t_PS3(){}
private:
// No copy constructors allowed
mstudioiklink_t_PS3(const mstudioiklink_t_PS3& vOther);
};
struct mstudioikchain_t_PS3
{
// DECLARE_BYTESWAP_DATADESC();
int sznameindex;
// inline char * const pszName( void ) const { return ((char *)this) + sznameindex; }
int linktype;
int numlinks;
int linkindex;
inline mstudioiklink_t_PS3 *pLink( void *pEA_this, int i ) const { return (mstudioiklink_t_PS3 *)(((byte *)pEA_this) + linkindex) + i; };
// FIXME: add unused entries
};
// struct mstudioiface_t
// {
// mstudioiface_t()
// {
// a = b = c = d = 0xFFFF;
// }
//
// unsigned short a, b, c, d; // Indices to vertices (If d is 0xFFFF, this is a triangle, else it's a quad)
// };
struct mstudiomodel_t_PS3;
// struct mstudio_modelvertexdata_t
// {
// DECLARE_BYTESWAP_DATADESC();
// Vector *Position( int i ) const;
// Vector *Normal( int i ) const;
// Vector4D *TangentS( int i ) const;
// Vector2D *Texcoord( int i ) const;
// mstudioboneweight_t *BoneWeights( int i ) const;
// mstudiovertex_t *Vertex( int i ) const;
// bool HasTangentData( void ) const;
// int GetGlobalVertexIndex( int i ) const;
// int GetGlobalTangentIndex( int i ) const;
//
// // base of external vertex data stores
// const void *pVertexData;
// const void *pTangentData;
// };
// struct mstudio_meshvertexdata_t
// {
// DECLARE_BYTESWAP_DATADESC();
// Vector *Position( int i ) const;
// Vector *Normal( int i ) const;
// Vector4D *TangentS( int i ) const;
// Vector2D *Texcoord( int i ) const;
// mstudioboneweight_t *BoneWeights( int i ) const;
// mstudiovertex_t *Vertex( int i ) const;
// bool HasTangentData( void ) const;
// int GetModelVertexIndex( int i ) const;
// int GetGlobalVertexIndex( int i ) const;
//
// // indirection to this mesh's model's vertex data
// const mstudio_modelvertexdata_t *modelvertexdata;
//
// // used for fixup calcs when culling top level lods
// // expected number of mesh verts at desired lod
// int numLODVertexes[MAX_NUM_LODS];
// };
// struct mstudiomesh_t
// {
// DECLARE_BYTESWAP_DATADESC();
// int material;
//
// int modelindex;
// mstudiomodel_t *pModel() const;
//
// int numvertices; // number of unique vertices/normals/texcoords
// int vertexoffset; // vertex mstudiovertex_t
//
// // Access thin/fat mesh vertex data (only one will return a non-NULL result)
// const mstudio_meshvertexdata_t *GetVertexData( void *pModelData = NULL );
// const thinModelVertices_t *GetThinVertexData( void *pModelData = NULL );
//
// int numflexes; // vertex animation
// int flexindex;
// inline mstudioflex_t *pFlex( int i ) const { return (mstudioflex_t *)(((byte *)this) + flexindex) + i; };
//
// // special codes for material operations
// int materialtype;
// int materialparam;
//
// // a unique ordinal for this mesh
// int meshid;
//
// Vector center;
//
// mstudio_meshvertexdata_t vertexdata;
//
// int unused[8]; // remove as appropriate
//
// mstudiomesh_t(){}
// private:
// // No copy constructors allowed
// mstudiomesh_t(const mstudiomesh_t& vOther);
// };
// studio models
// struct mstudiomodel_t
// {
// DECLARE_BYTESWAP_DATADESC();
// inline const char * pszName( void ) const { return name; }
// char name[64];
//
// int type;
//
// float boundingradius;
//
// int nummeshes;
// int meshindex;
// inline mstudiomesh_t *pMesh( int i ) const { return (mstudiomesh_t *)(((byte *)this) + meshindex) + i; };
//
// // cache purposes
// int numvertices; // number of unique vertices/normals/texcoords
// int vertexindex; // vertex Vector
// int tangentsindex; // tangents Vector
//
// // These functions are defined in application-specific code:
// const vertexFileHeader_t *CacheVertexData( void *pModelData );
//
// // Access thin/fat mesh vertex data (only one will return a non-NULL result)
// const mstudio_modelvertexdata_t *GetVertexData( void *pModelData = NULL );
// const thinModelVertices_t *GetThinVertexData( void *pModelData = NULL );
//
// int numattachments;
// int attachmentindex;
//
// int numeyeballs;
// int eyeballindex;
// inline mstudioeyeball_t *pEyeball( int i ) { return (mstudioeyeball_t *)(((byte *)this) + eyeballindex) + i; };
//
// mstudio_modelvertexdata_t vertexdata;
//
// int unused[8]; // remove as appropriate
// };
// inline bool mstudio_modelvertexdata_t::HasTangentData( void ) const
// {
// return (pTangentData != NULL);
// }
// inline int mstudio_modelvertexdata_t::GetGlobalVertexIndex( int i ) const
// {
// mstudiomodel_t *modelptr = (mstudiomodel_t *)((byte *)this - offsetof(mstudiomodel_t, vertexdata));
// Assert( ( modelptr->vertexindex % sizeof( mstudiovertex_t ) ) == 0 );
// return ( i + ( modelptr->vertexindex / sizeof( mstudiovertex_t ) ) );
// }
//
// inline int mstudio_modelvertexdata_t::GetGlobalTangentIndex( int i ) const
// {
// mstudiomodel_t *modelptr = (mstudiomodel_t *)((byte *)this - offsetof(mstudiomodel_t, vertexdata));
// Assert( ( modelptr->tangentsindex % sizeof( Vector4D ) ) == 0 );
// return ( i + ( modelptr->tangentsindex / sizeof( Vector4D ) ) );
// }
//
// inline mstudiovertex_t *mstudio_modelvertexdata_t::Vertex( int i ) const
// {
// return (mstudiovertex_t *)pVertexData + GetGlobalVertexIndex( i );
// }
//
// inline Vector *mstudio_modelvertexdata_t::Position( int i ) const
// {
// return &Vertex(i)->m_vecPosition;
// }
//
// inline Vector *mstudio_modelvertexdata_t::Normal( int i ) const
// {
// return &Vertex(i)->m_vecNormal;
// }
//
// inline Vector4D *mstudio_modelvertexdata_t::TangentS( int i ) const
// {
// // NOTE: The tangents vector is 16-bytes in a separate array
// // because it only exists on the high end, and if I leave it out
// // of the mstudiovertex_t, the vertex is 64-bytes (good for low end)
// return (Vector4D *)pTangentData + GetGlobalTangentIndex( i );
// }
//
// inline Vector2D *mstudio_modelvertexdata_t::Texcoord( int i ) const
// {
// return &Vertex(i)->m_vecTexCoord;
// }
//
// inline mstudioboneweight_t *mstudio_modelvertexdata_t::BoneWeights( int i ) const
// {
// return &Vertex(i)->m_BoneWeights;
// }
//
// inline mstudiomodel_t *mstudiomesh_t::pModel() const
// {
// return (mstudiomodel_t *)(((byte *)this) + modelindex);
// }
//
// inline bool mstudio_meshvertexdata_t::HasTangentData( void ) const
// {
// return modelvertexdata->HasTangentData();
// }
//
// inline const mstudio_meshvertexdata_t *mstudiomesh_t::GetVertexData( void *pModelData )
// {
// // get this mesh's model's vertex data (allow for mstudiomodel_t::GetVertexData
// // returning NULL if the data has been converted to 'thin' vertices)
// this->pModel()->GetVertexData( pModelData );
// vertexdata.modelvertexdata = &( this->pModel()->vertexdata );
//
// if ( !vertexdata.modelvertexdata->pVertexData )
// return NULL;
//
// return &vertexdata;
// }
//
// inline const thinModelVertices_t * mstudiomesh_t::GetThinVertexData( void *pModelData )
// {
// // get this mesh's model's thin vertex data
// return this->pModel()->GetThinVertexData( pModelData );
// }
//
// inline int mstudio_meshvertexdata_t::GetModelVertexIndex( int i ) const
// {
// mstudiomesh_t *meshptr = (mstudiomesh_t *)((byte *)this - offsetof(mstudiomesh_t,vertexdata));
// return meshptr->vertexoffset + i;
// }
//
// inline int mstudio_meshvertexdata_t::GetGlobalVertexIndex( int i ) const
// {
// return modelvertexdata->GetGlobalVertexIndex( GetModelVertexIndex( i ) );
// }
//
// inline Vector *mstudio_meshvertexdata_t::Position( int i ) const
// {
// return modelvertexdata->Position( GetModelVertexIndex( i ) );
// };
//
// inline Vector *mstudio_meshvertexdata_t::Normal( int i ) const
// {
// return modelvertexdata->Normal( GetModelVertexIndex( i ) );
// };
//
// inline Vector4D *mstudio_meshvertexdata_t::TangentS( int i ) const
// {
// return modelvertexdata->TangentS( GetModelVertexIndex( i ) );
// }
//
// inline Vector2D *mstudio_meshvertexdata_t::Texcoord( int i ) const
// {
// return modelvertexdata->Texcoord( GetModelVertexIndex( i ) );
// };
//
// inline mstudioboneweight_t *mstudio_meshvertexdata_t::BoneWeights( int i ) const
// {
// return modelvertexdata->BoneWeights( GetModelVertexIndex( i ) );
// };
//
// inline mstudiovertex_t *mstudio_meshvertexdata_t::Vertex( int i ) const
// {
// return modelvertexdata->Vertex( GetModelVertexIndex( i ) );
// }
//
// // a group of studio model data
// enum studiomeshgroupflags_t
// {
// MESHGROUP_IS_HWSKINNED = 0x2,
// MESHGROUP_IS_DELTA_FLEXED = 0x4
// };
// ----------------------------------------------------------
// Runtime stuff
// ----------------------------------------------------------
// struct studiomeshgroup_t
// {
// IMesh *m_pMesh;
// int m_NumStrips;
// int m_Flags; // see studiomeshgroupflags_t
// OptimizedModel::StripHeader_t *m_pStripData;
// unsigned short *m_pGroupIndexToMeshIndex;
// int m_NumVertices;
// int *m_pUniqueFaces; // for performance measurements
// unsigned short *m_pIndices;
// unsigned short *m_pTopologyIndices;
// bool m_MeshNeedsRestore;
// short m_ColorMeshID;
// IMorph *m_pMorph;
//
// inline unsigned short MeshIndex( int i ) const { return m_pGroupIndexToMeshIndex[m_pIndices[i]]; }
// };
// studio model data
// struct studiomeshdata_t
// {
// int m_NumGroup;
// studiomeshgroup_t* m_pMeshGroup;
// };
//
// struct studioloddata_t
// {
// // not needed - this is really the same as studiohwdata_t.m_NumStudioMeshes
// //int m_NumMeshes;
// studiomeshdata_t *m_pMeshData; // there are studiohwdata_t.m_NumStudioMeshes of these.
// float m_SwitchPoint;
// // one of these for each lod since we can switch to simpler materials on lower lods.
// int numMaterials;
// IMaterial **ppMaterials; /* will have studiohdr_t.numtextures elements allocated */
// // hack - this needs to go away.
// int *pMaterialFlags; /* will have studiohdr_t.numtextures elements allocated */
// #ifndef _CERT
// int m_NumFaces; /* Total face count for this LOD */
// #endif // !_CERT
//
// // For decals on hardware morphing, we must actually do hardware skinning
// // For this to work, we have to hope that the total # of bones used by
// // hw flexed verts is < than the max possible for the dx level we're running under
// int *m_pHWMorphDecalBoneRemap;
// int m_nDecalBoneCount;
// };
//
// struct studiohwdata_t
// {
// int m_RootLOD; // calced and clamped, nonzero for lod culling
// int m_NumLODs;
// studioloddata_t *m_pLODs;
// int m_NumStudioMeshes;
//
// inline float LODMetric( float unitSphereSize ) const { return ( unitSphereSize != 0.0f ) ? (100.0f / unitSphereSize) : 0.0f; }
// inline int GetLODForMetric( float lodMetric ) const
// {
// static ConVarRef r_lod_switch_scale( "r_lod_switch_scale" );
//
// if ( !m_NumLODs )
// return 0;
//
// // On low GPU levels, we pull in the LOD transitions with a scale factor
// float flSwitchPointModifier = r_lod_switch_scale.IsValid() ? r_lod_switch_scale.GetFloat() : 1.0f;
//
// // shadow lod is specified on the last lod with a negative switch
// // never consider shadow lod as viable candidate
// int numLODs = (m_pLODs[m_NumLODs-1].m_SwitchPoint < 0.0f) ? m_NumLODs-1 : m_NumLODs;
//
// for ( int i = m_RootLOD; i < numLODs-1; i++ )
// {
// if ( ( m_pLODs[i+1].m_SwitchPoint * flSwitchPointModifier ) > lodMetric )
// return i;
// }
//
// return numLODs-1;
// }
//
// #ifndef _CERT
// // Each model counts how many rendered faces it accounts for each frame:
// inline void UpdateFacesRenderedCount( studiohdr_t *pStudioHdr, CUtlHash< studiohwdata_t * > &hwDataHash, int nLOD, int nInstances, int nFacesOverride = -1 )
// {
// if ( hwDataHash.Find( this ) == hwDataHash.InvalidHandle() )
// {
// m_NumFacesRenderedThisFrame = 0;
// m_NumTimesRenderedThisFrame = 0;
// m_pStudioHdr = pStudioHdr;
// hwDataHash.Insert( this );
// }
// Assert( m_pStudioHdr && ( m_pStudioHdr == pStudioHdr ) );
// if ( nFacesOverride == -1 )
// {
// nFacesOverride = ( nLOD < m_NumLODs ) ? m_pLODs[ nLOD ].m_NumFaces : 0;
// }
// m_NumFacesRenderedThisFrame += nInstances * nFacesOverride;
// m_NumTimesRenderedThisFrame ++;
// }
// int m_NumFacesRenderedThisFrame;
// int m_NumTimesRenderedThisFrame;
// studiohdr_t *m_pStudioHdr; // There is no way to map between these inside CStudioRender, so we have to store it.
// #endif // !_CERT
// };
// ----------------------------------------------------------
// ----------------------------------------------------------
// body part index
// struct mstudiobodyparts_t
// {
// DECLARE_BYTESWAP_DATADESC();
// int sznameindex;
// inline char * const pszName( void ) const { return ((char *)this) + sznameindex; }
// int nummodels;
// int base;
// int modelindex; // index into models array
// inline mstudiomodel_t *pModel( int i ) const { return (mstudiomodel_t *)(((byte *)this) + modelindex) + i; };
// };
//
//
// struct mstudiomouth_t
// {
// DECLARE_BYTESWAP_DATADESC();
// int bone;
// Vector forward;
// int flexdesc;
//
// mstudiomouth_t(){}
// private:
// // No copy constructors allowed
// mstudiomouth_t(const mstudiomouth_t& vOther);
// };
//
// struct mstudiohitboxset_t
// {
// DECLARE_BYTESWAP_DATADESC();
// int sznameindex;
// inline char * const pszName( void ) const { return ((char *)this) + sznameindex; }
// int numhitboxes;
// int hitboxindex;
// inline mstudiobbox_t *pHitbox( int i ) const { return (mstudiobbox_t *)(((byte *)this) + hitboxindex) + i; };
// };
//-----------------------------------------------------------------------------
// Src bone transforms are transformations that will convert .dmx or .smd-based animations into .mdl-based animations
// NOTE: The operation you should apply is: pretransform * bone transform * posttransform
//-----------------------------------------------------------------------------
// struct mstudiosrcbonetransform_t
// {
// DECLARE_BYTESWAP_DATADESC();
//
// int sznameindex;
// inline const char *pszName( void ) const { return ((char *)this) + sznameindex; }
// matrix3x4_t pretransform;
// matrix3x4_t posttransform;
// };
// ----------------------------------------------------------
// Purpose: Load time results on model compositing
// ----------------------------------------------------------
class virtualgroup_t_PS3
{
public:
virtualgroup_t_PS3( void ) { cache = NULL; };
// tool dependant. In engine this is a model_t, in tool it's a direct pointer
void *cache;
// converts cache entry into a usable studiohdr_t *
// const studiohdr_t *GetStudioHdr( void ) const;
// CUtlVector< int > boneMap; // maps global bone to local bone
// CUtlVector< int > masterBone; // maps local bone to global bone
// CUtlVector< int > masterSeq; // maps local sequence to master sequence
// CUtlVector< int > masterAnim; // maps local animation to master animation
// CUtlVector< int > masterAttachment; // maps local attachment to global
// CUtlVector< int > masterPose; // maps local pose parameter to global
// CUtlVector< int > masterNode; // maps local transition nodes to global
};
struct virtualsequence_t_PS3
{
int flags;
int activity;
int group;
int index;
};
struct virtualgeneric_t_PS3
{
int group;
int index;
};
struct virtualmodel_t_PS3
{
// void AppendSequences( int group, const studiohdr_t_PS3 *pStudioHdr );
// void AppendAnimations( int group, const studiohdr_t_PS3 *pStudioHdr );
// void AppendAttachments( int ground, const studiohdr_t_PS3 *pStudioHdr );
// void AppendPoseParameters( int group, const studiohdr_t_PS3 *pStudioHdr );
// void AppendBonemap( int group, const studiohdr_t_PS3 *pStudioHdr );
// void AppendNodes( int group, const studiohdr_t_PS3 *pStudioHdr );
// void AppendTransitions( int group, const studiohdr_t_PS3 *pStudioHdr );
// void AppendIKLocks( int group, const studiohdr_t_PS3 *pStudioHdr );
// void AppendModels( int group, const studiohdr_t_PS3 *pStudioHdr );
// void UpdateAutoplaySequences( const studiohdr_t_PS3 *pStudioHdr );
// virtualgroup_t_PS3 *pAnimGroup( int animation ) { return &m_group[ m_anim[ animation ].group ]; }; // Note: user must manage mutex for this
// virtualgroup_t_PS3 *pSeqGroup( int sequence ) { return &m_group[ m_seq[ sequence ].group ]; }; // Note: user must manage mutex for this
CThreadFastMutex_PS3 m_Lock;
// CUtlVector< virtualsequence_t_PS3 > m_seq;
// CUtlVector< virtualgeneric_t_PS3 > m_anim;
// CUtlVector< virtualgeneric_t_PS3 > m_attachment;
// CUtlVector< virtualgeneric_t_PS3 > m_pose;
// CUtlVector< virtualgroup_t_PS3 > m_group;
// CUtlVector< virtualgeneric_t_PS3 > m_node;
// CUtlVector< virtualgeneric_t_PS3 > m_iklock;
// CUtlVector< unsigned short > m_autoplaySequences;
};
// 'thin' vertex data, used to do model decals (see Studio_CreateThinVertexes())
// struct thinModelVertices_t
// {
// void Init( int numBoneInfluences, Vector *positions, unsigned short *normals, float *boneWeights, byte *boneIndices )
// {
// Assert( positions != NULL );
// Assert( normals != NULL );
// Assert( ( numBoneInfluences >= 0 ) && ( numBoneInfluences <= 3 ) );
// Assert( numBoneInfluences > 0 ? !!boneIndices : !boneIndices );
// Assert( numBoneInfluences > 1 ? !!boneWeights : !boneWeights );
// m_numBoneInfluences = numBoneInfluences;
// m_vecPositions = positions;
// m_vecNormals = normals;
// m_boneWeights = boneWeights;
// m_boneIndices = boneIndices;
// }
//
// void SetPosition( int vertIndex, const Vector & position )
// {
// Assert( m_vecPositions );
// m_vecPositions[ vertIndex ] = position;
// }
//
// void SetNormal( int vertIndex, const Vector & normal )
// {
// Assert( m_vecNormals );
// unsigned int packedNormal;
// PackNormal_UBYTE4( normal.x, normal.y, normal.z, &packedNormal );
// m_vecNormals[ vertIndex ] = (unsigned short)( 0x0000FFFF & packedNormal );
// }
//
// void SetBoneWeights( int vertIndex, const mstudioboneweight_t & boneWeights )
// {
// Assert( ( m_numBoneInfluences >= 1 ) && ( m_numBoneInfluences <= 3 ) );
// Assert( ( boneWeights.numbones >= 1 ) && ( boneWeights.numbones <= m_numBoneInfluences ) );
// int numStoredWeights = MAX( 0, ( m_numBoneInfluences - 1 ) );
// float *pBaseWeight = m_boneWeights + vertIndex*numStoredWeights;
// byte *pBaseIndex = m_boneIndices + vertIndex*m_numBoneInfluences;
// for ( int i = 0; i < m_numBoneInfluences; i++ )
// {
// pBaseIndex[i] = boneWeights.bone[i];
// }
// for ( int i = 0; i < numStoredWeights; i++ )
// {
// pBaseWeight[i] = boneWeights.weight[i];
// }
// }
//
// void GetMeshPosition( mstudiomesh_t *pMesh, int meshIndex, Vector *pPosition ) const
// {
// Assert( pMesh );
// GetPosition( pMesh->vertexdata.GetGlobalVertexIndex( meshIndex ), pPosition );
// }
//
// void GetMeshNormal( mstudiomesh_t *pMesh, int meshIndex, Vector *pNormal ) const
// {
// Assert( pMesh );
// GetNormal( pMesh->vertexdata.GetGlobalVertexIndex( meshIndex ), pNormal );
// }
//
// void GetMeshBoneWeights( mstudiomesh_t *pMesh, int meshIndex, mstudioboneweight_t *pBoneWeights ) const
// {
// Assert( pMesh );
// GetBoneWeights( pMesh->vertexdata.GetGlobalVertexIndex( meshIndex ), pBoneWeights );
// }
//
// void GetModelPosition( mstudiomodel_t *pModel, int modelIndex, Vector *pPosition ) const
// {
// Assert( pModel );
// GetPosition( pModel->vertexdata.GetGlobalVertexIndex( modelIndex ), pPosition );
// }
//
// void GetModelNormal( mstudiomodel_t *pModel, int modelIndex, Vector *pNormal ) const
// {
// Assert( pModel );
// GetNormal( pModel->vertexdata.GetGlobalVertexIndex( modelIndex ), pNormal );
// }
//
// void GetModelBoneWeights( mstudiomodel_t *pModel, int modelIndex, mstudioboneweight_t *pBoneWeights ) const
// {
// Assert( pModel );
// GetBoneWeights( pModel->vertexdata.GetGlobalVertexIndex( modelIndex ), pBoneWeights );
// }
//
// private:
// void GetPosition( int vertIndex, Vector *pPosition ) const
// {
// Assert( pPosition );
// Assert( m_vecPositions );
// *pPosition = m_vecPositions[ vertIndex ];
// }
//
// void GetNormal( int vertIndex, Vector *pNormal ) const
// {
// Assert( pNormal );
// Assert( m_vecNormals );
// unsigned int packedNormal = 0x0000FFFF & m_vecNormals[ vertIndex ];
// UnpackNormal_UBYTE4( &packedNormal, pNormal->Base() );
// }
//
// void GetBoneWeights( int vertIndex, mstudioboneweight_t * RESTRICT pBoneWeights ) const
// {
// Assert( pBoneWeights );
// Assert( ( m_numBoneInfluences <= 1 ) || ( m_boneWeights != NULL ) );
// Assert( ( m_numBoneInfluences <= 0 ) || ( m_boneIndices != NULL ) );
// int numStoredWeights = MAX( 0, ( m_numBoneInfluences - 1 ) );
// float * RESTRICT pBaseWeight = m_boneWeights + vertIndex*numStoredWeights;
// byte * RESTRICT pBaseIndex = m_boneIndices + vertIndex*m_numBoneInfluences;
// float sum = 0.0f;
// // TODO: unroll this loop? It's only three. We could use a switch
// // and code it explicitly for the various possible m_numBoneInfluences
// // which would improve scheduling but bloat code.
// for (int i = 0;i < MAX_NUM_BONES_PER_VERT;i++)
// {
// float weight;
// if ( i < ( m_numBoneInfluences - 1 ) )
// {
// weight = pBaseWeight[i];
// sum += weight;
// }
// else
// {
// weight = 1.0f - sum;
// sum = 1.0f;
// }
//
// pBoneWeights->weight[i] = weight;
// pBoneWeights->bone[i] = ( i < m_numBoneInfluences ) ? pBaseIndex[i] : 0;
//
// /*
// if ( i < ( m_numBoneInfluences - 1 ) )
// pBoneWeights->weight[i] = pBaseWeight[i];
// else
// pBoneWeights->weight[i] = 1.0f - sum;
// sum += pBoneWeights->weight[i];
//
// pBoneWeights->bone[i] = ( i < m_numBoneInfluences ) ? pBaseIndex[i] : 0;
// */
// }
//
// // Treat 'zero weights' as '100% binding to bone zero':
// pBoneWeights->numbones = m_numBoneInfluences ? m_numBoneInfluences : 1;
// }
//
// int m_numBoneInfluences;// Number of bone influences per vertex, N
// float *m_boneWeights; // This array stores (N-1) weights per vertex (unless N is zero)
// byte *m_boneIndices; // This array stores N indices per vertex
// Vector *m_vecPositions;
// unsigned short *m_vecNormals; // Normals are compressed into 16 bits apiece (see PackNormal_UBYTE4() )
// };
// ----------------------------------------------------------
// Studio Model Stream Data File
// ----------------------------------------------------------
// little-endian "IDSS"
// #define MODEL_STREAM_FILE_ID (('S'<<24)+('S'<<16)+('D'<<8)+'I')
// #define MODEL_STREAM_FILE_VERSION 1
// struct vertexStreamFileHeader_t
// {
// DECLARE_BYTESWAP_DATADESC();
// int id; // MODEL_STREAM_FILE_ID
// int version; // MODEL_STREAM_FILE_VERSION
// long checksum; // same as studiohdr_t, ensures sync
// long flags; // flags
// int numVerts; // number of vertices
// int uv2StreamStart; // offset from base to uv2 stream
// int uv2ElementSize; // size of each uv2 element
// int pad; // pad
//
// public:
//
// // Accessor to uv2 stream
// const void *GetStreamUv2() const
// {
// if ( ( id == MODEL_STREAM_FILE_ID ) && ( uv2StreamStart != 0 ) )
// return ( void * ) ( uv2StreamStart + (byte *)this );
// else
// return NULL;
// }
// };
// ----------------------------------------------------------
// Studio Model Vertex Data File
// Position independent flat data for cache manager
// ----------------------------------------------------------
// little-endian "IDSV"
// #define MODEL_VERTEX_FILE_ID (('V'<<24)+('S'<<16)+('D'<<8)+'I')
// #define MODEL_VERTEX_FILE_VERSION 4
// // this id (IDCV) is used once the vertex data has been compressed (see CMDLCache::CreateThinVertexes)
// #define MODEL_VERTEX_FILE_THIN_ID (('V'<<24)+('C'<<16)+('D'<<8)+'I')
// // this id (IDDV) is used once the vertex data has been discarded (see CMDLCache::CreateNullVertexes)
// #define MODEL_VERTEX_FILE_NULL_ID (('V'<<24)+('D'<<16)+('D'<<8)+'I')
// struct vertexFileHeader_t
// {
// DECLARE_BYTESWAP_DATADESC();
// int id; // MODEL_VERTEX_FILE_ID
// int version; // MODEL_VERTEX_FILE_VERSION
// long checksum; // same as studiohdr_t, ensures sync
// int numLODs; // num of valid lods
// int numLODVertexes[MAX_NUM_LODS]; // num verts for desired root lod
// int numFixups; // num of vertexFileFixup_t
// #ifdef _PS3
// union
// {
// int fixupTableStart;
// uint32 ps3edgeDmaInputDesc; // [PS3: offset of the EDGE DMA INPUT stream]
// };
// uint32 inline GetPs3EdgeDmaInputStart() const { return ( ps3edgeDmaInputDesc & 0xFFFF ) << 8; }
// uint32 inline GetPs3EdgeDmaInputLength() const { return ( ( ps3edgeDmaInputDesc >> 16 ) & 0x7FFF ) << 8; }
// #else
// int fixupTableStart; // offset from base to fixup table
// #endif
// int vertexDataStart; // offset from base to vertex block
// int tangentDataStart; // offset from base to tangent block
//
// public:
//
// // Accessor to fat vertex data
// const mstudiovertex_t *GetVertexData() const
// {
// if ( ( id == MODEL_VERTEX_FILE_ID ) && ( vertexDataStart != 0 ) )
// return ( mstudiovertex_t * ) ( vertexDataStart + (byte *)this );
// else
// return NULL;
// }
// // Accessor to (fat) tangent vertex data (tangents aren't stored in compressed data)
// const Vector4D *GetTangentData() const
// {
// if ( ( id == MODEL_VERTEX_FILE_ID ) && ( tangentDataStart != 0 ) )
// return ( Vector4D * ) ( tangentDataStart + (byte *)this );
// else
// return NULL;
// }
// // Accessor to thin vertex data
// const thinModelVertices_t *GetThinVertexData() const
// {
// if ( ( id == MODEL_VERTEX_FILE_THIN_ID ) && ( vertexDataStart != 0 ) )
// return ( thinModelVertices_t * ) ( vertexDataStart + (byte *)this );
// else
// return NULL;
// }
//
// #ifdef _PS3
// // Accessor to EDGE DMA INPUT format
// const byte *GetPs3EdgeDmaInput() const
// {
// if ( ( id == MODEL_VERTEX_FILE_ID ) && ( ps3edgeDmaInputDesc & 0x80000000 ) )
// return ( byte * ) ( GetPs3EdgeDmaInputStart() + (byte *)this );
// else
// return NULL;
// }
// #endif
// };
//
// // model vertex data accessor (defined here so vertexFileHeader_t can be used)
// inline const mstudio_modelvertexdata_t * mstudiomodel_t::GetVertexData( void *pModelData )
// {
// const vertexFileHeader_t * pVertexHdr = CacheVertexData( pModelData );
// if ( !pVertexHdr )
// return NULL;
//
// vertexdata.pVertexData = pVertexHdr->GetVertexData();
// vertexdata.pTangentData = pVertexHdr->GetTangentData();
//
// if ( !vertexdata.pVertexData )
// return NULL;
//
// return &vertexdata;
// }
//
// // model thin vertex data accessor (defined here so vertexFileHeader_t can be used)
// inline const thinModelVertices_t * mstudiomodel_t::GetThinVertexData( void *pModelData )
// {
// const vertexFileHeader_t * pVertexHdr = CacheVertexData( pModelData );
// if ( !pVertexHdr )
// return NULL;
//
// return pVertexHdr->GetThinVertexData();
// }
//
// // apply sequentially to lod sorted vertex and tangent pools to re-establish mesh order
// struct vertexFileFixup_t
// {
// DECLARE_BYTESWAP_DATADESC();
// int lod; // used to skip culled root lod
// int sourceVertexID; // absolute index from start of vertex/tangent blocks
// int numVertexes;
// };
//
// // This flag is set if no hitbox information was specified
// #define STUDIOHDR_FLAGS_AUTOGENERATED_HITBOX ( 1 << 0 )
//
// // NOTE: This flag is set at loadtime, not mdl build time so that we don't have to rebuild
// // models when we change materials.
// #define STUDIOHDR_FLAGS_USES_ENV_CUBEMAP ( 1 << 1 )
//
// // Use this when there are translucent parts to the model but we're not going to sort it
// #define STUDIOHDR_FLAGS_FORCE_OPAQUE ( 1 << 2 )
//
// // Use this when we want to render the opaque parts during the opaque pass
// // and the translucent parts during the translucent pass
// #define STUDIOHDR_FLAGS_TRANSLUCENT_TWOPASS ( 1 << 3 )
//
// // This is set any time the .qc files has $staticprop in it
// // Means there's no bones and no transforms
// #define STUDIOHDR_FLAGS_STATIC_PROP ( 1 << 4 )
//
// // NOTE: This flag is set at loadtime, not mdl build time so that we don't have to rebuild
// // models when we change materials.
// #define STUDIOHDR_FLAGS_USES_FB_TEXTURE ( 1 << 5 )
//
// // This flag is set by studiomdl.exe if a separate "$shadowlod" entry was present
// // for the .mdl (the shadow lod is the last entry in the lod list if present)
// #define STUDIOHDR_FLAGS_HASSHADOWLOD ( 1 << 6 )
//
// // NOTE: This flag is set at loadtime, not mdl build time so that we don't have to rebuild
// // models when we change materials.
// #define STUDIOHDR_FLAGS_USES_BUMPMAPPING ( 1 << 7 )
//
// // NOTE: This flag is set when we should use the actual materials on the shadow LOD
// // instead of overriding them with the default one (necessary for translucent shadows)
// #define STUDIOHDR_FLAGS_USE_SHADOWLOD_MATERIALS ( 1 << 8 )
//
// // NOTE: This flag is set when we should use the actual materials on the shadow LOD
// // instead of overriding them with the default one (necessary for translucent shadows)
// #define STUDIOHDR_FLAGS_OBSOLETE ( 1 << 9 )
//
// #define STUDIOHDR_FLAGS_UNUSED ( 1 << 10 )
//
// // NOTE: This flag is set at mdl build time
// #define STUDIOHDR_FLAGS_NO_FORCED_FADE ( 1 << 11 )
//
// // NOTE: The npc will lengthen the viseme check to always include two phonemes
// #define STUDIOHDR_FLAGS_FORCE_PHONEME_CROSSFADE ( 1 << 12 )
//
// // This flag is set when the .qc has $constantdirectionallight in it
// // If set, we use constantdirectionallightdot to calculate light intensity
// // rather than the normal directional dot product
// // only valid if STUDIOHDR_FLAGS_STATIC_PROP is also set
// #define STUDIOHDR_FLAGS_CONSTANT_DIRECTIONAL_LIGHT_DOT ( 1 << 13 )
//
// // Flag to mark delta flexes as already converted from disk format to memory format
// #define STUDIOHDR_FLAGS_FLEXES_CONVERTED ( 1 << 14 )
//
// // Indicates the studiomdl was built in preview mode
// #define STUDIOHDR_FLAGS_BUILT_IN_PREVIEW_MODE ( 1 << 15 )
//
// // Ambient boost (runtime flag)
// #define STUDIOHDR_FLAGS_AMBIENT_BOOST ( 1 << 16 )
//
// // Don't cast shadows from this model (useful on first-person models)
// #define STUDIOHDR_FLAGS_DO_NOT_CAST_SHADOWS ( 1 << 17 )
//
// // alpha textures should cast shadows in vrad on this model (ONLY prop_static!)
// #define STUDIOHDR_FLAGS_CAST_TEXTURE_SHADOWS ( 1 << 18 )
//
// // Model has a quad-only Catmull-Clark SubD cage
// #define STUDIOHDR_FLAGS_SUBDIVISION_SURFACE ( 1 << 19 )
//
// // flagged on load to indicate no animation events on this model
// #define STUDIOHDR_FLAGS_NO_ANIM_EVENTS ( 1 << 20 )
//
// // If flag is set then studiohdr_t.flVertAnimFixedPointScale contains the
// // scale value for fixed point vert anim data, if not set then the
// // scale value is the default of 1.0 / 4096.0. Regardless use
// // studiohdr_t::VertAnimFixedPointScale() to always retrieve the scale value
// #define STUDIOHDR_FLAGS_VERT_ANIM_FIXED_POINT_SCALE ( 1 << 21 )
//
// // If flag is set then model data is processed for EDGE
// // the flag is set at tool time when producing PS3-format assets
// #define STUDIOHDR_FLAGS_PS3_EDGE_FORMAT ( 1 << 22 )
// NOTE! Next time we up the .mdl file format, remove studiohdr2_t
// and insert all fields in this structure into studiohdr_t.
struct studiohdr2_t_PS3
{
// NOTE: For forward compat, make sure any methods in this struct
// are also available in studiohdr_t so no leaf code ever directly references
// a studiohdr2_t structure
// DECLARE_BYTESWAP_DATADESC();
int numsrcbonetransform;
int srcbonetransformindex;
int illumpositionattachmentindex;
// inline int IllumPositionAttachmentIndex() const { return illumpositionattachmentindex; }
float flMaxEyeDeflection;
// inline float MaxEyeDeflection() const { return flMaxEyeDeflection != 0.0f ? flMaxEyeDeflection : 0.866f; } // default to cos(30) if not set
int linearboneindex;
// inline mstudiolinearbone_t *pLinearBones() const { return (linearboneindex) ? (mstudiolinearbone_t *)(((byte *)this) + linearboneindex) : NULL; }
int sznameindex;
// inline char *pszName() { return (sznameindex) ? (char *)(((byte *)this) + sznameindex ) : NULL; }
int m_nBoneFlexDriverCount;
int m_nBoneFlexDriverIndex;
// inline mstudioboneflexdriver_t *pBoneFlexDriver( int i ) const { Assert( i >= 0 && i < m_nBoneFlexDriverCount ); return (mstudioboneflexdriver_t *)(((byte *)this) + m_nBoneFlexDriverIndex) + i; }
int reserved[56];
};
struct studiohdr_t_PS3
{
// DECLARE_BYTESWAP_DATADESC();
int id;
int version;
long checksum; // this has to be the same in the phy and vtx files to load!
// inline const char * pszName( void ) const { if (studiohdr2index && pStudioHdr2()->pszName()) return pStudioHdr2()->pszName(); else return name; }
char name[64];
int length;
Vector eyeposition; // ideal eye position
Vector illumposition; // illumination center
Vector hull_min; // ideal movement hull size
Vector hull_max;
Vector view_bbmin; // clipping bounding box
Vector view_bbmax;
int flags;
int numbones; // bones
int boneindex;
// inline mstudiobone_t *pBone( int i ) const { Assert( i >= 0 && i < numbones); return (mstudiobone_t *)(((byte *)this) + boneindex) + i; };
// int RemapSeqBone( int iSequence, int iLocalBone ) const; // maps local sequence bone to global bone
// int RemapAnimBone( int iAnim, int iLocalBone ) const; // maps local animations bone to global bone
int numbonecontrollers; // bone controllers
int bonecontrollerindex;
// inline mstudiobonecontroller_t *pBonecontroller( int i ) const { Assert( i >= 0 && i < numbonecontrollers); return (mstudiobonecontroller_t *)(((byte *)this) + bonecontrollerindex) + i; };
int numhitboxsets;
int hitboxsetindex;
// Look up hitbox set by index
// mstudiohitboxset_t *pHitboxSet( int i ) const
// {
// Assert( i >= 0 && i < numhitboxsets);
// return (mstudiohitboxset_t *)(((byte *)this) + hitboxsetindex ) + i;
// };
// Calls through to hitbox to determine size of specified set
// inline mstudiobbox_t *pHitbox( int i, int set ) const
// {
// mstudiohitboxset_t const *s = pHitboxSet( set );
// if ( !s )
// return NULL;
//
// return s->pHitbox( i );
// };
// Calls through to set to get hitbox count for set
// inline int iHitboxCount( int set ) const
// {
// mstudiohitboxset_t const *s = pHitboxSet( set );
// if ( !s )
// return 0;
//
// return s->numhitboxes;
// };
// file local animations? and sequences
//private:
int numlocalanim; // animations/poses
int localanimindex; // animation descriptions
// inline mstudioanimdesc_t *pLocalAnimdesc( int i ) const { if (i < 0 || i >= numlocalanim) i = 0; return (mstudioanimdesc_t *)(((byte *)this) + localanimindex) + i; };
int numlocalseq; // sequences
int localseqindex;
// inline mstudioseqdesc_t_PS3 *pLocalSeqdesc_PS3( int i ) const { if (i < 0 || i >= numlocalseq) i = 0; return (mstudioseqdesc_t_PS3 *)(((byte *)this) + localseqindex) + i; };
//public:
// bool SequencesAvailable() const;
// int GetNumSeq_Internal() const;
// inline int GetNumSeq() const
// {
// if (numincludemodels == 0)
// {
// return numlocalseq;
// }
// return GetNumSeq_Internal();
//
// }
// mstudioanimdesc_t &pAnimdesc_Internal( int i ) const;
// inline mstudioanimdesc_t &pAnimdesc( int i ) const
// {
// if (numincludemodels == 0)
// {
// return *pLocalAnimdesc( i );
// }
//
// return pAnimdesc_Internal( i );
// }
//
// mstudioseqdesc_t &pSeqdesc_Internal( int i ) const;
// inline mstudioseqdesc_t &pSeqdesc( int i ) const
// {
// if (numincludemodels == 0)
// {
// return *pLocalSeqdesc( i );
// }
// return pSeqdesc_Internal( i );
// }
// int iRelativeAnim_Internal( int baseseq, int relanim ) const; // maps seq local anim reference to global anim index
// inline int iRelativeAnim( int baseseq, int relanim ) const
// {
// if ( numincludemodels == 0 )
// return relanim;
// return iRelativeAnim_Internal( baseseq, relanim );
// }
// int iRelativeSeq_Internal( int baseseq, int relseq ) const; // maps seq local seq reference to global seq index
// inline int iRelativeSeq( int baseseq, int relseq ) const
// {
// if (numincludemodels == 0)
// {
// return relseq;
// }
// return iRelativeSeq_Internal( baseseq, relseq );
// }
//private:
mutable int activitylistversion; // initialization flag - have the sequences been indexed?
mutable int eventsindexed;
//public:
// int GetSequenceActivity( int iSequence );
// void SetSequenceActivity( int iSequence, int iActivity );
// int GetActivityListVersion( void );
// void SetActivityListVersion( int version ) const;
// int GetEventListVersion( void );
// void SetEventListVersion( int version );
// raw textures
int numtextures;
int textureindex;
// inline mstudiotexture_t *pTexture( int i ) const { Assert( i >= 0 && i < numtextures ); return (mstudiotexture_t *)(((byte *)this) + textureindex) + i; };
// raw textures search paths
int numcdtextures;
int cdtextureindex;
// inline char *pCdtexture( int i ) const { return (((char *)this) + *((int *)(((byte *)this) + cdtextureindex) + i)); };
// replaceable textures tables
int numskinref;
int numskinfamilies;
int skinindex;
// inline short *pSkinref( int i ) const { return (short *)(((byte *)this) + skinindex) + i; };
int numbodyparts;
int bodypartindex;
// inline mstudiobodyparts_t *pBodypart( int i ) const { return (mstudiobodyparts_t *)(((byte *)this) + bodypartindex) + i; };
// queryable attachable points
//private:
int numlocalattachments;
int localattachmentindex;
// inline mstudioattachment_t *pLocalAttachment( int i ) const { Assert( i >= 0 && i < numlocalattachments); return (mstudioattachment_t *)(((byte *)this) + localattachmentindex) + i; };
////public:
// int GetNumAttachments( void ) const;
// const mstudioattachment_t &pAttachment( int i ) const;
// int GetAttachmentBone( int i );
// used on my tools in hlmv, not persistant
// void SetAttachmentBone( int iAttachment, int iBone );
// animation node to animation node transition graph
//private:
int numlocalnodes;
int localnodeindex;
int localnodenameindex;
// inline char *pszLocalNodeName( int iNode ) const { Assert( iNode >= 0 && iNode < numlocalnodes); return (((char *)this) + *((int *)(((byte *)this) + localnodenameindex) + iNode)); }
// inline byte *pLocalTransition( int i ) const { Assert( i >= 0 && i < (numlocalnodes * numlocalnodes)); return (byte *)(((byte *)this) + localnodeindex) + i; };
//// public:
// int EntryNode( int iSequence );
// int ExitNode( int iSequence );
// char *pszNodeName( int iNode );
// int GetTransition( int iFrom, int iTo ) const;
int numflexdesc;
int flexdescindex;
// inline mstudioflexdesc_t *pFlexdesc( int i ) const { Assert( i >= 0 && i < numflexdesc); return (mstudioflexdesc_t *)(((byte *)this) + flexdescindex) + i; };
int numflexcontrollers;
int flexcontrollerindex;
// inline mstudioflexcontroller_t *pFlexcontroller( LocalFlexController_t i ) const { Assert( i >= 0 && i < numflexcontrollers); return (mstudioflexcontroller_t *)(((byte *)this) + flexcontrollerindex) + i; };
int numflexrules;
int flexruleindex;
// inline mstudioflexrule_t *pFlexRule( int i ) const { Assert( i >= 0 && i < numflexrules); return (mstudioflexrule_t *)(((byte *)this) + flexruleindex) + i; };
int numikchains;
int ikchainindex;
// inline mstudioikchain_t *pIKChain( int i ) const { Assert( i >= 0 && i < numikchains); return (mstudioikchain_t *)(((byte *)this) + ikchainindex) + i; };
int nummouths;
int mouthindex;
// inline mstudiomouth_t *pMouth( int i ) const { Assert( i >= 0 && i < nummouths); return (mstudiomouth_t *)(((byte *)this) + mouthindex) + i; };
//private:
int numlocalposeparameters;
int localposeparamindex;
// inline mstudioposeparamdesc_t *pLocalPoseParameter( int i ) const { Assert( i >= 0 && i < numlocalposeparameters); return (mstudioposeparamdesc_t *)(((byte *)this) + localposeparamindex) + i; };
////public:
// int GetNumPoseParameters( void ) const;
// const mstudioposeparamdesc_t &pPoseParameter( int i );
// int GetSharedPoseParameter( int iSequence, int iLocalPose ) const;
int surfacepropindex;
// inline char * const pszSurfaceProp( void ) const { return ((char *)this) + surfacepropindex; }
// inline int GetSurfaceProp() const { return surfacepropLookup; }
// Key values
int keyvalueindex;
int keyvaluesize;
// inline const char * KeyValueText( void ) const { return keyvaluesize != 0 ? ((char *)this) + keyvalueindex : NULL; }
int numlocalikautoplaylocks;
int localikautoplaylockindex;
// inline mstudioiklock_t *pLocalIKAutoplayLock( int i ) const { Assert( i >= 0 && i < numlocalikautoplaylocks); return (mstudioiklock_t *)(((byte *)this) + localikautoplaylockindex) + i; };
// int GetNumIKAutoplayLocks( void ) const;
// const mstudioiklock_t &pIKAutoplayLock( int i );
// int CountAutoplaySequences() const;
// int CopyAutoplaySequences( unsigned short *pOut, int outCount ) const;
// int GetAutoplayList( unsigned short **pOut ) const;
// The collision model mass that jay wanted
float mass;
int contents;
// external animations, models, etc.
int numincludemodels;
int includemodelindex;
// inline mstudiomodelgroup_t *pModelGroup( int i ) const { Assert( i >= 0 && i < numincludemodels); return (mstudiomodelgroup_t *)(((byte *)this) + includemodelindex) + i; };
// implementation specific call to get a named model
// const studiohdr_t *FindModel( void **cache, char const *modelname ) const;
// implementation specific back pointer to virtual data
mutable void *virtualModel;
// virtualmodel_t *GetVirtualModel( void ) const;
// for demand loaded animation blocks
int szanimblocknameindex;
// inline char * const pszAnimBlockName( void ) const { return ((char *)this) + szanimblocknameindex; }
int numanimblocks;
int animblockindex;
// inline mstudioanimblock_t *pAnimBlock( int i ) const { Assert( i > 0 && i < numanimblocks); return (mstudioanimblock_t *)(((byte *)this) + animblockindex) + i; };
mutable void *animblockModel;
// byte * GetAnimBlock( int i, bool preloadIfMissing = true ) const;
// bool hasAnimBlockBeenPreloaded( int i ) const;
int bonetablebynameindex;
// inline const byte *GetBoneTableSortedByName() const { return (byte *)this + bonetablebynameindex; }
// used by tools only that don't cache, but persist mdl's peer data
// engine uses virtualModel to back link to cache pointers
void *pVertexBase;
void *pIndexBase;
// if STUDIOHDR_FLAGS_CONSTANT_DIRECTIONAL_LIGHT_DOT is set,
// this value is used to calculate directional components of lighting
// on static props
byte constdirectionallightdot;
// set during load of mdl data to track *desired* lod configuration (not actual)
// the *actual* clamped root lod is found in studiohwdata
// this is stored here as a global store to ensure the staged loading matches the rendering
byte rootLOD;
// set in the mdl data to specify that lod configuration should only allow first numAllowRootLODs
// to be set as root LOD:
// numAllowedRootLODs = 0 means no restriction, any lod can be set as root lod.
// numAllowedRootLODs = N means that lod0 - lod(N-1) can be set as root lod, but not lodN or lower.
byte numAllowedRootLODs;
byte unused[1];
int unused4; // zero out if version < 47
int numflexcontrollerui;
int flexcontrolleruiindex;
// mstudioflexcontrollerui_t *pFlexControllerUI( int i ) const { Assert( i >= 0 && i < numflexcontrollerui); return (mstudioflexcontrollerui_t *)(((byte *)this) + flexcontrolleruiindex) + i; }
float flVertAnimFixedPointScale;
// inline float VertAnimFixedPointScale() const { return ( flags & STUDIOHDR_FLAGS_VERT_ANIM_FIXED_POINT_SCALE ) ? flVertAnimFixedPointScale : 1.0f / 4096.0f; }
mutable int surfacepropLookup; // this index must be cached by the loader, not saved in the file
// FIXME: Remove when we up the model version. Move all fields of studiohdr2_t into studiohdr_t.
int studiohdr2index;
// studiohdr2_t* pStudioHdr2() const { return (studiohdr2_t *)( ( (byte *)this ) + studiohdr2index ); }
// Src bone transforms are transformations that will convert .dmx or .smd-based animations into .mdl-based animations
// int NumSrcBoneTransforms() const { return studiohdr2index ? pStudioHdr2()->numsrcbonetransform : 0; }
// const mstudiosrcbonetransform_t* SrcBoneTransform( int i ) const { Assert( i >= 0 && i < NumSrcBoneTransforms()); return (mstudiosrcbonetransform_t *)(((byte *)this) + pStudioHdr2()->srcbonetransformindex) + i; }
// inline int IllumPositionAttachmentIndex() const { return studiohdr2index ? pStudioHdr2()->IllumPositionAttachmentIndex() : 0; }
// inline float MaxEyeDeflection() const { return studiohdr2index ? pStudioHdr2()->MaxEyeDeflection() : 0.866f; } // default to cos(30) if not set
// inline mstudiolinearbone_t *pLinearBones() const { return studiohdr2index ? pStudioHdr2()->pLinearBones() : NULL; }
// inline int BoneFlexDriverCount() const { return studiohdr2index ? pStudioHdr2()->m_nBoneFlexDriverCount : 0; }
// inline const mstudioboneflexdriver_t* BoneFlexDriver( int i ) const { Assert( i >= 0 && i < BoneFlexDriverCount() ); return studiohdr2index ? pStudioHdr2()->pBoneFlexDriver( i ) : NULL; }
// NOTE: No room to add stuff? Up the .mdl file format version
// [and move all fields in studiohdr2_t into studiohdr_t and kill studiohdr2_t],
// or add your stuff to studiohdr2_t. See NumSrcBoneTransforms/SrcBoneTransform for the pattern to use.
int unused2[1];
studiohdr_t_PS3() {}
private:
// No copy constructors allowed
studiohdr_t_PS3(const studiohdr_t_PS3& vOther);
friend struct virtualmodel_t_PS3;
};
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
//class IDataCache_PS3;
//class IMDLCache_PS3;
// class CStudioHdr_PS3
// {
// public:
// CStudioHdr_PS3( void );
// CStudioHdr_PS3( const studiohdr_t_PS3 *pStudioHdr, IMDLCache_PS3 *mdlcache = NULL );
// ~CStudioHdr_PS3() { /*Term();*/ m_pActivityToSequence = NULL; }
// void Init( const studiohdr_t_PS3 *pStudioHdr, IMDLCache_PS3 *mdlcache = NULL );
// void Term();
// public:
// inline bool IsVirtual( void ) { return (m_pVModel != NULL); };
// inline bool IsValid( void ) { return (m_pStudioHdr != NULL); };
// inline bool IsReadyForAccess( void ) const { return (m_pStudioHdr != NULL); };
// inline virtualmodel_t *GetVirtualModel( void ) const { return m_pVModel; };
// inline const studiohdr_t *GetRenderHdr( void ) const { return m_pStudioHdr; };
// const studiohdr_t *pSeqStudioHdr( int sequence );
// const studiohdr_t *pAnimStudioHdr( int animation );
// private:
// mutable const studiohdr_t *m_pStudioHdr;
// mutable virtualmodel_t *m_pVModel;
// const virtualmodel_t * ResetVModel( const virtualmodel_t *pVModel ) const;
// const studiohdr_t *GroupStudioHdr( int group );
// mutable CUtlVector< const studiohdr_t_PS3 * > m_pStudioHdrCache;
//
// mutable int m_nFrameUnlockCounter;
// int * m_pFrameUnlockCounter;
// CThreadFastMutex_PS3 m_FrameUnlockCounterMutex;
// public:
// inline int numbones( void ) const { return m_pStudioHdr->numbones; };
// inline mstudiobone_t *pBone( int i ) const { return m_pStudioHdr->pBone( i ); };
// int RemapAnimBone( int iAnim, int iLocalBone ) const; // maps local animations bone to global bone
// int RemapSeqBone( int iSequence, int iLocalBone ) const; // maps local sequence bone to global bone
// bool SequencesAvailable() const;
// int GetNumSeq_Internal( void ) const;
// inline int GetNumSeq( void ) const
// {
// if ( !m_pVModel )
// return m_pStudioHdr->numlocalseq;
// return GetNumSeq_Internal();
// }
// mstudioanimdesc_t &pAnimdesc_Internal( int i );
// inline mstudioanimdesc_t &pAnimdesc( int i )
// {
// if ( !m_pVModel )
// return *m_pStudioHdr->pLocalAnimdesc( i );
// return pAnimdesc_Internal( i );
// }
// mstudioseqdesc_t_PS3 &pSeqdesc_Internal_PS3( int iSequence );
// inline mstudioseqdesc_t_PS3 &pSeqdesc_PS3( int iSequence )
// {
// if ( !m_pVModel )
// return *m_pStudioHdr->pLocalSeqdesc_PS3( iSequence );
//
// return pSeqdesc_Internal_PS3( iSequence );
// }
// int iRelativeAnim_Internal( int baseseq, int relanim ) const; // maps seq local anim reference to global anim index
// inline int iRelativeAnim( int baseseq, int relanim ) const
// {
// if ( !m_pVModel )
// return relanim;
// return iRelativeAnim_Internal( baseseq, relanim );
// }
// int iRelativeSeq( int baseseq, int relseq ) const; // maps seq local seq reference to global seq index
// int GetSequenceActivity( int iSequence );
// void SetSequenceActivity( int iSequence, int iActivity );
// int GetActivityListVersion( void );
// void SetActivityListVersion( int version );
// int GetEventListVersion( void );
// void SetEventListVersion( int version );
// int GetNumAttachments( void ) const;
// const mstudioattachment_t &pAttachment( int i );
// int GetAttachmentBone( int i );
// used on my tools in hlmv, not persistant
// void SetAttachmentBone( int iAttachment, int iBone );
// int EntryNode( int iSequence );
// int ExitNode( int iSequence );
// char *pszNodeName( int iNode );
// FIXME: where should this one be?
// int GetTransition( int iFrom, int iTo ) const;
// int GetNumPoseParameters( void ) const;
// const mstudioposeparamdesc_t &pPoseParameter( int i );
// int GetSharedPoseParameter( int iSequence, int iLocalPose ) const;
// int GetNumIKAutoplayLocks( void ) const;
// const mstudioiklock_t &pIKAutoplayLock( int i );
// inline int CountAutoplaySequences() const { return m_pStudioHdr->CountAutoplaySequences(); };
// inline int CopyAutoplaySequences( unsigned short *pOut, int outCount ) const { return m_pStudioHdr->CopyAutoplaySequences( pOut, outCount ); };
// inline int GetAutoplayList( unsigned short **pOut ) const { return m_pStudioHdr->GetAutoplayList( pOut ); };
// inline int GetNumBoneControllers( void ) const { return m_pStudioHdr->numbonecontrollers; };
// inline mstudiobonecontroller_t *pBonecontroller( int i ) const { return m_pStudioHdr->pBonecontroller( i ); };
// inline int numikchains() const { return m_pStudioHdr->numikchains; };
// inline int GetNumIKChains( void ) const { return m_pStudioHdr->numikchains; };
// inline mstudioikchain_t *pIKChain( int i ) const { return m_pStudioHdr->pIKChain( i ); };
// inline int numflexrules() const { return m_pStudioHdr->numflexrules; };
// inline mstudioflexrule_t *pFlexRule( int i ) const { return m_pStudioHdr->pFlexRule( i ); };
// inline int numflexdesc() const{ return m_pStudioHdr->numflexdesc; };
// inline mstudioflexdesc_t *pFlexdesc( int i ) const { return m_pStudioHdr->pFlexdesc( i ); };
// inline LocalFlexController_t numflexcontrollers() const{ return (LocalFlexController_t)m_pStudioHdr->numflexcontrollers; };
// inline mstudioflexcontroller_t *pFlexcontroller( LocalFlexController_t i ) const { return m_pStudioHdr->pFlexcontroller( i ); };
// inline int numflexcontrollerui() const{ return m_pStudioHdr->numflexcontrollerui; };
// inline mstudioflexcontrollerui_t *pFlexcontrollerUI( int i ) const { return m_pStudioHdr->pFlexControllerUI( i ); };
// inline const char *name() const { return m_pStudioHdr->pszName(); }; // deprecated -- remove after full xbox merge
// inline const char *pszName() const { return m_pStudioHdr->pszName(); };
// inline int numbonecontrollers() const { return m_pStudioHdr->numbonecontrollers; };
// inline int numhitboxsets() const { return m_pStudioHdr->numhitboxsets; };
// inline mstudiohitboxset_t *pHitboxSet( int i ) const { return m_pStudioHdr->pHitboxSet( i ); };
// inline mstudiobbox_t *pHitbox( int i, int set ) const { return m_pStudioHdr->pHitbox( i, set ); };
// inline int iHitboxCount( int set ) const { return m_pStudioHdr->iHitboxCount( set ); };
// inline int numbodyparts() const { return m_pStudioHdr->numbodyparts; };
// inline mstudiobodyparts_t *pBodypart( int i ) const { return m_pStudioHdr->pBodypart( i ); };
// inline int numskinfamilies() const { return m_pStudioHdr->numskinfamilies; }
// inline Vector eyeposition() const { return m_pStudioHdr->eyeposition; };
// inline int flags() const { return m_pStudioHdr->flags; };
// inline char *const pszSurfaceProp( void ) const { return m_pStudioHdr->pszSurfaceProp(); };
// inline int GetSurfaceProp()const { return m_pStudioHdr->surfacepropLookup; }
// inline float mass() const { return m_pStudioHdr->mass; };
// inline int contents() const { return m_pStudioHdr->contents; }
// inline const byte *GetBoneTableSortedByName() const { return m_pStudioHdr->GetBoneTableSortedByName(); };
// inline Vector illumposition() const { return m_pStudioHdr->illumposition; };
// inline Vector hull_min() const { return m_pStudioHdr->hull_min; }; // ideal movement hull size
// inline Vector hull_max() const { return m_pStudioHdr->hull_max; };
// inline Vector view_bbmin() const { return m_pStudioHdr->view_bbmin; }; // clipping bounding box
// inline Vector view_bbmax() const { return m_pStudioHdr->view_bbmax; };
// inline int numtextures() const { return m_pStudioHdr->numtextures; };
// inline int IllumPositionAttachmentIndex() const { return m_pStudioHdr->IllumPositionAttachmentIndex(); }
// inline float MaxEyeDeflection() const { return m_pStudioHdr->MaxEyeDeflection(); }
// inline mstudiolinearbone_t *pLinearBones() const { return m_pStudioHdr->pLinearBones(); }
// inline int BoneFlexDriverCount() const { return m_pStudioHdr->BoneFlexDriverCount(); }
// inline const mstudioboneflexdriver_t *BoneFlexDriver( int i ) const { return m_pStudioHdr->BoneFlexDriver( i ); }
// public:
// int IsSequenceLooping( int iSequence );
// float GetSequenceCycleRate( int iSequence );
// void RunFlexRules( const float *src, float *dest );
// void RunFlexRulesOld( const float *src, float *dest );
// void RunFlexRulesNew( const float *src, float *dest );
// public:
// inline int boneFlags( int iBone ) const { return m_boneFlags[ iBone ]; }
// inline void setBoneFlags( int iBone, int flags ) { m_boneFlags[ iBone ] |= flags; }
// inline void clearBoneFlags( int iBone, int flags ) { m_boneFlags[ iBone ] &= ~flags; }
// inline int boneParent( int iBone ) const { return m_boneParent[ iBone ]; }
// private:
// CUtlVector< int > m_boneFlags;
// CUtlVector< int > m_boneParent;
// public:
// This class maps an activity to sequences allowed for that activity, accelerating the resolution
// of SelectWeightedSequence(), especially on PowerPC. Iterating through every sequence
// attached to a model turned out to be a very destructive cache access pattern on 360.
//
// I've encapsulated this behavior inside a nested class for organizational reasons; there is
// no particular programmatic or efficiency benefit to it. It just makes clearer what particular
// code in the otherwise very complicated StudioHdr class has to do with this particular
// optimization, and it lets you collapse the whole definition down to a single line in Visual
// Studio.
// class CActivityToSequenceMapping_PS3 /* final */
// {
// public:
// // A tuple of a sequence and its corresponding weight. Lists of these correspond to activities.
// struct SequenceTuple_PS3
// {
// short seqnum;
// short weight; // the absolute value of the weight from the sequence header
// CUtlSymbol *pActivityModifiers; // list of activity modifier symbols
// int iNumActivityModifiers;
// };
// The type of the hash's stored data, a composite of both key and value
// (because that's how CUtlHash works):
// key: an int, the activity #
// values: an index into the m_pSequenceTuples array, a count of the
// total sequences present for an activity, and the sum of their
// weights.
// Note this struct is 128-bits wide, exactly coincident to a PowerPC
// cache line and VMX register. Please consider very carefully the
// performance implications before adding any additional fields to this.
// You could probably do away with totalWeight if you really had to.
// struct HashValueType_PS3
// {
// // KEY (hashed)
// int activityIdx;
//
// // VALUE (not hashed)
// int startingIdx;
// int count;
// int totalWeight;
// HashValueType(int _actIdx, int _stIdx, int _ct, int _tW) :
// activityIdx(_actIdx), startingIdx(_stIdx), count(_ct), totalWeight(_tW) {}
// default constructor (ought not to be actually used)
// HashValueType() : activityIdx(-1), startingIdx(-1), count(-1), totalWeight(-1)
// { AssertMsg(false, "Don't use default HashValueType()!"); }
// class HashFuncs_PS3
// {
// public:
// // dummy constructor (gndn)
// HashFuncs_PS3( int ) {}
// COMPARE
// compare two entries for uniqueness. We should never have two different
// entries for the same activity, so we only compare the activity index;
// this allows us to use the utlhash as a dict by constructing dummy entries
// as hash lookup keys.
// bool operator()( const HashValueType &lhs, const HashValueType &rhs ) const
// {
// return lhs.activityIdx == rhs.activityIdx;
// }
// HASH
// We only hash on the activity index; everything else is data.
// unsigned int operator()( const HashValueType &item ) const
// {
// return HashInt( item.activityIdx );
// }
// };
// };
// typedef CUtlHash<HashValueType_PS3, HashValueType_PS3::HashFuncs_PS3, HashValueType_PS3::HashFuncs_PS3> ActivityToValueIdxHash_PS3;
// These must be here because IFM does not compile/link studio.cpp (?!?)
// ctor
// CActivityToSequenceMapping( void )
// : m_pSequenceTuples(NULL), m_iSequenceTuplesCount(0), m_ActToSeqHash(8,0,0), m_expectedVModel(NULL), m_pStudioHdr(NULL)
// {};
// dtor -- not virtual because this class has no inheritors
// ~CActivityToSequenceMapping()
// {
// if ( m_pSequenceTuples != NULL )
// {
// if ( m_pSequenceTuples->pActivityModifiers != NULL )
// {
// delete[] m_pSequenceTuples->pActivityModifiers;
// }
// delete[] m_pSequenceTuples;
// }
// }
/// Get the list of sequences for an activity. Returns the pointer to the
/// first sequence tuple. Output parameters are a count of sequences present,
/// and the total weight of all the sequences. (it would be more LHS-friendly
/// to return these on registers, if only C++ offered more than one return
/// value....)
// const SequenceTuple *GetSequences( int forActivity, int *outSequenceCount, int *outTotalWeight );
/// The number of sequences available for an activity.
// int NumSequencesForActivity( int forActivity );
// static CActivityToSequenceMapping *FindMapping( const CStudioHdr *pstudiohdr );
// static void ReleaseMapping( CActivityToSequenceMapping *pMap );
// static void ResetMappings();
// private:
/// Allocate my internal array. (It is freed in the destructor.) Also,
/// build the hash of activities to sequences and populate m_pSequenceTuples.
// void Initialize( const CStudioHdr *pstudiohdr );
/// Force Initialize() to occur again, even if it has already occured.
// void Reinitialize( CStudioHdr *pstudiohdr );
/// A more efficient version of the old SelectWeightedSequence() function in animation.cpp.
// int SelectWeightedSequence( CStudioHdr *pstudiohdr, int activity, int curSequence );
// selects the sequence with the most matching modifiers
// int SelectWeightedSequenceFromModifiers( CStudioHdr *pstudiohdr, int activity, CUtlSymbol *pActivityModifiers, int iModifierCount );
// Actually a big array, into which the hash values index.
// SequenceTuple_PS3 *m_pSequenceTuples;
// unsigned int m_iSequenceTuplesCount; // (size of the whole array)
// we don't store an outer pointer because we can't initialize it at construction time
// (warning c4355) -- there are ways around this but it's easier to just pass in a
// pointer to the CStudioHdr when we need it, since this class isn't supposed to
// export its interface outside the studio header anyway.
// CStudioHdr * const m_pOuter;
// ActivityToValueIdxHash_PS3 m_ActToSeqHash;
//
// const studiohdr_t_PS3 *m_pStudioHdr;
// we store these so we can know if the contents of the studiohdr have changed
// from underneath our feet (this is an emergency data integrity check)
// const void *m_expectedVModel;
// double-check that the data I point to hasn't changed
// bool ValidateAgainst( const CStudioHdr * RESTRICT pstudiohdr ) RESTRICT;
// void SetValidation( const CStudioHdr *RESTRICT pstudiohdr ) RESTRICT;
// friend class CStudioHdr_PS3;
// };
// CActivityToSequenceMapping_PS3 *m_pActivityToSequence;
// void InitActivityToSequence()
// {
// if ( !m_pActivityToSequence )
// {
// m_pActivityToSequence = CActivityToSequenceMapping::FindMapping( this );
// }
// }
/// A more efficient version of the old SelectWeightedSequence() function in animation.cpp.
/// Returns -1 on failure to find a sequence
// inline int SelectWeightedSequence( int activity, int curSequence )
// {
// InitActivityToSequence();
// return m_pActivityToSequence->SelectWeightedSequence( this, activity, curSequence );
// }
// inline int SelectWeightedSequenceFromModifiers( int activity, CUtlSymbol *pActivityModifiers, int iModifierCount )
// {
// InitActivityToSequence();
// return m_pActivityToSequence->SelectWeightedSequenceFromModifiers( this, activity, pActivityModifiers, iModifierCount );
// }
/// True iff there is at least one sequence for the given activity.
// inline bool HaveSequenceForActivity( int activity )
// {
// InitActivityToSequence();
// return (m_pActivityToSequence->NumSequencesForActivity( activity ) > 0);
// }
// Force this CStudioHdr's activity-to-sequence mapping to be reinitialized
// inline void ReinitializeSequenceMapping(void)
// {
// if ( m_pActivityToSequence )
// {
// CActivityToSequenceMapping::ReleaseMapping( m_pActivityToSequence );
// m_pActivityToSequence = NULL;
// }
// m_pActivityToSequence = CActivityToSequenceMapping::FindMapping( this );
// }
// #ifdef STUDIO_ENABLE_PERF_COUNTERS
// public:
// inline void ClearPerfCounters_PS3( void )
// {
// m_nPerfAnimatedBones = 0;
// m_nPerfUsedBones = 0;
// m_nPerfAnimationLayers = 0;
// };
//
// // timing info
// mutable int m_nPerfAnimatedBones;
// mutable int m_nPerfUsedBones;
// mutable int m_nPerfAnimationLayers;
// #endif
// };
/*
class CModelAccess
{
public:
CModelAccess(CStudioHdr *pSemaphore)
: m_pStudioHdr(pSemaphore)
{
m_pStudioHdr->IncrementAccess();
}
~CModelAccess()
{
m_pStudioHdr->DecrementAccess();
}
private:
CStudioHdr *m_pStudioHdr;
};
#define ENABLE_MODEL_ACCESS( a ) \
CModelAccess ModelAccess##__LINE__( a->m_pStudioHdr )
*/
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
// struct flexweight_t
// {
// DECLARE_BYTESWAP_DATADESC();
// int key;
// float weight;
// float influence;
// };
//
// struct flexsetting_t
// {
// DECLARE_BYTESWAP_DATADESC();
// int nameindex;
//
// inline char *pszName( void ) const
// {
// return (char *)(((byte *)this) + nameindex);
// }
//
// // Leaving this for legacy support
// int obsolete1;
//
// // Number of flex settings
// int numsettings;
// int index;
//
// // OBSOLETE:
// int obsolete2;
//
// // Index of start of contiguous array of flexweight_t structures
// int settingindex;
//
// //-----------------------------------------------------------------------------
// // Purpose: Retrieves a pointer to the flexweight_t, including resolving
// // any markov chain hierarchy. Because of this possibility, we return
// // the number of settings in the weights array returned. We'll generally
// // call this function with i == 0
// // Input : *base -
// // i -
// // **weights -
// // Output : int
// //-----------------------------------------------------------------------------
// inline int psetting( byte *base, int i, flexweight_t **weights ) const;
// };
//
//
// struct flexsettinghdr_t
// {
// DECLARE_BYTESWAP_DATADESC();
// int id;
// int version;
//
// inline const char * pszName( void ) const { return name; }
// char name[64];
// int length;
//
// int numflexsettings;
// int flexsettingindex;
// inline flexsetting_t *pSetting( int i ) const { return (flexsetting_t *)(((byte *)this) + flexsettingindex) + i; };
// int nameindex;
//
// // look up flex settings by "index"
// int numindexes;
// int indexindex;
//
// inline flexsetting_t *pIndexedSetting( int index ) const
// {
// if ( index < 0 || index >= numindexes )
// {
// return NULL;
// }
//
// int i = *((int *)(((byte *)this) + indexindex) + index);
//
// if (i == -1)
// {
// return NULL;
// }
//
// return pSetting( i );
// }
//
// // index names of "flexcontrollers"
// int numkeys;
// int keynameindex;
// inline char *pLocalName( int i ) const { return (char *)(((byte *)this) + *((int *)(((byte *)this) + keynameindex) + i)); };
//
// int keymappingindex;
// inline int *pLocalToGlobal( int i ) const { return (int *)(((byte *)this) + keymappingindex) + i; };
// inline int LocalToGlobal( int i ) const { return *pLocalToGlobal( i ); };
// };
//-----------------------------------------------------------------------------
// Purpose: Retrieves a pointer to the flexweight_t.
// Input : *base - flexsettinghdr_t * pointer
// i - index of flex setting to retrieve
// **weights - destination for weights array starting at index i.
// Output : int
//-----------------------------------------------------------------------------
// inline int flexsetting_t::psetting( byte *base, int i, flexweight_t **weights ) const
// {
// // Grab array pointer
// *weights = (flexweight_t *)(((byte *)this) + settingindex) + i;
// // Return true number of settings
// return numsettings;
// };
//-----------------------------------------------------------------------------
// For a given flex controller ui struct, these return the index of the
// studiohdr_t flex controller that correspond to the the left and right
// flex controllers if the ui controller is a stereo control.
// nWayValueIndex returns the index of the flex controller that is the value
// flex controller for an NWAY combination
// If these functions are called and the ui controller isn't of the type
// specified then -1 is returned
//-----------------------------------------------------------------------------
// inline int mstudioflexcontrollerui_t::controllerIndex( const CStudioHdr &cStudioHdr ) const
// {
// return !stereo ? pController() - cStudioHdr.pFlexcontroller( (LocalFlexController_t)0 ) : -1;
// }
//
//
// inline int mstudioflexcontrollerui_t::rightIndex( const CStudioHdr &cStudioHdr ) const
// {
// return stereo ? pRightController() - cStudioHdr.pFlexcontroller( (LocalFlexController_t)0 ) : -1;
// }
//
//
// inline int mstudioflexcontrollerui_t::leftIndex( const CStudioHdr &cStudioHdr ) const
// {
// return stereo ? pLeftController() - cStudioHdr.pFlexcontroller((LocalFlexController_t) 0 ) : -1;
// }
//
//
// inline int mstudioflexcontrollerui_t::nWayValueIndex( const CStudioHdr &cStudioHdr ) const
// {
// return remaptype == FLEXCONTROLLER_REMAP_NWAY ? pNWayValueController() - cStudioHdr.pFlexcontroller( (LocalFlexController_t)0 ) : -1;
// }
// inline const mstudioflexcontroller_t *mstudioflexcontrollerui_t::pController( int index ) const
// {
// if ( index < 0 || index > Count() )
// return NULL;
//
// if ( remaptype == FLEXCONTROLLER_REMAP_NWAY )
// {
// if ( stereo )
// return (mstudioflexcontroller_t *)( ( char * ) this ) + *( &szindex0 + index );
//
// if ( index == 0 )
// return pController();
//
// if ( index == 1 )
// return pNWayValueController();
//
// return NULL;
// }
//
// if ( index > 1 )
// return NULL;
//
// if ( stereo )
// return (mstudioflexcontroller_t *)( ( char * ) this ) + *( &szindex0 + index );
//
// if ( index > 0 )
// return NULL;
//
// return pController();
// }
// #define STUDIO_CONST 1 // get float
// #define STUDIO_FETCH1 2 // get Flexcontroller value
// #define STUDIO_FETCH2 3 // get flex weight
// #define STUDIO_ADD 4
// #define STUDIO_SUB 5
// #define STUDIO_MUL 6
// #define STUDIO_DIV 7
// #define STUDIO_NEG 8 // not implemented
// #define STUDIO_EXP 9 // not implemented
// #define STUDIO_OPEN 10 // only used in token parsing
// #define STUDIO_CLOSE 11
// #define STUDIO_COMMA 12 // only used in token parsing
// #define STUDIO_MAX 13
// #define STUDIO_MIN 14
// #define STUDIO_2WAY_0 15 // Fetch a value from a 2 Way slider for the 1st value RemapVal( 0.0, 0.5, 0.0, 1.0 )
// #define STUDIO_2WAY_1 16 // Fetch a value from a 2 Way slider for the 2nd value RemapVal( 0.5, 1.0, 0.0, 1.0 )
// #define STUDIO_NWAY 17 // Fetch a value from a 2 Way slider for the 2nd value RemapVal( 0.5, 1.0, 0.0, 1.0 )
// #define STUDIO_COMBO 18 // Perform a combo operation (essentially multiply the last N values on the stack)
// #define STUDIO_DOMINATE 19 // Performs a combination domination operation
// #define STUDIO_DME_LOWER_EYELID 20 //
// #define STUDIO_DME_UPPER_EYELID 21 //
//
// // motion flags
// #define STUDIO_X 0x00000001
// #define STUDIO_Y 0x00000002
// #define STUDIO_Z 0x00000004
// #define STUDIO_XR 0x00000008
// #define STUDIO_YR 0x00000010
// #define STUDIO_ZR 0x00000020
//
// #define STUDIO_LX 0x00000040
// #define STUDIO_LY 0x00000080
// #define STUDIO_LZ 0x00000100
// #define STUDIO_LXR 0x00000200
// #define STUDIO_LYR 0x00000400
// #define STUDIO_LZR 0x00000800
//
// #define STUDIO_LINEAR 0x00001000
//
// #define STUDIO_TYPES 0x0003FFFF
// #define STUDIO_RLOOP 0x00040000 // controller that wraps shortest distance
//
// // sequence and autolayer flags
// #define STUDIO_LOOPING 0x0001 // ending frame should be the same as the starting frame
// #define STUDIO_SNAP 0x0002 // do not interpolate between previous animation and this one
// #define STUDIO_DELTA 0x0004 // this sequence "adds" to the base sequences, not slerp blends
// #define STUDIO_AUTOPLAY 0x0008 // temporary flag that forces the sequence to always play
// #define STUDIO_POST 0x0010 //
// #define STUDIO_ALLZEROS 0x0020 // this animation/sequence has no real animation data
// #define STUDIO_FRAMEANIM 0x0040 // animation is encoded as by frame x bone instead of RLE bone x frame
// #define STUDIO_CYCLEPOSE 0x0080 // cycle index is taken from a pose parameter index
// #define STUDIO_REALTIME 0x0100 // cycle index is taken from a real-time clock, not the animations cycle index
// #define STUDIO_LOCAL 0x0200 // sequence has a local context sequence
// #define STUDIO_HIDDEN 0x0400 // don't show in default selection views
// #define STUDIO_OVERRIDE 0x0800 // a forward declared sequence (empty)
// #define STUDIO_ACTIVITY 0x1000 // Has been updated at runtime to activity index
// #define STUDIO_EVENT 0x2000 // Has been updated at runtime to event index on server
// #define STUDIO_WORLD 0x4000 // sequence blends in worldspace
// #define STUDIO_NOFORCELOOP 0x8000 // do not force the animation loop
// #define STUDIO_EVENT_CLIENT 0x10000 // Has been updated at runtime to event index on client
// autolayer flags
// 0x0001
// 0x0002
// 0x0004
// 0x0008
//#define STUDIO_AL_POST 0x0010 //
// 0x0020
//#define STUDIO_AL_SPLINE 0x0040 // convert layer ramp in/out curve is a spline instead of linear
//#define STUDIO_AL_XFADE 0x0080 // pre-bias the ramp curve to compense for a non-1 weight, assuming a second layer is also going to accumulate
// 0x0100
//#define STUDIO_AL_NOBLEND 0x0200 // animation always blends at 1.0 (ignores weight)
// 0x0400
// 0x0800
//#define STUDIO_AL_LOCAL 0x1000 // layer is a local context sequence
// 0x2000
//#define STUDIO_AL_POSE 0x4000 // layer blends using a pose parameter instead of parent cycle
// Insert this code anywhere that you need to allow for conversion from an old STUDIO_VERSION to a new one.
// If we only support the current version, this function should be empty.
// inline bool Studio_ConvertStudioHdrToNewVersion( studiohdr_t *pStudioHdr )
// {
// COMPILE_TIME_ASSERT( STUDIO_VERSION == 49 ); // put this to make sure this code is updated upon changing version.
//
// int version = pStudioHdr->version;
// if ( version == STUDIO_VERSION )
// return true;
//
// bool bResult = true;
// if (version < 46)
// {
// // some of the anim index data is incompatible
// for (int i = 0; i < pStudioHdr->numlocalanim; i++)
// {
// mstudioanimdesc_t *pAnim = (mstudioanimdesc_t *)pStudioHdr->pLocalAnimdesc( i );
//
// // old ANI files that used sections (v45 only) are not compatible
// if ( pAnim->sectionframes != 0 )
// {
// // zero most everything out
// memset( &(pAnim->numframes), 0, (byte *)(pAnim + 1) - (byte *)&(pAnim->numframes) );
//
// pAnim->numframes = 1;
// pAnim->animblock = -1; // disable animation fetching
// bResult = false;
// }
// }
// }
//
// if (version < 47)
// {
// // now used to contain zeroframe cache data, make sure it's empty
// if (pStudioHdr->unused4 != 0)
// {
// pStudioHdr->unused4 = 0;
// bResult = false;
// }
// for (int i = 0; i < pStudioHdr->numlocalanim; i++)
// {
// mstudioanimdesc_t *pAnim = (mstudioanimdesc_t *)pStudioHdr->pLocalAnimdesc( i );
// pAnim->zeroframeindex = 0;
// pAnim->zeroframespan = 0;
// }
// }
// else if (version == 47)
// {
// // clear out stale version of zeroframe cache data
// for (int i = 0; i < pStudioHdr->numlocalanim; i++)
// {
// mstudioanimdesc_t *pAnim = (mstudioanimdesc_t *)pStudioHdr->pLocalAnimdesc( i );
// if (pAnim->zeroframeindex != 0)
// {
// pAnim->zeroframeindex = 0;
// pAnim->zeroframespan = 0;
// bResult = false;
// }
// }
// }
//
// if (version < 49)
// {
// // remove any frameanim flag settings that might be stale
// for (int i = 0; i < pStudioHdr->numlocalanim; i++)
// {
// mstudioanimdesc_t *pAnim = (mstudioanimdesc_t *)pStudioHdr->pLocalAnimdesc( i );
// if (pAnim->flags & STUDIO_FRAMEANIM)
// {
// pAnim->flags &= ~STUDIO_FRAMEANIM;
// bResult = false;
// }
// }
// }
// // for now, just slam the version number since they're compatible
// pStudioHdr->version = STUDIO_VERSION;
//
// return bResult;
// }
// must be run to fixup with specified rootLOD
// inline void Studio_SetRootLOD( studiohdr_t *pStudioHdr, int rootLOD )
// {
// // honor studiohdr restriction of root lod in case requested root lod exceeds restriction.
// if ( pStudioHdr->numAllowedRootLODs > 0 &&
// rootLOD >= pStudioHdr->numAllowedRootLODs )
// {
// rootLOD = pStudioHdr->numAllowedRootLODs - 1;
// }
//
// // run the lod fixups that culls higher detail lods
// // vertexes are external, fixups ensure relative offsets and counts are cognizant of shrinking data
// // indexes are built in lodN..lod0 order so higher detail lod data can be truncated at load
// // the fixup lookup arrays are filled (or replicated) to ensure all slots valid
// int vertexindex = 0;
// int tangentsindex = 0;
// int bodyPartID;
// for ( bodyPartID = 0; bodyPartID < pStudioHdr->numbodyparts; bodyPartID++ )
// {
// mstudiobodyparts_t *pBodyPart = pStudioHdr->pBodypart( bodyPartID );
// int modelID;
// for ( modelID = 0; modelID < pBodyPart->nummodels; modelID++ )
// {
// mstudiomodel_t *pModel = pBodyPart->pModel( modelID );
// int totalMeshVertexes = 0;
// int meshID;
// for ( meshID = 0; meshID < pModel->nummeshes; meshID++ )
// {
// mstudiomesh_t *pMesh = pModel->pMesh( meshID );
//
// // get the fixup, vertexes are reduced
// pMesh->numvertices = pMesh->vertexdata.numLODVertexes[rootLOD];
// pMesh->vertexoffset = totalMeshVertexes;
// totalMeshVertexes += pMesh->numvertices;
// }
//
// // stay in sync
// pModel->numvertices = totalMeshVertexes;
// pModel->vertexindex = vertexindex;
// pModel->tangentsindex = tangentsindex;
//
// vertexindex += totalMeshVertexes*sizeof(mstudiovertex_t);
// tangentsindex += totalMeshVertexes*sizeof(Vector4D);
// }
// }
//
// // track the set desired configuration
// pStudioHdr->rootLOD = rootLOD;
// }
// Determines allocation requirements for vertexes
// inline int Studio_VertexDataSize( const vertexFileHeader_t *pVvdHdr, int rootLOD, bool bNeedsTangentS )
// {
// // the quantity of vertexes necessary for root lod and all lower detail lods
// // add one extra vertex to each section
// // the extra vertex allows prefetch hints to read ahead 1 vertex without faulting
// int numVertexes = pVvdHdr->numLODVertexes[rootLOD] + 1;
// int dataLength = pVvdHdr->vertexDataStart + numVertexes*sizeof(mstudiovertex_t);
// if (bNeedsTangentS)
// {
// dataLength += numVertexes*sizeof(Vector4D);
// #ifdef _PS3
// if ( !pVvdHdr->numFixups && ( pVvdHdr->ps3edgeDmaInputDesc & 0x80000000 ) )
// {
// // PS3 does not support root lod, so all vertexes will be used
// dataLength = pVvdHdr->GetPs3EdgeDmaInputStart() + pVvdHdr->GetPs3EdgeDmaInputLength();
// }
// #endif
// }
//
// // allocate this much
// return dataLength;
// }
// Load the minimum quantity of verts and run fixups
// inline int Studio_LoadVertexes( const vertexFileHeader_t *pTempVvdHdr, vertexFileHeader_t *pNewVvdHdr, int rootLOD, bool bNeedsTangentS )
// {
// int i;
// int target;
// int numVertexes;
// vertexFileFixup_t *pFixupTable;
//
// numVertexes = pTempVvdHdr->numLODVertexes[rootLOD];
//
// // copy all data up to start of vertexes
// memcpy((void*)pNewVvdHdr, (void*)pTempVvdHdr, pTempVvdHdr->vertexDataStart);
//
// for ( i = 0; i < rootLOD; i++)
// {
// pNewVvdHdr->numLODVertexes[i] = pNewVvdHdr->numLODVertexes[rootLOD];
// }
//
// // fixup data starts
// if (bNeedsTangentS)
// {
// // tangent data follows possibly reduced vertex data
// pNewVvdHdr->tangentDataStart = pNewVvdHdr->vertexDataStart + numVertexes*sizeof(mstudiovertex_t);
//
// #ifdef _PS3
// // PS3 does not support root LOD, so all vertices will be available
// if ( !pTempVvdHdr->numFixups && ( pTempVvdHdr->ps3edgeDmaInputDesc & 0x80000000 ) )
// {
// pNewVvdHdr->ps3edgeDmaInputDesc = pTempVvdHdr->ps3edgeDmaInputDesc;
// }
// else
// {
// pNewVvdHdr->ps3edgeDmaInputDesc = 0;
// }
// #endif
// }
// else
// {
// // no tangent data will be available, mark for identification
// pNewVvdHdr->tangentDataStart = 0;
//
// #ifdef _PS3
// pNewVvdHdr->ps3edgeDmaInputDesc = 0;
// #endif
// }
//
// if (!pNewVvdHdr->numFixups)
// {
// // fixups not required
// // transfer vertex data
// memcpy(
// (byte *)pNewVvdHdr+pNewVvdHdr->vertexDataStart,
// (byte *)pTempVvdHdr+pTempVvdHdr->vertexDataStart,
// numVertexes*sizeof(mstudiovertex_t) );
//
// if (bNeedsTangentS)
// {
// // transfer tangent data to cache memory
// memcpy(
// (byte *)pNewVvdHdr+pNewVvdHdr->tangentDataStart,
// (byte *)pTempVvdHdr+pTempVvdHdr->tangentDataStart,
// numVertexes*sizeof(Vector4D) );
//
// #ifdef _PS3
// if ( pNewVvdHdr->ps3edgeDmaInputDesc )
// {
// // transfer EDGE DMA INPUT to cache memory
// memcpy(
// const_cast< byte* >( pNewVvdHdr->GetPs3EdgeDmaInput() ),
// pTempVvdHdr->GetPs3EdgeDmaInput(),
// pTempVvdHdr->GetPs3EdgeDmaInputLength()
// );
// }
// #endif
// }
//
// return numVertexes;
// }
//
// // fixups required
// // re-establish mesh ordered vertexes into cache memory, according to table
// target = 0;
// pFixupTable = (vertexFileFixup_t *)((byte *)pTempVvdHdr + pTempVvdHdr->fixupTableStart);
// for (i=0; i<pTempVvdHdr->numFixups; i++)
// {
// if (pFixupTable[i].lod < rootLOD)
// {
// // working bottom up, skip over copying higher detail lods
// continue;
// }
//
// // copy vertexes
// memcpy(
// (mstudiovertex_t *)((byte *)pNewVvdHdr+pNewVvdHdr->vertexDataStart) + target,
// (mstudiovertex_t *)((byte *)pTempVvdHdr+pTempVvdHdr->vertexDataStart) + pFixupTable[i].sourceVertexID,
// pFixupTable[i].numVertexes*sizeof(mstudiovertex_t) );
//
// if (bNeedsTangentS)
// {
// // copy tangents
// memcpy(
// (Vector4D *)((byte *)pNewVvdHdr+pNewVvdHdr->tangentDataStart) + target,
// (Vector4D *)((byte *)pTempVvdHdr+pTempVvdHdr->tangentDataStart) + pFixupTable[i].sourceVertexID,
// pFixupTable[i].numVertexes*sizeof(Vector4D) );
// }
//
// // data is placed consecutively
// target += pFixupTable[i].numVertexes;
// }
//
// pNewVvdHdr->numFixups = 0;
// pNewVvdHdr->fixupTableStart = 0; // otherwise PS3 will be confusing it for EDGE DMA INPUT
//
// return target;
// }
#endif // STUDIO__PS3_H
Reference in New Issue View Git Blame Copy Permalink