GitHub/Facepunch.Steamworks
2
0
Fork 0
mirror of https://github.com/Facepunch/Facepunch.Steamworks.git synced 2024-12-25 14:15:47 +03:00
Code Issues Projects Releases Wiki Activity

MacOs loading

Browse Source
This commit is contained in:
Garry Newman 2019-04-29 15:47:23 +01:00
parent e68dc15454
commit 74ef28b9fc
4 changed files with 332 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

165
Facepunch.Steamworks/Generated/SteamApi.cs
View File

@ -43,55 +43,200 @@ internal static class Win64
[return: MarshalAs( UnmanagedType.I1 )]
public static extern bool SteamAPI_RestartAppIfNecessary( uint unOwnAppID );
}
internal static class MacOs
{
[DllImport( "libsteam_api", EntryPoint = "SteamAPI_Init", CallingConvention = CallingConvention.Cdecl )]
[return: MarshalAs( UnmanagedType.I1 )]
public static extern bool SteamAPI_Init();
[DllImport( "libsteam_api", EntryPoint = "SteamAPI_RunCallbacks", CallingConvention = CallingConvention.Cdecl )]
public static extern void SteamAPI_RunCallbacks();
[DllImport( "libsteam_api", EntryPoint = "SteamAPI_RegisterCallback", CallingConvention = CallingConvention.Cdecl )]
public static extern void SteamAPI_RegisterCallback( IntPtr pCallback, int callback );
[DllImport( "libsteam_api", EntryPoint = "SteamAPI_UnregisterCallback", CallingConvention = CallingConvention.Cdecl )]
public static extern void SteamAPI_UnregisterCallback( IntPtr pCallback );
[DllImport( "libsteam_api", EntryPoint = "SteamAPI_RegisterCallResult", CallingConvention = CallingConvention.Cdecl )]
public static extern void SteamAPI_RegisterCallResult( IntPtr pCallback, SteamAPICall_t callback );
[DllImport( "libsteam_api", EntryPoint = "SteamAPI_UnregisterCallResult", CallingConvention = CallingConvention.Cdecl )]
public static extern void SteamAPI_UnregisterCallResult( IntPtr pCallback, SteamAPICall_t callback );
[DllImport( "libsteam_api", EntryPoint = "SteamAPI_Shutdown", CallingConvention = CallingConvention.Cdecl )]
public static extern void SteamAPI_Shutdown();
[DllImport( "libsteam_api", EntryPoint = "SteamAPI_GetHSteamUser", CallingConvention = CallingConvention.Cdecl )]
public static extern HSteamUser SteamAPI_GetHSteamUser();
[DllImport( "libsteam_api", EntryPoint = "SteamAPI_GetHSteamPipe", CallingConvention = CallingConvention.Cdecl )]
public static extern HSteamPipe SteamAPI_GetHSteamPipe();
[DllImport( "libsteam_api", EntryPoint = "SteamAPI_RestartAppIfNecessary", CallingConvention = CallingConvention.Cdecl )]
[return: MarshalAs( UnmanagedType.I1 )]
public static extern bool SteamAPI_RestartAppIfNecessary( uint unOwnAppID );
}
static internal bool Init()
{
return Win64.SteamAPI_Init();
if ( Config.Os == OsType.Windows )
{
return Win64.SteamAPI_Init();
}
else if ( Config.Os == OsType.MacOs )
{
return MacOs.SteamAPI_Init();
}
else
{
throw new System.Exception( "this platform isn't supported" );
}
}
static internal void RunCallbacks()
{
Win64.SteamAPI_RunCallbacks();
if ( Config.Os == OsType.Windows )
{
Win64.SteamAPI_RunCallbacks();
}
else if ( Config.Os == OsType.MacOs )
{
MacOs.SteamAPI_RunCallbacks();
}
else
{
throw new System.Exception( "this platform isn't supported" );
}
}
static internal void RegisterCallback( IntPtr pCallback, int callback )
{
Win64.SteamAPI_RegisterCallback( pCallback, callback );
if ( Config.Os == OsType.Windows )
{
Win64.SteamAPI_RegisterCallback( pCallback, callback );
}
else if ( Config.Os == OsType.MacOs )
{
MacOs.SteamAPI_RegisterCallback( pCallback, callback );
}
else
{
throw new System.Exception( "this platform isn't supported" );
}
}
static internal void UnregisterCallback( IntPtr pCallback )
{
Win64.SteamAPI_UnregisterCallback( pCallback );
if ( Config.Os == OsType.Windows )
{
Win64.SteamAPI_UnregisterCallback( pCallback );
}
else if ( Config.Os == OsType.MacOs )
{
MacOs.SteamAPI_UnregisterCallback( pCallback );
}
else
{
throw new System.Exception( "this platform isn't supported" );
}
}
static internal void RegisterCallResult( IntPtr pCallback, SteamAPICall_t callback )
{
Win64.SteamAPI_RegisterCallResult( pCallback, callback );
if ( Config.Os == OsType.Windows )
{
Win64.SteamAPI_RegisterCallResult( pCallback, callback );
}
else if ( Config.Os == OsType.MacOs )
{
MacOs.SteamAPI_RegisterCallResult( pCallback, callback );
}
else
{
throw new System.Exception( "this platform isn't supported" );
}
}
static internal void UnregisterCallResult( IntPtr pCallback, SteamAPICall_t callback )
{
Win64.SteamAPI_UnregisterCallResult( pCallback, callback );
if ( Config.Os == OsType.Windows )
{
Win64.SteamAPI_UnregisterCallResult( pCallback, callback );
}
else if ( Config.Os == OsType.MacOs )
{
MacOs.SteamAPI_UnregisterCallResult( pCallback, callback );
}
else
{
throw new System.Exception( "this platform isn't supported" );
}
}
static internal void Shutdown()
{
Win64.SteamAPI_Shutdown();
if ( Config.Os == OsType.Windows )
{
Win64.SteamAPI_Shutdown();
}
else if ( Config.Os == OsType.MacOs )
{
MacOs.SteamAPI_Shutdown();
}
else
{
throw new System.Exception( "this platform isn't supported" );
}
}
static internal HSteamUser GetHSteamUser()
{
return Win64.SteamAPI_GetHSteamUser();
if ( Config.Os == OsType.Windows )
{
return Win64.SteamAPI_GetHSteamUser();
}
else if ( Config.Os == OsType.MacOs )
{
return MacOs.SteamAPI_GetHSteamUser();
}
else
{
throw new System.Exception( "this platform isn't supported" );
}
}
static internal HSteamPipe GetHSteamPipe()
{
return Win64.SteamAPI_GetHSteamPipe();
if ( Config.Os == OsType.Windows )
{
return Win64.SteamAPI_GetHSteamPipe();
}
else if ( Config.Os == OsType.MacOs )
{
return MacOs.SteamAPI_GetHSteamPipe();
}
else
{
throw new System.Exception( "this platform isn't supported" );
}
}
static internal bool RestartAppIfNecessary( uint unOwnAppID )
{
return Win64.SteamAPI_RestartAppIfNecessary( unOwnAppID );
if ( Config.Os == OsType.Windows )
{
return Win64.SteamAPI_RestartAppIfNecessary( unOwnAppID );
}
else if ( Config.Os == OsType.MacOs )
{
return MacOs.SteamAPI_RestartAppIfNecessary( unOwnAppID );
}
else
{
throw new System.Exception( "this platform isn't supported" );
}
}
}

