GitHub/Facepunch.Steamworks
2
0
Fork 0
mirror of https://github.com/Facepunch/Facepunch.Steamworks.git synced 2025-01-12 14:48:02 +03:00
Code Issues Projects Releases Wiki Activity

Delegate name refactor

Browse Source
This commit is contained in:
Garry Newman 2019-04-17 13:36:11 +01:00
parent eb16bebae9
commit 6c1dd241ba
12 changed files with 1178 additions and 1178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

224
Facepunch.Steamworks/Generated/Interfaces/ISteamApps.cs
View File

@ -17,357 +17,357 @@ namespace Steamworks
public override void InitInternals() public override void InitInternals()
{ {
BIsSubscribedDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsSubscribedDelegate>( Marshal.ReadIntPtr( VTable, 0) ); _BIsSubscribed = Marshal.GetDelegateForFunctionPointer<FBIsSubscribed>( Marshal.ReadIntPtr( VTable, 0) );
BIsLowViolenceDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsLowViolenceDelegate>( Marshal.ReadIntPtr( VTable, 8) ); _BIsLowViolence = Marshal.GetDelegateForFunctionPointer<FBIsLowViolence>( Marshal.ReadIntPtr( VTable, 8) );
BIsCybercafeDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsCybercafeDelegate>( Marshal.ReadIntPtr( VTable, 16) ); _BIsCybercafe = Marshal.GetDelegateForFunctionPointer<FBIsCybercafe>( Marshal.ReadIntPtr( VTable, 16) );
BIsVACBannedDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsVACBannedDelegate>( Marshal.ReadIntPtr( VTable, 24) ); _BIsVACBanned = Marshal.GetDelegateForFunctionPointer<FBIsVACBanned>( Marshal.ReadIntPtr( VTable, 24) );
GetCurrentGameLanguageDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetCurrentGameLanguageDelegate>( Marshal.ReadIntPtr( VTable, 32) ); _GetCurrentGameLanguage = Marshal.GetDelegateForFunctionPointer<FGetCurrentGameLanguage>( Marshal.ReadIntPtr( VTable, 32) );
GetAvailableGameLanguagesDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAvailableGameLanguagesDelegate>( Marshal.ReadIntPtr( VTable, 40) ); _GetAvailableGameLanguages = Marshal.GetDelegateForFunctionPointer<FGetAvailableGameLanguages>( Marshal.ReadIntPtr( VTable, 40) );
BIsSubscribedAppDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsSubscribedAppDelegate>( Marshal.ReadIntPtr( VTable, 48) ); _BIsSubscribedApp = Marshal.GetDelegateForFunctionPointer<FBIsSubscribedApp>( Marshal.ReadIntPtr( VTable, 48) );
BIsDlcInstalledDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsDlcInstalledDelegate>( Marshal.ReadIntPtr( VTable, 56) ); _BIsDlcInstalled = Marshal.GetDelegateForFunctionPointer<FBIsDlcInstalled>( Marshal.ReadIntPtr( VTable, 56) );
GetEarliestPurchaseUnixTimeDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetEarliestPurchaseUnixTimeDelegate>( Marshal.ReadIntPtr( VTable, 64) ); _GetEarliestPurchaseUnixTime = Marshal.GetDelegateForFunctionPointer<FGetEarliestPurchaseUnixTime>( Marshal.ReadIntPtr( VTable, 64) );
BIsSubscribedFromFreeWeekendDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsSubscribedFromFreeWeekendDelegate>( Marshal.ReadIntPtr( VTable, 72) ); _BIsSubscribedFromFreeWeekend = Marshal.GetDelegateForFunctionPointer<FBIsSubscribedFromFreeWeekend>( Marshal.ReadIntPtr( VTable, 72) );
GetDLCCountDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetDLCCountDelegate>( Marshal.ReadIntPtr( VTable, 80) ); _GetDLCCount = Marshal.GetDelegateForFunctionPointer<FGetDLCCount>( Marshal.ReadIntPtr( VTable, 80) );
BGetDLCDataByIndexDelegatePointer = Marshal.GetDelegateForFunctionPointer<BGetDLCDataByIndexDelegate>( Marshal.ReadIntPtr( VTable, 88) ); _BGetDLCDataByIndex = Marshal.GetDelegateForFunctionPointer<FBGetDLCDataByIndex>( Marshal.ReadIntPtr( VTable, 88) );
InstallDLCDelegatePointer = Marshal.GetDelegateForFunctionPointer<InstallDLCDelegate>( Marshal.ReadIntPtr( VTable, 96) ); _InstallDLC = Marshal.GetDelegateForFunctionPointer<FInstallDLC>( Marshal.ReadIntPtr( VTable, 96) );
UninstallDLCDelegatePointer = Marshal.GetDelegateForFunctionPointer<UninstallDLCDelegate>( Marshal.ReadIntPtr( VTable, 104) ); _UninstallDLC = Marshal.GetDelegateForFunctionPointer<FUninstallDLC>( Marshal.ReadIntPtr( VTable, 104) );
RequestAppProofOfPurchaseKeyDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestAppProofOfPurchaseKeyDelegate>( Marshal.ReadIntPtr( VTable, 112) ); _RequestAppProofOfPurchaseKey = Marshal.GetDelegateForFunctionPointer<FRequestAppProofOfPurchaseKey>( Marshal.ReadIntPtr( VTable, 112) );
GetCurrentBetaNameDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetCurrentBetaNameDelegate>( Marshal.ReadIntPtr( VTable, 120) ); _GetCurrentBetaName = Marshal.GetDelegateForFunctionPointer<FGetCurrentBetaName>( Marshal.ReadIntPtr( VTable, 120) );
MarkContentCorruptDelegatePointer = Marshal.GetDelegateForFunctionPointer<MarkContentCorruptDelegate>( Marshal.ReadIntPtr( VTable, 128) ); _MarkContentCorrupt = Marshal.GetDelegateForFunctionPointer<FMarkContentCorrupt>( Marshal.ReadIntPtr( VTable, 128) );
GetInstalledDepotsDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetInstalledDepotsDelegate>( Marshal.ReadIntPtr( VTable, 136) ); _GetInstalledDepots = Marshal.GetDelegateForFunctionPointer<FGetInstalledDepots>( Marshal.ReadIntPtr( VTable, 136) );
GetAppInstallDirDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAppInstallDirDelegate>( Marshal.ReadIntPtr( VTable, 144) ); _GetAppInstallDir = Marshal.GetDelegateForFunctionPointer<FGetAppInstallDir>( Marshal.ReadIntPtr( VTable, 144) );
BIsAppInstalledDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsAppInstalledDelegate>( Marshal.ReadIntPtr( VTable, 152) ); _BIsAppInstalled = Marshal.GetDelegateForFunctionPointer<FBIsAppInstalled>( Marshal.ReadIntPtr( VTable, 152) );
GetAppOwnerDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAppOwnerDelegate>( Marshal.ReadIntPtr( VTable, 160) ); _GetAppOwner = Marshal.GetDelegateForFunctionPointer<FGetAppOwner>( Marshal.ReadIntPtr( VTable, 160) );
GetLaunchQueryParamDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetLaunchQueryParamDelegate>( Marshal.ReadIntPtr( VTable, 168) ); _GetLaunchQueryParam = Marshal.GetDelegateForFunctionPointer<FGetLaunchQueryParam>( Marshal.ReadIntPtr( VTable, 168) );
GetDlcDownloadProgressDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetDlcDownloadProgressDelegate>( Marshal.ReadIntPtr( VTable, 176) ); _GetDlcDownloadProgress = Marshal.GetDelegateForFunctionPointer<FGetDlcDownloadProgress>( Marshal.ReadIntPtr( VTable, 176) );
GetAppBuildIdDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAppBuildIdDelegate>( Marshal.ReadIntPtr( VTable, 184) ); _GetAppBuildId = Marshal.GetDelegateForFunctionPointer<FGetAppBuildId>( Marshal.ReadIntPtr( VTable, 184) );
RequestAllProofOfPurchaseKeysDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestAllProofOfPurchaseKeysDelegate>( Marshal.ReadIntPtr( VTable, 192) ); _RequestAllProofOfPurchaseKeys = Marshal.GetDelegateForFunctionPointer<FRequestAllProofOfPurchaseKeys>( Marshal.ReadIntPtr( VTable, 192) );
GetFileDetailsDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetFileDetailsDelegate>( Marshal.ReadIntPtr( VTable, 200) ); _GetFileDetails = Marshal.GetDelegateForFunctionPointer<FGetFileDetails>( Marshal.ReadIntPtr( VTable, 200) );
GetLaunchCommandLineDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetLaunchCommandLineDelegate>( Marshal.ReadIntPtr( VTable, 208) ); _GetLaunchCommandLine = Marshal.GetDelegateForFunctionPointer<FGetLaunchCommandLine>( Marshal.ReadIntPtr( VTable, 208) );
BIsSubscribedFromFamilySharingDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsSubscribedFromFamilySharingDelegate>( Marshal.ReadIntPtr( VTable, 216) ); _BIsSubscribedFromFamilySharing = Marshal.GetDelegateForFunctionPointer<FBIsSubscribedFromFamilySharing>( Marshal.ReadIntPtr( VTable, 216) );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool BIsSubscribedDelegate( IntPtr self ); private delegate bool FBIsSubscribed( IntPtr self );
private BIsSubscribedDelegate BIsSubscribedDelegatePointer; private FBIsSubscribed _BIsSubscribed;
#endregion #endregion
internal bool BIsSubscribed() internal bool BIsSubscribed()
{ {
return BIsSubscribedDelegatePointer( Self ); return _BIsSubscribed( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool BIsLowViolenceDelegate( IntPtr self ); private delegate bool FBIsLowViolence( IntPtr self );
private BIsLowViolenceDelegate BIsLowViolenceDelegatePointer; private FBIsLowViolence _BIsLowViolence;
#endregion #endregion
internal bool BIsLowViolence() internal bool BIsLowViolence()
{ {
return BIsLowViolenceDelegatePointer( Self ); return _BIsLowViolence( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool BIsCybercafeDelegate( IntPtr self ); private delegate bool FBIsCybercafe( IntPtr self );
private BIsCybercafeDelegate BIsCybercafeDelegatePointer; private FBIsCybercafe _BIsCybercafe;
#endregion #endregion
internal bool BIsCybercafe() internal bool BIsCybercafe()
{ {
return BIsCybercafeDelegatePointer( Self ); return _BIsCybercafe( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool BIsVACBannedDelegate( IntPtr self ); private delegate bool FBIsVACBanned( IntPtr self );
private BIsVACBannedDelegate BIsVACBannedDelegatePointer; private FBIsVACBanned _BIsVACBanned;
#endregion #endregion
internal bool BIsVACBanned() internal bool BIsVACBanned()
{ {
return BIsVACBannedDelegatePointer( Self ); return _BIsVACBanned( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate IntPtr GetCurrentGameLanguageDelegate( IntPtr self ); private delegate IntPtr FGetCurrentGameLanguage( IntPtr self );
private GetCurrentGameLanguageDelegate GetCurrentGameLanguageDelegatePointer; private FGetCurrentGameLanguage _GetCurrentGameLanguage;
#endregion #endregion
internal string GetCurrentGameLanguage() internal string GetCurrentGameLanguage()
{ {
return GetString( GetCurrentGameLanguageDelegatePointer( Self ) ); return GetString( _GetCurrentGameLanguage( Self ) );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate IntPtr GetAvailableGameLanguagesDelegate( IntPtr self ); private delegate IntPtr FGetAvailableGameLanguages( IntPtr self );
private GetAvailableGameLanguagesDelegate GetAvailableGameLanguagesDelegatePointer; private FGetAvailableGameLanguages _GetAvailableGameLanguages;
#endregion #endregion
internal string GetAvailableGameLanguages() internal string GetAvailableGameLanguages()
{ {
return GetString( GetAvailableGameLanguagesDelegatePointer( Self ) ); return GetString( _GetAvailableGameLanguages( Self ) );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool BIsSubscribedAppDelegate( IntPtr self, AppId_t appID ); private delegate bool FBIsSubscribedApp( IntPtr self, AppId_t appID );
private BIsSubscribedAppDelegate BIsSubscribedAppDelegatePointer; private FBIsSubscribedApp _BIsSubscribedApp;
#endregion #endregion
internal bool BIsSubscribedApp( AppId_t appID ) internal bool BIsSubscribedApp( AppId_t appID )
{ {
return BIsSubscribedAppDelegatePointer( Self, appID ); return _BIsSubscribedApp( Self, appID );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool BIsDlcInstalledDelegate( IntPtr self, AppId_t appID ); private delegate bool FBIsDlcInstalled( IntPtr self, AppId_t appID );
private BIsDlcInstalledDelegate BIsDlcInstalledDelegatePointer; private FBIsDlcInstalled _BIsDlcInstalled;
#endregion #endregion
internal bool BIsDlcInstalled( AppId_t appID ) internal bool BIsDlcInstalled( AppId_t appID )
{ {
return BIsDlcInstalledDelegatePointer( Self, appID ); return _BIsDlcInstalled( Self, appID );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate uint GetEarliestPurchaseUnixTimeDelegate( IntPtr self, AppId_t nAppID ); private delegate uint FGetEarliestPurchaseUnixTime( IntPtr self, AppId_t nAppID );
private GetEarliestPurchaseUnixTimeDelegate GetEarliestPurchaseUnixTimeDelegatePointer; private FGetEarliestPurchaseUnixTime _GetEarliestPurchaseUnixTime;
#endregion #endregion
internal uint GetEarliestPurchaseUnixTime( AppId_t nAppID ) internal uint GetEarliestPurchaseUnixTime( AppId_t nAppID )
{ {
return GetEarliestPurchaseUnixTimeDelegatePointer( Self, nAppID ); return _GetEarliestPurchaseUnixTime( Self, nAppID );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool BIsSubscribedFromFreeWeekendDelegate( IntPtr self ); private delegate bool FBIsSubscribedFromFreeWeekend( IntPtr self );
private BIsSubscribedFromFreeWeekendDelegate BIsSubscribedFromFreeWeekendDelegatePointer; private FBIsSubscribedFromFreeWeekend _BIsSubscribedFromFreeWeekend;
#endregion #endregion
internal bool BIsSubscribedFromFreeWeekend() internal bool BIsSubscribedFromFreeWeekend()
{ {
return BIsSubscribedFromFreeWeekendDelegatePointer( Self ); return _BIsSubscribedFromFreeWeekend( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate int GetDLCCountDelegate( IntPtr self ); private delegate int FGetDLCCount( IntPtr self );
private GetDLCCountDelegate GetDLCCountDelegatePointer; private FGetDLCCount _GetDLCCount;
#endregion #endregion
internal int GetDLCCount() internal int GetDLCCount()
{ {
return GetDLCCountDelegatePointer( Self ); return _GetDLCCount( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool BGetDLCDataByIndexDelegate( IntPtr self, int iDLC, ref AppId_t pAppID, [MarshalAs( UnmanagedType.U1 )] ref bool pbAvailable, StringBuilder pchName, int cchNameBufferSize ); private delegate bool FBGetDLCDataByIndex( IntPtr self, int iDLC, ref AppId_t pAppID, [MarshalAs( UnmanagedType.U1 )] ref bool pbAvailable, StringBuilder pchName, int cchNameBufferSize );
private BGetDLCDataByIndexDelegate BGetDLCDataByIndexDelegatePointer; private FBGetDLCDataByIndex _BGetDLCDataByIndex;
#endregion #endregion
internal bool BGetDLCDataByIndex( int iDLC, ref AppId_t pAppID, [MarshalAs( UnmanagedType.U1 )] ref bool pbAvailable, StringBuilder pchName, int cchNameBufferSize ) internal bool BGetDLCDataByIndex( int iDLC, ref AppId_t pAppID, [MarshalAs( UnmanagedType.U1 )] ref bool pbAvailable, StringBuilder pchName, int cchNameBufferSize )
{ {
return BGetDLCDataByIndexDelegatePointer( Self, iDLC, ref pAppID, ref pbAvailable, pchName, cchNameBufferSize ); return _BGetDLCDataByIndex( Self, iDLC, ref pAppID, ref pbAvailable, pchName, cchNameBufferSize );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void InstallDLCDelegate( IntPtr self, AppId_t nAppID ); private delegate void FInstallDLC( IntPtr self, AppId_t nAppID );
private InstallDLCDelegate InstallDLCDelegatePointer; private FInstallDLC _InstallDLC;
#endregion #endregion
internal void InstallDLC( AppId_t nAppID ) internal void InstallDLC( AppId_t nAppID )
{ {
InstallDLCDelegatePointer( Self, nAppID ); _InstallDLC( Self, nAppID );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void UninstallDLCDelegate( IntPtr self, AppId_t nAppID ); private delegate void FUninstallDLC( IntPtr self, AppId_t nAppID );
private UninstallDLCDelegate UninstallDLCDelegatePointer; private FUninstallDLC _UninstallDLC;
#endregion #endregion
internal void UninstallDLC( AppId_t nAppID ) internal void UninstallDLC( AppId_t nAppID )
{ {
UninstallDLCDelegatePointer( Self, nAppID ); _UninstallDLC( Self, nAppID );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void RequestAppProofOfPurchaseKeyDelegate( IntPtr self, AppId_t nAppID ); private delegate void FRequestAppProofOfPurchaseKey( IntPtr self, AppId_t nAppID );
private RequestAppProofOfPurchaseKeyDelegate RequestAppProofOfPurchaseKeyDelegatePointer; private FRequestAppProofOfPurchaseKey _RequestAppProofOfPurchaseKey;
#endregion #endregion
internal void RequestAppProofOfPurchaseKey( AppId_t nAppID ) internal void RequestAppProofOfPurchaseKey( AppId_t nAppID )
{ {
RequestAppProofOfPurchaseKeyDelegatePointer( Self, nAppID ); _RequestAppProofOfPurchaseKey( Self, nAppID );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool GetCurrentBetaNameDelegate( IntPtr self, StringBuilder pchName, int cchNameBufferSize ); private delegate bool FGetCurrentBetaName( IntPtr self, StringBuilder pchName, int cchNameBufferSize );
private GetCurrentBetaNameDelegate GetCurrentBetaNameDelegatePointer; private FGetCurrentBetaName _GetCurrentBetaName;
#endregion #endregion
internal bool GetCurrentBetaName( StringBuilder pchName, int cchNameBufferSize ) internal bool GetCurrentBetaName( StringBuilder pchName, int cchNameBufferSize )
{ {
return GetCurrentBetaNameDelegatePointer( Self, pchName, cchNameBufferSize ); return _GetCurrentBetaName( Self, pchName, cchNameBufferSize );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool MarkContentCorruptDelegate( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bMissingFilesOnly ); private delegate bool FMarkContentCorrupt( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bMissingFilesOnly );
private MarkContentCorruptDelegate MarkContentCorruptDelegatePointer; private FMarkContentCorrupt _MarkContentCorrupt;
#endregion #endregion
internal bool MarkContentCorrupt( [MarshalAs( UnmanagedType.U1 )] bool bMissingFilesOnly ) internal bool MarkContentCorrupt( [MarshalAs( UnmanagedType.U1 )] bool bMissingFilesOnly )
{ {
return MarkContentCorruptDelegatePointer( Self, bMissingFilesOnly ); return _MarkContentCorrupt( Self, bMissingFilesOnly );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate uint GetInstalledDepotsDelegate( IntPtr self, AppId_t appID, [In,Out] DepotId_t[] pvecDepots, uint cMaxDepots ); private delegate uint FGetInstalledDepots( IntPtr self, AppId_t appID, [In,Out] DepotId_t[] pvecDepots, uint cMaxDepots );
private GetInstalledDepotsDelegate GetInstalledDepotsDelegatePointer; private FGetInstalledDepots _GetInstalledDepots;
#endregion #endregion
internal uint GetInstalledDepots( AppId_t appID, [In,Out] DepotId_t[] pvecDepots, uint cMaxDepots ) internal uint GetInstalledDepots( AppId_t appID, [In,Out] DepotId_t[] pvecDepots, uint cMaxDepots )
{ {
return GetInstalledDepotsDelegatePointer( Self, appID, pvecDepots, cMaxDepots ); return _GetInstalledDepots( Self, appID, pvecDepots, cMaxDepots );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate uint GetAppInstallDirDelegate( IntPtr self, AppId_t appID, StringBuilder pchFolder, uint cchFolderBufferSize ); private delegate uint FGetAppInstallDir( IntPtr self, AppId_t appID, StringBuilder pchFolder, uint cchFolderBufferSize );
private GetAppInstallDirDelegate GetAppInstallDirDelegatePointer; private FGetAppInstallDir _GetAppInstallDir;
#endregion #endregion
internal uint GetAppInstallDir( AppId_t appID, StringBuilder pchFolder, uint cchFolderBufferSize ) internal uint GetAppInstallDir( AppId_t appID, StringBuilder pchFolder, uint cchFolderBufferSize )
{ {
return GetAppInstallDirDelegatePointer( Self, appID, pchFolder, cchFolderBufferSize ); return _GetAppInstallDir( Self, appID, pchFolder, cchFolderBufferSize );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool BIsAppInstalledDelegate( IntPtr self, AppId_t appID ); private delegate bool FBIsAppInstalled( IntPtr self, AppId_t appID );
private BIsAppInstalledDelegate BIsAppInstalledDelegatePointer; private FBIsAppInstalled _BIsAppInstalled;
#endregion #endregion
internal bool BIsAppInstalled( AppId_t appID ) internal bool BIsAppInstalled( AppId_t appID )
{ {
return BIsAppInstalledDelegatePointer( Self, appID ); return _BIsAppInstalled( Self, appID );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void GetAppOwnerDelegate( IntPtr self, ref SteamId retVal ); private delegate void FGetAppOwner( IntPtr self, ref SteamId retVal );
private GetAppOwnerDelegate GetAppOwnerDelegatePointer; private FGetAppOwner _GetAppOwner;
#endregion #endregion
internal SteamId GetAppOwner() internal SteamId GetAppOwner()
{ {
var retVal = default( SteamId ); var retVal = default( SteamId );
GetAppOwnerDelegatePointer( Self, ref retVal ); _GetAppOwner( Self, ref retVal );
return retVal; return retVal;
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate IntPtr GetLaunchQueryParamDelegate( IntPtr self, string pchKey ); private delegate IntPtr FGetLaunchQueryParam( IntPtr self, string pchKey );
private GetLaunchQueryParamDelegate GetLaunchQueryParamDelegatePointer; private FGetLaunchQueryParam _GetLaunchQueryParam;
#endregion #endregion
internal string GetLaunchQueryParam( string pchKey ) internal string GetLaunchQueryParam( string pchKey )
{ {
return GetString( GetLaunchQueryParamDelegatePointer( Self, pchKey ) ); return GetString( _GetLaunchQueryParam( Self, pchKey ) );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool GetDlcDownloadProgressDelegate( IntPtr self, AppId_t nAppID, ref ulong punBytesDownloaded, ref ulong punBytesTotal ); private delegate bool FGetDlcDownloadProgress( IntPtr self, AppId_t nAppID, ref ulong punBytesDownloaded, ref ulong punBytesTotal );
private GetDlcDownloadProgressDelegate GetDlcDownloadProgressDelegatePointer; private FGetDlcDownloadProgress _GetDlcDownloadProgress;
#endregion #endregion
internal bool GetDlcDownloadProgress( AppId_t nAppID, ref ulong punBytesDownloaded, ref ulong punBytesTotal ) internal bool GetDlcDownloadProgress( AppId_t nAppID, ref ulong punBytesDownloaded, ref ulong punBytesTotal )
{ {
return GetDlcDownloadProgressDelegatePointer( Self, nAppID, ref punBytesDownloaded, ref punBytesTotal ); return _GetDlcDownloadProgress( Self, nAppID, ref punBytesDownloaded, ref punBytesTotal );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate int GetAppBuildIdDelegate( IntPtr self ); private delegate int FGetAppBuildId( IntPtr self );
private GetAppBuildIdDelegate GetAppBuildIdDelegatePointer; private FGetAppBuildId _GetAppBuildId;
#endregion #endregion
internal int GetAppBuildId() internal int GetAppBuildId()
{ {
return GetAppBuildIdDelegatePointer( Self ); return _GetAppBuildId( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void RequestAllProofOfPurchaseKeysDelegate( IntPtr self ); private delegate void FRequestAllProofOfPurchaseKeys( IntPtr self );
private RequestAllProofOfPurchaseKeysDelegate RequestAllProofOfPurchaseKeysDelegatePointer; private FRequestAllProofOfPurchaseKeys _RequestAllProofOfPurchaseKeys;
#endregion #endregion
internal void RequestAllProofOfPurchaseKeys() internal void RequestAllProofOfPurchaseKeys()
{ {
RequestAllProofOfPurchaseKeysDelegatePointer( Self ); _RequestAllProofOfPurchaseKeys( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate SteamAPICall_t GetFileDetailsDelegate( IntPtr self, string pszFileName ); private delegate SteamAPICall_t FGetFileDetails( IntPtr self, string pszFileName );
private GetFileDetailsDelegate GetFileDetailsDelegatePointer; private FGetFileDetails _GetFileDetails;
#endregion #endregion
internal async Task<FileDetailsResult_t?> GetFileDetails( string pszFileName ) internal async Task<FileDetailsResult_t?> GetFileDetails( string pszFileName )
{ {
return await (new Result<FileDetailsResult_t>( GetFileDetailsDelegatePointer( Self, pszFileName ) )).GetResult(); return await (new Result<FileDetailsResult_t>( _GetFileDetails( Self, pszFileName ) )).GetResult();
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate int GetLaunchCommandLineDelegate( IntPtr self, StringBuilder pszCommandLine, int cubCommandLine ); private delegate int FGetLaunchCommandLine( IntPtr self, StringBuilder pszCommandLine, int cubCommandLine );
private GetLaunchCommandLineDelegate GetLaunchCommandLineDelegatePointer; private FGetLaunchCommandLine _GetLaunchCommandLine;
#endregion #endregion
internal int GetLaunchCommandLine( StringBuilder pszCommandLine, int cubCommandLine ) internal int GetLaunchCommandLine( StringBuilder pszCommandLine, int cubCommandLine )
{ {
return GetLaunchCommandLineDelegatePointer( Self, pszCommandLine, cubCommandLine ); return _GetLaunchCommandLine( Self, pszCommandLine, cubCommandLine );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool BIsSubscribedFromFamilySharingDelegate( IntPtr self ); private delegate bool FBIsSubscribedFromFamilySharing( IntPtr self );
private BIsSubscribedFromFamilySharingDelegate BIsSubscribedFromFamilySharingDelegatePointer; private FBIsSubscribedFromFamilySharing _BIsSubscribedFromFamilySharing;
#endregion #endregion
internal bool BIsSubscribedFromFamilySharing() internal bool BIsSubscribedFromFamilySharing()
{ {
return BIsSubscribedFromFamilySharingDelegatePointer( Self ); return _BIsSubscribedFromFamilySharing( Self );
} }
} }

584
Facepunch.Steamworks/Generated/Interfaces/ISteamFriends.cs
View File

File diff suppressed because it is too large Load Diff

352
Facepunch.Steamworks/Generated/Interfaces/ISteamGameServer.cs
View File

@ -17,546 +17,546 @@ namespace Steamworks
public override void InitInternals() public override void InitInternals()
{ {
InitGameServerDelegatePointer = Marshal.GetDelegateForFunctionPointer<InitGameServerDelegate>( Marshal.ReadIntPtr( VTable, 0) ); _InitGameServer = Marshal.GetDelegateForFunctionPointer<FInitGameServer>( Marshal.ReadIntPtr( VTable, 0) );
SetProductDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetProductDelegate>( Marshal.ReadIntPtr( VTable, 8) ); _SetProduct = Marshal.GetDelegateForFunctionPointer<FSetProduct>( Marshal.ReadIntPtr( VTable, 8) );
SetGameDescriptionDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetGameDescriptionDelegate>( Marshal.ReadIntPtr( VTable, 16) ); _SetGameDescription = Marshal.GetDelegateForFunctionPointer<FSetGameDescription>( Marshal.ReadIntPtr( VTable, 16) );
SetModDirDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetModDirDelegate>( Marshal.ReadIntPtr( VTable, 24) ); _SetModDir = Marshal.GetDelegateForFunctionPointer<FSetModDir>( Marshal.ReadIntPtr( VTable, 24) );
SetDedicatedServerDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetDedicatedServerDelegate>( Marshal.ReadIntPtr( VTable, 32) ); _SetDedicatedServer = Marshal.GetDelegateForFunctionPointer<FSetDedicatedServer>( Marshal.ReadIntPtr( VTable, 32) );
LogOnDelegatePointer = Marshal.GetDelegateForFunctionPointer<LogOnDelegate>( Marshal.ReadIntPtr( VTable, 40) ); _LogOn = Marshal.GetDelegateForFunctionPointer<FLogOn>( Marshal.ReadIntPtr( VTable, 40) );
LogOnAnonymousDelegatePointer = Marshal.GetDelegateForFunctionPointer<LogOnAnonymousDelegate>( Marshal.ReadIntPtr( VTable, 48) ); _LogOnAnonymous = Marshal.GetDelegateForFunctionPointer<FLogOnAnonymous>( Marshal.ReadIntPtr( VTable, 48) );
LogOffDelegatePointer = Marshal.GetDelegateForFunctionPointer<LogOffDelegate>( Marshal.ReadIntPtr( VTable, 56) ); _LogOff = Marshal.GetDelegateForFunctionPointer<FLogOff>( Marshal.ReadIntPtr( VTable, 56) );
BLoggedOnDelegatePointer = Marshal.GetDelegateForFunctionPointer<BLoggedOnDelegate>( Marshal.ReadIntPtr( VTable, 64) ); _BLoggedOn = Marshal.GetDelegateForFunctionPointer<FBLoggedOn>( Marshal.ReadIntPtr( VTable, 64) );
BSecureDelegatePointer = Marshal.GetDelegateForFunctionPointer<BSecureDelegate>( Marshal.ReadIntPtr( VTable, 72) ); _BSecure = Marshal.GetDelegateForFunctionPointer<FBSecure>( Marshal.ReadIntPtr( VTable, 72) );
GetSteamIDDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetSteamIDDelegate>( Marshal.ReadIntPtr( VTable, 80) ); _GetSteamID = Marshal.GetDelegateForFunctionPointer<FGetSteamID>( Marshal.ReadIntPtr( VTable, 80) );
WasRestartRequestedDelegatePointer = Marshal.GetDelegateForFunctionPointer<WasRestartRequestedDelegate>( Marshal.ReadIntPtr( VTable, 88) ); _WasRestartRequested = Marshal.GetDelegateForFunctionPointer<FWasRestartRequested>( Marshal.ReadIntPtr( VTable, 88) );
SetMaxPlayerCountDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetMaxPlayerCountDelegate>( Marshal.ReadIntPtr( VTable, 96) ); _SetMaxPlayerCount = Marshal.GetDelegateForFunctionPointer<FSetMaxPlayerCount>( Marshal.ReadIntPtr( VTable, 96) );
SetBotPlayerCountDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetBotPlayerCountDelegate>( Marshal.ReadIntPtr( VTable, 104) ); _SetBotPlayerCount = Marshal.GetDelegateForFunctionPointer<FSetBotPlayerCount>( Marshal.ReadIntPtr( VTable, 104) );
SetServerNameDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetServerNameDelegate>( Marshal.ReadIntPtr( VTable, 112) ); _SetServerName = Marshal.GetDelegateForFunctionPointer<FSetServerName>( Marshal.ReadIntPtr( VTable, 112) );
SetMapNameDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetMapNameDelegate>( Marshal.ReadIntPtr( VTable, 120) ); _SetMapName = Marshal.GetDelegateForFunctionPointer<FSetMapName>( Marshal.ReadIntPtr( VTable, 120) );
SetPasswordProtectedDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetPasswordProtectedDelegate>( Marshal.ReadIntPtr( VTable, 128) ); _SetPasswordProtected = Marshal.GetDelegateForFunctionPointer<FSetPasswordProtected>( Marshal.ReadIntPtr( VTable, 128) );
SetSpectatorPortDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetSpectatorPortDelegate>( Marshal.ReadIntPtr( VTable, 136) ); _SetSpectatorPort = Marshal.GetDelegateForFunctionPointer<FSetSpectatorPort>( Marshal.ReadIntPtr( VTable, 136) );
SetSpectatorServerNameDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetSpectatorServerNameDelegate>( Marshal.ReadIntPtr( VTable, 144) ); _SetSpectatorServerName = Marshal.GetDelegateForFunctionPointer<FSetSpectatorServerName>( Marshal.ReadIntPtr( VTable, 144) );
ClearAllKeyValuesDelegatePointer = Marshal.GetDelegateForFunctionPointer<ClearAllKeyValuesDelegate>( Marshal.ReadIntPtr( VTable, 152) ); _ClearAllKeyValues = Marshal.GetDelegateForFunctionPointer<FClearAllKeyValues>( Marshal.ReadIntPtr( VTable, 152) );
SetKeyValueDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetKeyValueDelegate>( Marshal.ReadIntPtr( VTable, 160) ); _SetKeyValue = Marshal.GetDelegateForFunctionPointer<FSetKeyValue>( Marshal.ReadIntPtr( VTable, 160) );
SetGameTagsDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetGameTagsDelegate>( Marshal.ReadIntPtr( VTable, 168) ); _SetGameTags = Marshal.GetDelegateForFunctionPointer<FSetGameTags>( Marshal.ReadIntPtr( VTable, 168) );
SetGameDataDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetGameDataDelegate>( Marshal.ReadIntPtr( VTable, 176) ); _SetGameData = Marshal.GetDelegateForFunctionPointer<FSetGameData>( Marshal.ReadIntPtr( VTable, 176) );
SetRegionDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetRegionDelegate>( Marshal.ReadIntPtr( VTable, 184) ); _SetRegion = Marshal.GetDelegateForFunctionPointer<FSetRegion>( Marshal.ReadIntPtr( VTable, 184) );
SendUserConnectAndAuthenticateDelegatePointer = Marshal.GetDelegateForFunctionPointer<SendUserConnectAndAuthenticateDelegate>( Marshal.ReadIntPtr( VTable, 192) ); _SendUserConnectAndAuthenticate = Marshal.GetDelegateForFunctionPointer<FSendUserConnectAndAuthenticate>( Marshal.ReadIntPtr( VTable, 192) );
CreateUnauthenticatedUserConnectionDelegatePointer = Marshal.GetDelegateForFunctionPointer<CreateUnauthenticatedUserConnectionDelegate>( Marshal.ReadIntPtr( VTable, 200) ); _CreateUnauthenticatedUserConnection = Marshal.GetDelegateForFunctionPointer<FCreateUnauthenticatedUserConnection>( Marshal.ReadIntPtr( VTable, 200) );
SendUserDisconnectDelegatePointer = Marshal.GetDelegateForFunctionPointer<SendUserDisconnectDelegate>( Marshal.ReadIntPtr( VTable, 208) ); _SendUserDisconnect = Marshal.GetDelegateForFunctionPointer<FSendUserDisconnect>( Marshal.ReadIntPtr( VTable, 208) );
BUpdateUserDataDelegatePointer = Marshal.GetDelegateForFunctionPointer<BUpdateUserDataDelegate>( Marshal.ReadIntPtr( VTable, 216) ); _BUpdateUserData = Marshal.GetDelegateForFunctionPointer<FBUpdateUserData>( Marshal.ReadIntPtr( VTable, 216) );
GetAuthSessionTicketDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAuthSessionTicketDelegate>( Marshal.ReadIntPtr( VTable, 224) ); _GetAuthSessionTicket = Marshal.GetDelegateForFunctionPointer<FGetAuthSessionTicket>( Marshal.ReadIntPtr( VTable, 224) );
BeginAuthSessionDelegatePointer = Marshal.GetDelegateForFunctionPointer<BeginAuthSessionDelegate>( Marshal.ReadIntPtr( VTable, 232) ); _BeginAuthSession = Marshal.GetDelegateForFunctionPointer<FBeginAuthSession>( Marshal.ReadIntPtr( VTable, 232) );
EndAuthSessionDelegatePointer = Marshal.GetDelegateForFunctionPointer<EndAuthSessionDelegate>( Marshal.ReadIntPtr( VTable, 240) ); _EndAuthSession = Marshal.GetDelegateForFunctionPointer<FEndAuthSession>( Marshal.ReadIntPtr( VTable, 240) );
CancelAuthTicketDelegatePointer = Marshal.GetDelegateForFunctionPointer<CancelAuthTicketDelegate>( Marshal.ReadIntPtr( VTable, 248) ); _CancelAuthTicket = Marshal.GetDelegateForFunctionPointer<FCancelAuthTicket>( Marshal.ReadIntPtr( VTable, 248) );
UserHasLicenseForAppDelegatePointer = Marshal.GetDelegateForFunctionPointer<UserHasLicenseForAppDelegate>( Marshal.ReadIntPtr( VTable, 256) ); _UserHasLicenseForApp = Marshal.GetDelegateForFunctionPointer<FUserHasLicenseForApp>( Marshal.ReadIntPtr( VTable, 256) );
RequestUserGroupStatusDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestUserGroupStatusDelegate>( Marshal.ReadIntPtr( VTable, 264) ); _RequestUserGroupStatus = Marshal.GetDelegateForFunctionPointer<FRequestUserGroupStatus>( Marshal.ReadIntPtr( VTable, 264) );
GetGameplayStatsDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetGameplayStatsDelegate>( Marshal.ReadIntPtr( VTable, 272) ); _GetGameplayStats = Marshal.GetDelegateForFunctionPointer<FGetGameplayStats>( Marshal.ReadIntPtr( VTable, 272) );
GetServerReputationDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetServerReputationDelegate>( Marshal.ReadIntPtr( VTable, 280) ); _GetServerReputation = Marshal.GetDelegateForFunctionPointer<FGetServerReputation>( Marshal.ReadIntPtr( VTable, 280) );
GetPublicIPDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetPublicIPDelegate>( Marshal.ReadIntPtr( VTable, 288) ); _GetPublicIP = Marshal.GetDelegateForFunctionPointer<FGetPublicIP>( Marshal.ReadIntPtr( VTable, 288) );
HandleIncomingPacketDelegatePointer = Marshal.GetDelegateForFunctionPointer<HandleIncomingPacketDelegate>( Marshal.ReadIntPtr( VTable, 296) ); _HandleIncomingPacket = Marshal.GetDelegateForFunctionPointer<FHandleIncomingPacket>( Marshal.ReadIntPtr( VTable, 296) );
GetNextOutgoingPacketDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetNextOutgoingPacketDelegate>( Marshal.ReadIntPtr( VTable, 304) ); _GetNextOutgoingPacket = Marshal.GetDelegateForFunctionPointer<FGetNextOutgoingPacket>( Marshal.ReadIntPtr( VTable, 304) );
EnableHeartbeatsDelegatePointer = Marshal.GetDelegateForFunctionPointer<EnableHeartbeatsDelegate>( Marshal.ReadIntPtr( VTable, 312) ); _EnableHeartbeats = Marshal.GetDelegateForFunctionPointer<FEnableHeartbeats>( Marshal.ReadIntPtr( VTable, 312) );
SetHeartbeatIntervalDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetHeartbeatIntervalDelegate>( Marshal.ReadIntPtr( VTable, 320) ); _SetHeartbeatInterval = Marshal.GetDelegateForFunctionPointer<FSetHeartbeatInterval>( Marshal.ReadIntPtr( VTable, 320) );
ForceHeartbeatDelegatePointer = Marshal.GetDelegateForFunctionPointer<ForceHeartbeatDelegate>( Marshal.ReadIntPtr( VTable, 328) ); _ForceHeartbeat = Marshal.GetDelegateForFunctionPointer<FForceHeartbeat>( Marshal.ReadIntPtr( VTable, 328) );
AssociateWithClanDelegatePointer = Marshal.GetDelegateForFunctionPointer<AssociateWithClanDelegate>( Marshal.ReadIntPtr( VTable, 336) ); _AssociateWithClan = Marshal.GetDelegateForFunctionPointer<FAssociateWithClan>( Marshal.ReadIntPtr( VTable, 336) );
ComputeNewPlayerCompatibilityDelegatePointer = Marshal.GetDelegateForFunctionPointer<ComputeNewPlayerCompatibilityDelegate>( Marshal.ReadIntPtr( VTable, 344) ); _ComputeNewPlayerCompatibility = Marshal.GetDelegateForFunctionPointer<FComputeNewPlayerCompatibility>( Marshal.ReadIntPtr( VTable, 344) );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool InitGameServerDelegate( IntPtr self, uint unIP, ushort usGamePort, ushort usQueryPort, uint unFlags, AppId_t nGameAppId, string pchVersionString ); private delegate bool FInitGameServer( IntPtr self, uint unIP, ushort usGamePort, ushort usQueryPort, uint unFlags, AppId_t nGameAppId, string pchVersionString );
private InitGameServerDelegate InitGameServerDelegatePointer; private FInitGameServer _InitGameServer;
#endregion #endregion
internal bool InitGameServer( uint unIP, ushort usGamePort, ushort usQueryPort, uint unFlags, AppId_t nGameAppId, string pchVersionString ) internal bool InitGameServer( uint unIP, ushort usGamePort, ushort usQueryPort, uint unFlags, AppId_t nGameAppId, string pchVersionString )
{ {
return InitGameServerDelegatePointer( Self, unIP, usGamePort, usQueryPort, unFlags, nGameAppId, pchVersionString ); return _InitGameServer( Self, unIP, usGamePort, usQueryPort, unFlags, nGameAppId, pchVersionString );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void SetProductDelegate( IntPtr self, string pszProduct ); private delegate void FSetProduct( IntPtr self, string pszProduct );
private SetProductDelegate SetProductDelegatePointer; private FSetProduct _SetProduct;
#endregion #endregion
internal void SetProduct( string pszProduct ) internal void SetProduct( string pszProduct )
{ {
SetProductDelegatePointer( Self, pszProduct ); _SetProduct( Self, pszProduct );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void SetGameDescriptionDelegate( IntPtr self, string pszGameDescription ); private delegate void FSetGameDescription( IntPtr self, string pszGameDescription );
private SetGameDescriptionDelegate SetGameDescriptionDelegatePointer; private FSetGameDescription _SetGameDescription;
#endregion #endregion
internal void SetGameDescription( string pszGameDescription ) internal void SetGameDescription( string pszGameDescription )
{ {
SetGameDescriptionDelegatePointer( Self, pszGameDescription ); _SetGameDescription( Self, pszGameDescription );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void SetModDirDelegate( IntPtr self, string pszModDir ); private delegate void FSetModDir( IntPtr self, string pszModDir );
private SetModDirDelegate SetModDirDelegatePointer; private FSetModDir _SetModDir;
#endregion #endregion
internal void SetModDir( string pszModDir ) internal void SetModDir( string pszModDir )
{ {
SetModDirDelegatePointer( Self, pszModDir ); _SetModDir( Self, pszModDir );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void SetDedicatedServerDelegate( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bDedicated ); private delegate void FSetDedicatedServer( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bDedicated );
private SetDedicatedServerDelegate SetDedicatedServerDelegatePointer; private FSetDedicatedServer _SetDedicatedServer;
#endregion #endregion
internal void SetDedicatedServer( [MarshalAs( UnmanagedType.U1 )] bool bDedicated ) internal void SetDedicatedServer( [MarshalAs( UnmanagedType.U1 )] bool bDedicated )
{ {
SetDedicatedServerDelegatePointer( Self, bDedicated ); _SetDedicatedServer( Self, bDedicated );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void LogOnDelegate( IntPtr self, string pszToken ); private delegate void FLogOn( IntPtr self, string pszToken );
private LogOnDelegate LogOnDelegatePointer; private FLogOn _LogOn;
#endregion #endregion
internal void LogOn( string pszToken ) internal void LogOn( string pszToken )
{ {
LogOnDelegatePointer( Self, pszToken ); _LogOn( Self, pszToken );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void LogOnAnonymousDelegate( IntPtr self ); private delegate void FLogOnAnonymous( IntPtr self );
private LogOnAnonymousDelegate LogOnAnonymousDelegatePointer; private FLogOnAnonymous _LogOnAnonymous;
#endregion #endregion
internal void LogOnAnonymous() internal void LogOnAnonymous()
{ {
LogOnAnonymousDelegatePointer( Self ); _LogOnAnonymous( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void LogOffDelegate( IntPtr self ); private delegate void FLogOff( IntPtr self );
private LogOffDelegate LogOffDelegatePointer; private FLogOff _LogOff;
#endregion #endregion
internal void LogOff() internal void LogOff()
{ {
LogOffDelegatePointer( Self ); _LogOff( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool BLoggedOnDelegate( IntPtr self ); private delegate bool FBLoggedOn( IntPtr self );
private BLoggedOnDelegate BLoggedOnDelegatePointer; private FBLoggedOn _BLoggedOn;
#endregion #endregion
internal bool BLoggedOn() internal bool BLoggedOn()
{ {
return BLoggedOnDelegatePointer( Self ); return _BLoggedOn( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool BSecureDelegate( IntPtr self ); private delegate bool FBSecure( IntPtr self );
private BSecureDelegate BSecureDelegatePointer; private FBSecure _BSecure;
#endregion #endregion
internal bool BSecure() internal bool BSecure()
{ {
return BSecureDelegatePointer( Self ); return _BSecure( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void GetSteamIDDelegate( IntPtr self, ref SteamId retVal ); private delegate void FGetSteamID( IntPtr self, ref SteamId retVal );
private GetSteamIDDelegate GetSteamIDDelegatePointer; private FGetSteamID _GetSteamID;
#endregion #endregion
internal SteamId GetSteamID() internal SteamId GetSteamID()
{ {
var retVal = default( SteamId ); var retVal = default( SteamId );
GetSteamIDDelegatePointer( Self, ref retVal ); _GetSteamID( Self, ref retVal );
return retVal; return retVal;
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool WasRestartRequestedDelegate( IntPtr self ); private delegate bool FWasRestartRequested( IntPtr self );
private WasRestartRequestedDelegate WasRestartRequestedDelegatePointer; private FWasRestartRequested _WasRestartRequested;
#endregion #endregion
internal bool WasRestartRequested() internal bool WasRestartRequested()
{ {
return WasRestartRequestedDelegatePointer( Self ); return _WasRestartRequested( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void SetMaxPlayerCountDelegate( IntPtr self, int cPlayersMax ); private delegate void FSetMaxPlayerCount( IntPtr self, int cPlayersMax );
private SetMaxPlayerCountDelegate SetMaxPlayerCountDelegatePointer; private FSetMaxPlayerCount _SetMaxPlayerCount;
#endregion #endregion
internal void SetMaxPlayerCount( int cPlayersMax ) internal void SetMaxPlayerCount( int cPlayersMax )
{ {
SetMaxPlayerCountDelegatePointer( Self, cPlayersMax ); _SetMaxPlayerCount( Self, cPlayersMax );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void SetBotPlayerCountDelegate( IntPtr self, int cBotplayers ); private delegate void FSetBotPlayerCount( IntPtr self, int cBotplayers );
private SetBotPlayerCountDelegate SetBotPlayerCountDelegatePointer; private FSetBotPlayerCount _SetBotPlayerCount;
#endregion #endregion
internal void SetBotPlayerCount( int cBotplayers ) internal void SetBotPlayerCount( int cBotplayers )
{ {
SetBotPlayerCountDelegatePointer( Self, cBotplayers ); _SetBotPlayerCount( Self, cBotplayers );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void SetServerNameDelegate( IntPtr self, string pszServerName ); private delegate void FSetServerName( IntPtr self, string pszServerName );
private SetServerNameDelegate SetServerNameDelegatePointer; private FSetServerName _SetServerName;
#endregion #endregion
internal void SetServerName( string pszServerName ) internal void SetServerName( string pszServerName )
{ {
SetServerNameDelegatePointer( Self, pszServerName ); _SetServerName( Self, pszServerName );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void SetMapNameDelegate( IntPtr self, string pszMapName ); private delegate void FSetMapName( IntPtr self, string pszMapName );
private SetMapNameDelegate SetMapNameDelegatePointer; private FSetMapName _SetMapName;
#endregion #endregion
internal void SetMapName( string pszMapName ) internal void SetMapName( string pszMapName )
{ {
SetMapNameDelegatePointer( Self, pszMapName ); _SetMapName( Self, pszMapName );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void SetPasswordProtectedDelegate( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bPasswordProtected ); private delegate void FSetPasswordProtected( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bPasswordProtected );
private SetPasswordProtectedDelegate SetPasswordProtectedDelegatePointer; private FSetPasswordProtected _SetPasswordProtected;
#endregion #endregion
internal void SetPasswordProtected( [MarshalAs( UnmanagedType.U1 )] bool bPasswordProtected ) internal void SetPasswordProtected( [MarshalAs( UnmanagedType.U1 )] bool bPasswordProtected )
{ {
SetPasswordProtectedDelegatePointer( Self, bPasswordProtected ); _SetPasswordProtected( Self, bPasswordProtected );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void SetSpectatorPortDelegate( IntPtr self, ushort unSpectatorPort ); private delegate void FSetSpectatorPort( IntPtr self, ushort unSpectatorPort );
private SetSpectatorPortDelegate SetSpectatorPortDelegatePointer; private FSetSpectatorPort _SetSpectatorPort;
#endregion #endregion
internal void SetSpectatorPort( ushort unSpectatorPort ) internal void SetSpectatorPort( ushort unSpectatorPort )
{ {
SetSpectatorPortDelegatePointer( Self, unSpectatorPort ); _SetSpectatorPort( Self, unSpectatorPort );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void SetSpectatorServerNameDelegate( IntPtr self, string pszSpectatorServerName ); private delegate void FSetSpectatorServerName( IntPtr self, string pszSpectatorServerName );
private SetSpectatorServerNameDelegate SetSpectatorServerNameDelegatePointer; private FSetSpectatorServerName _SetSpectatorServerName;
#endregion #endregion
internal void SetSpectatorServerName( string pszSpectatorServerName ) internal void SetSpectatorServerName( string pszSpectatorServerName )
{ {
SetSpectatorServerNameDelegatePointer( Self, pszSpectatorServerName ); _SetSpectatorServerName( Self, pszSpectatorServerName );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void ClearAllKeyValuesDelegate( IntPtr self ); private delegate void FClearAllKeyValues( IntPtr self );
private ClearAllKeyValuesDelegate ClearAllKeyValuesDelegatePointer; private FClearAllKeyValues _ClearAllKeyValues;
#endregion #endregion
internal void ClearAllKeyValues() internal void ClearAllKeyValues()
{ {
ClearAllKeyValuesDelegatePointer( Self ); _ClearAllKeyValues( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void SetKeyValueDelegate( IntPtr self, string pKey, string pValue ); private delegate void FSetKeyValue( IntPtr self, string pKey, string pValue );
private SetKeyValueDelegate SetKeyValueDelegatePointer; private FSetKeyValue _SetKeyValue;
#endregion #endregion
internal void SetKeyValue( string pKey, string pValue ) internal void SetKeyValue( string pKey, string pValue )
{ {
SetKeyValueDelegatePointer( Self, pKey, pValue ); _SetKeyValue( Self, pKey, pValue );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void SetGameTagsDelegate( IntPtr self, string pchGameTags ); private delegate void FSetGameTags( IntPtr self, string pchGameTags );
private SetGameTagsDelegate SetGameTagsDelegatePointer; private FSetGameTags _SetGameTags;
#endregion #endregion
internal void SetGameTags( string pchGameTags ) internal void SetGameTags( string pchGameTags )
{ {
SetGameTagsDelegatePointer( Self, pchGameTags ); _SetGameTags( Self, pchGameTags );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void SetGameDataDelegate( IntPtr self, string pchGameData ); private delegate void FSetGameData( IntPtr self, string pchGameData );
private SetGameDataDelegate SetGameDataDelegatePointer; private FSetGameData _SetGameData;
#endregion #endregion
internal void SetGameData( string pchGameData ) internal void SetGameData( string pchGameData )
{ {
SetGameDataDelegatePointer( Self, pchGameData ); _SetGameData( Self, pchGameData );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void SetRegionDelegate( IntPtr self, string pszRegion ); private delegate void FSetRegion( IntPtr self, string pszRegion );
private SetRegionDelegate SetRegionDelegatePointer; private FSetRegion _SetRegion;
#endregion #endregion
internal void SetRegion( string pszRegion ) internal void SetRegion( string pszRegion )
{ {
SetRegionDelegatePointer( Self, pszRegion ); _SetRegion( Self, pszRegion );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool SendUserConnectAndAuthenticateDelegate( IntPtr self, uint unIPClient, IntPtr pvAuthBlob, uint cubAuthBlobSize, ref SteamId pSteamIDUser ); private delegate bool FSendUserConnectAndAuthenticate( IntPtr self, uint unIPClient, IntPtr pvAuthBlob, uint cubAuthBlobSize, ref SteamId pSteamIDUser );
private SendUserConnectAndAuthenticateDelegate SendUserConnectAndAuthenticateDelegatePointer; private FSendUserConnectAndAuthenticate _SendUserConnectAndAuthenticate;
#endregion #endregion
internal bool SendUserConnectAndAuthenticate( uint unIPClient, IntPtr pvAuthBlob, uint cubAuthBlobSize, ref SteamId pSteamIDUser ) internal bool SendUserConnectAndAuthenticate( uint unIPClient, IntPtr pvAuthBlob, uint cubAuthBlobSize, ref SteamId pSteamIDUser )
{ {
return SendUserConnectAndAuthenticateDelegatePointer( Self, unIPClient, pvAuthBlob, cubAuthBlobSize, ref pSteamIDUser ); return _SendUserConnectAndAuthenticate( Self, unIPClient, pvAuthBlob, cubAuthBlobSize, ref pSteamIDUser );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void CreateUnauthenticatedUserConnectionDelegate( IntPtr self, ref SteamId retVal ); private delegate void FCreateUnauthenticatedUserConnection( IntPtr self, ref SteamId retVal );
private CreateUnauthenticatedUserConnectionDelegate CreateUnauthenticatedUserConnectionDelegatePointer; private FCreateUnauthenticatedUserConnection _CreateUnauthenticatedUserConnection;
#endregion #endregion
internal SteamId CreateUnauthenticatedUserConnection() internal SteamId CreateUnauthenticatedUserConnection()
{ {
var retVal = default( SteamId ); var retVal = default( SteamId );
CreateUnauthenticatedUserConnectionDelegatePointer( Self, ref retVal ); _CreateUnauthenticatedUserConnection( Self, ref retVal );
return retVal; return retVal;
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void SendUserDisconnectDelegate( IntPtr self, SteamId steamIDUser ); private delegate void FSendUserDisconnect( IntPtr self, SteamId steamIDUser );
private SendUserDisconnectDelegate SendUserDisconnectDelegatePointer; private FSendUserDisconnect _SendUserDisconnect;
#endregion #endregion
internal void SendUserDisconnect( SteamId steamIDUser ) internal void SendUserDisconnect( SteamId steamIDUser )
{ {
SendUserDisconnectDelegatePointer( Self, steamIDUser ); _SendUserDisconnect( Self, steamIDUser );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool BUpdateUserDataDelegate( IntPtr self, SteamId steamIDUser, string pchPlayerName, uint uScore ); private delegate bool FBUpdateUserData( IntPtr self, SteamId steamIDUser, string pchPlayerName, uint uScore );
private BUpdateUserDataDelegate BUpdateUserDataDelegatePointer; private FBUpdateUserData _BUpdateUserData;
#endregion #endregion
internal bool BUpdateUserData( SteamId steamIDUser, string pchPlayerName, uint uScore ) internal bool BUpdateUserData( SteamId steamIDUser, string pchPlayerName, uint uScore )
{ {
return BUpdateUserDataDelegatePointer( Self, steamIDUser, pchPlayerName, uScore ); return _BUpdateUserData( Self, steamIDUser, pchPlayerName, uScore );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate HAuthTicket GetAuthSessionTicketDelegate( IntPtr self, IntPtr pTicket, int cbMaxTicket, ref uint pcbTicket ); private delegate HAuthTicket FGetAuthSessionTicket( IntPtr self, IntPtr pTicket, int cbMaxTicket, ref uint pcbTicket );
private GetAuthSessionTicketDelegate GetAuthSessionTicketDelegatePointer; private FGetAuthSessionTicket _GetAuthSessionTicket;
#endregion #endregion
internal HAuthTicket GetAuthSessionTicket( IntPtr pTicket, int cbMaxTicket, ref uint pcbTicket ) internal HAuthTicket GetAuthSessionTicket( IntPtr pTicket, int cbMaxTicket, ref uint pcbTicket )
{ {
return GetAuthSessionTicketDelegatePointer( Self, pTicket, cbMaxTicket, ref pcbTicket ); return _GetAuthSessionTicket( Self, pTicket, cbMaxTicket, ref pcbTicket );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate BeginAuthResult BeginAuthSessionDelegate( IntPtr self, IntPtr pAuthTicket, int cbAuthTicket, SteamId steamID ); private delegate BeginAuthResult FBeginAuthSession( IntPtr self, IntPtr pAuthTicket, int cbAuthTicket, SteamId steamID );
private BeginAuthSessionDelegate BeginAuthSessionDelegatePointer; private FBeginAuthSession _BeginAuthSession;
#endregion #endregion
internal BeginAuthResult BeginAuthSession( IntPtr pAuthTicket, int cbAuthTicket, SteamId steamID ) internal BeginAuthResult BeginAuthSession( IntPtr pAuthTicket, int cbAuthTicket, SteamId steamID )
{ {
return BeginAuthSessionDelegatePointer( Self, pAuthTicket, cbAuthTicket, steamID ); return _BeginAuthSession( Self, pAuthTicket, cbAuthTicket, steamID );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void EndAuthSessionDelegate( IntPtr self, SteamId steamID ); private delegate void FEndAuthSession( IntPtr self, SteamId steamID );
private EndAuthSessionDelegate EndAuthSessionDelegatePointer; private FEndAuthSession _EndAuthSession;
#endregion #endregion
internal void EndAuthSession( SteamId steamID ) internal void EndAuthSession( SteamId steamID )
{ {
EndAuthSessionDelegatePointer( Self, steamID ); _EndAuthSession( Self, steamID );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void CancelAuthTicketDelegate( IntPtr self, HAuthTicket hAuthTicket ); private delegate void FCancelAuthTicket( IntPtr self, HAuthTicket hAuthTicket );
private CancelAuthTicketDelegate CancelAuthTicketDelegatePointer; private FCancelAuthTicket _CancelAuthTicket;
#endregion #endregion
internal void CancelAuthTicket( HAuthTicket hAuthTicket ) internal void CancelAuthTicket( HAuthTicket hAuthTicket )
{ {
CancelAuthTicketDelegatePointer( Self, hAuthTicket ); _CancelAuthTicket( Self, hAuthTicket );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate UserHasLicenseForAppResult UserHasLicenseForAppDelegate( IntPtr self, SteamId steamID, AppId_t appID ); private delegate UserHasLicenseForAppResult FUserHasLicenseForApp( IntPtr self, SteamId steamID, AppId_t appID );
private UserHasLicenseForAppDelegate UserHasLicenseForAppDelegatePointer; private FUserHasLicenseForApp _UserHasLicenseForApp;
#endregion #endregion
internal UserHasLicenseForAppResult UserHasLicenseForApp( SteamId steamID, AppId_t appID ) internal UserHasLicenseForAppResult UserHasLicenseForApp( SteamId steamID, AppId_t appID )
{ {
return UserHasLicenseForAppDelegatePointer( Self, steamID, appID ); return _UserHasLicenseForApp( Self, steamID, appID );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool RequestUserGroupStatusDelegate( IntPtr self, SteamId steamIDUser, SteamId steamIDGroup ); private delegate bool FRequestUserGroupStatus( IntPtr self, SteamId steamIDUser, SteamId steamIDGroup );
private RequestUserGroupStatusDelegate RequestUserGroupStatusDelegatePointer; private FRequestUserGroupStatus _RequestUserGroupStatus;
#endregion #endregion
internal bool RequestUserGroupStatus( SteamId steamIDUser, SteamId steamIDGroup ) internal bool RequestUserGroupStatus( SteamId steamIDUser, SteamId steamIDGroup )
{ {
return RequestUserGroupStatusDelegatePointer( Self, steamIDUser, steamIDGroup ); return _RequestUserGroupStatus( Self, steamIDUser, steamIDGroup );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void GetGameplayStatsDelegate( IntPtr self ); private delegate void FGetGameplayStats( IntPtr self );
private GetGameplayStatsDelegate GetGameplayStatsDelegatePointer; private FGetGameplayStats _GetGameplayStats;
#endregion #endregion
internal void GetGameplayStats() internal void GetGameplayStats()
{ {
GetGameplayStatsDelegatePointer( Self ); _GetGameplayStats( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate SteamAPICall_t GetServerReputationDelegate( IntPtr self ); private delegate SteamAPICall_t FGetServerReputation( IntPtr self );
private GetServerReputationDelegate GetServerReputationDelegatePointer; private FGetServerReputation _GetServerReputation;
#endregion #endregion
internal async Task<GSReputation_t?> GetServerReputation() internal async Task<GSReputation_t?> GetServerReputation()
{ {
return await (new Result<GSReputation_t>( GetServerReputationDelegatePointer( Self ) )).GetResult(); return await (new Result<GSReputation_t>( _GetServerReputation( Self ) )).GetResult();
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate uint GetPublicIPDelegate( IntPtr self ); private delegate uint FGetPublicIP( IntPtr self );
private GetPublicIPDelegate GetPublicIPDelegatePointer; private FGetPublicIP _GetPublicIP;
#endregion #endregion
internal uint GetPublicIP() internal uint GetPublicIP()
{ {
return GetPublicIPDelegatePointer( Self ); return _GetPublicIP( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool HandleIncomingPacketDelegate( IntPtr self, IntPtr pData, int cbData, uint srcIP, ushort srcPort ); private delegate bool FHandleIncomingPacket( IntPtr self, IntPtr pData, int cbData, uint srcIP, ushort srcPort );
private HandleIncomingPacketDelegate HandleIncomingPacketDelegatePointer; private FHandleIncomingPacket _HandleIncomingPacket;
#endregion #endregion
internal bool HandleIncomingPacket( IntPtr pData, int cbData, uint srcIP, ushort srcPort ) internal bool HandleIncomingPacket( IntPtr pData, int cbData, uint srcIP, ushort srcPort )
{ {
return HandleIncomingPacketDelegatePointer( Self, pData, cbData, srcIP, srcPort ); return _HandleIncomingPacket( Self, pData, cbData, srcIP, srcPort );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate int GetNextOutgoingPacketDelegate( IntPtr self, IntPtr pOut, int cbMaxOut, ref uint pNetAdr, ref ushort pPort ); private delegate int FGetNextOutgoingPacket( IntPtr self, IntPtr pOut, int cbMaxOut, ref uint pNetAdr, ref ushort pPort );
private GetNextOutgoingPacketDelegate GetNextOutgoingPacketDelegatePointer; private FGetNextOutgoingPacket _GetNextOutgoingPacket;
#endregion #endregion
internal int GetNextOutgoingPacket( IntPtr pOut, int cbMaxOut, ref uint pNetAdr, ref ushort pPort ) internal int GetNextOutgoingPacket( IntPtr pOut, int cbMaxOut, ref uint pNetAdr, ref ushort pPort )
{ {
return GetNextOutgoingPacketDelegatePointer( Self, pOut, cbMaxOut, ref pNetAdr, ref pPort ); return _GetNextOutgoingPacket( Self, pOut, cbMaxOut, ref pNetAdr, ref pPort );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void EnableHeartbeatsDelegate( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bActive ); private delegate void FEnableHeartbeats( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bActive );
private EnableHeartbeatsDelegate EnableHeartbeatsDelegatePointer; private FEnableHeartbeats _EnableHeartbeats;
#endregion #endregion
internal void EnableHeartbeats( [MarshalAs( UnmanagedType.U1 )] bool bActive ) internal void EnableHeartbeats( [MarshalAs( UnmanagedType.U1 )] bool bActive )
{ {
EnableHeartbeatsDelegatePointer( Self, bActive ); _EnableHeartbeats( Self, bActive );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void SetHeartbeatIntervalDelegate( IntPtr self, int iHeartbeatInterval ); private delegate void FSetHeartbeatInterval( IntPtr self, int iHeartbeatInterval );
private SetHeartbeatIntervalDelegate SetHeartbeatIntervalDelegatePointer; private FSetHeartbeatInterval _SetHeartbeatInterval;
#endregion #endregion
internal void SetHeartbeatInterval( int iHeartbeatInterval ) internal void SetHeartbeatInterval( int iHeartbeatInterval )
{ {
SetHeartbeatIntervalDelegatePointer( Self, iHeartbeatInterval ); _SetHeartbeatInterval( Self, iHeartbeatInterval );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void ForceHeartbeatDelegate( IntPtr self ); private delegate void FForceHeartbeat( IntPtr self );
private ForceHeartbeatDelegate ForceHeartbeatDelegatePointer; private FForceHeartbeat _ForceHeartbeat;
#endregion #endregion
internal void ForceHeartbeat() internal void ForceHeartbeat()
{ {
ForceHeartbeatDelegatePointer( Self ); _ForceHeartbeat( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate SteamAPICall_t AssociateWithClanDelegate( IntPtr self, SteamId steamIDClan ); private delegate SteamAPICall_t FAssociateWithClan( IntPtr self, SteamId steamIDClan );
private AssociateWithClanDelegate AssociateWithClanDelegatePointer; private FAssociateWithClan _AssociateWithClan;
#endregion #endregion
internal async Task<AssociateWithClanResult_t?> AssociateWithClan( SteamId steamIDClan ) internal async Task<AssociateWithClanResult_t?> AssociateWithClan( SteamId steamIDClan )
{ {
return await (new Result<AssociateWithClanResult_t>( AssociateWithClanDelegatePointer( Self, steamIDClan ) )).GetResult(); return await (new Result<AssociateWithClanResult_t>( _AssociateWithClan( Self, steamIDClan ) )).GetResult();
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate SteamAPICall_t ComputeNewPlayerCompatibilityDelegate( IntPtr self, SteamId steamIDNewPlayer ); private delegate SteamAPICall_t FComputeNewPlayerCompatibility( IntPtr self, SteamId steamIDNewPlayer );
private ComputeNewPlayerCompatibilityDelegate ComputeNewPlayerCompatibilityDelegatePointer; private FComputeNewPlayerCompatibility _ComputeNewPlayerCompatibility;
#endregion #endregion
internal async Task<ComputeNewPlayerCompatibilityResult_t?> ComputeNewPlayerCompatibility( SteamId steamIDNewPlayer ) internal async Task<ComputeNewPlayerCompatibilityResult_t?> ComputeNewPlayerCompatibility( SteamId steamIDNewPlayer )
{ {
return await (new Result<ComputeNewPlayerCompatibilityResult_t>( ComputeNewPlayerCompatibilityDelegatePointer( Self, steamIDNewPlayer ) )).GetResult(); return await (new Result<ComputeNewPlayerCompatibilityResult_t>( _ComputeNewPlayerCompatibility( Self, steamIDNewPlayer ) )).GetResult();
} }
} }

136
Facepunch.Steamworks/Generated/Interfaces/ISteamMatchmakingServers.cs
View File

@ -17,211 +17,211 @@ namespace Steamworks
public override void InitInternals() public override void InitInternals()
{ {
RequestInternetServerListDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestInternetServerListDelegate>( Marshal.ReadIntPtr( VTable, 0) ); _RequestInternetServerList = Marshal.GetDelegateForFunctionPointer<FRequestInternetServerList>( Marshal.ReadIntPtr( VTable, 0) );
RequestLANServerListDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestLANServerListDelegate>( Marshal.ReadIntPtr( VTable, 8) ); _RequestLANServerList = Marshal.GetDelegateForFunctionPointer<FRequestLANServerList>( Marshal.ReadIntPtr( VTable, 8) );
RequestFriendsServerListDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestFriendsServerListDelegate>( Marshal.ReadIntPtr( VTable, 16) ); _RequestFriendsServerList = Marshal.GetDelegateForFunctionPointer<FRequestFriendsServerList>( Marshal.ReadIntPtr( VTable, 16) );
RequestFavoritesServerListDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestFavoritesServerListDelegate>( Marshal.ReadIntPtr( VTable, 24) ); _RequestFavoritesServerList = Marshal.GetDelegateForFunctionPointer<FRequestFavoritesServerList>( Marshal.ReadIntPtr( VTable, 24) );
RequestHistoryServerListDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestHistoryServerListDelegate>( Marshal.ReadIntPtr( VTable, 32) ); _RequestHistoryServerList = Marshal.GetDelegateForFunctionPointer<FRequestHistoryServerList>( Marshal.ReadIntPtr( VTable, 32) );
RequestSpectatorServerListDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestSpectatorServerListDelegate>( Marshal.ReadIntPtr( VTable, 40) ); _RequestSpectatorServerList = Marshal.GetDelegateForFunctionPointer<FRequestSpectatorServerList>( Marshal.ReadIntPtr( VTable, 40) );
ReleaseRequestDelegatePointer = Marshal.GetDelegateForFunctionPointer<ReleaseRequestDelegate>( Marshal.ReadIntPtr( VTable, 48) ); _ReleaseRequest = Marshal.GetDelegateForFunctionPointer<FReleaseRequest>( Marshal.ReadIntPtr( VTable, 48) );
GetServerDetailsDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetServerDetailsDelegate>( Marshal.ReadIntPtr( VTable, 56) ); _GetServerDetails = Marshal.GetDelegateForFunctionPointer<FGetServerDetails>( Marshal.ReadIntPtr( VTable, 56) );
CancelQueryDelegatePointer = Marshal.GetDelegateForFunctionPointer<CancelQueryDelegate>( Marshal.ReadIntPtr( VTable, 64) ); _CancelQuery = Marshal.GetDelegateForFunctionPointer<FCancelQuery>( Marshal.ReadIntPtr( VTable, 64) );
RefreshQueryDelegatePointer = Marshal.GetDelegateForFunctionPointer<RefreshQueryDelegate>( Marshal.ReadIntPtr( VTable, 72) ); _RefreshQuery = Marshal.GetDelegateForFunctionPointer<FRefreshQuery>( Marshal.ReadIntPtr( VTable, 72) );
IsRefreshingDelegatePointer = Marshal.GetDelegateForFunctionPointer<IsRefreshingDelegate>( Marshal.ReadIntPtr( VTable, 80) ); _IsRefreshing = Marshal.GetDelegateForFunctionPointer<FIsRefreshing>( Marshal.ReadIntPtr( VTable, 80) );
GetServerCountDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetServerCountDelegate>( Marshal.ReadIntPtr( VTable, 88) ); _GetServerCount = Marshal.GetDelegateForFunctionPointer<FGetServerCount>( Marshal.ReadIntPtr( VTable, 88) );
RefreshServerDelegatePointer = Marshal.GetDelegateForFunctionPointer<RefreshServerDelegate>( Marshal.ReadIntPtr( VTable, 96) ); _RefreshServer = Marshal.GetDelegateForFunctionPointer<FRefreshServer>( Marshal.ReadIntPtr( VTable, 96) );
PingServerDelegatePointer = Marshal.GetDelegateForFunctionPointer<PingServerDelegate>( Marshal.ReadIntPtr( VTable, 104) ); _PingServer = Marshal.GetDelegateForFunctionPointer<FPingServer>( Marshal.ReadIntPtr( VTable, 104) );
PlayerDetailsDelegatePointer = Marshal.GetDelegateForFunctionPointer<PlayerDetailsDelegate>( Marshal.ReadIntPtr( VTable, 112) ); _PlayerDetails = Marshal.GetDelegateForFunctionPointer<FPlayerDetails>( Marshal.ReadIntPtr( VTable, 112) );
ServerRulesDelegatePointer = Marshal.GetDelegateForFunctionPointer<ServerRulesDelegate>( Marshal.ReadIntPtr( VTable, 120) ); _ServerRules = Marshal.GetDelegateForFunctionPointer<FServerRules>( Marshal.ReadIntPtr( VTable, 120) );
CancelServerQueryDelegatePointer = Marshal.GetDelegateForFunctionPointer<CancelServerQueryDelegate>( Marshal.ReadIntPtr( VTable, 128) ); _CancelServerQuery = Marshal.GetDelegateForFunctionPointer<FCancelServerQuery>( Marshal.ReadIntPtr( VTable, 128) );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate HServerListRequest RequestInternetServerListDelegate( IntPtr self, AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse ); private delegate HServerListRequest FRequestInternetServerList( IntPtr self, AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse );
private RequestInternetServerListDelegate RequestInternetServerListDelegatePointer; private FRequestInternetServerList _RequestInternetServerList;
#endregion #endregion
internal HServerListRequest RequestInternetServerList( AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse ) internal HServerListRequest RequestInternetServerList( AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse )
{ {
return RequestInternetServerListDelegatePointer( Self, iApp, ref ppchFilters, nFilters, pRequestServersResponse ); return _RequestInternetServerList( Self, iApp, ref ppchFilters, nFilters, pRequestServersResponse );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate HServerListRequest RequestLANServerListDelegate( IntPtr self, AppId_t iApp, IntPtr pRequestServersResponse ); private delegate HServerListRequest FRequestLANServerList( IntPtr self, AppId_t iApp, IntPtr pRequestServersResponse );
private RequestLANServerListDelegate RequestLANServerListDelegatePointer; private FRequestLANServerList _RequestLANServerList;
#endregion #endregion
internal HServerListRequest RequestLANServerList( AppId_t iApp, IntPtr pRequestServersResponse ) internal HServerListRequest RequestLANServerList( AppId_t iApp, IntPtr pRequestServersResponse )
{ {
return RequestLANServerListDelegatePointer( Self, iApp, pRequestServersResponse ); return _RequestLANServerList( Self, iApp, pRequestServersResponse );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate HServerListRequest RequestFriendsServerListDelegate( IntPtr self, AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse ); private delegate HServerListRequest FRequestFriendsServerList( IntPtr self, AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse );
private RequestFriendsServerListDelegate RequestFriendsServerListDelegatePointer; private FRequestFriendsServerList _RequestFriendsServerList;
#endregion #endregion
internal HServerListRequest RequestFriendsServerList( AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse ) internal HServerListRequest RequestFriendsServerList( AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse )
{ {
return RequestFriendsServerListDelegatePointer( Self, iApp, ref ppchFilters, nFilters, pRequestServersResponse ); return _RequestFriendsServerList( Self, iApp, ref ppchFilters, nFilters, pRequestServersResponse );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate HServerListRequest RequestFavoritesServerListDelegate( IntPtr self, AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse ); private delegate HServerListRequest FRequestFavoritesServerList( IntPtr self, AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse );
private RequestFavoritesServerListDelegate RequestFavoritesServerListDelegatePointer; private FRequestFavoritesServerList _RequestFavoritesServerList;
#endregion #endregion
internal HServerListRequest RequestFavoritesServerList( AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse ) internal HServerListRequest RequestFavoritesServerList( AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse )
{ {
return RequestFavoritesServerListDelegatePointer( Self, iApp, ref ppchFilters, nFilters, pRequestServersResponse ); return _RequestFavoritesServerList( Self, iApp, ref ppchFilters, nFilters, pRequestServersResponse );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate HServerListRequest RequestHistoryServerListDelegate( IntPtr self, AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse ); private delegate HServerListRequest FRequestHistoryServerList( IntPtr self, AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse );
private RequestHistoryServerListDelegate RequestHistoryServerListDelegatePointer; private FRequestHistoryServerList _RequestHistoryServerList;
#endregion #endregion
internal HServerListRequest RequestHistoryServerList( AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse ) internal HServerListRequest RequestHistoryServerList( AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse )
{ {
return RequestHistoryServerListDelegatePointer( Self, iApp, ref ppchFilters, nFilters, pRequestServersResponse ); return _RequestHistoryServerList( Self, iApp, ref ppchFilters, nFilters, pRequestServersResponse );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate HServerListRequest RequestSpectatorServerListDelegate( IntPtr self, AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse ); private delegate HServerListRequest FRequestSpectatorServerList( IntPtr self, AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse );
private RequestSpectatorServerListDelegate RequestSpectatorServerListDelegatePointer; private FRequestSpectatorServerList _RequestSpectatorServerList;
#endregion #endregion
internal HServerListRequest RequestSpectatorServerList( AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse ) internal HServerListRequest RequestSpectatorServerList( AppId_t iApp, [In,Out] ref MatchMakingKeyValuePair_t[] ppchFilters, uint nFilters, IntPtr pRequestServersResponse )
{ {
return RequestSpectatorServerListDelegatePointer( Self, iApp, ref ppchFilters, nFilters, pRequestServersResponse ); return _RequestSpectatorServerList( Self, iApp, ref ppchFilters, nFilters, pRequestServersResponse );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void ReleaseRequestDelegate( IntPtr self, HServerListRequest hServerListRequest ); private delegate void FReleaseRequest( IntPtr self, HServerListRequest hServerListRequest );
private ReleaseRequestDelegate ReleaseRequestDelegatePointer; private FReleaseRequest _ReleaseRequest;
#endregion #endregion
internal void ReleaseRequest( HServerListRequest hServerListRequest ) internal void ReleaseRequest( HServerListRequest hServerListRequest )
{ {
ReleaseRequestDelegatePointer( Self, hServerListRequest ); _ReleaseRequest( Self, hServerListRequest );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate IntPtr GetServerDetailsDelegate( IntPtr self, HServerListRequest hRequest, int iServer ); private delegate IntPtr FGetServerDetails( IntPtr self, HServerListRequest hRequest, int iServer );
private GetServerDetailsDelegate GetServerDetailsDelegatePointer; private FGetServerDetails _GetServerDetails;
#endregion #endregion
internal gameserveritem_t GetServerDetails( HServerListRequest hRequest, int iServer ) internal gameserveritem_t GetServerDetails( HServerListRequest hRequest, int iServer )
{ {
return new gameserveritem_t().Fill( GetServerDetailsDelegatePointer( Self, hRequest, iServer ) ); return new gameserveritem_t().Fill( _GetServerDetails( Self, hRequest, iServer ) );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void CancelQueryDelegate( IntPtr self, HServerListRequest hRequest ); private delegate void FCancelQuery( IntPtr self, HServerListRequest hRequest );
private CancelQueryDelegate CancelQueryDelegatePointer; private FCancelQuery _CancelQuery;
#endregion #endregion
internal void CancelQuery( HServerListRequest hRequest ) internal void CancelQuery( HServerListRequest hRequest )
{ {
CancelQueryDelegatePointer( Self, hRequest ); _CancelQuery( Self, hRequest );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void RefreshQueryDelegate( IntPtr self, HServerListRequest hRequest ); private delegate void FRefreshQuery( IntPtr self, HServerListRequest hRequest );
private RefreshQueryDelegate RefreshQueryDelegatePointer; private FRefreshQuery _RefreshQuery;
#endregion #endregion
internal void RefreshQuery( HServerListRequest hRequest ) internal void RefreshQuery( HServerListRequest hRequest )
{ {
RefreshQueryDelegatePointer( Self, hRequest ); _RefreshQuery( Self, hRequest );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool IsRefreshingDelegate( IntPtr self, HServerListRequest hRequest ); private delegate bool FIsRefreshing( IntPtr self, HServerListRequest hRequest );
private IsRefreshingDelegate IsRefreshingDelegatePointer; private FIsRefreshing _IsRefreshing;
#endregion #endregion
internal bool IsRefreshing( HServerListRequest hRequest ) internal bool IsRefreshing( HServerListRequest hRequest )
{ {
return IsRefreshingDelegatePointer( Self, hRequest ); return _IsRefreshing( Self, hRequest );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate int GetServerCountDelegate( IntPtr self, HServerListRequest hRequest ); private delegate int FGetServerCount( IntPtr self, HServerListRequest hRequest );
private GetServerCountDelegate GetServerCountDelegatePointer; private FGetServerCount _GetServerCount;
#endregion #endregion
internal int GetServerCount( HServerListRequest hRequest ) internal int GetServerCount( HServerListRequest hRequest )
{ {
return GetServerCountDelegatePointer( Self, hRequest ); return _GetServerCount( Self, hRequest );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void RefreshServerDelegate( IntPtr self, HServerListRequest hRequest, int iServer ); private delegate void FRefreshServer( IntPtr self, HServerListRequest hRequest, int iServer );
private RefreshServerDelegate RefreshServerDelegatePointer; private FRefreshServer _RefreshServer;
#endregion #endregion
internal void RefreshServer( HServerListRequest hRequest, int iServer ) internal void RefreshServer( HServerListRequest hRequest, int iServer )
{ {
RefreshServerDelegatePointer( Self, hRequest, iServer ); _RefreshServer( Self, hRequest, iServer );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate HServerQuery PingServerDelegate( IntPtr self, uint unIP, ushort usPort, IntPtr pRequestServersResponse ); private delegate HServerQuery FPingServer( IntPtr self, uint unIP, ushort usPort, IntPtr pRequestServersResponse );
private PingServerDelegate PingServerDelegatePointer; private FPingServer _PingServer;
#endregion #endregion
internal HServerQuery PingServer( uint unIP, ushort usPort, IntPtr pRequestServersResponse ) internal HServerQuery PingServer( uint unIP, ushort usPort, IntPtr pRequestServersResponse )
{ {
return PingServerDelegatePointer( Self, unIP, usPort, pRequestServersResponse ); return _PingServer( Self, unIP, usPort, pRequestServersResponse );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate HServerQuery PlayerDetailsDelegate( IntPtr self, uint unIP, ushort usPort, IntPtr pRequestServersResponse ); private delegate HServerQuery FPlayerDetails( IntPtr self, uint unIP, ushort usPort, IntPtr pRequestServersResponse );
private PlayerDetailsDelegate PlayerDetailsDelegatePointer; private FPlayerDetails _PlayerDetails;
#endregion #endregion
internal HServerQuery PlayerDetails( uint unIP, ushort usPort, IntPtr pRequestServersResponse ) internal HServerQuery PlayerDetails( uint unIP, ushort usPort, IntPtr pRequestServersResponse )
{ {
return PlayerDetailsDelegatePointer( Self, unIP, usPort, pRequestServersResponse ); return _PlayerDetails( Self, unIP, usPort, pRequestServersResponse );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate HServerQuery ServerRulesDelegate( IntPtr self, uint unIP, ushort usPort, IntPtr pRequestServersResponse ); private delegate HServerQuery FServerRules( IntPtr self, uint unIP, ushort usPort, IntPtr pRequestServersResponse );
private ServerRulesDelegate ServerRulesDelegatePointer; private FServerRules _ServerRules;
#endregion #endregion
internal HServerQuery ServerRules( uint unIP, ushort usPort, IntPtr pRequestServersResponse ) internal HServerQuery ServerRules( uint unIP, ushort usPort, IntPtr pRequestServersResponse )
{ {
return ServerRulesDelegatePointer( Self, unIP, usPort, pRequestServersResponse ); return _ServerRules( Self, unIP, usPort, pRequestServersResponse );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void CancelServerQueryDelegate( IntPtr self, HServerQuery hServerQuery ); private delegate void FCancelServerQuery( IntPtr self, HServerQuery hServerQuery );
private CancelServerQueryDelegate CancelServerQueryDelegatePointer; private FCancelServerQuery _CancelServerQuery;
#endregion #endregion
internal void CancelServerQuery( HServerQuery hServerQuery ) internal void CancelServerQuery( HServerQuery hServerQuery )
{ {
CancelServerQueryDelegatePointer( Self, hServerQuery ); _CancelServerQuery( Self, hServerQuery );
} }
} }

72
Facepunch.Steamworks/Generated/Interfaces/ISteamMusic.cs
View File

@ -17,116 +17,116 @@ namespace Steamworks
public override void InitInternals() public override void InitInternals()
{ {
BIsEnabledDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsEnabledDelegate>( Marshal.ReadIntPtr( VTable, 0) ); _BIsEnabled = Marshal.GetDelegateForFunctionPointer<FBIsEnabled>( Marshal.ReadIntPtr( VTable, 0) );
BIsPlayingDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsPlayingDelegate>( Marshal.ReadIntPtr( VTable, 8) ); _BIsPlaying = Marshal.GetDelegateForFunctionPointer<FBIsPlaying>( Marshal.ReadIntPtr( VTable, 8) );
GetPlaybackStatusDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetPlaybackStatusDelegate>( Marshal.ReadIntPtr( VTable, 16) ); _GetPlaybackStatus = Marshal.GetDelegateForFunctionPointer<FGetPlaybackStatus>( Marshal.ReadIntPtr( VTable, 16) );
PlayDelegatePointer = Marshal.GetDelegateForFunctionPointer<PlayDelegate>( Marshal.ReadIntPtr( VTable, 24) ); _Play = Marshal.GetDelegateForFunctionPointer<FPlay>( Marshal.ReadIntPtr( VTable, 24) );
PauseDelegatePointer = Marshal.GetDelegateForFunctionPointer<PauseDelegate>( Marshal.ReadIntPtr( VTable, 32) ); _Pause = Marshal.GetDelegateForFunctionPointer<FPause>( Marshal.ReadIntPtr( VTable, 32) );
PlayPreviousDelegatePointer = Marshal.GetDelegateForFunctionPointer<PlayPreviousDelegate>( Marshal.ReadIntPtr( VTable, 40) ); _PlayPrevious = Marshal.GetDelegateForFunctionPointer<FPlayPrevious>( Marshal.ReadIntPtr( VTable, 40) );
PlayNextDelegatePointer = Marshal.GetDelegateForFunctionPointer<PlayNextDelegate>( Marshal.ReadIntPtr( VTable, 48) ); _PlayNext = Marshal.GetDelegateForFunctionPointer<FPlayNext>( Marshal.ReadIntPtr( VTable, 48) );
SetVolumeDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetVolumeDelegate>( Marshal.ReadIntPtr( VTable, 56) ); _SetVolume = Marshal.GetDelegateForFunctionPointer<FSetVolume>( Marshal.ReadIntPtr( VTable, 56) );
GetVolumeDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetVolumeDelegate>( Marshal.ReadIntPtr( VTable, 64) ); _GetVolume = Marshal.GetDelegateForFunctionPointer<FGetVolume>( Marshal.ReadIntPtr( VTable, 64) );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool BIsEnabledDelegate( IntPtr self ); private delegate bool FBIsEnabled( IntPtr self );
private BIsEnabledDelegate BIsEnabledDelegatePointer; private FBIsEnabled _BIsEnabled;
#endregion #endregion
internal bool BIsEnabled() internal bool BIsEnabled()
{ {
return BIsEnabledDelegatePointer( Self ); return _BIsEnabled( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool BIsPlayingDelegate( IntPtr self ); private delegate bool FBIsPlaying( IntPtr self );
private BIsPlayingDelegate BIsPlayingDelegatePointer; private FBIsPlaying _BIsPlaying;
#endregion #endregion
internal bool BIsPlaying() internal bool BIsPlaying()
{ {
return BIsPlayingDelegatePointer( Self ); return _BIsPlaying( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate MusicStatus GetPlaybackStatusDelegate( IntPtr self ); private delegate MusicStatus FGetPlaybackStatus( IntPtr self );
private GetPlaybackStatusDelegate GetPlaybackStatusDelegatePointer; private FGetPlaybackStatus _GetPlaybackStatus;
#endregion #endregion
internal MusicStatus GetPlaybackStatus() internal MusicStatus GetPlaybackStatus()
{ {
return GetPlaybackStatusDelegatePointer( Self ); return _GetPlaybackStatus( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void PlayDelegate( IntPtr self ); private delegate void FPlay( IntPtr self );
private PlayDelegate PlayDelegatePointer; private FPlay _Play;
#endregion #endregion
internal void Play() internal void Play()
{ {
PlayDelegatePointer( Self ); _Play( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void PauseDelegate( IntPtr self ); private delegate void FPause( IntPtr self );
private PauseDelegate PauseDelegatePointer; private FPause _Pause;
#endregion #endregion
internal void Pause() internal void Pause()
{ {
PauseDelegatePointer( Self ); _Pause( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void PlayPreviousDelegate( IntPtr self ); private delegate void FPlayPrevious( IntPtr self );
private PlayPreviousDelegate PlayPreviousDelegatePointer; private FPlayPrevious _PlayPrevious;
#endregion #endregion
internal void PlayPrevious() internal void PlayPrevious()
{ {
PlayPreviousDelegatePointer( Self ); _PlayPrevious( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void PlayNextDelegate( IntPtr self ); private delegate void FPlayNext( IntPtr self );
private PlayNextDelegate PlayNextDelegatePointer; private FPlayNext _PlayNext;
#endregion #endregion
internal void PlayNext() internal void PlayNext()
{ {
PlayNextDelegatePointer( Self ); _PlayNext( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void SetVolumeDelegate( IntPtr self, float flVolume ); private delegate void FSetVolume( IntPtr self, float flVolume );
private SetVolumeDelegate SetVolumeDelegatePointer; private FSetVolume _SetVolume;
#endregion #endregion
internal void SetVolume( float flVolume ) internal void SetVolume( float flVolume )
{ {
SetVolumeDelegatePointer( Self, flVolume ); _SetVolume( Self, flVolume );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate float GetVolumeDelegate( IntPtr self ); private delegate float FGetVolume( IntPtr self );
private GetVolumeDelegate GetVolumeDelegatePointer; private FGetVolume _GetVolume;
#endregion #endregion
internal float GetVolume() internal float GetVolume()
{ {
return GetVolumeDelegatePointer( Self ); return _GetVolume( Self );
} }
} }

48
Facepunch.Steamworks/Generated/Interfaces/ISteamParentalSettings.cs
View File

@ -17,84 +17,84 @@ namespace Steamworks
public override void InitInternals() public override void InitInternals()
{ {
BIsParentalLockEnabledDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsParentalLockEnabledDelegate>( Marshal.ReadIntPtr( VTable, 0) ); _BIsParentalLockEnabled = Marshal.GetDelegateForFunctionPointer<FBIsParentalLockEnabled>( Marshal.ReadIntPtr( VTable, 0) );
BIsParentalLockLockedDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsParentalLockLockedDelegate>( Marshal.ReadIntPtr( VTable, 8) ); _BIsParentalLockLocked = Marshal.GetDelegateForFunctionPointer<FBIsParentalLockLocked>( Marshal.ReadIntPtr( VTable, 8) );
BIsAppBlockedDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsAppBlockedDelegate>( Marshal.ReadIntPtr( VTable, 16) ); _BIsAppBlocked = Marshal.GetDelegateForFunctionPointer<FBIsAppBlocked>( Marshal.ReadIntPtr( VTable, 16) );
BIsAppInBlockListDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsAppInBlockListDelegate>( Marshal.ReadIntPtr( VTable, 24) ); _BIsAppInBlockList = Marshal.GetDelegateForFunctionPointer<FBIsAppInBlockList>( Marshal.ReadIntPtr( VTable, 24) );
BIsFeatureBlockedDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsFeatureBlockedDelegate>( Marshal.ReadIntPtr( VTable, 32) ); _BIsFeatureBlocked = Marshal.GetDelegateForFunctionPointer<FBIsFeatureBlocked>( Marshal.ReadIntPtr( VTable, 32) );
BIsFeatureInBlockListDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsFeatureInBlockListDelegate>( Marshal.ReadIntPtr( VTable, 40) ); _BIsFeatureInBlockList = Marshal.GetDelegateForFunctionPointer<FBIsFeatureInBlockList>( Marshal.ReadIntPtr( VTable, 40) );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool BIsParentalLockEnabledDelegate( IntPtr self ); private delegate bool FBIsParentalLockEnabled( IntPtr self );
private BIsParentalLockEnabledDelegate BIsParentalLockEnabledDelegatePointer; private FBIsParentalLockEnabled _BIsParentalLockEnabled;
#endregion #endregion
internal bool BIsParentalLockEnabled() internal bool BIsParentalLockEnabled()
{ {
return BIsParentalLockEnabledDelegatePointer( Self ); return _BIsParentalLockEnabled( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool BIsParentalLockLockedDelegate( IntPtr self ); private delegate bool FBIsParentalLockLocked( IntPtr self );
private BIsParentalLockLockedDelegate BIsParentalLockLockedDelegatePointer; private FBIsParentalLockLocked _BIsParentalLockLocked;
#endregion #endregion
internal bool BIsParentalLockLocked() internal bool BIsParentalLockLocked()
{ {
return BIsParentalLockLockedDelegatePointer( Self ); return _BIsParentalLockLocked( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool BIsAppBlockedDelegate( IntPtr self, AppId_t nAppID ); private delegate bool FBIsAppBlocked( IntPtr self, AppId_t nAppID );
private BIsAppBlockedDelegate BIsAppBlockedDelegatePointer; private FBIsAppBlocked _BIsAppBlocked;
#endregion #endregion
internal bool BIsAppBlocked( AppId_t nAppID ) internal bool BIsAppBlocked( AppId_t nAppID )
{ {
return BIsAppBlockedDelegatePointer( Self, nAppID ); return _BIsAppBlocked( Self, nAppID );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool BIsAppInBlockListDelegate( IntPtr self, AppId_t nAppID ); private delegate bool FBIsAppInBlockList( IntPtr self, AppId_t nAppID );
private BIsAppInBlockListDelegate BIsAppInBlockListDelegatePointer; private FBIsAppInBlockList _BIsAppInBlockList;
#endregion #endregion
internal bool BIsAppInBlockList( AppId_t nAppID ) internal bool BIsAppInBlockList( AppId_t nAppID )
{ {
return BIsAppInBlockListDelegatePointer( Self, nAppID ); return _BIsAppInBlockList( Self, nAppID );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool BIsFeatureBlockedDelegate( IntPtr self, ParentalFeature eFeature ); private delegate bool FBIsFeatureBlocked( IntPtr self, ParentalFeature eFeature );
private BIsFeatureBlockedDelegate BIsFeatureBlockedDelegatePointer; private FBIsFeatureBlocked _BIsFeatureBlocked;
#endregion #endregion
internal bool BIsFeatureBlocked( ParentalFeature eFeature ) internal bool BIsFeatureBlocked( ParentalFeature eFeature )
{ {
return BIsFeatureBlockedDelegatePointer( Self, eFeature ); return _BIsFeatureBlocked( Self, eFeature );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool BIsFeatureInBlockListDelegate( IntPtr self, ParentalFeature eFeature ); private delegate bool FBIsFeatureInBlockList( IntPtr self, ParentalFeature eFeature );
private BIsFeatureInBlockListDelegate BIsFeatureInBlockListDelegatePointer; private FBIsFeatureInBlockList _BIsFeatureInBlockList;
#endregion #endregion
internal bool BIsFeatureInBlockList( ParentalFeature eFeature ) internal bool BIsFeatureInBlockList( ParentalFeature eFeature )
{ {
return BIsFeatureInBlockListDelegatePointer( Self, eFeature ); return _BIsFeatureInBlockList( Self, eFeature );
} }
} }

72
Facepunch.Steamworks/Generated/Interfaces/ISteamScreenshots.cs
View File

@ -17,118 +17,118 @@ namespace Steamworks
public override void InitInternals() public override void InitInternals()
{ {
WriteScreenshotDelegatePointer = Marshal.GetDelegateForFunctionPointer<WriteScreenshotDelegate>( Marshal.ReadIntPtr( VTable, 0) ); _WriteScreenshot = Marshal.GetDelegateForFunctionPointer<FWriteScreenshot>( Marshal.ReadIntPtr( VTable, 0) );
AddScreenshotToLibraryDelegatePointer = Marshal.GetDelegateForFunctionPointer<AddScreenshotToLibraryDelegate>( Marshal.ReadIntPtr( VTable, 8) ); _AddScreenshotToLibrary = Marshal.GetDelegateForFunctionPointer<FAddScreenshotToLibrary>( Marshal.ReadIntPtr( VTable, 8) );
TriggerScreenshotDelegatePointer = Marshal.GetDelegateForFunctionPointer<TriggerScreenshotDelegate>( Marshal.ReadIntPtr( VTable, 16) ); _TriggerScreenshot = Marshal.GetDelegateForFunctionPointer<FTriggerScreenshot>( Marshal.ReadIntPtr( VTable, 16) );
HookScreenshotsDelegatePointer = Marshal.GetDelegateForFunctionPointer<HookScreenshotsDelegate>( Marshal.ReadIntPtr( VTable, 24) ); _HookScreenshots = Marshal.GetDelegateForFunctionPointer<FHookScreenshots>( Marshal.ReadIntPtr( VTable, 24) );
SetLocationDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetLocationDelegate>( Marshal.ReadIntPtr( VTable, 32) ); _SetLocation = Marshal.GetDelegateForFunctionPointer<FSetLocation>( Marshal.ReadIntPtr( VTable, 32) );
TagUserDelegatePointer = Marshal.GetDelegateForFunctionPointer<TagUserDelegate>( Marshal.ReadIntPtr( VTable, 40) ); _TagUser = Marshal.GetDelegateForFunctionPointer<FTagUser>( Marshal.ReadIntPtr( VTable, 40) );
TagPublishedFileDelegatePointer = Marshal.GetDelegateForFunctionPointer<TagPublishedFileDelegate>( Marshal.ReadIntPtr( VTable, 48) ); _TagPublishedFile = Marshal.GetDelegateForFunctionPointer<FTagPublishedFile>( Marshal.ReadIntPtr( VTable, 48) );
IsScreenshotsHookedDelegatePointer = Marshal.GetDelegateForFunctionPointer<IsScreenshotsHookedDelegate>( Marshal.ReadIntPtr( VTable, 56) ); _IsScreenshotsHooked = Marshal.GetDelegateForFunctionPointer<FIsScreenshotsHooked>( Marshal.ReadIntPtr( VTable, 56) );
AddVRScreenshotToLibraryDelegatePointer = Marshal.GetDelegateForFunctionPointer<AddVRScreenshotToLibraryDelegate>( Marshal.ReadIntPtr( VTable, 64) ); _AddVRScreenshotToLibrary = Marshal.GetDelegateForFunctionPointer<FAddVRScreenshotToLibrary>( Marshal.ReadIntPtr( VTable, 64) );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate ScreenshotHandle WriteScreenshotDelegate( IntPtr self, IntPtr pubRGB, uint cubRGB, int nWidth, int nHeight ); private delegate ScreenshotHandle FWriteScreenshot( IntPtr self, IntPtr pubRGB, uint cubRGB, int nWidth, int nHeight );
private WriteScreenshotDelegate WriteScreenshotDelegatePointer; private FWriteScreenshot _WriteScreenshot;
#endregion #endregion
internal ScreenshotHandle WriteScreenshot( IntPtr pubRGB, uint cubRGB, int nWidth, int nHeight ) internal ScreenshotHandle WriteScreenshot( IntPtr pubRGB, uint cubRGB, int nWidth, int nHeight )
{ {
return WriteScreenshotDelegatePointer( Self, pubRGB, cubRGB, nWidth, nHeight ); return _WriteScreenshot( Self, pubRGB, cubRGB, nWidth, nHeight );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate ScreenshotHandle AddScreenshotToLibraryDelegate( IntPtr self, string pchFilename, string pchThumbnailFilename, int nWidth, int nHeight ); private delegate ScreenshotHandle FAddScreenshotToLibrary( IntPtr self, string pchFilename, string pchThumbnailFilename, int nWidth, int nHeight );
private AddScreenshotToLibraryDelegate AddScreenshotToLibraryDelegatePointer; private FAddScreenshotToLibrary _AddScreenshotToLibrary;
#endregion #endregion
internal ScreenshotHandle AddScreenshotToLibrary( string pchFilename, string pchThumbnailFilename, int nWidth, int nHeight ) internal ScreenshotHandle AddScreenshotToLibrary( string pchFilename, string pchThumbnailFilename, int nWidth, int nHeight )
{ {
return AddScreenshotToLibraryDelegatePointer( Self, pchFilename, pchThumbnailFilename, nWidth, nHeight ); return _AddScreenshotToLibrary( Self, pchFilename, pchThumbnailFilename, nWidth, nHeight );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void TriggerScreenshotDelegate( IntPtr self ); private delegate void FTriggerScreenshot( IntPtr self );
private TriggerScreenshotDelegate TriggerScreenshotDelegatePointer; private FTriggerScreenshot _TriggerScreenshot;
#endregion #endregion
internal void TriggerScreenshot() internal void TriggerScreenshot()
{ {
TriggerScreenshotDelegatePointer( Self ); _TriggerScreenshot( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void HookScreenshotsDelegate( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bHook ); private delegate void FHookScreenshots( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bHook );
private HookScreenshotsDelegate HookScreenshotsDelegatePointer; private FHookScreenshots _HookScreenshots;
#endregion #endregion
internal void HookScreenshots( [MarshalAs( UnmanagedType.U1 )] bool bHook ) internal void HookScreenshots( [MarshalAs( UnmanagedType.U1 )] bool bHook )
{ {
HookScreenshotsDelegatePointer( Self, bHook ); _HookScreenshots( Self, bHook );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool SetLocationDelegate( IntPtr self, ScreenshotHandle hScreenshot, string pchLocation ); private delegate bool FSetLocation( IntPtr self, ScreenshotHandle hScreenshot, string pchLocation );
private SetLocationDelegate SetLocationDelegatePointer; private FSetLocation _SetLocation;
#endregion #endregion
internal bool SetLocation( ScreenshotHandle hScreenshot, string pchLocation ) internal bool SetLocation( ScreenshotHandle hScreenshot, string pchLocation )
{ {
return SetLocationDelegatePointer( Self, hScreenshot, pchLocation ); return _SetLocation( Self, hScreenshot, pchLocation );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool TagUserDelegate( IntPtr self, ScreenshotHandle hScreenshot, SteamId steamID ); private delegate bool FTagUser( IntPtr self, ScreenshotHandle hScreenshot, SteamId steamID );
private TagUserDelegate TagUserDelegatePointer; private FTagUser _TagUser;
#endregion #endregion
internal bool TagUser( ScreenshotHandle hScreenshot, SteamId steamID ) internal bool TagUser( ScreenshotHandle hScreenshot, SteamId steamID )
{ {
return TagUserDelegatePointer( Self, hScreenshot, steamID ); return _TagUser( Self, hScreenshot, steamID );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool TagPublishedFileDelegate( IntPtr self, ScreenshotHandle hScreenshot, PublishedFileId unPublishedFileID ); private delegate bool FTagPublishedFile( IntPtr self, ScreenshotHandle hScreenshot, PublishedFileId unPublishedFileID );
private TagPublishedFileDelegate TagPublishedFileDelegatePointer; private FTagPublishedFile _TagPublishedFile;
#endregion #endregion
internal bool TagPublishedFile( ScreenshotHandle hScreenshot, PublishedFileId unPublishedFileID ) internal bool TagPublishedFile( ScreenshotHandle hScreenshot, PublishedFileId unPublishedFileID )
{ {
return TagPublishedFileDelegatePointer( Self, hScreenshot, unPublishedFileID ); return _TagPublishedFile( Self, hScreenshot, unPublishedFileID );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool IsScreenshotsHookedDelegate( IntPtr self ); private delegate bool FIsScreenshotsHooked( IntPtr self );
private IsScreenshotsHookedDelegate IsScreenshotsHookedDelegatePointer; private FIsScreenshotsHooked _IsScreenshotsHooked;
#endregion #endregion
internal bool IsScreenshotsHooked() internal bool IsScreenshotsHooked()
{ {
return IsScreenshotsHookedDelegatePointer( Self ); return _IsScreenshotsHooked( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate ScreenshotHandle AddVRScreenshotToLibraryDelegate( IntPtr self, VRScreenshotType eType, string pchFilename, string pchVRFilename ); private delegate ScreenshotHandle FAddVRScreenshotToLibrary( IntPtr self, VRScreenshotType eType, string pchFilename, string pchVRFilename );
private AddVRScreenshotToLibraryDelegate AddVRScreenshotToLibraryDelegatePointer; private FAddVRScreenshotToLibrary _AddVRScreenshotToLibrary;
#endregion #endregion
internal ScreenshotHandle AddVRScreenshotToLibrary( VRScreenshotType eType, string pchFilename, string pchVRFilename ) internal ScreenshotHandle AddVRScreenshotToLibrary( VRScreenshotType eType, string pchFilename, string pchVRFilename )
{ {
return AddVRScreenshotToLibraryDelegatePointer( Self, eType, pchFilename, pchVRFilename ); return _AddVRScreenshotToLibrary( Self, eType, pchFilename, pchVRFilename );
} }
} }

240
Facepunch.Steamworks/Generated/Interfaces/ISteamUser.cs
View File

@ -17,376 +17,376 @@ namespace Steamworks
public override void InitInternals() public override void InitInternals()
{ {
GetHSteamUserDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetHSteamUserDelegate>( Marshal.ReadIntPtr( VTable, 0) ); _GetHSteamUser = Marshal.GetDelegateForFunctionPointer<FGetHSteamUser>( Marshal.ReadIntPtr( VTable, 0) );
BLoggedOnDelegatePointer = Marshal.GetDelegateForFunctionPointer<BLoggedOnDelegate>( Marshal.ReadIntPtr( VTable, 8) ); _BLoggedOn = Marshal.GetDelegateForFunctionPointer<FBLoggedOn>( Marshal.ReadIntPtr( VTable, 8) );
GetSteamIDDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetSteamIDDelegate>( Marshal.ReadIntPtr( VTable, 16) ); _GetSteamID = Marshal.GetDelegateForFunctionPointer<FGetSteamID>( Marshal.ReadIntPtr( VTable, 16) );
InitiateGameConnectionDelegatePointer = Marshal.GetDelegateForFunctionPointer<InitiateGameConnectionDelegate>( Marshal.ReadIntPtr( VTable, 24) ); _InitiateGameConnection = Marshal.GetDelegateForFunctionPointer<FInitiateGameConnection>( Marshal.ReadIntPtr( VTable, 24) );
TerminateGameConnectionDelegatePointer = Marshal.GetDelegateForFunctionPointer<TerminateGameConnectionDelegate>( Marshal.ReadIntPtr( VTable, 32) ); _TerminateGameConnection = Marshal.GetDelegateForFunctionPointer<FTerminateGameConnection>( Marshal.ReadIntPtr( VTable, 32) );
TrackAppUsageEventDelegatePointer = Marshal.GetDelegateForFunctionPointer<TrackAppUsageEventDelegate>( Marshal.ReadIntPtr( VTable, 40) ); _TrackAppUsageEvent = Marshal.GetDelegateForFunctionPointer<FTrackAppUsageEvent>( Marshal.ReadIntPtr( VTable, 40) );
GetUserDataFolderDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetUserDataFolderDelegate>( Marshal.ReadIntPtr( VTable, 48) ); _GetUserDataFolder = Marshal.GetDelegateForFunctionPointer<FGetUserDataFolder>( Marshal.ReadIntPtr( VTable, 48) );
StartVoiceRecordingDelegatePointer = Marshal.GetDelegateForFunctionPointer<StartVoiceRecordingDelegate>( Marshal.ReadIntPtr( VTable, 56) ); _StartVoiceRecording = Marshal.GetDelegateForFunctionPointer<FStartVoiceRecording>( Marshal.ReadIntPtr( VTable, 56) );
StopVoiceRecordingDelegatePointer = Marshal.GetDelegateForFunctionPointer<StopVoiceRecordingDelegate>( Marshal.ReadIntPtr( VTable, 64) ); _StopVoiceRecording = Marshal.GetDelegateForFunctionPointer<FStopVoiceRecording>( Marshal.ReadIntPtr( VTable, 64) );
GetAvailableVoiceDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAvailableVoiceDelegate>( Marshal.ReadIntPtr( VTable, 72) ); _GetAvailableVoice = Marshal.GetDelegateForFunctionPointer<FGetAvailableVoice>( Marshal.ReadIntPtr( VTable, 72) );
GetVoiceDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetVoiceDelegate>( Marshal.ReadIntPtr( VTable, 80) ); _GetVoice = Marshal.GetDelegateForFunctionPointer<FGetVoice>( Marshal.ReadIntPtr( VTable, 80) );
DecompressVoiceDelegatePointer = Marshal.GetDelegateForFunctionPointer<DecompressVoiceDelegate>( Marshal.ReadIntPtr( VTable, 88) ); _DecompressVoice = Marshal.GetDelegateForFunctionPointer<FDecompressVoice>( Marshal.ReadIntPtr( VTable, 88) );
GetVoiceOptimalSampleRateDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetVoiceOptimalSampleRateDelegate>( Marshal.ReadIntPtr( VTable, 96) ); _GetVoiceOptimalSampleRate = Marshal.GetDelegateForFunctionPointer<FGetVoiceOptimalSampleRate>( Marshal.ReadIntPtr( VTable, 96) );
GetAuthSessionTicketDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAuthSessionTicketDelegate>( Marshal.ReadIntPtr( VTable, 104) ); _GetAuthSessionTicket = Marshal.GetDelegateForFunctionPointer<FGetAuthSessionTicket>( Marshal.ReadIntPtr( VTable, 104) );
BeginAuthSessionDelegatePointer = Marshal.GetDelegateForFunctionPointer<BeginAuthSessionDelegate>( Marshal.ReadIntPtr( VTable, 112) ); _BeginAuthSession = Marshal.GetDelegateForFunctionPointer<FBeginAuthSession>( Marshal.ReadIntPtr( VTable, 112) );
EndAuthSessionDelegatePointer = Marshal.GetDelegateForFunctionPointer<EndAuthSessionDelegate>( Marshal.ReadIntPtr( VTable, 120) ); _EndAuthSession = Marshal.GetDelegateForFunctionPointer<FEndAuthSession>( Marshal.ReadIntPtr( VTable, 120) );
CancelAuthTicketDelegatePointer = Marshal.GetDelegateForFunctionPointer<CancelAuthTicketDelegate>( Marshal.ReadIntPtr( VTable, 128) ); _CancelAuthTicket = Marshal.GetDelegateForFunctionPointer<FCancelAuthTicket>( Marshal.ReadIntPtr( VTable, 128) );
UserHasLicenseForAppDelegatePointer = Marshal.GetDelegateForFunctionPointer<UserHasLicenseForAppDelegate>( Marshal.ReadIntPtr( VTable, 136) ); _UserHasLicenseForApp = Marshal.GetDelegateForFunctionPointer<FUserHasLicenseForApp>( Marshal.ReadIntPtr( VTable, 136) );
BIsBehindNATDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsBehindNATDelegate>( Marshal.ReadIntPtr( VTable, 144) ); _BIsBehindNAT = Marshal.GetDelegateForFunctionPointer<FBIsBehindNAT>( Marshal.ReadIntPtr( VTable, 144) );
AdvertiseGameDelegatePointer = Marshal.GetDelegateForFunctionPointer<AdvertiseGameDelegate>( Marshal.ReadIntPtr( VTable, 152) ); _AdvertiseGame = Marshal.GetDelegateForFunctionPointer<FAdvertiseGame>( Marshal.ReadIntPtr( VTable, 152) );
RequestEncryptedAppTicketDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestEncryptedAppTicketDelegate>( Marshal.ReadIntPtr( VTable, 160) ); _RequestEncryptedAppTicket = Marshal.GetDelegateForFunctionPointer<FRequestEncryptedAppTicket>( Marshal.ReadIntPtr( VTable, 160) );
GetEncryptedAppTicketDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetEncryptedAppTicketDelegate>( Marshal.ReadIntPtr( VTable, 168) ); _GetEncryptedAppTicket = Marshal.GetDelegateForFunctionPointer<FGetEncryptedAppTicket>( Marshal.ReadIntPtr( VTable, 168) );
GetGameBadgeLevelDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetGameBadgeLevelDelegate>( Marshal.ReadIntPtr( VTable, 176) ); _GetGameBadgeLevel = Marshal.GetDelegateForFunctionPointer<FGetGameBadgeLevel>( Marshal.ReadIntPtr( VTable, 176) );
GetPlayerSteamLevelDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetPlayerSteamLevelDelegate>( Marshal.ReadIntPtr( VTable, 184) ); _GetPlayerSteamLevel = Marshal.GetDelegateForFunctionPointer<FGetPlayerSteamLevel>( Marshal.ReadIntPtr( VTable, 184) );
RequestStoreAuthURLDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestStoreAuthURLDelegate>( Marshal.ReadIntPtr( VTable, 192) ); _RequestStoreAuthURL = Marshal.GetDelegateForFunctionPointer<FRequestStoreAuthURL>( Marshal.ReadIntPtr( VTable, 192) );
BIsPhoneVerifiedDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsPhoneVerifiedDelegate>( Marshal.ReadIntPtr( VTable, 200) ); _BIsPhoneVerified = Marshal.GetDelegateForFunctionPointer<FBIsPhoneVerified>( Marshal.ReadIntPtr( VTable, 200) );
BIsTwoFactorEnabledDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsTwoFactorEnabledDelegate>( Marshal.ReadIntPtr( VTable, 208) ); _BIsTwoFactorEnabled = Marshal.GetDelegateForFunctionPointer<FBIsTwoFactorEnabled>( Marshal.ReadIntPtr( VTable, 208) );
BIsPhoneIdentifyingDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsPhoneIdentifyingDelegate>( Marshal.ReadIntPtr( VTable, 216) ); _BIsPhoneIdentifying = Marshal.GetDelegateForFunctionPointer<FBIsPhoneIdentifying>( Marshal.ReadIntPtr( VTable, 216) );
BIsPhoneRequiringVerificationDelegatePointer = Marshal.GetDelegateForFunctionPointer<BIsPhoneRequiringVerificationDelegate>( Marshal.ReadIntPtr( VTable, 224) ); _BIsPhoneRequiringVerification = Marshal.GetDelegateForFunctionPointer<FBIsPhoneRequiringVerification>( Marshal.ReadIntPtr( VTable, 224) );
GetMarketEligibilityDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetMarketEligibilityDelegate>( Marshal.ReadIntPtr( VTable, 232) ); _GetMarketEligibility = Marshal.GetDelegateForFunctionPointer<FGetMarketEligibility>( Marshal.ReadIntPtr( VTable, 232) );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate HSteamUser GetHSteamUserDelegate( IntPtr self ); private delegate HSteamUser FGetHSteamUser( IntPtr self );
private GetHSteamUserDelegate GetHSteamUserDelegatePointer; private FGetHSteamUser _GetHSteamUser;
#endregion #endregion
internal HSteamUser GetHSteamUser() internal HSteamUser GetHSteamUser()
{ {
return GetHSteamUserDelegatePointer( Self ); return _GetHSteamUser( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool BLoggedOnDelegate( IntPtr self ); private delegate bool FBLoggedOn( IntPtr self );
private BLoggedOnDelegate BLoggedOnDelegatePointer; private FBLoggedOn _BLoggedOn;
#endregion #endregion
internal bool BLoggedOn() internal bool BLoggedOn()
{ {
return BLoggedOnDelegatePointer( Self ); return _BLoggedOn( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void GetSteamIDDelegate( IntPtr self, ref SteamId retVal ); private delegate void FGetSteamID( IntPtr self, ref SteamId retVal );
private GetSteamIDDelegate GetSteamIDDelegatePointer; private FGetSteamID _GetSteamID;
#endregion #endregion
internal SteamId GetSteamID() internal SteamId GetSteamID()
{ {
var retVal = default( SteamId ); var retVal = default( SteamId );
GetSteamIDDelegatePointer( Self, ref retVal ); _GetSteamID( Self, ref retVal );
return retVal; return retVal;
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate int InitiateGameConnectionDelegate( IntPtr self, IntPtr pAuthBlob, int cbMaxAuthBlob, SteamId steamIDGameServer, uint unIPServer, ushort usPortServer, [MarshalAs( UnmanagedType.U1 )] bool bSecure ); private delegate int FInitiateGameConnection( IntPtr self, IntPtr pAuthBlob, int cbMaxAuthBlob, SteamId steamIDGameServer, uint unIPServer, ushort usPortServer, [MarshalAs( UnmanagedType.U1 )] bool bSecure );
private InitiateGameConnectionDelegate InitiateGameConnectionDelegatePointer; private FInitiateGameConnection _InitiateGameConnection;
#endregion #endregion
internal int InitiateGameConnection( IntPtr pAuthBlob, int cbMaxAuthBlob, SteamId steamIDGameServer, uint unIPServer, ushort usPortServer, [MarshalAs( UnmanagedType.U1 )] bool bSecure ) internal int InitiateGameConnection( IntPtr pAuthBlob, int cbMaxAuthBlob, SteamId steamIDGameServer, uint unIPServer, ushort usPortServer, [MarshalAs( UnmanagedType.U1 )] bool bSecure )
{ {
return InitiateGameConnectionDelegatePointer( Self, pAuthBlob, cbMaxAuthBlob, steamIDGameServer, unIPServer, usPortServer, bSecure ); return _InitiateGameConnection( Self, pAuthBlob, cbMaxAuthBlob, steamIDGameServer, unIPServer, usPortServer, bSecure );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void TerminateGameConnectionDelegate( IntPtr self, uint unIPServer, ushort usPortServer ); private delegate void FTerminateGameConnection( IntPtr self, uint unIPServer, ushort usPortServer );
private TerminateGameConnectionDelegate TerminateGameConnectionDelegatePointer; private FTerminateGameConnection _TerminateGameConnection;
#endregion #endregion
internal void TerminateGameConnection( uint unIPServer, ushort usPortServer ) internal void TerminateGameConnection( uint unIPServer, ushort usPortServer )
{ {
TerminateGameConnectionDelegatePointer( Self, unIPServer, usPortServer ); _TerminateGameConnection( Self, unIPServer, usPortServer );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void TrackAppUsageEventDelegate( IntPtr self, GameId gameID, int eAppUsageEvent, string pchExtraInfo ); private delegate void FTrackAppUsageEvent( IntPtr self, GameId gameID, int eAppUsageEvent, string pchExtraInfo );
private TrackAppUsageEventDelegate TrackAppUsageEventDelegatePointer; private FTrackAppUsageEvent _TrackAppUsageEvent;
#endregion #endregion
internal void TrackAppUsageEvent( GameId gameID, int eAppUsageEvent, string pchExtraInfo ) internal void TrackAppUsageEvent( GameId gameID, int eAppUsageEvent, string pchExtraInfo )
{ {
TrackAppUsageEventDelegatePointer( Self, gameID, eAppUsageEvent, pchExtraInfo ); _TrackAppUsageEvent( Self, gameID, eAppUsageEvent, pchExtraInfo );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool GetUserDataFolderDelegate( IntPtr self, StringBuilder pchBuffer, int cubBuffer ); private delegate bool FGetUserDataFolder( IntPtr self, StringBuilder pchBuffer, int cubBuffer );
private GetUserDataFolderDelegate GetUserDataFolderDelegatePointer; private FGetUserDataFolder _GetUserDataFolder;
#endregion #endregion
internal bool GetUserDataFolder( StringBuilder pchBuffer, int cubBuffer ) internal bool GetUserDataFolder( StringBuilder pchBuffer, int cubBuffer )
{ {
return GetUserDataFolderDelegatePointer( Self, pchBuffer, cubBuffer ); return _GetUserDataFolder( Self, pchBuffer, cubBuffer );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void StartVoiceRecordingDelegate( IntPtr self ); private delegate void FStartVoiceRecording( IntPtr self );
private StartVoiceRecordingDelegate StartVoiceRecordingDelegatePointer; private FStartVoiceRecording _StartVoiceRecording;
#endregion #endregion
internal void StartVoiceRecording() internal void StartVoiceRecording()
{ {
StartVoiceRecordingDelegatePointer( Self ); _StartVoiceRecording( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void StopVoiceRecordingDelegate( IntPtr self ); private delegate void FStopVoiceRecording( IntPtr self );
private StopVoiceRecordingDelegate StopVoiceRecordingDelegatePointer; private FStopVoiceRecording _StopVoiceRecording;
#endregion #endregion
internal void StopVoiceRecording() internal void StopVoiceRecording()
{ {
StopVoiceRecordingDelegatePointer( Self ); _StopVoiceRecording( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate VoiceResult GetAvailableVoiceDelegate( IntPtr self, ref uint pcbCompressed, ref uint pcbUncompressed_Deprecated, uint nUncompressedVoiceDesiredSampleRate_Deprecated ); private delegate VoiceResult FGetAvailableVoice( IntPtr self, ref uint pcbCompressed, ref uint pcbUncompressed_Deprecated, uint nUncompressedVoiceDesiredSampleRate_Deprecated );
private GetAvailableVoiceDelegate GetAvailableVoiceDelegatePointer; private FGetAvailableVoice _GetAvailableVoice;
#endregion #endregion
internal VoiceResult GetAvailableVoice( ref uint pcbCompressed, ref uint pcbUncompressed_Deprecated, uint nUncompressedVoiceDesiredSampleRate_Deprecated ) internal VoiceResult GetAvailableVoice( ref uint pcbCompressed, ref uint pcbUncompressed_Deprecated, uint nUncompressedVoiceDesiredSampleRate_Deprecated )
{ {
return GetAvailableVoiceDelegatePointer( Self, ref pcbCompressed, ref pcbUncompressed_Deprecated, nUncompressedVoiceDesiredSampleRate_Deprecated ); return _GetAvailableVoice( Self, ref pcbCompressed, ref pcbUncompressed_Deprecated, nUncompressedVoiceDesiredSampleRate_Deprecated );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate VoiceResult GetVoiceDelegate( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bWantCompressed, IntPtr pDestBuffer, uint cbDestBufferSize, ref uint nBytesWritten, [MarshalAs( UnmanagedType.U1 )] bool bWantUncompressed_Deprecated, IntPtr pUncompressedDestBuffer_Deprecated, uint cbUncompressedDestBufferSize_Deprecated, ref uint nUncompressBytesWritten_Deprecated, uint nUncompressedVoiceDesiredSampleRate_Deprecated ); private delegate VoiceResult FGetVoice( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bWantCompressed, IntPtr pDestBuffer, uint cbDestBufferSize, ref uint nBytesWritten, [MarshalAs( UnmanagedType.U1 )] bool bWantUncompressed_Deprecated, IntPtr pUncompressedDestBuffer_Deprecated, uint cbUncompressedDestBufferSize_Deprecated, ref uint nUncompressBytesWritten_Deprecated, uint nUncompressedVoiceDesiredSampleRate_Deprecated );
private GetVoiceDelegate GetVoiceDelegatePointer; private FGetVoice _GetVoice;
#endregion #endregion
internal VoiceResult GetVoice( [MarshalAs( UnmanagedType.U1 )] bool bWantCompressed, IntPtr pDestBuffer, uint cbDestBufferSize, ref uint nBytesWritten, [MarshalAs( UnmanagedType.U1 )] bool bWantUncompressed_Deprecated, IntPtr pUncompressedDestBuffer_Deprecated, uint cbUncompressedDestBufferSize_Deprecated, ref uint nUncompressBytesWritten_Deprecated, uint nUncompressedVoiceDesiredSampleRate_Deprecated ) internal VoiceResult GetVoice( [MarshalAs( UnmanagedType.U1 )] bool bWantCompressed, IntPtr pDestBuffer, uint cbDestBufferSize, ref uint nBytesWritten, [MarshalAs( UnmanagedType.U1 )] bool bWantUncompressed_Deprecated, IntPtr pUncompressedDestBuffer_Deprecated, uint cbUncompressedDestBufferSize_Deprecated, ref uint nUncompressBytesWritten_Deprecated, uint nUncompressedVoiceDesiredSampleRate_Deprecated )
{ {
return GetVoiceDelegatePointer( Self, bWantCompressed, pDestBuffer, cbDestBufferSize, ref nBytesWritten, bWantUncompressed_Deprecated, pUncompressedDestBuffer_Deprecated, cbUncompressedDestBufferSize_Deprecated, ref nUncompressBytesWritten_Deprecated, nUncompressedVoiceDesiredSampleRate_Deprecated ); return _GetVoice( Self, bWantCompressed, pDestBuffer, cbDestBufferSize, ref nBytesWritten, bWantUncompressed_Deprecated, pUncompressedDestBuffer_Deprecated, cbUncompressedDestBufferSize_Deprecated, ref nUncompressBytesWritten_Deprecated, nUncompressedVoiceDesiredSampleRate_Deprecated );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate VoiceResult DecompressVoiceDelegate( IntPtr self, IntPtr pCompressed, uint cbCompressed, IntPtr pDestBuffer, uint cbDestBufferSize, ref uint nBytesWritten, uint nDesiredSampleRate ); private delegate VoiceResult FDecompressVoice( IntPtr self, IntPtr pCompressed, uint cbCompressed, IntPtr pDestBuffer, uint cbDestBufferSize, ref uint nBytesWritten, uint nDesiredSampleRate );
private DecompressVoiceDelegate DecompressVoiceDelegatePointer; private FDecompressVoice _DecompressVoice;
#endregion #endregion
internal VoiceResult DecompressVoice( IntPtr pCompressed, uint cbCompressed, IntPtr pDestBuffer, uint cbDestBufferSize, ref uint nBytesWritten, uint nDesiredSampleRate ) internal VoiceResult DecompressVoice( IntPtr pCompressed, uint cbCompressed, IntPtr pDestBuffer, uint cbDestBufferSize, ref uint nBytesWritten, uint nDesiredSampleRate )
{ {
return DecompressVoiceDelegatePointer( Self, pCompressed, cbCompressed, pDestBuffer, cbDestBufferSize, ref nBytesWritten, nDesiredSampleRate ); return _DecompressVoice( Self, pCompressed, cbCompressed, pDestBuffer, cbDestBufferSize, ref nBytesWritten, nDesiredSampleRate );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate uint GetVoiceOptimalSampleRateDelegate( IntPtr self ); private delegate uint FGetVoiceOptimalSampleRate( IntPtr self );
private GetVoiceOptimalSampleRateDelegate GetVoiceOptimalSampleRateDelegatePointer; private FGetVoiceOptimalSampleRate _GetVoiceOptimalSampleRate;
#endregion #endregion
internal uint GetVoiceOptimalSampleRate() internal uint GetVoiceOptimalSampleRate()
{ {
return GetVoiceOptimalSampleRateDelegatePointer( Self ); return _GetVoiceOptimalSampleRate( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate HAuthTicket GetAuthSessionTicketDelegate( IntPtr self, IntPtr pTicket, int cbMaxTicket, ref uint pcbTicket ); private delegate HAuthTicket FGetAuthSessionTicket( IntPtr self, IntPtr pTicket, int cbMaxTicket, ref uint pcbTicket );
private GetAuthSessionTicketDelegate GetAuthSessionTicketDelegatePointer; private FGetAuthSessionTicket _GetAuthSessionTicket;
#endregion #endregion
internal HAuthTicket GetAuthSessionTicket( IntPtr pTicket, int cbMaxTicket, ref uint pcbTicket ) internal HAuthTicket GetAuthSessionTicket( IntPtr pTicket, int cbMaxTicket, ref uint pcbTicket )
{ {
return GetAuthSessionTicketDelegatePointer( Self, pTicket, cbMaxTicket, ref pcbTicket ); return _GetAuthSessionTicket( Self, pTicket, cbMaxTicket, ref pcbTicket );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate BeginAuthResult BeginAuthSessionDelegate( IntPtr self, IntPtr pAuthTicket, int cbAuthTicket, SteamId steamID ); private delegate BeginAuthResult FBeginAuthSession( IntPtr self, IntPtr pAuthTicket, int cbAuthTicket, SteamId steamID );
private BeginAuthSessionDelegate BeginAuthSessionDelegatePointer; private FBeginAuthSession _BeginAuthSession;
#endregion #endregion
internal BeginAuthResult BeginAuthSession( IntPtr pAuthTicket, int cbAuthTicket, SteamId steamID ) internal BeginAuthResult BeginAuthSession( IntPtr pAuthTicket, int cbAuthTicket, SteamId steamID )
{ {
return BeginAuthSessionDelegatePointer( Self, pAuthTicket, cbAuthTicket, steamID ); return _BeginAuthSession( Self, pAuthTicket, cbAuthTicket, steamID );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void EndAuthSessionDelegate( IntPtr self, SteamId steamID ); private delegate void FEndAuthSession( IntPtr self, SteamId steamID );
private EndAuthSessionDelegate EndAuthSessionDelegatePointer; private FEndAuthSession _EndAuthSession;
#endregion #endregion
internal void EndAuthSession( SteamId steamID ) internal void EndAuthSession( SteamId steamID )
{ {
EndAuthSessionDelegatePointer( Self, steamID ); _EndAuthSession( Self, steamID );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void CancelAuthTicketDelegate( IntPtr self, HAuthTicket hAuthTicket ); private delegate void FCancelAuthTicket( IntPtr self, HAuthTicket hAuthTicket );
private CancelAuthTicketDelegate CancelAuthTicketDelegatePointer; private FCancelAuthTicket _CancelAuthTicket;
#endregion #endregion
internal void CancelAuthTicket( HAuthTicket hAuthTicket ) internal void CancelAuthTicket( HAuthTicket hAuthTicket )
{ {
CancelAuthTicketDelegatePointer( Self, hAuthTicket ); _CancelAuthTicket( Self, hAuthTicket );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate UserHasLicenseForAppResult UserHasLicenseForAppDelegate( IntPtr self, SteamId steamID, AppId_t appID ); private delegate UserHasLicenseForAppResult FUserHasLicenseForApp( IntPtr self, SteamId steamID, AppId_t appID );
private UserHasLicenseForAppDelegate UserHasLicenseForAppDelegatePointer; private FUserHasLicenseForApp _UserHasLicenseForApp;
#endregion #endregion
internal UserHasLicenseForAppResult UserHasLicenseForApp( SteamId steamID, AppId_t appID ) internal UserHasLicenseForAppResult UserHasLicenseForApp( SteamId steamID, AppId_t appID )
{ {
return UserHasLicenseForAppDelegatePointer( Self, steamID, appID ); return _UserHasLicenseForApp( Self, steamID, appID );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool BIsBehindNATDelegate( IntPtr self ); private delegate bool FBIsBehindNAT( IntPtr self );
private BIsBehindNATDelegate BIsBehindNATDelegatePointer; private FBIsBehindNAT _BIsBehindNAT;
#endregion #endregion
internal bool BIsBehindNAT() internal bool BIsBehindNAT()
{ {
return BIsBehindNATDelegatePointer( Self ); return _BIsBehindNAT( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void AdvertiseGameDelegate( IntPtr self, SteamId steamIDGameServer, uint unIPServer, ushort usPortServer ); private delegate void FAdvertiseGame( IntPtr self, SteamId steamIDGameServer, uint unIPServer, ushort usPortServer );
private AdvertiseGameDelegate AdvertiseGameDelegatePointer; private FAdvertiseGame _AdvertiseGame;
#endregion #endregion
internal void AdvertiseGame( SteamId steamIDGameServer, uint unIPServer, ushort usPortServer ) internal void AdvertiseGame( SteamId steamIDGameServer, uint unIPServer, ushort usPortServer )
{ {
AdvertiseGameDelegatePointer( Self, steamIDGameServer, unIPServer, usPortServer ); _AdvertiseGame( Self, steamIDGameServer, unIPServer, usPortServer );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate SteamAPICall_t RequestEncryptedAppTicketDelegate( IntPtr self, IntPtr pDataToInclude, int cbDataToInclude ); private delegate SteamAPICall_t FRequestEncryptedAppTicket( IntPtr self, IntPtr pDataToInclude, int cbDataToInclude );
private RequestEncryptedAppTicketDelegate RequestEncryptedAppTicketDelegatePointer; private FRequestEncryptedAppTicket _RequestEncryptedAppTicket;
#endregion #endregion
internal async Task<EncryptedAppTicketResponse_t?> RequestEncryptedAppTicket( IntPtr pDataToInclude, int cbDataToInclude ) internal async Task<EncryptedAppTicketResponse_t?> RequestEncryptedAppTicket( IntPtr pDataToInclude, int cbDataToInclude )
{ {
return await (new Result<EncryptedAppTicketResponse_t>( RequestEncryptedAppTicketDelegatePointer( Self, pDataToInclude, cbDataToInclude ) )).GetResult(); return await (new Result<EncryptedAppTicketResponse_t>( _RequestEncryptedAppTicket( Self, pDataToInclude, cbDataToInclude ) )).GetResult();
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool GetEncryptedAppTicketDelegate( IntPtr self, IntPtr pTicket, int cbMaxTicket, ref uint pcbTicket ); private delegate bool FGetEncryptedAppTicket( IntPtr self, IntPtr pTicket, int cbMaxTicket, ref uint pcbTicket );
private GetEncryptedAppTicketDelegate GetEncryptedAppTicketDelegatePointer; private FGetEncryptedAppTicket _GetEncryptedAppTicket;
#endregion #endregion
internal bool GetEncryptedAppTicket( IntPtr pTicket, int cbMaxTicket, ref uint pcbTicket ) internal bool GetEncryptedAppTicket( IntPtr pTicket, int cbMaxTicket, ref uint pcbTicket )
{ {
return GetEncryptedAppTicketDelegatePointer( Self, pTicket, cbMaxTicket, ref pcbTicket ); return _GetEncryptedAppTicket( Self, pTicket, cbMaxTicket, ref pcbTicket );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate int GetGameBadgeLevelDelegate( IntPtr self, int nSeries, [MarshalAs( UnmanagedType.U1 )] bool bFoil ); private delegate int FGetGameBadgeLevel( IntPtr self, int nSeries, [MarshalAs( UnmanagedType.U1 )] bool bFoil );
private GetGameBadgeLevelDelegate GetGameBadgeLevelDelegatePointer; private FGetGameBadgeLevel _GetGameBadgeLevel;
#endregion #endregion
internal int GetGameBadgeLevel( int nSeries, [MarshalAs( UnmanagedType.U1 )] bool bFoil ) internal int GetGameBadgeLevel( int nSeries, [MarshalAs( UnmanagedType.U1 )] bool bFoil )
{ {
return GetGameBadgeLevelDelegatePointer( Self, nSeries, bFoil ); return _GetGameBadgeLevel( Self, nSeries, bFoil );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate int GetPlayerSteamLevelDelegate( IntPtr self ); private delegate int FGetPlayerSteamLevel( IntPtr self );
private GetPlayerSteamLevelDelegate GetPlayerSteamLevelDelegatePointer; private FGetPlayerSteamLevel _GetPlayerSteamLevel;
#endregion #endregion
internal int GetPlayerSteamLevel() internal int GetPlayerSteamLevel()
{ {
return GetPlayerSteamLevelDelegatePointer( Self ); return _GetPlayerSteamLevel( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate SteamAPICall_t RequestStoreAuthURLDelegate( IntPtr self, string pchRedirectURL ); private delegate SteamAPICall_t FRequestStoreAuthURL( IntPtr self, string pchRedirectURL );
private RequestStoreAuthURLDelegate RequestStoreAuthURLDelegatePointer; private FRequestStoreAuthURL _RequestStoreAuthURL;
#endregion #endregion
internal async Task<StoreAuthURLResponse_t?> RequestStoreAuthURL( string pchRedirectURL ) internal async Task<StoreAuthURLResponse_t?> RequestStoreAuthURL( string pchRedirectURL )
{ {
return await (new Result<StoreAuthURLResponse_t>( RequestStoreAuthURLDelegatePointer( Self, pchRedirectURL ) )).GetResult(); return await (new Result<StoreAuthURLResponse_t>( _RequestStoreAuthURL( Self, pchRedirectURL ) )).GetResult();
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool BIsPhoneVerifiedDelegate( IntPtr self ); private delegate bool FBIsPhoneVerified( IntPtr self );
private BIsPhoneVerifiedDelegate BIsPhoneVerifiedDelegatePointer; private FBIsPhoneVerified _BIsPhoneVerified;
#endregion #endregion
internal bool BIsPhoneVerified() internal bool BIsPhoneVerified()
{ {
return BIsPhoneVerifiedDelegatePointer( Self ); return _BIsPhoneVerified( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool BIsTwoFactorEnabledDelegate( IntPtr self ); private delegate bool FBIsTwoFactorEnabled( IntPtr self );
private BIsTwoFactorEnabledDelegate BIsTwoFactorEnabledDelegatePointer; private FBIsTwoFactorEnabled _BIsTwoFactorEnabled;
#endregion #endregion
internal bool BIsTwoFactorEnabled() internal bool BIsTwoFactorEnabled()
{ {
return BIsTwoFactorEnabledDelegatePointer( Self ); return _BIsTwoFactorEnabled( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool BIsPhoneIdentifyingDelegate( IntPtr self ); private delegate bool FBIsPhoneIdentifying( IntPtr self );
private BIsPhoneIdentifyingDelegate BIsPhoneIdentifyingDelegatePointer; private FBIsPhoneIdentifying _BIsPhoneIdentifying;
#endregion #endregion
internal bool BIsPhoneIdentifying() internal bool BIsPhoneIdentifying()
{ {
return BIsPhoneIdentifyingDelegatePointer( Self ); return _BIsPhoneIdentifying( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool BIsPhoneRequiringVerificationDelegate( IntPtr self ); private delegate bool FBIsPhoneRequiringVerification( IntPtr self );
private BIsPhoneRequiringVerificationDelegate BIsPhoneRequiringVerificationDelegatePointer; private FBIsPhoneRequiringVerification _BIsPhoneRequiringVerification;
#endregion #endregion
internal bool BIsPhoneRequiringVerification() internal bool BIsPhoneRequiringVerification()
{ {
return BIsPhoneRequiringVerificationDelegatePointer( Self ); return _BIsPhoneRequiringVerification( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate SteamAPICall_t GetMarketEligibilityDelegate( IntPtr self ); private delegate SteamAPICall_t FGetMarketEligibility( IntPtr self );
private GetMarketEligibilityDelegate GetMarketEligibilityDelegatePointer; private FGetMarketEligibility _GetMarketEligibility;
#endregion #endregion
internal async Task<MarketEligibilityResponse_t?> GetMarketEligibility() internal async Task<MarketEligibilityResponse_t?> GetMarketEligibility()
{ {
return await (new Result<MarketEligibilityResponse_t>( GetMarketEligibilityDelegatePointer( Self ) )).GetResult(); return await (new Result<MarketEligibilityResponse_t>( _GetMarketEligibility( Self ) )).GetResult();
} }
} }

344
Facepunch.Steamworks/Generated/Interfaces/ISteamUserStats.cs
View File

@ -17,543 +17,543 @@ namespace Steamworks
public override void InitInternals() public override void InitInternals()
{ {
RequestCurrentStatsDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestCurrentStatsDelegate>( Marshal.ReadIntPtr( VTable, 0) ); _RequestCurrentStats = Marshal.GetDelegateForFunctionPointer<FRequestCurrentStats>( Marshal.ReadIntPtr( VTable, 0) );
GetStat1DelegatePointer = Marshal.GetDelegateForFunctionPointer<GetStat1Delegate>( Marshal.ReadIntPtr( VTable, 8) ); _GetStat1 = Marshal.GetDelegateForFunctionPointer<FGetStat1>( Marshal.ReadIntPtr( VTable, 8) );
GetStat2DelegatePointer = Marshal.GetDelegateForFunctionPointer<GetStat2Delegate>( Marshal.ReadIntPtr( VTable, 16) ); _GetStat2 = Marshal.GetDelegateForFunctionPointer<FGetStat2>( Marshal.ReadIntPtr( VTable, 16) );
SetStat1DelegatePointer = Marshal.GetDelegateForFunctionPointer<SetStat1Delegate>( Marshal.ReadIntPtr( VTable, 24) ); _SetStat1 = Marshal.GetDelegateForFunctionPointer<FSetStat1>( Marshal.ReadIntPtr( VTable, 24) );
SetStat2DelegatePointer = Marshal.GetDelegateForFunctionPointer<SetStat2Delegate>( Marshal.ReadIntPtr( VTable, 32) ); _SetStat2 = Marshal.GetDelegateForFunctionPointer<FSetStat2>( Marshal.ReadIntPtr( VTable, 32) );
UpdateAvgRateStatDelegatePointer = Marshal.GetDelegateForFunctionPointer<UpdateAvgRateStatDelegate>( Marshal.ReadIntPtr( VTable, 40) ); _UpdateAvgRateStat = Marshal.GetDelegateForFunctionPointer<FUpdateAvgRateStat>( Marshal.ReadIntPtr( VTable, 40) );
GetAchievementDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAchievementDelegate>( Marshal.ReadIntPtr( VTable, 48) ); _GetAchievement = Marshal.GetDelegateForFunctionPointer<FGetAchievement>( Marshal.ReadIntPtr( VTable, 48) );
SetAchievementDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetAchievementDelegate>( Marshal.ReadIntPtr( VTable, 56) ); _SetAchievement = Marshal.GetDelegateForFunctionPointer<FSetAchievement>( Marshal.ReadIntPtr( VTable, 56) );
ClearAchievementDelegatePointer = Marshal.GetDelegateForFunctionPointer<ClearAchievementDelegate>( Marshal.ReadIntPtr( VTable, 64) ); _ClearAchievement = Marshal.GetDelegateForFunctionPointer<FClearAchievement>( Marshal.ReadIntPtr( VTable, 64) );
GetAchievementAndUnlockTimeDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAchievementAndUnlockTimeDelegate>( Marshal.ReadIntPtr( VTable, 72) ); _GetAchievementAndUnlockTime = Marshal.GetDelegateForFunctionPointer<FGetAchievementAndUnlockTime>( Marshal.ReadIntPtr( VTable, 72) );
StoreStatsDelegatePointer = Marshal.GetDelegateForFunctionPointer<StoreStatsDelegate>( Marshal.ReadIntPtr( VTable, 80) ); _StoreStats = Marshal.GetDelegateForFunctionPointer<FStoreStats>( Marshal.ReadIntPtr( VTable, 80) );
GetAchievementIconDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAchievementIconDelegate>( Marshal.ReadIntPtr( VTable, 88) ); _GetAchievementIcon = Marshal.GetDelegateForFunctionPointer<FGetAchievementIcon>( Marshal.ReadIntPtr( VTable, 88) );
GetAchievementDisplayAttributeDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAchievementDisplayAttributeDelegate>( Marshal.ReadIntPtr( VTable, 96) ); _GetAchievementDisplayAttribute = Marshal.GetDelegateForFunctionPointer<FGetAchievementDisplayAttribute>( Marshal.ReadIntPtr( VTable, 96) );
IndicateAchievementProgressDelegatePointer = Marshal.GetDelegateForFunctionPointer<IndicateAchievementProgressDelegate>( Marshal.ReadIntPtr( VTable, 104) ); _IndicateAchievementProgress = Marshal.GetDelegateForFunctionPointer<FIndicateAchievementProgress>( Marshal.ReadIntPtr( VTable, 104) );
GetNumAchievementsDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetNumAchievementsDelegate>( Marshal.ReadIntPtr( VTable, 112) ); _GetNumAchievements = Marshal.GetDelegateForFunctionPointer<FGetNumAchievements>( Marshal.ReadIntPtr( VTable, 112) );
GetAchievementNameDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAchievementNameDelegate>( Marshal.ReadIntPtr( VTable, 120) ); _GetAchievementName = Marshal.GetDelegateForFunctionPointer<FGetAchievementName>( Marshal.ReadIntPtr( VTable, 120) );
RequestUserStatsDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestUserStatsDelegate>( Marshal.ReadIntPtr( VTable, 128) ); _RequestUserStats = Marshal.GetDelegateForFunctionPointer<FRequestUserStats>( Marshal.ReadIntPtr( VTable, 128) );
GetUserStat1DelegatePointer = Marshal.GetDelegateForFunctionPointer<GetUserStat1Delegate>( Marshal.ReadIntPtr( VTable, 136) ); _GetUserStat1 = Marshal.GetDelegateForFunctionPointer<FGetUserStat1>( Marshal.ReadIntPtr( VTable, 136) );
GetUserStat2DelegatePointer = Marshal.GetDelegateForFunctionPointer<GetUserStat2Delegate>( Marshal.ReadIntPtr( VTable, 144) ); _GetUserStat2 = Marshal.GetDelegateForFunctionPointer<FGetUserStat2>( Marshal.ReadIntPtr( VTable, 144) );
GetUserAchievementDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetUserAchievementDelegate>( Marshal.ReadIntPtr( VTable, 152) ); _GetUserAchievement = Marshal.GetDelegateForFunctionPointer<FGetUserAchievement>( Marshal.ReadIntPtr( VTable, 152) );
GetUserAchievementAndUnlockTimeDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetUserAchievementAndUnlockTimeDelegate>( Marshal.ReadIntPtr( VTable, 160) ); _GetUserAchievementAndUnlockTime = Marshal.GetDelegateForFunctionPointer<FGetUserAchievementAndUnlockTime>( Marshal.ReadIntPtr( VTable, 160) );
ResetAllStatsDelegatePointer = Marshal.GetDelegateForFunctionPointer<ResetAllStatsDelegate>( Marshal.ReadIntPtr( VTable, 168) ); _ResetAllStats = Marshal.GetDelegateForFunctionPointer<FResetAllStats>( Marshal.ReadIntPtr( VTable, 168) );
FindOrCreateLeaderboardDelegatePointer = Marshal.GetDelegateForFunctionPointer<FindOrCreateLeaderboardDelegate>( Marshal.ReadIntPtr( VTable, 176) ); _FindOrCreateLeaderboard = Marshal.GetDelegateForFunctionPointer<FFindOrCreateLeaderboard>( Marshal.ReadIntPtr( VTable, 176) );
FindLeaderboardDelegatePointer = Marshal.GetDelegateForFunctionPointer<FindLeaderboardDelegate>( Marshal.ReadIntPtr( VTable, 184) ); _FindLeaderboard = Marshal.GetDelegateForFunctionPointer<FFindLeaderboard>( Marshal.ReadIntPtr( VTable, 184) );
GetLeaderboardNameDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetLeaderboardNameDelegate>( Marshal.ReadIntPtr( VTable, 192) ); _GetLeaderboardName = Marshal.GetDelegateForFunctionPointer<FGetLeaderboardName>( Marshal.ReadIntPtr( VTable, 192) );
GetLeaderboardEntryCountDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetLeaderboardEntryCountDelegate>( Marshal.ReadIntPtr( VTable, 200) ); _GetLeaderboardEntryCount = Marshal.GetDelegateForFunctionPointer<FGetLeaderboardEntryCount>( Marshal.ReadIntPtr( VTable, 200) );
GetLeaderboardSortMethodDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetLeaderboardSortMethodDelegate>( Marshal.ReadIntPtr( VTable, 208) ); _GetLeaderboardSortMethod = Marshal.GetDelegateForFunctionPointer<FGetLeaderboardSortMethod>( Marshal.ReadIntPtr( VTable, 208) );
GetLeaderboardDisplayTypeDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetLeaderboardDisplayTypeDelegate>( Marshal.ReadIntPtr( VTable, 216) ); _GetLeaderboardDisplayType = Marshal.GetDelegateForFunctionPointer<FGetLeaderboardDisplayType>( Marshal.ReadIntPtr( VTable, 216) );
DownloadLeaderboardEntriesDelegatePointer = Marshal.GetDelegateForFunctionPointer<DownloadLeaderboardEntriesDelegate>( Marshal.ReadIntPtr( VTable, 224) ); _DownloadLeaderboardEntries = Marshal.GetDelegateForFunctionPointer<FDownloadLeaderboardEntries>( Marshal.ReadIntPtr( VTable, 224) );
DownloadLeaderboardEntriesForUsersDelegatePointer = Marshal.GetDelegateForFunctionPointer<DownloadLeaderboardEntriesForUsersDelegate>( Marshal.ReadIntPtr( VTable, 232) ); _DownloadLeaderboardEntriesForUsers = Marshal.GetDelegateForFunctionPointer<FDownloadLeaderboardEntriesForUsers>( Marshal.ReadIntPtr( VTable, 232) );
GetDownloadedLeaderboardEntryDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetDownloadedLeaderboardEntryDelegate>( Marshal.ReadIntPtr( VTable, 240) ); _GetDownloadedLeaderboardEntry = Marshal.GetDelegateForFunctionPointer<FGetDownloadedLeaderboardEntry>( Marshal.ReadIntPtr( VTable, 240) );
UploadLeaderboardScoreDelegatePointer = Marshal.GetDelegateForFunctionPointer<UploadLeaderboardScoreDelegate>( Marshal.ReadIntPtr( VTable, 248) ); _UploadLeaderboardScore = Marshal.GetDelegateForFunctionPointer<FUploadLeaderboardScore>( Marshal.ReadIntPtr( VTable, 248) );
AttachLeaderboardUGCDelegatePointer = Marshal.GetDelegateForFunctionPointer<AttachLeaderboardUGCDelegate>( Marshal.ReadIntPtr( VTable, 256) ); _AttachLeaderboardUGC = Marshal.GetDelegateForFunctionPointer<FAttachLeaderboardUGC>( Marshal.ReadIntPtr( VTable, 256) );
GetNumberOfCurrentPlayersDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetNumberOfCurrentPlayersDelegate>( Marshal.ReadIntPtr( VTable, 264) ); _GetNumberOfCurrentPlayers = Marshal.GetDelegateForFunctionPointer<FGetNumberOfCurrentPlayers>( Marshal.ReadIntPtr( VTable, 264) );
RequestGlobalAchievementPercentagesDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestGlobalAchievementPercentagesDelegate>( Marshal.ReadIntPtr( VTable, 272) ); _RequestGlobalAchievementPercentages = Marshal.GetDelegateForFunctionPointer<FRequestGlobalAchievementPercentages>( Marshal.ReadIntPtr( VTable, 272) );
GetMostAchievedAchievementInfoDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetMostAchievedAchievementInfoDelegate>( Marshal.ReadIntPtr( VTable, 280) ); _GetMostAchievedAchievementInfo = Marshal.GetDelegateForFunctionPointer<FGetMostAchievedAchievementInfo>( Marshal.ReadIntPtr( VTable, 280) );
GetNextMostAchievedAchievementInfoDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetNextMostAchievedAchievementInfoDelegate>( Marshal.ReadIntPtr( VTable, 288) ); _GetNextMostAchievedAchievementInfo = Marshal.GetDelegateForFunctionPointer<FGetNextMostAchievedAchievementInfo>( Marshal.ReadIntPtr( VTable, 288) );
GetAchievementAchievedPercentDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAchievementAchievedPercentDelegate>( Marshal.ReadIntPtr( VTable, 296) ); _GetAchievementAchievedPercent = Marshal.GetDelegateForFunctionPointer<FGetAchievementAchievedPercent>( Marshal.ReadIntPtr( VTable, 296) );
RequestGlobalStatsDelegatePointer = Marshal.GetDelegateForFunctionPointer<RequestGlobalStatsDelegate>( Marshal.ReadIntPtr( VTable, 304) ); _RequestGlobalStats = Marshal.GetDelegateForFunctionPointer<FRequestGlobalStats>( Marshal.ReadIntPtr( VTable, 304) );
GetGlobalStat1DelegatePointer = Marshal.GetDelegateForFunctionPointer<GetGlobalStat1Delegate>( Marshal.ReadIntPtr( VTable, 312) ); _GetGlobalStat1 = Marshal.GetDelegateForFunctionPointer<FGetGlobalStat1>( Marshal.ReadIntPtr( VTable, 312) );
GetGlobalStat2DelegatePointer = Marshal.GetDelegateForFunctionPointer<GetGlobalStat2Delegate>( Marshal.ReadIntPtr( VTable, 320) ); _GetGlobalStat2 = Marshal.GetDelegateForFunctionPointer<FGetGlobalStat2>( Marshal.ReadIntPtr( VTable, 320) );
GetGlobalStatHistory1DelegatePointer = Marshal.GetDelegateForFunctionPointer<GetGlobalStatHistory1Delegate>( Marshal.ReadIntPtr( VTable, 328) ); _GetGlobalStatHistory1 = Marshal.GetDelegateForFunctionPointer<FGetGlobalStatHistory1>( Marshal.ReadIntPtr( VTable, 328) );
GetGlobalStatHistory2DelegatePointer = Marshal.GetDelegateForFunctionPointer<GetGlobalStatHistory2Delegate>( Marshal.ReadIntPtr( VTable, 336) ); _GetGlobalStatHistory2 = Marshal.GetDelegateForFunctionPointer<FGetGlobalStatHistory2>( Marshal.ReadIntPtr( VTable, 336) );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool RequestCurrentStatsDelegate( IntPtr self ); private delegate bool FRequestCurrentStats( IntPtr self );
private RequestCurrentStatsDelegate RequestCurrentStatsDelegatePointer; private FRequestCurrentStats _RequestCurrentStats;
#endregion #endregion
internal bool RequestCurrentStats() internal bool RequestCurrentStats()
{ {
return RequestCurrentStatsDelegatePointer( Self ); return _RequestCurrentStats( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool GetStat1Delegate( IntPtr self, string pchName, ref int pData ); private delegate bool FGetStat1( IntPtr self, string pchName, ref int pData );
private GetStat1Delegate GetStat1DelegatePointer; private FGetStat1 _GetStat1;
#endregion #endregion
internal bool GetStat1( string pchName, ref int pData ) internal bool GetStat1( string pchName, ref int pData )
{ {
return GetStat1DelegatePointer( Self, pchName, ref pData ); return _GetStat1( Self, pchName, ref pData );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool GetStat2Delegate( IntPtr self, string pchName, ref float pData ); private delegate bool FGetStat2( IntPtr self, string pchName, ref float pData );
private GetStat2Delegate GetStat2DelegatePointer; private FGetStat2 _GetStat2;
#endregion #endregion
internal bool GetStat2( string pchName, ref float pData ) internal bool GetStat2( string pchName, ref float pData )
{ {
return GetStat2DelegatePointer( Self, pchName, ref pData ); return _GetStat2( Self, pchName, ref pData );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool SetStat1Delegate( IntPtr self, string pchName, int nData ); private delegate bool FSetStat1( IntPtr self, string pchName, int nData );
private SetStat1Delegate SetStat1DelegatePointer; private FSetStat1 _SetStat1;
#endregion #endregion
internal bool SetStat1( string pchName, int nData ) internal bool SetStat1( string pchName, int nData )
{ {
return SetStat1DelegatePointer( Self, pchName, nData ); return _SetStat1( Self, pchName, nData );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool SetStat2Delegate( IntPtr self, string pchName, float fData ); private delegate bool FSetStat2( IntPtr self, string pchName, float fData );
private SetStat2Delegate SetStat2DelegatePointer; private FSetStat2 _SetStat2;
#endregion #endregion
internal bool SetStat2( string pchName, float fData ) internal bool SetStat2( string pchName, float fData )
{ {
return SetStat2DelegatePointer( Self, pchName, fData ); return _SetStat2( Self, pchName, fData );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool UpdateAvgRateStatDelegate( IntPtr self, string pchName, float flCountThisSession, double dSessionLength ); private delegate bool FUpdateAvgRateStat( IntPtr self, string pchName, float flCountThisSession, double dSessionLength );
private UpdateAvgRateStatDelegate UpdateAvgRateStatDelegatePointer; private FUpdateAvgRateStat _UpdateAvgRateStat;
#endregion #endregion
internal bool UpdateAvgRateStat( string pchName, float flCountThisSession, double dSessionLength ) internal bool UpdateAvgRateStat( string pchName, float flCountThisSession, double dSessionLength )
{ {
return UpdateAvgRateStatDelegatePointer( Self, pchName, flCountThisSession, dSessionLength ); return _UpdateAvgRateStat( Self, pchName, flCountThisSession, dSessionLength );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool GetAchievementDelegate( IntPtr self, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved ); private delegate bool FGetAchievement( IntPtr self, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved );
private GetAchievementDelegate GetAchievementDelegatePointer; private FGetAchievement _GetAchievement;
#endregion #endregion
internal bool GetAchievement( string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved ) internal bool GetAchievement( string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved )
{ {
return GetAchievementDelegatePointer( Self, pchName, ref pbAchieved ); return _GetAchievement( Self, pchName, ref pbAchieved );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool SetAchievementDelegate( IntPtr self, string pchName ); private delegate bool FSetAchievement( IntPtr self, string pchName );
private SetAchievementDelegate SetAchievementDelegatePointer; private FSetAchievement _SetAchievement;
#endregion #endregion
internal bool SetAchievement( string pchName ) internal bool SetAchievement( string pchName )
{ {
return SetAchievementDelegatePointer( Self, pchName ); return _SetAchievement( Self, pchName );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool ClearAchievementDelegate( IntPtr self, string pchName ); private delegate bool FClearAchievement( IntPtr self, string pchName );
private ClearAchievementDelegate ClearAchievementDelegatePointer; private FClearAchievement _ClearAchievement;
#endregion #endregion
internal bool ClearAchievement( string pchName ) internal bool ClearAchievement( string pchName )
{ {
return ClearAchievementDelegatePointer( Self, pchName ); return _ClearAchievement( Self, pchName );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool GetAchievementAndUnlockTimeDelegate( IntPtr self, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved, ref uint punUnlockTime ); private delegate bool FGetAchievementAndUnlockTime( IntPtr self, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved, ref uint punUnlockTime );
private GetAchievementAndUnlockTimeDelegate GetAchievementAndUnlockTimeDelegatePointer; private FGetAchievementAndUnlockTime _GetAchievementAndUnlockTime;
#endregion #endregion
internal bool GetAchievementAndUnlockTime( string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved, ref uint punUnlockTime ) internal bool GetAchievementAndUnlockTime( string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved, ref uint punUnlockTime )
{ {
return GetAchievementAndUnlockTimeDelegatePointer( Self, pchName, ref pbAchieved, ref punUnlockTime ); return _GetAchievementAndUnlockTime( Self, pchName, ref pbAchieved, ref punUnlockTime );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool StoreStatsDelegate( IntPtr self ); private delegate bool FStoreStats( IntPtr self );
private StoreStatsDelegate StoreStatsDelegatePointer; private FStoreStats _StoreStats;
#endregion #endregion
internal bool StoreStats() internal bool StoreStats()
{ {
return StoreStatsDelegatePointer( Self ); return _StoreStats( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate int GetAchievementIconDelegate( IntPtr self, string pchName ); private delegate int FGetAchievementIcon( IntPtr self, string pchName );
private GetAchievementIconDelegate GetAchievementIconDelegatePointer; private FGetAchievementIcon _GetAchievementIcon;
#endregion #endregion
internal int GetAchievementIcon( string pchName ) internal int GetAchievementIcon( string pchName )
{ {
return GetAchievementIconDelegatePointer( Self, pchName ); return _GetAchievementIcon( Self, pchName );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate IntPtr GetAchievementDisplayAttributeDelegate( IntPtr self, string pchName, string pchKey ); private delegate IntPtr FGetAchievementDisplayAttribute( IntPtr self, string pchName, string pchKey );
private GetAchievementDisplayAttributeDelegate GetAchievementDisplayAttributeDelegatePointer; private FGetAchievementDisplayAttribute _GetAchievementDisplayAttribute;
#endregion #endregion
internal string GetAchievementDisplayAttribute( string pchName, string pchKey ) internal string GetAchievementDisplayAttribute( string pchName, string pchKey )
{ {
return GetString( GetAchievementDisplayAttributeDelegatePointer( Self, pchName, pchKey ) ); return GetString( _GetAchievementDisplayAttribute( Self, pchName, pchKey ) );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool IndicateAchievementProgressDelegate( IntPtr self, string pchName, uint nCurProgress, uint nMaxProgress ); private delegate bool FIndicateAchievementProgress( IntPtr self, string pchName, uint nCurProgress, uint nMaxProgress );
private IndicateAchievementProgressDelegate IndicateAchievementProgressDelegatePointer; private FIndicateAchievementProgress _IndicateAchievementProgress;
#endregion #endregion
internal bool IndicateAchievementProgress( string pchName, uint nCurProgress, uint nMaxProgress ) internal bool IndicateAchievementProgress( string pchName, uint nCurProgress, uint nMaxProgress )
{ {
return IndicateAchievementProgressDelegatePointer( Self, pchName, nCurProgress, nMaxProgress ); return _IndicateAchievementProgress( Self, pchName, nCurProgress, nMaxProgress );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate uint GetNumAchievementsDelegate( IntPtr self ); private delegate uint FGetNumAchievements( IntPtr self );
private GetNumAchievementsDelegate GetNumAchievementsDelegatePointer; private FGetNumAchievements _GetNumAchievements;
#endregion #endregion
internal uint GetNumAchievements() internal uint GetNumAchievements()
{ {
return GetNumAchievementsDelegatePointer( Self ); return _GetNumAchievements( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate IntPtr GetAchievementNameDelegate( IntPtr self, uint iAchievement ); private delegate IntPtr FGetAchievementName( IntPtr self, uint iAchievement );
private GetAchievementNameDelegate GetAchievementNameDelegatePointer; private FGetAchievementName _GetAchievementName;
#endregion #endregion
internal string GetAchievementName( uint iAchievement ) internal string GetAchievementName( uint iAchievement )
{ {
return GetString( GetAchievementNameDelegatePointer( Self, iAchievement ) ); return GetString( _GetAchievementName( Self, iAchievement ) );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate SteamAPICall_t RequestUserStatsDelegate( IntPtr self, SteamId steamIDUser ); private delegate SteamAPICall_t FRequestUserStats( IntPtr self, SteamId steamIDUser );
private RequestUserStatsDelegate RequestUserStatsDelegatePointer; private FRequestUserStats _RequestUserStats;
#endregion #endregion
internal async Task<UserStatsReceived_t?> RequestUserStats( SteamId steamIDUser ) internal async Task<UserStatsReceived_t?> RequestUserStats( SteamId steamIDUser )
{ {
return await (new Result<UserStatsReceived_t>( RequestUserStatsDelegatePointer( Self, steamIDUser ) )).GetResult(); return await (new Result<UserStatsReceived_t>( _RequestUserStats( Self, steamIDUser ) )).GetResult();
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool GetUserStat1Delegate( IntPtr self, SteamId steamIDUser, string pchName, ref int pData ); private delegate bool FGetUserStat1( IntPtr self, SteamId steamIDUser, string pchName, ref int pData );
private GetUserStat1Delegate GetUserStat1DelegatePointer; private FGetUserStat1 _GetUserStat1;
#endregion #endregion
internal bool GetUserStat1( SteamId steamIDUser, string pchName, ref int pData ) internal bool GetUserStat1( SteamId steamIDUser, string pchName, ref int pData )
{ {
return GetUserStat1DelegatePointer( Self, steamIDUser, pchName, ref pData ); return _GetUserStat1( Self, steamIDUser, pchName, ref pData );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool GetUserStat2Delegate( IntPtr self, SteamId steamIDUser, string pchName, ref float pData ); private delegate bool FGetUserStat2( IntPtr self, SteamId steamIDUser, string pchName, ref float pData );
private GetUserStat2Delegate GetUserStat2DelegatePointer; private FGetUserStat2 _GetUserStat2;
#endregion #endregion
internal bool GetUserStat2( SteamId steamIDUser, string pchName, ref float pData ) internal bool GetUserStat2( SteamId steamIDUser, string pchName, ref float pData )
{ {
return GetUserStat2DelegatePointer( Self, steamIDUser, pchName, ref pData ); return _GetUserStat2( Self, steamIDUser, pchName, ref pData );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool GetUserAchievementDelegate( IntPtr self, SteamId steamIDUser, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved ); private delegate bool FGetUserAchievement( IntPtr self, SteamId steamIDUser, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved );
private GetUserAchievementDelegate GetUserAchievementDelegatePointer; private FGetUserAchievement _GetUserAchievement;
#endregion #endregion
internal bool GetUserAchievement( SteamId steamIDUser, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved ) internal bool GetUserAchievement( SteamId steamIDUser, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved )
{ {
return GetUserAchievementDelegatePointer( Self, steamIDUser, pchName, ref pbAchieved ); return _GetUserAchievement( Self, steamIDUser, pchName, ref pbAchieved );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool GetUserAchievementAndUnlockTimeDelegate( IntPtr self, SteamId steamIDUser, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved, ref uint punUnlockTime ); private delegate bool FGetUserAchievementAndUnlockTime( IntPtr self, SteamId steamIDUser, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved, ref uint punUnlockTime );
private GetUserAchievementAndUnlockTimeDelegate GetUserAchievementAndUnlockTimeDelegatePointer; private FGetUserAchievementAndUnlockTime _GetUserAchievementAndUnlockTime;
#endregion #endregion
internal bool GetUserAchievementAndUnlockTime( SteamId steamIDUser, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved, ref uint punUnlockTime ) internal bool GetUserAchievementAndUnlockTime( SteamId steamIDUser, string pchName, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved, ref uint punUnlockTime )
{ {
return GetUserAchievementAndUnlockTimeDelegatePointer( Self, steamIDUser, pchName, ref pbAchieved, ref punUnlockTime ); return _GetUserAchievementAndUnlockTime( Self, steamIDUser, pchName, ref pbAchieved, ref punUnlockTime );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool ResetAllStatsDelegate( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bAchievementsToo ); private delegate bool FResetAllStats( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bAchievementsToo );
private ResetAllStatsDelegate ResetAllStatsDelegatePointer; private FResetAllStats _ResetAllStats;
#endregion #endregion
internal bool ResetAllStats( [MarshalAs( UnmanagedType.U1 )] bool bAchievementsToo ) internal bool ResetAllStats( [MarshalAs( UnmanagedType.U1 )] bool bAchievementsToo )
{ {
return ResetAllStatsDelegatePointer( Self, bAchievementsToo ); return _ResetAllStats( Self, bAchievementsToo );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate SteamAPICall_t FindOrCreateLeaderboardDelegate( IntPtr self, string pchLeaderboardName, LeaderboardSort eLeaderboardSortMethod, LeaderboardDisplay eLeaderboardDisplayType ); private delegate SteamAPICall_t FFindOrCreateLeaderboard( IntPtr self, string pchLeaderboardName, LeaderboardSort eLeaderboardSortMethod, LeaderboardDisplay eLeaderboardDisplayType );
private FindOrCreateLeaderboardDelegate FindOrCreateLeaderboardDelegatePointer; private FFindOrCreateLeaderboard _FindOrCreateLeaderboard;
#endregion #endregion
internal async Task<LeaderboardFindResult_t?> FindOrCreateLeaderboard( string pchLeaderboardName, LeaderboardSort eLeaderboardSortMethod, LeaderboardDisplay eLeaderboardDisplayType ) internal async Task<LeaderboardFindResult_t?> FindOrCreateLeaderboard( string pchLeaderboardName, LeaderboardSort eLeaderboardSortMethod, LeaderboardDisplay eLeaderboardDisplayType )
{ {
return await (new Result<LeaderboardFindResult_t>( FindOrCreateLeaderboardDelegatePointer( Self, pchLeaderboardName, eLeaderboardSortMethod, eLeaderboardDisplayType ) )).GetResult(); return await (new Result<LeaderboardFindResult_t>( _FindOrCreateLeaderboard( Self, pchLeaderboardName, eLeaderboardSortMethod, eLeaderboardDisplayType ) )).GetResult();
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate SteamAPICall_t FindLeaderboardDelegate( IntPtr self, string pchLeaderboardName ); private delegate SteamAPICall_t FFindLeaderboard( IntPtr self, string pchLeaderboardName );
private FindLeaderboardDelegate FindLeaderboardDelegatePointer; private FFindLeaderboard _FindLeaderboard;
#endregion #endregion
internal async Task<LeaderboardFindResult_t?> FindLeaderboard( string pchLeaderboardName ) internal async Task<LeaderboardFindResult_t?> FindLeaderboard( string pchLeaderboardName )
{ {
return await (new Result<LeaderboardFindResult_t>( FindLeaderboardDelegatePointer( Self, pchLeaderboardName ) )).GetResult(); return await (new Result<LeaderboardFindResult_t>( _FindLeaderboard( Self, pchLeaderboardName ) )).GetResult();
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate IntPtr GetLeaderboardNameDelegate( IntPtr self, SteamLeaderboard_t hSteamLeaderboard ); private delegate IntPtr FGetLeaderboardName( IntPtr self, SteamLeaderboard_t hSteamLeaderboard );
private GetLeaderboardNameDelegate GetLeaderboardNameDelegatePointer; private FGetLeaderboardName _GetLeaderboardName;
#endregion #endregion
internal string GetLeaderboardName( SteamLeaderboard_t hSteamLeaderboard ) internal string GetLeaderboardName( SteamLeaderboard_t hSteamLeaderboard )
{ {
return GetString( GetLeaderboardNameDelegatePointer( Self, hSteamLeaderboard ) ); return GetString( _GetLeaderboardName( Self, hSteamLeaderboard ) );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate int GetLeaderboardEntryCountDelegate( IntPtr self, SteamLeaderboard_t hSteamLeaderboard ); private delegate int FGetLeaderboardEntryCount( IntPtr self, SteamLeaderboard_t hSteamLeaderboard );
private GetLeaderboardEntryCountDelegate GetLeaderboardEntryCountDelegatePointer; private FGetLeaderboardEntryCount _GetLeaderboardEntryCount;
#endregion #endregion
internal int GetLeaderboardEntryCount( SteamLeaderboard_t hSteamLeaderboard ) internal int GetLeaderboardEntryCount( SteamLeaderboard_t hSteamLeaderboard )
{ {
return GetLeaderboardEntryCountDelegatePointer( Self, hSteamLeaderboard ); return _GetLeaderboardEntryCount( Self, hSteamLeaderboard );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate LeaderboardSort GetLeaderboardSortMethodDelegate( IntPtr self, SteamLeaderboard_t hSteamLeaderboard ); private delegate LeaderboardSort FGetLeaderboardSortMethod( IntPtr self, SteamLeaderboard_t hSteamLeaderboard );
private GetLeaderboardSortMethodDelegate GetLeaderboardSortMethodDelegatePointer; private FGetLeaderboardSortMethod _GetLeaderboardSortMethod;
#endregion #endregion
internal LeaderboardSort GetLeaderboardSortMethod( SteamLeaderboard_t hSteamLeaderboard ) internal LeaderboardSort GetLeaderboardSortMethod( SteamLeaderboard_t hSteamLeaderboard )
{ {
return GetLeaderboardSortMethodDelegatePointer( Self, hSteamLeaderboard ); return _GetLeaderboardSortMethod( Self, hSteamLeaderboard );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate LeaderboardDisplay GetLeaderboardDisplayTypeDelegate( IntPtr self, SteamLeaderboard_t hSteamLeaderboard ); private delegate LeaderboardDisplay FGetLeaderboardDisplayType( IntPtr self, SteamLeaderboard_t hSteamLeaderboard );
private GetLeaderboardDisplayTypeDelegate GetLeaderboardDisplayTypeDelegatePointer; private FGetLeaderboardDisplayType _GetLeaderboardDisplayType;
#endregion #endregion
internal LeaderboardDisplay GetLeaderboardDisplayType( SteamLeaderboard_t hSteamLeaderboard ) internal LeaderboardDisplay GetLeaderboardDisplayType( SteamLeaderboard_t hSteamLeaderboard )
{ {
return GetLeaderboardDisplayTypeDelegatePointer( Self, hSteamLeaderboard ); return _GetLeaderboardDisplayType( Self, hSteamLeaderboard );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate SteamAPICall_t DownloadLeaderboardEntriesDelegate( IntPtr self, SteamLeaderboard_t hSteamLeaderboard, LeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd ); private delegate SteamAPICall_t FDownloadLeaderboardEntries( IntPtr self, SteamLeaderboard_t hSteamLeaderboard, LeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd );
private DownloadLeaderboardEntriesDelegate DownloadLeaderboardEntriesDelegatePointer; private FDownloadLeaderboardEntries _DownloadLeaderboardEntries;
#endregion #endregion
internal async Task<LeaderboardScoresDownloaded_t?> DownloadLeaderboardEntries( SteamLeaderboard_t hSteamLeaderboard, LeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd ) internal async Task<LeaderboardScoresDownloaded_t?> DownloadLeaderboardEntries( SteamLeaderboard_t hSteamLeaderboard, LeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd )
{ {
return await (new Result<LeaderboardScoresDownloaded_t>( DownloadLeaderboardEntriesDelegatePointer( Self, hSteamLeaderboard, eLeaderboardDataRequest, nRangeStart, nRangeEnd ) )).GetResult(); return await (new Result<LeaderboardScoresDownloaded_t>( _DownloadLeaderboardEntries( Self, hSteamLeaderboard, eLeaderboardDataRequest, nRangeStart, nRangeEnd ) )).GetResult();
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate SteamAPICall_t DownloadLeaderboardEntriesForUsersDelegate( IntPtr self, SteamLeaderboard_t hSteamLeaderboard, [In,Out] SteamId[] prgUsers, int cUsers ); private delegate SteamAPICall_t FDownloadLeaderboardEntriesForUsers( IntPtr self, SteamLeaderboard_t hSteamLeaderboard, [In,Out] SteamId[] prgUsers, int cUsers );
private DownloadLeaderboardEntriesForUsersDelegate DownloadLeaderboardEntriesForUsersDelegatePointer; private FDownloadLeaderboardEntriesForUsers _DownloadLeaderboardEntriesForUsers;
#endregion #endregion
internal async Task<LeaderboardScoresDownloaded_t?> DownloadLeaderboardEntriesForUsers( SteamLeaderboard_t hSteamLeaderboard, [In,Out] SteamId[] prgUsers, int cUsers ) internal async Task<LeaderboardScoresDownloaded_t?> DownloadLeaderboardEntriesForUsers( SteamLeaderboard_t hSteamLeaderboard, [In,Out] SteamId[] prgUsers, int cUsers )
{ {
return await (new Result<LeaderboardScoresDownloaded_t>( DownloadLeaderboardEntriesForUsersDelegatePointer( Self, hSteamLeaderboard, prgUsers, cUsers ) )).GetResult(); return await (new Result<LeaderboardScoresDownloaded_t>( _DownloadLeaderboardEntriesForUsers( Self, hSteamLeaderboard, prgUsers, cUsers ) )).GetResult();
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool GetDownloadedLeaderboardEntryDelegate( IntPtr self, SteamLeaderboardEntries_t hSteamLeaderboardEntries, int index, ref LeaderboardEntry_t pLeaderboardEntry, [In,Out] int[] pDetails, int cDetailsMax ); private delegate bool FGetDownloadedLeaderboardEntry( IntPtr self, SteamLeaderboardEntries_t hSteamLeaderboardEntries, int index, ref LeaderboardEntry_t pLeaderboardEntry, [In,Out] int[] pDetails, int cDetailsMax );
private GetDownloadedLeaderboardEntryDelegate GetDownloadedLeaderboardEntryDelegatePointer; private FGetDownloadedLeaderboardEntry _GetDownloadedLeaderboardEntry;
#endregion #endregion
internal bool GetDownloadedLeaderboardEntry( SteamLeaderboardEntries_t hSteamLeaderboardEntries, int index, ref LeaderboardEntry_t pLeaderboardEntry, [In,Out] int[] pDetails, int cDetailsMax ) internal bool GetDownloadedLeaderboardEntry( SteamLeaderboardEntries_t hSteamLeaderboardEntries, int index, ref LeaderboardEntry_t pLeaderboardEntry, [In,Out] int[] pDetails, int cDetailsMax )
{ {
return GetDownloadedLeaderboardEntryDelegatePointer( Self, hSteamLeaderboardEntries, index, ref pLeaderboardEntry, pDetails, cDetailsMax ); return _GetDownloadedLeaderboardEntry( Self, hSteamLeaderboardEntries, index, ref pLeaderboardEntry, pDetails, cDetailsMax );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate SteamAPICall_t UploadLeaderboardScoreDelegate( IntPtr self, SteamLeaderboard_t hSteamLeaderboard, LeaderboardUploadScoreMethod eLeaderboardUploadScoreMethod, int nScore, [In,Out] int[] pScoreDetails, int cScoreDetailsCount ); private delegate SteamAPICall_t FUploadLeaderboardScore( IntPtr self, SteamLeaderboard_t hSteamLeaderboard, LeaderboardUploadScoreMethod eLeaderboardUploadScoreMethod, int nScore, [In,Out] int[] pScoreDetails, int cScoreDetailsCount );
private UploadLeaderboardScoreDelegate UploadLeaderboardScoreDelegatePointer; private FUploadLeaderboardScore _UploadLeaderboardScore;
#endregion #endregion
internal async Task<LeaderboardScoreUploaded_t?> UploadLeaderboardScore( SteamLeaderboard_t hSteamLeaderboard, LeaderboardUploadScoreMethod eLeaderboardUploadScoreMethod, int nScore, [In,Out] int[] pScoreDetails, int cScoreDetailsCount ) internal async Task<LeaderboardScoreUploaded_t?> UploadLeaderboardScore( SteamLeaderboard_t hSteamLeaderboard, LeaderboardUploadScoreMethod eLeaderboardUploadScoreMethod, int nScore, [In,Out] int[] pScoreDetails, int cScoreDetailsCount )
{ {
return await (new Result<LeaderboardScoreUploaded_t>( UploadLeaderboardScoreDelegatePointer( Self, hSteamLeaderboard, eLeaderboardUploadScoreMethod, nScore, pScoreDetails, cScoreDetailsCount ) )).GetResult(); return await (new Result<LeaderboardScoreUploaded_t>( _UploadLeaderboardScore( Self, hSteamLeaderboard, eLeaderboardUploadScoreMethod, nScore, pScoreDetails, cScoreDetailsCount ) )).GetResult();
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate SteamAPICall_t AttachLeaderboardUGCDelegate( IntPtr self, SteamLeaderboard_t hSteamLeaderboard, UGCHandle_t hUGC ); private delegate SteamAPICall_t FAttachLeaderboardUGC( IntPtr self, SteamLeaderboard_t hSteamLeaderboard, UGCHandle_t hUGC );
private AttachLeaderboardUGCDelegate AttachLeaderboardUGCDelegatePointer; private FAttachLeaderboardUGC _AttachLeaderboardUGC;
#endregion #endregion
internal async Task<LeaderboardUGCSet_t?> AttachLeaderboardUGC( SteamLeaderboard_t hSteamLeaderboard, UGCHandle_t hUGC ) internal async Task<LeaderboardUGCSet_t?> AttachLeaderboardUGC( SteamLeaderboard_t hSteamLeaderboard, UGCHandle_t hUGC )
{ {
return await (new Result<LeaderboardUGCSet_t>( AttachLeaderboardUGCDelegatePointer( Self, hSteamLeaderboard, hUGC ) )).GetResult(); return await (new Result<LeaderboardUGCSet_t>( _AttachLeaderboardUGC( Self, hSteamLeaderboard, hUGC ) )).GetResult();
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate SteamAPICall_t GetNumberOfCurrentPlayersDelegate( IntPtr self ); private delegate SteamAPICall_t FGetNumberOfCurrentPlayers( IntPtr self );
private GetNumberOfCurrentPlayersDelegate GetNumberOfCurrentPlayersDelegatePointer; private FGetNumberOfCurrentPlayers _GetNumberOfCurrentPlayers;
#endregion #endregion
internal async Task<NumberOfCurrentPlayers_t?> GetNumberOfCurrentPlayers() internal async Task<NumberOfCurrentPlayers_t?> GetNumberOfCurrentPlayers()
{ {
return await (new Result<NumberOfCurrentPlayers_t>( GetNumberOfCurrentPlayersDelegatePointer( Self ) )).GetResult(); return await (new Result<NumberOfCurrentPlayers_t>( _GetNumberOfCurrentPlayers( Self ) )).GetResult();
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate SteamAPICall_t RequestGlobalAchievementPercentagesDelegate( IntPtr self ); private delegate SteamAPICall_t FRequestGlobalAchievementPercentages( IntPtr self );
private RequestGlobalAchievementPercentagesDelegate RequestGlobalAchievementPercentagesDelegatePointer; private FRequestGlobalAchievementPercentages _RequestGlobalAchievementPercentages;
#endregion #endregion
internal async Task<GlobalAchievementPercentagesReady_t?> RequestGlobalAchievementPercentages() internal async Task<GlobalAchievementPercentagesReady_t?> RequestGlobalAchievementPercentages()
{ {
return await (new Result<GlobalAchievementPercentagesReady_t>( RequestGlobalAchievementPercentagesDelegatePointer( Self ) )).GetResult(); return await (new Result<GlobalAchievementPercentagesReady_t>( _RequestGlobalAchievementPercentages( Self ) )).GetResult();
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate int GetMostAchievedAchievementInfoDelegate( IntPtr self, StringBuilder pchName, uint unNameBufLen, ref float pflPercent, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved ); private delegate int FGetMostAchievedAchievementInfo( IntPtr self, StringBuilder pchName, uint unNameBufLen, ref float pflPercent, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved );
private GetMostAchievedAchievementInfoDelegate GetMostAchievedAchievementInfoDelegatePointer; private FGetMostAchievedAchievementInfo _GetMostAchievedAchievementInfo;
#endregion #endregion
internal int GetMostAchievedAchievementInfo( StringBuilder pchName, uint unNameBufLen, ref float pflPercent, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved ) internal int GetMostAchievedAchievementInfo( StringBuilder pchName, uint unNameBufLen, ref float pflPercent, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved )
{ {
return GetMostAchievedAchievementInfoDelegatePointer( Self, pchName, unNameBufLen, ref pflPercent, ref pbAchieved ); return _GetMostAchievedAchievementInfo( Self, pchName, unNameBufLen, ref pflPercent, ref pbAchieved );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate int GetNextMostAchievedAchievementInfoDelegate( IntPtr self, int iIteratorPrevious, StringBuilder pchName, uint unNameBufLen, ref float pflPercent, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved ); private delegate int FGetNextMostAchievedAchievementInfo( IntPtr self, int iIteratorPrevious, StringBuilder pchName, uint unNameBufLen, ref float pflPercent, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved );
private GetNextMostAchievedAchievementInfoDelegate GetNextMostAchievedAchievementInfoDelegatePointer; private FGetNextMostAchievedAchievementInfo _GetNextMostAchievedAchievementInfo;
#endregion #endregion
internal int GetNextMostAchievedAchievementInfo( int iIteratorPrevious, StringBuilder pchName, uint unNameBufLen, ref float pflPercent, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved ) internal int GetNextMostAchievedAchievementInfo( int iIteratorPrevious, StringBuilder pchName, uint unNameBufLen, ref float pflPercent, [MarshalAs( UnmanagedType.U1 )] ref bool pbAchieved )
{ {
return GetNextMostAchievedAchievementInfoDelegatePointer( Self, iIteratorPrevious, pchName, unNameBufLen, ref pflPercent, ref pbAchieved ); return _GetNextMostAchievedAchievementInfo( Self, iIteratorPrevious, pchName, unNameBufLen, ref pflPercent, ref pbAchieved );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool GetAchievementAchievedPercentDelegate( IntPtr self, string pchName, ref float pflPercent ); private delegate bool FGetAchievementAchievedPercent( IntPtr self, string pchName, ref float pflPercent );
private GetAchievementAchievedPercentDelegate GetAchievementAchievedPercentDelegatePointer; private FGetAchievementAchievedPercent _GetAchievementAchievedPercent;
#endregion #endregion
internal bool GetAchievementAchievedPercent( string pchName, ref float pflPercent ) internal bool GetAchievementAchievedPercent( string pchName, ref float pflPercent )
{ {
return GetAchievementAchievedPercentDelegatePointer( Self, pchName, ref pflPercent ); return _GetAchievementAchievedPercent( Self, pchName, ref pflPercent );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate SteamAPICall_t RequestGlobalStatsDelegate( IntPtr self, int nHistoryDays ); private delegate SteamAPICall_t FRequestGlobalStats( IntPtr self, int nHistoryDays );
private RequestGlobalStatsDelegate RequestGlobalStatsDelegatePointer; private FRequestGlobalStats _RequestGlobalStats;
#endregion #endregion
internal async Task<GlobalStatsReceived_t?> RequestGlobalStats( int nHistoryDays ) internal async Task<GlobalStatsReceived_t?> RequestGlobalStats( int nHistoryDays )
{ {
return await (new Result<GlobalStatsReceived_t>( RequestGlobalStatsDelegatePointer( Self, nHistoryDays ) )).GetResult(); return await (new Result<GlobalStatsReceived_t>( _RequestGlobalStats( Self, nHistoryDays ) )).GetResult();
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool GetGlobalStat1Delegate( IntPtr self, string pchStatName, ref long pData ); private delegate bool FGetGlobalStat1( IntPtr self, string pchStatName, ref long pData );
private GetGlobalStat1Delegate GetGlobalStat1DelegatePointer; private FGetGlobalStat1 _GetGlobalStat1;
#endregion #endregion
internal bool GetGlobalStat1( string pchStatName, ref long pData ) internal bool GetGlobalStat1( string pchStatName, ref long pData )
{ {
return GetGlobalStat1DelegatePointer( Self, pchStatName, ref pData ); return _GetGlobalStat1( Self, pchStatName, ref pData );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool GetGlobalStat2Delegate( IntPtr self, string pchStatName, ref double pData ); private delegate bool FGetGlobalStat2( IntPtr self, string pchStatName, ref double pData );
private GetGlobalStat2Delegate GetGlobalStat2DelegatePointer; private FGetGlobalStat2 _GetGlobalStat2;
#endregion #endregion
internal bool GetGlobalStat2( string pchStatName, ref double pData ) internal bool GetGlobalStat2( string pchStatName, ref double pData )
{ {
return GetGlobalStat2DelegatePointer( Self, pchStatName, ref pData ); return _GetGlobalStat2( Self, pchStatName, ref pData );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate int GetGlobalStatHistory1Delegate( IntPtr self, string pchStatName, [In,Out] long[] pData, uint cubData ); private delegate int FGetGlobalStatHistory1( IntPtr self, string pchStatName, [In,Out] long[] pData, uint cubData );
private GetGlobalStatHistory1Delegate GetGlobalStatHistory1DelegatePointer; private FGetGlobalStatHistory1 _GetGlobalStatHistory1;
#endregion #endregion
internal int GetGlobalStatHistory1( string pchStatName, [In,Out] long[] pData, uint cubData ) internal int GetGlobalStatHistory1( string pchStatName, [In,Out] long[] pData, uint cubData )
{ {
return GetGlobalStatHistory1DelegatePointer( Self, pchStatName, pData, cubData ); return _GetGlobalStatHistory1( Self, pchStatName, pData, cubData );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate int GetGlobalStatHistory2Delegate( IntPtr self, string pchStatName, [In,Out] double[] pData, uint cubData ); private delegate int FGetGlobalStatHistory2( IntPtr self, string pchStatName, [In,Out] double[] pData, uint cubData );
private GetGlobalStatHistory2Delegate GetGlobalStatHistory2DelegatePointer; private FGetGlobalStatHistory2 _GetGlobalStatHistory2;
#endregion #endregion
internal int GetGlobalStatHistory2( string pchStatName, [In,Out] double[] pData, uint cubData ) internal int GetGlobalStatHistory2( string pchStatName, [In,Out] double[] pData, uint cubData )
{ {
return GetGlobalStatHistory2DelegatePointer( Self, pchStatName, pData, cubData ); return _GetGlobalStatHistory2( Self, pchStatName, pData, cubData );
} }
} }

240
Facepunch.Steamworks/Generated/Interfaces/ISteamUtils.cs
View File

@ -17,378 +17,378 @@ namespace Steamworks
public override void InitInternals() public override void InitInternals()
{ {
GetSecondsSinceAppActiveDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetSecondsSinceAppActiveDelegate>( Marshal.ReadIntPtr( VTable, 0) ); _GetSecondsSinceAppActive = Marshal.GetDelegateForFunctionPointer<FGetSecondsSinceAppActive>( Marshal.ReadIntPtr( VTable, 0) );
GetSecondsSinceComputerActiveDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetSecondsSinceComputerActiveDelegate>( Marshal.ReadIntPtr( VTable, 8) ); _GetSecondsSinceComputerActive = Marshal.GetDelegateForFunctionPointer<FGetSecondsSinceComputerActive>( Marshal.ReadIntPtr( VTable, 8) );
GetConnectedUniverseDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetConnectedUniverseDelegate>( Marshal.ReadIntPtr( VTable, 16) ); _GetConnectedUniverse = Marshal.GetDelegateForFunctionPointer<FGetConnectedUniverse>( Marshal.ReadIntPtr( VTable, 16) );
GetServerRealTimeDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetServerRealTimeDelegate>( Marshal.ReadIntPtr( VTable, 24) ); _GetServerRealTime = Marshal.GetDelegateForFunctionPointer<FGetServerRealTime>( Marshal.ReadIntPtr( VTable, 24) );
GetIPCountryDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetIPCountryDelegate>( Marshal.ReadIntPtr( VTable, 32) ); _GetIPCountry = Marshal.GetDelegateForFunctionPointer<FGetIPCountry>( Marshal.ReadIntPtr( VTable, 32) );
GetImageSizeDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetImageSizeDelegate>( Marshal.ReadIntPtr( VTable, 40) ); _GetImageSize = Marshal.GetDelegateForFunctionPointer<FGetImageSize>( Marshal.ReadIntPtr( VTable, 40) );
GetImageRGBADelegatePointer = Marshal.GetDelegateForFunctionPointer<GetImageRGBADelegate>( Marshal.ReadIntPtr( VTable, 48) ); _GetImageRGBA = Marshal.GetDelegateForFunctionPointer<FGetImageRGBA>( Marshal.ReadIntPtr( VTable, 48) );
GetCSERIPPortDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetCSERIPPortDelegate>( Marshal.ReadIntPtr( VTable, 56) ); _GetCSERIPPort = Marshal.GetDelegateForFunctionPointer<FGetCSERIPPort>( Marshal.ReadIntPtr( VTable, 56) );
GetCurrentBatteryPowerDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetCurrentBatteryPowerDelegate>( Marshal.ReadIntPtr( VTable, 64) ); _GetCurrentBatteryPower = Marshal.GetDelegateForFunctionPointer<FGetCurrentBatteryPower>( Marshal.ReadIntPtr( VTable, 64) );
GetAppIDDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAppIDDelegate>( Marshal.ReadIntPtr( VTable, 72) ); _GetAppID = Marshal.GetDelegateForFunctionPointer<FGetAppID>( Marshal.ReadIntPtr( VTable, 72) );
SetOverlayNotificationPositionDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetOverlayNotificationPositionDelegate>( Marshal.ReadIntPtr( VTable, 80) ); _SetOverlayNotificationPosition = Marshal.GetDelegateForFunctionPointer<FSetOverlayNotificationPosition>( Marshal.ReadIntPtr( VTable, 80) );
IsAPICallCompletedDelegatePointer = Marshal.GetDelegateForFunctionPointer<IsAPICallCompletedDelegate>( Marshal.ReadIntPtr( VTable, 88) ); _IsAPICallCompleted = Marshal.GetDelegateForFunctionPointer<FIsAPICallCompleted>( Marshal.ReadIntPtr( VTable, 88) );
GetAPICallFailureReasonDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAPICallFailureReasonDelegate>( Marshal.ReadIntPtr( VTable, 96) ); _GetAPICallFailureReason = Marshal.GetDelegateForFunctionPointer<FGetAPICallFailureReason>( Marshal.ReadIntPtr( VTable, 96) );
GetAPICallResultDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetAPICallResultDelegate>( Marshal.ReadIntPtr( VTable, 104) ); _GetAPICallResult = Marshal.GetDelegateForFunctionPointer<FGetAPICallResult>( Marshal.ReadIntPtr( VTable, 104) );
RunFrameDelegatePointer = Marshal.GetDelegateForFunctionPointer<RunFrameDelegate>( Marshal.ReadIntPtr( VTable, 112) ); _RunFrame = Marshal.GetDelegateForFunctionPointer<FRunFrame>( Marshal.ReadIntPtr( VTable, 112) );
GetIPCCallCountDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetIPCCallCountDelegate>( Marshal.ReadIntPtr( VTable, 120) ); _GetIPCCallCount = Marshal.GetDelegateForFunctionPointer<FGetIPCCallCount>( Marshal.ReadIntPtr( VTable, 120) );
SetWarningMessageHookDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetWarningMessageHookDelegate>( Marshal.ReadIntPtr( VTable, 128) ); _SetWarningMessageHook = Marshal.GetDelegateForFunctionPointer<FSetWarningMessageHook>( Marshal.ReadIntPtr( VTable, 128) );
IsOverlayEnabledDelegatePointer = Marshal.GetDelegateForFunctionPointer<IsOverlayEnabledDelegate>( Marshal.ReadIntPtr( VTable, 136) ); _IsOverlayEnabled = Marshal.GetDelegateForFunctionPointer<FIsOverlayEnabled>( Marshal.ReadIntPtr( VTable, 136) );
BOverlayNeedsPresentDelegatePointer = Marshal.GetDelegateForFunctionPointer<BOverlayNeedsPresentDelegate>( Marshal.ReadIntPtr( VTable, 144) ); _BOverlayNeedsPresent = Marshal.GetDelegateForFunctionPointer<FBOverlayNeedsPresent>( Marshal.ReadIntPtr( VTable, 144) );
CheckFileSignatureDelegatePointer = Marshal.GetDelegateForFunctionPointer<CheckFileSignatureDelegate>( Marshal.ReadIntPtr( VTable, 152) ); _CheckFileSignature = Marshal.GetDelegateForFunctionPointer<FCheckFileSignature>( Marshal.ReadIntPtr( VTable, 152) );
ShowGamepadTextInputDelegatePointer = Marshal.GetDelegateForFunctionPointer<ShowGamepadTextInputDelegate>( Marshal.ReadIntPtr( VTable, 160) ); _ShowGamepadTextInput = Marshal.GetDelegateForFunctionPointer<FShowGamepadTextInput>( Marshal.ReadIntPtr( VTable, 160) );
GetEnteredGamepadTextLengthDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetEnteredGamepadTextLengthDelegate>( Marshal.ReadIntPtr( VTable, 168) ); _GetEnteredGamepadTextLength = Marshal.GetDelegateForFunctionPointer<FGetEnteredGamepadTextLength>( Marshal.ReadIntPtr( VTable, 168) );
GetEnteredGamepadTextInputDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetEnteredGamepadTextInputDelegate>( Marshal.ReadIntPtr( VTable, 176) ); _GetEnteredGamepadTextInput = Marshal.GetDelegateForFunctionPointer<FGetEnteredGamepadTextInput>( Marshal.ReadIntPtr( VTable, 176) );
GetSteamUILanguageDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetSteamUILanguageDelegate>( Marshal.ReadIntPtr( VTable, 184) ); _GetSteamUILanguage = Marshal.GetDelegateForFunctionPointer<FGetSteamUILanguage>( Marshal.ReadIntPtr( VTable, 184) );
IsSteamRunningInVRDelegatePointer = Marshal.GetDelegateForFunctionPointer<IsSteamRunningInVRDelegate>( Marshal.ReadIntPtr( VTable, 192) ); _IsSteamRunningInVR = Marshal.GetDelegateForFunctionPointer<FIsSteamRunningInVR>( Marshal.ReadIntPtr( VTable, 192) );
SetOverlayNotificationInsetDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetOverlayNotificationInsetDelegate>( Marshal.ReadIntPtr( VTable, 200) ); _SetOverlayNotificationInset = Marshal.GetDelegateForFunctionPointer<FSetOverlayNotificationInset>( Marshal.ReadIntPtr( VTable, 200) );
IsSteamInBigPictureModeDelegatePointer = Marshal.GetDelegateForFunctionPointer<IsSteamInBigPictureModeDelegate>( Marshal.ReadIntPtr( VTable, 208) ); _IsSteamInBigPictureMode = Marshal.GetDelegateForFunctionPointer<FIsSteamInBigPictureMode>( Marshal.ReadIntPtr( VTable, 208) );
StartVRDashboardDelegatePointer = Marshal.GetDelegateForFunctionPointer<StartVRDashboardDelegate>( Marshal.ReadIntPtr( VTable, 216) ); _StartVRDashboard = Marshal.GetDelegateForFunctionPointer<FStartVRDashboard>( Marshal.ReadIntPtr( VTable, 216) );
IsVRHeadsetStreamingEnabledDelegatePointer = Marshal.GetDelegateForFunctionPointer<IsVRHeadsetStreamingEnabledDelegate>( Marshal.ReadIntPtr( VTable, 224) ); _IsVRHeadsetStreamingEnabled = Marshal.GetDelegateForFunctionPointer<FIsVRHeadsetStreamingEnabled>( Marshal.ReadIntPtr( VTable, 224) );
SetVRHeadsetStreamingEnabledDelegatePointer = Marshal.GetDelegateForFunctionPointer<SetVRHeadsetStreamingEnabledDelegate>( Marshal.ReadIntPtr( VTable, 232) ); _SetVRHeadsetStreamingEnabled = Marshal.GetDelegateForFunctionPointer<FSetVRHeadsetStreamingEnabled>( Marshal.ReadIntPtr( VTable, 232) );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate uint GetSecondsSinceAppActiveDelegate( IntPtr self ); private delegate uint FGetSecondsSinceAppActive( IntPtr self );
private GetSecondsSinceAppActiveDelegate GetSecondsSinceAppActiveDelegatePointer; private FGetSecondsSinceAppActive _GetSecondsSinceAppActive;
#endregion #endregion
internal uint GetSecondsSinceAppActive() internal uint GetSecondsSinceAppActive()
{ {
return GetSecondsSinceAppActiveDelegatePointer( Self ); return _GetSecondsSinceAppActive( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate uint GetSecondsSinceComputerActiveDelegate( IntPtr self ); private delegate uint FGetSecondsSinceComputerActive( IntPtr self );
private GetSecondsSinceComputerActiveDelegate GetSecondsSinceComputerActiveDelegatePointer; private FGetSecondsSinceComputerActive _GetSecondsSinceComputerActive;
#endregion #endregion
internal uint GetSecondsSinceComputerActive() internal uint GetSecondsSinceComputerActive()
{ {
return GetSecondsSinceComputerActiveDelegatePointer( Self ); return _GetSecondsSinceComputerActive( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate Universe GetConnectedUniverseDelegate( IntPtr self ); private delegate Universe FGetConnectedUniverse( IntPtr self );
private GetConnectedUniverseDelegate GetConnectedUniverseDelegatePointer; private FGetConnectedUniverse _GetConnectedUniverse;
#endregion #endregion
internal Universe GetConnectedUniverse() internal Universe GetConnectedUniverse()
{ {
return GetConnectedUniverseDelegatePointer( Self ); return _GetConnectedUniverse( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate uint GetServerRealTimeDelegate( IntPtr self ); private delegate uint FGetServerRealTime( IntPtr self );
private GetServerRealTimeDelegate GetServerRealTimeDelegatePointer; private FGetServerRealTime _GetServerRealTime;
#endregion #endregion
internal uint GetServerRealTime() internal uint GetServerRealTime()
{ {
return GetServerRealTimeDelegatePointer( Self ); return _GetServerRealTime( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate IntPtr GetIPCountryDelegate( IntPtr self ); private delegate IntPtr FGetIPCountry( IntPtr self );
private GetIPCountryDelegate GetIPCountryDelegatePointer; private FGetIPCountry _GetIPCountry;
#endregion #endregion
internal string GetIPCountry() internal string GetIPCountry()
{ {
return GetString( GetIPCountryDelegatePointer( Self ) ); return GetString( _GetIPCountry( Self ) );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool GetImageSizeDelegate( IntPtr self, int iImage, ref uint pnWidth, ref uint pnHeight ); private delegate bool FGetImageSize( IntPtr self, int iImage, ref uint pnWidth, ref uint pnHeight );
private GetImageSizeDelegate GetImageSizeDelegatePointer; private FGetImageSize _GetImageSize;
#endregion #endregion
internal bool GetImageSize( int iImage, ref uint pnWidth, ref uint pnHeight ) internal bool GetImageSize( int iImage, ref uint pnWidth, ref uint pnHeight )
{ {
return GetImageSizeDelegatePointer( Self, iImage, ref pnWidth, ref pnHeight ); return _GetImageSize( Self, iImage, ref pnWidth, ref pnHeight );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool GetImageRGBADelegate( IntPtr self, int iImage, [In,Out] byte[] pubDest, int nDestBufferSize ); private delegate bool FGetImageRGBA( IntPtr self, int iImage, [In,Out] byte[] pubDest, int nDestBufferSize );
private GetImageRGBADelegate GetImageRGBADelegatePointer; private FGetImageRGBA _GetImageRGBA;
#endregion #endregion
internal bool GetImageRGBA( int iImage, [In,Out] byte[] pubDest, int nDestBufferSize ) internal bool GetImageRGBA( int iImage, [In,Out] byte[] pubDest, int nDestBufferSize )
{ {
return GetImageRGBADelegatePointer( Self, iImage, pubDest, nDestBufferSize ); return _GetImageRGBA( Self, iImage, pubDest, nDestBufferSize );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool GetCSERIPPortDelegate( IntPtr self, ref uint unIP, ref ushort usPort ); private delegate bool FGetCSERIPPort( IntPtr self, ref uint unIP, ref ushort usPort );
private GetCSERIPPortDelegate GetCSERIPPortDelegatePointer; private FGetCSERIPPort _GetCSERIPPort;
#endregion #endregion
internal bool GetCSERIPPort( ref uint unIP, ref ushort usPort ) internal bool GetCSERIPPort( ref uint unIP, ref ushort usPort )
{ {
return GetCSERIPPortDelegatePointer( Self, ref unIP, ref usPort ); return _GetCSERIPPort( Self, ref unIP, ref usPort );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate byte GetCurrentBatteryPowerDelegate( IntPtr self ); private delegate byte FGetCurrentBatteryPower( IntPtr self );
private GetCurrentBatteryPowerDelegate GetCurrentBatteryPowerDelegatePointer; private FGetCurrentBatteryPower _GetCurrentBatteryPower;
#endregion #endregion
internal byte GetCurrentBatteryPower() internal byte GetCurrentBatteryPower()
{ {
return GetCurrentBatteryPowerDelegatePointer( Self ); return _GetCurrentBatteryPower( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate uint GetAppIDDelegate( IntPtr self ); private delegate uint FGetAppID( IntPtr self );
private GetAppIDDelegate GetAppIDDelegatePointer; private FGetAppID _GetAppID;
#endregion #endregion
internal uint GetAppID() internal uint GetAppID()
{ {
return GetAppIDDelegatePointer( Self ); return _GetAppID( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void SetOverlayNotificationPositionDelegate( IntPtr self, NotificationPosition eNotificationPosition ); private delegate void FSetOverlayNotificationPosition( IntPtr self, NotificationPosition eNotificationPosition );
private SetOverlayNotificationPositionDelegate SetOverlayNotificationPositionDelegatePointer; private FSetOverlayNotificationPosition _SetOverlayNotificationPosition;
#endregion #endregion
internal void SetOverlayNotificationPosition( NotificationPosition eNotificationPosition ) internal void SetOverlayNotificationPosition( NotificationPosition eNotificationPosition )
{ {
SetOverlayNotificationPositionDelegatePointer( Self, eNotificationPosition ); _SetOverlayNotificationPosition( Self, eNotificationPosition );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool IsAPICallCompletedDelegate( IntPtr self, SteamAPICall_t hSteamAPICall, [MarshalAs( UnmanagedType.U1 )] ref bool pbFailed ); private delegate bool FIsAPICallCompleted( IntPtr self, SteamAPICall_t hSteamAPICall, [MarshalAs( UnmanagedType.U1 )] ref bool pbFailed );
private IsAPICallCompletedDelegate IsAPICallCompletedDelegatePointer; private FIsAPICallCompleted _IsAPICallCompleted;
#endregion #endregion
internal bool IsAPICallCompleted( SteamAPICall_t hSteamAPICall, [MarshalAs( UnmanagedType.U1 )] ref bool pbFailed ) internal bool IsAPICallCompleted( SteamAPICall_t hSteamAPICall, [MarshalAs( UnmanagedType.U1 )] ref bool pbFailed )
{ {
return IsAPICallCompletedDelegatePointer( Self, hSteamAPICall, ref pbFailed ); return _IsAPICallCompleted( Self, hSteamAPICall, ref pbFailed );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate SteamAPICallFailure GetAPICallFailureReasonDelegate( IntPtr self, SteamAPICall_t hSteamAPICall ); private delegate SteamAPICallFailure FGetAPICallFailureReason( IntPtr self, SteamAPICall_t hSteamAPICall );
private GetAPICallFailureReasonDelegate GetAPICallFailureReasonDelegatePointer; private FGetAPICallFailureReason _GetAPICallFailureReason;
#endregion #endregion
internal SteamAPICallFailure GetAPICallFailureReason( SteamAPICall_t hSteamAPICall ) internal SteamAPICallFailure GetAPICallFailureReason( SteamAPICall_t hSteamAPICall )
{ {
return GetAPICallFailureReasonDelegatePointer( Self, hSteamAPICall ); return _GetAPICallFailureReason( Self, hSteamAPICall );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool GetAPICallResultDelegate( IntPtr self, SteamAPICall_t hSteamAPICall, IntPtr pCallback, int cubCallback, int iCallbackExpected, [MarshalAs( UnmanagedType.U1 )] ref bool pbFailed ); private delegate bool FGetAPICallResult( IntPtr self, SteamAPICall_t hSteamAPICall, IntPtr pCallback, int cubCallback, int iCallbackExpected, [MarshalAs( UnmanagedType.U1 )] ref bool pbFailed );
private GetAPICallResultDelegate GetAPICallResultDelegatePointer; private FGetAPICallResult _GetAPICallResult;
#endregion #endregion
internal bool GetAPICallResult( SteamAPICall_t hSteamAPICall, IntPtr pCallback, int cubCallback, int iCallbackExpected, [MarshalAs( UnmanagedType.U1 )] ref bool pbFailed ) internal bool GetAPICallResult( SteamAPICall_t hSteamAPICall, IntPtr pCallback, int cubCallback, int iCallbackExpected, [MarshalAs( UnmanagedType.U1 )] ref bool pbFailed )
{ {
return GetAPICallResultDelegatePointer( Self, hSteamAPICall, pCallback, cubCallback, iCallbackExpected, ref pbFailed ); return _GetAPICallResult( Self, hSteamAPICall, pCallback, cubCallback, iCallbackExpected, ref pbFailed );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void RunFrameDelegate( IntPtr self ); private delegate void FRunFrame( IntPtr self );
private RunFrameDelegate RunFrameDelegatePointer; private FRunFrame _RunFrame;
#endregion #endregion
internal void RunFrame() internal void RunFrame()
{ {
RunFrameDelegatePointer( Self ); _RunFrame( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate uint GetIPCCallCountDelegate( IntPtr self ); private delegate uint FGetIPCCallCount( IntPtr self );
private GetIPCCallCountDelegate GetIPCCallCountDelegatePointer; private FGetIPCCallCount _GetIPCCallCount;
#endregion #endregion
internal uint GetIPCCallCount() internal uint GetIPCCallCount()
{ {
return GetIPCCallCountDelegatePointer( Self ); return _GetIPCCallCount( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void SetWarningMessageHookDelegate( IntPtr self, IntPtr pFunction ); private delegate void FSetWarningMessageHook( IntPtr self, IntPtr pFunction );
private SetWarningMessageHookDelegate SetWarningMessageHookDelegatePointer; private FSetWarningMessageHook _SetWarningMessageHook;
#endregion #endregion
internal void SetWarningMessageHook( IntPtr pFunction ) internal void SetWarningMessageHook( IntPtr pFunction )
{ {
SetWarningMessageHookDelegatePointer( Self, pFunction ); _SetWarningMessageHook( Self, pFunction );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool IsOverlayEnabledDelegate( IntPtr self ); private delegate bool FIsOverlayEnabled( IntPtr self );
private IsOverlayEnabledDelegate IsOverlayEnabledDelegatePointer; private FIsOverlayEnabled _IsOverlayEnabled;
#endregion #endregion
internal bool IsOverlayEnabled() internal bool IsOverlayEnabled()
{ {
return IsOverlayEnabledDelegatePointer( Self ); return _IsOverlayEnabled( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool BOverlayNeedsPresentDelegate( IntPtr self ); private delegate bool FBOverlayNeedsPresent( IntPtr self );
private BOverlayNeedsPresentDelegate BOverlayNeedsPresentDelegatePointer; private FBOverlayNeedsPresent _BOverlayNeedsPresent;
#endregion #endregion
internal bool BOverlayNeedsPresent() internal bool BOverlayNeedsPresent()
{ {
return BOverlayNeedsPresentDelegatePointer( Self ); return _BOverlayNeedsPresent( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate SteamAPICall_t CheckFileSignatureDelegate( IntPtr self, string szFileName ); private delegate SteamAPICall_t FCheckFileSignature( IntPtr self, string szFileName );
private CheckFileSignatureDelegate CheckFileSignatureDelegatePointer; private FCheckFileSignature _CheckFileSignature;
#endregion #endregion
internal async Task<CheckFileSignature_t?> CheckFileSignature( string szFileName ) internal async Task<CheckFileSignature_t?> CheckFileSignature( string szFileName )
{ {
return await (new Result<CheckFileSignature_t>( CheckFileSignatureDelegatePointer( Self, szFileName ) )).GetResult(); return await (new Result<CheckFileSignature_t>( _CheckFileSignature( Self, szFileName ) )).GetResult();
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool ShowGamepadTextInputDelegate( IntPtr self, GamepadTextInputMode eInputMode, GamepadTextInputLineMode eLineInputMode, string pchDescription, uint unCharMax, string pchExistingText ); private delegate bool FShowGamepadTextInput( IntPtr self, GamepadTextInputMode eInputMode, GamepadTextInputLineMode eLineInputMode, string pchDescription, uint unCharMax, string pchExistingText );
private ShowGamepadTextInputDelegate ShowGamepadTextInputDelegatePointer; private FShowGamepadTextInput _ShowGamepadTextInput;
#endregion #endregion
internal bool ShowGamepadTextInput( GamepadTextInputMode eInputMode, GamepadTextInputLineMode eLineInputMode, string pchDescription, uint unCharMax, string pchExistingText ) internal bool ShowGamepadTextInput( GamepadTextInputMode eInputMode, GamepadTextInputLineMode eLineInputMode, string pchDescription, uint unCharMax, string pchExistingText )
{ {
return ShowGamepadTextInputDelegatePointer( Self, eInputMode, eLineInputMode, pchDescription, unCharMax, pchExistingText ); return _ShowGamepadTextInput( Self, eInputMode, eLineInputMode, pchDescription, unCharMax, pchExistingText );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate uint GetEnteredGamepadTextLengthDelegate( IntPtr self ); private delegate uint FGetEnteredGamepadTextLength( IntPtr self );
private GetEnteredGamepadTextLengthDelegate GetEnteredGamepadTextLengthDelegatePointer; private FGetEnteredGamepadTextLength _GetEnteredGamepadTextLength;
#endregion #endregion
internal uint GetEnteredGamepadTextLength() internal uint GetEnteredGamepadTextLength()
{ {
return GetEnteredGamepadTextLengthDelegatePointer( Self ); return _GetEnteredGamepadTextLength( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool GetEnteredGamepadTextInputDelegate( IntPtr self, StringBuilder pchText, uint cchText ); private delegate bool FGetEnteredGamepadTextInput( IntPtr self, StringBuilder pchText, uint cchText );
private GetEnteredGamepadTextInputDelegate GetEnteredGamepadTextInputDelegatePointer; private FGetEnteredGamepadTextInput _GetEnteredGamepadTextInput;
#endregion #endregion
internal bool GetEnteredGamepadTextInput( StringBuilder pchText, uint cchText ) internal bool GetEnteredGamepadTextInput( StringBuilder pchText, uint cchText )
{ {
return GetEnteredGamepadTextInputDelegatePointer( Self, pchText, cchText ); return _GetEnteredGamepadTextInput( Self, pchText, cchText );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate IntPtr GetSteamUILanguageDelegate( IntPtr self ); private delegate IntPtr FGetSteamUILanguage( IntPtr self );
private GetSteamUILanguageDelegate GetSteamUILanguageDelegatePointer; private FGetSteamUILanguage _GetSteamUILanguage;
#endregion #endregion
internal string GetSteamUILanguage() internal string GetSteamUILanguage()
{ {
return GetString( GetSteamUILanguageDelegatePointer( Self ) ); return GetString( _GetSteamUILanguage( Self ) );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool IsSteamRunningInVRDelegate( IntPtr self ); private delegate bool FIsSteamRunningInVR( IntPtr self );
private IsSteamRunningInVRDelegate IsSteamRunningInVRDelegatePointer; private FIsSteamRunningInVR _IsSteamRunningInVR;
#endregion #endregion
internal bool IsSteamRunningInVR() internal bool IsSteamRunningInVR()
{ {
return IsSteamRunningInVRDelegatePointer( Self ); return _IsSteamRunningInVR( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void SetOverlayNotificationInsetDelegate( IntPtr self, int nHorizontalInset, int nVerticalInset ); private delegate void FSetOverlayNotificationInset( IntPtr self, int nHorizontalInset, int nVerticalInset );
private SetOverlayNotificationInsetDelegate SetOverlayNotificationInsetDelegatePointer; private FSetOverlayNotificationInset _SetOverlayNotificationInset;
#endregion #endregion
internal void SetOverlayNotificationInset( int nHorizontalInset, int nVerticalInset ) internal void SetOverlayNotificationInset( int nHorizontalInset, int nVerticalInset )
{ {
SetOverlayNotificationInsetDelegatePointer( Self, nHorizontalInset, nVerticalInset ); _SetOverlayNotificationInset( Self, nHorizontalInset, nVerticalInset );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool IsSteamInBigPictureModeDelegate( IntPtr self ); private delegate bool FIsSteamInBigPictureMode( IntPtr self );
private IsSteamInBigPictureModeDelegate IsSteamInBigPictureModeDelegatePointer; private FIsSteamInBigPictureMode _IsSteamInBigPictureMode;
#endregion #endregion
internal bool IsSteamInBigPictureMode() internal bool IsSteamInBigPictureMode()
{ {
return IsSteamInBigPictureModeDelegatePointer( Self ); return _IsSteamInBigPictureMode( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void StartVRDashboardDelegate( IntPtr self ); private delegate void FStartVRDashboard( IntPtr self );
private StartVRDashboardDelegate StartVRDashboardDelegatePointer; private FStartVRDashboard _StartVRDashboard;
#endregion #endregion
internal void StartVRDashboard() internal void StartVRDashboard()
{ {
StartVRDashboardDelegatePointer( Self ); _StartVRDashboard( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool IsVRHeadsetStreamingEnabledDelegate( IntPtr self ); private delegate bool FIsVRHeadsetStreamingEnabled( IntPtr self );
private IsVRHeadsetStreamingEnabledDelegate IsVRHeadsetStreamingEnabledDelegatePointer; private FIsVRHeadsetStreamingEnabled _IsVRHeadsetStreamingEnabled;
#endregion #endregion
internal bool IsVRHeadsetStreamingEnabled() internal bool IsVRHeadsetStreamingEnabled()
{ {
return IsVRHeadsetStreamingEnabledDelegatePointer( Self ); return _IsVRHeadsetStreamingEnabled( Self );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void SetVRHeadsetStreamingEnabledDelegate( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bEnabled ); private delegate void FSetVRHeadsetStreamingEnabled( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bEnabled );
private SetVRHeadsetStreamingEnabledDelegate SetVRHeadsetStreamingEnabledDelegatePointer; private FSetVRHeadsetStreamingEnabled _SetVRHeadsetStreamingEnabled;
#endregion #endregion
internal void SetVRHeadsetStreamingEnabled( [MarshalAs( UnmanagedType.U1 )] bool bEnabled ) internal void SetVRHeadsetStreamingEnabled( [MarshalAs( UnmanagedType.U1 )] bool bEnabled )
{ {
SetVRHeadsetStreamingEnabledDelegatePointer( Self, bEnabled ); _SetVRHeadsetStreamingEnabled( Self, bEnabled );
} }
} }

32
Facepunch.Steamworks/Generated/Interfaces/ISteamVideo.cs
View File

@ -17,56 +17,56 @@ namespace Steamworks
public override void InitInternals() public override void InitInternals()
{ {
GetVideoURLDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetVideoURLDelegate>( Marshal.ReadIntPtr( VTable, 0) ); _GetVideoURL = Marshal.GetDelegateForFunctionPointer<FGetVideoURL>( Marshal.ReadIntPtr( VTable, 0) );
IsBroadcastingDelegatePointer = Marshal.GetDelegateForFunctionPointer<IsBroadcastingDelegate>( Marshal.ReadIntPtr( VTable, 8) ); _IsBroadcasting = Marshal.GetDelegateForFunctionPointer<FIsBroadcasting>( Marshal.ReadIntPtr( VTable, 8) );
GetOPFSettingsDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetOPFSettingsDelegate>( Marshal.ReadIntPtr( VTable, 16) ); _GetOPFSettings = Marshal.GetDelegateForFunctionPointer<FGetOPFSettings>( Marshal.ReadIntPtr( VTable, 16) );
GetOPFStringForAppDelegatePointer = Marshal.GetDelegateForFunctionPointer<GetOPFStringForAppDelegate>( Marshal.ReadIntPtr( VTable, 24) ); _GetOPFStringForApp = Marshal.GetDelegateForFunctionPointer<FGetOPFStringForApp>( Marshal.ReadIntPtr( VTable, 24) );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void GetVideoURLDelegate( IntPtr self, AppId_t unVideoAppID ); private delegate void FGetVideoURL( IntPtr self, AppId_t unVideoAppID );
private GetVideoURLDelegate GetVideoURLDelegatePointer; private FGetVideoURL _GetVideoURL;
#endregion #endregion
internal void GetVideoURL( AppId_t unVideoAppID ) internal void GetVideoURL( AppId_t unVideoAppID )
{ {
GetVideoURLDelegatePointer( Self, unVideoAppID ); _GetVideoURL( Self, unVideoAppID );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool IsBroadcastingDelegate( IntPtr self, ref int pnNumViewers ); private delegate bool FIsBroadcasting( IntPtr self, ref int pnNumViewers );
private IsBroadcastingDelegate IsBroadcastingDelegatePointer; private FIsBroadcasting _IsBroadcasting;
#endregion #endregion
internal bool IsBroadcasting( ref int pnNumViewers ) internal bool IsBroadcasting( ref int pnNumViewers )
{ {
return IsBroadcastingDelegatePointer( Self, ref pnNumViewers ); return _IsBroadcasting( Self, ref pnNumViewers );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
private delegate void GetOPFSettingsDelegate( IntPtr self, AppId_t unVideoAppID ); private delegate void FGetOPFSettings( IntPtr self, AppId_t unVideoAppID );
private GetOPFSettingsDelegate GetOPFSettingsDelegatePointer; private FGetOPFSettings _GetOPFSettings;
#endregion #endregion
internal void GetOPFSettings( AppId_t unVideoAppID ) internal void GetOPFSettings( AppId_t unVideoAppID )
{ {
GetOPFSettingsDelegatePointer( Self, unVideoAppID ); _GetOPFSettings( Self, unVideoAppID );
} }
#region FunctionMeta #region FunctionMeta
[UnmanagedFunctionPointer( CallingConvention.ThisCall )] [UnmanagedFunctionPointer( CallingConvention.ThisCall )]
[return: MarshalAs( UnmanagedType.I1 )] [return: MarshalAs( UnmanagedType.I1 )]
private delegate bool GetOPFStringForAppDelegate( IntPtr self, AppId_t unVideoAppID, StringBuilder pchBuffer, ref int pnBufferSize ); private delegate bool FGetOPFStringForApp( IntPtr self, AppId_t unVideoAppID, StringBuilder pchBuffer, ref int pnBufferSize );
private GetOPFStringForAppDelegate GetOPFStringForAppDelegatePointer; private FGetOPFStringForApp _GetOPFStringForApp;
#endregion #endregion
internal bool GetOPFStringForApp( AppId_t unVideoAppID, StringBuilder pchBuffer, ref int pnBufferSize ) internal bool GetOPFStringForApp( AppId_t unVideoAppID, StringBuilder pchBuffer, ref int pnBufferSize )
{ {
return GetOPFStringForAppDelegatePointer( Self, unVideoAppID, pchBuffer, ref pnBufferSize ); return _GetOPFStringForApp( Self, unVideoAppID, pchBuffer, ref pnBufferSize );
} }
} }

12
Generator/CodeWriter/ClassVTable.cs
View File

@ -62,7 +62,7 @@ namespace Generator
for (int i=0; i< clss.Functions.Count; i++ ) for (int i=0; i< clss.Functions.Count; i++ )
{ {
var func = clss.Functions[i]; var func = clss.Functions[i];
WriteLine( $"{func.Name}DelegatePointer = Marshal.GetDelegateForFunctionPointer<{func.Name}Delegate>( Marshal.ReadIntPtr( VTable, {i*8}) );" ); WriteLine( $"_{func.Name} = Marshal.GetDelegateForFunctionPointer<F{func.Name}>( Marshal.ReadIntPtr( VTable, {i*8}) );" );
} }
} }
EndBlock(); EndBlock();
@ -100,8 +100,8 @@ namespace Generator
if ( returnType.ReturnAttribute != null) if ( returnType.ReturnAttribute != null)
WriteLine( returnType.ReturnAttribute ); WriteLine( returnType.ReturnAttribute );
WriteLine( $"private delegate {(returnType.IsReturnedWeird?"void":returnType.TypeNameFrom)} {func.Name}Delegate( IntPtr self, {delegateargstr} );".Replace( "( IntPtr self, )", "( IntPtr self )" ) ); WriteLine( $"private delegate {(returnType.IsReturnedWeird?"void":returnType.TypeNameFrom)} F{func.Name}( IntPtr self, {delegateargstr} );".Replace( "( IntPtr self, )", "( IntPtr self )" ) );
WriteLine( $"private {func.Name}Delegate {func.Name}DelegatePointer;" ); WriteLine( $"private F{func.Name} _{func.Name};" );
WriteLine(); WriteLine();
WriteLine( $"#endregion" ); WriteLine( $"#endregion" );
@ -112,16 +112,16 @@ namespace Generator
if ( returnType.IsReturnedWeird ) if ( returnType.IsReturnedWeird )
{ {
WriteLine( $"var retVal = default( {returnType.TypeName} );" ); WriteLine( $"var retVal = default( {returnType.TypeName} );" );
WriteLine( $"{func.Name}DelegatePointer( Self, ref retVal, {callargs} );".Replace( ", );", " );" ) ); WriteLine( $"_{func.Name}( Self, ref retVal, {callargs} );".Replace( ", );", " );" ) );
WriteLine( $"{returnType.Return( "retVal" )}" ); WriteLine( $"{returnType.Return( "retVal" )}" );
} }
else if ( returnType.IsVoid ) else if ( returnType.IsVoid )
{ {
WriteLine( $"{func.Name}DelegatePointer( Self, {callargs} );".Replace( "( Self, )", "( Self )" ) ); WriteLine( $"_{func.Name}( Self, {callargs} );".Replace( "( Self, )", "( Self )" ) );
} }
else else
{ {
var v = $"{func.Name}DelegatePointer( Self, {callargs} )".Replace( "( Self, )", "( Self )" ); var v = $"_{func.Name}( Self, {callargs} )".Replace( "( Self, )", "( Self )" );
WriteLine( returnType.Return( v ) ); WriteLine( returnType.Return( v ) );
} }