v1.26

Readme.txt

@@ -11,6 +11,20 @@ website at: http://partner.steamgames.com
 
 Revision History:
 
+----------------------------------------------------------------
+v1.26 6th November 2013
+----------------------------------------------------------------
+* Includes libsteam_api.so for 64-bit Linux.
+* Callbacks ValidateAuthTicketResponse_t and GSClientApprove_t now contain the SteamID of the owner of current game. If the game is borrowed, this is different than the player's SteamID.
+* Added ISteamFriends::GetPlayerNickname, which returns the nickname the current user has set for the specified player.
+* Fix p2p networking apis on Linux so they work with dedicated servers
+* Fix command line argument handling bug in SteamAPI_RestartAppIfNecessary on Linux and OSX.
+* Added ISteamApps::GetLaunchQueryParam, which will get the value associated with the given key if a game is launched via a url with query paramaters, such as steam://run/<appid>//?param1=value1;param2=value2;param3=value3.  If the game is already running when such a url is executed, instead it will receive a NewLaunchQueryParameters_t callback.
+* Added EUGCReadAction parameter to ISteamRemoteStorage:UGCRead that allows the game to keep the file open if it needs to seek around the file for arbitrary data, rather than always closing the file when the last byte is read.
+* Added new ISteamUGC interface that is used for querying for lists of UGC details (e.g. Workshop items, screenshots, videos, artwork, guides, etc.). The ISteamUGC interface should be used instead of ISteamRemoteStorage, which contains similar, but less flexible and powerful functionality.
+* Removed tools for deprecated content system
+
+
 ----------------------------------------------------------------
 v1.25 1st October 2013
 ----------------------------------------------------------------

glmgr/glmgrbasics.cpp

@@ -7,9 +7,53 @@
 #include "glmgrbasics.h"
 #include "dxabstract.h"
 
+#if __MAC_OS_X_VERSION_MAX_ALLOWED <= __MAC_10_6
 #include <OpenGL/CGLProfiler.h>
 #include <OpenGL/CGLProfilerFunctionEnum.h>
+#else
+#define kCGLCPComment ((CGLContextParameter)1232)
+/* param is a pointer to a NULL-terminated C-style string. */
+/* Inserts a context-specific comment into the function trace stream. */
+/* Availability: set only, get is ignored. */
 
+#define kCGLCPDumpState ((CGLContextParameter)1233)
+/* param ignored.  Dumps all the gl state. */
+/* Availability: set only, get is ignored. */
+
+#define kCGLCPEnableForceFlush ((CGLContextParameter)1234)
+/* param is GL_TRUE to enable "force flush" mode or GL_FALSE to disable. */
+/* Availability: set and get. */
+
+#define kCGLGOComment ((CGLGlobalOption)1506)
+/* param is a pointer to a NULL-terminated C-style string. */
+/* Inserts a comment in the trace steam that applies to all contexts. */
+/* Availability: set only, get is ignored. */
+
+#define kCGLGOEnableFunctionTrace ((CGLGlobalOption)1507)
+/* param is GL_TRUE or GL_FALSE */
+/* Turns GL function call tracing on and off */
+/* Availability: set and get */
+
+#define kCGLGOResetFunctionTrace ((CGLGlobalOption)1509)
+/* param is ignored */
+/* Erases current function trace and starts a new one */
+/* Availability: set only, get is ignored. */
+
+#define kCGLGOEnableBreakpoint ((CGLGlobalOption)1514)
+/* param is an array of 3 GLints:
+ param[0] is function ID (see CGLProfilerFunctionEnum.h)
+ param[1] is the logical OR of kCGLProfBreakBefore or kCGLProfBreakAfter, indicating how
+ you want the breakpoint to stop: before entering OpenGL, on return from OpenGL, or both.
+ param[2] is a boolean which turns the breakpoint on or off.
+ */
+/* Availability: set and get. */
+
+#define kCGLProfBreakBefore  0x0001
+#define kCGLProfBreakAfter   0x0002
+
+#define kCGLFEglColor4sv 98
+
+#endif
 
 //===============================================================================
 #define TOLOWERC( x )  (( ( x >= 'A' ) && ( x <= 'Z' ) )?( x + 32 ) : x )
@@ -2704,10 +2748,10 @@ bool	GLMDetectOGLP( void )
 	result = error == 0;
 	if (result)
 	{
-		// enable a breakpoint on color4sv
+        // enable a breakpoint on color4sv
 		GLint oglp_bkpt[3] = { kCGLFEglColor4sv, kCGLProfBreakBefore, 1 };
 		
-		CGLSetGlobalOption( kCGLGOEnableBreakpoint, oglp_bkpt );			
+		CGLSetGlobalOption( kCGLGOEnableBreakpoint, oglp_bkpt );
 	}
 	
 	return result;

glmgr/glmgrbasics.h

@@ -21,7 +21,7 @@
 #include <OpenGL/CGLTypes.h>
 #include <OpenGL/CGLRenderers.h>
 #include <OpenGL/CGLCurrent.h>
-#include <OpenGL/CGLProfiler.h>
+//#include <OpenGL/CGLProfiler.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <ApplicationServices/ApplicationServices.h>

public/steam/isteamapps.h

@@ -59,11 +59,19 @@ public:
 
 	virtual bool GetCurrentBetaName( char *pchName, int cchNameBufferSize ) = 0; // returns current beta branch name, 'public' is the default branch
 	virtual bool MarkContentCorrupt( bool bMissingFilesOnly ) = 0; // signal Steam that game files seems corrupt or missing
-	virtual uint32 GetInstalledDepots( DepotId_t *pvecDepots, uint32 cMaxDepots ) = 0; // return installed depots in mount order
+	virtual uint32 GetInstalledDepots( AppId_t appID, DepotId_t *pvecDepots, uint32 cMaxDepots ) = 0; // return installed depots in mount order
 
 	// returns current app install folder for AppID, returns folder name length
 	virtual uint32 GetAppInstallDir( AppId_t appID, char *pchFolder, uint32 cchFolderBufferSize ) = 0;
-	virtual bool BIsAppInstalled( AppId_t appID ) = 0;
+	virtual bool BIsAppInstalled( AppId_t appID ) = 0; // returns true if that app is installed (not necessarily owned)
+	
+	virtual CSteamID GetAppOwner() = 0; // returns the SteamID of the original owner. If different from current user, it's borrowed
+
+	// Returns the associated launch param if the game is run via steam://run/<appid>//?param1=value1;param2=value2;param3=value3 etc.
+	// Parameter names starting with the character '@' are reserved for internal use and will always return and empty string.
+	// Parameter names starting with an underscore '_' are reserved for steam features -- they can be queried by the game,
+	// but it is advised that you not param names beginning with an underscore for your own features.
+	virtual const char *GetLaunchQueryParam( const char *pchKey ) = 0;
 
 #ifdef _PS3
 	// Result returned in a RegisterActivationCodeResponse_t callresult
@@ -71,7 +79,7 @@ public:
 #endif
 };
 
-#define STEAMAPPS_INTERFACE_VERSION "STEAMAPPS_INTERFACE_VERSION005"
+#define STEAMAPPS_INTERFACE_VERSION "STEAMAPPS_INTERFACE_VERSION006"
 
 // callbacks
 #if defined( VALVE_CALLBACK_PACK_SMALL )
