Backups/hl2sdk
1
0
Fork 0
mirror of https://github.com/alliedmodders/hl2sdk.git synced 2025-09-19 03:56:10 +08:00
Code Activity

SDK sync.

Browse Source
This commit is contained in:
Nicholas Hastings
2014-02-28 14:08:09 -05:00
parent 7cc1bd2f96
commit e2781a0000
558 changed files with 39082 additions and 1463 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
public/VGuiMatSurface/IMatSystemSurface.h
View File

@ -105,6 +105,10 @@ public:
// Gets a material bound to a surface texture ID
virtual IMaterial *DrawGetTextureMaterial( int id ) = 0;
// The matching method is in ISurface, but we can't add anything there and remain mod-compatible.
// So this goes here instead.
virtual void GetFullscreenViewportAndRenderTarget( int & x, int & y, int & w, int & h, ITexture **ppRenderTarget ) = 0;
};

10
public/XUnzip.cpp
View File

@ -4476,15 +4476,7 @@ bool SafeUnzipMemory( const void *pvZipped, int cubZipped, void *pvDest, int cub
int iRes = ZR_CORRUPT;
if ( hZip )
{
try
{
iRes = UnzipItem( hZip, 0, pvDest, cubDest, ZIP_MEMORY );
}
catch ( ... )
{
// failed to unzip, try to continue
iRes = ZR_CORRUPT;
}
iRes = UnzipItem( hZip, 0, pvDest, cubDest, ZIP_MEMORY );
CloseZip( hZip );
}

30
public/bone_setup.cpp
View File

@ -678,6 +678,12 @@ static void CalcLocalHierarchyAnimation(
int boneMask
)
{
#ifdef STAGING_ONLY
Assert( iNewParent == -1 || (iNewParent >= 0 && iNewParent < MAXSTUDIOBONES) );
Assert( iBone > 0 );
Assert( iBone < MAXSTUDIOBONES );
#endif // STAGING_ONLY
Vector localPos;
Quaternion localQ;
@ -715,12 +721,19 @@ static void CalcLocalHierarchyAnimation(
CalcDecompressedAnimation( pHierarchy->pLocalAnim(), iFrame - pHierarchy->iStart, flFraq, localPos, localQ );
BuildBoneChain( pStudioHdr, rootXform, pos, q, iBone, boneToWorld, boneComputed );
BuildBoneChain( pStudioHdr, rootXform, pos, q, iNewParent, boneToWorld, boneComputed );
matrix3x4_t localXform;
AngleMatrix( localQ, localPos, localXform );
ConcatTransforms( boneToWorld[iNewParent], localXform, boneToWorld[iBone] );
if ( iNewParent != -1 )
{
BuildBoneChain( pStudioHdr, rootXform, pos, q, iNewParent, boneToWorld, boneComputed );
ConcatTransforms( boneToWorld[iNewParent], localXform, boneToWorld[iBone] );
}
else
{
boneToWorld[iBone] = localXform;
}
// back solve
Vector p1;
@ -995,10 +1008,17 @@ static void CalcVirtualAnimation( virtualmodel_t *pVModel, const CStudioHdr *pSt
int iBone = pAnimGroup->masterBone[pHierarchy->iBone];
if (iBone >= 0 && (pStudioHdr->boneFlags(iBone) & boneMask))
{
int iNewParent = pAnimGroup->masterBone[pHierarchy->iNewParent];
if (iNewParent >= 0 && (pStudioHdr->boneFlags(iNewParent) & boneMask))
if ( pHierarchy->iNewParent != -1 )
{
CalcLocalHierarchyAnimation( pStudioHdr, boneToWorld, boneComputed, pos, q, pbone, pHierarchy, iBone, iNewParent, cycle, iFrame, s, boneMask );
int iNewParent = pAnimGroup->masterBone[pHierarchy->iNewParent];
if (iNewParent >= 0 && (pStudioHdr->boneFlags(iNewParent) & boneMask))
{
CalcLocalHierarchyAnimation( pStudioHdr, boneToWorld, boneComputed, pos, q, pbone, pHierarchy, iBone, iNewParent, cycle, iFrame, s, boneMask );
}
}
else
{
CalcLocalHierarchyAnimation( pStudioHdr, boneToWorld, boneComputed, pos, q, pbone, pHierarchy, iBone, -1, cycle, iFrame, s, boneMask );
}
}
}

2
public/bone_setup.h
View File

@ -444,4 +444,6 @@ void QuaternionMA( const Quaternion &p, float s, const Quaternion &q, Quaternion
bool Studio_PrefetchSequence( const CStudioHdr *pStudioHdr, int iSequence );
void Studio_RunBoneFlexDrivers( float *pFlexController, const CStudioHdr *pStudioHdr, const Vector *pPositions, const matrix3x4_t *pBoneToWorld, const matrix3x4_t &mRootToWorld );
#endif // BONE_SETUP_H

64
public/filesystem_init.cpp
View File

@ -224,6 +224,7 @@ CFSSearchPathsInit::CFSSearchPathsInit()
m_pDirectoryName = NULL;
m_pLanguage = NULL;
m_ModPath[0] = 0;
m_bMountHDContent = m_bLowViolence = false;
}
@ -460,52 +461,6 @@ FSReturnCode_t LoadGameInfoFile(
return FS_OK;
}
// checks the registry for the low violence setting
// Check "HKEY_CURRENT_USER\Software\Valve\Source\Settings" and "User Token 2" or "User Token 3"
bool IsLowViolenceBuild( void )
{
#if defined(_WIN32)
HKEY hKey;
char szValue[64];
unsigned long len = sizeof(szValue) - 1;
bool retVal = false;
if ( IsPC() && RegOpenKeyEx( HKEY_CURRENT_USER, "Software\\Valve\\Source\\Settings", NULL, KEY_READ, &hKey) == ERROR_SUCCESS )
{
// User Token 2
if ( RegQueryValueEx( hKey, "User Token 2", NULL, NULL, (unsigned char*)szValue, &len ) == ERROR_SUCCESS )
{
if ( Q_strlen( szValue ) > 0 )
{
retVal = true;
}
}
if ( !retVal )
{
// reset "len" for the next check
len = sizeof(szValue) - 1;
// User Token 3
if ( RegQueryValueEx( hKey, "User Token 3", NULL, NULL, (unsigned char*)szValue, &len ) == ERROR_SUCCESS )
{
if ( Q_strlen( szValue ) > 0 )
{
retVal = true;
}
}
}
RegCloseKey(hKey);
}
return retVal;
#elif POSIX
return false;
#else
#error "Fix me"
#endif
}
static void FileSystem_AddLoadedSearchPath(
CFSSearchPathsInit &initInfo,
@ -519,13 +474,26 @@ static void FileSystem_AddLoadedSearchPath(
{
// Not in LV build, don't mount
if ( !bLowViolence )
if ( !initInfo.m_bLowViolence )
return;
// Mount, as a game path
pPathID = "game";
}
// Check for mounting HD game content if enabled
if ( V_stricmp( pPathID, "game_hd" ) == 0 )
{
// Not in LV build, don't mount
if ( !initInfo.m_bMountHDContent )
return;
// Mount, as a game path
pPathID = "game";
}
// Special processing for ordinary game folders
if ( V_stristr( fullLocationPath, ".vpk" ) == NULL && Q_stricmp( pPathID, "game" ) == 0 )
{
@ -600,7 +568,7 @@ FSReturnCode_t FileSystem_LoadSearchPaths( CFSSearchPathsInit &initInfo )
}
}
bool bLowViolence = IsLowViolenceBuild();
bool bLowViolence = initInfo.m_bLowViolence;
for ( KeyValues *pCur=pSearchPaths->GetFirstValue(); pCur; pCur=pCur->GetNextValue() )
{
const char *pLocation = pCur->GetString();

3
public/filesystem_init.h
View File

@ -156,6 +156,9 @@ public:
// This is the filesystem FileSystem_LoadSearchPaths is talking to.
IFileSystem *m_pFileSystem;
bool m_bMountHDContent;
bool m_bLowViolence;
// Outputs.
public:
// This is the location of the first search path called "game", which also becomes your "mod" search path.

15
public/materialsystem/imaterialsystem.h
View File

@ -524,7 +524,8 @@ enum RenderTargetSizeMode_t
RT_SIZE_FULL_FRAME_BUFFER=4, // Same size as frame buffer, or next lower power of 2 if we can't do that.
RT_SIZE_OFFSCREEN=5, // Target of specified size, don't mess with dimensions
RT_SIZE_FULL_FRAME_BUFFER_ROUNDED_UP=6, // Same size as the frame buffer, rounded up if necessary for systems that can't do non-power of two textures.
RT_SIZE_REPLAY_SCREENSHOT = 7 // Rounded down to power of 2, essentially...
RT_SIZE_REPLAY_SCREENSHOT = 7, // Rounded down to power of 2, essentially...
RT_SIZE_LITERAL = 8 // Use the size passed in. Don't clamp it to the frame buffer size. Really.
};
typedef void (*MaterialBufferReleaseFunc_t)( );
@ -1028,6 +1029,16 @@ public:
#ifdef DX_TO_GL_ABSTRACTION
virtual void DoStartupShaderPreloading( void ) = 0;
#endif
// Sets the override sizes for all render target size tests. These replace the frame buffer size.
// Set them when you are rendering primarily to something larger than the frame buffer (as in VR mode).
virtual void SetRenderTargetFrameBufferSizeOverrides( int nWidth, int nHeight ) = 0;
// Returns the (possibly overridden) framebuffer size for render target sizing.
virtual void GetRenderTargetFrameBufferDimensions( int & nWidth, int & nHeight ) = 0;
// returns the display device name that matches the adapter index we were started with
virtual char *GetDisplayDeviceName() const = 0;
};
@ -1482,7 +1493,7 @@ public:
// Returns whether a pointer is render data. NOTE: passing NULL returns true
virtual bool IsRenderData( const void *pData ) const = 0;
virtual void PrintfVA( char *fmt, va_list vargs ) = 0;
virtual void Printf( PRINTF_FORMAT_STRING char *fmt, ... ) = 0;
virtual void Printf( PRINTF_FORMAT_STRING const char *fmt, ... ) = 0;
virtual float Knob( char *knobname, float *setvalue = NULL ) = 0;
// Allows us to override the alpha write setting of a material
virtual void OverrideAlphaWriteEnable( bool bEnable, bool bAlphaWriteEnable ) = 0;

7
public/materialsystem/materialsystem_config.h
View File

@ -33,6 +33,7 @@ enum MaterialSystem_Config_Flags_t
MATSYS_VIDCFG_FLAGS_SCALE_TO_OUTPUT_RESOLUTION = ( 1 << 14 ),
MATSYS_VIDCFG_FLAGS_USING_MULTIPLE_WINDOWS = ( 1 << 15 ),
MATSYS_VIDCFG_FLAGS_DISABLE_PHONG = ( 1 << 16 ),
MATSYS_VIDCFG_FLAGS_VR_MODE = ( 1 << 17 ),
};
struct MaterialSystemHardwareIdentifier_t
@ -64,6 +65,7 @@ struct MaterialSystem_Config_t
bool ScaleToOutputResolution() const { return ( m_Flags & MATSYS_VIDCFG_FLAGS_SCALE_TO_OUTPUT_RESOLUTION ) != 0; }
bool UsingMultipleWindows() const { return ( m_Flags & MATSYS_VIDCFG_FLAGS_USING_MULTIPLE_WINDOWS ) != 0; }
bool UsePhong() const { return ( m_Flags & MATSYS_VIDCFG_FLAGS_DISABLE_PHONG ) == 0; }
bool VRMode() const { return ( m_Flags & MATSYS_VIDCFG_FLAGS_VR_MODE) != 0; }
bool ShadowDepthTexture() const { return m_bShadowDepthTexture; }
bool MotionBlur() const { return m_bMotionBlur; }
bool SupportFlashlight() const { return m_bSupportFlashlight; }
@ -140,6 +142,8 @@ struct MaterialSystem_Config_t
bool m_bMotionBlur;
bool m_bSupportFlashlight;
int m_nVRModeAdapter;
MaterialSystem_Config_t()
{
memset( this, 0, sizeof( *this ) );
@ -160,6 +164,7 @@ struct MaterialSystem_Config_t
SetFlag( MATSYS_VIDCFG_FLAGS_SCALE_TO_OUTPUT_RESOLUTION, false );
SetFlag( MATSYS_VIDCFG_FLAGS_USING_MULTIPLE_WINDOWS, false );
SetFlag( MATSYS_VIDCFG_FLAGS_DISABLE_PHONG, false );
SetFlag( MATSYS_VIDCFG_FLAGS_VR_MODE, false );
m_VideoMode.m_Width = 640;
m_VideoMode.m_Height = 480;
@ -182,6 +187,8 @@ struct MaterialSystem_Config_t
m_bMotionBlur = false;
m_bSupportFlashlight = true;
m_nVRModeAdapter = -1;
// misc defaults
bAllowCheats = false;
bCompressedTextures = true;

2
public/mathlib/vector.h
View File

@ -1187,7 +1187,7 @@ inline Vector &AllocTempVector()
}
ThreadPause();
}
return s_vecTemp[nIndex & 0xffff];
return s_vecTemp[nIndex];
}

