Dynamically loading the Steamworks SDK

The game I’m currently working on uses the Steamworks SDK to integrate with the Steam client and do nice things such as achievements and cloud saves. I made my own custom engine for the game, and my initial approach for integrating the SDK was to simply link to the shared library and ship it as part of the game. The game itself is DRM-free, and this approach allowed it to work without the Steam client installed, by making sure that if SteamAPI_Init fails (e.g., because there is no Steam client) no other Steam function is called.

When the game was accepted to be published on GOG though, I knew I had to figure out a different approach. I had no intention of juggling multiple builds of the game for each storefront (times the number of supported platforms). Luckily there’s a way to avoid this: dynamic loading of the various SDKs! When the game is started, it checks if the shared library for each SDK was shipped with the build; as soon as one of them is found it is loaded, and the engine loads the functions we want as function pointers.

Caveats

One thing to note (and a potential drawback of this approach) is that dynamic loading only works for functions exported with C linkage, as C++ function names are mangled in a platform/compiler dependent way. In the specific case of the Steamworks API this means that you must use the flat API instead of the C++ one. This is not a problem for me, since I have to use the flat API anyway for other reasons¹.

It gets even more annoying with the GOG library since it only has C++ symbols, so you’re forced to first write an compile a C wrapper. Again, not a problem for me, since I would have had to do that anyway even if I just wanted to link to the library at compile time.

Implementation

Setting up dynamic loading is quite easy, especially if your engine is already using something like SDL that abstracts away the platform dependent dynamic loading. My approach is to create a class that wraps the SDK, and has the pointers to the API functions as members. When the class is initialised it attempts to dynamically load the library. It is allowed to fail, and the class can be tested to check if the library was loaded; this way, you can simply omit to bundle the shared library with the game to disable the Steam integration, instead of having to compile a different build of the game.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class Steam {
    public:
        Steam();
        ~Steam();

        // Test if SDK was found and loaded
        operator bool() const { return handle; }

        // Declare methods with the same signature as the SDK functions we need to
        // dynamicall load. Only declare the ones actually needed, add more as necessary

        decltype(SteamAPI_InitFlat)* InitFlat;
        decltype(SteamAPI_Shutdown)* Shutdown;

        decltype(SteamAPI_SteamUserStats)* SteamUserStats;
        decltype(SteamAPI_ISteamUserStats_SetAchievement)* ISteamUserStats_SetAchievement;
        decltype(SteamAPI_ISteamUserStats_StoreStats)* ISteamUserStats_StoreStats;
        decltype(SteamAPI_ISteamUserStats_RequestUserStats)* ISteamUserStats_RequestUserStats;
        decltype(SteamAPI_ISteamUserStats_ResetAllStats)* ISteamUserStats_ResetAllStats;

    private:
        void* handle = nullptr;
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

Steam::Steam() {
    // look for the shared library in the folder where the game executable is
    std::string soPath = SDL_GetBasePath();

    switch (os) {
        case Os::LINUX: soPath.append("libsteam_api.so"); break;
        case Os::MACOS: soPath.append("libsteam_api.dylib"); break;
        case Os::WINDOWS: soPath.append("steam_api64.dll"); break;
    }
    
    handle = SDL_LoadObject(soPath.c_str());
    if (!handle) return;

    InitFlat = reinterpret_cast<decltype(InitFlat)>(SDL_LoadFunction(handle, "SteamAPI_InitFlat"));
    Shutdown = reinterpret_cast<decltype(Shutdown)>(SDL_LoadFunction(handle, "SteamAPI_Shutdown"));

    SteamUserStats = reinterpret_cast<decltype(SteamUserStats)>(SDL_LoadFunction(handle, "SteamUserStats_v013"));
    ISteamUserStats_SetAchievement = reinterpret_cast<decltype(ISteamUserStats_SetAchievement)>(SDL_LoadFunction(handle, "SteamAPI_ISteamUserStats_SetAchievement"));
    ISteamUserStats_StoreStats = reinterpret_cast<decltype(ISteamUserStats_StoreStats)>(SDL_LoadFunction(handle, "SteamAPI_ISteamUserStats_StoreStats"));
    ISteamUserStats_RequestUserStats = reinterpret_cast<decltype(ISteamUserStats_RequestUserStats)>(SDL_LoadFunction(handle, "SteamAPI_ISteamUserStats_RequestUserStats"));
    ISteamUserStats_ResetAllStats = reinterpret_cast<decltype(ISteamUserStats_ResetAllStats)>(SDL_LoadFunction(handle, "SteamAPI_ISteamUserStats_ResetAllStats"));

}

Steam::~Steam() {
    if (handle) SDL_UnloadObject(handle);
}

Why not just link to all SDKs at compile time?

Sure, you could also do that. Link against the Steam SDK, the GOG SDK, and so on. But then you need to bundle unnecessary libraries with your game, and you still have the problem of letting the engine know which SDK it should be using. By dynamically loading, you tell the engine about it by only bundling the shared library you want, and there is only one build of the game (per platform) that you have to compile.

Abstracting the SDK behaviour

Of course you still have to deal with the fact that each SDK does things in a different way. My solution for this was to make a new SDK class that encapsulates the common methods (e.g., setting an achievement), and chooses what to do conditionally based on which shared library was loaded (or does nothing if no library was found).