@@ -124,5 +132,18 @@ struct AppProofOfPurchaseKeyResponse_t
 	uint32	m_nAppID;
 	char	m_rgchKey[ k_cubAppProofOfPurchaseKeyMax ];
 };
+
+//---------------------------------------------------------------------------------
+// Purpose: posted after the user gains executes a steam url with query parameters
+// such as steam://run/<appid>//?param1=value1;param2=value2;param3=value3; etc
+// while the game is already running.  The new params can be queried
+// with GetLaunchQueryParam.
+//---------------------------------------------------------------------------------
+struct NewLaunchQueryParameters_t
+{
+	enum { k_iCallback = k_iSteamAppsCallbacks + 14 };
+};
+
+
 #pragma pack( pop )
 #endif // ISTEAMAPPS_H

public/steam/isteamclient.h

@@ -87,6 +87,8 @@ class ISteamGameServerStats;
 class ISteamPS3OverlayRender;
 class ISteamHTTP;
 class ISteamUnifiedMessages;
+class ISteamController;
+class ISteamUGC;
 
 //-----------------------------------------------------------------------------
 // Purpose: Interface to creating a new steam instance, or to
@@ -189,6 +191,11 @@ public:
 	// Exposes the ISteamUnifiedMessages interface
 	virtual ISteamUnifiedMessages *GetISteamUnifiedMessages( HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
 
+	// Exposes the ISteamController interface
+	virtual ISteamController *GetISteamController( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
+
+	// Exposes the ISteamUGC interface
+	virtual ISteamUGC *GetISteamUGC( HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion ) = 0;
 };
 
 #define STEAMCLIENT_INTERFACE_VERSION		"SteamClient012"
@@ -229,6 +236,10 @@ enum { k_iClientParentalSettingsCallbacks = 2900 };
 enum { k_iClientDeviceAuthCallbacks = 3000 };
 enum { k_iClientNetworkDeviceManagerCallbacks = 3100 };
 enum { k_iClientMusicCallbacks = 3200 };
+enum { k_iClientRemoteClientManagerCallbacks = 3300 };
+enum { k_iClientUGCCallbacks = 3400 };
+enum { k_iSteamStreamClientCallbacks = 3500 };
+enum { k_IClientProductBuilderCallbacks = 3600 };
 
 
 //-----------------------------------------------------------------------------

public/steam/isteamfriends.h

@@ -203,6 +203,9 @@ public:
 	// accesses old friends names - returns an empty string when their are no more items in the history
 	virtual const char *GetFriendPersonaNameHistory( CSteamID steamIDFriend, int iPersonaName ) = 0;
 
+	// Returns nickname the current user has set for the specified player. Returns NULL if the no nickname has been set for that player.
+	virtual const char *GetPlayerNickname( CSteamID steamIDPlayer ) = 0;
+
 	// returns true if the specified user meets any of the criteria specified in iFriendFlags
 	// iFriendFlags can be the union (binary or, |) of one or more k_EFriendFlags values
 	virtual bool HasFriend( CSteamID steamIDFriend, int iFriendFlags ) = 0;
@@ -340,7 +343,7 @@ public:
 	virtual int GetClanChatMemberCount( CSteamID steamIDClan ) = 0;
 	virtual CSteamID GetChatMemberByIndex( CSteamID steamIDClan, int iUser ) = 0;
 	virtual bool SendClanChatMessage( CSteamID steamIDClanChat, const char *pchText ) = 0;
-	virtual int GetClanChatMessage( CSteamID steamIDClanChat, int iMessage, void *prgchText, int cchTextMax, EChatEntryType *, CSteamID * ) = 0;
+	virtual int GetClanChatMessage( CSteamID steamIDClanChat, int iMessage, void *prgchText, int cchTextMax, EChatEntryType *peChatEntryType, CSteamID *psteamidChatter ) = 0;
 	virtual bool IsClanChatAdmin( CSteamID steamIDClanChat, CSteamID steamIDUser ) = 0;
 
 	// interact with the Steam (game overlay / desktop)
@@ -360,7 +363,7 @@ public:
 	virtual SteamAPICall_t EnumerateFollowingList( uint32 unStartIndex ) = 0;
 };
 
-#define STEAMFRIENDS_INTERFACE_VERSION "SteamFriends013"
+#define STEAMFRIENDS_INTERFACE_VERSION "SteamFriends014"
 
 // callbacks
 #if defined( VALVE_CALLBACK_PACK_SMALL )

public/steam/isteamgamecoordinator.h

@@ -48,6 +48,15 @@ public:
 };
 #define STEAMGAMECOORDINATOR_INTERFACE_VERSION "SteamGameCoordinator001"
 
+// callbacks
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error isteamclient.h must be included
+#endif 
+
 // callback notification - A new message is available for reading from the message queue
 struct GCMessageAvailable_t
 {
@@ -61,4 +70,6 @@ struct GCMessageFailed_t
 	enum { k_iCallback = k_iSteamGameCoordinatorCallbacks + 2 };
 };
 
+#pragma pack( pop )
+
 #endif // ISTEAMGAMECOORDINATOR

public/steam/isteamgameserver.h

@@ -121,7 +121,7 @@ public:
 	/// it allows users to filter in the matchmaking/server-browser interfaces based on the value
 	///
 	/// @see k_cbMaxGameServerTags
-	virtual void SetGameTags( const char *pchGameTags ) = 0; 
+	virtual void SetGameTags( const char *pchGameTags ) = 0;
 
 	/// Sets a string defining the "gamedata" for this server, this is optional, but if it is set
 	/// it allows users to filter in the matchmaking/server-browser interfaces based on the value
@@ -129,7 +129,7 @@ public:
 	/// acknowledged)
 	///
 	/// @see k_cbMaxGameServerGameData
-	virtual void SetGameData( const char *pchGameData) = 0; 
+	virtual void SetGameData( const char *pchGameData ) = 0;
 
 	/// Region identifier.  This is an optional field, the default value is empty, meaning the "world" region
 	virtual void SetRegion( const char *pszRegion ) = 0;
@@ -284,7 +284,8 @@ const uint32 k_unServerFlagPrivate		= 0x20;		// server shouldn't list on master
 struct GSClientApprove_t
 {
 	enum { k_iCallback = k_iSteamGameServerCallbacks + 1 };
-	CSteamID m_SteamID;
+	CSteamID m_SteamID;			// SteamID of approved player
+	CSteamID m_OwnerSteamID;	// SteamID of original owner for game license
 };
 
 

public/steam/isteamremotestorage.h

@@ -104,7 +104,7 @@ enum EWorkshopFileType
 
 	// Update k_EWorkshopFileTypeMax if you add values
 	k_EWorkshopFileTypeMax = 14
-
+	
 };
 
 enum EWorkshopVote