3
public/mathlib/vmatrix.h
View File

@ -200,6 +200,9 @@ public:
// Setup a matrix for origin and angles.
void SetupMatrixOrgAngles( const Vector &origin, const QAngle &vAngles );
// Setup a matrix for angles and no translation.
void SetupMatrixAngles( const QAngle &vAngles );
// General inverse. This may fail so check the return!
bool InverseGeneral(VMatrix &vInverse) const;

8
public/matsys_controls/mdlpanel.h
View File

@ -51,6 +51,8 @@ public:
virtual void OnTick();
virtual void Paint();
// Sets the current mdl
virtual void SetMDL( MDLHandle_t handle, void *pProxyData = NULL );
virtual void SetMDL( const char *pMDLName, void *pProxyData = NULL );
@ -78,6 +80,7 @@ public:
void SetSkin( int nSkin );
void SetLookAtCamera( bool bLookAtCamera );
void SetIgnoreDoubleClick( bool bState );
void SetThumbnailSafeZone( bool bVisible );
// Bounds.
bool GetBoundingBox( Vector &vecBoundsMin, Vector &vecBoundsMax );
@ -103,6 +106,8 @@ public:
protected:
virtual void SetupRenderState( int nDisplayWidth, int nDisplayHeight ) OVERRIDE;
struct MDLData_t
{
CMDL m_MDL;
@ -122,7 +127,7 @@ protected:
private:
// paint it!
void OnPaint3D();
virtual void OnPaint3D();
virtual void PrePaint3D( IMatRenderContext *pRenderContext ) { };
virtual void PostPaint3D( IMatRenderContext *pRenderContext ) { };
virtual void RenderingMergedModel( IMatRenderContext *pRenderContext, CStudioHdr *pStudioHdr, MDLHandle_t mdlHandle, matrix3x4_t *pWorldMatrix ) { };
@ -141,6 +146,7 @@ private:
bool m_bWireFrame : 1;
bool m_bLookAtCamera : 1;
bool m_bIgnoreDoubleClick : 1;
bool m_bThumbnailSafeZone : 1;
float m_PoseParameters[ MAXSTUDIOPOSEPARAM ];
};

