/// user generated content
/// Downloads a UGC file. A priority value of 0 will download the file immediately,
/// otherwise it will wait to download the file until all downloads with a lower priority
/// value are completed. Downloads with equal priority will occur simultaneously.
public static SteamAPICall_t UGCDownload(UGCHandle_t hContent, uint unPriority)
{
return((SteamAPICall_t)0);
}
internal bool GetUGCDetails(UGCHandle_t hContent, ref AppId pnAppID, [In, Out] ref char[] ppchName, ref int pnFileSizeInBytes, ref SteamId pSteamIDOwner)
{
return(_GetUGCDetails(Self, hContent, ref pnAppID, ref ppchName, ref pnFileSizeInBytes, ref pSteamIDOwner));
}
internal async Task <RemoteStorageDownloadUGCResult_t?> UGCDownloadToLocation(UGCHandle_t hContent, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(Utf8StringToNative))] string pchLocation, uint unPriority)
{
return(await RemoteStorageDownloadUGCResult_t.GetResultAsync(_UGCDownloadToLocation( Self, hContent, pchLocation, unPriority )));
}
/// <summary>
/// <para> Gets the amount of data downloaded so far for a piece of content. pnBytesExpected can be 0 if function returns false</para>
/// <para> or if the transfer hasn't started yet, so be careful to check for that before dividing to get a percentage</para>
/// </summary>
public static bool GetUGCDownloadProgress(UGCHandle_t hContent, out int pnBytesDownloaded, out int pnBytesExpected)
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamRemoteStorage_GetUGCDownloadProgress(hContent, out pnBytesDownloaded, out pnBytesExpected));
}
internal async Task <RemoteStorageDownloadUGCResult_t?> UGCDownload(UGCHandle_t hContent, uint unPriority)
{
return(await RemoteStorageDownloadUGCResult_t.GetResultAsync(_UGCDownload( Self, hContent, unPriority )));
}
private static extern int _UGCRead(IntPtr self, UGCHandle_t hContent, IntPtr pvData, int cubDataToRead, uint cOffset, UGCReadAction eAction);
internal CallResult <RemoteStorageDownloadUGCResult_t> UGCDownloadToLocation(UGCHandle_t hContent, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(Utf8StringToNative))] string pchLocation, uint unPriority)
{
var returnValue = _UGCDownloadToLocation(Self, hContent, pchLocation, unPriority);
return(new CallResult <RemoteStorageDownloadUGCResult_t>(returnValue, IsServer));
}
public bool Equals(UGCHandle_t other) => default; // 0x0000000180004FB0-0x0000000180004FC0 public int CompareTo(UGCHandle_t other) => default; // 0x0000000180004F10-0x0000000180004F20
internal async Task <LeaderboardUGCSet_t?> AttachLeaderboardUGC(SteamLeaderboard_t hSteamLeaderboard, UGCHandle_t hUGC)
{
return(await LeaderboardUGCSet_t.GetResultAsync(_AttachLeaderboardUGC( Self, hSteamLeaderboard, hUGC )));
}
} // 0x0000000180004FE0-0x0000000180004FF0
static UGCHandle_t()
{
Invalid = default;
} // 0x0000000180840180-0x00000001808401C0
public static explicit operator ulong(UGCHandle_t that) => default; // 0x00000001802A78B0-0x00000001802A78C0 public bool Equals(UGCHandle_t other) => default; // 0x0000000180004FB0-0x0000000180004FC0
public static SteamAPICall_t UGCDownloadToLocation(UGCHandle_t hContent, string pchLocation, uint unPriority)
{
return((SteamAPICall_t)0);
}
/// After download, gets the content of the file.
/// Small files can be read all at once by calling this function with an offset of 0 and cubDataToRead equal to the size of the file.
/// Larger files can be read in chunks to reduce memory usage (since both sides of the IPC client and the game itself must allocate
/// enough memory for each chunk). Once the last byte is read, the file is implicitly closed and further calls to UGCRead will fail
/// unless UGCDownload is called again.
/// For especially large files (anything over 100MB) it is a requirement that the file is read in chunks.
public static int UGCRead(UGCHandle_t hContent, byte[] pvData, int cubDataToRead, uint cOffset, EUGCReadAction eAction)
{
return(0);
}
/// Gets the amount of data downloaded so far for a piece of content. pnBytesExpected can be 0 if function returns false
/// or if the transfer hasn't started yet, so be careful to check for that before dividing to get a percentage
public static bool GetUGCDownloadProgress(UGCHandle_t hContent, out int pnBytesDownloaded, out int pnBytesExpected)
{
pnBytesDownloaded = 0;
pnBytesExpected = 0;
return(false);
}
internal bool GetUGCDownloadProgress(UGCHandle_t hContent, ref int pnBytesDownloaded, ref int pnBytesExpected)
{
var returnValue = _GetUGCDownloadProgress(Self, hContent, ref pnBytesDownloaded, ref pnBytesExpected);
return(returnValue);
}
private static extern SteamAPICall_t _AttachLeaderboardUGC(IntPtr self, SteamLeaderboard_t hSteamLeaderboard, UGCHandle_t hUGC);
private static extern bool _GetUGCDetails(IntPtr self, UGCHandle_t hContent, ref AppId pnAppID, [In, Out] ref char[] ppchName, ref int pnFileSizeInBytes, ref SteamId pSteamIDOwner);
internal CallResult <LeaderboardUGCSet_t> AttachLeaderboardUGC(SteamLeaderboard_t hSteamLeaderboard, UGCHandle_t hUGC)
{
var returnValue = _AttachLeaderboardUGC(Self, hSteamLeaderboard, hUGC);
return(new CallResult <LeaderboardUGCSet_t>(returnValue, IsServer));
}
private static extern SteamAPICall_t _UGCDownloadToLocation(IntPtr self, UGCHandle_t hContent, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(Utf8StringToNative))] string pchLocation, uint unPriority);
public bool GetUGCDetails(UGCHandle_t hContent, ref AppId pnAppID, [In, Out] ref char[] ppchName, ref int pnFileSizeInBytes, ref SteamId pSteamIDOwner)
{
var returnValue = _GetUGCDetails(Self, hContent, ref pnAppID, ref ppchName, ref pnFileSizeInBytes, ref pSteamIDOwner);
return(returnValue);
}
/// <summary>
/// <para> user generated content</para>
/// <para> Downloads a UGC file. A priority value of 0 will download the file immediately,</para>
/// <para> otherwise it will wait to download the file until all downloads with a lower priority</para>
/// <para> value are completed. Downloads with equal priority will occur simultaneously.</para>
/// </summary>
public static SteamAPICall_t UGCDownload(UGCHandle_t hContent, uint unPriority)
{
InteropHelp.TestIfAvailableClient();
return((SteamAPICall_t)NativeMethods.ISteamRemoteStorage_UGCDownload(hContent, unPriority));
}
public int UGCRead(UGCHandle_t hContent, IntPtr pvData, int cubDataToRead, uint cOffset, UGCReadAction eAction)
{
var returnValue = _UGCRead(Self, hContent, pvData, cubDataToRead, cOffset, eAction);
return(returnValue);
}
/// <summary>
/// <para> After download, gets the content of the file.</para>
/// <para> Small files can be read all at once by calling this function with an offset of 0 and cubDataToRead equal to the size of the file.</para>
/// <para> Larger files can be read in chunks to reduce memory usage (since both sides of the IPC client and the game itself must allocate</para>
/// <para> enough memory for each chunk). Once the last byte is read, the file is implicitly closed and further calls to UGCRead will fail</para>
/// <para> unless UGCDownload is called again.</para>
/// <para> For especially large files (anything over 100MB) it is a requirement that the file is read in chunks.</para>
/// </summary>
public static int UGCRead(UGCHandle_t hContent, byte[] pvData, int cubDataToRead, uint cOffset, EUGCReadAction eAction)
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamRemoteStorage_UGCRead(hContent, pvData, cubDataToRead, cOffset, eAction));
}
private static extern SteamAPICall_t _UGCDownload(IntPtr self, UGCHandle_t hContent, uint unPriority);
internal bool GetUGCDownloadProgress(UGCHandle_t hContent, ref int pnBytesDownloaded, ref int pnBytesExpected)
{
return(_GetUGCDownloadProgress(Self, hContent, ref pnBytesDownloaded, ref pnBytesExpected));
}
internal CallResult <RemoteStorageDownloadUGCResult_t> UGCDownload(UGCHandle_t hContent, uint unPriority)
{
var returnValue = _UGCDownload(Self, hContent, unPriority);
return(new CallResult <RemoteStorageDownloadUGCResult_t>(returnValue, IsServer));
}
internal int UGCRead(UGCHandle_t hContent, IntPtr pvData, int cubDataToRead, uint cOffset, UGCReadAction eAction)
{
return(_UGCRead(Self, hContent, pvData, cubDataToRead, cOffset, eAction));
}
private static extern bool _GetUGCDownloadProgress(IntPtr self, UGCHandle_t hContent, ref int pnBytesDownloaded, ref int pnBytesExpected);
/// <summary>
/// <para> Attaches a piece of user generated content the user's entry on a leaderboard.</para>
/// <para> hContent is a handle to a piece of user generated content that was shared using ISteamUserRemoteStorage::FileShare().</para>
/// <para> This call is asynchronous, with the result returned in LeaderboardUGCSet_t.</para>
/// </summary>
public static SteamAPICall_t AttachLeaderboardUGC(SteamLeaderboard_t hSteamLeaderboard, UGCHandle_t hUGC)
{
InteropHelp.TestIfAvailableClient();
return((SteamAPICall_t)NativeMethods.ISteamUserStats_AttachLeaderboardUGC(hSteamLeaderboard, hUGC));
}
public static SteamAPICall_t UGCDownloadToLocation(UGCHandle_t hContent, string pchLocation, uint unPriority)
{
InteropHelp.TestIfAvailableClient();
using InteropHelp.UTF8StringHandle pchLocation2 = new InteropHelp.UTF8StringHandle(pchLocation);
return((SteamAPICall_t)NativeMethods.ISteamRemoteStorage_UGCDownloadToLocation(CSteamAPIContext.GetSteamRemoteStorage(), hContent, pchLocation2, unPriority));
}