@@ -165,124 +165,124 @@ enum EUGCReadAction
 //-----------------------------------------------------------------------------
 class ISteamRemoteStorage
 {
-public:
-	// NOTE
-	//
-	// Filenames are case-insensitive, and will be converted to lowercase automatically.
-	// So "foo.bar" and "Foo.bar" are the same file, and if you write "Foo.bar" then
-	// iterate the files, the filename returned will be "foo.bar".
-	//
+	public:
+		// NOTE
+		//
+		// Filenames are case-insensitive, and will be converted to lowercase automatically.
+		// So "foo.bar" and "Foo.bar" are the same file, and if you write "Foo.bar" then
+		// iterate the files, the filename returned will be "foo.bar".
+		//
 
-	// file operations
-	virtual bool	FileWrite( const char *pchFile, const void *pvData, int32 cubData ) = 0;
-	virtual int32	FileRead( const char *pchFile, void *pvData, int32 cubDataToRead ) = 0;
-	virtual bool	FileForget( const char *pchFile ) = 0;
-	virtual bool	FileDelete( const char *pchFile ) = 0;
-	virtual SteamAPICall_t FileShare( const char *pchFile ) = 0;
-	virtual bool	SetSyncPlatforms( const char *pchFile, ERemoteStoragePlatform eRemoteStoragePlatform ) = 0;
+		// file operations
+		virtual bool	FileWrite( const char *pchFile, const void *pvData, int32 cubData ) = 0;
+		virtual int32	FileRead( const char *pchFile, void *pvData, int32 cubDataToRead ) = 0;
+		virtual bool	FileForget( const char *pchFile ) = 0;
+		virtual bool	FileDelete( const char *pchFile ) = 0;
+		virtual SteamAPICall_t FileShare( const char *pchFile ) = 0;
+		virtual bool	SetSyncPlatforms( const char *pchFile, ERemoteStoragePlatform eRemoteStoragePlatform ) = 0;
 
-	// file operations that cause network IO
-	virtual UGCFileWriteStreamHandle_t FileWriteStreamOpen( const char *pchFile ) = 0;
-	virtual bool FileWriteStreamWriteChunk( UGCFileWriteStreamHandle_t writeHandle, const void *pvData, int32 cubData ) = 0;
-	virtual bool FileWriteStreamClose( UGCFileWriteStreamHandle_t writeHandle ) = 0;
-	virtual bool FileWriteStreamCancel( UGCFileWriteStreamHandle_t writeHandle ) = 0;
+		// file operations that cause network IO
+		virtual UGCFileWriteStreamHandle_t FileWriteStreamOpen( const char *pchFile ) = 0;
+		virtual bool FileWriteStreamWriteChunk( UGCFileWriteStreamHandle_t writeHandle, const void *pvData, int32 cubData ) = 0;
+		virtual bool FileWriteStreamClose( UGCFileWriteStreamHandle_t writeHandle ) = 0;
+		virtual bool FileWriteStreamCancel( UGCFileWriteStreamHandle_t writeHandle ) = 0;
 
-	// file information
-	virtual bool	FileExists( const char *pchFile ) = 0;
-	virtual bool	FilePersisted( const char *pchFile ) = 0;
-	virtual int32	GetFileSize( const char *pchFile ) = 0;
-	virtual int64	GetFileTimestamp( const char *pchFile ) = 0;
-	virtual ERemoteStoragePlatform GetSyncPlatforms( const char *pchFile ) = 0;
+		// file information
+		virtual bool	FileExists( const char *pchFile ) = 0;
+		virtual bool	FilePersisted( const char *pchFile ) = 0;
+		virtual int32	GetFileSize( const char *pchFile ) = 0;
+		virtual int64	GetFileTimestamp( const char *pchFile ) = 0;
+		virtual ERemoteStoragePlatform GetSyncPlatforms( const char *pchFile ) = 0;
 
-	// iteration
-	virtual int32 GetFileCount() = 0;
-	virtual const char *GetFileNameAndSize( int iFile, int32 *pnFileSizeInBytes ) = 0;
+		// iteration
+		virtual int32 GetFileCount() = 0;
+		virtual const char *GetFileNameAndSize( int iFile, int32 *pnFileSizeInBytes ) = 0;
 
-	// configuration management
-	virtual bool GetQuota( int32 *pnTotalBytes, int32 *puAvailableBytes ) = 0;
-	virtual bool IsCloudEnabledForAccount() = 0;
-	virtual bool IsCloudEnabledForApp() = 0;
-	virtual void SetCloudEnabledForApp( bool bEnabled ) = 0;
+		// configuration management
+		virtual bool GetQuota( int32 *pnTotalBytes, int32 *puAvailableBytes ) = 0;
+		virtual bool IsCloudEnabledForAccount() = 0;
+		virtual bool IsCloudEnabledForApp() = 0;
+		virtual void SetCloudEnabledForApp( bool bEnabled ) = 0;
 
-	// user generated content
+		// 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.
-	virtual SteamAPICall_t UGCDownload( UGCHandle_t hContent, uint32 unPriority ) = 0;
+		// 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.
+		virtual SteamAPICall_t UGCDownload( UGCHandle_t hContent, uint32 unPriority ) = 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
+		virtual bool	GetUGCDownloadProgress( UGCHandle_t hContent, int32 *pnBytesDownloaded, int32 *pnBytesExpected ) = 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
-	virtual bool	GetUGCDownloadProgress( UGCHandle_t hContent, int32 *pnBytesDownloaded, int32 *pnBytesExpected ) = 0;
+		// Gets metadata for a file after it has been downloaded. This is the same metadata given in the RemoteStorageDownloadUGCResult_t call result
+		virtual bool	GetUGCDetails( UGCHandle_t hContent, AppId_t *pnAppID, char **ppchName, int32 *pnFileSizeInBytes, CSteamID *pSteamIDOwner ) = 0;
 
-	// Gets metadata for a file after it has been downloaded. This is the same metadata given in the RemoteStorageDownloadUGCResult_t call result
-	virtual bool	GetUGCDetails( UGCHandle_t hContent, AppId_t *pnAppID, char **ppchName, int32 *pnFileSizeInBytes, CSteamID *pSteamIDOwner ) = 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.
+		virtual int32	UGCRead( UGCHandle_t hContent, void *pvData, int32 cubDataToRead, uint32 cOffset, EUGCReadAction eAction ) = 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.
-	virtual int32	UGCRead( UGCHandle_t hContent, void *pvData, int32 cubDataToRead, uint32 cOffset ) = 0;
-
-	// Functions to iterate through UGC that has finished downloading but has not yet been read via UGCRead()
-	virtual int32	GetCachedUGCCount() = 0;
-	virtual	UGCHandle_t GetCachedUGCHandle( int32 iCachedContent ) = 0;
-
-	// The following functions are only necessary on the Playstation 3. On PC & Mac, the Steam client will handle these operations for you
-	// On Playstation 3, the game controls which files are stored in the cloud, via FilePersist, FileFetch, and FileForget.
+		// Functions to iterate through UGC that has finished downloading but has not yet been read via UGCRead()
+		virtual int32	GetCachedUGCCount() = 0;
+		virtual	UGCHandle_t GetCachedUGCHandle( int32 iCachedContent ) = 0;
 
+		// The following functions are only necessary on the Playstation 3. On PC & Mac, the Steam client will handle these operations for you
+		// On Playstation 3, the game controls which files are stored in the cloud, via FilePersist, FileFetch, and FileForget.
+			
 #if defined(_PS3) || defined(_SERVER)
-	// Connect to Steam and get a list of files in the Cloud - results in a RemoteStorageAppSyncStatusCheck_t callback
-	virtual void GetFileListFromServer() = 0;
-	// Indicate this file should be downloaded in the next sync
-	virtual bool FileFetch( const char *pchFile ) = 0;
-	// Indicate this file should be persisted in the next sync
-	virtual bool FilePersist( const char *pchFile ) = 0;
-	// Pull any requested files down from the Cloud - results in a RemoteStorageAppSyncedClient_t callback
-	virtual bool SynchronizeToClient() = 0;
-	// Upload any requested files to the Cloud - results in a RemoteStorageAppSyncedServer_t callback
-	virtual bool SynchronizeToServer() = 0;
-	// Reset any fetch/persist/etc requests
-	virtual bool ResetFileRequestState() = 0;
+		// Connect to Steam and get a list of files in the Cloud - results in a RemoteStorageAppSyncStatusCheck_t callback
+		virtual void GetFileListFromServer() = 0;
+		// Indicate this file should be downloaded in the next sync
+		virtual bool FileFetch( const char *pchFile ) = 0;
+		// Indicate this file should be persisted in the next sync
+		virtual bool FilePersist( const char *pchFile ) = 0;
+		// Pull any requested files down from the Cloud - results in a RemoteStorageAppSyncedClient_t callback
+		virtual bool SynchronizeToClient() = 0;
+		// Upload any requested files to the Cloud - results in a RemoteStorageAppSyncedServer_t callback
+		virtual bool SynchronizeToServer() = 0;
+		// Reset any fetch/persist/etc requests
+		virtual bool ResetFileRequestState() = 0;
 #endif
 
-	// publishing UGC
-	virtual SteamAPICall_t	PublishWorkshopFile( const char *pchFile, const char *pchPreviewFile, AppId_t nConsumerAppId, const char *pchTitle, const char *pchDescription, ERemoteStoragePublishedFileVisibility eVisibility, SteamParamStringArray_t *pTags, EWorkshopFileType eWorkshopFileType ) = 0;
-	virtual PublishedFileUpdateHandle_t CreatePublishedFileUpdateRequest( PublishedFileId_t unPublishedFileId ) = 0;
-	virtual bool UpdatePublishedFileFile( PublishedFileUpdateHandle_t updateHandle, const char *pchFile ) = 0;
-	virtual bool UpdatePublishedFilePreviewFile( PublishedFileUpdateHandle_t updateHandle, const char *pchPreviewFile ) = 0;
-	virtual bool UpdatePublishedFileTitle( PublishedFileUpdateHandle_t updateHandle, const char *pchTitle ) = 0;
-	virtual bool UpdatePublishedFileDescription( PublishedFileUpdateHandle_t updateHandle, const char *pchDescription ) = 0;
-	virtual bool UpdatePublishedFileVisibility( PublishedFileUpdateHandle_t updateHandle, ERemoteStoragePublishedFileVisibility eVisibility ) = 0;
-	virtual bool UpdatePublishedFileTags( PublishedFileUpdateHandle_t updateHandle, SteamParamStringArray_t *pTags ) = 0;
-	virtual SteamAPICall_t	CommitPublishedFileUpdate( PublishedFileUpdateHandle_t updateHandle ) = 0;
-	// Gets published file details for the given publishedfileid.  If unMaxSecondsOld is greater than 0,
-	// cached data may be returned, depending on how long ago it was cached.  A value of 0 will force a refresh.
-	// A value of k_WorkshopForceLoadPublishedFileDetailsFromCache will use cached data if it exists, no matter how old it is.
-	virtual SteamAPICall_t	GetPublishedFileDetails( PublishedFileId_t unPublishedFileId, uint32 unMaxSecondsOld ) = 0;
-	virtual SteamAPICall_t	DeletePublishedFile( PublishedFileId_t unPublishedFileId ) = 0;
-	// enumerate the files that the current user published with this app
-	virtual SteamAPICall_t	EnumerateUserPublishedFiles( uint32 unStartIndex ) = 0;
-	virtual SteamAPICall_t	SubscribePublishedFile( PublishedFileId_t unPublishedFileId ) = 0;
-	virtual SteamAPICall_t	EnumerateUserSubscribedFiles( uint32 unStartIndex ) = 0;
-	virtual SteamAPICall_t	UnsubscribePublishedFile( PublishedFileId_t unPublishedFileId ) = 0;
-	virtual bool UpdatePublishedFileSetChangeDescription( PublishedFileUpdateHandle_t updateHandle, const char *pchChangeDescription ) = 0;
-	virtual SteamAPICall_t	GetPublishedItemVoteDetails( PublishedFileId_t unPublishedFileId ) = 0;
-	virtual SteamAPICall_t	UpdateUserPublishedItemVote( PublishedFileId_t unPublishedFileId, bool bVoteUp ) = 0;
-	virtual SteamAPICall_t	GetUserPublishedItemVoteDetails( PublishedFileId_t unPublishedFileId ) = 0;
-	virtual SteamAPICall_t	EnumerateUserSharedWorkshopFiles( CSteamID steamId, uint32 unStartIndex, SteamParamStringArray_t *pRequiredTags, SteamParamStringArray_t *pExcludedTags ) = 0;
-	virtual SteamAPICall_t	PublishVideo( EWorkshopVideoProvider eVideoProvider, const char *pchVideoAccount, const char *pchVideoIdentifier, const char *pchPreviewFile, AppId_t nConsumerAppId, const char *pchTitle, const char *pchDescription, ERemoteStoragePublishedFileVisibility eVisibility, SteamParamStringArray_t *pTags ) = 0;
-	virtual SteamAPICall_t	SetUserPublishedFileAction( PublishedFileId_t unPublishedFileId, EWorkshopFileAction eAction ) = 0;
-	virtual SteamAPICall_t	EnumeratePublishedFilesByUserAction( EWorkshopFileAction eAction, uint32 unStartIndex ) = 0;
-	// this method enumerates the public view of workshop files
-	virtual SteamAPICall_t	EnumeratePublishedWorkshopFiles( EWorkshopEnumerationType eEnumerationType, uint32 unStartIndex, uint32 unCount, uint32 unDays, SteamParamStringArray_t *pTags, SteamParamStringArray_t *pUserTags ) = 0;
+		// publishing UGC
+		virtual SteamAPICall_t	PublishWorkshopFile( const char *pchFile, const char *pchPreviewFile, AppId_t nConsumerAppId, const char *pchTitle, const char *pchDescription, ERemoteStoragePublishedFileVisibility eVisibility, SteamParamStringArray_t *pTags, EWorkshopFileType eWorkshopFileType ) = 0;
+		virtual PublishedFileUpdateHandle_t CreatePublishedFileUpdateRequest( PublishedFileId_t unPublishedFileId ) = 0;
+		virtual bool UpdatePublishedFileFile( PublishedFileUpdateHandle_t updateHandle, const char *pchFile ) = 0;
+		virtual bool UpdatePublishedFilePreviewFile( PublishedFileUpdateHandle_t updateHandle, const char *pchPreviewFile ) = 0;
+		virtual bool UpdatePublishedFileTitle( PublishedFileUpdateHandle_t updateHandle, const char *pchTitle ) = 0;
+		virtual bool UpdatePublishedFileDescription( PublishedFileUpdateHandle_t updateHandle, const char *pchDescription ) = 0;
+		virtual bool UpdatePublishedFileVisibility( PublishedFileUpdateHandle_t updateHandle, ERemoteStoragePublishedFileVisibility eVisibility ) = 0;
+		virtual bool UpdatePublishedFileTags( PublishedFileUpdateHandle_t updateHandle, SteamParamStringArray_t *pTags ) = 0;
+		virtual SteamAPICall_t	CommitPublishedFileUpdate( PublishedFileUpdateHandle_t updateHandle ) = 0;
+		// Gets published file details for the given publishedfileid.  If unMaxSecondsOld is greater than 0,
+		// cached data may be returned, depending on how long ago it was cached.  A value of 0 will force a refresh.
+		// A value of k_WorkshopForceLoadPublishedFileDetailsFromCache will use cached data if it exists, no matter how old it is.
+		virtual SteamAPICall_t	GetPublishedFileDetails( PublishedFileId_t unPublishedFileId, uint32 unMaxSecondsOld ) = 0;
+		virtual SteamAPICall_t	DeletePublishedFile( PublishedFileId_t unPublishedFileId ) = 0;
+		// enumerate the files that the current user published with this app
+		virtual SteamAPICall_t	EnumerateUserPublishedFiles( uint32 unStartIndex ) = 0;
+		virtual SteamAPICall_t	SubscribePublishedFile( PublishedFileId_t unPublishedFileId ) = 0;
+		virtual SteamAPICall_t	EnumerateUserSubscribedFiles( uint32 unStartIndex ) = 0;
+		virtual SteamAPICall_t	UnsubscribePublishedFile( PublishedFileId_t unPublishedFileId ) = 0;
+		virtual bool UpdatePublishedFileSetChangeDescription( PublishedFileUpdateHandle_t updateHandle, const char *pchChangeDescription ) = 0;
+		virtual SteamAPICall_t	GetPublishedItemVoteDetails( PublishedFileId_t unPublishedFileId ) = 0;
+		virtual SteamAPICall_t	UpdateUserPublishedItemVote( PublishedFileId_t unPublishedFileId, bool bVoteUp ) = 0;
+		virtual SteamAPICall_t	GetUserPublishedItemVoteDetails( PublishedFileId_t unPublishedFileId ) = 0;
+		virtual SteamAPICall_t	EnumerateUserSharedWorkshopFiles( CSteamID steamId, uint32 unStartIndex, SteamParamStringArray_t *pRequiredTags, SteamParamStringArray_t *pExcludedTags ) = 0;
+		virtual SteamAPICall_t	PublishVideo( EWorkshopVideoProvider eVideoProvider, const char *pchVideoAccount, const char *pchVideoIdentifier, const char *pchPreviewFile, AppId_t nConsumerAppId, const char *pchTitle, const char *pchDescription, ERemoteStoragePublishedFileVisibility eVisibility, SteamParamStringArray_t *pTags ) = 0;
+		virtual SteamAPICall_t	SetUserPublishedFileAction( PublishedFileId_t unPublishedFileId, EWorkshopFileAction eAction ) = 0;
+		virtual SteamAPICall_t	EnumeratePublishedFilesByUserAction( EWorkshopFileAction eAction, uint32 unStartIndex ) = 0;
+		// this method enumerates the public view of workshop files
+		virtual SteamAPICall_t	EnumeratePublishedWorkshopFiles( EWorkshopEnumerationType eEnumerationType, uint32 unStartIndex, uint32 unCount, uint32 unDays, SteamParamStringArray_t *pTags, SteamParamStringArray_t *pUserTags ) = 0;
 
-	virtual SteamAPICall_t UGCDownloadToLocation( UGCHandle_t hContent, const char *pchLocation, uint32 unPriority ) = 0;
+		virtual SteamAPICall_t UGCDownloadToLocation( UGCHandle_t hContent, const char *pchLocation, uint32 unPriority ) = 0;
 };
 