1
public/matsys_controls/mdlpicker.h
View File

@ -101,6 +101,7 @@ private:
void WriteBackbackVMTFiles( const char *assetName );
void GenerateBackpackIcons( void );
CUtlString GetOutputFileSuffix();
MESSAGE_FUNC_PARAMS( OnCheckButtonChecked, "CheckButtonChecked", kv );
MESSAGE_FUNC_PARAMS( OnItemSelected, "ItemSelected", kv );

3
public/matsys_controls/potterywheelpanel.h
View File

@ -131,8 +131,9 @@ protected:
bool m_bRenderToTexture;
virtual void SetupRenderState( int nDisplayWidth, int nDisplayHeight );
private:
void SetupRenderState( int nDisplayWidth, int nDisplayHeight );
void CreateDefaultLights();
void DestroyLights();

1
public/shaderapi/IShaderDevice.h
View File

@ -271,6 +271,7 @@ public:
#ifdef DX_TO_GL_ABSTRACTION
virtual void DoStartupShaderPreloading( void ) = 0;
#endif
virtual char *GetDisplayDeviceName() = 0;
};

2
public/shaderapi/ishaderapi.h
View File

@ -603,7 +603,7 @@ public:
// debug logging
// only implemented in some subclasses
virtual void PrintfVA( char *fmt, va_list vargs ) = 0;
virtual void Printf( PRINTF_FORMAT_STRING char *fmt, ... ) = 0;
virtual void Printf( PRINTF_FORMAT_STRING const char *fmt, ... ) = 0;
virtual float Knob( char *knobname, float *setvalue = NULL ) = 0;
// Allows us to override the alpha write setting of a material
virtual void OverrideAlphaWriteEnable( bool bEnable, bool bAlphaWriteEnable ) = 0;

