mirror of
https://github.com/0TheSpy/Seaside.git
synced 2025-01-11 03:32:10 +08:00
2781 lines
79 KiB
C++
2781 lines
79 KiB
C++
#ifndef STUDIO_H
|
|
#define STUDIO_H
|
|
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "basetypes.h"
|
|
#include "vector2d.h"
|
|
#include "vector.h"
|
|
#include "vector4d.h"
|
|
#include "compressed_vector.h"
|
|
#include "dbg.h"
|
|
#include "threadtools.h"
|
|
#include "mathlib.h"
|
|
#include "utlvector.h"
|
|
#include "utlhash.h"
|
|
#include "datamap.h"
|
|
#include "generichash.h"
|
|
#include "localflexcontroller.h"
|
|
#include "utlsymbol.h"
|
|
|
|
#define STUDIO_ENABLE_PERF_COUNTERS
|
|
|
|
#define STUDIO_SEQUENCE_ACTIVITY_LOOKUPS_ARE_SLOW 0
|
|
#define STUDIO_SEQUENCE_ACTIVITY_LAZY_INITIALIZE 1
|
|
|
|
class IMaterial;
|
|
class IMesh;
|
|
class IMorph;
|
|
struct virtualmodel_t;
|
|
struct vertexFileHeader_t;
|
|
struct thinModelVertices_t;
|
|
|
|
namespace OptimizedModel
|
|
{
|
|
struct StripHeader_t;
|
|
}
|
|
|
|
|
|
#define STUDIO_VERSION 48
|
|
|
|
#ifndef _XBOX
|
|
#define MAXSTUDIOTRIANGLES 65536
|
|
#define MAXSTUDIOVERTS 65536
|
|
#define MAXSTUDIOFLEXVERTS 10000
|
|
#else
|
|
#define MAXSTUDIOTRIANGLES 25000
|
|
#define MAXSTUDIOVERTS 10000
|
|
#define MAXSTUDIOFLEXVERTS 1000
|
|
#endif
|
|
#define MAXSTUDIOSKINS 32
|
|
#define MAXSTUDIOBONES 128
|
|
#define MAXSTUDIOFLEXDESC 1024
|
|
#define MAXSTUDIOFLEXCTRL 96
|
|
#define MAXSTUDIOPOSEPARAM 24
|
|
#define MAXSTUDIOBONECTRLS 4
|
|
#define MAXSTUDIOANIMBLOCKS 256
|
|
|
|
#define MAXSTUDIOBONEBITS 7
|
|
|
|
#define MAX_NUM_BONES_PER_VERT 3
|
|
|
|
#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
|
|
|
|
struct mstudioaxisinterpbone_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
int control;
|
|
int axis;
|
|
Vector pos[6];
|
|
Quaternion quat[6];
|
|
|
|
mstudioaxisinterpbone_t() {}
|
|
private:
|
|
mstudioaxisinterpbone_t(const mstudioaxisinterpbone_t& vOther);
|
|
};
|
|
|
|
|
|
struct mstudioquatinterpinfo_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
float inv_tolerance;
|
|
Quaternion trigger;
|
|
Vector pos;
|
|
Quaternion quat;
|
|
|
|
mstudioquatinterpinfo_t() {}
|
|
private:
|
|
mstudioquatinterpinfo_t(const mstudioquatinterpinfo_t& vOther);
|
|
};
|
|
|
|
struct mstudioquatinterpbone_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
int control;
|
|
int numtriggers;
|
|
int triggerindex;
|
|
inline mstudioquatinterpinfo_t* pTrigger(int i) const { return (mstudioquatinterpinfo_t*)(((byte*)this) + triggerindex) + i; };
|
|
|
|
mstudioquatinterpbone_t() {}
|
|
private:
|
|
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
|
|
#define JIGGLE_IS_BOING 0x80
|
|
|
|
struct mstudiojigglebone_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
|
|
int flags;
|
|
|
|
float length;
|
|
float tipMass;
|
|
|
|
float yawStiffness;
|
|
float yawDamping;
|
|
float pitchStiffness;
|
|
float pitchDamping;
|
|
float alongStiffness;
|
|
float alongDamping;
|
|
|
|
float angleLimit;
|
|
|
|
float minYaw;
|
|
float maxYaw;
|
|
float yawFriction;
|
|
float yawBounce;
|
|
|
|
float minPitch;
|
|
float maxPitch;
|
|
float pitchFriction;
|
|
float pitchBounce;
|
|
|
|
float baseMass;
|
|
float baseStiffness;
|
|
float baseDamping;
|
|
float baseMinLeft;
|
|
float baseMaxLeft;
|
|
float baseLeftFriction;
|
|
float baseMinUp;
|
|
float baseMaxUp;
|
|
float baseUpFriction;
|
|
float baseMinForward;
|
|
float baseMaxForward;
|
|
float baseForwardFriction;
|
|
|
|
float boingImpactSpeed;
|
|
float boingImpactAngle;
|
|
float boingDampingRate;
|
|
float boingFrequency;
|
|
float boingAmplitude;
|
|
|
|
private:
|
|
};
|
|
|
|
struct mstudioaimatbone_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
|
|
int parent;
|
|
int aim;
|
|
Vector aimvector;
|
|
Vector upvector;
|
|
Vector basepos;
|
|
|
|
mstudioaimatbone_t() {}
|
|
private:
|
|
mstudioaimatbone_t(const mstudioaimatbone_t& vOther);
|
|
};
|
|
|
|
struct mstudiobone_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
int sznameindex;
|
|
inline char* const pszName(void) const { return ((char*)this) + sznameindex; }
|
|
int parent;
|
|
int bonecontroller[6];
|
|
|
|
Vector pos;
|
|
Quaternion quat;
|
|
RadianEuler rot;
|
|
Vector posscale;
|
|
Vector rotscale;
|
|
|
|
matrix3x4_t poseToBone;
|
|
Quaternion qAlignment;
|
|
int flags;
|
|
int proctype;
|
|
int procindex;
|
|
mutable int physicsbone;
|
|
inline void* pProcedure() const { if (procindex == 0) return NULL; else return (void*)(((byte*)this) + procindex); };
|
|
int surfacepropidx;
|
|
inline char* const pszSurfaceProp(void) const { return ((char*)this) + surfacepropidx; }
|
|
int contents;
|
|
|
|
int unused[8];
|
|
|
|
mstudiobone_t() {}
|
|
private:
|
|
mstudiobone_t(const mstudiobone_t& vOther);
|
|
};
|
|
|
|
struct mstudiolinearbone_t
|
|
{
|
|
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 Vector pos(int i) const { Assert(i >= 0 && i < numbones); return *((Vector*)(((byte*)this) + posindex) + i); };
|
|
|
|
int quatindex;
|
|
inline Quaternion quat(int i) const { Assert(i >= 0 && i < numbones); return *((Quaternion*)(((byte*)this) + quatindex) + i); };
|
|
|
|
int rotindex;
|
|
inline RadianEuler rot(int i) const { Assert(i >= 0 && i < numbones); return *((RadianEuler*)(((byte*)this) + rotindex) + i); };
|
|
|
|
int posetoboneindex;
|
|
inline matrix3x4_t poseToBone(int i) const { Assert(i >= 0 && i < numbones); return *((matrix3x4_t*)(((byte*)this) + posetoboneindex) + i); };
|
|
|
|
int posscaleindex;
|
|
inline Vector posscale(int i) const { Assert(i >= 0 && i < numbones); return *((Vector*)(((byte*)this) + posscaleindex) + i); };
|
|
|
|
int rotscaleindex;
|
|
inline Vector rotscale(int i) const { Assert(i >= 0 && i < numbones); return *((Vector*)(((byte*)this) + rotscaleindex) + i); };
|
|
|
|
int qalignmentindex;
|
|
inline Quaternion qalignment(int i) const { Assert(i >= 0 && i < numbones); return *((Quaternion*)(((byte*)this) + qalignmentindex) + i); };
|
|
|
|
int unused[6];
|
|
|
|
mstudiolinearbone_t() {}
|
|
private:
|
|
mstudiolinearbone_t(const mstudiolinearbone_t& vOther);
|
|
};
|
|
|
|
|
|
enum StudioBoneFlexComponent_t
|
|
{
|
|
STUDIO_BONE_FLEX_INVALID = -1,
|
|
STUDIO_BONE_FLEX_TX = 0,
|
|
STUDIO_BONE_FLEX_TY = 1,
|
|
STUDIO_BONE_FLEX_TZ = 2
|
|
};
|
|
|
|
|
|
struct mstudioboneflexdrivercontrol_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
|
|
int m_nBoneComponent;
|
|
int m_nFlexControllerIndex;
|
|
float m_flMin;
|
|
float m_flMax;
|
|
|
|
mstudioboneflexdrivercontrol_t() {}
|
|
private:
|
|
mstudioboneflexdrivercontrol_t(const mstudioboneflexdrivercontrol_t& vOther);
|
|
};
|
|
|
|
|
|
struct mstudioboneflexdriver_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
|
|
int m_nBoneIndex;
|
|
int m_nControlCount;
|
|
int m_nControlIndex;
|
|
|
|
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:
|
|
mstudioboneflexdriver_t(const mstudioboneflexdriver_t& vOther);
|
|
};
|
|
|
|
|
|
#define BONE_CALCULATE_MASK 0x1F
|
|
#define BONE_PHYSICALLY_SIMULATED 0x01
|
|
#define BONE_PHYSICS_PROCEDURAL 0x02
|
|
#define BONE_ALWAYS_PROCEDURAL 0x04
|
|
#define BONE_SCREEN_ALIGN_SPHERE 0x08
|
|
#define BONE_SCREEN_ALIGN_CYLINDER 0x10
|
|
|
|
#define BONE_USED_MASK 0x0007FF00
|
|
#define BONE_USED_BY_ANYTHING 0x0007FF00
|
|
#define BONE_USED_BY_HITBOX 0x00000100
|
|
#define BONE_USED_BY_ATTACHMENT 0x00000200
|
|
#define BONE_USED_BY_VERTEX_MASK 0x0003FC00
|
|
#define BONE_USED_BY_VERTEX_LOD0 0x00000400
|
|
#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
|
|
|
|
#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
|
|
|
|
#define BONE_HAS_SAVEFRAME_POS 0x00200000
|
|
#define BONE_HAS_SAVEFRAME_ROT 0x00400000
|
|
|
|
struct mstudiobonecontroller_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
int bone;
|
|
int type;
|
|
float start;
|
|
float end;
|
|
int rest;
|
|
int inputfield;
|
|
int unused[8];
|
|
};
|
|
|
|
struct mstudiobbox_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
int bone;
|
|
int group;
|
|
Vector bbmin;
|
|
Vector bbmax;
|
|
int szhitboxnameindex;
|
|
int unused[8];
|
|
|
|
const char* pszHitboxName()
|
|
{
|
|
if (szhitboxnameindex == 0)
|
|
return "";
|
|
|
|
return ((const char*)this) + szhitboxnameindex;
|
|
}
|
|
|
|
mstudiobbox_t() {}
|
|
|
|
private:
|
|
mstudiobbox_t(const mstudiobbox_t& vOther);
|
|
};
|
|
|
|
struct mstudiomodelgroup_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
int szlabelindex;
|
|
inline char* const pszLabel(void) const { return ((char*)this) + szlabelindex; }
|
|
int sznameindex;
|
|
inline char* const pszName(void) const { return ((char*)this) + sznameindex; }
|
|
};
|
|
|
|
struct mstudiomodelgrouplookup_t
|
|
{
|
|
int modelgroup;
|
|
int indexwithingroup;
|
|
};
|
|
|
|
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
|
|
|
|
struct mstudioattachment_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
int sznameindex;
|
|
inline char* const pszName(void) const { return ((char*)this) + sznameindex; }
|
|
unsigned int flags;
|
|
int localbone;
|
|
matrix3x4_t local;
|
|
int unused[8];
|
|
};
|
|
|
|
#define IK_SELF 1
|
|
#define IK_WORLD 2
|
|
#define IK_GROUND 3
|
|
#define IK_RELEASE 4
|
|
#define IK_ATTACHMENT 5
|
|
#define IK_UNLATCH 6
|
|
|
|
struct mstudioikerror_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
Vector pos;
|
|
Quaternion q;
|
|
|
|
mstudioikerror_t() {}
|
|
|
|
private:
|
|
mstudioikerror_t(const mstudioikerror_t& vOther);
|
|
};
|
|
|
|
union mstudioanimvalue_t;
|
|
|
|
struct mstudiocompressedikerror_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
float scale[6];
|
|
short offset[6];
|
|
inline mstudioanimvalue_t* pAnimvalue(int i) const { if (offset[i] > 0) return (mstudioanimvalue_t*)(((byte*)this) + offset[i]); else return NULL; };
|
|
mstudiocompressedikerror_t() {}
|
|
|
|
private:
|
|
mstudiocompressedikerror_t(const mstudiocompressedikerror_t& vOther);
|
|
};
|
|
|
|
struct mstudioikrule_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
int index;
|
|
|
|
int type;
|
|
int chain;
|
|
|
|
int bone;
|
|
|
|
int slot;
|
|
float height;
|
|
float radius;
|
|
float floor;
|
|
Vector pos;
|
|
Quaternion q;
|
|
|
|
int compressedikerrorindex;
|
|
inline mstudiocompressedikerror_t* pCompressedError() const { return (mstudiocompressedikerror_t*)(((byte*)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; };
|
|
|
|
float start;
|
|
float peak;
|
|
float tail;
|
|
float end;
|
|
|
|
float unused3;
|
|
float contact;
|
|
float drop;
|
|
float top;
|
|
|
|
int unused6;
|
|
int unused7;
|
|
int unused8;
|
|
|
|
int szattachmentindex;
|
|
inline char* const pszAttachment(void) const { return ((char*)this) + szattachmentindex; }
|
|
|
|
int unused[7];
|
|
|
|
mstudioikrule_t() {}
|
|
|
|
private:
|
|
mstudioikrule_t(const mstudioikrule_t& vOther);
|
|
};
|
|
|
|
|
|
struct mstudioiklock_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
int chain;
|
|
float flPosWeight;
|
|
float flLocalQWeight;
|
|
int flags;
|
|
|
|
int unused[4];
|
|
};
|
|
|
|
|
|
struct mstudiolocalhierarchy_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
int iBone;
|
|
int iNewParent;
|
|
|
|
float start;
|
|
float peak;
|
|
float tail;
|
|
float end;
|
|
|
|
int iStart;
|
|
|
|
int localanimindex;
|
|
inline mstudiocompressedikerror_t* pLocalAnim() const { return (mstudiocompressedikerror_t*)(((byte*)this) + localanimindex); };
|
|
|
|
int unused[4];
|
|
};
|
|
|
|
|
|
|
|
union mstudioanimvalue_t
|
|
{
|
|
struct
|
|
{
|
|
byte valid;
|
|
byte total;
|
|
} num;
|
|
short value;
|
|
};
|
|
|
|
struct mstudioanim_valueptr_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
short offset[3];
|
|
inline mstudioanimvalue_t* pAnimvalue(int i) const { if (offset[i] > 0) return (mstudioanimvalue_t*)(((byte*)this) + offset[i]); else return NULL; };
|
|
};
|
|
|
|
#define STUDIO_ANIM_RAWPOS 0x01
|
|
#define STUDIO_ANIM_RAWROT 0x02
|
|
#define STUDIO_ANIM_ANIMPOS 0x04
|
|
#define STUDIO_ANIM_ANIMROT 0x08
|
|
#define STUDIO_ANIM_DELTA 0x10
|
|
#define STUDIO_ANIM_RAWROT2 0x20
|
|
|
|
|
|
struct mstudioanim_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
byte bone;
|
|
byte flags;
|
|
|
|
inline byte* pData(void) const { return (((byte*)this) + sizeof(struct mstudioanim_t)); };
|
|
inline mstudioanim_valueptr_t* pRotV(void) const { return (mstudioanim_valueptr_t*)(pData()); };
|
|
inline mstudioanim_valueptr_t* pPosV(void) const { return (mstudioanim_valueptr_t*)(pData()) + ((flags & STUDIO_ANIM_ANIMROT) != 0); };
|
|
|
|
inline Quaternion48* pQuat48(void) const { return (Quaternion48*)(pData()); };
|
|
inline Quaternion64* pQuat64(void) const { return (Quaternion64*)(pData()); };
|
|
inline Vector48* pPos(void) const { return (Vector48*)(pData() + ((flags & STUDIO_ANIM_RAWROT) != 0) * sizeof(*pQuat48()) + ((flags & STUDIO_ANIM_RAWROT2) != 0) * sizeof(*pQuat64())); };
|
|
|
|
short nextoffset;
|
|
inline mstudioanim_t* pNext(void) const { if (nextoffset != 0) return (mstudioanim_t*)(((byte*)this) + nextoffset); else return NULL; };
|
|
};
|
|
|
|
struct mstudiomovement_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
int endframe;
|
|
int motionflags;
|
|
float v0;
|
|
float v1;
|
|
float angle;
|
|
Vector vector;
|
|
Vector position;
|
|
|
|
mstudiomovement_t() {}
|
|
private:
|
|
mstudiomovement_t(const mstudiomovement_t& vOther);
|
|
};
|
|
|
|
struct studiohdr_t;
|
|
|
|
struct mstudioanimblock_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
int datastart;
|
|
int dataend;
|
|
};
|
|
|
|
struct mstudioanimsections_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
int animblock;
|
|
int animindex;
|
|
};
|
|
|
|
struct mstudioanimdesc_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
int baseptr;
|
|
inline studiohdr_t* pStudiohdr(void) const { return (studiohdr_t*)(((byte*)this) + baseptr); }
|
|
|
|
int sznameindex;
|
|
inline char* const pszName(void) const { return ((char*)this) + sznameindex; }
|
|
|
|
float fps;
|
|
int flags;
|
|
|
|
int numframes;
|
|
|
|
int nummovements;
|
|
int movementindex;
|
|
inline mstudiomovement_t* const pMovement(int i) const { return (mstudiomovement_t*)(((byte*)this) + movementindex) + i; };
|
|
|
|
int unused1[6];
|
|
|
|
int animblock;
|
|
int animindex;
|
|
mstudioanim_t* pAnimBlock(int block, int index) const;
|
|
mstudioanim_t* pAnim(int* piFrame, float& flStall) const;
|
|
mstudioanim_t* pAnim(int* piFrame) const;
|
|
|
|
int numikrules;
|
|
int ikruleindex;
|
|
int animblockikruleindex;
|
|
mstudioikrule_t* pIKRule(int i) const;
|
|
|
|
int numlocalhierarchy;
|
|
int localhierarchyindex;
|
|
mstudiolocalhierarchy_t* pHierarchy(int i) const;
|
|
|
|
int sectionindex;
|
|
int sectionframes;
|
|
inline mstudioanimsections_t* const pSection(int i) const { return (mstudioanimsections_t*)(((byte*)this) + sectionindex) + i; }
|
|
|
|
short zeroframespan;
|
|
short zeroframecount;
|
|
int zeroframeindex;
|
|
byte* pZeroFrameData() const { if (zeroframeindex) return (((byte*)this) + zeroframeindex); else return NULL; };
|
|
mutable float zeroframestalltime;
|
|
|
|
mstudioanimdesc_t() {}
|
|
private:
|
|
mstudioanimdesc_t(const mstudioanimdesc_t& vOther);
|
|
};
|
|
|
|
struct mstudioikrule_t;
|
|
|
|
struct mstudioautolayer_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
short iSequence;
|
|
short iPose;
|
|
int flags;
|
|
float start;
|
|
float peak;
|
|
float tail;
|
|
float end;
|
|
};
|
|
|
|
struct mstudioactivitymodifier_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
|
|
int sznameindex;
|
|
inline char* pszName() { return (sznameindex) ? (char*)(((byte*)this) + sznameindex) : NULL; }
|
|
};
|
|
|
|
struct mstudioseqdesc_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
int baseptr;
|
|
inline studiohdr_t* pStudiohdr(void) const { return (studiohdr_t*)(((byte*)this) + baseptr); }
|
|
|
|
int szlabelindex;
|
|
inline char* const pszLabel(void) const { return ((char*)this) + szlabelindex; }
|
|
|
|
int szactivitynameindex;
|
|
inline char* const pszActivityName(void) const { return ((char*)this) + szactivitynameindex; }
|
|
|
|
int flags;
|
|
|
|
int activity;
|
|
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; };
|
|
|
|
Vector bbmin;
|
|
Vector bbmax;
|
|
|
|
int numblends;
|
|
|
|
int animindexindex;
|
|
|
|
inline int anim(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*)this) + animindexindex);
|
|
int value = (int)blends[offset];
|
|
return value;
|
|
}
|
|
|
|
int movementindex;
|
|
int groupsize[2];
|
|
int paramindex[2];
|
|
float paramstart[2];
|
|
float paramend[2];
|
|
int paramparent;
|
|
|
|
float fadeintime;
|
|
float fadeouttime;
|
|
|
|
int localentrynode;
|
|
int localexitnode;
|
|
int nodeflags;
|
|
|
|
float entryphase;
|
|
float exitphase;
|
|
|
|
float lastframe;
|
|
|
|
int nextseq;
|
|
int pose;
|
|
|
|
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; };
|
|
|
|
int weightlistindex;
|
|
inline float* pBoneweight(int i) const { return ((float*)(((byte*)this) + weightlistindex) + i); };
|
|
inline float weight(int i) const { return *(pBoneweight(i)); };
|
|
|
|
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* pIKLock(int i) const { Assert(i >= 0 && i < numiklocks); return (mstudioiklock_t*)(((byte*)this) + iklockindex) + i; };
|
|
|
|
int keyvalueindex;
|
|
int keyvaluesize;
|
|
inline const char* KeyValueText(void) const { return keyvaluesize != 0 ? ((char*)this) + keyvalueindex : NULL; }
|
|
|
|
int cycleposeindex;
|
|
|
|
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];
|
|
|
|
mstudioseqdesc_t() {}
|
|
private:
|
|
mstudioseqdesc_t(const mstudioseqdesc_t& vOther);
|
|
};
|
|
|
|
|
|
struct mstudioposeparamdesc_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
int sznameindex;
|
|
inline char* const pszName(void) const { return ((char*)this) + sznameindex; }
|
|
int flags;
|
|
float start;
|
|
float end;
|
|
float loop;
|
|
};
|
|
|
|
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;
|
|
float min;
|
|
float max;
|
|
};
|
|
|
|
|
|
enum FlexControllerRemapType_t
|
|
{
|
|
FLEXCONTROLLER_REMAP_PASSTHRU = 0,
|
|
FLEXCONTROLLER_REMAP_2WAY,
|
|
FLEXCONTROLLER_REMAP_NWAY,
|
|
FLEXCONTROLLER_REMAP_EYELID
|
|
};
|
|
|
|
|
|
class CStudioHdr;
|
|
struct mstudioflexcontrollerui_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
int sznameindex;
|
|
inline char* const pszName(void) const { return ((char*)this) + sznameindex; }
|
|
|
|
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;
|
|
|
|
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;
|
|
bool stereo;
|
|
byte unused[2];
|
|
};
|
|
|
|
|
|
struct mstudiovertanim_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
unsigned short index;
|
|
byte speed;
|
|
byte side;
|
|
|
|
protected:
|
|
union
|
|
{
|
|
short delta[3];
|
|
float16 flDelta[3];
|
|
};
|
|
|
|
union
|
|
{
|
|
short ndelta[3];
|
|
float16 flNDelta[3];
|
|
};
|
|
|
|
public:
|
|
inline void ConvertToFixed(float flVertAnimFixedPointScale)
|
|
{
|
|
delta[0] = flDelta[0].GetFloat() / flVertAnimFixedPointScale;
|
|
delta[1] = flDelta[1].GetFloat() / flVertAnimFixedPointScale;
|
|
delta[2] = flDelta[2].GetFloat() / flVertAnimFixedPointScale;
|
|
ndelta[0] = flNDelta[0].GetFloat() / flVertAnimFixedPointScale;
|
|
ndelta[1] = flNDelta[1].GetFloat() / flVertAnimFixedPointScale;
|
|
ndelta[2] = 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] = vInput.x / flVertAnimFixedPointScale;
|
|
delta[1] = vInput.y / flVertAnimFixedPointScale;
|
|
delta[2] = vInput.z / flVertAnimFixedPointScale;
|
|
}
|
|
inline void SetNDeltaFixed(const Vector& vInputNormal, float flVertAnimFixedPointScale)
|
|
{
|
|
ndelta[0] = vInputNormal.x / flVertAnimFixedPointScale;
|
|
ndelta[1] = vInputNormal.y / flVertAnimFixedPointScale;
|
|
ndelta[2] = vInputNormal.z / flVertAnimFixedPointScale;
|
|
}
|
|
|
|
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() {}
|
|
};
|
|
|
|
|
|
struct mstudiovertanim_wrinkle_t : public mstudiovertanim_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
|
|
short wrinkledelta;
|
|
|
|
inline void SetWrinkleFixed(float flWrinkle, float flVertAnimFixedPointScale)
|
|
{
|
|
int nWrinkleDeltaInt = 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;
|
|
|
|
float target0;
|
|
float target1;
|
|
float target2;
|
|
float target3;
|
|
|
|
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;
|
|
unsigned char vertanimtype;
|
|
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; };
|
|
};
|
|
|
|
struct mstudioboneweight_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
float weight[MAX_NUM_BONES_PER_VERT];
|
|
char bone[MAX_NUM_BONES_PER_VERT];
|
|
byte numbones;
|
|
|
|
};
|
|
|
|
struct mstudiovertex_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
mstudioboneweight_t m_BoneWeights;
|
|
Vector m_vecPosition;
|
|
Vector m_vecNormal;
|
|
Vector2D m_vecTexCoord;
|
|
|
|
mstudiovertex_t() {}
|
|
|
|
private:
|
|
mstudiovertex_t(const mstudiovertex_t& vOther);
|
|
};
|
|
|
|
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;
|
|
mutable void* clientmaterial;
|
|
|
|
int unused[10];
|
|
};
|
|
|
|
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];
|
|
int lowerflexdesc[3];
|
|
float uppertarget[3];
|
|
float lowertarget[3];
|
|
|
|
int upperlidflexdesc;
|
|
int lowerlidflexdesc;
|
|
int unused[4];
|
|
bool m_bNonFACS;
|
|
char unused3[3];
|
|
int unused4[7];
|
|
|
|
mstudioeyeball_t() {}
|
|
private:
|
|
mstudioeyeball_t(const mstudioeyeball_t& vOther);
|
|
};
|
|
|
|
|
|
struct mstudioiklink_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
int bone;
|
|
Vector kneeDir;
|
|
Vector unused0;
|
|
|
|
mstudioiklink_t() {}
|
|
private:
|
|
mstudioiklink_t(const mstudioiklink_t& vOther);
|
|
};
|
|
|
|
struct mstudioikchain_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
int sznameindex;
|
|
inline char* const pszName(void) const { return ((char*)this) + sznameindex; }
|
|
int linktype;
|
|
int numlinks;
|
|
int linkindex;
|
|
inline mstudioiklink_t* pLink(int i) const { return (mstudioiklink_t*)(((byte*)this) + linkindex) + i; };
|
|
};
|
|
|
|
|
|
struct mstudioiface_t
|
|
{
|
|
unsigned short a, b, c;
|
|
};
|
|
|
|
|
|
struct mstudiomodel_t;
|
|
|
|
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;
|
|
|
|
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;
|
|
|
|
const mstudio_modelvertexdata_t* modelvertexdata;
|
|
|
|
int numLODVertexes[MAX_NUM_LODS];
|
|
};
|
|
|
|
struct mstudiomesh_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
int material;
|
|
|
|
int modelindex;
|
|
mstudiomodel_t* pModel() const;
|
|
|
|
int numvertices;
|
|
int vertexoffset;
|
|
|
|
const mstudio_meshvertexdata_t* GetVertexData(void* pModelData = NULL);
|
|
const thinModelVertices_t* GetThinVertexData(void* pModelData = NULL);
|
|
|
|
int numflexes;
|
|
int flexindex;
|
|
inline mstudioflex_t* pFlex(int i) const { return (mstudioflex_t*)(((byte*)this) + flexindex) + i; };
|
|
|
|
int materialtype;
|
|
int materialparam;
|
|
|
|
int meshid;
|
|
|
|
Vector center;
|
|
|
|
mstudio_meshvertexdata_t vertexdata;
|
|
|
|
int unused[8];
|
|
|
|
mstudiomesh_t() {}
|
|
private:
|
|
mstudiomesh_t(const mstudiomesh_t& vOther);
|
|
};
|
|
|
|
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; };
|
|
|
|
int numvertices;
|
|
int vertexindex;
|
|
int tangentsindex;
|
|
|
|
const vertexFileHeader_t* CacheVertexData(void* pModelData);
|
|
|
|
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];
|
|
};
|
|
|
|
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
|
|
{
|
|
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)
|
|
{
|
|
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)
|
|
{
|
|
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));
|
|
}
|
|
|
|
enum studiomeshgroupflags_t
|
|
{
|
|
MESHGROUP_IS_FLEXED = 0x1,
|
|
MESHGROUP_IS_HWSKINNED = 0x2,
|
|
MESHGROUP_IS_DELTA_FLEXED = 0x4
|
|
};
|
|
|
|
|
|
struct studiomeshgroup_t
|
|
{
|
|
IMesh* m_pMesh;
|
|
int m_NumStrips;
|
|
int m_Flags;
|
|
OptimizedModel::StripHeader_t* m_pStripData;
|
|
unsigned short* m_pGroupIndexToMeshIndex;
|
|
int m_NumVertices;
|
|
int* m_pUniqueTris;
|
|
unsigned short* m_pIndices;
|
|
bool m_MeshNeedsRestore;
|
|
short m_ColorMeshID;
|
|
IMorph* m_pMorph;
|
|
|
|
inline unsigned short MeshIndex(int i) const { return m_pGroupIndexToMeshIndex[m_pIndices[i]]; }
|
|
};
|
|
|
|
|
|
struct studiomeshdata_t
|
|
{
|
|
int m_NumGroup;
|
|
studiomeshgroup_t* m_pMeshGroup;
|
|
};
|
|
|
|
struct studioloddata_t
|
|
{
|
|
studiomeshdata_t* m_pMeshData;
|
|
float m_SwitchPoint;
|
|
int numMaterials;
|
|
IMaterial** ppMaterials;
|
|
int* pMaterialFlags;
|
|
|
|
int* m_pHWMorphDecalBoneRemap;
|
|
int m_nDecalBoneCount;
|
|
};
|
|
|
|
struct studiohwdata_t
|
|
{
|
|
int m_RootLOD;
|
|
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
|
|
{
|
|
if (!m_NumLODs)
|
|
return 0;
|
|
|
|
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 > lodMetric)
|
|
return i;
|
|
}
|
|
|
|
return numLODs - 1;
|
|
}
|
|
};
|
|
|
|
struct mstudiobodyparts_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
int sznameindex;
|
|
inline char* const pszName(void) const { return ((char*)this) + sznameindex; }
|
|
int nummodels;
|
|
int base;
|
|
int modelindex;
|
|
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:
|
|
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; };
|
|
};
|
|
|
|
|
|
struct mstudiosrcbonetransform_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
|
|
int sznameindex;
|
|
inline const char* pszName(void) const { return ((char*)this) + sznameindex; }
|
|
matrix3x4_t pretransform;
|
|
matrix3x4_t posttransform;
|
|
};
|
|
|
|
|
|
class virtualgroup_t
|
|
{
|
|
public:
|
|
virtualgroup_t(void) { cache = NULL; };
|
|
void* cache;
|
|
const studiohdr_t* GetStudioHdr(void) const;
|
|
|
|
CUtlVector< int > boneMap;
|
|
CUtlVector< int > masterBone;
|
|
CUtlVector< int > masterSeq;
|
|
CUtlVector< int > masterAnim;
|
|
CUtlVector< int > masterAttachment;
|
|
CUtlVector< int > masterPose;
|
|
CUtlVector< int > masterNode;
|
|
};
|
|
|
|
struct virtualsequence_t
|
|
{
|
|
#ifdef _XBOX
|
|
short flags;
|
|
short activity;
|
|
short group;
|
|
short index;
|
|
#else
|
|
int flags;
|
|
int activity;
|
|
int group;
|
|
int index;
|
|
#endif
|
|
};
|
|
|
|
struct virtualgeneric_t
|
|
{
|
|
#ifdef _XBOX
|
|
short group;
|
|
short index;
|
|
#else
|
|
int group;
|
|
int index;
|
|
#endif
|
|
};
|
|
|
|
|
|
struct virtualmodel_t
|
|
{
|
|
void AppendSequences(int group, const studiohdr_t* pStudioHdr);
|
|
void AppendAnimations(int group, const studiohdr_t* pStudioHdr);
|
|
void AppendAttachments(int ground, const studiohdr_t* pStudioHdr);
|
|
void AppendPoseParameters(int group, const studiohdr_t* pStudioHdr);
|
|
void AppendBonemap(int group, const studiohdr_t* pStudioHdr);
|
|
void AppendNodes(int group, const studiohdr_t* pStudioHdr);
|
|
void AppendTransitions(int group, const studiohdr_t* pStudioHdr);
|
|
void AppendIKLocks(int group, const studiohdr_t* pStudioHdr);
|
|
void AppendModels(int group, const studiohdr_t* pStudioHdr);
|
|
void UpdateAutoplaySequences(const studiohdr_t* pStudioHdr);
|
|
|
|
virtualgroup_t* pAnimGroup(int animation) { return &m_group[m_anim[animation].group]; }
|
|
virtualgroup_t* pSeqGroup(int sequence)
|
|
{
|
|
if ((unsigned)sequence >= (unsigned)m_seq.Count())
|
|
{
|
|
Assert(0);
|
|
return 0;
|
|
}
|
|
return &m_group[m_seq[sequence].group];
|
|
}
|
|
|
|
CThreadFastMutex m_Lock;
|
|
|
|
CUtlVector< virtualsequence_t > m_seq;
|
|
CUtlVector< virtualgeneric_t > m_anim;
|
|
CUtlVector< virtualgeneric_t > m_attachment;
|
|
CUtlVector< virtualgeneric_t > m_pose;
|
|
CUtlVector< virtualgroup_t > m_group;
|
|
CUtlVector< virtualgeneric_t > m_node;
|
|
CUtlVector< virtualgeneric_t > m_iklock;
|
|
CUtlVector< unsigned short > m_autoplaySequences;
|
|
};
|
|
|
|
struct thinModelVertices_t
|
|
{
|
|
void Init(int numBoneInfluences, Vector* positions, unsigned short* normals, float* boneWeights, char* 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;
|
|
char* 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* 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* pBaseWeight = m_boneWeights + vertIndex * numStoredWeights;
|
|
char* pBaseIndex = m_boneIndices + vertIndex * m_numBoneInfluences;
|
|
float sum = 0.0f;
|
|
for (int i = 0; i < MAX_NUM_BONES_PER_VERT; i++)
|
|
{
|
|
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;
|
|
}
|
|
|
|
pBoneWeights->numbones = m_numBoneInfluences ? m_numBoneInfluences : 1;
|
|
}
|
|
|
|
int m_numBoneInfluences;
|
|
float* m_boneWeights;
|
|
char* m_boneIndices;
|
|
Vector* m_vecPositions;
|
|
unsigned short* m_vecNormals;
|
|
};
|
|
|
|
#define MODEL_VERTEX_FILE_ID (('V'<<24)+('S'<<16)+('D'<<8)+'I')
|
|
#define MODEL_VERTEX_FILE_VERSION 4
|
|
#define MODEL_VERTEX_FILE_THIN_ID (('V'<<24)+('C'<<16)+('D'<<8)+'I')
|
|
|
|
struct vertexFileHeader_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
int id;
|
|
int version;
|
|
int checksum;
|
|
int numLODs;
|
|
int numLODVertexes[MAX_NUM_LODS];
|
|
int numFixups;
|
|
int fixupTableStart;
|
|
int vertexDataStart;
|
|
int tangentDataStart;
|
|
|
|
public:
|
|
|
|
const mstudiovertex_t* GetVertexData() const
|
|
{
|
|
if ((id == MODEL_VERTEX_FILE_ID) && (vertexDataStart != 0))
|
|
return (mstudiovertex_t*)(vertexDataStart + (byte*)this);
|
|
else
|
|
return NULL;
|
|
}
|
|
const Vector4D* GetTangentData() const
|
|
{
|
|
if ((id == MODEL_VERTEX_FILE_ID) && (tangentDataStart != 0))
|
|
return (Vector4D*)(tangentDataStart + (byte*)this);
|
|
else
|
|
return NULL;
|
|
}
|
|
const thinModelVertices_t* GetThinVertexData() const
|
|
{
|
|
if ((id == MODEL_VERTEX_FILE_THIN_ID) && (vertexDataStart != 0))
|
|
return (thinModelVertices_t*)(vertexDataStart + (byte*)this);
|
|
else
|
|
return NULL;
|
|
}
|
|
};
|
|
|
|
inline const mstudio_modelvertexdata_t* mstudiomodel_t::GetVertexData(void* pModelData)
|
|
{
|
|
const vertexFileHeader_t* pVertexHdr = CacheVertexData(pModelData);
|
|
if (!pVertexHdr)
|
|
{
|
|
vertexdata.pVertexData = NULL;
|
|
vertexdata.pTangentData = NULL;
|
|
return NULL;
|
|
}
|
|
|
|
vertexdata.pVertexData = pVertexHdr->GetVertexData();
|
|
vertexdata.pTangentData = pVertexHdr->GetTangentData();
|
|
|
|
if (!vertexdata.pVertexData)
|
|
return NULL;
|
|
|
|
return &vertexdata;
|
|
}
|
|
|
|
inline const thinModelVertices_t* mstudiomodel_t::GetThinVertexData(void* pModelData)
|
|
{
|
|
const vertexFileHeader_t* pVertexHdr = CacheVertexData(pModelData);
|
|
if (!pVertexHdr)
|
|
return NULL;
|
|
|
|
return pVertexHdr->GetThinVertexData();
|
|
}
|
|
|
|
struct vertexFileFixup_t
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
int lod;
|
|
int sourceVertexID;
|
|
int numVertexes;
|
|
};
|
|
|
|
#define STUDIOHDR_FLAGS_AUTOGENERATED_HITBOX 0x00000001
|
|
|
|
#define STUDIOHDR_FLAGS_USES_ENV_CUBEMAP 0x00000002
|
|
|
|
#define STUDIOHDR_FLAGS_FORCE_OPAQUE 0x00000004
|
|
|
|
#define STUDIOHDR_FLAGS_TRANSLUCENT_TWOPASS 0x00000008
|
|
|
|
#define STUDIOHDR_FLAGS_STATIC_PROP 0x00000010
|
|
|
|
#define STUDIOHDR_FLAGS_USES_FB_TEXTURE 0x00000020
|
|
|
|
#define STUDIOHDR_FLAGS_HASSHADOWLOD 0x00000040
|
|
|
|
#define STUDIOHDR_FLAGS_USES_BUMPMAPPING 0x00000080
|
|
|
|
#define STUDIOHDR_FLAGS_USE_SHADOWLOD_MATERIALS 0x00000100
|
|
|
|
#define STUDIOHDR_FLAGS_OBSOLETE 0x00000200
|
|
|
|
#define STUDIOHDR_FLAGS_UNUSED 0x00000400
|
|
|
|
#define STUDIOHDR_FLAGS_NO_FORCED_FADE 0x00000800
|
|
|
|
#define STUDIOHDR_FLAGS_FORCE_PHONEME_CROSSFADE 0x00001000
|
|
|
|
#define STUDIOHDR_FLAGS_CONSTANT_DIRECTIONAL_LIGHT_DOT 0x00002000
|
|
|
|
#define STUDIOHDR_FLAGS_FLEXES_CONVERTED 0x00004000
|
|
|
|
#define STUDIOHDR_FLAGS_BUILT_IN_PREVIEW_MODE 0x00008000
|
|
|
|
#define STUDIOHDR_FLAGS_AMBIENT_BOOST 0x00010000
|
|
|
|
#define STUDIOHDR_FLAGS_DO_NOT_CAST_SHADOWS 0x00020000
|
|
|
|
#define STUDIOHDR_FLAGS_CAST_TEXTURE_SHADOWS 0x00040000
|
|
|
|
|
|
#define STUDIOHDR_FLAGS_VERT_ANIM_FIXED_POINT_SCALE 0x00200000
|
|
|
|
struct studiohdr2_t
|
|
{
|
|
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; }
|
|
|
|
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
|
|
{
|
|
DECLARE_BYTESWAP_DATADESC();
|
|
int id;
|
|
int version;
|
|
int checksum;
|
|
inline const char* pszName(void) const { if (studiohdr2index && pStudioHdr2()->pszName()) return pStudioHdr2()->pszName(); else return name; }
|
|
char name[64];
|
|
int length;
|
|
Vector eyeposition;
|
|
Vector illumposition;
|
|
Vector hull_min;
|
|
Vector hull_max;
|
|
Vector view_bbmin;
|
|
Vector view_bbmax;
|
|
int flags;
|
|
int numbones;
|
|
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;
|
|
int RemapAnimBone(int iAnim, int iLocalBone) const;
|
|
int numbonecontrollers;
|
|
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;
|
|
|
|
mstudiohitboxset_t* pHitboxSet(int i) const
|
|
{
|
|
Assert(i >= 0 && i < numhitboxsets);
|
|
return (mstudiohitboxset_t*)(((byte*)this) + hitboxsetindex) + i;
|
|
};
|
|
|
|
inline mstudiobbox_t* pHitbox(int i, int set) const
|
|
{
|
|
mstudiohitboxset_t const* s = pHitboxSet(set);
|
|
if (!s)
|
|
return NULL;
|
|
|
|
return s->pHitbox(i);
|
|
};
|
|
|
|
inline int iHitboxCount(int set) const
|
|
{
|
|
mstudiohitboxset_t const* s = pHitboxSet(set);
|
|
if (!s)
|
|
return 0;
|
|
|
|
return s->numhitboxes;
|
|
};
|
|
|
|
|
|
int numlocalanim;
|
|
int localanimindex;
|
|
inline mstudioanimdesc_t* pLocalAnimdesc(int i) const { if (i < 0 || i >= numlocalanim) i = 0; return (mstudioanimdesc_t*)(((byte*)this) + localanimindex) + i; };
|
|
|
|
int numlocalseq;
|
|
int localseqindex;
|
|
inline mstudioseqdesc_t* pLocalSeqdesc(int i) const { if (i < 0 || i >= numlocalseq) i = 0; return (mstudioseqdesc_t*)(((byte*)this) + localseqindex) + i; };
|
|
|
|
bool SequencesAvailable() const;
|
|
int GetNumSeq() const;
|
|
mstudioanimdesc_t& pAnimdesc(int i) const;
|
|
mstudioseqdesc_t& pSeqdesc(int i) const;
|
|
int iRelativeAnim(int baseseq, int relanim) const;
|
|
int iRelativeSeq(int baseseq, int relseq) const;
|
|
|
|
mutable int activitylistversion;
|
|
mutable int eventsindexed;
|
|
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);
|
|
|
|
int numtextures;
|
|
int textureindex;
|
|
inline mstudiotexture_t* pTexture(int i) const { Assert(i >= 0 && i < numtextures); return (mstudiotexture_t*)(((byte*)this) + textureindex) + i; };
|
|
|
|
|
|
int numcdtextures;
|
|
int cdtextureindex;
|
|
inline char* pCdtexture(int i) const { return (((char*)this) + *((int*)(((byte*)this) + cdtextureindex) + i)); };
|
|
|
|
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; };
|
|
|
|
int numlocalattachments;
|
|
int localattachmentindex;
|
|
inline mstudioattachment_t* pLocalAttachment(int i) const { Assert(i >= 0 && i < numlocalattachments); return (mstudioattachment_t*)(((byte*)this) + localattachmentindex) + i; };
|
|
int GetNumAttachments(void) const;
|
|
const mstudioattachment_t& pAttachment(int i) const;
|
|
int GetAttachmentBone(int i);
|
|
void SetAttachmentBone(int iAttachment, int iBone);
|
|
|
|
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; };
|
|
|
|
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(numflexcontrollers == 0 || (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; };
|
|
|
|
int numlocalposeparameters;
|
|
int localposeparamindex;
|
|
inline mstudioposeparamdesc_t* pLocalPoseParameter(int i) const { Assert(i >= 0 && i < numlocalposeparameters); return (mstudioposeparamdesc_t*)(((byte*)this) + localposeparamindex) + i; };
|
|
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; }
|
|
|
|
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;
|
|
|
|
float mass;
|
|
int contents;
|
|
|
|
int numincludemodels;
|
|
int includemodelindex;
|
|
inline mstudiomodelgroup_t* pModelGroup(int i) const { Assert(i >= 0 && i < numincludemodels); return (mstudiomodelgroup_t*)(((byte*)this) + includemodelindex) + i; };
|
|
const studiohdr_t* FindModel(void** cache, char const* modelname) const;
|
|
|
|
mutable void* virtualModel;
|
|
virtualmodel_t* GetVirtualModel(void) const;
|
|
|
|
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) const;
|
|
|
|
int bonetablebynameindex;
|
|
inline const byte* GetBoneTableSortedByName() const { return (byte*)this + bonetablebynameindex; }
|
|
|
|
void* pVertexBase;
|
|
void* pIndexBase;
|
|
|
|
byte constdirectionallightdot;
|
|
|
|
byte rootLOD;
|
|
|
|
byte numAllowedRootLODs;
|
|
|
|
byte unused[1];
|
|
|
|
int unused4;
|
|
|
|
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; }
|
|
|
|
int unused3[1];
|
|
|
|
int studiohdr2index;
|
|
studiohdr2_t* pStudioHdr2() const { return (studiohdr2_t*)(((byte*)this) + studiohdr2index); }
|
|
|
|
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; }
|
|
|
|
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; }
|
|
|
|
int unused2[1];
|
|
|
|
studiohdr_t() {}
|
|
|
|
private:
|
|
studiohdr_t(const studiohdr_t& vOther);
|
|
|
|
friend struct virtualmodel_t;
|
|
};
|
|
|
|
|
|
|
|
class IDataCache;
|
|
class IMDLCache;
|
|
|
|
class CStudioHdr
|
|
{
|
|
public:
|
|
CStudioHdr(void);
|
|
CStudioHdr(const studiohdr_t* pStudioHdr, IMDLCache* mdlcache = NULL);
|
|
~CStudioHdr() { Term(); }
|
|
|
|
void Init(const studiohdr_t* pStudioHdr, IMDLCache* 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* > m_pStudioHdrCache;
|
|
|
|
mutable int m_nFrameUnlockCounter;
|
|
int* m_pFrameUnlockCounter;
|
|
CThreadFastMutex 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;
|
|
int RemapSeqBone(int iSequence, int iLocalBone) const;
|
|
|
|
bool SequencesAvailable() const;
|
|
int GetNumSeq(void) const;
|
|
mstudioanimdesc_t& pAnimdesc(int i);
|
|
mstudioseqdesc_t& pSeqdesc(int iSequence);
|
|
int iRelativeAnim(int baseseq, int relanim) const;
|
|
int iRelativeSeq(int baseseq, int relseq) const;
|
|
|
|
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);
|
|
void SetAttachmentBone(int iAttachment, int iBone);
|
|
|
|
int EntryNode(int iSequence);
|
|
int ExitNode(int iSequence);
|
|
char* pszNodeName(int iNode);
|
|
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* 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 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; };
|
|
inline Vector hull_max() const { return m_pStudioHdr->hull_max; };
|
|
|
|
inline Vector view_bbmin() const { return m_pStudioHdr->view_bbmin; };
|
|
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); }
|
|
|
|
inline float VertAnimFixedPointScale() const { return m_pStudioHdr->VertAnimFixedPointScale(); }
|
|
|
|
public:
|
|
int IsSequenceLooping(int iSequence);
|
|
float GetSequenceCycleRate(int iSequence);
|
|
|
|
void RunFlexRules(const float* src, float* dest);
|
|
|
|
|
|
public:
|
|
inline int boneFlags(int iBone) const { return m_boneFlags[iBone]; }
|
|
inline int boneParent(int iBone) const { return m_boneParent[iBone]; }
|
|
|
|
private:
|
|
CUtlVector< int > m_boneFlags;
|
|
CUtlVector< int > m_boneParent;
|
|
|
|
public:
|
|
|
|
class CActivityToSequenceMapping
|
|
{
|
|
public:
|
|
struct SequenceTuple
|
|
{
|
|
short seqnum;
|
|
short weight;
|
|
CUtlSymbol* pActivityModifiers;
|
|
int iNumActivityModifiers;
|
|
};
|
|
|
|
struct HashValueType
|
|
{
|
|
int activityIdx;
|
|
|
|
int startingIdx;
|
|
int count;
|
|
int totalWeight;
|
|
|
|
HashValueType(int _actIdx, int _stIdx, int _ct, int _tW) :
|
|
activityIdx(_actIdx), startingIdx(_stIdx), count(_ct), totalWeight(_tW) {}
|
|
|
|
HashValueType() : activityIdx(-1), startingIdx(-1), count(-1), totalWeight(-1)
|
|
{
|
|
AssertMsg(false, "Don't use default HashValueType()!");
|
|
}
|
|
|
|
|
|
class HashFuncs
|
|
{
|
|
public:
|
|
HashFuncs(int) {}
|
|
|
|
bool operator()(const HashValueType& lhs, const HashValueType& rhs) const
|
|
{
|
|
return lhs.activityIdx == rhs.activityIdx;
|
|
}
|
|
|
|
unsigned int operator()(const HashValueType& item) const
|
|
{
|
|
return HashInt(item.activityIdx);
|
|
}
|
|
};
|
|
};
|
|
|
|
typedef CUtlHash<HashValueType, HashValueType::HashFuncs, HashValueType::HashFuncs> ActivityToValueIdxHash;
|
|
|
|
CActivityToSequenceMapping(void)
|
|
: m_pSequenceTuples(NULL), m_iSequenceTuplesCount(0), m_ActToSeqHash(8, 0, 0), m_expectedPStudioHdr(NULL), m_expectedVModel(NULL)
|
|
#if STUDIO_SEQUENCE_ACTIVITY_LAZY_INITIALIZE
|
|
, m_bIsInitialized(false)
|
|
#endif
|
|
{};
|
|
|
|
~CActivityToSequenceMapping()
|
|
{
|
|
if (m_pSequenceTuples != NULL)
|
|
{
|
|
if (m_pSequenceTuples->pActivityModifiers != NULL)
|
|
{
|
|
delete[] m_pSequenceTuples->pActivityModifiers;
|
|
}
|
|
delete[] m_pSequenceTuples;
|
|
}
|
|
}
|
|
|
|
const SequenceTuple* GetSequences(int forActivity, int* outSequenceCount, int* outTotalWeight);
|
|
|
|
int NumSequencesForActivity(int forActivity);
|
|
|
|
#if STUDIO_SEQUENCE_ACTIVITY_LAZY_INITIALIZE
|
|
inline bool IsInitialized(void) { return m_bIsInitialized; }
|
|
#endif
|
|
|
|
private:
|
|
|
|
void Initialize(CStudioHdr* pstudiohdr);
|
|
|
|
void Reinitialize(CStudioHdr* pstudiohdr);
|
|
|
|
int SelectWeightedSequence(CStudioHdr* pstudiohdr, int activity, int curSequence);
|
|
|
|
int SelectWeightedSequenceFromModifiers(CStudioHdr* pstudiohdr, int activity, CUtlSymbol* pActivityModifiers, int iModifierCount);
|
|
|
|
SequenceTuple* m_pSequenceTuples;
|
|
unsigned int m_iSequenceTuplesCount;
|
|
#if STUDIO_SEQUENCE_ACTIVITY_LAZY_INITIALIZE
|
|
bool m_bIsInitialized;
|
|
#endif
|
|
|
|
ActivityToValueIdxHash m_ActToSeqHash;
|
|
|
|
const void* m_expectedPStudioHdr;
|
|
const void* m_expectedVModel;
|
|
|
|
bool ValidateAgainst(const CStudioHdr* RESTRICT pstudiohdr);
|
|
void SetValidationPair(const CStudioHdr* RESTRICT pstudiohdr);
|
|
|
|
friend class CStudioHdr;
|
|
};
|
|
|
|
CActivityToSequenceMapping m_ActivityToSequence;
|
|
|
|
inline int SelectWeightedSequence(int activity, int curSequence)
|
|
{
|
|
#if STUDIO_SEQUENCE_ACTIVITY_LAZY_INITIALIZE
|
|
if (!m_ActivityToSequence.IsInitialized())
|
|
{
|
|
m_ActivityToSequence.Initialize(this);
|
|
}
|
|
#endif
|
|
return m_ActivityToSequence.SelectWeightedSequence(this, activity, curSequence);
|
|
}
|
|
|
|
inline int SelectWeightedSequenceFromModifiers(int activity, CUtlSymbol* pActivityModifiers, int iModifierCount)
|
|
{
|
|
#if STUDIO_SEQUENCE_ACTIVITY_LAZY_INITIALIZE
|
|
if (!m_ActivityToSequence.IsInitialized())
|
|
{
|
|
m_ActivityToSequence.Initialize(this);
|
|
}
|
|
#endif
|
|
return m_ActivityToSequence.SelectWeightedSequenceFromModifiers(this, activity, pActivityModifiers, iModifierCount);
|
|
}
|
|
|
|
inline bool HaveSequenceForActivity(int activity)
|
|
{
|
|
#if STUDIO_SEQUENCE_ACTIVITY_LAZY_INITIALIZE
|
|
if (!m_ActivityToSequence.IsInitialized())
|
|
{
|
|
m_ActivityToSequence.Initialize(this);
|
|
}
|
|
#endif
|
|
return (m_ActivityToSequence.NumSequencesForActivity(activity) > 0);
|
|
}
|
|
|
|
inline void ReinitializeSequenceMapping(void)
|
|
{
|
|
m_ActivityToSequence.Reinitialize(this);
|
|
}
|
|
|
|
#ifdef STUDIO_ENABLE_PERF_COUNTERS
|
|
public:
|
|
inline void ClearPerfCounters(void)
|
|
{
|
|
m_nPerfAnimatedBones = 0;
|
|
m_nPerfUsedBones = 0;
|
|
m_nPerfAnimationLayers = 0;
|
|
};
|
|
|
|
mutable int m_nPerfAnimatedBones;
|
|
mutable int m_nPerfUsedBones;
|
|
mutable int m_nPerfAnimationLayers;
|
|
#endif
|
|
|
|
|
|
};
|
|
|
|
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);
|
|
}
|
|
|
|
int obsolete1;
|
|
|
|
int numsettings;
|
|
int index;
|
|
|
|
int obsolete2;
|
|
|
|
int settingindex;
|
|
|
|
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;
|
|
|
|
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);
|
|
}
|
|
|
|
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); };
|
|
};
|
|
|
|
inline int flexsetting_t::psetting(byte* base, int i, flexweight_t** weights) const
|
|
{
|
|
*weights = (flexweight_t*)(((byte*)this) + settingindex) + i;
|
|
return numsettings;
|
|
};
|
|
|
|
|
|
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
|
|
#define STUDIO_FETCH1 2
|
|
#define STUDIO_FETCH2 3
|
|
#define STUDIO_ADD 4
|
|
#define STUDIO_SUB 5
|
|
#define STUDIO_MUL 6
|
|
#define STUDIO_DIV 7
|
|
#define STUDIO_NEG 8
|
|
#define STUDIO_EXP 9
|
|
#define STUDIO_OPEN 10
|
|
#define STUDIO_CLOSE 11
|
|
#define STUDIO_COMMA 12
|
|
#define STUDIO_MAX 13
|
|
#define STUDIO_MIN 14
|
|
#define STUDIO_2WAY_0 15
|
|
#define STUDIO_2WAY_1 16
|
|
#define STUDIO_NWAY 17
|
|
#define STUDIO_COMBO 18
|
|
#define STUDIO_DOMINATE 19
|
|
#define STUDIO_DME_LOWER_EYELID 20
|
|
#define STUDIO_DME_UPPER_EYELID 21
|
|
|
|
#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
|
|
|
|
#define STUDIO_LOOPING 0x0001
|
|
#define STUDIO_SNAP 0x0002
|
|
#define STUDIO_DELTA 0x0004
|
|
#define STUDIO_AUTOPLAY 0x0008
|
|
#define STUDIO_POST 0x0010
|
|
#define STUDIO_ALLZEROS 0x0020
|
|
#define STUDIO_CYCLEPOSE 0x0080
|
|
#define STUDIO_REALTIME 0x0100
|
|
#define STUDIO_LOCAL 0x0200
|
|
#define STUDIO_HIDDEN 0x0400
|
|
#define STUDIO_OVERRIDE 0x0800
|
|
#define STUDIO_ACTIVITY 0x1000
|
|
#define STUDIO_EVENT 0x2000
|
|
#define STUDIO_WORLD 0x4000
|
|
#define STUDIO_AL_POST 0x0010
|
|
#define STUDIO_AL_SPLINE 0x0040
|
|
#define STUDIO_AL_XFADE 0x0080
|
|
#define STUDIO_AL_NOBLEND 0x0200
|
|
#define STUDIO_AL_LOCAL 0x1000
|
|
#define STUDIO_AL_POSE 0x4000
|
|
|
|
|
|
inline bool Studio_ConvertStudioHdrToNewVersion(studiohdr_t* pStudioHdr)
|
|
{
|
|
COMPILE_TIME_ASSERT(STUDIO_VERSION == 48);
|
|
|
|
int version = pStudioHdr->version;
|
|
if (version == STUDIO_VERSION)
|
|
return true;
|
|
|
|
bool bResult = true;
|
|
if (version < 46)
|
|
{
|
|
for (int i = 0; i < pStudioHdr->numlocalanim; i++)
|
|
{
|
|
mstudioanimdesc_t* pAnim = (mstudioanimdesc_t*)pStudioHdr->pLocalAnimdesc(i);
|
|
|
|
if (pAnim->sectionframes != 0)
|
|
{
|
|
memset(&(pAnim->numframes), 0, (byte*)(pAnim + 1) - (byte*)&(pAnim->numframes));
|
|
|
|
pAnim->numframes = 1;
|
|
pAnim->animblock = -1;
|
|
bResult = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (version < 47)
|
|
{
|
|
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)
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
pStudioHdr->version = STUDIO_VERSION;
|
|
|
|
return bResult;
|
|
}
|
|
|
|
inline void Studio_SetRootLOD(studiohdr_t* pStudioHdr, int rootLOD)
|
|
{
|
|
if (pStudioHdr->numAllowedRootLODs > 0 &&
|
|
rootLOD >= pStudioHdr->numAllowedRootLODs)
|
|
{
|
|
rootLOD = pStudioHdr->numAllowedRootLODs - 1;
|
|
}
|
|
|
|
Assert(rootLOD >= 0 && rootLOD < MAX_NUM_LODS);
|
|
Clamp(rootLOD, 0, MAX_NUM_LODS - 1);
|
|
|
|
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);
|
|
|
|
pMesh->numvertices = pMesh->vertexdata.numLODVertexes[rootLOD];
|
|
pMesh->vertexoffset = totalMeshVertexes;
|
|
totalMeshVertexes += pMesh->numvertices;
|
|
}
|
|
|
|
pModel->numvertices = totalMeshVertexes;
|
|
pModel->vertexindex = vertexindex;
|
|
pModel->tangentsindex = tangentsindex;
|
|
|
|
vertexindex += totalMeshVertexes * sizeof(mstudiovertex_t);
|
|
tangentsindex += totalMeshVertexes * sizeof(Vector4D);
|
|
}
|
|
}
|
|
|
|
pStudioHdr->rootLOD = rootLOD;
|
|
}
|
|
|
|
inline int Studio_VertexDataSize(const vertexFileHeader_t* pVvdHdr, int rootLOD, bool bNeedsTangentS)
|
|
{
|
|
int numVertexes = pVvdHdr->numLODVertexes[rootLOD] + 1;
|
|
int dataLength = pVvdHdr->vertexDataStart + numVertexes * sizeof(mstudiovertex_t);
|
|
if (bNeedsTangentS)
|
|
{
|
|
dataLength += numVertexes * sizeof(Vector4D);
|
|
}
|
|
|
|
return dataLength;
|
|
}
|
|
|
|
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];
|
|
|
|
memcpy((void*)pNewVvdHdr, (void*)pTempVvdHdr, pTempVvdHdr->vertexDataStart);
|
|
|
|
for (i = 0; i < rootLOD; i++)
|
|
{
|
|
pNewVvdHdr->numLODVertexes[i] = pNewVvdHdr->numLODVertexes[rootLOD];
|
|
}
|
|
|
|
if (bNeedsTangentS)
|
|
{
|
|
pNewVvdHdr->tangentDataStart = pNewVvdHdr->vertexDataStart + numVertexes * sizeof(mstudiovertex_t);
|
|
}
|
|
else
|
|
{
|
|
pNewVvdHdr->tangentDataStart = 0;
|
|
}
|
|
|
|
if (!pNewVvdHdr->numFixups)
|
|
{
|
|
memcpy(
|
|
(byte*)pNewVvdHdr + pNewVvdHdr->vertexDataStart,
|
|
(byte*)pTempVvdHdr + pTempVvdHdr->vertexDataStart,
|
|
numVertexes * sizeof(mstudiovertex_t));
|
|
|
|
if (bNeedsTangentS)
|
|
{
|
|
memcpy(
|
|
(byte*)pNewVvdHdr + pNewVvdHdr->tangentDataStart,
|
|
(byte*)pTempVvdHdr + pTempVvdHdr->tangentDataStart,
|
|
numVertexes * sizeof(Vector4D));
|
|
}
|
|
|
|
return numVertexes;
|
|
}
|
|
|
|
target = 0;
|
|
pFixupTable = (vertexFileFixup_t*)((byte*)pTempVvdHdr + pTempVvdHdr->fixupTableStart);
|
|
for (i = 0; i < pTempVvdHdr->numFixups; i++)
|
|
{
|
|
if (pFixupTable[i].lod < rootLOD)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
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)
|
|
{
|
|
memcpy(
|
|
(Vector4D*)((byte*)pNewVvdHdr + pNewVvdHdr->tangentDataStart) + target,
|
|
(Vector4D*)((byte*)pTempVvdHdr + pTempVvdHdr->tangentDataStart) + pFixupTable[i].sourceVertexID,
|
|
pFixupTable[i].numVertexes * sizeof(Vector4D));
|
|
}
|
|
|
|
target += pFixupTable[i].numVertexes;
|
|
}
|
|
|
|
pNewVvdHdr->numFixups = 0;
|
|
|
|
return target;
|
|
}
|
|
|
|
#endif |