steam ugc

[vg.git] / vg_steam.h

diff --git a/vg_steam.h b/vg_steam.h
index b39da94fb1c0122aa06a843bf0c531ba11f7033f..01c448acf076f6ae33826c91b85d479768b9fd3a 100644 (file)
--- a/vg_steam.h
+++ b/vg_steam.h
@@ -40,6 +40,7 @@ typedef u32 DepotId_t;
 const DepotId_t k_uDepotIdInvalid = 0x0;
 
 typedef u32 RTime32;
+typedef u32 AccountID_t;
 
 enum { k_iSteamUserCallbacks = 100 };
 enum { k_iSteamGameServerCallbacks = 200 };
@@ -56,7 +57,7 @@ enum { k_iSteamNetworkingCallbacks = 1200 };
 enum { k_iSteamNetworkingSocketsCallbacks = 1220 };
 enum { k_iSteamNetworkingMessagesCallbacks = 1250 };
 enum { k_iSteamNetworkingUtilsCallbacks = 1280 };
-enum { k_iClientRemoteStorageCallbacks = 1300 };
+enum { k_iSteamRemoteStorageCallbacks = 1300 };
 enum { k_iClientDepotBuilderCallbacks = 1400 };
 enum { k_iSteamGameServerItemsCallbacks = 1500 };
 enum { k_iClientUtilsCallbacks = 1600 };
@@ -78,6 +79,7 @@ enum { k_iClientNetworkDeviceManagerCallbacks = 3100 };
 enum { k_iClientMusicCallbacks = 3200 };
 enum { k_iClientRemoteClientManagerCallbacks = 3300 };
 enum { k_iClientUGCCallbacks = 3400 };
+enum { k_iSteamUGCCallbacks = 3400 };
 enum { k_iSteamStreamClientCallbacks = 3500 };
 enum { k_IClientProductBuilderCallbacks = 3600 };
 enum { k_iClientShortcutsCallbacks = 3700 };
@@ -453,27 +455,37 @@ u64  SteamGameServer_GetSteamID(void);
  * Async callbacks
  * =============================================================================
  */
