diff --git a/Facepunch.Steamworks/Generated/Interfaces/ISteamAppList.cs b/Facepunch.Steamworks/Generated/Interfaces/ISteamAppList.cs new file mode 100644 index 0000000..e9661c3 --- /dev/null +++ b/Facepunch.Steamworks/Generated/Interfaces/ISteamAppList.cs @@ -0,0 +1,80 @@ +using System; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading.Tasks; +using Steamworks.Data; + + +namespace Steamworks +{ + internal class ISteamAppList : SteamInterface + { + public override IntPtr GetInterfacePointer() => GetApi.SteamAppList(); + + + internal ISteamAppList() + { + SetupInterface(); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamAppList_GetNumInstalledApps")] + private static extern uint _GetNumInstalledApps( IntPtr self ); + + #endregion + internal uint GetNumInstalledApps() + { + var returnValue = _GetNumInstalledApps( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamAppList_GetInstalledApps")] + private static extern uint _GetInstalledApps( IntPtr self, [In,Out] AppId[] pvecAppID, uint unMaxAppIDs ); + + #endregion + internal uint GetInstalledApps( [In,Out] AppId[] pvecAppID, uint unMaxAppIDs ) + { + var returnValue = _GetInstalledApps( Self, pvecAppID, unMaxAppIDs ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamAppList_GetAppName")] + private static extern int _GetAppName( IntPtr self, AppId nAppID, IntPtr pchName, int cchNameMax ); + + #endregion + internal int GetAppName( AppId nAppID, out string pchName ) + { + IntPtr mempchName = Helpers.TakeMemory(); + var returnValue = _GetAppName( Self, nAppID, mempchName, (1024 * 32) ); + pchName = Helpers.MemoryToString( mempchName ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamAppList_GetAppInstallDir")] + private static extern int _GetAppInstallDir( IntPtr self, AppId nAppID, IntPtr pchDirectory, int cchNameMax ); + + #endregion + internal int GetAppInstallDir( AppId nAppID, out string pchDirectory ) + { + IntPtr mempchDirectory = Helpers.TakeMemory(); + var returnValue = _GetAppInstallDir( Self, nAppID, mempchDirectory, (1024 * 32) ); + pchDirectory = Helpers.MemoryToString( mempchDirectory ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamAppList_GetAppBuildId")] + private static extern int _GetAppBuildId( IntPtr self, AppId nAppID ); + + #endregion + internal int GetAppBuildId( AppId nAppID ) + { + var returnValue = _GetAppBuildId( Self, nAppID ); + return returnValue; + } + + } +} diff --git a/Facepunch.Steamworks/Generated/Interfaces/ISteamClient.cs b/Facepunch.Steamworks/Generated/Interfaces/ISteamClient.cs new file mode 100644 index 0000000..82b21a4 --- /dev/null +++ b/Facepunch.Steamworks/Generated/Interfaces/ISteamClient.cs @@ -0,0 +1,416 @@ +using System; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading.Tasks; +using Steamworks.Data; + + +namespace Steamworks +{ + internal class ISteamClient : SteamInterface + { + public override IntPtr GetInterfacePointer() => GetApi.SteamClient(); + + + internal ISteamClient() + { + SetupInterface(); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_CreateSteamPipe")] + private static extern HSteamPipe _CreateSteamPipe( IntPtr self ); + + #endregion + internal HSteamPipe CreateSteamPipe() + { + var returnValue = _CreateSteamPipe( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_BReleaseSteamPipe")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _BReleaseSteamPipe( IntPtr self, HSteamPipe hSteamPipe ); + + #endregion + internal bool BReleaseSteamPipe( HSteamPipe hSteamPipe ) + { + var returnValue = _BReleaseSteamPipe( Self, hSteamPipe ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_ConnectToGlobalUser")] + private static extern HSteamUser _ConnectToGlobalUser( IntPtr self, HSteamPipe hSteamPipe ); + + #endregion + internal HSteamUser ConnectToGlobalUser( HSteamPipe hSteamPipe ) + { + var returnValue = _ConnectToGlobalUser( Self, hSteamPipe ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_CreateLocalUser")] + private static extern HSteamUser _CreateLocalUser( IntPtr self, ref HSteamPipe phSteamPipe, AccountType eAccountType ); + + #endregion + internal HSteamUser CreateLocalUser( ref HSteamPipe phSteamPipe, AccountType eAccountType ) + { + var returnValue = _CreateLocalUser( Self, ref phSteamPipe, eAccountType ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_ReleaseUser")] + private static extern void _ReleaseUser( IntPtr self, HSteamPipe hSteamPipe, HSteamUser hUser ); + + #endregion + internal void ReleaseUser( HSteamPipe hSteamPipe, HSteamUser hUser ) + { + _ReleaseUser( Self, hSteamPipe, hUser ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamUser")] + private static extern IntPtr _GetISteamUser( IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ); + + #endregion + internal IntPtr GetISteamUser( HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ) + { + var returnValue = _GetISteamUser( Self, hSteamUser, hSteamPipe, pchVersion ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamGameServer")] + private static extern IntPtr _GetISteamGameServer( IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ); + + #endregion + internal IntPtr GetISteamGameServer( HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ) + { + var returnValue = _GetISteamGameServer( Self, hSteamUser, hSteamPipe, pchVersion ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_SetLocalIPBinding")] + private static extern void _SetLocalIPBinding( IntPtr self, ref SteamIPAddress_t unIP, ushort usPort ); + + #endregion + internal void SetLocalIPBinding( ref SteamIPAddress_t unIP, ushort usPort ) + { + _SetLocalIPBinding( Self, ref unIP, usPort ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamFriends")] + private static extern IntPtr _GetISteamFriends( IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ); + + #endregion + internal IntPtr GetISteamFriends( HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ) + { + var returnValue = _GetISteamFriends( Self, hSteamUser, hSteamPipe, pchVersion ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamUtils")] + private static extern IntPtr _GetISteamUtils( IntPtr self, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ); + + #endregion + internal IntPtr GetISteamUtils( HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ) + { + var returnValue = _GetISteamUtils( Self, hSteamPipe, pchVersion ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamMatchmaking")] + private static extern IntPtr _GetISteamMatchmaking( IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ); + + #endregion + internal IntPtr GetISteamMatchmaking( HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ) + { + var returnValue = _GetISteamMatchmaking( Self, hSteamUser, hSteamPipe, pchVersion ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamMatchmakingServers")] + private static extern IntPtr _GetISteamMatchmakingServers( IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ); + + #endregion + internal IntPtr GetISteamMatchmakingServers( HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ) + { + var returnValue = _GetISteamMatchmakingServers( Self, hSteamUser, hSteamPipe, pchVersion ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamGenericInterface")] + private static extern IntPtr _GetISteamGenericInterface( IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ); + + #endregion + internal IntPtr GetISteamGenericInterface( HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ) + { + var returnValue = _GetISteamGenericInterface( Self, hSteamUser, hSteamPipe, pchVersion ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamUserStats")] + private static extern IntPtr _GetISteamUserStats( IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ); + + #endregion + internal IntPtr GetISteamUserStats( HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ) + { + var returnValue = _GetISteamUserStats( Self, hSteamUser, hSteamPipe, pchVersion ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamGameServerStats")] + private static extern IntPtr _GetISteamGameServerStats( IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ); + + #endregion + internal IntPtr GetISteamGameServerStats( HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ) + { + var returnValue = _GetISteamGameServerStats( Self, hSteamuser, hSteamPipe, pchVersion ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamApps")] + private static extern IntPtr _GetISteamApps( IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ); + + #endregion + internal IntPtr GetISteamApps( HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ) + { + var returnValue = _GetISteamApps( Self, hSteamUser, hSteamPipe, pchVersion ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamNetworking")] + private static extern IntPtr _GetISteamNetworking( IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ); + + #endregion + internal IntPtr GetISteamNetworking( HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ) + { + var returnValue = _GetISteamNetworking( Self, hSteamUser, hSteamPipe, pchVersion ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamRemoteStorage")] + private static extern IntPtr _GetISteamRemoteStorage( IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ); + + #endregion + internal IntPtr GetISteamRemoteStorage( HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ) + { + var returnValue = _GetISteamRemoteStorage( Self, hSteamuser, hSteamPipe, pchVersion ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamScreenshots")] + private static extern IntPtr _GetISteamScreenshots( IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ); + + #endregion + internal IntPtr GetISteamScreenshots( HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ) + { + var returnValue = _GetISteamScreenshots( Self, hSteamuser, hSteamPipe, pchVersion ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamGameSearch")] + private static extern IntPtr _GetISteamGameSearch( IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ); + + #endregion + internal IntPtr GetISteamGameSearch( HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ) + { + var returnValue = _GetISteamGameSearch( Self, hSteamuser, hSteamPipe, pchVersion ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetIPCCallCount")] + private static extern uint _GetIPCCallCount( IntPtr self ); + + #endregion + internal uint GetIPCCallCount() + { + var returnValue = _GetIPCCallCount( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_SetWarningMessageHook")] + private static extern void _SetWarningMessageHook( IntPtr self, IntPtr pFunction ); + + #endregion + internal void SetWarningMessageHook( IntPtr pFunction ) + { + _SetWarningMessageHook( Self, pFunction ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_BShutdownIfAllPipesClosed")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _BShutdownIfAllPipesClosed( IntPtr self ); + + #endregion + internal bool BShutdownIfAllPipesClosed() + { + var returnValue = _BShutdownIfAllPipesClosed( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamHTTP")] + private static extern IntPtr _GetISteamHTTP( IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ); + + #endregion + internal IntPtr GetISteamHTTP( HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ) + { + var returnValue = _GetISteamHTTP( Self, hSteamuser, hSteamPipe, pchVersion ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamController")] + private static extern IntPtr _GetISteamController( IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ); + + #endregion + internal IntPtr GetISteamController( HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ) + { + var returnValue = _GetISteamController( Self, hSteamUser, hSteamPipe, pchVersion ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamUGC")] + private static extern IntPtr _GetISteamUGC( IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ); + + #endregion + internal IntPtr GetISteamUGC( HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ) + { + var returnValue = _GetISteamUGC( Self, hSteamUser, hSteamPipe, pchVersion ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamAppList")] + private static extern IntPtr _GetISteamAppList( IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ); + + #endregion + internal IntPtr GetISteamAppList( HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ) + { + var returnValue = _GetISteamAppList( Self, hSteamUser, hSteamPipe, pchVersion ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamMusic")] + private static extern IntPtr _GetISteamMusic( IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ); + + #endregion + internal IntPtr GetISteamMusic( HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ) + { + var returnValue = _GetISteamMusic( Self, hSteamuser, hSteamPipe, pchVersion ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamMusicRemote")] + private static extern IntPtr _GetISteamMusicRemote( IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ); + + #endregion + internal IntPtr GetISteamMusicRemote( HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ) + { + var returnValue = _GetISteamMusicRemote( Self, hSteamuser, hSteamPipe, pchVersion ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamHTMLSurface")] + private static extern IntPtr _GetISteamHTMLSurface( IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ); + + #endregion + internal IntPtr GetISteamHTMLSurface( HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ) + { + var returnValue = _GetISteamHTMLSurface( Self, hSteamuser, hSteamPipe, pchVersion ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamInventory")] + private static extern IntPtr _GetISteamInventory( IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ); + + #endregion + internal IntPtr GetISteamInventory( HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ) + { + var returnValue = _GetISteamInventory( Self, hSteamuser, hSteamPipe, pchVersion ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamVideo")] + private static extern IntPtr _GetISteamVideo( IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ); + + #endregion + internal IntPtr GetISteamVideo( HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ) + { + var returnValue = _GetISteamVideo( Self, hSteamuser, hSteamPipe, pchVersion ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamParentalSettings")] + private static extern IntPtr _GetISteamParentalSettings( IntPtr self, HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ); + + #endregion + internal IntPtr GetISteamParentalSettings( HSteamUser hSteamuser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ) + { + var returnValue = _GetISteamParentalSettings( Self, hSteamuser, hSteamPipe, pchVersion ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamInput")] + private static extern IntPtr _GetISteamInput( IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ); + + #endregion + internal IntPtr GetISteamInput( HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ) + { + var returnValue = _GetISteamInput( Self, hSteamUser, hSteamPipe, pchVersion ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamParties")] + private static extern IntPtr _GetISteamParties( IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ); + + #endregion + internal IntPtr GetISteamParties( HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ) + { + var returnValue = _GetISteamParties( Self, hSteamUser, hSteamPipe, pchVersion ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamClient_GetISteamRemotePlay")] + private static extern IntPtr _GetISteamRemotePlay( IntPtr self, HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ); + + #endregion + internal IntPtr GetISteamRemotePlay( HSteamUser hSteamUser, HSteamPipe hSteamPipe, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchVersion ) + { + var returnValue = _GetISteamRemotePlay( Self, hSteamUser, hSteamPipe, pchVersion ); + return returnValue; + } + + } +} diff --git a/Facepunch.Steamworks/Generated/Interfaces/ISteamController.cs b/Facepunch.Steamworks/Generated/Interfaces/ISteamController.cs new file mode 100644 index 0000000..57f9236 --- /dev/null +++ b/Facepunch.Steamworks/Generated/Interfaces/ISteamController.cs @@ -0,0 +1,389 @@ +using System; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading.Tasks; +using Steamworks.Data; + + +namespace Steamworks +{ + internal class ISteamController : SteamInterface + { + public override IntPtr GetInterfacePointer() => GetApi.SteamController(); + + + internal ISteamController() + { + SetupInterface(); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_Init")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _Init( IntPtr self ); + + #endregion + internal bool Init() + { + var returnValue = _Init( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_Shutdown")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _Shutdown( IntPtr self ); + + #endregion + internal bool Shutdown() + { + var returnValue = _Shutdown( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_RunFrame")] + private static extern void _RunFrame( IntPtr self ); + + #endregion + internal void RunFrame() + { + _RunFrame( Self ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_GetConnectedControllers")] + private static extern int _GetConnectedControllers( IntPtr self, [In,Out] ControllerHandle_t[] handlesOut ); + + #endregion + internal int GetConnectedControllers( [In,Out] ControllerHandle_t[] handlesOut ) + { + var returnValue = _GetConnectedControllers( Self, handlesOut ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_GetActionSetHandle")] + private static extern ControllerActionSetHandle_t _GetActionSetHandle( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pszActionSetName ); + + #endregion + internal ControllerActionSetHandle_t GetActionSetHandle( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pszActionSetName ) + { + var returnValue = _GetActionSetHandle( Self, pszActionSetName ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_ActivateActionSet")] + private static extern void _ActivateActionSet( IntPtr self, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle ); + + #endregion + internal void ActivateActionSet( ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle ) + { + _ActivateActionSet( Self, controllerHandle, actionSetHandle ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_GetCurrentActionSet")] + private static extern ControllerActionSetHandle_t _GetCurrentActionSet( IntPtr self, ControllerHandle_t controllerHandle ); + + #endregion + internal ControllerActionSetHandle_t GetCurrentActionSet( ControllerHandle_t controllerHandle ) + { + var returnValue = _GetCurrentActionSet( Self, controllerHandle ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_ActivateActionSetLayer")] + private static extern void _ActivateActionSetLayer( IntPtr self, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetLayerHandle ); + + #endregion + internal void ActivateActionSetLayer( ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetLayerHandle ) + { + _ActivateActionSetLayer( Self, controllerHandle, actionSetLayerHandle ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_DeactivateActionSetLayer")] + private static extern void _DeactivateActionSetLayer( IntPtr self, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetLayerHandle ); + + #endregion + internal void DeactivateActionSetLayer( ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetLayerHandle ) + { + _DeactivateActionSetLayer( Self, controllerHandle, actionSetLayerHandle ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_DeactivateAllActionSetLayers")] + private static extern void _DeactivateAllActionSetLayers( IntPtr self, ControllerHandle_t controllerHandle ); + + #endregion + internal void DeactivateAllActionSetLayers( ControllerHandle_t controllerHandle ) + { + _DeactivateAllActionSetLayers( Self, controllerHandle ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_GetActiveActionSetLayers")] + private static extern int _GetActiveActionSetLayers( IntPtr self, ControllerHandle_t controllerHandle, [In,Out] ControllerActionSetHandle_t[] handlesOut ); + + #endregion + internal int GetActiveActionSetLayers( ControllerHandle_t controllerHandle, [In,Out] ControllerActionSetHandle_t[] handlesOut ) + { + var returnValue = _GetActiveActionSetLayers( Self, controllerHandle, handlesOut ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_GetDigitalActionHandle")] + private static extern ControllerDigitalActionHandle_t _GetDigitalActionHandle( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pszActionName ); + + #endregion + internal ControllerDigitalActionHandle_t GetDigitalActionHandle( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pszActionName ) + { + var returnValue = _GetDigitalActionHandle( Self, pszActionName ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_GetDigitalActionData")] + private static extern DigitalState _GetDigitalActionData( IntPtr self, ControllerHandle_t controllerHandle, ControllerDigitalActionHandle_t digitalActionHandle ); + + #endregion + internal DigitalState GetDigitalActionData( ControllerHandle_t controllerHandle, ControllerDigitalActionHandle_t digitalActionHandle ) + { + var returnValue = _GetDigitalActionData( Self, controllerHandle, digitalActionHandle ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_GetDigitalActionOrigins")] + private static extern int _GetDigitalActionOrigins( IntPtr self, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerDigitalActionHandle_t digitalActionHandle, ref ControllerActionOrigin originsOut ); + + #endregion + internal int GetDigitalActionOrigins( ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerDigitalActionHandle_t digitalActionHandle, ref ControllerActionOrigin originsOut ) + { + var returnValue = _GetDigitalActionOrigins( Self, controllerHandle, actionSetHandle, digitalActionHandle, ref originsOut ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_GetAnalogActionHandle")] + private static extern ControllerAnalogActionHandle_t _GetAnalogActionHandle( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pszActionName ); + + #endregion + internal ControllerAnalogActionHandle_t GetAnalogActionHandle( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pszActionName ) + { + var returnValue = _GetAnalogActionHandle( Self, pszActionName ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_GetAnalogActionData")] + private static extern AnalogState _GetAnalogActionData( IntPtr self, ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t analogActionHandle ); + + #endregion + internal AnalogState GetAnalogActionData( ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t analogActionHandle ) + { + var returnValue = _GetAnalogActionData( Self, controllerHandle, analogActionHandle ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_GetAnalogActionOrigins")] + private static extern int _GetAnalogActionOrigins( IntPtr self, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerAnalogActionHandle_t analogActionHandle, ref ControllerActionOrigin originsOut ); + + #endregion + internal int GetAnalogActionOrigins( ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerAnalogActionHandle_t analogActionHandle, ref ControllerActionOrigin originsOut ) + { + var returnValue = _GetAnalogActionOrigins( Self, controllerHandle, actionSetHandle, analogActionHandle, ref originsOut ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_GetGlyphForActionOrigin")] + private static extern Utf8StringPointer _GetGlyphForActionOrigin( IntPtr self, ControllerActionOrigin eOrigin ); + + #endregion + internal string GetGlyphForActionOrigin( ControllerActionOrigin eOrigin ) + { + var returnValue = _GetGlyphForActionOrigin( Self, eOrigin ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_GetStringForActionOrigin")] + private static extern Utf8StringPointer _GetStringForActionOrigin( IntPtr self, ControllerActionOrigin eOrigin ); + + #endregion + internal string GetStringForActionOrigin( ControllerActionOrigin eOrigin ) + { + var returnValue = _GetStringForActionOrigin( Self, eOrigin ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_StopAnalogActionMomentum")] + private static extern void _StopAnalogActionMomentum( IntPtr self, ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t eAction ); + + #endregion + internal void StopAnalogActionMomentum( ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t eAction ) + { + _StopAnalogActionMomentum( Self, controllerHandle, eAction ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_GetMotionData")] + private static extern MotionState _GetMotionData( IntPtr self, ControllerHandle_t controllerHandle ); + + #endregion + internal MotionState GetMotionData( ControllerHandle_t controllerHandle ) + { + var returnValue = _GetMotionData( Self, controllerHandle ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_TriggerHapticPulse")] + private static extern void _TriggerHapticPulse( IntPtr self, ControllerHandle_t controllerHandle, SteamControllerPad eTargetPad, ushort usDurationMicroSec ); + + #endregion + internal void TriggerHapticPulse( ControllerHandle_t controllerHandle, SteamControllerPad eTargetPad, ushort usDurationMicroSec ) + { + _TriggerHapticPulse( Self, controllerHandle, eTargetPad, usDurationMicroSec ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_TriggerRepeatedHapticPulse")] + private static extern void _TriggerRepeatedHapticPulse( IntPtr self, ControllerHandle_t controllerHandle, SteamControllerPad eTargetPad, ushort usDurationMicroSec, ushort usOffMicroSec, ushort unRepeat, uint nFlags ); + + #endregion + internal void TriggerRepeatedHapticPulse( ControllerHandle_t controllerHandle, SteamControllerPad eTargetPad, ushort usDurationMicroSec, ushort usOffMicroSec, ushort unRepeat, uint nFlags ) + { + _TriggerRepeatedHapticPulse( Self, controllerHandle, eTargetPad, usDurationMicroSec, usOffMicroSec, unRepeat, nFlags ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_TriggerVibration")] + private static extern void _TriggerVibration( IntPtr self, ControllerHandle_t controllerHandle, ushort usLeftSpeed, ushort usRightSpeed ); + + #endregion + internal void TriggerVibration( ControllerHandle_t controllerHandle, ushort usLeftSpeed, ushort usRightSpeed ) + { + _TriggerVibration( Self, controllerHandle, usLeftSpeed, usRightSpeed ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_SetLEDColor")] + private static extern void _SetLEDColor( IntPtr self, ControllerHandle_t controllerHandle, byte nColorR, byte nColorG, byte nColorB, uint nFlags ); + + #endregion + internal void SetLEDColor( ControllerHandle_t controllerHandle, byte nColorR, byte nColorG, byte nColorB, uint nFlags ) + { + _SetLEDColor( Self, controllerHandle, nColorR, nColorG, nColorB, nFlags ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_ShowBindingPanel")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _ShowBindingPanel( IntPtr self, ControllerHandle_t controllerHandle ); + + #endregion + internal bool ShowBindingPanel( ControllerHandle_t controllerHandle ) + { + var returnValue = _ShowBindingPanel( Self, controllerHandle ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_GetInputTypeForHandle")] + private static extern InputType _GetInputTypeForHandle( IntPtr self, ControllerHandle_t controllerHandle ); + + #endregion + internal InputType GetInputTypeForHandle( ControllerHandle_t controllerHandle ) + { + var returnValue = _GetInputTypeForHandle( Self, controllerHandle ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_GetControllerForGamepadIndex")] + private static extern ControllerHandle_t _GetControllerForGamepadIndex( IntPtr self, int nIndex ); + + #endregion + internal ControllerHandle_t GetControllerForGamepadIndex( int nIndex ) + { + var returnValue = _GetControllerForGamepadIndex( Self, nIndex ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_GetGamepadIndexForController")] + private static extern int _GetGamepadIndexForController( IntPtr self, ControllerHandle_t ulControllerHandle ); + + #endregion + internal int GetGamepadIndexForController( ControllerHandle_t ulControllerHandle ) + { + var returnValue = _GetGamepadIndexForController( Self, ulControllerHandle ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_GetStringForXboxOrigin")] + private static extern Utf8StringPointer _GetStringForXboxOrigin( IntPtr self, XboxOrigin eOrigin ); + + #endregion + internal string GetStringForXboxOrigin( XboxOrigin eOrigin ) + { + var returnValue = _GetStringForXboxOrigin( Self, eOrigin ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_GetGlyphForXboxOrigin")] + private static extern Utf8StringPointer _GetGlyphForXboxOrigin( IntPtr self, XboxOrigin eOrigin ); + + #endregion + internal string GetGlyphForXboxOrigin( XboxOrigin eOrigin ) + { + var returnValue = _GetGlyphForXboxOrigin( Self, eOrigin ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_GetActionOriginFromXboxOrigin")] + private static extern ControllerActionOrigin _GetActionOriginFromXboxOrigin( IntPtr self, ControllerHandle_t controllerHandle, XboxOrigin eOrigin ); + + #endregion + internal ControllerActionOrigin GetActionOriginFromXboxOrigin( ControllerHandle_t controllerHandle, XboxOrigin eOrigin ) + { + var returnValue = _GetActionOriginFromXboxOrigin( Self, controllerHandle, eOrigin ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_TranslateActionOrigin")] + private static extern ControllerActionOrigin _TranslateActionOrigin( IntPtr self, InputType eDestinationInputType, ControllerActionOrigin eSourceOrigin ); + + #endregion + internal ControllerActionOrigin TranslateActionOrigin( InputType eDestinationInputType, ControllerActionOrigin eSourceOrigin ) + { + var returnValue = _TranslateActionOrigin( Self, eDestinationInputType, eSourceOrigin ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamController_GetControllerBindingRevision")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _GetControllerBindingRevision( IntPtr self, ControllerHandle_t controllerHandle, ref int pMajor, ref int pMinor ); + + #endregion + internal bool GetControllerBindingRevision( ControllerHandle_t controllerHandle, ref int pMajor, ref int pMinor ) + { + var returnValue = _GetControllerBindingRevision( Self, controllerHandle, ref pMajor, ref pMinor ); + return returnValue; + } + + } +} diff --git a/Facepunch.Steamworks/Generated/Interfaces/ISteamFriends.cs b/Facepunch.Steamworks/Generated/Interfaces/ISteamFriends.cs index 30a2fdb..7d247aa 100644 --- a/Facepunch.Steamworks/Generated/Interfaces/ISteamFriends.cs +++ b/Facepunch.Steamworks/Generated/Interfaces/ISteamFriends.cs @@ -277,10 +277,10 @@ namespace Steamworks private static extern SteamAPICall_t _DownloadClanActivityCounts( IntPtr self, [In,Out] SteamId[] psteamIDClans, int cClansToRequest ); #endregion - internal CallbackResult DownloadClanActivityCounts( [In,Out] SteamId[] psteamIDClans, int cClansToRequest ) + internal CallbackResult DownloadClanActivityCounts( [In,Out] SteamId[] psteamIDClans, int cClansToRequest ) { var returnValue = _DownloadClanActivityCounts( Self, psteamIDClans, cClansToRequest ); - return new CallbackResult( returnValue ); + return new CallbackResult( returnValue ); } #region FunctionMeta @@ -827,5 +827,15 @@ namespace Steamworks return returnValue; } + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamFriends_ActivateGameOverlayRemotePlayTogetherInviteDialog")] + private static extern void _ActivateGameOverlayRemotePlayTogetherInviteDialog( IntPtr self, SteamId steamIDLobby ); + + #endregion + internal void ActivateGameOverlayRemotePlayTogetherInviteDialog( SteamId steamIDLobby ) + { + _ActivateGameOverlayRemotePlayTogetherInviteDialog( Self, steamIDLobby ); + } + } } diff --git a/Facepunch.Steamworks/Generated/Interfaces/ISteamGameSearch.cs b/Facepunch.Steamworks/Generated/Interfaces/ISteamGameSearch.cs new file mode 100644 index 0000000..7b7511c --- /dev/null +++ b/Facepunch.Steamworks/Generated/Interfaces/ISteamGameSearch.cs @@ -0,0 +1,177 @@ +using System; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading.Tasks; +using Steamworks.Data; + + +namespace Steamworks +{ + internal class ISteamGameSearch : SteamInterface + { + public override IntPtr GetInterfacePointer() => GetApi.SteamGameSearch(); + + + internal ISteamGameSearch() + { + SetupInterface(); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamGameSearch_AddGameSearchParams")] + private static extern EGameSearchErrorCode_t _AddGameSearchParams( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchKeyToFind, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchValuesToFind ); + + #endregion + internal EGameSearchErrorCode_t AddGameSearchParams( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchKeyToFind, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchValuesToFind ) + { + var returnValue = _AddGameSearchParams( Self, pchKeyToFind, pchValuesToFind ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamGameSearch_SearchForGameWithLobby")] + private static extern EGameSearchErrorCode_t _SearchForGameWithLobby( IntPtr self, SteamId steamIDLobby, int nPlayerMin, int nPlayerMax ); + + #endregion + internal EGameSearchErrorCode_t SearchForGameWithLobby( SteamId steamIDLobby, int nPlayerMin, int nPlayerMax ) + { + var returnValue = _SearchForGameWithLobby( Self, steamIDLobby, nPlayerMin, nPlayerMax ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamGameSearch_SearchForGameSolo")] + private static extern EGameSearchErrorCode_t _SearchForGameSolo( IntPtr self, int nPlayerMin, int nPlayerMax ); + + #endregion + internal EGameSearchErrorCode_t SearchForGameSolo( int nPlayerMin, int nPlayerMax ) + { + var returnValue = _SearchForGameSolo( Self, nPlayerMin, nPlayerMax ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamGameSearch_AcceptGame")] + private static extern EGameSearchErrorCode_t _AcceptGame( IntPtr self ); + + #endregion + internal EGameSearchErrorCode_t AcceptGame() + { + var returnValue = _AcceptGame( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamGameSearch_DeclineGame")] + private static extern EGameSearchErrorCode_t _DeclineGame( IntPtr self ); + + #endregion + internal EGameSearchErrorCode_t DeclineGame() + { + var returnValue = _DeclineGame( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamGameSearch_RetrieveConnectionDetails")] + private static extern EGameSearchErrorCode_t _RetrieveConnectionDetails( IntPtr self, SteamId steamIDHost, IntPtr pchConnectionDetails, int cubConnectionDetails ); + + #endregion + internal EGameSearchErrorCode_t RetrieveConnectionDetails( SteamId steamIDHost, out string pchConnectionDetails ) + { + IntPtr mempchConnectionDetails = Helpers.TakeMemory(); + var returnValue = _RetrieveConnectionDetails( Self, steamIDHost, mempchConnectionDetails, (1024 * 32) ); + pchConnectionDetails = Helpers.MemoryToString( mempchConnectionDetails ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamGameSearch_EndGameSearch")] + private static extern EGameSearchErrorCode_t _EndGameSearch( IntPtr self ); + + #endregion + internal EGameSearchErrorCode_t EndGameSearch() + { + var returnValue = _EndGameSearch( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamGameSearch_SetGameHostParams")] + private static extern EGameSearchErrorCode_t _SetGameHostParams( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchKey, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchValue ); + + #endregion + internal EGameSearchErrorCode_t SetGameHostParams( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchKey, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchValue ) + { + var returnValue = _SetGameHostParams( Self, pchKey, pchValue ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamGameSearch_SetConnectionDetails")] + private static extern EGameSearchErrorCode_t _SetConnectionDetails( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchConnectionDetails, int cubConnectionDetails ); + + #endregion + internal EGameSearchErrorCode_t SetConnectionDetails( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchConnectionDetails, int cubConnectionDetails ) + { + var returnValue = _SetConnectionDetails( Self, pchConnectionDetails, cubConnectionDetails ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamGameSearch_RequestPlayersForGame")] + private static extern EGameSearchErrorCode_t _RequestPlayersForGame( IntPtr self, int nPlayerMin, int nPlayerMax, int nMaxTeamSize ); + + #endregion + internal EGameSearchErrorCode_t RequestPlayersForGame( int nPlayerMin, int nPlayerMax, int nMaxTeamSize ) + { + var returnValue = _RequestPlayersForGame( Self, nPlayerMin, nPlayerMax, nMaxTeamSize ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamGameSearch_HostConfirmGameStart")] + private static extern EGameSearchErrorCode_t _HostConfirmGameStart( IntPtr self, ulong ullUniqueGameID ); + + #endregion + internal EGameSearchErrorCode_t HostConfirmGameStart( ulong ullUniqueGameID ) + { + var returnValue = _HostConfirmGameStart( Self, ullUniqueGameID ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamGameSearch_CancelRequestPlayersForGame")] + private static extern EGameSearchErrorCode_t _CancelRequestPlayersForGame( IntPtr self ); + + #endregion + internal EGameSearchErrorCode_t CancelRequestPlayersForGame() + { + var returnValue = _CancelRequestPlayersForGame( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamGameSearch_SubmitPlayerResult")] + private static extern EGameSearchErrorCode_t _SubmitPlayerResult( IntPtr self, ulong ullUniqueGameID, SteamId steamIDPlayer, EPlayerResult_t EPlayerResult ); + + #endregion + internal EGameSearchErrorCode_t SubmitPlayerResult( ulong ullUniqueGameID, SteamId steamIDPlayer, EPlayerResult_t EPlayerResult ) + { + var returnValue = _SubmitPlayerResult( Self, ullUniqueGameID, steamIDPlayer, EPlayerResult ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamGameSearch_EndGame")] + private static extern EGameSearchErrorCode_t _EndGame( IntPtr self, ulong ullUniqueGameID ); + + #endregion + internal EGameSearchErrorCode_t EndGame( ulong ullUniqueGameID ) + { + var returnValue = _EndGame( Self, ullUniqueGameID ); + return returnValue; + } + + } +} diff --git a/Facepunch.Steamworks/Generated/Interfaces/ISteamGameServer.cs b/Facepunch.Steamworks/Generated/Interfaces/ISteamGameServer.cs index bcdf5bb..3f0e38c 100644 --- a/Facepunch.Steamworks/Generated/Interfaces/ISteamGameServer.cs +++ b/Facepunch.Steamworks/Generated/Interfaces/ISteamGameServer.cs @@ -399,10 +399,10 @@ namespace Steamworks #region FunctionMeta [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamGameServer_GetPublicIP")] - private static extern uint _GetPublicIP( IntPtr self ); + private static extern SteamIPAddress_t _GetPublicIP( IntPtr self ); #endregion - internal uint GetPublicIP() + internal SteamIPAddress_t GetPublicIP() { var returnValue = _GetPublicIP( Self ); return returnValue; diff --git a/Facepunch.Steamworks/Generated/Interfaces/ISteamGameServerStats.cs b/Facepunch.Steamworks/Generated/Interfaces/ISteamGameServerStats.cs index d58a0ce..f16e9a5 100644 --- a/Facepunch.Steamworks/Generated/Interfaces/ISteamGameServerStats.cs +++ b/Facepunch.Steamworks/Generated/Interfaces/ISteamGameServerStats.cs @@ -41,14 +41,14 @@ namespace Steamworks } #region FunctionMeta - [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamGameServerStats_GetUserStat0")] + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamGameServerStats_GetUserStat")] [return: MarshalAs( UnmanagedType.I1 )] - private static extern bool _GetUserStat0( IntPtr self, SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchName, ref float pData ); + private static extern bool _GetUserStat( IntPtr self, SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchName, ref float pData ); #endregion - internal bool GetUserStat0( SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchName, ref float pData ) + internal bool GetUserStat( SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchName, ref float pData ) { - var returnValue = _GetUserStat0( Self, steamIDUser, pchName, ref pData ); + var returnValue = _GetUserStat( Self, steamIDUser, pchName, ref pData ); return returnValue; } @@ -77,14 +77,14 @@ namespace Steamworks } #region FunctionMeta - [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamGameServerStats_SetUserStat0")] + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamGameServerStats_SetUserStat")] [return: MarshalAs( UnmanagedType.I1 )] - private static extern bool _SetUserStat0( IntPtr self, SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchName, float fData ); + private static extern bool _SetUserStat( IntPtr self, SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchName, float fData ); #endregion - internal bool SetUserStat0( SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchName, float fData ) + internal bool SetUserStat( SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchName, float fData ) { - var returnValue = _SetUserStat0( Self, steamIDUser, pchName, fData ); + var returnValue = _SetUserStat( Self, steamIDUser, pchName, fData ); return returnValue; } diff --git a/Facepunch.Steamworks/Generated/Interfaces/ISteamHTMLSurface.cs b/Facepunch.Steamworks/Generated/Interfaces/ISteamHTMLSurface.cs new file mode 100644 index 0000000..008e8d7 --- /dev/null +++ b/Facepunch.Steamworks/Generated/Interfaces/ISteamHTMLSurface.cs @@ -0,0 +1,396 @@ +using System; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading.Tasks; +using Steamworks.Data; + + +namespace Steamworks +{ + internal class ISteamHTMLSurface : SteamInterface + { + public override IntPtr GetInterfacePointer() => GetApi.SteamHTMLSurface(); + + + internal ISteamHTMLSurface() + { + SetupInterface(); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_Init")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _Init( IntPtr self ); + + #endregion + internal bool Init() + { + var returnValue = _Init( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_Shutdown")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _Shutdown( IntPtr self ); + + #endregion + internal bool Shutdown() + { + var returnValue = _Shutdown( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_CreateBrowser")] + private static extern SteamAPICall_t _CreateBrowser( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchUserAgent, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchUserCSS ); + + #endregion + internal CallbackResult CreateBrowser( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchUserAgent, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchUserCSS ) + { + var returnValue = _CreateBrowser( Self, pchUserAgent, pchUserCSS ); + return new CallbackResult( returnValue ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_RemoveBrowser")] + private static extern void _RemoveBrowser( IntPtr self, HHTMLBrowser unBrowserHandle ); + + #endregion + internal void RemoveBrowser( HHTMLBrowser unBrowserHandle ) + { + _RemoveBrowser( Self, unBrowserHandle ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_LoadURL")] + private static extern void _LoadURL( IntPtr self, HHTMLBrowser unBrowserHandle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchURL, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchPostData ); + + #endregion + internal void LoadURL( HHTMLBrowser unBrowserHandle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchURL, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchPostData ) + { + _LoadURL( Self, unBrowserHandle, pchURL, pchPostData ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_SetSize")] + private static extern void _SetSize( IntPtr self, HHTMLBrowser unBrowserHandle, uint unWidth, uint unHeight ); + + #endregion + internal void SetSize( HHTMLBrowser unBrowserHandle, uint unWidth, uint unHeight ) + { + _SetSize( Self, unBrowserHandle, unWidth, unHeight ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_StopLoad")] + private static extern void _StopLoad( IntPtr self, HHTMLBrowser unBrowserHandle ); + + #endregion + internal void StopLoad( HHTMLBrowser unBrowserHandle ) + { + _StopLoad( Self, unBrowserHandle ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_Reload")] + private static extern void _Reload( IntPtr self, HHTMLBrowser unBrowserHandle ); + + #endregion + internal void Reload( HHTMLBrowser unBrowserHandle ) + { + _Reload( Self, unBrowserHandle ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_GoBack")] + private static extern void _GoBack( IntPtr self, HHTMLBrowser unBrowserHandle ); + + #endregion + internal void GoBack( HHTMLBrowser unBrowserHandle ) + { + _GoBack( Self, unBrowserHandle ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_GoForward")] + private static extern void _GoForward( IntPtr self, HHTMLBrowser unBrowserHandle ); + + #endregion + internal void GoForward( HHTMLBrowser unBrowserHandle ) + { + _GoForward( Self, unBrowserHandle ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_AddHeader")] + private static extern void _AddHeader( IntPtr self, HHTMLBrowser unBrowserHandle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchKey, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchValue ); + + #endregion + internal void AddHeader( HHTMLBrowser unBrowserHandle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchKey, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchValue ) + { + _AddHeader( Self, unBrowserHandle, pchKey, pchValue ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_ExecuteJavascript")] + private static extern void _ExecuteJavascript( IntPtr self, HHTMLBrowser unBrowserHandle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchScript ); + + #endregion + internal void ExecuteJavascript( HHTMLBrowser unBrowserHandle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchScript ) + { + _ExecuteJavascript( Self, unBrowserHandle, pchScript ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_MouseUp")] + private static extern void _MouseUp( IntPtr self, HHTMLBrowser unBrowserHandle, IntPtr eMouseButton ); + + #endregion + internal void MouseUp( HHTMLBrowser unBrowserHandle, IntPtr eMouseButton ) + { + _MouseUp( Self, unBrowserHandle, eMouseButton ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_MouseDown")] + private static extern void _MouseDown( IntPtr self, HHTMLBrowser unBrowserHandle, IntPtr eMouseButton ); + + #endregion + internal void MouseDown( HHTMLBrowser unBrowserHandle, IntPtr eMouseButton ) + { + _MouseDown( Self, unBrowserHandle, eMouseButton ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_MouseDoubleClick")] + private static extern void _MouseDoubleClick( IntPtr self, HHTMLBrowser unBrowserHandle, IntPtr eMouseButton ); + + #endregion + internal void MouseDoubleClick( HHTMLBrowser unBrowserHandle, IntPtr eMouseButton ) + { + _MouseDoubleClick( Self, unBrowserHandle, eMouseButton ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_MouseMove")] + private static extern void _MouseMove( IntPtr self, HHTMLBrowser unBrowserHandle, int x, int y ); + + #endregion + internal void MouseMove( HHTMLBrowser unBrowserHandle, int x, int y ) + { + _MouseMove( Self, unBrowserHandle, x, y ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_MouseWheel")] + private static extern void _MouseWheel( IntPtr self, HHTMLBrowser unBrowserHandle, int nDelta ); + + #endregion + internal void MouseWheel( HHTMLBrowser unBrowserHandle, int nDelta ) + { + _MouseWheel( Self, unBrowserHandle, nDelta ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_KeyDown")] + private static extern void _KeyDown( IntPtr self, HHTMLBrowser unBrowserHandle, uint nNativeKeyCode, IntPtr eHTMLKeyModifiers, [MarshalAs( UnmanagedType.U1 )] bool bIsSystemKey ); + + #endregion + internal void KeyDown( HHTMLBrowser unBrowserHandle, uint nNativeKeyCode, IntPtr eHTMLKeyModifiers, [MarshalAs( UnmanagedType.U1 )] bool bIsSystemKey ) + { + _KeyDown( Self, unBrowserHandle, nNativeKeyCode, eHTMLKeyModifiers, bIsSystemKey ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_KeyUp")] + private static extern void _KeyUp( IntPtr self, HHTMLBrowser unBrowserHandle, uint nNativeKeyCode, IntPtr eHTMLKeyModifiers ); + + #endregion + internal void KeyUp( HHTMLBrowser unBrowserHandle, uint nNativeKeyCode, IntPtr eHTMLKeyModifiers ) + { + _KeyUp( Self, unBrowserHandle, nNativeKeyCode, eHTMLKeyModifiers ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_KeyChar")] + private static extern void _KeyChar( IntPtr self, HHTMLBrowser unBrowserHandle, uint cUnicodeChar, IntPtr eHTMLKeyModifiers ); + + #endregion + internal void KeyChar( HHTMLBrowser unBrowserHandle, uint cUnicodeChar, IntPtr eHTMLKeyModifiers ) + { + _KeyChar( Self, unBrowserHandle, cUnicodeChar, eHTMLKeyModifiers ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_SetHorizontalScroll")] + private static extern void _SetHorizontalScroll( IntPtr self, HHTMLBrowser unBrowserHandle, uint nAbsolutePixelScroll ); + + #endregion + internal void SetHorizontalScroll( HHTMLBrowser unBrowserHandle, uint nAbsolutePixelScroll ) + { + _SetHorizontalScroll( Self, unBrowserHandle, nAbsolutePixelScroll ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_SetVerticalScroll")] + private static extern void _SetVerticalScroll( IntPtr self, HHTMLBrowser unBrowserHandle, uint nAbsolutePixelScroll ); + + #endregion + internal void SetVerticalScroll( HHTMLBrowser unBrowserHandle, uint nAbsolutePixelScroll ) + { + _SetVerticalScroll( Self, unBrowserHandle, nAbsolutePixelScroll ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_SetKeyFocus")] + private static extern void _SetKeyFocus( IntPtr self, HHTMLBrowser unBrowserHandle, [MarshalAs( UnmanagedType.U1 )] bool bHasKeyFocus ); + + #endregion + internal void SetKeyFocus( HHTMLBrowser unBrowserHandle, [MarshalAs( UnmanagedType.U1 )] bool bHasKeyFocus ) + { + _SetKeyFocus( Self, unBrowserHandle, bHasKeyFocus ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_ViewSource")] + private static extern void _ViewSource( IntPtr self, HHTMLBrowser unBrowserHandle ); + + #endregion + internal void ViewSource( HHTMLBrowser unBrowserHandle ) + { + _ViewSource( Self, unBrowserHandle ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_CopyToClipboard")] + private static extern void _CopyToClipboard( IntPtr self, HHTMLBrowser unBrowserHandle ); + + #endregion + internal void CopyToClipboard( HHTMLBrowser unBrowserHandle ) + { + _CopyToClipboard( Self, unBrowserHandle ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_PasteFromClipboard")] + private static extern void _PasteFromClipboard( IntPtr self, HHTMLBrowser unBrowserHandle ); + + #endregion + internal void PasteFromClipboard( HHTMLBrowser unBrowserHandle ) + { + _PasteFromClipboard( Self, unBrowserHandle ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_Find")] + private static extern void _Find( IntPtr self, HHTMLBrowser unBrowserHandle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchSearchStr, [MarshalAs( UnmanagedType.U1 )] bool bCurrentlyInFind, [MarshalAs( UnmanagedType.U1 )] bool bReverse ); + + #endregion + internal void Find( HHTMLBrowser unBrowserHandle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchSearchStr, [MarshalAs( UnmanagedType.U1 )] bool bCurrentlyInFind, [MarshalAs( UnmanagedType.U1 )] bool bReverse ) + { + _Find( Self, unBrowserHandle, pchSearchStr, bCurrentlyInFind, bReverse ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_StopFind")] + private static extern void _StopFind( IntPtr self, HHTMLBrowser unBrowserHandle ); + + #endregion + internal void StopFind( HHTMLBrowser unBrowserHandle ) + { + _StopFind( Self, unBrowserHandle ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_GetLinkAtPosition")] + private static extern void _GetLinkAtPosition( IntPtr self, HHTMLBrowser unBrowserHandle, int x, int y ); + + #endregion + internal void GetLinkAtPosition( HHTMLBrowser unBrowserHandle, int x, int y ) + { + _GetLinkAtPosition( Self, unBrowserHandle, x, y ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_SetCookie")] + private static extern void _SetCookie( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchHostname, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchKey, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchValue, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchPath, RTime32 nExpires, [MarshalAs( UnmanagedType.U1 )] bool bSecure, [MarshalAs( UnmanagedType.U1 )] bool bHTTPOnly ); + + #endregion + internal void SetCookie( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchHostname, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchKey, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchValue, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchPath, RTime32 nExpires, [MarshalAs( UnmanagedType.U1 )] bool bSecure, [MarshalAs( UnmanagedType.U1 )] bool bHTTPOnly ) + { + _SetCookie( Self, pchHostname, pchKey, pchValue, pchPath, nExpires, bSecure, bHTTPOnly ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_SetPageScaleFactor")] + private static extern void _SetPageScaleFactor( IntPtr self, HHTMLBrowser unBrowserHandle, float flZoom, int nPointX, int nPointY ); + + #endregion + internal void SetPageScaleFactor( HHTMLBrowser unBrowserHandle, float flZoom, int nPointX, int nPointY ) + { + _SetPageScaleFactor( Self, unBrowserHandle, flZoom, nPointX, nPointY ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_SetBackgroundMode")] + private static extern void _SetBackgroundMode( IntPtr self, HHTMLBrowser unBrowserHandle, [MarshalAs( UnmanagedType.U1 )] bool bBackgroundMode ); + + #endregion + internal void SetBackgroundMode( HHTMLBrowser unBrowserHandle, [MarshalAs( UnmanagedType.U1 )] bool bBackgroundMode ) + { + _SetBackgroundMode( Self, unBrowserHandle, bBackgroundMode ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_SetDPIScalingFactor")] + private static extern void _SetDPIScalingFactor( IntPtr self, HHTMLBrowser unBrowserHandle, float flDPIScaling ); + + #endregion + internal void SetDPIScalingFactor( HHTMLBrowser unBrowserHandle, float flDPIScaling ) + { + _SetDPIScalingFactor( Self, unBrowserHandle, flDPIScaling ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_OpenDeveloperTools")] + private static extern void _OpenDeveloperTools( IntPtr self, HHTMLBrowser unBrowserHandle ); + + #endregion + internal void OpenDeveloperTools( HHTMLBrowser unBrowserHandle ) + { + _OpenDeveloperTools( Self, unBrowserHandle ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_AllowStartRequest")] + private static extern void _AllowStartRequest( IntPtr self, HHTMLBrowser unBrowserHandle, [MarshalAs( UnmanagedType.U1 )] bool bAllowed ); + + #endregion + internal void AllowStartRequest( HHTMLBrowser unBrowserHandle, [MarshalAs( UnmanagedType.U1 )] bool bAllowed ) + { + _AllowStartRequest( Self, unBrowserHandle, bAllowed ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_JSDialogResponse")] + private static extern void _JSDialogResponse( IntPtr self, HHTMLBrowser unBrowserHandle, [MarshalAs( UnmanagedType.U1 )] bool bResult ); + + #endregion + internal void JSDialogResponse( HHTMLBrowser unBrowserHandle, [MarshalAs( UnmanagedType.U1 )] bool bResult ) + { + _JSDialogResponse( Self, unBrowserHandle, bResult ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTMLSurface_FileLoadDialogResponse")] + private static extern void _FileLoadDialogResponse( IntPtr self, HHTMLBrowser unBrowserHandle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchSelectedFiles ); + + #endregion + internal void FileLoadDialogResponse( HHTMLBrowser unBrowserHandle, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchSelectedFiles ) + { + _FileLoadDialogResponse( Self, unBrowserHandle, pchSelectedFiles ); + } + + } +} diff --git a/Facepunch.Steamworks/Generated/Interfaces/ISteamHTTP.cs b/Facepunch.Steamworks/Generated/Interfaces/ISteamHTTP.cs new file mode 100644 index 0000000..36e1821 --- /dev/null +++ b/Facepunch.Steamworks/Generated/Interfaces/ISteamHTTP.cs @@ -0,0 +1,319 @@ +using System; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading.Tasks; +using Steamworks.Data; + + +namespace Steamworks +{ + internal class ISteamHTTP : SteamInterface + { + public override IntPtr GetInterfacePointer() => GetApi.SteamHTTP(); + + + internal ISteamHTTP() + { + SetupInterface(); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTTP_CreateHTTPRequest")] + private static extern HTTPRequestHandle _CreateHTTPRequest( IntPtr self, HTTPMethod eHTTPRequestMethod, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchAbsoluteURL ); + + #endregion + internal HTTPRequestHandle CreateHTTPRequest( HTTPMethod eHTTPRequestMethod, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchAbsoluteURL ) + { + var returnValue = _CreateHTTPRequest( Self, eHTTPRequestMethod, pchAbsoluteURL ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTTP_SetHTTPRequestContextValue")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SetHTTPRequestContextValue( IntPtr self, HTTPRequestHandle hRequest, ulong ulContextValue ); + + #endregion + internal bool SetHTTPRequestContextValue( HTTPRequestHandle hRequest, ulong ulContextValue ) + { + var returnValue = _SetHTTPRequestContextValue( Self, hRequest, ulContextValue ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTTP_SetHTTPRequestNetworkActivityTimeout")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SetHTTPRequestNetworkActivityTimeout( IntPtr self, HTTPRequestHandle hRequest, uint unTimeoutSeconds ); + + #endregion + internal bool SetHTTPRequestNetworkActivityTimeout( HTTPRequestHandle hRequest, uint unTimeoutSeconds ) + { + var returnValue = _SetHTTPRequestNetworkActivityTimeout( Self, hRequest, unTimeoutSeconds ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTTP_SetHTTPRequestHeaderValue")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SetHTTPRequestHeaderValue( IntPtr self, HTTPRequestHandle hRequest, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchHeaderName, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchHeaderValue ); + + #endregion + internal bool SetHTTPRequestHeaderValue( HTTPRequestHandle hRequest, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchHeaderName, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchHeaderValue ) + { + var returnValue = _SetHTTPRequestHeaderValue( Self, hRequest, pchHeaderName, pchHeaderValue ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTTP_SetHTTPRequestGetOrPostParameter")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SetHTTPRequestGetOrPostParameter( IntPtr self, HTTPRequestHandle hRequest, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchParamName, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchParamValue ); + + #endregion + internal bool SetHTTPRequestGetOrPostParameter( HTTPRequestHandle hRequest, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchParamName, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchParamValue ) + { + var returnValue = _SetHTTPRequestGetOrPostParameter( Self, hRequest, pchParamName, pchParamValue ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTTP_SendHTTPRequest")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SendHTTPRequest( IntPtr self, HTTPRequestHandle hRequest, ref SteamAPICall_t pCallHandle ); + + #endregion + internal bool SendHTTPRequest( HTTPRequestHandle hRequest, ref SteamAPICall_t pCallHandle ) + { + var returnValue = _SendHTTPRequest( Self, hRequest, ref pCallHandle ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTTP_SendHTTPRequestAndStreamResponse")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SendHTTPRequestAndStreamResponse( IntPtr self, HTTPRequestHandle hRequest, ref SteamAPICall_t pCallHandle ); + + #endregion + internal bool SendHTTPRequestAndStreamResponse( HTTPRequestHandle hRequest, ref SteamAPICall_t pCallHandle ) + { + var returnValue = _SendHTTPRequestAndStreamResponse( Self, hRequest, ref pCallHandle ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTTP_DeferHTTPRequest")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _DeferHTTPRequest( IntPtr self, HTTPRequestHandle hRequest ); + + #endregion + internal bool DeferHTTPRequest( HTTPRequestHandle hRequest ) + { + var returnValue = _DeferHTTPRequest( Self, hRequest ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTTP_PrioritizeHTTPRequest")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _PrioritizeHTTPRequest( IntPtr self, HTTPRequestHandle hRequest ); + + #endregion + internal bool PrioritizeHTTPRequest( HTTPRequestHandle hRequest ) + { + var returnValue = _PrioritizeHTTPRequest( Self, hRequest ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTTP_GetHTTPResponseHeaderSize")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _GetHTTPResponseHeaderSize( IntPtr self, HTTPRequestHandle hRequest, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchHeaderName, ref uint unResponseHeaderSize ); + + #endregion + internal bool GetHTTPResponseHeaderSize( HTTPRequestHandle hRequest, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchHeaderName, ref uint unResponseHeaderSize ) + { + var returnValue = _GetHTTPResponseHeaderSize( Self, hRequest, pchHeaderName, ref unResponseHeaderSize ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTTP_GetHTTPResponseHeaderValue")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _GetHTTPResponseHeaderValue( IntPtr self, HTTPRequestHandle hRequest, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchHeaderName, ref byte pHeaderValueBuffer, uint unBufferSize ); + + #endregion + internal bool GetHTTPResponseHeaderValue( HTTPRequestHandle hRequest, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchHeaderName, ref byte pHeaderValueBuffer, uint unBufferSize ) + { + var returnValue = _GetHTTPResponseHeaderValue( Self, hRequest, pchHeaderName, ref pHeaderValueBuffer, unBufferSize ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTTP_GetHTTPResponseBodySize")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _GetHTTPResponseBodySize( IntPtr self, HTTPRequestHandle hRequest, ref uint unBodySize ); + + #endregion + internal bool GetHTTPResponseBodySize( HTTPRequestHandle hRequest, ref uint unBodySize ) + { + var returnValue = _GetHTTPResponseBodySize( Self, hRequest, ref unBodySize ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTTP_GetHTTPResponseBodyData")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _GetHTTPResponseBodyData( IntPtr self, HTTPRequestHandle hRequest, ref byte pBodyDataBuffer, uint unBufferSize ); + + #endregion + internal bool GetHTTPResponseBodyData( HTTPRequestHandle hRequest, ref byte pBodyDataBuffer, uint unBufferSize ) + { + var returnValue = _GetHTTPResponseBodyData( Self, hRequest, ref pBodyDataBuffer, unBufferSize ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTTP_GetHTTPStreamingResponseBodyData")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _GetHTTPStreamingResponseBodyData( IntPtr self, HTTPRequestHandle hRequest, uint cOffset, ref byte pBodyDataBuffer, uint unBufferSize ); + + #endregion + internal bool GetHTTPStreamingResponseBodyData( HTTPRequestHandle hRequest, uint cOffset, ref byte pBodyDataBuffer, uint unBufferSize ) + { + var returnValue = _GetHTTPStreamingResponseBodyData( Self, hRequest, cOffset, ref pBodyDataBuffer, unBufferSize ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTTP_ReleaseHTTPRequest")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _ReleaseHTTPRequest( IntPtr self, HTTPRequestHandle hRequest ); + + #endregion + internal bool ReleaseHTTPRequest( HTTPRequestHandle hRequest ) + { + var returnValue = _ReleaseHTTPRequest( Self, hRequest ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTTP_GetHTTPDownloadProgressPct")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _GetHTTPDownloadProgressPct( IntPtr self, HTTPRequestHandle hRequest, ref float pflPercentOut ); + + #endregion + internal bool GetHTTPDownloadProgressPct( HTTPRequestHandle hRequest, ref float pflPercentOut ) + { + var returnValue = _GetHTTPDownloadProgressPct( Self, hRequest, ref pflPercentOut ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTTP_SetHTTPRequestRawPostBody")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SetHTTPRequestRawPostBody( IntPtr self, HTTPRequestHandle hRequest, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchContentType, [In,Out] byte[] pubBody, uint unBodyLen ); + + #endregion + internal bool SetHTTPRequestRawPostBody( HTTPRequestHandle hRequest, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchContentType, [In,Out] byte[] pubBody, uint unBodyLen ) + { + var returnValue = _SetHTTPRequestRawPostBody( Self, hRequest, pchContentType, pubBody, unBodyLen ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTTP_CreateCookieContainer")] + private static extern HTTPCookieContainerHandle _CreateCookieContainer( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bAllowResponsesToModify ); + + #endregion + internal HTTPCookieContainerHandle CreateCookieContainer( [MarshalAs( UnmanagedType.U1 )] bool bAllowResponsesToModify ) + { + var returnValue = _CreateCookieContainer( Self, bAllowResponsesToModify ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTTP_ReleaseCookieContainer")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _ReleaseCookieContainer( IntPtr self, HTTPCookieContainerHandle hCookieContainer ); + + #endregion + internal bool ReleaseCookieContainer( HTTPCookieContainerHandle hCookieContainer ) + { + var returnValue = _ReleaseCookieContainer( Self, hCookieContainer ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTTP_SetCookie")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SetCookie( IntPtr self, HTTPCookieContainerHandle hCookieContainer, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchHost, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchUrl, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchCookie ); + + #endregion + internal bool SetCookie( HTTPCookieContainerHandle hCookieContainer, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchHost, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchUrl, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchCookie ) + { + var returnValue = _SetCookie( Self, hCookieContainer, pchHost, pchUrl, pchCookie ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTTP_SetHTTPRequestCookieContainer")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SetHTTPRequestCookieContainer( IntPtr self, HTTPRequestHandle hRequest, HTTPCookieContainerHandle hCookieContainer ); + + #endregion + internal bool SetHTTPRequestCookieContainer( HTTPRequestHandle hRequest, HTTPCookieContainerHandle hCookieContainer ) + { + var returnValue = _SetHTTPRequestCookieContainer( Self, hRequest, hCookieContainer ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTTP_SetHTTPRequestUserAgentInfo")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SetHTTPRequestUserAgentInfo( IntPtr self, HTTPRequestHandle hRequest, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchUserAgentInfo ); + + #endregion + internal bool SetHTTPRequestUserAgentInfo( HTTPRequestHandle hRequest, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchUserAgentInfo ) + { + var returnValue = _SetHTTPRequestUserAgentInfo( Self, hRequest, pchUserAgentInfo ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTTP_SetHTTPRequestRequiresVerifiedCertificate")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SetHTTPRequestRequiresVerifiedCertificate( IntPtr self, HTTPRequestHandle hRequest, [MarshalAs( UnmanagedType.U1 )] bool bRequireVerifiedCertificate ); + + #endregion + internal bool SetHTTPRequestRequiresVerifiedCertificate( HTTPRequestHandle hRequest, [MarshalAs( UnmanagedType.U1 )] bool bRequireVerifiedCertificate ) + { + var returnValue = _SetHTTPRequestRequiresVerifiedCertificate( Self, hRequest, bRequireVerifiedCertificate ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTTP_SetHTTPRequestAbsoluteTimeoutMS")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SetHTTPRequestAbsoluteTimeoutMS( IntPtr self, HTTPRequestHandle hRequest, uint unMilliseconds ); + + #endregion + internal bool SetHTTPRequestAbsoluteTimeoutMS( HTTPRequestHandle hRequest, uint unMilliseconds ) + { + var returnValue = _SetHTTPRequestAbsoluteTimeoutMS( Self, hRequest, unMilliseconds ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamHTTP_GetHTTPRequestWasTimedOut")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _GetHTTPRequestWasTimedOut( IntPtr self, HTTPRequestHandle hRequest, [MarshalAs( UnmanagedType.U1 )] ref bool pbWasTimedOut ); + + #endregion + internal bool GetHTTPRequestWasTimedOut( HTTPRequestHandle hRequest, [MarshalAs( UnmanagedType.U1 )] ref bool pbWasTimedOut ) + { + var returnValue = _GetHTTPRequestWasTimedOut( Self, hRequest, ref pbWasTimedOut ); + return returnValue; + } + + } +} diff --git a/Facepunch.Steamworks/Generated/Interfaces/ISteamInput.cs b/Facepunch.Steamworks/Generated/Interfaces/ISteamInput.cs index 0ac4689..64bbd9b 100644 --- a/Facepunch.Steamworks/Generated/Interfaces/ISteamInput.cs +++ b/Facepunch.Steamworks/Generated/Interfaces/ISteamInput.cs @@ -373,5 +373,28 @@ namespace Steamworks return returnValue; } + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamInput_GetDeviceBindingRevision")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _GetDeviceBindingRevision( IntPtr self, InputHandle_t inputHandle, ref int pMajor, ref int pMinor ); + + #endregion + internal bool GetDeviceBindingRevision( InputHandle_t inputHandle, ref int pMajor, ref int pMinor ) + { + var returnValue = _GetDeviceBindingRevision( Self, inputHandle, ref pMajor, ref pMinor ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamInput_GetRemotePlaySessionID")] + private static extern uint _GetRemotePlaySessionID( IntPtr self, InputHandle_t inputHandle ); + + #endregion + internal uint GetRemotePlaySessionID( InputHandle_t inputHandle ) + { + var returnValue = _GetRemotePlaySessionID( Self, inputHandle ); + return returnValue; + } + } } diff --git a/Facepunch.Steamworks/Generated/Interfaces/ISteamInventory.cs b/Facepunch.Steamworks/Generated/Interfaces/ISteamInventory.cs index b17ec95..409e912 100644 --- a/Facepunch.Steamworks/Generated/Interfaces/ISteamInventory.cs +++ b/Facepunch.Steamworks/Generated/Interfaces/ISteamInventory.cs @@ -407,38 +407,38 @@ namespace Steamworks } #region FunctionMeta - [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamInventory_SetProperty0")] + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamInventory_SetProperty")] [return: MarshalAs( UnmanagedType.I1 )] - private static extern bool _SetProperty0( IntPtr self, SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchPropertyName, [MarshalAs( UnmanagedType.U1 )] bool bValue ); + private static extern bool _SetProperty( IntPtr self, SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchPropertyName, [MarshalAs( UnmanagedType.U1 )] bool bValue ); #endregion - internal bool SetProperty0( SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchPropertyName, [MarshalAs( UnmanagedType.U1 )] bool bValue ) + internal bool SetProperty( SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchPropertyName, [MarshalAs( UnmanagedType.U1 )] bool bValue ) { - var returnValue = _SetProperty0( Self, handle, nItemID, pchPropertyName, bValue ); + var returnValue = _SetProperty( Self, handle, nItemID, pchPropertyName, bValue ); return returnValue; } #region FunctionMeta - [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamInventory_SetProperty1")] + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamInventory_SetProperty")] [return: MarshalAs( UnmanagedType.I1 )] - private static extern bool _SetProperty1( IntPtr self, SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchPropertyName, long nValue ); + private static extern bool _SetProperty( IntPtr self, SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchPropertyName, long nValue ); #endregion - internal bool SetProperty1( SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchPropertyName, long nValue ) + internal bool SetProperty( SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchPropertyName, long nValue ) { - var returnValue = _SetProperty1( Self, handle, nItemID, pchPropertyName, nValue ); + var returnValue = _SetProperty( Self, handle, nItemID, pchPropertyName, nValue ); return returnValue; } #region FunctionMeta - [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamInventory_SetProperty2")] + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamInventory_SetProperty")] [return: MarshalAs( UnmanagedType.I1 )] - private static extern bool _SetProperty2( IntPtr self, SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchPropertyName, float flValue ); + private static extern bool _SetProperty( IntPtr self, SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchPropertyName, float flValue ); #endregion - internal bool SetProperty2( SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchPropertyName, float flValue ) + internal bool SetProperty( SteamInventoryUpdateHandle_t handle, InventoryItemId nItemID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchPropertyName, float flValue ) { - var returnValue = _SetProperty2( Self, handle, nItemID, pchPropertyName, flValue ); + var returnValue = _SetProperty( Self, handle, nItemID, pchPropertyName, flValue ); return returnValue; } diff --git a/Facepunch.Steamworks/Generated/Interfaces/ISteamMatchmakingPingResponse.cs b/Facepunch.Steamworks/Generated/Interfaces/ISteamMatchmakingPingResponse.cs new file mode 100644 index 0000000..36e807c --- /dev/null +++ b/Facepunch.Steamworks/Generated/Interfaces/ISteamMatchmakingPingResponse.cs @@ -0,0 +1,41 @@ +using System; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading.Tasks; +using Steamworks.Data; + + +namespace Steamworks +{ + internal class ISteamMatchmakingPingResponse : SteamInterface + { + public override IntPtr GetInterfacePointer() => GetApi.SteamMatchmakingPingResponse(); + + + internal ISteamMatchmakingPingResponse() + { + SetupInterface(); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMatchmakingPingResponse_ServerResponded")] + private static extern void _ServerResponded( IntPtr self, ref gameserveritem_t server ); + + #endregion + internal void ServerResponded( ref gameserveritem_t server ) + { + _ServerResponded( Self, ref server ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMatchmakingPingResponse_ServerFailedToRespond")] + private static extern void _ServerFailedToRespond( IntPtr self ); + + #endregion + internal void ServerFailedToRespond() + { + _ServerFailedToRespond( Self ); + } + + } +} diff --git a/Facepunch.Steamworks/Generated/Interfaces/ISteamMatchmakingPlayersResponse.cs b/Facepunch.Steamworks/Generated/Interfaces/ISteamMatchmakingPlayersResponse.cs new file mode 100644 index 0000000..19d0144 --- /dev/null +++ b/Facepunch.Steamworks/Generated/Interfaces/ISteamMatchmakingPlayersResponse.cs @@ -0,0 +1,51 @@ +using System; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading.Tasks; +using Steamworks.Data; + + +namespace Steamworks +{ + internal class ISteamMatchmakingPlayersResponse : SteamInterface + { + public override IntPtr GetInterfacePointer() => GetApi.SteamMatchmakingPlayersResponse(); + + + internal ISteamMatchmakingPlayersResponse() + { + SetupInterface(); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMatchmakingPlayersResponse_AddPlayerToList")] + private static extern void _AddPlayerToList( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchName, int nScore, float flTimePlayed ); + + #endregion + internal void AddPlayerToList( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchName, int nScore, float flTimePlayed ) + { + _AddPlayerToList( Self, pchName, nScore, flTimePlayed ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMatchmakingPlayersResponse_PlayersFailedToRespond")] + private static extern void _PlayersFailedToRespond( IntPtr self ); + + #endregion + internal void PlayersFailedToRespond() + { + _PlayersFailedToRespond( Self ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMatchmakingPlayersResponse_PlayersRefreshComplete")] + private static extern void _PlayersRefreshComplete( IntPtr self ); + + #endregion + internal void PlayersRefreshComplete() + { + _PlayersRefreshComplete( Self ); + } + + } +} diff --git a/Facepunch.Steamworks/Generated/Interfaces/ISteamMatchmakingRulesResponse.cs b/Facepunch.Steamworks/Generated/Interfaces/ISteamMatchmakingRulesResponse.cs new file mode 100644 index 0000000..bbebaa4 --- /dev/null +++ b/Facepunch.Steamworks/Generated/Interfaces/ISteamMatchmakingRulesResponse.cs @@ -0,0 +1,51 @@ +using System; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading.Tasks; +using Steamworks.Data; + + +namespace Steamworks +{ + internal class ISteamMatchmakingRulesResponse : SteamInterface + { + public override IntPtr GetInterfacePointer() => GetApi.SteamMatchmakingRulesResponse(); + + + internal ISteamMatchmakingRulesResponse() + { + SetupInterface(); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMatchmakingRulesResponse_RulesResponded")] + private static extern void _RulesResponded( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchRule, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchValue ); + + #endregion + internal void RulesResponded( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchRule, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchValue ) + { + _RulesResponded( Self, pchRule, pchValue ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMatchmakingRulesResponse_RulesFailedToRespond")] + private static extern void _RulesFailedToRespond( IntPtr self ); + + #endregion + internal void RulesFailedToRespond() + { + _RulesFailedToRespond( Self ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMatchmakingRulesResponse_RulesRefreshComplete")] + private static extern void _RulesRefreshComplete( IntPtr self ); + + #endregion + internal void RulesRefreshComplete() + { + _RulesRefreshComplete( Self ); + } + + } +} diff --git a/Facepunch.Steamworks/Generated/Interfaces/ISteamMatchmakingServerListResponse.cs b/Facepunch.Steamworks/Generated/Interfaces/ISteamMatchmakingServerListResponse.cs new file mode 100644 index 0000000..68a571e --- /dev/null +++ b/Facepunch.Steamworks/Generated/Interfaces/ISteamMatchmakingServerListResponse.cs @@ -0,0 +1,51 @@ +using System; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading.Tasks; +using Steamworks.Data; + + +namespace Steamworks +{ + internal class ISteamMatchmakingServerListResponse : SteamInterface + { + public override IntPtr GetInterfacePointer() => GetApi.SteamMatchmakingServerListResponse(); + + + internal ISteamMatchmakingServerListResponse() + { + SetupInterface(); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMatchmakingServerListResponse_ServerResponded")] + private static extern void _ServerResponded( IntPtr self, HServerListRequest hRequest, int iServer ); + + #endregion + internal void ServerResponded( HServerListRequest hRequest, int iServer ) + { + _ServerResponded( Self, hRequest, iServer ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMatchmakingServerListResponse_ServerFailedToRespond")] + private static extern void _ServerFailedToRespond( IntPtr self, HServerListRequest hRequest, int iServer ); + + #endregion + internal void ServerFailedToRespond( HServerListRequest hRequest, int iServer ) + { + _ServerFailedToRespond( Self, hRequest, iServer ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMatchmakingServerListResponse_RefreshComplete")] + private static extern void _RefreshComplete( IntPtr self, HServerListRequest hRequest, MatchMakingServerResponse response ); + + #endregion + internal void RefreshComplete( HServerListRequest hRequest, MatchMakingServerResponse response ) + { + _RefreshComplete( Self, hRequest, response ); + } + + } +} diff --git a/Facepunch.Steamworks/Generated/Interfaces/ISteamMusicRemote.cs b/Facepunch.Steamworks/Generated/Interfaces/ISteamMusicRemote.cs new file mode 100644 index 0000000..32e70f2 --- /dev/null +++ b/Facepunch.Steamworks/Generated/Interfaces/ISteamMusicRemote.cs @@ -0,0 +1,405 @@ +using System; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading.Tasks; +using Steamworks.Data; + + +namespace Steamworks +{ + internal class ISteamMusicRemote : SteamInterface + { + public override IntPtr GetInterfacePointer() => GetApi.SteamMusicRemote(); + + + internal ISteamMusicRemote() + { + SetupInterface(); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_RegisterSteamMusicRemote")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _RegisterSteamMusicRemote( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchName ); + + #endregion + internal bool RegisterSteamMusicRemote( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchName ) + { + var returnValue = _RegisterSteamMusicRemote( Self, pchName ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_DeregisterSteamMusicRemote")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _DeregisterSteamMusicRemote( IntPtr self ); + + #endregion + internal bool DeregisterSteamMusicRemote() + { + var returnValue = _DeregisterSteamMusicRemote( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_BIsCurrentMusicRemote")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _BIsCurrentMusicRemote( IntPtr self ); + + #endregion + internal bool BIsCurrentMusicRemote() + { + var returnValue = _BIsCurrentMusicRemote( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_BActivationSuccess")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _BActivationSuccess( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bValue ); + + #endregion + internal bool BActivationSuccess( [MarshalAs( UnmanagedType.U1 )] bool bValue ) + { + var returnValue = _BActivationSuccess( Self, bValue ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_SetDisplayName")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SetDisplayName( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchDisplayName ); + + #endregion + internal bool SetDisplayName( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchDisplayName ) + { + var returnValue = _SetDisplayName( Self, pchDisplayName ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_SetPNGIcon_64x64")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SetPNGIcon_64x64( IntPtr self, IntPtr pvBuffer, uint cbBufferLength ); + + #endregion + internal bool SetPNGIcon_64x64( IntPtr pvBuffer, uint cbBufferLength ) + { + var returnValue = _SetPNGIcon_64x64( Self, pvBuffer, cbBufferLength ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_EnablePlayPrevious")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _EnablePlayPrevious( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bValue ); + + #endregion + internal bool EnablePlayPrevious( [MarshalAs( UnmanagedType.U1 )] bool bValue ) + { + var returnValue = _EnablePlayPrevious( Self, bValue ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_EnablePlayNext")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _EnablePlayNext( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bValue ); + + #endregion + internal bool EnablePlayNext( [MarshalAs( UnmanagedType.U1 )] bool bValue ) + { + var returnValue = _EnablePlayNext( Self, bValue ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_EnableShuffled")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _EnableShuffled( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bValue ); + + #endregion + internal bool EnableShuffled( [MarshalAs( UnmanagedType.U1 )] bool bValue ) + { + var returnValue = _EnableShuffled( Self, bValue ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_EnableLooped")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _EnableLooped( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bValue ); + + #endregion + internal bool EnableLooped( [MarshalAs( UnmanagedType.U1 )] bool bValue ) + { + var returnValue = _EnableLooped( Self, bValue ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_EnableQueue")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _EnableQueue( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bValue ); + + #endregion + internal bool EnableQueue( [MarshalAs( UnmanagedType.U1 )] bool bValue ) + { + var returnValue = _EnableQueue( Self, bValue ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_EnablePlaylists")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _EnablePlaylists( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bValue ); + + #endregion + internal bool EnablePlaylists( [MarshalAs( UnmanagedType.U1 )] bool bValue ) + { + var returnValue = _EnablePlaylists( Self, bValue ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_UpdatePlaybackStatus")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _UpdatePlaybackStatus( IntPtr self, MusicStatus nStatus ); + + #endregion + internal bool UpdatePlaybackStatus( MusicStatus nStatus ) + { + var returnValue = _UpdatePlaybackStatus( Self, nStatus ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_UpdateShuffled")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _UpdateShuffled( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bValue ); + + #endregion + internal bool UpdateShuffled( [MarshalAs( UnmanagedType.U1 )] bool bValue ) + { + var returnValue = _UpdateShuffled( Self, bValue ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_UpdateLooped")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _UpdateLooped( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bValue ); + + #endregion + internal bool UpdateLooped( [MarshalAs( UnmanagedType.U1 )] bool bValue ) + { + var returnValue = _UpdateLooped( Self, bValue ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_UpdateVolume")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _UpdateVolume( IntPtr self, float flValue ); + + #endregion + internal bool UpdateVolume( float flValue ) + { + var returnValue = _UpdateVolume( Self, flValue ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_CurrentEntryWillChange")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _CurrentEntryWillChange( IntPtr self ); + + #endregion + internal bool CurrentEntryWillChange() + { + var returnValue = _CurrentEntryWillChange( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_CurrentEntryIsAvailable")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _CurrentEntryIsAvailable( IntPtr self, [MarshalAs( UnmanagedType.U1 )] bool bAvailable ); + + #endregion + internal bool CurrentEntryIsAvailable( [MarshalAs( UnmanagedType.U1 )] bool bAvailable ) + { + var returnValue = _CurrentEntryIsAvailable( Self, bAvailable ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_UpdateCurrentEntryText")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _UpdateCurrentEntryText( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchText ); + + #endregion + internal bool UpdateCurrentEntryText( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchText ) + { + var returnValue = _UpdateCurrentEntryText( Self, pchText ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_UpdateCurrentEntryElapsedSeconds")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _UpdateCurrentEntryElapsedSeconds( IntPtr self, int nValue ); + + #endregion + internal bool UpdateCurrentEntryElapsedSeconds( int nValue ) + { + var returnValue = _UpdateCurrentEntryElapsedSeconds( Self, nValue ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_UpdateCurrentEntryCoverArt")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _UpdateCurrentEntryCoverArt( IntPtr self, IntPtr pvBuffer, uint cbBufferLength ); + + #endregion + internal bool UpdateCurrentEntryCoverArt( IntPtr pvBuffer, uint cbBufferLength ) + { + var returnValue = _UpdateCurrentEntryCoverArt( Self, pvBuffer, cbBufferLength ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_CurrentEntryDidChange")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _CurrentEntryDidChange( IntPtr self ); + + #endregion + internal bool CurrentEntryDidChange() + { + var returnValue = _CurrentEntryDidChange( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_QueueWillChange")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _QueueWillChange( IntPtr self ); + + #endregion + internal bool QueueWillChange() + { + var returnValue = _QueueWillChange( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_ResetQueueEntries")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _ResetQueueEntries( IntPtr self ); + + #endregion + internal bool ResetQueueEntries() + { + var returnValue = _ResetQueueEntries( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_SetQueueEntry")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SetQueueEntry( IntPtr self, int nID, int nPosition, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchEntryText ); + + #endregion + internal bool SetQueueEntry( int nID, int nPosition, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchEntryText ) + { + var returnValue = _SetQueueEntry( Self, nID, nPosition, pchEntryText ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_SetCurrentQueueEntry")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SetCurrentQueueEntry( IntPtr self, int nID ); + + #endregion + internal bool SetCurrentQueueEntry( int nID ) + { + var returnValue = _SetCurrentQueueEntry( Self, nID ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_QueueDidChange")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _QueueDidChange( IntPtr self ); + + #endregion + internal bool QueueDidChange() + { + var returnValue = _QueueDidChange( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_PlaylistWillChange")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _PlaylistWillChange( IntPtr self ); + + #endregion + internal bool PlaylistWillChange() + { + var returnValue = _PlaylistWillChange( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_ResetPlaylistEntries")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _ResetPlaylistEntries( IntPtr self ); + + #endregion + internal bool ResetPlaylistEntries() + { + var returnValue = _ResetPlaylistEntries( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_SetPlaylistEntry")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SetPlaylistEntry( IntPtr self, int nID, int nPosition, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchEntryText ); + + #endregion + internal bool SetPlaylistEntry( int nID, int nPosition, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchEntryText ) + { + var returnValue = _SetPlaylistEntry( Self, nID, nPosition, pchEntryText ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_SetCurrentPlaylistEntry")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SetCurrentPlaylistEntry( IntPtr self, int nID ); + + #endregion + internal bool SetCurrentPlaylistEntry( int nID ) + { + var returnValue = _SetCurrentPlaylistEntry( Self, nID ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamMusicRemote_PlaylistDidChange")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _PlaylistDidChange( IntPtr self ); + + #endregion + internal bool PlaylistDidChange() + { + var returnValue = _PlaylistDidChange( Self ); + return returnValue; + } + + } +} diff --git a/Facepunch.Steamworks/Generated/Interfaces/ISteamNetworking.cs b/Facepunch.Steamworks/Generated/Interfaces/ISteamNetworking.cs index 1806ad3..f3a67a3 100644 --- a/Facepunch.Steamworks/Generated/Interfaces/ISteamNetworking.cs +++ b/Facepunch.Steamworks/Generated/Interfaces/ISteamNetworking.cs @@ -115,10 +115,10 @@ namespace Steamworks #region FunctionMeta [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworking_CreateListenSocket")] - private static extern SNetListenSocket_t _CreateListenSocket( IntPtr self, int nVirtualP2PPort, uint nIP, ushort nPort, [MarshalAs( UnmanagedType.U1 )] bool bAllowUseOfPacketRelay ); + private static extern SNetListenSocket_t _CreateListenSocket( IntPtr self, int nVirtualP2PPort, SteamIPAddress_t nIP, ushort nPort, [MarshalAs( UnmanagedType.U1 )] bool bAllowUseOfPacketRelay ); #endregion - internal SNetListenSocket_t CreateListenSocket( int nVirtualP2PPort, uint nIP, ushort nPort, [MarshalAs( UnmanagedType.U1 )] bool bAllowUseOfPacketRelay ) + internal SNetListenSocket_t CreateListenSocket( int nVirtualP2PPort, SteamIPAddress_t nIP, ushort nPort, [MarshalAs( UnmanagedType.U1 )] bool bAllowUseOfPacketRelay ) { var returnValue = _CreateListenSocket( Self, nVirtualP2PPort, nIP, nPort, bAllowUseOfPacketRelay ); return returnValue; @@ -137,10 +137,10 @@ namespace Steamworks #region FunctionMeta [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworking_CreateConnectionSocket")] - private static extern SNetSocket_t _CreateConnectionSocket( IntPtr self, uint nIP, ushort nPort, int nTimeoutSec ); + private static extern SNetSocket_t _CreateConnectionSocket( IntPtr self, SteamIPAddress_t nIP, ushort nPort, int nTimeoutSec ); #endregion - internal SNetSocket_t CreateConnectionSocket( uint nIP, ushort nPort, int nTimeoutSec ) + internal SNetSocket_t CreateConnectionSocket( SteamIPAddress_t nIP, ushort nPort, int nTimeoutSec ) { var returnValue = _CreateConnectionSocket( Self, nIP, nPort, nTimeoutSec ); return returnValue; @@ -233,10 +233,10 @@ namespace Steamworks #region FunctionMeta [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworking_GetSocketInfo")] [return: MarshalAs( UnmanagedType.I1 )] - private static extern bool _GetSocketInfo( IntPtr self, SNetSocket_t hSocket, ref SteamId pSteamIDRemote, ref int peSocketStatus, ref uint punIPRemote, ref ushort punPortRemote ); + private static extern bool _GetSocketInfo( IntPtr self, SNetSocket_t hSocket, ref SteamId pSteamIDRemote, ref int peSocketStatus, ref SteamIPAddress_t punIPRemote, ref ushort punPortRemote ); #endregion - internal bool GetSocketInfo( SNetSocket_t hSocket, ref SteamId pSteamIDRemote, ref int peSocketStatus, ref uint punIPRemote, ref ushort punPortRemote ) + internal bool GetSocketInfo( SNetSocket_t hSocket, ref SteamId pSteamIDRemote, ref int peSocketStatus, ref SteamIPAddress_t punIPRemote, ref ushort punPortRemote ) { var returnValue = _GetSocketInfo( Self, hSocket, ref pSteamIDRemote, ref peSocketStatus, ref punIPRemote, ref punPortRemote ); return returnValue; @@ -245,10 +245,10 @@ namespace Steamworks #region FunctionMeta [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworking_GetListenSocketInfo")] [return: MarshalAs( UnmanagedType.I1 )] - private static extern bool _GetListenSocketInfo( IntPtr self, SNetListenSocket_t hListenSocket, ref uint pnIP, ref ushort pnPort ); + private static extern bool _GetListenSocketInfo( IntPtr self, SNetListenSocket_t hListenSocket, ref SteamIPAddress_t pnIP, ref ushort pnPort ); #endregion - internal bool GetListenSocketInfo( SNetListenSocket_t hListenSocket, ref uint pnIP, ref ushort pnPort ) + internal bool GetListenSocketInfo( SNetListenSocket_t hListenSocket, ref SteamIPAddress_t pnIP, ref ushort pnPort ) { var returnValue = _GetListenSocketInfo( Self, hListenSocket, ref pnIP, ref pnPort ); return returnValue; diff --git a/Facepunch.Steamworks/Generated/Interfaces/ISteamNetworkingConnectionCustomSignaling.cs b/Facepunch.Steamworks/Generated/Interfaces/ISteamNetworkingConnectionCustomSignaling.cs new file mode 100644 index 0000000..47babaf --- /dev/null +++ b/Facepunch.Steamworks/Generated/Interfaces/ISteamNetworkingConnectionCustomSignaling.cs @@ -0,0 +1,43 @@ +using System; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading.Tasks; +using Steamworks.Data; + + +namespace Steamworks +{ + internal class ISteamNetworkingConnectionCustomSignaling : SteamInterface + { + public override IntPtr GetInterfacePointer() => GetApi.SteamNetworkingConnectionCustomSignaling(); + + + internal ISteamNetworkingConnectionCustomSignaling() + { + SetupInterface(); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingConnectionCustomSignaling_SendSignal")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SendSignal( IntPtr self, Connection hConn, ref ConnectionInfo info, IntPtr pMsg, int cbMsg ); + + #endregion + internal bool SendSignal( Connection hConn, ref ConnectionInfo info, IntPtr pMsg, int cbMsg ) + { + var returnValue = _SendSignal( Self, hConn, ref info, pMsg, cbMsg ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingConnectionCustomSignaling_Release")] + private static extern void _Release( IntPtr self ); + + #endregion + internal void Release() + { + _Release( Self ); + } + + } +} diff --git a/Facepunch.Steamworks/Generated/Interfaces/ISteamNetworkingCustomSignalingRecvContext.cs b/Facepunch.Steamworks/Generated/Interfaces/ISteamNetworkingCustomSignalingRecvContext.cs new file mode 100644 index 0000000..4bb9ee4 --- /dev/null +++ b/Facepunch.Steamworks/Generated/Interfaces/ISteamNetworkingCustomSignalingRecvContext.cs @@ -0,0 +1,42 @@ +using System; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading.Tasks; +using Steamworks.Data; + + +namespace Steamworks +{ + internal class ISteamNetworkingCustomSignalingRecvContext : SteamInterface + { + public override IntPtr GetInterfacePointer() => GetApi.SteamNetworkingCustomSignalingRecvContext(); + + + internal ISteamNetworkingCustomSignalingRecvContext() + { + SetupInterface(); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingCustomSignalingRecvContext_OnConnectRequest")] + private static extern IntPtr _OnConnectRequest( IntPtr self, Connection hConn, ref NetIdentity identityPeer ); + + #endregion + internal IntPtr OnConnectRequest( Connection hConn, ref NetIdentity identityPeer ) + { + var returnValue = _OnConnectRequest( Self, hConn, ref identityPeer ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingCustomSignalingRecvContext_SendRejectionSignal")] + private static extern void _SendRejectionSignal( IntPtr self, ref NetIdentity identityPeer, IntPtr pMsg, int cbMsg ); + + #endregion + internal void SendRejectionSignal( ref NetIdentity identityPeer, IntPtr pMsg, int cbMsg ) + { + _SendRejectionSignal( Self, ref identityPeer, pMsg, cbMsg ); + } + + } +} diff --git a/Facepunch.Steamworks/Generated/Interfaces/ISteamNetworkingSockets.cs b/Facepunch.Steamworks/Generated/Interfaces/ISteamNetworkingSockets.cs index 267f65f..dd6683d 100644 --- a/Facepunch.Steamworks/Generated/Interfaces/ISteamNetworkingSockets.cs +++ b/Facepunch.Steamworks/Generated/Interfaces/ISteamNetworkingSockets.cs @@ -17,5 +17,451 @@ namespace Steamworks SetupInterface(); } + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_CreateListenSocketIP")] + private static extern Socket _CreateListenSocketIP( IntPtr self, ref NetAddress localAddress, int nOptions, ref NetConfig_t pOptions ); + + #endregion + internal Socket CreateListenSocketIP( ref NetAddress localAddress, int nOptions, ref NetConfig_t pOptions ) + { + var returnValue = _CreateListenSocketIP( Self, ref localAddress, nOptions, ref pOptions ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_ConnectByIPAddress")] + private static extern Connection _ConnectByIPAddress( IntPtr self, ref NetAddress address, int nOptions, ref NetConfig_t pOptions ); + + #endregion + internal Connection ConnectByIPAddress( ref NetAddress address, int nOptions, ref NetConfig_t pOptions ) + { + var returnValue = _ConnectByIPAddress( Self, ref address, nOptions, ref pOptions ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_CreateListenSocketP2P")] + private static extern Socket _CreateListenSocketP2P( IntPtr self, int nVirtualPort, int nOptions, ref NetConfig_t pOptions ); + + #endregion + internal Socket CreateListenSocketP2P( int nVirtualPort, int nOptions, ref NetConfig_t pOptions ) + { + var returnValue = _CreateListenSocketP2P( Self, nVirtualPort, nOptions, ref pOptions ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_ConnectP2P")] + private static extern Connection _ConnectP2P( IntPtr self, ref NetIdentity identityRemote, int nVirtualPort, int nOptions, ref NetConfig_t pOptions ); + + #endregion + internal Connection ConnectP2P( ref NetIdentity identityRemote, int nVirtualPort, int nOptions, ref NetConfig_t pOptions ) + { + var returnValue = _ConnectP2P( Self, ref identityRemote, nVirtualPort, nOptions, ref pOptions ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_AcceptConnection")] + private static extern Result _AcceptConnection( IntPtr self, Connection hConn ); + + #endregion + internal Result AcceptConnection( Connection hConn ) + { + var returnValue = _AcceptConnection( Self, hConn ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_CloseConnection")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _CloseConnection( IntPtr self, Connection hPeer, int nReason, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pszDebug, [MarshalAs( UnmanagedType.U1 )] bool bEnableLinger ); + + #endregion + internal bool CloseConnection( Connection hPeer, int nReason, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pszDebug, [MarshalAs( UnmanagedType.U1 )] bool bEnableLinger ) + { + var returnValue = _CloseConnection( Self, hPeer, nReason, pszDebug, bEnableLinger ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_CloseListenSocket")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _CloseListenSocket( IntPtr self, Socket hSocket ); + + #endregion + internal bool CloseListenSocket( Socket hSocket ) + { + var returnValue = _CloseListenSocket( Self, hSocket ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_SetConnectionUserData")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SetConnectionUserData( IntPtr self, Connection hPeer, long nUserData ); + + #endregion + internal bool SetConnectionUserData( Connection hPeer, long nUserData ) + { + var returnValue = _SetConnectionUserData( Self, hPeer, nUserData ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_GetConnectionUserData")] + private static extern long _GetConnectionUserData( IntPtr self, Connection hPeer ); + + #endregion + internal long GetConnectionUserData( Connection hPeer ) + { + var returnValue = _GetConnectionUserData( Self, hPeer ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_SetConnectionName")] + private static extern void _SetConnectionName( IntPtr self, Connection hPeer, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pszName ); + + #endregion + internal void SetConnectionName( Connection hPeer, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pszName ) + { + _SetConnectionName( Self, hPeer, pszName ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_GetConnectionName")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _GetConnectionName( IntPtr self, Connection hPeer, IntPtr pszName, int nMaxLen ); + + #endregion + internal bool GetConnectionName( Connection hPeer, out string pszName ) + { + IntPtr mempszName = Helpers.TakeMemory(); + var returnValue = _GetConnectionName( Self, hPeer, mempszName, (1024 * 32) ); + pszName = Helpers.MemoryToString( mempszName ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_SendMessageToConnection")] + private static extern Result _SendMessageToConnection( IntPtr self, Connection hConn, IntPtr pData, uint cbData, int nSendFlags, [In,Out] long[] pOutMessageNumber ); + + #endregion + internal Result SendMessageToConnection( Connection hConn, IntPtr pData, uint cbData, int nSendFlags, [In,Out] long[] pOutMessageNumber ) + { + var returnValue = _SendMessageToConnection( Self, hConn, pData, cbData, nSendFlags, pOutMessageNumber ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_SendMessages")] + private static extern void _SendMessages( IntPtr self, int nMessages, ref SteamNetworkingMessage_t pMessages, [In,Out] long[] pOutMessageNumberOrResult ); + + #endregion + internal void SendMessages( int nMessages, ref SteamNetworkingMessage_t pMessages, [In,Out] long[] pOutMessageNumberOrResult ) + { + _SendMessages( Self, nMessages, ref pMessages, pOutMessageNumberOrResult ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_FlushMessagesOnConnection")] + private static extern Result _FlushMessagesOnConnection( IntPtr self, Connection hConn ); + + #endregion + internal Result FlushMessagesOnConnection( Connection hConn ) + { + var returnValue = _FlushMessagesOnConnection( Self, hConn ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnConnection")] + private static extern int _ReceiveMessagesOnConnection( IntPtr self, Connection hConn, IntPtr ppOutMessages, int nMaxMessages ); + + #endregion + internal int ReceiveMessagesOnConnection( Connection hConn, IntPtr ppOutMessages, int nMaxMessages ) + { + var returnValue = _ReceiveMessagesOnConnection( Self, hConn, ppOutMessages, nMaxMessages ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_GetConnectionInfo")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _GetConnectionInfo( IntPtr self, Connection hConn, ref ConnectionInfo pInfo ); + + #endregion + internal bool GetConnectionInfo( Connection hConn, ref ConnectionInfo pInfo ) + { + var returnValue = _GetConnectionInfo( Self, hConn, ref pInfo ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_GetQuickConnectionStatus")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _GetQuickConnectionStatus( IntPtr self, Connection hConn, ref SteamNetworkingQuickConnectionStatus pStats ); + + #endregion + internal bool GetQuickConnectionStatus( Connection hConn, ref SteamNetworkingQuickConnectionStatus pStats ) + { + var returnValue = _GetQuickConnectionStatus( Self, hConn, ref pStats ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_GetDetailedConnectionStatus")] + private static extern int _GetDetailedConnectionStatus( IntPtr self, Connection hConn, IntPtr pszBuf, int cbBuf ); + + #endregion + internal int GetDetailedConnectionStatus( Connection hConn, out string pszBuf ) + { + IntPtr mempszBuf = Helpers.TakeMemory(); + var returnValue = _GetDetailedConnectionStatus( Self, hConn, mempszBuf, (1024 * 32) ); + pszBuf = Helpers.MemoryToString( mempszBuf ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_GetListenSocketAddress")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _GetListenSocketAddress( IntPtr self, Socket hSocket, ref NetAddress address ); + + #endregion + internal bool GetListenSocketAddress( Socket hSocket, ref NetAddress address ) + { + var returnValue = _GetListenSocketAddress( Self, hSocket, ref address ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_CreateSocketPair")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _CreateSocketPair( IntPtr self, [In,Out] Connection[] pOutConnection1, [In,Out] Connection[] pOutConnection2, [MarshalAs( UnmanagedType.U1 )] bool bUseNetworkLoopback, ref NetIdentity pIdentity1, ref NetIdentity pIdentity2 ); + + #endregion + internal bool CreateSocketPair( [In,Out] Connection[] pOutConnection1, [In,Out] Connection[] pOutConnection2, [MarshalAs( UnmanagedType.U1 )] bool bUseNetworkLoopback, ref NetIdentity pIdentity1, ref NetIdentity pIdentity2 ) + { + var returnValue = _CreateSocketPair( Self, pOutConnection1, pOutConnection2, bUseNetworkLoopback, ref pIdentity1, ref pIdentity2 ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_GetIdentity")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _GetIdentity( IntPtr self, ref NetIdentity pIdentity ); + + #endregion + internal bool GetIdentity( ref NetIdentity pIdentity ) + { + var returnValue = _GetIdentity( Self, ref pIdentity ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_InitAuthentication")] + private static extern SteamNetworkingAvailability _InitAuthentication( IntPtr self ); + + #endregion + internal SteamNetworkingAvailability InitAuthentication() + { + var returnValue = _InitAuthentication( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_GetAuthenticationStatus")] + private static extern SteamNetworkingAvailability _GetAuthenticationStatus( IntPtr self, ref SteamNetAuthenticationStatus_t pDetails ); + + #endregion + internal SteamNetworkingAvailability GetAuthenticationStatus( ref SteamNetAuthenticationStatus_t pDetails ) + { + var returnValue = _GetAuthenticationStatus( Self, ref pDetails ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_CreatePollGroup")] + private static extern HSteamNetPollGroup _CreatePollGroup( IntPtr self ); + + #endregion + internal HSteamNetPollGroup CreatePollGroup() + { + var returnValue = _CreatePollGroup( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_DestroyPollGroup")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _DestroyPollGroup( IntPtr self, HSteamNetPollGroup hPollGroup ); + + #endregion + internal bool DestroyPollGroup( HSteamNetPollGroup hPollGroup ) + { + var returnValue = _DestroyPollGroup( Self, hPollGroup ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_SetConnectionPollGroup")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SetConnectionPollGroup( IntPtr self, Connection hConn, HSteamNetPollGroup hPollGroup ); + + #endregion + internal bool SetConnectionPollGroup( Connection hConn, HSteamNetPollGroup hPollGroup ) + { + var returnValue = _SetConnectionPollGroup( Self, hConn, hPollGroup ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnPollGroup")] + private static extern int _ReceiveMessagesOnPollGroup( IntPtr self, HSteamNetPollGroup hPollGroup, IntPtr ppOutMessages, int nMaxMessages ); + + #endregion + internal int ReceiveMessagesOnPollGroup( HSteamNetPollGroup hPollGroup, IntPtr ppOutMessages, int nMaxMessages ) + { + var returnValue = _ReceiveMessagesOnPollGroup( Self, hPollGroup, ppOutMessages, nMaxMessages ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_ReceivedRelayAuthTicket")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _ReceivedRelayAuthTicket( IntPtr self, IntPtr pvTicket, int cbTicket, [In,Out] SteamDatagramRelayAuthTicket[] pOutParsedTicket ); + + #endregion + internal bool ReceivedRelayAuthTicket( IntPtr pvTicket, int cbTicket, [In,Out] SteamDatagramRelayAuthTicket[] pOutParsedTicket ) + { + var returnValue = _ReceivedRelayAuthTicket( Self, pvTicket, cbTicket, pOutParsedTicket ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_FindRelayAuthTicketForServer")] + private static extern int _FindRelayAuthTicketForServer( IntPtr self, ref NetIdentity identityGameServer, int nVirtualPort, [In,Out] SteamDatagramRelayAuthTicket[] pOutParsedTicket ); + + #endregion + internal int FindRelayAuthTicketForServer( ref NetIdentity identityGameServer, int nVirtualPort, [In,Out] SteamDatagramRelayAuthTicket[] pOutParsedTicket ) + { + var returnValue = _FindRelayAuthTicketForServer( Self, ref identityGameServer, nVirtualPort, pOutParsedTicket ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_ConnectToHostedDedicatedServer")] + private static extern Connection _ConnectToHostedDedicatedServer( IntPtr self, ref NetIdentity identityTarget, int nVirtualPort, int nOptions, ref NetConfig_t pOptions ); + + #endregion + internal Connection ConnectToHostedDedicatedServer( ref NetIdentity identityTarget, int nVirtualPort, int nOptions, ref NetConfig_t pOptions ) + { + var returnValue = _ConnectToHostedDedicatedServer( Self, ref identityTarget, nVirtualPort, nOptions, ref pOptions ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_GetHostedDedicatedServerPort")] + private static extern ushort _GetHostedDedicatedServerPort( IntPtr self ); + + #endregion + internal ushort GetHostedDedicatedServerPort() + { + var returnValue = _GetHostedDedicatedServerPort( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_GetHostedDedicatedServerPOPID")] + private static extern SteamNetworkingPOPID _GetHostedDedicatedServerPOPID( IntPtr self ); + + #endregion + internal SteamNetworkingPOPID GetHostedDedicatedServerPOPID() + { + var returnValue = _GetHostedDedicatedServerPOPID( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_GetHostedDedicatedServerAddress")] + private static extern Result _GetHostedDedicatedServerAddress( IntPtr self, ref SteamDatagramHostedAddress pRouting ); + + #endregion + internal Result GetHostedDedicatedServerAddress( ref SteamDatagramHostedAddress pRouting ) + { + var returnValue = _GetHostedDedicatedServerAddress( Self, ref pRouting ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_CreateHostedDedicatedServerListenSocket")] + private static extern Socket _CreateHostedDedicatedServerListenSocket( IntPtr self, int nVirtualPort, int nOptions, ref NetConfig_t pOptions ); + + #endregion + internal Socket CreateHostedDedicatedServerListenSocket( int nVirtualPort, int nOptions, ref NetConfig_t pOptions ) + { + var returnValue = _CreateHostedDedicatedServerListenSocket( Self, nVirtualPort, nOptions, ref pOptions ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_GetGameCoordinatorServerLogin")] + private static extern Result _GetGameCoordinatorServerLogin( IntPtr self, ref SteamDatagramGameCoordinatorServerLogin pLoginInfo, ref int pcbSignedBlob, IntPtr pBlob ); + + #endregion + internal Result GetGameCoordinatorServerLogin( ref SteamDatagramGameCoordinatorServerLogin pLoginInfo, ref int pcbSignedBlob, IntPtr pBlob ) + { + var returnValue = _GetGameCoordinatorServerLogin( Self, ref pLoginInfo, ref pcbSignedBlob, pBlob ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_ConnectP2PCustomSignaling")] + private static extern Connection _ConnectP2PCustomSignaling( IntPtr self, IntPtr pSignaling, ref NetIdentity pPeerIdentity, int nOptions, ref NetConfig_t pOptions ); + + #endregion + internal Connection ConnectP2PCustomSignaling( IntPtr pSignaling, ref NetIdentity pPeerIdentity, int nOptions, ref NetConfig_t pOptions ) + { + var returnValue = _ConnectP2PCustomSignaling( Self, pSignaling, ref pPeerIdentity, nOptions, ref pOptions ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_ReceivedP2PCustomSignal")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _ReceivedP2PCustomSignal( IntPtr self, IntPtr pMsg, int cbMsg, IntPtr pContext ); + + #endregion + internal bool ReceivedP2PCustomSignal( IntPtr pMsg, int cbMsg, IntPtr pContext ) + { + var returnValue = _ReceivedP2PCustomSignal( Self, pMsg, cbMsg, pContext ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_GetCertificateRequest")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _GetCertificateRequest( IntPtr self, ref int pcbBlob, IntPtr pBlob, ref SteamNetworkingErrMsg errMsg ); + + #endregion + internal bool GetCertificateRequest( ref int pcbBlob, IntPtr pBlob, ref SteamNetworkingErrMsg errMsg ) + { + var returnValue = _GetCertificateRequest( Self, ref pcbBlob, pBlob, ref errMsg ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingSockets_SetCertificate")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SetCertificate( IntPtr self, IntPtr pCertificate, int cbCertificate, ref SteamNetworkingErrMsg errMsg ); + + #endregion + internal bool SetCertificate( IntPtr pCertificate, int cbCertificate, ref SteamNetworkingErrMsg errMsg ) + { + var returnValue = _SetCertificate( Self, pCertificate, cbCertificate, ref errMsg ); + return returnValue; + } + } } diff --git a/Facepunch.Steamworks/Generated/Interfaces/ISteamNetworkingUtils.cs b/Facepunch.Steamworks/Generated/Interfaces/ISteamNetworkingUtils.cs index b8de965..305a7f2 100644 --- a/Facepunch.Steamworks/Generated/Interfaces/ISteamNetworkingUtils.cs +++ b/Facepunch.Steamworks/Generated/Interfaces/ISteamNetworkingUtils.cs @@ -17,5 +17,349 @@ namespace Steamworks SetupInterface(); } + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_AllocateMessage")] + private static extern IntPtr _AllocateMessage( IntPtr self, int cbAllocateBuffer ); + + #endregion + internal SteamNetworkingMessage_t AllocateMessage( int cbAllocateBuffer ) + { + var returnValue = _AllocateMessage( Self, cbAllocateBuffer ); + return SteamNetworkingMessage_t.Fill( returnValue ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_InitRelayNetworkAccess")] + private static extern void _InitRelayNetworkAccess( IntPtr self ); + + #endregion + internal void InitRelayNetworkAccess() + { + _InitRelayNetworkAccess( Self ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_GetRelayNetworkStatus")] + private static extern SteamNetworkingAvailability _GetRelayNetworkStatus( IntPtr self, ref SteamRelayNetworkStatus_t pDetails ); + + #endregion + internal SteamNetworkingAvailability GetRelayNetworkStatus( ref SteamRelayNetworkStatus_t pDetails ) + { + var returnValue = _GetRelayNetworkStatus( Self, ref pDetails ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_GetLocalPingLocation")] + private static extern float _GetLocalPingLocation( IntPtr self, ref PingLocation result ); + + #endregion + internal float GetLocalPingLocation( ref PingLocation result ) + { + var returnValue = _GetLocalPingLocation( Self, ref result ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_EstimatePingTimeBetweenTwoLocations")] + private static extern int _EstimatePingTimeBetweenTwoLocations( IntPtr self, ref PingLocation location1, ref PingLocation location2 ); + + #endregion + internal int EstimatePingTimeBetweenTwoLocations( ref PingLocation location1, ref PingLocation location2 ) + { + var returnValue = _EstimatePingTimeBetweenTwoLocations( Self, ref location1, ref location2 ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_EstimatePingTimeFromLocalHost")] + private static extern int _EstimatePingTimeFromLocalHost( IntPtr self, ref PingLocation remoteLocation ); + + #endregion + internal int EstimatePingTimeFromLocalHost( ref PingLocation remoteLocation ) + { + var returnValue = _EstimatePingTimeFromLocalHost( Self, ref remoteLocation ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_ConvertPingLocationToString")] + private static extern void _ConvertPingLocationToString( IntPtr self, ref PingLocation location, IntPtr pszBuf, int cchBufSize ); + + #endregion + internal void ConvertPingLocationToString( ref PingLocation location, out string pszBuf ) + { + IntPtr mempszBuf = Helpers.TakeMemory(); + _ConvertPingLocationToString( Self, ref location, mempszBuf, (1024 * 32) ); + pszBuf = Helpers.MemoryToString( mempszBuf ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_ParsePingLocationString")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _ParsePingLocationString( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pszString, ref PingLocation result ); + + #endregion + internal bool ParsePingLocationString( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pszString, ref PingLocation result ) + { + var returnValue = _ParsePingLocationString( Self, pszString, ref result ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_CheckPingDataUpToDate")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _CheckPingDataUpToDate( IntPtr self, float flMaxAgeSeconds ); + + #endregion + internal bool CheckPingDataUpToDate( float flMaxAgeSeconds ) + { + var returnValue = _CheckPingDataUpToDate( Self, flMaxAgeSeconds ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_GetPingToDataCenter")] + private static extern int _GetPingToDataCenter( IntPtr self, SteamNetworkingPOPID popID, ref SteamNetworkingPOPID pViaRelayPoP ); + + #endregion + internal int GetPingToDataCenter( SteamNetworkingPOPID popID, ref SteamNetworkingPOPID pViaRelayPoP ) + { + var returnValue = _GetPingToDataCenter( Self, popID, ref pViaRelayPoP ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_GetDirectPingToPOP")] + private static extern int _GetDirectPingToPOP( IntPtr self, SteamNetworkingPOPID popID ); + + #endregion + internal int GetDirectPingToPOP( SteamNetworkingPOPID popID ) + { + var returnValue = _GetDirectPingToPOP( Self, popID ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_GetPOPCount")] + private static extern int _GetPOPCount( IntPtr self ); + + #endregion + internal int GetPOPCount() + { + var returnValue = _GetPOPCount( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_GetPOPList")] + private static extern int _GetPOPList( IntPtr self, ref SteamNetworkingPOPID list, int nListSz ); + + #endregion + internal int GetPOPList( ref SteamNetworkingPOPID list, int nListSz ) + { + var returnValue = _GetPOPList( Self, ref list, nListSz ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_GetLocalTimestamp")] + private static extern long _GetLocalTimestamp( IntPtr self ); + + #endregion + internal long GetLocalTimestamp() + { + var returnValue = _GetLocalTimestamp( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_SetDebugOutputFunction")] + private static extern void _SetDebugOutputFunction( IntPtr self, DebugOutputType eDetailLevel, FSteamNetworkingSocketsDebugOutput pfnFunc ); + + #endregion + internal void SetDebugOutputFunction( DebugOutputType eDetailLevel, FSteamNetworkingSocketsDebugOutput pfnFunc ) + { + _SetDebugOutputFunction( Self, eDetailLevel, pfnFunc ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValueInt32")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SetGlobalConfigValueInt32( IntPtr self, NetConfig eValue, int val ); + + #endregion + internal bool SetGlobalConfigValueInt32( NetConfig eValue, int val ) + { + var returnValue = _SetGlobalConfigValueInt32( Self, eValue, val ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValueFloat")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SetGlobalConfigValueFloat( IntPtr self, NetConfig eValue, float val ); + + #endregion + internal bool SetGlobalConfigValueFloat( NetConfig eValue, float val ) + { + var returnValue = _SetGlobalConfigValueFloat( Self, eValue, val ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValueString")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SetGlobalConfigValueString( IntPtr self, NetConfig eValue, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string val ); + + #endregion + internal bool SetGlobalConfigValueString( NetConfig eValue, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string val ) + { + var returnValue = _SetGlobalConfigValueString( Self, eValue, val ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_SetConnectionConfigValueInt32")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SetConnectionConfigValueInt32( IntPtr self, Connection hConn, NetConfig eValue, int val ); + + #endregion + internal bool SetConnectionConfigValueInt32( Connection hConn, NetConfig eValue, int val ) + { + var returnValue = _SetConnectionConfigValueInt32( Self, hConn, eValue, val ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_SetConnectionConfigValueFloat")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SetConnectionConfigValueFloat( IntPtr self, Connection hConn, NetConfig eValue, float val ); + + #endregion + internal bool SetConnectionConfigValueFloat( Connection hConn, NetConfig eValue, float val ) + { + var returnValue = _SetConnectionConfigValueFloat( Self, hConn, eValue, val ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_SetConnectionConfigValueString")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SetConnectionConfigValueString( IntPtr self, Connection hConn, NetConfig eValue, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string val ); + + #endregion + internal bool SetConnectionConfigValueString( Connection hConn, NetConfig eValue, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string val ) + { + var returnValue = _SetConnectionConfigValueString( Self, hConn, eValue, val ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_SetConfigValue")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SetConfigValue( IntPtr self, NetConfig eValue, NetScope eScopeType, long scopeObj, NetConfigType eDataType, IntPtr pArg ); + + #endregion + internal bool SetConfigValue( NetConfig eValue, NetScope eScopeType, long scopeObj, NetConfigType eDataType, IntPtr pArg ) + { + var returnValue = _SetConfigValue( Self, eValue, eScopeType, scopeObj, eDataType, pArg ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_SetConfigValueStruct")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SetConfigValueStruct( IntPtr self, ref NetConfig_t opt, NetScope eScopeType, long scopeObj ); + + #endregion + internal bool SetConfigValueStruct( ref NetConfig_t opt, NetScope eScopeType, long scopeObj ) + { + var returnValue = _SetConfigValueStruct( Self, ref opt, eScopeType, scopeObj ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_GetConfigValue")] + private static extern NetConfigResult _GetConfigValue( IntPtr self, NetConfig eValue, NetScope eScopeType, long scopeObj, ref NetConfigType pOutDataType, IntPtr pResult, ref UIntPtr cbResult ); + + #endregion + internal NetConfigResult GetConfigValue( NetConfig eValue, NetScope eScopeType, long scopeObj, ref NetConfigType pOutDataType, IntPtr pResult, ref UIntPtr cbResult ) + { + var returnValue = _GetConfigValue( Self, eValue, eScopeType, scopeObj, ref pOutDataType, pResult, ref cbResult ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_GetConfigValueInfo")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _GetConfigValueInfo( IntPtr self, NetConfig eValue, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pOutName, ref NetConfigType pOutDataType, [In,Out] NetScope[] pOutScope, [In,Out] NetConfig[] pOutNextValue ); + + #endregion + internal bool GetConfigValueInfo( NetConfig eValue, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pOutName, ref NetConfigType pOutDataType, [In,Out] NetScope[] pOutScope, [In,Out] NetConfig[] pOutNextValue ) + { + var returnValue = _GetConfigValueInfo( Self, eValue, pOutName, ref pOutDataType, pOutScope, pOutNextValue ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_GetFirstConfigValue")] + private static extern NetConfig _GetFirstConfigValue( IntPtr self ); + + #endregion + internal NetConfig GetFirstConfigValue() + { + var returnValue = _GetFirstConfigValue( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_SteamNetworkingIPAddr_ToString")] + private static extern void _SteamNetworkingIPAddr_ToString( IntPtr self, ref NetAddress addr, IntPtr buf, UIntPtr cbBuf, [MarshalAs( UnmanagedType.U1 )] bool bWithPort ); + + #endregion + internal void SteamNetworkingIPAddr_ToString( ref NetAddress addr, out string buf, [MarshalAs( UnmanagedType.U1 )] bool bWithPort ) + { + IntPtr membuf = Helpers.TakeMemory(); + _SteamNetworkingIPAddr_ToString( Self, ref addr, membuf, (1024 * 32), bWithPort ); + buf = Helpers.MemoryToString( membuf ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_SteamNetworkingIPAddr_ParseString")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SteamNetworkingIPAddr_ParseString( IntPtr self, ref NetAddress pAddr, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pszStr ); + + #endregion + internal bool SteamNetworkingIPAddr_ParseString( ref NetAddress pAddr, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pszStr ) + { + var returnValue = _SteamNetworkingIPAddr_ParseString( Self, ref pAddr, pszStr ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_SteamNetworkingIdentity_ToString")] + private static extern void _SteamNetworkingIdentity_ToString( IntPtr self, ref NetIdentity identity, IntPtr buf, UIntPtr cbBuf ); + + #endregion + internal void SteamNetworkingIdentity_ToString( ref NetIdentity identity, out string buf ) + { + IntPtr membuf = Helpers.TakeMemory(); + _SteamNetworkingIdentity_ToString( Self, ref identity, membuf, (1024 * 32) ); + buf = Helpers.MemoryToString( membuf ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamNetworkingUtils_SteamNetworkingIdentity_ParseString")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _SteamNetworkingIdentity_ParseString( IntPtr self, ref NetIdentity pIdentity, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pszStr ); + + #endregion + internal bool SteamNetworkingIdentity_ParseString( ref NetIdentity pIdentity, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pszStr ) + { + var returnValue = _SteamNetworkingIdentity_ParseString( Self, ref pIdentity, pszStr ); + return returnValue; + } + } } diff --git a/Facepunch.Steamworks/Generated/Interfaces/ISteamRemotePlay.cs b/Facepunch.Steamworks/Generated/Interfaces/ISteamRemotePlay.cs new file mode 100644 index 0000000..3605da9 --- /dev/null +++ b/Facepunch.Steamworks/Generated/Interfaces/ISteamRemotePlay.cs @@ -0,0 +1,100 @@ +using System; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading.Tasks; +using Steamworks.Data; + + +namespace Steamworks +{ + internal class ISteamRemotePlay : SteamInterface + { + public override IntPtr GetInterfacePointer() => GetApi.SteamRemotePlay(); + + + internal ISteamRemotePlay() + { + SetupInterface(); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamRemotePlay_GetSessionCount")] + private static extern uint _GetSessionCount( IntPtr self ); + + #endregion + internal uint GetSessionCount() + { + var returnValue = _GetSessionCount( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamRemotePlay_GetSessionID")] + private static extern RemotePlaySessionID_t _GetSessionID( IntPtr self, int iSessionIndex ); + + #endregion + internal RemotePlaySessionID_t GetSessionID( int iSessionIndex ) + { + var returnValue = _GetSessionID( Self, iSessionIndex ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamRemotePlay_GetSessionSteamID")] + private static extern SteamId _GetSessionSteamID( IntPtr self, RemotePlaySessionID_t unSessionID ); + + #endregion + internal SteamId GetSessionSteamID( RemotePlaySessionID_t unSessionID ) + { + var returnValue = _GetSessionSteamID( Self, unSessionID ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamRemotePlay_GetSessionClientName")] + private static extern Utf8StringPointer _GetSessionClientName( IntPtr self, RemotePlaySessionID_t unSessionID ); + + #endregion + internal string GetSessionClientName( RemotePlaySessionID_t unSessionID ) + { + var returnValue = _GetSessionClientName( Self, unSessionID ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamRemotePlay_GetSessionClientFormFactor")] + private static extern SteamDeviceFormFactor _GetSessionClientFormFactor( IntPtr self, RemotePlaySessionID_t unSessionID ); + + #endregion + internal SteamDeviceFormFactor GetSessionClientFormFactor( RemotePlaySessionID_t unSessionID ) + { + var returnValue = _GetSessionClientFormFactor( Self, unSessionID ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamRemotePlay_BGetSessionClientResolution")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _BGetSessionClientResolution( IntPtr self, RemotePlaySessionID_t unSessionID, ref int pnResolutionX, ref int pnResolutionY ); + + #endregion + internal bool BGetSessionClientResolution( RemotePlaySessionID_t unSessionID, ref int pnResolutionX, ref int pnResolutionY ) + { + var returnValue = _BGetSessionClientResolution( Self, unSessionID, ref pnResolutionX, ref pnResolutionY ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamRemotePlay_BSendRemotePlayTogetherInvite")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _BSendRemotePlayTogetherInvite( IntPtr self, SteamId steamIDFriend ); + + #endregion + internal bool BSendRemotePlayTogetherInvite( SteamId steamIDFriend ) + { + var returnValue = _BSendRemotePlayTogetherInvite( Self, steamIDFriend ); + return returnValue; + } + + } +} diff --git a/Facepunch.Steamworks/Generated/Interfaces/ISteamTV.cs b/Facepunch.Steamworks/Generated/Interfaces/ISteamTV.cs new file mode 100644 index 0000000..dd51cc3 --- /dev/null +++ b/Facepunch.Steamworks/Generated/Interfaces/ISteamTV.cs @@ -0,0 +1,94 @@ +using System; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading.Tasks; +using Steamworks.Data; + + +namespace Steamworks +{ + internal class ISteamTV : SteamInterface + { + public override IntPtr GetInterfacePointer() => GetApi.SteamTV(); + + + internal ISteamTV() + { + SetupInterface(); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamTV_IsBroadcasting")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _IsBroadcasting( IntPtr self, ref int pnNumViewers ); + + #endregion + internal bool IsBroadcasting( ref int pnNumViewers ) + { + var returnValue = _IsBroadcasting( Self, ref pnNumViewers ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamTV_AddBroadcastGameData")] + private static extern void _AddBroadcastGameData( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchKey, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchValue ); + + #endregion + internal void AddBroadcastGameData( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchKey, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchValue ) + { + _AddBroadcastGameData( Self, pchKey, pchValue ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamTV_RemoveBroadcastGameData")] + private static extern void _RemoveBroadcastGameData( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchKey ); + + #endregion + internal void RemoveBroadcastGameData( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchKey ) + { + _RemoveBroadcastGameData( Self, pchKey ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamTV_AddTimelineMarker")] + private static extern void _AddTimelineMarker( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchTemplateName, [MarshalAs( UnmanagedType.U1 )] bool bPersistent, byte nColorR, byte nColorG, byte nColorB ); + + #endregion + internal void AddTimelineMarker( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchTemplateName, [MarshalAs( UnmanagedType.U1 )] bool bPersistent, byte nColorR, byte nColorG, byte nColorB ) + { + _AddTimelineMarker( Self, pchTemplateName, bPersistent, nColorR, nColorG, nColorB ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamTV_RemoveTimelineMarker")] + private static extern void _RemoveTimelineMarker( IntPtr self ); + + #endregion + internal void RemoveTimelineMarker() + { + _RemoveTimelineMarker( Self ); + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamTV_AddRegion")] + private static extern uint _AddRegion( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchElementName, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchTimelineDataSection, ref SteamTVRegion_t pSteamTVRegion, SteamTVRegionBehavior eSteamTVRegionBehavior ); + + #endregion + internal uint AddRegion( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchElementName, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchTimelineDataSection, ref SteamTVRegion_t pSteamTVRegion, SteamTVRegionBehavior eSteamTVRegionBehavior ) + { + var returnValue = _AddRegion( Self, pchElementName, pchTimelineDataSection, ref pSteamTVRegion, eSteamTVRegionBehavior ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamTV_RemoveRegion")] + private static extern void _RemoveRegion( IntPtr self, uint unRegionHandle ); + + #endregion + internal void RemoveRegion( uint unRegionHandle ) + { + _RemoveRegion( Self, unRegionHandle ); + } + + } +} diff --git a/Facepunch.Steamworks/Generated/Interfaces/ISteamUGC.cs b/Facepunch.Steamworks/Generated/Interfaces/ISteamUGC.cs index 640fa96..3d1cf7c 100644 --- a/Facepunch.Steamworks/Generated/Interfaces/ISteamUGC.cs +++ b/Facepunch.Steamworks/Generated/Interfaces/ISteamUGC.cs @@ -40,13 +40,13 @@ namespace Steamworks } #region FunctionMeta - [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUGC_CreateQueryAllUGCRequest0")] - private static extern UGCQueryHandle_t _CreateQueryAllUGCRequest0( IntPtr self, UGCQuery eQueryType, UgcType eMatchingeMatchingUGCTypeFileType, AppId nCreatorAppID, AppId nConsumerAppID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchCursor ); + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUGC_CreateQueryAllUGCRequest")] + private static extern UGCQueryHandle_t _CreateQueryAllUGCRequest( IntPtr self, UGCQuery eQueryType, UgcType eMatchingeMatchingUGCTypeFileType, AppId nCreatorAppID, AppId nConsumerAppID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchCursor ); #endregion - internal UGCQueryHandle_t CreateQueryAllUGCRequest0( UGCQuery eQueryType, UgcType eMatchingeMatchingUGCTypeFileType, AppId nCreatorAppID, AppId nConsumerAppID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchCursor ) + internal UGCQueryHandle_t CreateQueryAllUGCRequest( UGCQuery eQueryType, UgcType eMatchingeMatchingUGCTypeFileType, AppId nCreatorAppID, AppId nConsumerAppID, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchCursor ) { - var returnValue = _CreateQueryAllUGCRequest0( Self, eQueryType, eMatchingeMatchingUGCTypeFileType, nCreatorAppID, nConsumerAppID, pchCursor ); + var returnValue = _CreateQueryAllUGCRequest( Self, eQueryType, eMatchingeMatchingUGCTypeFileType, nCreatorAppID, nConsumerAppID, pchCursor ); return returnValue; } @@ -190,6 +190,20 @@ namespace Steamworks return returnValue; } + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUGC_GetQueryUGCKeyValueTag")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _GetQueryUGCKeyValueTag( IntPtr self, UGCQueryHandle_t handle, uint index, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchKey, IntPtr pchValue, uint cchValueSize ); + + #endregion + internal bool GetQueryUGCKeyValueTag( UGCQueryHandle_t handle, uint index, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchKey, out string pchValue ) + { + IntPtr mempchValue = Helpers.TakeMemory(); + var returnValue = _GetQueryUGCKeyValueTag( Self, handle, index, pchKey, mempchValue, (1024 * 32) ); + pchValue = Helpers.MemoryToString( mempchValue ); + return returnValue; + } + #region FunctionMeta [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUGC_ReleaseQueryUGCRequest")] [return: MarshalAs( UnmanagedType.I1 )] @@ -214,6 +228,18 @@ namespace Steamworks return returnValue; } + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUGC_AddRequiredTagGroup")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _AddRequiredTagGroup( IntPtr self, UGCQueryHandle_t handle, ref SteamParamStringArray_t pTagGroups ); + + #endregion + internal bool AddRequiredTagGroup( UGCQueryHandle_t handle, ref SteamParamStringArray_t pTagGroups ) + { + var returnValue = _AddRequiredTagGroup( Self, handle, ref pTagGroups ); + return returnValue; + } + #region FunctionMeta [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUGC_AddExcludedTag")] [return: MarshalAs( UnmanagedType.I1 )] @@ -411,10 +437,10 @@ namespace Steamworks private static extern SteamAPICall_t _RequestUGCDetails( IntPtr self, PublishedFileId nPublishedFileID, uint unMaxAgeSeconds ); #endregion - internal CallbackResult RequestUGCDetails( PublishedFileId nPublishedFileID, uint unMaxAgeSeconds ) + internal CallbackResult RequestUGCDetails( PublishedFileId nPublishedFileID, uint unMaxAgeSeconds ) { var returnValue = _RequestUGCDetails( Self, nPublishedFileID, unMaxAgeSeconds ); - return new CallbackResult( returnValue ); + return new CallbackResult( returnValue ); } #region FunctionMeta @@ -547,6 +573,18 @@ namespace Steamworks return returnValue; } + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUGC_RemoveAllItemKeyValueTags")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _RemoveAllItemKeyValueTags( IntPtr self, UGCUpdateHandle_t handle ); + + #endregion + internal bool RemoveAllItemKeyValueTags( UGCUpdateHandle_t handle ) + { + var returnValue = _RemoveAllItemKeyValueTags( Self, handle ); + return returnValue; + } + #region FunctionMeta [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUGC_RemoveItemKeyValueTags")] [return: MarshalAs( UnmanagedType.I1 )] diff --git a/Facepunch.Steamworks/Generated/Interfaces/ISteamUser.cs b/Facepunch.Steamworks/Generated/Interfaces/ISteamUser.cs index bba0b37..3d1f2cd 100644 --- a/Facepunch.Steamworks/Generated/Interfaces/ISteamUser.cs +++ b/Facepunch.Steamworks/Generated/Interfaces/ISteamUser.cs @@ -350,5 +350,16 @@ namespace Steamworks return new CallbackResult( returnValue ); } + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUser_GetDurationControl")] + private static extern SteamAPICall_t _GetDurationControl( IntPtr self ); + + #endregion + internal CallbackResult GetDurationControl() + { + var returnValue = _GetDurationControl( Self ); + return new CallbackResult( returnValue ); + } + } } diff --git a/Facepunch.Steamworks/Generated/Interfaces/ISteamUserStats.cs b/Facepunch.Steamworks/Generated/Interfaces/ISteamUserStats.cs index 09ce10b..06c8687 100644 --- a/Facepunch.Steamworks/Generated/Interfaces/ISteamUserStats.cs +++ b/Facepunch.Steamworks/Generated/Interfaces/ISteamUserStats.cs @@ -42,14 +42,14 @@ namespace Steamworks } #region FunctionMeta - [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUserStats_GetStat0")] + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUserStats_GetStat")] [return: MarshalAs( UnmanagedType.I1 )] - private static extern bool _GetStat0( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchName, ref float pData ); + private static extern bool _GetStat( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchName, ref float pData ); #endregion - internal bool GetStat0( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchName, ref float pData ) + internal bool GetStat( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchName, ref float pData ) { - var returnValue = _GetStat0( Self, pchName, ref pData ); + var returnValue = _GetStat( Self, pchName, ref pData ); return returnValue; } @@ -66,14 +66,14 @@ namespace Steamworks } #region FunctionMeta - [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUserStats_SetStat0")] + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUserStats_SetStat")] [return: MarshalAs( UnmanagedType.I1 )] - private static extern bool _SetStat0( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchName, float fData ); + private static extern bool _SetStat( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchName, float fData ); #endregion - internal bool SetStat0( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchName, float fData ) + internal bool SetStat( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchName, float fData ) { - var returnValue = _SetStat0( Self, pchName, fData ); + var returnValue = _SetStat( Self, pchName, fData ); return returnValue; } @@ -229,14 +229,14 @@ namespace Steamworks } #region FunctionMeta - [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUserStats_GetUserStat0")] + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUserStats_GetUserStat")] [return: MarshalAs( UnmanagedType.I1 )] - private static extern bool _GetUserStat0( IntPtr self, SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchName, ref float pData ); + private static extern bool _GetUserStat( IntPtr self, SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchName, ref float pData ); #endregion - internal bool GetUserStat0( SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchName, ref float pData ) + internal bool GetUserStat( SteamId steamIDUser, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchName, ref float pData ) { - var returnValue = _GetUserStat0( Self, steamIDUser, pchName, ref pData ); + var returnValue = _GetUserStat( Self, steamIDUser, pchName, ref pData ); return returnValue; } @@ -482,14 +482,14 @@ namespace Steamworks } #region FunctionMeta - [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUserStats_GetGlobalStat0")] + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUserStats_GetGlobalStat")] [return: MarshalAs( UnmanagedType.I1 )] - private static extern bool _GetGlobalStat0( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchStatName, ref double pData ); + private static extern bool _GetGlobalStat( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchStatName, ref double pData ); #endregion - internal bool GetGlobalStat0( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchStatName, ref double pData ) + internal bool GetGlobalStat( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchStatName, ref double pData ) { - var returnValue = _GetGlobalStat0( Self, pchStatName, ref pData ); + var returnValue = _GetGlobalStat( Self, pchStatName, ref pData ); return returnValue; } @@ -505,13 +505,13 @@ namespace Steamworks } #region FunctionMeta - [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUserStats_GetGlobalStatHistory0")] - private static extern int _GetGlobalStatHistory0( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchStatName, [In,Out] double[] pData, uint cubData ); + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUserStats_GetGlobalStatHistory")] + private static extern int _GetGlobalStatHistory( IntPtr self, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchStatName, [In,Out] double[] pData, uint cubData ); #endregion - internal int GetGlobalStatHistory0( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchStatName, [In,Out] double[] pData, uint cubData ) + internal int GetGlobalStatHistory( [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchStatName, [In,Out] double[] pData, uint cubData ) { - var returnValue = _GetGlobalStatHistory0( Self, pchStatName, pData, cubData ); + var returnValue = _GetGlobalStatHistory( Self, pchStatName, pData, cubData ); return returnValue; } diff --git a/Facepunch.Steamworks/Generated/Interfaces/ISteamUtils.cs b/Facepunch.Steamworks/Generated/Interfaces/ISteamUtils.cs index 65896a9..5f6f735 100644 --- a/Facepunch.Steamworks/Generated/Interfaces/ISteamUtils.cs +++ b/Facepunch.Steamworks/Generated/Interfaces/ISteamUtils.cs @@ -345,5 +345,53 @@ namespace Steamworks _SetVRHeadsetStreamingEnabled( Self, bEnabled ); } + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUtils_IsSteamChinaLauncher")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _IsSteamChinaLauncher( IntPtr self ); + + #endregion + internal bool IsSteamChinaLauncher() + { + var returnValue = _IsSteamChinaLauncher( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUtils_InitFilterText")] + [return: MarshalAs( UnmanagedType.I1 )] + private static extern bool _InitFilterText( IntPtr self ); + + #endregion + internal bool InitFilterText() + { + var returnValue = _InitFilterText( Self ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUtils_FilterText")] + private static extern int _FilterText( IntPtr self, IntPtr pchOutFilteredText, uint nByteSizeOutFilteredText, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchInputMessage, [MarshalAs( UnmanagedType.U1 )] bool bLegalOnly ); + + #endregion + internal int FilterText( out string pchOutFilteredText, [MarshalAs( UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof( Utf8StringToNative ) )] string pchInputMessage, [MarshalAs( UnmanagedType.U1 )] bool bLegalOnly ) + { + IntPtr mempchOutFilteredText = Helpers.TakeMemory(); + var returnValue = _FilterText( Self, mempchOutFilteredText, (1024 * 32), pchInputMessage, bLegalOnly ); + pchOutFilteredText = Helpers.MemoryToString( mempchOutFilteredText ); + return returnValue; + } + + #region FunctionMeta + [DllImport( Platform.LibraryName, EntryPoint = "SteamAPI_ISteamUtils_GetIPv6ConnectivityState")] + private static extern SteamIPv6ConnectivityState _GetIPv6ConnectivityState( IntPtr self, SteamIPv6ConnectivityProtocol eProtocol ); + + #endregion + internal SteamIPv6ConnectivityState GetIPv6ConnectivityState( SteamIPv6ConnectivityProtocol eProtocol ) + { + var returnValue = _GetIPv6ConnectivityState( Self, eProtocol ); + return returnValue; + } + } } diff --git a/Facepunch.Steamworks/Generated/SteamConstants.cs b/Facepunch.Steamworks/Generated/SteamConstants.cs index 35c3b45..6f621d5 100644 --- a/Facepunch.Steamworks/Generated/SteamConstants.cs +++ b/Facepunch.Steamworks/Generated/SteamConstants.cs @@ -6,95 +6,4 @@ using System.Threading.Tasks; namespace Steamworks.Data { - internal static class CallbackIdentifiers - { - public const int SteamUser = 100; - public const int SteamGameServer = 200; - public const int SteamFriends = 300; - public const int SteamBilling = 400; - public const int SteamMatchmaking = 500; - public const int SteamContentServer = 600; - public const int SteamUtils = 700; - public const int ClientFriends = 800; - public const int ClientUser = 900; - public const int SteamApps = 1000; - public const int SteamUserStats = 1100; - public const int SteamNetworking = 1200; - public const int SteamNetworkingSockets = 1220; - public const int SteamNetworkingMessages = 1250; - public const int ClientRemoteStorage = 1300; - public const int ClientDepotBuilder = 1400; - public const int SteamGameServerItems = 1500; - public const int ClientUtils = 1600; - public const int SteamGameCoordinator = 1700; - public const int SteamGameServerStats = 1800; - public const int Steam2Async = 1900; - public const int SteamGameStats = 2000; - public const int ClientHTTP = 2100; - public const int ClientScreenshots = 2200; - public const int SteamScreenshots = 2300; - public const int ClientAudio = 2400; - public const int ClientUnifiedMessages = 2500; - public const int SteamStreamLauncher = 2600; - public const int ClientController = 2700; - public const int SteamController = 2800; - public const int ClientParentalSettings = 2900; - public const int ClientDeviceAuth = 3000; - public const int ClientNetworkDeviceManager = 3100; - public const int ClientMusic = 3200; - public const int ClientRemoteClientManager = 3300; - public const int ClientUGC = 3400; - public const int SteamStreamClient = 3500; - public const int ClientProductBuilder = 3600; - public const int ClientShortcuts = 3700; - public const int ClientRemoteControlManager = 3800; - public const int SteamAppList = 3900; - public const int SteamMusic = 4000; - public const int SteamMusicRemote = 4100; - public const int ClientVR = 4200; - public const int ClientGameNotification = 4300; - public const int SteamGameNotification = 4400; - public const int SteamHTMLSurface = 4500; - public const int ClientVideo = 4600; - public const int ClientInventory = 4700; - public const int ClientBluetoothManager = 4800; - public const int ClientSharedConnection = 4900; - public const int SteamParentalSettings = 5000; - public const int ClientShader = 5100; - public const int SteamGameSearch = 5200; - public const int SteamParties = 5300; - public const int ClientParties = 5400; - } - internal static class Defines - { - internal const string STEAMAPPLIST_INTERFACE_VERSION = "STEAMAPPLIST_INTERFACE_VERSION001"; - internal const string STEAMAPPS_INTERFACE_VERSION = "STEAMAPPS_INTERFACE_VERSION008"; - internal const string STEAMAPPTICKET_INTERFACE_VERSION = "STEAMAPPTICKET_INTERFACE_VERSION001"; - internal const string STEAMCONTROLLER_INTERFACE_VERSION = "SteamController007"; - internal const string STEAMFRIENDS_INTERFACE_VERSION = "SteamFriends017"; - internal const string STEAMGAMECOORDINATOR_INTERFACE_VERSION = "SteamGameCoordinator001"; - internal const string STEAMGAMESERVER_INTERFACE_VERSION = "SteamGameServer012"; - internal const string STEAMGAMESERVERSTATS_INTERFACE_VERSION = "SteamGameServerStats001"; - internal const string STEAMHTMLSURFACE_INTERFACE_VERSION = "STEAMHTMLSURFACE_INTERFACE_VERSION_005"; - internal const string STEAMHTTP_INTERFACE_VERSION = "STEAMHTTP_INTERFACE_VERSION003"; - internal const string STEAMINPUT_INTERFACE_VERSION = "SteamInput001"; - internal const string STEAMINVENTORY_INTERFACE_VERSION = "STEAMINVENTORY_INTERFACE_V003"; - internal const string STEAMMATCHMAKING_INTERFACE_VERSION = "SteamMatchMaking009"; - internal const string STEAMMATCHMAKINGSERVERS_INTERFACE_VERSION = "SteamMatchMakingServers002"; - internal const string STEAMGAMESEARCH_INTERFACE_VERSION = "SteamMatchGameSearch001"; - internal const string STEAMPARTIES_INTERFACE_VERSION = "SteamParties002"; - internal const string STEAMMUSIC_INTERFACE_VERSION = "STEAMMUSIC_INTERFACE_VERSION001"; - internal const string STEAMMUSICREMOTE_INTERFACE_VERSION = "STEAMMUSICREMOTE_INTERFACE_VERSION001"; - internal const string STEAMNETWORKING_INTERFACE_VERSION = "SteamNetworking005"; - internal const string STEAMNETWORKINGSOCKETS_INTERFACE_VERSION = "SteamNetworkingSockets002"; - internal const string STEAMNETWORKINGUTILS_INTERFACE_VERSION = "SteamNetworkingUtils001"; - internal const string STEAMPARENTALSETTINGS_INTERFACE_VERSION = "STEAMPARENTALSETTINGS_INTERFACE_VERSION001"; - internal const string STEAMREMOTESTORAGE_INTERFACE_VERSION = "STEAMREMOTESTORAGE_INTERFACE_VERSION014"; - internal const string STEAMSCREENSHOTS_INTERFACE_VERSION = "STEAMSCREENSHOTS_INTERFACE_VERSION003"; - internal const string STEAMUGC_INTERFACE_VERSION = "STEAMUGC_INTERFACE_VERSION012"; - internal const string STEAMUSER_INTERFACE_VERSION = "SteamUser020"; - internal const string STEAMUSERSTATS_INTERFACE_VERSION = "STEAMUSERSTATS_INTERFACE_VERSION011"; - internal const string STEAMUTILS_INTERFACE_VERSION = "SteamUtils009"; - internal const string STEAMVIDEO_INTERFACE_VERSION = "STEAMVIDEO_INTERFACE_V002"; - } } diff --git a/Facepunch.Steamworks/Generated/SteamEnums.cs b/Facepunch.Steamworks/Generated/SteamEnums.cs index 2076b6b..1281098 100644 --- a/Facepunch.Steamworks/Generated/SteamEnums.cs +++ b/Facepunch.Steamworks/Generated/SteamEnums.cs @@ -6,10 +6,19 @@ using System.Threading.Tasks; namespace Steamworks { + // + // ESteamIPType + // + internal enum SteamIPType : uint + { + SteamIPType4 = 0, + SteamIPType6 = 1, + } + // // EUniverse // - public enum Universe : int + public enum Universe : uint { Invalid = 0, Public = 1, @@ -22,8 +31,9 @@ namespace Steamworks // // EResult // - public enum Result : int + public enum Result : uint { + None = 0, OK = 1, Fail = 2, NoConnection = 3, @@ -136,12 +146,14 @@ namespace Steamworks AccountNotFriends = 111, LimitedUserAccount = 112, CantRemoveItem = 113, + AccountDeleted = 114, + ExistingUserCancelledLicense = 115, } // // EVoiceResult // - internal enum VoiceResult : int + internal enum VoiceResult : uint { OK = 0, NotInitialized = 1, @@ -158,7 +170,7 @@ namespace Steamworks // // EDenyReason // - internal enum DenyReason : int + internal enum DenyReason : uint { Invalid = 0, InvalidVersion = 1, @@ -181,7 +193,7 @@ namespace Steamworks // // EBeginAuthSessionResult // - public enum BeginAuthResult : int + public enum BeginAuthResult : uint { OK = 0, InvalidTicket = 1, @@ -194,7 +206,7 @@ namespace Steamworks // // EAuthSessionResponse // - public enum AuthResponse : int + public enum AuthResponse : uint { OK = 0, UserNotConnectedToSteam = 1, @@ -211,7 +223,7 @@ namespace Steamworks // // EUserHasLicenseForAppResult // - public enum UserHasLicenseForAppResult : int + public enum UserHasLicenseForAppResult : uint { HasLicense = 0, DoesNotHaveLicense = 1, @@ -221,7 +233,7 @@ namespace Steamworks // // EAccountType // - internal enum AccountType : int + internal enum AccountType : uint { Invalid = 0, Individual = 1, @@ -240,7 +252,7 @@ namespace Steamworks // // EAppReleaseState // - internal enum AppReleaseState : int + internal enum AppReleaseState : uint { Unknown = 0, Unavailable = 1, @@ -252,7 +264,7 @@ namespace Steamworks // // EAppOwnershipFlags // - internal enum AppOwnershipFlags : int + internal enum AppOwnershipFlags : uint { None = 0, OwnsLicense = 1, @@ -274,12 +286,14 @@ namespace Steamworks RentalNotActivated = 65536, Rental = 131072, SiteLicense = 262144, + LegacyFreeSub = 524288, + InvalidOSType = 1048576, } // // EAppType // - internal enum AppType : int + internal enum AppType : uint { Invalid = 0, Game = 1, @@ -295,17 +309,18 @@ namespace Steamworks Franchise = 1024, Video = 2048, Plugin = 4096, - Music = 8192, + MusicAlbum = 8192, Series = 16384, - Comic = 32768, + Comic_UNUSED = 32768, + Beta = 65536, Shortcut = 1073741824, - DepotOnly = -2147483648, + DepotOnly = 2147483648, } // // ESteamUserStatType // - internal enum SteamUserStatType : int + internal enum SteamUserStatType : uint { INVALID = 0, INT = 1, @@ -319,7 +334,7 @@ namespace Steamworks // // EChatEntryType // - internal enum ChatEntryType : int + internal enum ChatEntryType : uint { Invalid = 0, ChatMsg = 1, @@ -338,7 +353,7 @@ namespace Steamworks // // EChatRoomEnterResponse // - public enum RoomEnter : int + public enum RoomEnter : uint { Success = 1, DoesntExist = 2, @@ -357,7 +372,7 @@ namespace Steamworks // // EChatSteamIDInstanceFlags // - internal enum ChatSteamIDInstanceFlags : int + internal enum ChatSteamIDInstanceFlags : uint { AccountInstanceMask = 4095, InstanceFlagClan = 524288, @@ -368,7 +383,7 @@ namespace Steamworks // // EMarketingMessageFlags // - internal enum MarketingMessageFlags : int + internal enum MarketingMessageFlags : uint { None = 0, HighPriority = 1, @@ -381,7 +396,7 @@ namespace Steamworks // // ENotificationPosition // - public enum NotificationPosition : int + public enum NotificationPosition : uint { TopLeft = 0, TopRight = 1, @@ -392,7 +407,7 @@ namespace Steamworks // // EBroadcastUploadResult // - public enum BroadcastUploadResult : int + public enum BroadcastUploadResult : uint { None = 0, OK = 1, @@ -423,7 +438,7 @@ namespace Steamworks // // ELaunchOptionType // - internal enum LaunchOptionType : int + internal enum LaunchOptionType : uint { None = 0, Default = 1, @@ -447,41 +462,47 @@ namespace Steamworks // // EVRHMDType // - internal enum VRHMDType : int + internal enum VRHMDType : uint { - None = -1, - Unknown = 0, - HTC_Dev = 1, - HTC_VivePre = 2, - HTC_Vive = 3, - HTC_VivePro = 4, - HTC_Unknown = 20, - Oculus_DK1 = 21, - Oculus_DK2 = 22, - Oculus_Rift = 23, - Oculus_Unknown = 40, - Acer_Unknown = 50, - Acer_WindowsMR = 51, - Dell_Unknown = 60, - Dell_Visor = 61, - Lenovo_Unknown = 70, - Lenovo_Explorer = 71, - HP_Unknown = 80, - HP_WindowsMR = 81, - Samsung_Unknown = 90, - Samsung_Odyssey = 91, - Unannounced_Unknown = 100, - Unannounced_WindowsMR = 101, - vridge = 110, - Huawei_Unknown = 120, - Huawei_VR2 = 121, - Huawei_Unannounced = 129, + MDType_None = -1, + MDType_Unknown = 0, + MDType_HTC_Dev = 1, + MDType_HTC_VivePre = 2, + MDType_HTC_Vive = 3, + MDType_HTC_VivePro = 4, + MDType_HTC_ViveCosmos = 5, + MDType_HTC_Unknown = 20, + MDType_Oculus_DK1 = 21, + MDType_Oculus_DK2 = 22, + MDType_Oculus_Rift = 23, + MDType_Oculus_RiftS = 24, + MDType_Oculus_Quest = 25, + MDType_Oculus_Unknown = 40, + MDType_Acer_Unknown = 50, + MDType_Acer_WindowsMR = 51, + MDType_Dell_Unknown = 60, + MDType_Dell_Visor = 61, + MDType_Lenovo_Unknown = 70, + MDType_Lenovo_Explorer = 71, + MDType_HP_Unknown = 80, + MDType_HP_WindowsMR = 81, + MDType_HP_Reverb = 82, + MDType_Samsung_Unknown = 90, + MDType_Samsung_Odyssey = 91, + MDType_Unannounced_Unknown = 100, + MDType_Unannounced_WindowsMR = 101, + MDType_vridge = 110, + MDType_Huawei_Unknown = 120, + MDType_Huawei_VR2 = 121, + MDType_Huawei_EndOfRange = 129, + mdType_Valve_Unknown = 130, + mdType_Valve_Index = 131, } // // EMarketNotAllowedReasonFlags // - internal enum MarketNotAllowedReasonFlags : int + internal enum MarketNotAllowedReasonFlags : uint { None = 0, TemporaryFailure = 1, @@ -503,9 +524,37 @@ namespace Steamworks } // - // CGameID::EGameIDType + // EDurationControlProgress // - internal enum GameIDType : int + internal enum DurationControlProgress : uint + { + Progress_Full = 0, + Progress_Half = 1, + Progress_None = 2, + _ExitSoon_3h = 3, + _ExitSoon_5h = 4, + _ExitSoon_Night = 5, + } + + // + // EDurationControlNotification + // + internal enum DurationControlNotification : uint + { + None = 0, + DurationControlNotification1Hour = 1, + DurationControlNotification3Hours = 2, + HalfProgress = 3, + NoProgress = 4, + ExitSoon_3h = 5, + ExitSoon_5h = 6, + ExitSoon_Night = 7, + } + + // + // EGameIDType + // + internal enum GameIDType : uint { App = 0, GameMod = 1, @@ -516,7 +565,7 @@ namespace Steamworks // // EGameSearchErrorCode_t // - internal enum GameSearchErrorCode_t : int + internal enum GameSearchErrorCode_t : uint { OK = 1, Failed_Search_Already_In_Progress = 2, @@ -532,7 +581,7 @@ namespace Steamworks // // EPlayerResult_t // - internal enum PlayerResult_t : int + internal enum PlayerResult_t : uint { FailedToConnect = 1, Abandoned = 2, @@ -542,9 +591,29 @@ namespace Steamworks } // - // IPCFailure_t::EFailureType + // ESteamIPv6ConnectivityProtocol // - internal enum FailureType : int + internal enum SteamIPv6ConnectivityProtocol : uint + { + Invalid = 0, + HTTP = 1, + UDP = 2, + } + + // + // ESteamIPv6ConnectivityState + // + internal enum SteamIPv6ConnectivityState : uint + { + Unknown = 0, + Good = 1, + Bad = 2, + } + + // + // EFailureType + // + internal enum FailureType : uint { FlushedCallbackQueue = 0, PipeFail = 1, @@ -553,7 +622,7 @@ namespace Steamworks // // EFriendRelationship // - public enum Relationship : int + public enum Relationship : uint { None = 0, Blocked = 1, @@ -569,7 +638,7 @@ namespace Steamworks // // EPersonaState // - public enum FriendState : int + public enum FriendState : uint { Offline = 0, Online = 1, @@ -585,7 +654,7 @@ namespace Steamworks // // EFriendFlags // - public enum FriendFlags : int + public enum FriendFlags : uint { None = 0, Blocked = 1, @@ -604,7 +673,7 @@ namespace Steamworks // // EUserRestriction // - internal enum UserRestriction : int + internal enum UserRestriction : uint { None = 0, Unknown = 1, @@ -619,7 +688,7 @@ namespace Steamworks // // EOverlayToStoreFlag // - internal enum OverlayToStoreFlag : int + internal enum OverlayToStoreFlag : uint { None = 0, AddToCart = 1, @@ -629,7 +698,7 @@ namespace Steamworks // // EActivateGameOverlayToWebPageMode // - internal enum ActivateGameOverlayToWebPageMode : int + internal enum ActivateGameOverlayToWebPageMode : uint { Default = 0, Modal = 1, @@ -638,7 +707,7 @@ namespace Steamworks // // EPersonaChange // - internal enum PersonaChange : int + internal enum PersonaChange : uint { Name = 1, Status = 2, @@ -660,7 +729,7 @@ namespace Steamworks // // ESteamAPICallFailure // - internal enum SteamAPICallFailure : int + internal enum SteamAPICallFailure : uint { None = -1, SteamGone = 0, @@ -672,7 +741,7 @@ namespace Steamworks // // EGamepadTextInputMode // - public enum GamepadTextInputMode : int + public enum GamepadTextInputMode : uint { Normal = 0, Password = 1, @@ -681,7 +750,7 @@ namespace Steamworks // // EGamepadTextInputLineMode // - public enum GamepadTextInputLineMode : int + public enum GamepadTextInputLineMode : uint { SingleLine = 0, MultipleLines = 1, @@ -690,7 +759,7 @@ namespace Steamworks // // ECheckFileSignature // - public enum CheckFileSignature : int + public enum CheckFileSignature : uint { InvalidSignature = 0, ValidSignature = 1, @@ -702,7 +771,7 @@ namespace Steamworks // // EMatchMakingServerResponse // - internal enum MatchMakingServerResponse : int + internal enum MatchMakingServerResponse : uint { ServerResponded = 0, ServerFailedToRespond = 1, @@ -712,18 +781,19 @@ namespace Steamworks // // ELobbyType // - internal enum LobbyType : int + internal enum LobbyType : uint { Private = 0, FriendsOnly = 1, Public = 2, Invisible = 3, + PrivateUnique = 4, } // // ELobbyComparison // - internal enum LobbyComparison : int + internal enum LobbyComparison : uint { EqualToOrLessThan = -2, LessThan = -1, @@ -736,7 +806,7 @@ namespace Steamworks // // ELobbyDistanceFilter // - internal enum LobbyDistanceFilter : int + internal enum LobbyDistanceFilter : uint { Close = 0, Default = 1, @@ -747,7 +817,7 @@ namespace Steamworks // // EChatMemberStateChange // - internal enum ChatMemberStateChange : int + internal enum ChatMemberStateChange : uint { Entered = 1, Left = 2, @@ -759,7 +829,7 @@ namespace Steamworks // // ESteamPartyBeaconLocationType // - internal enum SteamPartyBeaconLocationType : int + internal enum SteamPartyBeaconLocationType : uint { Invalid = 0, ChatGroup = 1, @@ -769,7 +839,7 @@ namespace Steamworks // // ESteamPartyBeaconLocationData // - internal enum SteamPartyBeaconLocationData : int + internal enum SteamPartyBeaconLocationData : uint { Invalid = 0, Name = 1, @@ -779,9 +849,9 @@ namespace Steamworks } // - // RequestPlayersForGameResultCallback_t::PlayerAcceptState_t + // PlayerAcceptState_t // - internal enum PlayerAcceptState_t : int + internal enum PlayerAcceptState_t : uint { Unknown = 0, PlayerAccepted = 1, @@ -791,32 +861,34 @@ namespace Steamworks // // ERemoteStoragePlatform // - internal enum RemoteStoragePlatform : int + internal enum RemoteStoragePlatform : uint { None = 0, Windows = 1, OSX = 2, PS3 = 4, Linux = 8, - Reserved2 = 16, + Switch = 16, Android = 32, - All = -1, + IOS = 64, + All = 4294967295, } // // ERemoteStoragePublishedFileVisibility // - internal enum RemoteStoragePublishedFileVisibility : int + internal enum RemoteStoragePublishedFileVisibility : uint { Public = 0, FriendsOnly = 1, Private = 2, + Unlisted = 3, } // // EWorkshopFileType // - internal enum WorkshopFileType : int + internal enum WorkshopFileType : uint { First = 0, Community = 0, @@ -841,7 +913,7 @@ namespace Steamworks // // EWorkshopVote // - internal enum WorkshopVote : int + internal enum WorkshopVote : uint { Unvoted = 0, For = 1, @@ -852,7 +924,7 @@ namespace Steamworks // // EWorkshopFileAction // - internal enum WorkshopFileAction : int + internal enum WorkshopFileAction : uint { Played = 0, Completed = 1, @@ -861,7 +933,7 @@ namespace Steamworks // // EWorkshopEnumerationType // - internal enum WorkshopEnumerationType : int + internal enum WorkshopEnumerationType : uint { RankedByVote = 0, Recent = 1, @@ -875,7 +947,7 @@ namespace Steamworks // // EWorkshopVideoProvider // - internal enum WorkshopVideoProvider : int + internal enum WorkshopVideoProvider : uint { None = 0, Youtube = 1, @@ -884,7 +956,7 @@ namespace Steamworks // // EUGCReadAction // - internal enum UGCReadAction : int + internal enum UGCReadAction : uint { ontinueReadingUntilFinished = 0, ontinueReading = 1, @@ -894,7 +966,7 @@ namespace Steamworks // // ELeaderboardDataRequest // - internal enum LeaderboardDataRequest : int + internal enum LeaderboardDataRequest : uint { Global = 0, GlobalAroundUser = 1, @@ -911,7 +983,7 @@ namespace Steamworks // // ELeaderboardUploadScoreMethod // - internal enum LeaderboardUploadScoreMethod : int + internal enum LeaderboardUploadScoreMethod : uint { None = 0, KeepBest = 1, @@ -921,7 +993,7 @@ namespace Steamworks // // ERegisterActivationCodeResult // - internal enum RegisterActivationCodeResult : int + internal enum RegisterActivationCodeResult : uint { ResultOK = 0, ResultFail = 1, @@ -933,7 +1005,7 @@ namespace Steamworks // // EP2PSessionError // - public enum P2PSessionError : int + public enum P2PSessionError : uint { None = 0, NotRunningApp = 1, @@ -946,7 +1018,7 @@ namespace Steamworks // // EP2PSend // - public enum P2PSend : int + public enum P2PSend : uint { Unreliable = 0, UnreliableNoDelay = 1, @@ -957,7 +1029,7 @@ namespace Steamworks // // ESNetSocketState // - internal enum SNetSocketState : int + internal enum SNetSocketState : uint { Invalid = 0, Connected = 1, @@ -975,7 +1047,7 @@ namespace Steamworks // // ESNetSocketConnectionType // - internal enum SNetSocketConnectionType : int + internal enum SNetSocketConnectionType : uint { NotConnected = 0, UDP = 1, @@ -985,7 +1057,7 @@ namespace Steamworks // // EVRScreenshotType // - internal enum VRScreenshotType : int + internal enum VRScreenshotType : uint { None = 0, Mono = 1, @@ -998,7 +1070,7 @@ namespace Steamworks // // AudioPlayback_Status // - public enum MusicStatus : int + public enum MusicStatus : uint { Undefined = 0, Playing = 1, @@ -1009,7 +1081,7 @@ namespace Steamworks // // EHTTPMethod // - internal enum HTTPMethod : int + internal enum HTTPMethod : uint { Invalid = 0, GET = 1, @@ -1024,7 +1096,7 @@ namespace Steamworks // // EHTTPStatusCode // - internal enum HTTPStatusCode : int + internal enum HTTPStatusCode : uint { Invalid = 0, HTTPStatusCode100Continue = 100, @@ -1072,35 +1144,10 @@ namespace Steamworks HTTPStatusCode5xxUnknown = 599, } - // - // EInputSource - // - internal enum InputSource : int - { - None = 0, - LeftTrackpad = 1, - RightTrackpad = 2, - Joystick = 3, - ABXY = 4, - Switch = 5, - LeftTrigger = 6, - RightTrigger = 7, - LeftBumper = 8, - RightBumper = 9, - Gyro = 10, - CenterTrackpad = 11, - RightJoystick = 12, - DPad = 13, - Key = 14, - Mouse = 15, - LeftGyro = 16, - Count = 17, - } - // // EInputSourceMode // - public enum InputSourceMode : int + public enum InputSourceMode : uint { None = 0, Dpad = 1, @@ -1124,7 +1171,7 @@ namespace Steamworks // // EInputActionOrigin // - internal enum InputActionOrigin : int + internal enum InputActionOrigin : uint { None = 0, SteamController_A = 1, @@ -1229,7 +1276,7 @@ namespace Steamworks PS4_Gyro_Pitch = 100, PS4_Gyro_Yaw = 101, PS4_Gyro_Roll = 102, - PS4_Reserved0 = 103, + PS4_DPad_Move = 103, PS4_Reserved1 = 104, PS4_Reserved2 = 105, PS4_Reserved3 = 106, @@ -1268,7 +1315,7 @@ namespace Steamworks XBoxOne_DPad_South = 139, XBoxOne_DPad_West = 140, XBoxOne_DPad_East = 141, - XBoxOne_Reserved0 = 142, + XBoxOne_DPad_Move = 142, XBoxOne_Reserved1 = 143, XBoxOne_Reserved2 = 144, XBoxOne_Reserved3 = 145, @@ -1307,7 +1354,7 @@ namespace Steamworks XBox360_DPad_South = 178, XBox360_DPad_West = 179, XBox360_DPad_East = 180, - XBox360_Reserved0 = 181, + XBox360_DPad_Move = 181, XBox360_Reserved1 = 182, XBox360_Reserved2 = 183, XBox360_Reserved3 = 184, @@ -1351,7 +1398,7 @@ namespace Steamworks Switch_ProGyro_Pitch = 222, Switch_ProGyro_Yaw = 223, Switch_ProGyro_Roll = 224, - Switch_Reserved0 = 225, + Switch_DPad_Move = 225, Switch_Reserved1 = 226, Switch_Reserved2 = 227, Switch_Reserved3 = 228, @@ -1391,7 +1438,7 @@ namespace Steamworks // // EXboxOrigin // - internal enum XboxOrigin : int + internal enum XboxOrigin : uint { A = 0, B = 1, @@ -1427,7 +1474,7 @@ namespace Steamworks // // ESteamControllerPad // - internal enum SteamControllerPad : int + internal enum SteamControllerPad : uint { Left = 0, Right = 1, @@ -1436,7 +1483,7 @@ namespace Steamworks // // ESteamInputType // - public enum InputType : int + public enum InputType : uint { Unknown = 0, SteamController = 1, @@ -1458,65 +1505,16 @@ namespace Steamworks // // ESteamInputLEDFlag // - internal enum SteamInputLEDFlag : int + internal enum SteamInputLEDFlag : uint { SetColor = 0, RestoreUserDefault = 1, } - // - // EControllerSource - // - internal enum ControllerSource : int - { - None = 0, - LeftTrackpad = 1, - RightTrackpad = 2, - Joystick = 3, - ABXY = 4, - Switch = 5, - LeftTrigger = 6, - RightTrigger = 7, - LeftBumper = 8, - RightBumper = 9, - Gyro = 10, - CenterTrackpad = 11, - RightJoystick = 12, - DPad = 13, - Key = 14, - Mouse = 15, - LeftGyro = 16, - Count = 17, - } - - // - // EControllerSourceMode - // - internal enum ControllerSourceMode : int - { - None = 0, - Dpad = 1, - Buttons = 2, - FourButtons = 3, - AbsoluteMouse = 4, - RelativeMouse = 5, - JoystickMove = 6, - JoystickMouse = 7, - JoystickCamera = 8, - ScrollWheel = 9, - Trigger = 10, - TouchMenu = 11, - MouseJoystick = 12, - MouseRegion = 13, - RadialMenu = 14, - SingleButton = 15, - Switches = 16, - } - // // EControllerActionOrigin // - internal enum ControllerActionOrigin : int + internal enum ControllerActionOrigin : uint { None = 0, A = 1, @@ -1759,14 +1757,18 @@ namespace Steamworks Switch_LeftGrip_Upper = 238, Switch_RightGrip_Lower = 239, Switch_RightGrip_Upper = 240, - Count = 241, + PS4_DPad_Move = 241, + XBoxOne_DPad_Move = 242, + XBox360_DPad_Move = 243, + Switch_DPad_Move = 244, + Count = 245, MaximumPossibleValue = 32767, } // // ESteamControllerLEDFlag // - internal enum SteamControllerLEDFlag : int + internal enum SteamControllerLEDFlag : uint { SetColor = 0, RestoreUserDefault = 1, @@ -1775,7 +1777,7 @@ namespace Steamworks // // EUGCMatchingUGCType // - public enum UgcType : int + public enum UgcType : uint { Items = 0, Items_Mtx = 1, @@ -1796,7 +1798,7 @@ namespace Steamworks // // EUserUGCList // - internal enum UserUGCList : int + internal enum UserUGCList : uint { Published = 0, VotedOn = 1, @@ -1812,7 +1814,7 @@ namespace Steamworks // // EUserUGCListSortOrder // - internal enum UserUGCListSortOrder : int + internal enum UserUGCListSortOrder : uint { CreationOrderDesc = 0, CreationOrderAsc = 1, @@ -1826,7 +1828,7 @@ namespace Steamworks // // EUGCQuery // - internal enum UGCQuery : int + internal enum UGCQuery : uint { RankedByVote = 0, RankedByPublicationDate = 1, @@ -1852,7 +1854,7 @@ namespace Steamworks // // EItemUpdateStatus // - internal enum ItemUpdateStatus : int + internal enum ItemUpdateStatus : uint { Invalid = 0, PreparingConfig = 1, @@ -1865,7 +1867,7 @@ namespace Steamworks // // EItemState // - internal enum ItemState : int + internal enum ItemState : uint { None = 0, Subscribed = 1, @@ -1879,7 +1881,7 @@ namespace Steamworks // // EItemStatistic // - internal enum ItemStatistic : int + internal enum ItemStatistic : uint { NumSubscriptions = 0, NumFavorites = 1, @@ -1899,7 +1901,7 @@ namespace Steamworks // // EItemPreviewType // - internal enum ItemPreviewType : int + internal enum ItemPreviewType : uint { Image = 0, YouTubeVideo = 1, @@ -1910,9 +1912,9 @@ namespace Steamworks } // - // ISteamHTMLSurface::EHTMLMouseButton + // EHTMLMouseButton // - internal enum HTMLMouseButton : int + internal enum HTMLMouseButton : uint { Left = 0, Right = 1, @@ -1920,9 +1922,9 @@ namespace Steamworks } // - // ISteamHTMLSurface::EMouseCursor + // EMouseCursor // - internal enum MouseCursor : int + internal enum MouseCursor : uint { user = 0, none = 1, @@ -1969,9 +1971,9 @@ namespace Steamworks } // - // ISteamHTMLSurface::EHTMLKeyModifiers + // EHTMLKeyModifiers // - internal enum HTMLKeyModifiers : int + internal enum HTMLKeyModifiers : uint { None = 0, AltDown = 1, @@ -1982,17 +1984,28 @@ namespace Steamworks // // ESteamItemFlags // - internal enum SteamItemFlags : int + internal enum SteamItemFlags : uint { NoTrade = 1, Removed = 256, Consumed = 512, } + // + // ESteamTVRegionBehavior + // + internal enum SteamTVRegionBehavior : uint + { + Invalid = -1, + Hover = 0, + ClickPopup = 1, + ClickSurroundingRegion = 2, + } + // // EParentalFeature // - public enum ParentalFeature : int + public enum ParentalFeature : uint { Invalid = 0, Store = 1, @@ -2007,7 +2020,217 @@ namespace Steamworks ParentalSetup = 10, Library = 11, Test = 12, - Max = 13, + SiteLicense = 13, + Max = 14, + } + + // + // ESteamDeviceFormFactor + // + internal enum SteamDeviceFormFactor : uint + { + Unknown = 0, + Phone = 1, + Tablet = 2, + Computer = 3, + TV = 4, + } + + // + // ESteamNetworkingAvailability + // + internal enum SteamNetworkingAvailability : uint + { + CannotTry = -102, + Failed = -101, + Previously = -100, + Retrying = -10, + NeverTried = 1, + Waiting = 2, + Attempting = 3, + Current = 100, + Unknown = 0, + _Force32bit = 2147483647, + } + + // + // ESteamNetworkingIdentityType + // + internal enum NetIdentityType : uint + { + Invalid = 0, + SteamID = 16, + XboxPairwiseID = 17, + IPAddress = 1, + GenericString = 2, + GenericBytes = 3, + UnknownType = 4, + _Force32bit = 2147483647, + } + + // + // ESteamNetworkingConnectionState + // + internal enum ConnectionState : uint + { + None = 0, + Connecting = 1, + FindingRoute = 2, + Connected = 3, + ClosedByPeer = 4, + ProblemDetectedLocally = 5, + FinWait = -1, + Linger = -2, + Dead = -3, + _Force32Bit = 2147483647, + } + + // + // ESteamNetConnectionEnd + // + internal enum SteamNetConnectionEnd : uint + { + Invalid = 0, + App_Min = 1000, + App_Generic = 1000, + App_Max = 1999, + AppException_Min = 2000, + AppException_Generic = 2000, + AppException_Max = 2999, + Local_Min = 3000, + Local_OfflineMode = 3001, + Local_ManyRelayConnectivity = 3002, + Local_HostedServerPrimaryRelay = 3003, + Local_NetworkConfig = 3004, + Local_Rights = 3005, + Local_Max = 3999, + Remote_Min = 4000, + Remote_Timeout = 4001, + Remote_BadCrypt = 4002, + Remote_BadCert = 4003, + Remote_NotLoggedIn = 4004, + Remote_NotRunningApp = 4005, + Remote_BadProtocolVersion = 4006, + Remote_Max = 4999, + Misc_Min = 5000, + Misc_Generic = 5001, + Misc_InternalError = 5002, + Misc_Timeout = 5003, + Misc_RelayConnectivity = 5004, + Misc_SteamConnectivity = 5005, + Misc_NoRelaySessionsToClient = 5006, + Misc_Max = 5999, + _Force32Bit = 2147483647, + } + + // + // ESteamNetworkingConfigScope + // + internal enum NetScope : uint + { + _Global = 1, + _SocketsInterface = 2, + _ListenSocket = 3, + _Connection = 4, + Scope__Force32Bit = 2147483647, + } + + // + // ESteamNetworkingConfigDataType + // + internal enum NetConfigType : uint + { + _Int32 = 1, + _Int64 = 2, + _Float = 3, + _String = 4, + _FunctionPtr = 5, + DataType__Force32Bit = 2147483647, + } + + // + // ESteamNetworkingConfigValue + // + internal enum NetConfig : uint + { + _Invalid = 0, + _FakePacketLoss_Send = 2, + _FakePacketLoss_Recv = 3, + _FakePacketLag_Send = 4, + _FakePacketLag_Recv = 5, + _FakePacketReorder_Send = 6, + _FakePacketReorder_Recv = 7, + _FakePacketReorder_Time = 8, + _FakePacketDup_Send = 26, + _FakePacketDup_Recv = 27, + _FakePacketDup_TimeMax = 28, + _TimeoutInitial = 24, + _TimeoutConnected = 25, + _SendBufferSize = 9, + _SendRateMin = 10, + _SendRateMax = 11, + _NagleTime = 12, + _IP_AllowWithoutAuth = 23, + _MTU_PacketSize = 32, + _MTU_DataSize = 33, + _Unencrypted = 34, + _EnumerateDevVars = 35, + _SDRClient_ConsecutitivePingTimeoutsFailInitial = 19, + _SDRClient_ConsecutitivePingTimeoutsFail = 20, + _SDRClient_MinPingsBeforePingAccurate = 21, + _SDRClient_SingleSocket = 22, + _SDRClient_ForceRelayCluster = 29, + _SDRClient_DebugTicketAddress = 30, + _SDRClient_ForceProxyAddr = 31, + _SDRClient_FakeClusterPing = 36, + _LogLevel_AckRTT = 13, + _LogLevel_PacketDecode = 14, + _LogLevel_Message = 15, + _LogLevel_PacketGaps = 16, + _LogLevel_P2PRendezvous = 17, + _LogLevel_SDRRelayPings = 18, + Value__Force32Bit = 2147483647, + } + + // + // ESteamNetworkingGetConfigValueResult + // + internal enum NetConfigResult : uint + { + _BadValue = -1, + _BadScopeObj = -2, + _BufferTooSmall = -3, + _OK = 1, + _OKInherited = 2, + Result__Force32Bit = 2147483647, + } + + // + // ESteamNetworkingSocketsDebugOutputType + // + internal enum DebugOutputType : uint + { + None = 0, + Bug = 1, + Error = 2, + Important = 3, + Warning = 4, + Msg = 5, + Verbose = 6, + Debug = 7, + Everything = 8, + _Force32Bit = 2147483647, + } + + // + // EServerMode + // + internal enum ServerMode : uint + { + Invalid = 0, + NoAuthentication = 1, + Authentication = 2, + AuthenticationAndSecure = 3, } } diff --git a/Facepunch.Steamworks/Generated/SteamStructs.cs b/Facepunch.Steamworks/Generated/SteamStructs.cs index f44e8ba..416cdb4 100644 --- a/Facepunch.Steamworks/Generated/SteamStructs.cs +++ b/Facepunch.Steamworks/Generated/SteamStructs.cs @@ -7,29 +7,46 @@ using System.Threading.Tasks; namespace Steamworks.Data { [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct CallbackMsg_t + internal struct SteamServersConnected_t : ICallbackData { - internal int SteamUser; // m_hSteamUser HSteamUser - internal int Callback; // m_iCallback int - internal IntPtr ParamPtr; // m_pubParam uint8 * - internal int ParamCount; // m_cubParam int - #region Marshalling - internal static CallbackMsg_t Fill( IntPtr p ) => ((CallbackMsg_t)(CallbackMsg_t) Marshal.PtrToStructure( p, typeof(CallbackMsg_t) ) ); + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SteamServersConnected_t) ); + public int DataSize => _datasize; + public int CallbackId => 101; + internal static SteamServersConnected_t Fill( IntPtr p ) => ((SteamServersConnected_t)Marshal.PtrToStructure( p, typeof(SteamServersConnected_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 101, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 101, false ); + actionClient = action; + } + } #endregion } [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct SteamServerConnectFailure_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult [MarshalAs(UnmanagedType.I1)] - internal bool StillRetrying; // m_bStillRetrying _Bool + internal bool StillRetrying; // m_bStillRetrying bool #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SteamServerConnectFailure_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUser + 2; + public int CallbackId => 102; internal static SteamServerConnectFailure_t Fill( IntPtr p ) => ((SteamServerConnectFailure_t)Marshal.PtrToStructure( p, typeof(SteamServerConnectFailure_t) ) ); static Action actionClient; @@ -40,12 +57,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUser + 2, true ); + Event.Register( OnServer, _datasize, 102, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUser + 2, false ); + Event.Register( OnClient, _datasize, 102, false ); actionClient = action; } } @@ -55,12 +72,12 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct SteamServersDisconnected_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SteamServersDisconnected_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUser + 3; + public int CallbackId => 103; internal static SteamServersDisconnected_t Fill( IntPtr p ) => ((SteamServersDisconnected_t)Marshal.PtrToStructure( p, typeof(SteamServersDisconnected_t) ) ); static Action actionClient; @@ -71,12 +88,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUser + 3, true ); + Event.Register( OnServer, _datasize, 103, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUser + 3, false ); + Event.Register( OnClient, _datasize, 103, false ); actionClient = action; } } @@ -95,7 +112,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(ClientGameServerDeny_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUser + 13; + public int CallbackId => 113; internal static ClientGameServerDeny_t Fill( IntPtr p ) => ((ClientGameServerDeny_t)Marshal.PtrToStructure( p, typeof(ClientGameServerDeny_t) ) ); static Action actionClient; @@ -106,12 +123,73 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUser + 13, true ); + Event.Register( OnServer, _datasize, 113, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUser + 13, false ); + Event.Register( OnClient, _datasize, 113, false ); + actionClient = action; + } + } + #endregion + } + + [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] + internal struct IPCFailure_t : ICallbackData + { + internal byte FailureType; // m_eFailureType uint8 + + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(IPCFailure_t) ); + public int DataSize => _datasize; + public int CallbackId => 117; + internal static IPCFailure_t Fill( IntPtr p ) => ((IPCFailure_t)Marshal.PtrToStructure( p, typeof(IPCFailure_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 117, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 117, false ); + actionClient = action; + } + } + #endregion + } + + [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] + internal struct LicensesUpdated_t : ICallbackData + { + + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(LicensesUpdated_t) ); + public int DataSize => _datasize; + public int CallbackId => 125; + internal static LicensesUpdated_t Fill( IntPtr p ) => ((LicensesUpdated_t)Marshal.PtrToStructure( p, typeof(LicensesUpdated_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 125, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 125, false ); actionClient = action; } } @@ -121,14 +199,14 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct ValidateAuthTicketResponse_t : ICallbackData { - internal ulong SteamID; // m_SteamID class CSteamID - internal AuthResponse AuthSessionResponse; // m_eAuthSessionResponse enum EAuthSessionResponse - internal ulong OwnerSteamID; // m_OwnerSteamID class CSteamID + internal ulong SteamID; // m_SteamID CSteamID + internal AuthResponse AuthSessionResponse; // m_eAuthSessionResponse EAuthSessionResponse + internal ulong OwnerSteamID; // m_OwnerSteamID CSteamID #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(ValidateAuthTicketResponse_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUser + 43; + public int CallbackId => 143; internal static ValidateAuthTicketResponse_t Fill( IntPtr p ) => ((ValidateAuthTicketResponse_t)Marshal.PtrToStructure( p, typeof(ValidateAuthTicketResponse_t) ) ); static Action actionClient; @@ -139,12 +217,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUser + 43, true ); + Event.Register( OnServer, _datasize, 143, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUser + 43, false ); + Event.Register( OnClient, _datasize, 143, false ); actionClient = action; } } @@ -161,7 +239,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(MicroTxnAuthorizationResponse_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUser + 52; + public int CallbackId => 152; internal static MicroTxnAuthorizationResponse_t Fill( IntPtr p ) => ((MicroTxnAuthorizationResponse_t)Marshal.PtrToStructure( p, typeof(MicroTxnAuthorizationResponse_t) ) ); static Action actionClient; @@ -172,12 +250,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUser + 52, true ); + Event.Register( OnServer, _datasize, 152, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUser + 52, false ); + Event.Register( OnClient, _datasize, 152, false ); actionClient = action; } } @@ -187,12 +265,12 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct EncryptedAppTicketResponse_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(EncryptedAppTicketResponse_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUser + 54; + public int CallbackId => 154; internal static EncryptedAppTicketResponse_t Fill( IntPtr p ) => ((EncryptedAppTicketResponse_t)Marshal.PtrToStructure( p, typeof(EncryptedAppTicketResponse_t) ) ); static Action actionClient; @@ -203,12 +281,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUser + 54, true ); + Event.Register( OnServer, _datasize, 154, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUser + 54, false ); + Event.Register( OnClient, _datasize, 154, false ); actionClient = action; } } @@ -219,12 +297,12 @@ namespace Steamworks.Data internal struct GetAuthSessionTicketResponse_t : ICallbackData { internal uint AuthTicket; // m_hAuthTicket HAuthTicket - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GetAuthSessionTicketResponse_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUser + 63; + public int CallbackId => 163; internal static GetAuthSessionTicketResponse_t Fill( IntPtr p ) => ((GetAuthSessionTicketResponse_t)Marshal.PtrToStructure( p, typeof(GetAuthSessionTicketResponse_t) ) ); static Action actionClient; @@ -235,12 +313,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUser + 63, true ); + Event.Register( OnServer, _datasize, 163, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUser + 63, false ); + Event.Register( OnClient, _datasize, 163, false ); actionClient = action; } } @@ -257,7 +335,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GameWebCallback_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUser + 64; + public int CallbackId => 164; internal static GameWebCallback_t Fill( IntPtr p ) => ((GameWebCallback_t)Marshal.PtrToStructure( p, typeof(GameWebCallback_t) ) ); static Action actionClient; @@ -268,12 +346,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUser + 64, true ); + Event.Register( OnServer, _datasize, 164, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUser + 64, false ); + Event.Register( OnClient, _datasize, 164, false ); actionClient = action; } } @@ -290,7 +368,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(StoreAuthURLResponse_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUser + 65; + public int CallbackId => 165; internal static StoreAuthURLResponse_t Fill( IntPtr p ) => ((StoreAuthURLResponse_t)Marshal.PtrToStructure( p, typeof(StoreAuthURLResponse_t) ) ); static Action actionClient; @@ -301,12 +379,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUser + 65, true ); + Event.Register( OnServer, _datasize, 165, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUser + 65, false ); + Event.Register( OnClient, _datasize, 165, false ); actionClient = action; } } @@ -317,8 +395,8 @@ namespace Steamworks.Data internal struct MarketEligibilityResponse_t : ICallbackData { [MarshalAs(UnmanagedType.I1)] - internal bool Allowed; // m_bAllowed _Bool - internal MarketNotAllowedReasonFlags NotAllowedReason; // m_eNotAllowedReason enum EMarketNotAllowedReasonFlags + internal bool Allowed; // m_bAllowed bool + internal MarketNotAllowedReasonFlags NotAllowedReason; // m_eNotAllowedReason EMarketNotAllowedReasonFlags internal uint TAllowedAtTime; // m_rtAllowedAtTime RTime32 internal int CdaySteamGuardRequiredDays; // m_cdaySteamGuardRequiredDays int internal int CdayNewDeviceCooldown; // m_cdayNewDeviceCooldown int @@ -326,7 +404,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(MarketEligibilityResponse_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUser + 66; + public int CallbackId => 166; internal static MarketEligibilityResponse_t Fill( IntPtr p ) => ((MarketEligibilityResponse_t)Marshal.PtrToStructure( p, typeof(MarketEligibilityResponse_t) ) ); static Action actionClient; @@ -337,40 +415,54 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUser + 66, true ); + Event.Register( OnServer, _datasize, 166, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUser + 66, false ); + Event.Register( OnClient, _datasize, 166, false ); actionClient = action; } } #endregion } - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] - internal struct FriendGameInfo_t - { - internal GameId GameID; // m_gameID class CGameID - internal uint GameIP; // m_unGameIP uint32 - internal ushort GamePort; // m_usGamePort uint16 - internal ushort QueryPort; // m_usQueryPort uint16 - internal ulong SteamIDLobby; // m_steamIDLobby class CSteamID - - #region Marshalling - internal static FriendGameInfo_t Fill( IntPtr p ) => ((FriendGameInfo_t)(FriendGameInfo_t) Marshal.PtrToStructure( p, typeof(FriendGameInfo_t) ) ); - #endregion - } - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct FriendSessionStateInfo_t + internal struct DurationControl_t : ICallbackData { - internal uint IOnlineSessionInstances; // m_uiOnlineSessionInstances uint32 - internal byte IPublishedToFriendsSessionInstance; // m_uiPublishedToFriendsSessionInstance uint8 + internal Result Result; // m_eResult EResult + internal AppId Appid; // m_appid AppId_t + [MarshalAs(UnmanagedType.I1)] + internal bool Applicable; // m_bApplicable bool + internal int CsecsLast5h; // m_csecsLast5h int32 + internal DurationControlProgress Progress; // m_progress EDurationControlProgress + internal DurationControlNotification Otification; // m_notification EDurationControlNotification + internal int CsecsToday; // m_csecsToday int32 + internal int CsecsRemaining; // m_csecsRemaining int32 - #region Marshalling - internal static FriendSessionStateInfo_t Fill( IntPtr p ) => ((FriendSessionStateInfo_t)(FriendSessionStateInfo_t) Marshal.PtrToStructure( p, typeof(FriendSessionStateInfo_t) ) ); + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(DurationControl_t) ); + public int DataSize => _datasize; + public int CallbackId => 167; + internal static DurationControl_t Fill( IntPtr p ) => ((DurationControl_t)Marshal.PtrToStructure( p, typeof(DurationControl_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 167, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 167, false ); + actionClient = action; + } + } #endregion } @@ -383,7 +475,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(FriendStateChange_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamFriends + 4; + public int CallbackId => 304; internal static FriendStateChange_t Fill( IntPtr p ) => ((FriendStateChange_t)Marshal.PtrToStructure( p, typeof(FriendStateChange_t) ) ); static Action actionClient; @@ -394,12 +486,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamFriends + 4, true ); + Event.Register( OnServer, _datasize, 304, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamFriends + 4, false ); + Event.Register( OnClient, _datasize, 304, false ); actionClient = action; } } @@ -414,7 +506,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GameOverlayActivated_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamFriends + 31; + public int CallbackId => 331; internal static GameOverlayActivated_t Fill( IntPtr p ) => ((GameOverlayActivated_t)Marshal.PtrToStructure( p, typeof(GameOverlayActivated_t) ) ); static Action actionClient; @@ -425,12 +517,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamFriends + 31, true ); + Event.Register( OnServer, _datasize, 331, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamFriends + 31, false ); + Event.Register( OnClient, _datasize, 331, false ); actionClient = action; } } @@ -450,7 +542,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GameServerChangeRequested_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamFriends + 32; + public int CallbackId => 332; internal static GameServerChangeRequested_t Fill( IntPtr p ) => ((GameServerChangeRequested_t)Marshal.PtrToStructure( p, typeof(GameServerChangeRequested_t) ) ); static Action actionClient; @@ -461,12 +553,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamFriends + 32, true ); + Event.Register( OnServer, _datasize, 332, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamFriends + 32, false ); + Event.Register( OnClient, _datasize, 332, false ); actionClient = action; } } @@ -476,13 +568,13 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct GameLobbyJoinRequested_t : ICallbackData { - internal ulong SteamIDLobby; // m_steamIDLobby class CSteamID - internal ulong SteamIDFriend; // m_steamIDFriend class CSteamID + internal ulong SteamIDLobby; // m_steamIDLobby CSteamID + internal ulong SteamIDFriend; // m_steamIDFriend CSteamID #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GameLobbyJoinRequested_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamFriends + 33; + public int CallbackId => 333; internal static GameLobbyJoinRequested_t Fill( IntPtr p ) => ((GameLobbyJoinRequested_t)Marshal.PtrToStructure( p, typeof(GameLobbyJoinRequested_t) ) ); static Action actionClient; @@ -493,12 +585,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamFriends + 33, true ); + Event.Register( OnServer, _datasize, 333, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamFriends + 33, false ); + Event.Register( OnClient, _datasize, 333, false ); actionClient = action; } } @@ -508,7 +600,7 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct AvatarImageLoaded_t : ICallbackData { - internal ulong SteamID; // m_steamID class CSteamID + internal ulong SteamID; // m_steamID CSteamID internal int Image; // m_iImage int internal int Wide; // m_iWide int internal int Tall; // m_iTall int @@ -516,7 +608,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(AvatarImageLoaded_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamFriends + 34; + public int CallbackId => 334; internal static AvatarImageLoaded_t Fill( IntPtr p ) => ((AvatarImageLoaded_t)Marshal.PtrToStructure( p, typeof(AvatarImageLoaded_t) ) ); static Action actionClient; @@ -527,12 +619,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamFriends + 34, true ); + Event.Register( OnServer, _datasize, 334, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamFriends + 34, false ); + Event.Register( OnClient, _datasize, 334, false ); actionClient = action; } } @@ -542,14 +634,14 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct ClanOfficerListResponse_t : ICallbackData { - internal ulong SteamIDClan; // m_steamIDClan class CSteamID + internal ulong SteamIDClan; // m_steamIDClan CSteamID internal int COfficers; // m_cOfficers int internal byte Success; // m_bSuccess uint8 #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(ClanOfficerListResponse_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamFriends + 35; + public int CallbackId => 335; internal static ClanOfficerListResponse_t Fill( IntPtr p ) => ((ClanOfficerListResponse_t)Marshal.PtrToStructure( p, typeof(ClanOfficerListResponse_t) ) ); static Action actionClient; @@ -560,12 +652,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamFriends + 35, true ); + Event.Register( OnServer, _datasize, 335, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamFriends + 35, false ); + Event.Register( OnClient, _datasize, 335, false ); actionClient = action; } } @@ -575,13 +667,13 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct FriendRichPresenceUpdate_t : ICallbackData { - internal ulong SteamIDFriend; // m_steamIDFriend class CSteamID + internal ulong SteamIDFriend; // m_steamIDFriend CSteamID internal AppId AppID; // m_nAppID AppId_t #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(FriendRichPresenceUpdate_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamFriends + 36; + public int CallbackId => 336; internal static FriendRichPresenceUpdate_t Fill( IntPtr p ) => ((FriendRichPresenceUpdate_t)Marshal.PtrToStructure( p, typeof(FriendRichPresenceUpdate_t) ) ); static Action actionClient; @@ -592,12 +684,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamFriends + 36, true ); + Event.Register( OnServer, _datasize, 336, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamFriends + 36, false ); + Event.Register( OnClient, _datasize, 336, false ); actionClient = action; } } @@ -607,7 +699,7 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct GameRichPresenceJoinRequested_t : ICallbackData { - internal ulong SteamIDFriend; // m_steamIDFriend class CSteamID + internal ulong SteamIDFriend; // m_steamIDFriend CSteamID internal string ConnectUTF8() => System.Text.Encoding.UTF8.GetString( Connect, 0, System.Array.IndexOf( Connect, 0 ) ); [MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)] // byte[] m_rgchConnect internal byte[] Connect; // m_rgchConnect char [256] @@ -615,7 +707,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GameRichPresenceJoinRequested_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamFriends + 37; + public int CallbackId => 337; internal static GameRichPresenceJoinRequested_t Fill( IntPtr p ) => ((GameRichPresenceJoinRequested_t)Marshal.PtrToStructure( p, typeof(GameRichPresenceJoinRequested_t) ) ); static Action actionClient; @@ -626,12 +718,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamFriends + 37, true ); + Event.Register( OnServer, _datasize, 337, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamFriends + 37, false ); + Event.Register( OnClient, _datasize, 337, false ); actionClient = action; } } @@ -641,14 +733,14 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct GameConnectedClanChatMsg_t : ICallbackData { - internal ulong SteamIDClanChat; // m_steamIDClanChat class CSteamID - internal ulong SteamIDUser; // m_steamIDUser class CSteamID + internal ulong SteamIDClanChat; // m_steamIDClanChat CSteamID + internal ulong SteamIDUser; // m_steamIDUser CSteamID internal int MessageID; // m_iMessageID int #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GameConnectedClanChatMsg_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamFriends + 38; + public int CallbackId => 338; internal static GameConnectedClanChatMsg_t Fill( IntPtr p ) => ((GameConnectedClanChatMsg_t)Marshal.PtrToStructure( p, typeof(GameConnectedClanChatMsg_t) ) ); static Action actionClient; @@ -659,12 +751,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamFriends + 38, true ); + Event.Register( OnServer, _datasize, 338, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamFriends + 38, false ); + Event.Register( OnClient, _datasize, 338, false ); actionClient = action; } } @@ -674,13 +766,13 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct GameConnectedChatJoin_t : ICallbackData { - internal ulong SteamIDClanChat; // m_steamIDClanChat class CSteamID - internal ulong SteamIDUser; // m_steamIDUser class CSteamID + internal ulong SteamIDClanChat; // m_steamIDClanChat CSteamID + internal ulong SteamIDUser; // m_steamIDUser CSteamID #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GameConnectedChatJoin_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamFriends + 39; + public int CallbackId => 339; internal static GameConnectedChatJoin_t Fill( IntPtr p ) => ((GameConnectedChatJoin_t)Marshal.PtrToStructure( p, typeof(GameConnectedChatJoin_t) ) ); static Action actionClient; @@ -691,12 +783,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamFriends + 39, true ); + Event.Register( OnServer, _datasize, 339, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamFriends + 39, false ); + Event.Register( OnClient, _datasize, 339, false ); actionClient = action; } } @@ -706,17 +798,17 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct GameConnectedChatLeave_t : ICallbackData { - internal ulong SteamIDClanChat; // m_steamIDClanChat class CSteamID - internal ulong SteamIDUser; // m_steamIDUser class CSteamID + internal ulong SteamIDClanChat; // m_steamIDClanChat CSteamID + internal ulong SteamIDUser; // m_steamIDUser CSteamID [MarshalAs(UnmanagedType.I1)] - internal bool Kicked; // m_bKicked _Bool + internal bool Kicked; // m_bKicked bool [MarshalAs(UnmanagedType.I1)] - internal bool Dropped; // m_bDropped _Bool + internal bool Dropped; // m_bDropped bool #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GameConnectedChatLeave_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamFriends + 40; + public int CallbackId => 340; internal static GameConnectedChatLeave_t Fill( IntPtr p ) => ((GameConnectedChatLeave_t)Marshal.PtrToStructure( p, typeof(GameConnectedChatLeave_t) ) ); static Action actionClient; @@ -727,12 +819,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamFriends + 40, true ); + Event.Register( OnServer, _datasize, 340, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamFriends + 40, false ); + Event.Register( OnClient, _datasize, 340, false ); actionClient = action; } } @@ -743,12 +835,12 @@ namespace Steamworks.Data internal struct DownloadClanActivityCountsResult_t : ICallbackData { [MarshalAs(UnmanagedType.I1)] - internal bool Success; // m_bSuccess _Bool + internal bool Success; // m_bSuccess bool #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(DownloadClanActivityCountsResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamFriends + 41; + public int CallbackId => 341; internal static DownloadClanActivityCountsResult_t Fill( IntPtr p ) => ((DownloadClanActivityCountsResult_t)Marshal.PtrToStructure( p, typeof(DownloadClanActivityCountsResult_t) ) ); static Action actionClient; @@ -759,12 +851,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamFriends + 41, true ); + Event.Register( OnServer, _datasize, 341, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamFriends + 41, false ); + Event.Register( OnClient, _datasize, 341, false ); actionClient = action; } } @@ -774,13 +866,13 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct JoinClanChatRoomCompletionResult_t : ICallbackData { - internal ulong SteamIDClanChat; // m_steamIDClanChat class CSteamID - internal RoomEnter ChatRoomEnterResponse; // m_eChatRoomEnterResponse enum EChatRoomEnterResponse + internal ulong SteamIDClanChat; // m_steamIDClanChat CSteamID + internal RoomEnter ChatRoomEnterResponse; // m_eChatRoomEnterResponse EChatRoomEnterResponse #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(JoinClanChatRoomCompletionResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamFriends + 42; + public int CallbackId => 342; internal static JoinClanChatRoomCompletionResult_t Fill( IntPtr p ) => ((JoinClanChatRoomCompletionResult_t)Marshal.PtrToStructure( p, typeof(JoinClanChatRoomCompletionResult_t) ) ); static Action actionClient; @@ -791,12 +883,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamFriends + 42, true ); + Event.Register( OnServer, _datasize, 342, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamFriends + 42, false ); + Event.Register( OnClient, _datasize, 342, false ); actionClient = action; } } @@ -806,13 +898,13 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct GameConnectedFriendChatMsg_t : ICallbackData { - internal ulong SteamIDUser; // m_steamIDUser class CSteamID + internal ulong SteamIDUser; // m_steamIDUser CSteamID internal int MessageID; // m_iMessageID int #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GameConnectedFriendChatMsg_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamFriends + 43; + public int CallbackId => 343; internal static GameConnectedFriendChatMsg_t Fill( IntPtr p ) => ((GameConnectedFriendChatMsg_t)Marshal.PtrToStructure( p, typeof(GameConnectedFriendChatMsg_t) ) ); static Action actionClient; @@ -823,12 +915,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamFriends + 43, true ); + Event.Register( OnServer, _datasize, 343, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamFriends + 43, false ); + Event.Register( OnClient, _datasize, 343, false ); actionClient = action; } } @@ -838,14 +930,14 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct FriendsGetFollowerCount_t : ICallbackData { - internal Result Result; // m_eResult enum EResult - internal ulong SteamID; // m_steamID class CSteamID + internal Result Result; // m_eResult EResult + internal ulong SteamID; // m_steamID CSteamID internal int Count; // m_nCount int #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(FriendsGetFollowerCount_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamFriends + 44; + public int CallbackId => 344; internal static FriendsGetFollowerCount_t Fill( IntPtr p ) => ((FriendsGetFollowerCount_t)Marshal.PtrToStructure( p, typeof(FriendsGetFollowerCount_t) ) ); static Action actionClient; @@ -856,12 +948,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamFriends + 44, true ); + Event.Register( OnServer, _datasize, 344, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamFriends + 44, false ); + Event.Register( OnClient, _datasize, 344, false ); actionClient = action; } } @@ -871,15 +963,15 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct FriendsIsFollowing_t : ICallbackData { - internal Result Result; // m_eResult enum EResult - internal ulong SteamID; // m_steamID class CSteamID + internal Result Result; // m_eResult EResult + internal ulong SteamID; // m_steamID CSteamID [MarshalAs(UnmanagedType.I1)] - internal bool IsFollowing; // m_bIsFollowing _Bool + internal bool IsFollowing; // m_bIsFollowing bool #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(FriendsIsFollowing_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamFriends + 45; + public int CallbackId => 345; internal static FriendsIsFollowing_t Fill( IntPtr p ) => ((FriendsIsFollowing_t)Marshal.PtrToStructure( p, typeof(FriendsIsFollowing_t) ) ); static Action actionClient; @@ -890,12 +982,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamFriends + 45, true ); + Event.Register( OnServer, _datasize, 345, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamFriends + 45, false ); + Event.Register( OnClient, _datasize, 345, false ); actionClient = action; } } @@ -905,16 +997,16 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct FriendsEnumerateFollowingList_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult [MarshalAs(UnmanagedType.ByValArray, SizeConst = 50, ArraySubType = UnmanagedType.U8)] - internal ulong[] GSteamID; // m_rgSteamID class CSteamID [50] + internal ulong[] GSteamID; // m_rgSteamID CSteamID [50] internal int ResultsReturned; // m_nResultsReturned int32 internal int TotalResultCount; // m_nTotalResultCount int32 #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(FriendsEnumerateFollowingList_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamFriends + 46; + public int CallbackId => 346; internal static FriendsEnumerateFollowingList_t Fill( IntPtr p ) => ((FriendsEnumerateFollowingList_t)Marshal.PtrToStructure( p, typeof(FriendsEnumerateFollowingList_t) ) ); static Action actionClient; @@ -925,12 +1017,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamFriends + 46, true ); + Event.Register( OnServer, _datasize, 346, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamFriends + 46, false ); + Event.Register( OnClient, _datasize, 346, false ); actionClient = action; } } @@ -941,15 +1033,15 @@ namespace Steamworks.Data internal struct SetPersonaNameResponse_t : ICallbackData { [MarshalAs(UnmanagedType.I1)] - internal bool Success; // m_bSuccess _Bool + internal bool Success; // m_bSuccess bool [MarshalAs(UnmanagedType.I1)] - internal bool LocalSuccess; // m_bLocalSuccess _Bool - internal Result Result; // m_result enum EResult + internal bool LocalSuccess; // m_bLocalSuccess bool + internal Result Result; // m_result EResult #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SetPersonaNameResponse_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamFriends + 47; + public int CallbackId => 347; internal static SetPersonaNameResponse_t Fill( IntPtr p ) => ((SetPersonaNameResponse_t)Marshal.PtrToStructure( p, typeof(SetPersonaNameResponse_t) ) ); static Action actionClient; @@ -960,12 +1052,72 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamFriends + 47, true ); + Event.Register( OnServer, _datasize, 347, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamFriends + 47, false ); + Event.Register( OnClient, _datasize, 347, false ); + actionClient = action; + } + } + #endregion + } + + [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] + internal struct UnreadChatMessagesChanged_t : ICallbackData + { + + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(UnreadChatMessagesChanged_t) ); + public int DataSize => _datasize; + public int CallbackId => 348; + internal static UnreadChatMessagesChanged_t Fill( IntPtr p ) => ((UnreadChatMessagesChanged_t)Marshal.PtrToStructure( p, typeof(UnreadChatMessagesChanged_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 348, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 348, false ); + actionClient = action; + } + } + #endregion + } + + [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] + internal struct IPCountry_t : ICallbackData + { + + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(IPCountry_t) ); + public int DataSize => _datasize; + public int CallbackId => 701; + internal static IPCountry_t Fill( IntPtr p ) => ((IPCountry_t)Marshal.PtrToStructure( p, typeof(IPCountry_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 701, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 701, false ); actionClient = action; } } @@ -980,7 +1132,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(LowBatteryPower_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUtils + 2; + public int CallbackId => 702; internal static LowBatteryPower_t Fill( IntPtr p ) => ((LowBatteryPower_t)Marshal.PtrToStructure( p, typeof(LowBatteryPower_t) ) ); static Action actionClient; @@ -991,12 +1143,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUtils + 2, true ); + Event.Register( OnServer, _datasize, 702, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUtils + 2, false ); + Event.Register( OnClient, _datasize, 702, false ); actionClient = action; } } @@ -1013,7 +1165,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SteamAPICallCompleted_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUtils + 3; + public int CallbackId => 703; internal static SteamAPICallCompleted_t Fill( IntPtr p ) => ((SteamAPICallCompleted_t)Marshal.PtrToStructure( p, typeof(SteamAPICallCompleted_t) ) ); static Action actionClient; @@ -1024,12 +1176,42 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUtils + 3, true ); + Event.Register( OnServer, _datasize, 703, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUtils + 3, false ); + Event.Register( OnClient, _datasize, 703, false ); + actionClient = action; + } + } + #endregion + } + + [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] + internal struct SteamShutdown_t : ICallbackData + { + + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SteamShutdown_t) ); + public int DataSize => _datasize; + public int CallbackId => 704; + internal static SteamShutdown_t Fill( IntPtr p ) => ((SteamShutdown_t)Marshal.PtrToStructure( p, typeof(SteamShutdown_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 704, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 704, false ); actionClient = action; } } @@ -1039,12 +1221,12 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct CheckFileSignature_t : ICallbackData { - internal CheckFileSignature CheckFileSignature; // m_eCheckFileSignature enum ECheckFileSignature + internal CheckFileSignature CheckFileSignature; // m_eCheckFileSignature ECheckFileSignature #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(CheckFileSignature_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUtils + 5; + public int CallbackId => 705; internal static CheckFileSignature_t Fill( IntPtr p ) => ((CheckFileSignature_t)Marshal.PtrToStructure( p, typeof(CheckFileSignature_t) ) ); static Action actionClient; @@ -1055,12 +1237,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUtils + 5, true ); + Event.Register( OnServer, _datasize, 705, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUtils + 5, false ); + Event.Register( OnClient, _datasize, 705, false ); actionClient = action; } } @@ -1071,13 +1253,13 @@ namespace Steamworks.Data internal struct GamepadTextInputDismissed_t : ICallbackData { [MarshalAs(UnmanagedType.I1)] - internal bool Submitted; // m_bSubmitted _Bool + internal bool Submitted; // m_bSubmitted bool internal uint SubmittedText; // m_unSubmittedText uint32 #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GamepadTextInputDismissed_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUtils + 14; + public int CallbackId => 714; internal static GamepadTextInputDismissed_t Fill( IntPtr p ) => ((GamepadTextInputDismissed_t)Marshal.PtrToStructure( p, typeof(GamepadTextInputDismissed_t) ) ); static Action actionClient; @@ -1088,82 +1270,18 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUtils + 14, true ); + Event.Register( OnServer, _datasize, 714, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUtils + 14, false ); + Event.Register( OnClient, _datasize, 714, false ); actionClient = action; } } #endregion } - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct servernetadr_t - { - internal ushort ConnectionPort; // m_usConnectionPort uint16 - internal ushort QueryPort; // m_usQueryPort uint16 - internal uint IP; // m_unIP uint32 - - #region Marshalling - internal static servernetadr_t Fill( IntPtr p ) => ((servernetadr_t)(servernetadr_t) Marshal.PtrToStructure( p, typeof(servernetadr_t) ) ); - #endregion - } - - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] - internal struct gameserveritem_t - { - internal servernetadr_t NetAdr; // m_NetAdr class servernetadr_t - internal int Ping; // m_nPing int - [MarshalAs(UnmanagedType.I1)] - internal bool HadSuccessfulResponse; // m_bHadSuccessfulResponse _Bool - [MarshalAs(UnmanagedType.I1)] - internal bool DoNotRefresh; // m_bDoNotRefresh _Bool - internal string GameDirUTF8() => System.Text.Encoding.UTF8.GetString( GameDir, 0, System.Array.IndexOf( GameDir, 0 ) ); - [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)] // byte[] m_szGameDir - internal byte[] GameDir; // m_szGameDir char [32] - internal string MapUTF8() => System.Text.Encoding.UTF8.GetString( Map, 0, System.Array.IndexOf( Map, 0 ) ); - [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)] // byte[] m_szMap - internal byte[] Map; // m_szMap char [32] - internal string GameDescriptionUTF8() => System.Text.Encoding.UTF8.GetString( GameDescription, 0, System.Array.IndexOf( GameDescription, 0 ) ); - [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)] // byte[] m_szGameDescription - internal byte[] GameDescription; // m_szGameDescription char [64] - internal uint AppID; // m_nAppID uint32 - internal int Players; // m_nPlayers int - internal int MaxPlayers; // m_nMaxPlayers int - internal int BotPlayers; // m_nBotPlayers int - [MarshalAs(UnmanagedType.I1)] - internal bool Password; // m_bPassword _Bool - [MarshalAs(UnmanagedType.I1)] - internal bool Secure; // m_bSecure _Bool - internal uint TimeLastPlayed; // m_ulTimeLastPlayed uint32 - internal int ServerVersion; // m_nServerVersion int - internal string ServerNameUTF8() => System.Text.Encoding.UTF8.GetString( ServerName, 0, System.Array.IndexOf( ServerName, 0 ) ); - [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)] // byte[] m_szServerName - internal byte[] ServerName; // m_szServerName char [64] - internal string GameTagsUTF8() => System.Text.Encoding.UTF8.GetString( GameTags, 0, System.Array.IndexOf( GameTags, 0 ) ); - [MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)] // byte[] m_szGameTags - internal byte[] GameTags; // m_szGameTags char [128] - internal ulong SteamID; // m_steamID class CSteamID - - #region Marshalling - internal static gameserveritem_t Fill( IntPtr p ) => ((gameserveritem_t)(gameserveritem_t) Marshal.PtrToStructure( p, typeof(gameserveritem_t) ) ); - #endregion - } - - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct SteamPartyBeaconLocation_t - { - internal SteamPartyBeaconLocationType Type; // m_eType enum ESteamPartyBeaconLocationType - internal ulong LocationID; // m_ulLocationID uint64 - - #region Marshalling - internal static SteamPartyBeaconLocation_t Fill( IntPtr p ) => ((SteamPartyBeaconLocation_t)(SteamPartyBeaconLocation_t) Marshal.PtrToStructure( p, typeof(SteamPartyBeaconLocation_t) ) ); - #endregion - } - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct FavoritesListChanged_t : ICallbackData { @@ -1173,13 +1291,13 @@ namespace Steamworks.Data internal uint AppID; // m_nAppID uint32 internal uint Flags; // m_nFlags uint32 [MarshalAs(UnmanagedType.I1)] - internal bool Add; // m_bAdd _Bool + internal bool Add; // m_bAdd bool internal uint AccountId; // m_unAccountId AccountID_t #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(FavoritesListChanged_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamMatchmaking + 2; + public int CallbackId => 502; internal static FavoritesListChanged_t Fill( IntPtr p ) => ((FavoritesListChanged_t)Marshal.PtrToStructure( p, typeof(FavoritesListChanged_t) ) ); static Action actionClient; @@ -1190,12 +1308,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamMatchmaking + 2, true ); + Event.Register( OnServer, _datasize, 502, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamMatchmaking + 2, false ); + Event.Register( OnClient, _datasize, 502, false ); actionClient = action; } } @@ -1212,7 +1330,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(LobbyInvite_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamMatchmaking + 3; + public int CallbackId => 503; internal static LobbyInvite_t Fill( IntPtr p ) => ((LobbyInvite_t)Marshal.PtrToStructure( p, typeof(LobbyInvite_t) ) ); static Action actionClient; @@ -1223,12 +1341,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamMatchmaking + 3, true ); + Event.Register( OnServer, _datasize, 503, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamMatchmaking + 3, false ); + Event.Register( OnClient, _datasize, 503, false ); actionClient = action; } } @@ -1241,13 +1359,13 @@ namespace Steamworks.Data internal ulong SteamIDLobby; // m_ulSteamIDLobby uint64 internal uint GfChatPermissions; // m_rgfChatPermissions uint32 [MarshalAs(UnmanagedType.I1)] - internal bool Locked; // m_bLocked _Bool + internal bool Locked; // m_bLocked bool internal uint EChatRoomEnterResponse; // m_EChatRoomEnterResponse uint32 #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(LobbyEnter_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamMatchmaking + 4; + public int CallbackId => 504; internal static LobbyEnter_t Fill( IntPtr p ) => ((LobbyEnter_t)Marshal.PtrToStructure( p, typeof(LobbyEnter_t) ) ); static Action actionClient; @@ -1258,12 +1376,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamMatchmaking + 4, true ); + Event.Register( OnServer, _datasize, 504, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamMatchmaking + 4, false ); + Event.Register( OnClient, _datasize, 504, false ); actionClient = action; } } @@ -1280,7 +1398,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(LobbyDataUpdate_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamMatchmaking + 5; + public int CallbackId => 505; internal static LobbyDataUpdate_t Fill( IntPtr p ) => ((LobbyDataUpdate_t)Marshal.PtrToStructure( p, typeof(LobbyDataUpdate_t) ) ); static Action actionClient; @@ -1291,12 +1409,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamMatchmaking + 5, true ); + Event.Register( OnServer, _datasize, 505, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamMatchmaking + 5, false ); + Event.Register( OnClient, _datasize, 505, false ); actionClient = action; } } @@ -1314,7 +1432,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(LobbyChatUpdate_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamMatchmaking + 6; + public int CallbackId => 506; internal static LobbyChatUpdate_t Fill( IntPtr p ) => ((LobbyChatUpdate_t)Marshal.PtrToStructure( p, typeof(LobbyChatUpdate_t) ) ); static Action actionClient; @@ -1325,12 +1443,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamMatchmaking + 6, true ); + Event.Register( OnServer, _datasize, 506, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamMatchmaking + 6, false ); + Event.Register( OnClient, _datasize, 506, false ); actionClient = action; } } @@ -1348,7 +1466,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(LobbyChatMsg_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamMatchmaking + 7; + public int CallbackId => 507; internal static LobbyChatMsg_t Fill( IntPtr p ) => ((LobbyChatMsg_t)Marshal.PtrToStructure( p, typeof(LobbyChatMsg_t) ) ); static Action actionClient; @@ -1359,12 +1477,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamMatchmaking + 7, true ); + Event.Register( OnServer, _datasize, 507, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamMatchmaking + 7, false ); + Event.Register( OnClient, _datasize, 507, false ); actionClient = action; } } @@ -1382,7 +1500,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(LobbyGameCreated_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamMatchmaking + 9; + public int CallbackId => 509; internal static LobbyGameCreated_t Fill( IntPtr p ) => ((LobbyGameCreated_t)Marshal.PtrToStructure( p, typeof(LobbyGameCreated_t) ) ); static Action actionClient; @@ -1393,12 +1511,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamMatchmaking + 9, true ); + Event.Register( OnServer, _datasize, 509, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamMatchmaking + 9, false ); + Event.Register( OnClient, _datasize, 509, false ); actionClient = action; } } @@ -1413,7 +1531,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(LobbyMatchList_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamMatchmaking + 10; + public int CallbackId => 510; internal static LobbyMatchList_t Fill( IntPtr p ) => ((LobbyMatchList_t)Marshal.PtrToStructure( p, typeof(LobbyMatchList_t) ) ); static Action actionClient; @@ -1424,12 +1542,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamMatchmaking + 10, true ); + Event.Register( OnServer, _datasize, 510, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamMatchmaking + 10, false ); + Event.Register( OnClient, _datasize, 510, false ); actionClient = action; } } @@ -1446,7 +1564,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(LobbyKicked_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamMatchmaking + 12; + public int CallbackId => 512; internal static LobbyKicked_t Fill( IntPtr p ) => ((LobbyKicked_t)Marshal.PtrToStructure( p, typeof(LobbyKicked_t) ) ); static Action actionClient; @@ -1457,12 +1575,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamMatchmaking + 12, true ); + Event.Register( OnServer, _datasize, 512, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamMatchmaking + 12, false ); + Event.Register( OnClient, _datasize, 512, false ); actionClient = action; } } @@ -1472,13 +1590,13 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct LobbyCreated_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal ulong SteamIDLobby; // m_ulSteamIDLobby uint64 #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(LobbyCreated_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamMatchmaking + 13; + public int CallbackId => 513; internal static LobbyCreated_t Fill( IntPtr p ) => ((LobbyCreated_t)Marshal.PtrToStructure( p, typeof(LobbyCreated_t) ) ); static Action actionClient; @@ -1489,12 +1607,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamMatchmaking + 13, true ); + Event.Register( OnServer, _datasize, 513, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamMatchmaking + 13, false ); + Event.Register( OnClient, _datasize, 513, false ); actionClient = action; } } @@ -1505,13 +1623,13 @@ namespace Steamworks.Data internal struct PSNGameBootInviteResult_t : ICallbackData { [MarshalAs(UnmanagedType.I1)] - internal bool GameBootInviteExists; // m_bGameBootInviteExists _Bool - internal ulong SteamIDLobby; // m_steamIDLobby class CSteamID + internal bool GameBootInviteExists; // m_bGameBootInviteExists bool + internal ulong SteamIDLobby; // m_steamIDLobby CSteamID #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(PSNGameBootInviteResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamMatchmaking + 15; + public int CallbackId => 515; internal static PSNGameBootInviteResult_t Fill( IntPtr p ) => ((PSNGameBootInviteResult_t)Marshal.PtrToStructure( p, typeof(PSNGameBootInviteResult_t) ) ); static Action actionClient; @@ -1522,12 +1640,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamMatchmaking + 15, true ); + Event.Register( OnServer, _datasize, 515, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamMatchmaking + 15, false ); + Event.Register( OnClient, _datasize, 515, false ); actionClient = action; } } @@ -1537,12 +1655,12 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct FavoritesListAccountsUpdated_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(FavoritesListAccountsUpdated_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamMatchmaking + 16; + public int CallbackId => 516; internal static FavoritesListAccountsUpdated_t Fill( IntPtr p ) => ((FavoritesListAccountsUpdated_t)Marshal.PtrToStructure( p, typeof(FavoritesListAccountsUpdated_t) ) ); static Action actionClient; @@ -1553,12 +1671,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamMatchmaking + 16, true ); + Event.Register( OnServer, _datasize, 516, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamMatchmaking + 16, false ); + Event.Register( OnClient, _datasize, 516, false ); actionClient = action; } } @@ -1569,16 +1687,16 @@ namespace Steamworks.Data internal struct SearchForGameProgressCallback_t : ICallbackData { internal ulong LSearchID; // m_ullSearchID uint64 - internal Result Result; // m_eResult enum EResult - internal ulong LobbyID; // m_lobbyID class CSteamID - internal ulong SteamIDEndedSearch; // m_steamIDEndedSearch class CSteamID + internal Result Result; // m_eResult EResult + internal ulong LobbyID; // m_lobbyID CSteamID + internal ulong SteamIDEndedSearch; // m_steamIDEndedSearch CSteamID internal int SecondsRemainingEstimate; // m_nSecondsRemainingEstimate int32 internal int CPlayersSearching; // m_cPlayersSearching int32 #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SearchForGameProgressCallback_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamGameSearch + 1; + public int CallbackId => 5201; internal static SearchForGameProgressCallback_t Fill( IntPtr p ) => ((SearchForGameProgressCallback_t)Marshal.PtrToStructure( p, typeof(SearchForGameProgressCallback_t) ) ); static Action actionClient; @@ -1589,12 +1707,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamGameSearch + 1, true ); + Event.Register( OnServer, _datasize, 5201, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamGameSearch + 1, false ); + Event.Register( OnClient, _datasize, 5201, false ); actionClient = action; } } @@ -1605,17 +1723,17 @@ namespace Steamworks.Data internal struct SearchForGameResultCallback_t : ICallbackData { internal ulong LSearchID; // m_ullSearchID uint64 - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal int CountPlayersInGame; // m_nCountPlayersInGame int32 internal int CountAcceptedGame; // m_nCountAcceptedGame int32 - internal ulong SteamIDHost; // m_steamIDHost class CSteamID + internal ulong SteamIDHost; // m_steamIDHost CSteamID [MarshalAs(UnmanagedType.I1)] - internal bool FinalCallback; // m_bFinalCallback _Bool + internal bool FinalCallback; // m_bFinalCallback bool #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SearchForGameResultCallback_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamGameSearch + 2; + public int CallbackId => 5202; internal static SearchForGameResultCallback_t Fill( IntPtr p ) => ((SearchForGameResultCallback_t)Marshal.PtrToStructure( p, typeof(SearchForGameResultCallback_t) ) ); static Action actionClient; @@ -1626,12 +1744,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamGameSearch + 2, true ); + Event.Register( OnServer, _datasize, 5202, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamGameSearch + 2, false ); + Event.Register( OnClient, _datasize, 5202, false ); actionClient = action; } } @@ -1641,13 +1759,13 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct RequestPlayersForGameProgressCallback_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal ulong LSearchID; // m_ullSearchID uint64 #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RequestPlayersForGameProgressCallback_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamGameSearch + 11; + public int CallbackId => 5211; internal static RequestPlayersForGameProgressCallback_t Fill( IntPtr p ) => ((RequestPlayersForGameProgressCallback_t)Marshal.PtrToStructure( p, typeof(RequestPlayersForGameProgressCallback_t) ) ); static Action actionClient; @@ -1658,12 +1776,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamGameSearch + 11, true ); + Event.Register( OnServer, _datasize, 5211, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamGameSearch + 11, false ); + Event.Register( OnClient, _datasize, 5211, false ); actionClient = action; } } @@ -1673,11 +1791,11 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct RequestPlayersForGameResultCallback_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal ulong LSearchID; // m_ullSearchID uint64 - internal ulong SteamIDPlayerFound; // m_SteamIDPlayerFound class CSteamID - internal ulong SteamIDLobby; // m_SteamIDLobby class CSteamID - internal PlayerAcceptState_t PlayerAcceptState; // m_ePlayerAcceptState PlayerAcceptState_t + internal ulong SteamIDPlayerFound; // m_SteamIDPlayerFound CSteamID + internal ulong SteamIDLobby; // m_SteamIDLobby CSteamID + internal RequestPlayersForGameResultCallback_t_PlayerAcceptState_t PlayerAcceptState; // m_ePlayerAcceptState RequestPlayersForGameResultCallback_t_PlayerAcceptState_t internal int PlayerIndex; // m_nPlayerIndex int32 internal int TotalPlayersFound; // m_nTotalPlayersFound int32 internal int TotalPlayersAcceptedGame; // m_nTotalPlayersAcceptedGame int32 @@ -1687,7 +1805,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RequestPlayersForGameResultCallback_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamGameSearch + 12; + public int CallbackId => 5212; internal static RequestPlayersForGameResultCallback_t Fill( IntPtr p ) => ((RequestPlayersForGameResultCallback_t)Marshal.PtrToStructure( p, typeof(RequestPlayersForGameResultCallback_t) ) ); static Action actionClient; @@ -1698,12 +1816,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamGameSearch + 12, true ); + Event.Register( OnServer, _datasize, 5212, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamGameSearch + 12, false ); + Event.Register( OnClient, _datasize, 5212, false ); actionClient = action; } } @@ -1713,14 +1831,14 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct RequestPlayersForGameFinalResultCallback_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal ulong LSearchID; // m_ullSearchID uint64 internal ulong LUniqueGameID; // m_ullUniqueGameID uint64 #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RequestPlayersForGameFinalResultCallback_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamGameSearch + 13; + public int CallbackId => 5213; internal static RequestPlayersForGameFinalResultCallback_t Fill( IntPtr p ) => ((RequestPlayersForGameFinalResultCallback_t)Marshal.PtrToStructure( p, typeof(RequestPlayersForGameFinalResultCallback_t) ) ); static Action actionClient; @@ -1731,12 +1849,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamGameSearch + 13, true ); + Event.Register( OnServer, _datasize, 5213, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamGameSearch + 13, false ); + Event.Register( OnClient, _datasize, 5213, false ); actionClient = action; } } @@ -1746,14 +1864,14 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct SubmitPlayerResultResultCallback_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal ulong UllUniqueGameID; // ullUniqueGameID uint64 - internal ulong SteamIDPlayer; // steamIDPlayer class CSteamID + internal ulong SteamIDPlayer; // steamIDPlayer CSteamID #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SubmitPlayerResultResultCallback_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamGameSearch + 14; + public int CallbackId => 5214; internal static SubmitPlayerResultResultCallback_t Fill( IntPtr p ) => ((SubmitPlayerResultResultCallback_t)Marshal.PtrToStructure( p, typeof(SubmitPlayerResultResultCallback_t) ) ); static Action actionClient; @@ -1764,12 +1882,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamGameSearch + 14, true ); + Event.Register( OnServer, _datasize, 5214, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamGameSearch + 14, false ); + Event.Register( OnClient, _datasize, 5214, false ); actionClient = action; } } @@ -1779,13 +1897,13 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct EndGameResultCallback_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal ulong UllUniqueGameID; // ullUniqueGameID uint64 #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(EndGameResultCallback_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamGameSearch + 15; + public int CallbackId => 5215; internal static EndGameResultCallback_t Fill( IntPtr p ) => ((EndGameResultCallback_t)Marshal.PtrToStructure( p, typeof(EndGameResultCallback_t) ) ); static Action actionClient; @@ -1796,12 +1914,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamGameSearch + 15, true ); + Event.Register( OnServer, _datasize, 5215, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamGameSearch + 15, false ); + Event.Register( OnClient, _datasize, 5215, false ); actionClient = action; } } @@ -1811,9 +1929,9 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct JoinPartyCallback_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal ulong BeaconID; // m_ulBeaconID PartyBeaconID_t - internal ulong SteamIDBeaconOwner; // m_SteamIDBeaconOwner class CSteamID + internal ulong SteamIDBeaconOwner; // m_SteamIDBeaconOwner CSteamID internal string ConnectStringUTF8() => System.Text.Encoding.UTF8.GetString( ConnectString, 0, System.Array.IndexOf( ConnectString, 0 ) ); [MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)] // byte[] m_rgchConnectString internal byte[] ConnectString; // m_rgchConnectString char [256] @@ -1821,7 +1939,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(JoinPartyCallback_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamParties + 1; + public int CallbackId => 5301; internal static JoinPartyCallback_t Fill( IntPtr p ) => ((JoinPartyCallback_t)Marshal.PtrToStructure( p, typeof(JoinPartyCallback_t) ) ); static Action actionClient; @@ -1832,12 +1950,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamParties + 1, true ); + Event.Register( OnServer, _datasize, 5301, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamParties + 1, false ); + Event.Register( OnClient, _datasize, 5301, false ); actionClient = action; } } @@ -1847,13 +1965,13 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct CreateBeaconCallback_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal ulong BeaconID; // m_ulBeaconID PartyBeaconID_t #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(CreateBeaconCallback_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamParties + 2; + public int CallbackId => 5302; internal static CreateBeaconCallback_t Fill( IntPtr p ) => ((CreateBeaconCallback_t)Marshal.PtrToStructure( p, typeof(CreateBeaconCallback_t) ) ); static Action actionClient; @@ -1864,12 +1982,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamParties + 2, true ); + Event.Register( OnServer, _datasize, 5302, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamParties + 2, false ); + Event.Register( OnClient, _datasize, 5302, false ); actionClient = action; } } @@ -1880,12 +1998,12 @@ namespace Steamworks.Data internal struct ReservationNotificationCallback_t : ICallbackData { internal ulong BeaconID; // m_ulBeaconID PartyBeaconID_t - internal ulong SteamIDJoiner; // m_steamIDJoiner class CSteamID + internal ulong SteamIDJoiner; // m_steamIDJoiner CSteamID #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(ReservationNotificationCallback_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamParties + 3; + public int CallbackId => 5303; internal static ReservationNotificationCallback_t Fill( IntPtr p ) => ((ReservationNotificationCallback_t)Marshal.PtrToStructure( p, typeof(ReservationNotificationCallback_t) ) ); static Action actionClient; @@ -1896,12 +2014,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamParties + 3, true ); + Event.Register( OnServer, _datasize, 5303, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamParties + 3, false ); + Event.Register( OnClient, _datasize, 5303, false ); actionClient = action; } } @@ -1911,12 +2029,12 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct ChangeNumOpenSlotsCallback_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(ChangeNumOpenSlotsCallback_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamParties + 4; + public int CallbackId => 5304; internal static ChangeNumOpenSlotsCallback_t Fill( IntPtr p ) => ((ChangeNumOpenSlotsCallback_t)Marshal.PtrToStructure( p, typeof(ChangeNumOpenSlotsCallback_t) ) ); static Action actionClient; @@ -1927,12 +2045,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamParties + 4, true ); + Event.Register( OnServer, _datasize, 5304, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamParties + 4, false ); + Event.Register( OnClient, _datasize, 5304, false ); actionClient = action; } } @@ -1940,13 +2058,62 @@ namespace Steamworks.Data } [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct SteamParamStringArray_t + internal struct AvailableBeaconLocationsUpdated_t : ICallbackData { - internal IntPtr Strings; // m_ppStrings const char ** - internal int NumStrings; // m_nNumStrings int32 - #region Marshalling - internal static SteamParamStringArray_t Fill( IntPtr p ) => ((SteamParamStringArray_t)(SteamParamStringArray_t) Marshal.PtrToStructure( p, typeof(SteamParamStringArray_t) ) ); + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(AvailableBeaconLocationsUpdated_t) ); + public int DataSize => _datasize; + public int CallbackId => 5305; + internal static AvailableBeaconLocationsUpdated_t Fill( IntPtr p ) => ((AvailableBeaconLocationsUpdated_t)Marshal.PtrToStructure( p, typeof(AvailableBeaconLocationsUpdated_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 5305, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 5305, false ); + actionClient = action; + } + } + #endregion + } + + [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] + internal struct ActiveBeaconsUpdated_t : ICallbackData + { + + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(ActiveBeaconsUpdated_t) ); + public int DataSize => _datasize; + public int CallbackId => 5306; + internal static ActiveBeaconsUpdated_t Fill( IntPtr p ) => ((ActiveBeaconsUpdated_t)Marshal.PtrToStructure( p, typeof(ActiveBeaconsUpdated_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 5306, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 5306, false ); + actionClient = action; + } + } #endregion } @@ -1954,13 +2121,13 @@ namespace Steamworks.Data internal struct RemoteStorageAppSyncedClient_t : ICallbackData { internal AppId AppID; // m_nAppID AppId_t - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal int NumDownloads; // m_unNumDownloads int #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoteStorageAppSyncedClient_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientRemoteStorage + 1; + public int CallbackId => 1301; internal static RemoteStorageAppSyncedClient_t Fill( IntPtr p ) => ((RemoteStorageAppSyncedClient_t)Marshal.PtrToStructure( p, typeof(RemoteStorageAppSyncedClient_t) ) ); static Action actionClient; @@ -1971,12 +2138,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientRemoteStorage + 1, true ); + Event.Register( OnServer, _datasize, 1301, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientRemoteStorage + 1, false ); + Event.Register( OnClient, _datasize, 1301, false ); actionClient = action; } } @@ -1987,13 +2154,13 @@ namespace Steamworks.Data internal struct RemoteStorageAppSyncedServer_t : ICallbackData { internal AppId AppID; // m_nAppID AppId_t - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal int NumUploads; // m_unNumUploads int #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoteStorageAppSyncedServer_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientRemoteStorage + 2; + public int CallbackId => 1302; internal static RemoteStorageAppSyncedServer_t Fill( IntPtr p ) => ((RemoteStorageAppSyncedServer_t)Marshal.PtrToStructure( p, typeof(RemoteStorageAppSyncedServer_t) ) ); static Action actionClient; @@ -2004,12 +2171,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientRemoteStorage + 2, true ); + Event.Register( OnServer, _datasize, 1302, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientRemoteStorage + 2, false ); + Event.Register( OnClient, _datasize, 1302, false ); actionClient = action; } } @@ -2026,12 +2193,12 @@ namespace Steamworks.Data internal uint BytesTransferredThisChunk; // m_uBytesTransferredThisChunk uint32 internal double DAppPercentComplete; // m_dAppPercentComplete double [MarshalAs(UnmanagedType.I1)] - internal bool Uploading; // m_bUploading _Bool + internal bool Uploading; // m_bUploading bool #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoteStorageAppSyncProgress_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientRemoteStorage + 3; + public int CallbackId => 1303; internal static RemoteStorageAppSyncProgress_t Fill( IntPtr p ) => ((RemoteStorageAppSyncProgress_t)Marshal.PtrToStructure( p, typeof(RemoteStorageAppSyncProgress_t) ) ); static Action actionClient; @@ -2042,12 +2209,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientRemoteStorage + 3, true ); + Event.Register( OnServer, _datasize, 1303, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientRemoteStorage + 3, false ); + Event.Register( OnClient, _datasize, 1303, false ); actionClient = action; } } @@ -2058,12 +2225,12 @@ namespace Steamworks.Data internal struct RemoteStorageAppSyncStatusCheck_t : ICallbackData { internal AppId AppID; // m_nAppID AppId_t - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoteStorageAppSyncStatusCheck_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientRemoteStorage + 5; + public int CallbackId => 1305; internal static RemoteStorageAppSyncStatusCheck_t Fill( IntPtr p ) => ((RemoteStorageAppSyncStatusCheck_t)Marshal.PtrToStructure( p, typeof(RemoteStorageAppSyncStatusCheck_t) ) ); static Action actionClient; @@ -2074,12 +2241,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientRemoteStorage + 5, true ); + Event.Register( OnServer, _datasize, 1305, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientRemoteStorage + 5, false ); + Event.Register( OnClient, _datasize, 1305, false ); actionClient = action; } } @@ -2089,7 +2256,7 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct RemoteStorageFileShareResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal ulong File; // m_hFile UGCHandle_t internal string FilenameUTF8() => System.Text.Encoding.UTF8.GetString( Filename, 0, System.Array.IndexOf( Filename, 0 ) ); [MarshalAs(UnmanagedType.ByValArray, SizeConst = 260)] // byte[] m_rgchFilename @@ -2098,7 +2265,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoteStorageFileShareResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientRemoteStorage + 7; + public int CallbackId => 1307; internal static RemoteStorageFileShareResult_t Fill( IntPtr p ) => ((RemoteStorageFileShareResult_t)Marshal.PtrToStructure( p, typeof(RemoteStorageFileShareResult_t) ) ); static Action actionClient; @@ -2109,12 +2276,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientRemoteStorage + 7, true ); + Event.Register( OnServer, _datasize, 1307, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientRemoteStorage + 7, false ); + Event.Register( OnClient, _datasize, 1307, false ); actionClient = action; } } @@ -2124,15 +2291,15 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct RemoteStoragePublishFileResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t [MarshalAs(UnmanagedType.I1)] - internal bool UserNeedsToAcceptWorkshopLegalAgreement; // m_bUserNeedsToAcceptWorkshopLegalAgreement _Bool + internal bool UserNeedsToAcceptWorkshopLegalAgreement; // m_bUserNeedsToAcceptWorkshopLegalAgreement bool #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoteStoragePublishFileResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientRemoteStorage + 9; + public int CallbackId => 1309; internal static RemoteStoragePublishFileResult_t Fill( IntPtr p ) => ((RemoteStoragePublishFileResult_t)Marshal.PtrToStructure( p, typeof(RemoteStoragePublishFileResult_t) ) ); static Action actionClient; @@ -2143,12 +2310,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientRemoteStorage + 9, true ); + Event.Register( OnServer, _datasize, 1309, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientRemoteStorage + 9, false ); + Event.Register( OnClient, _datasize, 1309, false ); actionClient = action; } } @@ -2158,13 +2325,13 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct RemoteStorageDeletePublishedFileResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoteStorageDeletePublishedFileResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientRemoteStorage + 11; + public int CallbackId => 1311; internal static RemoteStorageDeletePublishedFileResult_t Fill( IntPtr p ) => ((RemoteStorageDeletePublishedFileResult_t)Marshal.PtrToStructure( p, typeof(RemoteStorageDeletePublishedFileResult_t) ) ); static Action actionClient; @@ -2175,12 +2342,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientRemoteStorage + 11, true ); + Event.Register( OnServer, _datasize, 1311, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientRemoteStorage + 11, false ); + Event.Register( OnClient, _datasize, 1311, false ); actionClient = action; } } @@ -2190,7 +2357,7 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct RemoteStorageEnumerateUserPublishedFilesResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal int ResultsReturned; // m_nResultsReturned int32 internal int TotalResultCount; // m_nTotalResultCount int32 [MarshalAs(UnmanagedType.ByValArray, SizeConst = 50, ArraySubType = UnmanagedType.U8)] @@ -2199,7 +2366,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoteStorageEnumerateUserPublishedFilesResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientRemoteStorage + 12; + public int CallbackId => 1312; internal static RemoteStorageEnumerateUserPublishedFilesResult_t Fill( IntPtr p ) => ((RemoteStorageEnumerateUserPublishedFilesResult_t)Marshal.PtrToStructure( p, typeof(RemoteStorageEnumerateUserPublishedFilesResult_t) ) ); static Action actionClient; @@ -2210,12 +2377,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientRemoteStorage + 12, true ); + Event.Register( OnServer, _datasize, 1312, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientRemoteStorage + 12, false ); + Event.Register( OnClient, _datasize, 1312, false ); actionClient = action; } } @@ -2225,13 +2392,13 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct RemoteStorageSubscribePublishedFileResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoteStorageSubscribePublishedFileResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientRemoteStorage + 13; + public int CallbackId => 1313; internal static RemoteStorageSubscribePublishedFileResult_t Fill( IntPtr p ) => ((RemoteStorageSubscribePublishedFileResult_t)Marshal.PtrToStructure( p, typeof(RemoteStorageSubscribePublishedFileResult_t) ) ); static Action actionClient; @@ -2242,12 +2409,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientRemoteStorage + 13, true ); + Event.Register( OnServer, _datasize, 1313, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientRemoteStorage + 13, false ); + Event.Register( OnClient, _datasize, 1313, false ); actionClient = action; } } @@ -2257,7 +2424,7 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct RemoteStorageEnumerateUserSubscribedFilesResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal int ResultsReturned; // m_nResultsReturned int32 internal int TotalResultCount; // m_nTotalResultCount int32 [MarshalAs(UnmanagedType.ByValArray, SizeConst = 50, ArraySubType = UnmanagedType.U8)] @@ -2268,7 +2435,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoteStorageEnumerateUserSubscribedFilesResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientRemoteStorage + 14; + public int CallbackId => 1314; internal static RemoteStorageEnumerateUserSubscribedFilesResult_t Fill( IntPtr p ) => ((RemoteStorageEnumerateUserSubscribedFilesResult_t)Marshal.PtrToStructure( p, typeof(RemoteStorageEnumerateUserSubscribedFilesResult_t) ) ); static Action actionClient; @@ -2279,12 +2446,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientRemoteStorage + 14, true ); + Event.Register( OnServer, _datasize, 1314, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientRemoteStorage + 14, false ); + Event.Register( OnClient, _datasize, 1314, false ); actionClient = action; } } @@ -2294,13 +2461,13 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct RemoteStorageUnsubscribePublishedFileResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoteStorageUnsubscribePublishedFileResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientRemoteStorage + 15; + public int CallbackId => 1315; internal static RemoteStorageUnsubscribePublishedFileResult_t Fill( IntPtr p ) => ((RemoteStorageUnsubscribePublishedFileResult_t)Marshal.PtrToStructure( p, typeof(RemoteStorageUnsubscribePublishedFileResult_t) ) ); static Action actionClient; @@ -2311,12 +2478,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientRemoteStorage + 15, true ); + Event.Register( OnServer, _datasize, 1315, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientRemoteStorage + 15, false ); + Event.Register( OnClient, _datasize, 1315, false ); actionClient = action; } } @@ -2326,15 +2493,15 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct RemoteStorageUpdatePublishedFileResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t [MarshalAs(UnmanagedType.I1)] - internal bool UserNeedsToAcceptWorkshopLegalAgreement; // m_bUserNeedsToAcceptWorkshopLegalAgreement _Bool + internal bool UserNeedsToAcceptWorkshopLegalAgreement; // m_bUserNeedsToAcceptWorkshopLegalAgreement bool #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoteStorageUpdatePublishedFileResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientRemoteStorage + 16; + public int CallbackId => 1316; internal static RemoteStorageUpdatePublishedFileResult_t Fill( IntPtr p ) => ((RemoteStorageUpdatePublishedFileResult_t)Marshal.PtrToStructure( p, typeof(RemoteStorageUpdatePublishedFileResult_t) ) ); static Action actionClient; @@ -2345,12 +2512,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientRemoteStorage + 16, true ); + Event.Register( OnServer, _datasize, 1316, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientRemoteStorage + 16, false ); + Event.Register( OnClient, _datasize, 1316, false ); actionClient = action; } } @@ -2360,7 +2527,7 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct RemoteStorageDownloadUGCResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal ulong File; // m_hFile UGCHandle_t internal AppId AppID; // m_nAppID AppId_t internal int SizeInBytes; // m_nSizeInBytes int32 @@ -2372,7 +2539,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoteStorageDownloadUGCResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientRemoteStorage + 17; + public int CallbackId => 1317; internal static RemoteStorageDownloadUGCResult_t Fill( IntPtr p ) => ((RemoteStorageDownloadUGCResult_t)Marshal.PtrToStructure( p, typeof(RemoteStorageDownloadUGCResult_t) ) ); static Action actionClient; @@ -2383,12 +2550,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientRemoteStorage + 17, true ); + Event.Register( OnServer, _datasize, 1317, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientRemoteStorage + 17, false ); + Event.Register( OnClient, _datasize, 1317, false ); actionClient = action; } } @@ -2398,7 +2565,7 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct RemoteStorageGetPublishedFileDetailsResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t internal AppId CreatorAppID; // m_nCreatorAppID AppId_t internal AppId ConsumerAppID; // m_nConsumerAppID AppId_t @@ -2413,14 +2580,14 @@ namespace Steamworks.Data internal ulong SteamIDOwner; // m_ulSteamIDOwner uint64 internal uint TimeCreated; // m_rtimeCreated uint32 internal uint TimeUpdated; // m_rtimeUpdated uint32 - internal RemoteStoragePublishedFileVisibility Visibility; // m_eVisibility enum ERemoteStoragePublishedFileVisibility + internal RemoteStoragePublishedFileVisibility Visibility; // m_eVisibility ERemoteStoragePublishedFileVisibility [MarshalAs(UnmanagedType.I1)] - internal bool Banned; // m_bBanned _Bool + internal bool Banned; // m_bBanned bool internal string TagsUTF8() => System.Text.Encoding.UTF8.GetString( Tags, 0, System.Array.IndexOf( Tags, 0 ) ); [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1025)] // byte[] m_rgchTags internal byte[] Tags; // m_rgchTags char [1025] [MarshalAs(UnmanagedType.I1)] - internal bool TagsTruncated; // m_bTagsTruncated _Bool + internal bool TagsTruncated; // m_bTagsTruncated bool internal string PchFileNameUTF8() => System.Text.Encoding.UTF8.GetString( PchFileName, 0, System.Array.IndexOf( PchFileName, 0 ) ); [MarshalAs(UnmanagedType.ByValArray, SizeConst = 260)] // byte[] m_pchFileName internal byte[] PchFileName; // m_pchFileName char [260] @@ -2429,14 +2596,14 @@ namespace Steamworks.Data internal string URLUTF8() => System.Text.Encoding.UTF8.GetString( URL, 0, System.Array.IndexOf( URL, 0 ) ); [MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)] // byte[] m_rgchURL internal byte[] URL; // m_rgchURL char [256] - internal WorkshopFileType FileType; // m_eFileType enum EWorkshopFileType + internal WorkshopFileType FileType; // m_eFileType EWorkshopFileType [MarshalAs(UnmanagedType.I1)] - internal bool AcceptedForUse; // m_bAcceptedForUse _Bool + internal bool AcceptedForUse; // m_bAcceptedForUse bool #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoteStorageGetPublishedFileDetailsResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientRemoteStorage + 18; + public int CallbackId => 1318; internal static RemoteStorageGetPublishedFileDetailsResult_t Fill( IntPtr p ) => ((RemoteStorageGetPublishedFileDetailsResult_t)Marshal.PtrToStructure( p, typeof(RemoteStorageGetPublishedFileDetailsResult_t) ) ); static Action actionClient; @@ -2447,12 +2614,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientRemoteStorage + 18, true ); + Event.Register( OnServer, _datasize, 1318, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientRemoteStorage + 18, false ); + Event.Register( OnClient, _datasize, 1318, false ); actionClient = action; } } @@ -2462,7 +2629,7 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct RemoteStorageEnumerateWorkshopFilesResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal int ResultsReturned; // m_nResultsReturned int32 internal int TotalResultCount; // m_nTotalResultCount int32 [MarshalAs(UnmanagedType.ByValArray, SizeConst = 50, ArraySubType = UnmanagedType.U8)] @@ -2475,7 +2642,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoteStorageEnumerateWorkshopFilesResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientRemoteStorage + 19; + public int CallbackId => 1319; internal static RemoteStorageEnumerateWorkshopFilesResult_t Fill( IntPtr p ) => ((RemoteStorageEnumerateWorkshopFilesResult_t)Marshal.PtrToStructure( p, typeof(RemoteStorageEnumerateWorkshopFilesResult_t) ) ); static Action actionClient; @@ -2486,12 +2653,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientRemoteStorage + 19, true ); + Event.Register( OnServer, _datasize, 1319, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientRemoteStorage + 19, false ); + Event.Register( OnClient, _datasize, 1319, false ); actionClient = action; } } @@ -2501,7 +2668,7 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct RemoteStorageGetPublishedItemVoteDetailsResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal PublishedFileId PublishedFileId; // m_unPublishedFileId PublishedFileId_t internal int VotesFor; // m_nVotesFor int32 internal int VotesAgainst; // m_nVotesAgainst int32 @@ -2511,7 +2678,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoteStorageGetPublishedItemVoteDetailsResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientRemoteStorage + 20; + public int CallbackId => 1320; internal static RemoteStorageGetPublishedItemVoteDetailsResult_t Fill( IntPtr p ) => ((RemoteStorageGetPublishedItemVoteDetailsResult_t)Marshal.PtrToStructure( p, typeof(RemoteStorageGetPublishedItemVoteDetailsResult_t) ) ); static Action actionClient; @@ -2522,12 +2689,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientRemoteStorage + 20, true ); + Event.Register( OnServer, _datasize, 1320, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientRemoteStorage + 20, false ); + Event.Register( OnClient, _datasize, 1320, false ); actionClient = action; } } @@ -2543,7 +2710,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoteStoragePublishedFileSubscribed_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientRemoteStorage + 21; + public int CallbackId => 1321; internal static RemoteStoragePublishedFileSubscribed_t Fill( IntPtr p ) => ((RemoteStoragePublishedFileSubscribed_t)Marshal.PtrToStructure( p, typeof(RemoteStoragePublishedFileSubscribed_t) ) ); static Action actionClient; @@ -2554,12 +2721,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientRemoteStorage + 21, true ); + Event.Register( OnServer, _datasize, 1321, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientRemoteStorage + 21, false ); + Event.Register( OnClient, _datasize, 1321, false ); actionClient = action; } } @@ -2575,7 +2742,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoteStoragePublishedFileUnsubscribed_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientRemoteStorage + 22; + public int CallbackId => 1322; internal static RemoteStoragePublishedFileUnsubscribed_t Fill( IntPtr p ) => ((RemoteStoragePublishedFileUnsubscribed_t)Marshal.PtrToStructure( p, typeof(RemoteStoragePublishedFileUnsubscribed_t) ) ); static Action actionClient; @@ -2586,12 +2753,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientRemoteStorage + 22, true ); + Event.Register( OnServer, _datasize, 1322, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientRemoteStorage + 22, false ); + Event.Register( OnClient, _datasize, 1322, false ); actionClient = action; } } @@ -2607,7 +2774,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoteStoragePublishedFileDeleted_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientRemoteStorage + 23; + public int CallbackId => 1323; internal static RemoteStoragePublishedFileDeleted_t Fill( IntPtr p ) => ((RemoteStoragePublishedFileDeleted_t)Marshal.PtrToStructure( p, typeof(RemoteStoragePublishedFileDeleted_t) ) ); static Action actionClient; @@ -2618,12 +2785,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientRemoteStorage + 23, true ); + Event.Register( OnServer, _datasize, 1323, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientRemoteStorage + 23, false ); + Event.Register( OnClient, _datasize, 1323, false ); actionClient = action; } } @@ -2633,13 +2800,13 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct RemoteStorageUpdateUserPublishedItemVoteResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoteStorageUpdateUserPublishedItemVoteResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientRemoteStorage + 24; + public int CallbackId => 1324; internal static RemoteStorageUpdateUserPublishedItemVoteResult_t Fill( IntPtr p ) => ((RemoteStorageUpdateUserPublishedItemVoteResult_t)Marshal.PtrToStructure( p, typeof(RemoteStorageUpdateUserPublishedItemVoteResult_t) ) ); static Action actionClient; @@ -2650,12 +2817,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientRemoteStorage + 24, true ); + Event.Register( OnServer, _datasize, 1324, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientRemoteStorage + 24, false ); + Event.Register( OnClient, _datasize, 1324, false ); actionClient = action; } } @@ -2665,14 +2832,14 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct RemoteStorageUserVoteDetails_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t - internal WorkshopVote Vote; // m_eVote enum EWorkshopVote + internal WorkshopVote Vote; // m_eVote EWorkshopVote #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoteStorageUserVoteDetails_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientRemoteStorage + 25; + public int CallbackId => 1325; internal static RemoteStorageUserVoteDetails_t Fill( IntPtr p ) => ((RemoteStorageUserVoteDetails_t)Marshal.PtrToStructure( p, typeof(RemoteStorageUserVoteDetails_t) ) ); static Action actionClient; @@ -2683,12 +2850,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientRemoteStorage + 25, true ); + Event.Register( OnServer, _datasize, 1325, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientRemoteStorage + 25, false ); + Event.Register( OnClient, _datasize, 1325, false ); actionClient = action; } } @@ -2698,7 +2865,7 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct RemoteStorageEnumerateUserSharedWorkshopFilesResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal int ResultsReturned; // m_nResultsReturned int32 internal int TotalResultCount; // m_nTotalResultCount int32 [MarshalAs(UnmanagedType.ByValArray, SizeConst = 50, ArraySubType = UnmanagedType.U8)] @@ -2707,7 +2874,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoteStorageEnumerateUserSharedWorkshopFilesResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientRemoteStorage + 26; + public int CallbackId => 1326; internal static RemoteStorageEnumerateUserSharedWorkshopFilesResult_t Fill( IntPtr p ) => ((RemoteStorageEnumerateUserSharedWorkshopFilesResult_t)Marshal.PtrToStructure( p, typeof(RemoteStorageEnumerateUserSharedWorkshopFilesResult_t) ) ); static Action actionClient; @@ -2718,12 +2885,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientRemoteStorage + 26, true ); + Event.Register( OnServer, _datasize, 1326, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientRemoteStorage + 26, false ); + Event.Register( OnClient, _datasize, 1326, false ); actionClient = action; } } @@ -2733,14 +2900,14 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct RemoteStorageSetUserPublishedFileActionResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t - internal WorkshopFileAction Action; // m_eAction enum EWorkshopFileAction + internal WorkshopFileAction Action; // m_eAction EWorkshopFileAction #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoteStorageSetUserPublishedFileActionResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientRemoteStorage + 27; + public int CallbackId => 1327; internal static RemoteStorageSetUserPublishedFileActionResult_t Fill( IntPtr p ) => ((RemoteStorageSetUserPublishedFileActionResult_t)Marshal.PtrToStructure( p, typeof(RemoteStorageSetUserPublishedFileActionResult_t) ) ); static Action actionClient; @@ -2751,12 +2918,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientRemoteStorage + 27, true ); + Event.Register( OnServer, _datasize, 1327, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientRemoteStorage + 27, false ); + Event.Register( OnClient, _datasize, 1327, false ); actionClient = action; } } @@ -2766,8 +2933,8 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct RemoteStorageEnumeratePublishedFilesByUserActionResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult - internal WorkshopFileAction Action; // m_eAction enum EWorkshopFileAction + internal Result Result; // m_eResult EResult + internal WorkshopFileAction Action; // m_eAction EWorkshopFileAction internal int ResultsReturned; // m_nResultsReturned int32 internal int TotalResultCount; // m_nTotalResultCount int32 [MarshalAs(UnmanagedType.ByValArray, SizeConst = 50, ArraySubType = UnmanagedType.U8)] @@ -2778,7 +2945,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoteStorageEnumeratePublishedFilesByUserActionResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientRemoteStorage + 28; + public int CallbackId => 1328; internal static RemoteStorageEnumeratePublishedFilesByUserActionResult_t Fill( IntPtr p ) => ((RemoteStorageEnumeratePublishedFilesByUserActionResult_t)Marshal.PtrToStructure( p, typeof(RemoteStorageEnumeratePublishedFilesByUserActionResult_t) ) ); static Action actionClient; @@ -2789,12 +2956,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientRemoteStorage + 28, true ); + Event.Register( OnServer, _datasize, 1328, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientRemoteStorage + 28, false ); + Event.Register( OnClient, _datasize, 1328, false ); actionClient = action; } } @@ -2806,12 +2973,12 @@ namespace Steamworks.Data { internal double DPercentFile; // m_dPercentFile double [MarshalAs(UnmanagedType.I1)] - internal bool Preview; // m_bPreview _Bool + internal bool Preview; // m_bPreview bool #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoteStoragePublishFileProgress_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientRemoteStorage + 29; + public int CallbackId => 1329; internal static RemoteStoragePublishFileProgress_t Fill( IntPtr p ) => ((RemoteStoragePublishFileProgress_t)Marshal.PtrToStructure( p, typeof(RemoteStoragePublishFileProgress_t) ) ); static Action actionClient; @@ -2822,12 +2989,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientRemoteStorage + 29, true ); + Event.Register( OnServer, _datasize, 1329, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientRemoteStorage + 29, false ); + Event.Register( OnClient, _datasize, 1329, false ); actionClient = action; } } @@ -2844,7 +3011,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoteStoragePublishedFileUpdated_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientRemoteStorage + 30; + public int CallbackId => 1330; internal static RemoteStoragePublishedFileUpdated_t Fill( IntPtr p ) => ((RemoteStoragePublishedFileUpdated_t)Marshal.PtrToStructure( p, typeof(RemoteStoragePublishedFileUpdated_t) ) ); static Action actionClient; @@ -2855,12 +3022,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientRemoteStorage + 30, true ); + Event.Register( OnServer, _datasize, 1330, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientRemoteStorage + 30, false ); + Event.Register( OnClient, _datasize, 1330, false ); actionClient = action; } } @@ -2870,12 +3037,12 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct RemoteStorageFileWriteAsyncComplete_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoteStorageFileWriteAsyncComplete_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientRemoteStorage + 31; + public int CallbackId => 1331; internal static RemoteStorageFileWriteAsyncComplete_t Fill( IntPtr p ) => ((RemoteStorageFileWriteAsyncComplete_t)Marshal.PtrToStructure( p, typeof(RemoteStorageFileWriteAsyncComplete_t) ) ); static Action actionClient; @@ -2886,12 +3053,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientRemoteStorage + 31, true ); + Event.Register( OnServer, _datasize, 1331, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientRemoteStorage + 31, false ); + Event.Register( OnClient, _datasize, 1331, false ); actionClient = action; } } @@ -2902,14 +3069,14 @@ namespace Steamworks.Data internal struct RemoteStorageFileReadAsyncComplete_t : ICallbackData { internal ulong FileReadAsync; // m_hFileReadAsync SteamAPICall_t - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal uint Offset; // m_nOffset uint32 internal uint Read; // m_cubRead uint32 #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoteStorageFileReadAsyncComplete_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientRemoteStorage + 32; + public int CallbackId => 1332; internal static RemoteStorageFileReadAsyncComplete_t Fill( IntPtr p ) => ((RemoteStorageFileReadAsyncComplete_t)Marshal.PtrToStructure( p, typeof(RemoteStorageFileReadAsyncComplete_t) ) ); static Action actionClient; @@ -2920,43 +3087,29 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientRemoteStorage + 32, true ); + Event.Register( OnServer, _datasize, 1332, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientRemoteStorage + 32, false ); + Event.Register( OnClient, _datasize, 1332, false ); actionClient = action; } } #endregion } - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] - internal struct LeaderboardEntry_t - { - internal ulong SteamIDUser; // m_steamIDUser class CSteamID - internal int GlobalRank; // m_nGlobalRank int32 - internal int Score; // m_nScore int32 - internal int CDetails; // m_cDetails int32 - internal ulong UGC; // m_hUGC UGCHandle_t - - #region Marshalling - internal static LeaderboardEntry_t Fill( IntPtr p ) => ((LeaderboardEntry_t)(LeaderboardEntry_t) Marshal.PtrToStructure( p, typeof(LeaderboardEntry_t) ) ); - #endregion - } - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct UserStatsReceived_t : ICallbackData { internal ulong GameID; // m_nGameID uint64 - internal Result Result; // m_eResult enum EResult - internal ulong SteamIDUser; // m_steamIDUser class CSteamID + internal Result Result; // m_eResult EResult + internal ulong SteamIDUser; // m_steamIDUser CSteamID #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(UserStatsReceived_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUserStats + 1; + public int CallbackId => 1101; internal static UserStatsReceived_t Fill( IntPtr p ) => ((UserStatsReceived_t)Marshal.PtrToStructure( p, typeof(UserStatsReceived_t) ) ); static Action actionClient; @@ -2967,12 +3120,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUserStats + 1, true ); + Event.Register( OnServer, _datasize, 1101, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUserStats + 1, false ); + Event.Register( OnClient, _datasize, 1101, false ); actionClient = action; } } @@ -2983,12 +3136,12 @@ namespace Steamworks.Data internal struct UserStatsStored_t : ICallbackData { internal ulong GameID; // m_nGameID uint64 - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(UserStatsStored_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUserStats + 2; + public int CallbackId => 1102; internal static UserStatsStored_t Fill( IntPtr p ) => ((UserStatsStored_t)Marshal.PtrToStructure( p, typeof(UserStatsStored_t) ) ); static Action actionClient; @@ -2999,12 +3152,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUserStats + 2, true ); + Event.Register( OnServer, _datasize, 1102, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUserStats + 2, false ); + Event.Register( OnClient, _datasize, 1102, false ); actionClient = action; } } @@ -3016,7 +3169,7 @@ namespace Steamworks.Data { internal ulong GameID; // m_nGameID uint64 [MarshalAs(UnmanagedType.I1)] - internal bool GroupAchievement; // m_bGroupAchievement _Bool + internal bool GroupAchievement; // m_bGroupAchievement bool internal string AchievementNameUTF8() => System.Text.Encoding.UTF8.GetString( AchievementName, 0, System.Array.IndexOf( AchievementName, 0 ) ); [MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)] // byte[] m_rgchAchievementName internal byte[] AchievementName; // m_rgchAchievementName char [128] @@ -3026,7 +3179,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(UserAchievementStored_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUserStats + 3; + public int CallbackId => 1103; internal static UserAchievementStored_t Fill( IntPtr p ) => ((UserAchievementStored_t)Marshal.PtrToStructure( p, typeof(UserAchievementStored_t) ) ); static Action actionClient; @@ -3037,12 +3190,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUserStats + 3, true ); + Event.Register( OnServer, _datasize, 1103, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUserStats + 3, false ); + Event.Register( OnClient, _datasize, 1103, false ); actionClient = action; } } @@ -3058,7 +3211,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(LeaderboardFindResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUserStats + 4; + public int CallbackId => 1104; internal static LeaderboardFindResult_t Fill( IntPtr p ) => ((LeaderboardFindResult_t)Marshal.PtrToStructure( p, typeof(LeaderboardFindResult_t) ) ); static Action actionClient; @@ -3069,12 +3222,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUserStats + 4, true ); + Event.Register( OnServer, _datasize, 1104, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUserStats + 4, false ); + Event.Register( OnClient, _datasize, 1104, false ); actionClient = action; } } @@ -3091,7 +3244,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(LeaderboardScoresDownloaded_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUserStats + 5; + public int CallbackId => 1105; internal static LeaderboardScoresDownloaded_t Fill( IntPtr p ) => ((LeaderboardScoresDownloaded_t)Marshal.PtrToStructure( p, typeof(LeaderboardScoresDownloaded_t) ) ); static Action actionClient; @@ -3102,12 +3255,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUserStats + 5, true ); + Event.Register( OnServer, _datasize, 1105, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUserStats + 5, false ); + Event.Register( OnClient, _datasize, 1105, false ); actionClient = action; } } @@ -3127,7 +3280,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(LeaderboardScoreUploaded_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUserStats + 6; + public int CallbackId => 1106; internal static LeaderboardScoreUploaded_t Fill( IntPtr p ) => ((LeaderboardScoreUploaded_t)Marshal.PtrToStructure( p, typeof(LeaderboardScoreUploaded_t) ) ); static Action actionClient; @@ -3138,12 +3291,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUserStats + 6, true ); + Event.Register( OnServer, _datasize, 1106, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUserStats + 6, false ); + Event.Register( OnClient, _datasize, 1106, false ); actionClient = action; } } @@ -3159,7 +3312,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(NumberOfCurrentPlayers_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUserStats + 7; + public int CallbackId => 1107; internal static NumberOfCurrentPlayers_t Fill( IntPtr p ) => ((NumberOfCurrentPlayers_t)Marshal.PtrToStructure( p, typeof(NumberOfCurrentPlayers_t) ) ); static Action actionClient; @@ -3170,12 +3323,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUserStats + 7, true ); + Event.Register( OnServer, _datasize, 1107, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUserStats + 7, false ); + Event.Register( OnClient, _datasize, 1107, false ); actionClient = action; } } @@ -3185,12 +3338,12 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct UserStatsUnloaded_t : ICallbackData { - internal ulong SteamIDUser; // m_steamIDUser class CSteamID + internal ulong SteamIDUser; // m_steamIDUser CSteamID #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(UserStatsUnloaded_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUserStats + 8; + public int CallbackId => 1108; internal static UserStatsUnloaded_t Fill( IntPtr p ) => ((UserStatsUnloaded_t)Marshal.PtrToStructure( p, typeof(UserStatsUnloaded_t) ) ); static Action actionClient; @@ -3201,12 +3354,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUserStats + 8, true ); + Event.Register( OnServer, _datasize, 1108, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUserStats + 8, false ); + Event.Register( OnClient, _datasize, 1108, false ); actionClient = action; } } @@ -3216,18 +3369,18 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct UserAchievementIconFetched_t : ICallbackData { - internal GameId GameID; // m_nGameID class CGameID + internal GameId GameID; // m_nGameID CGameID internal string AchievementNameUTF8() => System.Text.Encoding.UTF8.GetString( AchievementName, 0, System.Array.IndexOf( AchievementName, 0 ) ); [MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)] // byte[] m_rgchAchievementName internal byte[] AchievementName; // m_rgchAchievementName char [128] [MarshalAs(UnmanagedType.I1)] - internal bool Achieved; // m_bAchieved _Bool + internal bool Achieved; // m_bAchieved bool internal int IconHandle; // m_nIconHandle int #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(UserAchievementIconFetched_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUserStats + 9; + public int CallbackId => 1109; internal static UserAchievementIconFetched_t Fill( IntPtr p ) => ((UserAchievementIconFetched_t)Marshal.PtrToStructure( p, typeof(UserAchievementIconFetched_t) ) ); static Action actionClient; @@ -3238,12 +3391,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUserStats + 9, true ); + Event.Register( OnServer, _datasize, 1109, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUserStats + 9, false ); + Event.Register( OnClient, _datasize, 1109, false ); actionClient = action; } } @@ -3254,12 +3407,12 @@ namespace Steamworks.Data internal struct GlobalAchievementPercentagesReady_t : ICallbackData { internal ulong GameID; // m_nGameID uint64 - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GlobalAchievementPercentagesReady_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUserStats + 10; + public int CallbackId => 1110; internal static GlobalAchievementPercentagesReady_t Fill( IntPtr p ) => ((GlobalAchievementPercentagesReady_t)Marshal.PtrToStructure( p, typeof(GlobalAchievementPercentagesReady_t) ) ); static Action actionClient; @@ -3270,12 +3423,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUserStats + 10, true ); + Event.Register( OnServer, _datasize, 1110, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUserStats + 10, false ); + Event.Register( OnClient, _datasize, 1110, false ); actionClient = action; } } @@ -3285,13 +3438,13 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct LeaderboardUGCSet_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal ulong SteamLeaderboard; // m_hSteamLeaderboard SteamLeaderboard_t #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(LeaderboardUGCSet_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUserStats + 11; + public int CallbackId => 1111; internal static LeaderboardUGCSet_t Fill( IntPtr p ) => ((LeaderboardUGCSet_t)Marshal.PtrToStructure( p, typeof(LeaderboardUGCSet_t) ) ); static Action actionClient; @@ -3302,12 +3455,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUserStats + 11, true ); + Event.Register( OnServer, _datasize, 1111, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUserStats + 11, false ); + Event.Register( OnClient, _datasize, 1111, false ); actionClient = action; } } @@ -3318,13 +3471,13 @@ namespace Steamworks.Data internal struct PS3TrophiesInstalled_t : ICallbackData { internal ulong GameID; // m_nGameID uint64 - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal ulong RequiredDiskSpace; // m_ulRequiredDiskSpace uint64 #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(PS3TrophiesInstalled_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUserStats + 12; + public int CallbackId => 1112; internal static PS3TrophiesInstalled_t Fill( IntPtr p ) => ((PS3TrophiesInstalled_t)Marshal.PtrToStructure( p, typeof(PS3TrophiesInstalled_t) ) ); static Action actionClient; @@ -3335,12 +3488,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUserStats + 12, true ); + Event.Register( OnServer, _datasize, 1112, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUserStats + 12, false ); + Event.Register( OnClient, _datasize, 1112, false ); actionClient = action; } } @@ -3351,12 +3504,12 @@ namespace Steamworks.Data internal struct GlobalStatsReceived_t : ICallbackData { internal ulong GameID; // m_nGameID uint64 - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GlobalStatsReceived_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUserStats + 12; + public int CallbackId => 1112; internal static GlobalStatsReceived_t Fill( IntPtr p ) => ((GlobalStatsReceived_t)Marshal.PtrToStructure( p, typeof(GlobalStatsReceived_t) ) ); static Action actionClient; @@ -3367,12 +3520,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUserStats + 12, true ); + Event.Register( OnServer, _datasize, 1112, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUserStats + 12, false ); + Event.Register( OnClient, _datasize, 1112, false ); actionClient = action; } } @@ -3387,7 +3540,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(DlcInstalled_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamApps + 5; + public int CallbackId => 1005; internal static DlcInstalled_t Fill( IntPtr p ) => ((DlcInstalled_t)Marshal.PtrToStructure( p, typeof(DlcInstalled_t) ) ); static Action actionClient; @@ -3398,12 +3551,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamApps + 5, true ); + Event.Register( OnServer, _datasize, 1005, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamApps + 5, false ); + Event.Register( OnClient, _datasize, 1005, false ); actionClient = action; } } @@ -3413,13 +3566,13 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct RegisterActivationCodeResponse_t : ICallbackData { - internal RegisterActivationCodeResult Result; // m_eResult enum ERegisterActivationCodeResult + internal RegisterActivationCodeResult Result; // m_eResult ERegisterActivationCodeResult internal uint PackageRegistered; // m_unPackageRegistered uint32 #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RegisterActivationCodeResponse_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamApps + 8; + public int CallbackId => 1008; internal static RegisterActivationCodeResponse_t Fill( IntPtr p ) => ((RegisterActivationCodeResponse_t)Marshal.PtrToStructure( p, typeof(RegisterActivationCodeResponse_t) ) ); static Action actionClient; @@ -3430,12 +3583,42 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamApps + 8, true ); + Event.Register( OnServer, _datasize, 1008, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamApps + 8, false ); + Event.Register( OnClient, _datasize, 1008, false ); + actionClient = action; + } + } + #endregion + } + + [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] + internal struct NewUrlLaunchParameters_t : ICallbackData + { + + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(NewUrlLaunchParameters_t) ); + public int DataSize => _datasize; + public int CallbackId => 1014; + internal static NewUrlLaunchParameters_t Fill( IntPtr p ) => ((NewUrlLaunchParameters_t)Marshal.PtrToStructure( p, typeof(NewUrlLaunchParameters_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 1014, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 1014, false ); actionClient = action; } } @@ -3445,7 +3628,7 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct AppProofOfPurchaseKeyResponse_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal uint AppID; // m_nAppID uint32 internal uint CchKeyLength; // m_cchKeyLength uint32 internal string KeyUTF8() => System.Text.Encoding.UTF8.GetString( Key, 0, System.Array.IndexOf( Key, 0 ) ); @@ -3455,7 +3638,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(AppProofOfPurchaseKeyResponse_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamApps + 21; + public int CallbackId => 1021; internal static AppProofOfPurchaseKeyResponse_t Fill( IntPtr p ) => ((AppProofOfPurchaseKeyResponse_t)Marshal.PtrToStructure( p, typeof(AppProofOfPurchaseKeyResponse_t) ) ); static Action actionClient; @@ -3466,12 +3649,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamApps + 21, true ); + Event.Register( OnServer, _datasize, 1021, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamApps + 21, false ); + Event.Register( OnClient, _datasize, 1021, false ); actionClient = action; } } @@ -3481,7 +3664,7 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct FileDetailsResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal ulong FileSize; // m_ulFileSize uint64 [MarshalAs(UnmanagedType.ByValArray, SizeConst = 20)] // m_FileSHA internal byte[] FileSHA; // m_FileSHA uint8 [20] @@ -3490,7 +3673,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(FileDetailsResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamApps + 23; + public int CallbackId => 1023; internal static FileDetailsResult_t Fill( IntPtr p ) => ((FileDetailsResult_t)Marshal.PtrToStructure( p, typeof(FileDetailsResult_t) ) ); static Action actionClient; @@ -3501,44 +3684,27 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamApps + 23, true ); + Event.Register( OnServer, _datasize, 1023, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamApps + 23, false ); + Event.Register( OnClient, _datasize, 1023, false ); actionClient = action; } } #endregion } - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct P2PSessionState_t - { - internal byte ConnectionActive; // m_bConnectionActive uint8 - internal byte Connecting; // m_bConnecting uint8 - internal byte P2PSessionError; // m_eP2PSessionError uint8 - internal byte UsingRelay; // m_bUsingRelay uint8 - internal int BytesQueuedForSend; // m_nBytesQueuedForSend int32 - internal int PacketsQueuedForSend; // m_nPacketsQueuedForSend int32 - internal uint RemoteIP; // m_nRemoteIP uint32 - internal ushort RemotePort; // m_nRemotePort uint16 - - #region Marshalling - internal static P2PSessionState_t Fill( IntPtr p ) => ((P2PSessionState_t)(P2PSessionState_t) Marshal.PtrToStructure( p, typeof(P2PSessionState_t) ) ); - #endregion - } - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct P2PSessionRequest_t : ICallbackData { - internal ulong SteamIDRemote; // m_steamIDRemote class CSteamID + internal ulong SteamIDRemote; // m_steamIDRemote CSteamID #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(P2PSessionRequest_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamNetworking + 2; + public int CallbackId => 1202; internal static P2PSessionRequest_t Fill( IntPtr p ) => ((P2PSessionRequest_t)Marshal.PtrToStructure( p, typeof(P2PSessionRequest_t) ) ); static Action actionClient; @@ -3549,12 +3715,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamNetworking + 2, true ); + Event.Register( OnServer, _datasize, 1202, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamNetworking + 2, false ); + Event.Register( OnClient, _datasize, 1202, false ); actionClient = action; } } @@ -3564,13 +3730,13 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct P2PSessionConnectFail_t : ICallbackData { - internal ulong SteamIDRemote; // m_steamIDRemote class CSteamID + internal ulong SteamIDRemote; // m_steamIDRemote CSteamID internal byte P2PSessionError; // m_eP2PSessionError uint8 #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(P2PSessionConnectFail_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamNetworking + 3; + public int CallbackId => 1203; internal static P2PSessionConnectFail_t Fill( IntPtr p ) => ((P2PSessionConnectFail_t)Marshal.PtrToStructure( p, typeof(P2PSessionConnectFail_t) ) ); static Action actionClient; @@ -3581,12 +3747,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamNetworking + 3, true ); + Event.Register( OnServer, _datasize, 1203, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamNetworking + 3, false ); + Event.Register( OnClient, _datasize, 1203, false ); actionClient = action; } } @@ -3598,13 +3764,13 @@ namespace Steamworks.Data { internal uint Socket; // m_hSocket SNetSocket_t internal uint ListenSocket; // m_hListenSocket SNetListenSocket_t - internal ulong SteamIDRemote; // m_steamIDRemote class CSteamID + internal ulong SteamIDRemote; // m_steamIDRemote CSteamID internal int SNetSocketState; // m_eSNetSocketState int #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SocketStatusCallback_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamNetworking + 1; + public int CallbackId => 1201; internal static SocketStatusCallback_t Fill( IntPtr p ) => ((SocketStatusCallback_t)Marshal.PtrToStructure( p, typeof(SocketStatusCallback_t) ) ); static Action actionClient; @@ -3615,12 +3781,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamNetworking + 1, true ); + Event.Register( OnServer, _datasize, 1201, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamNetworking + 1, false ); + Event.Register( OnClient, _datasize, 1201, false ); actionClient = action; } } @@ -3631,12 +3797,12 @@ namespace Steamworks.Data internal struct ScreenshotReady_t : ICallbackData { internal uint Local; // m_hLocal ScreenshotHandle - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(ScreenshotReady_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamScreenshots + 1; + public int CallbackId => 2301; internal static ScreenshotReady_t Fill( IntPtr p ) => ((ScreenshotReady_t)Marshal.PtrToStructure( p, typeof(ScreenshotReady_t) ) ); static Action actionClient; @@ -3647,12 +3813,72 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamScreenshots + 1, true ); + Event.Register( OnServer, _datasize, 2301, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamScreenshots + 1, false ); + Event.Register( OnClient, _datasize, 2301, false ); + actionClient = action; + } + } + #endregion + } + + [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] + internal struct ScreenshotRequested_t : ICallbackData + { + + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(ScreenshotRequested_t) ); + public int DataSize => _datasize; + public int CallbackId => 2302; + internal static ScreenshotRequested_t Fill( IntPtr p ) => ((ScreenshotRequested_t)Marshal.PtrToStructure( p, typeof(ScreenshotRequested_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 2302, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 2302, false ); + actionClient = action; + } + } + #endregion + } + + [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] + internal struct PlaybackStatusHasChanged_t : ICallbackData + { + + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(PlaybackStatusHasChanged_t) ); + public int DataSize => _datasize; + public int CallbackId => 4001; + internal static PlaybackStatusHasChanged_t Fill( IntPtr p ) => ((PlaybackStatusHasChanged_t)Marshal.PtrToStructure( p, typeof(PlaybackStatusHasChanged_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 4001, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 4001, false ); actionClient = action; } } @@ -3667,7 +3893,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(VolumeHasChanged_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamMusic + 2; + public int CallbackId => 4002; internal static VolumeHasChanged_t Fill( IntPtr p ) => ((VolumeHasChanged_t)Marshal.PtrToStructure( p, typeof(VolumeHasChanged_t) ) ); static Action actionClient; @@ -3678,12 +3904,252 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamMusic + 2, true ); + Event.Register( OnServer, _datasize, 4002, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamMusic + 2, false ); + Event.Register( OnClient, _datasize, 4002, false ); + actionClient = action; + } + } + #endregion + } + + [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] + internal struct MusicPlayerRemoteWillActivate_t : ICallbackData + { + + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(MusicPlayerRemoteWillActivate_t) ); + public int DataSize => _datasize; + public int CallbackId => 4101; + internal static MusicPlayerRemoteWillActivate_t Fill( IntPtr p ) => ((MusicPlayerRemoteWillActivate_t)Marshal.PtrToStructure( p, typeof(MusicPlayerRemoteWillActivate_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 4101, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 4101, false ); + actionClient = action; + } + } + #endregion + } + + [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] + internal struct MusicPlayerRemoteWillDeactivate_t : ICallbackData + { + + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(MusicPlayerRemoteWillDeactivate_t) ); + public int DataSize => _datasize; + public int CallbackId => 4102; + internal static MusicPlayerRemoteWillDeactivate_t Fill( IntPtr p ) => ((MusicPlayerRemoteWillDeactivate_t)Marshal.PtrToStructure( p, typeof(MusicPlayerRemoteWillDeactivate_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 4102, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 4102, false ); + actionClient = action; + } + } + #endregion + } + + [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] + internal struct MusicPlayerRemoteToFront_t : ICallbackData + { + + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(MusicPlayerRemoteToFront_t) ); + public int DataSize => _datasize; + public int CallbackId => 4103; + internal static MusicPlayerRemoteToFront_t Fill( IntPtr p ) => ((MusicPlayerRemoteToFront_t)Marshal.PtrToStructure( p, typeof(MusicPlayerRemoteToFront_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 4103, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 4103, false ); + actionClient = action; + } + } + #endregion + } + + [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] + internal struct MusicPlayerWillQuit_t : ICallbackData + { + + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(MusicPlayerWillQuit_t) ); + public int DataSize => _datasize; + public int CallbackId => 4104; + internal static MusicPlayerWillQuit_t Fill( IntPtr p ) => ((MusicPlayerWillQuit_t)Marshal.PtrToStructure( p, typeof(MusicPlayerWillQuit_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 4104, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 4104, false ); + actionClient = action; + } + } + #endregion + } + + [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] + internal struct MusicPlayerWantsPlay_t : ICallbackData + { + + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(MusicPlayerWantsPlay_t) ); + public int DataSize => _datasize; + public int CallbackId => 4105; + internal static MusicPlayerWantsPlay_t Fill( IntPtr p ) => ((MusicPlayerWantsPlay_t)Marshal.PtrToStructure( p, typeof(MusicPlayerWantsPlay_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 4105, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 4105, false ); + actionClient = action; + } + } + #endregion + } + + [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] + internal struct MusicPlayerWantsPause_t : ICallbackData + { + + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(MusicPlayerWantsPause_t) ); + public int DataSize => _datasize; + public int CallbackId => 4106; + internal static MusicPlayerWantsPause_t Fill( IntPtr p ) => ((MusicPlayerWantsPause_t)Marshal.PtrToStructure( p, typeof(MusicPlayerWantsPause_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 4106, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 4106, false ); + actionClient = action; + } + } + #endregion + } + + [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] + internal struct MusicPlayerWantsPlayPrevious_t : ICallbackData + { + + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(MusicPlayerWantsPlayPrevious_t) ); + public int DataSize => _datasize; + public int CallbackId => 4107; + internal static MusicPlayerWantsPlayPrevious_t Fill( IntPtr p ) => ((MusicPlayerWantsPlayPrevious_t)Marshal.PtrToStructure( p, typeof(MusicPlayerWantsPlayPrevious_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 4107, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 4107, false ); + actionClient = action; + } + } + #endregion + } + + [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] + internal struct MusicPlayerWantsPlayNext_t : ICallbackData + { + + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(MusicPlayerWantsPlayNext_t) ); + public int DataSize => _datasize; + public int CallbackId => 4108; + internal static MusicPlayerWantsPlayNext_t Fill( IntPtr p ) => ((MusicPlayerWantsPlayNext_t)Marshal.PtrToStructure( p, typeof(MusicPlayerWantsPlayNext_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 4108, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 4108, false ); actionClient = action; } } @@ -3694,12 +4160,12 @@ namespace Steamworks.Data internal struct MusicPlayerWantsShuffled_t : ICallbackData { [MarshalAs(UnmanagedType.I1)] - internal bool Shuffled; // m_bShuffled _Bool + internal bool Shuffled; // m_bShuffled bool #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(MusicPlayerWantsShuffled_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamMusicRemote + 9; + public int CallbackId => 4109; internal static MusicPlayerWantsShuffled_t Fill( IntPtr p ) => ((MusicPlayerWantsShuffled_t)Marshal.PtrToStructure( p, typeof(MusicPlayerWantsShuffled_t) ) ); static Action actionClient; @@ -3710,12 +4176,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamMusicRemote + 9, true ); + Event.Register( OnServer, _datasize, 4109, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamMusicRemote + 9, false ); + Event.Register( OnClient, _datasize, 4109, false ); actionClient = action; } } @@ -3726,12 +4192,12 @@ namespace Steamworks.Data internal struct MusicPlayerWantsLooped_t : ICallbackData { [MarshalAs(UnmanagedType.I1)] - internal bool Looped; // m_bLooped _Bool + internal bool Looped; // m_bLooped bool #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(MusicPlayerWantsLooped_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamMusicRemote + 10; + public int CallbackId => 4110; internal static MusicPlayerWantsLooped_t Fill( IntPtr p ) => ((MusicPlayerWantsLooped_t)Marshal.PtrToStructure( p, typeof(MusicPlayerWantsLooped_t) ) ); static Action actionClient; @@ -3742,12 +4208,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamMusicRemote + 10, true ); + Event.Register( OnServer, _datasize, 4110, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamMusicRemote + 10, false ); + Event.Register( OnClient, _datasize, 4110, false ); actionClient = action; } } @@ -3762,7 +4228,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(MusicPlayerWantsVolume_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamMusic + 11; + public int CallbackId => 4011; internal static MusicPlayerWantsVolume_t Fill( IntPtr p ) => ((MusicPlayerWantsVolume_t)Marshal.PtrToStructure( p, typeof(MusicPlayerWantsVolume_t) ) ); static Action actionClient; @@ -3773,12 +4239,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamMusic + 11, true ); + Event.Register( OnServer, _datasize, 4011, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamMusic + 11, false ); + Event.Register( OnClient, _datasize, 4011, false ); actionClient = action; } } @@ -3793,7 +4259,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(MusicPlayerSelectsQueueEntry_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamMusic + 12; + public int CallbackId => 4012; internal static MusicPlayerSelectsQueueEntry_t Fill( IntPtr p ) => ((MusicPlayerSelectsQueueEntry_t)Marshal.PtrToStructure( p, typeof(MusicPlayerSelectsQueueEntry_t) ) ); static Action actionClient; @@ -3804,12 +4270,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamMusic + 12, true ); + Event.Register( OnServer, _datasize, 4012, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamMusic + 12, false ); + Event.Register( OnClient, _datasize, 4012, false ); actionClient = action; } } @@ -3824,7 +4290,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(MusicPlayerSelectsPlaylistEntry_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamMusic + 13; + public int CallbackId => 4013; internal static MusicPlayerSelectsPlaylistEntry_t Fill( IntPtr p ) => ((MusicPlayerSelectsPlaylistEntry_t)Marshal.PtrToStructure( p, typeof(MusicPlayerSelectsPlaylistEntry_t) ) ); static Action actionClient; @@ -3835,12 +4301,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamMusic + 13, true ); + Event.Register( OnServer, _datasize, 4013, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamMusic + 13, false ); + Event.Register( OnClient, _datasize, 4013, false ); actionClient = action; } } @@ -3855,7 +4321,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(MusicPlayerWantsPlayingRepeatStatus_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamMusicRemote + 14; + public int CallbackId => 4114; internal static MusicPlayerWantsPlayingRepeatStatus_t Fill( IntPtr p ) => ((MusicPlayerWantsPlayingRepeatStatus_t)Marshal.PtrToStructure( p, typeof(MusicPlayerWantsPlayingRepeatStatus_t) ) ); static Action actionClient; @@ -3866,12 +4332,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamMusicRemote + 14, true ); + Event.Register( OnServer, _datasize, 4114, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamMusicRemote + 14, false ); + Event.Register( OnClient, _datasize, 4114, false ); actionClient = action; } } @@ -3884,14 +4350,14 @@ namespace Steamworks.Data internal uint Request; // m_hRequest HTTPRequestHandle internal ulong ContextValue; // m_ulContextValue uint64 [MarshalAs(UnmanagedType.I1)] - internal bool RequestSuccessful; // m_bRequestSuccessful _Bool - internal HTTPStatusCode StatusCode; // m_eStatusCode enum EHTTPStatusCode + internal bool RequestSuccessful; // m_bRequestSuccessful bool + internal HTTPStatusCode StatusCode; // m_eStatusCode EHTTPStatusCode internal uint BodySize; // m_unBodySize uint32 #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(HTTPRequestCompleted_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientHTTP + 1; + public int CallbackId => 2101; internal static HTTPRequestCompleted_t Fill( IntPtr p ) => ((HTTPRequestCompleted_t)Marshal.PtrToStructure( p, typeof(HTTPRequestCompleted_t) ) ); static Action actionClient; @@ -3902,12 +4368,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientHTTP + 1, true ); + Event.Register( OnServer, _datasize, 2101, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientHTTP + 1, false ); + Event.Register( OnClient, _datasize, 2101, false ); actionClient = action; } } @@ -3923,7 +4389,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(HTTPRequestHeadersReceived_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientHTTP + 2; + public int CallbackId => 2102; internal static HTTPRequestHeadersReceived_t Fill( IntPtr p ) => ((HTTPRequestHeadersReceived_t)Marshal.PtrToStructure( p, typeof(HTTPRequestHeadersReceived_t) ) ); static Action actionClient; @@ -3934,12 +4400,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientHTTP + 2, true ); + Event.Register( OnServer, _datasize, 2102, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientHTTP + 2, false ); + Event.Register( OnClient, _datasize, 2102, false ); actionClient = action; } } @@ -3957,7 +4423,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(HTTPRequestDataReceived_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientHTTP + 3; + public int CallbackId => 2103; internal static HTTPRequestDataReceived_t Fill( IntPtr p ) => ((HTTPRequestDataReceived_t)Marshal.PtrToStructure( p, typeof(HTTPRequestDataReceived_t) ) ); static Action actionClient; @@ -3968,75 +4434,27 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientHTTP + 3, true ); + Event.Register( OnServer, _datasize, 2103, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientHTTP + 3, false ); + Event.Register( OnClient, _datasize, 2103, false ); actionClient = action; } } #endregion } - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct SteamUGCDetails_t - { - internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t - internal Result Result; // m_eResult enum EResult - internal WorkshopFileType FileType; // m_eFileType enum EWorkshopFileType - internal AppId CreatorAppID; // m_nCreatorAppID AppId_t - internal AppId ConsumerAppID; // m_nConsumerAppID AppId_t - internal string TitleUTF8() => System.Text.Encoding.UTF8.GetString( Title, 0, System.Array.IndexOf( Title, 0 ) ); - [MarshalAs(UnmanagedType.ByValArray, SizeConst = 129)] // byte[] m_rgchTitle - internal byte[] Title; // m_rgchTitle char [129] - internal string DescriptionUTF8() => System.Text.Encoding.UTF8.GetString( Description, 0, System.Array.IndexOf( Description, 0 ) ); - [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8000)] // byte[] m_rgchDescription - internal byte[] Description; // m_rgchDescription char [8000] - internal ulong SteamIDOwner; // m_ulSteamIDOwner uint64 - internal uint TimeCreated; // m_rtimeCreated uint32 - internal uint TimeUpdated; // m_rtimeUpdated uint32 - internal uint TimeAddedToUserList; // m_rtimeAddedToUserList uint32 - internal RemoteStoragePublishedFileVisibility Visibility; // m_eVisibility enum ERemoteStoragePublishedFileVisibility - [MarshalAs(UnmanagedType.I1)] - internal bool Banned; // m_bBanned _Bool - [MarshalAs(UnmanagedType.I1)] - internal bool AcceptedForUse; // m_bAcceptedForUse _Bool - [MarshalAs(UnmanagedType.I1)] - internal bool TagsTruncated; // m_bTagsTruncated _Bool - internal string TagsUTF8() => System.Text.Encoding.UTF8.GetString( Tags, 0, System.Array.IndexOf( Tags, 0 ) ); - [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1025)] // byte[] m_rgchTags - internal byte[] Tags; // m_rgchTags char [1025] - internal ulong File; // m_hFile UGCHandle_t - internal ulong PreviewFile; // m_hPreviewFile UGCHandle_t - internal string PchFileNameUTF8() => System.Text.Encoding.UTF8.GetString( PchFileName, 0, System.Array.IndexOf( PchFileName, 0 ) ); - [MarshalAs(UnmanagedType.ByValArray, SizeConst = 260)] // byte[] m_pchFileName - internal byte[] PchFileName; // m_pchFileName char [260] - internal int FileSize; // m_nFileSize int32 - internal int PreviewFileSize; // m_nPreviewFileSize int32 - internal string URLUTF8() => System.Text.Encoding.UTF8.GetString( URL, 0, System.Array.IndexOf( URL, 0 ) ); - [MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)] // byte[] m_rgchURL - internal byte[] URL; // m_rgchURL char [256] - internal uint VotesUp; // m_unVotesUp uint32 - internal uint VotesDown; // m_unVotesDown uint32 - internal float Score; // m_flScore float - internal uint NumChildren; // m_unNumChildren uint32 - - #region Marshalling - internal static SteamUGCDetails_t Fill( IntPtr p ) => ((SteamUGCDetails_t)(SteamUGCDetails_t) Marshal.PtrToStructure( p, typeof(SteamUGCDetails_t) ) ); - #endregion - } - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct SteamUGCQueryCompleted_t : ICallbackData { internal ulong Handle; // m_handle UGCQueryHandle_t - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal uint NumResultsReturned; // m_unNumResultsReturned uint32 internal uint TotalMatchingResults; // m_unTotalMatchingResults uint32 [MarshalAs(UnmanagedType.I1)] - internal bool CachedData; // m_bCachedData _Bool + internal bool CachedData; // m_bCachedData bool internal string NextCursorUTF8() => System.Text.Encoding.UTF8.GetString( NextCursor, 0, System.Array.IndexOf( NextCursor, 0 ) ); [MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)] // byte[] m_rgchNextCursor internal byte[] NextCursor; // m_rgchNextCursor char [256] @@ -4044,7 +4462,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SteamUGCQueryCompleted_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientUGC + 1; + public int CallbackId => 3401; internal static SteamUGCQueryCompleted_t Fill( IntPtr p ) => ((SteamUGCQueryCompleted_t)Marshal.PtrToStructure( p, typeof(SteamUGCQueryCompleted_t) ) ); static Action actionClient; @@ -4055,12 +4473,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientUGC + 1, true ); + Event.Register( OnServer, _datasize, 3401, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientUGC + 1, false ); + Event.Register( OnClient, _datasize, 3401, false ); actionClient = action; } } @@ -4070,14 +4488,14 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct SteamUGCRequestUGCDetailsResult_t : ICallbackData { - internal SteamUGCDetails_t Details; // m_details struct SteamUGCDetails_t + internal SteamUGCDetails_t Details; // m_details SteamUGCDetails_t [MarshalAs(UnmanagedType.I1)] - internal bool CachedData; // m_bCachedData _Bool + internal bool CachedData; // m_bCachedData bool #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SteamUGCRequestUGCDetailsResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientUGC + 2; + public int CallbackId => 3402; internal static SteamUGCRequestUGCDetailsResult_t Fill( IntPtr p ) => ((SteamUGCRequestUGCDetailsResult_t)Marshal.PtrToStructure( p, typeof(SteamUGCRequestUGCDetailsResult_t) ) ); static Action actionClient; @@ -4088,12 +4506,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientUGC + 2, true ); + Event.Register( OnServer, _datasize, 3402, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientUGC + 2, false ); + Event.Register( OnClient, _datasize, 3402, false ); actionClient = action; } } @@ -4103,15 +4521,15 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct CreateItemResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t [MarshalAs(UnmanagedType.I1)] - internal bool UserNeedsToAcceptWorkshopLegalAgreement; // m_bUserNeedsToAcceptWorkshopLegalAgreement _Bool + internal bool UserNeedsToAcceptWorkshopLegalAgreement; // m_bUserNeedsToAcceptWorkshopLegalAgreement bool #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(CreateItemResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientUGC + 3; + public int CallbackId => 3403; internal static CreateItemResult_t Fill( IntPtr p ) => ((CreateItemResult_t)Marshal.PtrToStructure( p, typeof(CreateItemResult_t) ) ); static Action actionClient; @@ -4122,12 +4540,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientUGC + 3, true ); + Event.Register( OnServer, _datasize, 3403, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientUGC + 3, false ); + Event.Register( OnClient, _datasize, 3403, false ); actionClient = action; } } @@ -4137,15 +4555,15 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct SubmitItemUpdateResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult [MarshalAs(UnmanagedType.I1)] - internal bool UserNeedsToAcceptWorkshopLegalAgreement; // m_bUserNeedsToAcceptWorkshopLegalAgreement _Bool + internal bool UserNeedsToAcceptWorkshopLegalAgreement; // m_bUserNeedsToAcceptWorkshopLegalAgreement bool internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SubmitItemUpdateResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientUGC + 4; + public int CallbackId => 3404; internal static SubmitItemUpdateResult_t Fill( IntPtr p ) => ((SubmitItemUpdateResult_t)Marshal.PtrToStructure( p, typeof(SubmitItemUpdateResult_t) ) ); static Action actionClient; @@ -4156,12 +4574,44 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientUGC + 4, true ); + Event.Register( OnServer, _datasize, 3404, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientUGC + 4, false ); + Event.Register( OnClient, _datasize, 3404, false ); + actionClient = action; + } + } + #endregion + } + + [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] + internal struct ItemInstalled_t : ICallbackData + { + internal AppId AppID; // m_unAppID AppId_t + internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t + + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(ItemInstalled_t) ); + public int DataSize => _datasize; + public int CallbackId => 3405; + internal static ItemInstalled_t Fill( IntPtr p ) => ((ItemInstalled_t)Marshal.PtrToStructure( p, typeof(ItemInstalled_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 3405, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 3405, false ); actionClient = action; } } @@ -4173,12 +4623,12 @@ namespace Steamworks.Data { internal AppId AppID; // m_unAppID AppId_t internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(DownloadItemResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientUGC + 6; + public int CallbackId => 3406; internal static DownloadItemResult_t Fill( IntPtr p ) => ((DownloadItemResult_t)Marshal.PtrToStructure( p, typeof(DownloadItemResult_t) ) ); static Action actionClient; @@ -4189,12 +4639,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientUGC + 6, true ); + Event.Register( OnServer, _datasize, 3406, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientUGC + 6, false ); + Event.Register( OnClient, _datasize, 3406, false ); actionClient = action; } } @@ -4205,14 +4655,14 @@ namespace Steamworks.Data internal struct UserFavoriteItemsListChanged_t : ICallbackData { internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult [MarshalAs(UnmanagedType.I1)] - internal bool WasAddRequest; // m_bWasAddRequest _Bool + internal bool WasAddRequest; // m_bWasAddRequest bool #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(UserFavoriteItemsListChanged_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientUGC + 7; + public int CallbackId => 3407; internal static UserFavoriteItemsListChanged_t Fill( IntPtr p ) => ((UserFavoriteItemsListChanged_t)Marshal.PtrToStructure( p, typeof(UserFavoriteItemsListChanged_t) ) ); static Action actionClient; @@ -4223,12 +4673,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientUGC + 7, true ); + Event.Register( OnServer, _datasize, 3407, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientUGC + 7, false ); + Event.Register( OnClient, _datasize, 3407, false ); actionClient = action; } } @@ -4239,14 +4689,14 @@ namespace Steamworks.Data internal struct SetUserItemVoteResult_t : ICallbackData { internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult [MarshalAs(UnmanagedType.I1)] - internal bool VoteUp; // m_bVoteUp _Bool + internal bool VoteUp; // m_bVoteUp bool #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SetUserItemVoteResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientUGC + 8; + public int CallbackId => 3408; internal static SetUserItemVoteResult_t Fill( IntPtr p ) => ((SetUserItemVoteResult_t)Marshal.PtrToStructure( p, typeof(SetUserItemVoteResult_t) ) ); static Action actionClient; @@ -4257,12 +4707,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientUGC + 8, true ); + Event.Register( OnServer, _datasize, 3408, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientUGC + 8, false ); + Event.Register( OnClient, _datasize, 3408, false ); actionClient = action; } } @@ -4273,18 +4723,18 @@ namespace Steamworks.Data internal struct GetUserItemVoteResult_t : ICallbackData { internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult [MarshalAs(UnmanagedType.I1)] - internal bool VotedUp; // m_bVotedUp _Bool + internal bool VotedUp; // m_bVotedUp bool [MarshalAs(UnmanagedType.I1)] - internal bool VotedDown; // m_bVotedDown _Bool + internal bool VotedDown; // m_bVotedDown bool [MarshalAs(UnmanagedType.I1)] - internal bool VoteSkipped; // m_bVoteSkipped _Bool + internal bool VoteSkipped; // m_bVoteSkipped bool #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GetUserItemVoteResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientUGC + 9; + public int CallbackId => 3409; internal static GetUserItemVoteResult_t Fill( IntPtr p ) => ((GetUserItemVoteResult_t)Marshal.PtrToStructure( p, typeof(GetUserItemVoteResult_t) ) ); static Action actionClient; @@ -4295,12 +4745,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientUGC + 9, true ); + Event.Register( OnServer, _datasize, 3409, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientUGC + 9, false ); + Event.Register( OnClient, _datasize, 3409, false ); actionClient = action; } } @@ -4310,12 +4760,12 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct StartPlaytimeTrackingResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(StartPlaytimeTrackingResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientUGC + 10; + public int CallbackId => 3410; internal static StartPlaytimeTrackingResult_t Fill( IntPtr p ) => ((StartPlaytimeTrackingResult_t)Marshal.PtrToStructure( p, typeof(StartPlaytimeTrackingResult_t) ) ); static Action actionClient; @@ -4326,12 +4776,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientUGC + 10, true ); + Event.Register( OnServer, _datasize, 3410, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientUGC + 10, false ); + Event.Register( OnClient, _datasize, 3410, false ); actionClient = action; } } @@ -4341,12 +4791,12 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct StopPlaytimeTrackingResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(StopPlaytimeTrackingResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientUGC + 11; + public int CallbackId => 3411; internal static StopPlaytimeTrackingResult_t Fill( IntPtr p ) => ((StopPlaytimeTrackingResult_t)Marshal.PtrToStructure( p, typeof(StopPlaytimeTrackingResult_t) ) ); static Action actionClient; @@ -4357,12 +4807,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientUGC + 11, true ); + Event.Register( OnServer, _datasize, 3411, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientUGC + 11, false ); + Event.Register( OnClient, _datasize, 3411, false ); actionClient = action; } } @@ -4372,14 +4822,14 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct AddUGCDependencyResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t internal PublishedFileId ChildPublishedFileId; // m_nChildPublishedFileId PublishedFileId_t #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(AddUGCDependencyResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientUGC + 12; + public int CallbackId => 3412; internal static AddUGCDependencyResult_t Fill( IntPtr p ) => ((AddUGCDependencyResult_t)Marshal.PtrToStructure( p, typeof(AddUGCDependencyResult_t) ) ); static Action actionClient; @@ -4390,12 +4840,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientUGC + 12, true ); + Event.Register( OnServer, _datasize, 3412, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientUGC + 12, false ); + Event.Register( OnClient, _datasize, 3412, false ); actionClient = action; } } @@ -4405,14 +4855,14 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct RemoveUGCDependencyResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t internal PublishedFileId ChildPublishedFileId; // m_nChildPublishedFileId PublishedFileId_t #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoveUGCDependencyResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientUGC + 13; + public int CallbackId => 3413; internal static RemoveUGCDependencyResult_t Fill( IntPtr p ) => ((RemoveUGCDependencyResult_t)Marshal.PtrToStructure( p, typeof(RemoveUGCDependencyResult_t) ) ); static Action actionClient; @@ -4423,12 +4873,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientUGC + 13, true ); + Event.Register( OnServer, _datasize, 3413, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientUGC + 13, false ); + Event.Register( OnClient, _datasize, 3413, false ); actionClient = action; } } @@ -4438,14 +4888,14 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct AddAppDependencyResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t internal AppId AppID; // m_nAppID AppId_t #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(AddAppDependencyResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientUGC + 14; + public int CallbackId => 3414; internal static AddAppDependencyResult_t Fill( IntPtr p ) => ((AddAppDependencyResult_t)Marshal.PtrToStructure( p, typeof(AddAppDependencyResult_t) ) ); static Action actionClient; @@ -4456,12 +4906,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientUGC + 14, true ); + Event.Register( OnServer, _datasize, 3414, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientUGC + 14, false ); + Event.Register( OnClient, _datasize, 3414, false ); actionClient = action; } } @@ -4471,14 +4921,14 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct RemoveAppDependencyResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t internal AppId AppID; // m_nAppID AppId_t #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(RemoveAppDependencyResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientUGC + 15; + public int CallbackId => 3415; internal static RemoveAppDependencyResult_t Fill( IntPtr p ) => ((RemoveAppDependencyResult_t)Marshal.PtrToStructure( p, typeof(RemoveAppDependencyResult_t) ) ); static Action actionClient; @@ -4489,12 +4939,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientUGC + 15, true ); + Event.Register( OnServer, _datasize, 3415, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientUGC + 15, false ); + Event.Register( OnClient, _datasize, 3415, false ); actionClient = action; } } @@ -4504,7 +4954,7 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct GetAppDependenciesResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32, ArraySubType = UnmanagedType.U4)] internal AppId[] GAppIDs; // m_rgAppIDs AppId_t [32] @@ -4514,7 +4964,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GetAppDependenciesResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientUGC + 16; + public int CallbackId => 3416; internal static GetAppDependenciesResult_t Fill( IntPtr p ) => ((GetAppDependenciesResult_t)Marshal.PtrToStructure( p, typeof(GetAppDependenciesResult_t) ) ); static Action actionClient; @@ -4525,12 +4975,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientUGC + 16, true ); + Event.Register( OnServer, _datasize, 3416, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientUGC + 16, false ); + Event.Register( OnClient, _datasize, 3416, false ); actionClient = action; } } @@ -4540,13 +4990,13 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct DeleteItemResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(DeleteItemResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientUGC + 17; + public int CallbackId => 3417; internal static DeleteItemResult_t Fill( IntPtr p ) => ((DeleteItemResult_t)Marshal.PtrToStructure( p, typeof(DeleteItemResult_t) ) ); static Action actionClient; @@ -4557,12 +5007,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientUGC + 17, true ); + Event.Register( OnServer, _datasize, 3417, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientUGC + 17, false ); + Event.Register( OnClient, _datasize, 3417, false ); actionClient = action; } } @@ -4577,7 +5027,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SteamAppInstalled_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamAppList + 1; + public int CallbackId => 3901; internal static SteamAppInstalled_t Fill( IntPtr p ) => ((SteamAppInstalled_t)Marshal.PtrToStructure( p, typeof(SteamAppInstalled_t) ) ); static Action actionClient; @@ -4588,12 +5038,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamAppList + 1, true ); + Event.Register( OnServer, _datasize, 3901, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamAppList + 1, false ); + Event.Register( OnClient, _datasize, 3901, false ); actionClient = action; } } @@ -4608,7 +5058,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SteamAppUninstalled_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamAppList + 2; + public int CallbackId => 3902; internal static SteamAppUninstalled_t Fill( IntPtr p ) => ((SteamAppUninstalled_t)Marshal.PtrToStructure( p, typeof(SteamAppUninstalled_t) ) ); static Action actionClient; @@ -4619,12 +5069,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamAppList + 2, true ); + Event.Register( OnServer, _datasize, 3902, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamAppList + 2, false ); + Event.Register( OnClient, _datasize, 3902, false ); actionClient = action; } } @@ -4639,7 +5089,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(HTML_BrowserReady_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamHTMLSurface + 1; + public int CallbackId => 4501; internal static HTML_BrowserReady_t Fill( IntPtr p ) => ((HTML_BrowserReady_t)Marshal.PtrToStructure( p, typeof(HTML_BrowserReady_t) ) ); static Action actionClient; @@ -4650,12 +5100,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamHTMLSurface + 1, true ); + Event.Register( OnServer, _datasize, 4501, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamHTMLSurface + 1, false ); + Event.Register( OnClient, _datasize, 4501, false ); actionClient = action; } } @@ -4663,7 +5113,7 @@ namespace Steamworks.Data } [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct HTML_NeedsPaint_t + internal struct HTML_NeedsPaint_t : ICallbackData { internal uint UnBrowserHandle; // unBrowserHandle HHTMLBrowser internal string PBGRA; // pBGRA const char * @@ -4678,33 +5128,96 @@ namespace Steamworks.Data internal float FlPageScale; // flPageScale float internal uint UnPageSerial; // unPageSerial uint32 - #region Marshalling - internal static HTML_NeedsPaint_t Fill( IntPtr p ) => ((HTML_NeedsPaint_t)(HTML_NeedsPaint_t) Marshal.PtrToStructure( p, typeof(HTML_NeedsPaint_t) ) ); + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(HTML_NeedsPaint_t) ); + public int DataSize => _datasize; + public int CallbackId => 4502; + internal static HTML_NeedsPaint_t Fill( IntPtr p ) => ((HTML_NeedsPaint_t)Marshal.PtrToStructure( p, typeof(HTML_NeedsPaint_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 4502, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 4502, false ); + actionClient = action; + } + } #endregion } [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct HTML_StartRequest_t + internal struct HTML_StartRequest_t : ICallbackData { internal uint UnBrowserHandle; // unBrowserHandle HHTMLBrowser internal string PchURL; // pchURL const char * internal string PchTarget; // pchTarget const char * internal string PchPostData; // pchPostData const char * [MarshalAs(UnmanagedType.I1)] - internal bool BIsRedirect; // bIsRedirect _Bool + internal bool BIsRedirect; // bIsRedirect bool - #region Marshalling - internal static HTML_StartRequest_t Fill( IntPtr p ) => ((HTML_StartRequest_t)(HTML_StartRequest_t) Marshal.PtrToStructure( p, typeof(HTML_StartRequest_t) ) ); + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(HTML_StartRequest_t) ); + public int DataSize => _datasize; + public int CallbackId => 4503; + internal static HTML_StartRequest_t Fill( IntPtr p ) => ((HTML_StartRequest_t)Marshal.PtrToStructure( p, typeof(HTML_StartRequest_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 4503, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 4503, false ); + actionClient = action; + } + } #endregion } [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct HTML_CloseBrowser_t + internal struct HTML_CloseBrowser_t : ICallbackData { internal uint UnBrowserHandle; // unBrowserHandle HHTMLBrowser - #region Marshalling - internal static HTML_CloseBrowser_t Fill( IntPtr p ) => ((HTML_CloseBrowser_t)(HTML_CloseBrowser_t) Marshal.PtrToStructure( p, typeof(HTML_CloseBrowser_t) ) ); + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(HTML_CloseBrowser_t) ); + public int DataSize => _datasize; + public int CallbackId => 4504; + internal static HTML_CloseBrowser_t Fill( IntPtr p ) => ((HTML_CloseBrowser_t)Marshal.PtrToStructure( p, typeof(HTML_CloseBrowser_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 4504, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 4504, false ); + actionClient = action; + } + } #endregion } @@ -4715,15 +5228,15 @@ namespace Steamworks.Data internal string PchURL; // pchURL const char * internal string PchPostData; // pchPostData const char * [MarshalAs(UnmanagedType.I1)] - internal bool BIsRedirect; // bIsRedirect _Bool + internal bool BIsRedirect; // bIsRedirect bool internal string PchPageTitle; // pchPageTitle const char * [MarshalAs(UnmanagedType.I1)] - internal bool BNewNavigation; // bNewNavigation _Bool + internal bool BNewNavigation; // bNewNavigation bool #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(HTML_URLChanged_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamHTMLSurface + 5; + public int CallbackId => 4505; internal static HTML_URLChanged_t Fill( IntPtr p ) => ((HTML_URLChanged_t)Marshal.PtrToStructure( p, typeof(HTML_URLChanged_t) ) ); static Action actionClient; @@ -4734,12 +5247,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamHTMLSurface + 5, true ); + Event.Register( OnServer, _datasize, 4505, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamHTMLSurface + 5, false ); + Event.Register( OnClient, _datasize, 4505, false ); actionClient = action; } } @@ -4756,7 +5269,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(HTML_FinishedRequest_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamHTMLSurface + 6; + public int CallbackId => 4506; internal static HTML_FinishedRequest_t Fill( IntPtr p ) => ((HTML_FinishedRequest_t)Marshal.PtrToStructure( p, typeof(HTML_FinishedRequest_t) ) ); static Action actionClient; @@ -4767,12 +5280,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamHTMLSurface + 6, true ); + Event.Register( OnServer, _datasize, 4506, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamHTMLSurface + 6, false ); + Event.Register( OnClient, _datasize, 4506, false ); actionClient = action; } } @@ -4788,7 +5301,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(HTML_OpenLinkInNewTab_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamHTMLSurface + 7; + public int CallbackId => 4507; internal static HTML_OpenLinkInNewTab_t Fill( IntPtr p ) => ((HTML_OpenLinkInNewTab_t)Marshal.PtrToStructure( p, typeof(HTML_OpenLinkInNewTab_t) ) ); static Action actionClient; @@ -4799,12 +5312,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamHTMLSurface + 7, true ); + Event.Register( OnServer, _datasize, 4507, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamHTMLSurface + 7, false ); + Event.Register( OnClient, _datasize, 4507, false ); actionClient = action; } } @@ -4820,7 +5333,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(HTML_ChangedTitle_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamHTMLSurface + 8; + public int CallbackId => 4508; internal static HTML_ChangedTitle_t Fill( IntPtr p ) => ((HTML_ChangedTitle_t)Marshal.PtrToStructure( p, typeof(HTML_ChangedTitle_t) ) ); static Action actionClient; @@ -4831,12 +5344,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamHTMLSurface + 8, true ); + Event.Register( OnServer, _datasize, 4508, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamHTMLSurface + 8, false ); + Event.Register( OnClient, _datasize, 4508, false ); actionClient = action; } } @@ -4853,7 +5366,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(HTML_SearchResults_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamHTMLSurface + 9; + public int CallbackId => 4509; internal static HTML_SearchResults_t Fill( IntPtr p ) => ((HTML_SearchResults_t)Marshal.PtrToStructure( p, typeof(HTML_SearchResults_t) ) ); static Action actionClient; @@ -4864,12 +5377,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamHTMLSurface + 9, true ); + Event.Register( OnServer, _datasize, 4509, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamHTMLSurface + 9, false ); + Event.Register( OnClient, _datasize, 4509, false ); actionClient = action; } } @@ -4881,14 +5394,14 @@ namespace Steamworks.Data { internal uint UnBrowserHandle; // unBrowserHandle HHTMLBrowser [MarshalAs(UnmanagedType.I1)] - internal bool BCanGoBack; // bCanGoBack _Bool + internal bool BCanGoBack; // bCanGoBack bool [MarshalAs(UnmanagedType.I1)] - internal bool BCanGoForward; // bCanGoForward _Bool + internal bool BCanGoForward; // bCanGoForward bool #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(HTML_CanGoBackAndForward_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamHTMLSurface + 10; + public int CallbackId => 4510; internal static HTML_CanGoBackAndForward_t Fill( IntPtr p ) => ((HTML_CanGoBackAndForward_t)Marshal.PtrToStructure( p, typeof(HTML_CanGoBackAndForward_t) ) ); static Action actionClient; @@ -4899,12 +5412,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamHTMLSurface + 10, true ); + Event.Register( OnServer, _datasize, 4510, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamHTMLSurface + 10, false ); + Event.Register( OnClient, _datasize, 4510, false ); actionClient = action; } } @@ -4919,13 +5432,13 @@ namespace Steamworks.Data internal uint UnScrollCurrent; // unScrollCurrent uint32 internal float FlPageScale; // flPageScale float [MarshalAs(UnmanagedType.I1)] - internal bool BVisible; // bVisible _Bool + internal bool BVisible; // bVisible bool internal uint UnPageSize; // unPageSize uint32 #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(HTML_HorizontalScroll_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamHTMLSurface + 11; + public int CallbackId => 4511; internal static HTML_HorizontalScroll_t Fill( IntPtr p ) => ((HTML_HorizontalScroll_t)Marshal.PtrToStructure( p, typeof(HTML_HorizontalScroll_t) ) ); static Action actionClient; @@ -4936,12 +5449,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamHTMLSurface + 11, true ); + Event.Register( OnServer, _datasize, 4511, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamHTMLSurface + 11, false ); + Event.Register( OnClient, _datasize, 4511, false ); actionClient = action; } } @@ -4956,13 +5469,13 @@ namespace Steamworks.Data internal uint UnScrollCurrent; // unScrollCurrent uint32 internal float FlPageScale; // flPageScale float [MarshalAs(UnmanagedType.I1)] - internal bool BVisible; // bVisible _Bool + internal bool BVisible; // bVisible bool internal uint UnPageSize; // unPageSize uint32 #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(HTML_VerticalScroll_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamHTMLSurface + 12; + public int CallbackId => 4512; internal static HTML_VerticalScroll_t Fill( IntPtr p ) => ((HTML_VerticalScroll_t)Marshal.PtrToStructure( p, typeof(HTML_VerticalScroll_t) ) ); static Action actionClient; @@ -4973,12 +5486,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamHTMLSurface + 12, true ); + Event.Register( OnServer, _datasize, 4512, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamHTMLSurface + 12, false ); + Event.Register( OnClient, _datasize, 4512, false ); actionClient = action; } } @@ -4993,14 +5506,14 @@ namespace Steamworks.Data internal uint Y; // y uint32 internal string PchURL; // pchURL const char * [MarshalAs(UnmanagedType.I1)] - internal bool BInput; // bInput _Bool + internal bool BInput; // bInput bool [MarshalAs(UnmanagedType.I1)] - internal bool BLiveLink; // bLiveLink _Bool + internal bool BLiveLink; // bLiveLink bool #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(HTML_LinkAtPosition_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamHTMLSurface + 13; + public int CallbackId => 4513; internal static HTML_LinkAtPosition_t Fill( IntPtr p ) => ((HTML_LinkAtPosition_t)Marshal.PtrToStructure( p, typeof(HTML_LinkAtPosition_t) ) ); static Action actionClient; @@ -5011,12 +5524,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamHTMLSurface + 13, true ); + Event.Register( OnServer, _datasize, 4513, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamHTMLSurface + 13, false ); + Event.Register( OnClient, _datasize, 4513, false ); actionClient = action; } } @@ -5032,7 +5545,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(HTML_JSAlert_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamHTMLSurface + 14; + public int CallbackId => 4514; internal static HTML_JSAlert_t Fill( IntPtr p ) => ((HTML_JSAlert_t)Marshal.PtrToStructure( p, typeof(HTML_JSAlert_t) ) ); static Action actionClient; @@ -5043,12 +5556,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamHTMLSurface + 14, true ); + Event.Register( OnServer, _datasize, 4514, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamHTMLSurface + 14, false ); + Event.Register( OnClient, _datasize, 4514, false ); actionClient = action; } } @@ -5064,7 +5577,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(HTML_JSConfirm_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamHTMLSurface + 15; + public int CallbackId => 4515; internal static HTML_JSConfirm_t Fill( IntPtr p ) => ((HTML_JSConfirm_t)Marshal.PtrToStructure( p, typeof(HTML_JSConfirm_t) ) ); static Action actionClient; @@ -5075,12 +5588,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamHTMLSurface + 15, true ); + Event.Register( OnServer, _datasize, 4515, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamHTMLSurface + 15, false ); + Event.Register( OnClient, _datasize, 4515, false ); actionClient = action; } } @@ -5097,7 +5610,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(HTML_FileOpenDialog_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamHTMLSurface + 16; + public int CallbackId => 4516; internal static HTML_FileOpenDialog_t Fill( IntPtr p ) => ((HTML_FileOpenDialog_t)Marshal.PtrToStructure( p, typeof(HTML_FileOpenDialog_t) ) ); static Action actionClient; @@ -5108,12 +5621,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamHTMLSurface + 16, true ); + Event.Register( OnServer, _datasize, 4516, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamHTMLSurface + 16, false ); + Event.Register( OnClient, _datasize, 4516, false ); actionClient = action; } } @@ -5134,7 +5647,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(HTML_NewWindow_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamHTMLSurface + 21; + public int CallbackId => 4521; internal static HTML_NewWindow_t Fill( IntPtr p ) => ((HTML_NewWindow_t)Marshal.PtrToStructure( p, typeof(HTML_NewWindow_t) ) ); static Action actionClient; @@ -5145,12 +5658,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamHTMLSurface + 21, true ); + Event.Register( OnServer, _datasize, 4521, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamHTMLSurface + 21, false ); + Event.Register( OnClient, _datasize, 4521, false ); actionClient = action; } } @@ -5166,7 +5679,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(HTML_SetCursor_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamHTMLSurface + 22; + public int CallbackId => 4522; internal static HTML_SetCursor_t Fill( IntPtr p ) => ((HTML_SetCursor_t)Marshal.PtrToStructure( p, typeof(HTML_SetCursor_t) ) ); static Action actionClient; @@ -5177,12 +5690,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamHTMLSurface + 22, true ); + Event.Register( OnServer, _datasize, 4522, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamHTMLSurface + 22, false ); + Event.Register( OnClient, _datasize, 4522, false ); actionClient = action; } } @@ -5198,7 +5711,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(HTML_StatusText_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamHTMLSurface + 23; + public int CallbackId => 4523; internal static HTML_StatusText_t Fill( IntPtr p ) => ((HTML_StatusText_t)Marshal.PtrToStructure( p, typeof(HTML_StatusText_t) ) ); static Action actionClient; @@ -5209,12 +5722,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamHTMLSurface + 23, true ); + Event.Register( OnServer, _datasize, 4523, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamHTMLSurface + 23, false ); + Event.Register( OnClient, _datasize, 4523, false ); actionClient = action; } } @@ -5230,7 +5743,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(HTML_ShowToolTip_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamHTMLSurface + 24; + public int CallbackId => 4524; internal static HTML_ShowToolTip_t Fill( IntPtr p ) => ((HTML_ShowToolTip_t)Marshal.PtrToStructure( p, typeof(HTML_ShowToolTip_t) ) ); static Action actionClient; @@ -5241,12 +5754,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamHTMLSurface + 24, true ); + Event.Register( OnServer, _datasize, 4524, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamHTMLSurface + 24, false ); + Event.Register( OnClient, _datasize, 4524, false ); actionClient = action; } } @@ -5262,7 +5775,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(HTML_UpdateToolTip_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamHTMLSurface + 25; + public int CallbackId => 4525; internal static HTML_UpdateToolTip_t Fill( IntPtr p ) => ((HTML_UpdateToolTip_t)Marshal.PtrToStructure( p, typeof(HTML_UpdateToolTip_t) ) ); static Action actionClient; @@ -5273,12 +5786,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamHTMLSurface + 25, true ); + Event.Register( OnServer, _datasize, 4525, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamHTMLSurface + 25, false ); + Event.Register( OnClient, _datasize, 4525, false ); actionClient = action; } } @@ -5293,7 +5806,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(HTML_HideToolTip_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamHTMLSurface + 26; + public int CallbackId => 4526; internal static HTML_HideToolTip_t Fill( IntPtr p ) => ((HTML_HideToolTip_t)Marshal.PtrToStructure( p, typeof(HTML_HideToolTip_t) ) ); static Action actionClient; @@ -5304,12 +5817,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamHTMLSurface + 26, true ); + Event.Register( OnServer, _datasize, 4526, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamHTMLSurface + 26, false ); + Event.Register( OnClient, _datasize, 4526, false ); actionClient = action; } } @@ -5325,7 +5838,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(HTML_BrowserRestarted_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamHTMLSurface + 27; + public int CallbackId => 4527; internal static HTML_BrowserRestarted_t Fill( IntPtr p ) => ((HTML_BrowserRestarted_t)Marshal.PtrToStructure( p, typeof(HTML_BrowserRestarted_t) ) ); static Action actionClient; @@ -5336,41 +5849,28 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamHTMLSurface + 27, true ); + Event.Register( OnServer, _datasize, 4527, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamHTMLSurface + 27, false ); + Event.Register( OnClient, _datasize, 4527, false ); actionClient = action; } } #endregion } - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct SteamItemDetails_t - { - internal InventoryItemId ItemId; // m_itemId SteamItemInstanceID_t - internal InventoryDefId Definition; // m_iDefinition SteamItemDef_t - internal ushort Quantity; // m_unQuantity uint16 - internal ushort Flags; // m_unFlags uint16 - - #region Marshalling - internal static SteamItemDetails_t Fill( IntPtr p ) => ((SteamItemDetails_t)(SteamItemDetails_t) Marshal.PtrToStructure( p, typeof(SteamItemDetails_t) ) ); - #endregion - } - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct SteamInventoryResultReady_t : ICallbackData { internal int Handle; // m_handle SteamInventoryResult_t - internal Result Result; // m_result enum EResult + internal Result Result; // m_result EResult #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SteamInventoryResultReady_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientInventory + 0; + public int CallbackId => 4700; internal static SteamInventoryResultReady_t Fill( IntPtr p ) => ((SteamInventoryResultReady_t)Marshal.PtrToStructure( p, typeof(SteamInventoryResultReady_t) ) ); static Action actionClient; @@ -5381,12 +5881,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientInventory + 0, true ); + Event.Register( OnServer, _datasize, 4700, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientInventory + 0, false ); + Event.Register( OnClient, _datasize, 4700, false ); actionClient = action; } } @@ -5401,7 +5901,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SteamInventoryFullUpdate_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientInventory + 1; + public int CallbackId => 4701; internal static SteamInventoryFullUpdate_t Fill( IntPtr p ) => ((SteamInventoryFullUpdate_t)Marshal.PtrToStructure( p, typeof(SteamInventoryFullUpdate_t) ) ); static Action actionClient; @@ -5412,12 +5912,42 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientInventory + 1, true ); + Event.Register( OnServer, _datasize, 4701, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientInventory + 1, false ); + Event.Register( OnClient, _datasize, 4701, false ); + actionClient = action; + } + } + #endregion + } + + [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] + internal struct SteamInventoryDefinitionUpdate_t : ICallbackData + { + + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SteamInventoryDefinitionUpdate_t) ); + public int DataSize => _datasize; + public int CallbackId => 4702; + internal static SteamInventoryDefinitionUpdate_t Fill( IntPtr p ) => ((SteamInventoryDefinitionUpdate_t)Marshal.PtrToStructure( p, typeof(SteamInventoryDefinitionUpdate_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 4702, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 4702, false ); actionClient = action; } } @@ -5427,16 +5957,16 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct SteamInventoryEligiblePromoItemDefIDs_t : ICallbackData { - internal Result Result; // m_result enum EResult - internal ulong SteamID; // m_steamID class CSteamID + internal Result Result; // m_result EResult + internal ulong SteamID; // m_steamID CSteamID internal int UmEligiblePromoItemDefs; // m_numEligiblePromoItemDefs int [MarshalAs(UnmanagedType.I1)] - internal bool CachedData; // m_bCachedData _Bool + internal bool CachedData; // m_bCachedData bool #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SteamInventoryEligiblePromoItemDefIDs_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientInventory + 3; + public int CallbackId => 4703; internal static SteamInventoryEligiblePromoItemDefIDs_t Fill( IntPtr p ) => ((SteamInventoryEligiblePromoItemDefIDs_t)Marshal.PtrToStructure( p, typeof(SteamInventoryEligiblePromoItemDefIDs_t) ) ); static Action actionClient; @@ -5447,12 +5977,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientInventory + 3, true ); + Event.Register( OnServer, _datasize, 4703, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientInventory + 3, false ); + Event.Register( OnClient, _datasize, 4703, false ); actionClient = action; } } @@ -5462,14 +5992,14 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct SteamInventoryStartPurchaseResult_t : ICallbackData { - internal Result Result; // m_result enum EResult + internal Result Result; // m_result EResult internal ulong OrderID; // m_ulOrderID uint64 internal ulong TransID; // m_ulTransID uint64 #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SteamInventoryStartPurchaseResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientInventory + 4; + public int CallbackId => 4704; internal static SteamInventoryStartPurchaseResult_t Fill( IntPtr p ) => ((SteamInventoryStartPurchaseResult_t)Marshal.PtrToStructure( p, typeof(SteamInventoryStartPurchaseResult_t) ) ); static Action actionClient; @@ -5480,12 +6010,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientInventory + 4, true ); + Event.Register( OnServer, _datasize, 4704, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientInventory + 4, false ); + Event.Register( OnClient, _datasize, 4704, false ); actionClient = action; } } @@ -5495,7 +6025,7 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct SteamInventoryRequestPricesResult_t : ICallbackData { - internal Result Result; // m_result enum EResult + internal Result Result; // m_result EResult internal string CurrencyUTF8() => System.Text.Encoding.UTF8.GetString( Currency, 0, System.Array.IndexOf( Currency, 0 ) ); [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] // byte[] m_rgchCurrency internal byte[] Currency; // m_rgchCurrency char [4] @@ -5503,7 +6033,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SteamInventoryRequestPricesResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientInventory + 5; + public int CallbackId => 4705; internal static SteamInventoryRequestPricesResult_t Fill( IntPtr p ) => ((SteamInventoryRequestPricesResult_t)Marshal.PtrToStructure( p, typeof(SteamInventoryRequestPricesResult_t) ) ); static Action actionClient; @@ -5514,43 +6044,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientInventory + 5, true ); + Event.Register( OnServer, _datasize, 4705, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientInventory + 5, false ); - actionClient = action; - } - } - #endregion - } - - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct BroadcastUploadStop_t : ICallbackData - { - internal BroadcastUploadResult Result; // m_eResult enum EBroadcastUploadResult - - #region SteamCallback - public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(BroadcastUploadStop_t) ); - public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientVideo + 5; - internal static BroadcastUploadStop_t Fill( IntPtr p ) => ((BroadcastUploadStop_t)Marshal.PtrToStructure( p, typeof(BroadcastUploadStop_t) ) ); - - static Action actionClient; - [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); - static Action actionServer; - [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); - public static void Install( Action action, bool server = false ) - { - if ( server ) - { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientVideo + 5, true ); - actionServer = action; - } - else - { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientVideo + 5, false ); + Event.Register( OnClient, _datasize, 4705, false ); actionClient = action; } } @@ -5560,7 +6059,7 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct GetVideoURLResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal AppId VideoAppID; // m_unVideoAppID AppId_t internal string URLUTF8() => System.Text.Encoding.UTF8.GetString( URL, 0, System.Array.IndexOf( URL, 0 ) ); [MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)] // byte[] m_rgchURL @@ -5569,7 +6068,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GetVideoURLResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientVideo + 11; + public int CallbackId => 4611; internal static GetVideoURLResult_t Fill( IntPtr p ) => ((GetVideoURLResult_t)Marshal.PtrToStructure( p, typeof(GetVideoURLResult_t) ) ); static Action actionClient; @@ -5580,12 +6079,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientVideo + 11, true ); + Event.Register( OnServer, _datasize, 4611, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientVideo + 11, false ); + Event.Register( OnClient, _datasize, 4611, false ); actionClient = action; } } @@ -5595,13 +6094,13 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct GetOPFSettingsResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal AppId VideoAppID; // m_unVideoAppID AppId_t #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GetOPFSettingsResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientVideo + 24; + public int CallbackId => 4624; internal static GetOPFSettingsResult_t Fill( IntPtr p ) => ((GetOPFSettingsResult_t)Marshal.PtrToStructure( p, typeof(GetOPFSettingsResult_t) ) ); static Action actionClient; @@ -5612,12 +6111,204 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientVideo + 24, true ); + Event.Register( OnServer, _datasize, 4624, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientVideo + 24, false ); + Event.Register( OnClient, _datasize, 4624, false ); + actionClient = action; + } + } + #endregion + } + + [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] + internal struct BroadcastUploadStart_t : ICallbackData + { + [MarshalAs(UnmanagedType.I1)] + internal bool IsRTMP; // m_bIsRTMP bool + + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(BroadcastUploadStart_t) ); + public int DataSize => _datasize; + public int CallbackId => 4604; + internal static BroadcastUploadStart_t Fill( IntPtr p ) => ((BroadcastUploadStart_t)Marshal.PtrToStructure( p, typeof(BroadcastUploadStart_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 4604, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 4604, false ); + actionClient = action; + } + } + #endregion + } + + [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] + internal struct BroadcastUploadStop_t : ICallbackData + { + internal BroadcastUploadResult Result; // m_eResult EBroadcastUploadResult + + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(BroadcastUploadStop_t) ); + public int DataSize => _datasize; + public int CallbackId => 4605; + internal static BroadcastUploadStop_t Fill( IntPtr p ) => ((BroadcastUploadStop_t)Marshal.PtrToStructure( p, typeof(BroadcastUploadStop_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 4605, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 4605, false ); + actionClient = action; + } + } + #endregion + } + + [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] + internal struct SteamParentalSettingsChanged_t : ICallbackData + { + + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SteamParentalSettingsChanged_t) ); + public int DataSize => _datasize; + public int CallbackId => 5001; + internal static SteamParentalSettingsChanged_t Fill( IntPtr p ) => ((SteamParentalSettingsChanged_t)Marshal.PtrToStructure( p, typeof(SteamParentalSettingsChanged_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 5001, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 5001, false ); + actionClient = action; + } + } + #endregion + } + + [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] + internal struct SteamRemotePlaySessionConnected_t : ICallbackData + { + internal uint SessionID; // m_unSessionID RemotePlaySessionID_t + + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SteamRemotePlaySessionConnected_t) ); + public int DataSize => _datasize; + public int CallbackId => 5701; + internal static SteamRemotePlaySessionConnected_t Fill( IntPtr p ) => ((SteamRemotePlaySessionConnected_t)Marshal.PtrToStructure( p, typeof(SteamRemotePlaySessionConnected_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 5701, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 5701, false ); + actionClient = action; + } + } + #endregion + } + + [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] + internal struct SteamRemotePlaySessionDisconnected_t : ICallbackData + { + internal uint SessionID; // m_unSessionID RemotePlaySessionID_t + + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SteamRemotePlaySessionDisconnected_t) ); + public int DataSize => _datasize; + public int CallbackId => 5702; + internal static SteamRemotePlaySessionDisconnected_t Fill( IntPtr p ) => ((SteamRemotePlaySessionDisconnected_t)Marshal.PtrToStructure( p, typeof(SteamRemotePlaySessionDisconnected_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 5702, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 5702, false ); + actionClient = action; + } + } + #endregion + } + + [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] + internal struct SteamRelayNetworkStatus_t : ICallbackData + { + internal SteamNetworkingAvailability Avail; // m_eAvail ESteamNetworkingAvailability + internal int PingMeasurementInProgress; // m_bPingMeasurementInProgress int + internal SteamNetworkingAvailability AvailNetworkConfig; // m_eAvailNetworkConfig ESteamNetworkingAvailability + internal SteamNetworkingAvailability AvailAnyRelay; // m_eAvailAnyRelay ESteamNetworkingAvailability + internal string DebugMsgUTF8() => System.Text.Encoding.UTF8.GetString( DebugMsg, 0, System.Array.IndexOf( DebugMsg, 0 ) ); + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)] // byte[] m_debugMsg + internal byte[] DebugMsg; // m_debugMsg char [256] + + #region SteamCallback + public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SteamRelayNetworkStatus_t) ); + public int DataSize => _datasize; + public int CallbackId => 1281; + internal static SteamRelayNetworkStatus_t Fill( IntPtr p ) => ((SteamRelayNetworkStatus_t)Marshal.PtrToStructure( p, typeof(SteamRelayNetworkStatus_t) ) ); + + static Action actionClient; + [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); + static Action actionServer; + [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); + public static void Install( Action action, bool server = false ) + { + if ( server ) + { + Event.Register( OnServer, _datasize, 1281, true ); + actionServer = action; + } + else + { + Event.Register( OnClient, _datasize, 1281, false ); actionClient = action; } } @@ -5627,13 +6318,13 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct GSClientApprove_t : ICallbackData { - internal ulong SteamID; // m_SteamID class CSteamID - internal ulong OwnerSteamID; // m_OwnerSteamID class CSteamID + internal ulong SteamID; // m_SteamID CSteamID + internal ulong OwnerSteamID; // m_OwnerSteamID CSteamID #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GSClientApprove_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamGameServer + 1; + public int CallbackId => 201; internal static GSClientApprove_t Fill( IntPtr p ) => ((GSClientApprove_t)Marshal.PtrToStructure( p, typeof(GSClientApprove_t) ) ); static Action actionClient; @@ -5644,12 +6335,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamGameServer + 1, true ); + Event.Register( OnServer, _datasize, 201, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamGameServer + 1, false ); + Event.Register( OnClient, _datasize, 201, false ); actionClient = action; } } @@ -5659,8 +6350,8 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct GSClientDeny_t : ICallbackData { - internal ulong SteamID; // m_SteamID class CSteamID - internal DenyReason DenyReason; // m_eDenyReason enum EDenyReason + internal ulong SteamID; // m_SteamID CSteamID + internal DenyReason DenyReason; // m_eDenyReason EDenyReason internal string OptionalTextUTF8() => System.Text.Encoding.UTF8.GetString( OptionalText, 0, System.Array.IndexOf( OptionalText, 0 ) ); [MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)] // byte[] m_rgchOptionalText internal byte[] OptionalText; // m_rgchOptionalText char [128] @@ -5668,7 +6359,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GSClientDeny_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamGameServer + 2; + public int CallbackId => 202; internal static GSClientDeny_t Fill( IntPtr p ) => ((GSClientDeny_t)Marshal.PtrToStructure( p, typeof(GSClientDeny_t) ) ); static Action actionClient; @@ -5679,12 +6370,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamGameServer + 2, true ); + Event.Register( OnServer, _datasize, 202, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamGameServer + 2, false ); + Event.Register( OnClient, _datasize, 202, false ); actionClient = action; } } @@ -5694,13 +6385,13 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct GSClientKick_t : ICallbackData { - internal ulong SteamID; // m_SteamID class CSteamID - internal DenyReason DenyReason; // m_eDenyReason enum EDenyReason + internal ulong SteamID; // m_SteamID CSteamID + internal DenyReason DenyReason; // m_eDenyReason EDenyReason #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GSClientKick_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamGameServer + 3; + public int CallbackId => 203; internal static GSClientKick_t Fill( IntPtr p ) => ((GSClientKick_t)Marshal.PtrToStructure( p, typeof(GSClientKick_t) ) ); static Action actionClient; @@ -5711,12 +6402,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamGameServer + 3, true ); + Event.Register( OnServer, _datasize, 203, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamGameServer + 3, false ); + Event.Register( OnClient, _datasize, 203, false ); actionClient = action; } } @@ -5731,12 +6422,12 @@ namespace Steamworks.Data [MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)] // byte[] m_pchAchievement internal byte[] PchAchievement; // m_pchAchievement char [128] [MarshalAs(UnmanagedType.I1)] - internal bool Unlocked; // m_bUnlocked _Bool + internal bool Unlocked; // m_bUnlocked bool #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GSClientAchievementStatus_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamGameServer + 6; + public int CallbackId => 206; internal static GSClientAchievementStatus_t Fill( IntPtr p ) => ((GSClientAchievementStatus_t)Marshal.PtrToStructure( p, typeof(GSClientAchievementStatus_t) ) ); static Action actionClient; @@ -5747,12 +6438,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamGameServer + 6, true ); + Event.Register( OnServer, _datasize, 206, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamGameServer + 6, false ); + Event.Register( OnClient, _datasize, 206, false ); actionClient = action; } } @@ -5767,7 +6458,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GSPolicyResponse_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUser + 15; + public int CallbackId => 115; internal static GSPolicyResponse_t Fill( IntPtr p ) => ((GSPolicyResponse_t)Marshal.PtrToStructure( p, typeof(GSPolicyResponse_t) ) ); static Action actionClient; @@ -5778,12 +6469,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUser + 15, true ); + Event.Register( OnServer, _datasize, 115, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUser + 15, false ); + Event.Register( OnClient, _datasize, 115, false ); actionClient = action; } } @@ -5793,7 +6484,7 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct GSGameplayStats_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal int Rank; // m_nRank int32 internal uint TotalConnects; // m_unTotalConnects uint32 internal uint TotalMinutesPlayed; // m_unTotalMinutesPlayed uint32 @@ -5801,7 +6492,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GSGameplayStats_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamGameServer + 7; + public int CallbackId => 207; internal static GSGameplayStats_t Fill( IntPtr p ) => ((GSGameplayStats_t)Marshal.PtrToStructure( p, typeof(GSGameplayStats_t) ) ); static Action actionClient; @@ -5812,12 +6503,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamGameServer + 7, true ); + Event.Register( OnServer, _datasize, 207, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamGameServer + 7, false ); + Event.Register( OnClient, _datasize, 207, false ); actionClient = action; } } @@ -5827,17 +6518,17 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct GSClientGroupStatus_t : ICallbackData { - internal ulong SteamIDUser; // m_SteamIDUser class CSteamID - internal ulong SteamIDGroup; // m_SteamIDGroup class CSteamID + internal ulong SteamIDUser; // m_SteamIDUser CSteamID + internal ulong SteamIDGroup; // m_SteamIDGroup CSteamID [MarshalAs(UnmanagedType.I1)] - internal bool Member; // m_bMember _Bool + internal bool Member; // m_bMember bool [MarshalAs(UnmanagedType.I1)] - internal bool Officer; // m_bOfficer _Bool + internal bool Officer; // m_bOfficer bool #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GSClientGroupStatus_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamGameServer + 8; + public int CallbackId => 208; internal static GSClientGroupStatus_t Fill( IntPtr p ) => ((GSClientGroupStatus_t)Marshal.PtrToStructure( p, typeof(GSClientGroupStatus_t) ) ); static Action actionClient; @@ -5848,12 +6539,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamGameServer + 8, true ); + Event.Register( OnServer, _datasize, 208, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamGameServer + 8, false ); + Event.Register( OnClient, _datasize, 208, false ); actionClient = action; } } @@ -5863,10 +6554,10 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct GSReputation_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal uint ReputationScore; // m_unReputationScore uint32 [MarshalAs(UnmanagedType.I1)] - internal bool Banned; // m_bBanned _Bool + internal bool Banned; // m_bBanned bool internal uint BannedIP; // m_unBannedIP uint32 internal ushort BannedPort; // m_usBannedPort uint16 internal ulong BannedGameID; // m_ulBannedGameID uint64 @@ -5875,7 +6566,7 @@ namespace Steamworks.Data #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GSReputation_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamGameServer + 9; + public int CallbackId => 209; internal static GSReputation_t Fill( IntPtr p ) => ((GSReputation_t)Marshal.PtrToStructure( p, typeof(GSReputation_t) ) ); static Action actionClient; @@ -5886,12 +6577,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamGameServer + 9, true ); + Event.Register( OnServer, _datasize, 209, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamGameServer + 9, false ); + Event.Register( OnClient, _datasize, 209, false ); actionClient = action; } } @@ -5901,12 +6592,12 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] internal struct AssociateWithClanResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(AssociateWithClanResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamGameServer + 10; + public int CallbackId => 210; internal static AssociateWithClanResult_t Fill( IntPtr p ) => ((AssociateWithClanResult_t)Marshal.PtrToStructure( p, typeof(AssociateWithClanResult_t) ) ); static Action actionClient; @@ -5917,12 +6608,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamGameServer + 10, true ); + Event.Register( OnServer, _datasize, 210, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamGameServer + 10, false ); + Event.Register( OnClient, _datasize, 210, false ); actionClient = action; } } @@ -5932,16 +6623,16 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct ComputeNewPlayerCompatibilityResult_t : ICallbackData { - internal Result Result; // m_eResult enum EResult + internal Result Result; // m_eResult EResult internal int CPlayersThatDontLikeCandidate; // m_cPlayersThatDontLikeCandidate int internal int CPlayersThatCandidateDoesntLike; // m_cPlayersThatCandidateDoesntLike int internal int CClanPlayersThatDontLikeCandidate; // m_cClanPlayersThatDontLikeCandidate int - internal ulong SteamIDCandidate; // m_SteamIDCandidate class CSteamID + internal ulong SteamIDCandidate; // m_SteamIDCandidate CSteamID #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(ComputeNewPlayerCompatibilityResult_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamGameServer + 11; + public int CallbackId => 211; internal static ComputeNewPlayerCompatibilityResult_t Fill( IntPtr p ) => ((ComputeNewPlayerCompatibilityResult_t)Marshal.PtrToStructure( p, typeof(ComputeNewPlayerCompatibilityResult_t) ) ); static Action actionClient; @@ -5952,12 +6643,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamGameServer + 11, true ); + Event.Register( OnServer, _datasize, 211, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamGameServer + 11, false ); + Event.Register( OnClient, _datasize, 211, false ); actionClient = action; } } @@ -5967,13 +6658,13 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct GSStatsReceived_t : ICallbackData { - internal Result Result; // m_eResult enum EResult - internal ulong SteamIDUser; // m_steamIDUser class CSteamID + internal Result Result; // m_eResult EResult + internal ulong SteamIDUser; // m_steamIDUser CSteamID #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GSStatsReceived_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamGameServerStats + 0; + public int CallbackId => 1800; internal static GSStatsReceived_t Fill( IntPtr p ) => ((GSStatsReceived_t)Marshal.PtrToStructure( p, typeof(GSStatsReceived_t) ) ); static Action actionClient; @@ -5984,12 +6675,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamGameServerStats + 0, true ); + Event.Register( OnServer, _datasize, 1800, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamGameServerStats + 0, false ); + Event.Register( OnClient, _datasize, 1800, false ); actionClient = action; } } @@ -5999,13 +6690,13 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct GSStatsStored_t : ICallbackData { - internal Result Result; // m_eResult enum EResult - internal ulong SteamIDUser; // m_steamIDUser class CSteamID + internal Result Result; // m_eResult EResult + internal ulong SteamIDUser; // m_steamIDUser CSteamID #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GSStatsStored_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamGameServerStats + 1; + public int CallbackId => 1801; internal static GSStatsStored_t Fill( IntPtr p ) => ((GSStatsStored_t)Marshal.PtrToStructure( p, typeof(GSStatsStored_t) ) ); static Action actionClient; @@ -6016,12 +6707,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamGameServerStats + 1, true ); + Event.Register( OnServer, _datasize, 1801, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamGameServerStats + 1, false ); + Event.Register( OnClient, _datasize, 1801, false ); actionClient = action; } } @@ -6031,12 +6722,12 @@ namespace Steamworks.Data [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPackSize )] internal struct GSStatsUnloaded_t : ICallbackData { - internal ulong SteamIDUser; // m_steamIDUser class CSteamID + internal ulong SteamIDUser; // m_steamIDUser CSteamID #region SteamCallback public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GSStatsUnloaded_t) ); public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUserStats + 8; + public int CallbackId => 1108; internal static GSStatsUnloaded_t Fill( IntPtr p ) => ((GSStatsUnloaded_t)Marshal.PtrToStructure( p, typeof(GSStatsUnloaded_t) ) ); static Action actionClient; @@ -6047,538 +6738,12 @@ namespace Steamworks.Data { if ( server ) { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUserStats + 8, true ); + Event.Register( OnServer, _datasize, 1108, true ); actionServer = action; } else { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUserStats + 8, false ); - actionClient = action; - } - } - #endregion - } - - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct AvailableBeaconLocationsUpdated_t : ICallbackData - { - - #region SteamCallback - public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(AvailableBeaconLocationsUpdated_t) ); - public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamParties + 5; - internal static AvailableBeaconLocationsUpdated_t Fill( IntPtr p ) => ((AvailableBeaconLocationsUpdated_t)Marshal.PtrToStructure( p, typeof(AvailableBeaconLocationsUpdated_t) ) ); - - static Action actionClient; - [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); - static Action actionServer; - [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); - public static void Install( Action action, bool server = false ) - { - if ( server ) - { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamParties + 5, true ); - actionServer = action; - } - else - { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamParties + 5, false ); - actionClient = action; - } - } - #endregion - } - - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct ActiveBeaconsUpdated_t : ICallbackData - { - - #region SteamCallback - public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(ActiveBeaconsUpdated_t) ); - public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamParties + 6; - internal static ActiveBeaconsUpdated_t Fill( IntPtr p ) => ((ActiveBeaconsUpdated_t)Marshal.PtrToStructure( p, typeof(ActiveBeaconsUpdated_t) ) ); - - static Action actionClient; - [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); - static Action actionServer; - [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); - public static void Install( Action action, bool server = false ) - { - if ( server ) - { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamParties + 6, true ); - actionServer = action; - } - else - { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamParties + 6, false ); - actionClient = action; - } - } - #endregion - } - - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct PlaybackStatusHasChanged_t : ICallbackData - { - - #region SteamCallback - public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(PlaybackStatusHasChanged_t) ); - public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamMusic + 1; - internal static PlaybackStatusHasChanged_t Fill( IntPtr p ) => ((PlaybackStatusHasChanged_t)Marshal.PtrToStructure( p, typeof(PlaybackStatusHasChanged_t) ) ); - - static Action actionClient; - [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); - static Action actionServer; - [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); - public static void Install( Action action, bool server = false ) - { - if ( server ) - { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamMusic + 1, true ); - actionServer = action; - } - else - { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamMusic + 1, false ); - actionClient = action; - } - } - #endregion - } - - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct BroadcastUploadStart_t : ICallbackData - { - - #region SteamCallback - public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(BroadcastUploadStart_t) ); - public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientVideo + 4; - internal static BroadcastUploadStart_t Fill( IntPtr p ) => ((BroadcastUploadStart_t)Marshal.PtrToStructure( p, typeof(BroadcastUploadStart_t) ) ); - - static Action actionClient; - [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); - static Action actionServer; - [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); - public static void Install( Action action, bool server = false ) - { - if ( server ) - { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientVideo + 4, true ); - actionServer = action; - } - else - { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientVideo + 4, false ); - actionClient = action; - } - } - #endregion - } - - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct NewUrlLaunchParameters_t : ICallbackData - { - - #region SteamCallback - public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(NewUrlLaunchParameters_t) ); - public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamApps + 14; - internal static NewUrlLaunchParameters_t Fill( IntPtr p ) => ((NewUrlLaunchParameters_t)Marshal.PtrToStructure( p, typeof(NewUrlLaunchParameters_t) ) ); - - static Action actionClient; - [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); - static Action actionServer; - [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); - public static void Install( Action action, bool server = false ) - { - if ( server ) - { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamApps + 14, true ); - actionServer = action; - } - else - { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamApps + 14, false ); - actionClient = action; - } - } - #endregion - } - - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct ItemInstalled_t : ICallbackData - { - internal AppId AppID; // m_unAppID AppId_t - internal PublishedFileId PublishedFileId; // m_nPublishedFileId PublishedFileId_t - - #region SteamCallback - public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(ItemInstalled_t) ); - public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientUGC + 5; - internal static ItemInstalled_t Fill( IntPtr p ) => ((ItemInstalled_t)Marshal.PtrToStructure( p, typeof(ItemInstalled_t) ) ); - - static Action actionClient; - [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); - static Action actionServer; - [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); - public static void Install( Action action, bool server = false ) - { - if ( server ) - { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientUGC + 5, true ); - actionServer = action; - } - else - { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientUGC + 5, false ); - actionClient = action; - } - } - #endregion - } - - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct SteamNetConnectionStatusChangedCallback_t : ICallbackData - { - internal Connection Conn; // m_hConn HSteamNetConnection - internal ConnectionInfo Nfo; // m_info SteamNetConnectionInfo_t - internal ConnectionState OldState; // m_eOldState ESteamNetworkingConnectionState - - #region SteamCallback - public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SteamNetConnectionStatusChangedCallback_t) ); - public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamNetworkingSockets + 1; - internal static SteamNetConnectionStatusChangedCallback_t Fill( IntPtr p ) => ((SteamNetConnectionStatusChangedCallback_t)Marshal.PtrToStructure( p, typeof(SteamNetConnectionStatusChangedCallback_t) ) ); - - static Action actionClient; - [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); - static Action actionServer; - [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); - public static void Install( Action action, bool server = false ) - { - if ( server ) - { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamNetworkingSockets + 1, true ); - actionServer = action; - } - else - { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamNetworkingSockets + 1, false ); - actionClient = action; - } - } - #endregion - } - - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct SteamInventoryDefinitionUpdate_t : ICallbackData - { - - #region SteamCallback - public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SteamInventoryDefinitionUpdate_t) ); - public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.ClientInventory + 2; - internal static SteamInventoryDefinitionUpdate_t Fill( IntPtr p ) => ((SteamInventoryDefinitionUpdate_t)Marshal.PtrToStructure( p, typeof(SteamInventoryDefinitionUpdate_t) ) ); - - static Action actionClient; - [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); - static Action actionServer; - [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); - public static void Install( Action action, bool server = false ) - { - if ( server ) - { - Event.Register( OnServer, _datasize, CallbackIdentifiers.ClientInventory + 2, true ); - actionServer = action; - } - else - { - Event.Register( OnClient, _datasize, CallbackIdentifiers.ClientInventory + 2, false ); - actionClient = action; - } - } - #endregion - } - - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct SteamParentalSettingsChanged_t : ICallbackData - { - - #region SteamCallback - public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SteamParentalSettingsChanged_t) ); - public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamParentalSettings + 1; - internal static SteamParentalSettingsChanged_t Fill( IntPtr p ) => ((SteamParentalSettingsChanged_t)Marshal.PtrToStructure( p, typeof(SteamParentalSettingsChanged_t) ) ); - - static Action actionClient; - [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); - static Action actionServer; - [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); - public static void Install( Action action, bool server = false ) - { - if ( server ) - { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamParentalSettings + 1, true ); - actionServer = action; - } - else - { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamParentalSettings + 1, false ); - actionClient = action; - } - } - #endregion - } - - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct SteamServersConnected_t : ICallbackData - { - - #region SteamCallback - public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SteamServersConnected_t) ); - public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUser + 1; - internal static SteamServersConnected_t Fill( IntPtr p ) => ((SteamServersConnected_t)Marshal.PtrToStructure( p, typeof(SteamServersConnected_t) ) ); - - static Action actionClient; - [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); - static Action actionServer; - [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); - public static void Install( Action action, bool server = false ) - { - if ( server ) - { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUser + 1, true ); - actionServer = action; - } - else - { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUser + 1, false ); - actionClient = action; - } - } - #endregion - } - - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct NewLaunchQueryParameters_t - { - - #region Marshalling - internal static NewLaunchQueryParameters_t Fill( IntPtr p ) => ((NewLaunchQueryParameters_t)(NewLaunchQueryParameters_t) Marshal.PtrToStructure( p, typeof(NewLaunchQueryParameters_t) ) ); - #endregion - } - - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct GCMessageAvailable_t : ICallbackData - { - internal uint MessageSize; // m_nMessageSize uint32 - - #region SteamCallback - public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GCMessageAvailable_t) ); - public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamGameCoordinator + 1; - internal static GCMessageAvailable_t Fill( IntPtr p ) => ((GCMessageAvailable_t)Marshal.PtrToStructure( p, typeof(GCMessageAvailable_t) ) ); - - static Action actionClient; - [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); - static Action actionServer; - [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); - public static void Install( Action action, bool server = false ) - { - if ( server ) - { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamGameCoordinator + 1, true ); - actionServer = action; - } - else - { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamGameCoordinator + 1, false ); - actionClient = action; - } - } - #endregion - } - - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct GCMessageFailed_t : ICallbackData - { - - #region SteamCallback - public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(GCMessageFailed_t) ); - public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamGameCoordinator + 2; - internal static GCMessageFailed_t Fill( IntPtr p ) => ((GCMessageFailed_t)Marshal.PtrToStructure( p, typeof(GCMessageFailed_t) ) ); - - static Action actionClient; - [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); - static Action actionServer; - [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); - public static void Install( Action action, bool server = false ) - { - if ( server ) - { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamGameCoordinator + 2, true ); - actionServer = action; - } - else - { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamGameCoordinator + 2, false ); - actionClient = action; - } - } - #endregion - } - - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct ScreenshotRequested_t : ICallbackData - { - - #region SteamCallback - public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(ScreenshotRequested_t) ); - public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamScreenshots + 2; - internal static ScreenshotRequested_t Fill( IntPtr p ) => ((ScreenshotRequested_t)Marshal.PtrToStructure( p, typeof(ScreenshotRequested_t) ) ); - - static Action actionClient; - [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); - static Action actionServer; - [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); - public static void Install( Action action, bool server = false ) - { - if ( server ) - { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamScreenshots + 2, true ); - actionServer = action; - } - else - { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamScreenshots + 2, false ); - actionClient = action; - } - } - #endregion - } - - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct LicensesUpdated_t : ICallbackData - { - - #region SteamCallback - public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(LicensesUpdated_t) ); - public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUser + 25; - internal static LicensesUpdated_t Fill( IntPtr p ) => ((LicensesUpdated_t)Marshal.PtrToStructure( p, typeof(LicensesUpdated_t) ) ); - - static Action actionClient; - [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); - static Action actionServer; - [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); - public static void Install( Action action, bool server = false ) - { - if ( server ) - { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUser + 25, true ); - actionServer = action; - } - else - { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUser + 25, false ); - actionClient = action; - } - } - #endregion - } - - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct SteamShutdown_t : ICallbackData - { - - #region SteamCallback - public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(SteamShutdown_t) ); - public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUtils + 4; - internal static SteamShutdown_t Fill( IntPtr p ) => ((SteamShutdown_t)Marshal.PtrToStructure( p, typeof(SteamShutdown_t) ) ); - - static Action actionClient; - [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); - static Action actionServer; - [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); - public static void Install( Action action, bool server = false ) - { - if ( server ) - { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUtils + 4, true ); - actionServer = action; - } - else - { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUtils + 4, false ); - actionClient = action; - } - } - #endregion - } - - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct IPCountry_t : ICallbackData - { - - #region SteamCallback - public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(IPCountry_t) ); - public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUtils + 1; - internal static IPCountry_t Fill( IntPtr p ) => ((IPCountry_t)Marshal.PtrToStructure( p, typeof(IPCountry_t) ) ); - - static Action actionClient; - [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); - static Action actionServer; - [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); - public static void Install( Action action, bool server = false ) - { - if ( server ) - { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUtils + 1, true ); - actionServer = action; - } - else - { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUtils + 1, false ); - actionClient = action; - } - } - #endregion - } - - [StructLayout( LayoutKind.Sequential, Pack = Platform.StructPlatformPackSize )] - internal struct IPCFailure_t : ICallbackData - { - internal byte FailureType; // m_eFailureType uint8 - - #region SteamCallback - public static int _datasize = System.Runtime.InteropServices.Marshal.SizeOf( typeof(IPCFailure_t) ); - public int DataSize => _datasize; - public int CallbackId => CallbackIdentifiers.SteamUser + 17; - internal static IPCFailure_t Fill( IntPtr p ) => ((IPCFailure_t)Marshal.PtrToStructure( p, typeof(IPCFailure_t) ) ); - - static Action actionClient; - [MonoPInvokeCallback] static void OnClient( IntPtr thisptr, IntPtr pvParam ) => actionClient?.Invoke( Fill( pvParam ) ); - static Action actionServer; - [MonoPInvokeCallback] static void OnServer( IntPtr thisptr, IntPtr pvParam ) => actionServer?.Invoke( Fill( pvParam ) ); - public static void Install( Action action, bool server = false ) - { - if ( server ) - { - Event.Register( OnServer, _datasize, CallbackIdentifiers.SteamUser + 17, true ); - actionServer = action; - } - else - { - Event.Register( OnClient, _datasize, CallbackIdentifiers.SteamUser + 17, false ); + Event.Register( OnClient, _datasize, 1108, false ); actionClient = action; } } diff --git a/Facepunch.Steamworks/Generated/SteamTypes.cs b/Facepunch.Steamworks/Generated/SteamTypes.cs index 1ccf33b..44f5be6 100644 --- a/Facepunch.Steamworks/Generated/SteamTypes.cs +++ b/Facepunch.Steamworks/Generated/SteamTypes.cs @@ -8,6 +8,7 @@ namespace Steamworks.Data { internal struct GID_t : IEquatable, IComparable { + // Name: GID_t, Type: unsigned long long public ulong Value; public static implicit operator GID_t( ulong value ) => new GID_t(){ Value = value }; @@ -23,6 +24,7 @@ namespace Steamworks.Data internal struct JobID_t : IEquatable, IComparable { + // Name: JobID_t, Type: unsigned long long public ulong Value; public static implicit operator JobID_t( ulong value ) => new JobID_t(){ Value = value }; @@ -38,10 +40,11 @@ namespace Steamworks.Data internal struct TxnID_t : IEquatable, IComparable { - public GID_t Value; + // Name: TxnID_t, Type: unsigned long long + public ulong Value; - public static implicit operator TxnID_t( GID_t value ) => new TxnID_t(){ Value = value }; - public static implicit operator GID_t( TxnID_t value ) => value.Value; + public static implicit operator TxnID_t( ulong value ) => new TxnID_t(){ Value = value }; + public static implicit operator ulong( TxnID_t value ) => value.Value; public override string ToString() => Value.ToString(); public override int GetHashCode() => Value.GetHashCode(); public override bool Equals( object p ) => this.Equals( (TxnID_t) p ); @@ -53,6 +56,7 @@ namespace Steamworks.Data internal struct PackageId_t : IEquatable, IComparable { + // Name: PackageId_t, Type: unsigned int public uint Value; public static implicit operator PackageId_t( uint value ) => new PackageId_t(){ Value = value }; @@ -68,6 +72,7 @@ namespace Steamworks.Data internal struct BundleId_t : IEquatable, IComparable { + // Name: BundleId_t, Type: unsigned int public uint Value; public static implicit operator BundleId_t( uint value ) => new BundleId_t(){ Value = value }; @@ -83,6 +88,7 @@ namespace Steamworks.Data internal struct AssetClassId_t : IEquatable, IComparable { + // Name: AssetClassId_t, Type: unsigned long long public ulong Value; public static implicit operator AssetClassId_t( ulong value ) => new AssetClassId_t(){ Value = value }; @@ -98,6 +104,7 @@ namespace Steamworks.Data internal struct PhysicalItemId_t : IEquatable, IComparable { + // Name: PhysicalItemId_t, Type: unsigned int public uint Value; public static implicit operator PhysicalItemId_t( uint value ) => new PhysicalItemId_t(){ Value = value }; @@ -113,6 +120,7 @@ namespace Steamworks.Data internal struct DepotId_t : IEquatable, IComparable { + // Name: DepotId_t, Type: unsigned int public uint Value; public static implicit operator DepotId_t( uint value ) => new DepotId_t(){ Value = value }; @@ -128,6 +136,7 @@ namespace Steamworks.Data internal struct RTime32 : IEquatable, IComparable { + // Name: RTime32, Type: unsigned int public uint Value; public static implicit operator RTime32( uint value ) => new RTime32(){ Value = value }; @@ -143,6 +152,7 @@ namespace Steamworks.Data internal struct CellID_t : IEquatable, IComparable { + // Name: CellID_t, Type: unsigned int public uint Value; public static implicit operator CellID_t( uint value ) => new CellID_t(){ Value = value }; @@ -158,6 +168,7 @@ namespace Steamworks.Data internal struct SteamAPICall_t : IEquatable, IComparable { + // Name: SteamAPICall_t, Type: unsigned long long public ulong Value; public static implicit operator SteamAPICall_t( ulong value ) => new SteamAPICall_t(){ Value = value }; @@ -173,6 +184,7 @@ namespace Steamworks.Data internal struct AccountID_t : IEquatable, IComparable { + // Name: AccountID_t, Type: unsigned int public uint Value; public static implicit operator AccountID_t( uint value ) => new AccountID_t(){ Value = value }; @@ -188,6 +200,7 @@ namespace Steamworks.Data internal struct PartnerId_t : IEquatable, IComparable { + // Name: PartnerId_t, Type: unsigned int public uint Value; public static implicit operator PartnerId_t( uint value ) => new PartnerId_t(){ Value = value }; @@ -203,6 +216,7 @@ namespace Steamworks.Data internal struct ManifestId_t : IEquatable, IComparable { + // Name: ManifestId_t, Type: unsigned long long public ulong Value; public static implicit operator ManifestId_t( ulong value ) => new ManifestId_t(){ Value = value }; @@ -218,6 +232,7 @@ namespace Steamworks.Data internal struct SiteId_t : IEquatable, IComparable { + // Name: SiteId_t, Type: unsigned long long public ulong Value; public static implicit operator SiteId_t( ulong value ) => new SiteId_t(){ Value = value }; @@ -233,6 +248,7 @@ namespace Steamworks.Data internal struct PartyBeaconID_t : IEquatable, IComparable { + // Name: PartyBeaconID_t, Type: unsigned long long public ulong Value; public static implicit operator PartyBeaconID_t( ulong value ) => new PartyBeaconID_t(){ Value = value }; @@ -248,6 +264,7 @@ namespace Steamworks.Data internal struct HAuthTicket : IEquatable, IComparable { + // Name: HAuthTicket, Type: unsigned int public uint Value; public static implicit operator HAuthTicket( uint value ) => new HAuthTicket(){ Value = value }; @@ -263,6 +280,7 @@ namespace Steamworks.Data internal struct BREAKPAD_HANDLE : IEquatable, IComparable { + // Name: BREAKPAD_HANDLE, Type: void * public IntPtr Value; public static implicit operator BREAKPAD_HANDLE( IntPtr value ) => new BREAKPAD_HANDLE(){ Value = value }; @@ -278,6 +296,7 @@ namespace Steamworks.Data internal struct HSteamPipe : IEquatable, IComparable { + // Name: HSteamPipe, Type: int public int Value; public static implicit operator HSteamPipe( int value ) => new HSteamPipe(){ Value = value }; @@ -293,6 +312,7 @@ namespace Steamworks.Data internal struct HSteamUser : IEquatable, IComparable { + // Name: HSteamUser, Type: int public int Value; public static implicit operator HSteamUser( int value ) => new HSteamUser(){ Value = value }; @@ -308,6 +328,7 @@ namespace Steamworks.Data internal struct FriendsGroupID_t : IEquatable, IComparable { + // Name: FriendsGroupID_t, Type: short public short Value; public static implicit operator FriendsGroupID_t( short value ) => new FriendsGroupID_t(){ Value = value }; @@ -323,6 +344,7 @@ namespace Steamworks.Data internal struct HServerListRequest : IEquatable, IComparable { + // Name: HServerListRequest, Type: void * public IntPtr Value; public static implicit operator HServerListRequest( IntPtr value ) => new HServerListRequest(){ Value = value }; @@ -338,6 +360,7 @@ namespace Steamworks.Data internal struct HServerQuery : IEquatable, IComparable { + // Name: HServerQuery, Type: int public int Value; public static implicit operator HServerQuery( int value ) => new HServerQuery(){ Value = value }; @@ -353,6 +376,7 @@ namespace Steamworks.Data internal struct UGCHandle_t : IEquatable, IComparable { + // Name: UGCHandle_t, Type: unsigned long long public ulong Value; public static implicit operator UGCHandle_t( ulong value ) => new UGCHandle_t(){ Value = value }; @@ -368,6 +392,7 @@ namespace Steamworks.Data internal struct PublishedFileUpdateHandle_t : IEquatable, IComparable { + // Name: PublishedFileUpdateHandle_t, Type: unsigned long long public ulong Value; public static implicit operator PublishedFileUpdateHandle_t( ulong value ) => new PublishedFileUpdateHandle_t(){ Value = value }; @@ -383,6 +408,7 @@ namespace Steamworks.Data public struct PublishedFileId : IEquatable, IComparable { + // Name: PublishedFileId_t, Type: unsigned long long public ulong Value; public static implicit operator PublishedFileId( ulong value ) => new PublishedFileId(){ Value = value }; @@ -398,6 +424,7 @@ namespace Steamworks.Data internal struct UGCFileWriteStreamHandle_t : IEquatable, IComparable { + // Name: UGCFileWriteStreamHandle_t, Type: unsigned long long public ulong Value; public static implicit operator UGCFileWriteStreamHandle_t( ulong value ) => new UGCFileWriteStreamHandle_t(){ Value = value }; @@ -413,6 +440,7 @@ namespace Steamworks.Data internal struct SteamLeaderboard_t : IEquatable, IComparable { + // Name: SteamLeaderboard_t, Type: unsigned long long public ulong Value; public static implicit operator SteamLeaderboard_t( ulong value ) => new SteamLeaderboard_t(){ Value = value }; @@ -428,6 +456,7 @@ namespace Steamworks.Data internal struct SteamLeaderboardEntries_t : IEquatable, IComparable { + // Name: SteamLeaderboardEntries_t, Type: unsigned long long public ulong Value; public static implicit operator SteamLeaderboardEntries_t( ulong value ) => new SteamLeaderboardEntries_t(){ Value = value }; @@ -443,6 +472,7 @@ namespace Steamworks.Data internal struct SNetSocket_t : IEquatable, IComparable { + // Name: SNetSocket_t, Type: unsigned int public uint Value; public static implicit operator SNetSocket_t( uint value ) => new SNetSocket_t(){ Value = value }; @@ -458,6 +488,7 @@ namespace Steamworks.Data internal struct SNetListenSocket_t : IEquatable, IComparable { + // Name: SNetListenSocket_t, Type: unsigned int public uint Value; public static implicit operator SNetListenSocket_t( uint value ) => new SNetListenSocket_t(){ Value = value }; @@ -473,6 +504,7 @@ namespace Steamworks.Data internal struct ScreenshotHandle : IEquatable, IComparable { + // Name: ScreenshotHandle, Type: unsigned int public uint Value; public static implicit operator ScreenshotHandle( uint value ) => new ScreenshotHandle(){ Value = value }; @@ -488,6 +520,7 @@ namespace Steamworks.Data internal struct HTTPRequestHandle : IEquatable, IComparable { + // Name: HTTPRequestHandle, Type: unsigned int public uint Value; public static implicit operator HTTPRequestHandle( uint value ) => new HTTPRequestHandle(){ Value = value }; @@ -503,6 +536,7 @@ namespace Steamworks.Data internal struct HTTPCookieContainerHandle : IEquatable, IComparable { + // Name: HTTPCookieContainerHandle, Type: unsigned int public uint Value; public static implicit operator HTTPCookieContainerHandle( uint value ) => new HTTPCookieContainerHandle(){ Value = value }; @@ -518,6 +552,7 @@ namespace Steamworks.Data internal struct InputHandle_t : IEquatable, IComparable { + // Name: InputHandle_t, Type: unsigned long long public ulong Value; public static implicit operator InputHandle_t( ulong value ) => new InputHandle_t(){ Value = value }; @@ -533,6 +568,7 @@ namespace Steamworks.Data internal struct InputActionSetHandle_t : IEquatable, IComparable { + // Name: InputActionSetHandle_t, Type: unsigned long long public ulong Value; public static implicit operator InputActionSetHandle_t( ulong value ) => new InputActionSetHandle_t(){ Value = value }; @@ -548,6 +584,7 @@ namespace Steamworks.Data internal struct InputDigitalActionHandle_t : IEquatable, IComparable { + // Name: InputDigitalActionHandle_t, Type: unsigned long long public ulong Value; public static implicit operator InputDigitalActionHandle_t( ulong value ) => new InputDigitalActionHandle_t(){ Value = value }; @@ -563,6 +600,7 @@ namespace Steamworks.Data internal struct InputAnalogActionHandle_t : IEquatable, IComparable { + // Name: InputAnalogActionHandle_t, Type: unsigned long long public ulong Value; public static implicit operator InputAnalogActionHandle_t( ulong value ) => new InputAnalogActionHandle_t(){ Value = value }; @@ -578,6 +616,7 @@ namespace Steamworks.Data internal struct ControllerHandle_t : IEquatable, IComparable { + // Name: ControllerHandle_t, Type: unsigned long long public ulong Value; public static implicit operator ControllerHandle_t( ulong value ) => new ControllerHandle_t(){ Value = value }; @@ -593,6 +632,7 @@ namespace Steamworks.Data internal struct ControllerActionSetHandle_t : IEquatable, IComparable { + // Name: ControllerActionSetHandle_t, Type: unsigned long long public ulong Value; public static implicit operator ControllerActionSetHandle_t( ulong value ) => new ControllerActionSetHandle_t(){ Value = value }; @@ -608,6 +648,7 @@ namespace Steamworks.Data internal struct ControllerDigitalActionHandle_t : IEquatable, IComparable { + // Name: ControllerDigitalActionHandle_t, Type: unsigned long long public ulong Value; public static implicit operator ControllerDigitalActionHandle_t( ulong value ) => new ControllerDigitalActionHandle_t(){ Value = value }; @@ -623,6 +664,7 @@ namespace Steamworks.Data internal struct ControllerAnalogActionHandle_t : IEquatable, IComparable { + // Name: ControllerAnalogActionHandle_t, Type: unsigned long long public ulong Value; public static implicit operator ControllerAnalogActionHandle_t( ulong value ) => new ControllerAnalogActionHandle_t(){ Value = value }; @@ -638,6 +680,7 @@ namespace Steamworks.Data internal struct UGCQueryHandle_t : IEquatable, IComparable { + // Name: UGCQueryHandle_t, Type: unsigned long long public ulong Value; public static implicit operator UGCQueryHandle_t( ulong value ) => new UGCQueryHandle_t(){ Value = value }; @@ -653,6 +696,7 @@ namespace Steamworks.Data internal struct UGCUpdateHandle_t : IEquatable, IComparable { + // Name: UGCUpdateHandle_t, Type: unsigned long long public ulong Value; public static implicit operator UGCUpdateHandle_t( ulong value ) => new UGCUpdateHandle_t(){ Value = value }; @@ -668,6 +712,7 @@ namespace Steamworks.Data internal struct HHTMLBrowser : IEquatable, IComparable { + // Name: HHTMLBrowser, Type: unsigned int public uint Value; public static implicit operator HHTMLBrowser( uint value ) => new HHTMLBrowser(){ Value = value }; @@ -683,6 +728,7 @@ namespace Steamworks.Data public struct InventoryItemId : IEquatable, IComparable { + // Name: SteamItemInstanceID_t, Type: unsigned long long public ulong Value; public static implicit operator InventoryItemId( ulong value ) => new InventoryItemId(){ Value = value }; @@ -698,6 +744,7 @@ namespace Steamworks.Data public struct InventoryDefId : IEquatable, IComparable { + // Name: SteamItemDef_t, Type: int public int Value; public static implicit operator InventoryDefId( int value ) => new InventoryDefId(){ Value = value }; @@ -713,6 +760,7 @@ namespace Steamworks.Data internal struct SteamInventoryResult_t : IEquatable, IComparable { + // Name: SteamInventoryResult_t, Type: int public int Value; public static implicit operator SteamInventoryResult_t( int value ) => new SteamInventoryResult_t(){ Value = value }; @@ -728,6 +776,7 @@ namespace Steamworks.Data internal struct SteamInventoryUpdateHandle_t : IEquatable, IComparable { + // Name: SteamInventoryUpdateHandle_t, Type: unsigned long long public ulong Value; public static implicit operator SteamInventoryUpdateHandle_t( ulong value ) => new SteamInventoryUpdateHandle_t(){ Value = value }; @@ -741,4 +790,52 @@ namespace Steamworks.Data public int CompareTo( SteamInventoryUpdateHandle_t other ) => Value.CompareTo( other.Value ); } + internal struct RemotePlaySessionID_t : IEquatable, IComparable + { + // Name: RemotePlaySessionID_t, Type: unsigned int + public uint Value; + + public static implicit operator RemotePlaySessionID_t( uint value ) => new RemotePlaySessionID_t(){ Value = value }; + public static implicit operator uint( RemotePlaySessionID_t value ) => value.Value; + public override string ToString() => Value.ToString(); + public override int GetHashCode() => Value.GetHashCode(); + public override bool Equals( object p ) => this.Equals( (RemotePlaySessionID_t) p ); + public bool Equals( RemotePlaySessionID_t p ) => p.Value == Value; + public static bool operator ==( RemotePlaySessionID_t a, RemotePlaySessionID_t b ) => a.Equals( b ); + public static bool operator !=( RemotePlaySessionID_t a, RemotePlaySessionID_t b ) => !a.Equals( b ); + public int CompareTo( RemotePlaySessionID_t other ) => Value.CompareTo( other.Value ); + } + + internal struct HSteamNetPollGroup : IEquatable, IComparable + { + // Name: HSteamNetPollGroup, Type: unsigned int + public uint Value; + + public static implicit operator HSteamNetPollGroup( uint value ) => new HSteamNetPollGroup(){ Value = value }; + public static implicit operator uint( HSteamNetPollGroup value ) => value.Value; + public override string ToString() => Value.ToString(); + public override int GetHashCode() => Value.GetHashCode(); + public override bool Equals( object p ) => this.Equals( (HSteamNetPollGroup) p ); + public bool Equals( HSteamNetPollGroup p ) => p.Value == Value; + public static bool operator ==( HSteamNetPollGroup a, HSteamNetPollGroup b ) => a.Equals( b ); + public static bool operator !=( HSteamNetPollGroup a, HSteamNetPollGroup b ) => !a.Equals( b ); + public int CompareTo( HSteamNetPollGroup other ) => Value.CompareTo( other.Value ); + } + + internal struct SteamNetworkingPOPID : IEquatable, IComparable + { + // Name: SteamNetworkingPOPID, Type: unsigned int + public uint Value; + + public static implicit operator SteamNetworkingPOPID( uint value ) => new SteamNetworkingPOPID(){ Value = value }; + public static implicit operator uint( SteamNetworkingPOPID value ) => value.Value; + public override string ToString() => Value.ToString(); + public override int GetHashCode() => Value.GetHashCode(); + public override bool Equals( object p ) => this.Equals( (SteamNetworkingPOPID) p ); + public bool Equals( SteamNetworkingPOPID p ) => p.Value == Value; + public static bool operator ==( SteamNetworkingPOPID a, SteamNetworkingPOPID b ) => a.Equals( b ); + public static bool operator !=( SteamNetworkingPOPID a, SteamNetworkingPOPID b ) => !a.Equals( b ); + public int CompareTo( SteamNetworkingPOPID other ) => Value.CompareTo( other.Value ); + } + }