mpo/VVVVVV
1
0
Fork 0
mirror of https://github.com/TerryCavanagh/VVVVVV.git synced 2024-11-05 10:49:41 +01:00
Code Issues Releases Wiki Activity
VVVVVV/desktop_version/src/SteamNetwork.c

270 lines
6.9 KiB
C
Raw Normal View History

Ifdef out network code for M&P M&P contains network code despite M&P not being a Steam/GOG release (as Steam/GOG releases are full releases of the game, not custom-levels-only releases). While unlocking achievements is already ifdef'd out in M&P, let's remove the network code entirely to make sure people can't do other shenanigans with M&P builds, and also to have a smaller binary size.
2020-08-03 05:35:00 +02:00
#include "MakeAndPlay.h"
#ifndef MAKEANDPLAY
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
#include <stdint.h>
#include <SDL.h>
Hook Steam screenshots and send internal capture Using the Steamworks API, we can hook the screenshot function and listen for a screenshot request callback to send in our own screenshot. This applies the screenshot improvements to Steam screenshots as well. Doing this requires adding some C wrapper functions, as our interface with the Steam API is only conducted through C.
2024-01-09 20:30:17 +01:00
#include "CWrappers.h"
Replace all print calls with vlog calls This is pretty straight-forward to do.
2021-02-24 00:21:29 +01:00
#include "Vlogging.h"
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
/* Steamworks interface versions */
#define VVVVVV_STEAMCLIENT "SteamClient017"
#define VVVVVV_STEAMUSERSTATS "STEAMUSERSTATS_INTERFACE_VERSION011"
Hook Steam screenshots and send internal capture Using the Steamworks API, we can hook the screenshot function and listen for a screenshot request callback to send in our own screenshot. This applies the screenshot improvements to Steam screenshots as well. Doing this requires adding some C wrapper functions, as our interface with the Steam API is only conducted through C.
2024-01-09 20:30:17 +01:00
#define VVVVVV_STEAMSCREENSHOTS "STEAMSCREENSHOTS_INTERFACE_VERSION003"
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
/* Shared object file name */
#if defined(_WIN32)
Add support for multiple Network backends, stub in GOGNetwork
2020-01-13 17:15:17 +01:00
#define STEAM_LIBRARY "steam_api.dll"
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
#elif defined(__APPLE__)
Add support for multiple Network backends, stub in GOGNetwork
2020-01-13 17:15:17 +01:00
#define STEAM_LIBRARY "libsteam_api.dylib"
Fix build on DragonFlyBSD
2020-04-20 15:41:11 +02:00
#elif defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__HAIKU__) || defined(__DragonFly__)
Add support for multiple Network backends, stub in GOGNetwork
2020-01-13 17:15:17 +01:00
#define STEAM_LIBRARY "libsteam_api.so"
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
#else
Add support for multiple Network backends, stub in GOGNetwork
2020-01-13 17:15:17 +01:00
#error STEAM_LIBRARY: Unrecognized platform!
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
#endif
/* DLL, Entry Points */
Use stub types instead of `intptr_t` This is so there are at least compiler warnings raised if one of the pointers mismatch their types.
2021-09-18 06:11:25 +02:00
struct ISteamClient;
struct ISteamUserStats;
Hook Steam screenshots and send internal capture Using the Steamworks API, we can hook the screenshot function and listen for a screenshot request callback to send in our own screenshot. This applies the screenshot improvements to Steam screenshots as well. Doing this requires adding some C wrapper functions, as our interface with the Steam API is only conducted through C.
2024-01-09 20:30:17 +01:00
struct ISteamScreenshots;
struct CallbackMsg_t
{
int32_t m_hSteamUser;
int32_t m_iCallback;
uint8_t* m_pubParam;
int32_t m_cubParam;
};
struct SteamAPICallCompleted_t
{
uint64_t m_hAsyncCall;
int32_t m_iCallback;
uint32_t m_cubParam;
};
Use stub types instead of `intptr_t` This is so there are at least compiler warnings raised if one of the pointers mismatch their types.
2021-09-18 06:11:25 +02:00
De-duplicate Steam network function list Instead of having three separate copies of the function list, use macro magic to make it so there is only one list that we use in three different cases.
2021-09-17 22:53:52 +02:00
#define FUNC_LIST \
FOREACH_FUNC(uint8_t, SteamAPI_Init, (void)) \
FOREACH_FUNC(void, SteamAPI_Shutdown, (void)) \
FOREACH_FUNC(void, SteamAPI_RunCallbacks, (void)) \
Use stub types instead of `intptr_t` This is so there are at least compiler warnings raised if one of the pointers mismatch their types.
2021-09-18 06:11:25 +02:00
FOREACH_FUNC(struct ISteamClient*, SteamInternal_CreateInterface, (const char*)) \
De-duplicate Steam network function list Instead of having three separate copies of the function list, use macro magic to make it so there is only one list that we use in three different cases.
2021-09-17 22:53:52 +02:00
FOREACH_FUNC(int32_t, SteamAPI_GetHSteamUser, (void)) \
FOREACH_FUNC(int32_t, SteamAPI_GetHSteamPipe, (void)) \
Use stub types instead of `intptr_t` This is so there are at least compiler warnings raised if one of the pointers mismatch their types.
2021-09-18 06:11:25 +02:00
FOREACH_FUNC(struct ISteamUserStats*, SteamAPI_ISteamClient_GetISteamUserStats, ( \
struct ISteamClient*, \
De-duplicate Steam network function list Instead of having three separate copies of the function list, use macro magic to make it so there is only one list that we use in three different cases.
2021-09-17 22:53:52 +02:00
int32_t, \
int32_t, \
const char* \
)) \
Use stub types instead of `intptr_t` This is so there are at least compiler warnings raised if one of the pointers mismatch their types.
2021-09-18 06:11:25 +02:00
FOREACH_FUNC(uint8_t, SteamAPI_ISteamUserStats_RequestCurrentStats, (struct ISteamUserStats*)) \
FOREACH_FUNC(uint8_t, SteamAPI_ISteamUserStats_StoreStats, (struct ISteamUserStats*)) \
De-duplicate Steam network function list Instead of having three separate copies of the function list, use macro magic to make it so there is only one list that we use in three different cases.
2021-09-17 22:53:52 +02:00
FOREACH_FUNC(uint8_t, SteamAPI_ISteamUserStats_SetAchievement, ( \
Use stub types instead of `intptr_t` This is so there are at least compiler warnings raised if one of the pointers mismatch their types.
2021-09-18 06:11:25 +02:00
struct ISteamUserStats*, \
De-duplicate Steam network function list Instead of having three separate copies of the function list, use macro magic to make it so there is only one list that we use in three different cases.
2021-09-17 22:53:52 +02:00
const char* \
Hook Steam screenshots and send internal capture Using the Steamworks API, we can hook the screenshot function and listen for a screenshot request callback to send in our own screenshot. This applies the screenshot improvements to Steam screenshots as well. Doing this requires adding some C wrapper functions, as our interface with the Steam API is only conducted through C.
2024-01-09 20:30:17 +01:00
)) \
FOREACH_FUNC(struct ISteamScreenshots*, SteamAPI_ISteamClient_GetISteamScreenshots, ( \
struct ISteamClient*, \
int32_t, \
int32_t, \
const char* \
)) \
FOREACH_FUNC(void, SteamAPI_ISteamScreenshots_HookScreenshots, (\
struct ISteamScreenshots*, \
uint8_t \
)) \
FOREACH_FUNC(uint32_t, SteamAPI_ISteamScreenshots_WriteScreenshot, ( \
struct ISteamScreenshots*, \
void*, \
uint32_t, \
int32_t, \
int32_t \
)) \
FOREACH_FUNC(void, SteamAPI_ManualDispatch_Init, (void)) \
FOREACH_FUNC(void, SteamAPI_ManualDispatch_RunFrame, (int32_t)) \
FOREACH_FUNC(uint8_t, SteamAPI_ManualDispatch_GetNextCallback, (int32_t, struct CallbackMsg_t*)) \
FOREACH_FUNC(void, SteamAPI_ManualDispatch_FreeLastCallback, (int32_t)) \
FOREACH_FUNC(uint8_t, SteamAPI_ManualDispatch_GetAPICallResult, ( \
int32_t, \
uint64_t, \
void*, \
int32_t, \
int32_t, \
uint8_t* \
De-duplicate Steam network function list Instead of having three separate copies of the function list, use macro magic to make it so there is only one list that we use in three different cases.
2021-09-17 22:53:52 +02:00
))
Hook Steam screenshots and send internal capture Using the Steamworks API, we can hook the screenshot function and listen for a screenshot request callback to send in our own screenshot. This applies the screenshot improvements to Steam screenshots as well. Doing this requires adding some C wrapper functions, as our interface with the Steam API is only conducted through C.
2024-01-09 20:30:17 +01:00
#define iScreenshotRequested 2302
static void* libHandle = NULL;
static struct ISteamUserStats* steamUserStats = NULL;
static struct ISteamScreenshots* steamScreenshots = NULL;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
Name the return types `rettype` instead of `retval` Minor code style fix. They are return types, not return values.
2021-09-17 22:58:44 +02:00
#define FOREACH_FUNC(rettype, name, params) static rettype (*name) params = NULL;
De-duplicate Steam network function list Instead of having three separate copies of the function list, use macro magic to make it so there is only one list that we use in three different cases.
2021-09-17 22:53:52 +02:00
FUNC_LIST
#undef FOREACH_FUNC
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
/* Clean up after ourselves... */
Explicitly declare void for all void parameter functions (#628) Apparently in C, if you have `void test();`, it's completely okay to do `test(2);`. The function will take in the argument, but just discard it and throw it away. It's like a trash can, and a rude one at that. If you declare it like `void test(void);`, this is prevented. This is not a problem in C++ - doing `void test();` and `test(2);` is guaranteed to result in a compile error (this also means that right now, at least in all `.cpp` files, nobody is ever calling a void parameter function with arguments and having their arguments be thrown away). However, we may not be using C++ in the future, so I just want to lay down the precedent that if a function takes in no arguments, you must explicitly declare it as such. I would've added `-Wstrict-prototypes`, but it produces an annoying warning message saying it doesn't work in C++ mode if you're compiling in C++ mode. So it can be added later.
2021-02-25 23:23:59 +01:00
static void ClearPointers(void)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
SDL_UnloadObject(libHandle);
libHandle = NULL;
Use stub types instead of `intptr_t` This is so there are at least compiler warnings raised if one of the pointers mismatch their types.
2021-09-18 06:11:25 +02:00
steamUserStats = NULL;
Name the return types `rettype` instead of `retval` Minor code style fix. They are return types, not return values.
2021-09-17 22:58:44 +02:00
#define FOREACH_FUNC(rettype, name, params) name = NULL;
De-duplicate Steam network function list Instead of having three separate copies of the function list, use macro magic to make it so there is only one list that we use in three different cases.
2021-09-17 22:53:52 +02:00
FUNC_LIST
#undef FOREACH_FUNC
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Hook Steam screenshots and send internal capture Using the Steamworks API, we can hook the screenshot function and listen for a screenshot request callback to send in our own screenshot. This applies the screenshot improvements to Steam screenshots as well. Doing this requires adding some C wrapper functions, as our interface with the Steam API is only conducted through C.
2024-01-09 20:30:17 +01:00
static void run_screenshot()
{
if (!libHandle)
{
return;
}
vlog_info("taking a screenshot");
SDL_Surface* surface = GRAPHICS_tempScreenshot();
uint8_t success = UTIL_TakeScreenshot(&surface);
if (!success)
{
return;
}
Upscale screenshots 2x The plan is to have Steam screenshots always be 2x, but in the VVVVVV screenshots directory (for F6 keybind) save both 1x and 2x. Again, just for now, the 2x screenshot is being saved to a temporary location for testing and will get proper timestamps later.
2024-01-08 02:56:26 +01:00
SDL_Surface* surface2x = GRAPHICS_tempScreenshot2x();
success = UTIL_UpscaleScreenshot2x(surface, &surface2x);
if (!success)
{
return;
}
Hook Steam screenshots and send internal capture Using the Steamworks API, we can hook the screenshot function and listen for a screenshot request callback to send in our own screenshot. This applies the screenshot improvements to Steam screenshots as well. Doing this requires adding some C wrapper functions, as our interface with the Steam API is only conducted through C.
2024-01-09 20:30:17 +01:00
SteamAPI_ISteamScreenshots_WriteScreenshot(
steamScreenshots,
Upscale screenshots 2x The plan is to have Steam screenshots always be 2x, but in the VVVVVV screenshots directory (for F6 keybind) save both 1x and 2x. Again, just for now, the 2x screenshot is being saved to a temporary location for testing and will get proper timestamps later.
2024-01-08 02:56:26 +01:00
surface2x->pixels,
surface2x->w * surface2x->h * surface2x->format->BytesPerPixel,
surface2x->w,
surface2x->h
Hook Steam screenshots and send internal capture Using the Steamworks API, we can hook the screenshot function and listen for a screenshot request callback to send in our own screenshot. This applies the screenshot improvements to Steam screenshots as well. Doing this requires adding some C wrapper functions, as our interface with the Steam API is only conducted through C.
2024-01-09 20:30:17 +01:00
);
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
/* NETWORK API Implementation */
Hook Steam screenshots and send internal capture Using the Steamworks API, we can hook the screenshot function and listen for a screenshot request callback to send in our own screenshot. This applies the screenshot improvements to Steam screenshots as well. Doing this requires adding some C wrapper functions, as our interface with the Steam API is only conducted through C.
2024-01-09 20:30:17 +01:00
static int32_t steamPipe = 0;
Explicitly declare void for all void parameter functions (#628) Apparently in C, if you have `void test();`, it's completely okay to do `test(2);`. The function will take in the argument, but just discard it and throw it away. It's like a trash can, and a rude one at that. If you declare it like `void test(void);`, this is prevented. This is not a problem in C++ - doing `void test();` and `test(2);` is guaranteed to result in a compile error (this also means that right now, at least in all `.cpp` files, nobody is ever calling a void parameter function with arguments and having their arguments be thrown away). However, we may not be using C++ in the future, so I just want to lay down the precedent that if a function takes in no arguments, you must explicitly declare it as such. I would've added `-Wstrict-prototypes`, but it produces an annoying warning message saying it doesn't work in C++ mode if you're compiling in C++ mode. So it can be added later.
2021-02-25 23:23:59 +01:00
int32_t STEAM_init(void)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Fix build on DragonFlyBSD
2020-04-20 15:41:11 +02:00
#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__HAIKU__) || defined(__DragonFly__)
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
return 0;
FreeBSD: Add workaround for libsteam Steam isn't supported on FreeBSD so add a workaround. Signed-off-by: Emmanuel Vadot <manu@freebsd.org>
2020-01-10 22:38:33 +01:00
#endif
Use stub types instead of `intptr_t` This is so there are at least compiler warnings raised if one of the pointers mismatch their types.
2021-09-18 06:11:25 +02:00
struct ISteamClient *steamClient;
Hook Steam screenshots and send internal capture Using the Steamworks API, we can hook the screenshot function and listen for a screenshot request callback to send in our own screenshot. This applies the screenshot improvements to Steam screenshots as well. Doing this requires adding some C wrapper functions, as our interface with the Steam API is only conducted through C.
2024-01-09 20:30:17 +01:00
int32_t steamUser;
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
libHandle = SDL_LoadObject(STEAM_LIBRARY);
if (!libHandle)
{
Don't use print formatting for hardcoded strings If the string is hardcoded, then use compile-time string literal concatenation instead. I don't know if compilers are smart enough to recognize when you're passing in hardcoded strings and to concatenate them into the string literal at compile time instead. I also don't know that if compilers are smart enough to recognize that, that further they recognize all the logging functions are just wrappers around printf, and so they can perform the same optimization at those function call sites, too. So it's better to just do the string concatenation explicitly instead.
2021-09-17 23:05:23 +02:00
vlog_info(STEAM_LIBRARY " not found!");
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
return 0;
}
Name the return types `rettype` instead of `retval` Minor code style fix. They are return types, not return values.
2021-09-17 22:58:44 +02:00
#define FOREACH_FUNC(rettype, name, params) \
Silence GCC warnings about `void*`-to-function-pointer casts GCC warns on casting `void*` to function pointers. This is because the C standard makes a clear distinction between pointers to objects (`void*`) and pointers to functions (function pointers), and does not specify anything related to being able to cast object pointers to function pointers. The warning message is factually wrong, though - it states that it is forbidden by ISO C, when in fact it is not, and is actually just unspecified. We can't get rid of the cast entirely, because we need the explicit cast (the C standard _does_ mandate you need an explicit cast when converting between object pointers and function pointers), and at the end of the day, this is simply how `SDL_LoadFunction()` works (and more importantly, how `dlsym()` works), so we can't get rid of it, and we have no reason to anyways since it means we don't have a hard runtime dependency on Steam (unlike some other games) and casting `void*` to function pointers always behaves well on every single platform we ship on that supports Steam. Unfortunately, this warning seems to be a part of -Wpedantic, and there's no way to disable this warning specifically without disabling -Wpedantic. Luckily, I've found a workaround - just cast to `intptr_t` before casting to the function pointer. Hopefully the compiler doesn't get smarter in the future and this ends up breaking or anything...
2021-10-21 10:00:06 +02:00
name = (rettype (*) params) (intptr_t) SDL_LoadFunction(libHandle, #name); \
De-duplicate Steam network function list Instead of having three separate copies of the function list, use macro magic to make it so there is only one list that we use in three different cases.
2021-09-17 22:53:52 +02:00
if (!name) \
{ \
Don't use print formatting for hardcoded strings If the string is hardcoded, then use compile-time string literal concatenation instead. I don't know if compilers are smart enough to recognize when you're passing in hardcoded strings and to concatenate them into the string literal at compile time instead. I also don't know that if compilers are smart enough to recognize that, that further they recognize all the logging functions are just wrappers around printf, and so they can perform the same optimization at those function call sites, too. So it's better to just do the string concatenation explicitly instead.
2021-09-17 23:05:23 +02:00
vlog_error(STEAM_LIBRARY " symbol " #name " not found!"); \
De-duplicate Steam network function list Instead of having three separate copies of the function list, use macro magic to make it so there is only one list that we use in three different cases.
2021-09-17 22:53:52 +02:00
ClearPointers(); \
return 0; \
}
FUNC_LIST
#undef FOREACH_FUNC
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
if (!SteamAPI_Init())
{
vlog_error("Steamworks not initialized!");
ClearPointers();
return 0;
}
Hook Steam screenshots and send internal capture Using the Steamworks API, we can hook the screenshot function and listen for a screenshot request callback to send in our own screenshot. This applies the screenshot improvements to Steam screenshots as well. Doing this requires adding some C wrapper functions, as our interface with the Steam API is only conducted through C.
2024-01-09 20:30:17 +01:00
SteamAPI_ManualDispatch_Init();
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
steamClient = SteamInternal_CreateInterface(VVVVVV_STEAMCLIENT);
steamUser = SteamAPI_GetHSteamUser();
steamPipe = SteamAPI_GetHSteamPipe();
if (!steamClient || !steamUser || !steamPipe)
{
SteamAPI_Shutdown();
vlog_error(VVVVVV_STEAMCLIENT " not created!");
ClearPointers();
return 0;
}
steamUserStats = SteamAPI_ISteamClient_GetISteamUserStats(
steamClient,
steamUser,
steamPipe,
VVVVVV_STEAMUSERSTATS
);
if (!steamUserStats)
{
SteamAPI_Shutdown();
vlog_error(VVVVVV_STEAMUSERSTATS " not created!");
ClearPointers();
return 0;
}
SteamAPI_ISteamUserStats_RequestCurrentStats(steamUserStats);
Hook Steam screenshots and send internal capture Using the Steamworks API, we can hook the screenshot function and listen for a screenshot request callback to send in our own screenshot. This applies the screenshot improvements to Steam screenshots as well. Doing this requires adding some C wrapper functions, as our interface with the Steam API is only conducted through C.
2024-01-09 20:30:17 +01:00
steamScreenshots = SteamAPI_ISteamClient_GetISteamScreenshots(
steamClient,
steamUser,
steamPipe,
VVVVVV_STEAMSCREENSHOTS
);
if (!steamScreenshots)
{
SteamAPI_Shutdown();
vlog_error(VVVVVV_STEAMSCREENSHOTS " not created!");
ClearPointers();
return 0;
}
SteamAPI_ISteamScreenshots_HookScreenshots(steamScreenshots, 1);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
return 1;
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Explicitly declare void for all void parameter functions (#628) Apparently in C, if you have `void test();`, it's completely okay to do `test(2);`. The function will take in the argument, but just discard it and throw it away. It's like a trash can, and a rude one at that. If you declare it like `void test(void);`, this is prevented. This is not a problem in C++ - doing `void test();` and `test(2);` is guaranteed to result in a compile error (this also means that right now, at least in all `.cpp` files, nobody is ever calling a void parameter function with arguments and having their arguments be thrown away). However, we may not be using C++ in the future, so I just want to lay down the precedent that if a function takes in no arguments, you must explicitly declare it as such. I would've added `-Wstrict-prototypes`, but it produces an annoying warning message saying it doesn't work in C++ mode if you're compiling in C++ mode. So it can be added later.
2021-02-25 23:23:59 +01:00
void STEAM_shutdown(void)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
if (libHandle)
{
SteamAPI_Shutdown();
ClearPointers();
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Explicitly declare void for all void parameter functions (#628) Apparently in C, if you have `void test();`, it's completely okay to do `test(2);`. The function will take in the argument, but just discard it and throw it away. It's like a trash can, and a rude one at that. If you declare it like `void test(void);`, this is prevented. This is not a problem in C++ - doing `void test();` and `test(2);` is guaranteed to result in a compile error (this also means that right now, at least in all `.cpp` files, nobody is ever calling a void parameter function with arguments and having their arguments be thrown away). However, we may not be using C++ in the future, so I just want to lay down the precedent that if a function takes in no arguments, you must explicitly declare it as such. I would've added `-Wstrict-prototypes`, but it produces an annoying warning message saying it doesn't work in C++ mode if you're compiling in C++ mode. So it can be added later.
2021-02-25 23:23:59 +01:00
void STEAM_update(void)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Hook Steam screenshots and send internal capture Using the Steamworks API, we can hook the screenshot function and listen for a screenshot request callback to send in our own screenshot. This applies the screenshot improvements to Steam screenshots as well. Doing this requires adding some C wrapper functions, as our interface with the Steam API is only conducted through C.
2024-01-09 20:30:17 +01:00
if (!libHandle)
{
return;
}
SteamAPI_ManualDispatch_RunFrame(steamPipe);
struct CallbackMsg_t callback;
SDL_zero(callback);
while (SteamAPI_ManualDispatch_GetNextCallback(steamPipe, &callback))
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
{
Hook Steam screenshots and send internal capture Using the Steamworks API, we can hook the screenshot function and listen for a screenshot request callback to send in our own screenshot. This applies the screenshot improvements to Steam screenshots as well. Doing this requires adding some C wrapper functions, as our interface with the Steam API is only conducted through C.
2024-01-09 20:30:17 +01:00
if (callback.m_iCallback == iScreenshotRequested)
{
run_screenshot();
}
SteamAPI_ManualDispatch_FreeLastCallback(steamPipe);
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Add support for multiple Network backends, stub in GOGNetwork
2020-01-13 17:15:17 +01:00
void STEAM_unlockAchievement(const char *name)
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
{
Untabify every single file YOLO. This is a repeat of #642. As before, I just did rg -l '\t' | xargs -n 1 sed -i -e 's/\t/ /g' inside the desktop_version/ folder.
2021-09-07 03:56:39 +02:00
if (libHandle)
{
SteamAPI_ISteamUserStats_SetAchievement(
steamUserStats,
name
);
SteamAPI_ISteamUserStats_StoreStats(steamUserStats);
}
Hello WWWWWWorld!
2020-01-01 21:29:24 +01:00
}
Ifdef out network code for M&P M&P contains network code despite M&P not being a Steam/GOG release (as Steam/GOG releases are full releases of the game, not custom-levels-only releases). While unlocking achievements is already ifdef'd out in M&P, let's remove the network code entirely to make sure people can't do other shenanigans with M&P builds, and also to have a smaller binary size.
2020-08-03 05:35:00 +02:00
#endif /* MAKEANDPLAY */
Reference in a new issue Copy permalink