110
public/headtrack/isourcevirtualreality.h → public/sourcevr/isourcevirtualreality.h
View File

@ -21,21 +21,19 @@
//-----------------------------------------------------------------------------
// forward declarations
//-----------------------------------------------------------------------------
class ITexture;
class IMaterialSystem;
//-----------------------------------------------------------------------------
// important enumeration
//-----------------------------------------------------------------------------
struct VRTrackerState_t
struct VRRect_t
{
// Tracker has finished starting up and has produced at least one valid pose.
bool bInitialized;
// Tracker currently has a valid pose.
bool bHasValidPose;
// Tracker is in a state where it is likely to suffer from yaw drift. This
// would apply to any gyro-only tracking system.
bool bWillDriftInYaw;
int32 nX;
int32 nY;
int32 nWidth;
int32 nHeight;
};
@ -69,6 +67,14 @@ public:
VREye_Right
};
// Which texture is being requested in GetRenderTarget?
enum EWhichRenderTarget
{
RT_Color = 0,
RT_Depth,
};
// ----------------------------------------------------------------------
// General utilities
// ----------------------------------------------------------------------
@ -76,24 +82,17 @@ public:
// Returns true if the game should run in VR mode
virtual bool ShouldRunInVR() = 0;
// The name of the display at which the game should put its window.
// TODO: This is pretty horrible from a "what the game has to do" point
// of view. Make it better.
virtual const char *GetDisplayName() = 0;
// The size of the window that the game should create
virtual bool GetWindowSize( int *pnWidth, int *pnHeight ) = 0;
// Lets engine tell headtrack that it's going to use a different size window based
// what the display is actually using. This happens when somebody clones
// their desktop onto the HMD
virtual void OverrideWindowSize( int nWidth, int nHeight ) = 0;
// Returns true if there is a compatible HMD connected
virtual bool IsHmdConnected() = 0;
// The size and position of the viewport for the specified eye
virtual void GetViewportBounds( VREye eEye, int *pnX, int *pnY, int *pnWidth, int *pnHeight ) = 0;
// Performs the distortion post-processing.
virtual bool DoDistortionProcessing ( const vrect_t *SrcRect ) = 0;
virtual bool DoDistortionProcessing ( VREye eEye ) = 0;
// Composites the HUD directly onto the backbuffer / render target, including undistort.
virtual bool CompositeHud ( VREye eEye, float ndcHudBounds[4], bool bDoUndistort, bool bBlackout, bool bTranslucent ) = 0;
// ----------------------------------------------------------------------
// Getting the current pose
@ -102,13 +101,6 @@ public:
// returns the pose relative to the zero point
virtual VMatrix GetMideyePose() = 0;
// returns the gravity-relative HUD correction matrix (I think)
virtual VMatrix GetHudUpCorrection() = 0;
// transforms to mid eye form left/right
virtual VMatrix GetMidEyeFromLeft() = 0;
virtual VMatrix GetMidEyeFromRight() = 0;
// All-in-one interfaces (they call GetCameraPoseZeroFromCurrent)
// Grabs the current tracking data and sets up state for the Override* calls.
virtual bool SampleTrackingState ( float PlayerGameFov, float fPredictionSeconds ) = 0;
@ -117,41 +109,49 @@ public:
// Information about the display
// ----------------------------------------------------------------------
// returns the serial number for the display or NULL if no serial number
// could be retrieved
virtual const char *GetDisplaySerialNumber() = 0;
// returns the model number for the display or NULL if no model number
// could be retrieved
virtual const char *GetDisplayModelNumber() = 0;
// returns the "ipd" of the display. This is the separation of the centers
// of the two lenses in mm
virtual float GetDisplaySeparationMM() = 0;
// Passes back the bounds of the window that the game should create. This might
// span two displays if we're dealing with a two-input display. Returns true
// if the bounds were set.
virtual bool GetDisplayBounds( VRRect_t *pRect ) = 0;
// Computes and returns the projection matrix for the eye
virtual bool GetEyeProjectionMatrix ( VMatrix *pResult, VREye, float zNear, float zFar, float fovScale ) = 0;
// Returns the horizontal FOV of the display in degrees
virtual float GetHorizontalFOVDegrees() = 0;
// ----------------------------------------------------------------------
// Information about the user
// ----------------------------------------------------------------------
// returns the intrapupilar distance of the user in mm
virtual float GetUserIPDMM() = 0;
// sets the intrapupilar distance of the user in mm
virtual void SetUserIPDMM( float fIPDMM ) = 0;
// Returns the transform from the mid-eye to the specified eye. Multiply this by
// the tweaked (for mouse rotation and WASD translation) mideye position to get the
// view matrix. This matrix takes the user's IPD into account.
virtual VMatrix GetMidEyeFromEye( VREye eEye ) = 0;
// returns the adapter index to use for VR mode
virtual int GetVRModeAdapter() = 0;
// ----------------------------------------------------------------------
// Information about the tracker
// ----------------------------------------------------------------------
// returns the state of the tracking system
virtual VRTrackerState_t GetTrackerState() = 0;
virtual bool WillDriftInYaw() = 0;
// ----------------------------------------------------------------------
// Methods about oversized offscreen rendering
// ----------------------------------------------------------------------
// Sets up the pre-distortion render targets.
virtual void CreateRenderTargets( IMaterialSystem *pMaterialSystem ) = 0;
virtual void ShutdownRenderTargets() = 0;
// fetches the render target for the specified eye
virtual ITexture *GetRenderTarget( VREye eEye, EWhichRenderTarget eWhich ) = 0;
// Returns the (possibly overridden) framebuffer size for render target sizing.
virtual void GetRenderTargetFrameBufferDimensions( int & nWidth, int & nHeight ) = 0;
// ----------------------------------------------------------------------
// Enter/leave VR mode
// ----------------------------------------------------------------------
virtual bool Activate() = 0;
virtual void Deactivate() = 0;
};