-typedef struct steam_async steam_async;
-struct steam_async
-{
-   SteamAPICall_t id;
-   void *data;
 
-   void (*p_handler)( void *result, void *userdata );
+typedef struct vg_steam_async_call vg_steam_async_call;
+typedef struct vg_steam_callback_handler vg_steam_callback_handler;
+
+struct vg_steam{
+   struct vg_steam_async_call{
+      SteamAPICall_t id;
+      void *userdata;
+
+      void (*p_handler)( void *result, void *userdata );
+   }
+   calls[4];
+   u32 call_count;
+
+   struct vg_steam_callback_handler{
+      u32 callback_id;
+      void (*p_handler)( CallbackMsg_t *msg );
+   }
+   callback_handlers[32];
+   u32 callback_handler_count;
 }
-static steam_async_trackers[32];
-static u32 steam_async_track_count;
+static vg_steam;
 
-steam_async *steam_new_async(void)
+vg_steam_async_call *vg_alloc_async_steam_api_call(void)
 {
-   if( steam_async_track_count == vg_list_size(steam_async_trackers) )
-   {
-      vg_error( "Maximum concurrent API calls exceeded (%u)\n",
-                steam_async_track_count );
-      return NULL;
+   if( vg_steam.call_count == vg_list_size(vg_steam.calls) ){
+      vg_fatal_error( "Maximum concurrent API calls exceeded (%u)\n",
+                      vg_steam.call_count );
    }
 
-   return &steam_async_trackers[ steam_async_track_count ++ ];
+   return &vg_steam.calls[ vg_steam.call_count ++ ];
 }
 
 /*
@@ -481,33 +493,21 @@ steam_async *steam_new_async(void)
  * =============================================================================
  */
 
-typedef struct steam_callback_handler steam_callback_handler;
-struct steam_callback_handler
-{
-   u32 callback_id;
-   void (*p_handler)( CallbackMsg_t *msg );
-}
-static steam_callback_handlers[64];
-static u32 steam_callback_handler_count;
-
-static int steam_register_callback( u32 id, 
-                                    void (*p_handler)( CallbackMsg_t *msg ) )
+static void steam_register_callback( u32 id, 
+                                     void (*p_handler)( CallbackMsg_t *msg ) )
 {
-   if( steam_callback_handler_count == vg_list_size(steam_callback_handlers) )
+   if( vg_steam.callback_handler_count == 
+       vg_list_size(vg_steam.callback_handlers) )
    {
-      vg_error( "Too many steam callback handlers registered (%u)\n", 
-                  steam_callback_handler_count );
-
-      return 0;
+      vg_fatal_error( "Too many steam callback handlers registered (%u)\n", 
+                      vg_steam.callback_handler_count );
    }
    
-   steam_callback_handler *handler = &steam_callback_handlers[
-      steam_callback_handler_count ++ ];
+   vg_steam_callback_handler *handler = 
+      &vg_steam.callback_handlers[ vg_steam.callback_handler_count ++ ];
 
    handler->p_handler = p_handler;
    handler->callback_id = id;
-   
-   return 1;
 }
 
 /*
@@ -535,13 +535,12 @@ static void steamworks_process_api_call( HSteamPipe pipe,
       (SteamAPICallCompleted_t *)callback->m_pubParam;
 
    int bFailed;
-
-   void *temp = alloca( pCallCompleted->m_cubParam );
+   void *call_data = alloca( pCallCompleted->m_cubParam );
    
    if( SteamAPI_ManualDispatch_GetAPICallResult( 
       pipe,
       pCallCompleted->m_hAsyncCall, 
-      temp,
+      call_data,
       pCallCompleted->m_cubParam, 
       pCallCompleted->m_iCallback, 
       &bFailed ) 
@@ -553,28 +552,24 @@ static void steamworks_process_api_call( HSteamPipe pipe,
        */
       
       vg_info( "steamworks_event::api_call_completed( %lu )\n", 
-            pCallCompleted->m_hAsyncCall );
+                  pCallCompleted->m_hAsyncCall );
       
       int j=0;
-      for( int i=0; i<steam_async_track_count; i++ )
-      {
-         if( steam_async_trackers[j].id != pCallCompleted->m_hAsyncCall )
-         {
-            steam_async_trackers[j ++] = steam_async_trackers[i];
+      for( int i=0; i<vg_steam.call_count; i++ ){
+         if( vg_steam.calls[i].id != pCallCompleted->m_hAsyncCall ){
+            vg_steam.calls[j ++] = vg_steam.calls[i];
          }
-         else
-         {
-            steam_async *pasync = &steam_async_trackers[j];
-            pasync->p_handler( temp, pasync->data );
+         else{
+            vg_steam_async_call *call = &vg_steam.calls[i];
+            call->p_handler( call_data, call->userdata );
          }
       }
 
-      if( steam_async_track_count == j )
-      {
+      if( vg_steam.call_count == j ){
          vg_error( "No tracker was register for API call\n" );
       }
 
-      steam_async_track_count = j;
+      vg_steam.call_count = j;
    } 
    else 
    { 
@@ -605,28 +600,23 @@ static void steamworks_event_loop( HSteamPipe pipe )
        SteamAPI_ManualDispatch_RunFrame( pipe );
        CallbackMsg_t callback;
        
-       while( SteamAPI_ManualDispatch_GetNextCallback( pipe, &callback ) )
-       {
+       while( SteamAPI_ManualDispatch_GetNextCallback( pipe, &callback ) ){
                vg_low( "steamworks_event::callback( %i )\n", callback.m_iCallback );
        
                /* Check for dispatching API call results */
-               if( callback.m_iCallback == k_iSteamAPICallCompleted )
-      {
+               if( callback.m_iCallback == k_iSteamAPICallCompleted ){
          steamworks_process_api_call( pipe, &callback );
                } 
-               else 
-               {
+               else {
                        /* 
           * Look at callback.m_iCallback to see what kind of callback it is,
                         * and dispatch to appropriate handler(s)
                         * void *data = callback.m_pubParam;
           */
 
-         for( int i=0; i<steam_callback_handler_count; i++ )
-         {
-            steam_callback_handler *handler = &steam_callback_handlers[i];
-            if( handler->callback_id == callback.m_iCallback )
-            {
+         for( int i=0; i<vg_steam.callback_handler_count; i++ ){
+            vg_steam_callback_handler *handler = &vg_steam.callback_handlers[i];
+            if( handler->callback_id == callback.m_iCallback ){
                handler->p_handler( &callback );
                break;
             }