vg_steam.c

   1 #include "vg_steam.h"
   2 #include "vg_log.h"
   3 #include <stdio.h>
   4
   5 struct vg_steam vg_steam;
   6
   7 vg_steam_async_call *vg_alloc_async_steam_api_call(void)
   8 {
   9    if( vg_steam.call_count == vg_list_size(vg_steam.calls) ){
  10       vg_fatal_error( "Maximum concurrent API calls exceeded (%u)\n",
  11                       vg_steam.call_count );
  12    }
  13
  14    return &vg_steam.calls[ vg_steam.call_count ++ ];
  15 }
  16
  17 void steam_register_callback( u32 id, void (*p_handler)( CallbackMsg_t *msg ) )
  18 {
  19    if( vg_steam.callback_handler_count ==
  20        vg_list_size(vg_steam.callback_handlers) )
  21    {
  22       vg_fatal_error( "Too many steam callback handlers registered (%u)\n",
  23                       vg_steam.callback_handler_count );
  24    }
  25
  26    vg_steam_callback_handler *handler =
  27       &vg_steam.callback_handlers[ vg_steam.callback_handler_count ++ ];
  28
  29    handler->p_handler = p_handler;
  30    handler->callback_id = id;
  31 }
  32
  33 void steamworks_process_api_call( HSteamPipe pipe, CallbackMsg_t *callback )
  34 {
  35    SteamAPICallCompleted_t *pCallCompleted =
  36       (SteamAPICallCompleted_t *)callback->m_pubParam;
  37
  38    steamapi_bool bFailed;
  39    void *call_data = alloca( pCallCompleted->m_cubParam );
  40
  41    if( SteamAPI_ManualDispatch_GetAPICallResult(
  42       pipe,
  43       pCallCompleted->m_hAsyncCall,
  44       call_data,
  45       pCallCompleted->m_cubParam,
  46       pCallCompleted->m_iCallback,
  47       &bFailed )
  48    )
  49    {
  50       /*
  51        * Dispatch the call result to the registered handler(s) for the
  52        * call identified by pCallCompleted->m_hAsyncCall
  53        */
  54
  55       vg_info( "steamworks_event::api_call_completed( %lu )\n",
  56                   pCallCompleted->m_hAsyncCall );
  57
  58       int j=0;
  59       for( int i=0; i<vg_steam.call_count; i++ ){
  60          if( vg_steam.calls[i].id != pCallCompleted->m_hAsyncCall ){
  61             vg_steam.calls[j ++] = vg_steam.calls[i];
  62          }
  63          else{
  64             vg_steam_async_call *call = &vg_steam.calls[i];
  65             call->p_handler( call_data, call->userdata );
  66          }
  67       }
  68
  69       if( vg_steam.call_count == j ){
  70          vg_error( "No tracker was register for API call\n" );
  71       }
  72
  73       vg_steam.call_count = j;
  74    }
  75    else
  76    {
  77 #if 0
  78       typedef enum ESteamAPICallFailure
  79       {
  80          k_ESteamAPICallFailureNone = -1,
  81          k_ESteamAPICallFailureSteamGone = 0,
  82          k_ESteamAPICallFailureNetworkFailure = 1,
  83          k_ESteamAPICallFailureInvalidHandle = 2,
  84          k_ESteamAPICallFailureMismatchedCallback = 3,
  85       }
  86
  87       ESteamAPICallFailure;
  88       ESteamAPICallFailure fail_why =
  89       SteamAPI_ISteamUtils_GetAPICallFailureReason(
  90             steam_api_classes.utils, pCallCompleted->m_hAsyncCall );
  91
  92       vg_error( "steamworks_event: error getting call result on"
  93                 "%lu (code %d)\n",
  94                 pCallCompleted->m_hAsyncCall, fail_why );
  95 #endif
  96    }
  97 }
  98
  99 void steamworks_event_loop( HSteamPipe pipe )
 100 {
 101    SteamAPI_ManualDispatch_RunFrame( pipe );
 102    CallbackMsg_t callback;
 103
 104    while( SteamAPI_ManualDispatch_GetNextCallback( pipe, &callback ) ){
 105       vg_low( "steamworks_event::callback( %i )\n", callback.m_iCallback );
 106
 107       /* Check for dispatching API call results */
 108       if( callback.m_iCallback == k_iSteamAPICallCompleted ){
 109          steamworks_process_api_call( pipe, &callback );
 110       }
 111       else {
 112          /*
 113           * Look at callback.m_iCallback to see what kind of callback it is,
 114           * and dispatch to appropriate handler(s)
 115           * void *data = callback.m_pubParam;
 116           */
 117
 118          for( int i=0; i<vg_steam.callback_handler_count; i++ ){
 119             vg_steam_callback_handler *handler = &vg_steam.callback_handlers[i];
 120             if( handler->callback_id == callback.m_iCallback ){
 121                handler->p_handler( &callback );
 122                break;
 123             }
 124          }
 125       }
 126
 127       SteamAPI_ManualDispatch_FreeLastCallback( pipe );
 128    }
 129 }
 130
 131 void steamworks_ensure_txt( const char *appid_str )
 132 {
 133    FILE *txt = fopen("steam_appid.txt", "w");
 134    fputs( appid_str, txt );
 135    fclose( txt );
 136 }