189
public/studio.h
View File

@ -313,6 +313,63 @@ private:
};
//-----------------------------------------------------------------------------
// 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
@ -902,33 +959,6 @@ struct mstudioflexcontrollerui_t
};
// these are the on-disk format vertex anims
struct dstudiovertanim_t
{
unsigned short index;
byte speed; // 255/max_length_in_flex
byte side; // 255/left_right
Vector48 delta;
Vector48 ndelta;
private:
// No copy constructors allowed
dstudiovertanim_t(const dstudiovertanim_t& vOther);
};
struct dstudiovertanim_wrinkle_t : public dstudiovertanim_t
{
short wrinkledelta; // Encodes a range from -1 to 1. NOTE: -32768 == -32767 == -1.0f, 32767 = 1.0f
private:
// No copy constructors allowed
dstudiovertanim_wrinkle_t( const dstudiovertanim_t& vOther );
};
const float g_VertAnimFixedPointScale = 1.0f / 4096.0f;
const float g_VertAnimFixedPointScaleInv = 1.0f / g_VertAnimFixedPointScale;
// this is the memory image of vertex anims (16-bit fixed point)
struct mstudiovertanim_t
{
@ -952,21 +982,31 @@ protected:
};
public:
inline Vector GetDeltaFixed()
inline void ConvertToFixed( float flVertAnimFixedPointScale )
{
return Vector( delta[0]*g_VertAnimFixedPointScale, delta[1]*g_VertAnimFixedPointScale, delta[2]*g_VertAnimFixedPointScale );
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 GetNDeltaFixed()
inline Vector GetDeltaFixed( float flVertAnimFixedPointScale )
{
return Vector( ndelta[0]*g_VertAnimFixedPointScale, ndelta[1]*g_VertAnimFixedPointScale, ndelta[2]*g_VertAnimFixedPointScale );
return Vector( delta[0] * flVertAnimFixedPointScale, delta[1] * flVertAnimFixedPointScale, delta[2] * flVertAnimFixedPointScale );
}
inline void GetDeltaFixed4DAligned( Vector4DAligned *vFillIn )
inline Vector GetNDeltaFixed( float flVertAnimFixedPointScale )
{
vFillIn->Set( delta[0]*g_VertAnimFixedPointScale, delta[1]*g_VertAnimFixedPointScale, delta[2]*g_VertAnimFixedPointScale, 0.0f );
return Vector( ndelta[0] * flVertAnimFixedPointScale, ndelta[1] * flVertAnimFixedPointScale, ndelta[2] * flVertAnimFixedPointScale );
}
inline void GetNDeltaFixed4DAligned( Vector4DAligned *vFillIn )
inline void GetDeltaFixed4DAligned( Vector4DAligned *vFillIn, float flVertAnimFixedPointScale )
{
vFillIn->Set( ndelta[0]*g_VertAnimFixedPointScale, ndelta[1]*g_VertAnimFixedPointScale, ndelta[2]*g_VertAnimFixedPointScale, 0.0f );
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()
{
@ -976,17 +1016,17 @@ public:
{
return Vector (flNDelta[0].GetFloat(), flNDelta[1].GetFloat(), flNDelta[2].GetFloat());
}
inline void SetDeltaFixed( const Vector& vInput )
inline void SetDeltaFixed( const Vector& vInput, float flVertAnimFixedPointScale )
{
delta[0] = vInput.x * g_VertAnimFixedPointScaleInv;
delta[1] = vInput.y * g_VertAnimFixedPointScaleInv;
delta[2] = vInput.z * g_VertAnimFixedPointScaleInv;
delta[0] = vInput.x / flVertAnimFixedPointScale;
delta[1] = vInput.y / flVertAnimFixedPointScale;
delta[2] = vInput.z / flVertAnimFixedPointScale;
}
inline void SetNDeltaFixed( const Vector& vInputNormal )
inline void SetNDeltaFixed( const Vector& vInputNormal, float flVertAnimFixedPointScale )
{
ndelta[0] = vInputNormal.x * g_VertAnimFixedPointScaleInv;
ndelta[1] = vInputNormal.y * g_VertAnimFixedPointScaleInv;
ndelta[2] = vInputNormal.z * g_VertAnimFixedPointScaleInv;
ndelta[0] = vInputNormal.x / flVertAnimFixedPointScale;
ndelta[1] = vInputNormal.y / flVertAnimFixedPointScale;
ndelta[2] = vInputNormal.z / flVertAnimFixedPointScale;
}
// Ick...can also force fp16 data into this structure for writing to file in legacy format...
@ -1003,10 +1043,20 @@ public:
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
mstudiovertanim_t(const mstudiovertanim_t& vOther);
//private:
// No copy constructors allowed, but it's needed for std::sort()
// mstudiovertanim_t(const mstudiovertanim_t& vOther);
};
@ -1017,20 +1067,25 @@ struct mstudiovertanim_wrinkle_t : public mstudiovertanim_t
short wrinkledelta;
inline void SetWrinkleFixed( float flWrinkle )
inline void SetWrinkleFixed( float flWrinkle, float flVertAnimFixedPointScale )
{
int nWrinkleDeltaInt = flWrinkle * g_VertAnimFixedPointScaleInv;
int nWrinkleDeltaInt = flWrinkle / flVertAnimFixedPointScale;
wrinkledelta = clamp( nWrinkleDeltaInt, -32767, 32767 );
}
inline Vector4D GetDeltaFixed()
inline Vector4D GetDeltaFixed( float flVertAnimFixedPointScale )
{
return Vector4D( delta[0]*g_VertAnimFixedPointScale, delta[1]*g_VertAnimFixedPointScale, delta[2]*g_VertAnimFixedPointScale, wrinkledelta*g_VertAnimFixedPointScale );
return Vector4D( delta[0] * flVertAnimFixedPointScale, delta[1] * flVertAnimFixedPointScale, delta[2] * flVertAnimFixedPointScale, wrinkledelta * flVertAnimFixedPointScale );
}
inline void GetDeltaFixed4DAligned( Vector4DAligned *vFillIn )
inline void GetDeltaFixed4DAligned( Vector4DAligned *vFillIn, float flVertAnimFixedPointScale )
{
vFillIn->Set( delta[0]*g_VertAnimFixedPointScale, delta[1]*g_VertAnimFixedPointScale, delta[2]*g_VertAnimFixedPointScale, wrinkledelta*g_VertAnimFixedPointScale );
vFillIn->Set( delta[0] * flVertAnimFixedPointScale, delta[1] * flVertAnimFixedPointScale, delta[2] * flVertAnimFixedPointScale, wrinkledelta * flVertAnimFixedPointScale );
}
inline float GetWrinkleDeltaFixed( float flVertAnimFixedPointScale )
{
return wrinkledelta * flVertAnimFixedPointScale;
}
};
@ -1959,6 +2014,9 @@ struct vertexFileFixup_t
#define STUDIOHDR_FLAGS_CAST_TEXTURE_SHADOWS ( 1 << 18 )
// flagged on load to indicate no animation events on this model
#define STUDIOHDR_FLAGS_VERT_ANIM_FIXED_POINT_SCALE ( 1 << 21 )
// 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
@ -1982,7 +2040,11 @@ struct studiohdr2_t
int sznameindex;
inline char *pszName() { return (sznameindex) ? (char *)(((byte *)this) + sznameindex ) : NULL; }
int reserved[58];
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
@ -2229,7 +2291,10 @@ struct studiohdr_t
int flexcontrolleruiindex;
mstudioflexcontrollerui_t *pFlexControllerUI( int i ) const { Assert( i >= 0 && i < numflexcontrollerui); return (mstudioflexcontrollerui_t *)(((byte *)this) + flexcontrolleruiindex) + i; }
int unused3[2];
float flVertAnimFixedPointScale;
inline float VertAnimFixedPointScale() const { return ( flags & STUDIOHDR_FLAGS_VERT_ANIM_FIXED_POINT_SCALE ) ? flVertAnimFixedPointScale : 1.0f / 4096.0f; }
int unused3[1];
// FIXME: Remove when we up the model version. Move all fields of studiohdr2_t into studiohdr_t.
int studiohdr2index;
@ -2245,6 +2310,9 @@ struct studiohdr_t
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.
@ -2404,6 +2472,11 @@ public:
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 );
@ -2498,11 +2571,10 @@ public:
// ctor
CActivityToSequenceMapping( void )
: m_pSequenceTuples(NULL), m_iSequenceTuplesCount(0),
: 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),
, m_bIsInitialized(false)
#endif
m_ActToSeqHash(8,0,0), m_expectedPStudioHdr(NULL), m_expectedVModel(NULL)
{};
// dtor -- not virtual because this class has no inheritors
@ -2972,6 +3044,9 @@ inline void Studio_SetRootLOD( studiohdr_t *pStudioHdr, int rootLOD )
rootLOD = pStudioHdr->numAllowedRootLODs - 1;
}
Assert( rootLOD >= 0 && rootLOD < MAX_NUM_LODS );
Clamp( rootLOD, 0, MAX_NUM_LODS - 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

8
public/tier0/afxmem_override.cpp
View File

@ -429,8 +429,7 @@ void* __cdecl operator new(size_t nSize, int nType, LPCSTR lpszFileName, int nLi
#endif
}
#if 0
#if _MSC_VER >= 1200
#if _MSC_VER >= 1700
void __cdecl operator delete(void* p, int nType, LPCSTR /* lpszFileName */, int /* nLine */)
{
#if !defined(_AFX_NO_DEBUG_CRT) && defined(_DEBUG)
@ -440,19 +439,16 @@ void __cdecl operator delete(void* p, int nType, LPCSTR /* lpszFileName */, int
#endif
}
#endif // _MSC_VER >= 1200
#endif
#if _MSC_VER >= 1210
#if _MSC_VER >= 1700
void* __cdecl operator new[](size_t nSize, int nType, LPCSTR lpszFileName, int nLine)
{
return ::operator new(nSize, nType, lpszFileName, nLine);
}
#if 0
void __cdecl operator delete[](void* p, int nType, LPCSTR lpszFileName, int nLine)
{
::operator delete(p, nType, lpszFileName, nLine);
}
#endif
#endif // _MSC_VER >= 1210
#endif //_DEBUG

10
public/tier0/dbg.h
View File

@ -247,8 +247,8 @@ DBG_INTERFACE struct SDL_Window * GetAssertDialogParent();
if (!(_exp)) \
{ \
_SpewInfo( SPEW_ASSERT, __TFILE__, __LINE__ ); \
SpewRetval_t ret = _SpewMessage("%s", _msg); \
CallAssertFailedNotifyFunc( __TFILE__, __LINE__, _msg ); \
SpewRetval_t ret = _SpewMessage("%s", static_cast<const char*>( _msg )); \
CallAssertFailedNotifyFunc( __TFILE__, __LINE__, _msg ); \
_executeExp; \
if ( ret == SPEW_DEBUGGER) \
{ \
@ -343,6 +343,9 @@ DBG_INTERFACE struct SDL_Window * GetAssertDialogParent();
#define AssertEquals( _exp, _expectedValue ) AssertMsg2( (_exp) == (_expectedValue), _T("Expected %d but got %d!"), (_expectedValue), (_exp) )
#define AssertFloatEquals( _exp, _expectedValue, _tol ) AssertMsg2( fabs((_exp) - (_expectedValue)) <= (_tol), _T("Expected %f but got %f!"), (_expectedValue), (_exp) )
#define Verify( _exp ) Assert( _exp )
#define VerifyMsg1( _exp, _msg, a1 ) AssertMsg1( _exp, _msg, a1 )
#define VerifyMsg2( _exp, _msg, a1, a2 ) AssertMsg2( _exp, _msg, a1, a2 )
#define VerifyMsg3( _exp, _msg, a1, a2, a3 ) AssertMsg3( _exp, _msg, a1, a2, a3 )
#define VerifyEquals( _exp, _expectedValue ) AssertEquals( _exp, _expectedValue )
#define DbgVerify( _exp ) Assert( _exp )
@ -366,6 +369,9 @@ DBG_INTERFACE struct SDL_Window * GetAssertDialogParent();
#define AssertEquals( _exp, _expectedValue ) ((void)0)
#define AssertFloatEquals( _exp, _expectedValue, _tol ) ((void)0)
#define Verify( _exp ) (_exp)
#define VerifyMsg1( _exp, _msg, a1 ) (_exp)
#define VerifyMsg2( _exp, _msg, a1, a2 ) (_exp)
#define VerifyMsg3( _exp, _msg, a1, a2, a3 ) (_exp)
#define VerifyEquals( _exp, _expectedValue ) (_exp)
#define DbgVerify( _exp ) (_exp)

115
public/tier1/fmtstr.h
View File

@ -125,7 +125,42 @@ public:
}
void AppendFormatV( const char *pchFormat, va_list args );
void Append( const char *pchValue ) { AppendFormat( "%s", pchValue ); }
void Append( const char *pchValue )
{
// This function is close to the metal to cut down on the CPU cost
// of the previous incantation of Append which was implemented as
// AppendFormat( "%s", pchValue ). This implementation, though not
// as easy to read, instead does a strcpy from the existing end
// point of the CFmtStrN. This brings something like a 10-20x speedup
// in my rudimentary tests. It isn't using V_strncpy because that
// function doesn't return the number of characters copied, which
// we need to adjust m_nLength. Doing the V_strncpy with a V_strlen
// afterwards took twice as long as this implementations in tests,
// so V_strncpy's implementation was used to write this method.
char *pDest = m_szBuf + m_nLength;
const int maxLen = SIZE_BUF - m_nLength;
char *pLast = pDest + maxLen - 1;
while ( (pDest < pLast) && (*pchValue != 0) )
{
*pDest = *pchValue;
++pDest; ++pchValue;
}
*pDest = 0;
m_nLength = pDest - m_szBuf;
}
//optimized version of append for just adding a single character
void Append( char ch )
{
if( m_nLength < SIZE_BUF - 1 )
{
m_szBuf[ m_nLength ] = ch;
m_nLength++;
m_szBuf[ m_nLength ] = '\0';
}
}
void AppendIndent( uint32 unCount, char chIndent = '\t' );
protected:
@ -193,6 +228,84 @@ typedef CFmtStrQuietTruncationN<FMTSTR_STD_LEN> CFmtStrQuietTruncation;
typedef CFmtStrN<1024> CFmtStr1024;
typedef CFmtStrN<8192> CFmtStrMax;
//-----------------------------------------------------------------------------
// Purpose: Fast-path number-to-string helper (with optional quoting)
// Derived off of the Steam CNumStr but with a few tweaks, such as
// trimming off the in-our-cases-unnecessary strlen calls (by not
// storing the length in the class).
//-----------------------------------------------------------------------------
class CNumStr
{
public:
CNumStr() { m_szBuf[0] = 0; }
explicit CNumStr( bool b ) { SetBool( b ); }
explicit CNumStr( int8 n8 ) { SetInt8( n8 ); }
explicit CNumStr( uint8 un8 ) { SetUint8( un8 ); }
explicit CNumStr( int16 n16 ) { SetInt16( n16 ); }
explicit CNumStr( uint16 un16 ) { SetUint16( un16 ); }
explicit CNumStr( int32 n32 ) { SetInt32( n32 ); }
explicit CNumStr( uint32 un32 ) { SetUint32( un32 ); }
explicit CNumStr( int64 n64 ) { SetInt64( n64 ); }
explicit CNumStr( uint64 un64 ) { SetUint64( un64 ); }
#if defined(COMPILER_GCC) && defined(PLATFORM_64BITS)
explicit CNumStr( lint64 n64 ) { SetInt64( (int64)n64 ); }
explicit CNumStr( ulint64 un64 ) { SetUint64( (uint64)un64 ); }
#endif
explicit CNumStr( double f ) { SetDouble( f ); }
explicit CNumStr( float f ) { SetFloat( f ); }
inline void SetBool( bool b ) { Q_memcpy( m_szBuf, b ? "1" : "0", 2 ); }
#ifdef _WIN32
inline void SetInt8( int8 n8 ) { _itoa( (int32)n8, m_szBuf, 10 ); }
inline void SetUint8( uint8 un8 ) { _itoa( (int32)un8, m_szBuf, 10 ); }
inline void SetInt16( int16 n16 ) { _itoa( (int32)n16, m_szBuf, 10 ); }
inline void SetUint16( uint16 un16 ) { _itoa( (int32)un16, m_szBuf, 10 ); }
inline void SetInt32( int32 n32 ) { _itoa( n32, m_szBuf, 10 ); }
inline void SetUint32( uint32 un32 ) { _i64toa( (int64)un32, m_szBuf, 10 ); }
inline void SetInt64( int64 n64 ) { _i64toa( n64, m_szBuf, 10 ); }
inline void SetUint64( uint64 un64 ) { _ui64toa( un64, m_szBuf, 10 ); }
#else
inline void SetInt8( int8 n8 ) { Q_snprintf( m_szBuf, sizeof(m_szBuf), "%d", (int32)n8 ); }
inline void SetUint8( uint8 un8 ) { Q_snprintf( m_szBuf, sizeof(m_szBuf), "%d", (int32)un8 ); }
inline void SetInt16( int16 n16 ) { Q_snprintf( m_szBuf, sizeof(m_szBuf), "%d", (int32)n16 ); }
inline void SetUint16( uint16 un16 ) { Q_snprintf( m_szBuf, sizeof(m_szBuf), "%d", (int32)un16 ); }
inline void SetInt32( int32 n32 ) { Q_snprintf( m_szBuf, sizeof(m_szBuf), "%d", n32 ); }
inline void SetUint32( uint32 un32 ) { Q_snprintf( m_szBuf, sizeof(m_szBuf), "%u", un32 ); }
inline void SetInt64( int64 n64 ) { Q_snprintf( m_szBuf, sizeof(m_szBuf), "%lld", n64 ); }
inline void SetUint64( uint64 un64 ) { Q_snprintf( m_szBuf, sizeof(m_szBuf), "%llu", un64 ); }
#endif
inline void SetDouble( double f ) { Q_snprintf( m_szBuf, sizeof(m_szBuf), "%.18g", f ); }
inline void SetFloat( float f ) { Q_snprintf( m_szBuf, sizeof(m_szBuf), "%.18g", f ); }
inline void SetHexUint64( uint64 un64 ) { Q_binarytohex( (byte *)&un64, sizeof( un64 ), m_szBuf, sizeof( m_szBuf ) ); }
operator const char *() const { return m_szBuf; }
const char* String() const { return m_szBuf; }
void AddQuotes()
{
Assert( m_szBuf[0] != '"' );
const int nLength = Q_strlen( m_szBuf );
Q_memmove( m_szBuf + 1, m_szBuf, nLength );
m_szBuf[0] = '"';
m_szBuf[nLength + 1] = '"';
m_szBuf[nLength + 2] = 0;
}
protected:
char m_szBuf[28]; // long enough to hold 18 digits of precision, a decimal, a - sign, e+### suffix, and quotes
};
//=============================================================================
bool BGetLocalFormattedDateAndTime( time_t timeVal, char *pchDate, int cubDate, char *pchTime, int cubTime );

9
public/vgui/ISurface.h
View File

@ -32,6 +32,7 @@
#endif
class Color;
class ITexture;
namespace vgui
{
@ -386,7 +387,7 @@ public:
virtual IHTMLChromeController *AccessChromeHTMLController() = 0;
// the origin of the viewport on the framebuffer (Which might not be 0,0 for stereo)
virtual void SetFullscreenViewport( int x, int y, int w, int h ) = 0;
virtual void SetFullscreenViewportAndRenderTarget( int x, int y, int w, int h, ITexture *pRenderTarget ) = 0;
virtual void GetFullscreenViewport( int & x, int & y, int & w, int & h ) = 0;
virtual void PushFullscreenViewport() = 0;
virtual void PopFullscreenViewport() = 0;
@ -394,6 +395,12 @@ public:
// handles support for software cursors
virtual void SetSoftwareCursor( bool bUseSoftwareCursor ) = 0;
virtual void PaintSoftwareCursor() = 0;
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// !! WARNING! YOU MUST NOT ADD YOUR NEW METHOD HERE OR YOU WILL BREAK MODS !!
// !! Add your new stuff to the bottom of IMatSystemSurface instead. !!
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
};
}

2
public/windows_default.manifest
View File

@ -8,6 +8,8 @@
<supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
<!--The ID below indicates application support for Windows 8 -->
<supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
<!--The ID below indicates application support for Windows 8.1 -->
<supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
</application>
</compatibility>
</assembly>