-#define STEAMREMOTESTORAGE_INTERFACE_VERSION "STEAMREMOTESTORAGE_INTERFACE_VERSION011"
+#define STEAMREMOTESTORAGE_INTERFACE_VERSION "STEAMREMOTESTORAGE_INTERFACE_VERSION012"
 
 
 // callbacks
@@ -433,9 +433,9 @@ struct RemoteStorageEnumerateUserSubscribedFilesResult_t
 };
 
 #if defined(VALVE_CALLBACK_PACK_SMALL)
-VALVE_COMPILE_TIME_ASSERT( sizeof( RemoteStorageEnumerateUserSubscribedFilesResult_t ) == (1 + 1 + 1 + 50 + 100) * 4 );
+	VALVE_COMPILE_TIME_ASSERT( sizeof( RemoteStorageEnumerateUserSubscribedFilesResult_t ) == (1 + 1 + 1 + 50 + 100) * 4 );
 #elif defined(VALVE_CALLBACK_PACK_LARGE)
-VALVE_COMPILE_TIME_ASSERT( sizeof( RemoteStorageEnumerateUserSubscribedFilesResult_t ) == (1 + 1 + 1 + 50 + 100) * 4 + 4 );
+	VALVE_COMPILE_TIME_ASSERT( sizeof( RemoteStorageEnumerateUserSubscribedFilesResult_t ) == (1 + 1 + 1 + 50 + 100) * 4 + 4 );
 #else
 #warning You must first include isteamclient.h
 #endif