67
Facepunch.Steamworks/Generated/SteamGameServer.cs
View File

@ -23,25 +23,84 @@ internal static class Win64
[DllImport( "steam_api64", EntryPoint = "SteamGameServer_GetHSteamPipe", CallingConvention = CallingConvention.Cdecl )]
public static extern HSteamPipe SteamGameServer_GetHSteamPipe();
}
internal static class MacOs
{
[DllImport( "libsteam_api", EntryPoint = "SteamGameServer_RunCallbacks", CallingConvention = CallingConvention.Cdecl )]
public static extern void SteamGameServer_RunCallbacks();
[DllImport( "libsteam_api", EntryPoint = "SteamGameServer_Shutdown", CallingConvention = CallingConvention.Cdecl )]
public static extern void SteamGameServer_Shutdown();
[DllImport( "libsteam_api", EntryPoint = "SteamGameServer_GetHSteamUser", CallingConvention = CallingConvention.Cdecl )]
public static extern HSteamUser SteamGameServer_GetHSteamUser();
[DllImport( "libsteam_api", EntryPoint = "SteamGameServer_GetHSteamPipe", CallingConvention = CallingConvention.Cdecl )]
public static extern HSteamPipe SteamGameServer_GetHSteamPipe();
}
static internal void RunCallbacks()
{
Win64.SteamGameServer_RunCallbacks();
if ( Config.Os == OsType.Windows )
{
Win64.SteamGameServer_RunCallbacks();
}
else if ( Config.Os == OsType.MacOs )
{
MacOs.SteamGameServer_RunCallbacks();
}
else
{
throw new System.Exception( "this platform isn't supported" );
}
}
static internal void Shutdown()
{
Win64.SteamGameServer_Shutdown();
if ( Config.Os == OsType.Windows )
{
Win64.SteamGameServer_Shutdown();
}
else if ( Config.Os == OsType.MacOs )
{
MacOs.SteamGameServer_Shutdown();
}
else
{
throw new System.Exception( "this platform isn't supported" );
}
}
static internal HSteamUser GetHSteamUser()
{
return Win64.SteamGameServer_GetHSteamUser();
if ( Config.Os == OsType.Windows )
{
return Win64.SteamGameServer_GetHSteamUser();
}
else if ( Config.Os == OsType.MacOs )
{
return MacOs.SteamGameServer_GetHSteamUser();
}
else
{
throw new System.Exception( "this platform isn't supported" );
}
}
static internal HSteamPipe GetHSteamPipe()
{
return Win64.SteamGameServer_GetHSteamPipe();
if ( Config.Os == OsType.Windows )
{
return Win64.SteamGameServer_GetHSteamPipe();
}
else if ( Config.Os == OsType.MacOs )
{
return MacOs.SteamGameServer_GetHSteamPipe();
}
else
{
throw new System.Exception( "this platform isn't supported" );
}
}
}

