build system revision

[vg.git] / vg_steam.c

diff --git a/vg_steam.c b/vg_steam.c
new file mode 100644 (file)
index 0000000..a021cb1
--- /dev/null
+++ b/vg_steam.c
@@ -0,0 +1,136 @@
+#include "vg_steam.h"
+#include "vg_log.h"
+#include <stdio.h>
+
+struct vg_steam vg_steam;
+
+vg_steam_async_call *vg_alloc_async_steam_api_call(void)
+{
+   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 &vg_steam.calls[ vg_steam.call_count ++ ];
+}
+
+void steam_register_callback( u32 id, void (*p_handler)( CallbackMsg_t *msg ) )
+{
+   if( vg_steam.callback_handler_count == 
+       vg_list_size(vg_steam.callback_handlers) )
+   {
+      vg_fatal_error( "Too many steam callback handlers registered (%u)\n", 
+                      vg_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;
+}
+
+void steamworks_process_api_call( HSteamPipe pipe, CallbackMsg_t *callback )
+{
+   SteamAPICallCompleted_t *pCallCompleted = 
+      (SteamAPICallCompleted_t *)callback->m_pubParam;
+
+   steamapi_bool bFailed;
+   void *call_data = alloca( pCallCompleted->m_cubParam );
+   
+   if( SteamAPI_ManualDispatch_GetAPICallResult( 
+      pipe,
+      pCallCompleted->m_hAsyncCall, 
+      call_data,
+      pCallCompleted->m_cubParam, 
+      pCallCompleted->m_iCallback, 
+      &bFailed ) 
+   )
+   {
+      /* 
+       * Dispatch the call result to the registered handler(s) for the
+       * call identified by pCallCompleted->m_hAsyncCall 
+       */
+      
+      vg_info( "steamworks_event::api_call_completed( %lu )\n", 
+                  pCallCompleted->m_hAsyncCall );
+      
+      int j=0;
+      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{
+            vg_steam_async_call *call = &vg_steam.calls[i];
+            call->p_handler( call_data, call->userdata );
+         }
+      }
+
+      if( vg_steam.call_count == j ){
+         vg_error( "No tracker was register for API call\n" );
+      }
+
+      vg_steam.call_count = j;
+   } 
+   else 
+   { 
+#if 0
+      typedef enum ESteamAPICallFailure
+      {
+         k_ESteamAPICallFailureNone = -1,
+         k_ESteamAPICallFailureSteamGone = 0, 
+         k_ESteamAPICallFailureNetworkFailure = 1,   
+         k_ESteamAPICallFailureInvalidHandle = 2,
+         k_ESteamAPICallFailureMismatchedCallback = 3,
+      } 
+
+      ESteamAPICallFailure;
+      ESteamAPICallFailure fail_why = 
+      SteamAPI_ISteamUtils_GetAPICallFailureReason( 
+            steam_api_classes.utils, pCallCompleted->m_hAsyncCall );
+   
+      vg_error( "steamworks_event: error getting call result on"
+                "%lu (code %d)\n", 
+                pCallCompleted->m_hAsyncCall, fail_why );
+#endif
+   }
+}
+
+void steamworks_event_loop( HSteamPipe pipe )
+{
+   SteamAPI_ManualDispatch_RunFrame( pipe );
+   CallbackMsg_t 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 ){
+         steamworks_process_api_call( pipe, &callback );
+      } 
+      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<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;
+            }
+         }
+      }
+      
+      SteamAPI_ManualDispatch_FreeLastCallback( pipe );
+   }
+}
+
+void steamworks_ensure_txt( const char *appid_str )
+{
+   FILE *txt = fopen("steam_appid.txt", "w");
+   fputs( appid_str, txt );
+   fclose( txt );
+}