/// <summary>
/// <para> this method enumerates the public view of workshop files</para>
/// </summary>
public static SteamAPICall_t EnumeratePublishedWorkshopFiles(EWorkshopEnumerationType eEnumerationType, uint unStartIndex, uint unCount, uint unDays, System.Collections.Generic.IList <string> pTags, System.Collections.Generic.IList <string> pUserTags)
{
InteropHelp.TestIfAvailableClient();
return((SteamAPICall_t)NativeMethods.ISteamRemoteStorage_EnumeratePublishedWorkshopFiles(CSteamAPIContext.GetSteamRemoteStorage(), eEnumerationType, unStartIndex, unCount, unDays, new InteropHelp.SteamParamStringArray(pTags), new InteropHelp.SteamParamStringArray(pUserTags)));
}
public static SteamAPICall_t EnumerateUserSubscribedFiles(uint unStartIndex)
{
InteropHelp.TestIfAvailableClient();
return((SteamAPICall_t)NativeMethods.ISteamRemoteStorage_EnumerateUserSubscribedFiles(CSteamAPIContext.GetSteamRemoteStorage(), unStartIndex));
}
public static bool UpdatePublishedFileSetChangeDescription(PublishedFileUpdateHandle_t updateHandle, string pchChangeDescription)
{
InteropHelp.TestIfAvailableClient();
using (var pchChangeDescription2 = new InteropHelp.UTF8StringHandle(pchChangeDescription)) {
return(NativeMethods.ISteamRemoteStorage_UpdatePublishedFileSetChangeDescription(CSteamAPIContext.GetSteamRemoteStorage(), updateHandle, pchChangeDescription2));
}
}
public static bool UpdatePublishedFileVisibility(PublishedFileUpdateHandle_t updateHandle, ERemoteStoragePublishedFileVisibility eVisibility)
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamRemoteStorage_UpdatePublishedFileVisibility(CSteamAPIContext.GetSteamRemoteStorage(), updateHandle, eVisibility));
}
public static SteamAPICall_t CommitPublishedFileUpdate(PublishedFileUpdateHandle_t updateHandle)
{
InteropHelp.TestIfAvailableClient();
return((SteamAPICall_t)NativeMethods.ISteamRemoteStorage_CommitPublishedFileUpdate(CSteamAPIContext.GetSteamRemoteStorage(), updateHandle));
}
/// <summary>
/// <para> Reset any fetch/persist/etc requests</para>
/// </summary>
public static bool ResetFileRequestState()
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamRemoteStorage_ResetFileRequestState(CSteamAPIContext.GetSteamRemoteStorage()));
}
public static PublishedFileUpdateHandle_t CreatePublishedFileUpdateRequest(PublishedFileId_t unPublishedFileId)
{
InteropHelp.TestIfAvailableClient();
return((PublishedFileUpdateHandle_t)NativeMethods.ISteamRemoteStorage_CreatePublishedFileUpdateRequest(CSteamAPIContext.GetSteamRemoteStorage(), unPublishedFileId));
}
public static string GetFileNameAndSize(int iFile, out int pnFileSizeInBytes)
{
InteropHelp.TestIfAvailableClient();
return(InteropHelp.PtrToStringUTF8(NativeMethods.ISteamRemoteStorage_GetFileNameAndSize(CSteamAPIContext.GetSteamRemoteStorage(), iFile, out pnFileSizeInBytes)));
}
/// <summary>
/// <para> configuration management</para>
/// </summary>
public static bool GetQuota(out ulong pnTotalBytes, out ulong puAvailableBytes)
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamRemoteStorage_GetQuota(CSteamAPIContext.GetSteamRemoteStorage(), out pnTotalBytes, out puAvailableBytes));
}
public static bool FileWriteStreamWriteChunk(UGCFileWriteStreamHandle_t writeHandle, byte[] pvData, int cubData)
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamRemoteStorage_FileWriteStreamWriteChunk(CSteamAPIContext.GetSteamRemoteStorage(), writeHandle, pvData, cubData));
}
public static bool FileWriteStreamCancel(UGCFileWriteStreamHandle_t writeHandle)
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamRemoteStorage_FileWriteStreamCancel(CSteamAPIContext.GetSteamRemoteStorage(), writeHandle));
}
/// <summary>
/// <para> file operations that cause network IO</para>
/// </summary>
public static UGCFileWriteStreamHandle_t FileWriteStreamOpen(string pchFile)
{
InteropHelp.TestIfAvailableClient();
using (var pchFile2 = new InteropHelp.UTF8StringHandle(pchFile)) {
return((UGCFileWriteStreamHandle_t)NativeMethods.ISteamRemoteStorage_FileWriteStreamOpen(CSteamAPIContext.GetSteamRemoteStorage(), pchFile2));
}
}
public static bool FileReadAsyncComplete(SteamAPICall_t hReadCall, byte[] pvBuffer, uint cubToRead)
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamRemoteStorage_FileReadAsyncComplete(CSteamAPIContext.GetSteamRemoteStorage(), hReadCall, pvBuffer, cubToRead));
}
public static SteamAPICall_t UGCDownloadToLocation(UGCHandle_t hContent, string pchLocation, uint unPriority)
{
InteropHelp.TestIfAvailableClient();
using (var pchLocation2 = new InteropHelp.UTF8StringHandle(pchLocation)) {
return((SteamAPICall_t)NativeMethods.ISteamRemoteStorage_UGCDownloadToLocation(CSteamAPIContext.GetSteamRemoteStorage(), hContent, pchLocation2, unPriority));
}
}
/// <summary>
/// <para> The following functions are only necessary on the Playstation 3. On PC & Mac, the Steam client will handle these operations for you</para>
/// <para> On Playstation 3, the game controls which files are stored in the cloud, via FilePersist, FileFetch, and FileForget.</para>
/// <para> Connect to Steam and get a list of files in the Cloud - results in a RemoteStorageAppSyncStatusCheck_t callback</para>
/// </summary>
public static void GetFileListFromServer()
{
InteropHelp.TestIfAvailableClient();
NativeMethods.ISteamRemoteStorage_GetFileListFromServer(CSteamAPIContext.GetSteamRemoteStorage());
}
public static bool IsCloudEnabledForApp()
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamRemoteStorage_IsCloudEnabledForApp(CSteamAPIContext.GetSteamRemoteStorage()));
}
/// <summary>
/// <para> Upload any requested files to the Cloud - results in a RemoteStorageAppSyncedServer_t callback</para>
/// </summary>
public static bool SynchronizeToServer()
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamRemoteStorage_SynchronizeToServer(CSteamAPIContext.GetSteamRemoteStorage()));
}
public static void SetCloudEnabledForApp(bool bEnabled)
{
InteropHelp.TestIfAvailableClient();
NativeMethods.ISteamRemoteStorage_SetCloudEnabledForApp(CSteamAPIContext.GetSteamRemoteStorage(), bEnabled);
}
/// <summary>
/// <para> publishing UGC</para>
/// </summary>
public static SteamAPICall_t PublishWorkshopFile(string pchFile, string pchPreviewFile, AppId_t nConsumerAppId, string pchTitle, string pchDescription, ERemoteStoragePublishedFileVisibility eVisibility, System.Collections.Generic.IList <string> pTags, EWorkshopFileType eWorkshopFileType)
{
InteropHelp.TestIfAvailableClient();
using (var pchFile2 = new InteropHelp.UTF8StringHandle(pchFile))
using (var pchPreviewFile2 = new InteropHelp.UTF8StringHandle(pchPreviewFile))
using (var pchTitle2 = new InteropHelp.UTF8StringHandle(pchTitle))
using (var pchDescription2 = new InteropHelp.UTF8StringHandle(pchDescription)) {
return((SteamAPICall_t)NativeMethods.ISteamRemoteStorage_PublishWorkshopFile(CSteamAPIContext.GetSteamRemoteStorage(), pchFile2, pchPreviewFile2, nConsumerAppId, pchTitle2, pchDescription2, eVisibility, new InteropHelp.SteamParamStringArray(pTags), eWorkshopFileType));
}
}
/// <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(CSteamAPIContext.GetSteamRemoteStorage(), hContent, unPriority));
}
public static bool UpdatePublishedFilePreviewFile(PublishedFileUpdateHandle_t updateHandle, string pchPreviewFile)
{
InteropHelp.TestIfAvailableClient();
using (var pchPreviewFile2 = new InteropHelp.UTF8StringHandle(pchPreviewFile)) {
return(NativeMethods.ISteamRemoteStorage_UpdatePublishedFilePreviewFile(CSteamAPIContext.GetSteamRemoteStorage(), updateHandle, pchPreviewFile2));
}
}
/// <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(CSteamAPIContext.GetSteamRemoteStorage(), hContent, out pnBytesDownloaded, out pnBytesExpected));
}
public static bool UpdatePublishedFileTags(PublishedFileUpdateHandle_t updateHandle, System.Collections.Generic.IList <string> pTags)
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamRemoteStorage_UpdatePublishedFileTags(CSteamAPIContext.GetSteamRemoteStorage(), updateHandle, new InteropHelp.SteamParamStringArray(pTags)));
}
/// <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(CSteamAPIContext.GetSteamRemoteStorage(), hContent, pvData, cubDataToRead, cOffset, eAction));
}
public static SteamAPICall_t FileWriteAsync(string pchFile, byte[] pvData, uint cubData)
{
InteropHelp.TestIfAvailableClient();
using (var pchFile2 = new InteropHelp.UTF8StringHandle(pchFile)) {
return((SteamAPICall_t)NativeMethods.ISteamRemoteStorage_FileWriteAsync(CSteamAPIContext.GetSteamRemoteStorage(), pchFile2, pvData, cubData));
}
}
/// <summary>
/// <para> Functions to iterate through UGC that has finished downloading but has not yet been read via UGCRead()</para>
/// </summary>
public static int GetCachedUGCCount()
{
InteropHelp.TestIfAvailableClient();
return(NativeMethods.ISteamRemoteStorage_GetCachedUGCCount(CSteamAPIContext.GetSteamRemoteStorage()));
}
public static SteamAPICall_t UnsubscribePublishedFile(PublishedFileId_t unPublishedFileId)
{
InteropHelp.TestIfAvailableClient();
return((SteamAPICall_t)NativeMethods.ISteamRemoteStorage_UnsubscribePublishedFile(CSteamAPIContext.GetSteamRemoteStorage(), unPublishedFileId));
}
public static UGCHandle_t GetCachedUGCHandle(int iCachedContent)
{
InteropHelp.TestIfAvailableClient();
return((UGCHandle_t)NativeMethods.ISteamRemoteStorage_GetCachedUGCHandle(CSteamAPIContext.GetSteamRemoteStorage(), iCachedContent));
}
public static SteamAPICall_t GetPublishedItemVoteDetails(PublishedFileId_t unPublishedFileId)
{
InteropHelp.TestIfAvailableClient();
return((SteamAPICall_t)NativeMethods.ISteamRemoteStorage_GetPublishedItemVoteDetails(CSteamAPIContext.GetSteamRemoteStorage(), unPublishedFileId));
}
public static SteamAPICall_t EnumeratePublishedFilesByUserAction(EWorkshopFileAction eAction, uint unStartIndex)
{
InteropHelp.TestIfAvailableClient();
return((SteamAPICall_t)NativeMethods.ISteamRemoteStorage_EnumeratePublishedFilesByUserAction(CSteamAPIContext.GetSteamRemoteStorage(), eAction, unStartIndex));
}