68
Facepunch.Steamworks/Generated/SteamInternal.cs
View File

@ -24,25 +24,85 @@ internal static class Win64
[DllImport( "steam_api64", EntryPoint = "SteamInternal_CreateInterface", CallingConvention = CallingConvention.Cdecl )]
public static extern IntPtr SteamInternal_CreateInterface( string version );
}
internal static class MacOs
{
[DllImport( "libsteam_api", EntryPoint = "SteamInternal_GameServer_Init", CallingConvention = CallingConvention.Cdecl )]
[return: MarshalAs( UnmanagedType.I1 )]
public static extern bool SteamInternal_GameServer_Init( uint unIP, ushort usPort, ushort usGamePort, ushort usQueryPort, int eServerMode, string pchVersionString );
[DllImport( "libsteam_api", EntryPoint = "SteamInternal_FindOrCreateUserInterface", CallingConvention = CallingConvention.Cdecl )]
public static extern IntPtr SteamInternal_FindOrCreateUserInterface( int steamuser, string versionname );
[DllImport( "libsteam_api", EntryPoint = "SteamInternal_FindOrCreateGameServerInterface", CallingConvention = CallingConvention.Cdecl )]
public static extern IntPtr SteamInternal_FindOrCreateGameServerInterface( int steamuser, string versionname );
[DllImport( "libsteam_api", EntryPoint = "SteamInternal_CreateInterface", CallingConvention = CallingConvention.Cdecl )]
public static extern IntPtr SteamInternal_CreateInterface( string version );
}
static internal bool GameServer_Init( uint unIP, ushort usPort, ushort usGamePort, ushort usQueryPort, int eServerMode, string pchVersionString )
{
return Win64.SteamInternal_GameServer_Init( unIP, usPort, usGamePort, usQueryPort, eServerMode, pchVersionString );
if ( Config.Os == OsType.Windows )
{
return Win64.SteamInternal_GameServer_Init( unIP, usPort, usGamePort, usQueryPort, eServerMode, pchVersionString );
}
else if ( Config.Os == OsType.MacOs )
{
return MacOs.SteamInternal_GameServer_Init( unIP, usPort, usGamePort, usQueryPort, eServerMode, pchVersionString );
}
else
{
throw new System.Exception( "this platform isn't supported" );
}
}
static internal IntPtr FindOrCreateUserInterface( int steamuser, string versionname )
{
return Win64.SteamInternal_FindOrCreateUserInterface( steamuser, versionname );
if ( Config.Os == OsType.Windows )
{
return Win64.SteamInternal_FindOrCreateUserInterface( steamuser, versionname );
}
else if ( Config.Os == OsType.MacOs )
{
return MacOs.SteamInternal_FindOrCreateUserInterface( steamuser, versionname );
}
else
{
throw new System.Exception( "this platform isn't supported" );
}
}
static internal IntPtr FindOrCreateGameServerInterface( int steamuser, string versionname )
{
return Win64.SteamInternal_FindOrCreateGameServerInterface( steamuser, versionname );
if ( Config.Os == OsType.Windows )
{
return Win64.SteamInternal_FindOrCreateGameServerInterface( steamuser, versionname );
}
else if ( Config.Os == OsType.MacOs )
{
return MacOs.SteamInternal_FindOrCreateGameServerInterface( steamuser, versionname );
}
else
{
throw new System.Exception( "this platform isn't supported" );
}
}
static internal IntPtr CreateInterface( string version )
{
return Win64.SteamInternal_CreateInterface( version );
if ( Config.Os == OsType.Windows )
{
return Win64.SteamInternal_CreateInterface( version );
}
else if ( Config.Os == OsType.MacOs )
{
return MacOs.SteamInternal_CreateInterface( version );
}
else
{
throw new System.Exception( "this platform isn't supported" );
}
}
}