@@ -504,6 +504,7 @@ struct RemoteStorageGetPublishedFileDetailsResult_t
 	int32 m_nPreviewFileSize;		// Size of the preview file
 	char m_rgchURL[k_cchPublishedFileURLMax];	// URL (for a video or a website)
 	EWorkshopFileType m_eFileType;	// Type of the file
+	bool m_bAcceptedForUse;			// developer has specifically flagged this item as accepted in the Workshop
 };
 
 

public/steam/isteamugc.h

@@ -0,0 +1,192 @@
+//====== Copyright 1996-2013, Valve Corporation, All rights reserved. =======
+//
+// Purpose: interface to steam ugc
+//
+//=============================================================================
+
+#ifndef ISTEAMUGC_H
+#define ISTEAMUGC_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "isteamclient.h"
+
+// callbacks
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error isteamclient.h must be included
+#endif 
+
+
+typedef uint64 UGCQueryHandle_t;
+
+const UGCQueryHandle_t k_UGCQueryHandleInvalid = 0xffffffffffffffffull;
+
+// Matching UGC types for queries
+enum EUGCMatchingUGCType
+{
+	k_EUGCMatchingUGCType_Items				 = 0,		// both mtx items and ready-to-use items
+	k_EUGCMatchingUGCType_Items_Mtx			 = 1,
+	k_EUGCMatchingUGCType_Items_ReadyToUse	 = 2,
+	k_EUGCMatchingUGCType_Collections		 = 3,
+	k_EUGCMatchingUGCType_Artwork			 = 4,
+	k_EUGCMatchingUGCType_Videos			 = 5,
+	k_EUGCMatchingUGCType_Screenshots		 = 6,
+	k_EUGCMatchingUGCType_AllGuides			 = 7,		// both web guides and integrated guides
+	k_EUGCMatchingUGCType_WebGuides			 = 8,
+	k_EUGCMatchingUGCType_IntegratedGuides	 = 9,
+	k_EUGCMatchingUGCType_UsableInGame		 = 10,		// ready-to-use items and integrated guides
+	k_EUGCMatchingUGCType_ControllerBindings = 11,
+};
+
+// Different lists of published UGC for a user.
+// If the current logged in user is different than the specified user, then some options may not be allowed.
+enum EUserUGCList
+{
+	k_EUserUGCList_Published,
+	k_EUserUGCList_VotedOn,
+	k_EUserUGCList_VotedUp,
+	k_EUserUGCList_VotedDown,
+	k_EUserUGCList_WillVoteLater,
+	k_EUserUGCList_Favorited,
+	k_EUserUGCList_Subscribed,
+	k_EUserUGCList_UsedOrPlayed,
+	k_EUserUGCList_Followed,
+};
+
+// Sort order for user published UGC lists (defaults to creation order descending)
+enum EUserUGCListSortOrder
+{
+	k_EUserUGCListSortOrder_CreationOrderDesc,
+	k_EUserUGCListSortOrder_CreationOrderAsc,
+	k_EUserUGCListSortOrder_TitleAsc,
+	k_EUserUGCListSortOrder_LastUpdatedDesc,
+	k_EUserUGCListSortOrder_SubscriptionDateDesc,
+	k_EUserUGCListSortOrder_VoteScoreDesc,
+	k_EUserUGCListSortOrder_ForModeration,
+};
+
+// Combination of sorting and filtering for queries across all UGC
+enum EUGCQuery
+{
+	k_EUGCQuery_RankedByVote								  = 0,
+	k_EUGCQuery_RankedByPublicationDate						  = 1,
+	k_EUGCQuery_AcceptedForGameRankedByAcceptanceDate		  = 2,
+	k_EUGCQuery_RankedByTrend								  = 3,
+	k_EUGCQuery_FavoritedByFriendsRankedByPublicationDate	  = 4,
+	k_EUGCQuery_CreatedByFriendsRankedByPublicationDate		  = 5,
+	k_EUGCQuery_RankedByNumTimesReported					  = 6,
+	k_EUGCQuery_CreatedByFollowedUsersRankedByPublicationDate = 7,
+	k_EUGCQuery_NotYetRated									  = 8,
+	k_EUGCQuery_RankedByTotalVotesAsc						  = 9,
+	k_EUGCQuery_RankedByVotesUp								  = 10,
+	k_EUGCQuery_RankedByTextSearch							  = 11,
+};
+
+
+const uint32 kNumUGCResultsPerPage = 50;
+
+// Details for a single published file/UGC
+struct SteamUGCDetails_t
+{
+	PublishedFileId_t m_nPublishedFileId;
+	EResult m_eResult;												// The result of the operation.	
+	EWorkshopFileType m_eFileType;									// Type of the file
+	AppId_t m_nCreatorAppID;										// ID of the app that created this file.
+	AppId_t m_nConsumerAppID;										// ID of the app that will consume this file.
+	char m_rgchTitle[k_cchPublishedDocumentTitleMax];				// title of document
+	char m_rgchDescription[k_cchPublishedDocumentDescriptionMax];	// description of document
+	uint64 m_ulSteamIDOwner;										// Steam ID of the user who created this content.
+	uint32 m_rtimeCreated;											// time when the published file was created
+	uint32 m_rtimeUpdated;											// time when the published file was last updated
+	uint32 m_rtimeAddedToUserList;									// time when the user added the published file to their list (not always applicable)
+	ERemoteStoragePublishedFileVisibility m_eVisibility;			// visibility
+	bool m_bBanned;													// whether the file was banned
+	bool m_bAcceptedForUse;											// developer has specifically flagged this item as accepted in the Workshop
+	bool m_bTagsTruncated;											// whether the list of tags was too long to be returned in the provided buffer
+	char m_rgchTags[k_cchTagListMax];								// comma separated list of all tags associated with this file	
+	// file/url information
+	UGCHandle_t m_hFile;											// The handle of the primary file
+	UGCHandle_t m_hPreviewFile;										// The handle of the preview file
+	char m_pchFileName[k_cchFilenameMax];							// The cloud filename of the primary file
+	int32 m_nFileSize;												// Size of the primary file
+	int32 m_nPreviewFileSize;										// Size of the preview file
+	char m_rgchURL[k_cchPublishedFileURLMax];						// URL (for a video or a website)
+	// voting information
+	uint32 m_unVotesUp;												// number of votes up
+	uint32 m_unVotesDown;											// number of votes down
+	float m_flScore;												// calculated score
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Steam UGC support API
+//-----------------------------------------------------------------------------
+class ISteamUGC
+{
+public:
+
+	// Query UGC associated with a user. Creator app id or consumer app id must be valid and be set to the current running app.
+	virtual UGCQueryHandle_t CreateQueryUserUGCRequest( AccountID_t unAccountID, EUserUGCList eListType, EUGCMatchingUGCType eMatchingUGCType, EUserUGCListSortOrder eSortOrder, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage ) = 0;
+
+	// Query for all matching UGC. Creator app id or consumer app id must be valid and be set to the current running app.
+	virtual UGCQueryHandle_t CreateQueryAllUGCRequest( EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage ) = 0;
+
+	// Send the query to Steam
+	virtual SteamAPICall_t SendQueryUGCRequest( UGCQueryHandle_t handle ) = 0;
+
+	// Retrieve an individual result after receiving the callback for querying UGC
+	virtual bool GetQueryUGCResult( UGCQueryHandle_t handle, uint32 index, SteamUGCDetails_t *pDetails ) = 0;
+
+	// Release the request to free up memory, after retrieving results
+	virtual bool ReleaseQueryUGCRequest( UGCQueryHandle_t handle ) = 0;
+
+	// Options to set for querying UGC
+	virtual bool AddRequiredTag( UGCQueryHandle_t handle, const char *pTagName ) = 0;
+	virtual bool AddExcludedTag( UGCQueryHandle_t handle, const char *pTagName ) = 0;
+	virtual bool SetReturnLongDescription( UGCQueryHandle_t handle, bool bReturnLongDescription ) = 0;
+	virtual bool SetReturnTotalOnly( UGCQueryHandle_t handle, bool bReturnTotalOnly ) = 0;
+
+	// Options only for querying user UGC
+	virtual bool SetCloudFileNameFilter( UGCQueryHandle_t handle, const char *pMatchCloudFileName ) = 0;
+
+	// Options only for querying all UGC
+	virtual bool SetMatchAnyTag( UGCQueryHandle_t handle, bool bMatchAnyTag ) = 0;
+	virtual bool SetSearchText( UGCQueryHandle_t handle, const char *pSearchText ) = 0;
+	virtual bool SetRankedByTrendDays( UGCQueryHandle_t handle, uint32 unDays ) = 0;
+
+	// Request full details for one piece of UGC
+	virtual SteamAPICall_t RequestUGCDetails( PublishedFileId_t nPublishedFileID ) = 0;
+
+};
+
+#define STEAMUGC_INTERFACE_VERSION "STEAMUGC_INTERFACE_VERSION001"
+
+//-----------------------------------------------------------------------------
+// Purpose: Callback for querying UGC
+//-----------------------------------------------------------------------------
+struct SteamUGCQueryCompleted_t
+{
+	enum { k_iCallback = k_iClientUGCCallbacks + 1 };
+	UGCQueryHandle_t m_handle;
+	EResult m_eResult;
+	uint32 m_unNumResultsReturned;
+	uint32 m_unTotalMatchingResults;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Callback for requesting details on one piece of UGC
+//-----------------------------------------------------------------------------
+struct SteamUGCRequestUGCDetailsResult_t
+{
+	enum { k_iCallback = k_iClientUGCCallbacks + 2 };
+	SteamUGCDetails_t m_details;
+};
+
+#pragma pack( pop )
+
+#endif // ISTEAMUGC_H

public/steam/isteamuser.h

@@ -295,6 +295,7 @@ struct ValidateAuthTicketResponse_t
 	enum { k_iCallback = k_iSteamUserCallbacks + 43 };
 	CSteamID m_SteamID;
 	EAuthSessionResponse m_eAuthSessionResponse;
+	CSteamID m_OwnerSteamID; // different from m_SteamID if borrowed
 };
 
 

public/steam/steam_api.h

@@ -23,6 +23,7 @@
 #include "isteamhttp.h"
 #include "isteamunifiedmessages.h"
 #include "isteamcontroller.h"
+#include "isteamugc.h"
 
 #if defined( _PS3 )
 #include "steamps3params.h"
@@ -59,10 +60,10 @@
 //----------------------------------------------------------------------------------------------------------------------------------------------------------//
 
 // S_API void SteamAPI_Init(); (see below)
-S_API void SteamAPI_Shutdown();
+S_API void S_CALLTYPE SteamAPI_Shutdown();
 
 // checks if a local Steam client is running 
-S_API bool SteamAPI_IsSteamRunning();
+S_API bool S_CALLTYPE SteamAPI_IsSteamRunning();
 
 // Detects if your executable was launched through the Steam client, and restarts your game through 
 // the client if necessary. The Steam client will be started if it is not running.
@@ -75,14 +76,14 @@ S_API bool SteamAPI_IsSteamRunning();
 //
 // NOTE: This function should be used only if you are using CEG or not using Steam's DRM. Once applied
 //       to your executable, Steam's DRM will handle restarting through Steam if necessary.
-S_API bool SteamAPI_RestartAppIfNecessary( uint32 unOwnAppID );
+S_API bool S_CALLTYPE SteamAPI_RestartAppIfNecessary( uint32 unOwnAppID );
 
 // crash dump recording functions
-S_API void SteamAPI_WriteMiniDump( uint32 uStructuredExceptionCode, void* pvExceptionInfo, uint32 uBuildID );
-S_API void SteamAPI_SetMiniDumpComment( const char *pchMsg );
+S_API void S_CALLTYPE SteamAPI_WriteMiniDump( uint32 uStructuredExceptionCode, void* pvExceptionInfo, uint32 uBuildID );
+S_API void S_CALLTYPE SteamAPI_SetMiniDumpComment( const char *pchMsg );
 
 // interface pointers, configured by SteamAPI_Init()
-S_API ISteamClient *SteamClient();
+S_API ISteamClient *S_CALLTYPE SteamClient();
 
 
 //
@@ -96,29 +97,30 @@ S_API ISteamClient *SteamClient();
 // functions below to get at the Steam interfaces.
 //
 #ifdef VERSION_SAFE_STEAM_API_INTERFACES
-S_API bool SteamAPI_InitSafe();
+S_API bool S_CALLTYPE SteamAPI_InitSafe();
 #else
 
 #if defined(_PS3)
-S_API bool SteamAPI_Init( SteamPS3Params_t *pParams );
+S_API bool S_CALLTYPE SteamAPI_Init( SteamPS3Params_t *pParams );
 #else
-S_API bool SteamAPI_Init();
+S_API bool S_CALLTYPE SteamAPI_Init();
 #endif
 
-S_API ISteamUser *SteamUser();
-S_API ISteamFriends *SteamFriends();
-S_API ISteamUtils *SteamUtils();
-S_API ISteamMatchmaking *SteamMatchmaking();
-S_API ISteamUserStats *SteamUserStats();
-S_API ISteamApps *SteamApps();
-S_API ISteamNetworking *SteamNetworking();
-S_API ISteamMatchmakingServers *SteamMatchmakingServers();
-S_API ISteamRemoteStorage *SteamRemoteStorage();
-S_API ISteamScreenshots *SteamScreenshots();
-S_API ISteamHTTP *SteamHTTP();
-S_API ISteamUnifiedMessages *SteamUnifiedMessages();
+S_API ISteamUser *S_CALLTYPE SteamUser();
+S_API ISteamFriends *S_CALLTYPE SteamFriends();
+S_API ISteamUtils *S_CALLTYPE SteamUtils();
+S_API ISteamMatchmaking *S_CALLTYPE SteamMatchmaking();
+S_API ISteamUserStats *S_CALLTYPE SteamUserStats();
+S_API ISteamApps *S_CALLTYPE SteamApps();
+S_API ISteamNetworking *S_CALLTYPE SteamNetworking();
+S_API ISteamMatchmakingServers *S_CALLTYPE SteamMatchmakingServers();
+S_API ISteamRemoteStorage *S_CALLTYPE SteamRemoteStorage();
+S_API ISteamScreenshots *S_CALLTYPE SteamScreenshots();
+S_API ISteamHTTP *S_CALLTYPE SteamHTTP();
+S_API ISteamUnifiedMessages *S_CALLTYPE SteamUnifiedMessages();
+S_API ISteamController *S_CALLTYPE SteamController();
 #ifdef _PS3
-S_API ISteamPS3OverlayRender * SteamPS3OverlayRender();
+S_API ISteamPS3OverlayRender *S_CALLTYPE SteamPS3OverlayRender();
 #endif
 #endif // VERSION_SAFE_STEAM_API_INTERFACES
 
@@ -132,16 +134,16 @@ S_API ISteamPS3OverlayRender * SteamPS3OverlayRender();
 //  to as many functions/objects as are registered to it
 //----------------------------------------------------------------------------------------------------------------------------------------------------------//
 
-S_API void SteamAPI_RunCallbacks();
+S_API void S_CALLTYPE SteamAPI_RunCallbacks();
 
 
 
 // functions used by the utility CCallback objects to receive callbacks
-S_API void SteamAPI_RegisterCallback( class CCallbackBase *pCallback, int iCallback );
-S_API void SteamAPI_UnregisterCallback( class CCallbackBase *pCallback );
+S_API void S_CALLTYPE SteamAPI_RegisterCallback( class CCallbackBase *pCallback, int iCallback );
+S_API void S_CALLTYPE SteamAPI_UnregisterCallback( class CCallbackBase *pCallback );
 // functions used by the utility CCallResult objects to receive async call results
-S_API void SteamAPI_RegisterCallResult( class CCallbackBase *pCallback, SteamAPICall_t hAPICall );
-S_API void SteamAPI_UnregisterCallResult( class CCallbackBase *pCallback, SteamAPICall_t hAPICall );
+S_API void S_CALLTYPE SteamAPI_RegisterCallResult( class CCallbackBase *pCallback, SteamAPICall_t hAPICall );
+S_API void S_CALLTYPE SteamAPI_UnregisterCallResult( class CCallbackBase *pCallback, SteamAPICall_t hAPICall );
 
 
 //-----------------------------------------------------------------------------
@@ -397,6 +399,8 @@ public:
 	ISteamScreenshots*	SteamScreenshots()					{ return m_pSteamScreenshots; }
 	ISteamHTTP*			SteamHTTP()							{ return m_pSteamHTTP; }
 	ISteamUnifiedMessages*	SteamUnifiedMessages()			{ return m_pSteamUnifiedMessages; }
+	ISteamController*	SteamController()					{ return m_pController; }
+	ISteamUGC*			SteamUGC()							{ return m_pSteamUGC; }
 #ifdef _PS3
 	ISteamPS3OverlayRender* SteamPS3OverlayRender()		{ return m_pSteamPS3OverlayRender; }
 #endif
@@ -415,6 +419,7 @@ private:
 	ISteamHTTP			*m_pSteamHTTP;
 	ISteamUnifiedMessages*m_pSteamUnifiedMessages;
 	ISteamController	*m_pController;
+	ISteamUGC			*m_pSteamUGC;
 #ifdef _PS3
 	ISteamPS3OverlayRender *m_pSteamPS3OverlayRender;
 #endif
@@ -439,6 +444,8 @@ inline void CSteamAPIContext::Clear()
 	m_pSteamHTTP = NULL;
 	m_pSteamScreenshots = NULL;
 	m_pSteamUnifiedMessages = NULL;
+	m_pController = NULL;
+	m_pSteamUGC = NULL;
 #ifdef _PS3
 	m_pSteamPS3OverlayRender = NULL;
 #endif
@@ -501,6 +508,14 @@ inline bool CSteamAPIContext::Init()
 	if ( !m_pSteamUnifiedMessages )
 		return false;
 
+	m_pController = SteamClient()->GetISteamController( hSteamUser, hSteamPipe, STEAMCONTROLLER_INTERFACE_VERSION );
+	if ( !m_pController )
+		return false;
+
+	m_pSteamUGC = SteamClient()->GetISteamUGC( hSteamUser, hSteamPipe, STEAMUGC_INTERFACE_VERSION );
+	if ( !m_pSteamUGC )
+		return false;
+
 #ifdef _PS3
 	m_pSteamPS3OverlayRender = SteamClient()->GetISteamPS3OverlayRender();
 #endif
@@ -512,13 +527,13 @@ inline bool CSteamAPIContext::Init()
 
 #if defined(USE_BREAKPAD_HANDLER) || defined(STEAM_API_EXPORTS)
 // this should be called before the game initialized the steam APIs
-// pchDate should be of the format "Mmm dd yyyy" (such as from the __DATE __ macro )
-// pchTime should be of the format "hh:mm:ss" (such as from the __TIME __ macro )
+// pchDate should be of the format "Mmm dd yyyy" (such as from the __DATE__ macro )
+// pchTime should be of the format "hh:mm:ss" (such as from the __TIME__ macro )
 // bFullMemoryDumps (Win32 only) -- writes out a uuid-full.dmp in the client/dumps folder
 // pvContext-- can be NULL, will be the void * context passed into m_pfnPreMinidumpCallback
 // PFNPreMinidumpCallback m_pfnPreMinidumpCallback   -- optional callback which occurs just before a .dmp file is written during a crash.  Applications can hook this to allow adding additional information into the .dmp comment stream.
-S_API void SteamAPI_UseBreakpadCrashHandler( char const *pchVersion, char const *pchDate, char const *pchTime, bool bFullMemoryDumps, void *pvContext, PFNPreMinidumpCallback m_pfnPreMinidumpCallback );
-S_API void SteamAPI_SetBreakpadAppID( uint32 unAppID );
+S_API void S_CALLTYPE SteamAPI_UseBreakpadCrashHandler( char const *pchVersion, char const *pchDate, char const *pchTime, bool bFullMemoryDumps, void *pvContext, PFNPreMinidumpCallback m_pfnPreMinidumpCallback );
+S_API void S_CALLTYPE SteamAPI_SetBreakpadAppID( uint32 unAppID );
 #endif
 
 #endif // STEAM_API_H

public/steam/steamclientpublic.h

@@ -102,7 +102,11 @@ enum EResult
 	k_EResultNoMatchingURL = 75,
 	k_EResultBadResponse = 76,					// parse failure, missing field, etc.
 	k_EResultRequirePasswordReEntry = 77,		// The user cannot complete the action until they re-enter their password
-	k_EResultValueOutOfRange = 78				// the value entered is outside the acceptable range
+	k_EResultValueOutOfRange = 78,				// the value entered is outside the acceptable range
+	k_EResultUnexpectedError = 79,				// something happened that we didn't expect to ever happen
+	k_EResultDisabled = 80,						// The requested service has been configured to be unavailable
+	k_EResultInvalidCEGSubmission = 81,			// The set of files submitted to the CEG server are not valid !
+	k_EResultRestrictedDevice = 82,				// The device being used is not allowed to perform this action
 };
 
 // Error codes for use with the voice functions