63
Generator/CodeWriter/GlobalFunctions.cs
View File

@ -36,6 +36,15 @@ public void GenerateGlobalFunctions( string startingWith, string filename )
}
EndBlock();
StartBlock( $"internal static class MacOs" );
{
foreach ( var func in functions )
{
WriteMarshalledFunction( func, "libsteam_api" );
}
}
EndBlock();
foreach ( var func in functions )
{
WriteGlobalFunction( startingWith, func );
@ -78,22 +87,50 @@ private void WriteGlobalFunction( string cname, SteamApiDefinition.MethodDef fun
{
var callargs = string.Join( ", ", args.Select( x => x.AsCallArgument() ) );
if ( returnType.IsReturnedWeird )
StartBlock( "if ( Config.Os == OsType.Windows )" );
{
WriteLine( $"var retVal = default( {returnType.TypeName} );" );
WriteLine( $"Win64.{func.Name}( ref retVal, {callargs} );" );
WriteLine( $"{returnType.Return( "retVal" )}" );
}
else if ( returnType.IsVoid )
{
WriteLine( $"Win64.{func.Name}( {callargs} );" );
}
else
{
var v = $"Win64.{func.Name}( {callargs} )";
WriteLine( returnType.Return( v ) );
if ( returnType.IsReturnedWeird )
{
WriteLine( $"var retVal = default( {returnType.TypeName} );" );
WriteLine( $"Win64.{func.Name}( ref retVal, {callargs} );" );
WriteLine( $"{returnType.Return( "retVal" )}" );
}
else if ( returnType.IsVoid )
{
WriteLine( $"Win64.{func.Name}( {callargs} );" );
}
else
{
var v = $"Win64.{func.Name}( {callargs} )";
WriteLine( returnType.Return( v ) );
}
}
Else( " if ( Config.Os == OsType.MacOs )" );
{
if ( returnType.IsReturnedWeird )
{
WriteLine( $"var retVal = default( {returnType.TypeName} );" );
WriteLine( $"MacOs.{func.Name}( ref retVal, {callargs} );" );
WriteLine( $"{returnType.Return( "retVal" )}" );
}
else if ( returnType.IsVoid )
{
WriteLine( $"MacOs.{func.Name}( {callargs} );" );
}
else
{
var v = $"MacOs.{func.Name}( {callargs} )";
WriteLine( returnType.Return( v ) );
}
}
Else();
{
WriteLine( "throw new System.Exception( \"this platform isn't supported\" );" );
}
EndBlock();
}
EndBlock();