public/steam/steamhttpenums.h

@@ -20,13 +20,13 @@ enum EHTTPMethod
 	k_EHTTPMethodGET,
 	k_EHTTPMethodHEAD,
 	k_EHTTPMethodPOST,
+	k_EHTTPMethodPUT,
+	k_EHTTPMethodDELETE,
+	k_EHTTPMethodOPTIONS,
 
 	// The remaining HTTP methods are not yet supported, per rfc2616 section 5.1.1 only GET and HEAD are required for 
 	// a compliant general purpose server.  We'll likely add more as we find uses for them.
 
-	k_EHTTPMethodPUT,
-	k_EHTTPMethodDELETE,
-	k_EHTTPMethodOPTIONS,
 	// k_EHTTPMethodTRACE,
 	// k_EHTTPMethodCONNECT
 };

public/steam/steamtypes.h

@@ -10,6 +10,8 @@
 #pragma once
 #endif
 
+#define S_CALLTYPE __cdecl
+
 // Steam-specific types. Defined here so this header file can be included in other code bases.
 #ifndef WCHARTYPES_H
 typedef unsigned char uint8;

tools/ContentTool.cnt

@@ -1,29 +0,0 @@
-:Base ContentTool.hlp
-1 Getting Started
-2 What is ContentTool=IDH_ABOUT_CONTENTTOOL
-2 ContentTool Components=IDH_CONTENTTOOL_COMPONENTS
-2 Overview of Steam Publishing=IDH_CONTENTTOOL_OVERVIEW
-1 Step-by-Step Procedures
-2 Creating a New Depot=IDH_CREATE_NEW_DEPOT
-2 Adding Files to a Depot=IDH_ADDING_FILES
-2 Moving Files in the Depot=IDH_MOVING_FILES
-2 Deleting Files in the Depot=IDH_DELETING_FILES
-2 Assigning Attributes to Files=IDH_ASSIGNING_ATTRIBUTES
-2 Building the Depot=IDH_BUILING_DEPOT
-2 Adding New Versions=IDH_ADDING_NEW_VERSIONS
-2 Modifying Old Versions=IDH_MOD_OLD_VERSIONS
-2 Publishing your Depot=IDH_EDITCONTENT
-1 ContentTool Reference
-2 Menus
-3 File menu=menu_file
-3 Edit menu=menu_edit
-3 View menu=menu_view
-3 Project menu=menu_project
-3 Build menu=menu_build
-3 Reslist menu=menu_reslist
-3 Help menu=menu_help
-2 Scripting
-3 Scripting overview=IDH_SCRIPT_OVERVIEW
-3 Creating script files=IDH_SCRIPT_FILE
-3 Script commands=IDH_SCRIPT_CMDS
-3 Running scripts=IDH_SCRIPT_RUN

tools/linux/README.txt

@@ -40,7 +40,7 @@ For example to run a shell targeting 32-bit architecture:
 
 For example to run a shell targeting 64-bit architecture:
 	shell-amd64.sh
-
+	
 
 Testing
 -------
@@ -61,6 +61,13 @@ You can debug your programs in the runtime environment with run.sh as well:
 	(gdb) r -windowed
 
 
+Steam Depots
+------------
+
+When you are ready to build and upload your Steam depots, you will need to use 
+Steamcmd.exe on a Windows machine.
+
+
 More Info
 ---------